gdb/blockframe.c

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