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"
39 #include "frame-base.h"
43 /* Flag to control debugging. */
45 static int frame_debug
;
47 /* Flag to indicate whether backtraces should stop at main. */
49 static int backtrace_below_main
;
51 /* Return a frame uniq ID that can be used to, later, re-find the
55 get_frame_id (struct frame_info
*fi
)
63 gdb_assert (!legacy_frame_p (current_gdbarch
));
64 /* Find THIS frame's ID. */
65 fi
->unwind
->this_id (fi
->next
, &fi
->prologue_cache
, &fi
->id
);
67 /* FIXME: cagney/2002-12-18: Instead of this hack, should only
68 store the frame ID in PREV_FRAME. */
69 fi
->frame
= fi
->id
.base
;
71 return frame_id_build (fi
->frame
, get_frame_pc (fi
));
74 const struct frame_id null_frame_id
; /* All zeros. */
77 frame_id_build (CORE_ADDR base
, CORE_ADDR func_or_pc
)
86 frame_id_p (struct frame_id l
)
88 /* The .func can be NULL but the .base cannot. */
93 frame_id_eq (struct frame_id l
, struct frame_id r
)
95 /* If .base is different, the frames are different. */
98 /* Add a test to check that the frame ID's are for the same function
104 frame_id_inner (struct frame_id l
, struct frame_id r
)
106 /* Only return non-zero when strictly inner than. Note that, per
107 comment in "frame.h", there is some fuzz here. Frameless
108 functions are not strictly inner than (same .base but different
110 return INNER_THAN (l
.base
, r
.base
);
114 frame_find_by_id (struct frame_id id
)
116 struct frame_info
*frame
;
118 /* ZERO denotes the null frame, let the caller decide what to do
119 about it. Should it instead return get_current_frame()? */
120 if (!frame_id_p (id
))
123 for (frame
= get_current_frame ();
125 frame
= get_prev_frame (frame
))
127 struct frame_id
this = get_frame_id (frame
);
128 if (frame_id_eq (id
, this))
129 /* An exact match. */
131 if (frame_id_inner (id
, this))
134 /* Either, we're not yet gone far enough out along the frame
135 chain (inner(this,id), or we're comparing frameless functions
136 (same .base, different .func, no test available). Struggle
137 on until we've definitly gone to far. */
143 frame_pc_unwind (struct frame_info
*this_frame
)
145 if (!this_frame
->pc_unwind_cache_p
)
148 if (gdbarch_unwind_pc_p (current_gdbarch
))
150 /* The right way. The `pure' way. The one true way. This
151 method depends solely on the register-unwind code to
152 determine the value of registers in THIS frame, and hence
153 the value of this frame's PC (resume address). A typical
154 implementation is no more than:
156 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
157 return extract_address (buf, size of ISA_PC_REGNUM);
159 Note: this method is very heavily dependent on a correct
160 register-unwind implementation, it pays to fix that
161 method first; this method is frame type agnostic, since
162 it only deals with register values, it works with any
163 frame. This is all in stark contrast to the old
164 FRAME_SAVED_PC which would try to directly handle all the
165 different ways that a PC could be unwound. */
166 pc
= gdbarch_unwind_pc (current_gdbarch
, this_frame
);
168 else if (this_frame
->level
< 0)
170 /* FIXME: cagney/2003-03-06: Old code and and a sentinel
171 frame. Do like was always done. Fetch the PC's value
172 direct from the global registers array (via read_pc).
173 This assumes that this frame belongs to the current
174 global register cache. The assumption is dangerous. */
177 else if (DEPRECATED_FRAME_SAVED_PC_P ())
179 /* FIXME: cagney/2003-03-06: Old code, but not a sentinel
180 frame. Do like was always done. Note that this method,
181 unlike unwind_pc(), tries to handle all the different
182 frame cases directly. It fails. */
183 pc
= DEPRECATED_FRAME_SAVED_PC (this_frame
);
186 internal_error (__FILE__
, __LINE__
, "No gdbarch_unwind_pc method");
187 this_frame
->pc_unwind_cache
= pc
;
188 this_frame
->pc_unwind_cache_p
= 1;
190 return this_frame
->pc_unwind_cache
;
194 frame_func_unwind (struct frame_info
*fi
)
196 if (!fi
->prev_func
.p
)
199 fi
->prev_func
.addr
= get_pc_function_start (frame_pc_unwind (fi
));
201 return fi
->prev_func
.addr
;
205 get_frame_func (struct frame_info
*fi
)
207 return frame_func_unwind (fi
->next
);
211 do_frame_unwind_register (void *src
, int regnum
, void *buf
)
213 frame_unwind_register (src
, regnum
, buf
);
218 frame_pop (struct frame_info
*this_frame
)
220 struct regcache
*scratch_regcache
;
221 struct cleanup
*cleanups
;
223 if (DEPRECATED_POP_FRAME_P ())
225 /* A legacy architecture that has implemented a custom pop
226 function. All new architectures should instead be using the
227 generic code below. */
228 DEPRECATED_POP_FRAME
;
232 /* Make a copy of all the register values unwound from this
233 frame. Save them in a scratch buffer so that there isn't a
234 race betweening trying to extract the old values from the
235 current_regcache while, at the same time writing new values
236 into that same cache. */
237 struct regcache
*scratch
= regcache_xmalloc (current_gdbarch
);
238 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (scratch
);
239 regcache_save (scratch
, do_frame_unwind_register
, this_frame
);
240 /* FIXME: cagney/2003-03-16: It should be possible to tell the
241 target's register cache that it is about to be hit with a
242 burst register transfer and that the sequence of register
243 writes should be batched. The pair target_prepare_to_store()
244 and target_store_registers() kind of suggest this
245 functionality. Unfortunatly, they don't implement it. Their
246 lack of a formal definition can lead to targets writing back
247 bogus values (arguably a bug in the target code mind). */
248 /* Now copy those saved registers into the current regcache.
249 Here, regcache_cpy() calls regcache_restore(). */
250 regcache_cpy (current_regcache
, scratch
);
251 do_cleanups (cleanups
);
253 /* We've made right mess of GDB's local state, just discard
255 flush_cached_frames ();
259 frame_register_unwind (struct frame_info
*frame
, int regnum
,
260 int *optimizedp
, enum lval_type
*lvalp
,
261 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
263 struct frame_unwind_cache
*cache
;
265 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
266 that the value proper does not need to be fetched. */
267 gdb_assert (optimizedp
!= NULL
);
268 gdb_assert (lvalp
!= NULL
);
269 gdb_assert (addrp
!= NULL
);
270 gdb_assert (realnump
!= NULL
);
271 /* gdb_assert (bufferp != NULL); */
273 /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
274 is broken. There is always a frame. If there, for some reason,
275 isn't, there is some pretty busted code as it should have
276 detected the problem before calling here. */
277 gdb_assert (frame
!= NULL
);
279 /* Ask this frame to unwind its register. See comment in
280 "frame-unwind.h" for why NEXT frame and this unwind cace are
282 frame
->unwind
->prev_register (frame
->next
, &frame
->prologue_cache
, regnum
,
283 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
288 frame_register (struct frame_info
*frame
, int regnum
,
289 int *optimizedp
, enum lval_type
*lvalp
,
290 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
292 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
293 that the value proper does not need to be fetched. */
294 gdb_assert (optimizedp
!= NULL
);
295 gdb_assert (lvalp
!= NULL
);
296 gdb_assert (addrp
!= NULL
);
297 gdb_assert (realnump
!= NULL
);
298 /* gdb_assert (bufferp != NULL); */
300 /* Ulgh! Old code that, for lval_register, sets ADDRP to the offset
301 of the register in the register cache. It should instead return
302 the REGNUM corresponding to that register. Translate the . */
303 if (DEPRECATED_GET_SAVED_REGISTER_P ())
305 DEPRECATED_GET_SAVED_REGISTER (bufferp
, optimizedp
, addrp
, frame
,
307 /* Compute the REALNUM if the caller wants it. */
308 if (*lvalp
== lval_register
)
311 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
313 if (*addrp
== register_offset_hack (current_gdbarch
, regnum
))
319 internal_error (__FILE__
, __LINE__
,
320 "Failed to compute the register number corresponding"
321 " to 0x%s", paddr_d (*addrp
));
327 /* Obtain the register value by unwinding the register from the next
328 (more inner frame). */
329 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
330 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
335 frame_unwind_register (struct frame_info
*frame
, int regnum
, void *buf
)
341 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
346 frame_unwind_signed_register (struct frame_info
*frame
, int regnum
,
349 void *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
350 frame_unwind_register (frame
, regnum
, buf
);
351 (*val
) = extract_signed_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
355 frame_unwind_unsigned_register (struct frame_info
*frame
, int regnum
,
358 void *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
359 frame_unwind_register (frame
, regnum
, buf
);
360 (*val
) = extract_unsigned_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
364 frame_read_register (struct frame_info
*frame
, int regnum
, void *buf
)
366 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
367 frame_unwind_register (frame
->next
, regnum
, buf
);
371 frame_read_unsigned_register (struct frame_info
*frame
, int regnum
,
374 /* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is
375 always a frame. Both this, and the equivalent
376 frame_read_signed_register() function, can only be called with a
377 valid frame. If, for some reason, this function is called
378 without a frame then the problem isn't here, but rather in the
379 caller. It should of first created a frame and then passed that
381 /* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the
382 ``current_frame'' should not be treated as a special case. While
383 ``get_next_frame (current_frame) == NULL'' currently holds, it
384 should, as far as possible, not be relied upon. In the future,
385 ``get_next_frame (current_frame)'' may instead simply return a
386 normal frame object that simply always gets register values from
387 the register cache. Consequently, frame code should try to avoid
388 tests like ``if get_next_frame() == NULL'' and instead just rely
389 on recursive frame calls (like the below code) when manipulating
391 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
392 frame_unwind_unsigned_register (frame
->next
, regnum
, val
);
396 frame_read_signed_register (struct frame_info
*frame
, int regnum
,
399 /* See note above in frame_read_unsigned_register(). */
400 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
401 frame_unwind_signed_register (frame
->next
, regnum
, val
);
405 generic_unwind_get_saved_register (char *raw_buffer
,
408 struct frame_info
*frame
,
410 enum lval_type
*lvalp
)
415 enum lval_type lvalx
;
417 if (!target_has_registers
)
418 error ("No registers.");
420 /* Keep things simple, ensure that all the pointers (except valuep)
422 if (optimizedp
== NULL
)
423 optimizedp
= &optimizedx
;
429 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
430 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
431 &realnumx
, raw_buffer
);
434 /* frame_register_read ()
436 Find and return the value of REGNUM for the specified stack frame.
437 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
439 Returns 0 if the register value could not be found. */
442 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
448 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
450 /* FIXME: cagney/2002-05-15: This test, is just bogus.
452 It indicates that the target failed to supply a value for a
453 register because it was "not available" at this time. Problem
454 is, the target still has the register and so get saved_register()
455 may be returning a value saved on the stack. */
457 if (register_cached (regnum
) < 0)
458 return 0; /* register value not available */
464 /* Map between a frame register number and its name. A frame register
465 space is a superset of the cooked register space --- it also
466 includes builtin registers. */
469 frame_map_name_to_regnum (const char *name
, int len
)
476 /* Search register name space. */
477 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
478 if (REGISTER_NAME (i
) && len
== strlen (REGISTER_NAME (i
))
479 && strncmp (name
, REGISTER_NAME (i
), len
) == 0)
484 /* Try builtin registers. */
485 i
= builtin_reg_map_name_to_regnum (name
, len
);
488 /* A builtin register doesn't fall into the architecture's
490 gdb_assert (i
>= NUM_REGS
+ NUM_PSEUDO_REGS
);
498 frame_map_regnum_to_name (int regnum
)
502 if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
503 return REGISTER_NAME (regnum
);
504 return builtin_reg_map_regnum_to_name (regnum
);
507 /* Create a sentinel frame. */
510 create_sentinel_frame (struct regcache
*regcache
)
512 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
513 frame
->type
= NORMAL_FRAME
;
515 /* Explicitly initialize the sentinel frame's cache. Provide it
516 with the underlying regcache. In the future additional
517 information, such as the frame's thread will be added. */
518 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
519 /* For the moment there is only one sentinel frame implementation. */
520 frame
->unwind
= sentinel_frame_unwind
;
521 /* Link this frame back to itself. The frame is self referential
522 (the unwound PC is the same as the pc), so make it so. */
524 /* Always unwind the PC as part of creating this frame. This
525 ensures that the frame's PC points at something valid. */
526 /* FIXME: cagney/2003-01-10: Problem here. Unwinding a sentinel
527 frame's PC may require information such as the frame's thread's
528 stop reason. Is it possible to get to that? */
529 /* FIXME: cagney/2003-04-04: Once ->pc is eliminated, this
530 assignment can go away. */
531 frame
->pc
= frame_pc_unwind (frame
);
532 /* Make the sentinel frame's ID valid, but invalid. That way all
533 comparisons with it should fail. */
535 frame
->id
= null_frame_id
;
539 /* Info about the innermost stack frame (contents of FP register) */
541 static struct frame_info
*current_frame
;
543 /* Cache for frame addresses already read by gdb. Valid only while
544 inferior is stopped. Control variables for the frame cache should
545 be local to this module. */
547 static struct obstack frame_cache_obstack
;
550 frame_obstack_zalloc (unsigned long size
)
552 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
553 memset (data
, 0, size
);
558 frame_saved_regs_zalloc (struct frame_info
*fi
)
560 fi
->saved_regs
= (CORE_ADDR
*)
561 frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
562 return fi
->saved_regs
;
566 get_frame_saved_regs (struct frame_info
*fi
)
568 return fi
->saved_regs
;
571 /* Return the innermost (currently executing) stack frame. This is
572 split into two functions. The function unwind_to_current_frame()
573 is wrapped in catch exceptions so that, even when the unwind of the
574 sentinel frame fails, the function still returns a stack frame. */
577 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
579 struct frame_info
*frame
= get_prev_frame (args
);
580 /* A sentinel frame can fail to unwind, eg, because it's PC value
581 lands in somewhere like start. */
584 current_frame
= frame
;
589 get_current_frame (void)
591 /* First check, and report, the lack of registers. Having GDB
592 report "No stack!" or "No memory" when the target doesn't even
593 have registers is very confusing. Besides, "printcmd.exp"
594 explicitly checks that ``print $pc'' with no registers prints "No
596 if (!target_has_registers
)
597 error ("No registers.");
598 if (!target_has_stack
)
600 if (!target_has_memory
)
601 error ("No memory.");
602 if (current_frame
== NULL
)
604 struct frame_info
*sentinel_frame
=
605 create_sentinel_frame (current_regcache
);
606 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
607 NULL
, RETURN_MASK_ERROR
) != 0)
609 /* Oops! Fake a current frame? Is this useful? It has a PC
610 of zero, for instance. */
611 current_frame
= sentinel_frame
;
614 return current_frame
;
617 /* The "selected" stack frame is used by default for local and arg
618 access. May be zero, for no selected frame. */
620 struct frame_info
*deprecated_selected_frame
;
622 /* Return the selected frame. Always non-null (unless there isn't an
623 inferior sufficient for creating a frame) in which case an error is
627 get_selected_frame (void)
629 if (deprecated_selected_frame
== NULL
)
630 /* Hey! Don't trust this. It should really be re-finding the
631 last selected frame of the currently selected thread. This,
632 though, is better than nothing. */
633 select_frame (get_current_frame ());
634 /* There is always a frame. */
635 gdb_assert (deprecated_selected_frame
!= NULL
);
636 return deprecated_selected_frame
;
639 /* Select frame FI (or NULL - to invalidate the current frame). */
642 select_frame (struct frame_info
*fi
)
644 register struct symtab
*s
;
646 deprecated_selected_frame
= fi
;
647 /* NOTE: cagney/2002-05-04: FI can be NULL. This occures when the
648 frame is being invalidated. */
649 if (selected_frame_level_changed_hook
)
650 selected_frame_level_changed_hook (frame_relative_level (fi
));
652 /* FIXME: kseitz/2002-08-28: It would be nice to call
653 selected_frame_level_changed_event right here, but due to limitations
654 in the current interfaces, we would end up flooding UIs with events
655 because select_frame is used extensively internally.
657 Once we have frame-parameterized frame (and frame-related) commands,
658 the event notification can be moved here, since this function will only
659 be called when the users selected frame is being changed. */
661 /* Ensure that symbols for this frame are read in. Also, determine the
662 source language of this frame, and switch to it if desired. */
665 s
= find_pc_symtab (get_frame_pc (fi
));
667 && s
->language
!= current_language
->la_language
668 && s
->language
!= language_unknown
669 && language_mode
== language_mode_auto
)
671 set_language (s
->language
);
676 /* Return the register saved in the simplistic ``saved_regs'' cache.
677 If the value isn't here AND a value is needed, try the next inner
681 legacy_saved_regs_prev_register (struct frame_info
*next_frame
,
682 void **this_prologue_cache
,
683 int regnum
, int *optimizedp
,
684 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
685 int *realnump
, void *bufferp
)
687 /* HACK: New code is passed the next frame and this cache.
688 Unfortunatly, old code expects this frame. Since this is a
689 backward compatibility hack, cheat by walking one level along the
690 prologue chain to the frame the old code expects.
692 Do not try this at home. Professional driver, closed course. */
693 struct frame_info
*frame
= next_frame
->prev
;
694 gdb_assert (frame
!= NULL
);
696 /* Only (older) architectures that implement the
697 DEPRECATED_FRAME_INIT_SAVED_REGS method should be using this
699 gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
701 /* Load the saved_regs register cache. */
702 if (get_frame_saved_regs (frame
) == NULL
)
703 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
705 if (get_frame_saved_regs (frame
) != NULL
706 && get_frame_saved_regs (frame
)[regnum
] != 0)
708 if (regnum
== SP_REGNUM
)
710 /* SP register treated specially. */
716 store_address (bufferp
, REGISTER_RAW_SIZE (regnum
),
717 get_frame_saved_regs (frame
)[regnum
]);
721 /* Any other register is saved in memory, fetch it but cache
722 a local copy of its value. */
724 *lvalp
= lval_memory
;
725 *addrp
= get_frame_saved_regs (frame
)[regnum
];
730 /* Save each register value, as it is read in, in a
731 frame based cache. */
732 void **regs
= (*this_prologue_cache
);
735 int sizeof_cache
= ((NUM_REGS
+ NUM_PSEUDO_REGS
)
737 regs
= frame_obstack_zalloc (sizeof_cache
);
738 (*this_prologue_cache
) = regs
;
740 if (regs
[regnum
] == NULL
)
743 = frame_obstack_zalloc (REGISTER_RAW_SIZE (regnum
));
744 read_memory (get_frame_saved_regs (frame
)[regnum
], regs
[regnum
],
745 REGISTER_RAW_SIZE (regnum
));
747 memcpy (bufferp
, regs
[regnum
], REGISTER_RAW_SIZE (regnum
));
749 /* Read the value in from memory. */
750 read_memory (get_frame_saved_regs (frame
)[regnum
], bufferp
,
751 REGISTER_RAW_SIZE (regnum
));
758 /* No luck. Assume this and the next frame have the same register
759 value. Pass the unwind request down the frame chain to the next
760 frame. Hopefully that frame will find the register's location. */
761 frame_register_unwind (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
766 legacy_saved_regs_this_id (struct frame_info
*next_frame
,
767 void **this_prologue_cache
,
774 if (frame_relative_level (next_frame
) < 0)
776 /* FIXME: cagney/2003-03-14: We've got the extra special case of
777 unwinding a sentinel frame, the PC of which is pointing at a
778 stack dummy. Fake up the dummy frame's ID using the same
779 sequence as is found a traditional unwinder. */
780 (*id
) = frame_id_build (read_fp (), read_pc ());
784 /* Start out by assuming it's NULL. */
785 (*id
) = null_frame_id
;
787 if (frame_relative_level (next_frame
) <= 0)
788 /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
789 the frame chain, not just the inner most frame! The generic,
790 per-architecture, frame code should handle this and the below
791 should simply be removed. */
792 fromleaf
= FRAMELESS_FUNCTION_INVOCATION (next_frame
);
797 /* A frameless inner-most frame. The `FP' (which isn't an
798 architecture frame-pointer register!) of the caller is the same
800 /* FIXME: 2002-11-09: There isn't any reason to special case this
801 edge condition. Instead the per-architecture code should hande
803 base
= get_frame_base (next_frame
);
806 /* Two macros defined in tm.h specify the machine-dependent
807 actions to be performed here.
809 First, get the frame's chain-pointer.
811 If that is zero, the frame is the outermost frame or a leaf
812 called by the outermost frame. This means that if start
813 calls main without a frame, we'll return 0 (which is fine
816 Nope; there's a problem. This also returns when the current
817 routine is a leaf of main. This is unacceptable. We move
818 this to after the ffi test; I'd rather have backtraces from
819 start go curfluy than have an abort called from main not show
821 gdb_assert (DEPRECATED_FRAME_CHAIN_P ());
822 base
= DEPRECATED_FRAME_CHAIN (next_frame
);
824 if (!frame_chain_valid (base
, next_frame
))
830 /* FIXME: cagney/2002-06-08: This should probably return the frame's
831 function and not the PC (a.k.a. resume address). */
832 pc
= frame_pc_unwind (next_frame
);
833 (*id
) = frame_id_build (base
, pc
);
836 const struct frame_unwind legacy_saved_regs_unwinder
= {
837 /* Not really. It gets overridden by legacy_get_prev_frame. */
839 legacy_saved_regs_this_id
,
840 legacy_saved_regs_prev_register
842 const struct frame_unwind
*legacy_saved_regs_unwind
= &legacy_saved_regs_unwinder
;
845 /* Function: deprecated_generic_get_saved_register
846 Find register number REGNUM relative to FRAME and put its (raw,
847 target format) contents in *RAW_BUFFER.
849 Set *OPTIMIZED if the variable was optimized out (and thus can't be
850 fetched). Note that this is never set to anything other than zero
851 in this implementation.
853 Set *LVAL to lval_memory, lval_register, or not_lval, depending on
854 whether the value was fetched from memory, from a register, or in a
855 strange and non-modifiable way (e.g. a frame pointer which was
856 calculated rather than fetched). We will use not_lval for values
857 fetched from generic dummy frames.
859 Set *ADDRP to the address, either in memory or as a REGISTER_BYTE
860 offset into the registers array. If the value is stored in a dummy
861 frame, set *ADDRP to zero.
863 The argument RAW_BUFFER must point to aligned memory. */
866 deprecated_generic_get_saved_register (char *raw_buffer
, int *optimized
,
868 struct frame_info
*frame
, int regnum
,
869 enum lval_type
*lval
)
871 if (!target_has_registers
)
872 error ("No registers.");
874 gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
876 /* Normal systems don't optimize out things with register numbers. */
877 if (optimized
!= NULL
)
880 if (addrp
) /* default assumption: not found in memory */
883 /* Note: since the current frame's registers could only have been
884 saved by frames INTERIOR TO the current frame, we skip examining
885 the current frame itself: otherwise, we would be getting the
886 previous frame's registers which were saved by the current frame. */
890 for (frame
= get_next_frame (frame
);
891 frame_relative_level (frame
) >= 0;
892 frame
= get_next_frame (frame
))
894 if (get_frame_type (frame
) == DUMMY_FRAME
)
896 if (lval
) /* found it in a CALL_DUMMY frame */
899 /* FIXME: cagney/2002-06-26: This should be via the
900 gdbarch_register_read() method so that it, on the
901 fly, constructs either a raw or pseudo register
902 from the raw register cache. */
904 (generic_find_dummy_frame (get_frame_pc (frame
),
905 get_frame_base (frame
)),
910 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
911 if (get_frame_saved_regs (frame
) != NULL
912 && get_frame_saved_regs (frame
)[regnum
] != 0)
914 if (lval
) /* found it saved on the stack */
916 if (regnum
== SP_REGNUM
)
918 if (raw_buffer
) /* SP register treated specially */
919 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
920 get_frame_saved_regs (frame
)[regnum
]);
924 if (addrp
) /* any other register */
925 *addrp
= get_frame_saved_regs (frame
)[regnum
];
927 read_memory (get_frame_saved_regs (frame
)[regnum
], raw_buffer
,
928 REGISTER_RAW_SIZE (regnum
));
935 /* If we get thru the loop to this point, it means the register was
936 not saved in any frame. Return the actual live-register value. */
938 if (lval
) /* found it in a live register */
939 *lval
= lval_register
;
941 *addrp
= REGISTER_BYTE (regnum
);
943 deprecated_read_register_gen (regnum
, raw_buffer
);
946 /* Determine the frame's type based on its PC. */
948 static enum frame_type
949 frame_type_from_pc (CORE_ADDR pc
)
951 /* FIXME: cagney/2002-11-24: Can't yet directly call
952 pc_in_dummy_frame() as some architectures don't set
953 PC_IN_CALL_DUMMY() to generic_pc_in_call_dummy() (remember the
954 latter is implemented by simply calling pc_in_dummy_frame). */
955 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
956 && DEPRECATED_PC_IN_CALL_DUMMY (pc
, 0, 0))
961 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
962 if (PC_IN_SIGTRAMP (pc
, name
))
963 return SIGTRAMP_FRAME
;
969 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
970 Always returns a non-NULL value. */
973 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
975 struct frame_info
*fi
;
977 fi
= frame_obstack_zalloc (sizeof (struct frame_info
));
979 fi
->next
= create_sentinel_frame (current_regcache
);
981 /* Select/initialize both the unwind function and the frame's type
983 fi
->unwind
= frame_unwind_find_by_pc (current_gdbarch
, fi
->pc
);
984 if (fi
->unwind
->type
!= UNKNOWN_FRAME
)
985 fi
->type
= fi
->unwind
->type
;
987 fi
->type
= frame_type_from_pc (pc
);
989 deprecated_update_frame_base_hack (fi
, addr
);
990 deprecated_update_frame_pc_hack (fi
, pc
);
992 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
993 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, fi
);
998 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
999 innermost frame). Be careful to not fall off the bottom of the
1000 frame chain and onto the sentinel frame. */
1003 get_next_frame (struct frame_info
*this_frame
)
1005 if (this_frame
->level
> 0)
1006 return this_frame
->next
;
1011 /* Flush the entire frame cache. */
1014 flush_cached_frames (void)
1016 /* Since we can't really be sure what the first object allocated was */
1017 obstack_free (&frame_cache_obstack
, 0);
1018 obstack_init (&frame_cache_obstack
);
1020 current_frame
= NULL
; /* Invalidate cache */
1021 select_frame (NULL
);
1022 annotate_frames_invalid ();
1025 /* Flush the frame cache, and start a new one if necessary. */
1028 reinit_frame_cache (void)
1030 flush_cached_frames ();
1032 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
1033 if (PIDGET (inferior_ptid
) != 0)
1035 select_frame (get_current_frame ());
1039 /* Create the previous frame using the deprecated methods
1040 INIT_EXTRA_INFO, INIT_FRAME_PC and INIT_FRAME_PC_FIRST. */
1042 static struct frame_info
*
1043 legacy_get_prev_frame (struct frame_info
*this_frame
)
1045 CORE_ADDR address
= 0;
1046 struct frame_info
*prev
;
1049 /* Allocate the new frame.
1051 There is no reason to worry about memory leaks, should the
1052 remainder of the function fail. The allocated memory will be
1053 quickly reclaimed when the frame cache is flushed, and the `we've
1054 been here before' check, in get_prev_frame will stop repeated
1055 memory allocation calls. */
1056 prev
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1057 prev
->level
= this_frame
->level
+ 1;
1059 /* Do not completly wire it in to the frame chain. Some (bad) code
1060 in INIT_FRAME_EXTRA_INFO tries to look along frame->prev to pull
1061 some fancy tricks (of course such code is, by definition,
1064 On the other hand, methods, such as get_frame_pc() and
1065 get_frame_base() rely on being able to walk along the frame
1066 chain. Make certain that at least they work by providing that
1067 link. Of course things manipulating prev can't go back. */
1068 prev
->next
= this_frame
;
1070 /* NOTE: cagney/2002-11-18: Should have been correctly setting the
1071 frame's type here, before anything else, and not last, at the
1072 bottom of this function. The various
1073 DEPRECATED_INIT_EXTRA_FRAME_INFO, DEPRECATED_INIT_FRAME_PC,
1074 DEPRECATED_INIT_FRAME_PC_FIRST and
1075 DEPRECATED_FRAME_INIT_SAVED_REGS methods are full of work-arounds
1076 that handle the frame not being correctly set from the start.
1077 Unfortunatly those same work-arounds rely on the type defaulting
1078 to NORMAL_FRAME. Ulgh! The new frame code does not have this
1080 prev
->type
= UNKNOWN_FRAME
;
1082 /* A legacy frame's ID is always computed here. Mark it as valid. */
1085 /* Handle sentinel frame unwind as a special case. */
1086 if (this_frame
->level
< 0)
1088 /* Try to unwind the PC. If that doesn't work, assume we've reached
1089 the oldest frame and simply return. Is there a better sentinal
1090 value? The unwound PC value is then used to initialize the new
1091 previous frame's type.
1093 Note that the pc-unwind is intentionally performed before the
1094 frame chain. This is ok since, for old targets, both
1095 frame_pc_unwind (nee, DEPRECATED_FRAME_SAVED_PC) and
1096 DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
1097 have already been initialized (using
1098 DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
1101 By unwinding the PC first, it becomes possible to, in the case of
1102 a dummy frame, avoid also unwinding the frame ID. This is
1103 because (well ignoring the PPC) a dummy frame can be located
1104 using THIS_FRAME's frame ID. */
1106 deprecated_update_frame_pc_hack (prev
, frame_pc_unwind (this_frame
));
1107 if (get_frame_pc (prev
) == 0)
1109 /* The allocated PREV_FRAME will be reclaimed when the frame
1110 obstack is next purged. */
1112 fprintf_unfiltered (gdb_stdlog
,
1113 "Outermost frame - unwound PC zero\n");
1117 /* Set the unwind functions based on that identified PC. Ditto
1118 for the "type" but strongly prefer the unwinder's frame type. */
1119 prev
->unwind
= frame_unwind_find_by_pc (current_gdbarch
, prev
->pc
);
1120 if (prev
->unwind
->type
== UNKNOWN_FRAME
)
1121 prev
->type
= frame_type_from_pc (prev
->pc
);
1123 prev
->type
= prev
->unwind
->type
;
1125 /* Find the prev's frame's ID. */
1126 if (prev
->type
== DUMMY_FRAME
1127 && gdbarch_unwind_dummy_id_p (current_gdbarch
))
1129 /* When unwinding a normal frame, the stack structure is
1130 determined by analyzing the frame's function's code (be
1131 it using brute force prologue analysis, or the dwarf2
1132 CFI). In the case of a dummy frame, that simply isn't
1133 possible. The The PC is either the program entry point,
1134 or some random address on the stack. Trying to use that
1135 PC to apply standard frame ID unwind techniques is just
1136 asking for trouble. */
1137 /* Assume call_function_by_hand(), via SAVE_DUMMY_FRAME_TOS,
1138 previously saved the dummy frame's ID. Things only work
1139 if the two return the same value. */
1140 gdb_assert (SAVE_DUMMY_FRAME_TOS_P ());
1141 /* Use an architecture specific method to extract the prev's
1142 dummy ID from the next frame. Note that this method uses
1143 frame_register_unwind to obtain the register values
1144 needed to determine the dummy frame's ID. */
1145 prev
->id
= gdbarch_unwind_dummy_id (current_gdbarch
, this_frame
);
1149 /* We're unwinding a sentinel frame, the PC of which is
1150 pointing at a stack dummy. Fake up the dummy frame's ID
1151 using the same sequence as is found a traditional
1152 unwinder. Once all architectures supply the
1153 unwind_dummy_id method, this code can go away. */
1154 prev
->id
= frame_id_build (read_fp (), read_pc ());
1157 /* Check that the unwound ID is valid. */
1158 if (!frame_id_p (prev
->id
))
1161 fprintf_unfiltered (gdb_stdlog
,
1162 "Outermost legacy sentinel frame - unwound frame ID invalid\n");
1166 /* Check that the new frame isn't inner to (younger, below,
1167 next) the old frame. If that happens the frame unwind is
1169 /* FIXME: cagney/2003-02-25: Ignore the sentinel frame since
1170 that doesn't have a valid frame ID. Should instead set the
1171 sentinel frame's frame ID to a `sentinel'. Leave it until
1172 after the switch to storing the frame ID, instead of the
1173 frame base, in the frame object. */
1175 /* FIXME: cagney/2002-12-18: Instead of this hack, should only
1176 store the frame ID in PREV_FRAME. */
1177 /* FIXME: cagney/2003-04-04: Once ->frame is eliminated, this
1178 assignment can go. */
1179 prev
->frame
= prev
->id
.base
;
1182 this_frame
->prev
= prev
;
1184 /* FIXME: cagney/2002-01-19: This call will go away. Instead of
1185 initializing extra info, all frames will use the frame_cache
1186 (passed to the unwind functions) to store additional frame
1187 info. Unfortunatly legacy targets can't use
1188 legacy_get_prev_frame() to unwind the sentinel frame and,
1189 consequently, are forced to take this code path and rely on
1190 the below call to DEPRECATED_INIT_EXTRA_FRAME_INFO to
1191 initialize the inner-most frame. */
1192 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1194 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, prev
);
1199 /* This code only works on normal frames. A sentinel frame, where
1200 the level is -1, should never reach this code. */
1201 gdb_assert (this_frame
->level
>= 0);
1203 /* On some machines it is possible to call a function without
1204 setting up a stack frame for it. On these machines, we
1205 define this macro to take two args; a frameinfo pointer
1206 identifying a frame and a variable to set or clear if it is
1207 or isn't leafless. */
1209 /* Still don't want to worry about this except on the innermost
1210 frame. This macro will set FROMLEAF if THIS_FRAME is a frameless
1211 function invocation. */
1212 if (this_frame
->level
== 0)
1213 /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
1214 the frame chain, not just the inner most frame! The generic,
1215 per-architecture, frame code should handle this and the below
1216 should simply be removed. */
1217 fromleaf
= FRAMELESS_FUNCTION_INVOCATION (this_frame
);
1222 /* A frameless inner-most frame. The `FP' (which isn't an
1223 architecture frame-pointer register!) of the caller is the same
1225 /* FIXME: 2002-11-09: There isn't any reason to special case this
1226 edge condition. Instead the per-architecture code should hande
1228 address
= get_frame_base (this_frame
);
1231 /* Two macros defined in tm.h specify the machine-dependent
1232 actions to be performed here.
1234 First, get the frame's chain-pointer.
1236 If that is zero, the frame is the outermost frame or a leaf
1237 called by the outermost frame. This means that if start
1238 calls main without a frame, we'll return 0 (which is fine
1241 Nope; there's a problem. This also returns when the current
1242 routine is a leaf of main. This is unacceptable. We move
1243 this to after the ffi test; I'd rather have backtraces from
1244 start go curfluy than have an abort called from main not show
1246 gdb_assert (DEPRECATED_FRAME_CHAIN_P ());
1247 address
= DEPRECATED_FRAME_CHAIN (this_frame
);
1249 if (!frame_chain_valid (address
, this_frame
))
1255 /* Link in the already allocated prev frame. */
1256 this_frame
->prev
= prev
;
1257 deprecated_update_frame_base_hack (prev
, address
);
1259 /* This change should not be needed, FIXME! We should determine
1260 whether any targets *need* DEPRECATED_INIT_FRAME_PC to happen
1261 after DEPRECATED_INIT_EXTRA_FRAME_INFO and come up with a simple
1262 way to express what goes on here.
1264 DEPRECATED_INIT_EXTRA_FRAME_INFO is called from two places:
1265 create_new_frame (where the PC is already set up) and here (where
1266 it isn't). DEPRECATED_INIT_FRAME_PC is only called from here,
1267 always after DEPRECATED_INIT_EXTRA_FRAME_INFO.
1269 The catch is the MIPS, where DEPRECATED_INIT_EXTRA_FRAME_INFO
1270 requires the PC value (which hasn't been set yet). Some other
1271 machines appear to require DEPRECATED_INIT_EXTRA_FRAME_INFO
1272 before they can do DEPRECATED_INIT_FRAME_PC. Phoo.
1274 We shouldn't need DEPRECATED_INIT_FRAME_PC_FIRST to add more
1275 complication to an already overcomplicated part of GDB.
1276 gnu@cygnus.com, 15Sep92.
1278 Assuming that some machines need DEPRECATED_INIT_FRAME_PC after
1279 DEPRECATED_INIT_EXTRA_FRAME_INFO, one possible scheme:
1281 SETUP_INNERMOST_FRAME(): Default version is just create_new_frame
1282 (read_fp ()), read_pc ()). Machines with extra frame info would
1283 do that (or the local equivalent) and then set the extra fields.
1285 SETUP_ARBITRARY_FRAME(argc, argv): Only change here is that
1286 create_new_frame would no longer init extra frame info;
1287 SETUP_ARBITRARY_FRAME would have to do that.
1289 INIT_PREV_FRAME(fromleaf, prev) Replace
1290 DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC.
1291 This should also return a flag saying whether to keep the new
1292 frame, or whether to discard it, because on some machines (e.g.
1293 mips) it is really awkward to have DEPRECATED_FRAME_CHAIN_VALID
1294 called BEFORE DEPRECATED_INIT_EXTRA_FRAME_INFO (there is no good
1295 way to get information deduced in DEPRECATED_FRAME_CHAIN_VALID
1296 into the extra fields of the new frame). std_frame_pc(fromleaf,
1299 This is the default setting for INIT_PREV_FRAME. It just does
1300 what the default DEPRECATED_INIT_FRAME_PC does. Some machines
1301 will call it from INIT_PREV_FRAME (either at the beginning, the
1302 end, or in the middle). Some machines won't use it.
1304 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
1306 /* NOTE: cagney/2002-11-09: Just ignore the above! There is no
1307 reason for things to be this complicated.
1309 The trick is to assume that there is always a frame. Instead of
1310 special casing the inner-most frame, create fake frame
1311 (containing the hardware registers) that is inner to the
1312 user-visible inner-most frame (...) and then unwind from that.
1313 That way architecture code can use use the standard
1314 frame_XX_unwind() functions and not differentiate between the
1315 inner most and any other case.
1317 Since there is always a frame to unwind from, there is always
1318 somewhere (THIS_FRAME) to store all the info needed to construct
1319 a new (previous) frame without having to first create it. This
1320 means that the convolution below - needing to carefully order a
1321 frame's initialization - isn't needed.
1323 The irony here though, is that DEPRECATED_FRAME_CHAIN(), at least
1324 for a more up-to-date architecture, always calls
1325 FRAME_SAVED_PC(), and FRAME_SAVED_PC() computes the PC but
1326 without first needing the frame! Instead of the convolution
1327 below, we could have simply called FRAME_SAVED_PC() and been done
1328 with it! Note that FRAME_SAVED_PC() is being superseed by
1329 frame_pc_unwind() and that function does have somewhere to cache
1332 if (DEPRECATED_INIT_FRAME_PC_FIRST_P ())
1333 deprecated_update_frame_pc_hack (prev
,
1334 DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf
,
1337 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1338 DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf
, prev
);
1340 /* This entry is in the frame queue now, which is good since
1341 FRAME_SAVED_PC may use that queue to figure out its value (see
1342 tm-sparc.h). We want the pc saved in the inferior frame. */
1343 if (DEPRECATED_INIT_FRAME_PC_P ())
1344 deprecated_update_frame_pc_hack (prev
,
1345 DEPRECATED_INIT_FRAME_PC (fromleaf
,
1348 /* If ->frame and ->pc are unchanged, we are in the process of
1349 getting ourselves into an infinite backtrace. Some architectures
1350 check this in DEPRECATED_FRAME_CHAIN or thereabouts, but it seems
1351 like there is no reason this can't be an architecture-independent
1353 if (get_frame_base (prev
) == get_frame_base (this_frame
)
1354 && get_frame_pc (prev
) == get_frame_pc (this_frame
))
1356 this_frame
->prev
= NULL
;
1357 obstack_free (&frame_cache_obstack
, prev
);
1361 /* Initialize the code used to unwind the frame PREV based on the PC
1362 (and probably other architectural information). The PC lets you
1363 check things like the debug info at that point (dwarf2cfi?) and
1364 use that to decide how the frame should be unwound. */
1365 prev
->unwind
= frame_unwind_find_by_pc (current_gdbarch
,
1366 get_frame_pc (prev
));
1368 /* If the unwinder provides a frame type, use it. Otherwize
1369 continue on to that heuristic mess. */
1370 if (prev
->unwind
->type
!= UNKNOWN_FRAME
)
1372 prev
->type
= prev
->unwind
->type
;
1376 /* NOTE: cagney/2002-11-18: The code segments, found in
1377 create_new_frame and get_prev_frame(), that initializes the
1378 frames type is subtly different. The latter only updates ->type
1379 when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME. This stops
1380 get_prev_frame() overriding the frame's type when the INIT code
1381 has previously set it. This is really somewhat bogus. The
1382 initialization, as seen in create_new_frame(), should occur
1383 before the INIT function has been called. */
1384 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1385 && (DEPRECATED_PC_IN_CALL_DUMMY_P ()
1386 ? DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (prev
), 0, 0)
1387 : pc_in_dummy_frame (get_frame_pc (prev
))))
1388 prev
->type
= DUMMY_FRAME
;
1391 /* FIXME: cagney/2002-11-10: This should be moved to before the
1392 INIT code above so that the INIT code knows what the frame's
1393 type is (in fact, for a [generic] dummy-frame, the type can
1394 be set and then the entire initialization can be skipped.
1395 Unforunatly, its the INIT code that sets the PC (Hmm, catch
1398 find_pc_partial_function (get_frame_pc (prev
), &name
, NULL
, NULL
);
1399 if (PC_IN_SIGTRAMP (get_frame_pc (prev
), name
))
1400 prev
->type
= SIGTRAMP_FRAME
;
1401 /* FIXME: cagney/2002-11-11: Leave prev->type alone. Some
1402 architectures are forcing the frame's type in INIT so we
1403 don't want to override it here. Remember, NORMAL_FRAME == 0,
1404 so it all works (just :-/). Once this initialization is
1405 moved to the start of this function, all this nastness will
1412 /* Return a structure containing various interesting information
1413 about the frame that called THIS_FRAME. Returns NULL
1414 if there is no such frame. */
1417 get_prev_frame (struct frame_info
*this_frame
)
1419 struct frame_info
*prev_frame
;
1421 /* Return the inner-most frame, when the caller passes in NULL. */
1422 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1423 caller should have previously obtained a valid frame using
1424 get_selected_frame() and then called this code - only possibility
1425 I can think of is code behaving badly.
1427 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1428 block_innermost_frame(). It does the sequence: frame = NULL;
1429 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1430 it couldn't be written better, I don't know.
1432 NOTE: cagney/2003-01-11: I suspect what is happening is
1433 block_innermost_frame() is, when the target has no state
1434 (registers, memory, ...), still calling this function. The
1435 assumption being that this function will return NULL indicating
1436 that a frame isn't possible, rather than checking that the target
1437 has state and then calling get_current_frame() and
1438 get_prev_frame(). This is a guess mind. */
1439 if (this_frame
== NULL
)
1441 /* NOTE: cagney/2002-11-09: There was a code segment here that
1442 would error out when CURRENT_FRAME was NULL. The comment
1443 that went with it made the claim ...
1445 ``This screws value_of_variable, which just wants a nice
1446 clean NULL return from block_innermost_frame if there are no
1447 frames. I don't think I've ever seen this message happen
1448 otherwise. And returning NULL here is a perfectly legitimate
1451 Per the above, this code shouldn't even be called with a NULL
1453 return current_frame
;
1456 /* There is always a frame. If this assertion fails, suspect that
1457 something should be calling get_selected_frame() or
1458 get_current_frame(). */
1459 gdb_assert (this_frame
!= NULL
);
1461 if (this_frame
->level
>= 0
1462 && !backtrace_below_main
1463 && inside_main_func (get_frame_pc (this_frame
)))
1464 /* Don't unwind past main(), bug always unwind the sentinel frame.
1465 Note, this is done _before_ the frame has been marked as
1466 previously unwound. That way if the user later decides to
1467 allow unwinds past main(), that just happens. */
1470 fprintf_unfiltered (gdb_stdlog
,
1471 "Outermost frame - inside main func.\n");
1475 /* Only try to do the unwind once. */
1476 if (this_frame
->prev_p
)
1477 return this_frame
->prev
;
1478 this_frame
->prev_p
= 1;
1481 /* If we're inside the entry file, it isn't valid. Don't apply this
1482 test to a dummy frame - dummy frame PC's typically land in the
1483 entry file. Don't apply this test to the sentinel frame.
1484 Sentinel frames should always be allowed to unwind. */
1485 /* NOTE: drow/2002-12-25: should there be a way to disable this
1486 check? It assumes a single small entry file, and the way some
1487 debug readers (e.g. dbxread) figure out which object is the
1488 entry file is somewhat hokey. */
1489 /* NOTE: cagney/2003-01-10: If there is a way of disabling this test
1490 then it should probably be moved to before the ->prev_p test,
1492 /* NOTE: vinschen/2003-04-01: Disabled. It turns out that the call to
1493 inside_entry_file destroys a meaningful backtrace under some
1494 conditions. E. g. the backtrace tests in the asm-source testcase
1495 are broken for some targets. In this test the functions are all
1496 implemented as part of one file and the testcase is not necessarily
1497 linked with a start file (depending on the target). What happens is,
1498 that the first frame is printed normaly and following frames are
1499 treated as being inside the enttry file then. This way, only the
1500 #0 frame is printed in the backtrace output. */
1501 if (this_frame
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1502 && inside_entry_file (get_frame_pc (this_frame
)))
1505 fprintf_unfiltered (gdb_stdlog
,
1506 "Outermost frame - inside entry file\n");
1511 /* If we're already inside the entry function for the main objfile,
1512 then it isn't valid. Don't apply this test to a dummy frame -
1513 dummy frame PC's typically land in the entry func. Don't apply
1514 this test to the sentinel frame. Sentinel frames should always
1515 be allowed to unwind. */
1516 /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1517 hard evidence that this is needed. */
1519 && this_frame
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1520 && inside_entry_func (get_frame_pc (this_frame
)))
1523 fprintf_unfiltered (gdb_stdlog
,
1524 "Outermost frame - inside entry func\n");
1528 /* If any of the old frame initialization methods are around, use
1529 the legacy get_prev_frame method. */
1530 if (legacy_frame_p (current_gdbarch
))
1532 prev_frame
= legacy_get_prev_frame (this_frame
);
1533 if (frame_debug
&& prev_frame
== NULL
)
1534 fprintf_unfiltered (gdb_stdlog
,
1535 "Outermost frame - legacy_get_prev_frame NULL.\n");
1539 /* Check that this frame's ID was valid. If it wasn't, don't try to
1540 unwind to the prev frame. Be careful to not apply this test to
1541 the sentinel frame. */
1542 if (this_frame
->level
>= 0 && !frame_id_p (get_frame_id (this_frame
)))
1545 fprintf_filtered (gdb_stdlog
,
1546 "Outermost frame - this ID is NULL\n");
1550 /* Check that this frame's ID isn't inner to (younger, below, next)
1551 the next frame. This happens when frame unwind goes backwards.
1552 Since the sentinel frame isn't valid, don't apply this if this
1553 frame is entier the inner-most or sentinel frame. */
1554 if (this_frame
->level
> 0
1555 && frame_id_inner (get_frame_id (this_frame
),
1556 get_frame_id (this_frame
->next
)))
1557 error ("This frame inner-to next frame (corrupt stack?)");
1559 /* Check that this and the next frame are different. If they are
1560 not, there is most likely a stack cycle. As with the inner-than
1561 test, avoid the inner-most and sentinel frames. */
1562 /* FIXME: cagney/2003-03-17: Can't yet enable this this check. The
1563 frame_id_eq() method doesn't yet use function addresses when
1564 comparing frame IDs. */
1566 && this_frame
->level
> 0
1567 && frame_id_eq (get_frame_id (this_frame
),
1568 get_frame_id (this_frame
->next
)))
1569 error ("This frame identical to next frame (corrupt stack?)");
1571 /* Allocate the new frame but do not wire it in to the frame chain.
1572 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1573 frame->next to pull some fancy tricks (of course such code is, by
1574 definition, recursive). Try to prevent it.
1576 There is no reason to worry about memory leaks, should the
1577 remainder of the function fail. The allocated memory will be
1578 quickly reclaimed when the frame cache is flushed, and the `we've
1579 been here before' check above will stop repeated memory
1580 allocation calls. */
1581 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1582 prev_frame
->level
= this_frame
->level
+ 1;
1584 /* Try to unwind the PC. If that doesn't work, assume we've reached
1585 the oldest frame and simply return. Is there a better sentinal
1586 value? The unwound PC value is then used to initialize the new
1587 previous frame's type.
1589 Note that the pc-unwind is intentionally performed before the
1590 frame chain. This is ok since, for old targets, both
1591 frame_pc_unwind (nee, FRAME_SAVED_PC) and
1592 DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
1593 have already been initialized (using
1594 DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
1597 By unwinding the PC first, it becomes possible to, in the case of
1598 a dummy frame, avoid also unwinding the frame ID. This is
1599 because (well ignoring the PPC) a dummy frame can be located
1600 using THIS_FRAME's frame ID. */
1602 /* FIXME: cagney/2003-04-04: Once ->pc is eliminated, this
1603 assignment can go away. */
1604 prev_frame
->pc
= frame_pc_unwind (this_frame
);
1605 if (prev_frame
->pc
== 0)
1607 /* The allocated PREV_FRAME will be reclaimed when the frame
1608 obstack is next purged. */
1610 fprintf_unfiltered (gdb_stdlog
,
1611 "Outermost frame - unwound PC zero\n");
1615 /* Set the unwind functions based on that identified PC. */
1616 prev_frame
->unwind
= frame_unwind_find_by_pc (current_gdbarch
,
1619 /* FIXME: cagney/2003-04-02: Rather than storing the frame's type in
1620 the frame, the unwinder's type should be returned directly.
1621 Unfortunatly, legacy code, called by legacy_get_prev_frame,
1622 explicitly set the frames type using the method
1623 deprecated_set_frame_type(). */
1624 gdb_assert (prev_frame
->unwind
->type
!= UNKNOWN_FRAME
);
1625 prev_frame
->type
= prev_frame
->unwind
->type
;
1627 /* Can the frame's type and unwinder be computed on demand? That
1628 would make a frame's creation really really lite! */
1630 /* The prev's frame's ID is computed by demand in get_frame_id(). */
1632 /* The unwound frame ID is validate at the start of this function,
1633 as part of the logic to decide if that frame should be further
1634 unwound, and not here while the prev frame is being created.
1635 Doing this makes it possible for the user to examine a frame that
1636 has an invalid frame ID.
1638 The very old VAX frame_args_address_correct() method noted: [...]
1639 For the sake of argument, suppose that the stack is somewhat
1640 trashed (which is one reason that "info frame" exists). So,
1641 return 0 (indicating we don't know the address of the arglist) if
1642 we don't know what frame this frame calls. */
1645 this_frame
->prev
= prev_frame
;
1646 prev_frame
->next
= this_frame
;
1652 get_frame_pc (struct frame_info
*frame
)
1658 pc_notcurrent (struct frame_info
*frame
)
1660 /* If FRAME is not the innermost frame, that normally means that
1661 FRAME->pc points at the return instruction (which is *after* the
1662 call instruction), and we want to get the line containing the
1663 call (because the call is where the user thinks the program is).
1664 However, if the next frame is either a SIGTRAMP_FRAME or a
1665 DUMMY_FRAME, then the next frame will contain a saved interrupt
1666 PC and such a PC indicates the current (rather than next)
1667 instruction/line, consequently, for such cases, want to get the
1668 line containing fi->pc. */
1669 struct frame_info
*next
= get_next_frame (frame
);
1670 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1675 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1677 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
1680 /* Per "frame.h", return the ``address'' of the frame. Code should
1681 really be using get_frame_id(). */
1683 get_frame_base (struct frame_info
*fi
)
1687 /* HACK: Force the ID code to (indirectly) initialize the
1694 /* High-level offsets into the frame. Used by the debug info. */
1697 get_frame_base_address (struct frame_info
*fi
)
1699 if (get_frame_type (fi
) != NORMAL_FRAME
)
1701 if (fi
->base
== NULL
)
1702 fi
->base
= frame_base_find_by_pc (current_gdbarch
, get_frame_pc (fi
));
1703 /* Sneaky: If the low-level unwind and high-level base code share a
1704 common unwinder, let them share the prologue cache. */
1705 if (fi
->base
->unwind
== fi
->unwind
)
1706 return fi
->base
->this_base (fi
->next
, &fi
->prologue_cache
);
1707 return fi
->base
->this_base (fi
->next
, &fi
->base_cache
);
1711 get_frame_locals_address (struct frame_info
*fi
)
1714 if (get_frame_type (fi
) != NORMAL_FRAME
)
1716 /* If there isn't a frame address method, find it. */
1717 if (fi
->base
== NULL
)
1718 fi
->base
= frame_base_find_by_pc (current_gdbarch
, get_frame_pc (fi
));
1719 /* Sneaky: If the low-level unwind and high-level base code share a
1720 common unwinder, let them share the prologue cache. */
1721 if (fi
->base
->unwind
== fi
->unwind
)
1722 cache
= &fi
->prologue_cache
;
1724 cache
= &fi
->base_cache
;
1725 return fi
->base
->this_locals (fi
->next
, cache
);
1729 get_frame_args_address (struct frame_info
*fi
)
1732 if (get_frame_type (fi
) != NORMAL_FRAME
)
1734 /* If there isn't a frame address method, find it. */
1735 if (fi
->base
== NULL
)
1736 fi
->base
= frame_base_find_by_pc (current_gdbarch
, get_frame_pc (fi
));
1737 /* Sneaky: If the low-level unwind and high-level base code share a
1738 common unwinder, let them share the prologue cache. */
1739 if (fi
->base
->unwind
== fi
->unwind
)
1740 cache
= &fi
->prologue_cache
;
1742 cache
= &fi
->base_cache
;
1743 return fi
->base
->this_args (fi
->next
, cache
);
1746 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1747 or -1 for a NULL frame. */
1750 frame_relative_level (struct frame_info
*fi
)
1759 get_frame_type (struct frame_info
*frame
)
1761 /* Some targets still don't use [generic] dummy frames. Catch them
1763 if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1764 && deprecated_frame_in_dummy (frame
))
1766 if (frame
->type
== UNKNOWN_FRAME
)
1767 return NORMAL_FRAME
;
1773 deprecated_set_frame_type (struct frame_info
*frame
, enum frame_type type
)
1775 /* Arrrg! See comment in "frame.h". */
1779 struct frame_extra_info
*
1780 get_frame_extra_info (struct frame_info
*fi
)
1782 return fi
->extra_info
;
1785 struct frame_extra_info
*
1786 frame_extra_info_zalloc (struct frame_info
*fi
, long size
)
1788 fi
->extra_info
= frame_obstack_zalloc (size
);
1789 return fi
->extra_info
;
1793 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
1795 /* See comment in "frame.h". */
1797 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
1798 maintaining a locally allocated frame object. Since such frame's
1799 are not in the frame chain, it isn't possible to assume that the
1800 frame has a next. Sigh. */
1801 if (frame
->next
!= NULL
)
1803 /* While we're at it, update this frame's cached PC value, found
1804 in the next frame. Oh for the day when "struct frame_info"
1805 is opaque and this hack on hack can just go away. */
1806 frame
->next
->pc_unwind_cache
= pc
;
1807 frame
->next
->pc_unwind_cache_p
= 1;
1812 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
1814 /* See comment in "frame.h". */
1815 frame
->frame
= base
;
1819 deprecated_set_frame_saved_regs_hack (struct frame_info
*frame
,
1820 CORE_ADDR
*saved_regs
)
1822 frame
->saved_regs
= saved_regs
;
1826 deprecated_set_frame_extra_info_hack (struct frame_info
*frame
,
1827 struct frame_extra_info
*extra_info
)
1829 frame
->extra_info
= extra_info
;
1833 deprecated_set_frame_next_hack (struct frame_info
*fi
,
1834 struct frame_info
*next
)
1840 deprecated_set_frame_prev_hack (struct frame_info
*fi
,
1841 struct frame_info
*prev
)
1847 deprecated_get_frame_context (struct frame_info
*fi
)
1853 deprecated_set_frame_context (struct frame_info
*fi
,
1854 struct context
*context
)
1856 fi
->context
= context
;
1860 deprecated_frame_xmalloc (void)
1862 struct frame_info
*frame
= XMALLOC (struct frame_info
);
1863 memset (frame
, 0, sizeof (struct frame_info
));
1868 deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs
,
1869 long sizeof_extra_info
)
1871 struct frame_info
*frame
= deprecated_frame_xmalloc ();
1872 make_cleanup (xfree
, frame
);
1873 if (sizeof_saved_regs
> 0)
1875 frame
->saved_regs
= xcalloc (1, sizeof_saved_regs
);
1876 make_cleanup (xfree
, frame
->saved_regs
);
1878 if (sizeof_extra_info
> 0)
1880 frame
->extra_info
= xcalloc (1, sizeof_extra_info
);
1881 make_cleanup (xfree
, frame
->extra_info
);
1887 legacy_frame_p (struct gdbarch
*current_gdbarch
)
1889 return (DEPRECATED_INIT_FRAME_PC_P ()
1890 || DEPRECATED_INIT_FRAME_PC_FIRST_P ()
1891 || DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()
1892 || DEPRECATED_FRAME_CHAIN_P ()
1893 || !gdbarch_unwind_dummy_id_p (current_gdbarch
)
1894 || !SAVE_DUMMY_FRAME_TOS_P ());
1898 _initialize_frame (void)
1900 obstack_init (&frame_cache_obstack
);
1902 /* FIXME: cagney/2003-01-19: This command needs a rename. Suggest
1903 `set backtrace {past,beyond,...}-main'. Also suggest adding `set
1904 backtrace ...-start' to control backtraces past start. The
1905 problem with `below' is that it stops the `up' command. */
1907 add_setshow_boolean_cmd ("backtrace-below-main", class_obscure
,
1908 &backtrace_below_main
, "\
1909 Set whether backtraces should continue past \"main\".\n\
1910 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1911 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1912 of the stack trace.", "\
1913 Show whether backtraces should continue past \"main\".\n\
1914 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
1915 the backtrace at \"main\". Set this variable if you need to see the rest\n\
1916 of the stack trace.",
1917 NULL
, NULL
, &setlist
, &showlist
);
1920 /* Debug this files internals. */
1921 add_show_from_set (add_set_cmd ("frame", class_maintenance
, var_zinteger
,
1922 &frame_debug
, "Set frame debugging.\n\
1923 When non-zero, frame specific internal debugging is enabled.", &setdebuglist
),