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, 2003 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 struct frame_unwind;
  28 struct frame_base;
  29 struct block;
  30 struct gdbarch;
  31
  32 /* A legacy unwinder to prop up architectures using the old style
  33    saved regs array.  */
  34 extern const struct frame_unwind *legacy_saved_regs_unwind;
  35
  36 /* The frame object.  */
  37
  38 struct frame_info;
  39
  40 /* The frame object's ID.  This provides a per-frame unique identifier
  41    that can be used to relocate a `struct frame_info' after a target
  42    resume or a frame cache destruct.  It of course assumes that the
  43    inferior hasn't unwound the stack past that frame.  */
  44
  45 struct frame_id
  46 {
  47   /* The frame's stack address.  This shall be constant through out
  48      the lifetime of a frame.  Note that this requirement applies to
  49      not just the function body, but also the prologue and (in theory
  50      at least) the epilogue.  Since that value needs to fall either on
  51      the boundary, or within the frame's address range, the frame's
  52      outer-most address (the inner-most address of the previous frame)
  53      is used.  Watch out for all the legacy targets that still use the
  54      function pointer register or stack pointer register.  They are
  55      wrong.  */
  56   /* NOTE: cagney/2002-11-16: The ia64 has two stacks and hence two
  57      frame bases.  This will need to be expanded to accomodate that.  */
  58   CORE_ADDR stack_addr;
  59   /* The frame's code address.  This shall be constant through out the
  60      lifetime of the frame.  While the PC (a.k.a. resume address)
  61      changes as the function is executed, this code address cannot.
  62      Typically, it is set to the address of the entry point of the
  63      frame's function (as returned by frame_func_unwind().  */
  64   CORE_ADDR code_addr;
  65 };
  66
  67 /* Methods for constructing and comparing Frame IDs.
  68
  69    NOTE: Given frameless functions A and B, where A calls B (and hence
  70    B is inner-to A).  The relationships: !eq(A,B); !eq(B,A);
  71    !inner(A,B); !inner(B,A); all hold.  This is because, while B is
  72    inner to A, B is not strictly inner to A (being frameless, they
  73    have the same .base value).  */
  74
  75 /* For convenience.  All fields are zero.  */
  76 extern const struct frame_id null_frame_id;
  77
  78 /* Construct a frame ID.  The first parameter is the frame's constant
  79    stack address (typically the outer-bound), and the second the
  80    frame's constant code address (typically the entry point) (or zero,
  81    to indicate a wild card).  */
  82 extern struct frame_id frame_id_build (CORE_ADDR stack_addr,
  83                                        CORE_ADDR code_addr);
  84
  85 /* Returns non-zero when L is a valid frame (a valid frame has a
  86    non-zero .base).  */
  87 extern int frame_id_p (struct frame_id l);
  88
  89 /* Returns non-zero when L and R identify the same frame, or, if
  90    either L or R have a zero .func, then the same frame base.  */
  91 extern int frame_id_eq (struct frame_id l, struct frame_id r);
  92
  93 /* Returns non-zero when L is strictly inner-than R (they have
  94    different frame .bases).  Neither L, nor R can be `null'.  See note
  95    above about frameless functions.  */
  96 extern int frame_id_inner (struct frame_id l, struct frame_id r);
  97
  98
  99 /* For every stopped thread, GDB tracks two frames: current and
 100    selected.  Current frame is the inner most frame of the selected
 101    thread.  Selected frame is the one being examined by the the GDB
 102    CLI (selected using `up', `down', ...).  The frames are created
 103    on-demand (via get_prev_frame()) and then held in a frame cache.  */
 104 /* FIXME: cagney/2002-11-28: Er, there is a lie here.  If you do the
 105    sequence: `thread 1; up; thread 2; thread 1' you loose thread 1's
 106    selected frame.  At present GDB only tracks the selected frame of
 107    the current thread.  But be warned, that might change.  */
 108 /* FIXME: cagney/2002-11-14: At any time, only one thread's selected
 109    and current frame can be active.  Switching threads causes gdb to
 110    discard all that cached frame information.  Ulgh!  Instead, current
 111    and selected frame should be bound to a thread.  */
 112
 113 /* On demand, create the inner most frame using information found in
 114    the inferior.  If the inner most frame can't be created, throw an
 115    error.  */
 116 extern struct frame_info *get_current_frame (void);
 117
 118 /* Invalidates the frame cache (this function should have been called
 119    invalidate_cached_frames).
 120
 121    FIXME: cagney/2002-11-28: The only difference between
 122    flush_cached_frames() and reinit_frame_cache() is that the latter
 123    explicitly sets the selected frame back to the current frame there
 124    isn't any real difference (except that one delays the selection of
 125    a new frame).  Code can instead simply rely on get_selected_frame()
 126    to reinit's the selected frame as needed.  As for invalidating the
 127    cache, there should be two methods one that reverts the thread's
 128    selected frame back to current frame (for when the inferior
 129    resumes) and one that does not (for when the user modifies the
 130    target invalidating the frame cache).  */
 131 extern void flush_cached_frames (void);
 132 extern void reinit_frame_cache (void);
 133
 134 /* On demand, create the selected frame and then return it.  If the
 135    selected frame can not be created, this function throws an error.  */
 136 /* FIXME: cagney/2002-11-28: At present, when there is no selected
 137    frame, this function always returns the current (inner most) frame.
 138    It should instead, when a thread has previously had its frame
 139    selected (but not resumed) and the frame cache invalidated, find
 140    and then return that thread's previously selected frame.  */
 141 extern struct frame_info *get_selected_frame (void);
 142
 143 /* Select a specific frame.  NULL, apparently implies re-select the
 144    inner most frame.  */
 145 extern void select_frame (struct frame_info *);
 146
 147 /* Given a FRAME, return the next (more inner, younger) or previous
 148    (more outer, older) frame.  */
 149 extern struct frame_info *get_prev_frame (struct frame_info *);
 150 extern struct frame_info *get_next_frame (struct frame_info *);
 151
 152 /* Given a frame's ID, relocate the frame.  Returns NULL if the frame
 153    is not found.  */
 154 extern struct frame_info *frame_find_by_id (struct frame_id id);
 155
 156 /* Base attributes of a frame: */
 157
 158 /* The frame's `resume' address.  Where the program will resume in
 159    this frame.  */
 160 extern CORE_ADDR get_frame_pc (struct frame_info *);
 161
 162 /* Following on from the `resume' address.  Return the entry point
 163    address of the function containing that resume address, or zero if
 164    that function isn't known.  */
 165 extern CORE_ADDR frame_func_unwind (struct frame_info *fi);
 166 extern CORE_ADDR get_frame_func (struct frame_info *fi);
 167
 168 /* Closely related to the resume address, various symbol table
 169    attributes that are determined by the PC.  Note that for a normal
 170    frame, the PC refers to the resume address after the return, and
 171    not the call instruction.  In such a case, the address is adjusted
 172    so that it (approximatly) identifies the call site (and not return
 173    site).
 174
 175    NOTE: cagney/2002-11-28: The frame cache could be used to cache the
 176    computed value.  Working on the assumption that the bottle-neck is
 177    in the single step code, and that code causes the frame cache to be
 178    constantly flushed, caching things in a frame is probably of little
 179    benefit.  As they say `show us the numbers'.
 180
 181    NOTE: cagney/2002-11-28: Plenty more where this one came from:
 182    find_frame_block(), find_frame_partial_function(),
 183    find_frame_symtab(), find_frame_function().  Each will need to be
 184    carefully considered to determine if the real intent was for it to
 185    apply to the PC or the adjusted PC.  */
 186 extern void find_frame_sal (struct frame_info *frame,
 187                             struct symtab_and_line *sal);
 188
 189 /* Return the frame base (what ever that is) (DEPRECATED).
 190
 191    Old code was trying to use this single method for two conflicting
 192    purposes.  Such code needs to be updated to use either of:
 193
 194    get_frame_id: A low level frame unique identifier, that consists of
 195    both a stack and a function address, that can be used to uniquely
 196    identify a frame.  This value is determined by the frame's
 197    low-level unwinder, the stack part [typically] being the
 198    top-of-stack of the previous frame, and the function part being the
 199    function's start address.  Since the correct identification of a
 200    frameless function requires both the a stack and function address,
 201    the old get_frame_base method was not sufficient.
 202
 203    get_frame_base_address: get_frame_locals_address:
 204    get_frame_args_address: A set of high-level debug-info dependant
 205    addresses that fall within the frame.  These addresses almost
 206    certainly will not match the stack address part of a frame ID (as
 207    returned by get_frame_base).  */
 208
 209 extern CORE_ADDR get_frame_base (struct frame_info *);
 210
 211 /* Return the per-frame unique identifer.  Can be used to relocate a
 212    frame after a frame cache flush (and other similar operations).  If
 213    FI is NULL, return the null_frame_id.  */
 214 extern struct frame_id get_frame_id (struct frame_info *fi);
 215
 216 /* Assuming that a frame is `normal', return its base-address, or 0 if
 217    the information isn't available.  NOTE: This address is really only
 218    meaningful to the frame's high-level debug info.  */
 219 extern CORE_ADDR get_frame_base_address (struct frame_info *);
 220
 221 /* Assuming that a frame is `normal', return the base-address of the
 222    local variables, or 0 if the information isn't available.  NOTE:
 223    This address is really only meaningful to the frame's high-level
 224    debug info.  Typically, the argument and locals share a single
 225    base-address.  */
 226 extern CORE_ADDR get_frame_locals_address (struct frame_info *);
 227
 228 /* Assuming that a frame is `normal', return the base-address of the
 229    parameter list, or 0 if that information isn't available.  NOTE:
 230    This address is really only meaningful to the frame's high-level
 231    debug info.  Typically, the argument and locals share a single
 232    base-address.  */
 233 extern CORE_ADDR get_frame_args_address (struct frame_info *);
 234
 235 /* The frame's level: 0 for innermost, 1 for its caller, ...; or -1
 236    for an invalid frame).  */
 237 extern int frame_relative_level (struct frame_info *fi);
 238
 239 /* Return the frame's type.  Some are real, some are signal
 240    trampolines, and some are completly artificial (dummy).  */
 241
 242 enum frame_type
 243 {
 244   /* The frame's type hasn't yet been defined.  This is a catch-all
 245      for legacy code that uses really strange technicques, such as
 246      deprecated_set_frame_type, to set the frame's type.  New code
 247      should not use this value.  */
 248   UNKNOWN_FRAME,
 249   /* A true stack frame, created by the target program during normal
 250      execution.  */
 251   NORMAL_FRAME,
 252   /* A fake frame, created by GDB when performing an inferior function
 253      call.  */
 254   DUMMY_FRAME,
 255   /* In a signal handler, various OSs handle this in various ways.
 256      The main thing is that the frame may be far from normal.  */
 257   SIGTRAMP_FRAME
 258 };
 259 extern enum frame_type get_frame_type (struct frame_info *);
 260
 261 /* FIXME: cagney/2002-11-10: Some targets want to directly mark a
 262    frame as being of a specific type.  This shouldn't be necessary.
 263    PC_IN_SIGTRAMP() indicates a SIGTRAMP_FRAME and
 264    DEPRECATED_PC_IN_CALL_DUMMY() indicates a DUMMY_FRAME.  I suspect
 265    the real problem here is that get_prev_frame() only sets
 266    initialized after DEPRECATED_INIT_EXTRA_FRAME_INFO as been called.
 267    Consequently, some targets found that the frame's type was wrong
 268    and tried to fix it.  The correct fix is to modify get_prev_frame()
 269    so that it initializes the frame's type before calling any other
 270    functions.  */
 271 extern void deprecated_set_frame_type (struct frame_info *,
 272                                        enum frame_type type);
 273
 274 /* Unwind the stack frame so that the value of REGNUM, in the previous
 275    (up, older) frame is returned.  If VALUEP is NULL, don't
 276    fetch/compute the value.  Instead just return the location of the
 277    value.  */
 278 extern void frame_register_unwind (struct frame_info *frame, int regnum,
 279                                    int *optimizedp, enum lval_type *lvalp,
 280                                    CORE_ADDR *addrp, int *realnump,
 281                                    void *valuep);
 282
 283 /* More convenient interface to frame_register_unwind().  */
 284 /* NOTE: cagney/2002-09-13: Return void as one day these functions may
 285    be changed to return an indication that the read succeeded.  */
 286
 287 extern void frame_unwind_register (struct frame_info *frame,
 288                                    int regnum, void *buf);
 289
 290 extern void frame_unwind_signed_register (struct frame_info *frame,
 291                                           int regnum, LONGEST *val);
 292
 293 extern void frame_unwind_unsigned_register (struct frame_info *frame,
 294                                             int regnum, ULONGEST *val);
 295
 296 /* Get the value of the register that belongs to this FRAME.  This
 297    function is a wrapper to the call sequence ``frame_unwind_register
 298    (get_next_frame (FRAME))''.  As per frame_register_unwind(), if
 299    VALUEP is NULL, the registers value is not fetched/computed.  */
 300
 301 extern void frame_register (struct frame_info *frame, int regnum,
 302                             int *optimizedp, enum lval_type *lvalp,
 303                             CORE_ADDR *addrp, int *realnump,
 304                             void *valuep);
 305
 306 /* More convenient interface to frame_register().  */
 307 /* NOTE: cagney/2002-09-13: Return void as one day these functions may
 308    be changed to return an indication that the read succeeded.  */
 309
 310 extern void frame_read_register (struct frame_info *frame, int regnum,
 311                                  void *buf);
 312
 313 extern void frame_read_signed_register (struct frame_info *frame,
 314                                         int regnum, LONGEST *val);
 315
 316 extern void frame_read_unsigned_register (struct frame_info *frame,
 317                                           int regnum, ULONGEST *val);
 318
 319 /* Map between a frame register number and its name.  A frame register
 320    space is a superset of the cooked register space --- it also
 321    includes builtin registers.  If NAMELEN is negative, use the NAME's
 322    length when doing the comparison.  */
 323
 324 extern int frame_map_name_to_regnum (const char *name, int namelen);
 325 extern const char *frame_map_regnum_to_name (int regnum);
 326
 327 /* Unwind the PC.  Strictly speaking return the resume address of the
 328    calling frame.  For GDB, `pc' is the resume address and not a
 329    specific register.  */
 330
 331 extern CORE_ADDR frame_pc_unwind (struct frame_info *frame);
 332
 333 /* Discard the specified frame.  Restoring the registers to the state
 334    of the caller.  */
 335 extern void frame_pop (struct frame_info *frame);
 336
 337 /* Values for the source flag to be used in print_frame_info_base(). */
 338 enum print_what
 339   {
 340     /* Print only the source line, like in stepi. */
 341     SRC_LINE = -1,
 342     /* Print only the location, i.e. level, address (sometimes)
 343        function, args, file, line, line num. */
 344     LOCATION,
 345     /* Print both of the above. */
 346     SRC_AND_LOC,
 347     /* Print location only, but always include the address. */
 348     LOC_AND_ADDRESS
 349   };
 350
 351 /* Allocate additional space for appendices to a struct frame_info.
 352    NOTE: Much of GDB's code works on the assumption that the allocated
 353    saved_regs[] array is the size specified below.  If you try to make
 354    that array smaller, GDB will happily walk off its end. */
 355
 356 #ifdef SIZEOF_FRAME_SAVED_REGS
 357 #error "SIZEOF_FRAME_SAVED_REGS can not be re-defined"
 358 #endif
 359 #define SIZEOF_FRAME_SAVED_REGS \
 360         (sizeof (CORE_ADDR) * (NUM_REGS+NUM_PSEUDO_REGS))
 361
 362 /* Allocate zero initialized memory from the frame cache obstack.
 363    Appendices to the frame info (such as the unwind cache) should
 364    allocate memory using this method.  */
 365
 366 extern void *frame_obstack_zalloc (unsigned long size);
 367 #define FRAME_OBSTACK_ZALLOC(TYPE) ((TYPE *) frame_obstack_zalloc (sizeof (TYPE)))
 368
 369 /* If legacy_frame_chain_valid() returns zero it means that the given
 370    frame is the outermost one and has no caller.
 371
 372    This method has been superseeded by the per-architecture
 373    frame_unwind_pc() (returns 0 to indicate an invalid return address)
 374    and per-frame this_id() (returns a NULL frame ID to indicate an
 375    invalid frame).  */
 376 extern int legacy_frame_chain_valid (CORE_ADDR, struct frame_info *);
 377
 378 extern void generic_save_dummy_frame_tos (CORE_ADDR sp);
 379
 380 extern struct block *get_frame_block (struct frame_info *,
 381                                       CORE_ADDR *addr_in_block);
 382
 383 /* Return the `struct block' that belongs to the selected thread's
 384    selected frame.  If the inferior has no state, return NULL.
 385
 386    NOTE: cagney/2002-11-29:
 387
 388    No state?  Does the inferior have any execution state (a core file
 389    does, an executable does not).  At present the code tests
 390    `target_has_stack' but I'm left wondering if it should test
 391    `target_has_registers' or, even, a merged target_has_state.
 392
 393    Should it look at the most recently specified SAL?  If the target
 394    has no state, should this function try to extract a block from the
 395    most recently selected SAL?  That way `list foo' would give it some
 396    sort of reference point.  Then again, perhaphs that would confuse
 397    things.
 398
 399    Calls to this function can be broken down into two categories: Code
 400    that uses the selected block as an additional, but optional, data
 401    point; Code that uses the selected block as a prop, when it should
 402    have the relevant frame/block/pc explicitly passed in.
 403
 404    The latter can be eliminated by correctly parameterizing the code,
 405    the former though is more interesting.  Per the "address" command,
 406    it occures in the CLI code and makes it possible for commands to
 407    work, even when the inferior has no state.  */
 408
 409 extern struct block *get_selected_block (CORE_ADDR *addr_in_block);
 410
 411 extern struct symbol *get_frame_function (struct frame_info *);
 412
 413 extern CORE_ADDR frame_address_in_block (struct frame_info *);
 414
 415 extern CORE_ADDR get_pc_function_start (CORE_ADDR);
 416
 417 extern int frameless_look_for_prologue (struct frame_info *);
 418
 419 extern void print_frame_args (struct symbol *, struct frame_info *,
 420                               int, struct ui_file *);
 421
 422 extern struct frame_info *find_relative_frame (struct frame_info *, int *);
 423
 424 extern void show_and_print_stack_frame (struct frame_info *fi, int level,
 425                                         int source);
 426
 427 extern void print_stack_frame (struct frame_info *, int, int);
 428
 429 extern void show_stack_frame (struct frame_info *);
 430
 431 extern void print_frame_info (struct frame_info *, int, int, int);
 432
 433 extern void show_frame_info (struct frame_info *, int, int, int);
 434
 435 extern struct frame_info *block_innermost_frame (struct block *);
 436
 437 /* NOTE: cagney/2002-09-13: There is no need for this function.
 438    Instead either of frame_unwind_signed_register() or
 439    frame_unwind_unsigned_register() can be used.  */
 440 extern CORE_ADDR deprecated_read_register_dummy (CORE_ADDR pc,
 441                                                  CORE_ADDR fp, int);
 442 extern void generic_push_dummy_frame (void);
 443 extern void generic_pop_current_frame (void (*)(struct frame_info *));
 444 extern void generic_pop_dummy_frame (void);
 445
 446 extern int generic_pc_in_call_dummy (CORE_ADDR pc,
 447                                      CORE_ADDR sp, CORE_ADDR fp);
 448
 449 /* NOTE: cagney/2002-06-26: Targets should no longer use this
 450    function.  Instead, the contents of a dummy frames registers can be
 451    obtained by applying: frame_register_unwind to the dummy frame; or
 452    frame_register_unwind() to the next outer frame.  */
 453
 454 extern char *deprecated_generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp);
 455
 456 void generic_unwind_get_saved_register (char *raw_buffer,
 457                                         int *optimizedp,
 458                                         CORE_ADDR *addrp,
 459                                         struct frame_info *frame,
 460                                         int regnum,
 461                                         enum lval_type *lvalp);
 462
 463 /* The function generic_get_saved_register() has been made obsolete.
 464    DEPRECATED_GET_SAVED_REGISTER now defaults to the recursive
 465    equivalent - generic_unwind_get_saved_register() - so there is no
 466    need to even set DEPRECATED_GET_SAVED_REGISTER.  Architectures that
 467    need to override the register unwind mechanism should modify
 468    frame->unwind().  */
 469 extern void deprecated_generic_get_saved_register (char *, int *, CORE_ADDR *,
 470                                                    struct frame_info *, int,
 471                                                    enum lval_type *);
 472
 473 extern void generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi);
 474
 475 /* FIXME: cagney/2003-02-02: Should be deprecated or replaced with a
 476    function called frame_read_register_p().  This slightly weird (and
 477    older) variant of frame_read_register() returns zero (indicating
 478    the register is unavailable) if either: the register isn't cached;
 479    or the register has been optimized out.  Problem is, neither check
 480    is exactly correct.  A register can't be optimized out (it may not
 481    have been saved as part of a function call); The fact that a
 482    register isn't in the register cache doesn't mean that the register
 483    isn't available (it could have been fetched from memory).  */
 484
 485 extern int frame_register_read (struct frame_info *frame, int regnum,
 486                                 void *buf);
 487
 488 /* From stack.c.  */
 489 extern void args_info (char *, int);
 490
 491 extern void locals_info (char *, int);
 492
 493 extern void (*selected_frame_level_changed_hook) (int);
 494
 495 extern void return_command (char *, int);
 496
 497
 498 /* NOTE: cagney/2002-11-27:
 499
 500    You might think that the below global can simply be replaced by a
 501    call to either get_selected_frame() or select_frame().
 502
 503    Unfortunatly, it isn't that easy.
 504
 505    The relevant code needs to be audited to determine if it is
 506    possible (or pratical) to instead pass the applicable frame in as a
 507    parameter.  For instance, DEPRECATED_DO_REGISTERS_INFO() relied on
 508    the deprecated_selected_frame global, while its replacement,
 509    PRINT_REGISTERS_INFO(), is parameterized with the selected frame.
 510    The only real exceptions occure at the edge (in the CLI code) where
 511    user commands need to pick up the selected frame before proceeding.
 512
 513    This is important.  GDB is trying to stamp out the hack:
 514
 515    saved_frame = deprecated_selected_frame;
 516    deprecated_selected_frame = ...;
 517    hack_using_global_selected_frame ();
 518    deprecated_selected_frame = saved_frame;
 519
 520    Take care!  */
 521
 522 extern struct frame_info *deprecated_selected_frame;
 523
 524
 525 /* Create a frame using the specified BASE and PC.  */
 526
 527 extern struct frame_info *create_new_frame (CORE_ADDR base, CORE_ADDR pc);
 528
 529
 530 /* Create/access the frame's `extra info'.  The extra info is used by
 531    older code to store information such as the analyzed prologue.  The
 532    zalloc() should only be called by the INIT_EXTRA_INFO method.  */
 533
 534 extern struct frame_extra_info *frame_extra_info_zalloc (struct frame_info *fi,
 535                                                          long size);
 536 extern struct frame_extra_info *get_frame_extra_info (struct frame_info *fi);
 537
 538 /* Create/access the frame's `saved_regs'.  The saved regs are used by
 539    older code to store the address of each register (except for
 540    SP_REGNUM where the value of the register in the previous frame is
 541    stored).  */
 542 extern CORE_ADDR *frame_saved_regs_zalloc (struct frame_info *);
 543 extern CORE_ADDR *get_frame_saved_regs (struct frame_info *);
 544
 545 /* FIXME: cagney/2002-12-06: Has the PC in the current frame changed?
 546    "infrun.c", Thanks to DECR_PC_AFTER_BREAK, can change the PC after
 547    the initial frame create.  This puts things back in sync.  */
 548 extern void deprecated_update_frame_pc_hack (struct frame_info *frame,
 549                                              CORE_ADDR pc);
 550
 551 /* FIXME: cagney/2002-12-18: Has the frame's base changed?  Or to be
 552    more exact, whas that initial guess at the frame's base as returned
 553    by read_fp() wrong.  If it was, fix it.  This shouldn't be
 554    necessary since the code should be getting the frame's base correct
 555    from the outset.  */
 556 extern void deprecated_update_frame_base_hack (struct frame_info *frame,
 557                                                CORE_ADDR base);
 558
 559 /* FIXME: cagney/2003-01-04: Explicitly set the frame's saved_regs
 560    and/or extra_info.  Target code is allocating a fake frame and than
 561    initializing that to get around the problem of, when creating the
 562    inner most frame, there is no where to cache information such as
 563    the prologue analysis.  This is fixed by the new unwind mechanism -
 564    even the inner most frame has somewhere to store things like the
 565    prolog analysis (or at least will once the frame overhaul is
 566    finished).  */
 567 extern void deprecated_set_frame_saved_regs_hack (struct frame_info *frame,
 568                                                   CORE_ADDR *saved_regs);
 569 extern void deprecated_set_frame_extra_info_hack (struct frame_info *frame,
 570                                                   struct frame_extra_info *extra_info);
 571
 572 /* FIXME: cagney/2003-01-04: Allocate a frame from the heap (rather
 573    than the frame obstack).  Targets do this as a way of saving the
 574    prologue analysis from the inner most frame before that frame has
 575    been created.  By always creating a frame, this problem goes away.  */
 576 extern struct frame_info *deprecated_frame_xmalloc (void);
 577
 578 /* FIXME: cagney/2003-01-05: Allocate a frame, along with the
 579    saved_regs and extra_info.  Set up cleanups for all three.  Same as
 580    for deprecated_frame_xmalloc, targets are calling this when
 581    creating a scratch `struct frame_info'.  The frame overhaul makes
 582    this unnecessary since all frame queries are parameterized with a
 583    common cache parameter and a frame.  */
 584 extern struct frame_info *deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs,
 585                                                                  long sizeof_extra_info);
 586
 587 /* FIXME: cagney/2003-01-07: These are just nasty.  Code shouldn't be
 588    doing this.  I suspect it dates back to the days when every field
 589    of an allocated structure was explicitly initialized.  */
 590 extern void deprecated_set_frame_next_hack (struct frame_info *fi,
 591                                             struct frame_info *next);
 592 extern void deprecated_set_frame_prev_hack (struct frame_info *fi,
 593                                             struct frame_info *prev);
 594
 595 /* FIXME: cagney/2003-01-07: Instead of the dwarf2cfi having its own
 596    dedicated `struct frame_info . context' field, the code should use
 597    the per frame `unwind_cache' that is passed to the
 598    frame_pc_unwind(), frame_register_unwind() and frame_id_unwind()
 599    methods.
 600
 601    See "dummy-frame.c" for an example of how a cfi-frame object can be
 602    implemented using this.  */
 603 extern struct context *deprecated_get_frame_context (struct frame_info *fi);
 604 extern void deprecated_set_frame_context (struct frame_info *fi,
 605                                           struct context *context);
 606
 607 /* Return non-zero if the architecture is relying on legacy frame
 608    code.  */
 609 extern int legacy_frame_p (struct gdbarch *gdbarch);
 610
 611 #endif /* !defined (FRAME_H)  */