ran "indent -gnu"; have not fixed block comment style

1 files changed, 109 insertions, 94 deletions

diff --git a/gprof/alpha.c b/gprof/alpha.c
index 9051634..e81b372 100644
--- a/gprof/alpha.c
+++ b/gprof/alpha.c
@@ -33,24 +33,32 @@
 #define Jxx_FUNC_RET		2
 #define Jxx_FUNC_JSR_COROUTINE	3
 
-typedef union {
-    struct {
-	unsigned other	 : 26;
-	unsigned op_code :  6;
-    } a;				/* any format */
-    struct {
-	signed	 disp	 : 21;
-	unsigned ra	 :  5;
-	unsigned op_code :  6;
-    } b;				/* branch format */
-    struct {
-	signed	 hint	 : 14;
-	unsigned func	 :  2;
-	unsigned rb	 :  5;
-	unsigned ra	 :  5;
-	unsigned op_code :  6;
-    } j;				/* jump format */
-} Instruction;
+typedef union
+  {
+    struct
+      {
+	unsigned other:26;
+	unsigned op_code:6;
+      }
+    a;				/* any format */
+    struct
+      {
+	signed disp:21;
+	unsigned ra:5;
+	unsigned op_code:6;
+      }
+    b;				/* branch format */
+    struct
+      {
+	signed hint:14;
+	unsigned func:2;
+	unsigned rb:5;
+	unsigned ra:5;
+	unsigned op_code:6;
+      }
+    j;				/* jump format */
+  }
+Instruction;
 
 static Sym indirect_child;
 
@@ -63,92 +71,99 @@ static Sym indirect_child;
  *  potentially call integer division routines, for example.)
  */
 void
-find_call(parent, p_lowpc, p_highpc)
+find_call (parent, p_lowpc, p_highpc)
      Sym *parent;
      bfd_vma p_lowpc;
      bfd_vma p_highpc;
 {
-    static bfd_vma delta = 0;
-    bfd_vma dest_pc;
-    Instruction *pc;
-    Sym *child;
-    
-    if (!delta) {
-	delta = (bfd_vma) core_text_space - core_text_sect->vma;
+  static bfd_vma delta = 0;
+  bfd_vma dest_pc;
+  Instruction *pc;
+  Sym *child;
 
-	sym_init(&indirect_child);
-	indirect_child.name = "<indirect child>";
-	indirect_child.cg.prop.fract = 1.0;
-	indirect_child.cg.cyc.head = &indirect_child;
-    } /* if */
-    
-    if (!core_text_space) {
-	return;
-    } /* if */
-    if (p_lowpc < s_lowpc) {
-	p_lowpc = s_lowpc;
-    } /* if */
-    if (p_highpc > s_highpc) {
-	p_highpc = s_highpc;
-    } /* if */
-    DBG(CALLDEBUG, printf("[find_call] %s: 0x%lx to 0x%lx\n",
+  if (!delta)
+    {
+      delta = (bfd_vma) core_text_space - core_text_sect->vma;
+
+      sym_init (&indirect_child);
+      indirect_child.name = "<indirect child>";
+      indirect_child.cg.prop.fract = 1.0;
+      indirect_child.cg.cyc.head = &indirect_child;
+    }				/* if */
+
+  if (!core_text_space)
+    {
+      return;
+    }				/* if */
+  if (p_lowpc < s_lowpc)
+    {
+      p_lowpc = s_lowpc;
+    }				/* if */
+  if (p_highpc > s_highpc)
+    {
+      p_highpc = s_highpc;
+    }				/* if */
+  DBG (CALLDEBUG, printf ("[find_call] %s: 0x%lx to 0x%lx\n",
 			  parent->name, p_lowpc, p_highpc));
-    for (pc = (Instruction*)(p_lowpc + delta);
-	 pc < (Instruction*)(p_highpc + delta);
-	 ++pc)
+  for (pc = (Instruction *) (p_lowpc + delta);
+       pc < (Instruction *) (p_highpc + delta);
+       ++pc)
     {
-	switch (pc->a.op_code) {
-	  case OP_Jxx:
-	    /*
-	     * There is no simple and reliable way to determine the
-	     * target of a jsr (the hint bits help, but there aren't
-	     * enough bits to get a satisfactory hit rate).  Instead,
-	     * for any indirect jump we simply add an arc from PARENT
-	     * to INDIRECT_CHILD---that way the user it at least able
-	     * to see that there are other calls as well.
-	     */
-	    if (pc->j.func == Jxx_FUNC_JSR
-		|| pc->j.func == Jxx_FUNC_JSR_COROUTINE)
+      switch (pc->a.op_code)
+	{
+	case OP_Jxx:
+	  /*
+	   * There is no simple and reliable way to determine the
+	   * target of a jsr (the hint bits help, but there aren't
+	   * enough bits to get a satisfactory hit rate).  Instead,
+	   * for any indirect jump we simply add an arc from PARENT
+	   * to INDIRECT_CHILD---that way the user it at least able
+	   * to see that there are other calls as well.
+	   */
+	  if (pc->j.func == Jxx_FUNC_JSR
+	      || pc->j.func == Jxx_FUNC_JSR_COROUTINE)
 	    {
-		DBG(CALLDEBUG,
-		    printf("[find_call] 0x%lx: jsr%s <indirect_child>\n",
+	      DBG (CALLDEBUG,
+		   printf ("[find_call] 0x%lx: jsr%s <indirect_child>\n",
 			   (bfd_vma) pc - delta,
 			   pc->j.func == Jxx_FUNC_JSR ? "" : "_coroutine"));
-		arc_add(parent, &indirect_child, 0);
-	    } /* if */
-	    break;
+	      arc_add (parent, &indirect_child, 0);
+	    }			/* if */
+	  break;
 
-	  case OP_BSR:
-	    DBG(CALLDEBUG,
-		printf("[find_call] 0x%lx: bsr", (bfd_vma) pc - delta));
-	    /*
-	     * Regular PC relative addressing.  Check that this is the
-	     * address of a function.  The linker sometimes redirects
-	     * the entry point by 8 bytes to skip loading the global
-	     * pointer, so we all for either address:
-	     */
-	    dest_pc = ((bfd_vma) (pc + 1 + pc->b.disp)) - delta;
-	    if (dest_pc >= s_lowpc && dest_pc <= s_highpc) {
-		child = sym_lookup(&symtab, dest_pc);
-		DBG(CALLDEBUG,
-		    printf(" 0x%lx\t; name=%s, addr=0x%lx",
+	case OP_BSR:
+	  DBG (CALLDEBUG,
+	       printf ("[find_call] 0x%lx: bsr", (bfd_vma) pc - delta));
+	  /*
+	   * Regular PC relative addressing.  Check that this is the
+	   * address of a function.  The linker sometimes redirects
+	   * the entry point by 8 bytes to skip loading the global
+	   * pointer, so we all for either address:
+	   */
+	  dest_pc = ((bfd_vma) (pc + 1 + pc->b.disp)) - delta;
+	  if (dest_pc >= s_lowpc && dest_pc <= s_highpc)
+	    {
+	      child = sym_lookup (&symtab, dest_pc);
+	      DBG (CALLDEBUG,
+		   printf (" 0x%lx\t; name=%s, addr=0x%lx",
 			   dest_pc, child->name, child->addr));
-		if (child->addr == dest_pc || child->addr == dest_pc - 8) {
-		    DBG(CALLDEBUG, printf("\n"));
-		    /* a hit:  */
-		    arc_add(parent, child, 0);
-		    continue;
-		} /* if */
-	    } /* if */
-	    /*
-	     * Something funny going on.
-	     */
-	    DBG(CALLDEBUG, printf("\tbut it's a botch\n"));
-	    break;
+	      if (child->addr == dest_pc || child->addr == dest_pc - 8)
+		{
+		  DBG (CALLDEBUG, printf ("\n"));
+		  /* a hit:  */
+		  arc_add (parent, child, 0);
+		  continue;
+		}		/* if */
+	    }			/* if */
+	  /*
+	   * Something funny going on.
+	   */
+	  DBG (CALLDEBUG, printf ("\tbut it's a botch\n"));
+	  break;
 
-	  default:
-	    break;
-	} /* switch */
-    } /* for */
-} /* find_call */
-			/*** end of alpha.c ***/
+	default:
+	  break;
+	}			/* switch */
+    }				/* for */
+}				/* find_call */
+/*** end of alpha.c ***/