gdb/target.c

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