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"
37 /* Return a frame uniq ID that can be used to, later re-find the
41 get_frame_id (struct frame_info
*fi
, struct frame_id
*id
)
50 id
->base
= FRAME_FP (fi
);
56 frame_find_by_id (struct frame_id id
)
58 struct frame_info
*frame
;
60 /* ZERO denotes the null frame, let the caller decide what to do
61 about it. Should it instead return get_current_frame()? */
62 if (id
.base
== 0 && id
.pc
== 0)
65 for (frame
= get_current_frame ();
67 frame
= get_prev_frame (frame
))
69 if (INNER_THAN (FRAME_FP (frame
), id
.base
))
70 /* ``inner/current < frame < id.base''. Keep looking along
73 if (INNER_THAN (id
.base
, FRAME_FP (frame
)))
74 /* ``inner/current < id.base < frame''. Oops, gone past it.
77 /* FIXME: cagney/2002-04-21: This isn't sufficient. It should
78 use id.pc to check that the two frames belong to the same
79 function. Otherwise we'll do things like match dummy frames
80 or mis-match frameless functions. However, until someone
81 notices, stick with the existing behavour. */
88 frame_register_unwind (struct frame_info
*frame
, int regnum
,
89 int *optimizedp
, enum lval_type
*lvalp
,
90 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
92 struct frame_unwind_cache
*cache
;
94 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
95 that the value proper does not need to be fetched. */
96 gdb_assert (optimizedp
!= NULL
);
97 gdb_assert (lvalp
!= NULL
);
98 gdb_assert (addrp
!= NULL
);
99 gdb_assert (realnump
!= NULL
);
100 /* gdb_assert (bufferp != NULL); */
102 /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
103 special case, there was always an inner frame dedicated to the
104 hardware registers. Unfortunatly, there is too much unwind code
105 around that looks up/down the frame chain while making the
106 assumption that each frame level is using the same unwind code. */
110 /* We're in the inner-most frame, get the value direct from the
113 *lvalp
= lval_register
;
114 /* ULGH! Code uses the offset into the raw register byte array
115 as a way of identifying a register. */
116 *addrp
= REGISTER_BYTE (regnum
);
117 /* Should this code test ``register_cached (regnum) < 0'' and do
118 something like set realnum to -1 when the register isn't
122 deprecated_read_register_gen (regnum
, bufferp
);
126 /* Ask this frame to unwind its register. */
127 frame
->register_unwind (frame
, &frame
->register_unwind_cache
, regnum
,
128 optimizedp
, lvalp
, addrp
, realnump
, bufferp
);
132 frame_register (struct frame_info
*frame
, int regnum
,
133 int *optimizedp
, enum lval_type
*lvalp
,
134 CORE_ADDR
*addrp
, int *realnump
, void *bufferp
)
136 /* Require all but BUFFERP to be valid. A NULL BUFFERP indicates
137 that the value proper does not need to be fetched. */
138 gdb_assert (optimizedp
!= NULL
);
139 gdb_assert (lvalp
!= NULL
);
140 gdb_assert (addrp
!= NULL
);
141 gdb_assert (realnump
!= NULL
);
142 /* gdb_assert (bufferp != NULL); */
144 /* Ulgh! Old code that, for lval_register, sets ADDRP to the offset
145 of the register in the register cache. It should instead return
146 the REGNUM corresponding to that register. Translate the . */
147 if (GET_SAVED_REGISTER_P ())
149 GET_SAVED_REGISTER (bufferp
, optimizedp
, addrp
, frame
, regnum
, lvalp
);
150 /* Compute the REALNUM if the caller wants it. */
151 if (*lvalp
== lval_register
)
154 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
156 if (*addrp
== register_offset_hack (current_gdbarch
, regnum
))
162 internal_error (__FILE__
, __LINE__
,
163 "Failed to compute the register number corresponding"
164 " to 0x%s", paddr_d (*addrp
));
170 /* Reached the the bottom (youngest, inner most) of the frame chain
171 (youngest, inner most) frame, go direct to the hardware register
172 cache (do not pass go, do not try to cache the value, ...). The
173 unwound value would have been cached in frame->next but that
174 doesn't exist. This doesn't matter as the hardware register
175 cache is stopping any unnecessary accesses to the target. */
177 /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
178 special case, there was always an inner frame dedicated to the
179 hardware registers. Unfortunatly, there is too much unwind code
180 around that looks up/down the frame chain while making the
181 assumption that each frame level is using the same unwind code. */
184 frame_register_unwind (NULL
, regnum
, optimizedp
, lvalp
, addrp
, realnump
,
187 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
192 frame_unwind_signed_register (struct frame_info
*frame
, int regnum
,
199 void *buf
= alloca (MAX_REGISTER_RAW_SIZE
);
200 frame_register_unwind (frame
, regnum
, &optimized
, &lval
, &addr
,
202 (*val
) = extract_signed_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
206 frame_unwind_unsigned_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_unsigned_integer (buf
, REGISTER_VIRTUAL_SIZE (regnum
));
220 frame_read_unsigned_register (struct frame_info
*frame
, int regnum
,
223 /* NOTE: cagney/2002-10-31: There is a bit of dogma here - there is
224 always a frame. Both this, and the equivalent
225 frame_read_signed_register() function, can only be called with a
226 valid frame. If, for some reason, this function is called
227 without a frame then the problem isn't here, but rather in the
228 caller. It should of first created a frame and then passed that
230 /* NOTE: cagney/2002-10-31: As a side bar, keep in mind that the
231 ``current_frame'' should not be treated as a special case. While
232 ``get_next_frame (current_frame) == NULL'' currently holds, it
233 should, as far as possible, not be relied upon. In the future,
234 ``get_next_frame (current_frame)'' may instead simply return a
235 normal frame object that simply always gets register values from
236 the register cache. Consequently, frame code should try to avoid
237 tests like ``if get_next_frame() == NULL'' and instead just rely
238 on recursive frame calls (like the below code) when manipulating
240 gdb_assert (frame
!= NULL
);
241 frame_unwind_unsigned_register (get_next_frame (frame
), regnum
, val
);
245 frame_read_signed_register (struct frame_info
*frame
, int regnum
,
248 /* See note in frame_read_unsigned_register(). */
249 gdb_assert (frame
!= NULL
);
250 frame_unwind_signed_register (get_next_frame (frame
), regnum
, val
);
254 generic_unwind_get_saved_register (char *raw_buffer
,
257 struct frame_info
*frame
,
259 enum lval_type
*lvalp
)
264 enum lval_type lvalx
;
266 if (!target_has_registers
)
267 error ("No registers.");
269 /* Keep things simple, ensure that all the pointers (except valuep)
271 if (optimizedp
== NULL
)
272 optimizedp
= &optimizedx
;
278 /* Reached the the bottom (youngest, inner most) of the frame chain
279 (youngest, inner most) frame, go direct to the hardware register
280 cache (do not pass go, do not try to cache the value, ...). The
281 unwound value would have been cached in frame->next but that
282 doesn't exist. This doesn't matter as the hardware register
283 cache is stopping any unnecessary accesses to the target. */
285 /* NOTE: cagney/2002-04-14: It would be nice if, instead of a
286 special case, there was always an inner frame dedicated to the
287 hardware registers. Unfortunatly, there is too much unwind code
288 around that looks up/down the frame chain while making the
289 assumption that each frame level is using the same unwind code. */
292 frame_register_unwind (NULL
, regnum
, optimizedp
, lvalp
, addrp
, &realnumx
,
295 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
296 &realnumx
, raw_buffer
);
300 get_saved_register (char *raw_buffer
,
303 struct frame_info
*frame
,
305 enum lval_type
*lval
)
307 if (GET_SAVED_REGISTER_P ())
309 GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
312 generic_unwind_get_saved_register (raw_buffer
, optimized
, addrp
, frame
,
316 /* frame_register_read ()
318 Find and return the value of REGNUM for the specified stack frame.
319 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
321 Returns 0 if the register value could not be found. */
324 frame_register_read (struct frame_info
*frame
, int regnum
, void *myaddr
)
330 frame_register (frame
, regnum
, &optimized
, &lval
, &addr
, &realnum
, myaddr
);
332 /* FIXME: cagney/2002-05-15: This test, is just bogus.
334 It indicates that the target failed to supply a value for a
335 register because it was "not available" at this time. Problem
336 is, the target still has the register and so get saved_register()
337 may be returning a value saved on the stack. */
339 if (register_cached (regnum
) < 0)
340 return 0; /* register value not available */
346 /* Map between a frame register number and its name. A frame register
347 space is a superset of the cooked register space --- it also
348 includes builtin registers. */
351 frame_map_name_to_regnum (const char *name
, int len
)
355 /* Search register name space. */
356 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
357 if (REGISTER_NAME (i
) && len
== strlen (REGISTER_NAME (i
))
358 && strncmp (name
, REGISTER_NAME (i
), len
) == 0)
363 /* Try builtin registers. */
364 i
= builtin_reg_map_name_to_regnum (name
, len
);
367 /* A builtin register doesn't fall into the architecture's
369 gdb_assert (i
>= NUM_REGS
+ NUM_PSEUDO_REGS
);
377 frame_map_regnum_to_name (int regnum
)
381 if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
382 return REGISTER_NAME (regnum
);
383 return builtin_reg_map_regnum_to_name (regnum
);
386 /* Info about the innermost stack frame (contents of FP register) */
388 static struct frame_info
*current_frame
;
390 /* Cache for frame addresses already read by gdb. Valid only while
391 inferior is stopped. Control variables for the frame cache should
392 be local to this module. */
394 static struct obstack frame_cache_obstack
;
397 frame_obstack_alloc (unsigned long size
)
399 return obstack_alloc (&frame_cache_obstack
, size
);
403 frame_saved_regs_zalloc (struct frame_info
*fi
)
405 fi
->saved_regs
= (CORE_ADDR
*)
406 frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS
);
407 memset (fi
->saved_regs
, 0, SIZEOF_FRAME_SAVED_REGS
);
411 /* Return the innermost (currently executing) stack frame. */
414 get_current_frame (void)
416 if (current_frame
== NULL
)
418 if (target_has_stack
)
419 current_frame
= create_new_frame (read_fp (), read_pc ());
423 return current_frame
;
427 set_current_frame (struct frame_info
*frame
)
429 current_frame
= frame
;
432 /* Return the register saved in the simplistic ``saved_regs'' cache.
433 If the value isn't here AND a value is needed, try the next inner
437 frame_saved_regs_register_unwind (struct frame_info
*frame
, void **cache
,
438 int regnum
, int *optimizedp
,
439 enum lval_type
*lvalp
, CORE_ADDR
*addrp
,
440 int *realnump
, void *bufferp
)
442 /* There is always a frame at this point. And THIS is the frame
443 we're interested in. */
444 gdb_assert (frame
!= NULL
);
445 /* If we're using generic dummy frames, we'd better not be in a call
446 dummy. (generic_call_dummy_register_unwind ought to have been called
448 gdb_assert (!(USE_GENERIC_DUMMY_FRAMES
449 && PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
)));
451 /* Load the saved_regs register cache. */
452 if (frame
->saved_regs
== NULL
)
453 FRAME_INIT_SAVED_REGS (frame
);
455 if (frame
->saved_regs
!= NULL
456 && frame
->saved_regs
[regnum
] != 0)
458 if (regnum
== SP_REGNUM
)
460 /* SP register treated specially. */
466 store_address (bufferp
, REGISTER_RAW_SIZE (regnum
),
467 frame
->saved_regs
[regnum
]);
471 /* Any other register is saved in memory, fetch it but cache
472 a local copy of its value. */
474 *lvalp
= lval_memory
;
475 *addrp
= frame
->saved_regs
[regnum
];
480 /* Save each register value, as it is read in, in a
481 frame based cache. */
482 void **regs
= (*cache
);
485 int sizeof_cache
= ((NUM_REGS
+ NUM_PSEUDO_REGS
)
487 regs
= frame_obstack_alloc (sizeof_cache
);
488 memset (regs
, 0, sizeof_cache
);
491 if (regs
[regnum
] == NULL
)
494 = frame_obstack_alloc (REGISTER_RAW_SIZE (regnum
));
495 read_memory (frame
->saved_regs
[regnum
], regs
[regnum
],
496 REGISTER_RAW_SIZE (regnum
));
498 memcpy (bufferp
, regs
[regnum
], REGISTER_RAW_SIZE (regnum
));
500 /* Read the value in from memory. */
501 read_memory (frame
->saved_regs
[regnum
], bufferp
,
502 REGISTER_RAW_SIZE (regnum
));
509 /* No luck, assume this and the next frame have the same register
510 value. If a value is needed, pass the request on down the chain;
511 otherwise just return an indication that the value is in the same
512 register as the next frame. */
516 *lvalp
= lval_register
;
522 frame_register_unwind (frame
->next
, regnum
, optimizedp
, lvalp
, addrp
,
527 /* Function: get_saved_register
528 Find register number REGNUM relative to FRAME and put its (raw,
529 target format) contents in *RAW_BUFFER.
531 Set *OPTIMIZED if the variable was optimized out (and thus can't be
532 fetched). Note that this is never set to anything other than zero
533 in this implementation.
535 Set *LVAL to lval_memory, lval_register, or not_lval, depending on
536 whether the value was fetched from memory, from a register, or in a
537 strange and non-modifiable way (e.g. a frame pointer which was
538 calculated rather than fetched). We will use not_lval for values
539 fetched from generic dummy frames.
541 Set *ADDRP to the address, either in memory or as a REGISTER_BYTE
542 offset into the registers array. If the value is stored in a dummy
543 frame, set *ADDRP to zero.
545 To use this implementation, define a function called
546 "get_saved_register" in your target code, which simply passes all
547 of its arguments to this function.
549 The argument RAW_BUFFER must point to aligned memory. */
552 deprecated_generic_get_saved_register (char *raw_buffer
, int *optimized
,
554 struct frame_info
*frame
, int regnum
,
555 enum lval_type
*lval
)
557 if (!target_has_registers
)
558 error ("No registers.");
560 /* Normal systems don't optimize out things with register numbers. */
561 if (optimized
!= NULL
)
564 if (addrp
) /* default assumption: not found in memory */
567 /* Note: since the current frame's registers could only have been
568 saved by frames INTERIOR TO the current frame, we skip examining
569 the current frame itself: otherwise, we would be getting the
570 previous frame's registers which were saved by the current frame. */
572 while (frame
&& ((frame
= frame
->next
) != NULL
))
574 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
576 if (lval
) /* found it in a CALL_DUMMY frame */
579 /* FIXME: cagney/2002-06-26: This should be via the
580 gdbarch_register_read() method so that it, on the fly,
581 constructs either a raw or pseudo register from the raw
583 regcache_raw_read (generic_find_dummy_frame (frame
->pc
,
589 FRAME_INIT_SAVED_REGS (frame
);
590 if (frame
->saved_regs
!= NULL
591 && frame
->saved_regs
[regnum
] != 0)
593 if (lval
) /* found it saved on the stack */
595 if (regnum
== SP_REGNUM
)
597 if (raw_buffer
) /* SP register treated specially */
598 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
599 frame
->saved_regs
[regnum
]);
603 if (addrp
) /* any other register */
604 *addrp
= frame
->saved_regs
[regnum
];
606 read_memory (frame
->saved_regs
[regnum
], raw_buffer
,
607 REGISTER_RAW_SIZE (regnum
));
613 /* If we get thru the loop to this point, it means the register was
614 not saved in any frame. Return the actual live-register value. */
616 if (lval
) /* found it in a live register */
617 *lval
= lval_register
;
619 *addrp
= REGISTER_BYTE (regnum
);
621 deprecated_read_register_gen (regnum
, raw_buffer
);
624 /* Using the PC, select a mechanism for unwinding a frame returning
625 the previous frame. The register unwind function should, on
626 demand, initialize the ->context object. */
629 set_unwind_by_pc (CORE_ADDR pc
, CORE_ADDR fp
,
630 frame_register_unwind_ftype
**unwind
)
632 if (!USE_GENERIC_DUMMY_FRAMES
)
633 /* Still need to set this to something. The ``info frame'' code
634 calls this function to find out where the saved registers are.
635 Hopefully this is robust enough to stop any core dumps and
636 return vaguely correct values.. */
637 *unwind
= frame_saved_regs_register_unwind
;
638 else if (PC_IN_CALL_DUMMY (pc
, fp
, fp
))
639 *unwind
= dummy_frame_register_unwind
;
641 *unwind
= frame_saved_regs_register_unwind
;
644 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
645 Always returns a non-NULL value. */
648 create_new_frame (CORE_ADDR addr
, CORE_ADDR pc
)
650 struct frame_info
*fi
;
653 fi
= (struct frame_info
*)
654 obstack_alloc (&frame_cache_obstack
,
655 sizeof (struct frame_info
));
657 /* Zero all fields by default. */
658 memset (fi
, 0, sizeof (struct frame_info
));
662 find_pc_partial_function (pc
, &name
, (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
663 fi
->signal_handler_caller
= PC_IN_SIGTRAMP (fi
->pc
, name
);
665 if (INIT_EXTRA_FRAME_INFO_P ())
666 INIT_EXTRA_FRAME_INFO (0, fi
);
668 /* Select/initialize an unwind function. */
669 set_unwind_by_pc (fi
->pc
, fi
->frame
, &fi
->register_unwind
);
674 /* Return the frame that FRAME calls (NULL if FRAME is the innermost
678 get_next_frame (struct frame_info
*frame
)
683 /* Flush the entire frame cache. */
686 flush_cached_frames (void)
688 /* Since we can't really be sure what the first object allocated was */
689 obstack_free (&frame_cache_obstack
, 0);
690 obstack_init (&frame_cache_obstack
);
692 current_frame
= NULL
; /* Invalidate cache */
694 annotate_frames_invalid ();
697 /* Flush the frame cache, and start a new one if necessary. */
700 reinit_frame_cache (void)
702 flush_cached_frames ();
704 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
705 if (PIDGET (inferior_ptid
) != 0)
707 select_frame (get_current_frame ());
711 /* Return a structure containing various interesting information
712 about the frame that called NEXT_FRAME. Returns NULL
713 if there is no such frame. */
716 get_prev_frame (struct frame_info
*next_frame
)
718 CORE_ADDR address
= 0;
719 struct frame_info
*prev
;
723 /* Return the inner-most frame, when the caller passes in NULL. */
724 /* NOTE: cagney/2002-11-09: Not sure how this would happen. The
725 caller should have previously obtained a valid frame using
726 get_selected_frame() and then called this code - only possibility
727 I can think of is code behaving badly. */
728 if (next_frame
== NULL
)
730 /* NOTE: cagney/2002-11-09: There was a code segment here that
731 would error out when CURRENT_FRAME was NULL. The comment
732 that went with it made the claim ...
734 ``This screws value_of_variable, which just wants a nice
735 clean NULL return from block_innermost_frame if there are no
736 frames. I don't think I've ever seen this message happen
737 otherwise. And returning NULL here is a perfectly legitimate
740 Per the above, this code shouldn't even be called with a NULL
742 return current_frame
;
745 /* If we have the prev one, return it. */
746 if (next_frame
->prev
)
747 /* FIXME: cagney/2002-11-09: Rather than relying on ->PREV being
748 non-NULL, there should be a predicate (->prev_p?). That would
749 stop this function constantly trying to chain beyond the
751 return next_frame
->prev
;
753 /* On some machines it is possible to call a function without
754 setting up a stack frame for it. On these machines, we
755 define this macro to take two args; a frameinfo pointer
756 identifying a frame and a variable to set or clear if it is
757 or isn't leafless. */
759 /* Still don't want to worry about this except on the innermost
760 frame. This macro will set FROMLEAF if NEXT_FRAME is a frameless
761 function invocation. */
762 if (next_frame
->next
== NULL
)
763 /* FIXME: 2002-11-09: Frameless functions can occure anywhere in
764 the frame chain, not just the inner most frame! The generic,
765 per-architecture, frame code should handle this and the below
766 should simply be removed. */
767 fromleaf
= FRAMELESS_FUNCTION_INVOCATION (next_frame
);
772 /* A frameless inner-most frame. The `FP' (which isn't an
773 architecture frame-pointer register!) of the caller is the same
775 /* FIXME: 2002-11-09: There isn't any reason to special case this
776 edge condition. Instead the per-architecture code should hande
778 address
= FRAME_FP (next_frame
);
781 /* Two macros defined in tm.h specify the machine-dependent
782 actions to be performed here.
784 First, get the frame's chain-pointer.
786 If that is zero, the frame is the outermost frame or a leaf
787 called by the outermost frame. This means that if start
788 calls main without a frame, we'll return 0 (which is fine
791 Nope; there's a problem. This also returns when the current
792 routine is a leaf of main. This is unacceptable. We move
793 this to after the ffi test; I'd rather have backtraces from
794 start go curfluy than have an abort called from main not show
796 address
= FRAME_CHAIN (next_frame
);
798 /* FIXME: cagney/2002-06-08: There should be two tests here.
799 The first would check for a valid frame chain based on a user
800 selectable policy. The default being ``stop at main'' (as
801 implemented by generic_func_frame_chain_valid()). Other
802 policies would be available - stop at NULL, .... The second
803 test, if provided by the target architecture, would check for
804 more exotic cases - most target architectures wouldn't bother
805 with this second case. */
806 if (!FRAME_CHAIN_VALID (address
, next_frame
))
812 /* Create an initially zero previous frame. */
813 prev
= (struct frame_info
*)
814 obstack_alloc (&frame_cache_obstack
,
815 sizeof (struct frame_info
));
816 memset (prev
, 0, sizeof (struct frame_info
));
819 next_frame
->prev
= prev
;
820 prev
->next
= next_frame
;
821 prev
->frame
= address
;
822 prev
->level
= next_frame
->level
+ 1;
824 /* This change should not be needed, FIXME! We should determine
825 whether any targets *need* INIT_FRAME_PC to happen after
826 INIT_EXTRA_FRAME_INFO and come up with a simple way to express
829 INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
830 (where the PC is already set up) and here (where it isn't).
831 INIT_FRAME_PC is only called from here, always after
832 INIT_EXTRA_FRAME_INFO.
834 The catch is the MIPS, where INIT_EXTRA_FRAME_INFO requires the
835 PC value (which hasn't been set yet). Some other machines appear
836 to require INIT_EXTRA_FRAME_INFO before they can do
839 We shouldn't need INIT_FRAME_PC_FIRST to add more complication to
840 an already overcomplicated part of GDB. gnu@cygnus.com, 15Sep92.
842 Assuming that some machines need INIT_FRAME_PC after
843 INIT_EXTRA_FRAME_INFO, one possible scheme:
845 SETUP_INNERMOST_FRAME(): Default version is just create_new_frame
846 (read_fp ()), read_pc ()). Machines with extra frame info would
847 do that (or the local equivalent) and then set the extra fields.
849 SETUP_ARBITRARY_FRAME(argc, argv): Only change here is that
850 create_new_frame would no longer init extra frame info;
851 SETUP_ARBITRARY_FRAME would have to do that.
853 INIT_PREV_FRAME(fromleaf, prev) Replace INIT_EXTRA_FRAME_INFO and
854 INIT_FRAME_PC. This should also return a flag saying whether to
855 keep the new frame, or whether to discard it, because on some
856 machines (e.g. mips) it is really awkward to have
857 FRAME_CHAIN_VALID called *before* INIT_EXTRA_FRAME_INFO (there is
858 no good way to get information deduced in FRAME_CHAIN_VALID into
859 the extra fields of the new frame). std_frame_pc(fromleaf, prev)
861 This is the default setting for INIT_PREV_FRAME. It just does
862 what the default INIT_FRAME_PC does. Some machines will call it
863 from INIT_PREV_FRAME (either at the beginning, the end, or in the
864 middle). Some machines won't use it.
866 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
868 /* NOTE: cagney/2002-11-09: Just ignore the above! There is no
869 reason for things to be this complicated.
871 The trick is to assume that there is always a frame. Instead of
872 special casing the inner-most frame, create fake frame
873 (containing the hardware registers) that is inner to the
874 user-visible inner-most frame (...) and then unwind from that.
875 That way architecture code can use use the standard
876 frame_XX_unwind() functions and not differentiate between the
877 inner most and any other case.
879 Since there is always a frame to unwind from, there is always
880 somewhere (NEXT_FRAME) to store all the info needed to construct
881 a new (previous) frame without having to first create it. This
882 means that the convolution below - needing to carefully order a
883 frame's initialization - isn't needed.
885 The irony here though, is that FRAME_CHAIN(), at least for a more
886 up-to-date architecture, always calls FRAME_SAVED_PC(), and
887 FRAME_SAVED_PC() computes the PC but without first needing the
888 frame! Instead of the convolution below, we could have simply
889 called FRAME_SAVED_PC() and been done with it! Note that
890 FRAME_SAVED_PC() is being superseed by frame_pc_unwind() and that
891 function does have somewhere to cache that PC value. */
893 INIT_FRAME_PC_FIRST (fromleaf
, prev
);
895 if (INIT_EXTRA_FRAME_INFO_P ())
896 INIT_EXTRA_FRAME_INFO (fromleaf
, prev
);
898 /* This entry is in the frame queue now, which is good since
899 FRAME_SAVED_PC may use that queue to figure out its value (see
900 tm-sparc.h). We want the pc saved in the inferior frame. */
901 INIT_FRAME_PC (fromleaf
, prev
);
903 /* If ->frame and ->pc are unchanged, we are in the process of
904 getting ourselves into an infinite backtrace. Some architectures
905 check this in FRAME_CHAIN or thereabouts, but it seems like there
906 is no reason this can't be an architecture-independent check. */
907 if (prev
->frame
== next_frame
->frame
908 && prev
->pc
== next_frame
->pc
)
910 next_frame
->prev
= NULL
;
911 obstack_free (&frame_cache_obstack
, prev
);
915 /* Initialize the code used to unwind the frame PREV based on the PC
916 (and probably other architectural information). The PC lets you
917 check things like the debug info at that point (dwarf2cfi?) and
918 use that to decide how the frame should be unwound. */
919 set_unwind_by_pc (prev
->pc
, prev
->frame
, &prev
->register_unwind
);
921 find_pc_partial_function (prev
->pc
, &name
,
922 (CORE_ADDR
*) NULL
, (CORE_ADDR
*) NULL
);
923 if (PC_IN_SIGTRAMP (prev
->pc
, name
))
924 prev
->signal_handler_caller
= 1;
930 get_frame_pc (struct frame_info
*frame
)
935 #ifdef FRAME_FIND_SAVED_REGS
936 /* XXX - deprecated. This is a compatibility function for targets
937 that do not yet implement FRAME_INIT_SAVED_REGS. */
938 /* Find the addresses in which registers are saved in FRAME. */
941 get_frame_saved_regs (struct frame_info
*frame
,
942 struct frame_saved_regs
*saved_regs_addr
)
944 if (frame
->saved_regs
== NULL
)
946 frame
->saved_regs
= (CORE_ADDR
*)
947 frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS
);
949 if (saved_regs_addr
== NULL
)
951 struct frame_saved_regs saved_regs
;
952 FRAME_FIND_SAVED_REGS (frame
, saved_regs
);
953 memcpy (frame
->saved_regs
, &saved_regs
, SIZEOF_FRAME_SAVED_REGS
);
957 FRAME_FIND_SAVED_REGS (frame
, *saved_regs_addr
);
958 memcpy (frame
->saved_regs
, saved_regs_addr
, SIZEOF_FRAME_SAVED_REGS
);
964 _initialize_frame (void)
966 obstack_init (&frame_cache_obstack
);