GDBserver

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