gdb/blockframe.c

   1 /* Get info from stack frames; convert between frames, blocks,
   2    functions and pc values.
   3
   4    Copyright (C) 1986-2019 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_ENTRY_PC (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 of
 169    find_pc_partial_function.
 170
 171    The addresses cache_pc_function_low and cache_pc_function_high
 172    record the range in which PC was found during the most recent
 173    successful lookup.  When the function occupies a single contiguous
 174    address range, these values correspond to the low and high
 175    addresses of the function.  (The high address is actually one byte
 176    beyond the last byte of the function.)  For a function with more
 177    than one (non-contiguous) range, the range in which PC was found is
 178    used to set the cache bounds.
 179
 180    When determining whether or not these cached values apply to a
 181    particular PC value, PC must be within the range specified by
 182    cache_pc_function_low and cache_pc_function_high.  In addition to
 183    PC being in that range, cache_pc_section must also match PC's
 184    section.  See find_pc_partial_function() for details on both the
 185    comparison as well as how PC's section is determined.
 186
 187    The other values aren't used for determining whether the cache
 188    applies, but are used for setting the outputs from
 189    find_pc_partial_function.  cache_pc_function_low and
 190    cache_pc_function_high are used to set outputs as well.  */
 191
 192 static CORE_ADDR cache_pc_function_low = 0;
 193 static CORE_ADDR cache_pc_function_high = 0;
 194 static const char *cache_pc_function_name = 0;
 195 static struct obj_section *cache_pc_function_section = NULL;
 196 static const struct block *cache_pc_function_block = nullptr;
 197
 198 /* Clear cache, e.g. when symbol table is discarded.  */
 199
 200 void
 201 clear_pc_function_cache (void)
 202 {
 203   cache_pc_function_low = 0;
 204   cache_pc_function_high = 0;
 205   cache_pc_function_name = (char *) 0;
 206   cache_pc_function_section = NULL;
 207   cache_pc_function_block = nullptr;
 208 }
 209
 210 /* See symtab.h.  */
 211
 212 int
 213 find_pc_partial_function (CORE_ADDR pc, const char **name, CORE_ADDR *address,
 214                           CORE_ADDR *endaddr, const struct block **block)
 215 {
 216   struct obj_section *section;
 217   struct symbol *f;
 218   struct bound_minimal_symbol msymbol;
 219   struct compunit_symtab *compunit_symtab = NULL;
 220   CORE_ADDR mapped_pc;
 221
 222   /* To ensure that the symbol returned belongs to the correct setion
 223      (and that the last [random] symbol from the previous section
 224      isn't returned) try to find the section containing PC.  First try
 225      the overlay code (which by default returns NULL); and second try
 226      the normal section code (which almost always succeeds).  */
 227   section = find_pc_overlay (pc);
 228   if (section == NULL)
 229     section = find_pc_section (pc);
 230
 231   mapped_pc = overlay_mapped_address (pc, section);
 232
 233   if (mapped_pc >= cache_pc_function_low
 234       && mapped_pc < cache_pc_function_high
 235       && section == cache_pc_function_section)
 236     goto return_cached_value;
 237
 238   msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
 239   for (objfile *objfile : current_program_space->objfiles ())
 240     {
 241       if (objfile->sf)
 242         {
 243           compunit_symtab
 244             = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
 245                                                              mapped_pc,
 246                                                              section,
 247                                                              0);
 248         }
 249       if (compunit_symtab != NULL)
 250         break;
 251     }
 252
 253   if (compunit_symtab != NULL)
 254     {
 255       /* Checking whether the msymbol has a larger value is for the
 256          "pathological" case mentioned in stack.c:find_frame_funname.
 257
 258          We use BLOCK_ENTRY_PC instead of BLOCK_START_PC for this
 259          comparison because the minimal symbol should refer to the
 260          function's entry pc which is not necessarily the lowest
 261          address of the function.  This will happen when the function
 262          has more than one range and the entry pc is not within the
 263          lowest range of addresses.  */
 264       f = find_pc_sect_function (mapped_pc, section);
 265       if (f != NULL
 266           && (msymbol.minsym == NULL
 267               || (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (f))
 268                   >= BMSYMBOL_VALUE_ADDRESS (msymbol))))
 269         {
 270           const struct block *b = SYMBOL_BLOCK_VALUE (f);
 271
 272           cache_pc_function_name = SYMBOL_LINKAGE_NAME (f);
 273           cache_pc_function_section = section;
 274           cache_pc_function_block = b;
 275
 276           /* For blocks occupying contiguous addresses (i.e. no gaps),
 277              the low and high cache addresses are simply the start
 278              and end of the block.
 279
 280              For blocks with non-contiguous ranges, we have to search
 281              for the range containing mapped_pc and then use the start
 282              and end of that range.
 283
 284              This causes the returned *ADDRESS and *ENDADDR values to
 285              be limited to the range in which mapped_pc is found.  See
 286              comment preceding declaration of find_pc_partial_function
 287              in symtab.h for more information.  */
 288
 289           if (BLOCK_CONTIGUOUS_P (b))
 290             {
 291               cache_pc_function_low = BLOCK_START (b);
 292               cache_pc_function_high = BLOCK_END (b);
 293             }
 294           else
 295             {
 296               int i;
 297               for (i = 0; i < BLOCK_NRANGES (b); i++)
 298                 {
 299                   if (BLOCK_RANGE_START (b, i) <= mapped_pc
 300                       && mapped_pc < BLOCK_RANGE_END (b, i))
 301                     {
 302                       cache_pc_function_low = BLOCK_RANGE_START (b, i);
 303                       cache_pc_function_high = BLOCK_RANGE_END (b, i);
 304                       break;
 305                     }
 306                 }
 307               /* Above loop should exit via the break.  */
 308               gdb_assert (i < BLOCK_NRANGES (b));
 309             }
 310
 311
 312           goto return_cached_value;
 313         }
 314     }
 315
 316   /* Not in the normal symbol tables, see if the pc is in a known
 317      section.  If it's not, then give up.  This ensures that anything
 318      beyond the end of the text seg doesn't appear to be part of the
 319      last function in the text segment.  */
 320
 321   if (!section)
 322     msymbol.minsym = NULL;
 323
 324   /* Must be in the minimal symbol table.  */
 325   if (msymbol.minsym == NULL)
 326     {
 327       /* No available symbol.  */
 328       if (name != NULL)
 329         *name = 0;
 330       if (address != NULL)
 331         *address = 0;
 332       if (endaddr != NULL)
 333         *endaddr = 0;
 334       return 0;
 335     }
 336
 337   cache_pc_function_low = BMSYMBOL_VALUE_ADDRESS (msymbol);
 338   cache_pc_function_name = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
 339   cache_pc_function_section = section;
 340   cache_pc_function_high = minimal_symbol_upper_bound (msymbol);
 341   cache_pc_function_block = nullptr;
 342
 343  return_cached_value:
 344
 345   if (address)
 346     {
 347       if (pc_in_unmapped_range (pc, section))
 348         *address = overlay_unmapped_address (cache_pc_function_low, section);
 349       else
 350         *address = cache_pc_function_low;
 351     }
 352
 353   if (name)
 354     *name = cache_pc_function_name;
 355
 356   if (endaddr)
 357     {
 358       if (pc_in_unmapped_range (pc, section))
 359         {
 360           /* Because the high address is actually beyond the end of
 361              the function (and therefore possibly beyond the end of
 362              the overlay), we must actually convert (high - 1) and
 363              then add one to that.  */
 364
 365           *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
 366                                                    section);
 367         }
 368       else
 369         *endaddr = cache_pc_function_high;
 370     }
 371
 372   if (block != nullptr)
 373     *block = cache_pc_function_block;
 374
 375   return 1;
 376 }
 377
 378 /* See symtab.h.  */
 379
 380 bool
 381 find_function_entry_range_from_pc (CORE_ADDR pc, const char **name,
 382                                    CORE_ADDR *address, CORE_ADDR *endaddr)
 383 {
 384   const struct block *block;
 385   bool status = find_pc_partial_function (pc, name, address, endaddr, &block);
 386
 387   if (status && block != nullptr && !BLOCK_CONTIGUOUS_P (block))
 388     {
 389       CORE_ADDR entry_pc = BLOCK_ENTRY_PC (block);
 390
 391       for (int i = 0; i < BLOCK_NRANGES (block); i++)
 392         {
 393           if (BLOCK_RANGE_START (block, i) <= entry_pc
 394               && entry_pc < BLOCK_RANGE_END (block, i))
 395             {
 396               if (address != nullptr)
 397                 *address = BLOCK_RANGE_START (block, i);
 398
 399               if (endaddr != nullptr)
 400                 *endaddr = BLOCK_RANGE_END (block, i);
 401
 402               return status;
 403             }
 404         }
 405
 406       /* It's an internal error if we exit the above loop without finding
 407          the range.  */
 408       internal_error (__FILE__, __LINE__,
 409                       _("Entry block not found in find_function_entry_range_from_pc"));
 410     }
 411
 412   return status;
 413 }
 414
 415 /* See symtab.h.  */
 416
 417 struct type *
 418 find_function_type (CORE_ADDR pc)
 419 {
 420   struct symbol *sym = find_pc_function (pc);
 421
 422   if (sym != NULL && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) == pc)
 423     return SYMBOL_TYPE (sym);
 424
 425   return NULL;
 426 }
 427
 428 /* See symtab.h.  */
 429
 430 struct type *
 431 find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr)
 432 {
 433   struct type *resolver_type = find_function_type (resolver_funaddr);
 434   if (resolver_type != NULL)
 435     {
 436       /* Get the return type of the resolver.  */
 437       struct type *resolver_ret_type
 438         = check_typedef (TYPE_TARGET_TYPE (resolver_type));
 439
 440       /* If we found a pointer to function, then the resolved type
 441          is the type of the pointed-to function.  */
 442       if (TYPE_CODE (resolver_ret_type) == TYPE_CODE_PTR)
 443         {
 444           struct type *resolved_type
 445             = TYPE_TARGET_TYPE (resolver_ret_type);
 446           if (TYPE_CODE (check_typedef (resolved_type)) == TYPE_CODE_FUNC)
 447             return resolved_type;
 448         }
 449     }
 450
 451   return NULL;
 452 }
 453
 454 /* Return the innermost stack frame that is executing inside of BLOCK and is
 455    at least as old as the selected frame. Return NULL if there is no
 456    such frame.  If BLOCK is NULL, just return NULL.  */
 457
 458 struct frame_info *
 459 block_innermost_frame (const struct block *block)
 460 {
 461   struct frame_info *frame;
 462
 463   if (block == NULL)
 464     return NULL;
 465
 466   frame = get_selected_frame_if_set ();
 467   if (frame == NULL)
 468     frame = get_current_frame ();
 469   while (frame != NULL)
 470     {
 471       const struct block *frame_block = get_frame_block (frame, NULL);
 472       if (frame_block != NULL && contained_in (frame_block, block))
 473         return frame;
 474
 475       frame = get_prev_frame (frame);
 476     }
 477
 478   return NULL;
 479 }