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 (DEPRECATED_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 (DEPRECATED_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 (get_next_frame (frame) != 0
 217       && get_frame_type (get_next_frame (frame)) != 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 CORE_ADDR
 251 get_pc_function_start (CORE_ADDR pc)
 252 {
 253   register struct block *bl;
 254   register struct symbol *symbol;
 255   register struct minimal_symbol *msymbol;
 256   CORE_ADDR fstart;
 257
 258   if ((bl = block_for_pc (pc)) != NULL &&
 259       (symbol = block_function (bl)) != NULL)
 260     {
 261       bl = SYMBOL_BLOCK_VALUE (symbol);
 262       fstart = BLOCK_START (bl);
 263     }
 264   else if ((msymbol = lookup_minimal_symbol_by_pc (pc)) != NULL)
 265     {
 266       fstart = SYMBOL_VALUE_ADDRESS (msymbol);
 267       if (!find_pc_section (fstart))
 268         return 0;
 269     }
 270   else
 271     {
 272       fstart = 0;
 273     }
 274   return (fstart);
 275 }
 276
 277 /* Return the symbol for the function executing in frame FRAME.  */
 278
 279 struct symbol *
 280 get_frame_function (struct frame_info *frame)
 281 {
 282   register struct block *bl = get_frame_block (frame, 0);
 283   if (bl == 0)
 284     return 0;
 285   return block_function (bl);
 286 }
 287 \f
 288
 289 /* Return the blockvector immediately containing the innermost lexical block
 290    containing the specified pc value and section, or 0 if there is none.
 291    PINDEX is a pointer to the index value of the block.  If PINDEX
 292    is NULL, we don't pass this information back to the caller.  */
 293
 294 struct blockvector *
 295 blockvector_for_pc_sect (register CORE_ADDR pc, struct sec *section,
 296                          int *pindex, struct symtab *symtab)
 297 {
 298   register struct block *b;
 299   register int bot, top, half;
 300   struct blockvector *bl;
 301
 302   if (symtab == 0)              /* if no symtab specified by caller */
 303     {
 304       /* First search all symtabs for one whose file contains our pc */
 305       if ((symtab = find_pc_sect_symtab (pc, section)) == 0)
 306         return 0;
 307     }
 308
 309   bl = BLOCKVECTOR (symtab);
 310   b = BLOCKVECTOR_BLOCK (bl, 0);
 311
 312   /* Then search that symtab for the smallest block that wins.  */
 313   /* Use binary search to find the last block that starts before PC.  */
 314
 315   bot = 0;
 316   top = BLOCKVECTOR_NBLOCKS (bl);
 317
 318   while (top - bot > 1)
 319     {
 320       half = (top - bot + 1) >> 1;
 321       b = BLOCKVECTOR_BLOCK (bl, bot + half);
 322       if (BLOCK_START (b) <= pc)
 323         bot += half;
 324       else
 325         top = bot + half;
 326     }
 327
 328   /* Now search backward for a block that ends after PC.  */
 329
 330   while (bot >= 0)
 331     {
 332       b = BLOCKVECTOR_BLOCK (bl, bot);
 333       if (BLOCK_END (b) > pc)
 334         {
 335           if (pindex)
 336             *pindex = bot;
 337           return bl;
 338         }
 339       bot--;
 340     }
 341   return 0;
 342 }
 343
 344 /* Return the blockvector immediately containing the innermost lexical block
 345    containing the specified pc value, or 0 if there is none.
 346    Backward compatibility, no section.  */
 347
 348 struct blockvector *
 349 blockvector_for_pc (register CORE_ADDR pc, int *pindex)
 350 {
 351   return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
 352                                   pindex, NULL);
 353 }
 354
 355 /* Return the innermost lexical block containing the specified pc value
 356    in the specified section, or 0 if there is none.  */
 357
 358 struct block *
 359 block_for_pc_sect (register CORE_ADDR pc, struct sec *section)
 360 {
 361   register struct blockvector *bl;
 362   int index;
 363
 364   bl = blockvector_for_pc_sect (pc, section, &index, NULL);
 365   if (bl)
 366     return BLOCKVECTOR_BLOCK (bl, index);
 367   return 0;
 368 }
 369
 370 /* Return the innermost lexical block containing the specified pc value,
 371    or 0 if there is none.  Backward compatibility, no section.  */
 372
 373 struct block *
 374 block_for_pc (register CORE_ADDR pc)
 375 {
 376   return block_for_pc_sect (pc, find_pc_mapped_section (pc));
 377 }
 378
 379 /* Return the function containing pc value PC in section SECTION.
 380    Returns 0 if function is not known.  */
 381
 382 struct symbol *
 383 find_pc_sect_function (CORE_ADDR pc, struct sec *section)
 384 {
 385   register struct block *b = block_for_pc_sect (pc, section);
 386   if (b == 0)
 387     return 0;
 388   return block_function (b);
 389 }
 390
 391 /* Return the function containing pc value PC.
 392    Returns 0 if function is not known.  Backward compatibility, no section */
 393
 394 struct symbol *
 395 find_pc_function (CORE_ADDR pc)
 396 {
 397   return find_pc_sect_function (pc, find_pc_mapped_section (pc));
 398 }
 399
 400 /* These variables are used to cache the most recent result
 401  * of find_pc_partial_function. */
 402
 403 static CORE_ADDR cache_pc_function_low = 0;
 404 static CORE_ADDR cache_pc_function_high = 0;
 405 static char *cache_pc_function_name = 0;
 406 static struct sec *cache_pc_function_section = NULL;
 407
 408 /* Clear cache, e.g. when symbol table is discarded. */
 409
 410 void
 411 clear_pc_function_cache (void)
 412 {
 413   cache_pc_function_low = 0;
 414   cache_pc_function_high = 0;
 415   cache_pc_function_name = (char *) 0;
 416   cache_pc_function_section = NULL;
 417 }
 418
 419 /* Finds the "function" (text symbol) that is smaller than PC but
 420    greatest of all of the potential text symbols in SECTION.  Sets
 421    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
 422    If ENDADDR is non-null, then set *ENDADDR to be the end of the
 423    function (exclusive), but passing ENDADDR as non-null means that
 424    the function might cause symbols to be read.  This function either
 425    succeeds or fails (not halfway succeeds).  If it succeeds, it sets
 426    *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
 427    If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
 428    returns 0.  */
 429
 430 int
 431 find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
 432                                CORE_ADDR *address, CORE_ADDR *endaddr)
 433 {
 434   struct partial_symtab *pst;
 435   struct symbol *f;
 436   struct minimal_symbol *msymbol;
 437   struct partial_symbol *psb;
 438   struct obj_section *osect;
 439   int i;
 440   CORE_ADDR mapped_pc;
 441
 442   mapped_pc = overlay_mapped_address (pc, section);
 443
 444   if (mapped_pc >= cache_pc_function_low
 445       && mapped_pc < cache_pc_function_high
 446       && section == cache_pc_function_section)
 447     goto return_cached_value;
 448
 449   /* If sigtramp is in the u area, it counts as a function (especially
 450      important for step_1).  */
 451   if (SIGTRAMP_START_P () && PC_IN_SIGTRAMP (mapped_pc, (char *) NULL))
 452     {
 453       cache_pc_function_low = SIGTRAMP_START (mapped_pc);
 454       cache_pc_function_high = SIGTRAMP_END (mapped_pc);
 455       cache_pc_function_name = "<sigtramp>";
 456       cache_pc_function_section = section;
 457       goto return_cached_value;
 458     }
 459
 460   msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
 461   pst = find_pc_sect_psymtab (mapped_pc, section);
 462   if (pst)
 463     {
 464       /* Need to read the symbols to get a good value for the end address.  */
 465       if (endaddr != NULL && !pst->readin)
 466         {
 467           /* Need to get the terminal in case symbol-reading produces
 468              output.  */
 469           target_terminal_ours_for_output ();
 470           PSYMTAB_TO_SYMTAB (pst);
 471         }
 472
 473       if (pst->readin)
 474         {
 475           /* Checking whether the msymbol has a larger value is for the
 476              "pathological" case mentioned in print_frame_info.  */
 477           f = find_pc_sect_function (mapped_pc, section);
 478           if (f != NULL
 479               && (msymbol == NULL
 480                   || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
 481                       >= SYMBOL_VALUE_ADDRESS (msymbol))))
 482             {
 483               cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
 484               cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
 485               cache_pc_function_name = SYMBOL_NAME (f);
 486               cache_pc_function_section = section;
 487               goto return_cached_value;
 488             }
 489         }
 490       else
 491         {
 492           /* Now that static symbols go in the minimal symbol table, perhaps
 493              we could just ignore the partial symbols.  But at least for now
 494              we use the partial or minimal symbol, whichever is larger.  */
 495           psb = find_pc_sect_psymbol (pst, mapped_pc, section);
 496
 497           if (psb
 498               && (msymbol == NULL ||
 499                   (SYMBOL_VALUE_ADDRESS (psb)
 500                    >= SYMBOL_VALUE_ADDRESS (msymbol))))
 501             {
 502               /* This case isn't being cached currently. */
 503               if (address)
 504                 *address = SYMBOL_VALUE_ADDRESS (psb);
 505               if (name)
 506                 *name = SYMBOL_NAME (psb);
 507               /* endaddr non-NULL can't happen here.  */
 508               return 1;
 509             }
 510         }
 511     }
 512
 513   /* Not in the normal symbol tables, see if the pc is in a known section.
 514      If it's not, then give up.  This ensures that anything beyond the end
 515      of the text seg doesn't appear to be part of the last function in the
 516      text segment.  */
 517
 518   osect = find_pc_sect_section (mapped_pc, section);
 519
 520   if (!osect)
 521     msymbol = NULL;
 522
 523   /* Must be in the minimal symbol table.  */
 524   if (msymbol == NULL)
 525     {
 526       /* No available symbol.  */
 527       if (name != NULL)
 528         *name = 0;
 529       if (address != NULL)
 530         *address = 0;
 531       if (endaddr != NULL)
 532         *endaddr = 0;
 533       return 0;
 534     }
 535
 536   cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
 537   cache_pc_function_name = SYMBOL_NAME (msymbol);
 538   cache_pc_function_section = section;
 539
 540   /* Use the lesser of the next minimal symbol in the same section, or
 541      the end of the section, as the end of the function.  */
 542
 543   /* Step over other symbols at this same address, and symbols in
 544      other sections, to find the next symbol in this section with
 545      a different address.  */
 546
 547   for (i = 1; SYMBOL_NAME (msymbol + i) != NULL; i++)
 548     {
 549       if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
 550           && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
 551         break;
 552     }
 553
 554   if (SYMBOL_NAME (msymbol + i) != NULL
 555       && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
 556     cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
 557   else
 558     /* We got the start address from the last msymbol in the objfile.
 559        So the end address is the end of the section.  */
 560     cache_pc_function_high = osect->endaddr;
 561
 562  return_cached_value:
 563
 564   if (address)
 565     {
 566       if (pc_in_unmapped_range (pc, section))
 567         *address = overlay_unmapped_address (cache_pc_function_low, section);
 568       else
 569         *address = cache_pc_function_low;
 570     }
 571
 572   if (name)
 573     *name = cache_pc_function_name;
 574
 575   if (endaddr)
 576     {
 577       if (pc_in_unmapped_range (pc, section))
 578         {
 579           /* Because the high address is actually beyond the end of
 580              the function (and therefore possibly beyond the end of
 581              the overlay), we must actually convert (high - 1) and
 582              then add one to that. */
 583
 584           *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
 585                                                    section);
 586         }
 587       else
 588         *endaddr = cache_pc_function_high;
 589     }
 590
 591   return 1;
 592 }
 593
 594 /* Backward compatibility, no section argument.  */
 595
 596 int
 597 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
 598                           CORE_ADDR *endaddr)
 599 {
 600   asection *section;
 601
 602   section = find_pc_overlay (pc);
 603   return find_pc_sect_partial_function (pc, section, name, address, endaddr);
 604 }
 605
 606 /* Return the innermost stack frame executing inside of BLOCK,
 607    or NULL if there is no such frame.  If BLOCK is NULL, just return NULL.  */
 608
 609 struct frame_info *
 610 block_innermost_frame (struct block *block)
 611 {
 612   struct frame_info *frame;
 613   register CORE_ADDR start;
 614   register CORE_ADDR end;
 615   CORE_ADDR calling_pc;
 616
 617   if (block == NULL)
 618     return NULL;
 619
 620   start = BLOCK_START (block);
 621   end = BLOCK_END (block);
 622
 623   frame = NULL;
 624   while (1)
 625     {
 626       frame = get_prev_frame (frame);
 627       if (frame == NULL)
 628         return NULL;
 629       calling_pc = frame_address_in_block (frame);
 630       if (calling_pc >= start && calling_pc < end)
 631         return frame;
 632     }
 633 }
 634
 635 /* Are we in a call dummy?  The code below which allows DECR_PC_AFTER_BREAK
 636    below is for infrun.c, which may give the macro a pc without that
 637    subtracted out.  */
 638
 639 extern CORE_ADDR text_end;
 640
 641 int
 642 deprecated_pc_in_call_dummy_before_text_end (CORE_ADDR pc, CORE_ADDR sp,
 643                                              CORE_ADDR frame_address)
 644 {
 645   return ((pc) >= text_end - CALL_DUMMY_LENGTH
 646           && (pc) <= text_end + DECR_PC_AFTER_BREAK);
 647 }
 648
 649 int
 650 deprecated_pc_in_call_dummy_after_text_end (CORE_ADDR pc, CORE_ADDR sp,
 651                                             CORE_ADDR frame_address)
 652 {
 653   return ((pc) >= text_end
 654           && (pc) <= text_end + CALL_DUMMY_LENGTH + DECR_PC_AFTER_BREAK);
 655 }
 656
 657 /* Is the PC in a call dummy?  SP and FRAME_ADDRESS are the bottom and
 658    top of the stack frame which we are checking, where "bottom" and
 659    "top" refer to some section of memory which contains the code for
 660    the call dummy.  Calls to this macro assume that the contents of
 661    SP_REGNUM and FP_REGNUM (or the saved values thereof), respectively,
 662    are the things to pass.
 663
 664    This won't work on the 29k, where SP_REGNUM and FP_REGNUM don't
 665    have that meaning, but the 29k doesn't use ON_STACK.  This could be
 666    fixed by generalizing this scheme, perhaps by passing in a frame
 667    and adding a few fields, at least on machines which need them for
 668    DEPRECATED_PC_IN_CALL_DUMMY.
 669
 670    Something simpler, like checking for the stack segment, doesn't work,
 671    since various programs (threads implementations, gcc nested function
 672    stubs, etc) may either allocate stack frames in another segment, or
 673    allocate other kinds of code on the stack.  */
 674
 675 int
 676 deprecated_pc_in_call_dummy_on_stack (CORE_ADDR pc, CORE_ADDR sp,
 677                                       CORE_ADDR frame_address)
 678 {
 679   return (INNER_THAN ((sp), (pc))
 680           && (frame_address != 0)
 681           && INNER_THAN ((pc), (frame_address)));
 682 }
 683
 684 int
 685 deprecated_pc_in_call_dummy_at_entry_point (CORE_ADDR pc, CORE_ADDR sp,
 686                                             CORE_ADDR frame_address)
 687 {
 688   return ((pc) >= CALL_DUMMY_ADDRESS ()
 689           && (pc) <= (CALL_DUMMY_ADDRESS () + DECR_PC_AFTER_BREAK));
 690 }
 691
 692
 693 /* Function: frame_chain_valid
 694    Returns true for a user frame or a call_function_by_hand dummy frame,
 695    and false for the CRT0 start-up frame.  Purpose is to terminate backtrace */
 696
 697 int
 698 generic_file_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
 699 {
 700   if (DEPRECATED_PC_IN_CALL_DUMMY (frame_pc_unwind (fi), fp, fp))
 701     return 1;                   /* don't prune CALL_DUMMY frames */
 702   else                          /* fall back to default algorithm (see frame.h) */
 703     return (fp != 0
 704             && (INNER_THAN (get_frame_base (fi), fp)
 705                 || get_frame_base (fi) == fp)
 706             && !inside_entry_file (frame_pc_unwind (fi)));
 707 }
 708
 709 int
 710 generic_func_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
 711 {
 712   if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
 713       && DEPRECATED_PC_IN_CALL_DUMMY ((fi)->pc, 0, 0))
 714     return 1;                   /* don't prune CALL_DUMMY frames */
 715   else                          /* fall back to default algorithm (see frame.h) */
 716     return (fp != 0
 717             && (INNER_THAN (get_frame_base (fi), fp)
 718                 || get_frame_base (fi) == fp)
 719             && !inside_main_func ((fi)->pc)
 720             && !inside_entry_func ((fi)->pc));
 721 }
 722