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