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