CbC/CbC_gcc: gcc/cfgexpand.c comparison

comparison gcc/cfgexpand.c @ 70:b81903832de2

merge c-decl.c

author	Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Sun, 21 Aug 2011 09:24:16 +0900
parents	1b10fe6932e1
children	ce75bd9117e4

comparison

equal deleted inserted replaced

-:1b10fe6932e1
+:b81903832de2
 #include "debug.h"
 #include "params.h"
 #include "tree-inline.h"
 #include "value-prof.h"
 #include "target.h"
-#ifndef noCbC
-#include "cbc-tree.h"
-#endif
 #include "ssaexpand.h"
 #include "bitmap.h"
 #include "sbitmap.h"
 #include "insn-attr.h" /* For INSN_SCHEDULING.  */
 		gimple_assign_rhs1 (stmt),
 		gimple_assign_rhs2 (stmt),
 		gimple_assign_rhs3 (stmt));
 else if (grhs_class == GIMPLE_BINARY_RHS)
 t = build2 (gimple_assign_rhs_code (stmt),
-TREE_TYPE (gimple_assign_lhs (stmt)),
+		TREE_TYPE (gimple_assign_lhs (stmt)),
-gimple_assign_rhs1 (stmt),
+		gimple_assign_rhs1 (stmt),
-gimple_assign_rhs2 (stmt));
+		gimple_assign_rhs2 (stmt));
 else if (grhs_class == GIMPLE_UNARY_RHS)
 t = build1 (gimple_assign_rhs_code (stmt),
-TREE_TYPE (gimple_assign_lhs (stmt)),
+		TREE_TYPE (gimple_assign_lhs (stmt)),
-gimple_assign_rhs1 (stmt));
+		gimple_assign_rhs1 (stmt));
 else if (grhs_class == GIMPLE_SINGLE_RHS)
 {
 t = gimple_assign_rhs1 (stmt);
 /* Avoid modifying this tree in place below.  */
 if ((gimple_has_location (stmt) && CAN_HAVE_LOCATION_P (t)
 {
 if (TREE_CODE (t) == SSA_NAME)
 {
 SA.partition_to_pseudo[var_to_partition (SA.map, t)] = x;
 if (x && !MEM_P (x))
-set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (t), x);
+	set_reg_attrs_for_decl_rtl (SSA_NAME_VAR (t), x);
 /* For the benefit of debug information at -O0 (where vartracking
 doesn't run) record the place also in the base DECL if it's
-a normal variable (not a parameter).  */
+	 a normal variable (not a parameter).  */
 if (x && x != pc_rtx && TREE_CODE (SSA_NAME_VAR (t)) == VAR_DECL)
-{
+	{
-tree var = SSA_NAME_VAR (t);
+	  tree var = SSA_NAME_VAR (t);
-/* If we don't yet have something recorded, just record it now.  */
+	  /* If we don't yet have something recorded, just record it now.  */
-if (!DECL_RTL_SET_P (var))
+	  if (!DECL_RTL_SET_P (var))
-SET_DECL_RTL (var, x);
+	    SET_DECL_RTL (var, x);
-/* If we have it set alrady to "multiple places" don't
+	  /* If we have it set alrady to "multiple places" don't
-change this.  */
+	     change this.  */
-else if (DECL_RTL (var) == pc_rtx)
+	  else if (DECL_RTL (var) == pc_rtx)
-;
+	    ;
-/* If we have something recorded and it's not the same place
+	  /* If we have something recorded and it's not the same place
-as we want to record now, we have multiple partitions for the
+	     as we want to record now, we have multiple partitions for the
-same base variable, with different places.  We can't just
+	     same base variable, with different places.  We can't just
-randomly chose one, hence we have to say that we don't know.
+	     randomly chose one, hence we have to say that we don't know.
-This only happens with optimization, and there var-tracking
+	     This only happens with optimization, and there var-tracking
-will figure out the right thing.  */
+	     will figure out the right thing.  */
-else if (DECL_RTL (var) != x)
+	  else if (DECL_RTL (var) != x)
-SET_DECL_RTL (var, pc_rtx);
+	    SET_DECL_RTL (var, pc_rtx);
-}
+	}
 }
 else
 SET_DECL_RTL (t, x);
 }
 struct stack_var *v;
 if (stack_vars_num >= stack_vars_alloc)
 {
 if (stack_vars_alloc)
-stack_vars_alloc = stack_vars_alloc * 3 / 2;
+	stack_vars_alloc = stack_vars_alloc * 3 / 2;
 else
-stack_vars_alloc = 32;
+	stack_vars_alloc = 32;
 stack_vars
-= XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
+	= XRESIZEVEC (struct stack_var, stack_vars, stack_vars_alloc);
 }
 v = &stack_vars[stack_vars_num];
 v->decl = decl;
 v->offset = 0;
 return false;
 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
 if (TREE_CODE (field) == FIELD_DECL)
 if (aggregate_contains_union_type (TREE_TYPE (field)))
-return true;
+	return true;
 return false;
 }
 /* A subroutine of expand_used_vars.  If two variables X and Y have alias
 bool aggr_i = AGGREGATE_TYPE_P (type_i);
 bool contains_union;
 contains_union = aggregate_contains_union_type (type_i);
 for (j = 0; j < i; ++j)
-{
+	{
-tree type_j = TREE_TYPE (stack_vars[j].decl);
+	  tree type_j = TREE_TYPE (stack_vars[j].decl);
-bool aggr_j = AGGREGATE_TYPE_P (type_j);
+	  bool aggr_j = AGGREGATE_TYPE_P (type_j);
-if (aggr_i != aggr_j
+	  if (aggr_i != aggr_j
-/* Either the objects conflict by means of type based
+	      /* Either the objects conflict by means of type based
-aliasing rules, or we need to add a conflict.  */
+		 aliasing rules, or we need to add a conflict.  */
-|| !objects_must_conflict_p (type_i, type_j)
+	      || !objects_must_conflict_p (type_i, type_j)
-/* In case the types do not conflict ensure that access
+	      /* In case the types do not conflict ensure that access
-to elements will conflict.  In case of unions we have
+		 to elements will conflict.  In case of unions we have
-to be careful as type based aliasing rules may say
+		 to be careful as type based aliasing rules may say
-access to the same memory does not conflict.  So play
+		 access to the same memory does not conflict.  So play
-safe and add a conflict in this case.  */
+		 safe and add a conflict in this case.  */
-|| contains_union)
+	      || contains_union)
-add_stack_var_conflict (i, j);
+	    add_stack_var_conflict (i, j);
-}
+	}
 }
 }
 /* A subroutine of partition_stack_vars.  A comparison function for qsort,
 sorting an array of indices by the properties of the object.  */
 Two SSA names are compared by their version, SSA names come before
 non-SSA names, and two normal decls are compared by their DECL_UID.  */
 if (TREE_CODE (decla) == SSA_NAME)
 {
 if (TREE_CODE (declb) == SSA_NAME)
-uida = SSA_NAME_VERSION (decla), uidb = SSA_NAME_VERSION (declb);
+	uida = SSA_NAME_VERSION (decla), uidb = SSA_NAME_VERSION (declb);
 else
-return -1;
+	return -1;
 }
 else if (TREE_CODE (declb) == SSA_NAME)
 return 1;
 else
 uida = DECL_UID (decla), uidb = DECL_UID (declb);
 together with other variables add all partition members to the pointed-to
 variables bitmap.  */
 static void
 add_partitioned_vars_to_ptset (struct pt_solution *pt,
-struct pointer_map_t *decls_to_partitions,
+			       struct pointer_map_t *decls_to_partitions,
-struct pointer_set_t *visited, bitmap temp)
+			       struct pointer_set_t *visited, bitmap temp)
 {
 bitmap_iterator bi;
 unsigned i;
 bitmap *part;
 if (pt->anything
 || pt->vars == NULL
 /* The pointed-to vars bitmap is shared, it is enough to
-visit it once.  */
+	 visit it once.  */
 || pointer_set_insert(visited, pt->vars))
 return;
 bitmap_clear (temp);
 /* By using a temporary bitmap to store all members of the partitions
 we have to add we make sure to visit each of the partitions only
 once.  */
 EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi)
 if ((!temp
-|| !bitmap_bit_p (temp, i))
+	 || !bitmap_bit_p (temp, i))
-&& (part = (bitmap *) pointer_map_contains (decls_to_partitions,
+	&& (part = (bitmap *) pointer_map_contains (decls_to_partitions,
-(void *)(size_t) i)))
+						    (void *)(size_t) i)))
 bitmap_ior_into (temp, *part);
 if (!bitmap_empty_p (temp))
 bitmap_ior_into (pt->vars, temp);
 }
 if (stack_vars[i].representative != i
 || stack_vars[i].next == EOC)
 continue;
 if (!decls_to_partitions)
-{
+	{
-decls_to_partitions = pointer_map_create ();
+	  decls_to_partitions = pointer_map_create ();
-cfun->gimple_df->decls_to_pointers = pointer_map_create ();
+	  cfun->gimple_df->decls_to_pointers = pointer_map_create ();
-}
+	}
 /* Create an SSA_NAME that points to the partition for use
 as base during alias-oracle queries on RTL for bases that
-have been partitioned.  */
+	 have been partitioned.  */
 if (var == NULL_TREE)
-var = create_tmp_var (ptr_type_node, NULL);
+	var = create_tmp_var (ptr_type_node, NULL);
 name = make_ssa_name (var, NULL);
 /* Create bitmaps representing partitions.  They will be used for
 points-to sets later, so use GGC alloc.  */
 part = BITMAP_GGC_ALLOC ();
 unsigned i;
 struct pointer_set_t *visited = pointer_set_create ();
 bitmap temp = BITMAP_ALLOC (NULL);
 for (i = 1; i < num_ssa_names; i++)
-{
+	{
-tree name = ssa_name (i);
+	  tree name = ssa_name (i);
-struct ptr_info_def *pi;
+	  struct ptr_info_def *pi;
-if (name
+	  if (name
-&& POINTER_TYPE_P (TREE_TYPE (name))
+	      && POINTER_TYPE_P (TREE_TYPE (name))
-&& ((pi = SSA_NAME_PTR_INFO (name)) != NULL))
+	      && ((pi = SSA_NAME_PTR_INFO (name)) != NULL))
-add_partitioned_vars_to_ptset (&pi->pt, decls_to_partitions,
+	    add_partitioned_vars_to_ptset (&pi->pt, decls_to_partitions,
-visited, temp);
+					   visited, temp);
-}
+	}
 add_partitioned_vars_to_ptset (&cfun->gimple_df->escaped,
 				     decls_to_partitions, visited, temp);
 pointer_set_destroy (visited);
 /* Update the interference graph and merge the conflicts.  */
 if (vb->conflicts)
 {
 EXECUTE_IF_SET_IN_BITMAP (vb->conflicts, 0, u, bi)
-add_stack_var_conflict (a, stack_vars[u].representative);
+	add_stack_var_conflict (a, stack_vars[u].representative);
 BITMAP_FREE (vb->conflicts);
 }
 }
 /* A subroutine of expand_used_vars.  Binpack the variables into
 partitions constrained by the interference graph.  The overall
 algorithm used is as follows:
-Sort the objects by size.
+	Sort the objects by size.
-For each object A {
+	For each object A {
-S = size(A)
+	  S = size(A)
-O = 0
+	  O = 0
-loop {
+	  loop {
-Look for the largest non-conflicting object B with size <= S.
+	    Look for the largest non-conflicting object B with size <= S.
-UNION (A, B)
+	    UNION (A, B)
-offset(B) = O
+	    offset(B) = O
-O += size(B)
+	    O += size(B)
-S -= size(B)
+	    S -= size(B)
-}
+	  }
-}
+	}
 */
 static void
 partition_stack_vars (void)
 {
 {
 i = stack_vars_sorted[si];
 /* Skip variables that aren't partition representatives, for now.  */
 if (stack_vars[i].representative != i)
-continue;
+	continue;
 fprintf (dump_file, "Partition %lu: size " HOST_WIDE_INT_PRINT_DEC
-" align %u\n", (unsigned long) i, stack_vars[i].size,
+	       " align %u\n", (unsigned long) i, stack_vars[i].size,
-stack_vars[i].alignb);
+	       stack_vars[i].alignb);
 for (j = i; j != EOC; j = stack_vars[j].next)
-{
+	{
-fputc ('\t', dump_file);
+	  fputc ('\t', dump_file);
-print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
+	  print_generic_expr (dump_file, stack_vars[j].decl, dump_flags);
-fprintf (dump_file, ", offset " HOST_WIDE_INT_PRINT_DEC "\n",
+	  fprintf (dump_file, ", offset " HOST_WIDE_INT_PRINT_DEC "\n",
-stack_vars[j].offset);
+		   stack_vars[j].offset);
-}
+	}
 }
 }
 /* Assign rtl to DECL at BASE + OFFSET.  */
 i = stack_vars_sorted[si];
 /* Skip variables that aren't partition representatives, for now.  */
 if (stack_vars[i].representative != i)
-continue;
+	continue;
 /* Skip variables that have already had rtl assigned.  See also
 	 add_stack_var where we perpetrate this pc_rtx hack.  */
 decl = stack_vars[i].decl;
 if ((TREE_CODE (decl) == SSA_NAME
 	  base = large_base;
 	  base_align = large_align;
 	}
 /* Create rtl for each variable based on their location within the
-partition.  */
+	 partition.  */
 for (j = i; j != EOC; j = stack_vars[j].next)
 	{
 	  gcc_assert (stack_vars[j].offset <= stack_vars[i].size);
 	  expand_one_stack_var_at (stack_vars[j].decl,
 				   base, base_align,
 {
 i = stack_vars_sorted[si];
 /* Skip variables that aren't partition representatives, for now.  */
 if (stack_vars[i].representative != i)
-continue;
+	continue;
 size += stack_vars[i].size;
 for (j = i; j != EOC; j = stack_vars[j].next)
-set_rtl (stack_vars[j].decl, NULL);
+	set_rtl (stack_vars[j].decl, NULL);
 }
 return size;
 }
 /* A subroutine of expand_one_var.  Called to immediately assign rtl
 var = SSAVAR (var);
 if (TREE_TYPE (var) != error_mark_node && TREE_CODE (var) == VAR_DECL)
 {
 /* Because we don't know if VAR will be in register or on stack,
-we conservatively assume it will be on stack even if VAR is
+	 we conservatively assume it will be on stack even if VAR is
-eventually put into register after RA pass.  For non-automatic
+	 eventually put into register after RA pass.  For non-automatic
-variables, which won't be on stack, we collect alignment of
+	 variables, which won't be on stack, we collect alignment of
-type and ignore user specified alignment.  */
+	 type and ignore user specified alignment.  */
 if (TREE_STATIC (var) || DECL_EXTERNAL (var))
 	align = MINIMUM_ALIGNMENT (TREE_TYPE (var),
 				   TYPE_MODE (TREE_TYPE (var)),
 				   TYPE_ALIGN (TREE_TYPE (var)));
 else if (DECL_HAS_VALUE_EXPR_P (var)
 	   or variables which were assigned a stack slot already by
 	   expand_one_stack_var_at - in the latter case DECL_ALIGN has been
 	   changed from the offset chosen to it.  */
 	align = crtl->stack_alignment_estimated;
 else
-align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var));
+	align = MINIMUM_ALIGNMENT (var, DECL_MODE (var), DECL_ALIGN (var));
 /* If the variable alignment is very large we'll dynamicaly allocate
 	 it, which means that in-frame portion is just a pointer.  */
 if (align > MAX_SUPPORTED_STACK_ALIGNMENT)
 	align = POINTER_SIZE;
 crtl->max_used_stack_slot_alignment = align;
 if (TREE_CODE (origvar) == SSA_NAME)
 {
 gcc_assert (TREE_CODE (var) != VAR_DECL
-|| (!DECL_EXTERNAL (var)
+		  || (!DECL_EXTERNAL (var)
-&& !DECL_HAS_VALUE_EXPR_P (var)
+		      && !DECL_HAS_VALUE_EXPR_P (var)
-&& !TREE_STATIC (var)
+		      && !TREE_STATIC (var)
-&& TREE_TYPE (var) != error_mark_node
+		      && TREE_TYPE (var) != error_mark_node
-&& !DECL_HARD_REGISTER (var)
+		      && !DECL_HARD_REGISTER (var)
-&& really_expand));
+		      && really_expand));
 }
 if (TREE_CODE (var) != VAR_DECL && TREE_CODE (origvar) != SSA_NAME)
 ;
 else if (DECL_EXTERNAL (var))
 ;
 if (old_sv_num < this_sv_num)
 {
 new_sv_num = stack_vars_num;
 for (i = old_sv_num; i < new_sv_num; ++i)
-for (j = i < this_sv_num ? i : this_sv_num; j-- > old_sv_num ;)
+	for (j = i < this_sv_num ? i : this_sv_num; j-- > old_sv_num ;)
-add_stack_var_conflict (i, j);
+	  add_stack_var_conflict (i, j);
 }
 }
 /* A subroutine of expand_used_vars.  Walk down through the BLOCK tree
 and clear TREE_USED on all local variables.  */
 clear_tree_used (t);
 }
 /* Examine TYPE and determine a bit mask of the following features.  */
-#define SPCT_HAS_LARGE_CHAR_ARRAY   1
+#define SPCT_HAS_LARGE_CHAR_ARRAY	1
-#define SPCT_HAS_SMALL_CHAR_ARRAY   2
+#define SPCT_HAS_SMALL_CHAR_ARRAY	2
-#define SPCT_HAS_ARRAY          4
+#define SPCT_HAS_ARRAY			4
-#define SPCT_HAS_AGGREGATE      8
+#define SPCT_HAS_AGGREGATE		8
 static unsigned int
 stack_protect_classify_type (tree type)
 {
 unsigned int ret = 0;
 switch (TREE_CODE (type))
 {
 case ARRAY_TYPE:
 t = TYPE_MAIN_VARIANT (TREE_TYPE (type));
 if (t == char_type_node
-|| t == signed_char_type_node
+	  || t == signed_char_type_node
-|| t == unsigned_char_type_node)
+	  || t == unsigned_char_type_node)
-{
+	{
-unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
+	  unsigned HOST_WIDE_INT max = PARAM_VALUE (PARAM_SSP_BUFFER_SIZE);
-unsigned HOST_WIDE_INT len;
+	  unsigned HOST_WIDE_INT len;
-if (!TYPE_SIZE_UNIT (type)
+	  if (!TYPE_SIZE_UNIT (type)
-|| !host_integerp (TYPE_SIZE_UNIT (type), 1))
+	      || !host_integerp (TYPE_SIZE_UNIT (type), 1))
-len = max;
+	    len = max;
+	  else
+	    len = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
+	  if (len < max)
+	    ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
+	  else
+	    ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
+	}
 else
-len = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
+	ret = SPCT_HAS_ARRAY;
-if (len < max)
-ret = SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_ARRAY;
-else
-ret = SPCT_HAS_LARGE_CHAR_ARRAY | SPCT_HAS_ARRAY;
-}
-else
-ret = SPCT_HAS_ARRAY;
 break;
 case UNION_TYPE:
 case QUAL_UNION_TYPE:
 case RECORD_TYPE:
 ret = SPCT_HAS_AGGREGATE;
 for (t = TYPE_FIELDS (type); t ; t = TREE_CHAIN (t))
-if (TREE_CODE (t) == FIELD_DECL)
+	if (TREE_CODE (t) == FIELD_DECL)
-ret |= stack_protect_classify_type (TREE_TYPE (t));
+	  ret |= stack_protect_classify_type (TREE_TYPE (t));
 break;
 default:
 break;
 }
 has_short_buffer = true;
 if (flag_stack_protect == 2)
 {
 if ((bits & (SPCT_HAS_SMALL_CHAR_ARRAY | SPCT_HAS_LARGE_CHAR_ARRAY))
-&& !(bits & SPCT_HAS_AGGREGATE))
+	  && !(bits & SPCT_HAS_AGGREGATE))
-ret = 1;
+	ret = 1;
 else if (bits & SPCT_HAS_ARRAY)
-ret = 2;
+	ret = 2;
 }
 else
 ret = (bits & SPCT_HAS_LARGE_CHAR_ARRAY) != 0;
 if (ret)
 for (i = 0; i < n; ++i)
 {
 unsigned char ph_i = phase[i];
 for (j = 0; j < i; ++j)
-if (ph_i != phase[j])
+	if (ph_i != phase[j])
-add_stack_var_conflict (i, j);
+	  add_stack_var_conflict (i, j);
 }
 XDELETEVEC (phase);
 }
 static void
 create_stack_guard (void)
 {
 tree guard = build_decl (DECL_SOURCE_LOCATION (current_function_decl),
-VAR_DECL, NULL, ptr_type_node);
+			   VAR_DECL, NULL, ptr_type_node);
 TREE_THIS_VOLATILE (guard) = 1;
 TREE_USED (guard) = 1;
 expand_one_stack_var (guard);
 crtl->stack_protect_guard = guard;
 }
 if (stack_vars_num > 0)
 {
 /* Fake sorting the stack vars for account_stack_vars ().  */
 stack_vars_sorted = XNEWVEC (size_t, stack_vars_num);
 for (i = 0; i < stack_vars_num; ++i)
-stack_vars_sorted[i] = i;
+	stack_vars_sorted[i] = i;
 size += account_stack_vars ();
 fini_vars_expansion ();
 }
 pop_cfun ();
 current_function_decl = old_cur_fun_decl;
 {
 tree var = partition_to_var (SA.map, i);
 gcc_assert (is_gimple_reg (var));
 if (TREE_CODE (SSA_NAME_VAR (var)) == VAR_DECL)
-expand_one_var (var, true, true);
+	expand_one_var (var, true, true);
 else
-{
+	{
-/* This is a PARM_DECL or RESULT_DECL.  For those partitions that
+	  /* This is a PARM_DECL or RESULT_DECL.  For those partitions that
-contain the default def (representing the parm or result itself)
+	     contain the default def (representing the parm or result itself)
-we don't do anything here.  But those which don't contain the
+	     we don't do anything here.  But those which don't contain the
-default def (representing a temporary based on the parm/result)
+	     default def (representing a temporary based on the parm/result)
-we need to allocate space just like for normal VAR_DECLs.  */
+	     we need to allocate space just like for normal VAR_DECLs.  */
-if (!bitmap_bit_p (SA.partition_has_default_def, i))
+	  if (!bitmap_bit_p (SA.partition_has_default_def, i))
-{
+	    {
-expand_one_var (var, true, true);
+	      expand_one_var (var, true, true);
-gcc_assert (SA.partition_to_pseudo[i]);
+	      gcc_assert (SA.partition_to_pseudo[i]);
-}
+	    }
-}
+	}
 }
 /* At this point all variables on the local_decls with TREE_USED
 set are not associated with any block scope.  Lay them out.  */
 	{
 	  TREE_USED (var) = 0;
 	  goto next;
 	}
 /* We didn't set a block for static or extern because it's hard
-to tell the difference between a global variable (re)declared
+	 to tell the difference between a global variable (re)declared
-in a local scope, and one that's really declared there to
+	 in a local scope, and one that's really declared there to
-begin with.  And it doesn't really matter much, since we're
+	 begin with.  And it doesn't really matter much, since we're
-not giving them stack space.  Expand them now.  */
+	 not giving them stack space.  Expand them now.  */
 else if (TREE_STATIC (var) || DECL_EXTERNAL (var))
-expand_now = true;
+	expand_now = true;
 /* If the variable is not associated with any block, then it
-was created by the optimizers, and could be live anywhere
+	 was created by the optimizers, and could be live anywhere
-in the function.  */
+	 in the function.  */
 else if (TREE_USED (var))
-expand_now = true;
+	expand_now = true;
 /* Finally, mark all variables on the list as used.  We'll use
-this in a moment when we expand those associated with scopes.  */
+	 this in a moment when we expand those associated with scopes.  */
 TREE_USED (var) = 1;
 if (expand_now)
 	expand_one_var (var, true, true);
 expand_used_vars_for_block (outer_block, true);
 if (stack_vars_num > 0)
 {
 /* Due to the way alias sets work, no variables with non-conflicting
-alias sets may be assigned the same address.  Add conflicts to
+	 alias sets may be assigned the same address.  Add conflicts to
-reflect this.  */
+	 reflect this.  */
 add_alias_set_conflicts ();
 /* If stack protection is enabled, we don't share space between
-vulnerable data and non-vulnerable data.  */
+	 vulnerable data and non-vulnerable data.  */
 if (flag_stack_protect)
-add_stack_protection_conflicts ();
+	add_stack_protection_conflicts ();
 /* Now that we have collected all stack variables, and have computed a
-minimal interference graph, attempt to save some stack space.  */
+	 minimal interference graph, attempt to save some stack space.  */
 partition_stack_vars ();
 if (dump_file)
-dump_stack_var_partition ();
+	dump_stack_var_partition ();
 }
 /* There are several conditions under which we should create a
 stack guard: protect-all, alloca used, protected decls present.  */
 if (flag_stack_protect == 2
 || (flag_stack_protect
-&& (cfun->calls_alloca || has_protected_decls)))
+	  && (cfun->calls_alloca || has_protected_decls)))
 create_stack_guard ();
 /* Assign rtl to each variable based on these partitions.  */
 if (stack_vars_num > 0)
 {
 /* Reorder decls to be protected by iterating over the variables
-array multiple times, and allocating out of each phase in turn.  */
+	 array multiple times, and allocating out of each phase in turn.  */
 /* ??? We could probably integrate this into the qsort we did
-earlier, such that we naturally see these variables first,
+	 earlier, such that we naturally see these variables first,
-and thus naturally allocate things in the right order.  */
+	 and thus naturally allocate things in the right order.  */
 if (has_protected_decls)
-{
+	{
-/* Phase 1 contains only character arrays.  */
+	  /* Phase 1 contains only character arrays.  */
-expand_stack_vars (stack_protect_decl_phase_1);
+	  expand_stack_vars (stack_protect_decl_phase_1);
-/* Phase 2 contains other kinds of arrays.  */
+	  /* Phase 2 contains other kinds of arrays.  */
-if (flag_stack_protect == 2)
+	  if (flag_stack_protect == 2)
-expand_stack_vars (stack_protect_decl_phase_2);
+	    expand_stack_vars (stack_protect_decl_phase_2);
-}
+	}
 expand_stack_vars (NULL);
 fini_vars_expansion ();
 }
 /* If the target requires that FRAME_OFFSET be aligned, do it.  */
 if (STACK_ALIGNMENT_NEEDED)
 {
 HOST_WIDE_INT align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
 if (!FRAME_GROWS_DOWNWARD)
-frame_offset += align - 1;
+	frame_offset += align - 1;
 frame_offset &= -align;
 }
 }
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "\n;; ");
 print_gimple_stmt (dump_file, stmt, 0,
-TDF_SLIM | (dump_flags & TDF_LINENO));
+			 TDF_SLIM | (dump_flags & TDF_LINENO));
 fprintf (dump_file, "\n");
 print_rtl (dump_file, since ? NEXT_INSN (since) : since);
 }
 }
 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 {
 lab_stmt = gsi_stmt (gsi);
 if (gimple_code (lab_stmt) != GIMPLE_LABEL)
-break;
+	break;
 lab = gimple_label_label (lab_stmt);
 if (DECL_NONLOCAL (lab))
-break;
+	break;
 return label_rtx (lab);
 }
 elt = pointer_map_insert (lab_rtx_for_bb, bb);
 if (BARRIER_P (get_last_insn ()))
 {
 rtx insn;
 remove_edge (e);
 /* Now, we have a single successor block, if we have insns to
-insert on the remaining edge we potentially will insert
+	 insert on the remaining edge we potentially will insert
-it at the end of this block (if the dest block isn't feasible)
+	 it at the end of this block (if the dest block isn't feasible)
-in order to avoid splitting the edge.  This insertion will take
+	 in order to avoid splitting the edge.  This insertion will take
-place in front of the last jump.  But we might have emitted
+	 place in front of the last jump.  But we might have emitted
-multiple jumps (conditional and one unconditional) to the
+	 multiple jumps (conditional and one unconditional) to the
-same destination.  Inserting in front of the last one then
+	 same destination.  Inserting in front of the last one then
-is a problem.  See PR 40021.  We fix this by deleting all
+	 is a problem.  See PR 40021.  We fix this by deleting all
-jumps except the last unconditional one.  */
+	 jumps except the last unconditional one.  */
 insn = PREV_INSN (get_last_insn ());
 /* Make sure we have an unconditional jump.  Otherwise we're
-confused.  */
+	 confused.  */
 gcc_assert (JUMP_P (insn) && !any_condjump_p (insn));
 for (insn = PREV_INSN (insn); insn != last;)
 	{
 	  insn = PREV_INSN (insn);
 	  if (JUMP_P (NEXT_INSN (insn)))
 && TREE_CODE (op0) == SSA_NAME
 && bitmap_bit_p (SA.values, SSA_NAME_VERSION (op0)))
 {
 gimple second = SSA_NAME_DEF_STMT (op0);
 if (gimple_code (second) == GIMPLE_ASSIGN)
-{
+	{
-enum tree_code code2 = gimple_assign_rhs_code (second);
+	  enum tree_code code2 = gimple_assign_rhs_code (second);
-if (TREE_CODE_CLASS (code2) == tcc_comparison)
+	  if (TREE_CODE_CLASS (code2) == tcc_comparison)
-{
+	    {
-code = code2;
+	      code = code2;
-op0 = gimple_assign_rhs1 (second);
+	      op0 = gimple_assign_rhs1 (second);
-op1 = gimple_assign_rhs2 (second);
+	      op1 = gimple_assign_rhs2 (second);
-}
+	    }
-/* If jumps are cheap turn some more codes into
+	  /* If jumps are cheap turn some more codes into
-jumpy sequences.  */
+	     jumpy sequences.  */
-else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
+	  else if (BRANCH_COST (optimize_insn_for_speed_p (), false) < 4)
-{
+	    {
-if ((code2 == BIT_AND_EXPR
+	      if ((code2 == BIT_AND_EXPR
-&& TYPE_PRECISION (TREE_TYPE (op0)) == 1
+		   && TYPE_PRECISION (TREE_TYPE (op0)) == 1
-&& TREE_CODE (gimple_assign_rhs2 (second)) != INTEGER_CST)
+		   && TREE_CODE (gimple_assign_rhs2 (second)) != INTEGER_CST)
-|| code2 == TRUTH_AND_EXPR)
+		  || code2 == TRUTH_AND_EXPR)
-{
+		{
-code = TRUTH_ANDIF_EXPR;
+		  code = TRUTH_ANDIF_EXPR;
-op0 = gimple_assign_rhs1 (second);
+		  op0 = gimple_assign_rhs1 (second);
-op1 = gimple_assign_rhs2 (second);
+		  op1 = gimple_assign_rhs2 (second);
-}
+		}
-else if (code2 == BIT_IOR_EXPR || code2 == TRUTH_OR_EXPR)
+	      else if (code2 == BIT_IOR_EXPR || code2 == TRUTH_OR_EXPR)
-{
+		{
-code = TRUTH_ORIF_EXPR;
+		  code = TRUTH_ORIF_EXPR;
-op0 = gimple_assign_rhs1 (second);
+		  op0 = gimple_assign_rhs1 (second);
-op1 = gimple_assign_rhs2 (second);
+		  op1 = gimple_assign_rhs2 (second);
-}
+		}
-}
+	    }
-}
+	}
 }
 last2 = last = get_last_insn ();
 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
 {
 jumpif_1 (code, op0, op1, label_rtx_for_bb (true_edge->dest),
 		true_edge->probability);
 maybe_dump_rtl_for_gimple_stmt (stmt, last);
 if (true_edge->goto_locus)
-{
+	{
-set_curr_insn_source_location (true_edge->goto_locus);
+	  set_curr_insn_source_location (true_edge->goto_locus);
-set_curr_insn_block (true_edge->goto_block);
+	  set_curr_insn_block (true_edge->goto_block);
-true_edge->goto_locus = curr_insn_locator ();
+	  true_edge->goto_locus = curr_insn_locator ();
-}
+	}
 true_edge->goto_block = NULL;
 false_edge->flags |= EDGE_FALLTHRU;
 maybe_cleanup_end_of_block (false_edge, last);
 return NULL;
 }
 {
 jumpifnot_1 (code, op0, op1, label_rtx_for_bb (false_edge->dest),
 		   false_edge->probability);
 maybe_dump_rtl_for_gimple_stmt (stmt, last);
 if (false_edge->goto_locus)
-{
+	{
-set_curr_insn_source_location (false_edge->goto_locus);
+	  set_curr_insn_source_location (false_edge->goto_locus);
-set_curr_insn_block (false_edge->goto_block);
+	  set_curr_insn_block (false_edge->goto_block);
-false_edge->goto_locus = curr_insn_locator ();
+	  false_edge->goto_locus = curr_insn_locator ();
-}
+	}
 false_edge->goto_block = NULL;
 true_edge->flags |= EDGE_FALLTHRU;
 maybe_cleanup_end_of_block (true_edge, last);
 return NULL;
 }
 switch (gimple_code (stmt))
 {
 case GIMPLE_GOTO:
 op0 = gimple_goto_dest (stmt);
 if (TREE_CODE (op0) == LABEL_DECL)
-expand_goto (op0);
+	expand_goto (op0);
 else
-expand_computed_goto (op0);
+	expand_computed_goto (op0);
 break;
 case GIMPLE_LABEL:
 expand_label (gimple_label_label (stmt));
 break;
 case GIMPLE_NOP:
 case GIMPLE_RETURN:
 op0 = gimple_return_retval (stmt);
 if (op0 && op0 != error_mark_node)
-{
+	{
-tree result = DECL_RESULT (current_function_decl);
+	  tree result = DECL_RESULT (current_function_decl);
-/* If we are not returning the current function's RESULT_DECL,
+	  /* If we are not returning the current function's RESULT_DECL,
-build an assignment to it.  */
+	     build an assignment to it.  */
-if (op0 != result)
+	  if (op0 != result)
-{
+	    {
-/* I believe that a function's RESULT_DECL is unique.  */
+	      /* I believe that a function's RESULT_DECL is unique.  */
-gcc_assert (TREE_CODE (op0) != RESULT_DECL);
+	      gcc_assert (TREE_CODE (op0) != RESULT_DECL);
-/* ??? We'd like to use simply expand_assignment here,
+	      /* ??? We'd like to use simply expand_assignment here,
-but this fails if the value is of BLKmode but the return
+	         but this fails if the value is of BLKmode but the return
-decl is a register.  expand_return has special handling
+		 decl is a register.  expand_return has special handling
-for this combination, which eventually should move
+		 for this combination, which eventually should move
-to common code.  See comments there.  Until then, let's
+		 to common code.  See comments there.  Until then, let's
-build a modify expression :-/  */
+		 build a modify expression :-/  */
-op0 = build2 (MODIFY_EXPR, TREE_TYPE (result),
+	      op0 = build2 (MODIFY_EXPR, TREE_TYPE (result),
-result, op0);
+			    result, op0);
-}
+	    }
-}
+	}
 if (!op0)
-expand_null_return ();
+	expand_null_return ();
 else
-expand_return (op0);
+	expand_return (op0);
 break;
 case GIMPLE_ASSIGN:
 {
 	tree lhs = gimple_assign_lhs (stmt);
 lp_nr = lookup_stmt_eh_lp (stmt);
 if (lp_nr)
 {
 rtx insn;
 for (insn = next_real_insn (last); insn;
-insn = next_real_insn (insn))
+	   insn = next_real_insn (insn))
-{
+	{
-if (! find_reg_note (insn, REG_EH_REGION, NULL_RTX)
+	  if (! find_reg_note (insn, REG_EH_REGION, NULL_RTX)
-/* If we want exceptions for non-call insns, any
+	      /* If we want exceptions for non-call insns, any
-may_trap_p instruction may throw.  */
+		 may_trap_p instruction may throw.  */
-&& GET_CODE (PATTERN (insn)) != CLOBBER
+	      && GET_CODE (PATTERN (insn)) != CLOBBER
-&& GET_CODE (PATTERN (insn)) != USE
+	      && GET_CODE (PATTERN (insn)) != USE
-&& insn_could_throw_p (insn))
+	      && insn_could_throw_p (insn))
-make_reg_eh_region_note (insn, 0, lp_nr);
+	    make_reg_eh_region_note (insn, 0, lp_nr);
-}
+	}
 }
 return last;
 }
 count = 0;
 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
 {
 if (!(e->flags & (EDGE_ABNORMAL | EDGE_EH)))
-{
+	{
-if (e->dest != EXIT_BLOCK_PTR)
+	  if (e->dest != EXIT_BLOCK_PTR)
-{
+	    {
-e->dest->count -= e->count;
+	      e->dest->count -= e->count;
-e->dest->frequency -= EDGE_FREQUENCY (e);
+	      e->dest->frequency -= EDGE_FREQUENCY (e);
-if (e->dest->count < 0)
+	      if (e->dest->count < 0)
-e->dest->count = 0;
+		e->dest->count = 0;
-if (e->dest->frequency < 0)
+	      if (e->dest->frequency < 0)
-e->dest->frequency = 0;
+		e->dest->frequency = 0;
-}
+	    }
-count += e->count;
+	  count += e->count;
-probability += e->probability;
+	  probability += e->probability;
-remove_edge (e);
+	  remove_edge (e);
-}
+	}
 else
-ei_next (&ei);
+	ei_next (&ei);
 }
 /* This is somewhat ugly: the call_expr expander often emits instructions
 after the sibcall (to perform the function return).  These confuse the
 find_many_sub_basic_blocks code, so we need to get rid of these.  */
 *can_fallthru = false;
 while (NEXT_INSN (last))
 {
 /* For instance an sqrt builtin expander expands if with
-sibcall in the then and label for `else`.  */
+	 sibcall in the then and label for `else`.  */
 if (LABEL_P (NEXT_INSN (last)))
-{
+	{
-*can_fallthru = true;
+	  *can_fallthru = true;
-break;
+	  break;
-}
+	}
 delete_insn (NEXT_INSN (last));
 }
 e = make_edge (bb, EXIT_BLOCK_PTR, EDGE_ABNORMAL | EDGE_SIBCALL);
 e->probability += probability;
 {
 bb = create_basic_block (NEXT_INSN (last), get_last_insn (), bb);
 last = BB_END (bb);
 if (BARRIER_P (last))
-BB_END (bb) = PREV_INSN (last);
+	BB_END (bb) = PREV_INSN (last);
 }
 maybe_dump_rtl_for_gimple_stmt (stmt, last2);
 return bb;
 /* (mod != 0 ? (op1 / mod < 0 ? -1 : 0) : 0) */
 return gen_rtx_IF_THEN_ELSE
 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
 gen_rtx_IF_THEN_ELSE
 (mode, gen_rtx_LT (BImode,
-gen_rtx_DIV (mode, op1, mod),
+			gen_rtx_DIV (mode, op1, mod),
-const0_rtx),
+			const0_rtx),
 constm1_rtx, const0_rtx),
 const0_rtx);
 }
 /* Return the difference between the ceil and the truncated result of
 /* (mod != 0 ? (op1 / mod > 0 ? 1 : 0) : 0) */
 return gen_rtx_IF_THEN_ELSE
 (mode, gen_rtx_NE (BImode, mod, const0_rtx),
 gen_rtx_IF_THEN_ELSE
 (mode, gen_rtx_GT (BImode,
-gen_rtx_DIV (mode, op1, mod),
+			gen_rtx_DIV (mode, op1, mod),
-const0_rtx),
+			const0_rtx),
 const1_rtx, const0_rtx),
 const0_rtx);
 }
 /* Return the difference between the ceil and the truncated result of
 /* (abs (mod) >= abs (op1) - abs (mod)
 ? (op1 / mod > 0 ? 1 : -1)
 : 0) */
 return gen_rtx_IF_THEN_ELSE
 (mode, gen_rtx_GE (BImode, gen_rtx_ABS (mode, mod),
-gen_rtx_MINUS (mode,
+		       gen_rtx_MINUS (mode,
-gen_rtx_ABS (mode, op1),
+				      gen_rtx_ABS (mode, op1),
-gen_rtx_ABS (mode, mod))),
+				      gen_rtx_ABS (mode, mod))),
 gen_rtx_IF_THEN_ELSE
 (mode, gen_rtx_GT (BImode,
-gen_rtx_DIV (mode, op1, mod),
+			gen_rtx_DIV (mode, op1, mod),
-const0_rtx),
+			const0_rtx),
 const1_rtx, constm1_rtx),
 const0_rtx);
 }
 /* Return the difference between the rounded and the truncated result
 round_udiv_adjust (enum machine_mode mode, rtx mod, rtx op1)
 {
 /* (mod >= op1 - mod ? 1 : 0) */
 return gen_rtx_IF_THEN_ELSE
 (mode, gen_rtx_GE (BImode, mod,
-gen_rtx_MINUS (mode, op1, mod)),
+		       gen_rtx_MINUS (mode, op1, mod)),
 const1_rtx, const0_rtx);
 }
 /* Convert X to MODE, that must be Pmode or ptr_mode, without emitting
 any rtl.  */
 if (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode)
 return x;
 if (GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (xmode))
 x = simplify_gen_subreg (mode, x, xmode,
-subreg_lowpart_offset
+			     subreg_lowpart_offset
-(mode, xmode));
+			     (mode, xmode));
 else if (POINTERS_EXTEND_UNSIGNED > 0)
 x = gen_rtx_ZERO_EXTEND (mode, x);
 else if (!POINTERS_EXTEND_UNSIGNED)
 x = gen_rtx_SIGN_EXTEND (mode, x);
 else
 break;
 ternary:
 op2 = expand_debug_expr (TREE_OPERAND (exp, 2));
 if (!op2)
-return NULL_RTX;
+	return NULL_RTX;
 /* Fall through.  */
 binary:
 case tcc_binary:
 case tcc_comparison:
 op1 = expand_debug_expr (TREE_OPERAND (exp, 1));
 if (!op1)
-return NULL_RTX;
+	return NULL_RTX;
 /* Fall through.  */
 unary:
 case tcc_unary:
 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
 if (!op0)
-return NULL_RTX;
+	return NULL_RTX;
 break;
 case tcc_type:
 case tcc_statement:
 gcc_unreachable ();
 switch (TREE_CODE (exp))
 {
 case STRING_CST:
 if (!lookup_constant_def (exp))
-{
+	{
-if (strlen (TREE_STRING_POINTER (exp)) + 1
+	  if (strlen (TREE_STRING_POINTER (exp)) + 1
-!= (size_t) TREE_STRING_LENGTH (exp))
+	      != (size_t) TREE_STRING_LENGTH (exp))
-return NULL_RTX;
+	    return NULL_RTX;
-op0 = gen_rtx_CONST_STRING (Pmode, TREE_STRING_POINTER (exp));
+	  op0 = gen_rtx_CONST_STRING (Pmode, TREE_STRING_POINTER (exp));
-op0 = gen_rtx_MEM (BLKmode, op0);
+	  op0 = gen_rtx_MEM (BLKmode, op0);
-set_mem_attributes (op0, exp, 0);
+	  set_mem_attributes (op0, exp, 0);
-return op0;
+	  return op0;
-}
+	}
 /* Fall through...  */
 case INTEGER_CST:
 case REAL_CST:
 case FIXED_CST:
 case DEBUG_EXPR_DECL:
 op0 = DECL_RTL_IF_SET (exp);
 if (op0)
-return op0;
+	return op0;
 op0 = gen_rtx_DEBUG_EXPR (mode);
 DEBUG_EXPR_TREE_DECL (op0) = exp;
 SET_DECL_RTL (exp, op0);
 	      || GET_CODE (XEXP (op0, 0)) != SYMBOL_REF
 	      || SYMBOL_REF_DECL (XEXP (op0, 0)) != exp)
 	    return NULL;
 	}
 else
-op0 = copy_rtx (op0);
+	op0 = copy_rtx (op0);
 if (GET_MODE (op0) == BLKmode
 	  /* If op0 is not BLKmode, but BLKmode is, adjust_mode
 	     below would ICE.  While it is likely a FE bug,
 	     try to be robust here.  See PR43166.  */
 	}
 /* FALLTHROUGH */
 case INDIRECT_REF:
 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
 if (!op0)
-return NULL;
+	return NULL;
 if (TREE_CODE (exp) == MEM_REF)
 	{
 	  if (GET_CODE (op0) == DEBUG_IMPLICIT_PTR
 	      || (GET_CODE (op0) == PLUS
 if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR
 	  && !DECL_RTL_SET_P (TREE_OPERAND (TMR_BASE (exp), 0)))
 	return NULL;
 op0 = expand_debug_expr
-(tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp)), exp));
+	    (tree_mem_ref_addr (build_pointer_type (TREE_TYPE (exp)), exp));
 if (!op0)
-return NULL;
+	return NULL;
 if (POINTER_TYPE_P (TREE_TYPE (exp)))
 	as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
 else
 	as = ADDR_SPACE_GENERIC;
 case BIT_NOT_EXPR:
 return gen_rtx_NOT (mode, op0);
 case FLOAT_EXPR:
 if (unsignedp)
-return gen_rtx_UNSIGNED_FLOAT (mode, op0);
+	return gen_rtx_UNSIGNED_FLOAT (mode, op0);
 else
-return gen_rtx_FLOAT (mode, op0);
+	return gen_rtx_FLOAT (mode, op0);
 case FIX_TRUNC_EXPR:
 if (unsignedp)
-return gen_rtx_UNSIGNED_FIX (mode, op0);
+	return gen_rtx_UNSIGNED_FIX (mode, op0);
 else
-return gen_rtx_FIX (mode, op0);
+	return gen_rtx_FIX (mode, op0);
 case POINTER_PLUS_EXPR:
 /* For the rare target where pointers are not the same size as
 	 size_t, we need to check for mis-matched modes and correct
 	 the addend.  */
 case RDIV_EXPR:
 case TRUNC_DIV_EXPR:
 case EXACT_DIV_EXPR:
 if (unsignedp)
-return gen_rtx_UDIV (mode, op0, op1);
+	return gen_rtx_UDIV (mode, op0, op1);
 else
-return gen_rtx_DIV (mode, op0, op1);
+	return gen_rtx_DIV (mode, op0, op1);
 case TRUNC_MOD_EXPR:
 if (unsignedp)
-return gen_rtx_UMOD (mode, op0, op1);
+	return gen_rtx_UMOD (mode, op0, op1);
 else
-return gen_rtx_MOD (mode, op0, op1);
+	return gen_rtx_MOD (mode, op0, op1);
 case FLOOR_DIV_EXPR:
 if (unsignedp)
-return gen_rtx_UDIV (mode, op0, op1);
+	return gen_rtx_UDIV (mode, op0, op1);
 else
-{
+	{
-rtx div = gen_rtx_DIV (mode, op0, op1);
+	  rtx div = gen_rtx_DIV (mode, op0, op1);
-rtx mod = gen_rtx_MOD (mode, op0, op1);
+	  rtx mod = gen_rtx_MOD (mode, op0, op1);
-rtx adj = floor_sdiv_adjust (mode, mod, op1);
+	  rtx adj = floor_sdiv_adjust (mode, mod, op1);
-return gen_rtx_PLUS (mode, div, adj);
+	  return gen_rtx_PLUS (mode, div, adj);
-}
+	}
 case FLOOR_MOD_EXPR:
 if (unsignedp)
-return gen_rtx_UMOD (mode, op0, op1);
+	return gen_rtx_UMOD (mode, op0, op1);
 else
-{
+	{
-rtx mod = gen_rtx_MOD (mode, op0, op1);
+	  rtx mod = gen_rtx_MOD (mode, op0, op1);
-rtx adj = floor_sdiv_adjust (mode, mod, op1);
+	  rtx adj = floor_sdiv_adjust (mode, mod, op1);
-adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
+	  adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
-return gen_rtx_PLUS (mode, mod, adj);
+	  return gen_rtx_PLUS (mode, mod, adj);
-}
+	}
 case CEIL_DIV_EXPR:
 if (unsignedp)
-{
+	{
-rtx div = gen_rtx_UDIV (mode, op0, op1);
+	  rtx div = gen_rtx_UDIV (mode, op0, op1);
-rtx mod = gen_rtx_UMOD (mode, op0, op1);
+	  rtx mod = gen_rtx_UMOD (mode, op0, op1);
-rtx adj = ceil_udiv_adjust (mode, mod, op1);
+	  rtx adj = ceil_udiv_adjust (mode, mod, op1);
-return gen_rtx_PLUS (mode, div, adj);
+	  return gen_rtx_PLUS (mode, div, adj);
-}
+	}
 else
-{
+	{
-rtx div = gen_rtx_DIV (mode, op0, op1);
+	  rtx div = gen_rtx_DIV (mode, op0, op1);
-rtx mod = gen_rtx_MOD (mode, op0, op1);
+	  rtx mod = gen_rtx_MOD (mode, op0, op1);
-rtx adj = ceil_sdiv_adjust (mode, mod, op1);
+	  rtx adj = ceil_sdiv_adjust (mode, mod, op1);
-return gen_rtx_PLUS (mode, div, adj);
+	  return gen_rtx_PLUS (mode, div, adj);
-}
+	}
 case CEIL_MOD_EXPR:
 if (unsignedp)
-{
+	{
-rtx mod = gen_rtx_UMOD (mode, op0, op1);
+	  rtx mod = gen_rtx_UMOD (mode, op0, op1);
-rtx adj = ceil_udiv_adjust (mode, mod, op1);
+	  rtx adj = ceil_udiv_adjust (mode, mod, op1);
-adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
+	  adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
-return gen_rtx_PLUS (mode, mod, adj);
+	  return gen_rtx_PLUS (mode, mod, adj);
-}
+	}
 else
-{
+	{
-rtx mod = gen_rtx_MOD (mode, op0, op1);
+	  rtx mod = gen_rtx_MOD (mode, op0, op1);
-rtx adj = ceil_sdiv_adjust (mode, mod, op1);
+	  rtx adj = ceil_sdiv_adjust (mode, mod, op1);
-adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
+	  adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
-return gen_rtx_PLUS (mode, mod, adj);
+	  return gen_rtx_PLUS (mode, mod, adj);
-}
+	}
 case ROUND_DIV_EXPR:
 if (unsignedp)
-{
+	{
-rtx div = gen_rtx_UDIV (mode, op0, op1);
+	  rtx div = gen_rtx_UDIV (mode, op0, op1);
-rtx mod = gen_rtx_UMOD (mode, op0, op1);
+	  rtx mod = gen_rtx_UMOD (mode, op0, op1);
-rtx adj = round_udiv_adjust (mode, mod, op1);
+	  rtx adj = round_udiv_adjust (mode, mod, op1);
-return gen_rtx_PLUS (mode, div, adj);
+	  return gen_rtx_PLUS (mode, div, adj);
-}
+	}
 else
-{
+	{
-rtx div = gen_rtx_DIV (mode, op0, op1);
+	  rtx div = gen_rtx_DIV (mode, op0, op1);
-rtx mod = gen_rtx_MOD (mode, op0, op1);
+	  rtx mod = gen_rtx_MOD (mode, op0, op1);
-rtx adj = round_sdiv_adjust (mode, mod, op1);
+	  rtx adj = round_sdiv_adjust (mode, mod, op1);
-return gen_rtx_PLUS (mode, div, adj);
+	  return gen_rtx_PLUS (mode, div, adj);
-}
+	}
 case ROUND_MOD_EXPR:
 if (unsignedp)
-{
+	{
-rtx mod = gen_rtx_UMOD (mode, op0, op1);
+	  rtx mod = gen_rtx_UMOD (mode, op0, op1);
-rtx adj = round_udiv_adjust (mode, mod, op1);
+	  rtx adj = round_udiv_adjust (mode, mod, op1);
-adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
+	  adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
-return gen_rtx_PLUS (mode, mod, adj);
+	  return gen_rtx_PLUS (mode, mod, adj);
-}
+	}
 else
-{
+	{
-rtx mod = gen_rtx_MOD (mode, op0, op1);
+	  rtx mod = gen_rtx_MOD (mode, op0, op1);
-rtx adj = round_sdiv_adjust (mode, mod, op1);
+	  rtx adj = round_sdiv_adjust (mode, mod, op1);
-adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
+	  adj = gen_rtx_NEG (mode, gen_rtx_MULT (mode, adj, op1));
-return gen_rtx_PLUS (mode, mod, adj);
+	  return gen_rtx_PLUS (mode, mod, adj);
-}
+	}
 case LSHIFT_EXPR:
 return gen_rtx_ASHIFT (mode, op0, op1);
 case RSHIFT_EXPR:
 if (unsignedp)
-return gen_rtx_LSHIFTRT (mode, op0, op1);
+	return gen_rtx_LSHIFTRT (mode, op0, op1);
 else
-return gen_rtx_ASHIFTRT (mode, op0, op1);
+	return gen_rtx_ASHIFTRT (mode, op0, op1);
 case LROTATE_EXPR:
 return gen_rtx_ROTATE (mode, op0, op1);
 case RROTATE_EXPR:
 return gen_rtx_ROTATERT (mode, op0, op1);
 case MIN_EXPR:
 if (unsignedp)
-return gen_rtx_UMIN (mode, op0, op1);
+	return gen_rtx_UMIN (mode, op0, op1);
 else
-return gen_rtx_SMIN (mode, op0, op1);
+	return gen_rtx_SMIN (mode, op0, op1);
 case MAX_EXPR:
 if (unsignedp)
-return gen_rtx_UMAX (mode, op0, op1);
+	return gen_rtx_UMAX (mode, op0, op1);
 else
-return gen_rtx_SMAX (mode, op0, op1);
+	return gen_rtx_SMAX (mode, op0, op1);
 case BIT_AND_EXPR:
 case TRUTH_AND_EXPR:
 return gen_rtx_AND (mode, op0, op1);
 case TRUTH_NOT_EXPR:
 return gen_rtx_EQ (mode, op0, const0_rtx);
 case LT_EXPR:
 if (unsignedp)
-return gen_rtx_LTU (mode, op0, op1);
+	return gen_rtx_LTU (mode, op0, op1);
 else
-return gen_rtx_LT (mode, op0, op1);
+	return gen_rtx_LT (mode, op0, op1);
 case LE_EXPR:
 if (unsignedp)
-return gen_rtx_LEU (mode, op0, op1);
+	return gen_rtx_LEU (mode, op0, op1);
 else
-return gen_rtx_LE (mode, op0, op1);
+	return gen_rtx_LE (mode, op0, op1);
 case GT_EXPR:
 if (unsignedp)
-return gen_rtx_GTU (mode, op0, op1);
+	return gen_rtx_GTU (mode, op0, op1);
 else
-return gen_rtx_GT (mode, op0, op1);
+	return gen_rtx_GT (mode, op0, op1);
 case GE_EXPR:
 if (unsignedp)
-return gen_rtx_GEU (mode, op0, op1);
+	return gen_rtx_GEU (mode, op0, op1);
 else
-return gen_rtx_GE (mode, op0, op1);
+	return gen_rtx_GE (mode, op0, op1);
 case EQ_EXPR:
 return gen_rtx_EQ (mode, op0, op1);
 case NE_EXPR:
 return gen_rtx_IF_THEN_ELSE (mode, op0, op1, op2);
 case COMPLEX_EXPR:
 gcc_assert (COMPLEX_MODE_P (mode));
 if (GET_MODE (op0) == VOIDmode)
-op0 = gen_rtx_CONST (GET_MODE_INNER (mode), op0);
+	op0 = gen_rtx_CONST (GET_MODE_INNER (mode), op0);
 if (GET_MODE (op1) == VOIDmode)
-op1 = gen_rtx_CONST (GET_MODE_INNER (mode), op1);
+	op1 = gen_rtx_CONST (GET_MODE_INNER (mode), op1);
 return gen_rtx_CONCAT (mode, op0, op1);
 case CONJ_EXPR:
 if (GET_CODE (op0) == CONCAT)
-return gen_rtx_CONCAT (mode, XEXP (op0, 0),
+	return gen_rtx_CONCAT (mode, XEXP (op0, 0),
-gen_rtx_NEG (GET_MODE_INNER (mode),
+			       gen_rtx_NEG (GET_MODE_INNER (mode),
-XEXP (op0, 1)));
+					    XEXP (op0, 1)));
 else
-{
+	{
-enum machine_mode imode = GET_MODE_INNER (mode);
+	  enum machine_mode imode = GET_MODE_INNER (mode);
-rtx re, im;
+	  rtx re, im;
-if (MEM_P (op0))
+	  if (MEM_P (op0))
-{
+	    {
-re = adjust_address_nv (op0, imode, 0);
+	      re = adjust_address_nv (op0, imode, 0);
-im = adjust_address_nv (op0, imode, GET_MODE_SIZE (imode));
+	      im = adjust_address_nv (op0, imode, GET_MODE_SIZE (imode));
-}
+	    }
-else
+	  else
-{
+	    {
-enum machine_mode ifmode = int_mode_for_mode (mode);
+	      enum machine_mode ifmode = int_mode_for_mode (mode);
-enum machine_mode ihmode = int_mode_for_mode (imode);
+	      enum machine_mode ihmode = int_mode_for_mode (imode);
-rtx halfsize;
+	      rtx halfsize;
-if (ifmode == BLKmode || ihmode == BLKmode)
+	      if (ifmode == BLKmode || ihmode == BLKmode)
-return NULL;
+		return NULL;
-halfsize = GEN_INT (GET_MODE_BITSIZE (ihmode));
+	      halfsize = GEN_INT (GET_MODE_BITSIZE (ihmode));
-re = op0;
+	      re = op0;
-if (mode != ifmode)
+	      if (mode != ifmode)
-re = gen_rtx_SUBREG (ifmode, re, 0);
+		re = gen_rtx_SUBREG (ifmode, re, 0);
-re = gen_rtx_ZERO_EXTRACT (ihmode, re, halfsize, const0_rtx);
+	      re = gen_rtx_ZERO_EXTRACT (ihmode, re, halfsize, const0_rtx);
-if (imode != ihmode)
+	      if (imode != ihmode)
-re = gen_rtx_SUBREG (imode, re, 0);
+		re = gen_rtx_SUBREG (imode, re, 0);
-im = copy_rtx (op0);
+	      im = copy_rtx (op0);
-if (mode != ifmode)
+	      if (mode != ifmode)
-im = gen_rtx_SUBREG (ifmode, im, 0);
+		im = gen_rtx_SUBREG (ifmode, im, 0);
-im = gen_rtx_ZERO_EXTRACT (ihmode, im, halfsize, halfsize);
+	      im = gen_rtx_ZERO_EXTRACT (ihmode, im, halfsize, halfsize);
-if (imode != ihmode)
+	      if (imode != ihmode)
-im = gen_rtx_SUBREG (imode, im, 0);
+		im = gen_rtx_SUBREG (imode, im, 0);
-}
+	    }
-im = gen_rtx_NEG (imode, im);
+	  im = gen_rtx_NEG (imode, im);
-return gen_rtx_CONCAT (mode, re, im);
+	  return gen_rtx_CONCAT (mode, re, im);
-}
+	}
 case ADDR_EXPR:
 op0 = expand_debug_expr (TREE_OPERAND (exp, 0));
 if (!op0 || !MEM_P (op0))
 	{
 return op0;
 case VECTOR_CST:
 exp = build_constructor_from_list (TREE_TYPE (exp),
-TREE_VECTOR_CST_ELTS (exp));
+					 TREE_VECTOR_CST_ELTS (exp));
 /* Fall through.  */
 case CONSTRUCTOR:
 if (TREE_CODE (TREE_TYPE (exp)) == VECTOR_TYPE)
 	{
 	    }
 	  return op0;
 	}
 else
-goto flag_unsupported;
+	goto flag_unsupported;
 case CALL_EXPR:
 /* ??? Maybe handle some builtins?  */
 return NULL;
 flag_strict_aliasing = 0;
 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
 if (DEBUG_INSN_P (insn))
 {
-tree value = (tree)INSN_VAR_LOCATION_LOC (insn);
+	tree value = (tree)INSN_VAR_LOCATION_LOC (insn);
-rtx val;
+	rtx val;
-enum machine_mode mode;
+	enum machine_mode mode;
-if (value == NULL_TREE)
+	if (value == NULL_TREE)
-val = NULL_RTX;
+	  val = NULL_RTX;
-else
+	else
-{
+	  {
-val = expand_debug_expr (value);
+	    val = expand_debug_expr (value);
-gcc_assert (last == get_last_insn ());
+	    gcc_assert (last == get_last_insn ());
-}
+	  }
-if (!val)
+	if (!val)
-val = gen_rtx_UNKNOWN_VAR_LOC ();
+	  val = gen_rtx_UNKNOWN_VAR_LOC ();
-else
+	else
-{
+	  {
-mode = GET_MODE (INSN_VAR_LOCATION (insn));
+	    mode = GET_MODE (INSN_VAR_LOCATION (insn));
-gcc_assert (mode == GET_MODE (val)
+	    gcc_assert (mode == GET_MODE (val)
-|| (GET_MODE (val) == VOIDmode
+			|| (GET_MODE (val) == VOIDmode
-&& (CONST_INT_P (val)
+			    && (CONST_INT_P (val)
-|| GET_CODE (val) == CONST_FIXED
+				|| GET_CODE (val) == CONST_FIXED
-|| GET_CODE (val) == CONST_DOUBLE
+				|| GET_CODE (val) == CONST_DOUBLE
-|| GET_CODE (val) == LABEL_REF)));
+				|| GET_CODE (val) == LABEL_REF)));
-}
+	  }
-INSN_VAR_LOCATION_LOC (insn) = val;
+	INSN_VAR_LOCATION_LOC (insn) = val;
 }
 flag_strict_aliasing = save_strict_alias;
 }
 edge_iterator ei;
 void **elt;
 if (dump_file)
 fprintf (dump_file, "\n;; Generating RTL for gimple basic block %d\n",
-bb->index);
+	     bb->index);
 /* Note that since we are now transitioning from GIMPLE to RTL, we
 cannot use the gsi_*_bb() routines because they expect the basic
 block to be in GIMPLE, instead of RTL.  Therefore, we need to
 access the BB sequence directly.  */
 gcc_assert (single_succ_p (bb));
 gcc_assert (single_succ (bb) == EXIT_BLOCK_PTR);
 if (bb->next_bb == EXIT_BLOCK_PTR
-&& !gimple_return_retval (ret_stmt))
+	  && !gimple_return_retval (ret_stmt))
-{
+	{
-gsi_remove (&gsi, false);
+	  gsi_remove (&gsi, false);
-single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
+	  single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
-}
+	}
 }
 gsi = gsi_start (stmts);
 if (!gsi_end_p (gsi))
 {
 stmt = gsi_stmt (gsi);
 if (gimple_code (stmt) != GIMPLE_LABEL)
-stmt = NULL;
+	stmt = NULL;
 }
 elt = pointer_map_contains (lab_rtx_for_bb, bb);
 if (stmt || elt)
 {
 last = get_last_insn ();
 if (stmt)
-{
+	{
-expand_gimple_stmt (stmt);
+	  expand_gimple_stmt (stmt);
-gsi_next (&gsi);
+	  gsi_next (&gsi);
-}
+	}
 if (elt)
-emit_label ((rtx) *elt);
+	emit_label ((rtx) *elt);
 /* Java emits line number notes in the top of labels.
-??? Make this go away once line number notes are obsoleted.  */
+	 ??? Make this go away once line number notes are obsoleted.  */
 BB_HEAD (bb) = NEXT_INSN (last);
 if (NOTE_P (BB_HEAD (bb)))
-BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
+	BB_HEAD (bb) = NEXT_INSN (BB_HEAD (bb));
 note = emit_note_after (NOTE_INSN_BASIC_BLOCK, BB_HEAD (bb));
 maybe_dump_rtl_for_gimple_stmt (stmt, last);
 }
 else
 	}
 currently_expanding_gimple_stmt = stmt;
 /* Expand this statement, then evaluate the resulting RTL and
-fixup the CFG accordingly.  */
+	 fixup the CFG accordingly.  */
 if (gimple_code (stmt) == GIMPLE_COND)
-{
+	{
-new_bb = expand_gimple_cond (bb, stmt);
+	  new_bb = expand_gimple_cond (bb, stmt);
-if (new_bb)
+	  if (new_bb)
-return new_bb;
+	    return new_bb;
-}
+	}
 else if (gimple_debug_bind_p (stmt))
 	{
 	  location_t sloc = get_curr_insn_source_location ();
 	  tree sblock = get_curr_insn_block ();
 	  gimple_stmt_iterator nsi = gsi;
 	  set_curr_insn_source_location (sloc);
 	  set_curr_insn_block (sblock);
 	}
 else
-{
+	{
-if (is_gimple_call (stmt) && gimple_call_tail_p (stmt))
+	  if (is_gimple_call (stmt) && gimple_call_tail_p (stmt))
-{
+	    {
-bool can_fallthru;
+	      bool can_fallthru;
-new_bb = expand_gimple_tailcall (bb, stmt, &can_fallthru);
+	      new_bb = expand_gimple_tailcall (bb, stmt, &can_fallthru);
-if (new_bb)
+	      if (new_bb)
-{
+		{
-if (can_fallthru)
+		  if (can_fallthru)
-bb = new_bb;
+		    bb = new_bb;
-else
+		  else
-return new_bb;
+		    return new_bb;
-}
+		}
-}
+	    }
-else
+	  else
-{
+	    {
-def_operand_p def_p;
+	      def_operand_p def_p;
-def_p = SINGLE_SSA_DEF_OPERAND (stmt, SSA_OP_DEF);
+	      def_p = SINGLE_SSA_DEF_OPERAND (stmt, SSA_OP_DEF);
-if (def_p != NULL)
+	      if (def_p != NULL)
-{
+		{
-/* Ignore this stmt if it is in the list of
+		  /* Ignore this stmt if it is in the list of
-replaceable expressions.  */
+		     replaceable expressions.  */
-if (SA.values
+		  if (SA.values
-&& bitmap_bit_p (SA.values,
+		      && bitmap_bit_p (SA.values,
-SSA_NAME_VERSION (DEF_FROM_PTR (def_p))))
+				       SSA_NAME_VERSION (DEF_FROM_PTR (def_p))))
-continue;
+		    continue;
-}
+		}
-last = expand_gimple_stmt (stmt);
+	      last = expand_gimple_stmt (stmt);
-maybe_dump_rtl_for_gimple_stmt (stmt, last);
+	      maybe_dump_rtl_for_gimple_stmt (stmt, last);
-}
+	    }
-}
+	}
 }
 currently_expanding_gimple_stmt = NULL;
 /* Expand implicit goto and convert goto_locus.  */
 FOR_EACH_EDGE (e, ei, bb->succs)
 {
 if (e->goto_locus && e->goto_block)
-{
+	{
-set_curr_insn_source_location (e->goto_locus);
+	  set_curr_insn_source_location (e->goto_locus);
-set_curr_insn_block (e->goto_block);
+	  set_curr_insn_block (e->goto_block);
-e->goto_locus = curr_insn_locator ();
+	  e->goto_locus = curr_insn_locator ();
-}
+	}
 e->goto_block = NULL;
 if ((e->flags & EDGE_FALLTHRU) && e->dest != bb->next_bb)
-{
+	{
-emit_jump (label_rtx_for_bb (e->dest));
+	  emit_jump (label_rtx_for_bb (e->dest));
-e->flags &= ~EDGE_FALLTHRU;
+	  e->flags &= ~EDGE_FALLTHRU;
-}
+	}
 }
 /* Expanded RTL can create a jump in the last instruction of block.
 This later might be assumed to be a jump to successor and break edge insertion.
 We need to insert dummy move to prevent this. PR41440. */
 }
 else
 flags = EDGE_FALLTHRU;
 init_block = create_basic_block (NEXT_INSN (get_insns ()),
-get_last_insn (),
+				   get_last_insn (),
-ENTRY_BLOCK_PTR);
+				   ENTRY_BLOCK_PTR);
 init_block->frequency = ENTRY_BLOCK_PTR->frequency;
 init_block->count = ENTRY_BLOCK_PTR->count;
 if (e)
 {
 first_block = e->dest;
 */
 BB_END (EXIT_BLOCK_PTR->prev_bb) = orig_end;
 while (NEXT_INSN (head) && NOTE_P (NEXT_INSN (head)))
 head = NEXT_INSN (head);
 exit_block = create_basic_block (NEXT_INSN (head), end,
-EXIT_BLOCK_PTR->prev_bb);
+				   EXIT_BLOCK_PTR->prev_bb);
 exit_block->frequency = EXIT_BLOCK_PTR->frequency;
 exit_block->count = EXIT_BLOCK_PTR->count;
 ix = 0;
 while (ix < EDGE_COUNT (EXIT_BLOCK_PTR->preds))
 {
 e = EDGE_PRED (EXIT_BLOCK_PTR, ix);
 if (!(e->flags & EDGE_ABNORMAL))
-redirect_edge_succ (e, exit_block);
+	redirect_edge_succ (e, exit_block);
 else
-ix++;
+	ix++;
 }
 e = make_edge (exit_block, EXIT_BLOCK_PTR, EDGE_FALLTHRU);
 e->probability = REG_BR_PROB_BASE;
 e->count = EXIT_BLOCK_PTR->count;
 FOR_EACH_EDGE (e2, ei, EXIT_BLOCK_PTR->preds)
 if (e2 != e)
 {
-e->count -= e2->count;
+	e->count -= e2->count;
-exit_block->count -= e2->count;
+	exit_block->count -= e2->count;
-exit_block->frequency -= EDGE_FREQUENCY (e2);
+	exit_block->frequency -= EDGE_FREQUENCY (e2);
 }
 if (e->count < 0)
 e->count = 0;
 if (exit_block->count < 0)
 exit_block->count = 0;
 Look for ARRAY_REF nodes with non-constant indexes and mark them
 addressable.  */
 static tree
 discover_nonconstant_array_refs_r (tree * tp, int *walk_subtrees,
-void *data ATTRIBUTE_UNUSED)
+				   void *data ATTRIBUTE_UNUSED)
 {
 tree t = *tp;
 if (IS_TYPE_OR_DECL_P (t))
 *walk_subtrees = 0;
 else if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
 {
 while (((TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
-&& is_gimple_min_invariant (TREE_OPERAND (t, 1))
+	      && is_gimple_min_invariant (TREE_OPERAND (t, 1))
-&& (!TREE_OPERAND (t, 2)
+	      && (!TREE_OPERAND (t, 2)
-|| is_gimple_min_invariant (TREE_OPERAND (t, 2))))
+		  || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
-|| (TREE_CODE (t) == COMPONENT_REF
+	     || (TREE_CODE (t) == COMPONENT_REF
-&& (!TREE_OPERAND (t,2)
+		 && (!TREE_OPERAND (t,2)
-|| is_gimple_min_invariant (TREE_OPERAND (t, 2))))
+		     || is_gimple_min_invariant (TREE_OPERAND (t, 2))))
-|| TREE_CODE (t) == BIT_FIELD_REF
+	     || TREE_CODE (t) == BIT_FIELD_REF
-|| TREE_CODE (t) == REALPART_EXPR
+	     || TREE_CODE (t) == REALPART_EXPR
-|| TREE_CODE (t) == IMAGPART_EXPR
+	     || TREE_CODE (t) == IMAGPART_EXPR
-|| TREE_CODE (t) == VIEW_CONVERT_EXPR
+	     || TREE_CODE (t) == VIEW_CONVERT_EXPR
-|| CONVERT_EXPR_P (t))
+	     || CONVERT_EXPR_P (t))
-t = TREE_OPERAND (t, 0);
+	t = TREE_OPERAND (t, 0);
 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
-{
+	{
-t = get_base_address (t);
+	  t = get_base_address (t);
-if (t && DECL_P (t)
+	  if (t && DECL_P (t)
 && DECL_MODE (t) != BLKmode)
-TREE_ADDRESSABLE (t) = 1;
+	    TREE_ADDRESSABLE (t) = 1;
-}
+	}
 *walk_subtrees = 0;
 }
 return NULL_TREE;
 crtl->stack_alignment_estimated = preferred_stack_boundary;
 if (preferred_stack_boundary > crtl->stack_alignment_needed)
 crtl->stack_alignment_needed = preferred_stack_boundary;
 gcc_assert (crtl->stack_alignment_needed
-<= crtl->stack_alignment_estimated);
+	      <= crtl->stack_alignment_estimated);
 crtl->stack_realign_needed
 = INCOMING_STACK_BOUNDARY < crtl->stack_alignment_estimated;
 crtl->stack_realign_tried = crtl->stack_realign_needed;
 timevar_push (TV_OUT_OF_SSA);
 rewrite_out_of_ssa (&SA);
 timevar_pop (TV_OUT_OF_SSA);
 SA.partition_to_pseudo = (rtx *)xcalloc (SA.map->num_partitions,
-sizeof (rtx));
+					   sizeof (rtx));
 /* Some backends want to know that we are expanding to RTL.  */
 currently_expanding_to_rtl = 1;
 rtl_profile_for_bb (ENTRY_BLOCK_PTR);
 for (i = 0; i < SA.map->num_partitions; i++)
 {
 tree var = SSA_NAME_VAR (partition_to_var (SA.map, i));
 if (TREE_CODE (var) != VAR_DECL
-&& !SA.partition_to_pseudo[i])
+	  && !SA.partition_to_pseudo[i])
-SA.partition_to_pseudo[i] = DECL_RTL_IF_SET (var);
+	SA.partition_to_pseudo[i] = DECL_RTL_IF_SET (var);
 gcc_assert (SA.partition_to_pseudo[i]);
 /* If this decl was marked as living in multiple places, reset
 this now to NULL.  */
 if (DECL_RTL_IF_SET (var) == pc_rtx)
-SET_DECL_RTL (var, NULL);
+	SET_DECL_RTL (var, NULL);
 /* Some RTL parts really want to look at DECL_RTL(x) when x
 was a decl marked in REG_ATTR or MEM_ATTR.  We could use
-SET_DECL_RTL here making this available, but that would mean
+	 SET_DECL_RTL here making this available, but that would mean
-to select one of the potentially many RTLs for one DECL.  Instead
+	 to select one of the potentially many RTLs for one DECL.  Instead
-of doing that we simply reset the MEM_EXPR of the RTL in question,
+	 of doing that we simply reset the MEM_EXPR of the RTL in question,
-then nobody can get at it and hence nobody can call DECL_RTL on it.  */
+	 then nobody can get at it and hence nobody can call DECL_RTL on it.  */
 if (!DECL_RTL_SET_P (var))
-{
+	{
-if (MEM_P (SA.partition_to_pseudo[i]))
+	  if (MEM_P (SA.partition_to_pseudo[i]))
-set_mem_expr (SA.partition_to_pseudo[i], NULL);
+	    set_mem_expr (SA.partition_to_pseudo[i], NULL);
-}
+	}
 }
 /* If this function is `main', emit a call to `__main'
 to run global initializers, etc.  */
 if (DECL_NAME (current_function_decl)
 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR->next_bb, EXIT_BLOCK_PTR, next_bb)
 {
 edge e;
 edge_iterator ei;
 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
-{
+	{
-/* Clear EDGE_EXECUTABLE.  This flag is never used in the backend.  */
+	  /* Clear EDGE_EXECUTABLE.  This flag is never used in the backend.  */
-e->flags &= ~EDGE_EXECUTABLE;
+	  e->flags &= ~EDGE_EXECUTABLE;
-/* At the moment not all abnormal edges match the RTL
+	  /* At the moment not all abnormal edges match the RTL
-representation.  It is safe to remove them here as
+	     representation.  It is safe to remove them here as
-find_many_sub_basic_blocks will rediscover them.
+	     find_many_sub_basic_blocks will rediscover them.
-In the future we should get this fixed properly.  */
+	     In the future we should get this fixed properly.  */
-if ((e->flags & EDGE_ABNORMAL)
+	  if ((e->flags & EDGE_ABNORMAL)
-&& !(e->flags & EDGE_SIBCALL))
+	      && !(e->flags & EDGE_SIBCALL))
-remove_edge (e);
+	    remove_edge (e);
-else
+	  else
-ei_next (&ei);
+	    ei_next (&ei);
-}
+	}
 }
 blocks = sbitmap_alloc (last_basic_block);
 sbitmap_ones (blocks);
 find_many_sub_basic_blocks (blocks);
 generating_concat_p = 0;
 if (dump_file)
 {
 fprintf (dump_file,
-"\n\n;;\n;; Full RTL generated for this function:\n;;\n");
+	       "\n\n;;\n;; Full RTL generated for this function:\n;;\n");
 /* And the pass manager will dump RTL for us.  */
 }
 /* If we're emitting a nested function, make sure its parent gets
 emitted as well.  Doing otherwise confuses debug info.  */
 {
 tree parent;
 for (parent = DECL_CONTEXT (current_function_decl);
-parent != NULL_TREE;
+	 parent != NULL_TREE;
-parent = get_containing_scope (parent))
+	 parent = get_containing_scope (parent))
 if (TREE_CODE (parent) == FUNCTION_DECL)
-TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
+	TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (parent)) = 1;
 }
 /* We are now committed to emitting code for this function.  Do any
 preparation, such as emitting abstract debug info for the inline
 before it gets mangled by optimization.  */
 struct rtl_opt_pass pass_expand =
 {
 {
 RTL_PASS,
-"expand",             /* name */
+"expand",				/* name */
 NULL,                                 /* gate */
-gimple_expand_cfg,            /* execute */
+gimple_expand_cfg,			/* execute */
 NULL,                                 /* sub */
 NULL,                                 /* next */
 0,                                    /* static_pass_number */
 TV_EXPAND,				/* tv_id */
 PROP_ssa | PROP_gimple_leh | PROP_cfg
 | PROP_gimple_lcx,			/* properties_required */
 PROP_rtl,                             /* properties_provided */
-PROP_ssa | PROP_trees,        /* properties_destroyed */
+PROP_ssa | PROP_trees,		/* properties_destroyed */
 TODO_verify_ssa | TODO_verify_flow
-| TODO_verify_stmts,        /* todo_flags_start */
+| TODO_verify_stmts,		/* todo_flags_start */
 TODO_dump_func
-| TODO_ggc_collect            /* todo_flags_finish */
+| TODO_ggc_collect			/* todo_flags_finish */
 }
 };

Mercurial > hg > CbC > CbC_gcc

comparison gcc/cfgexpand.c @ 70:b81903832de2