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 "objfiles.h"
  29 #include "frame.h"
  30 #include "gdbcore.h"
  31 #include "value.h"              /* for read_register */
  32 #include "target.h"             /* for target_has_stack */
  33 #include "inferior.h"           /* for read_pc */
  34 #include "annotate.h"
  35 #include "regcache.h"
  36 #include "gdb_assert.h"
  37 #include "dummy-frame.h"
  38 #include "command.h"
  39 #include "gdbcmd.h"
  40 #include "block.h"
  41
  42 /* Prototypes for exported functions. */
  43
  44 void _initialize_blockframe (void);
  45
  46 /* Test whether PC is in the range of addresses that corresponds to
  47    the "main" function.  */
  48
  49 int
  50 inside_main_func (CORE_ADDR pc)
  51 {
  52   struct minimal_symbol *msymbol;
  53
  54   if (symfile_objfile == 0)
  55     return 0;
  56
  57   msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
  58
  59   /* If the address range hasn't been set up at symbol reading time,
  60      set it up now.  */
  61
  62   if (msymbol != NULL
  63       && symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC
  64       && symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
  65     {
  66       /* brobecker/2003-10-10: We used to rely on lookup_symbol() to
  67          search the symbol associated to the "main" function.
  68          Unfortunately, lookup_symbol() uses the current-language
  69          la_lookup_symbol_nonlocal function to do the global symbol
  70          search.  Depending on the language, this can introduce
  71          certain side-effects, because certain languages, for instance
  72          Ada, may find more than one match.  Therefore we prefer to
  73          search the "main" function symbol using its address rather
  74          than its name.  */
  75       struct symbol *mainsym =
  76         find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol));
  77
  78       if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK)
  79         {
  80           symfile_objfile->ei.main_func_lowpc =
  81             BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
  82           symfile_objfile->ei.main_func_highpc =
  83             BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
  84         }
  85     }
  86
  87   /* Not in the normal symbol tables, see if "main" is in the partial
  88      symbol table.  If it's not, then give up.  */
  89   if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_text)
  90     {
  91       CORE_ADDR maddr = SYMBOL_VALUE_ADDRESS (msymbol);
  92       asection *msect = SYMBOL_BFD_SECTION (msymbol);
  93       struct obj_section *osect = find_pc_sect_section (maddr, msect);
  94
  95       if (osect != NULL)
  96         {
  97           int i;
  98
  99           /* Step over other symbols at this same address, and symbols
 100              in other sections, to find the next symbol in this
 101              section with a different address.  */
 102           for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
 103             {
 104               if (SYMBOL_VALUE_ADDRESS (msymbol + i) != maddr
 105                   && SYMBOL_BFD_SECTION (msymbol + i) == msect)
 106                 break;
 107             }
 108
 109           symfile_objfile->ei.main_func_lowpc = maddr;
 110
 111           /* Use the lesser of the next minimal symbol in the same
 112              section, or the end of the section, as the end of the
 113              function.  */
 114           if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
 115               && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
 116             symfile_objfile->ei.main_func_highpc =
 117               SYMBOL_VALUE_ADDRESS (msymbol + i);
 118           else
 119             /* We got the start address from the last msymbol in the
 120                objfile.  So the end address is the end of the
 121                section.  */
 122             symfile_objfile->ei.main_func_highpc = osect->endaddr;
 123         }
 124     }
 125
 126   return (symfile_objfile->ei.main_func_lowpc <= pc
 127           && symfile_objfile->ei.main_func_highpc > pc);
 128 }
 129
 130 /* Test whether THIS_FRAME is inside the process entry point function.  */
 131
 132 int
 133 inside_entry_func (struct frame_info *this_frame)
 134 {
 135   return (get_frame_func (this_frame) == entry_point_address ());
 136 }
 137
 138 /* Similar to inside_entry_func, but accomodating legacy frame code.  */
 139
 140 static int
 141 legacy_inside_entry_func (CORE_ADDR pc)
 142 {
 143   if (symfile_objfile == 0)
 144     return 0;
 145
 146   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
 147     {
 148       /* Do not stop backtracing if the program counter is in the call
 149          dummy at the entry point.  */
 150       /* FIXME: This won't always work with zeros for the last two
 151          arguments.  */
 152       if (DEPRECATED_PC_IN_CALL_DUMMY (pc, 0, 0))
 153         return 0;
 154     }
 155
 156   return (symfile_objfile->ei.entry_func_lowpc <= pc
 157           && symfile_objfile->ei.entry_func_highpc > pc);
 158 }
 159
 160 /* Return nonzero if the function for this frame lacks a prologue.
 161    Many machines can define DEPRECATED_FRAMELESS_FUNCTION_INVOCATION
 162    to just call this function.  */
 163
 164 int
 165 legacy_frameless_look_for_prologue (struct frame_info *frame)
 166 {
 167   CORE_ADDR func_start;
 168
 169   func_start = get_frame_func (frame);
 170   if (func_start)
 171     {
 172       func_start += FUNCTION_START_OFFSET;
 173       /* NOTE: cagney/2004-02-09: Eliminated per-architecture
 174          PROLOGUE_FRAMELESS_P call as architectures with custom
 175          implementations had all been deleted.  Eventually even this
 176          function can go - GDB no longer tries to differentiate
 177          between framed, frameless and stackless functions.  They are
 178          all now considered equally evil :-^.  */
 179       /* If skipping the prologue ends up skips nothing, there must be
 180          no prologue and hence no code creating a frame.  There for
 181          the function is "frameless" :-/.  */
 182       return func_start == SKIP_PROLOGUE (func_start);
 183     }
 184   else if (get_frame_pc (frame) == 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 innermost lexical block in execution
 199    in a specified stack frame.  The frame address is assumed valid.
 200
 201    If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
 202    address we used to choose the block.  We use this to find a source
 203    line, to decide which macro definitions are in scope.
 204
 205    The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
 206    PC, and may not really be a valid PC at all.  For example, in the
 207    caller of a function declared to never return, the code at the
 208    return address will never be reached, so the call instruction may
 209    be the very last instruction in the block.  So the address we use
 210    to choose the block is actually one byte before the return address
 211    --- hopefully pointing us at the call instruction, or its delay
 212    slot instruction.  */
 213
 214 struct block *
 215 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
 216 {
 217   const CORE_ADDR pc = get_frame_address_in_block (frame);
 218
 219   if (addr_in_block)
 220     *addr_in_block = pc;
 221
 222   return block_for_pc (pc);
 223 }
 224
 225 CORE_ADDR
 226 get_pc_function_start (CORE_ADDR pc)
 227 {
 228   struct block *bl;
 229   struct minimal_symbol *msymbol;
 230
 231   bl = block_for_pc (pc);
 232   if (bl)
 233     {
 234       struct symbol *symbol = block_function (bl);
 235
 236       if (symbol)
 237         {
 238           bl = SYMBOL_BLOCK_VALUE (symbol);
 239           return BLOCK_START (bl);
 240         }
 241     }
 242
 243   msymbol = lookup_minimal_symbol_by_pc (pc);
 244   if (msymbol)
 245     {
 246       CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
 247
 248       if (find_pc_section (fstart))
 249         return fstart;
 250     }
 251
 252   return 0;
 253 }
 254
 255 /* Return the symbol for the function executing in frame FRAME.  */
 256
 257 struct symbol *
 258 get_frame_function (struct frame_info *frame)
 259 {
 260   struct block *bl = get_frame_block (frame, 0);
 261   if (bl == 0)
 262     return 0;
 263   return block_function (bl);
 264 }
 265 \f
 266
 267 /* Return the function containing pc value PC in section SECTION.
 268    Returns 0 if function is not known.  */
 269
 270 struct symbol *
 271 find_pc_sect_function (CORE_ADDR pc, struct bfd_section *section)
 272 {
 273   struct block *b = block_for_pc_sect (pc, section);
 274   if (b == 0)
 275     return 0;
 276   return block_function (b);
 277 }
 278
 279 /* Return the function containing pc value PC.
 280    Returns 0 if function is not known.  Backward compatibility, no section */
 281
 282 struct symbol *
 283 find_pc_function (CORE_ADDR pc)
 284 {
 285   return find_pc_sect_function (pc, find_pc_mapped_section (pc));
 286 }
 287
 288 /* These variables are used to cache the most recent result
 289  * of find_pc_partial_function. */
 290
 291 static CORE_ADDR cache_pc_function_low = 0;
 292 static CORE_ADDR cache_pc_function_high = 0;
 293 static char *cache_pc_function_name = 0;
 294 static struct bfd_section *cache_pc_function_section = NULL;
 295
 296 /* Clear cache, e.g. when symbol table is discarded. */
 297
 298 void
 299 clear_pc_function_cache (void)
 300 {
 301   cache_pc_function_low = 0;
 302   cache_pc_function_high = 0;
 303   cache_pc_function_name = (char *) 0;
 304   cache_pc_function_section = NULL;
 305 }
 306
 307 /* Finds the "function" (text symbol) that is smaller than PC but
 308    greatest of all of the potential text symbols in SECTION.  Sets
 309    *NAME and/or *ADDRESS conditionally if that pointer is non-null.
 310    If ENDADDR is non-null, then set *ENDADDR to be the end of the
 311    function (exclusive), but passing ENDADDR as non-null means that
 312    the function might cause symbols to be read.  This function either
 313    succeeds or fails (not halfway succeeds).  If it succeeds, it sets
 314    *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
 315    If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
 316    returns 0.  */
 317
 318 /* Backward compatibility, no section argument.  */
 319
 320 int
 321 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
 322                           CORE_ADDR *endaddr)
 323 {
 324   struct bfd_section *section;
 325   struct partial_symtab *pst;
 326   struct symbol *f;
 327   struct minimal_symbol *msymbol;
 328   struct partial_symbol *psb;
 329   struct obj_section *osect;
 330   int i;
 331   CORE_ADDR mapped_pc;
 332
 333   /* To ensure that the symbol returned belongs to the correct setion
 334      (and that the last [random] symbol from the previous section
 335      isn't returned) try to find the section containing PC.  First try
 336      the overlay code (which by default returns NULL); and second try
 337      the normal section code (which almost always succeeds).  */
 338   section = find_pc_overlay (pc);
 339   if (section == NULL)
 340     {
 341       struct obj_section *obj_section = find_pc_section (pc);
 342       if (obj_section == NULL)
 343         section = NULL;
 344       else
 345         section = obj_section->the_bfd_section;
 346     }
 347
 348   mapped_pc = overlay_mapped_address (pc, section);
 349
 350   if (mapped_pc >= cache_pc_function_low
 351       && mapped_pc < cache_pc_function_high
 352       && section == cache_pc_function_section)
 353     goto return_cached_value;
 354
 355   msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
 356   pst = find_pc_sect_psymtab (mapped_pc, section);
 357   if (pst)
 358     {
 359       /* Need to read the symbols to get a good value for the end address.  */
 360       if (endaddr != NULL && !pst->readin)
 361         {
 362           /* Need to get the terminal in case symbol-reading produces
 363              output.  */
 364           target_terminal_ours_for_output ();
 365           PSYMTAB_TO_SYMTAB (pst);
 366         }
 367
 368       if (pst->readin)
 369         {
 370           /* Checking whether the msymbol has a larger value is for the
 371              "pathological" case mentioned in print_frame_info.  */
 372           f = find_pc_sect_function (mapped_pc, section);
 373           if (f != NULL
 374               && (msymbol == NULL
 375                   || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
 376                       >= SYMBOL_VALUE_ADDRESS (msymbol))))
 377             {
 378               cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
 379               cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
 380               cache_pc_function_name = DEPRECATED_SYMBOL_NAME (f);
 381               cache_pc_function_section = section;
 382               goto return_cached_value;
 383             }
 384         }
 385       else
 386         {
 387           /* Now that static symbols go in the minimal symbol table, perhaps
 388              we could just ignore the partial symbols.  But at least for now
 389              we use the partial or minimal symbol, whichever is larger.  */
 390           psb = find_pc_sect_psymbol (pst, mapped_pc, section);
 391
 392           if (psb
 393               && (msymbol == NULL ||
 394                   (SYMBOL_VALUE_ADDRESS (psb)
 395                    >= SYMBOL_VALUE_ADDRESS (msymbol))))
 396             {
 397               /* This case isn't being cached currently. */
 398               if (address)
 399                 *address = SYMBOL_VALUE_ADDRESS (psb);
 400               if (name)
 401                 *name = DEPRECATED_SYMBOL_NAME (psb);
 402               /* endaddr non-NULL can't happen here.  */
 403               return 1;
 404             }
 405         }
 406     }
 407
 408   /* Not in the normal symbol tables, see if the pc is in a known section.
 409      If it's not, then give up.  This ensures that anything beyond the end
 410      of the text seg doesn't appear to be part of the last function in the
 411      text segment.  */
 412
 413   osect = find_pc_sect_section (mapped_pc, section);
 414
 415   if (!osect)
 416     msymbol = NULL;
 417
 418   /* Must be in the minimal symbol table.  */
 419   if (msymbol == NULL)
 420     {
 421       /* No available symbol.  */
 422       if (name != NULL)
 423         *name = 0;
 424       if (address != NULL)
 425         *address = 0;
 426       if (endaddr != NULL)
 427         *endaddr = 0;
 428       return 0;
 429     }
 430
 431   cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
 432   cache_pc_function_name = DEPRECATED_SYMBOL_NAME (msymbol);
 433   cache_pc_function_section = section;
 434
 435   /* Use the lesser of the next minimal symbol in the same section, or
 436      the end of the section, as the end of the function.  */
 437
 438   /* Step over other symbols at this same address, and symbols in
 439      other sections, to find the next symbol in this section with
 440      a different address.  */
 441
 442   for (i = 1; DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL; i++)
 443     {
 444       if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
 445           && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
 446         break;
 447     }
 448
 449   if (DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL
 450       && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
 451     cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
 452   else
 453     /* We got the start address from the last msymbol in the objfile.
 454        So the end address is the end of the section.  */
 455     cache_pc_function_high = osect->endaddr;
 456
 457  return_cached_value:
 458
 459   if (address)
 460     {
 461       if (pc_in_unmapped_range (pc, section))
 462         *address = overlay_unmapped_address (cache_pc_function_low, section);
 463       else
 464         *address = cache_pc_function_low;
 465     }
 466
 467   if (name)
 468     *name = cache_pc_function_name;
 469
 470   if (endaddr)
 471     {
 472       if (pc_in_unmapped_range (pc, section))
 473         {
 474           /* Because the high address is actually beyond the end of
 475              the function (and therefore possibly beyond the end of
 476              the overlay), we must actually convert (high - 1) and
 477              then add one to that. */
 478
 479           *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
 480                                                    section);
 481         }
 482       else
 483         *endaddr = cache_pc_function_high;
 484     }
 485
 486   return 1;
 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   CORE_ADDR start;
 497   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 = get_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 DEPRECATED_FP_REGNUM (or the saved values thereof),
 527    respectively, are the things to pass.
 528
 529    This won't work on the 29k, where SP_REGNUM and
 530    DEPRECATED_FP_REGNUM don't have that meaning, but the 29k doesn't
 531    use ON_STACK.  This could be fixed by generalizing this scheme,
 532    perhaps by passing in a frame and adding a few fields, at least on
 533    machines which need them for 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 /* Returns true for a user frame or a call_function_by_hand dummy
 550    frame, and false for the CRT0 start-up frame.  Purpose is to
 551    terminate backtrace.  */
 552
 553 int
 554 legacy_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
 555 {
 556   /* Don't prune CALL_DUMMY frames.  */
 557   if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
 558       && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), 0, 0))
 559     return 1;
 560
 561   /* If the new frame pointer is zero, then it isn't valid.  */
 562   if (fp == 0)
 563     return 0;
 564
 565   /* If the new frame would be inside (younger than) the previous frame,
 566      then it isn't valid.  */
 567   if (INNER_THAN (fp, get_frame_base (fi)))
 568     return 0;
 569
 570   /* If the architecture has a custom DEPRECATED_FRAME_CHAIN_VALID,
 571      call it now.  */
 572   if (DEPRECATED_FRAME_CHAIN_VALID_P ())
 573     return DEPRECATED_FRAME_CHAIN_VALID (fp, fi);
 574
 575   /* If we're already inside the entry function for the main objfile, then it
 576      isn't valid.  */
 577   if (legacy_inside_entry_func (get_frame_pc (fi)))
 578     return 0;
 579
 580   return 1;
 581 }