gdb/frame.c

   1 /* Cache and manage frames for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
   4    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 #include "defs.h"
  24 #include "frame.h"
  25 #include "target.h"
  26 #include "value.h"
  27 #include "inferior.h"   /* for inferior_ptid */
  28 #include "regcache.h"
  29 #include "gdb_assert.h"
  30 #include "gdb_string.h"
  31 #include "builtin-regs.h"
  32 #include "gdb_obstack.h"
  33 #include "dummy-frame.h"
  34 #include "sentinel-frame.h"
  35 #include "gdbcore.h"
  36 #include "annotate.h"
  37 #include "language.h"
  38 #include "frame-unwind.h"
  39 #include "frame-base.h"
  40 #include "command.h"
  41 #include "gdbcmd.h"
  42
  43 /* We keep a cache of stack frames, each of which is a "struct
  44    frame_info".  The innermost one gets allocated (in
  45    wait_for_inferior) each time the inferior stops; current_frame
  46    points to it.  Additional frames get allocated (in get_prev_frame)
  47    as needed, and are chained through the next and prev fields.  Any
  48    time that the frame cache becomes invalid (most notably when we
  49    execute something, but also if we change how we interpret the
  50    frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
  51    which reads new symbols)), we should call reinit_frame_cache.  */
  52
  53 struct frame_info
  54 {
  55   /* Level of this frame.  The inner-most (youngest) frame is at level
  56      0.  As you move towards the outer-most (oldest) frame, the level
  57      increases.  This is a cached value.  It could just as easily be
  58      computed by counting back from the selected frame to the inner
  59      most frame.  */
  60   /* NOTE: cagney/2002-04-05: Perhaphs a level of ``-1'' should be
  61      reserved to indicate a bogus frame - one that has been created
  62      just to keep GDB happy (GDB always needs a frame).  For the
  63      moment leave this as speculation.  */
  64   int level;
  65
  66   /* The frame's type.  */
  67   /* FIXME: cagney/2003-04-02: Should instead be returning
  68      ->unwind->type.  Unfortunatly, legacy code is still explicitly
  69      setting the type using the method deprecated_set_frame_type.
  70      Eliminate that method and this field can be eliminated.  */
  71   enum frame_type type;
  72
  73   /* For each register, address of where it was saved on entry to the
  74      frame, or zero if it was not saved on entry to this frame.  This
  75      includes special registers such as pc and fp saved in special
  76      ways in the stack frame.  The SP_REGNUM is even more special, the
  77      address here is the sp for the previous frame, not the address
  78      where the sp was saved.  */
  79   /* Allocated by frame_saved_regs_zalloc () which is called /
  80      initialized by DEPRECATED_FRAME_INIT_SAVED_REGS(). */
  81   CORE_ADDR *saved_regs;        /*NUM_REGS + NUM_PSEUDO_REGS*/
  82
  83   /* Anything extra for this structure that may have been defined in
  84      the machine dependent files. */
  85   /* Allocated by frame_extra_info_zalloc () which is called /
  86      initialized by DEPRECATED_INIT_EXTRA_FRAME_INFO */
  87   struct frame_extra_info *extra_info;
  88
  89   /* If dwarf2 unwind frame informations is used, this structure holds
  90      all related unwind data.  */
  91   struct context *context;
  92
  93   /* The frame's low-level unwinder and corresponding cache.  The
  94      low-level unwinder is responsible for unwinding register values
  95      for the previous frame.  The low-level unwind methods are
  96      selected based on the presence, or otherwize, of register unwind
  97      information such as CFI.  */
  98   void *prologue_cache;
  99   const struct frame_unwind *unwind;
 100
 101   /* Cached copy of the previous frame's resume address.  */
 102   struct {
 103     int p;
 104     CORE_ADDR value;
 105   } prev_pc;
 106
 107   /* Cached copy of the previous frame's function address.  */
 108   struct
 109   {
 110     CORE_ADDR addr;
 111     int p;
 112   } prev_func;
 113
 114   /* This frame's ID.  */
 115   struct
 116   {
 117     int p;
 118     struct frame_id value;
 119   } this_id;
 120
 121   /* The frame's high-level base methods, and corresponding cache.
 122      The high level base methods are selected based on the frame's
 123      debug info.  */
 124   const struct frame_base *base;
 125   void *base_cache;
 126
 127   /* Pointers to the next (down, inner, younger) and previous (up,
 128      outer, older) frame_info's in the frame cache.  */
 129   struct frame_info *next; /* down, inner, younger */
 130   int prev_p;
 131   struct frame_info *prev; /* up, outer, older */
 132 };
 133
 134 /* Flag to control debugging.  */
 135
 136 static int frame_debug;
 137
 138 /* Flag to indicate whether backtraces should stop at main.  */
 139
 140 static int backtrace_below_main;
 141
 142 void
 143 fprint_frame_id (struct ui_file *file, struct frame_id id)
 144 {
 145   fprintf_unfiltered (file, "{stack=0x%s,code=0x%s}",
 146                       paddr_nz (id.stack_addr),
 147                       paddr_nz (id.code_addr));
 148 }
 149
 150 static void
 151 fprint_frame_type (struct ui_file *file, enum frame_type type)
 152 {
 153   switch (type)
 154     {
 155     case UNKNOWN_FRAME:
 156       fprintf_unfiltered (file, "UNKNOWN_FRAME");
 157       return;
 158     case NORMAL_FRAME:
 159       fprintf_unfiltered (file, "NORMAL_FRAME");
 160       return;
 161     case DUMMY_FRAME:
 162       fprintf_unfiltered (file, "DUMMY_FRAME");
 163       return;
 164     case SIGTRAMP_FRAME:
 165       fprintf_unfiltered (file, "SIGTRAMP_FRAME");
 166       return;
 167     default:
 168       fprintf_unfiltered (file, "<unknown type>");
 169       return;
 170     };
 171 }
 172
 173 static void
 174 fprint_frame (struct ui_file *file, struct frame_info *fi)
 175 {
 176   if (fi == NULL)
 177     {
 178       fprintf_unfiltered (file, "<NULL frame>");
 179       return;
 180     }
 181   fprintf_unfiltered (file, "{");
 182   fprintf_unfiltered (file, "level=%d", fi->level);
 183   fprintf_unfiltered (file, ",");
 184   fprintf_unfiltered (file, "type=");
 185   fprint_frame_type (file, fi->type);
 186   fprintf_unfiltered (file, ",");
 187   fprintf_unfiltered (file, "unwind=");
 188   if (fi->unwind != NULL)
 189     gdb_print_host_address (fi->unwind, file);
 190   else
 191     fprintf_unfiltered (file, "<unknown>");
 192   fprintf_unfiltered (file, ",");
 193   fprintf_unfiltered (file, "pc=");
 194   if (fi->next != NULL && fi->next->prev_pc.p)
 195     fprintf_unfiltered (file, "0x%s", paddr_nz (fi->next->prev_pc.value));
 196   else
 197     fprintf_unfiltered (file, "<unknown>");
 198   fprintf_unfiltered (file, ",");
 199   fprintf_unfiltered (file, "id=");
 200   if (fi->this_id.p)
 201     fprint_frame_id (file, fi->this_id.value);
 202   else
 203     fprintf_unfiltered (file, "<unknown>");
 204   fprintf_unfiltered (file, ",");
 205   fprintf_unfiltered (file, "func=");
 206   if (fi->next != NULL && fi->next->prev_func.p)
 207     fprintf_unfiltered (file, "0x%s", paddr_nz (fi->next->prev_func.addr));
 208   else
 209     fprintf_unfiltered (file, "<unknown>");
 210   fprintf_unfiltered (file, "}");
 211 }
 212
 213 /* Return a frame uniq ID that can be used to, later, re-find the
 214    frame.  */
 215
 216 struct frame_id
 217 get_frame_id (struct frame_info *fi)
 218 {
 219   if (fi == NULL)
 220     {
 221       return null_frame_id;
 222     }
 223   if (!fi->this_id.p)
 224     {
 225       gdb_assert (!legacy_frame_p (current_gdbarch));
 226       if (frame_debug)
 227         fprintf_unfiltered (gdb_stdlog, "{ get_frame_id (fi=%d) ",
 228                             fi->level);
 229       /* Find the unwinder.  */
 230       if (fi->unwind == NULL)
 231         {
 232           fi->unwind = frame_unwind_find_by_pc (current_gdbarch,
 233                                                 get_frame_pc (fi));
 234           /* FIXME: cagney/2003-04-02: Rather than storing the frame's
 235              type in the frame, the unwinder's type should be returned
 236              directly.  Unfortunatly, legacy code, called by
 237              legacy_get_prev_frame, explicitly set the frames type
 238              using the method deprecated_set_frame_type().  */
 239           gdb_assert (fi->unwind->type != UNKNOWN_FRAME);
 240           fi->type = fi->unwind->type;
 241         }
 242       /* Find THIS frame's ID.  */
 243       fi->unwind->this_id (fi->next, &fi->prologue_cache, &fi->this_id.value);
 244       fi->this_id.p = 1;
 245       if (frame_debug)
 246         {
 247           fprintf_unfiltered (gdb_stdlog, "-> ");
 248           fprint_frame_id (gdb_stdlog, fi->this_id.value);
 249           fprintf_unfiltered (gdb_stdlog, " }\n");
 250         }
 251     }
 252   return fi->this_id.value;
 253 }
 254
 255 const struct frame_id null_frame_id; /* All zeros.  */
 256
 257 struct frame_id
 258 frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr)
 259 {
 260   struct frame_id id;
 261   id.stack_addr = stack_addr;
 262   id.code_addr = code_addr;
 263   return id;
 264 }
 265
 266 int
 267 frame_id_p (struct frame_id l)
 268 {
 269   int p;
 270   /* The .code can be NULL but the .stack cannot.  */
 271   p = (l.stack_addr != 0);
 272   if (frame_debug)
 273     {
 274       fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l=");
 275       fprint_frame_id (gdb_stdlog, l);
 276       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p);
 277     }
 278   return p;
 279 }
 280
 281 int
 282 frame_id_eq (struct frame_id l, struct frame_id r)
 283 {
 284   int eq;
 285   if (l.stack_addr == 0 || r.stack_addr == 0)
 286     /* Like a NaN, if either ID is invalid, the result is false.  */
 287     eq = 0;
 288   else if (l.stack_addr != r.stack_addr)
 289     /* If .stack addresses are different, the frames are different.  */
 290     eq = 0;
 291   else if (l.code_addr == 0 || r.code_addr == 0)
 292     /* A zero code addr is a wild card, always succeed.  */
 293     eq = 1;
 294   else if (l.code_addr == r.code_addr)
 295     /* The .stack and .code are identical, the ID's are identical.  */
 296     eq = 1;
 297   else
 298     /* No luck.  */
 299     eq = 0;
 300   if (frame_debug)
 301     {
 302       fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
 303       fprint_frame_id (gdb_stdlog, l);
 304       fprintf_unfiltered (gdb_stdlog, ",r=");
 305       fprint_frame_id (gdb_stdlog, r);
 306       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq);
 307     }
 308   return eq;
 309 }
 310
 311 int
 312 frame_id_inner (struct frame_id l, struct frame_id r)
 313 {
 314   int inner;
 315   if (l.stack_addr == 0 || r.stack_addr == 0)
 316     /* Like NaN, any operation involving an invalid ID always fails.  */
 317     inner = 0;
 318   else
 319     /* Only return non-zero when strictly inner than.  Note that, per
 320        comment in "frame.h", there is some fuzz here.  Frameless
 321        functions are not strictly inner than (same .stack but
 322        different .code).  */
 323     inner = INNER_THAN (l.stack_addr, r.stack_addr);
 324   if (frame_debug)
 325     {
 326       fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l=");
 327       fprint_frame_id (gdb_stdlog, l);
 328       fprintf_unfiltered (gdb_stdlog, ",r=");
 329       fprint_frame_id (gdb_stdlog, r);
 330       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner);
 331     }
 332   return inner;
 333 }
 334
 335 struct frame_info *
 336 frame_find_by_id (struct frame_id id)
 337 {
 338   struct frame_info *frame;
 339
 340   /* ZERO denotes the null frame, let the caller decide what to do
 341      about it.  Should it instead return get_current_frame()?  */
 342   if (!frame_id_p (id))
 343     return NULL;
 344
 345   for (frame = get_current_frame ();
 346        frame != NULL;
 347        frame = get_prev_frame (frame))
 348     {
 349       struct frame_id this = get_frame_id (frame);
 350       if (frame_id_eq (id, this))
 351         /* An exact match.  */
 352         return frame;
 353       if (frame_id_inner (id, this))
 354         /* Gone to far.  */
 355         return NULL;
 356       /* Either, we're not yet gone far enough out along the frame
 357          chain (inner(this,id), or we're comparing frameless functions
 358          (same .base, different .func, no test available).  Struggle
 359          on until we've definitly gone to far.  */
 360     }
 361   return NULL;
 362 }
 363
 364 CORE_ADDR
 365 frame_pc_unwind (struct frame_info *this_frame)
 366 {
 367   if (!this_frame->prev_pc.p)
 368     {
 369       CORE_ADDR pc;
 370       if (gdbarch_unwind_pc_p (current_gdbarch))
 371         {
 372           /* The right way.  The `pure' way.  The one true way.  This
 373              method depends solely on the register-unwind code to
 374              determine the value of registers in THIS frame, and hence
 375              the value of this frame's PC (resume address).  A typical
 376              implementation is no more than:
 377
 378              frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
 379              return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
 380
 381              Note: this method is very heavily dependent on a correct
 382              register-unwind implementation, it pays to fix that
 383              method first; this method is frame type agnostic, since
 384              it only deals with register values, it works with any
 385              frame.  This is all in stark contrast to the old
 386              FRAME_SAVED_PC which would try to directly handle all the
 387              different ways that a PC could be unwound.  */
 388           pc = gdbarch_unwind_pc (current_gdbarch, this_frame);
 389         }
 390       else if (this_frame->level < 0)
 391         {
 392           /* FIXME: cagney/2003-03-06: Old code and and a sentinel
 393              frame.  Do like was always done.  Fetch the PC's value
 394              direct from the global registers array (via read_pc).
 395              This assumes that this frame belongs to the current
 396              global register cache.  The assumption is dangerous.  */
 397           pc = read_pc ();
 398         }
 399       else if (DEPRECATED_FRAME_SAVED_PC_P ())
 400         {
 401           /* FIXME: cagney/2003-03-06: Old code, but not a sentinel
 402              frame.  Do like was always done.  Note that this method,
 403              unlike unwind_pc(), tries to handle all the different
 404              frame cases directly.  It fails.  */
 405           pc = DEPRECATED_FRAME_SAVED_PC (this_frame);
 406         }
 407       else
 408         internal_error (__FILE__, __LINE__, "No gdbarch_unwind_pc method");
 409       this_frame->prev_pc.value = pc;
 410       this_frame->prev_pc.p = 1;
 411       if (frame_debug)
 412         fprintf_unfiltered (gdb_stdlog,
 413                             "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
 414                             this_frame->level,
 415                             paddr_nz (this_frame->prev_pc.value));
 416     }
 417   return this_frame->prev_pc.value;
 418 }
 419
 420 CORE_ADDR
 421 frame_func_unwind (struct frame_info *fi)
 422 {
 423   if (!fi->prev_func.p)
 424     {
 425       fi->prev_func.p = 1;
 426       fi->prev_func.addr = get_pc_function_start (frame_pc_unwind (fi));
 427       if (frame_debug)
 428         fprintf_unfiltered (gdb_stdlog,
 429                             "{ frame_func_unwind (fi=%d) -> 0x%s }\n",
 430                             fi->level, paddr_nz (fi->prev_func.addr));
 431     }
 432   return fi->prev_func.addr;
 433 }
 434
 435 CORE_ADDR
 436 get_frame_func (struct frame_info *fi)
 437 {
 438   return frame_func_unwind (fi->next);
 439 }
 440
 441 static int
 442 do_frame_unwind_register (void *src, int regnum, void *buf)
 443 {
 444   frame_unwind_register (src, regnum, buf);
 445   return 1;
 446 }
 447
 448 void
 449 frame_pop (struct frame_info *this_frame)
 450 {
 451   struct regcache *scratch_regcache;
 452   struct cleanup *cleanups;
 453
 454   if (DEPRECATED_POP_FRAME_P ())
 455     {
 456       /* A legacy architecture that has implemented a custom pop
 457          function.  All new architectures should instead be using the
 458          generic code below.  */
 459       DEPRECATED_POP_FRAME;
 460     }
 461   else
 462     {
 463       /* Make a copy of all the register values unwound from this
 464          frame.  Save them in a scratch buffer so that there isn't a
 465          race betweening trying to extract the old values from the
 466          current_regcache while, at the same time writing new values
 467          into that same cache.  */
 468       struct regcache *scratch = regcache_xmalloc (current_gdbarch);
 469       struct cleanup *cleanups = make_cleanup_regcache_xfree (scratch);
 470       regcache_save (scratch, do_frame_unwind_register, this_frame);
 471       /* FIXME: cagney/2003-03-16: It should be possible to tell the
 472          target's register cache that it is about to be hit with a
 473          burst register transfer and that the sequence of register
 474          writes should be batched.  The pair target_prepare_to_store()
 475          and target_store_registers() kind of suggest this
 476          functionality.  Unfortunatly, they don't implement it.  Their
 477          lack of a formal definition can lead to targets writing back
 478          bogus values (arguably a bug in the target code mind).  */
 479       /* Now copy those saved registers into the current regcache.
 480          Here, regcache_cpy() calls regcache_restore().  */
 481       regcache_cpy (current_regcache, scratch);
 482       do_cleanups (cleanups);
 483     }
 484   /* We've made right mess of GDB's local state, just discard
 485      everything.  */
 486   flush_cached_frames ();
 487 }
 488
 489 void
 490 frame_register_unwind (struct frame_info *frame, int regnum,
 491                        int *optimizedp, enum lval_type *lvalp,
 492                        CORE_ADDR *addrp, int *realnump, void *bufferp)
 493 {
 494   struct frame_unwind_cache *cache;
 495
 496   if (frame_debug)
 497     {
 498       fprintf_unfiltered (gdb_stdlog,
 499                           "{ frame_register_unwind (frame=%d,regnum=\"%s\",...) ",
 500                           frame->level, frame_map_regnum_to_name (regnum));
 501     }
 502
 503   /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
 504      that the value proper does not need to be fetched.  */
 505   gdb_assert (optimizedp != NULL);
 506   gdb_assert (lvalp != NULL);
 507   gdb_assert (addrp != NULL);
 508   gdb_assert (realnump != NULL);
 509   /* gdb_assert (bufferp != NULL); */
 510
 511   /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
 512      is broken.  There is always a frame.  If there, for some reason,
 513      isn't, there is some pretty busted code as it should have
 514      detected the problem before calling here.  */
 515   gdb_assert (frame != NULL);
 516
 517   /* Find the unwinder.  */
 518   if (frame->unwind == NULL)
 519     {
 520       frame->unwind = frame_unwind_find_by_pc (current_gdbarch,
 521                                                get_frame_pc (frame));
 522       /* FIXME: cagney/2003-04-02: Rather than storing the frame's
 523          type in the frame, the unwinder's type should be returned
 524          directly.  Unfortunatly, legacy code, called by
 525          legacy_get_prev_frame, explicitly set the frames type using
 526          the method deprecated_set_frame_type().  */
 527       gdb_assert (frame->unwind->type != UNKNOWN_FRAME);
 528       frame->type = frame->unwind->type;
 529     }
 530
 531   /* Ask this frame to unwind its register.  See comment in
 532      "frame-unwind.h" for why NEXT frame and this unwind cace are
 533      passed in.  */
 534   frame->unwind->prev_register (frame->next, &frame->prologue_cache, regnum,
 535                                 optimizedp, lvalp, addrp, realnump, bufferp);
 536
 537   if (frame_debug)
 538     {
 539       fprintf_unfiltered (gdb_stdlog, "->");
 540       fprintf_unfiltered (gdb_stdlog, " *optimizedp=%d", (*optimizedp));
 541       fprintf_unfiltered (gdb_stdlog, " *lvalp=%d", (int) (*lvalp));
 542       fprintf_unfiltered (gdb_stdlog, " *addrp=0x%s", paddr_nz ((*addrp)));
 543       fprintf_unfiltered (gdb_stdlog, " *bufferp=");
 544       if (bufferp == NULL)
 545         fprintf_unfiltered (gdb_stdlog, "<NULL>");
 546       else
 547         {
 548           int i;
 549           const char *buf = bufferp;
 550           fprintf_unfiltered (gdb_stdlog, "[");
 551           for (i = 0; i < register_size (current_gdbarch, regnum); i++)
 552             fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
 553           fprintf_unfiltered (gdb_stdlog, "]");
 554         }
 555       fprintf_unfiltered (gdb_stdlog, " }\n");
 556     }
 557 }
 558
 559 void
 560 frame_register (struct frame_info *frame, int regnum,
 561                 int *optimizedp, enum lval_type *lvalp,
 562                 CORE_ADDR *addrp, int *realnump, void *bufferp)
 563 {
 564   /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
 565      that the value proper does not need to be fetched.  */
 566   gdb_assert (optimizedp != NULL);
 567   gdb_assert (lvalp != NULL);
 568   gdb_assert (addrp != NULL);
 569   gdb_assert (realnump != NULL);
 570   /* gdb_assert (bufferp != NULL); */
 571
 572   /* Ulgh!  Old code that, for lval_register, sets ADDRP to the offset
 573      of the register in the register cache.  It should instead return
 574      the REGNUM corresponding to that register.  Translate the .  */
 575   if (DEPRECATED_GET_SAVED_REGISTER_P ())
 576     {
 577       DEPRECATED_GET_SAVED_REGISTER (bufferp, optimizedp, addrp, frame,
 578                                      regnum, lvalp);
 579       /* Compute the REALNUM if the caller wants it.  */
 580       if (*lvalp == lval_register)
 581         {
 582           int regnum;
 583           for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
 584             {
 585               if (*addrp == register_offset_hack (current_gdbarch, regnum))
 586                 {
 587                   *realnump = regnum;
 588                   return;
 589                 }
 590             }
 591           internal_error (__FILE__, __LINE__,
 592                           "Failed to compute the register number corresponding"
 593                           " to 0x%s", paddr_d (*addrp));
 594         }
 595       *realnump = -1;
 596       return;
 597     }
 598
 599   /* Obtain the register value by unwinding the register from the next
 600      (more inner frame).  */
 601   gdb_assert (frame != NULL && frame->next != NULL);
 602   frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
 603                          realnump, bufferp);
 604 }
 605
 606 void
 607 frame_unwind_register (struct frame_info *frame, int regnum, void *buf)
 608 {
 609   int optimized;
 610   CORE_ADDR addr;
 611   int realnum;
 612   enum lval_type lval;
 613   frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
 614                          &realnum, buf);
 615 }
 616
 617 void
 618 frame_unwind_signed_register (struct frame_info *frame, int regnum,
 619                               LONGEST *val)
 620 {
 621   char buf[MAX_REGISTER_SIZE];
 622   frame_unwind_register (frame, regnum, buf);
 623   (*val) = extract_signed_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
 624 }
 625
 626 void
 627 frame_unwind_unsigned_register (struct frame_info *frame, int regnum,
 628                                 ULONGEST *val)
 629 {
 630   char buf[MAX_REGISTER_SIZE];
 631   frame_unwind_register (frame, regnum, buf);
 632   (*val) = extract_unsigned_integer (buf, REGISTER_VIRTUAL_SIZE (regnum));
 633 }
 634
 635 void
 636 frame_read_register (struct frame_info *frame, int regnum, void *buf)
 637 {
 638   gdb_assert (frame != NULL && frame->next != NULL);
 639   frame_unwind_register (frame->next, regnum, buf);
 640 }
 641
 642 void
 643 frame_read_unsigned_register (struct frame_info *frame, int regnum,
 644                               ULONGEST *val)
 645 {
 646   /* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is
 647      always a frame.  Both this, and the equivalent
 648      frame_read_signed_register() function, can only be called with a
 649      valid frame.  If, for some reason, this function is called
 650      without a frame then the problem isn't here, but rather in the
 651      caller.  It should of first created a frame and then passed that
 652      in.  */
 653   /* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the
 654      ``current_frame'' should not be treated as a special case.  While
 655      ``get_next_frame (current_frame) == NULL'' currently holds, it
 656      should, as far as possible, not be relied upon.  In the future,
 657      ``get_next_frame (current_frame)'' may instead simply return a
 658      normal frame object that simply always gets register values from
 659      the register cache.  Consequently, frame code should try to avoid
 660      tests like ``if get_next_frame() == NULL'' and instead just rely
 661      on recursive frame calls (like the below code) when manipulating
 662      a frame chain.  */
 663   gdb_assert (frame != NULL && frame->next != NULL);
 664   frame_unwind_unsigned_register (frame->next, regnum, val);
 665 }
 666
 667 void
 668 frame_read_signed_register (struct frame_info *frame, int regnum,
 669                             LONGEST *val)
 670 {
 671   /* See note above in frame_read_unsigned_register().  */
 672   gdb_assert (frame != NULL && frame->next != NULL);
 673   frame_unwind_signed_register (frame->next, regnum, val);
 674 }
 675
 676 void
 677 deprecated_unwind_get_saved_register (char *raw_buffer,
 678                                       int *optimizedp,
 679                                       CORE_ADDR *addrp,
 680                                       struct frame_info *frame,
 681                                       int regnum,
 682                                       enum lval_type *lvalp)
 683 {
 684   int optimizedx;
 685   CORE_ADDR addrx;
 686   int realnumx;
 687   enum lval_type lvalx;
 688
 689   if (!target_has_registers)
 690     error ("No registers.");
 691
 692   /* Keep things simple, ensure that all the pointers (except valuep)
 693      are non NULL.  */
 694   if (optimizedp == NULL)
 695     optimizedp = &optimizedx;
 696   if (lvalp == NULL)
 697     lvalp = &lvalx;
 698   if (addrp == NULL)
 699     addrp = &addrx;
 700
 701   gdb_assert (frame != NULL && frame->next != NULL);
 702   frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
 703                          &realnumx, raw_buffer);
 704 }
 705
 706 /* frame_register_read ()
 707
 708    Find and return the value of REGNUM for the specified stack frame.
 709    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 710
 711    Returns 0 if the register value could not be found.  */
 712
 713 int
 714 frame_register_read (struct frame_info *frame, int regnum, void *myaddr)
 715 {
 716   int optimized;
 717   enum lval_type lval;
 718   CORE_ADDR addr;
 719   int realnum;
 720   frame_register (frame, regnum, &optimized, &lval, &addr, &realnum, myaddr);
 721
 722   /* FIXME: cagney/2002-05-15: This test, is just bogus.
 723
 724      It indicates that the target failed to supply a value for a
 725      register because it was "not available" at this time.  Problem
 726      is, the target still has the register and so get saved_register()
 727      may be returning a value saved on the stack.  */
 728
 729   if (register_cached (regnum) < 0)
 730     return 0;                   /* register value not available */
 731
 732   return !optimized;
 733 }
 734
 735
 736 /* Map between a frame register number and its name.  A frame register
 737    space is a superset of the cooked register space --- it also
 738    includes builtin registers.  */
 739
 740 int
 741 frame_map_name_to_regnum (const char *name, int len)
 742 {
 743   int i;
 744
 745   if (len < 0)
 746     len = strlen (name);
 747
 748   /* Search register name space. */
 749   for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
 750     if (REGISTER_NAME (i) && len == strlen (REGISTER_NAME (i))
 751         && strncmp (name, REGISTER_NAME (i), len) == 0)
 752       {
 753         return i;
 754       }
 755
 756   /* Try builtin registers.  */
 757   i = builtin_reg_map_name_to_regnum (name, len);
 758   if (i >= 0)
 759     {
 760       /* A builtin register doesn't fall into the architecture's
 761          register range.  */
 762       gdb_assert (i >= NUM_REGS + NUM_PSEUDO_REGS);
 763       return i;
 764     }
 765
 766   return -1;
 767 }
 768
 769 const char *
 770 frame_map_regnum_to_name (int regnum)
 771 {
 772   if (regnum < 0)
 773     return NULL;
 774   if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
 775     return REGISTER_NAME (regnum);
 776   return builtin_reg_map_regnum_to_name (regnum);
 777 }
 778
 779 /* Create a sentinel frame.  */
 780
 781 static struct frame_info *
 782 create_sentinel_frame (struct regcache *regcache)
 783 {
 784   struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
 785   frame->type = NORMAL_FRAME;
 786   frame->level = -1;
 787   /* Explicitly initialize the sentinel frame's cache.  Provide it
 788      with the underlying regcache.  In the future additional
 789      information, such as the frame's thread will be added.  */
 790   frame->prologue_cache = sentinel_frame_cache (regcache);
 791   /* For the moment there is only one sentinel frame implementation.  */
 792   frame->unwind = sentinel_frame_unwind;
 793   /* Link this frame back to itself.  The frame is self referential
 794      (the unwound PC is the same as the pc), so make it so.  */
 795   frame->next = frame;
 796   /* Make the sentinel frame's ID valid, but invalid.  That way all
 797      comparisons with it should fail.  */
 798   frame->this_id.p = 1;
 799   frame->this_id.value = null_frame_id;
 800   if (frame_debug)
 801     {
 802       fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> ");
 803       fprint_frame (gdb_stdlog, frame);
 804       fprintf_unfiltered (gdb_stdlog, " }\n");
 805     }
 806   return frame;
 807 }
 808
 809 /* Info about the innermost stack frame (contents of FP register) */
 810
 811 static struct frame_info *current_frame;
 812
 813 /* Cache for frame addresses already read by gdb.  Valid only while
 814    inferior is stopped.  Control variables for the frame cache should
 815    be local to this module.  */
 816
 817 static struct obstack frame_cache_obstack;
 818
 819 void *
 820 frame_obstack_zalloc (unsigned long size)
 821 {
 822   void *data = obstack_alloc (&frame_cache_obstack, size);
 823   memset (data, 0, size);
 824   return data;
 825 }
 826
 827 CORE_ADDR *
 828 frame_saved_regs_zalloc (struct frame_info *fi)
 829 {
 830   fi->saved_regs = (CORE_ADDR *)
 831     frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS);
 832   return fi->saved_regs;
 833 }
 834
 835 CORE_ADDR *
 836 get_frame_saved_regs (struct frame_info *fi)
 837 {
 838   return fi->saved_regs;
 839 }
 840
 841 /* Return the innermost (currently executing) stack frame.  This is
 842    split into two functions.  The function unwind_to_current_frame()
 843    is wrapped in catch exceptions so that, even when the unwind of the
 844    sentinel frame fails, the function still returns a stack frame.  */
 845
 846 static int
 847 unwind_to_current_frame (struct ui_out *ui_out, void *args)
 848 {
 849   struct frame_info *frame = get_prev_frame (args);
 850   /* A sentinel frame can fail to unwind, eg, because it's PC value
 851      lands in somewhere like start.  */
 852   if (frame == NULL)
 853     return 1;
 854   current_frame = frame;
 855   return 0;
 856 }
 857
 858 struct frame_info *
 859 get_current_frame (void)
 860 {
 861   /* First check, and report, the lack of registers.  Having GDB
 862      report "No stack!" or "No memory" when the target doesn't even
 863      have registers is very confusing.  Besides, "printcmd.exp"
 864      explicitly checks that ``print $pc'' with no registers prints "No
 865      registers".  */
 866   if (!target_has_registers)
 867     error ("No registers.");
 868   if (!target_has_stack)
 869     error ("No stack.");
 870   if (!target_has_memory)
 871     error ("No memory.");
 872   if (current_frame == NULL)
 873     {
 874       struct frame_info *sentinel_frame =
 875         create_sentinel_frame (current_regcache);
 876       if (catch_exceptions (uiout, unwind_to_current_frame, sentinel_frame,
 877                             NULL, RETURN_MASK_ERROR) != 0)
 878         {
 879           /* Oops! Fake a current frame?  Is this useful?  It has a PC
 880              of zero, for instance.  */
 881           current_frame = sentinel_frame;
 882         }
 883     }
 884   return current_frame;
 885 }
 886
 887 /* The "selected" stack frame is used by default for local and arg
 888    access.  May be zero, for no selected frame.  */
 889
 890 struct frame_info *deprecated_selected_frame;
 891
 892 /* Return the selected frame.  Always non-null (unless there isn't an
 893    inferior sufficient for creating a frame) in which case an error is
 894    thrown.  */
 895
 896 struct frame_info *
 897 get_selected_frame (void)
 898 {
 899   if (deprecated_selected_frame == NULL)
 900     /* Hey!  Don't trust this.  It should really be re-finding the
 901        last selected frame of the currently selected thread.  This,
 902        though, is better than nothing.  */
 903     select_frame (get_current_frame ());
 904   /* There is always a frame.  */
 905   gdb_assert (deprecated_selected_frame != NULL);
 906   return deprecated_selected_frame;
 907 }
 908
 909 /* Select frame FI (or NULL - to invalidate the current frame).  */
 910
 911 void
 912 select_frame (struct frame_info *fi)
 913 {
 914   register struct symtab *s;
 915
 916   deprecated_selected_frame = fi;
 917   /* NOTE: cagney/2002-05-04: FI can be NULL.  This occures when the
 918      frame is being invalidated.  */
 919   if (selected_frame_level_changed_hook)
 920     selected_frame_level_changed_hook (frame_relative_level (fi));
 921
 922   /* FIXME: kseitz/2002-08-28: It would be nice to call
 923      selected_frame_level_changed_event right here, but due to limitations
 924      in the current interfaces, we would end up flooding UIs with events
 925      because select_frame is used extensively internally.
 926
 927      Once we have frame-parameterized frame (and frame-related) commands,
 928      the event notification can be moved here, since this function will only
 929      be called when the users selected frame is being changed. */
 930
 931   /* Ensure that symbols for this frame are read in.  Also, determine the
 932      source language of this frame, and switch to it if desired.  */
 933   if (fi)
 934     {
 935       s = find_pc_symtab (get_frame_pc (fi));
 936       if (s
 937           && s->language != current_language->la_language
 938           && s->language != language_unknown
 939           && language_mode == language_mode_auto)
 940         {
 941           set_language (s->language);
 942         }
 943     }
 944 }
 945
 946 /* Return the register saved in the simplistic ``saved_regs'' cache.
 947    If the value isn't here AND a value is needed, try the next inner
 948    most frame.  */
 949
 950 static void
 951 legacy_saved_regs_prev_register (struct frame_info *next_frame,
 952                                  void **this_prologue_cache,
 953                                  int regnum, int *optimizedp,
 954                                  enum lval_type *lvalp, CORE_ADDR *addrp,
 955                                  int *realnump, void *bufferp)
 956 {
 957   /* HACK: New code is passed the next frame and this cache.
 958      Unfortunatly, old code expects this frame.  Since this is a
 959      backward compatibility hack, cheat by walking one level along the
 960      prologue chain to the frame the old code expects.
 961
 962      Do not try this at home.  Professional driver, closed course.  */
 963   struct frame_info *frame = next_frame->prev;
 964   gdb_assert (frame != NULL);
 965
 966   /* Only (older) architectures that implement the
 967      DEPRECATED_FRAME_INIT_SAVED_REGS method should be using this
 968      function.  */
 969   gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
 970
 971   /* Load the saved_regs register cache.  */
 972   if (get_frame_saved_regs (frame) == NULL)
 973     DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
 974
 975   if (get_frame_saved_regs (frame) != NULL
 976       && get_frame_saved_regs (frame)[regnum] != 0)
 977     {
 978       if (regnum == SP_REGNUM)
 979         {
 980           /* SP register treated specially.  */
 981           *optimizedp = 0;
 982           *lvalp = not_lval;
 983           *addrp = 0;
 984           *realnump = -1;
 985           if (bufferp != NULL)
 986             /* NOTE: cagney/2003-05-09: In-lined store_address with
 987                it's body - store_unsigned_integer.  */
 988             store_unsigned_integer (bufferp, REGISTER_RAW_SIZE (regnum),
 989                                     get_frame_saved_regs (frame)[regnum]);
 990         }
 991       else
 992         {
 993           /* Any other register is saved in memory, fetch it but cache
 994              a local copy of its value.  */
 995           *optimizedp = 0;
 996           *lvalp = lval_memory;
 997           *addrp = get_frame_saved_regs (frame)[regnum];
 998           *realnump = -1;
 999           if (bufferp != NULL)
1000             {
1001 #if 1
1002               /* Save each register value, as it is read in, in a
1003                  frame based cache.  */
1004               void **regs = (*this_prologue_cache);
1005               if (regs == NULL)
1006                 {
1007                   int sizeof_cache = ((NUM_REGS + NUM_PSEUDO_REGS)
1008                                       * sizeof (void *));
1009                   regs = frame_obstack_zalloc (sizeof_cache);
1010                   (*this_prologue_cache) = regs;
1011                 }
1012               if (regs[regnum] == NULL)
1013                 {
1014                   regs[regnum]
1015                     = frame_obstack_zalloc (REGISTER_RAW_SIZE (regnum));
1016                   read_memory (get_frame_saved_regs (frame)[regnum], regs[regnum],
1017                                REGISTER_RAW_SIZE (regnum));
1018                 }
1019               memcpy (bufferp, regs[regnum], REGISTER_RAW_SIZE (regnum));
1020 #else
1021               /* Read the value in from memory.  */
1022               read_memory (get_frame_saved_regs (frame)[regnum], bufferp,
1023                            REGISTER_RAW_SIZE (regnum));
1024 #endif
1025             }
1026         }
1027       return;
1028     }
1029
1030   /* No luck.  Assume this and the next frame have the same register
1031      value.  Pass the unwind request down the frame chain to the next
1032      frame.  Hopefully that frame will find the register's location.  */
1033   frame_register_unwind (next_frame, regnum, optimizedp, lvalp, addrp,
1034                          realnump, bufferp);
1035 }
1036
1037 static void
1038 legacy_saved_regs_this_id (struct frame_info *next_frame,
1039                            void **this_prologue_cache,
1040                            struct frame_id *id)
1041 {
1042   /* legacy_get_prev_frame() always sets ->this_id.p, hence this is
1043      never needed.  */
1044   internal_error (__FILE__, __LINE__, "legacy_saved_regs_this_id() called");
1045 }
1046
1047 const struct frame_unwind legacy_saved_regs_unwinder = {
1048   /* Not really.  It gets overridden by legacy_get_prev_frame.  */
1049   UNKNOWN_FRAME,
1050   legacy_saved_regs_this_id,
1051   legacy_saved_regs_prev_register
1052 };
1053 const struct frame_unwind *legacy_saved_regs_unwind = &legacy_saved_regs_unwinder;
1054
1055
1056 /* Function: deprecated_generic_get_saved_register
1057    Find register number REGNUM relative to FRAME and put its (raw,
1058    target format) contents in *RAW_BUFFER.
1059
1060    Set *OPTIMIZED if the variable was optimized out (and thus can't be
1061    fetched).  Note that this is never set to anything other than zero
1062    in this implementation.
1063
1064    Set *LVAL to lval_memory, lval_register, or not_lval, depending on
1065    whether the value was fetched from memory, from a register, or in a
1066    strange and non-modifiable way (e.g. a frame pointer which was
1067    calculated rather than fetched).  We will use not_lval for values
1068    fetched from generic dummy frames.
1069
1070    Set *ADDRP to the address, either in memory or as a REGISTER_BYTE
1071    offset into the registers array.  If the value is stored in a dummy
1072    frame, set *ADDRP to zero.
1073
1074    The argument RAW_BUFFER must point to aligned memory.  */
1075
1076 void
1077 deprecated_generic_get_saved_register (char *raw_buffer, int *optimized,
1078                                        CORE_ADDR *addrp,
1079                                        struct frame_info *frame, int regnum,
1080                                        enum lval_type *lval)
1081 {
1082   if (!target_has_registers)
1083     error ("No registers.");
1084
1085   gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
1086
1087   /* Normal systems don't optimize out things with register numbers.  */
1088   if (optimized != NULL)
1089     *optimized = 0;
1090
1091   if (addrp)                    /* default assumption: not found in memory */
1092     *addrp = 0;
1093
1094   /* Note: since the current frame's registers could only have been
1095      saved by frames INTERIOR TO the current frame, we skip examining
1096      the current frame itself: otherwise, we would be getting the
1097      previous frame's registers which were saved by the current frame.  */
1098
1099   if (frame != NULL)
1100     {
1101       for (frame = get_next_frame (frame);
1102            frame_relative_level (frame) >= 0;
1103            frame = get_next_frame (frame))
1104         {
1105           if (get_frame_type (frame) == DUMMY_FRAME)
1106             {
1107               if (lval)         /* found it in a CALL_DUMMY frame */
1108                 *lval = not_lval;
1109               if (raw_buffer)
1110                 /* FIXME: cagney/2002-06-26: This should be via the
1111                    gdbarch_register_read() method so that it, on the
1112                    fly, constructs either a raw or pseudo register
1113                    from the raw register cache.  */
1114                 regcache_raw_read
1115                   (deprecated_find_dummy_frame_regcache (get_frame_pc (frame),
1116                                                          get_frame_base (frame)),
1117                    regnum, raw_buffer);
1118               return;
1119             }
1120
1121           DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
1122           if (get_frame_saved_regs (frame) != NULL
1123               && get_frame_saved_regs (frame)[regnum] != 0)
1124             {
1125               if (lval)         /* found it saved on the stack */
1126                 *lval = lval_memory;
1127               if (regnum == SP_REGNUM)
1128                 {
1129                   if (raw_buffer)       /* SP register treated specially */
1130                     /* NOTE: cagney/2003-05-09: In-line store_address
1131                        with it's body - store_unsigned_integer.  */
1132                     store_unsigned_integer (raw_buffer,
1133                                             REGISTER_RAW_SIZE (regnum),
1134                                             get_frame_saved_regs (frame)[regnum]);
1135                 }
1136               else
1137                 {
1138                   if (addrp)    /* any other register */
1139                     *addrp = get_frame_saved_regs (frame)[regnum];
1140                   if (raw_buffer)
1141                     read_memory (get_frame_saved_regs (frame)[regnum], raw_buffer,
1142                                  REGISTER_RAW_SIZE (regnum));
1143                 }
1144               return;
1145             }
1146         }
1147     }
1148
1149   /* If we get thru the loop to this point, it means the register was
1150      not saved in any frame.  Return the actual live-register value.  */
1151
1152   if (lval)                     /* found it in a live register */
1153     *lval = lval_register;
1154   if (addrp)
1155     *addrp = REGISTER_BYTE (regnum);
1156   if (raw_buffer)
1157     deprecated_read_register_gen (regnum, raw_buffer);
1158 }
1159
1160 /* Determine the frame's type based on its PC.  */
1161
1162 static enum frame_type
1163 frame_type_from_pc (CORE_ADDR pc)
1164 {
1165   /* FIXME: cagney/2002-11-24: Can't yet directly call
1166      pc_in_dummy_frame() as some architectures don't set
1167      PC_IN_CALL_DUMMY() to generic_pc_in_call_dummy() (remember the
1168      latter is implemented by simply calling pc_in_dummy_frame).  */
1169   if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1170       && DEPRECATED_PC_IN_CALL_DUMMY (pc, 0, 0))
1171     return DUMMY_FRAME;
1172   else
1173     {
1174       char *name;
1175       find_pc_partial_function (pc, &name, NULL, NULL);
1176       if (PC_IN_SIGTRAMP (pc, name))
1177         return SIGTRAMP_FRAME;
1178       else
1179         return NORMAL_FRAME;
1180     }
1181 }
1182
1183 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1184    Always returns a non-NULL value.  */
1185
1186 struct frame_info *
1187 create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
1188 {
1189   struct frame_info *fi;
1190
1191   if (frame_debug)
1192     {
1193       fprintf_unfiltered (gdb_stdlog,
1194                           "{ create_new_frame (addr=0x%s, pc=0x%s) ",
1195                           paddr_nz (addr), paddr_nz (pc));
1196     }
1197
1198   fi = frame_obstack_zalloc (sizeof (struct frame_info));
1199
1200   fi->next = create_sentinel_frame (current_regcache);
1201
1202   /* Select/initialize both the unwind function and the frame's type
1203      based on the PC.  */
1204   fi->unwind = frame_unwind_find_by_pc (current_gdbarch, pc);
1205   if (fi->unwind->type != UNKNOWN_FRAME)
1206     fi->type = fi->unwind->type;
1207   else
1208     fi->type = frame_type_from_pc (pc);
1209
1210   fi->this_id.p = 1;
1211   deprecated_update_frame_base_hack (fi, addr);
1212   deprecated_update_frame_pc_hack (fi, pc);
1213
1214   if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1215     DEPRECATED_INIT_EXTRA_FRAME_INFO (0, fi);
1216
1217   if (frame_debug)
1218     {
1219       fprintf_unfiltered (gdb_stdlog, "-> ");
1220       fprint_frame (gdb_stdlog, fi);
1221       fprintf_unfiltered (gdb_stdlog, " }\n");
1222     }
1223
1224   return fi;
1225 }
1226
1227 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1228    innermost frame).  Be careful to not fall off the bottom of the
1229    frame chain and onto the sentinel frame.  */
1230
1231 struct frame_info *
1232 get_next_frame (struct frame_info *this_frame)
1233 {
1234   if (this_frame->level > 0)
1235     return this_frame->next;
1236   else
1237     return NULL;
1238 }
1239
1240 /* Flush the entire frame cache.  */
1241
1242 void
1243 flush_cached_frames (void)
1244 {
1245   /* Since we can't really be sure what the first object allocated was */
1246   obstack_free (&frame_cache_obstack, 0);
1247   obstack_init (&frame_cache_obstack);
1248
1249   current_frame = NULL;         /* Invalidate cache */
1250   select_frame (NULL);
1251   annotate_frames_invalid ();
1252   if (frame_debug)
1253     fprintf_unfiltered (gdb_stdlog, "{ flush_cached_frames () }\n");
1254 }
1255
1256 /* Flush the frame cache, and start a new one if necessary.  */
1257
1258 void
1259 reinit_frame_cache (void)
1260 {
1261   flush_cached_frames ();
1262
1263   /* FIXME: The inferior_ptid test is wrong if there is a corefile.  */
1264   if (PIDGET (inferior_ptid) != 0)
1265     {
1266       select_frame (get_current_frame ());
1267     }
1268 }
1269
1270 /* Create the previous frame using the deprecated methods
1271    INIT_EXTRA_INFO, INIT_FRAME_PC and INIT_FRAME_PC_FIRST.  */
1272
1273 static struct frame_info *
1274 legacy_get_prev_frame (struct frame_info *this_frame)
1275 {
1276   CORE_ADDR address = 0;
1277   struct frame_info *prev;
1278   int fromleaf;
1279
1280   /* Don't frame_debug print legacy_get_prev_frame() here, just
1281      confuses the output.  */
1282
1283   /* Allocate the new frame.
1284
1285      There is no reason to worry about memory leaks, should the
1286      remainder of the function fail.  The allocated memory will be
1287      quickly reclaimed when the frame cache is flushed, and the `we've
1288      been here before' check, in get_prev_frame will stop repeated
1289      memory allocation calls.  */
1290   prev = FRAME_OBSTACK_ZALLOC (struct frame_info);
1291   prev->level = this_frame->level + 1;
1292
1293   /* Do not completly wire it in to the frame chain.  Some (bad) code
1294      in INIT_FRAME_EXTRA_INFO tries to look along frame->prev to pull
1295      some fancy tricks (of course such code is, by definition,
1296      recursive).
1297
1298      On the other hand, methods, such as get_frame_pc() and
1299      get_frame_base() rely on being able to walk along the frame
1300      chain.  Make certain that at least they work by providing that
1301      link.  Of course things manipulating prev can't go back.  */
1302   prev->next = this_frame;
1303
1304   /* NOTE: cagney/2002-11-18: Should have been correctly setting the
1305      frame's type here, before anything else, and not last, at the
1306      bottom of this function.  The various
1307      DEPRECATED_INIT_EXTRA_FRAME_INFO, DEPRECATED_INIT_FRAME_PC,
1308      DEPRECATED_INIT_FRAME_PC_FIRST and
1309      DEPRECATED_FRAME_INIT_SAVED_REGS methods are full of work-arounds
1310      that handle the frame not being correctly set from the start.
1311      Unfortunatly those same work-arounds rely on the type defaulting
1312      to NORMAL_FRAME.  Ulgh!  The new frame code does not have this
1313      problem.  */
1314   prev->type = UNKNOWN_FRAME;
1315
1316   /* A legacy frame's ID is always computed here.  Mark it as valid.  */
1317   prev->this_id.p = 1;
1318
1319   /* Handle sentinel frame unwind as a special case.  */
1320   if (this_frame->level < 0)
1321     {
1322       /* Try to unwind the PC.  If that doesn't work, assume we've reached
1323          the oldest frame and simply return.  Is there a better sentinal
1324          value?  The unwound PC value is then used to initialize the new
1325          previous frame's type.
1326
1327          Note that the pc-unwind is intentionally performed before the
1328          frame chain.  This is ok since, for old targets, both
1329          frame_pc_unwind (nee, DEPRECATED_FRAME_SAVED_PC) and
1330          DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
1331          have already been initialized (using
1332          DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
1333          doesn't matter.
1334
1335          By unwinding the PC first, it becomes possible to, in the case of
1336          a dummy frame, avoid also unwinding the frame ID.  This is
1337          because (well ignoring the PPC) a dummy frame can be located
1338          using THIS_FRAME's frame ID.  */
1339
1340       deprecated_update_frame_pc_hack (prev, frame_pc_unwind (this_frame));
1341       if (get_frame_pc (prev) == 0)
1342         {
1343           /* The allocated PREV_FRAME will be reclaimed when the frame
1344              obstack is next purged.  */
1345           if (frame_debug)
1346             {
1347               fprintf_unfiltered (gdb_stdlog, "-> ");
1348               fprint_frame (gdb_stdlog, NULL);
1349               fprintf_unfiltered (gdb_stdlog,
1350                                   " // unwound legacy PC zero }\n");
1351             }
1352           return NULL;
1353         }
1354
1355       /* Set the unwind functions based on that identified PC.  Ditto
1356          for the "type" but strongly prefer the unwinder's frame type.  */
1357       prev->unwind = frame_unwind_find_by_pc (current_gdbarch,
1358                                               get_frame_pc (prev));
1359       if (prev->unwind->type == UNKNOWN_FRAME)
1360         prev->type = frame_type_from_pc (get_frame_pc (prev));
1361       else
1362         prev->type = prev->unwind->type;
1363
1364       /* Find the prev's frame's ID.  */
1365       if (prev->type == DUMMY_FRAME
1366           && gdbarch_unwind_dummy_id_p (current_gdbarch))
1367         {
1368           /* When unwinding a normal frame, the stack structure is
1369              determined by analyzing the frame's function's code (be
1370              it using brute force prologue analysis, or the dwarf2
1371              CFI).  In the case of a dummy frame, that simply isn't
1372              possible.  The The PC is either the program entry point,
1373              or some random address on the stack.  Trying to use that
1374              PC to apply standard frame ID unwind techniques is just
1375              asking for trouble.  */
1376           /* Assume call_function_by_hand(), via SAVE_DUMMY_FRAME_TOS,
1377              previously saved the dummy frame's ID.  Things only work
1378              if the two return the same value.  */
1379           gdb_assert (SAVE_DUMMY_FRAME_TOS_P ());
1380           /* Use an architecture specific method to extract the prev's
1381              dummy ID from the next frame.  Note that this method uses
1382              frame_register_unwind to obtain the register values
1383              needed to determine the dummy frame's ID.  */
1384           prev->this_id.value = gdbarch_unwind_dummy_id (current_gdbarch,
1385                                                          this_frame);
1386         }
1387       else
1388         {
1389           /* We're unwinding a sentinel frame, the PC of which is
1390              pointing at a stack dummy.  Fake up the dummy frame's ID
1391              using the same sequence as is found a traditional
1392              unwinder.  Once all architectures supply the
1393              unwind_dummy_id method, this code can go away.  */
1394           prev->this_id.value = frame_id_build (deprecated_read_fp (),
1395                                                 read_pc ());
1396         }
1397
1398       /* Check that the unwound ID is valid.  */
1399       if (!frame_id_p (prev->this_id.value))
1400         {
1401           if (frame_debug)
1402             {
1403               fprintf_unfiltered (gdb_stdlog, "-> ");
1404               fprint_frame (gdb_stdlog, NULL);
1405               fprintf_unfiltered (gdb_stdlog,
1406                                   " // unwound legacy ID invalid }\n");
1407             }
1408           return NULL;
1409         }
1410
1411       /* Check that the new frame isn't inner to (younger, below,
1412          next) the old frame.  If that happens the frame unwind is
1413          going backwards.  */
1414       /* FIXME: cagney/2003-02-25: Ignore the sentinel frame since
1415          that doesn't have a valid frame ID.  Should instead set the
1416          sentinel frame's frame ID to a `sentinel'.  Leave it until
1417          after the switch to storing the frame ID, instead of the
1418          frame base, in the frame object.  */
1419
1420       /* Link it in.  */
1421       this_frame->prev = prev;
1422
1423       /* FIXME: cagney/2002-01-19: This call will go away.  Instead of
1424          initializing extra info, all frames will use the frame_cache
1425          (passed to the unwind functions) to store additional frame
1426          info.  Unfortunatly legacy targets can't use
1427          legacy_get_prev_frame() to unwind the sentinel frame and,
1428          consequently, are forced to take this code path and rely on
1429          the below call to DEPRECATED_INIT_EXTRA_FRAME_INFO to
1430          initialize the inner-most frame.  */
1431       if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1432         {
1433           DEPRECATED_INIT_EXTRA_FRAME_INFO (0, prev);
1434         }
1435
1436       if (prev->type == NORMAL_FRAME)
1437         prev->this_id.value.code_addr
1438           = get_pc_function_start (prev->this_id.value.code_addr);
1439
1440       if (frame_debug)
1441         {
1442           fprintf_unfiltered (gdb_stdlog, "-> ");
1443           fprint_frame (gdb_stdlog, prev);
1444           fprintf_unfiltered (gdb_stdlog, " } // legacy innermost frame\n");
1445         }
1446       return prev;
1447     }
1448
1449   /* This code only works on normal frames.  A sentinel frame, where
1450      the level is -1, should never reach this code.  */
1451   gdb_assert (this_frame->level >= 0);
1452
1453   /* On some machines it is possible to call a function without
1454      setting up a stack frame for it.  On these machines, we
1455      define this macro to take two args; a frameinfo pointer
1456      identifying a frame and a variable to set or clear if it is
1457      or isn't leafless.  */
1458
1459   /* Still don't want to worry about this except on the innermost
1460      frame.  This macro will set FROMLEAF if THIS_FRAME is a frameless
1461      function invocation.  */
1462   if (this_frame->level == 0)
1463     /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
1464        the frame chain, not just the inner most frame!  The generic,
1465        per-architecture, frame code should handle this and the below
1466        should simply be removed.  */
1467     fromleaf = FRAMELESS_FUNCTION_INVOCATION (this_frame);
1468   else
1469     fromleaf = 0;
1470
1471   if (fromleaf)
1472     /* A frameless inner-most frame.  The `FP' (which isn't an
1473        architecture frame-pointer register!) of the caller is the same
1474        as the callee.  */
1475     /* FIXME: 2002-11-09: There isn't any reason to special case this
1476        edge condition.  Instead the per-architecture code should hande
1477        it locally.  */
1478     address = get_frame_base (this_frame);
1479   else
1480     {
1481       /* Two macros defined in tm.h specify the machine-dependent
1482          actions to be performed here.
1483
1484          First, get the frame's chain-pointer.
1485
1486          If that is zero, the frame is the outermost frame or a leaf
1487          called by the outermost frame.  This means that if start
1488          calls main without a frame, we'll return 0 (which is fine
1489          anyway).
1490
1491          Nope; there's a problem.  This also returns when the current
1492          routine is a leaf of main.  This is unacceptable.  We move
1493          this to after the ffi test; I'd rather have backtraces from
1494          start go curfluy than have an abort called from main not show
1495          main.  */
1496       gdb_assert (DEPRECATED_FRAME_CHAIN_P ());
1497       address = DEPRECATED_FRAME_CHAIN (this_frame);
1498
1499       if (!legacy_frame_chain_valid (address, this_frame))
1500         {
1501           if (frame_debug)
1502             {
1503               fprintf_unfiltered (gdb_stdlog, "-> ");
1504               fprint_frame (gdb_stdlog, NULL);
1505               fprintf_unfiltered (gdb_stdlog,
1506                                   " // legacy frame chain invalid }\n");
1507             }
1508           return NULL;
1509         }
1510     }
1511   if (address == 0)
1512     {
1513       if (frame_debug)
1514         {
1515           fprintf_unfiltered (gdb_stdlog, "-> ");
1516           fprint_frame (gdb_stdlog, NULL);
1517           fprintf_unfiltered (gdb_stdlog,
1518                               " // legacy frame chain NULL }\n");
1519         }
1520       return NULL;
1521     }
1522
1523   /* Link in the already allocated prev frame.  */
1524   this_frame->prev = prev;
1525   deprecated_update_frame_base_hack (prev, address);
1526
1527   /* This change should not be needed, FIXME!  We should determine
1528      whether any targets *need* DEPRECATED_INIT_FRAME_PC to happen
1529      after DEPRECATED_INIT_EXTRA_FRAME_INFO and come up with a simple
1530      way to express what goes on here.
1531
1532      DEPRECATED_INIT_EXTRA_FRAME_INFO is called from two places:
1533      create_new_frame (where the PC is already set up) and here (where
1534      it isn't).  DEPRECATED_INIT_FRAME_PC is only called from here,
1535      always after DEPRECATED_INIT_EXTRA_FRAME_INFO.
1536
1537      The catch is the MIPS, where DEPRECATED_INIT_EXTRA_FRAME_INFO
1538      requires the PC value (which hasn't been set yet).  Some other
1539      machines appear to require DEPRECATED_INIT_EXTRA_FRAME_INFO
1540      before they can do DEPRECATED_INIT_FRAME_PC.  Phoo.
1541
1542      We shouldn't need DEPRECATED_INIT_FRAME_PC_FIRST to add more
1543      complication to an already overcomplicated part of GDB.
1544      gnu@cygnus.com, 15Sep92.
1545
1546      Assuming that some machines need DEPRECATED_INIT_FRAME_PC after
1547      DEPRECATED_INIT_EXTRA_FRAME_INFO, one possible scheme:
1548
1549      SETUP_INNERMOST_FRAME(): Default version is just create_new_frame
1550      (deprecated_read_fp ()), read_pc ()).  Machines with extra frame
1551      info would do that (or the local equivalent) and then set the
1552      extra fields.
1553
1554      SETUP_ARBITRARY_FRAME(argc, argv): Only change here is that
1555      create_new_frame would no longer init extra frame info;
1556      SETUP_ARBITRARY_FRAME would have to do that.
1557
1558      INIT_PREV_FRAME(fromleaf, prev) Replace
1559      DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC.
1560      This should also return a flag saying whether to keep the new
1561      frame, or whether to discard it, because on some machines (e.g.
1562      mips) it is really awkward to have DEPRECATED_FRAME_CHAIN_VALID
1563      called BEFORE DEPRECATED_INIT_EXTRA_FRAME_INFO (there is no good
1564      way to get information deduced in DEPRECATED_FRAME_CHAIN_VALID
1565      into the extra fields of the new frame).  std_frame_pc(fromleaf,
1566      prev)
1567
1568      This is the default setting for INIT_PREV_FRAME.  It just does
1569      what the default DEPRECATED_INIT_FRAME_PC does.  Some machines
1570      will call it from INIT_PREV_FRAME (either at the beginning, the
1571      end, or in the middle).  Some machines won't use it.
1572
1573      kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94.  */
1574
1575   /* NOTE: cagney/2002-11-09: Just ignore the above!  There is no
1576      reason for things to be this complicated.
1577
1578      The trick is to assume that there is always a frame.  Instead of
1579      special casing the inner-most frame, create fake frame
1580      (containing the hardware registers) that is inner to the
1581      user-visible inner-most frame (...) and then unwind from that.
1582      That way architecture code can use use the standard
1583      frame_XX_unwind() functions and not differentiate between the
1584      inner most and any other case.
1585
1586      Since there is always a frame to unwind from, there is always
1587      somewhere (THIS_FRAME) to store all the info needed to construct
1588      a new (previous) frame without having to first create it.  This
1589      means that the convolution below - needing to carefully order a
1590      frame's initialization - isn't needed.
1591
1592      The irony here though, is that DEPRECATED_FRAME_CHAIN(), at least
1593      for a more up-to-date architecture, always calls
1594      FRAME_SAVED_PC(), and FRAME_SAVED_PC() computes the PC but
1595      without first needing the frame!  Instead of the convolution
1596      below, we could have simply called FRAME_SAVED_PC() and been done
1597      with it!  Note that FRAME_SAVED_PC() is being superseed by
1598      frame_pc_unwind() and that function does have somewhere to cache
1599      that PC value.  */
1600
1601   if (DEPRECATED_INIT_FRAME_PC_FIRST_P ())
1602     deprecated_update_frame_pc_hack (prev,
1603                                      DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf,
1604                                                                      prev));
1605
1606   if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1607     DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf, prev);
1608
1609   /* This entry is in the frame queue now, which is good since
1610      FRAME_SAVED_PC may use that queue to figure out its value (see
1611      tm-sparc.h).  We want the pc saved in the inferior frame. */
1612   if (DEPRECATED_INIT_FRAME_PC_P ())
1613     deprecated_update_frame_pc_hack (prev,
1614                                      DEPRECATED_INIT_FRAME_PC (fromleaf,
1615                                                                prev));
1616
1617   /* If ->frame and ->pc are unchanged, we are in the process of
1618      getting ourselves into an infinite backtrace.  Some architectures
1619      check this in DEPRECATED_FRAME_CHAIN or thereabouts, but it seems
1620      like there is no reason this can't be an architecture-independent
1621      check.  */
1622   if (get_frame_base (prev) == get_frame_base (this_frame)
1623       && get_frame_pc (prev) == get_frame_pc (this_frame))
1624     {
1625       this_frame->prev = NULL;
1626       obstack_free (&frame_cache_obstack, prev);
1627       if (frame_debug)
1628         {
1629           fprintf_unfiltered (gdb_stdlog, "-> ");
1630           fprint_frame (gdb_stdlog, NULL);
1631           fprintf_unfiltered (gdb_stdlog,
1632                               " // legacy this.id == prev.id }\n");
1633         }
1634       return NULL;
1635     }
1636
1637   /* Initialize the code used to unwind the frame PREV based on the PC
1638      (and probably other architectural information).  The PC lets you
1639      check things like the debug info at that point (dwarf2cfi?) and
1640      use that to decide how the frame should be unwound.  */
1641   prev->unwind = frame_unwind_find_by_pc (current_gdbarch,
1642                                           get_frame_pc (prev));
1643
1644   /* If the unwinder provides a frame type, use it.  Otherwize
1645      continue on to that heuristic mess.  */
1646   if (prev->unwind->type != UNKNOWN_FRAME)
1647     {
1648       prev->type = prev->unwind->type;
1649       if (prev->type == NORMAL_FRAME)
1650         prev->this_id.value.code_addr
1651           = get_pc_function_start (prev->this_id.value.code_addr);
1652       if (frame_debug)
1653         {
1654           fprintf_unfiltered (gdb_stdlog, "-> ");
1655           fprint_frame (gdb_stdlog, prev);
1656           fprintf_unfiltered (gdb_stdlog, " } // legacy with unwound type\n");
1657         }
1658       return prev;
1659     }
1660
1661   /* NOTE: cagney/2002-11-18: The code segments, found in
1662      create_new_frame and get_prev_frame(), that initializes the
1663      frames type is subtly different.  The latter only updates ->type
1664      when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME.  This stops
1665      get_prev_frame() overriding the frame's type when the INIT code
1666      has previously set it.  This is really somewhat bogus.  The
1667      initialization, as seen in create_new_frame(), should occur
1668      before the INIT function has been called.  */
1669   if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1670       && (DEPRECATED_PC_IN_CALL_DUMMY_P ()
1671           ? DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (prev), 0, 0)
1672           : pc_in_dummy_frame (get_frame_pc (prev))))
1673     prev->type = DUMMY_FRAME;
1674   else
1675     {
1676       /* FIXME: cagney/2002-11-10: This should be moved to before the
1677          INIT code above so that the INIT code knows what the frame's
1678          type is (in fact, for a [generic] dummy-frame, the type can
1679          be set and then the entire initialization can be skipped.
1680          Unforunatly, its the INIT code that sets the PC (Hmm, catch
1681          22).  */
1682       char *name;
1683       find_pc_partial_function (get_frame_pc (prev), &name, NULL, NULL);
1684       if (PC_IN_SIGTRAMP (get_frame_pc (prev), name))
1685         prev->type = SIGTRAMP_FRAME;
1686       /* FIXME: cagney/2002-11-11: Leave prev->type alone.  Some
1687          architectures are forcing the frame's type in INIT so we
1688          don't want to override it here.  Remember, NORMAL_FRAME == 0,
1689          so it all works (just :-/).  Once this initialization is
1690          moved to the start of this function, all this nastness will
1691          go away.  */
1692     }
1693
1694   if (prev->type == NORMAL_FRAME)
1695     prev->this_id.value.code_addr
1696       = get_pc_function_start (prev->this_id.value.code_addr);
1697
1698   if (frame_debug)
1699     {
1700       fprintf_unfiltered (gdb_stdlog, "-> ");
1701       fprint_frame (gdb_stdlog, prev);
1702       fprintf_unfiltered (gdb_stdlog, " } // legacy with confused type\n");
1703     }
1704
1705   return prev;
1706 }
1707
1708 /* Return a structure containing various interesting information
1709    about the frame that called THIS_FRAME.  Returns NULL
1710    if there is no such frame.  */
1711
1712 struct frame_info *
1713 get_prev_frame (struct frame_info *this_frame)
1714 {
1715   struct frame_info *prev_frame;
1716
1717   if (frame_debug)
1718     {
1719       fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame=");
1720       if (this_frame != NULL)
1721         fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1722       else
1723         fprintf_unfiltered (gdb_stdlog, "<NULL>");
1724       fprintf_unfiltered (gdb_stdlog, ") ");
1725     }
1726
1727   /* Return the inner-most frame, when the caller passes in NULL.  */
1728   /* NOTE: cagney/2002-11-09: Not sure how this would happen.  The
1729      caller should have previously obtained a valid frame using
1730      get_selected_frame() and then called this code - only possibility
1731      I can think of is code behaving badly.
1732
1733      NOTE: cagney/2003-01-10: Talk about code behaving badly.  Check
1734      block_innermost_frame().  It does the sequence: frame = NULL;
1735      while (1) { frame = get_prev_frame (frame); .... }.  Ulgh!  Why
1736      it couldn't be written better, I don't know.
1737
1738      NOTE: cagney/2003-01-11: I suspect what is happening is
1739      block_innermost_frame() is, when the target has no state
1740      (registers, memory, ...), still calling this function.  The
1741      assumption being that this function will return NULL indicating
1742      that a frame isn't possible, rather than checking that the target
1743      has state and then calling get_current_frame() and
1744      get_prev_frame().  This is a guess mind.  */
1745   if (this_frame == NULL)
1746     {
1747       /* NOTE: cagney/2002-11-09: There was a code segment here that
1748          would error out when CURRENT_FRAME was NULL.  The comment
1749          that went with it made the claim ...
1750
1751          ``This screws value_of_variable, which just wants a nice
1752          clean NULL return from block_innermost_frame if there are no
1753          frames.  I don't think I've ever seen this message happen
1754          otherwise.  And returning NULL here is a perfectly legitimate
1755          thing to do.''
1756
1757          Per the above, this code shouldn't even be called with a NULL
1758          THIS_FRAME.  */
1759       return current_frame;
1760     }
1761
1762   /* There is always a frame.  If this assertion fails, suspect that
1763      something should be calling get_selected_frame() or
1764      get_current_frame().  */
1765   gdb_assert (this_frame != NULL);
1766
1767   if (this_frame->level >= 0
1768       && !backtrace_below_main
1769       && inside_main_func (get_frame_pc (this_frame)))
1770     /* Don't unwind past main(), bug always unwind the sentinel frame.
1771        Note, this is done _before_ the frame has been marked as
1772        previously unwound.  That way if the user later decides to
1773        allow unwinds past main(), that just happens.  */
1774     {
1775       if (frame_debug)
1776         fprintf_unfiltered (gdb_stdlog, "-> NULL // inside main func }\n");
1777       return NULL;
1778     }
1779
1780   /* Only try to do the unwind once.  */
1781   if (this_frame->prev_p)
1782     {
1783       if (frame_debug)
1784         {
1785           fprintf_unfiltered (gdb_stdlog, "-> ");
1786           fprint_frame (gdb_stdlog, this_frame->prev);
1787           fprintf_unfiltered (gdb_stdlog, " // cached \n");
1788         }
1789       return this_frame->prev;
1790     }
1791   this_frame->prev_p = 1;
1792
1793 #if 0
1794   /* If we're inside the entry file, it isn't valid.  Don't apply this
1795      test to a dummy frame - dummy frame PC's typically land in the
1796      entry file.  Don't apply this test to the sentinel frame.
1797      Sentinel frames should always be allowed to unwind.  */
1798   /* NOTE: drow/2002-12-25: should there be a way to disable this
1799      check?  It assumes a single small entry file, and the way some
1800      debug readers (e.g.  dbxread) figure out which object is the
1801      entry file is somewhat hokey.  */
1802   /* NOTE: cagney/2003-01-10: If there is a way of disabling this test
1803      then it should probably be moved to before the ->prev_p test,
1804      above.  */
1805   /* NOTE: vinschen/2003-04-01: Disabled.  It turns out that the call to
1806      inside_entry_file destroys a meaningful backtrace under some
1807      conditions.  E. g. the backtrace tests in the asm-source testcase
1808      are broken for some targets.  In this test the functions are all
1809      implemented as part of one file and the testcase is not necessarily
1810      linked with a start file (depending on the target).  What happens is,
1811      that the first frame is printed normaly and following frames are
1812      treated as being inside the enttry file then.  This way, only the
1813      #0 frame is printed in the backtrace output.  */
1814   if (this_frame->type != DUMMY_FRAME && this_frame->level >= 0
1815       && inside_entry_file (get_frame_pc (this_frame)))
1816     {
1817       if (frame_debug)
1818         {
1819           fprintf_unfiltered (gdb_stdlog, "-> ");
1820           fprint_frame (gdb_stdlog, NULL);
1821           fprintf_unfiltered (gdb_stdlog, " // inside entry file }\n");
1822         }
1823       return NULL;
1824     }
1825 #endif
1826
1827   /* If we're already inside the entry function for the main objfile,
1828      then it isn't valid.  Don't apply this test to a dummy frame -
1829      dummy frame PC's typically land in the entry func.  Don't apply
1830      this test to the sentinel frame.  Sentinel frames should always
1831      be allowed to unwind.  */
1832   /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1833      hard evidence that this is needed.  */
1834   if (0
1835       && this_frame->type != DUMMY_FRAME && this_frame->level >= 0
1836       && inside_entry_func (get_frame_pc (this_frame)))
1837     {
1838       if (frame_debug)
1839         {
1840           fprintf_unfiltered (gdb_stdlog, "-> ");
1841           fprint_frame (gdb_stdlog, NULL);
1842           fprintf_unfiltered (gdb_stdlog, "// inside entry func }\n");
1843         }
1844       return NULL;
1845     }
1846
1847   /* If any of the old frame initialization methods are around, use
1848      the legacy get_prev_frame method.  */
1849   if (legacy_frame_p (current_gdbarch))
1850     {
1851       prev_frame = legacy_get_prev_frame (this_frame);
1852       return prev_frame;
1853     }
1854
1855   /* Check that this frame's ID was valid.  If it wasn't, don't try to
1856      unwind to the prev frame.  Be careful to not apply this test to
1857      the sentinel frame.  */
1858   if (this_frame->level >= 0 && !frame_id_p (get_frame_id (this_frame)))
1859     {
1860       if (frame_debug)
1861         {
1862           fprintf_unfiltered (gdb_stdlog, "-> ");
1863           fprint_frame (gdb_stdlog, NULL);
1864           fprintf_unfiltered (gdb_stdlog, " // this ID is NULL }\n");
1865         }
1866       return NULL;
1867     }
1868
1869   /* Check that this frame's ID isn't inner to (younger, below, next)
1870      the next frame.  This happens when frame unwind goes backwards.
1871      Since the sentinel frame isn't valid, don't apply this if this
1872      frame is entier the inner-most or sentinel frame.  */
1873   if (this_frame->level > 0
1874       && frame_id_inner (get_frame_id (this_frame),
1875                          get_frame_id (this_frame->next)))
1876     error ("This frame inner-to next frame (corrupt stack?)");
1877
1878   /* Check that this and the next frame are different.  If they are
1879      not, there is most likely a stack cycle.  As with the inner-than
1880      test, avoid the inner-most and sentinel frames.  */
1881   /* FIXME: cagney/2003-03-17: Can't yet enable this this check. The
1882      frame_id_eq() method doesn't yet use function addresses when
1883      comparing frame IDs.  */
1884   if (0
1885       && this_frame->level > 0
1886       && frame_id_eq (get_frame_id (this_frame),
1887                       get_frame_id (this_frame->next)))
1888     error ("This frame identical to next frame (corrupt stack?)");
1889
1890   /* Allocate the new frame but do not wire it in to the frame chain.
1891      Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1892      frame->next to pull some fancy tricks (of course such code is, by
1893      definition, recursive).  Try to prevent it.
1894
1895      There is no reason to worry about memory leaks, should the
1896      remainder of the function fail.  The allocated memory will be
1897      quickly reclaimed when the frame cache is flushed, and the `we've
1898      been here before' check above will stop repeated memory
1899      allocation calls.  */
1900   prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1901   prev_frame->level = this_frame->level + 1;
1902
1903   /* Try to unwind the PC.  If that doesn't work, assume we've reached
1904      the oldest frame and simply return.  Is there a better sentinal
1905      value?  The unwound PC value is then used to initialize the new
1906      previous frame's type.
1907
1908      Note that the pc-unwind is intentionally performed before the
1909      frame chain.  This is ok since, for old targets, both
1910      frame_pc_unwind (nee, FRAME_SAVED_PC) and
1911      DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
1912      have already been initialized (using
1913      DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
1914      doesn't matter.
1915
1916      By unwinding the PC first, it becomes possible to, in the case of
1917      a dummy frame, avoid also unwinding the frame ID.  This is
1918      because (well ignoring the PPC) a dummy frame can be located
1919      using THIS_FRAME's frame ID.  */
1920
1921   if (frame_pc_unwind (this_frame) == 0)
1922     {
1923       /* The allocated PREV_FRAME will be reclaimed when the frame
1924          obstack is next purged.  */
1925       if (frame_debug)
1926         {
1927           fprintf_unfiltered (gdb_stdlog, "-> ");
1928           fprint_frame (gdb_stdlog, NULL);
1929           fprintf_unfiltered (gdb_stdlog, " // unwound PC zero }\n");
1930         }
1931       return NULL;
1932     }
1933
1934   /* Don't yet compute ->unwind (and hence ->type).  It is computed
1935      on-demand in get_frame_type, frame_register_unwind, and
1936      get_frame_id.  */
1937
1938   /* Don't yet compute the frame's ID.  It is computed on-demand by
1939      get_frame_id().  */
1940
1941   /* The unwound frame ID is validate at the start of this function,
1942      as part of the logic to decide if that frame should be further
1943      unwound, and not here while the prev frame is being created.
1944      Doing this makes it possible for the user to examine a frame that
1945      has an invalid frame ID.
1946
1947      Some very old VAX code noted: [...]  For the sake of argument,
1948      suppose that the stack is somewhat trashed (which is one reason
1949      that "info frame" exists).  So, return 0 (indicating we don't
1950      know the address of the arglist) if we don't know what frame this
1951      frame calls.  */
1952
1953   /* Link it in.  */
1954   this_frame->prev = prev_frame;
1955   prev_frame->next = this_frame;
1956
1957   if (frame_debug)
1958     {
1959       fprintf_unfiltered (gdb_stdlog, "-> ");
1960       fprint_frame (gdb_stdlog, prev_frame);
1961       fprintf_unfiltered (gdb_stdlog, " }\n");
1962     }
1963
1964   return prev_frame;
1965 }
1966
1967 CORE_ADDR
1968 get_frame_pc (struct frame_info *frame)
1969 {
1970   gdb_assert (frame->next != NULL);
1971   return frame_pc_unwind (frame->next);
1972 }
1973
1974 static int
1975 pc_notcurrent (struct frame_info *frame)
1976 {
1977   /* If FRAME is not the innermost frame, that normally means that
1978      FRAME->pc points at the return instruction (which is *after* the
1979      call instruction), and we want to get the line containing the
1980      call (because the call is where the user thinks the program is).
1981      However, if the next frame is either a SIGTRAMP_FRAME or a
1982      DUMMY_FRAME, then the next frame will contain a saved interrupt
1983      PC and such a PC indicates the current (rather than next)
1984      instruction/line, consequently, for such cases, want to get the
1985      line containing fi->pc.  */
1986   struct frame_info *next = get_next_frame (frame);
1987   int notcurrent = (next != NULL && get_frame_type (next) == NORMAL_FRAME);
1988   return notcurrent;
1989 }
1990
1991 void
1992 find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
1993 {
1994   (*sal) = find_pc_line (get_frame_pc (frame), pc_notcurrent (frame));
1995 }
1996
1997 /* Per "frame.h", return the ``address'' of the frame.  Code should
1998    really be using get_frame_id().  */
1999 CORE_ADDR
2000 get_frame_base (struct frame_info *fi)
2001 {
2002   return get_frame_id (fi).stack_addr;
2003 }
2004
2005 /* High-level offsets into the frame.  Used by the debug info.  */
2006
2007 CORE_ADDR
2008 get_frame_base_address (struct frame_info *fi)
2009 {
2010   if (get_frame_type (fi) != NORMAL_FRAME)
2011     return 0;
2012   if (fi->base == NULL)
2013     fi->base = frame_base_find_by_pc (current_gdbarch, get_frame_pc (fi));
2014   /* Sneaky: If the low-level unwind and high-level base code share a
2015      common unwinder, let them share the prologue cache.  */
2016   if (fi->base->unwind == fi->unwind)
2017     return fi->base->this_base (fi->next, &fi->prologue_cache);
2018   return fi->base->this_base (fi->next, &fi->base_cache);
2019 }
2020
2021 CORE_ADDR
2022 get_frame_locals_address (struct frame_info *fi)
2023 {
2024   void **cache;
2025   if (get_frame_type (fi) != NORMAL_FRAME)
2026     return 0;
2027   /* If there isn't a frame address method, find it.  */
2028   if (fi->base == NULL)
2029     fi->base = frame_base_find_by_pc (current_gdbarch, get_frame_pc (fi));
2030   /* Sneaky: If the low-level unwind and high-level base code share a
2031      common unwinder, let them share the prologue cache.  */
2032   if (fi->base->unwind == fi->unwind)
2033     cache = &fi->prologue_cache;
2034   else
2035     cache = &fi->base_cache;
2036   return fi->base->this_locals (fi->next, cache);
2037 }
2038
2039 CORE_ADDR
2040 get_frame_args_address (struct frame_info *fi)
2041 {
2042   void **cache;
2043   if (get_frame_type (fi) != NORMAL_FRAME)
2044     return 0;
2045   /* If there isn't a frame address method, find it.  */
2046   if (fi->base == NULL)
2047     fi->base = frame_base_find_by_pc (current_gdbarch, get_frame_pc (fi));
2048   /* Sneaky: If the low-level unwind and high-level base code share a
2049      common unwinder, let them share the prologue cache.  */
2050   if (fi->base->unwind == fi->unwind)
2051     cache = &fi->prologue_cache;
2052   else
2053     cache = &fi->base_cache;
2054   return fi->base->this_args (fi->next, cache);
2055 }
2056
2057 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2058    or -1 for a NULL frame.  */
2059
2060 int
2061 frame_relative_level (struct frame_info *fi)
2062 {
2063   if (fi == NULL)
2064     return -1;
2065   else
2066     return fi->level;
2067 }
2068
2069 enum frame_type
2070 get_frame_type (struct frame_info *frame)
2071 {
2072   /* Some targets still don't use [generic] dummy frames.  Catch them
2073      here.  */
2074   if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
2075       && deprecated_frame_in_dummy (frame))
2076     return DUMMY_FRAME;
2077
2078   /* Some legacy code, e.g, mips_init_extra_frame_info() wants
2079      to determine the frame's type prior to it being completely
2080      initialized.  Don't attempt to lazily initialize ->unwind for
2081      legacy code.  It will be initialized in legacy_get_prev_frame().  */
2082   if (frame->unwind == NULL && !legacy_frame_p (current_gdbarch))
2083     {
2084       /* Initialize the frame's unwinder because it is that which
2085          provides the frame's type.  */
2086       frame->unwind = frame_unwind_find_by_pc (current_gdbarch,
2087                                                get_frame_pc (frame));
2088       /* FIXME: cagney/2003-04-02: Rather than storing the frame's
2089          type in the frame, the unwinder's type should be returned
2090          directly.  Unfortunatly, legacy code, called by
2091          legacy_get_prev_frame, explicitly set the frames type using
2092          the method deprecated_set_frame_type().  */
2093       gdb_assert (frame->unwind->type != UNKNOWN_FRAME);
2094       frame->type = frame->unwind->type;
2095     }
2096   if (frame->type == UNKNOWN_FRAME)
2097     return NORMAL_FRAME;
2098   else
2099     return frame->type;
2100 }
2101
2102 void
2103 deprecated_set_frame_type (struct frame_info *frame, enum frame_type type)
2104 {
2105   /* Arrrg!  See comment in "frame.h".  */
2106   frame->type = type;
2107 }
2108
2109 struct frame_extra_info *
2110 get_frame_extra_info (struct frame_info *fi)
2111 {
2112   return fi->extra_info;
2113 }
2114
2115 struct frame_extra_info *
2116 frame_extra_info_zalloc (struct frame_info *fi, long size)
2117 {
2118   fi->extra_info = frame_obstack_zalloc (size);
2119   return fi->extra_info;
2120 }
2121
2122 void
2123 deprecated_update_frame_pc_hack (struct frame_info *frame, CORE_ADDR pc)
2124 {
2125   if (frame_debug)
2126     fprintf_unfiltered (gdb_stdlog,
2127                         "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
2128                         frame->level, paddr_nz (pc));
2129   /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
2130      maintaining a locally allocated frame object.  Since such frame's
2131      are not in the frame chain, it isn't possible to assume that the
2132      frame has a next.  Sigh.  */
2133   if (frame->next != NULL)
2134     {
2135       /* While we're at it, update this frame's cached PC value, found
2136          in the next frame.  Oh for the day when "struct frame_info"
2137          is opaque and this hack on hack can just go away.  */
2138       frame->next->prev_pc.value = pc;
2139       frame->next->prev_pc.p = 1;
2140     }
2141 }
2142
2143 void
2144 deprecated_update_frame_base_hack (struct frame_info *frame, CORE_ADDR base)
2145 {
2146   if (frame_debug)
2147     fprintf_unfiltered (gdb_stdlog,
2148                         "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
2149                         frame->level, paddr_nz (base));
2150   /* See comment in "frame.h".  */
2151   frame->this_id.value.stack_addr = base;
2152 }
2153
2154 void
2155 deprecated_set_frame_saved_regs_hack (struct frame_info *frame,
2156                                       CORE_ADDR *saved_regs)
2157 {
2158   frame->saved_regs = saved_regs;
2159 }
2160
2161 void
2162 deprecated_set_frame_extra_info_hack (struct frame_info *frame,
2163                                       struct frame_extra_info *extra_info)
2164 {
2165   frame->extra_info = extra_info;
2166 }
2167
2168 void
2169 deprecated_set_frame_next_hack (struct frame_info *fi,
2170                                 struct frame_info *next)
2171 {
2172   fi->next = next;
2173 }
2174
2175 void
2176 deprecated_set_frame_prev_hack (struct frame_info *fi,
2177                                 struct frame_info *prev)
2178 {
2179   fi->prev = prev;
2180 }
2181
2182 struct context *
2183 deprecated_get_frame_context (struct frame_info *fi)
2184 {
2185   return fi->context;
2186 }
2187
2188 void
2189 deprecated_set_frame_context (struct frame_info *fi,
2190                               struct context *context)
2191 {
2192   fi->context = context;
2193 }
2194
2195 struct frame_info *
2196 deprecated_frame_xmalloc (void)
2197 {
2198   struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
2199   frame->this_id.p = 1;
2200   return frame;
2201 }
2202
2203 struct frame_info *
2204 deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs,
2205                                        long sizeof_extra_info)
2206 {
2207   struct frame_info *frame = deprecated_frame_xmalloc ();
2208   make_cleanup (xfree, frame);
2209   if (sizeof_saved_regs > 0)
2210     {
2211       frame->saved_regs = xcalloc (1, sizeof_saved_regs);
2212       make_cleanup (xfree, frame->saved_regs);
2213     }
2214   if (sizeof_extra_info > 0)
2215     {
2216       frame->extra_info = xcalloc (1, sizeof_extra_info);
2217       make_cleanup (xfree, frame->extra_info);
2218     }
2219   return frame;
2220 }
2221
2222 /* Memory access methods.  */
2223
2224 void
2225 get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr, void *buf,
2226                   int len)
2227 {
2228   read_memory (addr, buf, len);
2229 }
2230
2231 LONGEST
2232 get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr,
2233                          int len)
2234 {
2235   return read_memory_integer (addr, len);
2236 }
2237
2238 ULONGEST
2239 get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
2240                            int len)
2241 {
2242   return read_memory_unsigned_integer (addr, len);
2243 }
2244
2245 /* Architecture method.  */
2246
2247 struct gdbarch *
2248 get_frame_arch (struct frame_info *this_frame)
2249 {
2250   return current_gdbarch;
2251 }
2252
2253 /* Stack pointer methods.  */
2254
2255 CORE_ADDR
2256 get_frame_sp (struct frame_info *this_frame)
2257 {
2258   return frame_sp_unwind (this_frame->next);
2259 }
2260
2261 CORE_ADDR
2262 frame_sp_unwind (struct frame_info *next_frame)
2263 {
2264   /* Normality, an architecture that provides a way of obtaining any
2265      frame inner-most address.  */
2266   if (gdbarch_unwind_sp_p (current_gdbarch))
2267     return gdbarch_unwind_sp (current_gdbarch, next_frame);
2268   /* Things are looking grim.  If it's the inner-most frame and there
2269      is a TARGET_READ_SP then that can be used.  */
2270   if (next_frame->level < 0 && TARGET_READ_SP_P ())
2271     return TARGET_READ_SP ();
2272   /* Now things are really are grim.  Hope that the value returned by
2273      the SP_REGNUM register is meaningful.  */
2274   if (SP_REGNUM >= 0)
2275     {
2276       ULONGEST sp;
2277       frame_unwind_unsigned_register (next_frame, SP_REGNUM, &sp);
2278       return sp;
2279     }
2280   internal_error (__FILE__, __LINE__, "Missing unwind SP method");
2281 }
2282
2283
2284 int
2285 legacy_frame_p (struct gdbarch *current_gdbarch)
2286 {
2287   return (DEPRECATED_INIT_FRAME_PC_P ()
2288           || DEPRECATED_INIT_FRAME_PC_FIRST_P ()
2289           || DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()
2290           || DEPRECATED_FRAME_CHAIN_P ()
2291           || !gdbarch_unwind_dummy_id_p (current_gdbarch)
2292           || !SAVE_DUMMY_FRAME_TOS_P ());
2293 }
2294
2295 extern initialize_file_ftype _initialize_frame; /* -Wmissing-prototypes */
2296
2297 void
2298 _initialize_frame (void)
2299 {
2300   obstack_init (&frame_cache_obstack);
2301
2302   /* FIXME: cagney/2003-01-19: This command needs a rename.  Suggest
2303      `set backtrace {past,beyond,...}-main'.  Also suggest adding `set
2304      backtrace ...-start' to control backtraces past start.  The
2305      problem with `below' is that it stops the `up' command.  */
2306
2307   add_setshow_boolean_cmd ("backtrace-below-main", class_obscure,
2308                            &backtrace_below_main, "\
2309 Set whether backtraces should continue past \"main\".\n\
2310 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2311 the backtrace at \"main\".  Set this variable if you need to see the rest\n\
2312 of the stack trace.", "\
2313 Show whether backtraces should continue past \"main\".\n\
2314 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2315 the backtrace at \"main\".  Set this variable if you need to see the rest\n\
2316 of the stack trace.",
2317                            NULL, NULL, &setlist, &showlist);
2318
2319
2320   /* Debug this files internals. */
2321   add_show_from_set (add_set_cmd ("frame", class_maintenance, var_zinteger,
2322                                   &frame_debug, "Set frame debugging.\n\
2323 When non-zero, frame specific internal debugging is enabled.", &setdebuglist),
2324                      &showdebuglist);
2325 }