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