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"
43 static struct frame_info
*get_prev_frame_1 (struct frame_info
*this_frame
);
45 /* We keep a cache of stack frames, each of which is a "struct
46 frame_info". The innermost one gets allocated (in
47 wait_for_inferior) each time the inferior stops; current_frame
48 points to it. Additional frames get allocated (in get_prev_frame)
49 as needed, and are chained through the next and prev fields. Any
50 time that the frame cache becomes invalid (most notably when we
51 execute something, but also if we change how we interpret the
52 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
53 which reads new symbols)), we should call reinit_frame_cache. */
57 /* Level of this frame. The inner-most (youngest) frame is at level
58 0. As you move towards the outer-most (oldest) frame, the level
59 increases. This is a cached value. It could just as easily be
60 computed by counting back from the selected frame to the inner
62 /* NOTE: cagney/2002-04-05: Perhaphs a level of ``-1'' should be
63 reserved to indicate a bogus frame - one that has been created
64 just to keep GDB happy (GDB always needs a frame). For the
65 moment leave this as speculation. */
68 /* The frame's type. */
69 /* FIXME: cagney/2003-04-02: Should instead be returning
70 ->unwind->type. Unfortunately, legacy code is still explicitly
71 setting the type using the method deprecated_set_frame_type.
72 Eliminate that method and this field can be eliminated. */
75 /* For each register, address of where it was saved on entry to the
76 frame, or zero if it was not saved on entry to this frame. This
77 includes special registers such as pc and fp saved in special
78 ways in the stack frame. The SP_REGNUM is even more special, the
79 address here is the sp for the previous frame, not the address
80 where the sp was saved. */
81 /* Allocated by frame_saved_regs_zalloc () which is called /
82 initialized by DEPRECATED_FRAME_INIT_SAVED_REGS(). */
83 CORE_ADDR
*saved_regs
; /*NUM_REGS + NUM_PSEUDO_REGS*/
85 /* Anything extra for this structure that may have been defined in
86 the machine dependent files. */
87 /* Allocated by frame_extra_info_zalloc () which is called /
88 initialized by DEPRECATED_INIT_EXTRA_FRAME_INFO */
89 struct frame_extra_info
*extra_info
;
91 /* The frame's low-level unwinder and corresponding cache. The
92 low-level unwinder is responsible for unwinding register values
93 for the previous frame. The low-level unwind methods are
94 selected based on the presence, or otherwize, of register unwind
95 information such as CFI. */
97 const struct frame_unwind
*unwind
;
99 /* Cached copy of the previous frame's resume address. */
105 /* Cached copy of the previous frame's function address. */
112 /* This frame's ID. */
116 struct frame_id value
;
119 /* The frame's high-level base methods, and corresponding cache.
120 The high level base methods are selected based on the frame's
122 const struct frame_base
*base
;
125 /* Pointers to the next (down, inner, younger) and previous (up,
126 outer, older) frame_info's in the frame cache. */
127 struct frame_info
*next
; /* down, inner, younger */
129 struct frame_info
*prev
; /* up, outer, older */
132 /* Flag to control debugging. */
134 static int frame_debug
;
136 /* Flag to indicate whether backtraces should stop at main et.al. */
138 static int backtrace_past_main
;
139 static unsigned int backtrace_limit
= UINT_MAX
;
143 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
145 fprintf_unfiltered (file
, "{stack=0x%s,code=0x%s,special=0x%s}",
146 paddr_nz (id
.stack_addr
),
147 paddr_nz (id
.code_addr
),
148 paddr_nz (id
.special_addr
));
152 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
157 fprintf_unfiltered (file
, "UNKNOWN_FRAME");
160 fprintf_unfiltered (file
, "NORMAL_FRAME");
163 fprintf_unfiltered (file
, "DUMMY_FRAME");
166 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
169 fprintf_unfiltered (file
, "<unknown type>");
175 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
179 fprintf_unfiltered (file
, "<NULL frame>");
182 fprintf_unfiltered (file
, "{");
183 fprintf_unfiltered (file
, "level=%d", fi
->level
);
184 fprintf_unfiltered (file
, ",");
185 fprintf_unfiltered (file
, "type=");
186 fprint_frame_type (file
, fi
->type
);
187 fprintf_unfiltered (file
, ",");
188 fprintf_unfiltered (file
, "unwind=");
189 if (fi
->unwind
!= NULL
)
190 gdb_print_host_address (fi
->unwind
, file
);
192 fprintf_unfiltered (file
, "<unknown>");
193 fprintf_unfiltered (file
, ",");
194 fprintf_unfiltered (file
, "pc=");
195 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
196 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_pc
.value
));
198 fprintf_unfiltered (file
, "<unknown>");
199 fprintf_unfiltered (file
, ",");
200 fprintf_unfiltered (file
, "id=");
202 fprint_frame_id (file
, fi
->this_id
.value
);
204 fprintf_unfiltered (file
, "<unknown>");
205 fprintf_unfiltered (file
, ",");
206 fprintf_unfiltered (file
, "func=");
207 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
208 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_func
.addr
));
210 fprintf_unfiltered (file
, "<unknown>");
211 fprintf_unfiltered (file
, "}");
214 /* Return a frame uniq ID that can be used to, later, re-find the
218 get_frame_id (struct frame_info
*fi
)
222 return null_frame_id
;
226 gdb_assert (!legacy_frame_p (current_gdbarch
));
228 fprintf_unfiltered (gdb_stdlog
, "{ get_frame_id (fi=%d) ",
230 /* Find the unwinder. */
231 if (fi
->unwind
== NULL
)
233 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
,
234 &fi
->prologue_cache
);
235 /* FIXME: cagney/2003-04-02: Rather than storing the frame's
236 type in the frame, the unwinder's type should be returned
237 directly. Unfortunately, legacy code, called by
238 legacy_get_prev_frame, explicitly set the frames type
239 using the method deprecated_set_frame_type(). */
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 and a sentinel
417 frame. Do like was always done. Fetch the PC's value
418 direct 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 betweening 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, 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/2003-04-02: Rather than storing the frame's
551 type in the frame, the unwinder's type should be returned
552 directly. Unfortunately, legacy code, called by
553 legacy_get_prev_frame, explicitly set the frames type using
554 the method deprecated_set_frame_type(). */
555 frame
->type
= frame
->unwind
->type
;
558 /* Ask this frame to unwind its register. See comment in
559 "frame-unwind.h" for why NEXT frame and this unwind cace are
561 frame
->unwind
->prev_register (frame
->next
, &frame
->prologue_cache
, regnum
,
562 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
566 fprintf_unfiltered (gdb_stdlog
, "->");
567 fprintf_unfiltered (gdb_stdlog
, " *optimizedp=%d", (*optimizedp
));
568 fprintf_unfiltered (gdb_stdlog
, " *lvalp=%d", (int) (*lvalp
));
569 fprintf_unfiltered (gdb_stdlog
, " *addrp=0x%s", paddr_nz ((*addrp
)));
570 fprintf_unfiltered (gdb_stdlog
, " *bufferp=");
572 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
576 const unsigned char *buf
= bufferp
;
577 fprintf_unfiltered (gdb_stdlog
, "[");
578 for (i
= 0; i
< register_size (current_gdbarch
, regnum
); i
++)
579 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
580 fprintf_unfiltered (gdb_stdlog
, "]");
582 fprintf_unfiltered (gdb_stdlog
, " }\n");
587 frame_register (struct frame_info
*frame
, int regnum
,
588 int *optimizedp
, enum lval_type
*lvalp
,
589 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
591 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
592 that the value proper does not need to be fetched. */
593 gdb_assert (optimizedp
!= NULL
);
594 gdb_assert (lvalp
!= NULL
);
595 gdb_assert (addrp
!= NULL
);
596 gdb_assert (realnump
!= NULL
);
597 /* gdb_assert (bufferp != NULL); */
599 /* Ulgh! Old code that, for lval_register, sets ADDRP to the offset
600 of the register in the register cache. It should instead return
601 the REGNUM corresponding to that register. Translate the . */
602 if (DEPRECATED_GET_SAVED_REGISTER_P ())
604 DEPRECATED_GET_SAVED_REGISTER (bufferp
, optimizedp
, addrp
, frame
,
606 /* Compute the REALNUM if the caller wants it. */
607 if (*lvalp
== lval_register
)
610 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
612 if (*addrp
== register_offset_hack (current_gdbarch
, regnum
))
618 internal_error (__FILE__
, __LINE__
,
619 "Failed to compute the register number corresponding"
620 " to 0x%s", paddr_d (*addrp
));
626 /* Obtain the register value by unwinding the register from the next
627 (more inner frame). */
628 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
629 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
634 frame_unwind_register (struct frame_info
*frame
, int regnum
, void *buf
)
640 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
645 get_frame_register (struct frame_info
*frame
,
646 int regnum
, void *buf
)
648 frame_unwind_register (frame
->next
, regnum
, buf
);
652 frame_unwind_register_signed (struct frame_info
*frame
, int regnum
)
654 char buf
[MAX_REGISTER_SIZE
];
655 frame_unwind_register (frame
, regnum
, buf
);
656 return extract_signed_integer (buf
, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum
));
660 get_frame_register_signed (struct frame_info
*frame
, int regnum
)
662 return frame_unwind_register_signed (frame
->next
, regnum
);
666 frame_unwind_register_unsigned (struct frame_info
*frame
, int regnum
)
668 char buf
[MAX_REGISTER_SIZE
];
669 frame_unwind_register (frame
, regnum
, buf
);
670 return extract_unsigned_integer (buf
, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum
));
674 get_frame_register_unsigned (struct frame_info
*frame
, int regnum
)
676 return frame_unwind_register_unsigned (frame
->next
, regnum
);
680 frame_unwind_unsigned_register (struct frame_info
*frame
, int regnum
,
683 char buf
[MAX_REGISTER_SIZE
];
684 frame_unwind_register (frame
, regnum
, buf
);
685 (*val
) = extract_unsigned_integer (buf
, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum
));
689 put_frame_register (struct frame_info
*frame
, int regnum
, const void *buf
)
691 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
696 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, NULL
);
698 error ("Attempt to assign to a value that was optimized out.");
703 /* FIXME: write_memory doesn't yet take constant buffers.
705 char tmp
[MAX_REGISTER_SIZE
];
706 memcpy (tmp
, buf
, register_size (gdbarch
, regnum
));
707 write_memory (addr
, tmp
, register_size (gdbarch
, regnum
));
711 regcache_cooked_write (current_regcache
, realnum
, buf
);
714 error ("Attempt to assign to an unmodifiable value.");
718 /* frame_register_read ()
720 Find and return the value of REGNUM for the specified stack frame.
721 The number of bytes copied is DEPRECATED_REGISTER_RAW_SIZE
724 Returns 0 if the register value could not be found. */
727 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
733 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
735 /* FIXME: cagney/2002-05-15: This test, is just bogus.
737 It indicates that the target failed to supply a value for a
738 register because it was "not available" at this time. Problem
739 is, the target still has the register and so get saved_register()
740 may be returning a value saved on the stack. */
742 if (register_cached (regnum
) < 0)
743 return 0; /* register value not available */
749 /* Map between a frame register number and its name. A frame register
750 space is a superset of the cooked register space --- it also
751 includes builtin registers. */
754 frame_map_name_to_regnum (struct frame_info
*frame
, const char *name
, int len
)
756 return user_reg_map_name_to_regnum (get_frame_arch (frame
), name
, len
);
760 frame_map_regnum_to_name (struct frame_info
*frame
, int regnum
)
762 return user_reg_map_regnum_to_name (get_frame_arch (frame
), regnum
);
765 /* Create a sentinel frame. */
767 static struct frame_info
*
768 create_sentinel_frame (struct regcache
*regcache
)
770 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
771 frame
->type
= NORMAL_FRAME
;
773 /* Explicitly initialize the sentinel frame's cache. Provide it
774 with the underlying regcache. In the future additional
775 information, such as the frame's thread will be added. */
776 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
777 /* For the moment there is only one sentinel frame implementation. */
778 frame
->unwind
= sentinel_frame_unwind
;
779 /* Link this frame back to itself. The frame is self referential
780 (the unwound PC is the same as the pc), so make it so. */
782 /* Make the sentinel frame's ID valid, but invalid. That way all
783 comparisons with it should fail. */
784 frame
->this_id
.p
= 1;
785 frame
->this_id
.value
= null_frame_id
;
788 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
789 fprint_frame (gdb_stdlog
, frame
);
790 fprintf_unfiltered (gdb_stdlog
, " }\n");
795 /* Info about the innermost stack frame (contents of FP register) */
797 static struct frame_info
*current_frame
;
799 /* Cache for frame addresses already read by gdb. Valid only while
800 inferior is stopped. Control variables for the frame cache should
801 be local to this module. */
803 static struct obstack frame_cache_obstack
;
806 frame_obstack_zalloc (unsigned long size
)
808 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
809 memset (data
, 0, size
);
814 frame_saved_regs_zalloc (struct frame_info
*fi
)
816 fi
->saved_regs
= (CORE_ADDR
*)
817 frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
818 return fi
->saved_regs
;
822 deprecated_get_frame_saved_regs (struct frame_info
*fi
)
824 return fi
->saved_regs
;
827 /* Return the innermost (currently executing) stack frame. This is
828 split into two functions. The function unwind_to_current_frame()
829 is wrapped in catch exceptions so that, even when the unwind of the
830 sentinel frame fails, the function still returns a stack frame. */
833 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
835 struct frame_info
*frame
= get_prev_frame (args
);
836 /* A sentinel frame can fail to unwind, eg, because it's PC value
837 lands in somewhere like start. */
840 current_frame
= frame
;
845 get_current_frame (void)
847 /* First check, and report, the lack of registers. Having GDB
848 report "No stack!" or "No memory" when the target doesn't even
849 have registers is very confusing. Besides, "printcmd.exp"
850 explicitly checks that ``print $pc'' with no registers prints "No
852 if (!target_has_registers
)
853 error ("No registers.");
854 if (!target_has_stack
)
856 if (!target_has_memory
)
857 error ("No memory.");
858 if (current_frame
== NULL
)
860 struct frame_info
*sentinel_frame
=
861 create_sentinel_frame (current_regcache
);
862 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
863 NULL
, RETURN_MASK_ERROR
) != 0)
865 /* Oops! Fake a current frame? Is this useful? It has a PC
866 of zero, for instance. */
867 current_frame
= sentinel_frame
;
870 return current_frame
;
873 /* The "selected" stack frame is used by default for local and arg
874 access. May be zero, for no selected frame. */
876 struct frame_info
*deprecated_selected_frame
;
878 /* Return the selected frame. Always non-null (unless there isn't an
879 inferior sufficient for creating a frame) in which case an error is
883 get_selected_frame (void)
885 if (deprecated_selected_frame
== NULL
)
886 /* Hey! Don't trust this. It should really be re-finding the
887 last selected frame of the currently selected thread. This,
888 though, is better than nothing. */
889 select_frame (get_current_frame ());
890 /* There is always a frame. */
891 gdb_assert (deprecated_selected_frame
!= NULL
);
892 return deprecated_selected_frame
;
895 /* This is a variant of get_selected_frame which can be called when
896 the inferior does not have a frame; in that case it will return
897 NULL instead of calling error (). */
900 deprecated_safe_get_selected_frame (void)
902 if (!target_has_registers
|| !target_has_stack
|| !target_has_memory
)
904 return get_selected_frame ();
907 /* Select frame FI (or NULL - to invalidate the current frame). */
910 select_frame (struct frame_info
*fi
)
914 deprecated_selected_frame
= fi
;
915 /* NOTE: cagney/2002-05-04: FI can be NULL. This occures when the
916 frame is being invalidated. */
917 if (selected_frame_level_changed_hook
)
918 selected_frame_level_changed_hook (frame_relative_level (fi
));
920 /* FIXME: kseitz/2002-08-28: It would be nice to call
921 selected_frame_level_changed_event right here, but due to limitations
922 in the current interfaces, we would end up flooding UIs with events
923 because select_frame is used extensively internally.
925 Once we have frame-parameterized frame (and frame-related) commands,
926 the event notification can be moved here, since this function will only
927 be called when the users selected frame is being changed. */
929 /* Ensure that symbols for this frame are read in. Also, determine the
930 source language of this frame, and switch to it if desired. */
933 /* We retrieve the frame's symtab by using the frame PC. However
934 we cannot use the frame pc as is, because it usually points to
935 the instruction following the "call", which is sometimes the
936 first instruction of another function. So we rely on
937 get_frame_address_in_block() which provides us with a PC which
938 is guaranteed to be inside the frame's code block. */
939 s
= find_pc_symtab (get_frame_address_in_block (fi
));
941 && s
->language
!= current_language
->la_language
942 && s
->language
!= language_unknown
943 && language_mode
== language_mode_auto
)
945 set_language (s
->language
);
950 /* Return the register saved in the simplistic ``saved_regs'' cache.
951 If the value isn't here AND a value is needed, try the next inner
955 legacy_saved_regs_prev_register (struct frame_info
*next_frame
,
956 void **this_prologue_cache
,
957 int regnum
, int *optimizedp
,
958 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
959 int *realnump
, void *bufferp
)
961 /* HACK: New code is passed the next frame and this cache.
962 Unfortunately, old code expects this frame. Since this is a
963 backward compatibility hack, cheat by walking one level along the
964 prologue chain to the frame the old code expects.
966 Do not try this at home. Professional driver, closed course. */
967 struct frame_info
*frame
= next_frame
->prev
;
968 gdb_assert (frame
!= NULL
);
970 if (deprecated_get_frame_saved_regs (frame
) == NULL
)
972 /* If nothing's initialized the saved regs, do it now. */
973 gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
974 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
975 gdb_assert (deprecated_get_frame_saved_regs (frame
) != NULL
);
978 if (deprecated_get_frame_saved_regs (frame
) != NULL
979 && deprecated_get_frame_saved_regs (frame
)[regnum
] != 0)
981 if (regnum
== SP_REGNUM
)
983 /* SP register treated specially. */
989 /* NOTE: cagney/2003-05-09: In-lined store_address with
990 it's body - store_unsigned_integer. */
991 store_unsigned_integer (bufferp
, DEPRECATED_REGISTER_RAW_SIZE (regnum
),
992 deprecated_get_frame_saved_regs (frame
)[regnum
]);
996 /* Any other register is saved in memory, fetch it but cache
997 a local copy of its value. */
999 *lvalp
= lval_memory
;
1000 *addrp
= deprecated_get_frame_saved_regs (frame
)[regnum
];
1002 if (bufferp
!= NULL
)
1005 /* Save each register value, as it is read in, in a
1006 frame based cache. */
1007 void **regs
= (*this_prologue_cache
);
1010 int sizeof_cache
= ((NUM_REGS
+ NUM_PSEUDO_REGS
)
1012 regs
= frame_obstack_zalloc (sizeof_cache
);
1013 (*this_prologue_cache
) = regs
;
1015 if (regs
[regnum
] == NULL
)
1018 = frame_obstack_zalloc (DEPRECATED_REGISTER_RAW_SIZE (regnum
));
1019 read_memory (deprecated_get_frame_saved_regs (frame
)[regnum
], regs
[regnum
],
1020 DEPRECATED_REGISTER_RAW_SIZE (regnum
));
1022 memcpy (bufferp
, regs
[regnum
], DEPRECATED_REGISTER_RAW_SIZE (regnum
));
1024 /* Read the value in from memory. */
1025 read_memory (deprecated_get_frame_saved_regs (frame
)[regnum
], bufferp
,
1026 DEPRECATED_REGISTER_RAW_SIZE (regnum
));
1033 /* No luck. Assume this and the next frame have the same register
1034 value. Pass the unwind request down the frame chain to the next
1035 frame. Hopefully that frame will find the register's location. */
1036 frame_register_unwind (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1041 legacy_saved_regs_this_id (struct frame_info
*next_frame
,
1042 void **this_prologue_cache
,
1043 struct frame_id
*id
)
1045 /* A developer is trying to bring up a new architecture, help them
1046 by providing a default unwinder that refuses to unwind anything
1047 (the ID is always NULL). In the case of legacy code,
1048 legacy_get_prev_frame() will have previously set ->this_id.p, so
1049 this code won't be called. */
1050 (*id
) = null_frame_id
;
1053 const struct frame_unwind legacy_saved_regs_unwinder
= {
1054 /* Not really. It gets overridden by legacy_get_prev_frame. */
1056 legacy_saved_regs_this_id
,
1057 legacy_saved_regs_prev_register
1059 const struct frame_unwind
*legacy_saved_regs_unwind
= &legacy_saved_regs_unwinder
;
1062 /* Function: deprecated_generic_get_saved_register
1063 Find register number REGNUM relative to FRAME and put its (raw,
1064 target format) contents in *RAW_BUFFER.
1066 Set *OPTIMIZED if the variable was optimized out (and thus can't be
1067 fetched). Note that this is never set to anything other than zero
1068 in this implementation.
1070 Set *LVAL to lval_memory, lval_register, or not_lval, depending on
1071 whether the value was fetched from memory, from a register, or in a
1072 strange and non-modifiable way (e.g. a frame pointer which was
1073 calculated rather than fetched). We will use not_lval for values
1074 fetched from generic dummy frames.
1076 Set *ADDRP to the address, either in memory or as a
1077 DEPRECATED_REGISTER_BYTE offset into the registers array. If the
1078 value is stored in a dummy frame, set *ADDRP to zero.
1080 The argument RAW_BUFFER must point to aligned memory. */
1083 deprecated_generic_get_saved_register (char *raw_buffer
, int *optimized
,
1085 struct frame_info
*frame
, int regnum
,
1086 enum lval_type
*lval
)
1088 if (!target_has_registers
)
1089 error ("No registers.");
1091 /* Normal systems don't optimize out things with register numbers. */
1092 if (optimized
!= NULL
)
1095 if (addrp
) /* default assumption: not found in memory */
1098 /* Note: since the current frame's registers could only have been
1099 saved by frames INTERIOR TO the current frame, we skip examining
1100 the current frame itself: otherwise, we would be getting the
1101 previous frame's registers which were saved by the current frame. */
1105 for (frame
= get_next_frame (frame
);
1106 frame_relative_level (frame
) >= 0;
1107 frame
= get_next_frame (frame
))
1109 if (get_frame_type (frame
) == DUMMY_FRAME
)
1111 if (lval
) /* found it in a CALL_DUMMY frame */
1114 /* FIXME: cagney/2002-06-26: This should be via the
1115 gdbarch_register_read() method so that it, on the
1116 fly, constructs either a raw or pseudo register
1117 from the raw register cache. */
1119 (deprecated_find_dummy_frame_regcache (get_frame_pc (frame
),
1120 get_frame_base (frame
)),
1121 regnum
, raw_buffer
);
1125 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1126 if (deprecated_get_frame_saved_regs (frame
) != NULL
1127 && deprecated_get_frame_saved_regs (frame
)[regnum
] != 0)
1129 if (lval
) /* found it saved on the stack */
1130 *lval
= lval_memory
;
1131 if (regnum
== SP_REGNUM
)
1133 if (raw_buffer
) /* SP register treated specially */
1134 /* NOTE: cagney/2003-05-09: In-line store_address
1135 with it's body - store_unsigned_integer. */
1136 store_unsigned_integer (raw_buffer
,
1137 DEPRECATED_REGISTER_RAW_SIZE (regnum
),
1138 deprecated_get_frame_saved_regs (frame
)[regnum
]);
1142 if (addrp
) /* any other register */
1143 *addrp
= deprecated_get_frame_saved_regs (frame
)[regnum
];
1145 read_memory (deprecated_get_frame_saved_regs (frame
)[regnum
], raw_buffer
,
1146 DEPRECATED_REGISTER_RAW_SIZE (regnum
));
1153 /* If we get thru the loop to this point, it means the register was
1154 not saved in any frame. Return the actual live-register value. */
1156 if (lval
) /* found it in a live register */
1157 *lval
= lval_register
;
1159 *addrp
= DEPRECATED_REGISTER_BYTE (regnum
);
1161 deprecated_read_register_gen (regnum
, raw_buffer
);
1164 /* Determine the frame's type based on its PC. */
1166 static enum frame_type
1167 frame_type_from_pc (CORE_ADDR pc
)
1169 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1170 && deprecated_pc_in_call_dummy (pc
, 0, 0))
1175 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
1176 if (DEPRECATED_PC_IN_SIGTRAMP (pc
, name
))
1177 return SIGTRAMP_FRAME
;
1179 return NORMAL_FRAME
;
1183 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1184 Always returns a non-NULL value. */
1187 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1189 struct frame_info
*fi
;
1193 fprintf_unfiltered (gdb_stdlog
,
1194 "{ create_new_frame (addr=0x%s, pc=0x%s) ",
1195 paddr_nz (addr
), paddr_nz (pc
));
1198 fi
= frame_obstack_zalloc (sizeof (struct frame_info
));
1200 fi
->next
= create_sentinel_frame (current_regcache
);
1202 /* Select/initialize both the unwind function and the frame's type
1204 fi
->unwind
= frame_unwind_find_by_frame (fi
->next
, &fi
->prologue_cache
);
1205 if (fi
->unwind
->type
!= UNKNOWN_FRAME
)
1206 fi
->type
= fi
->unwind
->type
;
1208 fi
->type
= frame_type_from_pc (pc
);
1211 deprecated_update_frame_base_hack (fi
, addr
);
1212 deprecated_update_frame_pc_hack (fi
, pc
);
1214 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1215 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, fi
);
1219 fprintf_unfiltered (gdb_stdlog
, "-> ");
1220 fprint_frame (gdb_stdlog
, fi
);
1221 fprintf_unfiltered (gdb_stdlog
, " }\n");
1227 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1228 innermost frame). Be careful to not fall off the bottom of the
1229 frame chain and onto the sentinel frame. */
1232 get_next_frame (struct frame_info
*this_frame
)
1234 if (this_frame
->level
> 0)
1235 return this_frame
->next
;
1240 /* Flush the entire frame cache. */
1243 flush_cached_frames (void)
1245 /* Since we can't really be sure what the first object allocated was */
1246 obstack_free (&frame_cache_obstack
, 0);
1247 obstack_init (&frame_cache_obstack
);
1249 current_frame
= NULL
; /* Invalidate cache */
1250 select_frame (NULL
);
1251 annotate_frames_invalid ();
1253 fprintf_unfiltered (gdb_stdlog
, "{ flush_cached_frames () }\n");
1256 /* Flush the frame cache, and start a new one if necessary. */
1259 reinit_frame_cache (void)
1261 flush_cached_frames ();
1263 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
1264 if (PIDGET (inferior_ptid
) != 0)
1266 select_frame (get_current_frame ());
1270 /* Create the previous frame using the deprecated methods
1271 INIT_EXTRA_INFO, and INIT_FRAME_PC. */
1273 static struct frame_info
*
1274 legacy_get_prev_frame (struct frame_info
*this_frame
)
1276 CORE_ADDR address
= 0;
1277 struct frame_info
*prev
;
1280 /* Don't frame_debug print legacy_get_prev_frame() here, just
1281 confuses the output. */
1283 /* Allocate the new frame.
1285 There is no reason to worry about memory leaks, should the
1286 remainder of the function fail. The allocated memory will be
1287 quickly reclaimed when the frame cache is flushed, and the `we've
1288 been here before' check, in get_prev_frame will stop repeated
1289 memory allocation calls. */
1290 prev
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1291 prev
->level
= this_frame
->level
+ 1;
1293 /* Do not completely wire it in to the frame chain. Some (bad) code
1294 in INIT_FRAME_EXTRA_INFO tries to look along frame->prev to pull
1295 some fancy tricks (of course such code is, by definition,
1298 On the other hand, methods, such as get_frame_pc() and
1299 get_frame_base() rely on being able to walk along the frame
1300 chain. Make certain that at least they work by providing that
1301 link. Of course things manipulating prev can't go back. */
1302 prev
->next
= this_frame
;
1304 /* NOTE: cagney/2002-11-18: Should have been correctly setting the
1305 frame's type here, before anything else, and not last, at the
1306 bottom of this function. The various
1307 DEPRECATED_INIT_EXTRA_FRAME_INFO, DEPRECATED_INIT_FRAME_PC, and
1308 DEPRECATED_FRAME_INIT_SAVED_REGS methods are full of work-arounds
1309 that handle the frame not being correctly set from the start.
1310 Unfortunately those same work-arounds rely on the type defaulting
1311 to NORMAL_FRAME. Ulgh! The new frame code does not have this
1313 prev
->type
= UNKNOWN_FRAME
;
1315 /* A legacy frame's ID is always computed here. Mark it as valid. */
1316 prev
->this_id
.p
= 1;
1318 /* Handle sentinel frame unwind as a special case. */
1319 if (this_frame
->level
< 0)
1321 /* Try to unwind the PC. If that doesn't work, assume we've reached
1322 the oldest frame and simply return. Is there a better sentinal
1323 value? The unwound PC value is then used to initialize the new
1324 previous frame's type.
1326 Note that the pc-unwind is intentionally performed before the
1327 frame chain. This is ok since, for old targets, both
1328 frame_pc_unwind (nee, DEPRECATED_FRAME_SAVED_PC) and
1329 DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
1330 have already been initialized (using
1331 DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
1334 By unwinding the PC first, it becomes possible to, in the case of
1335 a dummy frame, avoid also unwinding the frame ID. This is
1336 because (well ignoring the PPC) a dummy frame can be located
1337 using THIS_FRAME's frame ID. */
1339 deprecated_update_frame_pc_hack (prev
, frame_pc_unwind (this_frame
));
1340 if (get_frame_pc (prev
) == 0)
1342 /* The allocated PREV_FRAME will be reclaimed when the frame
1343 obstack is next purged. */
1346 fprintf_unfiltered (gdb_stdlog
, "-> ");
1347 fprint_frame (gdb_stdlog
, NULL
);
1348 fprintf_unfiltered (gdb_stdlog
,
1349 " // unwound legacy PC zero }\n");
1354 /* Set the unwind functions based on that identified PC. Ditto
1355 for the "type" but strongly prefer the unwinder's frame type. */
1356 prev
->unwind
= frame_unwind_find_by_frame (prev
->next
,
1357 &prev
->prologue_cache
);
1358 if (prev
->unwind
->type
== UNKNOWN_FRAME
)
1359 prev
->type
= frame_type_from_pc (get_frame_pc (prev
));
1361 prev
->type
= prev
->unwind
->type
;
1363 /* Find the prev's frame's ID. */
1364 if (prev
->type
== DUMMY_FRAME
1365 && gdbarch_unwind_dummy_id_p (current_gdbarch
))
1367 /* When unwinding a normal frame, the stack structure is
1368 determined by analyzing the frame's function's code (be
1369 it using brute force prologue analysis, or the dwarf2
1370 CFI). In the case of a dummy frame, that simply isn't
1371 possible. The The PC is either the program entry point,
1372 or some random address on the stack. Trying to use that
1373 PC to apply standard frame ID unwind techniques is just
1374 asking for trouble. */
1375 /* Use an architecture specific method to extract the prev's
1376 dummy ID from the next frame. Note that this method uses
1377 frame_register_unwind to obtain the register values
1378 needed to determine the dummy frame's ID. */
1379 prev
->this_id
.value
= gdbarch_unwind_dummy_id (current_gdbarch
,
1384 /* We're unwinding a sentinel frame, the PC of which is
1385 pointing at a stack dummy. Fake up the dummy frame's ID
1386 using the same sequence as is found a traditional
1387 unwinder. Once all architectures supply the
1388 unwind_dummy_id method, this code can go away. */
1389 prev
->this_id
.value
= frame_id_build (deprecated_read_fp (),
1393 /* Check that the unwound ID is valid. */
1394 if (!frame_id_p (prev
->this_id
.value
))
1398 fprintf_unfiltered (gdb_stdlog
, "-> ");
1399 fprint_frame (gdb_stdlog
, NULL
);
1400 fprintf_unfiltered (gdb_stdlog
,
1401 " // unwound legacy ID invalid }\n");
1406 /* Check that the new frame isn't inner to (younger, below,
1407 next) the old frame. If that happens the frame unwind is
1409 /* FIXME: cagney/2003-02-25: Ignore the sentinel frame since
1410 that doesn't have a valid frame ID. Should instead set the
1411 sentinel frame's frame ID to a `sentinel'. Leave it until
1412 after the switch to storing the frame ID, instead of the
1413 frame base, in the frame object. */
1416 this_frame
->prev
= prev
;
1418 /* FIXME: cagney/2002-01-19: This call will go away. Instead of
1419 initializing extra info, all frames will use the frame_cache
1420 (passed to the unwind functions) to store additional frame
1421 info. Unfortunately legacy targets can't use
1422 legacy_get_prev_frame() to unwind the sentinel frame and,
1423 consequently, are forced to take this code path and rely on
1424 the below call to DEPRECATED_INIT_EXTRA_FRAME_INFO to
1425 initialize the inner-most frame. */
1426 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1428 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, prev
);
1431 if (prev
->type
== NORMAL_FRAME
)
1432 prev
->this_id
.value
.code_addr
1433 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1437 fprintf_unfiltered (gdb_stdlog
, "-> ");
1438 fprint_frame (gdb_stdlog
, prev
);
1439 fprintf_unfiltered (gdb_stdlog
, " } // legacy innermost frame\n");
1444 /* This code only works on normal frames. A sentinel frame, where
1445 the level is -1, should never reach this code. */
1446 gdb_assert (this_frame
->level
>= 0);
1448 /* On some machines it is possible to call a function without
1449 setting up a stack frame for it. On these machines, we
1450 define this macro to take two args; a frameinfo pointer
1451 identifying a frame and a variable to set or clear if it is
1452 or isn't leafless. */
1454 /* Still don't want to worry about this except on the innermost
1455 frame. This macro will set FROMLEAF if THIS_FRAME is a frameless
1456 function invocation. */
1457 if (this_frame
->level
== 0)
1458 /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
1459 the frame chain, not just the inner most frame! The generic,
1460 per-architecture, frame code should handle this and the below
1461 should simply be removed. */
1462 fromleaf
= (DEPRECATED_FRAMELESS_FUNCTION_INVOCATION_P ()
1463 && DEPRECATED_FRAMELESS_FUNCTION_INVOCATION (this_frame
));
1468 /* A frameless inner-most frame. The `FP' (which isn't an
1469 architecture frame-pointer register!) of the caller is the same
1471 /* FIXME: 2002-11-09: There isn't any reason to special case this
1472 edge condition. Instead the per-architecture code should hande
1474 /* FIXME: cagney/2003-06-16: This returns the inner most stack
1475 address for the previous frame, that, however, is wrong. It
1476 should be the inner most stack address for the previous to
1477 previous frame. This is because it is the previous to previous
1478 frame's innermost stack address that is constant through out
1479 the lifetime of the previous frame (trust me :-). */
1480 address
= get_frame_base (this_frame
);
1483 /* Two macros defined in tm.h specify the machine-dependent
1484 actions to be performed here.
1486 First, get the frame's chain-pointer.
1488 If that is zero, the frame is the outermost frame or a leaf
1489 called by the outermost frame. This means that if start
1490 calls main without a frame, we'll return 0 (which is fine
1493 Nope; there's a problem. This also returns when the current
1494 routine is a leaf of main. This is unacceptable. We move
1495 this to after the ffi test; I'd rather have backtraces from
1496 start go curfluy than have an abort called from main not show
1498 if (DEPRECATED_FRAME_CHAIN_P ())
1499 address
= DEPRECATED_FRAME_CHAIN (this_frame
);
1502 /* Someone is part way through coverting an old architecture
1503 to the new frame code. Implement FRAME_CHAIN the way the
1505 /* Find PREV frame's unwinder. */
1506 prev
->unwind
= frame_unwind_find_by_frame (this_frame
,
1507 &prev
->prologue_cache
);
1508 /* FIXME: cagney/2003-04-02: Rather than storing the frame's
1509 type in the frame, the unwinder's type should be returned
1510 directly. Unfortunately, legacy code, called by
1511 legacy_get_prev_frame, explicitly set the frames type
1512 using the method deprecated_set_frame_type(). */
1513 prev
->type
= prev
->unwind
->type
;
1514 /* Find PREV frame's ID. */
1515 prev
->unwind
->this_id (this_frame
,
1516 &prev
->prologue_cache
,
1517 &prev
->this_id
.value
);
1518 prev
->this_id
.p
= 1;
1519 address
= prev
->this_id
.value
.stack_addr
;
1522 if (!legacy_frame_chain_valid (address
, this_frame
))
1526 fprintf_unfiltered (gdb_stdlog
, "-> ");
1527 fprint_frame (gdb_stdlog
, NULL
);
1528 fprintf_unfiltered (gdb_stdlog
,
1529 " // legacy frame chain invalid }\n");
1538 fprintf_unfiltered (gdb_stdlog
, "-> ");
1539 fprint_frame (gdb_stdlog
, NULL
);
1540 fprintf_unfiltered (gdb_stdlog
,
1541 " // legacy frame chain NULL }\n");
1546 /* Link in the already allocated prev frame. */
1547 this_frame
->prev
= prev
;
1548 deprecated_update_frame_base_hack (prev
, address
);
1550 /* This change should not be needed, FIXME! We should determine
1551 whether any targets *need* DEPRECATED_INIT_FRAME_PC to happen
1552 after DEPRECATED_INIT_EXTRA_FRAME_INFO and come up with a simple
1553 way to express what goes on here.
1555 DEPRECATED_INIT_EXTRA_FRAME_INFO is called from two places:
1556 create_new_frame (where the PC is already set up) and here (where
1557 it isn't). DEPRECATED_INIT_FRAME_PC is only called from here,
1558 always after DEPRECATED_INIT_EXTRA_FRAME_INFO.
1560 The catch is the MIPS, where DEPRECATED_INIT_EXTRA_FRAME_INFO
1561 requires the PC value (which hasn't been set yet). Some other
1562 machines appear to require DEPRECATED_INIT_EXTRA_FRAME_INFO
1563 before they can do DEPRECATED_INIT_FRAME_PC. Phoo.
1565 Assuming that some machines need DEPRECATED_INIT_FRAME_PC after
1566 DEPRECATED_INIT_EXTRA_FRAME_INFO, one possible scheme:
1568 SETUP_INNERMOST_FRAME(): Default version is just create_new_frame
1569 (deprecated_read_fp ()), read_pc ()). Machines with extra frame
1570 info would do that (or the local equivalent) and then set the
1573 SETUP_ARBITRARY_FRAME(argc, argv): Only change here is that
1574 create_new_frame would no longer init extra frame info;
1575 SETUP_ARBITRARY_FRAME would have to do that.
1577 INIT_PREV_FRAME(fromleaf, prev) Replace
1578 DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC.
1579 This should also return a flag saying whether to keep the new
1580 frame, or whether to discard it, because on some machines (e.g.
1581 mips) it is really awkward to have DEPRECATED_FRAME_CHAIN_VALID
1582 called BEFORE DEPRECATED_INIT_EXTRA_FRAME_INFO (there is no good
1583 way to get information deduced in DEPRECATED_FRAME_CHAIN_VALID
1584 into the extra fields of the new frame). std_frame_pc(fromleaf,
1587 This is the default setting for INIT_PREV_FRAME. It just does
1588 what the default DEPRECATED_INIT_FRAME_PC does. Some machines
1589 will call it from INIT_PREV_FRAME (either at the beginning, the
1590 end, or in the middle). Some machines won't use it.
1592 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
1594 /* NOTE: cagney/2002-11-09: Just ignore the above! There is no
1595 reason for things to be this complicated.
1597 The trick is to assume that there is always a frame. Instead of
1598 special casing the inner-most frame, create fake frame
1599 (containing the hardware registers) that is inner to the
1600 user-visible inner-most frame (...) and then unwind from that.
1601 That way architecture code can use use the standard
1602 frame_XX_unwind() functions and not differentiate between the
1603 inner most and any other case.
1605 Since there is always a frame to unwind from, there is always
1606 somewhere (THIS_FRAME) to store all the info needed to construct
1607 a new (previous) frame without having to first create it. This
1608 means that the convolution below - needing to carefully order a
1609 frame's initialization - isn't needed.
1611 The irony here though, is that DEPRECATED_FRAME_CHAIN(), at least
1612 for a more up-to-date architecture, always calls
1613 FRAME_SAVED_PC(), and FRAME_SAVED_PC() computes the PC but
1614 without first needing the frame! Instead of the convolution
1615 below, we could have simply called FRAME_SAVED_PC() and been done
1616 with it! Note that FRAME_SAVED_PC() is being superseed by
1617 frame_pc_unwind() and that function does have somewhere to cache
1620 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1621 DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf
, prev
);
1623 /* This entry is in the frame queue now, which is good since
1624 FRAME_SAVED_PC may use that queue to figure out its value (see
1625 tm-sparc.h). We want the pc saved in the inferior frame. */
1626 if (DEPRECATED_INIT_FRAME_PC_P ())
1627 deprecated_update_frame_pc_hack (prev
,
1628 DEPRECATED_INIT_FRAME_PC (fromleaf
,
1631 /* If ->frame and ->pc are unchanged, we are in the process of
1632 getting ourselves into an infinite backtrace. Some architectures
1633 check this in DEPRECATED_FRAME_CHAIN or thereabouts, but it seems
1634 like there is no reason this can't be an architecture-independent
1636 if (get_frame_base (prev
) == get_frame_base (this_frame
)
1637 && get_frame_pc (prev
) == get_frame_pc (this_frame
))
1639 this_frame
->prev
= NULL
;
1640 obstack_free (&frame_cache_obstack
, prev
);
1643 fprintf_unfiltered (gdb_stdlog
, "-> ");
1644 fprint_frame (gdb_stdlog
, NULL
);
1645 fprintf_unfiltered (gdb_stdlog
,
1646 " // legacy this.id == prev.id }\n");
1651 /* Initialize the code used to unwind the frame PREV based on the PC
1652 (and probably other architectural information). The PC lets you
1653 check things like the debug info at that point (dwarf2cfi?) and
1654 use that to decide how the frame should be unwound.
1656 If there isn't a FRAME_CHAIN, the code above will have already
1658 if (prev
->unwind
== NULL
)
1659 prev
->unwind
= frame_unwind_find_by_frame (prev
->next
,
1660 &prev
->prologue_cache
);
1662 /* If the unwinder provides a frame type, use it. Otherwize
1663 continue on to that heuristic mess. */
1664 if (prev
->unwind
->type
!= UNKNOWN_FRAME
)
1666 prev
->type
= prev
->unwind
->type
;
1667 if (prev
->type
== NORMAL_FRAME
)
1668 /* FIXME: cagney/2003-06-16: would get_frame_pc() be better? */
1669 prev
->this_id
.value
.code_addr
1670 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1673 fprintf_unfiltered (gdb_stdlog
, "-> ");
1674 fprint_frame (gdb_stdlog
, prev
);
1675 fprintf_unfiltered (gdb_stdlog
, " } // legacy with unwound type\n");
1680 /* NOTE: cagney/2002-11-18: The code segments, found in
1681 create_new_frame and get_prev_frame(), that initializes the
1682 frames type is subtly different. The latter only updates ->type
1683 when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME. This stops
1684 get_prev_frame() overriding the frame's type when the INIT code
1685 has previously set it. This is really somewhat bogus. The
1686 initialization, as seen in create_new_frame(), should occur
1687 before the INIT function has been called. */
1688 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1689 && deprecated_pc_in_call_dummy (get_frame_pc (prev
), 0, 0))
1690 prev
->type
= DUMMY_FRAME
;
1693 /* FIXME: cagney/2002-11-10: This should be moved to before the
1694 INIT code above so that the INIT code knows what the frame's
1695 type is (in fact, for a [generic] dummy-frame, the type can
1696 be set and then the entire initialization can be skipped.
1697 Unforunatly, its the INIT code that sets the PC (Hmm, catch
1700 find_pc_partial_function (get_frame_pc (prev
), &name
, NULL
, NULL
);
1701 if (DEPRECATED_PC_IN_SIGTRAMP (get_frame_pc (prev
), name
))
1702 prev
->type
= SIGTRAMP_FRAME
;
1703 /* FIXME: cagney/2002-11-11: Leave prev->type alone. Some
1704 architectures are forcing the frame's type in INIT so we
1705 don't want to override it here. Remember, NORMAL_FRAME == 0,
1706 so it all works (just :-/). Once this initialization is
1707 moved to the start of this function, all this nastness will
1711 if (prev
->type
== NORMAL_FRAME
)
1712 prev
->this_id
.value
.code_addr
1713 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1717 fprintf_unfiltered (gdb_stdlog
, "-> ");
1718 fprint_frame (gdb_stdlog
, prev
);
1719 fprintf_unfiltered (gdb_stdlog
, " } // legacy with confused type\n");
1725 /* Return a "struct frame_info" corresponding to the frame that called
1726 THIS_FRAME. Returns NULL if there is no such frame.
1728 Unlike get_prev_frame, this function always tries to unwind the
1731 static struct frame_info
*
1732 get_prev_frame_1 (struct frame_info
*this_frame
)
1734 struct frame_info
*prev_frame
;
1736 gdb_assert (this_frame
!= NULL
);
1740 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1741 if (this_frame
!= NULL
)
1742 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1744 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1745 fprintf_unfiltered (gdb_stdlog
, ") ");
1748 /* Only try to do the unwind once. */
1749 if (this_frame
->prev_p
)
1753 fprintf_unfiltered (gdb_stdlog
, "-> ");
1754 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1755 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1757 return this_frame
->prev
;
1759 this_frame
->prev_p
= 1;
1761 /* If any of the old frame initialization methods are around, use
1762 the legacy get_prev_frame method. */
1763 if (legacy_frame_p (current_gdbarch
))
1765 prev_frame
= legacy_get_prev_frame (this_frame
);
1769 /* Check that this frame's ID was valid. If it wasn't, don't try to
1770 unwind to the prev frame. Be careful to not apply this test to
1771 the sentinel frame. */
1772 if (this_frame
->level
>= 0 && !frame_id_p (get_frame_id (this_frame
)))
1776 fprintf_unfiltered (gdb_stdlog
, "-> ");
1777 fprint_frame (gdb_stdlog
, NULL
);
1778 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1783 /* Check that this frame's ID isn't inner to (younger, below, next)
1784 the next frame. This happens when a frame unwind goes backwards.
1785 Exclude signal trampolines (due to sigaltstack the frame ID can
1786 go backwards) and sentinel frames (the test is meaningless). */
1787 if (this_frame
->next
->level
>= 0
1788 && this_frame
->next
->type
!= SIGTRAMP_FRAME
1789 && frame_id_inner (get_frame_id (this_frame
),
1790 get_frame_id (this_frame
->next
)))
1791 error ("Previous frame inner to this frame (corrupt stack?)");
1793 /* Check that this and the next frame are not identical. If they
1794 are, there is most likely a stack cycle. As with the inner-than
1795 test above, avoid comparing the inner-most and sentinel frames. */
1796 if (this_frame
->level
> 0
1797 && frame_id_eq (get_frame_id (this_frame
),
1798 get_frame_id (this_frame
->next
)))
1799 error ("Previous frame identical to this frame (corrupt stack?)");
1801 /* Allocate the new frame but do not wire it in to the frame chain.
1802 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1803 frame->next to pull some fancy tricks (of course such code is, by
1804 definition, recursive). Try to prevent it.
1806 There is no reason to worry about memory leaks, should the
1807 remainder of the function fail. The allocated memory will be
1808 quickly reclaimed when the frame cache is flushed, and the `we've
1809 been here before' check above will stop repeated memory
1810 allocation calls. */
1811 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1812 prev_frame
->level
= this_frame
->level
+ 1;
1814 /* Don't yet compute ->unwind (and hence ->type). It is computed
1815 on-demand in get_frame_type, frame_register_unwind, and
1818 /* Don't yet compute the frame's ID. It is computed on-demand by
1821 /* The unwound frame ID is validate at the start of this function,
1822 as part of the logic to decide if that frame should be further
1823 unwound, and not here while the prev frame is being created.
1824 Doing this makes it possible for the user to examine a frame that
1825 has an invalid frame ID.
1827 Some very old VAX code noted: [...] For the sake of argument,
1828 suppose that the stack is somewhat trashed (which is one reason
1829 that "info frame" exists). So, return 0 (indicating we don't
1830 know the address of the arglist) if we don't know what frame this
1834 this_frame
->prev
= prev_frame
;
1835 prev_frame
->next
= this_frame
;
1839 fprintf_unfiltered (gdb_stdlog
, "-> ");
1840 fprint_frame (gdb_stdlog
, prev_frame
);
1841 fprintf_unfiltered (gdb_stdlog
, " }\n");
1847 /* Debug routine to print a NULL frame being returned. */
1850 frame_debug_got_null_frame (struct ui_file
*file
,
1851 struct frame_info
*this_frame
,
1856 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1857 if (this_frame
!= NULL
)
1858 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1860 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1861 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1865 /* Return a structure containing various interesting information about
1866 the frame that called THIS_FRAME. Returns NULL if there is entier
1867 no such frame or the frame fails any of a set of target-independent
1868 condition that should terminate the frame chain (e.g., as unwinding
1871 This function should not contain target-dependent tests, such as
1872 checking whether the program-counter is zero. */
1875 get_prev_frame (struct frame_info
*this_frame
)
1877 struct frame_info
*prev_frame
;
1879 /* Return the inner-most frame, when the caller passes in NULL. */
1880 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1881 caller should have previously obtained a valid frame using
1882 get_selected_frame() and then called this code - only possibility
1883 I can think of is code behaving badly.
1885 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1886 block_innermost_frame(). It does the sequence: frame = NULL;
1887 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1888 it couldn't be written better, I don't know.
1890 NOTE: cagney/2003-01-11: I suspect what is happening is
1891 block_innermost_frame() is, when the target has no state
1892 (registers, memory, ...), still calling this function. The
1893 assumption being that this function will return NULL indicating
1894 that a frame isn't possible, rather than checking that the target
1895 has state and then calling get_current_frame() and
1896 get_prev_frame(). This is a guess mind. */
1897 if (this_frame
== NULL
)
1899 /* NOTE: cagney/2002-11-09: There was a code segment here that
1900 would error out when CURRENT_FRAME was NULL. The comment
1901 that went with it made the claim ...
1903 ``This screws value_of_variable, which just wants a nice
1904 clean NULL return from block_innermost_frame if there are no
1905 frames. I don't think I've ever seen this message happen
1906 otherwise. And returning NULL here is a perfectly legitimate
1909 Per the above, this code shouldn't even be called with a NULL
1911 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "this_frame NULL");
1912 return current_frame
;
1915 /* There is always a frame. If this assertion fails, suspect that
1916 something should be calling get_selected_frame() or
1917 get_current_frame(). */
1918 gdb_assert (this_frame
!= NULL
);
1920 /* Make sure we pass an address within THIS_FRAME's code block to
1921 inside_main_func. Otherwise, we might stop unwinding at a
1922 function which has a call instruction as its last instruction if
1923 that function immediately precedes main(). */
1924 if (this_frame
->level
>= 0
1925 && !backtrace_past_main
1926 && inside_main_func (get_frame_address_in_block (this_frame
)))
1927 /* Don't unwind past main(), bug always unwind the sentinel frame.
1928 Note, this is done _before_ the frame has been marked as
1929 previously unwound. That way if the user later decides to
1930 allow unwinds past main(), that just happens. */
1932 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside main func");
1936 if (this_frame
->level
> backtrace_limit
)
1938 error ("Backtrace limit of %d exceeded", backtrace_limit
);
1941 /* If we're already inside the entry function for the main objfile,
1942 then it isn't valid. Don't apply this test to a dummy frame -
1943 dummy frame PC's typically land in the entry func. Don't apply
1944 this test to the sentinel frame. Sentinel frames should always
1945 be allowed to unwind. */
1946 /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1947 hard evidence that this is needed. */
1948 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func - wasn't
1949 checking for "main" in the minimal symbols. With that fixed
1950 asm-source tests now stop in "main" instead of halting the
1951 backtrace in wierd and wonderful ways somewhere inside the entry
1952 file. Suspect that deprecated_inside_entry_file and
1953 inside_entry_func tests were added to work around that (now
1955 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1956 suggested having the inside_entry_func test use the
1957 inside_main_func msymbol trick (along with entry_point_address I
1958 guess) to determine the address range of the start function.
1959 That should provide a far better stopper than the current
1961 /* NOTE: cagney/2003-07-15: Need to add a "set backtrace
1962 beyond-entry-func" command so that this can be selectively
1966 && backtrace_beyond_entry_func
1968 && this_frame
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1969 && inside_entry_func (this_frame
))
1971 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry func");
1975 /* If we're inside the entry file, it isn't valid. Don't apply this
1976 test to a dummy frame - dummy frame PC's typically land in the
1977 entry file. Don't apply this test to the sentinel frame.
1978 Sentinel frames should always be allowed to unwind. */
1979 /* NOTE: drow/2002-12-25: should there be a way to disable this
1980 check? It assumes a single small entry file, and the way some
1981 debug readers (e.g. dbxread) figure out which object is the
1982 entry file is somewhat hokey. */
1983 /* NOTE: cagney/2003-01-10: If there is a way of disabling this test
1984 then it should probably be moved to before the ->prev_p test,
1986 /* NOTE: vinschen/2003-04-01: Disabled. It turns out that the call
1987 to deprecated_inside_entry_file destroys a meaningful backtrace
1988 under some conditions. E. g. the backtrace tests in the
1989 asm-source testcase are broken for some targets. In this test
1990 the functions are all implemented as part of one file and the
1991 testcase is not necessarily linked with a start file (depending
1992 on the target). What happens is, that the first frame is printed
1993 normaly and following frames are treated as being inside the
1994 enttry file then. This way, only the #0 frame is printed in the
1995 backtrace output. */
1997 && this_frame
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1998 && deprecated_inside_entry_file (get_frame_pc (this_frame
)))
2000 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry file");
2004 return get_prev_frame_1 (this_frame
);
2008 get_frame_pc (struct frame_info
*frame
)
2010 gdb_assert (frame
->next
!= NULL
);
2011 return frame_pc_unwind (frame
->next
);
2014 /* Return an address of that falls within the frame's code block. */
2017 frame_unwind_address_in_block (struct frame_info
*next_frame
)
2019 /* A draft address. */
2020 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2022 /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
2023 and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
2024 frame's PC ends up pointing at the instruction fallowing the
2025 "call". Adjust that PC value so that it falls on the call
2026 instruction (which, hopefully, falls within THIS frame's code
2027 block. So far it's proved to be a very good approximation. See
2028 get_frame_type for why ->type can't be used. */
2029 if (next_frame
->level
>= 0
2030 && get_frame_type (next_frame
) == NORMAL_FRAME
)
2036 get_frame_address_in_block (struct frame_info
*this_frame
)
2038 return frame_unwind_address_in_block (this_frame
->next
);
2042 pc_notcurrent (struct frame_info
*frame
)
2044 /* If FRAME is not the innermost frame, that normally means that
2045 FRAME->pc points at the return instruction (which is *after* the
2046 call instruction), and we want to get the line containing the
2047 call (because the call is where the user thinks the program is).
2048 However, if the next frame is either a SIGTRAMP_FRAME or a
2049 DUMMY_FRAME, then the next frame will contain a saved interrupt
2050 PC and such a PC indicates the current (rather than next)
2051 instruction/line, consequently, for such cases, want to get the
2052 line containing fi->pc. */
2053 struct frame_info
*next
= get_next_frame (frame
);
2054 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
2059 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2061 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
2064 /* Per "frame.h", return the ``address'' of the frame. Code should
2065 really be using get_frame_id(). */
2067 get_frame_base (struct frame_info
*fi
)
2069 return get_frame_id (fi
).stack_addr
;
2072 /* High-level offsets into the frame. Used by the debug info. */
2075 get_frame_base_address (struct frame_info
*fi
)
2077 if (get_frame_type (fi
) != NORMAL_FRAME
)
2079 if (fi
->base
== NULL
)
2080 fi
->base
= frame_base_find_by_frame (fi
->next
);
2081 /* Sneaky: If the low-level unwind and high-level base code share a
2082 common unwinder, let them share the prologue cache. */
2083 if (fi
->base
->unwind
== fi
->unwind
)
2084 return fi
->base
->this_base (fi
->next
, &fi
->prologue_cache
);
2085 return fi
->base
->this_base (fi
->next
, &fi
->base_cache
);
2089 get_frame_locals_address (struct frame_info
*fi
)
2092 if (get_frame_type (fi
) != NORMAL_FRAME
)
2094 /* If there isn't a frame address method, find it. */
2095 if (fi
->base
== NULL
)
2096 fi
->base
= frame_base_find_by_frame (fi
->next
);
2097 /* Sneaky: If the low-level unwind and high-level base code share a
2098 common unwinder, let them share the prologue cache. */
2099 if (fi
->base
->unwind
== fi
->unwind
)
2100 cache
= &fi
->prologue_cache
;
2102 cache
= &fi
->base_cache
;
2103 return fi
->base
->this_locals (fi
->next
, cache
);
2107 get_frame_args_address (struct frame_info
*fi
)
2110 if (get_frame_type (fi
) != NORMAL_FRAME
)
2112 /* If there isn't a frame address method, find it. */
2113 if (fi
->base
== NULL
)
2114 fi
->base
= frame_base_find_by_frame (fi
->next
);
2115 /* Sneaky: If the low-level unwind and high-level base code share a
2116 common unwinder, let them share the prologue cache. */
2117 if (fi
->base
->unwind
== fi
->unwind
)
2118 cache
= &fi
->prologue_cache
;
2120 cache
= &fi
->base_cache
;
2121 return fi
->base
->this_args (fi
->next
, cache
);
2124 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2125 or -1 for a NULL frame. */
2128 frame_relative_level (struct frame_info
*fi
)
2137 get_frame_type (struct frame_info
*frame
)
2139 /* Some targets still don't use [generic] dummy frames. Catch them
2141 if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
2142 && deprecated_frame_in_dummy (frame
))
2145 /* Some legacy code, e.g, mips_init_extra_frame_info() wants
2146 to determine the frame's type prior to it being completely
2147 initialized. Don't attempt to lazily initialize ->unwind for
2148 legacy code. It will be initialized in legacy_get_prev_frame(). */
2149 if (frame
->unwind
== NULL
&& !legacy_frame_p (current_gdbarch
))
2151 /* Initialize the frame's unwinder because it is that which
2152 provides the frame's type. */
2153 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
2154 &frame
->prologue_cache
);
2155 /* FIXME: cagney/2003-04-02: Rather than storing the frame's
2156 type in the frame, the unwinder's type should be returned
2157 directly. Unfortunately, legacy code, called by
2158 legacy_get_prev_frame, explicitly set the frames type using
2159 the method deprecated_set_frame_type(). */
2160 frame
->type
= frame
->unwind
->type
;
2162 if (frame
->type
== UNKNOWN_FRAME
)
2163 return NORMAL_FRAME
;
2169 deprecated_set_frame_type (struct frame_info
*frame
, enum frame_type type
)
2171 /* Arrrg! See comment in "frame.h". */
2175 struct frame_extra_info
*
2176 get_frame_extra_info (struct frame_info
*fi
)
2178 return fi
->extra_info
;
2181 struct frame_extra_info
*
2182 frame_extra_info_zalloc (struct frame_info
*fi
, long size
)
2184 fi
->extra_info
= frame_obstack_zalloc (size
);
2185 return fi
->extra_info
;
2189 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
2192 fprintf_unfiltered (gdb_stdlog
,
2193 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
2194 frame
->level
, paddr_nz (pc
));
2195 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
2196 maintaining a locally allocated frame object. Since such frame's
2197 are not in the frame chain, it isn't possible to assume that the
2198 frame has a next. Sigh. */
2199 if (frame
->next
!= NULL
)
2201 /* While we're at it, update this frame's cached PC value, found
2202 in the next frame. Oh for the day when "struct frame_info"
2203 is opaque and this hack on hack can just go away. */
2204 frame
->next
->prev_pc
.value
= pc
;
2205 frame
->next
->prev_pc
.p
= 1;
2210 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
2213 fprintf_unfiltered (gdb_stdlog
,
2214 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
2215 frame
->level
, paddr_nz (base
));
2216 /* See comment in "frame.h". */
2217 frame
->this_id
.value
.stack_addr
= base
;
2221 deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs
,
2222 long sizeof_extra_info
)
2224 struct frame_info
*frame
= XMALLOC (struct frame_info
);
2225 memset (frame
, 0, sizeof (*frame
));
2226 frame
->this_id
.p
= 1;
2227 make_cleanup (xfree
, frame
);
2228 if (sizeof_saved_regs
> 0)
2230 frame
->saved_regs
= xcalloc (1, sizeof_saved_regs
);
2231 make_cleanup (xfree
, frame
->saved_regs
);
2233 if (sizeof_extra_info
> 0)
2235 frame
->extra_info
= xcalloc (1, sizeof_extra_info
);
2236 make_cleanup (xfree
, frame
->extra_info
);
2241 /* Memory access methods. */
2244 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
, void *buf
,
2247 read_memory (addr
, buf
, len
);
2251 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2254 return read_memory_integer (addr
, len
);
2258 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2261 return read_memory_unsigned_integer (addr
, len
);
2265 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2266 CORE_ADDR addr
, void *buf
, int len
)
2268 /* NOTE: read_memory_nobpt returns zero on success! */
2269 return !read_memory_nobpt (addr
, buf
, len
);
2272 /* Architecture method. */
2275 get_frame_arch (struct frame_info
*this_frame
)
2277 return current_gdbarch
;
2280 /* Stack pointer methods. */
2283 get_frame_sp (struct frame_info
*this_frame
)
2285 return frame_sp_unwind (this_frame
->next
);
2289 frame_sp_unwind (struct frame_info
*next_frame
)
2291 /* Normality, an architecture that provides a way of obtaining any
2292 frame inner-most address. */
2293 if (gdbarch_unwind_sp_p (current_gdbarch
))
2294 return gdbarch_unwind_sp (current_gdbarch
, next_frame
);
2295 /* Things are looking grim. If it's the inner-most frame and there
2296 is a TARGET_READ_SP then that can be used. */
2297 if (next_frame
->level
< 0 && TARGET_READ_SP_P ())
2298 return TARGET_READ_SP ();
2299 /* Now things are really are grim. Hope that the value returned by
2300 the SP_REGNUM register is meaningful. */
2304 frame_unwind_unsigned_register (next_frame
, SP_REGNUM
, &sp
);
2307 internal_error (__FILE__
, __LINE__
, "Missing unwind SP method");
2312 legacy_frame_p (struct gdbarch
*current_gdbarch
)
2314 if (DEPRECATED_INIT_FRAME_PC_P ()
2315 || DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()
2316 || DEPRECATED_FRAME_CHAIN_P ())
2317 /* No question, it's a legacy frame. */
2319 if (gdbarch_unwind_dummy_id_p (current_gdbarch
))
2320 /* No question, it's not a legacy frame (provided none of the
2321 deprecated methods checked above are present that is). */
2323 if (DEPRECATED_TARGET_READ_FP_P ()
2324 || DEPRECATED_FP_REGNUM
>= 0)
2325 /* Assume it's legacy. If you're trying to convert a legacy frame
2326 target to the new mechanism, get rid of these. legacy
2327 get_prev_frame requires these when unwind_frame_id isn't
2330 /* Default to assuming that it's brand new code, and hence not
2331 legacy. Force it down the non-legacy path so that the new code
2332 uses the new frame mechanism from day one. Dummy frame's won't
2333 work very well but we can live with that. */
2337 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2339 static struct cmd_list_element
*set_backtrace_cmdlist
;
2340 static struct cmd_list_element
*show_backtrace_cmdlist
;
2343 set_backtrace_cmd (char *args
, int from_tty
)
2345 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2349 show_backtrace_cmd (char *args
, int from_tty
)
2351 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2355 _initialize_frame (void)
2357 obstack_init (&frame_cache_obstack
);
2359 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, "\
2360 Set backtrace specific variables.\n\
2361 Configure backtrace variables such as the backtrace limit",
2362 &set_backtrace_cmdlist
, "set backtrace ",
2363 0/*allow-unknown*/, &setlist
);
2364 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, "\
2365 Show backtrace specific variables\n\
2366 Show backtrace variables such as the backtrace limit",
2367 &show_backtrace_cmdlist
, "show backtrace ",
2368 0/*allow-unknown*/, &showlist
);
2370 add_setshow_boolean_cmd ("past-main", class_obscure
,
2371 &backtrace_past_main
, "\
2372 Set whether backtraces should continue past \"main\".\n\
2373 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2374 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2375 of the stack trace.", "\
2376 Show whether backtraces should continue past \"main\".\n\
2377 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2378 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2379 of the stack trace.",
2380 NULL
, NULL
, &set_backtrace_cmdlist
,
2381 &show_backtrace_cmdlist
);
2383 add_setshow_uinteger_cmd ("limit", class_obscure
,
2384 &backtrace_limit
, "\
2385 Set an upper bound on the number of backtrace levels.\n\
2386 No more than the specified number of frames can be displayed or examined.\n\
2387 Zero is unlimited.", "\
2388 Show the upper bound on the number of backtrace levels.",
2389 NULL
, NULL
, &set_backtrace_cmdlist
,
2390 &show_backtrace_cmdlist
);
2392 /* Debug this files internals. */
2393 add_show_from_set (add_set_cmd ("frame", class_maintenance
, var_zinteger
,
2394 &frame_debug
, "Set frame debugging.\n\
2395 When non-zero, frame specific internal debugging is enabled.", &setdebuglist
),