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