1 /* Target operations for the remote server for GDB.
2 Copyright (C) 2002-2014 Free Software Foundation, Inc.
4 Contributed by MontaVista Software.
6 This file is part of GDB.
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.
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.
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/>. */
24 #include "target/resume.h"
25 #include "target/wait.h"
26 #include "target/waitstatus.h"
29 struct btrace_target_info
;
33 /* This structure describes how to resume a particular thread (or all
34 threads) based on the client's request. If thread is -1, then this
35 entry applies to all threads. These are passed around as an
42 /* How to "resume". */
43 enum resume_kind kind
;
45 /* If non-zero, send this signal when we resume, or to stop the
46 thread. If stopping a thread, and this is 0, the target should
47 stop the thread however it best decides to (e.g., SIGSTOP on
48 linux; SuspendThread on win32). This is a host signal value (not
52 /* Range to single step within. Valid only iff KIND is resume_step.
54 Single-step once, and then continuing stepping as long as the
55 thread stops in this range. (If the range is empty
56 [STEP_RANGE_START == STEP_RANGE_END], then this is a single-step
58 CORE_ADDR step_range_start
; /* Inclusive */
59 CORE_ADDR step_range_end
; /* Exclusive */
64 /* Start a new process.
66 PROGRAM is a path to the program to execute.
67 ARGS is a standard NULL-terminated array of arguments,
68 to be passed to the inferior as ``argv''.
70 Returns the new PID on success, -1 on failure. Registers the new
71 process with the process list. */
73 int (*create_inferior
) (char *program
, char **args
);
75 /* Attach to a running process.
77 PID is the process ID to attach to, specified by the user
80 Returns -1 if attaching is unsupported, 0 on success, and calls
83 int (*attach
) (unsigned long pid
);
85 /* Kill inferior PID. Return -1 on failure, and 0 on success. */
87 int (*kill
) (int pid
);
89 /* Detach from inferior PID. Return -1 on failure, and 0 on
92 int (*detach
) (int pid
);
94 /* The inferior process has died. Do what is right. */
96 void (*mourn
) (struct process_info
*proc
);
98 /* Wait for inferior PID to exit. */
99 void (*join
) (int pid
);
101 /* Return 1 iff the thread with process ID PID is alive. */
103 int (*thread_alive
) (ptid_t pid
);
105 /* Resume the inferior process. */
107 void (*resume
) (struct thread_resume
*resume_info
, size_t n
);
109 /* Wait for the inferior process or thread to change state. Store
110 status through argument pointer STATUS.
112 PTID = -1 to wait for any pid to do something, PTID(pid,0,0) to
113 wait for any thread of process pid to do something. Return ptid
114 of child, or -1 in case of error; store status through argument
115 pointer STATUS. OPTIONS is a bit set of options defined as
116 TARGET_W* above. If options contains TARGET_WNOHANG and there's
117 no child stop to report, return is
118 null_ptid/TARGET_WAITKIND_IGNORE. */
120 ptid_t (*wait
) (ptid_t ptid
, struct target_waitstatus
*status
, int options
);
122 /* Fetch registers from the inferior process.
124 If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
126 void (*fetch_registers
) (struct regcache
*regcache
, int regno
);
128 /* Store registers to the inferior process.
130 If REGNO is -1, store all registers; otherwise, store at least REGNO. */
132 void (*store_registers
) (struct regcache
*regcache
, int regno
);
134 /* Prepare to read or write memory from the inferior process.
135 Targets use this to do what is necessary to get the state of the
136 inferior such that it is possible to access memory.
138 This should generally only be called from client facing routines,
139 such as gdb_read_memory/gdb_write_memory, or the insert_point
142 Like `read_memory' and `write_memory' below, returns 0 on success
143 and errno on failure. */
145 int (*prepare_to_access_memory
) (void);
147 /* Undo the effects of prepare_to_access_memory. */
149 void (*done_accessing_memory
) (void);
151 /* Read memory from the inferior process. This should generally be
152 called through read_inferior_memory, which handles breakpoint shadowing.
154 Read LEN bytes at MEMADDR into a buffer at MYADDR.
156 Returns 0 on success and errno on failure. */
158 int (*read_memory
) (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
);
160 /* Write memory to the inferior process. This should generally be
161 called through write_inferior_memory, which handles breakpoint shadowing.
163 Write LEN bytes from the buffer at MYADDR to MEMADDR.
165 Returns 0 on success and errno on failure. */
167 int (*write_memory
) (CORE_ADDR memaddr
, const unsigned char *myaddr
,
170 /* Query GDB for the values of any symbols we're interested in.
171 This function is called whenever we receive a "qSymbols::"
172 query, which corresponds to every time more symbols (might)
173 become available. NULL if we aren't interested in any
176 void (*look_up_symbols
) (void);
178 /* Send an interrupt request to the inferior process,
179 however is appropriate. */
181 void (*request_interrupt
) (void);
183 /* Read auxiliary vector data from the inferior process.
185 Read LEN bytes at OFFSET into a buffer at MYADDR. */
187 int (*read_auxv
) (CORE_ADDR offset
, unsigned char *myaddr
,
190 /* Insert and remove a break or watchpoint.
191 Returns 0 on success, -1 on failure and 1 on unsupported.
192 The type is coded as follows:
193 '0' - software-breakpoint
194 '1' - hardware-breakpoint
195 '2' - write watchpoint
196 '3' - read watchpoint
197 '4' - access watchpoint */
199 int (*insert_point
) (char type
, CORE_ADDR addr
, int len
);
200 int (*remove_point
) (char type
, CORE_ADDR addr
, int len
);
202 /* Returns 1 if target was stopped due to a watchpoint hit, 0 otherwise. */
204 int (*stopped_by_watchpoint
) (void);
206 /* Returns the address associated with the watchpoint that hit, if any;
207 returns 0 otherwise. */
209 CORE_ADDR (*stopped_data_address
) (void);
211 /* Reports the text, data offsets of the executable. This is
212 needed for uclinux where the executable is relocated during load
215 int (*read_offsets
) (CORE_ADDR
*text
, CORE_ADDR
*data
);
217 /* Fetch the address associated with a specific thread local storage
218 area, determined by the specified THREAD, OFFSET, and LOAD_MODULE.
219 Stores it in *ADDRESS and returns zero on success; otherwise returns
220 an error code. A return value of -1 means this system does not
221 support the operation. */
223 int (*get_tls_address
) (struct thread_info
*thread
, CORE_ADDR offset
,
224 CORE_ADDR load_module
, CORE_ADDR
*address
);
226 /* Read/Write from/to spufs using qXfer packets. */
227 int (*qxfer_spu
) (const char *annex
, unsigned char *readbuf
,
228 unsigned const char *writebuf
, CORE_ADDR offset
, int len
);
230 /* Fill BUF with an hostio error packet representing the last hostio
232 void (*hostio_last_error
) (char *buf
);
234 /* Read/Write OS data using qXfer packets. */
235 int (*qxfer_osdata
) (const char *annex
, unsigned char *readbuf
,
236 unsigned const char *writebuf
, CORE_ADDR offset
,
239 /* Read/Write extra signal info. */
240 int (*qxfer_siginfo
) (const char *annex
, unsigned char *readbuf
,
241 unsigned const char *writebuf
,
242 CORE_ADDR offset
, int len
);
244 int (*supports_non_stop
) (void);
246 /* Enables async target events. Returns the previous enable
248 int (*async
) (int enable
);
250 /* Switch to non-stop (1) or all-stop (0) mode. Return 0 on
251 success, -1 otherwise. */
252 int (*start_non_stop
) (int);
254 /* Returns true if the target supports multi-process debugging. */
255 int (*supports_multi_process
) (void);
257 /* If not NULL, target-specific routine to process monitor command.
258 Returns 1 if handled, or 0 to perform default processing. */
259 int (*handle_monitor_command
) (char *);
261 /* Returns the core given a thread, or -1 if not known. */
262 int (*core_of_thread
) (ptid_t
);
264 /* Read loadmaps. Read LEN bytes at OFFSET into a buffer at MYADDR. */
265 int (*read_loadmap
) (const char *annex
, CORE_ADDR offset
,
266 unsigned char *myaddr
, unsigned int len
);
268 /* Target specific qSupported support. */
269 void (*process_qsupported
) (const char *);
271 /* Return 1 if the target supports tracepoints, 0 (or leave the
272 callback NULL) otherwise. */
273 int (*supports_tracepoints
) (void);
275 /* Read PC from REGCACHE. */
276 CORE_ADDR (*read_pc
) (struct regcache
*regcache
);
278 /* Write PC to REGCACHE. */
279 void (*write_pc
) (struct regcache
*regcache
, CORE_ADDR pc
);
281 /* Return true if THREAD is known to be stopped now. */
282 int (*thread_stopped
) (struct thread_info
*thread
);
284 /* Read Thread Information Block address. */
285 int (*get_tib_address
) (ptid_t ptid
, CORE_ADDR
*address
);
287 /* Pause all threads. If FREEZE, arrange for any resume attempt to
288 be ignored until an unpause_all call unfreezes threads again.
289 There can be nested calls to pause_all, so a freeze counter
290 should be maintained. */
291 void (*pause_all
) (int freeze
);
293 /* Unpause all threads. Threads that hadn't been resumed by the
294 client should be left stopped. Basically a pause/unpause call
295 pair should not end up resuming threads that were stopped before
297 void (*unpause_all
) (int unfreeze
);
299 /* Cancel all pending breakpoints hits in all threads. */
300 void (*cancel_breakpoints
) (void);
302 /* Stabilize all threads. That is, force them out of jump pads. */
303 void (*stabilize_threads
) (void);
305 /* Install a fast tracepoint jump pad. TPOINT is the address of the
306 tracepoint internal object as used by the IPA agent. TPADDR is
307 the address of tracepoint. COLLECTOR is address of the function
308 the jump pad redirects to. LOCKADDR is the address of the jump
309 pad lock object. ORIG_SIZE is the size in bytes of the
310 instruction at TPADDR. JUMP_ENTRY points to the address of the
311 jump pad entry, and on return holds the address past the end of
312 the created jump pad. If a trampoline is created by the function,
313 then TRAMPOLINE and TRAMPOLINE_SIZE return the address and size of
314 the trampoline, else they remain unchanged. JJUMP_PAD_INSN is a
315 buffer containing a copy of the instruction at TPADDR.
316 ADJUST_INSN_ADDR and ADJUST_INSN_ADDR_END are output parameters that
317 return the address range where the instruction at TPADDR was relocated
318 to. If an error occurs, the ERR may be used to pass on an error
320 int (*install_fast_tracepoint_jump_pad
) (CORE_ADDR tpoint
, CORE_ADDR tpaddr
,
324 CORE_ADDR
*jump_entry
,
325 CORE_ADDR
*trampoline
,
326 ULONGEST
*trampoline_size
,
327 unsigned char *jjump_pad_insn
,
328 ULONGEST
*jjump_pad_insn_size
,
329 CORE_ADDR
*adjusted_insn_addr
,
330 CORE_ADDR
*adjusted_insn_addr_end
,
333 /* Return the bytecode operations vector for the current inferior.
334 Returns NULL if bytecode compilation is not supported. */
335 struct emit_ops
*(*emit_ops
) (void);
337 /* Returns true if the target supports disabling randomization. */
338 int (*supports_disable_randomization
) (void);
340 /* Return the minimum length of an instruction that can be safely overwritten
341 for use as a fast tracepoint. */
342 int (*get_min_fast_tracepoint_insn_len
) (void);
344 /* Read solib info on SVR4 platforms. */
345 int (*qxfer_libraries_svr4
) (const char *annex
, unsigned char *readbuf
,
346 unsigned const char *writebuf
,
347 CORE_ADDR offset
, int len
);
349 /* Return true if target supports debugging agent. */
350 int (*supports_agent
) (void);
352 /* Check whether the target supports branch tracing. */
353 int (*supports_btrace
) (void);
355 /* Enable branch tracing for @ptid and allocate a branch trace target
356 information struct for reading and for disabling branch trace. */
357 struct btrace_target_info
*(*enable_btrace
) (ptid_t ptid
);
359 /* Disable branch tracing.
360 Returns zero on success, non-zero otherwise. */
361 int (*disable_btrace
) (struct btrace_target_info
*tinfo
);
363 /* Read branch trace data into buffer. We use an int to specify the type
364 to break a cyclic dependency.
365 Return 0 on success; print an error message into BUFFER and return -1,
367 int (*read_btrace
) (struct btrace_target_info
*, struct buffer
*, int type
);
369 /* Return true if target supports range stepping. */
370 int (*supports_range_stepping
) (void);
373 extern struct target_ops
*the_target
;
375 void set_target_ops (struct target_ops
*);
377 #define create_inferior(program, args) \
378 (*the_target->create_inferior) (program, args)
380 #define myattach(pid) \
381 (*the_target->attach) (pid)
383 int kill_inferior (int);
385 #define detach_inferior(pid) \
386 (*the_target->detach) (pid)
388 #define mourn_inferior(PROC) \
389 (*the_target->mourn) (PROC)
391 #define mythread_alive(pid) \
392 (*the_target->thread_alive) (pid)
394 #define fetch_inferior_registers(regcache, regno) \
395 (*the_target->fetch_registers) (regcache, regno)
397 #define store_inferior_registers(regcache, regno) \
398 (*the_target->store_registers) (regcache, regno)
400 #define join_inferior(pid) \
401 (*the_target->join) (pid)
403 #define target_supports_non_stop() \
404 (the_target->supports_non_stop ? (*the_target->supports_non_stop ) () : 0)
406 #define target_async(enable) \
407 (the_target->async ? (*the_target->async) (enable) : 0)
409 #define target_supports_multi_process() \
410 (the_target->supports_multi_process ? \
411 (*the_target->supports_multi_process) () : 0)
413 #define target_process_qsupported(query) \
416 if (the_target->process_qsupported) \
417 the_target->process_qsupported (query); \
420 #define target_supports_tracepoints() \
421 (the_target->supports_tracepoints \
422 ? (*the_target->supports_tracepoints) () : 0)
424 #define target_supports_fast_tracepoints() \
425 (the_target->install_fast_tracepoint_jump_pad != NULL)
427 #define target_get_min_fast_tracepoint_insn_len() \
428 (the_target->get_min_fast_tracepoint_insn_len \
429 ? (*the_target->get_min_fast_tracepoint_insn_len) () : 0)
431 #define thread_stopped(thread) \
432 (*the_target->thread_stopped) (thread)
434 #define pause_all(freeze) \
437 if (the_target->pause_all) \
438 (*the_target->pause_all) (freeze); \
441 #define unpause_all(unfreeze) \
444 if (the_target->unpause_all) \
445 (*the_target->unpause_all) (unfreeze); \
448 #define cancel_breakpoints() \
451 if (the_target->cancel_breakpoints) \
452 (*the_target->cancel_breakpoints) (); \
455 #define stabilize_threads() \
458 if (the_target->stabilize_threads) \
459 (*the_target->stabilize_threads) (); \
462 #define install_fast_tracepoint_jump_pad(tpoint, tpaddr, \
463 collector, lockaddr, \
466 trampoline, trampoline_size, \
468 jjump_pad_insn_size, \
469 adjusted_insn_addr, \
470 adjusted_insn_addr_end, \
472 (*the_target->install_fast_tracepoint_jump_pad) (tpoint, tpaddr, \
473 collector,lockaddr, \
474 orig_size, jump_entry, \
478 jjump_pad_insn_size, \
479 adjusted_insn_addr, \
480 adjusted_insn_addr_end, \
483 #define target_emit_ops() \
484 (the_target->emit_ops ? (*the_target->emit_ops) () : NULL)
486 #define target_supports_disable_randomization() \
487 (the_target->supports_disable_randomization ? \
488 (*the_target->supports_disable_randomization) () : 0)
490 #define target_supports_agent() \
491 (the_target->supports_agent ? \
492 (*the_target->supports_agent) () : 0)
494 #define target_supports_btrace() \
495 (the_target->supports_btrace ? (*the_target->supports_btrace) () : 0)
497 #define target_enable_btrace(ptid) \
498 (*the_target->enable_btrace) (ptid)
500 #define target_disable_btrace(tinfo) \
501 (*the_target->disable_btrace) (tinfo)
503 #define target_read_btrace(tinfo, buffer, type) \
504 (*the_target->read_btrace) (tinfo, buffer, type)
506 #define target_supports_range_stepping() \
507 (the_target->supports_range_stepping ? \
508 (*the_target->supports_range_stepping) () : 0)
510 /* Start non-stop mode, returns 0 on success, -1 on failure. */
512 int start_non_stop (int nonstop
);
514 ptid_t
mywait (ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
,
517 #define prepare_to_access_memory() \
518 (the_target->prepare_to_access_memory \
519 ? (*the_target->prepare_to_access_memory) () \
522 #define done_accessing_memory() \
525 if (the_target->done_accessing_memory) \
526 (*the_target->done_accessing_memory) (); \
529 #define target_core_of_thread(ptid) \
530 (the_target->core_of_thread ? (*the_target->core_of_thread) (ptid) \
533 int read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
);
535 int write_inferior_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
,
538 void set_desired_inferior (int id
);
540 const char *target_pid_to_str (ptid_t
);
542 #endif /* TARGET_H */