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/>. */
21 #include "event-top.h"
22 #include "extract-store-integer.h"
27 #include "user-regs.h"
28 #include "gdbsupport/gdb_obstack.h"
29 #include "dummy-frame.h"
30 #include "sentinel-frame.h"
34 #include "frame-unwind.h"
35 #include "frame-base.h"
38 #include "observable.h"
40 #include "gdbthread.h"
42 #include "inline-frame.h"
43 #include "tracepoint.h"
46 #include "cli/cli-option.h"
47 #include "dwarf2/loc.h"
49 /* The sentinel frame terminates the innermost end of the frame chain.
50 If unwound, it returns the information needed to construct an
53 The current frame, which is the innermost frame, can be found at
56 This is an optimization to be able to find the sentinel frame quickly,
57 it could otherwise be found in the frame cache. */
59 static frame_info
*sentinel_frame
;
61 /* Number of calls to reinit_frame_cache. */
62 static unsigned int frame_cache_generation
= 0;
67 get_frame_cache_generation ()
69 return frame_cache_generation
;
72 /* The values behind the global "set backtrace ..." settings. */
73 set_backtrace_options user_set_backtrace_options
;
75 static frame_info_ptr
get_prev_frame_raw (const frame_info_ptr
&this_frame
);
76 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason
);
77 static frame_info_ptr
create_new_frame (frame_id id
);
79 /* Status of some values cached in the frame_info object. */
81 enum cached_copy_status
83 /* Value is unknown. */
86 /* We have a value. */
89 /* Value was not saved. */
92 /* Value is unavailable. */
96 enum class frame_id_status
98 /* Frame id is not computed. */
101 /* Frame id is being computed (compute_frame_id is active). */
104 /* Frame id has been computed. */
108 /* We keep a cache of stack frames, each of which is a "struct
109 frame_info". The innermost one gets allocated (in
110 wait_for_inferior) each time the inferior stops; sentinel_frame
111 points to it. Additional frames get allocated (in get_prev_frame)
112 as needed, and are chained through the next and prev fields. Any
113 time that the frame cache becomes invalid (most notably when we
114 execute something, but also if we change how we interpret the
115 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
116 which reads new symbols)), we should call reinit_frame_cache. */
120 /* Return a string representation of this frame. */
121 std::string
to_string () const;
123 /* Level of this frame. The inner-most (youngest) frame is at level
124 0. As you move towards the outer-most (oldest) frame, the level
125 increases. This is a cached value. It could just as easily be
126 computed by counting back from the selected frame to the inner
128 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
129 reserved to indicate a bogus frame - one that has been created
130 just to keep GDB happy (GDB always needs a frame). For the
131 moment leave this as speculation. */
134 /* The frame's program space. */
135 struct program_space
*pspace
;
137 /* The frame's address space. */
138 const address_space
*aspace
;
140 /* The frame's low-level unwinder and corresponding cache. The
141 low-level unwinder is responsible for unwinding register values
142 for the previous frame. The low-level unwind methods are
143 selected based on the presence, or otherwise, of register unwind
144 information such as CFI. */
145 void *prologue_cache
;
146 const struct frame_unwind
*unwind
;
148 /* Cached copy of the previous frame's architecture. */
152 struct gdbarch
*arch
;
155 /* Cached copy of the previous frame's resume address. */
157 cached_copy_status status
;
158 /* Did VALUE require unmasking when being read. */
163 /* Cached copy of the previous frame's function address. */
167 cached_copy_status status
;
170 /* This frame's ID. */
174 struct frame_id value
;
177 /* The frame's high-level base methods, and corresponding cache.
178 The high level base methods are selected based on the frame's
180 const struct frame_base
*base
;
183 /* Pointers to the next (down, inner, younger) and previous (up,
184 outer, older) frame_info's in the frame cache. */
185 struct frame_info
*next
; /* down, inner, younger */
187 struct frame_info
*prev
; /* up, outer, older */
189 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
190 could. Only valid when PREV_P is set. */
191 enum unwind_stop_reason stop_reason
;
193 /* A frame specific string describing the STOP_REASON in more detail.
194 Only valid when PREV_P is set, but even then may still be NULL. */
195 const char *stop_string
;
201 set_frame_previous_pc_masked (const frame_info_ptr
&frame
)
203 frame
->prev_pc
.masked
= true;
209 get_frame_pc_masked (const frame_info_ptr
&frame
)
211 gdb_assert (frame
->next
!= nullptr);
212 gdb_assert (frame
->next
->prev_pc
.status
== CC_VALUE
);
214 return frame
->next
->prev_pc
.masked
;
217 /* A frame stash used to speed up frame lookups. Create a hash table
218 to stash frames previously accessed from the frame cache for
219 quicker subsequent retrieval. The hash table is emptied whenever
220 the frame cache is invalidated. */
222 static htab_t frame_stash
;
224 /* Internal function to calculate a hash from the frame_id addresses,
225 using as many valid addresses as possible. Frames below level 0
226 are not stored in the hash table. */
229 frame_addr_hash (const void *ap
)
231 const frame_info
*frame
= (const frame_info
*) ap
;
232 const struct frame_id f_id
= frame
->this_id
.value
;
235 gdb_assert (f_id
.stack_status
!= FID_STACK_INVALID
237 || f_id
.special_addr_p
);
239 if (f_id
.stack_status
== FID_STACK_VALID
)
240 hash
= iterative_hash (&f_id
.stack_addr
,
241 sizeof (f_id
.stack_addr
), hash
);
242 if (f_id
.code_addr_p
)
243 hash
= iterative_hash (&f_id
.code_addr
,
244 sizeof (f_id
.code_addr
), hash
);
245 if (f_id
.special_addr_p
)
246 hash
= iterative_hash (&f_id
.special_addr
,
247 sizeof (f_id
.special_addr
), hash
);
249 char user_created_p
= f_id
.user_created_p
;
250 hash
= iterative_hash (&user_created_p
, sizeof (user_created_p
), hash
);
255 /* Internal equality function for the hash table. This function
256 defers equality operations to frame_id::operator==. */
259 frame_addr_hash_eq (const void *a
, const void *b
)
261 const frame_info
*f_entry
= (const frame_info
*) a
;
262 const frame_info
*f_element
= (const frame_info
*) b
;
264 return f_entry
->this_id
.value
== f_element
->this_id
.value
;
267 /* Deletion function for the frame cache hash table. */
270 frame_info_del (frame_info
*frame
)
272 if (frame
->prologue_cache
!= nullptr
273 && frame
->unwind
->dealloc_cache
!= nullptr)
274 frame
->unwind
->dealloc_cache (frame
, frame
->prologue_cache
);
276 if (frame
->base_cache
!= nullptr
277 && frame
->base
->unwind
->dealloc_cache
!= nullptr)
278 frame
->base
->unwind
->dealloc_cache (frame
, frame
->base_cache
);
281 /* Internal function to create the frame_stash hash table. 100 seems
282 to be a good compromise to start the hash table at. */
285 frame_stash_create (void)
287 frame_stash
= htab_create
288 (100, frame_addr_hash
, frame_addr_hash_eq
,
291 auto frame
= static_cast<frame_info
*> (p
);
292 frame_info_del (frame
);
296 /* Internal function to add a frame to the frame_stash hash table.
297 Returns false if a frame with the same ID was already stashed, true
301 frame_stash_add (frame_info
*frame
)
303 /* Valid frame levels are -1 (sentinel frames) and above. */
304 gdb_assert (frame
->level
>= -1);
306 frame_info
**slot
= (frame_info
**) htab_find_slot (frame_stash
,
309 /* If we already have a frame in the stack with the same id, we
310 either have a stack cycle (corrupted stack?), or some bug
311 elsewhere in GDB. In any case, ignore the duplicate and return
312 an indication to the caller. */
313 if (*slot
!= nullptr)
320 /* Internal function to search the frame stash for an entry with the
321 given frame ID. If found, return that frame. Otherwise return
324 static frame_info_ptr
325 frame_stash_find (struct frame_id id
)
327 struct frame_info dummy
;
330 dummy
.this_id
.value
= id
;
331 frame
= (frame_info
*) htab_find (frame_stash
, &dummy
);
332 return frame_info_ptr (frame
);
335 /* Internal function to invalidate the frame stash by removing all
336 entries in it. This only occurs when the frame cache is
340 frame_stash_invalidate (void)
342 htab_empty (frame_stash
);
346 scoped_restore_selected_frame::scoped_restore_selected_frame ()
348 m_lang
= current_language
->la_language
;
349 save_selected_frame (&m_fid
, &m_level
);
353 scoped_restore_selected_frame::~scoped_restore_selected_frame ()
355 restore_selected_frame (m_fid
, m_level
);
356 set_language (m_lang
);
359 /* Flag to control debugging. */
364 show_frame_debug (struct ui_file
*file
, int from_tty
,
365 struct cmd_list_element
*c
, const char *value
)
367 gdb_printf (file
, _("Frame debugging is %s.\n"), value
);
370 /* Implementation of "show backtrace past-main". */
373 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
374 struct cmd_list_element
*c
, const char *value
)
377 _("Whether backtraces should "
378 "continue past \"main\" is %s.\n"),
382 /* Implementation of "show backtrace past-entry". */
385 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
386 struct cmd_list_element
*c
, const char *value
)
388 gdb_printf (file
, _("Whether backtraces should continue past the "
389 "entry point of a program is %s.\n"),
393 /* Implementation of "show backtrace limit". */
396 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
397 struct cmd_list_element
*c
, const char *value
)
400 _("An upper bound on the number "
401 "of backtrace levels is %s.\n"),
408 frame_id::to_string () const
410 const struct frame_id
&id
= *this;
412 std::string res
= "{";
414 if (id
.stack_status
== FID_STACK_INVALID
)
416 else if (id
.stack_status
== FID_STACK_UNAVAILABLE
)
417 res
+= "stack=<unavailable>";
418 else if (id
.stack_status
== FID_STACK_SENTINEL
)
419 res
+= "stack=<sentinel>";
420 else if (id
.stack_status
== FID_STACK_OUTER
)
421 res
+= "stack=<outer>";
423 res
+= std::string ("stack=") + hex_string (id
.stack_addr
);
425 /* Helper function to format 'N=A' if P is true, otherwise '!N'. */
426 auto field_to_string
= [] (const char *n
, bool p
, CORE_ADDR a
) -> std::string
429 return std::string (n
) + "=" + core_addr_to_string (a
);
431 return std::string ("!") + std::string (n
);
434 res
+= (std::string (",")
435 + field_to_string ("code", id
.code_addr_p
, id
.code_addr
)
437 + field_to_string ("special", id
.special_addr_p
, id
.special_addr
));
439 if (id
.artificial_depth
)
440 res
+= ",artificial=" + std::to_string (id
.artificial_depth
);
448 frame_type_str (frame_type type
)
453 return "NORMAL_FRAME";
456 return "DUMMY_FRAME";
459 return "INLINE_FRAME";
462 return "TAILCALL_FRAME";
465 return "SIGTRAMP_FRAME";
471 return "SENTINEL_FRAME";
474 return "<unknown type>";
478 /* See struct frame_info. */
481 frame_info::to_string () const
483 const frame_info
*fi
= this;
487 res
+= string_printf ("{level=%d,", fi
->level
);
489 if (fi
->unwind
!= NULL
)
490 res
+= string_printf ("type=%s,", frame_type_str (fi
->unwind
->type
));
492 res
+= "type=<unknown>,";
494 if (fi
->unwind
!= NULL
)
495 res
+= string_printf ("unwinder=\"%s\",", fi
->unwind
->name
);
497 res
+= "unwinder=<unknown>,";
499 if (fi
->next
== NULL
|| fi
->next
->prev_pc
.status
== CC_UNKNOWN
)
500 res
+= "pc=<unknown>,";
501 else if (fi
->next
->prev_pc
.status
== CC_VALUE
)
502 res
+= string_printf ("pc=%s%s,", hex_string (fi
->next
->prev_pc
.value
),
503 fi
->next
->prev_pc
.masked
? "[PAC]" : "");
504 else if (fi
->next
->prev_pc
.status
== CC_NOT_SAVED
)
505 res
+= "pc=<not saved>,";
506 else if (fi
->next
->prev_pc
.status
== CC_UNAVAILABLE
)
507 res
+= "pc=<unavailable>,";
509 if (fi
->this_id
.p
== frame_id_status::NOT_COMPUTED
)
510 res
+= "id=<not computed>,";
511 else if (fi
->this_id
.p
== frame_id_status::COMPUTING
)
512 res
+= "id=<computing>,";
514 res
+= string_printf ("id=%s,", fi
->this_id
.value
.to_string ().c_str ());
516 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.status
== CC_VALUE
)
517 res
+= string_printf ("func=%s", hex_string (fi
->next
->prev_func
.addr
));
519 res
+= "func=<unknown>";
526 /* Given FRAME, return the enclosing frame as found in real frames read-in from
527 inferior memory. Skip any previous frames which were made up by GDB.
528 Return FRAME if FRAME is a non-artificial frame.
529 Return NULL if FRAME is the start of an artificial-only chain. */
531 static frame_info_ptr
532 skip_artificial_frames (const frame_info_ptr
&initial_frame
)
534 /* Note we use get_prev_frame_always, and not get_prev_frame. The
535 latter will truncate the frame chain, leading to this function
536 unintentionally returning a null_frame_id (e.g., when the user
537 sets a backtrace limit).
539 Note that for record targets we may get a frame chain that consists
540 of artificial frames only. */
541 frame_info_ptr frame
= initial_frame
;
542 while (get_frame_type (frame
) == INLINE_FRAME
543 || get_frame_type (frame
) == TAILCALL_FRAME
)
545 frame
= get_prev_frame_always (frame
);
554 skip_unwritable_frames (const frame_info_ptr
&initial_frame
)
556 frame_info_ptr frame
= initial_frame
;
557 while (gdbarch_code_of_frame_writable (get_frame_arch (frame
), frame
) == 0)
559 frame
= get_prev_frame (frame
);
570 skip_tailcall_frames (const frame_info_ptr
&initial_frame
)
572 frame_info_ptr frame
= initial_frame
;
573 while (get_frame_type (frame
) == TAILCALL_FRAME
)
575 /* Note that for record targets we may get a frame chain that consists of
576 tailcall frames only. */
577 frame
= get_prev_frame (frame
);
585 /* Compute the frame's uniq ID that can be used to, later, re-find the
589 compute_frame_id (const frame_info_ptr
&fi
)
591 FRAME_SCOPED_DEBUG_ENTER_EXIT
;
593 gdb_assert (fi
->this_id
.p
== frame_id_status::NOT_COMPUTED
);
595 unsigned int entry_generation
= get_frame_cache_generation ();
599 /* Mark this frame's id as "being computed. */
600 fi
->this_id
.p
= frame_id_status::COMPUTING
;
602 frame_debug_printf ("fi=%d", fi
->level
);
604 /* Find the unwinder. */
605 if (fi
->unwind
== NULL
)
606 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
608 /* Find THIS frame's ID. */
609 /* Default to outermost if no ID is found. */
610 fi
->this_id
.value
= outer_frame_id
;
611 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
612 gdb_assert (frame_id_p (fi
->this_id
.value
));
614 /* Mark this frame's id as "computed". */
615 fi
->this_id
.p
= frame_id_status::COMPUTED
;
617 frame_debug_printf (" -> %s", fi
->this_id
.value
.to_string ().c_str ());
619 catch (const gdb_exception
&ex
)
621 /* On error, revert the frame id status to not computed. If the frame
622 cache generation changed, the frame object doesn't exist anymore, so
624 if (get_frame_cache_generation () == entry_generation
)
625 fi
->this_id
.p
= frame_id_status::NOT_COMPUTED
;
631 /* Return a frame uniq ID that can be used to, later, re-find the
635 get_frame_id (const frame_info_ptr
&fi
)
638 return null_frame_id
;
640 /* It's always invalid to try to get a frame's id while it is being
642 gdb_assert (fi
->this_id
.p
!= frame_id_status::COMPUTING
);
644 if (fi
->this_id
.p
== frame_id_status::NOT_COMPUTED
)
646 /* If we haven't computed the frame id yet, then it must be that
647 this is the current frame. Compute it now, and stash the
648 result. The IDs of other frames are computed as soon as
649 they're created, in order to detect cycles. See
650 get_prev_frame_if_no_cycle. */
651 gdb_assert (fi
->level
== 0);
654 compute_frame_id (fi
);
656 /* Since this is the first frame in the chain, this should
658 bool stashed
= frame_stash_add (fi
.get ());
659 gdb_assert (stashed
);
662 return fi
->this_id
.value
;
666 get_stack_frame_id (const frame_info_ptr
&next_frame
)
668 return get_frame_id (skip_artificial_frames (next_frame
));
672 frame_unwind_caller_id (const frame_info_ptr
&initial_next_frame
)
674 /* Use get_prev_frame_always, and not get_prev_frame. The latter
675 will truncate the frame chain, leading to this function
676 unintentionally returning a null_frame_id (e.g., when a caller
677 requests the frame ID of "main()"s caller. */
679 frame_info_ptr next_frame
= skip_artificial_frames (initial_next_frame
);
680 if (next_frame
== NULL
)
681 return null_frame_id
;
683 frame_info_ptr this_frame
= get_prev_frame_always (next_frame
);
685 return get_frame_id (skip_artificial_frames (this_frame
));
687 return null_frame_id
;
690 const struct frame_id null_frame_id
= { 0 }; /* All zeros. */
691 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_OUTER
, 0, 1, 0 };
694 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
695 CORE_ADDR special_addr
)
697 struct frame_id id
= null_frame_id
;
699 id
.stack_addr
= stack_addr
;
700 id
.stack_status
= FID_STACK_VALID
;
701 id
.code_addr
= code_addr
;
702 id
.code_addr_p
= true;
703 id
.special_addr
= special_addr
;
704 id
.special_addr_p
= true;
711 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
713 struct frame_id id
= null_frame_id
;
715 id
.stack_status
= FID_STACK_UNAVAILABLE
;
716 id
.code_addr
= code_addr
;
717 id
.code_addr_p
= true;
724 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
725 CORE_ADDR special_addr
)
727 struct frame_id id
= null_frame_id
;
729 id
.stack_status
= FID_STACK_UNAVAILABLE
;
730 id
.code_addr
= code_addr
;
731 id
.code_addr_p
= true;
732 id
.special_addr
= special_addr
;
733 id
.special_addr_p
= true;
738 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
740 struct frame_id id
= null_frame_id
;
742 id
.stack_addr
= stack_addr
;
743 id
.stack_status
= FID_STACK_VALID
;
744 id
.code_addr
= code_addr
;
745 id
.code_addr_p
= true;
750 frame_id_build_wild (CORE_ADDR stack_addr
)
752 struct frame_id id
= null_frame_id
;
754 id
.stack_addr
= stack_addr
;
755 id
.stack_status
= FID_STACK_VALID
;
762 frame_id_build_sentinel (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
764 frame_id id
= null_frame_id
;
766 id
.stack_status
= FID_STACK_SENTINEL
;
767 id
.special_addr_p
= 1;
769 if (stack_addr
!= 0 || code_addr
!= 0)
771 /* The purpose of saving these in the sentinel frame ID is to be able to
772 differentiate the IDs of several sentinel frames that could exist
773 simultaneously in the frame cache. */
774 id
.stack_addr
= stack_addr
;
775 id
.code_addr
= code_addr
;
783 frame_id_p (frame_id l
)
785 /* The frame is valid iff it has a valid stack address. */
786 bool p
= l
.stack_status
!= FID_STACK_INVALID
;
788 frame_debug_printf ("l=%s -> %d", l
.to_string ().c_str (), p
);
794 frame_id_artificial_p (frame_id l
)
799 return l
.artificial_depth
!= 0;
803 frame_id::operator== (const frame_id
&r
) const
807 if (stack_status
== FID_STACK_INVALID
808 || r
.stack_status
== FID_STACK_INVALID
)
809 /* Like a NaN, if either ID is invalid, the result is false.
810 Note that a frame ID is invalid iff it is the null frame ID. */
812 else if (stack_status
!= r
.stack_status
|| stack_addr
!= r
.stack_addr
)
813 /* If .stack addresses are different, the frames are different. */
815 else if (code_addr_p
&& r
.code_addr_p
&& code_addr
!= r
.code_addr
)
816 /* An invalid code addr is a wild card. If .code addresses are
817 different, the frames are different. */
819 else if (special_addr_p
&& r
.special_addr_p
820 && special_addr
!= r
.special_addr
)
821 /* An invalid special addr is a wild card (or unused). Otherwise
822 if special addresses are different, the frames are different. */
824 else if (artificial_depth
!= r
.artificial_depth
)
825 /* If artificial depths are different, the frames must be different. */
827 else if (user_created_p
!= r
.user_created_p
)
830 /* Frames are equal. */
833 frame_debug_printf ("l=%s, r=%s -> %d",
834 to_string ().c_str (), r
.to_string ().c_str (), eq
);
839 /* Safety net to check whether frame ID L should be inner to
840 frame ID R, according to their stack addresses.
842 This method cannot be used to compare arbitrary frames, as the
843 ranges of valid stack addresses may be discontiguous (e.g. due
846 However, it can be used as safety net to discover invalid frame
847 IDs in certain circumstances. Assuming that NEXT is the immediate
848 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
850 * The stack address of NEXT must be inner-than-or-equal to the stack
853 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
856 * If NEXT and THIS have different stack addresses, no other frame
857 in the frame chain may have a stack address in between.
859 Therefore, if frame_id_inner (TEST, THIS) holds, but
860 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
861 to a valid frame in the frame chain.
863 The sanity checks above cannot be performed when a SIGTRAMP frame
864 is involved, because signal handlers might be executed on a different
865 stack than the stack used by the routine that caused the signal
866 to be raised. This can happen for instance when a thread exceeds
867 its maximum stack size. In this case, certain compilers implement
868 a stack overflow strategy that cause the handler to be run on a
872 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
876 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
877 /* Like NaN, any operation involving an invalid ID always fails.
878 Likewise if either ID has an unavailable stack address. */
880 else if (l
.artificial_depth
> r
.artificial_depth
881 && l
.stack_addr
== r
.stack_addr
882 && l
.code_addr_p
== r
.code_addr_p
883 && l
.special_addr_p
== r
.special_addr_p
884 && l
.special_addr
== r
.special_addr
)
886 /* Same function, different inlined functions. */
887 const struct block
*lb
, *rb
;
889 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
891 lb
= block_for_pc (l
.code_addr
);
892 rb
= block_for_pc (r
.code_addr
);
894 if (lb
== NULL
|| rb
== NULL
)
895 /* Something's gone wrong. */
898 /* This will return true if LB and RB are the same block, or
899 if the block with the smaller depth lexically encloses the
900 block with the greater depth. */
901 inner
= rb
->contains (lb
);
904 /* Only return non-zero when strictly inner than. Note that, per
905 comment in "frame.h", there is some fuzz here. Frameless
906 functions are not strictly inner than (same .stack but
907 different .code and/or .special address). */
908 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
910 frame_debug_printf ("is l=%s inner than r=%s? %d",
911 l
.to_string ().c_str (), r
.to_string ().c_str (),
918 frame_find_by_id (struct frame_id id
)
920 frame_info_ptr frame
, prev_frame
;
922 /* ZERO denotes the null frame, let the caller decide what to do
923 about it. Should it instead return get_current_frame()? */
924 if (!frame_id_p (id
))
927 /* Check for the sentinel frame. */
928 if (id
== frame_id_build_sentinel (0, 0))
929 return frame_info_ptr (sentinel_frame
);
931 /* Try using the frame stash first. Finding it there removes the need
932 to perform the search by looping over all frames, which can be very
933 CPU-intensive if the number of frames is very high (the loop is O(n)
934 and get_prev_frame performs a series of checks that are relatively
935 expensive). This optimization is particularly useful when this function
936 is called from another function (such as value_fetch_lazy, case
937 val->lval () == lval_register) which already loops over all frames,
938 making the overall behavior O(n^2). */
939 frame
= frame_stash_find (id
);
943 for (frame
= get_current_frame (); ; frame
= prev_frame
)
945 struct frame_id self
= get_frame_id (frame
);
948 /* An exact match. */
951 prev_frame
= get_prev_frame (frame
);
955 /* As a safety net to avoid unnecessary backtracing while trying
956 to find an invalid ID, we check for a common situation where
957 we can detect from comparing stack addresses that no other
958 frame in the current frame chain can have this ID. See the
959 comment at frame_id_inner for details. */
960 if (get_frame_type (frame
) == NORMAL_FRAME
961 && !frame_id_inner (get_frame_arch (frame
), id
, self
)
962 && frame_id_inner (get_frame_arch (prev_frame
), id
,
963 get_frame_id (prev_frame
)))
970 frame_unwind_pc (const frame_info_ptr
&this_frame
)
972 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
974 struct gdbarch
*prev_gdbarch
;
978 /* The right way. The `pure' way. The one true way. This
979 method depends solely on the register-unwind code to
980 determine the value of registers in THIS frame, and hence
981 the value of this frame's PC (resume address). A typical
982 implementation is no more than:
984 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
985 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
987 Note: this method is very heavily dependent on a correct
988 register-unwind implementation, it pays to fix that
989 method first; this method is frame type agnostic, since
990 it only deals with register values, it works with any
991 frame. This is all in stark contrast to the old
992 FRAME_SAVED_PC which would try to directly handle all the
993 different ways that a PC could be unwound. */
994 prev_gdbarch
= frame_unwind_arch (this_frame
);
998 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
1001 catch (const gdb_exception_error
&ex
)
1003 if (ex
.error
== NOT_AVAILABLE_ERROR
)
1005 this_frame
->prev_pc
.status
= CC_UNAVAILABLE
;
1007 frame_debug_printf ("this_frame=%d -> <unavailable>",
1010 else if (ex
.error
== OPTIMIZED_OUT_ERROR
)
1012 this_frame
->prev_pc
.status
= CC_NOT_SAVED
;
1014 frame_debug_printf ("this_frame=%d -> <not saved>",
1023 this_frame
->prev_pc
.value
= pc
;
1024 this_frame
->prev_pc
.status
= CC_VALUE
;
1026 frame_debug_printf ("this_frame=%d -> %s",
1028 hex_string (this_frame
->prev_pc
.value
));
1032 if (this_frame
->prev_pc
.status
== CC_VALUE
)
1033 return this_frame
->prev_pc
.value
;
1034 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
1035 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
1036 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
1037 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
1039 internal_error ("unexpected prev_pc status: %d",
1040 (int) this_frame
->prev_pc
.status
);
1044 frame_unwind_caller_pc (const frame_info_ptr
&initial_this_frame
)
1046 frame_info_ptr this_frame
= skip_artificial_frames (initial_this_frame
);
1048 /* We must have a non-artificial frame. The caller is supposed to check
1049 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
1051 gdb_assert (this_frame
!= nullptr);
1053 return frame_unwind_pc (this_frame
);
1057 get_frame_func_if_available (const frame_info_ptr
&this_frame
, CORE_ADDR
*pc
)
1059 frame_info
*next_frame
= this_frame
->next
;
1061 if (next_frame
->prev_func
.status
== CC_UNKNOWN
)
1063 CORE_ADDR addr_in_block
;
1065 /* Make certain that this, and not the adjacent, function is
1067 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
1069 next_frame
->prev_func
.status
= CC_UNAVAILABLE
;
1071 frame_debug_printf ("this_frame=%d -> unavailable",
1076 next_frame
->prev_func
.status
= CC_VALUE
;
1077 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
1079 frame_debug_printf ("this_frame=%d -> %s",
1081 hex_string (next_frame
->prev_func
.addr
));
1085 if (next_frame
->prev_func
.status
== CC_UNAVAILABLE
)
1092 gdb_assert (next_frame
->prev_func
.status
== CC_VALUE
);
1094 *pc
= next_frame
->prev_func
.addr
;
1100 get_frame_func (const frame_info_ptr
&this_frame
)
1104 if (!get_frame_func_if_available (this_frame
, &pc
))
1105 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
1110 std::unique_ptr
<readonly_detached_regcache
>
1111 frame_save_as_regcache (const frame_info_ptr
&this_frame
)
1113 auto cooked_read
= [this_frame
] (int regnum
, gdb::array_view
<gdb_byte
> buf
)
1115 if (!deprecated_frame_register_read (this_frame
, regnum
, buf
.data ()))
1116 return REG_UNAVAILABLE
;
1121 std::unique_ptr
<readonly_detached_regcache
> regcache
1122 (new readonly_detached_regcache (get_frame_arch (this_frame
), cooked_read
));
1128 frame_pop (const frame_info_ptr
&this_frame
)
1130 frame_info_ptr prev_frame
;
1132 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
1134 /* Popping a dummy frame involves restoring more than just registers.
1135 dummy_frame_pop does all the work. */
1136 dummy_frame_pop (get_frame_id (this_frame
), inferior_thread ());
1140 /* Ensure that we have a frame to pop to. */
1141 prev_frame
= get_prev_frame_always (this_frame
);
1144 error (_("Cannot pop the initial frame."));
1146 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1147 entering THISFRAME. */
1148 prev_frame
= skip_tailcall_frames (prev_frame
);
1150 if (prev_frame
== NULL
)
1151 error (_("Cannot find the caller frame."));
1153 /* Make a copy of all the register values unwound from this frame.
1154 Save them in a scratch buffer so that there isn't a race between
1155 trying to extract the old values from the current regcache while
1156 at the same time writing new values into that same cache. */
1157 std::unique_ptr
<readonly_detached_regcache
> scratch
1158 = frame_save_as_regcache (prev_frame
);
1160 /* FIXME: cagney/2003-03-16: It should be possible to tell the
1161 target's register cache that it is about to be hit with a burst
1162 register transfer and that the sequence of register writes should
1163 be batched. The pair target_prepare_to_store() and
1164 target_store_registers() kind of suggest this functionality.
1165 Unfortunately, they don't implement it. Their lack of a formal
1166 definition can lead to targets writing back bogus values
1167 (arguably a bug in the target code mind). */
1168 /* Now copy those saved registers into the current regcache. */
1169 get_thread_regcache (inferior_thread ())->restore (scratch
.get ());
1171 /* We've made right mess of GDB's local state, just discard
1173 reinit_frame_cache ();
1177 frame_register_unwind (const frame_info_ptr
&next_frame
, int regnum
,
1178 int *optimizedp
, int *unavailablep
,
1179 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1180 int *realnump
, gdb_byte
*bufferp
)
1182 struct value
*value
;
1184 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1185 that the value proper does not need to be fetched. */
1186 gdb_assert (optimizedp
!= NULL
);
1187 gdb_assert (lvalp
!= NULL
);
1188 gdb_assert (addrp
!= NULL
);
1189 gdb_assert (realnump
!= NULL
);
1190 /* gdb_assert (bufferp != NULL); */
1192 value
= frame_unwind_register_value (next_frame
, regnum
);
1194 gdb_assert (value
!= NULL
);
1196 *optimizedp
= value
->optimized_out ();
1197 *unavailablep
= !value
->entirely_available ();
1198 *lvalp
= value
->lval ();
1199 *addrp
= value
->address ();
1200 if (*lvalp
== lval_register
)
1201 *realnump
= value
->regnum ();
1207 if (!*optimizedp
&& !*unavailablep
)
1208 memcpy (bufferp
, value
->contents_all ().data (),
1209 value
->type ()->length ());
1211 memset (bufferp
, 0, value
->type ()->length ());
1214 /* Dispose of the new value. This prevents watchpoints from
1215 trying to watch the saved frame pointer. */
1216 release_value (value
);
1220 frame_unwind_register (const frame_info_ptr
&next_frame
, int regnum
, gdb_byte
*buf
)
1226 enum lval_type lval
;
1228 frame_register_unwind (next_frame
, regnum
, &optimized
, &unavailable
,
1229 &lval
, &addr
, &realnum
, buf
);
1232 throw_error (OPTIMIZED_OUT_ERROR
,
1233 _("Register %d was not saved"), regnum
);
1235 throw_error (NOT_AVAILABLE_ERROR
,
1236 _("Register %d is not available"), regnum
);
1240 get_frame_register (const frame_info_ptr
&frame
,
1241 int regnum
, gdb_byte
*buf
)
1243 frame_unwind_register (frame_info_ptr (frame
->next
), regnum
, buf
);
1247 frame_unwind_register_value (const frame_info_ptr
&next_frame
, int regnum
)
1249 FRAME_SCOPED_DEBUG_ENTER_EXIT
;
1251 gdb_assert (next_frame
!= NULL
);
1252 gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1253 frame_debug_printf ("frame=%d, regnum=%d(%s)",
1254 next_frame
->level
, regnum
,
1255 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1257 /* Find the unwinder. */
1258 if (next_frame
->unwind
== NULL
)
1259 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
1261 /* Ask this frame to unwind its register. */
1263 = next_frame
->unwind
->prev_register (next_frame
,
1264 &next_frame
->prologue_cache
, regnum
);
1265 if (value
== nullptr)
1267 if (gdbarch_pseudo_register_read_value_p (gdbarch
))
1269 /* This is a pseudo register, we don't know how how what raw registers
1270 this pseudo register is made of. Ask the gdbarch to read the
1271 value, it will itself ask the next frame to unwind the values of
1272 the raw registers it needs to compose the value of the pseudo
1274 value
= gdbarch_pseudo_register_read_value
1275 (gdbarch
, next_frame
, regnum
);
1277 else if (gdbarch_pseudo_register_read_p (gdbarch
))
1279 value
= value::allocate_register (next_frame
, regnum
);
1281 /* Passing the current regcache is known to be broken, the pseudo
1282 register value will be constructed using the current raw registers,
1283 rather than reading them using NEXT_FRAME. Architectures should be
1284 migrated to gdbarch_pseudo_register_read_value. */
1285 register_status status
= gdbarch_pseudo_register_read
1286 (gdbarch
, get_thread_regcache (inferior_thread ()), regnum
,
1287 value
->contents_writeable ().data ());
1288 if (status
== REG_UNAVAILABLE
)
1289 value
->mark_bytes_unavailable (0, value
->type ()->length ());
1292 error (_("Can't unwind value of register %d (%s)"), regnum
,
1293 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1298 string_file debug_file
;
1300 gdb_printf (&debug_file
, " ->");
1301 if (value
->optimized_out ())
1303 gdb_printf (&debug_file
, " ");
1304 val_print_not_saved (&debug_file
);
1308 if (value
->lval () == lval_register
)
1309 gdb_printf (&debug_file
, " register=%d", value
->regnum ());
1310 else if (value
->lval () == lval_memory
)
1311 gdb_printf (&debug_file
, " address=%s",
1313 value
->address ()));
1315 gdb_printf (&debug_file
, " computed");
1318 gdb_printf (&debug_file
, " lazy");
1319 else if (value
->entirely_available ())
1322 gdb::array_view
<const gdb_byte
> buf
= value
->contents ();
1324 gdb_printf (&debug_file
, " bytes=");
1325 gdb_printf (&debug_file
, "[");
1326 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1327 gdb_printf (&debug_file
, "%02x", buf
[i
]);
1328 gdb_printf (&debug_file
, "]");
1330 else if (value
->entirely_unavailable ())
1331 gdb_printf (&debug_file
, " unavailable");
1333 gdb_printf (&debug_file
, " partly unavailable");
1336 frame_debug_printf ("%s", debug_file
.c_str ());
1343 get_frame_register_value (const frame_info_ptr
&frame
, int regnum
)
1345 return frame_unwind_register_value (frame_info_ptr (frame
->next
), regnum
);
1349 frame_unwind_register_signed (const frame_info_ptr
&next_frame
, int regnum
)
1351 struct gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1352 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1353 struct value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1355 gdb_assert (value
!= NULL
);
1357 if (value
->optimized_out ())
1359 throw_error (OPTIMIZED_OUT_ERROR
,
1360 _("Register %d was not saved"), regnum
);
1362 if (!value
->entirely_available ())
1364 throw_error (NOT_AVAILABLE_ERROR
,
1365 _("Register %d is not available"), regnum
);
1368 LONGEST r
= extract_signed_integer (value
->contents_all (), byte_order
);
1370 release_value (value
);
1375 get_frame_register_signed (const frame_info_ptr
&frame
, int regnum
)
1377 return frame_unwind_register_signed (frame_info_ptr (frame
->next
), regnum
);
1381 frame_unwind_register_unsigned (const frame_info_ptr
&next_frame
, int regnum
)
1383 struct gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1384 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1385 int size
= register_size (gdbarch
, regnum
);
1386 struct value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1388 gdb_assert (value
!= NULL
);
1390 if (value
->optimized_out ())
1392 throw_error (OPTIMIZED_OUT_ERROR
,
1393 _("Register %d was not saved"), regnum
);
1395 if (!value
->entirely_available ())
1397 throw_error (NOT_AVAILABLE_ERROR
,
1398 _("Register %d is not available"), regnum
);
1401 ULONGEST r
= extract_unsigned_integer (value
->contents_all ().data (),
1404 release_value (value
);
1409 get_frame_register_unsigned (const frame_info_ptr
&frame
, int regnum
)
1411 return frame_unwind_register_unsigned (frame_info_ptr (frame
->next
), regnum
);
1415 read_frame_register_unsigned (const frame_info_ptr
&frame
, int regnum
,
1418 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1420 if (!regval
->optimized_out ()
1421 && regval
->entirely_available ())
1423 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1424 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1425 int size
= register_size (gdbarch
, regval
->regnum ());
1427 *val
= extract_unsigned_integer (regval
->contents ().data (), size
,
1436 put_frame_register (const frame_info_ptr
&next_frame
, int regnum
,
1437 gdb::array_view
<const gdb_byte
> buf
)
1439 gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1443 enum lval_type lval
;
1445 int size
= register_size (gdbarch
, regnum
);
1447 gdb_assert (buf
.size () == size
);
1449 frame_register_unwind (next_frame
, regnum
, &optim
, &unavail
, &lval
, &addr
,
1452 error (_("Attempt to assign to a register that was not saved."));
1457 write_memory (addr
, buf
.data (), size
);
1461 /* Not sure if that's always true... but we have a problem if not. */
1462 gdb_assert (size
== register_size (gdbarch
, realnum
));
1464 if (realnum
< gdbarch_num_regs (gdbarch
)
1465 || !gdbarch_pseudo_register_write_p (gdbarch
))
1466 get_thread_regcache (inferior_thread ())->cooked_write (realnum
, buf
);
1468 gdbarch_pseudo_register_write (gdbarch
, next_frame
, realnum
, buf
);
1471 error (_("Attempt to assign to an unmodifiable value."));
1475 /* This function is deprecated. Use get_frame_register_value instead,
1476 which provides more accurate information.
1478 Find and return the value of REGNUM for the specified stack frame.
1479 The number of bytes copied is REGISTER_SIZE (REGNUM).
1481 Returns 0 if the register value could not be found. */
1484 deprecated_frame_register_read (const frame_info_ptr
&frame
, int regnum
,
1489 enum lval_type lval
;
1493 frame_register_unwind (get_next_frame_sentinel_okay (frame
), regnum
,
1494 &optimized
, &unavailable
, &lval
, &addr
, &realnum
,
1497 return !optimized
&& !unavailable
;
1501 get_frame_register_bytes (const frame_info_ptr
&next_frame
, int regnum
,
1502 CORE_ADDR offset
, gdb::array_view
<gdb_byte
> buffer
,
1503 int *optimizedp
, int *unavailablep
)
1505 gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1507 /* Skip registers wholly inside of OFFSET. */
1508 while (offset
>= register_size (gdbarch
, regnum
))
1510 offset
-= register_size (gdbarch
, regnum
);
1514 /* Ensure that we will not read beyond the end of the register file.
1515 This can only ever happen if the debug information is bad. */
1516 int maxsize
= -offset
;
1517 int numregs
= gdbarch_num_cooked_regs (gdbarch
);
1518 for (int i
= regnum
; i
< numregs
; i
++)
1520 int thissize
= register_size (gdbarch
, i
);
1523 break; /* This register is not available on this architecture. */
1524 maxsize
+= thissize
;
1527 if (buffer
.size () > maxsize
)
1528 error (_("Bad debug information detected: "
1529 "Attempt to read %zu bytes from registers."), buffer
.size ());
1531 /* Copy the data. */
1532 while (!buffer
.empty ())
1534 int curr_len
= std::min
<int> (register_size (gdbarch
, regnum
) - offset
,
1537 if (curr_len
== register_size (gdbarch
, regnum
))
1539 enum lval_type lval
;
1543 frame_register_unwind (next_frame
, regnum
, optimizedp
, unavailablep
,
1544 &lval
, &addr
, &realnum
, buffer
.data ());
1545 if (*optimizedp
|| *unavailablep
)
1550 value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1551 gdb_assert (value
!= NULL
);
1552 *optimizedp
= value
->optimized_out ();
1553 *unavailablep
= !value
->entirely_available ();
1555 if (*optimizedp
|| *unavailablep
)
1557 release_value (value
);
1561 copy (value
->contents_all ().slice (offset
, curr_len
),
1562 buffer
.slice (0, curr_len
));
1563 release_value (value
);
1566 buffer
= buffer
.slice (curr_len
);
1578 put_frame_register_bytes (const frame_info_ptr
&next_frame
, int regnum
,
1580 gdb::array_view
<const gdb_byte
> buffer
)
1582 gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1584 /* Skip registers wholly inside of OFFSET. */
1585 while (offset
>= register_size (gdbarch
, regnum
))
1587 offset
-= register_size (gdbarch
, regnum
);
1591 /* Copy the data. */
1592 while (!buffer
.empty ())
1594 int curr_len
= std::min
<int> (register_size (gdbarch
, regnum
) - offset
,
1597 if (curr_len
== register_size (gdbarch
, regnum
))
1598 put_frame_register (next_frame
, regnum
, buffer
.slice (0, curr_len
));
1601 value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1602 gdb_assert (value
!= nullptr);
1604 copy (buffer
.slice (0, curr_len
),
1605 value
->contents_writeable ().slice (offset
, curr_len
));
1606 put_frame_register (next_frame
, regnum
, value
->contents_raw ());
1607 release_value (value
);
1610 buffer
= buffer
.slice (curr_len
);
1616 /* Create a sentinel frame.
1618 See frame_id_build_sentinel for the description of STACK_ADDR and
1621 static frame_info_ptr
1622 create_sentinel_frame (program_space
*pspace
, address_space
*aspace
,
1623 regcache
*regcache
, CORE_ADDR stack_addr
,
1624 CORE_ADDR code_addr
)
1626 frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1629 frame
->pspace
= pspace
;
1630 frame
->aspace
= aspace
;
1631 /* Explicitly initialize the sentinel frame's cache. Provide it
1632 with the underlying regcache. In the future additional
1633 information, such as the frame's thread will be added. */
1634 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1635 /* For the moment there is only one sentinel frame implementation. */
1636 frame
->unwind
= &sentinel_frame_unwind
;
1637 /* Link this frame back to itself. The frame is self referential
1638 (the unwound PC is the same as the pc), so make it so. */
1639 frame
->next
= frame
;
1640 /* The sentinel frame has a special ID. */
1641 frame
->this_id
.p
= frame_id_status::COMPUTED
;
1642 frame
->this_id
.value
= frame_id_build_sentinel (stack_addr
, code_addr
);
1644 bool added
= frame_stash_add (frame
);
1647 frame_debug_printf (" -> %s", frame
->to_string ().c_str ());
1649 return frame_info_ptr (frame
);
1652 /* Cache for frame addresses already read by gdb. Valid only while
1653 inferior is stopped. Control variables for the frame cache should
1654 be local to this module. */
1656 static struct obstack frame_cache_obstack
;
1659 frame_obstack_zalloc (unsigned long size
)
1661 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1663 memset (data
, 0, size
);
1667 static frame_info_ptr
get_prev_frame_always_1 (const frame_info_ptr
&this_frame
);
1670 get_current_frame (void)
1672 frame_info_ptr current_frame
;
1674 /* First check, and report, the lack of registers. Having GDB
1675 report "No stack!" or "No memory" when the target doesn't even
1676 have registers is very confusing. Besides, "printcmd.exp"
1677 explicitly checks that ``print $pc'' with no registers prints "No
1679 if (!target_has_registers ())
1680 error (_("No registers."));
1681 if (!target_has_stack ())
1682 error (_("No stack."));
1683 if (!target_has_memory ())
1684 error (_("No memory."));
1685 /* Traceframes are effectively a substitute for the live inferior. */
1686 if (get_traceframe_number () < 0)
1687 validate_registers_access ();
1689 if (sentinel_frame
== NULL
)
1691 create_sentinel_frame (current_program_space
,
1692 current_inferior ()->aspace
.get (),
1693 get_thread_regcache (inferior_thread ()),
1696 /* Set the current frame before computing the frame id, to avoid
1697 recursion inside compute_frame_id, in case the frame's
1698 unwinder decides to do a symbol lookup (which depends on the
1699 selected frame's block).
1701 This call must always succeed. In particular, nothing inside
1702 get_prev_frame_always_1 should try to unwind from the
1703 sentinel frame, because that could fail/throw, and we always
1704 want to leave with the current frame created and linked in --
1705 we should never end up with the sentinel frame as outermost
1707 current_frame
= get_prev_frame_always_1 (frame_info_ptr (sentinel_frame
));
1708 gdb_assert (current_frame
!= NULL
);
1710 return current_frame
;
1713 /* The "selected" stack frame is used by default for local and arg
1716 The "single source of truth" for the selected frame is the
1717 SELECTED_FRAME_ID / SELECTED_FRAME_LEVEL pair.
1719 Frame IDs can be saved/restored across reinitializing the frame
1720 cache, while frame_info pointers can't (frame_info objects are
1721 invalidated). If we know the corresponding frame_info object, it
1722 is cached in SELECTED_FRAME.
1724 If SELECTED_FRAME_ID / SELECTED_FRAME_LEVEL are null_frame_id / -1,
1725 and the target has stack and is stopped, the selected frame is the
1726 current (innermost) target frame. SELECTED_FRAME_ID is never the ID
1727 of the current (innermost) target frame. SELECTED_FRAME_LEVEL may
1728 only be 0 if the selected frame is a user-created one (created and
1729 selected through the "select-frame view" command), in which case
1730 SELECTED_FRAME_ID is the frame id derived from the user-provided
1733 If SELECTED_FRAME_ID / SELECTED_FRAME_LEVEL are null_frame_id / -1,
1734 and the target has no stack or is executing, then there's no
1736 static frame_id selected_frame_id
= null_frame_id
;
1737 static int selected_frame_level
= -1;
1739 /* See frame.h. This definition should come before any definition of a static
1740 frame_info_ptr, to ensure that frame_list is destroyed after any static
1741 frame_info_ptr. This is necessary because the destructor of frame_info_ptr
1744 intrusive_list
<frame_info_ptr
> frame_info_ptr::frame_list
;
1746 /* The cached frame_info object pointing to the selected frame.
1747 Looked up on demand by get_selected_frame. */
1748 static frame_info_ptr selected_frame
;
1753 save_selected_frame (frame_id
*frame_id
, int *frame_level
)
1756 *frame_id
= selected_frame_id
;
1757 *frame_level
= selected_frame_level
;
1763 restore_selected_frame (frame_id frame_id
, int frame_level
)
1766 /* Unless it is a user-created frame, save_selected_frame never returns
1767 level == 0, so we shouldn't see it here either. */
1768 gdb_assert (frame_level
!= 0 || frame_id
.user_created_p
);
1770 /* FRAME_ID can be null_frame_id only IFF frame_level is -1. */
1771 gdb_assert ((frame_level
== -1 && !frame_id_p (frame_id
))
1772 || (frame_level
!= -1 && frame_id_p (frame_id
)));
1774 selected_frame_id
= frame_id
;
1775 selected_frame_level
= frame_level
;
1777 /* Will be looked up later by get_selected_frame. */
1778 selected_frame
= nullptr;
1781 /* Lookup the frame_info object for the selected frame FRAME_ID /
1782 FRAME_LEVEL and cache the result.
1784 If FRAME_LEVEL > 0 and the originally selected frame isn't found,
1785 warn and select the innermost (current) frame. */
1788 lookup_selected_frame (struct frame_id a_frame_id
, int frame_level
)
1790 frame_info_ptr frame
= NULL
;
1793 /* This either means there was no selected frame, or the selected
1794 frame was the current frame. In either case, select the current
1796 if (frame_level
== -1)
1798 select_frame (get_current_frame ());
1802 /* This means the selected frame was a user-created one. Create a new one
1803 using the user-provided addresses, which happen to be in the frame id. */
1804 if (frame_level
== 0)
1806 gdb_assert (a_frame_id
.user_created_p
);
1807 select_frame (create_new_frame (a_frame_id
));
1811 /* select_frame never saves 0 in SELECTED_FRAME_LEVEL, so we
1812 shouldn't see it here. */
1813 gdb_assert (frame_level
> 0);
1815 /* Restore by level first, check if the frame id is the same as
1816 expected. If that fails, try restoring by frame id. If that
1817 fails, nothing to do, just warn the user. */
1819 count
= frame_level
;
1820 frame
= find_relative_frame (get_current_frame (), &count
);
1823 /* The frame ids must match - either both valid or both
1824 outer_frame_id. The latter case is not failsafe, but since
1825 it's highly unlikely the search by level finds the wrong
1826 frame, it's 99.9(9)% of the time (for all practical purposes)
1828 && get_frame_id (frame
) == a_frame_id
)
1830 /* Cool, all is fine. */
1831 select_frame (frame
);
1835 frame
= frame_find_by_id (a_frame_id
);
1838 /* Cool, refound it. */
1839 select_frame (frame
);
1843 /* Nothing else to do, the frame layout really changed. Select the
1844 innermost stack frame. */
1845 select_frame (get_current_frame ());
1847 /* Warn the user. */
1848 if (frame_level
> 0 && !current_uiout
->is_mi_like_p ())
1850 warning (_("Couldn't restore frame #%d in "
1851 "current thread. Bottom (innermost) frame selected:"),
1853 /* For MI, we should probably have a notification about current
1854 frame change. But this error is not very likely, so don't
1856 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1863 if (!target_has_registers () || !target_has_stack ()
1864 || !target_has_memory ())
1867 /* Traceframes are effectively a substitute for the live inferior. */
1868 if (get_traceframe_number () < 0)
1870 /* No current inferior, no frame. */
1871 if (inferior_ptid
== null_ptid
)
1874 thread_info
*tp
= inferior_thread ();
1875 /* Don't try to read from a dead thread. */
1876 if (tp
->state
== THREAD_EXITED
)
1879 /* ... or from a spinning thread. */
1880 if (tp
->executing ())
1890 get_selected_frame (const char *message
)
1892 if (selected_frame
== NULL
)
1894 if (message
!= NULL
&& !has_stack_frames ())
1895 error (("%s"), message
);
1897 lookup_selected_frame (selected_frame_id
, selected_frame_level
);
1899 /* There is always a frame. */
1900 gdb_assert (selected_frame
!= NULL
);
1901 return selected_frame
;
1904 /* This is a variant of get_selected_frame() which can be called when
1905 the inferior does not have a frame; in that case it will return
1906 NULL instead of calling error(). */
1909 deprecated_safe_get_selected_frame (void)
1911 if (!has_stack_frames ())
1913 return get_selected_frame (NULL
);
1916 /* Invalidate the selected frame. */
1919 invalidate_selected_frame ()
1921 selected_frame
= nullptr;
1922 selected_frame_level
= -1;
1923 selected_frame_id
= null_frame_id
;
1929 select_frame (const frame_info_ptr
&fi
)
1931 gdb_assert (fi
!= nullptr);
1933 selected_frame
= fi
;
1934 selected_frame_level
= frame_relative_level (fi
);
1936 /* If the frame is a user-created one, save its level and frame id just like
1937 any other non-level-0 frame. */
1938 if (selected_frame_level
== 0 && !fi
->this_id
.value
.user_created_p
)
1940 /* Treat the current frame especially -- we want to always
1941 save/restore it without warning, even if the frame ID changes
1942 (see lookup_selected_frame). E.g.:
1944 // The current frame is selected, the target had just stopped.
1946 scoped_restore_selected_frame restore_frame;
1947 some_operation_that_changes_the_stack ();
1949 // scoped_restore_selected_frame's dtor runs, but the
1950 // original frame_id can't be found. No matter whether it
1951 // is found or not, we still end up with the now-current
1952 // frame selected. Warning in lookup_selected_frame in this
1953 // case seems pointless.
1955 Also get_frame_id may access the target's registers/memory,
1956 and thus skipping get_frame_id optimizes the common case.
1958 Saving the selected frame this way makes get_selected_frame
1959 and restore_current_frame return/re-select whatever frame is
1960 the innermost (current) then. */
1961 selected_frame_level
= -1;
1962 selected_frame_id
= null_frame_id
;
1965 selected_frame_id
= get_frame_id (fi
);
1967 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1968 frame is being invalidated. */
1970 /* FIXME: kseitz/2002-08-28: It would be nice to call
1971 selected_frame_level_changed_event() right here, but due to limitations
1972 in the current interfaces, we would end up flooding UIs with events
1973 because select_frame() is used extensively internally.
1975 Once we have frame-parameterized frame (and frame-related) commands,
1976 the event notification can be moved here, since this function will only
1977 be called when the user's selected frame is being changed. */
1979 /* Ensure that symbols for this frame are read in. Also, determine the
1980 source language of this frame, and switch to it if desired. */
1985 /* We retrieve the frame's symtab by using the frame PC.
1986 However we cannot use the frame PC as-is, because it usually
1987 points to the instruction following the "call", which is
1988 sometimes the first instruction of another function. So we
1989 rely on get_frame_address_in_block() which provides us with a
1990 PC which is guaranteed to be inside the frame's code
1992 if (get_frame_address_in_block_if_available (fi
, &pc
))
1994 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
1997 && cust
->language () != current_language
->la_language
1998 && cust
->language () != language_unknown
1999 && language_mode
== language_mode_auto
)
2000 set_language (cust
->language ());
2005 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
2006 Always returns a non-NULL value. */
2008 static frame_info_ptr
2009 create_new_frame (frame_id id
)
2011 gdb_assert (id
.user_created_p
);
2012 gdb_assert (id
.stack_status
== frame_id_stack_status::FID_STACK_VALID
);
2013 gdb_assert (id
.code_addr_p
);
2015 frame_debug_printf ("stack_addr=%s, core_addr=%s",
2016 hex_string (id
.stack_addr
), hex_string (id
.code_addr
));
2018 /* Avoid creating duplicate frames, search for an existing frame with that id
2020 frame_info_ptr frame
= frame_stash_find (id
);
2021 if (frame
!= nullptr)
2024 frame_info
*fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2026 fi
->next
= create_sentinel_frame (current_program_space
,
2027 current_inferior ()->aspace
.get (),
2028 get_thread_regcache (inferior_thread ()),
2029 id
.stack_addr
, id
.code_addr
).get ();
2031 /* Set/update this frame's cached PC value, found in the next frame.
2032 Do this before looking for this frame's unwinder. A sniffer is
2033 very likely to read this, and the corresponding unwinder is
2034 entitled to rely that the PC doesn't magically change. */
2035 fi
->next
->prev_pc
.value
= id
.code_addr
;
2036 fi
->next
->prev_pc
.status
= CC_VALUE
;
2038 /* We currently assume that frame chain's can't cross spaces. */
2039 fi
->pspace
= fi
->next
->pspace
;
2040 fi
->aspace
= fi
->next
->aspace
;
2042 /* Select/initialize both the unwind function and the frame's type
2044 frame_unwind_find_by_frame (frame_info_ptr (fi
), &fi
->prologue_cache
);
2046 fi
->this_id
.p
= frame_id_status::COMPUTED
;
2047 fi
->this_id
.value
= id
;
2049 bool added
= frame_stash_add (fi
);
2052 frame_debug_printf (" -> %s", fi
->to_string ().c_str ());
2054 return frame_info_ptr (fi
);
2058 create_new_frame (CORE_ADDR stack
, CORE_ADDR pc
)
2060 frame_id id
= frame_id_build (stack
, pc
);
2061 id
.user_created_p
= 1;
2063 return create_new_frame (id
);
2066 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
2067 innermost frame). Be careful to not fall off the bottom of the
2068 frame chain and onto the sentinel frame. */
2071 get_next_frame (const frame_info_ptr
&this_frame
)
2073 if (this_frame
->level
> 0)
2074 return frame_info_ptr (this_frame
->next
);
2079 /* Return the frame that THIS_FRAME calls. If THIS_FRAME is the
2080 innermost (i.e. current) frame, return the sentinel frame. Thus,
2081 unlike get_next_frame(), NULL will never be returned. */
2084 get_next_frame_sentinel_okay (const frame_info_ptr
&this_frame
)
2086 gdb_assert (this_frame
!= NULL
);
2088 /* Note that, due to the manner in which the sentinel frame is
2089 constructed, this_frame->next still works even when this_frame
2090 is the sentinel frame. But we disallow it here anyway because
2091 calling get_next_frame_sentinel_okay() on the sentinel frame
2092 is likely a coding error. */
2093 if (this_frame
->this_id
.p
== frame_id_status::COMPUTED
)
2094 gdb_assert (!is_sentinel_frame_id (this_frame
->this_id
.value
));
2096 return frame_info_ptr (this_frame
->next
);
2099 /* Observer for the target_changed event. */
2102 frame_observer_target_changed (struct target_ops
*target
)
2104 reinit_frame_cache ();
2107 /* Flush the entire frame cache. */
2110 reinit_frame_cache (void)
2112 ++frame_cache_generation
;
2114 if (htab_elements (frame_stash
) > 0)
2115 annotate_frames_invalid ();
2117 invalidate_selected_frame ();
2119 /* Invalidate cache. */
2120 if (sentinel_frame
!= nullptr)
2122 /* If frame 0's id is not computed, it is not in the frame stash, so its
2123 dealloc functions will not be called when emptying the frame stash.
2124 Call frame_info_del manually in that case. */
2125 frame_info
*current_frame
= sentinel_frame
->prev
;
2126 if (current_frame
!= nullptr
2127 && current_frame
->this_id
.p
== frame_id_status::NOT_COMPUTED
)
2128 frame_info_del (current_frame
);
2130 sentinel_frame
= nullptr;
2133 frame_stash_invalidate ();
2135 /* Since we can't really be sure what the first object allocated was. */
2136 obstack_free (&frame_cache_obstack
, 0);
2137 obstack_init (&frame_cache_obstack
);
2139 for (frame_info_ptr
&iter
: frame_info_ptr::frame_list
)
2142 frame_debug_printf ("generation=%d", frame_cache_generation
);
2145 /* Find where a register is saved (in memory or another register).
2146 The result of frame_register_unwind is just where it is saved
2147 relative to this particular frame. */
2150 frame_register_unwind_location (const frame_info_ptr
&initial_this_frame
,
2151 int regnum
, int *optimizedp
, lval_type
*lvalp
,
2152 CORE_ADDR
*addrp
, int *realnump
)
2154 gdb_assert (initial_this_frame
== nullptr || initial_this_frame
->level
>= 0);
2156 frame_info_ptr this_frame
= initial_this_frame
;
2157 while (this_frame
!= NULL
)
2161 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
2162 lvalp
, addrp
, realnump
, NULL
);
2167 if (*lvalp
!= lval_register
)
2171 this_frame
= get_next_frame (this_frame
);
2175 /* Get the previous raw frame, and check that it is not identical to
2176 same other frame frame already in the chain. If it is, there is
2177 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
2178 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
2179 validity tests, that compare THIS_FRAME and the next frame, we do
2180 this right after creating the previous frame, to avoid ever ending
2181 up with two frames with the same id in the frame chain.
2183 There is however, one case where this cycle detection is not desirable,
2184 when asking for the previous frame of an inline frame, in this case, if
2185 the previous frame is a duplicate and we return nullptr then we will be
2186 unable to calculate the frame_id of the inline frame, this in turn
2187 causes inline_frame_this_id() to fail. So for inline frames (and only
2188 for inline frames), the previous frame will always be returned, even when it
2189 has a duplicate frame_id. We're not worried about cycles in the frame
2190 chain as, if the previous frame returned here has a duplicate frame_id,
2191 then the frame_id of the inline frame, calculated based off the frame_id
2192 of the previous frame, should also be a duplicate. */
2194 static frame_info_ptr
2195 get_prev_frame_maybe_check_cycle (const frame_info_ptr
&this_frame
)
2197 frame_info_ptr prev_frame
= get_prev_frame_raw (this_frame
);
2199 /* Don't compute the frame id of the current frame yet. Unwinding
2200 the sentinel frame can fail (e.g., if the thread is gone and we
2201 can't thus read its registers). If we let the cycle detection
2202 code below try to compute a frame ID, then an error thrown from
2203 within the frame ID computation would result in the sentinel
2204 frame as outermost frame, which is bogus. Instead, we'll compute
2205 the current frame's ID lazily in get_frame_id. Note that there's
2206 no point in doing cycle detection when there's only one frame, so
2207 nothing is lost here. */
2208 if (prev_frame
->level
== 0)
2211 unsigned int entry_generation
= get_frame_cache_generation ();
2215 compute_frame_id (prev_frame
);
2217 bool cycle_detection_p
= get_frame_type (this_frame
) != INLINE_FRAME
;
2219 /* This assert checks GDB's state with respect to calculating the
2220 frame-id of THIS_FRAME, in the case where THIS_FRAME is an inline
2223 If THIS_FRAME is frame #0, and is an inline frame, then we put off
2224 calculating the frame_id until we specifically make a call to
2225 get_frame_id(). As a result we can enter this function in two
2226 possible states. If GDB asked for the previous frame of frame #0
2227 then THIS_FRAME will be frame #0 (an inline frame), and the
2228 frame_id will be in the NOT_COMPUTED state. However, if GDB asked
2229 for the frame_id of frame #0, then, as getting the frame_id of an
2230 inline frame requires us to get the frame_id of the previous
2231 frame, we will still end up in here, and the frame_id status will
2234 If, instead, THIS_FRAME is at a level greater than #0 then things
2235 are simpler. For these frames we immediately compute the frame_id
2236 when the frame is initially created, and so, for those frames, we
2237 will always enter this function with the frame_id status of
2239 gdb_assert (cycle_detection_p
2240 || (this_frame
->level
> 0
2241 && (this_frame
->this_id
.p
2242 == frame_id_status::COMPUTING
))
2243 || (this_frame
->level
== 0
2244 && (this_frame
->this_id
.p
2245 != frame_id_status::COMPUTED
)));
2247 /* We must do the CYCLE_DETECTION_P check after attempting to add
2248 PREV_FRAME into the cache; if PREV_FRAME is unique then we do want
2249 it in the cache, but if it is a duplicate and CYCLE_DETECTION_P is
2250 false, then we don't want to unlink it. */
2251 if (!frame_stash_add (prev_frame
.get ()) && cycle_detection_p
)
2253 /* Another frame with the same id was already in the stash. We just
2254 detected a cycle. */
2255 frame_debug_printf (" -> nullptr // this frame has same ID");
2257 this_frame
->stop_reason
= UNWIND_SAME_ID
;
2259 prev_frame
->next
= NULL
;
2260 this_frame
->prev
= NULL
;
2264 catch (const gdb_exception
&ex
)
2266 if (get_frame_cache_generation () == entry_generation
)
2268 prev_frame
->next
= NULL
;
2269 this_frame
->prev
= NULL
;
2278 /* Helper function for get_prev_frame_always, this is called inside a
2279 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
2280 there is no such frame. This may throw an exception. */
2282 static frame_info_ptr
2283 get_prev_frame_always_1 (const frame_info_ptr
&this_frame
)
2285 FRAME_SCOPED_DEBUG_ENTER_EXIT
;
2287 gdb_assert (this_frame
!= NULL
);
2291 if (this_frame
!= NULL
)
2292 frame_debug_printf ("this_frame=%d", this_frame
->level
);
2294 frame_debug_printf ("this_frame=nullptr");
2297 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2299 /* Only try to do the unwind once. */
2300 if (this_frame
->prev_p
)
2302 if (this_frame
->prev
!= nullptr)
2303 frame_debug_printf (" -> %s // cached",
2304 this_frame
->prev
->to_string ().c_str ());
2307 (" -> nullptr // %s // cached",
2308 frame_stop_reason_symbol_string (this_frame
->stop_reason
));
2309 return frame_info_ptr (this_frame
->prev
);
2312 /* If the frame unwinder hasn't been selected yet, we must do so
2313 before setting prev_p; otherwise the check for misbehaved
2314 sniffers will think that this frame's sniffer tried to unwind
2315 further (see frame_cleanup_after_sniffer). */
2316 if (this_frame
->unwind
== NULL
)
2317 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
2319 this_frame
->prev_p
= true;
2320 this_frame
->stop_reason
= UNWIND_NO_REASON
;
2322 /* If we are unwinding from an inline frame, all of the below tests
2323 were already performed when we unwound from the next non-inline
2324 frame. We must skip them, since we can not get THIS_FRAME's ID
2325 until we have unwound all the way down to the previous non-inline
2327 if (get_frame_type (this_frame
) == INLINE_FRAME
)
2328 return get_prev_frame_maybe_check_cycle (this_frame
);
2330 /* If this_frame is the current frame, then compute and stash its
2331 frame id prior to fetching and computing the frame id of the
2332 previous frame. Otherwise, the cycle detection code in
2333 get_prev_frame_if_no_cycle() will not work correctly. When
2334 get_frame_id() is called later on, an assertion error will be
2335 triggered in the event of a cycle between the current frame and
2338 Note we do this after the INLINE_FRAME check above. That is
2339 because the inline frame's frame id computation needs to fetch
2340 the frame id of its previous real stack frame. I.e., we need to
2341 avoid recursion in that case. This is OK since we're sure the
2342 inline frame won't create a cycle with the real stack frame. See
2343 inline_frame_this_id. */
2344 if (this_frame
->level
== 0)
2345 get_frame_id (this_frame
);
2347 /* Check that this frame is unwindable. If it isn't, don't try to
2348 unwind to the prev frame. */
2349 this_frame
->stop_reason
2350 = this_frame
->unwind
->stop_reason (this_frame
,
2351 &this_frame
->prologue_cache
);
2353 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
2356 (" -> nullptr // %s",
2357 frame_stop_reason_symbol_string (this_frame
->stop_reason
));
2361 /* Check that this frame's ID isn't inner to (younger, below, next)
2362 the next frame. This happens when a frame unwind goes backwards.
2363 This check is valid only if this frame and the next frame are NORMAL.
2364 See the comment at frame_id_inner for details. */
2365 if (get_frame_type (this_frame
) == NORMAL_FRAME
2366 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
2367 && frame_id_inner (get_frame_arch (frame_info_ptr (this_frame
->next
)),
2368 get_frame_id (this_frame
),
2369 get_frame_id (frame_info_ptr (this_frame
->next
))))
2371 CORE_ADDR this_pc_in_block
;
2372 struct minimal_symbol
*morestack_msym
;
2373 const char *morestack_name
= NULL
;
2375 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
2376 this_pc_in_block
= get_frame_address_in_block (this_frame
);
2377 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
2379 morestack_name
= morestack_msym
->linkage_name ();
2380 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
2382 frame_debug_printf (" -> nullptr // this frame ID is inner");
2383 this_frame
->stop_reason
= UNWIND_INNER_ID
;
2388 /* Check that this and the next frame do not unwind the PC register
2389 to the same memory location. If they do, then even though they
2390 have different frame IDs, the new frame will be bogus; two
2391 functions can't share a register save slot for the PC. This can
2392 happen when the prologue analyzer finds a stack adjustment, but
2395 This check does assume that the "PC register" is roughly a
2396 traditional PC, even if the gdbarch_unwind_pc method adjusts
2397 it (we do not rely on the value, only on the unwound PC being
2398 dependent on this value). A potential improvement would be
2399 to have the frame prev_pc method and the gdbarch unwind_pc
2400 method set the same lval and location information as
2401 frame_register_unwind. */
2402 if (this_frame
->level
> 0
2403 && gdbarch_pc_regnum (gdbarch
) >= 0
2404 && get_frame_type (this_frame
) == NORMAL_FRAME
2405 && (get_frame_type (frame_info_ptr (this_frame
->next
)) == NORMAL_FRAME
2406 || get_frame_type (frame_info_ptr (this_frame
->next
)) == INLINE_FRAME
))
2408 int optimized
, realnum
, nrealnum
;
2409 enum lval_type lval
, nlval
;
2410 CORE_ADDR addr
, naddr
;
2412 frame_register_unwind_location (this_frame
,
2413 gdbarch_pc_regnum (gdbarch
),
2414 &optimized
, &lval
, &addr
, &realnum
);
2415 frame_register_unwind_location (get_next_frame (this_frame
),
2416 gdbarch_pc_regnum (gdbarch
),
2417 &optimized
, &nlval
, &naddr
, &nrealnum
);
2419 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
2420 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
2422 frame_debug_printf (" -> nullptr // no saved PC");
2423 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
2424 this_frame
->prev
= NULL
;
2429 /* Ensure we can unwind the program counter of THIS_FRAME. */
2432 /* Calling frame_unwind_pc for the sentinel frame relies on the
2433 current_frame being set, which at this point it might not be if we
2434 are in the process of setting the current_frame after a stop (see
2437 The point of this check is to ensure that the unwinder for
2438 THIS_FRAME can actually unwind the $pc, which we assume the
2439 sentinel frame unwinder can always do (it's just a read from the
2440 machine state), so we only call frame_unwind_pc for frames other
2441 than the sentinel (level -1) frame.
2443 Additionally, we don't actually care about the value of the
2444 unwound $pc, just that the call completed successfully. */
2445 if (this_frame
->level
>= 0)
2446 frame_unwind_pc (this_frame
);
2448 catch (const gdb_exception_error
&ex
)
2450 if (ex
.error
== NOT_AVAILABLE_ERROR
|| ex
.error
== OPTIMIZED_OUT_ERROR
)
2452 frame_debug_printf (" -> nullptr // no saved PC");
2453 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
2454 this_frame
->prev
= nullptr;
2461 return get_prev_frame_maybe_check_cycle (this_frame
);
2464 /* Return a "struct frame_info" corresponding to the frame that called
2465 THIS_FRAME. Returns NULL if there is no such frame.
2467 Unlike get_prev_frame, this function always tries to unwind the
2471 get_prev_frame_always (const frame_info_ptr
&this_frame
)
2473 frame_info_ptr prev_frame
= NULL
;
2477 prev_frame
= get_prev_frame_always_1 (this_frame
);
2479 catch (const gdb_exception_error
&ex
)
2481 if (ex
.error
== MEMORY_ERROR
)
2483 this_frame
->stop_reason
= UNWIND_MEMORY_ERROR
;
2484 if (ex
.message
!= NULL
)
2489 /* The error needs to live as long as the frame does.
2490 Allocate using stack local STOP_STRING then assign the
2491 pointer to the frame, this allows the STOP_STRING on the
2492 frame to be of type 'const char *'. */
2493 size
= ex
.message
->size () + 1;
2494 stop_string
= (char *) frame_obstack_zalloc (size
);
2495 memcpy (stop_string
, ex
.what (), size
);
2496 this_frame
->stop_string
= stop_string
;
2507 /* Construct a new "struct frame_info" and link it previous to
2510 static frame_info_ptr
2511 get_prev_frame_raw (const frame_info_ptr
&this_frame
)
2513 frame_info
*prev_frame
;
2515 /* Allocate the new frame but do not wire it in to the frame chain.
2516 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2517 frame->next to pull some fancy tricks (of course such code is, by
2518 definition, recursive). Try to prevent it.
2520 There is no reason to worry about memory leaks, should the
2521 remainder of the function fail. The allocated memory will be
2522 quickly reclaimed when the frame cache is flushed, and the `we've
2523 been here before' check above will stop repeated memory
2524 allocation calls. */
2525 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2526 prev_frame
->level
= this_frame
->level
+ 1;
2528 /* For now, assume we don't have frame chains crossing address
2530 prev_frame
->pspace
= this_frame
->pspace
;
2531 prev_frame
->aspace
= this_frame
->aspace
;
2533 /* Don't yet compute ->unwind (and hence ->type). It is computed
2534 on-demand in get_frame_type, frame_register_unwind, and
2537 /* Don't yet compute the frame's ID. It is computed on-demand by
2540 /* The unwound frame ID is validate at the start of this function,
2541 as part of the logic to decide if that frame should be further
2542 unwound, and not here while the prev frame is being created.
2543 Doing this makes it possible for the user to examine a frame that
2544 has an invalid frame ID.
2546 Some very old VAX code noted: [...] For the sake of argument,
2547 suppose that the stack is somewhat trashed (which is one reason
2548 that "info frame" exists). So, return 0 (indicating we don't
2549 know the address of the arglist) if we don't know what frame this
2553 this_frame
->prev
= prev_frame
;
2554 prev_frame
->next
= this_frame
.get ();
2556 frame_debug_printf (" -> %s", prev_frame
->to_string ().c_str ());
2558 return frame_info_ptr (prev_frame
);
2561 /* Debug routine to print a NULL frame being returned. */
2564 frame_debug_got_null_frame (const frame_info_ptr
&this_frame
,
2569 if (this_frame
!= NULL
)
2570 frame_debug_printf ("this_frame=%d -> %s", this_frame
->level
, reason
);
2572 frame_debug_printf ("this_frame=nullptr -> %s", reason
);
2576 /* Is this (non-sentinel) frame in the "main"() function? */
2579 inside_main_func (const frame_info_ptr
&this_frame
)
2581 if (current_program_space
->symfile_object_file
== nullptr)
2584 CORE_ADDR sym_addr
= 0;
2585 const char *name
= main_name ();
2586 bound_minimal_symbol msymbol
2587 = lookup_minimal_symbol (name
, NULL
,
2588 current_program_space
->symfile_object_file
);
2590 if (msymbol
.minsym
!= nullptr)
2591 sym_addr
= msymbol
.value_address ();
2593 /* Favor a full symbol in Fortran, for the case where the Fortran main
2594 is also called "main". */
2595 if (msymbol
.minsym
== nullptr
2596 || get_frame_language (this_frame
) == language_fortran
)
2598 /* In some language (for example Fortran) there will be no minimal
2599 symbol with the name of the main function. In this case we should
2600 search the full symbols to see if we can find a match. */
2601 struct block_symbol bs
= lookup_symbol (name
, nullptr,
2602 SEARCH_FUNCTION_DOMAIN
, nullptr);
2604 /* This lookup should always yield a block-valued symbol. */
2605 if (bs
.symbol
!= nullptr && bs
.symbol
->aclass () == LOC_BLOCK
)
2607 const struct block
*block
= bs
.symbol
->value_block ();
2608 gdb_assert (block
!= nullptr);
2609 sym_addr
= block
->start ();
2611 else if (msymbol
.minsym
== nullptr)
2615 /* Convert any function descriptor addresses into the actual function
2617 sym_addr
= (gdbarch_convert_from_func_ptr_addr
2618 (get_frame_arch (this_frame
), sym_addr
,
2619 current_inferior ()->top_target ()));
2621 return sym_addr
== get_frame_func (this_frame
);
2624 /* Test whether THIS_FRAME is inside the process entry point function. */
2627 inside_entry_func (const frame_info_ptr
&this_frame
)
2629 CORE_ADDR entry_point
;
2631 if (!entry_point_address_query (&entry_point
))
2634 return get_frame_func (this_frame
) == entry_point
;
2637 /* Return a structure containing various interesting information about
2638 the frame that called THIS_FRAME. Returns NULL if there is either
2639 no such frame or the frame fails any of a set of target-independent
2640 condition that should terminate the frame chain (e.g., as unwinding
2643 This function should not contain target-dependent tests, such as
2644 checking whether the program-counter is zero. */
2647 get_prev_frame (const frame_info_ptr
&this_frame
)
2649 FRAME_SCOPED_DEBUG_ENTER_EXIT
;
2654 /* There is always a frame. If this assertion fails, suspect that
2655 something should be calling get_selected_frame() or
2656 get_current_frame(). */
2657 gdb_assert (this_frame
!= NULL
);
2659 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2661 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2662 sense to stop unwinding at a dummy frame. One place where a dummy
2663 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2664 pcsqh register (space register for the instruction at the head of the
2665 instruction queue) cannot be written directly; the only way to set it
2666 is to branch to code that is in the target space. In order to implement
2667 frame dummies on HPUX, the called function is made to jump back to where
2668 the inferior was when the user function was called. If gdb was inside
2669 the main function when we created the dummy frame, the dummy frame will
2670 point inside the main function. */
2671 if (this_frame
->level
>= 0
2672 && get_frame_type (this_frame
) == NORMAL_FRAME
2673 && !user_set_backtrace_options
.backtrace_past_main
2675 && inside_main_func (this_frame
))
2676 /* Don't unwind past main(). Note, this is done _before_ the
2677 frame has been marked as previously unwound. That way if the
2678 user later decides to enable unwinds past main(), that will
2679 automatically happen. */
2681 frame_debug_got_null_frame (this_frame
, "inside main func");
2685 /* If the user's backtrace limit has been exceeded, stop. We must
2686 add two to the current level; one of those accounts for backtrace_limit
2687 being 1-based and the level being 0-based, and the other accounts for
2688 the level of the new frame instead of the level of the current
2690 if (this_frame
->level
+ 2 > user_set_backtrace_options
.backtrace_limit
)
2692 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2696 /* If we're already inside the entry function for the main objfile,
2697 then it isn't valid. Don't apply this test to a dummy frame -
2698 dummy frame PCs typically land in the entry func. Don't apply
2699 this test to the sentinel frame. Sentinel frames should always
2700 be allowed to unwind. */
2701 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2702 wasn't checking for "main" in the minimal symbols. With that
2703 fixed asm-source tests now stop in "main" instead of halting the
2704 backtrace in weird and wonderful ways somewhere inside the entry
2705 file. Suspect that tests for inside the entry file/func were
2706 added to work around that (now fixed) case. */
2707 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2708 suggested having the inside_entry_func test use the
2709 inside_main_func() msymbol trick (along with entry_point_address()
2710 I guess) to determine the address range of the start function.
2711 That should provide a far better stopper than the current
2713 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2714 applied tail-call optimizations to main so that a function called
2715 from main returns directly to the caller of main. Since we don't
2716 stop at main, we should at least stop at the entry point of the
2718 if (this_frame
->level
>= 0
2719 && get_frame_type (this_frame
) == NORMAL_FRAME
2720 && !user_set_backtrace_options
.backtrace_past_entry
2722 && inside_entry_func (this_frame
))
2724 frame_debug_got_null_frame (this_frame
, "inside entry func");
2728 /* Assume that the only way to get a zero PC is through something
2729 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2730 will never unwind a zero PC. */
2731 if (this_frame
->level
> 0
2732 && (get_frame_type (this_frame
) == NORMAL_FRAME
2733 || get_frame_type (this_frame
) == INLINE_FRAME
)
2734 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2735 && frame_pc_p
&& frame_pc
== 0)
2737 frame_debug_got_null_frame (this_frame
, "zero PC");
2741 return get_prev_frame_always (this_frame
);
2745 get_frame_pc (const frame_info_ptr
&frame
)
2747 gdb_assert (frame
->next
!= NULL
);
2748 return frame_unwind_pc (frame_info_ptr (frame
->next
));
2752 get_frame_pc_if_available (const frame_info_ptr
&frame
, CORE_ADDR
*pc
)
2755 gdb_assert (frame
->next
!= NULL
);
2759 *pc
= frame_unwind_pc (frame_info_ptr (frame
->next
));
2761 catch (const gdb_exception_error
&ex
)
2763 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2772 /* Return an address that falls within THIS_FRAME's code block. */
2775 get_frame_address_in_block (const frame_info_ptr
&this_frame
)
2777 /* A draft address. */
2778 CORE_ADDR pc
= get_frame_pc (this_frame
);
2780 frame_info_ptr
next_frame (this_frame
->next
);
2782 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2783 Normally the resume address is inside the body of the function
2784 associated with THIS_FRAME, but there is a special case: when
2785 calling a function which the compiler knows will never return
2786 (for instance abort), the call may be the very last instruction
2787 in the calling function. The resume address will point after the
2788 call and may be at the beginning of a different function
2791 If THIS_FRAME is a signal frame or dummy frame, then we should
2792 not adjust the unwound PC. For a dummy frame, GDB pushed the
2793 resume address manually onto the stack. For a signal frame, the
2794 OS may have pushed the resume address manually and invoked the
2795 handler (e.g. GNU/Linux), or invoked the trampoline which called
2796 the signal handler - but in either case the signal handler is
2797 expected to return to the trampoline. So in both of these
2798 cases we know that the resume address is executable and
2799 related. So we only need to adjust the PC if THIS_FRAME
2800 is a normal function.
2802 If the program has been interrupted while THIS_FRAME is current,
2803 then clearly the resume address is inside the associated
2804 function. There are three kinds of interruption: debugger stop
2805 (next frame will be SENTINEL_FRAME), operating system
2806 signal or exception (next frame will be SIGTRAMP_FRAME),
2807 or debugger-induced function call (next frame will be
2808 DUMMY_FRAME). So we only need to adjust the PC if
2809 NEXT_FRAME is a normal function.
2811 We check the type of NEXT_FRAME first, since it is already
2812 known; frame type is determined by the unwinder, and since
2813 we have THIS_FRAME we've already selected an unwinder for
2816 If the next frame is inlined, we need to keep going until we find
2817 the real function - for instance, if a signal handler is invoked
2818 while in an inlined function, then the code address of the
2819 "calling" normal function should not be adjusted either. */
2821 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2822 next_frame
= frame_info_ptr (next_frame
->next
);
2824 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2825 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2826 && (get_frame_type (this_frame
) == NORMAL_FRAME
2827 || get_frame_type (this_frame
) == TAILCALL_FRAME
2828 || get_frame_type (this_frame
) == INLINE_FRAME
))
2835 get_frame_address_in_block_if_available (const frame_info_ptr
&this_frame
,
2841 *pc
= get_frame_address_in_block (this_frame
);
2843 catch (const gdb_exception_error
&ex
)
2845 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2854 find_frame_sal (const frame_info_ptr
&frame
)
2856 frame_info_ptr next_frame
;
2860 if (frame_inlined_callees (frame
) > 0)
2864 /* If the current frame has some inlined callees, and we have a next
2865 frame, then that frame must be an inlined frame. In this case
2866 this frame's sal is the "call site" of the next frame's inlined
2867 function, which can not be inferred from get_frame_pc. */
2868 next_frame
= get_next_frame (frame
);
2870 sym
= get_frame_function (next_frame
);
2872 sym
= inline_skipped_symbol (inferior_thread ());
2874 /* If frame is inline, it certainly has symbols. */
2877 symtab_and_line sal
;
2878 if (sym
->line () != 0)
2880 sal
.symtab
= sym
->symtab ();
2881 sal
.line
= sym
->line ();
2884 /* If the symbol does not have a location, we don't know where
2885 the call site is. Do not pretend to. This is jarring, but
2886 we can't do much better. */
2887 sal
.pc
= get_frame_pc (frame
);
2889 sal
.pspace
= get_frame_program_space (frame
);
2893 /* If FRAME is not the innermost frame, that normally means that
2894 FRAME->pc points at the return instruction (which is *after* the
2895 call instruction), and we want to get the line containing the
2896 call (because the call is where the user thinks the program is).
2897 However, if the next frame is either a SIGTRAMP_FRAME or a
2898 DUMMY_FRAME, then the next frame will contain a saved interrupt
2899 PC and such a PC indicates the current (rather than next)
2900 instruction/line, consequently, for such cases, want to get the
2901 line containing fi->pc. */
2902 if (!get_frame_pc_if_available (frame
, &pc
))
2905 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2906 return find_pc_line (pc
, notcurrent
);
2909 /* Per "frame.h", return the ``address'' of the frame. Code should
2910 really be using get_frame_id(). */
2912 get_frame_base (const frame_info_ptr
&fi
)
2914 return get_frame_id (fi
).stack_addr
;
2917 /* High-level offsets into the frame. Used by the debug info. */
2920 get_frame_base_address (const frame_info_ptr
&fi
)
2922 if (get_frame_type (fi
) != NORMAL_FRAME
)
2924 if (fi
->base
== NULL
)
2925 fi
->base
= frame_base_find_by_frame (fi
);
2926 /* Sneaky: If the low-level unwind and high-level base code share a
2927 common unwinder, let them share the prologue cache. */
2928 if (fi
->base
->unwind
== fi
->unwind
)
2929 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2930 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2934 get_frame_locals_address (const frame_info_ptr
&fi
)
2936 if (get_frame_type (fi
) != NORMAL_FRAME
)
2938 /* If there isn't a frame address method, find it. */
2939 if (fi
->base
== NULL
)
2940 fi
->base
= frame_base_find_by_frame (fi
);
2941 /* Sneaky: If the low-level unwind and high-level base code share a
2942 common unwinder, let them share the prologue cache. */
2943 if (fi
->base
->unwind
== fi
->unwind
)
2944 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2945 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2949 get_frame_args_address (const frame_info_ptr
&fi
)
2951 if (get_frame_type (fi
) != NORMAL_FRAME
)
2953 /* If there isn't a frame address method, find it. */
2954 if (fi
->base
== NULL
)
2955 fi
->base
= frame_base_find_by_frame (fi
);
2956 /* Sneaky: If the low-level unwind and high-level base code share a
2957 common unwinder, let them share the prologue cache. */
2958 if (fi
->base
->unwind
== fi
->unwind
)
2959 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2960 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2963 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2967 frame_unwinder_is (const frame_info_ptr
&fi
, const frame_unwind
*unwinder
)
2969 if (fi
->unwind
== nullptr)
2970 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2972 return fi
->unwind
== unwinder
;
2975 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2976 or -1 for a NULL frame. */
2979 frame_relative_level (const frame_info_ptr
&fi
)
2988 get_frame_type (const frame_info_ptr
&frame
)
2990 if (frame
->unwind
== NULL
)
2991 /* Initialize the frame's unwinder because that's what
2992 provides the frame's type. */
2993 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2994 return frame
->unwind
->type
;
2997 struct program_space
*
2998 get_frame_program_space (const frame_info_ptr
&frame
)
3000 return frame
->pspace
;
3003 struct program_space
*
3004 frame_unwind_program_space (const frame_info_ptr
&this_frame
)
3006 gdb_assert (this_frame
);
3008 /* This is really a placeholder to keep the API consistent --- we
3009 assume for now that we don't have frame chains crossing
3011 return this_frame
->pspace
;
3014 const address_space
*
3015 get_frame_address_space (const frame_info_ptr
&frame
)
3017 return frame
->aspace
;
3020 /* Memory access methods. */
3023 get_frame_memory (const frame_info_ptr
&this_frame
, CORE_ADDR addr
,
3024 gdb::array_view
<gdb_byte
> buffer
)
3026 read_memory (addr
, buffer
.data (), buffer
.size ());
3030 get_frame_memory_signed (const frame_info_ptr
&this_frame
, CORE_ADDR addr
,
3033 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
3034 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3036 return read_memory_integer (addr
, len
, byte_order
);
3040 get_frame_memory_unsigned (const frame_info_ptr
&this_frame
, CORE_ADDR addr
,
3043 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
3044 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
3046 return read_memory_unsigned_integer (addr
, len
, byte_order
);
3050 safe_frame_unwind_memory (const frame_info_ptr
&this_frame
,
3051 CORE_ADDR addr
, gdb::array_view
<gdb_byte
> buffer
)
3053 /* NOTE: target_read_memory returns zero on success! */
3054 return target_read_memory (addr
, buffer
.data (), buffer
.size ()) == 0;
3057 /* Architecture methods. */
3060 get_frame_arch (const frame_info_ptr
&this_frame
)
3062 return frame_unwind_arch (frame_info_ptr (this_frame
->next
));
3066 frame_unwind_arch (const frame_info_ptr
&next_frame
)
3068 if (!next_frame
->prev_arch
.p
)
3070 struct gdbarch
*arch
;
3072 if (next_frame
->unwind
== NULL
)
3073 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
3075 if (next_frame
->unwind
->prev_arch
!= NULL
)
3076 arch
= next_frame
->unwind
->prev_arch (next_frame
,
3077 &next_frame
->prologue_cache
);
3079 arch
= get_frame_arch (next_frame
);
3081 next_frame
->prev_arch
.arch
= arch
;
3082 next_frame
->prev_arch
.p
= true;
3083 frame_debug_printf ("next_frame=%d -> %s",
3085 gdbarch_bfd_arch_info (arch
)->printable_name
);
3088 return next_frame
->prev_arch
.arch
;
3092 frame_unwind_caller_arch (const frame_info_ptr
&initial_next_frame
)
3094 frame_info_ptr next_frame
= skip_artificial_frames (initial_next_frame
);
3096 /* We must have a non-artificial frame. The caller is supposed to check
3097 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
3099 gdb_assert (next_frame
!= nullptr);
3101 return frame_unwind_arch (next_frame
);
3104 /* Gets the language of FRAME. */
3107 get_frame_language (const frame_info_ptr
&frame
)
3112 gdb_assert (frame
!= NULL
);
3114 /* We determine the current frame language by looking up its
3115 associated symtab. To retrieve this symtab, we use the frame
3116 PC. However we cannot use the frame PC as is, because it
3117 usually points to the instruction following the "call", which
3118 is sometimes the first instruction of another function. So
3119 we rely on get_frame_address_in_block(), it provides us with
3120 a PC that is guaranteed to be inside the frame's code
3125 pc
= get_frame_address_in_block (frame
);
3128 catch (const gdb_exception_error
&ex
)
3130 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
3136 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
3139 return cust
->language ();
3142 return language_unknown
;
3145 /* Stack pointer methods. */
3148 get_frame_sp (const frame_info_ptr
&this_frame
)
3150 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
3152 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
3153 operate on THIS_FRAME now. */
3154 return gdbarch_unwind_sp (gdbarch
, frame_info_ptr (this_frame
->next
));
3160 frame_follow_static_link (const frame_info_ptr
&initial_frame
)
3162 const block
*frame_block
= get_frame_block (initial_frame
, nullptr);
3163 if (frame_block
== nullptr)
3166 frame_block
= frame_block
->function_block ();
3168 const struct dynamic_prop
*static_link
= frame_block
->static_link ();
3169 if (static_link
== nullptr)
3172 CORE_ADDR upper_frame_base
;
3174 if (!dwarf2_evaluate_property (static_link
, initial_frame
, NULL
, &upper_frame_base
))
3177 /* Now climb up the stack frame until we reach the frame we are interested
3179 frame_info_ptr frame
= initial_frame
;
3180 for (; frame
!= nullptr; frame
= get_prev_frame (frame
))
3182 struct symbol
*framefunc
= get_frame_function (frame
);
3184 /* Stacks can be quite deep: give the user a chance to stop this. */
3187 /* If we don't know how to compute FRAME's base address, don't give up:
3188 maybe the frame we are looking for is upper in the stack frame. */
3189 if (framefunc
!= nullptr)
3191 if (const symbol_block_ops
*block_ops
= framefunc
->block_ops ();
3192 (block_ops
!= nullptr
3193 && block_ops
->get_frame_base
!= nullptr
3194 && (block_ops
->get_frame_base (framefunc
, frame
)
3195 == upper_frame_base
)))
3203 /* Return the reason why we can't unwind past FRAME. */
3205 enum unwind_stop_reason
3206 get_frame_unwind_stop_reason (const frame_info_ptr
&frame
)
3208 /* Fill-in STOP_REASON. */
3209 get_prev_frame_always (frame
);
3210 gdb_assert (frame
->prev_p
);
3212 return frame
->stop_reason
;
3215 /* Return a string explaining REASON. */
3218 unwind_stop_reason_to_string (enum unwind_stop_reason reason
)
3222 #define SET(name, description) \
3223 case name: return _(description);
3224 #include "unwind_stop_reasons.def"
3228 internal_error ("Invalid frame stop reason");
3233 frame_stop_reason_string (const frame_info_ptr
&fi
)
3235 gdb_assert (fi
->prev_p
);
3236 gdb_assert (fi
->prev
== NULL
);
3238 /* Return the specific string if we have one. */
3239 if (fi
->stop_string
!= NULL
)
3240 return fi
->stop_string
;
3242 /* Return the generic string if we have nothing better. */
3243 return unwind_stop_reason_to_string (fi
->stop_reason
);
3246 /* Return the enum symbol name of REASON as a string, to use in debug
3250 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
3254 #define SET(name, description) \
3255 case name: return #name;
3256 #include "unwind_stop_reasons.def"
3260 internal_error ("Invalid frame stop reason");
3264 /* Clean up after a failed (wrong unwinder) attempt to unwind past
3268 frame_cleanup_after_sniffer (const frame_info_ptr
&frame
)
3270 /* The sniffer should not allocate a prologue cache if it did not
3271 match this frame. */
3272 gdb_assert (frame
->prologue_cache
== NULL
);
3274 /* No sniffer should extend the frame chain; sniff based on what is
3276 gdb_assert (!frame
->prev_p
);
3278 /* The sniffer should not check the frame's ID; that's circular. */
3279 gdb_assert (frame
->this_id
.p
!= frame_id_status::COMPUTED
);
3281 /* Clear cached fields dependent on the unwinder.
3283 The previous PC is independent of the unwinder, but the previous
3284 function is not (see get_frame_address_in_block). */
3285 frame
->prev_func
.status
= CC_UNKNOWN
;
3286 frame
->prev_func
.addr
= 0;
3288 /* Discard the unwinder last, so that we can easily find it if an assertion
3289 in this function triggers. */
3290 frame
->unwind
= NULL
;
3293 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
3294 If sniffing fails, the caller should be sure to call
3295 frame_cleanup_after_sniffer. */
3298 frame_prepare_for_sniffer (const frame_info_ptr
&frame
,
3299 const struct frame_unwind
*unwind
)
3301 gdb_assert (frame
->unwind
== NULL
);
3302 frame
->unwind
= unwind
;
3305 static struct cmd_list_element
*set_backtrace_cmdlist
;
3306 static struct cmd_list_element
*show_backtrace_cmdlist
;
3308 /* Definition of the "set backtrace" settings that are exposed as
3309 "backtrace" command options. */
3311 using boolean_option_def
3312 = gdb::option::boolean_option_def
<set_backtrace_options
>;
3314 const gdb::option::option_def set_backtrace_option_defs
[] = {
3316 boolean_option_def
{
3318 [] (set_backtrace_options
*opt
) { return &opt
->backtrace_past_main
; },
3319 show_backtrace_past_main
, /* show_cmd_cb */
3320 N_("Set whether backtraces should continue past \"main\"."),
3321 N_("Show whether backtraces should continue past \"main\"."),
3322 N_("Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
3323 the backtrace at \"main\". Set this if you need to see the rest\n\
3324 of the stack trace."),
3327 boolean_option_def
{
3329 [] (set_backtrace_options
*opt
) { return &opt
->backtrace_past_entry
; },
3330 show_backtrace_past_entry
, /* show_cmd_cb */
3331 N_("Set whether backtraces should continue past the entry point of a program."),
3332 N_("Show whether backtraces should continue past the entry point of a program."),
3333 N_("Normally there are no callers beyond the entry point of a program, so GDB\n\
3334 will terminate the backtrace there. Set this if you need to see\n\
3335 the rest of the stack trace."),
3339 /* Implement the 'maintenance print frame-id' command. */
3342 maintenance_print_frame_id (const char *args
, int from_tty
)
3344 frame_info_ptr frame
;
3346 /* Use the currently selected frame, or select a frame based on the level
3347 number passed by the user. */
3348 if (args
== nullptr)
3349 frame
= get_selected_frame ("No frame selected");
3352 int level
= value_as_long (parse_and_eval (args
));
3353 frame
= find_relative_frame (get_current_frame (), &level
);
3356 /* Print the frame-id. */
3357 gdb_assert (frame
!= nullptr);
3358 gdb_printf ("frame-id for frame #%d: %s\n",
3359 frame_relative_level (frame
),
3360 get_frame_id (frame
).to_string ().c_str ());
3363 /* See frame-info-ptr.h. */
3365 frame_info_ptr::frame_info_ptr (struct frame_info
*ptr
)
3368 frame_list
.push_back (*this);
3370 if (m_ptr
== nullptr)
3373 m_cached_level
= ptr
->level
;
3375 if (m_cached_level
!= 0 || m_ptr
->this_id
.value
.user_created_p
)
3376 m_cached_id
= m_ptr
->this_id
.value
;
3379 /* See frame-info-ptr.h. */
3382 frame_info_ptr::reinflate () const
3384 /* Ensure we have a valid frame level (sentinel frame or above). */
3385 gdb_assert (m_cached_level
>= -1);
3387 if (m_ptr
!= nullptr)
3389 /* The frame_info wasn't invalidated, no need to reinflate. */
3393 if (m_cached_id
.user_created_p
)
3394 m_ptr
= create_new_frame (m_cached_id
).get ();
3397 /* Frame #0 needs special handling, see comment in select_frame. */
3398 if (m_cached_level
== 0)
3399 m_ptr
= get_current_frame ().get ();
3402 /* If we reach here without a valid frame id, it means we are trying
3403 to reinflate a frame whose id was not know at construction time.
3404 We're probably trying to reinflate a frame while computing its id
3405 which is not possible, and would indicate a problem with GDB. */
3406 gdb_assert (frame_id_p (m_cached_id
));
3407 m_ptr
= frame_find_by_id (m_cached_id
).get ();
3411 gdb_assert (m_ptr
!= nullptr);
3415 void _initialize_frame ();
3417 _initialize_frame ()
3419 obstack_init (&frame_cache_obstack
);
3421 frame_stash_create ();
3423 gdb::observers::target_changed
.attach (frame_observer_target_changed
,
3426 add_setshow_prefix_cmd ("backtrace", class_maintenance
,
3428 Set backtrace specific variables.\n\
3429 Configure backtrace variables such as the backtrace limit"),
3431 Show backtrace specific variables.\n\
3432 Show backtrace variables such as the backtrace limit."),
3433 &set_backtrace_cmdlist
, &show_backtrace_cmdlist
,
3434 &setlist
, &showlist
);
3436 add_setshow_uinteger_cmd ("limit", class_obscure
,
3437 &user_set_backtrace_options
.backtrace_limit
, _("\
3438 Set an upper bound on the number of backtrace levels."), _("\
3439 Show the upper bound on the number of backtrace levels."), _("\
3440 No more than the specified number of frames can be displayed or examined.\n\
3441 Literal \"unlimited\" or zero means no limit."),
3443 show_backtrace_limit
,
3444 &set_backtrace_cmdlist
,
3445 &show_backtrace_cmdlist
);
3447 gdb::option::add_setshow_cmds_for_options
3448 (class_stack
, &user_set_backtrace_options
,
3449 set_backtrace_option_defs
, &set_backtrace_cmdlist
, &show_backtrace_cmdlist
);
3451 /* Debug this files internals. */
3452 add_setshow_boolean_cmd ("frame", class_maintenance
, &frame_debug
, _("\
3453 Set frame debugging."), _("\
3454 Show frame debugging."), _("\
3455 When non-zero, frame specific internal debugging is enabled."),
3458 &setdebuglist
, &showdebuglist
);
3460 add_cmd ("frame-id", class_maintenance
, maintenance_print_frame_id
,
3461 _("Print the current frame-id."),
3462 &maintenanceprintlist
);