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