gdb/target.c

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