1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4 2001, 2002, 2003 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "inferior.h" /* for inferior_ptid */
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
31 #include "builtin-regs.h"
32 #include "gdb_obstack.h"
33 #include "dummy-frame.h"
34 #include "sentinel-frame.h"
38 #include "frame-unwind.h"
39 #include "frame-base.h"
43 /* We keep a cache of stack frames, each of which is a "struct
44 frame_info". The innermost one gets allocated (in
45 wait_for_inferior) each time the inferior stops; current_frame
46 points to it. Additional frames get allocated (in get_prev_frame)
47 as needed, and are chained through the next and prev fields. Any
48 time that the frame cache becomes invalid (most notably when we
49 execute something, but also if we change how we interpret the
50 frames (e.g. "set heuristic-fence-post" in mips-tdep.c, or anything
51 which reads new symbols)), we should call reinit_frame_cache. */
55 /* Level of this frame. The inner-most (youngest) frame is at level
56 0. As you move towards the outer-most (oldest) frame, the level
57 increases. This is a cached value. It could just as easily be
58 computed by counting back from the selected frame to the inner
60 /* NOTE: cagney/2002-04-05: Perhaphs a level of ``-1'' should be
61 reserved to indicate a bogus frame - one that has been created
62 just to keep GDB happy (GDB always needs a frame). For the
63 moment leave this as speculation. */
66 /* The frame's type. */
67 /* FIXME: cagney/2003-04-02: Should instead be returning
68 ->unwind->type. Unfortunatly, legacy code is still explicitly
69 setting the type using the method deprecated_set_frame_type.
70 Eliminate that method and this field can be eliminated. */
73 /* For each register, address of where it was saved on entry to the
74 frame, or zero if it was not saved on entry to this frame. This
75 includes special registers such as pc and fp saved in special
76 ways in the stack frame. The SP_REGNUM is even more special, the
77 address here is the sp for the previous frame, not the address
78 where the sp was saved. */
79 /* Allocated by frame_saved_regs_zalloc () which is called /
80 initialized by DEPRECATED_FRAME_INIT_SAVED_REGS(). */
81 CORE_ADDR
*saved_regs
; /*NUM_REGS + NUM_PSEUDO_REGS*/
83 /* Anything extra for this structure that may have been defined in
84 the machine dependent files. */
85 /* Allocated by frame_extra_info_zalloc () which is called /
86 initialized by DEPRECATED_INIT_EXTRA_FRAME_INFO */
87 struct frame_extra_info
*extra_info
;
89 /* If dwarf2 unwind frame informations is used, this structure holds
90 all related unwind data. */
91 struct context
*context
;
93 /* The frame's low-level unwinder and corresponding cache. The
94 low-level unwinder is responsible for unwinding register values
95 for the previous frame. The low-level unwind methods are
96 selected based on the presence, or otherwize, of register unwind
97 information such as CFI. */
99 const struct frame_unwind
*unwind
;
101 /* Cached copy of the previous frame's resume address. */
107 /* Cached copy of the previous frame's function address. */
114 /* This frame's ID. */
118 struct frame_id value
;
121 /* The frame's high-level base methods, and corresponding cache.
122 The high level base methods are selected based on the frame's
124 const struct frame_base
*base
;
127 /* Pointers to the next (down, inner, younger) and previous (up,
128 outer, older) frame_info's in the frame cache. */
129 struct frame_info
*next
; /* down, inner, younger */
131 struct frame_info
*prev
; /* up, outer, older */
134 /* Flag to control debugging. */
136 static int frame_debug
;
138 /* Flag to indicate whether backtraces should stop at main. */
140 static int backtrace_below_main
;
143 fprint_frame_id (struct ui_file
*file
, struct frame_id id
)
145 fprintf_unfiltered (file
, "{stack=0x%s,code=0x%s}",
146 paddr_nz (id
.stack_addr
),
147 paddr_nz (id
.code_addr
));
151 fprint_frame_type (struct ui_file
*file
, enum frame_type type
)
156 fprintf_unfiltered (file
, "UNKNOWN_FRAME");
159 fprintf_unfiltered (file
, "NORMAL_FRAME");
162 fprintf_unfiltered (file
, "DUMMY_FRAME");
165 fprintf_unfiltered (file
, "SIGTRAMP_FRAME");
168 fprintf_unfiltered (file
, "<unknown type>");
174 fprint_frame (struct ui_file
*file
, struct frame_info
*fi
)
178 fprintf_unfiltered (file
, "<NULL frame>");
181 fprintf_unfiltered (file
, "{");
182 fprintf_unfiltered (file
, "level=%d", fi
->level
);
183 fprintf_unfiltered (file
, ",");
184 fprintf_unfiltered (file
, "type=");
185 fprint_frame_type (file
, fi
->type
);
186 fprintf_unfiltered (file
, ",");
187 fprintf_unfiltered (file
, "unwind=");
188 if (fi
->unwind
!= NULL
)
189 gdb_print_host_address (fi
->unwind
, file
);
191 fprintf_unfiltered (file
, "<unknown>");
192 fprintf_unfiltered (file
, ",");
193 fprintf_unfiltered (file
, "pc=");
194 if (fi
->next
!= NULL
&& fi
->next
->prev_pc
.p
)
195 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_pc
.value
));
197 fprintf_unfiltered (file
, "<unknown>");
198 fprintf_unfiltered (file
, ",");
199 fprintf_unfiltered (file
, "id=");
201 fprint_frame_id (file
, fi
->this_id
.value
);
203 fprintf_unfiltered (file
, "<unknown>");
204 fprintf_unfiltered (file
, ",");
205 fprintf_unfiltered (file
, "func=");
206 if (fi
->next
!= NULL
&& fi
->next
->prev_func
.p
)
207 fprintf_unfiltered (file
, "0x%s", paddr_nz (fi
->next
->prev_func
.addr
));
209 fprintf_unfiltered (file
, "<unknown>");
210 fprintf_unfiltered (file
, "}");
213 /* Return a frame uniq ID that can be used to, later, re-find the
217 get_frame_id (struct frame_info
*fi
)
221 return null_frame_id
;
225 gdb_assert (!legacy_frame_p (current_gdbarch
));
227 fprintf_unfiltered (gdb_stdlog
, "{ get_frame_id (fi=%d) ",
229 /* Find THIS frame's ID. */
230 fi
->unwind
->this_id (fi
->next
, &fi
->prologue_cache
, &fi
->this_id
.value
);
234 fprintf_unfiltered (gdb_stdlog
, "-> ");
235 fprint_frame_id (gdb_stdlog
, fi
->this_id
.value
);
236 fprintf_unfiltered (gdb_stdlog
, " }\n");
239 return fi
->this_id
.value
;
242 const struct frame_id null_frame_id
; /* All zeros. */
245 frame_id_build (CORE_ADDR stack_addr
, CORE_ADDR code_addr
)
248 id
.stack_addr
= stack_addr
;
249 id
.code_addr
= code_addr
;
254 frame_id_p (struct frame_id l
)
257 /* The .code can be NULL but the .stack cannot. */
258 p
= (l
.stack_addr
!= 0);
261 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_p (l=");
262 fprint_frame_id (gdb_stdlog
, l
);
263 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", p
);
269 frame_id_eq (struct frame_id l
, struct frame_id r
)
272 if (l
.stack_addr
== 0 || r
.stack_addr
== 0)
273 /* Like a NaN, if either ID is invalid, the result is false. */
275 else if (l
.stack_addr
!= r
.stack_addr
)
276 /* If .stack addresses are different, the frames are different. */
278 else if (l
.code_addr
== 0 || r
.code_addr
== 0)
279 /* A zero code addr is a wild card, always succeed. */
281 else if (l
.code_addr
== r
.code_addr
)
282 /* The .stack and .code are identical, the ID's are identical. */
285 /* FIXME: cagney/2003-04-06: This should be zero. Can't yet do
286 this because most frame ID's are not being initialized
291 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_eq (l=");
292 fprint_frame_id (gdb_stdlog
, l
);
293 fprintf_unfiltered (gdb_stdlog
, ",r=");
294 fprint_frame_id (gdb_stdlog
, r
);
295 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", eq
);
301 frame_id_inner (struct frame_id l
, struct frame_id r
)
304 if (l
.stack_addr
== 0 || r
.stack_addr
== 0)
305 /* Like NaN, any operation involving an invalid ID always fails. */
308 /* Only return non-zero when strictly inner than. Note that, per
309 comment in "frame.h", there is some fuzz here. Frameless
310 functions are not strictly inner than (same .stack but
312 inner
= INNER_THAN (l
.stack_addr
, r
.stack_addr
);
315 fprintf_unfiltered (gdb_stdlog
, "{ frame_id_inner (l=");
316 fprint_frame_id (gdb_stdlog
, l
);
317 fprintf_unfiltered (gdb_stdlog
, ",r=");
318 fprint_frame_id (gdb_stdlog
, r
);
319 fprintf_unfiltered (gdb_stdlog
, ") -> %d }\n", inner
);
325 frame_find_by_id (struct frame_id id
)
327 struct frame_info
*frame
;
329 /* ZERO denotes the null frame, let the caller decide what to do
330 about it. Should it instead return get_current_frame()? */
331 if (!frame_id_p (id
))
334 for (frame
= get_current_frame ();
336 frame
= get_prev_frame (frame
))
338 struct frame_id
this = get_frame_id (frame
);
339 if (frame_id_eq (id
, this))
340 /* An exact match. */
342 if (frame_id_inner (id
, this))
345 /* Either, we're not yet gone far enough out along the frame
346 chain (inner(this,id), or we're comparing frameless functions
347 (same .base, different .func, no test available). Struggle
348 on until we've definitly gone to far. */
354 frame_pc_unwind (struct frame_info
*this_frame
)
356 if (!this_frame
->prev_pc
.p
)
359 if (gdbarch_unwind_pc_p (current_gdbarch
))
361 /* The right way. The `pure' way. The one true way. This
362 method depends solely on the register-unwind code to
363 determine the value of registers in THIS frame, and hence
364 the value of this frame's PC (resume address). A typical
365 implementation is no more than:
367 frame_unwind_register (this_frame, ISA_PC_REGNUM, buf);
368 return extract_address (buf, size of ISA_PC_REGNUM);
370 Note: this method is very heavily dependent on a correct
371 register-unwind implementation, it pays to fix that
372 method first; this method is frame type agnostic, since
373 it only deals with register values, it works with any
374 frame. This is all in stark contrast to the old
375 FRAME_SAVED_PC which would try to directly handle all the
376 different ways that a PC could be unwound. */
377 pc
= gdbarch_unwind_pc (current_gdbarch
, this_frame
);
379 else if (this_frame
->level
< 0)
381 /* FIXME: cagney/2003-03-06: Old code and and a sentinel
382 frame. Do like was always done. Fetch the PC's value
383 direct from the global registers array (via read_pc).
384 This assumes that this frame belongs to the current
385 global register cache. The assumption is dangerous. */
388 else if (DEPRECATED_FRAME_SAVED_PC_P ())
390 /* FIXME: cagney/2003-03-06: Old code, but not a sentinel
391 frame. Do like was always done. Note that this method,
392 unlike unwind_pc(), tries to handle all the different
393 frame cases directly. It fails. */
394 pc
= DEPRECATED_FRAME_SAVED_PC (this_frame
);
397 internal_error (__FILE__
, __LINE__
, "No gdbarch_unwind_pc method");
398 this_frame
->prev_pc
.value
= pc
;
399 this_frame
->prev_pc
.p
= 1;
401 fprintf_unfiltered (gdb_stdlog
,
402 "{ frame_pc_unwind (this_frame=%d) -> 0x%s }\n",
404 paddr_nz (this_frame
->prev_pc
.value
));
406 return this_frame
->prev_pc
.value
;
410 frame_func_unwind (struct frame_info
*fi
)
412 if (!fi
->prev_func
.p
)
415 fi
->prev_func
.addr
= get_pc_function_start (frame_pc_unwind (fi
));
417 fprintf_unfiltered (gdb_stdlog
,
418 "{ frame_func_unwind (fi=%d) -> 0x%s }\n",
419 fi
->level
, paddr_nz (fi
->prev_func
.addr
));
421 return fi
->prev_func
.addr
;
425 get_frame_func (struct frame_info
*fi
)
427 return frame_func_unwind (fi
->next
);
431 do_frame_unwind_register (void *src
, int regnum
, void *buf
)
433 frame_unwind_register (src
, regnum
, buf
);
438 frame_pop (struct frame_info
*this_frame
)
440 struct regcache
*scratch_regcache
;
441 struct cleanup
*cleanups
;
443 if (DEPRECATED_POP_FRAME_P ())
445 /* A legacy architecture that has implemented a custom pop
446 function. All new architectures should instead be using the
447 generic code below. */
448 DEPRECATED_POP_FRAME
;
452 /* Make a copy of all the register values unwound from this
453 frame. Save them in a scratch buffer so that there isn't a
454 race betweening trying to extract the old values from the
455 current_regcache while, at the same time writing new values
456 into that same cache. */
457 struct regcache
*scratch
= regcache_xmalloc (current_gdbarch
);
458 struct cleanup
*cleanups
= make_cleanup_regcache_xfree (scratch
);
459 regcache_save (scratch
, do_frame_unwind_register
, this_frame
);
460 /* FIXME: cagney/2003-03-16: It should be possible to tell the
461 target's register cache that it is about to be hit with a
462 burst register transfer and that the sequence of register
463 writes should be batched. The pair target_prepare_to_store()
464 and target_store_registers() kind of suggest this
465 functionality. Unfortunatly, they don't implement it. Their
466 lack of a formal definition can lead to targets writing back
467 bogus values (arguably a bug in the target code mind). */
468 /* Now copy those saved registers into the current regcache.
469 Here, regcache_cpy() calls regcache_restore(). */
470 regcache_cpy (current_regcache
, scratch
);
471 do_cleanups (cleanups
);
473 /* We've made right mess of GDB's local state, just discard
475 flush_cached_frames ();
479 frame_register_unwind (struct frame_info
*frame
, int regnum
,
480 int *optimizedp
, enum lval_type
*lvalp
,
481 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
483 struct frame_unwind_cache
*cache
;
487 fprintf_unfiltered (gdb_stdlog
,
488 "{ frame_register_unwind (frame=%d,regnum=\"%s\",...) ",
489 frame
->level
, frame_map_regnum_to_name (regnum
));
492 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
493 that the value proper does not need to be fetched. */
494 gdb_assert (optimizedp
!= NULL
);
495 gdb_assert (lvalp
!= NULL
);
496 gdb_assert (addrp
!= NULL
);
497 gdb_assert (realnump
!= NULL
);
498 /* gdb_assert (bufferp != NULL); */
500 /* NOTE: cagney/2002-11-27: A program trying to unwind a NULL frame
501 is broken. There is always a frame. If there, for some reason,
502 isn't, there is some pretty busted code as it should have
503 detected the problem before calling here. */
504 gdb_assert (frame
!= NULL
);
506 /* Ask this frame to unwind its register. See comment in
507 "frame-unwind.h" for why NEXT frame and this unwind cace are
509 frame
->unwind
->prev_register (frame
->next
, &frame
->prologue_cache
, regnum
,
510 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
514 fprintf_unfiltered (gdb_stdlog
, "->");
515 fprintf_unfiltered (gdb_stdlog
, " *optimizedp=%d", (*optimizedp
));
516 fprintf_unfiltered (gdb_stdlog
, " *lvalp=%d", (int) (*lvalp
));
517 fprintf_unfiltered (gdb_stdlog
, " *addrp=0x%s", paddr_nz ((*addrp
)));
518 fprintf_unfiltered (gdb_stdlog
, " *bufferp=");
520 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
524 const char *buf
= bufferp
;
525 fprintf_unfiltered (gdb_stdlog
, "[");
526 for (i
= 0; i
< register_size (current_gdbarch
, regnum
); i
++)
527 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
528 fprintf_unfiltered (gdb_stdlog
, "]");
530 fprintf_unfiltered (gdb_stdlog
, " }\n");
535 frame_register (struct frame_info
*frame
, int regnum
,
536 int *optimizedp
, enum lval_type
*lvalp
,
537 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
539 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
540 that the value proper does not need to be fetched. */
541 gdb_assert (optimizedp
!= NULL
);
542 gdb_assert (lvalp
!= NULL
);
543 gdb_assert (addrp
!= NULL
);
544 gdb_assert (realnump
!= NULL
);
545 /* gdb_assert (bufferp != NULL); */
547 /* Ulgh! Old code that, for lval_register, sets ADDRP to the offset
548 of the register in the register cache. It should instead return
549 the REGNUM corresponding to that register. Translate the . */
550 if (DEPRECATED_GET_SAVED_REGISTER_P ())
552 DEPRECATED_GET_SAVED_REGISTER (bufferp
, optimizedp
, addrp
, frame
,
554 /* Compute the REALNUM if the caller wants it. */
555 if (*lvalp
== lval_register
)
558 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
560 if (*addrp
== register_offset_hack (current_gdbarch
, regnum
))
566 internal_error (__FILE__
, __LINE__
,
567 "Failed to compute the register number corresponding"
568 " to 0x%s", paddr_d (*addrp
));
574 /* Obtain the register value by unwinding the register from the next
575 (more inner frame). */
576 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
577 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
582 frame_unwind_register (struct frame_info
*frame
, int regnum
, void *buf
)
588 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
593 frame_unwind_signed_register (struct frame_info
*frame
, int regnum
,
596 void *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
597 frame_unwind_register (frame
, regnum
, buf
);
598 (*val
) = extract_signed_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
602 frame_unwind_unsigned_register (struct frame_info
*frame
, int regnum
,
605 void *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
606 frame_unwind_register (frame
, regnum
, buf
);
607 (*val
) = extract_unsigned_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
611 frame_read_register (struct frame_info
*frame
, int regnum
, void *buf
)
613 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
614 frame_unwind_register (frame
->next
, regnum
, buf
);
618 frame_read_unsigned_register (struct frame_info
*frame
, int regnum
,
621 /* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is
622 always a frame. Both this, and the equivalent
623 frame_read_signed_register() function, can only be called with a
624 valid frame. If, for some reason, this function is called
625 without a frame then the problem isn't here, but rather in the
626 caller. It should of first created a frame and then passed that
628 /* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the
629 ``current_frame'' should not be treated as a special case. While
630 ``get_next_frame (current_frame) == NULL'' currently holds, it
631 should, as far as possible, not be relied upon. In the future,
632 ``get_next_frame (current_frame)'' may instead simply return a
633 normal frame object that simply always gets register values from
634 the register cache. Consequently, frame code should try to avoid
635 tests like ``if get_next_frame() == NULL'' and instead just rely
636 on recursive frame calls (like the below code) when manipulating
638 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
639 frame_unwind_unsigned_register (frame
->next
, regnum
, val
);
643 frame_read_signed_register (struct frame_info
*frame
, int regnum
,
646 /* See note above in frame_read_unsigned_register(). */
647 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
648 frame_unwind_signed_register (frame
->next
, regnum
, val
);
652 generic_unwind_get_saved_register (char *raw_buffer
,
655 struct frame_info
*frame
,
657 enum lval_type
*lvalp
)
662 enum lval_type lvalx
;
664 if (!target_has_registers
)
665 error ("No registers.");
667 /* Keep things simple, ensure that all the pointers (except valuep)
669 if (optimizedp
== NULL
)
670 optimizedp
= &optimizedx
;
676 gdb_assert (frame
!= NULL
&& frame
->next
!= NULL
);
677 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
678 &realnumx
, raw_buffer
);
681 /* frame_register_read ()
683 Find and return the value of REGNUM for the specified stack frame.
684 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
686 Returns 0 if the register value could not be found. */
689 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
695 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
697 /* FIXME: cagney/2002-05-15: This test, is just bogus.
699 It indicates that the target failed to supply a value for a
700 register because it was "not available" at this time. Problem
701 is, the target still has the register and so get saved_register()
702 may be returning a value saved on the stack. */
704 if (register_cached (regnum
) < 0)
705 return 0; /* register value not available */
711 /* Map between a frame register number and its name. A frame register
712 space is a superset of the cooked register space --- it also
713 includes builtin registers. */
716 frame_map_name_to_regnum (const char *name
, int len
)
723 /* Search register name space. */
724 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
725 if (REGISTER_NAME (i
) && len
== strlen (REGISTER_NAME (i
))
726 && strncmp (name
, REGISTER_NAME (i
), len
) == 0)
731 /* Try builtin registers. */
732 i
= builtin_reg_map_name_to_regnum (name
, len
);
735 /* A builtin register doesn't fall into the architecture's
737 gdb_assert (i
>= NUM_REGS
+ NUM_PSEUDO_REGS
);
745 frame_map_regnum_to_name (int regnum
)
749 if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
750 return REGISTER_NAME (regnum
);
751 return builtin_reg_map_regnum_to_name (regnum
);
754 /* Create a sentinel frame. */
757 create_sentinel_frame (struct regcache
*regcache
)
759 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
760 frame
->type
= NORMAL_FRAME
;
762 /* Explicitly initialize the sentinel frame's cache. Provide it
763 with the underlying regcache. In the future additional
764 information, such as the frame's thread will be added. */
765 frame
->prologue_cache
= sentinel_frame_cache (regcache
);
766 /* For the moment there is only one sentinel frame implementation. */
767 frame
->unwind
= sentinel_frame_unwind
;
768 /* Link this frame back to itself. The frame is self referential
769 (the unwound PC is the same as the pc), so make it so. */
771 /* Make the sentinel frame's ID valid, but invalid. That way all
772 comparisons with it should fail. */
773 frame
->this_id
.p
= 1;
774 frame
->this_id
.value
= null_frame_id
;
777 fprintf_unfiltered (gdb_stdlog
, "{ create_sentinel_frame (...) -> ");
778 fprint_frame (gdb_stdlog
, frame
);
779 fprintf_unfiltered (gdb_stdlog
, " }\n");
784 /* Info about the innermost stack frame (contents of FP register) */
786 static struct frame_info
*current_frame
;
788 /* Cache for frame addresses already read by gdb. Valid only while
789 inferior is stopped. Control variables for the frame cache should
790 be local to this module. */
792 static struct obstack frame_cache_obstack
;
795 frame_obstack_zalloc (unsigned long size
)
797 void *data
= obstack_alloc (&frame_cache_obstack
, size
);
798 memset (data
, 0, size
);
803 frame_saved_regs_zalloc (struct frame_info
*fi
)
805 fi
->saved_regs
= (CORE_ADDR
*)
806 frame_obstack_zalloc (SIZEOF_FRAME_SAVED_REGS
);
807 return fi
->saved_regs
;
811 get_frame_saved_regs (struct frame_info
*fi
)
813 return fi
->saved_regs
;
816 /* Return the innermost (currently executing) stack frame. This is
817 split into two functions. The function unwind_to_current_frame()
818 is wrapped in catch exceptions so that, even when the unwind of the
819 sentinel frame fails, the function still returns a stack frame. */
822 unwind_to_current_frame (struct ui_out
*ui_out
, void *args
)
824 struct frame_info
*frame
= get_prev_frame (args
);
825 /* A sentinel frame can fail to unwind, eg, because it's PC value
826 lands in somewhere like start. */
829 current_frame
= frame
;
834 get_current_frame (void)
836 /* First check, and report, the lack of registers. Having GDB
837 report "No stack!" or "No memory" when the target doesn't even
838 have registers is very confusing. Besides, "printcmd.exp"
839 explicitly checks that ``print $pc'' with no registers prints "No
841 if (!target_has_registers
)
842 error ("No registers.");
843 if (!target_has_stack
)
845 if (!target_has_memory
)
846 error ("No memory.");
847 if (current_frame
== NULL
)
849 struct frame_info
*sentinel_frame
=
850 create_sentinel_frame (current_regcache
);
851 if (catch_exceptions (uiout
, unwind_to_current_frame
, sentinel_frame
,
852 NULL
, RETURN_MASK_ERROR
) != 0)
854 /* Oops! Fake a current frame? Is this useful? It has a PC
855 of zero, for instance. */
856 current_frame
= sentinel_frame
;
859 return current_frame
;
862 /* The "selected" stack frame is used by default for local and arg
863 access. May be zero, for no selected frame. */
865 struct frame_info
*deprecated_selected_frame
;
867 /* Return the selected frame. Always non-null (unless there isn't an
868 inferior sufficient for creating a frame) in which case an error is
872 get_selected_frame (void)
874 if (deprecated_selected_frame
== NULL
)
875 /* Hey! Don't trust this. It should really be re-finding the
876 last selected frame of the currently selected thread. This,
877 though, is better than nothing. */
878 select_frame (get_current_frame ());
879 /* There is always a frame. */
880 gdb_assert (deprecated_selected_frame
!= NULL
);
881 return deprecated_selected_frame
;
884 /* Select frame FI (or NULL - to invalidate the current frame). */
887 select_frame (struct frame_info
*fi
)
889 register struct symtab
*s
;
891 deprecated_selected_frame
= fi
;
892 /* NOTE: cagney/2002-05-04: FI can be NULL. This occures when the
893 frame is being invalidated. */
894 if (selected_frame_level_changed_hook
)
895 selected_frame_level_changed_hook (frame_relative_level (fi
));
897 /* FIXME: kseitz/2002-08-28: It would be nice to call
898 selected_frame_level_changed_event right here, but due to limitations
899 in the current interfaces, we would end up flooding UIs with events
900 because select_frame is used extensively internally.
902 Once we have frame-parameterized frame (and frame-related) commands,
903 the event notification can be moved here, since this function will only
904 be called when the users selected frame is being changed. */
906 /* Ensure that symbols for this frame are read in. Also, determine the
907 source language of this frame, and switch to it if desired. */
910 s
= find_pc_symtab (get_frame_pc (fi
));
912 && s
->language
!= current_language
->la_language
913 && s
->language
!= language_unknown
914 && language_mode
== language_mode_auto
)
916 set_language (s
->language
);
921 /* Return the register saved in the simplistic ``saved_regs'' cache.
922 If the value isn't here AND a value is needed, try the next inner
926 legacy_saved_regs_prev_register (struct frame_info
*next_frame
,
927 void **this_prologue_cache
,
928 int regnum
, int *optimizedp
,
929 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
930 int *realnump
, void *bufferp
)
932 /* HACK: New code is passed the next frame and this cache.
933 Unfortunatly, old code expects this frame. Since this is a
934 backward compatibility hack, cheat by walking one level along the
935 prologue chain to the frame the old code expects.
937 Do not try this at home. Professional driver, closed course. */
938 struct frame_info
*frame
= next_frame
->prev
;
939 gdb_assert (frame
!= NULL
);
941 /* Only (older) architectures that implement the
942 DEPRECATED_FRAME_INIT_SAVED_REGS method should be using this
944 gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
946 /* Load the saved_regs register cache. */
947 if (get_frame_saved_regs (frame
) == NULL
)
948 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
950 if (get_frame_saved_regs (frame
) != NULL
951 && get_frame_saved_regs (frame
)[regnum
] != 0)
953 if (regnum
== SP_REGNUM
)
955 /* SP register treated specially. */
961 store_address (bufferp
, REGISTER_RAW_SIZE (regnum
),
962 get_frame_saved_regs (frame
)[regnum
]);
966 /* Any other register is saved in memory, fetch it but cache
967 a local copy of its value. */
969 *lvalp
= lval_memory
;
970 *addrp
= get_frame_saved_regs (frame
)[regnum
];
975 /* Save each register value, as it is read in, in a
976 frame based cache. */
977 void **regs
= (*this_prologue_cache
);
980 int sizeof_cache
= ((NUM_REGS
+ NUM_PSEUDO_REGS
)
982 regs
= frame_obstack_zalloc (sizeof_cache
);
983 (*this_prologue_cache
) = regs
;
985 if (regs
[regnum
] == NULL
)
988 = frame_obstack_zalloc (REGISTER_RAW_SIZE (regnum
));
989 read_memory (get_frame_saved_regs (frame
)[regnum
], regs
[regnum
],
990 REGISTER_RAW_SIZE (regnum
));
992 memcpy (bufferp
, regs
[regnum
], REGISTER_RAW_SIZE (regnum
));
994 /* Read the value in from memory. */
995 read_memory (get_frame_saved_regs (frame
)[regnum
], bufferp
,
996 REGISTER_RAW_SIZE (regnum
));
1003 /* No luck. Assume this and the next frame have the same register
1004 value. Pass the unwind request down the frame chain to the next
1005 frame. Hopefully that frame will find the register's location. */
1006 frame_register_unwind (next_frame
, regnum
, optimizedp
, lvalp
, addrp
,
1011 legacy_saved_regs_this_id (struct frame_info
*next_frame
,
1012 void **this_prologue_cache
,
1013 struct frame_id
*id
)
1015 /* legacy_get_prev_frame() always sets ->this_id.p, hence this is
1017 internal_error (__FILE__
, __LINE__
, "legacy_saved_regs_this_id() called");
1020 const struct frame_unwind legacy_saved_regs_unwinder
= {
1021 /* Not really. It gets overridden by legacy_get_prev_frame. */
1023 legacy_saved_regs_this_id
,
1024 legacy_saved_regs_prev_register
1026 const struct frame_unwind
*legacy_saved_regs_unwind
= &legacy_saved_regs_unwinder
;
1029 /* Function: deprecated_generic_get_saved_register
1030 Find register number REGNUM relative to FRAME and put its (raw,
1031 target format) contents in *RAW_BUFFER.
1033 Set *OPTIMIZED if the variable was optimized out (and thus can't be
1034 fetched). Note that this is never set to anything other than zero
1035 in this implementation.
1037 Set *LVAL to lval_memory, lval_register, or not_lval, depending on
1038 whether the value was fetched from memory, from a register, or in a
1039 strange and non-modifiable way (e.g. a frame pointer which was
1040 calculated rather than fetched). We will use not_lval for values
1041 fetched from generic dummy frames.
1043 Set *ADDRP to the address, either in memory or as a REGISTER_BYTE
1044 offset into the registers array. If the value is stored in a dummy
1045 frame, set *ADDRP to zero.
1047 The argument RAW_BUFFER must point to aligned memory. */
1050 deprecated_generic_get_saved_register (char *raw_buffer
, int *optimized
,
1052 struct frame_info
*frame
, int regnum
,
1053 enum lval_type
*lval
)
1055 if (!target_has_registers
)
1056 error ("No registers.");
1058 gdb_assert (DEPRECATED_FRAME_INIT_SAVED_REGS_P ());
1060 /* Normal systems don't optimize out things with register numbers. */
1061 if (optimized
!= NULL
)
1064 if (addrp
) /* default assumption: not found in memory */
1067 /* Note: since the current frame's registers could only have been
1068 saved by frames INTERIOR TO the current frame, we skip examining
1069 the current frame itself: otherwise, we would be getting the
1070 previous frame's registers which were saved by the current frame. */
1074 for (frame
= get_next_frame (frame
);
1075 frame_relative_level (frame
) >= 0;
1076 frame
= get_next_frame (frame
))
1078 if (get_frame_type (frame
) == DUMMY_FRAME
)
1080 if (lval
) /* found it in a CALL_DUMMY frame */
1083 /* FIXME: cagney/2002-06-26: This should be via the
1084 gdbarch_register_read() method so that it, on the
1085 fly, constructs either a raw or pseudo register
1086 from the raw register cache. */
1088 (generic_find_dummy_frame (get_frame_pc (frame
),
1089 get_frame_base (frame
)),
1090 regnum
, raw_buffer
);
1094 DEPRECATED_FRAME_INIT_SAVED_REGS (frame
);
1095 if (get_frame_saved_regs (frame
) != NULL
1096 && get_frame_saved_regs (frame
)[regnum
] != 0)
1098 if (lval
) /* found it saved on the stack */
1099 *lval
= lval_memory
;
1100 if (regnum
== SP_REGNUM
)
1102 if (raw_buffer
) /* SP register treated specially */
1103 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
1104 get_frame_saved_regs (frame
)[regnum
]);
1108 if (addrp
) /* any other register */
1109 *addrp
= get_frame_saved_regs (frame
)[regnum
];
1111 read_memory (get_frame_saved_regs (frame
)[regnum
], raw_buffer
,
1112 REGISTER_RAW_SIZE (regnum
));
1119 /* If we get thru the loop to this point, it means the register was
1120 not saved in any frame. Return the actual live-register value. */
1122 if (lval
) /* found it in a live register */
1123 *lval
= lval_register
;
1125 *addrp
= REGISTER_BYTE (regnum
);
1127 deprecated_read_register_gen (regnum
, raw_buffer
);
1130 /* Determine the frame's type based on its PC. */
1132 static enum frame_type
1133 frame_type_from_pc (CORE_ADDR pc
)
1135 /* FIXME: cagney/2002-11-24: Can't yet directly call
1136 pc_in_dummy_frame() as some architectures don't set
1137 PC_IN_CALL_DUMMY() to generic_pc_in_call_dummy() (remember the
1138 latter is implemented by simply calling pc_in_dummy_frame). */
1139 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1140 && DEPRECATED_PC_IN_CALL_DUMMY (pc
, 0, 0))
1145 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
1146 if (PC_IN_SIGTRAMP (pc
, name
))
1147 return SIGTRAMP_FRAME
;
1149 return NORMAL_FRAME
;
1153 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
1154 Always returns a non-NULL value. */
1157 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
1159 struct frame_info
*fi
;
1163 fprintf_unfiltered (gdb_stdlog
,
1164 "{ create_new_frame (addr=0x%s, pc=0x%s) ",
1165 paddr_nz (addr
), paddr_nz (pc
));
1168 fi
= frame_obstack_zalloc (sizeof (struct frame_info
));
1170 fi
->next
= create_sentinel_frame (current_regcache
);
1172 /* Select/initialize both the unwind function and the frame's type
1174 fi
->unwind
= frame_unwind_find_by_pc (current_gdbarch
, pc
);
1175 if (fi
->unwind
->type
!= UNKNOWN_FRAME
)
1176 fi
->type
= fi
->unwind
->type
;
1178 fi
->type
= frame_type_from_pc (pc
);
1181 deprecated_update_frame_base_hack (fi
, addr
);
1182 deprecated_update_frame_pc_hack (fi
, pc
);
1184 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1185 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, fi
);
1189 fprintf_unfiltered (gdb_stdlog
, "-> ");
1190 fprint_frame (gdb_stdlog
, fi
);
1191 fprintf_unfiltered (gdb_stdlog
, " }\n");
1197 /* Return the frame that THIS_FRAME calls (NULL if THIS_FRAME is the
1198 innermost frame). Be careful to not fall off the bottom of the
1199 frame chain and onto the sentinel frame. */
1202 get_next_frame (struct frame_info
*this_frame
)
1204 if (this_frame
->level
> 0)
1205 return this_frame
->next
;
1210 /* Flush the entire frame cache. */
1213 flush_cached_frames (void)
1215 /* Since we can't really be sure what the first object allocated was */
1216 obstack_free (&frame_cache_obstack
, 0);
1217 obstack_init (&frame_cache_obstack
);
1219 current_frame
= NULL
; /* Invalidate cache */
1220 select_frame (NULL
);
1221 annotate_frames_invalid ();
1223 fprintf_unfiltered (gdb_stdlog
, "{ flush_cached_frames () }\n");
1226 /* Flush the frame cache, and start a new one if necessary. */
1229 reinit_frame_cache (void)
1231 flush_cached_frames ();
1233 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
1234 if (PIDGET (inferior_ptid
) != 0)
1236 select_frame (get_current_frame ());
1240 /* Create the previous frame using the deprecated methods
1241 INIT_EXTRA_INFO, INIT_FRAME_PC and INIT_FRAME_PC_FIRST. */
1243 static struct frame_info
*
1244 legacy_get_prev_frame (struct frame_info
*this_frame
)
1246 CORE_ADDR address
= 0;
1247 struct frame_info
*prev
;
1250 /* Don't frame_debug print legacy_get_prev_frame() here, just
1251 confuses the output. */
1253 /* Allocate the new frame.
1255 There is no reason to worry about memory leaks, should the
1256 remainder of the function fail. The allocated memory will be
1257 quickly reclaimed when the frame cache is flushed, and the `we've
1258 been here before' check, in get_prev_frame will stop repeated
1259 memory allocation calls. */
1260 prev
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1261 prev
->level
= this_frame
->level
+ 1;
1263 /* Do not completly wire it in to the frame chain. Some (bad) code
1264 in INIT_FRAME_EXTRA_INFO tries to look along frame->prev to pull
1265 some fancy tricks (of course such code is, by definition,
1268 On the other hand, methods, such as get_frame_pc() and
1269 get_frame_base() rely on being able to walk along the frame
1270 chain. Make certain that at least they work by providing that
1271 link. Of course things manipulating prev can't go back. */
1272 prev
->next
= this_frame
;
1274 /* NOTE: cagney/2002-11-18: Should have been correctly setting the
1275 frame's type here, before anything else, and not last, at the
1276 bottom of this function. The various
1277 DEPRECATED_INIT_EXTRA_FRAME_INFO, DEPRECATED_INIT_FRAME_PC,
1278 DEPRECATED_INIT_FRAME_PC_FIRST and
1279 DEPRECATED_FRAME_INIT_SAVED_REGS methods are full of work-arounds
1280 that handle the frame not being correctly set from the start.
1281 Unfortunatly those same work-arounds rely on the type defaulting
1282 to NORMAL_FRAME. Ulgh! The new frame code does not have this
1284 prev
->type
= UNKNOWN_FRAME
;
1286 /* A legacy frame's ID is always computed here. Mark it as valid. */
1287 prev
->this_id
.p
= 1;
1289 /* Handle sentinel frame unwind as a special case. */
1290 if (this_frame
->level
< 0)
1292 /* Try to unwind the PC. If that doesn't work, assume we've reached
1293 the oldest frame and simply return. Is there a better sentinal
1294 value? The unwound PC value is then used to initialize the new
1295 previous frame's type.
1297 Note that the pc-unwind is intentionally performed before the
1298 frame chain. This is ok since, for old targets, both
1299 frame_pc_unwind (nee, DEPRECATED_FRAME_SAVED_PC) and
1300 DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
1301 have already been initialized (using
1302 DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
1305 By unwinding the PC first, it becomes possible to, in the case of
1306 a dummy frame, avoid also unwinding the frame ID. This is
1307 because (well ignoring the PPC) a dummy frame can be located
1308 using THIS_FRAME's frame ID. */
1310 deprecated_update_frame_pc_hack (prev
, frame_pc_unwind (this_frame
));
1311 if (get_frame_pc (prev
) == 0)
1313 /* The allocated PREV_FRAME will be reclaimed when the frame
1314 obstack is next purged. */
1317 fprintf_unfiltered (gdb_stdlog
, "-> ");
1318 fprint_frame (gdb_stdlog
, NULL
);
1319 fprintf_unfiltered (gdb_stdlog
,
1320 " // unwound legacy PC zero }\n");
1325 /* Set the unwind functions based on that identified PC. Ditto
1326 for the "type" but strongly prefer the unwinder's frame type. */
1327 prev
->unwind
= frame_unwind_find_by_pc (current_gdbarch
,
1328 get_frame_pc (prev
));
1329 if (prev
->unwind
->type
== UNKNOWN_FRAME
)
1330 prev
->type
= frame_type_from_pc (get_frame_pc (prev
));
1332 prev
->type
= prev
->unwind
->type
;
1334 /* Find the prev's frame's ID. */
1335 if (prev
->type
== DUMMY_FRAME
1336 && gdbarch_unwind_dummy_id_p (current_gdbarch
))
1338 /* When unwinding a normal frame, the stack structure is
1339 determined by analyzing the frame's function's code (be
1340 it using brute force prologue analysis, or the dwarf2
1341 CFI). In the case of a dummy frame, that simply isn't
1342 possible. The The PC is either the program entry point,
1343 or some random address on the stack. Trying to use that
1344 PC to apply standard frame ID unwind techniques is just
1345 asking for trouble. */
1346 /* Assume call_function_by_hand(), via SAVE_DUMMY_FRAME_TOS,
1347 previously saved the dummy frame's ID. Things only work
1348 if the two return the same value. */
1349 gdb_assert (SAVE_DUMMY_FRAME_TOS_P ());
1350 /* Use an architecture specific method to extract the prev's
1351 dummy ID from the next frame. Note that this method uses
1352 frame_register_unwind to obtain the register values
1353 needed to determine the dummy frame's ID. */
1354 prev
->this_id
.value
= gdbarch_unwind_dummy_id (current_gdbarch
,
1359 /* We're unwinding a sentinel frame, the PC of which is
1360 pointing at a stack dummy. Fake up the dummy frame's ID
1361 using the same sequence as is found a traditional
1362 unwinder. Once all architectures supply the
1363 unwind_dummy_id method, this code can go away. */
1364 prev
->this_id
.value
= frame_id_build (read_fp (), read_pc ());
1367 /* Check that the unwound ID is valid. */
1368 if (!frame_id_p (prev
->this_id
.value
))
1372 fprintf_unfiltered (gdb_stdlog
, "-> ");
1373 fprint_frame (gdb_stdlog
, NULL
);
1374 fprintf_unfiltered (gdb_stdlog
,
1375 " // unwound legacy ID invalid }\n");
1380 /* Check that the new frame isn't inner to (younger, below,
1381 next) the old frame. If that happens the frame unwind is
1383 /* FIXME: cagney/2003-02-25: Ignore the sentinel frame since
1384 that doesn't have a valid frame ID. Should instead set the
1385 sentinel frame's frame ID to a `sentinel'. Leave it until
1386 after the switch to storing the frame ID, instead of the
1387 frame base, in the frame object. */
1390 this_frame
->prev
= prev
;
1392 /* FIXME: cagney/2002-01-19: This call will go away. Instead of
1393 initializing extra info, all frames will use the frame_cache
1394 (passed to the unwind functions) to store additional frame
1395 info. Unfortunatly legacy targets can't use
1396 legacy_get_prev_frame() to unwind the sentinel frame and,
1397 consequently, are forced to take this code path and rely on
1398 the below call to DEPRECATED_INIT_EXTRA_FRAME_INFO to
1399 initialize the inner-most frame. */
1400 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1402 DEPRECATED_INIT_EXTRA_FRAME_INFO (0, prev
);
1405 if (prev
->type
== NORMAL_FRAME
)
1406 prev
->this_id
.value
.code_addr
1407 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1411 fprintf_unfiltered (gdb_stdlog
, "-> ");
1412 fprint_frame (gdb_stdlog
, prev
);
1413 fprintf_unfiltered (gdb_stdlog
, " } // legacy innermost frame\n");
1418 /* This code only works on normal frames. A sentinel frame, where
1419 the level is -1, should never reach this code. */
1420 gdb_assert (this_frame
->level
>= 0);
1422 /* On some machines it is possible to call a function without
1423 setting up a stack frame for it. On these machines, we
1424 define this macro to take two args; a frameinfo pointer
1425 identifying a frame and a variable to set or clear if it is
1426 or isn't leafless. */
1428 /* Still don't want to worry about this except on the innermost
1429 frame. This macro will set FROMLEAF if THIS_FRAME is a frameless
1430 function invocation. */
1431 if (this_frame
->level
== 0)
1432 /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
1433 the frame chain, not just the inner most frame! The generic,
1434 per-architecture, frame code should handle this and the below
1435 should simply be removed. */
1436 fromleaf
= FRAMELESS_FUNCTION_INVOCATION (this_frame
);
1441 /* A frameless inner-most frame. The `FP' (which isn't an
1442 architecture frame-pointer register!) of the caller is the same
1444 /* FIXME: 2002-11-09: There isn't any reason to special case this
1445 edge condition. Instead the per-architecture code should hande
1447 address
= get_frame_base (this_frame
);
1450 /* Two macros defined in tm.h specify the machine-dependent
1451 actions to be performed here.
1453 First, get the frame's chain-pointer.
1455 If that is zero, the frame is the outermost frame or a leaf
1456 called by the outermost frame. This means that if start
1457 calls main without a frame, we'll return 0 (which is fine
1460 Nope; there's a problem. This also returns when the current
1461 routine is a leaf of main. This is unacceptable. We move
1462 this to after the ffi test; I'd rather have backtraces from
1463 start go curfluy than have an abort called from main not show
1465 gdb_assert (DEPRECATED_FRAME_CHAIN_P ());
1466 address
= DEPRECATED_FRAME_CHAIN (this_frame
);
1468 if (!legacy_frame_chain_valid (address
, this_frame
))
1472 fprintf_unfiltered (gdb_stdlog
, "-> ");
1473 fprint_frame (gdb_stdlog
, NULL
);
1474 fprintf_unfiltered (gdb_stdlog
,
1475 " // legacy frame chain invalid }\n");
1484 fprintf_unfiltered (gdb_stdlog
, "-> ");
1485 fprint_frame (gdb_stdlog
, NULL
);
1486 fprintf_unfiltered (gdb_stdlog
,
1487 " // legacy frame chain NULL }\n");
1492 /* Link in the already allocated prev frame. */
1493 this_frame
->prev
= prev
;
1494 deprecated_update_frame_base_hack (prev
, address
);
1496 /* This change should not be needed, FIXME! We should determine
1497 whether any targets *need* DEPRECATED_INIT_FRAME_PC to happen
1498 after DEPRECATED_INIT_EXTRA_FRAME_INFO and come up with a simple
1499 way to express what goes on here.
1501 DEPRECATED_INIT_EXTRA_FRAME_INFO is called from two places:
1502 create_new_frame (where the PC is already set up) and here (where
1503 it isn't). DEPRECATED_INIT_FRAME_PC is only called from here,
1504 always after DEPRECATED_INIT_EXTRA_FRAME_INFO.
1506 The catch is the MIPS, where DEPRECATED_INIT_EXTRA_FRAME_INFO
1507 requires the PC value (which hasn't been set yet). Some other
1508 machines appear to require DEPRECATED_INIT_EXTRA_FRAME_INFO
1509 before they can do DEPRECATED_INIT_FRAME_PC. Phoo.
1511 We shouldn't need DEPRECATED_INIT_FRAME_PC_FIRST to add more
1512 complication to an already overcomplicated part of GDB.
1513 gnu@cygnus.com, 15Sep92.
1515 Assuming that some machines need DEPRECATED_INIT_FRAME_PC after
1516 DEPRECATED_INIT_EXTRA_FRAME_INFO, one possible scheme:
1518 SETUP_INNERMOST_FRAME(): Default version is just create_new_frame
1519 (read_fp ()), read_pc ()). Machines with extra frame info would
1520 do that (or the local equivalent) and then set the extra fields.
1522 SETUP_ARBITRARY_FRAME(argc, argv): Only change here is that
1523 create_new_frame would no longer init extra frame info;
1524 SETUP_ARBITRARY_FRAME would have to do that.
1526 INIT_PREV_FRAME(fromleaf, prev) Replace
1527 DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC.
1528 This should also return a flag saying whether to keep the new
1529 frame, or whether to discard it, because on some machines (e.g.
1530 mips) it is really awkward to have DEPRECATED_FRAME_CHAIN_VALID
1531 called BEFORE DEPRECATED_INIT_EXTRA_FRAME_INFO (there is no good
1532 way to get information deduced in DEPRECATED_FRAME_CHAIN_VALID
1533 into the extra fields of the new frame). std_frame_pc(fromleaf,
1536 This is the default setting for INIT_PREV_FRAME. It just does
1537 what the default DEPRECATED_INIT_FRAME_PC does. Some machines
1538 will call it from INIT_PREV_FRAME (either at the beginning, the
1539 end, or in the middle). Some machines won't use it.
1541 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
1543 /* NOTE: cagney/2002-11-09: Just ignore the above! There is no
1544 reason for things to be this complicated.
1546 The trick is to assume that there is always a frame. Instead of
1547 special casing the inner-most frame, create fake frame
1548 (containing the hardware registers) that is inner to the
1549 user-visible inner-most frame (...) and then unwind from that.
1550 That way architecture code can use use the standard
1551 frame_XX_unwind() functions and not differentiate between the
1552 inner most and any other case.
1554 Since there is always a frame to unwind from, there is always
1555 somewhere (THIS_FRAME) to store all the info needed to construct
1556 a new (previous) frame without having to first create it. This
1557 means that the convolution below - needing to carefully order a
1558 frame's initialization - isn't needed.
1560 The irony here though, is that DEPRECATED_FRAME_CHAIN(), at least
1561 for a more up-to-date architecture, always calls
1562 FRAME_SAVED_PC(), and FRAME_SAVED_PC() computes the PC but
1563 without first needing the frame! Instead of the convolution
1564 below, we could have simply called FRAME_SAVED_PC() and been done
1565 with it! Note that FRAME_SAVED_PC() is being superseed by
1566 frame_pc_unwind() and that function does have somewhere to cache
1569 if (DEPRECATED_INIT_FRAME_PC_FIRST_P ())
1570 deprecated_update_frame_pc_hack (prev
,
1571 DEPRECATED_INIT_FRAME_PC_FIRST (fromleaf
,
1574 if (DEPRECATED_INIT_EXTRA_FRAME_INFO_P ())
1575 DEPRECATED_INIT_EXTRA_FRAME_INFO (fromleaf
, prev
);
1577 /* This entry is in the frame queue now, which is good since
1578 FRAME_SAVED_PC may use that queue to figure out its value (see
1579 tm-sparc.h). We want the pc saved in the inferior frame. */
1580 if (DEPRECATED_INIT_FRAME_PC_P ())
1581 deprecated_update_frame_pc_hack (prev
,
1582 DEPRECATED_INIT_FRAME_PC (fromleaf
,
1585 /* If ->frame and ->pc are unchanged, we are in the process of
1586 getting ourselves into an infinite backtrace. Some architectures
1587 check this in DEPRECATED_FRAME_CHAIN or thereabouts, but it seems
1588 like there is no reason this can't be an architecture-independent
1590 if (get_frame_base (prev
) == get_frame_base (this_frame
)
1591 && get_frame_pc (prev
) == get_frame_pc (this_frame
))
1593 this_frame
->prev
= NULL
;
1594 obstack_free (&frame_cache_obstack
, prev
);
1597 fprintf_unfiltered (gdb_stdlog
, "-> ");
1598 fprint_frame (gdb_stdlog
, NULL
);
1599 fprintf_unfiltered (gdb_stdlog
,
1600 " // legacy this.id == prev.id }\n");
1605 /* Initialize the code used to unwind the frame PREV based on the PC
1606 (and probably other architectural information). The PC lets you
1607 check things like the debug info at that point (dwarf2cfi?) and
1608 use that to decide how the frame should be unwound. */
1609 prev
->unwind
= frame_unwind_find_by_pc (current_gdbarch
,
1610 get_frame_pc (prev
));
1612 /* If the unwinder provides a frame type, use it. Otherwize
1613 continue on to that heuristic mess. */
1614 if (prev
->unwind
->type
!= UNKNOWN_FRAME
)
1616 prev
->type
= prev
->unwind
->type
;
1617 if (prev
->type
== NORMAL_FRAME
)
1618 prev
->this_id
.value
.code_addr
1619 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1622 fprintf_unfiltered (gdb_stdlog
, "-> ");
1623 fprint_frame (gdb_stdlog
, prev
);
1624 fprintf_unfiltered (gdb_stdlog
, " } // legacy with unwound type\n");
1629 /* NOTE: cagney/2002-11-18: The code segments, found in
1630 create_new_frame and get_prev_frame(), that initializes the
1631 frames type is subtly different. The latter only updates ->type
1632 when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME. This stops
1633 get_prev_frame() overriding the frame's type when the INIT code
1634 has previously set it. This is really somewhat bogus. The
1635 initialization, as seen in create_new_frame(), should occur
1636 before the INIT function has been called. */
1637 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1638 && (DEPRECATED_PC_IN_CALL_DUMMY_P ()
1639 ? DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (prev
), 0, 0)
1640 : pc_in_dummy_frame (get_frame_pc (prev
))))
1641 prev
->type
= DUMMY_FRAME
;
1644 /* FIXME: cagney/2002-11-10: This should be moved to before the
1645 INIT code above so that the INIT code knows what the frame's
1646 type is (in fact, for a [generic] dummy-frame, the type can
1647 be set and then the entire initialization can be skipped.
1648 Unforunatly, its the INIT code that sets the PC (Hmm, catch
1651 find_pc_partial_function (get_frame_pc (prev
), &name
, NULL
, NULL
);
1652 if (PC_IN_SIGTRAMP (get_frame_pc (prev
), name
))
1653 prev
->type
= SIGTRAMP_FRAME
;
1654 /* FIXME: cagney/2002-11-11: Leave prev->type alone. Some
1655 architectures are forcing the frame's type in INIT so we
1656 don't want to override it here. Remember, NORMAL_FRAME == 0,
1657 so it all works (just :-/). Once this initialization is
1658 moved to the start of this function, all this nastness will
1662 if (prev
->type
== NORMAL_FRAME
)
1663 prev
->this_id
.value
.code_addr
1664 = get_pc_function_start (prev
->this_id
.value
.code_addr
);
1668 fprintf_unfiltered (gdb_stdlog
, "-> ");
1669 fprint_frame (gdb_stdlog
, prev
);
1670 fprintf_unfiltered (gdb_stdlog
, " } // legacy with confused type\n");
1676 /* Return a structure containing various interesting information
1677 about the frame that called THIS_FRAME. Returns NULL
1678 if there is no such frame. */
1681 get_prev_frame (struct frame_info
*this_frame
)
1683 struct frame_info
*prev_frame
;
1687 fprintf_unfiltered (gdb_stdlog
, "{ get_prev_frame (this_frame=");
1688 if (this_frame
!= NULL
)
1689 fprintf_unfiltered (gdb_stdlog
, "%d", this_frame
->level
);
1691 fprintf_unfiltered (gdb_stdlog
, "<NULL>");
1692 fprintf_unfiltered (gdb_stdlog
, ") ");
1695 /* Return the inner-most frame, when the caller passes in NULL. */
1696 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
1697 caller should have previously obtained a valid frame using
1698 get_selected_frame() and then called this code - only possibility
1699 I can think of is code behaving badly.
1701 NOTE: cagney/2003-01-10: Talk about code behaving badly. Check
1702 block_innermost_frame(). It does the sequence: frame = NULL;
1703 while (1) { frame = get_prev_frame (frame); .... }. Ulgh! Why
1704 it couldn't be written better, I don't know.
1706 NOTE: cagney/2003-01-11: I suspect what is happening is
1707 block_innermost_frame() is, when the target has no state
1708 (registers, memory, ...), still calling this function. The
1709 assumption being that this function will return NULL indicating
1710 that a frame isn't possible, rather than checking that the target
1711 has state and then calling get_current_frame() and
1712 get_prev_frame(). This is a guess mind. */
1713 if (this_frame
== NULL
)
1715 /* NOTE: cagney/2002-11-09: There was a code segment here that
1716 would error out when CURRENT_FRAME was NULL. The comment
1717 that went with it made the claim ...
1719 ``This screws value_of_variable, which just wants a nice
1720 clean NULL return from block_innermost_frame if there are no
1721 frames. I don't think I've ever seen this message happen
1722 otherwise. And returning NULL here is a perfectly legitimate
1725 Per the above, this code shouldn't even be called with a NULL
1727 return current_frame
;
1730 /* There is always a frame. If this assertion fails, suspect that
1731 something should be calling get_selected_frame() or
1732 get_current_frame(). */
1733 gdb_assert (this_frame
!= NULL
);
1735 if (this_frame
->level
>= 0
1736 && !backtrace_below_main
1737 && inside_main_func (get_frame_pc (this_frame
)))
1738 /* Don't unwind past main(), bug always unwind the sentinel frame.
1739 Note, this is done _before_ the frame has been marked as
1740 previously unwound. That way if the user later decides to
1741 allow unwinds past main(), that just happens. */
1744 fprintf_unfiltered (gdb_stdlog
, "-> NULL // inside main func }\n");
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;
1762 /* If we're inside the entry file, it isn't valid. Don't apply this
1763 test to a dummy frame - dummy frame PC's typically land in the
1764 entry file. Don't apply this test to the sentinel frame.
1765 Sentinel frames should always be allowed to unwind. */
1766 /* NOTE: drow/2002-12-25: should there be a way to disable this
1767 check? It assumes a single small entry file, and the way some
1768 debug readers (e.g. dbxread) figure out which object is the
1769 entry file is somewhat hokey. */
1770 /* NOTE: cagney/2003-01-10: If there is a way of disabling this test
1771 then it should probably be moved to before the ->prev_p test,
1773 /* NOTE: vinschen/2003-04-01: Disabled. It turns out that the call to
1774 inside_entry_file destroys a meaningful backtrace under some
1775 conditions. E. g. the backtrace tests in the asm-source testcase
1776 are broken for some targets. In this test the functions are all
1777 implemented as part of one file and the testcase is not necessarily
1778 linked with a start file (depending on the target). What happens is,
1779 that the first frame is printed normaly and following frames are
1780 treated as being inside the enttry file then. This way, only the
1781 #0 frame is printed in the backtrace output. */
1782 if (this_frame
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1783 && inside_entry_file (get_frame_pc (this_frame
)))
1787 fprintf_unfiltered (gdb_stdlog
, "-> ");
1788 fprint_frame (gdb_stdlog
, NULL
);
1789 fprintf_unfiltered (gdb_stdlog
, " // inside entry file }\n");
1795 /* If we're already inside the entry function for the main objfile,
1796 then it isn't valid. Don't apply this test to a dummy frame -
1797 dummy frame PC's typically land in the entry func. Don't apply
1798 this test to the sentinel frame. Sentinel frames should always
1799 be allowed to unwind. */
1800 /* NOTE: cagney/2003-02-25: Don't enable until someone has found
1801 hard evidence that this is needed. */
1803 && this_frame
->type
!= DUMMY_FRAME
&& this_frame
->level
>= 0
1804 && inside_entry_func (get_frame_pc (this_frame
)))
1808 fprintf_unfiltered (gdb_stdlog
, "-> ");
1809 fprint_frame (gdb_stdlog
, NULL
);
1810 fprintf_unfiltered (gdb_stdlog
, "// inside entry func }\n");
1815 /* If any of the old frame initialization methods are around, use
1816 the legacy get_prev_frame method. */
1817 if (legacy_frame_p (current_gdbarch
))
1819 prev_frame
= legacy_get_prev_frame (this_frame
);
1823 /* Check that this frame's ID was valid. If it wasn't, don't try to
1824 unwind to the prev frame. Be careful to not apply this test to
1825 the sentinel frame. */
1826 if (this_frame
->level
>= 0 && !frame_id_p (get_frame_id (this_frame
)))
1830 fprintf_unfiltered (gdb_stdlog
, "-> ");
1831 fprint_frame (gdb_stdlog
, NULL
);
1832 fprintf_unfiltered (gdb_stdlog
, " // this ID is NULL }\n");
1837 /* Check that this frame's ID isn't inner to (younger, below, next)
1838 the next frame. This happens when frame unwind goes backwards.
1839 Since the sentinel frame isn't valid, don't apply this if this
1840 frame is entier the inner-most or sentinel frame. */
1841 if (this_frame
->level
> 0
1842 && frame_id_inner (get_frame_id (this_frame
),
1843 get_frame_id (this_frame
->next
)))
1844 error ("This frame inner-to next frame (corrupt stack?)");
1846 /* Check that this and the next frame are different. If they are
1847 not, there is most likely a stack cycle. As with the inner-than
1848 test, avoid the inner-most and sentinel frames. */
1849 /* FIXME: cagney/2003-03-17: Can't yet enable this this check. The
1850 frame_id_eq() method doesn't yet use function addresses when
1851 comparing frame IDs. */
1853 && this_frame
->level
> 0
1854 && frame_id_eq (get_frame_id (this_frame
),
1855 get_frame_id (this_frame
->next
)))
1856 error ("This frame identical to next frame (corrupt stack?)");
1858 /* Allocate the new frame but do not wire it in to the frame chain.
1859 Some (bad) code in INIT_FRAME_EXTRA_INFO tries to look along
1860 frame->next to pull some fancy tricks (of course such code is, by
1861 definition, recursive). Try to prevent it.
1863 There is no reason to worry about memory leaks, should the
1864 remainder of the function fail. The allocated memory will be
1865 quickly reclaimed when the frame cache is flushed, and the `we've
1866 been here before' check above will stop repeated memory
1867 allocation calls. */
1868 prev_frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
1869 prev_frame
->level
= this_frame
->level
+ 1;
1871 /* Try to unwind the PC. If that doesn't work, assume we've reached
1872 the oldest frame and simply return. Is there a better sentinal
1873 value? The unwound PC value is then used to initialize the new
1874 previous frame's type.
1876 Note that the pc-unwind is intentionally performed before the
1877 frame chain. This is ok since, for old targets, both
1878 frame_pc_unwind (nee, FRAME_SAVED_PC) and
1879 DEPRECATED_FRAME_CHAIN()) assume THIS_FRAME's data structures
1880 have already been initialized (using
1881 DEPRECATED_INIT_EXTRA_FRAME_INFO) and hence the call order
1884 By unwinding the PC first, it becomes possible to, in the case of
1885 a dummy frame, avoid also unwinding the frame ID. This is
1886 because (well ignoring the PPC) a dummy frame can be located
1887 using THIS_FRAME's frame ID. */
1889 if (frame_pc_unwind (this_frame
) == 0)
1891 /* The allocated PREV_FRAME will be reclaimed when the frame
1892 obstack is next purged. */
1895 fprintf_unfiltered (gdb_stdlog
, "-> ");
1896 fprint_frame (gdb_stdlog
, NULL
);
1897 fprintf_unfiltered (gdb_stdlog
, " // unwound PC zero }\n");
1902 /* Set the unwind functions based on that identified PC. */
1903 prev_frame
->unwind
= frame_unwind_find_by_pc (current_gdbarch
,
1904 frame_pc_unwind (this_frame
));
1906 /* FIXME: cagney/2003-04-02: Rather than storing the frame's type in
1907 the frame, the unwinder's type should be returned directly.
1908 Unfortunatly, legacy code, called by legacy_get_prev_frame,
1909 explicitly set the frames type using the method
1910 deprecated_set_frame_type(). */
1911 gdb_assert (prev_frame
->unwind
->type
!= UNKNOWN_FRAME
);
1912 prev_frame
->type
= prev_frame
->unwind
->type
;
1914 /* Can the frame's type and unwinder be computed on demand? That
1915 would make a frame's creation really really lite! */
1917 /* The prev's frame's ID is computed by demand in get_frame_id(). */
1919 /* The unwound frame ID is validate at the start of this function,
1920 as part of the logic to decide if that frame should be further
1921 unwound, and not here while the prev frame is being created.
1922 Doing this makes it possible for the user to examine a frame that
1923 has an invalid frame ID.
1925 The very old VAX frame_args_address_correct() method noted: [...]
1926 For the sake of argument, suppose that the stack is somewhat
1927 trashed (which is one reason that "info frame" exists). So,
1928 return 0 (indicating we don't know the address of the arglist) if
1929 we don't know what frame this frame calls. */
1932 this_frame
->prev
= prev_frame
;
1933 prev_frame
->next
= this_frame
;
1937 fprintf_unfiltered (gdb_stdlog
, "-> ");
1938 fprint_frame (gdb_stdlog
, prev_frame
);
1939 fprintf_unfiltered (gdb_stdlog
, " }\n");
1946 get_frame_pc (struct frame_info
*frame
)
1948 gdb_assert (frame
->next
!= NULL
);
1949 return frame_pc_unwind (frame
->next
);
1953 pc_notcurrent (struct frame_info
*frame
)
1955 /* If FRAME is not the innermost frame, that normally means that
1956 FRAME->pc points at the return instruction (which is *after* the
1957 call instruction), and we want to get the line containing the
1958 call (because the call is where the user thinks the program is).
1959 However, if the next frame is either a SIGTRAMP_FRAME or a
1960 DUMMY_FRAME, then the next frame will contain a saved interrupt
1961 PC and such a PC indicates the current (rather than next)
1962 instruction/line, consequently, for such cases, want to get the
1963 line containing fi->pc. */
1964 struct frame_info
*next
= get_next_frame (frame
);
1965 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1970 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1972 (*sal
) = find_pc_line (get_frame_pc (frame
), pc_notcurrent (frame
));
1975 /* Per "frame.h", return the ``address'' of the frame. Code should
1976 really be using get_frame_id(). */
1978 get_frame_base (struct frame_info
*fi
)
1980 return get_frame_id (fi
).stack_addr
;
1983 /* High-level offsets into the frame. Used by the debug info. */
1986 get_frame_base_address (struct frame_info
*fi
)
1988 if (get_frame_type (fi
) != NORMAL_FRAME
)
1990 if (fi
->base
== NULL
)
1991 fi
->base
= frame_base_find_by_pc (current_gdbarch
, get_frame_pc (fi
));
1992 /* Sneaky: If the low-level unwind and high-level base code share a
1993 common unwinder, let them share the prologue cache. */
1994 if (fi
->base
->unwind
== fi
->unwind
)
1995 return fi
->base
->this_base (fi
->next
, &fi
->prologue_cache
);
1996 return fi
->base
->this_base (fi
->next
, &fi
->base_cache
);
2000 get_frame_locals_address (struct frame_info
*fi
)
2003 if (get_frame_type (fi
) != NORMAL_FRAME
)
2005 /* If there isn't a frame address method, find it. */
2006 if (fi
->base
== NULL
)
2007 fi
->base
= frame_base_find_by_pc (current_gdbarch
, get_frame_pc (fi
));
2008 /* Sneaky: If the low-level unwind and high-level base code share a
2009 common unwinder, let them share the prologue cache. */
2010 if (fi
->base
->unwind
== fi
->unwind
)
2011 cache
= &fi
->prologue_cache
;
2013 cache
= &fi
->base_cache
;
2014 return fi
->base
->this_locals (fi
->next
, cache
);
2018 get_frame_args_address (struct frame_info
*fi
)
2021 if (get_frame_type (fi
) != NORMAL_FRAME
)
2023 /* If there isn't a frame address method, find it. */
2024 if (fi
->base
== NULL
)
2025 fi
->base
= frame_base_find_by_pc (current_gdbarch
, get_frame_pc (fi
));
2026 /* Sneaky: If the low-level unwind and high-level base code share a
2027 common unwinder, let them share the prologue cache. */
2028 if (fi
->base
->unwind
== fi
->unwind
)
2029 cache
= &fi
->prologue_cache
;
2031 cache
= &fi
->base_cache
;
2032 return fi
->base
->this_args (fi
->next
, cache
);
2035 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
2036 or -1 for a NULL frame. */
2039 frame_relative_level (struct frame_info
*fi
)
2048 get_frame_type (struct frame_info
*frame
)
2050 /* Some targets still don't use [generic] dummy frames. Catch them
2052 if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
2053 && deprecated_frame_in_dummy (frame
))
2055 if (frame
->type
== UNKNOWN_FRAME
)
2056 return NORMAL_FRAME
;
2062 deprecated_set_frame_type (struct frame_info
*frame
, enum frame_type type
)
2064 /* Arrrg! See comment in "frame.h". */
2068 struct frame_extra_info
*
2069 get_frame_extra_info (struct frame_info
*fi
)
2071 return fi
->extra_info
;
2074 struct frame_extra_info
*
2075 frame_extra_info_zalloc (struct frame_info
*fi
, long size
)
2077 fi
->extra_info
= frame_obstack_zalloc (size
);
2078 return fi
->extra_info
;
2082 deprecated_update_frame_pc_hack (struct frame_info
*frame
, CORE_ADDR pc
)
2085 fprintf_unfiltered (gdb_stdlog
,
2086 "{ deprecated_update_frame_pc_hack (frame=%d,pc=0x%s) }\n",
2087 frame
->level
, paddr_nz (pc
));
2088 /* NOTE: cagney/2003-03-11: Some architectures (e.g., Arm) are
2089 maintaining a locally allocated frame object. Since such frame's
2090 are not in the frame chain, it isn't possible to assume that the
2091 frame has a next. Sigh. */
2092 if (frame
->next
!= NULL
)
2094 /* While we're at it, update this frame's cached PC value, found
2095 in the next frame. Oh for the day when "struct frame_info"
2096 is opaque and this hack on hack can just go away. */
2097 frame
->next
->prev_pc
.value
= pc
;
2098 frame
->next
->prev_pc
.p
= 1;
2103 deprecated_update_frame_base_hack (struct frame_info
*frame
, CORE_ADDR base
)
2106 fprintf_unfiltered (gdb_stdlog
,
2107 "{ deprecated_update_frame_base_hack (frame=%d,base=0x%s) }\n",
2108 frame
->level
, paddr_nz (base
));
2109 /* See comment in "frame.h". */
2110 frame
->this_id
.value
.stack_addr
= base
;
2114 deprecated_set_frame_saved_regs_hack (struct frame_info
*frame
,
2115 CORE_ADDR
*saved_regs
)
2117 frame
->saved_regs
= saved_regs
;
2121 deprecated_set_frame_extra_info_hack (struct frame_info
*frame
,
2122 struct frame_extra_info
*extra_info
)
2124 frame
->extra_info
= extra_info
;
2128 deprecated_set_frame_next_hack (struct frame_info
*fi
,
2129 struct frame_info
*next
)
2135 deprecated_set_frame_prev_hack (struct frame_info
*fi
,
2136 struct frame_info
*prev
)
2142 deprecated_get_frame_context (struct frame_info
*fi
)
2148 deprecated_set_frame_context (struct frame_info
*fi
,
2149 struct context
*context
)
2151 fi
->context
= context
;
2155 deprecated_frame_xmalloc (void)
2157 struct frame_info
*frame
= FRAME_OBSTACK_ZALLOC (struct frame_info
);
2158 frame
->this_id
.p
= 1;
2163 deprecated_frame_xmalloc_with_cleanup (long sizeof_saved_regs
,
2164 long sizeof_extra_info
)
2166 struct frame_info
*frame
= deprecated_frame_xmalloc ();
2167 make_cleanup (xfree
, frame
);
2168 if (sizeof_saved_regs
> 0)
2170 frame
->saved_regs
= xcalloc (1, sizeof_saved_regs
);
2171 make_cleanup (xfree
, frame
->saved_regs
);
2173 if (sizeof_extra_info
> 0)
2175 frame
->extra_info
= xcalloc (1, sizeof_extra_info
);
2176 make_cleanup (xfree
, frame
->extra_info
);
2182 legacy_frame_p (struct gdbarch
*current_gdbarch
)
2184 return (DEPRECATED_INIT_FRAME_PC_P ()
2185 || DEPRECATED_INIT_FRAME_PC_FIRST_P ()
2186 || DEPRECATED_INIT_EXTRA_FRAME_INFO_P ()
2187 || DEPRECATED_FRAME_CHAIN_P ()
2188 || !gdbarch_unwind_dummy_id_p (current_gdbarch
)
2189 || !SAVE_DUMMY_FRAME_TOS_P ());
2193 _initialize_frame (void)
2195 obstack_init (&frame_cache_obstack
);
2197 /* FIXME: cagney/2003-01-19: This command needs a rename. Suggest
2198 `set backtrace {past,beyond,...}-main'. Also suggest adding `set
2199 backtrace ...-start' to control backtraces past start. The
2200 problem with `below' is that it stops the `up' command. */
2202 add_setshow_boolean_cmd ("backtrace-below-main", class_obscure
,
2203 &backtrace_below_main
, "\
2204 Set whether backtraces should continue past \"main\".\n\
2205 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2206 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2207 of the stack trace.", "\
2208 Show whether backtraces should continue past \"main\".\n\
2209 Normally the caller of \"main\" is not of interest, so GDB will terminate\n\
2210 the backtrace at \"main\". Set this variable if you need to see the rest\n\
2211 of the stack trace.",
2212 NULL
, NULL
, &setlist
, &showlist
);
2215 /* Debug this files internals. */
2216 add_show_from_set (add_set_cmd ("frame", class_maintenance
, var_zinteger
,
2217 &frame_debug
, "Set frame debugging.\n\
2218 When non-zero, frame specific internal debugging is enabled.", &setdebuglist
),