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 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
  40 /* Prototypes for exported functions. */
  41
  42 void _initialize_blockframe (void);
  43
  44 /* A default FRAME_CHAIN_VALID, in the form that is suitable for most
  45    targets.  If FRAME_CHAIN_VALID returns zero it means that the given
  46    frame is the outermost one and has no caller. */
  47
  48 int
  49 file_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
  50 {
  51   return ((chain) != 0
  52           && !inside_entry_file (frame_pc_unwind (thisframe)));
  53 }
  54
  55 /* Use the alternate method of avoiding running up off the end of the
  56    frame chain or following frames back into the startup code.  See
  57    the comments in objfiles.h. */
  58
  59 int
  60 func_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
  61 {
  62   return ((chain) != 0
  63           && !inside_main_func ((thisframe)->pc)
  64           && !inside_entry_func ((thisframe)->pc));
  65 }
  66
  67 /* A very simple method of determining a valid frame */
  68
  69 int
  70 nonnull_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
  71 {
  72   return ((chain) != 0);
  73 }
  74
  75 /* Is ADDR inside the startup file?  Note that if your machine
  76    has a way to detect the bottom of the stack, there is no need
  77    to call this function from FRAME_CHAIN_VALID; the reason for
  78    doing so is that some machines have no way of detecting bottom
  79    of stack.
  80
  81    A PC of zero is always considered to be the bottom of the stack. */
  82
  83 int
  84 inside_entry_file (CORE_ADDR addr)
  85 {
  86   if (addr == 0)
  87     return 1;
  88   if (symfile_objfile == 0)
  89     return 0;
  90   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
  91     {
  92       /* Do not stop backtracing if the pc is in the call dummy
  93          at the entry point.  */
  94       /* FIXME: Won't always work with zeros for the last two arguments */
  95       if (PC_IN_CALL_DUMMY (addr, 0, 0))
  96         return 0;
  97     }
  98   return (addr >= symfile_objfile->ei.entry_file_lowpc &&
  99           addr < symfile_objfile->ei.entry_file_highpc);
 100 }
 101
 102 /* Test a specified PC value to see if it is in the range of addresses
 103    that correspond to the main() function.  See comments above for why
 104    we might want to do this.
 105
 106    Typically called from FRAME_CHAIN_VALID.
 107
 108    A PC of zero is always considered to be the bottom of the stack. */
 109
 110 int
 111 inside_main_func (CORE_ADDR pc)
 112 {
 113   if (pc == 0)
 114     return 1;
 115   if (symfile_objfile == 0)
 116     return 0;
 117
 118   /* If the addr range is not set up at symbol reading time, set it up now.
 119      This is for FRAME_CHAIN_VALID_ALTERNATE. I do this for coff, because
 120      it is unable to set it up and symbol reading time. */
 121
 122   if (symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC &&
 123       symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
 124     {
 125       struct symbol *mainsym;
 126
 127       mainsym = lookup_symbol (main_name (), NULL, VAR_NAMESPACE, NULL, NULL);
 128       if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK)
 129         {
 130           symfile_objfile->ei.main_func_lowpc =
 131             BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
 132           symfile_objfile->ei.main_func_highpc =
 133             BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
 134         }
 135     }
 136   return (symfile_objfile->ei.main_func_lowpc <= pc &&
 137           symfile_objfile->ei.main_func_highpc > pc);
 138 }
 139
 140 /* Test a specified PC value to see if it is in the range of addresses
 141    that correspond to the process entry point function.  See comments
 142    in objfiles.h for why we might want to do this.
 143
 144    Typically called from FRAME_CHAIN_VALID.
 145
 146    A PC of zero is always considered to be the bottom of the stack. */
 147
 148 int
 149 inside_entry_func (CORE_ADDR pc)
 150 {
 151   if (pc == 0)
 152     return 1;
 153   if (symfile_objfile == 0)
 154     return 0;
 155   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
 156     {
 157       /* Do not stop backtracing if the pc is in the call dummy
 158          at the entry point.  */
 159       /* FIXME: Won't always work with zeros for the last two arguments */
 160       if (PC_IN_CALL_DUMMY (pc, 0, 0))
 161         return 0;
 162     }
 163   return (symfile_objfile->ei.entry_func_lowpc <= pc &&
 164           symfile_objfile->ei.entry_func_highpc > pc);
 165 }
 166
 167 /* Return nonzero if the function for this frame lacks a prologue.  Many
 168    machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
 169    function.  */
 170
 171 int
 172 frameless_look_for_prologue (struct frame_info *frame)
 173 {
 174   CORE_ADDR func_start, after_prologue;
 175
 176   func_start = get_pc_function_start (frame->pc);
 177   if (func_start)
 178     {
 179       func_start += FUNCTION_START_OFFSET;
 180       /* This is faster, since only care whether there *is* a
 181          prologue, not how long it is.  */
 182       return PROLOGUE_FRAMELESS_P (func_start);
 183     }
 184   else if (frame->pc == 0)
 185     /* A frame with a zero PC is usually created by dereferencing a
 186        NULL function pointer, normally causing an immediate core dump
 187        of the inferior. Mark function as frameless, as the inferior
 188        has no chance of setting up a stack frame.  */
 189     return 1;
 190   else
 191     /* If we can't find the start of the function, we don't really
 192        know whether the function is frameless, but we should be able
 193        to get a reasonable (i.e. best we can do under the
 194        circumstances) backtrace by saying that it isn't.  */
 195     return 0;
 196 }
 197
 198 /* return the address of the PC for the given FRAME, ie the current PC value
 199    if FRAME is the innermost frame, or the address adjusted to point to the
 200    call instruction if not.  */
 201
 202 CORE_ADDR
 203 frame_address_in_block (struct frame_info *frame)
 204 {
 205   CORE_ADDR pc = frame->pc;
 206
 207   /* If we are not in the innermost frame, and we are not interrupted
 208      by a signal, frame->pc points to the instruction following the
 209      call. As a consequence, we need to get the address of the previous
 210      instruction. Unfortunately, this is not straightforward to do, so
 211      we just use the address minus one, which is a good enough
 212      approximation.  */
 213   /* FIXME: cagney/2002-11-10: Should this instead test for
 214      NORMAL_FRAME?  A dummy frame (in fact all the abnormal frames)
 215      save the PC value in the block.  */
 216   if (frame->next != 0
 217       && get_frame_type (frame->next) != SIGTRAMP_FRAME)
 218     --pc;
 219
 220   return pc;
 221 }
 222
 223 /* Return the innermost lexical block in execution
 224    in a specified stack frame.  The frame address is assumed valid.
 225
 226    If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
 227    address we used to choose the block.  We use this to find a source
 228    line, to decide which macro definitions are in scope.
 229
 230    The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
 231    PC, and may not really be a valid PC at all.  For example, in the
 232    caller of a function declared to never return, the code at the
 233    return address will never be reached, so the call instruction may
 234    be the very last instruction in the block.  So the address we use
 235    to choose the block is actually one byte before the return address
 236    --- hopefully pointing us at the call instruction, or its delay
 237    slot instruction.  */
 238
 239 struct block *
 240 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
 241 {
 242   const CORE_ADDR pc = frame_address_in_block (frame);
 243
 244   if (addr_in_block)
 245     *addr_in_block = pc;
 246
 247   return block_for_pc (pc);
 248 }
 249
 250 struct block *
 251 get_current_block (CORE_ADDR *addr_in_block)
 252 {
 253   CORE_ADDR pc = read_pc ();
 254
 255   if (addr_in_block)
 256     *addr_in_block = pc;
 257
 258   return block_for_pc (pc);
 259 }
 260
 261 CORE_ADDR
 262 get_pc_function_start (CORE_ADDR pc)
 263 {
 264   register struct block *bl;
 265   register struct symbol *symbol;
 266   register struct minimal_symbol *msymbol;
 267   CORE_ADDR fstart;
 268
 269   if ((bl = block_for_pc (pc)) != NULL &&
 270       (symbol = block_function (bl)) != NULL)
 271     {
 272       bl = SYMBOL_BLOCK_VALUE (symbol);
 273       fstart = BLOCK_START (bl);
 274     }
 275   else if ((msymbol = lookup_minimal_symbol_by_pc (pc)) != NULL)
 276     {
 277       fstart = SYMBOL_VALUE_ADDRESS (msymbol);
 278       if (!find_pc_section (fstart))
 279         return 0;
 280     }
 281   else
 282     {
 283       fstart = 0;
 284     }
 285   return (fstart);
 286 }
 287
 288 /* Return the symbol for the function executing in frame FRAME.  */
 289
 290 struct symbol *
 291 get_frame_function (struct frame_info *frame)
 292 {
 293   register struct block *bl = get_frame_block (frame, 0);
 294   if (bl == 0)
 295     return 0;
 296   return block_function (bl);
 297 }
 298 \f
 299
 300 /* Return the blockvector immediately containing the innermost lexical block
 301    containing the specified pc value and section, or 0 if there is none.
 302    PINDEX is a pointer to the index value of the block.  If PINDEX
 303    is NULL, we don't pass this information back to the caller.  */
 304
 305 struct blockvector *
 306 blockvector_for_pc_sect (register CORE_ADDR pc, struct sec *section,
 307                          int *pindex, struct symtab *symtab)
 308 {
 309   register struct block *b;
 310   register int bot, top, half;
 311   struct blockvector *bl;
 312
 313   if (symtab == 0)              /* if no symtab specified by caller */
 314     {
 315       /* First search all symtabs for one whose file contains our pc */
 316       if ((symtab = find_pc_sect_symtab (pc, section)) == 0)
 317         return 0;
 318     }
 319
 320   bl = BLOCKVECTOR (symtab);
 321   b = BLOCKVECTOR_BLOCK (bl, 0);
 322
 323   /* Then search that symtab for the smallest block that wins.  */
 324   /* Use binary search to find the last block that starts before PC.  */
 325
 326   bot = 0;
 327   top = BLOCKVECTOR_NBLOCKS (bl);
 328
 329   while (top - bot > 1)
 330     {
 331       half = (top - bot + 1) >> 1;
 332       b = BLOCKVECTOR_BLOCK (bl, bot + half);
 333       if (BLOCK_START (b) <= pc)
 334         bot += half;
 335       else
 336         top = bot + half;
 337     }
 338
 339   /* Now search backward for a block that ends after PC.  */
 340
 341   while (bot >= 0)
 342     {
 343       b = BLOCKVECTOR_BLOCK (bl, bot);
 344       if (BLOCK_END (b) > pc)
 345         {
 346           if (pindex)
 347             *pindex = bot;
 348           return bl;
 349         }
 350       bot--;
 351     }
 352   return 0;
 353 }
 354
 355 /* Return the blockvector immediately containing the innermost lexical block
 356    containing the specified pc value, or 0 if there is none.
 357    Backward compatibility, no section.  */
 358
 359 struct blockvector *
 360 blockvector_for_pc (register CORE_ADDR pc, int *pindex)
 361 {
 362   return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
 363                                   pindex, NULL);
 364 }
 365
 366 /* Return the innermost lexical block containing the specified pc value
 367    in the specified section, or 0 if there is none.  */
 368
 369 struct block *
 370 block_for_pc_sect (register CORE_ADDR pc, struct sec *section)
 371 {
 372   register struct blockvector *bl;
 373   int index;
 374
 375   bl = blockvector_for_pc_sect (pc, section, &index, NULL);
 376   if (bl)
 377     return BLOCKVECTOR_BLOCK (bl, index);
 378   return 0;
 379 }
 380
 381 /* Return the innermost lexical block containing the specified pc value,
 382    or 0 if there is none.  Backward compatibility, no section.  */
 383
 384 struct block *
 385 block_for_pc (register CORE_ADDR pc)
 386 {
 387   return block_for_pc_sect (pc, find_pc_mapped_section (pc));
 388 }
 389
 390 /* Return the function containing pc value PC in section SECTION.
 391    Returns 0 if function is not known.  */
 392
 393 struct symbol *
 394 find_pc_sect_function (CORE_ADDR pc, struct sec *section)
 395 {
 396   register struct block *b = block_for_pc_sect (pc, section);
 397   if (b == 0)
 398     return 0;
 399   return block_function (b);
 400 }
 401
 402 /* Return the function containing pc value PC.
 403    Returns 0 if function is not known.  Backward compatibility, no section */
 404
 405 struct symbol *
 406 find_pc_function (CORE_ADDR pc)
 407 {
 408   return find_pc_sect_function (pc, find_pc_mapped_section (pc));
 409 }
 410
 411 /* These variables are used to cache the most recent result
 412  * of find_pc_partial_function. */
 413
 414 static CORE_ADDR cache_pc_function_low = 0;
 415 static CORE_ADDR cache_pc_function_high = 0;
 416 static char *cache_pc_function_name = 0;
 417 static struct sec *cache_pc_function_section = NULL;
 418
 419 /* Clear cache, e.g. when symbol table is discarded. */
 420
 421 void
 422 clear_pc_function_cache (void)
 423 {
 424   cache_pc_function_low = 0;
 425   cache_pc_function_high = 0;
 426   cache_pc_function_name = (char *) 0;
 427   cache_pc_function_section = NULL;
 428 }
 429
 430 /* Finds the "function" (text symbol) that is smaller than PC but
 431    greatest of all of the potential text symbols in SECTION.  Sets
 432    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
 433    If ENDADDR is non-null, then set *ENDADDR to be the end of the
 434    function (exclusive), but passing ENDADDR as non-null means that
 435    the function might cause symbols to be read.  This function either
 436    succeeds or fails (not halfway succeeds).  If it succeeds, it sets
 437    *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
 438    If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
 439    returns 0.  */
 440
 441 int
 442 find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
 443                                CORE_ADDR *address, CORE_ADDR *endaddr)
 444 {
 445   struct partial_symtab *pst;
 446   struct symbol *f;
 447   struct minimal_symbol *msymbol;
 448   struct partial_symbol *psb;
 449   struct obj_section *osect;
 450   int i;
 451   CORE_ADDR mapped_pc;
 452
 453   mapped_pc = overlay_mapped_address (pc, section);
 454
 455   if (mapped_pc >= cache_pc_function_low
 456       && mapped_pc < cache_pc_function_high
 457       && section == cache_pc_function_section)
 458     goto return_cached_value;
 459
 460   /* If sigtramp is in the u area, it counts as a function (especially
 461      important for step_1).  */
 462   if (SIGTRAMP_START_P () && PC_IN_SIGTRAMP (mapped_pc, (char *) NULL))
 463     {
 464       cache_pc_function_low = SIGTRAMP_START (mapped_pc);
 465       cache_pc_function_high = SIGTRAMP_END (mapped_pc);
 466       cache_pc_function_name = "<sigtramp>";
 467       cache_pc_function_section = section;
 468       goto return_cached_value;
 469     }
 470
 471   msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
 472   pst = find_pc_sect_psymtab (mapped_pc, section);
 473   if (pst)
 474     {
 475       /* Need to read the symbols to get a good value for the end address.  */
 476       if (endaddr != NULL && !pst->readin)
 477         {
 478           /* Need to get the terminal in case symbol-reading produces
 479              output.  */
 480           target_terminal_ours_for_output ();
 481           PSYMTAB_TO_SYMTAB (pst);
 482         }
 483
 484       if (pst->readin)
 485         {
 486           /* Checking whether the msymbol has a larger value is for the
 487              "pathological" case mentioned in print_frame_info.  */
 488           f = find_pc_sect_function (mapped_pc, section);
 489           if (f != NULL
 490               && (msymbol == NULL
 491                   || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
 492                       >= SYMBOL_VALUE_ADDRESS (msymbol))))
 493             {
 494               cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
 495               cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
 496               cache_pc_function_name = SYMBOL_NAME (f);
 497               cache_pc_function_section = section;
 498               goto return_cached_value;
 499             }
 500         }
 501       else
 502         {
 503           /* Now that static symbols go in the minimal symbol table, perhaps
 504              we could just ignore the partial symbols.  But at least for now
 505              we use the partial or minimal symbol, whichever is larger.  */
 506           psb = find_pc_sect_psymbol (pst, mapped_pc, section);
 507
 508           if (psb
 509               && (msymbol == NULL ||
 510                   (SYMBOL_VALUE_ADDRESS (psb)
 511                    >= SYMBOL_VALUE_ADDRESS (msymbol))))
 512             {
 513               /* This case isn't being cached currently. */
 514               if (address)
 515                 *address = SYMBOL_VALUE_ADDRESS (psb);
 516               if (name)
 517                 *name = SYMBOL_NAME (psb);
 518               /* endaddr non-NULL can't happen here.  */
 519               return 1;
 520             }
 521         }
 522     }
 523
 524   /* Not in the normal symbol tables, see if the pc is in a known section.
 525      If it's not, then give up.  This ensures that anything beyond the end
 526      of the text seg doesn't appear to be part of the last function in the
 527      text segment.  */
 528
 529   osect = find_pc_sect_section (mapped_pc, section);
 530
 531   if (!osect)
 532     msymbol = NULL;
 533
 534   /* Must be in the minimal symbol table.  */
 535   if (msymbol == NULL)
 536     {
 537       /* No available symbol.  */
 538       if (name != NULL)
 539         *name = 0;
 540       if (address != NULL)
 541         *address = 0;
 542       if (endaddr != NULL)
 543         *endaddr = 0;
 544       return 0;
 545     }
 546
 547   cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
 548   cache_pc_function_name = SYMBOL_NAME (msymbol);
 549   cache_pc_function_section = section;
 550
 551   /* Use the lesser of the next minimal symbol in the same section, or
 552      the end of the section, as the end of the function.  */
 553
 554   /* Step over other symbols at this same address, and symbols in
 555      other sections, to find the next symbol in this section with
 556      a different address.  */
 557
 558   for (i = 1; SYMBOL_NAME (msymbol + i) != NULL; i++)
 559     {
 560       if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
 561           && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
 562         break;
 563     }
 564
 565   if (SYMBOL_NAME (msymbol + i) != NULL
 566       && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
 567     cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
 568   else
 569     /* We got the start address from the last msymbol in the objfile.
 570        So the end address is the end of the section.  */
 571     cache_pc_function_high = osect->endaddr;
 572
 573  return_cached_value:
 574
 575   if (address)
 576     {
 577       if (pc_in_unmapped_range (pc, section))
 578         *address = overlay_unmapped_address (cache_pc_function_low, section);
 579       else
 580         *address = cache_pc_function_low;
 581     }
 582
 583   if (name)
 584     *name = cache_pc_function_name;
 585
 586   if (endaddr)
 587     {
 588       if (pc_in_unmapped_range (pc, section))
 589         {
 590           /* Because the high address is actually beyond the end of
 591              the function (and therefore possibly beyond the end of
 592              the overlay), we must actually convert (high - 1) and
 593              then add one to that. */
 594
 595           *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
 596                                                    section);
 597         }
 598       else
 599         *endaddr = cache_pc_function_high;
 600     }
 601
 602   return 1;
 603 }
 604
 605 /* Backward compatibility, no section argument.  */
 606
 607 int
 608 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
 609                           CORE_ADDR *endaddr)
 610 {
 611   asection *section;
 612
 613   section = find_pc_overlay (pc);
 614   return find_pc_sect_partial_function (pc, section, name, address, endaddr);
 615 }
 616
 617 /* Return the innermost stack frame executing inside of BLOCK,
 618    or NULL if there is no such frame.  If BLOCK is NULL, just return NULL.  */
 619
 620 struct frame_info *
 621 block_innermost_frame (struct block *block)
 622 {
 623   struct frame_info *frame;
 624   register CORE_ADDR start;
 625   register CORE_ADDR end;
 626   CORE_ADDR calling_pc;
 627
 628   if (block == NULL)
 629     return NULL;
 630
 631   start = BLOCK_START (block);
 632   end = BLOCK_END (block);
 633
 634   frame = NULL;
 635   while (1)
 636     {
 637       frame = get_prev_frame (frame);
 638       if (frame == NULL)
 639         return NULL;
 640       calling_pc = frame_address_in_block (frame);
 641       if (calling_pc >= start && calling_pc < end)
 642         return frame;
 643     }
 644 }
 645
 646 /* Return the full FRAME which corresponds to the given CORE_ADDR
 647    or NULL if no FRAME on the chain corresponds to CORE_ADDR.  */
 648
 649 struct frame_info *
 650 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
 651 {
 652   struct frame_info *frame = NULL;
 653
 654   if (frame_addr == (CORE_ADDR) 0)
 655     return NULL;
 656
 657   while (1)
 658     {
 659       frame = get_prev_frame (frame);
 660       if (frame == NULL)
 661         return NULL;
 662       if (FRAME_FP (frame) == frame_addr)
 663         return frame;
 664     }
 665 }
 666
 667 /* Are we in a call dummy?  The code below which allows DECR_PC_AFTER_BREAK
 668    below is for infrun.c, which may give the macro a pc without that
 669    subtracted out.  */
 670
 671 extern CORE_ADDR text_end;
 672
 673 int
 674 pc_in_call_dummy_before_text_end (CORE_ADDR pc, CORE_ADDR sp,
 675                                   CORE_ADDR frame_address)
 676 {
 677   return ((pc) >= text_end - CALL_DUMMY_LENGTH
 678           && (pc) <= text_end + DECR_PC_AFTER_BREAK);
 679 }
 680
 681 int
 682 pc_in_call_dummy_after_text_end (CORE_ADDR pc, CORE_ADDR sp,
 683                                  CORE_ADDR frame_address)
 684 {
 685   return ((pc) >= text_end
 686           && (pc) <= text_end + CALL_DUMMY_LENGTH + DECR_PC_AFTER_BREAK);
 687 }
 688
 689 /* Is the PC in a call dummy?  SP and FRAME_ADDRESS are the bottom and
 690    top of the stack frame which we are checking, where "bottom" and
 691    "top" refer to some section of memory which contains the code for
 692    the call dummy.  Calls to this macro assume that the contents of
 693    SP_REGNUM and FP_REGNUM (or the saved values thereof), respectively,
 694    are the things to pass.
 695
 696    This won't work on the 29k, where SP_REGNUM and FP_REGNUM don't
 697    have that meaning, but the 29k doesn't use ON_STACK.  This could be
 698    fixed by generalizing this scheme, perhaps by passing in a frame
 699    and adding a few fields, at least on machines which need them for
 700    PC_IN_CALL_DUMMY.
 701
 702    Something simpler, like checking for the stack segment, doesn't work,
 703    since various programs (threads implementations, gcc nested function
 704    stubs, etc) may either allocate stack frames in another segment, or
 705    allocate other kinds of code on the stack.  */
 706
 707 int
 708 pc_in_call_dummy_on_stack (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
 709 {
 710   return (INNER_THAN ((sp), (pc))
 711           && (frame_address != 0)
 712           && INNER_THAN ((pc), (frame_address)));
 713 }
 714
 715 int
 716 pc_in_call_dummy_at_entry_point (CORE_ADDR pc, CORE_ADDR sp,
 717                                  CORE_ADDR frame_address)
 718 {
 719   return ((pc) >= CALL_DUMMY_ADDRESS ()
 720           && (pc) <= (CALL_DUMMY_ADDRESS () + DECR_PC_AFTER_BREAK));
 721 }
 722
 723
 724 /* Function: frame_chain_valid
 725    Returns true for a user frame or a call_function_by_hand dummy frame,
 726    and false for the CRT0 start-up frame.  Purpose is to terminate backtrace */
 727
 728 int
 729 generic_file_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
 730 {
 731   if (PC_IN_CALL_DUMMY (frame_pc_unwind (fi), fp, fp))
 732     return 1;                   /* don't prune CALL_DUMMY frames */
 733   else                          /* fall back to default algorithm (see frame.h) */
 734     return (fp != 0
 735             && (INNER_THAN (fi->frame, fp) || fi->frame == fp)
 736             && !inside_entry_file (frame_pc_unwind (fi)));
 737 }
 738
 739 int
 740 generic_func_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
 741 {
 742   if (USE_GENERIC_DUMMY_FRAMES
 743       && PC_IN_CALL_DUMMY ((fi)->pc, 0, 0))
 744     return 1;                   /* don't prune CALL_DUMMY frames */
 745   else                          /* fall back to default algorithm (see frame.h) */
 746     return (fp != 0
 747             && (INNER_THAN (fi->frame, fp) || fi->frame == fp)
 748             && !inside_main_func ((fi)->pc)
 749             && !inside_entry_func ((fi)->pc));
 750 }
 751