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