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