gdb/blockframe.c

   1 /* Get info from stack frames; convert between frames, blocks,
   2    functions and pc values.
   3
   4    Copyright (C) 1986-2018 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 /* See symtab.h.  */
 156
 157 struct symbol *
 158 find_pc_sect_containing_function (CORE_ADDR pc, struct obj_section *section)
 159 {
 160   const block *bl = block_for_pc_sect (pc, section);
 161
 162   if (bl == nullptr)
 163     return nullptr;
 164
 165   return block_containing_function (bl);
 166 }
 167
 168 /* These variables are used to cache the most recent result
 169    of find_pc_partial_function.  */
 170
 171 static CORE_ADDR cache_pc_function_low = 0;
 172 static CORE_ADDR cache_pc_function_high = 0;
 173 static const char *cache_pc_function_name = 0;
 174 static struct obj_section *cache_pc_function_section = NULL;
 175
 176 /* Clear cache, e.g. when symbol table is discarded.  */
 177
 178 void
 179 clear_pc_function_cache (void)
 180 {
 181   cache_pc_function_low = 0;
 182   cache_pc_function_high = 0;
 183   cache_pc_function_name = (char *) 0;
 184   cache_pc_function_section = NULL;
 185 }
 186
 187 /* Finds the "function" (text symbol) that is smaller than PC but
 188    greatest of all of the potential text symbols in SECTION.  Sets
 189    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
 190    If ENDADDR is non-null, then set *ENDADDR to be the end of the
 191    function (exclusive), but passing ENDADDR as non-null means that
 192    the function might cause symbols to be read.  This function either
 193    succeeds or fails (not halfway succeeds).  If it succeeds, it sets
 194    *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
 195    If it fails, it sets *NAME, *ADDRESS and *ENDADDR to zero and
 196    returns 0.  */
 197
 198 /* Backward compatibility, no section argument.  */
 199
 200 int
 201 find_pc_partial_function (CORE_ADDR pc, const char **name, CORE_ADDR *address,
 202                           CORE_ADDR *endaddr)
 203 {
 204   struct obj_section *section;
 205   struct symbol *f;
 206   struct bound_minimal_symbol msymbol;
 207   struct compunit_symtab *compunit_symtab = NULL;
 208   struct objfile *objfile;
 209   CORE_ADDR mapped_pc;
 210
 211   /* To ensure that the symbol returned belongs to the correct setion
 212      (and that the last [random] symbol from the previous section
 213      isn't returned) try to find the section containing PC.  First try
 214      the overlay code (which by default returns NULL); and second try
 215      the normal section code (which almost always succeeds).  */
 216   section = find_pc_overlay (pc);
 217   if (section == NULL)
 218     section = find_pc_section (pc);
 219
 220   mapped_pc = overlay_mapped_address (pc, section);
 221
 222   if (mapped_pc >= cache_pc_function_low
 223       && mapped_pc < cache_pc_function_high
 224       && section == cache_pc_function_section)
 225     goto return_cached_value;
 226
 227   msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
 228   ALL_OBJFILES (objfile)
 229   {
 230     if (objfile->sf)
 231       {
 232         compunit_symtab
 233           = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
 234                                                            mapped_pc, section,
 235                                                            0);
 236       }
 237     if (compunit_symtab != NULL)
 238       break;
 239   }
 240
 241   if (compunit_symtab != NULL)
 242     {
 243       /* Checking whether the msymbol has a larger value is for the
 244          "pathological" case mentioned in print_frame_info.  */
 245       f = find_pc_sect_function (mapped_pc, section);
 246       if (f != NULL
 247           && (msymbol.minsym == NULL
 248               || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
 249                   >= BMSYMBOL_VALUE_ADDRESS (msymbol))))
 250         {
 251           cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
 252           cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
 253           cache_pc_function_name = SYMBOL_LINKAGE_NAME (f);
 254           cache_pc_function_section = section;
 255           goto return_cached_value;
 256         }
 257     }
 258
 259   /* Not in the normal symbol tables, see if the pc is in a known
 260      section.  If it's not, then give up.  This ensures that anything
 261      beyond the end of the text seg doesn't appear to be part of the
 262      last function in the text segment.  */
 263
 264   if (!section)
 265     msymbol.minsym = NULL;
 266
 267   /* Must be in the minimal symbol table.  */
 268   if (msymbol.minsym == NULL)
 269     {
 270       /* No available symbol.  */
 271       if (name != NULL)
 272         *name = 0;
 273       if (address != NULL)
 274         *address = 0;
 275       if (endaddr != NULL)
 276         *endaddr = 0;
 277       return 0;
 278     }
 279
 280   cache_pc_function_low = BMSYMBOL_VALUE_ADDRESS (msymbol);
 281   cache_pc_function_name = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
 282   cache_pc_function_section = section;
 283   cache_pc_function_high = minimal_symbol_upper_bound (msymbol);
 284
 285  return_cached_value:
 286
 287   if (address)
 288     {
 289       if (pc_in_unmapped_range (pc, section))
 290         *address = overlay_unmapped_address (cache_pc_function_low, section);
 291       else
 292         *address = cache_pc_function_low;
 293     }
 294
 295   if (name)
 296     *name = cache_pc_function_name;
 297
 298   if (endaddr)
 299     {
 300       if (pc_in_unmapped_range (pc, section))
 301         {
 302           /* Because the high address is actually beyond the end of
 303              the function (and therefore possibly beyond the end of
 304              the overlay), we must actually convert (high - 1) and
 305              then add one to that.  */
 306
 307           *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
 308                                                    section);
 309         }
 310       else
 311         *endaddr = cache_pc_function_high;
 312     }
 313
 314   return 1;
 315 }
 316
 317 /* See symtab.h.  */
 318
 319 struct type *
 320 find_function_type (CORE_ADDR pc)
 321 {
 322   struct symbol *sym = find_pc_function (pc);
 323
 324   if (sym != NULL && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == pc)
 325     return SYMBOL_TYPE (sym);
 326
 327   return NULL;
 328 }
 329
 330 /* See symtab.h.  */
 331
 332 struct type *
 333 find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr)
 334 {
 335   struct type *resolver_type = find_function_type (resolver_funaddr);
 336   if (resolver_type != NULL)
 337     {
 338       /* Get the return type of the resolver.  */
 339       struct type *resolver_ret_type
 340         = check_typedef (TYPE_TARGET_TYPE (resolver_type));
 341
 342       /* If we found a pointer to function, then the resolved type
 343          is the type of the pointed-to function.  */
 344       if (TYPE_CODE (resolver_ret_type) == TYPE_CODE_PTR)
 345         {
 346           struct type *resolved_type
 347             = TYPE_TARGET_TYPE (resolver_ret_type);
 348           if (TYPE_CODE (check_typedef (resolved_type)) == TYPE_CODE_FUNC)
 349             return resolved_type;
 350         }
 351     }
 352
 353   return NULL;
 354 }
 355
 356 /* Return the innermost stack frame that is executing inside of BLOCK and is
 357    at least as old as the selected frame. Return NULL if there is no
 358    such frame.  If BLOCK is NULL, just return NULL.  */
 359
 360 struct frame_info *
 361 block_innermost_frame (const struct block *block)
 362 {
 363   struct frame_info *frame;
 364
 365   if (block == NULL)
 366     return NULL;
 367
 368   frame = get_selected_frame_if_set ();
 369   if (frame == NULL)
 370     frame = get_current_frame ();
 371   while (frame != NULL)
 372     {
 373       const struct block *frame_block = get_frame_block (frame, NULL);
 374       if (frame_block != NULL && contained_in (frame_block, block))
 375         return frame;
 376
 377       frame = get_prev_frame (frame);
 378     }
 379
 380   return NULL;
 381 }