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