1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2024 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "user-regs.h"
27 #include "gdbsupport/gdb_obstack.h"
28 #include "dummy-frame.h"
29 #include "sentinel-frame.h"
33 #include "frame-unwind.h"
34 #include "frame-base.h"
37 #include "observable.h"
39 #include "gdbthread.h"
41 #include "inline-frame.h"
42 #include "tracepoint.h"
45 #include "cli/cli-option.h"
46 #include "dwarf2/loc.h"
48 /* The sentinel frame terminates the innermost end of the frame chain.
49 If unwound, it returns the information needed to construct an
52 The current frame, which is the innermost frame, can be found at
55 This is an optimization to be able to find the sentinel frame quickly,
56 it could otherwise be found in the frame cache. */
58 static frame_info
*sentinel_frame
;
60 /* Number of calls to reinit_frame_cache. */
61 static unsigned int frame_cache_generation
= 0;
66 get_frame_cache_generation ()
68 return frame_cache_generation
;
71 /* The values behind the global "set backtrace ..." settings. */
72 set_backtrace_options user_set_backtrace_options
;
74 static frame_info_ptr
get_prev_frame_raw (frame_info_ptr this_frame
);
75 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason
);
76 static frame_info_ptr
create_new_frame (frame_id id
);
78 /* Status of some values cached in the frame_info object. */
80 enum cached_copy_status
82 /* Value is unknown. */
85 /* We have a value. */
88 /* Value was not saved. */
91 /* Value is unavailable. */
95 enum class frame_id_status
97 /* Frame id is not computed. */
100 /* Frame id is being computed (compute_frame_id is active). */
103 /* Frame id has been computed. */
107 /* We keep a cache of stack frames, each of which is a "struct
108 frame_info". The innermost one gets allocated (in
109 wait_for_inferior) each time the inferior stops; sentinel_frame
110 points to it. Additional frames get allocated (in get_prev_frame)
111 as needed, and are chained through the next and prev fields. Any
112 time that the frame cache becomes invalid (most notably when we
113 execute something, but also if we change how we interpret the
114 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
115 which reads new symbols)), we should call reinit_frame_cache. */
119 /* Return a string representation of this frame. */
120 std::string
to_string () const;
122 /* Level of this frame. The inner-most (youngest) frame is at level
123 0. As you move towards the outer-most (oldest) frame, the level
124 increases. This is a cached value. It could just as easily be
125 computed by counting back from the selected frame to the inner
127 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
128 reserved to indicate a bogus frame - one that has been created
129 just to keep GDB happy (GDB always needs a frame). For the
130 moment leave this as speculation. */
133 /* The frame's program space. */
134 struct program_space
*pspace
;
136 /* The frame's address space. */
137 const address_space
*aspace
;
139 /* The frame's low-level unwinder and corresponding cache. The
140 low-level unwinder is responsible for unwinding register values
141 for the previous frame. The low-level unwind methods are
142 selected based on the presence, or otherwise, of register unwind
143 information such as CFI. */
144 void *prologue_cache
;
145 const struct frame_unwind
*unwind
;
147 /* Cached copy of the previous frame's architecture. */
151 struct gdbarch
*arch
;
154 /* Cached copy of the previous frame's resume address. */
156 cached_copy_status status
;
157 /* Did VALUE require unmasking when being read. */
162 /* Cached copy of the previous frame's function address. */
166 cached_copy_status status
;
169 /* This frame's ID. */
173 struct frame_id value
;
176 /* The frame's high-level base methods, and corresponding cache.
177 The high level base methods are selected based on the frame's
179 const struct frame_base
*base
;
182 /* Pointers to the next (down, inner, younger) and previous (up,
183 outer, older) frame_info's in the frame cache. */
184 struct frame_info
*next
; /* down, inner, younger */
186 struct frame_info
*prev
; /* up, outer, older */
188 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
189 could. Only valid when PREV_P is set. */
190 enum unwind_stop_reason stop_reason
;
192 /* A frame specific string describing the STOP_REASON in more detail.
193 Only valid when PREV_P is set, but even then may still be NULL. */
194 const char *stop_string
;
200 set_frame_previous_pc_masked (frame_info_ptr frame
)
202 frame
->prev_pc
.masked
= true;
208 get_frame_pc_masked (frame_info_ptr frame
)
210 gdb_assert (frame
->next
!= nullptr);
211 gdb_assert (frame
->next
->prev_pc
.status
== CC_VALUE
);
213 return frame
->next
->prev_pc
.masked
;
216 /* A frame stash used to speed up frame lookups. Create a hash table
217 to stash frames previously accessed from the frame cache for
218 quicker subsequent retrieval. The hash table is emptied whenever
219 the frame cache is invalidated. */
221 static htab_t frame_stash
;
223 /* Internal function to calculate a hash from the frame_id addresses,
224 using as many valid addresses as possible. Frames below level 0
225 are not stored in the hash table. */
228 frame_addr_hash (const void *ap
)
230 const frame_info
*frame
= (const frame_info
*) ap
;
231 const struct frame_id f_id
= frame
->this_id
.value
;
234 gdb_assert (f_id
.stack_status
!= FID_STACK_INVALID
236 || f_id
.special_addr_p
);
238 if (f_id
.stack_status
== FID_STACK_VALID
)
239 hash
= iterative_hash (&f_id
.stack_addr
,
240 sizeof (f_id
.stack_addr
), hash
);
241 if (f_id
.code_addr_p
)
242 hash
= iterative_hash (&f_id
.code_addr
,
243 sizeof (f_id
.code_addr
), hash
);
244 if (f_id
.special_addr_p
)
245 hash
= iterative_hash (&f_id
.special_addr
,
246 sizeof (f_id
.special_addr
), hash
);
248 char user_created_p
= f_id
.user_created_p
;
249 hash
= iterative_hash (&user_created_p
, sizeof (user_created_p
), hash
);
254 /* Internal equality function for the hash table. This function
255 defers equality operations to frame_id::operator==. */
258 frame_addr_hash_eq (const void *a
, const void *b
)
260 const frame_info
*f_entry
= (const frame_info
*) a
;
261 const frame_info
*f_element
= (const frame_info
*) b
;
263 return f_entry
->this_id
.value
== f_element
->this_id
.value
;
266 /* Deletion function for the frame cache hash table. */
269 frame_info_del (frame_info
*frame
)
271 if (frame
->prologue_cache
!= nullptr
272 && frame
->unwind
->dealloc_cache
!= nullptr)
273 frame
->unwind
->dealloc_cache (frame
, frame
->prologue_cache
);
275 if (frame
->base_cache
!= nullptr
276 && frame
->base
->unwind
->dealloc_cache
!= nullptr)
277 frame
->base
->unwind
->dealloc_cache (frame
, frame
->base_cache
);
280 /* Internal function to create the frame_stash hash table. 100 seems
281 to be a good compromise to start the hash table at. */
284 frame_stash_create (void)
286 frame_stash
= htab_create
287 (100, frame_addr_hash
, frame_addr_hash_eq
,
290 auto frame
= static_cast<frame_info
*> (p
);
291 frame_info_del (frame
);
295 /* Internal function to add a frame to the frame_stash hash table.
296 Returns false if a frame with the same ID was already stashed, true
300 frame_stash_add (frame_info
*frame
)
302 /* Valid frame levels are -1 (sentinel frames) and above. */
303 gdb_assert (frame
->level
>= -1);
305 frame_info
**slot
= (frame_info
**) htab_find_slot (frame_stash
,
308 /* If we already have a frame in the stack with the same id, we
309 either have a stack cycle (corrupted stack?), or some bug
310 elsewhere in GDB. In any case, ignore the duplicate and return
311 an indication to the caller. */
312 if (*slot
!= nullptr)
319 /* Internal function to search the frame stash for an entry with the
320 given frame ID. If found, return that frame. Otherwise return
323 static frame_info_ptr
324 frame_stash_find (struct frame_id id
)
326 struct frame_info dummy
;
329 dummy
.this_id
.value
= id
;
330 frame
= (frame_info
*) htab_find (frame_stash
, &dummy
);
331 return frame_info_ptr (frame
);
334 /* Internal function to invalidate the frame stash by removing all
335 entries in it. This only occurs when the frame cache is
339 frame_stash_invalidate (void)
341 htab_empty (frame_stash
);
345 scoped_restore_selected_frame::scoped_restore_selected_frame ()
347 m_lang
= current_language
->la_language
;
348 save_selected_frame (&m_fid
, &m_level
);
352 scoped_restore_selected_frame::~scoped_restore_selected_frame ()
354 restore_selected_frame (m_fid
, m_level
);
355 set_language (m_lang
);
358 /* Flag to control debugging. */
363 show_frame_debug (struct ui_file
*file
, int from_tty
,
364 struct cmd_list_element
*c
, const char *value
)
366 gdb_printf (file
, _("Frame debugging is %s.\n"), value
);
369 /* Implementation of "show backtrace past-main". */
372 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
373 struct cmd_list_element
*c
, const char *value
)
376 _("Whether backtraces should "
377 "continue past \"main\" is %s.\n"),
381 /* Implementation of "show backtrace past-entry". */
384 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
385 struct cmd_list_element
*c
, const char *value
)
387 gdb_printf (file
, _("Whether backtraces should continue past the "
388 "entry point of a program is %s.\n"),
392 /* Implementation of "show backtrace limit". */
395 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
396 struct cmd_list_element
*c
, const char *value
)
399 _("An upper bound on the number "
400 "of backtrace levels is %s.\n"),
407 frame_id::to_string () const
409 const struct frame_id
&id
= *this;
411 std::string res
= "{";
413 if (id
.stack_status
== FID_STACK_INVALID
)
415 else if (id
.stack_status
== FID_STACK_UNAVAILABLE
)
416 res
+= "stack=<unavailable>";
417 else if (id
.stack_status
== FID_STACK_SENTINEL
)
418 res
+= "stack=<sentinel>";
419 else if (id
.stack_status
== FID_STACK_OUTER
)
420 res
+= "stack=<outer>";
422 res
+= std::string ("stack=") + hex_string (id
.stack_addr
);
424 /* Helper function to format 'N=A' if P is true, otherwise '!N'. */
425 auto field_to_string
= [] (const char *n
, bool p
, CORE_ADDR a
) -> std::string
428 return std::string (n
) + "=" + core_addr_to_string (a
);
430 return std::string ("!") + std::string (n
);
433 res
+= (std::string (",")
434 + field_to_string ("code", id
.code_addr_p
, id
.code_addr
)
436 + field_to_string ("special", id
.special_addr_p
, id
.special_addr
));
438 if (id
.artificial_depth
)
439 res
+= ",artificial=" + std::to_string (id
.artificial_depth
);
447 frame_type_str (frame_type type
)
452 return "NORMAL_FRAME";
455 return "DUMMY_FRAME";
458 return "INLINE_FRAME";
461 return "TAILCALL_FRAME";
464 return "SIGTRAMP_FRAME";
470 return "SENTINEL_FRAME";
473 return "<unknown type>";
477 /* See struct frame_info. */
480 frame_info::to_string () const
482 const frame_info
*fi
= this;
486 res
+= string_printf ("{level=%d,", fi
->level
);
488 if (fi
->unwind
!= NULL
)
489 res
+= string_printf ("type=%s,", frame_type_str (fi
->unwind
->type
));
491 res
+= "type=<unknown>,";
493 if (fi
->unwind
!= NULL
)
494 res
+= string_printf ("unwinder=\"%s\",", fi
->unwind
->name
);
496 res
+= "unwinder=<unknown>,";
498 if (fi
->next
== NULL
|| fi
->next
->prev_pc
.status
== CC_UNKNOWN
)
499 res
+= "pc=<unknown>,";
500 else if (fi
->next
->prev_pc
.status
== CC_VALUE
)
501 res
+= string_printf ("pc=%s%s,", hex_string (fi
->next
->prev_pc
.value
),
502 fi
->next
->prev_pc
.masked
? "[PAC]" : "");
503 else if (fi
->next
->prev_pc
.status
== CC_NOT_SAVED
)
504 res
+= "pc=<not saved>,";
505 else if (fi
->next
->prev_pc
.status
== CC_UNAVAILABLE
)
506 res
+= "pc=<unavailable>,";
508 if (fi
->this_id
.p
== frame_id_status::NOT_COMPUTED
)
509 res
+= "id=<not computed>,";
510 else if (fi
->this_id
.p
== frame_id_status::COMPUTING
)
511 res
+= "id=<computing>,";
513 res
+= string_printf ("id=%s,", fi
->this_id
.value
.to_string ().c_str ());
515 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.status
== CC_VALUE
)
516 res
+= string_printf ("func=%s", hex_string (fi
->next
->prev_func
.addr
));
518 res
+= "func=<unknown>";
525 /* Given FRAME, return the enclosing frame as found in real frames read-in from
526 inferior memory. Skip any previous frames which were made up by GDB.
527 Return FRAME if FRAME is a non-artificial frame.
528 Return NULL if FRAME is the start of an artificial-only chain. */
530 static frame_info_ptr
531 skip_artificial_frames (frame_info_ptr frame
)
533 /* Note we use get_prev_frame_always, and not get_prev_frame. The
534 latter will truncate the frame chain, leading to this function
535 unintentionally returning a null_frame_id (e.g., when the user
536 sets a backtrace limit).
538 Note that for record targets we may get a frame chain that consists
539 of artificial frames only. */
540 while (get_frame_type (frame
) == INLINE_FRAME
541 || get_frame_type (frame
) == TAILCALL_FRAME
)
543 frame
= get_prev_frame_always (frame
);
552 skip_unwritable_frames (frame_info_ptr frame
)
554 while (gdbarch_code_of_frame_writable (get_frame_arch (frame
), frame
) == 0)
556 frame
= get_prev_frame (frame
);
567 skip_tailcall_frames (frame_info_ptr frame
)
569 while (get_frame_type (frame
) == TAILCALL_FRAME
)
571 /* Note that for record targets we may get a frame chain that consists of
572 tailcall frames only. */
573 frame
= get_prev_frame (frame
);
581 /* Compute the frame's uniq ID that can be used to, later, re-find the
585 compute_frame_id (frame_info_ptr fi
)
587 FRAME_SCOPED_DEBUG_ENTER_EXIT
;
589 gdb_assert (fi
->this_id
.p
== frame_id_status::NOT_COMPUTED
);
591 unsigned int entry_generation
= get_frame_cache_generation ();
595 /* Mark this frame's id as "being computed. */
596 fi
->this_id
.p
= frame_id_status::COMPUTING
;
598 frame_debug_printf ("fi=%d", fi
->level
);
600 /* Find the unwinder. */
601 if (fi
->unwind
== NULL
)
602 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
604 /* Find THIS frame's ID. */
605 /* Default to outermost if no ID is found. */
606 fi
->this_id
.value
= outer_frame_id
;
607 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
608 gdb_assert (frame_id_p (fi
->this_id
.value
));
610 /* Mark this frame's id as "computed". */
611 fi
->this_id
.p
= frame_id_status::COMPUTED
;
613 frame_debug_printf (" -> %s", fi
->this_id
.value
.to_string ().c_str ());
615 catch (const gdb_exception
&ex
)
617 /* On error, revert the frame id status to not computed. If the frame
618 cache generation changed, the frame object doesn't exist anymore, so
620 if (get_frame_cache_generation () == entry_generation
)
621 fi
->this_id
.p
= frame_id_status::NOT_COMPUTED
;
627 /* Return a frame uniq ID that can be used to, later, re-find the
631 get_frame_id (frame_info_ptr fi
)
634 return null_frame_id
;
636 /* It's always invalid to try to get a frame's id while it is being
638 gdb_assert (fi
->this_id
.p
!= frame_id_status::COMPUTING
);
640 if (fi
->this_id
.p
== frame_id_status::NOT_COMPUTED
)
642 /* If we haven't computed the frame id yet, then it must be that
643 this is the current frame. Compute it now, and stash the
644 result. The IDs of other frames are computed as soon as
645 they're created, in order to detect cycles. See
646 get_prev_frame_if_no_cycle. */
647 gdb_assert (fi
->level
== 0);
650 compute_frame_id (fi
);
652 /* Since this is the first frame in the chain, this should
654 bool stashed
= frame_stash_add (fi
.get ());
655 gdb_assert (stashed
);
658 return fi
->this_id
.value
;
662 get_stack_frame_id (frame_info_ptr next_frame
)
664 return get_frame_id (skip_artificial_frames (next_frame
));
668 frame_unwind_caller_id (frame_info_ptr next_frame
)
670 frame_info_ptr this_frame
;
672 /* Use get_prev_frame_always, and not get_prev_frame. The latter
673 will truncate the frame chain, leading to this function
674 unintentionally returning a null_frame_id (e.g., when a caller
675 requests the frame ID of "main()"s caller. */
677 next_frame
= skip_artificial_frames (next_frame
);
678 if (next_frame
== NULL
)
679 return null_frame_id
;
681 this_frame
= get_prev_frame_always (next_frame
);
683 return get_frame_id (skip_artificial_frames (this_frame
));
685 return null_frame_id
;
688 const struct frame_id null_frame_id
= { 0 }; /* All zeros. */
689 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_OUTER
, 0, 1, 0 };
692 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
693 CORE_ADDR special_addr
)
695 struct frame_id id
= null_frame_id
;
697 id
.stack_addr
= stack_addr
;
698 id
.stack_status
= FID_STACK_VALID
;
699 id
.code_addr
= code_addr
;
700 id
.code_addr_p
= true;
701 id
.special_addr
= special_addr
;
702 id
.special_addr_p
= true;
709 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
711 struct frame_id id
= null_frame_id
;
713 id
.stack_status
= FID_STACK_UNAVAILABLE
;
714 id
.code_addr
= code_addr
;
715 id
.code_addr_p
= true;
722 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
723 CORE_ADDR special_addr
)
725 struct frame_id id
= null_frame_id
;
727 id
.stack_status
= FID_STACK_UNAVAILABLE
;
728 id
.code_addr
= code_addr
;
729 id
.code_addr_p
= true;
730 id
.special_addr
= special_addr
;
731 id
.special_addr_p
= true;
736 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
738 struct frame_id id
= null_frame_id
;
740 id
.stack_addr
= stack_addr
;
741 id
.stack_status
= FID_STACK_VALID
;
742 id
.code_addr
= code_addr
;
743 id
.code_addr_p
= true;
748 frame_id_build_wild (CORE_ADDR stack_addr
)
750 struct frame_id id
= null_frame_id
;
752 id
.stack_addr
= stack_addr
;
753 id
.stack_status
= FID_STACK_VALID
;
760 frame_id_build_sentinel (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
762 frame_id id
= null_frame_id
;
764 id
.stack_status
= FID_STACK_SENTINEL
;
765 id
.special_addr_p
= 1;
767 if (stack_addr
!= 0 || code_addr
!= 0)
769 /* The purpose of saving these in the sentinel frame ID is to be able to
770 differentiate the IDs of several sentinel frames that could exist
771 simultaneously in the frame cache. */
772 id
.stack_addr
= stack_addr
;
773 id
.code_addr
= code_addr
;
781 frame_id_p (frame_id l
)
783 /* The frame is valid iff it has a valid stack address. */
784 bool p
= l
.stack_status
!= FID_STACK_INVALID
;
786 frame_debug_printf ("l=%s -> %d", l
.to_string ().c_str (), p
);
792 frame_id_artificial_p (frame_id l
)
797 return l
.artificial_depth
!= 0;
801 frame_id::operator== (const frame_id
&r
) const
805 if (stack_status
== FID_STACK_INVALID
806 || r
.stack_status
== FID_STACK_INVALID
)
807 /* Like a NaN, if either ID is invalid, the result is false.
808 Note that a frame ID is invalid iff it is the null frame ID. */
810 else if (stack_status
!= r
.stack_status
|| stack_addr
!= r
.stack_addr
)
811 /* If .stack addresses are different, the frames are different. */
813 else if (code_addr_p
&& r
.code_addr_p
&& code_addr
!= r
.code_addr
)
814 /* An invalid code addr is a wild card. If .code addresses are
815 different, the frames are different. */
817 else if (special_addr_p
&& r
.special_addr_p
818 && special_addr
!= r
.special_addr
)
819 /* An invalid special addr is a wild card (or unused). Otherwise
820 if special addresses are different, the frames are different. */
822 else if (artificial_depth
!= r
.artificial_depth
)
823 /* If artificial depths are different, the frames must be different. */
825 else if (user_created_p
!= r
.user_created_p
)
828 /* Frames are equal. */
831 frame_debug_printf ("l=%s, r=%s -> %d",
832 to_string ().c_str (), r
.to_string ().c_str (), eq
);
837 /* Safety net to check whether frame ID L should be inner to
838 frame ID R, according to their stack addresses.
840 This method cannot be used to compare arbitrary frames, as the
841 ranges of valid stack addresses may be discontiguous (e.g. due
844 However, it can be used as safety net to discover invalid frame
845 IDs in certain circumstances. Assuming that NEXT is the immediate
846 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
848 * The stack address of NEXT must be inner-than-or-equal to the stack
851 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
854 * If NEXT and THIS have different stack addresses, no other frame
855 in the frame chain may have a stack address in between.
857 Therefore, if frame_id_inner (TEST, THIS) holds, but
858 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
859 to a valid frame in the frame chain.
861 The sanity checks above cannot be performed when a SIGTRAMP frame
862 is involved, because signal handlers might be executed on a different
863 stack than the stack used by the routine that caused the signal
864 to be raised. This can happen for instance when a thread exceeds
865 its maximum stack size. In this case, certain compilers implement
866 a stack overflow strategy that cause the handler to be run on a
870 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
874 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
875 /* Like NaN, any operation involving an invalid ID always fails.
876 Likewise if either ID has an unavailable stack address. */
878 else if (l
.artificial_depth
> r
.artificial_depth
879 && l
.stack_addr
== r
.stack_addr
880 && l
.code_addr_p
== r
.code_addr_p
881 && l
.special_addr_p
== r
.special_addr_p
882 && l
.special_addr
== r
.special_addr
)
884 /* Same function, different inlined functions. */
885 const struct block
*lb
, *rb
;
887 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
889 lb
= block_for_pc (l
.code_addr
);
890 rb
= block_for_pc (r
.code_addr
);
892 if (lb
== NULL
|| rb
== NULL
)
893 /* Something's gone wrong. */
896 /* This will return true if LB and RB are the same block, or
897 if the block with the smaller depth lexically encloses the
898 block with the greater depth. */
899 inner
= rb
->contains (lb
);
902 /* Only return non-zero when strictly inner than. Note that, per
903 comment in "frame.h", there is some fuzz here. Frameless
904 functions are not strictly inner than (same .stack but
905 different .code and/or .special address). */
906 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
908 frame_debug_printf ("is l=%s inner than r=%s? %d",
909 l
.to_string ().c_str (), r
.to_string ().c_str (),
916 frame_find_by_id (struct frame_id id
)
918 frame_info_ptr frame
, prev_frame
;
920 /* ZERO denotes the null frame, let the caller decide what to do
921 about it. Should it instead return get_current_frame()? */
922 if (!frame_id_p (id
))
925 /* Check for the sentinel frame. */
926 if (id
== frame_id_build_sentinel (0, 0))
927 return frame_info_ptr (sentinel_frame
);
929 /* Try using the frame stash first. Finding it there removes the need
930 to perform the search by looping over all frames, which can be very
931 CPU-intensive if the number of frames is very high (the loop is O(n)
932 and get_prev_frame performs a series of checks that are relatively
933 expensive). This optimization is particularly useful when this function
934 is called from another function (such as value_fetch_lazy, case
935 val->lval () == lval_register) which already loops over all frames,
936 making the overall behavior O(n^2). */
937 frame
= frame_stash_find (id
);
941 for (frame
= get_current_frame (); ; frame
= prev_frame
)
943 struct frame_id self
= get_frame_id (frame
);
946 /* An exact match. */
949 prev_frame
= get_prev_frame (frame
);
953 /* As a safety net to avoid unnecessary backtracing while trying
954 to find an invalid ID, we check for a common situation where
955 we can detect from comparing stack addresses that no other
956 frame in the current frame chain can have this ID. See the
957 comment at frame_id_inner for details. */
958 if (get_frame_type (frame
) == NORMAL_FRAME
959 && !frame_id_inner (get_frame_arch (frame
), id
, self
)
960 && frame_id_inner (get_frame_arch (prev_frame
), id
,
961 get_frame_id (prev_frame
)))
968 frame_unwind_pc (frame_info_ptr this_frame
)
970 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
972 struct gdbarch
*prev_gdbarch
;
976 /* The right way. The `pure' way. The one true way. This
977 method depends solely on the register-unwind code to
978 determine the value of registers in THIS frame, and hence
979 the value of this frame's PC (resume address). A typical
980 implementation is no more than:
982 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
983 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
985 Note: this method is very heavily dependent on a correct
986 register-unwind implementation, it pays to fix that
987 method first; this method is frame type agnostic, since
988 it only deals with register values, it works with any
989 frame. This is all in stark contrast to the old
990 FRAME_SAVED_PC which would try to directly handle all the
991 different ways that a PC could be unwound. */
992 prev_gdbarch
= frame_unwind_arch (this_frame
);
996 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
999 catch (const gdb_exception_error
&ex
)
1001 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1003 this_frame
->prev_pc
.status
= CC_UNAVAILABLE
;
1005 frame_debug_printf ("this_frame=%d -> <unavailable>",
1008 else if (ex
.error
== OPTIMIZED_OUT_ERROR
)
1010 this_frame
->prev_pc
.status
= CC_NOT_SAVED
;
1012 frame_debug_printf ("this_frame=%d -> <not saved>",
1021 this_frame
->prev_pc
.value
= pc
;
1022 this_frame
->prev_pc
.status
= CC_VALUE
;
1024 frame_debug_printf ("this_frame=%d -> %s",
1026 hex_string (this_frame
->prev_pc
.value
));
1030 if (this_frame
->prev_pc
.status
== CC_VALUE
)
1031 return this_frame
->prev_pc
.value
;
1032 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
1033 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
1034 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
1035 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
1037 internal_error ("unexpected prev_pc status: %d",
1038 (int) this_frame
->prev_pc
.status
);
1042 frame_unwind_caller_pc (frame_info_ptr this_frame
)
1044 this_frame
= skip_artificial_frames (this_frame
);
1046 /* We must have a non-artificial frame. The caller is supposed to check
1047 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
1049 gdb_assert (this_frame
!= NULL
);
1051 return frame_unwind_pc (this_frame
);
1055 get_frame_func_if_available (frame_info_ptr this_frame
, CORE_ADDR
*pc
)
1057 frame_info
*next_frame
= this_frame
->next
;
1059 if (next_frame
->prev_func
.status
== CC_UNKNOWN
)
1061 CORE_ADDR addr_in_block
;
1063 /* Make certain that this, and not the adjacent, function is
1065 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
1067 next_frame
->prev_func
.status
= CC_UNAVAILABLE
;
1069 frame_debug_printf ("this_frame=%d -> unavailable",
1074 next_frame
->prev_func
.status
= CC_VALUE
;
1075 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
1077 frame_debug_printf ("this_frame=%d -> %s",
1079 hex_string (next_frame
->prev_func
.addr
));
1083 if (next_frame
->prev_func
.status
== CC_UNAVAILABLE
)
1090 gdb_assert (next_frame
->prev_func
.status
== CC_VALUE
);
1092 *pc
= next_frame
->prev_func
.addr
;
1098 get_frame_func (frame_info_ptr this_frame
)
1102 if (!get_frame_func_if_available (this_frame
, &pc
))
1103 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
1108 std::unique_ptr
<readonly_detached_regcache
>
1109 frame_save_as_regcache (frame_info_ptr this_frame
)
1111 auto cooked_read
= [this_frame
] (int regnum
, gdb::array_view
<gdb_byte
> buf
)
1113 if (!deprecated_frame_register_read (this_frame
, regnum
, buf
.data ()))
1114 return REG_UNAVAILABLE
;
1119 std::unique_ptr
<readonly_detached_regcache
> regcache
1120 (new readonly_detached_regcache (get_frame_arch (this_frame
), cooked_read
));
1126 frame_pop (frame_info_ptr this_frame
)
1128 frame_info_ptr prev_frame
;
1130 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
1132 /* Popping a dummy frame involves restoring more than just registers.
1133 dummy_frame_pop does all the work. */
1134 dummy_frame_pop (get_frame_id (this_frame
), inferior_thread ());
1138 /* Ensure that we have a frame to pop to. */
1139 prev_frame
= get_prev_frame_always (this_frame
);
1142 error (_("Cannot pop the initial frame."));
1144 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1145 entering THISFRAME. */
1146 prev_frame
= skip_tailcall_frames (prev_frame
);
1148 if (prev_frame
== NULL
)
1149 error (_("Cannot find the caller frame."));
1151 /* Make a copy of all the register values unwound from this frame.
1152 Save them in a scratch buffer so that there isn't a race between
1153 trying to extract the old values from the current regcache while
1154 at the same time writing new values into that same cache. */
1155 std::unique_ptr
<readonly_detached_regcache
> scratch
1156 = frame_save_as_regcache (prev_frame
);
1158 /* FIXME: cagney/2003-03-16: It should be possible to tell the
1159 target's register cache that it is about to be hit with a burst
1160 register transfer and that the sequence of register writes should
1161 be batched. The pair target_prepare_to_store() and
1162 target_store_registers() kind of suggest this functionality.
1163 Unfortunately, they don't implement it. Their lack of a formal
1164 definition can lead to targets writing back bogus values
1165 (arguably a bug in the target code mind). */
1166 /* Now copy those saved registers into the current regcache. */
1167 get_thread_regcache (inferior_thread ())->restore (scratch
.get ());
1169 /* We've made right mess of GDB's local state, just discard
1171 reinit_frame_cache ();
1175 frame_register_unwind (frame_info_ptr next_frame
, int regnum
,
1176 int *optimizedp
, int *unavailablep
,
1177 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1178 int *realnump
, gdb_byte
*bufferp
)
1180 struct value
*value
;
1182 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1183 that the value proper does not need to be fetched. */
1184 gdb_assert (optimizedp
!= NULL
);
1185 gdb_assert (lvalp
!= NULL
);
1186 gdb_assert (addrp
!= NULL
);
1187 gdb_assert (realnump
!= NULL
);
1188 /* gdb_assert (bufferp != NULL); */
1190 value
= frame_unwind_register_value (next_frame
, regnum
);
1192 gdb_assert (value
!= NULL
);
1194 *optimizedp
= value
->optimized_out ();
1195 *unavailablep
= !value
->entirely_available ();
1196 *lvalp
= value
->lval ();
1197 *addrp
= value
->address ();
1198 if (*lvalp
== lval_register
)
1199 *realnump
= value
->regnum ();
1205 if (!*optimizedp
&& !*unavailablep
)
1206 memcpy (bufferp
, value
->contents_all ().data (),
1207 value
->type ()->length ());
1209 memset (bufferp
, 0, value
->type ()->length ());
1212 /* Dispose of the new value. This prevents watchpoints from
1213 trying to watch the saved frame pointer. */
1214 release_value (value
);
1218 frame_unwind_register (frame_info_ptr next_frame
, int regnum
, gdb_byte
*buf
)
1224 enum lval_type lval
;
1226 frame_register_unwind (next_frame
, regnum
, &optimized
, &unavailable
,
1227 &lval
, &addr
, &realnum
, buf
);
1230 throw_error (OPTIMIZED_OUT_ERROR
,
1231 _("Register %d was not saved"), regnum
);
1233 throw_error (NOT_AVAILABLE_ERROR
,
1234 _("Register %d is not available"), regnum
);
1238 get_frame_register (frame_info_ptr frame
,
1239 int regnum
, gdb_byte
*buf
)
1241 frame_unwind_register (frame_info_ptr (frame
->next
), regnum
, buf
);
1245 frame_unwind_register_value (frame_info_ptr next_frame
, int regnum
)
1247 FRAME_SCOPED_DEBUG_ENTER_EXIT
;
1249 gdb_assert (next_frame
!= NULL
);
1250 gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1251 frame_debug_printf ("frame=%d, regnum=%d(%s)",
1252 next_frame
->level
, regnum
,
1253 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1255 /* Find the unwinder. */
1256 if (next_frame
->unwind
== NULL
)
1257 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
1259 /* Ask this frame to unwind its register. */
1261 = next_frame
->unwind
->prev_register (next_frame
,
1262 &next_frame
->prologue_cache
, regnum
);
1263 if (value
== nullptr)
1265 if (gdbarch_pseudo_register_read_value_p (gdbarch
))
1267 /* This is a pseudo register, we don't know how how what raw registers
1268 this pseudo register is made of. Ask the gdbarch to read the
1269 value, it will itself ask the next frame to unwind the values of
1270 the raw registers it needs to compose the value of the pseudo
1272 value
= gdbarch_pseudo_register_read_value
1273 (gdbarch
, next_frame
, regnum
);
1275 else if (gdbarch_pseudo_register_read_p (gdbarch
))
1277 value
= value::allocate_register (next_frame
, regnum
);
1279 /* Passing the current regcache is known to be broken, the pseudo
1280 register value will be constructed using the current raw registers,
1281 rather than reading them using NEXT_FRAME. Architectures should be
1282 migrated to gdbarch_pseudo_register_read_value. */
1283 register_status status
= gdbarch_pseudo_register_read
1284 (gdbarch
, get_thread_regcache (inferior_thread ()), regnum
,
1285 value
->contents_writeable ().data ());
1286 if (status
== REG_UNAVAILABLE
)
1287 value
->mark_bytes_unavailable (0, value
->type ()->length ());
1290 error (_("Can't unwind value of register %d (%s)"), regnum
,
1291 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1296 string_file debug_file
;
1298 gdb_printf (&debug_file
, " ->");
1299 if (value
->optimized_out ())
1301 gdb_printf (&debug_file
, " ");
1302 val_print_not_saved (&debug_file
);
1306 if (value
->lval () == lval_register
)
1307 gdb_printf (&debug_file
, " register=%d", value
->regnum ());
1308 else if (value
->lval () == lval_memory
)
1309 gdb_printf (&debug_file
, " address=%s",
1311 value
->address ()));
1313 gdb_printf (&debug_file
, " computed");
1316 gdb_printf (&debug_file
, " lazy");
1320 gdb::array_view
<const gdb_byte
> buf
= value
->contents ();
1322 gdb_printf (&debug_file
, " bytes=");
1323 gdb_printf (&debug_file
, "[");
1324 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1325 gdb_printf (&debug_file
, "%02x", buf
[i
]);
1326 gdb_printf (&debug_file
, "]");
1330 frame_debug_printf ("%s", debug_file
.c_str ());
1337 get_frame_register_value (frame_info_ptr frame
, int regnum
)
1339 return frame_unwind_register_value (frame_info_ptr (frame
->next
), regnum
);
1343 frame_unwind_register_signed (frame_info_ptr next_frame
, int regnum
)
1345 struct gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1346 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1347 struct value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1349 gdb_assert (value
!= NULL
);
1351 if (value
->optimized_out ())
1353 throw_error (OPTIMIZED_OUT_ERROR
,
1354 _("Register %d was not saved"), regnum
);
1356 if (!value
->entirely_available ())
1358 throw_error (NOT_AVAILABLE_ERROR
,
1359 _("Register %d is not available"), regnum
);
1362 LONGEST r
= extract_signed_integer (value
->contents_all (), byte_order
);
1364 release_value (value
);
1369 get_frame_register_signed (frame_info_ptr frame
, int regnum
)
1371 return frame_unwind_register_signed (frame_info_ptr (frame
->next
), regnum
);
1375 frame_unwind_register_unsigned (frame_info_ptr next_frame
, int regnum
)
1377 struct gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1378 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1379 int size
= register_size (gdbarch
, regnum
);
1380 struct value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1382 gdb_assert (value
!= NULL
);
1384 if (value
->optimized_out ())
1386 throw_error (OPTIMIZED_OUT_ERROR
,
1387 _("Register %d was not saved"), regnum
);
1389 if (!value
->entirely_available ())
1391 throw_error (NOT_AVAILABLE_ERROR
,
1392 _("Register %d is not available"), regnum
);
1395 ULONGEST r
= extract_unsigned_integer (value
->contents_all ().data (),
1398 release_value (value
);
1403 get_frame_register_unsigned (frame_info_ptr frame
, int regnum
)
1405 return frame_unwind_register_unsigned (frame_info_ptr (frame
->next
), regnum
);
1409 read_frame_register_unsigned (frame_info_ptr frame
, int regnum
,
1412 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1414 if (!regval
->optimized_out ()
1415 && regval
->entirely_available ())
1417 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1418 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1419 int size
= register_size (gdbarch
, regval
->regnum ());
1421 *val
= extract_unsigned_integer (regval
->contents ().data (), size
,
1430 put_frame_register (frame_info_ptr next_frame
, int regnum
,
1431 gdb::array_view
<const gdb_byte
> buf
)
1433 gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1437 enum lval_type lval
;
1439 int size
= register_size (gdbarch
, regnum
);
1441 gdb_assert (buf
.size () == size
);
1443 frame_register_unwind (next_frame
, regnum
, &optim
, &unavail
, &lval
, &addr
,
1446 error (_("Attempt to assign to a register that was not saved."));
1451 write_memory (addr
, buf
.data (), size
);
1455 /* Not sure if that's always true... but we have a problem if not. */
1456 gdb_assert (size
== register_size (gdbarch
, realnum
));
1458 if (realnum
< gdbarch_num_regs (gdbarch
)
1459 || !gdbarch_pseudo_register_write_p (gdbarch
))
1460 get_thread_regcache (inferior_thread ())->cooked_write (realnum
, buf
);
1462 gdbarch_pseudo_register_write (gdbarch
, next_frame
, realnum
, buf
);
1465 error (_("Attempt to assign to an unmodifiable value."));
1469 /* This function is deprecated. Use get_frame_register_value instead,
1470 which provides more accurate information.
1472 Find and return the value of REGNUM for the specified stack frame.
1473 The number of bytes copied is REGISTER_SIZE (REGNUM).
1475 Returns 0 if the register value could not be found. */
1478 deprecated_frame_register_read (frame_info_ptr frame
, int regnum
,
1483 enum lval_type lval
;
1487 frame_register_unwind (get_next_frame_sentinel_okay (frame
), regnum
,
1488 &optimized
, &unavailable
, &lval
, &addr
, &realnum
,
1491 return !optimized
&& !unavailable
;
1495 get_frame_register_bytes (frame_info_ptr next_frame
, int regnum
,
1496 CORE_ADDR offset
, gdb::array_view
<gdb_byte
> buffer
,
1497 int *optimizedp
, int *unavailablep
)
1499 gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1501 /* Skip registers wholly inside of OFFSET. */
1502 while (offset
>= register_size (gdbarch
, regnum
))
1504 offset
-= register_size (gdbarch
, regnum
);
1508 /* Ensure that we will not read beyond the end of the register file.
1509 This can only ever happen if the debug information is bad. */
1510 int maxsize
= -offset
;
1511 int numregs
= gdbarch_num_cooked_regs (gdbarch
);
1512 for (int i
= regnum
; i
< numregs
; i
++)
1514 int thissize
= register_size (gdbarch
, i
);
1517 break; /* This register is not available on this architecture. */
1518 maxsize
+= thissize
;
1521 if (buffer
.size () > maxsize
)
1522 error (_("Bad debug information detected: "
1523 "Attempt to read %zu bytes from registers."), buffer
.size ());
1525 /* Copy the data. */
1526 while (!buffer
.empty ())
1528 int curr_len
= std::min
<int> (register_size (gdbarch
, regnum
) - offset
,
1531 if (curr_len
== register_size (gdbarch
, regnum
))
1533 enum lval_type lval
;
1537 frame_register_unwind (next_frame
, regnum
, optimizedp
, unavailablep
,
1538 &lval
, &addr
, &realnum
, buffer
.data ());
1539 if (*optimizedp
|| *unavailablep
)
1544 value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1545 gdb_assert (value
!= NULL
);
1546 *optimizedp
= value
->optimized_out ();
1547 *unavailablep
= !value
->entirely_available ();
1549 if (*optimizedp
|| *unavailablep
)
1551 release_value (value
);
1555 copy (value
->contents_all ().slice (offset
, curr_len
),
1556 buffer
.slice (0, curr_len
));
1557 release_value (value
);
1560 buffer
= buffer
.slice (curr_len
);
1572 put_frame_register_bytes (frame_info_ptr next_frame
, int regnum
,
1574 gdb::array_view
<const gdb_byte
> buffer
)
1576 gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1578 /* Skip registers wholly inside of OFFSET. */
1579 while (offset
>= register_size (gdbarch
, regnum
))
1581 offset
-= register_size (gdbarch
, regnum
);
1585 /* Copy the data. */
1586 while (!buffer
.empty ())
1588 int curr_len
= std::min
<int> (register_size (gdbarch
, regnum
) - offset
,
1591 if (curr_len
== register_size (gdbarch
, regnum
))
1592 put_frame_register (next_frame
, regnum
, buffer
.slice (0, curr_len
));
1595 value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1596 gdb_assert (value
!= nullptr);
1598 copy (buffer
.slice (0, curr_len
),
1599 value
->contents_writeable ().slice (offset
, curr_len
));
1600 put_frame_register (next_frame
, regnum
, value
->contents_raw ());
1601 release_value (value
);
1604 buffer
= buffer
.slice (curr_len
);
1610 /* Create a sentinel frame.
1612 See frame_id_build_sentinel for the description of STACK_ADDR and
1615 static frame_info_ptr
1616 create_sentinel_frame (program_space
*pspace
, address_space
*aspace
,
1617 regcache
*regcache
, CORE_ADDR stack_addr
,
1618 CORE_ADDR code_addr
)
1620 frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1623 frame
->pspace
= pspace
;
1624 frame
->aspace
= aspace
;
1625 /* Explicitly initialize the sentinel frame's cache. Provide it
1626 with the underlying regcache. In the future additional
1627 information, such as the frame's thread will be added. */
1628 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1629 /* For the moment there is only one sentinel frame implementation. */
1630 frame
->unwind
= &sentinel_frame_unwind
;
1631 /* Link this frame back to itself. The frame is self referential
1632 (the unwound PC is the same as the pc), so make it so. */
1633 frame
->next
= frame
;
1634 /* The sentinel frame has a special ID. */
1635 frame
->this_id
.p
= frame_id_status::COMPUTED
;
1636 frame
->this_id
.value
= frame_id_build_sentinel (stack_addr
, code_addr
);
1638 bool added
= frame_stash_add (frame
);
1641 frame_debug_printf (" -> %s", frame
->to_string ().c_str ());
1643 return frame_info_ptr (frame
);
1646 /* Cache for frame addresses already read by gdb. Valid only while
1647 inferior is stopped. Control variables for the frame cache should
1648 be local to this module. */
1650 static struct obstack frame_cache_obstack
;
1653 frame_obstack_zalloc (unsigned long size
)
1655 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1657 memset (data
, 0, size
);
1661 static frame_info_ptr
get_prev_frame_always_1 (frame_info_ptr this_frame
);
1664 get_current_frame (void)
1666 frame_info_ptr current_frame
;
1668 /* First check, and report, the lack of registers. Having GDB
1669 report "No stack!" or "No memory" when the target doesn't even
1670 have registers is very confusing. Besides, "printcmd.exp"
1671 explicitly checks that ``print $pc'' with no registers prints "No
1673 if (!target_has_registers ())
1674 error (_("No registers."));
1675 if (!target_has_stack ())
1676 error (_("No stack."));
1677 if (!target_has_memory ())
1678 error (_("No memory."));
1679 /* Traceframes are effectively a substitute for the live inferior. */
1680 if (get_traceframe_number () < 0)
1681 validate_registers_access ();
1683 if (sentinel_frame
== NULL
)
1685 create_sentinel_frame (current_program_space
,
1686 current_inferior ()->aspace
.get (),
1687 get_thread_regcache (inferior_thread ()),
1690 /* Set the current frame before computing the frame id, to avoid
1691 recursion inside compute_frame_id, in case the frame's
1692 unwinder decides to do a symbol lookup (which depends on the
1693 selected frame's block).
1695 This call must always succeed. In particular, nothing inside
1696 get_prev_frame_always_1 should try to unwind from the
1697 sentinel frame, because that could fail/throw, and we always
1698 want to leave with the current frame created and linked in --
1699 we should never end up with the sentinel frame as outermost
1701 current_frame
= get_prev_frame_always_1 (frame_info_ptr (sentinel_frame
));
1702 gdb_assert (current_frame
!= NULL
);
1704 return current_frame
;
1707 /* The "selected" stack frame is used by default for local and arg
1710 The "single source of truth" for the selected frame is the
1711 SELECTED_FRAME_ID / SELECTED_FRAME_LEVEL pair.
1713 Frame IDs can be saved/restored across reinitializing the frame
1714 cache, while frame_info pointers can't (frame_info objects are
1715 invalidated). If we know the corresponding frame_info object, it
1716 is cached in SELECTED_FRAME.
1718 If SELECTED_FRAME_ID / SELECTED_FRAME_LEVEL are null_frame_id / -1,
1719 and the target has stack and is stopped, the selected frame is the
1720 current (innermost) target frame. SELECTED_FRAME_ID is never the ID
1721 of the current (innermost) target frame. SELECTED_FRAME_LEVEL may
1722 only be 0 if the selected frame is a user-created one (created and
1723 selected through the "select-frame view" command), in which case
1724 SELECTED_FRAME_ID is the frame id derived from the user-provided
1727 If SELECTED_FRAME_ID / SELECTED_FRAME_LEVEL are null_frame_id / -1,
1728 and the target has no stack or is executing, then there's no
1730 static frame_id selected_frame_id
= null_frame_id
;
1731 static int selected_frame_level
= -1;
1733 /* See frame.h. This definition should come before any definition of a static
1734 frame_info_ptr, to ensure that frame_list is destroyed after any static
1735 frame_info_ptr. This is necessary because the destructor of frame_info_ptr
1738 intrusive_list
<frame_info_ptr
> frame_info_ptr::frame_list
;
1740 /* The cached frame_info object pointing to the selected frame.
1741 Looked up on demand by get_selected_frame. */
1742 static frame_info_ptr selected_frame
;
1747 save_selected_frame (frame_id
*frame_id
, int *frame_level
)
1750 *frame_id
= selected_frame_id
;
1751 *frame_level
= selected_frame_level
;
1757 restore_selected_frame (frame_id frame_id
, int frame_level
)
1760 /* Unless it is a user-created frame, save_selected_frame never returns
1761 level == 0, so we shouldn't see it here either. */
1762 gdb_assert (frame_level
!= 0 || frame_id
.user_created_p
);
1764 /* FRAME_ID can be null_frame_id only IFF frame_level is -1. */
1765 gdb_assert ((frame_level
== -1 && !frame_id_p (frame_id
))
1766 || (frame_level
!= -1 && frame_id_p (frame_id
)));
1768 selected_frame_id
= frame_id
;
1769 selected_frame_level
= frame_level
;
1771 /* Will be looked up later by get_selected_frame. */
1772 selected_frame
= nullptr;
1775 /* Lookup the frame_info object for the selected frame FRAME_ID /
1776 FRAME_LEVEL and cache the result.
1778 If FRAME_LEVEL > 0 and the originally selected frame isn't found,
1779 warn and select the innermost (current) frame. */
1782 lookup_selected_frame (struct frame_id a_frame_id
, int frame_level
)
1784 frame_info_ptr frame
= NULL
;
1787 /* This either means there was no selected frame, or the selected
1788 frame was the current frame. In either case, select the current
1790 if (frame_level
== -1)
1792 select_frame (get_current_frame ());
1796 /* This means the selected frame was a user-created one. Create a new one
1797 using the user-provided addresses, which happen to be in the frame id. */
1798 if (frame_level
== 0)
1800 gdb_assert (a_frame_id
.user_created_p
);
1801 select_frame (create_new_frame (a_frame_id
));
1805 /* select_frame never saves 0 in SELECTED_FRAME_LEVEL, so we
1806 shouldn't see it here. */
1807 gdb_assert (frame_level
> 0);
1809 /* Restore by level first, check if the frame id is the same as
1810 expected. If that fails, try restoring by frame id. If that
1811 fails, nothing to do, just warn the user. */
1813 count
= frame_level
;
1814 frame
= find_relative_frame (get_current_frame (), &count
);
1817 /* The frame ids must match - either both valid or both
1818 outer_frame_id. The latter case is not failsafe, but since
1819 it's highly unlikely the search by level finds the wrong
1820 frame, it's 99.9(9)% of the time (for all practical purposes)
1822 && get_frame_id (frame
) == a_frame_id
)
1824 /* Cool, all is fine. */
1825 select_frame (frame
);
1829 frame
= frame_find_by_id (a_frame_id
);
1832 /* Cool, refound it. */
1833 select_frame (frame
);
1837 /* Nothing else to do, the frame layout really changed. Select the
1838 innermost stack frame. */
1839 select_frame (get_current_frame ());
1841 /* Warn the user. */
1842 if (frame_level
> 0 && !current_uiout
->is_mi_like_p ())
1844 warning (_("Couldn't restore frame #%d in "
1845 "current thread. Bottom (innermost) frame selected:"),
1847 /* For MI, we should probably have a notification about current
1848 frame change. But this error is not very likely, so don't
1850 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1857 if (!target_has_registers () || !target_has_stack ()
1858 || !target_has_memory ())
1861 /* Traceframes are effectively a substitute for the live inferior. */
1862 if (get_traceframe_number () < 0)
1864 /* No current inferior, no frame. */
1865 if (inferior_ptid
== null_ptid
)
1868 thread_info
*tp
= inferior_thread ();
1869 /* Don't try to read from a dead thread. */
1870 if (tp
->state
== THREAD_EXITED
)
1873 /* ... or from a spinning thread. */
1874 if (tp
->executing ())
1884 get_selected_frame (const char *message
)
1886 if (selected_frame
== NULL
)
1888 if (message
!= NULL
&& !has_stack_frames ())
1889 error (("%s"), message
);
1891 lookup_selected_frame (selected_frame_id
, selected_frame_level
);
1893 /* There is always a frame. */
1894 gdb_assert (selected_frame
!= NULL
);
1895 return selected_frame
;
1898 /* This is a variant of get_selected_frame() which can be called when
1899 the inferior does not have a frame; in that case it will return
1900 NULL instead of calling error(). */
1903 deprecated_safe_get_selected_frame (void)
1905 if (!has_stack_frames ())
1907 return get_selected_frame (NULL
);
1910 /* Invalidate the selected frame. */
1913 invalidate_selected_frame ()
1915 selected_frame
= nullptr;
1916 selected_frame_level
= -1;
1917 selected_frame_id
= null_frame_id
;
1923 select_frame (frame_info_ptr fi
)
1925 gdb_assert (fi
!= nullptr);
1927 selected_frame
= fi
;
1928 selected_frame_level
= frame_relative_level (fi
);
1930 /* If the frame is a user-created one, save its level and frame id just like
1931 any other non-level-0 frame. */
1932 if (selected_frame_level
== 0 && !fi
->this_id
.value
.user_created_p
)
1934 /* Treat the current frame especially -- we want to always
1935 save/restore it without warning, even if the frame ID changes
1936 (see lookup_selected_frame). E.g.:
1938 // The current frame is selected, the target had just stopped.
1940 scoped_restore_selected_frame restore_frame;
1941 some_operation_that_changes_the_stack ();
1943 // scoped_restore_selected_frame's dtor runs, but the
1944 // original frame_id can't be found. No matter whether it
1945 // is found or not, we still end up with the now-current
1946 // frame selected. Warning in lookup_selected_frame in this
1947 // case seems pointless.
1949 Also get_frame_id may access the target's registers/memory,
1950 and thus skipping get_frame_id optimizes the common case.
1952 Saving the selected frame this way makes get_selected_frame
1953 and restore_current_frame return/re-select whatever frame is
1954 the innermost (current) then. */
1955 selected_frame_level
= -1;
1956 selected_frame_id
= null_frame_id
;
1959 selected_frame_id
= get_frame_id (fi
);
1961 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1962 frame is being invalidated. */
1964 /* FIXME: kseitz/2002-08-28: It would be nice to call
1965 selected_frame_level_changed_event() right here, but due to limitations
1966 in the current interfaces, we would end up flooding UIs with events
1967 because select_frame() is used extensively internally.
1969 Once we have frame-parameterized frame (and frame-related) commands,
1970 the event notification can be moved here, since this function will only
1971 be called when the user's selected frame is being changed. */
1973 /* Ensure that symbols for this frame are read in. Also, determine the
1974 source language of this frame, and switch to it if desired. */
1979 /* We retrieve the frame's symtab by using the frame PC.
1980 However we cannot use the frame PC as-is, because it usually
1981 points to the instruction following the "call", which is
1982 sometimes the first instruction of another function. So we
1983 rely on get_frame_address_in_block() which provides us with a
1984 PC which is guaranteed to be inside the frame's code
1986 if (get_frame_address_in_block_if_available (fi
, &pc
))
1988 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
1991 && cust
->language () != current_language
->la_language
1992 && cust
->language () != language_unknown
1993 && language_mode
== language_mode_auto
)
1994 set_language (cust
->language ());
1999 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
2000 Always returns a non-NULL value. */
2002 static frame_info_ptr
2003 create_new_frame (frame_id id
)
2005 gdb_assert (id
.user_created_p
);
2006 gdb_assert (id
.stack_status
== frame_id_stack_status::FID_STACK_VALID
);
2007 gdb_assert (id
.code_addr_p
);
2009 frame_debug_printf ("stack_addr=%s, core_addr=%s",
2010 hex_string (id
.stack_addr
), hex_string (id
.code_addr
));
2012 /* Avoid creating duplicate frames, search for an existing frame with that id
2014 frame_info_ptr frame
= frame_stash_find (id
);
2015 if (frame
!= nullptr)
2018 frame_info
*fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2020 fi
->next
= create_sentinel_frame (current_program_space
,
2021 current_inferior ()->aspace
.get (),
2022 get_thread_regcache (inferior_thread ()),
2023 id
.stack_addr
, id
.code_addr
).get ();
2025 /* Set/update this frame's cached PC value, found in the next frame.
2026 Do this before looking for this frame's unwinder. A sniffer is
2027 very likely to read this, and the corresponding unwinder is
2028 entitled to rely that the PC doesn't magically change. */
2029 fi
->next
->prev_pc
.value
= id
.code_addr
;
2030 fi
->next
->prev_pc
.status
= CC_VALUE
;
2032 /* We currently assume that frame chain's can't cross spaces. */
2033 fi
->pspace
= fi
->next
->pspace
;
2034 fi
->aspace
= fi
->next
->aspace
;
2036 /* Select/initialize both the unwind function and the frame's type
2038 frame_unwind_find_by_frame (frame_info_ptr (fi
), &fi
->prologue_cache
);
2040 fi
->this_id
.p
= frame_id_status::COMPUTED
;
2041 fi
->this_id
.value
= id
;
2043 bool added
= frame_stash_add (fi
);
2046 frame_debug_printf (" -> %s", fi
->to_string ().c_str ());
2048 return frame_info_ptr (fi
);
2052 create_new_frame (CORE_ADDR stack
, CORE_ADDR pc
)
2054 frame_id id
= frame_id_build (stack
, pc
);
2055 id
.user_created_p
= 1;
2057 return create_new_frame (id
);
2060 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
2061 innermost frame). Be careful to not fall off the bottom of the
2062 frame chain and onto the sentinel frame. */
2065 get_next_frame (frame_info_ptr this_frame
)
2067 if (this_frame
->level
> 0)
2068 return frame_info_ptr (this_frame
->next
);
2073 /* Return the frame that THIS_FRAME calls. If THIS_FRAME is the
2074 innermost (i.e. current) frame, return the sentinel frame. Thus,
2075 unlike get_next_frame(), NULL will never be returned. */
2078 get_next_frame_sentinel_okay (frame_info_ptr this_frame
)
2080 gdb_assert (this_frame
!= NULL
);
2082 /* Note that, due to the manner in which the sentinel frame is
2083 constructed, this_frame->next still works even when this_frame
2084 is the sentinel frame. But we disallow it here anyway because
2085 calling get_next_frame_sentinel_okay() on the sentinel frame
2086 is likely a coding error. */
2087 if (this_frame
->this_id
.p
== frame_id_status::COMPUTED
)
2088 gdb_assert (!is_sentinel_frame_id (this_frame
->this_id
.value
));
2090 return frame_info_ptr (this_frame
->next
);
2093 /* Observer for the target_changed event. */
2096 frame_observer_target_changed (struct target_ops
*target
)
2098 reinit_frame_cache ();
2101 /* Flush the entire frame cache. */
2104 reinit_frame_cache (void)
2106 ++frame_cache_generation
;
2108 if (htab_elements (frame_stash
) > 0)
2109 annotate_frames_invalid ();
2111 invalidate_selected_frame ();
2113 /* Invalidate cache. */
2114 if (sentinel_frame
!= nullptr)
2116 /* If frame 0's id is not computed, it is not in the frame stash, so its
2117 dealloc functions will not be called when emptying the frame stash.
2118 Call frame_info_del manually in that case. */
2119 frame_info
*current_frame
= sentinel_frame
->prev
;
2120 if (current_frame
!= nullptr
2121 && current_frame
->this_id
.p
== frame_id_status::NOT_COMPUTED
)
2122 frame_info_del (current_frame
);
2124 sentinel_frame
= nullptr;
2127 frame_stash_invalidate ();
2129 /* Since we can't really be sure what the first object allocated was. */
2130 obstack_free (&frame_cache_obstack
, 0);
2131 obstack_init (&frame_cache_obstack
);
2133 for (frame_info_ptr
&iter
: frame_info_ptr::frame_list
)
2136 frame_debug_printf ("generation=%d", frame_cache_generation
);
2139 /* Find where a register is saved (in memory or another register).
2140 The result of frame_register_unwind is just where it is saved
2141 relative to this particular frame. */
2144 frame_register_unwind_location (frame_info_ptr this_frame
, int regnum
,
2145 int *optimizedp
, enum lval_type
*lvalp
,
2146 CORE_ADDR
*addrp
, int *realnump
)
2148 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
2150 while (this_frame
!= NULL
)
2154 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
2155 lvalp
, addrp
, realnump
, NULL
);
2160 if (*lvalp
!= lval_register
)
2164 this_frame
= get_next_frame (this_frame
);
2168 /* Get the previous raw frame, and check that it is not identical to
2169 same other frame frame already in the chain. If it is, there is
2170 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
2171 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
2172 validity tests, that compare THIS_FRAME and the next frame, we do
2173 this right after creating the previous frame, to avoid ever ending
2174 up with two frames with the same id in the frame chain.
2176 There is however, one case where this cycle detection is not desirable,
2177 when asking for the previous frame of an inline frame, in this case, if
2178 the previous frame is a duplicate and we return nullptr then we will be
2179 unable to calculate the frame_id of the inline frame, this in turn
2180 causes inline_frame_this_id() to fail. So for inline frames (and only
2181 for inline frames), the previous frame will always be returned, even when it
2182 has a duplicate frame_id. We're not worried about cycles in the frame
2183 chain as, if the previous frame returned here has a duplicate frame_id,
2184 then the frame_id of the inline frame, calculated based off the frame_id
2185 of the previous frame, should also be a duplicate. */
2187 static frame_info_ptr
2188 get_prev_frame_maybe_check_cycle (frame_info_ptr this_frame
)
2190 frame_info_ptr prev_frame
= get_prev_frame_raw (this_frame
);
2192 /* Don't compute the frame id of the current frame yet. Unwinding
2193 the sentinel frame can fail (e.g., if the thread is gone and we
2194 can't thus read its registers). If we let the cycle detection
2195 code below try to compute a frame ID, then an error thrown from
2196 within the frame ID computation would result in the sentinel
2197 frame as outermost frame, which is bogus. Instead, we'll compute
2198 the current frame's ID lazily in get_frame_id. Note that there's
2199 no point in doing cycle detection when there's only one frame, so
2200 nothing is lost here. */
2201 if (prev_frame
->level
== 0)
2204 unsigned int entry_generation
= get_frame_cache_generation ();
2208 compute_frame_id (prev_frame
);
2210 bool cycle_detection_p
= get_frame_type (this_frame
) != INLINE_FRAME
;
2212 /* This assert checks GDB's state with respect to calculating the
2213 frame-id of THIS_FRAME, in the case where THIS_FRAME is an inline
2216 If THIS_FRAME is frame #0, and is an inline frame, then we put off
2217 calculating the frame_id until we specifically make a call to
2218 get_frame_id(). As a result we can enter this function in two
2219 possible states. If GDB asked for the previous frame of frame #0
2220 then THIS_FRAME will be frame #0 (an inline frame), and the
2221 frame_id will be in the NOT_COMPUTED state. However, if GDB asked
2222 for the frame_id of frame #0, then, as getting the frame_id of an
2223 inline frame requires us to get the frame_id of the previous
2224 frame, we will still end up in here, and the frame_id status will
2227 If, instead, THIS_FRAME is at a level greater than #0 then things
2228 are simpler. For these frames we immediately compute the frame_id
2229 when the frame is initially created, and so, for those frames, we
2230 will always enter this function with the frame_id status of
2232 gdb_assert (cycle_detection_p
2233 || (this_frame
->level
> 0
2234 && (this_frame
->this_id
.p
2235 == frame_id_status::COMPUTING
))
2236 || (this_frame
->level
== 0
2237 && (this_frame
->this_id
.p
2238 != frame_id_status::COMPUTED
)));
2240 /* We must do the CYCLE_DETECTION_P check after attempting to add
2241 PREV_FRAME into the cache; if PREV_FRAME is unique then we do want
2242 it in the cache, but if it is a duplicate and CYCLE_DETECTION_P is
2243 false, then we don't want to unlink it. */
2244 if (!frame_stash_add (prev_frame
.get ()) && cycle_detection_p
)
2246 /* Another frame with the same id was already in the stash. We just
2247 detected a cycle. */
2248 frame_debug_printf (" -> nullptr // this frame has same ID");
2250 this_frame
->stop_reason
= UNWIND_SAME_ID
;
2252 prev_frame
->next
= NULL
;
2253 this_frame
->prev
= NULL
;
2257 catch (const gdb_exception
&ex
)
2259 if (get_frame_cache_generation () == entry_generation
)
2261 prev_frame
->next
= NULL
;
2262 this_frame
->prev
= NULL
;
2271 /* Helper function for get_prev_frame_always, this is called inside a
2272 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
2273 there is no such frame. This may throw an exception. */
2275 static frame_info_ptr
2276 get_prev_frame_always_1 (frame_info_ptr this_frame
)
2278 FRAME_SCOPED_DEBUG_ENTER_EXIT
;
2280 gdb_assert (this_frame
!= NULL
);
2284 if (this_frame
!= NULL
)
2285 frame_debug_printf ("this_frame=%d", this_frame
->level
);
2287 frame_debug_printf ("this_frame=nullptr");
2290 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2292 /* Only try to do the unwind once. */
2293 if (this_frame
->prev_p
)
2295 if (this_frame
->prev
!= nullptr)
2296 frame_debug_printf (" -> %s // cached",
2297 this_frame
->prev
->to_string ().c_str ());
2300 (" -> nullptr // %s // cached",
2301 frame_stop_reason_symbol_string (this_frame
->stop_reason
));
2302 return frame_info_ptr (this_frame
->prev
);
2305 /* If the frame unwinder hasn't been selected yet, we must do so
2306 before setting prev_p; otherwise the check for misbehaved
2307 sniffers will think that this frame's sniffer tried to unwind
2308 further (see frame_cleanup_after_sniffer). */
2309 if (this_frame
->unwind
== NULL
)
2310 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
2312 this_frame
->prev_p
= true;
2313 this_frame
->stop_reason
= UNWIND_NO_REASON
;
2315 /* If we are unwinding from an inline frame, all of the below tests
2316 were already performed when we unwound from the next non-inline
2317 frame. We must skip them, since we can not get THIS_FRAME's ID
2318 until we have unwound all the way down to the previous non-inline
2320 if (get_frame_type (this_frame
) == INLINE_FRAME
)
2321 return get_prev_frame_maybe_check_cycle (this_frame
);
2323 /* If this_frame is the current frame, then compute and stash its
2324 frame id prior to fetching and computing the frame id of the
2325 previous frame. Otherwise, the cycle detection code in
2326 get_prev_frame_if_no_cycle() will not work correctly. When
2327 get_frame_id() is called later on, an assertion error will be
2328 triggered in the event of a cycle between the current frame and
2331 Note we do this after the INLINE_FRAME check above. That is
2332 because the inline frame's frame id computation needs to fetch
2333 the frame id of its previous real stack frame. I.e., we need to
2334 avoid recursion in that case. This is OK since we're sure the
2335 inline frame won't create a cycle with the real stack frame. See
2336 inline_frame_this_id. */
2337 if (this_frame
->level
== 0)
2338 get_frame_id (this_frame
);
2340 /* Check that this frame is unwindable. If it isn't, don't try to
2341 unwind to the prev frame. */
2342 this_frame
->stop_reason
2343 = this_frame
->unwind
->stop_reason (this_frame
,
2344 &this_frame
->prologue_cache
);
2346 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
2349 (" -> nullptr // %s",
2350 frame_stop_reason_symbol_string (this_frame
->stop_reason
));
2354 /* Check that this frame's ID isn't inner to (younger, below, next)
2355 the next frame. This happens when a frame unwind goes backwards.
2356 This check is valid only if this frame and the next frame are NORMAL.
2357 See the comment at frame_id_inner for details. */
2358 if (get_frame_type (this_frame
) == NORMAL_FRAME
2359 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
2360 && frame_id_inner (get_frame_arch (frame_info_ptr (this_frame
->next
)),
2361 get_frame_id (this_frame
),
2362 get_frame_id (frame_info_ptr (this_frame
->next
))))
2364 CORE_ADDR this_pc_in_block
;
2365 struct minimal_symbol
*morestack_msym
;
2366 const char *morestack_name
= NULL
;
2368 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
2369 this_pc_in_block
= get_frame_address_in_block (this_frame
);
2370 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
2372 morestack_name
= morestack_msym
->linkage_name ();
2373 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
2375 frame_debug_printf (" -> nullptr // this frame ID is inner");
2376 this_frame
->stop_reason
= UNWIND_INNER_ID
;
2381 /* Check that this and the next frame do not unwind the PC register
2382 to the same memory location. If they do, then even though they
2383 have different frame IDs, the new frame will be bogus; two
2384 functions can't share a register save slot for the PC. This can
2385 happen when the prologue analyzer finds a stack adjustment, but
2388 This check does assume that the "PC register" is roughly a
2389 traditional PC, even if the gdbarch_unwind_pc method adjusts
2390 it (we do not rely on the value, only on the unwound PC being
2391 dependent on this value). A potential improvement would be
2392 to have the frame prev_pc method and the gdbarch unwind_pc
2393 method set the same lval and location information as
2394 frame_register_unwind. */
2395 if (this_frame
->level
> 0
2396 && gdbarch_pc_regnum (gdbarch
) >= 0
2397 && get_frame_type (this_frame
) == NORMAL_FRAME
2398 && (get_frame_type (frame_info_ptr (this_frame
->next
)) == NORMAL_FRAME
2399 || get_frame_type (frame_info_ptr (this_frame
->next
)) == INLINE_FRAME
))
2401 int optimized
, realnum
, nrealnum
;
2402 enum lval_type lval
, nlval
;
2403 CORE_ADDR addr
, naddr
;
2405 frame_register_unwind_location (this_frame
,
2406 gdbarch_pc_regnum (gdbarch
),
2407 &optimized
, &lval
, &addr
, &realnum
);
2408 frame_register_unwind_location (get_next_frame (this_frame
),
2409 gdbarch_pc_regnum (gdbarch
),
2410 &optimized
, &nlval
, &naddr
, &nrealnum
);
2412 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
2413 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
2415 frame_debug_printf (" -> nullptr // no saved PC");
2416 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
2417 this_frame
->prev
= NULL
;
2422 return get_prev_frame_maybe_check_cycle (this_frame
);
2425 /* Return a "struct frame_info" corresponding to the frame that called
2426 THIS_FRAME. Returns NULL if there is no such frame.
2428 Unlike get_prev_frame, this function always tries to unwind the
2432 get_prev_frame_always (frame_info_ptr this_frame
)
2434 frame_info_ptr prev_frame
= NULL
;
2438 prev_frame
= get_prev_frame_always_1 (this_frame
);
2440 catch (const gdb_exception_error
&ex
)
2442 if (ex
.error
== MEMORY_ERROR
)
2444 this_frame
->stop_reason
= UNWIND_MEMORY_ERROR
;
2445 if (ex
.message
!= NULL
)
2450 /* The error needs to live as long as the frame does.
2451 Allocate using stack local STOP_STRING then assign the
2452 pointer to the frame, this allows the STOP_STRING on the
2453 frame to be of type 'const char *'. */
2454 size
= ex
.message
->size () + 1;
2455 stop_string
= (char *) frame_obstack_zalloc (size
);
2456 memcpy (stop_string
, ex
.what (), size
);
2457 this_frame
->stop_string
= stop_string
;
2468 /* Construct a new "struct frame_info" and link it previous to
2471 static frame_info_ptr
2472 get_prev_frame_raw (frame_info_ptr this_frame
)
2474 frame_info
*prev_frame
;
2476 /* Allocate the new frame but do not wire it in to the frame chain.
2477 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2478 frame->next to pull some fancy tricks (of course such code is, by
2479 definition, recursive). Try to prevent it.
2481 There is no reason to worry about memory leaks, should the
2482 remainder of the function fail. The allocated memory will be
2483 quickly reclaimed when the frame cache is flushed, and the `we've
2484 been here before' check above will stop repeated memory
2485 allocation calls. */
2486 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2487 prev_frame
->level
= this_frame
->level
+ 1;
2489 /* For now, assume we don't have frame chains crossing address
2491 prev_frame
->pspace
= this_frame
->pspace
;
2492 prev_frame
->aspace
= this_frame
->aspace
;
2494 /* Don't yet compute ->unwind (and hence ->type). It is computed
2495 on-demand in get_frame_type, frame_register_unwind, and
2498 /* Don't yet compute the frame's ID. It is computed on-demand by
2501 /* The unwound frame ID is validate at the start of this function,
2502 as part of the logic to decide if that frame should be further
2503 unwound, and not here while the prev frame is being created.
2504 Doing this makes it possible for the user to examine a frame that
2505 has an invalid frame ID.
2507 Some very old VAX code noted: [...] For the sake of argument,
2508 suppose that the stack is somewhat trashed (which is one reason
2509 that "info frame" exists). So, return 0 (indicating we don't
2510 know the address of the arglist) if we don't know what frame this
2514 this_frame
->prev
= prev_frame
;
2515 prev_frame
->next
= this_frame
.get ();
2517 frame_debug_printf (" -> %s", prev_frame
->to_string ().c_str ());
2519 return frame_info_ptr (prev_frame
);
2522 /* Debug routine to print a NULL frame being returned. */
2525 frame_debug_got_null_frame (frame_info_ptr this_frame
,
2530 if (this_frame
!= NULL
)
2531 frame_debug_printf ("this_frame=%d -> %s", this_frame
->level
, reason
);
2533 frame_debug_printf ("this_frame=nullptr -> %s", reason
);
2537 /* Is this (non-sentinel) frame in the "main"() function? */
2540 inside_main_func (frame_info_ptr this_frame
)
2542 if (current_program_space
->symfile_object_file
== nullptr)
2545 CORE_ADDR sym_addr
= 0;
2546 const char *name
= main_name ();
2547 bound_minimal_symbol msymbol
2548 = lookup_minimal_symbol (name
, NULL
,
2549 current_program_space
->symfile_object_file
);
2551 if (msymbol
.minsym
!= nullptr)
2552 sym_addr
= msymbol
.value_address ();
2554 /* Favor a full symbol in Fortran, for the case where the Fortran main
2555 is also called "main". */
2556 if (msymbol
.minsym
== nullptr
2557 || get_frame_language (this_frame
) == language_fortran
)
2559 /* In some language (for example Fortran) there will be no minimal
2560 symbol with the name of the main function. In this case we should
2561 search the full symbols to see if we can find a match. */
2562 struct block_symbol bs
= lookup_symbol (name
, nullptr,
2563 SEARCH_FUNCTION_DOMAIN
, nullptr);
2565 /* This lookup should always yield a block-valued symbol. */
2566 if (bs
.symbol
!= nullptr && bs
.symbol
->aclass () == LOC_BLOCK
)
2568 const struct block
*block
= bs
.symbol
->value_block ();
2569 gdb_assert (block
!= nullptr);
2570 sym_addr
= block
->start ();
2572 else if (msymbol
.minsym
== nullptr)
2576 /* Convert any function descriptor addresses into the actual function
2578 sym_addr
= (gdbarch_convert_from_func_ptr_addr
2579 (get_frame_arch (this_frame
), sym_addr
,
2580 current_inferior ()->top_target ()));
2582 return sym_addr
== get_frame_func (this_frame
);
2585 /* Test whether THIS_FRAME is inside the process entry point function. */
2588 inside_entry_func (frame_info_ptr this_frame
)
2590 CORE_ADDR entry_point
;
2592 if (!entry_point_address_query (&entry_point
))
2595 return get_frame_func (this_frame
) == entry_point
;
2598 /* Return a structure containing various interesting information about
2599 the frame that called THIS_FRAME. Returns NULL if there is either
2600 no such frame or the frame fails any of a set of target-independent
2601 condition that should terminate the frame chain (e.g., as unwinding
2604 This function should not contain target-dependent tests, such as
2605 checking whether the program-counter is zero. */
2608 get_prev_frame (frame_info_ptr this_frame
)
2610 FRAME_SCOPED_DEBUG_ENTER_EXIT
;
2615 /* There is always a frame. If this assertion fails, suspect that
2616 something should be calling get_selected_frame() or
2617 get_current_frame(). */
2618 gdb_assert (this_frame
!= NULL
);
2620 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2622 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2623 sense to stop unwinding at a dummy frame. One place where a dummy
2624 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2625 pcsqh register (space register for the instruction at the head of the
2626 instruction queue) cannot be written directly; the only way to set it
2627 is to branch to code that is in the target space. In order to implement
2628 frame dummies on HPUX, the called function is made to jump back to where
2629 the inferior was when the user function was called. If gdb was inside
2630 the main function when we created the dummy frame, the dummy frame will
2631 point inside the main function. */
2632 if (this_frame
->level
>= 0
2633 && get_frame_type (this_frame
) == NORMAL_FRAME
2634 && !user_set_backtrace_options
.backtrace_past_main
2636 && inside_main_func (this_frame
))
2637 /* Don't unwind past main(). Note, this is done _before_ the
2638 frame has been marked as previously unwound. That way if the
2639 user later decides to enable unwinds past main(), that will
2640 automatically happen. */
2642 frame_debug_got_null_frame (this_frame
, "inside main func");
2646 /* If the user's backtrace limit has been exceeded, stop. We must
2647 add two to the current level; one of those accounts for backtrace_limit
2648 being 1-based and the level being 0-based, and the other accounts for
2649 the level of the new frame instead of the level of the current
2651 if (this_frame
->level
+ 2 > user_set_backtrace_options
.backtrace_limit
)
2653 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2657 /* If we're already inside the entry function for the main objfile,
2658 then it isn't valid. Don't apply this test to a dummy frame -
2659 dummy frame PCs typically land in the entry func. Don't apply
2660 this test to the sentinel frame. Sentinel frames should always
2661 be allowed to unwind. */
2662 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2663 wasn't checking for "main" in the minimal symbols. With that
2664 fixed asm-source tests now stop in "main" instead of halting the
2665 backtrace in weird and wonderful ways somewhere inside the entry
2666 file. Suspect that tests for inside the entry file/func were
2667 added to work around that (now fixed) case. */
2668 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2669 suggested having the inside_entry_func test use the
2670 inside_main_func() msymbol trick (along with entry_point_address()
2671 I guess) to determine the address range of the start function.
2672 That should provide a far better stopper than the current
2674 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2675 applied tail-call optimizations to main so that a function called
2676 from main returns directly to the caller of main. Since we don't
2677 stop at main, we should at least stop at the entry point of the
2679 if (this_frame
->level
>= 0
2680 && get_frame_type (this_frame
) == NORMAL_FRAME
2681 && !user_set_backtrace_options
.backtrace_past_entry
2683 && inside_entry_func (this_frame
))
2685 frame_debug_got_null_frame (this_frame
, "inside entry func");
2689 /* Assume that the only way to get a zero PC is through something
2690 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2691 will never unwind a zero PC. */
2692 if (this_frame
->level
> 0
2693 && (get_frame_type (this_frame
) == NORMAL_FRAME
2694 || get_frame_type (this_frame
) == INLINE_FRAME
)
2695 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2696 && frame_pc_p
&& frame_pc
== 0)
2698 frame_debug_got_null_frame (this_frame
, "zero PC");
2702 return get_prev_frame_always (this_frame
);
2706 get_frame_pc (frame_info_ptr frame
)
2708 gdb_assert (frame
->next
!= NULL
);
2709 return frame_unwind_pc (frame_info_ptr (frame
->next
));
2713 get_frame_pc_if_available (frame_info_ptr frame
, CORE_ADDR
*pc
)
2716 gdb_assert (frame
->next
!= NULL
);
2720 *pc
= frame_unwind_pc (frame_info_ptr (frame
->next
));
2722 catch (const gdb_exception_error
&ex
)
2724 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2733 /* Return an address that falls within THIS_FRAME's code block. */
2736 get_frame_address_in_block (frame_info_ptr this_frame
)
2738 /* A draft address. */
2739 CORE_ADDR pc
= get_frame_pc (this_frame
);
2741 frame_info_ptr
next_frame (this_frame
->next
);
2743 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2744 Normally the resume address is inside the body of the function
2745 associated with THIS_FRAME, but there is a special case: when
2746 calling a function which the compiler knows will never return
2747 (for instance abort), the call may be the very last instruction
2748 in the calling function. The resume address will point after the
2749 call and may be at the beginning of a different function
2752 If THIS_FRAME is a signal frame or dummy frame, then we should
2753 not adjust the unwound PC. For a dummy frame, GDB pushed the
2754 resume address manually onto the stack. For a signal frame, the
2755 OS may have pushed the resume address manually and invoked the
2756 handler (e.g. GNU/Linux), or invoked the trampoline which called
2757 the signal handler - but in either case the signal handler is
2758 expected to return to the trampoline. So in both of these
2759 cases we know that the resume address is executable and
2760 related. So we only need to adjust the PC if THIS_FRAME
2761 is a normal function.
2763 If the program has been interrupted while THIS_FRAME is current,
2764 then clearly the resume address is inside the associated
2765 function. There are three kinds of interruption: debugger stop
2766 (next frame will be SENTINEL_FRAME), operating system
2767 signal or exception (next frame will be SIGTRAMP_FRAME),
2768 or debugger-induced function call (next frame will be
2769 DUMMY_FRAME). So we only need to adjust the PC if
2770 NEXT_FRAME is a normal function.
2772 We check the type of NEXT_FRAME first, since it is already
2773 known; frame type is determined by the unwinder, and since
2774 we have THIS_FRAME we've already selected an unwinder for
2777 If the next frame is inlined, we need to keep going until we find
2778 the real function - for instance, if a signal handler is invoked
2779 while in an inlined function, then the code address of the
2780 "calling" normal function should not be adjusted either. */
2782 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2783 next_frame
= frame_info_ptr (next_frame
->next
);
2785 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2786 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2787 && (get_frame_type (this_frame
) == NORMAL_FRAME
2788 || get_frame_type (this_frame
) == TAILCALL_FRAME
2789 || get_frame_type (this_frame
) == INLINE_FRAME
))
2796 get_frame_address_in_block_if_available (frame_info_ptr this_frame
,
2802 *pc
= get_frame_address_in_block (this_frame
);
2804 catch (const gdb_exception_error
&ex
)
2806 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2815 find_frame_sal (frame_info_ptr frame
)
2817 frame_info_ptr next_frame
;
2821 if (frame_inlined_callees (frame
) > 0)
2825 /* If the current frame has some inlined callees, and we have a next
2826 frame, then that frame must be an inlined frame. In this case
2827 this frame's sal is the "call site" of the next frame's inlined
2828 function, which can not be inferred from get_frame_pc. */
2829 next_frame
= get_next_frame (frame
);
2831 sym
= get_frame_function (next_frame
);
2833 sym
= inline_skipped_symbol (inferior_thread ());
2835 /* If frame is inline, it certainly has symbols. */
2838 symtab_and_line sal
;
2839 if (sym
->line () != 0)
2841 sal
.symtab
= sym
->symtab ();
2842 sal
.line
= sym
->line ();
2845 /* If the symbol does not have a location, we don't know where
2846 the call site is. Do not pretend to. This is jarring, but
2847 we can't do much better. */
2848 sal
.pc
= get_frame_pc (frame
);
2850 sal
.pspace
= get_frame_program_space (frame
);
2854 /* If FRAME is not the innermost frame, that normally means that
2855 FRAME->pc points at the return instruction (which is *after* the
2856 call instruction), and we want to get the line containing the
2857 call (because the call is where the user thinks the program is).
2858 However, if the next frame is either a SIGTRAMP_FRAME or a
2859 DUMMY_FRAME, then the next frame will contain a saved interrupt
2860 PC and such a PC indicates the current (rather than next)
2861 instruction/line, consequently, for such cases, want to get the
2862 line containing fi->pc. */
2863 if (!get_frame_pc_if_available (frame
, &pc
))
2866 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2867 return find_pc_line (pc
, notcurrent
);
2870 /* Per "frame.h", return the ``address'' of the frame. Code should
2871 really be using get_frame_id(). */
2873 get_frame_base (frame_info_ptr fi
)
2875 return get_frame_id (fi
).stack_addr
;
2878 /* High-level offsets into the frame. Used by the debug info. */
2881 get_frame_base_address (frame_info_ptr fi
)
2883 if (get_frame_type (fi
) != NORMAL_FRAME
)
2885 if (fi
->base
== NULL
)
2886 fi
->base
= frame_base_find_by_frame (fi
);
2887 /* Sneaky: If the low-level unwind and high-level base code share a
2888 common unwinder, let them share the prologue cache. */
2889 if (fi
->base
->unwind
== fi
->unwind
)
2890 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2891 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2895 get_frame_locals_address (frame_info_ptr fi
)
2897 if (get_frame_type (fi
) != NORMAL_FRAME
)
2899 /* If there isn't a frame address method, find it. */
2900 if (fi
->base
== NULL
)
2901 fi
->base
= frame_base_find_by_frame (fi
);
2902 /* Sneaky: If the low-level unwind and high-level base code share a
2903 common unwinder, let them share the prologue cache. */
2904 if (fi
->base
->unwind
== fi
->unwind
)
2905 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2906 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2910 get_frame_args_address (frame_info_ptr fi
)
2912 if (get_frame_type (fi
) != NORMAL_FRAME
)
2914 /* If there isn't a frame address method, find it. */
2915 if (fi
->base
== NULL
)
2916 fi
->base
= frame_base_find_by_frame (fi
);
2917 /* Sneaky: If the low-level unwind and high-level base code share a
2918 common unwinder, let them share the prologue cache. */
2919 if (fi
->base
->unwind
== fi
->unwind
)
2920 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2921 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2924 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2928 frame_unwinder_is (frame_info_ptr fi
, const frame_unwind
*unwinder
)
2930 if (fi
->unwind
== nullptr)
2931 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2933 return fi
->unwind
== unwinder
;
2936 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2937 or -1 for a NULL frame. */
2940 frame_relative_level (frame_info_ptr fi
)
2949 get_frame_type (frame_info_ptr frame
)
2951 if (frame
->unwind
== NULL
)
2952 /* Initialize the frame's unwinder because that's what
2953 provides the frame's type. */
2954 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2955 return frame
->unwind
->type
;
2958 struct program_space
*
2959 get_frame_program_space (frame_info_ptr frame
)
2961 return frame
->pspace
;
2964 struct program_space
*
2965 frame_unwind_program_space (frame_info_ptr this_frame
)
2967 gdb_assert (this_frame
);
2969 /* This is really a placeholder to keep the API consistent --- we
2970 assume for now that we don't have frame chains crossing
2972 return this_frame
->pspace
;
2975 const address_space
*
2976 get_frame_address_space (frame_info_ptr frame
)
2978 return frame
->aspace
;
2981 /* Memory access methods. */
2984 get_frame_memory (frame_info_ptr this_frame
, CORE_ADDR addr
,
2985 gdb::array_view
<gdb_byte
> buffer
)
2987 read_memory (addr
, buffer
.data (), buffer
.size ());
2991 get_frame_memory_signed (frame_info_ptr this_frame
, CORE_ADDR addr
,
2994 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2995 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2997 return read_memory_integer (addr
, len
, byte_order
);
3001 get_frame_memory_unsigned (frame_info_ptr this_frame
, CORE_ADDR addr
,
3004 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
3005 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3007 return read_memory_unsigned_integer (addr
, len
, byte_order
);
3011 safe_frame_unwind_memory (frame_info_ptr this_frame
,
3012 CORE_ADDR addr
, gdb::array_view
<gdb_byte
> buffer
)
3014 /* NOTE: target_read_memory returns zero on success! */
3015 return target_read_memory (addr
, buffer
.data (), buffer
.size ()) == 0;
3018 /* Architecture methods. */
3021 get_frame_arch (frame_info_ptr this_frame
)
3023 return frame_unwind_arch (frame_info_ptr (this_frame
->next
));
3027 frame_unwind_arch (frame_info_ptr next_frame
)
3029 if (!next_frame
->prev_arch
.p
)
3031 struct gdbarch
*arch
;
3033 if (next_frame
->unwind
== NULL
)
3034 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
3036 if (next_frame
->unwind
->prev_arch
!= NULL
)
3037 arch
= next_frame
->unwind
->prev_arch (next_frame
,
3038 &next_frame
->prologue_cache
);
3040 arch
= get_frame_arch (next_frame
);
3042 next_frame
->prev_arch
.arch
= arch
;
3043 next_frame
->prev_arch
.p
= true;
3044 frame_debug_printf ("next_frame=%d -> %s",
3046 gdbarch_bfd_arch_info (arch
)->printable_name
);
3049 return next_frame
->prev_arch
.arch
;
3053 frame_unwind_caller_arch (frame_info_ptr next_frame
)
3055 next_frame
= skip_artificial_frames (next_frame
);
3057 /* We must have a non-artificial frame. The caller is supposed to check
3058 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
3060 gdb_assert (next_frame
!= NULL
);
3062 return frame_unwind_arch (next_frame
);
3065 /* Gets the language of FRAME. */
3068 get_frame_language (frame_info_ptr frame
)
3073 gdb_assert (frame
!= NULL
);
3075 /* We determine the current frame language by looking up its
3076 associated symtab. To retrieve this symtab, we use the frame
3077 PC. However we cannot use the frame PC as is, because it
3078 usually points to the instruction following the "call", which
3079 is sometimes the first instruction of another function. So
3080 we rely on get_frame_address_in_block(), it provides us with
3081 a PC that is guaranteed to be inside the frame's code
3086 pc
= get_frame_address_in_block (frame
);
3089 catch (const gdb_exception_error
&ex
)
3091 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
3097 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
3100 return cust
->language ();
3103 return language_unknown
;
3106 /* Stack pointer methods. */
3109 get_frame_sp (frame_info_ptr this_frame
)
3111 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
3113 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
3114 operate on THIS_FRAME now. */
3115 return gdbarch_unwind_sp (gdbarch
, frame_info_ptr (this_frame
->next
));
3121 frame_follow_static_link (frame_info_ptr frame
)
3123 const block
*frame_block
= get_frame_block (frame
, nullptr);
3124 frame_block
= frame_block
->function_block ();
3126 const struct dynamic_prop
*static_link
= frame_block
->static_link ();
3127 if (static_link
== nullptr)
3130 CORE_ADDR upper_frame_base
;
3132 if (!dwarf2_evaluate_property (static_link
, frame
, NULL
, &upper_frame_base
))
3135 /* Now climb up the stack frame until we reach the frame we are interested
3137 for (; frame
!= nullptr; frame
= get_prev_frame (frame
))
3139 struct symbol
*framefunc
= get_frame_function (frame
);
3141 /* Stacks can be quite deep: give the user a chance to stop this. */
3144 /* If we don't know how to compute FRAME's base address, don't give up:
3145 maybe the frame we are looking for is upper in the stack frame. */
3146 if (framefunc
!= nullptr)
3148 if (const symbol_block_ops
*block_ops
= framefunc
->block_ops ();
3149 (block_ops
!= nullptr
3150 && block_ops
->get_frame_base
!= nullptr
3151 && (block_ops
->get_frame_base (framefunc
, frame
)
3152 == upper_frame_base
)))
3160 /* Return the reason why we can't unwind past FRAME. */
3162 enum unwind_stop_reason
3163 get_frame_unwind_stop_reason (frame_info_ptr frame
)
3165 /* Fill-in STOP_REASON. */
3166 get_prev_frame_always (frame
);
3167 gdb_assert (frame
->prev_p
);
3169 return frame
->stop_reason
;
3172 /* Return a string explaining REASON. */
3175 unwind_stop_reason_to_string (enum unwind_stop_reason reason
)
3179 #define SET(name, description) \
3180 case name: return _(description);
3181 #include "unwind_stop_reasons.def"
3185 internal_error ("Invalid frame stop reason");
3190 frame_stop_reason_string (frame_info_ptr fi
)
3192 gdb_assert (fi
->prev_p
);
3193 gdb_assert (fi
->prev
== NULL
);
3195 /* Return the specific string if we have one. */
3196 if (fi
->stop_string
!= NULL
)
3197 return fi
->stop_string
;
3199 /* Return the generic string if we have nothing better. */
3200 return unwind_stop_reason_to_string (fi
->stop_reason
);
3203 /* Return the enum symbol name of REASON as a string, to use in debug
3207 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
3211 #define SET(name, description) \
3212 case name: return #name;
3213 #include "unwind_stop_reasons.def"
3217 internal_error ("Invalid frame stop reason");
3221 /* Clean up after a failed (wrong unwinder) attempt to unwind past
3225 frame_cleanup_after_sniffer (frame_info_ptr frame
)
3227 /* The sniffer should not allocate a prologue cache if it did not
3228 match this frame. */
3229 gdb_assert (frame
->prologue_cache
== NULL
);
3231 /* No sniffer should extend the frame chain; sniff based on what is
3233 gdb_assert (!frame
->prev_p
);
3235 /* The sniffer should not check the frame's ID; that's circular. */
3236 gdb_assert (frame
->this_id
.p
!= frame_id_status::COMPUTED
);
3238 /* Clear cached fields dependent on the unwinder.
3240 The previous PC is independent of the unwinder, but the previous
3241 function is not (see get_frame_address_in_block). */
3242 frame
->prev_func
.status
= CC_UNKNOWN
;
3243 frame
->prev_func
.addr
= 0;
3245 /* Discard the unwinder last, so that we can easily find it if an assertion
3246 in this function triggers. */
3247 frame
->unwind
= NULL
;
3250 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
3251 If sniffing fails, the caller should be sure to call
3252 frame_cleanup_after_sniffer. */
3255 frame_prepare_for_sniffer (frame_info_ptr frame
,
3256 const struct frame_unwind
*unwind
)
3258 gdb_assert (frame
->unwind
== NULL
);
3259 frame
->unwind
= unwind
;
3262 static struct cmd_list_element
*set_backtrace_cmdlist
;
3263 static struct cmd_list_element
*show_backtrace_cmdlist
;
3265 /* Definition of the "set backtrace" settings that are exposed as
3266 "backtrace" command options. */
3268 using boolean_option_def
3269 = gdb::option::boolean_option_def
<set_backtrace_options
>;
3271 const gdb::option::option_def set_backtrace_option_defs
[] = {
3273 boolean_option_def
{
3275 [] (set_backtrace_options
*opt
) { return &opt
->backtrace_past_main
; },
3276 show_backtrace_past_main
, /* show_cmd_cb */
3277 N_("Set whether backtraces should continue past \"main\"."),
3278 N_("Show whether backtraces should continue past \"main\"."),
3279 N_("Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
3280 the backtrace at \"main\". Set this if you need to see the rest\n\
3281 of the stack trace."),
3284 boolean_option_def
{
3286 [] (set_backtrace_options
*opt
) { return &opt
->backtrace_past_entry
; },
3287 show_backtrace_past_entry
, /* show_cmd_cb */
3288 N_("Set whether backtraces should continue past the entry point of a program."),
3289 N_("Show whether backtraces should continue past the entry point of a program."),
3290 N_("Normally there are no callers beyond the entry point of a program, so GDB\n\
3291 will terminate the backtrace there. Set this if you need to see\n\
3292 the rest of the stack trace."),
3296 /* Implement the 'maintenance print frame-id' command. */
3299 maintenance_print_frame_id (const char *args
, int from_tty
)
3301 frame_info_ptr frame
;
3303 /* Use the currently selected frame, or select a frame based on the level
3304 number passed by the user. */
3305 if (args
== nullptr)
3306 frame
= get_selected_frame ("No frame selected");
3309 int level
= value_as_long (parse_and_eval (args
));
3310 frame
= find_relative_frame (get_current_frame (), &level
);
3313 /* Print the frame-id. */
3314 gdb_assert (frame
!= nullptr);
3315 gdb_printf ("frame-id for frame #%d: %s\n",
3316 frame_relative_level (frame
),
3317 get_frame_id (frame
).to_string ().c_str ());
3320 /* See frame-info-ptr.h. */
3322 frame_info_ptr::frame_info_ptr (struct frame_info
*ptr
)
3325 frame_list
.push_back (*this);
3327 if (m_ptr
== nullptr)
3330 m_cached_level
= ptr
->level
;
3332 if (m_cached_level
!= 0 || m_ptr
->this_id
.value
.user_created_p
)
3333 m_cached_id
= m_ptr
->this_id
.value
;
3336 /* See frame-info-ptr.h. */
3339 frame_info_ptr::reinflate () const
3341 /* Ensure we have a valid frame level (sentinel frame or above). */
3342 gdb_assert (m_cached_level
>= -1);
3344 if (m_ptr
!= nullptr)
3346 /* The frame_info wasn't invalidated, no need to reinflate. */
3350 if (m_cached_id
.user_created_p
)
3351 m_ptr
= create_new_frame (m_cached_id
).get ();
3354 /* Frame #0 needs special handling, see comment in select_frame. */
3355 if (m_cached_level
== 0)
3356 m_ptr
= get_current_frame ().get ();
3359 /* If we reach here without a valid frame id, it means we are trying
3360 to reinflate a frame whose id was not know at construction time.
3361 We're probably trying to reinflate a frame while computing its id
3362 which is not possible, and would indicate a problem with GDB. */
3363 gdb_assert (frame_id_p (m_cached_id
));
3364 m_ptr
= frame_find_by_id (m_cached_id
).get ();
3368 gdb_assert (m_ptr
!= nullptr);
3372 void _initialize_frame ();
3374 _initialize_frame ()
3376 obstack_init (&frame_cache_obstack
);
3378 frame_stash_create ();
3380 gdb::observers::target_changed
.attach (frame_observer_target_changed
,
3383 add_setshow_prefix_cmd ("backtrace", class_maintenance
,
3385 Set backtrace specific variables.\n\
3386 Configure backtrace variables such as the backtrace limit"),
3388 Show backtrace specific variables.\n\
3389 Show backtrace variables such as the backtrace limit."),
3390 &set_backtrace_cmdlist
, &show_backtrace_cmdlist
,
3391 &setlist
, &showlist
);
3393 add_setshow_uinteger_cmd ("limit", class_obscure
,
3394 &user_set_backtrace_options
.backtrace_limit
, _("\
3395 Set an upper bound on the number of backtrace levels."), _("\
3396 Show the upper bound on the number of backtrace levels."), _("\
3397 No more than the specified number of frames can be displayed or examined.\n\
3398 Literal \"unlimited\" or zero means no limit."),
3400 show_backtrace_limit
,
3401 &set_backtrace_cmdlist
,
3402 &show_backtrace_cmdlist
);
3404 gdb::option::add_setshow_cmds_for_options
3405 (class_stack
, &user_set_backtrace_options
,
3406 set_backtrace_option_defs
, &set_backtrace_cmdlist
, &show_backtrace_cmdlist
);
3408 /* Debug this files internals. */
3409 add_setshow_boolean_cmd ("frame", class_maintenance
, &frame_debug
, _("\
3410 Set frame debugging."), _("\
3411 Show frame debugging."), _("\
3412 When non-zero, frame specific internal debugging is enabled."),
3415 &setdebuglist
, &showdebuglist
);
3417 add_cmd ("frame-id", class_maintenance
, maintenance_print_frame_id
,
3418 _("Print the current frame-id."),
3419 &maintenanceprintlist
);