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, 2004 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 "user-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"
44 static struct frame_info
*get_prev_frame_1 (struct frame_info
*this_frame
);
46 /* We keep a cache of stack frames, each of which is a "struct
47 frame_info". The innermost one gets allocated (in
48 wait_for_inferior) each time the inferior stops; current_frame
49 points to it. Additional frames get allocated (in get_prev_frame)
50 as needed, and are chained through the next and prev fields. Any
51 time that the frame cache becomes invalid (most notably when we
52 execute something, but also if we change how we interpret the
53 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
54 which reads new symbols)), we should call reinit_frame_cache. */
58 /* Level of this frame. The inner-most (youngest) frame is at level
59 0. As you move towards the outer-most (oldest) frame, the level
60 increases. This is a cached value. It could just as easily be
61 computed by counting back from the selected frame to the inner
63 /* NOTE: cagney/2002-04-05: Perhaps a level of ``-1'' should be
64 reserved to indicate a bogus frame - one that has been created
65 just to keep GDB happy (GDB always needs a frame). For the
66 moment leave this as speculation. */
69 /* The frame's type. */
70 /* FIXME: cagney/2004-05-01: Should instead just use ->unwind->type.
71 Unfortunately, legacy_get_prev_frame is still explicitly setting
72 the type. Eliminate that method and this field can be
76 /* For each register, address of where it was saved on entry to the
77 frame, or zero if it was not saved on entry to this frame. This
78 includes special registers such as pc and fp saved in special
79 ways in the stack frame. The SP_REGNUM is even more special, the
80 address here is the sp for the previous frame, not the address
81 where the sp was saved. */
82 /* Allocated by frame_saved_regs_zalloc () which is called /
83 initialized by DEPRECATED_FRAME_INIT_SAVED_REGS(). */
84 CORE_ADDR
*saved_regs
; /*NUM_REGS + NUM_PSEUDO_REGS*/
86 /* Anything extra for this structure that may have been defined in
87 the machine dependent files. */
88 /* Allocated by frame_extra_info_zalloc () which is called /
89 initialized by DEPRECATED_INIT_EXTRA_FRAME_INFO */
90 struct frame_extra_info
*extra_info
;
92 /* The frame's low-level unwinder and corresponding cache. The
93 low-level unwinder is responsible for unwinding register values
94 for the previous frame. The low-level unwind methods are
95 selected based on the presence, or otherwise, of register unwind
96 information such as CFI. */
98 const struct frame_unwind
*unwind
;
100 /* Cached copy of the previous frame's resume address. */
106 /* Cached copy of the previous frame's function address. */
113 /* This frame's ID. */
117 struct frame_id value
;
120 /* The frame's high-level base methods, and corresponding cache.
121 The high level base methods are selected based on the frame's
123 const struct frame_base
*base
;
126 /* Pointers to the next (down, inner, younger) and previous (up,
127 outer, older) frame_info's in the frame cache. */
128 struct frame_info
*next
; /* down, inner, younger */
130 struct frame_info
*prev
; /* up, outer, older */
133 /* Flag to control debugging. */
135 static int frame_debug
;
137 /* Flag to indicate whether backtraces should stop at main et.al. */
139 static int backtrace_past_main
;
140 static unsigned int backtrace_limit
= UINT_MAX
;
144 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
146 fprintf_unfiltered (file
, "{stack=0x%s,code=0x%s,special=0x%s}",
147 paddr_nz (id
.stack_addr
),
148 paddr_nz (id
.code_addr
),
149 paddr_nz (id
.special_addr
));
153 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
158 fprintf_unfiltered (file
, "UNKNOWN_FRAME");
161 fprintf_unfiltered (file
, "NORMAL_FRAME");
164 fprintf_unfiltered (file
, "DUMMY_FRAME");
167 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
170 fprintf_unfiltered (file
, "<unknown type>");
176 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
180 fprintf_unfiltered (file
, "<NULL frame>");
183 fprintf_unfiltered (file
, "{");
184 fprintf_unfiltered (file
, "level=%d", fi
->level
);
185 fprintf_unfiltered (file
, ",");
186 fprintf_unfiltered (file
, "type=");
187 fprint_frame_type (file
, fi
->type
);
188 fprintf_unfiltered (file
, ",");
189 fprintf_unfiltered (file
, "unwind=");
190 if (fi
->unwind
!= NULL
)
191 gdb_print_host_address (fi
->unwind
, file
);
193 fprintf_unfiltered (file
, "<unknown>");
194 fprintf_unfiltered (file
, ",");
195 fprintf_unfiltered (file
, "pc=");
196 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
197 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_pc
.value
));
199 fprintf_unfiltered (file
, "<unknown>");
200 fprintf_unfiltered (file
, ",");
201 fprintf_unfiltered (file
, "id=");
203 fprint_frame_id (file
, fi
->this_id
.value
);
205 fprintf_unfiltered (file
, "<unknown>");
206 fprintf_unfiltered (file
, ",");
207 fprintf_unfiltered (file
, "func=");
208 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
209 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_func
.addr
));
211 fprintf_unfiltered (file
, "<unknown>");
212 fprintf_unfiltered (file
, "}");
215 /* Return a frame uniq ID that can be used to, later, re-find the
219 get_frame_id (struct frame_info
*fi
)
223 return null_frame_id
;
227 gdb_assert (!legacy_frame_p (current_gdbarch
));
229 fprintf_unfiltered (gdb_stdlog
, "{ get_frame_id (fi=%d) ",
231 /* Find the unwinder. */
232 if (fi
->unwind
== NULL
)
234 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
,
235 &fi
->prologue_cache
);
236 /* FIXME: cagney/2004-05-01: Should instead just use
237 ->unwind->type. Unfortunately, legacy_get_prev_frame is
238 still explicitly setting the type. Eliminate that method
239 and this field can be eliminated. */
240 fi
->type
= fi
->unwind
->type
;
242 /* Find THIS frame's ID. */
243 fi
->unwind
->this_id (fi
->next
, &fi
->prologue_cache
, &fi
->this_id
.value
);
247 fprintf_unfiltered (gdb_stdlog
, "-> ");
248 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
249 fprintf_unfiltered (gdb_stdlog
, " }\n");
252 return fi
->this_id
.value
;
256 frame_unwind_id (struct frame_info
*next_frame
)
258 /* Use prev_frame, and not get_prev_frame. The latter will truncate
259 the frame chain, leading to this function unintentionally
260 returning a null_frame_id (e.g., when a caller requests the frame
261 ID of "main()"s caller. */
262 return get_frame_id (get_prev_frame_1 (next_frame
));
265 const struct frame_id null_frame_id
; /* All zeros. */
268 frame_id_build_special (CORE_ADDR stack_addr
, CORE_ADDR code_addr
,
269 CORE_ADDR special_addr
)
272 id
.stack_addr
= stack_addr
;
273 id
.code_addr
= code_addr
;
274 id
.special_addr
= special_addr
;
279 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
281 return frame_id_build_special (stack_addr
, code_addr
, 0);
285 frame_id_p (struct frame_id l
)
288 /* The .code can be NULL but the .stack cannot. */
289 p
= (l
.stack_addr
!= 0);
292 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
293 fprint_frame_id (gdb_stdlog
, l
);
294 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
300 frame_id_eq (struct frame_id l
, struct frame_id r
)
303 if (l
.stack_addr
== 0 || r
.stack_addr
== 0)
304 /* Like a NaN, if either ID is invalid, the result is false. */
306 else if (l
.stack_addr
!= r
.stack_addr
)
307 /* If .stack addresses are different, the frames are different. */
309 else if (l
.code_addr
== 0 || r
.code_addr
== 0)
310 /* A zero code addr is a wild card, always succeed. */
312 else if (l
.code_addr
!= r
.code_addr
)
313 /* If .code addresses are different, the frames are different. */
315 else if (l
.special_addr
== 0 || r
.special_addr
== 0)
316 /* A zero special addr is a wild card (or unused), always succeed. */
318 else if (l
.special_addr
== r
.special_addr
)
319 /* Frames are equal. */
326 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
327 fprint_frame_id (gdb_stdlog
, l
);
328 fprintf_unfiltered (gdb_stdlog
, ",r=");
329 fprint_frame_id (gdb_stdlog
, r
);
330 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
336 frame_id_inner (struct frame_id l
, struct frame_id r
)
339 if (l
.stack_addr
== 0 || r
.stack_addr
== 0)
340 /* Like NaN, any operation involving an invalid ID always fails. */
343 /* Only return non-zero when strictly inner than. Note that, per
344 comment in "frame.h", there is some fuzz here. Frameless
345 functions are not strictly inner than (same .stack but
346 different .code and/or .special address). */
347 inner
= INNER_THAN (l
.stack_addr
, r
.stack_addr
);
350 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
351 fprint_frame_id (gdb_stdlog
, l
);
352 fprintf_unfiltered (gdb_stdlog
, ",r=");
353 fprint_frame_id (gdb_stdlog
, r
);
354 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
360 frame_find_by_id (struct frame_id id
)
362 struct frame_info
*frame
;
364 /* ZERO denotes the null frame, let the caller decide what to do
365 about it. Should it instead return get_current_frame()? */
366 if (!frame_id_p (id
))
369 for (frame
= get_current_frame ();
371 frame
= get_prev_frame (frame
))
373 struct frame_id
this = get_frame_id (frame
);
374 if (frame_id_eq (id
, this))
375 /* An exact match. */
377 if (frame_id_inner (id
, this))
380 /* Either we're not yet gone far enough out along the frame
381 chain (inner(this,id)), or we're comparing frameless functions
382 (same .base, different .func, no test available). Struggle
383 on until we've definitly gone to far. */
389 frame_pc_unwind (struct frame_info
*this_frame
)
391 if (!this_frame
->prev_pc
.p
)
394 if (gdbarch_unwind_pc_p (current_gdbarch
))
396 /* The right way. The `pure' way. The one true way. This
397 method depends solely on the register-unwind code to
398 determine the value of registers in THIS frame, and hence
399 the value of this frame's PC (resume address). A typical
400 implementation is no more than:
402 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
403 return extract_unsigned_integer (buf, size of ISA_PC_REGNUM);
405 Note: this method is very heavily dependent on a correct
406 register-unwind implementation, it pays to fix that
407 method first; this method is frame type agnostic, since
408 it only deals with register values, it works with any
409 frame. This is all in stark contrast to the old
410 FRAME_SAVED_PC which would try to directly handle all the
411 different ways that a PC could be unwound. */
412 pc
= gdbarch_unwind_pc (current_gdbarch
, this_frame
);
414 else if (this_frame
->level
< 0)
416 /* FIXME: cagney/2003-03-06: Old code and a sentinel
417 frame. Do like was always done. Fetch the PC's value
418 directly from the global registers array (via read_pc).
419 This assumes that this frame belongs to the current
420 global register cache. The assumption is dangerous. */
423 else if (DEPRECATED_FRAME_SAVED_PC_P ())
425 /* FIXME: cagney/2003-03-06: Old code, but not a sentinel
426 frame. Do like was always done. Note that this method,
427 unlike unwind_pc(), tries to handle all the different
428 frame cases directly. It fails. */
429 pc
= DEPRECATED_FRAME_SAVED_PC (this_frame
);
432 internal_error (__FILE__
, __LINE__
, "No gdbarch_unwind_pc method");
433 this_frame
->prev_pc
.value
= pc
;
434 this_frame
->prev_pc
.p
= 1;
436 fprintf_unfiltered (gdb_stdlog
,
437 "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
439 paddr_nz (this_frame
->prev_pc
.value
));
441 return this_frame
->prev_pc
.value
;
445 frame_func_unwind (struct frame_info
*fi
)
447 if (!fi
->prev_func
.p
)
449 /* Make certain that this, and not the adjacent, function is
451 CORE_ADDR addr_in_block
= frame_unwind_address_in_block (fi
);
453 fi
->prev_func
.addr
= get_pc_function_start (addr_in_block
);
455 fprintf_unfiltered (gdb_stdlog
,
456 "{ frame_func_unwind (fi=%d) -> 0x%s }\n",
457 fi
->level
, paddr_nz (fi
->prev_func
.addr
));
459 return fi
->prev_func
.addr
;
463 get_frame_func (struct frame_info
*fi
)
465 return frame_func_unwind (fi
->next
);
469 do_frame_unwind_register (void *src
, int regnum
, void *buf
)
471 frame_unwind_register (src
, regnum
, buf
);
476 frame_pop (struct frame_info
*this_frame
)
478 struct regcache
*scratch_regcache
;
479 struct cleanup
*cleanups
;
481 if (DEPRECATED_POP_FRAME_P ())
483 /* A legacy architecture that has implemented a custom pop
484 function. All new architectures should instead be using the
485 generic code below. */
486 DEPRECATED_POP_FRAME
;
490 /* Make a copy of all the register values unwound from this
491 frame. Save them in a scratch buffer so that there isn't a
492 race between trying to extract the old values from the
493 current_regcache while at the same time writing new values
494 into that same cache. */
495 struct regcache
*scratch
= regcache_xmalloc (current_gdbarch
);
496 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (scratch
);
497 regcache_save (scratch
, do_frame_unwind_register
, this_frame
);
498 /* FIXME: cagney/2003-03-16: It should be possible to tell the
499 target's register cache that it is about to be hit with a
500 burst register transfer and that the sequence of register
501 writes should be batched. The pair target_prepare_to_store()
502 and target_store_registers() kind of suggest this
503 functionality. Unfortunately, they don't implement it. Their
504 lack of a formal definition can lead to targets writing back
505 bogus values (arguably a bug in the target code mind). */
506 /* Now copy those saved registers into the current regcache.
507 Here, regcache_cpy() calls regcache_restore(). */
508 regcache_cpy (current_regcache
, scratch
);
509 do_cleanups (cleanups
);
511 /* We've made right mess of GDB's local state, just discard
513 flush_cached_frames ();
517 frame_register_unwind (struct frame_info
*frame
, int regnum
,
518 int *optimizedp
, enum lval_type
*lvalp
,
519 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
521 struct frame_unwind_cache
*cache
;
525 fprintf_unfiltered (gdb_stdlog
, "\
526 { frame_register_unwind (frame=%d,regnum=%d(%s),...) ",
527 frame
->level
, regnum
,
528 frame_map_regnum_to_name (frame
, regnum
));
531 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
532 that the value proper does not need to be fetched. */
533 gdb_assert (optimizedp
!= NULL
);
534 gdb_assert (lvalp
!= NULL
);
535 gdb_assert (addrp
!= NULL
);
536 gdb_assert (realnump
!= NULL
);
537 /* gdb_assert (bufferp != NULL); */
539 /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
540 is broken. There is always a frame. If there, for some reason,
541 isn't a frame, there is some pretty busted code as it should have
542 detected the problem before calling here. */
543 gdb_assert (frame
!= NULL
);
545 /* Find the unwinder. */
546 if (frame
->unwind
== NULL
)
548 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
549 &frame
->prologue_cache
);
550 /* FIXME: cagney/2004-05-01: Should instead just use ->unwind->type.
551 Unfortunately, legacy_get_prev_frame is still explicitly setting
552 the type. Eliminate that method and this field can be
554 frame
->type
= frame
->unwind
->type
;
557 /* Ask this frame to unwind its register. See comment in
558 "frame-unwind.h" for why NEXT frame and this unwind cache are
560 frame
->unwind
->prev_register (frame
->next
, &frame
->prologue_cache
, regnum
,
561 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
565 fprintf_unfiltered (gdb_stdlog
, "->");
566 fprintf_unfiltered (gdb_stdlog
, " *optimizedp=%d", (*optimizedp
));
567 fprintf_unfiltered (gdb_stdlog
, " *lvalp=%d", (int) (*lvalp
));
568 fprintf_unfiltered (gdb_stdlog
, " *addrp=0x%s", paddr_nz ((*addrp
)));
569 fprintf_unfiltered (gdb_stdlog
, " *bufferp=");
571 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
575 const unsigned char *buf
= bufferp
;
576 fprintf_unfiltered (gdb_stdlog
, "[");
577 for (i
= 0; i
< register_size (current_gdbarch
, regnum
); i
++)
578 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
579 fprintf_unfiltered (gdb_stdlog
, "]");
581 fprintf_unfiltered (gdb_stdlog
, " }\n");
586 frame_register (struct frame_info
*frame
, int regnum
,
587 int *optimizedp
, enum lval_type
*lvalp
,
588 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
590 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
591 that the value proper does not need to be fetched. */
592 gdb_assert (optimizedp
!= NULL
);
593 gdb_assert (lvalp
!= NULL
);
594 gdb_assert (addrp
!= NULL
);
595 gdb_assert (realnump
!= NULL
);
596 /* gdb_assert (bufferp != NULL); */
598 /* Ulgh! Old code that, for lval_register, sets ADDRP to the offset
599 of the register in the register cache. It should instead return
600 the REGNUM corresponding to that register. Translate the . */
601 if (DEPRECATED_GET_SAVED_REGISTER_P ())
603 DEPRECATED_GET_SAVED_REGISTER (bufferp
, optimizedp
, addrp
, frame
,
605 /* Compute the REALNUM if the caller wants it. */
606 if (*lvalp
== lval_register
)
609 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
611 if (*addrp
== register_offset_hack (current_gdbarch
, regnum
))
617 internal_error (__FILE__
, __LINE__
,
618 "Failed to compute the register number corresponding"
619 " to 0x%s", paddr_d (*addrp
));
625 /* Obtain the register value by unwinding the register from the next
626 (more inner frame). */
627 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
628 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
633 frame_unwind_register (struct frame_info
*frame
, int regnum
, void *buf
)
639 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
644 get_frame_register (struct frame_info
*frame
,
645 int regnum
, void *buf
)
647 frame_unwind_register (frame
->next
, regnum
, buf
);
651 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
653 char buf
[MAX_REGISTER_SIZE
];
654 frame_unwind_register (frame
, regnum
, buf
);
655 return extract_signed_integer (buf
, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum
));
659 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
661 return frame_unwind_register_signed (frame
->next
, regnum
);
665 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
667 char buf
[MAX_REGISTER_SIZE
];
668 frame_unwind_register (frame
, regnum
, buf
);
669 return extract_unsigned_integer (buf
, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum
));
673 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
675 return frame_unwind_register_unsigned (frame
->next
, regnum
);
679 frame_unwind_unsigned_register (struct frame_info
*frame
, int regnum
,
682 char buf
[MAX_REGISTER_SIZE
];
683 frame_unwind_register (frame
, regnum
, buf
);
684 (*val
) = extract_unsigned_integer (buf
, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum
));
688 put_frame_register (struct frame_info
*frame
, int regnum
, const void *buf
)
690 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
695 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, NULL
);
697 error ("Attempt to assign to a value that was optimized out.");
702 /* FIXME: write_memory doesn't yet take constant buffers.
704 char tmp
[MAX_REGISTER_SIZE
];
705 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
706 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
710 regcache_cooked_write (current_regcache
, realnum
, buf
);
713 error ("Attempt to assign to an unmodifiable value.");
717 /* frame_register_read ()
719 Find and return the value of REGNUM for the specified stack frame.
720 The number of bytes copied is DEPRECATED_REGISTER_RAW_SIZE
723 Returns 0 if the register value could not be found. */
726 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
732 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
734 /* FIXME: cagney/2002-05-15: This test is just bogus.
736 It indicates that the target failed to supply a value for a
737 register because it was "not available" at this time. Problem
738 is, the target still has the register and so get saved_register()
739 may be returning a value saved on the stack. */
741 if (register_cached (regnum
) < 0)
742 return 0; /* register value not available */
748 /* Map between a frame register number and its name. A frame register
749 space is a superset of the cooked register space --- it also
750 includes builtin registers. */
753 frame_map_name_to_regnum (struct frame_info
*frame
, const char *name
, int len
)
755 return user_reg_map_name_to_regnum (get_frame_arch (frame
), name
, len
);
759 frame_map_regnum_to_name (struct frame_info
*frame
, int regnum
)
761 return user_reg_map_regnum_to_name (get_frame_arch (frame
), regnum
);
764 /* Create a sentinel frame. */
766 static struct frame_info
*
767 create_sentinel_frame (struct regcache
*regcache
)
769 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
770 frame
->type
= SENTINEL_FRAME
;
772 /* Explicitly initialize the sentinel frame's cache. Provide it
773 with the underlying regcache. In the future additional
774 information, such as the frame's thread will be added. */
775 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
776 /* For the moment there is only one sentinel frame implementation. */
777 frame
->unwind
= sentinel_frame_unwind
;
778 /* Link this frame back to itself. The frame is self referential
779 (the unwound PC is the same as the pc), so make it so. */
781 /* Make the sentinel frame's ID valid, but invalid. That way all
782 comparisons with it should fail. */
783 frame
->this_id
.p
= 1;
784 frame
->this_id
.value
= null_frame_id
;
787 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
788 fprint_frame (gdb_stdlog
, frame
);
789 fprintf_unfiltered (gdb_stdlog
, " }\n");
794 /* Info about the innermost stack frame (contents of FP register) */
796 static struct frame_info
*current_frame
;
798 /* Cache for frame addresses already read by gdb. Valid only while
799 inferior is stopped. Control variables for the frame cache should
800 be local to this module. */
802 static struct obstack frame_cache_obstack
;
805 frame_obstack_zalloc (unsigned long size
)
807 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
808 memset (data
, 0, size
);
813 frame_saved_regs_zalloc (struct frame_info
*fi
)
815 fi
->saved_regs
= (CORE_ADDR
*)
816 frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
817 return fi
->saved_regs
;
821 deprecated_get_frame_saved_regs (struct frame_info
*fi
)
823 return fi
->saved_regs
;
826 /* Return the innermost (currently executing) stack frame. This is
827 split into two functions. The function unwind_to_current_frame()
828 is wrapped in catch exceptions so that, even when the unwind of the
829 sentinel frame fails, the function still returns a stack frame. */
832 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
834 struct frame_info
*frame
= get_prev_frame (args
);
835 /* A sentinel frame can fail to unwind, e.g., because its PC value
836 lands in somewhere like start. */
839 current_frame
= frame
;
844 get_current_frame (void)
846 /* First check, and report, the lack of registers. Having GDB
847 report "No stack!" or "No memory" when the target doesn't even
848 have registers is very confusing. Besides, "printcmd.exp"
849 explicitly checks that ``print $pc'' with no registers prints "No
851 if (!target_has_registers
)
852 error ("No registers.");
853 if (!target_has_stack
)
855 if (!target_has_memory
)
856 error ("No memory.");
857 if (current_frame
== NULL
)
859 struct frame_info
*sentinel_frame
=
860 create_sentinel_frame (current_regcache
);
861 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
862 NULL
, RETURN_MASK_ERROR
) != 0)
864 /* Oops! Fake a current frame? Is this useful? It has a PC
865 of zero, for instance. */
866 current_frame
= sentinel_frame
;
869 return current_frame
;
872 /* The "selected" stack frame is used by default for local and arg
873 access. May be zero, for no selected frame. */
875 struct frame_info
*deprecated_selected_frame
;
877 /* Return the selected frame. Always non-NULL (unless there isn't an
878 inferior sufficient for creating a frame) in which case an error is
882 get_selected_frame (void)
884 if (deprecated_selected_frame
== NULL
)
885 /* Hey! Don't trust this. It should really be re-finding the
886 last selected frame of the currently selected thread. This,
887 though, is better than nothing. */
888 select_frame (get_current_frame ());
889 /* There is always a frame. */
890 gdb_assert (deprecated_selected_frame
!= NULL
);
891 return deprecated_selected_frame
;
894 /* This is a variant of get_selected_frame() which can be called when
895 the inferior does not have a frame; in that case it will return
896 NULL instead of calling error(). */
899 deprecated_safe_get_selected_frame (void)
901 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
903 return get_selected_frame ();
906 /* Select frame FI (or NULL - to invalidate the current frame). */
909 select_frame (struct frame_info
*fi
)
913 deprecated_selected_frame
= fi
;
914 /* NOTE: cagney/2002-05-04: FI can be NULL. This occurs when the
915 frame is being invalidated. */
916 if (deprecated_selected_frame_level_changed_hook
)
917 deprecated_selected_frame_level_changed_hook (frame_relative_level (fi
));
919 /* FIXME: kseitz/2002-08-28: It would be nice to call
920 selected_frame_level_changed_event() right here, but due to limitations
921 in the current interfaces, we would end up flooding UIs with events
922 because select_frame() is used extensively internally.
924 Once we have frame-parameterized frame (and frame-related) commands,
925 the event notification can be moved here, since this function will only
926 be called when the user's selected frame is being changed. */
928 /* Ensure that symbols for this frame are read in. Also, determine the
929 source language of this frame, and switch to it if desired. */
932 /* We retrieve the frame's symtab by using the frame PC. However
933 we cannot use the frame PC as-is, because it usually points to
934 the instruction following the "call", which is sometimes the
935 first instruction of another function. So we rely on
936 get_frame_address_in_block() which provides us with a PC which
937 is guaranteed to be inside the frame's code block. */
938 s
= find_pc_symtab (get_frame_address_in_block (fi
));
940 && s
->language
!= current_language
->la_language
941 && s
->language
!= language_unknown
942 && language_mode
== language_mode_auto
)
944 set_language (s
->language
);
949 /* Return the register saved in the simplistic ``saved_regs'' cache.
950 If the value isn't here AND a value is needed, try the next inner
954 legacy_saved_regs_prev_register (struct frame_info
*next_frame
,
955 void **this_prologue_cache
,
956 int regnum
, int *optimizedp
,
957 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
958 int *realnump
, void *bufferp
)
960 /* HACK: New code is passed the next frame and this cache.
961 Unfortunately, old code expects this frame. Since this is a
962 backward compatibility hack, cheat by walking one level along the
963 prologue chain to the frame the old code expects.
965 Do not try this at home. Professional driver, closed course. */
966 struct frame_info
*frame
= next_frame
->prev
;
967 gdb_assert (frame
!= NULL
);
969 if (deprecated_get_frame_saved_regs (frame
) == NULL
)
971 /* If nothing has initialized the saved regs, do it now. */
972 gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
973 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
974 gdb_assert (deprecated_get_frame_saved_regs (frame
) != NULL
);
977 if (deprecated_get_frame_saved_regs (frame
) != NULL
978 && deprecated_get_frame_saved_regs (frame
)[regnum
] != 0)
980 if (regnum
== SP_REGNUM
)
982 /* SP register treated specially. */
988 /* NOTE: cagney/2003-05-09: In-lined store_address() with
989 it's body - store_unsigned_integer(). */
990 store_unsigned_integer (bufferp
, DEPRECATED_REGISTER_RAW_SIZE (regnum
),
991 deprecated_get_frame_saved_regs (frame
)[regnum
]);
995 /* Any other register is saved in memory, fetch it but cache
996 a local copy of its value. */
998 *lvalp
= lval_memory
;
999 *addrp
= deprecated_get_frame_saved_regs (frame
)[regnum
];
1001 if (bufferp
!= NULL
)
1004 /* Save each register value, as it is read in, in a
1005 frame based cache. */
1006 void **regs
= (*this_prologue_cache
);
1009 int sizeof_cache
= ((NUM_REGS
+ NUM_PSEUDO_REGS
)
1011 regs
= frame_obstack_zalloc (sizeof_cache
);
1012 (*this_prologue_cache
) = regs
;
1014 if (regs
[regnum
] == NULL
)
1017 = frame_obstack_zalloc (DEPRECATED_REGISTER_RAW_SIZE (regnum
));
1018 read_memory (deprecated_get_frame_saved_regs (frame
)[regnum
], regs
[regnum
],
1019 DEPRECATED_REGISTER_RAW_SIZE (regnum
));
1021 memcpy (bufferp
, regs
[regnum
], DEPRECATED_REGISTER_RAW_SIZE (regnum
));
1023 /* Read the value in from memory. */
1024 read_memory (deprecated_get_frame_saved_regs (frame
)[regnum
], bufferp
,
1025 DEPRECATED_REGISTER_RAW_SIZE (regnum
));
1032 /* No luck. Assume this and the next frame have the same register
1033 value. Pass the unwind request down the frame chain to the next
1034 frame. Hopefully that frame will find the register's location. */
1035 frame_register_unwind (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1040 legacy_saved_regs_this_id (struct frame_info
*next_frame
,
1041 void **this_prologue_cache
,
1042 struct frame_id
*id
)
1044 /* A developer is trying to bring up a new architecture, help them
1045 by providing a default unwinder that refuses to unwind anything
1046 (the ID is always NULL). In the case of legacy code,
1047 legacy_get_prev_frame() will have previously set ->this_id.p, so
1048 this code won't be called. */
1049 (*id
) = null_frame_id
;
1052 const struct frame_unwind legacy_saved_regs_unwinder
= {
1053 /* Not really. It gets overridden by legacy_get_prev_frame(). */
1055 legacy_saved_regs_this_id
,
1056 legacy_saved_regs_prev_register
1058 const struct frame_unwind
*legacy_saved_regs_unwind
= &legacy_saved_regs_unwinder
;
1060 /* Determine the frame's type based on its PC. */
1062 static enum frame_type
1063 frame_type_from_pc (CORE_ADDR pc
)
1065 /* NOTE: cagney/2004-05-08: Eliminating this function depends on all
1066 architectures being forced to use the frame-unwind code. */
1067 if (deprecated_pc_in_call_dummy (pc
))
1070 return NORMAL_FRAME
;
1073 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1074 Always returns a non-NULL value. */
1077 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1079 struct frame_info
*fi
;
1083 fprintf_unfiltered (gdb_stdlog
,
1084 "{ create_new_frame (addr=0x%s, pc=0x%s) ",
1085 paddr_nz (addr
), paddr_nz (pc
));
1088 fi
= frame_obstack_zalloc (sizeof (struct frame_info
));
1090 fi
->next
= create_sentinel_frame (current_regcache
);
1092 /* Select/initialize both the unwind function and the frame's type
1094 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
, &fi
->prologue_cache
);
1095 if (fi
->unwind
->type
!= UNKNOWN_FRAME
)
1096 fi
->type
= fi
->unwind
->type
;
1098 fi
->type
= frame_type_from_pc (pc
);
1101 deprecated_update_frame_base_hack (fi
, addr
);
1102 deprecated_update_frame_pc_hack (fi
, pc
);
1104 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1105 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, fi
);
1109 fprintf_unfiltered (gdb_stdlog
, "-> ");
1110 fprint_frame (gdb_stdlog
, fi
);
1111 fprintf_unfiltered (gdb_stdlog
, " }\n");
1117 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1118 innermost frame). Be careful to not fall off the bottom of the
1119 frame chain and onto the sentinel frame. */
1122 get_next_frame (struct frame_info
*this_frame
)
1124 if (this_frame
->level
> 0)
1125 return this_frame
->next
;
1130 /* Observer for the target_changed event. */
1133 frame_observer_target_changed (struct target_ops
*target
)
1135 flush_cached_frames ();
1138 /* Flush the entire frame cache. */
1141 flush_cached_frames (void)
1143 /* Since we can't really be sure what the first object allocated was */
1144 obstack_free (&frame_cache_obstack
, 0);
1145 obstack_init (&frame_cache_obstack
);
1147 current_frame
= NULL
; /* Invalidate cache */
1148 select_frame (NULL
);
1149 annotate_frames_invalid ();
1151 fprintf_unfiltered (gdb_stdlog
, "{ flush_cached_frames () }\n");
1154 /* Flush the frame cache, and start a new one if necessary. */
1157 reinit_frame_cache (void)
1159 flush_cached_frames ();
1161 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
1162 if (PIDGET (inferior_ptid
) != 0)
1164 select_frame (get_current_frame ());
1168 /* Create the previous frame using the deprecated methods
1169 INIT_EXTRA_INFO, and INIT_FRAME_PC. */
1171 static struct frame_info
*
1172 legacy_get_prev_frame (struct frame_info
*this_frame
)
1174 CORE_ADDR address
= 0;
1175 struct frame_info
*prev
;
1178 /* Don't frame_debug print legacy_get_prev_frame() here, just
1179 confuses the output. */
1181 /* Allocate the new frame.
1183 There is no reason to worry about memory leaks, should the
1184 remainder of the function fail. The allocated memory will be
1185 quickly reclaimed when the frame cache is flushed, and the `we've
1186 been here before' check, in get_prev_frame() will stop repeated
1187 memory allocation calls. */
1188 prev
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1189 prev
->level
= this_frame
->level
+ 1;
1191 /* Do not completely wire it in to the frame chain. Some (bad) code
1192 in INIT_FRAME_EXTRA_INFO tries to look along frame->prev to pull
1193 some fancy tricks (of course such code is, by definition,
1196 On the other hand, methods, such as get_frame_pc() and
1197 get_frame_base() rely on being able to walk along the frame
1198 chain. Make certain that at least they work by providing that
1199 link. Of course things manipulating prev can't go back. */
1200 prev
->next
= this_frame
;
1202 /* NOTE: cagney/2002-11-18: Should have been correctly setting the
1203 frame's type here, before anything else, and not last, at the
1204 bottom of this function. The various
1205 DEPRECATED_INIT_EXTRA_FRAME_INFO, DEPRECATED_INIT_FRAME_PC, and
1206 DEPRECATED_FRAME_INIT_SAVED_REGS methods are full of work-arounds
1207 that handle the frame not being correctly set from the start.
1208 Unfortunately those same work-arounds rely on the type defaulting
1209 to NORMAL_FRAME. Ulgh! The new frame code does not have this
1211 prev
->type
= UNKNOWN_FRAME
;
1213 /* A legacy frame's ID is always computed here. Mark it as valid. */
1214 prev
->this_id
.p
= 1;
1216 /* Handle sentinel frame unwind as a special case. */
1217 if (this_frame
->level
< 0)
1219 /* Try to unwind the PC. If that doesn't work, assume we've reached
1220 the oldest frame and simply return. Is there a better sentinal
1221 value? The unwound PC value is then used to initialize the new
1222 previous frame's type.
1224 Note that the pc-unwind is intentionally performed before the
1225 frame chain. This is ok since, for old targets, both
1226 frame_pc_unwind() (nee, DEPRECATED_FRAME_SAVED_PC) and
1227 DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
1228 have already been initialized (using
1229 DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
1232 By unwinding the PC first, it becomes possible to, in the case of
1233 a dummy frame, avoid also unwinding the frame ID. This is
1234 because (well ignoring the PPC) a dummy frame can be located
1235 using THIS_FRAME's frame ID. */
1237 deprecated_update_frame_pc_hack (prev
, frame_pc_unwind (this_frame
));
1238 if (get_frame_pc (prev
) == 0)
1240 /* The allocated PREV_FRAME will be reclaimed when the frame
1241 obstack is next purged. */
1244 fprintf_unfiltered (gdb_stdlog
, "-> ");
1245 fprint_frame (gdb_stdlog
, NULL
);
1246 fprintf_unfiltered (gdb_stdlog
,
1247 " // unwound legacy PC zero }\n");
1252 /* Set the unwind functions based on that identified PC. Ditto
1253 for the "type" but strongly prefer the unwinder's frame type. */
1254 prev
->unwind
= frame_unwind_find_by_frame (prev
->next
,
1255 &prev
->prologue_cache
);
1256 if (prev
->unwind
->type
== UNKNOWN_FRAME
)
1257 prev
->type
= frame_type_from_pc (get_frame_pc (prev
));
1259 prev
->type
= prev
->unwind
->type
;
1261 /* Find the prev's frame's ID. */
1262 if (prev
->type
== DUMMY_FRAME
1263 && gdbarch_unwind_dummy_id_p (current_gdbarch
))
1265 /* When unwinding a normal frame, the stack structure is
1266 determined by analyzing the frame's function's code (be
1267 it using brute force prologue analysis, or the dwarf2
1268 CFI). In the case of a dummy frame, that simply isn't
1269 possible. The The PC is either the program entry point,
1270 or some random address on the stack. Trying to use that
1271 PC to apply standard frame ID unwind techniques is just
1272 asking for trouble. */
1273 /* Use an architecture specific method to extract the prev's
1274 dummy ID from the next frame. Note that this method uses
1275 frame_register_unwind to obtain the register values
1276 needed to determine the dummy frame's ID. */
1277 prev
->this_id
.value
= gdbarch_unwind_dummy_id (current_gdbarch
,
1282 /* We're unwinding a sentinel frame, the PC of which is
1283 pointing at a stack dummy. Fake up the dummy frame's ID
1284 using the same sequence as is found a traditional
1285 unwinder. Once all architectures supply the
1286 unwind_dummy_id method, this code can go away. */
1287 prev
->this_id
.value
= frame_id_build (deprecated_read_fp (),
1291 /* Check that the unwound ID is valid. */
1292 if (!frame_id_p (prev
->this_id
.value
))
1296 fprintf_unfiltered (gdb_stdlog
, "-> ");
1297 fprint_frame (gdb_stdlog
, NULL
);
1298 fprintf_unfiltered (gdb_stdlog
,
1299 " // unwound legacy ID invalid }\n");
1304 /* Check that the new frame isn't inner to (younger, below,
1305 next) the old frame. If that happens the frame unwind is
1307 /* FIXME: cagney/2003-02-25: Ignore the sentinel frame since
1308 that doesn't have a valid frame ID. Should instead set the
1309 sentinel frame's frame ID to a `sentinel'. Leave it until
1310 after the switch to storing the frame ID, instead of the
1311 frame base, in the frame object. */
1314 this_frame
->prev
= prev
;
1316 /* FIXME: cagney/2002-01-19: This call will go away. Instead of
1317 initializing extra info, all frames will use the frame_cache
1318 (passed to the unwind functions) to store additional frame
1319 info. Unfortunately legacy targets can't use
1320 legacy_get_prev_frame() to unwind the sentinel frame and,
1321 consequently, are forced to take this code path and rely on
1322 the below call to DEPRECATED_INIT_EXTRA_FRAME_INFO to
1323 initialize the inner-most frame. */
1324 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1326 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, prev
);
1329 if (prev
->type
== NORMAL_FRAME
)
1330 prev
->this_id
.value
.code_addr
1331 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1335 fprintf_unfiltered (gdb_stdlog
, "-> ");
1336 fprint_frame (gdb_stdlog
, prev
);
1337 fprintf_unfiltered (gdb_stdlog
, " } // legacy innermost frame\n");
1342 /* This code only works on normal frames. A sentinel frame, where
1343 the level is -1, should never reach this code. */
1344 gdb_assert (this_frame
->level
>= 0);
1346 /* On some machines it is possible to call a function without
1347 setting up a stack frame for it. On these machines, we
1348 define this macro to take two args; a frameinfo pointer
1349 identifying a frame and a variable to set or clear if it is
1350 or isn't leafless. */
1352 /* Still don't want to worry about this except on the innermost
1353 frame. This macro will set FROMLEAF if THIS_FRAME is a frameless
1354 function invocation. */
1355 if (this_frame
->level
== 0)
1356 /* FIXME: 2002-11-09: Frameless functions can occur anywhere in
1357 the frame chain, not just the inner most frame! The generic,
1358 per-architecture, frame code should handle this and the below
1359 should simply be removed. */
1360 fromleaf
= (DEPRECATED_FRAMELESS_FUNCTION_INVOCATION_P ()
1361 && DEPRECATED_FRAMELESS_FUNCTION_INVOCATION (this_frame
));
1366 /* A frameless inner-most frame. The `FP' (which isn't an
1367 architecture frame-pointer register!) of the caller is the same
1369 /* FIXME: 2002-11-09: There isn't any reason to special case this
1370 edge condition. Instead the per-architecture code should handle
1372 /* FIXME: cagney/2003-06-16: This returns the inner most stack
1373 address for the previous frame, that, however, is wrong. It
1374 should be the inner most stack address for the previous to
1375 previous frame. This is because it is the previous to previous
1376 frame's innermost stack address that is constant through out
1377 the lifetime of the previous frame (trust me :-). */
1378 address
= get_frame_base (this_frame
);
1381 /* Two macros defined in tm.h specify the machine-dependent
1382 actions to be performed here.
1384 First, get the frame's chain-pointer.
1386 If that is zero, the frame is the outermost frame or a leaf
1387 called by the outermost frame. This means that if start
1388 calls main without a frame, we'll return 0 (which is fine
1391 Nope; there's a problem. This also returns when the current
1392 routine is a leaf of main. This is unacceptable. We move
1393 this to after the ffi test; I'd rather have backtraces from
1394 start go curfluy than have an abort called from main not show
1396 if (DEPRECATED_FRAME_CHAIN_P ())
1397 address
= DEPRECATED_FRAME_CHAIN (this_frame
);
1400 /* Someone is part way through coverting an old architecture
1401 to the new frame code. Implement FRAME_CHAIN the way the
1403 /* Find PREV frame's unwinder. */
1404 prev
->unwind
= frame_unwind_find_by_frame (this_frame
,
1405 &prev
->prologue_cache
);
1406 /* FIXME: cagney/2004-05-01: Should instead just use
1407 ->unwind->type. Unfortunately, legacy_get_prev_frame is
1408 still explicitly setting the type. Eliminate that method
1409 and this field can be eliminated. */
1410 prev
->type
= prev
->unwind
->type
;
1411 /* Find PREV frame's ID. */
1412 prev
->unwind
->this_id (this_frame
,
1413 &prev
->prologue_cache
,
1414 &prev
->this_id
.value
);
1415 prev
->this_id
.p
= 1;
1416 address
= prev
->this_id
.value
.stack_addr
;
1419 if (!legacy_frame_chain_valid (address
, this_frame
))
1423 fprintf_unfiltered (gdb_stdlog
, "-> ");
1424 fprint_frame (gdb_stdlog
, NULL
);
1425 fprintf_unfiltered (gdb_stdlog
,
1426 " // legacy frame chain invalid }\n");
1435 fprintf_unfiltered (gdb_stdlog
, "-> ");
1436 fprint_frame (gdb_stdlog
, NULL
);
1437 fprintf_unfiltered (gdb_stdlog
,
1438 " // legacy frame chain NULL }\n");
1443 /* Link in the already allocated prev frame. */
1444 this_frame
->prev
= prev
;
1445 deprecated_update_frame_base_hack (prev
, address
);
1447 /* This change should not be needed, FIXME! We should determine
1448 whether any targets *need* DEPRECATED_INIT_FRAME_PC to happen
1449 after DEPRECATED_INIT_EXTRA_FRAME_INFO and come up with a simple
1450 way to express what goes on here.
1452 DEPRECATED_INIT_EXTRA_FRAME_INFO is called from two places:
1453 create_new_frame (where the PC is already set up) and here (where
1454 it isn't). DEPRECATED_INIT_FRAME_PC is only called from here,
1455 always after DEPRECATED_INIT_EXTRA_FRAME_INFO.
1457 The catch is the MIPS, where DEPRECATED_INIT_EXTRA_FRAME_INFO
1458 requires the PC value (which hasn't been set yet). Some other
1459 machines appear to require DEPRECATED_INIT_EXTRA_FRAME_INFO
1460 before they can do DEPRECATED_INIT_FRAME_PC. Phoo.
1462 Assuming that some machines need DEPRECATED_INIT_FRAME_PC after
1463 DEPRECATED_INIT_EXTRA_FRAME_INFO, one possible scheme:
1465 SETUP_INNERMOST_FRAME(): Default version is just create_new_frame
1466 (deprecated_read_fp ()), read_pc ()). Machines with extra frame
1467 info would do that (or the local equivalent) and then set the
1470 SETUP_ARBITRARY_FRAME(argc, argv): Only change here is that
1471 create_new_frame would no longer init extra frame info;
1472 SETUP_ARBITRARY_FRAME would have to do that.
1474 INIT_PREV_FRAME(fromleaf, prev) Replace
1475 DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC.
1476 This should also return a flag saying whether to keep the new
1477 frame, or whether to discard it, because on some machines (e.g.
1478 mips) it is really awkward to have DEPRECATED_FRAME_CHAIN_VALID
1479 called BEFORE DEPRECATED_INIT_EXTRA_FRAME_INFO (there is no good
1480 way to get information deduced in DEPRECATED_FRAME_CHAIN_VALID
1481 into the extra fields of the new frame). std_frame_pc(fromleaf,
1484 This is the default setting for INIT_PREV_FRAME. It just does
1485 what the default DEPRECATED_INIT_FRAME_PC does. Some machines
1486 will call it from INIT_PREV_FRAME (either at the beginning, the
1487 end, or in the middle). Some machines won't use it.
1489 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
1491 /* NOTE: cagney/2002-11-09: Just ignore the above! There is no
1492 reason for things to be this complicated.
1494 The trick is to assume that there is always a frame. Instead of
1495 special casing the inner-most frame, create a fake frame
1496 (containing the hardware registers) that is inner to the
1497 user-visible inner-most frame (...) and then unwind from that.
1498 That way architecture code can use the standard
1499 frame_XX_unwind() functions and not differentiate between the
1500 inner most and any other case.
1502 Since there is always a frame to unwind from, there is always
1503 somewhere (THIS_FRAME) to store all the info needed to construct
1504 a new (previous) frame without having to first create it. This
1505 means that the convolution below - needing to carefully order a
1506 frame's initialization - isn't needed.
1508 The irony here though, is that DEPRECATED_FRAME_CHAIN(), at least
1509 for a more up-to-date architecture, always calls
1510 FRAME_SAVED_PC(), and FRAME_SAVED_PC() computes the PC but
1511 without first needing the frame! Instead of the convolution
1512 below, we could have simply called FRAME_SAVED_PC() and been done
1513 with it! Note that FRAME_SAVED_PC() is being superseded by
1514 frame_pc_unwind() and that function does have somewhere to cache
1517 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1518 DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf
, prev
);
1520 /* This entry is in the frame queue now, which is good since
1521 FRAME_SAVED_PC may use that queue to figure out its value (see
1522 tm-sparc.h). We want the PC saved in the inferior frame. */
1523 if (DEPRECATED_INIT_FRAME_PC_P ())
1524 deprecated_update_frame_pc_hack (prev
,
1525 DEPRECATED_INIT_FRAME_PC (fromleaf
,
1528 /* If ->frame and ->pc are unchanged, we are in the process of
1529 getting ourselves into an infinite backtrace. Some architectures
1530 check this in DEPRECATED_FRAME_CHAIN or thereabouts, but it seems
1531 like there is no reason this can't be an architecture-independent
1533 if (get_frame_base (prev
) == get_frame_base (this_frame
)
1534 && get_frame_pc (prev
) == get_frame_pc (this_frame
))
1536 this_frame
->prev
= NULL
;
1537 obstack_free (&frame_cache_obstack
, prev
);
1540 fprintf_unfiltered (gdb_stdlog
, "-> ");
1541 fprint_frame (gdb_stdlog
, NULL
);
1542 fprintf_unfiltered (gdb_stdlog
,
1543 " // legacy this.id == prev.id }\n");
1548 /* Initialize the code used to unwind the frame PREV based on the PC
1549 (and probably other architectural information). The PC lets you
1550 check things like the debug info at that point (dwarf2cfi?) and
1551 use that to decide how the frame should be unwound.
1553 If there isn't a FRAME_CHAIN, the code above will have already
1555 if (prev
->unwind
== NULL
)
1556 prev
->unwind
= frame_unwind_find_by_frame (prev
->next
,
1557 &prev
->prologue_cache
);
1559 /* If the unwinder provides a frame type, use it. Otherwise
1560 continue on to that heuristic mess. */
1561 if (prev
->unwind
->type
!= UNKNOWN_FRAME
)
1563 prev
->type
= prev
->unwind
->type
;
1564 if (prev
->type
== NORMAL_FRAME
)
1565 /* FIXME: cagney/2003-06-16: would get_frame_pc() be better? */
1566 prev
->this_id
.value
.code_addr
1567 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1570 fprintf_unfiltered (gdb_stdlog
, "-> ");
1571 fprint_frame (gdb_stdlog
, prev
);
1572 fprintf_unfiltered (gdb_stdlog
, " } // legacy with unwound type\n");
1577 /* NOTE: cagney/2002-11-18: The code segments, found in
1578 create_new_frame() and get_prev_frame(), that initialize the
1579 frame's type is subtly different. The latter only updates ->type
1580 when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME. This stops
1581 get_prev_frame() overriding the frame's type when the INIT code
1582 has previously set it. This is really somewhat bogus. The
1583 initialization, as seen in create_new_frame(), should occur
1584 before the INIT function has been called. */
1585 if (deprecated_pc_in_call_dummy (get_frame_pc (prev
)))
1586 prev
->type
= DUMMY_FRAME
;
1588 if (prev
->type
== NORMAL_FRAME
)
1589 prev
->this_id
.value
.code_addr
1590 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1594 fprintf_unfiltered (gdb_stdlog
, "-> ");
1595 fprint_frame (gdb_stdlog
, prev
);
1596 fprintf_unfiltered (gdb_stdlog
, " } // legacy with confused type\n");
1602 /* Return a "struct frame_info" corresponding to the frame that called
1603 THIS_FRAME. Returns NULL if there is no such frame.
1605 Unlike get_prev_frame, this function always tries to unwind the
1608 static struct frame_info
*
1609 get_prev_frame_1 (struct frame_info
*this_frame
)
1611 struct frame_info
*prev_frame
;
1612 struct frame_id this_id
;
1614 gdb_assert (this_frame
!= NULL
);
1618 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1619 if (this_frame
!= NULL
)
1620 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1622 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1623 fprintf_unfiltered (gdb_stdlog
, ") ");
1626 /* Only try to do the unwind once. */
1627 if (this_frame
->prev_p
)
1631 fprintf_unfiltered (gdb_stdlog
, "-> ");
1632 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1633 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1635 return this_frame
->prev
;
1637 this_frame
->prev_p
= 1;
1639 /* If any of the old frame initialization methods are around, use
1640 the legacy get_prev_frame() method. */
1641 if (legacy_frame_p (current_gdbarch
))
1643 prev_frame
= legacy_get_prev_frame (this_frame
);
1647 /* Check that this frame's ID was valid. If it wasn't, don't try to
1648 unwind to the prev frame. Be careful to not apply this test to
1649 the sentinel frame. */
1650 this_id
= get_frame_id (this_frame
);
1651 if (this_frame
->level
>= 0 && !frame_id_p (this_id
))
1655 fprintf_unfiltered (gdb_stdlog
, "-> ");
1656 fprint_frame (gdb_stdlog
, NULL
);
1657 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1662 /* Check that this frame's ID isn't inner to (younger, below, next)
1663 the next frame. This happens when a frame unwind goes backwards.
1664 Exclude signal trampolines (due to sigaltstack the frame ID can
1665 go backwards) and sentinel frames (the test is meaningless). */
1666 if (this_frame
->next
->level
>= 0
1667 && this_frame
->next
->type
!= SIGTRAMP_FRAME
1668 && frame_id_inner (this_id
, get_frame_id (this_frame
->next
)))
1669 error ("Previous frame inner to this frame (corrupt stack?)");
1671 /* Check that this and the next frame are not identical. If they
1672 are, there is most likely a stack cycle. As with the inner-than
1673 test above, avoid comparing the inner-most and sentinel frames. */
1674 if (this_frame
->level
> 0
1675 && frame_id_eq (this_id
, get_frame_id (this_frame
->next
)))
1676 error ("Previous frame identical to this frame (corrupt stack?)");
1678 /* Allocate the new frame but do not wire it in to the frame chain.
1679 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1680 frame->next to pull some fancy tricks (of course such code is, by
1681 definition, recursive). Try to prevent it.
1683 There is no reason to worry about memory leaks, should the
1684 remainder of the function fail. The allocated memory will be
1685 quickly reclaimed when the frame cache is flushed, and the `we've
1686 been here before' check above will stop repeated memory
1687 allocation calls. */
1688 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1689 prev_frame
->level
= this_frame
->level
+ 1;
1691 /* Don't yet compute ->unwind (and hence ->type). It is computed
1692 on-demand in get_frame_type, frame_register_unwind, and
1695 /* Don't yet compute the frame's ID. It is computed on-demand by
1698 /* The unwound frame ID is validate at the start of this function,
1699 as part of the logic to decide if that frame should be further
1700 unwound, and not here while the prev frame is being created.
1701 Doing this makes it possible for the user to examine a frame that
1702 has an invalid frame ID.
1704 Some very old VAX code noted: [...] For the sake of argument,
1705 suppose that the stack is somewhat trashed (which is one reason
1706 that "info frame" exists). So, return 0 (indicating we don't
1707 know the address of the arglist) if we don't know what frame this
1711 this_frame
->prev
= prev_frame
;
1712 prev_frame
->next
= this_frame
;
1716 fprintf_unfiltered (gdb_stdlog
, "-> ");
1717 fprint_frame (gdb_stdlog
, prev_frame
);
1718 fprintf_unfiltered (gdb_stdlog
, " }\n");
1724 /* Debug routine to print a NULL frame being returned. */
1727 frame_debug_got_null_frame (struct ui_file
*file
,
1728 struct frame_info
*this_frame
,
1733 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1734 if (this_frame
!= NULL
)
1735 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1737 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1738 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1742 /* Return a structure containing various interesting information about
1743 the frame that called THIS_FRAME. Returns NULL if there is entier
1744 no such frame or the frame fails any of a set of target-independent
1745 condition that should terminate the frame chain (e.g., as unwinding
1748 This function should not contain target-dependent tests, such as
1749 checking whether the program-counter is zero. */
1752 get_prev_frame (struct frame_info
*this_frame
)
1754 struct frame_info
*prev_frame
;
1756 /* Return the inner-most frame, when the caller passes in NULL. */
1757 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1758 caller should have previously obtained a valid frame using
1759 get_selected_frame() and then called this code - only possibility
1760 I can think of is code behaving badly.
1762 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1763 block_innermost_frame(). It does the sequence: frame = NULL;
1764 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1765 it couldn't be written better, I don't know.
1767 NOTE: cagney/2003-01-11: I suspect what is happening in
1768 block_innermost_frame() is, when the target has no state
1769 (registers, memory, ...), it is still calling this function. The
1770 assumption being that this function will return NULL indicating
1771 that a frame isn't possible, rather than checking that the target
1772 has state and then calling get_current_frame() and
1773 get_prev_frame(). This is a guess mind. */
1774 if (this_frame
== NULL
)
1776 /* NOTE: cagney/2002-11-09: There was a code segment here that
1777 would error out when CURRENT_FRAME was NULL. The comment
1778 that went with it made the claim ...
1780 ``This screws value_of_variable, which just wants a nice
1781 clean NULL return from block_innermost_frame if there are no
1782 frames. I don't think I've ever seen this message happen
1783 otherwise. And returning NULL here is a perfectly legitimate
1786 Per the above, this code shouldn't even be called with a NULL
1788 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "this_frame NULL");
1789 return current_frame
;
1792 /* There is always a frame. If this assertion fails, suspect that
1793 something should be calling get_selected_frame() or
1794 get_current_frame(). */
1795 gdb_assert (this_frame
!= NULL
);
1797 /* Make sure we pass an address within THIS_FRAME's code block to
1798 inside_main_func(). Otherwise, we might stop unwinding at a
1799 function which has a call instruction as its last instruction if
1800 that function immediately precedes main(). */
1801 if (this_frame
->level
>= 0
1802 && !backtrace_past_main
1803 && inside_main_func (get_frame_address_in_block (this_frame
)))
1804 /* Don't unwind past main(), but always unwind the sentinel frame.
1805 Note, this is done _before_ the frame has been marked as
1806 previously unwound. That way if the user later decides to
1807 allow unwinds past main(), that just happens. */
1809 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside main func");
1813 if (this_frame
->level
> backtrace_limit
)
1815 error ("Backtrace limit of %d exceeded", backtrace_limit
);
1818 /* If we're already inside the entry function for the main objfile,
1819 then it isn't valid. Don't apply this test to a dummy frame -
1820 dummy frame PCs typically land in the entry func. Don't apply
1821 this test to the sentinel frame. Sentinel frames should always
1822 be allowed to unwind. */
1823 /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1824 hard evidence that this is needed. */
1825 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func() -
1826 wasn't checking for "main" in the minimal symbols. With that
1827 fixed asm-source tests now stop in "main" instead of halting the
1828 backtrace in weird and wonderful ways somewhere inside the entry
1829 file. Suspect that tests for inside the entry file/func were
1830 added to work around that (now fixed) case. */
1831 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1832 suggested having the inside_entry_func test use the
1833 inside_main_func() msymbol trick (along with entry_point_address()
1834 I guess) to determine the address range of the start function.
1835 That should provide a far better stopper than the current
1837 /* NOTE: cagney/2003-07-15: Need to add a "set backtrace
1838 beyond-entry-func" command so that this can be selectively
1842 && backtrace_beyond_entry_func
1844 && this_frame
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1845 && inside_entry_func (this_frame
))
1847 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry func");
1851 return get_prev_frame_1 (this_frame
);
1855 get_frame_pc (struct frame_info
*frame
)
1857 gdb_assert (frame
->next
!= NULL
);
1858 return frame_pc_unwind (frame
->next
);
1861 /* Return an address of that falls within the frame's code block. */
1864 frame_unwind_address_in_block (struct frame_info
*next_frame
)
1866 /* A draft address. */
1867 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
1869 /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
1870 and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
1871 frame's PC ends up pointing at the instruction fallowing the
1872 "call". Adjust that PC value so that it falls on the call
1873 instruction (which, hopefully, falls within THIS frame's code
1874 block. So far it's proved to be a very good approximation. See
1875 get_frame_type() for why ->type can't be used. */
1876 if (next_frame
->level
>= 0
1877 && get_frame_type (next_frame
) == NORMAL_FRAME
)
1883 get_frame_address_in_block (struct frame_info
*this_frame
)
1885 return frame_unwind_address_in_block (this_frame
->next
);
1889 pc_notcurrent (struct frame_info
*frame
)
1891 /* If FRAME is not the innermost frame, that normally means that
1892 FRAME->pc points at the return instruction (which is *after* the
1893 call instruction), and we want to get the line containing the
1894 call (because the call is where the user thinks the program is).
1895 However, if the next frame is either a SIGTRAMP_FRAME or a
1896 DUMMY_FRAME, then the next frame will contain a saved interrupt
1897 PC and such a PC indicates the current (rather than next)
1898 instruction/line, consequently, for such cases, want to get the
1899 line containing fi->pc. */
1900 struct frame_info
*next
= get_next_frame (frame
);
1901 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1906 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1908 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
1911 /* Per "frame.h", return the ``address'' of the frame. Code should
1912 really be using get_frame_id(). */
1914 get_frame_base (struct frame_info
*fi
)
1916 return get_frame_id (fi
).stack_addr
;
1919 /* High-level offsets into the frame. Used by the debug info. */
1922 get_frame_base_address (struct frame_info
*fi
)
1924 if (get_frame_type (fi
) != NORMAL_FRAME
)
1926 if (fi
->base
== NULL
)
1927 fi
->base
= frame_base_find_by_frame (fi
->next
);
1928 /* Sneaky: If the low-level unwind and high-level base code share a
1929 common unwinder, let them share the prologue cache. */
1930 if (fi
->base
->unwind
== fi
->unwind
)
1931 return fi
->base
->this_base (fi
->next
, &fi
->prologue_cache
);
1932 return fi
->base
->this_base (fi
->next
, &fi
->base_cache
);
1936 get_frame_locals_address (struct frame_info
*fi
)
1939 if (get_frame_type (fi
) != NORMAL_FRAME
)
1941 /* If there isn't a frame address method, find it. */
1942 if (fi
->base
== NULL
)
1943 fi
->base
= frame_base_find_by_frame (fi
->next
);
1944 /* Sneaky: If the low-level unwind and high-level base code share a
1945 common unwinder, let them share the prologue cache. */
1946 if (fi
->base
->unwind
== fi
->unwind
)
1947 cache
= &fi
->prologue_cache
;
1949 cache
= &fi
->base_cache
;
1950 return fi
->base
->this_locals (fi
->next
, cache
);
1954 get_frame_args_address (struct frame_info
*fi
)
1957 if (get_frame_type (fi
) != NORMAL_FRAME
)
1959 /* If there isn't a frame address method, find it. */
1960 if (fi
->base
== NULL
)
1961 fi
->base
= frame_base_find_by_frame (fi
->next
);
1962 /* Sneaky: If the low-level unwind and high-level base code share a
1963 common unwinder, let them share the prologue cache. */
1964 if (fi
->base
->unwind
== fi
->unwind
)
1965 cache
= &fi
->prologue_cache
;
1967 cache
= &fi
->base_cache
;
1968 return fi
->base
->this_args (fi
->next
, cache
);
1971 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1972 or -1 for a NULL frame. */
1975 frame_relative_level (struct frame_info
*fi
)
1984 get_frame_type (struct frame_info
*frame
)
1986 /* Some legacy code, e.g, mips_init_extra_frame_info() wants
1987 to determine the frame's type prior to it being completely
1988 initialized. Don't attempt to lazily initialize ->unwind for
1989 legacy code. It will be initialized in legacy_get_prev_frame(). */
1990 if (frame
->unwind
== NULL
&& !legacy_frame_p (current_gdbarch
))
1992 /* Initialize the frame's unwinder because that's what
1993 provides the frame's type. */
1994 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
1995 &frame
->prologue_cache
);
1996 /* FIXME: cagney/2004-05-01: Should instead just use
1997 ->unwind->type. Unfortunately, legacy_get_prev_frame is
1998 still explicitly setting the type. Eliminate that method and
1999 this field can be eliminated. */
2000 frame
->type
= frame
->unwind
->type
;
2002 if (frame
->type
== UNKNOWN_FRAME
)
2003 return NORMAL_FRAME
;
2008 struct frame_extra_info
*
2009 get_frame_extra_info (struct frame_info
*fi
)
2011 return fi
->extra_info
;
2014 struct frame_extra_info
*
2015 frame_extra_info_zalloc (struct frame_info
*fi
, long size
)
2017 fi
->extra_info
= frame_obstack_zalloc (size
);
2018 return fi
->extra_info
;
2022 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
2025 fprintf_unfiltered (gdb_stdlog
,
2026 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
2027 frame
->level
, paddr_nz (pc
));
2028 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
2029 maintaining a locally allocated frame object. Since such frames
2030 are not in the frame chain, it isn't possible to assume that the
2031 frame has a next. Sigh. */
2032 if (frame
->next
!= NULL
)
2034 /* While we're at it, update this frame's cached PC value, found
2035 in the next frame. Oh for the day when "struct frame_info"
2036 is opaque and this hack on hack can just go away. */
2037 frame
->next
->prev_pc
.value
= pc
;
2038 frame
->next
->prev_pc
.p
= 1;
2043 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
2046 fprintf_unfiltered (gdb_stdlog
,
2047 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
2048 frame
->level
, paddr_nz (base
));
2049 /* See comment in "frame.h". */
2050 frame
->this_id
.value
.stack_addr
= base
;
2054 deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs
,
2055 long sizeof_extra_info
)
2057 struct frame_info
*frame
= XMALLOC (struct frame_info
);
2058 memset (frame
, 0, sizeof (*frame
));
2059 frame
->this_id
.p
= 1;
2060 make_cleanup (xfree
, frame
);
2061 if (sizeof_saved_regs
> 0)
2063 frame
->saved_regs
= xcalloc (1, sizeof_saved_regs
);
2064 make_cleanup (xfree
, frame
->saved_regs
);
2066 if (sizeof_extra_info
> 0)
2068 frame
->extra_info
= xcalloc (1, sizeof_extra_info
);
2069 make_cleanup (xfree
, frame
->extra_info
);
2074 /* Memory access methods. */
2077 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
, void *buf
,
2080 read_memory (addr
, buf
, len
);
2084 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2087 return read_memory_integer (addr
, len
);
2091 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2094 return read_memory_unsigned_integer (addr
, len
);
2098 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2099 CORE_ADDR addr
, void *buf
, int len
)
2101 /* NOTE: read_memory_nobpt returns zero on success! */
2102 return !read_memory_nobpt (addr
, buf
, len
);
2105 /* Architecture method. */
2108 get_frame_arch (struct frame_info
*this_frame
)
2110 return current_gdbarch
;
2113 /* Stack pointer methods. */
2116 get_frame_sp (struct frame_info
*this_frame
)
2118 return frame_sp_unwind (this_frame
->next
);
2122 frame_sp_unwind (struct frame_info
*next_frame
)
2124 /* Normality - an architecture that provides a way of obtaining any
2125 frame inner-most address. */
2126 if (gdbarch_unwind_sp_p (current_gdbarch
))
2127 return gdbarch_unwind_sp (current_gdbarch
, next_frame
);
2128 /* Things are looking grim. If it's the inner-most frame and there
2129 is a TARGET_READ_SP, then that can be used. */
2130 if (next_frame
->level
< 0 && TARGET_READ_SP_P ())
2131 return TARGET_READ_SP ();
2132 /* Now things are really are grim. Hope that the value returned by
2133 the SP_REGNUM register is meaningful. */
2137 frame_unwind_unsigned_register (next_frame
, SP_REGNUM
, &sp
);
2140 internal_error (__FILE__
, __LINE__
, "Missing unwind SP method");
2145 legacy_frame_p (struct gdbarch
*current_gdbarch
)
2147 if (DEPRECATED_INIT_FRAME_PC_P ()
2148 || DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()
2149 || DEPRECATED_FRAME_CHAIN_P ())
2150 /* No question, it's a legacy frame. */
2152 if (gdbarch_unwind_dummy_id_p (current_gdbarch
))
2153 /* No question, it's not a legacy frame (provided none of the
2154 deprecated methods checked above are present that is). */
2156 if (DEPRECATED_TARGET_READ_FP_P ()
2157 || DEPRECATED_FP_REGNUM
>= 0)
2158 /* Assume it's legacy. If you're trying to convert a legacy frame
2159 target to the new mechanism, get rid of these. legacy
2160 get_prev_frame() requires these when unwind_frame_id() isn't
2163 /* Default to assuming that it's brand new code, and hence not
2164 legacy. Force it down the non-legacy path so that the new code
2165 uses the new frame mechanism from day one. Dummy frames won't
2166 work very well but we can live with that. */
2170 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2172 static struct cmd_list_element
*set_backtrace_cmdlist
;
2173 static struct cmd_list_element
*show_backtrace_cmdlist
;
2176 set_backtrace_cmd (char *args
, int from_tty
)
2178 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2182 show_backtrace_cmd (char *args
, int from_tty
)
2184 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2188 _initialize_frame (void)
2190 obstack_init (&frame_cache_obstack
);
2192 observer_attach_target_changed (frame_observer_target_changed
);
2194 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, "\
2195 Set backtrace specific variables.\n\
2196 Configure backtrace variables such as the backtrace limit",
2197 &set_backtrace_cmdlist
, "set backtrace ",
2198 0/*allow-unknown*/, &setlist
);
2199 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, "\
2200 Show backtrace specific variables\n\
2201 Show backtrace variables such as the backtrace limit",
2202 &show_backtrace_cmdlist
, "show backtrace ",
2203 0/*allow-unknown*/, &showlist
);
2205 add_setshow_boolean_cmd ("past-main", class_obscure
,
2206 &backtrace_past_main
, "\
2207 Set whether backtraces should continue past \"main\".\n\
2208 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2209 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2210 of the stack trace.", "\
2211 Show whether backtraces should continue past \"main\".\n\
2212 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2213 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2214 of the stack trace.",
2215 NULL
, NULL
, &set_backtrace_cmdlist
,
2216 &show_backtrace_cmdlist
);
2218 add_setshow_uinteger_cmd ("limit", class_obscure
,
2219 &backtrace_limit
, "\
2220 Set an upper bound on the number of backtrace levels.\n\
2221 No more than the specified number of frames can be displayed or examined.\n\
2222 Zero is unlimited.", "\
2223 Show the upper bound on the number of backtrace levels.",
2224 NULL
, NULL
, &set_backtrace_cmdlist
,
2225 &show_backtrace_cmdlist
);
2227 /* Debug this files internals. */
2228 add_show_from_set (add_set_cmd ("frame", class_maintenance
, var_zinteger
,
2229 &frame_debug
, "Set frame debugging.\n\
2230 When non-zero, frame specific internal debugging is enabled.", &setdebuglist
),