gdb/blockframe.c

   1 /* Get info from stack frames; convert between frames, blocks,
   2    functions and pc values.
   3
   4    Copyright (C) 1986-2014 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "symtab.h"
  23 #include "bfd.h"
  24 #include "objfiles.h"
  25 #include "frame.h"
  26 #include "gdbcore.h"
  27 #include "value.h"
  28 #include "target.h"
  29 #include "inferior.h"
  30 #include "annotate.h"
  31 #include "regcache.h"
  32 #include "dummy-frame.h"
  33 #include "command.h"
  34 #include "gdbcmd.h"
  35 #include "block.h"
  36 #include "inline-frame.h"
  37
  38 /* Return the innermost lexical block in execution in a specified
  39    stack frame.  The frame address is assumed valid.
  40
  41    If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
  42    address we used to choose the block.  We use this to find a source
  43    line, to decide which macro definitions are in scope.
  44
  45    The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
  46    PC, and may not really be a valid PC at all.  For example, in the
  47    caller of a function declared to never return, the code at the
  48    return address will never be reached, so the call instruction may
  49    be the very last instruction in the block.  So the address we use
  50    to choose the block is actually one byte before the return address
  51    --- hopefully pointing us at the call instruction, or its delay
  52    slot instruction.  */
  53
  54 const struct block *
  55 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
  56 {
  57   CORE_ADDR pc;
  58   const struct block *bl;
  59   int inline_count;
  60
  61   if (!get_frame_address_in_block_if_available (frame, &pc))
  62     return NULL;
  63
  64   if (addr_in_block)
  65     *addr_in_block = pc;
  66
  67   bl = block_for_pc (pc);
  68   if (bl == NULL)
  69     return NULL;
  70
  71   inline_count = frame_inlined_callees (frame);
  72
  73   while (inline_count > 0)
  74     {
  75       if (block_inlined_p (bl))
  76         inline_count--;
  77
  78       bl = BLOCK_SUPERBLOCK (bl);
  79       gdb_assert (bl != NULL);
  80     }
  81
  82   return bl;
  83 }
  84
  85 CORE_ADDR
  86 get_pc_function_start (CORE_ADDR pc)
  87 {
  88   const struct block *bl;
  89   struct bound_minimal_symbol msymbol;
  90
  91   bl = block_for_pc (pc);
  92   if (bl)
  93     {
  94       struct symbol *symbol = block_linkage_function (bl);
  95
  96       if (symbol)
  97         {
  98           bl = SYMBOL_BLOCK_VALUE (symbol);
  99           return BLOCK_START (bl);
 100         }
 101     }
 102
 103   msymbol = lookup_minimal_symbol_by_pc (pc);
 104   if (msymbol.minsym)
 105     {
 106       CORE_ADDR fstart = BMSYMBOL_VALUE_ADDRESS (msymbol);
 107
 108       if (find_pc_section (fstart))
 109         return fstart;
 110     }
 111
 112   return 0;
 113 }
 114
 115 /* Return the symbol for the function executing in frame FRAME.  */
 116
 117 struct symbol *
 118 get_frame_function (struct frame_info *frame)
 119 {
 120   const struct block *bl = get_frame_block (frame, 0);
 121
 122   if (bl == NULL)
 123     return NULL;
 124
 125   while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL)
 126     bl = BLOCK_SUPERBLOCK (bl);
 127
 128   return BLOCK_FUNCTION (bl);
 129 }
 130 \f
 131
 132 /* Return the function containing pc value PC in section SECTION.
 133    Returns 0 if function is not known.  */
 134
 135 struct symbol *
 136 find_pc_sect_function (CORE_ADDR pc, struct obj_section *section)
 137 {
 138   const struct block *b = block_for_pc_sect (pc, section);
 139
 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.
 147    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 const char *cache_pc_function_name = 0;
 161 static struct obj_section *cache_pc_function_section = NULL;
 162 static int cache_pc_function_is_gnu_ifunc = 0;
 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   cache_pc_function_is_gnu_ifunc = 0;
 174 }
 175
 176 /* Finds the "function" (text symbol) that is smaller than PC but
 177    greatest of all of the potential text symbols in SECTION.  Sets
 178    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
 179    If ENDADDR is non-null, then set *ENDADDR to be the end of the
 180    function (exclusive), but passing ENDADDR as non-null means that
 181    the function might cause symbols to be read.  If IS_GNU_IFUNC_P is provided
 182    *IS_GNU_IFUNC_P is set to 1 on return if the function is STT_GNU_IFUNC.
 183    This function either succeeds or fails (not halfway succeeds).  If it
 184    succeeds, it sets *NAME, *ADDRESS, and *ENDADDR to real information and
 185    returns 1.  If it fails, it sets *NAME, *ADDRESS, *ENDADDR and
 186    *IS_GNU_IFUNC_P to zero and returns 0.  */
 187
 188 /* Backward compatibility, no section argument.  */
 189
 190 int
 191 find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name,
 192                                     CORE_ADDR *address, CORE_ADDR *endaddr,
 193                                     int *is_gnu_ifunc_p)
 194 {
 195   struct obj_section *section;
 196   struct symbol *f;
 197   struct bound_minimal_symbol msymbol;
 198   struct compunit_symtab *compunit_symtab = NULL;
 199   struct objfile *objfile;
 200   int i;
 201   CORE_ADDR mapped_pc;
 202
 203   /* To ensure that the symbol returned belongs to the correct setion
 204      (and that the last [random] symbol from the previous section
 205      isn't returned) try to find the section containing PC.  First try
 206      the overlay code (which by default returns NULL); and second try
 207      the normal section code (which almost always succeeds).  */
 208   section = find_pc_overlay (pc);
 209   if (section == NULL)
 210     section = find_pc_section (pc);
 211
 212   mapped_pc = overlay_mapped_address (pc, section);
 213
 214   if (mapped_pc >= cache_pc_function_low
 215       && mapped_pc < cache_pc_function_high
 216       && section == cache_pc_function_section)
 217     goto return_cached_value;
 218
 219   msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
 220   ALL_OBJFILES (objfile)
 221   {
 222     if (objfile->sf)
 223       {
 224         compunit_symtab
 225           = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
 226                                                            mapped_pc, section,
 227                                                            0);
 228       }
 229     if (compunit_symtab != NULL)
 230       break;
 231   }
 232
 233   if (compunit_symtab != NULL)
 234     {
 235       /* Checking whether the msymbol has a larger value is for the
 236          "pathological" case mentioned in print_frame_info.  */
 237       f = find_pc_sect_function (mapped_pc, section);
 238       if (f != NULL
 239           && (msymbol.minsym == NULL
 240               || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
 241                   >= BMSYMBOL_VALUE_ADDRESS (msymbol))))
 242         {
 243           cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
 244           cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
 245           cache_pc_function_name = SYMBOL_LINKAGE_NAME (f);
 246           cache_pc_function_section = section;
 247           cache_pc_function_is_gnu_ifunc = TYPE_GNU_IFUNC (SYMBOL_TYPE (f));
 248           goto return_cached_value;
 249         }
 250     }
 251
 252   /* Not in the normal symbol tables, see if the pc is in a known
 253      section.  If it's not, then give up.  This ensures that anything
 254      beyond the end of the text seg doesn't appear to be part of the
 255      last function in the text segment.  */
 256
 257   if (!section)
 258     msymbol.minsym = NULL;
 259
 260   /* Must be in the minimal symbol table.  */
 261   if (msymbol.minsym == NULL)
 262     {
 263       /* No available symbol.  */
 264       if (name != NULL)
 265         *name = 0;
 266       if (address != NULL)
 267         *address = 0;
 268       if (endaddr != NULL)
 269         *endaddr = 0;
 270       if (is_gnu_ifunc_p != NULL)
 271         *is_gnu_ifunc_p = 0;
 272       return 0;
 273     }
 274
 275   cache_pc_function_low = BMSYMBOL_VALUE_ADDRESS (msymbol);
 276   cache_pc_function_name = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
 277   cache_pc_function_section = section;
 278   cache_pc_function_is_gnu_ifunc = (MSYMBOL_TYPE (msymbol.minsym)
 279                                     == mst_text_gnu_ifunc);
 280   cache_pc_function_high = minimal_symbol_upper_bound (msymbol);
 281
 282  return_cached_value:
 283
 284   if (address)
 285     {
 286       if (pc_in_unmapped_range (pc, section))
 287         *address = overlay_unmapped_address (cache_pc_function_low, section);
 288       else
 289         *address = cache_pc_function_low;
 290     }
 291
 292   if (name)
 293     *name = cache_pc_function_name;
 294
 295   if (endaddr)
 296     {
 297       if (pc_in_unmapped_range (pc, section))
 298         {
 299           /* Because the high address is actually beyond the end of
 300              the function (and therefore possibly beyond the end of
 301              the overlay), we must actually convert (high - 1) and
 302              then add one to that.  */
 303
 304           *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
 305                                                    section);
 306         }
 307       else
 308         *endaddr = cache_pc_function_high;
 309     }
 310
 311   if (is_gnu_ifunc_p)
 312     *is_gnu_ifunc_p = cache_pc_function_is_gnu_ifunc;
 313
 314   return 1;
 315 }
 316
 317 /* See find_pc_partial_function_gnu_ifunc, only the IS_GNU_IFUNC_P parameter
 318    is omitted here for backward API compatibility.  */
 319
 320 int
 321 find_pc_partial_function (CORE_ADDR pc, const char **name, CORE_ADDR *address,
 322                           CORE_ADDR *endaddr)
 323 {
 324   return find_pc_partial_function_gnu_ifunc (pc, name, address, endaddr, NULL);
 325 }
 326
 327 /* Return the innermost stack frame that is executing inside of BLOCK and is
 328    at least as old as the selected frame. Return NULL if there is no
 329    such frame.  If BLOCK is NULL, just return NULL.  */
 330
 331 struct frame_info *
 332 block_innermost_frame (const struct block *block)
 333 {
 334   struct frame_info *frame;
 335
 336   if (block == NULL)
 337     return NULL;
 338
 339   frame = get_selected_frame_if_set ();
 340   if (frame == NULL)
 341     frame = get_current_frame ();
 342   while (frame != NULL)
 343     {
 344       const struct block *frame_block = get_frame_block (frame, NULL);
 345       if (frame_block != NULL && contained_in (frame_block, block))
 346         return frame;
 347
 348       frame = get_prev_frame (frame);
 349     }
 350
 351   return NULL;
 352 }