gdbserver/target.h

   1 /* Target operations for the remote server for GDB.
   2    Copyright (C) 2002-2020 Free Software Foundation, Inc.
   3
   4    Contributed by MontaVista Software.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GDBSERVER_TARGET_H
  22 #define GDBSERVER_TARGET_H
  23
  24 #include <sys/types.h> /* for mode_t */
  25 #include "target/target.h"
  26 #include "target/resume.h"
  27 #include "target/wait.h"
  28 #include "target/waitstatus.h"
  29 #include "mem-break.h"
  30 #include "gdbsupport/btrace-common.h"
  31 #include <vector>
  32
  33 struct emit_ops;
  34 struct buffer;
  35 struct process_info;
  36
  37 /* This structure describes how to resume a particular thread (or all
  38    threads) based on the client's request.  If thread is -1, then this
  39    entry applies to all threads.  These are passed around as an
  40    array.  */
  41
  42 struct thread_resume
  43 {
  44   ptid_t thread;
  45
  46   /* How to "resume".  */
  47   enum resume_kind kind;
  48
  49   /* If non-zero, send this signal when we resume, or to stop the
  50      thread.  If stopping a thread, and this is 0, the target should
  51      stop the thread however it best decides to (e.g., SIGSTOP on
  52      linux; SuspendThread on win32).  This is a host signal value (not
  53      enum gdb_signal).  */
  54   int sig;
  55
  56   /* Range to single step within.  Valid only iff KIND is resume_step.
  57
  58      Single-step once, and then continuing stepping as long as the
  59      thread stops in this range.  (If the range is empty
  60      [STEP_RANGE_START == STEP_RANGE_END], then this is a single-step
  61      request.)  */
  62   CORE_ADDR step_range_start;   /* Inclusive */
  63   CORE_ADDR step_range_end;     /* Exclusive */
  64 };
  65
  66 class process_target;
  67
  68 /* GDBserver doesn't have a concept of strata like GDB, but we call
  69    its target vector "process_stratum" anyway for the benefit of
  70    shared code.  */
  71 struct process_stratum_target
  72 {
  73   /* Read auxiliary vector data from the inferior process.
  74
  75      Read LEN bytes at OFFSET into a buffer at MYADDR.  */
  76
  77   int (*read_auxv) (CORE_ADDR offset, unsigned char *myaddr,
  78                     unsigned int len);
  79
  80   /* Returns true if GDB Z breakpoint type TYPE is supported, false
  81      otherwise.  The type is coded as follows:
  82        '0' - software-breakpoint
  83        '1' - hardware-breakpoint
  84        '2' - write watchpoint
  85        '3' - read watchpoint
  86        '4' - access watchpoint
  87   */
  88   int (*supports_z_point_type) (char z_type);
  89
  90   /* Insert and remove a break or watchpoint.
  91      Returns 0 on success, -1 on failure and 1 on unsupported.  */
  92
  93   int (*insert_point) (enum raw_bkpt_type type, CORE_ADDR addr,
  94                        int size, struct raw_breakpoint *bp);
  95   int (*remove_point) (enum raw_bkpt_type type, CORE_ADDR addr,
  96                        int size, struct raw_breakpoint *bp);
  97
  98   /* Returns 1 if the target stopped because it executed a software
  99      breakpoint instruction, 0 otherwise.  */
 100   int (*stopped_by_sw_breakpoint) (void);
 101
 102   /* Returns true if the target knows whether a trap was caused by a
 103      SW breakpoint triggering.  */
 104   int (*supports_stopped_by_sw_breakpoint) (void);
 105
 106   /* Returns 1 if the target stopped for a hardware breakpoint.  */
 107   int (*stopped_by_hw_breakpoint) (void);
 108
 109   /* Returns true if the target knows whether a trap was caused by a
 110      HW breakpoint triggering.  */
 111   int (*supports_stopped_by_hw_breakpoint) (void);
 112
 113   /* Returns true if the target can do hardware single step.  */
 114   int (*supports_hardware_single_step) (void);
 115
 116   /* Returns 1 if target was stopped due to a watchpoint hit, 0 otherwise.  */
 117
 118   int (*stopped_by_watchpoint) (void);
 119
 120   /* Returns the address associated with the watchpoint that hit, if any;
 121      returns 0 otherwise.  */
 122
 123   CORE_ADDR (*stopped_data_address) (void);
 124
 125   /* Reports the text, data offsets of the executable.  This is
 126      needed for uclinux where the executable is relocated during load
 127      time.  */
 128
 129   int (*read_offsets) (CORE_ADDR *text, CORE_ADDR *data);
 130
 131   /* Fetch the address associated with a specific thread local storage
 132      area, determined by the specified THREAD, OFFSET, and LOAD_MODULE.
 133      Stores it in *ADDRESS and returns zero on success; otherwise returns
 134      an error code.  A return value of -1 means this system does not
 135      support the operation.  */
 136
 137   int (*get_tls_address) (struct thread_info *thread, CORE_ADDR offset,
 138                           CORE_ADDR load_module, CORE_ADDR *address);
 139
 140   /* Fill BUF with an hostio error packet representing the last hostio
 141      error.  */
 142   void (*hostio_last_error) (char *buf);
 143
 144   /* Read/Write OS data using qXfer packets.  */
 145   int (*qxfer_osdata) (const char *annex, unsigned char *readbuf,
 146                        unsigned const char *writebuf, CORE_ADDR offset,
 147                        int len);
 148
 149   /* Read/Write extra signal info.  */
 150   int (*qxfer_siginfo) (const char *annex, unsigned char *readbuf,
 151                         unsigned const char *writebuf,
 152                         CORE_ADDR offset, int len);
 153
 154   int (*supports_non_stop) (void);
 155
 156   /* Enables async target events.  Returns the previous enable
 157      state.  */
 158   int (*async) (int enable);
 159
 160   /* Switch to non-stop (1) or all-stop (0) mode.  Return 0 on
 161      success, -1 otherwise.  */
 162   int (*start_non_stop) (int);
 163
 164   /* Returns true if the target supports multi-process debugging.  */
 165   int (*supports_multi_process) (void);
 166
 167   /* Returns true if fork events are supported.  */
 168   int (*supports_fork_events) (void);
 169
 170   /* Returns true if vfork events are supported.  */
 171   int (*supports_vfork_events) (void);
 172
 173   /* Returns true if exec events are supported.  */
 174   int (*supports_exec_events) (void);
 175
 176   /* Allows target to re-initialize connection-specific settings.  */
 177   void (*handle_new_gdb_connection) (void);
 178
 179   /* If not NULL, target-specific routine to process monitor command.
 180      Returns 1 if handled, or 0 to perform default processing.  */
 181   int (*handle_monitor_command) (char *);
 182
 183   /* Returns the core given a thread, or -1 if not known.  */
 184   int (*core_of_thread) (ptid_t);
 185
 186   /* Read loadmaps.  Read LEN bytes at OFFSET into a buffer at MYADDR.  */
 187   int (*read_loadmap) (const char *annex, CORE_ADDR offset,
 188                        unsigned char *myaddr, unsigned int len);
 189
 190   /* Target specific qSupported support.  FEATURES is an array of
 191      features with COUNT elements.  */
 192   void (*process_qsupported) (char **features, int count);
 193
 194   /* Return 1 if the target supports tracepoints, 0 (or leave the
 195      callback NULL) otherwise.  */
 196   int (*supports_tracepoints) (void);
 197
 198   /* Read PC from REGCACHE.  */
 199   CORE_ADDR (*read_pc) (struct regcache *regcache);
 200
 201   /* Write PC to REGCACHE.  */
 202   void (*write_pc) (struct regcache *regcache, CORE_ADDR pc);
 203
 204   /* Return true if THREAD is known to be stopped now.  */
 205   int (*thread_stopped) (struct thread_info *thread);
 206
 207   /* Read Thread Information Block address.  */
 208   int (*get_tib_address) (ptid_t ptid, CORE_ADDR *address);
 209
 210   /* Pause all threads.  If FREEZE, arrange for any resume attempt to
 211      be ignored until an unpause_all call unfreezes threads again.
 212      There can be nested calls to pause_all, so a freeze counter
 213      should be maintained.  */
 214   void (*pause_all) (int freeze);
 215
 216   /* Unpause all threads.  Threads that hadn't been resumed by the
 217      client should be left stopped.  Basically a pause/unpause call
 218      pair should not end up resuming threads that were stopped before
 219      the pause call.  */
 220   void (*unpause_all) (int unfreeze);
 221
 222   /* Stabilize all threads.  That is, force them out of jump pads.  */
 223   void (*stabilize_threads) (void);
 224
 225   /* Install a fast tracepoint jump pad.  TPOINT is the address of the
 226      tracepoint internal object as used by the IPA agent.  TPADDR is
 227      the address of tracepoint.  COLLECTOR is address of the function
 228      the jump pad redirects to.  LOCKADDR is the address of the jump
 229      pad lock object.  ORIG_SIZE is the size in bytes of the
 230      instruction at TPADDR.  JUMP_ENTRY points to the address of the
 231      jump pad entry, and on return holds the address past the end of
 232      the created jump pad.  If a trampoline is created by the function,
 233      then TRAMPOLINE and TRAMPOLINE_SIZE return the address and size of
 234      the trampoline, else they remain unchanged.  JJUMP_PAD_INSN is a
 235      buffer containing a copy of the instruction at TPADDR.
 236      ADJUST_INSN_ADDR and ADJUST_INSN_ADDR_END are output parameters that
 237      return the address range where the instruction at TPADDR was relocated
 238      to.  If an error occurs, the ERR may be used to pass on an error
 239      message.  */
 240   int (*install_fast_tracepoint_jump_pad) (CORE_ADDR tpoint, CORE_ADDR tpaddr,
 241                                            CORE_ADDR collector,
 242                                            CORE_ADDR lockaddr,
 243                                            ULONGEST orig_size,
 244                                            CORE_ADDR *jump_entry,
 245                                            CORE_ADDR *trampoline,
 246                                            ULONGEST *trampoline_size,
 247                                            unsigned char *jjump_pad_insn,
 248                                            ULONGEST *jjump_pad_insn_size,
 249                                            CORE_ADDR *adjusted_insn_addr,
 250                                            CORE_ADDR *adjusted_insn_addr_end,
 251                                            char *err);
 252
 253   /* Return the bytecode operations vector for the current inferior.
 254      Returns NULL if bytecode compilation is not supported.  */
 255   struct emit_ops *(*emit_ops) (void);
 256
 257   /* Returns true if the target supports disabling randomization.  */
 258   int (*supports_disable_randomization) (void);
 259
 260   /* Return the minimum length of an instruction that can be safely overwritten
 261      for use as a fast tracepoint.  */
 262   int (*get_min_fast_tracepoint_insn_len) (void);
 263
 264   /* Read solib info on SVR4 platforms.  */
 265   int (*qxfer_libraries_svr4) (const char *annex, unsigned char *readbuf,
 266                                unsigned const char *writebuf,
 267                                CORE_ADDR offset, int len);
 268
 269   /* Return true if target supports debugging agent.  */
 270   int (*supports_agent) (void);
 271
 272   /* Enable branch tracing for PTID based on CONF and allocate a branch trace
 273      target information struct for reading and for disabling branch trace.  */
 274   struct btrace_target_info *(*enable_btrace)
 275     (ptid_t ptid, const struct btrace_config *conf);
 276
 277   /* Disable branch tracing.
 278      Returns zero on success, non-zero otherwise.  */
 279   int (*disable_btrace) (struct btrace_target_info *tinfo);
 280
 281   /* Read branch trace data into buffer.
 282      Return 0 on success; print an error message into BUFFER and return -1,
 283      otherwise.  */
 284   int (*read_btrace) (struct btrace_target_info *, struct buffer *,
 285                       enum btrace_read_type type);
 286
 287   /* Read the branch trace configuration into BUFFER.
 288      Return 0 on success; print an error message into BUFFER and return -1
 289      otherwise.  */
 290   int (*read_btrace_conf) (const struct btrace_target_info *, struct buffer *);
 291
 292   /* Return true if target supports range stepping.  */
 293   int (*supports_range_stepping) (void);
 294
 295   /* Return the full absolute name of the executable file that was
 296      run to create the process PID.  If the executable file cannot
 297      be determined, NULL is returned.  Otherwise, a pointer to a
 298      character string containing the pathname is returned.  This
 299      string should be copied into a buffer by the client if the string
 300      will not be immediately used, or if it must persist.  */
 301   char *(*pid_to_exec_file) (int pid);
 302
 303   /* Multiple-filesystem-aware open.  Like open(2), but operating in
 304      the filesystem as it appears to process PID.  Systems where all
 305      processes share a common filesystem should set this to NULL.
 306      If NULL, the caller should fall back to open(2).  */
 307   int (*multifs_open) (int pid, const char *filename,
 308                        int flags, mode_t mode);
 309
 310   /* Multiple-filesystem-aware unlink.  Like unlink(2), but operates
 311      in the filesystem as it appears to process PID.  Systems where
 312      all processes share a common filesystem should set this to NULL.
 313      If NULL, the caller should fall back to unlink(2).  */
 314   int (*multifs_unlink) (int pid, const char *filename);
 315
 316   /* Multiple-filesystem-aware readlink.  Like readlink(2), but
 317      operating in the filesystem as it appears to process PID.
 318      Systems where all processes share a common filesystem should
 319      set this to NULL.  If NULL, the caller should fall back to
 320      readlink(2).  */
 321   ssize_t (*multifs_readlink) (int pid, const char *filename,
 322                                char *buf, size_t bufsiz);
 323
 324   /* Return the breakpoint kind for this target based on PC.  The PCPTR is
 325      adjusted to the real memory location in case a flag (e.g., the Thumb bit on
 326      ARM) was present in the PC.  */
 327   int (*breakpoint_kind_from_pc) (CORE_ADDR *pcptr);
 328
 329   /* Return the software breakpoint from KIND.  KIND can have target
 330      specific meaning like the Z0 kind parameter.
 331      SIZE is set to the software breakpoint's length in memory.  */
 332   const gdb_byte *(*sw_breakpoint_from_kind) (int kind, int *size);
 333
 334   /* Return the thread's name, or NULL if the target is unable to determine it.
 335      The returned value must not be freed by the caller.  */
 336   const char *(*thread_name) (ptid_t thread);
 337
 338   /* Return the breakpoint kind for this target based on the current
 339      processor state (e.g. the current instruction mode on ARM) and the
 340      PC.  The PCPTR is adjusted to the real memory location in case a flag
 341      (e.g., the Thumb bit on ARM) is present in the PC.  */
 342   int (*breakpoint_kind_from_current_state) (CORE_ADDR *pcptr);
 343
 344   /* Returns true if the target can software single step.  */
 345   int (*supports_software_single_step) (void);
 346
 347   /* Return 1 if the target supports catch syscall, 0 (or leave the
 348      callback NULL) otherwise.  */
 349   int (*supports_catch_syscall) (void);
 350
 351   /* Return tdesc index for IPA.  */
 352   int (*get_ipa_tdesc_idx) (void);
 353
 354   /* Thread ID to (numeric) thread handle: Return true on success and
 355      false for failure.  Return pointer to thread handle via HANDLE
 356      and the handle's length via HANDLE_LEN.  */
 357   bool (*thread_handle) (ptid_t ptid, gdb_byte **handle, int *handle_len);
 358
 359   /* The object that will gradually replace this struct.  */
 360   process_target *pt;
 361 };
 362
 363 class process_target
 364 {
 365 public:
 366
 367   virtual ~process_target () = default;
 368
 369   /* Start a new process.
 370
 371      PROGRAM is a path to the program to execute.
 372      PROGRAM_ARGS is a standard NULL-terminated array of arguments,
 373      to be passed to the inferior as ``argv'' (along with PROGRAM).
 374
 375      Returns the new PID on success, -1 on failure.  Registers the new
 376      process with the process list.  */
 377   virtual int create_inferior (const char *program,
 378                                const std::vector<char *> &program_args) = 0;
 379
 380   /* Do additional setup after a new process is created, including
 381      exec-wrapper completion.  */
 382   virtual void post_create_inferior ();
 383
 384   /* Attach to a running process.
 385
 386      PID is the process ID to attach to, specified by the user
 387      or a higher layer.
 388
 389      Returns -1 if attaching is unsupported, 0 on success, and calls
 390      error() otherwise.  */
 391   virtual int attach (unsigned long pid) = 0;
 392
 393   /* Kill process PROC.  Return -1 on failure, and 0 on success.  */
 394   virtual int kill (process_info *proc) = 0;
 395
 396   /* Detach from process PROC.  Return -1 on failure, and 0 on
 397      success.  */
 398   virtual int detach (process_info *proc) = 0;
 399
 400   /* The inferior process has died.  Do what is right.  */
 401   virtual void mourn (process_info *proc) = 0;
 402
 403   /* Wait for process PID to exit.  */
 404   virtual void join (int pid) = 0;
 405
 406   /* Return true iff the thread with process ID PID is alive.  */
 407   virtual bool thread_alive (ptid_t pid) = 0;
 408
 409   /* Resume the inferior process.  */
 410   virtual void resume (thread_resume *resume_info, size_t n) = 0;
 411
 412   /* Wait for the inferior process or thread to change state.  Store
 413      status through argument pointer STATUS.
 414
 415      PTID = -1 to wait for any pid to do something, PTID(pid,0,0) to
 416      wait for any thread of process pid to do something.  Return ptid
 417      of child, or -1 in case of error; store status through argument
 418      pointer STATUS.  OPTIONS is a bit set of options defined as
 419      TARGET_W* above.  If options contains TARGET_WNOHANG and there's
 420      no child stop to report, return is
 421      null_ptid/TARGET_WAITKIND_IGNORE.  */
 422   virtual ptid_t wait (ptid_t ptid, target_waitstatus *status,
 423                        int options) = 0;
 424
 425   /* Fetch registers from the inferior process.
 426
 427      If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO.  */
 428   virtual void fetch_registers (regcache *regcache, int regno) = 0;
 429
 430   /* Store registers to the inferior process.
 431
 432      If REGNO is -1, store all registers; otherwise, store at least REGNO.  */
 433   virtual void store_registers (regcache *regcache, int regno) = 0;
 434
 435   /* Prepare to read or write memory from the inferior process.
 436      Targets use this to do what is necessary to get the state of the
 437      inferior such that it is possible to access memory.
 438
 439      This should generally only be called from client facing routines,
 440      such as gdb_read_memory/gdb_write_memory, or the GDB breakpoint
 441      insertion routine.
 442
 443      Like `read_memory' and `write_memory' below, returns 0 on success
 444      and errno on failure.  */
 445   virtual int prepare_to_access_memory ();
 446
 447   /* Undo the effects of prepare_to_access_memory.  */
 448   virtual void done_accessing_memory ();
 449
 450   /* Read memory from the inferior process.  This should generally be
 451      called through read_inferior_memory, which handles breakpoint shadowing.
 452
 453      Read LEN bytes at MEMADDR into a buffer at MYADDR.
 454
 455      Returns 0 on success and errno on failure.  */
 456   virtual int read_memory (CORE_ADDR memaddr, unsigned char *myaddr,
 457                            int len) = 0;
 458
 459   /* Write memory to the inferior process.  This should generally be
 460      called through target_write_memory, which handles breakpoint shadowing.
 461
 462      Write LEN bytes from the buffer at MYADDR to MEMADDR.
 463
 464      Returns 0 on success and errno on failure.  */
 465   virtual int write_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
 466                             int len) = 0;
 467
 468   /* Query GDB for the values of any symbols we're interested in.
 469      This function is called whenever we receive a "qSymbols::"
 470      query, which corresponds to every time more symbols (might)
 471      become available.  */
 472   virtual void look_up_symbols ();
 473
 474   /* Send an interrupt request to the inferior process,
 475      however is appropriate.  */
 476   virtual void request_interrupt () = 0;
 477 };
 478
 479 extern process_stratum_target *the_target;
 480
 481 void set_target_ops (process_stratum_target *);
 482
 483 #define target_create_inferior(program, program_args)   \
 484   the_target->pt->create_inferior (program, program_args)
 485
 486 #define target_post_create_inferior()                    \
 487   the_target->pt->post_create_inferior ()
 488
 489 #define myattach(pid) \
 490   the_target->pt->attach (pid)
 491
 492 int kill_inferior (process_info *proc);
 493
 494 #define target_supports_fork_events() \
 495   (the_target->supports_fork_events ? \
 496    (*the_target->supports_fork_events) () : 0)
 497
 498 #define target_supports_vfork_events() \
 499   (the_target->supports_vfork_events ? \
 500    (*the_target->supports_vfork_events) () : 0)
 501
 502 #define target_supports_exec_events() \
 503   (the_target->supports_exec_events ? \
 504    (*the_target->supports_exec_events) () : 0)
 505
 506 #define target_handle_new_gdb_connection()               \
 507   do                                                     \
 508     {                                                    \
 509       if (the_target->handle_new_gdb_connection != NULL) \
 510         (*the_target->handle_new_gdb_connection) ();     \
 511     } while (0)
 512
 513 #define detach_inferior(proc) \
 514   the_target->pt->detach (proc)
 515
 516 #define mythread_alive(pid) \
 517   the_target->pt->thread_alive (pid)
 518
 519 #define fetch_inferior_registers(regcache, regno)       \
 520   the_target->pt->fetch_registers (regcache, regno)
 521
 522 #define store_inferior_registers(regcache, regno) \
 523   the_target->pt->store_registers (regcache, regno)
 524
 525 #define join_inferior(pid) \
 526   the_target->pt->join (pid)
 527
 528 #define target_supports_non_stop() \
 529   (the_target->supports_non_stop ? (*the_target->supports_non_stop ) () : 0)
 530
 531 #define target_async(enable) \
 532   (the_target->async ? (*the_target->async) (enable) : 0)
 533
 534 #define target_process_qsupported(features, count)      \
 535   do                                                    \
 536     {                                                   \
 537       if (the_target->process_qsupported)               \
 538         the_target->process_qsupported (features, count); \
 539     } while (0)
 540
 541 #define target_supports_catch_syscall()                 \
 542   (the_target->supports_catch_syscall ?                 \
 543    (*the_target->supports_catch_syscall) () : 0)
 544
 545 #define target_get_ipa_tdesc_idx()                      \
 546   (the_target->get_ipa_tdesc_idx                        \
 547    ? (*the_target->get_ipa_tdesc_idx) () : 0)
 548
 549 #define target_supports_tracepoints()                   \
 550   (the_target->supports_tracepoints                     \
 551    ? (*the_target->supports_tracepoints) () : 0)
 552
 553 #define target_supports_fast_tracepoints()              \
 554   (the_target->install_fast_tracepoint_jump_pad != NULL)
 555
 556 #define target_get_min_fast_tracepoint_insn_len()       \
 557   (the_target->get_min_fast_tracepoint_insn_len         \
 558    ? (*the_target->get_min_fast_tracepoint_insn_len) () : 0)
 559
 560 #define thread_stopped(thread) \
 561   (*the_target->thread_stopped) (thread)
 562
 563 #define pause_all(freeze)                       \
 564   do                                            \
 565     {                                           \
 566       if (the_target->pause_all)                \
 567         (*the_target->pause_all) (freeze);      \
 568     } while (0)
 569
 570 #define unpause_all(unfreeze)                   \
 571   do                                            \
 572     {                                           \
 573       if (the_target->unpause_all)              \
 574         (*the_target->unpause_all) (unfreeze);  \
 575     } while (0)
 576
 577 #define stabilize_threads()                     \
 578   do                                            \
 579     {                                           \
 580       if (the_target->stabilize_threads)        \
 581         (*the_target->stabilize_threads) ();    \
 582     } while (0)
 583
 584 #define install_fast_tracepoint_jump_pad(tpoint, tpaddr,                \
 585                                          collector, lockaddr,           \
 586                                          orig_size,                     \
 587                                          jump_entry,                    \
 588                                          trampoline, trampoline_size,   \
 589                                          jjump_pad_insn,                \
 590                                          jjump_pad_insn_size,           \
 591                                          adjusted_insn_addr,            \
 592                                          adjusted_insn_addr_end,        \
 593                                          err)                           \
 594   (*the_target->install_fast_tracepoint_jump_pad) (tpoint, tpaddr,      \
 595                                                    collector,lockaddr,  \
 596                                                    orig_size, jump_entry, \
 597                                                    trampoline,          \
 598                                                    trampoline_size,     \
 599                                                    jjump_pad_insn,      \
 600                                                    jjump_pad_insn_size, \
 601                                                    adjusted_insn_addr,  \
 602                                                    adjusted_insn_addr_end, \
 603                                                    err)
 604
 605 #define target_emit_ops() \
 606   (the_target->emit_ops ? (*the_target->emit_ops) () : NULL)
 607
 608 #define target_supports_disable_randomization() \
 609   (the_target->supports_disable_randomization ? \
 610    (*the_target->supports_disable_randomization) () : 0)
 611
 612 #define target_supports_agent() \
 613   (the_target->supports_agent ? \
 614    (*the_target->supports_agent) () : 0)
 615
 616 static inline struct btrace_target_info *
 617 target_enable_btrace (ptid_t ptid, const struct btrace_config *conf)
 618 {
 619   if (the_target->enable_btrace == nullptr)
 620     error (_("Target does not support branch tracing."));
 621
 622   return (*the_target->enable_btrace) (ptid, conf);
 623 }
 624
 625 static inline int
 626 target_disable_btrace (struct btrace_target_info *tinfo)
 627 {
 628   if (the_target->disable_btrace == nullptr)
 629     error (_("Target does not support branch tracing."));
 630
 631   return (*the_target->disable_btrace) (tinfo);
 632 }
 633
 634 static inline int
 635 target_read_btrace (struct btrace_target_info *tinfo,
 636                     struct buffer *buffer,
 637                     enum btrace_read_type type)
 638 {
 639   if (the_target->read_btrace == nullptr)
 640     error (_("Target does not support branch tracing."));
 641
 642   return (*the_target->read_btrace) (tinfo, buffer, type);
 643 }
 644
 645 static inline int
 646 target_read_btrace_conf (struct btrace_target_info *tinfo,
 647                          struct buffer *buffer)
 648 {
 649   if (the_target->read_btrace_conf == nullptr)
 650     error (_("Target does not support branch tracing."));
 651
 652   return (*the_target->read_btrace_conf) (tinfo, buffer);
 653 }
 654
 655 #define target_supports_range_stepping() \
 656   (the_target->supports_range_stepping ? \
 657    (*the_target->supports_range_stepping) () : 0)
 658
 659 #define target_supports_stopped_by_sw_breakpoint() \
 660   (the_target->supports_stopped_by_sw_breakpoint ? \
 661    (*the_target->supports_stopped_by_sw_breakpoint) () : 0)
 662
 663 #define target_stopped_by_sw_breakpoint() \
 664   (the_target->stopped_by_sw_breakpoint ? \
 665    (*the_target->stopped_by_sw_breakpoint) () : 0)
 666
 667 #define target_supports_stopped_by_hw_breakpoint() \
 668   (the_target->supports_stopped_by_hw_breakpoint ? \
 669    (*the_target->supports_stopped_by_hw_breakpoint) () : 0)
 670
 671 #define target_supports_hardware_single_step() \
 672   (the_target->supports_hardware_single_step ? \
 673    (*the_target->supports_hardware_single_step) () : 0)
 674
 675 #define target_stopped_by_hw_breakpoint() \
 676   (the_target->stopped_by_hw_breakpoint ? \
 677    (*the_target->stopped_by_hw_breakpoint) () : 0)
 678
 679 #define target_breakpoint_kind_from_pc(pcptr) \
 680   (the_target->breakpoint_kind_from_pc \
 681    ? (*the_target->breakpoint_kind_from_pc) (pcptr) \
 682    : default_breakpoint_kind_from_pc (pcptr))
 683
 684 #define target_breakpoint_kind_from_current_state(pcptr) \
 685   (the_target->breakpoint_kind_from_current_state \
 686    ? (*the_target->breakpoint_kind_from_current_state) (pcptr) \
 687    : target_breakpoint_kind_from_pc (pcptr))
 688
 689 #define target_supports_software_single_step() \
 690   (the_target->supports_software_single_step ? \
 691    (*the_target->supports_software_single_step) () : 0)
 692
 693 /* Start non-stop mode, returns 0 on success, -1 on failure.   */
 694
 695 int start_non_stop (int nonstop);
 696
 697 ptid_t mywait (ptid_t ptid, struct target_waitstatus *ourstatus, int options,
 698                int connected_wait);
 699
 700 /* Prepare to read or write memory from the inferior process.  See the
 701    corresponding process_stratum_target methods for more details.  */
 702
 703 int prepare_to_access_memory (void);
 704 void done_accessing_memory (void);
 705
 706 #define target_core_of_thread(ptid)             \
 707   (the_target->core_of_thread ? (*the_target->core_of_thread) (ptid) \
 708    : -1)
 709
 710 #define target_thread_name(ptid)                                \
 711   (the_target->thread_name ? (*the_target->thread_name) (ptid)  \
 712    : NULL)
 713
 714 #define target_thread_handle(ptid, handle, handle_len) \
 715    (the_target->thread_handle ? (*the_target->thread_handle) \
 716                                   (ptid, handle, handle_len) \
 717    : false)
 718
 719 int read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len);
 720
 721 int set_desired_thread ();
 722
 723 const char *target_pid_to_str (ptid_t);
 724
 725 int target_can_do_hardware_single_step (void);
 726
 727 int default_breakpoint_kind_from_pc (CORE_ADDR *pcptr);
 728
 729 #endif /* GDBSERVER_TARGET_H */