This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH 3/3] Fix indentation issues seen by -Wmisleading-indentation


This patch fixes the places in our tree where -Wmisleading-indentation
correctly identifies code that's misleadingly indented.

In particular, a couple of places in
  gcc/cp/parser.c:cp_parser_asm_definition
appeared to be missing braces, both of the form:

  if (complicated_multiline_condition ())
    some_var_not_otherwise_set = some_value ();

    if (some_var_not_otherwise_set == error_mark_node)
       some_flag = true;

where the second "if" is misleadingly indented as if guarded by
the first.  Given the logic, it was clear that these ought to have
been so guarded, so I changed these to read:

 if (complicated_multiline_condition ())
   {
     some_var_not_otherwise_set = some_value ();

     if (some_var_not_otherwise_set == error_mark_node)
       some_flag = true;
   }

gcc/ChangeLog:
	* auto-profile.c (afdo_find_equiv_class): Fix indentation so
	that it reflects the block structure.
	(afdo_propagate_edge): Likewise.
	(afdo_calculate_branch_prob): Likewise.
	(afdo_annotate_cfg): Likewise.
	* cfgcleanup.c (equal_different_set_p): Likewise.
	(try_crossjump_to_edge): Likewise.
	* cgraph.c (cgraph_node::verify_node): Likewise.
	* cgraphunit.c (expand_all_functions): Likewise.
	* config/i386/i386.c (ix86_expand_copysign): Likewise.
	(exact_dependency_1): Likewise.
	* dwarf2asm.c (dw2_output_indirect_constants): Likewise.
	* dwarf2out.c (tree_add_const_value_attribute_for_decl): Likewise.
	* gensupport.c (process_define_subst): Likewise.
	* lto-wrapper.c (merge_and_complain): Likewise.
	* tree-if-conv.c (if_convertible_bb_p): Likewise.
	* tree-ssa-loop-prefetch.c (find_or_create_group): Likewise.
	* tree-ssa-tail-merge.c (gsi_advance_fw_nondebug_nonlocal): Likewise.
	* tree-vect-data-refs.c (vect_grouped_load_supported): Likewise.
	* tree-vect-loop.c (vectorizable_reduction): Likewise.
	* tree-vect-slp.c (vect_transform_slp_perm_load): Likewise.
	* tree-vect-stmts.c (vectorizable_shift): Likewise.
	* tree-vrp.c (vrp_finalize): Likewise.
	* tree.c (variably_modified_type_p): Likewise.

gcc/cp/ChangeLog:
	* parser.c (cp_parser_asm_definition): Only test for
        error_mark_node if "outputs" was just set.
	(cp_parser_asm_definition): Likewise for "inputs".

gcc/fortran/ChangeLog:
	* expr.c (check_inquiry): Fix indentation so that it reflects the
	block structure.
	* interface.c (compare_parameter): Likewise.
	* parse.c (parse_oacc_structured_block): Likewise.
	* target-memory.c (expr_to_char): Likewise.
	* trans-types.c (gfc_init_kinds): Likewise.

libcpp/ChangeLog:
	* pch.c (cpp_valid_state): Fix indentation so that it reflects the
	block structure.
---
 gcc/auto-profile.c           | 52 ++++++++++++++++++++++----------------------
 gcc/cfgcleanup.c             |  6 ++---
 gcc/cgraph.c                 | 10 ++++-----
 gcc/cgraphunit.c             | 16 +++++++-------
 gcc/config/i386/i386.c       |  4 ++--
 gcc/cp/parser.c              | 18 ++++++++-------
 gcc/dwarf2asm.c              |  4 ++--
 gcc/dwarf2out.c              | 12 +++++-----
 gcc/fortran/expr.c           |  4 ++--
 gcc/fortran/interface.c      |  2 +-
 gcc/fortran/parse.c          |  2 +-
 gcc/fortran/target-memory.c  |  4 ++--
 gcc/fortran/trans-types.c    | 12 +++++-----
 gcc/gensupport.c             | 11 +++++-----
 gcc/lto-wrapper.c            | 14 ++++++------
 gcc/tree-if-conv.c           |  2 +-
 gcc/tree-ssa-loop-prefetch.c |  4 ++--
 gcc/tree-ssa-tail-merge.c    |  2 +-
 gcc/tree-vect-data-refs.c    |  2 +-
 gcc/tree-vect-loop.c         |  2 +-
 gcc/tree-vect-slp.c          |  2 +-
 gcc/tree-vect-stmts.c        |  2 +-
 gcc/tree-vrp.c               | 12 +++++-----
 gcc/tree.c                   |  2 +-
 libcpp/pch.c                 |  2 +-
 25 files changed, 103 insertions(+), 100 deletions(-)

diff --git a/gcc/auto-profile.c b/gcc/auto-profile.c
index ba2d5ab..55dd8d1 100644
--- a/gcc/auto-profile.c
+++ b/gcc/auto-profile.c
@@ -1143,28 +1143,28 @@ afdo_find_equiv_class (bb_set *annotated_bb)
     bb->aux = bb;
     dom_bbs = get_dominated_by (CDI_DOMINATORS, bb);
     FOR_EACH_VEC_ELT (dom_bbs, i, bb1)
-    if (bb1->aux == NULL && dominated_by_p (CDI_POST_DOMINATORS, bb, bb1)
-        && bb1->loop_father == bb->loop_father)
-      {
-        bb1->aux = bb;
-        if (bb1->count > bb->count && is_bb_annotated (bb1, *annotated_bb))
-          {
-            bb->count = bb1->count;
-            set_bb_annotated (bb, annotated_bb);
-          }
-      }
+      if (bb1->aux == NULL && dominated_by_p (CDI_POST_DOMINATORS, bb, bb1)
+	  && bb1->loop_father == bb->loop_father)
+	{
+	  bb1->aux = bb;
+	  if (bb1->count > bb->count && is_bb_annotated (bb1, *annotated_bb))
+	    {
+	      bb->count = bb1->count;
+	      set_bb_annotated (bb, annotated_bb);
+	    }
+	}
     dom_bbs = get_dominated_by (CDI_POST_DOMINATORS, bb);
     FOR_EACH_VEC_ELT (dom_bbs, i, bb1)
-    if (bb1->aux == NULL && dominated_by_p (CDI_DOMINATORS, bb, bb1)
-        && bb1->loop_father == bb->loop_father)
-      {
-        bb1->aux = bb;
-        if (bb1->count > bb->count && is_bb_annotated (bb1, *annotated_bb))
-          {
-            bb->count = bb1->count;
-            set_bb_annotated (bb, annotated_bb);
-          }
-      }
+      if (bb1->aux == NULL && dominated_by_p (CDI_DOMINATORS, bb, bb1)
+	  && bb1->loop_father == bb->loop_father)
+	{
+	  bb1->aux = bb;
+	  if (bb1->count > bb->count && is_bb_annotated (bb1, *annotated_bb))
+	    {
+	      bb->count = bb1->count;
+	      set_bb_annotated (bb, annotated_bb);
+	    }
+	}
   }
 }
 
@@ -1191,10 +1191,10 @@ afdo_propagate_edge (bool is_succ, bb_set *annotated_bb,
     gcov_type total_known_count = 0;
 
     FOR_EACH_EDGE (e, ei, is_succ ? bb->succs : bb->preds)
-    if (!is_edge_annotated (e, *annotated_edge))
-      num_unknown_edge++, unknown_edge = e;
-    else
-      total_known_count += e->count;
+      if (!is_edge_annotated (e, *annotated_edge))
+	num_unknown_edge++, unknown_edge = e;
+      else
+	total_known_count += e->count;
 
     if (num_unknown_edge == 0)
       {
@@ -1404,7 +1404,7 @@ afdo_calculate_branch_prob (bb_set *annotated_bb, edge_set *annotated_edge)
     edge_iterator ei;
 
     FOR_EACH_EDGE (e, ei, bb->succs)
-    e->count = (double)bb->count * e->probability / REG_BR_PROB_BASE;
+      e->count = (double)bb->count * e->probability / REG_BR_PROB_BASE;
     bb->aux = NULL;
   }
 
@@ -1502,7 +1502,7 @@ afdo_annotate_cfg (const stmt_set &promoted_stmts)
 
     bb->count = 0;
     FOR_EACH_EDGE (e, ei, bb->succs)
-    e->count = 0;
+      e->count = 0;
 
     if (afdo_set_bb_count (bb, promoted_stmts))
       set_bb_annotated (bb, &annotated_bb);
diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c
index cee152e..53a28e5 100644
--- a/gcc/cfgcleanup.c
+++ b/gcc/cfgcleanup.c
@@ -1032,7 +1032,7 @@ equal_different_set_p (rtx p1, rtx s1, rtx p2, rtx s2)
           ? rtx_renumbered_equal_p (e1, e2) : rtx_equal_p (e1, e2))
         continue;
 
-        return false;
+      return false;
     }
 
   return true;
@@ -2001,7 +2001,7 @@ try_crossjump_to_edge (int mode, edge e1, edge e2,
      If we have tablejumps in the end of SRC1 and SRC2
      they have been already compared for equivalence in outgoing_edges_match ()
      so replace the references to TABLE1 by references to TABLE2.  */
-    {
+  {
       rtx label1, label2;
       rtx_jump_table_data *table1, *table2;
 
@@ -2021,7 +2021,7 @@ try_crossjump_to_edge (int mode, edge e1, edge e2,
 		replace_label_in_insn (insn, label1, label2, true);
 	    }
 	}
-    }
+  }
 
   /* Avoid splitting if possible.  We must always split when SRC2 has
      EH predecessor edges, or we may end up with basic blocks with both
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 85531c8..7f83ccc 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -2955,11 +2955,11 @@ cgraph_node::verify_node (void)
 	  }
 	else
 	  ref_found = true;
-	if (!ref_found)
-	  {
-	    error ("Analyzed alias has no reference");
-	    error_found = true;
-	  }
+      if (!ref_found)
+	{
+	  error ("Analyzed alias has no reference");
+	  error_found = true;
+	}
     }
 
   /* Check instrumented version reference.  */
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 2315ba8..a3f73a5 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -2019,14 +2019,14 @@ expand_all_functions (void)
 
       if (node->process)
 	{
-     expanded_func_count++;
-     if(node->tp_first_run)
-       profiled_func_count++;
-
-    if (symtab->dump_file)
-	  fprintf (symtab->dump_file,
-		   "Time profile order in expand_all_functions:%s:%d\n",
-		   node->asm_name (), node->tp_first_run);
+	  expanded_func_count++;
+	  if(node->tp_first_run)
+	    profiled_func_count++;
+
+	  if (symtab->dump_file)
+	    fprintf (symtab->dump_file,
+		     "Time profile order in expand_all_functions:%s:%d\n",
+		     node->asm_name (), node->tp_first_run);
 	  node->process = 0;
 	  node->expand ();
 	}
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index 74332f3..0249e7f 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -19619,7 +19619,7 @@ ix86_expand_copysign (rtx operands[])
       else
 	copysign_insn = gen_copysigntf3_const;
 
-	emit_insn (copysign_insn (dest, op0, op1, mask));
+      emit_insn (copysign_insn (dest, op0, op1, mask));
     }
   else
     {
@@ -26128,7 +26128,7 @@ exact_dependency_1 (rtx addr, rtx insn)
 	  for (j = 0; j < XVECLEN (insn, i); j++)
 	    if (exact_dependency_1 (addr, XVECEXP (insn, i, j)))
 	      return true;
-	    break;
+	  break;
 	}
     }
   return false;
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 73f5da7..daa4360 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -16774,10 +16774,11 @@ cp_parser_asm_definition (cp_parser* parser)
 	      && cp_lexer_next_token_is_not (parser->lexer,
 					     CPP_CLOSE_PAREN)
 	      && !goto_p)
-	    outputs = cp_parser_asm_operand_list (parser);
-
-	    if (outputs == error_mark_node)
-	      invalid_outputs_p = true;
+            {
+              outputs = cp_parser_asm_operand_list (parser);
+              if (outputs == error_mark_node)
+                invalid_outputs_p = true;
+            }
 	}
       /* If the next token is `::', there are no outputs, and the
 	 next token is the beginning of the inputs.  */
@@ -16798,10 +16799,11 @@ cp_parser_asm_definition (cp_parser* parser)
 					     CPP_SCOPE)
 	      && cp_lexer_next_token_is_not (parser->lexer,
 					     CPP_CLOSE_PAREN))
-	    inputs = cp_parser_asm_operand_list (parser);
-
-	    if (inputs == error_mark_node)
-	      invalid_inputs_p = true;
+            {
+              inputs = cp_parser_asm_operand_list (parser);
+              if (inputs == error_mark_node)
+                invalid_inputs_p = true;
+            }
 	}
       else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
 	/* The clobbers are coming next.  */
diff --git a/gcc/dwarf2asm.c b/gcc/dwarf2asm.c
index b817aaf..ba1b543 100644
--- a/gcc/dwarf2asm.c
+++ b/gcc/dwarf2asm.c
@@ -931,9 +931,9 @@ dw2_output_indirect_constants (void)
        iter != indirect_pool->end (); ++iter)
     temp.quick_push (*iter);
 
-    temp.qsort (compare_strings);
+  temp.qsort (compare_strings);
 
-    for (unsigned int i = 0; i < temp.length (); i++)
+  for (unsigned int i = 0; i < temp.length (); i++)
     dw2_output_indirect_constant_1 (temp[i].first, temp[i].second);
 }
 
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index a04e6f6..06d18fe 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -16321,12 +16321,12 @@ tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
 	  && !TREE_STATIC (decl)))
     return false;
 
-    if (TREE_READONLY (decl)
-	&& ! TREE_THIS_VOLATILE (decl)
-	&& DECL_INITIAL (decl))
-      /* OK */;
-    else
-      return false;
+  if (TREE_READONLY (decl)
+      && ! TREE_THIS_VOLATILE (decl)
+      && DECL_INITIAL (decl))
+    /* OK */;
+  else
+    return false;
 
   /* Don't add DW_AT_const_value if abstract origin already has one.  */
   if (get_AT (var_die, DW_AT_const_value))
diff --git a/gcc/fortran/expr.c b/gcc/fortran/expr.c
index ab6f7a5..3673bfd 100644
--- a/gcc/fortran/expr.c
+++ b/gcc/fortran/expr.c
@@ -2297,8 +2297,8 @@ check_inquiry (gfc_expr *e, int not_restricted)
 	if (strcmp (functions[i], name) == 0)
 	  break;
 
-	if (functions[i] == NULL)
-	  return MATCH_ERROR;
+      if (functions[i] == NULL)
+	return MATCH_ERROR;
     }
 
   /* At this point we have an inquiry function with a variable argument.  The
diff --git a/gcc/fortran/interface.c b/gcc/fortran/interface.c
index 320eb01..0d29bde 100644
--- a/gcc/fortran/interface.c
+++ b/gcc/fortran/interface.c
@@ -2169,7 +2169,7 @@ compare_parameter (gfc_symbol *formal, gfc_expr *actual,
 	    gfc_error ("Passing coarray at %L to allocatable, noncoarray, "
 		       "INTENT(OUT) dummy argument %qs", &actual->where,
 		       formal->name);
-	    return 0;
+	  return 0;
 	}
       else if (warn_surprising && where && formal->attr.intent != INTENT_IN)
 	gfc_warning (OPT_Wsurprising,
diff --git a/gcc/fortran/parse.c b/gcc/fortran/parse.c
index 2c7c554..30e4eab 100644
--- a/gcc/fortran/parse.c
+++ b/gcc/fortran/parse.c
@@ -4283,7 +4283,7 @@ parse_oacc_structured_block (gfc_statement acc_st)
 	unexpected_eof ();
       else if (st != acc_end_st)
 	gfc_error ("Expecting %s at %C", gfc_ascii_statement (acc_end_st));
-	reject_statement ();
+      reject_statement ();
     }
   while (st != acc_end_st);
 
diff --git a/gcc/fortran/target-memory.c b/gcc/fortran/target-memory.c
index 4d63636..187682a 100644
--- a/gcc/fortran/target-memory.c
+++ b/gcc/fortran/target-memory.c
@@ -671,8 +671,8 @@ expr_to_char (gfc_expr *e, unsigned char *data, unsigned char *chk, size_t len)
 	  gcc_assert (cmp && cmp->backend_decl);
 	  if (!c->expr)
 	    continue;
-	    ptr = TREE_INT_CST_LOW(DECL_FIELD_OFFSET(cmp->backend_decl))
-			+ TREE_INT_CST_LOW(DECL_FIELD_BIT_OFFSET(cmp->backend_decl))/8;
+	  ptr = TREE_INT_CST_LOW(DECL_FIELD_OFFSET(cmp->backend_decl))
+	    + TREE_INT_CST_LOW(DECL_FIELD_BIT_OFFSET(cmp->backend_decl))/8;
 	  expr_to_char (c->expr, &data[ptr], &chk[ptr], len);
 	}
       return len;
diff --git a/gcc/fortran/trans-types.c b/gcc/fortran/trans-types.c
index 0ad8ac2..41ffbaa 100644
--- a/gcc/fortran/trans-types.c
+++ b/gcc/fortran/trans-types.c
@@ -438,10 +438,10 @@ gfc_init_kinds (void)
       /* Only let float, double, long double and __float128 go through.
 	 Runtime support for others is not provided, so they would be
 	 useless.  */
-	if (!targetm.libgcc_floating_mode_supported_p ((machine_mode)
+      if (!targetm.libgcc_floating_mode_supported_p ((machine_mode)
 						       mode))
-	  continue;
-	if (mode != TYPE_MODE (float_type_node)
+	continue;
+      if (mode != TYPE_MODE (float_type_node)
 	    && (mode != TYPE_MODE (double_type_node))
 	    && (mode != TYPE_MODE (long_double_type_node))
 #if defined(HAVE_TFmode) && defined(ENABLE_LIBQUADMATH_SUPPORT)
@@ -587,7 +587,7 @@ gfc_init_kinds (void)
 	gfc_fatal_error ("REAL(KIND=4) is not available for "
 			 "%<-freal-8-real-4%> option");
 
-	gfc_default_double_kind = 4;
+      gfc_default_double_kind = 4;
     }
   else if (flag_real8_kind == 10 )
     {
@@ -595,7 +595,7 @@ gfc_init_kinds (void)
 	gfc_fatal_error ("REAL(KIND=10) is not available for "
 			 "%<-freal-8-real-10%> option");
 
-	gfc_default_double_kind = 10;
+      gfc_default_double_kind = 10;
     }
   else if (flag_real8_kind == 16 )
     {
@@ -603,7 +603,7 @@ gfc_init_kinds (void)
 	gfc_fatal_error ("REAL(KIND=10) is not available for "
 			 "%<-freal-8-real-16%> option");
 
-	gfc_default_double_kind = 16;
+      gfc_default_double_kind = 16;
     }
   else if (saw_r4 && saw_r8)
     gfc_default_double_kind = 8;
diff --git a/gcc/gensupport.c b/gcc/gensupport.c
index 26a09bc..7d025b6 100644
--- a/gcc/gensupport.c
+++ b/gcc/gensupport.c
@@ -2227,11 +2227,12 @@ process_define_subst (void)
 	if (strcmp (XSTR (elem->data, 0), XSTR (elem_attr->data, 1)) == 0)
 	    goto found;
 
-	error_with_line (elem->lineno,
-			 "%s: `define_subst' must have at least one "
-			 "corresponding `define_subst_attr'",
-			 XSTR (elem->data, 0));
-	return;
+      error_with_line (elem->lineno,
+		       "%s: `define_subst' must have at least one "
+		       "corresponding `define_subst_attr'",
+		       XSTR (elem->data, 0));
+      return;
+
       found:
 	continue;
     }
diff --git a/gcc/lto-wrapper.c b/gcc/lto-wrapper.c
index 404cb68..123ffc1 100644
--- a/gcc/lto-wrapper.c
+++ b/gcc/lto-wrapper.c
@@ -303,13 +303,13 @@ merge_and_complain (struct cl_decoded_option **decoded_options,
 	  for (j = 0; j < *decoded_options_count; ++j)
 	    if ((*decoded_options)[j].opt_index == foption->opt_index)
 	      break;
-	    if (j == *decoded_options_count)
-	      append_option (decoded_options, decoded_options_count, foption);
-	    else if (foption->value != (*decoded_options)[j].value)
-	      fatal_error (input_location,
-			   "Option %s not used consistently in all LTO input"
-			   " files", foption->orig_option_with_args_text);
-	    break;
+	  if (j == *decoded_options_count)
+	    append_option (decoded_options, decoded_options_count, foption);
+	  else if (foption->value != (*decoded_options)[j].value)
+	    fatal_error (input_location,
+			 "Option %s not used consistently in all LTO input"
+			 " files", foption->orig_option_with_args_text);
+	  break;
 
 	case OPT_O:
 	case OPT_Ofast:
diff --git a/gcc/tree-if-conv.c b/gcc/tree-if-conv.c
index 400ee01..49ff458 100644
--- a/gcc/tree-if-conv.c
+++ b/gcc/tree-if-conv.c
@@ -1087,7 +1087,7 @@ if_convertible_bb_p (struct loop *loop, basic_block bb, basic_block exit_bb)
     {
       if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "only critical predecessors\n");
-	return false;
+      return false;
     }
 
   return true;
diff --git a/gcc/tree-ssa-loop-prefetch.c b/gcc/tree-ssa-loop-prefetch.c
index 10e156e..a948d68 100644
--- a/gcc/tree-ssa-loop-prefetch.c
+++ b/gcc/tree-ssa-loop-prefetch.c
@@ -368,8 +368,8 @@ find_or_create_group (struct mem_ref_group **groups, tree base, tree step)
 
       /* If step is an integer constant, keep the list of groups sorted
          by decreasing step.  */
-        if (cst_and_fits_in_hwi ((*groups)->step) && cst_and_fits_in_hwi (step)
-            && int_cst_value ((*groups)->step) < int_cst_value (step))
+      if (cst_and_fits_in_hwi ((*groups)->step) && cst_and_fits_in_hwi (step)
+	  && int_cst_value ((*groups)->step) < int_cst_value (step))
 	break;
     }
 
diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c
index 4afe94e..ee6e7b2 100644
--- a/gcc/tree-ssa-tail-merge.c
+++ b/gcc/tree-ssa-tail-merge.c
@@ -379,7 +379,7 @@ gsi_advance_fw_nondebug_nonlocal (gimple_stmt_iterator *gsi)
       stmt = gsi_stmt (*gsi);
       if (!stmt_local_def (stmt))
 	return;
-	gsi_next_nondebug (gsi);
+      gsi_next_nondebug (gsi);
     }
 }
 
diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c
index 3913862..2abea1a 100644
--- a/gcc/tree-vect-data-refs.c
+++ b/gcc/tree-vect-data-refs.c
@@ -5019,7 +5019,7 @@ vect_grouped_load_supported (tree vectype, unsigned HOST_WIDE_INT count)
 		    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
 				     "shuffle of 3 loads is not supported by"
 				     " target\n");
-		    return false;
+		  return false;
 		}
 	      for (i = 0, j = 0; i < nelt; i++)
 		if (3 * i + k < 2 * nelt)
diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c
index 88ef251..49bf518 100644
--- a/gcc/tree-vect-loop.c
+++ b/gcc/tree-vect-loop.c
@@ -5057,7 +5057,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
 	    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
 			     "unsupported condition in reduction\n");
 
-            return false;
+	  return false;
         }
     }
   else
diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c
index 73ab24e..a2ab398 100644
--- a/gcc/tree-vect-slp.c
+++ b/gcc/tree-vect-slp.c
@@ -3107,7 +3107,7 @@ vect_transform_slp_perm_load (slp_tree node, vec<tree> dr_chain,
      we need the second and the third vectors: {b1,c1,a2,b2} and
      {c2,a3,b3,c3}.  */
 
-    {
+  {
       scalar_index = 0;
       index = 0;
       vect_stmts_counter = 0;
diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c
index de35508..a20fcc6 100644
--- a/gcc/tree-vect-stmts.c
+++ b/gcc/tree-vect-stmts.c
@@ -4445,7 +4445,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_iterator *gsi,
                         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                          "unusable type for last operand in"
                                          " vector/vector shift/rotate.\n");
-			return false;
+		      return false;
 		    }
 		  if (vec_stmt && !slp_node)
 		    {
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index e7ab23c..c7d243c 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -10258,12 +10258,12 @@ vrp_finalize (void)
 	  || (vr_value[i]->type == VR_UNDEFINED))
 	continue;
 
-	if ((TREE_CODE (vr_value[i]->min) == INTEGER_CST)
-	    && (TREE_CODE (vr_value[i]->max) == INTEGER_CST)
-	    && (vr_value[i]->type == VR_RANGE
-		|| vr_value[i]->type == VR_ANTI_RANGE))
-	  set_range_info (name, vr_value[i]->type, vr_value[i]->min,
-			  vr_value[i]->max);
+      if ((TREE_CODE (vr_value[i]->min) == INTEGER_CST)
+	  && (TREE_CODE (vr_value[i]->max) == INTEGER_CST)
+	  && (vr_value[i]->type == VR_RANGE
+	      || vr_value[i]->type == VR_ANTI_RANGE))
+	set_range_info (name, vr_value[i]->type, vr_value[i]->min,
+			vr_value[i]->max);
       }
 
   /* Free allocated memory.  */
diff --git a/gcc/tree.c b/gcc/tree.c
index 01860af..114d5b3 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -8927,7 +8927,7 @@ variably_modified_type_p (tree type, tree fn)
 	    if (TREE_CODE (type) == QUAL_UNION_TYPE)
 	      RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
 	  }
-	break;
+      break;
 
     case ARRAY_TYPE:
       /* Do not call ourselves to avoid infinite recursion.  This is
diff --git a/libcpp/pch.c b/libcpp/pch.c
index eb2d30b..ed59565 100644
--- a/libcpp/pch.c
+++ b/libcpp/pch.c
@@ -713,7 +713,7 @@ cpp_valid_state (cpp_reader *r, const char *name, int fd)
 	cpp_warning_syshdr (r, CPP_W_INVALID_PCH,
 		            "%s: not used because `__COUNTER__' is invalid",
 		            name);
-	goto fail;
+      goto fail;
     }
 
   /* We win!  */
-- 
1.8.5.3


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]