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