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