gdb/blockframe.c

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