gdb/target.h

   1 /* Interface between GDB and target environments, including files and processes
   2    Copyright 1990-1994, 1999, 2000, 2001 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.  Written by John Gilmore.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #if !defined (TARGET_H)
  23 #define TARGET_H
  24
  25 /* This include file defines the interface between the main part
  26    of the debugger, and the part which is target-specific, or
  27    specific to the communications interface between us and the
  28    target.
  29
  30    A TARGET is an interface between the debugger and a particular
  31    kind of file or process.  Targets can be STACKED in STRATA,
  32    so that more than one target can potentially respond to a request.
  33    In particular, memory accesses will walk down the stack of targets
  34    until they find a target that is interested in handling that particular
  35    address.  STRATA are artificial boundaries on the stack, within
  36    which particular kinds of targets live.  Strata exist so that
  37    people don't get confused by pushing e.g. a process target and then
  38    a file target, and wondering why they can't see the current values
  39    of variables any more (the file target is handling them and they
  40    never get to the process target).  So when you push a file target,
  41    it goes into the file stratum, which is always below the process
  42    stratum.  */
  43
  44 #include "bfd.h"
  45 #include "symtab.h"
  46 #include "dcache.h"
  47 #include "memattr.h"
  48
  49 enum strata
  50   {
  51     dummy_stratum,              /* The lowest of the low */
  52     file_stratum,               /* Executable files, etc */
  53     core_stratum,               /* Core dump files */
  54     download_stratum,           /* Downloading of remote targets */
  55     process_stratum,            /* Executing processes */
  56     thread_stratum              /* Executing threads */
  57   };
  58
  59 enum thread_control_capabilities
  60   {
  61     tc_none = 0,                /* Default: can't control thread execution.  */
  62     tc_schedlock = 1,           /* Can lock the thread scheduler.  */
  63     tc_switch = 2               /* Can switch the running thread on demand.  */
  64   };
  65
  66 /* Stuff for target_wait.  */
  67
  68 /* Generally, what has the program done?  */
  69 enum target_waitkind
  70   {
  71     /* The program has exited.  The exit status is in value.integer.  */
  72     TARGET_WAITKIND_EXITED,
  73
  74     /* The program has stopped with a signal.  Which signal is in
  75        value.sig.  */
  76     TARGET_WAITKIND_STOPPED,
  77
  78     /* The program has terminated with a signal.  Which signal is in
  79        value.sig.  */
  80     TARGET_WAITKIND_SIGNALLED,
  81
  82     /* The program is letting us know that it dynamically loaded something
  83        (e.g. it called load(2) on AIX).  */
  84     TARGET_WAITKIND_LOADED,
  85
  86     /* The program has forked.  A "related" process' ID is in
  87        value.related_pid.  I.e., if the child forks, value.related_pid
  88        is the parent's ID.  */
  89
  90     TARGET_WAITKIND_FORKED,
  91
  92     /* The program has vforked.  A "related" process's ID is in
  93        value.related_pid.  */
  94
  95     TARGET_WAITKIND_VFORKED,
  96
  97     /* The program has exec'ed a new executable file.  The new file's
  98        pathname is pointed to by value.execd_pathname.  */
  99
 100     TARGET_WAITKIND_EXECD,
 101
 102     /* The program has entered or returned from a system call.  On
 103        HP-UX, this is used in the hardware watchpoint implementation.
 104        The syscall's unique integer ID number is in value.syscall_id */
 105
 106     TARGET_WAITKIND_SYSCALL_ENTRY,
 107     TARGET_WAITKIND_SYSCALL_RETURN,
 108
 109     /* Nothing happened, but we stopped anyway.  This perhaps should be handled
 110        within target_wait, but I'm not sure target_wait should be resuming the
 111        inferior.  */
 112     TARGET_WAITKIND_SPURIOUS,
 113
 114     /* This is used for target async and extended-async
 115        only. Remote_async_wait() returns this when there is an event
 116        on the inferior, but the rest of the world is not interested in
 117        it. The inferior has not stopped, but has just sent some output
 118        to the console, for instance. In this case, we want to go back
 119        to the event loop and wait there for another event from the
 120        inferior, rather than being stuck in the remote_async_wait()
 121        function. This way the event loop is responsive to other events,
 122        like for instance the user typing.  */
 123     TARGET_WAITKIND_IGNORE
 124   };
 125
 126 /* The numbering of these signals is chosen to match traditional unix
 127    signals (insofar as various unices use the same numbers, anyway).
 128    It is also the numbering of the GDB remote protocol.  Other remote
 129    protocols, if they use a different numbering, should make sure to
 130    translate appropriately.
 131
 132    Since these numbers have actually made it out into other software
 133    (stubs, etc.), you mustn't disturb the assigned numbering.  If you
 134    need to add new signals here, add them to the end of the explicitly
 135    numbered signals.
 136
 137    This is based strongly on Unix/POSIX signals for several reasons:
 138    (1) This set of signals represents a widely-accepted attempt to
 139    represent events of this sort in a portable fashion, (2) we want a
 140    signal to make it from wait to child_wait to the user intact, (3) many
 141    remote protocols use a similar encoding.  However, it is
 142    recognized that this set of signals has limitations (such as not
 143    distinguishing between various kinds of SIGSEGV, or not
 144    distinguishing hitting a breakpoint from finishing a single step).
 145    So in the future we may get around this either by adding additional
 146    signals for breakpoint, single-step, etc., or by adding signal
 147    codes; the latter seems more in the spirit of what BSD, System V,
 148    etc. are doing to address these issues.  */
 149
 150 /* For an explanation of what each signal means, see
 151    target_signal_to_string.  */
 152
 153 enum target_signal
 154   {
 155     /* Used some places (e.g. stop_signal) to record the concept that
 156        there is no signal.  */
 157     TARGET_SIGNAL_0 = 0,
 158     TARGET_SIGNAL_FIRST = 0,
 159     TARGET_SIGNAL_HUP = 1,
 160     TARGET_SIGNAL_INT = 2,
 161     TARGET_SIGNAL_QUIT = 3,
 162     TARGET_SIGNAL_ILL = 4,
 163     TARGET_SIGNAL_TRAP = 5,
 164     TARGET_SIGNAL_ABRT = 6,
 165     TARGET_SIGNAL_EMT = 7,
 166     TARGET_SIGNAL_FPE = 8,
 167     TARGET_SIGNAL_KILL = 9,
 168     TARGET_SIGNAL_BUS = 10,
 169     TARGET_SIGNAL_SEGV = 11,
 170     TARGET_SIGNAL_SYS = 12,
 171     TARGET_SIGNAL_PIPE = 13,
 172     TARGET_SIGNAL_ALRM = 14,
 173     TARGET_SIGNAL_TERM = 15,
 174     TARGET_SIGNAL_URG = 16,
 175     TARGET_SIGNAL_STOP = 17,
 176     TARGET_SIGNAL_TSTP = 18,
 177     TARGET_SIGNAL_CONT = 19,
 178     TARGET_SIGNAL_CHLD = 20,
 179     TARGET_SIGNAL_TTIN = 21,
 180     TARGET_SIGNAL_TTOU = 22,
 181     TARGET_SIGNAL_IO = 23,
 182     TARGET_SIGNAL_XCPU = 24,
 183     TARGET_SIGNAL_XFSZ = 25,
 184     TARGET_SIGNAL_VTALRM = 26,
 185     TARGET_SIGNAL_PROF = 27,
 186     TARGET_SIGNAL_WINCH = 28,
 187     TARGET_SIGNAL_LOST = 29,
 188     TARGET_SIGNAL_USR1 = 30,
 189     TARGET_SIGNAL_USR2 = 31,
 190     TARGET_SIGNAL_PWR = 32,
 191     /* Similar to SIGIO.  Perhaps they should have the same number.  */
 192     TARGET_SIGNAL_POLL = 33,
 193     TARGET_SIGNAL_WIND = 34,
 194     TARGET_SIGNAL_PHONE = 35,
 195     TARGET_SIGNAL_WAITING = 36,
 196     TARGET_SIGNAL_LWP = 37,
 197     TARGET_SIGNAL_DANGER = 38,
 198     TARGET_SIGNAL_GRANT = 39,
 199     TARGET_SIGNAL_RETRACT = 40,
 200     TARGET_SIGNAL_MSG = 41,
 201     TARGET_SIGNAL_SOUND = 42,
 202     TARGET_SIGNAL_SAK = 43,
 203     TARGET_SIGNAL_PRIO = 44,
 204     TARGET_SIGNAL_REALTIME_33 = 45,
 205     TARGET_SIGNAL_REALTIME_34 = 46,
 206     TARGET_SIGNAL_REALTIME_35 = 47,
 207     TARGET_SIGNAL_REALTIME_36 = 48,
 208     TARGET_SIGNAL_REALTIME_37 = 49,
 209     TARGET_SIGNAL_REALTIME_38 = 50,
 210     TARGET_SIGNAL_REALTIME_39 = 51,
 211     TARGET_SIGNAL_REALTIME_40 = 52,
 212     TARGET_SIGNAL_REALTIME_41 = 53,
 213     TARGET_SIGNAL_REALTIME_42 = 54,
 214     TARGET_SIGNAL_REALTIME_43 = 55,
 215     TARGET_SIGNAL_REALTIME_44 = 56,
 216     TARGET_SIGNAL_REALTIME_45 = 57,
 217     TARGET_SIGNAL_REALTIME_46 = 58,
 218     TARGET_SIGNAL_REALTIME_47 = 59,
 219     TARGET_SIGNAL_REALTIME_48 = 60,
 220     TARGET_SIGNAL_REALTIME_49 = 61,
 221     TARGET_SIGNAL_REALTIME_50 = 62,
 222     TARGET_SIGNAL_REALTIME_51 = 63,
 223     TARGET_SIGNAL_REALTIME_52 = 64,
 224     TARGET_SIGNAL_REALTIME_53 = 65,
 225     TARGET_SIGNAL_REALTIME_54 = 66,
 226     TARGET_SIGNAL_REALTIME_55 = 67,
 227     TARGET_SIGNAL_REALTIME_56 = 68,
 228     TARGET_SIGNAL_REALTIME_57 = 69,
 229     TARGET_SIGNAL_REALTIME_58 = 70,
 230     TARGET_SIGNAL_REALTIME_59 = 71,
 231     TARGET_SIGNAL_REALTIME_60 = 72,
 232     TARGET_SIGNAL_REALTIME_61 = 73,
 233     TARGET_SIGNAL_REALTIME_62 = 74,
 234     TARGET_SIGNAL_REALTIME_63 = 75,
 235
 236     /* Used internally by Solaris threads.  See signal(5) on Solaris.  */
 237     TARGET_SIGNAL_CANCEL = 76,
 238
 239     /* Yes, this pains me, too.  But LynxOS didn't have SIG32, and now
 240        Linux does, and we can't disturb the numbering, since it's part
 241        of the protocol.  Note that in some GDB's TARGET_SIGNAL_REALTIME_32
 242        is number 76.  */
 243     TARGET_SIGNAL_REALTIME_32,
 244     /* Yet another pain, IRIX 6 has SIG64.  */
 245     TARGET_SIGNAL_REALTIME_64,
 246
 247 #if defined(MACH) || defined(__MACH__)
 248     /* Mach exceptions */
 249     TARGET_EXC_BAD_ACCESS,
 250     TARGET_EXC_BAD_INSTRUCTION,
 251     TARGET_EXC_ARITHMETIC,
 252     TARGET_EXC_EMULATION,
 253     TARGET_EXC_SOFTWARE,
 254     TARGET_EXC_BREAKPOINT,
 255 #endif
 256     TARGET_SIGNAL_INFO,
 257
 258     /* Some signal we don't know about.  */
 259     TARGET_SIGNAL_UNKNOWN,
 260
 261     /* Use whatever signal we use when one is not specifically specified
 262        (for passing to proceed and so on).  */
 263     TARGET_SIGNAL_DEFAULT,
 264
 265     /* Last and unused enum value, for sizing arrays, etc.  */
 266     TARGET_SIGNAL_LAST
 267   };
 268
 269 struct target_waitstatus
 270   {
 271     enum target_waitkind kind;
 272
 273     /* Forked child pid, execd pathname, exit status or signal number.  */
 274     union
 275       {
 276         int integer;
 277         enum target_signal sig;
 278         int related_pid;
 279         char *execd_pathname;
 280         int syscall_id;
 281       }
 282     value;
 283   };
 284
 285 /* Possible types of events that the inferior handler will have to
 286    deal with.  */
 287 enum inferior_event_type
 288   {
 289     /* There is a request to quit the inferior, abandon it.  */
 290     INF_QUIT_REQ,
 291     /* Process a normal inferior event which will result in target_wait
 292        being called.  */
 293     INF_REG_EVENT,
 294     /* Deal with an error on the inferior.  */
 295     INF_ERROR,
 296     /* We are called because a timer went off.  */
 297     INF_TIMER,
 298     /* We are called to do stuff after the inferior stops.  */
 299     INF_EXEC_COMPLETE,
 300     /* We are called to do some stuff after the inferior stops, but we
 301        are expected to reenter the proceed() and
 302        handle_inferior_event() functions. This is used only in case of
 303        'step n' like commands.  */
 304     INF_EXEC_CONTINUE
 305   };
 306
 307 /* Return the string for a signal.  */
 308 extern char *target_signal_to_string (enum target_signal);
 309
 310 /* Return the name (SIGHUP, etc.) for a signal.  */
 311 extern char *target_signal_to_name (enum target_signal);
 312
 313 /* Given a name (SIGHUP, etc.), return its signal.  */
 314 enum target_signal target_signal_from_name (char *);
 315 \f
 316
 317 /* If certain kinds of activity happen, target_wait should perform
 318    callbacks.  */
 319 /* Right now we just call (*TARGET_ACTIVITY_FUNCTION) if I/O is possible
 320    on TARGET_ACTIVITY_FD.  */
 321 extern int target_activity_fd;
 322 /* Returns zero to leave the inferior alone, one to interrupt it.  */
 323 extern int (*target_activity_function) (void);
 324 \f
 325 struct thread_info;             /* fwd decl for parameter list below: */
 326
 327 struct target_ops
 328   {
 329     char *to_shortname;         /* Name this target type */
 330     char *to_longname;          /* Name for printing */
 331     char *to_doc;               /* Documentation.  Does not include trailing
 332                                    newline, and starts with a one-line descrip-
 333                                    tion (probably similar to to_longname).  */
 334     void (*to_open) (char *, int);
 335     void (*to_close) (int);
 336     void (*to_attach) (char *, int);
 337     void (*to_post_attach) (int);
 338     void (*to_require_attach) (char *, int);
 339     void (*to_detach) (char *, int);
 340     void (*to_require_detach) (int, char *, int);
 341     void (*to_resume) (int, int, enum target_signal);
 342     int (*to_wait) (int, struct target_waitstatus *);
 343     void (*to_post_wait) (int, int);
 344     void (*to_fetch_registers) (int);
 345     void (*to_store_registers) (int);
 346     void (*to_prepare_to_store) (void);
 347
 348     /* Transfer LEN bytes of memory between GDB address MYADDR and
 349        target address MEMADDR.  If WRITE, transfer them to the target, else
 350        transfer them from the target.  TARGET is the target from which we
 351        get this function.
 352
 353        Return value, N, is one of the following:
 354
 355        0 means that we can't handle this.  If errno has been set, it is the
 356        error which prevented us from doing it (FIXME: What about bfd_error?).
 357
 358        positive (call it N) means that we have transferred N bytes
 359        starting at MEMADDR.  We might be able to handle more bytes
 360        beyond this length, but no promises.
 361
 362        negative (call its absolute value N) means that we cannot
 363        transfer right at MEMADDR, but we could transfer at least
 364        something at MEMADDR + N.  */
 365
 366     int (*to_xfer_memory) (CORE_ADDR memaddr, char *myaddr,
 367                            int len, int write,
 368                            struct mem_attrib *attrib,
 369                            struct target_ops *target);
 370
 371 #if 0
 372     /* Enable this after 4.12.  */
 373
 374     /* Search target memory.  Start at STARTADDR and take LEN bytes of
 375        target memory, and them with MASK, and compare to DATA.  If they
 376        match, set *ADDR_FOUND to the address we found it at, store the data
 377        we found at LEN bytes starting at DATA_FOUND, and return.  If
 378        not, add INCREMENT to the search address and keep trying until
 379        the search address is outside of the range [LORANGE,HIRANGE).
 380
 381        If we don't find anything, set *ADDR_FOUND to (CORE_ADDR)0 and
 382        return.  */
 383
 384     void (*to_search) (int len, char *data, char *mask,
 385                        CORE_ADDR startaddr, int increment,
 386                        CORE_ADDR lorange, CORE_ADDR hirange,
 387                        CORE_ADDR * addr_found, char *data_found);
 388
 389 #define target_search(len, data, mask, startaddr, increment, lorange, hirange, addr_found, data_found)  \
 390     (*current_target.to_search) (len, data, mask, startaddr, increment, \
 391                                  lorange, hirange, addr_found, data_found)
 392 #endif                          /* 0 */
 393
 394     void (*to_files_info) (struct target_ops *);
 395     int (*to_insert_breakpoint) (CORE_ADDR, char *);
 396     int (*to_remove_breakpoint) (CORE_ADDR, char *);
 397     void (*to_terminal_init) (void);
 398     void (*to_terminal_inferior) (void);
 399     void (*to_terminal_ours_for_output) (void);
 400     void (*to_terminal_ours) (void);
 401     void (*to_terminal_info) (char *, int);
 402     void (*to_kill) (void);
 403     void (*to_load) (char *, int);
 404     int (*to_lookup_symbol) (char *, CORE_ADDR *);
 405     void (*to_create_inferior) (char *, char *, char **);
 406     void (*to_post_startup_inferior) (int);
 407     void (*to_acknowledge_created_inferior) (int);
 408     void (*to_clone_and_follow_inferior) (int, int *);
 409     void (*to_post_follow_inferior_by_clone) (void);
 410     int (*to_insert_fork_catchpoint) (int);
 411     int (*to_remove_fork_catchpoint) (int);
 412     int (*to_insert_vfork_catchpoint) (int);
 413     int (*to_remove_vfork_catchpoint) (int);
 414     int (*to_has_forked) (int, int *);
 415     int (*to_has_vforked) (int, int *);
 416     int (*to_can_follow_vfork_prior_to_exec) (void);
 417     void (*to_post_follow_vfork) (int, int, int, int);
 418     int (*to_insert_exec_catchpoint) (int);
 419     int (*to_remove_exec_catchpoint) (int);
 420     int (*to_has_execd) (int, char **);
 421     int (*to_reported_exec_events_per_exec_call) (void);
 422     int (*to_has_syscall_event) (int, enum target_waitkind *, int *);
 423     int (*to_has_exited) (int, int, int *);
 424     void (*to_mourn_inferior) (void);
 425     int (*to_can_run) (void);
 426     void (*to_notice_signals) (int pid);
 427     int (*to_thread_alive) (int pid);
 428     void (*to_find_new_threads) (void);
 429     char *(*to_pid_to_str) (int);
 430     char *(*to_extra_thread_info) (struct thread_info *);
 431     void (*to_stop) (void);
 432     int (*to_query) (int /*char */ , char *, char *, int *);
 433     void (*to_rcmd) (char *command, struct ui_file *output);
 434     struct symtab_and_line *(*to_enable_exception_callback) (enum
 435                                                              exception_event_kind,
 436                                                              int);
 437     struct exception_event_record *(*to_get_current_exception_event) (void);
 438     char *(*to_pid_to_exec_file) (int pid);
 439     char *(*to_core_file_to_sym_file) (char *);
 440     enum strata to_stratum;
 441     struct target_ops
 442      *DONT_USE;                 /* formerly to_next */
 443     int to_has_all_memory;
 444     int to_has_memory;
 445     int to_has_stack;
 446     int to_has_registers;
 447     int to_has_execution;
 448     int to_has_thread_control;  /* control thread execution */
 449     struct section_table
 450      *to_sections;
 451     struct section_table
 452      *to_sections_end;
 453     /* ASYNC target controls */
 454     int (*to_can_async_p) (void);
 455     int (*to_is_async_p) (void);
 456     void (*to_async) (void (*cb) (enum inferior_event_type, void *context),
 457                       void *context);
 458     int to_async_mask_value;
 459     int to_magic;
 460     /* Need sub-structure for target machine related rather than comm related?
 461      */
 462   };
 463
 464 /* Magic number for checking ops size.  If a struct doesn't end with this
 465    number, somebody changed the declaration but didn't change all the
 466    places that initialize one.  */
 467
 468 #define OPS_MAGIC       3840
 469
 470 /* The ops structure for our "current" target process.  This should
 471    never be NULL.  If there is no target, it points to the dummy_target.  */
 472
 473 extern struct target_ops current_target;
 474
 475 /* An item on the target stack.  */
 476
 477 struct target_stack_item
 478   {
 479     struct target_stack_item *next;
 480     struct target_ops *target_ops;
 481   };
 482
 483 /* The target stack.  */
 484
 485 extern struct target_stack_item *target_stack;
 486
 487 /* Define easy words for doing these operations on our current target.  */
 488
 489 #define target_shortname        (current_target.to_shortname)
 490 #define target_longname         (current_target.to_longname)
 491
 492 /* The open routine takes the rest of the parameters from the command,
 493    and (if successful) pushes a new target onto the stack.
 494    Targets should supply this routine, if only to provide an error message.  */
 495
 496 #define target_open(name, from_tty)                                     \
 497   do {                                                                  \
 498     dcache_invalidate (target_dcache);                                  \
 499     (*current_target.to_open) (name, from_tty);                         \
 500   } while (0)
 501
 502 /* Does whatever cleanup is required for a target that we are no longer
 503    going to be calling.  Argument says whether we are quitting gdb and
 504    should not get hung in case of errors, or whether we want a clean
 505    termination even if it takes a while.  This routine is automatically
 506    always called just before a routine is popped off the target stack.
 507    Closing file descriptors and freeing memory are typical things it should
 508    do.  */
 509
 510 #define target_close(quitting)  \
 511      (*current_target.to_close) (quitting)
 512
 513 /* Attaches to a process on the target side.  Arguments are as passed
 514    to the `attach' command by the user.  This routine can be called
 515    when the target is not on the target-stack, if the target_can_run
 516    routine returns 1; in that case, it must push itself onto the stack.
 517    Upon exit, the target should be ready for normal operations, and
 518    should be ready to deliver the status of the process immediately
 519    (without waiting) to an upcoming target_wait call.  */
 520
 521 #define target_attach(args, from_tty)   \
 522      (*current_target.to_attach) (args, from_tty)
 523
 524 /* The target_attach operation places a process under debugger control,
 525    and stops the process.
 526
 527    This operation provides a target-specific hook that allows the
 528    necessary bookkeeping to be performed after an attach completes.  */
 529 #define target_post_attach(pid) \
 530      (*current_target.to_post_attach) (pid)
 531
 532 /* Attaches to a process on the target side, if not already attached.
 533    (If already attached, takes no action.)
 534
 535    This operation can be used to follow the child process of a fork.
 536    On some targets, such child processes of an original inferior process
 537    are automatically under debugger control, and thus do not require an
 538    actual attach operation.  */
 539
 540 #define target_require_attach(args, from_tty)   \
 541      (*current_target.to_require_attach) (args, from_tty)
 542
 543 /* Takes a program previously attached to and detaches it.
 544    The program may resume execution (some targets do, some don't) and will
 545    no longer stop on signals, etc.  We better not have left any breakpoints
 546    in the program or it'll die when it hits one.  ARGS is arguments
 547    typed by the user (e.g. a signal to send the process).  FROM_TTY
 548    says whether to be verbose or not.  */
 549
 550 extern void target_detach (char *, int);
 551
 552 /* Detaches from a process on the target side, if not already dettached.
 553    (If already detached, takes no action.)
 554
 555    This operation can be used to follow the parent process of a fork.
 556    On some targets, such child processes of an original inferior process
 557    are automatically under debugger control, and thus do require an actual
 558    detach operation.
 559
 560    PID is the process id of the child to detach from.
 561    ARGS is arguments typed by the user (e.g. a signal to send the process).
 562    FROM_TTY says whether to be verbose or not.  */
 563
 564 #define target_require_detach(pid, args, from_tty)      \
 565      (*current_target.to_require_detach) (pid, args, from_tty)
 566
 567 /* Resume execution of the target process PID.  STEP says whether to
 568    single-step or to run free; SIGGNAL is the signal to be given to
 569    the target, or TARGET_SIGNAL_0 for no signal.  The caller may not
 570    pass TARGET_SIGNAL_DEFAULT.  */
 571
 572 #define target_resume(pid, step, siggnal)                               \
 573   do {                                                                  \
 574     dcache_invalidate(target_dcache);                                   \
 575     (*current_target.to_resume) (pid, step, siggnal);                   \
 576   } while (0)
 577
 578 /* Wait for process pid to do something.  Pid = -1 to wait for any pid
 579    to do something.  Return pid of child, or -1 in case of error;
 580    store status through argument pointer STATUS.  Note that it is
 581    *not* OK to return_to_top_level out of target_wait without popping
 582    the debugging target from the stack; GDB isn't prepared to get back
 583    to the prompt with a debugging target but without the frame cache,
 584    stop_pc, etc., set up.  */
 585
 586 #define target_wait(pid, status)                \
 587      (*current_target.to_wait) (pid, status)
 588
 589 /* The target_wait operation waits for a process event to occur, and
 590    thereby stop the process.
 591
 592    On some targets, certain events may happen in sequences.  gdb's
 593    correct response to any single event of such a sequence may require
 594    knowledge of what earlier events in the sequence have been seen.
 595
 596    This operation provides a target-specific hook that allows the
 597    necessary bookkeeping to be performed to track such sequences.  */
 598
 599 #define target_post_wait(pid, status) \
 600      (*current_target.to_post_wait) (pid, status)
 601
 602 /* Fetch at least register REGNO, or all regs if regno == -1.  No result.  */
 603
 604 #define target_fetch_registers(regno)   \
 605      (*current_target.to_fetch_registers) (regno)
 606
 607 /* Store at least register REGNO, or all regs if REGNO == -1.
 608    It can store as many registers as it wants to, so target_prepare_to_store
 609    must have been previously called.  Calls error() if there are problems.  */
 610
 611 #define target_store_registers(regs)    \
 612      (*current_target.to_store_registers) (regs)
 613
 614 /* Get ready to modify the registers array.  On machines which store
 615    individual registers, this doesn't need to do anything.  On machines
 616    which store all the registers in one fell swoop, this makes sure
 617    that REGISTERS contains all the registers from the program being
 618    debugged.  */
 619
 620 #define target_prepare_to_store()       \
 621      (*current_target.to_prepare_to_store) ()
 622
 623 extern DCACHE *target_dcache;
 624
 625 extern int do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 626                            struct mem_attrib *attrib);
 627
 628 extern int target_read_string (CORE_ADDR, char **, int, int *);
 629
 630 extern int target_read_memory (CORE_ADDR memaddr, char *myaddr, int len);
 631
 632 extern int target_write_memory (CORE_ADDR memaddr, char *myaddr, int len);
 633
 634 extern int xfer_memory (CORE_ADDR, char *, int, int,
 635                         struct mem_attrib *, struct target_ops *);
 636
 637 extern int child_xfer_memory (CORE_ADDR, char *, int, int,
 638                               struct mem_attrib *, struct target_ops *);
 639
 640 /* Make a single attempt at transfering LEN bytes.  On a successful
 641    transfer, the number of bytes actually transfered is returned and
 642    ERR is set to 0.  When a transfer fails, -1 is returned (the number
 643    of bytes actually transfered is not defined) and ERR is set to a
 644    non-zero error indication.  */
 645
 646 extern int
 647 target_read_memory_partial (CORE_ADDR addr, char *buf, int len, int *err);
 648
 649 extern int
 650 target_write_memory_partial (CORE_ADDR addr, char *buf, int len, int *err);
 651
 652 extern char *child_pid_to_exec_file (int);
 653
 654 extern char *child_core_file_to_sym_file (char *);
 655
 656 #if defined(CHILD_POST_ATTACH)
 657 extern void child_post_attach (int);
 658 #endif
 659
 660 extern void child_post_wait (int, int);
 661
 662 extern void child_post_startup_inferior (int);
 663
 664 extern void child_acknowledge_created_inferior (int);
 665
 666 extern void child_clone_and_follow_inferior (int, int *);
 667
 668 extern void child_post_follow_inferior_by_clone (void);
 669
 670 extern int child_insert_fork_catchpoint (int);
 671
 672 extern int child_remove_fork_catchpoint (int);
 673
 674 extern int child_insert_vfork_catchpoint (int);
 675
 676 extern int child_remove_vfork_catchpoint (int);
 677
 678 extern int child_has_forked (int, int *);
 679
 680 extern int child_has_vforked (int, int *);
 681
 682 extern void child_acknowledge_created_inferior (int);
 683
 684 extern int child_can_follow_vfork_prior_to_exec (void);
 685
 686 extern void child_post_follow_vfork (int, int, int, int);
 687
 688 extern int child_insert_exec_catchpoint (int);
 689
 690 extern int child_remove_exec_catchpoint (int);
 691
 692 extern int child_has_execd (int, char **);
 693
 694 extern int child_reported_exec_events_per_exec_call (void);
 695
 696 extern int child_has_syscall_event (int, enum target_waitkind *, int *);
 697
 698 extern int child_has_exited (int, int, int *);
 699
 700 extern int child_thread_alive (int);
 701
 702 /* From exec.c */
 703
 704 extern void print_section_info (struct target_ops *, bfd *);
 705
 706 /* Print a line about the current target.  */
 707
 708 #define target_files_info()     \
 709      (*current_target.to_files_info) (&current_target)
 710
 711 /* Insert a breakpoint at address ADDR in the target machine.
 712    SAVE is a pointer to memory allocated for saving the
 713    target contents.  It is guaranteed by the caller to be long enough
 714    to save "sizeof BREAKPOINT" bytes.  Result is 0 for success, or
 715    an errno value.  */
 716
 717 #define target_insert_breakpoint(addr, save)    \
 718      (*current_target.to_insert_breakpoint) (addr, save)
 719
 720 /* Remove a breakpoint at address ADDR in the target machine.
 721    SAVE is a pointer to the same save area
 722    that was previously passed to target_insert_breakpoint.
 723    Result is 0 for success, or an errno value.  */
 724
 725 #define target_remove_breakpoint(addr, save)    \
 726      (*current_target.to_remove_breakpoint) (addr, save)
 727
 728 /* Initialize the terminal settings we record for the inferior,
 729    before we actually run the inferior.  */
 730
 731 #define target_terminal_init() \
 732      (*current_target.to_terminal_init) ()
 733
 734 /* Put the inferior's terminal settings into effect.
 735    This is preparation for starting or resuming the inferior.  */
 736
 737 #define target_terminal_inferior() \
 738      (*current_target.to_terminal_inferior) ()
 739
 740 /* Put some of our terminal settings into effect,
 741    enough to get proper results from our output,
 742    but do not change into or out of RAW mode
 743    so that no input is discarded.
 744
 745    After doing this, either terminal_ours or terminal_inferior
 746    should be called to get back to a normal state of affairs.  */
 747
 748 #define target_terminal_ours_for_output() \
 749      (*current_target.to_terminal_ours_for_output) ()
 750
 751 /* Put our terminal settings into effect.
 752    First record the inferior's terminal settings
 753    so they can be restored properly later.  */
 754
 755 #define target_terminal_ours() \
 756      (*current_target.to_terminal_ours) ()
 757
 758 /* Print useful information about our terminal status, if such a thing
 759    exists.  */
 760
 761 #define target_terminal_info(arg, from_tty) \
 762      (*current_target.to_terminal_info) (arg, from_tty)
 763
 764 /* Kill the inferior process.   Make it go away.  */
 765
 766 #define target_kill() \
 767      (*current_target.to_kill) ()
 768
 769 /* Load an executable file into the target process.  This is expected
 770    to not only bring new code into the target process, but also to
 771    update GDB's symbol tables to match.  */
 772
 773 extern void target_load (char *arg, int from_tty);
 774
 775 /* Look up a symbol in the target's symbol table.  NAME is the symbol
 776    name.  ADDRP is a CORE_ADDR * pointing to where the value of the
 777    symbol should be returned.  The result is 0 if successful, nonzero
 778    if the symbol does not exist in the target environment.  This
 779    function should not call error() if communication with the target
 780    is interrupted, since it is called from symbol reading, but should
 781    return nonzero, possibly doing a complain().  */
 782
 783 #define target_lookup_symbol(name, addrp) \
 784      (*current_target.to_lookup_symbol) (name, addrp)
 785
 786 /* Start an inferior process and set inferior_pid to its pid.
 787    EXEC_FILE is the file to run.
 788    ALLARGS is a string containing the arguments to the program.
 789    ENV is the environment vector to pass.  Errors reported with error().
 790    On VxWorks and various standalone systems, we ignore exec_file.  */
 791
 792 #define target_create_inferior(exec_file, args, env)    \
 793      (*current_target.to_create_inferior) (exec_file, args, env)
 794
 795
 796 /* Some targets (such as ttrace-based HPUX) don't allow us to request
 797    notification of inferior events such as fork and vork immediately
 798    after the inferior is created.  (This because of how gdb gets an
 799    inferior created via invoking a shell to do it.  In such a scenario,
 800    if the shell init file has commands in it, the shell will fork and
 801    exec for each of those commands, and we will see each such fork
 802    event.  Very bad.)
 803
 804    Such targets will supply an appropriate definition for this function.  */
 805
 806 #define target_post_startup_inferior(pid) \
 807      (*current_target.to_post_startup_inferior) (pid)
 808
 809 /* On some targets, the sequence of starting up an inferior requires
 810    some synchronization between gdb and the new inferior process, PID.  */
 811
 812 #define target_acknowledge_created_inferior(pid) \
 813      (*current_target.to_acknowledge_created_inferior) (pid)
 814
 815 /* An inferior process has been created via a fork() or similar
 816    system call.  This function will clone the debugger, then ensure
 817    that CHILD_PID is attached to by that debugger.
 818
 819    FOLLOWED_CHILD is set TRUE on return *for the clone debugger only*,
 820    and FALSE otherwise.  (The original and clone debuggers can use this
 821    to determine which they are, if need be.)
 822
 823    (This is not a terribly useful feature without a GUI to prevent
 824    the two debuggers from competing for shell input.)  */
 825
 826 #define target_clone_and_follow_inferior(child_pid,followed_child) \
 827      (*current_target.to_clone_and_follow_inferior) (child_pid, followed_child)
 828
 829 /* This operation is intended to be used as the last in a sequence of
 830    steps taken when following both parent and child of a fork.  This
 831    is used by a clone of the debugger, which will follow the child.
 832
 833    The original debugger has detached from this process, and the
 834    clone has attached to it.
 835
 836    On some targets, this requires a bit of cleanup to make it work
 837    correctly.  */
 838
 839 #define target_post_follow_inferior_by_clone() \
 840      (*current_target.to_post_follow_inferior_by_clone) ()
 841
 842 /* On some targets, we can catch an inferior fork or vfork event when
 843    it occurs.  These functions insert/remove an already-created
 844    catchpoint for such events.  */
 845
 846 #define target_insert_fork_catchpoint(pid) \
 847      (*current_target.to_insert_fork_catchpoint) (pid)
 848
 849 #define target_remove_fork_catchpoint(pid) \
 850      (*current_target.to_remove_fork_catchpoint) (pid)
 851
 852 #define target_insert_vfork_catchpoint(pid) \
 853      (*current_target.to_insert_vfork_catchpoint) (pid)
 854
 855 #define target_remove_vfork_catchpoint(pid) \
 856      (*current_target.to_remove_vfork_catchpoint) (pid)
 857
 858 /* Returns TRUE if PID has invoked the fork() system call.  And,
 859    also sets CHILD_PID to the process id of the other ("child")
 860    inferior process that was created by that call.  */
 861
 862 #define target_has_forked(pid,child_pid) \
 863      (*current_target.to_has_forked) (pid,child_pid)
 864
 865 /* Returns TRUE if PID has invoked the vfork() system call.  And,
 866    also sets CHILD_PID to the process id of the other ("child")
 867    inferior process that was created by that call.  */
 868
 869 #define target_has_vforked(pid,child_pid) \
 870      (*current_target.to_has_vforked) (pid,child_pid)
 871
 872 /* Some platforms (such as pre-10.20 HP-UX) don't allow us to do
 873    anything to a vforked child before it subsequently calls exec().
 874    On such platforms, we say that the debugger cannot "follow" the
 875    child until it has vforked.
 876
 877    This function should be defined to return 1 by those targets
 878    which can allow the debugger to immediately follow a vforked
 879    child, and 0 if they cannot.  */
 880
 881 #define target_can_follow_vfork_prior_to_exec() \
 882      (*current_target.to_can_follow_vfork_prior_to_exec) ()
 883
 884 /* An inferior process has been created via a vfork() system call.
 885    The debugger has followed the parent, the child, or both.  The
 886    process of setting up for that follow may have required some
 887    target-specific trickery to track the sequence of reported events.
 888    If so, this function should be defined by those targets that
 889    require the debugger to perform cleanup or initialization after
 890    the vfork follow.  */
 891
 892 #define target_post_follow_vfork(parent_pid,followed_parent,child_pid,followed_child) \
 893      (*current_target.to_post_follow_vfork) (parent_pid,followed_parent,child_pid,followed_child)
 894
 895 /* On some targets, we can catch an inferior exec event when it
 896    occurs.  These functions insert/remove an already-created
 897    catchpoint for such events.  */
 898
 899 #define target_insert_exec_catchpoint(pid) \
 900      (*current_target.to_insert_exec_catchpoint) (pid)
 901
 902 #define target_remove_exec_catchpoint(pid) \
 903      (*current_target.to_remove_exec_catchpoint) (pid)
 904
 905 /* Returns TRUE if PID has invoked a flavor of the exec() system call.
 906    And, also sets EXECD_PATHNAME to the pathname of the executable
 907    file that was passed to exec(), and is now being executed.  */
 908
 909 #define target_has_execd(pid,execd_pathname) \
 910      (*current_target.to_has_execd) (pid,execd_pathname)
 911
 912 /* Returns the number of exec events that are reported when a process
 913    invokes a flavor of the exec() system call on this target, if exec
 914    events are being reported.  */
 915
 916 #define target_reported_exec_events_per_exec_call() \
 917      (*current_target.to_reported_exec_events_per_exec_call) ()
 918
 919 /* Returns TRUE if PID has reported a syscall event.  And, also sets
 920    KIND to the appropriate TARGET_WAITKIND_, and sets SYSCALL_ID to
 921    the unique integer ID of the syscall.  */
 922
 923 #define target_has_syscall_event(pid,kind,syscall_id) \
 924      (*current_target.to_has_syscall_event) (pid,kind,syscall_id)
 925
 926 /* Returns TRUE if PID has exited.  And, also sets EXIT_STATUS to the
 927    exit code of PID, if any.  */
 928
 929 #define target_has_exited(pid,wait_status,exit_status) \
 930      (*current_target.to_has_exited) (pid,wait_status,exit_status)
 931
 932 /* The debugger has completed a blocking wait() call.  There is now
 933    some process event that must be processed.  This function should
 934    be defined by those targets that require the debugger to perform
 935    cleanup or internal state changes in response to the process event.  */
 936
 937 /* The inferior process has died.  Do what is right.  */
 938
 939 #define target_mourn_inferior() \
 940      (*current_target.to_mourn_inferior) ()
 941
 942 /* Does target have enough data to do a run or attach command? */
 943
 944 #define target_can_run(t) \
 945      ((t)->to_can_run) ()
 946
 947 /* post process changes to signal handling in the inferior.  */
 948
 949 #define target_notice_signals(pid) \
 950      (*current_target.to_notice_signals) (pid)
 951
 952 /* Check to see if a thread is still alive.  */
 953
 954 #define target_thread_alive(pid) \
 955      (*current_target.to_thread_alive) (pid)
 956
 957 /* Query for new threads and add them to the thread list.  */
 958
 959 #define target_find_new_threads() \
 960      (*current_target.to_find_new_threads) (); \
 961
 962 /* Make target stop in a continuable fashion.  (For instance, under
 963    Unix, this should act like SIGSTOP).  This function is normally
 964    used by GUIs to implement a stop button.  */
 965
 966 #define target_stop current_target.to_stop
 967
 968 /* Queries the target side for some information.  The first argument is a
 969    letter specifying the type of the query, which is used to determine who
 970    should process it.  The second argument is a string that specifies which
 971    information is desired and the third is a buffer that carries back the
 972    response from the target side. The fourth parameter is the size of the
 973    output buffer supplied.  */
 974
 975 #define target_query(query_type, query, resp_buffer, bufffer_size)      \
 976      (*current_target.to_query) (query_type, query, resp_buffer, bufffer_size)
 977
 978 /* Send the specified COMMAND to the target's monitor
 979    (shell,interpreter) for execution.  The result of the query is
 980    placed in OUTBUF.  */
 981
 982 #define target_rcmd(command, outbuf) \
 983      (*current_target.to_rcmd) (command, outbuf)
 984
 985
 986 /* Get the symbol information for a breakpointable routine called when
 987    an exception event occurs.
 988    Intended mainly for C++, and for those
 989    platforms/implementations where such a callback mechanism is available,
 990    e.g. HP-UX with ANSI C++ (aCC).  Some compilers (e.g. g++) support
 991    different mechanisms for debugging exceptions.  */
 992
 993 #define target_enable_exception_callback(kind, enable) \
 994      (*current_target.to_enable_exception_callback) (kind, enable)
 995
 996 /* Get the current exception event kind -- throw or catch, etc.  */
 997
 998 #define target_get_current_exception_event() \
 999      (*current_target.to_get_current_exception_event) ()
1000
1001 /* Pointer to next target in the chain, e.g. a core file and an exec file.  */
1002
1003 #define target_next \
1004      (current_target.to_next)
1005
1006 /* Does the target include all of memory, or only part of it?  This
1007    determines whether we look up the target chain for other parts of
1008    memory if this target can't satisfy a request.  */
1009
1010 #define target_has_all_memory   \
1011      (current_target.to_has_all_memory)
1012
1013 /* Does the target include memory?  (Dummy targets don't.)  */
1014
1015 #define target_has_memory       \
1016      (current_target.to_has_memory)
1017
1018 /* Does the target have a stack?  (Exec files don't, VxWorks doesn't, until
1019    we start a process.)  */
1020
1021 #define target_has_stack        \
1022      (current_target.to_has_stack)
1023
1024 /* Does the target have registers?  (Exec files don't.)  */
1025
1026 #define target_has_registers    \
1027      (current_target.to_has_registers)
1028
1029 /* Does the target have execution?  Can we make it jump (through
1030    hoops), or pop its stack a few times?  FIXME: If this is to work that
1031    way, it needs to check whether an inferior actually exists.
1032    remote-udi.c and probably other targets can be the current target
1033    when the inferior doesn't actually exist at the moment.  Right now
1034    this just tells us whether this target is *capable* of execution.  */
1035
1036 #define target_has_execution    \
1037      (current_target.to_has_execution)
1038
1039 /* Can the target support the debugger control of thread execution?
1040    a) Can it lock the thread scheduler?
1041    b) Can it switch the currently running thread?  */
1042
1043 #define target_can_lock_scheduler \
1044      (current_target.to_has_thread_control & tc_schedlock)
1045
1046 #define target_can_switch_threads \
1047      (current_target.to_has_thread_control & tc_switch)
1048
1049 /* Can the target support asynchronous execution? */
1050 #define target_can_async_p() (current_target.to_can_async_p ())
1051
1052 /* Is the target in asynchronous execution mode? */
1053 #define target_is_async_p() (current_target.to_is_async_p())
1054
1055 /* Put the target in async mode with the specified callback function. */
1056 #define target_async(CALLBACK,CONTEXT) \
1057      (current_target.to_async((CALLBACK), (CONTEXT)))
1058
1059 /* This is to be used ONLY within run_stack_dummy(). It
1060    provides a workaround, to have inferior function calls done in
1061    sychronous mode, even though the target is asynchronous. After
1062    target_async_mask(0) is called, calls to target_can_async_p() will
1063    return FALSE , so that target_resume() will not try to start the
1064    target asynchronously. After the inferior stops, we IMMEDIATELY
1065    restore the previous nature of the target, by calling
1066    target_async_mask(1). After that, target_can_async_p() will return
1067    TRUE. ANY OTHER USE OF THIS FEATURE IS DEPRECATED.
1068
1069    FIXME ezannoni 1999-12-13: we won't need this once we move
1070    the turning async on and off to the single execution commands,
1071    from where it is done currently, in remote_resume().  */
1072
1073 #define target_async_mask_value \
1074      (current_target.to_async_mask_value)
1075
1076 extern int target_async_mask (int mask);
1077
1078 extern void target_link (char *, CORE_ADDR *);
1079
1080 /* Converts a process id to a string.  Usually, the string just contains
1081    `process xyz', but on some systems it may contain
1082    `process xyz thread abc'.  */
1083
1084 #undef target_pid_to_str
1085 #define target_pid_to_str(PID) current_target.to_pid_to_str (PID)
1086
1087 #ifndef target_tid_to_str
1088 #define target_tid_to_str(PID) \
1089      target_pid_to_str (PID)
1090 extern char *normal_pid_to_str (int pid);
1091 #endif
1092
1093 /* Return a short string describing extra information about PID,
1094    e.g. "sleeping", "runnable", "running on LWP 3".  Null return value
1095    is okay.  */
1096
1097 #define target_extra_thread_info(TP) \
1098      (current_target.to_extra_thread_info (TP))
1099
1100 /*
1101  * New Objfile Event Hook:
1102  *
1103  * Sometimes a GDB component wants to get notified whenever a new
1104  * objfile is loaded.  Mainly this is used by thread-debugging
1105  * implementations that need to know when symbols for the target
1106  * thread implemenation are available.
1107  *
1108  * The old way of doing this is to define a macro 'target_new_objfile'
1109  * that points to the function that you want to be called on every
1110  * objfile/shlib load.
1111  *
1112  * The new way is to grab the function pointer, 'target_new_objfile_hook',
1113  * and point it to the function that you want to be called on every
1114  * objfile/shlib load.
1115  *
1116  * If multiple clients are willing to be cooperative, they can each
1117  * save a pointer to the previous value of target_new_objfile_hook
1118  * before modifying it, and arrange for their function to call the
1119  * previous function in the chain.  In that way, multiple clients
1120  * can receive this notification (something like with signal handlers).
1121  */
1122
1123 extern void (*target_new_objfile_hook) (struct objfile *);
1124
1125 #ifndef target_pid_or_tid_to_str
1126 #define target_pid_or_tid_to_str(ID) \
1127      target_pid_to_str (ID)
1128 #endif
1129
1130 /* Attempts to find the pathname of the executable file
1131    that was run to create a specified process.
1132
1133    The process PID must be stopped when this operation is used.
1134
1135    If the executable file cannot be determined, NULL is returned.
1136
1137    Else, a pointer to a character string containing the pathname
1138    is returned.  This string should be copied into a buffer by
1139    the client if the string will not be immediately used, or if
1140    it must persist.  */
1141
1142 #define target_pid_to_exec_file(pid) \
1143      (current_target.to_pid_to_exec_file) (pid)
1144
1145 /* Hook to call target-dependent code after reading in a new symbol table.  */
1146
1147 #ifndef TARGET_SYMFILE_POSTREAD
1148 #define TARGET_SYMFILE_POSTREAD(OBJFILE)
1149 #endif
1150
1151 /* Hook to call target dependent code just after inferior target process has
1152    started.  */
1153
1154 #ifndef TARGET_CREATE_INFERIOR_HOOK
1155 #define TARGET_CREATE_INFERIOR_HOOK(PID)
1156 #endif
1157
1158 /* Hardware watchpoint interfaces.  */
1159
1160 /* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
1161    write).  */
1162
1163 #ifndef STOPPED_BY_WATCHPOINT
1164 #define STOPPED_BY_WATCHPOINT(w) 0
1165 #endif
1166
1167 /* HP-UX supplies these operations, which respectively disable and enable
1168    the memory page-protections that are used to implement hardware watchpoints
1169    on that platform.  See wait_for_inferior's use of these.  */
1170
1171 #if !defined(TARGET_DISABLE_HW_WATCHPOINTS)
1172 #define TARGET_DISABLE_HW_WATCHPOINTS(pid)
1173 #endif
1174
1175 #if !defined(TARGET_ENABLE_HW_WATCHPOINTS)
1176 #define TARGET_ENABLE_HW_WATCHPOINTS(pid)
1177 #endif
1178
1179 /* Provide defaults for systems that don't support hardware watchpoints.  */
1180
1181 #ifndef TARGET_HAS_HARDWARE_WATCHPOINTS
1182
1183 /* Returns non-zero if we can set a hardware watchpoint of type TYPE.  TYPE is
1184    one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, or
1185    bp_hardware_breakpoint.  CNT is the number of such watchpoints used so far
1186    (including this one?).  OTHERTYPE is who knows what...  */
1187
1188 #define TARGET_CAN_USE_HARDWARE_WATCHPOINT(TYPE,CNT,OTHERTYPE) 0
1189
1190 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
1191 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(byte_count) \
1192      ((LONGEST)(byte_count) <= REGISTER_SIZE)
1193 #endif
1194
1195 /* However, some addresses may not be profitable to use hardware to watch,
1196    or may be difficult to understand when the addressed object is out of
1197    scope, and hence should be unwatched.  On some targets, this may have
1198    severe performance penalties, such that we might as well use regular
1199    watchpoints, and save (possibly precious) hardware watchpoints for other
1200    locations.  */
1201
1202 #if !defined(TARGET_RANGE_PROFITABLE_FOR_HW_WATCHPOINT)
1203 #define TARGET_RANGE_PROFITABLE_FOR_HW_WATCHPOINT(pid,start,len) 0
1204 #endif
1205
1206
1207 /* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes.  TYPE is 0
1208    for write, 1 for read, and 2 for read/write accesses.  Returns 0 for
1209    success, non-zero for failure.  */
1210
1211 #define target_remove_watchpoint(ADDR,LEN,TYPE) -1
1212 #define target_insert_watchpoint(ADDR,LEN,TYPE) -1
1213
1214 #endif /* TARGET_HAS_HARDWARE_WATCHPOINTS */
1215
1216 #ifndef target_insert_hw_breakpoint
1217 #define target_remove_hw_breakpoint(ADDR,SHADOW) -1
1218 #define target_insert_hw_breakpoint(ADDR,SHADOW) -1
1219 #endif
1220
1221 #ifndef target_stopped_data_address
1222 #define target_stopped_data_address() 0
1223 #endif
1224
1225 /* If defined, then we need to decr pc by this much after a hardware break-
1226    point.  Presumably this overrides DECR_PC_AFTER_BREAK...  */
1227
1228 #ifndef DECR_PC_AFTER_HW_BREAK
1229 #define DECR_PC_AFTER_HW_BREAK 0
1230 #endif
1231
1232 /* Sometimes gdb may pick up what appears to be a valid target address
1233    from a minimal symbol, but the value really means, essentially,
1234    "This is an index into a table which is populated when the inferior
1235    is run.  Therefore, do not attempt to use this as a PC."  */
1236
1237 #if !defined(PC_REQUIRES_RUN_BEFORE_USE)
1238 #define PC_REQUIRES_RUN_BEFORE_USE(pc) (0)
1239 #endif
1240
1241 /* This will only be defined by a target that supports catching vfork events,
1242    such as HP-UX.
1243
1244    On some targets (such as HP-UX 10.20 and earlier), resuming a newly vforked
1245    child process after it has exec'd, causes the parent process to resume as
1246    well.  To prevent the parent from running spontaneously, such targets should
1247    define this to a function that prevents that from happening.  */
1248 #if !defined(ENSURE_VFORKING_PARENT_REMAINS_STOPPED)
1249 #define ENSURE_VFORKING_PARENT_REMAINS_STOPPED(PID) (0)
1250 #endif
1251
1252 /* This will only be defined by a target that supports catching vfork events,
1253    such as HP-UX.
1254
1255    On some targets (such as HP-UX 10.20 and earlier), a newly vforked child
1256    process must be resumed when it delivers its exec event, before the parent
1257    vfork event will be delivered to us.  */
1258
1259 #if !defined(RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK)
1260 #define RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK() (0)
1261 #endif
1262
1263 /* Routines for maintenance of the target structures...
1264
1265    add_target:   Add a target to the list of all possible targets.
1266
1267    push_target:  Make this target the top of the stack of currently used
1268    targets, within its particular stratum of the stack.  Result
1269    is 0 if now atop the stack, nonzero if not on top (maybe
1270    should warn user).
1271
1272    unpush_target: Remove this from the stack of currently used targets,
1273    no matter where it is on the list.  Returns 0 if no
1274    change, 1 if removed from stack.
1275
1276    pop_target:   Remove the top thing on the stack of current targets.  */
1277
1278 extern void add_target (struct target_ops *);
1279
1280 extern int push_target (struct target_ops *);
1281
1282 extern int unpush_target (struct target_ops *);
1283
1284 extern void target_preopen (int);
1285
1286 extern void pop_target (void);
1287
1288 /* Struct section_table maps address ranges to file sections.  It is
1289    mostly used with BFD files, but can be used without (e.g. for handling
1290    raw disks, or files not in formats handled by BFD).  */
1291
1292 struct section_table
1293   {
1294     CORE_ADDR addr;             /* Lowest address in section */
1295     CORE_ADDR endaddr;          /* 1+highest address in section */
1296
1297     sec_ptr the_bfd_section;
1298
1299     bfd *bfd;                   /* BFD file pointer */
1300   };
1301
1302 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
1303    Returns 0 if OK, 1 on error.  */
1304
1305 extern int
1306 build_section_table (bfd *, struct section_table **, struct section_table **);
1307
1308 /* From mem-break.c */
1309
1310 extern int memory_remove_breakpoint (CORE_ADDR, char *);
1311
1312 extern int memory_insert_breakpoint (CORE_ADDR, char *);
1313
1314 extern int default_memory_remove_breakpoint (CORE_ADDR, char *);
1315
1316 extern int default_memory_insert_breakpoint (CORE_ADDR, char *);
1317
1318 extern breakpoint_from_pc_fn memory_breakpoint_from_pc;
1319
1320
1321 /* From target.c */
1322
1323 extern void initialize_targets (void);
1324
1325 extern void noprocess (void);
1326
1327 extern void find_default_attach (char *, int);
1328
1329 extern void find_default_require_attach (char *, int);
1330
1331 extern void find_default_require_detach (int, char *, int);
1332
1333 extern void find_default_create_inferior (char *, char *, char **);
1334
1335 extern void find_default_clone_and_follow_inferior (int, int *);
1336
1337 extern struct target_ops *find_run_target (void);
1338
1339 extern struct target_ops *find_core_target (void);
1340
1341 extern struct target_ops *find_target_beneath (struct target_ops *);
1342
1343 extern int
1344 target_resize_to_sections (struct target_ops *target, int num_added);
1345
1346 extern void remove_target_sections (bfd *abfd);
1347
1348 \f
1349 /* Stuff that should be shared among the various remote targets.  */
1350
1351 /* Debugging level.  0 is off, and non-zero values mean to print some debug
1352    information (higher values, more information).  */
1353 extern int remote_debug;
1354
1355 /* Speed in bits per second, or -1 which means don't mess with the speed.  */
1356 extern int baud_rate;
1357 /* Timeout limit for response from target. */
1358 extern int remote_timeout;
1359
1360 \f
1361 /* Functions for helping to write a native target.  */
1362
1363 /* This is for native targets which use a unix/POSIX-style waitstatus.  */
1364 extern void store_waitstatus (struct target_waitstatus *, int);
1365
1366 /* Predicate to target_signal_to_host(). Return non-zero if the enum
1367    targ_signal SIGNO has an equivalent ``host'' representation.  */
1368 /* FIXME: cagney/1999-11-22: The name below was chosen in preference
1369    to the shorter target_signal_p() because it is far less ambigious.
1370    In this context ``target_signal'' refers to GDB's internal
1371    representation of the target's set of signals while ``host signal''
1372    refers to the target operating system's signal.  Confused?  */
1373
1374 extern int target_signal_to_host_p (enum target_signal signo);
1375
1376 /* Convert between host signal numbers and enum target_signal's.
1377    target_signal_to_host() returns 0 and prints a warning() on GDB's
1378    console if SIGNO has no equivalent host representation.  */
1379 /* FIXME: cagney/1999-11-22: Here ``host'' is used incorrectly, it is
1380    refering to the target operating system's signal numbering.
1381    Similarly, ``enum target_signal'' is named incorrectly, ``enum
1382    gdb_signal'' would probably be better as it is refering to GDB's
1383    internal representation of a target operating system's signal.  */
1384
1385 extern enum target_signal target_signal_from_host (int);
1386 extern int target_signal_to_host (enum target_signal);
1387
1388 /* Convert from a number used in a GDB command to an enum target_signal.  */
1389 extern enum target_signal target_signal_from_command (int);
1390
1391 /* Any target can call this to switch to remote protocol (in remote.c). */
1392 extern void push_remote_target (char *name, int from_tty);
1393 \f
1394 /* Imported from machine dependent code */
1395
1396 #ifndef SOFTWARE_SINGLE_STEP_P
1397 #define SOFTWARE_SINGLE_STEP_P 0
1398 #define SOFTWARE_SINGLE_STEP(sig,bp_p)  \
1399      (internal_error (__FILE__, __LINE__, "SOFTWARE_SINGLE_STEP"), 0)
1400 #endif /* SOFTWARE_SINGLE_STEP_P */
1401
1402 /* Blank target vector entries are initialized to target_ignore. */
1403 void target_ignore (void);
1404
1405 /* Macro for getting target's idea of a frame pointer.
1406    FIXME: GDB's whole scheme for dealing with "frames" and
1407    "frame pointers" needs a serious shakedown.  */
1408 #ifndef TARGET_VIRTUAL_FRAME_POINTER
1409 #define TARGET_VIRTUAL_FRAME_POINTER(ADDR, REGP, OFFP) \
1410    do { *(REGP) = FP_REGNUM; *(OFFP) =  0; } while (0)
1411 #endif /* TARGET_VIRTUAL_FRAME_POINTER */
1412
1413 #endif /* !defined (TARGET_H) */