gdb/frame.c

   1 /* Cache and manage frames for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
   4    2002, 2003, 2004, 2007, 2008, 2009 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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "target.h"
  24 #include "value.h"
  25 #include "inferior.h"   /* for inferior_ptid */
  26 #include "regcache.h"
  27 #include "gdb_assert.h"
  28 #include "gdb_string.h"
  29 #include "user-regs.h"
  30 #include "gdb_obstack.h"
  31 #include "dummy-frame.h"
  32 #include "sentinel-frame.h"
  33 #include "gdbcore.h"
  34 #include "annotate.h"
  35 #include "language.h"
  36 #include "frame-unwind.h"
  37 #include "frame-base.h"
  38 #include "command.h"
  39 #include "gdbcmd.h"
  40 #include "observer.h"
  41 #include "objfiles.h"
  42 #include "exceptions.h"
  43 #include "gdbthread.h"
  44
  45 static struct frame_info *get_prev_frame_1 (struct frame_info *this_frame);
  46
  47 /* We keep a cache of stack frames, each of which is a "struct
  48    frame_info".  The innermost one gets allocated (in
  49    wait_for_inferior) each time the inferior stops; current_frame
  50    points to it.  Additional frames get allocated (in get_prev_frame)
  51    as needed, and are chained through the next and prev fields.  Any
  52    time that the frame cache becomes invalid (most notably when we
  53    execute something, but also if we change how we interpret the
  54    frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
  55    which reads new symbols)), we should call reinit_frame_cache.  */
  56
  57 struct frame_info
  58 {
  59   /* Level of this frame.  The inner-most (youngest) frame is at level
  60      0.  As you move towards the outer-most (oldest) frame, the level
  61      increases.  This is a cached value.  It could just as easily be
  62      computed by counting back from the selected frame to the inner
  63      most frame.  */
  64   /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
  65      reserved to indicate a bogus frame - one that has been created
  66      just to keep GDB happy (GDB always needs a frame).  For the
  67      moment leave this as speculation.  */
  68   int level;
  69
  70   /* The frame's low-level unwinder and corresponding cache.  The
  71      low-level unwinder is responsible for unwinding register values
  72      for the previous frame.  The low-level unwind methods are
  73      selected based on the presence, or otherwise, of register unwind
  74      information such as CFI.  */
  75   void *prologue_cache;
  76   const struct frame_unwind *unwind;
  77
  78   /* Cached copy of the previous frame's resume address.  */
  79   struct {
  80     int p;
  81     CORE_ADDR value;
  82   } prev_pc;
  83
  84   /* Cached copy of the previous frame's function address.  */
  85   struct
  86   {
  87     CORE_ADDR addr;
  88     int p;
  89   } prev_func;
  90
  91   /* This frame's ID.  */
  92   struct
  93   {
  94     int p;
  95     struct frame_id value;
  96   } this_id;
  97
  98   /* The frame's high-level base methods, and corresponding cache.
  99      The high level base methods are selected based on the frame's
 100      debug info.  */
 101   const struct frame_base *base;
 102   void *base_cache;
 103
 104   /* Pointers to the next (down, inner, younger) and previous (up,
 105      outer, older) frame_info's in the frame cache.  */
 106   struct frame_info *next; /* down, inner, younger */
 107   int prev_p;
 108   struct frame_info *prev; /* up, outer, older */
 109
 110   /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
 111      could.  Only valid when PREV_P is set.  */
 112   enum unwind_stop_reason stop_reason;
 113 };
 114
 115 /* Flag to control debugging.  */
 116
 117 int frame_debug;
 118 static void
 119 show_frame_debug (struct ui_file *file, int from_tty,
 120                   struct cmd_list_element *c, const char *value)
 121 {
 122   fprintf_filtered (file, _("Frame debugging is %s.\n"), value);
 123 }
 124
 125 /* Flag to indicate whether backtraces should stop at main et.al.  */
 126
 127 static int backtrace_past_main;
 128 static void
 129 show_backtrace_past_main (struct ui_file *file, int from_tty,
 130                           struct cmd_list_element *c, const char *value)
 131 {
 132   fprintf_filtered (file, _("\
 133 Whether backtraces should continue past \"main\" is %s.\n"),
 134                     value);
 135 }
 136
 137 static int backtrace_past_entry;
 138 static void
 139 show_backtrace_past_entry (struct ui_file *file, int from_tty,
 140                            struct cmd_list_element *c, const char *value)
 141 {
 142   fprintf_filtered (file, _("\
 143 Whether backtraces should continue past the entry point of a program is %s.\n"),
 144                     value);
 145 }
 146
 147 static int backtrace_limit = INT_MAX;
 148 static void
 149 show_backtrace_limit (struct ui_file *file, int from_tty,
 150                       struct cmd_list_element *c, const char *value)
 151 {
 152   fprintf_filtered (file, _("\
 153 An upper bound on the number of backtrace levels is %s.\n"),
 154                     value);
 155 }
 156
 157
 158 static void
 159 fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr)
 160 {
 161   if (p)
 162     fprintf_unfiltered (file, "%s=0x%s", name, paddr_nz (addr));
 163   else
 164     fprintf_unfiltered (file, "!%s", name);
 165 }
 166
 167 void
 168 fprint_frame_id (struct ui_file *file, struct frame_id id)
 169 {
 170   fprintf_unfiltered (file, "{");
 171   fprint_field (file, "stack", id.stack_addr_p, id.stack_addr);
 172   fprintf_unfiltered (file, ",");
 173   fprint_field (file, "code", id.code_addr_p, id.code_addr);
 174   fprintf_unfiltered (file, ",");
 175   fprint_field (file, "special", id.special_addr_p, id.special_addr);
 176   fprintf_unfiltered (file, "}");
 177 }
 178
 179 static void
 180 fprint_frame_type (struct ui_file *file, enum frame_type type)
 181 {
 182   switch (type)
 183     {
 184     case NORMAL_FRAME:
 185       fprintf_unfiltered (file, "NORMAL_FRAME");
 186       return;
 187     case DUMMY_FRAME:
 188       fprintf_unfiltered (file, "DUMMY_FRAME");
 189       return;
 190     case SIGTRAMP_FRAME:
 191       fprintf_unfiltered (file, "SIGTRAMP_FRAME");
 192       return;
 193     default:
 194       fprintf_unfiltered (file, "<unknown type>");
 195       return;
 196     };
 197 }
 198
 199 static void
 200 fprint_frame (struct ui_file *file, struct frame_info *fi)
 201 {
 202   if (fi == NULL)
 203     {
 204       fprintf_unfiltered (file, "<NULL frame>");
 205       return;
 206     }
 207   fprintf_unfiltered (file, "{");
 208   fprintf_unfiltered (file, "level=%d", fi->level);
 209   fprintf_unfiltered (file, ",");
 210   fprintf_unfiltered (file, "type=");
 211   if (fi->unwind != NULL)
 212     fprint_frame_type (file, fi->unwind->type);
 213   else
 214     fprintf_unfiltered (file, "<unknown>");
 215   fprintf_unfiltered (file, ",");
 216   fprintf_unfiltered (file, "unwind=");
 217   if (fi->unwind != NULL)
 218     gdb_print_host_address (fi->unwind, file);
 219   else
 220     fprintf_unfiltered (file, "<unknown>");
 221   fprintf_unfiltered (file, ",");
 222   fprintf_unfiltered (file, "pc=");
 223   if (fi->next != NULL && fi->next->prev_pc.p)
 224     fprintf_unfiltered (file, "0x%s", paddr_nz (fi->next->prev_pc.value));
 225   else
 226     fprintf_unfiltered (file, "<unknown>");
 227   fprintf_unfiltered (file, ",");
 228   fprintf_unfiltered (file, "id=");
 229   if (fi->this_id.p)
 230     fprint_frame_id (file, fi->this_id.value);
 231   else
 232     fprintf_unfiltered (file, "<unknown>");
 233   fprintf_unfiltered (file, ",");
 234   fprintf_unfiltered (file, "func=");
 235   if (fi->next != NULL && fi->next->prev_func.p)
 236     fprintf_unfiltered (file, "0x%s", paddr_nz (fi->next->prev_func.addr));
 237   else
 238     fprintf_unfiltered (file, "<unknown>");
 239   fprintf_unfiltered (file, "}");
 240 }
 241
 242 /* Return a frame uniq ID that can be used to, later, re-find the
 243    frame.  */
 244
 245 struct frame_id
 246 get_frame_id (struct frame_info *fi)
 247 {
 248   if (fi == NULL)
 249     {
 250       return null_frame_id;
 251     }
 252   if (!fi->this_id.p)
 253     {
 254       if (frame_debug)
 255         fprintf_unfiltered (gdb_stdlog, "{ get_frame_id (fi=%d) ",
 256                             fi->level);
 257       /* Find the unwinder.  */
 258       if (fi->unwind == NULL)
 259         fi->unwind = frame_unwind_find_by_frame (fi, &fi->prologue_cache);
 260       /* Find THIS frame's ID.  */
 261       fi->unwind->this_id (fi, &fi->prologue_cache, &fi->this_id.value);
 262       fi->this_id.p = 1;
 263       if (frame_debug)
 264         {
 265           fprintf_unfiltered (gdb_stdlog, "-> ");
 266           fprint_frame_id (gdb_stdlog, fi->this_id.value);
 267           fprintf_unfiltered (gdb_stdlog, " }\n");
 268         }
 269     }
 270   return fi->this_id.value;
 271 }
 272
 273 struct frame_id
 274 frame_unwind_id (struct frame_info *next_frame)
 275 {
 276   /* Use prev_frame, and not get_prev_frame.  The latter will truncate
 277      the frame chain, leading to this function unintentionally
 278      returning a null_frame_id (e.g., when a caller requests the frame
 279      ID of "main()"s caller.  */
 280   return get_frame_id (get_prev_frame_1 (next_frame));
 281 }
 282
 283 const struct frame_id null_frame_id; /* All zeros.  */
 284
 285 struct frame_id
 286 frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr,
 287                         CORE_ADDR special_addr)
 288 {
 289   struct frame_id id = null_frame_id;
 290   id.stack_addr = stack_addr;
 291   id.stack_addr_p = 1;
 292   id.code_addr = code_addr;
 293   id.code_addr_p = 1;
 294   id.special_addr = special_addr;
 295   id.special_addr_p = 1;
 296   return id;
 297 }
 298
 299 struct frame_id
 300 frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr)
 301 {
 302   struct frame_id id = null_frame_id;
 303   id.stack_addr = stack_addr;
 304   id.stack_addr_p = 1;
 305   id.code_addr = code_addr;
 306   id.code_addr_p = 1;
 307   return id;
 308 }
 309
 310 struct frame_id
 311 frame_id_build_wild (CORE_ADDR stack_addr)
 312 {
 313   struct frame_id id = null_frame_id;
 314   id.stack_addr = stack_addr;
 315   id.stack_addr_p = 1;
 316   return id;
 317 }
 318
 319 int
 320 frame_id_p (struct frame_id l)
 321 {
 322   int p;
 323   /* The frame is valid iff it has a valid stack address.  */
 324   p = l.stack_addr_p;
 325   if (frame_debug)
 326     {
 327       fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l=");
 328       fprint_frame_id (gdb_stdlog, l);
 329       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p);
 330     }
 331   return p;
 332 }
 333
 334 int
 335 frame_id_eq (struct frame_id l, struct frame_id r)
 336 {
 337   int eq;
 338   if (!l.stack_addr_p || !r.stack_addr_p)
 339     /* Like a NaN, if either ID is invalid, the result is false.
 340        Note that a frame ID is invalid iff it is the null frame ID.  */
 341     eq = 0;
 342   else if (l.stack_addr != r.stack_addr)
 343     /* If .stack addresses are different, the frames are different.  */
 344     eq = 0;
 345   else if (!l.code_addr_p || !r.code_addr_p)
 346     /* An invalid code addr is a wild card, always succeed.  */
 347     eq = 1;
 348   else if (l.code_addr != r.code_addr)
 349     /* If .code addresses are different, the frames are different.  */
 350     eq = 0;
 351   else if (!l.special_addr_p || !r.special_addr_p)
 352     /* An invalid special addr is a wild card (or unused), always succeed.  */
 353     eq = 1;
 354   else if (l.special_addr == r.special_addr)
 355     /* Frames are equal.  */
 356     eq = 1;
 357   else
 358     /* No luck.  */
 359     eq = 0;
 360   if (frame_debug)
 361     {
 362       fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
 363       fprint_frame_id (gdb_stdlog, l);
 364       fprintf_unfiltered (gdb_stdlog, ",r=");
 365       fprint_frame_id (gdb_stdlog, r);
 366       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq);
 367     }
 368   return eq;
 369 }
 370
 371 /* Safety net to check whether frame ID L should be inner to
 372    frame ID R, according to their stack addresses.
 373
 374    This method cannot be used to compare arbitrary frames, as the
 375    ranges of valid stack addresses may be discontiguous (e.g. due
 376    to sigaltstack).
 377
 378    However, it can be used as safety net to discover invalid frame
 379    IDs in certain circumstances.
 380
 381    * If frame NEXT is the immediate inner frame to THIS, and NEXT
 382      is a NORMAL frame, then the stack address of NEXT must be
 383      inner-than-or-equal to the stack address of THIS.
 384
 385      Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
 386      error has occurred.
 387
 388    * If frame NEXT is the immediate inner frame to THIS, and NEXT
 389      is a NORMAL frame, and NEXT and THIS have different stack
 390      addresses, no other frame in the frame chain may have a stack
 391      address in between.
 392
 393      Therefore, if frame_id_inner (TEST, THIS) holds, but
 394      frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
 395      to a valid frame in the frame chain.   */
 396
 397 static int
 398 frame_id_inner (struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
 399 {
 400   int inner;
 401   if (!l.stack_addr_p || !r.stack_addr_p)
 402     /* Like NaN, any operation involving an invalid ID always fails.  */
 403     inner = 0;
 404   else
 405     /* Only return non-zero when strictly inner than.  Note that, per
 406        comment in "frame.h", there is some fuzz here.  Frameless
 407        functions are not strictly inner than (same .stack but
 408        different .code and/or .special address).  */
 409     inner = gdbarch_inner_than (gdbarch, l.stack_addr, r.stack_addr);
 410   if (frame_debug)
 411     {
 412       fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l=");
 413       fprint_frame_id (gdb_stdlog, l);
 414       fprintf_unfiltered (gdb_stdlog, ",r=");
 415       fprint_frame_id (gdb_stdlog, r);
 416       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner);
 417     }
 418   return inner;
 419 }
 420
 421 struct frame_info *
 422 frame_find_by_id (struct frame_id id)
 423 {
 424   struct frame_info *frame, *prev_frame;
 425
 426   /* ZERO denotes the null frame, let the caller decide what to do
 427      about it.  Should it instead return get_current_frame()?  */
 428   if (!frame_id_p (id))
 429     return NULL;
 430
 431   for (frame = get_current_frame (); ; frame = prev_frame)
 432     {
 433       struct frame_id this = get_frame_id (frame);
 434       if (frame_id_eq (id, this))
 435         /* An exact match.  */
 436         return frame;
 437
 438       prev_frame = get_prev_frame (frame);
 439       if (!prev_frame)
 440         return NULL;
 441
 442       /* As a safety net to avoid unnecessary backtracing while trying
 443          to find an invalid ID, we check for a common situation where
 444          we can detect from comparing stack addresses that no other
 445          frame in the current frame chain can have this ID.  See the
 446          comment at frame_id_inner for details.   */
 447       if (get_frame_type (frame) == NORMAL_FRAME
 448           && !frame_id_inner (get_frame_arch (frame), id, this)
 449           && frame_id_inner (get_frame_arch (prev_frame), id,
 450                              get_frame_id (prev_frame)))
 451         return NULL;
 452     }
 453   return NULL;
 454 }
 455
 456 CORE_ADDR
 457 frame_pc_unwind (struct frame_info *this_frame)
 458 {
 459   if (!this_frame->prev_pc.p)
 460     {
 461       CORE_ADDR pc;
 462       if (gdbarch_unwind_pc_p (get_frame_arch (this_frame)))
 463         {
 464           /* The right way.  The `pure' way.  The one true way.  This
 465              method depends solely on the register-unwind code to
 466              determine the value of registers in THIS frame, and hence
 467              the value of this frame's PC (resume address).  A typical
 468              implementation is no more than:
 469
 470              frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
 471              return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
 472
 473              Note: this method is very heavily dependent on a correct
 474              register-unwind implementation, it pays to fix that
 475              method first; this method is frame type agnostic, since
 476              it only deals with register values, it works with any
 477              frame.  This is all in stark contrast to the old
 478              FRAME_SAVED_PC which would try to directly handle all the
 479              different ways that a PC could be unwound.  */
 480           pc = gdbarch_unwind_pc (get_frame_arch (this_frame), this_frame);
 481         }
 482       else
 483         internal_error (__FILE__, __LINE__, _("No unwind_pc method"));
 484       this_frame->prev_pc.value = pc;
 485       this_frame->prev_pc.p = 1;
 486       if (frame_debug)
 487         fprintf_unfiltered (gdb_stdlog,
 488                             "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
 489                             this_frame->level,
 490                             paddr_nz (this_frame->prev_pc.value));
 491     }
 492   return this_frame->prev_pc.value;
 493 }
 494
 495 CORE_ADDR
 496 get_frame_func (struct frame_info *this_frame)
 497 {
 498   struct frame_info *next_frame = this_frame->next;
 499
 500   if (!next_frame->prev_func.p)
 501     {
 502       /* Make certain that this, and not the adjacent, function is
 503          found.  */
 504       CORE_ADDR addr_in_block = get_frame_address_in_block (this_frame);
 505       next_frame->prev_func.p = 1;
 506       next_frame->prev_func.addr = get_pc_function_start (addr_in_block);
 507       if (frame_debug)
 508         fprintf_unfiltered (gdb_stdlog,
 509                             "{ get_frame_func (this_frame=%d) -> 0x%s }\n",
 510                             this_frame->level,
 511                             paddr_nz (next_frame->prev_func.addr));
 512     }
 513   return next_frame->prev_func.addr;
 514 }
 515
 516 static int
 517 do_frame_register_read (void *src, int regnum, gdb_byte *buf)
 518 {
 519   return frame_register_read (src, regnum, buf);
 520 }
 521
 522 struct regcache *
 523 frame_save_as_regcache (struct frame_info *this_frame)
 524 {
 525   struct regcache *regcache = regcache_xmalloc (get_frame_arch (this_frame));
 526   struct cleanup *cleanups = make_cleanup_regcache_xfree (regcache);
 527   regcache_save (regcache, do_frame_register_read, this_frame);
 528   discard_cleanups (cleanups);
 529   return regcache;
 530 }
 531
 532 void
 533 frame_pop (struct frame_info *this_frame)
 534 {
 535   struct frame_info *prev_frame;
 536   struct regcache *scratch;
 537   struct cleanup *cleanups;
 538
 539   if (get_frame_type (this_frame) == DUMMY_FRAME)
 540     {
 541       /* Popping a dummy frame involves restoring more than just registers.
 542          dummy_frame_pop does all the work.  */
 543       dummy_frame_pop (get_frame_id (this_frame));
 544       return;
 545     }
 546
 547   /* Ensure that we have a frame to pop to.  */
 548   prev_frame = get_prev_frame_1 (this_frame);
 549
 550   if (!prev_frame)
 551     error (_("Cannot pop the initial frame."));
 552
 553   /* Make a copy of all the register values unwound from this frame.
 554      Save them in a scratch buffer so that there isn't a race between
 555      trying to extract the old values from the current regcache while
 556      at the same time writing new values into that same cache.  */
 557   scratch = frame_save_as_regcache (prev_frame);
 558   cleanups = make_cleanup_regcache_xfree (scratch);
 559
 560   /* FIXME: cagney/2003-03-16: It should be possible to tell the
 561      target's register cache that it is about to be hit with a burst
 562      register transfer and that the sequence of register writes should
 563      be batched.  The pair target_prepare_to_store() and
 564      target_store_registers() kind of suggest this functionality.
 565      Unfortunately, they don't implement it.  Their lack of a formal
 566      definition can lead to targets writing back bogus values
 567      (arguably a bug in the target code mind).  */
 568   /* Now copy those saved registers into the current regcache.
 569      Here, regcache_cpy() calls regcache_restore().  */
 570   regcache_cpy (get_current_regcache (), scratch);
 571   do_cleanups (cleanups);
 572
 573   /* We've made right mess of GDB's local state, just discard
 574      everything.  */
 575   reinit_frame_cache ();
 576 }
 577
 578 void
 579 frame_register_unwind (struct frame_info *frame, int regnum,
 580                        int *optimizedp, enum lval_type *lvalp,
 581                        CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
 582 {
 583   struct value *value;
 584
 585   /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
 586      that the value proper does not need to be fetched.  */
 587   gdb_assert (optimizedp != NULL);
 588   gdb_assert (lvalp != NULL);
 589   gdb_assert (addrp != NULL);
 590   gdb_assert (realnump != NULL);
 591   /* gdb_assert (bufferp != NULL); */
 592
 593   value = frame_unwind_register_value (frame, regnum);
 594
 595   gdb_assert (value != NULL);
 596
 597   *optimizedp = value_optimized_out (value);
 598   *lvalp = VALUE_LVAL (value);
 599   *addrp = VALUE_ADDRESS (value);
 600   *realnump = VALUE_REGNUM (value);
 601
 602   if (bufferp)
 603     memcpy (bufferp, value_contents_all (value),
 604             TYPE_LENGTH (value_type (value)));
 605
 606   /* Dispose of the new value.  This prevents watchpoints from
 607      trying to watch the saved frame pointer.  */
 608   release_value (value);
 609   value_free (value);
 610 }
 611
 612 void
 613 frame_register (struct frame_info *frame, int regnum,
 614                 int *optimizedp, enum lval_type *lvalp,
 615                 CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
 616 {
 617   /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
 618      that the value proper does not need to be fetched.  */
 619   gdb_assert (optimizedp != NULL);
 620   gdb_assert (lvalp != NULL);
 621   gdb_assert (addrp != NULL);
 622   gdb_assert (realnump != NULL);
 623   /* gdb_assert (bufferp != NULL); */
 624
 625   /* Obtain the register value by unwinding the register from the next
 626      (more inner frame).  */
 627   gdb_assert (frame != NULL && frame->next != NULL);
 628   frame_register_unwind (frame->next, regnum, optimizedp, lvalp, addrp,
 629                          realnump, bufferp);
 630 }
 631
 632 void
 633 frame_unwind_register (struct frame_info *frame, int regnum, gdb_byte *buf)
 634 {
 635   int optimized;
 636   CORE_ADDR addr;
 637   int realnum;
 638   enum lval_type lval;
 639   frame_register_unwind (frame, regnum, &optimized, &lval, &addr,
 640                          &realnum, buf);
 641 }
 642
 643 void
 644 get_frame_register (struct frame_info *frame,
 645                     int regnum, gdb_byte *buf)
 646 {
 647   frame_unwind_register (frame->next, regnum, buf);
 648 }
 649
 650 struct value *
 651 frame_unwind_register_value (struct frame_info *frame, int regnum)
 652 {
 653   struct value *value;
 654
 655   gdb_assert (frame != NULL);
 656
 657   if (frame_debug)
 658     {
 659       fprintf_unfiltered (gdb_stdlog, "\
 660 { frame_unwind_register_value (frame=%d,regnum=%d(%s),...) ",
 661                           frame->level, regnum,
 662                           user_reg_map_regnum_to_name
 663                             (get_frame_arch (frame), regnum));
 664     }
 665
 666   /* Find the unwinder.  */
 667   if (frame->unwind == NULL)
 668     frame->unwind = frame_unwind_find_by_frame (frame, &frame->prologue_cache);
 669
 670   /* Ask this frame to unwind its register.  */
 671   value = frame->unwind->prev_register (frame, &frame->prologue_cache, regnum);
 672
 673   if (frame_debug)
 674     {
 675       fprintf_unfiltered (gdb_stdlog, "->");
 676       if (value_optimized_out (value))
 677         fprintf_unfiltered (gdb_stdlog, " optimized out");
 678       else
 679         {
 680           if (VALUE_LVAL (value) == lval_register)
 681             fprintf_unfiltered (gdb_stdlog, " register=%d",
 682                                 VALUE_REGNUM (value));
 683           else if (VALUE_LVAL (value) == lval_memory)
 684             fprintf_unfiltered (gdb_stdlog, " address=0x%s",
 685                                 paddr_nz (VALUE_ADDRESS (value)));
 686           else
 687             fprintf_unfiltered (gdb_stdlog, " computed");
 688
 689           if (value_lazy (value))
 690             fprintf_unfiltered (gdb_stdlog, " lazy");
 691           else
 692             {
 693               int i;
 694               const gdb_byte *buf = value_contents (value);
 695
 696               fprintf_unfiltered (gdb_stdlog, " bytes=");
 697               fprintf_unfiltered (gdb_stdlog, "[");
 698               for (i = 0; i < register_size (get_frame_arch (frame), regnum); i++)
 699                 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
 700               fprintf_unfiltered (gdb_stdlog, "]");
 701             }
 702         }
 703
 704       fprintf_unfiltered (gdb_stdlog, " }\n");
 705     }
 706
 707   return value;
 708 }
 709
 710 struct value *
 711 get_frame_register_value (struct frame_info *frame, int regnum)
 712 {
 713   return frame_unwind_register_value (frame->next, regnum);
 714 }
 715
 716 LONGEST
 717 frame_unwind_register_signed (struct frame_info *frame, int regnum)
 718 {
 719   gdb_byte buf[MAX_REGISTER_SIZE];
 720   frame_unwind_register (frame, regnum, buf);
 721   return extract_signed_integer (buf, register_size (get_frame_arch (frame),
 722                                                      regnum));
 723 }
 724
 725 LONGEST
 726 get_frame_register_signed (struct frame_info *frame, int regnum)
 727 {
 728   return frame_unwind_register_signed (frame->next, regnum);
 729 }
 730
 731 ULONGEST
 732 frame_unwind_register_unsigned (struct frame_info *frame, int regnum)
 733 {
 734   gdb_byte buf[MAX_REGISTER_SIZE];
 735   frame_unwind_register (frame, regnum, buf);
 736   return extract_unsigned_integer (buf, register_size (get_frame_arch (frame),
 737                                                        regnum));
 738 }
 739
 740 ULONGEST
 741 get_frame_register_unsigned (struct frame_info *frame, int regnum)
 742 {
 743   return frame_unwind_register_unsigned (frame->next, regnum);
 744 }
 745
 746 void
 747 put_frame_register (struct frame_info *frame, int regnum,
 748                     const gdb_byte *buf)
 749 {
 750   struct gdbarch *gdbarch = get_frame_arch (frame);
 751   int realnum;
 752   int optim;
 753   enum lval_type lval;
 754   CORE_ADDR addr;
 755   frame_register (frame, regnum, &optim, &lval, &addr, &realnum, NULL);
 756   if (optim)
 757     error (_("Attempt to assign to a value that was optimized out."));
 758   switch (lval)
 759     {
 760     case lval_memory:
 761       {
 762         /* FIXME: write_memory doesn't yet take constant buffers.
 763            Arrrg!  */
 764         gdb_byte tmp[MAX_REGISTER_SIZE];
 765         memcpy (tmp, buf, register_size (gdbarch, regnum));
 766         write_memory (addr, tmp, register_size (gdbarch, regnum));
 767         break;
 768       }
 769     case lval_register:
 770       regcache_cooked_write (get_current_regcache (), realnum, buf);
 771       break;
 772     default:
 773       error (_("Attempt to assign to an unmodifiable value."));
 774     }
 775 }
 776
 777 /* frame_register_read ()
 778
 779    Find and return the value of REGNUM for the specified stack frame.
 780    The number of bytes copied is REGISTER_SIZE (REGNUM).
 781
 782    Returns 0 if the register value could not be found.  */
 783
 784 int
 785 frame_register_read (struct frame_info *frame, int regnum,
 786                      gdb_byte *myaddr)
 787 {
 788   int optimized;
 789   enum lval_type lval;
 790   CORE_ADDR addr;
 791   int realnum;
 792   frame_register (frame, regnum, &optimized, &lval, &addr, &realnum, myaddr);
 793
 794   return !optimized;
 795 }
 796
 797 int
 798 get_frame_register_bytes (struct frame_info *frame, int regnum,
 799                           CORE_ADDR offset, int len, gdb_byte *myaddr)
 800 {
 801   struct gdbarch *gdbarch = get_frame_arch (frame);
 802   int i;
 803   int maxsize;
 804   int numregs;
 805
 806   /* Skip registers wholly inside of OFFSET.  */
 807   while (offset >= register_size (gdbarch, regnum))
 808     {
 809       offset -= register_size (gdbarch, regnum);
 810       regnum++;
 811     }
 812
 813   /* Ensure that we will not read beyond the end of the register file.
 814      This can only ever happen if the debug information is bad.  */
 815   maxsize = -offset;
 816   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 817   for (i = regnum; i < numregs; i++)
 818     {
 819       int thissize = register_size (gdbarch, i);
 820       if (thissize == 0)
 821         break;  /* This register is not available on this architecture.  */
 822       maxsize += thissize;
 823     }
 824   if (len > maxsize)
 825     {
 826       warning (_("Bad debug information detected: "
 827                  "Attempt to read %d bytes from registers."), len);
 828       return 0;
 829     }
 830
 831   /* Copy the data.  */
 832   while (len > 0)
 833     {
 834       int curr_len = register_size (gdbarch, regnum) - offset;
 835       if (curr_len > len)
 836         curr_len = len;
 837
 838       if (curr_len == register_size (gdbarch, regnum))
 839         {
 840           if (!frame_register_read (frame, regnum, myaddr))
 841             return 0;
 842         }
 843       else
 844         {
 845           gdb_byte buf[MAX_REGISTER_SIZE];
 846           if (!frame_register_read (frame, regnum, buf))
 847             return 0;
 848           memcpy (myaddr, buf + offset, curr_len);
 849         }
 850
 851       myaddr += curr_len;
 852       len -= curr_len;
 853       offset = 0;
 854       regnum++;
 855     }
 856
 857   return 1;
 858 }
 859
 860 void
 861 put_frame_register_bytes (struct frame_info *frame, int regnum,
 862                           CORE_ADDR offset, int len, const gdb_byte *myaddr)
 863 {
 864   struct gdbarch *gdbarch = get_frame_arch (frame);
 865
 866   /* Skip registers wholly inside of OFFSET.  */
 867   while (offset >= register_size (gdbarch, regnum))
 868     {
 869       offset -= register_size (gdbarch, regnum);
 870       regnum++;
 871     }
 872
 873   /* Copy the data.  */
 874   while (len > 0)
 875     {
 876       int curr_len = register_size (gdbarch, regnum) - offset;
 877       if (curr_len > len)
 878         curr_len = len;
 879
 880       if (curr_len == register_size (gdbarch, regnum))
 881         {
 882           put_frame_register (frame, regnum, myaddr);
 883         }
 884       else
 885         {
 886           gdb_byte buf[MAX_REGISTER_SIZE];
 887           frame_register_read (frame, regnum, buf);
 888           memcpy (buf + offset, myaddr, curr_len);
 889           put_frame_register (frame, regnum, buf);
 890         }
 891
 892       myaddr += curr_len;
 893       len -= curr_len;
 894       offset = 0;
 895       regnum++;
 896     }
 897 }
 898
 899 /* Create a sentinel frame.  */
 900
 901 static struct frame_info *
 902 create_sentinel_frame (struct regcache *regcache)
 903 {
 904   struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
 905   frame->level = -1;
 906   /* Explicitly initialize the sentinel frame's cache.  Provide it
 907      with the underlying regcache.  In the future additional
 908      information, such as the frame's thread will be added.  */
 909   frame->prologue_cache = sentinel_frame_cache (regcache);
 910   /* For the moment there is only one sentinel frame implementation.  */
 911   frame->unwind = sentinel_frame_unwind;
 912   /* Link this frame back to itself.  The frame is self referential
 913      (the unwound PC is the same as the pc), so make it so.  */
 914   frame->next = frame;
 915   /* Make the sentinel frame's ID valid, but invalid.  That way all
 916      comparisons with it should fail.  */
 917   frame->this_id.p = 1;
 918   frame->this_id.value = null_frame_id;
 919   if (frame_debug)
 920     {
 921       fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> ");
 922       fprint_frame (gdb_stdlog, frame);
 923       fprintf_unfiltered (gdb_stdlog, " }\n");
 924     }
 925   return frame;
 926 }
 927
 928 /* Info about the innermost stack frame (contents of FP register) */
 929
 930 static struct frame_info *current_frame;
 931
 932 /* Cache for frame addresses already read by gdb.  Valid only while
 933    inferior is stopped.  Control variables for the frame cache should
 934    be local to this module.  */
 935
 936 static struct obstack frame_cache_obstack;
 937
 938 void *
 939 frame_obstack_zalloc (unsigned long size)
 940 {
 941   void *data = obstack_alloc (&frame_cache_obstack, size);
 942   memset (data, 0, size);
 943   return data;
 944 }
 945
 946 /* Return the innermost (currently executing) stack frame.  This is
 947    split into two functions.  The function unwind_to_current_frame()
 948    is wrapped in catch exceptions so that, even when the unwind of the
 949    sentinel frame fails, the function still returns a stack frame.  */
 950
 951 static int
 952 unwind_to_current_frame (struct ui_out *ui_out, void *args)
 953 {
 954   struct frame_info *frame = get_prev_frame (args);
 955   /* A sentinel frame can fail to unwind, e.g., because its PC value
 956      lands in somewhere like start.  */
 957   if (frame == NULL)
 958     return 1;
 959   current_frame = frame;
 960   return 0;
 961 }
 962
 963 struct frame_info *
 964 get_current_frame (void)
 965 {
 966   /* First check, and report, the lack of registers.  Having GDB
 967      report "No stack!" or "No memory" when the target doesn't even
 968      have registers is very confusing.  Besides, "printcmd.exp"
 969      explicitly checks that ``print $pc'' with no registers prints "No
 970      registers".  */
 971   if (!target_has_registers)
 972     error (_("No registers."));
 973   if (!target_has_stack)
 974     error (_("No stack."));
 975   if (!target_has_memory)
 976     error (_("No memory."));
 977   if (is_executing (inferior_ptid))
 978     error (_("Target is executing."));
 979
 980   if (current_frame == NULL)
 981     {
 982       struct frame_info *sentinel_frame =
 983         create_sentinel_frame (get_current_regcache ());
 984       if (catch_exceptions (uiout, unwind_to_current_frame, sentinel_frame,
 985                             RETURN_MASK_ERROR) != 0)
 986         {
 987           /* Oops! Fake a current frame?  Is this useful?  It has a PC
 988              of zero, for instance.  */
 989           current_frame = sentinel_frame;
 990         }
 991     }
 992   return current_frame;
 993 }
 994
 995 /* The "selected" stack frame is used by default for local and arg
 996    access.  May be zero, for no selected frame.  */
 997
 998 static struct frame_info *selected_frame;
 999
1000 int
1001 has_stack_frames (void)
1002 {
1003   if (!target_has_registers || !target_has_stack || !target_has_memory)
1004     return 0;
1005
1006   /* If the current thread is executing, don't try to read from
1007      it.  */
1008   if (is_executing (inferior_ptid))
1009     return 0;
1010
1011   return 1;
1012 }
1013
1014 /* Return the selected frame.  Always non-NULL (unless there isn't an
1015    inferior sufficient for creating a frame) in which case an error is
1016    thrown.  */
1017
1018 struct frame_info *
1019 get_selected_frame (const char *message)
1020 {
1021   if (selected_frame == NULL)
1022     {
1023       if (message != NULL && !has_stack_frames ())
1024         error (("%s"), message);
1025       /* Hey!  Don't trust this.  It should really be re-finding the
1026          last selected frame of the currently selected thread.  This,
1027          though, is better than nothing.  */
1028       select_frame (get_current_frame ());
1029     }
1030   /* There is always a frame.  */
1031   gdb_assert (selected_frame != NULL);
1032   return selected_frame;
1033 }
1034
1035 /* This is a variant of get_selected_frame() which can be called when
1036    the inferior does not have a frame; in that case it will return
1037    NULL instead of calling error().  */
1038
1039 struct frame_info *
1040 deprecated_safe_get_selected_frame (void)
1041 {
1042   if (!has_stack_frames ())
1043     return NULL;
1044   return get_selected_frame (NULL);
1045 }
1046
1047 /* Select frame FI (or NULL - to invalidate the current frame).  */
1048
1049 void
1050 select_frame (struct frame_info *fi)
1051 {
1052   struct symtab *s;
1053
1054   selected_frame = fi;
1055   /* NOTE: cagney/2002-05-04: FI can be NULL.  This occurs when the
1056      frame is being invalidated.  */
1057   if (deprecated_selected_frame_level_changed_hook)
1058     deprecated_selected_frame_level_changed_hook (frame_relative_level (fi));
1059
1060   /* FIXME: kseitz/2002-08-28: It would be nice to call
1061      selected_frame_level_changed_event() right here, but due to limitations
1062      in the current interfaces, we would end up flooding UIs with events
1063      because select_frame() is used extensively internally.
1064
1065      Once we have frame-parameterized frame (and frame-related) commands,
1066      the event notification can be moved here, since this function will only
1067      be called when the user's selected frame is being changed. */
1068
1069   /* Ensure that symbols for this frame are read in.  Also, determine the
1070      source language of this frame, and switch to it if desired.  */
1071   if (fi)
1072     {
1073       /* We retrieve the frame's symtab by using the frame PC.  However
1074          we cannot use the frame PC as-is, because it usually points to
1075          the instruction following the "call", which is sometimes the
1076          first instruction of another function.  So we rely on
1077          get_frame_address_in_block() which provides us with a PC which
1078          is guaranteed to be inside the frame's code block.  */
1079       s = find_pc_symtab (get_frame_address_in_block (fi));
1080       if (s
1081           && s->language != current_language->la_language
1082           && s->language != language_unknown
1083           && language_mode == language_mode_auto)
1084         {
1085           set_language (s->language);
1086         }
1087     }
1088 }
1089
1090 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1091    Always returns a non-NULL value.  */
1092
1093 struct frame_info *
1094 create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
1095 {
1096   struct frame_info *fi;
1097
1098   if (frame_debug)
1099     {
1100       fprintf_unfiltered (gdb_stdlog,
1101                           "{ create_new_frame (addr=0x%s, pc=0x%s) ",
1102                           paddr_nz (addr), paddr_nz (pc));
1103     }
1104
1105   fi = FRAME_OBSTACK_ZALLOC (struct frame_info);
1106
1107   fi->next = create_sentinel_frame (get_current_regcache ());
1108
1109   /* Set/update this frame's cached PC value, found in the next frame.
1110      Do this before looking for this frame's unwinder.  A sniffer is
1111      very likely to read this, and the corresponding unwinder is
1112      entitled to rely that the PC doesn't magically change.  */
1113   fi->next->prev_pc.value = pc;
1114   fi->next->prev_pc.p = 1;
1115
1116   /* Select/initialize both the unwind function and the frame's type
1117      based on the PC.  */
1118   fi->unwind = frame_unwind_find_by_frame (fi, &fi->prologue_cache);
1119
1120   fi->this_id.p = 1;
1121   fi->this_id.value = frame_id_build (addr, pc);
1122
1123   if (frame_debug)
1124     {
1125       fprintf_unfiltered (gdb_stdlog, "-> ");
1126       fprint_frame (gdb_stdlog, fi);
1127       fprintf_unfiltered (gdb_stdlog, " }\n");
1128     }
1129
1130   return fi;
1131 }
1132
1133 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1134    innermost frame).  Be careful to not fall off the bottom of the
1135    frame chain and onto the sentinel frame.  */
1136
1137 struct frame_info *
1138 get_next_frame (struct frame_info *this_frame)
1139 {
1140   if (this_frame->level > 0)
1141     return this_frame->next;
1142   else
1143     return NULL;
1144 }
1145
1146 /* Observer for the target_changed event.  */
1147
1148 static void
1149 frame_observer_target_changed (struct target_ops *target)
1150 {
1151   reinit_frame_cache ();
1152 }
1153
1154 /* Flush the entire frame cache.  */
1155
1156 void
1157 reinit_frame_cache (void)
1158 {
1159   struct frame_info *fi;
1160
1161   /* Tear down all frame caches.  */
1162   for (fi = current_frame; fi != NULL; fi = fi->prev)
1163     {
1164       if (fi->prologue_cache && fi->unwind->dealloc_cache)
1165         fi->unwind->dealloc_cache (fi, fi->prologue_cache);
1166       if (fi->base_cache && fi->base->unwind->dealloc_cache)
1167         fi->base->unwind->dealloc_cache (fi, fi->base_cache);
1168     }
1169
1170   /* Since we can't really be sure what the first object allocated was */
1171   obstack_free (&frame_cache_obstack, 0);
1172   obstack_init (&frame_cache_obstack);
1173
1174   if (current_frame != NULL)
1175     annotate_frames_invalid ();
1176
1177   current_frame = NULL;         /* Invalidate cache */
1178   select_frame (NULL);
1179   if (frame_debug)
1180     fprintf_unfiltered (gdb_stdlog, "{ reinit_frame_cache () }\n");
1181 }
1182
1183 /* Find where a register is saved (in memory or another register).
1184    The result of frame_register_unwind is just where it is saved
1185    relative to this particular frame.  */
1186
1187 static void
1188 frame_register_unwind_location (struct frame_info *this_frame, int regnum,
1189                                 int *optimizedp, enum lval_type *lvalp,
1190                                 CORE_ADDR *addrp, int *realnump)
1191 {
1192   gdb_assert (this_frame == NULL || this_frame->level >= 0);
1193
1194   while (this_frame != NULL)
1195     {
1196       frame_register_unwind (this_frame, regnum, optimizedp, lvalp,
1197                              addrp, realnump, NULL);
1198
1199       if (*optimizedp)
1200         break;
1201
1202       if (*lvalp != lval_register)
1203         break;
1204
1205       regnum = *realnump;
1206       this_frame = get_next_frame (this_frame);
1207     }
1208 }
1209
1210 /* Return a "struct frame_info" corresponding to the frame that called
1211    THIS_FRAME.  Returns NULL if there is no such frame.
1212
1213    Unlike get_prev_frame, this function always tries to unwind the
1214    frame.  */
1215
1216 static struct frame_info *
1217 get_prev_frame_1 (struct frame_info *this_frame)
1218 {
1219   struct frame_info *prev_frame;
1220   struct frame_id this_id;
1221   struct gdbarch *gdbarch;
1222
1223   gdb_assert (this_frame != NULL);
1224   gdbarch = get_frame_arch (this_frame);
1225
1226   if (frame_debug)
1227     {
1228       fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_1 (this_frame=");
1229       if (this_frame != NULL)
1230         fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1231       else
1232         fprintf_unfiltered (gdb_stdlog, "<NULL>");
1233       fprintf_unfiltered (gdb_stdlog, ") ");
1234     }
1235
1236   /* Only try to do the unwind once.  */
1237   if (this_frame->prev_p)
1238     {
1239       if (frame_debug)
1240         {
1241           fprintf_unfiltered (gdb_stdlog, "-> ");
1242           fprint_frame (gdb_stdlog, this_frame->prev);
1243           fprintf_unfiltered (gdb_stdlog, " // cached \n");
1244         }
1245       return this_frame->prev;
1246     }
1247
1248   /* If the frame unwinder hasn't been selected yet, we must do so
1249      before setting prev_p; otherwise the check for misbehaved
1250      sniffers will think that this frame's sniffer tried to unwind
1251      further (see frame_cleanup_after_sniffer).  */
1252   if (this_frame->unwind == NULL)
1253     this_frame->unwind
1254       = frame_unwind_find_by_frame (this_frame, &this_frame->prologue_cache);
1255
1256   this_frame->prev_p = 1;
1257   this_frame->stop_reason = UNWIND_NO_REASON;
1258
1259   /* Check that this frame's ID was valid.  If it wasn't, don't try to
1260      unwind to the prev frame.  Be careful to not apply this test to
1261      the sentinel frame.  */
1262   this_id = get_frame_id (this_frame);
1263   if (this_frame->level >= 0 && !frame_id_p (this_id))
1264     {
1265       if (frame_debug)
1266         {
1267           fprintf_unfiltered (gdb_stdlog, "-> ");
1268           fprint_frame (gdb_stdlog, NULL);
1269           fprintf_unfiltered (gdb_stdlog, " // this ID is NULL }\n");
1270         }
1271       this_frame->stop_reason = UNWIND_NULL_ID;
1272       return NULL;
1273     }
1274
1275   /* Check that this frame's ID isn't inner to (younger, below, next)
1276      the next frame.  This happens when a frame unwind goes backwards.
1277      This check is valid only if the next frame is NORMAL.  See the
1278      comment at frame_id_inner for details.  */
1279   if (this_frame->next->unwind->type == NORMAL_FRAME
1280       && frame_id_inner (get_frame_arch (this_frame->next), this_id,
1281                          get_frame_id (this_frame->next)))
1282     {
1283       if (frame_debug)
1284         {
1285           fprintf_unfiltered (gdb_stdlog, "-> ");
1286           fprint_frame (gdb_stdlog, NULL);
1287           fprintf_unfiltered (gdb_stdlog, " // this frame ID is inner }\n");
1288         }
1289       this_frame->stop_reason = UNWIND_INNER_ID;
1290       return NULL;
1291     }
1292
1293   /* Check that this and the next frame are not identical.  If they
1294      are, there is most likely a stack cycle.  As with the inner-than
1295      test above, avoid comparing the inner-most and sentinel frames.  */
1296   if (this_frame->level > 0
1297       && frame_id_eq (this_id, get_frame_id (this_frame->next)))
1298     {
1299       if (frame_debug)
1300         {
1301           fprintf_unfiltered (gdb_stdlog, "-> ");
1302           fprint_frame (gdb_stdlog, NULL);
1303           fprintf_unfiltered (gdb_stdlog, " // this frame has same ID }\n");
1304         }
1305       this_frame->stop_reason = UNWIND_SAME_ID;
1306       return NULL;
1307     }
1308
1309   /* Check that this and the next frame do not unwind the PC register
1310      to the same memory location.  If they do, then even though they
1311      have different frame IDs, the new frame will be bogus; two
1312      functions can't share a register save slot for the PC.  This can
1313      happen when the prologue analyzer finds a stack adjustment, but
1314      no PC save.
1315
1316      This check does assume that the "PC register" is roughly a
1317      traditional PC, even if the gdbarch_unwind_pc method adjusts
1318      it (we do not rely on the value, only on the unwound PC being
1319      dependent on this value).  A potential improvement would be
1320      to have the frame prev_pc method and the gdbarch unwind_pc
1321      method set the same lval and location information as
1322      frame_register_unwind.  */
1323   if (this_frame->level > 0
1324       && gdbarch_pc_regnum (gdbarch) >= 0
1325       && get_frame_type (this_frame) == NORMAL_FRAME
1326       && get_frame_type (this_frame->next) == NORMAL_FRAME)
1327     {
1328       int optimized, realnum, nrealnum;
1329       enum lval_type lval, nlval;
1330       CORE_ADDR addr, naddr;
1331
1332       frame_register_unwind_location (this_frame,
1333                                       gdbarch_pc_regnum (gdbarch),
1334                                       &optimized, &lval, &addr, &realnum);
1335       frame_register_unwind_location (get_next_frame (this_frame),
1336                                       gdbarch_pc_regnum (gdbarch),
1337                                       &optimized, &nlval, &naddr, &nrealnum);
1338
1339       if ((lval == lval_memory && lval == nlval && addr == naddr)
1340           || (lval == lval_register && lval == nlval && realnum == nrealnum))
1341         {
1342           if (frame_debug)
1343             {
1344               fprintf_unfiltered (gdb_stdlog, "-> ");
1345               fprint_frame (gdb_stdlog, NULL);
1346               fprintf_unfiltered (gdb_stdlog, " // no saved PC }\n");
1347             }
1348
1349           this_frame->stop_reason = UNWIND_NO_SAVED_PC;
1350           this_frame->prev = NULL;
1351           return NULL;
1352         }
1353     }
1354
1355   /* Allocate the new frame but do not wire it in to the frame chain.
1356      Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1357      frame->next to pull some fancy tricks (of course such code is, by
1358      definition, recursive).  Try to prevent it.
1359
1360      There is no reason to worry about memory leaks, should the
1361      remainder of the function fail.  The allocated memory will be
1362      quickly reclaimed when the frame cache is flushed, and the `we've
1363      been here before' check above will stop repeated memory
1364      allocation calls.  */
1365   prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1366   prev_frame->level = this_frame->level + 1;
1367
1368   /* Don't yet compute ->unwind (and hence ->type).  It is computed
1369      on-demand in get_frame_type, frame_register_unwind, and
1370      get_frame_id.  */
1371
1372   /* Don't yet compute the frame's ID.  It is computed on-demand by
1373      get_frame_id().  */
1374
1375   /* The unwound frame ID is validate at the start of this function,
1376      as part of the logic to decide if that frame should be further
1377      unwound, and not here while the prev frame is being created.
1378      Doing this makes it possible for the user to examine a frame that
1379      has an invalid frame ID.
1380
1381      Some very old VAX code noted: [...]  For the sake of argument,
1382      suppose that the stack is somewhat trashed (which is one reason
1383      that "info frame" exists).  So, return 0 (indicating we don't
1384      know the address of the arglist) if we don't know what frame this
1385      frame calls.  */
1386
1387   /* Link it in.  */
1388   this_frame->prev = prev_frame;
1389   prev_frame->next = this_frame;
1390
1391   if (frame_debug)
1392     {
1393       fprintf_unfiltered (gdb_stdlog, "-> ");
1394       fprint_frame (gdb_stdlog, prev_frame);
1395       fprintf_unfiltered (gdb_stdlog, " }\n");
1396     }
1397
1398   return prev_frame;
1399 }
1400
1401 /* Debug routine to print a NULL frame being returned.  */
1402
1403 static void
1404 frame_debug_got_null_frame (struct frame_info *this_frame,
1405                             const char *reason)
1406 {
1407   if (frame_debug)
1408     {
1409       fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame=");
1410       if (this_frame != NULL)
1411         fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1412       else
1413         fprintf_unfiltered (gdb_stdlog, "<NULL>");
1414       fprintf_unfiltered (gdb_stdlog, ") -> // %s}\n", reason);
1415     }
1416 }
1417
1418 /* Is this (non-sentinel) frame in the "main"() function?  */
1419
1420 static int
1421 inside_main_func (struct frame_info *this_frame)
1422 {
1423   struct minimal_symbol *msymbol;
1424   CORE_ADDR maddr;
1425
1426   if (symfile_objfile == 0)
1427     return 0;
1428   msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
1429   if (msymbol == NULL)
1430     return 0;
1431   /* Make certain that the code, and not descriptor, address is
1432      returned.  */
1433   maddr = gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame),
1434                                               SYMBOL_VALUE_ADDRESS (msymbol),
1435                                               &current_target);
1436   return maddr == get_frame_func (this_frame);
1437 }
1438
1439 /* Test whether THIS_FRAME is inside the process entry point function.  */
1440
1441 static int
1442 inside_entry_func (struct frame_info *this_frame)
1443 {
1444   return (get_frame_func (this_frame) == entry_point_address ());
1445 }
1446
1447 /* Return a structure containing various interesting information about
1448    the frame that called THIS_FRAME.  Returns NULL if there is entier
1449    no such frame or the frame fails any of a set of target-independent
1450    condition that should terminate the frame chain (e.g., as unwinding
1451    past main()).
1452
1453    This function should not contain target-dependent tests, such as
1454    checking whether the program-counter is zero.  */
1455
1456 struct frame_info *
1457 get_prev_frame (struct frame_info *this_frame)
1458 {
1459   struct frame_info *prev_frame;
1460
1461   /* There is always a frame.  If this assertion fails, suspect that
1462      something should be calling get_selected_frame() or
1463      get_current_frame().  */
1464   gdb_assert (this_frame != NULL);
1465
1466   /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
1467      sense to stop unwinding at a dummy frame.  One place where a dummy
1468      frame may have an address "inside_main_func" is on HPUX.  On HPUX, the
1469      pcsqh register (space register for the instruction at the head of the
1470      instruction queue) cannot be written directly; the only way to set it
1471      is to branch to code that is in the target space.  In order to implement
1472      frame dummies on HPUX, the called function is made to jump back to where
1473      the inferior was when the user function was called.  If gdb was inside
1474      the main function when we created the dummy frame, the dummy frame will
1475      point inside the main function.  */
1476   if (this_frame->level >= 0
1477       && get_frame_type (this_frame) != DUMMY_FRAME
1478       && !backtrace_past_main
1479       && inside_main_func (this_frame))
1480     /* Don't unwind past main().  Note, this is done _before_ the
1481        frame has been marked as previously unwound.  That way if the
1482        user later decides to enable unwinds past main(), that will
1483        automatically happen.  */
1484     {
1485       frame_debug_got_null_frame (this_frame, "inside main func");
1486       return NULL;
1487     }
1488
1489   /* If the user's backtrace limit has been exceeded, stop.  We must
1490      add two to the current level; one of those accounts for backtrace_limit
1491      being 1-based and the level being 0-based, and the other accounts for
1492      the level of the new frame instead of the level of the current
1493      frame.  */
1494   if (this_frame->level + 2 > backtrace_limit)
1495     {
1496       frame_debug_got_null_frame (this_frame, "backtrace limit exceeded");
1497       return NULL;
1498     }
1499
1500   /* If we're already inside the entry function for the main objfile,
1501      then it isn't valid.  Don't apply this test to a dummy frame -
1502      dummy frame PCs typically land in the entry func.  Don't apply
1503      this test to the sentinel frame.  Sentinel frames should always
1504      be allowed to unwind.  */
1505   /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1506      wasn't checking for "main" in the minimal symbols.  With that
1507      fixed asm-source tests now stop in "main" instead of halting the
1508      backtrace in weird and wonderful ways somewhere inside the entry
1509      file.  Suspect that tests for inside the entry file/func were
1510      added to work around that (now fixed) case.  */
1511   /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1512      suggested having the inside_entry_func test use the
1513      inside_main_func() msymbol trick (along with entry_point_address()
1514      I guess) to determine the address range of the start function.
1515      That should provide a far better stopper than the current
1516      heuristics.  */
1517   /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
1518      applied tail-call optimizations to main so that a function called
1519      from main returns directly to the caller of main.  Since we don't
1520      stop at main, we should at least stop at the entry point of the
1521      application.  */
1522   if (!backtrace_past_entry
1523       && get_frame_type (this_frame) != DUMMY_FRAME && this_frame->level >= 0
1524       && inside_entry_func (this_frame))
1525     {
1526       frame_debug_got_null_frame (this_frame, "inside entry func");
1527       return NULL;
1528     }
1529
1530   /* Assume that the only way to get a zero PC is through something
1531      like a SIGSEGV or a dummy frame, and hence that NORMAL frames
1532      will never unwind a zero PC.  */
1533   if (this_frame->level > 0
1534       && get_frame_type (this_frame) == NORMAL_FRAME
1535       && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME
1536       && get_frame_pc (this_frame) == 0)
1537     {
1538       frame_debug_got_null_frame (this_frame, "zero PC");
1539       return NULL;
1540     }
1541
1542   return get_prev_frame_1 (this_frame);
1543 }
1544
1545 CORE_ADDR
1546 get_frame_pc (struct frame_info *frame)
1547 {
1548   gdb_assert (frame->next != NULL);
1549   return frame_pc_unwind (frame->next);
1550 }
1551
1552 /* Return an address that falls within THIS_FRAME's code block.  */
1553
1554 CORE_ADDR
1555 get_frame_address_in_block (struct frame_info *this_frame)
1556 {
1557   /* A draft address.  */
1558   CORE_ADDR pc = get_frame_pc (this_frame);
1559
1560   struct frame_info *next_frame = this_frame->next;
1561
1562   /* Calling get_frame_pc returns the resume address for THIS_FRAME.
1563      Normally the resume address is inside the body of the function
1564      associated with THIS_FRAME, but there is a special case: when
1565      calling a function which the compiler knows will never return
1566      (for instance abort), the call may be the very last instruction
1567      in the calling function.  The resume address will point after the
1568      call and may be at the beginning of a different function
1569      entirely.
1570
1571      If THIS_FRAME is a signal frame or dummy frame, then we should
1572      not adjust the unwound PC.  For a dummy frame, GDB pushed the
1573      resume address manually onto the stack.  For a signal frame, the
1574      OS may have pushed the resume address manually and invoked the
1575      handler (e.g. GNU/Linux), or invoked the trampoline which called
1576      the signal handler - but in either case the signal handler is
1577      expected to return to the trampoline.  So in both of these
1578      cases we know that the resume address is executable and
1579      related.  So we only need to adjust the PC if THIS_FRAME
1580      is a normal function.
1581
1582      If the program has been interrupted while THIS_FRAME is current,
1583      then clearly the resume address is inside the associated
1584      function.  There are three kinds of interruption: debugger stop
1585      (next frame will be SENTINEL_FRAME), operating system
1586      signal or exception (next frame will be SIGTRAMP_FRAME),
1587      or debugger-induced function call (next frame will be
1588      DUMMY_FRAME).  So we only need to adjust the PC if
1589      NEXT_FRAME is a normal function.
1590
1591      We check the type of NEXT_FRAME first, since it is already
1592      known; frame type is determined by the unwinder, and since
1593      we have THIS_FRAME we've already selected an unwinder for
1594      NEXT_FRAME.  */
1595   if (get_frame_type (next_frame) == NORMAL_FRAME
1596       && get_frame_type (this_frame) == NORMAL_FRAME)
1597     return pc - 1;
1598
1599   return pc;
1600 }
1601
1602 static int
1603 pc_notcurrent (struct frame_info *frame)
1604 {
1605   /* If FRAME is not the innermost frame, that normally means that
1606      FRAME->pc points at the return instruction (which is *after* the
1607      call instruction), and we want to get the line containing the
1608      call (because the call is where the user thinks the program is).
1609      However, if the next frame is either a SIGTRAMP_FRAME or a
1610      DUMMY_FRAME, then the next frame will contain a saved interrupt
1611      PC and such a PC indicates the current (rather than next)
1612      instruction/line, consequently, for such cases, want to get the
1613      line containing fi->pc.  */
1614   struct frame_info *next = get_next_frame (frame);
1615   int notcurrent = (next != NULL && get_frame_type (next) == NORMAL_FRAME);
1616   return notcurrent;
1617 }
1618
1619 void
1620 find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
1621 {
1622   (*sal) = find_pc_line (get_frame_pc (frame), pc_notcurrent (frame));
1623 }
1624
1625 /* Per "frame.h", return the ``address'' of the frame.  Code should
1626    really be using get_frame_id().  */
1627 CORE_ADDR
1628 get_frame_base (struct frame_info *fi)
1629 {
1630   return get_frame_id (fi).stack_addr;
1631 }
1632
1633 /* High-level offsets into the frame.  Used by the debug info.  */
1634
1635 CORE_ADDR
1636 get_frame_base_address (struct frame_info *fi)
1637 {
1638   if (get_frame_type (fi) != NORMAL_FRAME)
1639     return 0;
1640   if (fi->base == NULL)
1641     fi->base = frame_base_find_by_frame (fi);
1642   /* Sneaky: If the low-level unwind and high-level base code share a
1643      common unwinder, let them share the prologue cache.  */
1644   if (fi->base->unwind == fi->unwind)
1645     return fi->base->this_base (fi, &fi->prologue_cache);
1646   return fi->base->this_base (fi, &fi->base_cache);
1647 }
1648
1649 CORE_ADDR
1650 get_frame_locals_address (struct frame_info *fi)
1651 {
1652   void **cache;
1653   if (get_frame_type (fi) != NORMAL_FRAME)
1654     return 0;
1655   /* If there isn't a frame address method, find it.  */
1656   if (fi->base == NULL)
1657     fi->base = frame_base_find_by_frame (fi);
1658   /* Sneaky: If the low-level unwind and high-level base code share a
1659      common unwinder, let them share the prologue cache.  */
1660   if (fi->base->unwind == fi->unwind)
1661     return fi->base->this_locals (fi, &fi->prologue_cache);
1662   return fi->base->this_locals (fi, &fi->base_cache);
1663 }
1664
1665 CORE_ADDR
1666 get_frame_args_address (struct frame_info *fi)
1667 {
1668   void **cache;
1669   if (get_frame_type (fi) != NORMAL_FRAME)
1670     return 0;
1671   /* If there isn't a frame address method, find it.  */
1672   if (fi->base == NULL)
1673     fi->base = frame_base_find_by_frame (fi);
1674   /* Sneaky: If the low-level unwind and high-level base code share a
1675      common unwinder, let them share the prologue cache.  */
1676   if (fi->base->unwind == fi->unwind)
1677     return fi->base->this_args (fi, &fi->prologue_cache);
1678   return fi->base->this_args (fi, &fi->base_cache);
1679 }
1680
1681 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1682    or -1 for a NULL frame.  */
1683
1684 int
1685 frame_relative_level (struct frame_info *fi)
1686 {
1687   if (fi == NULL)
1688     return -1;
1689   else
1690     return fi->level;
1691 }
1692
1693 enum frame_type
1694 get_frame_type (struct frame_info *frame)
1695 {
1696   if (frame->unwind == NULL)
1697     /* Initialize the frame's unwinder because that's what
1698        provides the frame's type.  */
1699     frame->unwind = frame_unwind_find_by_frame (frame, &frame->prologue_cache);
1700   return frame->unwind->type;
1701 }
1702
1703 /* Memory access methods.  */
1704
1705 void
1706 get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
1707                   gdb_byte *buf, int len)
1708 {
1709   read_memory (addr, buf, len);
1710 }
1711
1712 LONGEST
1713 get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr,
1714                          int len)
1715 {
1716   return read_memory_integer (addr, len);
1717 }
1718
1719 ULONGEST
1720 get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
1721                            int len)
1722 {
1723   return read_memory_unsigned_integer (addr, len);
1724 }
1725
1726 int
1727 safe_frame_unwind_memory (struct frame_info *this_frame,
1728                           CORE_ADDR addr, gdb_byte *buf, int len)
1729 {
1730   /* NOTE: target_read_memory returns zero on success!  */
1731   return !target_read_memory (addr, buf, len);
1732 }
1733
1734 /* Architecture method.  */
1735
1736 struct gdbarch *
1737 get_frame_arch (struct frame_info *this_frame)
1738 {
1739   /* In the future, this function will return a per-frame
1740      architecture instead of current_gdbarch.  Calling the
1741      routine with a NULL value of this_frame is a bug!  */
1742   gdb_assert (this_frame);
1743
1744   return current_gdbarch;
1745 }
1746
1747 /* Stack pointer methods.  */
1748
1749 CORE_ADDR
1750 get_frame_sp (struct frame_info *this_frame)
1751 {
1752   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1753   /* Normality - an architecture that provides a way of obtaining any
1754      frame inner-most address.  */
1755   if (gdbarch_unwind_sp_p (gdbarch))
1756     /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
1757        operate on THIS_FRAME now.  */
1758     return gdbarch_unwind_sp (gdbarch, this_frame->next);
1759   /* Now things are really are grim.  Hope that the value returned by
1760      the gdbarch_sp_regnum register is meaningful.  */
1761   if (gdbarch_sp_regnum (gdbarch) >= 0)
1762     return get_frame_register_unsigned (this_frame,
1763                                         gdbarch_sp_regnum (gdbarch));
1764   internal_error (__FILE__, __LINE__, _("Missing unwind SP method"));
1765 }
1766
1767 /* Return the reason why we can't unwind past FRAME.  */
1768
1769 enum unwind_stop_reason
1770 get_frame_unwind_stop_reason (struct frame_info *frame)
1771 {
1772   /* If we haven't tried to unwind past this point yet, then assume
1773      that unwinding would succeed.  */
1774   if (frame->prev_p == 0)
1775     return UNWIND_NO_REASON;
1776
1777   /* Otherwise, we set a reason when we succeeded (or failed) to
1778      unwind.  */
1779   return frame->stop_reason;
1780 }
1781
1782 /* Return a string explaining REASON.  */
1783
1784 const char *
1785 frame_stop_reason_string (enum unwind_stop_reason reason)
1786 {
1787   switch (reason)
1788     {
1789     case UNWIND_NULL_ID:
1790       return _("unwinder did not report frame ID");
1791
1792     case UNWIND_INNER_ID:
1793       return _("previous frame inner to this frame (corrupt stack?)");
1794
1795     case UNWIND_SAME_ID:
1796       return _("previous frame identical to this frame (corrupt stack?)");
1797
1798     case UNWIND_NO_SAVED_PC:
1799       return _("frame did not save the PC");
1800
1801     case UNWIND_NO_REASON:
1802     case UNWIND_FIRST_ERROR:
1803     default:
1804       internal_error (__FILE__, __LINE__,
1805                       "Invalid frame stop reason");
1806     }
1807 }
1808
1809 /* Clean up after a failed (wrong unwinder) attempt to unwind past
1810    FRAME.  */
1811
1812 static void
1813 frame_cleanup_after_sniffer (void *arg)
1814 {
1815   struct frame_info *frame = arg;
1816
1817   /* The sniffer should not allocate a prologue cache if it did not
1818      match this frame.  */
1819   gdb_assert (frame->prologue_cache == NULL);
1820
1821   /* No sniffer should extend the frame chain; sniff based on what is
1822      already certain.  */
1823   gdb_assert (!frame->prev_p);
1824
1825   /* The sniffer should not check the frame's ID; that's circular.  */
1826   gdb_assert (!frame->this_id.p);
1827
1828   /* Clear cached fields dependent on the unwinder.
1829
1830      The previous PC is independent of the unwinder, but the previous
1831      function is not (see get_frame_address_in_block).  */
1832   frame->prev_func.p = 0;
1833   frame->prev_func.addr = 0;
1834
1835   /* Discard the unwinder last, so that we can easily find it if an assertion
1836      in this function triggers.  */
1837   frame->unwind = NULL;
1838 }
1839
1840 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
1841    Return a cleanup which should be called if unwinding fails, and
1842    discarded if it succeeds.  */
1843
1844 struct cleanup *
1845 frame_prepare_for_sniffer (struct frame_info *frame,
1846                            const struct frame_unwind *unwind)
1847 {
1848   gdb_assert (frame->unwind == NULL);
1849   frame->unwind = unwind;
1850   return make_cleanup (frame_cleanup_after_sniffer, frame);
1851 }
1852
1853 extern initialize_file_ftype _initialize_frame; /* -Wmissing-prototypes */
1854
1855 static struct cmd_list_element *set_backtrace_cmdlist;
1856 static struct cmd_list_element *show_backtrace_cmdlist;
1857
1858 static void
1859 set_backtrace_cmd (char *args, int from_tty)
1860 {
1861   help_list (set_backtrace_cmdlist, "set backtrace ", -1, gdb_stdout);
1862 }
1863
1864 static void
1865 show_backtrace_cmd (char *args, int from_tty)
1866 {
1867   cmd_show_list (show_backtrace_cmdlist, from_tty, "");
1868 }
1869
1870 void
1871 _initialize_frame (void)
1872 {
1873   obstack_init (&frame_cache_obstack);
1874
1875   observer_attach_target_changed (frame_observer_target_changed);
1876
1877   add_prefix_cmd ("backtrace", class_maintenance, set_backtrace_cmd, _("\
1878 Set backtrace specific variables.\n\
1879 Configure backtrace variables such as the backtrace limit"),
1880                   &set_backtrace_cmdlist, "set backtrace ",
1881                   0/*allow-unknown*/, &setlist);
1882   add_prefix_cmd ("backtrace", class_maintenance, show_backtrace_cmd, _("\
1883 Show backtrace specific variables\n\
1884 Show backtrace variables such as the backtrace limit"),
1885                   &show_backtrace_cmdlist, "show backtrace ",
1886                   0/*allow-unknown*/, &showlist);
1887
1888   add_setshow_boolean_cmd ("past-main", class_obscure,
1889                            &backtrace_past_main, _("\
1890 Set whether backtraces should continue past \"main\"."), _("\
1891 Show whether backtraces should continue past \"main\"."), _("\
1892 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1893 the backtrace at \"main\".  Set this variable if you need to see the rest\n\
1894 of the stack trace."),
1895                            NULL,
1896                            show_backtrace_past_main,
1897                            &set_backtrace_cmdlist,
1898                            &show_backtrace_cmdlist);
1899
1900   add_setshow_boolean_cmd ("past-entry", class_obscure,
1901                            &backtrace_past_entry, _("\
1902 Set whether backtraces should continue past the entry point of a program."),
1903                            _("\
1904 Show whether backtraces should continue past the entry point of a program."),
1905                            _("\
1906 Normally there are no callers beyond the entry point of a program, so GDB\n\
1907 will terminate the backtrace there.  Set this variable if you need to see \n\
1908 the rest of the stack trace."),
1909                            NULL,
1910                            show_backtrace_past_entry,
1911                            &set_backtrace_cmdlist,
1912                            &show_backtrace_cmdlist);
1913
1914   add_setshow_integer_cmd ("limit", class_obscure,
1915                            &backtrace_limit, _("\
1916 Set an upper bound on the number of backtrace levels."), _("\
1917 Show the upper bound on the number of backtrace levels."), _("\
1918 No more than the specified number of frames can be displayed or examined.\n\
1919 Zero is unlimited."),
1920                            NULL,
1921                            show_backtrace_limit,
1922                            &set_backtrace_cmdlist,
1923                            &show_backtrace_cmdlist);
1924
1925   /* Debug this files internals. */
1926   add_setshow_zinteger_cmd ("frame", class_maintenance, &frame_debug,  _("\
1927 Set frame debugging."), _("\
1928 Show frame debugging."), _("\
1929 When non-zero, frame specific internal debugging is enabled."),
1930                             NULL,
1931                             show_frame_debug,
1932                             &setdebuglist, &showdebuglist);
1933 }