reformat a little to match GNU coding standards.

From-SVN: r14024

23 files changed, 122 insertions, 122 deletions

diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index ebe8922..d4ed6a4 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -7515,9 +7515,9 @@ gen_subprogram_die (decl, context_die)
       for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
 	if (TREE_CODE (parm) == PARM_DECL)
 	  {
-	    if (DECL_NAME (parm) &&
-		!strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
-			 "__builtin_va_alist"))
+	    if (DECL_NAME (parm)
+		&& !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
+			    "__builtin_va_alist"))
 	      gen_unspecified_parameters_die (parm, subr_die);
 	    else
 	      gen_decl_die (parm, subr_die);
diff --git a/gcc/expmed.c b/gcc/expmed.c
index 65fb007..291e8d4 100644
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -920,8 +920,8 @@ extract_bit_field (str_rtx, bitsize, bitnum, unsignedp,
   /* If OP0 is a register, BITPOS must count within a word.
      But as we have it, it counts within whatever size OP0 now has.
      On a bigendian machine, these are not the same, so convert.  */
-  if (BYTES_BIG_ENDIAN &&
-      GET_CODE (op0) != MEM
+  if (BYTES_BIG_ENDIAN
+      && GET_CODE (op0) != MEM
       && unit > GET_MODE_BITSIZE (GET_MODE (op0)))
     bitpos += unit - GET_MODE_BITSIZE (GET_MODE (op0));
 
@@ -2875,11 +2875,11 @@ expand_divmod (rem_flag, code, mode, op0, op1, target, unsignedp)
 		    pre_shift = floor_log2 (d);
 		    if (rem_flag)
 		      {
-			remainder =
-			  expand_binop (compute_mode, and_optab, op0,
-					GEN_INT (((HOST_WIDE_INT) 1 << pre_shift) - 1),
-					remainder, 1,
-					OPTAB_LIB_WIDEN);
+			remainder
+			  = expand_binop (compute_mode, and_optab, op0,
+					  GEN_INT (((HOST_WIDE_INT) 1 << pre_shift) - 1),
+					  remainder, 1,
+					  OPTAB_LIB_WIDEN);
 			if (remainder)
 			  return gen_lowpart (mode, remainder);
 		      }
@@ -2940,10 +2940,10 @@ expand_divmod (rem_flag, code, mode, op0, op1, target, unsignedp)
 			    t4 = force_operand (gen_rtx (PLUS, compute_mode,
 							 t1, t3),
 						NULL_RTX);
-			    quotient =
-			      expand_shift (RSHIFT_EXPR, compute_mode, t4,
-					    build_int_2 (post_shift - 1, 0),
-					    tquotient, 1);
+			    quotient
+			      = expand_shift (RSHIFT_EXPR, compute_mode, t4,
+					      build_int_2 (post_shift - 1, 0),
+					      tquotient, 1);
 			  }
 			else
 			  {
@@ -2959,10 +2959,10 @@ expand_divmod (rem_flag, code, mode, op0, op1, target, unsignedp)
 						       max_cost - extra_cost);
 			    if (t2 == 0)
 			      goto fail1;
-			    quotient =
-			      expand_shift (RSHIFT_EXPR, compute_mode, t2,
-					    build_int_2 (post_shift, 0),
-					    tquotient, 1);
+			    quotient
+			      = expand_shift (RSHIFT_EXPR, compute_mode, t2,
+					      build_int_2 (post_shift, 0),
+					      tquotient, 1);
 			  }
 		      }
 		  }
diff --git a/gcc/expr.c b/gcc/expr.c
index b3babf6..1dc79b6 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -263,9 +263,9 @@ bc_init_mode_to_opcode_maps ()
   int mode;
 
   for (mode = 0; mode < (int) MAX_MACHINE_MODE; mode++)
-    mode_to_const_map[mode] =
-      mode_to_load_map[mode] =
-	mode_to_store_map[mode] = neverneverland;
+    mode_to_const_map[mode]
+      = mode_to_load_map[mode]
+      = mode_to_store_map[mode] = neverneverland;
       
 #define DEF_MODEMAP(SYM, CODE, UCODE, CONST, LOAD, STORE) \
   mode_to_const_map[(int) SYM] = CONST; \
@@ -1522,12 +1522,12 @@ move_by_pieces_1 (genfun, mode, data)
 							data->offset))));
       MEM_IN_STRUCT_P (to1) = data->to_struct;
 
-      from1 =
-	(data->autinc_from
-	 ? gen_rtx (MEM, mode, data->from_addr)
-	 : copy_rtx (change_address (data->from, mode,
-				     plus_constant (data->from_addr,
-						    data->offset))));
+      from1
+	= (data->autinc_from
+	   ? gen_rtx (MEM, mode, data->from_addr)
+	   : copy_rtx (change_address (data->from, mode,
+				       plus_constant (data->from_addr,
+						      data->offset))));
       MEM_IN_STRUCT_P (from1) = data->from_struct;
 
 #ifdef HAVE_PRE_DECREMENT
diff --git a/gcc/final.c b/gcc/final.c
index 0f2afd9..9096d54 100644
--- a/gcc/final.c
+++ b/gcc/final.c
@@ -1011,8 +1011,8 @@ final_start_function (first, file, optimize)
      of the function name.  */
   if (profile_block_flag)
     {
-      bb_func_label_num =
-	add_bb_string ((*decl_printable_name) (current_function_decl, 2), FALSE);
+      bb_func_label_num
+	= add_bb_string ((*decl_printable_name) (current_function_decl, 2), FALSE);
     }
 }
 
diff --git a/gcc/fix-header.c b/gcc/fix-header.c
index 3464d3f..2400651 100644
--- a/gcc/fix-header.c
+++ b/gcc/fix-header.c
@@ -632,8 +632,8 @@ read_scan_file (in_fname, argc, argv)
       && (fn = lookup_std_proto ("_filbuf", 7)) != NULL)
     {
       static char getchar_call[] = "getchar();";
-      cpp_buffer *buf =
-	cpp_push_buffer (&scan_in, getchar_call, sizeof(getchar_call) - 1);
+      cpp_buffer *buf
+	= cpp_push_buffer (&scan_in, getchar_call, sizeof(getchar_call) - 1);
       int old_written = CPP_WRITTEN (&scan_in);
       int seen_filbuf = 0;
 
diff --git a/gcc/flow.c b/gcc/flow.c
index 72b42ea..1e5d265 100644
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -987,8 +987,8 @@ life_analysis (f, nregs)
 	  if (GET_CODE (PATTERN (insn)) == SET
 	      && GET_CODE (SET_DEST (PATTERN (insn))) == REG
 	      && GET_CODE (SET_SRC (PATTERN (insn))) == REG
-	      && REGNO (SET_DEST (PATTERN (insn))) ==
-			REGNO (SET_SRC (PATTERN (insn)))
+	      && (REGNO (SET_DEST (PATTERN (insn)))
+		  == REGNO (SET_SRC (PATTERN (insn))))
 	      /* Insns carrying these notes are useful later on.  */
 	      && ! find_reg_note (insn, REG_EQUAL, NULL_RTX))
 	    {
@@ -1002,8 +1002,8 @@ life_analysis (f, nregs)
 	      && GET_CODE (SUBREG_REG (SET_DEST (PATTERN (insn)))) == REG
 	      && GET_CODE (SET_SRC (PATTERN (insn))) == SUBREG
 	      && GET_CODE (SUBREG_REG (SET_SRC (PATTERN (insn)))) == REG
-	      && REGNO (SUBREG_REG (SET_DEST (PATTERN (insn)))) ==
-			REGNO (SUBREG_REG (SET_SRC (PATTERN (insn))))
+	      && (REGNO (SUBREG_REG (SET_DEST (PATTERN (insn))))
+		  == REGNO (SUBREG_REG (SET_SRC (PATTERN (insn)))))
 	      && SUBREG_WORD (SET_DEST (PATTERN (insn))) ==
 			      SUBREG_WORD (SET_SRC (PATTERN (insn)))
 	      /* Insns carrying these notes are useful later on.  */
diff --git a/gcc/function.c b/gcc/function.c
index 750f333..571ac62 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -4279,8 +4279,8 @@ locate_and_pad_parm (passed_mode, type, in_regs, fndecl,
     }
   else
     {
-      arg_size_ptr->constant = (- initial_offset_ptr->constant -
-				offset_ptr->constant); 
+      arg_size_ptr->constant = (- initial_offset_ptr->constant
+				- offset_ptr->constant); 
     }
 #else /* !ARGS_GROW_DOWNWARD */
   pad_to_arg_alignment (initial_offset_ptr, boundary);
@@ -5134,8 +5134,8 @@ bc_expand_function_start (subr, parms_have_cleanups)
   ++nlab;
   name = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
   this_function_callinfo = bc_gen_rtx (name, 0, (struct bc_label *) 0);
-  this_function_bytecode =
-    bc_emit_trampoline (BYTECODE_LABEL (this_function_callinfo));
+  this_function_bytecode
+    = bc_emit_trampoline (BYTECODE_LABEL (this_function_callinfo));
 }
 
 
diff --git a/gcc/gcov.c b/gcc/gcov.c
index fe9dce8..b3ad330 100644
--- a/gcc/gcov.c
+++ b/gcc/gcov.c
@@ -1301,8 +1301,8 @@ output_data ()
 	      /* In case the source file line is larger than our buffer, keep
 		 reading and outputing lines until we get a newline.  */
 	      len = strlen (string);
-	      while ((len == 0 || string[strlen (string) - 1] != '\n') &&
-		     retval != NULL)
+	      while ((len == 0 || string[strlen (string) - 1] != '\n')
+		     && retval != NULL)
 		{
 		  retval = fgets (string, STRING_SIZE, source_file);
 		  fputs (string, gcov_file);
@@ -1358,8 +1358,8 @@ output_data ()
 		/* In case the source file line is larger than our buffer, keep
 		   reading and outputing lines until we get a newline.  */
 		len = strlen (string);
-		while ((len == 0 || string[strlen (string) - 1] != '\n') &&
-		       retval != NULL)
+		while ((len == 0 || string[strlen (string) - 1] != '\n')
+		       && retval != NULL)
 		  {
 		    retval = fgets (string, STRING_SIZE, source_file);
 		    fputs (string, gcov_file);
diff --git a/gcc/integrate.c b/gcc/integrate.c
index 423ded2..d5f5b51 100644
--- a/gcc/integrate.c
+++ b/gcc/integrate.c
@@ -175,9 +175,9 @@ function_cannot_inline_p (fndecl)
   /* This is a hack, until the inliner is taught about eh regions at
      the start of the function.  */
   for (insn = get_insns ();
-       insn &&
-         ! (GET_CODE (insn) == NOTE
-	    && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG);
+       insn
+	 && ! (GET_CODE (insn) == NOTE
+	       && NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG);
        insn = NEXT_INSN (insn))
     {
       if (insn && GET_CODE (insn) == NOTE
@@ -604,8 +604,8 @@ save_for_inline_copying (fndecl)
 	  copy = rtx_alloc (GET_CODE (insn));
 
 	  if (GET_CODE (insn) == CALL_INSN)
-	    CALL_INSN_FUNCTION_USAGE (copy) =
-	           copy_for_inline (CALL_INSN_FUNCTION_USAGE (insn));
+	    CALL_INSN_FUNCTION_USAGE (copy)
+	      = copy_for_inline (CALL_INSN_FUNCTION_USAGE (insn));
 
 	  PATTERN (copy) = copy_for_inline (PATTERN (insn));
 	  INSN_CODE (copy) = -1;
@@ -1896,8 +1896,8 @@ expand_inline_function (fndecl, parms, target, ignore, type,
 
 	  /* Because the USAGE information potentially contains objects other
 	     than hard registers, we need to copy it.  */
-	  CALL_INSN_FUNCTION_USAGE (copy) =
-	     copy_rtx_and_substitute (CALL_INSN_FUNCTION_USAGE (insn), map);
+	  CALL_INSN_FUNCTION_USAGE (copy)
+	    = copy_rtx_and_substitute (CALL_INSN_FUNCTION_USAGE (insn), map);
 
 #ifdef HAVE_cc0
 	  if (cc0_insn)
diff --git a/gcc/jump.c b/gcc/jump.c
index 2253f7b..316e741 100644
--- a/gcc/jump.c
+++ b/gcc/jump.c
@@ -449,8 +449,8 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
 					      sreg, NULL_PTR, dreg,
 					      GET_MODE (SET_SRC (body)));
 
-		    if (tem != 0 &&
-			GET_MODE (tem) == GET_MODE (SET_DEST (body)))
+		    if (tem != 0
+			&& GET_MODE (tem) == GET_MODE (SET_DEST (body)))
 		      {
 			/* DREG may have been the target of a REG_DEAD note in
 			   the insn which makes INSN redundant.  If so, reorg
diff --git a/gcc/libgcc2.c b/gcc/libgcc2.c
index 7251618..107c4bf 100644
--- a/gcc/libgcc2.c
+++ b/gcc/libgcc2.c
@@ -1815,8 +1815,8 @@ gopen (char *fn, char *mode)
     return (FILE *) 0;
 
   p = fn + strlen (fn)-1;
-  use_gzip = ((p[-1] == '.' && (p[0] == 'Z' || p[0] == 'z')) ||
-              (p[-2] == '.' && p[-1] == 'g' && p[0] == 'z'));
+  use_gzip = ((p[-1] == '.' && (p[0] == 'Z' || p[0] == 'z'))
+	      || (p[-2] == '.' && p[-1] == 'g' && p[0] == 'z'));
 
   if (use_gzip)
     {
@@ -2195,15 +2195,15 @@ __bb_trace_func ()
     {
       struct bb_edge **startbucket, **oldnext;
 
-      oldnext = startbucket =
-          & bb_hashbuckets[ (((int) bb_src*8) ^ (int) bb_dst) % BB_BUCKETS ];
+      oldnext = startbucket
+	= & bb_hashbuckets[ (((int) bb_src*8) ^ (int) bb_dst) % BB_BUCKETS ];
       bucket = *startbucket;
 
       for (bucket = *startbucket; bucket; 
            oldnext = &(bucket->next), bucket = *oldnext)
         {
-          if ( bucket->src_addr == bb_src &&
-               bucket->dst_addr == bb_dst )
+          if (bucket->src_addr == bb_src
+	      && bucket->dst_addr == bb_dst)
             {
               bucket->count++;
               *oldnext = bucket->next;
@@ -2258,15 +2258,15 @@ __bb_trace_func_ret ()
     {
       struct bb_edge **startbucket, **oldnext;
 
-      oldnext = startbucket =
-          & bb_hashbuckets[ (((int) bb_dst * 8) ^ (int) bb_src) % BB_BUCKETS ];
+      oldnext = startbucket
+	= & bb_hashbuckets[ (((int) bb_dst * 8) ^ (int) bb_src) % BB_BUCKETS ];
       bucket = *startbucket;
 
       for (bucket = *startbucket; bucket; 
            oldnext = &(bucket->next), bucket = *oldnext)
         {
-          if ( bucket->src_addr == bb_dst &&
-               bucket->dst_addr == bb_src )
+          if (bucket->src_addr == bb_dst
+	       && bucket->dst_addr == bb_src)
             {
               bucket->count++;
               *oldnext = bucket->next;
@@ -2321,8 +2321,8 @@ __bb_init_file (struct bb *blocks)
   bb_head = blocks;
 
   blocks->flags = 0;
-  if (!bb_func_head ||
-      !(blocks->flags = (char *) malloc (sizeof (char) * blocks->ncounts)))
+  if (!bb_func_head
+      || !(blocks->flags = (char *) malloc (sizeof (char) * blocks->ncounts)))
     return;
 
   for (blk = 0; blk < ncounts; blk++)
@@ -2332,8 +2332,8 @@ __bb_init_file (struct bb *blocks)
     {
       for (p = bb_func_head; p; p = p->next)
         {
-          if (!strcmp (p->funcname, functions[blk]) &&
-              (!p->filename || !strcmp (p->filename, blocks->filename)))
+          if (!strcmp (p->funcname, functions[blk])
+	      && (!p->filename || !strcmp (p->filename, blocks->filename)))
             {
               blocks->flags[blk] |= p->mode;
             }
diff --git a/gcc/loop.c b/gcc/loop.c
index 698e7a1..64c1245 100644
--- a/gcc/loop.c
+++ b/gcc/loop.c
@@ -1804,8 +1804,8 @@ move_movables (movables, threshold, insn_count, loop_start, end, nregs)
 				     contains objects other than hard registers
 				     we need to copy it.  */
 				  if (CALL_INSN_FUNCTION_USAGE (temp))
-				    CALL_INSN_FUNCTION_USAGE (i1) =
-				      copy_rtx (CALL_INSN_FUNCTION_USAGE (temp));
+				    CALL_INSN_FUNCTION_USAGE (i1)
+				      = copy_rtx (CALL_INSN_FUNCTION_USAGE (temp));
 				}
 			      else
 				i1 = emit_insn_before (body, loop_start);
@@ -1848,8 +1848,8 @@ move_movables (movables, threshold, insn_count, loop_start, end, nregs)
 			     contains objects other than hard registers
 			     we need to copy it.  */
 			  if (CALL_INSN_FUNCTION_USAGE (p))
-			    CALL_INSN_FUNCTION_USAGE (i1) =
-			      copy_rtx (CALL_INSN_FUNCTION_USAGE (p));
+			    CALL_INSN_FUNCTION_USAGE (i1)
+			      = copy_rtx (CALL_INSN_FUNCTION_USAGE (p));
 			}
 		      else
 			i1 = emit_insn_before (PATTERN (p), loop_start);
@@ -5920,8 +5920,8 @@ check_dbra_loop (loop_end, insn_count, loop_start)
 
       if (GET_CODE (bl->initial_value) == CONST_INT
 	  && INTVAL (bl->initial_value) > 0
-	  && (INTVAL (bl->initial_value) %
-	      (-INTVAL (bl->biv->add_val))) == 0)
+	  && (INTVAL (bl->initial_value)
+	      % (-INTVAL (bl->biv->add_val))) == 0)
 	{
 	  /* register always nonnegative, add REG_NOTE to branch */
 	  REG_NOTES (PREV_INSN (loop_end))
diff --git a/gcc/mips-tdump.c b/gcc/mips-tdump.c
index 6890fc7..3eb4ef8 100644
--- a/gcc/mips-tdump.c
+++ b/gcc/mips-tdump.c
@@ -1526,9 +1526,9 @@ main (argc, argv)
       if (sym_hdr.ifdMax == 0)
 	last_aux_in_use = 0;
       else
-	last_aux_in_use =
-	  file_desc[sym_hdr.ifdMax-1].iauxBase +
-	  file_desc[sym_hdr.ifdMax-1].caux - 1;
+	last_aux_in_use
+	  = (file_desc[sym_hdr.ifdMax-1].iauxBase
+	     + file_desc[sym_hdr.ifdMax-1].caux - 1);
 
       if (last_aux_in_use < sym_hdr.iauxMax-1)
 	{
diff --git a/gcc/mips-tfile.c b/gcc/mips-tfile.c
index 61bbbc9..4cd18d0 100644
--- a/gcc/mips-tfile.c
+++ b/gcc/mips-tfile.c
@@ -1899,8 +1899,8 @@ add_string (vp, hash_tbl, start, end_p1, ret_hash)
 
       if (vp->objects_last_page + len >= PAGE_USIZE)
 	{
-	  vp->num_allocated =
-	    ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE;
+	  vp->num_allocated
+	    = ((vp->num_allocated + PAGE_USIZE - 1) / PAGE_USIZE) * PAGE_USIZE;
 	  add_varray_page (vp);
 	}
 
@@ -2576,8 +2576,8 @@ add_file (file_start, file_end_p1)
       if (file_desc.objects_last_page == file_desc.objects_per_page)
 	add_varray_page (&file_desc);
 
-      file_ptr = cur_file_ptr =
-	&file_desc.last->datum->file[ file_desc.objects_last_page++ ];
+      file_ptr = cur_file_ptr
+	= &file_desc.last->datum->file[ file_desc.objects_last_page++ ];
       *file_ptr = init_file;
 
       file_ptr->file_index = file_desc.num_allocated++;
diff --git a/gcc/profile.c b/gcc/profile.c
index dcdd5fe..0509562 100644
--- a/gcc/profile.c
+++ b/gcc/profile.c
@@ -499,8 +499,8 @@ branch_prob (f, dump_file)
 	else if ((prev_code == JUMP_INSN || prev_code == CALL_INSN
 		  || prev_code == CODE_LABEL || prev_code == BARRIER)
 		 && (GET_RTX_CLASS (code) == 'i'
-		     || (code == NOTE &&
-			 NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)))
+		     || (code == NOTE
+			 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)))
 	  {
 	    i += 1;
 
@@ -550,8 +550,8 @@ branch_prob (f, dump_file)
 		      {
 			if (last_bb_file_name)
 			  free (last_bb_file_name);
-			last_bb_file_name =
-			  xmalloc (strlen (NOTE_SOURCE_FILE (insn)) + 1);
+			last_bb_file_name
+			  = xmalloc (strlen (NOTE_SOURCE_FILE (insn)) + 1);
 			strcpy (last_bb_file_name, NOTE_SOURCE_FILE (insn));
 			output_gcov_string (NOTE_SOURCE_FILE (insn), (long)-1);
 		      }
@@ -662,8 +662,8 @@ branch_prob (f, dump_file)
 	else if ((prev_code == JUMP_INSN || prev_code == CALL_INSN
 		  || prev_code == CODE_LABEL || prev_code == BARRIER)
 		 && (GET_RTX_CLASS (code) == 'i'
-		     || (code == NOTE &&
-			 NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)))
+		     || (code == NOTE
+			 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_SETJMP)))
 	  {
 	    /* This is the first insn of the block.  */
 	    i += 1;
diff --git a/gcc/protoize.c b/gcc/protoize.c
index e94b79c..d386664 100644
--- a/gcc/protoize.c
+++ b/gcc/protoize.c
@@ -1788,8 +1788,8 @@ save_def_or_dec (l, is_syscalls)
       const char *left_paren_p = find_corresponding_lparen (p);
 #ifndef UNPROTOIZE
       {
-        f_list_chain_item *cip =
-          (f_list_chain_item *) xmalloc (sizeof (f_list_chain_item));
+        f_list_chain_item *cip
+	  = (f_list_chain_item *) xmalloc (sizeof (f_list_chain_item));
 
         cip->formals_list
 	  = dupnstr (left_paren_p + 1, (size_t) (p - (left_paren_p+1)));
@@ -4362,8 +4362,8 @@ edit_file (hp)
 
   if (!nosave_flag)
     {
-      char *new_filename =
-          (char *) xmalloc (strlen (convert_filename) + strlen (save_suffix) + 2);
+      char *new_filename
+	= (char *) xmalloc (strlen (convert_filename) + strlen (save_suffix) + 2);
   
       strcpy (new_filename, convert_filename);
       strcat (new_filename, save_suffix);
@@ -4659,8 +4659,8 @@ main (argc, argv)
 
   /* Now actually make a list of the base source filenames.  */
 
-  base_source_filenames =
-    (const char **) xmalloc ((n_base_source_files + 1) * sizeof (char *));
+  base_source_filenames
+    = (const char **) xmalloc ((n_base_source_files + 1) * sizeof (char *));
   n_base_source_files = 0;
   for (; optind < argc; optind++)
     {
diff --git a/gcc/reg-stack.c b/gcc/reg-stack.c
index 8551e65..5ef9356 100644
--- a/gcc/reg-stack.c
+++ b/gcc/reg-stack.c
@@ -3122,8 +3122,8 @@ convert_regs ()
 
       }
      for (reg = regstack.top; reg >= 0; reg--)
-        if (regstack.reg[reg] < value_reg_low ||
-            regstack.reg[reg] > value_reg_high)
+        if (regstack.reg[reg] < value_reg_low
+	    || regstack.reg[reg] > value_reg_high)
            insn = emit_pop_insn (insn, &regstack,
 			    FP_MODE_REG (regstack.reg[reg], DFmode),
 			    emit_insn_after);
diff --git a/gcc/reload.c b/gcc/reload.c
index 4a69835..a868931 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -3576,20 +3576,20 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	      }
 	  }
 	else if (goal_alternative_matched[i] == -1)
-	  operand_reloadnum[i] =
-	    push_reload (modified[i] != RELOAD_WRITE ? recog_operand[i] : 0,
-			 modified[i] != RELOAD_READ ? recog_operand[i] : 0,
-			 (modified[i] != RELOAD_WRITE ?
-			  recog_operand_loc[i] : 0),
-			 modified[i] != RELOAD_READ ? recog_operand_loc[i] : 0,
-			 (enum reg_class) goal_alternative[i],
-			 (modified[i] == RELOAD_WRITE
-			  ? VOIDmode : operand_mode[i]),
-			 (modified[i] == RELOAD_READ
-			  ? VOIDmode : operand_mode[i]),
-			 (insn_code_number < 0 ? 0
-			  : insn_operand_strict_low[insn_code_number][i]),
-			 0, i, operand_type[i]);
+	  operand_reloadnum[i]
+	    = push_reload (modified[i] != RELOAD_WRITE ? recog_operand[i] : 0,
+			   modified[i] != RELOAD_READ ? recog_operand[i] : 0,
+			   (modified[i] != RELOAD_WRITE
+			    ? recog_operand_loc[i] : 0),
+			   modified[i] != RELOAD_READ ? recog_operand_loc[i] : 0,
+			   (enum reg_class) goal_alternative[i],
+			   (modified[i] == RELOAD_WRITE
+			    ? VOIDmode : operand_mode[i]),
+			   (modified[i] == RELOAD_READ
+			    ? VOIDmode : operand_mode[i]),
+			   (insn_code_number < 0 ? 0
+			    : insn_operand_strict_low[insn_code_number][i]),
+			   0, i, operand_type[i]);
 	/* In a matching pair of operands, one must be input only
 	   and the other must be output only.
 	   Pass the input operand as IN and the other as OUT.  */
@@ -3828,8 +3828,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	    {
 	      int secondary_in_reload = reload_secondary_in_reload[i];
 
-	      reload_when_needed[secondary_in_reload] = 
-		RELOAD_FOR_OPADDR_ADDR;
+	      reload_when_needed[secondary_in_reload]
+		= RELOAD_FOR_OPADDR_ADDR;
 
 	      /* If there's a tertiary reload we have to change it also.  */
 	      if (secondary_in_reload > 0
@@ -3844,8 +3844,8 @@ find_reloads (insn, replace, ind_levels, live_known, reload_reg_p)
 	    {
 	      int secondary_out_reload = reload_secondary_out_reload[i];
 
-	      reload_when_needed[secondary_out_reload] = 
-		RELOAD_FOR_OPADDR_ADDR;
+	      reload_when_needed[secondary_out_reload]
+		= RELOAD_FOR_OPADDR_ADDR;
 
 	      /* If there's a tertiary reload we have to change it also.  */
 	      if (secondary_out_reload
diff --git a/gcc/sched.c b/gcc/sched.c
index d7fe1ca..cfef88f 100644
--- a/gcc/sched.c
+++ b/gcc/sched.c
@@ -645,8 +645,8 @@ memrefs_conflict_p (xsize, x, ysize, y, c)
     y = canon_rtx (y);
 
   if (rtx_equal_for_memref_p (x, y))
-    return (xsize == 0 || ysize == 0 ||
-	    (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
+    return (xsize == 0 || ysize == 0
+	    || (c >= 0 && xsize > c) || (c < 0 && ysize+c > 0));
 
   if (y == frame_pointer_rtx || y == hard_frame_pointer_rtx
       || y == stack_pointer_rtx)
diff --git a/gcc/sdbout.c b/gcc/sdbout.c
index 12924c0..046ec32 100644
--- a/gcc/sdbout.c
+++ b/gcc/sdbout.c
@@ -1286,8 +1286,8 @@ sdbout_parms (parms)
 
 	/* Perform any necessary register eliminations on the parameter's rtl,
 	   so that the debugging output will be accurate.  */
-	DECL_INCOMING_RTL (parms) =
-	  eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX, 0);
+	DECL_INCOMING_RTL (parms)
+	  = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX, 0);
 	DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX, 0);
 
 	if (PARM_PASSED_IN_MEMORY (parms))
diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c
index e55961a9..8c2357a 100644
--- a/gcc/stor-layout.c
+++ b/gcc/stor-layout.c
@@ -949,9 +949,9 @@ layout_type (type)
 #define SET_WORD_SIZE BITS_PER_WORD
 #endif
 	  int alignment = set_alignment ? set_alignment : SET_WORD_SIZE;
-	  int size_in_bits =
-	    TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
-	      - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1;
+	  int size_in_bits
+	    = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
+	       - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1);
 	  int rounded_size
 	    = ((size_in_bits + alignment - 1) / alignment) * alignment;
 	  if (rounded_size > alignment)
diff --git a/gcc/tree.c b/gcc/tree.c
index f6a92e1..170892e 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -4564,8 +4564,8 @@ get_set_constructor_bits (init, buffer, bit_size)
       if (TREE_CODE (TREE_VALUE (vals)) != INTEGER_CST
 	  || (TREE_PURPOSE (vals) != NULL_TREE
 	      && TREE_CODE (TREE_PURPOSE (vals)) != INTEGER_CST))
-	non_const_bits =
-	  tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits);
+	non_const_bits
+	  = tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits);
       else if (TREE_PURPOSE (vals) != NULL_TREE)
 	{
 	  /* Set a range of bits to ones.  */
diff --git a/gcc/unroll.c b/gcc/unroll.c
index 2f9d969..de5f64a 100644
--- a/gcc/unroll.c
+++ b/gcc/unroll.c
@@ -2011,8 +2011,8 @@ copy_loop_body (copy_start, copy_end, map, exit_label, last_iteration,
 
 	  /* Because the USAGE information potentially contains objects other
 	     than hard registers, we need to copy it.  */
-	  CALL_INSN_FUNCTION_USAGE (copy) =
-	     copy_rtx_and_substitute (CALL_INSN_FUNCTION_USAGE (insn), map);
+	  CALL_INSN_FUNCTION_USAGE (copy)
+	    = copy_rtx_and_substitute (CALL_INSN_FUNCTION_USAGE (insn), map);
 
 #ifdef HAVE_cc0
 	  if (cc0_insn)