gdbserver/target.h

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