convert to_set_permissions
[deliverable/binutils-gdb.git] / gdb / target.h
CommitLineData
c906108c 1/* Interface between GDB and target environments, including files and processes
0088c768 2
ecd75fc8 3 Copyright (C) 1990-2014 Free Software Foundation, Inc.
0088c768 4
c906108c
SS
5 Contributed by Cygnus Support. Written by John Gilmore.
6
c5aa993b 7 This file is part of GDB.
c906108c 8
c5aa993b
JM
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
a9762ec7 11 the Free Software Foundation; either version 3 of the License, or
c5aa993b 12 (at your option) any later version.
c906108c 13
c5aa993b
JM
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
c906108c 18
c5aa993b 19 You should have received a copy of the GNU General Public License
a9762ec7 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
21
22#if !defined (TARGET_H)
23#define TARGET_H
24
da3331ec
AC
25struct objfile;
26struct ui_file;
27struct mem_attrib;
1e3ff5ad 28struct target_ops;
d248b706 29struct bp_location;
8181d85f 30struct bp_target_info;
56be3814 31struct regcache;
07b82ea5 32struct target_section_table;
35b1e5cc 33struct trace_state_variable;
00bf0b85
SS
34struct trace_status;
35struct uploaded_tsv;
36struct uploaded_tp;
0fb4aa4b 37struct static_tracepoint_marker;
b3b9301e 38struct traceframe_info;
0cf6dd15 39struct expression;
2a2f9fe4 40struct dcache_struct;
0cf6dd15 41
c906108c
SS
42/* This include file defines the interface between the main part
43 of the debugger, and the part which is target-specific, or
44 specific to the communications interface between us and the
45 target.
46
2146d243
RM
47 A TARGET is an interface between the debugger and a particular
48 kind of file or process. Targets can be STACKED in STRATA,
c906108c
SS
49 so that more than one target can potentially respond to a request.
50 In particular, memory accesses will walk down the stack of targets
51 until they find a target that is interested in handling that particular
52 address. STRATA are artificial boundaries on the stack, within
53 which particular kinds of targets live. Strata exist so that
54 people don't get confused by pushing e.g. a process target and then
55 a file target, and wondering why they can't see the current values
56 of variables any more (the file target is handling them and they
57 never get to the process target). So when you push a file target,
58 it goes into the file stratum, which is always below the process
59 stratum. */
60
33b60d58
LM
61#include "target/resume.h"
62#include "target/wait.h"
63#include "target/waitstatus.h"
c906108c
SS
64#include "bfd.h"
65#include "symtab.h"
29e57380 66#include "memattr.h"
fd79ecee 67#include "vec.h"
2aecd87f 68#include "gdb_signals.h"
02d27625 69#include "btrace.h"
9852c492 70#include "command.h"
c906108c 71
c5aa993b
JM
72enum strata
73 {
74 dummy_stratum, /* The lowest of the low */
75 file_stratum, /* Executable files, etc */
c0edd9ed 76 process_stratum, /* Executing processes or core dump files */
81e64f55 77 thread_stratum, /* Executing threads */
85e747d2
UW
78 record_stratum, /* Support record debugging */
79 arch_stratum /* Architecture overrides */
c5aa993b 80 };
c906108c 81
c5aa993b
JM
82enum thread_control_capabilities
83 {
0d06e24b
JM
84 tc_none = 0, /* Default: can't control thread execution. */
85 tc_schedlock = 1, /* Can lock the thread scheduler. */
c5aa993b 86 };
c906108c 87
a96d9b2e
SDJ
88/* The structure below stores information about a system call.
89 It is basically used in the "catch syscall" command, and in
90 every function that gives information about a system call.
91
92 It's also good to mention that its fields represent everything
93 that we currently know about a syscall in GDB. */
94struct syscall
95 {
96 /* The syscall number. */
97 int number;
98
99 /* The syscall name. */
100 const char *name;
101 };
102
f00150c9
DE
103/* Return a pretty printed form of target_waitstatus.
104 Space for the result is malloc'd, caller must free. */
105extern char *target_waitstatus_to_string (const struct target_waitstatus *);
106
09826ec5
PA
107/* Return a pretty printed form of TARGET_OPTIONS.
108 Space for the result is malloc'd, caller must free. */
109extern char *target_options_to_string (int target_options);
110
2acceee2 111/* Possible types of events that the inferior handler will have to
0d06e24b 112 deal with. */
2acceee2
JM
113enum inferior_event_type
114 {
2acceee2 115 /* Process a normal inferior event which will result in target_wait
0d06e24b 116 being called. */
2146d243 117 INF_REG_EVENT,
0d06e24b 118 /* We are called because a timer went off. */
2acceee2 119 INF_TIMER,
0d06e24b 120 /* We are called to do stuff after the inferior stops. */
c2d11a7d
JM
121 INF_EXEC_COMPLETE,
122 /* We are called to do some stuff after the inferior stops, but we
123 are expected to reenter the proceed() and
c378eb4e 124 handle_inferior_event() functions. This is used only in case of
0d06e24b 125 'step n' like commands. */
c2d11a7d 126 INF_EXEC_CONTINUE
2acceee2 127 };
c906108c 128\f
13547ab6
DJ
129/* Target objects which can be transfered using target_read,
130 target_write, et cetera. */
1e3ff5ad
AC
131
132enum target_object
133{
1e3ff5ad
AC
134 /* AVR target specific transfer. See "avr-tdep.c" and "remote.c". */
135 TARGET_OBJECT_AVR,
23d964e7
UW
136 /* SPU target specific transfer. See "spu-tdep.c". */
137 TARGET_OBJECT_SPU,
1e3ff5ad 138 /* Transfer up-to LEN bytes of memory starting at OFFSET. */
287a334e 139 TARGET_OBJECT_MEMORY,
cf7a04e8
DJ
140 /* Memory, avoiding GDB's data cache and trusting the executable.
141 Target implementations of to_xfer_partial never need to handle
142 this object, and most callers should not use it. */
143 TARGET_OBJECT_RAW_MEMORY,
4e5d721f
DE
144 /* Memory known to be part of the target's stack. This is cached even
145 if it is not in a region marked as such, since it is known to be
146 "normal" RAM. */
147 TARGET_OBJECT_STACK_MEMORY,
29453a14
YQ
148 /* Memory known to be part of the target code. This is cached even
149 if it is not in a region marked as such. */
150 TARGET_OBJECT_CODE_MEMORY,
287a334e
JJ
151 /* Kernel Unwind Table. See "ia64-tdep.c". */
152 TARGET_OBJECT_UNWIND_TABLE,
2146d243
RM
153 /* Transfer auxilliary vector. */
154 TARGET_OBJECT_AUXV,
baf92889 155 /* StackGhost cookie. See "sparc-tdep.c". */
fd79ecee
DJ
156 TARGET_OBJECT_WCOOKIE,
157 /* Target memory map in XML format. */
158 TARGET_OBJECT_MEMORY_MAP,
a76d924d
DJ
159 /* Flash memory. This object can be used to write contents to
160 a previously erased flash memory. Using it without erasing
161 flash can have unexpected results. Addresses are physical
162 address on target, and not relative to flash start. */
23181151
DJ
163 TARGET_OBJECT_FLASH,
164 /* Available target-specific features, e.g. registers and coprocessors.
165 See "target-descriptions.c". ANNEX should never be empty. */
cfa9d6d9
DJ
166 TARGET_OBJECT_AVAILABLE_FEATURES,
167 /* Currently loaded libraries, in XML format. */
07e059b5 168 TARGET_OBJECT_LIBRARIES,
2268b414
JK
169 /* Currently loaded libraries specific for SVR4 systems, in XML format. */
170 TARGET_OBJECT_LIBRARIES_SVR4,
4d1eb6b4 171 /* Currently loaded libraries specific to AIX systems, in XML format. */
ff99b71b 172 TARGET_OBJECT_LIBRARIES_AIX,
07e059b5 173 /* Get OS specific data. The ANNEX specifies the type (running
113a6f1e
JB
174 processes, etc.). The data being transfered is expected to follow
175 the DTD specified in features/osdata.dtd. */
4aa995e1
PA
176 TARGET_OBJECT_OSDATA,
177 /* Extra signal info. Usually the contents of `siginfo_t' on unix
178 platforms. */
179 TARGET_OBJECT_SIGNAL_INFO,
dc146f7c
VP
180 /* The list of threads that are being debugged. */
181 TARGET_OBJECT_THREADS,
0fb4aa4b
PA
182 /* Collected static trace data. */
183 TARGET_OBJECT_STATIC_TRACE_DATA,
77ca787b
JB
184 /* The HP-UX registers (those that can be obtained or modified by using
185 the TT_LWP_RUREGS/TT_LWP_WUREGS ttrace requests). */
186 TARGET_OBJECT_HPUX_UREGS,
c4de7027
JB
187 /* The HP-UX shared library linkage pointer. ANNEX should be a string
188 image of the code address whose linkage pointer we are looking for.
189
190 The size of the data transfered is always 8 bytes (the size of an
191 address on ia64). */
192 TARGET_OBJECT_HPUX_SOLIB_GOT,
b3b9301e
PA
193 /* Traceframe info, in XML format. */
194 TARGET_OBJECT_TRACEFRAME_INFO,
78d85199
YQ
195 /* Load maps for FDPIC systems. */
196 TARGET_OBJECT_FDPIC,
f00c55f8 197 /* Darwin dynamic linker info data. */
169081d0
TG
198 TARGET_OBJECT_DARWIN_DYLD_INFO,
199 /* OpenVMS Unwind Information Block. */
02d27625 200 TARGET_OBJECT_OPENVMS_UIB,
9accd112
MM
201 /* Branch trace data, in XML format. */
202 TARGET_OBJECT_BTRACE
c378eb4e 203 /* Possible future objects: TARGET_OBJECT_FILE, ... */
1e3ff5ad
AC
204};
205
9b409511 206/* Possible values returned by target_xfer_partial, etc. */
6be7b56e 207
9b409511 208enum target_xfer_status
6be7b56e 209{
9b409511
YQ
210 /* Some bytes are transferred. */
211 TARGET_XFER_OK = 1,
212
213 /* No further transfer is possible. */
214 TARGET_XFER_EOF = 0,
215
6be7b56e
PA
216 /* Generic I/O error. Note that it's important that this is '-1',
217 as we still have target_xfer-related code returning hardcoded
218 '-1' on error. */
219 TARGET_XFER_E_IO = -1,
220
221 /* Transfer failed because the piece of the object requested is
222 unavailable. */
223 TARGET_XFER_E_UNAVAILABLE = -2,
224
225 /* Keep list in sync with target_xfer_error_to_string. */
226};
227
9b409511
YQ
228#define TARGET_XFER_STATUS_ERROR_P(STATUS) ((STATUS) < TARGET_XFER_EOF)
229
6be7b56e
PA
230/* Return the string form of ERR. */
231
9b409511 232extern const char *target_xfer_status_to_string (enum target_xfer_status err);
6be7b56e 233
35b1e5cc
SS
234/* Enumeration of the kinds of traceframe searches that a target may
235 be able to perform. */
236
237enum trace_find_type
238 {
239 tfind_number,
240 tfind_pc,
241 tfind_tp,
242 tfind_range,
243 tfind_outside,
244 };
245
0fb4aa4b
PA
246typedef struct static_tracepoint_marker *static_tracepoint_marker_p;
247DEF_VEC_P(static_tracepoint_marker_p);
248
9b409511 249typedef enum target_xfer_status
4ac248ca
YQ
250 target_xfer_partial_ftype (struct target_ops *ops,
251 enum target_object object,
252 const char *annex,
253 gdb_byte *readbuf,
254 const gdb_byte *writebuf,
255 ULONGEST offset,
9b409511
YQ
256 ULONGEST len,
257 ULONGEST *xfered_len);
4ac248ca 258
13547ab6
DJ
259/* Request that OPS transfer up to LEN 8-bit bytes of the target's
260 OBJECT. The OFFSET, for a seekable object, specifies the
261 starting point. The ANNEX can be used to provide additional
262 data-specific information to the target.
1e3ff5ad 263
578d3588
PA
264 Return the number of bytes actually transfered, or a negative error
265 code (an 'enum target_xfer_error' value) if the transfer is not
266 supported or otherwise fails. Return of a positive value less than
267 LEN indicates that no further transfer is possible. Unlike the raw
268 to_xfer_partial interface, callers of these functions do not need
269 to retry partial transfers. */
1e3ff5ad 270
1e3ff5ad
AC
271extern LONGEST target_read (struct target_ops *ops,
272 enum target_object object,
1b0ba102 273 const char *annex, gdb_byte *buf,
1e3ff5ad
AC
274 ULONGEST offset, LONGEST len);
275
8dedea02
VP
276struct memory_read_result
277 {
c378eb4e 278 /* First address that was read. */
8dedea02
VP
279 ULONGEST begin;
280 /* Past-the-end address. */
281 ULONGEST end;
282 /* The data. */
283 gdb_byte *data;
284};
285typedef struct memory_read_result memory_read_result_s;
286DEF_VEC_O(memory_read_result_s);
287
288extern void free_memory_read_result_vector (void *);
289
290extern VEC(memory_read_result_s)* read_memory_robust (struct target_ops *ops,
291 ULONGEST offset,
292 LONGEST len);
d5086790 293
1e3ff5ad
AC
294extern LONGEST target_write (struct target_ops *ops,
295 enum target_object object,
1b0ba102 296 const char *annex, const gdb_byte *buf,
1e3ff5ad 297 ULONGEST offset, LONGEST len);
b6591e8b 298
a76d924d
DJ
299/* Similar to target_write, except that it also calls PROGRESS with
300 the number of bytes written and the opaque BATON after every
301 successful partial write (and before the first write). This is
302 useful for progress reporting and user interaction while writing
303 data. To abort the transfer, the progress callback can throw an
304 exception. */
305
cf7a04e8
DJ
306LONGEST target_write_with_progress (struct target_ops *ops,
307 enum target_object object,
308 const char *annex, const gdb_byte *buf,
309 ULONGEST offset, LONGEST len,
310 void (*progress) (ULONGEST, void *),
311 void *baton);
312
13547ab6
DJ
313/* Wrapper to perform a full read of unknown size. OBJECT/ANNEX will
314 be read using OPS. The return value will be -1 if the transfer
315 fails or is not supported; 0 if the object is empty; or the length
316 of the object otherwise. If a positive value is returned, a
317 sufficiently large buffer will be allocated using xmalloc and
318 returned in *BUF_P containing the contents of the object.
319
320 This method should be used for objects sufficiently small to store
321 in a single xmalloc'd buffer, when no fixed bound on the object's
322 size is known in advance. Don't try to read TARGET_OBJECT_MEMORY
323 through this function. */
324
325extern LONGEST target_read_alloc (struct target_ops *ops,
326 enum target_object object,
327 const char *annex, gdb_byte **buf_p);
328
159f81f3
DJ
329/* Read OBJECT/ANNEX using OPS. The result is NUL-terminated and
330 returned as a string, allocated using xmalloc. If an error occurs
331 or the transfer is unsupported, NULL is returned. Empty objects
332 are returned as allocated but empty strings. A warning is issued
333 if the result contains any embedded NUL bytes. */
334
335extern char *target_read_stralloc (struct target_ops *ops,
336 enum target_object object,
337 const char *annex);
338
6be7b56e 339/* See target_ops->to_xfer_partial. */
4ac248ca 340extern target_xfer_partial_ftype target_xfer_partial;
6be7b56e 341
b6591e8b
AC
342/* Wrappers to target read/write that perform memory transfers. They
343 throw an error if the memory transfer fails.
344
345 NOTE: cagney/2003-10-23: The naming schema is lifted from
346 "frame.h". The parameter order is lifted from get_frame_memory,
347 which in turn lifted it from read_memory. */
348
349extern void get_target_memory (struct target_ops *ops, CORE_ADDR addr,
1b0ba102 350 gdb_byte *buf, LONGEST len);
b6591e8b 351extern ULONGEST get_target_memory_unsigned (struct target_ops *ops,
e17a4113
UW
352 CORE_ADDR addr, int len,
353 enum bfd_endian byte_order);
1e3ff5ad 354\f
0d06e24b
JM
355struct thread_info; /* fwd decl for parameter list below: */
356
b0a16e66
TT
357/* The type of the callback to the to_async method. */
358
359typedef void async_callback_ftype (enum inferior_event_type event_type,
360 void *context);
361
1101cb7b
TT
362/* These defines are used to mark target_ops methods. The script
363 make-target-delegates scans these and auto-generates the base
364 method implementations. There are four macros that can be used:
365
366 1. TARGET_DEFAULT_IGNORE. There is no argument. The base method
367 does nothing. This is only valid if the method return type is
368 'void'.
369
370 2. TARGET_DEFAULT_NORETURN. The argument is a function call, like
371 'tcomplain ()'. The base method simply makes this call, which is
372 assumed not to return.
373
374 3. TARGET_DEFAULT_RETURN. The argument is a C expression. The
375 base method returns this expression's value.
376
377 4. TARGET_DEFAULT_FUNC. The argument is the name of a function.
378 make-target-delegates does not generate a base method in this case,
379 but instead uses the argument function as the base method. */
380
381#define TARGET_DEFAULT_IGNORE()
382#define TARGET_DEFAULT_NORETURN(ARG)
383#define TARGET_DEFAULT_RETURN(ARG)
384#define TARGET_DEFAULT_FUNC(ARG)
385
c906108c 386struct target_ops
c5aa993b 387 {
258b763a 388 struct target_ops *beneath; /* To the target under this one. */
c5aa993b
JM
389 char *to_shortname; /* Name this target type */
390 char *to_longname; /* Name for printing */
391 char *to_doc; /* Documentation. Does not include trailing
c906108c 392 newline, and starts with a one-line descrip-
0d06e24b 393 tion (probably similar to to_longname). */
bba2d28d
AC
394 /* Per-target scratch pad. */
395 void *to_data;
f1c07ab0
AC
396 /* The open routine takes the rest of the parameters from the
397 command, and (if successful) pushes a new target onto the
398 stack. Targets should supply this routine, if only to provide
399 an error message. */
507f3c78 400 void (*to_open) (char *, int);
f1c07ab0
AC
401 /* Old targets with a static target vector provide "to_close".
402 New re-entrant targets provide "to_xclose" and that is expected
403 to xfree everything (including the "struct target_ops"). */
460014f5 404 void (*to_xclose) (struct target_ops *targ);
de90e03d 405 void (*to_close) (struct target_ops *);
e9a29200
TT
406 void (*to_attach) (struct target_ops *ops, char *, int)
407 TARGET_DEFAULT_FUNC (find_default_attach);
bebd3233
TT
408 void (*to_post_attach) (struct target_ops *, int)
409 TARGET_DEFAULT_IGNORE ();
09da0d0a
TT
410 void (*to_detach) (struct target_ops *ops, const char *, int)
411 TARGET_DEFAULT_IGNORE ();
597320e7 412 void (*to_disconnect) (struct target_ops *, char *, int);
6b84065d
TT
413 void (*to_resume) (struct target_ops *, ptid_t, int, enum gdb_signal)
414 TARGET_DEFAULT_NORETURN (noprocess ());
117de6a9 415 ptid_t (*to_wait) (struct target_ops *,
6b84065d
TT
416 ptid_t, struct target_waitstatus *, int)
417 TARGET_DEFAULT_NORETURN (noprocess ());
28439f5e 418 void (*to_fetch_registers) (struct target_ops *, struct regcache *, int);
6b84065d
TT
419 void (*to_store_registers) (struct target_ops *, struct regcache *, int)
420 TARGET_DEFAULT_NORETURN (noprocess ());
6c628163
TT
421 void (*to_prepare_to_store) (struct target_ops *, struct regcache *)
422 TARGET_DEFAULT_NORETURN (noprocess ());
c5aa993b
JM
423
424 /* Transfer LEN bytes of memory between GDB address MYADDR and
425 target address MEMADDR. If WRITE, transfer them to the target, else
426 transfer them from the target. TARGET is the target from which we
427 get this function.
428
429 Return value, N, is one of the following:
430
431 0 means that we can't handle this. If errno has been set, it is the
432 error which prevented us from doing it (FIXME: What about bfd_error?).
433
434 positive (call it N) means that we have transferred N bytes
435 starting at MEMADDR. We might be able to handle more bytes
436 beyond this length, but no promises.
437
438 negative (call its absolute value N) means that we cannot
439 transfer right at MEMADDR, but we could transfer at least
c8e73a31 440 something at MEMADDR + N.
c5aa993b 441
c8e73a31
AC
442 NOTE: cagney/2004-10-01: This has been entirely superseeded by
443 to_xfer_partial and inferior inheritance. */
444
1b0ba102 445 int (*deprecated_xfer_memory) (CORE_ADDR memaddr, gdb_byte *myaddr,
c8e73a31
AC
446 int len, int write,
447 struct mem_attrib *attrib,
448 struct target_ops *target);
c906108c 449
f86e59b2
TT
450 void (*to_files_info) (struct target_ops *)
451 TARGET_DEFAULT_IGNORE ();
3db08215 452 int (*to_insert_breakpoint) (struct target_ops *, struct gdbarch *,
6b84065d
TT
453 struct bp_target_info *)
454 TARGET_DEFAULT_FUNC (memory_insert_breakpoint);
3db08215 455 int (*to_remove_breakpoint) (struct target_ops *, struct gdbarch *,
6b84065d
TT
456 struct bp_target_info *)
457 TARGET_DEFAULT_FUNC (memory_remove_breakpoint);
52b51d06
TT
458 int (*to_can_use_hw_breakpoint) (struct target_ops *, int, int, int)
459 TARGET_DEFAULT_RETURN (0);
f1310107 460 int (*to_ranged_break_num_registers) (struct target_ops *);
23a26771 461 int (*to_insert_hw_breakpoint) (struct target_ops *,
61b371f9
TT
462 struct gdbarch *, struct bp_target_info *)
463 TARGET_DEFAULT_RETURN (-1);
a64dc96c 464 int (*to_remove_hw_breakpoint) (struct target_ops *,
418dabac
TT
465 struct gdbarch *, struct bp_target_info *)
466 TARGET_DEFAULT_RETURN (-1);
0cf6dd15
TJB
467
468 /* Documentation of what the two routines below are expected to do is
469 provided with the corresponding target_* macros. */
11b5219a 470 int (*to_remove_watchpoint) (struct target_ops *,
61dd109f
TT
471 CORE_ADDR, int, int, struct expression *)
472 TARGET_DEFAULT_RETURN (-1);
7bb99c53 473 int (*to_insert_watchpoint) (struct target_ops *,
016facd4
TT
474 CORE_ADDR, int, int, struct expression *)
475 TARGET_DEFAULT_RETURN (-1);
0cf6dd15 476
9c06b0b4
TJB
477 int (*to_insert_mask_watchpoint) (struct target_ops *,
478 CORE_ADDR, CORE_ADDR, int);
479 int (*to_remove_mask_watchpoint) (struct target_ops *,
480 CORE_ADDR, CORE_ADDR, int);
6b84065d
TT
481 int (*to_stopped_by_watchpoint) (struct target_ops *)
482 TARGET_DEFAULT_RETURN (0);
74174d2e 483 int to_have_steppable_watchpoint;
7df1a324 484 int to_have_continuable_watchpoint;
6b84065d
TT
485 int (*to_stopped_data_address) (struct target_ops *, CORE_ADDR *)
486 TARGET_DEFAULT_RETURN (0);
5009afc5 487 int (*to_watchpoint_addr_within_range) (struct target_ops *,
65f160a9
TT
488 CORE_ADDR, CORE_ADDR, int)
489 TARGET_DEFAULT_FUNC (default_watchpoint_addr_within_range);
e09342b5
TJB
490
491 /* Documentation of this routine is provided with the corresponding
492 target_* macro. */
31568a15 493 int (*to_region_ok_for_hw_watchpoint) (struct target_ops *,
d03655e4
TT
494 CORE_ADDR, int)
495 TARGET_DEFAULT_FUNC (default_region_ok_for_hw_watchpoint);
e09342b5 496
c3a5ff89
TT
497 int (*to_can_accel_watchpoint_condition) (struct target_ops *,
498 CORE_ADDR, int, int,
77cdffe9
TT
499 struct expression *)
500 TARGET_DEFAULT_RETURN (0);
9c06b0b4
TJB
501 int (*to_masked_watch_num_registers) (struct target_ops *,
502 CORE_ADDR, CORE_ADDR);
0343661d
TT
503 void (*to_terminal_init) (struct target_ops *)
504 TARGET_DEFAULT_IGNORE ();
ddeaacc9
TT
505 void (*to_terminal_inferior) (struct target_ops *)
506 TARGET_DEFAULT_IGNORE ();
74fcbef9
TT
507 void (*to_terminal_ours_for_output) (struct target_ops *)
508 TARGET_DEFAULT_IGNORE ();
e4a733f1
TT
509 void (*to_terminal_ours) (struct target_ops *)
510 TARGET_DEFAULT_IGNORE ();
c6ea8f79
TT
511 void (*to_terminal_save_ours) (struct target_ops *)
512 TARGET_DEFAULT_IGNORE ();
e19e919f
TT
513 void (*to_terminal_info) (struct target_ops *, const char *, int)
514 TARGET_DEFAULT_FUNC (default_terminal_info);
7d85a9c0 515 void (*to_kill) (struct target_ops *);
7634da87
TT
516 void (*to_load) (struct target_ops *, char *, int)
517 TARGET_DEFAULT_NORETURN (tcomplain ());
136d6dae
VP
518 void (*to_create_inferior) (struct target_ops *,
519 char *, char *, char **, int);
340ba4bf
TT
520 void (*to_post_startup_inferior) (struct target_ops *, ptid_t)
521 TARGET_DEFAULT_IGNORE ();
5958ebeb
TT
522 int (*to_insert_fork_catchpoint) (struct target_ops *, int)
523 TARGET_DEFAULT_RETURN (1);
e1a21fb7
TT
524 int (*to_remove_fork_catchpoint) (struct target_ops *, int)
525 TARGET_DEFAULT_RETURN (1);
7e18a8dc
TT
526 int (*to_insert_vfork_catchpoint) (struct target_ops *, int)
527 TARGET_DEFAULT_RETURN (1);
95c3375e
TT
528 int (*to_remove_vfork_catchpoint) (struct target_ops *, int)
529 TARGET_DEFAULT_RETURN (1);
07107ca6 530 int (*to_follow_fork) (struct target_ops *, int, int);
62f64d7a
TT
531 int (*to_insert_exec_catchpoint) (struct target_ops *, int)
532 TARGET_DEFAULT_RETURN (1);
cda0f38c
TT
533 int (*to_remove_exec_catchpoint) (struct target_ops *, int)
534 TARGET_DEFAULT_RETURN (1);
ff214e67 535 int (*to_set_syscall_catchpoint) (struct target_ops *,
6a9fa051
TT
536 int, int, int, int, int *)
537 TARGET_DEFAULT_RETURN (1);
0db88c1d
TT
538 int (*to_has_exited) (struct target_ops *, int, int, int *)
539 TARGET_DEFAULT_RETURN (0);
136d6dae 540 void (*to_mourn_inferior) (struct target_ops *);
da82bd6b 541 int (*to_can_run) (struct target_ops *);
2455069d
UW
542
543 /* Documentation of this routine is provided with the corresponding
544 target_* macro. */
94bedb42 545 void (*to_pass_signals) (struct target_ops *, int, unsigned char *);
2455069d 546
9b224c5e
PA
547 /* Documentation of this routine is provided with the
548 corresponding target_* function. */
daf5e9b6 549 void (*to_program_signals) (struct target_ops *, int, unsigned char *);
9b224c5e 550
28439f5e
PA
551 int (*to_thread_alive) (struct target_ops *, ptid_t ptid);
552 void (*to_find_new_threads) (struct target_ops *);
117de6a9 553 char *(*to_pid_to_str) (struct target_ops *, ptid_t);
4a7e6dda
TT
554 char *(*to_extra_thread_info) (struct target_ops *, struct thread_info *)
555 TARGET_DEFAULT_RETURN (0);
825828fc
TT
556 char *(*to_thread_name) (struct target_ops *, struct thread_info *)
557 TARGET_DEFAULT_RETURN (0);
1eab8a48 558 void (*to_stop) (struct target_ops *, ptid_t);
1aac633b 559 void (*to_rcmd) (struct target_ops *,
a53f3625
TT
560 char *command, struct ui_file *output)
561 TARGET_DEFAULT_FUNC (default_rcmd);
830ca330
TT
562 char *(*to_pid_to_exec_file) (struct target_ops *, int pid)
563 TARGET_DEFAULT_RETURN (0);
d9cb0195
TT
564 void (*to_log_command) (struct target_ops *, const char *)
565 TARGET_DEFAULT_IGNORE ();
07b82ea5 566 struct target_section_table *(*to_get_section_table) (struct target_ops *);
c5aa993b 567 enum strata to_stratum;
c35b1492
PA
568 int (*to_has_all_memory) (struct target_ops *);
569 int (*to_has_memory) (struct target_ops *);
570 int (*to_has_stack) (struct target_ops *);
571 int (*to_has_registers) (struct target_ops *);
aeaec162 572 int (*to_has_execution) (struct target_ops *, ptid_t);
c5aa993b 573 int to_has_thread_control; /* control thread execution */
dc177b7a 574 int to_attach_no_wait;
6426a772 575 /* ASYNC target controls */
6b84065d
TT
576 int (*to_can_async_p) (struct target_ops *)
577 TARGET_DEFAULT_FUNC (find_default_can_async_p);
578 int (*to_is_async_p) (struct target_ops *)
579 TARGET_DEFAULT_FUNC (find_default_is_async_p);
580 void (*to_async) (struct target_ops *, async_callback_ftype *, void *)
581 TARGET_DEFAULT_NORETURN (tcomplain ());
2a9a2795 582 int (*to_supports_non_stop) (struct target_ops *);
6b04bdb7 583 /* find_memory_regions support method for gcore */
2e73927c 584 int (*to_find_memory_regions) (struct target_ops *,
0b5a2719
TT
585 find_memory_region_ftype func, void *data)
586 TARGET_DEFAULT_FUNC (dummy_find_memory_regions);
6b04bdb7 587 /* make_corefile_notes support method for gcore */
16f796b1
TT
588 char * (*to_make_corefile_notes) (struct target_ops *, bfd *, int *)
589 TARGET_DEFAULT_FUNC (dummy_make_corefile_notes);
6b04bdb7 590 /* get_bookmark support method for bookmarks */
3dbafbbb
TT
591 gdb_byte * (*to_get_bookmark) (struct target_ops *, char *, int)
592 TARGET_DEFAULT_NORETURN (tcomplain ());
6b04bdb7 593 /* goto_bookmark support method for bookmarks */
9bb9d61d
TT
594 void (*to_goto_bookmark) (struct target_ops *, gdb_byte *, int)
595 TARGET_DEFAULT_NORETURN (tcomplain ());
3f47be5c
EZ
596 /* Return the thread-local address at OFFSET in the
597 thread-local storage for the thread PTID and the shared library
598 or executable file given by OBJFILE. If that block of
599 thread-local storage hasn't been allocated yet, this function
600 may return an error. */
117de6a9
PA
601 CORE_ADDR (*to_get_thread_local_address) (struct target_ops *ops,
602 ptid_t ptid,
b2756930 603 CORE_ADDR load_module_addr,
3f47be5c
EZ
604 CORE_ADDR offset);
605
13547ab6
DJ
606 /* Request that OPS transfer up to LEN 8-bit bytes of the target's
607 OBJECT. The OFFSET, for a seekable object, specifies the
608 starting point. The ANNEX can be used to provide additional
609 data-specific information to the target.
610
9b409511
YQ
611 Return the transferred status, error or OK (an
612 'enum target_xfer_status' value). Save the number of bytes
613 actually transferred in *XFERED_LEN if transfer is successful
614 (TARGET_XFER_OK) or the number unavailable bytes if the requested
615 data is unavailable (TARGET_XFER_E_UNAVAILABLE). *XFERED_LEN
616 smaller than LEN does not indicate the end of the object, only
617 the end of the transfer; higher level code should continue
618 transferring if desired. This is handled in target.c.
13547ab6
DJ
619
620 The interface does not support a "retry" mechanism. Instead it
621 assumes that at least one byte will be transfered on each
622 successful call.
623
624 NOTE: cagney/2003-10-17: The current interface can lead to
625 fragmented transfers. Lower target levels should not implement
626 hacks, such as enlarging the transfer, in an attempt to
627 compensate for this. Instead, the target stack should be
628 extended so that it implements supply/collect methods and a
629 look-aside object cache. With that available, the lowest
630 target can safely and freely "push" data up the stack.
631
632 See target_read and target_write for more information. One,
633 and only one, of readbuf or writebuf must be non-NULL. */
634
9b409511
YQ
635 enum target_xfer_status (*to_xfer_partial) (struct target_ops *ops,
636 enum target_object object,
637 const char *annex,
638 gdb_byte *readbuf,
639 const gdb_byte *writebuf,
640 ULONGEST offset, ULONGEST len,
6b84065d
TT
641 ULONGEST *xfered_len)
642 TARGET_DEFAULT_RETURN (TARGET_XFER_E_IO);
1e3ff5ad 643
fd79ecee
DJ
644 /* Returns the memory map for the target. A return value of NULL
645 means that no memory map is available. If a memory address
646 does not fall within any returned regions, it's assumed to be
647 RAM. The returned memory regions should not overlap.
648
649 The order of regions does not matter; target_memory_map will
c378eb4e 650 sort regions by starting address. For that reason, this
fd79ecee
DJ
651 function should not be called directly except via
652 target_memory_map.
653
654 This method should not cache data; if the memory map could
655 change unexpectedly, it should be invalidated, and higher
656 layers will re-fetch it. */
657 VEC(mem_region_s) *(*to_memory_map) (struct target_ops *);
658
a76d924d
DJ
659 /* Erases the region of flash memory starting at ADDRESS, of
660 length LENGTH.
661
662 Precondition: both ADDRESS and ADDRESS+LENGTH should be aligned
663 on flash block boundaries, as reported by 'to_memory_map'. */
664 void (*to_flash_erase) (struct target_ops *,
665 ULONGEST address, LONGEST length);
666
667 /* Finishes a flash memory write sequence. After this operation
668 all flash memory should be available for writing and the result
669 of reading from areas written by 'to_flash_write' should be
670 equal to what was written. */
671 void (*to_flash_done) (struct target_ops *);
672
424163ea
DJ
673 /* Describe the architecture-specific features of this target.
674 Returns the description found, or NULL if no description
675 was available. */
676 const struct target_desc *(*to_read_description) (struct target_ops *ops);
677
0ef643c8
JB
678 /* Build the PTID of the thread on which a given task is running,
679 based on LWP and THREAD. These values are extracted from the
680 task Private_Data section of the Ada Task Control Block, and
681 their interpretation depends on the target. */
1e6b91a4 682 ptid_t (*to_get_ada_task_ptid) (struct target_ops *,
4229b31d
TT
683 long lwp, long thread)
684 TARGET_DEFAULT_FUNC (default_get_ada_task_ptid);
0ef643c8 685
c47ffbe3
VP
686 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
687 Return 0 if *READPTR is already at the end of the buffer.
688 Return -1 if there is insufficient buffer for a whole entry.
689 Return 1 if an entry was read into *TYPEP and *VALP. */
690 int (*to_auxv_parse) (struct target_ops *ops, gdb_byte **readptr,
691 gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp);
692
08388c79
DE
693 /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
694 sequence of bytes in PATTERN with length PATTERN_LEN.
695
696 The result is 1 if found, 0 if not found, and -1 if there was an error
697 requiring halting of the search (e.g. memory read error).
698 If the pattern is found the address is recorded in FOUND_ADDRP. */
699 int (*to_search_memory) (struct target_ops *ops,
700 CORE_ADDR start_addr, ULONGEST search_space_len,
701 const gdb_byte *pattern, ULONGEST pattern_len,
702 CORE_ADDR *found_addrp);
703
b2175913 704 /* Can target execute in reverse? */
53e1cfc7
TT
705 int (*to_can_execute_reverse) (struct target_ops *)
706 TARGET_DEFAULT_RETURN (0);
b2175913 707
32231432
PA
708 /* The direction the target is currently executing. Must be
709 implemented on targets that support reverse execution and async
710 mode. The default simply returns forward execution. */
fe31bf5b
TT
711 enum exec_direction_kind (*to_execution_direction) (struct target_ops *)
712 TARGET_DEFAULT_FUNC (default_execution_direction);
32231432 713
8a305172
PA
714 /* Does this target support debugging multiple processes
715 simultaneously? */
a7304748
TT
716 int (*to_supports_multi_process) (struct target_ops *)
717 TARGET_DEFAULT_RETURN (0);
8a305172 718
d248b706
KY
719 /* Does this target support enabling and disabling tracepoints while a trace
720 experiment is running? */
aab1b22d
TT
721 int (*to_supports_enable_disable_tracepoint) (struct target_ops *)
722 TARGET_DEFAULT_RETURN (0);
d248b706 723
03583c20 724 /* Does this target support disabling address space randomization? */
2bfc0540 725 int (*to_supports_disable_randomization) (struct target_ops *);
03583c20 726
3065dfb6 727 /* Does this target support the tracenz bytecode for string collection? */
9409d39e
TT
728 int (*to_supports_string_tracing) (struct target_ops *)
729 TARGET_DEFAULT_RETURN (0);
3065dfb6 730
b775012e
LM
731 /* Does this target support evaluation of breakpoint conditions on its
732 end? */
efcc2da7 733 int (*to_supports_evaluation_of_breakpoint_conditions) (struct target_ops *);
b775012e 734
d3ce09f5
SS
735 /* Does this target support evaluation of breakpoint commands on its
736 end? */
78eff0ec 737 int (*to_can_run_breakpoint_commands) (struct target_ops *);
d3ce09f5 738
3a8f7b07
JK
739 /* Determine current architecture of thread PTID.
740
741 The target is supposed to determine the architecture of the code where
742 the target is currently stopped at (on Cell, if a target is in spu_run,
743 to_thread_architecture would return SPU, otherwise PPC32 or PPC64).
744 This is architecture used to perform decr_pc_after_break adjustment,
745 and also determines the frame architecture of the innermost frame.
f5656ead 746 ptrace operations need to operate according to target_gdbarch ().
3a8f7b07 747
f5656ead 748 The default implementation always returns target_gdbarch (). */
43eba180
TT
749 struct gdbarch *(*to_thread_architecture) (struct target_ops *, ptid_t)
750 TARGET_DEFAULT_FUNC (default_thread_architecture);
c2250ad1 751
c0694254
PA
752 /* Determine current address space of thread PTID.
753
754 The default implementation always returns the inferior's
755 address space. */
756 struct address_space *(*to_thread_address_space) (struct target_ops *,
757 ptid_t);
758
7313baad
UW
759 /* Target file operations. */
760
761 /* Open FILENAME on the target, using FLAGS and MODE. Return a
762 target file descriptor, or -1 if an error occurs (and set
763 *TARGET_ERRNO). */
cd897586
TT
764 int (*to_fileio_open) (struct target_ops *,
765 const char *filename, int flags, int mode,
7313baad
UW
766 int *target_errno);
767
768 /* Write up to LEN bytes from WRITE_BUF to FD on the target.
769 Return the number of bytes written, or -1 if an error occurs
770 (and set *TARGET_ERRNO). */
0d866f62
TT
771 int (*to_fileio_pwrite) (struct target_ops *,
772 int fd, const gdb_byte *write_buf, int len,
7313baad
UW
773 ULONGEST offset, int *target_errno);
774
775 /* Read up to LEN bytes FD on the target into READ_BUF.
776 Return the number of bytes read, or -1 if an error occurs
777 (and set *TARGET_ERRNO). */
a3be983c
TT
778 int (*to_fileio_pread) (struct target_ops *,
779 int fd, gdb_byte *read_buf, int len,
7313baad
UW
780 ULONGEST offset, int *target_errno);
781
782 /* Close FD on the target. Return 0, or -1 if an error occurs
783 (and set *TARGET_ERRNO). */
df39ea25 784 int (*to_fileio_close) (struct target_ops *, int fd, int *target_errno);
7313baad
UW
785
786 /* Unlink FILENAME on the target. Return 0, or -1 if an error
787 occurs (and set *TARGET_ERRNO). */
dbbca37d
TT
788 int (*to_fileio_unlink) (struct target_ops *,
789 const char *filename, int *target_errno);
7313baad 790
b9e7b9c3
UW
791 /* Read value of symbolic link FILENAME on the target. Return a
792 null-terminated string allocated via xmalloc, or NULL if an error
793 occurs (and set *TARGET_ERRNO). */
fab5aa7c
TT
794 char *(*to_fileio_readlink) (struct target_ops *,
795 const char *filename, int *target_errno);
b9e7b9c3 796
7313baad 797
145b16a9
UW
798 /* Implement the "info proc" command. */
799 void (*to_info_proc) (struct target_ops *, char *, enum info_proc_what);
800
35b1e5cc
SS
801 /* Tracepoint-related operations. */
802
803 /* Prepare the target for a tracing run. */
5536135b
TT
804 void (*to_trace_init) (struct target_ops *)
805 TARGET_DEFAULT_NORETURN (tcomplain ());
35b1e5cc 806
e8ba3115 807 /* Send full details of a tracepoint location to the target. */
548f7808 808 void (*to_download_tracepoint) (struct target_ops *,
9a980a22
TT
809 struct bp_location *location)
810 TARGET_DEFAULT_NORETURN (tcomplain ());
35b1e5cc 811
1e4d1764
YQ
812 /* Is the target able to download tracepoint locations in current
813 state? */
719acc4a
TT
814 int (*to_can_download_tracepoint) (struct target_ops *)
815 TARGET_DEFAULT_RETURN (0);
1e4d1764 816
35b1e5cc 817 /* Send full details of a trace state variable to the target. */
559d2b81 818 void (*to_download_trace_state_variable) (struct target_ops *,
94eb98b9
TT
819 struct trace_state_variable *tsv)
820 TARGET_DEFAULT_NORETURN (tcomplain ());
35b1e5cc 821
d248b706 822 /* Enable a tracepoint on the target. */
46670d57 823 void (*to_enable_tracepoint) (struct target_ops *,
151f70f1
TT
824 struct bp_location *location)
825 TARGET_DEFAULT_NORETURN (tcomplain ());
d248b706
KY
826
827 /* Disable a tracepoint on the target. */
780b049c 828 void (*to_disable_tracepoint) (struct target_ops *,
05c41993
TT
829 struct bp_location *location)
830 TARGET_DEFAULT_NORETURN (tcomplain ());
d248b706 831
35b1e5cc
SS
832 /* Inform the target info of memory regions that are readonly
833 (such as text sections), and so it should return data from
834 those rather than look in the trace buffer. */
86dd181d
TT
835 void (*to_trace_set_readonly_regions) (struct target_ops *)
836 TARGET_DEFAULT_NORETURN (tcomplain ());
35b1e5cc
SS
837
838 /* Start a trace run. */
25da2e80
TT
839 void (*to_trace_start) (struct target_ops *)
840 TARGET_DEFAULT_NORETURN (tcomplain ());
35b1e5cc
SS
841
842 /* Get the current status of a tracing run. */
4072d4ff
TT
843 int (*to_get_trace_status) (struct target_ops *, struct trace_status *ts)
844 TARGET_DEFAULT_RETURN (-1);
35b1e5cc 845
db90e85c
TT
846 void (*to_get_tracepoint_status) (struct target_ops *,
847 struct breakpoint *tp,
6fea14cd
TT
848 struct uploaded_tp *utp)
849 TARGET_DEFAULT_NORETURN (tcomplain ());
f196051f 850
35b1e5cc 851 /* Stop a trace run. */
e51c07ea
TT
852 void (*to_trace_stop) (struct target_ops *)
853 TARGET_DEFAULT_NORETURN (tcomplain ());
35b1e5cc
SS
854
855 /* Ask the target to find a trace frame of the given type TYPE,
856 using NUM, ADDR1, and ADDR2 as search parameters. Returns the
857 number of the trace frame, and also the tracepoint number at
c378eb4e 858 TPP. If no trace frame matches, return -1. May throw if the
f197e0f1 859 operation fails. */
bd4c6793
TT
860 int (*to_trace_find) (struct target_ops *,
861 enum trace_find_type type, int num,
afc94e66
TT
862 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
863 TARGET_DEFAULT_RETURN (-1);
35b1e5cc
SS
864
865 /* Get the value of the trace state variable number TSV, returning
866 1 if the value is known and writing the value itself into the
867 location pointed to by VAL, else returning 0. */
4011015b 868 int (*to_get_trace_state_variable_value) (struct target_ops *,
959bcd0b
TT
869 int tsv, LONGEST *val)
870 TARGET_DEFAULT_RETURN (0);
35b1e5cc 871
a2e6c147
TT
872 int (*to_save_trace_data) (struct target_ops *, const char *filename)
873 TARGET_DEFAULT_NORETURN (tcomplain ());
00bf0b85 874
ab6617cc 875 int (*to_upload_tracepoints) (struct target_ops *,
1e949b00
TT
876 struct uploaded_tp **utpp)
877 TARGET_DEFAULT_RETURN (0);
00bf0b85 878
181e3713 879 int (*to_upload_trace_state_variables) (struct target_ops *,
08120467
TT
880 struct uploaded_tsv **utsvp)
881 TARGET_DEFAULT_RETURN (0);
00bf0b85 882
88ee6f45 883 LONGEST (*to_get_raw_trace_data) (struct target_ops *, gdb_byte *buf,
ace92e7d
TT
884 ULONGEST offset, LONGEST len)
885 TARGET_DEFAULT_NORETURN (tcomplain ());
00bf0b85 886
405f8e94
SS
887 /* Get the minimum length of instruction on which a fast tracepoint
888 may be set on the target. If this operation is unsupported,
889 return -1. If for some reason the minimum length cannot be
890 determined, return 0. */
9249843f
TT
891 int (*to_get_min_fast_tracepoint_insn_len) (struct target_ops *)
892 TARGET_DEFAULT_RETURN (-1);
405f8e94 893
35b1e5cc
SS
894 /* Set the target's tracing behavior in response to unexpected
895 disconnection - set VAL to 1 to keep tracing, 0 to stop. */
0bcfeddf
TT
896 void (*to_set_disconnected_tracing) (struct target_ops *, int val)
897 TARGET_DEFAULT_IGNORE ();
8d526939
TT
898 void (*to_set_circular_trace_buffer) (struct target_ops *, int val)
899 TARGET_DEFAULT_IGNORE ();
f6f899bf 900 /* Set the size of trace buffer in the target. */
91df8d1d
TT
901 void (*to_set_trace_buffer_size) (struct target_ops *, LONGEST val)
902 TARGET_DEFAULT_IGNORE ();
35b1e5cc 903
f196051f
SS
904 /* Add/change textual notes about the trace run, returning 1 if
905 successful, 0 otherwise. */
d9e68a2c
TT
906 int (*to_set_trace_notes) (struct target_ops *,
907 const char *user, const char *notes,
8586ccaa
TT
908 const char *stopnotes)
909 TARGET_DEFAULT_RETURN (0);
f196051f 910
dc146f7c
VP
911 /* Return the processor core that thread PTID was last seen on.
912 This information is updated only when:
913 - update_thread_list is called
914 - thread stops
3e43a32a
MS
915 If the core cannot be determined -- either for the specified
916 thread, or right now, or in this debug session, or for this
917 target -- return -1. */
dc146f7c
VP
918 int (*to_core_of_thread) (struct target_ops *, ptid_t ptid);
919
4a5e7a5b
PA
920 /* Verify that the memory in the [MEMADDR, MEMADDR+SIZE) range
921 matches the contents of [DATA,DATA+SIZE). Returns 1 if there's
922 a match, 0 if there's a mismatch, and -1 if an error is
923 encountered while reading memory. */
924 int (*to_verify_memory) (struct target_ops *, const gdb_byte *data,
925 CORE_ADDR memaddr, ULONGEST size);
926
711e434b
PM
927 /* Return the address of the start of the Thread Information Block
928 a Windows OS specific feature. */
bd7ae0f5 929 int (*to_get_tib_address) (struct target_ops *,
22bcceee
TT
930 ptid_t ptid, CORE_ADDR *addr)
931 TARGET_DEFAULT_NORETURN (tcomplain ());
711e434b 932
d914c394 933 /* Send the new settings of write permission variables. */
dcd6917f
TT
934 void (*to_set_permissions) (struct target_ops *)
935 TARGET_DEFAULT_IGNORE ();
d914c394 936
0fb4aa4b
PA
937 /* Look for a static tracepoint marker at ADDR, and fill in MARKER
938 with its details. Return 1 on success, 0 on failure. */
61fc905d 939 int (*to_static_tracepoint_marker_at) (struct target_ops *, CORE_ADDR,
0fb4aa4b
PA
940 struct static_tracepoint_marker *marker);
941
942 /* Return a vector of all tracepoints markers string id ID, or all
943 markers if ID is NULL. */
944 VEC(static_tracepoint_marker_p) *(*to_static_tracepoint_markers_by_strid)
c686c57f 945 (struct target_ops *, const char *id);
0fb4aa4b 946
b3b9301e 947 /* Return a traceframe info object describing the current
1527aea8
YQ
948 traceframe's contents. If the target doesn't support
949 traceframe info, return NULL. If the current traceframe is not
950 selected (the current traceframe number is -1), the target can
951 choose to return either NULL or an empty traceframe info. If
952 NULL is returned, for example in remote target, GDB will read
953 from the live inferior. If an empty traceframe info is
954 returned, for example in tfile target, which means the
955 traceframe info is available, but the requested memory is not
956 available in it. GDB will try to see if the requested memory
957 is available in the read-only sections. This method should not
958 cache data; higher layers take care of caching, invalidating,
959 and re-fetching when necessary. */
a893e81f 960 struct traceframe_info *(*to_traceframe_info) (struct target_ops *);
b3b9301e 961
d1feda86
YQ
962 /* Ask the target to use or not to use agent according to USE. Return 1
963 successful, 0 otherwise. */
2c152180 964 int (*to_use_agent) (struct target_ops *, int use);
d1feda86
YQ
965
966 /* Is the target able to use agent in current state? */
fe38f897 967 int (*to_can_use_agent) (struct target_ops *);
d1feda86 968
02d27625 969 /* Check whether the target supports branch tracing. */
46917d26
TT
970 int (*to_supports_btrace) (struct target_ops *)
971 TARGET_DEFAULT_RETURN (0);
02d27625
MM
972
973 /* Enable branch tracing for PTID and allocate a branch trace target
974 information struct for reading and for disabling branch trace. */
e3c49f88
TT
975 struct btrace_target_info *(*to_enable_btrace) (struct target_ops *,
976 ptid_t ptid);
02d27625
MM
977
978 /* Disable branch tracing and deallocate TINFO. */
25e95349
TT
979 void (*to_disable_btrace) (struct target_ops *,
980 struct btrace_target_info *tinfo);
02d27625
MM
981
982 /* Disable branch tracing and deallocate TINFO. This function is similar
983 to to_disable_btrace, except that it is called during teardown and is
984 only allowed to perform actions that are safe. A counter-example would
985 be attempting to talk to a remote target. */
1777056d
TT
986 void (*to_teardown_btrace) (struct target_ops *,
987 struct btrace_target_info *tinfo);
02d27625 988
969c39fb
MM
989 /* Read branch trace data for the thread indicated by BTINFO into DATA.
990 DATA is cleared before new trace is added.
991 The branch trace will start with the most recent block and continue
992 towards older blocks. */
39c49f83
TT
993 enum btrace_error (*to_read_btrace) (struct target_ops *self,
994 VEC (btrace_block_s) **data,
969c39fb
MM
995 struct btrace_target_info *btinfo,
996 enum btrace_read_type type);
02d27625 997
7c1687a9 998 /* Stop trace recording. */
c6cd7c02 999 void (*to_stop_recording) (struct target_ops *);
7c1687a9 1000
d02ed0bb 1001 /* Print information about the recording. */
630d6a4a 1002 void (*to_info_record) (struct target_ops *);
d02ed0bb
MM
1003
1004 /* Save the recorded execution trace into a file. */
1390f529 1005 void (*to_save_record) (struct target_ops *, const char *filename);
d02ed0bb
MM
1006
1007 /* Delete the recorded execution trace from the current position onwards. */
d1b55219 1008 void (*to_delete_record) (struct target_ops *);
d02ed0bb
MM
1009
1010 /* Query if the record target is currently replaying. */
1c63c994 1011 int (*to_record_is_replaying) (struct target_ops *);
d02ed0bb
MM
1012
1013 /* Go to the begin of the execution trace. */
08475817 1014 void (*to_goto_record_begin) (struct target_ops *);
d02ed0bb
MM
1015
1016 /* Go to the end of the execution trace. */
307a1b91 1017 void (*to_goto_record_end) (struct target_ops *);
d02ed0bb
MM
1018
1019 /* Go to a specific location in the recorded execution trace. */
606183ac 1020 void (*to_goto_record) (struct target_ops *, ULONGEST insn);
d02ed0bb 1021
67c86d06
MM
1022 /* Disassemble SIZE instructions in the recorded execution trace from
1023 the current position.
1024 If SIZE < 0, disassemble abs (SIZE) preceding instructions; otherwise,
1025 disassemble SIZE succeeding instructions. */
7a6c5609 1026 void (*to_insn_history) (struct target_ops *, int size, int flags);
67c86d06
MM
1027
1028 /* Disassemble SIZE instructions in the recorded execution trace around
1029 FROM.
1030 If SIZE < 0, disassemble abs (SIZE) instructions before FROM; otherwise,
1031 disassemble SIZE instructions after FROM. */
9abc3ff3
TT
1032 void (*to_insn_history_from) (struct target_ops *,
1033 ULONGEST from, int size, int flags);
67c86d06
MM
1034
1035 /* Disassemble a section of the recorded execution trace from instruction
0688d04e 1036 BEGIN (inclusive) to instruction END (inclusive). */
4e99c6b7
TT
1037 void (*to_insn_history_range) (struct target_ops *,
1038 ULONGEST begin, ULONGEST end, int flags);
67c86d06 1039
15984c13
MM
1040 /* Print a function trace of the recorded execution trace.
1041 If SIZE < 0, print abs (SIZE) preceding functions; otherwise, print SIZE
1042 succeeding functions. */
5df2fcba 1043 void (*to_call_history) (struct target_ops *, int size, int flags);
15984c13
MM
1044
1045 /* Print a function trace of the recorded execution trace starting
1046 at function FROM.
1047 If SIZE < 0, print abs (SIZE) functions before FROM; otherwise, print
1048 SIZE functions after FROM. */
ec0aea04
TT
1049 void (*to_call_history_from) (struct target_ops *,
1050 ULONGEST begin, int size, int flags);
15984c13
MM
1051
1052 /* Print a function trace of an execution trace section from function BEGIN
0688d04e 1053 (inclusive) to function END (inclusive). */
f0d960ea
TT
1054 void (*to_call_history_range) (struct target_ops *,
1055 ULONGEST begin, ULONGEST end, int flags);
15984c13 1056
ced63ec0
GB
1057 /* Nonzero if TARGET_OBJECT_LIBRARIES_SVR4 may be read with a
1058 non-empty annex. */
5436ff03 1059 int (*to_augmented_libraries_svr4_read) (struct target_ops *);
ced63ec0 1060
ea001bdc
MM
1061 /* Those unwinders are tried before any other arch unwinders. Use NULL if
1062 it is not used. */
1063 const struct frame_unwind *to_get_unwinder;
1064 const struct frame_unwind *to_get_tailcall_unwinder;
1065
118e6252
MM
1066 /* Return the number of bytes by which the PC needs to be decremented
1067 after executing a breakpoint instruction.
1068 Defaults to gdbarch_decr_pc_after_break (GDBARCH). */
1069 CORE_ADDR (*to_decr_pc_after_break) (struct target_ops *ops,
1070 struct gdbarch *gdbarch);
1071
c5aa993b 1072 int to_magic;
0d06e24b
JM
1073 /* Need sub-structure for target machine related rather than comm related?
1074 */
c5aa993b 1075 };
c906108c
SS
1076
1077/* Magic number for checking ops size. If a struct doesn't end with this
1078 number, somebody changed the declaration but didn't change all the
1079 places that initialize one. */
1080
1081#define OPS_MAGIC 3840
1082
1083/* The ops structure for our "current" target process. This should
1084 never be NULL. If there is no target, it points to the dummy_target. */
1085
c5aa993b 1086extern struct target_ops current_target;
c906108c 1087
c906108c
SS
1088/* Define easy words for doing these operations on our current target. */
1089
1090#define target_shortname (current_target.to_shortname)
1091#define target_longname (current_target.to_longname)
1092
f1c07ab0 1093/* Does whatever cleanup is required for a target that we are no
460014f5
JK
1094 longer going to be calling. This routine is automatically always
1095 called after popping the target off the target stack - the target's
1096 own methods are no longer available through the target vector.
1097 Closing file descriptors and freeing all memory allocated memory are
1098 typical things it should do. */
f1c07ab0 1099
460014f5 1100void target_close (struct target_ops *targ);
c906108c
SS
1101
1102/* Attaches to a process on the target side. Arguments are as passed
1103 to the `attach' command by the user. This routine can be called
1104 when the target is not on the target-stack, if the target_can_run
2146d243 1105 routine returns 1; in that case, it must push itself onto the stack.
c906108c 1106 Upon exit, the target should be ready for normal operations, and
2146d243 1107 should be ready to deliver the status of the process immediately
c906108c
SS
1108 (without waiting) to an upcoming target_wait call. */
1109
136d6dae 1110void target_attach (char *, int);
c906108c 1111
dc177b7a
PA
1112/* Some targets don't generate traps when attaching to the inferior,
1113 or their target_attach implementation takes care of the waiting.
1114 These targets must set to_attach_no_wait. */
1115
1116#define target_attach_no_wait \
1117 (current_target.to_attach_no_wait)
1118
c906108c
SS
1119/* The target_attach operation places a process under debugger control,
1120 and stops the process.
1121
1122 This operation provides a target-specific hook that allows the
0d06e24b 1123 necessary bookkeeping to be performed after an attach completes. */
c906108c 1124#define target_post_attach(pid) \
f045800c 1125 (*current_target.to_post_attach) (&current_target, pid)
c906108c 1126
c906108c
SS
1127/* Takes a program previously attached to and detaches it.
1128 The program may resume execution (some targets do, some don't) and will
1129 no longer stop on signals, etc. We better not have left any breakpoints
1130 in the program or it'll die when it hits one. ARGS is arguments
1131 typed by the user (e.g. a signal to send the process). FROM_TTY
1132 says whether to be verbose or not. */
1133
52554a0e 1134extern void target_detach (const char *, int);
c906108c 1135
6ad8ae5c
DJ
1136/* Disconnect from the current target without resuming it (leaving it
1137 waiting for a debugger). */
1138
1139extern void target_disconnect (char *, int);
1140
e5ef252a
PA
1141/* Resume execution of the target process PTID (or a group of
1142 threads). STEP says whether to single-step or to run free; SIGGNAL
1143 is the signal to be given to the target, or GDB_SIGNAL_0 for no
1144 signal. The caller may not pass GDB_SIGNAL_DEFAULT. A specific
1145 PTID means `step/resume only this process id'. A wildcard PTID
1146 (all threads, or all threads of process) means `step/resume
1147 INFERIOR_PTID, and let other threads (for which the wildcard PTID
1148 matches) resume with their 'thread->suspend.stop_signal' signal
1149 (usually GDB_SIGNAL_0) if it is in "pass" state, or with no signal
1150 if in "no pass" state. */
c906108c 1151
2ea28649 1152extern void target_resume (ptid_t ptid, int step, enum gdb_signal signal);
c906108c 1153
b5a2688f
AC
1154/* Wait for process pid to do something. PTID = -1 to wait for any
1155 pid to do something. Return pid of child, or -1 in case of error;
c906108c 1156 store status through argument pointer STATUS. Note that it is
b5a2688f 1157 _NOT_ OK to throw_exception() out of target_wait() without popping
c906108c
SS
1158 the debugging target from the stack; GDB isn't prepared to get back
1159 to the prompt with a debugging target but without the frame cache,
47608cb1
PA
1160 stop_pc, etc., set up. OPTIONS is a bitwise OR of TARGET_W*
1161 options. */
c906108c 1162
47608cb1
PA
1163extern ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status,
1164 int options);
c906108c 1165
17dee195 1166/* Fetch at least register REGNO, or all regs if regno == -1. No result. */
c906108c 1167
28439f5e 1168extern void target_fetch_registers (struct regcache *regcache, int regno);
c906108c
SS
1169
1170/* Store at least register REGNO, or all regs if REGNO == -1.
1171 It can store as many registers as it wants to, so target_prepare_to_store
1172 must have been previously called. Calls error() if there are problems. */
1173
28439f5e 1174extern void target_store_registers (struct regcache *regcache, int regs);
c906108c
SS
1175
1176/* Get ready to modify the registers array. On machines which store
1177 individual registers, this doesn't need to do anything. On machines
1178 which store all the registers in one fell swoop, this makes sure
1179 that REGISTERS contains all the registers from the program being
1180 debugged. */
1181
316f2060 1182#define target_prepare_to_store(regcache) \
f32dbf8c 1183 (*current_target.to_prepare_to_store) (&current_target, regcache)
c906108c 1184
6c95b8df
PA
1185/* Determine current address space of thread PTID. */
1186
1187struct address_space *target_thread_address_space (ptid_t);
1188
451b7c33
TT
1189/* Implement the "info proc" command. This returns one if the request
1190 was handled, and zero otherwise. It can also throw an exception if
1191 an error was encountered while attempting to handle the
1192 request. */
145b16a9 1193
451b7c33 1194int target_info_proc (char *, enum info_proc_what);
145b16a9 1195
8a305172
PA
1196/* Returns true if this target can debug multiple processes
1197 simultaneously. */
1198
1199#define target_supports_multi_process() \
86ce2668 1200 (*current_target.to_supports_multi_process) (&current_target)
8a305172 1201
03583c20
UW
1202/* Returns true if this target can disable address space randomization. */
1203
1204int target_supports_disable_randomization (void);
1205
d248b706
KY
1206/* Returns true if this target can enable and disable tracepoints
1207 while a trace experiment is running. */
1208
1209#define target_supports_enable_disable_tracepoint() \
7d178d6a 1210 (*current_target.to_supports_enable_disable_tracepoint) (&current_target)
d248b706 1211
3065dfb6 1212#define target_supports_string_tracing() \
6de37a3a 1213 (*current_target.to_supports_string_tracing) (&current_target)
3065dfb6 1214
b775012e
LM
1215/* Returns true if this target can handle breakpoint conditions
1216 on its end. */
1217
1218#define target_supports_evaluation_of_breakpoint_conditions() \
efcc2da7 1219 (*current_target.to_supports_evaluation_of_breakpoint_conditions) (&current_target)
b775012e 1220
d3ce09f5
SS
1221/* Returns true if this target can handle breakpoint commands
1222 on its end. */
1223
1224#define target_can_run_breakpoint_commands() \
78eff0ec 1225 (*current_target.to_can_run_breakpoint_commands) (&current_target)
d3ce09f5 1226
a14ed312 1227extern int target_read_string (CORE_ADDR, char **, int, int *);
c906108c 1228
5299c1c4 1229extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
1b162304 1230 ssize_t len);
c906108c 1231
aee4bf85
PA
1232extern int target_read_raw_memory (CORE_ADDR memaddr, gdb_byte *myaddr,
1233 ssize_t len);
1234
45aa4659 1235extern int target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len);
4e5d721f 1236
29453a14
YQ
1237extern int target_read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len);
1238
fc1a4b47 1239extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
45aa4659 1240 ssize_t len);
c906108c 1241
f0ba3972 1242extern int target_write_raw_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
45aa4659 1243 ssize_t len);
f0ba3972 1244
fd79ecee
DJ
1245/* Fetches the target's memory map. If one is found it is sorted
1246 and returned, after some consistency checking. Otherwise, NULL
1247 is returned. */
1248VEC(mem_region_s) *target_memory_map (void);
1249
a76d924d
DJ
1250/* Erase the specified flash region. */
1251void target_flash_erase (ULONGEST address, LONGEST length);
1252
1253/* Finish a sequence of flash operations. */
1254void target_flash_done (void);
1255
1256/* Describes a request for a memory write operation. */
1257struct memory_write_request
1258 {
c378eb4e 1259 /* Begining address that must be written. */
a76d924d 1260 ULONGEST begin;
c378eb4e 1261 /* Past-the-end address. */
a76d924d 1262 ULONGEST end;
c378eb4e 1263 /* The data to write. */
a76d924d
DJ
1264 gdb_byte *data;
1265 /* A callback baton for progress reporting for this request. */
1266 void *baton;
1267 };
1268typedef struct memory_write_request memory_write_request_s;
1269DEF_VEC_O(memory_write_request_s);
1270
1271/* Enumeration specifying different flash preservation behaviour. */
1272enum flash_preserve_mode
1273 {
1274 flash_preserve,
1275 flash_discard
1276 };
1277
1278/* Write several memory blocks at once. This version can be more
1279 efficient than making several calls to target_write_memory, in
1280 particular because it can optimize accesses to flash memory.
1281
1282 Moreover, this is currently the only memory access function in gdb
1283 that supports writing to flash memory, and it should be used for
1284 all cases where access to flash memory is desirable.
1285
1286 REQUESTS is the vector (see vec.h) of memory_write_request.
1287 PRESERVE_FLASH_P indicates what to do with blocks which must be
1288 erased, but not completely rewritten.
1289 PROGRESS_CB is a function that will be periodically called to provide
1290 feedback to user. It will be called with the baton corresponding
1291 to the request currently being written. It may also be called
1292 with a NULL baton, when preserved flash sectors are being rewritten.
1293
1294 The function returns 0 on success, and error otherwise. */
1295int target_write_memory_blocks (VEC(memory_write_request_s) *requests,
1296 enum flash_preserve_mode preserve_flash_p,
1297 void (*progress_cb) (ULONGEST, void *));
1298
c906108c
SS
1299/* Print a line about the current target. */
1300
1301#define target_files_info() \
0d06e24b 1302 (*current_target.to_files_info) (&current_target)
c906108c 1303
0000e5cc
PA
1304/* Insert a hardware breakpoint at address BP_TGT->placed_address in
1305 the target machine. Returns 0 for success, and returns non-zero or
1306 throws an error (with a detailed failure reason error code and
1307 message) otherwise. */
c906108c 1308
d914c394
SS
1309extern int target_insert_breakpoint (struct gdbarch *gdbarch,
1310 struct bp_target_info *bp_tgt);
c906108c 1311
8181d85f 1312/* Remove a breakpoint at address BP_TGT->placed_address in the target
578d3588 1313 machine. Result is 0 for success, non-zero for error. */
c906108c 1314
d914c394
SS
1315extern int target_remove_breakpoint (struct gdbarch *gdbarch,
1316 struct bp_target_info *bp_tgt);
c906108c
SS
1317
1318/* Initialize the terminal settings we record for the inferior,
1319 before we actually run the inferior. */
1320
1321#define target_terminal_init() \
c42bf286 1322 (*current_target.to_terminal_init) (&current_target)
c906108c
SS
1323
1324/* Put the inferior's terminal settings into effect.
1325 This is preparation for starting or resuming the inferior. */
1326
d9d2d8b6 1327extern void target_terminal_inferior (void);
c906108c
SS
1328
1329/* Put some of our terminal settings into effect,
1330 enough to get proper results from our output,
1331 but do not change into or out of RAW mode
1332 so that no input is discarded.
1333
1334 After doing this, either terminal_ours or terminal_inferior
1335 should be called to get back to a normal state of affairs. */
1336
1337#define target_terminal_ours_for_output() \
2e1e1a19 1338 (*current_target.to_terminal_ours_for_output) (&current_target)
c906108c
SS
1339
1340/* Put our terminal settings into effect.
1341 First record the inferior's terminal settings
1342 so they can be restored properly later. */
1343
1344#define target_terminal_ours() \
e3594fd1 1345 (*current_target.to_terminal_ours) (&current_target)
c906108c 1346
a790ad35
SC
1347/* Save our terminal settings.
1348 This is called from TUI after entering or leaving the curses
1349 mode. Since curses modifies our terminal this call is here
1350 to take this change into account. */
1351
1352#define target_terminal_save_ours() \
ae3bd431 1353 (*current_target.to_terminal_save_ours) (&current_target)
a790ad35 1354
c906108c
SS
1355/* Print useful information about our terminal status, if such a thing
1356 exists. */
1357
1358#define target_terminal_info(arg, from_tty) \
0a4f40a2 1359 (*current_target.to_terminal_info) (&current_target, arg, from_tty)
c906108c
SS
1360
1361/* Kill the inferior process. Make it go away. */
1362
7d85a9c0 1363extern void target_kill (void);
c906108c 1364
0d06e24b
JM
1365/* Load an executable file into the target process. This is expected
1366 to not only bring new code into the target process, but also to
1986bccd
AS
1367 update GDB's symbol tables to match.
1368
1369 ARG contains command-line arguments, to be broken down with
1370 buildargv (). The first non-switch argument is the filename to
1371 load, FILE; the second is a number (as parsed by strtoul (..., ...,
1372 0)), which is an offset to apply to the load addresses of FILE's
1373 sections. The target may define switches, or other non-switch
1374 arguments, as it pleases. */
c906108c 1375
11cf8741 1376extern void target_load (char *arg, int from_tty);
c906108c 1377
39f77062 1378/* Start an inferior process and set inferior_ptid to its pid.
c906108c
SS
1379 EXEC_FILE is the file to run.
1380 ALLARGS is a string containing the arguments to the program.
1381 ENV is the environment vector to pass. Errors reported with error().
1382 On VxWorks and various standalone systems, we ignore exec_file. */
c5aa993b 1383
136d6dae
VP
1384void target_create_inferior (char *exec_file, char *args,
1385 char **env, int from_tty);
c906108c
SS
1386
1387/* Some targets (such as ttrace-based HPUX) don't allow us to request
1388 notification of inferior events such as fork and vork immediately
1389 after the inferior is created. (This because of how gdb gets an
1390 inferior created via invoking a shell to do it. In such a scenario,
1391 if the shell init file has commands in it, the shell will fork and
1392 exec for each of those commands, and we will see each such fork
1393 event. Very bad.)
c5aa993b 1394
0d06e24b
JM
1395 Such targets will supply an appropriate definition for this function. */
1396
39f77062 1397#define target_post_startup_inferior(ptid) \
2e97a79e 1398 (*current_target.to_post_startup_inferior) (&current_target, ptid)
c906108c 1399
0d06e24b
JM
1400/* On some targets, we can catch an inferior fork or vfork event when
1401 it occurs. These functions insert/remove an already-created
77b06cd7
TJB
1402 catchpoint for such events. They return 0 for success, 1 if the
1403 catchpoint type is not supported and -1 for failure. */
c906108c 1404
c906108c 1405#define target_insert_fork_catchpoint(pid) \
a863b201 1406 (*current_target.to_insert_fork_catchpoint) (&current_target, pid)
c906108c
SS
1407
1408#define target_remove_fork_catchpoint(pid) \
973fc227 1409 (*current_target.to_remove_fork_catchpoint) (&current_target, pid)
c906108c
SS
1410
1411#define target_insert_vfork_catchpoint(pid) \
3ecc7da0 1412 (*current_target.to_insert_vfork_catchpoint) (&current_target, pid)
c906108c
SS
1413
1414#define target_remove_vfork_catchpoint(pid) \
e98cf0cd 1415 (*current_target.to_remove_vfork_catchpoint) (&current_target, pid)
c906108c 1416
6604731b
DJ
1417/* If the inferior forks or vforks, this function will be called at
1418 the next resume in order to perform any bookkeeping and fiddling
1419 necessary to continue debugging either the parent or child, as
1420 requested, and releasing the other. Information about the fork
1421 or vfork event is available via get_last_target_status ().
1422 This function returns 1 if the inferior should not be resumed
1423 (i.e. there is another event pending). */
0d06e24b 1424
07107ca6 1425int target_follow_fork (int follow_child, int detach_fork);
c906108c
SS
1426
1427/* On some targets, we can catch an inferior exec event when it
0d06e24b 1428 occurs. These functions insert/remove an already-created
77b06cd7
TJB
1429 catchpoint for such events. They return 0 for success, 1 if the
1430 catchpoint type is not supported and -1 for failure. */
0d06e24b 1431
c906108c 1432#define target_insert_exec_catchpoint(pid) \
ba025e51 1433 (*current_target.to_insert_exec_catchpoint) (&current_target, pid)
c5aa993b 1434
c906108c 1435#define target_remove_exec_catchpoint(pid) \
758e29d2 1436 (*current_target.to_remove_exec_catchpoint) (&current_target, pid)
c906108c 1437
a96d9b2e
SDJ
1438/* Syscall catch.
1439
1440 NEEDED is nonzero if any syscall catch (of any kind) is requested.
1441 If NEEDED is zero, it means the target can disable the mechanism to
1442 catch system calls because there are no more catchpoints of this type.
1443
1444 ANY_COUNT is nonzero if a generic (filter-less) syscall catch is
1445 being requested. In this case, both TABLE_SIZE and TABLE should
1446 be ignored.
1447
1448 TABLE_SIZE is the number of elements in TABLE. It only matters if
1449 ANY_COUNT is zero.
1450
1451 TABLE is an array of ints, indexed by syscall number. An element in
1452 this array is nonzero if that syscall should be caught. This argument
77b06cd7
TJB
1453 only matters if ANY_COUNT is zero.
1454
1455 Return 0 for success, 1 if syscall catchpoints are not supported or -1
1456 for failure. */
a96d9b2e
SDJ
1457
1458#define target_set_syscall_catchpoint(pid, needed, any_count, table_size, table) \
ff214e67
TT
1459 (*current_target.to_set_syscall_catchpoint) (&current_target, \
1460 pid, needed, any_count, \
a96d9b2e
SDJ
1461 table_size, table)
1462
c906108c 1463/* Returns TRUE if PID has exited. And, also sets EXIT_STATUS to the
0d06e24b
JM
1464 exit code of PID, if any. */
1465
c906108c 1466#define target_has_exited(pid,wait_status,exit_status) \
d796e1d6
TT
1467 (*current_target.to_has_exited) (&current_target, \
1468 pid,wait_status,exit_status)
c906108c
SS
1469
1470/* The debugger has completed a blocking wait() call. There is now
2146d243 1471 some process event that must be processed. This function should
c906108c 1472 be defined by those targets that require the debugger to perform
0d06e24b 1473 cleanup or internal state changes in response to the process event. */
c906108c
SS
1474
1475/* The inferior process has died. Do what is right. */
1476
136d6dae 1477void target_mourn_inferior (void);
c906108c
SS
1478
1479/* Does target have enough data to do a run or attach command? */
1480
1481#define target_can_run(t) \
da82bd6b 1482 ((t)->to_can_run) (t)
c906108c 1483
2455069d
UW
1484/* Set list of signals to be handled in the target.
1485
1486 PASS_SIGNALS is an array of size NSIG, indexed by target signal number
2ea28649 1487 (enum gdb_signal). For every signal whose entry in this array is
2455069d
UW
1488 non-zero, the target is allowed -but not required- to skip reporting
1489 arrival of the signal to the GDB core by returning from target_wait,
1490 and to pass the signal directly to the inferior instead.
1491
1492 However, if the target is hardware single-stepping a thread that is
1493 about to receive a signal, it needs to be reported in any case, even
1494 if mentioned in a previous target_pass_signals call. */
c906108c 1495
2455069d 1496extern void target_pass_signals (int nsig, unsigned char *pass_signals);
c906108c 1497
9b224c5e
PA
1498/* Set list of signals the target may pass to the inferior. This
1499 directly maps to the "handle SIGNAL pass/nopass" setting.
1500
1501 PROGRAM_SIGNALS is an array of size NSIG, indexed by target signal
2ea28649 1502 number (enum gdb_signal). For every signal whose entry in this
9b224c5e
PA
1503 array is non-zero, the target is allowed to pass the signal to the
1504 inferior. Signals not present in the array shall be silently
1505 discarded. This does not influence whether to pass signals to the
1506 inferior as a result of a target_resume call. This is useful in
1507 scenarios where the target needs to decide whether to pass or not a
1508 signal to the inferior without GDB core involvement, such as for
1509 example, when detaching (as threads may have been suspended with
1510 pending signals not reported to GDB). */
1511
1512extern void target_program_signals (int nsig, unsigned char *program_signals);
1513
c906108c
SS
1514/* Check to see if a thread is still alive. */
1515
28439f5e 1516extern int target_thread_alive (ptid_t ptid);
c906108c 1517
b83266a0
SS
1518/* Query for new threads and add them to the thread list. */
1519
28439f5e 1520extern void target_find_new_threads (void);
b83266a0 1521
0d06e24b
JM
1522/* Make target stop in a continuable fashion. (For instance, under
1523 Unix, this should act like SIGSTOP). This function is normally
1524 used by GUIs to implement a stop button. */
c906108c 1525
d914c394 1526extern void target_stop (ptid_t ptid);
c906108c 1527
96baa820
JM
1528/* Send the specified COMMAND to the target's monitor
1529 (shell,interpreter) for execution. The result of the query is
0d06e24b 1530 placed in OUTBUF. */
96baa820
JM
1531
1532#define target_rcmd(command, outbuf) \
1aac633b 1533 (*current_target.to_rcmd) (&current_target, command, outbuf)
96baa820
JM
1534
1535
c906108c
SS
1536/* Does the target include all of memory, or only part of it? This
1537 determines whether we look up the target chain for other parts of
1538 memory if this target can't satisfy a request. */
1539
c35b1492
PA
1540extern int target_has_all_memory_1 (void);
1541#define target_has_all_memory target_has_all_memory_1 ()
c906108c
SS
1542
1543/* Does the target include memory? (Dummy targets don't.) */
1544
c35b1492
PA
1545extern int target_has_memory_1 (void);
1546#define target_has_memory target_has_memory_1 ()
c906108c
SS
1547
1548/* Does the target have a stack? (Exec files don't, VxWorks doesn't, until
1549 we start a process.) */
c5aa993b 1550
c35b1492
PA
1551extern int target_has_stack_1 (void);
1552#define target_has_stack target_has_stack_1 ()
c906108c
SS
1553
1554/* Does the target have registers? (Exec files don't.) */
1555
c35b1492
PA
1556extern int target_has_registers_1 (void);
1557#define target_has_registers target_has_registers_1 ()
c906108c
SS
1558
1559/* Does the target have execution? Can we make it jump (through
52bb452f
DJ
1560 hoops), or pop its stack a few times? This means that the current
1561 target is currently executing; for some targets, that's the same as
1562 whether or not the target is capable of execution, but there are
1563 also targets which can be current while not executing. In that
1564 case this will become true after target_create_inferior or
1565 target_attach. */
c906108c 1566
aeaec162
TT
1567extern int target_has_execution_1 (ptid_t);
1568
1569/* Like target_has_execution_1, but always passes inferior_ptid. */
1570
1571extern int target_has_execution_current (void);
1572
1573#define target_has_execution target_has_execution_current ()
c35b1492
PA
1574
1575/* Default implementations for process_stratum targets. Return true
1576 if there's a selected inferior, false otherwise. */
1577
1578extern int default_child_has_all_memory (struct target_ops *ops);
1579extern int default_child_has_memory (struct target_ops *ops);
1580extern int default_child_has_stack (struct target_ops *ops);
1581extern int default_child_has_registers (struct target_ops *ops);
aeaec162
TT
1582extern int default_child_has_execution (struct target_ops *ops,
1583 ptid_t the_ptid);
c906108c
SS
1584
1585/* Can the target support the debugger control of thread execution?
d6350901 1586 Can it lock the thread scheduler? */
c906108c
SS
1587
1588#define target_can_lock_scheduler \
0d06e24b 1589 (current_target.to_has_thread_control & tc_schedlock)
c906108c 1590
c6ebd6cf
VP
1591/* Should the target enable async mode if it is supported? Temporary
1592 cludge until async mode is a strict superset of sync mode. */
1593extern int target_async_permitted;
1594
c378eb4e 1595/* Can the target support asynchronous execution? */
6a109b6b 1596#define target_can_async_p() (current_target.to_can_async_p (&current_target))
6426a772 1597
c378eb4e 1598/* Is the target in asynchronous execution mode? */
6a109b6b 1599#define target_is_async_p() (current_target.to_is_async_p (&current_target))
6426a772 1600
9908b566
VP
1601int target_supports_non_stop (void);
1602
c378eb4e 1603/* Put the target in async mode with the specified callback function. */
0d06e24b 1604#define target_async(CALLBACK,CONTEXT) \
6a109b6b 1605 (current_target.to_async (&current_target, (CALLBACK), (CONTEXT)))
43ff13b4 1606
32231432 1607#define target_execution_direction() \
4c612759 1608 (current_target.to_execution_direction (&current_target))
32231432 1609
c906108c
SS
1610/* Converts a process id to a string. Usually, the string just contains
1611 `process xyz', but on some systems it may contain
1612 `process xyz thread abc'. */
1613
117de6a9 1614extern char *target_pid_to_str (ptid_t ptid);
c906108c 1615
39f77062 1616extern char *normal_pid_to_str (ptid_t ptid);
c5aa993b 1617
0d06e24b
JM
1618/* Return a short string describing extra information about PID,
1619 e.g. "sleeping", "runnable", "running on LWP 3". Null return value
1620 is okay. */
1621
1622#define target_extra_thread_info(TP) \
c15906d8 1623 (current_target.to_extra_thread_info (&current_target, TP))
ed9a39eb 1624
4694da01
TT
1625/* Return the thread's name. A NULL result means that the target
1626 could not determine this thread's name. */
1627
1628extern char *target_thread_name (struct thread_info *);
1629
c906108c
SS
1630/* Attempts to find the pathname of the executable file
1631 that was run to create a specified process.
1632
1633 The process PID must be stopped when this operation is used.
c5aa993b 1634
c906108c
SS
1635 If the executable file cannot be determined, NULL is returned.
1636
1637 Else, a pointer to a character string containing the pathname
1638 is returned. This string should be copied into a buffer by
1639 the client if the string will not be immediately used, or if
0d06e24b 1640 it must persist. */
c906108c
SS
1641
1642#define target_pid_to_exec_file(pid) \
8dd27370 1643 (current_target.to_pid_to_exec_file) (&current_target, pid)
c906108c 1644
3a8f7b07 1645/* See the to_thread_architecture description in struct target_ops. */
c2250ad1
UW
1646
1647#define target_thread_architecture(ptid) \
1648 (current_target.to_thread_architecture (&current_target, ptid))
1649
be4d1333
MS
1650/*
1651 * Iterator function for target memory regions.
1652 * Calls a callback function once for each memory region 'mapped'
1653 * in the child process. Defined as a simple macro rather than
2146d243 1654 * as a function macro so that it can be tested for nullity.
be4d1333
MS
1655 */
1656
1657#define target_find_memory_regions(FUNC, DATA) \
2e73927c 1658 (current_target.to_find_memory_regions) (&current_target, FUNC, DATA)
be4d1333
MS
1659
1660/*
1661 * Compose corefile .note section.
1662 */
1663
1664#define target_make_corefile_notes(BFD, SIZE_P) \
fc6691b2 1665 (current_target.to_make_corefile_notes) (&current_target, BFD, SIZE_P)
be4d1333 1666
6b04bdb7
MS
1667/* Bookmark interfaces. */
1668#define target_get_bookmark(ARGS, FROM_TTY) \
dd0e2830 1669 (current_target.to_get_bookmark) (&current_target, ARGS, FROM_TTY)
6b04bdb7
MS
1670
1671#define target_goto_bookmark(ARG, FROM_TTY) \
3c80fb48 1672 (current_target.to_goto_bookmark) (&current_target, ARG, FROM_TTY)
6b04bdb7 1673
c906108c
SS
1674/* Hardware watchpoint interfaces. */
1675
1676/* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
7f82dfc7 1677 write). Only the INFERIOR_PTID task is being queried. */
c906108c 1678
6a109b6b
TT
1679#define target_stopped_by_watchpoint() \
1680 ((*current_target.to_stopped_by_watchpoint) (&current_target))
7df1a324 1681
74174d2e
UW
1682/* Non-zero if we have steppable watchpoints */
1683
d92524f1 1684#define target_have_steppable_watchpoint \
74174d2e 1685 (current_target.to_have_steppable_watchpoint)
74174d2e 1686
7df1a324
KW
1687/* Non-zero if we have continuable watchpoints */
1688
d92524f1 1689#define target_have_continuable_watchpoint \
7df1a324 1690 (current_target.to_have_continuable_watchpoint)
c906108c 1691
ccaa32c7 1692/* Provide defaults for hardware watchpoint functions. */
c906108c 1693
2146d243 1694/* If the *_hw_beakpoint functions have not been defined
ccaa32c7 1695 elsewhere use the definitions in the target vector. */
c906108c
SS
1696
1697/* Returns non-zero if we can set a hardware watchpoint of type TYPE. TYPE is
1698 one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, or
1699 bp_hardware_breakpoint. CNT is the number of such watchpoints used so far
1700 (including this one?). OTHERTYPE is who knows what... */
1701
d92524f1 1702#define target_can_use_hardware_watchpoint(TYPE,CNT,OTHERTYPE) \
5461485a
TT
1703 (*current_target.to_can_use_hw_breakpoint) (&current_target, \
1704 TYPE, CNT, OTHERTYPE);
c906108c 1705
e09342b5
TJB
1706/* Returns the number of debug registers needed to watch the given
1707 memory region, or zero if not supported. */
1708
d92524f1 1709#define target_region_ok_for_hw_watchpoint(addr, len) \
31568a15
TT
1710 (*current_target.to_region_ok_for_hw_watchpoint) (&current_target, \
1711 addr, len)
e0d24f8d 1712
c906108c 1713
85d721b8
PA
1714/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes.
1715 TYPE is 0 for write, 1 for read, and 2 for read/write accesses.
0cf6dd15 1716 COND is the expression for its condition, or NULL if there's none.
85d721b8
PA
1717 Returns 0 for success, 1 if the watchpoint type is not supported,
1718 -1 for failure. */
c906108c 1719
0cf6dd15 1720#define target_insert_watchpoint(addr, len, type, cond) \
7bb99c53
TT
1721 (*current_target.to_insert_watchpoint) (&current_target, \
1722 addr, len, type, cond)
c906108c 1723
0cf6dd15 1724#define target_remove_watchpoint(addr, len, type, cond) \
11b5219a
TT
1725 (*current_target.to_remove_watchpoint) (&current_target, \
1726 addr, len, type, cond)
c906108c 1727
9c06b0b4
TJB
1728/* Insert a new masked watchpoint at ADDR using the mask MASK.
1729 RW may be hw_read for a read watchpoint, hw_write for a write watchpoint
1730 or hw_access for an access watchpoint. Returns 0 for success, 1 if
1731 masked watchpoints are not supported, -1 for failure. */
1732
1733extern int target_insert_mask_watchpoint (CORE_ADDR, CORE_ADDR, int);
1734
1735/* Remove a masked watchpoint at ADDR with the mask MASK.
1736 RW may be hw_read for a read watchpoint, hw_write for a write watchpoint
1737 or hw_access for an access watchpoint. Returns 0 for success, non-zero
1738 for failure. */
1739
1740extern int target_remove_mask_watchpoint (CORE_ADDR, CORE_ADDR, int);
1741
0000e5cc
PA
1742/* Insert a hardware breakpoint at address BP_TGT->placed_address in
1743 the target machine. Returns 0 for success, and returns non-zero or
1744 throws an error (with a detailed failure reason error code and
1745 message) otherwise. */
1746
a6d9a66e 1747#define target_insert_hw_breakpoint(gdbarch, bp_tgt) \
23a26771
TT
1748 (*current_target.to_insert_hw_breakpoint) (&current_target, \
1749 gdbarch, bp_tgt)
ccaa32c7 1750
a6d9a66e 1751#define target_remove_hw_breakpoint(gdbarch, bp_tgt) \
a64dc96c
TT
1752 (*current_target.to_remove_hw_breakpoint) (&current_target, \
1753 gdbarch, bp_tgt)
c906108c 1754
f1310107
TJB
1755/* Return number of debug registers needed for a ranged breakpoint,
1756 or -1 if ranged breakpoints are not supported. */
1757
1758extern int target_ranged_break_num_registers (void);
1759
7f82dfc7
JK
1760/* Return non-zero if target knows the data address which triggered this
1761 target_stopped_by_watchpoint, in such case place it to *ADDR_P. Only the
1762 INFERIOR_PTID task is being queried. */
1763#define target_stopped_data_address(target, addr_p) \
1764 (*target.to_stopped_data_address) (target, addr_p)
c906108c 1765
9b3e86b1
MR
1766/* Return non-zero if ADDR is within the range of a watchpoint spanning
1767 LENGTH bytes beginning at START. */
5009afc5
AS
1768#define target_watchpoint_addr_within_range(target, addr, start, length) \
1769 (*target.to_watchpoint_addr_within_range) (target, addr, start, length)
1770
0cf6dd15
TJB
1771/* Return non-zero if the target is capable of using hardware to evaluate
1772 the condition expression. In this case, if the condition is false when
1773 the watched memory location changes, execution may continue without the
1774 debugger being notified.
1775
1776 Due to limitations in the hardware implementation, it may be capable of
1777 avoiding triggering the watchpoint in some cases where the condition
1778 expression is false, but may report some false positives as well.
1779 For this reason, GDB will still evaluate the condition expression when
1780 the watchpoint triggers. */
1781#define target_can_accel_watchpoint_condition(addr, len, type, cond) \
c3a5ff89
TT
1782 (*current_target.to_can_accel_watchpoint_condition) (&current_target, \
1783 addr, len, type, cond)
0cf6dd15 1784
9c06b0b4
TJB
1785/* Return number of debug registers needed for a masked watchpoint,
1786 -1 if masked watchpoints are not supported or -2 if the given address
1787 and mask combination cannot be used. */
1788
1789extern int target_masked_watch_num_registers (CORE_ADDR addr, CORE_ADDR mask);
1790
b2175913
MS
1791/* Target can execute in reverse? */
1792#define target_can_execute_reverse \
53e1cfc7 1793 current_target.to_can_execute_reverse (&current_target)
b2175913 1794
424163ea
DJ
1795extern const struct target_desc *target_read_description (struct target_ops *);
1796
0ef643c8 1797#define target_get_ada_task_ptid(lwp, tid) \
1e6b91a4 1798 (*current_target.to_get_ada_task_ptid) (&current_target, lwp,tid)
0ef643c8 1799
08388c79
DE
1800/* Utility implementation of searching memory. */
1801extern int simple_search_memory (struct target_ops* ops,
1802 CORE_ADDR start_addr,
1803 ULONGEST search_space_len,
1804 const gdb_byte *pattern,
1805 ULONGEST pattern_len,
1806 CORE_ADDR *found_addrp);
1807
1808/* Main entry point for searching memory. */
1809extern int target_search_memory (CORE_ADDR start_addr,
1810 ULONGEST search_space_len,
1811 const gdb_byte *pattern,
1812 ULONGEST pattern_len,
1813 CORE_ADDR *found_addrp);
1814
7313baad
UW
1815/* Target file operations. */
1816
1817/* Open FILENAME on the target, using FLAGS and MODE. Return a
1818 target file descriptor, or -1 if an error occurs (and set
1819 *TARGET_ERRNO). */
1820extern int target_fileio_open (const char *filename, int flags, int mode,
1821 int *target_errno);
1822
1823/* Write up to LEN bytes from WRITE_BUF to FD on the target.
1824 Return the number of bytes written, or -1 if an error occurs
1825 (and set *TARGET_ERRNO). */
1826extern int target_fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
1827 ULONGEST offset, int *target_errno);
1828
1829/* Read up to LEN bytes FD on the target into READ_BUF.
1830 Return the number of bytes read, or -1 if an error occurs
1831 (and set *TARGET_ERRNO). */
1832extern int target_fileio_pread (int fd, gdb_byte *read_buf, int len,
1833 ULONGEST offset, int *target_errno);
1834
1835/* Close FD on the target. Return 0, or -1 if an error occurs
1836 (and set *TARGET_ERRNO). */
1837extern int target_fileio_close (int fd, int *target_errno);
1838
1839/* Unlink FILENAME on the target. Return 0, or -1 if an error
1840 occurs (and set *TARGET_ERRNO). */
1841extern int target_fileio_unlink (const char *filename, int *target_errno);
1842
b9e7b9c3
UW
1843/* Read value of symbolic link FILENAME on the target. Return a
1844 null-terminated string allocated via xmalloc, or NULL if an error
1845 occurs (and set *TARGET_ERRNO). */
1846extern char *target_fileio_readlink (const char *filename, int *target_errno);
1847
7313baad
UW
1848/* Read target file FILENAME. The return value will be -1 if the transfer
1849 fails or is not supported; 0 if the object is empty; or the length
1850 of the object otherwise. If a positive value is returned, a
1851 sufficiently large buffer will be allocated using xmalloc and
1852 returned in *BUF_P containing the contents of the object.
1853
1854 This method should be used for objects sufficiently small to store
1855 in a single xmalloc'd buffer, when no fixed bound on the object's
1856 size is known in advance. */
1857extern LONGEST target_fileio_read_alloc (const char *filename,
1858 gdb_byte **buf_p);
1859
1860/* Read target file FILENAME. The result is NUL-terminated and
1861 returned as a string, allocated using xmalloc. If an error occurs
1862 or the transfer is unsupported, NULL is returned. Empty objects
1863 are returned as allocated but empty strings. A warning is issued
1864 if the result contains any embedded NUL bytes. */
1865extern char *target_fileio_read_stralloc (const char *filename);
1866
1867
35b1e5cc
SS
1868/* Tracepoint-related operations. */
1869
1870#define target_trace_init() \
ecae04e1 1871 (*current_target.to_trace_init) (&current_target)
35b1e5cc
SS
1872
1873#define target_download_tracepoint(t) \
548f7808 1874 (*current_target.to_download_tracepoint) (&current_target, t)
35b1e5cc 1875
1e4d1764 1876#define target_can_download_tracepoint() \
a52a8357 1877 (*current_target.to_can_download_tracepoint) (&current_target)
1e4d1764 1878
35b1e5cc 1879#define target_download_trace_state_variable(tsv) \
559d2b81 1880 (*current_target.to_download_trace_state_variable) (&current_target, tsv)
35b1e5cc 1881
d248b706 1882#define target_enable_tracepoint(loc) \
46670d57 1883 (*current_target.to_enable_tracepoint) (&current_target, loc)
d248b706
KY
1884
1885#define target_disable_tracepoint(loc) \
780b049c 1886 (*current_target.to_disable_tracepoint) (&current_target, loc)
d248b706 1887
35b1e5cc 1888#define target_trace_start() \
e2d1aae3 1889 (*current_target.to_trace_start) (&current_target)
35b1e5cc
SS
1890
1891#define target_trace_set_readonly_regions() \
583f9a86 1892 (*current_target.to_trace_set_readonly_regions) (&current_target)
35b1e5cc 1893
00bf0b85 1894#define target_get_trace_status(ts) \
8bd200f1 1895 (*current_target.to_get_trace_status) (&current_target, ts)
35b1e5cc 1896
f196051f 1897#define target_get_tracepoint_status(tp,utp) \
db90e85c 1898 (*current_target.to_get_tracepoint_status) (&current_target, tp, utp)
f196051f 1899
35b1e5cc 1900#define target_trace_stop() \
74499f1b 1901 (*current_target.to_trace_stop) (&current_target)
35b1e5cc
SS
1902
1903#define target_trace_find(type,num,addr1,addr2,tpp) \
bd4c6793
TT
1904 (*current_target.to_trace_find) (&current_target, \
1905 (type), (num), (addr1), (addr2), (tpp))
35b1e5cc
SS
1906
1907#define target_get_trace_state_variable_value(tsv,val) \
4011015b
TT
1908 (*current_target.to_get_trace_state_variable_value) (&current_target, \
1909 (tsv), (val))
35b1e5cc 1910
00bf0b85 1911#define target_save_trace_data(filename) \
dc3decaf 1912 (*current_target.to_save_trace_data) (&current_target, filename)
00bf0b85
SS
1913
1914#define target_upload_tracepoints(utpp) \
ab6617cc 1915 (*current_target.to_upload_tracepoints) (&current_target, utpp)
00bf0b85
SS
1916
1917#define target_upload_trace_state_variables(utsvp) \
181e3713 1918 (*current_target.to_upload_trace_state_variables) (&current_target, utsvp)
00bf0b85
SS
1919
1920#define target_get_raw_trace_data(buf,offset,len) \
88ee6f45
TT
1921 (*current_target.to_get_raw_trace_data) (&current_target, \
1922 (buf), (offset), (len))
00bf0b85 1923
405f8e94 1924#define target_get_min_fast_tracepoint_insn_len() \
0e67620a 1925 (*current_target.to_get_min_fast_tracepoint_insn_len) (&current_target)
405f8e94 1926
35b1e5cc 1927#define target_set_disconnected_tracing(val) \
37b25738 1928 (*current_target.to_set_disconnected_tracing) (&current_target, val)
35b1e5cc 1929
4daf5ac0 1930#define target_set_circular_trace_buffer(val) \
736d5b1f 1931 (*current_target.to_set_circular_trace_buffer) (&current_target, val)
4daf5ac0 1932
f6f899bf 1933#define target_set_trace_buffer_size(val) \
4da384be 1934 (*current_target.to_set_trace_buffer_size) (&current_target, val)
f6f899bf 1935
f196051f 1936#define target_set_trace_notes(user,notes,stopnotes) \
d9e68a2c
TT
1937 (*current_target.to_set_trace_notes) (&current_target, \
1938 (user), (notes), (stopnotes))
f196051f 1939
711e434b 1940#define target_get_tib_address(ptid, addr) \
bd7ae0f5 1941 (*current_target.to_get_tib_address) (&current_target, (ptid), (addr))
711e434b 1942
d914c394 1943#define target_set_permissions() \
c378d69d 1944 (*current_target.to_set_permissions) (&current_target)
d914c394 1945
0fb4aa4b 1946#define target_static_tracepoint_marker_at(addr, marker) \
61fc905d
TT
1947 (*current_target.to_static_tracepoint_marker_at) (&current_target, \
1948 addr, marker)
0fb4aa4b
PA
1949
1950#define target_static_tracepoint_markers_by_strid(marker_id) \
c686c57f
TT
1951 (*current_target.to_static_tracepoint_markers_by_strid) (&current_target, \
1952 marker_id)
0fb4aa4b 1953
b3b9301e 1954#define target_traceframe_info() \
a893e81f 1955 (*current_target.to_traceframe_info) (&current_target)
b3b9301e 1956
d1feda86 1957#define target_use_agent(use) \
2c152180 1958 (*current_target.to_use_agent) (&current_target, use)
d1feda86
YQ
1959
1960#define target_can_use_agent() \
fe38f897 1961 (*current_target.to_can_use_agent) (&current_target)
d1feda86 1962
ced63ec0 1963#define target_augmented_libraries_svr4_read() \
5436ff03 1964 (*current_target.to_augmented_libraries_svr4_read) (&current_target)
ced63ec0 1965
49d03eab
MR
1966/* Command logging facility. */
1967
d9cb0195
TT
1968#define target_log_command(p) \
1969 (*current_target.to_log_command) (&current_target, p)
49d03eab 1970
dc146f7c
VP
1971
1972extern int target_core_of_thread (ptid_t ptid);
1973
ea001bdc
MM
1974/* See to_get_unwinder in struct target_ops. */
1975extern const struct frame_unwind *target_get_unwinder (void);
1976
1977/* See to_get_tailcall_unwinder in struct target_ops. */
1978extern const struct frame_unwind *target_get_tailcall_unwinder (void);
1979
4a5e7a5b
PA
1980/* Verify that the memory in the [MEMADDR, MEMADDR+SIZE) range matches
1981 the contents of [DATA,DATA+SIZE). Returns 1 if there's a match, 0
1982 if there's a mismatch, and -1 if an error is encountered while
1983 reading memory. Throws an error if the functionality is found not
1984 to be supported by the current target. */
1985int target_verify_memory (const gdb_byte *data,
1986 CORE_ADDR memaddr, ULONGEST size);
1987
c906108c
SS
1988/* Routines for maintenance of the target structures...
1989
c22a2b88
TT
1990 complete_target_initialization: Finalize a target_ops by filling in
1991 any fields needed by the target implementation.
1992
c906108c
SS
1993 add_target: Add a target to the list of all possible targets.
1994
1995 push_target: Make this target the top of the stack of currently used
c5aa993b
JM
1996 targets, within its particular stratum of the stack. Result
1997 is 0 if now atop the stack, nonzero if not on top (maybe
1998 should warn user).
c906108c
SS
1999
2000 unpush_target: Remove this from the stack of currently used targets,
c5aa993b 2001 no matter where it is on the list. Returns 0 if no
7fdc1521 2002 change, 1 if removed from stack. */
c906108c 2003
a14ed312 2004extern void add_target (struct target_ops *);
c906108c 2005
9852c492
YQ
2006extern void add_target_with_completer (struct target_ops *t,
2007 completer_ftype *completer);
2008
c22a2b88
TT
2009extern void complete_target_initialization (struct target_ops *t);
2010
b48d48eb
MM
2011/* Adds a command ALIAS for target T and marks it deprecated. This is useful
2012 for maintaining backwards compatibility when renaming targets. */
2013
2014extern void add_deprecated_target_alias (struct target_ops *t, char *alias);
2015
b26a4dcb 2016extern void push_target (struct target_ops *);
c906108c 2017
a14ed312 2018extern int unpush_target (struct target_ops *);
c906108c 2019
fd79ecee
DJ
2020extern void target_pre_inferior (int);
2021
a14ed312 2022extern void target_preopen (int);
c906108c 2023
460014f5
JK
2024/* Does whatever cleanup is required to get rid of all pushed targets. */
2025extern void pop_all_targets (void);
aa76d38d 2026
87ab71f0
PA
2027/* Like pop_all_targets, but pops only targets whose stratum is
2028 strictly above ABOVE_STRATUM. */
460014f5 2029extern void pop_all_targets_above (enum strata above_stratum);
87ab71f0 2030
c0edd9ed
JK
2031extern int target_is_pushed (struct target_ops *t);
2032
9e35dae4
DJ
2033extern CORE_ADDR target_translate_tls_address (struct objfile *objfile,
2034 CORE_ADDR offset);
2035
0542c86d 2036/* Struct target_section maps address ranges to file sections. It is
c906108c
SS
2037 mostly used with BFD files, but can be used without (e.g. for handling
2038 raw disks, or files not in formats handled by BFD). */
2039
0542c86d 2040struct target_section
c5aa993b
JM
2041 {
2042 CORE_ADDR addr; /* Lowest address in section */
2043 CORE_ADDR endaddr; /* 1+highest address in section */
c906108c 2044
7be0c536 2045 struct bfd_section *the_bfd_section;
c906108c 2046
046ac79f
JK
2047 /* The "owner" of the section.
2048 It can be any unique value. It is set by add_target_sections
2049 and used by remove_target_sections.
2050 For example, for executables it is a pointer to exec_bfd and
2051 for shlibs it is the so_list pointer. */
2052 void *owner;
c5aa993b 2053 };
c906108c 2054
07b82ea5
PA
2055/* Holds an array of target sections. Defined by [SECTIONS..SECTIONS_END[. */
2056
2057struct target_section_table
2058{
2059 struct target_section *sections;
2060 struct target_section *sections_end;
2061};
2062
8db32d44 2063/* Return the "section" containing the specified address. */
0542c86d
PA
2064struct target_section *target_section_by_addr (struct target_ops *target,
2065 CORE_ADDR addr);
8db32d44 2066
07b82ea5
PA
2067/* Return the target section table this target (or the targets
2068 beneath) currently manipulate. */
2069
2070extern struct target_section_table *target_get_section_table
2071 (struct target_ops *target);
2072
c906108c
SS
2073/* From mem-break.c */
2074
3db08215 2075extern int memory_remove_breakpoint (struct target_ops *, struct gdbarch *,
3e43a32a 2076 struct bp_target_info *);
c906108c 2077
3db08215 2078extern int memory_insert_breakpoint (struct target_ops *, struct gdbarch *,
3e43a32a 2079 struct bp_target_info *);
c906108c 2080
3e43a32a
MS
2081extern int default_memory_remove_breakpoint (struct gdbarch *,
2082 struct bp_target_info *);
917317f4 2083
3e43a32a
MS
2084extern int default_memory_insert_breakpoint (struct gdbarch *,
2085 struct bp_target_info *);
917317f4 2086
c906108c
SS
2087
2088/* From target.c */
2089
a14ed312 2090extern void initialize_targets (void);
c906108c 2091
c25c4a8b 2092extern void noprocess (void) ATTRIBUTE_NORETURN;
c906108c 2093
8edfe269
DJ
2094extern void target_require_runnable (void);
2095
136d6dae 2096extern void find_default_attach (struct target_ops *, char *, int);
c906108c 2097
136d6dae
VP
2098extern void find_default_create_inferior (struct target_ops *,
2099 char *, char *, char **, int);
c906108c 2100
a14ed312 2101extern struct target_ops *find_target_beneath (struct target_ops *);
ed9a39eb 2102
8b06beed
TT
2103/* Find the target at STRATUM. If no target is at that stratum,
2104 return NULL. */
2105
2106struct target_ops *find_target_at (enum strata stratum);
2107
e0665bc8
PA
2108/* Read OS data object of type TYPE from the target, and return it in
2109 XML format. The result is NUL-terminated and returned as a string,
2110 allocated using xmalloc. If an error occurs or the transfer is
2111 unsupported, NULL is returned. Empty objects are returned as
2112 allocated but empty strings. */
2113
07e059b5
VP
2114extern char *target_get_osdata (const char *type);
2115
c906108c
SS
2116\f
2117/* Stuff that should be shared among the various remote targets. */
2118
2119/* Debugging level. 0 is off, and non-zero values mean to print some debug
2120 information (higher values, more information). */
2121extern int remote_debug;
2122
2123/* Speed in bits per second, or -1 which means don't mess with the speed. */
2124extern int baud_rate;
c378eb4e 2125/* Timeout limit for response from target. */
c906108c
SS
2126extern int remote_timeout;
2127
c906108c 2128\f
c906108c 2129
8defab1a
DJ
2130/* Set the show memory breakpoints mode to show, and installs a cleanup
2131 to restore it back to the current value. */
2132extern struct cleanup *make_show_memory_breakpoints_cleanup (int show);
2133
d914c394
SS
2134extern int may_write_registers;
2135extern int may_write_memory;
2136extern int may_insert_breakpoints;
2137extern int may_insert_tracepoints;
2138extern int may_insert_fast_tracepoints;
2139extern int may_stop;
2140
2141extern void update_target_permissions (void);
2142
c906108c 2143\f
c378eb4e 2144/* Imported from machine dependent code. */
c906108c 2145
c378eb4e 2146/* Blank target vector entries are initialized to target_ignore. */
a14ed312 2147void target_ignore (void);
c906108c 2148
02d27625 2149/* See to_supports_btrace in struct target_ops. */
46917d26
TT
2150#define target_supports_btrace() \
2151 (current_target.to_supports_btrace (&current_target))
02d27625
MM
2152
2153/* See to_enable_btrace in struct target_ops. */
2154extern struct btrace_target_info *target_enable_btrace (ptid_t ptid);
2155
2156/* See to_disable_btrace in struct target_ops. */
2157extern void target_disable_btrace (struct btrace_target_info *btinfo);
2158
2159/* See to_teardown_btrace in struct target_ops. */
2160extern void target_teardown_btrace (struct btrace_target_info *btinfo);
2161
2162/* See to_read_btrace in struct target_ops. */
969c39fb
MM
2163extern enum btrace_error target_read_btrace (VEC (btrace_block_s) **,
2164 struct btrace_target_info *,
2165 enum btrace_read_type);
02d27625 2166
7c1687a9
MM
2167/* See to_stop_recording in struct target_ops. */
2168extern void target_stop_recording (void);
2169
d02ed0bb
MM
2170/* See to_info_record in struct target_ops. */
2171extern void target_info_record (void);
2172
2173/* See to_save_record in struct target_ops. */
85e1311a 2174extern void target_save_record (const char *filename);
d02ed0bb
MM
2175
2176/* Query if the target supports deleting the execution log. */
2177extern int target_supports_delete_record (void);
2178
2179/* See to_delete_record in struct target_ops. */
2180extern void target_delete_record (void);
2181
2182/* See to_record_is_replaying in struct target_ops. */
2183extern int target_record_is_replaying (void);
2184
2185/* See to_goto_record_begin in struct target_ops. */
2186extern void target_goto_record_begin (void);
2187
2188/* See to_goto_record_end in struct target_ops. */
2189extern void target_goto_record_end (void);
2190
2191/* See to_goto_record in struct target_ops. */
2192extern void target_goto_record (ULONGEST insn);
02d27625 2193
67c86d06
MM
2194/* See to_insn_history. */
2195extern void target_insn_history (int size, int flags);
2196
2197/* See to_insn_history_from. */
2198extern void target_insn_history_from (ULONGEST from, int size, int flags);
2199
2200/* See to_insn_history_range. */
2201extern void target_insn_history_range (ULONGEST begin, ULONGEST end, int flags);
2202
15984c13
MM
2203/* See to_call_history. */
2204extern void target_call_history (int size, int flags);
2205
2206/* See to_call_history_from. */
2207extern void target_call_history_from (ULONGEST begin, int size, int flags);
2208
2209/* See to_call_history_range. */
2210extern void target_call_history_range (ULONGEST begin, ULONGEST end, int flags);
2211
118e6252
MM
2212/* See to_decr_pc_after_break. Start searching for the target at OPS. */
2213extern CORE_ADDR forward_target_decr_pc_after_break (struct target_ops *ops,
2214 struct gdbarch *gdbarch);
2215
2216/* See to_decr_pc_after_break. */
2217extern CORE_ADDR target_decr_pc_after_break (struct gdbarch *gdbarch);
2218
c5aa993b 2219#endif /* !defined (TARGET_H) */
This page took 1.589016 seconds and 4 git commands to generate.