OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [remote-sim.c] - Blame information for rev 227

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Generic remote debugging interface for simulators.
2
 
3
   Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4
   2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5
 
6
   Contributed by Cygnus Support.
7
   Steve Chamberlain (sac@cygnus.com).
8
 
9
   This file is part of GDB.
10
 
11
   This program is free software; you can redistribute it and/or modify
12
   it under the terms of the GNU General Public License as published by
13
   the Free Software Foundation; either version 3 of the License, or
14
   (at your option) any later version.
15
 
16
   This program is distributed in the hope that it will be useful,
17
   but WITHOUT ANY WARRANTY; without even the implied warranty of
18
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
   GNU General Public License for more details.
20
 
21
   You should have received a copy of the GNU General Public License
22
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
 
24
#include "defs.h"
25
#include "inferior.h"
26
#include "value.h"
27
#include "gdb_string.h"
28
#include <ctype.h>
29
#include <fcntl.h>
30
#include <signal.h>
31
#include <setjmp.h>
32
#include <errno.h>
33
#include "terminal.h"
34
#include "target.h"
35
#include "gdbcore.h"
36
#include "gdb/callback.h"
37
#include "gdb/remote-sim.h"
38
#include "command.h"
39
#include "regcache.h"
40
#include "gdb_assert.h"
41
#include "sim-regno.h"
42
#include "arch-utils.h"
43
#include "readline/readline.h"
44
#include "gdbthread.h"
45
 
46
/* Prototypes */
47
 
48
extern void _initialize_remote_sim (void);
49
 
50
static void dump_mem (char *buf, int len);
51
 
52
static void init_callbacks (void);
53
 
54
static void end_callbacks (void);
55
 
56
static int gdb_os_write_stdout (host_callback *, const char *, int);
57
 
58
static void gdb_os_flush_stdout (host_callback *);
59
 
60
static int gdb_os_write_stderr (host_callback *, const char *, int);
61
 
62
static void gdb_os_flush_stderr (host_callback *);
63
 
64
static int gdb_os_poll_quit (host_callback *);
65
 
66
/* printf_filtered is depreciated */
67
static void gdb_os_printf_filtered (host_callback *, const char *, ...);
68
 
69
static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
70
 
71
static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
72
 
73
static void gdb_os_error (host_callback *, const char *, ...) ATTR_NORETURN;
74
 
75
static void gdbsim_kill (struct target_ops *);
76
 
77
static void gdbsim_load (char *prog, int fromtty);
78
 
79
static void gdbsim_open (char *args, int from_tty);
80
 
81
static void gdbsim_close (int quitting);
82
 
83
static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty);
84
 
85
static void gdbsim_prepare_to_store (struct regcache *regcache);
86
 
87
static void gdbsim_files_info (struct target_ops *target);
88
 
89
static void gdbsim_mourn_inferior (struct target_ops *target);
90
 
91
static void gdbsim_stop (ptid_t ptid);
92
 
93
void simulator_command (char *args, int from_tty);
94
 
95
/* Naming convention:
96
 
97
   sim_* are the interface to the simulator (see remote-sim.h).
98
   gdbsim_* are stuff which is internal to gdb.  */
99
 
100
/* Forward data declarations */
101
extern struct target_ops gdbsim_ops;
102
 
103
static int program_loaded = 0;
104
 
105
/* We must keep track of whether the simulator has been opened or not because
106
   GDB can call a target's close routine twice, but sim_close doesn't allow
107
   this.  We also need to record the result of sim_open so we can pass it
108
   back to the other sim_foo routines.  */
109
static SIM_DESC gdbsim_desc = 0;
110
 
111
/* This is the ptid we use while we're connected to the simulator.
112
   Its value is arbitrary, as the simulator target don't have a notion
113
   or processes or threads, but we need something non-null to place in
114
   inferior_ptid.  */
115
static ptid_t remote_sim_ptid;
116
 
117
static void
118
dump_mem (char *buf, int len)
119
{
120
  if (len <= 8)
121
    {
122
      if (len == 8 || len == 4)
123
        {
124
          long l[2];
125
          memcpy (l, buf, len);
126
          printf_filtered ("\t0x%lx", l[0]);
127
          if (len == 8)
128
            printf_filtered (" 0x%lx", l[1]);
129
          printf_filtered ("\n");
130
        }
131
      else
132
        {
133
          int i;
134
          printf_filtered ("\t");
135
          for (i = 0; i < len; i++)
136
            printf_filtered ("0x%x ", buf[i]);
137
          printf_filtered ("\n");
138
        }
139
    }
140
}
141
 
142
static host_callback gdb_callback;
143
static int callbacks_initialized = 0;
144
 
145
/* Initialize gdb_callback.  */
146
 
147
static void
148
init_callbacks (void)
149
{
150
  if (!callbacks_initialized)
151
    {
152
      gdb_callback = default_callback;
153
      gdb_callback.init (&gdb_callback);
154
      gdb_callback.write_stdout = gdb_os_write_stdout;
155
      gdb_callback.flush_stdout = gdb_os_flush_stdout;
156
      gdb_callback.write_stderr = gdb_os_write_stderr;
157
      gdb_callback.flush_stderr = gdb_os_flush_stderr;
158
      gdb_callback.printf_filtered = gdb_os_printf_filtered;
159
      gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
160
      gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
161
      gdb_callback.error = gdb_os_error;
162
      gdb_callback.poll_quit = gdb_os_poll_quit;
163
      gdb_callback.magic = HOST_CALLBACK_MAGIC;
164
      callbacks_initialized = 1;
165
    }
166
}
167
 
168
/* Release callbacks (free resources used by them).  */
169
 
170
static void
171
end_callbacks (void)
172
{
173
  if (callbacks_initialized)
174
    {
175
      gdb_callback.shutdown (&gdb_callback);
176
      callbacks_initialized = 0;
177
    }
178
}
179
 
180
/* GDB version of os_write_stdout callback.  */
181
 
182
static int
183
gdb_os_write_stdout (host_callback *p, const char *buf, int len)
184
{
185
  int i;
186
  char b[2];
187
 
188
  ui_file_write (gdb_stdtarg, buf, len);
189
  return len;
190
}
191
 
192
/* GDB version of os_flush_stdout callback.  */
193
 
194
static void
195
gdb_os_flush_stdout (host_callback *p)
196
{
197
  gdb_flush (gdb_stdtarg);
198
}
199
 
200
/* GDB version of os_write_stderr callback.  */
201
 
202
static int
203
gdb_os_write_stderr (host_callback *p, const char *buf, int len)
204
{
205
  int i;
206
  char b[2];
207
 
208
  for (i = 0; i < len; i++)
209
    {
210
      b[0] = buf[i];
211
      b[1] = 0;
212
      fputs_unfiltered (b, gdb_stdtargerr);
213
    }
214
  return len;
215
}
216
 
217
/* GDB version of os_flush_stderr callback.  */
218
 
219
static void
220
gdb_os_flush_stderr (host_callback *p)
221
{
222
  gdb_flush (gdb_stdtargerr);
223
}
224
 
225
/* GDB version of printf_filtered callback.  */
226
 
227
static void
228
gdb_os_printf_filtered (host_callback * p, const char *format,...)
229
{
230
  va_list args;
231
  va_start (args, format);
232
 
233
  vfprintf_filtered (gdb_stdout, format, args);
234
 
235
  va_end (args);
236
}
237
 
238
/* GDB version of error vprintf_filtered.  */
239
 
240
static void
241
gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
242
{
243
  vfprintf_filtered (gdb_stdout, format, ap);
244
}
245
 
246
/* GDB version of error evprintf_filtered.  */
247
 
248
static void
249
gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
250
{
251
  vfprintf_filtered (gdb_stderr, format, ap);
252
}
253
 
254
/* GDB version of error callback.  */
255
 
256
static void
257
gdb_os_error (host_callback * p, const char *format, ...)
258
{
259
  va_list args;
260
  va_start (args, format);
261
  verror (format, args);
262
  va_end (args);
263
}
264
 
265
int
266
one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
267
{
268
  /* Only makes sense to supply raw registers.  */
269
  gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
270
  return regnum;
271
}
272
 
273
static void
274
gdbsim_fetch_register (struct target_ops *ops,
275
                       struct regcache *regcache, int regno)
276
{
277
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
278
  if (regno == -1)
279
    {
280
      for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
281
        gdbsim_fetch_register (ops, regcache, regno);
282
      return;
283
    }
284
 
285
  switch (gdbarch_register_sim_regno (gdbarch, regno))
286
    {
287
    case LEGACY_SIM_REGNO_IGNORE:
288
      break;
289
    case SIM_REGNO_DOES_NOT_EXIST:
290
      {
291
        /* For moment treat a `does not exist' register the same way
292
           as an ``unavailable'' register.  */
293
        char buf[MAX_REGISTER_SIZE];
294
        int nr_bytes;
295
        memset (buf, 0, MAX_REGISTER_SIZE);
296
        regcache_raw_supply (regcache, regno, buf);
297
        break;
298
      }
299
 
300
    default:
301
      {
302
        static int warn_user = 1;
303
        char buf[MAX_REGISTER_SIZE];
304
        int nr_bytes;
305
        gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
306
        memset (buf, 0, MAX_REGISTER_SIZE);
307
        nr_bytes = sim_fetch_register (gdbsim_desc,
308
                                       gdbarch_register_sim_regno
309
                                         (gdbarch, regno),
310
                                       buf,
311
                                       register_size (gdbarch, regno));
312
        if (nr_bytes > 0
313
            && nr_bytes != register_size (gdbarch, regno) && warn_user)
314
          {
315
            fprintf_unfiltered (gdb_stderr,
316
                                "Size of register %s (%d/%d) incorrect (%d instead of %d))",
317
                                gdbarch_register_name (gdbarch, regno),
318
                                regno,
319
                                gdbarch_register_sim_regno
320
                                  (gdbarch, regno),
321
                                nr_bytes, register_size (gdbarch, regno));
322
            warn_user = 0;
323
          }
324
        /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
325
           indicating that GDB and the SIM have different ideas about
326
           which registers are fetchable.  */
327
        /* Else if (nr_bytes < 0): an old simulator, that doesn't
328
           think to return the register size.  Just assume all is ok.  */
329
        regcache_raw_supply (regcache, regno, buf);
330
        if (remote_debug)
331
          {
332
            printf_filtered ("gdbsim_fetch_register: %d", regno);
333
            /* FIXME: We could print something more intelligible.  */
334
            dump_mem (buf, register_size (gdbarch, regno));
335
          }
336
        break;
337
      }
338
    }
339
}
340
 
341
 
342
static void
343
gdbsim_store_register (struct target_ops *ops,
344
                       struct regcache *regcache, int regno)
345
{
346
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
347
  if (regno == -1)
348
    {
349
      for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
350
        gdbsim_store_register (ops, regcache, regno);
351
      return;
352
    }
353
  else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
354
    {
355
      char tmp[MAX_REGISTER_SIZE];
356
      int nr_bytes;
357
      regcache_cooked_read (regcache, regno, tmp);
358
      nr_bytes = sim_store_register (gdbsim_desc,
359
                                     gdbarch_register_sim_regno
360
                                       (gdbarch, regno),
361
                                     tmp, register_size (gdbarch, regno));
362
      if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno))
363
        internal_error (__FILE__, __LINE__,
364
                        _("Register size different to expected"));
365
      /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
366
         indicating that GDB and the SIM have different ideas about
367
         which registers are fetchable.  */
368
      if (remote_debug)
369
        {
370
          printf_filtered ("gdbsim_store_register: %d", regno);
371
          /* FIXME: We could print something more intelligible.  */
372
          dump_mem (tmp, register_size (gdbarch, regno));
373
        }
374
    }
375
}
376
 
377
/* Kill the running program.  This may involve closing any open files
378
   and releasing other resources acquired by the simulated program.  */
379
 
380
static void
381
gdbsim_kill (struct target_ops *ops)
382
{
383
  if (remote_debug)
384
    printf_filtered ("gdbsim_kill\n");
385
 
386
  /* There is no need to `kill' running simulator - the simulator is
387
     not running.  Mourning it is enough.  */
388
  target_mourn_inferior ();
389
}
390
 
391
/* Load an executable file into the target process.  This is expected to
392
   not only bring new code into the target process, but also to update
393
   GDB's symbol tables to match.  */
394
 
395
static void
396
gdbsim_load (char *args, int fromtty)
397
{
398
  char **argv;
399
  char *prog;
400
 
401
  if (args == NULL)
402
      error_no_arg (_("program to load"));
403
 
404
  argv = gdb_buildargv (args);
405
  make_cleanup_freeargv (argv);
406
 
407
  prog = tilde_expand (argv[0]);
408
 
409
  if (argv[1] != NULL)
410
    error (_("GDB sim does not yet support a load offset."));
411
 
412
  if (remote_debug)
413
    printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
414
 
415
  /* FIXME: We will print two messages on error.
416
     Need error to either not print anything if passed NULL or need
417
     another routine that doesn't take any arguments.  */
418
  if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
419
    error (_("unable to load program"));
420
 
421
  /* FIXME: If a load command should reset the targets registers then
422
     a call to sim_create_inferior() should go here. */
423
 
424
  program_loaded = 1;
425
}
426
 
427
 
428
/* Start an inferior process and set inferior_ptid to its pid.
429
   EXEC_FILE is the file to run.
430
   ARGS is a string containing the arguments to the program.
431
   ENV is the environment vector to pass.  Errors reported with error().
432
   On VxWorks and various standalone systems, we ignore exec_file.  */
433
/* This is called not only when we first attach, but also when the
434
   user types "run" after having attached.  */
435
 
436
static void
437
gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
438
                        char **env, int from_tty)
439
{
440
  int len;
441
  char *arg_buf, **argv;
442
 
443
  if (exec_file == 0 || exec_bfd == 0)
444
    warning (_("No executable file specified."));
445
  if (!program_loaded)
446
    warning (_("No program loaded."));
447
 
448
  if (remote_debug)
449
    printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
450
                     (exec_file ? exec_file : "(NULL)"),
451
                     args);
452
 
453
  if (ptid_equal (inferior_ptid, remote_sim_ptid))
454
    gdbsim_kill (target);
455
  remove_breakpoints ();
456
  init_wait_for_inferior ();
457
 
458
  if (exec_file != NULL)
459
    {
460
      len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
461
      arg_buf = (char *) alloca (len);
462
      arg_buf[0] = '\0';
463
      strcat (arg_buf, exec_file);
464
      strcat (arg_buf, " ");
465
      strcat (arg_buf, args);
466
      argv = gdb_buildargv (arg_buf);
467
      make_cleanup_freeargv (argv);
468
    }
469
  else
470
    argv = NULL;
471
  sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
472
 
473
  inferior_ptid = remote_sim_ptid;
474
  inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
475
  add_thread_silent (inferior_ptid);
476
 
477
  insert_breakpoints ();        /* Needed to get correct instruction in cache */
478
 
479
  clear_proceed_status ();
480
}
481
 
482
/* The open routine takes the rest of the parameters from the command,
483
   and (if successful) pushes a new target onto the stack.
484
   Targets should supply this routine, if only to provide an error message.  */
485
/* Called when selecting the simulator. EG: (gdb) target sim name.  */
486
 
487
static void
488
gdbsim_open (char *args, int from_tty)
489
{
490
  int len;
491
  char *arg_buf;
492
  char **argv;
493
 
494
  if (remote_debug)
495
    printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
496
 
497
  /* Remove current simulator if one exists.  Only do this if the simulator
498
     has been opened because sim_close requires it.
499
     This is important because the call to push_target below will cause
500
     sim_close to be called if the simulator is already open, but push_target
501
     is called after sim_open!  We can't move the call to push_target before
502
     the call to sim_open because sim_open may invoke `error'.  */
503
  if (gdbsim_desc != NULL)
504
    unpush_target (&gdbsim_ops);
505
 
506
  len = (7 + 1                  /* gdbsim */
507
         + strlen (" -E little")
508
         + strlen (" --architecture=xxxxxxxxxx")
509
         + (args ? strlen (args) : 0)
510
         + 50) /* slack */ ;
511
  arg_buf = (char *) alloca (len);
512
  strcpy (arg_buf, "gdbsim");   /* 7 */
513
  /* Specify the byte order for the target when it is explicitly
514
     specified by the user (not auto detected). */
515
  switch (selected_byte_order ())
516
    {
517
    case BFD_ENDIAN_BIG:
518
      strcat (arg_buf, " -E big");
519
      break;
520
    case BFD_ENDIAN_LITTLE:
521
      strcat (arg_buf, " -E little");
522
      break;
523
    case BFD_ENDIAN_UNKNOWN:
524
      break;
525
    }
526
  /* Specify the architecture of the target when it has been
527
     explicitly specified */
528
  if (selected_architecture_name () != NULL)
529
    {
530
      strcat (arg_buf, " --architecture=");
531
      strcat (arg_buf, selected_architecture_name ());
532
    }
533
  /* finally, any explicit args */
534
  if (args)
535
    {
536
      strcat (arg_buf, " ");    /* 1 */
537
      strcat (arg_buf, args);
538
    }
539
  argv = gdb_buildargv (arg_buf);
540
  make_cleanup_freeargv (argv);
541
 
542
  init_callbacks ();
543
  gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
544
 
545
  if (gdbsim_desc == 0)
546
    error (_("unable to create simulator instance"));
547
 
548
  push_target (&gdbsim_ops);
549
  printf_filtered ("Connected to the simulator.\n");
550
 
551
  /* There's nothing running after "target sim" or "load"; not until
552
     "run".  */
553
  inferior_ptid = null_ptid;
554
}
555
 
556
/* Does whatever cleanup is required for a target that we are no longer
557
   going to be calling.  Argument says whether we are quitting gdb and
558
   should not get hung in case of errors, or whether we want a clean
559
   termination even if it takes a while.  This routine is automatically
560
   always called just before a routine is popped off the target stack.
561
   Closing file descriptors and freeing memory are typical things it should
562
   do.  */
563
/* Close out all files and local state before this target loses control. */
564
 
565
static void
566
gdbsim_close (int quitting)
567
{
568
  if (remote_debug)
569
    printf_filtered ("gdbsim_close: quitting %d\n", quitting);
570
 
571
  program_loaded = 0;
572
 
573
  if (gdbsim_desc != NULL)
574
    {
575
      sim_close (gdbsim_desc, quitting);
576
      gdbsim_desc = NULL;
577
    }
578
 
579
  end_callbacks ();
580
  generic_mourn_inferior ();
581
  delete_thread_silent (remote_sim_ptid);
582
  delete_inferior_silent (ptid_get_pid (remote_sim_ptid));
583
}
584
 
585
/* Takes a program previously attached to and detaches it.
586
   The program may resume execution (some targets do, some don't) and will
587
   no longer stop on signals, etc.  We better not have left any breakpoints
588
   in the program or it'll die when it hits one.  ARGS is arguments
589
   typed by the user (e.g. a signal to send the process).  FROM_TTY
590
   says whether to be verbose or not.  */
591
/* Terminate the open connection to the remote debugger.
592
   Use this when you want to detach and do something else with your gdb.  */
593
 
594
static void
595
gdbsim_detach (struct target_ops *ops, char *args, int from_tty)
596
{
597
  if (remote_debug)
598
    printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
599
 
600
  pop_target ();                /* calls gdbsim_close to do the real work */
601
  if (from_tty)
602
    printf_filtered ("Ending simulator %s debugging\n", target_shortname);
603
}
604
 
605
/* Resume execution of the target process.  STEP says whether to single-step
606
   or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
607
   to the target, or zero for no signal.  */
608
 
609
static enum target_signal resume_siggnal;
610
static int resume_step;
611
 
612
static void
613
gdbsim_resume (struct target_ops *ops,
614
               ptid_t ptid, int step, enum target_signal siggnal)
615
{
616
  if (!ptid_equal (inferior_ptid, remote_sim_ptid))
617
    error (_("The program is not being run."));
618
 
619
  if (remote_debug)
620
    printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
621
 
622
  resume_siggnal = siggnal;
623
  resume_step = step;
624
}
625
 
626
/* Notify the simulator of an asynchronous request to stop.
627
 
628
   The simulator shall ensure that the stop request is eventually
629
   delivered to the simulator.  If the call is made while the
630
   simulator is not running then the stop request is processed when
631
   the simulator is next resumed.
632
 
633
   For simulators that do not support this operation, just abort */
634
 
635
static void
636
gdbsim_stop (ptid_t ptid)
637
{
638
  if (!sim_stop (gdbsim_desc))
639
    {
640
      quit ();
641
    }
642
}
643
 
644
/* GDB version of os_poll_quit callback.
645
   Taken from gdb/util.c - should be in a library.  */
646
 
647
static int
648
gdb_os_poll_quit (host_callback *p)
649
{
650
  if (deprecated_ui_loop_hook != NULL)
651
    deprecated_ui_loop_hook (0);
652
 
653
  if (quit_flag)                /* gdb's idea of quit */
654
    {
655
      quit_flag = 0;             /* we've stolen it */
656
      return 1;
657
    }
658
  else if (immediate_quit)
659
    {
660
      return 1;
661
    }
662
  return 0;
663
}
664
 
665
/* Wait for inferior process to do something.  Return pid of child,
666
   or -1 in case of error; store status through argument pointer STATUS,
667
   just as `wait' would. */
668
 
669
static void
670
gdbsim_cntrl_c (int signo)
671
{
672
  gdbsim_stop (remote_sim_ptid);
673
}
674
 
675
static ptid_t
676
gdbsim_wait (struct target_ops *ops,
677
             ptid_t ptid, struct target_waitstatus *status, int options)
678
{
679
  static RETSIGTYPE (*prev_sigint) ();
680
  int sigrc = 0;
681
  enum sim_stop reason = sim_running;
682
 
683
  if (remote_debug)
684
    printf_filtered ("gdbsim_wait\n");
685
 
686
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
687
  {
688
    struct sigaction sa, osa;
689
    sa.sa_handler = gdbsim_cntrl_c;
690
    sigemptyset (&sa.sa_mask);
691
    sa.sa_flags = 0;
692
    sigaction (SIGINT, &sa, &osa);
693
    prev_sigint = osa.sa_handler;
694
  }
695
#else
696
  prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
697
#endif
698
  sim_resume (gdbsim_desc, resume_step, resume_siggnal);
699
  signal (SIGINT, prev_sigint);
700
  resume_step = 0;
701
 
702
  sim_stop_reason (gdbsim_desc, &reason, &sigrc);
703
 
704
  switch (reason)
705
    {
706
    case sim_exited:
707
      status->kind = TARGET_WAITKIND_EXITED;
708
      status->value.integer = sigrc;
709
      break;
710
    case sim_stopped:
711
      switch (sigrc)
712
        {
713
        case TARGET_SIGNAL_ABRT:
714
          quit ();
715
          break;
716
        case TARGET_SIGNAL_INT:
717
        case TARGET_SIGNAL_TRAP:
718
        default:
719
          status->kind = TARGET_WAITKIND_STOPPED;
720
          status->value.sig = sigrc;
721
          break;
722
        }
723
      break;
724
    case sim_signalled:
725
      status->kind = TARGET_WAITKIND_SIGNALLED;
726
      status->value.sig = sigrc;
727
      break;
728
    case sim_running:
729
    case sim_polling:
730
      /* FIXME: Is this correct? */
731
      break;
732
    }
733
 
734
  return inferior_ptid;
735
}
736
 
737
/* Get ready to modify the registers array.  On machines which store
738
   individual registers, this doesn't need to do anything.  On machines
739
   which store all the registers in one fell swoop, this makes sure
740
   that registers contains all the registers from the program being
741
   debugged.  */
742
 
743
static void
744
gdbsim_prepare_to_store (struct regcache *regcache)
745
{
746
  /* Do nothing, since we can store individual regs */
747
}
748
 
749
/* Transfer LEN bytes between GDB address MYADDR and target address
750
   MEMADDR.  If WRITE is non-zero, transfer them to the target,
751
   otherwise transfer them from the target.  TARGET is unused.
752
 
753
   Returns the number of bytes transferred. */
754
 
755
static int
756
gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
757
                             int write, struct mem_attrib *attrib,
758
                             struct target_ops *target)
759
{
760
  /* If no program is running yet, then ignore the simulator for
761
     memory.  Pass the request down to the next target, hopefully
762
     an exec file.  */
763
  if (!target_has_execution)
764
    return 0;
765
 
766
  if (!program_loaded)
767
    error (_("No program loaded."));
768
 
769
  if (remote_debug)
770
    {
771
      /* FIXME: Send to something other than STDOUT? */
772
      printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
773
      gdb_print_host_address (myaddr, gdb_stdout);
774
      printf_filtered (", memaddr %s, len %d, write %d\n",
775
                       paddress (target_gdbarch, memaddr), len, write);
776
      if (remote_debug && write)
777
        dump_mem (myaddr, len);
778
    }
779
 
780
  if (write)
781
    {
782
      len = sim_write (gdbsim_desc, memaddr, myaddr, len);
783
    }
784
  else
785
    {
786
      len = sim_read (gdbsim_desc, memaddr, myaddr, len);
787
      if (remote_debug && len > 0)
788
        dump_mem (myaddr, len);
789
    }
790
  return len;
791
}
792
 
793
static void
794
gdbsim_files_info (struct target_ops *target)
795
{
796
  char *file = "nothing";
797
 
798
  if (exec_bfd)
799
    file = bfd_get_filename (exec_bfd);
800
 
801
  if (remote_debug)
802
    printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
803
 
804
  if (exec_bfd)
805
    {
806
      printf_filtered ("\tAttached to %s running program %s\n",
807
                       target_shortname, file);
808
      sim_info (gdbsim_desc, 0);
809
    }
810
}
811
 
812
/* Clear the simulator's notion of what the break points are.  */
813
 
814
static void
815
gdbsim_mourn_inferior (struct target_ops *target)
816
{
817
  if (remote_debug)
818
    printf_filtered ("gdbsim_mourn_inferior:\n");
819
 
820
  remove_breakpoints ();
821
  generic_mourn_inferior ();
822
  delete_thread_silent (remote_sim_ptid);
823
}
824
 
825
/* Pass the command argument through to the simulator verbatim.  The
826
   simulator must do any command interpretation work.  */
827
 
828
void
829
simulator_command (char *args, int from_tty)
830
{
831
  if (gdbsim_desc == NULL)
832
    {
833
 
834
      /* PREVIOUSLY: The user may give a command before the simulator
835
         is opened. [...] (??? assuming of course one wishes to
836
         continue to allow commands to be sent to unopened simulators,
837
         which isn't entirely unreasonable). */
838
 
839
      /* The simulator is a builtin abstraction of a remote target.
840
         Consistent with that model, access to the simulator, via sim
841
         commands, is restricted to the period when the channel to the
842
         simulator is open. */
843
 
844
      error (_("Not connected to the simulator target"));
845
    }
846
 
847
  sim_do_command (gdbsim_desc, args);
848
 
849
  /* Invalidate the register cache, in case the simulator command does
850
     something funny. */
851
  registers_changed ();
852
}
853
 
854
/* Check to see if a thread is still alive.  */
855
 
856
static int
857
gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
858
{
859
  if (ptid_equal (ptid, remote_sim_ptid))
860
    /* The simulators' task is always alive.  */
861
    return 1;
862
 
863
  return 0;
864
}
865
 
866
/* Convert a thread ID to a string.  Returns the string in a static
867
   buffer.  */
868
 
869
static char *
870
gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
871
{
872
  static char buf[64];
873
 
874
  if (ptid_equal (remote_sim_ptid, ptid))
875
    {
876
      xsnprintf (buf, sizeof buf, "Thread <main>");
877
      return buf;
878
    }
879
 
880
  return normal_pid_to_str (ptid);
881
}
882
 
883
/* Define the target subroutine names */
884
 
885
struct target_ops gdbsim_ops;
886
 
887
static void
888
init_gdbsim_ops (void)
889
{
890
  gdbsim_ops.to_shortname = "sim";
891
  gdbsim_ops.to_longname = "simulator";
892
  gdbsim_ops.to_doc = "Use the compiled-in simulator.";
893
  gdbsim_ops.to_open = gdbsim_open;
894
  gdbsim_ops.to_close = gdbsim_close;
895
  gdbsim_ops.to_detach = gdbsim_detach;
896
  gdbsim_ops.to_resume = gdbsim_resume;
897
  gdbsim_ops.to_wait = gdbsim_wait;
898
  gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
899
  gdbsim_ops.to_store_registers = gdbsim_store_register;
900
  gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
901
  gdbsim_ops.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
902
  gdbsim_ops.to_files_info = gdbsim_files_info;
903
  gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
904
  gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
905
  gdbsim_ops.to_kill = gdbsim_kill;
906
  gdbsim_ops.to_load = gdbsim_load;
907
  gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
908
  gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
909
  gdbsim_ops.to_stop = gdbsim_stop;
910
  gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
911
  gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
912
  gdbsim_ops.to_stratum = process_stratum;
913
  gdbsim_ops.to_has_all_memory = default_child_has_all_memory;
914
  gdbsim_ops.to_has_memory = default_child_has_memory;
915
  gdbsim_ops.to_has_stack = default_child_has_stack;
916
  gdbsim_ops.to_has_registers = default_child_has_registers;
917
  gdbsim_ops.to_has_execution = default_child_has_execution;
918
  gdbsim_ops.to_magic = OPS_MAGIC;
919
}
920
 
921
void
922
_initialize_remote_sim (void)
923
{
924
  init_gdbsim_ops ();
925
  add_target (&gdbsim_ops);
926
 
927
  add_com ("sim", class_obscure, simulator_command,
928
           _("Send a command to the simulator."));
929
 
930
  /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
931
     isn't 0.  */
932
  remote_sim_ptid = ptid_build (42000, 0, 42000);
933
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.