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