gdb/frame.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Cache and manage frames for GDB, the GNU debugger.

  3.    Copyright (C) 1986-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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 "user-regs.h"
  27. #include "gdb_obstack.h"
  28. #include "dummy-frame.h"
  29. #include "sentinel-frame.h"
  30. #include "gdbcore.h"
  31. #include "annotate.h"
  32. #include "language.h"
  33. #include "frame-unwind.h"
  34. #include "frame-base.h"
  35. #include "command.h"
  36. #include "gdbcmd.h"
  37. #include "observer.h"
  38. #include "objfiles.h"
  39. #include "gdbthread.h"
  40. #include "block.h"
  41. #include "inline-frame.h"
  42. #include "tracepoint.h"
  43. #include "hashtab.h"
  44. #include "valprint.h"

  46. static struct frame_info *get_prev_frame_raw (struct frame_info *this_frame);
  47. static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason);

  49. /* Status of some values cached in the frame_info object.  */

  51. ‌enum cached_copy_status
  52. {
  53.   /* Value is unknown.  */
  54.   CC_UNKNOWN,

  56.   /* We have a value.  */
  57.   CC_VALUE,

  59.   /* Value was not saved.  */
  60.   CC_NOT_SAVED,

  62.   /* Value is unavailable.  */
  63.   CC_UNAVAILABLE
  64. };

  66. /* We keep a cache of stack frames, each of which is a "struct
  67.    frame_info".  The innermost one gets allocated (in
  68.    wait_for_inferior) each time the inferior stops; current_frame
  69.    points to it.  Additional frames get allocated (in get_prev_frame)
  70.    as needed, and are chained through the next and prev fields.  Any
  71.    time that the frame cache becomes invalid (most notably when we
  72.    execute something, but also if we change how we interpret the
  73.    frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
  74.    which reads new symbols)), we should call reinit_frame_cache.  */

  76. ‌struct frame_info
  77. {
  78.   /* Level of this frame.  The inner-most (youngest) frame is at level
  79.      0.  As you move towards the outer-most (oldest) frame, the level
  80.      increases.  This is a cached value.  It could just as easily be
  81.      computed by counting back from the selected frame to the inner
  82.      most frame.  */
  83.   /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
  84.      reserved to indicate a bogus frame - one that has been created
  85.      just to keep GDB happy (GDB always needs a frame).  For the
  86.      moment leave this as speculation.  */
  87.   int level;

  89.   /* The frame's program space.  */
  90.   struct program_space *pspace;

  92.   /* The frame's address space.  */
  93.   struct address_space *aspace;

  95.   /* The frame's low-level unwinder and corresponding cache.  The
  96.      low-level unwinder is responsible for unwinding register values
  97.      for the previous frame.  The low-level unwind methods are
  98.      selected based on the presence, or otherwise, of register unwind
  99.      information such as CFI.  */
  100.   void *prologue_cache;
  101.   const struct frame_unwind *unwind;

  103.   /* Cached copy of the previous frame's architecture.  */
  104.   struct
  105.   {
  106.     int p;
  107.     struct gdbarch *arch;
  108.   } prev_arch;

  110.   /* Cached copy of the previous frame's resume address.  */
  111.   struct {
  112.     enum cached_copy_status status;
  113.     CORE_ADDR value;
  114.   } prev_pc;

  116.   /* Cached copy of the previous frame's function address.  */
  117.   struct
  118.   {
  119.     CORE_ADDR addr;
  120.     int p;
  121.   } prev_func;

  123.   /* This frame's ID.  */
  124.   struct
  125.   {
  126.     int p;
  127.     struct frame_id value;
  128.   } this_id;

  130.   /* The frame's high-level base methods, and corresponding cache.
  131.      The high level base methods are selected based on the frame's
  132.      debug info.  */
  133.   const struct frame_base *base;
  134.   void *base_cache;

  136.   /* Pointers to the next (down, inner, younger) and previous (up,
  137.      outer, older) frame_info's in the frame cache.  */
  138.   struct frame_info *next; /* down, inner, younger */
  139.   int prev_p;
  140.   struct frame_info *prev; /* up, outer, older */

  142.   /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
  143.      could.  Only valid when PREV_P is set.  */
  144.   enum unwind_stop_reason stop_reason;

  146.   /* A frame specific string describing the STOP_REASON in more detail.
  147.      Only valid when PREV_P is set, but even then may still be NULL.  */
  148.   const char *stop_string;
  149. };

  151. /* A frame stash used to speed up frame lookups.  Create a hash table
  152.    to stash frames previously accessed from the frame cache for
  153.    quicker subsequent retrieval.  The hash table is emptied whenever
  154.    the frame cache is invalidated.  */

  156. ‌static htab_t frame_stash;

  158. /* Internal function to calculate a hash from the frame_id addresses,
  159.    using as many valid addresses as possible.  Frames below level 0
  160.    are not stored in the hash table.  */

  162. static hashval_t
  163. ‌frame_addr_hash (const void *ap)
  164. {
  165.   const struct frame_info *frame = ap;
  166.   const struct frame_id f_id = frame->this_id.value;
  167.   hashval_t hash = 0;

  169.   gdb_assert (f_id.stack_status != FID_STACK_INVALID
  170.               || f_id.code_addr_p
  171.               || f_id.special_addr_p);

  173.   if (f_id.stack_status == FID_STACK_VALID)
  174.     hash = iterative_hash (&f_id.stack_addr,
  175.                            sizeof (f_id.stack_addr), hash);
  176.   if (f_id.code_addr_p)
  177.     hash = iterative_hash (&f_id.code_addr,
  178.                            sizeof (f_id.code_addr), hash);
  179.   if (f_id.special_addr_p)
  180.     hash = iterative_hash (&f_id.special_addr,
  181.                            sizeof (f_id.special_addr), hash);

  183.   return hash;
  184. }

  186. /* Internal equality function for the hash table.  This function
  187.    defers equality operations to frame_id_eq.  */

  189. static int
  190. ‌frame_addr_hash_eq (const void *a, const void *b)
  191. {
  192.   const struct frame_info *f_entry = a;
  193.   const struct frame_info *f_element = b;

  195.   return frame_id_eq (f_entry->this_id.value,
  196.                       f_element->this_id.value);
  197. }

  199. /* Internal function to create the frame_stash hash table.  100 seems
  200.    to be a good compromise to start the hash table at.  */

  202. static void
  203. ‌frame_stash_create (void)
  204. {
  205.   frame_stash = htab_create (100,
  206.                              frame_addr_hash,
  207.                              frame_addr_hash_eq,
  208.                              NULL);
  209. }

  211. /* Internal function to add a frame to the frame_stash hash table.
  212.    Returns false if a frame with the same ID was already stashed, true
  213.    otherwise.  */

  215. static int
  216. ‌frame_stash_add (struct frame_info *frame)
  217. {
  218.   struct frame_info **slot;

  220.   /* Do not try to stash the sentinel frame.  */
  221.   gdb_assert (frame->level >= 0);

  223.   slot = (struct frame_info **) htab_find_slot (frame_stash,
  224.                                                 frame,
  225.                                                 INSERT);

  227.   /* If we already have a frame in the stack with the same id, we
  228.      either have a stack cycle (corrupted stack?), or some bug
  229.      elsewhere in GDB.  In any case, ignore the duplicate and return
  230.      an indication to the caller.  */
  231.   if (*slot != NULL)
  232.     return 0;

  234.   *slot = frame;
  235.   return 1;
  236. }

  238. /* Internal function to search the frame stash for an entry with the
  239.    given frame ID.  If found, return that frame.  Otherwise return
  240.    NULL.  */

  242. static struct frame_info *
  243. ‌frame_stash_find (struct frame_id id)
  244. {
  245.   struct frame_info dummy;
  246.   struct frame_info *frame;

  248.   dummy.this_id.value = id;
  249.   frame = htab_find (frame_stash, &dummy);
  250.   return frame;
  251. }

  253. /* Internal function to invalidate the frame stash by removing all
  254.    entries in it.  This only occurs when the frame cache is
  255.    invalidated.  */

  257. static void
  258. ‌frame_stash_invalidate (void)
  259. {
  260.   htab_empty (frame_stash);
  261. }

  263. /* Flag to control debugging.  */

  265. ‌unsigned int frame_debug;
  266. static void
  267. ‌show_frame_debug (struct ui_file *file, int from_tty,
  268.                   struct cmd_list_element *c, const char *value)
  269. {
  270.   fprintf_filtered (file, _("Frame debugging is %s.\n"), value);
  271. }

  273. /* Flag to indicate whether backtraces should stop at main et.al.  */

  275. ‌static int backtrace_past_main;
  276. static void
  277. ‌show_backtrace_past_main (struct ui_file *file, int from_tty,
  278.                           struct cmd_list_element *c, const char *value)
  279. {
  280.   fprintf_filtered (file,
  281.                     _("Whether backtraces should "
  282.                       "continue past \"main\" is %s.\n"),
  283.                     value);
  284. }

  286. ‌static int backtrace_past_entry;
  287. static void
  288. ‌show_backtrace_past_entry (struct ui_file *file, int from_tty,
  289.                            struct cmd_list_element *c, const char *value)
  290. {
  291.   fprintf_filtered (file, _("Whether backtraces should continue past the "
  292.                             "entry point of a program is %s.\n"),
  293.                     value);
  294. }

  296. ‌static unsigned int backtrace_limit = UINT_MAX;
  297. static void
  298. ‌show_backtrace_limit (struct ui_file *file, int from_tty,
  299.                       struct cmd_list_element *c, const char *value)
  300. {
  301.   fprintf_filtered (file,
  302.                     _("An upper bound on the number "
  303.                       "of backtrace levels is %s.\n"),
  304.                     value);
  305. }


  308. static void
  309. ‌fprint_field (struct ui_file *file, const char *name, int p, CORE_ADDR addr)
  310. {
  311.   if (p)
  312.     fprintf_unfiltered (file, "%s=%s", name, hex_string (addr));
  313.   else
  314.     fprintf_unfiltered (file, "!%s", name);
  315. }

  317. void
  318. ‌fprint_frame_id (struct ui_file *file, struct frame_id id)
  319. {
  320.   fprintf_unfiltered (file, "{");

  322.   if (id.stack_status == FID_STACK_INVALID)
  323.     fprintf_unfiltered (file, "!stack");
  324.   else if (id.stack_status == FID_STACK_UNAVAILABLE)
  325.     fprintf_unfiltered (file, "stack=<unavailable>");
  326.   else
  327.     fprintf_unfiltered (file, "stack=%s", hex_string (id.stack_addr));
  328.   fprintf_unfiltered (file, ",");

  330.   fprint_field (file, "code", id.code_addr_p, id.code_addr);
  331.   fprintf_unfiltered (file, ",");

  333.   fprint_field (file, "special", id.special_addr_p, id.special_addr);

  335.   if (id.artificial_depth)
  336.     fprintf_unfiltered (file, ",artificial=%d", id.artificial_depth);

  338.   fprintf_unfiltered (file, "}");
  339. }

  341. static void
  342. ‌fprint_frame_type (struct ui_file *file, enum frame_type type)
  343. {
  344.   switch (type)
  345.     {
  346.     case NORMAL_FRAME:
  347.       fprintf_unfiltered (file, "NORMAL_FRAME");
  348.       return;
  349.     case DUMMY_FRAME:
  350.       fprintf_unfiltered (file, "DUMMY_FRAME");
  351.       return;
  352.     case INLINE_FRAME:
  353.       fprintf_unfiltered (file, "INLINE_FRAME");
  354.       return;
  355.     case TAILCALL_FRAME:
  356.       fprintf_unfiltered (file, "TAILCALL_FRAME");
  357.       return;
  358.     case SIGTRAMP_FRAME:
  359.       fprintf_unfiltered (file, "SIGTRAMP_FRAME");
  360.       return;
  361.     case ARCH_FRAME:
  362.       fprintf_unfiltered (file, "ARCH_FRAME");
  363.       return;
  364.     case SENTINEL_FRAME:
  365.       fprintf_unfiltered (file, "SENTINEL_FRAME");
  366.       return;
  367.     default:
  368.       fprintf_unfiltered (file, "<unknown type>");
  369.       return;
  370.     };
  371. }

  373. static void
  374. ‌fprint_frame (struct ui_file *file, struct frame_info *fi)
  375. {
  376.   if (fi == NULL)
  377.     {
  378.       fprintf_unfiltered (file, "<NULL frame>");
  379.       return;
  380.     }
  381.   fprintf_unfiltered (file, "{");
  382.   fprintf_unfiltered (file, "level=%d", fi->level);
  383.   fprintf_unfiltered (file, ",");
  384.   fprintf_unfiltered (file, "type=");
  385.   if (fi->unwind != NULL)
  386.     fprint_frame_type (file, fi->unwind->type);
  387.   else
  388.     fprintf_unfiltered (file, "<unknown>");
  389.   fprintf_unfiltered (file, ",");
  390.   fprintf_unfiltered (file, "unwind=");
  391.   if (fi->unwind != NULL)
  392.     gdb_print_host_address (fi->unwind, file);
  393.   else
  394.     fprintf_unfiltered (file, "<unknown>");
  395.   fprintf_unfiltered (file, ",");
  396.   fprintf_unfiltered (file, "pc=");
  397.   if (fi->next == NULL || fi->next->prev_pc.status == CC_UNKNOWN)
  398.     fprintf_unfiltered (file, "<unknown>");
  399.   else if (fi->next->prev_pc.status == CC_VALUE)
  400.     fprintf_unfiltered (file, "%s",
  401.                         hex_string (fi->next->prev_pc.value));
  402.   else if (fi->next->prev_pc.status == CC_NOT_SAVED)
  403.     val_print_not_saved (file);
  404.   else if (fi->next->prev_pc.status == CC_UNAVAILABLE)
  405.     val_print_unavailable (file);
  406.   fprintf_unfiltered (file, ",");
  407.   fprintf_unfiltered (file, "id=");
  408.   if (fi->this_id.p)
  409.     fprint_frame_id (file, fi->this_id.value);
  410.   else
  411.     fprintf_unfiltered (file, "<unknown>");
  412.   fprintf_unfiltered (file, ",");
  413.   fprintf_unfiltered (file, "func=");
  414.   if (fi->next != NULL && fi->next->prev_func.p)
  415.     fprintf_unfiltered (file, "%s", hex_string (fi->next->prev_func.addr));
  416.   else
  417.     fprintf_unfiltered (file, "<unknown>");
  418.   fprintf_unfiltered (file, "}");
  419. }

  421. /* Given FRAME, return the enclosing frame as found in real frames read-in from
  422.    inferior memory.  Skip any previous frames which were made up by GDB.
  423.    Return the original frame if no immediate previous frames exist.  */

  425. static struct frame_info *
  426. ‌skip_artificial_frames (struct frame_info *frame)
  427. {
  428.   /* Note we use get_prev_frame_always, and not get_prev_frame.  The
  429.      latter will truncate the frame chain, leading to this function
  430.      unintentionally returning a null_frame_id (e.g., when the user
  431.      sets a backtrace limit).  This is safe, because as these frames
  432.      are made up by GDB, there must be a real frame in the chain
  433.      below.  */
  434.   while (get_frame_type (frame) == INLINE_FRAME
  435.          || get_frame_type (frame) == TAILCALL_FRAME)
  436.     frame = get_prev_frame_always (frame);

  438.   return frame;
  439. }

  441. /* Compute the frame's uniq ID that can be used to, later, re-find the
  442.    frame.  */

  444. static void
  445. ‌compute_frame_id (struct frame_info *fi)
  446. {
  447.   gdb_assert (!fi->this_id.p);

  449.   if (frame_debug)
  450.     fprintf_unfiltered (gdb_stdlog, "{ compute_frame_id (fi=%d) ",
  451.                         fi->level);
  452.   /* Find the unwinder.  */
  453.   if (fi->unwind == NULL)
  454.     frame_unwind_find_by_frame (fi, &fi->prologue_cache);
  455.   /* Find THIS frame's ID.  */
  456.   /* Default to outermost if no ID is found.  */
  457.   fi->this_id.value = outer_frame_id;
  458.   fi->unwind->this_id (fi, &fi->prologue_cache, &fi->this_id.value);
  459.   gdb_assert (frame_id_p (fi->this_id.value));
  460.   fi->this_id.p = 1;
  461.   if (frame_debug)
  462.     {
  463.       fprintf_unfiltered (gdb_stdlog, "-> ");
  464.       fprint_frame_id (gdb_stdlog, fi->this_id.value);
  465.       fprintf_unfiltered (gdb_stdlog, " }\n");
  466.     }
  467. }

  469. /* Return a frame uniq ID that can be used to, later, re-find the
  470.    frame.  */

  472. struct frame_id
  473. ‌get_frame_id (struct frame_info *fi)
  474. {
  475.   if (fi == NULL)
  476.     return null_frame_id;

  478.   gdb_assert (fi->this_id.p);
  479.   return fi->this_id.value;
  480. }

  482. struct frame_id
  483. ‌get_stack_frame_id (struct frame_info *next_frame)
  484. {
  485.   return get_frame_id (skip_artificial_frames (next_frame));
  486. }

  488. struct frame_id
  489. ‌frame_unwind_caller_id (struct frame_info *next_frame)
  490. {
  491.   struct frame_info *this_frame;

  493.   /* Use get_prev_frame_always, and not get_prev_frame.  The latter
  494.      will truncate the frame chain, leading to this function
  495.      unintentionally returning a null_frame_id (e.g., when a caller
  496.      requests the frame ID of "main()"s caller.  */

  498.   next_frame = skip_artificial_frames (next_frame);
  499.   this_frame = get_prev_frame_always (next_frame);
  500.   if (this_frame)
  501.     return get_frame_id (skip_artificial_frames (this_frame));
  502.   else
  503.     return null_frame_id;
  504. }

  506. ‌const struct frame_id null_frame_id; /* All zeros.  */
  507. ‌const struct frame_id outer_frame_id = { 0, 0, 0, FID_STACK_INVALID, 0, 1, 0 };

  509. struct frame_id
  510. ‌frame_id_build_special (CORE_ADDR stack_addr, CORE_ADDR code_addr,
  511.                         CORE_ADDR special_addr)
  512. {
  513.   struct frame_id id = null_frame_id;

  515.   id.stack_addr = stack_addr;
  516.   id.stack_status = FID_STACK_VALID;
  517.   id.code_addr = code_addr;
  518.   id.code_addr_p = 1;
  519.   id.special_addr = special_addr;
  520.   id.special_addr_p = 1;
  521.   return id;
  522. }

  524. /* See frame.h.  */

  526. struct frame_id
  527. ‌frame_id_build_unavailable_stack (CORE_ADDR code_addr)
  528. {
  529.   struct frame_id id = null_frame_id;

  531.   id.stack_status = FID_STACK_UNAVAILABLE;
  532.   id.code_addr = code_addr;
  533.   id.code_addr_p = 1;
  534.   return id;
  535. }

  537. /* See frame.h.  */

  539. struct frame_id
  540. ‌frame_id_build_unavailable_stack_special (CORE_ADDR code_addr,
  541.                                           CORE_ADDR special_addr)
  542. {
  543.   struct frame_id id = null_frame_id;

  545.   id.stack_status = FID_STACK_UNAVAILABLE;
  546.   id.code_addr = code_addr;
  547.   id.code_addr_p = 1;
  548.   id.special_addr = special_addr;
  549.   id.special_addr_p = 1;
  550.   return id;
  551. }

  553. struct frame_id
  554. ‌frame_id_build (CORE_ADDR stack_addr, CORE_ADDR code_addr)
  555. {
  556.   struct frame_id id = null_frame_id;

  558.   id.stack_addr = stack_addr;
  559.   id.stack_status = FID_STACK_VALID;
  560.   id.code_addr = code_addr;
  561.   id.code_addr_p = 1;
  562.   return id;
  563. }

  565. struct frame_id
  566. ‌frame_id_build_wild (CORE_ADDR stack_addr)
  567. {
  568.   struct frame_id id = null_frame_id;

  570.   id.stack_addr = stack_addr;
  571.   id.stack_status = FID_STACK_VALID;
  572.   return id;
  573. }

  575. int
  576. ‌frame_id_p (struct frame_id l)
  577. {
  578.   int p;

  580.   /* The frame is valid iff it has a valid stack address.  */
  581.   p = l.stack_status != FID_STACK_INVALID;
  582.   /* outer_frame_id is also valid.  */
  583.   if (!p && memcmp (&l, &outer_frame_id, sizeof (l)) == 0)
  584.     p = 1;
  585.   if (frame_debug)
  586.     {
  587.       fprintf_unfiltered (gdb_stdlog, "{ frame_id_p (l=");
  588.       fprint_frame_id (gdb_stdlog, l);
  589.       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", p);
  590.     }
  591.   return p;
  592. }

  594. int
  595. ‌frame_id_artificial_p (struct frame_id l)
  596. {
  597.   if (!frame_id_p (l))
  598.     return 0;

  600.   return (l.artificial_depth != 0);
  601. }

  603. int
  604. ‌frame_id_eq (struct frame_id l, struct frame_id r)
  605. {
  606.   int eq;

  608.   if (l.stack_status == FID_STACK_INVALID && l.special_addr_p
  609.       && r.stack_status == FID_STACK_INVALID && r.special_addr_p)
  610.     /* The outermost frame marker is equal to itself.  This is the
  611.        dodgy thing about outer_frame_id, since between execution steps
  612.        we might step into another function - from which we can't
  613.        unwind either.  More thought required to get rid of
  614.        outer_frame_id.  */
  615.     eq = 1;
  616.   else if (l.stack_status == FID_STACK_INVALID
  617.            || r.stack_status == FID_STACK_INVALID)
  618.     /* Like a NaN, if either ID is invalid, the result is false.
  619.        Note that a frame ID is invalid iff it is the null frame ID.  */
  620.     eq = 0;
  621.   else if (l.stack_status != r.stack_status || l.stack_addr != r.stack_addr)
  622.     /* If .stack addresses are different, the frames are different.  */
  623.     eq = 0;
  624.   else if (l.code_addr_p && r.code_addr_p && l.code_addr != r.code_addr)
  625.     /* An invalid code addr is a wild card.  If .code addresses are
  626.        different, the frames are different.  */
  627.     eq = 0;
  628.   else if (l.special_addr_p && r.special_addr_p
  629.            && l.special_addr != r.special_addr)
  630.     /* An invalid special addr is a wild card (or unused).  Otherwise
  631.        if special addresses are different, the frames are different.  */
  632.     eq = 0;
  633.   else if (l.artificial_depth != r.artificial_depth)
  634.     /* If artifical depths are different, the frames must be different.  */
  635.     eq = 0;
  636.   else
  637.     /* Frames are equal.  */
  638.     eq = 1;

  640.   if (frame_debug)
  641.     {
  642.       fprintf_unfiltered (gdb_stdlog, "{ frame_id_eq (l=");
  643.       fprint_frame_id (gdb_stdlog, l);
  644.       fprintf_unfiltered (gdb_stdlog, ",r=");
  645.       fprint_frame_id (gdb_stdlog, r);
  646.       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", eq);
  647.     }
  648.   return eq;
  649. }

  651. /* Safety net to check whether frame ID L should be inner to
  652.    frame ID R, according to their stack addresses.

  654.    This method cannot be used to compare arbitrary frames, as the
  655.    ranges of valid stack addresses may be discontiguous (e.g. due
  656.    to sigaltstack).

  658.    However, it can be used as safety net to discover invalid frame
  659.    IDs in certain circumstances.  Assuming that NEXT is the immediate
  660.    inner frame to THIS and that NEXT and THIS are both NORMAL frames:

  662.    * The stack address of NEXT must be inner-than-or-equal to the stack
  663.      address of THIS.

  665.      Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
  666.      error has occurred.

  668.    * If NEXT and THIS have different stack addresses, no other frame
  669.      in the frame chain may have a stack address in between.

  671.      Therefore, if frame_id_inner (TEST, THIS) holds, but
  672.      frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
  673.      to a valid frame in the frame chain.

  675.    The sanity checks above cannot be performed when a SIGTRAMP frame
  676.    is involved, because signal handlers might be executed on a different
  677.    stack than the stack used by the routine that caused the signal
  678.    to be raised.  This can happen for instance when a thread exceeds
  679.    its maximum stack size.  In this case, certain compilers implement
  680.    a stack overflow strategy that cause the handler to be run on a
  681.    different stack.  */

  683. static int
  684. ‌frame_id_inner (struct gdbarch *gdbarch, struct frame_id l, struct frame_id r)
  685. {
  686.   int inner;

  688.   if (l.stack_status != FID_STACK_VALID || r.stack_status != FID_STACK_VALID)
  689.     /* Like NaN, any operation involving an invalid ID always fails.
  690.        Likewise if either ID has an unavailable stack address.  */
  691.     inner = 0;
  692.   else if (l.artificial_depth > r.artificial_depth
  693.            && l.stack_addr == r.stack_addr
  694.            && l.code_addr_p == r.code_addr_p
  695.            && l.special_addr_p == r.special_addr_p
  696.            && l.special_addr == r.special_addr)
  697.     {
  698.       /* Same function, different inlined functions.  */
  699.       const struct block *lb, *rb;

  701.       gdb_assert (l.code_addr_p && r.code_addr_p);

  703.       lb = block_for_pc (l.code_addr);
  704.       rb = block_for_pc (r.code_addr);

  706.       if (lb == NULL || rb == NULL)
  707.         /* Something's gone wrong.  */
  708.         inner = 0;
  709.       else
  710.         /* This will return true if LB and RB are the same block, or
  711.            if the block with the smaller depth lexically encloses the
  712.            block with the greater depth.  */
  713.         inner = contained_in (lb, rb);
  714.     }
  715.   else
  716.     /* Only return non-zero when strictly inner than.  Note that, per
  717.        comment in "frame.h", there is some fuzz here.  Frameless
  718.        functions are not strictly inner than (same .stack but
  719.        different .code and/or .special address).  */
  720.     inner = gdbarch_inner_than (gdbarch, l.stack_addr, r.stack_addr);
  721.   if (frame_debug)
  722.     {
  723.       fprintf_unfiltered (gdb_stdlog, "{ frame_id_inner (l=");
  724.       fprint_frame_id (gdb_stdlog, l);
  725.       fprintf_unfiltered (gdb_stdlog, ",r=");
  726.       fprint_frame_id (gdb_stdlog, r);
  727.       fprintf_unfiltered (gdb_stdlog, ") -> %d }\n", inner);
  728.     }
  729.   return inner;
  730. }

  732. struct frame_info *
  733. ‌frame_find_by_id (struct frame_id id)
  734. {
  735.   struct frame_info *frame, *prev_frame;

  737.   /* ZERO denotes the null frame, let the caller decide what to do
  738.      about it.  Should it instead return get_current_frame()?  */
  739.   if (!frame_id_p (id))
  740.     return NULL;

  742.   /* Try using the frame stash first.  Finding it there removes the need
  743.      to perform the search by looping over all frames, which can be very
  744.      CPU-intensive if the number of frames is very high (the loop is O(n)
  745.      and get_prev_frame performs a series of checks that are relatively
  746.      expensive).  This optimization is particularly useful when this function
  747.      is called from another function (such as value_fetch_lazy, case
  748.      VALUE_LVAL (val) == lval_register) which already loops over all frames,
  749.      making the overall behavior O(n^2).  */
  750.   frame = frame_stash_find (id);
  751.   if (frame)
  752.     return frame;

  754.   for (frame = get_current_frame (); ; frame = prev_frame)
  755.     {
  756.       struct frame_id this = get_frame_id (frame);

  758.       if (frame_id_eq (id, this))
  759.         /* An exact match.  */
  760.         return frame;

  762.       prev_frame = get_prev_frame (frame);
  763.       if (!prev_frame)
  764.         return NULL;

  766.       /* As a safety net to avoid unnecessary backtracing while trying
  767.          to find an invalid ID, we check for a common situation where
  768.          we can detect from comparing stack addresses that no other
  769.          frame in the current frame chain can have this ID.  See the
  770.          comment at frame_id_inner for details.   */
  771.       if (get_frame_type (frame) == NORMAL_FRAME
  772.           && !frame_id_inner (get_frame_arch (frame), id, this)
  773.           && frame_id_inner (get_frame_arch (prev_frame), id,
  774.                              get_frame_id (prev_frame)))
  775.         return NULL;
  776.     }
  777.   return NULL;
  778. }

  780. static CORE_ADDR
  781. ‌frame_unwind_pc (struct frame_info *this_frame)
  782. {
  783.   if (this_frame->prev_pc.status == CC_UNKNOWN)
  784.     {
  785.       if (gdbarch_unwind_pc_p (frame_unwind_arch (this_frame)))
  786.         {
  787.           volatile struct gdb_exception ex;
  788.           struct gdbarch *prev_gdbarch;
  789.           CORE_ADDR pc = 0;

  791.           /* The right way.  The `pure' way.  The one true way.  This
  792.              method depends solely on the register-unwind code to
  793.              determine the value of registers in THIS frame, and hence
  794.              the value of this frame's PC (resume address).  A typical
  795.              implementation is no more than:

  797.              frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
  798.              return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);

  800.              Note: this method is very heavily dependent on a correct
  801.              register-unwind implementation, it pays to fix that
  802.              method first; this method is frame type agnostic, since
  803.              it only deals with register values, it works with any
  804.              frame.  This is all in stark contrast to the old
  805.              FRAME_SAVED_PC which would try to directly handle all the
  806.              different ways that a PC could be unwound.  */
  807.           prev_gdbarch = frame_unwind_arch (this_frame);

  809.           TRY_CATCH (ex, RETURN_MASK_ERROR)
  810.             {
  811.               pc = gdbarch_unwind_pc (prev_gdbarch, this_frame);
  812.             }
  813.           if (ex.reason < 0)
  814.             {
  815.               if (ex.error == NOT_AVAILABLE_ERROR)
  816.                 {
  817.                   this_frame->prev_pc.status = CC_UNAVAILABLE;

  819.                   if (frame_debug)
  820.                     fprintf_unfiltered (gdb_stdlog,
  821.                                         "{ frame_unwind_pc (this_frame=%d)"
  822.                                         " -> <unavailable> }\n",
  823.                                         this_frame->level);
  824.                 }
  825.               else if (ex.error == OPTIMIZED_OUT_ERROR)
  826.                 {
  827.                   this_frame->prev_pc.status = CC_NOT_SAVED;

  829.                   if (frame_debug)
  830.                     fprintf_unfiltered (gdb_stdlog,
  831.                                         "{ frame_unwind_pc (this_frame=%d)"
  832.                                         " -> <not saved> }\n",
  833.                                         this_frame->level);
  834.                 }
  835.               else
  836.                 throw_exception (ex);
  837.             }
  838.           else
  839.             {
  840.               this_frame->prev_pc.value = pc;
  841.               this_frame->prev_pc.status = CC_VALUE;
  842.               if (frame_debug)
  843.                 fprintf_unfiltered (gdb_stdlog,
  844.                                     "{ frame_unwind_pc (this_frame=%d) "
  845.                                     "-> %s }\n",
  846.                                     this_frame->level,
  847.                                     hex_string (this_frame->prev_pc.value));
  848.             }
  849.         }
  850.       else
  851.         internal_error (__FILE__, __LINE__, _("No unwind_pc method"));
  852.     }

  854.   if (this_frame->prev_pc.status == CC_VALUE)
  855.     return this_frame->prev_pc.value;
  856.   else if (this_frame->prev_pc.status == CC_UNAVAILABLE)
  857.     throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));
  858.   else if (this_frame->prev_pc.status == CC_NOT_SAVED)
  859.     throw_error (OPTIMIZED_OUT_ERROR, _("PC not saved"));
  860.   else
  861.     internal_error (__FILE__, __LINE__,
  862.                     "unexpected prev_pc status: %d",
  863.                     (int) this_frame->prev_pc.status);
  864. }

  866. CORE_ADDR
  867. ‌frame_unwind_caller_pc (struct frame_info *this_frame)
  868. {
  869.   return frame_unwind_pc (skip_artificial_frames (this_frame));
  870. }

  872. int
  873. ‌get_frame_func_if_available (struct frame_info *this_frame, CORE_ADDR *pc)
  874. {
  875.   struct frame_info *next_frame = this_frame->next;

  877.   if (!next_frame->prev_func.p)
  878.     {
  879.       CORE_ADDR addr_in_block;

  881.       /* Make certain that this, and not the adjacent, function is
  882.          found.  */
  883.       if (!get_frame_address_in_block_if_available (this_frame, &addr_in_block))
  884.         {
  885.           next_frame->prev_func.p = -1;
  886.           if (frame_debug)
  887.             fprintf_unfiltered (gdb_stdlog,
  888.                                 "{ get_frame_func (this_frame=%d)"
  889.                                 " -> unavailable }\n",
  890.                                 this_frame->level);
  891.         }
  892.       else
  893.         {
  894.           next_frame->prev_func.p = 1;
  895.           next_frame->prev_func.addr = get_pc_function_start (addr_in_block);
  896.           if (frame_debug)
  897.             fprintf_unfiltered (gdb_stdlog,
  898.                                 "{ get_frame_func (this_frame=%d) -> %s }\n",
  899.                                 this_frame->level,
  900.                                 hex_string (next_frame->prev_func.addr));
  901.         }
  902.     }

  904.   if (next_frame->prev_func.p < 0)
  905.     {
  906.       *pc = -1;
  907.       return 0;
  908.     }
  909.   else
  910.     {
  911.       *pc = next_frame->prev_func.addr;
  912.       return 1;
  913.     }
  914. }

  916. CORE_ADDR
  917. ‌get_frame_func (struct frame_info *this_frame)
  918. {
  919.   CORE_ADDR pc;

  921.   if (!get_frame_func_if_available (this_frame, &pc))
  922.     throw_error (NOT_AVAILABLE_ERROR, _("PC not available"));

  924.   return pc;
  925. }

  927. static enum register_status
  928. ‌do_frame_register_read (void *src, int regnum, gdb_byte *buf)
  929. {
  930.   if (!deprecated_frame_register_read (src, regnum, buf))
  931.     return REG_UNAVAILABLE;
  932.   else
  933.     return REG_VALID;
  934. }

  936. struct regcache *
  937. ‌frame_save_as_regcache (struct frame_info *this_frame)
  938. {
  939.   struct address_space *aspace = get_frame_address_space (this_frame);
  940.   struct regcache *regcache = regcache_xmalloc (get_frame_arch (this_frame),
  941.                                                 aspace);
  942.   struct cleanup *cleanups = make_cleanup_regcache_xfree (regcache);

  944.   regcache_save (regcache, do_frame_register_read, this_frame);
  945.   discard_cleanups (cleanups);
  946.   return regcache;
  947. }

  949. void
  950. ‌frame_pop (struct frame_info *this_frame)
  951. {
  952.   struct frame_info *prev_frame;
  953.   struct regcache *scratch;
  954.   struct cleanup *cleanups;

  956.   if (get_frame_type (this_frame) == DUMMY_FRAME)
  957.     {
  958.       /* Popping a dummy frame involves restoring more than just registers.
  959.          dummy_frame_pop does all the work.  */
  960.       dummy_frame_pop (get_frame_id (this_frame), inferior_ptid);
  961.       return;
  962.     }

  964.   /* Ensure that we have a frame to pop to.  */
  965.   prev_frame = get_prev_frame_always (this_frame);

  967.   if (!prev_frame)
  968.     error (_("Cannot pop the initial frame."));

  970.   /* Ignore TAILCALL_FRAME type frames, they were executed already before
  971.      entering THISFRAME.  */
  972.   while (get_frame_type (prev_frame) == TAILCALL_FRAME)
  973.     prev_frame = get_prev_frame (prev_frame);

  975.   /* Make a copy of all the register values unwound from this frame.
  976.      Save them in a scratch buffer so that there isn't a race between
  977.      trying to extract the old values from the current regcache while
  978.      at the same time writing new values into that same cache.  */
  979.   scratch = frame_save_as_regcache (prev_frame);
  980.   cleanups = make_cleanup_regcache_xfree (scratch);

  982.   /* FIXME: cagney/2003-03-16: It should be possible to tell the
  983.      target's register cache that it is about to be hit with a burst
  984.      register transfer and that the sequence of register writes should
  985.      be batched.  The pair target_prepare_to_store() and
  986.      target_store_registers() kind of suggest this functionality.
  987.      Unfortunately, they don't implement it.  Their lack of a formal
  988.      definition can lead to targets writing back bogus values
  989.      (arguably a bug in the target code mind).  */
  990.   /* Now copy those saved registers into the current regcache.
  991.      Here, regcache_cpy() calls regcache_restore().  */
  992.   regcache_cpy (get_current_regcache (), scratch);
  993.   do_cleanups (cleanups);

  995.   /* We've made right mess of GDB's local state, just discard
  996.      everything.  */
  997.   reinit_frame_cache ();
  998. }

  1000. void
  1001. ‌frame_register_unwind (struct frame_info *frame, int regnum,
  1002.                        int *optimizedp, int *unavailablep,
  1003.                        enum lval_type *lvalp, CORE_ADDR *addrp,
  1004.                        int *realnump, gdb_byte *bufferp)
  1005. {
  1006.   struct value *value;

  1008.   /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
  1009.      that the value proper does not need to be fetched.  */
  1010.   gdb_assert (optimizedp != NULL);
  1011.   gdb_assert (lvalp != NULL);
  1012.   gdb_assert (addrp != NULL);
  1013.   gdb_assert (realnump != NULL);
  1014.   /* gdb_assert (bufferp != NULL); */

  1016.   value = frame_unwind_register_value (frame, regnum);

  1018.   gdb_assert (value != NULL);

  1020.   *optimizedp = value_optimized_out (value);
  1021.   *unavailablep = !value_entirely_available (value);
  1022.   *lvalp = VALUE_LVAL (value);
  1023.   *addrp = value_address (value);
  1024.   *realnump = VALUE_REGNUM (value);

  1026.   if (bufferp)
  1027.     {
  1028.       if (!*optimizedp && !*unavailablep)
  1029.         memcpy (bufferp, value_contents_all (value),
  1030.                 TYPE_LENGTH (value_type (value)));
  1031.       else
  1032.         memset (bufferp, 0, TYPE_LENGTH (value_type (value)));
  1033.     }

  1035.   /* Dispose of the new value.  This prevents watchpoints from
  1036.      trying to watch the saved frame pointer.  */
  1037.   release_value (value);
  1038.   value_free (value);
  1039. }

  1041. void
  1042. ‌frame_register (struct frame_info *frame, int regnum,
  1043.                 int *optimizedp, int *unavailablep, enum lval_type *lvalp,
  1044.                 CORE_ADDR *addrp, int *realnump, gdb_byte *bufferp)
  1045. {
  1046.   /* Require all but BUFFERP to be valid.  A NULL BUFFERP indicates
  1047.      that the value proper does not need to be fetched.  */
  1048.   gdb_assert (optimizedp != NULL);
  1049.   gdb_assert (lvalp != NULL);
  1050.   gdb_assert (addrp != NULL);
  1051.   gdb_assert (realnump != NULL);
  1052.   /* gdb_assert (bufferp != NULL); */

  1054.   /* Obtain the register value by unwinding the register from the next
  1055.      (more inner frame).  */
  1056.   gdb_assert (frame != NULL && frame->next != NULL);
  1057.   frame_register_unwind (frame->next, regnum, optimizedp, unavailablep,
  1058.                          lvalp, addrp, realnump, bufferp);
  1059. }

  1061. void
  1062. ‌frame_unwind_register (struct frame_info *frame, int regnum, gdb_byte *buf)
  1063. {
  1064.   int optimized;
  1065.   int unavailable;
  1066.   CORE_ADDR addr;
  1067.   int realnum;
  1068.   enum lval_type lval;

  1070.   frame_register_unwind (frame, regnum, &optimized, &unavailable,
  1071.                          &lval, &addr, &realnum, buf);

  1073.   if (optimized)
  1074.     throw_error (OPTIMIZED_OUT_ERROR,
  1075.                  _("Register %d was not saved"), regnum);
  1076.   if (unavailable)
  1077.     throw_error (NOT_AVAILABLE_ERROR,
  1078.                  _("Register %d is not available"), regnum);
  1079. }

  1081. void
  1082. ‌get_frame_register (struct frame_info *frame,
  1083.                     int regnum, gdb_byte *buf)
  1084. {
  1085.   frame_unwind_register (frame->next, regnum, buf);
  1086. }

  1088. struct value *
  1089. ‌frame_unwind_register_value (struct frame_info *frame, int regnum)
  1090. {
  1091.   struct gdbarch *gdbarch;
  1092.   struct value *value;

  1094.   gdb_assert (frame != NULL);
  1095.   gdbarch = frame_unwind_arch (frame);

  1097.   if (frame_debug)
  1098.     {
  1099.       fprintf_unfiltered (gdb_stdlog,
  1100.                           "{ frame_unwind_register_value "
  1101.                           "(frame=%d,regnum=%d(%s),...) ",
  1102.                           frame->level, regnum,
  1103.                           user_reg_map_regnum_to_name (gdbarch, regnum));
  1104.     }

  1106.   /* Find the unwinder.  */
  1107.   if (frame->unwind == NULL)
  1108.     frame_unwind_find_by_frame (frame, &frame->prologue_cache);

  1110.   /* Ask this frame to unwind its register.  */
  1111.   value = frame->unwind->prev_register (frame, &frame->prologue_cache, regnum);

  1113.   if (frame_debug)
  1114.     {
  1115.       fprintf_unfiltered (gdb_stdlog, "->");
  1116.       if (value_optimized_out (value))
  1117.         {
  1118.           fprintf_unfiltered (gdb_stdlog, " ");
  1119.           val_print_optimized_out (value, gdb_stdlog);
  1120.         }
  1121.       else
  1122.         {
  1123.           if (VALUE_LVAL (value) == lval_register)
  1124.             fprintf_unfiltered (gdb_stdlog, " register=%d",
  1125.                                 VALUE_REGNUM (value));
  1126.           else if (VALUE_LVAL (value) == lval_memory)
  1127.             fprintf_unfiltered (gdb_stdlog, " address=%s",
  1128.                                 paddress (gdbarch,
  1129.                                           value_address (value)));
  1130.           else
  1131.             fprintf_unfiltered (gdb_stdlog, " computed");

  1133.           if (value_lazy (value))
  1134.             fprintf_unfiltered (gdb_stdlog, " lazy");
  1135.           else
  1136.             {
  1137.               int i;
  1138.               const gdb_byte *buf = value_contents (value);

  1140.               fprintf_unfiltered (gdb_stdlog, " bytes=");
  1141.               fprintf_unfiltered (gdb_stdlog, "[");
  1142.               for (i = 0; i < register_size (gdbarch, regnum); i++)
  1143.                 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
  1144.               fprintf_unfiltered (gdb_stdlog, "]");
  1145.             }
  1146.         }

  1148.       fprintf_unfiltered (gdb_stdlog, " }\n");
  1149.     }

  1151.   return value;
  1152. }

  1154. struct value *
  1155. ‌get_frame_register_value (struct frame_info *frame, int regnum)
  1156. {
  1157.   return frame_unwind_register_value (frame->next, regnum);
  1158. }

  1160. LONGEST
  1161. ‌frame_unwind_register_signed (struct frame_info *frame, int regnum)
  1162. {
  1163.   struct gdbarch *gdbarch = frame_unwind_arch (frame);
  1164.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  1165.   int size = register_size (gdbarch, regnum);
  1166.   gdb_byte buf[MAX_REGISTER_SIZE];

  1168.   frame_unwind_register (frame, regnum, buf);
  1169.   return extract_signed_integer (buf, size, byte_order);
  1170. }

  1172. LONGEST
  1173. ‌get_frame_register_signed (struct frame_info *frame, int regnum)
  1174. {
  1175.   return frame_unwind_register_signed (frame->next, regnum);
  1176. }

  1178. ULONGEST
  1179. ‌frame_unwind_register_unsigned (struct frame_info *frame, int regnum)
  1180. {
  1181.   struct gdbarch *gdbarch = frame_unwind_arch (frame);
  1182.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  1183.   int size = register_size (gdbarch, regnum);
  1184.   gdb_byte buf[MAX_REGISTER_SIZE];

  1186.   frame_unwind_register (frame, regnum, buf);
  1187.   return extract_unsigned_integer (buf, size, byte_order);
  1188. }

  1190. ULONGEST
  1191. ‌get_frame_register_unsigned (struct frame_info *frame, int regnum)
  1192. {
  1193.   return frame_unwind_register_unsigned (frame->next, regnum);
  1194. }

  1196. int
  1197. ‌read_frame_register_unsigned (struct frame_info *frame, int regnum,
  1198.                               ULONGEST *val)
  1199. {
  1200.   struct value *regval = get_frame_register_value (frame, regnum);

  1202.   if (!value_optimized_out (regval)
  1203.       && value_entirely_available (regval))
  1204.     {
  1205.       struct gdbarch *gdbarch = get_frame_arch (frame);
  1206.       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  1207.       int size = register_size (gdbarch, VALUE_REGNUM (regval));

  1209.       *val = extract_unsigned_integer (value_contents (regval), size, byte_order);
  1210.       return 1;
  1211.     }

  1213.   return 0;
  1214. }

  1216. void
  1217. ‌put_frame_register (struct frame_info *frame, int regnum,
  1218.                     const gdb_byte *buf)
  1219. {
  1220.   struct gdbarch *gdbarch = get_frame_arch (frame);
  1221.   int realnum;
  1222.   int optim;
  1223.   int unavail;
  1224.   enum lval_type lval;
  1225.   CORE_ADDR addr;

  1227.   frame_register (frame, regnum, &optim, &unavail,
  1228.                   &lval, &addr, &realnum, NULL);
  1229.   if (optim)
  1230.     error (_("Attempt to assign to a register that was not saved."));
  1231.   switch (lval)
  1232.     {
  1233.     case lval_memory:
  1234.       {
  1235.         write_memory (addr, buf, register_size (gdbarch, regnum));
  1236.         break;
  1237.       }
  1238.     case lval_register:
  1239.       regcache_cooked_write (get_current_regcache (), realnum, buf);
  1240.       break;
  1241.     default:
  1242.       error (_("Attempt to assign to an unmodifiable value."));
  1243.     }
  1244. }

  1246. /* This function is deprecated.  Use get_frame_register_value instead,
  1247.    which provides more accurate information.

  1249.    Find and return the value of REGNUM for the specified stack frame.
  1250.    The number of bytes copied is REGISTER_SIZE (REGNUM).

  1252.    Returns 0 if the register value could not be found.  */

  1254. int
  1255. ‌deprecated_frame_register_read (struct frame_info *frame, int regnum,
  1256.                      gdb_byte *myaddr)
  1257. {
  1258.   int optimized;
  1259.   int unavailable;
  1260.   enum lval_type lval;
  1261.   CORE_ADDR addr;
  1262.   int realnum;

  1264.   frame_register (frame, regnum, &optimized, &unavailable,
  1265.                   &lval, &addr, &realnum, myaddr);

  1267.   return !optimized && !unavailable;
  1268. }

  1270. int
  1271. ‌get_frame_register_bytes (struct frame_info *frame, int regnum,
  1272.                           CORE_ADDR offset, int len, gdb_byte *myaddr,
  1273.                           int *optimizedp, int *unavailablep)
  1274. {
  1275.   struct gdbarch *gdbarch = get_frame_arch (frame);
  1276.   int i;
  1277.   int maxsize;
  1278.   int numregs;

  1280.   /* Skip registers wholly inside of OFFSET.  */
  1281.   while (offset >= register_size (gdbarch, regnum))
  1282.     {
  1283.       offset -= register_size (gdbarch, regnum);
  1284.       regnum++;
  1285.     }

  1287.   /* Ensure that we will not read beyond the end of the register file.
  1288.      This can only ever happen if the debug information is bad.  */
  1289.   maxsize = -offset;
  1290.   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
  1291.   for (i = regnum; i < numregs; i++)
  1292.     {
  1293.       int thissize = register_size (gdbarch, i);

  1295.       if (thissize == 0)
  1296.         break;        /* This register is not available on this architecture.  */
  1297.       maxsize += thissize;
  1298.     }
  1299.   if (len > maxsize)
  1300.     error (_("Bad debug information detected: "
  1301.              "Attempt to read %d bytes from registers."), len);

  1303.   /* Copy the data.  */
  1304.   while (len > 0)
  1305.     {
  1306.       int curr_len = register_size (gdbarch, regnum) - offset;

  1308.       if (curr_len > len)
  1309.         curr_len = len;

  1311.       if (curr_len == register_size (gdbarch, regnum))
  1312.         {
  1313.           enum lval_type lval;
  1314.           CORE_ADDR addr;
  1315.           int realnum;

  1317.           frame_register (frame, regnum, optimizedp, unavailablep,
  1318.                           &lval, &addr, &realnum, myaddr);
  1319.           if (*optimizedp || *unavailablep)
  1320.             return 0;
  1321.         }
  1322.       else
  1323.         {
  1324.           gdb_byte buf[MAX_REGISTER_SIZE];
  1325.           enum lval_type lval;
  1326.           CORE_ADDR addr;
  1327.           int realnum;

  1329.           frame_register (frame, regnum, optimizedp, unavailablep,
  1330.                           &lval, &addr, &realnum, buf);
  1331.           if (*optimizedp || *unavailablep)
  1332.             return 0;
  1333.           memcpy (myaddr, buf + offset, curr_len);
  1334.         }

  1336.       myaddr += curr_len;
  1337.       len -= curr_len;
  1338.       offset = 0;
  1339.       regnum++;
  1340.     }

  1342.   *optimizedp = 0;
  1343.   *unavailablep = 0;
  1344.   return 1;
  1345. }

  1347. void
  1348. ‌put_frame_register_bytes (struct frame_info *frame, int regnum,
  1349.                           CORE_ADDR offset, int len, const gdb_byte *myaddr)
  1350. {
  1351.   struct gdbarch *gdbarch = get_frame_arch (frame);

  1353.   /* Skip registers wholly inside of OFFSET.  */
  1354.   while (offset >= register_size (gdbarch, regnum))
  1355.     {
  1356.       offset -= register_size (gdbarch, regnum);
  1357.       regnum++;
  1358.     }

  1360.   /* Copy the data.  */
  1361.   while (len > 0)
  1362.     {
  1363.       int curr_len = register_size (gdbarch, regnum) - offset;

  1365.       if (curr_len > len)
  1366.         curr_len = len;

  1368.       if (curr_len == register_size (gdbarch, regnum))
  1369.         {
  1370.           put_frame_register (frame, regnum, myaddr);
  1371.         }
  1372.       else
  1373.         {
  1374.           gdb_byte buf[MAX_REGISTER_SIZE];

  1376.           deprecated_frame_register_read (frame, regnum, buf);
  1377.           memcpy (buf + offset, myaddr, curr_len);
  1378.           put_frame_register (frame, regnum, buf);
  1379.         }

  1381.       myaddr += curr_len;
  1382.       len -= curr_len;
  1383.       offset = 0;
  1384.       regnum++;
  1385.     }
  1386. }

  1388. /* Create a sentinel frame.  */

  1390. static struct frame_info *
  1391. ‌create_sentinel_frame (struct program_space *pspace, struct regcache *regcache)
  1392. {
  1393.   struct frame_info *frame = FRAME_OBSTACK_ZALLOC (struct frame_info);

  1395.   frame->level = -1;
  1396.   frame->pspace = pspace;
  1397.   frame->aspace = get_regcache_aspace (regcache);
  1398.   /* Explicitly initialize the sentinel frame's cache.  Provide it
  1399.      with the underlying regcache.  In the future additional
  1400.      information, such as the frame's thread will be added.  */
  1401.   frame->prologue_cache = sentinel_frame_cache (regcache);
  1402.   /* For the moment there is only one sentinel frame implementation.  */
  1403.   frame->unwind = &sentinel_frame_unwind;
  1404.   /* Link this frame back to itself.  The frame is self referential
  1405.      (the unwound PC is the same as the pc), so make it so.  */
  1406.   frame->next = frame;
  1407.   /* Make the sentinel frame's ID valid, but invalid.  That way all
  1408.      comparisons with it should fail.  */
  1409.   frame->this_id.p = 1;
  1410.   frame->this_id.value = null_frame_id;
  1411.   if (frame_debug)
  1412.     {
  1413.       fprintf_unfiltered (gdb_stdlog, "{ create_sentinel_frame (...) -> ");
  1414.       fprint_frame (gdb_stdlog, frame);
  1415.       fprintf_unfiltered (gdb_stdlog, " }\n");
  1416.     }
  1417.   return frame;
  1418. }

  1420. /* Info about the innermost stack frame (contents of FP register).  */

  1422. ‌static struct frame_info *current_frame;

  1424. /* Cache for frame addresses already read by gdb.  Valid only while
  1425.    inferior is stopped.  Control variables for the frame cache should
  1426.    be local to this module.  */

  1428. ‌static struct obstack frame_cache_obstack;

  1430. void *
  1431. ‌frame_obstack_zalloc (unsigned long size)
  1432. {
  1433.   void *data = obstack_alloc (&frame_cache_obstack, size);

  1435.   memset (data, 0, size);
  1436.   return data;
  1437. }

  1439. /* Return the innermost (currently executing) stack frame.  This is
  1440.    split into two functions.  The function unwind_to_current_frame()
  1441.    is wrapped in catch exceptions so that, even when the unwind of the
  1442.    sentinel frame fails, the function still returns a stack frame.  */

  1444. static int
  1445. ‌unwind_to_current_frame (struct ui_out *ui_out, void *args)
  1446. {
  1447.   struct frame_info *frame = get_prev_frame (args);

  1449.   /* A sentinel frame can fail to unwind, e.g., because its PC value
  1450.      lands in somewhere like start.  */
  1451.   if (frame == NULL)
  1452.     return 1;
  1453.   current_frame = frame;
  1454.   return 0;
  1455. }

  1457. struct frame_info *
  1458. ‌get_current_frame (void)
  1459. {
  1460.   /* First check, and report, the lack of registers.  Having GDB
  1461.      report "No stack!" or "No memory" when the target doesn't even
  1462.      have registers is very confusing.  Besides, "printcmd.exp"
  1463.      explicitly checks that ``print $pc'' with no registers prints "No
  1464.      registers".  */
  1465.   if (!target_has_registers)
  1466.     error (_("No registers."));
  1467.   if (!target_has_stack)
  1468.     error (_("No stack."));
  1469.   if (!target_has_memory)
  1470.     error (_("No memory."));
  1471.   /* Traceframes are effectively a substitute for the live inferior.  */
  1472.   if (get_traceframe_number () < 0)
  1473.     {
  1474.       if (ptid_equal (inferior_ptid, null_ptid))
  1475.         error (_("No selected thread."));
  1476.       if (is_exited (inferior_ptid))
  1477.         error (_("Invalid selected thread."));
  1478.       if (is_executing (inferior_ptid))
  1479.         error (_("Target is executing."));
  1480.     }

  1482.   if (current_frame == NULL)
  1483.     {
  1484.       struct frame_info *sentinel_frame =
  1485.         create_sentinel_frame (current_program_space, get_current_regcache ());
  1486.       if (catch_exceptions (current_uiout, unwind_to_current_frame,
  1487.                             sentinel_frame, RETURN_MASK_ERROR) != 0)
  1488.         {
  1489.           /* Oops! Fake a current frame?  Is this useful?  It has a PC
  1490.              of zero, for instance.  */
  1491.           current_frame = sentinel_frame;
  1492.         }
  1493.     }
  1494.   return current_frame;
  1495. }

  1497. /* The "selected" stack frame is used by default for local and arg
  1498.    access.  May be zero, for no selected frame.  */

  1500. ‌static struct frame_info *selected_frame;

  1502. int
  1503. ‌has_stack_frames (void)
  1504. {
  1505.   if (!target_has_registers || !target_has_stack || !target_has_memory)
  1506.     return 0;

  1508.   /* Traceframes are effectively a substitute for the live inferior.  */
  1509.   if (get_traceframe_number () < 0)
  1510.     {
  1511.       /* No current inferior, no frame.  */
  1512.       if (ptid_equal (inferior_ptid, null_ptid))
  1513.         return 0;

  1515.       /* Don't try to read from a dead thread.  */
  1516.       if (is_exited (inferior_ptid))
  1517.         return 0;

  1519.       /* ... or from a spinning thread.  */
  1520.       if (is_executing (inferior_ptid))
  1521.         return 0;
  1522.     }

  1524.   return 1;
  1525. }

  1527. /* Return the selected frame.  Always non-NULL (unless there isn't an
  1528.    inferior sufficient for creating a frame) in which case an error is
  1529.    thrown.  */

  1531. struct frame_info *
  1532. ‌get_selected_frame (const char *message)
  1533. {
  1534.   if (selected_frame == NULL)
  1535.     {
  1536.       if (message != NULL && !has_stack_frames ())
  1537.         error (("%s"), message);
  1538.       /* Hey!  Don't trust this.  It should really be re-finding the
  1539.          last selected frame of the currently selected thread.  This,
  1540.          though, is better than nothing.  */
  1541.       select_frame (get_current_frame ());
  1542.     }
  1543.   /* There is always a frame.  */
  1544.   gdb_assert (selected_frame != NULL);
  1545.   return selected_frame;
  1546. }

  1548. /* If there is a selected frame, return it.  Otherwise, return NULL.  */

  1550. struct frame_info *
  1551. ‌get_selected_frame_if_set (void)
  1552. {
  1553.   return selected_frame;
  1554. }

  1556. /* This is a variant of get_selected_frame() which can be called when
  1557.    the inferior does not have a frame; in that case it will return
  1558.    NULL instead of calling error().  */

  1560. struct frame_info *
  1561. ‌deprecated_safe_get_selected_frame (void)
  1562. {
  1563.   if (!has_stack_frames ())
  1564.     return NULL;
  1565.   return get_selected_frame (NULL);
  1566. }

  1568. /* Select frame FI (or NULL - to invalidate the current frame).  */

  1570. void
  1571. ‌select_frame (struct frame_info *fi)
  1572. {
  1573.   selected_frame = fi;
  1574.   /* NOTE: cagney/2002-05-04: FI can be NULL.  This occurs when the
  1575.      frame is being invalidated.  */
  1576.   if (deprecated_selected_frame_level_changed_hook)
  1577.     deprecated_selected_frame_level_changed_hook (frame_relative_level (fi));

  1579.   /* FIXME: kseitz/2002-08-28: It would be nice to call
  1580.      selected_frame_level_changed_event() right here, but due to limitations
  1581.      in the current interfaces, we would end up flooding UIs with events
  1582.      because select_frame() is used extensively internally.

  1584.      Once we have frame-parameterized frame (and frame-related) commands,
  1585.      the event notification can be moved here, since this function will only
  1586.      be called when the user's selected frame is being changed.  */

  1588.   /* Ensure that symbols for this frame are read in.  Also, determine the
  1589.      source language of this frame, and switch to it if desired.  */
  1590.   if (fi)
  1591.     {
  1592.       CORE_ADDR pc;

  1594.       /* We retrieve the frame's symtab by using the frame PC.
  1595.          However we cannot use the frame PC as-is, because it usually
  1596.          points to the instruction following the "call", which is
  1597.          sometimes the first instruction of another function.  So we
  1598.          rely on get_frame_address_in_block() which provides us with a
  1599.          PC which is guaranteed to be inside the frame's code
  1600.          block.  */
  1601.       if (get_frame_address_in_block_if_available (fi, &pc))
  1602.         {
  1603.           struct compunit_symtab *cust = find_pc_compunit_symtab (pc);

  1605.           if (cust != NULL
  1606.               && compunit_language (cust) != current_language->la_language
  1607.               && compunit_language (cust) != language_unknown
  1608.               && language_mode == language_mode_auto)
  1609.             set_language (compunit_language (cust));
  1610.         }
  1611.     }
  1612. }

  1614. /* Create an arbitrary (i.e. address specified by user) or innermost frame.
  1615.    Always returns a non-NULL value.  */

  1617. struct frame_info *
  1618. ‌create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
  1619. {
  1620.   struct frame_info *fi;

  1622.   if (frame_debug)
  1623.     {
  1624.       fprintf_unfiltered (gdb_stdlog,
  1625.                           "{ create_new_frame (addr=%s, pc=%s) ",
  1626.                           hex_string (addr), hex_string (pc));
  1627.     }

  1629.   fi = FRAME_OBSTACK_ZALLOC (struct frame_info);

  1631.   fi->next = create_sentinel_frame (current_program_space,
  1632.                                     get_current_regcache ());

  1634.   /* Set/update this frame's cached PC value, found in the next frame.
  1635.      Do this before looking for this frame's unwinder.  A sniffer is
  1636.      very likely to read this, and the corresponding unwinder is
  1637.      entitled to rely that the PC doesn't magically change.  */
  1638.   fi->next->prev_pc.value = pc;
  1639.   fi->next->prev_pc.status = CC_VALUE;

  1641.   /* We currently assume that frame chain's can't cross spaces.  */
  1642.   fi->pspace = fi->next->pspace;
  1643.   fi->aspace = fi->next->aspace;

  1645.   /* Select/initialize both the unwind function and the frame's type
  1646.      based on the PC.  */
  1647.   frame_unwind_find_by_frame (fi, &fi->prologue_cache);

  1649.   fi->this_id.p = 1;
  1650.   fi->this_id.value = frame_id_build (addr, pc);

  1652.   if (frame_debug)
  1653.     {
  1654.       fprintf_unfiltered (gdb_stdlog, "-> ");
  1655.       fprint_frame (gdb_stdlog, fi);
  1656.       fprintf_unfiltered (gdb_stdlog, " }\n");
  1657.     }

  1659.   return fi;
  1660. }

  1662. /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
  1663.    innermost frame).  Be careful to not fall off the bottom of the
  1664.    frame chain and onto the sentinel frame.  */

  1666. struct frame_info *
  1667. ‌get_next_frame (struct frame_info *this_frame)
  1668. {
  1669.   if (this_frame->level > 0)
  1670.     return this_frame->next;
  1671.   else
  1672.     return NULL;
  1673. }

  1675. /* Observer for the target_changed event.  */

  1677. static void
  1678. ‌frame_observer_target_changed (struct target_ops *target)
  1679. {
  1680.   reinit_frame_cache ();
  1681. }

  1683. /* Flush the entire frame cache.  */

  1685. void
  1686. ‌reinit_frame_cache (void)
  1687. {
  1688.   struct frame_info *fi;

  1690.   /* Tear down all frame caches.  */
  1691.   for (fi = current_frame; fi != NULL; fi = fi->prev)
  1692.     {
  1693.       if (fi->prologue_cache && fi->unwind->dealloc_cache)
  1694.         fi->unwind->dealloc_cache (fi, fi->prologue_cache);
  1695.       if (fi->base_cache && fi->base->unwind->dealloc_cache)
  1696.         fi->base->unwind->dealloc_cache (fi, fi->base_cache);
  1697.     }

  1699.   /* Since we can't really be sure what the first object allocated was.  */
  1700.   obstack_free (&frame_cache_obstack, 0);
  1701.   obstack_init (&frame_cache_obstack);

  1703.   if (current_frame != NULL)
  1704.     annotate_frames_invalid ();

  1706.   current_frame = NULL;                /* Invalidate cache */
  1707.   select_frame (NULL);
  1708.   frame_stash_invalidate ();
  1709.   if (frame_debug)
  1710.     fprintf_unfiltered (gdb_stdlog, "{ reinit_frame_cache () }\n");
  1711. }

  1713. /* Find where a register is saved (in memory or another register).
  1714.    The result of frame_register_unwind is just where it is saved
  1715.    relative to this particular frame.  */

  1717. static void
  1718. ‌frame_register_unwind_location (struct frame_info *this_frame, int regnum,
  1719.                                 int *optimizedp, enum lval_type *lvalp,
  1720.                                 CORE_ADDR *addrp, int *realnump)
  1721. {
  1722.   gdb_assert (this_frame == NULL || this_frame->level >= 0);

  1724.   while (this_frame != NULL)
  1725.     {
  1726.       int unavailable;

  1728.       frame_register_unwind (this_frame, regnum, optimizedp, &unavailable,
  1729.                              lvalp, addrp, realnump, NULL);

  1731.       if (*optimizedp)
  1732.         break;

  1734.       if (*lvalp != lval_register)
  1735.         break;

  1737.       regnum = *realnump;
  1738.       this_frame = get_next_frame (this_frame);
  1739.     }
  1740. }

  1742. /* Called during frame unwinding to remove a previous frame pointer from a
  1743.    frame passed in ARG.  */

  1745. static void
  1746. ‌remove_prev_frame (void *arg)
  1747. {
  1748.   struct frame_info *this_frame, *prev_frame;

  1750.   this_frame = (struct frame_info *) arg;
  1751.   prev_frame = this_frame->prev;
  1752.   gdb_assert (prev_frame != NULL);

  1754.   prev_frame->next = NULL;
  1755.   this_frame->prev = NULL;
  1756. }

  1758. /* Get the previous raw frame, and check that it is not identical to
  1759.    same other frame frame already in the chain.  If it is, there is
  1760.    most likely a stack cycle, so we discard it, and mark THIS_FRAME as
  1761.    outermost, with UNWIND_SAME_ID stop reason.  Unlike the other
  1762.    validity tests, that compare THIS_FRAME and the next frame, we do
  1763.    this right after creating the previous frame, to avoid ever ending
  1764.    up with two frames with the same id in the frame chain.  */

  1766. static struct frame_info *
  1767. ‌get_prev_frame_if_no_cycle (struct frame_info *this_frame)
  1768. {
  1769.   struct frame_info *prev_frame;
  1770.   struct cleanup *prev_frame_cleanup;

  1772.   prev_frame = get_prev_frame_raw (this_frame);
  1773.   if (prev_frame == NULL)
  1774.     return NULL;

  1776.   /* The cleanup will remove the previous frame that get_prev_frame_raw
  1777.      linked onto THIS_FRAME.  */
  1778.   prev_frame_cleanup = make_cleanup (remove_prev_frame, this_frame);

  1780.   compute_frame_id (prev_frame);
  1781.   if (!frame_stash_add (prev_frame))
  1782.     {
  1783.       /* Another frame with the same id was already in the stash.  We just
  1784.          detected a cycle.  */
  1785.       if (frame_debug)
  1786.         {
  1787.           fprintf_unfiltered (gdb_stdlog, "-> ");
  1788.           fprint_frame (gdb_stdlog, NULL);
  1789.           fprintf_unfiltered (gdb_stdlog, " // this frame has same ID }\n");
  1790.         }
  1791.       this_frame->stop_reason = UNWIND_SAME_ID;
  1792.       /* Unlink.  */
  1793.       prev_frame->next = NULL;
  1794.       this_frame->prev = NULL;
  1795.       prev_frame = NULL;
  1796.     }

  1798.   discard_cleanups (prev_frame_cleanup);
  1799.   return prev_frame;
  1800. }

  1802. /* Helper function for get_prev_frame_always, this is called inside a
  1803.    TRY_CATCH block.  Return the frame that called THIS_FRAME or NULL if
  1804.    there is no such frame.  This may throw an exception.  */

  1806. static struct frame_info *
  1807. ‌get_prev_frame_always_1 (struct frame_info *this_frame)
  1808. {
  1809.   struct gdbarch *gdbarch;

  1811.   gdb_assert (this_frame != NULL);
  1812.   gdbarch = get_frame_arch (this_frame);

  1814.   if (frame_debug)
  1815.     {
  1816.       fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame_always (this_frame=");
  1817.       if (this_frame != NULL)
  1818.         fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
  1819.       else
  1820.         fprintf_unfiltered (gdb_stdlog, "<NULL>");
  1821.       fprintf_unfiltered (gdb_stdlog, ") ");
  1822.     }

  1824.   /* Only try to do the unwind once.  */
  1825.   if (this_frame->prev_p)
  1826.     {
  1827.       if (frame_debug)
  1828.         {
  1829.           fprintf_unfiltered (gdb_stdlog, "-> ");
  1830.           fprint_frame (gdb_stdlog, this_frame->prev);
  1831.           fprintf_unfiltered (gdb_stdlog, " // cached \n");
  1832.         }
  1833.       return this_frame->prev;
  1834.     }

  1836.   /* If the frame unwinder hasn't been selected yet, we must do so
  1837.      before setting prev_p; otherwise the check for misbehaved
  1838.      sniffers will think that this frame's sniffer tried to unwind
  1839.      further (see frame_cleanup_after_sniffer).  */
  1840.   if (this_frame->unwind == NULL)
  1841.     frame_unwind_find_by_frame (this_frame, &this_frame->prologue_cache);

  1843.   this_frame->prev_p = 1;
  1844.   this_frame->stop_reason = UNWIND_NO_REASON;

  1846.   /* If we are unwinding from an inline frame, all of the below tests
  1847.      were already performed when we unwound from the next non-inline
  1848.      frame.  We must skip them, since we can not get THIS_FRAME's ID
  1849.      until we have unwound all the way down to the previous non-inline
  1850.      frame.  */
  1851.   if (get_frame_type (this_frame) == INLINE_FRAME)
  1852.     return get_prev_frame_if_no_cycle (this_frame);

  1854.   /* Check that this frame is unwindable.  If it isn't, don't try to
  1855.      unwind to the prev frame.  */
  1856.   this_frame->stop_reason
  1857.     = this_frame->unwind->stop_reason (this_frame,
  1858.                                        &this_frame->prologue_cache);

  1860.   if (this_frame->stop_reason != UNWIND_NO_REASON)
  1861.     {
  1862.       if (frame_debug)
  1863.         {
  1864.           enum unwind_stop_reason reason = this_frame->stop_reason;

  1866.           fprintf_unfiltered (gdb_stdlog, "-> ");
  1867.           fprint_frame (gdb_stdlog, NULL);
  1868.           fprintf_unfiltered (gdb_stdlog, " // %s }\n",
  1869.                               frame_stop_reason_symbol_string (reason));
  1870.         }
  1871.       return NULL;
  1872.     }

  1874.   /* Check that this frame's ID isn't inner to (younger, below, next)
  1875.      the next frame.  This happens when a frame unwind goes backwards.
  1876.      This check is valid only if this frame and the next frame are NORMAL.
  1877.      See the comment at frame_id_inner for details.  */
  1878.   if (get_frame_type (this_frame) == NORMAL_FRAME
  1879.       && this_frame->next->unwind->type == NORMAL_FRAME
  1880.       && frame_id_inner (get_frame_arch (this_frame->next),
  1881.                          get_frame_id (this_frame),
  1882.                          get_frame_id (this_frame->next)))
  1883.     {
  1884.       CORE_ADDR this_pc_in_block;
  1885.       struct minimal_symbol *morestack_msym;
  1886.       const char *morestack_name = NULL;

  1888.       /* gcc -fsplit-stack __morestack can continue the stack anywhere.  */
  1889.       this_pc_in_block = get_frame_address_in_block (this_frame);
  1890.       morestack_msym = lookup_minimal_symbol_by_pc (this_pc_in_block).minsym;
  1891.       if (morestack_msym)
  1892.         morestack_name = MSYMBOL_LINKAGE_NAME (morestack_msym);
  1893.       if (!morestack_name || strcmp (morestack_name, "__morestack") != 0)
  1894.         {
  1895.           if (frame_debug)
  1896.             {
  1897.               fprintf_unfiltered (gdb_stdlog, "-> ");
  1898.               fprint_frame (gdb_stdlog, NULL);
  1899.               fprintf_unfiltered (gdb_stdlog,
  1900.                                   " // this frame ID is inner }\n");
  1901.             }
  1902.           this_frame->stop_reason = UNWIND_INNER_ID;
  1903.           return NULL;
  1904.         }
  1905.     }

  1907.   /* Check that this and the next frame do not unwind the PC register
  1908.      to the same memory location.  If they do, then even though they
  1909.      have different frame IDs, the new frame will be bogus; two
  1910.      functions can't share a register save slot for the PC.  This can
  1911.      happen when the prologue analyzer finds a stack adjustment, but
  1912.      no PC save.

  1914.      This check does assume that the "PC register" is roughly a
  1915.      traditional PC, even if the gdbarch_unwind_pc method adjusts
  1916.      it (we do not rely on the value, only on the unwound PC being
  1917.      dependent on this value).  A potential improvement would be
  1918.      to have the frame prev_pc method and the gdbarch unwind_pc
  1919.      method set the same lval and location information as
  1920.      frame_register_unwind.  */
  1921.   if (this_frame->level > 0
  1922.       && gdbarch_pc_regnum (gdbarch) >= 0
  1923.       && get_frame_type (this_frame) == NORMAL_FRAME
  1924.       && (get_frame_type (this_frame->next) == NORMAL_FRAME
  1925.           || get_frame_type (this_frame->next) == INLINE_FRAME))
  1926.     {
  1927.       int optimized, realnum, nrealnum;
  1928.       enum lval_type lval, nlval;
  1929.       CORE_ADDR addr, naddr;

  1931.       frame_register_unwind_location (this_frame,
  1932.                                       gdbarch_pc_regnum (gdbarch),
  1933.                                       &optimized, &lval, &addr, &realnum);
  1934.       frame_register_unwind_location (get_next_frame (this_frame),
  1935.                                       gdbarch_pc_regnum (gdbarch),
  1936.                                       &optimized, &nlval, &naddr, &nrealnum);

  1938.       if ((lval == lval_memory && lval == nlval && addr == naddr)
  1939.           || (lval == lval_register && lval == nlval && realnum == nrealnum))
  1940.         {
  1941.           if (frame_debug)
  1942.             {
  1943.               fprintf_unfiltered (gdb_stdlog, "-> ");
  1944.               fprint_frame (gdb_stdlog, NULL);
  1945.               fprintf_unfiltered (gdb_stdlog, " // no saved PC }\n");
  1946.             }

  1948.           this_frame->stop_reason = UNWIND_NO_SAVED_PC;
  1949.           this_frame->prev = NULL;
  1950.           return NULL;
  1951.         }
  1952.     }

  1954.   return get_prev_frame_if_no_cycle (this_frame);
  1955. }

  1957. /* Return a "struct frame_info" corresponding to the frame that called
  1958.    THIS_FRAME.  Returns NULL if there is no such frame.

  1960.    Unlike get_prev_frame, this function always tries to unwind the
  1961.    frame.  */

  1963. struct frame_info *
  1964. ‌get_prev_frame_always (struct frame_info *this_frame)
  1965. {
  1966.   volatile struct gdb_exception ex;
  1967.   struct frame_info *prev_frame = NULL;

  1969.   TRY_CATCH (ex, RETURN_MASK_ERROR)
  1970.     {
  1971.       prev_frame = get_prev_frame_always_1 (this_frame);
  1972.     }
  1973.   if (ex.reason < 0)
  1974.     {
  1975.       if (ex.error == MEMORY_ERROR)
  1976.         {
  1977.           this_frame->stop_reason = UNWIND_MEMORY_ERROR;
  1978.           if (ex.message != NULL)
  1979.             {
  1980.               char *stop_string;
  1981.               size_t size;

  1983.               /* The error needs to live as long as the frame does.
  1984.                  Allocate using stack local STOP_STRING then assign the
  1985.                  pointer to the frame, this allows the STOP_STRING on the
  1986.                  frame to be of type 'const char *'.  */
  1987.               size = strlen (ex.message) + 1;
  1988.               stop_string = frame_obstack_zalloc (size);
  1989.               memcpy (stop_string, ex.message, size);
  1990.               this_frame->stop_string = stop_string;
  1991.             }
  1992.           prev_frame = NULL;
  1993.         }
  1994.       else
  1995.         throw_exception (ex);
  1996.     }

  1998.   return prev_frame;
  1999. }

  2001. /* Construct a new "struct frame_info" and link it previous to
  2002.    this_frame.  */

  2004. static struct frame_info *
  2005. ‌get_prev_frame_raw (struct frame_info *this_frame)
  2006. {
  2007.   struct frame_info *prev_frame;

  2009.   /* Allocate the new frame but do not wire it in to the frame chain.
  2010.      Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
  2011.      frame->next to pull some fancy tricks (of course such code is, by
  2012.      definition, recursive).  Try to prevent it.

  2014.      There is no reason to worry about memory leaks, should the
  2015.      remainder of the function fail.  The allocated memory will be
  2016.      quickly reclaimed when the frame cache is flushed, and the `we've
  2017.      been here before' check above will stop repeated memory
  2018.      allocation calls.  */
  2019.   prev_frame = FRAME_OBSTACK_ZALLOC (struct frame_info);
  2020.   prev_frame->level = this_frame->level + 1;

  2022.   /* For now, assume we don't have frame chains crossing address
  2023.      spaces.  */
  2024.   prev_frame->pspace = this_frame->pspace;
  2025.   prev_frame->aspace = this_frame->aspace;

  2027.   /* Don't yet compute ->unwind (and hence ->type).  It is computed
  2028.      on-demand in get_frame_type, frame_register_unwind, and
  2029.      get_frame_id.  */

  2031.   /* Don't yet compute the frame's ID.  It is computed on-demand by
  2032.      get_frame_id().  */

  2034.   /* The unwound frame ID is validate at the start of this function,
  2035.      as part of the logic to decide if that frame should be further
  2036.      unwound, and not here while the prev frame is being created.
  2037.      Doing this makes it possible for the user to examine a frame that
  2038.      has an invalid frame ID.

  2040.      Some very old VAX code noted: [...]  For the sake of argument,
  2041.      suppose that the stack is somewhat trashed (which is one reason
  2042.      that "info frame" exists).  So, return 0 (indicating we don't
  2043.      know the address of the arglist) if we don't know what frame this
  2044.      frame calls.  */

  2046.   /* Link it in.  */
  2047.   this_frame->prev = prev_frame;
  2048.   prev_frame->next = this_frame;

  2050.   if (frame_debug)
  2051.     {
  2052.       fprintf_unfiltered (gdb_stdlog, "-> ");
  2053.       fprint_frame (gdb_stdlog, prev_frame);
  2054.       fprintf_unfiltered (gdb_stdlog, " }\n");
  2055.     }

  2057.   return prev_frame;
  2058. }

  2060. /* Debug routine to print a NULL frame being returned.  */

  2062. static void
  2063. ‌frame_debug_got_null_frame (struct frame_info *this_frame,
  2064.                             const char *reason)
  2065. {
  2066.   if (frame_debug)
  2067.     {
  2068.       fprintf_unfiltered (gdb_stdlog, "{ get_prev_frame (this_frame=");
  2069.       if (this_frame != NULL)
  2070.         fprintf_unfiltered (gdb_stdlog, "%d", this_frame->level);
  2071.       else
  2072.         fprintf_unfiltered (gdb_stdlog, "<NULL>");
  2073.       fprintf_unfiltered (gdb_stdlog, ") -> // %s}\n", reason);
  2074.     }
  2075. }

  2077. /* Is this (non-sentinel) frame in the "main"() function?  */

  2079. static int
  2080. ‌inside_main_func (struct frame_info *this_frame)
  2081. {
  2082.   struct bound_minimal_symbol msymbol;
  2083.   CORE_ADDR maddr;

  2085.   if (symfile_objfile == 0)
  2086.     return 0;
  2087.   msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
  2088.   if (msymbol.minsym == NULL)
  2089.     return 0;
  2090.   /* Make certain that the code, and not descriptor, address is
  2091.      returned.  */
  2092.   maddr = gdbarch_convert_from_func_ptr_addr (get_frame_arch (this_frame),
  2093.                                               BMSYMBOL_VALUE_ADDRESS (msymbol),
  2094.                                               &current_target);
  2095.   return maddr == get_frame_func (this_frame);
  2096. }

  2098. /* Test whether THIS_FRAME is inside the process entry point function.  */

  2100. static int
  2101. ‌inside_entry_func (struct frame_info *this_frame)
  2102. {
  2103.   CORE_ADDR entry_point;

  2105.   if (!entry_point_address_query (&entry_point))
  2106.     return 0;

  2108.   return get_frame_func (this_frame) == entry_point;
  2109. }

  2111. /* Return a structure containing various interesting information about
  2112.    the frame that called THIS_FRAME.  Returns NULL if there is entier
  2113.    no such frame or the frame fails any of a set of target-independent
  2114.    condition that should terminate the frame chain (e.g., as unwinding
  2115.    past main()).

  2117.    This function should not contain target-dependent tests, such as
  2118.    checking whether the program-counter is zero.  */

  2120. struct frame_info *
  2121. ‌get_prev_frame (struct frame_info *this_frame)
  2122. {
  2123.   CORE_ADDR frame_pc;
  2124.   int frame_pc_p;

  2126.   /* There is always a frame.  If this assertion fails, suspect that
  2127.      something should be calling get_selected_frame() or
  2128.      get_current_frame().  */
  2129.   gdb_assert (this_frame != NULL);
  2130.   frame_pc_p = get_frame_pc_if_available (this_frame, &frame_pc);

  2132.   /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
  2133.      sense to stop unwinding at a dummy frame.  One place where a dummy
  2134.      frame may have an address "inside_main_func" is on HPUX.  On HPUX, the
  2135.      pcsqh register (space register for the instruction at the head of the
  2136.      instruction queue) cannot be written directly; the only way to set it
  2137.      is to branch to code that is in the target space.  In order to implement
  2138.      frame dummies on HPUX, the called function is made to jump back to where
  2139.      the inferior was when the user function was called.  If gdb was inside
  2140.      the main function when we created the dummy frame, the dummy frame will
  2141.      point inside the main function.  */
  2142.   if (this_frame->level >= 0
  2143.       && get_frame_type (this_frame) == NORMAL_FRAME
  2144.       && !backtrace_past_main
  2145.       && frame_pc_p
  2146.       && inside_main_func (this_frame))
  2147.     /* Don't unwind past main().  Note, this is done _before_ the
  2148.        frame has been marked as previously unwound.  That way if the
  2149.        user later decides to enable unwinds past main(), that will
  2150.        automatically happen.  */
  2151.     {
  2152.       frame_debug_got_null_frame (this_frame, "inside main func");
  2153.       return NULL;
  2154.     }

  2156.   /* If the user's backtrace limit has been exceeded, stop.  We must
  2157.      add two to the current level; one of those accounts for backtrace_limit
  2158.      being 1-based and the level being 0-based, and the other accounts for
  2159.      the level of the new frame instead of the level of the current
  2160.      frame.  */
  2161.   if (this_frame->level + 2 > backtrace_limit)
  2162.     {
  2163.       frame_debug_got_null_frame (this_frame, "backtrace limit exceeded");
  2164.       return NULL;
  2165.     }

  2167.   /* If we're already inside the entry function for the main objfile,
  2168.      then it isn't valid.  Don't apply this test to a dummy frame -
  2169.      dummy frame PCs typically land in the entry func.  Don't apply
  2170.      this test to the sentinel frame.  Sentinel frames should always
  2171.      be allowed to unwind.  */
  2172.   /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
  2173.      wasn't checking for "main" in the minimal symbols.  With that
  2174.      fixed asm-source tests now stop in "main" instead of halting the
  2175.      backtrace in weird and wonderful ways somewhere inside the entry
  2176.      file.  Suspect that tests for inside the entry file/func were
  2177.      added to work around that (now fixed) case.  */
  2178.   /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
  2179.      suggested having the inside_entry_func test use the
  2180.      inside_main_func() msymbol trick (along with entry_point_address()
  2181.      I guess) to determine the address range of the start function.
  2182.      That should provide a far better stopper than the current
  2183.      heuristics.  */
  2184.   /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
  2185.      applied tail-call optimizations to main so that a function called
  2186.      from main returns directly to the caller of main.  Since we don't
  2187.      stop at main, we should at least stop at the entry point of the
  2188.      application.  */
  2189.   if (this_frame->level >= 0
  2190.       && get_frame_type (this_frame) == NORMAL_FRAME
  2191.       && !backtrace_past_entry
  2192.       && frame_pc_p
  2193.       && inside_entry_func (this_frame))
  2194.     {
  2195.       frame_debug_got_null_frame (this_frame, "inside entry func");
  2196.       return NULL;
  2197.     }

  2199.   /* Assume that the only way to get a zero PC is through something
  2200.      like a SIGSEGV or a dummy frame, and hence that NORMAL frames
  2201.      will never unwind a zero PC.  */
  2202.   if (this_frame->level > 0
  2203.       && (get_frame_type (this_frame) == NORMAL_FRAME
  2204.           || get_frame_type (this_frame) == INLINE_FRAME)
  2205.       && get_frame_type (get_next_frame (this_frame)) == NORMAL_FRAME
  2206.       && frame_pc_p && frame_pc == 0)
  2207.     {
  2208.       frame_debug_got_null_frame (this_frame, "zero PC");
  2209.       return NULL;
  2210.     }

  2212.   return get_prev_frame_always (this_frame);
  2213. }

  2215. CORE_ADDR
  2216. ‌get_frame_pc (struct frame_info *frame)
  2217. {
  2218.   gdb_assert (frame->next != NULL);
  2219.   return frame_unwind_pc (frame->next);
  2220. }

  2222. int
  2223. ‌get_frame_pc_if_available (struct frame_info *frame, CORE_ADDR *pc)
  2224. {
  2225.   volatile struct gdb_exception ex;

  2227.   gdb_assert (frame->next != NULL);

  2229.   TRY_CATCH (ex, RETURN_MASK_ERROR)
  2230.     {
  2231.       *pc = frame_unwind_pc (frame->next);
  2232.     }
  2233.   if (ex.reason < 0)
  2234.     {
  2235.       if (ex.error == NOT_AVAILABLE_ERROR)
  2236.         return 0;
  2237.       else
  2238.         throw_exception (ex);
  2239.     }

  2241.   return 1;
  2242. }

  2244. /* Return an address that falls within THIS_FRAME's code block.  */

  2246. CORE_ADDR
  2247. ‌get_frame_address_in_block (struct frame_info *this_frame)
  2248. {
  2249.   /* A draft address.  */
  2250.   CORE_ADDR pc = get_frame_pc (this_frame);

  2252.   struct frame_info *next_frame = this_frame->next;

  2254.   /* Calling get_frame_pc returns the resume address for THIS_FRAME.
  2255.      Normally the resume address is inside the body of the function
  2256.      associated with THIS_FRAME, but there is a special case: when
  2257.      calling a function which the compiler knows will never return
  2258.      (for instance abort), the call may be the very last instruction
  2259.      in the calling function.  The resume address will point after the
  2260.      call and may be at the beginning of a different function
  2261.      entirely.

  2263.      If THIS_FRAME is a signal frame or dummy frame, then we should
  2264.      not adjust the unwound PC.  For a dummy frame, GDB pushed the
  2265.      resume address manually onto the stack.  For a signal frame, the
  2266.      OS may have pushed the resume address manually and invoked the
  2267.      handler (e.g. GNU/Linux), or invoked the trampoline which called
  2268.      the signal handler - but in either case the signal handler is
  2269.      expected to return to the trampoline.  So in both of these
  2270.      cases we know that the resume address is executable and
  2271.      related.  So we only need to adjust the PC if THIS_FRAME
  2272.      is a normal function.

  2274.      If the program has been interrupted while THIS_FRAME is current,
  2275.      then clearly the resume address is inside the associated
  2276.      function.  There are three kinds of interruption: debugger stop
  2277.      (next frame will be SENTINEL_FRAME), operating system
  2278.      signal or exception (next frame will be SIGTRAMP_FRAME),
  2279.      or debugger-induced function call (next frame will be
  2280.      DUMMY_FRAME).  So we only need to adjust the PC if
  2281.      NEXT_FRAME is a normal function.

  2283.      We check the type of NEXT_FRAME first, since it is already
  2284.      known; frame type is determined by the unwinder, and since
  2285.      we have THIS_FRAME we've already selected an unwinder for
  2286.      NEXT_FRAME.

  2288.      If the next frame is inlined, we need to keep going until we find
  2289.      the real function - for instance, if a signal handler is invoked
  2290.      while in an inlined function, then the code address of the
  2291.      "calling" normal function should not be adjusted either.  */

  2293.   while (get_frame_type (next_frame) == INLINE_FRAME)
  2294.     next_frame = next_frame->next;

  2296.   if ((get_frame_type (next_frame) == NORMAL_FRAME
  2297.        || get_frame_type (next_frame) == TAILCALL_FRAME)
  2298.       && (get_frame_type (this_frame) == NORMAL_FRAME
  2299.           || get_frame_type (this_frame) == TAILCALL_FRAME
  2300.           || get_frame_type (this_frame) == INLINE_FRAME))
  2301.     return pc - 1;

  2303.   return pc;
  2304. }

  2306. int
  2307. ‌get_frame_address_in_block_if_available (struct frame_info *this_frame,
  2308.                                          CORE_ADDR *pc)
  2309. {
  2310.   volatile struct gdb_exception ex;

  2312.   TRY_CATCH (ex, RETURN_MASK_ERROR)
  2313.     {
  2314.       *pc = get_frame_address_in_block (this_frame);
  2315.     }
  2316.   if (ex.reason < 0 && ex.error == NOT_AVAILABLE_ERROR)
  2317.     return 0;
  2318.   else if (ex.reason < 0)
  2319.     throw_exception (ex);
  2320.   else
  2321.     return 1;
  2322. }

  2324. void
  2325. ‌find_frame_sal (struct frame_info *frame, struct symtab_and_line *sal)
  2326. {
  2327.   struct frame_info *next_frame;
  2328.   int notcurrent;
  2329.   CORE_ADDR pc;

  2331.   /* If the next frame represents an inlined function call, this frame's
  2332.      sal is the "call site" of that inlined function, which can not
  2333.      be inferred from get_frame_pc.  */
  2334.   next_frame = get_next_frame (frame);
  2335.   if (frame_inlined_callees (frame) > 0)
  2336.     {
  2337.       struct symbol *sym;

  2339.       if (next_frame)
  2340.         sym = get_frame_function (next_frame);
  2341.       else
  2342.         sym = inline_skipped_symbol (inferior_ptid);

  2344.       /* If frame is inline, it certainly has symbols.  */
  2345.       gdb_assert (sym);
  2346.       init_sal (sal);
  2347.       if (SYMBOL_LINE (sym) != 0)
  2348.         {
  2349.           sal->symtab = symbol_symtab (sym);
  2350.           sal->line = SYMBOL_LINE (sym);
  2351.         }
  2352.       else
  2353.         /* If the symbol does not have a location, we don't know where
  2354.            the call site is.  Do not pretend to.  This is jarring, but
  2355.            we can't do much better.  */
  2356.         sal->pc = get_frame_pc (frame);

  2358.       sal->pspace = get_frame_program_space (frame);

  2360.       return;
  2361.     }

  2363.   /* If FRAME is not the innermost frame, that normally means that
  2364.      FRAME->pc points at the return instruction (which is *after* the
  2365.      call instruction), and we want to get the line containing the
  2366.      call (because the call is where the user thinks the program is).
  2367.      However, if the next frame is either a SIGTRAMP_FRAME or a
  2368.      DUMMY_FRAME, then the next frame will contain a saved interrupt
  2369.      PC and such a PC indicates the current (rather than next)
  2370.      instruction/line, consequently, for such cases, want to get the
  2371.      line containing fi->pc.  */
  2372.   if (!get_frame_pc_if_available (frame, &pc))
  2373.     {
  2374.       init_sal (sal);
  2375.       return;
  2376.     }

  2378.   notcurrent = (pc != get_frame_address_in_block (frame));
  2379.   (*sal) = find_pc_line (pc, notcurrent);
  2380. }

  2382. /* Per "frame.h", return the ``address'' of the frame.  Code should
  2383.    really be using get_frame_id().  */
  2384. CORE_ADDR
  2385. ‌get_frame_base (struct frame_info *fi)
  2386. {
  2387.   return get_frame_id (fi).stack_addr;
  2388. }

  2390. /* High-level offsets into the frame.  Used by the debug info.  */

  2392. CORE_ADDR
  2393. ‌get_frame_base_address (struct frame_info *fi)
  2394. {
  2395.   if (get_frame_type (fi) != NORMAL_FRAME)
  2396.     return 0;
  2397.   if (fi->base == NULL)
  2398.     fi->base = frame_base_find_by_frame (fi);
  2399.   /* Sneaky: If the low-level unwind and high-level base code share a
  2400.      common unwinder, let them share the prologue cache.  */
  2401.   if (fi->base->unwind == fi->unwind)
  2402.     return fi->base->this_base (fi, &fi->prologue_cache);
  2403.   return fi->base->this_base (fi, &fi->base_cache);
  2404. }

  2406. CORE_ADDR
  2407. ‌get_frame_locals_address (struct frame_info *fi)
  2408. {
  2409.   if (get_frame_type (fi) != NORMAL_FRAME)
  2410.     return 0;
  2411.   /* If there isn't a frame address method, find it.  */
  2412.   if (fi->base == NULL)
  2413.     fi->base = frame_base_find_by_frame (fi);
  2414.   /* Sneaky: If the low-level unwind and high-level base code share a
  2415.      common unwinder, let them share the prologue cache.  */
  2416.   if (fi->base->unwind == fi->unwind)
  2417.     return fi->base->this_locals (fi, &fi->prologue_cache);
  2418.   return fi->base->this_locals (fi, &fi->base_cache);
  2419. }

  2421. CORE_ADDR
  2422. ‌get_frame_args_address (struct frame_info *fi)
  2423. {
  2424.   if (get_frame_type (fi) != NORMAL_FRAME)
  2425.     return 0;
  2426.   /* If there isn't a frame address method, find it.  */
  2427.   if (fi->base == NULL)
  2428.     fi->base = frame_base_find_by_frame (fi);
  2429.   /* Sneaky: If the low-level unwind and high-level base code share a
  2430.      common unwinder, let them share the prologue cache.  */
  2431.   if (fi->base->unwind == fi->unwind)
  2432.     return fi->base->this_args (fi, &fi->prologue_cache);
  2433.   return fi->base->this_args (fi, &fi->base_cache);
  2434. }

  2436. /* Return true if the frame unwinder for frame FI is UNWINDER; false
  2437.    otherwise.  */

  2439. int
  2440. ‌frame_unwinder_is (struct frame_info *fi, const struct frame_unwind *unwinder)
  2441. {
  2442.   if (fi->unwind == NULL)
  2443.     frame_unwind_find_by_frame (fi, &fi->prologue_cache);
  2444.   return fi->unwind == unwinder;
  2445. }

  2447. /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
  2448.    or -1 for a NULL frame.  */

  2450. int
  2451. ‌frame_relative_level (struct frame_info *fi)
  2452. {
  2453.   if (fi == NULL)
  2454.     return -1;
  2455.   else
  2456.     return fi->level;
  2457. }

  2459. enum frame_type
  2460. ‌get_frame_type (struct frame_info *frame)
  2461. {
  2462.   if (frame->unwind == NULL)
  2463.     /* Initialize the frame's unwinder because that's what
  2464.        provides the frame's type.  */
  2465.     frame_unwind_find_by_frame (frame, &frame->prologue_cache);
  2466.   return frame->unwind->type;
  2467. }

  2469. struct program_space *
  2470. ‌get_frame_program_space (struct frame_info *frame)
  2471. {
  2472.   return frame->pspace;
  2473. }

  2475. struct program_space *
  2476. ‌frame_unwind_program_space (struct frame_info *this_frame)
  2477. {
  2478.   gdb_assert (this_frame);

  2480.   /* This is really a placeholder to keep the API consistent --- we
  2481.      assume for now that we don't have frame chains crossing
  2482.      spaces.  */
  2483.   return this_frame->pspace;
  2484. }

  2486. struct address_space *
  2487. ‌get_frame_address_space (struct frame_info *frame)
  2488. {
  2489.   return frame->aspace;
  2490. }

  2492. /* Memory access methods.  */

  2494. void
  2495. ‌get_frame_memory (struct frame_info *this_frame, CORE_ADDR addr,
  2496.                   gdb_byte *buf, int len)
  2497. {
  2498.   read_memory (addr, buf, len);
  2499. }

  2501. LONGEST
  2502. ‌get_frame_memory_signed (struct frame_info *this_frame, CORE_ADDR addr,
  2503.                          int len)
  2504. {
  2505.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  2506.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

  2508.   return read_memory_integer (addr, len, byte_order);
  2509. }

  2511. ULONGEST
  2512. ‌get_frame_memory_unsigned (struct frame_info *this_frame, CORE_ADDR addr,
  2513.                            int len)
  2514. {
  2515.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  2516.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

  2518.   return read_memory_unsigned_integer (addr, len, byte_order);
  2519. }

  2521. int
  2522. ‌safe_frame_unwind_memory (struct frame_info *this_frame,
  2523.                           CORE_ADDR addr, gdb_byte *buf, int len)
  2524. {
  2525.   /* NOTE: target_read_memory returns zero on success!  */
  2526.   return !target_read_memory (addr, buf, len);
  2527. }

  2529. /* Architecture methods.  */

  2531. struct gdbarch *
  2532. ‌get_frame_arch (struct frame_info *this_frame)
  2533. {
  2534.   return frame_unwind_arch (this_frame->next);
  2535. }

  2537. struct gdbarch *
  2538. ‌frame_unwind_arch (struct frame_info *next_frame)
  2539. {
  2540.   if (!next_frame->prev_arch.p)
  2541.     {
  2542.       struct gdbarch *arch;

  2544.       if (next_frame->unwind == NULL)
  2545.         frame_unwind_find_by_frame (next_frame, &next_frame->prologue_cache);

  2547.       if (next_frame->unwind->prev_arch != NULL)
  2548.         arch = next_frame->unwind->prev_arch (next_frame,
  2549.                                               &next_frame->prologue_cache);
  2550.       else
  2551.         arch = get_frame_arch (next_frame);

  2553.       next_frame->prev_arch.arch = arch;
  2554.       next_frame->prev_arch.p = 1;
  2555.       if (frame_debug)
  2556.         fprintf_unfiltered (gdb_stdlog,
  2557.                             "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
  2558.                             next_frame->level,
  2559.                             gdbarch_bfd_arch_info (arch)->printable_name);
  2560.     }

  2562.   return next_frame->prev_arch.arch;
  2563. }

  2565. struct gdbarch *
  2566. ‌frame_unwind_caller_arch (struct frame_info *next_frame)
  2567. {
  2568.   return frame_unwind_arch (skip_artificial_frames (next_frame));
  2569. }

  2571. /* Stack pointer methods.  */

  2573. CORE_ADDR
  2574. ‌get_frame_sp (struct frame_info *this_frame)
  2575. {
  2576.   struct gdbarch *gdbarch = get_frame_arch (this_frame);

  2578.   /* Normality - an architecture that provides a way of obtaining any
  2579.      frame inner-most address.  */
  2580.   if (gdbarch_unwind_sp_p (gdbarch))
  2581.     /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
  2582.        operate on THIS_FRAME now.  */
  2583.     return gdbarch_unwind_sp (gdbarch, this_frame->next);
  2584.   /* Now things are really are grim.  Hope that the value returned by
  2585.      the gdbarch_sp_regnum register is meaningful.  */
  2586.   if (gdbarch_sp_regnum (gdbarch) >= 0)
  2587.     return get_frame_register_unsigned (this_frame,
  2588.                                         gdbarch_sp_regnum (gdbarch));
  2589.   internal_error (__FILE__, __LINE__, _("Missing unwind SP method"));
  2590. }

  2592. /* Return the reason why we can't unwind past FRAME.  */

  2594. enum unwind_stop_reason
  2595. ‌get_frame_unwind_stop_reason (struct frame_info *frame)
  2596. {
  2597.   /* Fill-in STOP_REASON.  */
  2598.   get_prev_frame_always (frame);
  2599.   gdb_assert (frame->prev_p);

  2601.   return frame->stop_reason;
  2602. }

  2604. /* Return a string explaining REASON.  */

  2606. const char *
  2607. ‌unwind_stop_reason_to_string (enum unwind_stop_reason reason)
  2608. {
  2609.   switch (reason)
  2610.     {
  2611. ‌#define SET(name, description) \
  2612.     case name: return _(description);
  2613. #include "unwind_stop_reasons.def"
  2614. ‌#undef SET

  2616.     default:
  2617.       internal_error (__FILE__, __LINE__,
  2618.                       "Invalid frame stop reason");
  2619.     }
  2620. }

  2622. const char *
  2623. ‌frame_stop_reason_string (struct frame_info *fi)
  2624. {
  2625.   gdb_assert (fi->prev_p);
  2626.   gdb_assert (fi->prev == NULL);

  2628.   /* Return the specific string if we have one.  */
  2629.   if (fi->stop_string != NULL)
  2630.     return fi->stop_string;

  2632.   /* Return the generic string if we have nothing better.  */
  2633.   return unwind_stop_reason_to_string (fi->stop_reason);
  2634. }

  2636. /* Return the enum symbol name of REASON as a string, to use in debug
  2637.    output.  */

  2639. static const char *
  2640. ‌frame_stop_reason_symbol_string (enum unwind_stop_reason reason)
  2641. {
  2642.   switch (reason)
  2643.     {
  2644. ‌#define SET(name, description) \
  2645.     case name: return #name;
  2646. #include "unwind_stop_reasons.def"
  2647. ‌#undef SET

  2649.     default:
  2650.       internal_error (__FILE__, __LINE__,
  2651.                       "Invalid frame stop reason");
  2652.     }
  2653. }

  2655. /* Clean up after a failed (wrong unwinder) attempt to unwind past
  2656.    FRAME.  */

  2658. static void
  2659. ‌frame_cleanup_after_sniffer (void *arg)
  2660. {
  2661.   struct frame_info *frame = arg;

  2663.   /* The sniffer should not allocate a prologue cache if it did not
  2664.      match this frame.  */
  2665.   gdb_assert (frame->prologue_cache == NULL);

  2667.   /* No sniffer should extend the frame chain; sniff based on what is
  2668.      already certain.  */
  2669.   gdb_assert (!frame->prev_p);

  2671.   /* The sniffer should not check the frame's ID; that's circular.  */
  2672.   gdb_assert (!frame->this_id.p);

  2674.   /* Clear cached fields dependent on the unwinder.

  2676.      The previous PC is independent of the unwinder, but the previous
  2677.      function is not (see get_frame_address_in_block).  */
  2678.   frame->prev_func.p = 0;
  2679.   frame->prev_func.addr = 0;

  2681.   /* Discard the unwinder last, so that we can easily find it if an assertion
  2682.      in this function triggers.  */
  2683.   frame->unwind = NULL;
  2684. }

  2686. /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
  2687.    Return a cleanup which should be called if unwinding fails, and
  2688.    discarded if it succeeds.  */

  2690. struct cleanup *
  2691. ‌frame_prepare_for_sniffer (struct frame_info *frame,
  2692.                            const struct frame_unwind *unwind)
  2693. {
  2694.   gdb_assert (frame->unwind == NULL);
  2695.   frame->unwind = unwind;
  2696.   return make_cleanup (frame_cleanup_after_sniffer, frame);
  2697. }

  2699. extern initialize_file_ftype _initialize_frame; /* -Wmissing-prototypes */

  2701. ‌static struct cmd_list_element *set_backtrace_cmdlist;
  2702. ‌static struct cmd_list_element *show_backtrace_cmdlist;

  2704. static void
  2705. ‌set_backtrace_cmd (char *args, int from_tty)
  2706. {
  2707.   help_list (set_backtrace_cmdlist, "set backtrace ", all_commands,
  2708.              gdb_stdout);
  2709. }

  2711. static void
  2712. ‌show_backtrace_cmd (char *args, int from_tty)
  2713. {
  2714.   cmd_show_list (show_backtrace_cmdlist, from_tty, "");
  2715. }

  2717. void
  2718. ‌_initialize_frame (void)
  2719. {
  2720.   obstack_init (&frame_cache_obstack);

  2722.   frame_stash_create ();

  2724.   observer_attach_target_changed (frame_observer_target_changed);

  2726.   add_prefix_cmd ("backtrace", class_maintenance, set_backtrace_cmd, _("\
  2727. Set backtrace specific variables.\n\
  2728. Configure backtrace variables such as the backtrace limit"),
  2729.                   &set_backtrace_cmdlist, "set backtrace ",
  2730.                   0/*allow-unknown*/, &setlist);
  2731.   add_prefix_cmd ("backtrace", class_maintenance, show_backtrace_cmd, _("\
  2732. Show backtrace specific variables\n\
  2733. Show backtrace variables such as the backtrace limit"),
  2734.                   &show_backtrace_cmdlist, "show backtrace ",
  2735.                   0/*allow-unknown*/, &showlist);

  2737.   add_setshow_boolean_cmd ("past-main", class_obscure,
  2738.                            &backtrace_past_main, _("\
  2739. Set whether backtraces should continue past \"main\"."), _("\
  2740. Show whether backtraces should continue past \"main\"."), _("\
  2741. Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
  2742. the backtrace at \"main\".  Set this variable if you need to see the rest\n\
  2743. of the stack trace."),
  2744.                            NULL,
  2745.                            show_backtrace_past_main,
  2746.                            &set_backtrace_cmdlist,
  2747.                            &show_backtrace_cmdlist);

  2749.   add_setshow_boolean_cmd ("past-entry", class_obscure,
  2750.                            &backtrace_past_entry, _("\
  2751. Set whether backtraces should continue past the entry point of a program."),
  2752.                            _("\
  2753. Show whether backtraces should continue past the entry point of a program."),
  2754.                            _("\
  2755. Normally there are no callers beyond the entry point of a program, so GDB\n\
  2756. will terminate the backtrace there.  Set this variable if you need to see\n\
  2757. the rest of the stack trace."),
  2758.                            NULL,
  2759.                            show_backtrace_past_entry,
  2760.                            &set_backtrace_cmdlist,
  2761.                            &show_backtrace_cmdlist);

  2763.   add_setshow_uinteger_cmd ("limit", class_obscure,
  2764.                             &backtrace_limit, _("\
  2765. Set an upper bound on the number of backtrace levels."), _("\
  2766. Show the upper bound on the number of backtrace levels."), _("\
  2767. No more than the specified number of frames can be displayed or examined.\n\
  2768. Literal \"unlimited\" or zero means no limit."),
  2769.                             NULL,
  2770.                             show_backtrace_limit,
  2771.                             &set_backtrace_cmdlist,
  2772.                             &show_backtrace_cmdlist);

  2774.   /* Debug this files internals.  */
  2775.   add_setshow_zuinteger_cmd ("frame", class_maintenance, &frame_debug,  _("\
  2776. Set frame debugging."), _("\
  2777. Show frame debugging."), _("\
  2778. When non-zero, frame specific internal debugging is enabled."),
  2779.                              NULL,
  2780.                              show_frame_debug,
  2781.                              &setdebuglist, &showdebuglist);
  2782. }