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       /* This is faster, since only care whether there *is* a
 203          prologue, not how long it is.  */
 204       return PROLOGUE_FRAMELESS_P (func_start);
 205     }
 206   else if (get_frame_pc (frame) == 0)
 207     /* A frame with a zero PC is usually created by dereferencing a
 208        NULL function pointer, normally causing an immediate core dump
 209        of the inferior. Mark function as frameless, as the inferior
 210        has no chance of setting up a stack frame.  */
 211     return 1;
 212   else
 213     /* If we can't find the start of the function, we don't really
 214        know whether the function is frameless, but we should be able
 215        to get a reasonable (i.e. best we can do under the
 216        circumstances) backtrace by saying that it isn't.  */
 217     return 0;
 218 }
 219
 220 /* Return the innermost lexical block in execution
 221    in a specified stack frame.  The frame address is assumed valid.
 222
 223    If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
 224    address we used to choose the block.  We use this to find a source
 225    line, to decide which macro definitions are in scope.
 226
 227    The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
 228    PC, and may not really be a valid PC at all.  For example, in the
 229    caller of a function declared to never return, the code at the
 230    return address will never be reached, so the call instruction may
 231    be the very last instruction in the block.  So the address we use
 232    to choose the block is actually one byte before the return address
 233    --- hopefully pointing us at the call instruction, or its delay
 234    slot instruction.  */
 235
 236 struct block *
 237 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
 238 {
 239   const CORE_ADDR pc = get_frame_address_in_block (frame);
 240
 241   if (addr_in_block)
 242     *addr_in_block = pc;
 243
 244   return block_for_pc (pc);
 245 }
 246
 247 CORE_ADDR
 248 get_pc_function_start (CORE_ADDR pc)
 249 {
 250   struct block *bl;
 251   struct minimal_symbol *msymbol;
 252
 253   bl = block_for_pc (pc);
 254   if (bl)
 255     {
 256       struct symbol *symbol = block_function (bl);
 257
 258       if (symbol)
 259         {
 260           bl = SYMBOL_BLOCK_VALUE (symbol);
 261           return BLOCK_START (bl);
 262         }
 263     }
 264
 265   msymbol = lookup_minimal_symbol_by_pc (pc);
 266   if (msymbol)
 267     {
 268       CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
 269
 270       if (find_pc_section (fstart))
 271         return fstart;
 272     }
 273
 274   return 0;
 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   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 function containing pc value PC in section SECTION.
 290    Returns 0 if function is not known.  */
 291
 292 struct symbol *
 293 find_pc_sect_function (CORE_ADDR pc, struct bfd_section *section)
 294 {
 295   struct block *b = block_for_pc_sect (pc, section);
 296   if (b == 0)
 297     return 0;
 298   return block_function (b);
 299 }
 300
 301 /* Return the function containing pc value PC.
 302    Returns 0 if function is not known.  Backward compatibility, no section */
 303
 304 struct symbol *
 305 find_pc_function (CORE_ADDR pc)
 306 {
 307   return find_pc_sect_function (pc, find_pc_mapped_section (pc));
 308 }
 309
 310 /* These variables are used to cache the most recent result
 311  * of find_pc_partial_function. */
 312
 313 static CORE_ADDR cache_pc_function_low = 0;
 314 static CORE_ADDR cache_pc_function_high = 0;
 315 static char *cache_pc_function_name = 0;
 316 static struct bfd_section *cache_pc_function_section = NULL;
 317
 318 /* Clear cache, e.g. when symbol table is discarded. */
 319
 320 void
 321 clear_pc_function_cache (void)
 322 {
 323   cache_pc_function_low = 0;
 324   cache_pc_function_high = 0;
 325   cache_pc_function_name = (char *) 0;
 326   cache_pc_function_section = NULL;
 327 }
 328
 329 /* Finds the "function" (text symbol) that is smaller than PC but
 330    greatest of all of the potential text symbols in SECTION.  Sets
 331    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
 332    If ENDADDR is non-null, then set *ENDADDR to be the end of the
 333    function (exclusive), but passing ENDADDR as non-null means that
 334    the function might cause symbols to be read.  This function either
 335    succeeds or fails (not halfway succeeds).  If it succeeds, it sets
 336    *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
 337    If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
 338    returns 0.  */
 339
 340 int
 341 find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
 342                                CORE_ADDR *address, CORE_ADDR *endaddr)
 343 {
 344   struct partial_symtab *pst;
 345   struct symbol *f;
 346   struct minimal_symbol *msymbol;
 347   struct partial_symbol *psb;
 348   struct obj_section *osect;
 349   int i;
 350   CORE_ADDR mapped_pc;
 351
 352   mapped_pc = overlay_mapped_address (pc, section);
 353
 354   if (mapped_pc >= cache_pc_function_low
 355       && mapped_pc < cache_pc_function_high
 356       && section == cache_pc_function_section)
 357     goto return_cached_value;
 358
 359   /* If sigtramp is in the u area, it counts as a function (especially
 360      important for step_1).  */
 361   if (SIGTRAMP_START_P () && PC_IN_SIGTRAMP (mapped_pc, (char *) NULL))
 362     {
 363       cache_pc_function_low = SIGTRAMP_START (mapped_pc);
 364       cache_pc_function_high = SIGTRAMP_END (mapped_pc);
 365       cache_pc_function_name = "<sigtramp>";
 366       cache_pc_function_section = section;
 367       goto return_cached_value;
 368     }
 369
 370   msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
 371   pst = find_pc_sect_psymtab (mapped_pc, section);
 372   if (pst)
 373     {
 374       /* Need to read the symbols to get a good value for the end address.  */
 375       if (endaddr != NULL && !pst->readin)
 376         {
 377           /* Need to get the terminal in case symbol-reading produces
 378              output.  */
 379           target_terminal_ours_for_output ();
 380           PSYMTAB_TO_SYMTAB (pst);
 381         }
 382
 383       if (pst->readin)
 384         {
 385           /* Checking whether the msymbol has a larger value is for the
 386              "pathological" case mentioned in print_frame_info.  */
 387           f = find_pc_sect_function (mapped_pc, section);
 388           if (f != NULL
 389               && (msymbol == NULL
 390                   || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
 391                       >= SYMBOL_VALUE_ADDRESS (msymbol))))
 392             {
 393               cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
 394               cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
 395               cache_pc_function_name = DEPRECATED_SYMBOL_NAME (f);
 396               cache_pc_function_section = section;
 397               goto return_cached_value;
 398             }
 399         }
 400       else
 401         {
 402           /* Now that static symbols go in the minimal symbol table, perhaps
 403              we could just ignore the partial symbols.  But at least for now
 404              we use the partial or minimal symbol, whichever is larger.  */
 405           psb = find_pc_sect_psymbol (pst, mapped_pc, section);
 406
 407           if (psb
 408               && (msymbol == NULL ||
 409                   (SYMBOL_VALUE_ADDRESS (psb)
 410                    >= SYMBOL_VALUE_ADDRESS (msymbol))))
 411             {
 412               /* This case isn't being cached currently. */
 413               if (address)
 414                 *address = SYMBOL_VALUE_ADDRESS (psb);
 415               if (name)
 416                 *name = DEPRECATED_SYMBOL_NAME (psb);
 417               /* endaddr non-NULL can't happen here.  */
 418               return 1;
 419             }
 420         }
 421     }
 422
 423   /* Not in the normal symbol tables, see if the pc is in a known section.
 424      If it's not, then give up.  This ensures that anything beyond the end
 425      of the text seg doesn't appear to be part of the last function in the
 426      text segment.  */
 427
 428   osect = find_pc_sect_section (mapped_pc, section);
 429
 430   if (!osect)
 431     msymbol = NULL;
 432
 433   /* Must be in the minimal symbol table.  */
 434   if (msymbol == NULL)
 435     {
 436       /* No available symbol.  */
 437       if (name != NULL)
 438         *name = 0;
 439       if (address != NULL)
 440         *address = 0;
 441       if (endaddr != NULL)
 442         *endaddr = 0;
 443       return 0;
 444     }
 445
 446   cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
 447   cache_pc_function_name = DEPRECATED_SYMBOL_NAME (msymbol);
 448   cache_pc_function_section = section;
 449
 450   /* Use the lesser of the next minimal symbol in the same section, or
 451      the end of the section, as the end of the function.  */
 452
 453   /* Step over other symbols at this same address, and symbols in
 454      other sections, to find the next symbol in this section with
 455      a different address.  */
 456
 457   for (i = 1; DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL; i++)
 458     {
 459       if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
 460           && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
 461         break;
 462     }
 463
 464   if (DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL
 465       && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
 466     cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
 467   else
 468     /* We got the start address from the last msymbol in the objfile.
 469        So the end address is the end of the section.  */
 470     cache_pc_function_high = osect->endaddr;
 471
 472  return_cached_value:
 473
 474   if (address)
 475     {
 476       if (pc_in_unmapped_range (pc, section))
 477         *address = overlay_unmapped_address (cache_pc_function_low, section);
 478       else
 479         *address = cache_pc_function_low;
 480     }
 481
 482   if (name)
 483     *name = cache_pc_function_name;
 484
 485   if (endaddr)
 486     {
 487       if (pc_in_unmapped_range (pc, section))
 488         {
 489           /* Because the high address is actually beyond the end of
 490              the function (and therefore possibly beyond the end of
 491              the overlay), we must actually convert (high - 1) and
 492              then add one to that. */
 493
 494           *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
 495                                                    section);
 496         }
 497       else
 498         *endaddr = cache_pc_function_high;
 499     }
 500
 501   return 1;
 502 }
 503
 504 /* Backward compatibility, no section argument.  */
 505
 506 int
 507 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
 508                           CORE_ADDR *endaddr)
 509 {
 510   struct bfd_section *bfd_section;
 511
 512   /* To ensure that the symbol returned belongs to the correct setion
 513      (and that the last [random] symbol from the previous section
 514      isn't returned) try to find the section containing PC.  First try
 515      the overlay code (which by default returns NULL); and second try
 516      the normal section code (which almost always succeeds).  */
 517   bfd_section = find_pc_overlay (pc);
 518   if (bfd_section == NULL)
 519     {
 520       struct obj_section *obj_section = find_pc_section (pc);
 521       if (obj_section == NULL)
 522         bfd_section = NULL;
 523       else
 524         bfd_section = obj_section->the_bfd_section;
 525     }
 526   return find_pc_sect_partial_function (pc, bfd_section, name, address,
 527                                         endaddr);
 528 }
 529
 530 /* Return the innermost stack frame executing inside of BLOCK,
 531    or NULL if there is no such frame.  If BLOCK is NULL, just return NULL.  */
 532
 533 struct frame_info *
 534 block_innermost_frame (struct block *block)
 535 {
 536   struct frame_info *frame;
 537   CORE_ADDR start;
 538   CORE_ADDR end;
 539   CORE_ADDR calling_pc;
 540
 541   if (block == NULL)
 542     return NULL;
 543
 544   start = BLOCK_START (block);
 545   end = BLOCK_END (block);
 546
 547   frame = NULL;
 548   while (1)
 549     {
 550       frame = get_prev_frame (frame);
 551       if (frame == NULL)
 552         return NULL;
 553       calling_pc = get_frame_address_in_block (frame);
 554       if (calling_pc >= start && calling_pc < end)
 555         return frame;
 556     }
 557 }
 558
 559 /* Are we in a call dummy?  The code below which allows DECR_PC_AFTER_BREAK
 560    below is for infrun.c, which may give the macro a pc without that
 561    subtracted out.  */
 562
 563 /* Is the PC in a call dummy?  SP and FRAME_ADDRESS are the bottom and
 564    top of the stack frame which we are checking, where "bottom" and
 565    "top" refer to some section of memory which contains the code for
 566    the call dummy.  Calls to this macro assume that the contents of
 567    SP_REGNUM and DEPRECATED_FP_REGNUM (or the saved values thereof),
 568    respectively, are the things to pass.
 569
 570    This won't work on the 29k, where SP_REGNUM and
 571    DEPRECATED_FP_REGNUM don't have that meaning, but the 29k doesn't
 572    use ON_STACK.  This could be fixed by generalizing this scheme,
 573    perhaps by passing in a frame and adding a few fields, at least on
 574    machines which need them for DEPRECATED_PC_IN_CALL_DUMMY.
 575
 576    Something simpler, like checking for the stack segment, doesn't work,
 577    since various programs (threads implementations, gcc nested function
 578    stubs, etc) may either allocate stack frames in another segment, or
 579    allocate other kinds of code on the stack.  */
 580
 581 int
 582 deprecated_pc_in_call_dummy_on_stack (CORE_ADDR pc, CORE_ADDR sp,
 583                                       CORE_ADDR frame_address)
 584 {
 585   return (INNER_THAN ((sp), (pc))
 586           && (frame_address != 0)
 587           && INNER_THAN ((pc), (frame_address)));
 588 }
 589
 590 int
 591 deprecated_pc_in_call_dummy_at_entry_point (CORE_ADDR pc, CORE_ADDR sp,
 592                                             CORE_ADDR frame_address)
 593 {
 594   CORE_ADDR addr = entry_point_address ();
 595   if (DEPRECATED_CALL_DUMMY_ADDRESS_P ())
 596     addr = DEPRECATED_CALL_DUMMY_ADDRESS ();
 597   return ((pc) >= addr && (pc) <= (addr + DECR_PC_AFTER_BREAK));
 598 }
 599
 600 /* Returns true for a user frame or a call_function_by_hand dummy
 601    frame, and false for the CRT0 start-up frame.  Purpose is to
 602    terminate backtrace.  */
 603
 604 int
 605 legacy_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
 606 {
 607   /* Don't prune CALL_DUMMY frames.  */
 608   if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
 609       && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), 0, 0))
 610     return 1;
 611
 612   /* If the new frame pointer is zero, then it isn't valid.  */
 613   if (fp == 0)
 614     return 0;
 615
 616   /* If the new frame would be inside (younger than) the previous frame,
 617      then it isn't valid.  */
 618   if (INNER_THAN (fp, get_frame_base (fi)))
 619     return 0;
 620
 621   /* If the architecture has a custom DEPRECATED_FRAME_CHAIN_VALID,
 622      call it now.  */
 623   if (DEPRECATED_FRAME_CHAIN_VALID_P ())
 624     return DEPRECATED_FRAME_CHAIN_VALID (fp, fi);
 625
 626   /* If we're already inside the entry function for the main objfile, then it
 627      isn't valid.  */
 628   if (legacy_inside_entry_func (get_frame_pc (fi)))
 629     return 0;
 630
 631   /* If we're inside the entry file, it isn't valid.  */
 632   /* NOTE/drow 2002-12-25: should there be a way to disable this check?  It
 633      assumes a single small entry file, and the way some debug readers (e.g.
 634      dbxread) figure out which object is the entry file is somewhat hokey.  */
 635   if (deprecated_inside_entry_file (frame_pc_unwind (fi)))
 636       return 0;
 637
 638   return 1;
 639 }