import gdb-1999-07-07 post reformat

1 files changed, 429 insertions, 411 deletions

diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c
index 7d851d9..664b131 100644
--- a/gdb/alpha-tdep.c
+++ b/gdb/alpha-tdep.c
@@ -1,21 +1,22 @@
 /* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.
    Copyright 1993, 94, 95, 96, 97, 1998 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 "frame.h"
@@ -41,7 +42,7 @@ static CORE_ADDR heuristic_proc_start PARAMS ((CORE_ADDR));
 
 static alpha_extra_func_info_t heuristic_proc_desc PARAMS ((CORE_ADDR,
 							    CORE_ADDR,
-							    struct frame_info *));
+						      struct frame_info *));
 
 static alpha_extra_func_info_t find_proc_desc PARAMS ((CORE_ADDR,
 						       struct frame_info *));
@@ -57,7 +58,7 @@ static CORE_ADDR after_prologue PARAMS ((CORE_ADDR pc,
 					 alpha_extra_func_info_t proc_desc));
 
 static int alpha_in_prologue PARAMS ((CORE_ADDR pc,
-				alpha_extra_func_info_t proc_desc));
+				      alpha_extra_func_info_t proc_desc));
 
 static int alpha_about_to_return PARAMS ((CORE_ADDR pc));
 
@@ -67,7 +68,7 @@ void _initialize_alpha_tdep PARAMS ((void));
    time across a 2400 baud serial line.  Allows the user to limit this
    search.  */
 static unsigned int heuristic_fence_post = 0;
-
+/* *INDENT-OFF* */
 /* Layout of a stack frame on the alpha:
 
                 |				|
@@ -110,13 +111,16 @@ static unsigned int heuristic_fence_post = 0;
    -------------|-------------------------------|<-- sp
                 |				|
 */
+/* *INDENT-ON* */
+
+
 
-#define PROC_LOW_ADDR(proc) ((proc)->pdr.adr) /* least address */
+#define PROC_LOW_ADDR(proc) ((proc)->pdr.adr)	/* least address */
 /* These next two fields are kind of being hijacked.  I wonder if
    iline is too small for the values it needs to hold, if GDB is
    running on a 32-bit host.  */
-#define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline) /* upper address bound */
-#define PROC_DUMMY_FRAME(proc) ((proc)->pdr.cbLineOffset) /*CALL_DUMMY frame */
+#define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline)	/* upper address bound */
+#define PROC_DUMMY_FRAME(proc) ((proc)->pdr.cbLineOffset)	/*CALL_DUMMY frame */
 #define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
 #define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
 #define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
@@ -131,21 +135,22 @@ static unsigned int heuristic_fence_post = 0;
 #define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)
 
 struct linked_proc_info
-{
-  struct alpha_extra_func_info info;
-  struct linked_proc_info *next;
-} *linked_proc_desc_table = NULL;
-
+  {
+    struct alpha_extra_func_info info;
+    struct linked_proc_info *next;
+  }
+ *linked_proc_desc_table = NULL;
 
+
 /* Under GNU/Linux, signal handler invocations can be identified by the
    designated code sequence that is used to return from a signal
    handler.  In particular, the return address of a signal handler
    points to the following sequence (the first instruction is quadword
    aligned):
 
-	bis $30,$30,$16
-	addq $31,0x67,$0
-	call_pal callsys
+   bis $30,$30,$16
+   addq $31,0x67,$0
+   call_pal callsys
 
    Each instruction has a unique encoding, so we simply attempt to
    match the instruction the pc is pointing to with any of the above
@@ -159,7 +164,7 @@ struct linked_proc_info
    middle of the designated sequence, in which case there is no
    guarantee that we are in the middle of a sigreturn syscall.  Don't
    think this will be a problem in praxis, though.
-*/
+ */
 
 #ifndef TM_LINUXALPHA_H
 /* HACK: Provide a prototype when compiling this file for non
@@ -173,16 +178,23 @@ alpha_linux_sigtramp_offset (pc)
   unsigned int i[3], w;
   long off;
 
-  if (read_memory_nobpt(pc, (char *) &w, 4) != 0)
+  if (read_memory_nobpt (pc, (char *) &w, 4) != 0)
     return -1;
 
   off = -1;
   switch (w)
     {
-    case 0x47de0410: off = 0; break;	/* bis $30,$30,$16 */
-    case 0x43ecf400: off = 4; break;	/* addq $31,0x67,$0 */
-    case 0x00000083: off = 8; break;	/* call_pal callsys */
-    default:	     return -1;
+    case 0x47de0410:
+      off = 0;
+      break;			/* bis $30,$30,$16 */
+    case 0x43ecf400:
+      off = 4;
+      break;			/* addq $31,0x67,$0 */
+    case 0x00000083:
+      off = 8;
+      break;			/* call_pal callsys */
+    default:
+      return -1;
     }
   pc -= off;
   if (pc & 0x7)
@@ -191,7 +203,7 @@ alpha_linux_sigtramp_offset (pc)
       return -1;
     }
 
-  if (read_memory_nobpt(pc, (char *) i, sizeof(i)) != 0)
+  if (read_memory_nobpt (pc, (char *) i, sizeof (i)) != 0)
     return -1;
 
   if (i[0] == 0x47de0410 && i[1] == 0x43ecf400 && i[2] == 0x00000083)
@@ -199,8 +211,8 @@ alpha_linux_sigtramp_offset (pc)
 
   return -1;
 }
-
 
+
 /* Under OSF/1, the __sigtramp routine is frameless and has a frame
    size of zero, but we are able to backtrace through it.  */
 CORE_ADDR
@@ -209,14 +221,14 @@ alpha_osf_skip_sigtramp_frame (frame, pc)
      CORE_ADDR pc;
 {
   char *name;
-  find_pc_partial_function (pc, &name, (CORE_ADDR *)NULL, (CORE_ADDR *)NULL);
+  find_pc_partial_function (pc, &name, (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
   if (IN_SIGTRAMP (pc, name))
     return frame->frame;
   else
     return 0;
 }
-
 
+
 /* Dynamically create a signal-handler caller procedure descriptor for
    the signal-handler return code starting at address LOW_ADDR.  The
    descriptor is added to the linked_proc_desc_table.  */
@@ -236,20 +248,20 @@ push_sigtramp_desc (low_addr)
   proc_desc = &link->info;
 
   proc_desc->numargs = 0;
-  PROC_LOW_ADDR (proc_desc)	= low_addr;
-  PROC_HIGH_ADDR (proc_desc)	= low_addr + 3 * 4;
-  PROC_DUMMY_FRAME (proc_desc)	= 0;
-  PROC_FRAME_OFFSET (proc_desc)	= 0x298; /* sizeof(struct sigcontext_struct) */
-  PROC_FRAME_REG (proc_desc)	= SP_REGNUM;
-  PROC_REG_MASK (proc_desc)	= 0xffff;
-  PROC_FREG_MASK (proc_desc)	= 0xffff;
-  PROC_PC_REG (proc_desc)	= 26;
-  PROC_LOCALOFF (proc_desc)	= 0;
+  PROC_LOW_ADDR (proc_desc) = low_addr;
+  PROC_HIGH_ADDR (proc_desc) = low_addr + 3 * 4;
+  PROC_DUMMY_FRAME (proc_desc) = 0;
+  PROC_FRAME_OFFSET (proc_desc) = 0x298;	/* sizeof(struct sigcontext_struct) */
+  PROC_FRAME_REG (proc_desc) = SP_REGNUM;
+  PROC_REG_MASK (proc_desc) = 0xffff;
+  PROC_FREG_MASK (proc_desc) = 0xffff;
+  PROC_PC_REG (proc_desc) = 26;
+  PROC_LOCALOFF (proc_desc) = 0;
   SET_PROC_DESC_IS_DYN_SIGTRAMP (proc_desc);
   return (proc_desc);
 }
-
 
+
 /* Guaranteed to set frame->saved_regs to some values (it never leaves it
    NULL).  */
 
@@ -282,13 +294,13 @@ alpha_find_saved_regs (frame)
       sigcontext_addr = SIGCONTEXT_ADDR (frame);
       for (ireg = 0; ireg < 32; ireg++)
 	{
- 	  reg_position = sigcontext_addr + SIGFRAME_REGSAVE_OFF + ireg * 8;
- 	  frame->saved_regs[ireg] = reg_position;
+	  reg_position = sigcontext_addr + SIGFRAME_REGSAVE_OFF + ireg * 8;
+	  frame->saved_regs[ireg] = reg_position;
 	}
       for (ireg = 0; ireg < 32; ireg++)
 	{
- 	  reg_position = sigcontext_addr + SIGFRAME_FPREGSAVE_OFF + ireg * 8;
- 	  frame->saved_regs[FP0_REGNUM + ireg] = reg_position;
+	  reg_position = sigcontext_addr + SIGFRAME_FPREGSAVE_OFF + ireg * 8;
+	  frame->saved_regs[FP0_REGNUM + ireg] = reg_position;
 	}
       frame->saved_regs[PC_REGNUM] = sigcontext_addr + SIGFRAME_PC_OFF;
       return;
@@ -315,11 +327,11 @@ alpha_find_saved_regs (frame)
     {
       frame->saved_regs[returnreg] = reg_position;
       reg_position += 8;
-      mask &= ~(1 << returnreg); /* Clear bit for RA so we
-				    don't save again later. */
+      mask &= ~(1 << returnreg);	/* Clear bit for RA so we
+					   don't save again later. */
     }
 
-  for (ireg = 0; ireg <= 31 ; ++ireg)
+  for (ireg = 0; ireg <= 31; ++ireg)
     if (mask & (1 << ireg))
       {
 	frame->saved_regs[ireg] = reg_position;
@@ -332,10 +344,10 @@ alpha_find_saved_regs (frame)
   reg_position = frame->frame + PROC_FREG_OFFSET (proc_desc);
   mask = PROC_FREG_MASK (proc_desc);
 
-  for (ireg = 0; ireg <= 31 ; ++ireg)
+  for (ireg = 0; ireg <= 31; ++ireg)
     if (mask & (1 << ireg))
       {
-	frame->saved_regs[FP0_REGNUM+ireg] = reg_position;
+	frame->saved_regs[FP0_REGNUM + ireg] = reg_position;
 	reg_position += 8;
       }
 
@@ -343,14 +355,14 @@ alpha_find_saved_regs (frame)
 }
 
 static CORE_ADDR
-read_next_frame_reg(fi, regno)
+read_next_frame_reg (fi, regno)
      struct frame_info *fi;
      int regno;
 {
   for (; fi; fi = fi->next)
     {
       /* We have to get the saved sp from the sigcontext
-	 if it is a signal handler frame.  */
+         if it is a signal handler frame.  */
       if (regno == SP_REGNUM && !fi->signal_handler_caller)
 	return fi->frame;
       else
@@ -358,14 +370,14 @@ read_next_frame_reg(fi, regno)
 	  if (fi->saved_regs == NULL)
 	    alpha_find_saved_regs (fi);
 	  if (fi->saved_regs[regno])
-	    return read_memory_integer(fi->saved_regs[regno], 8);
+	    return read_memory_integer (fi->saved_regs[regno], 8);
 	}
     }
-  return read_register(regno);
+  return read_register (regno);
 }
 
 CORE_ADDR
-alpha_frame_saved_pc(frame)
+alpha_frame_saved_pc (frame)
      struct frame_info *frame;
 {
   alpha_extra_func_info_t proc_desc = frame->proc_desc;
@@ -373,10 +385,10 @@ alpha_frame_saved_pc(frame)
      if it is a signal handler frame.  */
   int pcreg = frame->signal_handler_caller ? PC_REGNUM : frame->pc_reg;
 
-  if (proc_desc && PROC_DESC_IS_DUMMY(proc_desc))
-      return read_memory_integer(frame->frame - 8, 8);
+  if (proc_desc && PROC_DESC_IS_DUMMY (proc_desc))
+    return read_memory_integer (frame->frame - 8, 8);
 
-  return read_next_frame_reg(frame, pcreg);
+  return read_next_frame_reg (frame, pcreg);
 }
 
 CORE_ADDR
@@ -423,177 +435,178 @@ alpha_about_to_return (pc)
    lines.  */
 
 static CORE_ADDR
-heuristic_proc_start(pc)
-    CORE_ADDR pc;
+heuristic_proc_start (pc)
+     CORE_ADDR pc;
 {
-    CORE_ADDR start_pc = pc;
-    CORE_ADDR fence = start_pc - heuristic_fence_post;
+  CORE_ADDR start_pc = pc;
+  CORE_ADDR fence = start_pc - heuristic_fence_post;
 
-    if (start_pc == 0)	return 0;
+  if (start_pc == 0)
+    return 0;
 
-    if (heuristic_fence_post == UINT_MAX
-	|| fence < VM_MIN_ADDRESS)
-      fence = VM_MIN_ADDRESS;
+  if (heuristic_fence_post == UINT_MAX
+      || fence < VM_MIN_ADDRESS)
+    fence = VM_MIN_ADDRESS;
 
-    /* search back for previous return */
-    for (start_pc -= 4; ; start_pc -= 4)
-	if (start_pc < fence)
+  /* search back for previous return */
+  for (start_pc -= 4;; start_pc -= 4)
+    if (start_pc < fence)
+      {
+	/* It's not clear to me why we reach this point when
+	   stop_soon_quietly, but with this test, at least we
+	   don't print out warnings for every child forked (eg, on
+	   decstation).  22apr93 rich@cygnus.com.  */
+	if (!stop_soon_quietly)
 	  {
-	    /* It's not clear to me why we reach this point when
-	       stop_soon_quietly, but with this test, at least we
-	       don't print out warnings for every child forked (eg, on
-	       decstation).  22apr93 rich@cygnus.com.  */
-	    if (!stop_soon_quietly)
+	    static int blurb_printed = 0;
+
+	    if (fence == VM_MIN_ADDRESS)
+	      warning ("Hit beginning of text section without finding");
+	    else
+	      warning ("Hit heuristic-fence-post without finding");
+
+	    warning ("enclosing function for address 0x%lx", pc);
+	    if (!blurb_printed)
 	      {
-		static int blurb_printed = 0;
-
-		if (fence == VM_MIN_ADDRESS)
-		  warning("Hit beginning of text section without finding");
-		else
-		  warning("Hit heuristic-fence-post without finding");
-		
-		warning("enclosing function for address 0x%lx", pc);
-		if (!blurb_printed)
-		  {
-		    printf_filtered ("\
+		printf_filtered ("\
 This warning occurs if you are debugging a function without any symbols\n\
 (for example, in a stripped executable).  In that case, you may wish to\n\
 increase the size of the search with the `set heuristic-fence-post' command.\n\
 \n\
 Otherwise, you told GDB there was a function where there isn't one, or\n\
 (more likely) you have encountered a bug in GDB.\n");
-		    blurb_printed = 1;
-		  }
+		blurb_printed = 1;
 	      }
-
-	    return 0; 
 	  }
-	else if (alpha_about_to_return (start_pc))
-	  break;
 
-    start_pc += 4; /* skip return */
-    return start_pc;
+	return 0;
+      }
+    else if (alpha_about_to_return (start_pc))
+      break;
+
+  start_pc += 4;		/* skip return */
+  return start_pc;
 }
 
 static alpha_extra_func_info_t
-heuristic_proc_desc(start_pc, limit_pc, next_frame)
-    CORE_ADDR start_pc, limit_pc;
-    struct frame_info *next_frame;
+heuristic_proc_desc (start_pc, limit_pc, next_frame)
+     CORE_ADDR start_pc, limit_pc;
+     struct frame_info *next_frame;
 {
-    CORE_ADDR sp = read_next_frame_reg (next_frame, SP_REGNUM);
-    CORE_ADDR cur_pc;
-    int frame_size;
-    int has_frame_reg = 0;
-    unsigned long reg_mask = 0;
-    int pcreg = -1;
-
-    if (start_pc == 0)
-      return NULL;
-    memset (&temp_proc_desc, '\0', sizeof(temp_proc_desc));
-    memset (&temp_saved_regs, '\0', sizeof(struct frame_saved_regs));
-    PROC_LOW_ADDR (&temp_proc_desc) = start_pc;
-
-    if (start_pc + 200 < limit_pc)
-      limit_pc = start_pc + 200;
-    frame_size = 0;
-    for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += 4)
-      {
-        char buf[4];
-	unsigned long word;
-	int status;
+  CORE_ADDR sp = read_next_frame_reg (next_frame, SP_REGNUM);
+  CORE_ADDR cur_pc;
+  int frame_size;
+  int has_frame_reg = 0;
+  unsigned long reg_mask = 0;
+  int pcreg = -1;
+
+  if (start_pc == 0)
+    return NULL;
+  memset (&temp_proc_desc, '\0', sizeof (temp_proc_desc));
+  memset (&temp_saved_regs, '\0', sizeof (struct frame_saved_regs));
+  PROC_LOW_ADDR (&temp_proc_desc) = start_pc;
+
+  if (start_pc + 200 < limit_pc)
+    limit_pc = start_pc + 200;
+  frame_size = 0;
+  for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += 4)
+    {
+      char buf[4];
+      unsigned long word;
+      int status;
 
-	status = read_memory_nobpt (cur_pc, buf, 4); 
-	if (status)
-	  memory_error (status, cur_pc);
-	word = extract_unsigned_integer (buf, 4);
+      status = read_memory_nobpt (cur_pc, buf, 4);
+      if (status)
+	memory_error (status, cur_pc);
+      word = extract_unsigned_integer (buf, 4);
 
-	if ((word & 0xffff0000) == 0x23de0000)		/* lda $sp,n($sp) */
-	  {
-	    if (word & 0x8000)
-	      frame_size += (-word) & 0xffff;
-	    else
-	      /* Exit loop if a positive stack adjustment is found, which
-		 usually means that the stack cleanup code in the function
-		 epilogue is reached.  */
-	      break;
-	  }
-	else if ((word & 0xfc1f0000) == 0xb41e0000	/* stq reg,n($sp) */
-		 && (word & 0xffff0000) != 0xb7fe0000)	/* reg != $zero */
-	  {
-	    int reg = (word & 0x03e00000) >> 21;
-	    reg_mask |= 1 << reg;
-	    temp_saved_regs.regs[reg] = sp + (short)word;
-
-	    /* Starting with OSF/1-3.2C, the system libraries are shipped
-	       without local symbols, but they still contain procedure
-	       descriptors without a symbol reference. GDB is currently
-	       unable to find these procedure descriptors and uses
-	       heuristic_proc_desc instead.
-	       As some low level compiler support routines (__div*, __add*)
-	       use a non-standard return address register, we have to
-	       add some heuristics to determine the return address register,
-	       or stepping over these routines will fail.
-	       Usually the return address register is the first register
-	       saved on the stack, but assembler optimization might
-	       rearrange the register saves.
-	       So we recognize only a few registers (t7, t9, ra) within
-	       the procedure prologue as valid return address registers.
-	       If we encounter a return instruction, we extract the
-	       the return address register from it.
-
-	       FIXME: Rewriting GDB to access the procedure descriptors,
-	       e.g. via the minimal symbol table, might obviate this hack.  */
-	    if (pcreg == -1
-		&& cur_pc < (start_pc + 80)
-		&& (reg == T7_REGNUM || reg == T9_REGNUM || reg == RA_REGNUM))
-	      pcreg = reg;
-	  }
-	else if ((word & 0xffe0ffff) == 0x6be08001)	/* ret zero,reg,1 */
-	  pcreg = (word >> 16) & 0x1f;
-	else if (word == 0x47de040f)			/* bis sp,sp fp */
-	  has_frame_reg = 1;
-      }
-    if (pcreg == -1)
-      {
-	/* If we haven't found a valid return address register yet,
-	   keep searching in the procedure prologue.  */
-	while (cur_pc < (limit_pc + 80) && cur_pc < (start_pc + 80))
-	  {
-	    char buf[4];
-	    unsigned long word;
+      if ((word & 0xffff0000) == 0x23de0000)	/* lda $sp,n($sp) */
+	{
+	  if (word & 0x8000)
+	    frame_size += (-word) & 0xffff;
+	  else
+	    /* Exit loop if a positive stack adjustment is found, which
+	       usually means that the stack cleanup code in the function
+	       epilogue is reached.  */
+	    break;
+	}
+      else if ((word & 0xfc1f0000) == 0xb41e0000	/* stq reg,n($sp) */
+	       && (word & 0xffff0000) != 0xb7fe0000)	/* reg != $zero */
+	{
+	  int reg = (word & 0x03e00000) >> 21;
+	  reg_mask |= 1 << reg;
+	  temp_saved_regs.regs[reg] = sp + (short) word;
+
+	  /* Starting with OSF/1-3.2C, the system libraries are shipped
+	     without local symbols, but they still contain procedure
+	     descriptors without a symbol reference. GDB is currently
+	     unable to find these procedure descriptors and uses
+	     heuristic_proc_desc instead.
+	     As some low level compiler support routines (__div*, __add*)
+	     use a non-standard return address register, we have to
+	     add some heuristics to determine the return address register,
+	     or stepping over these routines will fail.
+	     Usually the return address register is the first register
+	     saved on the stack, but assembler optimization might
+	     rearrange the register saves.
+	     So we recognize only a few registers (t7, t9, ra) within
+	     the procedure prologue as valid return address registers.
+	     If we encounter a return instruction, we extract the
+	     the return address register from it.
+
+	     FIXME: Rewriting GDB to access the procedure descriptors,
+	     e.g. via the minimal symbol table, might obviate this hack.  */
+	  if (pcreg == -1
+	      && cur_pc < (start_pc + 80)
+	      && (reg == T7_REGNUM || reg == T9_REGNUM || reg == RA_REGNUM))
+	    pcreg = reg;
+	}
+      else if ((word & 0xffe0ffff) == 0x6be08001)	/* ret zero,reg,1 */
+	pcreg = (word >> 16) & 0x1f;
+      else if (word == 0x47de040f)	/* bis sp,sp fp */
+	has_frame_reg = 1;
+    }
+  if (pcreg == -1)
+    {
+      /* If we haven't found a valid return address register yet,
+         keep searching in the procedure prologue.  */
+      while (cur_pc < (limit_pc + 80) && cur_pc < (start_pc + 80))
+	{
+	  char buf[4];
+	  unsigned long word;
 
-	    if (read_memory_nobpt (cur_pc, buf, 4))
-	      break;
-	    cur_pc += 4;
-	    word = extract_unsigned_integer (buf, 4);
+	  if (read_memory_nobpt (cur_pc, buf, 4))
+	    break;
+	  cur_pc += 4;
+	  word = extract_unsigned_integer (buf, 4);
 
-	    if ((word & 0xfc1f0000) == 0xb41e0000	/* stq reg,n($sp) */
-		&& (word & 0xffff0000) != 0xb7fe0000)	/* reg != $zero */
-	      {
-		int reg = (word & 0x03e00000) >> 21;
-		if (reg == T7_REGNUM || reg == T9_REGNUM || reg == RA_REGNUM)
-		  {
-		    pcreg = reg;
-		    break;
-		  }
-	      }
-	    else if ((word & 0xffe0ffff) == 0x6be08001)	/* ret zero,reg,1 */
-	      {
-		pcreg = (word >> 16) & 0x1f;
-		break;
-	      }
-	  }
-      }
+	  if ((word & 0xfc1f0000) == 0xb41e0000		/* stq reg,n($sp) */
+	      && (word & 0xffff0000) != 0xb7fe0000)	/* reg != $zero */
+	    {
+	      int reg = (word & 0x03e00000) >> 21;
+	      if (reg == T7_REGNUM || reg == T9_REGNUM || reg == RA_REGNUM)
+		{
+		  pcreg = reg;
+		  break;
+		}
+	    }
+	  else if ((word & 0xffe0ffff) == 0x6be08001)	/* ret zero,reg,1 */
+	    {
+	      pcreg = (word >> 16) & 0x1f;
+	      break;
+	    }
+	}
+    }
 
-    if (has_frame_reg)
-      PROC_FRAME_REG(&temp_proc_desc) = GCC_FP_REGNUM;
-    else
-      PROC_FRAME_REG(&temp_proc_desc) = SP_REGNUM;
-    PROC_FRAME_OFFSET(&temp_proc_desc) = frame_size;
-    PROC_REG_MASK(&temp_proc_desc) = reg_mask;
-    PROC_PC_REG(&temp_proc_desc) = (pcreg == -1) ? RA_REGNUM : pcreg;
-    PROC_LOCALOFF(&temp_proc_desc) = 0;	/* XXX - bogus */
-    return &temp_proc_desc;
+  if (has_frame_reg)
+    PROC_FRAME_REG (&temp_proc_desc) = GCC_FP_REGNUM;
+  else
+    PROC_FRAME_REG (&temp_proc_desc) = SP_REGNUM;
+  PROC_FRAME_OFFSET (&temp_proc_desc) = frame_size;
+  PROC_REG_MASK (&temp_proc_desc) = reg_mask;
+  PROC_PC_REG (&temp_proc_desc) = (pcreg == -1) ? RA_REGNUM : pcreg;
+  PROC_LOCALOFF (&temp_proc_desc) = 0;	/* XXX - bogus */
+  return &temp_proc_desc;
 }
 
 /* This returns the PC of the first inst after the prologue.  If we can't
@@ -616,7 +629,7 @@ after_prologue (pc, proc_desc)
 	return PROC_LOW_ADDR (proc_desc);	/* "prologue" is in kernel */
 
       /* If function is frameless, then we need to do it the hard way.  I
-	 strongly suspect that frameless always means prologueless... */
+         strongly suspect that frameless always means prologueless... */
       if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
 	  && PROC_FRAME_OFFSET (proc_desc) == 0)
 	return 0;
@@ -657,8 +670,8 @@ alpha_in_prologue (pc, proc_desc)
 
 static alpha_extra_func_info_t
 find_proc_desc (pc, next_frame)
-    CORE_ADDR pc;
-    struct frame_info *next_frame;
+     CORE_ADDR pc;
+     struct frame_info *next_frame;
 {
   alpha_extra_func_info_t proc_desc;
   struct block *b;
@@ -693,7 +706,7 @@ find_proc_desc (pc, next_frame)
 	return found_proc_desc;
     }
 
-  b = block_for_pc(pc);
+  b = block_for_pc (pc);
 
   find_pc_partial_function (pc, NULL, &startaddr, NULL);
   if (b == NULL)
@@ -717,57 +730,57 @@ find_proc_desc (pc, next_frame)
 
   if (sym)
     {
-	/* IF this is the topmost frame AND
-	 * (this proc does not have debugging information OR
-	 * the PC is in the procedure prologue)
-	 * THEN create a "heuristic" proc_desc (by analyzing
-	 * the actual code) to replace the "official" proc_desc.
-	 */
-	proc_desc = (alpha_extra_func_info_t)SYMBOL_VALUE(sym);
-	if (next_frame == NULL)
-	  {
-	    if (PROC_DESC_IS_DUMMY (proc_desc) || alpha_in_prologue (pc, proc_desc))
-	      {
-		alpha_extra_func_info_t found_heuristic =
-		  heuristic_proc_desc (PROC_LOW_ADDR (proc_desc),
-				       pc, next_frame);
-		if (found_heuristic)
-		  {
-		    PROC_LOCALOFF (found_heuristic) =
-		      PROC_LOCALOFF (proc_desc);
-		    PROC_PC_REG (found_heuristic) = PROC_PC_REG (proc_desc);
-		    proc_desc = found_heuristic;
-		  }
-	      }
-	  }
+      /* IF this is the topmost frame AND
+       * (this proc does not have debugging information OR
+       * the PC is in the procedure prologue)
+       * THEN create a "heuristic" proc_desc (by analyzing
+       * the actual code) to replace the "official" proc_desc.
+       */
+      proc_desc = (alpha_extra_func_info_t) SYMBOL_VALUE (sym);
+      if (next_frame == NULL)
+	{
+	  if (PROC_DESC_IS_DUMMY (proc_desc) || alpha_in_prologue (pc, proc_desc))
+	    {
+	      alpha_extra_func_info_t found_heuristic =
+	      heuristic_proc_desc (PROC_LOW_ADDR (proc_desc),
+				   pc, next_frame);
+	      if (found_heuristic)
+		{
+		  PROC_LOCALOFF (found_heuristic) =
+		    PROC_LOCALOFF (proc_desc);
+		  PROC_PC_REG (found_heuristic) = PROC_PC_REG (proc_desc);
+		  proc_desc = found_heuristic;
+		}
+	    }
+	}
     }
   else
     {
       long offset;
 
       /* Is linked_proc_desc_table really necessary?  It only seems to be used
-	 by procedure call dummys.  However, the procedures being called ought
-	 to have their own proc_descs, and even if they don't,
-	 heuristic_proc_desc knows how to create them! */
+         by procedure call dummys.  However, the procedures being called ought
+         to have their own proc_descs, and even if they don't,
+         heuristic_proc_desc knows how to create them! */
 
       register struct linked_proc_info *link;
       for (link = linked_proc_desc_table; link; link = link->next)
-	  if (PROC_LOW_ADDR(&link->info) <= pc
-	      && PROC_HIGH_ADDR(&link->info) > pc)
-	      return &link->info;
+	if (PROC_LOW_ADDR (&link->info) <= pc
+	    && PROC_HIGH_ADDR (&link->info) > pc)
+	  return &link->info;
 
       /* If PC is inside a dynamically generated sigtramp handler,
-	 create and push a procedure descriptor for that code: */
+         create and push a procedure descriptor for that code: */
       offset = DYNAMIC_SIGTRAMP_OFFSET (pc);
       if (offset >= 0)
 	return push_sigtramp_desc (pc - offset);
 
       /* If heuristic_fence_post is non-zero, determine the procedure
-	 start address by examining the instructions.
-	 This allows us to find the start address of static functions which
-	 have no symbolic information, as startaddr would have been set to
-	 the preceding global function start address by the
-	 find_pc_partial_function call above.  */
+         start address by examining the instructions.
+         This allows us to find the start address of static functions which
+         have no symbolic information, as startaddr would have been set to
+         the preceding global function start address by the
+         find_pc_partial_function call above.  */
       if (startaddr == 0 || heuristic_fence_post != 0)
 	startaddr = heuristic_proc_start (pc);
 
@@ -780,38 +793,38 @@ find_proc_desc (pc, next_frame)
 alpha_extra_func_info_t cached_proc_desc;
 
 CORE_ADDR
-alpha_frame_chain(frame)
-    struct frame_info *frame;
+alpha_frame_chain (frame)
+     struct frame_info *frame;
 {
-    alpha_extra_func_info_t proc_desc;
-    CORE_ADDR saved_pc = FRAME_SAVED_PC(frame);
-
-    if (saved_pc == 0 || inside_entry_file (saved_pc))
-      return 0;
-
-    proc_desc = find_proc_desc(saved_pc, frame);
-    if (!proc_desc)
-      return 0;
-
-    cached_proc_desc = proc_desc;
-
-    /* Fetch the frame pointer for a dummy frame from the procedure
-       descriptor.  */
-    if (PROC_DESC_IS_DUMMY(proc_desc))
-      return (CORE_ADDR) PROC_DUMMY_FRAME(proc_desc);
-
-    /* If no frame pointer and frame size is zero, we must be at end
-       of stack (or otherwise hosed).  If we don't check frame size,
-       we loop forever if we see a zero size frame.  */
-    if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
-	&& PROC_FRAME_OFFSET (proc_desc) == 0
-	/* The previous frame from a sigtramp frame might be frameless
-	   and have frame size zero.  */
-	&& !frame->signal_handler_caller)
-      return FRAME_PAST_SIGTRAMP_FRAME (frame, saved_pc);
-    else
-      return read_next_frame_reg(frame, PROC_FRAME_REG(proc_desc))
-	     + PROC_FRAME_OFFSET(proc_desc);
+  alpha_extra_func_info_t proc_desc;
+  CORE_ADDR saved_pc = FRAME_SAVED_PC (frame);
+
+  if (saved_pc == 0 || inside_entry_file (saved_pc))
+    return 0;
+
+  proc_desc = find_proc_desc (saved_pc, frame);
+  if (!proc_desc)
+    return 0;
+
+  cached_proc_desc = proc_desc;
+
+  /* Fetch the frame pointer for a dummy frame from the procedure
+     descriptor.  */
+  if (PROC_DESC_IS_DUMMY (proc_desc))
+    return (CORE_ADDR) PROC_DUMMY_FRAME (proc_desc);
+
+  /* If no frame pointer and frame size is zero, we must be at end
+     of stack (or otherwise hosed).  If we don't check frame size,
+     we loop forever if we see a zero size frame.  */
+  if (PROC_FRAME_REG (proc_desc) == SP_REGNUM
+      && PROC_FRAME_OFFSET (proc_desc) == 0
+  /* The previous frame from a sigtramp frame might be frameless
+     and have frame size zero.  */
+      && !frame->signal_handler_caller)
+    return FRAME_PAST_SIGTRAMP_FRAME (frame, saved_pc);
+  else
+    return read_next_frame_reg (frame, PROC_FRAME_REG (proc_desc))
+      + PROC_FRAME_OFFSET (proc_desc);
 }
 
 void
@@ -820,7 +833,7 @@ init_extra_frame_info (frame)
 {
   /* Use proc_desc calculated in frame_chain */
   alpha_extra_func_info_t proc_desc =
-    frame->next ? cached_proc_desc : find_proc_desc(frame->pc, frame->next);
+  frame->next ? cached_proc_desc : find_proc_desc (frame->pc, frame->next);
 
   frame->saved_regs = NULL;
   frame->localoff = 0;
@@ -829,21 +842,21 @@ init_extra_frame_info (frame)
   if (proc_desc)
     {
       /* Get the locals offset and the saved pc register from the
-	 procedure descriptor, they are valid even if we are in the
-	 middle of the prologue.  */
-      frame->localoff = PROC_LOCALOFF(proc_desc);
-      frame->pc_reg = PROC_PC_REG(proc_desc);
+         procedure descriptor, they are valid even if we are in the
+         middle of the prologue.  */
+      frame->localoff = PROC_LOCALOFF (proc_desc);
+      frame->pc_reg = PROC_PC_REG (proc_desc);
 
       /* Fixup frame-pointer - only needed for top frame */
 
       /* Fetch the frame pointer for a dummy frame from the procedure
-	 descriptor.  */
-      if (PROC_DESC_IS_DUMMY(proc_desc))
-	frame->frame = (CORE_ADDR) PROC_DUMMY_FRAME(proc_desc);
+         descriptor.  */
+      if (PROC_DESC_IS_DUMMY (proc_desc))
+	frame->frame = (CORE_ADDR) PROC_DUMMY_FRAME (proc_desc);
 
       /* This may not be quite right, if proc has a real frame register.
-	 Get the value of the frame relative sp, procedure might have been
-	 interrupted by a signal at it's very start.  */
+         Get the value of the frame relative sp, procedure might have been
+         interrupted by a signal at it's very start.  */
       else if (frame->pc == PROC_LOW_ADDR (proc_desc)
 	       && !PROC_DESC_IS_DYN_SIGTRAMP (proc_desc))
 	frame->frame = read_next_frame_reg (frame->next, SP_REGNUM);
@@ -859,10 +872,10 @@ init_extra_frame_info (frame)
 	     alpha_find_saved_registers will do that for us.
 	     We can't use frame->signal_handler_caller, it is not yet set.  */
 	  find_pc_partial_function (frame->pc, &name,
-				    (CORE_ADDR *)NULL,(CORE_ADDR *)NULL);
+				    (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
 	  if (!IN_SIGTRAMP (frame->pc, name))
 	    {
-	      frame->saved_regs = (CORE_ADDR*)
+	      frame->saved_regs = (CORE_ADDR *)
 		frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
 	      memcpy (frame->saved_regs, temp_saved_regs.regs, SIZEOF_FRAME_SAVED_REGS);
 	      frame->saved_regs[PC_REGNUM]
@@ -919,9 +932,14 @@ alpha_push_arguments (nargs, args, sp, struct_return, struct_addr)
   int i;
   int accumulate_size = struct_return ? 8 : 0;
   int arg_regs_size = ALPHA_NUM_ARG_REGS * 8;
-  struct alpha_arg { char *contents; int len; int offset; };
+  struct alpha_arg
+    {
+      char *contents;
+      int len;
+      int offset;
+    };
   struct alpha_arg *alpha_args =
-      (struct alpha_arg*)alloca (nargs * sizeof (struct alpha_arg));
+  (struct alpha_arg *) alloca (nargs * sizeof (struct alpha_arg));
   register struct alpha_arg *m_arg;
   char raw_buffer[sizeof (CORE_ADDR)];
   int required_arg_regs;
@@ -950,7 +968,7 @@ alpha_push_arguments (nargs, args, sp, struct_return, struct_addr)
       m_arg->len = TYPE_LENGTH (arg_type);
       m_arg->offset = accumulate_size;
       accumulate_size = (accumulate_size + m_arg->len + 7) & ~7;
-      m_arg->contents = VALUE_CONTENTS(arg);
+      m_arg->contents = VALUE_CONTENTS (arg);
     }
 
   /* Determine required argument register loads, loading an argument register
@@ -961,15 +979,15 @@ alpha_push_arguments (nargs, args, sp, struct_return, struct_addr)
 
   /* Make room for the arguments on the stack.  */
   if (accumulate_size < arg_regs_size)
-    accumulate_size = arg_regs_size; 
+    accumulate_size = arg_regs_size;
   sp -= accumulate_size;
 
   /* Keep sp aligned to a multiple of 16 as the compiler does it too.  */
   sp &= ~15;
 
   /* `Push' arguments on the stack.  */
-  for (i = nargs; m_arg--, --i >= 0; )
-    write_memory(sp + m_arg->offset, m_arg->contents, m_arg->len);
+  for (i = nargs; m_arg--, --i >= 0;)
+    write_memory (sp + m_arg->offset, m_arg->contents, m_arg->len);
   if (struct_return)
     {
       store_address (raw_buffer, sizeof (CORE_ADDR), struct_addr);
@@ -990,7 +1008,7 @@ alpha_push_arguments (nargs, args, sp, struct_return, struct_addr)
 }
 
 void
-alpha_push_dummy_frame()
+alpha_push_dummy_frame ()
 {
   int ireg;
   struct linked_proc_info *link;
@@ -1000,10 +1018,10 @@ alpha_push_dummy_frame()
   char raw_buffer[MAX_REGISTER_RAW_SIZE];
   unsigned long mask;
 
-  link = (struct linked_proc_info *) xmalloc(sizeof (struct linked_proc_info));
+  link = (struct linked_proc_info *) xmalloc (sizeof (struct linked_proc_info));
   link->next = linked_proc_desc_table;
   linked_proc_desc_table = link;
- 
+
   proc_desc = &link->info;
 
   /*
@@ -1013,15 +1031,15 @@ alpha_push_dummy_frame()
    *
    * Dummy frame layout:
    *  (high memory)
-   * 	Saved PC
+   *    Saved PC
    *    Saved F30
    *    ...
    *    Saved F0
-   *	Saved R29
-   *	...
-   *	Saved R0
-   *	Saved R26 (RA)
-   *	Parameter build area
+   *    Saved R29
+   *    ...
+   *    Saved R0
+   *    Saved R26 (RA)
+   *    Parameter build area
    *  (low memory)
    */
 
@@ -1035,27 +1053,27 @@ alpha_push_dummy_frame()
      alpha_frame_saved_pc knows where the pc is saved in a dummy frame.  */
 #define SPECIAL_REG_SAVE_COUNT 1
 
-  PROC_REG_MASK(proc_desc) = GEN_REG_SAVE_MASK;
-  PROC_FREG_MASK(proc_desc) = FLOAT_REG_SAVE_MASK;
+  PROC_REG_MASK (proc_desc) = GEN_REG_SAVE_MASK;
+  PROC_FREG_MASK (proc_desc) = FLOAT_REG_SAVE_MASK;
   /* PROC_REG_OFFSET is the offset from the dummy frame to the saved RA,
      but keep SP aligned to a multiple of 16.  */
-  PROC_REG_OFFSET(proc_desc) =
-    - ((8 * (SPECIAL_REG_SAVE_COUNT
+  PROC_REG_OFFSET (proc_desc) =
+    -((8 * (SPECIAL_REG_SAVE_COUNT
 	    + GEN_REG_SAVE_COUNT
 	    + FLOAT_REG_SAVE_COUNT)
-	+ 15) & ~15);
-  PROC_FREG_OFFSET(proc_desc) =
-    PROC_REG_OFFSET(proc_desc) + 8 * GEN_REG_SAVE_COUNT;
+       + 15) & ~15);
+  PROC_FREG_OFFSET (proc_desc) =
+    PROC_REG_OFFSET (proc_desc) + 8 * GEN_REG_SAVE_COUNT;
 
   /* Save general registers.
      The return address register is the first saved register, all other
      registers follow in ascending order.
      The PC is saved immediately below the SP.  */
-  save_address = sp + PROC_REG_OFFSET(proc_desc);
+  save_address = sp + PROC_REG_OFFSET (proc_desc);
   store_address (raw_buffer, 8, read_register (RA_REGNUM));
   write_memory (save_address, raw_buffer, 8);
   save_address += 8;
-  mask = PROC_REG_MASK(proc_desc) & 0xffffffffL;
+  mask = PROC_REG_MASK (proc_desc) & 0xffffffffL;
   for (ireg = 0; mask; ireg++, mask >>= 1)
     if (mask & 1)
       {
@@ -1070,8 +1088,8 @@ alpha_push_dummy_frame()
   write_memory (sp - 8, raw_buffer, 8);
 
   /* Save floating point registers.  */
-  save_address = sp + PROC_FREG_OFFSET(proc_desc);
-  mask = PROC_FREG_MASK(proc_desc) & 0xffffffffL;
+  save_address = sp + PROC_FREG_OFFSET (proc_desc);
+  mask = PROC_FREG_MASK (proc_desc) & 0xffffffffL;
   for (ireg = 0; mask; ireg++, mask >>= 1)
     if (mask & 1)
       {
@@ -1092,21 +1110,21 @@ alpha_push_dummy_frame()
      is set to the virtual frame (pseudo) register, it's value will always
      be read as zero and will help us to catch any errors in the dummy frame
      retrieval code.  */
-  PROC_DUMMY_FRAME(proc_desc) = sp;
-  PROC_FRAME_REG(proc_desc) = FP_REGNUM;
-  PROC_FRAME_OFFSET(proc_desc) = 0;
-  sp += PROC_REG_OFFSET(proc_desc);
+  PROC_DUMMY_FRAME (proc_desc) = sp;
+  PROC_FRAME_REG (proc_desc) = FP_REGNUM;
+  PROC_FRAME_OFFSET (proc_desc) = 0;
+  sp += PROC_REG_OFFSET (proc_desc);
   write_register (SP_REGNUM, sp);
 
-  PROC_LOW_ADDR(proc_desc) = CALL_DUMMY_ADDRESS ();
-  PROC_HIGH_ADDR(proc_desc) = PROC_LOW_ADDR(proc_desc) + 4;
+  PROC_LOW_ADDR (proc_desc) = CALL_DUMMY_ADDRESS ();
+  PROC_HIGH_ADDR (proc_desc) = PROC_LOW_ADDR (proc_desc) + 4;
 
-  SET_PROC_DESC_IS_DUMMY(proc_desc);
-  PROC_PC_REG(proc_desc) = RA_REGNUM;
+  SET_PROC_DESC_IS_DUMMY (proc_desc);
+  PROC_PC_REG (proc_desc) = RA_REGNUM;
 }
 
 void
-alpha_pop_frame()
+alpha_pop_frame ()
 {
   register int regnum;
   struct frame_info *frame = get_current_frame ();
@@ -1117,31 +1135,31 @@ alpha_pop_frame()
   /* we need proc_desc to know how to restore the registers;
      if it is NULL, construct (a temporary) one */
   if (proc_desc == NULL)
-    proc_desc = find_proc_desc(frame->pc, frame->next);
+    proc_desc = find_proc_desc (frame->pc, frame->next);
 
   /* Question: should we copy this proc_desc and save it in
      frame->proc_desc?  If we do, who will free it?
      For now, we don't save a copy... */
 
-  write_register (PC_REGNUM, FRAME_SAVED_PC(frame));
+  write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
   if (frame->saved_regs == NULL)
     alpha_find_saved_regs (frame);
   if (proc_desc)
     {
-      for (regnum = 32; --regnum >= 0; )
-	if (PROC_REG_MASK(proc_desc) & (1 << regnum))
+      for (regnum = 32; --regnum >= 0;)
+	if (PROC_REG_MASK (proc_desc) & (1 << regnum))
 	  write_register (regnum,
 			  read_memory_integer (frame->saved_regs[regnum],
 					       8));
-      for (regnum = 32; --regnum >= 0; )
-	if (PROC_FREG_MASK(proc_desc) & (1 << regnum))
+      for (regnum = 32; --regnum >= 0;)
+	if (PROC_FREG_MASK (proc_desc) & (1 << regnum))
 	  write_register (regnum + FP0_REGNUM,
-			  read_memory_integer (frame->saved_regs[regnum + FP0_REGNUM], 8));
+	   read_memory_integer (frame->saved_regs[regnum + FP0_REGNUM], 8));
     }
   write_register (SP_REGNUM, new_sp);
   flush_cached_frames ();
 
-  if (proc_desc && (PROC_DESC_IS_DUMMY(proc_desc)
+  if (proc_desc && (PROC_DESC_IS_DUMMY (proc_desc)
 		    || PROC_DESC_IS_DYN_SIGTRAMP (proc_desc)))
     {
       struct linked_proc_info *pi_ptr, *prev_ptr;
@@ -1180,74 +1198,74 @@ alpha_skip_prologue (pc, lenient)
      CORE_ADDR pc;
      int lenient;
 {
-    unsigned long inst;
-    int offset;
-    CORE_ADDR post_prologue_pc;
-    char buf[4];
+  unsigned long inst;
+  int offset;
+  CORE_ADDR post_prologue_pc;
+  char buf[4];
 
 #ifdef GDB_TARGET_HAS_SHARED_LIBS
-    /* Silently return the unaltered pc upon memory errors.
-       This could happen on OSF/1 if decode_line_1 tries to skip the
-       prologue for quickstarted shared library functions when the
-       shared library is not yet mapped in.
-       Reading target memory is slow over serial lines, so we perform
-       this check only if the target has shared libraries.  */
-    if (target_read_memory (pc, buf, 4))
-      return pc;
+  /* Silently return the unaltered pc upon memory errors.
+     This could happen on OSF/1 if decode_line_1 tries to skip the
+     prologue for quickstarted shared library functions when the
+     shared library is not yet mapped in.
+     Reading target memory is slow over serial lines, so we perform
+     this check only if the target has shared libraries.  */
+  if (target_read_memory (pc, buf, 4))
+    return pc;
 #endif
 
-    /* See if we can determine the end of the prologue via the symbol table.
-       If so, then return either PC, or the PC after the prologue, whichever
-       is greater.  */
-
-    post_prologue_pc = after_prologue (pc, NULL);
+  /* See if we can determine the end of the prologue via the symbol table.
+     If so, then return either PC, or the PC after the prologue, whichever
+     is greater.  */
 
-    if (post_prologue_pc != 0)
-      return max (pc, post_prologue_pc);
+  post_prologue_pc = after_prologue (pc, NULL);
 
-    /* Can't determine prologue from the symbol table, need to examine
-       instructions.  */
+  if (post_prologue_pc != 0)
+    return max (pc, post_prologue_pc);
 
-    /* Skip the typical prologue instructions. These are the stack adjustment
-       instruction and the instructions that save registers on the stack
-       or in the gcc frame.  */
-    for (offset = 0; offset < 100; offset += 4)
-      {
-	int status;
+  /* Can't determine prologue from the symbol table, need to examine
+     instructions.  */
 
-	status = read_memory_nobpt (pc + offset, buf, 4);
-	if (status)
-	  memory_error (status, pc + offset);
-	inst = extract_unsigned_integer (buf, 4);
-
-	/* The alpha has no delay slots. But let's keep the lenient stuff,
-	   we might need it for something else in the future.  */
-	if (lenient && 0)
-	  continue;
-
-	if ((inst & 0xffff0000) == 0x27bb0000)	/* ldah $gp,n($t12) */
-	    continue;
-	if ((inst & 0xffff0000) == 0x23bd0000)	/* lda $gp,n($gp) */
-	    continue;
-	if ((inst & 0xffff0000) == 0x23de0000)	/* lda $sp,n($sp) */
-	    continue;
-	if ((inst & 0xffe01fff) == 0x43c0153e)  /* subq $sp,n,$sp */
-	    continue;
-
-	if ((inst & 0xfc1f0000) == 0xb41e0000
-	    && (inst & 0xffff0000) != 0xb7fe0000)
-	    continue;				/* stq reg,n($sp) */
-						/* reg != $zero */
-	if ((inst & 0xfc1f0000) == 0x9c1e0000
-	    && (inst & 0xffff0000) != 0x9ffe0000)
-	    continue;				/* stt reg,n($sp) */
-						/* reg != $zero */
-	if (inst == 0x47de040f)			/* bis sp,sp,fp */
-	    continue;
-
-	break;
+  /* Skip the typical prologue instructions. These are the stack adjustment
+     instruction and the instructions that save registers on the stack
+     or in the gcc frame.  */
+  for (offset = 0; offset < 100; offset += 4)
+    {
+      int status;
+
+      status = read_memory_nobpt (pc + offset, buf, 4);
+      if (status)
+	memory_error (status, pc + offset);
+      inst = extract_unsigned_integer (buf, 4);
+
+      /* The alpha has no delay slots. But let's keep the lenient stuff,
+         we might need it for something else in the future.  */
+      if (lenient && 0)
+	continue;
+
+      if ((inst & 0xffff0000) == 0x27bb0000)	/* ldah $gp,n($t12) */
+	continue;
+      if ((inst & 0xffff0000) == 0x23bd0000)	/* lda $gp,n($gp) */
+	continue;
+      if ((inst & 0xffff0000) == 0x23de0000)	/* lda $sp,n($sp) */
+	continue;
+      if ((inst & 0xffe01fff) == 0x43c0153e)	/* subq $sp,n,$sp */
+	continue;
+
+      if ((inst & 0xfc1f0000) == 0xb41e0000
+	  && (inst & 0xffff0000) != 0xb7fe0000)
+	continue;		/* stq reg,n($sp) */
+      /* reg != $zero */
+      if ((inst & 0xfc1f0000) == 0x9c1e0000
+	  && (inst & 0xffff0000) != 0x9ffe0000)
+	continue;		/* stt reg,n($sp) */
+      /* reg != $zero */
+      if (inst == 0x47de040f)	/* bis sp,sp,fp */
+	continue;
+
+      break;
     }
-    return pc + offset;
+  return pc + offset;
 }
 
 #if 0
@@ -1266,16 +1284,16 @@ alpha_in_lenient_prologue (startaddr, pc)
 
 /* The alpha needs a conversion between register and memory format if
    the register is a floating point register and
-      memory format is float, as the register format must be double
+   memory format is float, as the register format must be double
    or
-      memory format is an integer with 4 bytes or less, as the representation
-      of integers in floating point registers is different. */
+   memory format is an integer with 4 bytes or less, as the representation
+   of integers in floating point registers is different. */
 void
 alpha_register_convert_to_virtual (regnum, valtype, raw_buffer, virtual_buffer)
-    int regnum;
-    struct type *valtype;
-    char *raw_buffer;
-    char *virtual_buffer;
+     int regnum;
+     struct type *valtype;
+     char *raw_buffer;
+     char *virtual_buffer;
 {
   if (TYPE_LENGTH (valtype) >= REGISTER_RAW_SIZE (regnum))
     {
@@ -1301,10 +1319,10 @@ alpha_register_convert_to_virtual (regnum, valtype, raw_buffer, virtual_buffer)
 
 void
 alpha_register_convert_to_raw (valtype, regnum, virtual_buffer, raw_buffer)
-    struct type *valtype;
-    int regnum;
-    char *virtual_buffer;
-    char *raw_buffer;
+     struct type *valtype;
+     int regnum;
+     char *virtual_buffer;
+     char *raw_buffer;
 {
   if (TYPE_LENGTH (valtype) >= REGISTER_RAW_SIZE (regnum))
     {
@@ -1336,9 +1354,9 @@ alpha_register_convert_to_raw (valtype, regnum, virtual_buffer, raw_buffer)
 
 void
 alpha_extract_return_value (valtype, regbuf, valbuf)
-    struct type *valtype;
-    char regbuf[REGISTER_BYTES];
-    char *valbuf;
+     struct type *valtype;
+     char regbuf[REGISTER_BYTES];
+     char *valbuf;
 {
   if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
     alpha_register_convert_to_virtual (FP0_REGNUM, valtype,
@@ -1353,13 +1371,13 @@ alpha_extract_return_value (valtype, regbuf, valbuf)
 
 void
 alpha_store_return_value (valtype, valbuf)
-    struct type *valtype;
-    char *valbuf;
+     struct type *valtype;
+     char *valbuf;
 {
   char raw_buffer[MAX_REGISTER_RAW_SIZE];
   int regnum = V0_REGNUM;
   int length = TYPE_LENGTH (valtype);
-  
+
   if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
     {
       regnum = FP0_REGNUM;