1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4 2001, 2002, 2003 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "inferior.h" /* for inferior_ptid */
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
31 #include "builtin-regs.h"
32 #include "gdb_obstack.h"
33 #include "dummy-frame.h"
34 #include "sentinel-frame.h"
38 #include "frame-unwind.h"
42 /* Flag to indicate whether backtraces should stop at main. */
44 static int backtrace_below_main
;
46 /* Return a frame uniq ID that can be used to, later, re-find the
50 get_frame_id (struct frame_info
*fi
)
65 const struct frame_id null_frame_id
; /* All zeros. */
68 frame_id_build (CORE_ADDR base
, CORE_ADDR func_or_pc
)
77 frame_id_p (struct frame_id l
)
79 /* The .func can be NULL but the .base cannot. */
84 frame_id_eq (struct frame_id l
, struct frame_id r
)
86 /* If .base is different, the frames are different. */
89 /* Add a test to check that the frame ID's are for the same function
95 frame_id_inner (struct frame_id l
, struct frame_id r
)
97 /* Only return non-zero when strictly inner than. Note that, per
98 comment in "frame.h", there is some fuzz here. Frameless
99 functions are not strictly inner than (same .base but different
101 return INNER_THAN (l
.base
, r
.base
);
105 frame_find_by_id (struct frame_id id
)
107 struct frame_info
*frame
;
109 /* ZERO denotes the null frame, let the caller decide what to do
110 about it. Should it instead return get_current_frame()? */
111 if (!frame_id_p (id
))
114 for (frame
= get_current_frame ();
116 frame
= get_prev_frame (frame
))
118 struct frame_id
this = get_frame_id (frame
);
119 if (frame_id_eq (id
, this))
120 /* An exact match. */
122 if (frame_id_inner (id
, this))
125 /* Either, we're not yet gone far enough out along the frame
126 chain (inner(this,id), or we're comparing frameless functions
127 (same .base, different .func, no test available). Struggle
128 on until we've definitly gone to far. */
134 frame_pc_unwind (struct frame_info
*frame
)
136 if (!frame
->pc_unwind_cache_p
)
138 frame
->pc_unwind_cache
= frame
->unwind
->pc (frame
, &frame
->unwind_cache
);
139 frame
->pc_unwind_cache_p
= 1;
141 return frame
->pc_unwind_cache
;
145 frame_id_unwind (struct frame_info
*frame
)
147 if (!frame
->id_unwind_cache_p
)
149 frame
->unwind
->id (frame
, &frame
->unwind_cache
, &frame
->id_unwind_cache
);
150 frame
->id_unwind_cache_p
= 1;
152 return frame
->id_unwind_cache
;
156 frame_pop (struct frame_info
*frame
)
158 /* FIXME: cagney/2003-01-18: There is probably a chicken-egg problem
159 with passing in current_regcache. The pop function needs to be
160 written carefully so as to not overwrite registers whose [old]
161 values are needed to restore other registers. Instead, this code
162 should pass in a scratch cache and, as a second step, restore the
163 registers using that. */
164 frame
->unwind
->pop (frame
, &frame
->unwind_cache
, current_regcache
);
165 flush_cached_frames ();
169 frame_register_unwind (struct frame_info
*frame
, int regnum
,
170 int *optimizedp
, enum lval_type
*lvalp
,
171 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
173 struct frame_unwind_cache
*cache
;
175 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
176 that the value proper does not need to be fetched. */
177 gdb_assert (optimizedp
!= NULL
);
178 gdb_assert (lvalp
!= NULL
);
179 gdb_assert (addrp
!= NULL
);
180 gdb_assert (realnump
!= NULL
);
181 /* gdb_assert (bufferp != NULL); */
183 /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
184 is broken. There is always a frame. If there, for some reason,
185 isn't, there is some pretty busted code as it should have
186 detected the problem before calling here. */
187 gdb_assert (frame
!= NULL
);
189 /* Ask this frame to unwind its register. */
190 frame
->unwind
->reg (frame
, &frame
->unwind_cache
, regnum
,
191 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
195 frame_register (struct frame_info
*frame
, int regnum
,
196 int *optimizedp
, enum lval_type
*lvalp
,
197 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
199 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
200 that the value proper does not need to be fetched. */
201 gdb_assert (optimizedp
!= NULL
);
202 gdb_assert (lvalp
!= NULL
);
203 gdb_assert (addrp
!= NULL
);
204 gdb_assert (realnump
!= NULL
);
205 /* gdb_assert (bufferp != NULL); */
207 /* Ulgh! Old code that, for lval_register, sets ADDRP to the offset
208 of the register in the register cache. It should instead return
209 the REGNUM corresponding to that register. Translate the . */
210 if (GET_SAVED_REGISTER_P ())
212 GET_SAVED_REGISTER (bufferp
, optimizedp
, addrp
, frame
, regnum
, lvalp
);
213 /* Compute the REALNUM if the caller wants it. */
214 if (*lvalp
== lval_register
)
217 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
219 if (*addrp
== register_offset_hack (current_gdbarch
, regnum
))
225 internal_error (__FILE__
, __LINE__
,
226 "Failed to compute the register number corresponding"
227 " to 0x%s", paddr_d (*addrp
));
233 /* Obtain the register value by unwinding the register from the next
234 (more inner frame). */
235 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
236 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
241 frame_unwind_register (struct frame_info
*frame
, int regnum
, void *buf
)
247 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
252 frame_unwind_signed_register (struct frame_info
*frame
, int regnum
,
255 void *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
256 frame_unwind_register (frame
, regnum
, buf
);
257 (*val
) = extract_signed_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
261 frame_unwind_unsigned_register (struct frame_info
*frame
, int regnum
,
264 void *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
265 frame_unwind_register (frame
, regnum
, buf
);
266 (*val
) = extract_unsigned_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
270 frame_read_register (struct frame_info
*frame
, int regnum
, void *buf
)
272 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
273 frame_unwind_register (frame
->next
, regnum
, buf
);
277 frame_read_unsigned_register (struct frame_info
*frame
, int regnum
,
280 /* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is
281 always a frame. Both this, and the equivalent
282 frame_read_signed_register() function, can only be called with a
283 valid frame. If, for some reason, this function is called
284 without a frame then the problem isn't here, but rather in the
285 caller. It should of first created a frame and then passed that
287 /* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the
288 ``current_frame'' should not be treated as a special case. While
289 ``get_next_frame (current_frame) == NULL'' currently holds, it
290 should, as far as possible, not be relied upon. In the future,
291 ``get_next_frame (current_frame)'' may instead simply return a
292 normal frame object that simply always gets register values from
293 the register cache. Consequently, frame code should try to avoid
294 tests like ``if get_next_frame() == NULL'' and instead just rely
295 on recursive frame calls (like the below code) when manipulating
297 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
298 frame_unwind_unsigned_register (frame
->next
, regnum
, val
);
302 frame_read_signed_register (struct frame_info
*frame
, int regnum
,
305 /* See note above in frame_read_unsigned_register(). */
306 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
307 frame_unwind_signed_register (frame
->next
, regnum
, val
);
311 generic_unwind_get_saved_register (char *raw_buffer
,
314 struct frame_info
*frame
,
316 enum lval_type
*lvalp
)
321 enum lval_type lvalx
;
323 if (!target_has_registers
)
324 error ("No registers.");
326 /* Keep things simple, ensure that all the pointers (except valuep)
328 if (optimizedp
== NULL
)
329 optimizedp
= &optimizedx
;
335 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
336 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
337 &realnumx
, raw_buffer
);
341 get_saved_register (char *raw_buffer
,
344 struct frame_info
*frame
,
346 enum lval_type
*lval
)
348 if (GET_SAVED_REGISTER_P ())
350 GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
353 generic_unwind_get_saved_register (raw_buffer
, optimized
, addrp
, frame
,
357 /* frame_register_read ()
359 Find and return the value of REGNUM for the specified stack frame.
360 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
362 Returns 0 if the register value could not be found. */
365 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
371 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
373 /* FIXME: cagney/2002-05-15: This test, is just bogus.
375 It indicates that the target failed to supply a value for a
376 register because it was "not available" at this time. Problem
377 is, the target still has the register and so get saved_register()
378 may be returning a value saved on the stack. */
380 if (register_cached (regnum
) < 0)
381 return 0; /* register value not available */
387 /* Map between a frame register number and its name. A frame register
388 space is a superset of the cooked register space --- it also
389 includes builtin registers. */
392 frame_map_name_to_regnum (const char *name
, int len
)
399 /* Search register name space. */
400 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
401 if (REGISTER_NAME (i
) && len
== strlen (REGISTER_NAME (i
))
402 && strncmp (name
, REGISTER_NAME (i
), len
) == 0)
407 /* Try builtin registers. */
408 i
= builtin_reg_map_name_to_regnum (name
, len
);
411 /* A builtin register doesn't fall into the architecture's
413 gdb_assert (i
>= NUM_REGS
+ NUM_PSEUDO_REGS
);
421 frame_map_regnum_to_name (int regnum
)
425 if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
426 return REGISTER_NAME (regnum
);
427 return builtin_reg_map_regnum_to_name (regnum
);
430 /* Create a sentinel frame. */
433 create_sentinel_frame (struct regcache
*regcache
)
435 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
436 frame
->type
= NORMAL_FRAME
;
438 /* Explicitly initialize the sentinel frame's cache. Provide it
439 with the underlying regcache. In the future additional
440 information, such as the frame's thread will be added. */
441 frame
->unwind_cache
= sentinel_frame_cache (regcache
);
442 /* For the moment there is only one sentinel frame implementation. */
443 frame
->unwind
= sentinel_frame_unwind
;
444 /* Link this frame back to itself. The frame is self referential
445 (the unwound PC is the same as the pc), so make it so. */
447 /* Always unwind the PC as part of creating this frame. This
448 ensures that the frame's PC points at something valid. */
449 /* FIXME: cagney/2003-01-10: Problem here. Unwinding a sentinel
450 frame's PC may require information such as the frame's thread's
451 stop reason. Is it possible to get to that? */
452 frame
->pc
= frame_pc_unwind (frame
);
456 /* Info about the innermost stack frame (contents of FP register) */
458 static struct frame_info
*current_frame
;
460 /* Cache for frame addresses already read by gdb. Valid only while
461 inferior is stopped. Control variables for the frame cache should
462 be local to this module. */
464 static struct obstack frame_cache_obstack
;
467 frame_obstack_zalloc (unsigned long size
)
469 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
470 memset (data
, 0, size
);
475 frame_saved_regs_zalloc (struct frame_info
*fi
)
477 fi
->saved_regs
= (CORE_ADDR
*)
478 frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
479 return fi
->saved_regs
;
483 get_frame_saved_regs (struct frame_info
*fi
)
485 return fi
->saved_regs
;
488 /* Return the innermost (currently executing) stack frame. This is
489 split into two functions. The function unwind_to_current_frame()
490 is wrapped in catch exceptions so that, even when the unwind of the
491 sentinel frame fails, the function still returns a stack frame. */
494 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
496 struct frame_info
*frame
= get_prev_frame (args
);
497 /* A sentinel frame can fail to unwind, eg, because it's PC value
498 lands in somewhere like start. */
501 current_frame
= frame
;
506 get_current_frame (void)
508 if (!target_has_stack
)
510 if (!target_has_registers
)
511 error ("No registers.");
512 if (!target_has_memory
)
513 error ("No memory.");
514 if (current_frame
== NULL
)
516 struct frame_info
*sentinel_frame
=
517 create_sentinel_frame (current_regcache
);
518 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
519 NULL
, RETURN_MASK_ERROR
) != 0)
521 /* Oops! Fake a current frame? Is this useful? It has a PC
522 of zero, for instance. */
523 current_frame
= sentinel_frame
;
526 return current_frame
;
529 /* The "selected" stack frame is used by default for local and arg
530 access. May be zero, for no selected frame. */
532 struct frame_info
*deprecated_selected_frame
;
534 /* Return the selected frame. Always non-null (unless there isn't an
535 inferior sufficient for creating a frame) in which case an error is
539 get_selected_frame (void)
541 if (deprecated_selected_frame
== NULL
)
542 /* Hey! Don't trust this. It should really be re-finding the
543 last selected frame of the currently selected thread. This,
544 though, is better than nothing. */
545 select_frame (get_current_frame ());
546 /* There is always a frame. */
547 gdb_assert (deprecated_selected_frame
!= NULL
);
548 return deprecated_selected_frame
;
551 /* Select frame FI (or NULL - to invalidate the current frame). */
554 select_frame (struct frame_info
*fi
)
556 register struct symtab
*s
;
558 deprecated_selected_frame
= fi
;
559 /* NOTE: cagney/2002-05-04: FI can be NULL. This occures when the
560 frame is being invalidated. */
561 if (selected_frame_level_changed_hook
)
562 selected_frame_level_changed_hook (frame_relative_level (fi
));
564 /* FIXME: kseitz/2002-08-28: It would be nice to call
565 selected_frame_level_changed_event right here, but due to limitations
566 in the current interfaces, we would end up flooding UIs with events
567 because select_frame is used extensively internally.
569 Once we have frame-parameterized frame (and frame-related) commands,
570 the event notification can be moved here, since this function will only
571 be called when the users selected frame is being changed. */
573 /* Ensure that symbols for this frame are read in. Also, determine the
574 source language of this frame, and switch to it if desired. */
577 s
= find_pc_symtab (fi
->pc
);
579 && s
->language
!= current_language
->la_language
580 && s
->language
!= language_unknown
581 && language_mode
== language_mode_auto
)
583 set_language (s
->language
);
588 /* Return the register saved in the simplistic ``saved_regs'' cache.
589 If the value isn't here AND a value is needed, try the next inner
593 frame_saved_regs_register_unwind (struct frame_info
*frame
, void **cache
,
594 int regnum
, int *optimizedp
,
595 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
596 int *realnump
, void *bufferp
)
598 /* There is always a frame at this point. And THIS is the frame
599 we're interested in. */
600 gdb_assert (frame
!= NULL
);
601 /* If we're using generic dummy frames, we'd better not be in a call
602 dummy. (generic_call_dummy_register_unwind ought to have been called
604 gdb_assert (!(DEPRECATED_USE_GENERIC_DUMMY_FRAMES
605 && (get_frame_type (frame
) == DUMMY_FRAME
)));
607 /* Only (older) architectures that implement the
608 FRAME_INIT_SAVED_REGS method should be using this function. */
609 gdb_assert (FRAME_INIT_SAVED_REGS_P ());
611 /* Load the saved_regs register cache. */
612 if (get_frame_saved_regs (frame
) == NULL
)
613 FRAME_INIT_SAVED_REGS (frame
);
615 if (get_frame_saved_regs (frame
) != NULL
616 && get_frame_saved_regs (frame
)[regnum
] != 0)
618 if (regnum
== SP_REGNUM
)
620 /* SP register treated specially. */
626 store_address (bufferp
, REGISTER_RAW_SIZE (regnum
),
627 get_frame_saved_regs (frame
)[regnum
]);
631 /* Any other register is saved in memory, fetch it but cache
632 a local copy of its value. */
634 *lvalp
= lval_memory
;
635 *addrp
= get_frame_saved_regs (frame
)[regnum
];
640 /* Save each register value, as it is read in, in a
641 frame based cache. */
642 void **regs
= (*cache
);
645 int sizeof_cache
= ((NUM_REGS
+ NUM_PSEUDO_REGS
)
647 regs
= frame_obstack_zalloc (sizeof_cache
);
650 if (regs
[regnum
] == NULL
)
653 = frame_obstack_zalloc (REGISTER_RAW_SIZE (regnum
));
654 read_memory (get_frame_saved_regs (frame
)[regnum
], regs
[regnum
],
655 REGISTER_RAW_SIZE (regnum
));
657 memcpy (bufferp
, regs
[regnum
], REGISTER_RAW_SIZE (regnum
));
659 /* Read the value in from memory. */
660 read_memory (get_frame_saved_regs (frame
)[regnum
], bufferp
,
661 REGISTER_RAW_SIZE (regnum
));
668 /* No luck, assume this and the next frame have the same register
669 value. Pass the request down the frame chain to the next frame.
670 Hopefully that will find the register's location, either in a
671 register or in memory. */
672 frame_register (frame
, regnum
, optimizedp
, lvalp
, addrp
, realnump
,
677 frame_saved_regs_pc_unwind (struct frame_info
*frame
, void **cache
)
679 gdb_assert (FRAME_SAVED_PC_P ());
680 return FRAME_SAVED_PC (frame
);
684 frame_saved_regs_id_unwind (struct frame_info
*next_frame
, void **cache
,
691 /* Start out by assuming it's NULL. */
692 (*id
) = null_frame_id
;
694 if (frame_relative_level (next_frame
) <= 0)
695 /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
696 the frame chain, not just the inner most frame! The generic,
697 per-architecture, frame code should handle this and the below
698 should simply be removed. */
699 fromleaf
= FRAMELESS_FUNCTION_INVOCATION (next_frame
);
704 /* A frameless inner-most frame. The `FP' (which isn't an
705 architecture frame-pointer register!) of the caller is the same
707 /* FIXME: 2002-11-09: There isn't any reason to special case this
708 edge condition. Instead the per-architecture code should hande
710 base
= get_frame_base (next_frame
);
713 /* Two macros defined in tm.h specify the machine-dependent
714 actions to be performed here.
716 First, get the frame's chain-pointer.
718 If that is zero, the frame is the outermost frame or a leaf
719 called by the outermost frame. This means that if start
720 calls main without a frame, we'll return 0 (which is fine
723 Nope; there's a problem. This also returns when the current
724 routine is a leaf of main. This is unacceptable. We move
725 this to after the ffi test; I'd rather have backtraces from
726 start go curfluy than have an abort called from main not show
728 gdb_assert (FRAME_CHAIN_P ());
729 base
= FRAME_CHAIN (next_frame
);
731 if (!frame_chain_valid (base
, next_frame
))
737 /* FIXME: cagney/2002-06-08: This should probably return the frame's
738 function and not the PC (a.k.a. resume address). */
739 pc
= frame_pc_unwind (next_frame
);
745 frame_saved_regs_pop (struct frame_info
*fi
, void **cache
,
746 struct regcache
*regcache
)
748 gdb_assert (POP_FRAME_P ());
752 const struct frame_unwind trad_frame_unwinder
= {
753 frame_saved_regs_pop
,
754 frame_saved_regs_pc_unwind
,
755 frame_saved_regs_id_unwind
,
756 frame_saved_regs_register_unwind
758 const struct frame_unwind
*trad_frame_unwind
= &trad_frame_unwinder
;
761 /* Function: get_saved_register
762 Find register number REGNUM relative to FRAME and put its (raw,
763 target format) contents in *RAW_BUFFER.
765 Set *OPTIMIZED if the variable was optimized out (and thus can't be
766 fetched). Note that this is never set to anything other than zero
767 in this implementation.
769 Set *LVAL to lval_memory, lval_register, or not_lval, depending on
770 whether the value was fetched from memory, from a register, or in a
771 strange and non-modifiable way (e.g. a frame pointer which was
772 calculated rather than fetched). We will use not_lval for values
773 fetched from generic dummy frames.
775 Set *ADDRP to the address, either in memory or as a REGISTER_BYTE
776 offset into the registers array. If the value is stored in a dummy
777 frame, set *ADDRP to zero.
779 To use this implementation, define a function called
780 "get_saved_register" in your target code, which simply passes all
781 of its arguments to this function.
783 The argument RAW_BUFFER must point to aligned memory. */
786 deprecated_generic_get_saved_register (char *raw_buffer
, int *optimized
,
788 struct frame_info
*frame
, int regnum
,
789 enum lval_type
*lval
)
791 if (!target_has_registers
)
792 error ("No registers.");
794 gdb_assert (FRAME_INIT_SAVED_REGS_P ());
796 /* Normal systems don't optimize out things with register numbers. */
797 if (optimized
!= NULL
)
800 if (addrp
) /* default assumption: not found in memory */
803 /* Note: since the current frame's registers could only have been
804 saved by frames INTERIOR TO the current frame, we skip examining
805 the current frame itself: otherwise, we would be getting the
806 previous frame's registers which were saved by the current frame. */
810 for (frame
= get_next_frame (frame
);
811 frame_relative_level (frame
) >= 0;
812 frame
= get_next_frame (frame
))
814 if (get_frame_type (frame
) == DUMMY_FRAME
)
816 if (lval
) /* found it in a CALL_DUMMY frame */
819 /* FIXME: cagney/2002-06-26: This should be via the
820 gdbarch_register_read() method so that it, on the
821 fly, constructs either a raw or pseudo register
822 from the raw register cache. */
824 (generic_find_dummy_frame (get_frame_pc (frame
),
825 get_frame_base (frame
)),
830 FRAME_INIT_SAVED_REGS (frame
);
831 if (get_frame_saved_regs (frame
) != NULL
832 && get_frame_saved_regs (frame
)[regnum
] != 0)
834 if (lval
) /* found it saved on the stack */
836 if (regnum
== SP_REGNUM
)
838 if (raw_buffer
) /* SP register treated specially */
839 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
840 get_frame_saved_regs (frame
)[regnum
]);
844 if (addrp
) /* any other register */
845 *addrp
= get_frame_saved_regs (frame
)[regnum
];
847 read_memory (get_frame_saved_regs (frame
)[regnum
], raw_buffer
,
848 REGISTER_RAW_SIZE (regnum
));
855 /* If we get thru the loop to this point, it means the register was
856 not saved in any frame. Return the actual live-register value. */
858 if (lval
) /* found it in a live register */
859 *lval
= lval_register
;
861 *addrp
= REGISTER_BYTE (regnum
);
863 deprecated_read_register_gen (regnum
, raw_buffer
);
866 /* Determine the frame's type based on its PC. */
868 static enum frame_type
869 frame_type_from_pc (CORE_ADDR pc
)
871 /* FIXME: cagney/2002-11-24: Can't yet directly call
872 pc_in_dummy_frame() as some architectures don't set
873 PC_IN_CALL_DUMMY() to generic_pc_in_call_dummy() (remember the
874 latter is implemented by simply calling pc_in_dummy_frame). */
875 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
876 && DEPRECATED_PC_IN_CALL_DUMMY (pc
, 0, 0))
881 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
882 if (PC_IN_SIGTRAMP (pc
, name
))
883 return SIGTRAMP_FRAME
;
889 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
890 Always returns a non-NULL value. */
893 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
895 struct frame_info
*fi
;
897 fi
= frame_obstack_zalloc (sizeof (struct frame_info
));
901 fi
->next
= create_sentinel_frame (current_regcache
);
902 fi
->type
= frame_type_from_pc (pc
);
904 if (INIT_EXTRA_FRAME_INFO_P ())
905 INIT_EXTRA_FRAME_INFO (0, fi
);
907 /* Select/initialize an unwind function. */
908 fi
->unwind
= frame_unwind_find_by_pc (current_gdbarch
, fi
->pc
);
913 /* Return the frame that FRAME calls (NULL if FRAME is the innermost
914 frame). Be careful to not fall off the bottom of the frame chain
915 and onto the sentinel frame. */
918 get_next_frame (struct frame_info
*frame
)
920 if (frame
->level
> 0)
926 /* Flush the entire frame cache. */
929 flush_cached_frames (void)
931 /* Since we can't really be sure what the first object allocated was */
932 obstack_free (&frame_cache_obstack
, 0);
933 obstack_init (&frame_cache_obstack
);
935 current_frame
= NULL
; /* Invalidate cache */
937 annotate_frames_invalid ();
940 /* Flush the frame cache, and start a new one if necessary. */
943 reinit_frame_cache (void)
945 flush_cached_frames ();
947 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
948 if (PIDGET (inferior_ptid
) != 0)
950 select_frame (get_current_frame ());
954 /* Create the previous frame using the deprecated methods
955 INIT_EXTRA_INFO, INIT_FRAME_PC and INIT_FRAME_PC_FIRST. */
957 static struct frame_info
*
958 legacy_get_prev_frame (struct frame_info
*next_frame
)
960 CORE_ADDR address
= 0;
961 struct frame_info
*prev
;
964 /* This code only works on normal frames. A sentinel frame, where
965 the level is -1, should never reach this code. */
966 gdb_assert (next_frame
->level
>= 0);
968 /* On some machines it is possible to call a function without
969 setting up a stack frame for it. On these machines, we
970 define this macro to take two args; a frameinfo pointer
971 identifying a frame and a variable to set or clear if it is
972 or isn't leafless. */
974 /* Still don't want to worry about this except on the innermost
975 frame. This macro will set FROMLEAF if NEXT_FRAME is a frameless
976 function invocation. */
977 if (next_frame
->level
== 0)
978 /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
979 the frame chain, not just the inner most frame! The generic,
980 per-architecture, frame code should handle this and the below
981 should simply be removed. */
982 fromleaf
= FRAMELESS_FUNCTION_INVOCATION (next_frame
);
987 /* A frameless inner-most frame. The `FP' (which isn't an
988 architecture frame-pointer register!) of the caller is the same
990 /* FIXME: 2002-11-09: There isn't any reason to special case this
991 edge condition. Instead the per-architecture code should hande
993 address
= get_frame_base (next_frame
);
996 /* Two macros defined in tm.h specify the machine-dependent
997 actions to be performed here.
999 First, get the frame's chain-pointer.
1001 If that is zero, the frame is the outermost frame or a leaf
1002 called by the outermost frame. This means that if start
1003 calls main without a frame, we'll return 0 (which is fine
1006 Nope; there's a problem. This also returns when the current
1007 routine is a leaf of main. This is unacceptable. We move
1008 this to after the ffi test; I'd rather have backtraces from
1009 start go curfluy than have an abort called from main not show
1011 gdb_assert (FRAME_CHAIN_P ());
1012 address
= FRAME_CHAIN (next_frame
);
1014 if (!frame_chain_valid (address
, next_frame
))
1020 /* Create an initially zero previous frame. */
1021 prev
= frame_obstack_zalloc (sizeof (struct frame_info
));
1024 next_frame
->prev
= prev
;
1025 prev
->next
= next_frame
;
1026 prev
->frame
= address
;
1027 prev
->level
= next_frame
->level
+ 1;
1028 /* FIXME: cagney/2002-11-18: Should be setting the frame's type
1029 here, before anything else, and not last. Various INIT functions
1030 are full of work-arounds for the frames type not being set
1031 correctly from the word go. Ulgh! */
1032 prev
->type
= NORMAL_FRAME
;
1034 /* This change should not be needed, FIXME! We should determine
1035 whether any targets *need* DEPRECATED_INIT_FRAME_PC to happen
1036 after INIT_EXTRA_FRAME_INFO and come up with a simple way to
1037 express what goes on here.
1039 INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
1040 (where the PC is already set up) and here (where it isn't).
1041 DEPRECATED_INIT_FRAME_PC is only called from here, always after
1042 INIT_EXTRA_FRAME_INFO.
1044 The catch is the MIPS, where INIT_EXTRA_FRAME_INFO requires the
1045 PC value (which hasn't been set yet). Some other machines appear
1046 to require INIT_EXTRA_FRAME_INFO before they can do
1047 DEPRECATED_INIT_FRAME_PC. Phoo.
1049 We shouldn't need DEPRECATED_INIT_FRAME_PC_FIRST to add more
1050 complication to an already overcomplicated part of GDB.
1051 gnu@cygnus.com, 15Sep92.
1053 Assuming that some machines need DEPRECATED_INIT_FRAME_PC after
1054 INIT_EXTRA_FRAME_INFO, one possible scheme:
1056 SETUP_INNERMOST_FRAME(): Default version is just create_new_frame
1057 (read_fp ()), read_pc ()). Machines with extra frame info would
1058 do that (or the local equivalent) and then set the extra fields.
1060 SETUP_ARBITRARY_FRAME(argc, argv): Only change here is that
1061 create_new_frame would no longer init extra frame info;
1062 SETUP_ARBITRARY_FRAME would have to do that.
1064 INIT_PREV_FRAME(fromleaf, prev) Replace INIT_EXTRA_FRAME_INFO and
1065 DEPRECATED_INIT_FRAME_PC. This should also return a flag saying
1066 whether to keep the new frame, or whether to discard it, because
1067 on some machines (e.g. mips) it is really awkward to have
1068 FRAME_CHAIN_VALID called *before* INIT_EXTRA_FRAME_INFO (there is
1069 no good way to get information deduced in FRAME_CHAIN_VALID into
1070 the extra fields of the new frame). std_frame_pc(fromleaf, prev)
1072 This is the default setting for INIT_PREV_FRAME. It just does
1073 what the default DEPRECATED_INIT_FRAME_PC does. Some machines
1074 will call it from INIT_PREV_FRAME (either at the beginning, the
1075 end, or in the middle). Some machines won't use it.
1077 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
1079 /* NOTE: cagney/2002-11-09: Just ignore the above! There is no
1080 reason for things to be this complicated.
1082 The trick is to assume that there is always a frame. Instead of
1083 special casing the inner-most frame, create fake frame
1084 (containing the hardware registers) that is inner to the
1085 user-visible inner-most frame (...) and then unwind from that.
1086 That way architecture code can use use the standard
1087 frame_XX_unwind() functions and not differentiate between the
1088 inner most and any other case.
1090 Since there is always a frame to unwind from, there is always
1091 somewhere (NEXT_FRAME) to store all the info needed to construct
1092 a new (previous) frame without having to first create it. This
1093 means that the convolution below - needing to carefully order a
1094 frame's initialization - isn't needed.
1096 The irony here though, is that FRAME_CHAIN(), at least for a more
1097 up-to-date architecture, always calls FRAME_SAVED_PC(), and
1098 FRAME_SAVED_PC() computes the PC but without first needing the
1099 frame! Instead of the convolution below, we could have simply
1100 called FRAME_SAVED_PC() and been done with it! Note that
1101 FRAME_SAVED_PC() is being superseed by frame_pc_unwind() and that
1102 function does have somewhere to cache that PC value. */
1104 if (DEPRECATED_INIT_FRAME_PC_FIRST_P ())
1105 prev
->pc
= (DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf
, prev
));
1107 if (INIT_EXTRA_FRAME_INFO_P ())
1108 INIT_EXTRA_FRAME_INFO (fromleaf
, prev
);
1110 /* This entry is in the frame queue now, which is good since
1111 FRAME_SAVED_PC may use that queue to figure out its value (see
1112 tm-sparc.h). We want the pc saved in the inferior frame. */
1113 if (DEPRECATED_INIT_FRAME_PC_P ())
1114 prev
->pc
= DEPRECATED_INIT_FRAME_PC (fromleaf
, prev
);
1116 /* If ->frame and ->pc are unchanged, we are in the process of
1117 getting ourselves into an infinite backtrace. Some architectures
1118 check this in FRAME_CHAIN or thereabouts, but it seems like there
1119 is no reason this can't be an architecture-independent check. */
1120 if (prev
->frame
== next_frame
->frame
1121 && prev
->pc
== next_frame
->pc
)
1123 next_frame
->prev
= NULL
;
1124 obstack_free (&frame_cache_obstack
, prev
);
1128 /* Initialize the code used to unwind the frame PREV based on the PC
1129 (and probably other architectural information). The PC lets you
1130 check things like the debug info at that point (dwarf2cfi?) and
1131 use that to decide how the frame should be unwound. */
1132 prev
->unwind
= frame_unwind_find_by_pc (current_gdbarch
, prev
->pc
);
1134 /* NOTE: cagney/2002-11-18: The code segments, found in
1135 create_new_frame and get_prev_frame(), that initializes the
1136 frames type is subtly different. The latter only updates ->type
1137 when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME. This stops
1138 get_prev_frame() overriding the frame's type when the INIT code
1139 has previously set it. This is really somewhat bogus. The
1140 initialization, as seen in create_new_frame(), should occur
1141 before the INIT function has been called. */
1142 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1143 && (DEPRECATED_PC_IN_CALL_DUMMY_P ()
1144 ? DEPRECATED_PC_IN_CALL_DUMMY (prev
->pc
, 0, 0)
1145 : pc_in_dummy_frame (prev
->pc
)))
1146 prev
->type
= DUMMY_FRAME
;
1149 /* FIXME: cagney/2002-11-10: This should be moved to before the
1150 INIT code above so that the INIT code knows what the frame's
1151 type is (in fact, for a [generic] dummy-frame, the type can
1152 be set and then the entire initialization can be skipped.
1153 Unforunatly, its the INIT code that sets the PC (Hmm, catch
1156 find_pc_partial_function (prev
->pc
, &name
, NULL
, NULL
);
1157 if (PC_IN_SIGTRAMP (prev
->pc
, name
))
1158 prev
->type
= SIGTRAMP_FRAME
;
1159 /* FIXME: cagney/2002-11-11: Leave prev->type alone. Some
1160 architectures are forcing the frame's type in INIT so we
1161 don't want to override it here. Remember, NORMAL_FRAME == 0,
1162 so it all works (just :-/). Once this initialization is
1163 moved to the start of this function, all this nastness will
1170 /* Return a structure containing various interesting information
1171 about the frame that called NEXT_FRAME. Returns NULL
1172 if there is no such frame. */
1175 get_prev_frame (struct frame_info
*next_frame
)
1177 struct frame_info
*prev_frame
;
1179 /* Return the inner-most frame, when the caller passes in NULL. */
1180 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1181 caller should have previously obtained a valid frame using
1182 get_selected_frame() and then called this code - only possibility
1183 I can think of is code behaving badly.
1185 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1186 block_innermost_frame(). It does the sequence: frame = NULL;
1187 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1188 it couldn't be written better, I don't know.
1190 NOTE: cagney/2003-01-11: I suspect what is happening is
1191 block_innermost_frame() is, when the target has no state
1192 (registers, memory, ...), still calling this function. The
1193 assumption being that this function will return NULL indicating
1194 that a frame isn't possible, rather than checking that the target
1195 has state and then calling get_current_frame() and
1196 get_prev_frame(). This is a guess mind. */
1197 if (next_frame
== NULL
)
1199 /* NOTE: cagney/2002-11-09: There was a code segment here that
1200 would error out when CURRENT_FRAME was NULL. The comment
1201 that went with it made the claim ...
1203 ``This screws value_of_variable, which just wants a nice
1204 clean NULL return from block_innermost_frame if there are no
1205 frames. I don't think I've ever seen this message happen
1206 otherwise. And returning NULL here is a perfectly legitimate
1209 Per the above, this code shouldn't even be called with a NULL
1211 return current_frame
;
1214 /* There is always a frame. If this assertion fails, suspect that
1215 something should be calling get_selected_frame() or
1216 get_current_frame(). */
1217 gdb_assert (next_frame
!= NULL
);
1219 if (next_frame
->level
>= 0
1220 && !backtrace_below_main
1221 && inside_main_func (get_frame_pc (next_frame
)))
1222 /* Don't unwind past main(), bug always unwind the sentinel frame.
1223 Note, this is done _before_ the frame has been marked as
1224 previously unwound. That way if the user later decides to
1225 allow unwinds past main(), that just happens. */
1228 /* Only try to do the unwind once. */
1229 if (next_frame
->prev_p
)
1230 return next_frame
->prev
;
1231 next_frame
->prev_p
= 1;
1233 /* If we're inside the entry file, it isn't valid. */
1234 /* NOTE: drow/2002-12-25: should there be a way to disable this
1235 check? It assumes a single small entry file, and the way some
1236 debug readers (e.g. dbxread) figure out which object is the
1237 entry file is somewhat hokey. */
1238 /* NOTE: cagney/2003-01-10: If there is a way of disabling this test
1239 then it should probably be moved to before the ->prev_p test,
1241 if (inside_entry_file (get_frame_pc (next_frame
)))
1244 /* If any of the old frame initialization methods are around, use
1245 the legacy get_prev_frame method. Just don't try to unwind a
1246 sentinel frame using that method - it doesn't work. All sentinal
1247 frames use the new unwind code. */
1248 if ((DEPRECATED_INIT_FRAME_PC_P ()
1249 || DEPRECATED_INIT_FRAME_PC_FIRST_P ()
1250 || INIT_EXTRA_FRAME_INFO_P ()
1251 || FRAME_CHAIN_P ())
1252 && next_frame
->level
>= 0)
1253 return legacy_get_prev_frame (next_frame
);
1255 /* Allocate the new frame but do not wire it in to the frame chain.
1256 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1257 frame->next to pull some fancy tricks (of course such code is, by
1258 definition, recursive). Try to prevent it.
1260 There is no reason to worry about memory leaks, should the
1261 remainder of the function fail. The allocated memory will be
1262 quickly reclaimed when the frame cache is flushed, and the `we've
1263 been here before' check above will stop repeated memory
1264 allocation calls. */
1265 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1266 prev_frame
->level
= next_frame
->level
+ 1;
1268 /* Try to unwind the PC. If that doesn't work, assume we've reached
1269 the oldest frame and simply return. Is there a better sentinal
1270 value? The unwound PC value is then used to initialize the new
1271 previous frame's type.
1273 Note that the pc-unwind is intentionally performed before the
1274 frame chain. This is ok since, for old targets, both
1275 frame_pc_unwind (nee, FRAME_SAVED_PC) and FRAME_CHAIN()) assume
1276 NEXT_FRAME's data structures have already been initialized (using
1277 INIT_EXTRA_FRAME_INFO) and hence the call order doesn't matter.
1279 By unwinding the PC first, it becomes possible to, in the case of
1280 a dummy frame, avoid also unwinding the frame ID. This is
1281 because (well ignoring the PPC) a dummy frame can be located
1282 using NEXT_FRAME's frame ID. */
1284 prev_frame
->pc
= frame_pc_unwind (next_frame
);
1285 if (prev_frame
->pc
== 0)
1286 /* The allocated PREV_FRAME will be reclaimed when the frame
1287 obstack is next purged. */
1289 prev_frame
->type
= frame_type_from_pc (prev_frame
->pc
);
1291 /* Set the unwind functions based on that identified PC. */
1292 prev_frame
->unwind
= frame_unwind_find_by_pc (current_gdbarch
,
1295 /* FIXME: cagney/2003-01-13: A dummy frame doesn't need to unwind
1296 the frame ID because the frame ID comes from the previous frame.
1297 The other frames do though. True? */
1299 /* FIXME: cagney/2002-12-18: Instead of this hack, should just
1300 save the frame ID directly. */
1301 struct frame_id id
= frame_id_unwind (next_frame
);
1302 if (!frame_id_p (id
))
1304 prev_frame
->frame
= id
.base
;
1308 next_frame
->prev
= prev_frame
;
1309 prev_frame
->next
= next_frame
;
1311 /* FIXME: cagney/2002-01-19: This call will go away. Instead of
1312 initializing extra info, all frames will use the frame_cache
1313 (passed to the unwind functions) to store additional frame info.
1314 Unfortunatly legacy targets can't use legacy_get_prev_frame() to
1315 unwind the sentinel frame and, consequently, are forced to take
1316 this code path and rely on the below call to INIT_EXTR_FRAME_INFO
1317 to initialize the inner-most frame. */
1318 if (INIT_EXTRA_FRAME_INFO_P ())
1320 gdb_assert (prev_frame
->level
== 0);
1321 INIT_EXTRA_FRAME_INFO (0, prev_frame
);
1328 get_frame_pc (struct frame_info
*frame
)
1334 pc_notcurrent (struct frame_info
*frame
)
1336 /* If FRAME is not the innermost frame, that normally means that
1337 FRAME->pc points at the return instruction (which is *after* the
1338 call instruction), and we want to get the line containing the
1339 call (because the call is where the user thinks the program is).
1340 However, if the next frame is either a SIGTRAMP_FRAME or a
1341 DUMMY_FRAME, then the next frame will contain a saved interrupt
1342 PC and such a PC indicates the current (rather than next)
1343 instruction/line, consequently, for such cases, want to get the
1344 line containing fi->pc. */
1345 struct frame_info
*next
= get_next_frame (frame
);
1346 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1351 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1353 (*sal
) = find_pc_line (frame
->pc
, pc_notcurrent (frame
));
1356 /* Per "frame.h", return the ``address'' of the frame. Code should
1357 really be using get_frame_id(). */
1359 get_frame_base (struct frame_info
*fi
)
1364 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1365 or -1 for a NULL frame. */
1368 frame_relative_level (struct frame_info
*fi
)
1377 get_frame_type (struct frame_info
*frame
)
1379 /* Some targets still don't use [generic] dummy frames. Catch them
1381 if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1382 && deprecated_frame_in_dummy (frame
))
1388 deprecated_set_frame_type (struct frame_info
*frame
, enum frame_type type
)
1390 /* Arrrg! See comment in "frame.h". */
1394 #ifdef FRAME_FIND_SAVED_REGS
1395 /* XXX - deprecated. This is a compatibility function for targets
1396 that do not yet implement FRAME_INIT_SAVED_REGS. */
1397 /* Find the addresses in which registers are saved in FRAME. */
1400 deprecated_get_frame_saved_regs (struct frame_info
*frame
,
1401 struct frame_saved_regs
*saved_regs_addr
)
1403 if (frame
->saved_regs
== NULL
)
1405 frame
->saved_regs
= (CORE_ADDR
*)
1406 frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
1408 if (saved_regs_addr
== NULL
)
1410 struct frame_saved_regs saved_regs
;
1411 FRAME_FIND_SAVED_REGS (frame
, saved_regs
);
1412 memcpy (frame
->saved_regs
, &saved_regs
, SIZEOF_FRAME_SAVED_REGS
);
1416 FRAME_FIND_SAVED_REGS (frame
, *saved_regs_addr
);
1417 memcpy (frame
->saved_regs
, saved_regs_addr
, SIZEOF_FRAME_SAVED_REGS
);
1422 struct frame_extra_info
*
1423 get_frame_extra_info (struct frame_info
*fi
)
1425 return fi
->extra_info
;
1428 struct frame_extra_info
*
1429 frame_extra_info_zalloc (struct frame_info
*fi
, long size
)
1431 fi
->extra_info
= frame_obstack_zalloc (size
);
1432 return fi
->extra_info
;
1436 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
1438 /* See comment in "frame.h". */
1439 gdb_assert (frame
->next
!= NULL
);
1444 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
1446 /* See comment in "frame.h". */
1447 frame
->frame
= base
;
1451 deprecated_set_frame_saved_regs_hack (struct frame_info
*frame
,
1452 CORE_ADDR
*saved_regs
)
1454 frame
->saved_regs
= saved_regs
;
1458 deprecated_set_frame_extra_info_hack (struct frame_info
*frame
,
1459 struct frame_extra_info
*extra_info
)
1461 frame
->extra_info
= extra_info
;
1465 deprecated_set_frame_next_hack (struct frame_info
*fi
,
1466 struct frame_info
*next
)
1472 deprecated_set_frame_prev_hack (struct frame_info
*fi
,
1473 struct frame_info
*prev
)
1479 deprecated_get_frame_context (struct frame_info
*fi
)
1485 deprecated_set_frame_context (struct frame_info
*fi
,
1486 struct context
*context
)
1488 fi
->context
= context
;
1492 deprecated_frame_xmalloc (void)
1494 struct frame_info
*frame
= XMALLOC (struct frame_info
);
1495 memset (frame
, 0, sizeof (struct frame_info
));
1500 deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs
,
1501 long sizeof_extra_info
)
1503 struct frame_info
*frame
= deprecated_frame_xmalloc ();
1504 make_cleanup (xfree
, frame
);
1505 if (sizeof_saved_regs
> 0)
1507 frame
->saved_regs
= xcalloc (1, sizeof_saved_regs
);
1508 make_cleanup (xfree
, frame
->saved_regs
);
1510 if (sizeof_extra_info
> 0)
1512 frame
->extra_info
= xcalloc (1, sizeof_extra_info
);
1513 make_cleanup (xfree
, frame
->extra_info
);
1519 _initialize_frame (void)
1521 obstack_init (&frame_cache_obstack
);
1523 /* FIXME: cagney/2003-01-19: This command needs a rename. Suggest
1524 `set backtrace {past,beyond,...}-main'. Also suggest adding `set
1525 backtrace ...-start' to control backtraces past start. The
1526 problem with `below' is that it stops the `up' command. */
1528 add_setshow_boolean_cmd ("backtrace-below-main", class_obscure
,
1529 &backtrace_below_main
, "\
1530 Set whether backtraces should continue past \"main\".\n\
1531 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1532 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1533 of the stack trace.", "\
1534 Show whether backtraces should continue past \"main\".\n\
1535 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1536 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1537 of the stack trace.",
1538 NULL
, NULL
, &setlist
, &showlist
);