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. */
28 /* Start and end of object file containing the entry point.
29 STARTUP_FILE_END is the first address of the next file.
30 This file is assumed to be a startup file
31 and frames with pc's inside it
32 are treated as nonexistent.
34 Setting these variables is necessary so that backtraces do not fly off
35 the bottom of the stack. */
36 CORE_ADDR startup_file_start
;
37 CORE_ADDR startup_file_end
;
39 /* Is ADDR outside the startup file? */
41 outside_startup_file (addr
)
44 return !(addr
>= startup_file_start
&& addr
< startup_file_end
);
47 /* Address of innermost stack frame (contents of FP register) */
49 static FRAME current_frame
;
51 struct block
*block_for_pc ();
52 CORE_ADDR
get_pc_function_start ();
55 * Cache for frame addresses already read by gdb. Valid only while
56 * inferior is stopped. Control variables for the frame cache should
57 * be local to this module.
59 struct obstack frame_cache_obstack
;
61 /* Return the innermost (currently executing) stack frame. */
66 /* We assume its address is kept in a general register;
67 param.h says which register. */
73 set_current_frame (frame
)
76 current_frame
= frame
;
80 create_new_frame (addr
, pc
)
84 struct frame_info
*fci
; /* Same type as FRAME */
86 fci
= (struct frame_info
*)
87 obstack_alloc (&frame_cache_obstack
,
88 sizeof (struct frame_info
));
91 fci
->next
= (struct frame_info
*) 0;
92 fci
->prev
= (struct frame_info
*) 0;
94 fci
->next_frame
= 0; /* Since arbitrary */
97 #ifdef INIT_EXTRA_FRAME_INFO
98 INIT_EXTRA_FRAME_INFO (fci
);
104 /* Return the frame that called FRAME.
105 If FRAME is the original frame (it has no caller), return 0. */
108 get_prev_frame (frame
)
111 /* We're allowed to know that FRAME and "struct frame_info *" are
113 return get_prev_frame_info (frame
);
116 /* Return the frame that FRAME calls (0 if FRAME is the innermost
120 get_next_frame (frame
)
123 /* We're allowed to know that FRAME and "struct frame_info *" are
129 * Flush the entire frame cache.
132 flush_cached_frames ()
134 /* Since we can't really be sure what the first object allocated was */
135 obstack_free (&frame_cache_obstack
, 0);
136 obstack_init (&frame_cache_obstack
);
138 current_frame
= (struct frame_info
*) 0; /* Invalidate cache */
141 /* Return a structure containing various interesting information
142 about a specified stack frame. */
143 /* How do I justify including this function? Well, the FRAME
144 identifier format has gone through several changes recently, and
145 it's not completely inconceivable that it could happen again. If
146 it does, have this routine around will help */
149 get_frame_info (frame
)
155 /* If a machine allows frameless functions, it should define a macro
156 FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) in param.h. FI is the struct
157 frame_info for the frame, and FRAMELESS should be set to nonzero
158 if it represents a frameless function invocation. */
160 /* Many machines which allow frameless functions can detect them using
161 this macro. Such machines should define FRAMELESS_FUNCTION_INVOCATION
162 to just call this macro. */
163 #define FRAMELESS_LOOK_FOR_PROLOGUE(FI, FRAMELESS) \
165 CORE_ADDR func_start, after_prologue; \
166 func_start = (get_pc_function_start ((FI)->pc) + \
167 FUNCTION_START_OFFSET); \
170 after_prologue = func_start; \
171 SKIP_PROLOGUE (after_prologue); \
172 (FRAMELESS) = (after_prologue == func_start); \
175 /* If we can't find the start of the function, we don't really */ \
176 /* know whether the function is frameless, but we should be */ \
177 /* able to get a reasonable (i.e. best we can do under the */ \
178 /* circumstances) backtrace by saying that it isn't. */ \
182 /* Return a structure containing various interesting information
183 about the frame that called NEXT_FRAME. */
186 get_prev_frame_info (next_frame
)
190 struct frame_info
*prev
;
193 /* If the requested entry is in the cache, return it.
194 Otherwise, figure out what the address should be for the entry
195 we're about to add to the cache. */
201 if (!have_inferior_p () && !have_core_file_p ())
202 fatal ("get_prev_frame_info: Called before cache primed. \"Shouldn't happen.\"");
204 error ("No inferior or core file.");
207 return current_frame
;
210 /* If we have the prev one, return it */
211 if (next_frame
->prev
)
212 return next_frame
->prev
;
214 /* On some machines it is possible to call a function without
215 setting up a stack frame for it. On these machines, we
216 define this macro to take two args; a frameinfo pointer
217 identifying a frame and a variable to set or clear if it is
218 or isn't leafless. */
219 #ifdef FRAMELESS_FUNCTION_INVOCATION
220 /* Still don't want to worry about this except on the innermost
221 frame. This macro will set FROMLEAF if NEXT_FRAME is a
222 frameless function invocation. */
223 if (!(next_frame
->next
))
225 FRAMELESS_FUNCTION_INVOCATION (next_frame
, fromleaf
);
227 address
= next_frame
->frame
;
233 /* Two macros defined in param.h specify the machine-dependent
234 actions to be performed here.
235 First, get the frame's chain-pointer.
236 If that is zero, the frame is the outermost frame or a leaf
237 called by the outermost frame. This means that if start
238 calls main without a frame, we'll return 0 (which is fine
241 Nope; there's a problem. This also returns when the current
242 routine is a leaf of main. This is unacceptable. We move
243 this to after the ffi test; I'd rather have backtraces from
244 start go curfluy than have an abort called from main not show
246 address
= FRAME_CHAIN (next_frame
);
247 if (!FRAME_CHAIN_VALID (address
, next_frame
))
249 /* If this frame is a leaf, this will be superceeded by the
251 address
= FRAME_CHAIN_COMBINE (address
, next_frame
);
254 prev
= (struct frame_info
*)
255 obstack_alloc (&frame_cache_obstack
,
256 sizeof (struct frame_info
));
259 next_frame
->prev
= prev
;
260 prev
->next
= next_frame
;
261 prev
->prev
= (struct frame_info
*) 0;
262 prev
->frame
= address
;
263 prev
->next_frame
= prev
->next
? prev
->next
->frame
: 0;
265 #ifdef INIT_EXTRA_FRAME_INFO
266 INIT_EXTRA_FRAME_INFO(prev
);
269 /* This entry is in the frame queue now, which is good since
270 FRAME_SAVED_PC may use that queue to figure out it's value
271 (see m-sparc.h). We want the pc saved in the inferior frame. */
272 prev
->pc
= (fromleaf
? SAVED_PC_AFTER_CALL (next_frame
) :
273 next_frame
? FRAME_SAVED_PC (next_frame
) : read_pc ());
282 struct frame_info
*fi
;
283 fi
= get_frame_info (frame
);
287 /* Find the addresses in which registers are saved in FRAME. */
290 get_frame_saved_regs (frame_info_addr
, saved_regs_addr
)
291 struct frame_info
*frame_info_addr
;
292 struct frame_saved_regs
*saved_regs_addr
;
294 FRAME_FIND_SAVED_REGS (frame_info_addr
, *saved_regs_addr
);
297 /* Return the innermost lexical block in execution
298 in a specified stack frame. The frame address is assumed valid. */
301 get_frame_block (frame
)
304 struct frame_info
*fi
;
306 fi
= get_frame_info (frame
);
307 return block_for_pc (fi
->pc
);
313 return block_for_pc (read_pc ());
317 get_pc_function_start (pc
)
320 register struct block
*bl
= block_for_pc (pc
);
321 register struct symbol
*symbol
;
322 if (bl
== 0 || (symbol
= block_function (bl
)) == 0)
324 register int misc_index
= find_pc_misc_function (pc
);
326 return misc_function_vector
[misc_index
].address
;
329 bl
= SYMBOL_BLOCK_VALUE (symbol
);
330 return BLOCK_START (bl
);
333 /* Return the symbol for the function executing in frame FRAME. */
336 get_frame_function (frame
)
339 register struct block
*bl
= get_frame_block (frame
);
342 return block_function (bl
);
345 /* Return the innermost lexical block containing the specified pc value,
346 or 0 if there is none. */
348 extern struct symtab
*psymtab_to_symtab ();
352 register CORE_ADDR pc
;
354 register struct block
*b
;
355 register int bot
, top
, half
;
356 register struct symtab
*s
;
357 register struct partial_symtab
*ps
;
358 struct blockvector
*bl
;
360 /* First search all symtabs for one whose file contains our pc */
362 for (s
= symtab_list
; s
; s
= s
->next
)
364 bl
= BLOCKVECTOR (s
);
365 b
= BLOCKVECTOR_BLOCK (bl
, 0);
366 if (BLOCK_START (b
) <= pc
367 && BLOCK_END (b
) > pc
)
372 for (ps
= partial_symtab_list
; ps
; ps
= ps
->next
)
374 if (ps
->textlow
<= pc
375 && ps
->texthigh
> pc
)
378 fatal ("Internal error: pc found in readin psymtab and not in any symtab.");
379 s
= psymtab_to_symtab (ps
);
380 bl
= BLOCKVECTOR (s
);
381 b
= BLOCKVECTOR_BLOCK (bl
, 0);
389 /* Then search that symtab for the smallest block that wins. */
390 /* Use binary search to find the last block that starts before PC. */
393 top
= BLOCKVECTOR_NBLOCKS (bl
);
395 while (top
- bot
> 1)
397 half
= (top
- bot
+ 1) >> 1;
398 b
= BLOCKVECTOR_BLOCK (bl
, bot
+ half
);
399 if (BLOCK_START (b
) <= pc
)
405 /* Now search backward for a block that ends after PC. */
409 b
= BLOCKVECTOR_BLOCK (bl
, bot
);
410 if (BLOCK_END (b
) > pc
)
418 /* Return the function containing pc value PC.
419 Returns 0 if function is not known. */
422 find_pc_function (pc
)
425 register struct block
*b
= block_for_pc (pc
);
428 return block_function (b
);
431 /* Finds the "function" (text symbol) that is smaller than PC
432 but greatest of all of the potential text symbols. Sets
433 *NAME and/or *ADDRESS conditionally if that pointer is non-zero.
434 Returns 0 if it couldn't find anything, 1 if it did.
436 Note that there are several possible responses:
437 * Set *NAME and *ADDRESS to nonzero values and return 0
438 * Set *NAME and *ADDRESS to zero and return 0
439 * Don't set *NAME and *ADDRESS and return 1
440 (I don't know whether it *should* work this way, but I'd rather
441 document it than risk breaking code
442 which depends on this behavior). */
445 find_pc_partial_function (pc
, name
, address
)
450 struct partial_symtab
*pst
= find_pc_psymtab (pc
);
453 struct partial_symbol
*psb
;
459 /* The information we want has already been read in.
460 We can go to the already readin symbols and we'll get
461 the best possible answer. */
462 f
= find_pc_function (pc
);
465 /* No availible symbol. */
474 *name
= SYMBOL_NAME (f
);
476 *address
= SYMBOL_VALUE (f
);
479 /* Get the information from a combination of the pst
480 (static symbols), and the misc function vector (extern
482 miscfunc
= find_pc_misc_function (pc
);
483 psb
= find_pc_psymbol (pst
, pc
);
485 if (!psb
&& miscfunc
== -1)
495 && SYMBOL_VALUE(psb
) < misc_function_vector
[miscfunc
].address
))
498 *address
= misc_function_vector
[miscfunc
].address
;
500 *name
= misc_function_vector
[miscfunc
].name
;
505 *address
= SYMBOL_VALUE (psb
);
507 *name
= SYMBOL_NAME (psb
);
511 /* Must be in the misc function stuff. */
513 miscfunc
= find_pc_misc_function (pc
);
517 *address
= misc_function_vector
[miscfunc
].address
;
519 *name
= misc_function_vector
[miscfunc
].name
;
524 /* Find the misc function whose address is the largest
525 while being less than PC. Return its index in misc_function_vector.
526 Returns -1 if PC is not in suitable range. */
529 find_pc_misc_function (pc
)
530 register CORE_ADDR pc
;
533 register int hi
= misc_function_count
-1;
535 register int distance
;
537 /* Note that the last thing in the vector is always _etext. */
538 /* Actually, "end", now that non-functions
539 go on the misc_function_vector. */
541 /* Above statement is not *always* true - fix for case where there are */
542 /* no misc functions at all (ie no symbol table has been read). */
543 if (hi
< 0) return -1; /* no misc functions recorded */
545 /* trivial reject range test */
546 if (pc
< misc_function_vector
[0].address
||
547 pc
> misc_function_vector
[hi
].address
)
550 /* Note that the following search will not return hi if
551 pc == misc_function_vector[hi].address. If "end" points to the
552 first unused location, this is correct and the above test
553 simply needs to be changed to
554 "pc >= misc_function_vector[hi].address". */
556 new = (lo
+ hi
) >> 1;
557 distance
= misc_function_vector
[new].address
- pc
;
559 return new; /* an exact match */
560 else if (distance
> 0)
564 } while (hi
-lo
!= 1);
566 /* if here, we had no exact match, so return the lower choice */
570 /* Return the innermost stack frame executing inside of the specified block,
571 or zero if there is no such frame. */
574 block_innermost_frame (block
)
577 struct frame_info
*fi
;
578 register FRAME frame
;
579 register CORE_ADDR start
= BLOCK_START (block
);
580 register CORE_ADDR end
= BLOCK_END (block
);
585 frame
= get_prev_frame (frame
);
588 fi
= get_frame_info (frame
);
589 if (fi
->pc
>= start
&& fi
->pc
< end
)
595 _initialize_blockframe ()
597 obstack_init (&frame_cache_obstack
);