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, 2008, 2009
   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 #include "inline-frame.h"
  40
  41 /* Prototypes for exported functions. */
  42
  43 void _initialize_blockframe (void);
  44
  45 /* Return the innermost lexical block in execution
  46    in a specified stack frame.  The frame address is assumed valid.
  47
  48    If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
  49    address we used to choose the block.  We use this to find a source
  50    line, to decide which macro definitions are in scope.
  51
  52    The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
  53    PC, and may not really be a valid PC at all.  For example, in the
  54    caller of a function declared to never return, the code at the
  55    return address will never be reached, so the call instruction may
  56    be the very last instruction in the block.  So the address we use
  57    to choose the block is actually one byte before the return address
  58    --- hopefully pointing us at the call instruction, or its delay
  59    slot instruction.  */
  60
  61 struct block *
  62 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
  63 {
  64   const CORE_ADDR pc = get_frame_address_in_block (frame);
  65   struct frame_info *next_frame;
  66   struct block *bl;
  67   int inline_count;
  68
  69   if (addr_in_block)
  70     *addr_in_block = pc;
  71
  72   bl = block_for_pc (pc);
  73   if (bl == NULL)
  74     return NULL;
  75
  76   inline_count = frame_inlined_callees (frame);
  77
  78   while (inline_count > 0)
  79     {
  80       if (block_inlined_p (bl))
  81         inline_count--;
  82
  83       bl = BLOCK_SUPERBLOCK (bl);
  84       gdb_assert (bl != NULL);
  85     }
  86
  87   return bl;
  88 }
  89
  90 CORE_ADDR
  91 get_pc_function_start (CORE_ADDR pc)
  92 {
  93   struct block *bl;
  94   struct minimal_symbol *msymbol;
  95
  96   bl = block_for_pc (pc);
  97   if (bl)
  98     {
  99       struct symbol *symbol = block_linkage_function (bl);
 100
 101       if (symbol)
 102         {
 103           bl = SYMBOL_BLOCK_VALUE (symbol);
 104           return BLOCK_START (bl);
 105         }
 106     }
 107
 108   msymbol = lookup_minimal_symbol_by_pc (pc);
 109   if (msymbol)
 110     {
 111       CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
 112
 113       if (find_pc_section (fstart))
 114         return fstart;
 115     }
 116
 117   return 0;
 118 }
 119
 120 /* Return the symbol for the function executing in frame FRAME.  */
 121
 122 struct symbol *
 123 get_frame_function (struct frame_info *frame)
 124 {
 125   struct block *bl = get_frame_block (frame, 0);
 126
 127   if (bl == NULL)
 128     return NULL;
 129
 130   while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL)
 131     bl = BLOCK_SUPERBLOCK (bl);
 132
 133   return BLOCK_FUNCTION (bl);
 134 }
 135 \f
 136
 137 /* Return the function containing pc value PC in section SECTION.
 138    Returns 0 if function is not known.  */
 139
 140 struct symbol *
 141 find_pc_sect_function (CORE_ADDR pc, struct obj_section *section)
 142 {
 143   struct block *b = block_for_pc_sect (pc, section);
 144   if (b == 0)
 145     return 0;
 146   return block_linkage_function (b);
 147 }
 148
 149 /* Return the function containing pc value PC.
 150    Returns 0 if function is not known.  Backward compatibility, no section */
 151
 152 struct symbol *
 153 find_pc_function (CORE_ADDR pc)
 154 {
 155   return find_pc_sect_function (pc, find_pc_mapped_section (pc));
 156 }
 157
 158 /* These variables are used to cache the most recent result
 159  * of find_pc_partial_function. */
 160
 161 static CORE_ADDR cache_pc_function_low = 0;
 162 static CORE_ADDR cache_pc_function_high = 0;
 163 static char *cache_pc_function_name = 0;
 164 static struct obj_section *cache_pc_function_section = NULL;
 165
 166 /* Clear cache, e.g. when symbol table is discarded. */
 167
 168 void
 169 clear_pc_function_cache (void)
 170 {
 171   cache_pc_function_low = 0;
 172   cache_pc_function_high = 0;
 173   cache_pc_function_name = (char *) 0;
 174   cache_pc_function_section = NULL;
 175 }
 176
 177 /* Finds the "function" (text symbol) that is smaller than PC but
 178    greatest of all of the potential text symbols in SECTION.  Sets
 179    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
 180    If ENDADDR is non-null, then set *ENDADDR to be the end of the
 181    function (exclusive), but passing ENDADDR as non-null means that
 182    the function might cause symbols to be read.  This function either
 183    succeeds or fails (not halfway succeeds).  If it succeeds, it sets
 184    *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
 185    If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
 186    returns 0.  */
 187
 188 /* Backward compatibility, no section argument.  */
 189
 190 int
 191 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
 192                           CORE_ADDR *endaddr)
 193 {
 194   struct obj_section *section;
 195   struct partial_symtab *pst;
 196   struct symbol *f;
 197   struct minimal_symbol *msymbol;
 198   struct partial_symbol *psb;
 199   int i;
 200   CORE_ADDR mapped_pc;
 201
 202   /* To ensure that the symbol returned belongs to the correct setion
 203      (and that the last [random] symbol from the previous section
 204      isn't returned) try to find the section containing PC.  First try
 205      the overlay code (which by default returns NULL); and second try
 206      the normal section code (which almost always succeeds).  */
 207   section = find_pc_overlay (pc);
 208   if (section == NULL)
 209     section = find_pc_section (pc);
 210
 211   mapped_pc = overlay_mapped_address (pc, section);
 212
 213   if (mapped_pc >= cache_pc_function_low
 214       && mapped_pc < cache_pc_function_high
 215       && section == cache_pc_function_section)
 216     goto return_cached_value;
 217
 218   msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
 219   pst = find_pc_sect_psymtab (mapped_pc, section);
 220   if (pst)
 221     {
 222       /* Need to read the symbols to get a good value for the end address.  */
 223       if (endaddr != NULL && !pst->readin)
 224         {
 225           /* Need to get the terminal in case symbol-reading produces
 226              output.  */
 227           target_terminal_ours_for_output ();
 228           PSYMTAB_TO_SYMTAB (pst);
 229         }
 230
 231       if (pst->readin)
 232         {
 233           /* Checking whether the msymbol has a larger value is for the
 234              "pathological" case mentioned in print_frame_info.  */
 235           f = find_pc_sect_function (mapped_pc, section);
 236           if (f != NULL
 237               && (msymbol == NULL
 238                   || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
 239                       >= SYMBOL_VALUE_ADDRESS (msymbol))))
 240             {
 241               cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
 242               cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
 243               cache_pc_function_name = SYMBOL_LINKAGE_NAME (f);
 244               cache_pc_function_section = section;
 245               goto return_cached_value;
 246             }
 247         }
 248       else
 249         {
 250           /* Now that static symbols go in the minimal symbol table, perhaps
 251              we could just ignore the partial symbols.  But at least for now
 252              we use the partial or minimal symbol, whichever is larger.  */
 253           psb = find_pc_sect_psymbol (pst, mapped_pc, section);
 254
 255           if (psb
 256               && (msymbol == NULL ||
 257                   (SYMBOL_VALUE_ADDRESS (psb)
 258                    >= SYMBOL_VALUE_ADDRESS (msymbol))))
 259             {
 260               /* This case isn't being cached currently. */
 261               if (address)
 262                 *address = SYMBOL_VALUE_ADDRESS (psb);
 263               if (name)
 264                 *name = SYMBOL_LINKAGE_NAME (psb);
 265               /* endaddr non-NULL can't happen here.  */
 266               return 1;
 267             }
 268         }
 269     }
 270
 271   /* Not in the normal symbol tables, see if the pc is in a known section.
 272      If it's not, then give up.  This ensures that anything beyond the end
 273      of the text seg doesn't appear to be part of the last function in the
 274      text segment.  */
 275
 276   if (!section)
 277     msymbol = NULL;
 278
 279   /* Must be in the minimal symbol table.  */
 280   if (msymbol == NULL)
 281     {
 282       /* No available symbol.  */
 283       if (name != NULL)
 284         *name = 0;
 285       if (address != NULL)
 286         *address = 0;
 287       if (endaddr != NULL)
 288         *endaddr = 0;
 289       return 0;
 290     }
 291
 292   cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
 293   cache_pc_function_name = SYMBOL_LINKAGE_NAME (msymbol);
 294   cache_pc_function_section = section;
 295
 296   /* If the minimal symbol has a size, use it for the cache.
 297      Otherwise use the lesser of the next minimal symbol in the same
 298      section, or the end of the section, as the end of the
 299      function.  */
 300
 301   if (MSYMBOL_SIZE (msymbol) != 0)
 302     cache_pc_function_high = cache_pc_function_low + MSYMBOL_SIZE (msymbol);
 303   else
 304     {
 305       /* Step over other symbols at this same address, and symbols in
 306          other sections, to find the next symbol in this section with
 307          a different address.  */
 308
 309       for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
 310         {
 311           if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
 312               && SYMBOL_OBJ_SECTION (msymbol + i) == SYMBOL_OBJ_SECTION (msymbol))
 313             break;
 314         }
 315
 316       if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
 317           && SYMBOL_VALUE_ADDRESS (msymbol + i) < obj_section_endaddr (section))
 318         cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
 319       else
 320         /* We got the start address from the last msymbol in the objfile.
 321            So the end address is the end of the section.  */
 322         cache_pc_function_high = obj_section_endaddr (section);
 323     }
 324
 325  return_cached_value:
 326
 327   if (address)
 328     {
 329       if (pc_in_unmapped_range (pc, section))
 330         *address = overlay_unmapped_address (cache_pc_function_low, section);
 331       else
 332         *address = cache_pc_function_low;
 333     }
 334
 335   if (name)
 336     *name = cache_pc_function_name;
 337
 338   if (endaddr)
 339     {
 340       if (pc_in_unmapped_range (pc, section))
 341         {
 342           /* Because the high address is actually beyond the end of
 343              the function (and therefore possibly beyond the end of
 344              the overlay), we must actually convert (high - 1) and
 345              then add one to that. */
 346
 347           *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
 348                                                    section);
 349         }
 350       else
 351         *endaddr = cache_pc_function_high;
 352     }
 353
 354   return 1;
 355 }
 356
 357 /* Return the innermost stack frame executing inside of BLOCK,
 358    or NULL if there is no such frame.  If BLOCK is NULL, just return NULL.  */
 359
 360 struct frame_info *
 361 block_innermost_frame (struct block *block)
 362 {
 363   struct frame_info *frame;
 364   CORE_ADDR start;
 365   CORE_ADDR end;
 366
 367   if (block == NULL)
 368     return NULL;
 369
 370   start = BLOCK_START (block);
 371   end = BLOCK_END (block);
 372
 373   frame = get_current_frame ();
 374   while (frame != NULL)
 375     {
 376       struct block *frame_block = get_frame_block (frame, NULL);
 377       if (frame_block != NULL && contained_in (frame_block, block))
 378         return frame;
 379
 380       frame = get_prev_frame (frame);
 381     }
 382
 383   return NULL;
 384 }