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