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