Switch the license of all .c files to GPLv3.
[external/binutils.git] / gdb / blockframe.c
1 /* Get info from stack frames; convert between frames, blocks,
2    functions and pc values.
3
4    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
5    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
6    Free Software Foundation, Inc.
7
8    This file is part of GDB.
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
23 #include "defs.h"
24 #include "symtab.h"
25 #include "bfd.h"
26 #include "objfiles.h"
27 #include "frame.h"
28 #include "gdbcore.h"
29 #include "value.h"
30 #include "target.h"
31 #include "inferior.h"
32 #include "annotate.h"
33 #include "regcache.h"
34 #include "gdb_assert.h"
35 #include "dummy-frame.h"
36 #include "command.h"
37 #include "gdbcmd.h"
38 #include "block.h"
39
40 /* Prototypes for exported functions. */
41
42 void _initialize_blockframe (void);
43
44 /* Return the innermost lexical block in execution
45    in a specified stack frame.  The frame address is assumed valid.
46
47    If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
48    address we used to choose the block.  We use this to find a source
49    line, to decide which macro definitions are in scope.
50
51    The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
52    PC, and may not really be a valid PC at all.  For example, in the
53    caller of a function declared to never return, the code at the
54    return address will never be reached, so the call instruction may
55    be the very last instruction in the block.  So the address we use
56    to choose the block is actually one byte before the return address
57    --- hopefully pointing us at the call instruction, or its delay
58    slot instruction.  */
59
60 struct block *
61 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
62 {
63   const CORE_ADDR pc = get_frame_address_in_block (frame);
64
65   if (addr_in_block)
66     *addr_in_block = pc;
67
68   return block_for_pc (pc);
69 }
70
71 CORE_ADDR
72 get_pc_function_start (CORE_ADDR pc)
73 {
74   struct block *bl;
75   struct minimal_symbol *msymbol;
76
77   bl = block_for_pc (pc);
78   if (bl)
79     {
80       struct symbol *symbol = block_function (bl);
81
82       if (symbol)
83         {
84           bl = SYMBOL_BLOCK_VALUE (symbol);
85           return BLOCK_START (bl);
86         }
87     }
88
89   msymbol = lookup_minimal_symbol_by_pc (pc);
90   if (msymbol)
91     {
92       CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
93
94       if (find_pc_section (fstart))
95         return fstart;
96     }
97
98   return 0;
99 }
100
101 /* Return the symbol for the function executing in frame FRAME.  */
102
103 struct symbol *
104 get_frame_function (struct frame_info *frame)
105 {
106   struct block *bl = get_frame_block (frame, 0);
107   if (bl == 0)
108     return 0;
109   return block_function (bl);
110 }
111 \f
112
113 /* Return the function containing pc value PC in section SECTION.
114    Returns 0 if function is not known.  */
115
116 struct symbol *
117 find_pc_sect_function (CORE_ADDR pc, struct bfd_section *section)
118 {
119   struct block *b = block_for_pc_sect (pc, section);
120   if (b == 0)
121     return 0;
122   return block_function (b);
123 }
124
125 /* Return the function containing pc value PC.
126    Returns 0 if function is not known.  Backward compatibility, no section */
127
128 struct symbol *
129 find_pc_function (CORE_ADDR pc)
130 {
131   return find_pc_sect_function (pc, find_pc_mapped_section (pc));
132 }
133
134 /* These variables are used to cache the most recent result
135  * of find_pc_partial_function. */
136
137 static CORE_ADDR cache_pc_function_low = 0;
138 static CORE_ADDR cache_pc_function_high = 0;
139 static char *cache_pc_function_name = 0;
140 static struct bfd_section *cache_pc_function_section = NULL;
141
142 /* Clear cache, e.g. when symbol table is discarded. */
143
144 void
145 clear_pc_function_cache (void)
146 {
147   cache_pc_function_low = 0;
148   cache_pc_function_high = 0;
149   cache_pc_function_name = (char *) 0;
150   cache_pc_function_section = NULL;
151 }
152
153 /* Finds the "function" (text symbol) that is smaller than PC but
154    greatest of all of the potential text symbols in SECTION.  Sets
155    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
156    If ENDADDR is non-null, then set *ENDADDR to be the end of the
157    function (exclusive), but passing ENDADDR as non-null means that
158    the function might cause symbols to be read.  This function either
159    succeeds or fails (not halfway succeeds).  If it succeeds, it sets
160    *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
161    If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
162    returns 0.  */
163
164 /* Backward compatibility, no section argument.  */
165
166 int
167 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
168                           CORE_ADDR *endaddr)
169 {
170   struct bfd_section *section;
171   struct partial_symtab *pst;
172   struct symbol *f;
173   struct minimal_symbol *msymbol;
174   struct partial_symbol *psb;
175   struct obj_section *osect;
176   int i;
177   CORE_ADDR mapped_pc;
178
179   /* To ensure that the symbol returned belongs to the correct setion
180      (and that the last [random] symbol from the previous section
181      isn't returned) try to find the section containing PC.  First try
182      the overlay code (which by default returns NULL); and second try
183      the normal section code (which almost always succeeds).  */
184   section = find_pc_overlay (pc);
185   if (section == NULL)
186     {
187       struct obj_section *obj_section = find_pc_section (pc);
188       if (obj_section == NULL)
189         section = NULL;
190       else
191         section = obj_section->the_bfd_section;
192     }
193
194   mapped_pc = overlay_mapped_address (pc, section);
195
196   if (mapped_pc >= cache_pc_function_low
197       && mapped_pc < cache_pc_function_high
198       && section == cache_pc_function_section)
199     goto return_cached_value;
200
201   msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
202   pst = find_pc_sect_psymtab (mapped_pc, section);
203   if (pst)
204     {
205       /* Need to read the symbols to get a good value for the end address.  */
206       if (endaddr != NULL && !pst->readin)
207         {
208           /* Need to get the terminal in case symbol-reading produces
209              output.  */
210           target_terminal_ours_for_output ();
211           PSYMTAB_TO_SYMTAB (pst);
212         }
213
214       if (pst->readin)
215         {
216           /* Checking whether the msymbol has a larger value is for the
217              "pathological" case mentioned in print_frame_info.  */
218           f = find_pc_sect_function (mapped_pc, section);
219           if (f != NULL
220               && (msymbol == NULL
221                   || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
222                       >= SYMBOL_VALUE_ADDRESS (msymbol))))
223             {
224               cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
225               cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
226               cache_pc_function_name = DEPRECATED_SYMBOL_NAME (f);
227               cache_pc_function_section = section;
228               goto return_cached_value;
229             }
230         }
231       else
232         {
233           /* Now that static symbols go in the minimal symbol table, perhaps
234              we could just ignore the partial symbols.  But at least for now
235              we use the partial or minimal symbol, whichever is larger.  */
236           psb = find_pc_sect_psymbol (pst, mapped_pc, section);
237
238           if (psb
239               && (msymbol == NULL ||
240                   (SYMBOL_VALUE_ADDRESS (psb)
241                    >= SYMBOL_VALUE_ADDRESS (msymbol))))
242             {
243               /* This case isn't being cached currently. */
244               if (address)
245                 *address = SYMBOL_VALUE_ADDRESS (psb);
246               if (name)
247                 *name = DEPRECATED_SYMBOL_NAME (psb);
248               /* endaddr non-NULL can't happen here.  */
249               return 1;
250             }
251         }
252     }
253
254   /* Not in the normal symbol tables, see if the pc is in a known section.
255      If it's not, then give up.  This ensures that anything beyond the end
256      of the text seg doesn't appear to be part of the last function in the
257      text segment.  */
258
259   osect = find_pc_sect_section (mapped_pc, section);
260
261   if (!osect)
262     msymbol = NULL;
263
264   /* Must be in the minimal symbol table.  */
265   if (msymbol == NULL)
266     {
267       /* No available symbol.  */
268       if (name != NULL)
269         *name = 0;
270       if (address != NULL)
271         *address = 0;
272       if (endaddr != NULL)
273         *endaddr = 0;
274       return 0;
275     }
276
277   cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
278   cache_pc_function_name = DEPRECATED_SYMBOL_NAME (msymbol);
279   cache_pc_function_section = section;
280
281   /* If the minimal symbol has a size, use it for the cache.
282      Otherwise use the lesser of the next minimal symbol in the same
283      section, or the end of the section, as the end of the
284      function.  */
285
286   if (MSYMBOL_SIZE (msymbol) != 0)
287     cache_pc_function_high = cache_pc_function_low + MSYMBOL_SIZE (msymbol);
288   else
289     {
290       /* Step over other symbols at this same address, and symbols in
291          other sections, to find the next symbol in this section with
292          a different address.  */
293
294       for (i = 1; DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL; i++)
295         {
296           if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
297               && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
298             break;
299         }
300
301       if (DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL
302           && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
303         cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
304       else
305         /* We got the start address from the last msymbol in the objfile.
306            So the end address is the end of the section.  */
307         cache_pc_function_high = osect->endaddr;
308     }
309
310  return_cached_value:
311
312   if (address)
313     {
314       if (pc_in_unmapped_range (pc, section))
315         *address = overlay_unmapped_address (cache_pc_function_low, section);
316       else
317         *address = cache_pc_function_low;
318     }
319
320   if (name)
321     *name = cache_pc_function_name;
322
323   if (endaddr)
324     {
325       if (pc_in_unmapped_range (pc, section))
326         {
327           /* Because the high address is actually beyond the end of
328              the function (and therefore possibly beyond the end of
329              the overlay), we must actually convert (high - 1) and
330              then add one to that. */
331
332           *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
333                                                    section);
334         }
335       else
336         *endaddr = cache_pc_function_high;
337     }
338
339   return 1;
340 }
341
342 /* Return the innermost stack frame executing inside of BLOCK,
343    or NULL if there is no such frame.  If BLOCK is NULL, just return NULL.  */
344
345 struct frame_info *
346 block_innermost_frame (struct block *block)
347 {
348   struct frame_info *frame;
349   CORE_ADDR start;
350   CORE_ADDR end;
351   CORE_ADDR calling_pc;
352
353   if (block == NULL)
354     return NULL;
355
356   start = BLOCK_START (block);
357   end = BLOCK_END (block);
358
359   frame = get_current_frame ();
360   while (frame != NULL)
361     {
362       calling_pc = get_frame_address_in_block (frame);
363       if (calling_pc >= start && calling_pc < end)
364         return frame;
365
366       frame = get_prev_frame (frame);
367     }
368
369   return NULL;
370 }