* TODO: Add item suggesting an "info bfd" command.

[binutils.git] / gdb / blockframe.c

diff --git a/gdb/blockframe.c b/gdb/blockframe.c
index 2817017074a8fd769b93d56817b65c122fc0b294..a55e85a9f8d0188b6267c5eb36f2ab4ac80a2fe1 100644 (file)
--- a/gdb/blockframe.c
+++ b/gdb/blockframe.c
@@ -1,133 +1,204 @@
 /* Get info from stack frames;
    convert between frames, blocks, functions and pc values.
 /* Get info from stack frames;
    convert between frames, blocks, functions and pc values.

-   Copyright (C) 1986, 1987, 1988, 1989 Free Software Foundation, Inc.
+   Copyright 1986, 1987, 1988, 1989, 1991, 1994 Free Software Foundation, Inc.

 
 This file is part of GDB.
 
 
 This file is part of GDB.
 

-GDB is free software; you can redistribute it and/or modify
+This program is free software; you can redistribute it and/or modify

 it under the terms of the GNU General Public License as published by
 it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 1, or (at your option)
-any later version.
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.

 
 

-GDB is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,

 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License

-along with GDB; see the file COPYING.  If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

 
 #include "defs.h"
 
 #include "defs.h"

-#include "param.h"

 #include "symtab.h"
 #include "symtab.h"

+#include "bfd.h"
+#include "symfile.h"
+#include "objfiles.h"

 #include "frame.h"
 #include "frame.h"

+#include "gdbcore.h"
+#include "value.h"             /* for read_register */
+#include "target.h"            /* for target_has_stack */
+#include "inferior.h"          /* for read_pc */
+#include "annotate.h"

 
 

-#include <obstack.h>
+/* Is ADDR inside the startup file?  Note that if your machine
+   has a way to detect the bottom of the stack, there is no need
+   to call this function from FRAME_CHAIN_VALID; the reason for
+   doing so is that some machines have no way of detecting bottom
+   of stack. 

 
 

-/* Start and end of object file containing the entry point.
-   STARTUP_FILE_END is the first address of the next file.
-   This file is assumed to be a startup file
-   and frames with pc's inside it
-   are treated as nonexistent.
+   A PC of zero is always considered to be the bottom of the stack. */

 
 

-   Setting these variables is necessary so that backtraces do not fly off
-   the bottom of the stack.  */
-CORE_ADDR startup_file_start;
-CORE_ADDR startup_file_end;
-
-/* Is ADDR outside the startup file?  */

 int
 int

-outside_startup_file (addr)
+inside_entry_file (addr)

      CORE_ADDR addr;
 {
      CORE_ADDR addr;
 {

-  return !(addr >= startup_file_start && addr < startup_file_end);
+  if (addr == 0)
+    return 1;
+  if (symfile_objfile == 0)
+    return 0;
+#if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
+  /* Do not stop backtracing if the pc is in the call dummy
+     at the entry point.  */
+  if (PC_IN_CALL_DUMMY (addr, 0, 0))
+    return 0;
+#endif
+  return (addr >= symfile_objfile -> ei.entry_file_lowpc &&
+         addr <  symfile_objfile -> ei.entry_file_highpc);
+}
+
+/* Test a specified PC value to see if it is in the range of addresses
+   that correspond to the main() function.  See comments above for why
+   we might want to do this.
+
+   Typically called from FRAME_CHAIN_VALID.
+
+   A PC of zero is always considered to be the bottom of the stack. */
+
+int
+inside_main_func (pc)
+CORE_ADDR pc;
+{
+struct symbol *mainsym;
+  if (pc == 0)
+    return 1;
+  if (symfile_objfile == 0)
+    return 0;
+
+  if (symfile_objfile -> ei.main_func_lowpc == 0 &&
+      symfile_objfile -> ei.main_func_highpc == 0)
+    {
+      mainsym = lookup_symbol ("main", NULL, VAR_NAMESPACE, NULL, NULL);
+      if (mainsym && SYMBOL_CLASS(mainsym) == LOC_BLOCK)
+        {
+          symfile_objfile->ei.main_func_lowpc = BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
+          symfile_objfile->ei.main_func_highpc = BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
+        }
+
+    }
+  return (symfile_objfile -> ei.main_func_lowpc  <= pc &&
+         symfile_objfile -> ei.main_func_highpc > pc);
+}
+
+/* Test a specified PC value to see if it is in the range of addresses
+   that correspond to the process entry point function.  See comments
+   in objfiles.h for why we might want to do this.
+
+   Typically called from FRAME_CHAIN_VALID.
+
+   A PC of zero is always considered to be the bottom of the stack. */
+
+int
+inside_entry_func (pc)
+CORE_ADDR pc;
+{
+  if (pc == 0)
+    return 1;
+  if (symfile_objfile == 0)
+    return 0;
+#if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
+  /* Do not stop backtracing if the pc is in the call dummy
+     at the entry point.  */
+  if (PC_IN_CALL_DUMMY (pc, 0, 0))
+    return 0;
+#endif
+  return (symfile_objfile -> ei.entry_func_lowpc  <= pc &&
+         symfile_objfile -> ei.entry_func_highpc > pc);

 }
 
 }
 

-/* Address of innermost stack frame (contents of FP register) */
+/* Info about the innermost stack frame (contents of FP register) */

 
 

-static FRAME current_frame;
+static struct frame_info *current_frame;

 
 

-struct block *block_for_pc ();
-CORE_ADDR get_pc_function_start ();
+/* Cache for frame addresses already read by gdb.  Valid only while
+   inferior is stopped.  Control variables for the frame cache should
+   be local to this module.  */

 
 

-/*
- * Cache for frame addresses already read by gdb.  Valid only while
- * inferior is stopped.  Control variables for the frame cache should
- * be local to this module.
- */

 struct obstack frame_cache_obstack;
 
 /* Return the innermost (currently executing) stack frame.  */
 
 struct obstack frame_cache_obstack;
 
 /* Return the innermost (currently executing) stack frame.  */
 

-FRAME
+struct frame_info *

 get_current_frame ()
 {
 get_current_frame ()
 {

-  /* We assume its address is kept in a general register;
-     param.h says which register.  */
-
+  if (current_frame == NULL)
+    {
+      if (target_has_stack)
+       current_frame = create_new_frame (read_fp (), read_pc ());
+      else
+       error ("No stack.");
+    }

   return current_frame;
 }
 
 void
 set_current_frame (frame)
   return current_frame;
 }
 
 void
 set_current_frame (frame)

-     FRAME frame;
+     struct frame_info *frame;

 {
   current_frame = frame;
 }
 
 {
   current_frame = frame;
 }
 

-FRAME
+/* Create an arbitrary (i.e. address specified by user) or innermost frame.
+   Always returns a non-NULL value.  */
+
+struct frame_info *

 create_new_frame (addr, pc)
 create_new_frame (addr, pc)

-     FRAME_ADDR addr;
+     CORE_ADDR addr;

      CORE_ADDR pc;
 {
      CORE_ADDR pc;
 {

-  struct frame_info *fci;      /* Same type as FRAME */
+  struct frame_info *fi;
+  char *name;

 
 

-  fci = (struct frame_info *)
+  fi = (struct frame_info *)

     obstack_alloc (&frame_cache_obstack,
                   sizeof (struct frame_info));
 
   /* Arbitrary frame */
     obstack_alloc (&frame_cache_obstack,
                   sizeof (struct frame_info));
 
   /* Arbitrary frame */

-  fci->next = (struct frame_info *) 0;
-  fci->prev = (struct frame_info *) 0;
-  fci->frame = addr;
-  fci->next_frame = 0;         /* Since arbitrary */
-  fci->pc = pc;
+  fi->next = NULL;
+  fi->prev = NULL;
+  fi->frame = addr;
+  fi->pc = pc;
+  find_pc_partial_function (pc, &name, (CORE_ADDR *)NULL,(CORE_ADDR *)NULL);
+  fi->signal_handler_caller = IN_SIGTRAMP (fi->pc, name);

 
 #ifdef INIT_EXTRA_FRAME_INFO
 
 #ifdef INIT_EXTRA_FRAME_INFO

-  INIT_EXTRA_FRAME_INFO (fci);
+  INIT_EXTRA_FRAME_INFO (0, fi);

 #endif
 
 #endif
 

-  return fci;
+  return fi;

 }
 
 }
 

-/* Return the frame that called FRAME.
-   If FRAME is the original frame (it has no caller), return 0.  */
+/* Return the frame that called FI.
+   If FI is the original frame (it has no caller), return 0.  */

 
 

-FRAME
+struct frame_info *

 get_prev_frame (frame)
 get_prev_frame (frame)

-     FRAME frame;
+     struct frame_info *frame;

 {
 {

-  /* We're allowed to know that FRAME and "struct frame_info *" are
-     the same */

   return get_prev_frame_info (frame);
 }
 
   return get_prev_frame_info (frame);
 }
 

-/* Return the frame that FRAME calls (0 if FRAME is the innermost
+/* Return the frame that FRAME calls (NULL if FRAME is the innermost

    frame).  */
 
    frame).  */
 

-FRAME
+struct frame_info *

 get_next_frame (frame)
 get_next_frame (frame)

-     FRAME frame;
+     struct frame_info *frame;

 {
 {

-  /* We're allowed to know that FRAME and "struct frame_info *" are
-     the same */

   return frame->next;
 }
 
   return frame->next;
 }
 

-/*
- * Flush the entire frame cache.
- */
+/* Flush the entire frame cache.  */
+

 void
 flush_cached_frames ()
 {
 void
 flush_cached_frames ()
 {


@@ -135,21 +206,23 @@ flush_cached_frames ()
   obstack_free (&frame_cache_obstack, 0);
   obstack_init (&frame_cache_obstack);
 
   obstack_free (&frame_cache_obstack, 0);
   obstack_init (&frame_cache_obstack);
 

-  current_frame = (struct frame_info *) 0; /* Invalidate cache */
+  current_frame = NULL;  /* Invalidate cache */
+  select_frame (NULL, -1);
+  annotate_frames_invalid ();

 }
 
 }
 

-/* Return a structure containing various interesting information
-   about a specified stack frame.  */
-/* How do I justify including this function?  Well, the FRAME
-   identifier format has gone through several changes recently, and
-   it's not completely inconceivable that it could happen again.  If
-   it does, have this routine around will help */
+/* Flush the frame cache, and start a new one if necessary.  */

 
 

-struct frame_info *
-get_frame_info (frame)
-     FRAME frame;
+void
+reinit_frame_cache ()

 {
 {

-  return frame;
+  flush_cached_frames ();
+
+  /* FIXME: The inferior_pid test is wrong if there is a corefile.  */
+  if (inferior_pid != 0)
+    {
+      select_frame (get_current_frame (), 0);
+    }

 }
 
 /* If a machine allows frameless functions, it should define a macro
 }
 
 /* If a machine allows frameless functions, it should define a macro


@@ -157,38 +230,60 @@ get_frame_info (frame)
    frame_info for the frame, and FRAMELESS should be set to nonzero
    if it represents a frameless function invocation.  */
 
    frame_info for the frame, and FRAMELESS should be set to nonzero
    if it represents a frameless function invocation.  */
 

-/* Many machines which allow frameless functions can detect them using
-   this macro.  Such machines should define FRAMELESS_FUNCTION_INVOCATION
-   to just call this macro.  */
-#define FRAMELESS_LOOK_FOR_PROLOGUE(FI, FRAMELESS) \
-{                                                                               \
-  CORE_ADDR func_start, after_prologue;                                         \
-  func_start = (get_pc_function_start ((FI)->pc) +                      \
-               FUNCTION_START_OFFSET);                                  \
-  if (func_start)                                                        \
-    {                                                                   \
-      after_prologue = func_start;                                      \
-      SKIP_PROLOGUE (after_prologue);                                   \
-      (FRAMELESS) = (after_prologue == func_start);                     \
-    }                                                                   \
-  else                                                                  \
-    /* If we can't find the start of the function, we don't really */    \
-    /* know whether the function is frameless, but we should be           */    \
-    /* able to get a reasonable (i.e. best we can do under the    */    \
-    /* circumstances) backtrace by saying that it isn't.  */            \
-    (FRAMELESS) = 0;                                                    \
+/* Return nonzero if the function for this frame lacks a prologue.  Many
+   machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
+   function.  */
+
+int
+frameless_look_for_prologue (frame)
+     struct frame_info *frame;
+{
+  CORE_ADDR func_start, after_prologue;
+  func_start = (get_pc_function_start (frame->pc) + FUNCTION_START_OFFSET);
+  if (func_start)
+    {
+      after_prologue = func_start;
+#ifdef SKIP_PROLOGUE_FRAMELESS_P
+      /* This is faster, since only care whether there *is* a prologue,
+        not how long it is.  */
+      SKIP_PROLOGUE_FRAMELESS_P (after_prologue);
+#else
+      SKIP_PROLOGUE (after_prologue);
+#endif
+      return after_prologue == func_start;
+    }
+  else
+    /* If we can't find the start of the function, we don't really
+       know whether the function is frameless, but we should be able
+       to get a reasonable (i.e. best we can do under the
+       circumstances) backtrace by saying that it isn't.  */
+    return 0;

 }
 
 }
 

+/* Default a few macros that people seldom redefine.  */
+
+#if !defined (INIT_FRAME_PC)
+#define INIT_FRAME_PC(fromleaf, prev) \
+  prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
+             prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
+#endif
+
+#ifndef FRAME_CHAIN_COMBINE
+#define        FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
+#endif
+

 /* Return a structure containing various interesting information
 /* Return a structure containing various interesting information

-   about the frame that called NEXT_FRAME.  */
+   about the frame that called NEXT_FRAME.  Returns NULL
+   if there is no such frame.  */

 
 struct frame_info *
 get_prev_frame_info (next_frame)
 
 struct frame_info *
 get_prev_frame_info (next_frame)

-     FRAME next_frame;
+     struct frame_info *next_frame;

 {
 {

-  FRAME_ADDR address;
+  CORE_ADDR address = 0;

   struct frame_info *prev;
   int fromleaf = 0;
   struct frame_info *prev;
   int fromleaf = 0;

+  char *name;

 
   /* If the requested entry is in the cache, return it.
      Otherwise, figure out what the address should be for the entry
 
   /* If the requested entry is in the cache, return it.
      Otherwise, figure out what the address should be for the entry


@@ -196,13 +291,16 @@ get_prev_frame_info (next_frame)
 
   if (!next_frame)
     {
 
   if (!next_frame)
     {

+#if 0
+      /* This screws value_of_variable, which just wants a nice clean
+        NULL return from block_innermost_frame if there are no frames.
+        I don't think I've ever seen this message happen otherwise.
+        And returning NULL here is a perfectly legitimate thing to do.  */

       if (!current_frame)
        {
       if (!current_frame)
        {

-         if (!have_inferior_p () && !have_core_file_p ())
-           fatal ("get_prev_frame_info: Called before cache primed.  \"Shouldn't happen.\"");
-         else
-           error ("No inferior or core file.");
+         error ("You haven't set up a process's stack to examine.");

        }
        }

+#endif

 
       return current_frame;
     }
 
       return current_frame;
     }


@@ -224,13 +322,13 @@ get_prev_frame_info (next_frame)
     {
       FRAMELESS_FUNCTION_INVOCATION (next_frame, fromleaf);
       if (fromleaf)
     {
       FRAMELESS_FUNCTION_INVOCATION (next_frame, fromleaf);
       if (fromleaf)

-       address = next_frame->frame;
+       address = FRAME_FP (next_frame);

     }
 #endif
 
   if (!fromleaf)
     {
     }
 #endif
 
   if (!fromleaf)
     {

-      /* Two macros defined in param.h specify the machine-dependent
+      /* Two macros defined in tm.h specify the machine-dependent

         actions to be performed here.
         First, get the frame's chain-pointer.
         If that is zero, the frame is the outermost frame or a leaf
         actions to be performed here.
         First, get the frame's chain-pointer.
         If that is zero, the frame is the outermost frame or a leaf


@@ -246,10 +344,10 @@ get_prev_frame_info (next_frame)
       address = FRAME_CHAIN (next_frame);
       if (!FRAME_CHAIN_VALID (address, next_frame))
        return 0;
       address = FRAME_CHAIN (next_frame);
       if (!FRAME_CHAIN_VALID (address, next_frame))
        return 0;

-      /* If this frame is a leaf, this will be superceeded by the
-        code below.  */

       address = FRAME_CHAIN_COMBINE (address, next_frame);
     }
       address = FRAME_CHAIN_COMBINE (address, next_frame);
     }

+  if (address == 0)
+    return 0;

 
   prev = (struct frame_info *)
     obstack_alloc (&frame_cache_obstack,
 
   prev = (struct frame_info *)
     obstack_alloc (&frame_cache_obstack,


@@ -260,51 +358,123 @@ get_prev_frame_info (next_frame)
   prev->next = next_frame;
   prev->prev = (struct frame_info *) 0;
   prev->frame = address;
   prev->next = next_frame;
   prev->prev = (struct frame_info *) 0;
   prev->frame = address;

-  prev->next_frame = prev->next ? prev->next->frame : 0;
+  prev->signal_handler_caller = 0;
+
+/* This change should not be needed, FIXME!  We should
+   determine whether any targets *need* INIT_FRAME_PC to happen
+   after INIT_EXTRA_FRAME_INFO and come up with a simple way to
+   express what goes on here.
+
+      INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
+               (where the PC is already set up) and here (where it isn't).
+      INIT_FRAME_PC is only called from here, always after
+               INIT_EXTRA_FRAME_INFO.
+   
+   The catch is the MIPS, where INIT_EXTRA_FRAME_INFO requires the PC
+   value (which hasn't been set yet).  Some other machines appear to
+   require INIT_EXTRA_FRAME_INFO before they can do INIT_FRAME_PC.  Phoo.
+
+   We shouldn't need INIT_FRAME_PC_FIRST to add more complication to
+   an already overcomplicated part of GDB.   [email protected], 15Sep92.
+
+   Assuming that some machines need INIT_FRAME_PC after
+   INIT_EXTRA_FRAME_INFO, one possible scheme:
+
+   SETUP_INNERMOST_FRAME()
+     Default version is just create_new_frame (read_fp ()),
+     read_pc ()).  Machines with extra frame info would do that (or the
+     local equivalent) and then set the extra fields.
+   SETUP_ARBITRARY_FRAME(argc, argv)
+     Only change here is that create_new_frame would no longer init extra
+     frame info; SETUP_ARBITRARY_FRAME would have to do that.
+   INIT_PREV_FRAME(fromleaf, prev)
+     Replace INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC.  This should
+     also return a flag saying whether to keep the new frame, or
+     whether to discard it, because on some machines (e.g.  mips) it
+     is really awkward to have FRAME_CHAIN_VALID called *before*
+     INIT_EXTRA_FRAME_INFO (there is no good way to get information
+     deduced in FRAME_CHAIN_VALID into the extra fields of the new frame).
+   std_frame_pc(fromleaf, prev)
+     This is the default setting for INIT_PREV_FRAME.  It just does what
+     the default INIT_FRAME_PC does.  Some machines will call it from
+     INIT_PREV_FRAME (either at the beginning, the end, or in the middle).
+     Some machines won't use it.
+   [email protected], 13Apr93, 31Jan94, 14Dec94.  */
+
+#ifdef INIT_FRAME_PC_FIRST
+  INIT_FRAME_PC_FIRST (fromleaf, prev);
+#endif

 
 #ifdef INIT_EXTRA_FRAME_INFO
 
 #ifdef INIT_EXTRA_FRAME_INFO

-  INIT_EXTRA_FRAME_INFO(prev);
+  INIT_EXTRA_FRAME_INFO(fromleaf, prev);

 #endif
 
   /* This entry is in the frame queue now, which is good since
 #endif
 
   /* This entry is in the frame queue now, which is good since

-     FRAME_SAVED_PC may use that queue to figure out it's value
-     (see m-sparc.h).  We want the pc saved in the inferior frame. */
-  prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (next_frame) :
-             next_frame ? FRAME_SAVED_PC (next_frame) : read_pc ());
+     FRAME_SAVED_PC may use that queue to figure out its value
+     (see tm-sparc.h).  We want the pc saved in the inferior frame. */
+  INIT_FRAME_PC(fromleaf, prev);
+
+  /* If ->frame and ->pc are unchanged, we are in the process of getting
+     ourselves into an infinite backtrace.  Some architectures check this
+     in FRAME_CHAIN or thereabouts, but it seems like there is no reason
+     this can't be an architecture-independent check.  */
+  if (next_frame != NULL)
+    {
+      if (prev->frame == next_frame->frame
+         && prev->pc == next_frame->pc)
+       {
+         next_frame->prev = NULL;
+         obstack_free (&frame_cache_obstack, prev);
+         return NULL;
+       }
+    }
+
+  find_pc_partial_function (prev->pc, &name,
+                           (CORE_ADDR *)NULL,(CORE_ADDR *)NULL);
+  if (IN_SIGTRAMP (prev->pc, name))
+    prev->signal_handler_caller = 1;

 
   return prev;
 }
 
 CORE_ADDR
 get_frame_pc (frame)
 
   return prev;
 }
 
 CORE_ADDR
 get_frame_pc (frame)

-     FRAME frame;
+     struct frame_info *frame;

 {
 {

-  struct frame_info *fi;
-  fi = get_frame_info (frame);
-  return fi->pc;
+  return frame->pc;

 }
 
 }
 

+#if defined (FRAME_FIND_SAVED_REGS)

 /* Find the addresses in which registers are saved in FRAME.  */
 
 void
 /* Find the addresses in which registers are saved in FRAME.  */
 
 void

-get_frame_saved_regs (frame_info_addr, saved_regs_addr)
-     struct frame_info *frame_info_addr;
+get_frame_saved_regs (frame, saved_regs_addr)
+     struct frame_info *frame;

      struct frame_saved_regs *saved_regs_addr;
 {
      struct frame_saved_regs *saved_regs_addr;
 {

-  FRAME_FIND_SAVED_REGS (frame_info_addr, *saved_regs_addr);
+  FRAME_FIND_SAVED_REGS (frame, *saved_regs_addr);

 }
 }

+#endif

 
 /* Return the innermost lexical block in execution
    in a specified stack frame.  The frame address is assumed valid.  */
 
 struct block *
 get_frame_block (frame)
 
 /* Return the innermost lexical block in execution
    in a specified stack frame.  The frame address is assumed valid.  */
 
 struct block *
 get_frame_block (frame)

-     FRAME frame;
+     struct frame_info *frame;

 {
 {

-  struct frame_info *fi;
-
-  fi = get_frame_info (frame);
-  return block_for_pc (fi->pc);
+  CORE_ADDR pc;
+
+  pc = frame->pc;
+  if (frame->next != 0 && frame->next->signal_handler_caller == 0)
+    /* We are not in the innermost frame and we were not interrupted
+       by a signal.  We need to subtract one to get the correct block,
+       in case the call instruction was the last instruction of the block.
+       If there are any machines on which the saved pc does not point to
+       after the call insn, we probably want to make frame->pc point after
+       the call insn anyway.  */
+    --pc;
+  return block_for_pc (pc);

 }
 
 struct block *
 }
 
 struct block *


@@ -317,24 +487,33 @@ CORE_ADDR
 get_pc_function_start (pc)
      CORE_ADDR pc;
 {
 get_pc_function_start (pc)
      CORE_ADDR pc;
 {

-  register struct block *bl = block_for_pc (pc);
+  register struct block *bl;

   register struct symbol *symbol;
   register struct symbol *symbol;

-  if (bl == 0 || (symbol = block_function (bl)) == 0)
+  register struct minimal_symbol *msymbol;
+  CORE_ADDR fstart;
+
+  if ((bl = block_for_pc (pc)) != NULL &&
+      (symbol = block_function (bl)) != NULL)

     {
     {

-      register int misc_index = find_pc_misc_function (pc);
-      if (misc_index >= 0)
-       return misc_function_vector[misc_index].address;
-      return 0;
+      bl = SYMBOL_BLOCK_VALUE (symbol);
+      fstart = BLOCK_START (bl);

     }
     }

-  bl = SYMBOL_BLOCK_VALUE (symbol);
-  return BLOCK_START (bl);
+  else if ((msymbol = lookup_minimal_symbol_by_pc (pc)) != NULL)
+    {
+      fstart = SYMBOL_VALUE_ADDRESS (msymbol);
+    }
+  else
+    {
+      fstart = 0;
+    }
+  return (fstart);

 }
 
 /* Return the symbol for the function executing in frame FRAME.  */
 
 struct symbol *
 get_frame_function (frame)
 }
 
 /* Return the symbol for the function executing in frame FRAME.  */
 
 struct symbol *
 get_frame_function (frame)

-     FRAME frame;
+     struct frame_info *frame;

 {
   register struct block *bl = get_frame_block (frame);
   if (bl == 0)
 {
   register struct block *bl = get_frame_block (frame);
   if (bl == 0)


@@ -342,50 +521,29 @@ get_frame_function (frame)
   return block_function (bl);
 }
 \f
   return block_function (bl);
 }
 \f

-/* Return the innermost lexical block containing the specified pc value,
-   or 0 if there is none.  */
-
-extern struct symtab *psymtab_to_symtab ();
+/* Return the blockvector immediately containing the innermost lexical block
+   containing the specified pc value, or 0 if there is none.
+   PINDEX is a pointer to the index value of the block.  If PINDEX
+   is NULL, we don't pass this information back to the caller.  */

 
 

-struct block *
-block_for_pc (pc)
+struct blockvector *
+blockvector_for_pc (pc, pindex)

      register CORE_ADDR pc;
      register CORE_ADDR pc;

+     int *pindex;

 {
   register struct block *b;
   register int bot, top, half;
   register struct symtab *s;
 {
   register struct block *b;
   register int bot, top, half;
   register struct symtab *s;

-  register struct partial_symtab *ps;

   struct blockvector *bl;
 
   /* First search all symtabs for one whose file contains our pc */
   struct blockvector *bl;
 
   /* First search all symtabs for one whose file contains our pc */

-
-  for (s = symtab_list; s; s = s->next)
-    {
-      bl = BLOCKVECTOR (s);
-      b = BLOCKVECTOR_BLOCK (bl, 0);
-      if (BLOCK_START (b) <= pc
-         && BLOCK_END (b) > pc)
-       break;
-    }
-
-  if (s == 0)
-    for (ps = partial_symtab_list; ps; ps = ps->next)
-      {
-       if (ps->textlow <= pc
-           && ps->texthigh > pc)
-         {
-           if (ps->readin)
-             fatal ("Internal error: pc found in readin psymtab and not in any symtab.");
-           s = psymtab_to_symtab (ps);
-           bl = BLOCKVECTOR (s);
-           b = BLOCKVECTOR_BLOCK (bl, 0);
-           break;
-         }
-      }
-
+  s = find_pc_symtab (pc);

   if (s == 0)
     return 0;
 
   if (s == 0)
     return 0;
 

+  bl = BLOCKVECTOR (s);
+  b = BLOCKVECTOR_BLOCK (bl, 0);
+

   /* Then search that symtab for the smallest block that wins.  */
   /* Use binary search to find the last block that starts before PC.  */
 
   /* Then search that symtab for the smallest block that wins.  */
   /* Use binary search to find the last block that starts before PC.  */
 


@@ -408,13 +566,33 @@ block_for_pc (pc)
     {
       b = BLOCKVECTOR_BLOCK (bl, bot);
       if (BLOCK_END (b) > pc)
     {
       b = BLOCKVECTOR_BLOCK (bl, bot);
       if (BLOCK_END (b) > pc)

-       return b;
+       {
+         if (pindex)
+           *pindex = bot;
+         return bl;
+       }

       bot--;
     }
 
   return 0;
 }
 
       bot--;
     }
 
   return 0;
 }
 

+/* Return the innermost lexical block containing the specified pc value,
+   or 0 if there is none.  */
+
+struct block *
+block_for_pc (pc)
+     register CORE_ADDR pc;
+{
+  register struct blockvector *bl;
+  int index;
+
+  bl = blockvector_for_pc (pc, &index);
+  if (bl)
+    return BLOCKVECTOR_BLOCK (bl, index);
+  return 0;
+}
+

 /* Return the function containing pc value PC.
    Returns 0 if function is not known.  */
 
 /* Return the function containing pc value PC.
    Returns 0 if function is not known.  */
 


@@ -428,169 +606,260 @@ find_pc_function (pc)
   return block_function (b);
 }
 
   return block_function (b);
 }
 

-/* Finds the "function" (text symbol) that is smaller than PC
-   but greatest of all of the potential text symbols.  Sets
-   *NAME and/or *ADDRESS conditionally if that pointer is non-zero.
-   Returns 0 if it couldn't find anything, 1 if it did.
+/* These variables are used to cache the most recent result
+ * of find_pc_partial_function. */
+
+static CORE_ADDR cache_pc_function_low = 0;
+static CORE_ADDR cache_pc_function_high = 0;
+static char *cache_pc_function_name = 0;
+
+/* Clear cache, e.g. when symbol table is discarded. */
+
+void
+clear_pc_function_cache()
+{
+  cache_pc_function_low = 0;
+  cache_pc_function_high = 0;
+  cache_pc_function_name = (char *)0;
+}

 
 

-   Note that there are several possible responses:
-   * Set *NAME and *ADDRESS to nonzero values and return 0
-   * Set *NAME and *ADDRESS to zero and return 0
-   * Don't set *NAME and *ADDRESS and return 1
-   (I don't know whether it *should* work this way, but I'd rather
-   document it than risk breaking code
-   which depends on this behavior).  */
+/* Finds the "function" (text symbol) that is smaller than PC but
+   greatest of all of the potential text symbols.  Sets *NAME and/or
+   *ADDRESS conditionally if that pointer is non-null.  If ENDADDR is
+   non-null, then set *ENDADDR to be the end of the function
+   (exclusive), but passing ENDADDR as non-null means that the
+   function might cause symbols to be read.  This function either
+   succeeds or fails (not halfway succeeds).  If it succeeds, it sets
+   *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
+   If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero
+   and returns 0.  */

 
 int
 
 int

-find_pc_partial_function (pc, name, address)
+find_pc_partial_function (pc, name, address, endaddr)

      CORE_ADDR pc;
      char **name;
      CORE_ADDR *address;
      CORE_ADDR pc;
      char **name;
      CORE_ADDR *address;

+     CORE_ADDR *endaddr;

 {
 {

-  struct partial_symtab *pst = find_pc_psymtab (pc);
+  struct partial_symtab *pst;

   struct symbol *f;
   struct symbol *f;

-  int miscfunc;
+  struct minimal_symbol *msymbol;

   struct partial_symbol *psb;
   struct partial_symbol *psb;

+  struct obj_section *sec;
+
+  if (pc >= cache_pc_function_low && pc < cache_pc_function_high)
+    goto return_cached_value;

 
 

+  /* If sigtramp is in the u area, it counts as a function (especially
+     important for step_1).  */
+#if defined SIGTRAMP_START
+  if (IN_SIGTRAMP (pc, (char *)NULL))
+    {
+      cache_pc_function_low = SIGTRAMP_START;
+      cache_pc_function_high = SIGTRAMP_END;
+      cache_pc_function_name = "<sigtramp>";
+
+      goto return_cached_value;
+    }
+#endif
+
+  msymbol = lookup_minimal_symbol_by_pc (pc);
+  pst = find_pc_psymtab (pc);

   if (pst)
     {
   if (pst)
     {

+      /* Need to read the symbols to get a good value for the end address.  */
+      if (endaddr != NULL && !pst->readin)
+       {
+         /* Need to get the terminal in case symbol-reading produces
+            output.  */
+         target_terminal_ours_for_output ();
+         PSYMTAB_TO_SYMTAB (pst);
+       }
+

       if (pst->readin)
        {
       if (pst->readin)
        {

-         /* The information we want has already been read in.
-            We can go to the already readin symbols and we'll get
-            the best possible answer.  */
+         /* Checking whether the msymbol has a larger value is for the
+            "pathological" case mentioned in print_frame_info.  */

          f = find_pc_function (pc);
          f = find_pc_function (pc);

-         if (!f)
+         if (f != NULL
+             && (msymbol == NULL
+                 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
+                     >= SYMBOL_VALUE_ADDRESS (msymbol))))

            {
            {

-             /* No availible symbol.  */
-             if (name != 0)
-               *name = 0;
-             if (address != 0)
-               *address = 0;
-             return 0;
+             cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
+             cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
+             cache_pc_function_name = SYMBOL_NAME (f);
+             goto return_cached_value;

            }
            }

-
-         if (name)
-           *name = SYMBOL_NAME (f);
-         if (address)
-           *address = SYMBOL_VALUE (f);
-       }
-
-      /* Get the information from a combination of the pst
-        (static symbols), and the misc function vector (extern
-        symbols).  */
-      miscfunc = find_pc_misc_function (pc);
-      psb = find_pc_psymbol (pst, pc);
-
-      if (!psb && miscfunc == -1)
-       {
-         if (address != 0)
-           *address = 0;
-         if (name != 0)
-           *name = 0;
-         return 0;
-       }
-      if (!psb
-         || (miscfunc != -1
-             && SYMBOL_VALUE(psb) < misc_function_vector[miscfunc].address))
-       {
-         if (address)
-           *address = misc_function_vector[miscfunc].address;
-         if (name)
-           *name = misc_function_vector[miscfunc].name;

        }
       else
        {
        }
       else
        {

-         if (address)
-           *address = SYMBOL_VALUE (psb);
-         if (name)
-           *name = SYMBOL_NAME (psb);
+         /* Now that static symbols go in the minimal symbol table, perhaps
+            we could just ignore the partial symbols.  But at least for now
+            we use the partial or minimal symbol, whichever is larger.  */
+         psb = find_pc_psymbol (pst, pc);
+
+         if (psb
+             && (msymbol == NULL ||
+                 (SYMBOL_VALUE_ADDRESS (psb)
+                  >= SYMBOL_VALUE_ADDRESS (msymbol))))
+           {
+             /* This case isn't being cached currently. */
+             if (address)
+               *address = SYMBOL_VALUE_ADDRESS (psb);
+             if (name)
+               *name = SYMBOL_NAME (psb);
+             /* endaddr non-NULL can't happen here.  */
+             return 1;
+           }

        }
     }
        }
     }

-  else
-    /* Must be in the misc function stuff.  */
+
+  /* Not in the normal symbol tables, see if the pc is in a known section.
+     If it's not, then give up.  This ensures that anything beyond the end
+     of the text seg doesn't appear to be part of the last function in the
+     text segment.  */
+
+  sec = find_pc_section (pc);
+
+  if (!sec)
+    msymbol = NULL;
+
+  /* Must be in the minimal symbol table.  */
+  if (msymbol == NULL)

     {
     {

-      miscfunc = find_pc_misc_function (pc);
-      if (miscfunc == -1)
-       return 0;
-      if (address)
-       *address = misc_function_vector[miscfunc].address;
-      if (name)
-       *name = misc_function_vector[miscfunc].name;
+      /* No available symbol.  */
+      if (name != NULL)
+       *name = 0;
+      if (address != NULL)
+       *address = 0;
+      if (endaddr != NULL)
+       *endaddr = 0;
+      return 0;

     }
     }

+
+  /* See if we're in a transfer table for Sun shared libs.
+
+     Note the hack for Sun shared library transfer tables creates
+     problems for single stepping through the return path from a shared
+     library call if the return path includes trampoline code.
+
+     I don't really understand the reasoning behind the magic handling
+     for mst_trampoline symbols.  */
+
+#ifdef INHIBIT_SUNSOLIB_TRANSFER_TABLE_HACK
+    cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
+#else
+  if (msymbol -> type == mst_text || msymbol -> type == mst_file_text)
+    cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
+  else
+    /* It is a transfer table for Sun shared libraries.  */
+    cache_pc_function_low = pc - FUNCTION_START_OFFSET;
+#endif
+
+  cache_pc_function_name = SYMBOL_NAME (msymbol);
+
+  /* Use the lesser of the next minimal symbol, or the end of the section, as
+     the end of the function.  */
+
+  if (SYMBOL_NAME (msymbol + 1) != NULL
+      && SYMBOL_VALUE_ADDRESS (msymbol + 1) < sec->endaddr)
+    cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + 1);
+  else
+    /* We got the start address from the last msymbol in the objfile.
+       So the end address is the end of the section.  */
+    cache_pc_function_high = sec->endaddr;
+
+ return_cached_value:
+  if (address)
+    *address = cache_pc_function_low;
+  if (name)
+    *name = cache_pc_function_name;
+  if (endaddr)
+    *endaddr = cache_pc_function_high;

   return 1;
 }
 
   return 1;
 }
 

-/* Find the misc function whose address is the largest
-   while being less than PC.  Return its index in misc_function_vector.
-   Returns -1 if PC is not in suitable range.  */
+/* Return the innermost stack frame executing inside of BLOCK,
+   or NULL if there is no such frame.  If BLOCK is NULL, just return NULL.  */

 
 

-int
-find_pc_misc_function (pc)
-     register CORE_ADDR pc;
+struct frame_info *
+block_innermost_frame (block)
+     struct block *block;

 {
 {

-  register int lo = 0;
-  register int hi = misc_function_count-1;
-  register int new;
-  register int distance;
-
-  /* Note that the last thing in the vector is always _etext.  */
-  /* Actually, "end", now that non-functions
-     go on the misc_function_vector.  */
-
-  /* Above statement is not *always* true - fix for case where there are */
-  /* no misc functions at all (ie no symbol table has been read). */
-  if (hi < 0) return -1;        /* no misc functions recorded */
-
-  /* trivial reject range test */
-  if (pc < misc_function_vector[0].address ||
-      pc > misc_function_vector[hi].address)
-    return -1;
-
-  /* Note that the following search will not return hi if
-     pc == misc_function_vector[hi].address.  If "end" points to the
-     first unused location, this is correct and the above test
-     simply needs to be changed to
-     "pc >= misc_function_vector[hi].address".  */
-  do {
-    new = (lo + hi) >> 1;
-    distance = misc_function_vector[new].address - pc;
-    if (distance == 0)
-      return new;              /* an exact match */
-    else if (distance > 0)
-      hi = new;
-    else
-      lo = new;
-  } while (hi-lo != 1);
-
-  /* if here, we had no exact match, so return the lower choice */
-  return lo;
+  struct frame_info *frame;
+  register CORE_ADDR start;
+  register CORE_ADDR end;
+
+  if (block == NULL)
+    return NULL;
+
+  start = BLOCK_START (block);
+  end = BLOCK_END (block);
+
+  frame = NULL;
+  while (1)
+    {
+      frame = get_prev_frame (frame);
+      if (frame == NULL)
+       return NULL;
+      if (frame->pc >= start && frame->pc < end)
+       return frame;
+    }

 }
 
 }
 

-/* Return the innermost stack frame executing inside of the specified block,
-   or zero if there is no such frame.  */
+/* Return the full FRAME which corresponds to the given CORE_ADDR
+   or NULL if no FRAME on the chain corresponds to CORE_ADDR.  */

 
 

-FRAME
-block_innermost_frame (block)
-     struct block *block;
+struct frame_info *
+find_frame_addr_in_frame_chain (frame_addr)
+     CORE_ADDR frame_addr;

 {
 {

-  struct frame_info *fi;
-  register FRAME frame;
-  register CORE_ADDR start = BLOCK_START (block);
-  register CORE_ADDR end = BLOCK_END (block);
+  struct frame_info *frame = NULL;
+
+  if (frame_addr == (CORE_ADDR)0)
+    return NULL;

 
 

-  frame = 0;

   while (1)
     {
       frame = get_prev_frame (frame);
   while (1)
     {
       frame = get_prev_frame (frame);

-      if (frame == 0)
-       return 0;
-      fi = get_frame_info (frame);
-      if (fi->pc >= start && fi->pc < end)
+      if (frame == NULL)
+       return NULL;
+      if (FRAME_FP (frame) == frame_addr)

        return frame;
     }
 }
 
        return frame;
     }
 }
 

+#ifdef SIGCONTEXT_PC_OFFSET
+/* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp.  */
+
+CORE_ADDR
+sigtramp_saved_pc (frame)
+     struct frame_info *frame;
+{
+  CORE_ADDR sigcontext_addr;
+  char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
+  int ptrbytes = TARGET_PTR_BIT / TARGET_CHAR_BIT;
+  int sigcontext_offs = (2 * TARGET_INT_BIT) / TARGET_CHAR_BIT;
+
+  /* Get sigcontext address, it is the third parameter on the stack.  */
+  if (frame->next)
+    sigcontext_addr = read_memory_integer (FRAME_ARGS_ADDRESS (frame->next)
+                                          + FRAME_ARGS_SKIP
+                                          + sigcontext_offs,
+                                          ptrbytes);
+  else
+    sigcontext_addr = read_memory_integer (read_register (SP_REGNUM)
+                                           + sigcontext_offs,
+                                          ptrbytes);
+
+  /* Don't cause a memory_error when accessing sigcontext in case the stack
+     layout has changed or the stack is corrupt.  */
+  target_read_memory (sigcontext_addr + SIGCONTEXT_PC_OFFSET, buf, ptrbytes);
+  return extract_unsigned_integer (buf, ptrbytes);
+}
+#endif /* SIGCONTEXT_PC_OFFSET */
+

 void
 _initialize_blockframe ()
 {
 void
 _initialize_blockframe ()
 {