1 /* Get info from stack frames;
2 convert between frames, blocks, functions and pc values.
3 Copyright (C) 1986, 1987, 1988, 1989 Free Software Foundation, Inc.
5 This file is part of GDB.
7 GDB is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 1, or (at your option)
12 GDB is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GDB; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
26 #include "value.h" /* for read_register */
27 #include "target.h" /* for target_has_stack */
29 /* Required by INIT_EXTRA_FRAME_INFO on 88k. */
33 CORE_ADDR
read_pc (); /* In infcmd.c */
35 /* Start and end of object file containing the entry point.
36 STARTUP_FILE_END is the first address of the next file.
37 This file is assumed to be a startup file
38 and frames with pc's inside it
39 are treated as nonexistent.
41 Setting these variables is necessary so that backtraces do not fly off
42 the bottom of the stack. */
43 CORE_ADDR startup_file_start
;
44 CORE_ADDR startup_file_end
;
46 /* Is ADDR outside the startup file? Note that if your machine
47 has a way to detect the bottom of the stack, there is no need
48 to call this function from FRAME_CHAIN_VALID; the reason for
49 doing so is that some machines have no way of detecting bottom
52 outside_startup_file (addr
)
55 return !(addr
>= startup_file_start
&& addr
< startup_file_end
);
58 /* Address of innermost stack frame (contents of FP register) */
60 static FRAME current_frame
;
63 * Cache for frame addresses already read by gdb. Valid only while
64 * inferior is stopped. Control variables for the frame cache should
65 * be local to this module.
67 struct obstack frame_cache_obstack
;
69 /* Return the innermost (currently executing) stack frame. */
74 /* We assume its address is kept in a general register;
75 param.h says which register. */
81 set_current_frame (frame
)
84 current_frame
= frame
;
88 create_new_frame (addr
, pc
)
92 struct frame_info
*fci
; /* Same type as FRAME */
94 fci
= (struct frame_info
*)
95 obstack_alloc (&frame_cache_obstack
,
96 sizeof (struct frame_info
));
99 fci
->next
= (struct frame_info
*) 0;
100 fci
->prev
= (struct frame_info
*) 0;
102 fci
->next_frame
= 0; /* Since arbitrary */
105 #ifdef INIT_EXTRA_FRAME_INFO
106 INIT_EXTRA_FRAME_INFO (fci
);
112 /* Return the frame that called FRAME.
113 If FRAME is the original frame (it has no caller), return 0. */
116 get_prev_frame (frame
)
119 /* We're allowed to know that FRAME and "struct frame_info *" are
121 return get_prev_frame_info (frame
);
124 /* Return the frame that FRAME calls (0 if FRAME is the innermost
128 get_next_frame (frame
)
131 /* We're allowed to know that FRAME and "struct frame_info *" are
137 * Flush the entire frame cache.
140 flush_cached_frames ()
142 /* Since we can't really be sure what the first object allocated was */
143 obstack_free (&frame_cache_obstack
, 0);
144 obstack_init (&frame_cache_obstack
);
146 current_frame
= (struct frame_info
*) 0; /* Invalidate cache */
149 /* Return a structure containing various interesting information
150 about a specified stack frame. */
151 /* How do I justify including this function? Well, the FRAME
152 identifier format has gone through several changes recently, and
153 it's not completely inconceivable that it could happen again. If
154 it does, have this routine around will help */
157 get_frame_info (frame
)
163 /* If a machine allows frameless functions, it should define a macro
164 FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) in param.h. FI is the struct
165 frame_info for the frame, and FRAMELESS should be set to nonzero
166 if it represents a frameless function invocation. */
168 /* Return nonzero if the function for this frame has a prologue. Many
169 machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
173 frameless_look_for_prologue (frame
)
176 CORE_ADDR func_start
, after_prologue
;
177 func_start
= (get_pc_function_start (frame
->pc
) +
178 FUNCTION_START_OFFSET
);
181 after_prologue
= func_start
;
182 SKIP_PROLOGUE (after_prologue
);
183 return after_prologue
== func_start
;
186 /* If we can't find the start of the function, we don't really
187 know whether the function is frameless, but we should be able
188 to get a reasonable (i.e. best we can do under the
189 circumstances) backtrace by saying that it isn't. */
193 #if !defined (INIT_FRAME_PC)
194 #define INIT_FRAME_PC(fromleaf, prev) \
195 prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
196 prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
199 /* Return a structure containing various interesting information
200 about the frame that called NEXT_FRAME. Returns NULL
201 if there is no such frame. */
204 get_prev_frame_info (next_frame
)
208 struct frame_info
*prev
;
211 /* If the requested entry is in the cache, return it.
212 Otherwise, figure out what the address should be for the entry
213 we're about to add to the cache. */
219 error ("You haven't set up a process's stack to examine.");
222 return current_frame
;
225 /* If we have the prev one, return it */
226 if (next_frame
->prev
)
227 return next_frame
->prev
;
229 /* On some machines it is possible to call a function without
230 setting up a stack frame for it. On these machines, we
231 define this macro to take two args; a frameinfo pointer
232 identifying a frame and a variable to set or clear if it is
233 or isn't leafless. */
234 #ifdef FRAMELESS_FUNCTION_INVOCATION
235 /* Still don't want to worry about this except on the innermost
236 frame. This macro will set FROMLEAF if NEXT_FRAME is a
237 frameless function invocation. */
238 if (!(next_frame
->next
))
240 FRAMELESS_FUNCTION_INVOCATION (next_frame
, fromleaf
);
242 address
= next_frame
->frame
;
248 /* Two macros defined in tm.h specify the machine-dependent
249 actions to be performed here.
250 First, get the frame's chain-pointer.
251 If that is zero, the frame is the outermost frame or a leaf
252 called by the outermost frame. This means that if start
253 calls main without a frame, we'll return 0 (which is fine
256 Nope; there's a problem. This also returns when the current
257 routine is a leaf of main. This is unacceptable. We move
258 this to after the ffi test; I'd rather have backtraces from
259 start go curfluy than have an abort called from main not show
261 address
= FRAME_CHAIN (next_frame
);
262 if (!FRAME_CHAIN_VALID (address
, next_frame
))
264 address
= FRAME_CHAIN_COMBINE (address
, next_frame
);
267 prev
= (struct frame_info
*)
268 obstack_alloc (&frame_cache_obstack
,
269 sizeof (struct frame_info
));
272 next_frame
->prev
= prev
;
273 prev
->next
= next_frame
;
274 prev
->prev
= (struct frame_info
*) 0;
275 prev
->frame
= address
;
276 prev
->next_frame
= prev
->next
? prev
->next
->frame
: 0;
278 #ifdef INIT_EXTRA_FRAME_INFO
279 INIT_EXTRA_FRAME_INFO(prev
);
282 /* This entry is in the frame queue now, which is good since
283 FRAME_SAVED_PC may use that queue to figure out it's value
284 (see m-sparc.h). We want the pc saved in the inferior frame. */
285 INIT_FRAME_PC(fromleaf
, prev
);
294 struct frame_info
*fi
;
295 fi
= get_frame_info (frame
);
299 #if defined (FRAME_FIND_SAVED_REGS)
300 /* Find the addresses in which registers are saved in FRAME. */
303 get_frame_saved_regs (frame_info_addr
, saved_regs_addr
)
304 struct frame_info
*frame_info_addr
;
305 struct frame_saved_regs
*saved_regs_addr
;
307 FRAME_FIND_SAVED_REGS (frame_info_addr
, *saved_regs_addr
);
311 /* Return the innermost lexical block in execution
312 in a specified stack frame. The frame address is assumed valid. */
315 get_frame_block (frame
)
318 struct frame_info
*fi
;
321 fi
= get_frame_info (frame
);
324 if (fi
->next_frame
!= 0)
325 /* We are not in the innermost frame. We need to subtract one to
326 get the correct block, in case the call instruction was the
327 last instruction of the block. If there are any machines on
328 which the saved pc does not point to after the call insn, we
329 probably want to make fi->pc point after the call insn anyway. */
331 return block_for_pc (pc
);
337 return block_for_pc (read_pc ());
341 get_pc_function_start (pc
)
344 register struct block
*bl
= block_for_pc (pc
);
345 register struct symbol
*symbol
;
346 if (bl
== 0 || (symbol
= block_function (bl
)) == 0)
348 register int misc_index
= find_pc_misc_function (pc
);
350 return misc_function_vector
[misc_index
].address
;
353 bl
= SYMBOL_BLOCK_VALUE (symbol
);
354 return BLOCK_START (bl
);
357 /* Return the symbol for the function executing in frame FRAME. */
360 get_frame_function (frame
)
363 register struct block
*bl
= get_frame_block (frame
);
366 return block_function (bl
);
369 /* Return the blockvector immediately containing the innermost lexical block
370 containing the specified pc value, or 0 if there is none.
371 PINDEX is a pointer to the index value of the block. If PINDEX
372 is NULL, we don't pass this information back to the caller. */
375 blockvector_for_pc (pc
, pindex
)
376 register CORE_ADDR pc
;
379 register struct block
*b
;
380 register int bot
, top
, half
;
381 register struct symtab
*s
;
382 struct blockvector
*bl
;
384 /* First search all symtabs for one whose file contains our pc */
385 s
= find_pc_symtab (pc
);
389 bl
= BLOCKVECTOR (s
);
390 b
= BLOCKVECTOR_BLOCK (bl
, 0);
392 /* Then search that symtab for the smallest block that wins. */
393 /* Use binary search to find the last block that starts before PC. */
396 top
= BLOCKVECTOR_NBLOCKS (bl
);
398 while (top
- bot
> 1)
400 half
= (top
- bot
+ 1) >> 1;
401 b
= BLOCKVECTOR_BLOCK (bl
, bot
+ half
);
402 if (BLOCK_START (b
) <= pc
)
408 /* Now search backward for a block that ends after PC. */
412 b
= BLOCKVECTOR_BLOCK (bl
, bot
);
413 if (BLOCK_END (b
) > pc
)
425 /* Return the innermost lexical block containing the specified pc value,
426 or 0 if there is none. */
430 register CORE_ADDR pc
;
432 register struct blockvector
*bl
;
435 bl
= blockvector_for_pc (pc
, &index
);
437 return BLOCKVECTOR_BLOCK (bl
, index
);
441 /* Return the function containing pc value PC.
442 Returns 0 if function is not known. */
445 find_pc_function (pc
)
448 register struct block
*b
= block_for_pc (pc
);
451 return block_function (b
);
454 /* These variables are used to cache the most recent result
455 * of find_pc_partial_function. */
457 static CORE_ADDR cache_pc_function_low
= 0;
458 static CORE_ADDR cache_pc_function_high
= 0;
459 static char *cache_pc_function_name
= 0;
461 /* Clear cache, e.g. when symbol table is discarded. */
464 clear_pc_function_cache()
466 cache_pc_function_low
= 0;
467 cache_pc_function_high
= 0;
468 cache_pc_function_name
= (char *)0;
471 /* Finds the "function" (text symbol) that is smaller than PC
472 but greatest of all of the potential text symbols. Sets
473 *NAME and/or *ADDRESS conditionally if that pointer is non-zero.
474 Returns 0 if it couldn't find anything, 1 if it did. On a zero
475 return, *NAME and *ADDRESS are always set to zero. On a 1 return,
476 *NAME and *ADDRESS contain real information. */
479 find_pc_partial_function (pc
, name
, address
)
484 struct partial_symtab
*pst
;
487 struct partial_symbol
*psb
;
489 if (pc
>= cache_pc_function_low
&& pc
< cache_pc_function_high
)
492 *address
= cache_pc_function_low
;
494 *name
= cache_pc_function_name
;
498 pst
= find_pc_psymtab (pc
);
503 /* The information we want has already been read in.
504 We can go to the already readin symbols and we'll get
505 the best possible answer. */
506 f
= find_pc_function (pc
);
510 /* No available symbol. */
518 cache_pc_function_low
= BLOCK_START (SYMBOL_BLOCK_VALUE (f
));
519 cache_pc_function_high
= BLOCK_END (SYMBOL_BLOCK_VALUE (f
));
520 cache_pc_function_name
= SYMBOL_NAME (f
);
522 *name
= cache_pc_function_name
;
524 *address
= cache_pc_function_low
;
528 /* Get the information from a combination of the pst
529 (static symbols), and the misc function vector (extern
531 miscfunc
= find_pc_misc_function (pc
);
532 psb
= find_pc_psymbol (pst
, pc
);
534 if (!psb
&& miscfunc
== -1)
540 || (SYMBOL_VALUE_ADDRESS (psb
)
541 >= misc_function_vector
[miscfunc
].address
)))
543 /* This case isn't being cached currently. */
545 *address
= SYMBOL_VALUE_ADDRESS (psb
);
547 *name
= SYMBOL_NAME (psb
);
552 /* Must be in the misc function stuff. */
554 miscfunc
= find_pc_misc_function (pc
);
560 if (misc_function_vector
[miscfunc
].type
== mf_text
)
561 cache_pc_function_low
= misc_function_vector
[miscfunc
].address
;
563 /* It is a transfer table for Sun shared libraries. */
564 cache_pc_function_low
= pc
- FUNCTION_START_OFFSET
;
566 cache_pc_function_name
= misc_function_vector
[miscfunc
].name
;
567 if (miscfunc
< misc_function_count
&& 1 /* FIXME mf_text again? */ )
568 cache_pc_function_high
= misc_function_vector
[miscfunc
+1].address
;
570 cache_pc_function_high
= cache_pc_function_low
+ 1;
572 *address
= cache_pc_function_low
;
574 *name
= cache_pc_function_name
;
578 /* Find the misc function whose address is the largest
579 while being less than PC. Return its index in misc_function_vector.
580 Returns -1 if PC is not in suitable range. */
583 find_pc_misc_function (pc
)
584 register CORE_ADDR pc
;
587 register int hi
= misc_function_count
-1;
590 /* Note that the last thing in the vector is always _etext. */
591 /* Actually, "end", now that non-functions
592 go on the misc_function_vector. */
594 /* Above statement is not *always* true - fix for case where there are */
595 /* no misc functions at all (ie no symbol table has been read). */
596 if (hi
< 0) return -1; /* no misc functions recorded */
598 /* trivial reject range test */
599 if (pc
< misc_function_vector
[0].address
||
600 pc
> misc_function_vector
[hi
].address
)
603 /* Note that the following search will not return hi if
604 pc == misc_function_vector[hi].address. If "end" points to the
605 first unused location, this is correct and the above test
606 simply needs to be changed to
607 "pc >= misc_function_vector[hi].address". */
609 new = (lo
+ hi
) >> 1;
610 if (misc_function_vector
[new].address
== pc
)
611 return new; /* an exact match */
612 else if (misc_function_vector
[new].address
> pc
)
616 } while (hi
-lo
!= 1);
618 /* if here, we had no exact match, so return the lower choice */
622 /* Return the innermost stack frame executing inside of the specified block,
623 or zero if there is no such frame. */
626 block_innermost_frame (block
)
629 struct frame_info
*fi
;
630 register FRAME frame
;
631 register CORE_ADDR start
= BLOCK_START (block
);
632 register CORE_ADDR end
= BLOCK_END (block
);
637 frame
= get_prev_frame (frame
);
640 fi
= get_frame_info (frame
);
641 if (fi
->pc
>= start
&& fi
->pc
< end
)
647 _initialize_blockframe ()
649 obstack_init (&frame_cache_obstack
);