gdb/blockframe.c

   1 /* Get info from stack frames;
   2    convert between frames, blocks, functions and pc values.
   3    Copyright (C) 1986, 1987, 1988, 1989 Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   6
   7 GDB is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 1, or (at your option)
  10 any later version.
  11
  12 GDB is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GDB; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include <stdio.h>
  22 #include "defs.h"
  23 #include "param.h"
  24 #include "symtab.h"
  25 #include "frame.h"
  26 #include "gdbcore.h"
  27 #include "value.h"              /* for read_register */
  28 #include "target.h"             /* for target_has_stack */
  29
  30 /* Required by INIT_EXTRA_FRAME_INFO on 88k.  */
  31 #include <setjmp.h>
  32 #include <obstack.h>
  33
  34 CORE_ADDR read_pc ();           /* In infcmd.c */
  35
  36 /* Start and end of object file containing the entry point.
  37    STARTUP_FILE_END is the first address of the next file.
  38    This file is assumed to be a startup file
  39    and frames with pc's inside it
  40    are treated as nonexistent.
  41
  42    Setting these variables is necessary so that backtraces do not fly off
  43    the bottom of the stack.  */
  44 CORE_ADDR startup_file_start;
  45 CORE_ADDR startup_file_end;
  46
  47 /* Is ADDR outside the startup file?  Note that if your machine
  48    has a way to detect the bottom of the stack, there is no need
  49    to call this function from FRAME_CHAIN_VALID; the reason for
  50    doing so is that some machines have no way of detecting bottom
  51    of stack.  */
  52 int
  53 outside_startup_file (addr)
  54      CORE_ADDR addr;
  55 {
  56   return !(addr >= startup_file_start && addr < startup_file_end);
  57 }
  58
  59 /* Address of innermost stack frame (contents of FP register) */
  60
  61 static FRAME current_frame;
  62
  63 /*
  64  * Cache for frame addresses already read by gdb.  Valid only while
  65  * inferior is stopped.  Control variables for the frame cache should
  66  * be local to this module.
  67  */
  68 struct obstack frame_cache_obstack;
  69
  70 /* Return the innermost (currently executing) stack frame.  */
  71
  72 FRAME
  73 get_current_frame ()
  74 {
  75   /* We assume its address is kept in a general register;
  76      param.h says which register.  */
  77
  78   return current_frame;
  79 }
  80
  81 void
  82 set_current_frame (frame)
  83      FRAME frame;
  84 {
  85   current_frame = frame;
  86 }
  87
  88 FRAME
  89 create_new_frame (addr, pc)
  90      FRAME_ADDR addr;
  91      CORE_ADDR pc;
  92 {
  93   struct frame_info *fci;       /* Same type as FRAME */
  94
  95   fci = (struct frame_info *)
  96     obstack_alloc (&frame_cache_obstack,
  97                    sizeof (struct frame_info));
  98
  99   /* Arbitrary frame */
 100   fci->next = (struct frame_info *) 0;
 101   fci->prev = (struct frame_info *) 0;
 102   fci->frame = addr;
 103   fci->next_frame = 0;          /* Since arbitrary */
 104   fci->pc = pc;
 105
 106 #ifdef INIT_EXTRA_FRAME_INFO
 107   INIT_EXTRA_FRAME_INFO (fci);
 108 #endif
 109
 110   return fci;
 111 }
 112
 113 /* Return the frame that called FRAME.
 114    If FRAME is the original frame (it has no caller), return 0.  */
 115
 116 FRAME
 117 get_prev_frame (frame)
 118      FRAME frame;
 119 {
 120   /* We're allowed to know that FRAME and "struct frame_info *" are
 121      the same */
 122   return get_prev_frame_info (frame);
 123 }
 124
 125 /* Return the frame that FRAME calls (0 if FRAME is the innermost
 126    frame).  */
 127
 128 FRAME
 129 get_next_frame (frame)
 130      FRAME frame;
 131 {
 132   /* We're allowed to know that FRAME and "struct frame_info *" are
 133      the same */
 134   return frame->next;
 135 }
 136
 137 /*
 138  * Flush the entire frame cache.
 139  */
 140 void
 141 flush_cached_frames ()
 142 {
 143   /* Since we can't really be sure what the first object allocated was */
 144   obstack_free (&frame_cache_obstack, 0);
 145   obstack_init (&frame_cache_obstack);
 146
 147   current_frame = (struct frame_info *) 0; /* Invalidate cache */
 148 }
 149
 150 /* Flush the frame cache, and start a new one if necessary.  */
 151 void
 152 reinit_frame_cache ()
 153 {
 154   FRAME fr = current_frame;
 155   flush_cached_frames ();
 156   if (fr)
 157     set_current_frame ( create_new_frame (read_register (FP_REGNUM),
 158                                           read_pc ()));
 159 }
 160
 161 /* Return a structure containing various interesting information
 162    about a specified stack frame.  */
 163 /* How do I justify including this function?  Well, the FRAME
 164    identifier format has gone through several changes recently, and
 165    it's not completely inconceivable that it could happen again.  If
 166    it does, have this routine around will help */
 167
 168 struct frame_info *
 169 get_frame_info (frame)
 170      FRAME frame;
 171 {
 172   return frame;
 173 }
 174
 175 /* If a machine allows frameless functions, it should define a macro
 176    FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) in param.h.  FI is the struct
 177    frame_info for the frame, and FRAMELESS should be set to nonzero
 178    if it represents a frameless function invocation.  */
 179
 180 /* Return nonzero if the function for this frame has a prologue.  Many
 181    machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
 182    function.  */
 183
 184 int
 185 frameless_look_for_prologue (frame)
 186      FRAME frame;
 187 {
 188   CORE_ADDR func_start, after_prologue;
 189   func_start = (get_pc_function_start (frame->pc) +
 190                 FUNCTION_START_OFFSET);
 191   if (func_start)
 192     {
 193       after_prologue = func_start;
 194       SKIP_PROLOGUE (after_prologue);
 195       return after_prologue == func_start;
 196     }
 197   else
 198     /* If we can't find the start of the function, we don't really
 199        know whether the function is frameless, but we should be able
 200        to get a reasonable (i.e. best we can do under the
 201        circumstances) backtrace by saying that it isn't.  */
 202     return 0;
 203 }
 204
 205 #if !defined (INIT_FRAME_PC)
 206 #define INIT_FRAME_PC(fromleaf, prev) \
 207   prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
 208               prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
 209 #endif
 210
 211 /* Return a structure containing various interesting information
 212    about the frame that called NEXT_FRAME.  Returns NULL
 213    if there is no such frame.  */
 214
 215 struct frame_info *
 216 get_prev_frame_info (next_frame)
 217      FRAME next_frame;
 218 {
 219   FRAME_ADDR address;
 220   struct frame_info *prev;
 221   int fromleaf = 0;
 222
 223   /* If the requested entry is in the cache, return it.
 224      Otherwise, figure out what the address should be for the entry
 225      we're about to add to the cache. */
 226
 227   if (!next_frame)
 228     {
 229       if (!current_frame)
 230         {
 231           error ("You haven't set up a process's stack to examine.");
 232         }
 233
 234       return current_frame;
 235     }
 236
 237   /* If we have the prev one, return it */
 238   if (next_frame->prev)
 239     return next_frame->prev;
 240
 241   /* On some machines it is possible to call a function without
 242      setting up a stack frame for it.  On these machines, we
 243      define this macro to take two args; a frameinfo pointer
 244      identifying a frame and a variable to set or clear if it is
 245      or isn't leafless.  */
 246 #ifdef FRAMELESS_FUNCTION_INVOCATION
 247   /* Still don't want to worry about this except on the innermost
 248      frame.  This macro will set FROMLEAF if NEXT_FRAME is a
 249      frameless function invocation.  */
 250   if (!(next_frame->next))
 251     {
 252       FRAMELESS_FUNCTION_INVOCATION (next_frame, fromleaf);
 253       if (fromleaf)
 254         address = next_frame->frame;
 255     }
 256 #endif
 257
 258   if (!fromleaf)
 259     {
 260       /* Two macros defined in tm.h specify the machine-dependent
 261          actions to be performed here.
 262          First, get the frame's chain-pointer.
 263          If that is zero, the frame is the outermost frame or a leaf
 264          called by the outermost frame.  This means that if start
 265          calls main without a frame, we'll return 0 (which is fine
 266          anyway).
 267
 268          Nope; there's a problem.  This also returns when the current
 269          routine is a leaf of main.  This is unacceptable.  We move
 270          this to after the ffi test; I'd rather have backtraces from
 271          start go curfluy than have an abort called from main not show
 272          main.  */
 273       address = FRAME_CHAIN (next_frame);
 274       if (!FRAME_CHAIN_VALID (address, next_frame))
 275         return 0;
 276       address = FRAME_CHAIN_COMBINE (address, next_frame);
 277     }
 278
 279   prev = (struct frame_info *)
 280     obstack_alloc (&frame_cache_obstack,
 281                    sizeof (struct frame_info));
 282
 283   if (next_frame)
 284     next_frame->prev = prev;
 285   prev->next = next_frame;
 286   prev->prev = (struct frame_info *) 0;
 287   prev->frame = address;
 288   prev->next_frame = prev->next ? prev->next->frame : 0;
 289
 290 #ifdef INIT_EXTRA_FRAME_INFO
 291   INIT_EXTRA_FRAME_INFO(prev);
 292 #endif
 293
 294   /* This entry is in the frame queue now, which is good since
 295      FRAME_SAVED_PC may use that queue to figure out it's value
 296      (see m-sparc.h).  We want the pc saved in the inferior frame. */
 297   INIT_FRAME_PC(fromleaf, prev);
 298
 299   return prev;
 300 }
 301
 302 CORE_ADDR
 303 get_frame_pc (frame)
 304      FRAME frame;
 305 {
 306   struct frame_info *fi;
 307   fi = get_frame_info (frame);
 308   return fi->pc;
 309 }
 310
 311 #if defined (FRAME_FIND_SAVED_REGS)
 312 /* Find the addresses in which registers are saved in FRAME.  */
 313
 314 void
 315 get_frame_saved_regs (frame_info_addr, saved_regs_addr)
 316      struct frame_info *frame_info_addr;
 317      struct frame_saved_regs *saved_regs_addr;
 318 {
 319   FRAME_FIND_SAVED_REGS (frame_info_addr, *saved_regs_addr);
 320 }
 321 #endif
 322
 323 /* Return the innermost lexical block in execution
 324    in a specified stack frame.  The frame address is assumed valid.  */
 325
 326 struct block *
 327 get_frame_block (frame)
 328      FRAME frame;
 329 {
 330   struct frame_info *fi;
 331   CORE_ADDR pc;
 332
 333   fi = get_frame_info (frame);
 334
 335   pc = fi->pc;
 336   if (fi->next_frame != 0)
 337     /* We are not in the innermost frame.  We need to subtract one to
 338        get the correct block, in case the call instruction was the
 339        last instruction of the block.  If there are any machines on
 340        which the saved pc does not point to after the call insn, we
 341        probably want to make fi->pc point after the call insn anyway.  */
 342     --pc;
 343   return block_for_pc (pc);
 344 }
 345
 346 struct block *
 347 get_current_block ()
 348 {
 349   return block_for_pc (read_pc ());
 350 }
 351
 352 CORE_ADDR
 353 get_pc_function_start (pc)
 354      CORE_ADDR pc;
 355 {
 356   register struct block *bl = block_for_pc (pc);
 357   register struct symbol *symbol;
 358   if (bl == 0 || (symbol = block_function (bl)) == 0)
 359     {
 360       register int misc_index = find_pc_misc_function (pc);
 361       if (misc_index >= 0)
 362         return misc_function_vector[misc_index].address;
 363       return 0;
 364     }
 365   bl = SYMBOL_BLOCK_VALUE (symbol);
 366   return BLOCK_START (bl);
 367 }
 368
 369 /* Return the symbol for the function executing in frame FRAME.  */
 370
 371 struct symbol *
 372 get_frame_function (frame)
 373      FRAME frame;
 374 {
 375   register struct block *bl = get_frame_block (frame);
 376   if (bl == 0)
 377     return 0;
 378   return block_function (bl);
 379 }
 380 \f
 381 /* Return the blockvector immediately containing the innermost lexical block
 382    containing the specified pc value, or 0 if there is none.
 383    PINDEX is a pointer to the index value of the block.  If PINDEX
 384    is NULL, we don't pass this information back to the caller.  */
 385
 386 struct blockvector *
 387 blockvector_for_pc (pc, pindex)
 388      register CORE_ADDR pc;
 389      int *pindex;
 390 {
 391   register struct block *b;
 392   register int bot, top, half;
 393   register struct symtab *s;
 394   struct blockvector *bl;
 395
 396   /* First search all symtabs for one whose file contains our pc */
 397   s = find_pc_symtab (pc);
 398   if (s == 0)
 399     return 0;
 400
 401   bl = BLOCKVECTOR (s);
 402   b = BLOCKVECTOR_BLOCK (bl, 0);
 403
 404   /* Then search that symtab for the smallest block that wins.  */
 405   /* Use binary search to find the last block that starts before PC.  */
 406
 407   bot = 0;
 408   top = BLOCKVECTOR_NBLOCKS (bl);
 409
 410   while (top - bot > 1)
 411     {
 412       half = (top - bot + 1) >> 1;
 413       b = BLOCKVECTOR_BLOCK (bl, bot + half);
 414       if (BLOCK_START (b) <= pc)
 415         bot += half;
 416       else
 417         top = bot + half;
 418     }
 419
 420   /* Now search backward for a block that ends after PC.  */
 421
 422   while (bot >= 0)
 423     {
 424       b = BLOCKVECTOR_BLOCK (bl, bot);
 425       if (BLOCK_END (b) > pc)
 426         {
 427           if (pindex)
 428             *pindex = bot;
 429           return bl;
 430         }
 431       bot--;
 432     }
 433
 434   return 0;
 435 }
 436
 437 /* Return the innermost lexical block containing the specified pc value,
 438    or 0 if there is none.  */
 439
 440 struct block *
 441 block_for_pc (pc)
 442      register CORE_ADDR pc;
 443 {
 444   register struct blockvector *bl;
 445   int index;
 446
 447   bl = blockvector_for_pc (pc, &index);
 448   if (bl)
 449     return BLOCKVECTOR_BLOCK (bl, index);
 450   return 0;
 451 }
 452
 453 /* Return the function containing pc value PC.
 454    Returns 0 if function is not known.  */
 455
 456 struct symbol *
 457 find_pc_function (pc)
 458      CORE_ADDR pc;
 459 {
 460   register struct block *b = block_for_pc (pc);
 461   if (b == 0)
 462     return 0;
 463   return block_function (b);
 464 }
 465
 466 /* These variables are used to cache the most recent result
 467  * of find_pc_partial_function. */
 468
 469 static CORE_ADDR cache_pc_function_low = 0;
 470 static CORE_ADDR cache_pc_function_high = 0;
 471 static char *cache_pc_function_name = 0;
 472
 473 /* Clear cache, e.g. when symbol table is discarded. */
 474
 475 void
 476 clear_pc_function_cache()
 477 {
 478   cache_pc_function_low = 0;
 479   cache_pc_function_high = 0;
 480   cache_pc_function_name = (char *)0;
 481 }
 482
 483 /* Finds the "function" (text symbol) that is smaller than PC
 484    but greatest of all of the potential text symbols.  Sets
 485    *NAME and/or *ADDRESS conditionally if that pointer is non-zero.
 486    Returns 0 if it couldn't find anything, 1 if it did.  On a zero
 487    return, *NAME and *ADDRESS are always set to zero.  On a 1 return,
 488    *NAME and *ADDRESS contain real information.  */
 489
 490 int
 491 find_pc_partial_function (pc, name, address)
 492      CORE_ADDR pc;
 493      char **name;
 494      CORE_ADDR *address;
 495 {
 496   struct partial_symtab *pst;
 497   struct symbol *f;
 498   int miscfunc;
 499   struct partial_symbol *psb;
 500
 501   if (pc >= cache_pc_function_low && pc < cache_pc_function_high)
 502     {
 503         if (address)
 504             *address = cache_pc_function_low;
 505         if (name)
 506             *name = cache_pc_function_name;
 507         return 1;
 508     }
 509
 510   pst = find_pc_psymtab (pc);
 511   if (pst)
 512     {
 513       if (pst->readin)
 514         {
 515           /* The information we want has already been read in.
 516              We can go to the already readin symbols and we'll get
 517              the best possible answer.  */
 518           f = find_pc_function (pc);
 519           if (!f)
 520             {
 521             return_error:
 522               /* No available symbol.  */
 523               if (name != 0)
 524                 *name = 0;
 525               if (address != 0)
 526                 *address = 0;
 527               return 0;
 528             }
 529
 530           cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
 531           cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
 532           cache_pc_function_name = SYMBOL_NAME (f);
 533           if (name)
 534             *name = cache_pc_function_name;
 535           if (address)
 536             *address = cache_pc_function_low;
 537           return 1;
 538         }
 539
 540       /* Get the information from a combination of the pst
 541          (static symbols), and the misc function vector (extern
 542          symbols).  */
 543       miscfunc = find_pc_misc_function (pc);
 544       psb = find_pc_psymbol (pst, pc);
 545
 546       if (!psb && miscfunc == -1)
 547         {
 548           goto return_error;
 549         }
 550       if (psb
 551           && (miscfunc == -1
 552               || (SYMBOL_VALUE_ADDRESS (psb)
 553                   >= misc_function_vector[miscfunc].address)))
 554         {
 555           /* This case isn't being cached currently. */
 556           if (address)
 557             *address = SYMBOL_VALUE_ADDRESS (psb);
 558           if (name)
 559             *name = SYMBOL_NAME (psb);
 560           return 1;
 561         }
 562     }
 563   else
 564     /* Must be in the misc function stuff.  */
 565     {
 566       miscfunc = find_pc_misc_function (pc);
 567       if (miscfunc == -1)
 568         goto return_error;
 569     }
 570
 571   {
 572     if (misc_function_vector[miscfunc].type == mf_text)
 573       cache_pc_function_low = misc_function_vector[miscfunc].address;
 574     else
 575       /* It is a transfer table for Sun shared libraries.  */
 576       cache_pc_function_low = pc - FUNCTION_START_OFFSET;
 577   }
 578   cache_pc_function_name = misc_function_vector[miscfunc].name;
 579   if (miscfunc < misc_function_count /* && FIXME mf_text again? */ )
 580     cache_pc_function_high = misc_function_vector[miscfunc+1].address;
 581   else
 582     cache_pc_function_high = cache_pc_function_low + 1;
 583   if (address)
 584     *address = cache_pc_function_low;
 585   if (name)
 586     *name = cache_pc_function_name;
 587   return 1;
 588 }
 589
 590 /* Find the misc function whose address is the largest
 591    while being less than PC.  Return its index in misc_function_vector.
 592    Returns -1 if PC is not in suitable range.  */
 593
 594 int
 595 find_pc_misc_function (pc)
 596      register CORE_ADDR pc;
 597 {
 598   register int lo = 0;
 599   register int hi = misc_function_count-1;
 600   register int new;
 601
 602   /* Note that the last thing in the vector is always _etext.  */
 603   /* Actually, "end", now that non-functions
 604      go on the misc_function_vector.  */
 605
 606   /* Above statement is not *always* true - fix for case where there are */
 607   /* no misc functions at all (ie no symbol table has been read). */
 608   if (hi < 0) return -1;        /* no misc functions recorded */
 609
 610   /* trivial reject range test */
 611   if (pc < misc_function_vector[0].address ||
 612       pc > misc_function_vector[hi].address)
 613     return -1;
 614
 615   /* Note that the following search will not return hi if
 616      pc == misc_function_vector[hi].address.  If "end" points to the
 617      first unused location, this is correct and the above test
 618      simply needs to be changed to
 619      "pc >= misc_function_vector[hi].address".  */
 620   do {
 621     new = (lo + hi) >> 1;
 622     if (misc_function_vector[new].address == pc)
 623       return new;               /* an exact match */
 624     else if (misc_function_vector[new].address > pc)
 625       hi = new;
 626     else
 627       lo = new;
 628   } while (hi-lo != 1);
 629
 630   /* if here, we had no exact match, so return the lower choice */
 631   return lo;
 632 }
 633
 634 /* Return the innermost stack frame executing inside of the specified block,
 635    or zero if there is no such frame.  */
 636
 637 FRAME
 638 block_innermost_frame (block)
 639      struct block *block;
 640 {
 641   struct frame_info *fi;
 642   register FRAME frame;
 643   register CORE_ADDR start = BLOCK_START (block);
 644   register CORE_ADDR end = BLOCK_END (block);
 645
 646   frame = 0;
 647   while (1)
 648     {
 649       frame = get_prev_frame (frame);
 650       if (frame == 0)
 651         return 0;
 652       fi = get_frame_info (frame);
 653       if (fi->pc >= start && fi->pc < end)
 654         return frame;
 655     }
 656 }
 657
 658 void
 659 _initialize_blockframe ()
 660 {
 661   obstack_init (&frame_cache_obstack);
 662 }