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