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