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

Subversion Repositories openrisc

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

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

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

powered by: WebSVN 2.1.0

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