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, INIT_FRAME_PC and INIT_FRAME_PC_FIRST. */
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,
1308 DEPRECATED_INIT_FRAME_PC_FIRST and
1309 DEPRECATED_FRAME_INIT_SAVED_REGS methods are full of work-arounds
1310 that handle the frame not being correctly set from the start.
1311 Unfortunately those same work-arounds rely on the type defaulting
1312 to NORMAL_FRAME. Ulgh! The new frame code does not have this
1314 prev
->type
= UNKNOWN_FRAME
;
1316 /* A legacy frame's ID is always computed here. Mark it as valid. */
1317 prev
->this_id
.p
= 1;
1319 /* Handle sentinel frame unwind as a special case. */
1320 if (this_frame
->level
< 0)
1322 /* Try to unwind the PC. If that doesn't work, assume we've reached
1323 the oldest frame and simply return. Is there a better sentinal
1324 value? The unwound PC value is then used to initialize the new
1325 previous frame's type.
1327 Note that the pc-unwind is intentionally performed before the
1328 frame chain. This is ok since, for old targets, both
1329 frame_pc_unwind (nee, DEPRECATED_FRAME_SAVED_PC) and
1330 DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
1331 have already been initialized (using
1332 DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
1335 By unwinding the PC first, it becomes possible to, in the case of
1336 a dummy frame, avoid also unwinding the frame ID. This is
1337 because (well ignoring the PPC) a dummy frame can be located
1338 using THIS_FRAME's frame ID. */
1340 deprecated_update_frame_pc_hack (prev
, frame_pc_unwind (this_frame
));
1341 if (get_frame_pc (prev
) == 0)
1343 /* The allocated PREV_FRAME will be reclaimed when the frame
1344 obstack is next purged. */
1347 fprintf_unfiltered (gdb_stdlog
, "-> ");
1348 fprint_frame (gdb_stdlog
, NULL
);
1349 fprintf_unfiltered (gdb_stdlog
,
1350 " // unwound legacy PC zero }\n");
1355 /* Set the unwind functions based on that identified PC. Ditto
1356 for the "type" but strongly prefer the unwinder's frame type. */
1357 prev
->unwind
= frame_unwind_find_by_frame (prev
->next
,
1358 &prev
->prologue_cache
);
1359 if (prev
->unwind
->type
== UNKNOWN_FRAME
)
1360 prev
->type
= frame_type_from_pc (get_frame_pc (prev
));
1362 prev
->type
= prev
->unwind
->type
;
1364 /* Find the prev's frame's ID. */
1365 if (prev
->type
== DUMMY_FRAME
1366 && gdbarch_unwind_dummy_id_p (current_gdbarch
))
1368 /* When unwinding a normal frame, the stack structure is
1369 determined by analyzing the frame's function's code (be
1370 it using brute force prologue analysis, or the dwarf2
1371 CFI). In the case of a dummy frame, that simply isn't
1372 possible. The The PC is either the program entry point,
1373 or some random address on the stack. Trying to use that
1374 PC to apply standard frame ID unwind techniques is just
1375 asking for trouble. */
1376 /* Use an architecture specific method to extract the prev's
1377 dummy ID from the next frame. Note that this method uses
1378 frame_register_unwind to obtain the register values
1379 needed to determine the dummy frame's ID. */
1380 prev
->this_id
.value
= gdbarch_unwind_dummy_id (current_gdbarch
,
1385 /* We're unwinding a sentinel frame, the PC of which is
1386 pointing at a stack dummy. Fake up the dummy frame's ID
1387 using the same sequence as is found a traditional
1388 unwinder. Once all architectures supply the
1389 unwind_dummy_id method, this code can go away. */
1390 prev
->this_id
.value
= frame_id_build (deprecated_read_fp (),
1394 /* Check that the unwound ID is valid. */
1395 if (!frame_id_p (prev
->this_id
.value
))
1399 fprintf_unfiltered (gdb_stdlog
, "-> ");
1400 fprint_frame (gdb_stdlog
, NULL
);
1401 fprintf_unfiltered (gdb_stdlog
,
1402 " // unwound legacy ID invalid }\n");
1407 /* Check that the new frame isn't inner to (younger, below,
1408 next) the old frame. If that happens the frame unwind is
1410 /* FIXME: cagney/2003-02-25: Ignore the sentinel frame since
1411 that doesn't have a valid frame ID. Should instead set the
1412 sentinel frame's frame ID to a `sentinel'. Leave it until
1413 after the switch to storing the frame ID, instead of the
1414 frame base, in the frame object. */
1417 this_frame
->prev
= prev
;
1419 /* FIXME: cagney/2002-01-19: This call will go away. Instead of
1420 initializing extra info, all frames will use the frame_cache
1421 (passed to the unwind functions) to store additional frame
1422 info. Unfortunately legacy targets can't use
1423 legacy_get_prev_frame() to unwind the sentinel frame and,
1424 consequently, are forced to take this code path and rely on
1425 the below call to DEPRECATED_INIT_EXTRA_FRAME_INFO to
1426 initialize the inner-most frame. */
1427 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1429 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, prev
);
1432 if (prev
->type
== NORMAL_FRAME
)
1433 prev
->this_id
.value
.code_addr
1434 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1438 fprintf_unfiltered (gdb_stdlog
, "-> ");
1439 fprint_frame (gdb_stdlog
, prev
);
1440 fprintf_unfiltered (gdb_stdlog
, " } // legacy innermost frame\n");
1445 /* This code only works on normal frames. A sentinel frame, where
1446 the level is -1, should never reach this code. */
1447 gdb_assert (this_frame
->level
>= 0);
1449 /* On some machines it is possible to call a function without
1450 setting up a stack frame for it. On these machines, we
1451 define this macro to take two args; a frameinfo pointer
1452 identifying a frame and a variable to set or clear if it is
1453 or isn't leafless. */
1455 /* Still don't want to worry about this except on the innermost
1456 frame. This macro will set FROMLEAF if THIS_FRAME is a frameless
1457 function invocation. */
1458 if (this_frame
->level
== 0)
1459 /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
1460 the frame chain, not just the inner most frame! The generic,
1461 per-architecture, frame code should handle this and the below
1462 should simply be removed. */
1463 fromleaf
= (DEPRECATED_FRAMELESS_FUNCTION_INVOCATION_P ()
1464 && DEPRECATED_FRAMELESS_FUNCTION_INVOCATION (this_frame
));
1469 /* A frameless inner-most frame. The `FP' (which isn't an
1470 architecture frame-pointer register!) of the caller is the same
1472 /* FIXME: 2002-11-09: There isn't any reason to special case this
1473 edge condition. Instead the per-architecture code should hande
1475 /* FIXME: cagney/2003-06-16: This returns the inner most stack
1476 address for the previous frame, that, however, is wrong. It
1477 should be the inner most stack address for the previous to
1478 previous frame. This is because it is the previous to previous
1479 frame's innermost stack address that is constant through out
1480 the lifetime of the previous frame (trust me :-). */
1481 address
= get_frame_base (this_frame
);
1484 /* Two macros defined in tm.h specify the machine-dependent
1485 actions to be performed here.
1487 First, get the frame's chain-pointer.
1489 If that is zero, the frame is the outermost frame or a leaf
1490 called by the outermost frame. This means that if start
1491 calls main without a frame, we'll return 0 (which is fine
1494 Nope; there's a problem. This also returns when the current
1495 routine is a leaf of main. This is unacceptable. We move
1496 this to after the ffi test; I'd rather have backtraces from
1497 start go curfluy than have an abort called from main not show
1499 if (DEPRECATED_FRAME_CHAIN_P ())
1500 address
= DEPRECATED_FRAME_CHAIN (this_frame
);
1503 /* Someone is part way through coverting an old architecture
1504 to the new frame code. Implement FRAME_CHAIN the way the
1506 /* Find PREV frame's unwinder. */
1507 prev
->unwind
= frame_unwind_find_by_frame (this_frame
,
1508 &prev
->prologue_cache
);
1509 /* FIXME: cagney/2003-04-02: Rather than storing the frame's
1510 type in the frame, the unwinder's type should be returned
1511 directly. Unfortunately, legacy code, called by
1512 legacy_get_prev_frame, explicitly set the frames type
1513 using the method deprecated_set_frame_type(). */
1514 prev
->type
= prev
->unwind
->type
;
1515 /* Find PREV frame's ID. */
1516 prev
->unwind
->this_id (this_frame
,
1517 &prev
->prologue_cache
,
1518 &prev
->this_id
.value
);
1519 prev
->this_id
.p
= 1;
1520 address
= prev
->this_id
.value
.stack_addr
;
1523 if (!legacy_frame_chain_valid (address
, this_frame
))
1527 fprintf_unfiltered (gdb_stdlog
, "-> ");
1528 fprint_frame (gdb_stdlog
, NULL
);
1529 fprintf_unfiltered (gdb_stdlog
,
1530 " // legacy frame chain invalid }\n");
1539 fprintf_unfiltered (gdb_stdlog
, "-> ");
1540 fprint_frame (gdb_stdlog
, NULL
);
1541 fprintf_unfiltered (gdb_stdlog
,
1542 " // legacy frame chain NULL }\n");
1547 /* Link in the already allocated prev frame. */
1548 this_frame
->prev
= prev
;
1549 deprecated_update_frame_base_hack (prev
, address
);
1551 /* This change should not be needed, FIXME! We should determine
1552 whether any targets *need* DEPRECATED_INIT_FRAME_PC to happen
1553 after DEPRECATED_INIT_EXTRA_FRAME_INFO and come up with a simple
1554 way to express what goes on here.
1556 DEPRECATED_INIT_EXTRA_FRAME_INFO is called from two places:
1557 create_new_frame (where the PC is already set up) and here (where
1558 it isn't). DEPRECATED_INIT_FRAME_PC is only called from here,
1559 always after DEPRECATED_INIT_EXTRA_FRAME_INFO.
1561 The catch is the MIPS, where DEPRECATED_INIT_EXTRA_FRAME_INFO
1562 requires the PC value (which hasn't been set yet). Some other
1563 machines appear to require DEPRECATED_INIT_EXTRA_FRAME_INFO
1564 before they can do DEPRECATED_INIT_FRAME_PC. Phoo.
1566 We shouldn't need DEPRECATED_INIT_FRAME_PC_FIRST to add more
1567 complication to an already overcomplicated part of GDB.
1568 gnu@cygnus.com, 15Sep92.
1570 Assuming that some machines need DEPRECATED_INIT_FRAME_PC after
1571 DEPRECATED_INIT_EXTRA_FRAME_INFO, one possible scheme:
1573 SETUP_INNERMOST_FRAME(): Default version is just create_new_frame
1574 (deprecated_read_fp ()), read_pc ()). Machines with extra frame
1575 info would do that (or the local equivalent) and then set the
1578 SETUP_ARBITRARY_FRAME(argc, argv): Only change here is that
1579 create_new_frame would no longer init extra frame info;
1580 SETUP_ARBITRARY_FRAME would have to do that.
1582 INIT_PREV_FRAME(fromleaf, prev) Replace
1583 DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC.
1584 This should also return a flag saying whether to keep the new
1585 frame, or whether to discard it, because on some machines (e.g.
1586 mips) it is really awkward to have DEPRECATED_FRAME_CHAIN_VALID
1587 called BEFORE DEPRECATED_INIT_EXTRA_FRAME_INFO (there is no good
1588 way to get information deduced in DEPRECATED_FRAME_CHAIN_VALID
1589 into the extra fields of the new frame). std_frame_pc(fromleaf,
1592 This is the default setting for INIT_PREV_FRAME. It just does
1593 what the default DEPRECATED_INIT_FRAME_PC does. Some machines
1594 will call it from INIT_PREV_FRAME (either at the beginning, the
1595 end, or in the middle). Some machines won't use it.
1597 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
1599 /* NOTE: cagney/2002-11-09: Just ignore the above! There is no
1600 reason for things to be this complicated.
1602 The trick is to assume that there is always a frame. Instead of
1603 special casing the inner-most frame, create fake frame
1604 (containing the hardware registers) that is inner to the
1605 user-visible inner-most frame (...) and then unwind from that.
1606 That way architecture code can use use the standard
1607 frame_XX_unwind() functions and not differentiate between the
1608 inner most and any other case.
1610 Since there is always a frame to unwind from, there is always
1611 somewhere (THIS_FRAME) to store all the info needed to construct
1612 a new (previous) frame without having to first create it. This
1613 means that the convolution below - needing to carefully order a
1614 frame's initialization - isn't needed.
1616 The irony here though, is that DEPRECATED_FRAME_CHAIN(), at least
1617 for a more up-to-date architecture, always calls
1618 FRAME_SAVED_PC(), and FRAME_SAVED_PC() computes the PC but
1619 without first needing the frame! Instead of the convolution
1620 below, we could have simply called FRAME_SAVED_PC() and been done
1621 with it! Note that FRAME_SAVED_PC() is being superseed by
1622 frame_pc_unwind() and that function does have somewhere to cache
1625 if (DEPRECATED_INIT_FRAME_PC_FIRST_P ())
1626 deprecated_update_frame_pc_hack (prev
,
1627 DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf
,
1630 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1631 DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf
, prev
);
1633 /* This entry is in the frame queue now, which is good since
1634 FRAME_SAVED_PC may use that queue to figure out its value (see
1635 tm-sparc.h). We want the pc saved in the inferior frame. */
1636 if (DEPRECATED_INIT_FRAME_PC_P ())
1637 deprecated_update_frame_pc_hack (prev
,
1638 DEPRECATED_INIT_FRAME_PC (fromleaf
,
1641 /* If ->frame and ->pc are unchanged, we are in the process of
1642 getting ourselves into an infinite backtrace. Some architectures
1643 check this in DEPRECATED_FRAME_CHAIN or thereabouts, but it seems
1644 like there is no reason this can't be an architecture-independent
1646 if (get_frame_base (prev
) == get_frame_base (this_frame
)
1647 && get_frame_pc (prev
) == get_frame_pc (this_frame
))
1649 this_frame
->prev
= NULL
;
1650 obstack_free (&frame_cache_obstack
, prev
);
1653 fprintf_unfiltered (gdb_stdlog
, "-> ");
1654 fprint_frame (gdb_stdlog
, NULL
);
1655 fprintf_unfiltered (gdb_stdlog
,
1656 " // legacy this.id == prev.id }\n");
1661 /* Initialize the code used to unwind the frame PREV based on the PC
1662 (and probably other architectural information). The PC lets you
1663 check things like the debug info at that point (dwarf2cfi?) and
1664 use that to decide how the frame should be unwound.
1666 If there isn't a FRAME_CHAIN, the code above will have already
1668 if (prev
->unwind
== NULL
)
1669 prev
->unwind
= frame_unwind_find_by_frame (prev
->next
,
1670 &prev
->prologue_cache
);
1672 /* If the unwinder provides a frame type, use it. Otherwize
1673 continue on to that heuristic mess. */
1674 if (prev
->unwind
->type
!= UNKNOWN_FRAME
)
1676 prev
->type
= prev
->unwind
->type
;
1677 if (prev
->type
== NORMAL_FRAME
)
1678 /* FIXME: cagney/2003-06-16: would get_frame_pc() be better? */
1679 prev
->this_id
.value
.code_addr
1680 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1683 fprintf_unfiltered (gdb_stdlog
, "-> ");
1684 fprint_frame (gdb_stdlog
, prev
);
1685 fprintf_unfiltered (gdb_stdlog
, " } // legacy with unwound type\n");
1690 /* NOTE: cagney/2002-11-18: The code segments, found in
1691 create_new_frame and get_prev_frame(), that initializes the
1692 frames type is subtly different. The latter only updates ->type
1693 when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME. This stops
1694 get_prev_frame() overriding the frame's type when the INIT code
1695 has previously set it. This is really somewhat bogus. The
1696 initialization, as seen in create_new_frame(), should occur
1697 before the INIT function has been called. */
1698 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1699 && deprecated_pc_in_call_dummy (get_frame_pc (prev
), 0, 0))
1700 prev
->type
= DUMMY_FRAME
;
1703 /* FIXME: cagney/2002-11-10: This should be moved to before the
1704 INIT code above so that the INIT code knows what the frame's
1705 type is (in fact, for a [generic] dummy-frame, the type can
1706 be set and then the entire initialization can be skipped.
1707 Unforunatly, its the INIT code that sets the PC (Hmm, catch
1710 find_pc_partial_function (get_frame_pc (prev
), &name
, NULL
, NULL
);
1711 if (DEPRECATED_PC_IN_SIGTRAMP (get_frame_pc (prev
), name
))
1712 prev
->type
= SIGTRAMP_FRAME
;
1713 /* FIXME: cagney/2002-11-11: Leave prev->type alone. Some
1714 architectures are forcing the frame's type in INIT so we
1715 don't want to override it here. Remember, NORMAL_FRAME == 0,
1716 so it all works (just :-/). Once this initialization is
1717 moved to the start of this function, all this nastness will
1721 if (prev
->type
== NORMAL_FRAME
)
1722 prev
->this_id
.value
.code_addr
1723 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1727 fprintf_unfiltered (gdb_stdlog
, "-> ");
1728 fprint_frame (gdb_stdlog
, prev
);
1729 fprintf_unfiltered (gdb_stdlog
, " } // legacy with confused type\n");
1735 /* Return a "struct frame_info" corresponding to the frame that called
1736 THIS_FRAME. Returns NULL if there is no such frame.
1738 Unlike get_prev_frame, this function always tries to unwind the
1741 static struct frame_info
*
1742 get_prev_frame_1 (struct frame_info
*this_frame
)
1744 struct frame_info
*prev_frame
;
1746 gdb_assert (this_frame
!= NULL
);
1750 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame_1 (this_frame=");
1751 if (this_frame
!= NULL
)
1752 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1754 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1755 fprintf_unfiltered (gdb_stdlog
, ") ");
1758 /* Only try to do the unwind once. */
1759 if (this_frame
->prev_p
)
1763 fprintf_unfiltered (gdb_stdlog
, "-> ");
1764 fprint_frame (gdb_stdlog
, this_frame
->prev
);
1765 fprintf_unfiltered (gdb_stdlog
, " // cached \n");
1767 return this_frame
->prev
;
1769 this_frame
->prev_p
= 1;
1771 /* If any of the old frame initialization methods are around, use
1772 the legacy get_prev_frame method. */
1773 if (legacy_frame_p (current_gdbarch
))
1775 prev_frame
= legacy_get_prev_frame (this_frame
);
1779 /* Check that this frame's ID was valid. If it wasn't, don't try to
1780 unwind to the prev frame. Be careful to not apply this test to
1781 the sentinel frame. */
1782 if (this_frame
->level
>= 0 && !frame_id_p (get_frame_id (this_frame
)))
1786 fprintf_unfiltered (gdb_stdlog
, "-> ");
1787 fprint_frame (gdb_stdlog
, NULL
);
1788 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1793 /* Check that this frame's ID isn't inner to (younger, below, next)
1794 the next frame. This happens when a frame unwind goes backwards.
1795 Exclude signal trampolines (due to sigaltstack the frame ID can
1796 go backwards) and sentinel frames (the test is meaningless). */
1797 if (this_frame
->next
->level
>= 0
1798 && this_frame
->next
->type
!= SIGTRAMP_FRAME
1799 && frame_id_inner (get_frame_id (this_frame
),
1800 get_frame_id (this_frame
->next
)))
1801 error ("Previous frame inner to this frame (corrupt stack?)");
1803 /* Check that this and the next frame are not identical. If they
1804 are, there is most likely a stack cycle. As with the inner-than
1805 test above, avoid comparing the inner-most and sentinel frames. */
1806 if (this_frame
->level
> 0
1807 && frame_id_eq (get_frame_id (this_frame
),
1808 get_frame_id (this_frame
->next
)))
1809 error ("Previous frame identical to this frame (corrupt stack?)");
1811 /* Allocate the new frame but do not wire it in to the frame chain.
1812 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1813 frame->next to pull some fancy tricks (of course such code is, by
1814 definition, recursive). Try to prevent it.
1816 There is no reason to worry about memory leaks, should the
1817 remainder of the function fail. The allocated memory will be
1818 quickly reclaimed when the frame cache is flushed, and the `we've
1819 been here before' check above will stop repeated memory
1820 allocation calls. */
1821 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1822 prev_frame
->level
= this_frame
->level
+ 1;
1824 /* Don't yet compute ->unwind (and hence ->type). It is computed
1825 on-demand in get_frame_type, frame_register_unwind, and
1828 /* Don't yet compute the frame's ID. It is computed on-demand by
1831 /* The unwound frame ID is validate at the start of this function,
1832 as part of the logic to decide if that frame should be further
1833 unwound, and not here while the prev frame is being created.
1834 Doing this makes it possible for the user to examine a frame that
1835 has an invalid frame ID.
1837 Some very old VAX code noted: [...] For the sake of argument,
1838 suppose that the stack is somewhat trashed (which is one reason
1839 that "info frame" exists). So, return 0 (indicating we don't
1840 know the address of the arglist) if we don't know what frame this
1844 this_frame
->prev
= prev_frame
;
1845 prev_frame
->next
= this_frame
;
1849 fprintf_unfiltered (gdb_stdlog
, "-> ");
1850 fprint_frame (gdb_stdlog
, prev_frame
);
1851 fprintf_unfiltered (gdb_stdlog
, " }\n");
1857 /* Debug routine to print a NULL frame being returned. */
1860 frame_debug_got_null_frame (struct ui_file
*file
,
1861 struct frame_info
*this_frame
,
1866 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1867 if (this_frame
!= NULL
)
1868 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1870 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1871 fprintf_unfiltered (gdb_stdlog
, ") -> // %s}\n", reason
);
1875 /* Return a structure containing various interesting information about
1876 the frame that called THIS_FRAME. Returns NULL if there is entier
1877 no such frame or the frame fails any of a set of target-independent
1878 condition that should terminate the frame chain (e.g., as unwinding
1881 This function should not contain target-dependent tests, such as
1882 checking whether the program-counter is zero. */
1885 get_prev_frame (struct frame_info
*this_frame
)
1887 struct frame_info
*prev_frame
;
1889 /* Return the inner-most frame, when the caller passes in NULL. */
1890 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1891 caller should have previously obtained a valid frame using
1892 get_selected_frame() and then called this code - only possibility
1893 I can think of is code behaving badly.
1895 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1896 block_innermost_frame(). It does the sequence: frame = NULL;
1897 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1898 it couldn't be written better, I don't know.
1900 NOTE: cagney/2003-01-11: I suspect what is happening is
1901 block_innermost_frame() is, when the target has no state
1902 (registers, memory, ...), still calling this function. The
1903 assumption being that this function will return NULL indicating
1904 that a frame isn't possible, rather than checking that the target
1905 has state and then calling get_current_frame() and
1906 get_prev_frame(). This is a guess mind. */
1907 if (this_frame
== NULL
)
1909 /* NOTE: cagney/2002-11-09: There was a code segment here that
1910 would error out when CURRENT_FRAME was NULL. The comment
1911 that went with it made the claim ...
1913 ``This screws value_of_variable, which just wants a nice
1914 clean NULL return from block_innermost_frame if there are no
1915 frames. I don't think I've ever seen this message happen
1916 otherwise. And returning NULL here is a perfectly legitimate
1919 Per the above, this code shouldn't even be called with a NULL
1921 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "this_frame NULL");
1922 return current_frame
;
1925 /* There is always a frame. If this assertion fails, suspect that
1926 something should be calling get_selected_frame() or
1927 get_current_frame(). */
1928 gdb_assert (this_frame
!= NULL
);
1930 /* Make sure we pass an address within THIS_FRAME's code block to
1931 inside_main_func. Otherwise, we might stop unwinding at a
1932 function which has a call instruction as its last instruction if
1933 that function immediately precedes main(). */
1934 if (this_frame
->level
>= 0
1935 && !backtrace_past_main
1936 && inside_main_func (get_frame_address_in_block (this_frame
)))
1937 /* Don't unwind past main(), bug always unwind the sentinel frame.
1938 Note, this is done _before_ the frame has been marked as
1939 previously unwound. That way if the user later decides to
1940 allow unwinds past main(), that just happens. */
1942 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside main func");
1946 if (this_frame
->level
> backtrace_limit
)
1948 error ("Backtrace limit of %d exceeded", backtrace_limit
);
1951 /* If we're already inside the entry function for the main objfile,
1952 then it isn't valid. Don't apply this test to a dummy frame -
1953 dummy frame PC's typically land in the entry func. Don't apply
1954 this test to the sentinel frame. Sentinel frames should always
1955 be allowed to unwind. */
1956 /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1957 hard evidence that this is needed. */
1958 /* NOTE: cagney/2003-07-07: Fixed a bug in inside_main_func - wasn't
1959 checking for "main" in the minimal symbols. With that fixed
1960 asm-source tests now stop in "main" instead of halting the
1961 backtrace in wierd and wonderful ways somewhere inside the entry
1962 file. Suspect that deprecated_inside_entry_file and
1963 inside_entry_func tests were added to work around that (now
1965 /* NOTE: cagney/2003-07-15: danielj (if I'm reading it right)
1966 suggested having the inside_entry_func test use the
1967 inside_main_func msymbol trick (along with entry_point_address I
1968 guess) to determine the address range of the start function.
1969 That should provide a far better stopper than the current
1971 /* NOTE: cagney/2003-07-15: Need to add a "set backtrace
1972 beyond-entry-func" command so that this can be selectively
1976 && backtrace_beyond_entry_func
1978 && this_frame
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1979 && inside_entry_func (this_frame
))
1981 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry func");
1985 /* If we're inside the entry file, it isn't valid. Don't apply this
1986 test to a dummy frame - dummy frame PC's typically land in the
1987 entry file. Don't apply this test to the sentinel frame.
1988 Sentinel frames should always be allowed to unwind. */
1989 /* NOTE: drow/2002-12-25: should there be a way to disable this
1990 check? It assumes a single small entry file, and the way some
1991 debug readers (e.g. dbxread) figure out which object is the
1992 entry file is somewhat hokey. */
1993 /* NOTE: cagney/2003-01-10: If there is a way of disabling this test
1994 then it should probably be moved to before the ->prev_p test,
1996 /* NOTE: vinschen/2003-04-01: Disabled. It turns out that the call
1997 to deprecated_inside_entry_file destroys a meaningful backtrace
1998 under some conditions. E. g. the backtrace tests in the
1999 asm-source testcase are broken for some targets. In this test
2000 the functions are all implemented as part of one file and the
2001 testcase is not necessarily linked with a start file (depending
2002 on the target). What happens is, that the first frame is printed
2003 normaly and following frames are treated as being inside the
2004 enttry file then. This way, only the #0 frame is printed in the
2005 backtrace output. */
2007 && this_frame
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
2008 && deprecated_inside_entry_file (get_frame_pc (this_frame
)))
2010 frame_debug_got_null_frame (gdb_stdlog
, this_frame
, "inside entry file");
2014 return get_prev_frame_1 (this_frame
);
2018 get_frame_pc (struct frame_info
*frame
)
2020 gdb_assert (frame
->next
!= NULL
);
2021 return frame_pc_unwind (frame
->next
);
2024 /* Return an address of that falls within the frame's code block. */
2027 frame_unwind_address_in_block (struct frame_info
*next_frame
)
2029 /* A draft address. */
2030 CORE_ADDR pc
= frame_pc_unwind (next_frame
);
2032 /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
2033 and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
2034 frame's PC ends up pointing at the instruction fallowing the
2035 "call". Adjust that PC value so that it falls on the call
2036 instruction (which, hopefully, falls within THIS frame's code
2037 block. So far it's proved to be a very good approximation. See
2038 get_frame_type for why ->type can't be used. */
2039 if (next_frame
->level
>= 0
2040 && get_frame_type (next_frame
) == NORMAL_FRAME
)
2046 get_frame_address_in_block (struct frame_info
*this_frame
)
2048 return frame_unwind_address_in_block (this_frame
->next
);
2052 pc_notcurrent (struct frame_info
*frame
)
2054 /* If FRAME is not the innermost frame, that normally means that
2055 FRAME->pc points at the return instruction (which is *after* the
2056 call instruction), and we want to get the line containing the
2057 call (because the call is where the user thinks the program is).
2058 However, if the next frame is either a SIGTRAMP_FRAME or a
2059 DUMMY_FRAME, then the next frame will contain a saved interrupt
2060 PC and such a PC indicates the current (rather than next)
2061 instruction/line, consequently, for such cases, want to get the
2062 line containing fi->pc. */
2063 struct frame_info
*next
= get_next_frame (frame
);
2064 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
2069 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
2071 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
2074 /* Per "frame.h", return the ``address'' of the frame. Code should
2075 really be using get_frame_id(). */
2077 get_frame_base (struct frame_info
*fi
)
2079 return get_frame_id (fi
).stack_addr
;
2082 /* High-level offsets into the frame. Used by the debug info. */
2085 get_frame_base_address (struct frame_info
*fi
)
2087 if (get_frame_type (fi
) != NORMAL_FRAME
)
2089 if (fi
->base
== NULL
)
2090 fi
->base
= frame_base_find_by_frame (fi
->next
);
2091 /* Sneaky: If the low-level unwind and high-level base code share a
2092 common unwinder, let them share the prologue cache. */
2093 if (fi
->base
->unwind
== fi
->unwind
)
2094 return fi
->base
->this_base (fi
->next
, &fi
->prologue_cache
);
2095 return fi
->base
->this_base (fi
->next
, &fi
->base_cache
);
2099 get_frame_locals_address (struct frame_info
*fi
)
2102 if (get_frame_type (fi
) != NORMAL_FRAME
)
2104 /* If there isn't a frame address method, find it. */
2105 if (fi
->base
== NULL
)
2106 fi
->base
= frame_base_find_by_frame (fi
->next
);
2107 /* Sneaky: If the low-level unwind and high-level base code share a
2108 common unwinder, let them share the prologue cache. */
2109 if (fi
->base
->unwind
== fi
->unwind
)
2110 cache
= &fi
->prologue_cache
;
2112 cache
= &fi
->base_cache
;
2113 return fi
->base
->this_locals (fi
->next
, cache
);
2117 get_frame_args_address (struct frame_info
*fi
)
2120 if (get_frame_type (fi
) != NORMAL_FRAME
)
2122 /* If there isn't a frame address method, find it. */
2123 if (fi
->base
== NULL
)
2124 fi
->base
= frame_base_find_by_frame (fi
->next
);
2125 /* Sneaky: If the low-level unwind and high-level base code share a
2126 common unwinder, let them share the prologue cache. */
2127 if (fi
->base
->unwind
== fi
->unwind
)
2128 cache
= &fi
->prologue_cache
;
2130 cache
= &fi
->base_cache
;
2131 return fi
->base
->this_args (fi
->next
, cache
);
2134 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2135 or -1 for a NULL frame. */
2138 frame_relative_level (struct frame_info
*fi
)
2147 get_frame_type (struct frame_info
*frame
)
2149 /* Some targets still don't use [generic] dummy frames. Catch them
2151 if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
2152 && deprecated_frame_in_dummy (frame
))
2155 /* Some legacy code, e.g, mips_init_extra_frame_info() wants
2156 to determine the frame's type prior to it being completely
2157 initialized. Don't attempt to lazily initialize ->unwind for
2158 legacy code. It will be initialized in legacy_get_prev_frame(). */
2159 if (frame
->unwind
== NULL
&& !legacy_frame_p (current_gdbarch
))
2161 /* Initialize the frame's unwinder because it is that which
2162 provides the frame's type. */
2163 frame
->unwind
= frame_unwind_find_by_frame (frame
->next
,
2164 &frame
->prologue_cache
);
2165 /* FIXME: cagney/2003-04-02: Rather than storing the frame's
2166 type in the frame, the unwinder's type should be returned
2167 directly. Unfortunately, legacy code, called by
2168 legacy_get_prev_frame, explicitly set the frames type using
2169 the method deprecated_set_frame_type(). */
2170 frame
->type
= frame
->unwind
->type
;
2172 if (frame
->type
== UNKNOWN_FRAME
)
2173 return NORMAL_FRAME
;
2179 deprecated_set_frame_type (struct frame_info
*frame
, enum frame_type type
)
2181 /* Arrrg! See comment in "frame.h". */
2185 struct frame_extra_info
*
2186 get_frame_extra_info (struct frame_info
*fi
)
2188 return fi
->extra_info
;
2191 struct frame_extra_info
*
2192 frame_extra_info_zalloc (struct frame_info
*fi
, long size
)
2194 fi
->extra_info
= frame_obstack_zalloc (size
);
2195 return fi
->extra_info
;
2199 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
2202 fprintf_unfiltered (gdb_stdlog
,
2203 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
2204 frame
->level
, paddr_nz (pc
));
2205 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
2206 maintaining a locally allocated frame object. Since such frame's
2207 are not in the frame chain, it isn't possible to assume that the
2208 frame has a next. Sigh. */
2209 if (frame
->next
!= NULL
)
2211 /* While we're at it, update this frame's cached PC value, found
2212 in the next frame. Oh for the day when "struct frame_info"
2213 is opaque and this hack on hack can just go away. */
2214 frame
->next
->prev_pc
.value
= pc
;
2215 frame
->next
->prev_pc
.p
= 1;
2220 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
2223 fprintf_unfiltered (gdb_stdlog
,
2224 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
2225 frame
->level
, paddr_nz (base
));
2226 /* See comment in "frame.h". */
2227 frame
->this_id
.value
.stack_addr
= base
;
2231 deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs
,
2232 long sizeof_extra_info
)
2234 struct frame_info
*frame
= XMALLOC (struct frame_info
);
2235 memset (frame
, 0, sizeof (*frame
));
2236 frame
->this_id
.p
= 1;
2237 make_cleanup (xfree
, frame
);
2238 if (sizeof_saved_regs
> 0)
2240 frame
->saved_regs
= xcalloc (1, sizeof_saved_regs
);
2241 make_cleanup (xfree
, frame
->saved_regs
);
2243 if (sizeof_extra_info
> 0)
2245 frame
->extra_info
= xcalloc (1, sizeof_extra_info
);
2246 make_cleanup (xfree
, frame
->extra_info
);
2251 /* Memory access methods. */
2254 get_frame_memory (struct frame_info
*this_frame
, CORE_ADDR addr
, void *buf
,
2257 read_memory (addr
, buf
, len
);
2261 get_frame_memory_signed (struct frame_info
*this_frame
, CORE_ADDR addr
,
2264 return read_memory_integer (addr
, len
);
2268 get_frame_memory_unsigned (struct frame_info
*this_frame
, CORE_ADDR addr
,
2271 return read_memory_unsigned_integer (addr
, len
);
2275 safe_frame_unwind_memory (struct frame_info
*this_frame
,
2276 CORE_ADDR addr
, void *buf
, int len
)
2278 /* NOTE: read_memory_nobpt returns zero on success! */
2279 return !read_memory_nobpt (addr
, buf
, len
);
2282 /* Architecture method. */
2285 get_frame_arch (struct frame_info
*this_frame
)
2287 return current_gdbarch
;
2290 /* Stack pointer methods. */
2293 get_frame_sp (struct frame_info
*this_frame
)
2295 return frame_sp_unwind (this_frame
->next
);
2299 frame_sp_unwind (struct frame_info
*next_frame
)
2301 /* Normality, an architecture that provides a way of obtaining any
2302 frame inner-most address. */
2303 if (gdbarch_unwind_sp_p (current_gdbarch
))
2304 return gdbarch_unwind_sp (current_gdbarch
, next_frame
);
2305 /* Things are looking grim. If it's the inner-most frame and there
2306 is a TARGET_READ_SP then that can be used. */
2307 if (next_frame
->level
< 0 && TARGET_READ_SP_P ())
2308 return TARGET_READ_SP ();
2309 /* Now things are really are grim. Hope that the value returned by
2310 the SP_REGNUM register is meaningful. */
2314 frame_unwind_unsigned_register (next_frame
, SP_REGNUM
, &sp
);
2317 internal_error (__FILE__
, __LINE__
, "Missing unwind SP method");
2322 legacy_frame_p (struct gdbarch
*current_gdbarch
)
2324 if (DEPRECATED_INIT_FRAME_PC_P ()
2325 || DEPRECATED_INIT_FRAME_PC_FIRST_P ()
2326 || DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()
2327 || DEPRECATED_FRAME_CHAIN_P ())
2328 /* No question, it's a legacy frame. */
2330 if (gdbarch_unwind_dummy_id_p (current_gdbarch
))
2331 /* No question, it's not a legacy frame (provided none of the
2332 deprecated methods checked above are present that is). */
2334 if (DEPRECATED_TARGET_READ_FP_P ()
2335 || DEPRECATED_FP_REGNUM
>= 0)
2336 /* Assume it's legacy. If you're trying to convert a legacy frame
2337 target to the new mechanism, get rid of these. legacy
2338 get_prev_frame requires these when unwind_frame_id isn't
2341 /* Default to assuming that it's brand new code, and hence not
2342 legacy. Force it down the non-legacy path so that the new code
2343 uses the new frame mechanism from day one. Dummy frame's won't
2344 work very well but we can live with that. */
2348 extern initialize_file_ftype _initialize_frame
; /* -Wmissing-prototypes */
2350 static struct cmd_list_element
*set_backtrace_cmdlist
;
2351 static struct cmd_list_element
*show_backtrace_cmdlist
;
2354 set_backtrace_cmd (char *args
, int from_tty
)
2356 help_list (set_backtrace_cmdlist
, "set backtrace ", -1, gdb_stdout
);
2360 show_backtrace_cmd (char *args
, int from_tty
)
2362 cmd_show_list (show_backtrace_cmdlist
, from_tty
, "");
2366 _initialize_frame (void)
2368 obstack_init (&frame_cache_obstack
);
2370 add_prefix_cmd ("backtrace", class_maintenance
, set_backtrace_cmd
, "\
2371 Set backtrace specific variables.\n\
2372 Configure backtrace variables such as the backtrace limit",
2373 &set_backtrace_cmdlist
, "set backtrace ",
2374 0/*allow-unknown*/, &setlist
);
2375 add_prefix_cmd ("backtrace", class_maintenance
, show_backtrace_cmd
, "\
2376 Show backtrace specific variables\n\
2377 Show backtrace variables such as the backtrace limit",
2378 &show_backtrace_cmdlist
, "show backtrace ",
2379 0/*allow-unknown*/, &showlist
);
2381 add_setshow_boolean_cmd ("past-main", class_obscure
,
2382 &backtrace_past_main
, "\
2383 Set whether backtraces should continue past \"main\".\n\
2384 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2385 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2386 of the stack trace.", "\
2387 Show whether backtraces should continue past \"main\".\n\
2388 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2389 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2390 of the stack trace.",
2391 NULL
, NULL
, &set_backtrace_cmdlist
,
2392 &show_backtrace_cmdlist
);
2394 add_setshow_uinteger_cmd ("limit", class_obscure
,
2395 &backtrace_limit
, "\
2396 Set an upper bound on the number of backtrace levels.\n\
2397 No more than the specified number of frames can be displayed or examined.\n\
2398 Zero is unlimited.", "\
2399 Show the upper bound on the number of backtrace levels.",
2400 NULL
, NULL
, &set_backtrace_cmdlist
,
2401 &show_backtrace_cmdlist
);
2403 /* Debug this files internals. */
2404 add_show_from_set (add_set_cmd ("frame", class_maintenance
, var_zinteger
,
2405 &frame_debug
, "Set frame debugging.\n\
2406 When non-zero, frame specific internal debugging is enabled.", &setdebuglist
),