gdb/inferior.h

   1 /* Variables that describe the inferior process running under GDB:
   2    Where it is, why it stopped, and how to step it.
   3    Copyright 1986, 1989, 1992, 1996, 1998 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #if !defined (INFERIOR_H)
  23 #define INFERIOR_H 1
  24
  25 /* For bpstat.  */
  26 #include "breakpoint.h"
  27
  28 /* For enum target_signal.  */
  29 #include "target.h"
  30
  31 /* Structure in which to save the status of the inferior.  Create/Save
  32    through "save_inferior_status", restore through
  33    "restore_inferior_status".
  34
  35    This pair of routines should be called around any transfer of
  36    control to the inferior which you don't want showing up in your
  37    control variables.  */
  38
  39 struct inferior_status;
  40
  41 extern struct inferior_status *save_inferior_status (int);
  42
  43 extern void restore_inferior_status (struct inferior_status *);
  44
  45 extern struct cleanup *make_cleanup_restore_inferior_status (struct inferior_status *);
  46
  47 extern void discard_inferior_status (struct inferior_status *);
  48
  49 extern void write_inferior_status_register (struct inferior_status
  50                                             *inf_status, int regno,
  51                                             LONGEST val);
  52
  53 /* This macro gives the number of registers actually in use by the
  54    inferior.  This may be less than the total number of registers,
  55    perhaps depending on the actual CPU in use or program being run.
  56    FIXME: This could be replaced by the new MULTI_ARCH capability.  */
  57
  58 #ifndef ARCH_NUM_REGS
  59 #define ARCH_NUM_REGS NUM_REGS
  60 #endif
  61
  62 /* This macro gives the number of pseudo-registers that live in the
  63    register namespace but do not get fetched or stored on the target.
  64    These pseudo-registers may be aliases for other registers,
  65    combinations of other registers, or they may be computed by GDB.
  66    FIXME: move into gdbarch.[ch] */
  67 #ifndef NUM_PSEUDO_REGS
  68 #define NUM_PSEUDO_REGS 0
  69 #endif
  70
  71 /* This function is called when the value of a pseudo-register needs
  72    to be updated.  Typically it will be defined on a per-architecture
  73    basis.  FIXME: move into gdbarch.[ch].  */
  74 #ifndef ARCH_FETCH_PSEUDO_REGISTERS
  75 #define ARCH_FETCH_PSEUDO_REGISTERS(REGNUM) /* no-op */
  76 #endif
  77
  78 /* This function is called when the value of a pseudo-register needs
  79    to be set or stored.  Typically it will be defined on a per-architecture
  80    basis.  FIXME: move into gdbarch.[ch].  */
  81 #ifndef ARCH_STORE_PSEUDO_REGISTERS
  82 #define ARCH_STORE_PSEUDO_REGISTERS(REGNUM) /* no-op */
  83 #endif
  84
  85 extern void set_sigint_trap (void);
  86
  87 extern void clear_sigint_trap (void);
  88
  89 extern void set_sigio_trap (void);
  90
  91 extern void clear_sigio_trap (void);
  92
  93 /* File name for default use for standard in/out in the inferior.  */
  94
  95 extern char *inferior_io_terminal;
  96
  97 /* Pid of our debugged inferior, or 0 if no inferior now.  */
  98
  99 extern int inferior_pid;
 100
 101 /* Is the inferior running right now, as a result of a 'run&',
 102    'continue&' etc command? This is used in asycn gdb to determine
 103    whether a command that the user enters while the target is running
 104    is allowed or not. */
 105 extern int target_executing;
 106
 107 /* Are we simulating synchronous execution? This is used in async gdb
 108    to implement the 'run', 'continue' etc commands, which will not
 109    redisplay the prompt until the execution is actually over. */
 110 extern int sync_execution;
 111
 112 /* This is only valid when inferior_pid is non-zero.
 113
 114    If this is 0, then exec events should be noticed and responded to
 115    by the debugger (i.e., be reported to the user).
 116
 117    If this is > 0, then that many subsequent exec events should be
 118    ignored (i.e., not be reported to the user).
 119  */
 120 extern int inferior_ignoring_startup_exec_events;
 121
 122 /* This is only valid when inferior_ignoring_startup_exec_events is
 123    zero.
 124
 125    Some targets (stupidly) report more than one exec event per actual
 126    call to an event() system call.  If only the last such exec event
 127    need actually be noticed and responded to by the debugger (i.e.,
 128    be reported to the user), then this is the number of "leading"
 129    exec events which should be ignored.
 130  */
 131 extern int inferior_ignoring_leading_exec_events;
 132
 133 /* Inferior environment. */
 134
 135 extern struct environ *inferior_environ;
 136
 137 /* Character array containing an image of the inferior programs'
 138    registers. */
 139
 140 extern char *registers;
 141
 142 /* Character array containing the current state of each register
 143    (unavailable<0, valid=0, invalid>0). */
 144
 145 extern signed char *register_valid;
 146
 147 extern void clear_proceed_status (void);
 148
 149 extern void proceed (CORE_ADDR, enum target_signal, int);
 150
 151 extern void kill_inferior (void);
 152
 153 extern void generic_mourn_inferior (void);
 154
 155 extern void terminal_ours (void);
 156
 157 extern int run_stack_dummy (CORE_ADDR, char *);
 158
 159 extern CORE_ADDR read_pc (void);
 160
 161 extern CORE_ADDR read_pc_pid (int);
 162
 163 extern CORE_ADDR generic_target_read_pc (int);
 164
 165 extern void write_pc (CORE_ADDR);
 166
 167 extern void write_pc_pid (CORE_ADDR, int);
 168
 169 extern void generic_target_write_pc (CORE_ADDR, int);
 170
 171 extern CORE_ADDR read_sp (void);
 172
 173 extern CORE_ADDR generic_target_read_sp (void);
 174
 175 extern void write_sp (CORE_ADDR);
 176
 177 extern void generic_target_write_sp (CORE_ADDR);
 178
 179 extern CORE_ADDR read_fp (void);
 180
 181 extern CORE_ADDR generic_target_read_fp (void);
 182
 183 extern void write_fp (CORE_ADDR);
 184
 185 extern void generic_target_write_fp (CORE_ADDR);
 186
 187 extern CORE_ADDR unsigned_pointer_to_address (struct type *type, void *buf);
 188
 189 extern void unsigned_address_to_pointer (struct type *type, void *buf,
 190                                          CORE_ADDR addr);
 191 extern CORE_ADDR signed_pointer_to_address (struct type *type, void *buf);
 192 extern void address_to_signed_pointer (struct type *type, void *buf,
 193                                        CORE_ADDR addr);
 194
 195 extern void wait_for_inferior (void);
 196
 197 extern void fetch_inferior_event (void *);
 198
 199 extern void init_wait_for_inferior (void);
 200
 201 extern void close_exec_file (void);
 202
 203 extern void reopen_exec_file (void);
 204
 205 /* The `resume' routine should only be called in special circumstances.
 206    Normally, use `proceed', which handles a lot of bookkeeping.  */
 207
 208 extern void resume (int, enum target_signal);
 209
 210 /* From misc files */
 211
 212 extern void store_inferior_registers (int);
 213
 214 extern void fetch_inferior_registers (int);
 215
 216 extern void solib_create_inferior_hook (void);
 217
 218 extern void child_terminal_info (char *, int);
 219
 220 extern void term_info (char *, int);
 221
 222 extern void terminal_ours_for_output (void);
 223
 224 extern void terminal_inferior (void);
 225
 226 extern void terminal_init_inferior (void);
 227
 228 extern void terminal_init_inferior_with_pgrp (int pgrp);
 229
 230 /* From infptrace.c or infttrace.c */
 231
 232 extern int attach (int);
 233
 234 #if !defined(REQUIRE_ATTACH)
 235 #define REQUIRE_ATTACH attach
 236 #endif
 237
 238 #if !defined(REQUIRE_DETACH)
 239 #define REQUIRE_DETACH(pid,siggnal) detach (siggnal)
 240 #endif
 241
 242 extern void detach (int);
 243
 244 /* PTRACE method of waiting for inferior process.  */
 245 int ptrace_wait (int, int *);
 246
 247 extern void child_resume (int, int, enum target_signal);
 248
 249 #ifndef PTRACE_ARG3_TYPE
 250 #define PTRACE_ARG3_TYPE int    /* Correct definition for most systems. */
 251 #endif
 252
 253 extern int call_ptrace (int, int, PTRACE_ARG3_TYPE, int);
 254
 255 extern void pre_fork_inferior (void);
 256
 257 /* From procfs.c */
 258
 259 extern int proc_iterate_over_mappings (int (*)(int, CORE_ADDR));
 260
 261 extern int procfs_first_available (void);
 262
 263 /* From fork-child.c */
 264
 265 extern void fork_inferior (char *, char *, char **,
 266                            void (*)(void),
 267                            void (*)(int), void (*)(void), char *);
 268
 269
 270 extern void clone_and_follow_inferior (int, int *);
 271
 272 extern void startup_inferior (int);
 273
 274 /* From inflow.c */
 275
 276 extern void new_tty_prefork (char *);
 277
 278 extern int gdb_has_a_terminal (void);
 279
 280 /* From infrun.c */
 281
 282 extern void start_remote (void);
 283
 284 extern void normal_stop (void);
 285
 286 extern int signal_stop_state (int);
 287
 288 extern int signal_print_state (int);
 289
 290 extern int signal_pass_state (int);
 291
 292 extern int signal_stop_update (int, int);
 293
 294 extern int signal_print_update (int, int);
 295
 296 extern int signal_pass_update (int, int);
 297
 298 /* From infcmd.c */
 299
 300 extern void tty_command (char *, int);
 301
 302 extern void attach_command (char *, int);
 303
 304 /* Last signal that the inferior received (why it stopped).  */
 305
 306 extern enum target_signal stop_signal;
 307
 308 /* Address at which inferior stopped.  */
 309
 310 extern CORE_ADDR stop_pc;
 311
 312 /* Chain containing status of breakpoint(s) that we have stopped at.  */
 313
 314 extern bpstat stop_bpstat;
 315
 316 /* Flag indicating that a command has proceeded the inferior past the
 317    current breakpoint.  */
 318
 319 extern int breakpoint_proceeded;
 320
 321 /* Nonzero if stopped due to a step command.  */
 322
 323 extern int stop_step;
 324
 325 /* Nonzero if stopped due to completion of a stack dummy routine.  */
 326
 327 extern int stop_stack_dummy;
 328
 329 /* Nonzero if program stopped due to a random (unexpected) signal in
 330    inferior process.  */
 331
 332 extern int stopped_by_random_signal;
 333
 334 /* Range to single step within.
 335    If this is nonzero, respond to a single-step signal
 336    by continuing to step if the pc is in this range.
 337
 338    If step_range_start and step_range_end are both 1, it means to step for
 339    a single instruction (FIXME: it might clean up wait_for_inferior in a
 340    minor way if this were changed to the address of the instruction and
 341    that address plus one.  But maybe not.).  */
 342
 343 extern CORE_ADDR step_range_start;      /* Inclusive */
 344 extern CORE_ADDR step_range_end;        /* Exclusive */
 345
 346 /* Stack frame address as of when stepping command was issued.
 347    This is how we know when we step into a subroutine call,
 348    and how to set the frame for the breakpoint used to step out.  */
 349
 350 extern CORE_ADDR step_frame_address;
 351
 352 /* Our notion of the current stack pointer.  */
 353
 354 extern CORE_ADDR step_sp;
 355
 356 /* 1 means step over all subroutine calls.
 357    -1 means step over calls to undebuggable functions.  */
 358
 359 extern int step_over_calls;
 360
 361 /* If stepping, nonzero means step count is > 1
 362    so don't print frame next time inferior stops
 363    if it stops due to stepping.  */
 364
 365 extern int step_multi;
 366
 367 /* Nonzero means expecting a trap and caller will handle it themselves.
 368    It is used after attach, due to attaching to a process;
 369    when running in the shell before the child program has been exec'd;
 370    and when running some kinds of remote stuff (FIXME?).  */
 371
 372 extern int stop_soon_quietly;
 373
 374 /* Nonzero if proceed is being used for a "finish" command or a similar
 375    situation when stop_registers should be saved.  */
 376
 377 extern int proceed_to_finish;
 378
 379 /* Save register contents here when about to pop a stack dummy frame,
 380    if-and-only-if proceed_to_finish is set.
 381    Thus this contains the return value from the called function (assuming
 382    values are returned in a register).  */
 383
 384 extern char *stop_registers;
 385
 386 /* Nonzero if the child process in inferior_pid was attached rather
 387    than forked.  */
 388
 389 extern int attach_flag;
 390 \f
 391 /* Sigtramp is a routine that the kernel calls (which then calls the
 392    signal handler).  On most machines it is a library routine that
 393    is linked into the executable.
 394
 395    This macro, given a program counter value and the name of the
 396    function in which that PC resides (which can be null if the
 397    name is not known), returns nonzero if the PC and name show
 398    that we are in sigtramp.
 399
 400    On most machines just see if the name is sigtramp (and if we have
 401    no name, assume we are not in sigtramp).  */
 402 #if !defined (IN_SIGTRAMP)
 403 #if defined (SIGTRAMP_START)
 404 #define IN_SIGTRAMP(pc, name) \
 405        ((pc) >= SIGTRAMP_START(pc)   \
 406         && (pc) < SIGTRAMP_END(pc) \
 407         )
 408 #else
 409 #define IN_SIGTRAMP(pc, name) \
 410        (name && STREQ ("_sigtramp", name))
 411 #endif
 412 #endif
 413 \f
 414 /* Possible values for CALL_DUMMY_LOCATION.  */
 415 #define ON_STACK 1
 416 #define BEFORE_TEXT_END 2
 417 #define AFTER_TEXT_END 3
 418 #define AT_ENTRY_POINT 4
 419
 420 #if !defined (USE_GENERIC_DUMMY_FRAMES)
 421 #define USE_GENERIC_DUMMY_FRAMES 0
 422 #endif
 423
 424 #if !defined (CALL_DUMMY_LOCATION)
 425 #define CALL_DUMMY_LOCATION ON_STACK
 426 #endif /* No CALL_DUMMY_LOCATION.  */
 427
 428 #if !defined (CALL_DUMMY_ADDRESS)
 429 #define CALL_DUMMY_ADDRESS() (internal_error ("CALL_DUMMY_ADDRESS"), 0)
 430 #endif
 431 #if !defined (CALL_DUMMY_START_OFFSET)
 432 #define CALL_DUMMY_START_OFFSET (internal_error ("CALL_DUMMY_START_OFFSET"), 0)
 433 #endif
 434 #if !defined (CALL_DUMMY_BREAKPOINT_OFFSET)
 435 #define CALL_DUMMY_BREAKPOINT_OFFSET_P (0)
 436 #define CALL_DUMMY_BREAKPOINT_OFFSET (internal_error ("CALL_DUMMY_BREAKPOINT_OFFSET"), 0)
 437 #endif
 438 #if !defined CALL_DUMMY_BREAKPOINT_OFFSET_P
 439 #define CALL_DUMMY_BREAKPOINT_OFFSET_P (1)
 440 #endif
 441 #if !defined (CALL_DUMMY_LENGTH)
 442 #define CALL_DUMMY_LENGTH (internal_error ("CALL_DUMMY_LENGTH"), 0)
 443 #endif
 444
 445 #if defined (CALL_DUMMY_STACK_ADJUST)
 446 #if !defined (CALL_DUMMY_STACK_ADJUST_P)
 447 #define CALL_DUMMY_STACK_ADJUST_P (1)
 448 #endif
 449 #endif
 450 #if !defined (CALL_DUMMY_STACK_ADJUST)
 451 #define CALL_DUMMY_STACK_ADJUST (internal_error ("CALL_DUMMY_STACK_ADJUST"), 0)
 452 #endif
 453 #if !defined (CALL_DUMMY_STACK_ADJUST_P)
 454 #define CALL_DUMMY_STACK_ADJUST_P (0)
 455 #endif
 456
 457 /* FIXME: cagney/2000-04-17: gdbarch should manage this.  The default
 458    shouldn't be necessary. */
 459
 460 #if !defined (CALL_DUMMY_P)
 461 #if defined (CALL_DUMMY)
 462 #define CALL_DUMMY_P 1
 463 #else
 464 #define CALL_DUMMY_P 0
 465 #endif
 466 #endif
 467
 468 #if !defined PUSH_DUMMY_FRAME
 469 #define PUSH_DUMMY_FRAME (internal_error ("PUSH_DUMMY_FRAME"), 0)
 470 #endif
 471
 472 #if !defined FIX_CALL_DUMMY
 473 #define FIX_CALL_DUMMY(a1,a2,a3,a4,a5,a6,a7) (internal_error ("FIX_CALL_DUMMY"), 0)
 474 #endif
 475
 476 #if !defined STORE_STRUCT_RETURN
 477 #define STORE_STRUCT_RETURN(a1,a2) (internal_error ("STORE_STRUCT_RETURN"), 0)
 478 #endif
 479
 480
 481 /* Are we in a call dummy? */
 482
 483 extern int pc_in_call_dummy_before_text_end (CORE_ADDR pc, CORE_ADDR sp,
 484                                              CORE_ADDR frame_address);
 485 #if !GDB_MULTI_ARCH
 486 #if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == BEFORE_TEXT_END
 487 #define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_before_text_end (pc, sp, frame_address)
 488 #endif /* Before text_end.  */
 489 #endif
 490
 491 extern int pc_in_call_dummy_after_text_end (CORE_ADDR pc, CORE_ADDR sp,
 492                                             CORE_ADDR frame_address);
 493 #if !GDB_MULTI_ARCH
 494 #if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == AFTER_TEXT_END
 495 #define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_after_text_end (pc, sp, frame_address)
 496 #endif
 497 #endif
 498
 499 extern int pc_in_call_dummy_on_stack (CORE_ADDR pc, CORE_ADDR sp,
 500                                       CORE_ADDR frame_address);
 501 #if !GDB_MULTI_ARCH
 502 #if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == ON_STACK
 503 #define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_on_stack (pc, sp, frame_address)
 504 #endif
 505 #endif
 506
 507 extern int pc_in_call_dummy_at_entry_point (CORE_ADDR pc, CORE_ADDR sp,
 508                                             CORE_ADDR frame_address);
 509 #if !GDB_MULTI_ARCH
 510 #if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == AT_ENTRY_POINT
 511 #define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_at_entry_point (pc, sp, frame_address)
 512 #endif
 513 #endif
 514
 515 /* It's often not enough for our clients to know whether the PC is merely
 516    somewhere within the call dummy.  They may need to know whether the
 517    call dummy has actually completed.  (For example, wait_for_inferior
 518    wants to know when it should truly stop because the call dummy has
 519    completed.  If we're single-stepping because of slow watchpoints,
 520    then we may find ourselves stopped at the entry of the call dummy,
 521    and want to continue stepping until we reach the end.)
 522
 523    Note that this macro is intended for targets (like HP-UX) which
 524    require more than a single breakpoint in their call dummies, and
 525    therefore cannot use the CALL_DUMMY_BREAKPOINT_OFFSET mechanism.
 526
 527    If a target does define CALL_DUMMY_BREAKPOINT_OFFSET, then this
 528    default implementation of CALL_DUMMY_HAS_COMPLETED is sufficient.
 529    Else, a target may wish to supply an implementation that works in
 530    the presense of multiple breakpoints in its call dummy.
 531  */
 532 #if !defined(CALL_DUMMY_HAS_COMPLETED)
 533 #define CALL_DUMMY_HAS_COMPLETED(pc, sp, frame_address) \
 534   PC_IN_CALL_DUMMY((pc), (sp), (frame_address))
 535 #endif
 536
 537 /* If STARTUP_WITH_SHELL is set, GDB's "run"
 538    will attempts to start up the debugee under a shell.
 539    This is in order for argument-expansion to occur. E.g.,
 540    (gdb) run *
 541    The "*" gets expanded by the shell into a list of files.
 542    While this is a nice feature, it turns out to interact badly
 543    with some of the catch-fork/catch-exec features we have added.
 544    In particular, if the shell does any fork/exec's before
 545    the exec of the target program, that can confuse GDB.
 546    To disable this feature, set STARTUP_WITH_SHELL to 0.
 547    To enable this feature, set STARTUP_WITH_SHELL to 1.
 548    The catch-exec traps expected during start-up will
 549    be 1 if target is not started up with a shell, 2 if it is.
 550    - RT
 551    If you disable this, you need to decrement
 552    START_INFERIOR_TRAPS_EXPECTED in tm.h. */
 553 #define STARTUP_WITH_SHELL 1
 554 #if !defined(START_INFERIOR_TRAPS_EXPECTED)
 555 #define START_INFERIOR_TRAPS_EXPECTED   2
 556 #endif
 557 #endif /* !defined (INFERIOR_H) */