1 /* Cache and manage frames for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4 2001, 2002 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"
38 /* Return a frame uniq ID that can be used to, later re-find the
42 get_frame_id (struct frame_info
*fi
, struct frame_id
*id
)
57 frame_find_by_id (struct frame_id id
)
59 struct frame_info
*frame
;
61 /* ZERO denotes the null frame, let the caller decide what to do
62 about it. Should it instead return get_current_frame()? */
63 if (id
.base
== 0 && id
.pc
== 0)
66 for (frame
= get_current_frame ();
68 frame
= get_prev_frame (frame
))
71 get_frame_id (frame
, &this);
72 if (INNER_THAN (this.base
, id
.base
))
73 /* ``inner/current < frame < id.base''. Keep looking along
76 if (INNER_THAN (id
.base
, this.base
))
77 /* ``inner/current < id.base < frame''. Oops, gone past it.
80 /* FIXME: cagney/2002-04-21: This isn't sufficient. It should
81 use id.pc / this.pc to check that the two frames belong to
82 the same function. Otherwise we'll do things like match
83 dummy frames or mis-match frameless functions. However,
84 until someone notices, stick with the existing behavour. */
91 frame_pc_unwind (struct frame_info
*frame
)
93 if (!frame
->pc_unwind_cache_p
)
95 frame
->pc_unwind_cache
= frame
->pc_unwind (frame
, &frame
->unwind_cache
);
96 frame
->pc_unwind_cache_p
= 1;
98 return frame
->pc_unwind_cache
;
102 frame_register_unwind (struct frame_info
*frame
, int regnum
,
103 int *optimizedp
, enum lval_type
*lvalp
,
104 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
106 struct frame_unwind_cache
*cache
;
108 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
109 that the value proper does not need to be fetched. */
110 gdb_assert (optimizedp
!= NULL
);
111 gdb_assert (lvalp
!= NULL
);
112 gdb_assert (addrp
!= NULL
);
113 gdb_assert (realnump
!= NULL
);
114 /* gdb_assert (bufferp != NULL); */
116 /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
117 special case, there was always an inner frame dedicated to the
118 hardware registers. Unfortunatly, there is too much unwind code
119 around that looks up/down the frame chain while making the
120 assumption that each frame level is using the same unwind code. */
124 /* We're in the inner-most frame, get the value direct from the
127 *lvalp
= lval_register
;
128 /* ULGH! Code uses the offset into the raw register byte array
129 as a way of identifying a register. */
130 *addrp
= REGISTER_BYTE (regnum
);
131 /* Should this code test ``register_cached (regnum) < 0'' and do
132 something like set realnum to -1 when the register isn't
136 deprecated_read_register_gen (regnum
, bufferp
);
140 /* Ask this frame to unwind its register. */
141 frame
->register_unwind (frame
, &frame
->unwind_cache
, regnum
,
142 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
146 frame_register (struct frame_info
*frame
, int regnum
,
147 int *optimizedp
, enum lval_type
*lvalp
,
148 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
150 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
151 that the value proper does not need to be fetched. */
152 gdb_assert (optimizedp
!= NULL
);
153 gdb_assert (lvalp
!= NULL
);
154 gdb_assert (addrp
!= NULL
);
155 gdb_assert (realnump
!= NULL
);
156 /* gdb_assert (bufferp != NULL); */
158 /* Ulgh! Old code that, for lval_register, sets ADDRP to the offset
159 of the register in the register cache. It should instead return
160 the REGNUM corresponding to that register. Translate the . */
161 if (GET_SAVED_REGISTER_P ())
163 GET_SAVED_REGISTER (bufferp
, optimizedp
, addrp
, frame
, regnum
, lvalp
);
164 /* Compute the REALNUM if the caller wants it. */
165 if (*lvalp
== lval_register
)
168 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
170 if (*addrp
== register_offset_hack (current_gdbarch
, regnum
))
176 internal_error (__FILE__
, __LINE__
,
177 "Failed to compute the register number corresponding"
178 " to 0x%s", paddr_d (*addrp
));
184 /* Reached the the bottom (youngest, inner most) of the frame chain
185 (youngest, inner most) frame, go direct to the hardware register
186 cache (do not pass go, do not try to cache the value, ...). The
187 unwound value would have been cached in frame->next but that
188 doesn't exist. This doesn't matter as the hardware register
189 cache is stopping any unnecessary accesses to the target. */
191 /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
192 special case, there was always an inner frame dedicated to the
193 hardware registers. Unfortunatly, there is too much unwind code
194 around that looks up/down the frame chain while making the
195 assumption that each frame level is using the same unwind code. */
198 frame_register_unwind (NULL
, regnum
, optimizedp
, lvalp
, addrp
, realnump
,
201 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
206 frame_unwind_signed_register (struct frame_info
*frame
, int regnum
,
213 void *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
214 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
216 (*val
) = extract_signed_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
220 frame_unwind_unsigned_register (struct frame_info
*frame
, int regnum
,
227 void *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
228 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
230 (*val
) = extract_unsigned_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
234 frame_read_unsigned_register (struct frame_info
*frame
, int regnum
,
237 /* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is
238 always a frame. Both this, and the equivalent
239 frame_read_signed_register() function, can only be called with a
240 valid frame. If, for some reason, this function is called
241 without a frame then the problem isn't here, but rather in the
242 caller. It should of first created a frame and then passed that
244 /* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the
245 ``current_frame'' should not be treated as a special case. While
246 ``get_next_frame (current_frame) == NULL'' currently holds, it
247 should, as far as possible, not be relied upon. In the future,
248 ``get_next_frame (current_frame)'' may instead simply return a
249 normal frame object that simply always gets register values from
250 the register cache. Consequently, frame code should try to avoid
251 tests like ``if get_next_frame() == NULL'' and instead just rely
252 on recursive frame calls (like the below code) when manipulating
254 gdb_assert (frame
!= NULL
);
255 frame_unwind_unsigned_register (get_next_frame (frame
), regnum
, val
);
259 frame_read_signed_register (struct frame_info
*frame
, int regnum
,
262 /* See note in frame_read_unsigned_register(). */
263 gdb_assert (frame
!= NULL
);
264 frame_unwind_signed_register (get_next_frame (frame
), regnum
, val
);
268 generic_unwind_get_saved_register (char *raw_buffer
,
271 struct frame_info
*frame
,
273 enum lval_type
*lvalp
)
278 enum lval_type lvalx
;
280 if (!target_has_registers
)
281 error ("No registers.");
283 /* Keep things simple, ensure that all the pointers (except valuep)
285 if (optimizedp
== NULL
)
286 optimizedp
= &optimizedx
;
292 /* Reached the the bottom (youngest, inner most) of the frame chain
293 (youngest, inner most) frame, go direct to the hardware register
294 cache (do not pass go, do not try to cache the value, ...). The
295 unwound value would have been cached in frame->next but that
296 doesn't exist. This doesn't matter as the hardware register
297 cache is stopping any unnecessary accesses to the target. */
299 /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
300 special case, there was always an inner frame dedicated to the
301 hardware registers. Unfortunatly, there is too much unwind code
302 around that looks up/down the frame chain while making the
303 assumption that each frame level is using the same unwind code. */
306 frame_register_unwind (NULL
, regnum
, optimizedp
, lvalp
, addrp
, &realnumx
,
309 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
310 &realnumx
, raw_buffer
);
314 get_saved_register (char *raw_buffer
,
317 struct frame_info
*frame
,
319 enum lval_type
*lval
)
321 if (GET_SAVED_REGISTER_P ())
323 GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
326 generic_unwind_get_saved_register (raw_buffer
, optimized
, addrp
, frame
,
330 /* frame_register_read ()
332 Find and return the value of REGNUM for the specified stack frame.
333 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
335 Returns 0 if the register value could not be found. */
338 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
344 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
346 /* FIXME: cagney/2002-05-15: This test, is just bogus.
348 It indicates that the target failed to supply a value for a
349 register because it was "not available" at this time. Problem
350 is, the target still has the register and so get saved_register()
351 may be returning a value saved on the stack. */
353 if (register_cached (regnum
) < 0)
354 return 0; /* register value not available */
360 /* Map between a frame register number and its name. A frame register
361 space is a superset of the cooked register space --- it also
362 includes builtin registers. */
365 frame_map_name_to_regnum (const char *name
, int len
)
369 /* Search register name space. */
370 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
371 if (REGISTER_NAME (i
) && len
== strlen (REGISTER_NAME (i
))
372 && strncmp (name
, REGISTER_NAME (i
), len
) == 0)
377 /* Try builtin registers. */
378 i
= builtin_reg_map_name_to_regnum (name
, len
);
381 /* A builtin register doesn't fall into the architecture's
383 gdb_assert (i
>= NUM_REGS
+ NUM_PSEUDO_REGS
);
391 frame_map_regnum_to_name (int regnum
)
395 if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
396 return REGISTER_NAME (regnum
);
397 return builtin_reg_map_regnum_to_name (regnum
);
400 /* Info about the innermost stack frame (contents of FP register) */
402 static struct frame_info
*current_frame
;
404 /* Cache for frame addresses already read by gdb. Valid only while
405 inferior is stopped. Control variables for the frame cache should
406 be local to this module. */
408 static struct obstack frame_cache_obstack
;
411 frame_obstack_alloc (unsigned long size
)
413 return obstack_alloc (&frame_cache_obstack
, size
);
417 frame_saved_regs_zalloc (struct frame_info
*fi
)
419 fi
->saved_regs
= (CORE_ADDR
*)
420 frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS
);
421 memset (fi
->saved_regs
, 0, SIZEOF_FRAME_SAVED_REGS
);
425 /* Return the innermost (currently executing) stack frame. */
428 get_current_frame (void)
430 if (current_frame
== NULL
)
432 if (target_has_stack
)
433 current_frame
= create_new_frame (read_fp (), read_pc ());
437 return current_frame
;
441 set_current_frame (struct frame_info
*frame
)
443 current_frame
= frame
;
446 /* The "selected" stack frame is used by default for local and arg
447 access. May be zero, for no selected frame. */
449 struct frame_info
*deprecated_selected_frame
;
451 /* Return the selected frame. Always non-null (unless there isn't an
452 inferior sufficient for creating a frame) in which case an error is
456 get_selected_frame (void)
458 if (deprecated_selected_frame
== NULL
)
459 /* Hey! Don't trust this. It should really be re-finding the
460 last selected frame of the currently selected thread. This,
461 though, is better than nothing. */
462 select_frame (get_current_frame ());
463 /* There is always a frame. */
464 gdb_assert (deprecated_selected_frame
!= NULL
);
465 return deprecated_selected_frame
;
468 /* Select frame FI (or NULL - to invalidate the current frame). */
471 select_frame (struct frame_info
*fi
)
473 register struct symtab
*s
;
475 deprecated_selected_frame
= fi
;
476 /* NOTE: cagney/2002-05-04: FI can be NULL. This occures when the
477 frame is being invalidated. */
478 if (selected_frame_level_changed_hook
)
479 selected_frame_level_changed_hook (frame_relative_level (fi
));
481 /* FIXME: kseitz/2002-08-28: It would be nice to call
482 selected_frame_level_changed_event right here, but due to limitations
483 in the current interfaces, we would end up flooding UIs with events
484 because select_frame is used extensively internally.
486 Once we have frame-parameterized frame (and frame-related) commands,
487 the event notification can be moved here, since this function will only
488 be called when the users selected frame is being changed. */
490 /* Ensure that symbols for this frame are read in. Also, determine the
491 source language of this frame, and switch to it if desired. */
494 s
= find_pc_symtab (fi
->pc
);
496 && s
->language
!= current_language
->la_language
497 && s
->language
!= language_unknown
498 && language_mode
== language_mode_auto
)
500 set_language (s
->language
);
505 /* Return the register saved in the simplistic ``saved_regs'' cache.
506 If the value isn't here AND a value is needed, try the next inner
510 frame_saved_regs_register_unwind (struct frame_info
*frame
, void **cache
,
511 int regnum
, int *optimizedp
,
512 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
513 int *realnump
, void *bufferp
)
515 /* There is always a frame at this point. And THIS is the frame
516 we're interested in. */
517 gdb_assert (frame
!= NULL
);
518 /* If we're using generic dummy frames, we'd better not be in a call
519 dummy. (generic_call_dummy_register_unwind ought to have been called
521 gdb_assert (!(DEPRECATED_USE_GENERIC_DUMMY_FRAMES
522 && (get_frame_type (frame
) == DUMMY_FRAME
)));
524 /* Load the saved_regs register cache. */
525 if (frame
->saved_regs
== NULL
)
526 FRAME_INIT_SAVED_REGS (frame
);
528 if (frame
->saved_regs
!= NULL
529 && frame
->saved_regs
[regnum
] != 0)
531 if (regnum
== SP_REGNUM
)
533 /* SP register treated specially. */
539 store_address (bufferp
, REGISTER_RAW_SIZE (regnum
),
540 frame
->saved_regs
[regnum
]);
544 /* Any other register is saved in memory, fetch it but cache
545 a local copy of its value. */
547 *lvalp
= lval_memory
;
548 *addrp
= frame
->saved_regs
[regnum
];
553 /* Save each register value, as it is read in, in a
554 frame based cache. */
555 void **regs
= (*cache
);
558 int sizeof_cache
= ((NUM_REGS
+ NUM_PSEUDO_REGS
)
560 regs
= frame_obstack_alloc (sizeof_cache
);
561 memset (regs
, 0, sizeof_cache
);
564 if (regs
[regnum
] == NULL
)
567 = frame_obstack_alloc (REGISTER_RAW_SIZE (regnum
));
568 read_memory (frame
->saved_regs
[regnum
], regs
[regnum
],
569 REGISTER_RAW_SIZE (regnum
));
571 memcpy (bufferp
, regs
[regnum
], REGISTER_RAW_SIZE (regnum
));
573 /* Read the value in from memory. */
574 read_memory (frame
->saved_regs
[regnum
], bufferp
,
575 REGISTER_RAW_SIZE (regnum
));
582 /* No luck, assume this and the next frame have the same register
583 value. If a value is needed, pass the request on down the chain;
584 otherwise just return an indication that the value is in the same
585 register as the next frame. */
589 *lvalp
= lval_register
;
595 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
601 frame_saved_regs_pc_unwind (struct frame_info
*frame
, void **cache
)
603 return FRAME_SAVED_PC (frame
);
606 /* Function: get_saved_register
607 Find register number REGNUM relative to FRAME and put its (raw,
608 target format) contents in *RAW_BUFFER.
610 Set *OPTIMIZED if the variable was optimized out (and thus can't be
611 fetched). Note that this is never set to anything other than zero
612 in this implementation.
614 Set *LVAL to lval_memory, lval_register, or not_lval, depending on
615 whether the value was fetched from memory, from a register, or in a
616 strange and non-modifiable way (e.g. a frame pointer which was
617 calculated rather than fetched). We will use not_lval for values
618 fetched from generic dummy frames.
620 Set *ADDRP to the address, either in memory or as a REGISTER_BYTE
621 offset into the registers array. If the value is stored in a dummy
622 frame, set *ADDRP to zero.
624 To use this implementation, define a function called
625 "get_saved_register" in your target code, which simply passes all
626 of its arguments to this function.
628 The argument RAW_BUFFER must point to aligned memory. */
631 deprecated_generic_get_saved_register (char *raw_buffer
, int *optimized
,
633 struct frame_info
*frame
, int regnum
,
634 enum lval_type
*lval
)
636 if (!target_has_registers
)
637 error ("No registers.");
639 /* Normal systems don't optimize out things with register numbers. */
640 if (optimized
!= NULL
)
643 if (addrp
) /* default assumption: not found in memory */
646 /* Note: since the current frame's registers could only have been
647 saved by frames INTERIOR TO the current frame, we skip examining
648 the current frame itself: otherwise, we would be getting the
649 previous frame's registers which were saved by the current frame. */
651 while (frame
&& ((frame
= frame
->next
) != NULL
))
653 if (get_frame_type (frame
) == DUMMY_FRAME
)
655 if (lval
) /* found it in a CALL_DUMMY frame */
658 /* FIXME: cagney/2002-06-26: This should be via the
659 gdbarch_register_read() method so that it, on the fly,
660 constructs either a raw or pseudo register from the raw
662 regcache_raw_read (generic_find_dummy_frame (frame
->pc
,
668 FRAME_INIT_SAVED_REGS (frame
);
669 if (frame
->saved_regs
!= NULL
670 && frame
->saved_regs
[regnum
] != 0)
672 if (lval
) /* found it saved on the stack */
674 if (regnum
== SP_REGNUM
)
676 if (raw_buffer
) /* SP register treated specially */
677 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
678 frame
->saved_regs
[regnum
]);
682 if (addrp
) /* any other register */
683 *addrp
= frame
->saved_regs
[regnum
];
685 read_memory (frame
->saved_regs
[regnum
], raw_buffer
,
686 REGISTER_RAW_SIZE (regnum
));
692 /* If we get thru the loop to this point, it means the register was
693 not saved in any frame. Return the actual live-register value. */
695 if (lval
) /* found it in a live register */
696 *lval
= lval_register
;
698 *addrp
= REGISTER_BYTE (regnum
);
700 deprecated_read_register_gen (regnum
, raw_buffer
);
703 /* Using the PC, select a mechanism for unwinding a frame returning
704 the previous frame. The register unwind function should, on
705 demand, initialize the ->context object. */
708 set_unwind_by_pc (CORE_ADDR pc
, CORE_ADDR fp
,
709 frame_register_unwind_ftype
**unwind_register
,
710 frame_pc_unwind_ftype
**unwind_pc
)
712 if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
)
714 /* Still need to set this to something. The ``info frame'' code
715 calls this function to find out where the saved registers are.
716 Hopefully this is robust enough to stop any core dumps and
717 return vaguely correct values.. */
718 *unwind_register
= frame_saved_regs_register_unwind
;
719 *unwind_pc
= frame_saved_regs_pc_unwind
;
721 /* FIXME: cagney/2002-11-24: Can't yet directly call
722 pc_in_dummy_frame() as some architectures don't set
723 PC_IN_CALL_DUMMY() to generic_pc_in_call_dummy() (remember the
724 latter is implemented by simply calling pc_in_dummy_frame). */
725 else if (PC_IN_CALL_DUMMY (pc
, 0, 0))
727 *unwind_register
= dummy_frame_register_unwind
;
728 *unwind_pc
= dummy_frame_pc_unwind
;
732 *unwind_register
= frame_saved_regs_register_unwind
;
733 *unwind_pc
= frame_saved_regs_pc_unwind
;
737 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
738 Always returns a non-NULL value. */
741 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
743 struct frame_info
*fi
;
744 enum frame_type type
;
746 fi
= (struct frame_info
*)
747 obstack_alloc (&frame_cache_obstack
,
748 sizeof (struct frame_info
));
750 /* Zero all fields by default. */
751 memset (fi
, 0, sizeof (struct frame_info
));
755 /* NOTE: cagney/2002-11-18: The code segments, found in
756 create_new_frame and get_prev_frame(), that initializes the
757 frames type is subtly different. The latter only updates ->type
758 when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME. This stops
759 get_prev_frame() overriding the frame's type when the INIT code
760 has previously set it. This is really somewhat bogus. The
761 initialization, as seen in create_new_frame(), should occur
762 before the INIT function has been called. */
763 /* FIXME: cagney/2002-11-24: Can't yet directly call
764 pc_in_dummy_frame() as some architectures don't set
765 PC_IN_CALL_DUMMY() to generic_pc_in_call_dummy() (remember the
766 latter is implemented by simply calling pc_in_dummy_frame). */
767 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
&& PC_IN_CALL_DUMMY (pc
, 0, 0))
768 /* NOTE: cagney/2002-11-11: Does this even occure? */
773 find_pc_partial_function (pc
, &name
, NULL
, NULL
);
774 if (PC_IN_SIGTRAMP (fi
->pc
, name
))
775 type
= SIGTRAMP_FRAME
;
781 if (INIT_EXTRA_FRAME_INFO_P ())
782 INIT_EXTRA_FRAME_INFO (0, fi
);
784 /* Select/initialize an unwind function. */
785 set_unwind_by_pc (fi
->pc
, fi
->frame
, &fi
->register_unwind
,
791 /* Return the frame that FRAME calls (NULL if FRAME is the innermost
795 get_next_frame (struct frame_info
*frame
)
800 /* Flush the entire frame cache. */
803 flush_cached_frames (void)
805 /* Since we can't really be sure what the first object allocated was */
806 obstack_free (&frame_cache_obstack
, 0);
807 obstack_init (&frame_cache_obstack
);
809 current_frame
= NULL
; /* Invalidate cache */
811 annotate_frames_invalid ();
814 /* Flush the frame cache, and start a new one if necessary. */
817 reinit_frame_cache (void)
819 flush_cached_frames ();
821 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
822 if (PIDGET (inferior_ptid
) != 0)
824 select_frame (get_current_frame ());
828 /* Return a structure containing various interesting information
829 about the frame that called NEXT_FRAME. Returns NULL
830 if there is no such frame. */
833 get_prev_frame (struct frame_info
*next_frame
)
835 CORE_ADDR address
= 0;
836 struct frame_info
*prev
;
839 /* Return the inner-most frame, when the caller passes in NULL. */
840 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
841 caller should have previously obtained a valid frame using
842 get_selected_frame() and then called this code - only possibility
843 I can think of is code behaving badly. */
844 if (next_frame
== NULL
)
846 /* NOTE: cagney/2002-11-09: There was a code segment here that
847 would error out when CURRENT_FRAME was NULL. The comment
848 that went with it made the claim ...
850 ``This screws value_of_variable, which just wants a nice
851 clean NULL return from block_innermost_frame if there are no
852 frames. I don't think I've ever seen this message happen
853 otherwise. And returning NULL here is a perfectly legitimate
856 Per the above, this code shouldn't even be called with a NULL
858 return current_frame
;
861 /* Only try to do the unwind once. */
862 if (next_frame
->prev_p
)
863 return next_frame
->prev
;
864 next_frame
->prev_p
= 1;
866 /* On some machines it is possible to call a function without
867 setting up a stack frame for it. On these machines, we
868 define this macro to take two args; a frameinfo pointer
869 identifying a frame and a variable to set or clear if it is
870 or isn't leafless. */
872 /* Still don't want to worry about this except on the innermost
873 frame. This macro will set FROMLEAF if NEXT_FRAME is a frameless
874 function invocation. */
875 if (next_frame
->next
== NULL
)
876 /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
877 the frame chain, not just the inner most frame! The generic,
878 per-architecture, frame code should handle this and the below
879 should simply be removed. */
880 fromleaf
= FRAMELESS_FUNCTION_INVOCATION (next_frame
);
885 /* A frameless inner-most frame. The `FP' (which isn't an
886 architecture frame-pointer register!) of the caller is the same
888 /* FIXME: 2002-11-09: There isn't any reason to special case this
889 edge condition. Instead the per-architecture code should hande
891 address
= get_frame_base (next_frame
);
894 /* Two macros defined in tm.h specify the machine-dependent
895 actions to be performed here.
897 First, get the frame's chain-pointer.
899 If that is zero, the frame is the outermost frame or a leaf
900 called by the outermost frame. This means that if start
901 calls main without a frame, we'll return 0 (which is fine
904 Nope; there's a problem. This also returns when the current
905 routine is a leaf of main. This is unacceptable. We move
906 this to after the ffi test; I'd rather have backtraces from
907 start go curfluy than have an abort called from main not show
909 address
= FRAME_CHAIN (next_frame
);
911 /* FIXME: cagney/2002-06-08: There should be two tests here.
912 The first would check for a valid frame chain based on a user
913 selectable policy. The default being ``stop at main'' (as
914 implemented by generic_func_frame_chain_valid()). Other
915 policies would be available - stop at NULL, .... The second
916 test, if provided by the target architecture, would check for
917 more exotic cases - most target architectures wouldn't bother
918 with this second case. */
919 if (!FRAME_CHAIN_VALID (address
, next_frame
))
925 /* Create an initially zero previous frame. */
926 prev
= (struct frame_info
*)
927 obstack_alloc (&frame_cache_obstack
,
928 sizeof (struct frame_info
));
929 memset (prev
, 0, sizeof (struct frame_info
));
932 next_frame
->prev
= prev
;
933 prev
->next
= next_frame
;
934 prev
->frame
= address
;
935 prev
->level
= next_frame
->level
+ 1;
936 /* FIXME: cagney/2002-11-18: Should be setting the frame's type
937 here, before anything else, and not last. Various INIT functions
938 are full of work-arounds for the frames type not being set
939 correctly from the word go. Ulgh! */
940 prev
->type
= NORMAL_FRAME
;
942 /* This change should not be needed, FIXME! We should determine
943 whether any targets *need* INIT_FRAME_PC to happen after
944 INIT_EXTRA_FRAME_INFO and come up with a simple way to express
947 INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
948 (where the PC is already set up) and here (where it isn't).
949 INIT_FRAME_PC is only called from here, always after
950 INIT_EXTRA_FRAME_INFO.
952 The catch is the MIPS, where INIT_EXTRA_FRAME_INFO requires the
953 PC value (which hasn't been set yet). Some other machines appear
954 to require INIT_EXTRA_FRAME_INFO before they can do
957 We shouldn't need INIT_FRAME_PC_FIRST to add more complication to
958 an already overcomplicated part of GDB. gnu@cygnus.com, 15Sep92.
960 Assuming that some machines need INIT_FRAME_PC after
961 INIT_EXTRA_FRAME_INFO, one possible scheme:
963 SETUP_INNERMOST_FRAME(): Default version is just create_new_frame
964 (read_fp ()), read_pc ()). Machines with extra frame info would
965 do that (or the local equivalent) and then set the extra fields.
967 SETUP_ARBITRARY_FRAME(argc, argv): Only change here is that
968 create_new_frame would no longer init extra frame info;
969 SETUP_ARBITRARY_FRAME would have to do that.
971 INIT_PREV_FRAME(fromleaf, prev) Replace INIT_EXTRA_FRAME_INFO and
972 INIT_FRAME_PC. This should also return a flag saying whether to
973 keep the new frame, or whether to discard it, because on some
974 machines (e.g. mips) it is really awkward to have
975 FRAME_CHAIN_VALID called *before* INIT_EXTRA_FRAME_INFO (there is
976 no good way to get information deduced in FRAME_CHAIN_VALID into
977 the extra fields of the new frame). std_frame_pc(fromleaf, prev)
979 This is the default setting for INIT_PREV_FRAME. It just does
980 what the default INIT_FRAME_PC does. Some machines will call it
981 from INIT_PREV_FRAME (either at the beginning, the end, or in the
982 middle). Some machines won't use it.
984 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
986 /* NOTE: cagney/2002-11-09: Just ignore the above! There is no
987 reason for things to be this complicated.
989 The trick is to assume that there is always a frame. Instead of
990 special casing the inner-most frame, create fake frame
991 (containing the hardware registers) that is inner to the
992 user-visible inner-most frame (...) and then unwind from that.
993 That way architecture code can use use the standard
994 frame_XX_unwind() functions and not differentiate between the
995 inner most and any other case.
997 Since there is always a frame to unwind from, there is always
998 somewhere (NEXT_FRAME) to store all the info needed to construct
999 a new (previous) frame without having to first create it. This
1000 means that the convolution below - needing to carefully order a
1001 frame's initialization - isn't needed.
1003 The irony here though, is that FRAME_CHAIN(), at least for a more
1004 up-to-date architecture, always calls FRAME_SAVED_PC(), and
1005 FRAME_SAVED_PC() computes the PC but without first needing the
1006 frame! Instead of the convolution below, we could have simply
1007 called FRAME_SAVED_PC() and been done with it! Note that
1008 FRAME_SAVED_PC() is being superseed by frame_pc_unwind() and that
1009 function does have somewhere to cache that PC value. */
1011 INIT_FRAME_PC_FIRST (fromleaf
, prev
);
1013 if (INIT_EXTRA_FRAME_INFO_P ())
1014 INIT_EXTRA_FRAME_INFO (fromleaf
, prev
);
1016 /* This entry is in the frame queue now, which is good since
1017 FRAME_SAVED_PC may use that queue to figure out its value (see
1018 tm-sparc.h). We want the pc saved in the inferior frame. */
1019 INIT_FRAME_PC (fromleaf
, prev
);
1021 /* If ->frame and ->pc are unchanged, we are in the process of
1022 getting ourselves into an infinite backtrace. Some architectures
1023 check this in FRAME_CHAIN or thereabouts, but it seems like there
1024 is no reason this can't be an architecture-independent check. */
1025 if (prev
->frame
== next_frame
->frame
1026 && prev
->pc
== next_frame
->pc
)
1028 next_frame
->prev
= NULL
;
1029 obstack_free (&frame_cache_obstack
, prev
);
1033 /* Initialize the code used to unwind the frame PREV based on the PC
1034 (and probably other architectural information). The PC lets you
1035 check things like the debug info at that point (dwarf2cfi?) and
1036 use that to decide how the frame should be unwound. */
1037 set_unwind_by_pc (prev
->pc
, prev
->frame
, &prev
->register_unwind
,
1040 /* NOTE: cagney/2002-11-18: The code segments, found in
1041 create_new_frame and get_prev_frame(), that initializes the
1042 frames type is subtly different. The latter only updates ->type
1043 when it encounters a SIGTRAMP_FRAME or DUMMY_FRAME. This stops
1044 get_prev_frame() overriding the frame's type when the INIT code
1045 has previously set it. This is really somewhat bogus. The
1046 initialization, as seen in create_new_frame(), should occur
1047 before the INIT function has been called. */
1048 /* FIXME: cagney/2002-11-24: Can't yet directly call
1049 pc_in_dummy_frame() as some architectures don't set
1050 PC_IN_CALL_DUMMY() to generic_pc_in_call_dummy() (remember the
1051 latter is implemented by simply calling pc_in_dummy_frame). */
1052 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1053 && PC_IN_CALL_DUMMY (prev
->pc
, 0, 0))
1054 prev
->type
= DUMMY_FRAME
;
1057 /* FIXME: cagney/2002-11-10: This should be moved to before the
1058 INIT code above so that the INIT code knows what the frame's
1059 type is (in fact, for a [generic] dummy-frame, the type can
1060 be set and then the entire initialization can be skipped.
1061 Unforunatly, its the INIT code that sets the PC (Hmm, catch
1064 find_pc_partial_function (prev
->pc
, &name
, NULL
, NULL
);
1065 if (PC_IN_SIGTRAMP (prev
->pc
, name
))
1066 prev
->type
= SIGTRAMP_FRAME
;
1067 /* FIXME: cagney/2002-11-11: Leave prev->type alone. Some
1068 architectures are forcing the frame's type in INIT so we
1069 don't want to override it here. Remember, NORMAL_FRAME == 0,
1070 so it all works (just :-/). Once this initialization is
1071 moved to the start of this function, all this nastness will
1079 get_frame_pc (struct frame_info
*frame
)
1085 pc_notcurrent (struct frame_info
*frame
)
1087 /* If FRAME is not the innermost frame, that normally means that
1088 FRAME->pc points at the return instruction (which is *after* the
1089 call instruction), and we want to get the line containing the
1090 call (because the call is where the user thinks the program is).
1091 However, if the next frame is either a SIGTRAMP_FRAME or a
1092 DUMMY_FRAME, then the next frame will contain a saved interrupt
1093 PC and such a PC indicates the current (rather than next)
1094 instruction/line, consequently, for such cases, want to get the
1095 line containing fi->pc. */
1096 struct frame_info
*next
= get_next_frame (frame
);
1097 int notcurrent
= (next
!= NULL
&& get_frame_type (next
) == NORMAL_FRAME
);
1102 find_frame_sal (struct frame_info
*frame
, struct symtab_and_line
*sal
)
1104 (*sal
) = find_pc_line (frame
->pc
, pc_notcurrent (frame
));
1107 /* Per "frame.h", return the ``address'' of the frame. Code should
1108 really be using get_frame_id(). */
1110 get_frame_base (struct frame_info
*fi
)
1115 /* Level of the selected frame: 0 for innermost, 1 for its caller, ...
1116 or -1 for a NULL frame. */
1119 frame_relative_level (struct frame_info
*fi
)
1128 get_frame_type (struct frame_info
*frame
)
1130 /* Some targets still don't use [generic] dummy frames. Catch them
1132 if (!DEPRECATED_USE_GENERIC_DUMMY_FRAMES
1133 && deprecated_frame_in_dummy (frame
))
1139 deprecated_set_frame_type (struct frame_info
*frame
, enum frame_type type
)
1141 /* Arrrg! See comment in "frame.h". */
1145 #ifdef FRAME_FIND_SAVED_REGS
1146 /* XXX - deprecated. This is a compatibility function for targets
1147 that do not yet implement FRAME_INIT_SAVED_REGS. */
1148 /* Find the addresses in which registers are saved in FRAME. */
1151 get_frame_saved_regs (struct frame_info
*frame
,
1152 struct frame_saved_regs
*saved_regs_addr
)
1154 if (frame
->saved_regs
== NULL
)
1156 frame
->saved_regs
= (CORE_ADDR
*)
1157 frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS
);
1159 if (saved_regs_addr
== NULL
)
1161 struct frame_saved_regs saved_regs
;
1162 FRAME_FIND_SAVED_REGS (frame
, saved_regs
);
1163 memcpy (frame
->saved_regs
, &saved_regs
, SIZEOF_FRAME_SAVED_REGS
);
1167 FRAME_FIND_SAVED_REGS (frame
, *saved_regs_addr
);
1168 memcpy (frame
->saved_regs
, saved_regs_addr
, SIZEOF_FRAME_SAVED_REGS
);
1174 _initialize_frame (void)
1176 obstack_init (&frame_cache_obstack
);