gdb/target.c

   1 /* Select target systems and architectures at runtime for GDB.
   2    Copyright 1990, 1992-1995, 1998, 1999 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include <errno.h>
  23 #include <ctype.h>
  24 #include "gdb_string.h"
  25 #include "target.h"
  26 #include "gdbcmd.h"
  27 #include "symtab.h"
  28 #include "inferior.h"
  29 #include "bfd.h"
  30 #include "symfile.h"
  31 #include "objfiles.h"
  32 #include "wait.h"
  33 #include <signal.h>
  34
  35 extern int errno;
  36
  37 static void
  38 target_info PARAMS ((char *, int));
  39
  40 static void
  41 cleanup_target PARAMS ((struct target_ops *));
  42
  43 static void
  44 maybe_kill_then_create_inferior PARAMS ((char *, char *, char **));
  45
  46 static void
  47 default_clone_and_follow_inferior PARAMS ((int, int *));
  48
  49 static void
  50 maybe_kill_then_attach PARAMS ((char *, int));
  51
  52 static void
  53 kill_or_be_killed PARAMS ((int));
  54
  55 static void
  56 default_terminal_info PARAMS ((char *, int));
  57
  58 static int
  59 nosymbol PARAMS ((char *, CORE_ADDR *));
  60
  61 static void
  62 tcomplain PARAMS ((void));
  63
  64 static int
  65 nomemory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
  66
  67 static int
  68 return_zero PARAMS ((void));
  69
  70 static int
  71 return_one PARAMS ((void));
  72
  73 void
  74 target_ignore PARAMS ((void));
  75
  76 static void
  77 target_command PARAMS ((char *, int));
  78
  79 static struct target_ops *
  80 find_default_run_target PARAMS ((char *));
  81
  82 static void
  83 update_current_target PARAMS ((void));
  84
  85 /* Transfer LEN bytes between target address MEMADDR and GDB address MYADDR.
  86    Returns 0 for success, errno code for failure (which includes partial
  87    transfers--if you want a more useful response to partial transfers, try
  88    target_read_memory_partial).  */
  89
  90 static int
  91 target_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len,
  92                             int write, asection *bfd_section));
  93
  94 static void init_dummy_target PARAMS ((void));
  95
  96 static void
  97 debug_to_open PARAMS ((char *, int));
  98
  99 static void
 100 debug_to_close PARAMS ((int));
 101
 102 static void
 103 debug_to_attach PARAMS ((char *, int));
 104
 105 static void
 106 debug_to_detach PARAMS ((char *, int));
 107
 108 static void
 109 debug_to_resume PARAMS ((int, int, enum target_signal));
 110
 111 static int
 112 debug_to_wait PARAMS ((int, struct target_waitstatus *));
 113
 114 static void
 115 debug_to_fetch_registers PARAMS ((int));
 116
 117 static void
 118 debug_to_store_registers PARAMS ((int));
 119
 120 static void
 121 debug_to_prepare_to_store PARAMS ((void));
 122
 123 static int
 124 debug_to_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
 125
 126 static void
 127 debug_to_files_info PARAMS ((struct target_ops *));
 128
 129 static int
 130 debug_to_insert_breakpoint PARAMS ((CORE_ADDR, char *));
 131
 132 static int
 133 debug_to_remove_breakpoint PARAMS ((CORE_ADDR, char *));
 134
 135 static void
 136 debug_to_terminal_init PARAMS ((void));
 137
 138 static void
 139 debug_to_terminal_inferior PARAMS ((void));
 140
 141 static void
 142 debug_to_terminal_ours_for_output PARAMS ((void));
 143
 144 static void
 145 debug_to_terminal_ours PARAMS ((void));
 146
 147 static void
 148 debug_to_terminal_info PARAMS ((char *, int));
 149
 150 static void
 151 debug_to_kill PARAMS ((void));
 152
 153 static void
 154 debug_to_load PARAMS ((char *, int));
 155
 156 static int
 157 debug_to_lookup_symbol PARAMS ((char *, CORE_ADDR *));
 158
 159 static void
 160 debug_to_create_inferior PARAMS ((char *, char *, char **));
 161
 162 static void
 163 debug_to_mourn_inferior PARAMS ((void));
 164
 165 static int
 166 debug_to_can_run PARAMS ((void));
 167
 168 static void
 169 debug_to_notice_signals PARAMS ((int));
 170
 171 static int
 172 debug_to_thread_alive PARAMS ((int));
 173
 174 static void
 175 debug_to_stop PARAMS ((void));
 176
 177 static int debug_to_query PARAMS ((int/*char*/, char *, char *, int *));
 178
 179 /* Pointer to array of target architecture structures; the size of the
 180    array; the current index into the array; the allocated size of the
 181    array.  */
 182 struct target_ops **target_structs;
 183 unsigned target_struct_size;
 184 unsigned target_struct_index;
 185 unsigned target_struct_allocsize;
 186 #define DEFAULT_ALLOCSIZE       10
 187
 188 /* The initial current target, so that there is always a semi-valid
 189    current target.  */
 190
 191 static struct target_ops dummy_target;
 192
 193 /* Top of target stack.  */
 194
 195 struct target_stack_item *target_stack;
 196
 197 /* The target structure we are currently using to talk to a process
 198    or file or whatever "inferior" we have.  */
 199
 200 struct target_ops current_target;
 201
 202 /* Command list for target.  */
 203
 204 static struct cmd_list_element *targetlist = NULL;
 205
 206 /* Nonzero if we are debugging an attached outside process
 207    rather than an inferior.  */
 208
 209 int attach_flag;
 210
 211 /* Non-zero if we want to see trace of target level stuff.  */
 212
 213 static int targetdebug = 0;
 214
 215 static void setup_target_debug PARAMS ((void));
 216
 217 /* The user just typed 'target' without the name of a target.  */
 218
 219 /* ARGSUSED */
 220 static void
 221 target_command (arg, from_tty)
 222      char *arg;
 223      int from_tty;
 224 {
 225   fputs_filtered ("Argument required (target name).  Try `help target'\n",
 226                   gdb_stdout);
 227 }
 228
 229 /* Add a possible target architecture to the list.  */
 230
 231 void
 232 add_target (t)
 233      struct target_ops *t;
 234 {
 235   if (!target_structs)
 236     {
 237       target_struct_allocsize = DEFAULT_ALLOCSIZE;
 238       target_structs = (struct target_ops **) xmalloc
 239         (target_struct_allocsize * sizeof (*target_structs));
 240     }
 241   if (target_struct_size >= target_struct_allocsize)
 242     {
 243       target_struct_allocsize *= 2;
 244       target_structs = (struct target_ops **)
 245           xrealloc ((char *) target_structs,
 246                     target_struct_allocsize * sizeof (*target_structs));
 247     }
 248   target_structs[target_struct_size++] = t;
 249 /*  cleanup_target (t);*/
 250
 251   if (targetlist == NULL)
 252     add_prefix_cmd ("target", class_run, target_command,
 253                     "Connect to a target machine or process.\n\
 254 The first argument is the type or protocol of the target machine.\n\
 255 Remaining arguments are interpreted by the target protocol.  For more\n\
 256 information on the arguments for a particular protocol, type\n\
 257 `help target ' followed by the protocol name.",
 258                     &targetlist, "target ", 0, &cmdlist);
 259   add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
 260 }
 261
 262 /* Stub functions */
 263
 264 void
 265 target_ignore ()
 266 {
 267 }
 268
 269 /* ARGSUSED */
 270 static int
 271 nomemory (memaddr, myaddr, len, write, t)
 272      CORE_ADDR memaddr;
 273      char *myaddr;
 274      int len;
 275      int write;
 276      struct target_ops *t;
 277 {
 278   errno = EIO;          /* Can't read/write this location */
 279   return 0;             /* No bytes handled */
 280 }
 281
 282 static void
 283 tcomplain ()
 284 {
 285   error ("You can't do that when your target is `%s'",
 286          current_target.to_shortname);
 287 }
 288
 289 void
 290 noprocess ()
 291 {
 292   error ("You can't do that without a process to debug.");
 293 }
 294
 295 /* ARGSUSED */
 296 static int
 297 nosymbol (name, addrp)
 298      char *name;
 299      CORE_ADDR *addrp;
 300 {
 301   return 1;             /* Symbol does not exist in target env */
 302 }
 303
 304 /* ARGSUSED */
 305 void
 306 nosupport_runtime ()
 307 {
 308   if (!inferior_pid)
 309     noprocess ();
 310   else
 311     error ("No run-time support for this");
 312 }
 313
 314
 315 /* ARGSUSED */
 316 static void
 317 default_terminal_info (args, from_tty)
 318      char *args;
 319      int from_tty;
 320 {
 321   printf_unfiltered("No saved terminal information.\n");
 322 }
 323
 324 /* This is the default target_create_inferior and target_attach function.
 325    If the current target is executing, it asks whether to kill it off.
 326    If this function returns without calling error(), it has killed off
 327    the target, and the operation should be attempted.  */
 328
 329 static void
 330 kill_or_be_killed (from_tty)
 331      int from_tty;
 332 {
 333   if (target_has_execution)
 334     {
 335       printf_unfiltered ("You are already running a program:\n");
 336       target_files_info ();
 337       if (query ("Kill it? ")) {
 338         target_kill ();
 339         if (target_has_execution)
 340           error ("Killing the program did not help.");
 341         return;
 342       } else {
 343         error ("Program not killed.");
 344       }
 345     }
 346   tcomplain();
 347 }
 348
 349 static void
 350 maybe_kill_then_attach (args, from_tty)
 351      char *args;
 352      int from_tty;
 353 {
 354   kill_or_be_killed (from_tty);
 355   target_attach (args, from_tty);
 356 }
 357
 358 static void
 359 maybe_kill_then_create_inferior (exec, args, env)
 360      char *exec;
 361      char *args;
 362      char **env;
 363 {
 364   kill_or_be_killed (0);
 365   target_create_inferior (exec, args, env);
 366 }
 367
 368 static void
 369 default_clone_and_follow_inferior (child_pid, followed_child)
 370   int  child_pid;
 371   int  *followed_child;
 372 {
 373   target_clone_and_follow_inferior (child_pid, followed_child);
 374 }
 375
 376 /* Clean up a target struct so it no longer has any zero pointers in it.
 377    We default entries, at least to stubs that print error messages.  */
 378
 379 static void
 380 cleanup_target (t)
 381      struct target_ops *t;
 382 {
 383
 384 #define de_fault(field, value) \
 385   if (!t->field)        t->field = value
 386
 387   /*        FIELD                       DEFAULT VALUE        */
 388
 389   de_fault (to_open,                    (void (*) PARAMS((char *, int))) tcomplain);
 390   de_fault (to_close,                   (void (*) PARAMS((int))) target_ignore);
 391   de_fault (to_attach,                  maybe_kill_then_attach);
 392   de_fault (to_post_attach,             (void (*) PARAMS ((int))) target_ignore);
 393   de_fault (to_require_attach,          maybe_kill_then_attach);
 394   de_fault (to_detach,                  (void (*) PARAMS((char *, int))) target_ignore);
 395   de_fault (to_require_detach,          (void (*) PARAMS((int, char *, int))) target_ignore);
 396   de_fault (to_resume,                  (void (*) PARAMS((int, int, enum target_signal))) noprocess);
 397   de_fault (to_wait,                    (int (*) PARAMS((int, struct target_waitstatus *))) noprocess);
 398   de_fault (to_post_wait,               (void (*) PARAMS ((int, int))) target_ignore);
 399   de_fault (to_fetch_registers,         (void (*) PARAMS((int))) target_ignore);
 400   de_fault (to_store_registers,         (void (*) PARAMS((int))) noprocess);
 401   de_fault (to_prepare_to_store,        (void (*) PARAMS((void))) noprocess);
 402   de_fault (to_xfer_memory,             (int (*) PARAMS((CORE_ADDR, char *, int, int, struct target_ops *))) nomemory);
 403   de_fault (to_files_info,              (void (*) PARAMS((struct target_ops *))) target_ignore);
 404   de_fault (to_insert_breakpoint,       memory_insert_breakpoint);
 405   de_fault (to_remove_breakpoint,       memory_remove_breakpoint);
 406   de_fault (to_terminal_init,           (void (*) PARAMS((void))) target_ignore);
 407   de_fault (to_terminal_inferior,       (void (*) PARAMS ((void))) target_ignore);
 408   de_fault (to_terminal_ours_for_output,(void (*) PARAMS ((void))) target_ignore);
 409   de_fault (to_terminal_ours,           (void (*) PARAMS ((void))) target_ignore);
 410   de_fault (to_terminal_info,           default_terminal_info);
 411   de_fault (to_kill,                    (void (*) PARAMS((void))) noprocess);
 412   de_fault (to_load,                    (void (*) PARAMS((char *, int))) tcomplain);
 413   de_fault (to_lookup_symbol,           (int (*) PARAMS ((char *, CORE_ADDR *))) nosymbol);
 414   de_fault (to_create_inferior,         maybe_kill_then_create_inferior);
 415   de_fault (to_post_startup_inferior,   (void (*) PARAMS ((int))) target_ignore);
 416   de_fault (to_acknowledge_created_inferior,            (void (*) PARAMS((int))) target_ignore);
 417   de_fault (to_clone_and_follow_inferior,               default_clone_and_follow_inferior);
 418   de_fault (to_post_follow_inferior_by_clone,           (void (*) PARAMS ((void))) target_ignore);
 419   de_fault (to_insert_fork_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
 420   de_fault (to_remove_fork_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
 421   de_fault (to_insert_vfork_catchpoint, (int (*) PARAMS ((int))) tcomplain);
 422   de_fault (to_remove_vfork_catchpoint, (int (*) PARAMS ((int))) tcomplain);
 423   de_fault (to_has_forked,              (int (*) PARAMS ((int, int *))) return_zero);
 424   de_fault (to_has_vforked,             (int (*) PARAMS ((int, int *))) return_zero);
 425   de_fault (to_can_follow_vfork_prior_to_exec, (int (*) PARAMS ((void ))) return_zero);
 426   de_fault (to_post_follow_vfork,       (void (*) PARAMS ((int, int, int, int))) target_ignore);
 427   de_fault (to_insert_exec_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
 428   de_fault (to_remove_exec_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
 429   de_fault (to_has_execd,               (int (*) PARAMS ((int, char **))) return_zero);
 430   de_fault (to_reported_exec_events_per_exec_call, (int (*) PARAMS ((void))) return_one);
 431   de_fault (to_has_syscall_event,       (int (*) PARAMS ((int, enum target_waitkind *, int *))) return_zero);
 432   de_fault (to_has_exited,              (int (*) PARAMS ((int, int, int *))) return_zero);
 433   de_fault (to_mourn_inferior,          (void (*) PARAMS ((void))) noprocess);
 434   de_fault (to_can_run,                 return_zero);
 435   de_fault (to_notice_signals,          (void (*) PARAMS((int))) target_ignore);
 436   de_fault (to_thread_alive,            (int (*) PARAMS((int))) target_ignore);
 437   de_fault (to_stop,                    (void (*) PARAMS((void))) target_ignore);
 438   de_fault (to_query,                   (int (*) PARAMS((int/*char*/, char*, char *, int *))) target_ignore);
 439   de_fault (to_enable_exception_callback,       (struct symtab_and_line * (*) PARAMS((enum exception_event_kind, int))) nosupport_runtime);
 440   de_fault (to_get_current_exception_event,     (struct exception_event_record * (*) PARAMS((void))) nosupport_runtime);
 441
 442   de_fault (to_pid_to_exec_file,        (char* (*) PARAMS((int))) return_zero);
 443   de_fault (to_core_file_to_sym_file,   (char* (*) PARAMS ((char *))) return_zero);
 444 #undef de_fault
 445 }
 446
 447 /* Go through the target stack from top to bottom, copying over zero entries in
 448    current_target.  In effect, we are doing class inheritance through the
 449    pushed target vectors.  */
 450
 451 static void
 452 update_current_target ()
 453 {
 454   struct target_stack_item *item;
 455   struct target_ops *t;
 456
 457   /* First, reset current_target */
 458   memset (&current_target, 0, sizeof current_target);
 459
 460   for (item = target_stack; item; item = item->next)
 461     {
 462       t = item->target_ops;
 463
 464 #define INHERIT(FIELD, TARGET) \
 465       if (!current_target.FIELD) \
 466         current_target.FIELD = TARGET->FIELD
 467
 468       INHERIT (to_shortname, t);
 469       INHERIT (to_longname, t);
 470       INHERIT (to_doc, t);
 471       INHERIT (to_open, t);
 472       INHERIT (to_close, t);
 473       INHERIT (to_attach, t);
 474       INHERIT (to_post_attach, t);
 475       INHERIT (to_require_attach, t);
 476       INHERIT (to_detach, t);
 477       INHERIT (to_require_detach, t);
 478       INHERIT (to_resume, t);
 479       INHERIT (to_wait, t);
 480       INHERIT (to_post_wait, t);
 481       INHERIT (to_fetch_registers, t);
 482       INHERIT (to_store_registers, t);
 483       INHERIT (to_prepare_to_store, t);
 484       INHERIT (to_xfer_memory, t);
 485       INHERIT (to_files_info, t);
 486       INHERIT (to_insert_breakpoint, t);
 487       INHERIT (to_remove_breakpoint, t);
 488       INHERIT (to_terminal_init, t);
 489       INHERIT (to_terminal_inferior, t);
 490       INHERIT (to_terminal_ours_for_output, t);
 491       INHERIT (to_terminal_ours, t);
 492       INHERIT (to_terminal_info, t);
 493       INHERIT (to_kill, t);
 494       INHERIT (to_load, t);
 495       INHERIT (to_lookup_symbol, t);
 496       INHERIT (to_create_inferior, t);
 497       INHERIT (to_post_startup_inferior, t);
 498       INHERIT (to_acknowledge_created_inferior, t);
 499       INHERIT (to_clone_and_follow_inferior, t);
 500       INHERIT (to_post_follow_inferior_by_clone, t);
 501       INHERIT (to_insert_fork_catchpoint, t);
 502       INHERIT (to_remove_fork_catchpoint, t);
 503       INHERIT (to_insert_vfork_catchpoint, t);
 504       INHERIT (to_remove_vfork_catchpoint, t);
 505       INHERIT (to_has_forked, t);
 506       INHERIT (to_has_vforked, t);
 507       INHERIT (to_can_follow_vfork_prior_to_exec, t);
 508       INHERIT (to_post_follow_vfork, t);
 509       INHERIT (to_insert_exec_catchpoint, t);
 510       INHERIT (to_remove_exec_catchpoint, t);
 511       INHERIT (to_has_execd, t);
 512       INHERIT (to_reported_exec_events_per_exec_call, t);
 513       INHERIT (to_has_syscall_event, t);
 514       INHERIT (to_has_exited, t);
 515       INHERIT (to_mourn_inferior, t);
 516       INHERIT (to_can_run, t);
 517       INHERIT (to_notice_signals, t);
 518       INHERIT (to_thread_alive, t);
 519       INHERIT (to_find_new_threads, t);
 520       INHERIT (to_stop, t);
 521       INHERIT (to_query, t);
 522       INHERIT (to_enable_exception_callback, t);
 523       INHERIT (to_get_current_exception_event, t);
 524       INHERIT (to_pid_to_exec_file, t);
 525       INHERIT (to_core_file_to_sym_file, t);
 526       INHERIT (to_stratum, t);
 527       INHERIT (DONT_USE, t);
 528       INHERIT (to_has_all_memory, t);
 529       INHERIT (to_has_memory, t);
 530       INHERIT (to_has_stack, t);
 531       INHERIT (to_has_registers, t);
 532       INHERIT (to_has_execution, t);
 533       INHERIT (to_has_thread_control, t);
 534       INHERIT (to_sections, t);
 535       INHERIT (to_sections_end, t);
 536       INHERIT (to_magic, t);
 537
 538 #undef INHERIT
 539     }
 540 }
 541
 542 /* Push a new target type into the stack of the existing target accessors,
 543    possibly superseding some of the existing accessors.
 544
 545    Result is zero if the pushed target ended up on top of the stack,
 546    nonzero if at least one target is on top of it.
 547
 548    Rather than allow an empty stack, we always have the dummy target at
 549    the bottom stratum, so we can call the function vectors without
 550    checking them.  */
 551
 552 int
 553 push_target (t)
 554      struct target_ops *t;
 555 {
 556   struct target_stack_item *cur, *prev, *tmp;
 557
 558   /* Check magic number.  If wrong, it probably means someone changed
 559      the struct definition, but not all the places that initialize one.  */
 560   if (t->to_magic != OPS_MAGIC)
 561     {
 562       fprintf_unfiltered(gdb_stderr,
 563                          "Magic number of %s target struct wrong\n",
 564                          t->to_shortname);
 565       abort();
 566     }
 567
 568   /* Find the proper stratum to install this target in. */
 569
 570   for (prev = NULL, cur = target_stack; cur; prev = cur, cur = cur->next)
 571     {
 572       if ((int)(t->to_stratum) >= (int)(cur->target_ops->to_stratum))
 573         break;
 574     }
 575
 576   /* If there's already targets at this stratum, remove them. */
 577
 578   if (cur)
 579     while (t->to_stratum == cur->target_ops->to_stratum)
 580       {
 581         /* There's already something on this stratum.  Close it off.  */
 582         if (cur->target_ops->to_close)
 583           (cur->target_ops->to_close) (0);
 584         if (prev)
 585           prev->next = cur->next; /* Unchain old target_ops */
 586         else
 587           target_stack = cur->next; /* Unchain first on list */
 588         tmp = cur->next;
 589         free (cur);
 590         cur = tmp;
 591       }
 592
 593   /* We have removed all targets in our stratum, now add the new one.  */
 594
 595   tmp = (struct target_stack_item *)
 596     xmalloc (sizeof (struct target_stack_item));
 597   tmp->next = cur;
 598   tmp->target_ops = t;
 599
 600   if (prev)
 601     prev->next = tmp;
 602   else
 603     target_stack = tmp;
 604
 605   update_current_target ();
 606
 607   cleanup_target (&current_target); /* Fill in the gaps */
 608
 609   if (targetdebug)
 610     setup_target_debug ();
 611
 612   return prev != 0;
 613 }
 614
 615 /* Remove a target_ops vector from the stack, wherever it may be.
 616    Return how many times it was removed (0 or 1).  */
 617
 618 int
 619 unpush_target (t)
 620      struct target_ops *t;
 621 {
 622   struct target_stack_item *cur, *prev;
 623
 624   if (t->to_close)
 625     t->to_close (0);            /* Let it clean up */
 626
 627   /* Look for the specified target.  Note that we assume that a target
 628      can only occur once in the target stack. */
 629
 630   for (cur = target_stack, prev = NULL; cur; prev = cur, cur = cur->next)
 631     if (cur->target_ops == t)
 632       break;
 633
 634   if (!cur)
 635     return 0;                   /* Didn't find target_ops, quit now */
 636
 637   /* Unchain the target */
 638
 639   if (!prev)
 640     target_stack = cur->next;
 641   else
 642     prev->next = cur->next;
 643
 644   free (cur);                   /* Release the target_stack_item */
 645
 646   update_current_target ();
 647   cleanup_target (&current_target);
 648
 649   return 1;
 650 }
 651
 652 void
 653 pop_target ()
 654 {
 655   (current_target.to_close)(0); /* Let it clean up */
 656   if (unpush_target (target_stack->target_ops) == 1)
 657     return;
 658
 659   fprintf_unfiltered(gdb_stderr,
 660                      "pop_target couldn't find target %s\n",
 661                      current_target.to_shortname);
 662   abort();
 663 }
 664
 665 #undef  MIN
 666 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
 667
 668 /* target_read_string -- read a null terminated string, up to LEN bytes,
 669    from MEMADDR in target.  Set *ERRNOP to the errno code, or 0 if successful.
 670    Set *STRING to a pointer to malloc'd memory containing the data; the caller
 671    is responsible for freeing it.  Return the number of bytes successfully
 672    read.  */
 673
 674 int
 675 target_read_string (memaddr, string, len, errnop)
 676      CORE_ADDR memaddr;
 677      char **string;
 678      int len;
 679      int *errnop;
 680 {
 681   int tlen, origlen, offset, i;
 682   char buf[4];
 683   int errcode = 0;
 684   char *buffer;
 685   int buffer_allocated;
 686   char *bufptr;
 687   unsigned int nbytes_read = 0;
 688
 689   /* Small for testing.  */
 690   buffer_allocated = 4;
 691   buffer = xmalloc (buffer_allocated);
 692   bufptr = buffer;
 693
 694   origlen = len;
 695
 696   while (len > 0)
 697     {
 698       tlen = MIN (len, 4 - (memaddr & 3));
 699       offset = memaddr & 3;
 700
 701       errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0, NULL);
 702       if (errcode != 0)
 703         {
 704           /* The transfer request might have crossed the boundary to an
 705              unallocated region of memory. Retry the transfer, requesting
 706              a single byte.  */
 707           tlen = 1;
 708           offset = 0;
 709           errcode = target_xfer_memory (memaddr, buf, 1, 0, NULL);
 710           if (errcode != 0)
 711             goto done;
 712         }
 713
 714       if (bufptr - buffer + tlen > buffer_allocated)
 715         {
 716           unsigned int bytes;
 717           bytes = bufptr - buffer;
 718           buffer_allocated *= 2;
 719           buffer = xrealloc (buffer, buffer_allocated);
 720           bufptr = buffer + bytes;
 721         }
 722
 723       for (i = 0; i < tlen; i++)
 724         {
 725           *bufptr++ = buf[i + offset];
 726           if (buf[i + offset] == '\000')
 727             {
 728               nbytes_read += i + 1;
 729               goto done;
 730             }
 731         }
 732
 733       memaddr += tlen;
 734       len -= tlen;
 735       nbytes_read += tlen;
 736     }
 737  done:
 738   if (errnop != NULL)
 739     *errnop = errcode;
 740   if (string != NULL)
 741     *string = buffer;
 742   return nbytes_read;
 743 }
 744
 745 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
 746    GDB's memory at MYADDR.  Returns either 0 for success or an errno value
 747    if any error occurs.
 748
 749    If an error occurs, no guarantee is made about the contents of the data at
 750    MYADDR.  In particular, the caller should not depend upon partial reads
 751    filling the buffer with good data.  There is no way for the caller to know
 752    how much good data might have been transfered anyway.  Callers that can
 753    deal with partial reads should call target_read_memory_partial. */
 754
 755 int
 756 target_read_memory (memaddr, myaddr, len)
 757      CORE_ADDR memaddr;
 758      char *myaddr;
 759      int len;
 760 {
 761   return target_xfer_memory (memaddr, myaddr, len, 0, NULL);
 762 }
 763
 764 int
 765 target_read_memory_section (memaddr, myaddr, len, bfd_section)
 766      CORE_ADDR memaddr;
 767      char *myaddr;
 768      int len;
 769      asection *bfd_section;
 770 {
 771   return target_xfer_memory (memaddr, myaddr, len, 0, bfd_section);
 772 }
 773
 774 /* Read LEN bytes of target memory at address MEMADDR, placing the results
 775    in GDB's memory at MYADDR.  Returns a count of the bytes actually read,
 776    and optionally an errno value in the location pointed to by ERRNOPTR
 777    if ERRNOPTR is non-null. */
 778
 779 int
 780 target_read_memory_partial (memaddr, myaddr, len, errnoptr)
 781      CORE_ADDR memaddr;
 782      char *myaddr;
 783      int len;
 784      int *errnoptr;
 785 {
 786   int nread;    /* Number of bytes actually read. */
 787   int errcode;  /* Error from last read. */
 788
 789   /* First try a complete read. */
 790   errcode = target_xfer_memory (memaddr, myaddr, len, 0, NULL);
 791   if (errcode == 0)
 792     {
 793       /* Got it all. */
 794       nread = len;
 795     }
 796   else
 797     {
 798       /* Loop, reading one byte at a time until we get as much as we can. */
 799       for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
 800         {
 801           errcode = target_xfer_memory (memaddr++, myaddr++, 1, 0, NULL);
 802         }
 803       /* If an error, the last read was unsuccessful, so adjust count. */
 804       if (errcode != 0)
 805         {
 806           nread--;
 807         }
 808     }
 809   if (errnoptr != NULL)
 810     {
 811       *errnoptr = errcode;
 812     }
 813   return (nread);
 814 }
 815
 816 int
 817 target_write_memory (memaddr, myaddr, len)
 818      CORE_ADDR memaddr;
 819      char *myaddr;
 820      int len;
 821 {
 822   return target_xfer_memory (memaddr, myaddr, len, 1, NULL);
 823 }
 824
 825 /* This variable is used to pass section information down to targets.  This
 826    *should* be done by adding an argument to the target_xfer_memory function
 827    of all the targets, but I didn't feel like changing 50+ files.  */
 828
 829 asection *target_memory_bfd_section = NULL;
 830
 831 /* Move memory to or from the targets.  Iterate until all of it has
 832    been moved, if necessary.  The top target gets priority; anything
 833    it doesn't want, is offered to the next one down, etc.  Note the
 834    business with curlen:  if an early target says "no, but I have a
 835    boundary overlapping this xfer" then we shorten what we offer to
 836    the subsequent targets so the early guy will get a chance at the
 837    tail before the subsequent ones do.
 838
 839    Result is 0 or errno value.  */
 840
 841 static int
 842 target_xfer_memory (memaddr, myaddr, len, write, bfd_section)
 843      CORE_ADDR memaddr;
 844      char *myaddr;
 845      int len;
 846      int write;
 847      asection *bfd_section;
 848 {
 849   int curlen;
 850   int res;
 851   struct target_ops *t;
 852   struct target_stack_item *item;
 853
 854   /* Zero length requests are ok and require no work.  */
 855   if (len == 0)
 856     return 0;
 857
 858   target_memory_bfd_section = bfd_section;
 859
 860   /* to_xfer_memory is not guaranteed to set errno, even when it returns
 861      0.  */
 862   errno = 0;
 863
 864   /* The quick case is that the top target does it all.  */
 865   res = current_target.to_xfer_memory
 866                         (memaddr, myaddr, len, write, &current_target);
 867   if (res == len)
 868     return 0;
 869
 870   if (res > 0)
 871     goto bump;
 872   /* If res <= 0 then we call it again in the loop.  Ah well.  */
 873
 874   for (; len > 0;)
 875     {
 876       curlen = len;             /* Want to do it all */
 877       for (item = target_stack; item; item = item->next)
 878         {
 879           t = item->target_ops;
 880           if (!t->to_has_memory)
 881             continue;
 882
 883           res = t->to_xfer_memory (memaddr, myaddr, curlen, write, t);
 884           if (res > 0)
 885             break;              /* Handled all or part of xfer */
 886           if (t->to_has_all_memory)
 887             break;
 888         }
 889
 890       if (res <= 0)
 891         {
 892           /* If this address is for nonexistent memory,
 893              read zeros if reading, or do nothing if writing.  Return error. */
 894           if (!write)
 895             memset (myaddr, 0, len);
 896           if (errno == 0)
 897             return EIO;
 898           else
 899             return errno;
 900         }
 901 bump:
 902       memaddr += res;
 903       myaddr  += res;
 904       len     -= res;
 905     }
 906   return 0;                     /* We managed to cover it all somehow. */
 907 }
 908
 909
 910 /* ARGSUSED */
 911 static void
 912 target_info (args, from_tty)
 913      char *args;
 914      int from_tty;
 915 {
 916   struct target_ops *t;
 917   struct target_stack_item *item;
 918   int has_all_mem = 0;
 919
 920   if (symfile_objfile != NULL)
 921     printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
 922
 923 #ifdef FILES_INFO_HOOK
 924   if (FILES_INFO_HOOK ())
 925     return;
 926 #endif
 927
 928   for (item = target_stack; item; item = item->next)
 929     {
 930       t = item->target_ops;
 931
 932       if (!t->to_has_memory)
 933         continue;
 934
 935       if ((int)(t->to_stratum) <= (int)dummy_stratum)
 936         continue;
 937       if (has_all_mem)
 938         printf_unfiltered("\tWhile running this, GDB does not access memory from...\n");
 939       printf_unfiltered("%s:\n", t->to_longname);
 940       (t->to_files_info)(t);
 941       has_all_mem = t->to_has_all_memory;
 942     }
 943 }
 944
 945 /* This is to be called by the open routine before it does
 946    anything.  */
 947
 948 void
 949 target_preopen (from_tty)
 950      int from_tty;
 951 {
 952   dont_repeat();
 953
 954   if (target_has_execution)
 955     {
 956       if (query ("A program is being debugged already.  Kill it? "))
 957         target_kill ();
 958       else
 959         error ("Program not killed.");
 960     }
 961
 962   /* Calling target_kill may remove the target from the stack.  But if
 963      it doesn't (which seems like a win for UDI), remove it now.  */
 964
 965   if (target_has_execution)
 966     pop_target ();
 967 }
 968
 969 /* Detach a target after doing deferred register stores.  */
 970
 971 void
 972 target_detach (args, from_tty)
 973      char *args;
 974      int from_tty;
 975 {
 976   /* Handle any optimized stores to the inferior.  */
 977 #ifdef DO_DEFERRED_STORES
 978   DO_DEFERRED_STORES;
 979 #endif
 980   (current_target.to_detach) (args, from_tty);
 981 }
 982
 983 void
 984 target_link (modname, t_reloc)
 985      char *modname;
 986      CORE_ADDR *t_reloc;
 987 {
 988   if (STREQ(current_target.to_shortname, "rombug"))
 989     {
 990       (current_target.to_lookup_symbol) (modname, t_reloc);
 991       if (*t_reloc == 0)
 992       error("Unable to link to %s and get relocation in rombug", modname);
 993     }
 994   else
 995     *t_reloc = (CORE_ADDR)-1;
 996 }
 997
 998 /* Look through the list of possible targets for a target that can
 999    execute a run or attach command without any other data.  This is
1000    used to locate the default process stratum.
1001
1002    Result is always valid (error() is called for errors).  */
1003
1004 static struct target_ops *
1005 find_default_run_target (do_mesg)
1006      char *do_mesg;
1007 {
1008   struct target_ops **t;
1009   struct target_ops *runable = NULL;
1010   int count;
1011
1012   count = 0;
1013
1014   for (t = target_structs; t < target_structs + target_struct_size;
1015        ++t)
1016     {
1017       if ((*t)->to_can_run && target_can_run(*t))
1018         {
1019           runable = *t;
1020           ++count;
1021         }
1022     }
1023
1024   if (count != 1)
1025     error ("Don't know how to %s.  Try \"help target\".", do_mesg);
1026
1027   return runable;
1028 }
1029
1030 void
1031 find_default_attach (args, from_tty)
1032      char *args;
1033      int from_tty;
1034 {
1035   struct target_ops *t;
1036
1037   t = find_default_run_target("attach");
1038   (t->to_attach) (args, from_tty);
1039   return;
1040 }
1041
1042 void
1043 find_default_require_attach (args, from_tty)
1044      char *args;
1045      int from_tty;
1046 {
1047   struct target_ops *t;
1048
1049   t = find_default_run_target("require_attach");
1050   (t->to_require_attach) (args, from_tty);
1051   return;
1052 }
1053
1054 void
1055 find_default_require_detach (pid, args, from_tty)
1056   int  pid;
1057   char *  args;
1058   int  from_tty;
1059 {
1060   struct target_ops *t;
1061
1062   t = find_default_run_target("require_detach");
1063   (t->to_require_detach) (pid, args, from_tty);
1064   return;
1065 }
1066
1067 void
1068 find_default_create_inferior (exec_file, allargs, env)
1069      char *exec_file;
1070      char *allargs;
1071      char **env;
1072 {
1073   struct target_ops *t;
1074
1075   t = find_default_run_target("run");
1076   (t->to_create_inferior) (exec_file, allargs, env);
1077   return;
1078 }
1079
1080 void
1081 find_default_clone_and_follow_inferior (child_pid, followed_child)
1082   int  child_pid;
1083   int  *followed_child;
1084 {
1085   struct target_ops *t;
1086
1087   t = find_default_run_target("run");
1088   (t->to_clone_and_follow_inferior) (child_pid, followed_child);
1089   return;
1090 }
1091
1092 static int
1093 return_zero ()
1094 {
1095   return 0;
1096 }
1097
1098 static int
1099 return_one ()
1100 {
1101   return 1;
1102 }
1103
1104 /* Find a single runnable target in the stack and return it.  If for
1105    some reason there is more than one, return NULL.  */
1106
1107 struct target_ops *
1108 find_run_target ()
1109 {
1110   struct target_ops **t;
1111   struct target_ops *runable = NULL;
1112   int count;
1113
1114   count = 0;
1115
1116   for (t = target_structs; t < target_structs + target_struct_size; ++t)
1117     {
1118       if ((*t)->to_can_run && target_can_run(*t))
1119         {
1120           runable = *t;
1121           ++count;
1122         }
1123     }
1124
1125   return (count == 1 ? runable : NULL);
1126 }
1127
1128 struct target_ops *
1129 find_core_target ()
1130 {
1131   struct target_ops **t;
1132   struct target_ops *runable = NULL;
1133   int count;
1134
1135   count = 0;
1136
1137   for (t = target_structs; t < target_structs + target_struct_size;
1138        ++t)
1139     {
1140       if ((*t)->to_stratum == core_stratum)
1141         {
1142           runable = *t;
1143           ++count;
1144         }
1145     }
1146
1147   return(count == 1 ? runable : NULL);
1148 }
1149 \f
1150 /* The inferior process has died.  Long live the inferior!  */
1151
1152 void
1153 generic_mourn_inferior ()
1154 {
1155   extern int show_breakpoint_hit_counts;
1156
1157   inferior_pid = 0;
1158   attach_flag = 0;
1159   breakpoint_init_inferior (inf_exited);
1160   registers_changed ();
1161
1162 #ifdef CLEAR_DEFERRED_STORES
1163   /* Delete any pending stores to the inferior... */
1164   CLEAR_DEFERRED_STORES;
1165 #endif
1166
1167   reopen_exec_file ();
1168   reinit_frame_cache ();
1169
1170   /* It is confusing to the user for ignore counts to stick around
1171      from previous runs of the inferior.  So clear them.  */
1172   /* However, it is more confusing for the ignore counts to disappear when
1173      using hit counts.  So don't clear them if we're counting hits.  */
1174   if (!show_breakpoint_hit_counts)
1175     breakpoint_clear_ignore_counts ();
1176 }
1177 \f
1178 /* This table must match in order and size the signals in enum target_signal
1179    in target.h.  */
1180 static struct {
1181   char *name;
1182   char *string;
1183   } signals [] =
1184 {
1185   {"0", "Signal 0"},
1186   {"SIGHUP", "Hangup"},
1187   {"SIGINT", "Interrupt"},
1188   {"SIGQUIT", "Quit"},
1189   {"SIGILL", "Illegal instruction"},
1190   {"SIGTRAP", "Trace/breakpoint trap"},
1191   {"SIGABRT", "Aborted"},
1192   {"SIGEMT", "Emulation trap"},
1193   {"SIGFPE", "Arithmetic exception"},
1194   {"SIGKILL", "Killed"},
1195   {"SIGBUS", "Bus error"},
1196   {"SIGSEGV", "Segmentation fault"},
1197   {"SIGSYS", "Bad system call"},
1198   {"SIGPIPE", "Broken pipe"},
1199   {"SIGALRM", "Alarm clock"},
1200   {"SIGTERM", "Terminated"},
1201   {"SIGURG", "Urgent I/O condition"},
1202   {"SIGSTOP", "Stopped (signal)"},
1203   {"SIGTSTP", "Stopped (user)"},
1204   {"SIGCONT", "Continued"},
1205   {"SIGCHLD", "Child status changed"},
1206   {"SIGTTIN", "Stopped (tty input)"},
1207   {"SIGTTOU", "Stopped (tty output)"},
1208   {"SIGIO", "I/O possible"},
1209   {"SIGXCPU", "CPU time limit exceeded"},
1210   {"SIGXFSZ", "File size limit exceeded"},
1211   {"SIGVTALRM", "Virtual timer expired"},
1212   {"SIGPROF", "Profiling timer expired"},
1213   {"SIGWINCH", "Window size changed"},
1214   {"SIGLOST", "Resource lost"},
1215   {"SIGUSR1", "User defined signal 1"},
1216   {"SIGUSR2", "User defined signal 2"},
1217   {"SIGPWR", "Power fail/restart"},
1218   {"SIGPOLL", "Pollable event occurred"},
1219   {"SIGWIND", "SIGWIND"},
1220   {"SIGPHONE", "SIGPHONE"},
1221   {"SIGWAITING", "Process's LWPs are blocked"},
1222   {"SIGLWP", "Signal LWP"},
1223   {"SIGDANGER", "Swap space dangerously low"},
1224   {"SIGGRANT", "Monitor mode granted"},
1225   {"SIGRETRACT", "Need to relinquish monitor mode"},
1226   {"SIGMSG", "Monitor mode data available"},
1227   {"SIGSOUND", "Sound completed"},
1228   {"SIGSAK", "Secure attention"},
1229   {"SIGPRIO", "SIGPRIO"},
1230   {"SIG33", "Real-time event 33"},
1231   {"SIG34", "Real-time event 34"},
1232   {"SIG35", "Real-time event 35"},
1233   {"SIG36", "Real-time event 36"},
1234   {"SIG37", "Real-time event 37"},
1235   {"SIG38", "Real-time event 38"},
1236   {"SIG39", "Real-time event 39"},
1237   {"SIG40", "Real-time event 40"},
1238   {"SIG41", "Real-time event 41"},
1239   {"SIG42", "Real-time event 42"},
1240   {"SIG43", "Real-time event 43"},
1241   {"SIG44", "Real-time event 44"},
1242   {"SIG45", "Real-time event 45"},
1243   {"SIG46", "Real-time event 46"},
1244   {"SIG47", "Real-time event 47"},
1245   {"SIG48", "Real-time event 48"},
1246   {"SIG49", "Real-time event 49"},
1247   {"SIG50", "Real-time event 50"},
1248   {"SIG51", "Real-time event 51"},
1249   {"SIG52", "Real-time event 52"},
1250   {"SIG53", "Real-time event 53"},
1251   {"SIG54", "Real-time event 54"},
1252   {"SIG55", "Real-time event 55"},
1253   {"SIG56", "Real-time event 56"},
1254   {"SIG57", "Real-time event 57"},
1255   {"SIG58", "Real-time event 58"},
1256   {"SIG59", "Real-time event 59"},
1257   {"SIG60", "Real-time event 60"},
1258   {"SIG61", "Real-time event 61"},
1259   {"SIG62", "Real-time event 62"},
1260   {"SIG63", "Real-time event 63"},
1261
1262 #if defined(MACH) || defined(__MACH__)
1263   /* Mach exceptions */
1264   {"EXC_BAD_ACCESS", "Could not access memory"},
1265   {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
1266   {"EXC_ARITHMETIC", "Arithmetic exception"},
1267   {"EXC_EMULATION", "Emulation instruction"},
1268   {"EXC_SOFTWARE", "Software generated exception"},
1269   {"EXC_BREAKPOINT", "Breakpoint"},
1270 #endif
1271   {"SIGINFO", "Information request"},
1272
1273   {NULL, "Unknown signal"},
1274   {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
1275
1276   /* Last entry, used to check whether the table is the right size.  */
1277   {NULL, "TARGET_SIGNAL_MAGIC"}
1278 };
1279
1280 /* Return the string for a signal.  */
1281 char *
1282 target_signal_to_string (sig)
1283      enum target_signal sig;
1284 {
1285   if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST))
1286     return signals[sig].string;
1287   else
1288     return signals[TARGET_SIGNAL_UNKNOWN].string;
1289 }
1290
1291 /* Return the name for a signal.  */
1292 char *
1293 target_signal_to_name (sig)
1294      enum target_signal sig;
1295 {
1296   if (sig == TARGET_SIGNAL_UNKNOWN)
1297     /* I think the code which prints this will always print it along with
1298        the string, so no need to be verbose.  */
1299     return "?";
1300   return signals[sig].name;
1301 }
1302
1303 /* Given a name, return its signal.  */
1304 enum target_signal
1305 target_signal_from_name (name)
1306      char *name;
1307 {
1308   enum target_signal sig;
1309
1310   /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
1311      for TARGET_SIGNAL_SIGCHLD.  SIGIOT, on the other hand, is more
1312      questionable; seems like by now people should call it SIGABRT
1313      instead.  */
1314
1315   /* This ugly cast brought to you by the native VAX compiler.  */
1316   for (sig = TARGET_SIGNAL_HUP;
1317        signals[sig].name != NULL;
1318        sig = (enum target_signal)((int)sig + 1))
1319     if (STREQ (name, signals[sig].name))
1320       return sig;
1321   return TARGET_SIGNAL_UNKNOWN;
1322 }
1323 \f
1324 /* The following functions are to help certain targets deal
1325    with the signal/waitstatus stuff.  They could just as well be in
1326    a file called native-utils.c or unixwaitstatus-utils.c or whatever.  */
1327
1328 /* Convert host signal to our signals.  */
1329 enum target_signal
1330 target_signal_from_host (hostsig)
1331      int hostsig;
1332 {
1333   /* A switch statement would make sense but would require special kludges
1334      to deal with the cases where more than one signal has the same number.  */
1335
1336   if (hostsig == 0) return TARGET_SIGNAL_0;
1337
1338 #if defined (SIGHUP)
1339   if (hostsig == SIGHUP) return TARGET_SIGNAL_HUP;
1340 #endif
1341 #if defined (SIGINT)
1342   if (hostsig == SIGINT) return TARGET_SIGNAL_INT;
1343 #endif
1344 #if defined (SIGQUIT)
1345   if (hostsig == SIGQUIT) return TARGET_SIGNAL_QUIT;
1346 #endif
1347 #if defined (SIGILL)
1348   if (hostsig == SIGILL) return TARGET_SIGNAL_ILL;
1349 #endif
1350 #if defined (SIGTRAP)
1351   if (hostsig == SIGTRAP) return TARGET_SIGNAL_TRAP;
1352 #endif
1353 #if defined (SIGABRT)
1354   if (hostsig == SIGABRT) return TARGET_SIGNAL_ABRT;
1355 #endif
1356 #if defined (SIGEMT)
1357   if (hostsig == SIGEMT) return TARGET_SIGNAL_EMT;
1358 #endif
1359 #if defined (SIGFPE)
1360   if (hostsig == SIGFPE) return TARGET_SIGNAL_FPE;
1361 #endif
1362 #if defined (SIGKILL)
1363   if (hostsig == SIGKILL) return TARGET_SIGNAL_KILL;
1364 #endif
1365 #if defined (SIGBUS)
1366   if (hostsig == SIGBUS) return TARGET_SIGNAL_BUS;
1367 #endif
1368 #if defined (SIGSEGV)
1369   if (hostsig == SIGSEGV) return TARGET_SIGNAL_SEGV;
1370 #endif
1371 #if defined (SIGSYS)
1372   if (hostsig == SIGSYS) return TARGET_SIGNAL_SYS;
1373 #endif
1374 #if defined (SIGPIPE)
1375   if (hostsig == SIGPIPE) return TARGET_SIGNAL_PIPE;
1376 #endif
1377 #if defined (SIGALRM)
1378   if (hostsig == SIGALRM) return TARGET_SIGNAL_ALRM;
1379 #endif
1380 #if defined (SIGTERM)
1381   if (hostsig == SIGTERM) return TARGET_SIGNAL_TERM;
1382 #endif
1383 #if defined (SIGUSR1)
1384   if (hostsig == SIGUSR1) return TARGET_SIGNAL_USR1;
1385 #endif
1386 #if defined (SIGUSR2)
1387   if (hostsig == SIGUSR2) return TARGET_SIGNAL_USR2;
1388 #endif
1389 #if defined (SIGCLD)
1390   if (hostsig == SIGCLD) return TARGET_SIGNAL_CHLD;
1391 #endif
1392 #if defined (SIGCHLD)
1393   if (hostsig == SIGCHLD) return TARGET_SIGNAL_CHLD;
1394 #endif
1395 #if defined (SIGPWR)
1396   if (hostsig == SIGPWR) return TARGET_SIGNAL_PWR;
1397 #endif
1398 #if defined (SIGWINCH)
1399   if (hostsig == SIGWINCH) return TARGET_SIGNAL_WINCH;
1400 #endif
1401 #if defined (SIGURG)
1402   if (hostsig == SIGURG) return TARGET_SIGNAL_URG;
1403 #endif
1404 #if defined (SIGIO)
1405   if (hostsig == SIGIO) return TARGET_SIGNAL_IO;
1406 #endif
1407 #if defined (SIGPOLL)
1408   if (hostsig == SIGPOLL) return TARGET_SIGNAL_POLL;
1409 #endif
1410 #if defined (SIGSTOP)
1411   if (hostsig == SIGSTOP) return TARGET_SIGNAL_STOP;
1412 #endif
1413 #if defined (SIGTSTP)
1414   if (hostsig == SIGTSTP) return TARGET_SIGNAL_TSTP;
1415 #endif
1416 #if defined (SIGCONT)
1417   if (hostsig == SIGCONT) return TARGET_SIGNAL_CONT;
1418 #endif
1419 #if defined (SIGTTIN)
1420   if (hostsig == SIGTTIN) return TARGET_SIGNAL_TTIN;
1421 #endif
1422 #if defined (SIGTTOU)
1423   if (hostsig == SIGTTOU) return TARGET_SIGNAL_TTOU;
1424 #endif
1425 #if defined (SIGVTALRM)
1426   if (hostsig == SIGVTALRM) return TARGET_SIGNAL_VTALRM;
1427 #endif
1428 #if defined (SIGPROF)
1429   if (hostsig == SIGPROF) return TARGET_SIGNAL_PROF;
1430 #endif
1431 #if defined (SIGXCPU)
1432   if (hostsig == SIGXCPU) return TARGET_SIGNAL_XCPU;
1433 #endif
1434 #if defined (SIGXFSZ)
1435   if (hostsig == SIGXFSZ) return TARGET_SIGNAL_XFSZ;
1436 #endif
1437 #if defined (SIGWIND)
1438   if (hostsig == SIGWIND) return TARGET_SIGNAL_WIND;
1439 #endif
1440 #if defined (SIGPHONE)
1441   if (hostsig == SIGPHONE) return TARGET_SIGNAL_PHONE;
1442 #endif
1443 #if defined (SIGLOST)
1444   if (hostsig == SIGLOST) return TARGET_SIGNAL_LOST;
1445 #endif
1446 #if defined (SIGWAITING)
1447   if (hostsig == SIGWAITING) return TARGET_SIGNAL_WAITING;
1448 #endif
1449 #if defined (SIGLWP)
1450   if (hostsig == SIGLWP) return TARGET_SIGNAL_LWP;
1451 #endif
1452 #if defined (SIGDANGER)
1453   if (hostsig == SIGDANGER) return TARGET_SIGNAL_DANGER;
1454 #endif
1455 #if defined (SIGGRANT)
1456   if (hostsig == SIGGRANT) return TARGET_SIGNAL_GRANT;
1457 #endif
1458 #if defined (SIGRETRACT)
1459   if (hostsig == SIGRETRACT) return TARGET_SIGNAL_RETRACT;
1460 #endif
1461 #if defined (SIGMSG)
1462   if (hostsig == SIGMSG) return TARGET_SIGNAL_MSG;
1463 #endif
1464 #if defined (SIGSOUND)
1465   if (hostsig == SIGSOUND) return TARGET_SIGNAL_SOUND;
1466 #endif
1467 #if defined (SIGSAK)
1468   if (hostsig == SIGSAK) return TARGET_SIGNAL_SAK;
1469 #endif
1470 #if defined (SIGPRIO)
1471   if (hostsig == SIGPRIO) return TARGET_SIGNAL_PRIO;
1472 #endif
1473
1474   /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
1475 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1476   if (hostsig == _NSIG + EXC_BAD_ACCESS) return TARGET_EXC_BAD_ACCESS;
1477 #endif
1478 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1479   if (hostsig == _NSIG + EXC_BAD_INSTRUCTION) return TARGET_EXC_BAD_INSTRUCTION;
1480 #endif
1481 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1482   if (hostsig == _NSIG + EXC_ARITHMETIC) return TARGET_EXC_ARITHMETIC;
1483 #endif
1484 #if defined (EXC_EMULATION) && defined (_NSIG)
1485   if (hostsig == _NSIG + EXC_EMULATION) return TARGET_EXC_EMULATION;
1486 #endif
1487 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1488   if (hostsig == _NSIG + EXC_SOFTWARE) return TARGET_EXC_SOFTWARE;
1489 #endif
1490 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1491   if (hostsig == _NSIG + EXC_BREAKPOINT) return TARGET_EXC_BREAKPOINT;
1492 #endif
1493
1494 #if defined (SIGINFO)
1495   if (hostsig == SIGINFO) return TARGET_SIGNAL_INFO;
1496 #endif
1497
1498 #if defined (REALTIME_LO)
1499   if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
1500     return (enum target_signal)
1501       (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
1502 #endif
1503   return TARGET_SIGNAL_UNKNOWN;
1504 }
1505
1506 int
1507 target_signal_to_host (oursig)
1508      enum target_signal oursig;
1509 {
1510   switch (oursig)
1511     {
1512     case TARGET_SIGNAL_0: return 0;
1513
1514 #if defined (SIGHUP)
1515     case TARGET_SIGNAL_HUP: return SIGHUP;
1516 #endif
1517 #if defined (SIGINT)
1518     case TARGET_SIGNAL_INT: return SIGINT;
1519 #endif
1520 #if defined (SIGQUIT)
1521     case TARGET_SIGNAL_QUIT: return SIGQUIT;
1522 #endif
1523 #if defined (SIGILL)
1524     case TARGET_SIGNAL_ILL: return SIGILL;
1525 #endif
1526 #if defined (SIGTRAP)
1527     case TARGET_SIGNAL_TRAP: return SIGTRAP;
1528 #endif
1529 #if defined (SIGABRT)
1530     case TARGET_SIGNAL_ABRT: return SIGABRT;
1531 #endif
1532 #if defined (SIGEMT)
1533     case TARGET_SIGNAL_EMT: return SIGEMT;
1534 #endif
1535 #if defined (SIGFPE)
1536     case TARGET_SIGNAL_FPE: return SIGFPE;
1537 #endif
1538 #if defined (SIGKILL)
1539     case TARGET_SIGNAL_KILL: return SIGKILL;
1540 #endif
1541 #if defined (SIGBUS)
1542     case TARGET_SIGNAL_BUS: return SIGBUS;
1543 #endif
1544 #if defined (SIGSEGV)
1545     case TARGET_SIGNAL_SEGV: return SIGSEGV;
1546 #endif
1547 #if defined (SIGSYS)
1548     case TARGET_SIGNAL_SYS: return SIGSYS;
1549 #endif
1550 #if defined (SIGPIPE)
1551     case TARGET_SIGNAL_PIPE: return SIGPIPE;
1552 #endif
1553 #if defined (SIGALRM)
1554     case TARGET_SIGNAL_ALRM: return SIGALRM;
1555 #endif
1556 #if defined (SIGTERM)
1557     case TARGET_SIGNAL_TERM: return SIGTERM;
1558 #endif
1559 #if defined (SIGUSR1)
1560     case TARGET_SIGNAL_USR1: return SIGUSR1;
1561 #endif
1562 #if defined (SIGUSR2)
1563     case TARGET_SIGNAL_USR2: return SIGUSR2;
1564 #endif
1565 #if defined (SIGCHLD) || defined (SIGCLD)
1566     case TARGET_SIGNAL_CHLD:
1567 #if defined (SIGCHLD)
1568       return SIGCHLD;
1569 #else
1570       return SIGCLD;
1571 #endif
1572 #endif /* SIGCLD or SIGCHLD */
1573 #if defined (SIGPWR)
1574     case TARGET_SIGNAL_PWR: return SIGPWR;
1575 #endif
1576 #if defined (SIGWINCH)
1577     case TARGET_SIGNAL_WINCH: return SIGWINCH;
1578 #endif
1579 #if defined (SIGURG)
1580     case TARGET_SIGNAL_URG: return SIGURG;
1581 #endif
1582 #if defined (SIGIO)
1583     case TARGET_SIGNAL_IO: return SIGIO;
1584 #endif
1585 #if defined (SIGPOLL)
1586     case TARGET_SIGNAL_POLL: return SIGPOLL;
1587 #endif
1588 #if defined (SIGSTOP)
1589     case TARGET_SIGNAL_STOP: return SIGSTOP;
1590 #endif
1591 #if defined (SIGTSTP)
1592     case TARGET_SIGNAL_TSTP: return SIGTSTP;
1593 #endif
1594 #if defined (SIGCONT)
1595     case TARGET_SIGNAL_CONT: return SIGCONT;
1596 #endif
1597 #if defined (SIGTTIN)
1598     case TARGET_SIGNAL_TTIN: return SIGTTIN;
1599 #endif
1600 #if defined (SIGTTOU)
1601     case TARGET_SIGNAL_TTOU: return SIGTTOU;
1602 #endif
1603 #if defined (SIGVTALRM)
1604     case TARGET_SIGNAL_VTALRM: return SIGVTALRM;
1605 #endif
1606 #if defined (SIGPROF)
1607     case TARGET_SIGNAL_PROF: return SIGPROF;
1608 #endif
1609 #if defined (SIGXCPU)
1610     case TARGET_SIGNAL_XCPU: return SIGXCPU;
1611 #endif
1612 #if defined (SIGXFSZ)
1613     case TARGET_SIGNAL_XFSZ: return SIGXFSZ;
1614 #endif
1615 #if defined (SIGWIND)
1616     case TARGET_SIGNAL_WIND: return SIGWIND;
1617 #endif
1618 #if defined (SIGPHONE)
1619     case TARGET_SIGNAL_PHONE: return SIGPHONE;
1620 #endif
1621 #if defined (SIGLOST)
1622     case TARGET_SIGNAL_LOST: return SIGLOST;
1623 #endif
1624 #if defined (SIGWAITING)
1625     case TARGET_SIGNAL_WAITING: return SIGWAITING;
1626 #endif
1627 #if defined (SIGLWP)
1628     case TARGET_SIGNAL_LWP: return SIGLWP;
1629 #endif
1630 #if defined (SIGDANGER)
1631     case TARGET_SIGNAL_DANGER: return SIGDANGER;
1632 #endif
1633 #if defined (SIGGRANT)
1634     case TARGET_SIGNAL_GRANT: return SIGGRANT;
1635 #endif
1636 #if defined (SIGRETRACT)
1637     case TARGET_SIGNAL_RETRACT: return SIGRETRACT;
1638 #endif
1639 #if defined (SIGMSG)
1640     case TARGET_SIGNAL_MSG: return SIGMSG;
1641 #endif
1642 #if defined (SIGSOUND)
1643     case TARGET_SIGNAL_SOUND: return SIGSOUND;
1644 #endif
1645 #if defined (SIGSAK)
1646     case TARGET_SIGNAL_SAK: return SIGSAK;
1647 #endif
1648 #if defined (SIGPRIO)
1649     case TARGET_SIGNAL_PRIO: return SIGPRIO;
1650 #endif
1651
1652       /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
1653 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
1654     case TARGET_EXC_BAD_ACCESS: return _NSIG + EXC_BAD_ACCESS;
1655 #endif
1656 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
1657     case TARGET_EXC_BAD_INSTRUCTION: return _NSIG + EXC_BAD_INSTRUCTION;
1658 #endif
1659 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
1660     case TARGET_EXC_ARITHMETIC: return _NSIG + EXC_ARITHMETIC;
1661 #endif
1662 #if defined (EXC_EMULATION) && defined (_NSIG)
1663     case TARGET_EXC_EMULATION: return _NSIG + EXC_EMULATION;
1664 #endif
1665 #if defined (EXC_SOFTWARE) && defined (_NSIG)
1666     case TARGET_EXC_SOFTWARE: return _NSIG + EXC_SOFTWARE;
1667 #endif
1668 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
1669     case TARGET_EXC_BREAKPOINT: return _NSIG + EXC_BREAKPOINT;
1670 #endif
1671
1672 #if defined (SIGINFO)
1673     case TARGET_SIGNAL_INFO: return SIGINFO;
1674 #endif
1675
1676     default:
1677 #if defined (REALTIME_LO)
1678       if (oursig >= TARGET_SIGNAL_REALTIME_33
1679           && oursig <= TARGET_SIGNAL_REALTIME_63)
1680         {
1681           int retsig =
1682             (int)oursig - (int)TARGET_SIGNAL_REALTIME_33 + REALTIME_LO;
1683           if (retsig < REALTIME_HI)
1684             return retsig;
1685         }
1686 #endif
1687       /* The user might be trying to do "signal SIGSAK" where this system
1688          doesn't have SIGSAK.  */
1689       warning ("Signal %s does not exist on this system.\n",
1690                target_signal_to_name (oursig));
1691       return 0;
1692     }
1693 }
1694
1695 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1696    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1697    translation of that in OURSTATUS.  */
1698 void
1699 store_waitstatus (ourstatus, hoststatus)
1700      struct target_waitstatus *ourstatus;
1701      int hoststatus;
1702 {
1703 #ifdef CHILD_SPECIAL_WAITSTATUS
1704   /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1705      if it wants to deal with hoststatus.  */
1706   if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
1707     return;
1708 #endif
1709
1710   if (WIFEXITED (hoststatus))
1711     {
1712       ourstatus->kind = TARGET_WAITKIND_EXITED;
1713       ourstatus->value.integer = WEXITSTATUS (hoststatus);
1714     }
1715   else if (!WIFSTOPPED (hoststatus))
1716     {
1717       ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1718       ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
1719     }
1720   else
1721     {
1722       ourstatus->kind = TARGET_WAITKIND_STOPPED;
1723       ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
1724     }
1725 }
1726 \f
1727 /* In some circumstances we allow a command to specify a numeric
1728    signal.  The idea is to keep these circumstances limited so that
1729    users (and scripts) develop portable habits.  For comparison,
1730    POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
1731    numeric signal at all is obscelescent.  We are slightly more
1732    lenient and allow 1-15 which should match host signal numbers on
1733    most systems.  Use of symbolic signal names is strongly encouraged.  */
1734
1735 enum target_signal
1736 target_signal_from_command (num)
1737      int num;
1738 {
1739   if (num >= 1 && num <= 15)
1740     return (enum target_signal)num;
1741   error ("Only signals 1-15 are valid as numeric signals.\n\
1742 Use \"info signals\" for a list of symbolic signals.");
1743 }
1744 \f
1745 /* Returns zero to leave the inferior alone, one to interrupt it.  */
1746 int (*target_activity_function) PARAMS ((void));
1747 int target_activity_fd;
1748 \f
1749 /* Convert a normal process ID to a string.  Returns the string in a static
1750    buffer.  */
1751
1752 char *
1753 normal_pid_to_str (pid)
1754      int pid;
1755 {
1756   static char buf[30];
1757
1758   if (STREQ (current_target.to_shortname, "remote"))
1759     sprintf (buf, "thread %d\0", pid);
1760   else
1761     sprintf (buf, "process %d\0", pid);
1762
1763   return buf;
1764 }
1765
1766 /* Some targets (such as ttrace-based HPUX) don't allow us to request
1767    notification of inferior events such as fork and vork immediately
1768    after the inferior is created.  (This because of how gdb gets an
1769    inferior created via invoking a shell to do it.  In such a scenario,
1770    if the shell init file has commands in it, the shell will fork and
1771    exec for each of those commands, and we will see each such fork
1772    event.  Very bad.)
1773
1774    This function is used by all targets that allow us to request
1775    notification of forks, etc at inferior creation time; e.g., in
1776    target_acknowledge_forked_child.
1777    */
1778 void
1779 normal_target_post_startup_inferior (pid)
1780   int  pid;
1781 {
1782   /* This space intentionally left blank. */
1783 }
1784
1785 /* Set up the handful of non-empty slots needed by the dummy target
1786    vector.  */
1787
1788 static void
1789 init_dummy_target ()
1790 {
1791   dummy_target.to_shortname = "None";
1792   dummy_target.to_longname = "None";
1793   dummy_target.to_doc = "";
1794   dummy_target.to_attach = find_default_attach;
1795   dummy_target.to_require_attach = find_default_require_attach;
1796   dummy_target.to_require_detach = find_default_require_detach;
1797   dummy_target.to_create_inferior = find_default_create_inferior;
1798   dummy_target.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
1799   dummy_target.to_stratum = dummy_stratum;
1800   dummy_target.to_magic = OPS_MAGIC;
1801 }
1802
1803 \f
1804 static struct target_ops debug_target;
1805
1806 static void
1807 debug_to_open (args, from_tty)
1808      char *args;
1809      int from_tty;
1810 {
1811   debug_target.to_open (args, from_tty);
1812
1813   fprintf_unfiltered (gdb_stderr, "target_open (%s, %d)\n", args, from_tty);
1814 }
1815
1816 static void
1817 debug_to_close (quitting)
1818      int quitting;
1819 {
1820   debug_target.to_close (quitting);
1821
1822   fprintf_unfiltered (gdb_stderr, "target_close (%d)\n", quitting);
1823 }
1824
1825 static void
1826 debug_to_attach (args, from_tty)
1827      char *args;
1828      int from_tty;
1829 {
1830   debug_target.to_attach (args, from_tty);
1831
1832   fprintf_unfiltered (gdb_stderr, "target_attach (%s, %d)\n", args, from_tty);
1833 }
1834
1835
1836 static void
1837 debug_to_post_attach (pid)
1838   int  pid;
1839 {
1840   debug_target.to_post_attach (pid);
1841
1842   fprintf_unfiltered (gdb_stderr, "target_post_attach (%d)\n", pid);
1843 }
1844
1845 static void
1846 debug_to_require_attach (args, from_tty)
1847      char *args;
1848      int from_tty;
1849 {
1850   debug_target.to_require_attach (args, from_tty);
1851
1852   fprintf_unfiltered (gdb_stderr,
1853                       "target_require_attach (%s, %d)\n", args, from_tty);
1854 }
1855
1856 static void
1857 debug_to_detach (args, from_tty)
1858      char *args;
1859      int from_tty;
1860 {
1861   debug_target.to_detach (args, from_tty);
1862
1863   fprintf_unfiltered (gdb_stderr, "target_detach (%s, %d)\n", args, from_tty);
1864 }
1865
1866 static void
1867 debug_to_require_detach (pid, args, from_tty)
1868   int  pid;
1869   char *  args;
1870   int  from_tty;
1871 {
1872   debug_target.to_require_detach (pid, args, from_tty);
1873
1874   fprintf_unfiltered (gdb_stderr,
1875                       "target_require_detach (%d, %s, %d)\n", pid, args, from_tty);
1876 }
1877
1878 static void
1879 debug_to_resume (pid, step, siggnal)
1880      int pid;
1881      int step;
1882      enum target_signal siggnal;
1883 {
1884   debug_target.to_resume (pid, step, siggnal);
1885
1886   fprintf_unfiltered (gdb_stderr, "target_resume (%d, %s, %s)\n", pid,
1887                       step ? "step" : "continue",
1888                       target_signal_to_name (siggnal));
1889 }
1890
1891 static int
1892 debug_to_wait (pid, status)
1893      int pid;
1894      struct target_waitstatus *status;
1895 {
1896   int retval;
1897
1898   retval = debug_target.to_wait (pid, status);
1899
1900   fprintf_unfiltered (gdb_stderr,
1901                       "target_wait (%d, status) = %d,   ", pid, retval);
1902   fprintf_unfiltered (gdb_stderr, "status->kind = ");
1903   switch (status->kind)
1904     {
1905     case TARGET_WAITKIND_EXITED:
1906       fprintf_unfiltered (gdb_stderr, "exited, status = %d\n",
1907                           status->value.integer);
1908       break;
1909     case TARGET_WAITKIND_STOPPED:
1910       fprintf_unfiltered (gdb_stderr, "stopped, signal = %s\n",
1911                           target_signal_to_name (status->value.sig));
1912       break;
1913     case TARGET_WAITKIND_SIGNALLED:
1914       fprintf_unfiltered (gdb_stderr, "signalled, signal = %s\n",
1915                           target_signal_to_name (status->value.sig));
1916       break;
1917     case TARGET_WAITKIND_LOADED:
1918       fprintf_unfiltered (gdb_stderr, "loaded\n");
1919       break;
1920     case TARGET_WAITKIND_FORKED:
1921       fprintf_unfiltered (gdb_stderr, "forked\n");
1922       break;
1923     case TARGET_WAITKIND_VFORKED:
1924       fprintf_unfiltered (gdb_stderr, "vforked\n");
1925       break;
1926     case TARGET_WAITKIND_EXECD:
1927       fprintf_unfiltered (gdb_stderr, "execd\n");
1928       break;
1929     case TARGET_WAITKIND_SPURIOUS:
1930       fprintf_unfiltered (gdb_stderr, "spurious\n");
1931       break;
1932     default:
1933       fprintf_unfiltered (gdb_stderr, "unknown???\n");
1934       break;
1935     }
1936
1937   return retval;
1938 }
1939
1940 static void
1941 debug_to_post_wait (pid, status)
1942   int  pid;
1943   int  status;
1944 {
1945   debug_target.to_post_wait (pid, status);
1946
1947   fprintf_unfiltered (gdb_stderr, "target_post_wait (%d, %d)\n",
1948                       pid, status);
1949 }
1950
1951 static void
1952 debug_to_fetch_registers (regno)
1953      int regno;
1954 {
1955   debug_target.to_fetch_registers (regno);
1956
1957   fprintf_unfiltered (gdb_stderr, "target_fetch_registers (%s)",
1958                       regno != -1 ? REGISTER_NAME (regno) : "-1");
1959   if (regno != -1)
1960     fprintf_unfiltered (gdb_stderr, " = 0x%x %d",
1961                         (unsigned long) read_register (regno),
1962                         read_register (regno));
1963   fprintf_unfiltered (gdb_stderr, "\n");
1964 }
1965
1966 static void
1967 debug_to_store_registers (regno)
1968      int regno;
1969 {
1970   debug_target.to_store_registers (regno);
1971
1972   if (regno >= 0 && regno < NUM_REGS)
1973     fprintf_unfiltered (gdb_stderr, "target_store_registers (%s) = 0x%x %d\n",
1974                         REGISTER_NAME (regno),
1975                         (unsigned long) read_register (regno),
1976                         (unsigned long) read_register (regno));
1977   else
1978     fprintf_unfiltered (gdb_stderr, "target_store_registers (%d)\n", regno);
1979 }
1980
1981 static void
1982 debug_to_prepare_to_store ()
1983 {
1984   debug_target.to_prepare_to_store ();
1985
1986   fprintf_unfiltered (gdb_stderr, "target_prepare_to_store ()\n");
1987 }
1988
1989 static int
1990 debug_to_xfer_memory (memaddr, myaddr, len, write, target)
1991      CORE_ADDR memaddr;
1992      char *myaddr;
1993      int len;
1994      int write;
1995      struct target_ops *target;
1996 {
1997   int retval;
1998
1999   retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, target);
2000
2001   fprintf_unfiltered (gdb_stderr,
2002                       "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2003                       (unsigned int) memaddr, /* possable truncate long long */
2004                       len, write ? "write" : "read", retval);
2005
2006
2007
2008   if (retval > 0)
2009     {
2010       int i;
2011
2012       fputs_unfiltered (", bytes =", gdb_stderr);
2013       for (i = 0; i < retval; i++)
2014         {
2015           if ((((long) &(myaddr[i])) & 0xf) == 0)
2016             fprintf_unfiltered (gdb_stderr, "\n");
2017           fprintf_unfiltered (gdb_stderr, " %02x", myaddr[i] & 0xff);
2018         }
2019     }
2020
2021   fputc_unfiltered ('\n', gdb_stderr);
2022
2023   return retval;
2024 }
2025
2026 static void
2027 debug_to_files_info (target)
2028      struct target_ops *target;
2029 {
2030   debug_target.to_files_info (target);
2031
2032   fprintf_unfiltered (gdb_stderr, "target_files_info (xxx)\n");
2033 }
2034
2035 static int
2036 debug_to_insert_breakpoint (addr, save)
2037      CORE_ADDR addr;
2038      char *save;
2039 {
2040   int retval;
2041
2042   retval = debug_target.to_insert_breakpoint (addr, save);
2043
2044   fprintf_unfiltered (gdb_stderr,
2045                       "target_insert_breakpoint (0x%x, xxx) = %d\n",
2046                       (unsigned long) addr, retval);
2047   return retval;
2048 }
2049
2050 static int
2051 debug_to_remove_breakpoint (addr, save)
2052      CORE_ADDR addr;
2053      char *save;
2054 {
2055   int retval;
2056
2057   retval = debug_target.to_remove_breakpoint (addr, save);
2058
2059   fprintf_unfiltered (gdb_stderr,
2060                       "target_remove_breakpoint (0x%x, xxx) = %d\n",
2061                       (unsigned long)addr, retval);
2062   return retval;
2063 }
2064
2065 static void
2066 debug_to_terminal_init ()
2067 {
2068   debug_target.to_terminal_init ();
2069
2070   fprintf_unfiltered (gdb_stderr, "target_terminal_init ()\n");
2071 }
2072
2073 static void
2074 debug_to_terminal_inferior ()
2075 {
2076   debug_target.to_terminal_inferior ();
2077
2078   fprintf_unfiltered (gdb_stderr, "target_terminal_inferior ()\n");
2079 }
2080
2081 static void
2082 debug_to_terminal_ours_for_output ()
2083 {
2084   debug_target.to_terminal_ours_for_output ();
2085
2086   fprintf_unfiltered (gdb_stderr, "target_terminal_ours_for_output ()\n");
2087 }
2088
2089 static void
2090 debug_to_terminal_ours ()
2091 {
2092   debug_target.to_terminal_ours ();
2093
2094   fprintf_unfiltered (gdb_stderr, "target_terminal_ours ()\n");
2095 }
2096
2097 static void
2098 debug_to_terminal_info (arg, from_tty)
2099      char *arg;
2100      int from_tty;
2101 {
2102   debug_target.to_terminal_info (arg, from_tty);
2103
2104   fprintf_unfiltered (gdb_stderr, "target_terminal_info (%s, %d)\n", arg,
2105                       from_tty);
2106 }
2107
2108 static void
2109 debug_to_kill ()
2110 {
2111   debug_target.to_kill ();
2112
2113   fprintf_unfiltered (gdb_stderr, "target_kill ()\n");
2114 }
2115
2116 static void
2117 debug_to_load (args, from_tty)
2118      char *args;
2119      int from_tty;
2120 {
2121   debug_target.to_load (args, from_tty);
2122
2123   fprintf_unfiltered (gdb_stderr, "target_load (%s, %d)\n", args, from_tty);
2124 }
2125
2126 static int
2127 debug_to_lookup_symbol (name, addrp)
2128      char *name;
2129      CORE_ADDR *addrp;
2130 {
2131   int retval;
2132
2133   retval = debug_target.to_lookup_symbol (name, addrp);
2134
2135   fprintf_unfiltered (gdb_stderr, "target_lookup_symbol (%s, xxx)\n", name);
2136
2137   return retval;
2138 }
2139
2140 static void
2141 debug_to_create_inferior (exec_file, args, env)
2142      char *exec_file;
2143      char *args;
2144      char **env;
2145 {
2146   debug_target.to_create_inferior (exec_file, args, env);
2147
2148   fprintf_unfiltered (gdb_stderr, "target_create_inferior (%s, %s, xxx)\n",
2149                       exec_file, args);
2150 }
2151
2152 static void
2153 debug_to_post_startup_inferior (pid)
2154   int  pid;
2155 {
2156   debug_target.to_post_startup_inferior (pid);
2157
2158   fprintf_unfiltered (gdb_stderr, "target_post_startup_inferior (%d)\n",
2159                       pid);
2160 }
2161
2162 static void
2163 debug_to_acknowledge_created_inferior (pid)
2164   int  pid;
2165 {
2166   debug_target.to_acknowledge_created_inferior (pid);
2167
2168   fprintf_unfiltered (gdb_stderr, "target_acknowledge_created_inferior (%d)\n",
2169                       pid);
2170 }
2171
2172 static void
2173 debug_to_clone_and_follow_inferior (child_pid, followed_child)
2174   int  child_pid;
2175   int  *followed_child;
2176 {
2177   debug_target.to_clone_and_follow_inferior (child_pid, followed_child);
2178
2179   fprintf_unfiltered (gdb_stderr,
2180                       "target_clone_and_follow_inferior (%d, %d)\n",
2181                       child_pid, *followed_child);
2182 }
2183
2184 static void
2185 debug_to_post_follow_inferior_by_clone ()
2186 {
2187   debug_target.to_post_follow_inferior_by_clone ();
2188
2189   fprintf_unfiltered (gdb_stderr, "target_post_follow_inferior_by_clone ()\n");
2190 }
2191
2192 static int
2193 debug_to_insert_fork_catchpoint (pid)
2194   int  pid;
2195 {
2196   int  retval;
2197
2198   retval = debug_target.to_insert_fork_catchpoint (pid);
2199
2200   fprintf_unfiltered (gdb_stderr, "target_insert_fork_catchpoint (%d) = %d\n",
2201                       pid, retval);
2202
2203   return retval;
2204 }
2205
2206 static int
2207 debug_to_remove_fork_catchpoint (pid)
2208   int  pid;
2209 {
2210   int  retval;
2211
2212   retval = debug_target.to_remove_fork_catchpoint (pid);
2213
2214   fprintf_unfiltered (gdb_stderr, "target_remove_fork_catchpoint (%d) = %d\n",
2215                       pid, retval);
2216
2217   return retval;
2218 }
2219
2220 static int
2221 debug_to_insert_vfork_catchpoint (pid)
2222   int  pid;
2223 {
2224   int  retval;
2225
2226   retval = debug_target.to_insert_vfork_catchpoint (pid);
2227
2228   fprintf_unfiltered (gdb_stderr, "target_insert_vfork_catchpoint (%d)= %d\n",
2229                       pid, retval);
2230
2231   return retval;
2232 }
2233
2234 static int
2235 debug_to_remove_vfork_catchpoint (pid)
2236   int  pid;
2237 {
2238   int  retval;
2239
2240   retval = debug_target.to_remove_vfork_catchpoint (pid);
2241
2242   fprintf_unfiltered (gdb_stderr, "target_remove_vfork_catchpoint (%d) = %d\n",
2243                       pid, retval);
2244
2245   return retval;
2246 }
2247
2248 static int
2249 debug_to_has_forked (pid, child_pid)
2250   int  pid;
2251   int *  child_pid;
2252 {
2253   int  has_forked;
2254
2255   has_forked = debug_target.to_has_forked (pid, child_pid);
2256
2257   fprintf_unfiltered (gdb_stderr, "target_has_forked (%d, %d) = %d\n",
2258                       pid, *child_pid, has_forked);
2259
2260   return has_forked;
2261 }
2262
2263 static int
2264 debug_to_has_vforked (pid, child_pid)
2265   int  pid;
2266   int *  child_pid;
2267 {
2268   int  has_vforked;
2269
2270   has_vforked = debug_target.to_has_vforked (pid, child_pid);
2271
2272   fprintf_unfiltered (gdb_stderr, "target_has_vforked (%d, %d) = %d\n",
2273                       pid, *child_pid, has_vforked);
2274
2275   return has_vforked;
2276 }
2277
2278 static int
2279 debug_to_can_follow_vfork_prior_to_exec ()
2280 {
2281   int  can_immediately_follow_vfork;
2282
2283   can_immediately_follow_vfork = debug_target.to_can_follow_vfork_prior_to_exec ();
2284
2285   fprintf_unfiltered (gdb_stderr, "target_can_follow_vfork_prior_to_exec () = %d\n",
2286                       can_immediately_follow_vfork);
2287
2288   return can_immediately_follow_vfork;
2289 }
2290
2291 static void
2292 debug_to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child)
2293   int  parent_pid;
2294   int  followed_parent;
2295   int  child_pid;
2296   int  followed_child;
2297 {
2298   debug_target.to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child);
2299
2300   fprintf_unfiltered (gdb_stderr,
2301                       "target_post_follow_vfork (%d, %d, %d, %d)\n",
2302                       parent_pid, followed_parent, child_pid, followed_child);
2303 }
2304
2305 static int
2306 debug_to_insert_exec_catchpoint (pid)
2307   int  pid;
2308 {
2309   int  retval;
2310
2311   retval = debug_target.to_insert_exec_catchpoint (pid);
2312
2313   fprintf_unfiltered (gdb_stderr, "target_insert_exec_catchpoint (%d) = %d\n",
2314                       pid, retval);
2315
2316   return retval;
2317 }
2318
2319 static int
2320 debug_to_remove_exec_catchpoint (pid)
2321   int  pid;
2322 {
2323   int  retval;
2324
2325   retval = debug_target.to_remove_exec_catchpoint (pid);
2326
2327   fprintf_unfiltered (gdb_stderr, "target_remove_exec_catchpoint (%d) = %d\n",
2328                       pid, retval);
2329
2330   return retval;
2331 }
2332
2333 static int
2334 debug_to_has_execd (pid, execd_pathname)
2335   int  pid;
2336   char **  execd_pathname;
2337 {
2338   int  has_execd;
2339
2340   has_execd = debug_target.to_has_execd (pid, execd_pathname);
2341
2342   fprintf_unfiltered (gdb_stderr, "target_has_execd (%d, %s) = %d\n",
2343                       pid, (*execd_pathname ? *execd_pathname : "<NULL>"),
2344                       has_execd);
2345
2346   return has_execd;
2347 }
2348
2349 static int
2350 debug_to_reported_exec_events_per_exec_call ()
2351 {
2352   int  reported_exec_events;
2353
2354   reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2355
2356   fprintf_unfiltered (gdb_stderr,
2357                       "target_reported_exec_events_per_exec_call () = %d\n",
2358                       reported_exec_events);
2359
2360   return reported_exec_events;
2361 }
2362
2363 static int
2364 debug_to_has_syscall_event (pid, kind, syscall_id)
2365   int  pid;
2366   enum target_waitkind *  kind;
2367   int *  syscall_id;
2368 {
2369   int  has_syscall_event;
2370   char *  kind_spelling = "??";
2371
2372   has_syscall_event = debug_target.to_has_syscall_event (pid, kind, syscall_id);
2373   if (has_syscall_event)
2374     {
2375       switch (*kind)
2376         {
2377           case TARGET_WAITKIND_SYSCALL_ENTRY:
2378             kind_spelling = "SYSCALL_ENTRY";
2379             break;
2380           case TARGET_WAITKIND_SYSCALL_RETURN:
2381             kind_spelling = "SYSCALL_RETURN";
2382             break;
2383           default:
2384             break;
2385         }
2386     }
2387
2388   fprintf_unfiltered (gdb_stderr,
2389                       "target_has_syscall_event (%d, %s, %d) = %d\n",
2390                       pid, kind_spelling, *syscall_id, has_syscall_event);
2391
2392   return has_syscall_event;
2393 }
2394
2395 static int
2396 debug_to_has_exited (pid, wait_status, exit_status)
2397   int  pid;
2398   int  wait_status;
2399   int *  exit_status;
2400 {
2401   int  has_exited;
2402
2403   has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2404
2405   fprintf_unfiltered (gdb_stderr, "target_has_exited (%d, %d, %d) = %d\n",
2406                       pid, wait_status, *exit_status, has_exited);
2407
2408   return has_exited;
2409 }
2410
2411 static void
2412 debug_to_mourn_inferior ()
2413 {
2414   debug_target.to_mourn_inferior ();
2415
2416   fprintf_unfiltered (gdb_stderr, "target_mourn_inferior ()\n");
2417 }
2418
2419 static int
2420 debug_to_can_run ()
2421 {
2422   int retval;
2423
2424   retval = debug_target.to_can_run ();
2425
2426   fprintf_unfiltered (gdb_stderr, "target_can_run () = %d\n", retval);
2427
2428   return retval;
2429 }
2430
2431 static void
2432 debug_to_notice_signals (pid)
2433      int pid;
2434 {
2435   debug_target.to_notice_signals (pid);
2436
2437   fprintf_unfiltered (gdb_stderr, "target_notice_signals (%d)\n", pid);
2438 }
2439
2440 static int
2441 debug_to_thread_alive (pid)
2442      int pid;
2443 {
2444   int retval;
2445
2446   retval = debug_target.to_thread_alive (pid);
2447
2448   fprintf_unfiltered (gdb_stderr, "target_thread_alive (%d) = %d\n",
2449                       pid, retval);
2450
2451   return retval;
2452 }
2453
2454 static void
2455 debug_to_stop ()
2456 {
2457   debug_target.to_stop ();
2458
2459   fprintf_unfiltered (gdb_stderr, "target_stop ()\n");
2460 }
2461
2462 static int
2463 debug_to_query (type, req, resp, siz)
2464   int type;
2465   char *req;
2466   char *resp;
2467   int *siz;
2468 {
2469   int retval;
2470
2471   retval = debug_target.to_query (type, req, resp, siz);
2472
2473   fprintf_unfiltered (gdb_stderr, "target_query (%c, %s, %s,  %d) = %d\n", type, req, resp, *siz, retval);
2474
2475   return retval;
2476 }
2477
2478 static struct symtab_and_line *
2479 debug_to_enable_exception_callback (kind, enable)
2480   enum exception_event_kind kind;
2481   int enable;
2482 {
2483   struct symtab_and_line *result;
2484   result = debug_target.to_enable_exception_callback (kind, enable);
2485   fprintf_unfiltered (gdb_stderr,
2486                       "target get_exception_callback_sal (%d, %d)\n",
2487                       kind, enable);
2488   return result;
2489 }
2490
2491 static struct exception_event_record *
2492 debug_to_get_current_exception_event ()
2493 {
2494   struct exception_event_record *result;
2495   result = debug_target.to_get_current_exception_event();
2496   fprintf_unfiltered (gdb_stderr, "target get_current_exception_event ()\n");
2497   return result;
2498 }
2499
2500 static char *
2501 debug_to_pid_to_exec_file (pid)
2502   int  pid;
2503 {
2504   char *  exec_file;
2505
2506   exec_file = debug_target.to_pid_to_exec_file (pid);
2507
2508   fprintf_unfiltered (gdb_stderr, "target_pid_to_exec_file (%d) = %s\n",
2509                       pid, exec_file);
2510
2511   return exec_file;
2512 }
2513
2514 static char *
2515 debug_to_core_file_to_sym_file (core)
2516   char *  core;
2517 {
2518   char *  sym_file;
2519
2520   sym_file = debug_target.to_core_file_to_sym_file (core);
2521
2522   fprintf_unfiltered (gdb_stderr, "target_core_file_to_sym_file (%s) = %s\n",
2523                       core, sym_file);
2524
2525   return sym_file;
2526 }
2527
2528 static void
2529 setup_target_debug ()
2530 {
2531   memcpy (&debug_target, &current_target, sizeof debug_target);
2532
2533   current_target.to_open = debug_to_open;
2534   current_target.to_close = debug_to_close;
2535   current_target.to_attach = debug_to_attach;
2536   current_target.to_post_attach = debug_to_post_attach;
2537   current_target.to_require_attach = debug_to_require_attach;
2538   current_target.to_detach = debug_to_detach;
2539   current_target.to_require_detach = debug_to_require_detach;
2540   current_target.to_resume = debug_to_resume;
2541   current_target.to_wait = debug_to_wait;
2542   current_target.to_post_wait = debug_to_post_wait;
2543   current_target.to_fetch_registers = debug_to_fetch_registers;
2544   current_target.to_store_registers = debug_to_store_registers;
2545   current_target.to_prepare_to_store = debug_to_prepare_to_store;
2546   current_target.to_xfer_memory = debug_to_xfer_memory;
2547   current_target.to_files_info = debug_to_files_info;
2548   current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2549   current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2550   current_target.to_terminal_init = debug_to_terminal_init;
2551   current_target.to_terminal_inferior = debug_to_terminal_inferior;
2552   current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2553   current_target.to_terminal_ours = debug_to_terminal_ours;
2554   current_target.to_terminal_info = debug_to_terminal_info;
2555   current_target.to_kill = debug_to_kill;
2556   current_target.to_load = debug_to_load;
2557   current_target.to_lookup_symbol = debug_to_lookup_symbol;
2558   current_target.to_create_inferior = debug_to_create_inferior;
2559   current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2560   current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2561   current_target.to_clone_and_follow_inferior = debug_to_clone_and_follow_inferior;
2562   current_target.to_post_follow_inferior_by_clone = debug_to_post_follow_inferior_by_clone;
2563   current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2564   current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2565   current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2566   current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2567   current_target.to_has_forked = debug_to_has_forked;
2568   current_target.to_has_vforked = debug_to_has_vforked;
2569   current_target.to_can_follow_vfork_prior_to_exec = debug_to_can_follow_vfork_prior_to_exec;
2570   current_target.to_post_follow_vfork = debug_to_post_follow_vfork;
2571   current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2572   current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2573   current_target.to_has_execd = debug_to_has_execd;
2574   current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2575   current_target.to_has_syscall_event = debug_to_has_syscall_event;
2576   current_target.to_has_exited = debug_to_has_exited;
2577   current_target.to_mourn_inferior = debug_to_mourn_inferior;
2578   current_target.to_can_run = debug_to_can_run;
2579   current_target.to_notice_signals = debug_to_notice_signals;
2580   current_target.to_thread_alive = debug_to_thread_alive;
2581   current_target.to_stop = debug_to_stop;
2582   current_target.to_query = debug_to_query;
2583   current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2584   current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2585   current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2586   current_target.to_core_file_to_sym_file = debug_to_core_file_to_sym_file;
2587
2588 }
2589
2590 \f
2591 static char targ_desc[] =
2592     "Names of targets and files being debugged.\n\
2593 Shows the entire stack of targets currently in use (including the exec-file,\n\
2594 core-file, and process, if any), as well as the symbol file name.";
2595
2596 void
2597 initialize_targets ()
2598 {
2599   init_dummy_target ();
2600   push_target (&dummy_target);
2601
2602   add_info ("target", target_info, targ_desc);
2603   add_info ("files", target_info, targ_desc);
2604
2605   add_show_from_set (
2606      add_set_cmd ("targetdebug", class_maintenance, var_zinteger,
2607                   (char *)&targetdebug,
2608                  "Set target debugging.\n\
2609 When non-zero, target debugging is enabled.", &setlist),
2610                      &showlist);
2611
2612   if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC"))
2613     abort ();
2614 }