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   /* Fill BUF with an hostio error packet representing the last hostio
 260      error.  */
 261   virtual void hostio_last_error (char *buf);
 262
 263   /* Return true if the qxfer_osdata target op is supported.  */
 264   virtual bool supports_qxfer_osdata ();
 265
 266   /* Read/Write OS data using qXfer packets.  */
 267   virtual int qxfer_osdata (const char *annex, unsigned char *readbuf,
 268                             unsigned const char *writebuf,
 269                             CORE_ADDR offset, int len);
 270
 271   /* Return true if the qxfer_siginfo target op is supported.  */
 272   virtual bool supports_qxfer_siginfo ();
 273
 274   /* Read/Write extra signal info.  */
 275   virtual int qxfer_siginfo (const char *annex, unsigned char *readbuf,
 276                              unsigned const char *writebuf,
 277                              CORE_ADDR offset, int len);
 278
 279   /* Return true if non-stop mode is supported.  */
 280   virtual bool supports_non_stop ();
 281
 282   /* Enables async target events.  Returns the previous enable
 283      state.  */
 284   virtual bool async (bool enable);
 285
 286   /* Switch to non-stop (ENABLE == true) or all-stop (ENABLE == false)
 287      mode.  Return 0 on success, -1 otherwise.  */
 288   virtual int start_non_stop (bool enable);
 289
 290   /* Returns true if the target supports multi-process debugging.  */
 291   virtual bool supports_multi_process ();
 292
 293   /* Returns true if fork events are supported.  */
 294   virtual bool supports_fork_events ();
 295
 296   /* Returns true if vfork events are supported.  */
 297   virtual bool supports_vfork_events ();
 298
 299   /* Returns true if exec events are supported.  */
 300   virtual bool supports_exec_events ();
 301
 302   /* Allows target to re-initialize connection-specific settings.  */
 303   virtual void handle_new_gdb_connection ();
 304
 305   /* The target-specific routine to process monitor command.
 306      Returns 1 if handled, or 0 to perform default processing.  */
 307   virtual int handle_monitor_command (char *mon);
 308
 309   /* Returns the core given a thread, or -1 if not known.  */
 310   virtual int core_of_thread (ptid_t ptid);
 311
 312   /* Returns true if the read_loadmap target op is supported.  */
 313   virtual bool supports_read_loadmap ();
 314
 315   /* Read loadmaps.  Read LEN bytes at OFFSET into a buffer at MYADDR.  */
 316   virtual int read_loadmap (const char *annex, CORE_ADDR offset,
 317                             unsigned char *myaddr, unsigned int len);
 318
 319   /* Target specific qSupported support.  FEATURES is an array of
 320      features unsupported by the core of GDBserver.  */
 321   virtual void process_qsupported
 322     (gdb::array_view<const char * const> features);
 323
 324   /* Return true if the target supports tracepoints, false otherwise.  */
 325   virtual bool supports_tracepoints ();
 326
 327   /* Read PC from REGCACHE.  */
 328   virtual CORE_ADDR read_pc (regcache *regcache);
 329
 330   /* Write PC to REGCACHE.  */
 331   virtual void write_pc (regcache *regcache, CORE_ADDR pc);
 332
 333   /* Return true if the thread_stopped op is supported.  */
 334   virtual bool supports_thread_stopped ();
 335
 336   /* Return true if THREAD is known to be stopped now.  */
 337   virtual bool thread_stopped (thread_info *thread);
 338
 339   /* Return true if the get_tib_address op is supported.  */
 340   virtual bool supports_get_tib_address ();
 341
 342   /* Read Thread Information Block address.  */
 343   virtual int get_tib_address (ptid_t ptid, CORE_ADDR *address);
 344
 345   /* Pause all threads.  If FREEZE, arrange for any resume attempt to
 346      be ignored until an unpause_all call unfreezes threads again.
 347      There can be nested calls to pause_all, so a freeze counter
 348      should be maintained.  */
 349   virtual void pause_all (bool freeze);
 350
 351   /* Unpause all threads.  Threads that hadn't been resumed by the
 352      client should be left stopped.  Basically a pause/unpause call
 353      pair should not end up resuming threads that were stopped before
 354      the pause call.  */
 355   virtual void unpause_all (bool unfreeze);
 356
 357   /* Stabilize all threads.  That is, force them out of jump pads.  */
 358   virtual void stabilize_threads ();
 359
 360   /* Return true if the install_fast_tracepoint_jump_pad op is
 361      supported.  */
 362   virtual bool supports_fast_tracepoints ();
 363
 364   /* Install a fast tracepoint jump pad.  TPOINT is the address of the
 365      tracepoint internal object as used by the IPA agent.  TPADDR is
 366      the address of tracepoint.  COLLECTOR is address of the function
 367      the jump pad redirects to.  LOCKADDR is the address of the jump
 368      pad lock object.  ORIG_SIZE is the size in bytes of the
 369      instruction at TPADDR.  JUMP_ENTRY points to the address of the
 370      jump pad entry, and on return holds the address past the end of
 371      the created jump pad.  If a trampoline is created by the function,
 372      then TRAMPOLINE and TRAMPOLINE_SIZE return the address and size of
 373      the trampoline, else they remain unchanged.  JJUMP_PAD_INSN is a
 374      buffer containing a copy of the instruction at TPADDR.
 375      ADJUST_INSN_ADDR and ADJUST_INSN_ADDR_END are output parameters that
 376      return the address range where the instruction at TPADDR was relocated
 377      to.  If an error occurs, the ERR may be used to pass on an error
 378      message.  */
 379   virtual int install_fast_tracepoint_jump_pad
 380     (CORE_ADDR tpoint, CORE_ADDR tpaddr, CORE_ADDR collector,
 381      CORE_ADDR lockaddr, ULONGEST orig_size, CORE_ADDR *jump_entry,
 382      CORE_ADDR *trampoline, ULONGEST *trampoline_size,
 383      unsigned char *jjump_pad_insn, ULONGEST *jjump_pad_insn_size,
 384      CORE_ADDR *adjusted_insn_addr, CORE_ADDR *adjusted_insn_addr_end,
 385      char *err);
 386
 387   /* Return the minimum length of an instruction that can be safely
 388      overwritten for use as a fast tracepoint.  */
 389   virtual int get_min_fast_tracepoint_insn_len ();
 390
 391   /* Return the bytecode operations vector for the current inferior.
 392      Returns nullptr if bytecode compilation is not supported.  */
 393   virtual struct emit_ops *emit_ops ();
 394
 395   /* Returns true if the target supports disabling randomization.  */
 396   virtual bool supports_disable_randomization ();
 397
 398   /* Return true if the qxfer_libraries_svr4 op is supported.  */
 399   virtual bool supports_qxfer_libraries_svr4 ();
 400
 401   /* Read solib info on SVR4 platforms.  */
 402   virtual int qxfer_libraries_svr4 (const char *annex,
 403                                     unsigned char *readbuf,
 404                                     unsigned const char *writebuf,
 405                                     CORE_ADDR offset, int len);
 406
 407   /* Return true if target supports debugging agent.  */
 408   virtual bool supports_agent ();
 409
 410   /* Enable branch tracing for PTID based on CONF and allocate a branch trace
 411      target information struct for reading and for disabling branch trace.  */
 412   virtual btrace_target_info *enable_btrace (ptid_t ptid,
 413                                              const btrace_config *conf);
 414
 415   /* Disable branch tracing.
 416      Returns zero on success, non-zero otherwise.  */
 417   virtual int disable_btrace (btrace_target_info *tinfo);
 418
 419   /* Read branch trace data into buffer.
 420      Return 0 on success; print an error message into BUFFER and return -1,
 421      otherwise.  */
 422   virtual int read_btrace (btrace_target_info *tinfo, buffer *buf,
 423                            enum btrace_read_type type);
 424
 425   /* Read the branch trace configuration into BUFFER.
 426      Return 0 on success; print an error message into BUFFER and return -1
 427      otherwise.  */
 428   virtual int read_btrace_conf (const btrace_target_info *tinfo,
 429                                 buffer *buf);
 430
 431   /* Return true if target supports range stepping.  */
 432   virtual bool supports_range_stepping ();
 433
 434   /* Return true if the pid_to_exec_file op is supported.  */
 435   virtual bool supports_pid_to_exec_file ();
 436
 437   /* Return the full absolute name of the executable file that was
 438      run to create the process PID.  If the executable file cannot
 439      be determined, NULL is returned.  Otherwise, a pointer to a
 440      character string containing the pathname is returned.  This
 441      string should be copied into a buffer by the client if the string
 442      will not be immediately used, or if it must persist.  */
 443   virtual const char *pid_to_exec_file (int pid);
 444
 445   /* Return true if any of the multifs ops is supported.  */
 446   virtual bool supports_multifs ();
 447
 448   /* Multiple-filesystem-aware open.  Like open(2), but operating in
 449      the filesystem as it appears to process PID.  Systems where all
 450      processes share a common filesystem should not override this.
 451      The default behavior is to use open(2).  */
 452   virtual int multifs_open (int pid, const char *filename,
 453                             int flags, mode_t mode);
 454
 455   /* Multiple-filesystem-aware unlink.  Like unlink(2), but operates
 456      in the filesystem as it appears to process PID.  Systems where
 457      all processes share a common filesystem should not override this.
 458      The default behavior is to use unlink(2).  */
 459   virtual int multifs_unlink (int pid, const char *filename);
 460
 461   /* Multiple-filesystem-aware readlink.  Like readlink(2), but
 462      operating in the filesystem as it appears to process PID.
 463      Systems where all processes share a common filesystem should
 464      not override this.  The default behavior is to use readlink(2).  */
 465   virtual ssize_t multifs_readlink (int pid, const char *filename,
 466                                     char *buf, size_t bufsiz);
 467
 468   /* Return the breakpoint kind for this target based on PC.  The
 469      PCPTR is adjusted to the real memory location in case a flag
 470      (e.g., the Thumb bit on ARM) was present in the PC.  */
 471   virtual int breakpoint_kind_from_pc (CORE_ADDR *pcptr);
 472
 473   /* Return the software breakpoint from KIND.  KIND can have target
 474      specific meaning like the Z0 kind parameter.
 475      SIZE is set to the software breakpoint's length in memory.  */
 476   virtual const gdb_byte *sw_breakpoint_from_kind (int kind, int *size) = 0;
 477
 478   /* Return the breakpoint kind for this target based on the current
 479      processor state (e.g. the current instruction mode on ARM) and the
 480      PC.  The PCPTR is adjusted to the real memory location in case a
 481      flag (e.g., the Thumb bit on ARM) is present in the  PC.  */
 482   virtual int breakpoint_kind_from_current_state (CORE_ADDR *pcptr);
 483
 484   /* Return the thread's name, or NULL if the target is unable to
 485      determine it.  The returned value must not be freed by the
 486      caller.  */
 487   virtual const char *thread_name (ptid_t thread);
 488
 489   /* Thread ID to (numeric) thread handle: Return true on success and
 490      false for failure.  Return pointer to thread handle via HANDLE
 491      and the handle's length via HANDLE_LEN.  */
 492   virtual bool thread_handle (ptid_t ptid, gdb_byte **handle,
 493                               int *handle_len);
 494
 495   /* Returns true if the target can software single step.  */
 496   virtual bool supports_software_single_step ();
 497
 498   /* Return true if the target supports catch syscall.  */
 499   virtual bool supports_catch_syscall ();
 500
 501   /* Return tdesc index for IPA.  */
 502   virtual int get_ipa_tdesc_idx ();
 503
 504   /* Returns true if the target supports memory tagging facilities.  */
 505   virtual bool supports_memory_tagging ();
 506
 507   /* Return the allocated memory tags of type TYPE associated with
 508      [ADDRESS, ADDRESS + LEN) in TAGS.
 509
 510      Returns true if successful and false otherwise.  */
 511   virtual bool fetch_memtags (CORE_ADDR address, size_t len,
 512                               gdb::byte_vector &tags, int type);
 513
 514   /* Write the allocation tags of type TYPE contained in TAGS to the
 515      memory range [ADDRESS, ADDRESS + LEN).
 516
 517      Returns true if successful and false otherwise.  */
 518   virtual bool store_memtags (CORE_ADDR address, size_t len,
 519                               const gdb::byte_vector &tags, int type);
 520 };
 521
 522 extern process_stratum_target *the_target;
 523
 524 void set_target_ops (process_stratum_target *);
 525
 526 #define target_create_inferior(program, program_args)   \
 527   the_target->create_inferior (program, program_args)
 528
 529 #define target_post_create_inferior()                    \
 530   the_target->post_create_inferior ()
 531
 532 #define myattach(pid) \
 533   the_target->attach (pid)
 534
 535 int kill_inferior (process_info *proc);
 536
 537 #define target_supports_fork_events() \
 538   the_target->supports_fork_events ()
 539
 540 #define target_supports_vfork_events() \
 541   the_target->supports_vfork_events ()
 542
 543 #define target_supports_exec_events() \
 544   the_target->supports_exec_events ()
 545
 546 #define target_supports_memory_tagging() \
 547   the_target->supports_memory_tagging ()
 548
 549 #define target_handle_new_gdb_connection()               \
 550   the_target->handle_new_gdb_connection ()
 551
 552 #define detach_inferior(proc) \
 553   the_target->detach (proc)
 554
 555 #define mythread_alive(pid) \
 556   the_target->thread_alive (pid)
 557
 558 #define fetch_inferior_registers(regcache, regno)       \
 559   the_target->fetch_registers (regcache, regno)
 560
 561 #define store_inferior_registers(regcache, regno) \
 562   the_target->store_registers (regcache, regno)
 563
 564 #define join_inferior(pid) \
 565   the_target->join (pid)
 566
 567 #define target_supports_non_stop() \
 568   the_target->supports_non_stop ()
 569
 570 #define target_async(enable) \
 571   the_target->async (enable)
 572
 573 #define target_process_qsupported(features) \
 574   the_target->process_qsupported (features)
 575
 576 #define target_supports_catch_syscall()                 \
 577   the_target->supports_catch_syscall ()
 578
 579 #define target_get_ipa_tdesc_idx()                      \
 580   the_target->get_ipa_tdesc_idx ()
 581
 582 #define target_supports_tracepoints()                   \
 583   the_target->supports_tracepoints ()
 584
 585 #define target_supports_fast_tracepoints()              \
 586   the_target->supports_fast_tracepoints ()
 587
 588 #define target_get_min_fast_tracepoint_insn_len()       \
 589   the_target->get_min_fast_tracepoint_insn_len ()
 590
 591 #define target_thread_stopped(thread) \
 592   the_target->thread_stopped (thread)
 593
 594 #define target_pause_all(freeze)                \
 595   the_target->pause_all (freeze)
 596
 597 #define target_unpause_all(unfreeze)            \
 598   the_target->unpause_all (unfreeze)
 599
 600 #define target_stabilize_threads()              \
 601   the_target->stabilize_threads ()
 602
 603 #define target_install_fast_tracepoint_jump_pad(tpoint, tpaddr,         \
 604                                                 collector, lockaddr,    \
 605                                                 orig_size,              \
 606                                                 jump_entry,             \
 607                                                 trampoline, trampoline_size, \
 608                                                 jjump_pad_insn,         \
 609                                                 jjump_pad_insn_size,    \
 610                                                 adjusted_insn_addr,     \
 611                                                 adjusted_insn_addr_end, \
 612                                                 err)                    \
 613   the_target->install_fast_tracepoint_jump_pad (tpoint, tpaddr, \
 614                                                 collector,lockaddr,     \
 615                                                 orig_size, jump_entry,  \
 616                                                 trampoline,             \
 617                                                 trampoline_size,        \
 618                                                 jjump_pad_insn,         \
 619                                                 jjump_pad_insn_size,    \
 620                                                 adjusted_insn_addr,     \
 621                                                 adjusted_insn_addr_end, \
 622                                                 err)
 623
 624 #define target_emit_ops() \
 625   the_target->emit_ops ()
 626
 627 #define target_supports_disable_randomization() \
 628   the_target->supports_disable_randomization ()
 629
 630 #define target_supports_agent() \
 631   the_target->supports_agent ()
 632
 633 static inline struct btrace_target_info *
 634 target_enable_btrace (ptid_t ptid, const struct btrace_config *conf)
 635 {
 636   return the_target->enable_btrace (ptid, conf);
 637 }
 638
 639 static inline int
 640 target_disable_btrace (struct btrace_target_info *tinfo)
 641 {
 642   return the_target->disable_btrace (tinfo);
 643 }
 644
 645 static inline int
 646 target_read_btrace (struct btrace_target_info *tinfo,
 647                     struct buffer *buffer,
 648                     enum btrace_read_type type)
 649 {
 650   return the_target->read_btrace (tinfo, buffer, type);
 651 }
 652
 653 static inline int
 654 target_read_btrace_conf (struct btrace_target_info *tinfo,
 655                          struct buffer *buffer)
 656 {
 657   return the_target->read_btrace_conf (tinfo, buffer);
 658 }
 659
 660 #define target_supports_range_stepping() \
 661   the_target->supports_range_stepping ()
 662
 663 #define target_supports_stopped_by_sw_breakpoint() \
 664   the_target->supports_stopped_by_sw_breakpoint ()
 665
 666 #define target_stopped_by_sw_breakpoint() \
 667   the_target->stopped_by_sw_breakpoint ()
 668
 669 #define target_supports_stopped_by_hw_breakpoint() \
 670   the_target->supports_stopped_by_hw_breakpoint ()
 671
 672 #define target_supports_hardware_single_step() \
 673   the_target->supports_hardware_single_step ()
 674
 675 #define target_stopped_by_hw_breakpoint() \
 676   the_target->stopped_by_hw_breakpoint ()
 677
 678 #define target_breakpoint_kind_from_pc(pcptr) \
 679   the_target->breakpoint_kind_from_pc (pcptr)
 680
 681 #define target_breakpoint_kind_from_current_state(pcptr) \
 682   the_target->breakpoint_kind_from_current_state (pcptr)
 683
 684 #define target_supports_software_single_step() \
 685   the_target->supports_software_single_step ()
 686
 687 ptid_t mywait (ptid_t ptid, struct target_waitstatus *ourstatus,
 688                target_wait_flags options, int connected_wait);
 689
 690 /* Prepare to read or write memory from the inferior process.  See the
 691    corresponding process_stratum_target methods for more details.  */
 692
 693 int prepare_to_access_memory (void);
 694 void done_accessing_memory (void);
 695
 696 #define target_core_of_thread(ptid)             \
 697   the_target->core_of_thread (ptid)
 698
 699 #define target_thread_name(ptid)                                \
 700   the_target->thread_name (ptid)
 701
 702 #define target_thread_handle(ptid, handle, handle_len) \
 703   the_target->thread_handle (ptid, handle, handle_len)
 704
 705 int read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len);
 706
 707 int set_desired_thread ();
 708
 709 const char *target_pid_to_str (ptid_t);
 710
 711 #endif /* GDBSERVER_TARGET_H */