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