OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [gdb/] [target.h] - Blame information for rev 841

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* Interface between GDB and target environments, including files and processes
2
 
3
   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4
   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5
   Free Software Foundation, Inc.
6
 
7
   Contributed by Cygnus Support.  Written by John Gilmore.
8
 
9
   This file is part of GDB.
10
 
11
   This program is free software; you can redistribute it and/or modify
12
   it under the terms of the GNU General Public License as published by
13
   the Free Software Foundation; either version 3 of the License, or
14
   (at your option) any later version.
15
 
16
   This program is distributed in the hope that it will be useful,
17
   but WITHOUT ANY WARRANTY; without even the implied warranty of
18
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
   GNU General Public License for more details.
20
 
21
   You should have received a copy of the GNU General Public License
22
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
 
24
#if !defined (TARGET_H)
25
#define TARGET_H
26
 
27
struct objfile;
28
struct ui_file;
29
struct mem_attrib;
30
struct target_ops;
31
struct bp_target_info;
32
struct regcache;
33
struct target_section_table;
34
struct trace_state_variable;
35
struct trace_status;
36
struct uploaded_tsv;
37
struct uploaded_tp;
38
struct static_tracepoint_marker;
39
 
40
struct expression;
41
 
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
 
47
   A TARGET is an interface between the debugger and a particular
48
   kind of file or process.  Targets can be STACKED in STRATA,
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
 
61
#include "bfd.h"
62
#include "symtab.h"
63
#include "memattr.h"
64
#include "vec.h"
65
#include "gdb_signals.h"
66
 
67
enum strata
68
  {
69
    dummy_stratum,              /* The lowest of the low */
70
    file_stratum,               /* Executable files, etc */
71
    core_stratum,               /* Core dump files */
72
    process_stratum,            /* Executing processes */
73
    thread_stratum,             /* Executing threads */
74
    record_stratum,             /* Support record debugging */
75
    arch_stratum                /* Architecture overrides */
76
  };
77
 
78
enum thread_control_capabilities
79
  {
80
    tc_none = 0,         /* Default: can't control thread execution.  */
81
    tc_schedlock = 1,           /* Can lock the thread scheduler.  */
82
  };
83
 
84
/* Stuff for target_wait.  */
85
 
86
/* Generally, what has the program done?  */
87
enum target_waitkind
88
  {
89
    /* The program has exited.  The exit status is in value.integer.  */
90
    TARGET_WAITKIND_EXITED,
91
 
92
    /* The program has stopped with a signal.  Which signal is in
93
       value.sig.  */
94
    TARGET_WAITKIND_STOPPED,
95
 
96
    /* The program has terminated with a signal.  Which signal is in
97
       value.sig.  */
98
    TARGET_WAITKIND_SIGNALLED,
99
 
100
    /* The program is letting us know that it dynamically loaded something
101
       (e.g. it called load(2) on AIX).  */
102
    TARGET_WAITKIND_LOADED,
103
 
104
    /* The program has forked.  A "related" process' PTID is in
105
       value.related_pid.  I.e., if the child forks, value.related_pid
106
       is the parent's ID.  */
107
 
108
    TARGET_WAITKIND_FORKED,
109
 
110
    /* The program has vforked.  A "related" process's PTID is in
111
       value.related_pid.  */
112
 
113
    TARGET_WAITKIND_VFORKED,
114
 
115
    /* The program has exec'ed a new executable file.  The new file's
116
       pathname is pointed to by value.execd_pathname.  */
117
 
118
    TARGET_WAITKIND_EXECD,
119
 
120
    /* The program had previously vforked, and now the child is done
121
       with the shared memory region, because it exec'ed or exited.
122
       Note that the event is reported to the vfork parent.  This is
123
       only used if GDB did not stay attached to the vfork child,
124
       otherwise, a TARGET_WAITKIND_EXECD or
125
       TARGET_WAITKIND_EXIT|SIGNALLED event associated with the child
126
       has the same effect.  */
127
    TARGET_WAITKIND_VFORK_DONE,
128
 
129
    /* The program has entered or returned from a system call.  On
130
       HP-UX, this is used in the hardware watchpoint implementation.
131
       The syscall's unique integer ID number is in value.syscall_id */
132
 
133
    TARGET_WAITKIND_SYSCALL_ENTRY,
134
    TARGET_WAITKIND_SYSCALL_RETURN,
135
 
136
    /* Nothing happened, but we stopped anyway.  This perhaps should be handled
137
       within target_wait, but I'm not sure target_wait should be resuming the
138
       inferior.  */
139
    TARGET_WAITKIND_SPURIOUS,
140
 
141
    /* An event has occured, but we should wait again.
142
       Remote_async_wait() returns this when there is an event
143
       on the inferior, but the rest of the world is not interested in
144
       it. The inferior has not stopped, but has just sent some output
145
       to the console, for instance. In this case, we want to go back
146
       to the event loop and wait there for another event from the
147
       inferior, rather than being stuck in the remote_async_wait()
148
       function. This way the event loop is responsive to other events,
149
       like for instance the user typing.  */
150
    TARGET_WAITKIND_IGNORE,
151
 
152
    /* The target has run out of history information,
153
       and cannot run backward any further.  */
154
    TARGET_WAITKIND_NO_HISTORY
155
  };
156
 
157
struct target_waitstatus
158
  {
159
    enum target_waitkind kind;
160
 
161
    /* Forked child pid, execd pathname, exit status, signal number or
162
       syscall number.  */
163
    union
164
      {
165
        int integer;
166
        enum target_signal sig;
167
        ptid_t related_pid;
168
        char *execd_pathname;
169
        int syscall_number;
170
      }
171
    value;
172
  };
173
 
174
/* Options that can be passed to target_wait.  */
175
 
176
/* Return immediately if there's no event already queued.  If this
177
   options is not requested, target_wait blocks waiting for an
178
   event.  */
179
#define TARGET_WNOHANG 1
180
 
181
/* The structure below stores information about a system call.
182
   It is basically used in the "catch syscall" command, and in
183
   every function that gives information about a system call.
184
 
185
   It's also good to mention that its fields represent everything
186
   that we currently know about a syscall in GDB.  */
187
struct syscall
188
  {
189
    /* The syscall number.  */
190
    int number;
191
 
192
    /* The syscall name.  */
193
    const char *name;
194
  };
195
 
196
/* Return a pretty printed form of target_waitstatus.
197
   Space for the result is malloc'd, caller must free.  */
198
extern char *target_waitstatus_to_string (const struct target_waitstatus *);
199
 
200
/* Possible types of events that the inferior handler will have to
201
   deal with.  */
202
enum inferior_event_type
203
  {
204
    /* There is a request to quit the inferior, abandon it.  */
205
    INF_QUIT_REQ,
206
    /* Process a normal inferior event which will result in target_wait
207
       being called.  */
208
    INF_REG_EVENT,
209
    /* Deal with an error on the inferior.  */
210
    INF_ERROR,
211
    /* We are called because a timer went off.  */
212
    INF_TIMER,
213
    /* We are called to do stuff after the inferior stops.  */
214
    INF_EXEC_COMPLETE,
215
    /* We are called to do some stuff after the inferior stops, but we
216
       are expected to reenter the proceed() and
217
       handle_inferior_event() functions. This is used only in case of
218
       'step n' like commands.  */
219
    INF_EXEC_CONTINUE
220
  };
221
 
222
/* Target objects which can be transfered using target_read,
223
   target_write, et cetera.  */
224
 
225
enum target_object
226
{
227
  /* AVR target specific transfer.  See "avr-tdep.c" and "remote.c".  */
228
  TARGET_OBJECT_AVR,
229
  /* SPU target specific transfer.  See "spu-tdep.c".  */
230
  TARGET_OBJECT_SPU,
231
  /* Transfer up-to LEN bytes of memory starting at OFFSET.  */
232
  TARGET_OBJECT_MEMORY,
233
  /* Memory, avoiding GDB's data cache and trusting the executable.
234
     Target implementations of to_xfer_partial never need to handle
235
     this object, and most callers should not use it.  */
236
  TARGET_OBJECT_RAW_MEMORY,
237
  /* Memory known to be part of the target's stack.  This is cached even
238
     if it is not in a region marked as such, since it is known to be
239
     "normal" RAM.  */
240
  TARGET_OBJECT_STACK_MEMORY,
241
  /* Kernel Unwind Table.  See "ia64-tdep.c".  */
242
  TARGET_OBJECT_UNWIND_TABLE,
243
  /* Transfer auxilliary vector.  */
244
  TARGET_OBJECT_AUXV,
245
  /* StackGhost cookie.  See "sparc-tdep.c".  */
246
  TARGET_OBJECT_WCOOKIE,
247
  /* Target memory map in XML format.  */
248
  TARGET_OBJECT_MEMORY_MAP,
249
  /* Flash memory.  This object can be used to write contents to
250
     a previously erased flash memory.  Using it without erasing
251
     flash can have unexpected results.  Addresses are physical
252
     address on target, and not relative to flash start.  */
253
  TARGET_OBJECT_FLASH,
254
  /* Available target-specific features, e.g. registers and coprocessors.
255
     See "target-descriptions.c".  ANNEX should never be empty.  */
256
  TARGET_OBJECT_AVAILABLE_FEATURES,
257
  /* Currently loaded libraries, in XML format.  */
258
  TARGET_OBJECT_LIBRARIES,
259
  /* Get OS specific data.  The ANNEX specifies the type (running
260
     processes, etc.).  */
261
  TARGET_OBJECT_OSDATA,
262
  /* Extra signal info.  Usually the contents of `siginfo_t' on unix
263
     platforms.  */
264
  TARGET_OBJECT_SIGNAL_INFO,
265
  /* The list of threads that are being debugged.  */
266
  TARGET_OBJECT_THREADS,
267
  /* Collected static trace data.  */
268
  TARGET_OBJECT_STATIC_TRACE_DATA,
269
  /* Possible future objects: TARGET_OBJECT_FILE, ... */
270
};
271
 
272
/* Enumeration of the kinds of traceframe searches that a target may
273
   be able to perform.  */
274
 
275
enum trace_find_type
276
  {
277
    tfind_number,
278
    tfind_pc,
279
    tfind_tp,
280
    tfind_range,
281
    tfind_outside,
282
  };
283
 
284
typedef struct static_tracepoint_marker *static_tracepoint_marker_p;
285
DEF_VEC_P(static_tracepoint_marker_p);
286
 
287
/* Request that OPS transfer up to LEN 8-bit bytes of the target's
288
   OBJECT.  The OFFSET, for a seekable object, specifies the
289
   starting point.  The ANNEX can be used to provide additional
290
   data-specific information to the target.
291
 
292
   Return the number of bytes actually transfered, or -1 if the
293
   transfer is not supported or otherwise fails.  Return of a positive
294
   value less than LEN indicates that no further transfer is possible.
295
   Unlike the raw to_xfer_partial interface, callers of these
296
   functions do not need to retry partial transfers.  */
297
 
298
extern LONGEST target_read (struct target_ops *ops,
299
                            enum target_object object,
300
                            const char *annex, gdb_byte *buf,
301
                            ULONGEST offset, LONGEST len);
302
 
303
extern LONGEST target_read_until_error (struct target_ops *ops,
304
                                        enum target_object object,
305
                                        const char *annex, gdb_byte *buf,
306
                                        ULONGEST offset, LONGEST len);
307
 
308
extern LONGEST target_write (struct target_ops *ops,
309
                             enum target_object object,
310
                             const char *annex, const gdb_byte *buf,
311
                             ULONGEST offset, LONGEST len);
312
 
313
/* Similar to target_write, except that it also calls PROGRESS with
314
   the number of bytes written and the opaque BATON after every
315
   successful partial write (and before the first write).  This is
316
   useful for progress reporting and user interaction while writing
317
   data.  To abort the transfer, the progress callback can throw an
318
   exception.  */
319
 
320
LONGEST target_write_with_progress (struct target_ops *ops,
321
                                    enum target_object object,
322
                                    const char *annex, const gdb_byte *buf,
323
                                    ULONGEST offset, LONGEST len,
324
                                    void (*progress) (ULONGEST, void *),
325
                                    void *baton);
326
 
327
/* Wrapper to perform a full read of unknown size.  OBJECT/ANNEX will
328
   be read using OPS.  The return value will be -1 if the transfer
329
   fails or is not supported; 0 if the object is empty; or the length
330
   of the object otherwise.  If a positive value is returned, a
331
   sufficiently large buffer will be allocated using xmalloc and
332
   returned in *BUF_P containing the contents of the object.
333
 
334
   This method should be used for objects sufficiently small to store
335
   in a single xmalloc'd buffer, when no fixed bound on the object's
336
   size is known in advance.  Don't try to read TARGET_OBJECT_MEMORY
337
   through this function.  */
338
 
339
extern LONGEST target_read_alloc (struct target_ops *ops,
340
                                  enum target_object object,
341
                                  const char *annex, gdb_byte **buf_p);
342
 
343
/* Read OBJECT/ANNEX using OPS.  The result is NUL-terminated and
344
   returned as a string, allocated using xmalloc.  If an error occurs
345
   or the transfer is unsupported, NULL is returned.  Empty objects
346
   are returned as allocated but empty strings.  A warning is issued
347
   if the result contains any embedded NUL bytes.  */
348
 
349
extern char *target_read_stralloc (struct target_ops *ops,
350
                                   enum target_object object,
351
                                   const char *annex);
352
 
353
/* Wrappers to target read/write that perform memory transfers.  They
354
   throw an error if the memory transfer fails.
355
 
356
   NOTE: cagney/2003-10-23: The naming schema is lifted from
357
   "frame.h".  The parameter order is lifted from get_frame_memory,
358
   which in turn lifted it from read_memory.  */
359
 
360
extern void get_target_memory (struct target_ops *ops, CORE_ADDR addr,
361
                               gdb_byte *buf, LONGEST len);
362
extern ULONGEST get_target_memory_unsigned (struct target_ops *ops,
363
                                            CORE_ADDR addr, int len,
364
                                            enum bfd_endian byte_order);
365
 
366
struct thread_info;             /* fwd decl for parameter list below: */
367
 
368
struct target_ops
369
  {
370
    struct target_ops *beneath; /* To the target under this one.  */
371
    char *to_shortname;         /* Name this target type */
372
    char *to_longname;          /* Name for printing */
373
    char *to_doc;               /* Documentation.  Does not include trailing
374
                                   newline, and starts with a one-line descrip-
375
                                   tion (probably similar to to_longname).  */
376
    /* Per-target scratch pad.  */
377
    void *to_data;
378
    /* The open routine takes the rest of the parameters from the
379
       command, and (if successful) pushes a new target onto the
380
       stack.  Targets should supply this routine, if only to provide
381
       an error message.  */
382
    void (*to_open) (char *, int);
383
    /* Old targets with a static target vector provide "to_close".
384
       New re-entrant targets provide "to_xclose" and that is expected
385
       to xfree everything (including the "struct target_ops").  */
386
    void (*to_xclose) (struct target_ops *targ, int quitting);
387
    void (*to_close) (int);
388
    void (*to_attach) (struct target_ops *ops, char *, int);
389
    void (*to_post_attach) (int);
390
    void (*to_detach) (struct target_ops *ops, char *, int);
391
    void (*to_disconnect) (struct target_ops *, char *, int);
392
    void (*to_resume) (struct target_ops *, ptid_t, int, enum target_signal);
393
    ptid_t (*to_wait) (struct target_ops *,
394
                       ptid_t, struct target_waitstatus *, int);
395
    void (*to_fetch_registers) (struct target_ops *, struct regcache *, int);
396
    void (*to_store_registers) (struct target_ops *, struct regcache *, int);
397
    void (*to_prepare_to_store) (struct regcache *);
398
 
399
    /* Transfer LEN bytes of memory between GDB address MYADDR and
400
       target address MEMADDR.  If WRITE, transfer them to the target, else
401
       transfer them from the target.  TARGET is the target from which we
402
       get this function.
403
 
404
       Return value, N, is one of the following:
405
 
406
 
407
       error which prevented us from doing it (FIXME: What about bfd_error?).
408
 
409
       positive (call it N) means that we have transferred N bytes
410
       starting at MEMADDR.  We might be able to handle more bytes
411
       beyond this length, but no promises.
412
 
413
       negative (call its absolute value N) means that we cannot
414
       transfer right at MEMADDR, but we could transfer at least
415
       something at MEMADDR + N.
416
 
417
       NOTE: cagney/2004-10-01: This has been entirely superseeded by
418
       to_xfer_partial and inferior inheritance.  */
419
 
420
    int (*deprecated_xfer_memory) (CORE_ADDR memaddr, gdb_byte *myaddr,
421
                                   int len, int write,
422
                                   struct mem_attrib *attrib,
423
                                   struct target_ops *target);
424
 
425
    void (*to_files_info) (struct target_ops *);
426
    int (*to_insert_breakpoint) (struct gdbarch *, struct bp_target_info *);
427
    int (*to_remove_breakpoint) (struct gdbarch *, struct bp_target_info *);
428
    int (*to_can_use_hw_breakpoint) (int, int, int);
429
    int (*to_insert_hw_breakpoint) (struct gdbarch *, struct bp_target_info *);
430
    int (*to_remove_hw_breakpoint) (struct gdbarch *, struct bp_target_info *);
431
 
432
    /* Documentation of what the two routines below are expected to do is
433
       provided with the corresponding target_* macros.  */
434
    int (*to_remove_watchpoint) (CORE_ADDR, int, int, struct expression *);
435
    int (*to_insert_watchpoint) (CORE_ADDR, int, int, struct expression *);
436
 
437
    int (*to_stopped_by_watchpoint) (void);
438
    int to_have_steppable_watchpoint;
439
    int to_have_continuable_watchpoint;
440
    int (*to_stopped_data_address) (struct target_ops *, CORE_ADDR *);
441
    int (*to_watchpoint_addr_within_range) (struct target_ops *,
442
                                            CORE_ADDR, CORE_ADDR, int);
443
    int (*to_region_ok_for_hw_watchpoint) (CORE_ADDR, int);
444
    int (*to_can_accel_watchpoint_condition) (CORE_ADDR, int, int,
445
                                              struct expression *);
446
    void (*to_terminal_init) (void);
447
    void (*to_terminal_inferior) (void);
448
    void (*to_terminal_ours_for_output) (void);
449
    void (*to_terminal_ours) (void);
450
    void (*to_terminal_save_ours) (void);
451
    void (*to_terminal_info) (char *, int);
452
    void (*to_kill) (struct target_ops *);
453
    void (*to_load) (char *, int);
454
    int (*to_lookup_symbol) (char *, CORE_ADDR *);
455
    void (*to_create_inferior) (struct target_ops *,
456
                                char *, char *, char **, int);
457
    void (*to_post_startup_inferior) (ptid_t);
458
    void (*to_acknowledge_created_inferior) (int);
459
    void (*to_insert_fork_catchpoint) (int);
460
    int (*to_remove_fork_catchpoint) (int);
461
    void (*to_insert_vfork_catchpoint) (int);
462
    int (*to_remove_vfork_catchpoint) (int);
463
    int (*to_follow_fork) (struct target_ops *, int);
464
    void (*to_insert_exec_catchpoint) (int);
465
    int (*to_remove_exec_catchpoint) (int);
466
    int (*to_set_syscall_catchpoint) (int, int, int, int, int *);
467
    int (*to_has_exited) (int, int, int *);
468
    void (*to_mourn_inferior) (struct target_ops *);
469
    int (*to_can_run) (void);
470
    void (*to_notice_signals) (ptid_t ptid);
471
    int (*to_thread_alive) (struct target_ops *, ptid_t ptid);
472
    void (*to_find_new_threads) (struct target_ops *);
473
    char *(*to_pid_to_str) (struct target_ops *, ptid_t);
474
    char *(*to_extra_thread_info) (struct thread_info *);
475
    void (*to_stop) (ptid_t);
476
    void (*to_rcmd) (char *command, struct ui_file *output);
477
    char *(*to_pid_to_exec_file) (int pid);
478
    void (*to_log_command) (const char *);
479
    struct target_section_table *(*to_get_section_table) (struct target_ops *);
480
    enum strata to_stratum;
481
    int (*to_has_all_memory) (struct target_ops *);
482
    int (*to_has_memory) (struct target_ops *);
483
    int (*to_has_stack) (struct target_ops *);
484
    int (*to_has_registers) (struct target_ops *);
485
    int (*to_has_execution) (struct target_ops *);
486
    int to_has_thread_control;  /* control thread execution */
487
    int to_attach_no_wait;
488
    /* ASYNC target controls */
489
    int (*to_can_async_p) (void);
490
    int (*to_is_async_p) (void);
491
    void (*to_async) (void (*) (enum inferior_event_type, void *), void *);
492
    int (*to_async_mask) (int);
493
    int (*to_supports_non_stop) (void);
494
    /* find_memory_regions support method for gcore */
495
    int (*to_find_memory_regions) (int (*) (CORE_ADDR,
496
                                            unsigned long,
497
                                            int, int, int,
498
                                            void *),
499
                                   void *);
500
    /* make_corefile_notes support method for gcore */
501
    char * (*to_make_corefile_notes) (bfd *, int *);
502
    /* get_bookmark support method for bookmarks */
503
    gdb_byte * (*to_get_bookmark) (char *, int);
504
    /* goto_bookmark support method for bookmarks */
505
    void (*to_goto_bookmark) (gdb_byte *, int);
506
    /* Return the thread-local address at OFFSET in the
507
       thread-local storage for the thread PTID and the shared library
508
       or executable file given by OBJFILE.  If that block of
509
       thread-local storage hasn't been allocated yet, this function
510
       may return an error.  */
511
    CORE_ADDR (*to_get_thread_local_address) (struct target_ops *ops,
512
                                              ptid_t ptid,
513
                                              CORE_ADDR load_module_addr,
514
                                              CORE_ADDR offset);
515
 
516
    /* Request that OPS transfer up to LEN 8-bit bytes of the target's
517
       OBJECT.  The OFFSET, for a seekable object, specifies the
518
       starting point.  The ANNEX can be used to provide additional
519
       data-specific information to the target.
520
 
521
       Return the number of bytes actually transfered, zero when no
522
       further transfer is possible, and -1 when the transfer is not
523
       supported.  Return of a positive value smaller than LEN does
524
       not indicate the end of the object, only the end of the
525
       transfer; higher level code should continue transferring if
526
       desired.  This is handled in target.c.
527
 
528
       The interface does not support a "retry" mechanism.  Instead it
529
       assumes that at least one byte will be transfered on each
530
       successful call.
531
 
532
       NOTE: cagney/2003-10-17: The current interface can lead to
533
       fragmented transfers.  Lower target levels should not implement
534
       hacks, such as enlarging the transfer, in an attempt to
535
       compensate for this.  Instead, the target stack should be
536
       extended so that it implements supply/collect methods and a
537
       look-aside object cache.  With that available, the lowest
538
       target can safely and freely "push" data up the stack.
539
 
540
       See target_read and target_write for more information.  One,
541
       and only one, of readbuf or writebuf must be non-NULL.  */
542
 
543
    LONGEST (*to_xfer_partial) (struct target_ops *ops,
544
                                enum target_object object, const char *annex,
545
                                gdb_byte *readbuf, const gdb_byte *writebuf,
546
                                ULONGEST offset, LONGEST len);
547
 
548
    /* Returns the memory map for the target.  A return value of NULL
549
       means that no memory map is available.  If a memory address
550
       does not fall within any returned regions, it's assumed to be
551
       RAM.  The returned memory regions should not overlap.
552
 
553
       The order of regions does not matter; target_memory_map will
554
       sort regions by starting address. For that reason, this
555
       function should not be called directly except via
556
       target_memory_map.
557
 
558
       This method should not cache data; if the memory map could
559
       change unexpectedly, it should be invalidated, and higher
560
       layers will re-fetch it.  */
561
    VEC(mem_region_s) *(*to_memory_map) (struct target_ops *);
562
 
563
    /* Erases the region of flash memory starting at ADDRESS, of
564
       length LENGTH.
565
 
566
       Precondition: both ADDRESS and ADDRESS+LENGTH should be aligned
567
       on flash block boundaries, as reported by 'to_memory_map'.  */
568
    void (*to_flash_erase) (struct target_ops *,
569
                           ULONGEST address, LONGEST length);
570
 
571
    /* Finishes a flash memory write sequence.  After this operation
572
       all flash memory should be available for writing and the result
573
       of reading from areas written by 'to_flash_write' should be
574
       equal to what was written.  */
575
    void (*to_flash_done) (struct target_ops *);
576
 
577
    /* Describe the architecture-specific features of this target.
578
       Returns the description found, or NULL if no description
579
       was available.  */
580
    const struct target_desc *(*to_read_description) (struct target_ops *ops);
581
 
582
    /* Build the PTID of the thread on which a given task is running,
583
       based on LWP and THREAD.  These values are extracted from the
584
       task Private_Data section of the Ada Task Control Block, and
585
       their interpretation depends on the target.  */
586
    ptid_t (*to_get_ada_task_ptid) (long lwp, long thread);
587
 
588
    /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
589
       Return 0 if *READPTR is already at the end of the buffer.
590
       Return -1 if there is insufficient buffer for a whole entry.
591
       Return 1 if an entry was read into *TYPEP and *VALP.  */
592
    int (*to_auxv_parse) (struct target_ops *ops, gdb_byte **readptr,
593
                         gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp);
594
 
595
    /* Search SEARCH_SPACE_LEN bytes beginning at START_ADDR for the
596
       sequence of bytes in PATTERN with length PATTERN_LEN.
597
 
598
       The result is 1 if found, 0 if not found, and -1 if there was an error
599
       requiring halting of the search (e.g. memory read error).
600
       If the pattern is found the address is recorded in FOUND_ADDRP.  */
601
    int (*to_search_memory) (struct target_ops *ops,
602
                             CORE_ADDR start_addr, ULONGEST search_space_len,
603
                             const gdb_byte *pattern, ULONGEST pattern_len,
604
                             CORE_ADDR *found_addrp);
605
 
606
    /* Can target execute in reverse?  */
607
    int (*to_can_execute_reverse) (void);
608
 
609
    /* Does this target support debugging multiple processes
610
       simultaneously?  */
611
    int (*to_supports_multi_process) (void);
612
 
613
    /* Determine current architecture of thread PTID.
614
 
615
       The target is supposed to determine the architecture of the code where
616
       the target is currently stopped at (on Cell, if a target is in spu_run,
617
       to_thread_architecture would return SPU, otherwise PPC32 or PPC64).
618
       This is architecture used to perform decr_pc_after_break adjustment,
619
       and also determines the frame architecture of the innermost frame.
620
       ptrace operations need to operate according to target_gdbarch.
621
 
622
       The default implementation always returns target_gdbarch.  */
623
    struct gdbarch *(*to_thread_architecture) (struct target_ops *, ptid_t);
624
 
625
    /* Determine current address space of thread PTID.
626
 
627
       The default implementation always returns the inferior's
628
       address space.  */
629
    struct address_space *(*to_thread_address_space) (struct target_ops *,
630
                                                      ptid_t);
631
 
632
    /* Tracepoint-related operations.  */
633
 
634
    /* Prepare the target for a tracing run.  */
635
    void (*to_trace_init) (void);
636
 
637
    /* Send full details of a tracepoint to the target.  */
638
    void (*to_download_tracepoint) (struct breakpoint *t);
639
 
640
    /* Send full details of a trace state variable to the target.  */
641
    void (*to_download_trace_state_variable) (struct trace_state_variable *tsv);
642
 
643
    /* Inform the target info of memory regions that are readonly
644
       (such as text sections), and so it should return data from
645
       those rather than look in the trace buffer.  */
646
    void (*to_trace_set_readonly_regions) (void);
647
 
648
    /* Start a trace run.  */
649
    void (*to_trace_start) (void);
650
 
651
    /* Get the current status of a tracing run.  */
652
    int (*to_get_trace_status) (struct trace_status *ts);
653
 
654
    /* Stop a trace run.  */
655
    void (*to_trace_stop) (void);
656
 
657
   /* Ask the target to find a trace frame of the given type TYPE,
658
      using NUM, ADDR1, and ADDR2 as search parameters.  Returns the
659
      number of the trace frame, and also the tracepoint number at
660
      TPP.  If no trace frame matches, return -1. May throw if the
661
      operation fails.  */
662
    int (*to_trace_find) (enum trace_find_type type, int num,
663
                          ULONGEST addr1, ULONGEST addr2, int *tpp);
664
 
665
    /* Get the value of the trace state variable number TSV, returning
666
       1 if the value is known and writing the value itself into the
667
       location pointed to by VAL, else returning 0.  */
668
    int (*to_get_trace_state_variable_value) (int tsv, LONGEST *val);
669
 
670
    int (*to_save_trace_data) (const char *filename);
671
 
672
    int (*to_upload_tracepoints) (struct uploaded_tp **utpp);
673
 
674
    int (*to_upload_trace_state_variables) (struct uploaded_tsv **utsvp);
675
 
676
    LONGEST (*to_get_raw_trace_data) (gdb_byte *buf,
677
                                      ULONGEST offset, LONGEST len);
678
 
679
    /* Set the target's tracing behavior in response to unexpected
680
       disconnection - set VAL to 1 to keep tracing, 0 to stop.  */
681
    void (*to_set_disconnected_tracing) (int val);
682
    void (*to_set_circular_trace_buffer) (int val);
683
 
684
    /* Return the processor core that thread PTID was last seen on.
685
       This information is updated only when:
686
       - update_thread_list is called
687
       - thread stops
688
       If the core cannot be determined -- either for the specified thread, or
689
       right now, or in this debug session, or for this target -- return -1.  */
690
    int (*to_core_of_thread) (struct target_ops *, ptid_t ptid);
691
 
692
    /* Verify that the memory in the [MEMADDR, MEMADDR+SIZE) range
693
       matches the contents of [DATA,DATA+SIZE).  Returns 1 if there's
694
       a match, 0 if there's a mismatch, and -1 if an error is
695
       encountered while reading memory.  */
696
    int (*to_verify_memory) (struct target_ops *, const gdb_byte *data,
697
                             CORE_ADDR memaddr, ULONGEST size);
698
 
699
    /* Return the address of the start of the Thread Information Block
700
       a Windows OS specific feature.  */
701
    int (*to_get_tib_address) (ptid_t ptid, CORE_ADDR *addr);
702
 
703
    /* Send the new settings of write permission variables.  */
704
    void (*to_set_permissions) (void);
705
 
706
    /* Look for a static tracepoint marker at ADDR, and fill in MARKER
707
       with its details.  Return 1 on success, 0 on failure.  */
708
    int (*to_static_tracepoint_marker_at) (CORE_ADDR,
709
                                           struct static_tracepoint_marker *marker);
710
 
711
    /* Return a vector of all tracepoints markers string id ID, or all
712
       markers if ID is NULL.  */
713
    VEC(static_tracepoint_marker_p) *(*to_static_tracepoint_markers_by_strid)
714
      (const char *id);
715
 
716
    int to_magic;
717
    /* Need sub-structure for target machine related rather than comm related?
718
     */
719
  };
720
 
721
/* Magic number for checking ops size.  If a struct doesn't end with this
722
   number, somebody changed the declaration but didn't change all the
723
   places that initialize one.  */
724
 
725
#define OPS_MAGIC       3840
726
 
727
/* The ops structure for our "current" target process.  This should
728
   never be NULL.  If there is no target, it points to the dummy_target.  */
729
 
730
extern struct target_ops current_target;
731
 
732
/* Define easy words for doing these operations on our current target.  */
733
 
734
#define target_shortname        (current_target.to_shortname)
735
#define target_longname         (current_target.to_longname)
736
 
737
/* Does whatever cleanup is required for a target that we are no
738
   longer going to be calling.  QUITTING indicates that GDB is exiting
739
   and should not get hung on an error (otherwise it is important to
740
   perform clean termination, even if it takes a while).  This routine
741
   is automatically always called when popping the target off the
742
   target stack (to_beneath is undefined).  Closing file descriptors
743
   and freeing all memory allocated memory are typical things it
744
   should do.  */
745
 
746
void target_close (struct target_ops *targ, int quitting);
747
 
748
/* Attaches to a process on the target side.  Arguments are as passed
749
   to the `attach' command by the user.  This routine can be called
750
   when the target is not on the target-stack, if the target_can_run
751
   routine returns 1; in that case, it must push itself onto the stack.
752
   Upon exit, the target should be ready for normal operations, and
753
   should be ready to deliver the status of the process immediately
754
   (without waiting) to an upcoming target_wait call.  */
755
 
756
void target_attach (char *, int);
757
 
758
/* Some targets don't generate traps when attaching to the inferior,
759
   or their target_attach implementation takes care of the waiting.
760
   These targets must set to_attach_no_wait.  */
761
 
762
#define target_attach_no_wait \
763
     (current_target.to_attach_no_wait)
764
 
765
/* The target_attach operation places a process under debugger control,
766
   and stops the process.
767
 
768
   This operation provides a target-specific hook that allows the
769
   necessary bookkeeping to be performed after an attach completes.  */
770
#define target_post_attach(pid) \
771
     (*current_target.to_post_attach) (pid)
772
 
773
/* Takes a program previously attached to and detaches it.
774
   The program may resume execution (some targets do, some don't) and will
775
   no longer stop on signals, etc.  We better not have left any breakpoints
776
   in the program or it'll die when it hits one.  ARGS is arguments
777
   typed by the user (e.g. a signal to send the process).  FROM_TTY
778
   says whether to be verbose or not.  */
779
 
780
extern void target_detach (char *, int);
781
 
782
/* Disconnect from the current target without resuming it (leaving it
783
   waiting for a debugger).  */
784
 
785
extern void target_disconnect (char *, int);
786
 
787
/* Resume execution of the target process PTID.  STEP says whether to
788
   single-step or to run free; SIGGNAL is the signal to be given to
789
   the target, or TARGET_SIGNAL_0 for no signal.  The caller may not
790
   pass TARGET_SIGNAL_DEFAULT.  */
791
 
792
extern void target_resume (ptid_t ptid, int step, enum target_signal signal);
793
 
794
/* Wait for process pid to do something.  PTID = -1 to wait for any
795
   pid to do something.  Return pid of child, or -1 in case of error;
796
   store status through argument pointer STATUS.  Note that it is
797
   _NOT_ OK to throw_exception() out of target_wait() without popping
798
   the debugging target from the stack; GDB isn't prepared to get back
799
   to the prompt with a debugging target but without the frame cache,
800
   stop_pc, etc., set up.  OPTIONS is a bitwise OR of TARGET_W*
801
   options.  */
802
 
803
extern ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status,
804
                           int options);
805
 
806
/* Fetch at least register REGNO, or all regs if regno == -1.  No result.  */
807
 
808
extern void target_fetch_registers (struct regcache *regcache, int regno);
809
 
810
/* Store at least register REGNO, or all regs if REGNO == -1.
811
   It can store as many registers as it wants to, so target_prepare_to_store
812
   must have been previously called.  Calls error() if there are problems.  */
813
 
814
extern void target_store_registers (struct regcache *regcache, int regs);
815
 
816
/* Get ready to modify the registers array.  On machines which store
817
   individual registers, this doesn't need to do anything.  On machines
818
   which store all the registers in one fell swoop, this makes sure
819
   that REGISTERS contains all the registers from the program being
820
   debugged.  */
821
 
822
#define target_prepare_to_store(regcache)       \
823
     (*current_target.to_prepare_to_store) (regcache)
824
 
825
/* Determine current address space of thread PTID.  */
826
 
827
struct address_space *target_thread_address_space (ptid_t);
828
 
829
/* Returns true if this target can debug multiple processes
830
   simultaneously.  */
831
 
832
#define target_supports_multi_process() \
833
     (*current_target.to_supports_multi_process) ()
834
 
835
/* Invalidate all target dcaches.  */
836
extern void target_dcache_invalidate (void);
837
 
838
extern int target_read_string (CORE_ADDR, char **, int, int *);
839
 
840
extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
841
 
842
extern int target_read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
843
 
844
extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
845
                                int len);
846
 
847
/* Fetches the target's memory map.  If one is found it is sorted
848
   and returned, after some consistency checking.  Otherwise, NULL
849
   is returned.  */
850
VEC(mem_region_s) *target_memory_map (void);
851
 
852
/* Erase the specified flash region.  */
853
void target_flash_erase (ULONGEST address, LONGEST length);
854
 
855
/* Finish a sequence of flash operations.  */
856
void target_flash_done (void);
857
 
858
/* Describes a request for a memory write operation.  */
859
struct memory_write_request
860
  {
861
    /* Begining address that must be written. */
862
    ULONGEST begin;
863
    /* Past-the-end address. */
864
    ULONGEST end;
865
    /* The data to write. */
866
    gdb_byte *data;
867
    /* A callback baton for progress reporting for this request.  */
868
    void *baton;
869
  };
870
typedef struct memory_write_request memory_write_request_s;
871
DEF_VEC_O(memory_write_request_s);
872
 
873
/* Enumeration specifying different flash preservation behaviour.  */
874
enum flash_preserve_mode
875
  {
876
    flash_preserve,
877
    flash_discard
878
  };
879
 
880
/* Write several memory blocks at once.  This version can be more
881
   efficient than making several calls to target_write_memory, in
882
   particular because it can optimize accesses to flash memory.
883
 
884
   Moreover, this is currently the only memory access function in gdb
885
   that supports writing to flash memory, and it should be used for
886
   all cases where access to flash memory is desirable.
887
 
888
   REQUESTS is the vector (see vec.h) of memory_write_request.
889
   PRESERVE_FLASH_P indicates what to do with blocks which must be
890
     erased, but not completely rewritten.
891
   PROGRESS_CB is a function that will be periodically called to provide
892
     feedback to user.  It will be called with the baton corresponding
893
     to the request currently being written.  It may also be called
894
     with a NULL baton, when preserved flash sectors are being rewritten.
895
 
896
   The function returns 0 on success, and error otherwise.  */
897
int target_write_memory_blocks (VEC(memory_write_request_s) *requests,
898
                                enum flash_preserve_mode preserve_flash_p,
899
                                void (*progress_cb) (ULONGEST, void *));
900
 
901
/* From infrun.c.  */
902
 
903
extern int inferior_has_forked (ptid_t pid, ptid_t *child_pid);
904
 
905
extern int inferior_has_vforked (ptid_t pid, ptid_t *child_pid);
906
 
907
extern int inferior_has_execd (ptid_t pid, char **execd_pathname);
908
 
909
extern int inferior_has_called_syscall (ptid_t pid, int *syscall_number);
910
 
911
/* Print a line about the current target.  */
912
 
913
#define target_files_info()     \
914
     (*current_target.to_files_info) (&current_target)
915
 
916
/* Insert a breakpoint at address BP_TGT->placed_address in the target
917
   machine.  Result is 0 for success, or an errno value.  */
918
 
919
extern int target_insert_breakpoint (struct gdbarch *gdbarch,
920
                                     struct bp_target_info *bp_tgt);
921
 
922
/* Remove a breakpoint at address BP_TGT->placed_address in the target
923
   machine.  Result is 0 for success, or an errno value.  */
924
 
925
extern int target_remove_breakpoint (struct gdbarch *gdbarch,
926
                                     struct bp_target_info *bp_tgt);
927
 
928
/* Initialize the terminal settings we record for the inferior,
929
   before we actually run the inferior.  */
930
 
931
#define target_terminal_init() \
932
     (*current_target.to_terminal_init) ()
933
 
934
/* Put the inferior's terminal settings into effect.
935
   This is preparation for starting or resuming the inferior.  */
936
 
937
extern void target_terminal_inferior (void);
938
 
939
/* Put some of our terminal settings into effect,
940
   enough to get proper results from our output,
941
   but do not change into or out of RAW mode
942
   so that no input is discarded.
943
 
944
   After doing this, either terminal_ours or terminal_inferior
945
   should be called to get back to a normal state of affairs.  */
946
 
947
#define target_terminal_ours_for_output() \
948
     (*current_target.to_terminal_ours_for_output) ()
949
 
950
/* Put our terminal settings into effect.
951
   First record the inferior's terminal settings
952
   so they can be restored properly later.  */
953
 
954
#define target_terminal_ours() \
955
     (*current_target.to_terminal_ours) ()
956
 
957
/* Save our terminal settings.
958
   This is called from TUI after entering or leaving the curses
959
   mode.  Since curses modifies our terminal this call is here
960
   to take this change into account.  */
961
 
962
#define target_terminal_save_ours() \
963
     (*current_target.to_terminal_save_ours) ()
964
 
965
/* Print useful information about our terminal status, if such a thing
966
   exists.  */
967
 
968
#define target_terminal_info(arg, from_tty) \
969
     (*current_target.to_terminal_info) (arg, from_tty)
970
 
971
/* Kill the inferior process.   Make it go away.  */
972
 
973
extern void target_kill (void);
974
 
975
/* Load an executable file into the target process.  This is expected
976
   to not only bring new code into the target process, but also to
977
   update GDB's symbol tables to match.
978
 
979
   ARG contains command-line arguments, to be broken down with
980
   buildargv ().  The first non-switch argument is the filename to
981
   load, FILE; the second is a number (as parsed by strtoul (..., ...,
982
   0)), which is an offset to apply to the load addresses of FILE's
983
   sections.  The target may define switches, or other non-switch
984
   arguments, as it pleases.  */
985
 
986
extern void target_load (char *arg, int from_tty);
987
 
988
/* Look up a symbol in the target's symbol table.  NAME is the symbol
989
   name.  ADDRP is a CORE_ADDR * pointing to where the value of the
990
   symbol should be returned.  The result is 0 if successful, nonzero
991
   if the symbol does not exist in the target environment.  This
992
   function should not call error() if communication with the target
993
   is interrupted, since it is called from symbol reading, but should
994
   return nonzero, possibly doing a complain().  */
995
 
996
#define target_lookup_symbol(name, addrp) \
997
     (*current_target.to_lookup_symbol) (name, addrp)
998
 
999
/* Start an inferior process and set inferior_ptid to its pid.
1000
   EXEC_FILE is the file to run.
1001
   ALLARGS is a string containing the arguments to the program.
1002
   ENV is the environment vector to pass.  Errors reported with error().
1003
   On VxWorks and various standalone systems, we ignore exec_file.  */
1004
 
1005
void target_create_inferior (char *exec_file, char *args,
1006
                             char **env, int from_tty);
1007
 
1008
/* Some targets (such as ttrace-based HPUX) don't allow us to request
1009
   notification of inferior events such as fork and vork immediately
1010
   after the inferior is created.  (This because of how gdb gets an
1011
   inferior created via invoking a shell to do it.  In such a scenario,
1012
   if the shell init file has commands in it, the shell will fork and
1013
   exec for each of those commands, and we will see each such fork
1014
   event.  Very bad.)
1015
 
1016
   Such targets will supply an appropriate definition for this function.  */
1017
 
1018
#define target_post_startup_inferior(ptid) \
1019
     (*current_target.to_post_startup_inferior) (ptid)
1020
 
1021
/* On some targets, the sequence of starting up an inferior requires
1022
   some synchronization between gdb and the new inferior process, PID.  */
1023
 
1024
#define target_acknowledge_created_inferior(pid) \
1025
     (*current_target.to_acknowledge_created_inferior) (pid)
1026
 
1027
/* On some targets, we can catch an inferior fork or vfork event when
1028
   it occurs.  These functions insert/remove an already-created
1029
   catchpoint for such events.  */
1030
 
1031
#define target_insert_fork_catchpoint(pid) \
1032
     (*current_target.to_insert_fork_catchpoint) (pid)
1033
 
1034
#define target_remove_fork_catchpoint(pid) \
1035
     (*current_target.to_remove_fork_catchpoint) (pid)
1036
 
1037
#define target_insert_vfork_catchpoint(pid) \
1038
     (*current_target.to_insert_vfork_catchpoint) (pid)
1039
 
1040
#define target_remove_vfork_catchpoint(pid) \
1041
     (*current_target.to_remove_vfork_catchpoint) (pid)
1042
 
1043
/* If the inferior forks or vforks, this function will be called at
1044
   the next resume in order to perform any bookkeeping and fiddling
1045
   necessary to continue debugging either the parent or child, as
1046
   requested, and releasing the other.  Information about the fork
1047
   or vfork event is available via get_last_target_status ().
1048
   This function returns 1 if the inferior should not be resumed
1049
   (i.e. there is another event pending).  */
1050
 
1051
int target_follow_fork (int follow_child);
1052
 
1053
/* On some targets, we can catch an inferior exec event when it
1054
   occurs.  These functions insert/remove an already-created
1055
   catchpoint for such events.  */
1056
 
1057
#define target_insert_exec_catchpoint(pid) \
1058
     (*current_target.to_insert_exec_catchpoint) (pid)
1059
 
1060
#define target_remove_exec_catchpoint(pid) \
1061
     (*current_target.to_remove_exec_catchpoint) (pid)
1062
 
1063
/* Syscall catch.
1064
 
1065
   NEEDED is nonzero if any syscall catch (of any kind) is requested.
1066
   If NEEDED is zero, it means the target can disable the mechanism to
1067
   catch system calls because there are no more catchpoints of this type.
1068
 
1069
   ANY_COUNT is nonzero if a generic (filter-less) syscall catch is
1070
   being requested.  In this case, both TABLE_SIZE and TABLE should
1071
   be ignored.
1072
 
1073
   TABLE_SIZE is the number of elements in TABLE.  It only matters if
1074
   ANY_COUNT is zero.
1075
 
1076
   TABLE is an array of ints, indexed by syscall number.  An element in
1077
   this array is nonzero if that syscall should be caught.  This argument
1078
   only matters if ANY_COUNT is zero.  */
1079
 
1080
#define target_set_syscall_catchpoint(pid, needed, any_count, table_size, table) \
1081
     (*current_target.to_set_syscall_catchpoint) (pid, needed, any_count, \
1082
                                                  table_size, table)
1083
 
1084
/* Returns TRUE if PID has exited.  And, also sets EXIT_STATUS to the
1085
   exit code of PID, if any.  */
1086
 
1087
#define target_has_exited(pid,wait_status,exit_status) \
1088
     (*current_target.to_has_exited) (pid,wait_status,exit_status)
1089
 
1090
/* The debugger has completed a blocking wait() call.  There is now
1091
   some process event that must be processed.  This function should
1092
   be defined by those targets that require the debugger to perform
1093
   cleanup or internal state changes in response to the process event.  */
1094
 
1095
/* The inferior process has died.  Do what is right.  */
1096
 
1097
void target_mourn_inferior (void);
1098
 
1099
/* Does target have enough data to do a run or attach command? */
1100
 
1101
#define target_can_run(t) \
1102
     ((t)->to_can_run) ()
1103
 
1104
/* post process changes to signal handling in the inferior.  */
1105
 
1106
#define target_notice_signals(ptid) \
1107
     (*current_target.to_notice_signals) (ptid)
1108
 
1109
/* Check to see if a thread is still alive.  */
1110
 
1111
extern int target_thread_alive (ptid_t ptid);
1112
 
1113
/* Query for new threads and add them to the thread list.  */
1114
 
1115
extern void target_find_new_threads (void);
1116
 
1117
/* Make target stop in a continuable fashion.  (For instance, under
1118
   Unix, this should act like SIGSTOP).  This function is normally
1119
   used by GUIs to implement a stop button.  */
1120
 
1121
extern void target_stop (ptid_t ptid);
1122
 
1123
/* Send the specified COMMAND to the target's monitor
1124
   (shell,interpreter) for execution.  The result of the query is
1125
   placed in OUTBUF.  */
1126
 
1127
#define target_rcmd(command, outbuf) \
1128
     (*current_target.to_rcmd) (command, outbuf)
1129
 
1130
 
1131
/* Does the target include all of memory, or only part of it?  This
1132
   determines whether we look up the target chain for other parts of
1133
   memory if this target can't satisfy a request.  */
1134
 
1135
extern int target_has_all_memory_1 (void);
1136
#define target_has_all_memory target_has_all_memory_1 ()
1137
 
1138
/* Does the target include memory?  (Dummy targets don't.)  */
1139
 
1140
extern int target_has_memory_1 (void);
1141
#define target_has_memory target_has_memory_1 ()
1142
 
1143
/* Does the target have a stack?  (Exec files don't, VxWorks doesn't, until
1144
   we start a process.)  */
1145
 
1146
extern int target_has_stack_1 (void);
1147
#define target_has_stack target_has_stack_1 ()
1148
 
1149
/* Does the target have registers?  (Exec files don't.)  */
1150
 
1151
extern int target_has_registers_1 (void);
1152
#define target_has_registers target_has_registers_1 ()
1153
 
1154
/* Does the target have execution?  Can we make it jump (through
1155
   hoops), or pop its stack a few times?  This means that the current
1156
   target is currently executing; for some targets, that's the same as
1157
   whether or not the target is capable of execution, but there are
1158
   also targets which can be current while not executing.  In that
1159
   case this will become true after target_create_inferior or
1160
   target_attach.  */
1161
 
1162
extern int target_has_execution_1 (void);
1163
#define target_has_execution target_has_execution_1 ()
1164
 
1165
/* Default implementations for process_stratum targets.  Return true
1166
   if there's a selected inferior, false otherwise.  */
1167
 
1168
extern int default_child_has_all_memory (struct target_ops *ops);
1169
extern int default_child_has_memory (struct target_ops *ops);
1170
extern int default_child_has_stack (struct target_ops *ops);
1171
extern int default_child_has_registers (struct target_ops *ops);
1172
extern int default_child_has_execution (struct target_ops *ops);
1173
 
1174
/* Can the target support the debugger control of thread execution?
1175
   Can it lock the thread scheduler?  */
1176
 
1177
#define target_can_lock_scheduler \
1178
     (current_target.to_has_thread_control & tc_schedlock)
1179
 
1180
/* Should the target enable async mode if it is supported?  Temporary
1181
   cludge until async mode is a strict superset of sync mode.  */
1182
extern int target_async_permitted;
1183
 
1184
/* Can the target support asynchronous execution? */
1185
#define target_can_async_p() (current_target.to_can_async_p ())
1186
 
1187
/* Is the target in asynchronous execution mode? */
1188
#define target_is_async_p() (current_target.to_is_async_p ())
1189
 
1190
int target_supports_non_stop (void);
1191
 
1192
/* Put the target in async mode with the specified callback function. */
1193
#define target_async(CALLBACK,CONTEXT) \
1194
     (current_target.to_async ((CALLBACK), (CONTEXT)))
1195
 
1196
/* This is to be used ONLY within call_function_by_hand(). It provides
1197
   a workaround, to have inferior function calls done in sychronous
1198
   mode, even though the target is asynchronous. After
1199
   target_async_mask(0) is called, calls to target_can_async_p() will
1200
   return FALSE , so that target_resume() will not try to start the
1201
   target asynchronously. After the inferior stops, we IMMEDIATELY
1202
   restore the previous nature of the target, by calling
1203
   target_async_mask(1). After that, target_can_async_p() will return
1204
   TRUE. ANY OTHER USE OF THIS FEATURE IS DEPRECATED.
1205
 
1206
   FIXME ezannoni 1999-12-13: we won't need this once we move
1207
   the turning async on and off to the single execution commands,
1208
   from where it is done currently, in remote_resume().  */
1209
 
1210
#define target_async_mask(MASK) \
1211
  (current_target.to_async_mask (MASK))
1212
 
1213
/* Converts a process id to a string.  Usually, the string just contains
1214
   `process xyz', but on some systems it may contain
1215
   `process xyz thread abc'.  */
1216
 
1217
extern char *target_pid_to_str (ptid_t ptid);
1218
 
1219
extern char *normal_pid_to_str (ptid_t ptid);
1220
 
1221
/* Return a short string describing extra information about PID,
1222
   e.g. "sleeping", "runnable", "running on LWP 3".  Null return value
1223
   is okay.  */
1224
 
1225
#define target_extra_thread_info(TP) \
1226
     (current_target.to_extra_thread_info (TP))
1227
 
1228
/* Attempts to find the pathname of the executable file
1229
   that was run to create a specified process.
1230
 
1231
   The process PID must be stopped when this operation is used.
1232
 
1233
   If the executable file cannot be determined, NULL is returned.
1234
 
1235
   Else, a pointer to a character string containing the pathname
1236
   is returned.  This string should be copied into a buffer by
1237
   the client if the string will not be immediately used, or if
1238
   it must persist.  */
1239
 
1240
#define target_pid_to_exec_file(pid) \
1241
     (current_target.to_pid_to_exec_file) (pid)
1242
 
1243
/* See the to_thread_architecture description in struct target_ops.  */
1244
 
1245
#define target_thread_architecture(ptid) \
1246
     (current_target.to_thread_architecture (&current_target, ptid))
1247
 
1248
/*
1249
 * Iterator function for target memory regions.
1250
 * Calls a callback function once for each memory region 'mapped'
1251
 * in the child process.  Defined as a simple macro rather than
1252
 * as a function macro so that it can be tested for nullity.
1253
 */
1254
 
1255
#define target_find_memory_regions(FUNC, DATA) \
1256
     (current_target.to_find_memory_regions) (FUNC, DATA)
1257
 
1258
/*
1259
 * Compose corefile .note section.
1260
 */
1261
 
1262
#define target_make_corefile_notes(BFD, SIZE_P) \
1263
     (current_target.to_make_corefile_notes) (BFD, SIZE_P)
1264
 
1265
/* Bookmark interfaces.  */
1266
#define target_get_bookmark(ARGS, FROM_TTY) \
1267
     (current_target.to_get_bookmark) (ARGS, FROM_TTY)
1268
 
1269
#define target_goto_bookmark(ARG, FROM_TTY) \
1270
     (current_target.to_goto_bookmark) (ARG, FROM_TTY)
1271
 
1272
/* Hardware watchpoint interfaces.  */
1273
 
1274
/* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
1275
   write).  Only the INFERIOR_PTID task is being queried.  */
1276
 
1277
#define target_stopped_by_watchpoint \
1278
   (*current_target.to_stopped_by_watchpoint)
1279
 
1280
/* Non-zero if we have steppable watchpoints  */
1281
 
1282
#define target_have_steppable_watchpoint \
1283
   (current_target.to_have_steppable_watchpoint)
1284
 
1285
/* Non-zero if we have continuable watchpoints  */
1286
 
1287
#define target_have_continuable_watchpoint \
1288
   (current_target.to_have_continuable_watchpoint)
1289
 
1290
/* Provide defaults for hardware watchpoint functions.  */
1291
 
1292
/* If the *_hw_beakpoint functions have not been defined
1293
   elsewhere use the definitions in the target vector.  */
1294
 
1295
/* Returns non-zero if we can set a hardware watchpoint of type TYPE.  TYPE is
1296
   one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, or
1297
   bp_hardware_breakpoint.  CNT is the number of such watchpoints used so far
1298
   (including this one?).  OTHERTYPE is who knows what...  */
1299
 
1300
#define target_can_use_hardware_watchpoint(TYPE,CNT,OTHERTYPE) \
1301
 (*current_target.to_can_use_hw_breakpoint) (TYPE, CNT, OTHERTYPE);
1302
 
1303
#define target_region_ok_for_hw_watchpoint(addr, len) \
1304
    (*current_target.to_region_ok_for_hw_watchpoint) (addr, len)
1305
 
1306
 
1307
/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes.
1308
   TYPE is 0 for write, 1 for read, and 2 for read/write accesses.
1309
   COND is the expression for its condition, or NULL if there's none.
1310
   Returns 0 for success, 1 if the watchpoint type is not supported,
1311
   -1 for failure.  */
1312
 
1313
#define target_insert_watchpoint(addr, len, type, cond) \
1314
     (*current_target.to_insert_watchpoint) (addr, len, type, cond)
1315
 
1316
#define target_remove_watchpoint(addr, len, type, cond) \
1317
     (*current_target.to_remove_watchpoint) (addr, len, type, cond)
1318
 
1319
#define target_insert_hw_breakpoint(gdbarch, bp_tgt) \
1320
     (*current_target.to_insert_hw_breakpoint) (gdbarch, bp_tgt)
1321
 
1322
#define target_remove_hw_breakpoint(gdbarch, bp_tgt) \
1323
     (*current_target.to_remove_hw_breakpoint) (gdbarch, bp_tgt)
1324
 
1325
/* Return non-zero if target knows the data address which triggered this
1326
   target_stopped_by_watchpoint, in such case place it to *ADDR_P.  Only the
1327
   INFERIOR_PTID task is being queried.  */
1328
#define target_stopped_data_address(target, addr_p) \
1329
    (*target.to_stopped_data_address) (target, addr_p)
1330
 
1331
#define target_watchpoint_addr_within_range(target, addr, start, length) \
1332
  (*target.to_watchpoint_addr_within_range) (target, addr, start, length)
1333
 
1334
/* Return non-zero if the target is capable of using hardware to evaluate
1335
   the condition expression.  In this case, if the condition is false when
1336
   the watched memory location changes, execution may continue without the
1337
   debugger being notified.
1338
 
1339
   Due to limitations in the hardware implementation, it may be capable of
1340
   avoiding triggering the watchpoint in some cases where the condition
1341
   expression is false, but may report some false positives as well.
1342
   For this reason, GDB will still evaluate the condition expression when
1343
   the watchpoint triggers.  */
1344
#define target_can_accel_watchpoint_condition(addr, len, type, cond) \
1345
  (*current_target.to_can_accel_watchpoint_condition) (addr, len, type, cond)
1346
 
1347
/* Target can execute in reverse?  */
1348
#define target_can_execute_reverse \
1349
     (current_target.to_can_execute_reverse ? \
1350
      current_target.to_can_execute_reverse () : 0)
1351
 
1352
extern const struct target_desc *target_read_description (struct target_ops *);
1353
 
1354
#define target_get_ada_task_ptid(lwp, tid) \
1355
     (*current_target.to_get_ada_task_ptid) (lwp,tid)
1356
 
1357
/* Utility implementation of searching memory.  */
1358
extern int simple_search_memory (struct target_ops* ops,
1359
                                 CORE_ADDR start_addr,
1360
                                 ULONGEST search_space_len,
1361
                                 const gdb_byte *pattern,
1362
                                 ULONGEST pattern_len,
1363
                                 CORE_ADDR *found_addrp);
1364
 
1365
/* Main entry point for searching memory.  */
1366
extern int target_search_memory (CORE_ADDR start_addr,
1367
                                 ULONGEST search_space_len,
1368
                                 const gdb_byte *pattern,
1369
                                 ULONGEST pattern_len,
1370
                                 CORE_ADDR *found_addrp);
1371
 
1372
/* Tracepoint-related operations.  */
1373
 
1374
#define target_trace_init() \
1375
  (*current_target.to_trace_init) ()
1376
 
1377
#define target_download_tracepoint(t) \
1378
  (*current_target.to_download_tracepoint) (t)
1379
 
1380
#define target_download_trace_state_variable(tsv) \
1381
  (*current_target.to_download_trace_state_variable) (tsv)
1382
 
1383
#define target_trace_start() \
1384
  (*current_target.to_trace_start) ()
1385
 
1386
#define target_trace_set_readonly_regions() \
1387
  (*current_target.to_trace_set_readonly_regions) ()
1388
 
1389
#define target_get_trace_status(ts) \
1390
  (*current_target.to_get_trace_status) (ts)
1391
 
1392
#define target_trace_stop() \
1393
  (*current_target.to_trace_stop) ()
1394
 
1395
#define target_trace_find(type,num,addr1,addr2,tpp) \
1396
  (*current_target.to_trace_find) ((type), (num), (addr1), (addr2), (tpp))
1397
 
1398
#define target_get_trace_state_variable_value(tsv,val) \
1399
  (*current_target.to_get_trace_state_variable_value) ((tsv), (val))
1400
 
1401
#define target_save_trace_data(filename) \
1402
  (*current_target.to_save_trace_data) (filename)
1403
 
1404
#define target_upload_tracepoints(utpp) \
1405
  (*current_target.to_upload_tracepoints) (utpp)
1406
 
1407
#define target_upload_trace_state_variables(utsvp) \
1408
  (*current_target.to_upload_trace_state_variables) (utsvp)
1409
 
1410
#define target_get_raw_trace_data(buf,offset,len) \
1411
  (*current_target.to_get_raw_trace_data) ((buf), (offset), (len))
1412
 
1413
#define target_set_disconnected_tracing(val) \
1414
  (*current_target.to_set_disconnected_tracing) (val)
1415
 
1416
#define target_set_circular_trace_buffer(val)   \
1417
  (*current_target.to_set_circular_trace_buffer) (val)
1418
 
1419
#define target_get_tib_address(ptid, addr) \
1420
  (*current_target.to_get_tib_address) ((ptid), (addr))
1421
 
1422
#define target_set_permissions() \
1423
  (*current_target.to_set_permissions) ()
1424
 
1425
#define target_static_tracepoint_marker_at(addr, marker) \
1426
  (*current_target.to_static_tracepoint_marker_at) (addr, marker)
1427
 
1428
#define target_static_tracepoint_markers_by_strid(marker_id) \
1429
  (*current_target.to_static_tracepoint_markers_by_strid) (marker_id)
1430
 
1431
/* Command logging facility.  */
1432
 
1433
#define target_log_command(p)                                           \
1434
  do                                                                    \
1435
    if (current_target.to_log_command)                                  \
1436
      (*current_target.to_log_command) (p);                             \
1437
  while (0)
1438
 
1439
 
1440
extern int target_core_of_thread (ptid_t ptid);
1441
 
1442
/* Verify that the memory in the [MEMADDR, MEMADDR+SIZE) range matches
1443
   the contents of [DATA,DATA+SIZE).  Returns 1 if there's a match, 0
1444
   if there's a mismatch, and -1 if an error is encountered while
1445
   reading memory.  Throws an error if the functionality is found not
1446
   to be supported by the current target.  */
1447
int target_verify_memory (const gdb_byte *data,
1448
                          CORE_ADDR memaddr, ULONGEST size);
1449
 
1450
/* Routines for maintenance of the target structures...
1451
 
1452
   add_target:   Add a target to the list of all possible targets.
1453
 
1454
   push_target:  Make this target the top of the stack of currently used
1455
   targets, within its particular stratum of the stack.  Result
1456
   is 0 if now atop the stack, nonzero if not on top (maybe
1457
   should warn user).
1458
 
1459
   unpush_target: Remove this from the stack of currently used targets,
1460
   no matter where it is on the list.  Returns 0 if no
1461
   change, 1 if removed from stack.
1462
 
1463
   pop_target:   Remove the top thing on the stack of current targets.  */
1464
 
1465
extern void add_target (struct target_ops *);
1466
 
1467
extern void push_target (struct target_ops *);
1468
 
1469
extern int unpush_target (struct target_ops *);
1470
 
1471
extern void target_pre_inferior (int);
1472
 
1473
extern void target_preopen (int);
1474
 
1475
extern void pop_target (void);
1476
 
1477
/* Does whatever cleanup is required to get rid of all pushed targets.
1478
   QUITTING is propagated to target_close; it indicates that GDB is
1479
   exiting and should not get hung on an error (otherwise it is
1480
   important to perform clean termination, even if it takes a
1481
   while).  */
1482
extern void pop_all_targets (int quitting);
1483
 
1484
/* Like pop_all_targets, but pops only targets whose stratum is
1485
   strictly above ABOVE_STRATUM.  */
1486
extern void pop_all_targets_above (enum strata above_stratum, int quitting);
1487
 
1488
extern CORE_ADDR target_translate_tls_address (struct objfile *objfile,
1489
                                               CORE_ADDR offset);
1490
 
1491
/* Struct target_section maps address ranges to file sections.  It is
1492
   mostly used with BFD files, but can be used without (e.g. for handling
1493
   raw disks, or files not in formats handled by BFD).  */
1494
 
1495
struct target_section
1496
  {
1497
    CORE_ADDR addr;             /* Lowest address in section */
1498
    CORE_ADDR endaddr;          /* 1+highest address in section */
1499
 
1500
    struct bfd_section *the_bfd_section;
1501
 
1502
    bfd *bfd;                   /* BFD file pointer */
1503
  };
1504
 
1505
/* Holds an array of target sections.  Defined by [SECTIONS..SECTIONS_END[.  */
1506
 
1507
struct target_section_table
1508
{
1509
  struct target_section *sections;
1510
  struct target_section *sections_end;
1511
};
1512
 
1513
/* Return the "section" containing the specified address.  */
1514
struct target_section *target_section_by_addr (struct target_ops *target,
1515
                                               CORE_ADDR addr);
1516
 
1517
/* Return the target section table this target (or the targets
1518
   beneath) currently manipulate.  */
1519
 
1520
extern struct target_section_table *target_get_section_table
1521
  (struct target_ops *target);
1522
 
1523
/* From mem-break.c */
1524
 
1525
extern int memory_remove_breakpoint (struct gdbarch *, struct bp_target_info *);
1526
 
1527
extern int memory_insert_breakpoint (struct gdbarch *, struct bp_target_info *);
1528
 
1529
extern int default_memory_remove_breakpoint (struct gdbarch *, struct bp_target_info *);
1530
 
1531
extern int default_memory_insert_breakpoint (struct gdbarch *, struct bp_target_info *);
1532
 
1533
 
1534
/* From target.c */
1535
 
1536
extern void initialize_targets (void);
1537
 
1538
extern void noprocess (void) ATTRIBUTE_NORETURN;
1539
 
1540
extern void target_require_runnable (void);
1541
 
1542
extern void find_default_attach (struct target_ops *, char *, int);
1543
 
1544
extern void find_default_create_inferior (struct target_ops *,
1545
                                          char *, char *, char **, int);
1546
 
1547
extern struct target_ops *find_run_target (void);
1548
 
1549
extern struct target_ops *find_core_target (void);
1550
 
1551
extern struct target_ops *find_target_beneath (struct target_ops *);
1552
 
1553
/* Read OS data object of type TYPE from the target, and return it in
1554
   XML format.  The result is NUL-terminated and returned as a string,
1555
   allocated using xmalloc.  If an error occurs or the transfer is
1556
   unsupported, NULL is returned.  Empty objects are returned as
1557
   allocated but empty strings.  */
1558
 
1559
extern char *target_get_osdata (const char *type);
1560
 
1561
 
1562
/* Stuff that should be shared among the various remote targets.  */
1563
 
1564
/* Debugging level.  0 is off, and non-zero values mean to print some debug
1565
   information (higher values, more information).  */
1566
extern int remote_debug;
1567
 
1568
/* Speed in bits per second, or -1 which means don't mess with the speed.  */
1569
extern int baud_rate;
1570
/* Timeout limit for response from target. */
1571
extern int remote_timeout;
1572
 
1573
 
1574
/* Functions for helping to write a native target.  */
1575
 
1576
/* This is for native targets which use a unix/POSIX-style waitstatus.  */
1577
extern void store_waitstatus (struct target_waitstatus *, int);
1578
 
1579
/* These are in common/signals.c, but they're only used by gdb.  */
1580
extern enum target_signal default_target_signal_from_host (struct gdbarch *,
1581
                                                           int);
1582
extern int default_target_signal_to_host (struct gdbarch *,
1583
                                          enum target_signal);
1584
 
1585
/* Convert from a number used in a GDB command to an enum target_signal.  */
1586
extern enum target_signal target_signal_from_command (int);
1587
/* End of files in common/signals.c.  */
1588
 
1589
/* Set the show memory breakpoints mode to show, and installs a cleanup
1590
   to restore it back to the current value.  */
1591
extern struct cleanup *make_show_memory_breakpoints_cleanup (int show);
1592
 
1593
extern int may_write_registers;
1594
extern int may_write_memory;
1595
extern int may_insert_breakpoints;
1596
extern int may_insert_tracepoints;
1597
extern int may_insert_fast_tracepoints;
1598
extern int may_stop;
1599
 
1600
extern void update_target_permissions (void);
1601
 
1602
 
1603
/* Imported from machine dependent code */
1604
 
1605
/* Blank target vector entries are initialized to target_ignore. */
1606
void target_ignore (void);
1607
 
1608
extern struct target_ops deprecated_child_ops;
1609
 
1610
#endif /* !defined (TARGET_H) */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.