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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [inferior.h] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Variables that describe the inferior process running under GDB:
2
   Where it is, why it stopped, and how to step it.
3
 
4
   Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
5
   1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
6
   Free Software Foundation, Inc.
7
 
8
   This file is part of GDB.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
 
23
#if !defined (INFERIOR_H)
24
#define INFERIOR_H 1
25
 
26
struct target_waitstatus;
27
struct frame_info;
28
struct ui_file;
29
struct type;
30
struct gdbarch;
31
struct regcache;
32
struct ui_out;
33
struct terminal_info;
34
 
35
/* For bpstat.  */
36
#include "breakpoint.h"
37
 
38
/* For enum target_signal.  */
39
#include "target.h"
40
 
41
/* For struct frame_id.  */
42
#include "frame.h"
43
 
44
#include "progspace.h"
45
 
46
/* Two structures are used to record inferior state.
47
 
48
   inferior_thread_state contains state about the program itself like its
49
   registers and any signal it received when it last stopped.
50
   This state must be restored regardless of how the inferior function call
51
   ends (either successfully, or after it hits a breakpoint or signal)
52
   if the program is to properly continue where it left off.
53
 
54
   inferior_status contains state regarding gdb's control of the inferior
55
   itself like stepping control.  It also contains session state like the
56
   user's currently selected frame.
57
 
58
   Call these routines around hand called functions, including function calls
59
   in conditional breakpoints for example.  */
60
 
61
struct inferior_thread_state;
62
struct inferior_status;
63
 
64
extern struct inferior_thread_state *save_inferior_thread_state (void);
65
extern struct inferior_status *save_inferior_status (void);
66
 
67
extern void restore_inferior_thread_state (struct inferior_thread_state *);
68
extern void restore_inferior_status (struct inferior_status *);
69
 
70
extern struct cleanup *make_cleanup_restore_inferior_thread_state (struct inferior_thread_state *);
71
extern struct cleanup *make_cleanup_restore_inferior_status (struct inferior_status *);
72
 
73
extern void discard_inferior_thread_state (struct inferior_thread_state *);
74
extern void discard_inferior_status (struct inferior_status *);
75
 
76
extern struct regcache *get_inferior_thread_state_regcache (struct inferior_thread_state *);
77
 
78
/* The -1 ptid, often used to indicate either an error condition
79
   or a "don't care" condition, i.e, "run all threads."  */
80
extern ptid_t minus_one_ptid;
81
 
82
/* The null or zero ptid, often used to indicate no process. */
83
extern ptid_t null_ptid;
84
 
85
/* Attempt to find and return an existing ptid with the given PID, LWP,
86
   and TID components.  If none exists, create a new one and return
87
   that.  */
88
ptid_t ptid_build (int pid, long lwp, long tid);
89
 
90
/* Find/Create a ptid from just a pid. */
91
ptid_t pid_to_ptid (int pid);
92
 
93
/* Fetch the pid (process id) component from a ptid. */
94
int ptid_get_pid (ptid_t ptid);
95
 
96
/* Fetch the lwp (lightweight process) component from a ptid. */
97
long ptid_get_lwp (ptid_t ptid);
98
 
99
/* Fetch the tid (thread id) component from a ptid. */
100
long ptid_get_tid (ptid_t ptid);
101
 
102
/* Compare two ptids to see if they are equal */
103
extern int ptid_equal (ptid_t p1, ptid_t p2);
104
 
105
/* Return true if PTID represents a process id.  */
106
extern int ptid_is_pid (ptid_t ptid);
107
 
108
/* Save value of inferior_ptid so that it may be restored by
109
   a later call to do_cleanups().  Returns the struct cleanup
110
   pointer needed for later doing the cleanup.  */
111
extern struct cleanup * save_inferior_ptid (void);
112
 
113
extern void set_sigint_trap (void);
114
 
115
extern void clear_sigint_trap (void);
116
 
117
/* Set/get file name for default use for standard in/out in the inferior.  */
118
 
119
extern void set_inferior_io_terminal (const char *terminal_name);
120
extern const char *get_inferior_io_terminal (void);
121
 
122
/* Collected pid, tid, etc. of the debugged inferior.  When there's
123
   no inferior, PIDGET (inferior_ptid) will be 0. */
124
 
125
extern ptid_t inferior_ptid;
126
 
127
/* Are we simulating synchronous execution? This is used in async gdb
128
   to implement the 'run', 'continue' etc commands, which will not
129
   redisplay the prompt until the execution is actually over. */
130
extern int sync_execution;
131
 
132
/* Inferior environment. */
133
 
134
extern void clear_proceed_status (void);
135
 
136
extern void proceed (CORE_ADDR, enum target_signal, int);
137
 
138
extern int sched_multi;
139
 
140
/* When set, stop the 'step' command if we enter a function which has
141
   no line number information.  The normal behavior is that we step
142
   over such function.  */
143
extern int step_stop_if_no_debug;
144
 
145
/* If set, the inferior should be controlled in non-stop mode.  In
146
   this mode, each thread is controlled independently.  Execution
147
   commands apply only to the the selected thread by default, and stop
148
   events stop only the thread that had the event -- the other threads
149
   are kept running freely.  */
150
extern int non_stop;
151
 
152
/* If set (default), when following a fork, GDB will detach from one
153
   the fork branches, child or parent.  Exactly which branch is
154
   detached depends on 'set follow-fork-mode' setting.  */
155
extern int detach_fork;
156
 
157
extern void generic_mourn_inferior (void);
158
 
159
extern void terminal_save_ours (void);
160
 
161
extern void terminal_ours (void);
162
 
163
extern CORE_ADDR unsigned_pointer_to_address (struct gdbarch *gdbarch,
164
                                              struct type *type,
165
                                              const gdb_byte *buf);
166
extern void unsigned_address_to_pointer (struct gdbarch *gdbarch,
167
                                         struct type *type, gdb_byte *buf,
168
                                         CORE_ADDR addr);
169
extern CORE_ADDR signed_pointer_to_address (struct gdbarch *gdbarch,
170
                                            struct type *type,
171
                                            const gdb_byte *buf);
172
extern void address_to_signed_pointer (struct gdbarch *gdbarch,
173
                                       struct type *type, gdb_byte *buf,
174
                                       CORE_ADDR addr);
175
 
176
extern void wait_for_inferior (int treat_exec_as_sigtrap);
177
 
178
extern void fetch_inferior_event (void *);
179
 
180
extern void init_wait_for_inferior (void);
181
 
182
extern void close_exec_file (void);
183
 
184
extern void reopen_exec_file (void);
185
 
186
/* The `resume' routine should only be called in special circumstances.
187
   Normally, use `proceed', which handles a lot of bookkeeping.  */
188
 
189
extern void resume (int, enum target_signal);
190
 
191
/* From misc files */
192
 
193
extern void default_print_registers_info (struct gdbarch *gdbarch,
194
                                          struct ui_file *file,
195
                                          struct frame_info *frame,
196
                                          int regnum, int all);
197
 
198
extern void child_terminal_info (char *, int);
199
 
200
extern void term_info (char *, int);
201
 
202
extern void terminal_ours_for_output (void);
203
 
204
extern void terminal_inferior (void);
205
 
206
extern void terminal_init_inferior (void);
207
 
208
extern void terminal_init_inferior_with_pgrp (int pgrp);
209
 
210
/* From fork-child.c */
211
 
212
extern int fork_inferior (char *, char *, char **,
213
                          void (*)(void),
214
                          void (*)(int), void (*)(void), char *);
215
 
216
 
217
extern void startup_inferior (int);
218
 
219
extern char *construct_inferior_arguments (int, char **);
220
 
221
/* From infrun.c */
222
 
223
extern void start_remote (int from_tty);
224
 
225
extern void normal_stop (void);
226
 
227
extern int signal_stop_state (int);
228
 
229
extern int signal_print_state (int);
230
 
231
extern int signal_pass_state (int);
232
 
233
extern int signal_stop_update (int, int);
234
 
235
extern int signal_print_update (int, int);
236
 
237
extern int signal_pass_update (int, int);
238
 
239
extern void get_last_target_status(ptid_t *ptid,
240
                                   struct target_waitstatus *status);
241
 
242
extern void follow_inferior_reset_breakpoints (void);
243
 
244
/* Throw an error indicating the current thread is running.  */
245
extern void error_is_running (void);
246
 
247
/* Calls error_is_running if the current thread is running.  */
248
extern void ensure_not_running (void);
249
 
250
void set_step_info (struct frame_info *frame, struct symtab_and_line sal);
251
 
252
/* From infcmd.c */
253
 
254
extern void post_create_inferior (struct target_ops *, int);
255
 
256
extern void attach_command (char *, int);
257
 
258
extern char *get_inferior_args (void);
259
 
260
extern void set_inferior_args (char *);
261
 
262
extern void set_inferior_args_vector (int, char **);
263
 
264
extern void registers_info (char *, int);
265
 
266
extern void nexti_command (char *, int);
267
 
268
extern void stepi_command (char *, int);
269
 
270
extern void continue_1 (int all_threads);
271
 
272
extern void continue_command (char *, int);
273
 
274
extern void interrupt_target_command (char *args, int from_tty);
275
 
276
extern void interrupt_target_1 (int all_threads);
277
 
278
extern void detach_command (char *, int);
279
 
280
extern void notice_new_inferior (ptid_t, int, int);
281
 
282
/* Address at which inferior stopped.  */
283
 
284
extern CORE_ADDR stop_pc;
285
 
286
/* Nonzero if stopped due to completion of a stack dummy routine.  */
287
 
288
extern int stop_stack_dummy;
289
 
290
/* Nonzero if program stopped due to a random (unexpected) signal in
291
   inferior process.  */
292
 
293
extern int stopped_by_random_signal;
294
 
295
/* STEP_OVER_ALL means step over all subroutine calls.
296
   STEP_OVER_UNDEBUGGABLE means step over calls to undebuggable functions.
297
   STEP_OVER_NONE means don't step over any subroutine calls.  */
298
 
299
enum step_over_calls_kind
300
  {
301
    STEP_OVER_NONE,
302
    STEP_OVER_ALL,
303
    STEP_OVER_UNDEBUGGABLE
304
  };
305
 
306
/* Anything but NO_STOP_QUIETLY means we expect a trap and the caller
307
   will handle it themselves.  STOP_QUIETLY is used when running in
308
   the shell before the child program has been exec'd and when running
309
   through shared library loading.  STOP_QUIETLY_REMOTE is used when
310
   setting up a remote connection; it is like STOP_QUIETLY_NO_SIGSTOP
311
   except that there is no need to hide a signal.  */
312
 
313
/* It is also used after attach, due to attaching to a process. This
314
   is a bit trickier.  When doing an attach, the kernel stops the
315
   debuggee with a SIGSTOP.  On newer GNU/Linux kernels (>= 2.5.61)
316
   the handling of SIGSTOP for a ptraced process has changed. Earlier
317
   versions of the kernel would ignore these SIGSTOPs, while now
318
   SIGSTOP is treated like any other signal, i.e. it is not muffled.
319
 
320
   If the gdb user does a 'continue' after the 'attach', gdb passes
321
   the global variable stop_signal (which stores the signal from the
322
   attach, SIGSTOP) to the ptrace(PTRACE_CONT,...)  call.  This is
323
   problematic, because the kernel doesn't ignore such SIGSTOP
324
   now. I.e. it is reported back to gdb, which in turn presents it
325
   back to the user.
326
 
327
   To avoid the problem, we use STOP_QUIETLY_NO_SIGSTOP, which allows
328
   gdb to clear the value of stop_signal after the attach, so that it
329
   is not passed back down to the kernel.  */
330
 
331
enum stop_kind
332
  {
333
    NO_STOP_QUIETLY = 0,
334
    STOP_QUIETLY,
335
    STOP_QUIETLY_REMOTE,
336
    STOP_QUIETLY_NO_SIGSTOP
337
  };
338
 
339
/* Reverse execution.  */
340
enum exec_direction_kind
341
  {
342
    EXEC_FORWARD,
343
    EXEC_REVERSE,
344
    EXEC_ERROR
345
  };
346
 
347
extern enum exec_direction_kind execution_direction;
348
 
349
/* Save register contents here when executing a "finish" command or are
350
   about to pop a stack dummy frame, if-and-only-if proceed_to_finish is set.
351
   Thus this contains the return value from the called function (assuming
352
   values are returned in a register).  */
353
 
354
extern struct regcache *stop_registers;
355
 
356
/* True if we are debugging displaced stepping.  */
357
extern int debug_displaced;
358
 
359
/* Dump LEN bytes at BUF in hex to FILE, followed by a newline.  */
360
void displaced_step_dump_bytes (struct ui_file *file,
361
                                const gdb_byte *buf, size_t len);
362
 
363
 
364
/* Possible values for gdbarch_call_dummy_location.  */
365
#define ON_STACK 1
366
#define AT_ENTRY_POINT 4
367
#define AT_SYMBOL 5
368
 
369
/* If STARTUP_WITH_SHELL is set, GDB's "run"
370
   will attempts to start up the debugee under a shell.
371
   This is in order for argument-expansion to occur. E.g.,
372
   (gdb) run *
373
   The "*" gets expanded by the shell into a list of files.
374
   While this is a nice feature, it turns out to interact badly
375
   with some of the catch-fork/catch-exec features we have added.
376
   In particular, if the shell does any fork/exec's before
377
   the exec of the target program, that can confuse GDB.
378
   To disable this feature, set STARTUP_WITH_SHELL to 0.
379
   To enable this feature, set STARTUP_WITH_SHELL to 1.
380
   The catch-exec traps expected during start-up will
381
   be 1 if target is not started up with a shell, 2 if it is.
382
   - RT
383
   If you disable this, you need to decrement
384
   START_INFERIOR_TRAPS_EXPECTED in tm.h. */
385
#define STARTUP_WITH_SHELL 1
386
#if !defined(START_INFERIOR_TRAPS_EXPECTED)
387
#define START_INFERIOR_TRAPS_EXPECTED   2
388
#endif
389
 
390
struct private_inferior;
391
 
392
/* GDB represents the state of each program execution with an object
393
   called an inferior.  An inferior typically corresponds to a process
394
   but is more general and applies also to targets that do not have a
395
   notion of processes.  Each run of an executable creates a new
396
   inferior, as does each attachment to an existing process.
397
   Inferiors have unique internal identifiers that are different from
398
   target process ids.  Each inferior may in turn have multiple
399
   threads running in it.  */
400
 
401
struct inferior
402
{
403
  /* Pointer to next inferior in singly-linked list of inferiors.  */
404
  struct inferior *next;
405
 
406
  /* Convenient handle (GDB inferior id).  Unique across all
407
     inferiors.  */
408
  int num;
409
 
410
  /* Actual target inferior id, usually, a process id.  This matches
411
     the ptid_t.pid member of threads of this inferior.  */
412
  int pid;
413
 
414
  /* True if this was an auto-created inferior, e.g. created from
415
     following a fork; false, if this inferior was manually added by
416
     the user, and we should not attempt to prune it
417
     automatically.  */
418
  int removable;
419
 
420
  /* The address space bound to this inferior.  */
421
  struct address_space *aspace;
422
 
423
  /* The program space bound to this inferior.  */
424
  struct program_space *pspace;
425
 
426
  /* The arguments string to use when running.  */
427
  char *args;
428
 
429
  /* The size of elements in argv.  */
430
  int argc;
431
 
432
  /* The vector version of arguments.  If ARGC is nonzero,
433
     then we must compute ARGS from this (via the target).
434
     This is always coming from main's argv and therefore
435
     should never be freed.  */
436
  char **argv;
437
 
438
  /* The name of terminal device to use for I/O.  */
439
  char *terminal;
440
 
441
  /* Environment to use for running inferior,
442
     in format described in environ.h.  */
443
  struct gdb_environ *environment;
444
 
445
  /* See the definition of stop_kind above.  */
446
  enum stop_kind stop_soon;
447
 
448
  /* Nonzero if this child process was attached rather than
449
     forked.  */
450
  int attach_flag;
451
 
452
  /* If this inferior is a vfork child, then this is the pointer to
453
     its vfork parent, if GDB is still attached to it.  */
454
  struct inferior *vfork_parent;
455
 
456
  /* If this process is a vfork parent, this is the pointer to the
457
     child.  Since a vfork parent is left frozen by the kernel until
458
     the child execs or exits, a process can only have one vfork child
459
     at a given time.  */
460
  struct inferior *vfork_child;
461
 
462
  /* True if this inferior should be detached when it's vfork sibling
463
     exits or execs.  */
464
  int pending_detach;
465
 
466
  /* True if this inferior is a vfork parent waiting for a vfork child
467
     not under our control to be done with the shared memory region,
468
     either by exiting or execing.  */
469
  int waiting_for_vfork_done;
470
 
471
  /* What is left to do for an execution command after any thread of
472
     this inferior stops.  For continuations associated with a
473
     specific thread, see `struct thread_info'.  */
474
  struct continuation *continuations;
475
 
476
  /* Private data used by the target vector implementation.  */
477
  struct private_inferior *private;
478
 
479
  /* We keep a count of the number of times the user has requested a
480
     particular syscall to be tracked, and pass this information to the
481
     target.  This lets capable targets implement filtering directly.  */
482
 
483
  /* Number of times that "any" syscall is requested.  */
484
  int any_syscall_count;
485
 
486
  /* Count of each system call.  */
487
  VEC(int) *syscalls_counts;
488
 
489
  /* This counts all syscall catch requests, so we can readily determine
490
     if any catching is necessary.  */
491
  int total_syscalls_count;
492
 
493
  /* Per inferior data-pointers required by other GDB modules.  */
494
  void **data;
495
  unsigned num_data;
496
};
497
 
498
/* Keep a registry of per-inferior data-pointers required by other GDB
499
   modules.  */
500
 
501
extern const struct inferior_data *register_inferior_data (void);
502
extern const struct inferior_data *register_inferior_data_with_cleanup
503
  (void (*cleanup) (struct inferior *, void *));
504
extern void clear_inferior_data (struct inferior *inf);
505
extern void set_inferior_data (struct inferior *inf,
506
                               const struct inferior_data *data, void *value);
507
extern void *inferior_data (struct inferior *inf,
508
                            const struct inferior_data *data);
509
 
510
/* Create an empty inferior list, or empty the existing one.  */
511
extern void init_inferior_list (void);
512
 
513
/* Add an inferior to the inferior list, print a message that a new
514
   inferior is found, and return the pointer to the new inferior.
515
   Caller may use this pointer to initialize the private inferior
516
   data.  */
517
extern struct inferior *add_inferior (int pid);
518
 
519
/* Same as add_inferior, but don't print new inferior notifications to
520
   the CLI.  */
521
extern struct inferior *add_inferior_silent (int pid);
522
 
523
/* Delete an existing inferior list entry, due to inferior exit.  */
524
extern void delete_inferior (int pid);
525
 
526
/* Same as delete_inferior, but don't print new inferior notifications
527
   to the CLI.  */
528
extern void delete_inferior_silent (int pid);
529
 
530
/* Delete an existing inferior list entry, due to inferior detaching.  */
531
extern void detach_inferior (int pid);
532
 
533
extern void exit_inferior (int pid);
534
 
535
extern void exit_inferior_silent (int pid);
536
 
537
extern void exit_inferior_num_silent (int num);
538
 
539
extern void inferior_appeared (struct inferior *inf, int pid);
540
 
541
/* Get rid of all inferiors.  */
542
extern void discard_all_inferiors (void);
543
 
544
/* Translate the integer inferior id (GDB's homegrown id, not the system's)
545
   into a "pid" (which may be overloaded with extra inferior information).  */
546
extern int gdb_inferior_id_to_pid (int);
547
 
548
/* Translate a target 'pid' into the integer inferior id (GDB's
549
   homegrown id, not the system's).  */
550
extern int pid_to_gdb_inferior_id (int pid);
551
 
552
/* Boolean test for an already-known pid.  */
553
extern int in_inferior_list (int pid);
554
 
555
/* Boolean test for an already-known inferior id (GDB's homegrown id,
556
   not the system's).  */
557
extern int valid_gdb_inferior_id (int num);
558
 
559
/* Search function to lookup an inferior by target 'pid'.  */
560
extern struct inferior *find_inferior_pid (int pid);
561
 
562
/* Search function to lookup an inferior by GDB 'num'.  */
563
extern struct inferior *find_inferior_id (int num);
564
 
565
/* Find an inferior bound to PSPACE.  */
566
extern struct inferior *
567
  find_inferior_for_program_space (struct program_space *pspace);
568
 
569
/* Inferior iterator function.
570
 
571
   Calls a callback function once for each inferior, so long as the
572
   callback function returns false.  If the callback function returns
573
   true, the iteration will end and the current inferior will be
574
   returned.  This can be useful for implementing a search for a
575
   inferior with arbitrary attributes, or for applying some operation
576
   to every inferior.
577
 
578
   It is safe to delete the iterated inferior from the callback.  */
579
extern struct inferior *iterate_over_inferiors (int (*) (struct inferior *,
580
                                                         void *),
581
                                                void *);
582
 
583
/* Prints the list of inferiors and their details on UIOUT.
584
 
585
   If REQUESTED_INFERIOR is not -1, it's the GDB id of the inferior
586
   that should be printed.  Otherwise, all inferiors are printed.  */
587
extern void print_inferior (struct ui_out *uiout, int requested_inferior);
588
 
589
/* Returns true if the inferior list is not empty.  */
590
extern int have_inferiors (void);
591
 
592
/* Returns true if there are any live inferiors in the inferior list
593
   (not cores, not executables, real live processes).  */
594
extern int have_live_inferiors (void);
595
 
596
/* Return a pointer to the current inferior.  It is an error to call
597
   this if there is no current inferior.  */
598
extern struct inferior *current_inferior (void);
599
 
600
extern void set_current_inferior (struct inferior *);
601
 
602
extern struct cleanup *save_current_inferior (void);
603
 
604
extern struct inferior *inferior_list;
605
 
606
/* Prune away automatically added inferiors that aren't required
607
   anymore.  */
608
extern void prune_inferiors (void);
609
 
610
extern int number_of_inferiors (void);
611
 
612
#endif /* !defined (INFERIOR_H) */

powered by: WebSVN 2.1.0

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