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 Free Software
   6    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 "symfile.h"
  29 #include "objfiles.h"
  30 #include "frame.h"
  31 #include "gdbcore.h"
  32 #include "value.h"              /* for read_register */
  33 #include "target.h"             /* for target_has_stack */
  34 #include "inferior.h"           /* for read_pc */
  35 #include "annotate.h"
  36 #include "regcache.h"
  37 #include "gdb_assert.h"
  38 #include "dummy-frame.h"
  39 #include "command.h"
  40 #include "gdbcmd.h"
  41 #include "block.h"
  42
  43 /* Prototypes for exported functions. */
  44
  45 void _initialize_blockframe (void);
  46
  47 /* Is ADDR inside the startup file?  Note that if your machine has a
  48    way to detect the bottom of the stack, there is no need to call
  49    this function from DEPRECATED_FRAME_CHAIN_VALID; the reason for
  50    doing so is that some machines have no way of detecting bottom of
  51    stack.
  52
  53    A PC of zero is always considered to be the bottom of the stack. */
  54
  55 int
  56 deprecated_inside_entry_file (CORE_ADDR addr)
  57 {
  58   if (addr == 0)
  59     return 1;
  60   if (symfile_objfile == 0)
  61     return 0;
  62   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT
  63       || CALL_DUMMY_LOCATION == AT_SYMBOL)
  64     {
  65       /* Do not stop backtracing if the pc is in the call dummy
  66          at the entry point.  */
  67       /* FIXME: Won't always work with zeros for the last two arguments */
  68       if (DEPRECATED_PC_IN_CALL_DUMMY (addr, 0, 0))
  69         return 0;
  70     }
  71   return (addr >= symfile_objfile->ei.deprecated_entry_file_lowpc &&
  72           addr < symfile_objfile->ei.deprecated_entry_file_highpc);
  73 }
  74
  75 /* Test whether PC is in the range of addresses that corresponds to
  76    the "main" function.
  77
  78    A PC of zero is always considered to be the bottom of the stack.  */
  79
  80 int
  81 inside_main_func (CORE_ADDR pc)
  82 {
  83   struct minimal_symbol *msymbol;
  84
  85   if (pc == 0)
  86     return 1;
  87
  88   if (symfile_objfile == 0)
  89     return 0;
  90
  91   msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
  92
  93   /* If the address range hasn't been set up at symbol reading time,
  94      set it up now.  */
  95
  96   if (msymbol != NULL
  97       && symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC
  98       && symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
  99     {
 100       /* brobecker/2003-10-10: We used to rely on lookup_symbol() to
 101          search the symbol associated to the "main" function.
 102          Unfortunately, lookup_symbol() uses the current-language
 103          la_lookup_symbol_nonlocal function to do the global symbol
 104          search.  Depending on the language, this can introduce
 105          certain side-effects, because certain languages, for instance
 106          Ada, may find more than one match.  Therefore we prefer to
 107          search the "main" function symbol using its address rather
 108          than its name.  */
 109       struct symbol *mainsym =
 110         find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol));
 111
 112       if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK)
 113         {
 114           symfile_objfile->ei.main_func_lowpc =
 115             BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
 116           symfile_objfile->ei.main_func_highpc =
 117             BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
 118         }
 119     }
 120
 121   /* Not in the normal symbol tables, see if "main" is in the partial
 122      symbol table.  If it's not, then give up.  */
 123   if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_text)
 124     {
 125       CORE_ADDR maddr = SYMBOL_VALUE_ADDRESS (msymbol);
 126       asection *msect = SYMBOL_BFD_SECTION (msymbol);
 127       struct obj_section *osect = find_pc_sect_section (maddr, msect);
 128
 129       if (osect != NULL)
 130         {
 131           int i;
 132
 133           /* Step over other symbols at this same address, and symbols
 134              in other sections, to find the next symbol in this
 135              section with a different address.  */
 136           for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
 137             {
 138               if (SYMBOL_VALUE_ADDRESS (msymbol + i) != maddr
 139                   && SYMBOL_BFD_SECTION (msymbol + i) == msect)
 140                 break;
 141             }
 142
 143           symfile_objfile->ei.main_func_lowpc = maddr;
 144
 145           /* Use the lesser of the next minimal symbol in the same
 146              section, or the end of the section, as the end of the
 147              function.  */
 148           if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
 149               && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
 150             symfile_objfile->ei.main_func_highpc =
 151               SYMBOL_VALUE_ADDRESS (msymbol + i);
 152           else
 153             /* We got the start address from the last msymbol in the
 154                objfile.  So the end address is the end of the
 155                section.  */
 156             symfile_objfile->ei.main_func_highpc = osect->endaddr;
 157         }
 158     }
 159
 160   return (symfile_objfile->ei.main_func_lowpc <= pc
 161           && symfile_objfile->ei.main_func_highpc > pc);
 162 }
 163
 164 /* Test a specified PC value to see if it is in the range of addresses
 165    that correspond to the process entry point function.  See comments
 166    in objfiles.h for why we might want to do this.
 167
 168    Typically called from DEPRECATED_FRAME_CHAIN_VALID.
 169
 170    A PC of zero is always considered to be the bottom of the stack. */
 171
 172 int
 173 inside_entry_func (CORE_ADDR pc)
 174 {
 175   if (pc == 0)
 176     return 1;
 177   if (symfile_objfile == 0)
 178     return 0;
 179   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
 180     {
 181       /* Do not stop backtracing if the pc is in the call dummy
 182          at the entry point.  */
 183       /* FIXME: Won't always work with zeros for the last two arguments */
 184       if (DEPRECATED_PC_IN_CALL_DUMMY (pc, 0, 0))
 185         return 0;
 186     }
 187   return (symfile_objfile->ei.entry_func_lowpc <= pc &&
 188           symfile_objfile->ei.entry_func_highpc > pc);
 189 }
 190
 191 /* Return nonzero if the function for this frame lacks a prologue.  Many
 192    machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
 193    function.  */
 194
 195 int
 196 frameless_look_for_prologue (struct frame_info *frame)
 197 {
 198   CORE_ADDR func_start;
 199
 200   func_start = get_frame_func (frame);
 201   if (func_start)
 202     {
 203       func_start += FUNCTION_START_OFFSET;
 204       /* This is faster, since only care whether there *is* a
 205          prologue, not how long it is.  */
 206       return PROLOGUE_FRAMELESS_P (func_start);
 207     }
 208   else if (get_frame_pc (frame) == 0)
 209     /* A frame with a zero PC is usually created by dereferencing a
 210        NULL function pointer, normally causing an immediate core dump
 211        of the inferior. Mark function as frameless, as the inferior
 212        has no chance of setting up a stack frame.  */
 213     return 1;
 214   else
 215     /* If we can't find the start of the function, we don't really
 216        know whether the function is frameless, but we should be able
 217        to get a reasonable (i.e. best we can do under the
 218        circumstances) backtrace by saying that it isn't.  */
 219     return 0;
 220 }
 221
 222 /* Return the innermost lexical block in execution
 223    in a specified stack frame.  The frame address is assumed valid.
 224
 225    If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
 226    address we used to choose the block.  We use this to find a source
 227    line, to decide which macro definitions are in scope.
 228
 229    The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
 230    PC, and may not really be a valid PC at all.  For example, in the
 231    caller of a function declared to never return, the code at the
 232    return address will never be reached, so the call instruction may
 233    be the very last instruction in the block.  So the address we use
 234    to choose the block is actually one byte before the return address
 235    --- hopefully pointing us at the call instruction, or its delay
 236    slot instruction.  */
 237
 238 struct block *
 239 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
 240 {
 241   const CORE_ADDR pc = get_frame_address_in_block (frame);
 242
 243   if (addr_in_block)
 244     *addr_in_block = pc;
 245
 246   return block_for_pc (pc);
 247 }
 248
 249 CORE_ADDR
 250 get_pc_function_start (CORE_ADDR pc)
 251 {
 252   struct block *bl;
 253   struct minimal_symbol *msymbol;
 254
 255   bl = block_for_pc (pc);
 256   if (bl)
 257     {
 258       struct symbol *symbol = block_function (bl);
 259
 260       if (symbol)
 261         {
 262           bl = SYMBOL_BLOCK_VALUE (symbol);
 263           return BLOCK_START (bl);
 264         }
 265     }
 266
 267   msymbol = lookup_minimal_symbol_by_pc (pc);
 268   if (msymbol)
 269     {
 270       CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
 271
 272       if (find_pc_section (fstart))
 273         return fstart;
 274     }
 275
 276   return 0;
 277 }
 278
 279 /* Return the symbol for the function executing in frame FRAME.  */
 280
 281 struct symbol *
 282 get_frame_function (struct frame_info *frame)
 283 {
 284   struct block *bl = get_frame_block (frame, 0);
 285   if (bl == 0)
 286     return 0;
 287   return block_function (bl);
 288 }
 289 \f
 290
 291 /* Return the function containing pc value PC in section SECTION.
 292    Returns 0 if function is not known.  */
 293
 294 struct symbol *
 295 find_pc_sect_function (CORE_ADDR pc, struct bfd_section *section)
 296 {
 297   struct block *b = block_for_pc_sect (pc, section);
 298   if (b == 0)
 299     return 0;
 300   return block_function (b);
 301 }
 302
 303 /* Return the function containing pc value PC.
 304    Returns 0 if function is not known.  Backward compatibility, no section */
 305
 306 struct symbol *
 307 find_pc_function (CORE_ADDR pc)
 308 {
 309   return find_pc_sect_function (pc, find_pc_mapped_section (pc));
 310 }
 311
 312 /* These variables are used to cache the most recent result
 313  * of find_pc_partial_function. */
 314
 315 static CORE_ADDR cache_pc_function_low = 0;
 316 static CORE_ADDR cache_pc_function_high = 0;
 317 static char *cache_pc_function_name = 0;
 318 static struct bfd_section *cache_pc_function_section = NULL;
 319
 320 /* Clear cache, e.g. when symbol table is discarded. */
 321
 322 void
 323 clear_pc_function_cache (void)
 324 {
 325   cache_pc_function_low = 0;
 326   cache_pc_function_high = 0;
 327   cache_pc_function_name = (char *) 0;
 328   cache_pc_function_section = NULL;
 329 }
 330
 331 /* Finds the "function" (text symbol) that is smaller than PC but
 332    greatest of all of the potential text symbols in SECTION.  Sets
 333    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
 334    If ENDADDR is non-null, then set *ENDADDR to be the end of the
 335    function (exclusive), but passing ENDADDR as non-null means that
 336    the function might cause symbols to be read.  This function either
 337    succeeds or fails (not halfway succeeds).  If it succeeds, it sets
 338    *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
 339    If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
 340    returns 0.  */
 341
 342 int
 343 find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
 344                                CORE_ADDR *address, CORE_ADDR *endaddr)
 345 {
 346   struct partial_symtab *pst;
 347   struct symbol *f;
 348   struct minimal_symbol *msymbol;
 349   struct partial_symbol *psb;
 350   struct obj_section *osect;
 351   int i;
 352   CORE_ADDR mapped_pc;
 353
 354   mapped_pc = overlay_mapped_address (pc, section);
 355
 356   if (mapped_pc >= cache_pc_function_low
 357       && mapped_pc < cache_pc_function_high
 358       && section == cache_pc_function_section)
 359     goto return_cached_value;
 360
 361   /* If sigtramp is in the u area, it counts as a function (especially
 362      important for step_1).  */
 363   if (SIGTRAMP_START_P () && PC_IN_SIGTRAMP (mapped_pc, (char *) NULL))
 364     {
 365       cache_pc_function_low = SIGTRAMP_START (mapped_pc);
 366       cache_pc_function_high = SIGTRAMP_END (mapped_pc);
 367       cache_pc_function_name = "<sigtramp>";
 368       cache_pc_function_section = section;
 369       goto return_cached_value;
 370     }
 371
 372   msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
 373   pst = find_pc_sect_psymtab (mapped_pc, section);
 374   if (pst)
 375     {
 376       /* Need to read the symbols to get a good value for the end address.  */
 377       if (endaddr != NULL && !pst->readin)
 378         {
 379           /* Need to get the terminal in case symbol-reading produces
 380              output.  */
 381           target_terminal_ours_for_output ();
 382           PSYMTAB_TO_SYMTAB (pst);
 383         }
 384
 385       if (pst->readin)
 386         {
 387           /* Checking whether the msymbol has a larger value is for the
 388              "pathological" case mentioned in print_frame_info.  */
 389           f = find_pc_sect_function (mapped_pc, section);
 390           if (f != NULL
 391               && (msymbol == NULL
 392                   || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
 393                       >= SYMBOL_VALUE_ADDRESS (msymbol))))
 394             {
 395               cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
 396               cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
 397               cache_pc_function_name = DEPRECATED_SYMBOL_NAME (f);
 398               cache_pc_function_section = section;
 399               goto return_cached_value;
 400             }
 401         }
 402       else
 403         {
 404           /* Now that static symbols go in the minimal symbol table, perhaps
 405              we could just ignore the partial symbols.  But at least for now
 406              we use the partial or minimal symbol, whichever is larger.  */
 407           psb = find_pc_sect_psymbol (pst, mapped_pc, section);
 408
 409           if (psb
 410               && (msymbol == NULL ||
 411                   (SYMBOL_VALUE_ADDRESS (psb)
 412                    >= SYMBOL_VALUE_ADDRESS (msymbol))))
 413             {
 414               /* This case isn't being cached currently. */
 415               if (address)
 416                 *address = SYMBOL_VALUE_ADDRESS (psb);
 417               if (name)
 418                 *name = DEPRECATED_SYMBOL_NAME (psb);
 419               /* endaddr non-NULL can't happen here.  */
 420               return 1;
 421             }
 422         }
 423     }
 424
 425   /* Not in the normal symbol tables, see if the pc is in a known section.
 426      If it's not, then give up.  This ensures that anything beyond the end
 427      of the text seg doesn't appear to be part of the last function in the
 428      text segment.  */
 429
 430   osect = find_pc_sect_section (mapped_pc, section);
 431
 432   if (!osect)
 433     msymbol = NULL;
 434
 435   /* Must be in the minimal symbol table.  */
 436   if (msymbol == NULL)
 437     {
 438       /* No available symbol.  */
 439       if (name != NULL)
 440         *name = 0;
 441       if (address != NULL)
 442         *address = 0;
 443       if (endaddr != NULL)
 444         *endaddr = 0;
 445       return 0;
 446     }
 447
 448   cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
 449   cache_pc_function_name = DEPRECATED_SYMBOL_NAME (msymbol);
 450   cache_pc_function_section = section;
 451
 452   /* Use the lesser of the next minimal symbol in the same section, or
 453      the end of the section, as the end of the function.  */
 454
 455   /* Step over other symbols at this same address, and symbols in
 456      other sections, to find the next symbol in this section with
 457      a different address.  */
 458
 459   for (i = 1; DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL; i++)
 460     {
 461       if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
 462           && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
 463         break;
 464     }
 465
 466   if (DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL
 467       && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
 468     cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
 469   else
 470     /* We got the start address from the last msymbol in the objfile.
 471        So the end address is the end of the section.  */
 472     cache_pc_function_high = osect->endaddr;
 473
 474  return_cached_value:
 475
 476   if (address)
 477     {
 478       if (pc_in_unmapped_range (pc, section))
 479         *address = overlay_unmapped_address (cache_pc_function_low, section);
 480       else
 481         *address = cache_pc_function_low;
 482     }
 483
 484   if (name)
 485     *name = cache_pc_function_name;
 486
 487   if (endaddr)
 488     {
 489       if (pc_in_unmapped_range (pc, section))
 490         {
 491           /* Because the high address is actually beyond the end of
 492              the function (and therefore possibly beyond the end of
 493              the overlay), we must actually convert (high - 1) and
 494              then add one to that. */
 495
 496           *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
 497                                                    section);
 498         }
 499       else
 500         *endaddr = cache_pc_function_high;
 501     }
 502
 503   return 1;
 504 }
 505
 506 /* Backward compatibility, no section argument.  */
 507
 508 int
 509 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
 510                           CORE_ADDR *endaddr)
 511 {
 512   asection *section;
 513
 514   section = find_pc_overlay (pc);
 515   return find_pc_sect_partial_function (pc, section, name, address, endaddr);
 516 }
 517
 518 /* Return the innermost stack frame executing inside of BLOCK,
 519    or NULL if there is no such frame.  If BLOCK is NULL, just return NULL.  */
 520
 521 struct frame_info *
 522 block_innermost_frame (struct block *block)
 523 {
 524   struct frame_info *frame;
 525   CORE_ADDR start;
 526   CORE_ADDR end;
 527   CORE_ADDR calling_pc;
 528
 529   if (block == NULL)
 530     return NULL;
 531
 532   start = BLOCK_START (block);
 533   end = BLOCK_END (block);
 534
 535   frame = NULL;
 536   while (1)
 537     {
 538       frame = get_prev_frame (frame);
 539       if (frame == NULL)
 540         return NULL;
 541       calling_pc = get_frame_address_in_block (frame);
 542       if (calling_pc >= start && calling_pc < end)
 543         return frame;
 544     }
 545 }
 546
 547 /* Are we in a call dummy?  The code below which allows DECR_PC_AFTER_BREAK
 548    below is for infrun.c, which may give the macro a pc without that
 549    subtracted out.  */
 550
 551 /* Is the PC in a call dummy?  SP and FRAME_ADDRESS are the bottom and
 552    top of the stack frame which we are checking, where "bottom" and
 553    "top" refer to some section of memory which contains the code for
 554    the call dummy.  Calls to this macro assume that the contents of
 555    SP_REGNUM and DEPRECATED_FP_REGNUM (or the saved values thereof),
 556    respectively, are the things to pass.
 557
 558    This won't work on the 29k, where SP_REGNUM and
 559    DEPRECATED_FP_REGNUM don't have that meaning, but the 29k doesn't
 560    use ON_STACK.  This could be fixed by generalizing this scheme,
 561    perhaps by passing in a frame and adding a few fields, at least on
 562    machines which need them for DEPRECATED_PC_IN_CALL_DUMMY.
 563
 564    Something simpler, like checking for the stack segment, doesn't work,
 565    since various programs (threads implementations, gcc nested function
 566    stubs, etc) may either allocate stack frames in another segment, or
 567    allocate other kinds of code on the stack.  */
 568
 569 int
 570 deprecated_pc_in_call_dummy_on_stack (CORE_ADDR pc, CORE_ADDR sp,
 571                                       CORE_ADDR frame_address)
 572 {
 573   return (INNER_THAN ((sp), (pc))
 574           && (frame_address != 0)
 575           && INNER_THAN ((pc), (frame_address)));
 576 }
 577
 578 int
 579 deprecated_pc_in_call_dummy_at_entry_point (CORE_ADDR pc, CORE_ADDR sp,
 580                                             CORE_ADDR frame_address)
 581 {
 582   CORE_ADDR addr = entry_point_address ();
 583   if (DEPRECATED_CALL_DUMMY_ADDRESS_P ())
 584     addr = DEPRECATED_CALL_DUMMY_ADDRESS ();
 585   return ((pc) >= addr && (pc) <= (addr + DECR_PC_AFTER_BREAK));
 586 }
 587
 588 /* Returns true for a user frame or a call_function_by_hand dummy
 589    frame, and false for the CRT0 start-up frame.  Purpose is to
 590    terminate backtrace.  */
 591
 592 int
 593 legacy_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
 594 {
 595   /* Don't prune CALL_DUMMY frames.  */
 596   if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
 597       && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), 0, 0))
 598     return 1;
 599
 600   /* If the new frame pointer is zero, then it isn't valid.  */
 601   if (fp == 0)
 602     return 0;
 603
 604   /* If the new frame would be inside (younger than) the previous frame,
 605      then it isn't valid.  */
 606   if (INNER_THAN (fp, get_frame_base (fi)))
 607     return 0;
 608
 609   /* If the architecture has a custom DEPRECATED_FRAME_CHAIN_VALID,
 610      call it now.  */
 611   if (DEPRECATED_FRAME_CHAIN_VALID_P ())
 612     return DEPRECATED_FRAME_CHAIN_VALID (fp, fi);
 613
 614   /* If we're already inside the entry function for the main objfile, then it
 615      isn't valid.  */
 616   if (inside_entry_func (get_frame_pc (fi)))
 617     return 0;
 618
 619   /* If we're inside the entry file, it isn't valid.  */
 620   /* NOTE/drow 2002-12-25: should there be a way to disable this check?  It
 621      assumes a single small entry file, and the way some debug readers (e.g.
 622      dbxread) figure out which object is the entry file is somewhat hokey.  */
 623   if (deprecated_inside_entry_file (frame_pc_unwind (fi)))
 624       return 0;
 625
 626   return 1;
 627 }