gdb/frame.h

   1 /* Definitions for dealing with stack frames, for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996,
   4    1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #if !defined (FRAME_H)
  24 #define FRAME_H 1
  25
  26 struct symtab_and_line;
  27
  28 /* The frame object.  */
  29
  30 struct frame_info;
  31
  32 /* The frame object's ID.  This provides a per-frame unique identifier
  33    that can be used to relocate a `struct frame_info' after a target
  34    resume or a frame cache destruct (assuming the target hasn't
  35    unwound the stack past that frame - a problem handled elsewhere).  */
  36
  37 struct frame_id
  38 {
  39   /* The frame's address.  This should be constant through out the
  40      lifetime of a frame.  */
  41   /* NOTE: cagney/2002-11-16: The ia64 has two stacks and hence two
  42      frame bases.  This will need to be expanded to accomodate that.  */
  43   CORE_ADDR base;
  44   /* The frame's current PC.  While the PC within the function may
  45      change, the function that contains the PC does not.  Should this
  46      instead be the frame's function?  */
  47   CORE_ADDR pc;
  48 };
  49
  50 /* For every stopped thread, GDB tracks two frames: current and
  51    selected.  Current frame is the inner most frame of the selected
  52    thread.  Selected frame is the one being examined by the the GDB
  53    CLI (selected using `up', `down', ...).  The frames are created
  54    on-demand (via get_prev_frame()) and then held in a frame cache.  */
  55 /* FIXME: cagney/2002-11-28: Er, there is a lie here.  If you do the
  56    sequence: `thread 1; up; thread 2; thread 1' you loose thread 1's
  57    selected frame.  At present GDB only tracks the selected frame of
  58    the current thread.  But be warned, that might change.  */
  59 /* FIXME: cagney/2002-11-14: At any time, only one thread's selected
  60    and current frame can be active.  Switching threads causes gdb to
  61    discard all that cached frame information.  Ulgh!  Instead, current
  62    and selected frame should be bound to a thread.  */
  63
  64 /* On demand, create the inner most frame using information found in
  65    the inferior.  If the inner most frame can't be created, throw an
  66    error.  */
  67 extern struct frame_info *get_current_frame (void);
  68
  69 /* Invalidates the frame cache (this function should have been called
  70    invalidate_cached_frames).
  71
  72    FIXME: cagney/2002-11-28: The only difference between
  73    flush_cached_frames() and reinit_frame_cache() is that the latter
  74    explicitly sets the selected frame back to the current frame there
  75    isn't any real difference (except that one delays the selection of
  76    a new frame).  Code can instead simply rely on get_selected_frame()
  77    to reinit's the selected frame as needed.  As for invalidating the
  78    cache, there should be two methods one that reverts the thread's
  79    selected frame back to current frame (for when the inferior
  80    resumes) and one that does not (for when the user modifies the
  81    target invalidating the frame cache).  */
  82 extern void flush_cached_frames (void);
  83 extern void reinit_frame_cache (void);
  84
  85 /* On demand, create the selected frame and then return it.  If the
  86    selected frame can not be created, this function throws an error.  */
  87 /* FIXME: cagney/2002-11-28: At present, when there is no selected
  88    frame, this function always returns the current (inner most) frame.
  89    It should instead, when a thread has previously had its frame
  90    selected (but not resumed) and the frame cache invalidated, find
  91    and then return that thread's previously selected frame.  */
  92 extern struct frame_info *get_selected_frame (void);
  93
  94 /* Select a specific frame.  NULL, apparently implies re-select the
  95    inner most frame.  */
  96 extern void select_frame (struct frame_info *);
  97
  98 /* Given a FRAME, return the next (more inner, younger) or previous
  99    (more outer, older) frame.  */
 100 extern struct frame_info *get_prev_frame (struct frame_info *);
 101 extern struct frame_info *get_next_frame (struct frame_info *);
 102
 103 /* Given a frame's ID, relocate the frame.  Returns NULL if the frame
 104    is not found.  */
 105 extern struct frame_info *frame_find_by_id (struct frame_id id);
 106
 107 /* Base attributes of a frame: */
 108
 109 /* The frame's `resume' address.  Where the program will resume in
 110    this frame.  */
 111 extern CORE_ADDR get_frame_pc (struct frame_info *);
 112
 113 /* Closely related to the resume address, various symbol table
 114    attributes that are determined by the PC.  Note that for a normal
 115    frame, the PC refers to the resume address after the return, and
 116    not the call instruction.  In such a case, the address is adjusted
 117    so that it (approximatly) identifies the call site (and not return
 118    site).
 119
 120    NOTE: cagney/2002-11-28: The frame cache could be used to cache the
 121    computed value.  Working on the assumption that the bottle-neck is
 122    in the single step code, and that code causes the frame cache to be
 123    constantly flushed, caching things in a frame is probably of little
 124    benefit.  As they say `show us the numbers'.
 125
 126    NOTE: cagney/2002-11-28: Plenty more where this one came from:
 127    find_frame_block(), find_frame_partial_function(),
 128    find_frame_symtab(), find_frame_function().  Each will need to be
 129    carefully considered to determine if the real intent was for it to
 130    apply to the PC or the adjusted PC.  */
 131 extern void find_frame_sal (struct frame_info *frame,
 132                             struct symtab_and_line *sal);
 133
 134 /* Return the frame address from FI.  Except in the machine-dependent
 135    *FRAME* macros, a frame address has no defined meaning other than
 136    as a magic cookie which identifies a frame over calls to the
 137    inferior (um, SEE NOTE BELOW).  The only known exception is
 138    inferior.h (DEPRECATED_PC_IN_CALL_DUMMY) [ON_STACK]; see comments
 139    there.  You cannot assume that a frame address contains enough
 140    information to reconstruct the frame; if you want more than just to
 141    identify the frame (e.g. be able to fetch variables relative to
 142    that frame), then save the whole struct frame_info (and the next
 143    struct frame_info, since the latter is used for fetching variables
 144    on some machines) (um, again SEE NOTE BELOW).
 145
 146    NOTE: cagney/2002-11-18: Actually, the frame address isn't
 147    sufficient for identifying a frame, and the counter examples are
 148    wrong!
 149
 150    Code that needs to (re)identify a frame must use get_frame_id() and
 151    frame_find_by_id() (and in the future, a frame_compare() function
 152    instead of INNER_THAN()).  Two reasons: an architecture (e.g.,
 153    ia64) can have more than one frame address (due to multiple stack
 154    pointers) (frame ID is going to be expanded to accomodate this);
 155    successive frameless function calls can only be differientated by
 156    comparing both the frame's base and the frame's enclosing function
 157    (frame_find_by_id() is going to be modified to perform this test).
 158
 159    The generic dummy frame version of DEPRECATED_PC_IN_CALL_DUMMY() is
 160    able to identify a dummy frame using only the PC value.  So the
 161    frame address is not needed.  In fact, most
 162    DEPRECATED_PC_IN_CALL_DUMMY() calls now pass zero as the frame/sp
 163    values as the caller knows that those values won't be used.  Once
 164    all architectures are using generic dummy frames,
 165    DEPRECATED_PC_IN_CALL_DUMMY() can drop the sp/frame parameters.
 166    When it comes to finding a dummy frame, the next frame's frame ID
 167    (with out duing an unwind) can be used (ok, could if it wasn't for
 168    the need to change the way the PPC defined frame base in a strange
 169    way).
 170
 171    Modern architectures should be using something like dwarf2's
 172    location expression to describe where a variable lives.  Such
 173    expressions specify their own debug info centric frame address.
 174    Consequently, a generic frame address is pretty meaningless.  */
 175
 176 extern CORE_ADDR get_frame_base (struct frame_info *);
 177
 178 /* Return the per-frame unique identifer.  Can be used to relocate a
 179    frame after a frame cache flush (and other similar operations).  */
 180 extern void get_frame_id (struct frame_info *fi, struct frame_id *id);
 181
 182 /* The frame's level: 0 for innermost, 1 for its caller, ...; or -1
 183    for an invalid frame).  */
 184 extern int frame_relative_level (struct frame_info *fi);
 185
 186 /* Return the frame's type.  Some are real, some are signal
 187    trampolines, and some are completly artificial (dummy).  */
 188
 189 enum frame_type
 190 {
 191   /* A true stack frame, created by the target program during normal
 192      execution.  */
 193   NORMAL_FRAME,
 194   /* A fake frame, created by GDB when performing an inferior function
 195      call.  */
 196   DUMMY_FRAME,
 197   /* In a signal handler, various OSs handle this in various ways.
 198      The main thing is that the frame may be far from normal.  */
 199   SIGTRAMP_FRAME
 200 };
 201 extern enum frame_type get_frame_type (struct frame_info *);
 202
 203 /* FIXME: cagney/2002-11-10: Some targets want to directly mark a
 204    frame as being of a specific type.  This shouldn't be necessary.
 205    PC_IN_SIGTRAMP() indicates a SIGTRAMP_FRAME and
 206    DEPRECATED_PC_IN_CALL_DUMMY() indicates a DUMMY_FRAME.  I suspect
 207    the real problem here is that get_prev_frame() only sets
 208    initialized after INIT_EXTRA_FRAME_INFO as been called.
 209    Consequently, some targets found that the frame's type was wrong
 210    and tried to fix it.  The correct fix is to modify get_prev_frame()
 211    so that it initializes the frame's type before calling any other
 212    functions.  */
 213 extern void deprecated_set_frame_type (struct frame_info *,
 214                                        enum frame_type type);
 215
 216 /* Unwind the stack frame so that the value of REGNUM, in the previous
 217    (up, older) frame is returned.  If VALUEP is NULL, don't
 218    fetch/compute the value.  Instead just return the location of the
 219    value.  */
 220 extern void frame_register_unwind (struct frame_info *frame, int regnum,
 221                                    int *optimizedp, enum lval_type *lvalp,
 222                                    CORE_ADDR *addrp, int *realnump,
 223                                    void *valuep);
 224
 225 /* More convenient interface to frame_register_unwind().  */
 226 /* NOTE: cagney/2002-09-13: Return void as one day these functions may
 227    be changed to return an indication that the read succeeded.  */
 228
 229 extern void frame_unwind_signed_register (struct frame_info *frame,
 230                                           int regnum, LONGEST *val);
 231
 232 extern void frame_unwind_unsigned_register (struct frame_info *frame,
 233                                             int regnum, ULONGEST *val);
 234
 235 /* Get the value of the register that belongs to this FRAME.  This
 236    function is a wrapper to the call sequence ``frame_unwind_register
 237    (get_next_frame (FRAME))''.  As per frame_register_unwind(), if
 238    VALUEP is NULL, the registers value is not fetched/computed.  */
 239
 240 extern void frame_register (struct frame_info *frame, int regnum,
 241                             int *optimizedp, enum lval_type *lvalp,
 242                             CORE_ADDR *addrp, int *realnump,
 243                             void *valuep);
 244
 245 /* More convenient interface to frame_register().  */
 246 /* NOTE: cagney/2002-09-13: Return void as one day these functions may
 247    be changed to return an indication that the read succeeded.  */
 248
 249 extern void frame_read_signed_register (struct frame_info *frame,
 250                                         int regnum, LONGEST *val);
 251
 252 extern void frame_read_unsigned_register (struct frame_info *frame,
 253                                           int regnum, ULONGEST *val);
 254
 255 /* Map between a frame register number and its name.  A frame register
 256    space is a superset of the cooked register space --- it also
 257    includes builtin registers.  */
 258
 259 extern int frame_map_name_to_regnum (const char *name, int strlen);
 260 extern const char *frame_map_regnum_to_name (int regnum);
 261
 262 /* Unwind the PC.  Strictly speaking return the resume address of the
 263    calling frame.  For GDB, `pc' is the resume address and not a
 264    specific register.  */
 265
 266 extern CORE_ADDR frame_pc_unwind (struct frame_info *frame);
 267
 268 \f
 269 /* Return the location (and possibly value) of REGNUM for the previous
 270    (older, up) frame.  All parameters except VALUEP can be assumed to
 271    be non NULL.  When VALUEP is NULL, just the location of the
 272    register should be returned.
 273
 274    UNWIND_CACHE is provided as mechanism for implementing a per-frame
 275    local cache.  It's initial value being NULL.  Memory for that cache
 276    should be allocated using frame_obstack_alloc().
 277
 278    Register window architectures (eg SPARC) should note that REGNUM
 279    identifies the register for the previous frame.  For instance, a
 280    request for the value of "o1" for the previous frame would be found
 281    in the register "i1" in this FRAME.  */
 282
 283 typedef void (frame_register_unwind_ftype) (struct frame_info *frame,
 284                                             void **unwind_cache,
 285                                             int regnum,
 286                                             int *optimized,
 287                                             enum lval_type *lvalp,
 288                                             CORE_ADDR *addrp,
 289                                             int *realnump,
 290                                             void *valuep);
 291
 292 /* Same as for registers above, but return the address at which the
 293    calling frame would resume.  */
 294
 295 typedef CORE_ADDR (frame_pc_unwind_ftype) (struct frame_info *frame,
 296                                            void **unwind_cache);
 297
 298 /* Describe the saved registers of a frame.  */
 299
 300 #if defined (EXTRA_FRAME_INFO) || defined (FRAME_FIND_SAVED_REGS)
 301 /* XXXX - deprecated */
 302 struct frame_saved_regs
 303   {
 304     /* For each register R (except the SP), regs[R] is the address at
 305        which it was saved on entry to the frame, or zero if it was not
 306        saved on entry to this frame.  This includes special registers
 307        such as pc and fp saved in special ways in the stack frame.
 308
 309        regs[SP_REGNUM] is different.  It holds the actual SP, not the
 310        address at which it was saved.  */
 311
 312     CORE_ADDR regs[NUM_REGS];
 313   };
 314 #endif
 315
 316 /* We keep a cache of stack frames, each of which is a "struct
 317    frame_info".  The innermost one gets allocated (in
 318    wait_for_inferior) each time the inferior stops; current_frame
 319    points to it.  Additional frames get allocated (in
 320    get_prev_frame) as needed, and are chained through the next
 321    and prev fields.  Any time that the frame cache becomes invalid
 322    (most notably when we execute something, but also if we change how
 323    we interpret the frames (e.g. "set heuristic-fence-post" in
 324    mips-tdep.c, or anything which reads new symbols)), we should call
 325    reinit_frame_cache.  */
 326
 327 struct frame_info
 328   {
 329     /* Nominal address of the frame described.  See comments at
 330        get_frame_base() about what this means outside the *FRAME*
 331        macros; in the *FRAME* macros, it can mean whatever makes most
 332        sense for this machine.  */
 333     CORE_ADDR frame;
 334
 335     /* Address at which execution is occurring in this frame.
 336        For the innermost frame, it's the current pc.
 337        For other frames, it is a pc saved in the next frame.  */
 338     CORE_ADDR pc;
 339
 340     /* Level of this frame.  The inner-most (youngest) frame is at
 341        level 0.  As you move towards the outer-most (oldest) frame,
 342        the level increases.  This is a cached value.  It could just as
 343        easily be computed by counting back from the selected frame to
 344        the inner most frame.  */
 345     /* NOTE: cagney/2002-04-05: Perhaphs a level of ``-1'' should be
 346        reserved to indicate a bogus frame - one that has been created
 347        just to keep GDB happy (GDB always needs a frame).  For the
 348        moment leave this as speculation.  */
 349     int level;
 350
 351     /* The frame's type.  */
 352     enum frame_type type;
 353
 354     /* For each register, address of where it was saved on entry to
 355        the frame, or zero if it was not saved on entry to this frame.
 356        This includes special registers such as pc and fp saved in
 357        special ways in the stack frame.  The SP_REGNUM is even more
 358        special, the address here is the sp for the previous frame, not
 359        the address where the sp was saved.  */
 360     /* Allocated by frame_saved_regs_zalloc () which is called /
 361        initialized by FRAME_INIT_SAVED_REGS(). */
 362     CORE_ADDR *saved_regs;      /*NUM_REGS + NUM_PSEUDO_REGS*/
 363
 364 #ifdef EXTRA_FRAME_INFO
 365     /* XXXX - deprecated */
 366     /* Anything extra for this structure that may have been defined
 367        in the machine dependent files. */
 368       EXTRA_FRAME_INFO
 369 #endif
 370
 371     /* Anything extra for this structure that may have been defined
 372        in the machine dependent files. */
 373     /* Allocated by frame_obstack_alloc () which is called /
 374        initialized by INIT_EXTRA_FRAME_INFO */
 375     struct frame_extra_info *extra_info;
 376
 377     /* If dwarf2 unwind frame informations is used, this structure holds all
 378        related unwind data.  */
 379     struct context *context;
 380
 381     /* Unwind cache shared between the unwind functions - they had
 382        better all agree as to the contents.  */
 383     void *unwind_cache;
 384
 385     /* See description above.  The previous frame's registers.  */
 386     frame_register_unwind_ftype *register_unwind;
 387
 388     /* See description above.  The previous frame's resume address.
 389        Save the previous PC in a local cache.  */
 390     frame_pc_unwind_ftype *pc_unwind;
 391     int pc_unwind_cache_p;
 392     CORE_ADDR pc_unwind_cache;
 393
 394     /* Pointers to the next (down, inner, younger) and previous (up,
 395        outer, older) frame_info's in the frame cache.  */
 396     struct frame_info *next; /* down, inner, younger */
 397     int prev_p;
 398     struct frame_info *prev; /* up, outer, older */
 399   };
 400
 401 /* Values for the source flag to be used in print_frame_info_base(). */
 402 enum print_what
 403   {
 404     /* Print only the source line, like in stepi. */
 405     SRC_LINE = -1,
 406     /* Print only the location, i.e. level, address (sometimes)
 407        function, args, file, line, line num. */
 408     LOCATION,
 409     /* Print both of the above. */
 410     SRC_AND_LOC,
 411     /* Print location only, but always include the address. */
 412     LOC_AND_ADDRESS
 413   };
 414
 415 /* Allocate additional space for appendices to a struct frame_info.
 416    NOTE: Much of GDB's code works on the assumption that the allocated
 417    saved_regs[] array is the size specified below.  If you try to make
 418    that array smaller, GDB will happily walk off its end. */
 419
 420 #ifdef SIZEOF_FRAME_SAVED_REGS
 421 #error "SIZEOF_FRAME_SAVED_REGS can not be re-defined"
 422 #endif
 423 #define SIZEOF_FRAME_SAVED_REGS \
 424         (sizeof (CORE_ADDR) * (NUM_REGS+NUM_PSEUDO_REGS))
 425
 426 extern void *frame_obstack_alloc (unsigned long size);
 427 extern void frame_saved_regs_zalloc (struct frame_info *);
 428
 429 /* Define a default FRAME_CHAIN_VALID, in the form that is suitable for most
 430    targets.  If FRAME_CHAIN_VALID returns zero it means that the given frame
 431    is the outermost one and has no caller.
 432
 433    XXXX - both default and alternate frame_chain_valid functions are
 434    deprecated.  New code should use dummy frames and one of the
 435    generic functions. */
 436
 437 extern int file_frame_chain_valid (CORE_ADDR, struct frame_info *);
 438 extern int func_frame_chain_valid (CORE_ADDR, struct frame_info *);
 439 extern int nonnull_frame_chain_valid (CORE_ADDR, struct frame_info *);
 440 extern int generic_file_frame_chain_valid (CORE_ADDR, struct frame_info *);
 441 extern int generic_func_frame_chain_valid (CORE_ADDR, struct frame_info *);
 442 extern void generic_save_dummy_frame_tos (CORE_ADDR sp);
 443
 444
 445
 446 #ifdef FRAME_FIND_SAVED_REGS
 447 /* XXX - deprecated */
 448 #define FRAME_INIT_SAVED_REGS(FI) get_frame_saved_regs (FI, NULL)
 449 extern void get_frame_saved_regs (struct frame_info *,
 450                                   struct frame_saved_regs *);
 451 #endif
 452
 453 extern struct block *get_frame_block (struct frame_info *,
 454                                       CORE_ADDR *addr_in_block);
 455
 456 /* Return the `struct block' that belongs to the selected thread's
 457    selected frame.  If the inferior has no state, return NULL.
 458
 459    NOTE: cagney/2002-11-29:
 460
 461    No state?  Does the inferior have any execution state (a core file
 462    does, an executable does not).  At present the code tests
 463    `target_has_stack' but I'm left wondering if it should test
 464    `target_has_registers' or, even, a merged target_has_state.
 465
 466    Should it look at the most recently specified SAL?  If the target
 467    has no state, should this function try to extract a block from the
 468    most recently selected SAL?  That way `list foo' would give it some
 469    sort of reference point.  Then again, perhaphs that would confuse
 470    things.
 471
 472    Calls to this function can be broken down into two categories: Code
 473    that uses the selected block as an additional, but optional, data
 474    point; Code that uses the selected block as a prop, when it should
 475    have the relevant frame/block/pc explicitly passed in.
 476
 477    The latter can be eliminated by correctly parameterizing the code,
 478    the former though is more interesting.  Per the "address" command,
 479    it occures in the CLI code and makes it possible for commands to
 480    work, even when the inferior has no state.  */
 481
 482 extern struct block *get_selected_block (CORE_ADDR *addr_in_block);
 483
 484 extern struct symbol *get_frame_function (struct frame_info *);
 485
 486 extern CORE_ADDR frame_address_in_block (struct frame_info *);
 487
 488 extern CORE_ADDR get_pc_function_start (CORE_ADDR);
 489
 490 extern struct block *block_for_pc (CORE_ADDR);
 491
 492 extern struct block *block_for_pc_sect (CORE_ADDR, asection *);
 493
 494 extern int frameless_look_for_prologue (struct frame_info *);
 495
 496 extern void print_frame_args (struct symbol *, struct frame_info *,
 497                               int, struct ui_file *);
 498
 499 extern struct frame_info *find_relative_frame (struct frame_info *, int *);
 500
 501 extern void show_and_print_stack_frame (struct frame_info *fi, int level,
 502                                         int source);
 503
 504 extern void print_stack_frame (struct frame_info *, int, int);
 505
 506 extern void print_only_stack_frame (struct frame_info *, int, int);
 507
 508 extern void show_stack_frame (struct frame_info *);
 509
 510 extern void print_frame_info (struct frame_info *, int, int, int);
 511
 512 extern void show_frame_info (struct frame_info *, int, int, int);
 513
 514 extern struct frame_info *block_innermost_frame (struct block *);
 515
 516 /* NOTE: cagney/2002-09-13: There is no need for this function.
 517    Instead either of frame_unwind_signed_register() or
 518    frame_unwind_unsigned_register() can be used.  */
 519 extern CORE_ADDR deprecated_read_register_dummy (CORE_ADDR pc,
 520                                                  CORE_ADDR fp, int);
 521 extern void generic_push_dummy_frame (void);
 522 extern void generic_pop_current_frame (void (*)(struct frame_info *));
 523 extern void generic_pop_dummy_frame (void);
 524
 525 extern int generic_pc_in_call_dummy (CORE_ADDR pc,
 526                                      CORE_ADDR sp, CORE_ADDR fp);
 527
 528 /* NOTE: cagney/2002-06-26: Targets should no longer use this
 529    function.  Instead, the contents of a dummy frames registers can be
 530    obtained by applying: frame_register_unwind to the dummy frame; or
 531    get_saved_register to the next outer frame.  */
 532
 533 extern char *deprecated_generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp);
 534
 535 extern void generic_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
 536                                     int nargs, struct value **args,
 537                                     struct type *type, int gcc_p);
 538
 539 /* The function generic_get_saved_register() has been made obsolete.
 540    GET_SAVED_REGISTER now defaults to the recursive equivalent -
 541    generic_unwind_get_saved_register() - so there is no need to even
 542    set GET_SAVED_REGISTER.  Architectures that need to override the
 543    register unwind mechanism should modify frame->unwind().  */
 544 extern void deprecated_generic_get_saved_register (char *, int *, CORE_ADDR *,
 545                                                    struct frame_info *, int,
 546                                                    enum lval_type *);
 547
 548 extern void generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi);
 549
 550 extern void get_saved_register (char *raw_buffer, int *optimized,
 551                                 CORE_ADDR * addrp,
 552                                 struct frame_info *frame,
 553                                 int regnum, enum lval_type *lval);
 554
 555 extern int frame_register_read (struct frame_info *frame, int regnum,
 556                                 void *buf);
 557
 558 /* From stack.c.  */
 559 extern void args_info (char *, int);
 560
 561 extern void locals_info (char *, int);
 562
 563 extern void (*selected_frame_level_changed_hook) (int);
 564
 565 extern void return_command (char *, int);
 566
 567
 568 /* NOTE: cagney/2002-11-27:
 569
 570    You might think that the below global can simply be replaced by a
 571    call to either get_selected_frame() or select_frame().
 572
 573    Unfortunatly, it isn't that easy.
 574
 575    The relevant code needs to be audited to determine if it is
 576    possible (or pratical) to instead pass the applicable frame in as a
 577    parameter.  For instance, DEPRECATED_DO_REGISTERS_INFO() relied on
 578    the deprecated_selected_frame global, while its replacement,
 579    PRINT_REGISTERS_INFO(), is parameterized with the selected frame.
 580    The only real exceptions occure at the edge (in the CLI code) where
 581    user commands need to pick up the selected frame before proceeding.
 582
 583    This is important.  GDB is trying to stamp out the hack:
 584
 585    saved_frame = deprecated_selected_frame;
 586    deprecated_selected_frame = ...;
 587    hack_using_global_selected_frame ();
 588    deprecated_selected_frame = saved_frame;
 589
 590    Take care!  */
 591
 592 extern struct frame_info *deprecated_selected_frame;
 593
 594
 595 /* NOTE: cagney/2002-11-28:
 596
 597    These functions are used to explicitly create and set the inner
 598    most (current) frame vis:
 599
 600    set_current_frame (create_new_frame (read_fp(), stop_pc)));
 601
 602    Such code should be removed.  Instead that task can be left to
 603    get_current_frame() which will update things on-demand.
 604
 605    The only vague exception is found in "infcmd.c" (and a few
 606    architectures specific files) as part of the code implementing the
 607    command ``(gdb) frame FRAME PC''.  There, the frame should be
 608    created/selected in a single shot.  */
 609
 610 extern void set_current_frame (struct frame_info *);
 611 extern struct frame_info *create_new_frame (CORE_ADDR, CORE_ADDR);
 612
 613 #endif /* !defined (FRAME_H)  */