import gdb-1999-07-07 post reformat

1 files changed, 143 insertions, 142 deletions

diff --git a/gdb/blockframe.c b/gdb/blockframe.c
index 87ce8bf..26a26ae 100644
--- a/gdb/blockframe.c
+++ b/gdb/blockframe.c
@@ -1,23 +1,24 @@
 /* Get info from stack frames;
    convert between frames, blocks, functions and pc values.
    Copyright 1986, 87, 88, 89, 91, 94, 95, 96, 97, 1998
-             Free Software Foundation, Inc.
+   Free Software Foundation, Inc.
 
-This file is part of GDB.
+   This file is part of GDB.
 
-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
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   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
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-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.
+   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
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   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 "symtab.h"
@@ -45,14 +46,14 @@ default_frame_chain_valid (chain, thisframe)
      struct frame_info *thisframe;
 {
   return ((chain) != 0
-	  && !inside_main_func ((thisframe) -> pc)
-	  && !inside_entry_func ((thisframe) -> pc));
+	  && !inside_main_func ((thisframe)->pc)
+	  && !inside_entry_func ((thisframe)->pc));
 }
 
 /* Use the alternate method of avoiding running up off the end of the
    frame chain or following frames back into the startup code.  See
    the comments in objfiles.h. */
-   
+
 int
 alternate_frame_chain_valid (chain, thisframe)
      CORE_ADDR chain;
@@ -63,7 +64,7 @@ alternate_frame_chain_valid (chain, thisframe)
 }
 
 /* A very simple method of determining a valid frame */
-   
+
 int
 nonnull_frame_chain_valid (chain, thisframe)
      CORE_ADDR chain;
@@ -91,13 +92,13 @@ inside_entry_file (addr)
   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
     {
       /* Do not stop backtracing if the pc is in the call dummy
-	 at the entry point.  */
+         at the entry point.  */
       /* FIXME: Won't always work with zeros for the last two arguments */
-      if (PC_IN_CALL_DUMMY (addr, 0, 0))	
+      if (PC_IN_CALL_DUMMY (addr, 0, 0))
 	return 0;
     }
-  return (addr >= symfile_objfile -> ei.entry_file_lowpc &&
-	  addr <  symfile_objfile -> ei.entry_file_highpc);
+  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
@@ -110,7 +111,7 @@ inside_entry_file (addr)
 
 int
 inside_main_func (pc)
-CORE_ADDR pc;
+     CORE_ADDR pc;
 {
   if (pc == 0)
     return 1;
@@ -121,22 +122,22 @@ CORE_ADDR pc;
      This is for FRAME_CHAIN_VALID_ALTERNATE. I do this for coff, because
      it is unable to set it up and symbol reading time. */
 
-  if (symfile_objfile -> ei.main_func_lowpc == INVALID_ENTRY_LOWPC &&
-      symfile_objfile -> ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
+  if (symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC &&
+      symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
     {
       struct symbol *mainsym;
 
       mainsym = lookup_symbol ("main", NULL, VAR_NAMESPACE, NULL, NULL);
-      if (mainsym && SYMBOL_CLASS(mainsym) == LOC_BLOCK)
-        {
-          symfile_objfile->ei.main_func_lowpc = 
+      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 = 
+	  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);
+  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
@@ -158,13 +159,13 @@ inside_entry_func (pc)
   if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
     {
       /* Do not stop backtracing if the pc is in the call dummy
-	 at the entry point.  */
+         at the entry point.  */
       /* FIXME: Won't always work with zeros for the last two arguments */
       if (PC_IN_CALL_DUMMY (pc, 0, 0))
 	return 0;
     }
-  return (symfile_objfile -> ei.entry_func_lowpc  <= pc &&
-	  symfile_objfile -> ei.entry_func_highpc > pc);
+  return (symfile_objfile->ei.entry_func_lowpc <= pc &&
+	  symfile_objfile->ei.entry_func_highpc > pc);
 }
 
 /* Info about the innermost stack frame (contents of FP register) */
@@ -188,7 +189,7 @@ void
 frame_saved_regs_zalloc (fi)
      struct frame_info *fi;
 {
-  fi->saved_regs = (CORE_ADDR*)
+  fi->saved_regs = (CORE_ADDR *)
     frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
   memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
 }
@@ -237,7 +238,7 @@ create_new_frame (addr, pc)
   fi->prev = NULL;
   fi->frame = addr;
   fi->pc = pc;
-  find_pc_partial_function (pc, &name, (CORE_ADDR *)NULL,(CORE_ADDR *)NULL);
+  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
@@ -266,7 +267,7 @@ flush_cached_frames ()
   obstack_free (&frame_cache_obstack, 0);
   obstack_init (&frame_cache_obstack);
 
-  current_frame = NULL;  /* Invalidate cache */
+  current_frame = NULL;		/* Invalidate cache */
   select_frame (NULL, -1);
   annotate_frames_invalid ();
 }
@@ -306,7 +307,7 @@ frameless_look_for_prologue (frame)
       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.  */
+         not how long it is.  */
       after_prologue = SKIP_PROLOGUE_FRAMELESS_P (after_prologue);
 #else
       after_prologue = SKIP_PROLOGUE (after_prologue);
@@ -360,9 +361,9 @@ get_prev_frame (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.  */
+         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)
 	{
 	  error ("You haven't set up a process's stack to examine.");
@@ -395,18 +396,18 @@ get_prev_frame (next_frame)
   if (!fromleaf)
     {
       /* 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
-	 called by the outermost frame.  This means that if start
-	 calls main without a frame, we'll return 0 (which is fine
-	 anyway).
-
-	 Nope; there's a problem.  This also returns when the current
-	 routine is a leaf of main.  This is unacceptable.  We move
-	 this to after the ffi test; I'd rather have backtraces from
-	 start go curfluy than have an abort called from main not show
-	 main.  */
+         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
+         called by the outermost frame.  This means that if start
+         calls main without a frame, we'll return 0 (which is fine
+         anyway).
+
+         Nope; there's a problem.  This also returns when the current
+         routine is a leaf of main.  This is unacceptable.  We move
+         this to after the ffi test; I'd rather have backtraces from
+         start go curfluy than have an abort called from main not show
+         main.  */
       address = FRAME_CHAIN (next_frame);
       if (!FRAME_CHAIN_VALID (address, next_frame))
 	return 0;
@@ -432,11 +433,11 @@ get_prev_frame (next_frame)
    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.
-   
+   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.
@@ -448,24 +449,24 @@ get_prev_frame (next_frame)
    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.
+   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.
+   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).
+   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.
+   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.
    kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94.  */
 
 #ifdef INIT_FRAME_PC_FIRST
@@ -473,13 +474,13 @@ get_prev_frame (next_frame)
 #endif
 
 #ifdef INIT_EXTRA_FRAME_INFO
-  INIT_EXTRA_FRAME_INFO(fromleaf, prev);
+  INIT_EXTRA_FRAME_INFO (fromleaf, prev);
 #endif
 
   /* This entry is in the frame queue now, which is good since
      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);
+  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
@@ -497,7 +498,7 @@ get_prev_frame (next_frame)
     }
 
   find_pc_partial_function (prev->pc, &name,
-			    (CORE_ADDR *)NULL,(CORE_ADDR *)NULL);
+			    (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
   if (IN_SIGTRAMP (prev->pc, name))
     prev->signal_handler_caller = 1;
 
@@ -524,7 +525,7 @@ get_frame_saved_regs (frame, saved_regs_addr)
 {
   if (frame->saved_regs == NULL)
     {
-      frame->saved_regs = (CORE_ADDR*)
+      frame->saved_regs = (CORE_ADDR *)
 	frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
     }
   if (saved_regs_addr == NULL)
@@ -618,13 +619,13 @@ blockvector_for_pc_sect (pc, section, pindex, symtab)
      struct sec *section;
      int *pindex;
      struct symtab *symtab;
-     
+
 {
   register struct block *b;
   register int bot, top, half;
   struct blockvector *bl;
 
-  if (symtab == 0)	/* if no symtab specified by caller */
+  if (symtab == 0)		/* if no symtab specified by caller */
     {
       /* First search all symtabs for one whose file contains our pc */
       if ((symtab = find_pc_sect_symtab (pc, section)) == 0)
@@ -733,19 +734,19 @@ find_pc_function (pc)
 /* 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;
+static CORE_ADDR cache_pc_function_low = 0;
+static CORE_ADDR cache_pc_function_high = 0;
+static char *cache_pc_function_name = 0;
 static struct sec *cache_pc_function_section = NULL;
 
 /* Clear cache, e.g. when symbol table is discarded. */
 
 void
-clear_pc_function_cache()
+clear_pc_function_cache ()
 {
   cache_pc_function_low = 0;
   cache_pc_function_high = 0;
-  cache_pc_function_name = (char *)0;
+  cache_pc_function_name = (char *) 0;
   cache_pc_function_section = NULL;
 }
 
@@ -762,23 +763,23 @@ clear_pc_function_cache()
 
 int
 find_pc_sect_partial_function (pc, section, name, address, endaddr)
-     CORE_ADDR  pc;
-     asection  *section;
-     char     **name;
+     CORE_ADDR pc;
+     asection *section;
+     char **name;
      CORE_ADDR *address;
      CORE_ADDR *endaddr;
 {
   struct partial_symtab *pst;
-  struct symbol         *f;
+  struct symbol *f;
   struct minimal_symbol *msymbol;
   struct partial_symbol *psb;
-  struct obj_section    *osect;
+  struct obj_section *osect;
   int i;
   CORE_ADDR mapped_pc;
 
   mapped_pc = overlay_mapped_address (pc, section);
 
-  if (mapped_pc >= cache_pc_function_low && 
+  if (mapped_pc >= cache_pc_function_low &&
       mapped_pc < cache_pc_function_high &&
       section == cache_pc_function_section)
     goto return_cached_value;
@@ -786,11 +787,11 @@ find_pc_sect_partial_function (pc, section, name, address, endaddr)
   /* If sigtramp is in the u area, it counts as a function (especially
      important for step_1).  */
 #if defined SIGTRAMP_START
-  if (IN_SIGTRAMP (mapped_pc, (char *)NULL))
+  if (IN_SIGTRAMP (mapped_pc, (char *) NULL))
     {
-      cache_pc_function_low     = SIGTRAMP_START (mapped_pc);
-      cache_pc_function_high    = SIGTRAMP_END (mapped_pc);
-      cache_pc_function_name    = "<sigtramp>";
+      cache_pc_function_low = SIGTRAMP_START (mapped_pc);
+      cache_pc_function_high = SIGTRAMP_END (mapped_pc);
+      cache_pc_function_name = "<sigtramp>";
       cache_pc_function_section = section;
       goto return_cached_value;
     }
@@ -819,9 +820,9 @@ find_pc_sect_partial_function (pc, section, name, address, endaddr)
 		  || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
 		      >= SYMBOL_VALUE_ADDRESS (msymbol))))
 	    {
-	      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);
+	      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);
 	      cache_pc_function_section = section;
 	      goto return_cached_value;
 	    }
@@ -872,21 +873,21 @@ find_pc_sect_partial_function (pc, section, name, address, endaddr)
       return 0;
     }
 
-  cache_pc_function_low     = SYMBOL_VALUE_ADDRESS (msymbol);
-  cache_pc_function_name    = SYMBOL_NAME (msymbol);
+  cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
+  cache_pc_function_name = SYMBOL_NAME (msymbol);
   cache_pc_function_section = section;
 
   /* Use the lesser of the next minimal symbol in the same section, or
      the end of the section, as the end of the function.  */
-  
+
   /* Step over other symbols at this same address, and symbols in
      other sections, to find the next symbol in this section with
      a different address.  */
 
-  for (i=1; SYMBOL_NAME (msymbol+i) != NULL; i++)
+  for (i = 1; SYMBOL_NAME (msymbol + i) != NULL; i++)
     {
-      if (SYMBOL_VALUE_ADDRESS (msymbol+i) != SYMBOL_VALUE_ADDRESS (msymbol) 
-	  && SYMBOL_BFD_SECTION (msymbol+i) == SYMBOL_BFD_SECTION (msymbol))
+      if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
+	&& SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
 	break;
     }
 
@@ -898,33 +899,33 @@ find_pc_sect_partial_function (pc, section, name, address, endaddr)
        So the end address is the end of the section.  */
     cache_pc_function_high = osect->endaddr;
 
- return_cached_value:
+return_cached_value:
 
   if (address)
     {
       if (pc_in_unmapped_range (pc, section))
-        *address = overlay_unmapped_address (cache_pc_function_low, section);
+	*address = overlay_unmapped_address (cache_pc_function_low, section);
       else
-        *address = cache_pc_function_low;
+	*address = cache_pc_function_low;
     }
-    
+
   if (name)
     *name = cache_pc_function_name;
 
   if (endaddr)
     {
       if (pc_in_unmapped_range (pc, section))
-        {
+	{
 	  /* Because the high address is actually beyond the end of
 	     the function (and therefore possibly beyond the end of
 	     the overlay), we must actually convert (high - 1)
 	     and then add one to that. */
 
-	  *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1, 
+	  *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
 						   section);
-        }
+	}
       else
-        *endaddr = cache_pc_function_high;
+	*endaddr = cache_pc_function_high;
     }
 
   return 1;
@@ -934,12 +935,12 @@ find_pc_sect_partial_function (pc, section, name, address, endaddr)
 
 int
 find_pc_partial_function (pc, name, address, endaddr)
-     CORE_ADDR  pc;
-     char     **name;
+     CORE_ADDR pc;
+     char **name;
      CORE_ADDR *address;
      CORE_ADDR *endaddr;
 {
-  asection     *section;
+  asection *section;
 
   section = find_pc_overlay (pc);
   return find_pc_sect_partial_function (pc, section, name, address, endaddr);
@@ -982,7 +983,7 @@ find_frame_addr_in_frame_chain (frame_addr)
 {
   struct frame_info *frame = NULL;
 
-  if (frame_addr == (CORE_ADDR)0)
+  if (frame_addr == (CORE_ADDR) 0)
     return NULL;
 
   while (1)
@@ -1015,7 +1016,7 @@ sigtramp_saved_pc (frame)
 					   ptrbytes);
   else
     sigcontext_addr = read_memory_integer (read_register (SP_REGNUM)
-					    + sigcontext_offs,
+					   + sigcontext_offs,
 					   ptrbytes);
 
   /* Don't cause a memory_error when accessing sigcontext in case the stack
@@ -1131,12 +1132,12 @@ static struct dummy_frame *dummy_frame_stack = NULL;
    Search the stack of dummy frames for one matching the given PC, FP and SP.
    This is the work-horse for pc_in_call_dummy and read_register_dummy     */
 
-char * 
+char *
 generic_find_dummy_frame (pc, fp)
      CORE_ADDR pc;
      CORE_ADDR fp;
 {
-  struct dummy_frame * dummyframe;
+  struct dummy_frame *dummyframe;
 
   if (pc != entry_point_address ())
     return 0;
@@ -1179,7 +1180,7 @@ generic_read_register_dummy (pc, fp, regno)
 
   if (dummy_regs)
     return extract_address (&dummy_regs[REGISTER_BYTE (regno)],
-			    REGISTER_RAW_SIZE(regno));
+			    REGISTER_RAW_SIZE (regno));
   else
     return 0;
 }
@@ -1216,10 +1217,10 @@ generic_push_dummy_frame ()
   dummy_frame = xmalloc (sizeof (struct dummy_frame));
   dummy_frame->registers = xmalloc (REGISTER_BYTES);
 
-  dummy_frame->pc   = read_register (PC_REGNUM);
-  dummy_frame->sp   = read_register (SP_REGNUM);
-  dummy_frame->top  = dummy_frame->sp;
-  dummy_frame->fp   = fp;
+  dummy_frame->pc = read_register (PC_REGNUM);
+  dummy_frame->sp = read_register (SP_REGNUM);
+  dummy_frame->top = dummy_frame->sp;
+  dummy_frame->fp = fp;
   read_register_bytes (0, dummy_frame->registers, REGISTER_BYTES);
   dummy_frame->next = dummy_frame_stack;
   dummy_frame_stack = dummy_frame;
@@ -1238,10 +1239,10 @@ generic_save_dummy_frame_tos (sp)
 
 void
 generic_pop_current_frame (pop)
-  void (*pop) PARAMS ((struct frame_info *frame));
+     void (*pop) PARAMS ((struct frame_info * frame));
 {
   struct frame_info *frame = get_current_frame ();
-  if (PC_IN_CALL_DUMMY(frame->pc, frame->frame, frame->frame))
+  if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
     generic_pop_dummy_frame ();
   else
     pop (frame);
@@ -1271,20 +1272,20 @@ generic_pop_dummy_frame ()
 /* Function: frame_chain_valid 
    Returns true for a user frame or a call_function_by_hand dummy frame,
    and false for the CRT0 start-up frame.  Purpose is to terminate backtrace */
- 
+
 int
 generic_frame_chain_valid (fp, fi)
      CORE_ADDR fp;
      struct frame_info *fi;
 {
-  if (PC_IN_CALL_DUMMY(FRAME_SAVED_PC(fi), fp, fp))
-    return 1;   /* don't prune CALL_DUMMY frames */
-  else          /* fall back to default algorithm (see frame.h) */
+  if (PC_IN_CALL_DUMMY (FRAME_SAVED_PC (fi), fp, fp))
+    return 1;			/* don't prune CALL_DUMMY frames */
+  else				/* fall back to default algorithm (see frame.h) */
     return (fp != 0
 	    && (INNER_THAN (fi->frame, fp) || fi->frame == fp)
-	    && !inside_entry_file (FRAME_SAVED_PC(fi)));
+	    && !inside_entry_file (FRAME_SAVED_PC (fi)));
 }
- 
+
 /* Function: fix_call_dummy
    Stub function.  Generic dumy frames typically do not need to fix
    the frame being created */
@@ -1342,7 +1343,7 @@ generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
   if (optimized != NULL)
     *optimized = 0;
 
-  if (addrp)		/* default assumption: not found in memory */
+  if (addrp)			/* default assumption: not found in memory */
     *addrp = 0;
 
   /* Note: since the current frame's registers could only have been
@@ -1354,34 +1355,34 @@ generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
     {
       if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
 	{
-	  if (lval)			/* found it in a CALL_DUMMY frame */
+	  if (lval)		/* found it in a CALL_DUMMY frame */
 	    *lval = not_lval;
 	  if (raw_buffer)
-	    memcpy (raw_buffer, 
-		    generic_find_dummy_frame (frame->pc, frame->frame) + 
+	    memcpy (raw_buffer,
+		    generic_find_dummy_frame (frame->pc, frame->frame) +
 		    REGISTER_BYTE (regnum),
 		    REGISTER_RAW_SIZE (regnum));
-	      return;
+	  return;
 	}
 
       FRAME_INIT_SAVED_REGS (frame);
       if (frame->saved_regs != NULL
 	  && frame->saved_regs[regnum] != 0)
 	{
-	  if (lval)			/* found it saved on the stack */
+	  if (lval)		/* found it saved on the stack */
 	    *lval = lval_memory;
 	  if (regnum == SP_REGNUM)
 	    {
-	      if (raw_buffer)		/* SP register treated specially */
-		store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), 
+	      if (raw_buffer)	/* SP register treated specially */
+		store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
 			       frame->saved_regs[regnum]);
 	    }
 	  else
 	    {
-	      if (addrp)		/* any other register */
+	      if (addrp)	/* any other register */
 		*addrp = frame->saved_regs[regnum];
 	      if (raw_buffer)
-		read_memory (frame->saved_regs[regnum], raw_buffer, 
+		read_memory (frame->saved_regs[regnum], raw_buffer,
 			     REGISTER_RAW_SIZE (regnum));
 	    }
 	  return;
@@ -1391,7 +1392,7 @@ generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
   /* If we get thru the loop to this point, it means the register was
      not saved in any frame.  Return the actual live-register value.  */
 
-  if (lval)				/* found it in a live register */
+  if (lval)			/* found it in a live register */
     *lval = lval_register;
   if (addrp)
     *addrp = REGISTER_BYTE (regnum);