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