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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [target.h] - Blame information for rev 816

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 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
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
 
34
/* This include file defines the interface between the main part
35
   of the debugger, and the part which is target-specific, or
36
   specific to the communications interface between us and the
37
   target.
38
 
39
   A TARGET is an interface between the debugger and a particular
40
   kind of file or process.  Targets can be STACKED in STRATA,
41
   so that more than one target can potentially respond to a request.
42
   In particular, memory accesses will walk down the stack of targets
43
   until they find a target that is interested in handling that particular
44
   address.  STRATA are artificial boundaries on the stack, within
45
   which particular kinds of targets live.  Strata exist so that
46
   people don't get confused by pushing e.g. a process target and then
47
   a file target, and wondering why they can't see the current values
48
   of variables any more (the file target is handling them and they
49
   never get to the process target).  So when you push a file target,
50
   it goes into the file stratum, which is always below the process
51
   stratum.  */
52
 
53
#include "bfd.h"
54
#include "symtab.h"
55
#include "dcache.h"
56
#include "memattr.h"
57
#include "vec.h"
58
 
59
enum strata
60
  {
61
    dummy_stratum,              /* The lowest of the low */
62
    file_stratum,               /* Executable files, etc */
63
    core_stratum,               /* Core dump files */
64
    download_stratum,           /* Downloading of remote targets */
65
    process_stratum,            /* Executing processes */
66
    thread_stratum              /* Executing threads */
67
  };
68
 
69
enum thread_control_capabilities
70
  {
71
    tc_none = 0,         /* Default: can't control thread execution.  */
72
    tc_schedlock = 1,           /* Can lock the thread scheduler.  */
73
    tc_switch = 2               /* Can switch the running thread on demand.  */
74
  };
75
 
76
/* Stuff for target_wait.  */
77
 
78
/* Generally, what has the program done?  */
79
enum target_waitkind
80
  {
81
    /* The program has exited.  The exit status is in value.integer.  */
82
    TARGET_WAITKIND_EXITED,
83
 
84
    /* The program has stopped with a signal.  Which signal is in
85
       value.sig.  */
86
    TARGET_WAITKIND_STOPPED,
87
 
88
    /* The program has terminated with a signal.  Which signal is in
89
       value.sig.  */
90
    TARGET_WAITKIND_SIGNALLED,
91
 
92
    /* The program is letting us know that it dynamically loaded something
93
       (e.g. it called load(2) on AIX).  */
94
    TARGET_WAITKIND_LOADED,
95
 
96
    /* The program has forked.  A "related" process' ID is in
97
       value.related_pid.  I.e., if the child forks, value.related_pid
98
       is the parent's ID.  */
99
 
100
    TARGET_WAITKIND_FORKED,
101
 
102
    /* The program has vforked.  A "related" process's ID is in
103
       value.related_pid.  */
104
 
105
    TARGET_WAITKIND_VFORKED,
106
 
107
    /* The program has exec'ed a new executable file.  The new file's
108
       pathname is pointed to by value.execd_pathname.  */
109
 
110
    TARGET_WAITKIND_EXECD,
111
 
112
    /* The program has entered or returned from a system call.  On
113
       HP-UX, this is used in the hardware watchpoint implementation.
114
       The syscall's unique integer ID number is in value.syscall_id */
115
 
116
    TARGET_WAITKIND_SYSCALL_ENTRY,
117
    TARGET_WAITKIND_SYSCALL_RETURN,
118
 
119
    /* Nothing happened, but we stopped anyway.  This perhaps should be handled
120
       within target_wait, but I'm not sure target_wait should be resuming the
121
       inferior.  */
122
    TARGET_WAITKIND_SPURIOUS,
123
 
124
    /* An event has occured, but we should wait again.
125
       Remote_async_wait() returns this when there is an event
126
       on the inferior, but the rest of the world is not interested in
127
       it. The inferior has not stopped, but has just sent some output
128
       to the console, for instance. In this case, we want to go back
129
       to the event loop and wait there for another event from the
130
       inferior, rather than being stuck in the remote_async_wait()
131
       function. This way the event loop is responsive to other events,
132
       like for instance the user typing.  */
133
    TARGET_WAITKIND_IGNORE
134
  };
135
 
136
struct target_waitstatus
137
  {
138
    enum target_waitkind kind;
139
 
140
    /* Forked child pid, execd pathname, exit status or signal number.  */
141
    union
142
      {
143
        int integer;
144
        enum target_signal sig;
145
        int related_pid;
146
        char *execd_pathname;
147
        int syscall_id;
148
      }
149
    value;
150
  };
151
 
152
/* Possible types of events that the inferior handler will have to
153
   deal with.  */
154
enum inferior_event_type
155
  {
156
    /* There is a request to quit the inferior, abandon it.  */
157
    INF_QUIT_REQ,
158
    /* Process a normal inferior event which will result in target_wait
159
       being called.  */
160
    INF_REG_EVENT,
161
    /* Deal with an error on the inferior.  */
162
    INF_ERROR,
163
    /* We are called because a timer went off.  */
164
    INF_TIMER,
165
    /* We are called to do stuff after the inferior stops.  */
166
    INF_EXEC_COMPLETE,
167
    /* We are called to do some stuff after the inferior stops, but we
168
       are expected to reenter the proceed() and
169
       handle_inferior_event() functions. This is used only in case of
170
       'step n' like commands.  */
171
    INF_EXEC_CONTINUE
172
  };
173
 
174
/* Return the string for a signal.  */
175
extern char *target_signal_to_string (enum target_signal);
176
 
177
/* Return the name (SIGHUP, etc.) for a signal.  */
178
extern char *target_signal_to_name (enum target_signal);
179
 
180
/* Given a name (SIGHUP, etc.), return its signal.  */
181
enum target_signal target_signal_from_name (char *);
182
 
183
/* Target objects which can be transfered using target_read,
184
   target_write, et cetera.  */
185
 
186
enum target_object
187
{
188
  /* AVR target specific transfer.  See "avr-tdep.c" and "remote.c".  */
189
  TARGET_OBJECT_AVR,
190
  /* SPU target specific transfer.  See "spu-tdep.c".  */
191
  TARGET_OBJECT_SPU,
192
  /* Transfer up-to LEN bytes of memory starting at OFFSET.  */
193
  TARGET_OBJECT_MEMORY,
194
  /* Memory, avoiding GDB's data cache and trusting the executable.
195
     Target implementations of to_xfer_partial never need to handle
196
     this object, and most callers should not use it.  */
197
  TARGET_OBJECT_RAW_MEMORY,
198
  /* Kernel Unwind Table.  See "ia64-tdep.c".  */
199
  TARGET_OBJECT_UNWIND_TABLE,
200
  /* Transfer auxilliary vector.  */
201
  TARGET_OBJECT_AUXV,
202
  /* StackGhost cookie.  See "sparc-tdep.c".  */
203
  TARGET_OBJECT_WCOOKIE,
204
  /* Target memory map in XML format.  */
205
  TARGET_OBJECT_MEMORY_MAP,
206
  /* Flash memory.  This object can be used to write contents to
207
     a previously erased flash memory.  Using it without erasing
208
     flash can have unexpected results.  Addresses are physical
209
     address on target, and not relative to flash start.  */
210
  TARGET_OBJECT_FLASH,
211
  /* Available target-specific features, e.g. registers and coprocessors.
212
     See "target-descriptions.c".  ANNEX should never be empty.  */
213
  TARGET_OBJECT_AVAILABLE_FEATURES,
214
  /* Currently loaded libraries, in XML format.  */
215
  TARGET_OBJECT_LIBRARIES
216
  /* Possible future objects: TARGET_OBJECT_FILE, TARGET_OBJECT_PROC, ... */
217
};
218
 
219
/* Request that OPS transfer up to LEN 8-bit bytes of the target's
220
   OBJECT.  The OFFSET, for a seekable object, specifies the
221
   starting point.  The ANNEX can be used to provide additional
222
   data-specific information to the target.
223
 
224
   Return the number of bytes actually transfered, or -1 if the
225
   transfer is not supported or otherwise fails.  Return of a positive
226
   value less than LEN indicates that no further transfer is possible.
227
   Unlike the raw to_xfer_partial interface, callers of these
228
   functions do not need to retry partial transfers.  */
229
 
230
extern LONGEST target_read (struct target_ops *ops,
231
                            enum target_object object,
232
                            const char *annex, gdb_byte *buf,
233
                            ULONGEST offset, LONGEST len);
234
 
235
extern LONGEST target_write (struct target_ops *ops,
236
                             enum target_object object,
237
                             const char *annex, const gdb_byte *buf,
238
                             ULONGEST offset, LONGEST len);
239
 
240
/* Similar to target_write, except that it also calls PROGRESS with
241
   the number of bytes written and the opaque BATON after every
242
   successful partial write (and before the first write).  This is
243
   useful for progress reporting and user interaction while writing
244
   data.  To abort the transfer, the progress callback can throw an
245
   exception.  */
246
 
247
LONGEST target_write_with_progress (struct target_ops *ops,
248
                                    enum target_object object,
249
                                    const char *annex, const gdb_byte *buf,
250
                                    ULONGEST offset, LONGEST len,
251
                                    void (*progress) (ULONGEST, void *),
252
                                    void *baton);
253
 
254
/* Wrapper to perform a full read of unknown size.  OBJECT/ANNEX will
255
   be read using OPS.  The return value will be -1 if the transfer
256
   fails or is not supported; 0 if the object is empty; or the length
257
   of the object otherwise.  If a positive value is returned, a
258
   sufficiently large buffer will be allocated using xmalloc and
259
   returned in *BUF_P containing the contents of the object.
260
 
261
   This method should be used for objects sufficiently small to store
262
   in a single xmalloc'd buffer, when no fixed bound on the object's
263
   size is known in advance.  Don't try to read TARGET_OBJECT_MEMORY
264
   through this function.  */
265
 
266
extern LONGEST target_read_alloc (struct target_ops *ops,
267
                                  enum target_object object,
268
                                  const char *annex, gdb_byte **buf_p);
269
 
270
/* Read OBJECT/ANNEX using OPS.  The result is NUL-terminated and
271
   returned as a string, allocated using xmalloc.  If an error occurs
272
   or the transfer is unsupported, NULL is returned.  Empty objects
273
   are returned as allocated but empty strings.  A warning is issued
274
   if the result contains any embedded NUL bytes.  */
275
 
276
extern char *target_read_stralloc (struct target_ops *ops,
277
                                   enum target_object object,
278
                                   const char *annex);
279
 
280
/* Wrappers to target read/write that perform memory transfers.  They
281
   throw an error if the memory transfer fails.
282
 
283
   NOTE: cagney/2003-10-23: The naming schema is lifted from
284
   "frame.h".  The parameter order is lifted from get_frame_memory,
285
   which in turn lifted it from read_memory.  */
286
 
287
extern void get_target_memory (struct target_ops *ops, CORE_ADDR addr,
288
                               gdb_byte *buf, LONGEST len);
289
extern ULONGEST get_target_memory_unsigned (struct target_ops *ops,
290
                                            CORE_ADDR addr, int len);
291
 
292
 
293
/* If certain kinds of activity happen, target_wait should perform
294
   callbacks.  */
295
/* Right now we just call (*TARGET_ACTIVITY_FUNCTION) if I/O is possible
296
   on TARGET_ACTIVITY_FD.  */
297
extern int target_activity_fd;
298
/* Returns zero to leave the inferior alone, one to interrupt it.  */
299
extern int (*target_activity_function) (void);
300
 
301
struct thread_info;             /* fwd decl for parameter list below: */
302
 
303
struct target_ops
304
  {
305
    struct target_ops *beneath; /* To the target under this one.  */
306
    char *to_shortname;         /* Name this target type */
307
    char *to_longname;          /* Name for printing */
308
    char *to_doc;               /* Documentation.  Does not include trailing
309
                                   newline, and starts with a one-line descrip-
310
                                   tion (probably similar to to_longname).  */
311
    /* Per-target scratch pad.  */
312
    void *to_data;
313
    /* The open routine takes the rest of the parameters from the
314
       command, and (if successful) pushes a new target onto the
315
       stack.  Targets should supply this routine, if only to provide
316
       an error message.  */
317
    void (*to_open) (char *, int);
318
    /* Old targets with a static target vector provide "to_close".
319
       New re-entrant targets provide "to_xclose" and that is expected
320
       to xfree everything (including the "struct target_ops").  */
321
    void (*to_xclose) (struct target_ops *targ, int quitting);
322
    void (*to_close) (int);
323
    void (*to_attach) (char *, int);
324
    void (*to_post_attach) (int);
325
    void (*to_detach) (char *, int);
326
    void (*to_disconnect) (struct target_ops *, char *, int);
327
    void (*to_resume) (ptid_t, int, enum target_signal);
328
    ptid_t (*to_wait) (ptid_t, struct target_waitstatus *);
329
    void (*to_fetch_registers) (struct regcache *, int);
330
    void (*to_store_registers) (struct regcache *, int);
331
    void (*to_prepare_to_store) (struct regcache *);
332
 
333
    /* Transfer LEN bytes of memory between GDB address MYADDR and
334
       target address MEMADDR.  If WRITE, transfer them to the target, else
335
       transfer them from the target.  TARGET is the target from which we
336
       get this function.
337
 
338
       Return value, N, is one of the following:
339
 
340
 
341
       error which prevented us from doing it (FIXME: What about bfd_error?).
342
 
343
       positive (call it N) means that we have transferred N bytes
344
       starting at MEMADDR.  We might be able to handle more bytes
345
       beyond this length, but no promises.
346
 
347
       negative (call its absolute value N) means that we cannot
348
       transfer right at MEMADDR, but we could transfer at least
349
       something at MEMADDR + N.
350
 
351
       NOTE: cagney/2004-10-01: This has been entirely superseeded by
352
       to_xfer_partial and inferior inheritance.  */
353
 
354
    int (*deprecated_xfer_memory) (CORE_ADDR memaddr, gdb_byte *myaddr,
355
                                   int len, int write,
356
                                   struct mem_attrib *attrib,
357
                                   struct target_ops *target);
358
 
359
    void (*to_files_info) (struct target_ops *);
360
    int (*to_insert_breakpoint) (struct bp_target_info *);
361
    int (*to_remove_breakpoint) (struct bp_target_info *);
362
    int (*to_can_use_hw_breakpoint) (int, int, int);
363
    int (*to_insert_hw_breakpoint) (struct bp_target_info *);
364
    int (*to_remove_hw_breakpoint) (struct bp_target_info *);
365
    int (*to_remove_watchpoint) (CORE_ADDR, int, int);
366
    int (*to_insert_watchpoint) (CORE_ADDR, int, int);
367
    int (*to_stopped_by_watchpoint) (void);
368
    int to_have_steppable_watchpoint;
369
    int to_have_continuable_watchpoint;
370
    int (*to_stopped_data_address) (struct target_ops *, CORE_ADDR *);
371
    int (*to_region_ok_for_hw_watchpoint) (CORE_ADDR, int);
372
    void (*to_terminal_init) (void);
373
    void (*to_terminal_inferior) (void);
374
    void (*to_terminal_ours_for_output) (void);
375
    void (*to_terminal_ours) (void);
376
    void (*to_terminal_save_ours) (void);
377
    void (*to_terminal_info) (char *, int);
378
    void (*to_kill) (void);
379
    void (*to_load) (char *, int);
380
    int (*to_lookup_symbol) (char *, CORE_ADDR *);
381
    void (*to_create_inferior) (char *, char *, char **, int);
382
    void (*to_post_startup_inferior) (ptid_t);
383
    void (*to_acknowledge_created_inferior) (int);
384
    void (*to_insert_fork_catchpoint) (int);
385
    int (*to_remove_fork_catchpoint) (int);
386
    void (*to_insert_vfork_catchpoint) (int);
387
    int (*to_remove_vfork_catchpoint) (int);
388
    int (*to_follow_fork) (struct target_ops *, int);
389
    void (*to_insert_exec_catchpoint) (int);
390
    int (*to_remove_exec_catchpoint) (int);
391
    int (*to_reported_exec_events_per_exec_call) (void);
392
    int (*to_has_exited) (int, int, int *);
393
    void (*to_mourn_inferior) (void);
394
    int (*to_can_run) (void);
395
    void (*to_notice_signals) (ptid_t ptid);
396
    int (*to_thread_alive) (ptid_t ptid);
397
    void (*to_find_new_threads) (void);
398
    char *(*to_pid_to_str) (ptid_t);
399
    char *(*to_extra_thread_info) (struct thread_info *);
400
    void (*to_stop) (void);
401
    void (*to_rcmd) (char *command, struct ui_file *output);
402
    char *(*to_pid_to_exec_file) (int pid);
403
    void (*to_log_command) (const char *);
404
    enum strata to_stratum;
405
    int to_has_all_memory;
406
    int to_has_memory;
407
    int to_has_stack;
408
    int to_has_registers;
409
    int to_has_execution;
410
    int to_has_thread_control;  /* control thread execution */
411
    struct section_table
412
     *to_sections;
413
    struct section_table
414
     *to_sections_end;
415
    /* ASYNC target controls */
416
    int (*to_can_async_p) (void);
417
    int (*to_is_async_p) (void);
418
    void (*to_async) (void (*cb) (enum inferior_event_type, void *context),
419
                      void *context);
420
    int to_async_mask_value;
421
    int (*to_find_memory_regions) (int (*) (CORE_ADDR,
422
                                            unsigned long,
423
                                            int, int, int,
424
                                            void *),
425
                                   void *);
426
    char * (*to_make_corefile_notes) (bfd *, int *);
427
 
428
    /* Return the thread-local address at OFFSET in the
429
       thread-local storage for the thread PTID and the shared library
430
       or executable file given by OBJFILE.  If that block of
431
       thread-local storage hasn't been allocated yet, this function
432
       may return an error.  */
433
    CORE_ADDR (*to_get_thread_local_address) (ptid_t ptid,
434
                                              CORE_ADDR load_module_addr,
435
                                              CORE_ADDR offset);
436
 
437
    /* Request that OPS transfer up to LEN 8-bit bytes of the target's
438
       OBJECT.  The OFFSET, for a seekable object, specifies the
439
       starting point.  The ANNEX can be used to provide additional
440
       data-specific information to the target.
441
 
442
       Return the number of bytes actually transfered, zero when no
443
       further transfer is possible, and -1 when the transfer is not
444
       supported.  Return of a positive value smaller than LEN does
445
       not indicate the end of the object, only the end of the
446
       transfer; higher level code should continue transferring if
447
       desired.  This is handled in target.c.
448
 
449
       The interface does not support a "retry" mechanism.  Instead it
450
       assumes that at least one byte will be transfered on each
451
       successful call.
452
 
453
       NOTE: cagney/2003-10-17: The current interface can lead to
454
       fragmented transfers.  Lower target levels should not implement
455
       hacks, such as enlarging the transfer, in an attempt to
456
       compensate for this.  Instead, the target stack should be
457
       extended so that it implements supply/collect methods and a
458
       look-aside object cache.  With that available, the lowest
459
       target can safely and freely "push" data up the stack.
460
 
461
       See target_read and target_write for more information.  One,
462
       and only one, of readbuf or writebuf must be non-NULL.  */
463
 
464
    LONGEST (*to_xfer_partial) (struct target_ops *ops,
465
                                enum target_object object, const char *annex,
466
                                gdb_byte *readbuf, const gdb_byte *writebuf,
467
                                ULONGEST offset, LONGEST len);
468
 
469
    /* Returns the memory map for the target.  A return value of NULL
470
       means that no memory map is available.  If a memory address
471
       does not fall within any returned regions, it's assumed to be
472
       RAM.  The returned memory regions should not overlap.
473
 
474
       The order of regions does not matter; target_memory_map will
475
       sort regions by starting address. For that reason, this
476
       function should not be called directly except via
477
       target_memory_map.
478
 
479
       This method should not cache data; if the memory map could
480
       change unexpectedly, it should be invalidated, and higher
481
       layers will re-fetch it.  */
482
    VEC(mem_region_s) *(*to_memory_map) (struct target_ops *);
483
 
484
    /* Erases the region of flash memory starting at ADDRESS, of
485
       length LENGTH.
486
 
487
       Precondition: both ADDRESS and ADDRESS+LENGTH should be aligned
488
       on flash block boundaries, as reported by 'to_memory_map'.  */
489
    void (*to_flash_erase) (struct target_ops *,
490
                           ULONGEST address, LONGEST length);
491
 
492
    /* Finishes a flash memory write sequence.  After this operation
493
       all flash memory should be available for writing and the result
494
       of reading from areas written by 'to_flash_write' should be
495
       equal to what was written.  */
496
    void (*to_flash_done) (struct target_ops *);
497
 
498
    /* Describe the architecture-specific features of this target.
499
       Returns the description found, or NULL if no description
500
       was available.  */
501
    const struct target_desc *(*to_read_description) (struct target_ops *ops);
502
 
503
    int to_magic;
504
    /* Need sub-structure for target machine related rather than comm related?
505
     */
506
  };
507
 
508
/* Magic number for checking ops size.  If a struct doesn't end with this
509
   number, somebody changed the declaration but didn't change all the
510
   places that initialize one.  */
511
 
512
#define OPS_MAGIC       3840
513
 
514
/* The ops structure for our "current" target process.  This should
515
   never be NULL.  If there is no target, it points to the dummy_target.  */
516
 
517
extern struct target_ops current_target;
518
 
519
/* Define easy words for doing these operations on our current target.  */
520
 
521
#define target_shortname        (current_target.to_shortname)
522
#define target_longname         (current_target.to_longname)
523
 
524
/* Does whatever cleanup is required for a target that we are no
525
   longer going to be calling.  QUITTING indicates that GDB is exiting
526
   and should not get hung on an error (otherwise it is important to
527
   perform clean termination, even if it takes a while).  This routine
528
   is automatically always called when popping the target off the
529
   target stack (to_beneath is undefined).  Closing file descriptors
530
   and freeing all memory allocated memory are typical things it
531
   should do.  */
532
 
533
void target_close (struct target_ops *targ, int quitting);
534
 
535
/* Attaches to a process on the target side.  Arguments are as passed
536
   to the `attach' command by the user.  This routine can be called
537
   when the target is not on the target-stack, if the target_can_run
538
   routine returns 1; in that case, it must push itself onto the stack.
539
   Upon exit, the target should be ready for normal operations, and
540
   should be ready to deliver the status of the process immediately
541
   (without waiting) to an upcoming target_wait call.  */
542
 
543
#define target_attach(args, from_tty)   \
544
     (*current_target.to_attach) (args, from_tty)
545
 
546
/* The target_attach operation places a process under debugger control,
547
   and stops the process.
548
 
549
   This operation provides a target-specific hook that allows the
550
   necessary bookkeeping to be performed after an attach completes.  */
551
#define target_post_attach(pid) \
552
     (*current_target.to_post_attach) (pid)
553
 
554
/* Takes a program previously attached to and detaches it.
555
   The program may resume execution (some targets do, some don't) and will
556
   no longer stop on signals, etc.  We better not have left any breakpoints
557
   in the program or it'll die when it hits one.  ARGS is arguments
558
   typed by the user (e.g. a signal to send the process).  FROM_TTY
559
   says whether to be verbose or not.  */
560
 
561
extern void target_detach (char *, int);
562
 
563
/* Disconnect from the current target without resuming it (leaving it
564
   waiting for a debugger).  */
565
 
566
extern void target_disconnect (char *, int);
567
 
568
/* Resume execution of the target process PTID.  STEP says whether to
569
   single-step or to run free; SIGGNAL is the signal to be given to
570
   the target, or TARGET_SIGNAL_0 for no signal.  The caller may not
571
   pass TARGET_SIGNAL_DEFAULT.  */
572
 
573
#define target_resume(ptid, step, siggnal)                              \
574
  do {                                                                  \
575
    dcache_invalidate(target_dcache);                                   \
576
    (*current_target.to_resume) (ptid, step, siggnal);                  \
577
  } while (0)
578
 
579
/* Wait for process pid to do something.  PTID = -1 to wait for any
580
   pid to do something.  Return pid of child, or -1 in case of error;
581
   store status through argument pointer STATUS.  Note that it is
582
   _NOT_ OK to throw_exception() out of target_wait() without popping
583
   the debugging target from the stack; GDB isn't prepared to get back
584
   to the prompt with a debugging target but without the frame cache,
585
   stop_pc, etc., set up.  */
586
 
587
#define target_wait(ptid, status)               \
588
     (*current_target.to_wait) (ptid, status)
589
 
590
/* Fetch at least register REGNO, or all regs if regno == -1.  No result.  */
591
 
592
#define target_fetch_registers(regcache, regno) \
593
     (*current_target.to_fetch_registers) (regcache, regno)
594
 
595
/* Store at least register REGNO, or all regs if REGNO == -1.
596
   It can store as many registers as it wants to, so target_prepare_to_store
597
   must have been previously called.  Calls error() if there are problems.  */
598
 
599
#define target_store_registers(regcache, regs)  \
600
     (*current_target.to_store_registers) (regcache, regs)
601
 
602
/* Get ready to modify the registers array.  On machines which store
603
   individual registers, this doesn't need to do anything.  On machines
604
   which store all the registers in one fell swoop, this makes sure
605
   that REGISTERS contains all the registers from the program being
606
   debugged.  */
607
 
608
#define target_prepare_to_store(regcache)       \
609
     (*current_target.to_prepare_to_store) (regcache)
610
 
611
extern DCACHE *target_dcache;
612
 
613
extern int target_read_string (CORE_ADDR, char **, int, int *);
614
 
615
extern int target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len);
616
 
617
extern int target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr,
618
                                int len);
619
 
620
extern int xfer_memory (CORE_ADDR, gdb_byte *, int, int,
621
                        struct mem_attrib *, struct target_ops *);
622
 
623
/* Fetches the target's memory map.  If one is found it is sorted
624
   and returned, after some consistency checking.  Otherwise, NULL
625
   is returned.  */
626
VEC(mem_region_s) *target_memory_map (void);
627
 
628
/* Erase the specified flash region.  */
629
void target_flash_erase (ULONGEST address, LONGEST length);
630
 
631
/* Finish a sequence of flash operations.  */
632
void target_flash_done (void);
633
 
634
/* Describes a request for a memory write operation.  */
635
struct memory_write_request
636
  {
637
    /* Begining address that must be written. */
638
    ULONGEST begin;
639
    /* Past-the-end address. */
640
    ULONGEST end;
641
    /* The data to write. */
642
    gdb_byte *data;
643
    /* A callback baton for progress reporting for this request.  */
644
    void *baton;
645
  };
646
typedef struct memory_write_request memory_write_request_s;
647
DEF_VEC_O(memory_write_request_s);
648
 
649
/* Enumeration specifying different flash preservation behaviour.  */
650
enum flash_preserve_mode
651
  {
652
    flash_preserve,
653
    flash_discard
654
  };
655
 
656
/* Write several memory blocks at once.  This version can be more
657
   efficient than making several calls to target_write_memory, in
658
   particular because it can optimize accesses to flash memory.
659
 
660
   Moreover, this is currently the only memory access function in gdb
661
   that supports writing to flash memory, and it should be used for
662
   all cases where access to flash memory is desirable.
663
 
664
   REQUESTS is the vector (see vec.h) of memory_write_request.
665
   PRESERVE_FLASH_P indicates what to do with blocks which must be
666
     erased, but not completely rewritten.
667
   PROGRESS_CB is a function that will be periodically called to provide
668
     feedback to user.  It will be called with the baton corresponding
669
     to the request currently being written.  It may also be called
670
     with a NULL baton, when preserved flash sectors are being rewritten.
671
 
672
   The function returns 0 on success, and error otherwise.  */
673
int target_write_memory_blocks (VEC(memory_write_request_s) *requests,
674
                                enum flash_preserve_mode preserve_flash_p,
675
                                void (*progress_cb) (ULONGEST, void *));
676
 
677
/* From infrun.c.  */
678
 
679
extern int inferior_has_forked (int pid, int *child_pid);
680
 
681
extern int inferior_has_vforked (int pid, int *child_pid);
682
 
683
extern int inferior_has_execd (int pid, char **execd_pathname);
684
 
685
/* From exec.c */
686
 
687
extern void print_section_info (struct target_ops *, bfd *);
688
 
689
/* Print a line about the current target.  */
690
 
691
#define target_files_info()     \
692
     (*current_target.to_files_info) (&current_target)
693
 
694
/* Insert a breakpoint at address BP_TGT->placed_address in the target
695
   machine.  Result is 0 for success, or an errno value.  */
696
 
697
#define target_insert_breakpoint(bp_tgt)        \
698
     (*current_target.to_insert_breakpoint) (bp_tgt)
699
 
700
/* Remove a breakpoint at address BP_TGT->placed_address in the target
701
   machine.  Result is 0 for success, or an errno value.  */
702
 
703
#define target_remove_breakpoint(bp_tgt)        \
704
     (*current_target.to_remove_breakpoint) (bp_tgt)
705
 
706
/* Initialize the terminal settings we record for the inferior,
707
   before we actually run the inferior.  */
708
 
709
#define target_terminal_init() \
710
     (*current_target.to_terminal_init) ()
711
 
712
/* Put the inferior's terminal settings into effect.
713
   This is preparation for starting or resuming the inferior.  */
714
 
715
#define target_terminal_inferior() \
716
     (*current_target.to_terminal_inferior) ()
717
 
718
/* Put some of our terminal settings into effect,
719
   enough to get proper results from our output,
720
   but do not change into or out of RAW mode
721
   so that no input is discarded.
722
 
723
   After doing this, either terminal_ours or terminal_inferior
724
   should be called to get back to a normal state of affairs.  */
725
 
726
#define target_terminal_ours_for_output() \
727
     (*current_target.to_terminal_ours_for_output) ()
728
 
729
/* Put our terminal settings into effect.
730
   First record the inferior's terminal settings
731
   so they can be restored properly later.  */
732
 
733
#define target_terminal_ours() \
734
     (*current_target.to_terminal_ours) ()
735
 
736
/* Save our terminal settings.
737
   This is called from TUI after entering or leaving the curses
738
   mode.  Since curses modifies our terminal this call is here
739
   to take this change into account.  */
740
 
741
#define target_terminal_save_ours() \
742
     (*current_target.to_terminal_save_ours) ()
743
 
744
/* Print useful information about our terminal status, if such a thing
745
   exists.  */
746
 
747
#define target_terminal_info(arg, from_tty) \
748
     (*current_target.to_terminal_info) (arg, from_tty)
749
 
750
/* Kill the inferior process.   Make it go away.  */
751
 
752
#define target_kill() \
753
     (*current_target.to_kill) ()
754
 
755
/* Load an executable file into the target process.  This is expected
756
   to not only bring new code into the target process, but also to
757
   update GDB's symbol tables to match.
758
 
759
   ARG contains command-line arguments, to be broken down with
760
   buildargv ().  The first non-switch argument is the filename to
761
   load, FILE; the second is a number (as parsed by strtoul (..., ...,
762
   0)), which is an offset to apply to the load addresses of FILE's
763
   sections.  The target may define switches, or other non-switch
764
   arguments, as it pleases.  */
765
 
766
extern void target_load (char *arg, int from_tty);
767
 
768
/* Look up a symbol in the target's symbol table.  NAME is the symbol
769
   name.  ADDRP is a CORE_ADDR * pointing to where the value of the
770
   symbol should be returned.  The result is 0 if successful, nonzero
771
   if the symbol does not exist in the target environment.  This
772
   function should not call error() if communication with the target
773
   is interrupted, since it is called from symbol reading, but should
774
   return nonzero, possibly doing a complain().  */
775
 
776
#define target_lookup_symbol(name, addrp) \
777
     (*current_target.to_lookup_symbol) (name, addrp)
778
 
779
/* Start an inferior process and set inferior_ptid to its pid.
780
   EXEC_FILE is the file to run.
781
   ALLARGS is a string containing the arguments to the program.
782
   ENV is the environment vector to pass.  Errors reported with error().
783
   On VxWorks and various standalone systems, we ignore exec_file.  */
784
 
785
#define target_create_inferior(exec_file, args, env, FROM_TTY)  \
786
     (*current_target.to_create_inferior) (exec_file, args, env, (FROM_TTY))
787
 
788
 
789
/* Some targets (such as ttrace-based HPUX) don't allow us to request
790
   notification of inferior events such as fork and vork immediately
791
   after the inferior is created.  (This because of how gdb gets an
792
   inferior created via invoking a shell to do it.  In such a scenario,
793
   if the shell init file has commands in it, the shell will fork and
794
   exec for each of those commands, and we will see each such fork
795
   event.  Very bad.)
796
 
797
   Such targets will supply an appropriate definition for this function.  */
798
 
799
#define target_post_startup_inferior(ptid) \
800
     (*current_target.to_post_startup_inferior) (ptid)
801
 
802
/* On some targets, the sequence of starting up an inferior requires
803
   some synchronization between gdb and the new inferior process, PID.  */
804
 
805
#define target_acknowledge_created_inferior(pid) \
806
     (*current_target.to_acknowledge_created_inferior) (pid)
807
 
808
/* On some targets, we can catch an inferior fork or vfork event when
809
   it occurs.  These functions insert/remove an already-created
810
   catchpoint for such events.  */
811
 
812
#define target_insert_fork_catchpoint(pid) \
813
     (*current_target.to_insert_fork_catchpoint) (pid)
814
 
815
#define target_remove_fork_catchpoint(pid) \
816
     (*current_target.to_remove_fork_catchpoint) (pid)
817
 
818
#define target_insert_vfork_catchpoint(pid) \
819
     (*current_target.to_insert_vfork_catchpoint) (pid)
820
 
821
#define target_remove_vfork_catchpoint(pid) \
822
     (*current_target.to_remove_vfork_catchpoint) (pid)
823
 
824
/* If the inferior forks or vforks, this function will be called at
825
   the next resume in order to perform any bookkeeping and fiddling
826
   necessary to continue debugging either the parent or child, as
827
   requested, and releasing the other.  Information about the fork
828
   or vfork event is available via get_last_target_status ().
829
   This function returns 1 if the inferior should not be resumed
830
   (i.e. there is another event pending).  */
831
 
832
int target_follow_fork (int follow_child);
833
 
834
/* On some targets, we can catch an inferior exec event when it
835
   occurs.  These functions insert/remove an already-created
836
   catchpoint for such events.  */
837
 
838
#define target_insert_exec_catchpoint(pid) \
839
     (*current_target.to_insert_exec_catchpoint) (pid)
840
 
841
#define target_remove_exec_catchpoint(pid) \
842
     (*current_target.to_remove_exec_catchpoint) (pid)
843
 
844
/* Returns the number of exec events that are reported when a process
845
   invokes a flavor of the exec() system call on this target, if exec
846
   events are being reported.  */
847
 
848
#define target_reported_exec_events_per_exec_call() \
849
     (*current_target.to_reported_exec_events_per_exec_call) ()
850
 
851
/* Returns TRUE if PID has exited.  And, also sets EXIT_STATUS to the
852
   exit code of PID, if any.  */
853
 
854
#define target_has_exited(pid,wait_status,exit_status) \
855
     (*current_target.to_has_exited) (pid,wait_status,exit_status)
856
 
857
/* The debugger has completed a blocking wait() call.  There is now
858
   some process event that must be processed.  This function should
859
   be defined by those targets that require the debugger to perform
860
   cleanup or internal state changes in response to the process event.  */
861
 
862
/* The inferior process has died.  Do what is right.  */
863
 
864
#define target_mourn_inferior() \
865
     (*current_target.to_mourn_inferior) ()
866
 
867
/* Does target have enough data to do a run or attach command? */
868
 
869
#define target_can_run(t) \
870
     ((t)->to_can_run) ()
871
 
872
/* post process changes to signal handling in the inferior.  */
873
 
874
#define target_notice_signals(ptid) \
875
     (*current_target.to_notice_signals) (ptid)
876
 
877
/* Check to see if a thread is still alive.  */
878
 
879
#define target_thread_alive(ptid) \
880
     (*current_target.to_thread_alive) (ptid)
881
 
882
/* Query for new threads and add them to the thread list.  */
883
 
884
#define target_find_new_threads() \
885
     (*current_target.to_find_new_threads) ()
886
 
887
/* Make target stop in a continuable fashion.  (For instance, under
888
   Unix, this should act like SIGSTOP).  This function is normally
889
   used by GUIs to implement a stop button.  */
890
 
891
#define target_stop current_target.to_stop
892
 
893
/* Send the specified COMMAND to the target's monitor
894
   (shell,interpreter) for execution.  The result of the query is
895
   placed in OUTBUF.  */
896
 
897
#define target_rcmd(command, outbuf) \
898
     (*current_target.to_rcmd) (command, outbuf)
899
 
900
 
901
/* Does the target include all of memory, or only part of it?  This
902
   determines whether we look up the target chain for other parts of
903
   memory if this target can't satisfy a request.  */
904
 
905
#define target_has_all_memory   \
906
     (current_target.to_has_all_memory)
907
 
908
/* Does the target include memory?  (Dummy targets don't.)  */
909
 
910
#define target_has_memory       \
911
     (current_target.to_has_memory)
912
 
913
/* Does the target have a stack?  (Exec files don't, VxWorks doesn't, until
914
   we start a process.)  */
915
 
916
#define target_has_stack        \
917
     (current_target.to_has_stack)
918
 
919
/* Does the target have registers?  (Exec files don't.)  */
920
 
921
#define target_has_registers    \
922
     (current_target.to_has_registers)
923
 
924
/* Does the target have execution?  Can we make it jump (through
925
   hoops), or pop its stack a few times?  This means that the current
926
   target is currently executing; for some targets, that's the same as
927
   whether or not the target is capable of execution, but there are
928
   also targets which can be current while not executing.  In that
929
   case this will become true after target_create_inferior or
930
   target_attach.  */
931
 
932
#define target_has_execution    \
933
     (current_target.to_has_execution)
934
 
935
/* Can the target support the debugger control of thread execution?
936
   a) Can it lock the thread scheduler?
937
   b) Can it switch the currently running thread?  */
938
 
939
#define target_can_lock_scheduler \
940
     (current_target.to_has_thread_control & tc_schedlock)
941
 
942
#define target_can_switch_threads \
943
     (current_target.to_has_thread_control & tc_switch)
944
 
945
/* Can the target support asynchronous execution? */
946
#define target_can_async_p() (current_target.to_can_async_p ())
947
 
948
/* Is the target in asynchronous execution mode? */
949
#define target_is_async_p() (current_target.to_is_async_p())
950
 
951
/* Put the target in async mode with the specified callback function. */
952
#define target_async(CALLBACK,CONTEXT) \
953
     (current_target.to_async((CALLBACK), (CONTEXT)))
954
 
955
/* This is to be used ONLY within call_function_by_hand(). It provides
956
   a workaround, to have inferior function calls done in sychronous
957
   mode, even though the target is asynchronous. After
958
   target_async_mask(0) is called, calls to target_can_async_p() will
959
   return FALSE , so that target_resume() will not try to start the
960
   target asynchronously. After the inferior stops, we IMMEDIATELY
961
   restore the previous nature of the target, by calling
962
   target_async_mask(1). After that, target_can_async_p() will return
963
   TRUE. ANY OTHER USE OF THIS FEATURE IS DEPRECATED.
964
 
965
   FIXME ezannoni 1999-12-13: we won't need this once we move
966
   the turning async on and off to the single execution commands,
967
   from where it is done currently, in remote_resume().  */
968
 
969
#define target_async_mask_value \
970
     (current_target.to_async_mask_value)
971
 
972
extern int target_async_mask (int mask);
973
 
974
/* Converts a process id to a string.  Usually, the string just contains
975
   `process xyz', but on some systems it may contain
976
   `process xyz thread abc'.  */
977
 
978
#undef target_pid_to_str
979
#define target_pid_to_str(PID) current_target.to_pid_to_str (PID)
980
 
981
#ifndef target_tid_to_str
982
#define target_tid_to_str(PID) \
983
     target_pid_to_str (PID)
984
extern char *normal_pid_to_str (ptid_t ptid);
985
#endif
986
 
987
/* Return a short string describing extra information about PID,
988
   e.g. "sleeping", "runnable", "running on LWP 3".  Null return value
989
   is okay.  */
990
 
991
#define target_extra_thread_info(TP) \
992
     (current_target.to_extra_thread_info (TP))
993
 
994
/* Attempts to find the pathname of the executable file
995
   that was run to create a specified process.
996
 
997
   The process PID must be stopped when this operation is used.
998
 
999
   If the executable file cannot be determined, NULL is returned.
1000
 
1001
   Else, a pointer to a character string containing the pathname
1002
   is returned.  This string should be copied into a buffer by
1003
   the client if the string will not be immediately used, or if
1004
   it must persist.  */
1005
 
1006
#define target_pid_to_exec_file(pid) \
1007
     (current_target.to_pid_to_exec_file) (pid)
1008
 
1009
/*
1010
 * Iterator function for target memory regions.
1011
 * Calls a callback function once for each memory region 'mapped'
1012
 * in the child process.  Defined as a simple macro rather than
1013
 * as a function macro so that it can be tested for nullity.
1014
 */
1015
 
1016
#define target_find_memory_regions(FUNC, DATA) \
1017
     (current_target.to_find_memory_regions) (FUNC, DATA)
1018
 
1019
/*
1020
 * Compose corefile .note section.
1021
 */
1022
 
1023
#define target_make_corefile_notes(BFD, SIZE_P) \
1024
     (current_target.to_make_corefile_notes) (BFD, SIZE_P)
1025
 
1026
/* Thread-local values.  */
1027
#define target_get_thread_local_address \
1028
    (current_target.to_get_thread_local_address)
1029
#define target_get_thread_local_address_p() \
1030
    (target_get_thread_local_address != NULL)
1031
 
1032
 
1033
/* Hardware watchpoint interfaces.  */
1034
 
1035
/* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
1036
   write).  */
1037
 
1038
#ifndef STOPPED_BY_WATCHPOINT
1039
#define STOPPED_BY_WATCHPOINT(w) \
1040
   (*current_target.to_stopped_by_watchpoint) ()
1041
#endif
1042
 
1043
/* Non-zero if we have steppable watchpoints  */
1044
 
1045
#ifndef HAVE_STEPPABLE_WATCHPOINT
1046
#define HAVE_STEPPABLE_WATCHPOINT \
1047
   (current_target.to_have_steppable_watchpoint)
1048
#endif
1049
 
1050
/* Non-zero if we have continuable watchpoints  */
1051
 
1052
#ifndef HAVE_CONTINUABLE_WATCHPOINT
1053
#define HAVE_CONTINUABLE_WATCHPOINT \
1054
   (current_target.to_have_continuable_watchpoint)
1055
#endif
1056
 
1057
/* Provide defaults for hardware watchpoint functions.  */
1058
 
1059
/* If the *_hw_beakpoint functions have not been defined
1060
   elsewhere use the definitions in the target vector.  */
1061
 
1062
/* Returns non-zero if we can set a hardware watchpoint of type TYPE.  TYPE is
1063
   one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, or
1064
   bp_hardware_breakpoint.  CNT is the number of such watchpoints used so far
1065
   (including this one?).  OTHERTYPE is who knows what...  */
1066
 
1067
#ifndef TARGET_CAN_USE_HARDWARE_WATCHPOINT
1068
#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(TYPE,CNT,OTHERTYPE) \
1069
 (*current_target.to_can_use_hw_breakpoint) (TYPE, CNT, OTHERTYPE);
1070
#endif
1071
 
1072
#ifndef TARGET_REGION_OK_FOR_HW_WATCHPOINT
1073
#define TARGET_REGION_OK_FOR_HW_WATCHPOINT(addr, len) \
1074
    (*current_target.to_region_ok_for_hw_watchpoint) (addr, len)
1075
#endif
1076
 
1077
 
1078
/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes.  TYPE is 0
1079
   for write, 1 for read, and 2 for read/write accesses.  Returns 0 for
1080
   success, non-zero for failure.  */
1081
 
1082
#ifndef target_insert_watchpoint
1083
#define target_insert_watchpoint(addr, len, type)       \
1084
     (*current_target.to_insert_watchpoint) (addr, len, type)
1085
 
1086
#define target_remove_watchpoint(addr, len, type)       \
1087
     (*current_target.to_remove_watchpoint) (addr, len, type)
1088
#endif
1089
 
1090
#ifndef target_insert_hw_breakpoint
1091
#define target_insert_hw_breakpoint(bp_tgt) \
1092
     (*current_target.to_insert_hw_breakpoint) (bp_tgt)
1093
 
1094
#define target_remove_hw_breakpoint(bp_tgt) \
1095
     (*current_target.to_remove_hw_breakpoint) (bp_tgt)
1096
#endif
1097
 
1098
extern int target_stopped_data_address_p (struct target_ops *);
1099
 
1100
#ifndef target_stopped_data_address
1101
#define target_stopped_data_address(target, x) \
1102
    (*target.to_stopped_data_address) (target, x)
1103
#else
1104
/* Horrible hack to get around existing macros :-(.  */
1105
#define target_stopped_data_address_p(CURRENT_TARGET) (1)
1106
#endif
1107
 
1108
extern const struct target_desc *target_read_description (struct target_ops *);
1109
 
1110
/* Command logging facility.  */
1111
 
1112
#define target_log_command(p)                                           \
1113
  do                                                                    \
1114
    if (current_target.to_log_command)                                  \
1115
      (*current_target.to_log_command) (p);                             \
1116
  while (0)
1117
 
1118
/* Routines for maintenance of the target structures...
1119
 
1120
   add_target:   Add a target to the list of all possible targets.
1121
 
1122
   push_target:  Make this target the top of the stack of currently used
1123
   targets, within its particular stratum of the stack.  Result
1124
   is 0 if now atop the stack, nonzero if not on top (maybe
1125
   should warn user).
1126
 
1127
   unpush_target: Remove this from the stack of currently used targets,
1128
   no matter where it is on the list.  Returns 0 if no
1129
   change, 1 if removed from stack.
1130
 
1131
   pop_target:   Remove the top thing on the stack of current targets.  */
1132
 
1133
extern void add_target (struct target_ops *);
1134
 
1135
extern int push_target (struct target_ops *);
1136
 
1137
extern int unpush_target (struct target_ops *);
1138
 
1139
extern void target_pre_inferior (int);
1140
 
1141
extern void target_preopen (int);
1142
 
1143
extern void pop_target (void);
1144
 
1145
extern CORE_ADDR target_translate_tls_address (struct objfile *objfile,
1146
                                               CORE_ADDR offset);
1147
 
1148
/* Mark a pushed target as running or exited, for targets which do not
1149
   automatically pop when not active.  */
1150
 
1151
void target_mark_running (struct target_ops *);
1152
 
1153
void target_mark_exited (struct target_ops *);
1154
 
1155
/* Struct section_table maps address ranges to file sections.  It is
1156
   mostly used with BFD files, but can be used without (e.g. for handling
1157
   raw disks, or files not in formats handled by BFD).  */
1158
 
1159
struct section_table
1160
  {
1161
    CORE_ADDR addr;             /* Lowest address in section */
1162
    CORE_ADDR endaddr;          /* 1+highest address in section */
1163
 
1164
    struct bfd_section *the_bfd_section;
1165
 
1166
    bfd *bfd;                   /* BFD file pointer */
1167
  };
1168
 
1169
/* Return the "section" containing the specified address.  */
1170
struct section_table *target_section_by_addr (struct target_ops *target,
1171
                                              CORE_ADDR addr);
1172
 
1173
 
1174
/* From mem-break.c */
1175
 
1176
extern int memory_remove_breakpoint (struct bp_target_info *);
1177
 
1178
extern int memory_insert_breakpoint (struct bp_target_info *);
1179
 
1180
extern int default_memory_remove_breakpoint (struct gdbarch *, struct bp_target_info *);
1181
 
1182
extern int default_memory_insert_breakpoint (struct gdbarch *, struct bp_target_info *);
1183
 
1184
 
1185
/* From target.c */
1186
 
1187
extern void initialize_targets (void);
1188
 
1189
extern void noprocess (void);
1190
 
1191
extern void find_default_attach (char *, int);
1192
 
1193
extern void find_default_create_inferior (char *, char *, char **, int);
1194
 
1195
extern struct target_ops *find_run_target (void);
1196
 
1197
extern struct target_ops *find_core_target (void);
1198
 
1199
extern struct target_ops *find_target_beneath (struct target_ops *);
1200
 
1201
extern int target_resize_to_sections (struct target_ops *target,
1202
                                      int num_added);
1203
 
1204
extern void remove_target_sections (bfd *abfd);
1205
 
1206
 
1207
/* Stuff that should be shared among the various remote targets.  */
1208
 
1209
/* Debugging level.  0 is off, and non-zero values mean to print some debug
1210
   information (higher values, more information).  */
1211
extern int remote_debug;
1212
 
1213
/* Speed in bits per second, or -1 which means don't mess with the speed.  */
1214
extern int baud_rate;
1215
/* Timeout limit for response from target. */
1216
extern int remote_timeout;
1217
 
1218
 
1219
/* Functions for helping to write a native target.  */
1220
 
1221
/* This is for native targets which use a unix/POSIX-style waitstatus.  */
1222
extern void store_waitstatus (struct target_waitstatus *, int);
1223
 
1224
/* Predicate to target_signal_to_host(). Return non-zero if the enum
1225
   targ_signal SIGNO has an equivalent ``host'' representation.  */
1226
/* FIXME: cagney/1999-11-22: The name below was chosen in preference
1227
   to the shorter target_signal_p() because it is far less ambigious.
1228
   In this context ``target_signal'' refers to GDB's internal
1229
   representation of the target's set of signals while ``host signal''
1230
   refers to the target operating system's signal.  Confused?  */
1231
 
1232
extern int target_signal_to_host_p (enum target_signal signo);
1233
 
1234
/* Convert between host signal numbers and enum target_signal's.
1235
   target_signal_to_host() returns 0 and prints a warning() on GDB's
1236
   console if SIGNO has no equivalent host representation.  */
1237
/* FIXME: cagney/1999-11-22: Here ``host'' is used incorrectly, it is
1238
   refering to the target operating system's signal numbering.
1239
   Similarly, ``enum target_signal'' is named incorrectly, ``enum
1240
   gdb_signal'' would probably be better as it is refering to GDB's
1241
   internal representation of a target operating system's signal.  */
1242
 
1243
extern enum target_signal target_signal_from_host (int);
1244
extern int target_signal_to_host (enum target_signal);
1245
 
1246
/* Convert from a number used in a GDB command to an enum target_signal.  */
1247
extern enum target_signal target_signal_from_command (int);
1248
 
1249
/* Any target can call this to switch to remote protocol (in remote.c). */
1250
extern void push_remote_target (char *name, int from_tty);
1251
 
1252
/* Imported from machine dependent code */
1253
 
1254
/* Blank target vector entries are initialized to target_ignore. */
1255
void target_ignore (void);
1256
 
1257
extern struct target_ops deprecated_child_ops;
1258
 
1259
#endif /* !defined (TARGET_H) */

powered by: WebSVN 2.1.0

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