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 PC is in the range of addresses that corresponds to
  47    the "main" function.  */
  48
  49 int
  50 inside_main_func (CORE_ADDR pc)
  51 {
  52   struct minimal_symbol *msymbol;
  53
  54   if (symfile_objfile == 0)
  55     return 0;
  56
  57   msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
  58
  59   /* If the address range hasn't been set up at symbol reading time,
  60      set it up now.  */
  61
  62   if (msymbol != NULL
  63       && symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC
  64       && symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
  65     {
  66       /* brobecker/2003-10-10: We used to rely on lookup_symbol() to
  67          search the symbol associated to the "main" function.
  68          Unfortunately, lookup_symbol() uses the current-language
  69          la_lookup_symbol_nonlocal function to do the global symbol
  70          search.  Depending on the language, this can introduce
  71          certain side-effects, because certain languages, for instance
  72          Ada, may find more than one match.  Therefore we prefer to
  73          search the "main" function symbol using its address rather
  74          than its name.  */
  75       struct symbol *mainsym =
  76         find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol));
  77
  78       if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK)
  79         {
  80           symfile_objfile->ei.main_func_lowpc =
  81             BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
  82           symfile_objfile->ei.main_func_highpc =
  83             BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
  84         }
  85     }
  86
  87   /* Not in the normal symbol tables, see if "main" is in the partial
  88      symbol table.  If it's not, then give up.  */
  89   if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_text)
  90     {
  91       CORE_ADDR maddr = SYMBOL_VALUE_ADDRESS (msymbol);
  92       asection *msect = SYMBOL_BFD_SECTION (msymbol);
  93       struct obj_section *osect = find_pc_sect_section (maddr, msect);
  94
  95       if (osect != NULL)
  96         {
  97           int i;
  98
  99           /* Step over other symbols at this same address, and symbols
 100              in other sections, to find the next symbol in this
 101              section with a different address.  */
 102           for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
 103             {
 104               if (SYMBOL_VALUE_ADDRESS (msymbol + i) != maddr
 105                   && SYMBOL_BFD_SECTION (msymbol + i) == msect)
 106                 break;
 107             }
 108
 109           symfile_objfile->ei.main_func_lowpc = maddr;
 110
 111           /* Use the lesser of the next minimal symbol in the same
 112              section, or the end of the section, as the end of the
 113              function.  */
 114           if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
 115               && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
 116             symfile_objfile->ei.main_func_highpc =
 117               SYMBOL_VALUE_ADDRESS (msymbol + i);
 118           else
 119             /* We got the start address from the last msymbol in the
 120                objfile.  So the end address is the end of the
 121                section.  */
 122             symfile_objfile->ei.main_func_highpc = osect->endaddr;
 123         }
 124     }
 125
 126   return (symfile_objfile->ei.main_func_lowpc <= pc
 127           && symfile_objfile->ei.main_func_highpc > pc);
 128 }
 129
 130 /* Test whether THIS_FRAME is inside the process entry point function.  */
 131
 132 int
 133 inside_entry_func (struct frame_info *this_frame)
 134 {
 135   return (get_frame_func (this_frame) == entry_point_address ());
 136 }
 137
 138 /* Return nonzero if the function for this frame lacks a prologue.
 139    Many machines can define DEPRECATED_FRAMELESS_FUNCTION_INVOCATION
 140    to just call this function.  */
 141
 142 int
 143 legacy_frameless_look_for_prologue (struct frame_info *frame)
 144 {
 145   CORE_ADDR func_start;
 146
 147   func_start = get_frame_func (frame);
 148   if (func_start)
 149     {
 150       func_start += DEPRECATED_FUNCTION_START_OFFSET;
 151       /* NOTE: cagney/2004-02-09: Eliminated per-architecture
 152          PROLOGUE_FRAMELESS_P call as architectures with custom
 153          implementations had all been deleted.  Eventually even this
 154          function can go - GDB no longer tries to differentiate
 155          between framed, frameless and stackless functions.  They are
 156          all now considered equally evil :-^.  */
 157       /* If skipping the prologue ends up skips nothing, there must be
 158          no prologue and hence no code creating a frame.  There for
 159          the function is "frameless" :-/.  */
 160       return func_start == SKIP_PROLOGUE (func_start);
 161     }
 162   else if (get_frame_pc (frame) == 0)
 163     /* A frame with a zero PC is usually created by dereferencing a
 164        NULL function pointer, normally causing an immediate core dump
 165        of the inferior. Mark function as frameless, as the inferior
 166        has no chance of setting up a stack frame.  */
 167     return 1;
 168   else
 169     /* If we can't find the start of the function, we don't really
 170        know whether the function is frameless, but we should be able
 171        to get a reasonable (i.e. best we can do under the
 172        circumstances) backtrace by saying that it isn't.  */
 173     return 0;
 174 }
 175
 176 /* Return the innermost lexical block in execution
 177    in a specified stack frame.  The frame address is assumed valid.
 178
 179    If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
 180    address we used to choose the block.  We use this to find a source
 181    line, to decide which macro definitions are in scope.
 182
 183    The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
 184    PC, and may not really be a valid PC at all.  For example, in the
 185    caller of a function declared to never return, the code at the
 186    return address will never be reached, so the call instruction may
 187    be the very last instruction in the block.  So the address we use
 188    to choose the block is actually one byte before the return address
 189    --- hopefully pointing us at the call instruction, or its delay
 190    slot instruction.  */
 191
 192 struct block *
 193 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
 194 {
 195   const CORE_ADDR pc = get_frame_address_in_block (frame);
 196
 197   if (addr_in_block)
 198     *addr_in_block = pc;
 199
 200   return block_for_pc (pc);
 201 }
 202
 203 CORE_ADDR
 204 get_pc_function_start (CORE_ADDR pc)
 205 {
 206   struct block *bl;
 207   struct minimal_symbol *msymbol;
 208
 209   bl = block_for_pc (pc);
 210   if (bl)
 211     {
 212       struct symbol *symbol = block_function (bl);
 213
 214       if (symbol)
 215         {
 216           bl = SYMBOL_BLOCK_VALUE (symbol);
 217           return BLOCK_START (bl);
 218         }
 219     }
 220
 221   msymbol = lookup_minimal_symbol_by_pc (pc);
 222   if (msymbol)
 223     {
 224       CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
 225
 226       if (find_pc_section (fstart))
 227         return fstart;
 228     }
 229
 230   return 0;
 231 }
 232
 233 /* Return the symbol for the function executing in frame FRAME.  */
 234
 235 struct symbol *
 236 get_frame_function (struct frame_info *frame)
 237 {
 238   struct block *bl = get_frame_block (frame, 0);
 239   if (bl == 0)
 240     return 0;
 241   return block_function (bl);
 242 }
 243 \f
 244
 245 /* Return the function containing pc value PC in section SECTION.
 246    Returns 0 if function is not known.  */
 247
 248 struct symbol *
 249 find_pc_sect_function (CORE_ADDR pc, struct bfd_section *section)
 250 {
 251   struct block *b = block_for_pc_sect (pc, section);
 252   if (b == 0)
 253     return 0;
 254   return block_function (b);
 255 }
 256
 257 /* Return the function containing pc value PC.
 258    Returns 0 if function is not known.  Backward compatibility, no section */
 259
 260 struct symbol *
 261 find_pc_function (CORE_ADDR pc)
 262 {
 263   return find_pc_sect_function (pc, find_pc_mapped_section (pc));
 264 }
 265
 266 /* These variables are used to cache the most recent result
 267  * of find_pc_partial_function. */
 268
 269 static CORE_ADDR cache_pc_function_low = 0;
 270 static CORE_ADDR cache_pc_function_high = 0;
 271 static char *cache_pc_function_name = 0;
 272 static struct bfd_section *cache_pc_function_section = NULL;
 273
 274 /* Clear cache, e.g. when symbol table is discarded. */
 275
 276 void
 277 clear_pc_function_cache (void)
 278 {
 279   cache_pc_function_low = 0;
 280   cache_pc_function_high = 0;
 281   cache_pc_function_name = (char *) 0;
 282   cache_pc_function_section = NULL;
 283 }
 284
 285 /* Finds the "function" (text symbol) that is smaller than PC but
 286    greatest of all of the potential text symbols in SECTION.  Sets
 287    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
 288    If ENDADDR is non-null, then set *ENDADDR to be the end of the
 289    function (exclusive), but passing ENDADDR as non-null means that
 290    the function might cause symbols to be read.  This function either
 291    succeeds or fails (not halfway succeeds).  If it succeeds, it sets
 292    *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
 293    If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
 294    returns 0.  */
 295
 296 /* Backward compatibility, no section argument.  */
 297
 298 int
 299 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
 300                           CORE_ADDR *endaddr)
 301 {
 302   struct bfd_section *section;
 303   struct partial_symtab *pst;
 304   struct symbol *f;
 305   struct minimal_symbol *msymbol;
 306   struct partial_symbol *psb;
 307   struct obj_section *osect;
 308   int i;
 309   CORE_ADDR mapped_pc;
 310
 311   /* To ensure that the symbol returned belongs to the correct setion
 312      (and that the last [random] symbol from the previous section
 313      isn't returned) try to find the section containing PC.  First try
 314      the overlay code (which by default returns NULL); and second try
 315      the normal section code (which almost always succeeds).  */
 316   section = find_pc_overlay (pc);
 317   if (section == NULL)
 318     {
 319       struct obj_section *obj_section = find_pc_section (pc);
 320       if (obj_section == NULL)
 321         section = NULL;
 322       else
 323         section = obj_section->the_bfd_section;
 324     }
 325
 326   mapped_pc = overlay_mapped_address (pc, section);
 327
 328   if (mapped_pc >= cache_pc_function_low
 329       && mapped_pc < cache_pc_function_high
 330       && section == cache_pc_function_section)
 331     goto return_cached_value;
 332
 333   msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
 334   pst = find_pc_sect_psymtab (mapped_pc, section);
 335   if (pst)
 336     {
 337       /* Need to read the symbols to get a good value for the end address.  */
 338       if (endaddr != NULL && !pst->readin)
 339         {
 340           /* Need to get the terminal in case symbol-reading produces
 341              output.  */
 342           target_terminal_ours_for_output ();
 343           PSYMTAB_TO_SYMTAB (pst);
 344         }
 345
 346       if (pst->readin)
 347         {
 348           /* Checking whether the msymbol has a larger value is for the
 349              "pathological" case mentioned in print_frame_info.  */
 350           f = find_pc_sect_function (mapped_pc, section);
 351           if (f != NULL
 352               && (msymbol == NULL
 353                   || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
 354                       >= SYMBOL_VALUE_ADDRESS (msymbol))))
 355             {
 356               cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
 357               cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
 358               cache_pc_function_name = DEPRECATED_SYMBOL_NAME (f);
 359               cache_pc_function_section = section;
 360               goto return_cached_value;
 361             }
 362         }
 363       else
 364         {
 365           /* Now that static symbols go in the minimal symbol table, perhaps
 366              we could just ignore the partial symbols.  But at least for now
 367              we use the partial or minimal symbol, whichever is larger.  */
 368           psb = find_pc_sect_psymbol (pst, mapped_pc, section);
 369
 370           if (psb
 371               && (msymbol == NULL ||
 372                   (SYMBOL_VALUE_ADDRESS (psb)
 373                    >= SYMBOL_VALUE_ADDRESS (msymbol))))
 374             {
 375               /* This case isn't being cached currently. */
 376               if (address)
 377                 *address = SYMBOL_VALUE_ADDRESS (psb);
 378               if (name)
 379                 *name = DEPRECATED_SYMBOL_NAME (psb);
 380               /* endaddr non-NULL can't happen here.  */
 381               return 1;
 382             }
 383         }
 384     }
 385
 386   /* Not in the normal symbol tables, see if the pc is in a known section.
 387      If it's not, then give up.  This ensures that anything beyond the end
 388      of the text seg doesn't appear to be part of the last function in the
 389      text segment.  */
 390
 391   osect = find_pc_sect_section (mapped_pc, section);
 392
 393   if (!osect)
 394     msymbol = NULL;
 395
 396   /* Must be in the minimal symbol table.  */
 397   if (msymbol == NULL)
 398     {
 399       /* No available symbol.  */
 400       if (name != NULL)
 401         *name = 0;
 402       if (address != NULL)
 403         *address = 0;
 404       if (endaddr != NULL)
 405         *endaddr = 0;
 406       return 0;
 407     }
 408
 409   cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
 410   cache_pc_function_name = DEPRECATED_SYMBOL_NAME (msymbol);
 411   cache_pc_function_section = section;
 412
 413   /* Use the lesser of the next minimal symbol in the same section, or
 414      the end of the section, as the end of the function.  */
 415
 416   /* Step over other symbols at this same address, and symbols in
 417      other sections, to find the next symbol in this section with
 418      a different address.  */
 419
 420   for (i = 1; DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL; i++)
 421     {
 422       if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
 423           && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
 424         break;
 425     }
 426
 427   if (DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL
 428       && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
 429     cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
 430   else
 431     /* We got the start address from the last msymbol in the objfile.
 432        So the end address is the end of the section.  */
 433     cache_pc_function_high = osect->endaddr;
 434
 435  return_cached_value:
 436
 437   if (address)
 438     {
 439       if (pc_in_unmapped_range (pc, section))
 440         *address = overlay_unmapped_address (cache_pc_function_low, section);
 441       else
 442         *address = cache_pc_function_low;
 443     }
 444
 445   if (name)
 446     *name = cache_pc_function_name;
 447
 448   if (endaddr)
 449     {
 450       if (pc_in_unmapped_range (pc, section))
 451         {
 452           /* Because the high address is actually beyond the end of
 453              the function (and therefore possibly beyond the end of
 454              the overlay), we must actually convert (high - 1) and
 455              then add one to that. */
 456
 457           *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
 458                                                    section);
 459         }
 460       else
 461         *endaddr = cache_pc_function_high;
 462     }
 463
 464   return 1;
 465 }
 466
 467 /* Return the innermost stack frame executing inside of BLOCK,
 468    or NULL if there is no such frame.  If BLOCK is NULL, just return NULL.  */
 469
 470 struct frame_info *
 471 block_innermost_frame (struct block *block)
 472 {
 473   struct frame_info *frame;
 474   CORE_ADDR start;
 475   CORE_ADDR end;
 476   CORE_ADDR calling_pc;
 477
 478   if (block == NULL)
 479     return NULL;
 480
 481   start = BLOCK_START (block);
 482   end = BLOCK_END (block);
 483
 484   frame = NULL;
 485   while (1)
 486     {
 487       frame = get_prev_frame (frame);
 488       if (frame == NULL)
 489         return NULL;
 490       calling_pc = get_frame_address_in_block (frame);
 491       if (calling_pc >= start && calling_pc < end)
 492         return frame;
 493     }
 494 }
 495
 496 /* Are we in a call dummy?  The code below which allows DECR_PC_AFTER_BREAK
 497    below is for infrun.c, which may give the macro a pc without that
 498    subtracted out.  */
 499
 500 /* Returns true for a user frame or a call_function_by_hand dummy
 501    frame, and false for the CRT0 start-up frame.  Purpose is to
 502    terminate backtrace.  */
 503
 504 int
 505 legacy_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
 506 {
 507   /* Don't prune CALL_DUMMY frames.  */
 508   if (deprecated_pc_in_call_dummy (get_frame_pc (fi)))
 509     return 1;
 510
 511   /* If the new frame pointer is zero, then it isn't valid.  */
 512   if (fp == 0)
 513     return 0;
 514
 515   /* If the new frame would be inside (younger than) the previous frame,
 516      then it isn't valid.  */
 517   if (INNER_THAN (fp, get_frame_base (fi)))
 518     return 0;
 519
 520   /* If the architecture has a custom DEPRECATED_FRAME_CHAIN_VALID,
 521      call it now.  */
 522   if (DEPRECATED_FRAME_CHAIN_VALID_P ())
 523     return DEPRECATED_FRAME_CHAIN_VALID (fp, fi);
 524
 525   /* If we're already inside the entry function for the main objfile,
 526      then it isn't valid.  */
 527   if (inside_entry_func (fi))
 528     return 0;
 529
 530   return 1;
 531 }