1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2021 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/>. */
24 #include "inferior.h" /* for inferior_ptid */
26 #include "user-regs.h"
27 #include "gdb_obstack.h"
28 #include "dummy-frame.h"
29 #include "sentinel-frame.h"
33 #include "frame-unwind.h"
34 #include "frame-base.h"
37 #include "observable.h"
39 #include "gdbthread.h"
41 #include "inline-frame.h"
42 #include "tracepoint.h"
45 #include "cli/cli-option.h"
47 /* The sentinel frame terminates the innermost end of the frame chain.
48 If unwound, it returns the information needed to construct an
51 The current frame, which is the innermost frame, can be found at
52 sentinel_frame->prev. */
54 static struct frame_info
*sentinel_frame
;
56 /* Number of calls to reinit_frame_cache. */
57 static unsigned int frame_cache_generation
= 0;
62 get_frame_cache_generation ()
64 return frame_cache_generation
;
67 /* The values behind the global "set backtrace ..." settings. */
68 set_backtrace_options user_set_backtrace_options
;
70 static struct frame_info
*get_prev_frame_raw (struct frame_info
*this_frame
);
71 static const char *frame_stop_reason_symbol_string (enum unwind_stop_reason reason
);
73 /* Status of some values cached in the frame_info object. */
75 enum cached_copy_status
77 /* Value is unknown. */
80 /* We have a value. */
83 /* Value was not saved. */
86 /* Value is unavailable. */
90 enum class frame_id_status
92 /* Frame id is not computed. */
95 /* Frame id is being computed (compute_frame_id is active). */
98 /* Frame id has been computed. */
102 /* We keep a cache of stack frames, each of which is a "struct
103 frame_info". The innermost one gets allocated (in
104 wait_for_inferior) each time the inferior stops; sentinel_frame
105 points to it. Additional frames get allocated (in get_prev_frame)
106 as needed, and are chained through the next and prev fields. Any
107 time that the frame cache becomes invalid (most notably when we
108 execute something, but also if we change how we interpret the
109 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
110 which reads new symbols)), we should call reinit_frame_cache. */
114 /* Level of this frame. The inner-most (youngest) frame is at level
115 0. As you move towards the outer-most (oldest) frame, the level
116 increases. This is a cached value. It could just as easily be
117 computed by counting back from the selected frame to the inner
119 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
120 reserved to indicate a bogus frame - one that has been created
121 just to keep GDB happy (GDB always needs a frame). For the
122 moment leave this as speculation. */
125 /* The frame's program space. */
126 struct program_space
*pspace
;
128 /* The frame's address space. */
129 const address_space
*aspace
;
131 /* The frame's low-level unwinder and corresponding cache. The
132 low-level unwinder is responsible for unwinding register values
133 for the previous frame. The low-level unwind methods are
134 selected based on the presence, or otherwise, of register unwind
135 information such as CFI. */
136 void *prologue_cache
;
137 const struct frame_unwind
*unwind
;
139 /* Cached copy of the previous frame's architecture. */
143 struct gdbarch
*arch
;
146 /* Cached copy of the previous frame's resume address. */
148 cached_copy_status status
;
149 /* Did VALUE require unmasking when being read. */
154 /* Cached copy of the previous frame's function address. */
158 cached_copy_status status
;
161 /* This frame's ID. */
165 struct frame_id value
;
168 /* The frame's high-level base methods, and corresponding cache.
169 The high level base methods are selected based on the frame's
171 const struct frame_base
*base
;
174 /* Pointers to the next (down, inner, younger) and previous (up,
175 outer, older) frame_info's in the frame cache. */
176 struct frame_info
*next
; /* down, inner, younger */
178 struct frame_info
*prev
; /* up, outer, older */
180 /* The reason why we could not set PREV, or UNWIND_NO_REASON if we
181 could. Only valid when PREV_P is set. */
182 enum unwind_stop_reason stop_reason
;
184 /* A frame specific string describing the STOP_REASON in more detail.
185 Only valid when PREV_P is set, but even then may still be NULL. */
186 const char *stop_string
;
192 set_frame_previous_pc_masked (struct frame_info
*frame
)
194 frame
->prev_pc
.masked
= true;
200 get_frame_pc_masked (const struct frame_info
*frame
)
202 gdb_assert (frame
->next
!= nullptr);
203 gdb_assert (frame
->next
->prev_pc
.status
== CC_VALUE
);
205 return frame
->next
->prev_pc
.masked
;
208 /* A frame stash used to speed up frame lookups. Create a hash table
209 to stash frames previously accessed from the frame cache for
210 quicker subsequent retrieval. The hash table is emptied whenever
211 the frame cache is invalidated. */
213 static htab_t frame_stash
;
215 /* Internal function to calculate a hash from the frame_id addresses,
216 using as many valid addresses as possible. Frames below level 0
217 are not stored in the hash table. */
220 frame_addr_hash (const void *ap
)
222 const struct frame_info
*frame
= (const struct frame_info
*) ap
;
223 const struct frame_id f_id
= frame
->this_id
.value
;
226 gdb_assert (f_id
.stack_status
!= FID_STACK_INVALID
228 || f_id
.special_addr_p
);
230 if (f_id
.stack_status
== FID_STACK_VALID
)
231 hash
= iterative_hash (&f_id
.stack_addr
,
232 sizeof (f_id
.stack_addr
), hash
);
233 if (f_id
.code_addr_p
)
234 hash
= iterative_hash (&f_id
.code_addr
,
235 sizeof (f_id
.code_addr
), hash
);
236 if (f_id
.special_addr_p
)
237 hash
= iterative_hash (&f_id
.special_addr
,
238 sizeof (f_id
.special_addr
), hash
);
243 /* Internal equality function for the hash table. This function
244 defers equality operations to frame_id_eq. */
247 frame_addr_hash_eq (const void *a
, const void *b
)
249 const struct frame_info
*f_entry
= (const struct frame_info
*) a
;
250 const struct frame_info
*f_element
= (const struct frame_info
*) b
;
252 return frame_id_eq (f_entry
->this_id
.value
,
253 f_element
->this_id
.value
);
256 /* Internal function to create the frame_stash hash table. 100 seems
257 to be a good compromise to start the hash table at. */
260 frame_stash_create (void)
262 frame_stash
= htab_create (100,
268 /* Internal function to add a frame to the frame_stash hash table.
269 Returns false if a frame with the same ID was already stashed, true
273 frame_stash_add (frame_info
*frame
)
275 /* Do not try to stash the sentinel frame. */
276 gdb_assert (frame
->level
>= 0);
278 frame_info
**slot
= (struct frame_info
**) htab_find_slot (frame_stash
,
281 /* If we already have a frame in the stack with the same id, we
282 either have a stack cycle (corrupted stack?), or some bug
283 elsewhere in GDB. In any case, ignore the duplicate and return
284 an indication to the caller. */
285 if (*slot
!= nullptr)
292 /* Internal function to search the frame stash for an entry with the
293 given frame ID. If found, return that frame. Otherwise return
296 static struct frame_info
*
297 frame_stash_find (struct frame_id id
)
299 struct frame_info dummy
;
300 struct frame_info
*frame
;
302 dummy
.this_id
.value
= id
;
303 frame
= (struct frame_info
*) htab_find (frame_stash
, &dummy
);
307 /* Internal function to invalidate the frame stash by removing all
308 entries in it. This only occurs when the frame cache is
312 frame_stash_invalidate (void)
314 htab_empty (frame_stash
);
318 scoped_restore_selected_frame::scoped_restore_selected_frame ()
320 m_lang
= current_language
->la_language
;
321 save_selected_frame (&m_fid
, &m_level
);
325 scoped_restore_selected_frame::~scoped_restore_selected_frame ()
327 restore_selected_frame (m_fid
, m_level
);
328 set_language (m_lang
);
331 /* Flag to control debugging. */
336 show_frame_debug (struct ui_file
*file
, int from_tty
,
337 struct cmd_list_element
*c
, const char *value
)
339 fprintf_filtered (file
, _("Frame debugging is %s.\n"), value
);
342 /* Implementation of "show backtrace past-main". */
345 show_backtrace_past_main (struct ui_file
*file
, int from_tty
,
346 struct cmd_list_element
*c
, const char *value
)
348 fprintf_filtered (file
,
349 _("Whether backtraces should "
350 "continue past \"main\" is %s.\n"),
354 /* Implementation of "show backtrace past-entry". */
357 show_backtrace_past_entry (struct ui_file
*file
, int from_tty
,
358 struct cmd_list_element
*c
, const char *value
)
360 fprintf_filtered (file
, _("Whether backtraces should continue past the "
361 "entry point of a program is %s.\n"),
365 /* Implementation of "show backtrace limit". */
368 show_backtrace_limit (struct ui_file
*file
, int from_tty
,
369 struct cmd_list_element
*c
, const char *value
)
371 fprintf_filtered (file
,
372 _("An upper bound on the number "
373 "of backtrace levels is %s.\n"),
380 frame_id::to_string () const
382 const struct frame_id
&id
= *this;
384 std::string res
= "{";
386 if (id
.stack_status
== FID_STACK_INVALID
)
388 else if (id
.stack_status
== FID_STACK_UNAVAILABLE
)
389 res
+= "stack=<unavailable>";
390 else if (id
.stack_status
== FID_STACK_SENTINEL
)
391 res
+= "stack=<sentinel>";
392 else if (id
.stack_status
== FID_STACK_OUTER
)
393 res
+= "stack=<outer>";
395 res
+= std::string ("stack=") + hex_string (id
.stack_addr
);
397 /* Helper function to format 'N=A' if P is true, otherwise '!N'. */
398 auto field_to_string
= [] (const char *n
, bool p
, CORE_ADDR a
) -> std::string
401 return std::string (n
) + "=" + core_addr_to_string (a
);
403 return std::string ("!") + std::string (n
);
406 res
+= (std::string (",")
407 + field_to_string ("code", id
.code_addr_p
, id
.code_addr
)
409 + field_to_string ("special", id
.special_addr_p
, id
.special_addr
));
411 if (id
.artificial_depth
)
412 res
+= ",artificial=" + std::to_string (id
.artificial_depth
);
418 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
423 fprintf_unfiltered (file
, "NORMAL_FRAME");
426 fprintf_unfiltered (file
, "DUMMY_FRAME");
429 fprintf_unfiltered (file
, "INLINE_FRAME");
432 fprintf_unfiltered (file
, "TAILCALL_FRAME");
435 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
438 fprintf_unfiltered (file
, "ARCH_FRAME");
441 fprintf_unfiltered (file
, "SENTINEL_FRAME");
444 fprintf_unfiltered (file
, "<unknown type>");
450 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
454 fprintf_unfiltered (file
, "<NULL frame>");
458 fprintf_unfiltered (file
, "{");
459 fprintf_unfiltered (file
, "level=%d", fi
->level
);
460 fprintf_unfiltered (file
, ",");
462 fprintf_unfiltered (file
, "type=");
463 if (fi
->unwind
!= NULL
)
464 fprint_frame_type (file
, fi
->unwind
->type
);
466 fprintf_unfiltered (file
, "<unknown>");
467 fprintf_unfiltered (file
, ",");
469 fprintf_unfiltered (file
, "unwind=");
470 if (fi
->unwind
!= NULL
)
471 gdb_print_host_address (fi
->unwind
, file
);
473 fprintf_unfiltered (file
, "<unknown>");
474 fprintf_unfiltered (file
, ",");
476 fprintf_unfiltered (file
, "pc=");
477 if (fi
->next
== NULL
|| fi
->next
->prev_pc
.status
== CC_UNKNOWN
)
478 fprintf_unfiltered (file
, "<unknown>");
479 else if (fi
->next
->prev_pc
.status
== CC_VALUE
)
481 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_pc
.value
));
482 if (fi
->next
->prev_pc
.masked
)
483 fprintf_unfiltered (file
, "[PAC]");
485 else if (fi
->next
->prev_pc
.status
== CC_NOT_SAVED
)
486 val_print_not_saved (file
);
487 else if (fi
->next
->prev_pc
.status
== CC_UNAVAILABLE
)
488 val_print_unavailable (file
);
489 fprintf_unfiltered (file
, ",");
491 fprintf_unfiltered (file
, "id=");
492 if (fi
->this_id
.p
== frame_id_status::NOT_COMPUTED
)
493 fprintf_unfiltered (file
, "<not computed>");
494 else if (fi
->this_id
.p
== frame_id_status::COMPUTING
)
495 fprintf_unfiltered (file
, "<computing>");
497 fprintf_unfiltered (file
, "%s", fi
->this_id
.value
.to_string ().c_str ());
498 fprintf_unfiltered (file
, ",");
500 fprintf_unfiltered (file
, "func=");
501 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.status
== CC_VALUE
)
502 fprintf_unfiltered (file
, "%s", hex_string (fi
->next
->prev_func
.addr
));
504 fprintf_unfiltered (file
, "<unknown>");
505 fprintf_unfiltered (file
, "}");
508 /* Given FRAME, return the enclosing frame as found in real frames read-in from
509 inferior memory. Skip any previous frames which were made up by GDB.
510 Return FRAME if FRAME is a non-artificial frame.
511 Return NULL if FRAME is the start of an artificial-only chain. */
513 static struct frame_info
*
514 skip_artificial_frames (struct frame_info
*frame
)
516 /* Note we use get_prev_frame_always, and not get_prev_frame. The
517 latter will truncate the frame chain, leading to this function
518 unintentionally returning a null_frame_id (e.g., when the user
519 sets a backtrace limit).
521 Note that for record targets we may get a frame chain that consists
522 of artificial frames only. */
523 while (get_frame_type (frame
) == INLINE_FRAME
524 || get_frame_type (frame
) == TAILCALL_FRAME
)
526 frame
= get_prev_frame_always (frame
);
535 skip_unwritable_frames (struct frame_info
*frame
)
537 while (gdbarch_code_of_frame_writable (get_frame_arch (frame
), frame
) == 0)
539 frame
= get_prev_frame (frame
);
550 skip_tailcall_frames (struct frame_info
*frame
)
552 while (get_frame_type (frame
) == TAILCALL_FRAME
)
554 /* Note that for record targets we may get a frame chain that consists of
555 tailcall frames only. */
556 frame
= get_prev_frame (frame
);
564 /* Compute the frame's uniq ID that can be used to, later, re-find the
568 compute_frame_id (struct frame_info
*fi
)
570 gdb_assert (fi
->this_id
.p
== frame_id_status::NOT_COMPUTED
);
572 unsigned int entry_generation
= get_frame_cache_generation ();
576 /* Mark this frame's id as "being computed. */
577 fi
->this_id
.p
= frame_id_status::COMPUTING
;
580 fprintf_unfiltered (gdb_stdlog
, "{ compute_frame_id (fi=%d) ",
583 /* Find the unwinder. */
584 if (fi
->unwind
== NULL
)
585 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
587 /* Find THIS frame's ID. */
588 /* Default to outermost if no ID is found. */
589 fi
->this_id
.value
= outer_frame_id
;
590 fi
->unwind
->this_id (fi
, &fi
->prologue_cache
, &fi
->this_id
.value
);
591 gdb_assert (frame_id_p (fi
->this_id
.value
));
593 /* Mark this frame's id as "computed". */
594 fi
->this_id
.p
= frame_id_status::COMPUTED
;
597 fprintf_unfiltered (gdb_stdlog
, "-> %s }\n",
598 fi
->this_id
.value
.to_string ().c_str ());
600 catch (const gdb_exception
&ex
)
602 /* On error, revert the frame id status to not computed. If the frame
603 cache generation changed, the frame object doesn't exist anymore, so
605 if (get_frame_cache_generation () == entry_generation
)
606 fi
->this_id
.p
= frame_id_status::NOT_COMPUTED
;
612 /* Return a frame uniq ID that can be used to, later, re-find the
616 get_frame_id (struct frame_info
*fi
)
619 return null_frame_id
;
621 /* It's always invalid to try to get a frame's id while it is being
623 gdb_assert (fi
->this_id
.p
!= frame_id_status::COMPUTING
);
625 if (fi
->this_id
.p
== frame_id_status::NOT_COMPUTED
)
627 /* If we haven't computed the frame id yet, then it must be that
628 this is the current frame. Compute it now, and stash the
629 result. The IDs of other frames are computed as soon as
630 they're created, in order to detect cycles. See
631 get_prev_frame_if_no_cycle. */
632 gdb_assert (fi
->level
== 0);
635 compute_frame_id (fi
);
637 /* Since this is the first frame in the chain, this should
639 bool stashed
= frame_stash_add (fi
);
640 gdb_assert (stashed
);
643 return fi
->this_id
.value
;
647 get_stack_frame_id (struct frame_info
*next_frame
)
649 return get_frame_id (skip_artificial_frames (next_frame
));
653 frame_unwind_caller_id (struct frame_info
*next_frame
)
655 struct frame_info
*this_frame
;
657 /* Use get_prev_frame_always, and not get_prev_frame. The latter
658 will truncate the frame chain, leading to this function
659 unintentionally returning a null_frame_id (e.g., when a caller
660 requests the frame ID of "main()"s caller. */
662 next_frame
= skip_artificial_frames (next_frame
);
663 if (next_frame
== NULL
)
664 return null_frame_id
;
666 this_frame
= get_prev_frame_always (next_frame
);
668 return get_frame_id (skip_artificial_frames (this_frame
));
670 return null_frame_id
;
673 const struct frame_id null_frame_id
= { 0 }; /* All zeros. */
674 const struct frame_id sentinel_frame_id
= { 0, 0, 0, FID_STACK_SENTINEL
, 0, 1, 0 };
675 const struct frame_id outer_frame_id
= { 0, 0, 0, FID_STACK_OUTER
, 0, 1, 0 };
678 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
679 CORE_ADDR special_addr
)
681 struct frame_id id
= null_frame_id
;
683 id
.stack_addr
= stack_addr
;
684 id
.stack_status
= FID_STACK_VALID
;
685 id
.code_addr
= code_addr
;
686 id
.code_addr_p
= true;
687 id
.special_addr
= special_addr
;
688 id
.special_addr_p
= true;
695 frame_id_build_unavailable_stack (CORE_ADDR code_addr
)
697 struct frame_id id
= null_frame_id
;
699 id
.stack_status
= FID_STACK_UNAVAILABLE
;
700 id
.code_addr
= code_addr
;
701 id
.code_addr_p
= true;
708 frame_id_build_unavailable_stack_special (CORE_ADDR code_addr
,
709 CORE_ADDR special_addr
)
711 struct frame_id id
= null_frame_id
;
713 id
.stack_status
= FID_STACK_UNAVAILABLE
;
714 id
.code_addr
= code_addr
;
715 id
.code_addr_p
= true;
716 id
.special_addr
= special_addr
;
717 id
.special_addr_p
= true;
722 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
724 struct frame_id id
= null_frame_id
;
726 id
.stack_addr
= stack_addr
;
727 id
.stack_status
= FID_STACK_VALID
;
728 id
.code_addr
= code_addr
;
729 id
.code_addr_p
= true;
734 frame_id_build_wild (CORE_ADDR stack_addr
)
736 struct frame_id id
= null_frame_id
;
738 id
.stack_addr
= stack_addr
;
739 id
.stack_status
= FID_STACK_VALID
;
744 frame_id_p (frame_id l
)
746 /* The frame is valid iff it has a valid stack address. */
747 bool p
= l
.stack_status
!= FID_STACK_INVALID
;
750 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=%s) -> %d }\n",
751 l
.to_string ().c_str (), p
);
757 frame_id_artificial_p (frame_id l
)
762 return l
.artificial_depth
!= 0;
766 frame_id_eq (frame_id l
, frame_id r
)
770 if (l
.stack_status
== FID_STACK_INVALID
771 || r
.stack_status
== FID_STACK_INVALID
)
772 /* Like a NaN, if either ID is invalid, the result is false.
773 Note that a frame ID is invalid iff it is the null frame ID. */
775 else if (l
.stack_status
!= r
.stack_status
|| l
.stack_addr
!= r
.stack_addr
)
776 /* If .stack addresses are different, the frames are different. */
778 else if (l
.code_addr_p
&& r
.code_addr_p
&& l
.code_addr
!= r
.code_addr
)
779 /* An invalid code addr is a wild card. If .code addresses are
780 different, the frames are different. */
782 else if (l
.special_addr_p
&& r
.special_addr_p
783 && l
.special_addr
!= r
.special_addr
)
784 /* An invalid special addr is a wild card (or unused). Otherwise
785 if special addresses are different, the frames are different. */
787 else if (l
.artificial_depth
!= r
.artificial_depth
)
788 /* If artificial depths are different, the frames must be different. */
791 /* Frames are equal. */
795 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=%s,r=%s) -> %d }\n",
796 l
.to_string ().c_str (), r
.to_string ().c_str (), eq
);
801 /* Safety net to check whether frame ID L should be inner to
802 frame ID R, according to their stack addresses.
804 This method cannot be used to compare arbitrary frames, as the
805 ranges of valid stack addresses may be discontiguous (e.g. due
808 However, it can be used as safety net to discover invalid frame
809 IDs in certain circumstances. Assuming that NEXT is the immediate
810 inner frame to THIS and that NEXT and THIS are both NORMAL frames:
812 * The stack address of NEXT must be inner-than-or-equal to the stack
815 Therefore, if frame_id_inner (THIS, NEXT) holds, some unwind
818 * If NEXT and THIS have different stack addresses, no other frame
819 in the frame chain may have a stack address in between.
821 Therefore, if frame_id_inner (TEST, THIS) holds, but
822 frame_id_inner (TEST, NEXT) does not hold, TEST cannot refer
823 to a valid frame in the frame chain.
825 The sanity checks above cannot be performed when a SIGTRAMP frame
826 is involved, because signal handlers might be executed on a different
827 stack than the stack used by the routine that caused the signal
828 to be raised. This can happen for instance when a thread exceeds
829 its maximum stack size. In this case, certain compilers implement
830 a stack overflow strategy that cause the handler to be run on a
834 frame_id_inner (struct gdbarch
*gdbarch
, struct frame_id l
, struct frame_id r
)
838 if (l
.stack_status
!= FID_STACK_VALID
|| r
.stack_status
!= FID_STACK_VALID
)
839 /* Like NaN, any operation involving an invalid ID always fails.
840 Likewise if either ID has an unavailable stack address. */
842 else if (l
.artificial_depth
> r
.artificial_depth
843 && l
.stack_addr
== r
.stack_addr
844 && l
.code_addr_p
== r
.code_addr_p
845 && l
.special_addr_p
== r
.special_addr_p
846 && l
.special_addr
== r
.special_addr
)
848 /* Same function, different inlined functions. */
849 const struct block
*lb
, *rb
;
851 gdb_assert (l
.code_addr_p
&& r
.code_addr_p
);
853 lb
= block_for_pc (l
.code_addr
);
854 rb
= block_for_pc (r
.code_addr
);
856 if (lb
== NULL
|| rb
== NULL
)
857 /* Something's gone wrong. */
860 /* This will return true if LB and RB are the same block, or
861 if the block with the smaller depth lexically encloses the
862 block with the greater depth. */
863 inner
= contained_in (lb
, rb
);
866 /* Only return non-zero when strictly inner than. Note that, per
867 comment in "frame.h", there is some fuzz here. Frameless
868 functions are not strictly inner than (same .stack but
869 different .code and/or .special address). */
870 inner
= gdbarch_inner_than (gdbarch
, l
.stack_addr
, r
.stack_addr
);
873 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=%s,r=%s) -> %d }\n",
874 l
.to_string ().c_str (), r
.to_string ().c_str (),
881 frame_find_by_id (struct frame_id id
)
883 struct frame_info
*frame
, *prev_frame
;
885 /* ZERO denotes the null frame, let the caller decide what to do
886 about it. Should it instead return get_current_frame()? */
887 if (!frame_id_p (id
))
890 /* Check for the sentinel frame. */
891 if (frame_id_eq (id
, sentinel_frame_id
))
892 return sentinel_frame
;
894 /* Try using the frame stash first. Finding it there removes the need
895 to perform the search by looping over all frames, which can be very
896 CPU-intensive if the number of frames is very high (the loop is O(n)
897 and get_prev_frame performs a series of checks that are relatively
898 expensive). This optimization is particularly useful when this function
899 is called from another function (such as value_fetch_lazy, case
900 VALUE_LVAL (val) == lval_register) which already loops over all frames,
901 making the overall behavior O(n^2). */
902 frame
= frame_stash_find (id
);
906 for (frame
= get_current_frame (); ; frame
= prev_frame
)
908 struct frame_id self
= get_frame_id (frame
);
910 if (frame_id_eq (id
, self
))
911 /* An exact match. */
914 prev_frame
= get_prev_frame (frame
);
918 /* As a safety net to avoid unnecessary backtracing while trying
919 to find an invalid ID, we check for a common situation where
920 we can detect from comparing stack addresses that no other
921 frame in the current frame chain can have this ID. See the
922 comment at frame_id_inner for details. */
923 if (get_frame_type (frame
) == NORMAL_FRAME
924 && !frame_id_inner (get_frame_arch (frame
), id
, self
)
925 && frame_id_inner (get_frame_arch (prev_frame
), id
,
926 get_frame_id (prev_frame
)))
933 frame_unwind_pc (struct frame_info
*this_frame
)
935 if (this_frame
->prev_pc
.status
== CC_UNKNOWN
)
937 struct gdbarch
*prev_gdbarch
;
941 /* The right way. The `pure' way. The one true way. This
942 method depends solely on the register-unwind code to
943 determine the value of registers in THIS frame, and hence
944 the value of this frame's PC (resume address). A typical
945 implementation is no more than:
947 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
948 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
950 Note: this method is very heavily dependent on a correct
951 register-unwind implementation, it pays to fix that
952 method first; this method is frame type agnostic, since
953 it only deals with register values, it works with any
954 frame. This is all in stark contrast to the old
955 FRAME_SAVED_PC which would try to directly handle all the
956 different ways that a PC could be unwound. */
957 prev_gdbarch
= frame_unwind_arch (this_frame
);
961 pc
= gdbarch_unwind_pc (prev_gdbarch
, this_frame
);
964 catch (const gdb_exception_error
&ex
)
966 if (ex
.error
== NOT_AVAILABLE_ERROR
)
968 this_frame
->prev_pc
.status
= CC_UNAVAILABLE
;
971 fprintf_unfiltered (gdb_stdlog
,
972 "{ frame_unwind_pc (this_frame=%d)"
973 " -> <unavailable> }\n",
976 else if (ex
.error
== OPTIMIZED_OUT_ERROR
)
978 this_frame
->prev_pc
.status
= CC_NOT_SAVED
;
981 fprintf_unfiltered (gdb_stdlog
,
982 "{ frame_unwind_pc (this_frame=%d)"
983 " -> <not saved> }\n",
992 this_frame
->prev_pc
.value
= pc
;
993 this_frame
->prev_pc
.status
= CC_VALUE
;
995 fprintf_unfiltered (gdb_stdlog
,
996 "{ frame_unwind_pc (this_frame=%d) "
999 hex_string (this_frame
->prev_pc
.value
));
1003 if (this_frame
->prev_pc
.status
== CC_VALUE
)
1004 return this_frame
->prev_pc
.value
;
1005 else if (this_frame
->prev_pc
.status
== CC_UNAVAILABLE
)
1006 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
1007 else if (this_frame
->prev_pc
.status
== CC_NOT_SAVED
)
1008 throw_error (OPTIMIZED_OUT_ERROR
, _("PC not saved"));
1010 internal_error (__FILE__
, __LINE__
,
1011 "unexpected prev_pc status: %d",
1012 (int) this_frame
->prev_pc
.status
);
1016 frame_unwind_caller_pc (struct frame_info
*this_frame
)
1018 this_frame
= skip_artificial_frames (this_frame
);
1020 /* We must have a non-artificial frame. The caller is supposed to check
1021 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
1023 gdb_assert (this_frame
!= NULL
);
1025 return frame_unwind_pc (this_frame
);
1029 get_frame_func_if_available (frame_info
*this_frame
, CORE_ADDR
*pc
)
1031 struct frame_info
*next_frame
= this_frame
->next
;
1033 if (next_frame
->prev_func
.status
== CC_UNKNOWN
)
1035 CORE_ADDR addr_in_block
;
1037 /* Make certain that this, and not the adjacent, function is
1039 if (!get_frame_address_in_block_if_available (this_frame
, &addr_in_block
))
1041 next_frame
->prev_func
.status
= CC_UNAVAILABLE
;
1043 fprintf_unfiltered (gdb_stdlog
,
1044 "{ get_frame_func (this_frame=%d)"
1045 " -> unavailable }\n",
1050 next_frame
->prev_func
.status
= CC_VALUE
;
1051 next_frame
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
1053 fprintf_unfiltered (gdb_stdlog
,
1054 "{ get_frame_func (this_frame=%d) -> %s }\n",
1056 hex_string (next_frame
->prev_func
.addr
));
1060 if (next_frame
->prev_func
.status
== CC_UNAVAILABLE
)
1067 gdb_assert (next_frame
->prev_func
.status
== CC_VALUE
);
1069 *pc
= next_frame
->prev_func
.addr
;
1075 get_frame_func (struct frame_info
*this_frame
)
1079 if (!get_frame_func_if_available (this_frame
, &pc
))
1080 throw_error (NOT_AVAILABLE_ERROR
, _("PC not available"));
1085 std::unique_ptr
<readonly_detached_regcache
>
1086 frame_save_as_regcache (struct frame_info
*this_frame
)
1088 auto cooked_read
= [this_frame
] (int regnum
, gdb_byte
*buf
)
1090 if (!deprecated_frame_register_read (this_frame
, regnum
, buf
))
1091 return REG_UNAVAILABLE
;
1096 std::unique_ptr
<readonly_detached_regcache
> regcache
1097 (new readonly_detached_regcache (get_frame_arch (this_frame
), cooked_read
));
1103 frame_pop (struct frame_info
*this_frame
)
1105 struct frame_info
*prev_frame
;
1107 if (get_frame_type (this_frame
) == DUMMY_FRAME
)
1109 /* Popping a dummy frame involves restoring more than just registers.
1110 dummy_frame_pop does all the work. */
1111 dummy_frame_pop (get_frame_id (this_frame
), inferior_thread ());
1115 /* Ensure that we have a frame to pop to. */
1116 prev_frame
= get_prev_frame_always (this_frame
);
1119 error (_("Cannot pop the initial frame."));
1121 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1122 entering THISFRAME. */
1123 prev_frame
= skip_tailcall_frames (prev_frame
);
1125 if (prev_frame
== NULL
)
1126 error (_("Cannot find the caller frame."));
1128 /* Make a copy of all the register values unwound from this frame.
1129 Save them in a scratch buffer so that there isn't a race between
1130 trying to extract the old values from the current regcache while
1131 at the same time writing new values into that same cache. */
1132 std::unique_ptr
<readonly_detached_regcache
> scratch
1133 = frame_save_as_regcache (prev_frame
);
1135 /* FIXME: cagney/2003-03-16: It should be possible to tell the
1136 target's register cache that it is about to be hit with a burst
1137 register transfer and that the sequence of register writes should
1138 be batched. The pair target_prepare_to_store() and
1139 target_store_registers() kind of suggest this functionality.
1140 Unfortunately, they don't implement it. Their lack of a formal
1141 definition can lead to targets writing back bogus values
1142 (arguably a bug in the target code mind). */
1143 /* Now copy those saved registers into the current regcache. */
1144 get_current_regcache ()->restore (scratch
.get ());
1146 /* We've made right mess of GDB's local state, just discard
1148 reinit_frame_cache ();
1152 frame_register_unwind (frame_info
*next_frame
, int regnum
,
1153 int *optimizedp
, int *unavailablep
,
1154 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
1155 int *realnump
, gdb_byte
*bufferp
)
1157 struct value
*value
;
1159 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1160 that the value proper does not need to be fetched. */
1161 gdb_assert (optimizedp
!= NULL
);
1162 gdb_assert (lvalp
!= NULL
);
1163 gdb_assert (addrp
!= NULL
);
1164 gdb_assert (realnump
!= NULL
);
1165 /* gdb_assert (bufferp != NULL); */
1167 value
= frame_unwind_register_value (next_frame
, regnum
);
1169 gdb_assert (value
!= NULL
);
1171 *optimizedp
= value_optimized_out (value
);
1172 *unavailablep
= !value_entirely_available (value
);
1173 *lvalp
= VALUE_LVAL (value
);
1174 *addrp
= value_address (value
);
1175 if (*lvalp
== lval_register
)
1176 *realnump
= VALUE_REGNUM (value
);
1182 if (!*optimizedp
&& !*unavailablep
)
1183 memcpy (bufferp
, value_contents_all (value
),
1184 TYPE_LENGTH (value_type (value
)));
1186 memset (bufferp
, 0, TYPE_LENGTH (value_type (value
)));
1189 /* Dispose of the new value. This prevents watchpoints from
1190 trying to watch the saved frame pointer. */
1191 release_value (value
);
1195 frame_register (struct frame_info
*frame
, int regnum
,
1196 int *optimizedp
, int *unavailablep
, enum lval_type
*lvalp
,
1197 CORE_ADDR
*addrp
, int *realnump
, gdb_byte
*bufferp
)
1199 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
1200 that the value proper does not need to be fetched. */
1201 gdb_assert (optimizedp
!= NULL
);
1202 gdb_assert (lvalp
!= NULL
);
1203 gdb_assert (addrp
!= NULL
);
1204 gdb_assert (realnump
!= NULL
);
1205 /* gdb_assert (bufferp != NULL); */
1207 /* Obtain the register value by unwinding the register from the next
1208 (more inner frame). */
1209 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
1210 frame_register_unwind (frame
->next
, regnum
, optimizedp
, unavailablep
,
1211 lvalp
, addrp
, realnump
, bufferp
);
1215 frame_unwind_register (frame_info
*next_frame
, int regnum
, gdb_byte
*buf
)
1221 enum lval_type lval
;
1223 frame_register_unwind (next_frame
, regnum
, &optimized
, &unavailable
,
1224 &lval
, &addr
, &realnum
, buf
);
1227 throw_error (OPTIMIZED_OUT_ERROR
,
1228 _("Register %d was not saved"), regnum
);
1230 throw_error (NOT_AVAILABLE_ERROR
,
1231 _("Register %d is not available"), regnum
);
1235 get_frame_register (struct frame_info
*frame
,
1236 int regnum
, gdb_byte
*buf
)
1238 frame_unwind_register (frame
->next
, regnum
, buf
);
1242 frame_unwind_register_value (frame_info
*next_frame
, int regnum
)
1244 struct gdbarch
*gdbarch
;
1245 struct value
*value
;
1247 gdb_assert (next_frame
!= NULL
);
1248 gdbarch
= frame_unwind_arch (next_frame
);
1252 fprintf_unfiltered (gdb_stdlog
,
1253 "{ frame_unwind_register_value "
1254 "(frame=%d,regnum=%d(%s),...) ",
1255 next_frame
->level
, regnum
,
1256 user_reg_map_regnum_to_name (gdbarch
, regnum
));
1259 /* Find the unwinder. */
1260 if (next_frame
->unwind
== NULL
)
1261 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
1263 /* Ask this frame to unwind its register. */
1264 value
= next_frame
->unwind
->prev_register (next_frame
,
1265 &next_frame
->prologue_cache
,
1270 fprintf_unfiltered (gdb_stdlog
, "->");
1271 if (value_optimized_out (value
))
1273 fprintf_unfiltered (gdb_stdlog
, " ");
1274 val_print_not_saved (gdb_stdlog
);
1278 if (VALUE_LVAL (value
) == lval_register
)
1279 fprintf_unfiltered (gdb_stdlog
, " register=%d",
1280 VALUE_REGNUM (value
));
1281 else if (VALUE_LVAL (value
) == lval_memory
)
1282 fprintf_unfiltered (gdb_stdlog
, " address=%s",
1284 value_address (value
)));
1286 fprintf_unfiltered (gdb_stdlog
, " computed");
1288 if (value_lazy (value
))
1289 fprintf_unfiltered (gdb_stdlog
, " lazy");
1293 const gdb_byte
*buf
= value_contents (value
);
1295 fprintf_unfiltered (gdb_stdlog
, " bytes=");
1296 fprintf_unfiltered (gdb_stdlog
, "[");
1297 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
1298 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1299 fprintf_unfiltered (gdb_stdlog
, "]");
1303 fprintf_unfiltered (gdb_stdlog
, " }\n");
1310 get_frame_register_value (struct frame_info
*frame
, int regnum
)
1312 return frame_unwind_register_value (frame
->next
, regnum
);
1316 frame_unwind_register_signed (frame_info
*next_frame
, int regnum
)
1318 struct gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1319 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1320 int size
= register_size (gdbarch
, regnum
);
1321 struct value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1323 gdb_assert (value
!= NULL
);
1325 if (value_optimized_out (value
))
1327 throw_error (OPTIMIZED_OUT_ERROR
,
1328 _("Register %d was not saved"), regnum
);
1330 if (!value_entirely_available (value
))
1332 throw_error (NOT_AVAILABLE_ERROR
,
1333 _("Register %d is not available"), regnum
);
1336 LONGEST r
= extract_signed_integer (value_contents_all (value
), size
,
1339 release_value (value
);
1344 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
1346 return frame_unwind_register_signed (frame
->next
, regnum
);
1350 frame_unwind_register_unsigned (frame_info
*next_frame
, int regnum
)
1352 struct gdbarch
*gdbarch
= frame_unwind_arch (next_frame
);
1353 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1354 int size
= register_size (gdbarch
, regnum
);
1355 struct value
*value
= frame_unwind_register_value (next_frame
, regnum
);
1357 gdb_assert (value
!= NULL
);
1359 if (value_optimized_out (value
))
1361 throw_error (OPTIMIZED_OUT_ERROR
,
1362 _("Register %d was not saved"), regnum
);
1364 if (!value_entirely_available (value
))
1366 throw_error (NOT_AVAILABLE_ERROR
,
1367 _("Register %d is not available"), regnum
);
1370 ULONGEST r
= extract_unsigned_integer (value_contents_all (value
), size
,
1373 release_value (value
);
1378 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
1380 return frame_unwind_register_unsigned (frame
->next
, regnum
);
1384 read_frame_register_unsigned (frame_info
*frame
, int regnum
,
1387 struct value
*regval
= get_frame_register_value (frame
, regnum
);
1389 if (!value_optimized_out (regval
)
1390 && value_entirely_available (regval
))
1392 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1393 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1394 int size
= register_size (gdbarch
, VALUE_REGNUM (regval
));
1396 *val
= extract_unsigned_integer (value_contents (regval
), size
, byte_order
);
1404 put_frame_register (struct frame_info
*frame
, int regnum
,
1405 const gdb_byte
*buf
)
1407 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1411 enum lval_type lval
;
1414 frame_register (frame
, regnum
, &optim
, &unavail
,
1415 &lval
, &addr
, &realnum
, NULL
);
1417 error (_("Attempt to assign to a register that was not saved."));
1422 write_memory (addr
, buf
, register_size (gdbarch
, regnum
));
1426 get_current_regcache ()->cooked_write (realnum
, buf
);
1429 error (_("Attempt to assign to an unmodifiable value."));
1433 /* This function is deprecated. Use get_frame_register_value instead,
1434 which provides more accurate information.
1436 Find and return the value of REGNUM for the specified stack frame.
1437 The number of bytes copied is REGISTER_SIZE (REGNUM).
1439 Returns 0 if the register value could not be found. */
1442 deprecated_frame_register_read (frame_info
*frame
, int regnum
,
1447 enum lval_type lval
;
1451 frame_register (frame
, regnum
, &optimized
, &unavailable
,
1452 &lval
, &addr
, &realnum
, myaddr
);
1454 return !optimized
&& !unavailable
;
1458 get_frame_register_bytes (frame_info
*frame
, int regnum
,
1460 gdb::array_view
<gdb_byte
> buffer
,
1461 int *optimizedp
, int *unavailablep
)
1463 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1468 /* Skip registers wholly inside of OFFSET. */
1469 while (offset
>= register_size (gdbarch
, regnum
))
1471 offset
-= register_size (gdbarch
, regnum
);
1475 /* Ensure that we will not read beyond the end of the register file.
1476 This can only ever happen if the debug information is bad. */
1478 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1479 for (i
= regnum
; i
< numregs
; i
++)
1481 int thissize
= register_size (gdbarch
, i
);
1484 break; /* This register is not available on this architecture. */
1485 maxsize
+= thissize
;
1488 int len
= buffer
.size ();
1490 error (_("Bad debug information detected: "
1491 "Attempt to read %d bytes from registers."), len
);
1493 /* Copy the data. */
1496 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1501 gdb_byte
*myaddr
= buffer
.data ();
1503 if (curr_len
== register_size (gdbarch
, regnum
))
1505 enum lval_type lval
;
1509 frame_register (frame
, regnum
, optimizedp
, unavailablep
,
1510 &lval
, &addr
, &realnum
, myaddr
);
1511 if (*optimizedp
|| *unavailablep
)
1516 struct value
*value
= frame_unwind_register_value (frame
->next
,
1518 gdb_assert (value
!= NULL
);
1519 *optimizedp
= value_optimized_out (value
);
1520 *unavailablep
= !value_entirely_available (value
);
1522 if (*optimizedp
|| *unavailablep
)
1524 release_value (value
);
1528 memcpy (myaddr
, value_contents_all (value
) + offset
, curr_len
);
1529 release_value (value
);
1545 put_frame_register_bytes (struct frame_info
*frame
, int regnum
,
1547 gdb::array_view
<const gdb_byte
> buffer
)
1549 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1551 /* Skip registers wholly inside of OFFSET. */
1552 while (offset
>= register_size (gdbarch
, regnum
))
1554 offset
-= register_size (gdbarch
, regnum
);
1558 int len
= buffer
.size ();
1559 /* Copy the data. */
1562 int curr_len
= register_size (gdbarch
, regnum
) - offset
;
1567 const gdb_byte
*myaddr
= buffer
.data ();
1568 if (curr_len
== register_size (gdbarch
, regnum
))
1570 put_frame_register (frame
, regnum
, myaddr
);
1574 struct value
*value
= frame_unwind_register_value (frame
->next
,
1576 gdb_assert (value
!= NULL
);
1578 memcpy ((char *) value_contents_writeable (value
) + offset
, myaddr
,
1580 put_frame_register (frame
, regnum
, value_contents_raw (value
));
1581 release_value (value
);
1591 /* Create a sentinel frame. */
1593 static struct frame_info
*
1594 create_sentinel_frame (struct program_space
*pspace
, struct regcache
*regcache
)
1596 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1599 frame
->pspace
= pspace
;
1600 frame
->aspace
= regcache
->aspace ();
1601 /* Explicitly initialize the sentinel frame's cache. Provide it
1602 with the underlying regcache. In the future additional
1603 information, such as the frame's thread will be added. */
1604 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
1605 /* For the moment there is only one sentinel frame implementation. */
1606 frame
->unwind
= &sentinel_frame_unwind
;
1607 /* Link this frame back to itself. The frame is self referential
1608 (the unwound PC is the same as the pc), so make it so. */
1609 frame
->next
= frame
;
1610 /* The sentinel frame has a special ID. */
1611 frame
->this_id
.p
= frame_id_status::COMPUTED
;
1612 frame
->this_id
.value
= sentinel_frame_id
;
1615 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
1616 fprint_frame (gdb_stdlog
, frame
);
1617 fprintf_unfiltered (gdb_stdlog
, " }\n");
1622 /* Cache for frame addresses already read by gdb. Valid only while
1623 inferior is stopped. Control variables for the frame cache should
1624 be local to this module. */
1626 static struct obstack frame_cache_obstack
;
1629 frame_obstack_zalloc (unsigned long size
)
1631 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
1633 memset (data
, 0, size
);
1637 static struct frame_info
*get_prev_frame_always_1 (struct frame_info
*this_frame
);
1640 get_current_frame (void)
1642 struct frame_info
*current_frame
;
1644 /* First check, and report, the lack of registers. Having GDB
1645 report "No stack!" or "No memory" when the target doesn't even
1646 have registers is very confusing. Besides, "printcmd.exp"
1647 explicitly checks that ``print $pc'' with no registers prints "No
1649 if (!target_has_registers ())
1650 error (_("No registers."));
1651 if (!target_has_stack ())
1652 error (_("No stack."));
1653 if (!target_has_memory ())
1654 error (_("No memory."));
1655 /* Traceframes are effectively a substitute for the live inferior. */
1656 if (get_traceframe_number () < 0)
1657 validate_registers_access ();
1659 if (sentinel_frame
== NULL
)
1661 create_sentinel_frame (current_program_space
, get_current_regcache ());
1663 /* Set the current frame before computing the frame id, to avoid
1664 recursion inside compute_frame_id, in case the frame's
1665 unwinder decides to do a symbol lookup (which depends on the
1666 selected frame's block).
1668 This call must always succeed. In particular, nothing inside
1669 get_prev_frame_always_1 should try to unwind from the
1670 sentinel frame, because that could fail/throw, and we always
1671 want to leave with the current frame created and linked in --
1672 we should never end up with the sentinel frame as outermost
1674 current_frame
= get_prev_frame_always_1 (sentinel_frame
);
1675 gdb_assert (current_frame
!= NULL
);
1677 return current_frame
;
1680 /* The "selected" stack frame is used by default for local and arg
1683 The "single source of truth" for the selected frame is the
1684 SELECTED_FRAME_ID / SELECTED_FRAME_LEVEL pair.
1686 Frame IDs can be saved/restored across reinitializing the frame
1687 cache, while frame_info pointers can't (frame_info objects are
1688 invalidated). If we know the corresponding frame_info object, it
1689 is cached in SELECTED_FRAME.
1691 If SELECTED_FRAME_ID / SELECTED_FRAME_LEVEL are null_frame_id / -1,
1692 and the target has stack and is stopped, the selected frame is the
1693 current (innermost) frame. This means that SELECTED_FRAME_LEVEL is
1694 never 0 and SELECTED_FRAME_ID is never the ID of the innermost
1697 If SELECTED_FRAME_ID / SELECTED_FRAME_LEVEL are null_frame_id / -1,
1698 and the target has no stack or is executing, then there's no
1700 static frame_id selected_frame_id
= null_frame_id
;
1701 static int selected_frame_level
= -1;
1703 /* The cached frame_info object pointing to the selected frame.
1704 Looked up on demand by get_selected_frame. */
1705 static struct frame_info
*selected_frame
;
1710 save_selected_frame (frame_id
*frame_id
, int *frame_level
)
1713 *frame_id
= selected_frame_id
;
1714 *frame_level
= selected_frame_level
;
1720 restore_selected_frame (frame_id frame_id
, int frame_level
)
1723 /* save_selected_frame never returns level == 0, so we shouldn't see
1725 gdb_assert (frame_level
!= 0);
1727 /* FRAME_ID can be null_frame_id only IFF frame_level is -1. */
1728 gdb_assert ((frame_level
== -1 && !frame_id_p (frame_id
))
1729 || (frame_level
!= -1 && frame_id_p (frame_id
)));
1731 selected_frame_id
= frame_id
;
1732 selected_frame_level
= frame_level
;
1734 /* Will be looked up later by get_selected_frame. */
1735 selected_frame
= nullptr;
1741 lookup_selected_frame (struct frame_id a_frame_id
, int frame_level
)
1743 struct frame_info
*frame
= NULL
;
1746 /* This either means there was no selected frame, or the selected
1747 frame was the current frame. In either case, select the current
1749 if (frame_level
== -1)
1751 select_frame (get_current_frame ());
1755 /* select_frame never saves 0 in SELECTED_FRAME_LEVEL, so we
1756 shouldn't see it here. */
1757 gdb_assert (frame_level
> 0);
1759 /* Restore by level first, check if the frame id is the same as
1760 expected. If that fails, try restoring by frame id. If that
1761 fails, nothing to do, just warn the user. */
1763 count
= frame_level
;
1764 frame
= find_relative_frame (get_current_frame (), &count
);
1767 /* The frame ids must match - either both valid or both
1768 outer_frame_id. The latter case is not failsafe, but since
1769 it's highly unlikely the search by level finds the wrong
1770 frame, it's 99.9(9)% of the time (for all practical purposes)
1772 && frame_id_eq (get_frame_id (frame
), a_frame_id
))
1774 /* Cool, all is fine. */
1775 select_frame (frame
);
1779 frame
= frame_find_by_id (a_frame_id
);
1782 /* Cool, refound it. */
1783 select_frame (frame
);
1787 /* Nothing else to do, the frame layout really changed. Select the
1788 innermost stack frame. */
1789 select_frame (get_current_frame ());
1791 /* Warn the user. */
1792 if (frame_level
> 0 && !current_uiout
->is_mi_like_p ())
1794 warning (_("Couldn't restore frame #%d in "
1795 "current thread. Bottom (innermost) frame selected:"),
1797 /* For MI, we should probably have a notification about current
1798 frame change. But this error is not very likely, so don't
1800 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
1807 if (!target_has_registers () || !target_has_stack ()
1808 || !target_has_memory ())
1811 /* Traceframes are effectively a substitute for the live inferior. */
1812 if (get_traceframe_number () < 0)
1814 /* No current inferior, no frame. */
1815 if (inferior_ptid
== null_ptid
)
1818 thread_info
*tp
= inferior_thread ();
1819 /* Don't try to read from a dead thread. */
1820 if (tp
->state
== THREAD_EXITED
)
1823 /* ... or from a spinning thread. */
1834 get_selected_frame (const char *message
)
1836 if (selected_frame
== NULL
)
1838 if (message
!= NULL
&& !has_stack_frames ())
1839 error (("%s"), message
);
1841 lookup_selected_frame (selected_frame_id
, selected_frame_level
);
1843 /* There is always a frame. */
1844 gdb_assert (selected_frame
!= NULL
);
1845 return selected_frame
;
1848 /* This is a variant of get_selected_frame() which can be called when
1849 the inferior does not have a frame; in that case it will return
1850 NULL instead of calling error(). */
1853 deprecated_safe_get_selected_frame (void)
1855 if (!has_stack_frames ())
1857 return get_selected_frame (NULL
);
1860 /* Select frame FI (or NULL - to invalidate the selected frame). */
1863 select_frame (struct frame_info
*fi
)
1865 selected_frame
= fi
;
1866 selected_frame_level
= frame_relative_level (fi
);
1867 if (selected_frame_level
== 0)
1869 /* Treat the current frame especially -- we want to always
1870 save/restore it without warning, even if the frame ID changes
1871 (see lookup_selected_frame). E.g.:
1873 // The current frame is selected, the target had just stopped.
1875 scoped_restore_selected_frame restore_frame;
1876 some_operation_that_changes_the_stack ();
1878 // scoped_restore_selected_frame's dtor runs, but the
1879 // original frame_id can't be found. No matter whether it
1880 // is found or not, we still end up with the now-current
1881 // frame selected. Warning in lookup_selected_frame in this
1882 // case seems pointless.
1884 Also get_frame_id may access the target's registers/memory,
1885 and thus skipping get_frame_id optimizes the common case.
1887 Saving the selected frame this way makes get_selected_frame
1888 and restore_current_frame return/re-select whatever frame is
1889 the innermost (current) then. */
1890 selected_frame_level
= -1;
1891 selected_frame_id
= null_frame_id
;
1894 selected_frame_id
= get_frame_id (fi
);
1896 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
1897 frame is being invalidated. */
1899 /* FIXME: kseitz/2002-08-28: It would be nice to call
1900 selected_frame_level_changed_event() right here, but due to limitations
1901 in the current interfaces, we would end up flooding UIs with events
1902 because select_frame() is used extensively internally.
1904 Once we have frame-parameterized frame (and frame-related) commands,
1905 the event notification can be moved here, since this function will only
1906 be called when the user's selected frame is being changed. */
1908 /* Ensure that symbols for this frame are read in. Also, determine the
1909 source language of this frame, and switch to it if desired. */
1914 /* We retrieve the frame's symtab by using the frame PC.
1915 However we cannot use the frame PC as-is, because it usually
1916 points to the instruction following the "call", which is
1917 sometimes the first instruction of another function. So we
1918 rely on get_frame_address_in_block() which provides us with a
1919 PC which is guaranteed to be inside the frame's code
1921 if (get_frame_address_in_block_if_available (fi
, &pc
))
1923 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
1926 && compunit_language (cust
) != current_language
->la_language
1927 && compunit_language (cust
) != language_unknown
1928 && language_mode
== language_mode_auto
)
1929 set_language (compunit_language (cust
));
1934 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1935 Always returns a non-NULL value. */
1938 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1940 struct frame_info
*fi
;
1944 fprintf_unfiltered (gdb_stdlog
,
1945 "{ create_new_frame (addr=%s, pc=%s) ",
1946 hex_string (addr
), hex_string (pc
));
1949 fi
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1951 fi
->next
= create_sentinel_frame (current_program_space
,
1952 get_current_regcache ());
1954 /* Set/update this frame's cached PC value, found in the next frame.
1955 Do this before looking for this frame's unwinder. A sniffer is
1956 very likely to read this, and the corresponding unwinder is
1957 entitled to rely that the PC doesn't magically change. */
1958 fi
->next
->prev_pc
.value
= pc
;
1959 fi
->next
->prev_pc
.status
= CC_VALUE
;
1961 /* We currently assume that frame chain's can't cross spaces. */
1962 fi
->pspace
= fi
->next
->pspace
;
1963 fi
->aspace
= fi
->next
->aspace
;
1965 /* Select/initialize both the unwind function and the frame's type
1967 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
1969 fi
->this_id
.p
= frame_id_status::COMPUTED
;
1970 fi
->this_id
.value
= frame_id_build (addr
, pc
);
1974 fprintf_unfiltered (gdb_stdlog
, "-> ");
1975 fprint_frame (gdb_stdlog
, fi
);
1976 fprintf_unfiltered (gdb_stdlog
, " }\n");
1982 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1983 innermost frame). Be careful to not fall off the bottom of the
1984 frame chain and onto the sentinel frame. */
1987 get_next_frame (struct frame_info
*this_frame
)
1989 if (this_frame
->level
> 0)
1990 return this_frame
->next
;
1995 /* Return the frame that THIS_FRAME calls. If THIS_FRAME is the
1996 innermost (i.e. current) frame, return the sentinel frame. Thus,
1997 unlike get_next_frame(), NULL will never be returned. */
2000 get_next_frame_sentinel_okay (struct frame_info
*this_frame
)
2002 gdb_assert (this_frame
!= NULL
);
2004 /* Note that, due to the manner in which the sentinel frame is
2005 constructed, this_frame->next still works even when this_frame
2006 is the sentinel frame. But we disallow it here anyway because
2007 calling get_next_frame_sentinel_okay() on the sentinel frame
2008 is likely a coding error. */
2009 gdb_assert (this_frame
!= sentinel_frame
);
2011 return this_frame
->next
;
2014 /* Observer for the target_changed event. */
2017 frame_observer_target_changed (struct target_ops
*target
)
2019 reinit_frame_cache ();
2022 /* Flush the entire frame cache. */
2025 reinit_frame_cache (void)
2027 struct frame_info
*fi
;
2029 ++frame_cache_generation
;
2031 /* Tear down all frame caches. */
2032 for (fi
= sentinel_frame
; fi
!= NULL
; fi
= fi
->prev
)
2034 if (fi
->prologue_cache
&& fi
->unwind
->dealloc_cache
)
2035 fi
->unwind
->dealloc_cache (fi
, fi
->prologue_cache
);
2036 if (fi
->base_cache
&& fi
->base
->unwind
->dealloc_cache
)
2037 fi
->base
->unwind
->dealloc_cache (fi
, fi
->base_cache
);
2040 /* Since we can't really be sure what the first object allocated was. */
2041 obstack_free (&frame_cache_obstack
, 0);
2042 obstack_init (&frame_cache_obstack
);
2044 if (sentinel_frame
!= NULL
)
2045 annotate_frames_invalid ();
2047 sentinel_frame
= NULL
; /* Invalidate cache */
2048 select_frame (NULL
);
2049 frame_stash_invalidate ();
2051 fprintf_unfiltered (gdb_stdlog
, "{ reinit_frame_cache () }\n");
2054 /* Find where a register is saved (in memory or another register).
2055 The result of frame_register_unwind is just where it is saved
2056 relative to this particular frame. */
2059 frame_register_unwind_location (struct frame_info
*this_frame
, int regnum
,
2060 int *optimizedp
, enum lval_type
*lvalp
,
2061 CORE_ADDR
*addrp
, int *realnump
)
2063 gdb_assert (this_frame
== NULL
|| this_frame
->level
>= 0);
2065 while (this_frame
!= NULL
)
2069 frame_register_unwind (this_frame
, regnum
, optimizedp
, &unavailable
,
2070 lvalp
, addrp
, realnump
, NULL
);
2075 if (*lvalp
!= lval_register
)
2079 this_frame
= get_next_frame (this_frame
);
2083 /* Get the previous raw frame, and check that it is not identical to
2084 same other frame frame already in the chain. If it is, there is
2085 most likely a stack cycle, so we discard it, and mark THIS_FRAME as
2086 outermost, with UNWIND_SAME_ID stop reason. Unlike the other
2087 validity tests, that compare THIS_FRAME and the next frame, we do
2088 this right after creating the previous frame, to avoid ever ending
2089 up with two frames with the same id in the frame chain. */
2091 static struct frame_info
*
2092 get_prev_frame_if_no_cycle (struct frame_info
*this_frame
)
2094 struct frame_info
*prev_frame
;
2096 prev_frame
= get_prev_frame_raw (this_frame
);
2098 /* Don't compute the frame id of the current frame yet. Unwinding
2099 the sentinel frame can fail (e.g., if the thread is gone and we
2100 can't thus read its registers). If we let the cycle detection
2101 code below try to compute a frame ID, then an error thrown from
2102 within the frame ID computation would result in the sentinel
2103 frame as outermost frame, which is bogus. Instead, we'll compute
2104 the current frame's ID lazily in get_frame_id. Note that there's
2105 no point in doing cycle detection when there's only one frame, so
2106 nothing is lost here. */
2107 if (prev_frame
->level
== 0)
2110 unsigned int entry_generation
= get_frame_cache_generation ();
2114 compute_frame_id (prev_frame
);
2115 if (!frame_stash_add (prev_frame
))
2117 /* Another frame with the same id was already in the stash. We just
2118 detected a cycle. */
2121 fprintf_unfiltered (gdb_stdlog
, "-> ");
2122 fprint_frame (gdb_stdlog
, NULL
);
2123 fprintf_unfiltered (gdb_stdlog
, " // this frame has same ID }\n");
2125 this_frame
->stop_reason
= UNWIND_SAME_ID
;
2127 prev_frame
->next
= NULL
;
2128 this_frame
->prev
= NULL
;
2132 catch (const gdb_exception
&ex
)
2134 if (get_frame_cache_generation () == entry_generation
)
2136 prev_frame
->next
= NULL
;
2137 this_frame
->prev
= NULL
;
2146 /* Helper function for get_prev_frame_always, this is called inside a
2147 TRY_CATCH block. Return the frame that called THIS_FRAME or NULL if
2148 there is no such frame. This may throw an exception. */
2150 static struct frame_info
*
2151 get_prev_frame_always_1 (struct frame_info
*this_frame
)
2153 struct gdbarch
*gdbarch
;
2155 gdb_assert (this_frame
!= NULL
);
2156 gdbarch
= get_frame_arch (this_frame
);
2160 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_always (this_frame=");
2161 if (this_frame
!= NULL
)
2162 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
2164 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
2165 fprintf_unfiltered (gdb_stdlog
, ") ");
2168 /* Only try to do the unwind once. */
2169 if (this_frame
->prev_p
)
2173 fprintf_unfiltered (gdb_stdlog
, "-> ");
2174 fprint_frame (gdb_stdlog
, this_frame
->prev
);
2175 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
2177 return this_frame
->prev
;
2180 /* If the frame unwinder hasn't been selected yet, we must do so
2181 before setting prev_p; otherwise the check for misbehaved
2182 sniffers will think that this frame's sniffer tried to unwind
2183 further (see frame_cleanup_after_sniffer). */
2184 if (this_frame
->unwind
== NULL
)
2185 frame_unwind_find_by_frame (this_frame
, &this_frame
->prologue_cache
);
2187 this_frame
->prev_p
= true;
2188 this_frame
->stop_reason
= UNWIND_NO_REASON
;
2190 /* If we are unwinding from an inline frame, all of the below tests
2191 were already performed when we unwound from the next non-inline
2192 frame. We must skip them, since we can not get THIS_FRAME's ID
2193 until we have unwound all the way down to the previous non-inline
2195 if (get_frame_type (this_frame
) == INLINE_FRAME
)
2196 return get_prev_frame_if_no_cycle (this_frame
);
2198 /* If this_frame is the current frame, then compute and stash its
2199 frame id prior to fetching and computing the frame id of the
2200 previous frame. Otherwise, the cycle detection code in
2201 get_prev_frame_if_no_cycle() will not work correctly. When
2202 get_frame_id() is called later on, an assertion error will be
2203 triggered in the event of a cycle between the current frame and
2206 Note we do this after the INLINE_FRAME check above. That is
2207 because the inline frame's frame id computation needs to fetch
2208 the frame id of its previous real stack frame. I.e., we need to
2209 avoid recursion in that case. This is OK since we're sure the
2210 inline frame won't create a cycle with the real stack frame. See
2211 inline_frame_this_id. */
2212 if (this_frame
->level
== 0)
2213 get_frame_id (this_frame
);
2215 /* Check that this frame is unwindable. If it isn't, don't try to
2216 unwind to the prev frame. */
2217 this_frame
->stop_reason
2218 = this_frame
->unwind
->stop_reason (this_frame
,
2219 &this_frame
->prologue_cache
);
2221 if (this_frame
->stop_reason
!= UNWIND_NO_REASON
)
2225 enum unwind_stop_reason reason
= this_frame
->stop_reason
;
2227 fprintf_unfiltered (gdb_stdlog
, "-> ");
2228 fprint_frame (gdb_stdlog
, NULL
);
2229 fprintf_unfiltered (gdb_stdlog
, " // %s }\n",
2230 frame_stop_reason_symbol_string (reason
));
2235 /* Check that this frame's ID isn't inner to (younger, below, next)
2236 the next frame. This happens when a frame unwind goes backwards.
2237 This check is valid only if this frame and the next frame are NORMAL.
2238 See the comment at frame_id_inner for details. */
2239 if (get_frame_type (this_frame
) == NORMAL_FRAME
2240 && this_frame
->next
->unwind
->type
== NORMAL_FRAME
2241 && frame_id_inner (get_frame_arch (this_frame
->next
),
2242 get_frame_id (this_frame
),
2243 get_frame_id (this_frame
->next
)))
2245 CORE_ADDR this_pc_in_block
;
2246 struct minimal_symbol
*morestack_msym
;
2247 const char *morestack_name
= NULL
;
2249 /* gcc -fsplit-stack __morestack can continue the stack anywhere. */
2250 this_pc_in_block
= get_frame_address_in_block (this_frame
);
2251 morestack_msym
= lookup_minimal_symbol_by_pc (this_pc_in_block
).minsym
;
2253 morestack_name
= morestack_msym
->linkage_name ();
2254 if (!morestack_name
|| strcmp (morestack_name
, "__morestack") != 0)
2258 fprintf_unfiltered (gdb_stdlog
, "-> ");
2259 fprint_frame (gdb_stdlog
, NULL
);
2260 fprintf_unfiltered (gdb_stdlog
,
2261 " // this frame ID is inner }\n");
2263 this_frame
->stop_reason
= UNWIND_INNER_ID
;
2268 /* Check that this and the next frame do not unwind the PC register
2269 to the same memory location. If they do, then even though they
2270 have different frame IDs, the new frame will be bogus; two
2271 functions can't share a register save slot for the PC. This can
2272 happen when the prologue analyzer finds a stack adjustment, but
2275 This check does assume that the "PC register" is roughly a
2276 traditional PC, even if the gdbarch_unwind_pc method adjusts
2277 it (we do not rely on the value, only on the unwound PC being
2278 dependent on this value). A potential improvement would be
2279 to have the frame prev_pc method and the gdbarch unwind_pc
2280 method set the same lval and location information as
2281 frame_register_unwind. */
2282 if (this_frame
->level
> 0
2283 && gdbarch_pc_regnum (gdbarch
) >= 0
2284 && get_frame_type (this_frame
) == NORMAL_FRAME
2285 && (get_frame_type (this_frame
->next
) == NORMAL_FRAME
2286 || get_frame_type (this_frame
->next
) == INLINE_FRAME
))
2288 int optimized
, realnum
, nrealnum
;
2289 enum lval_type lval
, nlval
;
2290 CORE_ADDR addr
, naddr
;
2292 frame_register_unwind_location (this_frame
,
2293 gdbarch_pc_regnum (gdbarch
),
2294 &optimized
, &lval
, &addr
, &realnum
);
2295 frame_register_unwind_location (get_next_frame (this_frame
),
2296 gdbarch_pc_regnum (gdbarch
),
2297 &optimized
, &nlval
, &naddr
, &nrealnum
);
2299 if ((lval
== lval_memory
&& lval
== nlval
&& addr
== naddr
)
2300 || (lval
== lval_register
&& lval
== nlval
&& realnum
== nrealnum
))
2304 fprintf_unfiltered (gdb_stdlog
, "-> ");
2305 fprint_frame (gdb_stdlog
, NULL
);
2306 fprintf_unfiltered (gdb_stdlog
, " // no saved PC }\n");
2309 this_frame
->stop_reason
= UNWIND_NO_SAVED_PC
;
2310 this_frame
->prev
= NULL
;
2315 return get_prev_frame_if_no_cycle (this_frame
);
2318 /* Return a "struct frame_info" corresponding to the frame that called
2319 THIS_FRAME. Returns NULL if there is no such frame.
2321 Unlike get_prev_frame, this function always tries to unwind the
2325 get_prev_frame_always (struct frame_info
*this_frame
)
2327 struct frame_info
*prev_frame
= NULL
;
2331 prev_frame
= get_prev_frame_always_1 (this_frame
);
2333 catch (const gdb_exception_error
&ex
)
2335 if (ex
.error
== MEMORY_ERROR
)
2337 this_frame
->stop_reason
= UNWIND_MEMORY_ERROR
;
2338 if (ex
.message
!= NULL
)
2343 /* The error needs to live as long as the frame does.
2344 Allocate using stack local STOP_STRING then assign the
2345 pointer to the frame, this allows the STOP_STRING on the
2346 frame to be of type 'const char *'. */
2347 size
= ex
.message
->size () + 1;
2348 stop_string
= (char *) frame_obstack_zalloc (size
);
2349 memcpy (stop_string
, ex
.what (), size
);
2350 this_frame
->stop_string
= stop_string
;
2361 /* Construct a new "struct frame_info" and link it previous to
2364 static struct frame_info
*
2365 get_prev_frame_raw (struct frame_info
*this_frame
)
2367 struct frame_info
*prev_frame
;
2369 /* Allocate the new frame but do not wire it in to the frame chain.
2370 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
2371 frame->next to pull some fancy tricks (of course such code is, by
2372 definition, recursive). Try to prevent it.
2374 There is no reason to worry about memory leaks, should the
2375 remainder of the function fail. The allocated memory will be
2376 quickly reclaimed when the frame cache is flushed, and the `we've
2377 been here before' check above will stop repeated memory
2378 allocation calls. */
2379 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2380 prev_frame
->level
= this_frame
->level
+ 1;
2382 /* For now, assume we don't have frame chains crossing address
2384 prev_frame
->pspace
= this_frame
->pspace
;
2385 prev_frame
->aspace
= this_frame
->aspace
;
2387 /* Don't yet compute ->unwind (and hence ->type). It is computed
2388 on-demand in get_frame_type, frame_register_unwind, and
2391 /* Don't yet compute the frame's ID. It is computed on-demand by
2394 /* The unwound frame ID is validate at the start of this function,
2395 as part of the logic to decide if that frame should be further
2396 unwound, and not here while the prev frame is being created.
2397 Doing this makes it possible for the user to examine a frame that
2398 has an invalid frame ID.
2400 Some very old VAX code noted: [...] For the sake of argument,
2401 suppose that the stack is somewhat trashed (which is one reason
2402 that "info frame" exists). So, return 0 (indicating we don't
2403 know the address of the arglist) if we don't know what frame this
2407 this_frame
->prev
= prev_frame
;
2408 prev_frame
->next
= this_frame
;
2412 fprintf_unfiltered (gdb_stdlog
, "-> ");
2413 fprint_frame (gdb_stdlog
, prev_frame
);
2414 fprintf_unfiltered (gdb_stdlog
, " }\n");
2420 /* Debug routine to print a NULL frame being returned. */
2423 frame_debug_got_null_frame (struct frame_info
*this_frame
,
2428 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
2429 if (this_frame
!= NULL
)
2430 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
2432 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
2433 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
2437 /* Is this (non-sentinel) frame in the "main"() function? */
2440 inside_main_func (frame_info
*this_frame
)
2442 if (current_program_space
->symfile_object_file
== nullptr)
2446 const char *name
= main_name ();
2447 bound_minimal_symbol msymbol
2448 = lookup_minimal_symbol (name
, NULL
,
2449 current_program_space
->symfile_object_file
);
2450 if (msymbol
.minsym
== nullptr)
2452 /* In some language (for example Fortran) there will be no minimal
2453 symbol with the name of the main function. In this case we should
2454 search the full symbols to see if we can find a match. */
2455 struct block_symbol bs
= lookup_symbol (name
, NULL
, VAR_DOMAIN
, 0);
2456 if (bs
.symbol
== nullptr)
2459 const struct block
*block
= SYMBOL_BLOCK_VALUE (bs
.symbol
);
2460 gdb_assert (block
!= nullptr);
2461 sym_addr
= BLOCK_START (block
);
2464 sym_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
2466 /* Convert any function descriptor addresses into the actual function
2468 sym_addr
= gdbarch_convert_from_func_ptr_addr
2469 (get_frame_arch (this_frame
), sym_addr
, current_inferior ()->top_target ());
2471 return sym_addr
== get_frame_func (this_frame
);
2474 /* Test whether THIS_FRAME is inside the process entry point function. */
2477 inside_entry_func (frame_info
*this_frame
)
2479 CORE_ADDR entry_point
;
2481 if (!entry_point_address_query (&entry_point
))
2484 return get_frame_func (this_frame
) == entry_point
;
2487 /* Return a structure containing various interesting information about
2488 the frame that called THIS_FRAME. Returns NULL if there is entier
2489 no such frame or the frame fails any of a set of target-independent
2490 condition that should terminate the frame chain (e.g., as unwinding
2493 This function should not contain target-dependent tests, such as
2494 checking whether the program-counter is zero. */
2497 get_prev_frame (struct frame_info
*this_frame
)
2502 /* There is always a frame. If this assertion fails, suspect that
2503 something should be calling get_selected_frame() or
2504 get_current_frame(). */
2505 gdb_assert (this_frame
!= NULL
);
2507 frame_pc_p
= get_frame_pc_if_available (this_frame
, &frame_pc
);
2509 /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much
2510 sense to stop unwinding at a dummy frame. One place where a dummy
2511 frame may have an address "inside_main_func" is on HPUX. On HPUX, the
2512 pcsqh register (space register for the instruction at the head of the
2513 instruction queue) cannot be written directly; the only way to set it
2514 is to branch to code that is in the target space. In order to implement
2515 frame dummies on HPUX, the called function is made to jump back to where
2516 the inferior was when the user function was called. If gdb was inside
2517 the main function when we created the dummy frame, the dummy frame will
2518 point inside the main function. */
2519 if (this_frame
->level
>= 0
2520 && get_frame_type (this_frame
) == NORMAL_FRAME
2521 && !user_set_backtrace_options
.backtrace_past_main
2523 && inside_main_func (this_frame
))
2524 /* Don't unwind past main(). Note, this is done _before_ the
2525 frame has been marked as previously unwound. That way if the
2526 user later decides to enable unwinds past main(), that will
2527 automatically happen. */
2529 frame_debug_got_null_frame (this_frame
, "inside main func");
2533 /* If the user's backtrace limit has been exceeded, stop. We must
2534 add two to the current level; one of those accounts for backtrace_limit
2535 being 1-based and the level being 0-based, and the other accounts for
2536 the level of the new frame instead of the level of the current
2538 if (this_frame
->level
+ 2 > user_set_backtrace_options
.backtrace_limit
)
2540 frame_debug_got_null_frame (this_frame
, "backtrace limit exceeded");
2544 /* If we're already inside the entry function for the main objfile,
2545 then it isn't valid. Don't apply this test to a dummy frame -
2546 dummy frame PCs typically land in the entry func. Don't apply
2547 this test to the sentinel frame. Sentinel frames should always
2548 be allowed to unwind. */
2549 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
2550 wasn't checking for "main" in the minimal symbols. With that
2551 fixed asm-source tests now stop in "main" instead of halting the
2552 backtrace in weird and wonderful ways somewhere inside the entry
2553 file. Suspect that tests for inside the entry file/func were
2554 added to work around that (now fixed) case. */
2555 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
2556 suggested having the inside_entry_func test use the
2557 inside_main_func() msymbol trick (along with entry_point_address()
2558 I guess) to determine the address range of the start function.
2559 That should provide a far better stopper than the current
2561 /* NOTE: tausq/2004-10-09: this is needed if, for example, the compiler
2562 applied tail-call optimizations to main so that a function called
2563 from main returns directly to the caller of main. Since we don't
2564 stop at main, we should at least stop at the entry point of the
2566 if (this_frame
->level
>= 0
2567 && get_frame_type (this_frame
) == NORMAL_FRAME
2568 && !user_set_backtrace_options
.backtrace_past_entry
2570 && inside_entry_func (this_frame
))
2572 frame_debug_got_null_frame (this_frame
, "inside entry func");
2576 /* Assume that the only way to get a zero PC is through something
2577 like a SIGSEGV or a dummy frame, and hence that NORMAL frames
2578 will never unwind a zero PC. */
2579 if (this_frame
->level
> 0
2580 && (get_frame_type (this_frame
) == NORMAL_FRAME
2581 || get_frame_type (this_frame
) == INLINE_FRAME
)
2582 && get_frame_type (get_next_frame (this_frame
)) == NORMAL_FRAME
2583 && frame_pc_p
&& frame_pc
== 0)
2585 frame_debug_got_null_frame (this_frame
, "zero PC");
2589 return get_prev_frame_always (this_frame
);
2593 get_prev_frame_id_by_id (struct frame_id id
)
2595 struct frame_id prev_id
;
2596 struct frame_info
*frame
;
2598 frame
= frame_find_by_id (id
);
2601 prev_id
= get_frame_id (get_prev_frame (frame
));
2603 prev_id
= null_frame_id
;
2609 get_frame_pc (struct frame_info
*frame
)
2611 gdb_assert (frame
->next
!= NULL
);
2612 return frame_unwind_pc (frame
->next
);
2616 get_frame_pc_if_available (frame_info
*frame
, CORE_ADDR
*pc
)
2619 gdb_assert (frame
->next
!= NULL
);
2623 *pc
= frame_unwind_pc (frame
->next
);
2625 catch (const gdb_exception_error
&ex
)
2627 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2636 /* Return an address that falls within THIS_FRAME's code block. */
2639 get_frame_address_in_block (struct frame_info
*this_frame
)
2641 /* A draft address. */
2642 CORE_ADDR pc
= get_frame_pc (this_frame
);
2644 struct frame_info
*next_frame
= this_frame
->next
;
2646 /* Calling get_frame_pc returns the resume address for THIS_FRAME.
2647 Normally the resume address is inside the body of the function
2648 associated with THIS_FRAME, but there is a special case: when
2649 calling a function which the compiler knows will never return
2650 (for instance abort), the call may be the very last instruction
2651 in the calling function. The resume address will point after the
2652 call and may be at the beginning of a different function
2655 If THIS_FRAME is a signal frame or dummy frame, then we should
2656 not adjust the unwound PC. For a dummy frame, GDB pushed the
2657 resume address manually onto the stack. For a signal frame, the
2658 OS may have pushed the resume address manually and invoked the
2659 handler (e.g. GNU/Linux), or invoked the trampoline which called
2660 the signal handler - but in either case the signal handler is
2661 expected to return to the trampoline. So in both of these
2662 cases we know that the resume address is executable and
2663 related. So we only need to adjust the PC if THIS_FRAME
2664 is a normal function.
2666 If the program has been interrupted while THIS_FRAME is current,
2667 then clearly the resume address is inside the associated
2668 function. There are three kinds of interruption: debugger stop
2669 (next frame will be SENTINEL_FRAME), operating system
2670 signal or exception (next frame will be SIGTRAMP_FRAME),
2671 or debugger-induced function call (next frame will be
2672 DUMMY_FRAME). So we only need to adjust the PC if
2673 NEXT_FRAME is a normal function.
2675 We check the type of NEXT_FRAME first, since it is already
2676 known; frame type is determined by the unwinder, and since
2677 we have THIS_FRAME we've already selected an unwinder for
2680 If the next frame is inlined, we need to keep going until we find
2681 the real function - for instance, if a signal handler is invoked
2682 while in an inlined function, then the code address of the
2683 "calling" normal function should not be adjusted either. */
2685 while (get_frame_type (next_frame
) == INLINE_FRAME
)
2686 next_frame
= next_frame
->next
;
2688 if ((get_frame_type (next_frame
) == NORMAL_FRAME
2689 || get_frame_type (next_frame
) == TAILCALL_FRAME
)
2690 && (get_frame_type (this_frame
) == NORMAL_FRAME
2691 || get_frame_type (this_frame
) == TAILCALL_FRAME
2692 || get_frame_type (this_frame
) == INLINE_FRAME
))
2699 get_frame_address_in_block_if_available (frame_info
*this_frame
,
2705 *pc
= get_frame_address_in_block (this_frame
);
2707 catch (const gdb_exception_error
&ex
)
2709 if (ex
.error
== NOT_AVAILABLE_ERROR
)
2718 find_frame_sal (frame_info
*frame
)
2720 struct frame_info
*next_frame
;
2724 if (frame_inlined_callees (frame
) > 0)
2728 /* If the current frame has some inlined callees, and we have a next
2729 frame, then that frame must be an inlined frame. In this case
2730 this frame's sal is the "call site" of the next frame's inlined
2731 function, which can not be inferred from get_frame_pc. */
2732 next_frame
= get_next_frame (frame
);
2734 sym
= get_frame_function (next_frame
);
2736 sym
= inline_skipped_symbol (inferior_thread ());
2738 /* If frame is inline, it certainly has symbols. */
2741 symtab_and_line sal
;
2742 if (SYMBOL_LINE (sym
) != 0)
2744 sal
.symtab
= symbol_symtab (sym
);
2745 sal
.line
= SYMBOL_LINE (sym
);
2748 /* If the symbol does not have a location, we don't know where
2749 the call site is. Do not pretend to. This is jarring, but
2750 we can't do much better. */
2751 sal
.pc
= get_frame_pc (frame
);
2753 sal
.pspace
= get_frame_program_space (frame
);
2757 /* If FRAME is not the innermost frame, that normally means that
2758 FRAME->pc points at the return instruction (which is *after* the
2759 call instruction), and we want to get the line containing the
2760 call (because the call is where the user thinks the program is).
2761 However, if the next frame is either a SIGTRAMP_FRAME or a
2762 DUMMY_FRAME, then the next frame will contain a saved interrupt
2763 PC and such a PC indicates the current (rather than next)
2764 instruction/line, consequently, for such cases, want to get the
2765 line containing fi->pc. */
2766 if (!get_frame_pc_if_available (frame
, &pc
))
2769 notcurrent
= (pc
!= get_frame_address_in_block (frame
));
2770 return find_pc_line (pc
, notcurrent
);
2773 /* Per "frame.h", return the ``address'' of the frame. Code should
2774 really be using get_frame_id(). */
2776 get_frame_base (struct frame_info
*fi
)
2778 return get_frame_id (fi
).stack_addr
;
2781 /* High-level offsets into the frame. Used by the debug info. */
2784 get_frame_base_address (struct frame_info
*fi
)
2786 if (get_frame_type (fi
) != NORMAL_FRAME
)
2788 if (fi
->base
== NULL
)
2789 fi
->base
= frame_base_find_by_frame (fi
);
2790 /* Sneaky: If the low-level unwind and high-level base code share a
2791 common unwinder, let them share the prologue cache. */
2792 if (fi
->base
->unwind
== fi
->unwind
)
2793 return fi
->base
->this_base (fi
, &fi
->prologue_cache
);
2794 return fi
->base
->this_base (fi
, &fi
->base_cache
);
2798 get_frame_locals_address (struct frame_info
*fi
)
2800 if (get_frame_type (fi
) != NORMAL_FRAME
)
2802 /* If there isn't a frame address method, find it. */
2803 if (fi
->base
== NULL
)
2804 fi
->base
= frame_base_find_by_frame (fi
);
2805 /* Sneaky: If the low-level unwind and high-level base code share a
2806 common unwinder, let them share the prologue cache. */
2807 if (fi
->base
->unwind
== fi
->unwind
)
2808 return fi
->base
->this_locals (fi
, &fi
->prologue_cache
);
2809 return fi
->base
->this_locals (fi
, &fi
->base_cache
);
2813 get_frame_args_address (struct frame_info
*fi
)
2815 if (get_frame_type (fi
) != NORMAL_FRAME
)
2817 /* If there isn't a frame address method, find it. */
2818 if (fi
->base
== NULL
)
2819 fi
->base
= frame_base_find_by_frame (fi
);
2820 /* Sneaky: If the low-level unwind and high-level base code share a
2821 common unwinder, let them share the prologue cache. */
2822 if (fi
->base
->unwind
== fi
->unwind
)
2823 return fi
->base
->this_args (fi
, &fi
->prologue_cache
);
2824 return fi
->base
->this_args (fi
, &fi
->base_cache
);
2827 /* Return true if the frame unwinder for frame FI is UNWINDER; false
2831 frame_unwinder_is (frame_info
*fi
, const frame_unwind
*unwinder
)
2833 if (fi
->unwind
== nullptr)
2834 frame_unwind_find_by_frame (fi
, &fi
->prologue_cache
);
2836 return fi
->unwind
== unwinder
;
2839 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2840 or -1 for a NULL frame. */
2843 frame_relative_level (struct frame_info
*fi
)
2852 get_frame_type (struct frame_info
*frame
)
2854 if (frame
->unwind
== NULL
)
2855 /* Initialize the frame's unwinder because that's what
2856 provides the frame's type. */
2857 frame_unwind_find_by_frame (frame
, &frame
->prologue_cache
);
2858 return frame
->unwind
->type
;
2861 struct program_space
*
2862 get_frame_program_space (struct frame_info
*frame
)
2864 return frame
->pspace
;
2867 struct program_space
*
2868 frame_unwind_program_space (struct frame_info
*this_frame
)
2870 gdb_assert (this_frame
);
2872 /* This is really a placeholder to keep the API consistent --- we
2873 assume for now that we don't have frame chains crossing
2875 return this_frame
->pspace
;
2878 const address_space
*
2879 get_frame_address_space (struct frame_info
*frame
)
2881 return frame
->aspace
;
2884 /* Memory access methods. */
2887 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
,
2888 gdb::array_view
<gdb_byte
> buffer
)
2890 read_memory (addr
, buffer
.data (), buffer
.size ());
2894 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2897 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2898 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2900 return read_memory_integer (addr
, len
, byte_order
);
2904 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2907 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
2908 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2910 return read_memory_unsigned_integer (addr
, len
, byte_order
);
2914 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2915 CORE_ADDR addr
, gdb::array_view
<gdb_byte
> buffer
)
2917 /* NOTE: target_read_memory returns zero on success! */
2918 return target_read_memory (addr
, buffer
.data (), buffer
.size ()) == 0;
2921 /* Architecture methods. */
2924 get_frame_arch (struct frame_info
*this_frame
)
2926 return frame_unwind_arch (this_frame
->next
);
2930 frame_unwind_arch (struct frame_info
*next_frame
)
2932 if (!next_frame
->prev_arch
.p
)
2934 struct gdbarch
*arch
;
2936 if (next_frame
->unwind
== NULL
)
2937 frame_unwind_find_by_frame (next_frame
, &next_frame
->prologue_cache
);
2939 if (next_frame
->unwind
->prev_arch
!= NULL
)
2940 arch
= next_frame
->unwind
->prev_arch (next_frame
,
2941 &next_frame
->prologue_cache
);
2943 arch
= get_frame_arch (next_frame
);
2945 next_frame
->prev_arch
.arch
= arch
;
2946 next_frame
->prev_arch
.p
= true;
2948 fprintf_unfiltered (gdb_stdlog
,
2949 "{ frame_unwind_arch (next_frame=%d) -> %s }\n",
2951 gdbarch_bfd_arch_info (arch
)->printable_name
);
2954 return next_frame
->prev_arch
.arch
;
2958 frame_unwind_caller_arch (struct frame_info
*next_frame
)
2960 next_frame
= skip_artificial_frames (next_frame
);
2962 /* We must have a non-artificial frame. The caller is supposed to check
2963 the result of frame_unwind_caller_id (), which returns NULL_FRAME_ID
2965 gdb_assert (next_frame
!= NULL
);
2967 return frame_unwind_arch (next_frame
);
2970 /* Gets the language of FRAME. */
2973 get_frame_language (struct frame_info
*frame
)
2978 gdb_assert (frame
!= NULL
);
2980 /* We determine the current frame language by looking up its
2981 associated symtab. To retrieve this symtab, we use the frame
2982 PC. However we cannot use the frame PC as is, because it
2983 usually points to the instruction following the "call", which
2984 is sometimes the first instruction of another function. So
2985 we rely on get_frame_address_in_block(), it provides us with
2986 a PC that is guaranteed to be inside the frame's code
2991 pc
= get_frame_address_in_block (frame
);
2994 catch (const gdb_exception_error
&ex
)
2996 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
3002 struct compunit_symtab
*cust
= find_pc_compunit_symtab (pc
);
3005 return compunit_language (cust
);
3008 return language_unknown
;
3011 /* Stack pointer methods. */
3014 get_frame_sp (struct frame_info
*this_frame
)
3016 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
3018 /* NOTE drow/2008-06-28: gdbarch_unwind_sp could be converted to
3019 operate on THIS_FRAME now. */
3020 return gdbarch_unwind_sp (gdbarch
, this_frame
->next
);
3023 /* Return the reason why we can't unwind past FRAME. */
3025 enum unwind_stop_reason
3026 get_frame_unwind_stop_reason (struct frame_info
*frame
)
3028 /* Fill-in STOP_REASON. */
3029 get_prev_frame_always (frame
);
3030 gdb_assert (frame
->prev_p
);
3032 return frame
->stop_reason
;
3035 /* Return a string explaining REASON. */
3038 unwind_stop_reason_to_string (enum unwind_stop_reason reason
)
3042 #define SET(name, description) \
3043 case name: return _(description);
3044 #include "unwind_stop_reasons.def"
3048 internal_error (__FILE__
, __LINE__
,
3049 "Invalid frame stop reason");
3054 frame_stop_reason_string (struct frame_info
*fi
)
3056 gdb_assert (fi
->prev_p
);
3057 gdb_assert (fi
->prev
== NULL
);
3059 /* Return the specific string if we have one. */
3060 if (fi
->stop_string
!= NULL
)
3061 return fi
->stop_string
;
3063 /* Return the generic string if we have nothing better. */
3064 return unwind_stop_reason_to_string (fi
->stop_reason
);
3067 /* Return the enum symbol name of REASON as a string, to use in debug
3071 frame_stop_reason_symbol_string (enum unwind_stop_reason reason
)
3075 #define SET(name, description) \
3076 case name: return #name;
3077 #include "unwind_stop_reasons.def"
3081 internal_error (__FILE__
, __LINE__
,
3082 "Invalid frame stop reason");
3086 /* Clean up after a failed (wrong unwinder) attempt to unwind past
3090 frame_cleanup_after_sniffer (struct frame_info
*frame
)
3092 /* The sniffer should not allocate a prologue cache if it did not
3093 match this frame. */
3094 gdb_assert (frame
->prologue_cache
== NULL
);
3096 /* No sniffer should extend the frame chain; sniff based on what is
3098 gdb_assert (!frame
->prev_p
);
3100 /* The sniffer should not check the frame's ID; that's circular. */
3101 gdb_assert (frame
->this_id
.p
!= frame_id_status::COMPUTED
);
3103 /* Clear cached fields dependent on the unwinder.
3105 The previous PC is independent of the unwinder, but the previous
3106 function is not (see get_frame_address_in_block). */
3107 frame
->prev_func
.status
= CC_UNKNOWN
;
3108 frame
->prev_func
.addr
= 0;
3110 /* Discard the unwinder last, so that we can easily find it if an assertion
3111 in this function triggers. */
3112 frame
->unwind
= NULL
;
3115 /* Set FRAME's unwinder temporarily, so that we can call a sniffer.
3116 If sniffing fails, the caller should be sure to call
3117 frame_cleanup_after_sniffer. */
3120 frame_prepare_for_sniffer (struct frame_info
*frame
,
3121 const struct frame_unwind
*unwind
)
3123 gdb_assert (frame
->unwind
== NULL
);
3124 frame
->unwind
= unwind
;
3127 static struct cmd_list_element
*set_backtrace_cmdlist
;
3128 static struct cmd_list_element
*show_backtrace_cmdlist
;
3130 /* Definition of the "set backtrace" settings that are exposed as
3131 "backtrace" command options. */
3133 using boolean_option_def
3134 = gdb::option::boolean_option_def
<set_backtrace_options
>;
3136 const gdb::option::option_def set_backtrace_option_defs
[] = {
3138 boolean_option_def
{
3140 [] (set_backtrace_options
*opt
) { return &opt
->backtrace_past_main
; },
3141 show_backtrace_past_main
, /* show_cmd_cb */
3142 N_("Set whether backtraces should continue past \"main\"."),
3143 N_("Show whether backtraces should continue past \"main\"."),
3144 N_("Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
3145 the backtrace at \"main\". Set this if you need to see the rest\n\
3146 of the stack trace."),
3149 boolean_option_def
{
3151 [] (set_backtrace_options
*opt
) { return &opt
->backtrace_past_entry
; },
3152 show_backtrace_past_entry
, /* show_cmd_cb */
3153 N_("Set whether backtraces should continue past the entry point of a program."),
3154 N_("Show whether backtraces should continue past the entry point of a program."),
3155 N_("Normally there are no callers beyond the entry point of a program, so GDB\n\
3156 will terminate the backtrace there. Set this if you need to see\n\
3157 the rest of the stack trace."),
3161 void _initialize_frame ();
3163 _initialize_frame ()
3165 obstack_init (&frame_cache_obstack
);
3167 frame_stash_create ();
3169 gdb::observers::target_changed
.attach (frame_observer_target_changed
,
3172 add_basic_prefix_cmd ("backtrace", class_maintenance
, _("\
3173 Set backtrace specific variables.\n\
3174 Configure backtrace variables such as the backtrace limit"),
3175 &set_backtrace_cmdlist
,
3176 0/*allow-unknown*/, &setlist
);
3177 add_show_prefix_cmd ("backtrace", class_maintenance
, _("\
3178 Show backtrace specific variables.\n\
3179 Show backtrace variables such as the backtrace limit."),
3180 &show_backtrace_cmdlist
,
3181 0/*allow-unknown*/, &showlist
);
3183 add_setshow_uinteger_cmd ("limit", class_obscure
,
3184 &user_set_backtrace_options
.backtrace_limit
, _("\
3185 Set an upper bound on the number of backtrace levels."), _("\
3186 Show the upper bound on the number of backtrace levels."), _("\
3187 No more than the specified number of frames can be displayed or examined.\n\
3188 Literal \"unlimited\" or zero means no limit."),
3190 show_backtrace_limit
,
3191 &set_backtrace_cmdlist
,
3192 &show_backtrace_cmdlist
);
3194 gdb::option::add_setshow_cmds_for_options
3195 (class_stack
, &user_set_backtrace_options
,
3196 set_backtrace_option_defs
, &set_backtrace_cmdlist
, &show_backtrace_cmdlist
);
3198 /* Debug this files internals. */
3199 add_setshow_boolean_cmd ("frame", class_maintenance
, &frame_debug
, _("\
3200 Set frame debugging."), _("\
3201 Show frame debugging."), _("\
3202 When non-zero, frame specific internal debugging is enabled."),
3205 &setdebuglist
, &showdebuglist
);