gdb/frame.c

   1 /* Cache and manage frames for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "target.h"
  23 #include "value.h"
  24 #include "inferior.h"   /* for inferior_ptid */
  25 #include "regcache.h"
  26 #include <string.h>
  27 #include "user-regs.h"
  28 #include "gdb_obstack.h"
  29 #include "dummy-frame.h"
  30 #include "sentinel-frame.h"
  31 #include "gdbcore.h"
  32 #include "annotate.h"
  33 #include "language.h"
  34 #include "frame-unwind.h"
  35 #include "frame-base.h"
  36 #include "command.h"
  37 #include "gdbcmd.h"
  38 #include "observer.h"
  39 #include "objfiles.h"
  40 #include "exceptions.h"
  41 #include "gdbthread.h"
  42 #include "block.h"
  43 #include "inline-frame.h"
  44 #include "tracepoint.h"
  45 #include "hashtab.h"
  46 #include "valprint.h"
  47
  48 static struct frame_info *get_prev_frame_raw (struct frame_info *this_frame);
  49 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason);
  50
  51 /* Status of some values cached in the frame_info object.  */
  52
  53 enum cached_copy_status
  54 {
  55   /* Value is unknown.  */
  56   CC_UNKNOWN,
  57
  58   /* We have a value.  */
  59   CC_VALUE,
  60
  61   /* Value was not saved.  */
  62   CC_NOT_SAVED,
  63
  64   /* Value is unavailable.  */
  65   CC_UNAVAILABLE
  66 };
  67
  68 /* We keep a cache of stack frames, each of which is a "struct
  69    frame_info".  The innermost one gets allocated (in
  70    wait_for_inferior) each time the inferior stops; current_frame
  71    points to it.  Additional frames get allocated (in get_prev_frame)
  72    as needed, and are chained through the next and prev fields.  Any
  73    time that the frame cache becomes invalid (most notably when we
  74    execute something, but also if we change how we interpret the
  75    frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
  76    which reads new symbols)), we should call reinit_frame_cache.  */
  77
  78 struct frame_info
  79 {
  80   /* Level of this frame.  The inner-most (youngest) frame is at level
  81      0.  As you move towards the outer-most (oldest) frame, the level
  82      increases.  This is a cached value.  It could just as easily be
  83      computed by counting back from the selected frame to the inner
  84      most frame.  */
  85   /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
  86      reserved to indicate a bogus frame - one that has been created
  87      just to keep GDB happy (GDB always needs a frame).  For the
  88      moment leave this as speculation.  */
  89   int level;
  90
  91   /* The frame's program space.  */
  92   struct program_space *pspace;
  93
  94   /* The frame's address space.  */
  95   struct address_space *aspace;
  96
  97   /* The frame's low-level unwinder and corresponding cache.  The
  98      low-level unwinder is responsible for unwinding register values
  99      for the previous frame.  The low-level unwind methods are
 100      selected based on the presence, or otherwise, of register unwind
 101      information such as CFI.  */
 102   void *prologue_cache;
 103   const struct frame_unwind *unwind;
 104
 105   /* Cached copy of the previous frame's architecture.  */
 106   struct
 107   {
 108     int p;
 109     struct gdbarch *arch;
 110   } prev_arch;
 111
 112   /* Cached copy of the previous frame's resume address.  */
 113   struct {
 114     enum cached_copy_status status;
 115     CORE_ADDR value;
 116   } prev_pc;
 117
 118   /* Cached copy of the previous frame's function address.  */
 119   struct
 120   {
 121     CORE_ADDR addr;
 122     int p;
 123   } prev_func;
 124
 125   /* This frame's ID.  */
 126   struct
 127   {
 128     int p;
 129     struct frame_id value;
 130   } this_id;
 131
 132   /* The frame's high-level base methods, and corresponding cache.
 133      The high level base methods are selected based on the frame's
 134      debug info.  */
 135   const struct frame_base *base;
 136   void *base_cache;
 137
 138   /* Pointers to the next (down, inner, younger) and previous (up,
 139      outer, older) frame_info's in the frame cache.  */
 140   struct frame_info *next; /* down, inner, younger */
 141   int prev_p;
 142   struct frame_info *prev; /* up, outer, older */
 143
 144   /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
 145      could.  Only valid when PREV_P is set.  */
 146   enum unwind_stop_reason stop_reason;
 147
 148   /* A frame specific string describing the STOP_REASON in more detail.
 149      Only valid when PREV_P is set, but even then may still be NULL.  */
 150   const char *stop_string;
 151 };
 152
 153 /* A frame stash used to speed up frame lookups.  Create a hash table
 154    to stash frames previously accessed from the frame cache for
 155    quicker subsequent retrieval.  The hash table is emptied whenever
 156    the frame cache is invalidated.  */
 157
 158 static htab_t frame_stash;
 159
 160 /* Internal function to calculate a hash from the frame_id addresses,
 161    using as many valid addresses as possible.  Frames below level 0
 162    are not stored in the hash table.  */
 163
 164 static hashval_t
 165 frame_addr_hash (const void *ap)
 166 {
 167   const struct frame_info *frame = ap;
 168   const struct frame_id f_id = frame->this_id.value;
 169   hashval_t hash = 0;
 170
 171   gdb_assert (f_id.stack_status != FID_STACK_INVALID
 172               || f_id.code_addr_p
 173               || f_id.special_addr_p);
 174
 175   if (f_id.stack_status == FID_STACK_VALID)
 176     hash = iterative_hash (&f_id.stack_addr,
 177                            sizeof (f_id.stack_addr), hash);
 178   if (f_id.code_addr_p)
 179     hash = iterative_hash (&f_id.code_addr,
 180                            sizeof (f_id.code_addr), hash);
 181   if (f_id.special_addr_p)
 182     hash = iterative_hash (&f_id.special_addr,
 183                            sizeof (f_id.special_addr), hash);
 184
 185   return hash;
 186 }
 187
 188 /* Internal equality function for the hash table.  This function
 189    defers equality operations to frame_id_eq.  */
 190
 191 static int
 192 frame_addr_hash_eq (const void *a, const void *b)
 193 {
 194   const struct frame_info *f_entry = a;
 195   const struct frame_info *f_element = b;
 196
 197   return frame_id_eq (f_entry->this_id.value,
 198                       f_element->this_id.value);
 199 }
 200
 201 /* Internal function to create the frame_stash hash table.  100 seems
 202    to be a good compromise to start the hash table at.  */
 203
 204 static void
 205 frame_stash_create (void)
 206 {
 207   frame_stash = htab_create (100,
 208                              frame_addr_hash,
 209                              frame_addr_hash_eq,
 210                              NULL);
 211 }
 212
 213 /* Internal function to add a frame to the frame_stash hash table.
 214    Returns false if a frame with the same ID was already stashed, true
 215    otherwise.  */
 216
 217 static int
 218 frame_stash_add (struct frame_info *frame)
 219 {
 220   struct frame_info **slot;
 221
 222   /* Do not try to stash the sentinel frame.  */
 223   gdb_assert (frame->level >= 0);
 224
 225   slot = (struct frame_info **) htab_find_slot (frame_stash,
 226                                                 frame,
 227                                                 INSERT);
 228
 229   /* If we already have a frame in the stack with the same id, we
 230      either have a stack cycle (corrupted stack?), or some bug
 231      elsewhere in GDB.  In any case, ignore the duplicate and return
 232      an indication to the caller.  */
 233   if (*slot != NULL)
 234     return 0;
 235
 236   *slot = frame;
 237   return 1;
 238 }
 239
 240 /* Internal function to search the frame stash for an entry with the
 241    given frame ID.  If found, return that frame.  Otherwise return
 242    NULL.  */
 243
 244 static struct frame_info *
 245 frame_stash_find (struct frame_id id)
 246 {
 247   struct frame_info dummy;
 248   struct frame_info *frame;
 249
 250   dummy.this_id.value = id;
 251   frame = htab_find (frame_stash, &dummy);
 252   return frame;
 253 }
 254
 255 /* Internal function to invalidate the frame stash by removing all
 256    entries in it.  This only occurs when the frame cache is
 257    invalidated.  */
 258
 259 static void
 260 frame_stash_invalidate (void)
 261 {
 262   htab_empty (frame_stash);
 263 }
 264
 265 /* Flag to control debugging.  */
 266
 267 unsigned int frame_debug;
 268 static void
 269 show_frame_debug (struct ui_file *file, int from_tty,
 270                   struct cmd_list_element *c, const char *value)
 271 {
 272   fprintf_filtered (file, _("Frame debugging is %s.\n"), value);
 273 }
 274
 275 /* Flag to indicate whether backtraces should stop at main et.al.  */
 276
 277 static int backtrace_past_main;
 278 static void
 279 show_backtrace_past_main (struct ui_file *file, int from_tty,
 280                           struct cmd_list_element *c, const char *value)
 281 {
 282   fprintf_filtered (file,
 283                     _("Whether backtraces should "
 284                       "continue past \"main\" is %s.\n"),
 285                     value);
 286 }
 287
 288 static int backtrace_past_entry;
 289 static void
 290 show_backtrace_past_entry (struct ui_file *file, int from_tty,
 291                            struct cmd_list_element *c, const char *value)
 292 {
 293   fprintf_filtered (file, _("Whether backtraces should continue past the "
 294                             "entry point of a program is %s.\n"),
 295                     value);
 296 }
 297
 298 static unsigned int backtrace_limit = UINT_MAX;
 299 static void
 300 show_backtrace_limit (struct ui_file *file, int from_tty,
 301                       struct cmd_list_element *c, const char *value)
 302 {
 303   fprintf_filtered (file,
 304                     _("An upper bound on the number "
 305                       "of backtrace levels is %s.\n"),
 306                     value);
 307 }
 308
 309
 310 static void
 311 fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr)
 312 {
 313   if (p)
 314     fprintf_unfiltered (file, "%s=%s", name, hex_string (addr));
 315   else
 316     fprintf_unfiltered (file, "!%s", name);
 317 }
 318
 319 void
 320 fprint_frame_id (struct ui_file *file, struct frame_id id)
 321 {
 322   fprintf_unfiltered (file, "{");
 323
 324   if (id.stack_status == FID_STACK_INVALID)
 325     fprintf_unfiltered (file, "!stack");
 326   else if (id.stack_status == FID_STACK_UNAVAILABLE)
 327     fprintf_unfiltered (file, "stack=<unavailable>");
 328   else
 329     fprintf_unfiltered (file, "stack=%s", hex_string (id.stack_addr));
 330   fprintf_unfiltered (file, ",");
 331
 332   fprint_field (file, "code", id.code_addr_p, id.code_addr);
 333   fprintf_unfiltered (file, ",");
 334
 335   fprint_field (file, "special", id.special_addr_p, id.special_addr);
 336
 337   if (id.artificial_depth)
 338     fprintf_unfiltered (file, ",artificial=%d", id.artificial_depth);
 339
 340   fprintf_unfiltered (file, "}");
 341 }
 342
 343 static void
 344 fprint_frame_type (struct ui_file *file, enum frame_type type)
 345 {
 346   switch (type)
 347     {
 348     case NORMAL_FRAME:
 349       fprintf_unfiltered (file, "NORMAL_FRAME");
 350       return;
 351     case DUMMY_FRAME:
 352       fprintf_unfiltered (file, "DUMMY_FRAME");
 353       return;
 354     case INLINE_FRAME:
 355       fprintf_unfiltered (file, "INLINE_FRAME");
 356       return;
 357     case TAILCALL_FRAME:
 358       fprintf_unfiltered (file, "TAILCALL_FRAME");
 359       return;
 360     case SIGTRAMP_FRAME:
 361       fprintf_unfiltered (file, "SIGTRAMP_FRAME");
 362       return;
 363     case ARCH_FRAME:
 364       fprintf_unfiltered (file, "ARCH_FRAME");
 365       return;
 366     case SENTINEL_FRAME:
 367       fprintf_unfiltered (file, "SENTINEL_FRAME");
 368       return;
 369     default:
 370       fprintf_unfiltered (file, "<unknown type>");
 371       return;
 372     };
 373 }
 374
 375 static void
 376 fprint_frame (struct ui_file *file, struct frame_info *fi)
 377 {
 378   if (fi == NULL)
 379     {
 380       fprintf_unfiltered (file, "<NULL frame>");
 381       return;
 382     }
 383   fprintf_unfiltered (file, "{");
 384   fprintf_unfiltered (file, "level=%d", fi->level);
 385   fprintf_unfiltered (file, ",");
 386   fprintf_unfiltered (file, "type=");
 387   if (fi->unwind != NULL)
 388     fprint_frame_type (file, fi->unwind->type);
 389   else
 390     fprintf_unfiltered (file, "<unknown>");
 391   fprintf_unfiltered (file, ",");
 392   fprintf_unfiltered (file, "unwind=");
 393   if (fi->unwind != NULL)
 394     gdb_print_host_address (fi->unwind, file);
 395   else
 396     fprintf_unfiltered (file, "<unknown>");
 397   fprintf_unfiltered (file, ",");
 398   fprintf_unfiltered (file, "pc=");
 399   if (fi->next == NULL || fi->next->prev_pc.status == CC_UNKNOWN)
 400     fprintf_unfiltered (file, "<unknown>");
 401   else if (fi->next->prev_pc.status == CC_VALUE)
 402     fprintf_unfiltered (file, "%s",
 403                         hex_string (fi->next->prev_pc.value));
 404   else if (fi->next->prev_pc.status == CC_NOT_SAVED)
 405     val_print_not_saved (file);
 406   else if (fi->next->prev_pc.status == CC_UNAVAILABLE)
 407     val_print_unavailable (file);
 408   fprintf_unfiltered (file, ",");
 409   fprintf_unfiltered (file, "id=");
 410   if (fi->this_id.p)
 411     fprint_frame_id (file, fi->this_id.value);
 412   else
 413     fprintf_unfiltered (file, "<unknown>");
 414   fprintf_unfiltered (file, ",");
 415   fprintf_unfiltered (file, "func=");
 416   if (fi->next != NULL && fi->next->prev_func.p)
 417     fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_func.addr));
 418   else
 419     fprintf_unfiltered (file, "<unknown>");
 420   fprintf_unfiltered (file, "}");
 421 }
 422
 423 /* Given FRAME, return the enclosing frame as found in real frames read-in from
 424    inferior memory.  Skip any previous frames which were made up by GDB.
 425    Return the original frame if no immediate previous frames exist.  */
 426
 427 static struct frame_info *
 428 skip_artificial_frames (struct frame_info *frame)
 429 {
 430   /* Note we use get_prev_frame_always, and not get_prev_frame.  The
 431      latter will truncate the frame chain, leading to this function
 432      unintentionally returning a null_frame_id (e.g., when the user
 433      sets a backtrace limit).  This is safe, because as these frames
 434      are made up by GDB, there must be a real frame in the chain
 435      below.  */
 436   while (get_frame_type (frame) == INLINE_FRAME
 437          || get_frame_type (frame) == TAILCALL_FRAME)
 438     frame = get_prev_frame_always (frame);
 439
 440   return frame;
 441 }
 442
 443 /* Compute the frame's uniq ID that can be used to, later, re-find the
 444    frame.  */
 445
 446 static void
 447 compute_frame_id (struct frame_info *fi)
 448 {
 449   gdb_assert (!fi->this_id.p);
 450
 451   if (frame_debug)
 452     fprintf_unfiltered (gdb_stdlog, "{ compute_frame_id (fi=%d) ",
 453                         fi->level);
 454   /* Find the unwinder.  */
 455   if (fi->unwind == NULL)
 456     frame_unwind_find_by_frame (fi, &fi->prologue_cache);
 457   /* Find THIS frame's ID.  */
 458   /* Default to outermost if no ID is found.  */
 459   fi->this_id.value = outer_frame_id;
 460   fi->unwind->this_id (fi, &fi->prologue_cache, &fi->this_id.value);
 461   gdb_assert (frame_id_p (fi->this_id.value));
 462   fi->this_id.p = 1;
 463   if (frame_debug)
 464     {
 465       fprintf_unfiltered (gdb_stdlog, "-> ");
 466       fprint_frame_id (gdb_stdlog, fi->this_id.value);
 467       fprintf_unfiltered (gdb_stdlog, " }\n");
 468     }
 469 }
 470
 471 /* Return a frame uniq ID that can be used to, later, re-find the
 472    frame.  */
 473
 474 struct frame_id
 475 get_frame_id (struct frame_info *fi)
 476 {
 477   if (fi == NULL)
 478     return null_frame_id;
 479
 480   gdb_assert (fi->this_id.p);
 481   return fi->this_id.value;
 482 }
 483
 484 struct frame_id
 485 get_stack_frame_id (struct frame_info *next_frame)
 486 {
 487   return get_frame_id (skip_artificial_frames (next_frame));
 488 }
 489
 490 struct frame_id
 491 frame_unwind_caller_id (struct frame_info *next_frame)
 492 {
 493   struct frame_info *this_frame;
 494
 495   /* Use get_prev_frame_always, and not get_prev_frame.  The latter
 496      will truncate the frame chain, leading to this function
 497      unintentionally returning a null_frame_id (e.g., when a caller
 498      requests the frame ID of "main()"s caller.  */
 499
 500   next_frame = skip_artificial_frames (next_frame);
 501   this_frame = get_prev_frame_always (next_frame);
 502   if (this_frame)
 503     return get_frame_id (skip_artificial_frames (this_frame));
 504   else
 505     return null_frame_id;
 506 }
 507
 508 const struct frame_id null_frame_id; /* All zeros.  */
 509 const struct frame_id outer_frame_id = { 0, 0, 0, FID_STACK_INVALID, 0, 1, 0 };
 510
 511 struct frame_id
 512 frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr,
 513                         CORE_ADDR special_addr)
 514 {
 515   struct frame_id id = null_frame_id;
 516
 517   id.stack_addr = stack_addr;
 518   id.stack_status = FID_STACK_VALID;
 519   id.code_addr = code_addr;
 520   id.code_addr_p = 1;
 521   id.special_addr = special_addr;
 522   id.special_addr_p = 1;
 523   return id;
 524 }
 525
 526 /* See frame.h.  */
 527
 528 struct frame_id
 529 frame_id_build_unavailable_stack (CORE_ADDR code_addr)
 530 {
 531   struct frame_id id = null_frame_id;
 532
 533   id.stack_status = FID_STACK_UNAVAILABLE;
 534   id.code_addr = code_addr;
 535   id.code_addr_p = 1;
 536   return id;
 537 }
 538
 539 /* See frame.h.  */
 540
 541 struct frame_id
 542 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr,
 543                                           CORE_ADDR special_addr)
 544 {
 545   struct frame_id id = null_frame_id;
 546
 547   id.stack_status = FID_STACK_UNAVAILABLE;
 548   id.code_addr = code_addr;
 549   id.code_addr_p = 1;
 550   id.special_addr = special_addr;
 551   id.special_addr_p = 1;
 552   return id;
 553 }
 554
 555 struct frame_id
 556 frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr)
 557 {
 558   struct frame_id id = null_frame_id;
 559
 560   id.stack_addr = stack_addr;
 561   id.stack_status = FID_STACK_VALID;
 562   id.code_addr = code_addr;
 563   id.code_addr_p = 1;
 564   return id;
 565 }
 566
 567 struct frame_id
 568 frame_id_build_wild (CORE_ADDR stack_addr)
 569 {
 570   struct frame_id id = null_frame_id;
 571
 572   id.stack_addr = stack_addr;
 573   id.stack_status = FID_STACK_VALID;
 574   return id;
 575 }
 576
 577 int
 578 frame_id_p (struct frame_id l)
 579 {
 580   int p;
 581
 582   /* The frame is valid iff it has a valid stack address.  */
 583   p = l.stack_status != FID_STACK_INVALID;
 584   /* outer_frame_id is also valid.  */
 585   if (!p && memcmp (&l, &outer_frame_id, sizeof (l)) == 0)
 586     p = 1;
 587   if (frame_debug)
 588     {
 589       fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l=");
 590       fprint_frame_id (gdb_stdlog, l);
 591       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p);
 592     }
 593   return p;
 594 }
 595
 596 int
 597 frame_id_artificial_p (struct frame_id l)
 598 {
 599   if (!frame_id_p (l))
 600     return 0;
 601
 602   return (l.artificial_depth != 0);
 603 }
 604
 605 int
 606 frame_id_eq (struct frame_id l, struct frame_id r)
 607 {
 608   int eq;
 609
 610   if (l.stack_status == FID_STACK_INVALID && l.special_addr_p
 611       && r.stack_status == FID_STACK_INVALID && r.special_addr_p)
 612     /* The outermost frame marker is equal to itself.  This is the
 613        dodgy thing about outer_frame_id, since between execution steps
 614        we might step into another function - from which we can't
 615        unwind either.  More thought required to get rid of
 616        outer_frame_id.  */
 617     eq = 1;
 618   else if (l.stack_status == FID_STACK_INVALID
 619            || l.stack_status == FID_STACK_INVALID)
 620     /* Like a NaN, if either ID is invalid, the result is false.
 621        Note that a frame ID is invalid iff it is the null frame ID.  */
 622     eq = 0;
 623   else if (l.stack_status != r.stack_status || l.stack_addr != r.stack_addr)
 624     /* If .stack addresses are different, the frames are different.  */
 625     eq = 0;
 626   else if (l.code_addr_p && r.code_addr_p && l.code_addr != r.code_addr)
 627     /* An invalid code addr is a wild card.  If .code addresses are
 628        different, the frames are different.  */
 629     eq = 0;
 630   else if (l.special_addr_p && r.special_addr_p
 631            && l.special_addr != r.special_addr)
 632     /* An invalid special addr is a wild card (or unused).  Otherwise
 633        if special addresses are different, the frames are different.  */
 634     eq = 0;
 635   else if (l.artificial_depth != r.artificial_depth)
 636     /* If artifical depths are different, the frames must be different.  */
 637     eq = 0;
 638   else
 639     /* Frames are equal.  */
 640     eq = 1;
 641
 642   if (frame_debug)
 643     {
 644       fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
 645       fprint_frame_id (gdb_stdlog, l);
 646       fprintf_unfiltered (gdb_stdlog, ",r=");
 647       fprint_frame_id (gdb_stdlog, r);
 648       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq);
 649     }
 650   return eq;
 651 }
 652
 653 /* Safety net to check whether frame ID L should be inner to
 654    frame ID R, according to their stack addresses.
 655
 656    This method cannot be used to compare arbitrary frames, as the
 657    ranges of valid stack addresses may be discontiguous (e.g. due
 658    to sigaltstack).
 659
 660    However, it can be used as safety net to discover invalid frame
 661    IDs in certain circumstances.  Assuming that NEXT is the immediate
 662    inner frame to THIS and that NEXT and THIS are both NORMAL frames:
 663
 664    * The stack address of NEXT must be inner-than-or-equal to the stack
 665      address of THIS.
 666
 667      Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
 668      error has occurred.
 669
 670    * If NEXT and THIS have different stack addresses, no other frame
 671      in the frame chain may have a stack address in between.
 672
 673      Therefore, if frame_id_inner (TEST, THIS) holds, but
 674      frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
 675      to a valid frame in the frame chain.
 676
 677    The sanity checks above cannot be performed when a SIGTRAMP frame
 678    is involved, because signal handlers might be executed on a different
 679    stack than the stack used by the routine that caused the signal
 680    to be raised.  This can happen for instance when a thread exceeds
 681    its maximum stack size.  In this case, certain compilers implement
 682    a stack overflow strategy that cause the handler to be run on a
 683    different stack.  */
 684
 685 static int
 686 frame_id_inner (struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
 687 {
 688   int inner;
 689
 690   if (l.stack_status != FID_STACK_VALID || r.stack_status != FID_STACK_VALID)
 691     /* Like NaN, any operation involving an invalid ID always fails.
 692        Likewise if either ID has an unavailable stack address.  */
 693     inner = 0;
 694   else if (l.artificial_depth > r.artificial_depth
 695            && l.stack_addr == r.stack_addr
 696            && l.code_addr_p == r.code_addr_p
 697            && l.special_addr_p == r.special_addr_p
 698            && l.special_addr == r.special_addr)
 699     {
 700       /* Same function, different inlined functions.  */
 701       const struct block *lb, *rb;
 702
 703       gdb_assert (l.code_addr_p && r.code_addr_p);
 704
 705       lb = block_for_pc (l.code_addr);
 706       rb = block_for_pc (r.code_addr);
 707
 708       if (lb == NULL || rb == NULL)
 709         /* Something's gone wrong.  */
 710         inner = 0;
 711       else
 712         /* This will return true if LB and RB are the same block, or
 713            if the block with the smaller depth lexically encloses the
 714            block with the greater depth.  */
 715         inner = contained_in (lb, rb);
 716     }
 717   else
 718     /* Only return non-zero when strictly inner than.  Note that, per
 719        comment in "frame.h", there is some fuzz here.  Frameless
 720        functions are not strictly inner than (same .stack but
 721        different .code and/or .special address).  */
 722     inner = gdbarch_inner_than (gdbarch, l.stack_addr, r.stack_addr);
 723   if (frame_debug)
 724     {
 725       fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l=");
 726       fprint_frame_id (gdb_stdlog, l);
 727       fprintf_unfiltered (gdb_stdlog, ",r=");
 728       fprint_frame_id (gdb_stdlog, r);
 729       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner);
 730     }
 731   return inner;
 732 }
 733
 734 struct frame_info *
 735 frame_find_by_id (struct frame_id id)
 736 {
 737   struct frame_info *frame, *prev_frame;
 738
 739   /* ZERO denotes the null frame, let the caller decide what to do
 740      about it.  Should it instead return get_current_frame()?  */
 741   if (!frame_id_p (id))
 742     return NULL;
 743
 744   /* Try using the frame stash first.  Finding it there removes the need
 745      to perform the search by looping over all frames, which can be very
 746      CPU-intensive if the number of frames is very high (the loop is O(n)
 747      and get_prev_frame performs a series of checks that are relatively
 748      expensive).  This optimization is particularly useful when this function
 749      is called from another function (such as value_fetch_lazy, case
 750      VALUE_LVAL (val) == lval_register) which already loops over all frames,
 751      making the overall behavior O(n^2).  */
 752   frame = frame_stash_find (id);
 753   if (frame)
 754     return frame;
 755
 756   for (frame = get_current_frame (); ; frame = prev_frame)
 757     {
 758       struct frame_id this = get_frame_id (frame);
 759
 760       if (frame_id_eq (id, this))
 761         /* An exact match.  */
 762         return frame;
 763
 764       prev_frame = get_prev_frame (frame);
 765       if (!prev_frame)
 766         return NULL;
 767
 768       /* As a safety net to avoid unnecessary backtracing while trying
 769          to find an invalid ID, we check for a common situation where
 770          we can detect from comparing stack addresses that no other
 771          frame in the current frame chain can have this ID.  See the
 772          comment at frame_id_inner for details.   */
 773       if (get_frame_type (frame) == NORMAL_FRAME
 774           && !frame_id_inner (get_frame_arch (frame), id, this)
 775           && frame_id_inner (get_frame_arch (prev_frame), id,
 776                              get_frame_id (prev_frame)))
 777         return NULL;
 778     }
 779   return NULL;
 780 }
 781
 782 static CORE_ADDR
 783 frame_unwind_pc (struct frame_info *this_frame)
 784 {
 785   if (this_frame->prev_pc.status == CC_UNKNOWN)
 786     {
 787       if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame)))
 788         {
 789           volatile struct gdb_exception ex;
 790           struct gdbarch *prev_gdbarch;
 791           CORE_ADDR pc = 0;
 792
 793           /* The right way.  The `pure' way.  The one true way.  This
 794              method depends solely on the register-unwind code to
 795              determine the value of registers in THIS frame, and hence
 796              the value of this frame's PC (resume address).  A typical
 797              implementation is no more than:
 798
 799              frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
 800              return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
 801
 802              Note: this method is very heavily dependent on a correct
 803              register-unwind implementation, it pays to fix that
 804              method first; this method is frame type agnostic, since
 805              it only deals with register values, it works with any
 806              frame.  This is all in stark contrast to the old
 807              FRAME_SAVED_PC which would try to directly handle all the
 808              different ways that a PC could be unwound.  */
 809           prev_gdbarch = frame_unwind_arch (this_frame);
 810
 811           TRY_CATCH (ex, RETURN_MASK_ERROR)
 812             {
 813               pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
 814             }
 815           if (ex.reason < 0)
 816             {
 817               if (ex.error == NOT_AVAILABLE_ERROR)
 818                 {
 819                   this_frame->prev_pc.status = CC_UNAVAILABLE;
 820
 821                   if (frame_debug)
 822                     fprintf_unfiltered (gdb_stdlog,
 823                                         "{ frame_unwind_pc (this_frame=%d)"
 824                                         " -> <unavailable> }\n",
 825                                         this_frame->level);
 826                 }
 827               else if (ex.error == OPTIMIZED_OUT_ERROR)
 828                 {
 829                   this_frame->prev_pc.status = CC_NOT_SAVED;
 830
 831                   if (frame_debug)
 832                     fprintf_unfiltered (gdb_stdlog,
 833                                         "{ frame_unwind_pc (this_frame=%d)"
 834                                         " -> <not saved> }\n",
 835                                         this_frame->level);
 836                 }
 837               else
 838                 throw_exception (ex);
 839             }
 840           else
 841             {
 842               this_frame->prev_pc.value = pc;
 843               this_frame->prev_pc.status = CC_VALUE;
 844               if (frame_debug)
 845                 fprintf_unfiltered (gdb_stdlog,
 846                                     "{ frame_unwind_pc (this_frame=%d) "
 847                                     "-> %s }\n",
 848                                     this_frame->level,
 849                                     hex_string (this_frame->prev_pc.value));
 850             }
 851         }
 852       else
 853         internal_error (__FILE__, __LINE__, _("No unwind_pc method"));
 854     }
 855
 856   if (this_frame->prev_pc.status == CC_VALUE)
 857     return this_frame->prev_pc.value;
 858   else if (this_frame->prev_pc.status == CC_UNAVAILABLE)
 859     throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));
 860   else if (this_frame->prev_pc.status == CC_NOT_SAVED)
 861     throw_error (OPTIMIZED_OUT_ERROR, _("PC not saved"));
 862   else
 863     internal_error (__FILE__, __LINE__,
 864                     "unexpected prev_pc status: %d",
 865                     (int) this_frame->prev_pc.status);
 866 }
 867
 868 CORE_ADDR
 869 frame_unwind_caller_pc (struct frame_info *this_frame)
 870 {
 871   return frame_unwind_pc (skip_artificial_frames (this_frame));
 872 }
 873
 874 int
 875 get_frame_func_if_available (struct frame_info *this_frame, CORE_ADDR *pc)
 876 {
 877   struct frame_info *next_frame = this_frame->next;
 878
 879   if (!next_frame->prev_func.p)
 880     {
 881       CORE_ADDR addr_in_block;
 882
 883       /* Make certain that this, and not the adjacent, function is
 884          found.  */
 885       if (!get_frame_address_in_block_if_available (this_frame, &addr_in_block))
 886         {
 887           next_frame->prev_func.p = -1;
 888           if (frame_debug)
 889             fprintf_unfiltered (gdb_stdlog,
 890                                 "{ get_frame_func (this_frame=%d)"
 891                                 " -> unavailable }\n",
 892                                 this_frame->level);
 893         }
 894       else
 895         {
 896           next_frame->prev_func.p = 1;
 897           next_frame->prev_func.addr = get_pc_function_start (addr_in_block);
 898           if (frame_debug)
 899             fprintf_unfiltered (gdb_stdlog,
 900                                 "{ get_frame_func (this_frame=%d) -> %s }\n",
 901                                 this_frame->level,
 902                                 hex_string (next_frame->prev_func.addr));
 903         }
 904     }
 905
 906   if (next_frame->prev_func.p < 0)
 907     {
 908       *pc = -1;
 909       return 0;
 910     }
 911   else
 912     {
 913       *pc = next_frame->prev_func.addr;
 914       return 1;
 915     }
 916 }
 917
 918 CORE_ADDR
 919 get_frame_func (struct frame_info *this_frame)
 920 {
 921   CORE_ADDR pc;
 922
 923   if (!get_frame_func_if_available (this_frame, &pc))
 924     throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));
 925
 926   return pc;
 927 }
 928
 929 static enum register_status
 930 do_frame_register_read (void *src, int regnum, gdb_byte *buf)
 931 {
 932   if (!deprecated_frame_register_read (src, regnum, buf))
 933     return REG_UNAVAILABLE;
 934   else
 935     return REG_VALID;
 936 }
 937
 938 struct regcache *
 939 frame_save_as_regcache (struct frame_info *this_frame)
 940 {
 941   struct address_space *aspace = get_frame_address_space (this_frame);
 942   struct regcache *regcache = regcache_xmalloc (get_frame_arch (this_frame),
 943                                                 aspace);
 944   struct cleanup *cleanups = make_cleanup_regcache_xfree (regcache);
 945
 946   regcache_save (regcache, do_frame_register_read, this_frame);
 947   discard_cleanups (cleanups);
 948   return regcache;
 949 }
 950
 951 void
 952 frame_pop (struct frame_info *this_frame)
 953 {
 954   struct frame_info *prev_frame;
 955   struct regcache *scratch;
 956   struct cleanup *cleanups;
 957
 958   if (get_frame_type (this_frame) == DUMMY_FRAME)
 959     {
 960       /* Popping a dummy frame involves restoring more than just registers.
 961          dummy_frame_pop does all the work.  */
 962       dummy_frame_pop (get_frame_id (this_frame), inferior_ptid);
 963       return;
 964     }
 965
 966   /* Ensure that we have a frame to pop to.  */
 967   prev_frame = get_prev_frame_always (this_frame);
 968
 969   if (!prev_frame)
 970     error (_("Cannot pop the initial frame."));
 971
 972   /* Ignore TAILCALL_FRAME type frames, they were executed already before
 973      entering THISFRAME.  */
 974   while (get_frame_type (prev_frame) == TAILCALL_FRAME)
 975     prev_frame = get_prev_frame (prev_frame);
 976
 977   /* Make a copy of all the register values unwound from this frame.
 978      Save them in a scratch buffer so that there isn't a race between
 979      trying to extract the old values from the current regcache while
 980      at the same time writing new values into that same cache.  */
 981   scratch = frame_save_as_regcache (prev_frame);
 982   cleanups = make_cleanup_regcache_xfree (scratch);
 983
 984   /* FIXME: cagney/2003-03-16: It should be possible to tell the
 985      target's register cache that it is about to be hit with a burst
 986      register transfer and that the sequence of register writes should
 987      be batched.  The pair target_prepare_to_store() and
 988      target_store_registers() kind of suggest this functionality.
 989      Unfortunately, they don't implement it.  Their lack of a formal
 990      definition can lead to targets writing back bogus values
 991      (arguably a bug in the target code mind).  */
 992   /* Now copy those saved registers into the current regcache.
 993      Here, regcache_cpy() calls regcache_restore().  */
 994   regcache_cpy (get_current_regcache (), scratch);
 995   do_cleanups (cleanups);
 996
 997   /* We've made right mess of GDB's local state, just discard
 998      everything.  */
 999   reinit_frame_cache ();
1000 }
1001
1002 void
1003 frame_register_unwind (struct frame_info *frame, int regnum,
1004                        int *optimizedp, int *unavailablep,
1005                        enum lval_type *lvalp, CORE_ADDR *addrp,
1006                        int *realnump, gdb_byte *bufferp)
1007 {
1008   struct value *value;
1009
1010   /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
1011      that the value proper does not need to be fetched.  */
1012   gdb_assert (optimizedp != NULL);
1013   gdb_assert (lvalp != NULL);
1014   gdb_assert (addrp != NULL);
1015   gdb_assert (realnump != NULL);
1016   /* gdb_assert (bufferp != NULL); */
1017
1018   value = frame_unwind_register_value (frame, regnum);
1019
1020   gdb_assert (value != NULL);
1021
1022   *optimizedp = value_optimized_out (value);
1023   *unavailablep = !value_entirely_available (value);
1024   *lvalp = VALUE_LVAL (value);
1025   *addrp = value_address (value);
1026   *realnump = VALUE_REGNUM (value);
1027
1028   if (bufferp)
1029     {
1030       if (!*optimizedp && !*unavailablep)
1031         memcpy (bufferp, value_contents_all (value),
1032                 TYPE_LENGTH (value_type (value)));
1033       else
1034         memset (bufferp, 0, TYPE_LENGTH (value_type (value)));
1035     }
1036
1037   /* Dispose of the new value.  This prevents watchpoints from
1038      trying to watch the saved frame pointer.  */
1039   release_value (value);
1040   value_free (value);
1041 }
1042
1043 void
1044 frame_register (struct frame_info *frame, int regnum,
1045                 int *optimizedp, int *unavailablep, enum lval_type *lvalp,
1046                 CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
1047 {
1048   /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
1049      that the value proper does not need to be fetched.  */
1050   gdb_assert (optimizedp != NULL);
1051   gdb_assert (lvalp != NULL);
1052   gdb_assert (addrp != NULL);
1053   gdb_assert (realnump != NULL);
1054   /* gdb_assert (bufferp != NULL); */
1055
1056   /* Obtain the register value by unwinding the register from the next
1057      (more inner frame).  */
1058   gdb_assert (frame != NULL && frame->next != NULL);
1059   frame_register_unwind (frame->next, regnum, optimizedp, unavailablep,
1060                          lvalp, addrp, realnump, bufferp);
1061 }
1062
1063 void
1064 frame_unwind_register (struct frame_info *frame, int regnum, gdb_byte *buf)
1065 {
1066   int optimized;
1067   int unavailable;
1068   CORE_ADDR addr;
1069   int realnum;
1070   enum lval_type lval;
1071
1072   frame_register_unwind (frame, regnum, &optimized, &unavailable,
1073                          &lval, &addr, &realnum, buf);
1074
1075   if (optimized)
1076     throw_error (OPTIMIZED_OUT_ERROR,
1077                  _("Register %d was not saved"), regnum);
1078   if (unavailable)
1079     throw_error (NOT_AVAILABLE_ERROR,
1080                  _("Register %d is not available"), regnum);
1081 }
1082
1083 void
1084 get_frame_register (struct frame_info *frame,
1085                     int regnum, gdb_byte *buf)
1086 {
1087   frame_unwind_register (frame->next, regnum, buf);
1088 }
1089
1090 struct value *
1091 frame_unwind_register_value (struct frame_info *frame, int regnum)
1092 {
1093   struct gdbarch *gdbarch;
1094   struct value *value;
1095
1096   gdb_assert (frame != NULL);
1097   gdbarch = frame_unwind_arch (frame);
1098
1099   if (frame_debug)
1100     {
1101       fprintf_unfiltered (gdb_stdlog,
1102                           "{ frame_unwind_register_value "
1103                           "(frame=%d,regnum=%d(%s),...) ",
1104                           frame->level, regnum,
1105                           user_reg_map_regnum_to_name (gdbarch, regnum));
1106     }
1107
1108   /* Find the unwinder.  */
1109   if (frame->unwind == NULL)
1110     frame_unwind_find_by_frame (frame, &frame->prologue_cache);
1111
1112   /* Ask this frame to unwind its register.  */
1113   value = frame->unwind->prev_register (frame, &frame->prologue_cache, regnum);
1114
1115   if (frame_debug)
1116     {
1117       fprintf_unfiltered (gdb_stdlog, "->");
1118       if (value_optimized_out (value))
1119         {
1120           fprintf_unfiltered (gdb_stdlog, " ");
1121           val_print_optimized_out (value, gdb_stdlog);
1122         }
1123       else
1124         {
1125           if (VALUE_LVAL (value) == lval_register)
1126             fprintf_unfiltered (gdb_stdlog, " register=%d",
1127                                 VALUE_REGNUM (value));
1128           else if (VALUE_LVAL (value) == lval_memory)
1129             fprintf_unfiltered (gdb_stdlog, " address=%s",
1130                                 paddress (gdbarch,
1131                                           value_address (value)));
1132           else
1133             fprintf_unfiltered (gdb_stdlog, " computed");
1134
1135           if (value_lazy (value))
1136             fprintf_unfiltered (gdb_stdlog, " lazy");
1137           else
1138             {
1139               int i;
1140               const gdb_byte *buf = value_contents (value);
1141
1142               fprintf_unfiltered (gdb_stdlog, " bytes=");
1143               fprintf_unfiltered (gdb_stdlog, "[");
1144               for (i = 0; i < register_size (gdbarch, regnum); i++)
1145                 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1146               fprintf_unfiltered (gdb_stdlog, "]");
1147             }
1148         }
1149
1150       fprintf_unfiltered (gdb_stdlog, " }\n");
1151     }
1152
1153   return value;
1154 }
1155
1156 struct value *
1157 get_frame_register_value (struct frame_info *frame, int regnum)
1158 {
1159   return frame_unwind_register_value (frame->next, regnum);
1160 }
1161
1162 LONGEST
1163 frame_unwind_register_signed (struct frame_info *frame, int regnum)
1164 {
1165   struct gdbarch *gdbarch = frame_unwind_arch (frame);
1166   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1167   int size = register_size (gdbarch, regnum);
1168   gdb_byte buf[MAX_REGISTER_SIZE];
1169
1170   frame_unwind_register (frame, regnum, buf);
1171   return extract_signed_integer (buf, size, byte_order);
1172 }
1173
1174 LONGEST
1175 get_frame_register_signed (struct frame_info *frame, int regnum)
1176 {
1177   return frame_unwind_register_signed (frame->next, regnum);
1178 }
1179
1180 ULONGEST
1181 frame_unwind_register_unsigned (struct frame_info *frame, int regnum)
1182 {
1183   struct gdbarch *gdbarch = frame_unwind_arch (frame);
1184   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1185   int size = register_size (gdbarch, regnum);
1186   gdb_byte buf[MAX_REGISTER_SIZE];
1187
1188   frame_unwind_register (frame, regnum, buf);
1189   return extract_unsigned_integer (buf, size, byte_order);
1190 }
1191
1192 ULONGEST
1193 get_frame_register_unsigned (struct frame_info *frame, int regnum)
1194 {
1195   return frame_unwind_register_unsigned (frame->next, regnum);
1196 }
1197
1198 int
1199 read_frame_register_unsigned (struct frame_info *frame, int regnum,
1200                               ULONGEST *val)
1201 {
1202   struct value *regval = get_frame_register_value (frame, regnum);
1203
1204   if (!value_optimized_out (regval)
1205       && value_entirely_available (regval))
1206     {
1207       struct gdbarch *gdbarch = get_frame_arch (frame);
1208       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1209       int size = register_size (gdbarch, VALUE_REGNUM (regval));
1210
1211       *val = extract_unsigned_integer (value_contents (regval), size, byte_order);
1212       return 1;
1213     }
1214
1215   return 0;
1216 }
1217
1218 void
1219 put_frame_register (struct frame_info *frame, int regnum,
1220                     const gdb_byte *buf)
1221 {
1222   struct gdbarch *gdbarch = get_frame_arch (frame);
1223   int realnum;
1224   int optim;
1225   int unavail;
1226   enum lval_type lval;
1227   CORE_ADDR addr;
1228
1229   frame_register (frame, regnum, &optim, &unavail,
1230                   &lval, &addr, &realnum, NULL);
1231   if (optim)
1232     error (_("Attempt to assign to a register that was not saved."));
1233   switch (lval)
1234     {
1235     case lval_memory:
1236       {
1237         write_memory (addr, buf, register_size (gdbarch, regnum));
1238         break;
1239       }
1240     case lval_register:
1241       regcache_cooked_write (get_current_regcache (), realnum, buf);
1242       break;
1243     default:
1244       error (_("Attempt to assign to an unmodifiable value."));
1245     }
1246 }
1247
1248 /* This function is deprecated.  Use get_frame_register_value instead,
1249    which provides more accurate information.
1250
1251    Find and return the value of REGNUM for the specified stack frame.
1252    The number of bytes copied is REGISTER_SIZE (REGNUM).
1253
1254    Returns 0 if the register value could not be found.  */
1255
1256 int
1257 deprecated_frame_register_read (struct frame_info *frame, int regnum,
1258                      gdb_byte *myaddr)
1259 {
1260   int optimized;
1261   int unavailable;
1262   enum lval_type lval;
1263   CORE_ADDR addr;
1264   int realnum;
1265
1266   frame_register (frame, regnum, &optimized, &unavailable,
1267                   &lval, &addr, &realnum, myaddr);
1268
1269   return !optimized && !unavailable;
1270 }
1271
1272 int
1273 get_frame_register_bytes (struct frame_info *frame, int regnum,
1274                           CORE_ADDR offset, int len, gdb_byte *myaddr,
1275                           int *optimizedp, int *unavailablep)
1276 {
1277   struct gdbarch *gdbarch = get_frame_arch (frame);
1278   int i;
1279   int maxsize;
1280   int numregs;
1281
1282   /* Skip registers wholly inside of OFFSET.  */
1283   while (offset >= register_size (gdbarch, regnum))
1284     {
1285       offset -= register_size (gdbarch, regnum);
1286       regnum++;
1287     }
1288
1289   /* Ensure that we will not read beyond the end of the register file.
1290      This can only ever happen if the debug information is bad.  */
1291   maxsize = -offset;
1292   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1293   for (i = regnum; i < numregs; i++)
1294     {
1295       int thissize = register_size (gdbarch, i);
1296
1297       if (thissize == 0)
1298         break;  /* This register is not available on this architecture.  */
1299       maxsize += thissize;
1300     }
1301   if (len > maxsize)
1302     error (_("Bad debug information detected: "
1303              "Attempt to read %d bytes from registers."), len);
1304
1305   /* Copy the data.  */
1306   while (len > 0)
1307     {
1308       int curr_len = register_size (gdbarch, regnum) - offset;
1309
1310       if (curr_len > len)
1311         curr_len = len;
1312
1313       if (curr_len == register_size (gdbarch, regnum))
1314         {
1315           enum lval_type lval;
1316           CORE_ADDR addr;
1317           int realnum;
1318
1319           frame_register (frame, regnum, optimizedp, unavailablep,
1320                           &lval, &addr, &realnum, myaddr);
1321           if (*optimizedp || *unavailablep)
1322             return 0;
1323         }
1324       else
1325         {
1326           gdb_byte buf[MAX_REGISTER_SIZE];
1327           enum lval_type lval;
1328           CORE_ADDR addr;
1329           int realnum;
1330
1331           frame_register (frame, regnum, optimizedp, unavailablep,
1332                           &lval, &addr, &realnum, buf);
1333           if (*optimizedp || *unavailablep)
1334             return 0;
1335           memcpy (myaddr, buf + offset, curr_len);
1336         }
1337
1338       myaddr += curr_len;
1339       len -= curr_len;
1340       offset = 0;
1341       regnum++;
1342     }
1343
1344   *optimizedp = 0;
1345   *unavailablep = 0;
1346   return 1;
1347 }
1348
1349 void
1350 put_frame_register_bytes (struct frame_info *frame, int regnum,
1351                           CORE_ADDR offset, int len, const gdb_byte *myaddr)
1352 {
1353   struct gdbarch *gdbarch = get_frame_arch (frame);
1354
1355   /* Skip registers wholly inside of OFFSET.  */
1356   while (offset >= register_size (gdbarch, regnum))
1357     {
1358       offset -= register_size (gdbarch, regnum);
1359       regnum++;
1360     }
1361
1362   /* Copy the data.  */
1363   while (len > 0)
1364     {
1365       int curr_len = register_size (gdbarch, regnum) - offset;
1366
1367       if (curr_len > len)
1368         curr_len = len;
1369
1370       if (curr_len == register_size (gdbarch, regnum))
1371         {
1372           put_frame_register (frame, regnum, myaddr);
1373         }
1374       else
1375         {
1376           gdb_byte buf[MAX_REGISTER_SIZE];
1377
1378           deprecated_frame_register_read (frame, regnum, buf);
1379           memcpy (buf + offset, myaddr, curr_len);
1380           put_frame_register (frame, regnum, buf);
1381         }
1382
1383       myaddr += curr_len;
1384       len -= curr_len;
1385       offset = 0;
1386       regnum++;
1387     }
1388 }
1389
1390 /* Create a sentinel frame.  */
1391
1392 static struct frame_info *
1393 create_sentinel_frame (struct program_space *pspace, struct regcache *regcache)
1394 {
1395   struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
1396
1397   frame->level = -1;
1398   frame->pspace = pspace;
1399   frame->aspace = get_regcache_aspace (regcache);
1400   /* Explicitly initialize the sentinel frame's cache.  Provide it
1401      with the underlying regcache.  In the future additional
1402      information, such as the frame's thread will be added.  */
1403   frame->prologue_cache = sentinel_frame_cache (regcache);
1404   /* For the moment there is only one sentinel frame implementation.  */
1405   frame->unwind = &sentinel_frame_unwind;
1406   /* Link this frame back to itself.  The frame is self referential
1407      (the unwound PC is the same as the pc), so make it so.  */
1408   frame->next = frame;
1409   /* Make the sentinel frame's ID valid, but invalid.  That way all
1410      comparisons with it should fail.  */
1411   frame->this_id.p = 1;
1412   frame->this_id.value = null_frame_id;
1413   if (frame_debug)
1414     {
1415       fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> ");
1416       fprint_frame (gdb_stdlog, frame);
1417       fprintf_unfiltered (gdb_stdlog, " }\n");
1418     }
1419   return frame;
1420 }
1421
1422 /* Info about the innermost stack frame (contents of FP register).  */
1423
1424 static struct frame_info *current_frame;
1425
1426 /* Cache for frame addresses already read by gdb.  Valid only while
1427    inferior is stopped.  Control variables for the frame cache should
1428    be local to this module.  */
1429
1430 static struct obstack frame_cache_obstack;
1431
1432 void *
1433 frame_obstack_zalloc (unsigned long size)
1434 {
1435   void *data = obstack_alloc (&frame_cache_obstack, size);
1436
1437   memset (data, 0, size);
1438   return data;
1439 }
1440
1441 /* Return the innermost (currently executing) stack frame.  This is
1442    split into two functions.  The function unwind_to_current_frame()
1443    is wrapped in catch exceptions so that, even when the unwind of the
1444    sentinel frame fails, the function still returns a stack frame.  */
1445
1446 static int
1447 unwind_to_current_frame (struct ui_out *ui_out, void *args)
1448 {
1449   struct frame_info *frame = get_prev_frame (args);
1450
1451   /* A sentinel frame can fail to unwind, e.g., because its PC value
1452      lands in somewhere like start.  */
1453   if (frame == NULL)
1454     return 1;
1455   current_frame = frame;
1456   return 0;
1457 }
1458
1459 struct frame_info *
1460 get_current_frame (void)
1461 {
1462   /* First check, and report, the lack of registers.  Having GDB
1463      report "No stack!" or "No memory" when the target doesn't even
1464      have registers is very confusing.  Besides, "printcmd.exp"
1465      explicitly checks that ``print $pc'' with no registers prints "No
1466      registers".  */
1467   if (!target_has_registers)
1468     error (_("No registers."));
1469   if (!target_has_stack)
1470     error (_("No stack."));
1471   if (!target_has_memory)
1472     error (_("No memory."));
1473   /* Traceframes are effectively a substitute for the live inferior.  */
1474   if (get_traceframe_number () < 0)
1475     {
1476       if (ptid_equal (inferior_ptid, null_ptid))
1477         error (_("No selected thread."));
1478       if (is_exited (inferior_ptid))
1479         error (_("Invalid selected thread."));
1480       if (is_executing (inferior_ptid))
1481         error (_("Target is executing."));
1482     }
1483
1484   if (current_frame == NULL)
1485     {
1486       struct frame_info *sentinel_frame =
1487         create_sentinel_frame (current_program_space, get_current_regcache ());
1488       if (catch_exceptions (current_uiout, unwind_to_current_frame,
1489                             sentinel_frame, RETURN_MASK_ERROR) != 0)
1490         {
1491           /* Oops! Fake a current frame?  Is this useful?  It has a PC
1492              of zero, for instance.  */
1493           current_frame = sentinel_frame;
1494         }
1495     }
1496   return current_frame;
1497 }
1498
1499 /* The "selected" stack frame is used by default for local and arg
1500    access.  May be zero, for no selected frame.  */
1501
1502 static struct frame_info *selected_frame;
1503
1504 int
1505 has_stack_frames (void)
1506 {
1507   if (!target_has_registers || !target_has_stack || !target_has_memory)
1508     return 0;
1509
1510   /* Traceframes are effectively a substitute for the live inferior.  */
1511   if (get_traceframe_number () < 0)
1512     {
1513       /* No current inferior, no frame.  */
1514       if (ptid_equal (inferior_ptid, null_ptid))
1515         return 0;
1516
1517       /* Don't try to read from a dead thread.  */
1518       if (is_exited (inferior_ptid))
1519         return 0;
1520
1521       /* ... or from a spinning thread.  */
1522       if (is_executing (inferior_ptid))
1523         return 0;
1524     }
1525
1526   return 1;
1527 }
1528
1529 /* Return the selected frame.  Always non-NULL (unless there isn't an
1530    inferior sufficient for creating a frame) in which case an error is
1531    thrown.  */
1532
1533 struct frame_info *
1534 get_selected_frame (const char *message)
1535 {
1536   if (selected_frame == NULL)
1537     {
1538       if (message != NULL && !has_stack_frames ())
1539         error (("%s"), message);
1540       /* Hey!  Don't trust this.  It should really be re-finding the
1541          last selected frame of the currently selected thread.  This,
1542          though, is better than nothing.  */
1543       select_frame (get_current_frame ());
1544     }
1545   /* There is always a frame.  */
1546   gdb_assert (selected_frame != NULL);
1547   return selected_frame;
1548 }
1549
1550 /* If there is a selected frame, return it.  Otherwise, return NULL.  */
1551
1552 struct frame_info *
1553 get_selected_frame_if_set (void)
1554 {
1555   return selected_frame;
1556 }
1557
1558 /* This is a variant of get_selected_frame() which can be called when
1559    the inferior does not have a frame; in that case it will return
1560    NULL instead of calling error().  */
1561
1562 struct frame_info *
1563 deprecated_safe_get_selected_frame (void)
1564 {
1565   if (!has_stack_frames ())
1566     return NULL;
1567   return get_selected_frame (NULL);
1568 }
1569
1570 /* Select frame FI (or NULL - to invalidate the current frame).  */
1571
1572 void
1573 select_frame (struct frame_info *fi)
1574 {
1575   selected_frame = fi;
1576   /* NOTE: cagney/2002-05-04: FI can be NULL.  This occurs when the
1577      frame is being invalidated.  */
1578   if (deprecated_selected_frame_level_changed_hook)
1579     deprecated_selected_frame_level_changed_hook (frame_relative_level (fi));
1580
1581   /* FIXME: kseitz/2002-08-28: It would be nice to call
1582      selected_frame_level_changed_event() right here, but due to limitations
1583      in the current interfaces, we would end up flooding UIs with events
1584      because select_frame() is used extensively internally.
1585
1586      Once we have frame-parameterized frame (and frame-related) commands,
1587      the event notification can be moved here, since this function will only
1588      be called when the user's selected frame is being changed.  */
1589
1590   /* Ensure that symbols for this frame are read in.  Also, determine the
1591      source language of this frame, and switch to it if desired.  */
1592   if (fi)
1593     {
1594       CORE_ADDR pc;
1595
1596       /* We retrieve the frame's symtab by using the frame PC.
1597          However we cannot use the frame PC as-is, because it usually
1598          points to the instruction following the "call", which is
1599          sometimes the first instruction of another function.  So we
1600          rely on get_frame_address_in_block() which provides us with a
1601          PC which is guaranteed to be inside the frame's code
1602          block.  */
1603       if (get_frame_address_in_block_if_available (fi, &pc))
1604         {
1605           struct symtab *s = find_pc_symtab (pc);
1606
1607           if (s
1608               && s->language != current_language->la_language
1609               && s->language != language_unknown
1610               && language_mode == language_mode_auto)
1611             set_language (s->language);
1612         }
1613     }
1614 }
1615
1616 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1617    Always returns a non-NULL value.  */
1618
1619 struct frame_info *
1620 create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
1621 {
1622   struct frame_info *fi;
1623
1624   if (frame_debug)
1625     {
1626       fprintf_unfiltered (gdb_stdlog,
1627                           "{ create_new_frame (addr=%s, pc=%s) ",
1628                           hex_string (addr), hex_string (pc));
1629     }
1630
1631   fi = FRAME_OBSTACK_ZALLOC (struct frame_info);
1632
1633   fi->next = create_sentinel_frame (current_program_space,
1634                                     get_current_regcache ());
1635
1636   /* Set/update this frame's cached PC value, found in the next frame.
1637      Do this before looking for this frame's unwinder.  A sniffer is
1638      very likely to read this, and the corresponding unwinder is
1639      entitled to rely that the PC doesn't magically change.  */
1640   fi->next->prev_pc.value = pc;
1641   fi->next->prev_pc.status = CC_VALUE;
1642
1643   /* We currently assume that frame chain's can't cross spaces.  */
1644   fi->pspace = fi->next->pspace;
1645   fi->aspace = fi->next->aspace;
1646
1647   /* Select/initialize both the unwind function and the frame's type
1648      based on the PC.  */
1649   frame_unwind_find_by_frame (fi, &fi->prologue_cache);
1650
1651   fi->this_id.p = 1;
1652   fi->this_id.value = frame_id_build (addr, pc);
1653
1654   if (frame_debug)
1655     {
1656       fprintf_unfiltered (gdb_stdlog, "-> ");
1657       fprint_frame (gdb_stdlog, fi);
1658       fprintf_unfiltered (gdb_stdlog, " }\n");
1659     }
1660
1661   return fi;
1662 }
1663
1664 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1665    innermost frame).  Be careful to not fall off the bottom of the
1666    frame chain and onto the sentinel frame.  */
1667
1668 struct frame_info *
1669 get_next_frame (struct frame_info *this_frame)
1670 {
1671   if (this_frame->level > 0)
1672     return this_frame->next;
1673   else
1674     return NULL;
1675 }
1676
1677 /* Observer for the target_changed event.  */
1678
1679 static void
1680 frame_observer_target_changed (struct target_ops *target)
1681 {
1682   reinit_frame_cache ();
1683 }
1684
1685 /* Flush the entire frame cache.  */
1686
1687 void
1688 reinit_frame_cache (void)
1689 {
1690   struct frame_info *fi;
1691
1692   /* Tear down all frame caches.  */
1693   for (fi = current_frame; fi != NULL; fi = fi->prev)
1694     {
1695       if (fi->prologue_cache && fi->unwind->dealloc_cache)
1696         fi->unwind->dealloc_cache (fi, fi->prologue_cache);
1697       if (fi->base_cache && fi->base->unwind->dealloc_cache)
1698         fi->base->unwind->dealloc_cache (fi, fi->base_cache);
1699     }
1700
1701   /* Since we can't really be sure what the first object allocated was.  */
1702   obstack_free (&frame_cache_obstack, 0);
1703   obstack_init (&frame_cache_obstack);
1704
1705   if (current_frame != NULL)
1706     annotate_frames_invalid ();
1707
1708   current_frame = NULL;         /* Invalidate cache */
1709   select_frame (NULL);
1710   frame_stash_invalidate ();
1711   if (frame_debug)
1712     fprintf_unfiltered (gdb_stdlog, "{ reinit_frame_cache () }\n");
1713 }
1714
1715 /* Find where a register is saved (in memory or another register).
1716    The result of frame_register_unwind is just where it is saved
1717    relative to this particular frame.  */
1718
1719 static void
1720 frame_register_unwind_location (struct frame_info *this_frame, int regnum,
1721                                 int *optimizedp, enum lval_type *lvalp,
1722                                 CORE_ADDR *addrp, int *realnump)
1723 {
1724   gdb_assert (this_frame == NULL || this_frame->level >= 0);
1725
1726   while (this_frame != NULL)
1727     {
1728       int unavailable;
1729
1730       frame_register_unwind (this_frame, regnum, optimizedp, &unavailable,
1731                              lvalp, addrp, realnump, NULL);
1732
1733       if (*optimizedp)
1734         break;
1735
1736       if (*lvalp != lval_register)
1737         break;
1738
1739       regnum = *realnump;
1740       this_frame = get_next_frame (this_frame);
1741     }
1742 }
1743
1744 /* Called during frame unwinding to remove a previous frame pointer from a
1745    frame passed in ARG.  */
1746
1747 static void
1748 remove_prev_frame (void *arg)
1749 {
1750   struct frame_info *this_frame, *prev_frame;
1751
1752   this_frame = (struct frame_info *) arg;
1753   prev_frame = this_frame->prev;
1754   gdb_assert (prev_frame != NULL);
1755
1756   prev_frame->next = NULL;
1757   this_frame->prev = NULL;
1758 }
1759
1760 /* Get the previous raw frame, and check that it is not identical to
1761    same other frame frame already in the chain.  If it is, there is
1762    most likely a stack cycle, so we discard it, and mark THIS_FRAME as
1763    outermost, with UNWIND_SAME_ID stop reason.  Unlike the other
1764    validity tests, that compare THIS_FRAME and the next frame, we do
1765    this right after creating the previous frame, to avoid ever ending
1766    up with two frames with the same id in the frame chain.  */
1767
1768 static struct frame_info *
1769 get_prev_frame_if_no_cycle (struct frame_info *this_frame)
1770 {
1771   struct frame_info *prev_frame;
1772   struct cleanup *prev_frame_cleanup;
1773
1774   prev_frame = get_prev_frame_raw (this_frame);
1775   if (prev_frame == NULL)
1776     return NULL;
1777
1778   /* The cleanup will remove the previous frame that get_prev_frame_raw
1779      linked onto THIS_FRAME.  */
1780   prev_frame_cleanup = make_cleanup (remove_prev_frame, this_frame);
1781
1782   compute_frame_id (prev_frame);
1783   if (!frame_stash_add (prev_frame))
1784     {
1785       /* Another frame with the same id was already in the stash.  We just
1786          detected a cycle.  */
1787       if (frame_debug)
1788         {
1789           fprintf_unfiltered (gdb_stdlog, "-> ");
1790           fprint_frame (gdb_stdlog, NULL);
1791           fprintf_unfiltered (gdb_stdlog, " // this frame has same ID }\n");
1792         }
1793       this_frame->stop_reason = UNWIND_SAME_ID;
1794       /* Unlink.  */
1795       prev_frame->next = NULL;
1796       this_frame->prev = NULL;
1797       prev_frame = NULL;
1798     }
1799
1800   discard_cleanups (prev_frame_cleanup);
1801   return prev_frame;
1802 }
1803
1804 /* Helper function for get_prev_frame_always, this is called inside a
1805    TRY_CATCH block.  Return the frame that called THIS_FRAME or NULL if
1806    there is no such frame.  This may throw an exception.  */
1807
1808 static struct frame_info *
1809 get_prev_frame_always_1 (struct frame_info *this_frame)
1810 {
1811   struct gdbarch *gdbarch;
1812
1813   gdb_assert (this_frame != NULL);
1814   gdbarch = get_frame_arch (this_frame);
1815
1816   if (frame_debug)
1817     {
1818       fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_always (this_frame=");
1819       if (this_frame != NULL)
1820         fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
1821       else
1822         fprintf_unfiltered (gdb_stdlog, "<NULL>");
1823       fprintf_unfiltered (gdb_stdlog, ") ");
1824     }
1825
1826   /* Only try to do the unwind once.  */
1827   if (this_frame->prev_p)
1828     {
1829       if (frame_debug)
1830         {
1831           fprintf_unfiltered (gdb_stdlog, "-> ");
1832           fprint_frame (gdb_stdlog, this_frame->prev);
1833           fprintf_unfiltered (gdb_stdlog, " // cached \n");
1834         }
1835       return this_frame->prev;
1836     }
1837
1838   /* If the frame unwinder hasn't been selected yet, we must do so
1839      before setting prev_p; otherwise the check for misbehaved
1840      sniffers will think that this frame's sniffer tried to unwind
1841      further (see frame_cleanup_after_sniffer).  */
1842   if (this_frame->unwind == NULL)
1843     frame_unwind_find_by_frame (this_frame, &this_frame->prologue_cache);
1844
1845   this_frame->prev_p = 1;
1846   this_frame->stop_reason = UNWIND_NO_REASON;
1847
1848   /* If we are unwinding from an inline frame, all of the below tests
1849      were already performed when we unwound from the next non-inline
1850      frame.  We must skip them, since we can not get THIS_FRAME's ID
1851      until we have unwound all the way down to the previous non-inline
1852      frame.  */
1853   if (get_frame_type (this_frame) == INLINE_FRAME)
1854     return get_prev_frame_if_no_cycle (this_frame);
1855
1856   /* Check that this frame is unwindable.  If it isn't, don't try to
1857      unwind to the prev frame.  */
1858   this_frame->stop_reason
1859     = this_frame->unwind->stop_reason (this_frame,
1860                                        &this_frame->prologue_cache);
1861
1862   if (this_frame->stop_reason != UNWIND_NO_REASON)
1863     {
1864       if (frame_debug)
1865         {
1866           enum unwind_stop_reason reason = this_frame->stop_reason;
1867
1868           fprintf_unfiltered (gdb_stdlog, "-> ");
1869           fprint_frame (gdb_stdlog, NULL);
1870           fprintf_unfiltered (gdb_stdlog, " // %s }\n",
1871                               frame_stop_reason_symbol_string (reason));
1872         }
1873       return NULL;
1874     }
1875
1876   /* Check that this frame's ID isn't inner to (younger, below, next)
1877      the next frame.  This happens when a frame unwind goes backwards.
1878      This check is valid only if this frame and the next frame are NORMAL.
1879      See the comment at frame_id_inner for details.  */
1880   if (get_frame_type (this_frame) == NORMAL_FRAME
1881       && this_frame->next->unwind->type == NORMAL_FRAME
1882       && frame_id_inner (get_frame_arch (this_frame->next),
1883                          get_frame_id (this_frame),
1884                          get_frame_id (this_frame->next)))
1885     {
1886       CORE_ADDR this_pc_in_block;
1887       struct minimal_symbol *morestack_msym;
1888       const char *morestack_name = NULL;
1889
1890       /* gcc -fsplit-stack __morestack can continue the stack anywhere.  */
1891       this_pc_in_block = get_frame_address_in_block (this_frame);
1892       morestack_msym = lookup_minimal_symbol_by_pc (this_pc_in_block).minsym;
1893       if (morestack_msym)
1894         morestack_name = MSYMBOL_LINKAGE_NAME (morestack_msym);
1895       if (!morestack_name || strcmp (morestack_name, "__morestack") != 0)
1896         {
1897           if (frame_debug)
1898             {
1899               fprintf_unfiltered (gdb_stdlog, "-> ");
1900               fprint_frame (gdb_stdlog, NULL);
1901               fprintf_unfiltered (gdb_stdlog,
1902                                   " // this frame ID is inner }\n");
1903             }
1904           this_frame->stop_reason = UNWIND_INNER_ID;
1905           return NULL;
1906         }
1907     }
1908
1909   /* Check that this and the next frame do not unwind the PC register
1910      to the same memory location.  If they do, then even though they
1911      have different frame IDs, the new frame will be bogus; two
1912      functions can't share a register save slot for the PC.  This can
1913      happen when the prologue analyzer finds a stack adjustment, but
1914      no PC save.
1915
1916      This check does assume that the "PC register" is roughly a
1917      traditional PC, even if the gdbarch_unwind_pc method adjusts
1918      it (we do not rely on the value, only on the unwound PC being
1919      dependent on this value).  A potential improvement would be
1920      to have the frame prev_pc method and the gdbarch unwind_pc
1921      method set the same lval and location information as
1922      frame_register_unwind.  */
1923   if (this_frame->level > 0
1924       && gdbarch_pc_regnum (gdbarch) >= 0
1925       && get_frame_type (this_frame) == NORMAL_FRAME
1926       && (get_frame_type (this_frame->next) == NORMAL_FRAME
1927           || get_frame_type (this_frame->next) == INLINE_FRAME))
1928     {
1929       int optimized, realnum, nrealnum;
1930       enum lval_type lval, nlval;
1931       CORE_ADDR addr, naddr;
1932
1933       frame_register_unwind_location (this_frame,
1934                                       gdbarch_pc_regnum (gdbarch),
1935                                       &optimized, &lval, &addr, &realnum);
1936       frame_register_unwind_location (get_next_frame (this_frame),
1937                                       gdbarch_pc_regnum (gdbarch),
1938                                       &optimized, &nlval, &naddr, &nrealnum);
1939
1940       if ((lval == lval_memory && lval == nlval && addr == naddr)
1941           || (lval == lval_register && lval == nlval && realnum == nrealnum))
1942         {
1943           if (frame_debug)
1944             {
1945               fprintf_unfiltered (gdb_stdlog, "-> ");
1946               fprint_frame (gdb_stdlog, NULL);
1947               fprintf_unfiltered (gdb_stdlog, " // no saved PC }\n");
1948             }
1949
1950           this_frame->stop_reason = UNWIND_NO_SAVED_PC;
1951           this_frame->prev = NULL;
1952           return NULL;
1953         }
1954     }
1955
1956   return get_prev_frame_if_no_cycle (this_frame);
1957 }
1958
1959 /* Return a "struct frame_info" corresponding to the frame that called
1960    THIS_FRAME.  Returns NULL if there is no such frame.
1961
1962    Unlike get_prev_frame, this function always tries to unwind the
1963    frame.  */
1964
1965 struct frame_info *
1966 get_prev_frame_always (struct frame_info *this_frame)
1967 {
1968   volatile struct gdb_exception ex;
1969   struct frame_info *prev_frame = NULL;
1970
1971   TRY_CATCH (ex, RETURN_MASK_ERROR)
1972     {
1973       prev_frame = get_prev_frame_always_1 (this_frame);
1974     }
1975   if (ex.reason < 0)
1976     {
1977       if (ex.error == MEMORY_ERROR)
1978         {
1979           this_frame->stop_reason = UNWIND_MEMORY_ERROR;
1980           if (ex.message != NULL)
1981             {
1982               char *stop_string;
1983               size_t size;
1984
1985               /* The error needs to live as long as the frame does.
1986                  Allocate using stack local STOP_STRING then assign the
1987                  pointer to the frame, this allows the STOP_STRING on the
1988                  frame to be of type 'const char *'.  */
1989               size = strlen (ex.message) + 1;
1990               stop_string = frame_obstack_zalloc (size);
1991               memcpy (stop_string, ex.message, size);
1992               this_frame->stop_string = stop_string;
1993             }
1994           prev_frame = NULL;
1995         }
1996       else
1997         throw_exception (ex);
1998     }
1999
2000   return prev_frame;
2001 }
2002
2003 /* Construct a new "struct frame_info" and link it previous to
2004    this_frame.  */
2005
2006 static struct frame_info *
2007 get_prev_frame_raw (struct frame_info *this_frame)
2008 {
2009   struct frame_info *prev_frame;
2010
2011   /* Allocate the new frame but do not wire it in to the frame chain.
2012      Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2013      frame->next to pull some fancy tricks (of course such code is, by
2014      definition, recursive).  Try to prevent it.
2015
2016      There is no reason to worry about memory leaks, should the
2017      remainder of the function fail.  The allocated memory will be
2018      quickly reclaimed when the frame cache is flushed, and the `we've
2019      been here before' check above will stop repeated memory
2020      allocation calls.  */
2021   prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
2022   prev_frame->level = this_frame->level + 1;
2023
2024   /* For now, assume we don't have frame chains crossing address
2025      spaces.  */
2026   prev_frame->pspace = this_frame->pspace;
2027   prev_frame->aspace = this_frame->aspace;
2028
2029   /* Don't yet compute ->unwind (and hence ->type).  It is computed
2030      on-demand in get_frame_type, frame_register_unwind, and
2031      get_frame_id.  */
2032
2033   /* Don't yet compute the frame's ID.  It is computed on-demand by
2034      get_frame_id().  */
2035
2036   /* The unwound frame ID is validate at the start of this function,
2037      as part of the logic to decide if that frame should be further
2038      unwound, and not here while the prev frame is being created.
2039      Doing this makes it possible for the user to examine a frame that
2040      has an invalid frame ID.
2041
2042      Some very old VAX code noted: [...]  For the sake of argument,
2043      suppose that the stack is somewhat trashed (which is one reason
2044      that "info frame" exists).  So, return 0 (indicating we don't
2045      know the address of the arglist) if we don't know what frame this
2046      frame calls.  */
2047
2048   /* Link it in.  */
2049   this_frame->prev = prev_frame;
2050   prev_frame->next = this_frame;
2051
2052   if (frame_debug)
2053     {
2054       fprintf_unfiltered (gdb_stdlog, "-> ");
2055       fprint_frame (gdb_stdlog, prev_frame);
2056       fprintf_unfiltered (gdb_stdlog, " }\n");
2057     }
2058
2059   return prev_frame;
2060 }
2061
2062 /* Debug routine to print a NULL frame being returned.  */
2063
2064 static void
2065 frame_debug_got_null_frame (struct frame_info *this_frame,
2066                             const char *reason)
2067 {
2068   if (frame_debug)
2069     {
2070       fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame=");
2071       if (this_frame != NULL)
2072         fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
2073       else
2074         fprintf_unfiltered (gdb_stdlog, "<NULL>");
2075       fprintf_unfiltered (gdb_stdlog, ") -> // %s}\n", reason);
2076     }
2077 }
2078
2079 /* Is this (non-sentinel) frame in the "main"() function?  */
2080
2081 static int
2082 inside_main_func (struct frame_info *this_frame)
2083 {
2084   struct bound_minimal_symbol msymbol;
2085   CORE_ADDR maddr;
2086
2087   if (symfile_objfile == 0)
2088     return 0;
2089   msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
2090   if (msymbol.minsym == NULL)
2091     return 0;
2092   /* Make certain that the code, and not descriptor, address is
2093      returned.  */
2094   maddr = gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame),
2095                                               BMSYMBOL_VALUE_ADDRESS (msymbol),
2096                                               &current_target);
2097   return maddr == get_frame_func (this_frame);
2098 }
2099
2100 /* Test whether THIS_FRAME is inside the process entry point function.  */
2101
2102 static int
2103 inside_entry_func (struct frame_info *this_frame)
2104 {
2105   CORE_ADDR entry_point;
2106
2107   if (!entry_point_address_query (&entry_point))
2108     return 0;
2109
2110   return get_frame_func (this_frame) == entry_point;
2111 }
2112
2113 /* Return a structure containing various interesting information about
2114    the frame that called THIS_FRAME.  Returns NULL if there is entier
2115    no such frame or the frame fails any of a set of target-independent
2116    condition that should terminate the frame chain (e.g., as unwinding
2117    past main()).
2118
2119    This function should not contain target-dependent tests, such as
2120    checking whether the program-counter is zero.  */
2121
2122 struct frame_info *
2123 get_prev_frame (struct frame_info *this_frame)
2124 {
2125   CORE_ADDR frame_pc;
2126   int frame_pc_p;
2127
2128   /* There is always a frame.  If this assertion fails, suspect that
2129      something should be calling get_selected_frame() or
2130      get_current_frame().  */
2131   gdb_assert (this_frame != NULL);
2132   frame_pc_p = get_frame_pc_if_available (this_frame, &frame_pc);
2133
2134   /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2135      sense to stop unwinding at a dummy frame.  One place where a dummy
2136      frame may have an address "inside_main_func" is on HPUX.  On HPUX, the
2137      pcsqh register (space register for the instruction at the head of the
2138      instruction queue) cannot be written directly; the only way to set it
2139      is to branch to code that is in the target space.  In order to implement
2140      frame dummies on HPUX, the called function is made to jump back to where
2141      the inferior was when the user function was called.  If gdb was inside
2142      the main function when we created the dummy frame, the dummy frame will
2143      point inside the main function.  */
2144   if (this_frame->level >= 0
2145       && get_frame_type (this_frame) == NORMAL_FRAME
2146       && !backtrace_past_main
2147       && frame_pc_p
2148       && inside_main_func (this_frame))
2149     /* Don't unwind past main().  Note, this is done _before_ the
2150        frame has been marked as previously unwound.  That way if the
2151        user later decides to enable unwinds past main(), that will
2152        automatically happen.  */
2153     {
2154       frame_debug_got_null_frame (this_frame, "inside main func");
2155       return NULL;
2156     }
2157
2158   /* If the user's backtrace limit has been exceeded, stop.  We must
2159      add two to the current level; one of those accounts for backtrace_limit
2160      being 1-based and the level being 0-based, and the other accounts for
2161      the level of the new frame instead of the level of the current
2162      frame.  */
2163   if (this_frame->level + 2 > backtrace_limit)
2164     {
2165       frame_debug_got_null_frame (this_frame, "backtrace limit exceeded");
2166       return NULL;
2167     }
2168
2169   /* If we're already inside the entry function for the main objfile,
2170      then it isn't valid.  Don't apply this test to a dummy frame -
2171      dummy frame PCs typically land in the entry func.  Don't apply
2172      this test to the sentinel frame.  Sentinel frames should always
2173      be allowed to unwind.  */
2174   /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2175      wasn't checking for "main" in the minimal symbols.  With that
2176      fixed asm-source tests now stop in "main" instead of halting the
2177      backtrace in weird and wonderful ways somewhere inside the entry
2178      file.  Suspect that tests for inside the entry file/func were
2179      added to work around that (now fixed) case.  */
2180   /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2181      suggested having the inside_entry_func test use the
2182      inside_main_func() msymbol trick (along with entry_point_address()
2183      I guess) to determine the address range of the start function.
2184      That should provide a far better stopper than the current
2185      heuristics.  */
2186   /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2187      applied tail-call optimizations to main so that a function called
2188      from main returns directly to the caller of main.  Since we don't
2189      stop at main, we should at least stop at the entry point of the
2190      application.  */
2191   if (this_frame->level >= 0
2192       && get_frame_type (this_frame) == NORMAL_FRAME
2193       && !backtrace_past_entry
2194       && frame_pc_p
2195       && inside_entry_func (this_frame))
2196     {
2197       frame_debug_got_null_frame (this_frame, "inside entry func");
2198       return NULL;
2199     }
2200
2201   /* Assume that the only way to get a zero PC is through something
2202      like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2203      will never unwind a zero PC.  */
2204   if (this_frame->level > 0
2205       && (get_frame_type (this_frame) == NORMAL_FRAME
2206           || get_frame_type (this_frame) == INLINE_FRAME)
2207       && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME
2208       && frame_pc_p && frame_pc == 0)
2209     {
2210       frame_debug_got_null_frame (this_frame, "zero PC");
2211       return NULL;
2212     }
2213
2214   return get_prev_frame_always (this_frame);
2215 }
2216
2217 CORE_ADDR
2218 get_frame_pc (struct frame_info *frame)
2219 {
2220   gdb_assert (frame->next != NULL);
2221   return frame_unwind_pc (frame->next);
2222 }
2223
2224 int
2225 get_frame_pc_if_available (struct frame_info *frame, CORE_ADDR *pc)
2226 {
2227   volatile struct gdb_exception ex;
2228
2229   gdb_assert (frame->next != NULL);
2230
2231   TRY_CATCH (ex, RETURN_MASK_ERROR)
2232     {
2233       *pc = frame_unwind_pc (frame->next);
2234     }
2235   if (ex.reason < 0)
2236     {
2237       if (ex.error == NOT_AVAILABLE_ERROR)
2238         return 0;
2239       else
2240         throw_exception (ex);
2241     }
2242
2243   return 1;
2244 }
2245
2246 /* Return an address that falls within THIS_FRAME's code block.  */
2247
2248 CORE_ADDR
2249 get_frame_address_in_block (struct frame_info *this_frame)
2250 {
2251   /* A draft address.  */
2252   CORE_ADDR pc = get_frame_pc (this_frame);
2253
2254   struct frame_info *next_frame = this_frame->next;
2255
2256   /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2257      Normally the resume address is inside the body of the function
2258      associated with THIS_FRAME, but there is a special case: when
2259      calling a function which the compiler knows will never return
2260      (for instance abort), the call may be the very last instruction
2261      in the calling function.  The resume address will point after the
2262      call and may be at the beginning of a different function
2263      entirely.
2264
2265      If THIS_FRAME is a signal frame or dummy frame, then we should
2266      not adjust the unwound PC.  For a dummy frame, GDB pushed the
2267      resume address manually onto the stack.  For a signal frame, the
2268      OS may have pushed the resume address manually and invoked the
2269      handler (e.g. GNU/Linux), or invoked the trampoline which called
2270      the signal handler - but in either case the signal handler is
2271      expected to return to the trampoline.  So in both of these
2272      cases we know that the resume address is executable and
2273      related.  So we only need to adjust the PC if THIS_FRAME
2274      is a normal function.
2275
2276      If the program has been interrupted while THIS_FRAME is current,
2277      then clearly the resume address is inside the associated
2278      function.  There are three kinds of interruption: debugger stop
2279      (next frame will be SENTINEL_FRAME), operating system
2280      signal or exception (next frame will be SIGTRAMP_FRAME),
2281      or debugger-induced function call (next frame will be
2282      DUMMY_FRAME).  So we only need to adjust the PC if
2283      NEXT_FRAME is a normal function.
2284
2285      We check the type of NEXT_FRAME first, since it is already
2286      known; frame type is determined by the unwinder, and since
2287      we have THIS_FRAME we've already selected an unwinder for
2288      NEXT_FRAME.
2289
2290      If the next frame is inlined, we need to keep going until we find
2291      the real function - for instance, if a signal handler is invoked
2292      while in an inlined function, then the code address of the
2293      "calling" normal function should not be adjusted either.  */
2294
2295   while (get_frame_type (next_frame) == INLINE_FRAME)
2296     next_frame = next_frame->next;
2297
2298   if ((get_frame_type (next_frame) == NORMAL_FRAME
2299        || get_frame_type (next_frame) == TAILCALL_FRAME)
2300       && (get_frame_type (this_frame) == NORMAL_FRAME
2301           || get_frame_type (this_frame) == TAILCALL_FRAME
2302           || get_frame_type (this_frame) == INLINE_FRAME))
2303     return pc - 1;
2304
2305   return pc;
2306 }
2307
2308 int
2309 get_frame_address_in_block_if_available (struct frame_info *this_frame,
2310                                          CORE_ADDR *pc)
2311 {
2312   volatile struct gdb_exception ex;
2313
2314   TRY_CATCH (ex, RETURN_MASK_ERROR)
2315     {
2316       *pc = get_frame_address_in_block (this_frame);
2317     }
2318   if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
2319     return 0;
2320   else if (ex.reason < 0)
2321     throw_exception (ex);
2322   else
2323     return 1;
2324 }
2325
2326 void
2327 find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
2328 {
2329   struct frame_info *next_frame;
2330   int notcurrent;
2331   CORE_ADDR pc;
2332
2333   /* If the next frame represents an inlined function call, this frame's
2334      sal is the "call site" of that inlined function, which can not
2335      be inferred from get_frame_pc.  */
2336   next_frame = get_next_frame (frame);
2337   if (frame_inlined_callees (frame) > 0)
2338     {
2339       struct symbol *sym;
2340
2341       if (next_frame)
2342         sym = get_frame_function (next_frame);
2343       else
2344         sym = inline_skipped_symbol (inferior_ptid);
2345
2346       /* If frame is inline, it certainly has symbols.  */
2347       gdb_assert (sym);
2348       init_sal (sal);
2349       if (SYMBOL_LINE (sym) != 0)
2350         {
2351           sal->symtab = SYMBOL_SYMTAB (sym);
2352           sal->line = SYMBOL_LINE (sym);
2353         }
2354       else
2355         /* If the symbol does not have a location, we don't know where
2356            the call site is.  Do not pretend to.  This is jarring, but
2357            we can't do much better.  */
2358         sal->pc = get_frame_pc (frame);
2359
2360       sal->pspace = get_frame_program_space (frame);
2361
2362       return;
2363     }
2364
2365   /* If FRAME is not the innermost frame, that normally means that
2366      FRAME->pc points at the return instruction (which is *after* the
2367      call instruction), and we want to get the line containing the
2368      call (because the call is where the user thinks the program is).
2369      However, if the next frame is either a SIGTRAMP_FRAME or a
2370      DUMMY_FRAME, then the next frame will contain a saved interrupt
2371      PC and such a PC indicates the current (rather than next)
2372      instruction/line, consequently, for such cases, want to get the
2373      line containing fi->pc.  */
2374   if (!get_frame_pc_if_available (frame, &pc))
2375     {
2376       init_sal (sal);
2377       return;
2378     }
2379
2380   notcurrent = (pc != get_frame_address_in_block (frame));
2381   (*sal) = find_pc_line (pc, notcurrent);
2382 }
2383
2384 /* Per "frame.h", return the ``address'' of the frame.  Code should
2385    really be using get_frame_id().  */
2386 CORE_ADDR
2387 get_frame_base (struct frame_info *fi)
2388 {
2389   return get_frame_id (fi).stack_addr;
2390 }
2391
2392 /* High-level offsets into the frame.  Used by the debug info.  */
2393
2394 CORE_ADDR
2395 get_frame_base_address (struct frame_info *fi)
2396 {
2397   if (get_frame_type (fi) != NORMAL_FRAME)
2398     return 0;
2399   if (fi->base == NULL)
2400     fi->base = frame_base_find_by_frame (fi);
2401   /* Sneaky: If the low-level unwind and high-level base code share a
2402      common unwinder, let them share the prologue cache.  */
2403   if (fi->base->unwind == fi->unwind)
2404     return fi->base->this_base (fi, &fi->prologue_cache);
2405   return fi->base->this_base (fi, &fi->base_cache);
2406 }
2407
2408 CORE_ADDR
2409 get_frame_locals_address (struct frame_info *fi)
2410 {
2411   if (get_frame_type (fi) != NORMAL_FRAME)
2412     return 0;
2413   /* If there isn't a frame address method, find it.  */
2414   if (fi->base == NULL)
2415     fi->base = frame_base_find_by_frame (fi);
2416   /* Sneaky: If the low-level unwind and high-level base code share a
2417      common unwinder, let them share the prologue cache.  */
2418   if (fi->base->unwind == fi->unwind)
2419     return fi->base->this_locals (fi, &fi->prologue_cache);
2420   return fi->base->this_locals (fi, &fi->base_cache);
2421 }
2422
2423 CORE_ADDR
2424 get_frame_args_address (struct frame_info *fi)
2425 {
2426   if (get_frame_type (fi) != NORMAL_FRAME)
2427     return 0;
2428   /* If there isn't a frame address method, find it.  */
2429   if (fi->base == NULL)
2430     fi->base = frame_base_find_by_frame (fi);
2431   /* Sneaky: If the low-level unwind and high-level base code share a
2432      common unwinder, let them share the prologue cache.  */
2433   if (fi->base->unwind == fi->unwind)
2434     return fi->base->this_args (fi, &fi->prologue_cache);
2435   return fi->base->this_args (fi, &fi->base_cache);
2436 }
2437
2438 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2439    otherwise.  */
2440
2441 int
2442 frame_unwinder_is (struct frame_info *fi, const struct frame_unwind *unwinder)
2443 {
2444   if (fi->unwind == NULL)
2445     frame_unwind_find_by_frame (fi, &fi->prologue_cache);
2446   return fi->unwind == unwinder;
2447 }
2448
2449 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2450    or -1 for a NULL frame.  */
2451
2452 int
2453 frame_relative_level (struct frame_info *fi)
2454 {
2455   if (fi == NULL)
2456     return -1;
2457   else
2458     return fi->level;
2459 }
2460
2461 enum frame_type
2462 get_frame_type (struct frame_info *frame)
2463 {
2464   if (frame->unwind == NULL)
2465     /* Initialize the frame's unwinder because that's what
2466        provides the frame's type.  */
2467     frame_unwind_find_by_frame (frame, &frame->prologue_cache);
2468   return frame->unwind->type;
2469 }
2470
2471 struct program_space *
2472 get_frame_program_space (struct frame_info *frame)
2473 {
2474   return frame->pspace;
2475 }
2476
2477 struct program_space *
2478 frame_unwind_program_space (struct frame_info *this_frame)
2479 {
2480   gdb_assert (this_frame);
2481
2482   /* This is really a placeholder to keep the API consistent --- we
2483      assume for now that we don't have frame chains crossing
2484      spaces.  */
2485   return this_frame->pspace;
2486 }
2487
2488 struct address_space *
2489 get_frame_address_space (struct frame_info *frame)
2490 {
2491   return frame->aspace;
2492 }
2493
2494 /* Memory access methods.  */
2495
2496 void
2497 get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
2498                   gdb_byte *buf, int len)
2499 {
2500   read_memory (addr, buf, len);
2501 }
2502
2503 LONGEST
2504 get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr,
2505                          int len)
2506 {
2507   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2508   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2509
2510   return read_memory_integer (addr, len, byte_order);
2511 }
2512
2513 ULONGEST
2514 get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
2515                            int len)
2516 {
2517   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2518   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2519
2520   return read_memory_unsigned_integer (addr, len, byte_order);
2521 }
2522
2523 int
2524 safe_frame_unwind_memory (struct frame_info *this_frame,
2525                           CORE_ADDR addr, gdb_byte *buf, int len)
2526 {
2527   /* NOTE: target_read_memory returns zero on success!  */
2528   return !target_read_memory (addr, buf, len);
2529 }
2530
2531 /* Architecture methods.  */
2532
2533 struct gdbarch *
2534 get_frame_arch (struct frame_info *this_frame)
2535 {
2536   return frame_unwind_arch (this_frame->next);
2537 }
2538
2539 struct gdbarch *
2540 frame_unwind_arch (struct frame_info *next_frame)
2541 {
2542   if (!next_frame->prev_arch.p)
2543     {
2544       struct gdbarch *arch;
2545
2546       if (next_frame->unwind == NULL)
2547         frame_unwind_find_by_frame (next_frame, &next_frame->prologue_cache);
2548
2549       if (next_frame->unwind->prev_arch != NULL)
2550         arch = next_frame->unwind->prev_arch (next_frame,
2551                                               &next_frame->prologue_cache);
2552       else
2553         arch = get_frame_arch (next_frame);
2554
2555       next_frame->prev_arch.arch = arch;
2556       next_frame->prev_arch.p = 1;
2557       if (frame_debug)
2558         fprintf_unfiltered (gdb_stdlog,
2559                             "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2560                             next_frame->level,
2561                             gdbarch_bfd_arch_info (arch)->printable_name);
2562     }
2563
2564   return next_frame->prev_arch.arch;
2565 }
2566
2567 struct gdbarch *
2568 frame_unwind_caller_arch (struct frame_info *next_frame)
2569 {
2570   return frame_unwind_arch (skip_artificial_frames (next_frame));
2571 }
2572
2573 /* Stack pointer methods.  */
2574
2575 CORE_ADDR
2576 get_frame_sp (struct frame_info *this_frame)
2577 {
2578   struct gdbarch *gdbarch = get_frame_arch (this_frame);
2579
2580   /* Normality - an architecture that provides a way of obtaining any
2581      frame inner-most address.  */
2582   if (gdbarch_unwind_sp_p (gdbarch))
2583     /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
2584        operate on THIS_FRAME now.  */
2585     return gdbarch_unwind_sp (gdbarch, this_frame->next);
2586   /* Now things are really are grim.  Hope that the value returned by
2587      the gdbarch_sp_regnum register is meaningful.  */
2588   if (gdbarch_sp_regnum (gdbarch) >= 0)
2589     return get_frame_register_unsigned (this_frame,
2590                                         gdbarch_sp_regnum (gdbarch));
2591   internal_error (__FILE__, __LINE__, _("Missing unwind SP method"));
2592 }
2593
2594 /* Return the reason why we can't unwind past FRAME.  */
2595
2596 enum unwind_stop_reason
2597 get_frame_unwind_stop_reason (struct frame_info *frame)
2598 {
2599   /* Fill-in STOP_REASON.  */
2600   get_prev_frame_always (frame);
2601   gdb_assert (frame->prev_p);
2602
2603   return frame->stop_reason;
2604 }
2605
2606 /* Return a string explaining REASON.  */
2607
2608 const char *
2609 unwind_stop_reason_to_string (enum unwind_stop_reason reason)
2610 {
2611   switch (reason)
2612     {
2613 #define SET(name, description) \
2614     case name: return _(description);
2615 #include "unwind_stop_reasons.def"
2616 #undef SET
2617
2618     default:
2619       internal_error (__FILE__, __LINE__,
2620                       "Invalid frame stop reason");
2621     }
2622 }
2623
2624 const char *
2625 frame_stop_reason_string (struct frame_info *fi)
2626 {
2627   gdb_assert (fi->prev_p);
2628   gdb_assert (fi->prev == NULL);
2629
2630   /* Return the specific string if we have one.  */
2631   if (fi->stop_string != NULL)
2632     return fi->stop_string;
2633
2634   /* Return the generic string if we have nothing better.  */
2635   return unwind_stop_reason_to_string (fi->stop_reason);
2636 }
2637
2638 /* Return the enum symbol name of REASON as a string, to use in debug
2639    output.  */
2640
2641 static const char *
2642 frame_stop_reason_symbol_string (enum unwind_stop_reason reason)
2643 {
2644   switch (reason)
2645     {
2646 #define SET(name, description) \
2647     case name: return #name;
2648 #include "unwind_stop_reasons.def"
2649 #undef SET
2650
2651     default:
2652       internal_error (__FILE__, __LINE__,
2653                       "Invalid frame stop reason");
2654     }
2655 }
2656
2657 /* Clean up after a failed (wrong unwinder) attempt to unwind past
2658    FRAME.  */
2659
2660 static void
2661 frame_cleanup_after_sniffer (void *arg)
2662 {
2663   struct frame_info *frame = arg;
2664
2665   /* The sniffer should not allocate a prologue cache if it did not
2666      match this frame.  */
2667   gdb_assert (frame->prologue_cache == NULL);
2668
2669   /* No sniffer should extend the frame chain; sniff based on what is
2670      already certain.  */
2671   gdb_assert (!frame->prev_p);
2672
2673   /* The sniffer should not check the frame's ID; that's circular.  */
2674   gdb_assert (!frame->this_id.p);
2675
2676   /* Clear cached fields dependent on the unwinder.
2677
2678      The previous PC is independent of the unwinder, but the previous
2679      function is not (see get_frame_address_in_block).  */
2680   frame->prev_func.p = 0;
2681   frame->prev_func.addr = 0;
2682
2683   /* Discard the unwinder last, so that we can easily find it if an assertion
2684      in this function triggers.  */
2685   frame->unwind = NULL;
2686 }
2687
2688 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
2689    Return a cleanup which should be called if unwinding fails, and
2690    discarded if it succeeds.  */
2691
2692 struct cleanup *
2693 frame_prepare_for_sniffer (struct frame_info *frame,
2694                            const struct frame_unwind *unwind)
2695 {
2696   gdb_assert (frame->unwind == NULL);
2697   frame->unwind = unwind;
2698   return make_cleanup (frame_cleanup_after_sniffer, frame);
2699 }
2700
2701 extern initialize_file_ftype _initialize_frame; /* -Wmissing-prototypes */
2702
2703 static struct cmd_list_element *set_backtrace_cmdlist;
2704 static struct cmd_list_element *show_backtrace_cmdlist;
2705
2706 static void
2707 set_backtrace_cmd (char *args, int from_tty)
2708 {
2709   help_list (set_backtrace_cmdlist, "set backtrace ", all_commands,
2710              gdb_stdout);
2711 }
2712
2713 static void
2714 show_backtrace_cmd (char *args, int from_tty)
2715 {
2716   cmd_show_list (show_backtrace_cmdlist, from_tty, "");
2717 }
2718
2719 void
2720 _initialize_frame (void)
2721 {
2722   obstack_init (&frame_cache_obstack);
2723
2724   frame_stash_create ();
2725
2726   observer_attach_target_changed (frame_observer_target_changed);
2727
2728   add_prefix_cmd ("backtrace", class_maintenance, set_backtrace_cmd, _("\
2729 Set backtrace specific variables.\n\
2730 Configure backtrace variables such as the backtrace limit"),
2731                   &set_backtrace_cmdlist, "set backtrace ",
2732                   0/*allow-unknown*/, &setlist);
2733   add_prefix_cmd ("backtrace", class_maintenance, show_backtrace_cmd, _("\
2734 Show backtrace specific variables\n\
2735 Show backtrace variables such as the backtrace limit"),
2736                   &show_backtrace_cmdlist, "show backtrace ",
2737                   0/*allow-unknown*/, &showlist);
2738
2739   add_setshow_boolean_cmd ("past-main", class_obscure,
2740                            &backtrace_past_main, _("\
2741 Set whether backtraces should continue past \"main\"."), _("\
2742 Show whether backtraces should continue past \"main\"."), _("\
2743 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2744 the backtrace at \"main\".  Set this variable if you need to see the rest\n\
2745 of the stack trace."),
2746                            NULL,
2747                            show_backtrace_past_main,
2748                            &set_backtrace_cmdlist,
2749                            &show_backtrace_cmdlist);
2750
2751   add_setshow_boolean_cmd ("past-entry", class_obscure,
2752                            &backtrace_past_entry, _("\
2753 Set whether backtraces should continue past the entry point of a program."),
2754                            _("\
2755 Show whether backtraces should continue past the entry point of a program."),
2756                            _("\
2757 Normally there are no callers beyond the entry point of a program, so GDB\n\
2758 will terminate the backtrace there.  Set this variable if you need to see\n\
2759 the rest of the stack trace."),
2760                            NULL,
2761                            show_backtrace_past_entry,
2762                            &set_backtrace_cmdlist,
2763                            &show_backtrace_cmdlist);
2764
2765   add_setshow_uinteger_cmd ("limit", class_obscure,
2766                             &backtrace_limit, _("\
2767 Set an upper bound on the number of backtrace levels."), _("\
2768 Show the upper bound on the number of backtrace levels."), _("\
2769 No more than the specified number of frames can be displayed or examined.\n\
2770 Literal \"unlimited\" or zero means no limit."),
2771                             NULL,
2772                             show_backtrace_limit,
2773                             &set_backtrace_cmdlist,
2774                             &show_backtrace_cmdlist);
2775
2776   /* Debug this files internals.  */
2777   add_setshow_zuinteger_cmd ("frame", class_maintenance, &frame_debug,  _("\
2778 Set frame debugging."), _("\
2779 Show frame debugging."), _("\
2780 When non-zero, frame specific internal debugging is enabled."),
2781                              NULL,
2782                              show_frame_debug,
2783                              &setdebuglist, &showdebuglist);
2784 }