GDB (xrefs)
/tmp/gdb-7.10/gdb/blockframe.c
Go to the documentation of this file.
1 /* Get info from stack frames; convert between frames, blocks,
2  functions and pc values.
3 
4  Copyright (C) 1986-2015 Free Software Foundation, Inc.
5 
6  This file is part of GDB.
7 
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 3 of the License, or
11  (at your option) any later version.
12 
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.
17 
18  You should have received a copy of the GNU General Public License
19  along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 
21 #include "defs.h"
22 #include "symtab.h"
23 #include "bfd.h"
24 #include "objfiles.h"
25 #include "frame.h"
26 #include "gdbcore.h"
27 #include "value.h"
28 #include "target.h"
29 #include "inferior.h"
30 #include "annotate.h"
31 #include "regcache.h"
32 #include "dummy-frame.h"
33 #include "command.h"
34 #include "gdbcmd.h"
35 #include "block.h"
36 #include "inline-frame.h"
37 
38 /* Return the innermost lexical block in execution in a specified
39  stack frame. The frame address is assumed valid.
40 
41  If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
42  address we used to choose the block. We use this to find a source
43  line, to decide which macro definitions are in scope.
44 
45  The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
46  PC, and may not really be a valid PC at all. For example, in the
47  caller of a function declared to never return, the code at the
48  return address will never be reached, so the call instruction may
49  be the very last instruction in the block. So the address we use
50  to choose the block is actually one byte before the return address
51  --- hopefully pointing us at the call instruction, or its delay
52  slot instruction. */
53 
54 const struct block *
55 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
56 {
57  CORE_ADDR pc;
58  const struct block *bl;
59  int inline_count;
60 
62  return NULL;
63 
64  if (addr_in_block)
65  *addr_in_block = pc;
66 
67  bl = block_for_pc (pc);
68  if (bl == NULL)
69  return NULL;
70 
71  inline_count = frame_inlined_callees (frame);
72 
73  while (inline_count > 0)
74  {
75  if (block_inlined_p (bl))
76  inline_count--;
77 
78  bl = BLOCK_SUPERBLOCK (bl);
79  gdb_assert (bl != NULL);
80  }
81 
82  return bl;
83 }
84 
87 {
88  const struct block *bl;
89  struct bound_minimal_symbol msymbol;
90 
91  bl = block_for_pc (pc);
92  if (bl)
93  {
94  struct symbol *symbol = block_linkage_function (bl);
95 
96  if (symbol)
97  {
98  bl = SYMBOL_BLOCK_VALUE (symbol);
99  return BLOCK_START (bl);
100  }
101  }
102 
103  msymbol = lookup_minimal_symbol_by_pc (pc);
104  if (msymbol.minsym)
105  {
106  CORE_ADDR fstart = BMSYMBOL_VALUE_ADDRESS (msymbol);
107 
108  if (find_pc_section (fstart))
109  return fstart;
110  }
111 
112  return 0;
113 }
114 
115 /* Return the symbol for the function executing in frame FRAME. */
116 
117 struct symbol *
119 {
120  const struct block *bl = get_frame_block (frame, 0);
121 
122  if (bl == NULL)
123  return NULL;
124 
125  while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL)
126  bl = BLOCK_SUPERBLOCK (bl);
127 
128  return BLOCK_FUNCTION (bl);
129 }
130 
131 
132 /* Return the function containing pc value PC in section SECTION.
133  Returns 0 if function is not known. */
134 
135 struct symbol *
137 {
138  const struct block *b = block_for_pc_sect (pc, section);
139 
140  if (b == 0)
141  return 0;
142  return block_linkage_function (b);
143 }
144 
145 /* Return the function containing pc value PC.
146  Returns 0 if function is not known.
147  Backward compatibility, no section */
148 
149 struct symbol *
151 {
153 }
154 
155 /* These variables are used to cache the most recent result
156  of find_pc_partial_function. */
157 
160 static const char *cache_pc_function_name = 0;
161 static struct obj_section *cache_pc_function_section = NULL;
163 
164 /* Clear cache, e.g. when symbol table is discarded. */
165 
166 void
168 {
171  cache_pc_function_name = (char *) 0;
172  cache_pc_function_section = NULL;
174 }
175 
176 /* Finds the "function" (text symbol) that is smaller than PC but
177  greatest of all of the potential text symbols in SECTION. Sets
178  *NAME and/or *ADDRESS conditionally if that pointer is non-null.
179  If ENDADDR is non-null, then set *ENDADDR to be the end of the
180  function (exclusive), but passing ENDADDR as non-null means that
181  the function might cause symbols to be read. If IS_GNU_IFUNC_P is provided
182  *IS_GNU_IFUNC_P is set to 1 on return if the function is STT_GNU_IFUNC.
183  This function either succeeds or fails (not halfway succeeds). If it
184  succeeds, it sets *NAME, *ADDRESS, and *ENDADDR to real information and
185  returns 1. If it fails, it sets *NAME, *ADDRESS, *ENDADDR and
186  *IS_GNU_IFUNC_P to zero and returns 0. */
187 
188 /* Backward compatibility, no section argument. */
189 
190 int
192  CORE_ADDR *address, CORE_ADDR *endaddr,
193  int *is_gnu_ifunc_p)
194 {
195  struct obj_section *section;
196  struct symbol *f;
197  struct bound_minimal_symbol msymbol;
198  struct compunit_symtab *compunit_symtab = NULL;
199  struct objfile *objfile;
200  int i;
201  CORE_ADDR mapped_pc;
202 
203  /* To ensure that the symbol returned belongs to the correct setion
204  (and that the last [random] symbol from the previous section
205  isn't returned) try to find the section containing PC. First try
206  the overlay code (which by default returns NULL); and second try
207  the normal section code (which almost always succeeds). */
208  section = find_pc_overlay (pc);
209  if (section == NULL)
210  section = find_pc_section (pc);
211 
212  mapped_pc = overlay_mapped_address (pc, section);
213 
214  if (mapped_pc >= cache_pc_function_low
215  && mapped_pc < cache_pc_function_high
216  && section == cache_pc_function_section)
217  goto return_cached_value;
218 
219  msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
220  ALL_OBJFILES (objfile)
221  {
222  if (objfile->sf)
223  {
224  compunit_symtab
225  = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
226  mapped_pc, section,
227  0);
228  }
229  if (compunit_symtab != NULL)
230  break;
231  }
232 
233  if (compunit_symtab != NULL)
234  {
235  /* Checking whether the msymbol has a larger value is for the
236  "pathological" case mentioned in print_frame_info. */
237  f = find_pc_sect_function (mapped_pc, section);
238  if (f != NULL
239  && (msymbol.minsym == NULL
241  >= BMSYMBOL_VALUE_ADDRESS (msymbol))))
242  {
246  cache_pc_function_section = section;
248  goto return_cached_value;
249  }
250  }
251 
252  /* Not in the normal symbol tables, see if the pc is in a known
253  section. If it's not, then give up. This ensures that anything
254  beyond the end of the text seg doesn't appear to be part of the
255  last function in the text segment. */
256 
257  if (!section)
258  msymbol.minsym = NULL;
259 
260  /* Must be in the minimal symbol table. */
261  if (msymbol.minsym == NULL)
262  {
263  /* No available symbol. */
264  if (name != NULL)
265  *name = 0;
266  if (address != NULL)
267  *address = 0;
268  if (endaddr != NULL)
269  *endaddr = 0;
270  if (is_gnu_ifunc_p != NULL)
271  *is_gnu_ifunc_p = 0;
272  return 0;
273  }
274 
277  cache_pc_function_section = section;
279  == mst_text_gnu_ifunc);
281 
282  return_cached_value:
283 
284  if (address)
285  {
286  if (pc_in_unmapped_range (pc, section))
287  *address = overlay_unmapped_address (cache_pc_function_low, section);
288  else
289  *address = cache_pc_function_low;
290  }
291 
292  if (name)
293  *name = cache_pc_function_name;
294 
295  if (endaddr)
296  {
297  if (pc_in_unmapped_range (pc, section))
298  {
299  /* Because the high address is actually beyond the end of
300  the function (and therefore possibly beyond the end of
301  the overlay), we must actually convert (high - 1) and
302  then add one to that. */
303 
305  section);
306  }
307  else
308  *endaddr = cache_pc_function_high;
309  }
310 
311  if (is_gnu_ifunc_p)
312  *is_gnu_ifunc_p = cache_pc_function_is_gnu_ifunc;
313 
314  return 1;
315 }
316 
317 /* See find_pc_partial_function_gnu_ifunc, only the IS_GNU_IFUNC_P parameter
318  is omitted here for backward API compatibility. */
319 
320 int
321 find_pc_partial_function (CORE_ADDR pc, const char **name, CORE_ADDR *address,
322  CORE_ADDR *endaddr)
323 {
324  return find_pc_partial_function_gnu_ifunc (pc, name, address, endaddr, NULL);
325 }
326 
327 /* Return the innermost stack frame that is executing inside of BLOCK and is
328  at least as old as the selected frame. Return NULL if there is no
329  such frame. If BLOCK is NULL, just return NULL. */
330 
331 struct frame_info *
333 {
334  struct frame_info *frame;
335 
336  if (block == NULL)
337  return NULL;
338 
339  frame = get_selected_frame_if_set ();
340  if (frame == NULL)
341  frame = get_current_frame ();
342  while (frame != NULL)
343  {
344  const struct block *frame_block = get_frame_block (frame, NULL);
345  if (frame_block != NULL && contained_in (frame_block, block))
346  return frame;
347 
348  frame = get_prev_frame (frame);
349  }
350 
351  return NULL;
352 }
int get_frame_address_in_block_if_available(struct frame_info *this_frame, CORE_ADDR *pc)
Definition: frame.c:2308
struct bound_minimal_symbol lookup_minimal_symbol_by_pc_section(CORE_ADDR pc, struct obj_section *section)
Definition: minsyms.c:779
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:409
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
bfd_vma CORE_ADDR
Definition: common-types.h:41
static int cache_pc_function_is_gnu_ifunc
Definition: blockframe.c:162
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2122
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
struct symbol * find_pc_sect_function(CORE_ADDR pc, struct obj_section *section)
Definition: blockframe.c:136
CORE_ADDR minimal_symbol_upper_bound(struct bound_minimal_symbol minsym)
Definition: minsyms.c:1434
struct compunit_symtab *(* find_pc_sect_compunit_symtab)(struct objfile *objfile, struct bound_minimal_symbol msymbol, CORE_ADDR pc, struct obj_section *section, int warn_if_readin)
Definition: symfile.h:304
struct symbol * block_linkage_function(const struct block *bl)
Definition: block.c:100
#define BLOCK_START(bl)
Definition: block.h:116
const struct block * block_for_pc(CORE_ADDR pc)
Definition: block.c:282
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3287
#define BLOCK_FUNCTION(bl)
Definition: block.h:118
static const char * cache_pc_function_name
Definition: blockframe.c:160
const char *const name
Definition: aarch64-tdep.c:68
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
#define TYPE_GNU_IFUNC(t)
Definition: gdbtypes.h:318
struct frame_info * block_innermost_frame(const struct block *block)
Definition: blockframe.c:332
int contained_in(const struct block *a, const struct block *b)
Definition: block.c:73
static CORE_ADDR cache_pc_function_low
Definition: blockframe.c:158
struct symbol * find_pc_function(CORE_ADDR pc)
Definition: blockframe.c:150
const struct block * get_frame_block(struct frame_info *frame, CORE_ADDR *addr_in_block)
Definition: blockframe.c:55
const struct sym_fns * sf
Definition: objfiles.h:347
struct symbol * get_frame_function(struct frame_info *frame)
Definition: blockframe.c:118
struct frame_info * get_selected_frame_if_set(void)
Definition: frame.c:1554
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:321
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:119
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
#define BLOCK_END(bl)
Definition: block.h:117
int find_pc_partial_function_gnu_ifunc(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, int *is_gnu_ifunc_p)
Definition: blockframe.c:191
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1337
static CORE_ADDR cache_pc_function_high
Definition: blockframe.c:159
const struct block * block_for_pc_sect(CORE_ADDR pc, struct obj_section *section)
Definition: block.c:267
Definition: block.h:60
void clear_pc_function_cache(void)
Definition: blockframe.c:167
int frame_inlined_callees(struct frame_info *this_frame)
Definition: inline-frame.c:396
int block_inlined_p(const struct block *bl)
Definition: block.c:126
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:382
struct obj_section * find_pc_mapped_section(CORE_ADDR pc)
Definition: symfile.c:3314
CORE_ADDR overlay_unmapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3219
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition: minsyms.c:801
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:185
struct minimal_symbol * minsym
Definition: minsyms.h:32
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
CORE_ADDR overlay_mapped_address(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3238
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
Definition: blockframe.c:86
const struct quick_symbol_functions * qf
Definition: symfile.h:398
CORE_ADDR pc_in_unmapped_range(CORE_ADDR pc, struct obj_section *section)
Definition: symfile.c:3165