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   int size;
1797
1798   size = snprintf (buf, sizeof buf, "process %d", ptid_get_pid (ptid));
1799   gdb_assert (size < sizeof buf);
1800   return buf;
1801 }
1802
1803 /* Error-catcher for target_find_memory_regions */
1804 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
1805 {
1806   error (_("No target."));
1807   return 0;
1808 }
1809
1810 /* Error-catcher for target_make_corefile_notes */
1811 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
1812 {
1813   error (_("No target."));
1814   return NULL;
1815 }
1816
1817 /* Set up the handful of non-empty slots needed by the dummy target
1818    vector.  */
1819
1820 static void
1821 init_dummy_target (void)
1822 {
1823   dummy_target.to_shortname = "None";
1824   dummy_target.to_longname = "None";
1825   dummy_target.to_doc = "";
1826   dummy_target.to_attach = find_default_attach;
1827   dummy_target.to_create_inferior = find_default_create_inferior;
1828   dummy_target.to_pid_to_str = normal_pid_to_str;
1829   dummy_target.to_stratum = dummy_stratum;
1830   dummy_target.to_find_memory_regions = dummy_find_memory_regions;
1831   dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
1832   dummy_target.to_xfer_partial = default_xfer_partial;
1833   dummy_target.to_magic = OPS_MAGIC;
1834 }
1835 \f
1836 static void
1837 debug_to_open (char *args, int from_tty)
1838 {
1839   debug_target.to_open (args, from_tty);
1840
1841   fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
1842 }
1843
1844 static void
1845 debug_to_close (int quitting)
1846 {
1847   target_close (&debug_target, quitting);
1848   fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
1849 }
1850
1851 void
1852 target_close (struct target_ops *targ, int quitting)
1853 {
1854   if (targ->to_xclose != NULL)
1855     targ->to_xclose (targ, quitting);
1856   else if (targ->to_close != NULL)
1857     targ->to_close (quitting);
1858 }
1859
1860 static void
1861 debug_to_attach (char *args, int from_tty)
1862 {
1863   debug_target.to_attach (args, from_tty);
1864
1865   fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
1866 }
1867
1868
1869 static void
1870 debug_to_post_attach (int pid)
1871 {
1872   debug_target.to_post_attach (pid);
1873
1874   fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
1875 }
1876
1877 static void
1878 debug_to_detach (char *args, int from_tty)
1879 {
1880   debug_target.to_detach (args, from_tty);
1881
1882   fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
1883 }
1884
1885 static void
1886 debug_to_disconnect (char *args, int from_tty)
1887 {
1888   debug_target.to_disconnect (args, from_tty);
1889
1890   fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1891                       args, from_tty);
1892 }
1893
1894 static void
1895 debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
1896 {
1897   debug_target.to_resume (ptid, step, siggnal);
1898
1899   fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
1900                       step ? "step" : "continue",
1901                       target_signal_to_name (siggnal));
1902 }
1903
1904 static ptid_t
1905 debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
1906 {
1907   ptid_t retval;
1908
1909   retval = debug_target.to_wait (ptid, status);
1910
1911   fprintf_unfiltered (gdb_stdlog,
1912                       "target_wait (%d, status) = %d,   ", PIDGET (ptid),
1913                       PIDGET (retval));
1914   fprintf_unfiltered (gdb_stdlog, "status->kind = ");
1915   switch (status->kind)
1916     {
1917     case TARGET_WAITKIND_EXITED:
1918       fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
1919                           status->value.integer);
1920       break;
1921     case TARGET_WAITKIND_STOPPED:
1922       fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
1923                           target_signal_to_name (status->value.sig));
1924       break;
1925     case TARGET_WAITKIND_SIGNALLED:
1926       fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
1927                           target_signal_to_name (status->value.sig));
1928       break;
1929     case TARGET_WAITKIND_LOADED:
1930       fprintf_unfiltered (gdb_stdlog, "loaded\n");
1931       break;
1932     case TARGET_WAITKIND_FORKED:
1933       fprintf_unfiltered (gdb_stdlog, "forked\n");
1934       break;
1935     case TARGET_WAITKIND_VFORKED:
1936       fprintf_unfiltered (gdb_stdlog, "vforked\n");
1937       break;
1938     case TARGET_WAITKIND_EXECD:
1939       fprintf_unfiltered (gdb_stdlog, "execd\n");
1940       break;
1941     case TARGET_WAITKIND_SPURIOUS:
1942       fprintf_unfiltered (gdb_stdlog, "spurious\n");
1943       break;
1944     default:
1945       fprintf_unfiltered (gdb_stdlog, "unknown???\n");
1946       break;
1947     }
1948
1949   return retval;
1950 }
1951
1952 static void
1953 debug_print_register (const char * func, int regno)
1954 {
1955   fprintf_unfiltered (gdb_stdlog, "%s ", func);
1956   if (regno >= 0 && regno < NUM_REGS + NUM_PSEUDO_REGS
1957       && REGISTER_NAME (regno) != NULL && REGISTER_NAME (regno)[0] != '\0')
1958     fprintf_unfiltered (gdb_stdlog, "(%s)", REGISTER_NAME (regno));
1959   else
1960     fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
1961   if (regno >= 0)
1962     {
1963       int i;
1964       unsigned char buf[MAX_REGISTER_SIZE];
1965       deprecated_read_register_gen (regno, buf);
1966       fprintf_unfiltered (gdb_stdlog, " = ");
1967       for (i = 0; i < register_size (current_gdbarch, regno); i++)
1968         {
1969           fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1970         }
1971       if (register_size (current_gdbarch, regno) <= sizeof (LONGEST))
1972         {
1973           fprintf_unfiltered (gdb_stdlog, " 0x%s %s",
1974                               paddr_nz (read_register (regno)),
1975                               paddr_d (read_register (regno)));
1976         }
1977     }
1978   fprintf_unfiltered (gdb_stdlog, "\n");
1979 }
1980
1981 static void
1982 debug_to_fetch_registers (int regno)
1983 {
1984   debug_target.to_fetch_registers (regno);
1985   debug_print_register ("target_fetch_registers", regno);
1986 }
1987
1988 static void
1989 debug_to_store_registers (int regno)
1990 {
1991   debug_target.to_store_registers (regno);
1992   debug_print_register ("target_store_registers", regno);
1993   fprintf_unfiltered (gdb_stdlog, "\n");
1994 }
1995
1996 static void
1997 debug_to_prepare_to_store (void)
1998 {
1999   debug_target.to_prepare_to_store ();
2000
2001   fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
2002 }
2003
2004 static int
2005 deprecated_debug_xfer_memory (CORE_ADDR memaddr, bfd_byte *myaddr, int len,
2006                               int write, struct mem_attrib *attrib,
2007                               struct target_ops *target)
2008 {
2009   int retval;
2010
2011   retval = debug_target.deprecated_xfer_memory (memaddr, myaddr, len, write,
2012                                                 attrib, target);
2013
2014   fprintf_unfiltered (gdb_stdlog,
2015                       "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
2016                       (unsigned int) memaddr,   /* possable truncate long long */
2017                       len, write ? "write" : "read", retval);
2018
2019   if (retval > 0)
2020     {
2021       int i;
2022
2023       fputs_unfiltered (", bytes =", gdb_stdlog);
2024       for (i = 0; i < retval; i++)
2025         {
2026           if ((((long) &(myaddr[i])) & 0xf) == 0)
2027             {
2028               if (targetdebug < 2 && i > 0)
2029                 {
2030                   fprintf_unfiltered (gdb_stdlog, " ...");
2031                   break;
2032                 }
2033               fprintf_unfiltered (gdb_stdlog, "\n");
2034             }
2035
2036           fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
2037         }
2038     }
2039
2040   fputc_unfiltered ('\n', gdb_stdlog);
2041
2042   return retval;
2043 }
2044
2045 static void
2046 debug_to_files_info (struct target_ops *target)
2047 {
2048   debug_target.to_files_info (target);
2049
2050   fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
2051 }
2052
2053 static int
2054 debug_to_insert_breakpoint (CORE_ADDR addr, gdb_byte *save)
2055 {
2056   int retval;
2057
2058   retval = debug_target.to_insert_breakpoint (addr, save);
2059
2060   fprintf_unfiltered (gdb_stdlog,
2061                       "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
2062                       (unsigned long) addr,
2063                       (unsigned long) retval);
2064   return retval;
2065 }
2066
2067 static int
2068 debug_to_remove_breakpoint (CORE_ADDR addr, gdb_byte *save)
2069 {
2070   int retval;
2071
2072   retval = debug_target.to_remove_breakpoint (addr, save);
2073
2074   fprintf_unfiltered (gdb_stdlog,
2075                       "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
2076                       (unsigned long) addr,
2077                       (unsigned long) retval);
2078   return retval;
2079 }
2080
2081 static int
2082 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
2083 {
2084   int retval;
2085
2086   retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
2087
2088   fprintf_unfiltered (gdb_stdlog,
2089                       "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
2090                       (unsigned long) type,
2091                       (unsigned long) cnt,
2092                       (unsigned long) from_tty,
2093                       (unsigned long) retval);
2094   return retval;
2095 }
2096
2097 static int
2098 debug_to_region_size_ok_for_hw_watchpoint (int byte_count)
2099 {
2100   CORE_ADDR retval;
2101
2102   retval = debug_target.to_region_size_ok_for_hw_watchpoint (byte_count);
2103
2104   fprintf_unfiltered (gdb_stdlog,
2105                       "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
2106                       (unsigned long) byte_count,
2107                       (unsigned long) retval);
2108   return retval;
2109 }
2110
2111 static int
2112 debug_to_stopped_by_watchpoint (void)
2113 {
2114   int retval;
2115
2116   retval = debug_target.to_stopped_by_watchpoint ();
2117
2118   fprintf_unfiltered (gdb_stdlog,
2119                       "STOPPED_BY_WATCHPOINT () = %ld\n",
2120                       (unsigned long) retval);
2121   return retval;
2122 }
2123
2124 static int
2125 debug_to_stopped_data_address (struct target_ops *target, CORE_ADDR *addr)
2126 {
2127   int retval;
2128
2129   retval = debug_target.to_stopped_data_address (target, addr);
2130
2131   fprintf_unfiltered (gdb_stdlog,
2132                       "target_stopped_data_address ([0x%lx]) = %ld\n",
2133                       (unsigned long)*addr,
2134                       (unsigned long)retval);
2135   return retval;
2136 }
2137
2138 static int
2139 debug_to_insert_hw_breakpoint (CORE_ADDR addr, gdb_byte *save)
2140 {
2141   int retval;
2142
2143   retval = debug_target.to_insert_hw_breakpoint (addr, save);
2144
2145   fprintf_unfiltered (gdb_stdlog,
2146                       "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
2147                       (unsigned long) addr,
2148                       (unsigned long) retval);
2149   return retval;
2150 }
2151
2152 static int
2153 debug_to_remove_hw_breakpoint (CORE_ADDR addr, gdb_byte *save)
2154 {
2155   int retval;
2156
2157   retval = debug_target.to_remove_hw_breakpoint (addr, save);
2158
2159   fprintf_unfiltered (gdb_stdlog,
2160                       "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
2161                       (unsigned long) addr,
2162                       (unsigned long) retval);
2163   return retval;
2164 }
2165
2166 static int
2167 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
2168 {
2169   int retval;
2170
2171   retval = debug_target.to_insert_watchpoint (addr, len, type);
2172
2173   fprintf_unfiltered (gdb_stdlog,
2174                       "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2175                       (unsigned long) addr, len, type, (unsigned long) retval);
2176   return retval;
2177 }
2178
2179 static int
2180 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
2181 {
2182   int retval;
2183
2184   retval = debug_target.to_insert_watchpoint (addr, len, type);
2185
2186   fprintf_unfiltered (gdb_stdlog,
2187                       "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
2188                       (unsigned long) addr, len, type, (unsigned long) retval);
2189   return retval;
2190 }
2191
2192 static void
2193 debug_to_terminal_init (void)
2194 {
2195   debug_target.to_terminal_init ();
2196
2197   fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2198 }
2199
2200 static void
2201 debug_to_terminal_inferior (void)
2202 {
2203   debug_target.to_terminal_inferior ();
2204
2205   fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2206 }
2207
2208 static void
2209 debug_to_terminal_ours_for_output (void)
2210 {
2211   debug_target.to_terminal_ours_for_output ();
2212
2213   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2214 }
2215
2216 static void
2217 debug_to_terminal_ours (void)
2218 {
2219   debug_target.to_terminal_ours ();
2220
2221   fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2222 }
2223
2224 static void
2225 debug_to_terminal_save_ours (void)
2226 {
2227   debug_target.to_terminal_save_ours ();
2228
2229   fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
2230 }
2231
2232 static void
2233 debug_to_terminal_info (char *arg, int from_tty)
2234 {
2235   debug_target.to_terminal_info (arg, from_tty);
2236
2237   fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2238                       from_tty);
2239 }
2240
2241 static void
2242 debug_to_kill (void)
2243 {
2244   debug_target.to_kill ();
2245
2246   fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2247 }
2248
2249 static void
2250 debug_to_load (char *args, int from_tty)
2251 {
2252   debug_target.to_load (args, from_tty);
2253
2254   fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2255 }
2256
2257 static int
2258 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
2259 {
2260   int retval;
2261
2262   retval = debug_target.to_lookup_symbol (name, addrp);
2263
2264   fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
2265
2266   return retval;
2267 }
2268
2269 static void
2270 debug_to_create_inferior (char *exec_file, char *args, char **env,
2271                           int from_tty)
2272 {
2273   debug_target.to_create_inferior (exec_file, args, env, from_tty);
2274
2275   fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
2276                       exec_file, args, from_tty);
2277 }
2278
2279 static void
2280 debug_to_post_startup_inferior (ptid_t ptid)
2281 {
2282   debug_target.to_post_startup_inferior (ptid);
2283
2284   fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
2285                       PIDGET (ptid));
2286 }
2287
2288 static void
2289 debug_to_acknowledge_created_inferior (int pid)
2290 {
2291   debug_target.to_acknowledge_created_inferior (pid);
2292
2293   fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
2294                       pid);
2295 }
2296
2297 static void
2298 debug_to_insert_fork_catchpoint (int pid)
2299 {
2300   debug_target.to_insert_fork_catchpoint (pid);
2301
2302   fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d)\n",
2303                       pid);
2304 }
2305
2306 static int
2307 debug_to_remove_fork_catchpoint (int pid)
2308 {
2309   int retval;
2310
2311   retval = debug_target.to_remove_fork_catchpoint (pid);
2312
2313   fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
2314                       pid, retval);
2315
2316   return retval;
2317 }
2318
2319 static void
2320 debug_to_insert_vfork_catchpoint (int pid)
2321 {
2322   debug_target.to_insert_vfork_catchpoint (pid);
2323
2324   fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)\n",
2325                       pid);
2326 }
2327
2328 static int
2329 debug_to_remove_vfork_catchpoint (int pid)
2330 {
2331   int retval;
2332
2333   retval = debug_target.to_remove_vfork_catchpoint (pid);
2334
2335   fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
2336                       pid, retval);
2337
2338   return retval;
2339 }
2340
2341 static int
2342 debug_to_follow_fork (int follow_child)
2343 {
2344   int retval =  debug_target.to_follow_fork (follow_child);
2345
2346   fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
2347                       follow_child, retval);
2348
2349   return retval;
2350 }
2351
2352 static void
2353 debug_to_insert_exec_catchpoint (int pid)
2354 {
2355   debug_target.to_insert_exec_catchpoint (pid);
2356
2357   fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d)\n",
2358                       pid);
2359 }
2360
2361 static int
2362 debug_to_remove_exec_catchpoint (int pid)
2363 {
2364   int retval;
2365
2366   retval = debug_target.to_remove_exec_catchpoint (pid);
2367
2368   fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
2369                       pid, retval);
2370
2371   return retval;
2372 }
2373
2374 static int
2375 debug_to_reported_exec_events_per_exec_call (void)
2376 {
2377   int reported_exec_events;
2378
2379   reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2380
2381   fprintf_unfiltered (gdb_stdlog,
2382                       "target_reported_exec_events_per_exec_call () = %d\n",
2383                       reported_exec_events);
2384
2385   return reported_exec_events;
2386 }
2387
2388 static int
2389 debug_to_has_exited (int pid, int wait_status, int *exit_status)
2390 {
2391   int has_exited;
2392
2393   has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2394
2395   fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
2396                       pid, wait_status, *exit_status, has_exited);
2397
2398   return has_exited;
2399 }
2400
2401 static void
2402 debug_to_mourn_inferior (void)
2403 {
2404   debug_target.to_mourn_inferior ();
2405
2406   fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2407 }
2408
2409 static int
2410 debug_to_can_run (void)
2411 {
2412   int retval;
2413
2414   retval = debug_target.to_can_run ();
2415
2416   fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
2417
2418   return retval;
2419 }
2420
2421 static void
2422 debug_to_notice_signals (ptid_t ptid)
2423 {
2424   debug_target.to_notice_signals (ptid);
2425
2426   fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
2427                       PIDGET (ptid));
2428 }
2429
2430 static int
2431 debug_to_thread_alive (ptid_t ptid)
2432 {
2433   int retval;
2434
2435   retval = debug_target.to_thread_alive (ptid);
2436
2437   fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2438                       PIDGET (ptid), retval);
2439
2440   return retval;
2441 }
2442
2443 static void
2444 debug_to_find_new_threads (void)
2445 {
2446   debug_target.to_find_new_threads ();
2447
2448   fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
2449 }
2450
2451 static void
2452 debug_to_stop (void)
2453 {
2454   debug_target.to_stop ();
2455
2456   fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
2457 }
2458
2459 static void
2460 debug_to_rcmd (char *command,
2461                struct ui_file *outbuf)
2462 {
2463   debug_target.to_rcmd (command, outbuf);
2464   fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
2465 }
2466
2467 static struct symtab_and_line *
2468 debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
2469 {
2470   struct symtab_and_line *result;
2471   result = debug_target.to_enable_exception_callback (kind, enable);
2472   fprintf_unfiltered (gdb_stdlog,
2473                       "target get_exception_callback_sal (%d, %d)\n",
2474                       kind, enable);
2475   return result;
2476 }
2477
2478 static struct exception_event_record *
2479 debug_to_get_current_exception_event (void)
2480 {
2481   struct exception_event_record *result;
2482   result = debug_target.to_get_current_exception_event ();
2483   fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n");
2484   return result;
2485 }
2486
2487 static char *
2488 debug_to_pid_to_exec_file (int pid)
2489 {
2490   char *exec_file;
2491
2492   exec_file = debug_target.to_pid_to_exec_file (pid);
2493
2494   fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
2495                       pid, exec_file);
2496
2497   return exec_file;
2498 }
2499
2500 static void
2501 setup_target_debug (void)
2502 {
2503   memcpy (&debug_target, &current_target, sizeof debug_target);
2504
2505   current_target.to_open = debug_to_open;
2506   current_target.to_close = debug_to_close;
2507   current_target.to_attach = debug_to_attach;
2508   current_target.to_post_attach = debug_to_post_attach;
2509   current_target.to_detach = debug_to_detach;
2510   current_target.to_disconnect = debug_to_disconnect;
2511   current_target.to_resume = debug_to_resume;
2512   current_target.to_wait = debug_to_wait;
2513   current_target.to_fetch_registers = debug_to_fetch_registers;
2514   current_target.to_store_registers = debug_to_store_registers;
2515   current_target.to_prepare_to_store = debug_to_prepare_to_store;
2516   current_target.deprecated_xfer_memory = deprecated_debug_xfer_memory;
2517   current_target.to_files_info = debug_to_files_info;
2518   current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2519   current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2520   current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
2521   current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
2522   current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
2523   current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
2524   current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
2525   current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
2526   current_target.to_stopped_data_address = debug_to_stopped_data_address;
2527   current_target.to_region_size_ok_for_hw_watchpoint = debug_to_region_size_ok_for_hw_watchpoint;
2528   current_target.to_terminal_init = debug_to_terminal_init;
2529   current_target.to_terminal_inferior = debug_to_terminal_inferior;
2530   current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2531   current_target.to_terminal_ours = debug_to_terminal_ours;
2532   current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
2533   current_target.to_terminal_info = debug_to_terminal_info;
2534   current_target.to_kill = debug_to_kill;
2535   current_target.to_load = debug_to_load;
2536   current_target.to_lookup_symbol = debug_to_lookup_symbol;
2537   current_target.to_create_inferior = debug_to_create_inferior;
2538   current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2539   current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2540   current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2541   current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2542   current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2543   current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2544   current_target.to_follow_fork = debug_to_follow_fork;
2545   current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2546   current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2547   current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2548   current_target.to_has_exited = debug_to_has_exited;
2549   current_target.to_mourn_inferior = debug_to_mourn_inferior;
2550   current_target.to_can_run = debug_to_can_run;
2551   current_target.to_notice_signals = debug_to_notice_signals;
2552   current_target.to_thread_alive = debug_to_thread_alive;
2553   current_target.to_find_new_threads = debug_to_find_new_threads;
2554   current_target.to_stop = debug_to_stop;
2555   current_target.to_rcmd = debug_to_rcmd;
2556   current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2557   current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2558   current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2559
2560 }
2561 \f
2562
2563 static char targ_desc[] =
2564 "Names of targets and files being debugged.\n\
2565 Shows the entire stack of targets currently in use (including the exec-file,\n\
2566 core-file, and process, if any), as well as the symbol file name.";
2567
2568 static void
2569 do_monitor_command (char *cmd,
2570                  int from_tty)
2571 {
2572   if ((current_target.to_rcmd
2573        == (void (*) (char *, struct ui_file *)) tcomplain)
2574       || (current_target.to_rcmd == debug_to_rcmd
2575           && (debug_target.to_rcmd
2576               == (void (*) (char *, struct ui_file *)) tcomplain)))
2577     error (_("\"monitor\" command not supported by this target."));
2578   target_rcmd (cmd, gdb_stdtarg);
2579 }
2580
2581 void
2582 initialize_targets (void)
2583 {
2584   init_dummy_target ();
2585   push_target (&dummy_target);
2586
2587   add_info ("target", target_info, targ_desc);
2588   add_info ("files", target_info, targ_desc);
2589
2590   add_setshow_zinteger_cmd ("target", class_maintenance, &targetdebug, _("\
2591 Set target debugging."), _("\
2592 Show target debugging."), _("\
2593 When non-zero, target debugging is enabled.  Higher numbers are more\n\
2594 verbose.  Changes do not take effect until the next \"run\" or \"target\"\n\
2595 command."),
2596                             NULL,
2597                             show_targetdebug,
2598                             &setdebuglist, &showdebuglist);
2599
2600   add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
2601                            &trust_readonly, _("\
2602 Set mode for reading from readonly sections."), _("\
2603 Show mode for reading from readonly sections."), _("\
2604 When this mode is on, memory reads from readonly sections (such as .text)\n\
2605 will be read from the object file instead of from the target.  This will\n\
2606 result in significant performance improvement for remote targets."),
2607                            NULL,
2608                            show_trust_readonly,
2609                            &setlist, &showlist);
2610
2611   add_com ("monitor", class_obscure, do_monitor_command,
2612            _("Send a command to the remote monitor (remote targets only)."));
2613
2614   target_dcache = dcache_init ();
2615 }