CbC/CbC_gcc: gcc/gimplify.c comparison

comparison gcc/gimplify.c @ 57:326d9e06c2e3

modify c-parser.c

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 15 Feb 2010 00:54:17 +0900
parents	9907f3135723 77e2b8dfacca
children	1b10fe6932e1

comparison

equal deleted inserted replaced

-:f62c169bbc24
+:326d9e06c2e3
 #include "gimple.h"
 #ifndef noCbC
 #include "cbc-tree.h"
 #endif
+#include "tree-pass.h"
 enum gimplify_omp_var_data
 {
 GOVD_SEEN = 1,
 GOVD_EXPLICIT = 2,
 GOVD_REDUCTION = 64,
 GOVD_LOCAL = 128,
 GOVD_DEBUG_PRIVATE = 256,
 GOVD_PRIVATE_OUTER_REF = 512,
 GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
-			   | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
+| GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
 };
 enum omp_region_type
 {
 /* Forward declarations.  */
 static enum gimplify_status gimplify_compound_expr (tree *, gimple_seq *, bool);
 /* Mark X addressable.  Unlike the langhook we expect X to be in gimple
 form and we don't do any syntax checking.  */
-static void
+void
 mark_addressable (tree x)
 {
 while (handled_component_p (x))
 x = TREE_OPERAND (x, 0);
-if (TREE_CODE (x) != VAR_DECL && TREE_CODE (x) != PARM_DECL)
+if (TREE_CODE (x) != VAR_DECL
+&& TREE_CODE (x) != PARM_DECL
+&& TREE_CODE (x) != RESULT_DECL)
 return ;
 TREE_ADDRESSABLE (x) = 1;
 }
 /* Return a hash value for a formal temporary table entry.  */
 void
 pop_gimplify_context (gimple body)
 {
 struct gimplify_ctx *c = gimplify_ctxp;
-tree t;
 gcc_assert (c && (c->bind_expr_stack == NULL
-		    || VEC_empty (gimple, c->bind_expr_stack)));
+|| VEC_empty (gimple, c->bind_expr_stack)));
 VEC_free (gimple, heap, c->bind_expr_stack);
 gimplify_ctxp = c->prev_context;
-for (t = c->temps; t ; t = TREE_CHAIN (t))
-DECL_GIMPLE_FORMAL_TEMP_P (t) = 0;
 if (body)
 declare_vars (c->temps, body, false);
 else
 record_vars (c->temps);
 tree_stmt_iterator i;
 if (!list)
 {
 if (t && TREE_CODE (t) == STATEMENT_LIST)
-	{
+{
-	  *list_p = t;
+*list_p = t;
-	  return;
+return;
-	}
+}
 *list_p = list = alloc_stmt_list ();
 }
 i = tsi_last (list);
 tsi_link_after (&i, t, TSI_CONTINUE_LINKING);
 int i;
 for (i = 2;  i < 8 && len > i;  i++)
 {
 if (name[len - i] == '.')
-	{
+{
-	  name[len - i] = '\0';
+name[len - i] = '\0';
-	  break;
+break;
-	}
+}
 }
-}
-/* Subroutine for find_single_pointer_decl.  */
-static tree
-find_single_pointer_decl_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
-			    void *data)
-{
-tree *pdecl = (tree *) data;
-/* We are only looking for pointers at the same level as the
-original tree; we must not look through any indirections.
-Returning anything other than NULL_TREE will cause the caller to
-not find a base.  */
-if (REFERENCE_CLASS_P (*tp))
-return *tp;
-if (DECL_P (*tp) && POINTER_TYPE_P (TREE_TYPE (*tp)))
-{
-if (*pdecl)
-	{
-	  /* We already found a pointer decl; return anything other
-	     than NULL_TREE to unwind from walk_tree signalling that
-	     we have a duplicate.  */
-	  return *tp;
-	}
-*pdecl = *tp;
-}
-return NULL_TREE;
-}
-/* Find the single DECL of pointer type in the tree T, used directly
-rather than via an indirection, and return it.  If there are zero
-or more than one such DECLs, return NULL.  */
-static tree
-find_single_pointer_decl (tree t)
-{
-tree decl = NULL_TREE;
-if (walk_tree (&t, find_single_pointer_decl_1, &decl, NULL))
-{
-/* find_single_pointer_decl_1 returns a nonzero value, causing
-	 walk_tree to return a nonzero value, to indicate that it
-	 found more than one pointer DECL or that it found an
-	 indirection.  */
-return NULL_TREE;
-}
-return decl;
 }
 /* Create a new temporary name with PREFIX.  Returns an identifier.  */
 static GTY(()) unsigned int tmp_var_id_num;
 /* Make the type of the variable writable.  */
 new_type = build_type_variant (type, 0, 0);
 TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type);
-tmp_var = build_decl (VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
+tmp_var = build_decl (input_location,
-			type);
+VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
+type);
 /* The variable was declared by the compiler.  */
 DECL_ARTIFICIAL (tmp_var) = 1;
 /* And we don't want debug info for it.  */
 DECL_IGNORED_P (tmp_var) = 1;
 void **slot;
 elt.val = val;
 if (gimplify_ctxp->temp_htab == NULL)
 gimplify_ctxp->temp_htab
-	  = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
+= htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
 slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT);
 if (*slot == NULL)
-	{
+{
-	  elt_p = XNEW (elt_t);
+elt_p = XNEW (elt_t);
-	  elt_p->val = val;
+elt_p->val = val;
-	  elt_p->temp = ret = create_tmp_from_val (val);
+elt_p->temp = ret = create_tmp_from_val (val);
-	  *slot = (void *) elt_p;
+*slot = (void *) elt_p;
-	}
+}
 else
-	{
+{
-	  elt_p = (elt_t *) *slot;
+elt_p = (elt_t *) *slot;
 ret = elt_p->temp;
-	}
+}
 }
-if (is_formal)
-DECL_GIMPLE_FORMAL_TEMP_P (ret) = 1;
 return ret;
 }
 assignmed to a temporary.  Note that this predicate should only be
 used during gimplification.  See the rationale for this in
 gimplify_modify_expr.  */
 static bool
-is_gimple_formal_tmp_or_call_rhs (tree t)
+is_gimple_reg_rhs_or_call (tree t)
 {
-return TREE_CODE (t) == CALL_EXPR || is_gimple_formal_tmp_rhs (t);
+return (get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS
-}
+|| TREE_CODE (t) == CALL_EXPR);
-/* Returns true iff T is a valid RHS for an assignment to a renamed
-user -- or front-end generated artificial -- variable.  */
-static bool
-is_gimple_reg_or_call_rhs (tree t)
-{
-/* If the RHS of the MODIFY_EXPR may throw or make a nonlocal goto
-and the LHS is a user variable, then we need to introduce a formal
-temporary.  This way the optimizers can determine that the user
-variable is only modified if evaluation of the RHS does not throw.
-Don't force a temp of a non-renamable type; the copy could be
-arbitrarily expensive.  Instead we will generate a VDEF for
-the assignment.  */
-if (is_gimple_reg_type (TREE_TYPE (t))
-&& ((TREE_CODE (t) == CALL_EXPR && TREE_SIDE_EFFECTS (t))
-	  || tree_could_throw_p (t)))
-return false;
-return is_gimple_formal_tmp_or_call_rhs (t);
 }
 /* Return true if T is a valid memory RHS or a CALL_EXPR.  Note that
 this predicate should only be used during gimplification.  See the
 rationale for this in gimplify_modify_expr.  */
 static bool
-is_gimple_mem_or_call_rhs (tree t)
+is_gimple_mem_rhs_or_call (tree t)
 {
 /* If we're dealing with a renamable type, either source or dest must be
 a renamed variable.  */
 if (is_gimple_reg_type (TREE_TYPE (t)))
 return is_gimple_val (t);
 else
-return is_gimple_formal_tmp_or_call_rhs (t);
+return (is_gimple_val (t) || is_gimple_lvalue (t)
-}
+|| TREE_CODE (t) == CALL_EXPR);
+}
+/* Helper for get_formal_tmp_var and get_initialized_tmp_var.  */
+static tree
+internal_get_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
+bool is_formal)
+{
+tree t, mod;
+/* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
+can create an INIT_EXPR and convert it into a GIMPLE_CALL below.  */
+gimplify_expr (&val, pre_p, post_p, is_gimple_reg_rhs_or_call,
+fb_rvalue);
+t = lookup_tmp_var (val, is_formal);
+if (is_formal
+&& (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
+|| TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE))
+DECL_GIMPLE_REG_P (t) = 1;
+mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
+if (EXPR_HAS_LOCATION (val))
+SET_EXPR_LOCATION (mod, EXPR_LOCATION (val));
+else
+SET_EXPR_LOCATION (mod, input_location);
+/* gimplify_modify_expr might want to reduce this further.  */
+gimplify_and_add (mod, pre_p);
+ggc_free (mod);
+/* If we're gimplifying into ssa, gimplify_modify_expr will have
+given our temporary an SSA name.  Find and return it.  */
+if (gimplify_ctxp->into_ssa)
+{
+gimple last = gimple_seq_last_stmt (*pre_p);
+t = gimple_get_lhs (last);
+}
+return t;
+}
 /* Returns a formal temporary variable initialized with VAL.  PRE_P is as
 in gimplify_expr.  Only use this function if:
 1) The value of the unfactored expression represented by VAL will not
 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
 and #2 means it is inappropriate for && temps.
 For other cases, use get_initialized_tmp_var instead.  */
-static tree
-internal_get_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
-bool is_formal)
-{
-tree t, mod;
-/* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
-can create an INIT_EXPR and convert it into a GIMPLE_CALL below.  */
-gimplify_expr (&val, pre_p, post_p, is_gimple_formal_tmp_or_call_rhs,
-		 fb_rvalue);
-t = lookup_tmp_var (val, is_formal);
-if (is_formal)
-{
-tree u = find_single_pointer_decl (val);
-if (u && TREE_CODE (u) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (u))
-	u = DECL_GET_RESTRICT_BASE (u);
-if (u && TYPE_RESTRICT (TREE_TYPE (u)))
-	{
-	  if (DECL_BASED_ON_RESTRICT_P (t))
-	    gcc_assert (u == DECL_GET_RESTRICT_BASE (t));
-	  else
-	    {
-	      DECL_BASED_ON_RESTRICT_P (t) = 1;
-	      SET_DECL_RESTRICT_BASE (t, u);
-	    }
-	}
-}
-if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
-|| TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
-DECL_GIMPLE_REG_P (t) = 1;
-mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
-if (EXPR_HAS_LOCATION (val))
-SET_EXPR_LOCUS (mod, EXPR_LOCUS (val));
-else
-SET_EXPR_LOCATION (mod, input_location);
-/* gimplify_modify_expr might want to reduce this further.  */
-gimplify_and_add (mod, pre_p);
-ggc_free (mod);
-/* If we're gimplifying into ssa, gimplify_modify_expr will have
-given our temporary an SSA name.  Find and return it.  */
-if (gimplify_ctxp->into_ssa)
-{
-gimple last = gimple_seq_last_stmt (*pre_p);
-t = gimple_get_lhs (last);
-}
-return t;
-}
-/* Returns a formal temporary variable initialized with VAL.  PRE_P
-points to a sequence where side-effects needed to compute VAL should be
-stored.  */
 tree
 get_formal_tmp_var (tree val, gimple_seq *pre_p)
 {
 return internal_get_tmp_var (val, pre_p, NULL, true);
 }
 temps = nreverse (last);
 block = gimple_bind_block (scope);
 gcc_assert (!block || TREE_CODE (block) == BLOCK);
 if (!block || !debug_info)
-	{
+{
-	  TREE_CHAIN (last) = gimple_bind_vars (scope);
+TREE_CHAIN (last) = gimple_bind_vars (scope);
-	  gimple_bind_set_vars (scope, temps);
+gimple_bind_set_vars (scope, temps);
-	}
+}
 else
-	{
+{
-	  /* We need to attach the nodes both to the BIND_EXPR and to its
+/* We need to attach the nodes both to the BIND_EXPR and to its
-	     associated BLOCK for debugging purposes.  The key point here
+associated BLOCK for debugging purposes.  The key point here
-	     is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
+is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
-	     is a subchain of the BIND_EXPR_VARS of the BIND_EXPR.  */
+is a subchain of the BIND_EXPR_VARS of the BIND_EXPR.  */
-	  if (BLOCK_VARS (block))
+if (BLOCK_VARS (block))
-	    BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
+BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
-	  else
+else
-	    {
+{
-	      gimple_bind_set_vars (scope,
+gimple_bind_set_vars (scope,
-	      			    chainon (gimple_bind_vars (scope), temps));
+chainon (gimple_bind_vars (scope), temps));
-	      BLOCK_VARS (block) = temps;
+BLOCK_VARS (block) = temps;
-	    }
+}
-	}
+}
 }
 }
 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly.  Abort if
 TREE_CHAIN (tmp) = gimplify_ctxp->temps;
 gimplify_ctxp->temps = tmp;
 /* Mark temporaries local within the nearest enclosing parallel.  */
 if (gimplify_omp_ctxp)
-	{
+{
-	  struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
+struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
-	  while (ctx && ctx->region_type == ORT_WORKSHARE)
+while (ctx && ctx->region_type == ORT_WORKSHARE)
-	    ctx = ctx->outer_context;
+ctx = ctx->outer_context;
-	  if (ctx)
+if (ctx)
-	    omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
+omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
-	}
+}
 }
 else if (cfun)
 record_vars (tmp);
 else
 {
 gimple_seq body_seq;
 /* This case is for nested functions.  We need to expose the locals
-	 they create.  */
+they create.  */
 body_seq = gimple_body (current_function_decl);
 declare_vars (tmp, gimple_seq_first_stmt (body_seq), false);
 }
 }
 return false;
 return true;
 }
-/* Same, but for a tree.  */
-static bool
-tree_should_carry_location_p (const_tree stmt)
-{
-/* Don't emit a line note for a label.  We particularly don't want to
-emit one for the break label, since it doesn't actually correspond
-to the beginning of the loop/switch.  */
-if (TREE_CODE (stmt) == LABEL_EXPR)
-return false;
-/* Do not annotate empty statements, since it confuses gcov.  */
-if (!TREE_SIDE_EFFECTS (stmt))
-return false;
-return true;
-}
 /* Return true if a location should not be emitted for this statement
 by annotate_one_with_location.  */
 static inline bool
 /* The PLF flags are initialized to 0 when a new tuple is created,
 so no need to initialize it anywhere.  */
 gimple_set_plf (g, GF_PLF_1, true);
 }
-/* Set the location for gimple statement GS to LOCUS.  */
+/* Set the location for gimple statement GS to LOCATION.  */
 static void
 annotate_one_with_location (gimple gs, location_t location)
 {
 if (!gimple_has_location (gs)
 && !gimple_do_not_emit_location_p (gs)
 && should_carry_location_p (gs))
 gimple_set_location (gs, location);
 }
-/* Same, but for tree T.  */
-static void
-tree_annotate_one_with_location (tree t, location_t location)
-{
-if (CAN_HAVE_LOCATION_P (t)
-&& ! EXPR_HAS_LOCATION (t) && tree_should_carry_location_p (t))
-SET_EXPR_LOCATION (t, location);
-}
 /* Set LOCATION for all the statements after iterator GSI in sequence
 SEQ.  If GSI is pointing to the end of the sequence, start with the
 first statement in SEQ.  */
 static void
 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
-				  location_t location)
+location_t location)
 {
 if (gsi_end_p (gsi))
 gsi = gsi_start (seq);
 else
 gsi_next (&gsi);
 for (; !gsi_end_p (gsi); gsi_next (&gsi))
 annotate_one_with_location (gsi_stmt (gsi), location);
 }
-/* Set the location for all the statements in a sequence STMT_P to LOCUS.  */
+/* Set the location for all the statements in a sequence STMT_P to LOCATION.  */
 void
 annotate_all_with_location (gimple_seq stmt_p, location_t location)
 {
 gimple_stmt_iterator i;
 for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
 {
 gimple gs = gsi_stmt (i);
 annotate_one_with_location (gs, location);
-}
-}
-/* Same, but for statement or statement list in *STMT_P.  */
-void
-tree_annotate_all_with_location (tree *stmt_p, location_t location)
-{
-tree_stmt_iterator i;
-if (!*stmt_p)
-return;
-for (i = tsi_start (*stmt_p); !tsi_end_p (i); tsi_next (&i))
-{
-tree t = tsi_stmt (i);
-/* Assuming we've already been gimplified, we shouldn't
-	  see nested chaining constructs anymore.  */
-gcc_assert (TREE_CODE (t) != STATEMENT_LIST
-		  && TREE_CODE (t) != COMPOUND_EXPR);
-tree_annotate_one_with_location (t, location);
 }
 }
 /* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes.
 if (TREE_CODE_CLASS (code) == tcc_type
 || TREE_CODE_CLASS (code) == tcc_declaration
 || TREE_CODE_CLASS (code) == tcc_constant
 || code == SAVE_EXPR || code == TARGET_EXPR
 /* We can't do anything sensible with a BLOCK used as an expression,
-	 but we also can't just die when we see it because of non-expression
+but we also can't just die when we see it because of non-expression
-	 uses.  So just avert our eyes and cross our fingers.  Silly Java.  */
+uses.  So just avert our eyes and cross our fingers.  Silly Java.  */
 || code == BLOCK)
 *walk_subtrees = 0;
 else
 {
 gcc_assert (code != BIND_EXPR);
 done once.  If we were to unshare something like SAVE_EXPR(i++), the
 gimplification process would create wrong code.  */
 static tree
 copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
-		  void *data ATTRIBUTE_UNUSED)
+void *data ATTRIBUTE_UNUSED)
 {
 tree t = *tp;
 enum tree_code code = TREE_CODE (t);
 /* Skip types, decls, and constants.  But we do want to look at their
 if (TREE_CODE_CLASS (code) == tcc_type
 || TREE_CODE_CLASS (code) == tcc_declaration
 || TREE_CODE_CLASS (code) == tcc_constant)
 {
 if (TREE_VISITED (t))
-	*walk_subtrees = 0;
+*walk_subtrees = 0;
 else
-	TREE_VISITED (t) = 1;
+TREE_VISITED (t) = 1;
 }
 /* If this node has been visited already, unshare it and don't look
 any deeper.  */
 else if (TREE_VISITED (t))
 return NULL_TREE;
 }
 static tree
 unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
-		  void *data ATTRIBUTE_UNUSED)
+void *data ATTRIBUTE_UNUSED)
 {
 if (TREE_VISITED (*tp))
 TREE_VISITED (*tp) = 0;
 else
 *walk_subtrees = 0;
 if (type && !VOID_TYPE_P (type))
 {
 tree *p;
 /* Set p to point to the body of the wrapper.  Loop until we find
-	 something that isn't a wrapper.  */
+something that isn't a wrapper.  */
 for (p = &wrapper; p && *p; )
-	{
+{
-	  switch (TREE_CODE (*p))
+switch (TREE_CODE (*p))
-	    {
+{
-	    case BIND_EXPR:
+case BIND_EXPR:
-	      TREE_SIDE_EFFECTS (*p) = 1;
+TREE_SIDE_EFFECTS (*p) = 1;
-	      TREE_TYPE (*p) = void_type_node;
+TREE_TYPE (*p) = void_type_node;
-	      /* For a BIND_EXPR, the body is operand 1.  */
+/* For a BIND_EXPR, the body is operand 1.  */
-	      p = &BIND_EXPR_BODY (*p);
+p = &BIND_EXPR_BODY (*p);
-	      break;
+break;
-	    case CLEANUP_POINT_EXPR:
+case CLEANUP_POINT_EXPR:
-	    case TRY_FINALLY_EXPR:
+case TRY_FINALLY_EXPR:
-	    case TRY_CATCH_EXPR:
+case TRY_CATCH_EXPR:
-	      TREE_SIDE_EFFECTS (*p) = 1;
+TREE_SIDE_EFFECTS (*p) = 1;
-	      TREE_TYPE (*p) = void_type_node;
+TREE_TYPE (*p) = void_type_node;
-	      p = &TREE_OPERAND (*p, 0);
+p = &TREE_OPERAND (*p, 0);
-	      break;
+break;
-	    case STATEMENT_LIST:
+case STATEMENT_LIST:
-	      {
+{
-		tree_stmt_iterator i = tsi_last (*p);
+tree_stmt_iterator i = tsi_last (*p);
-		TREE_SIDE_EFFECTS (*p) = 1;
+TREE_SIDE_EFFECTS (*p) = 1;
-		TREE_TYPE (*p) = void_type_node;
+TREE_TYPE (*p) = void_type_node;
-		p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
+p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
-	      }
+}
-	      break;
+break;
-	    case COMPOUND_EXPR:
+case COMPOUND_EXPR:
-	      /* Advance to the last statement.  Set all container types to void.  */
+/* Advance to the last statement.  Set all container types to void.  */
-	      for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
+for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
-		{
+{
-		  TREE_SIDE_EFFECTS (*p) = 1;
+TREE_SIDE_EFFECTS (*p) = 1;
-		  TREE_TYPE (*p) = void_type_node;
+TREE_TYPE (*p) = void_type_node;
-		}
+}
-	      break;
+break;
-	    default:
+default:
-	      goto out;
+goto out;
-	    }
+}
-	}
+}
 out:
 if (p == NULL || IS_EMPTY_STMT (*p))
-	temp = NULL_TREE;
+temp = NULL_TREE;
 else if (temp)
-	{
+{
-	  /* The wrapper is on the RHS of an assignment that we're pushing
+/* The wrapper is on the RHS of an assignment that we're pushing
-	     down.  */
+down.  */
-	  gcc_assert (TREE_CODE (temp) == INIT_EXPR
+gcc_assert (TREE_CODE (temp) == INIT_EXPR
-		      || TREE_CODE (temp) == MODIFY_EXPR);
+|| TREE_CODE (temp) == MODIFY_EXPR);
-	  TREE_OPERAND (temp, 1) = *p;
+TREE_OPERAND (temp, 1) = *p;
-	  *p = temp;
+*p = temp;
-	}
+}
 else
-	{
+{
-	  temp = create_tmp_var (type, "retval");
+temp = create_tmp_var (type, "retval");
-	  *p = build2 (INIT_EXPR, type, temp, *p);
+*p = build2 (INIT_EXPR, type, temp, *p);
-	}
+}
 return temp;
 }
 return NULL_TREE;
 *save = gimple_build_call (implicit_built_in_decls[BUILT_IN_STACK_SAVE], 0);
 tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
 gimple_call_set_lhs (*save, tmp_var);
 *restore = gimple_build_call (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
-			    1, tmp_var);
+1, tmp_var);
 }
 /* Gimplify a BIND_EXPR.  Just voidify and recurse.  */
 static enum gimplify_status
 /* Mark variables seen in this bind expr.  */
 for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t))
 {
 if (TREE_CODE (t) == VAR_DECL)
-	{
+{
-	  struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
+struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
-	  /* Mark variable as local.  */
+/* Mark variable as local.  */
-	  if (ctx && !is_global_var (t)
+if (ctx && !is_global_var (t)
-	      && (! DECL_SEEN_IN_BIND_EXPR_P (t)
+&& (! DECL_SEEN_IN_BIND_EXPR_P (t)
-		  || splay_tree_lookup (ctx->variables,
+|| splay_tree_lookup (ctx->variables,
-					(splay_tree_key) t) == NULL))
+(splay_tree_key) t) == NULL))
-	    omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN);
+omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN);
-	  DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
+DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
-	  if (DECL_HARD_REGISTER (t) && !is_global_var (t) && cfun)
+if (DECL_HARD_REGISTER (t) && !is_global_var (t) && cfun)
-	    cfun->has_local_explicit_reg_vars = true;
+cfun->has_local_explicit_reg_vars = true;
-	}
+}
 /* Preliminarily mark non-addressed complex variables as eligible
-	 for promotion to gimple registers.  We'll transform their uses
+for promotion to gimple registers.  We'll transform their uses
-	 as we find them.  */
+as we find them.
-if ((TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
+We exclude complex types if not optimizing because they can be
-	   || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
+subject to partial stores in GNU C by means of the __real__ and
-	  && !TREE_THIS_VOLATILE (t)
+__imag__ operators and we cannot promote them to total stores
-	  && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
+(see gimplify_modify_expr_complex_part).  */
-	  && !needs_to_live_in_memory (t))
+if (optimize
-	DECL_GIMPLE_REG_P (t) = 1;
+&& (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
+|| TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
+&& !TREE_THIS_VOLATILE (t)
+&& (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
+&& !needs_to_live_in_memory (t))
+DECL_GIMPLE_REG_P (t) = 1;
 }
 gimple_bind = gimple_build_bind (BIND_EXPR_VARS (bind_expr), NULL,
 BIND_EXPR_BLOCK (bind_expr));
 gimple_push_bind_expr (gimple_bind);
 {
 gimple stack_save, stack_restore, gs;
 gimple_seq cleanup, new_body;
 /* Save stack on entry and restore it on exit.  Add a try_finally
-	 block to achieve this.  Note that mudflap depends on the
+block to achieve this.  Note that mudflap depends on the
-	 format of the emitted code: see mx_register_decls().  */
+format of the emitted code: see mx_register_decls().  */
 build_stack_save_restore (&stack_save, &stack_restore);
 cleanup = new_body = NULL;
 gimplify_seq_add_stmt (&cleanup, stack_restore);
 gs = gimple_build_try (gimple_bind_body (gimple_bind), cleanup,
-	  		     GIMPLE_TRY_FINALLY);
+GIMPLE_TRY_FINALLY);
 gimplify_seq_add_stmt (&new_body, stack_save);
 gimplify_seq_add_stmt (&new_body, gs);
 gimple_bind_set_body (gimple_bind, new_body);
 }
 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
 gimplify_seq_add_stmt (pre_p, ret);
 return GS_ALL_DONE;
 }
 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
 #ifndef noCbC
 || ( ret_expr
 && TREE_CODE(ret_expr)==CALL_EXPR
-	   && CbC_IS_CbC_GOTO(ret_expr)
+&& CbC_IS_CbC_GOTO(ret_expr)
-	   //&& !CbC_IS_CODE_SEGMENT(TREE_TYPE(current_function_decl)))
+//&& !CbC_IS_CODE_SEGMENT(TREE_TYPE(current_function_decl)))
-	   && !(current_function_decl&&CbC_IS_CODE_SEGMENT(TREE_TYPE(current_function_decl))))
+&& !(current_function_decl&&CbC_IS_CODE_SEGMENT(TREE_TYPE(current_function_decl))))
-	   //&& !(current_function_decl&&CbC_IS_CODE_SEGMENT(current_function_decl)))
+//&& !(current_function_decl&&CbC_IS_CODE_SEGMENT(current_function_decl)))
 #endif
 )
 result_decl = NULL_TREE;
 else
 {
 result_decl = TREE_OPERAND (ret_expr, 0);
 /* See through a return by reference.  */
 if (TREE_CODE (result_decl) == INDIRECT_REF)
-	result_decl = TREE_OPERAND (result_decl, 0);
+result_decl = TREE_OPERAND (result_decl, 0);
 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
-		   || TREE_CODE (ret_expr) == INIT_EXPR)
+|| TREE_CODE (ret_expr) == INIT_EXPR)
-		  && TREE_CODE (result_decl) == RESULT_DECL);
+&& TREE_CODE (result_decl) == RESULT_DECL);
 }
 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
 Recall that aggregate_value_p is FALSE for any aggregate type that is
 returned in registers.  If we're returning values in registers, then
 if (TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
 DECL_GIMPLE_REG_P (result) = 1;
 /* ??? With complex control flow (usually involving abnormal edges),
-	 we can wind up warning about an uninitialized value for this.  Due
+we can wind up warning about an uninitialized value for this.  Due
-	 to how this variable is constructed and initialized, this is never
+to how this variable is constructed and initialized, this is never
-	 true.  Give up and never warn.  */
+true.  Give up and never warn.  */
 TREE_NO_WARNING (result) = 1;
 gimplify_ctxp->return_temp = result;
 }
 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
 {
 tree init = DECL_INITIAL (decl);
 if (TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
-	  || (!TREE_STATIC (decl)
+|| (!TREE_STATIC (decl)
-	      && flag_stack_check == GENERIC_STACK_CHECK
+&& flag_stack_check == GENERIC_STACK_CHECK
-	      && compare_tree_int (DECL_SIZE_UNIT (decl),
+&& compare_tree_int (DECL_SIZE_UNIT (decl),
-				   STACK_CHECK_MAX_VAR_SIZE) > 0))
+STACK_CHECK_MAX_VAR_SIZE) > 0))
-	gimplify_vla_decl (decl, seq_p);
+gimplify_vla_decl (decl, seq_p);
 if (init && init != error_mark_node)
-	{
+{
-	  if (!TREE_STATIC (decl))
+if (!TREE_STATIC (decl))
-	    {
+{
-	      DECL_INITIAL (decl) = NULL_TREE;
+DECL_INITIAL (decl) = NULL_TREE;
-	      init = build2 (INIT_EXPR, void_type_node, decl, init);
+init = build2 (INIT_EXPR, void_type_node, decl, init);
-	      gimplify_and_add (init, seq_p);
+gimplify_and_add (init, seq_p);
-	      ggc_free (init);
+ggc_free (init);
-	    }
+}
-	  else
+else
-	    /* We must still examine initializers for static variables
+/* We must still examine initializers for static variables
-	       as they may contain a label address.  */
+as they may contain a label address.  */
-	    walk_tree (&init, force_labels_r, NULL, NULL);
+walk_tree (&init, force_labels_r, NULL, NULL);
-	}
+}
 /* Some front ends do not explicitly declare all anonymous
-	 artificial variables.  We compensate here by declaring the
+artificial variables.  We compensate here by declaring the
-	 variables, though it would be better if the front ends would
+variables, though it would be better if the front ends would
-	 explicitly declare them.  */
+explicitly declare them.  */
 if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
-	  && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
+&& DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
-	gimple_add_tmp_var (decl);
+gimple_add_tmp_var (decl);
 }
 return GS_ALL_DONE;
 }
 static enum gimplify_status
 gimplify_loop_expr (tree *expr_p, gimple_seq *pre_p)
 {
 tree saved_label = gimplify_ctxp->exit_label;
-tree start_label = create_artificial_label ();
+tree start_label = create_artificial_label (UNKNOWN_LOCATION);
 gimplify_seq_add_stmt (pre_p, gimple_build_label (start_label));
 gimplify_ctxp->exit_label = NULL_TREE;
 VEC (tree,heap) *labels;
 VEC (tree,heap) *saved_labels;
 tree default_case = NULL_TREE;
 size_t i, len;
 gimple gimple_switch;
 /* If someone can be bothered to fill in the labels, they can
-	 be bothered to null out the body too.  */
+be bothered to null out the body too.  */
 gcc_assert (!SWITCH_LABELS (switch_expr));
 /* save old labels, get new ones from body, then restore the old
 labels.  Save all the things from the switch body to append after.  */
 saved_labels = gimplify_ctxp->case_labels;
 gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
 gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
 labels = gimplify_ctxp->case_labels;
 gimplify_ctxp->case_labels = saved_labels;
 i = 0;
 while (i < VEC_length (tree, labels))
-	{
+{
-	  tree elt = VEC_index (tree, labels, i);
+tree elt = VEC_index (tree, labels, i);
-	  tree low = CASE_LOW (elt);
+tree low = CASE_LOW (elt);
-	  bool remove_element = FALSE;
+bool remove_element = FALSE;
-	  if (low)
+if (low)
-	    {
+{
-	      /* Discard empty ranges.  */
+/* Discard empty ranges.  */
-	      tree high = CASE_HIGH (elt);
+tree high = CASE_HIGH (elt);
-	      if (high && tree_int_cst_lt (high, low))
+if (high && tree_int_cst_lt (high, low))
-	        remove_element = TRUE;
+remove_element = TRUE;
-	    }
+}
-	  else
+else
-	    {
+{
-	      /* The default case must be the last label in the list.  */
+/* The default case must be the last label in the list.  */
-	      gcc_assert (!default_case);
+gcc_assert (!default_case);
-	      default_case = elt;
+default_case = elt;
-	      remove_element = TRUE;
+remove_element = TRUE;
-	    }
+}
-	  if (remove_element)
+if (remove_element)
-	    VEC_ordered_remove (tree, labels, i);
+VEC_ordered_remove (tree, labels, i);
-	  else
+else
-	    i++;
+i++;
-	}
+}
 len = i;
 if (!VEC_empty (tree, labels))
-	sort_case_labels (labels);
+sort_case_labels (labels);
 if (!default_case)
-	{
+{
-	  tree type = TREE_TYPE (switch_expr);
+tree type = TREE_TYPE (switch_expr);
-	  /* If the switch has no default label, add one, so that we jump
+/* If the switch has no default label, add one, so that we jump
-	     around the switch body.  If the labels already cover the whole
+around the switch body.  If the labels already cover the whole
-	     range of type, add the default label pointing to one of the
+range of type, add the default label pointing to one of the
-	     existing labels.  */
+existing labels.  */
-	  if (type == void_type_node)
+if (type == void_type_node)
-	    type = TREE_TYPE (SWITCH_COND (switch_expr));
+type = TREE_TYPE (SWITCH_COND (switch_expr));
-	  if (len
+if (len
-	      && INTEGRAL_TYPE_P (type)
+&& INTEGRAL_TYPE_P (type)
-	      && TYPE_MIN_VALUE (type)
+&& TYPE_MIN_VALUE (type)
-	      && TYPE_MAX_VALUE (type)
+&& TYPE_MAX_VALUE (type)
-	      && tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)),
+&& tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)),
-				     TYPE_MIN_VALUE (type)))
+TYPE_MIN_VALUE (type)))
-	    {
+{
-	      tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1));
+tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1));
-	      if (!high)
+if (!high)
-		high = CASE_LOW (VEC_index (tree, labels, len - 1));
+high = CASE_LOW (VEC_index (tree, labels, len - 1));
-	      if (tree_int_cst_equal (high, TYPE_MAX_VALUE (type)))
+if (tree_int_cst_equal (high, TYPE_MAX_VALUE (type)))
-		{
+{
-		  for (i = 1; i < len; i++)
+for (i = 1; i < len; i++)
-		    {
+{
-		      high = CASE_LOW (VEC_index (tree, labels, i));
+high = CASE_LOW (VEC_index (tree, labels, i));
-		      low = CASE_HIGH (VEC_index (tree, labels, i - 1));
+low = CASE_HIGH (VEC_index (tree, labels, i - 1));
-		      if (!low)
+if (!low)
-			low = CASE_LOW (VEC_index (tree, labels, i - 1));
+low = CASE_LOW (VEC_index (tree, labels, i - 1));
-		      if ((TREE_INT_CST_LOW (low) + 1
+if ((TREE_INT_CST_LOW (low) + 1
-			   != TREE_INT_CST_LOW (high))
+!= TREE_INT_CST_LOW (high))
-			  || (TREE_INT_CST_HIGH (low)
+|| (TREE_INT_CST_HIGH (low)
-			      + (TREE_INT_CST_LOW (high) == 0)
++ (TREE_INT_CST_LOW (high) == 0)
-			      != TREE_INT_CST_HIGH (high)))
+!= TREE_INT_CST_HIGH (high)))
-			break;
+break;
-		    }
+}
-		  if (i == len)
+if (i == len)
-		    default_case = build3 (CASE_LABEL_EXPR, void_type_node,
+default_case = build3 (CASE_LABEL_EXPR, void_type_node,
-					   NULL_TREE, NULL_TREE,
+NULL_TREE, NULL_TREE,
-					   CASE_LABEL (VEC_index (tree,
+CASE_LABEL (VEC_index (tree,
-								  labels, 0)));
+labels, 0)));
-		}
+}
-	    }
+}
-	  if (!default_case)
+if (!default_case)
-	    {
+{
-	      gimple new_default;
+gimple new_default;
-	      default_case = build3 (CASE_LABEL_EXPR, void_type_node,
+default_case
-				     NULL_TREE, NULL_TREE,
+= build3 (CASE_LABEL_EXPR, void_type_node,
-				     create_artificial_label ());
+NULL_TREE, NULL_TREE,
-	      new_default = gimple_build_label (CASE_LABEL (default_case));
+create_artificial_label (UNKNOWN_LOCATION));
-	      gimplify_seq_add_stmt (&switch_body_seq, new_default);
+new_default = gimple_build_label (CASE_LABEL (default_case));
-	    }
+gimplify_seq_add_stmt (&switch_body_seq, new_default);
-	}
+}
+}
-gimple_switch = gimple_build_switch_vec (SWITCH_COND (switch_expr),
+gimple_switch = gimple_build_switch_vec (SWITCH_COND (switch_expr),
 default_case, labels);
 gimplify_seq_add_stmt (pre_p, gimple_switch);
 gimplify_seq_add_seq (pre_p, switch_body_seq);
 VEC_free(tree, heap, labels);
 }
 /* If there's nowhere to jump, just fall through.  */
 return NULL_TREE;
 if (*label_p == NULL_TREE)
 {
-tree label = create_artificial_label ();
+tree label = create_artificial_label (UNKNOWN_LOCATION);
 *label_p = label;
 }
 return build1 (GOTO_EXPR, void_type_node, *label_p);
 }
 tree old_type = TREE_TYPE (expr);
 #endif
 int type_quals;
 /* We need to preserve qualifiers and propagate them from
-	 operand 0.  */
+operand 0.  */
 type_quals = TYPE_QUALS (type)
-	| TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
+| TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
 if (TYPE_QUALS (type) != type_quals)
-	type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
+type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
 /* Set the type of the COMPONENT_REF to the underlying type.  */
 TREE_TYPE (expr) = type;
 #ifdef ENABLE_TYPES_CHECKING
 /* It is now a FE error, if the conversion from the canonical
-	 type to the original expression type is not useless.  */
+type to the original expression type is not useless.  */
 gcc_assert (useless_type_conversion_p (old_type, type));
 #endif
 }
 }
 /* The pointer to element type shall be trivially convertible to
 the expression pointer type.  */
 ddatype = TREE_TYPE (datype);
 pddatype = build_pointer_type (ddatype);
-if (!useless_type_conversion_p (pddatype, ddatype))
+if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)),
+pddatype))
 return;
 /* The lower bound and element sizes must be constant.  */
 if (!TYPE_SIZE_UNIT (ddatype)
 || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
 return;
 /* All checks succeeded.  Build a new node to merge the cast.  */
 *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
-		    TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
+TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
-		    NULL_TREE, NULL_TREE);
+NULL_TREE, NULL_TREE);
 *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
+/* We can have stripped a required restrict qualifier above.  */
+if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
+*expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
 }
 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR.  Remove it and/or other conversions
 underneath as appropriate.  */
 static enum gimplify_status
 gimplify_conversion (tree *expr_p)
 {
 tree tem;
+location_t loc = EXPR_LOCATION (*expr_p);
 gcc_assert (CONVERT_EXPR_P (*expr_p));
 /* Then strip away all but the outermost conversion.  */
 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
 /* And remove the outermost conversion if it's useless.  */
 if (tree_ssa_useless_type_conversion (*expr_p))
 a need for statement.  */
 if (CONVERT_EXPR_P (*expr_p)
 && POINTER_TYPE_P (TREE_TYPE (*expr_p))
 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 0)))
 && (tem = maybe_fold_offset_to_address
-		  (TREE_OPERAND (*expr_p, 0),
+(EXPR_LOCATION (*expr_p), TREE_OPERAND (*expr_p, 0),
-		   integer_zero_node, TREE_TYPE (*expr_p))) != NULL_TREE)
+integer_zero_node, TREE_TYPE (*expr_p))) != NULL_TREE)
 *expr_p = tem;
 /* If we still have a conversion at the toplevel,
 then canonicalize some constructs.  */
 if (CONVERT_EXPR_P (*expr_p))
 {
 tree sub = TREE_OPERAND (*expr_p, 0);
 /* If a NOP conversion is changing the type of a COMPONENT_REF
-	 expression, then canonicalize its type now in order to expose more
+expression, then canonicalize its type now in order to expose more
-	 redundant conversions.  */
+redundant conversions.  */
 if (TREE_CODE (sub) == COMPONENT_REF)
-	canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
+canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
 /* If a NOP conversion is changing a pointer to array of foo
-	 to a pointer to foo, embed that change in the ADDR_EXPR.  */
+to a pointer to foo, embed that change in the ADDR_EXPR.  */
 else if (TREE_CODE (sub) == ADDR_EXPR)
-	canonicalize_addr_expr (expr_p);
+canonicalize_addr_expr (expr_p);
 }
 /* If we have a conversion to a non-register type force the
 use of a VIEW_CONVERT_EXPR instead.  */
 if (CONVERT_EXPR_P (*expr_p) && !is_gimple_reg_type (TREE_TYPE (*expr_p)))
-*expr_p = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
+*expr_p = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
-			   TREE_OPERAND (*expr_p, 0));
+TREE_OPERAND (*expr_p, 0));
 return GS_OK;
 }
-/* Gimplify a VAR_DECL or PARM_DECL.  Returns GS_OK if we expanded a
+/* Nonlocal VLAs seen in the current function.  */
+static struct pointer_set_t *nonlocal_vlas;
+/* Gimplify a VAR_DECL or PARM_DECL.  Returns GS_OK if we expanded a
 DECL_VALUE_EXPR, and it's worth re-examining things.  */
 static enum gimplify_status
 gimplify_var_or_parm_decl (tree *expr_p)
 {
 return GS_ALL_DONE;
 /* If the decl is an alias for another expression, substitute it now.  */
 if (DECL_HAS_VALUE_EXPR_P (decl))
 {
-*expr_p = unshare_expr (DECL_VALUE_EXPR (decl));
+tree value_expr = DECL_VALUE_EXPR (decl);
+/* For referenced nonlocal VLAs add a decl for debugging purposes
+to the current function.  */
+if (TREE_CODE (decl) == VAR_DECL
+&& TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
+&& nonlocal_vlas != NULL
+&& TREE_CODE (value_expr) == INDIRECT_REF
+&& TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
+&& decl_function_context (decl) != current_function_decl)
+{
+struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
+while (ctx && ctx->region_type == ORT_WORKSHARE)
+ctx = ctx->outer_context;
+if (!ctx && !pointer_set_insert (nonlocal_vlas, decl))
+{
+tree copy = copy_node (decl), block;
+lang_hooks.dup_lang_specific_decl (copy);
+SET_DECL_RTL (copy, NULL_RTX);
+TREE_USED (copy) = 1;
+block = DECL_INITIAL (current_function_decl);
+TREE_CHAIN (copy) = BLOCK_VARS (block);
+BLOCK_VARS (block) = copy;
+SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
+DECL_HAS_VALUE_EXPR_P (copy) = 1;
+}
+}
+*expr_p = unshare_expr (value_expr);
 return GS_OK;
 }
 return GS_ALL_DONE;
 }
 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
 node *EXPR_P.
 compound_lval
-	      : min_lval '[' val ']'
+: min_lval '[' val ']'
-	      | min_lval '.' ID
+| min_lval '.' ID
-	      | compound_lval '[' val ']'
+| compound_lval '[' val ']'
-	      | compound_lval '.' ID
+| compound_lval '.' ID
 This is not part of the original SIMPLE definition, which separates
 array and member references, but it seems reasonable to handle them
 together.  Also, this way we don't run into problems with union
 aliasing; gcc requires that for accesses through a union to alias, the
 POST_P points to the sequence where side effects that must happen after
 *EXPR_P should be stored.  */
 static enum gimplify_status
 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
-			fallback_t fallback)
+fallback_t fallback)
 {
 tree *p;
 VEC(tree,heap) *stack;
 enum gimplify_status ret = GS_OK, tret;
 int i;
+location_t loc = EXPR_LOCATION (*expr_p);
 /* Create a stack of the subexpressions so later we can walk them in
 order from inner to outer.  */
 stack = VEC_alloc (tree, heap, 10);
 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
 {
 restart:
 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs.  */
 if (TREE_CODE (*p) == INDIRECT_REF)
-	*p = fold_indirect_ref (*p);
+*p = fold_indirect_ref_loc (loc, *p);
 if (handled_component_p (*p))
-	;
+;
 /* Expand DECL_VALUE_EXPR now.  In some cases that may expose
-	 additional COMPONENT_REFs.  */
+additional COMPONENT_REFs.  */
 else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
-	       && gimplify_var_or_parm_decl (p) == GS_OK)
+&& gimplify_var_or_parm_decl (p) == GS_OK)
-	goto restart;
+goto restart;
 else
-	break;
+break;
 VEC_safe_push (tree, heap, stack, *p);
 }
 gcc_assert (VEC_length (tree, stack));
 for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
 {
 tree t = VEC_index (tree, stack, i);
 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
-	{
+{
-	  /* Gimplify the low bound and element type size and put them into
+/* Gimplify the low bound and element type size and put them into
-	     the ARRAY_REF.  If these values are set, they have already been
+the ARRAY_REF.  If these values are set, they have already been
-	     gimplified.  */
+gimplified.  */
-	  if (TREE_OPERAND (t, 2) == NULL_TREE)
+if (TREE_OPERAND (t, 2) == NULL_TREE)
-	    {
+{
-	      tree low = unshare_expr (array_ref_low_bound (t));
+tree low = unshare_expr (array_ref_low_bound (t));
-	      if (!is_gimple_min_invariant (low))
+if (!is_gimple_min_invariant (low))
-		{
+{
-		  TREE_OPERAND (t, 2) = low;
+TREE_OPERAND (t, 2) = low;
-		  tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
+tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
-					post_p, is_gimple_formal_tmp_reg,
+post_p, is_gimple_reg,
-					fb_rvalue);
+fb_rvalue);
-		  ret = MIN (ret, tret);
+ret = MIN (ret, tret);
-		}
+}
-	    }
+}
-	  if (!TREE_OPERAND (t, 3))
+if (!TREE_OPERAND (t, 3))
-	    {
+{
-	      tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
+tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
-	      tree elmt_size = unshare_expr (array_ref_element_size (t));
+tree elmt_size = unshare_expr (array_ref_element_size (t));
-	      tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
+tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
-	      /* Divide the element size by the alignment of the element
+/* Divide the element size by the alignment of the element
-		 type (above).  */
+type (above).  */
-	      elmt_size = size_binop (EXACT_DIV_EXPR, elmt_size, factor);
+elmt_size = size_binop_loc (loc, EXACT_DIV_EXPR, elmt_size, factor);
-	      if (!is_gimple_min_invariant (elmt_size))
+if (!is_gimple_min_invariant (elmt_size))
-		{
+{
-		  TREE_OPERAND (t, 3) = elmt_size;
+TREE_OPERAND (t, 3) = elmt_size;
-		  tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
+tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
-					post_p, is_gimple_formal_tmp_reg,
+post_p, is_gimple_reg,
-					fb_rvalue);
+fb_rvalue);
-		  ret = MIN (ret, tret);
+ret = MIN (ret, tret);
-		}
+}
-	    }
+}
-	}
+}
 else if (TREE_CODE (t) == COMPONENT_REF)
-	{
+{
-	  /* Set the field offset into T and gimplify it.  */
+/* Set the field offset into T and gimplify it.  */
-	  if (!TREE_OPERAND (t, 2))
+if (!TREE_OPERAND (t, 2))
-	    {
+{
-	      tree offset = unshare_expr (component_ref_field_offset (t));
+tree offset = unshare_expr (component_ref_field_offset (t));
-	      tree field = TREE_OPERAND (t, 1);
+tree field = TREE_OPERAND (t, 1);
-	      tree factor
+tree factor
-		= size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
+= size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
-	      /* Divide the offset by its alignment.  */
+/* Divide the offset by its alignment.  */
-	      offset = size_binop (EXACT_DIV_EXPR, offset, factor);
+offset = size_binop_loc (loc, EXACT_DIV_EXPR, offset, factor);
-	      if (!is_gimple_min_invariant (offset))
+if (!is_gimple_min_invariant (offset))
-		{
+{
-		  TREE_OPERAND (t, 2) = offset;
+TREE_OPERAND (t, 2) = offset;
-		  tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
+tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
-					post_p, is_gimple_formal_tmp_reg,
+post_p, is_gimple_reg,
-					fb_rvalue);
+fb_rvalue);
-		  ret = MIN (ret, tret);
+ret = MIN (ret, tret);
-		}
+}
-	    }
+}
-	}
+}
 }
 /* Step 2 is to gimplify the base expression.  Make sure lvalue is set
 so as to match the min_lval predicate.  Failure to do so may result
 in the creation of large aggregate temporaries.  */
 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
-			fallback | fb_lvalue);
+fallback | fb_lvalue);
 ret = MIN (ret, tret);
 /* And finally, the indices and operands to BIT_FIELD_REF.  During this
 loop we also remove any useless conversions.  */
 for (; VEC_length (tree, stack) > 0; )
 {
 tree t = VEC_pop (tree, stack);
 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
-	{
+{
-	  /* Gimplify the dimension.
+/* Gimplify the dimension.  */
-	     Temporary fix for gcc.c-torture/execute/20040313-1.c.
+if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
-	     Gimplify non-constant array indices into a temporary
+{
-	     variable.
+tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
-	     FIXME - The real fix is to gimplify post-modify
+is_gimple_val, fb_rvalue);
-	     expressions into a minimal gimple lvalue.  However, that
+ret = MIN (ret, tret);
-	     exposes bugs in alias analysis.  The alias analyzer does
+}
-	     not handle &PTR->FIELD very well.  Will fix after the
+}
-	     branch is merged into mainline (dnovillo 2004-05-03).  */
-	  if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
-	    {
-	      tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
-				    is_gimple_formal_tmp_reg, fb_rvalue);
-	      ret = MIN (ret, tret);
-	    }
-	}
 else if (TREE_CODE (t) == BIT_FIELD_REF)
-	{
+{
-	  tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
+tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
-				is_gimple_val, fb_rvalue);
+is_gimple_val, fb_rvalue);
-	  ret = MIN (ret, tret);
+ret = MIN (ret, tret);
-	  tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
+tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
-				is_gimple_val, fb_rvalue);
+is_gimple_val, fb_rvalue);
-	  ret = MIN (ret, tret);
+ret = MIN (ret, tret);
-	}
+}
 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
 /* The innermost expression P may have originally had
-	 TREE_SIDE_EFFECTS set which would have caused all the outer
+TREE_SIDE_EFFECTS set which would have caused all the outer
-	 expressions in *EXPR_P leading to P to also have had
+expressions in *EXPR_P leading to P to also have had
-	 TREE_SIDE_EFFECTS set.  */
+TREE_SIDE_EFFECTS set.  */
 recalculate_side_effects (t);
 }
 /* If the outermost expression is a COMPONENT_REF, canonicalize its type.  */
 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
 /*  Gimplify the self modifying expression pointed to by EXPR_P
 (++, --, +=, -=).
 PRE_P points to the list where side effects that must happen before
-	*EXPR_P should be stored.
+*EXPR_P should be stored.
 POST_P points to the list where side effects that must happen after
-	*EXPR_P should be stored.
+*EXPR_P should be stored.
 WANT_VALUE is nonzero iff we want to use the value of this expression
-	in another expression.  */
+in another expression.  */
 static enum gimplify_status
 gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
-			bool want_value)
+bool want_value)
 {
 enum tree_code code;
 tree lhs, lvalue, rhs, t1;
 gimple_seq post = NULL, *orig_post_p = post_p;
 bool postfix;
 enum tree_code arith_code;
 enum gimplify_status ret;
+location_t loc = EXPR_LOCATION (*expr_p);
 code = TREE_CODE (*expr_p);
 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
-	      || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
+|| code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
 /* Prefix or postfix?  */
 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
 /* Faster to treat as prefix if result is not used.  */
 postfix = want_value;
 /* Extract the operands to the arithmetic operation.  */
 lhs = lvalue;
 rhs = TREE_OPERAND (*expr_p, 1);
 /* For postfix operator, we evaluate the LHS to an rvalue and then use
-that as the result value and in the postqueue operation.  */
+that as the result value and in the postqueue operation.  We also
+make sure to make lvalue a minimal lval, see
+gcc.c-torture/execute/20040313-1.c for an example where this matters.  */
 if (postfix)
 {
+if (!is_gimple_min_lval (lvalue))
+{
+mark_addressable (lvalue);
+lvalue = build_fold_addr_expr_loc (input_location, lvalue);
+gimplify_expr (&lvalue, pre_p, post_p, is_gimple_val, fb_rvalue);
+lvalue = build_fold_indirect_ref_loc (input_location, lvalue);
+}
 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
 if (ret == GS_ERROR)
-	return ret;
+return ret;
 }
 /* For POINTERs increment, use POINTER_PLUS_EXPR.  */
 if (POINTER_TYPE_P (TREE_TYPE (lhs)))
 {
-rhs = fold_convert (sizetype, rhs);
+rhs = fold_convert_loc (loc, sizetype, rhs);
 if (arith_code == MINUS_EXPR)
-	rhs = fold_build1 (NEGATE_EXPR, TREE_TYPE (rhs), rhs);
+rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs);
 arith_code = POINTER_PLUS_EXPR;
 }
 t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
 test = is_gimple_lvalue, fb = fb_either;
 /* If this is a variable sized type, we must remember the size.  */
 maybe_with_size_expr (arg_p);
+/* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c.  */
 /* Make sure arguments have the same location as the function call
 itself.  */
 protected_set_expr_location (*arg_p, call_location);
 /* There is a sequence point before a function call.  Side effects in
 tree fndecl, parms, p;
 enum gimplify_status ret;
 int i, nargs;
 gimple call;
 bool builtin_va_start_p = FALSE;
+location_t loc = EXPR_LOCATION (*expr_p);
 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
 /* For reliable diagnostics during inlining, it is necessary that
 every call_expr be annotated with file and line.  */
 transform all calls in the same manner as the expanders do, but
 we do transform most of them.  */
 fndecl = get_callee_fndecl (*expr_p);
 if (fndecl && DECL_BUILT_IN (fndecl))
 {
-tree new_tree = fold_call_expr (*expr_p, !want_value);
+tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
 if (new_tree && new_tree != *expr_p)
-	{
+{
-	  /* There was a transformation of this call which computes the
+/* There was a transformation of this call which computes the
-	     same value, but in a more efficient way.  Return and try
+same value, but in a more efficient way.  Return and try
-	     again.  */
+again.  */
-	  *expr_p = new_tree;
+*expr_p = new_tree;
-	  return GS_OK;
+return GS_OK;
-	}
+}
 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
-	  && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_VA_START)
+&& DECL_FUNCTION_CODE (fndecl) == BUILT_IN_VA_START)
 {
-	  builtin_va_start_p = TRUE;
+builtin_va_start_p = TRUE;
-	  if (call_expr_nargs (*expr_p) < 2)
+if (call_expr_nargs (*expr_p) < 2)
-	    {
+{
-	      error ("too few arguments to function %<va_start%>");
+error ("too few arguments to function %<va_start%>");
-	      *expr_p = build_empty_stmt ();
+*expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
-	      return GS_OK;
+return GS_OK;
-	    }
+}
-	  if (fold_builtin_next_arg (*expr_p, true))
+if (fold_builtin_next_arg (*expr_p, true))
-	    {
+{
-	      *expr_p = build_empty_stmt ();
+*expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
-	      return GS_OK;
+return GS_OK;
-	    }
+}
-	}
+}
 }
 /* There is a sequence point before the call, so any side effects in
 the calling expression must occur before the actual call.  Force
 gimplify_expr to use an internal post queue.  */
 ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
-		       is_gimple_call_addr, fb_rvalue);
+is_gimple_call_addr, fb_rvalue);
 nargs = call_expr_nargs (*expr_p);
 /* Get argument types for verification.  */
 fndecl = get_callee_fndecl (*expr_p);
 {
 tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
 tree last_arg_fndecl = get_callee_fndecl (last_arg);
 if (last_arg_fndecl
-	  && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
+&& TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
-	  && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
+&& DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
-	  && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
+&& DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
-	{
+{
-	  tree call = *expr_p;
+tree call = *expr_p;
-	  --nargs;
+--nargs;
-	  *expr_p = build_call_array (TREE_TYPE (call), CALL_EXPR_FN (call),
+*expr_p = build_call_array_loc (loc, TREE_TYPE (call),
-				      nargs, CALL_EXPR_ARGP (call));
+CALL_EXPR_FN (call),
+nargs, CALL_EXPR_ARGP (call));
-	  /* Copy all CALL_EXPR flags, location and block, except
-	     CALL_EXPR_VA_ARG_PACK flag.  */
+/* Copy all CALL_EXPR flags, location and block, except
-	  CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
+CALL_EXPR_VA_ARG_PACK flag.  */
-	  CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
+CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
-	  CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
+CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
-	    = CALL_EXPR_RETURN_SLOT_OPT (call);
+CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
-	  CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
+= CALL_EXPR_RETURN_SLOT_OPT (call);
-	  CALL_CANNOT_INLINE_P (*expr_p) = CALL_CANNOT_INLINE_P (call);
+CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
-	  SET_EXPR_LOCUS (*expr_p, EXPR_LOCUS (call));
+CALL_CANNOT_INLINE_P (*expr_p) = CALL_CANNOT_INLINE_P (call);
-	  TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
+SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call));
+TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
-	  /* Set CALL_EXPR_VA_ARG_PACK.  */
-	  CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
+/* Set CALL_EXPR_VA_ARG_PACK.  */
-	}
+CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
+}
 }
 /* Finally, gimplify the function arguments.  */
 if (nargs > 0)
 {
 /* Avoid gimplifying the second argument to va_start, which needs to
 be the plain PARM_DECL.  */
 if ((i != 1) || !builtin_va_start_p)
 {
 t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
-				EXPR_LOCATION (*expr_p));
+EXPR_LOCATION (*expr_p));
 if (t == GS_ERROR)
 ret = GS_ERROR;
 }
 }
 }
+/* Verify the function result.  */
+if (want_value && fndecl
+&& VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl))))
+{
+error_at (loc, "using result of function returning %<void%>");
+ret = GS_ERROR;
+}
 /* Try this again in case gimplification exposed something.  */
 if (ret != GS_ERROR)
 {
-tree new_tree = fold_call_expr (*expr_p, !want_value);
+tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
 if (new_tree && new_tree != *expr_p)
-	{
+{
-	  /* There was a transformation of this call which computes the
+/* There was a transformation of this call which computes the
-	     same value, but in a more efficient way.  Return and try
+same value, but in a more efficient way.  Return and try
-	     again.  */
+again.  */
-	  *expr_p = new_tree;
+*expr_p = new_tree;
-	  return GS_OK;
+return GS_OK;
-	}
+}
 }
 else
 {
 *expr_p = error_mark_node;
 return GS_ERROR;
 calls to "const" functions.  */
 if (TREE_CODE (*expr_p) == CALL_EXPR)
 {
 int flags = call_expr_flags (*expr_p);
 if (flags & (ECF_CONST | ECF_PURE)
-	  /* An infinite loop is considered a side effect.  */
+/* An infinite loop is considered a side effect.  */
-	  && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
+&& !(flags & (ECF_LOOPING_CONST_OR_PURE)))
-	TREE_SIDE_EFFECTS (*expr_p) = 0;
+TREE_SIDE_EFFECTS (*expr_p) = 0;
 }
 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
 and clear *EXPR_P.  Otherwise, leave *EXPR_P in its gimplified
 form and delegate the creation of a GIMPLE_CALL to
 internal_get_tmp_var which will then be handled by
 gimplify_modify_expr.  */
 if (!want_value)
 {
 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
-	 have to do is replicate it as a GIMPLE_CALL tuple.  */
+have to do is replicate it as a GIMPLE_CALL tuple.  */
 call = gimple_build_call_from_tree (*expr_p);
 gimplify_seq_add_stmt (pre_p, call);
 *expr_p = NULL_TREE;
 }
 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
 condition is true or false, respectively.  If null, we should generate
 our own to skip over the evaluation of this specific expression.
+LOCUS is the source location of the COND_EXPR.
 This function is the tree equivalent of do_jump.
 shortcut_cond_r should only be called by shortcut_cond_expr.  */
 static tree
-shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p)
+shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
+location_t locus)
 {
 tree local_label = NULL_TREE;
 tree t, expr = NULL;
 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
 retain the shortcut semantics.  Just insert the gotos here;
 shortcut_cond_expr will append the real blocks later.  */
 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
 {
+location_t new_locus;
 /* Turn if (a && b) into
-	 if (a); else goto no;
+if (a); else goto no;
-	 if (b) goto yes; else goto no;
+if (b) goto yes; else goto no;
-	 (no:) */
+(no:) */
 if (false_label_p == NULL)
-	false_label_p = &local_label;
+false_label_p = &local_label;
-t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p);
+/* Keep the original source location on the first 'if'.  */
+t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
 append_to_statement_list (t, &expr);
-t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
+/* Set the source location of the && on the second 'if'.  */
-			   false_label_p);
+new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
+t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
+new_locus);
 append_to_statement_list (t, &expr);
 }
 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
 {
+location_t new_locus;
 /* Turn if (a || b) into
-	 if (a) goto yes;
+if (a) goto yes;
-	 if (b) goto yes; else goto no;
+if (b) goto yes; else goto no;
-	 (yes:) */
+(yes:) */
 if (true_label_p == NULL)
-	true_label_p = &local_label;
+true_label_p = &local_label;
-t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL);
+/* Keep the original source location on the first 'if'.  */
+t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
 append_to_statement_list (t, &expr);
-t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
+/* Set the source location of the || on the second 'if'.  */
-			   false_label_p);
+new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
+t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
+new_locus);
 append_to_statement_list (t, &expr);
 }
 else if (TREE_CODE (pred) == COND_EXPR)
 {
+location_t new_locus;
 /* As long as we're messing with gotos, turn if (a ? b : c) into
-	 if (a)
+if (a)
-	   if (b) goto yes; else goto no;
+if (b) goto yes; else goto no;
-	 else
+else
-	   if (c) goto yes; else goto no;  */
+if (c) goto yes; else goto no;  */
+/* Keep the original source location on the first 'if'.  Set the source
+location of the ? on the second 'if'.  */
+new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
-		     shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
+shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
-				      false_label_p),
+false_label_p, locus),
-		     shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
+shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
-				      false_label_p));
+false_label_p, new_locus));
 }
 else
 {
 expr = build3 (COND_EXPR, void_type_node, pred,
-		     build_and_jump (true_label_p),
+build_and_jump (true_label_p),
-		     build_and_jump (false_label_p));
+build_and_jump (false_label_p));
+SET_EXPR_LOCATION (expr, locus);
 }
 if (local_label)
 {
 t = build1 (LABEL_EXPR, void_type_node, local_label);
 bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
 /* First do simple transformations.  */
 if (!else_se)
 {
-/* If there is no 'else', turn (a && b) into if (a) if (b).  */
+/* If there is no 'else', turn
+if (a && b) then c
+into
+if (a) if (b) then c.  */
 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
-	{
+{
-	  TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
+/* Keep the original source location on the first 'if'.  */
-	  then_ = shortcut_cond_expr (expr);
+location_t locus = EXPR_HAS_LOCATION (expr)
-	  then_se = then_ && TREE_SIDE_EFFECTS (then_);
+? EXPR_LOCATION (expr) : input_location;
-	  pred = TREE_OPERAND (pred, 0);
+TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
-	  expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
+/* Set the source location of the && on the second 'if'.  */
-	}
+if (EXPR_HAS_LOCATION (pred))
+SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
+then_ = shortcut_cond_expr (expr);
+then_se = then_ && TREE_SIDE_EFFECTS (then_);
+pred = TREE_OPERAND (pred, 0);
+expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
+SET_EXPR_LOCATION (expr, locus);
+}
 }
 if (!then_se)
 {
 /* If there is no 'then', turn
-	   if (a || b); else d
+if (a || b); else d
-	 into
+into
-	   if (a); else if (b); else d.  */
+if (a); else if (b); else d.  */
 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
-	{
+{
-	  TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
+/* Keep the original source location on the first 'if'.  */
-	  else_ = shortcut_cond_expr (expr);
+location_t locus = EXPR_HAS_LOCATION (expr)
-	  else_se = else_ && TREE_SIDE_EFFECTS (else_);
+? EXPR_LOCATION (expr) : input_location;
-	  pred = TREE_OPERAND (pred, 0);
+TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
-	  expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
+/* Set the source location of the || on the second 'if'.  */
-	}
+if (EXPR_HAS_LOCATION (pred))
+SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
+else_ = shortcut_cond_expr (expr);
+else_se = else_ && TREE_SIDE_EFFECTS (else_);
+pred = TREE_OPERAND (pred, 0);
+expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
+SET_EXPR_LOCATION (expr, locus);
+}
 }
 /* If we're done, great.  */
 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
 else
 false_label_p = NULL;
 /* If there was nothing else in our arms, just forward the label(s).  */
 if (!then_se && !else_se)
-return shortcut_cond_r (pred, true_label_p, false_label_p);
+return shortcut_cond_r (pred, true_label_p, false_label_p,
+EXPR_HAS_LOCATION (expr)
+? EXPR_LOCATION (expr) : input_location);
 /* If our last subexpression already has a terminal label, reuse it.  */
 if (else_se)
-expr = expr_last (else_);
+t = expr_last (else_);
 else if (then_se)
-expr = expr_last (then_);
+t = expr_last (then_);
 else
-expr = NULL;
+t = NULL;
-if (expr && TREE_CODE (expr) == LABEL_EXPR)
+if (t && TREE_CODE (t) == LABEL_EXPR)
-end_label = LABEL_EXPR_LABEL (expr);
+end_label = LABEL_EXPR_LABEL (t);
 /* If we don't care about jumping to the 'else' branch, jump to the end
 if the condition is false.  */
 if (!false_label_p)
 false_label_p = &end_label;
 which ends with such a condition, that can cause us to issue an
 inappropriate warning about control reaching the end of a
 non-void function.  */
 jump_over_else = block_may_fallthru (then_);
-pred = shortcut_cond_r (pred, true_label_p, false_label_p);
+pred = shortcut_cond_r (pred, true_label_p, false_label_p,
+EXPR_HAS_LOCATION (expr)
+? EXPR_LOCATION (expr) : input_location);
 expr = NULL;
 append_to_statement_list (pred, &expr);
 append_to_statement_list (then_, &expr);
 if (else_se)
 {
 if (jump_over_else)
-	{
+{
-	  t = build_and_jump (&end_label);
+tree last = expr_last (expr);
-	  append_to_statement_list (t, &expr);
+t = build_and_jump (&end_label);
-	}
+if (EXPR_HAS_LOCATION (last))
+SET_EXPR_LOCATION (t, EXPR_LOCATION (last));
+append_to_statement_list (t, &expr);
+}
 if (emit_false)
-	{
+{
-	  t = build1 (LABEL_EXPR, void_type_node, false_label);
+t = build1 (LABEL_EXPR, void_type_node, false_label);
-	  append_to_statement_list (t, &expr);
+append_to_statement_list (t, &expr);
-	}
+}
 append_to_statement_list (else_, &expr);
 }
 if (emit_end && end_label)
 {
 t = build1 (LABEL_EXPR, void_type_node, end_label);
 tree
 gimple_boolify (tree expr)
 {
 tree type = TREE_TYPE (expr);
+location_t loc = EXPR_LOCATION (expr);
 if (TREE_CODE (type) == BOOLEAN_TYPE)
 return expr;
 switch (TREE_CODE (expr))
 TREE_TYPE (expr) = boolean_type_node;
 return expr;
 default:
 /* Other expressions that get here must have boolean values, but
-	 might need to be converted to the appropriate mode.  */
+might need to be converted to the appropriate mode.  */
-return fold_convert (boolean_type_node, expr);
+return fold_convert_loc (loc, boolean_type_node, expr);
 }
 }
 /* Given a conditional expression *EXPR_P without side effects, gimplify
 its operands.  New statements are inserted to PRE_P.  */
 TREE_SET_CODE (cond, TRUTH_OR_EXPR);
 ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
 COND_EXPR_COND (*expr_p) = cond;
 tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
-				   is_gimple_val, fb_rvalue);
+is_gimple_val, fb_rvalue);
 ret = MIN (ret, tret);
 tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
-				   is_gimple_val, fb_rvalue);
+is_gimple_val, fb_rvalue);
 return MIN (ret, tret);
 }
 /* Returns true if evaluating EXPR could trap.
 }
 /*  Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
 into
-if (p)			if (p)
+if (p)          if (p)
-t1 = a;			  a;
+t1 = a;             a;
-else		or	else
+else        or  else
-t1 = b;			  b;
+t1 = b;             b;
 t1;
 The second form is used when *EXPR_P is of type void.
 PRE_P points to the list where side effects that must happen before
 tree label_true, label_false, label_cont;
 bool have_then_clause_p, have_else_clause_p;
 gimple gimple_cond;
 enum tree_code pred_code;
 gimple_seq seq = NULL;
+location_t loc = EXPR_LOCATION (*expr_p);
 type = TREE_TYPE (expr);
 /* If this COND_EXPR has a value, copy the values into a temporary within
 the arms.  */
 if (! VOID_TYPE_P (type))
 {
 tree result;
 /* If an rvalue is ok or we do not require an lvalue, avoid creating
-	 an addressable temporary.  */
+an addressable temporary.  */
 if (((fallback & fb_rvalue)
-	   || !(fallback & fb_lvalue))
+|| !(fallback & fb_lvalue))
-	  && !TREE_ADDRESSABLE (type))
+&& !TREE_ADDRESSABLE (type))
-	{
+{
-	  if (gimplify_ctxp->allow_rhs_cond_expr
+if (gimplify_ctxp->allow_rhs_cond_expr
-	      /* If either branch has side effects or could trap, it can't be
+/* If either branch has side effects or could trap, it can't be
-		 evaluated unconditionally.  */
+evaluated unconditionally.  */
-	      && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1))
+&& !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1))
-	      && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 1))
+&& !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 1))
-	      && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 2))
+&& !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 2))
-	      && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 2)))
+&& !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 2)))
-	    return gimplify_pure_cond_expr (expr_p, pre_p);
+return gimplify_pure_cond_expr (expr_p, pre_p);
-	  result = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
+result = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
-	  ret = GS_ALL_DONE;
+ret = GS_ALL_DONE;
-	}
+}
 else
-	{
+{
-	  tree type = build_pointer_type (TREE_TYPE (expr));
+tree type = build_pointer_type (TREE_TYPE (expr));
-	  if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
+if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
-	    TREE_OPERAND (expr, 1) =
+TREE_OPERAND (expr, 1) =
-	      build_fold_addr_expr (TREE_OPERAND (expr, 1));
+build_fold_addr_expr_loc (loc, TREE_OPERAND (expr, 1));
-	  if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
+if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
-	    TREE_OPERAND (expr, 2) =
+TREE_OPERAND (expr, 2) =
-	      build_fold_addr_expr (TREE_OPERAND (expr, 2));
+build_fold_addr_expr_loc (loc, TREE_OPERAND (expr, 2));
-	  tmp = create_tmp_var (type, "iftmp");
+tmp = create_tmp_var (type, "iftmp");
-	  expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
+expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
-			 TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
+TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
-	  result = build_fold_indirect_ref (tmp);
+result = build_fold_indirect_ref_loc (loc, tmp);
-	}
+}
 /* Build the then clause, 't1 = a;'.  But don't build an assignment
-	 if this branch is void; in C++ it can be, if it's a throw.  */
+if this branch is void; in C++ it can be, if it's a throw.  */
 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
-	TREE_OPERAND (expr, 1)
+TREE_OPERAND (expr, 1)
-	  = build2 (MODIFY_EXPR, TREE_TYPE (tmp), tmp, TREE_OPERAND (expr, 1));
+= build2 (MODIFY_EXPR, TREE_TYPE (tmp), tmp, TREE_OPERAND (expr, 1));
 /* Build the else clause, 't1 = b;'.  */
 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
-	TREE_OPERAND (expr, 2)
+TREE_OPERAND (expr, 2)
-	  = build2 (MODIFY_EXPR, TREE_TYPE (tmp), tmp, TREE_OPERAND (expr, 2));
+= build2 (MODIFY_EXPR, TREE_TYPE (tmp), tmp, TREE_OPERAND (expr, 2));
 TREE_TYPE (expr) = void_type_node;
 recalculate_side_effects (expr);
 /* Move the COND_EXPR to the prequeue.  */
 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
 {
 expr = shortcut_cond_expr (expr);
 if (expr != *expr_p)
-	{
+{
-	  *expr_p = expr;
+*expr_p = expr;
-	  /* We can't rely on gimplify_expr to re-gimplify the expanded
+/* We can't rely on gimplify_expr to re-gimplify the expanded
-	     form properly, as cleanups might cause the target labels to be
+form properly, as cleanups might cause the target labels to be
-	     wrapped in a TRY_FINALLY_EXPR.  To prevent that, we need to
+wrapped in a TRY_FINALLY_EXPR.  To prevent that, we need to
-	     set up a conditional context.  */
+set up a conditional context.  */
-	  gimple_push_condition ();
+gimple_push_condition ();
-	  gimplify_stmt (expr_p, &seq);
+gimplify_stmt (expr_p, &seq);
-	  gimple_pop_condition (pre_p);
+gimple_pop_condition (pre_p);
-	  gimple_seq_add_seq (pre_p, seq);
+gimple_seq_add_seq (pre_p, seq);
-	  return GS_ALL_DONE;
+return GS_ALL_DONE;
-	}
+}
 }
 /* Now do the normal gimplification.  */
 /* Gimplify condition.  */
 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
-		       fb_rvalue);
+fb_rvalue);
 if (ret == GS_ERROR)
 return GS_ERROR;
 gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
 gimple_push_condition ();
 have_then_clause_p = have_else_clause_p = false;
 if (TREE_OPERAND (expr, 1) != NULL
 && TREE_CODE (TREE_OPERAND (expr, 1)) == GOTO_EXPR
 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 1))) == LABEL_DECL
 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 1)))
-	  == current_function_decl)
+== current_function_decl)
 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
-	 have different locations, otherwise we end up with incorrect
+have different locations, otherwise we end up with incorrect
-	 location information on the branches.  */
+location information on the branches.  */
 && (optimize
-	  || !EXPR_HAS_LOCATION (expr)
+|| !EXPR_HAS_LOCATION (expr)
-	  || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
+|| !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
-	  || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
+|| EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
 {
 label_true = GOTO_DESTINATION (TREE_OPERAND (expr, 1));
 have_then_clause_p = true;
 }
 else
-label_true = create_artificial_label ();
+label_true = create_artificial_label (UNKNOWN_LOCATION);
 if (TREE_OPERAND (expr, 2) != NULL
 && TREE_CODE (TREE_OPERAND (expr, 2)) == GOTO_EXPR
 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 2))) == LABEL_DECL
 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 2)))
-	  == current_function_decl)
+== current_function_decl)
 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
-	 have different locations, otherwise we end up with incorrect
+have different locations, otherwise we end up with incorrect
-	 location information on the branches.  */
+location information on the branches.  */
 && (optimize
-	  || !EXPR_HAS_LOCATION (expr)
+|| !EXPR_HAS_LOCATION (expr)
-	  || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
+|| !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
-	  || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
+|| EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
 {
 label_false = GOTO_DESTINATION (TREE_OPERAND (expr, 2));
 have_else_clause_p = true;
 }
 else
-label_false = create_artificial_label ();
+label_false = create_artificial_label (UNKNOWN_LOCATION);
 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
-				 &arm2);
+&arm2);
 gimple_cond = gimple_build_cond (pred_code, arm1, arm2, label_true,
 label_false);
 gimplify_seq_add_stmt (&seq, gimple_cond);
 label_cont = NULL_TREE;
 if (!have_then_clause_p)
 {
 /* For if (...) {} else { code; } put label_true after
-	 the else block.  */
+the else block.  */
 if (TREE_OPERAND (expr, 1) == NULL_TREE
-	  && !have_else_clause_p
+&& !have_else_clause_p
-	  && TREE_OPERAND (expr, 2) != NULL_TREE)
+&& TREE_OPERAND (expr, 2) != NULL_TREE)
-	label_cont = label_true;
+label_cont = label_true;
 else
-	{
+{
-	  gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
+gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
-	  have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
+have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
-	  /* For if (...) { code; } else {} or
+/* For if (...) { code; } else {} or
-	     if (...) { code; } else goto label; or
+if (...) { code; } else goto label; or
-	     if (...) { code; return; } else { ... }
+if (...) { code; return; } else { ... }
-	     label_cont isn't needed.  */
+label_cont isn't needed.  */
-	  if (!have_else_clause_p
+if (!have_else_clause_p
-	      && TREE_OPERAND (expr, 2) != NULL_TREE
+&& TREE_OPERAND (expr, 2) != NULL_TREE
-	      && gimple_seq_may_fallthru (seq))
+&& gimple_seq_may_fallthru (seq))
-	    {
+{
-	      gimple g;
+gimple g;
-	      label_cont = create_artificial_label ();
+label_cont = create_artificial_label (UNKNOWN_LOCATION);
-	      g = gimple_build_goto (label_cont);
+g = gimple_build_goto (label_cont);
-	      /* GIMPLE_COND's are very low level; they have embedded
+/* GIMPLE_COND's are very low level; they have embedded
-		 gotos.  This particular embedded goto should not be marked
+gotos.  This particular embedded goto should not be marked
-		 with the location of the original COND_EXPR, as it would
+with the location of the original COND_EXPR, as it would
-		 correspond to the COND_EXPR's condition, not the ELSE or the
+correspond to the COND_EXPR's condition, not the ELSE or the
-		 THEN arms.  To avoid marking it with the wrong location, flag
+THEN arms.  To avoid marking it with the wrong location, flag
-		 it as "no location".  */
+it as "no location".  */
-	      gimple_set_do_not_emit_location (g);
+gimple_set_do_not_emit_location (g);
-	      gimplify_seq_add_stmt (&seq, g);
+gimplify_seq_add_stmt (&seq, g);
-	    }
+}
-	}
+}
 }
 if (!have_else_clause_p)
 {
 gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
 have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
 *expr_p = NULL;
 return ret;
 }
+/* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
+to be marked addressable.
+We cannot rely on such an expression being directly markable if a temporary
+has been created by the gimplification.  In this case, we create another
+temporary and initialize it with a copy, which will become a store after we
+mark it addressable.  This can happen if the front-end passed us something
+that it could not mark addressable yet, like a Fortran pass-by-reference
+parameter (int) floatvar.  */
+static void
+prepare_gimple_addressable (tree *expr_p, gimple_seq *seq_p)
+{
+while (handled_component_p (*expr_p))
+expr_p = &TREE_OPERAND (*expr_p, 0);
+if (is_gimple_reg (*expr_p))
+*expr_p = get_initialized_tmp_var (*expr_p, seq_p, NULL);
+}
 /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
 a call to __builtin_memcpy.  */
 static enum gimplify_status
 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
-				gimple_seq *seq_p)
+gimple_seq *seq_p)
 {
 tree t, to, to_ptr, from, from_ptr;
 gimple gs;
+location_t loc = EXPR_LOCATION (*expr_p);
 to = TREE_OPERAND (*expr_p, 0);
 from = TREE_OPERAND (*expr_p, 1);
-from_ptr = build_fold_addr_expr (from);
+/* Mark the RHS addressable.  Beware that it may not be possible to do so
-gimplify_arg (&from_ptr, seq_p, EXPR_LOCATION (*expr_p));
+directly if a temporary has been created by the gimplification.  */
+prepare_gimple_addressable (&from, seq_p);
-to_ptr = build_fold_addr_expr (to);
-gimplify_arg (&to_ptr, seq_p, EXPR_LOCATION (*expr_p));
+mark_addressable (from);
+from_ptr = build_fold_addr_expr_loc (loc, from);
+gimplify_arg (&from_ptr, seq_p, loc);
+mark_addressable (to);
+to_ptr = build_fold_addr_expr_loc (loc, to);
+gimplify_arg (&to_ptr, seq_p, loc);
 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
 gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
 a call to __builtin_memset.  In this case we know that the RHS is
 a CONSTRUCTOR with an empty element list.  */
 static enum gimplify_status
 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
-				gimple_seq *seq_p)
+gimple_seq *seq_p)
 {
 tree t, from, to, to_ptr;
 gimple gs;
+location_t loc = EXPR_LOCATION (*expr_p);
 /* Assert our assumptions, to abort instead of producing wrong code
 silently if they are not met.  Beware that the RHS CONSTRUCTOR might
 not be immediately exposed.  */
 from = TREE_OPERAND (*expr_p, 1);
 if (TREE_CODE (from) == WITH_SIZE_EXPR)
 from = TREE_OPERAND (from, 0);
 gcc_assert (TREE_CODE (from) == CONSTRUCTOR
-	      && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
+&& VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
 /* Now proceed.  */
 to = TREE_OPERAND (*expr_p, 0);
-to_ptr = build_fold_addr_expr (to);
+to_ptr = build_fold_addr_expr_loc (loc, to);
-gimplify_arg (&to_ptr, seq_p, EXPR_LOCATION (*expr_p));
+gimplify_arg (&to_ptr, seq_p, loc);
 t = implicit_built_in_decls[BUILT_IN_MEMSET];
 gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
 if (want_value)
 if (TREE_CODE (t) == CALL_EXPR)
 {
 tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
 for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
-	if (POINTER_TYPE_P (TREE_VALUE (type))
+if (POINTER_TYPE_P (TREE_VALUE (type))
-	    && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
+&& (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
-	    && alias_sets_conflict_p (data->lhs_alias_set,
+&& alias_sets_conflict_p (data->lhs_alias_set,
-				      get_alias_set
+get_alias_set
-				        (TREE_TYPE (TREE_VALUE (type)))))
+(TREE_TYPE (TREE_VALUE (type)))))
-	  return t;
+return t;
 }
 if (IS_TYPE_OR_DECL_P (t))
 *walk_subtrees = 0;
 return NULL;
 force values that overlap with the lhs (as described by *DATA)
 into temporaries.  */
 static void
 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
-			    struct gimplify_init_ctor_preeval_data *data)
+struct gimplify_init_ctor_preeval_data *data)
 {
 enum gimplify_status one;
 /* If the value is constant, then there's nothing to pre-evaluate.  */
 if (TREE_CONSTANT (*expr_p))
 {
 /* Ensure it does not have side effects, it might contain a reference to
-	 the object we're initializing.  */
+the object we're initializing.  */
 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
 return;
 }
 /* If the type has non-trivial constructors, we can't pre-evaluate.  */
 unsigned HOST_WIDE_INT ix;
 constructor_elt *ce;
 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
 for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++)
-	gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
+gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
 return;
 }
 /* If this is a variable sized type, we must remember the size.  */
 var = lower;
 loop_entry:
 object[var] = value;
 if (var == upper)
-	goto loop_exit;
+goto loop_exit;
 var = var + 1;
 goto loop_entry;
 loop_exit:
 We increment var _after_ the loop exit check because we might otherwise
 Note that we never have to deal with SAVE_EXPRs here, because this has
 already been taken care of for us, in gimplify_init_ctor_preeval().  */
 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
-				     gimple_seq *, bool);
+gimple_seq *, bool);
 static void
 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
-			       tree value, tree array_elt_type,
+tree value, tree array_elt_type,
-			       gimple_seq *pre_p, bool cleared)
+gimple_seq *pre_p, bool cleared)
 {
 tree loop_entry_label, loop_exit_label, fall_thru_label;
 tree var, var_type, cref, tmp;
-loop_entry_label = create_artificial_label ();
+loop_entry_label = create_artificial_label (UNKNOWN_LOCATION);
-loop_exit_label = create_artificial_label ();
+loop_exit_label = create_artificial_label (UNKNOWN_LOCATION);
-fall_thru_label = create_artificial_label ();
+fall_thru_label = create_artificial_label (UNKNOWN_LOCATION);
 /* Create and initialize the index variable.  */
 var_type = TREE_TYPE (upper);
 var = create_tmp_var (var_type, NULL);
 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
 /* Add the loop entry label.  */
 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
 /* Build the reference.  */
 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
-		 var, NULL_TREE, NULL_TREE);
+var, NULL_TREE, NULL_TREE);
 /* If we are a constructor, just call gimplify_init_ctor_eval to do
 the store.  Otherwise just assign value to the reference.  */
 if (TREE_CODE (value) == CONSTRUCTOR)
 /* NB we might have to call ourself recursively through
 gimplify_init_ctor_eval if the value is a constructor.  */
 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
-			     pre_p, cleared);
+pre_p, cleared);
 else
 gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
 /* We exit the loop when the index var is equal to the upper bound.  */
 gimplify_seq_add_stmt (pre_p,
-			 gimple_build_cond (EQ_EXPR, var, upper,
+gimple_build_cond (EQ_EXPR, var, upper,
-					    loop_exit_label, fall_thru_label));
+loop_exit_label, fall_thru_label));
 gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
 /* Otherwise, increment the index var...  */
 tmp = build2 (PLUS_EXPR, var_type, var,
-		fold_convert (var_type, integer_one_node));
+fold_convert (var_type, integer_one_node));
 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
 /* ...and jump back to the loop entry.  */
 gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
 /* Add the loop exit label.  */
 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
 }
 /* Return true if FDECL is accessing a field that is zero sized.  */
 static bool
 zero_sized_field_decl (const_tree fdecl)
 {
 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
 && integer_zerop (DECL_SIZE (fdecl)))
 return true;
 return false;
 }
 /* Return true if TYPE is zero sized.  */
 static bool
 zero_sized_type (const_tree type)
 {
 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
 && integer_zerop (TYPE_SIZE (type)))
 CONSTRUCTOR.  CLEARED is true if the entire LHS object has been
 zeroed first.  */
 static void
 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
-			 gimple_seq *pre_p, bool cleared)
+gimple_seq *pre_p, bool cleared)
 {
 tree array_elt_type = NULL;
 unsigned HOST_WIDE_INT ix;
 tree purpose, value;
 {
 tree cref;
 /* NULL values are created above for gimplification errors.  */
 if (value == NULL)
-	continue;
+continue;
 if (cleared && initializer_zerop (value))
-	continue;
+continue;
 /* ??? Here's to hoping the front end fills in all of the indices,
-	 so we don't have to figure out what's missing ourselves.  */
+so we don't have to figure out what's missing ourselves.  */
 gcc_assert (purpose);
 /* Skip zero-sized fields, unless value has side-effects.  This can
-	 happen with calls to functions returning a zero-sized type, which
+happen with calls to functions returning a zero-sized type, which
-	 we shouldn't discard.  As a number of downstream passes don't
+we shouldn't discard.  As a number of downstream passes don't
-	 expect sets of zero-sized fields, we rely on the gimplification of
+expect sets of zero-sized fields, we rely on the gimplification of
-	 the MODIFY_EXPR we make below to drop the assignment statement.  */
+the MODIFY_EXPR we make below to drop the assignment statement.  */
 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
-	continue;
+continue;
 /* If we have a RANGE_EXPR, we have to build a loop to assign the
-	 whole range.  */
+whole range.  */
 if (TREE_CODE (purpose) == RANGE_EXPR)
-	{
+{
-	  tree lower = TREE_OPERAND (purpose, 0);
+tree lower = TREE_OPERAND (purpose, 0);
-	  tree upper = TREE_OPERAND (purpose, 1);
+tree upper = TREE_OPERAND (purpose, 1);
-	  /* If the lower bound is equal to upper, just treat it as if
+/* If the lower bound is equal to upper, just treat it as if
-	     upper was the index.  */
+upper was the index.  */
-	  if (simple_cst_equal (lower, upper))
+if (simple_cst_equal (lower, upper))
-	    purpose = upper;
+purpose = upper;
-	  else
+else
-	    {
+{
-	      gimplify_init_ctor_eval_range (object, lower, upper, value,
+gimplify_init_ctor_eval_range (object, lower, upper, value,
-					     array_elt_type, pre_p, cleared);
+array_elt_type, pre_p, cleared);
-	      continue;
+continue;
-	    }
+}
-	}
+}
 if (array_elt_type)
-	{
+{
-	  /* Do not use bitsizetype for ARRAY_REF indices.  */
+/* Do not use bitsizetype for ARRAY_REF indices.  */
-	  if (TYPE_DOMAIN (TREE_TYPE (object)))
+if (TYPE_DOMAIN (TREE_TYPE (object)))
-	    purpose = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
+purpose = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
-				    purpose);
+purpose);
-	  cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
+cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
-			 purpose, NULL_TREE, NULL_TREE);
+purpose, NULL_TREE, NULL_TREE);
-	}
+}
 else
-	{
+{
-	  gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
+gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
-	  cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
+cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
-			 unshare_expr (object), purpose, NULL_TREE);
+unshare_expr (object), purpose, NULL_TREE);
-	}
+}
 if (TREE_CODE (value) == CONSTRUCTOR
-	  && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
+&& TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
-	gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
+gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
-				 pre_p, cleared);
+pre_p, cleared);
 else
-	{
+{
-	  tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
+tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
-	  gimplify_and_add (init, pre_p);
+gimplify_and_add (init, pre_p);
-	  ggc_free (init);
+ggc_free (init);
-	}
+}
 }
 }
 /* Returns the appropriate RHS predicate for this LHS.  */
 gimple_predicate
 rhs_predicate_for (tree lhs)
 {
-if (is_gimple_formal_tmp_var (lhs))
+if (is_gimple_reg (lhs))
-return is_gimple_formal_tmp_or_call_rhs;
+return is_gimple_reg_rhs_or_call;
-else if (is_gimple_reg (lhs))
-return is_gimple_reg_or_call_rhs;
 else
-return is_gimple_mem_or_call_rhs;
+return is_gimple_mem_rhs_or_call;
 }
+/* Gimplify a C99 compound literal expression.  This just means adding
+the DECL_EXPR before the current statement and using its anonymous
+decl instead.  */
+static enum gimplify_status
+gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p)
+{
+tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
+tree decl = DECL_EXPR_DECL (decl_s);
+/* Mark the decl as addressable if the compound literal
+expression is addressable now, otherwise it is marked too late
+after we gimplify the initialization expression.  */
+if (TREE_ADDRESSABLE (*expr_p))
+TREE_ADDRESSABLE (decl) = 1;
+/* Preliminarily mark non-addressed complex variables as eligible
+for promotion to gimple registers.  We'll transform their uses
+as we find them.  */
+if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
+|| TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
+&& !TREE_THIS_VOLATILE (decl)
+&& !needs_to_live_in_memory (decl))
+DECL_GIMPLE_REG_P (decl) = 1;
+/* This decl isn't mentioned in the enclosing block, so add it to the
+list of temps.  FIXME it seems a bit of a kludge to say that
+anonymous artificial vars aren't pushed, but everything else is.  */
+if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
+gimple_add_tmp_var (decl);
+gimplify_and_add (decl_s, pre_p);
+*expr_p = decl;
+return GS_OK;
+}
+/* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
+return a new CONSTRUCTOR if something changed.  */
+static tree
+optimize_compound_literals_in_ctor (tree orig_ctor)
+{
+tree ctor = orig_ctor;
+VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor);
+unsigned int idx, num = VEC_length (constructor_elt, elts);
+for (idx = 0; idx < num; idx++)
+{
+tree value = VEC_index (constructor_elt, elts, idx)->value;
+tree newval = value;
+if (TREE_CODE (value) == CONSTRUCTOR)
+newval = optimize_compound_literals_in_ctor (value);
+else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
+{
+tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
+tree decl = DECL_EXPR_DECL (decl_s);
+tree init = DECL_INITIAL (decl);
+if (!TREE_ADDRESSABLE (value)
+&& !TREE_ADDRESSABLE (decl)
+&& init)
+newval = optimize_compound_literals_in_ctor (init);
+}
+if (newval == value)
+continue;
+if (ctor == orig_ctor)
+{
+ctor = copy_node (orig_ctor);
+CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts);
+elts = CONSTRUCTOR_ELTS (ctor);
+}
+VEC_index (constructor_elt, elts, idx)->value = newval;
+}
+return ctor;
+}
 /* A subroutine of gimplify_modify_expr.  Break out elements of a
 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
 If NOTIFY_TEMP_CREATION is false, just do the gimplification.  */
 static enum gimplify_status
 gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
-			   bool want_value, bool notify_temp_creation)
+bool want_value, bool notify_temp_creation)
 {
-tree object;
+tree object, ctor, type;
-tree ctor = TREE_OPERAND (*expr_p, 1);
-tree type = TREE_TYPE (ctor);
 enum gimplify_status ret;
 VEC(constructor_elt,gc) *elts;
-if (TREE_CODE (ctor) != CONSTRUCTOR)
+gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR);
-return GS_UNHANDLED;
 if (!notify_temp_creation)
 {
 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
-			   is_gimple_lvalue, fb_lvalue);
+is_gimple_lvalue, fb_lvalue);
 if (ret == GS_ERROR)
-	return ret;
+return ret;
 }
 object = TREE_OPERAND (*expr_p, 0);
+ctor = TREE_OPERAND (*expr_p, 1) =
+optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p, 1));
+type = TREE_TYPE (ctor);
 elts = CONSTRUCTOR_ELTS (ctor);
 ret = GS_ALL_DONE;
 switch (TREE_CODE (type))
 {
 case RECORD_TYPE:
 case UNION_TYPE:
 case QUAL_UNION_TYPE:
 case ARRAY_TYPE:
 {
-	struct gimplify_init_ctor_preeval_data preeval_data;
+struct gimplify_init_ctor_preeval_data preeval_data;
-	HOST_WIDE_INT num_type_elements, num_ctor_elements;
+HOST_WIDE_INT num_type_elements, num_ctor_elements;
-	HOST_WIDE_INT num_nonzero_elements;
+HOST_WIDE_INT num_nonzero_elements;
-	bool cleared, valid_const_initializer;
+bool cleared, valid_const_initializer;
-	/* Aggregate types must lower constructors to initialization of
+/* Aggregate types must lower constructors to initialization of
-	   individual elements.  The exception is that a CONSTRUCTOR node
+individual elements.  The exception is that a CONSTRUCTOR node
-	   with no elements indicates zero-initialization of the whole.  */
+with no elements indicates zero-initialization of the whole.  */
-	if (VEC_empty (constructor_elt, elts))
+if (VEC_empty (constructor_elt, elts))
-	  {
+{
-	    if (notify_temp_creation)
+if (notify_temp_creation)
-	      return GS_OK;
+return GS_OK;
-	    break;
+break;
-	  }
+}
-	/* Fetch information about the constructor to direct later processing.
+/* Fetch information about the constructor to direct later processing.
-	   We might want to make static versions of it in various cases, and
+We might want to make static versions of it in various cases, and
-	   can only do so if it known to be a valid constant initializer.  */
+can only do so if it known to be a valid constant initializer.  */
-	valid_const_initializer
+valid_const_initializer
-	  = categorize_ctor_elements (ctor, &num_nonzero_elements,
+= categorize_ctor_elements (ctor, &num_nonzero_elements,
-				      &num_ctor_elements, &cleared);
+&num_ctor_elements, &cleared);
-	/* If a const aggregate variable is being initialized, then it
+/* If a const aggregate variable is being initialized, then it
-	   should never be a lose to promote the variable to be static.  */
+should never be a lose to promote the variable to be static.  */
-	if (valid_const_initializer
+if (valid_const_initializer
-	    && num_nonzero_elements > 1
+&& num_nonzero_elements > 1
-	    && TREE_READONLY (object)
+&& TREE_READONLY (object)
-	    && TREE_CODE (object) == VAR_DECL
+&& TREE_CODE (object) == VAR_DECL
-	    && (flag_merge_constants >= 2 || !TREE_ADDRESSABLE (object)))
+&& (flag_merge_constants >= 2 || !TREE_ADDRESSABLE (object)))
-	  {
+{
-	    if (notify_temp_creation)
+if (notify_temp_creation)
-	      return GS_ERROR;
+return GS_ERROR;
-	    DECL_INITIAL (object) = ctor;
+DECL_INITIAL (object) = ctor;
-	    TREE_STATIC (object) = 1;
+TREE_STATIC (object) = 1;
-	    if (!DECL_NAME (object))
+if (!DECL_NAME (object))
-	      DECL_NAME (object) = create_tmp_var_name ("C");
+DECL_NAME (object) = create_tmp_var_name ("C");
-	    walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
+walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
-	    /* ??? C++ doesn't automatically append a .<number> to the
+/* ??? C++ doesn't automatically append a .<number> to the
-	       assembler name, and even when it does, it looks a FE private
+assembler name, and even when it does, it looks a FE private
-	       data structures to figure out what that number should be,
+data structures to figure out what that number should be,
-	       which are not set for this variable.  I suppose this is
+which are not set for this variable.  I suppose this is
-	       important for local statics for inline functions, which aren't
+important for local statics for inline functions, which aren't
-	       "local" in the object file sense.  So in order to get a unique
+"local" in the object file sense.  So in order to get a unique
-	       TU-local symbol, we must invoke the lhd version now.  */
+TU-local symbol, we must invoke the lhd version now.  */
-	    lhd_set_decl_assembler_name (object);
+lhd_set_decl_assembler_name (object);
-	    *expr_p = NULL_TREE;
+*expr_p = NULL_TREE;
-	    break;
+break;
-	  }
+}
-	/* If there are "lots" of initialized elements, even discounting
+/* If there are "lots" of initialized elements, even discounting
-	   those that are not address constants (and thus *must* be
+those that are not address constants (and thus *must* be
-	   computed at runtime), then partition the constructor into
+computed at runtime), then partition the constructor into
-	   constant and non-constant parts.  Block copy the constant
+constant and non-constant parts.  Block copy the constant
-	   parts in, then generate code for the non-constant parts.  */
+parts in, then generate code for the non-constant parts.  */
-	/* TODO.  There's code in cp/typeck.c to do this.  */
+/* TODO.  There's code in cp/typeck.c to do this.  */
-	num_type_elements = count_type_elements (type, true);
+num_type_elements = count_type_elements (type, true);
-	/* If count_type_elements could not determine number of type elements
+/* If count_type_elements could not determine number of type elements
-	   for a constant-sized object, assume clearing is needed.
+for a constant-sized object, assume clearing is needed.
-	   Don't do this for variable-sized objects, as store_constructor
+Don't do this for variable-sized objects, as store_constructor
-	   will ignore the clearing of variable-sized objects.  */
+will ignore the clearing of variable-sized objects.  */
-	if (num_type_elements < 0 && int_size_in_bytes (type) >= 0)
+if (num_type_elements < 0 && int_size_in_bytes (type) >= 0)
-	  cleared = true;
+cleared = true;
-	/* If there are "lots" of zeros, then block clear the object first.  */
+/* If there are "lots" of zeros, then block clear the object first.  */
-	else if (num_type_elements - num_nonzero_elements
+else if (num_type_elements - num_nonzero_elements
-		 > CLEAR_RATIO (optimize_function_for_speed_p (cfun))
+> CLEAR_RATIO (optimize_function_for_speed_p (cfun))
-		 && num_nonzero_elements < num_type_elements/4)
+&& num_nonzero_elements < num_type_elements/4)
-	  cleared = true;
+cleared = true;
-	/* ??? This bit ought not be needed.  For any element not present
+/* ??? This bit ought not be needed.  For any element not present
-	   in the initializer, we should simply set them to zero.  Except
+in the initializer, we should simply set them to zero.  Except
-	   we'd need to *find* the elements that are not present, and that
+we'd need to *find* the elements that are not present, and that
-	   requires trickery to avoid quadratic compile-time behavior in
+requires trickery to avoid quadratic compile-time behavior in
-	   large cases or excessive memory use in small cases.  */
+large cases or excessive memory use in small cases.  */
-	else if (num_ctor_elements < num_type_elements)
+else if (num_ctor_elements < num_type_elements)
-	  cleared = true;
+cleared = true;
-	/* If there are "lots" of initialized elements, and all of them
+/* If there are "lots" of initialized elements, and all of them
-	   are valid address constants, then the entire initializer can
+are valid address constants, then the entire initializer can
-	   be dropped to memory, and then memcpy'd out.  Don't do this
+be dropped to memory, and then memcpy'd out.  Don't do this
-	   for sparse arrays, though, as it's more efficient to follow
+for sparse arrays, though, as it's more efficient to follow
-	   the standard CONSTRUCTOR behavior of memset followed by
+the standard CONSTRUCTOR behavior of memset followed by
-	   individual element initialization.  Also don't do this for small
+individual element initialization.  Also don't do this for small
-	   all-zero initializers (which aren't big enough to merit
+all-zero initializers (which aren't big enough to merit
-	   clearing), and don't try to make bitwise copies of
+clearing), and don't try to make bitwise copies of
-	   TREE_ADDRESSABLE types.  */
+TREE_ADDRESSABLE types.  */
-	if (valid_const_initializer
+if (valid_const_initializer
-	    && !(cleared || num_nonzero_elements == 0)
+&& !(cleared || num_nonzero_elements == 0)
-	    && !TREE_ADDRESSABLE (type))
+&& !TREE_ADDRESSABLE (type))
-	  {
+{
-	    HOST_WIDE_INT size = int_size_in_bytes (type);
+HOST_WIDE_INT size = int_size_in_bytes (type);
-	    unsigned int align;
+unsigned int align;
-	    /* ??? We can still get unbounded array types, at least
+/* ??? We can still get unbounded array types, at least
-	       from the C++ front end.  This seems wrong, but attempt
+from the C++ front end.  This seems wrong, but attempt
-	       to work around it for now.  */
+to work around it for now.  */
-	    if (size < 0)
+if (size < 0)
-	      {
+{
-		size = int_size_in_bytes (TREE_TYPE (object));
+size = int_size_in_bytes (TREE_TYPE (object));
-		if (size >= 0)
+if (size >= 0)
-		  TREE_TYPE (ctor) = type = TREE_TYPE (object);
+TREE_TYPE (ctor) = type = TREE_TYPE (object);
-	      }
+}
-	    /* Find the maximum alignment we can assume for the object.  */
+/* Find the maximum alignment we can assume for the object.  */
-	    /* ??? Make use of DECL_OFFSET_ALIGN.  */
+/* ??? Make use of DECL_OFFSET_ALIGN.  */
-	    if (DECL_P (object))
+if (DECL_P (object))
-	      align = DECL_ALIGN (object);
+align = DECL_ALIGN (object);
-	    else
+else
-	      align = TYPE_ALIGN (type);
+align = TYPE_ALIGN (type);
-	    if (size > 0
+if (size > 0
-		&& num_nonzero_elements > 1
+&& num_nonzero_elements > 1
-		&& !can_move_by_pieces (size, align))
+&& !can_move_by_pieces (size, align))
-	      {
+{
-		tree new_tree;
+tree new_tree;
-		if (notify_temp_creation)
+if (notify_temp_creation)
-		  return GS_ERROR;
+return GS_ERROR;
-		new_tree = create_tmp_var_raw (type, "C");
+new_tree = create_tmp_var_raw (type, "C");
-		gimple_add_tmp_var (new_tree);
+gimple_add_tmp_var (new_tree);
-		TREE_STATIC (new_tree) = 1;
+TREE_STATIC (new_tree) = 1;
-		TREE_READONLY (new_tree) = 1;
+TREE_READONLY (new_tree) = 1;
-		DECL_INITIAL (new_tree) = ctor;
+DECL_INITIAL (new_tree) = ctor;
-		if (align > DECL_ALIGN (new_tree))
+if (align > DECL_ALIGN (new_tree))
-		  {
+{
-		    DECL_ALIGN (new_tree) = align;
+DECL_ALIGN (new_tree) = align;
-		    DECL_USER_ALIGN (new_tree) = 1;
+DECL_USER_ALIGN (new_tree) = 1;
-		  }
+}
-	        walk_tree (&DECL_INITIAL (new_tree), force_labels_r, NULL, NULL);
+walk_tree (&DECL_INITIAL (new_tree), force_labels_r, NULL, NULL);
-		TREE_OPERAND (*expr_p, 1) = new_tree;
+TREE_OPERAND (*expr_p, 1) = new_tree;
-		/* This is no longer an assignment of a CONSTRUCTOR, but
+/* This is no longer an assignment of a CONSTRUCTOR, but
-		   we still may have processing to do on the LHS.  So
+we still may have processing to do on the LHS.  So
-		   pretend we didn't do anything here to let that happen.  */
+pretend we didn't do anything here to let that happen.  */
-		return GS_UNHANDLED;
+return GS_UNHANDLED;
-	      }
+}
-	  }
+}
-	if (notify_temp_creation)
+if (notify_temp_creation)
-	  return GS_OK;
+return GS_OK;
-	/* If there are nonzero elements, pre-evaluate to capture elements
+/* If there are nonzero elements, pre-evaluate to capture elements
-	   overlapping with the lhs into temporaries.  We must do this before
+overlapping with the lhs into temporaries.  We must do this before
-	   clearing to fetch the values before they are zeroed-out.  */
+clearing to fetch the values before they are zeroed-out.  */
-	if (num_nonzero_elements > 0)
+if (num_nonzero_elements > 0)
-	  {
+{
-	    preeval_data.lhs_base_decl = get_base_address (object);
+preeval_data.lhs_base_decl = get_base_address (object);
-	    if (!DECL_P (preeval_data.lhs_base_decl))
+if (!DECL_P (preeval_data.lhs_base_decl))
-	      preeval_data.lhs_base_decl = NULL;
+preeval_data.lhs_base_decl = NULL;
-	    preeval_data.lhs_alias_set = get_alias_set (object);
+preeval_data.lhs_alias_set = get_alias_set (object);
-	    gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
+gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
-					pre_p, post_p, &preeval_data);
+pre_p, post_p, &preeval_data);
-	  }
+}
-	if (cleared)
+if (cleared)
-	  {
+{
-	    /* Zap the CONSTRUCTOR element list, which simplifies this case.
+/* Zap the CONSTRUCTOR element list, which simplifies this case.
-	       Note that we still have to gimplify, in order to handle the
+Note that we still have to gimplify, in order to handle the
-	       case of variable sized types.  Avoid shared tree structures.  */
+case of variable sized types.  Avoid shared tree structures.  */
-	    CONSTRUCTOR_ELTS (ctor) = NULL;
+CONSTRUCTOR_ELTS (ctor) = NULL;
-	    TREE_SIDE_EFFECTS (ctor) = 0;
+TREE_SIDE_EFFECTS (ctor) = 0;
-	    object = unshare_expr (object);
+object = unshare_expr (object);
-	    gimplify_stmt (expr_p, pre_p);
+gimplify_stmt (expr_p, pre_p);
-	  }
+}
-	/* If we have not block cleared the object, or if there are nonzero
+/* If we have not block cleared the object, or if there are nonzero
-	   elements in the constructor, add assignments to the individual
+elements in the constructor, add assignments to the individual
-	   scalar fields of the object.  */
+scalar fields of the object.  */
-	if (!cleared || num_nonzero_elements > 0)
+if (!cleared || num_nonzero_elements > 0)
-	  gimplify_init_ctor_eval (object, elts, pre_p, cleared);
+gimplify_init_ctor_eval (object, elts, pre_p, cleared);
-	*expr_p = NULL_TREE;
+*expr_p = NULL_TREE;
 }
 break;
 case COMPLEX_TYPE:
 {
-	tree r, i;
+tree r, i;
-	if (notify_temp_creation)
+if (notify_temp_creation)
-	  return GS_OK;
+return GS_OK;
-	/* Extract the real and imaginary parts out of the ctor.  */
+/* Extract the real and imaginary parts out of the ctor.  */
-	gcc_assert (VEC_length (constructor_elt, elts) == 2);
+gcc_assert (VEC_length (constructor_elt, elts) == 2);
-	r = VEC_index (constructor_elt, elts, 0)->value;
+r = VEC_index (constructor_elt, elts, 0)->value;
-	i = VEC_index (constructor_elt, elts, 1)->value;
+i = VEC_index (constructor_elt, elts, 1)->value;
-	if (r == NULL || i == NULL)
+if (r == NULL || i == NULL)
-	  {
+{
-	    tree zero = fold_convert (TREE_TYPE (type), integer_zero_node);
+tree zero = fold_convert (TREE_TYPE (type), integer_zero_node);
-	    if (r == NULL)
+if (r == NULL)
-	      r = zero;
+r = zero;
-	    if (i == NULL)
+if (i == NULL)
-	      i = zero;
+i = zero;
-	  }
+}
-	/* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
+/* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
-	   represent creation of a complex value.  */
+represent creation of a complex value.  */
-	if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
+if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
-	  {
+{
-	    ctor = build_complex (type, r, i);
+ctor = build_complex (type, r, i);
-	    TREE_OPERAND (*expr_p, 1) = ctor;
+TREE_OPERAND (*expr_p, 1) = ctor;
-	  }
+}
-	else
+else
-	  {
+{
-	    ctor = build2 (COMPLEX_EXPR, type, r, i);
+ctor = build2 (COMPLEX_EXPR, type, r, i);
-	    TREE_OPERAND (*expr_p, 1) = ctor;
+TREE_OPERAND (*expr_p, 1) = ctor;
-	    ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1),
+ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1),
-				 pre_p,
+pre_p,
-				 post_p,
+post_p,
-				 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
+rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
-				 fb_rvalue);
+fb_rvalue);
-	  }
+}
 }
 break;
 case VECTOR_TYPE:
 {
-	unsigned HOST_WIDE_INT ix;
+unsigned HOST_WIDE_INT ix;
-	constructor_elt *ce;
+constructor_elt *ce;
-	if (notify_temp_creation)
+if (notify_temp_creation)
-	  return GS_OK;
+return GS_OK;
-	/* Go ahead and simplify constant constructors to VECTOR_CST.  */
+/* Go ahead and simplify constant constructors to VECTOR_CST.  */
-	if (TREE_CONSTANT (ctor))
+if (TREE_CONSTANT (ctor))
-	  {
+{
-	    bool constant_p = true;
+bool constant_p = true;
-	    tree value;
+tree value;
-	    /* Even when ctor is constant, it might contain non-*_CST
+/* Even when ctor is constant, it might contain non-*_CST
-	       elements, such as addresses or trapping values like
+elements, such as addresses or trapping values like
-	       1.0/0.0 - 1.0/0.0.  Such expressions don't belong
+1.0/0.0 - 1.0/0.0.  Such expressions don't belong
-	       in VECTOR_CST nodes.  */
+in VECTOR_CST nodes.  */
-	    FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
+FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
-	      if (!CONSTANT_CLASS_P (value))
+if (!CONSTANT_CLASS_P (value))
-		{
+{
-		  constant_p = false;
+constant_p = false;
-		  break;
+break;
-		}
+}
-	    if (constant_p)
+if (constant_p)
-	      {
+{
-		TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
+TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
-		break;
+break;
-	      }
+}
-	    /* Don't reduce an initializer constant even if we can't
+/* Don't reduce an initializer constant even if we can't
-	       make a VECTOR_CST.  It won't do anything for us, and it'll
+make a VECTOR_CST.  It won't do anything for us, and it'll
-	       prevent us from representing it as a single constant.  */
+prevent us from representing it as a single constant.  */
-	    if (initializer_constant_valid_p (ctor, type))
+if (initializer_constant_valid_p (ctor, type))
-	      break;
+break;
-	    TREE_CONSTANT (ctor) = 0;
+TREE_CONSTANT (ctor) = 0;
-	  }
+}
-	/* Vector types use CONSTRUCTOR all the way through gimple
+/* Vector types use CONSTRUCTOR all the way through gimple
-	  compilation as a general initializer.  */
+compilation as a general initializer.  */
-	for (ix = 0; VEC_iterate (constructor_elt, elts, ix, ce); ix++)
+for (ix = 0; VEC_iterate (constructor_elt, elts, ix, ce); ix++)
-	  {
+{
-	    enum gimplify_status tret;
+enum gimplify_status tret;
-	    tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val,
+tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val,
-				  fb_rvalue);
+fb_rvalue);
-	    if (tret == GS_ERROR)
+if (tret == GS_ERROR)
-	      ret = GS_ERROR;
+ret = GS_ERROR;
-	  }
+}
-	if (!is_gimple_reg (TREE_OPERAND (*expr_p, 0)))
+if (!is_gimple_reg (TREE_OPERAND (*expr_p, 0)))
-	  TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
+TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
 }
 break;
 default:
 /* So how did we get a CONSTRUCTOR for a scalar type?  */
 return GS_OK;
 }
 else
 {
 /* If we have gimplified both sides of the initializer but have
-	 not emitted an assignment, do so now.  */
+not emitted an assignment, do so now.  */
 if (*expr_p)
-	{
+{
-	  tree lhs = TREE_OPERAND (*expr_p, 0);
+tree lhs = TREE_OPERAND (*expr_p, 0);
-	  tree rhs = TREE_OPERAND (*expr_p, 1);
+tree rhs = TREE_OPERAND (*expr_p, 1);
-	  gimple init = gimple_build_assign (lhs, rhs);
+gimple init = gimple_build_assign (lhs, rhs);
-	  gimplify_seq_add_stmt (pre_p, init);
+gimplify_seq_add_stmt (pre_p, init);
-	  *expr_p = NULL;
+*expr_p = NULL;
-	}
+}
 return GS_ALL_DONE;
 }
 }
 if (useless_type_conversion_p (type, optype))
 return op;
 /* *(foo *)&fooarray => fooarray[0] */
 if (TREE_CODE (optype) == ARRAY_TYPE
-	  && useless_type_conversion_p (type, TREE_TYPE (optype)))
+&& useless_type_conversion_p (type, TREE_TYPE (optype)))
 {
 tree type_domain = TYPE_DOMAIN (optype);
 tree min_val = size_zero_node;
 if (type_domain && TYPE_MIN_VALUE (type_domain))
 min_val = TYPE_MIN_VALUE (type_domain);
 tree type_domain;
 tree min_val = size_zero_node;
 tree osub = sub;
 sub = gimple_fold_indirect_ref (sub);
 if (! sub)
-	sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
+sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
 if (type_domain && TYPE_MIN_VALUE (type_domain))
 min_val = TYPE_MIN_VALUE (type_domain);
 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
 }
 MODIFY_EXPRs based on the code of the RHS.  We loop for as long as
 something changes.  */
 static enum gimplify_status
 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p,
-			  gimple_seq *pre_p, gimple_seq *post_p,
+gimple_seq *pre_p, gimple_seq *post_p,
-			  bool want_value)
+bool want_value)
 {
 enum gimplify_status ret = GS_OK;
 while (ret != GS_UNHANDLED)
 switch (TREE_CODE (*from_p))
 {
 case VAR_DECL:
-	/* If we're assigning from a constant constructor, move the
+/* If we're assigning from a read-only variable initialized with
-	   constructor expression to the RHS of the MODIFY_EXPR.  */
+a constructor, do the direct assignment from the constructor,
-	if (DECL_INITIAL (*from_p)
+but only if neither source nor target are volatile since this
-	    && TREE_READONLY (*from_p)
+latter assignment might end up being done on a per-field basis.  */
-	    && !TREE_THIS_VOLATILE (*from_p)
+if (DECL_INITIAL (*from_p)
-	    && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
+&& TREE_READONLY (*from_p)
-	  {
+&& !TREE_THIS_VOLATILE (*from_p)
-	    tree old_from = *from_p;
+&& !TREE_THIS_VOLATILE (*to_p)
+&& TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
-	    /* Move the constructor into the RHS.  */
+{
-	    *from_p = unshare_expr (DECL_INITIAL (*from_p));
+tree old_from = *from_p;
-	    /* Let's see if gimplify_init_constructor will need to put
+/* Move the constructor into the RHS.  */
-	       it in memory.  If so, revert the change.  */
+*from_p = unshare_expr (DECL_INITIAL (*from_p));
-	    ret = gimplify_init_constructor (expr_p, NULL, NULL, false, true);
-	    if (ret == GS_ERROR)
+/* Let's see if gimplify_init_constructor will need to put
-	      {
+it in memory.  If so, revert the change.  */
-		*from_p = old_from;
+ret = gimplify_init_constructor (expr_p, NULL, NULL, false, true);
-		/* Fall through.  */
+if (ret == GS_ERROR)
-	      }
+{
-	    else
+*from_p = old_from;
-	      {
+/* Fall through.  */
-		ret = GS_OK;
+}
-		break;
+else
-	      }
+{
-	  }
+ret = GS_OK;
-	ret = GS_UNHANDLED;
+break;
-	break;
+}
+}
+ret = GS_UNHANDLED;
+break;
 case INDIRECT_REF:
-	{
+{
-	  /* If we have code like
+/* If we have code like
-	        *(const A*)(A*)&x
+*(const A*)(A*)&x
-	     where the type of "x" is a (possibly cv-qualified variant
+where the type of "x" is a (possibly cv-qualified variant
-	     of "A"), treat the entire expression as identical to "x".
+of "A"), treat the entire expression as identical to "x".
-	     This kind of code arises in C++ when an object is bound
+This kind of code arises in C++ when an object is bound
-	     to a const reference, and if "x" is a TARGET_EXPR we want
+to a const reference, and if "x" is a TARGET_EXPR we want
-	     to take advantage of the optimization below.  */
+to take advantage of the optimization below.  */
-	  tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
+tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
-	  if (t)
+if (t)
-	    {
+{
-	      *from_p = t;
+*from_p = t;
-	      ret = GS_OK;
+ret = GS_OK;
-	    }
+}
-	  else
+else
-	    ret = GS_UNHANDLED;
+ret = GS_UNHANDLED;
-	  break;
+break;
-	}
+}
 case TARGET_EXPR:
-	{
+{
-	  /* If we are initializing something from a TARGET_EXPR, strip the
+/* If we are initializing something from a TARGET_EXPR, strip the
-	     TARGET_EXPR and initialize it directly, if possible.  This can't
+TARGET_EXPR and initialize it directly, if possible.  This can't
-	     be done if the initializer is void, since that implies that the
+be done if the initializer is void, since that implies that the
-	     temporary is set in some non-trivial way.
+temporary is set in some non-trivial way.
-	     ??? What about code that pulls out the temp and uses it
+??? What about code that pulls out the temp and uses it
-	     elsewhere? I think that such code never uses the TARGET_EXPR as
+elsewhere? I think that such code never uses the TARGET_EXPR as
-	     an initializer.  If I'm wrong, we'll die because the temp won't
+an initializer.  If I'm wrong, we'll die because the temp won't
-	     have any RTL.  In that case, I guess we'll need to replace
+have any RTL.  In that case, I guess we'll need to replace
-	     references somehow.  */
+references somehow.  */
-	  tree init = TARGET_EXPR_INITIAL (*from_p);
+tree init = TARGET_EXPR_INITIAL (*from_p);
-	  if (init
+if (init
-	      && !VOID_TYPE_P (TREE_TYPE (init)))
+&& !VOID_TYPE_P (TREE_TYPE (init)))
-	    {
+{
-	      *from_p = init;
+*from_p = init;
-	      ret = GS_OK;
+ret = GS_OK;
-	    }
+}
-	  else
+else
-	    ret = GS_UNHANDLED;
+ret = GS_UNHANDLED;
-	}
+}
-	break;
+break;
 case COMPOUND_EXPR:
-	/* Remove any COMPOUND_EXPR in the RHS so the following cases will be
+/* Remove any COMPOUND_EXPR in the RHS so the following cases will be
-	   caught.  */
+caught.  */
-	gimplify_compound_expr (from_p, pre_p, true);
+gimplify_compound_expr (from_p, pre_p, true);
-	ret = GS_OK;
+ret = GS_OK;
-	break;
+break;
 case CONSTRUCTOR:
-	/* If we're initializing from a CONSTRUCTOR, break this into
+/* If we're initializing from a CONSTRUCTOR, break this into
-	   individual MODIFY_EXPRs.  */
+individual MODIFY_EXPRs.  */
-	return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
+return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
-					  false);
+false);
 case COND_EXPR:
-	/* If we're assigning to a non-register type, push the assignment
+/* If we're assigning to a non-register type, push the assignment
-	   down into the branches.  This is mandatory for ADDRESSABLE types,
+down into the branches.  This is mandatory for ADDRESSABLE types,
-	   since we cannot generate temporaries for such, but it saves a
+since we cannot generate temporaries for such, but it saves a
-	   copy in other cases as well.  */
+copy in other cases as well.  */
-	if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
+if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
-	  {
+{
-	    /* This code should mirror the code in gimplify_cond_expr. */
+/* This code should mirror the code in gimplify_cond_expr. */
-	    enum tree_code code = TREE_CODE (*expr_p);
+enum tree_code code = TREE_CODE (*expr_p);
-	    tree cond = *from_p;
+tree cond = *from_p;
-	    tree result = *to_p;
+tree result = *to_p;
-	    ret = gimplify_expr (&result, pre_p, post_p,
+ret = gimplify_expr (&result, pre_p, post_p,
-				 is_gimple_lvalue, fb_lvalue);
+is_gimple_lvalue, fb_lvalue);
-	    if (ret != GS_ERROR)
+if (ret != GS_ERROR)
-	      ret = GS_OK;
+ret = GS_OK;
-	    if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
+if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
-	      TREE_OPERAND (cond, 1)
+TREE_OPERAND (cond, 1)
-		= build2 (code, void_type_node, result,
+= build2 (code, void_type_node, result,
-			  TREE_OPERAND (cond, 1));
+TREE_OPERAND (cond, 1));
-	    if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
+if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
-	      TREE_OPERAND (cond, 2)
+TREE_OPERAND (cond, 2)
-		= build2 (code, void_type_node, unshare_expr (result),
+= build2 (code, void_type_node, unshare_expr (result),
-			  TREE_OPERAND (cond, 2));
+TREE_OPERAND (cond, 2));
-	    TREE_TYPE (cond) = void_type_node;
+TREE_TYPE (cond) = void_type_node;
-	    recalculate_side_effects (cond);
+recalculate_side_effects (cond);
-	    if (want_value)
+if (want_value)
-	      {
+{
-		gimplify_and_add (cond, pre_p);
+gimplify_and_add (cond, pre_p);
-		*expr_p = unshare_expr (result);
+*expr_p = unshare_expr (result);
-	      }
+}
-	    else
+else
-	      *expr_p = cond;
+*expr_p = cond;
-	    return ret;
+return ret;
-	  }
+}
-	else
+else
-	  ret = GS_UNHANDLED;
+ret = GS_UNHANDLED;
-	break;
+break;
 case CALL_EXPR:
-	/* For calls that return in memory, give *to_p as the CALL_EXPR's
+/* For calls that return in memory, give *to_p as the CALL_EXPR's
-	   return slot so that we don't generate a temporary.  */
+return slot so that we don't generate a temporary.  */
-	if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
+if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
-	    && aggregate_value_p (*from_p, *from_p))
+&& aggregate_value_p (*from_p, *from_p))
-	  {
+{
-	    bool use_target;
+bool use_target;
-	    if (!(rhs_predicate_for (*to_p))(*from_p))
+if (!(rhs_predicate_for (*to_p))(*from_p))
-	      /* If we need a temporary, *to_p isn't accurate.  */
+/* If we need a temporary, *to_p isn't accurate.  */
-	      use_target = false;
+use_target = false;
-	    else if (TREE_CODE (*to_p) == RESULT_DECL
+else if (TREE_CODE (*to_p) == RESULT_DECL
-		     && DECL_NAME (*to_p) == NULL_TREE
+&& DECL_NAME (*to_p) == NULL_TREE
-		     && needs_to_live_in_memory (*to_p))
+&& needs_to_live_in_memory (*to_p))
-	      /* It's OK to use the return slot directly unless it's an NRV. */
+/* It's OK to use the return slot directly unless it's an NRV. */
-	      use_target = true;
+use_target = true;
-	    else if (is_gimple_reg_type (TREE_TYPE (*to_p))
+else if (is_gimple_reg_type (TREE_TYPE (*to_p))
-		     || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
+|| (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
-	      /* Don't force regs into memory.  */
+/* Don't force regs into memory.  */
-	      use_target = false;
+use_target = false;
-	    else if (TREE_CODE (*to_p) == VAR_DECL
+else if (TREE_CODE (*expr_p) == INIT_EXPR)
-		     && DECL_GIMPLE_FORMAL_TEMP_P (*to_p))
+/* It's OK to use the target directly if it's being
-	      /* Don't use the original target if it's a formal temp; we
+initialized. */
-		 don't want to take their addresses.  */
+use_target = true;
-	      use_target = false;
+else if (!is_gimple_non_addressable (*to_p))
-	    else if (TREE_CODE (*expr_p) == INIT_EXPR)
+/* Don't use the original target if it's already addressable;
-	      /* It's OK to use the target directly if it's being
+if its address escapes, and the called function uses the
-		 initialized. */
+NRV optimization, a conforming program could see *to_p
-	      use_target = true;
+change before the called function returns; see c++/19317.
-	    else if (!is_gimple_non_addressable (*to_p))
+When optimizing, the return_slot pass marks more functions
-	      /* Don't use the original target if it's already addressable;
+as safe after we have escape info.  */
-		 if its address escapes, and the called function uses the
+use_target = false;
-		 NRV optimization, a conforming program could see *to_p
+else
-		 change before the called function returns; see c++/19317.
+use_target = true;
-		 When optimizing, the return_slot pass marks more functions
-		 as safe after we have escape info.  */
+if (use_target)
-	      use_target = false;
+{
-	    else
+CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
-	      use_target = true;
+mark_addressable (*to_p);
+}
-	    if (use_target)
+}
-	      {
-		CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
+ret = GS_UNHANDLED;
-		mark_addressable (*to_p);
+break;
-	      }
-	  }
+/* If we're initializing from a container, push the initialization
+inside it.  */
-	ret = GS_UNHANDLED;
-	break;
-	/* If we're initializing from a container, push the initialization
-	   inside it.  */
 case CLEANUP_POINT_EXPR:
 case BIND_EXPR:
 case STATEMENT_LIST:
-	{
+{
-	  tree wrap = *from_p;
+tree wrap = *from_p;
-	  tree t;
+tree t;
-	  ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
+ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
-			       fb_lvalue);
+fb_lvalue);
-	  if (ret != GS_ERROR)
+if (ret != GS_ERROR)
-	    ret = GS_OK;
+ret = GS_OK;
-	  t = voidify_wrapper_expr (wrap, *expr_p);
+t = voidify_wrapper_expr (wrap, *expr_p);
-	  gcc_assert (t == *expr_p);
+gcc_assert (t == *expr_p);
-	  if (want_value)
+if (want_value)
-	    {
+{
-	      gimplify_and_add (wrap, pre_p);
+gimplify_and_add (wrap, pre_p);
-	      *expr_p = unshare_expr (*to_p);
+*expr_p = unshare_expr (*to_p);
-	    }
+}
-	  else
+else
-	    *expr_p = wrap;
+*expr_p = wrap;
-	  return GS_OK;
+return GS_OK;
-	}
+}
+case COMPOUND_LITERAL_EXPR:
+{
+tree complit = TREE_OPERAND (*expr_p, 1);
+tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (complit);
+tree decl = DECL_EXPR_DECL (decl_s);
+tree init = DECL_INITIAL (decl);
+/* struct T x = (struct T) { 0, 1, 2 } can be optimized
+into struct T x = { 0, 1, 2 } if the address of the
+compound literal has never been taken.  */
+if (!TREE_ADDRESSABLE (complit)
+&& !TREE_ADDRESSABLE (decl)
+&& init)
+{
+*expr_p = copy_node (*expr_p);
+TREE_OPERAND (*expr_p, 1) = init;
+return GS_OK;
+}
+}
 default:
-	ret = GS_UNHANDLED;
+ret = GS_UNHANDLED;
-	break;
+break;
 }
 return ret;
 }
 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
 modify_expr
-	      : varname '=' rhs
+: varname '=' rhs
-	      | '*' ID '=' rhs
+| '*' ID '=' rhs
 PRE_P points to the list where side effects that must happen before
-	*EXPR_P should be stored.
+*EXPR_P should be stored.
 POST_P points to the list where side effects that must happen after
-	*EXPR_P should be stored.
+*EXPR_P should be stored.
 WANT_VALUE is nonzero iff we want to use the value of this expression
-	in another expression.  */
+in another expression.  */
 static enum gimplify_status
 gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
-		      bool want_value)
+bool want_value)
 {
 tree *from_p = &TREE_OPERAND (*expr_p, 1);
 tree *to_p = &TREE_OPERAND (*expr_p, 0);
 enum gimplify_status ret = GS_UNHANDLED;
 gimple assign;
+location_t loc = EXPR_LOCATION (*expr_p);
 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
-	      || TREE_CODE (*expr_p) == INIT_EXPR);
+|| TREE_CODE (*expr_p) == INIT_EXPR);
 /* Insert pointer conversions required by the middle-end that are not
 required by the frontend.  This fixes middle-end type checking for
 for example gcc.dg/redecl-6.c.  */
-if (POINTER_TYPE_P (TREE_TYPE (*to_p))
+if (POINTER_TYPE_P (TREE_TYPE (*to_p)))
-&& lang_hooks.types_compatible_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
 {
 STRIP_USELESS_TYPE_CONVERSION (*from_p);
 if (!useless_type_conversion_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
-	*from_p = fold_convert (TREE_TYPE (*to_p), *from_p);
+*from_p = fold_convert_loc (loc, TREE_TYPE (*to_p), *from_p);
 }
 /* See if any simplifications can be done based on what the RHS is.  */
 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
-				  want_value);
+want_value);
 if (ret != GS_UNHANDLED)
 return ret;
 /* For zero sized types only gimplify the left hand side and right hand
 side as statements and throw away the assignment.  Do this after
 foo's LHS, we tell it that it should only gimplify until it
 reaches the CALL_EXPR.  On return from gimplify_expr, the newly
 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
 and all we need to do here is set 'a' to be its LHS.  */
 ret = gimplify_expr (from_p, pre_p, post_p, rhs_predicate_for (*to_p),
-		       fb_rvalue);
+fb_rvalue);
 if (ret == GS_ERROR)
 return ret;
 /* Now see if the above changed *from_p to something we handle specially.  */
 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
-				  want_value);
+want_value);
 if (ret != GS_UNHANDLED)
 return ret;
 /* If we've got a variable sized assignment between two lvalues (i.e. does
 not involve a call), then we can make things a bit more straightforward
 {
 tree from = TREE_OPERAND (*from_p, 0);
 tree size = TREE_OPERAND (*from_p, 1);
 if (TREE_CODE (from) == CONSTRUCTOR)
-	return gimplify_modify_expr_to_memset (expr_p, size, want_value, pre_p);
+return gimplify_modify_expr_to_memset (expr_p, size, want_value, pre_p);
 if (is_gimple_addressable (from))
-	{
+{
-	  *from_p = from;
+*from_p = from;
-	  return gimplify_modify_expr_to_memcpy (expr_p, size, want_value,
+return gimplify_modify_expr_to_memcpy (expr_p, size, want_value,
-	      					 pre_p);
+pre_p);
-	}
+}
 }
 /* Transform partial stores to non-addressable complex variables into
 total stores.  This allows us to use real instead of virtual operands
 for these variables, which improves optimization.  */
 && DECL_IGNORED_P (*from_p)
 && DECL_P (*to_p)
 && !DECL_IGNORED_P (*to_p))
 {
 if (!DECL_NAME (*from_p) && DECL_NAME (*to_p))
-	DECL_NAME (*from_p)
+DECL_NAME (*from_p)
-	  = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
+= create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
 DECL_DEBUG_EXPR_IS_FROM (*from_p) = 1;
 SET_DECL_DEBUG_EXPR (*from_p, *to_p);
 }
 if (TREE_CODE (*from_p) == CALL_EXPR)
 {
 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
-	 instead of a GIMPLE_ASSIGN.  */
+instead of a GIMPLE_ASSIGN.  */
 assign = gimple_build_call_from_tree (*from_p);
 gimple_call_set_lhs (assign, *to_p);
 }
 else
-assign = gimple_build_assign (*to_p, *from_p);
+{
+assign = gimple_build_assign (*to_p, *from_p);
+gimple_set_location (assign, EXPR_LOCATION (*expr_p));
+}
 gimplify_seq_add_stmt (pre_p, assign);
 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
 {
 /* If we've somehow already got an SSA_NAME on the LHS, then
-	 we've probably modified it twice.  Not good.  */
+we've probably modified it twice.  Not good.  */
 gcc_assert (TREE_CODE (*to_p) != SSA_NAME);
 *to_p = make_ssa_name (*to_p, assign);
 gimple_set_lhs (assign, *to_p);
 }
 gimplify_variable_sized_compare (tree *expr_p)
 {
 tree op0 = TREE_OPERAND (*expr_p, 0);
 tree op1 = TREE_OPERAND (*expr_p, 1);
 tree t, arg, dest, src;
+location_t loc = EXPR_LOCATION (*expr_p);
 arg = TYPE_SIZE_UNIT (TREE_TYPE (op0));
 arg = unshare_expr (arg);
 arg = SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg, op0);
-src = build_fold_addr_expr (op1);
+src = build_fold_addr_expr_loc (loc, op1);
-dest = build_fold_addr_expr (op0);
+dest = build_fold_addr_expr_loc (loc, op0);
 t = implicit_built_in_decls[BUILT_IN_MEMCMP];
-t = build_call_expr (t, 3, dest, src, arg);
+t = build_call_expr_loc (loc, t, 3, dest, src, arg);
 *expr_p
 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
 return GS_OK;
 }
 mode as a comparison between the bitwise equivalent scalar values.  */
 static enum gimplify_status
 gimplify_scalar_mode_aggregate_compare (tree *expr_p)
 {
+location_t loc = EXPR_LOCATION (*expr_p);
 tree op0 = TREE_OPERAND (*expr_p, 0);
 tree op1 = TREE_OPERAND (*expr_p, 1);
 tree type = TREE_TYPE (op0);
 tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
-op0 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op0);
+op0 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op0);
-op1 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op1);
+op1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op1);
 *expr_p
-= fold_build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
+= fold_build2_loc (loc, TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
 return GS_OK;
 }
 /*  Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions.  EXPR_P
 points to the expression to gimplify.
 Expressions of the form 'a && b' are gimplified to:
-	a && b ? true : false
+a && b ? true : false
-gimplify_cond_expr will do the rest.
+LOCUS is the source location to be put on the generated COND_EXPR.
+gimplify_cond_expr will do the rest.  */
-PRE_P points to the list where side effects that must happen before
-	*EXPR_P should be stored.  */
 static enum gimplify_status
-gimplify_boolean_expr (tree *expr_p)
+gimplify_boolean_expr (tree *expr_p, location_t locus)
 {
 /* Preserve the original type of the expression.  */
 tree type = TREE_TYPE (*expr_p);
 *expr_p = build3 (COND_EXPR, type, *expr_p,
-		    fold_convert (type, boolean_true_node),
+fold_convert_loc (locus, type, boolean_true_node),
-		    fold_convert (type, boolean_false_node));
+fold_convert_loc (locus, type, boolean_false_node));
+SET_EXPR_LOCATION (*expr_p, locus);
 return GS_OK;
 }
 /* Gimplifies an expression sequence.  This function gimplifies each
 do
 {
 tree *sub_p = &TREE_OPERAND (t, 0);
 if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
-	gimplify_compound_expr (sub_p, pre_p, false);
+gimplify_compound_expr (sub_p, pre_p, false);
 else
-	gimplify_stmt (sub_p, pre_p);
+gimplify_stmt (sub_p, pre_p);
 t = TREE_OPERAND (t, 1);
 }
 while (TREE_CODE (t) == COMPOUND_EXPR);
 /* If the SAVE_EXPR has not been resolved, then evaluate it once.  */
 if (!SAVE_EXPR_RESOLVED_P (*expr_p))
 {
 /* The operand may be a void-valued expression such as SAVE_EXPRs
-	 generated by the Java frontend for class initialization.  It is
+generated by the Java frontend for class initialization.  It is
-	 being executed only for its side-effects.  */
+being executed only for its side-effects.  */
 if (TREE_TYPE (val) == void_type_node)
-	{
+{
-	  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
+ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
-			       is_gimple_stmt, fb_none);
+is_gimple_stmt, fb_none);
-	  val = NULL;
+val = NULL;
-	}
+}
 else
-	val = get_initialized_tmp_var (val, pre_p, post_p);
+val = get_initialized_tmp_var (val, pre_p, post_p);
 TREE_OPERAND (*expr_p, 0) = val;
 SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
 }
 }
 /*  Re-write the ADDR_EXPR node pointed to by EXPR_P
 unary_expr
-	      : ...
+: ...
-	      | '&' varname
+| '&' varname
-	      ...
+...
 PRE_P points to the list where side effects that must happen before
-	*EXPR_P should be stored.
+*EXPR_P should be stored.
 POST_P points to the list where side effects that must happen after
-	*EXPR_P should be stored.  */
+*EXPR_P should be stored.  */
 static enum gimplify_status
 gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
 {
 tree expr = *expr_p;
 tree op0 = TREE_OPERAND (expr, 0);
 enum gimplify_status ret;
+location_t loc = EXPR_LOCATION (*expr_p);
 switch (TREE_CODE (op0))
 {
 case INDIRECT_REF:
 case MISALIGNED_INDIRECT_REF:
 do_indirect_ref:
 /* Check if we are dealing with an expression of the form '&*ptr'.
-	 While the front end folds away '&*ptr' into 'ptr', these
+While the front end folds away '&*ptr' into 'ptr', these
-	 expressions may be generated internally by the compiler (e.g.,
+expressions may be generated internally by the compiler (e.g.,
-	 builtins like __builtin_va_end).  */
+builtins like __builtin_va_end).  */
 /* Caution: the silent array decomposition semantics we allow for
-	 ADDR_EXPR means we can't always discard the pair.  */
+ADDR_EXPR means we can't always discard the pair.  */
 /* Gimplification of the ADDR_EXPR operand may drop
-	 cv-qualification conversions, so make sure we add them if
+cv-qualification conversions, so make sure we add them if
-	 needed.  */
+needed.  */
 {
-	tree op00 = TREE_OPERAND (op0, 0);
+tree op00 = TREE_OPERAND (op0, 0);
-	tree t_expr = TREE_TYPE (expr);
+tree t_expr = TREE_TYPE (expr);
-	tree t_op00 = TREE_TYPE (op00);
+tree t_op00 = TREE_TYPE (op00);
 if (!useless_type_conversion_p (t_expr, t_op00))
-	  op00 = fold_convert (TREE_TYPE (expr), op00);
+op00 = fold_convert_loc (loc, TREE_TYPE (expr), op00);
 *expr_p = op00;
 ret = GS_OK;
 }
 break;
 case VIEW_CONVERT_EXPR:
 /* Take the address of our operand and then convert it to the type of
-	 this ADDR_EXPR.
+this ADDR_EXPR.
-	 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
+??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
-	 all clear.  The impact of this transformation is even less clear.  */
+all clear.  The impact of this transformation is even less clear.  */
 /* If the operand is a useless conversion, look through it.  Doing so
-	 guarantees that the ADDR_EXPR and its operand will remain of the
+guarantees that the ADDR_EXPR and its operand will remain of the
-	 same type.  */
+same type.  */
 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
-	op0 = TREE_OPERAND (op0, 0);
+op0 = TREE_OPERAND (op0, 0);
-*expr_p = fold_convert (TREE_TYPE (expr),
+*expr_p = fold_convert_loc (loc, TREE_TYPE (expr),
-			      build_fold_addr_expr (TREE_OPERAND (op0, 0)));
+build_fold_addr_expr_loc (loc,
+TREE_OPERAND (op0, 0)));
 ret = GS_OK;
 break;
 default:
 /* We use fb_either here because the C frontend sometimes takes
-	 the address of a call that returns a struct; see
+the address of a call that returns a struct; see
-	 gcc.dg/c99-array-lval-1.c.  The gimplifier will correctly make
+gcc.dg/c99-array-lval-1.c.  The gimplifier will correctly make
-	 the implied temporary explicit.  */
+the implied temporary explicit.  */
-/* Mark the RHS addressable.  */
+/* Make the operand addressable.  */
 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
-			   is_gimple_addressable, fb_either);
+is_gimple_addressable, fb_either);
 if (ret == GS_ERROR)
-	break;
+break;
-/* We cannot rely on making the RHS addressable if it is
+/* Then mark it.  Beware that it may not be possible to do so directly
-	 a temporary created by gimplification.  In this case create a
+if a temporary has been created by the gimplification.  */
-	 new temporary that is initialized by a copy (which will
+prepare_gimple_addressable (&TREE_OPERAND (expr, 0), pre_p);
-	 become a store after we mark it addressable).
-	 This mostly happens if the frontend passed us something that
-	 it could not mark addressable yet, like a fortran
-	 pass-by-reference parameter (int) floatvar.  */
-if (is_gimple_formal_tmp_var (TREE_OPERAND (expr, 0)))
-	TREE_OPERAND (expr, 0)
-	  = get_initialized_tmp_var (TREE_OPERAND (expr, 0), pre_p, post_p);
 op0 = TREE_OPERAND (expr, 0);
 /* For various reasons, the gimplification of the expression
-	 may have made a new INDIRECT_REF.  */
+may have made a new INDIRECT_REF.  */
 if (TREE_CODE (op0) == INDIRECT_REF)
-	goto do_indirect_ref;
+goto do_indirect_ref;
+mark_addressable (TREE_OPERAND (expr, 0));
+/* The FEs may end up building ADDR_EXPRs early on a decl with
+an incomplete type.  Re-build ADDR_EXPRs in canonical form
+here.  */
+if (!types_compatible_p (TREE_TYPE (op0), TREE_TYPE (TREE_TYPE (expr))))
+*expr_p = build_fold_addr_expr (op0);
 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly.  */
-recompute_tree_invariant_for_addr_expr (expr);
+recompute_tree_invariant_for_addr_expr (*expr_p);
-mark_addressable (TREE_OPERAND (expr, 0));
+/* If we re-built the ADDR_EXPR add a conversion to the original type
+if required.  */
+if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
+*expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
 break;
 }
 return ret;
 }
 enum gimplify_status ret, tret;
 gimple stmt;
 VEC(tree, gc) *inputs;
 VEC(tree, gc) *outputs;
 VEC(tree, gc) *clobbers;
+VEC(tree, gc) *labels;
 tree link_next;
 expr = *expr_p;
 noutputs = list_length (ASM_OUTPUTS (expr));
 oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
-inputs = outputs = clobbers = NULL;
+inputs = outputs = clobbers = labels = NULL;
 ret = GS_ALL_DONE;
 link_next = NULL_TREE;
 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = link_next)
 {
 size_t constraint_len;
 link_next = TREE_CHAIN (link);
 oconstraints[i]
-	= constraint
+= constraint
-	= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
+= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
 constraint_len = strlen (constraint);
 if (constraint_len == 0)
 continue;
 ok = parse_output_constraint (&constraint, i, 0, 0,
-				    &allows_mem, &allows_reg, &is_inout);
+&allows_mem, &allows_reg, &is_inout);
 if (!ok)
-	{
+{
-	  ret = GS_ERROR;
+ret = GS_ERROR;
-	  is_inout = false;
+is_inout = false;
-	}
+}
 if (!allows_reg && allows_mem)
-	mark_addressable (TREE_VALUE (link));
+mark_addressable (TREE_VALUE (link));
 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
-			    is_inout ? is_gimple_min_lval : is_gimple_lvalue,
+is_inout ? is_gimple_min_lval : is_gimple_lvalue,
-			    fb_lvalue | fb_mayfail);
+fb_lvalue | fb_mayfail);
 if (tret == GS_ERROR)
-	{
+{
-	  error ("invalid lvalue in asm output %d", i);
+error ("invalid lvalue in asm output %d", i);
-	  ret = tret;
+ret = tret;
-	}
+}
 VEC_safe_push (tree, gc, outputs, link);
 TREE_CHAIN (link) = NULL_TREE;
 if (is_inout)
-	{
+{
-	  /* An input/output operand.  To give the optimizers more
+/* An input/output operand.  To give the optimizers more
-	     flexibility, split it into separate input and output
+flexibility, split it into separate input and output
-	     operands.  */
+operands.  */
-	  tree input;
+tree input;
-	  char buf[10];
+char buf[10];
-	  /* Turn the in/out constraint into an output constraint.  */
+/* Turn the in/out constraint into an output constraint.  */
-	  char *p = xstrdup (constraint);
+char *p = xstrdup (constraint);
-	  p[0] = '=';
+p[0] = '=';
-	  TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
+TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
-	  /* And add a matching input constraint.  */
+/* And add a matching input constraint.  */
-	  if (allows_reg)
+if (allows_reg)
-	    {
+{
-	      sprintf (buf, "%d", i);
+sprintf (buf, "%d", i);
-	      /* If there are multiple alternatives in the constraint,
+/* If there are multiple alternatives in the constraint,
-		 handle each of them individually.  Those that allow register
+handle each of them individually.  Those that allow register
-		 will be replaced with operand number, the others will stay
+will be replaced with operand number, the others will stay
-		 unchanged.  */
+unchanged.  */
-	      if (strchr (p, ',') != NULL)
+if (strchr (p, ',') != NULL)
-		{
+{
-		  size_t len = 0, buflen = strlen (buf);
+size_t len = 0, buflen = strlen (buf);
-		  char *beg, *end, *str, *dst;
+char *beg, *end, *str, *dst;
-		  for (beg = p + 1;;)
+for (beg = p + 1;;)
-		    {
+{
-		      end = strchr (beg, ',');
+end = strchr (beg, ',');
-		      if (end == NULL)
+if (end == NULL)
-			end = strchr (beg, '\0');
+end = strchr (beg, '\0');
-		      if ((size_t) (end - beg) < buflen)
+if ((size_t) (end - beg) < buflen)
-			len += buflen + 1;
+len += buflen + 1;
-		      else
+else
-			len += end - beg + 1;
+len += end - beg + 1;
-		      if (*end)
+if (*end)
-			beg = end + 1;
+beg = end + 1;
-		      else
+else
-			break;
+break;
-		    }
+}
-		  str = (char *) alloca (len);
+str = (char *) alloca (len);
-		  for (beg = p + 1, dst = str;;)
+for (beg = p + 1, dst = str;;)
-		    {
+{
-		      const char *tem;
+const char *tem;
-		      bool mem_p, reg_p, inout_p;
+bool mem_p, reg_p, inout_p;
-		      end = strchr (beg, ',');
+end = strchr (beg, ',');
-		      if (end)
+if (end)
-			*end = '\0';
+*end = '\0';
-		      beg[-1] = '=';
+beg[-1] = '=';
-		      tem = beg - 1;
+tem = beg - 1;
-		      parse_output_constraint (&tem, i, 0, 0,
+parse_output_constraint (&tem, i, 0, 0,
-					       &mem_p, &reg_p, &inout_p);
+&mem_p, &reg_p, &inout_p);
-		      if (dst != str)
+if (dst != str)
-			*dst++ = ',';
+*dst++ = ',';
-		      if (reg_p)
+if (reg_p)
-			{
+{
-			  memcpy (dst, buf, buflen);
+memcpy (dst, buf, buflen);
-			  dst += buflen;
+dst += buflen;
-			}
+}
-		      else
+else
-			{
+{
-			  if (end)
+if (end)
-			    len = end - beg;
+len = end - beg;
-			  else
+else
-			    len = strlen (beg);
+len = strlen (beg);
-			  memcpy (dst, beg, len);
+memcpy (dst, beg, len);
-			  dst += len;
+dst += len;
-			}
+}
-		      if (end)
+if (end)
-			beg = end + 1;
+beg = end + 1;
-		      else
+else
-			break;
+break;
-		    }
+}
-		  *dst = '\0';
+*dst = '\0';
-		  input = build_string (dst - str, str);
+input = build_string (dst - str, str);
-		}
+}
-	      else
+else
-		input = build_string (strlen (buf), buf);
+input = build_string (strlen (buf), buf);
-	    }
+}
-	  else
+else
-	    input = build_string (constraint_len - 1, constraint + 1);
+input = build_string (constraint_len - 1, constraint + 1);
-	  free (p);
+free (p);
-	  input = build_tree_list (build_tree_list (NULL_TREE, input),
+input = build_tree_list (build_tree_list (NULL_TREE, input),
-				   unshare_expr (TREE_VALUE (link)));
+unshare_expr (TREE_VALUE (link)));
-	  ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
+ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
-	}
+}
 }
 link_next = NULL_TREE;
 for (link = ASM_INPUTS (expr); link; ++i, link = link_next)
 {
 link_next = TREE_CHAIN (link);
 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
-			      oconstraints, &allows_mem, &allows_reg);
+oconstraints, &allows_mem, &allows_reg);
 /* If we can't make copies, we can only accept memory.  */
 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link))))
-	{
+{
-	  if (allows_mem)
+if (allows_mem)
-	    allows_reg = 0;
+allows_reg = 0;
-	  else
+else
-	    {
+{
-	      error ("impossible constraint in %<asm%>");
+error ("impossible constraint in %<asm%>");
-	      error ("non-memory input %d must stay in memory", i);
+error ("non-memory input %d must stay in memory", i);
-	      return GS_ERROR;
+return GS_ERROR;
-	    }
+}
-	}
+}
 /* If the operand is a memory input, it should be an lvalue.  */
 if (!allows_reg && allows_mem)
-	{
+{
-	  tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
+tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
-				is_gimple_lvalue, fb_lvalue | fb_mayfail);
+is_gimple_lvalue, fb_lvalue | fb_mayfail);
-	  mark_addressable (TREE_VALUE (link));
+mark_addressable (TREE_VALUE (link));
-	  if (tret == GS_ERROR)
+if (tret == GS_ERROR)
-	    {
+{
-	      if (EXPR_HAS_LOCATION (TREE_VALUE (link)))
+if (EXPR_HAS_LOCATION (TREE_VALUE (link)))
-	        input_location = EXPR_LOCATION (TREE_VALUE (link));
+input_location = EXPR_LOCATION (TREE_VALUE (link));
-	      error ("memory input %d is not directly addressable", i);
+error ("memory input %d is not directly addressable", i);
-	      ret = tret;
+ret = tret;
-	    }
+}
-	}
+}
 else
-	{
+{
-	  tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
+tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
-				is_gimple_asm_val, fb_rvalue);
+is_gimple_asm_val, fb_rvalue);
-	  if (tret == GS_ERROR)
+if (tret == GS_ERROR)
-	    ret = tret;
+ret = tret;
-	}
+}
 TREE_CHAIN (link) = NULL_TREE;
 VEC_safe_push (tree, gc, inputs, link);
 }
 for (link = ASM_CLOBBERS (expr); link; ++i, link = TREE_CHAIN (link))
 VEC_safe_push (tree, gc, clobbers, link);
-stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
+for (link = ASM_LABELS (expr); link; ++i, link = TREE_CHAIN (link))
-inputs, outputs, clobbers);
+VEC_safe_push (tree, gc, labels, link);
-gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr));
+/* Do not add ASMs with errors to the gimple IL stream.  */
-gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
+if (ret != GS_ERROR)
+{
-gimplify_seq_add_stmt (pre_p, stmt);
+stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
+inputs, outputs, clobbers, labels);
+gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr));
+gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
+gimplify_seq_add_stmt (pre_p, stmt);
+}
 return ret;
 }
 /* Gimplify a CLEANUP_POINT_EXPR.  Currently this works by adding
 for (iter = gsi_start (body_sequence); !gsi_end_p (iter); )
 {
 gimple wce = gsi_stmt (iter);
 if (gimple_code (wce) == GIMPLE_WITH_CLEANUP_EXPR)
-	{
+{
-	  if (gsi_one_before_end_p (iter))
+if (gsi_one_before_end_p (iter))
-	    {
+{
 /* Note that gsi_insert_seq_before and gsi_remove do not
 scan operands, unlike some other sequence mutators.  */
-	      gsi_insert_seq_before_without_update (&iter,
+gsi_insert_seq_before_without_update (&iter,
 gimple_wce_cleanup (wce),
 GSI_SAME_STMT);
-	      gsi_remove (&iter, true);
+gsi_remove (&iter, true);
-	      break;
+break;
-	    }
+}
-	  else
+else
-	    {
+{
-	      gimple gtry;
+gimple gtry;
-	      gimple_seq seq;
+gimple_seq seq;
-	      enum gimple_try_flags kind;
+enum gimple_try_flags kind;
-	      if (gimple_wce_cleanup_eh_only (wce))
+if (gimple_wce_cleanup_eh_only (wce))
-		kind = GIMPLE_TRY_CATCH;
+kind = GIMPLE_TRY_CATCH;
-	      else
+else
-		kind = GIMPLE_TRY_FINALLY;
+kind = GIMPLE_TRY_FINALLY;
-	      seq = gsi_split_seq_after (iter);
+seq = gsi_split_seq_after (iter);
-	      gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind);
+gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind);
 /* Do not use gsi_replace here, as it may scan operands.
 We want to do a simple structural modification only.  */
 *gsi_stmt_ptr (&iter) = gtry;
-	      iter = gsi_start (seq);
+iter = gsi_start (seq);
-	    }
+}
-	}
+}
 else
-	gsi_next (&iter);
+gsi_next (&iter);
 }
 gimplify_seq_add_seq (pre_p, body_sequence);
 if (temp)
 {
 return;
 if (gimple_conditional_context ())
 {
 /* If we're in a conditional context, this is more complex.  We only
-	 want to run the cleanup if we actually ran the initialization that
+want to run the cleanup if we actually ran the initialization that
-	 necessitates it, but we want to run it after the end of the
+necessitates it, but we want to run it after the end of the
-	 conditional context.  So we wrap the try/finally around the
+conditional context.  So we wrap the try/finally around the
-	 condition and use a flag to determine whether or not to actually
+condition and use a flag to determine whether or not to actually
-	 run the destructor.  Thus
+run the destructor.  Thus
-	   test ? f(A()) : 0
+test ? f(A()) : 0
-	 becomes (approximately)
+becomes (approximately)
-	   flag = 0;
+flag = 0;
-	   try {
+try {
-	     if (test) { A::A(temp); flag = 1; val = f(temp); }
+if (test) { A::A(temp); flag = 1; val = f(temp); }
-	     else { val = 0; }
+else { val = 0; }
-	   } finally {
+} finally {
-	     if (flag) A::~A(temp);
+if (flag) A::~A(temp);
-	   }
+}
-	   val
+val
 */
 tree flag = create_tmp_var (boolean_type_node, "cleanup");
 gimple ffalse = gimple_build_assign (flag, boolean_false_node);
 gimple ftrue = gimple_build_assign (flag, boolean_true_node);
 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, ffalse);
 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, wce);
 gimplify_seq_add_stmt (pre_p, ftrue);
 /* Because of this manipulation, and the EH edges that jump
-	 threading cannot redirect, the temporary (VAR) will appear
+threading cannot redirect, the temporary (VAR) will appear
-	 to be used uninitialized.  Don't warn.  */
+to be used uninitialized.  Don't warn.  */
 TREE_NO_WARNING (var) = 1;
 }
 else
 {
 gimplify_stmt (&cleanup, &cleanup_stmts);
 enum gimplify_status ret;
 if (init)
 {
 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
-	 to the temps list.  Handle also variable length TARGET_EXPRs.  */
+to the temps list.  Handle also variable length TARGET_EXPRs.  */
 if (TREE_CODE (DECL_SIZE (temp)) != INTEGER_CST)
-	{
+{
-	  if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp)))
+if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp)))
-	    gimplify_type_sizes (TREE_TYPE (temp), pre_p);
+gimplify_type_sizes (TREE_TYPE (temp), pre_p);
-	  gimplify_vla_decl (temp, pre_p);
+gimplify_vla_decl (temp, pre_p);
-	}
+}
 else
-	gimple_add_tmp_var (temp);
+gimple_add_tmp_var (temp);
 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
-	 expression is supposed to initialize the slot.  */
+expression is supposed to initialize the slot.  */
 if (VOID_TYPE_P (TREE_TYPE (init)))
-	ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
+ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
 else
-	{
+{
-	  tree init_expr = build2 (INIT_EXPR, void_type_node, temp, init);
+tree init_expr = build2 (INIT_EXPR, void_type_node, temp, init);
-	  init = init_expr;
+init = init_expr;
-	  ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
+ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
-	  init = NULL;
+init = NULL;
-	  ggc_free (init_expr);
+ggc_free (init_expr);
-	}
+}
 if (ret == GS_ERROR)
-	{
+{
-	  /* PR c++/28266 Make sure this is expanded only once. */
+/* PR c++/28266 Make sure this is expanded only once. */
-	  TARGET_EXPR_INITIAL (targ) = NULL_TREE;
+TARGET_EXPR_INITIAL (targ) = NULL_TREE;
-	  return GS_ERROR;
+return GS_ERROR;
-	}
+}
 if (init)
-	gimplify_and_add (init, pre_p);
+gimplify_and_add (init, pre_p);
 /* If needed, push the cleanup for the temp.  */
 if (TARGET_EXPR_CLEANUP (targ))
-	gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
+gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
-			     CLEANUP_EH_ONLY (targ), pre_p);
+CLEANUP_EH_ONLY (targ), pre_p);
 /* Only expand this once.  */
 TREE_OPERAND (targ, 3) = init;
 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
 }
 do
 {
 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
 if (n != NULL)
-	{
+{
-	  if (n->value & GOVD_SHARED)
+if (n->value & GOVD_SHARED)
-	    n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
+n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
-	  else
+else
-	    return;
+return;
-	}
+}
 else if (ctx->region_type != ORT_WORKSHARE)
-	omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
+omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
 ctx = ctx->outer_context;
 }
 while (ctx);
 }
 case RECORD_TYPE:
 case UNION_TYPE:
 case QUAL_UNION_TYPE:
 {
-	tree field;
+tree field;
-	for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
+for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
-	  if (TREE_CODE (field) == FIELD_DECL)
+if (TREE_CODE (field) == FIELD_DECL)
-	    {
+{
-	      omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
+omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
-	      omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
+omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
-	    }
+}
 }
 break;
 case POINTER_TYPE:
 case REFERENCE_TYPE:
 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
 if (n != NULL)
 {
 /* We shouldn't be re-adding the decl with the same data
-	 sharing class.  */
+sharing class.  */
 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
 /* The only combination of data sharing classes we should see is
-	 FIRSTPRIVATE and LASTPRIVATE.  */
+FIRSTPRIVATE and LASTPRIVATE.  */
 nflags = n->value | flags;
 gcc_assert ((nflags & GOVD_DATA_SHARE_CLASS)
-		  == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE));
+== (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE));
 n->value = nflags;
 return;
 }
 /* When adding a variable-sized variable, we have to handle all sorts
 of additional bits of data: the pointer replacement variable, and
 the parameters of the type.  */
 if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
 {
 /* Add the pointer replacement variable as PRIVATE if the variable
-	 replacement is private, else FIRSTPRIVATE since we'll need the
+replacement is private, else FIRSTPRIVATE since we'll need the
-	 address of the original variable either for SHARED, or for the
+address of the original variable either for SHARED, or for the
-	 copy into or out of the context.  */
+copy into or out of the context.  */
 if (!(flags & GOVD_LOCAL))
-	{
+{
-	  nflags = flags & GOVD_PRIVATE ? GOVD_PRIVATE : GOVD_FIRSTPRIVATE;
+nflags = flags & GOVD_PRIVATE ? GOVD_PRIVATE : GOVD_FIRSTPRIVATE;
-	  nflags |= flags & GOVD_SEEN;
+nflags |= flags & GOVD_SEEN;
-	  t = DECL_VALUE_EXPR (decl);
+t = DECL_VALUE_EXPR (decl);
-	  gcc_assert (TREE_CODE (t) == INDIRECT_REF);
+gcc_assert (TREE_CODE (t) == INDIRECT_REF);
-	  t = TREE_OPERAND (t, 0);
+t = TREE_OPERAND (t, 0);
-	  gcc_assert (DECL_P (t));
+gcc_assert (DECL_P (t));
-	  omp_add_variable (ctx, t, nflags);
+omp_add_variable (ctx, t, nflags);
-	}
+}
 /* Add all of the variable and type parameters (which should have
-	 been gimplified to a formal temporary) as FIRSTPRIVATE.  */
+been gimplified to a formal temporary) as FIRSTPRIVATE.  */
 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
 omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
 /* The variable-sized variable itself is never SHARED, only some form
-	 of PRIVATE.  The sharing would take place via the pointer variable
+of PRIVATE.  The sharing would take place via the pointer variable
-	 which we remapped above.  */
+which we remapped above.  */
 if (flags & GOVD_SHARED)
-	flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
+flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
-		| (flags & (GOVD_SEEN | GOVD_EXPLICIT));
+| (flags & (GOVD_SEEN | GOVD_EXPLICIT));
 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
-	 alloca statement we generate for the variable, so make sure it
+alloca statement we generate for the variable, so make sure it
-	 is available.  This isn't automatically needed for the SHARED
+is available.  This isn't automatically needed for the SHARED
-	 case, since we won't be allocating local storage then.
+case, since we won't be allocating local storage then.
-	 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
+For local variables TYPE_SIZE_UNIT might not be gimplified yet,
-	 in this case omp_notice_variable will be called later
+in this case omp_notice_variable will be called later
-	 on when it is gimplified.  */
+on when it is gimplified.  */
 else if (! (flags & GOVD_LOCAL))
-	omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
+omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
 }
 else if (lang_hooks.decls.omp_privatize_by_reference (decl))
 {
 gcc_assert ((flags & GOVD_LOCAL) == 0);
 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
 /* Similar to the direct variable sized case above, we'll need the
-	 size of references being privatized.  */
+size of references being privatized.  */
 if ((flags & GOVD_SHARED) == 0)
-	{
+{
-	  t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
+t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
-	  if (TREE_CODE (t) != INTEGER_CST)
+if (TREE_CODE (t) != INTEGER_CST)
-	    omp_notice_variable (ctx, t, true);
+omp_notice_variable (ctx, t, true);
-	}
+}
 }
 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
 }
 /* Threadprivate variables are predetermined.  */
 if (is_global_var (decl))
 {
 if (DECL_THREAD_LOCAL_P (decl))
-	return false;
+return false;
 if (DECL_HAS_VALUE_EXPR_P (decl))
-	{
+{
-	  tree value = get_base_address (DECL_VALUE_EXPR (decl));
+tree value = get_base_address (DECL_VALUE_EXPR (decl));
-	  if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
+if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
-	    return false;
+return false;
-	}
+}
 }
 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
 if (n == NULL)
 {
 enum omp_clause_default_kind default_kind, kind;
 struct gimplify_omp_ctx *octx;
 if (ctx->region_type == ORT_WORKSHARE)
-	goto do_outer;
+goto do_outer;
 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
-	 remapped firstprivate instead of shared.  To some extent this is
+remapped firstprivate instead of shared.  To some extent this is
-	 addressed in omp_firstprivatize_type_sizes, but not effectively.  */
+addressed in omp_firstprivatize_type_sizes, but not effectively.  */
 default_kind = ctx->default_kind;
 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
-	default_kind = kind;
+default_kind = kind;
 switch (default_kind)
-	{
+{
-	case OMP_CLAUSE_DEFAULT_NONE:
+case OMP_CLAUSE_DEFAULT_NONE:
-	  error ("%qs not specified in enclosing parallel",
+error ("%qE not specified in enclosing parallel",
-		 IDENTIFIER_POINTER (DECL_NAME (decl)));
+DECL_NAME (decl));
-	  error ("%Henclosing parallel", &ctx->location);
+error_at (ctx->location, "enclosing parallel");
-	  /* FALLTHRU */
+/* FALLTHRU */
-	case OMP_CLAUSE_DEFAULT_SHARED:
+case OMP_CLAUSE_DEFAULT_SHARED:
-	  flags |= GOVD_SHARED;
+flags |= GOVD_SHARED;
-	  break;
+break;
-	case OMP_CLAUSE_DEFAULT_PRIVATE:
+case OMP_CLAUSE_DEFAULT_PRIVATE:
-	  flags |= GOVD_PRIVATE;
+flags |= GOVD_PRIVATE;
-	  break;
+break;
-	case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
+case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
-	  flags |= GOVD_FIRSTPRIVATE;
+flags |= GOVD_FIRSTPRIVATE;
-	  break;
+break;
-	case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
+case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
-	  /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED.  */
+/* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED.  */
-	  gcc_assert (ctx->region_type == ORT_TASK);
+gcc_assert (ctx->region_type == ORT_TASK);
-	  if (ctx->outer_context)
+if (ctx->outer_context)
-	    omp_notice_variable (ctx->outer_context, decl, in_code);
+omp_notice_variable (ctx->outer_context, decl, in_code);
-	  for (octx = ctx->outer_context; octx; octx = octx->outer_context)
+for (octx = ctx->outer_context; octx; octx = octx->outer_context)
-	    {
+{
-	      splay_tree_node n2;
+splay_tree_node n2;
-	      n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
+n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
-	      if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
+if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
-		{
+{
-		  flags |= GOVD_FIRSTPRIVATE;
+flags |= GOVD_FIRSTPRIVATE;
-		  break;
+break;
-		}
+}
-	      if ((octx->region_type & ORT_PARALLEL) != 0)
+if ((octx->region_type & ORT_PARALLEL) != 0)
-		break;
+break;
-	    }
+}
-	  if (flags & GOVD_FIRSTPRIVATE)
+if (flags & GOVD_FIRSTPRIVATE)
-	    break;
+break;
-	  if (octx == NULL
+if (octx == NULL
-	      && (TREE_CODE (decl) == PARM_DECL
+&& (TREE_CODE (decl) == PARM_DECL
-		  || (!is_global_var (decl)
+|| (!is_global_var (decl)
-		      && DECL_CONTEXT (decl) == current_function_decl)))
+&& DECL_CONTEXT (decl) == current_function_decl)))
-	    {
+{
-	      flags |= GOVD_FIRSTPRIVATE;
+flags |= GOVD_FIRSTPRIVATE;
-	      break;
+break;
-	    }
+}
-	  flags |= GOVD_SHARED;
+flags |= GOVD_SHARED;
-	  break;
+break;
-	default:
+default:
-	  gcc_unreachable ();
+gcc_unreachable ();
-	}
+}
 if ((flags & GOVD_PRIVATE)
-	  && lang_hooks.decls.omp_private_outer_ref (decl))
+&& lang_hooks.decls.omp_private_outer_ref (decl))
-	flags |= GOVD_PRIVATE_OUTER_REF;
+flags |= GOVD_PRIVATE_OUTER_REF;
 omp_add_variable (ctx, decl, flags);
 shared = (flags & GOVD_SHARED) != 0;
 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
 if (n != NULL)
 {
 if (n->value & GOVD_SHARED)
-	{
+{
-	  if (ctx == gimplify_omp_ctxp)
+if (ctx == gimplify_omp_ctxp)
-	    {
+{
-	      error ("iteration variable %qs should be private",
+error ("iteration variable %qE should be private",
-		     IDENTIFIER_POINTER (DECL_NAME (decl)));
+DECL_NAME (decl));
-	      n->value = GOVD_PRIVATE;
+n->value = GOVD_PRIVATE;
-	      return true;
+return true;
-	    }
+}
-	  else
+else
-	    return false;
+return false;
-	}
+}
 else if ((n->value & GOVD_EXPLICIT) != 0
-	       && (ctx == gimplify_omp_ctxp
+&& (ctx == gimplify_omp_ctxp
-		   || (ctx->region_type == ORT_COMBINED_PARALLEL
+|| (ctx->region_type == ORT_COMBINED_PARALLEL
-		       && gimplify_omp_ctxp->outer_context == ctx)))
+&& gimplify_omp_ctxp->outer_context == ctx)))
-	{
+{
-	  if ((n->value & GOVD_FIRSTPRIVATE) != 0)
+if ((n->value & GOVD_FIRSTPRIVATE) != 0)
-	    error ("iteration variable %qs should not be firstprivate",
+error ("iteration variable %qE should not be firstprivate",
-		   IDENTIFIER_POINTER (DECL_NAME (decl)));
+DECL_NAME (decl));
-	  else if ((n->value & GOVD_REDUCTION) != 0)
+else if ((n->value & GOVD_REDUCTION) != 0)
-	    error ("iteration variable %qs should not be reduction",
+error ("iteration variable %qE should not be reduction",
-		   IDENTIFIER_POINTER (DECL_NAME (decl)));
+DECL_NAME (decl));
-	}
+}
 return (ctx == gimplify_omp_ctxp
-	      || (ctx->region_type == ORT_COMBINED_PARALLEL
+|| (ctx->region_type == ORT_COMBINED_PARALLEL
-		  && gimplify_omp_ctxp->outer_context == ctx));
+&& gimplify_omp_ctxp->outer_context == ctx));
 }
 if (ctx->region_type != ORT_WORKSHARE)
 return false;
 else if (ctx->outer_context)
 do
 {
 ctx = ctx->outer_context;
 if (ctx == NULL)
-	return !(is_global_var (decl)
+return !(is_global_var (decl)
-		 /* References might be private, but might be shared too.  */
+/* References might be private, but might be shared too.  */
-		 || lang_hooks.decls.omp_privatize_by_reference (decl));
+|| lang_hooks.decls.omp_privatize_by_reference (decl));
 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
 if (n != NULL)
-	return (n->value & GOVD_SHARED) == 0;
+return (n->value & GOVD_SHARED) == 0;
 }
 while (ctx->region_type == ORT_WORKSHARE);
 return false;
 }
 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
 and previous omp contexts.  */
 static void
 gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
-			   enum omp_region_type region_type)
+enum omp_region_type region_type)
 {
 struct gimplify_omp_ctx *ctx, *outer_ctx;
 struct gimplify_ctx gctx;
 tree c;
 const char *check_non_private = NULL;
 unsigned int flags;
 tree decl;
 switch (OMP_CLAUSE_CODE (c))
-	{
+{
-	case OMP_CLAUSE_PRIVATE:
+case OMP_CLAUSE_PRIVATE:
-	  flags = GOVD_PRIVATE | GOVD_EXPLICIT;
+flags = GOVD_PRIVATE | GOVD_EXPLICIT;
-	  if (lang_hooks.decls.omp_private_outer_ref (OMP_CLAUSE_DECL (c)))
+if (lang_hooks.decls.omp_private_outer_ref (OMP_CLAUSE_DECL (c)))
-	    {
+{
-	      flags |= GOVD_PRIVATE_OUTER_REF;
+flags |= GOVD_PRIVATE_OUTER_REF;
-	      OMP_CLAUSE_PRIVATE_OUTER_REF (c) = 1;
+OMP_CLAUSE_PRIVATE_OUTER_REF (c) = 1;
-	    }
+}
-	  else
+else
-	    notice_outer = false;
+notice_outer = false;
-	  goto do_add;
+goto do_add;
-	case OMP_CLAUSE_SHARED:
+case OMP_CLAUSE_SHARED:
-	  flags = GOVD_SHARED | GOVD_EXPLICIT;
+flags = GOVD_SHARED | GOVD_EXPLICIT;
-	  goto do_add;
+goto do_add;
-	case OMP_CLAUSE_FIRSTPRIVATE:
+case OMP_CLAUSE_FIRSTPRIVATE:
-	  flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
+flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
-	  check_non_private = "firstprivate";
+check_non_private = "firstprivate";
-	  goto do_add;
+goto do_add;
-	case OMP_CLAUSE_LASTPRIVATE:
+case OMP_CLAUSE_LASTPRIVATE:
-	  flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
+flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
-	  check_non_private = "lastprivate";
+check_non_private = "lastprivate";
-	  goto do_add;
+goto do_add;
-	case OMP_CLAUSE_REDUCTION:
+case OMP_CLAUSE_REDUCTION:
-	  flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
+flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
-	  check_non_private = "reduction";
+check_non_private = "reduction";
-	  goto do_add;
+goto do_add;
-	do_add:
+do_add:
-	  decl = OMP_CLAUSE_DECL (c);
+decl = OMP_CLAUSE_DECL (c);
-	  if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
+if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
-	    {
+{
-	      remove = true;
+remove = true;
-	      break;
+break;
-	    }
+}
-	  omp_add_variable (ctx, decl, flags);
+omp_add_variable (ctx, decl, flags);
-	  if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
+if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
-	      && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
+&& OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
-	    {
+{
-	      omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
+omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
-				GOVD_LOCAL | GOVD_SEEN);
+GOVD_LOCAL | GOVD_SEEN);
-	      gimplify_omp_ctxp = ctx;
+gimplify_omp_ctxp = ctx;
-	      push_gimplify_context (&gctx);
+push_gimplify_context (&gctx);
-	      OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = gimple_seq_alloc ();
+OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = gimple_seq_alloc ();
-	      OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = gimple_seq_alloc ();
+OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = gimple_seq_alloc ();
-	      gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c),
+gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c),
-		  		&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
+&OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
-	      pop_gimplify_context
+pop_gimplify_context
-		(gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c)));
+(gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c)));
-	      push_gimplify_context (&gctx);
+push_gimplify_context (&gctx);
-	      gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c),
+gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c),
-		  		&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
+&OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
-	      pop_gimplify_context
+pop_gimplify_context
-		(gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c)));
+(gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c)));
-	      OMP_CLAUSE_REDUCTION_INIT (c) = NULL_TREE;
+OMP_CLAUSE_REDUCTION_INIT (c) = NULL_TREE;
-	      OMP_CLAUSE_REDUCTION_MERGE (c) = NULL_TREE;
+OMP_CLAUSE_REDUCTION_MERGE (c) = NULL_TREE;
-	      gimplify_omp_ctxp = outer_ctx;
+gimplify_omp_ctxp = outer_ctx;
-	    }
+}
-	  else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
+else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
-		   && OMP_CLAUSE_LASTPRIVATE_STMT (c))
+&& OMP_CLAUSE_LASTPRIVATE_STMT (c))
-	    {
+{
-	      gimplify_omp_ctxp = ctx;
+gimplify_omp_ctxp = ctx;
-	      push_gimplify_context (&gctx);
+push_gimplify_context (&gctx);
-	      if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
+if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
-		{
+{
-		  tree bind = build3 (BIND_EXPR, void_type_node, NULL,
+tree bind = build3 (BIND_EXPR, void_type_node, NULL,
-				      NULL, NULL);
+NULL, NULL);
-		  TREE_SIDE_EFFECTS (bind) = 1;
+TREE_SIDE_EFFECTS (bind) = 1;
-		  BIND_EXPR_BODY (bind) = OMP_CLAUSE_LASTPRIVATE_STMT (c);
+BIND_EXPR_BODY (bind) = OMP_CLAUSE_LASTPRIVATE_STMT (c);
-		  OMP_CLAUSE_LASTPRIVATE_STMT (c) = bind;
+OMP_CLAUSE_LASTPRIVATE_STMT (c) = bind;
-		}
+}
-	      gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c),
+gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c),
-				&OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
+&OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
-	      pop_gimplify_context
+pop_gimplify_context
-		(gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c)));
+(gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c)));
-	      OMP_CLAUSE_LASTPRIVATE_STMT (c) = NULL_TREE;
+OMP_CLAUSE_LASTPRIVATE_STMT (c) = NULL_TREE;
-	      gimplify_omp_ctxp = outer_ctx;
+gimplify_omp_ctxp = outer_ctx;
-	    }
+}
-	  if (notice_outer)
+if (notice_outer)
-	    goto do_notice;
+goto do_notice;
-	  break;
+break;
-	case OMP_CLAUSE_COPYIN:
+case OMP_CLAUSE_COPYIN:
-	case OMP_CLAUSE_COPYPRIVATE:
+case OMP_CLAUSE_COPYPRIVATE:
-	  decl = OMP_CLAUSE_DECL (c);
+decl = OMP_CLAUSE_DECL (c);
-	  if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
+if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
-	    {
+{
-	      remove = true;
+remove = true;
-	      break;
+break;
-	    }
+}
-	do_notice:
+do_notice:
-	  if (outer_ctx)
+if (outer_ctx)
-	    omp_notice_variable (outer_ctx, decl, true);
+omp_notice_variable (outer_ctx, decl, true);
-	  if (check_non_private
+if (check_non_private
-	      && region_type == ORT_WORKSHARE
+&& region_type == ORT_WORKSHARE
-	      && omp_check_private (ctx, decl))
+&& omp_check_private (ctx, decl))
-	    {
+{
-	      error ("%s variable %qs is private in outer context",
+error ("%s variable %qE is private in outer context",
-		     check_non_private, IDENTIFIER_POINTER (DECL_NAME (decl)));
+check_non_private, DECL_NAME (decl));
-	      remove = true;
+remove = true;
-	    }
+}
-	  break;
+break;
-	case OMP_CLAUSE_IF:
+case OMP_CLAUSE_IF:
-	  OMP_CLAUSE_OPERAND (c, 0)
+OMP_CLAUSE_OPERAND (c, 0)
-	    = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
+= gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
-	  /* Fall through.  */
+/* Fall through.  */
-	case OMP_CLAUSE_SCHEDULE:
+case OMP_CLAUSE_SCHEDULE:
-	case OMP_CLAUSE_NUM_THREADS:
+case OMP_CLAUSE_NUM_THREADS:
-	  if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
+if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
-			     is_gimple_val, fb_rvalue) == GS_ERROR)
+is_gimple_val, fb_rvalue) == GS_ERROR)
-	      remove = true;
+remove = true;
-	  break;
+break;
-	case OMP_CLAUSE_NOWAIT:
+case OMP_CLAUSE_NOWAIT:
-	case OMP_CLAUSE_ORDERED:
+case OMP_CLAUSE_ORDERED:
-	case OMP_CLAUSE_UNTIED:
+case OMP_CLAUSE_UNTIED:
-	case OMP_CLAUSE_COLLAPSE:
+case OMP_CLAUSE_COLLAPSE:
-	  break;
+break;
-	case OMP_CLAUSE_DEFAULT:
+case OMP_CLAUSE_DEFAULT:
-	  ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
+ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
-	  break;
+break;
-	default:
+default:
-	  gcc_unreachable ();
+gcc_unreachable ();
-	}
+}
 if (remove)
-	*list_p = OMP_CLAUSE_CHAIN (c);
+*list_p = OMP_CLAUSE_CHAIN (c);
 else
-	list_p = &OMP_CLAUSE_CHAIN (c);
+list_p = &OMP_CLAUSE_CHAIN (c);
 }
 gimplify_omp_ctxp = ctx;
 }
 private_debug = true;
 }
 else
 private_debug
 = lang_hooks.decls.omp_private_debug_clause (decl,
-						   !!(flags & GOVD_SHARED));
+!!(flags & GOVD_SHARED));
 if (private_debug)
 code = OMP_CLAUSE_PRIVATE;
 else if (flags & GOVD_SHARED)
 {
 if (is_global_var (decl))
-	{
+{
-	  struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
+struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
-	  while (ctx != NULL)
+while (ctx != NULL)
-	    {
+{
-	      splay_tree_node on
+splay_tree_node on
-		= splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
+= splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
-	      if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
+if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
-				      | GOVD_PRIVATE | GOVD_REDUCTION)) != 0)
+| GOVD_PRIVATE | GOVD_REDUCTION)) != 0)
-		break;
+break;
-	      ctx = ctx->outer_context;
+ctx = ctx->outer_context;
-	    }
+}
-	  if (ctx == NULL)
+if (ctx == NULL)
-	    return 0;
+return 0;
-	}
+}
 code = OMP_CLAUSE_SHARED;
 }
 else if (flags & GOVD_PRIVATE)
 code = OMP_CLAUSE_PRIVATE;
 else if (flags & GOVD_FIRSTPRIVATE)
 code = OMP_CLAUSE_FIRSTPRIVATE;
 else
 gcc_unreachable ();
-clause = build_omp_clause (code);
+clause = build_omp_clause (input_location, code);
 OMP_CLAUSE_DECL (clause) = decl;
 OMP_CLAUSE_CHAIN (clause) = *list_p;
 if (private_debug)
 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
 else if (code == OMP_CLAUSE_PRIVATE && (flags & GOVD_PRIVATE_OUTER_REF))
 {
 splay_tree_node n;
 bool remove = false;
 switch (OMP_CLAUSE_CODE (c))
-	{
+{
-	case OMP_CLAUSE_PRIVATE:
+case OMP_CLAUSE_PRIVATE:
-	case OMP_CLAUSE_SHARED:
+case OMP_CLAUSE_SHARED:
-	case OMP_CLAUSE_FIRSTPRIVATE:
+case OMP_CLAUSE_FIRSTPRIVATE:
-	  decl = OMP_CLAUSE_DECL (c);
+decl = OMP_CLAUSE_DECL (c);
-	  n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
+n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
-	  remove = !(n->value & GOVD_SEEN);
+remove = !(n->value & GOVD_SEEN);
-	  if (! remove)
+if (! remove)
-	    {
+{
-	      bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
+bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
-	      if ((n->value & GOVD_DEBUG_PRIVATE)
+if ((n->value & GOVD_DEBUG_PRIVATE)
-		  || lang_hooks.decls.omp_private_debug_clause (decl, shared))
+|| lang_hooks.decls.omp_private_debug_clause (decl, shared))
-		{
+{
-		  gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
+gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
-			      || ((n->value & GOVD_DATA_SHARE_CLASS)
+|| ((n->value & GOVD_DATA_SHARE_CLASS)
-				  == GOVD_PRIVATE));
+== GOVD_PRIVATE));
-		  OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
+OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
-		  OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
+OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
-		}
+}
-	    }
+}
-	  break;
+break;
-	case OMP_CLAUSE_LASTPRIVATE:
+case OMP_CLAUSE_LASTPRIVATE:
-	  /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
+/* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
-	     accurately reflect the presence of a FIRSTPRIVATE clause.  */
+accurately reflect the presence of a FIRSTPRIVATE clause.  */
-	  decl = OMP_CLAUSE_DECL (c);
+decl = OMP_CLAUSE_DECL (c);
-	  n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
+n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
-	  OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
+OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
-	    = (n->value & GOVD_FIRSTPRIVATE) != 0;
+= (n->value & GOVD_FIRSTPRIVATE) != 0;
-	  break;
+break;
-	case OMP_CLAUSE_REDUCTION:
+case OMP_CLAUSE_REDUCTION:
-	case OMP_CLAUSE_COPYIN:
+case OMP_CLAUSE_COPYIN:
-	case OMP_CLAUSE_COPYPRIVATE:
+case OMP_CLAUSE_COPYPRIVATE:
-	case OMP_CLAUSE_IF:
+case OMP_CLAUSE_IF:
-	case OMP_CLAUSE_NUM_THREADS:
+case OMP_CLAUSE_NUM_THREADS:
-	case OMP_CLAUSE_SCHEDULE:
+case OMP_CLAUSE_SCHEDULE:
-	case OMP_CLAUSE_NOWAIT:
+case OMP_CLAUSE_NOWAIT:
-	case OMP_CLAUSE_ORDERED:
+case OMP_CLAUSE_ORDERED:
-	case OMP_CLAUSE_DEFAULT:
+case OMP_CLAUSE_DEFAULT:
-	case OMP_CLAUSE_UNTIED:
+case OMP_CLAUSE_UNTIED:
-	case OMP_CLAUSE_COLLAPSE:
+case OMP_CLAUSE_COLLAPSE:
-	  break;
+break;
-	default:
+default:
-	  gcc_unreachable ();
+gcc_unreachable ();
-	}
+}
 if (remove)
-	*list_p = OMP_CLAUSE_CHAIN (c);
+*list_p = OMP_CLAUSE_CHAIN (c);
 else
-	list_p = &OMP_CLAUSE_CHAIN (c);
+list_p = &OMP_CLAUSE_CHAIN (c);
 }
 /* Add in any implicit data sharing.  */
 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, list_p);
 gimplify_omp_ctxp = ctx->outer_context;
 delete_omp_context (ctx);
 }
 /* Gimplify the contents of an OMP_PARALLEL statement.  This involves
 gimple g;
 gimple_seq body = NULL;
 struct gimplify_ctx gctx;
 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p,
-			     OMP_PARALLEL_COMBINED (expr)
+OMP_PARALLEL_COMBINED (expr)
-			     ? ORT_COMBINED_PARALLEL
+? ORT_COMBINED_PARALLEL
-			     : ORT_PARALLEL);
+: ORT_PARALLEL);
 push_gimplify_context (&gctx);
 g = gimplify_and_return_first (OMP_PARALLEL_BODY (expr), &body);
 if (gimple_code (g) == GIMPLE_BIND)
 pop_gimplify_context (NULL);
 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr));
 g = gimple_build_omp_parallel (body,
-				 OMP_PARALLEL_CLAUSES (expr),
+OMP_PARALLEL_CLAUSES (expr),
-				 NULL_TREE, NULL_TREE);
+NULL_TREE, NULL_TREE);
 if (OMP_PARALLEL_COMBINED (expr))
 gimple_omp_set_subcode (g, GF_OMP_PARALLEL_COMBINED);
 gimplify_seq_add_stmt (pre_p, g);
 *expr_p = NULL_TREE;
 }
 pop_gimplify_context (NULL);
 gimplify_adjust_omp_clauses (&OMP_TASK_CLAUSES (expr));
 g = gimple_build_omp_task (body,
-			     OMP_TASK_CLAUSES (expr),
+OMP_TASK_CLAUSES (expr),
-			     NULL_TREE, NULL_TREE,
+NULL_TREE, NULL_TREE,
-			     NULL_TREE, NULL_TREE, NULL_TREE);
+NULL_TREE, NULL_TREE, NULL_TREE);
 gimplify_seq_add_stmt (pre_p, g);
 *expr_p = NULL_TREE;
 }
 /* Gimplify the gross structure of an OMP_FOR statement.  */
 static enum gimplify_status
 gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
 {
 tree for_stmt, decl, var, t;
-enum gimplify_status ret = GS_OK;
+enum gimplify_status ret = GS_ALL_DONE;
+enum gimplify_status tret;
 gimple gfor;
 gimple_seq for_body, for_pre_body;
 int i;
 for_stmt = *expr_p;
 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p,
-			     ORT_WORKSHARE);
+ORT_WORKSHARE);
 /* Handle OMP_FOR_INIT.  */
 for_pre_body = NULL;
 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt), &for_pre_body);
 OMP_FOR_PRE_BODY (for_stmt) = NULL_TREE;
 for_body = gimple_seq_alloc ();
 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
-	      == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt)));
+== TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt)));
 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
-	      == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt)));
+== TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt)));
 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
 {
 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
 decl = TREE_OPERAND (t, 0);
 gcc_assert (DECL_P (decl));
 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl))
-		  || POINTER_TYPE_P (TREE_TYPE (decl)));
+|| POINTER_TYPE_P (TREE_TYPE (decl)));
 /* Make sure the iteration variable is private.  */
 if (omp_is_private (gimplify_omp_ctxp, decl))
-	omp_notice_variable (gimplify_omp_ctxp, decl, true);
+omp_notice_variable (gimplify_omp_ctxp, decl, true);
 else
-	omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
+omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
 /* If DECL is not a gimple register, create a temporary variable to act
-	 as an iteration counter.  This is valid, since DECL cannot be
+as an iteration counter.  This is valid, since DECL cannot be
-	 modified in the body of the loop.  */
+modified in the body of the loop.  */
 if (!is_gimple_reg (decl))
-	{
+{
-	  var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
+var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
-	  TREE_OPERAND (t, 0) = var;
+TREE_OPERAND (t, 0) = var;
-	  gimplify_seq_add_stmt (&for_body, gimple_build_assign (decl, var));
+gimplify_seq_add_stmt (&for_body, gimple_build_assign (decl, var));
-	  omp_add_variable (gimplify_omp_ctxp, var, GOVD_PRIVATE | GOVD_SEEN);
+omp_add_variable (gimplify_omp_ctxp, var, GOVD_PRIVATE | GOVD_SEEN);
-	}
+}
 else
-	var = decl;
+var = decl;
-ret |= gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
+tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
-			    is_gimple_val, fb_rvalue);
+is_gimple_val, fb_rvalue);
+ret = MIN (ret, tret);
 if (ret == GS_ERROR)
-	return ret;
+return ret;
 /* Handle OMP_FOR_COND.  */
 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
 gcc_assert (COMPARISON_CLASS_P (t));
 gcc_assert (TREE_OPERAND (t, 0) == decl);
-ret |= gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
+tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
-			    is_gimple_val, fb_rvalue);
+is_gimple_val, fb_rvalue);
+ret = MIN (ret, tret);
 /* Handle OMP_FOR_INCR.  */
 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
 switch (TREE_CODE (t))
-	{
+{
-	case PREINCREMENT_EXPR:
+case PREINCREMENT_EXPR:
-	case POSTINCREMENT_EXPR:
+case POSTINCREMENT_EXPR:
-	  t = build_int_cst (TREE_TYPE (decl), 1);
+t = build_int_cst (TREE_TYPE (decl), 1);
-	  t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
+t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
-	  t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
+t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
-	  TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
+TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
-	  break;
+break;
-	case PREDECREMENT_EXPR:
+case PREDECREMENT_EXPR:
-	case POSTDECREMENT_EXPR:
+case POSTDECREMENT_EXPR:
-	  t = build_int_cst (TREE_TYPE (decl), -1);
+t = build_int_cst (TREE_TYPE (decl), -1);
-	  t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
+t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
-	  t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
+t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
-	  TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
+TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
-	  break;
+break;
-	case MODIFY_EXPR:
+case MODIFY_EXPR:
-	  gcc_assert (TREE_OPERAND (t, 0) == decl);
+gcc_assert (TREE_OPERAND (t, 0) == decl);
-	  TREE_OPERAND (t, 0) = var;
+TREE_OPERAND (t, 0) = var;
-	  t = TREE_OPERAND (t, 1);
+t = TREE_OPERAND (t, 1);
-	  switch (TREE_CODE (t))
+switch (TREE_CODE (t))
-	    {
+{
-	    case PLUS_EXPR:
+case PLUS_EXPR:
-	      if (TREE_OPERAND (t, 1) == decl)
+if (TREE_OPERAND (t, 1) == decl)
-		{
+{
-		  TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
+TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
-		  TREE_OPERAND (t, 0) = var;
+TREE_OPERAND (t, 0) = var;
-		  break;
+break;
-		}
+}
-	      /* Fallthru.  */
+/* Fallthru.  */
-	    case MINUS_EXPR:
+case MINUS_EXPR:
-	    case POINTER_PLUS_EXPR:
+case POINTER_PLUS_EXPR:
-	      gcc_assert (TREE_OPERAND (t, 0) == decl);
+gcc_assert (TREE_OPERAND (t, 0) == decl);
-	      TREE_OPERAND (t, 0) = var;
+TREE_OPERAND (t, 0) = var;
-	      break;
+break;
-	    default:
+default:
-	      gcc_unreachable ();
+gcc_unreachable ();
-	    }
+}
-	  ret |= gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
+tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
-				is_gimple_val, fb_rvalue);
+is_gimple_val, fb_rvalue);
-	  break;
+ret = MIN (ret, tret);
+break;
-	default:
-	  gcc_unreachable ();
+default:
-	}
+gcc_unreachable ();
+}
 if (var != decl || TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) > 1)
-	{
+{
-	  tree c;
+tree c;
-	  for (c = OMP_FOR_CLAUSES (for_stmt); c ; c = OMP_CLAUSE_CHAIN (c))
+for (c = OMP_FOR_CLAUSES (for_stmt); c ; c = OMP_CLAUSE_CHAIN (c))
-	    if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
+if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
-		&& OMP_CLAUSE_DECL (c) == decl
+&& OMP_CLAUSE_DECL (c) == decl
-		&& OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c) == NULL)
+&& OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c) == NULL)
-	      {
+{
-		t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
+t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
-		gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
+gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
-		gcc_assert (TREE_OPERAND (t, 0) == var);
+gcc_assert (TREE_OPERAND (t, 0) == var);
-		t = TREE_OPERAND (t, 1);
+t = TREE_OPERAND (t, 1);
-		gcc_assert (TREE_CODE (t) == PLUS_EXPR
+gcc_assert (TREE_CODE (t) == PLUS_EXPR
-			    || TREE_CODE (t) == MINUS_EXPR
+|| TREE_CODE (t) == MINUS_EXPR
-			    || TREE_CODE (t) == POINTER_PLUS_EXPR);
+|| TREE_CODE (t) == POINTER_PLUS_EXPR);
-		gcc_assert (TREE_OPERAND (t, 0) == var);
+gcc_assert (TREE_OPERAND (t, 0) == var);
-		t = build2 (TREE_CODE (t), TREE_TYPE (decl), decl,
+t = build2 (TREE_CODE (t), TREE_TYPE (decl), decl,
-			    TREE_OPERAND (t, 1));
+TREE_OPERAND (t, 1));
-		gimplify_assign (decl, t,
+gimplify_assign (decl, t,
-				 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
+&OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
-	    }
+}
-	}
+}
 }
 gimplify_and_add (OMP_FOR_BODY (for_stmt), &for_body);
 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt));
 gfor = gimple_build_omp_for (for_body, OMP_FOR_CLAUSES (for_stmt),
-			       TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)),
+TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)),
-			       for_pre_body);
+for_pre_body);
 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
 {
 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
 gimple_omp_for_set_index (gfor, i, TREE_OPERAND (t, 0));
 gimplify_seq_add_stmt (pre_p, stmt);
 }
 /* A subroutine of gimplify_omp_atomic.  The front end is supposed to have
 stabilized the lhs of the atomic operation as *ADDR.  Return true if
 EXPR is this stabilized form.  */
 static bool
 goa_lhs_expr_p (tree expr, tree addr)
 {
 /* Also include casts to other type variants.  The C front end is fond
 of adding these for e.g. volatile variables.  This is like
 STRIP_TYPE_NOPS but includes the main variant lookup.  */
-while ((CONVERT_EXPR_P (expr)
+STRIP_USELESS_TYPE_CONVERSION (expr);
-|| TREE_CODE (expr) == NON_LVALUE_EXPR)
-&& TREE_OPERAND (expr, 0) != error_mark_node
-&& (TYPE_MAIN_VARIANT (TREE_TYPE (expr))
-== TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (expr, 0)))))
-expr = TREE_OPERAND (expr, 0);
 if (TREE_CODE (expr) == INDIRECT_REF)
 {
 expr = TREE_OPERAND (expr, 0);
 while (expr != addr
-	     && (CONVERT_EXPR_P (expr)
+&& (CONVERT_EXPR_P (expr)
-		 || TREE_CODE (expr) == NON_LVALUE_EXPR)
+|| TREE_CODE (expr) == NON_LVALUE_EXPR)
-	     && TREE_CODE (expr) == TREE_CODE (addr)
+&& TREE_CODE (expr) == TREE_CODE (addr)
-	     && TYPE_MAIN_VARIANT (TREE_TYPE (expr))
+&& types_compatible_p (TREE_TYPE (expr), TREE_TYPE (addr)))
-		== TYPE_MAIN_VARIANT (TREE_TYPE (addr)))
+{
-	{
+expr = TREE_OPERAND (expr, 0);
-	  expr = TREE_OPERAND (expr, 0);
+addr = TREE_OPERAND (addr, 0);
-	  addr = TREE_OPERAND (addr, 0);
+}
-	}
 if (expr == addr)
-	return true;
+return true;
 return (TREE_CODE (addr) == ADDR_EXPR
-	      && TREE_CODE (expr) == ADDR_EXPR
+&& TREE_CODE (expr) == ADDR_EXPR
-	      && TREE_OPERAND (addr, 0) == TREE_OPERAND (expr, 0));
+&& TREE_OPERAND (addr, 0) == TREE_OPERAND (expr, 0));
 }
 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
 return true;
 return false;
 }
 the lhs, evaluate it into a temporary.  Return 1 if the lhs appeared as
 a subexpression, 0 if it did not, or -1 if an error was encountered.  */
 static int
 goa_stabilize_expr (tree *expr_p, gimple_seq *pre_p, tree lhs_addr,
-		    tree lhs_var)
+tree lhs_var)
 {
 tree expr = *expr_p;
 int saw_lhs;
 if (goa_lhs_expr_p (expr, lhs_addr))
 *expr_p = lhs_var;
 return 1;
 }
 if (is_gimple_val (expr))
 return 0;
 saw_lhs = 0;
 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
 {
 case tcc_binary:
 case tcc_comparison:
 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p, lhs_addr,
-				     lhs_var);
+lhs_var);
 case tcc_unary:
 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p, lhs_addr,
-				     lhs_var);
+lhs_var);
 break;
 case tcc_expression:
 switch (TREE_CODE (expr))
-	{
+{
-	case TRUTH_ANDIF_EXPR:
+case TRUTH_ANDIF_EXPR:
-	case TRUTH_ORIF_EXPR:
+case TRUTH_ORIF_EXPR:
-	  saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
+saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
-					 lhs_addr, lhs_var);
+lhs_addr, lhs_var);
-	  saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
+saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
-					 lhs_addr, lhs_var);
+lhs_addr, lhs_var);
-	  break;
+break;
-	default:
+default:
-	  break;
+break;
-	}
+}
 break;
 default:
 break;
 }
 if (saw_lhs == 0)
 {
 enum gimplify_status gs;
 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
 if (gs != GS_ALL_DONE)
-	saw_lhs = -1;
+saw_lhs = -1;
 }
 return saw_lhs;
 }
 side-effects of '--' must actually occur *after* the post
 side-effects of '++'.  However, gimplification will first visit
 the inner expression, so if a separate POST sequence was not
 used, the resulting sequence would be:
-	    1	t.1 = *p
+1   t.1 = *p
-	    2	p = p - 1
+2   p = p - 1
-	    3	t.2 = t.1 + 1
+3   t.2 = t.1 + 1
-	    4	*p = t.2
+4   *p = t.2
 However, the post-decrement operation in line #2 must not be
 evaluated until after the store to *p at line #4, so the
 correct sequence should be:
-	    1	t.1 = *p
+1   t.1 = *p
-	    2	t.2 = t.1 + 1
+2   t.2 = t.1 + 1
-	    3	*p = t.2
+3   *p = t.2
-	    4	p = p - 1
+4   p = p - 1
 So, by specifying a separate post queue, it is possible
 to emit the post side-effects in the correct order.
 If POST_P is NULL, an internal queue will be used.  Before
 returning to the caller, the sequence POST_P is appended to
 function iterates until EXPR is completely gimplified or an error
 occurs.  */
 enum gimplify_status
 gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
-	       bool (*gimple_test_f) (tree), fallback_t fallback)
+bool (*gimple_test_f) (tree), fallback_t fallback)
 {
 tree tmp;
 gimple_seq internal_pre = NULL;
 gimple_seq internal_post = NULL;
 tree save_expr;
 /* Consistency checks.  */
 if (gimple_test_f == is_gimple_reg)
 gcc_assert (fallback & (fb_rvalue | fb_lvalue));
 else if (gimple_test_f == is_gimple_val
-|| gimple_test_f == is_gimple_formal_tmp_rhs
-|| gimple_test_f == is_gimple_formal_tmp_or_call_rhs
-|| gimple_test_f == is_gimple_formal_tmp_reg
-|| gimple_test_f == is_gimple_formal_tmp_var
 || gimple_test_f == is_gimple_call_addr
 || gimple_test_f == is_gimple_condexpr
 || gimple_test_f == is_gimple_mem_rhs
-|| gimple_test_f == is_gimple_mem_or_call_rhs
+|| gimple_test_f == is_gimple_mem_rhs_or_call
 || gimple_test_f == is_gimple_reg_rhs
-|| gimple_test_f == is_gimple_reg_or_call_rhs
+|| gimple_test_f == is_gimple_reg_rhs_or_call
 || gimple_test_f == is_gimple_asm_val)
 gcc_assert (fallback & fb_rvalue);
 else if (gimple_test_f == is_gimple_min_lval
-	   || gimple_test_f == is_gimple_lvalue)
+|| gimple_test_f == is_gimple_lvalue)
 gcc_assert (fallback & fb_lvalue);
 else if (gimple_test_f == is_gimple_addressable)
 gcc_assert (fallback & fb_either);
 else if (gimple_test_f == is_gimple_stmt)
 gcc_assert (fallback == fb_none);
 else
 {
 /* We should have recognized the GIMPLE_TEST_F predicate to
-	 know what kind of fallback to use in case a temporary is
+know what kind of fallback to use in case a temporary is
-	 needed to hold the value or address of *EXPR_P.  */
+needed to hold the value or address of *EXPR_P.  */
 gcc_unreachable ();
 }
 /* We used to check the predicate here and return immediately if it
 succeeds.  This is wrong; the design is for gimplification to be
 /* Loop over the specific gimplifiers until the toplevel node
 remains the same.  */
 do
 {
 /* Strip away as many useless type conversions as possible
-	 at the toplevel.  */
+at the toplevel.  */
 STRIP_USELESS_TYPE_CONVERSION (*expr_p);
 /* Remember the expr.  */
 save_expr = *expr_p;
 /* Die, die, die, my darling.  */
 if (save_expr == error_mark_node
-	  || (TREE_TYPE (save_expr)
+|| (TREE_TYPE (save_expr)
-	      && TREE_TYPE (save_expr) == error_mark_node))
+&& TREE_TYPE (save_expr) == error_mark_node))
-	{
+{
-	  ret = GS_ERROR;
+ret = GS_ERROR;
-	  break;
+break;
-	}
+}
 /* Do any language-specific gimplification.  */
-ret = lang_hooks.gimplify_expr (expr_p, pre_p, post_p);
+ret = ((enum gimplify_status)
+lang_hooks.gimplify_expr (expr_p, pre_p, post_p));
 if (ret == GS_OK)
-	{
+{
-	  if (*expr_p == NULL_TREE)
+if (*expr_p == NULL_TREE)
-	    break;
+break;
-	  if (*expr_p != save_expr)
+if (*expr_p != save_expr)
-	    continue;
+continue;
-	}
+}
 else if (ret != GS_UNHANDLED)
-	break;
+break;
 ret = GS_OK;
 switch (TREE_CODE (*expr_p))
-	{
+{
-	  /* First deal with the special cases.  */
+/* First deal with the special cases.  */
-	case POSTINCREMENT_EXPR:
+case POSTINCREMENT_EXPR:
-	case POSTDECREMENT_EXPR:
+case POSTDECREMENT_EXPR:
-	case PREINCREMENT_EXPR:
+case PREINCREMENT_EXPR:
-	case PREDECREMENT_EXPR:
+case PREDECREMENT_EXPR:
-	  ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
+ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
-					fallback != fb_none);
+fallback != fb_none);
-	  break;
+break;
-	case ARRAY_REF:
+case ARRAY_REF:
-	case ARRAY_RANGE_REF:
+case ARRAY_RANGE_REF:
-	case REALPART_EXPR:
+case REALPART_EXPR:
-	case IMAGPART_EXPR:
+case IMAGPART_EXPR:
-	case COMPONENT_REF:
+case COMPONENT_REF:
-	case VIEW_CONVERT_EXPR:
+case VIEW_CONVERT_EXPR:
-	  ret = gimplify_compound_lval (expr_p, pre_p, post_p,
+ret = gimplify_compound_lval (expr_p, pre_p, post_p,
-					fallback ? fallback : fb_rvalue);
+fallback ? fallback : fb_rvalue);
-	  break;
+break;
-	case COND_EXPR:
+case COND_EXPR:
-	  ret = gimplify_cond_expr (expr_p, pre_p, fallback);
+ret = gimplify_cond_expr (expr_p, pre_p, fallback);
-	  /* C99 code may assign to an array in a structure value of a
+/* C99 code may assign to an array in a structure value of a
-	     conditional expression, and this has undefined behavior
+conditional expression, and this has undefined behavior
-	     only on execution, so create a temporary if an lvalue is
+only on execution, so create a temporary if an lvalue is
-	     required.  */
+required.  */
-	  if (fallback == fb_lvalue)
+if (fallback == fb_lvalue)
-	    {
+{
-	      *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
+*expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
-	      mark_addressable (*expr_p);
+mark_addressable (*expr_p);
-	    }
+}
-	  break;
+break;
-	case CALL_EXPR:
+case CALL_EXPR:
-	  ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
+ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
-	  /* C99 code may assign to an array in a structure returned
+/* C99 code may assign to an array in a structure returned
-	     from a function, and this has undefined behavior only on
+from a function, and this has undefined behavior only on
-	     execution, so create a temporary if an lvalue is
+execution, so create a temporary if an lvalue is
-	     required.  */
+required.  */
-	  if (fallback == fb_lvalue)
+if (fallback == fb_lvalue)
-	    {
+{
-	      *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
+*expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
-	      mark_addressable (*expr_p);
+mark_addressable (*expr_p);
-	    }
+}
-	  break;
+break;
-	case TREE_LIST:
+case TREE_LIST:
-	  gcc_unreachable ();
+gcc_unreachable ();
-	case COMPOUND_EXPR:
+case COMPOUND_EXPR:
-	  ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
+ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
-	  break;
+break;
-	case MODIFY_EXPR:
+case COMPOUND_LITERAL_EXPR:
-	case INIT_EXPR:
+ret = gimplify_compound_literal_expr (expr_p, pre_p);
-	  ret = gimplify_modify_expr (expr_p, pre_p, post_p,
+break;
-				      fallback != fb_none);
-	  break;
+case MODIFY_EXPR:
+case INIT_EXPR:
-	case TRUTH_ANDIF_EXPR:
+ret = gimplify_modify_expr (expr_p, pre_p, post_p,
-	case TRUTH_ORIF_EXPR:
+fallback != fb_none);
-	  ret = gimplify_boolean_expr (expr_p);
+break;
-	  break;
+case TRUTH_ANDIF_EXPR:
-	case TRUTH_NOT_EXPR:
+case TRUTH_ORIF_EXPR:
-	  if (TREE_CODE (TREE_TYPE (*expr_p)) != BOOLEAN_TYPE)
+/* Pass the source location of the outer expression.  */
-	    {
+ret = gimplify_boolean_expr (expr_p, saved_location);
-	      tree type = TREE_TYPE (*expr_p);
+break;
-	      *expr_p = fold_convert (type, gimple_boolify (*expr_p));
-	      ret = GS_OK;
+case TRUTH_NOT_EXPR:
-	      break;
+if (TREE_CODE (TREE_TYPE (*expr_p)) != BOOLEAN_TYPE)
-	    }
+{
+tree type = TREE_TYPE (*expr_p);
-	  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
+*expr_p = fold_convert (type, gimple_boolify (*expr_p));
-			       is_gimple_val, fb_rvalue);
+ret = GS_OK;
-	  recalculate_side_effects (*expr_p);
+break;
-	  break;
+}
-	case ADDR_EXPR:
+ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
-	  ret = gimplify_addr_expr (expr_p, pre_p, post_p);
+is_gimple_val, fb_rvalue);
-	  break;
+recalculate_side_effects (*expr_p);
+break;
-	case VA_ARG_EXPR:
-	  ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
+case ADDR_EXPR:
-	  break;
+ret = gimplify_addr_expr (expr_p, pre_p, post_p);
+break;
-	CASE_CONVERT:
-	  if (IS_EMPTY_STMT (*expr_p))
+case VA_ARG_EXPR:
-	    {
+ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
-	      ret = GS_ALL_DONE;
+break;
-	      break;
-	    }
+CASE_CONVERT:
+if (IS_EMPTY_STMT (*expr_p))
-	  if (VOID_TYPE_P (TREE_TYPE (*expr_p))
+{
-	      || fallback == fb_none)
+ret = GS_ALL_DONE;
-	    {
+break;
-	      /* Just strip a conversion to void (or in void context) and
+}
-		 try again.  */
-	      *expr_p = TREE_OPERAND (*expr_p, 0);
+if (VOID_TYPE_P (TREE_TYPE (*expr_p))
-	      break;
+|| fallback == fb_none)
-	    }
+{
+/* Just strip a conversion to void (or in void context) and
-	  ret = gimplify_conversion (expr_p);
+try again.  */
-	  if (ret == GS_ERROR)
+*expr_p = TREE_OPERAND (*expr_p, 0);
-	    break;
+break;
-	  if (*expr_p != save_expr)
+}
-	    break;
-	  /* FALLTHRU */
+ret = gimplify_conversion (expr_p);
+if (ret == GS_ERROR)
-	case FIX_TRUNC_EXPR:
+break;
-	  /* unary_expr: ... | '(' cast ')' val | ...  */
+if (*expr_p != save_expr)
-	  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
+break;
-			       is_gimple_val, fb_rvalue);
+/* FALLTHRU */
-	  recalculate_side_effects (*expr_p);
-	  break;
+case FIX_TRUNC_EXPR:
+/* unary_expr: ... | '(' cast ')' val | ...  */
-	case INDIRECT_REF:
+ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
-	  *expr_p = fold_indirect_ref (*expr_p);
+is_gimple_val, fb_rvalue);
-	  if (*expr_p != save_expr)
+recalculate_side_effects (*expr_p);
-	    break;
+break;
-	  /* else fall through.  */
-	case ALIGN_INDIRECT_REF:
+case INDIRECT_REF:
-	case MISALIGNED_INDIRECT_REF:
+*expr_p = fold_indirect_ref_loc (input_location, *expr_p);
-	  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
+if (*expr_p != save_expr)
-			       is_gimple_reg, fb_rvalue);
+break;
-	  recalculate_side_effects (*expr_p);
+/* else fall through.  */
-	  break;
+case ALIGN_INDIRECT_REF:
+case MISALIGNED_INDIRECT_REF:
-	  /* Constants need not be gimplified.  */
+ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
-	case INTEGER_CST:
+is_gimple_reg, fb_rvalue);
-	case REAL_CST:
+recalculate_side_effects (*expr_p);
-	case FIXED_CST:
+break;
-	case STRING_CST:
-	case COMPLEX_CST:
+/* Constants need not be gimplified.  */
-	case VECTOR_CST:
+case INTEGER_CST:
-	  ret = GS_ALL_DONE;
+case REAL_CST:
-	  break;
+case FIXED_CST:
+case STRING_CST:
-	case CONST_DECL:
+case COMPLEX_CST:
-	  /* If we require an lvalue, such as for ADDR_EXPR, retain the
+case VECTOR_CST:
-	     CONST_DECL node.  Otherwise the decl is replaceable by its
+ret = GS_ALL_DONE;
-	     value.  */
+break;
-	  /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either.  */
-	  if (fallback & fb_lvalue)
+case CONST_DECL:
-	    ret = GS_ALL_DONE;
+/* If we require an lvalue, such as for ADDR_EXPR, retain the
-	  else
+CONST_DECL node.  Otherwise the decl is replaceable by its
-	    *expr_p = DECL_INITIAL (*expr_p);
+value.  */
-	  break;
+/* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either.  */
+if (fallback & fb_lvalue)
-	case DECL_EXPR:
+ret = GS_ALL_DONE;
-	  ret = gimplify_decl_expr (expr_p, pre_p);
+else
-	  break;
+*expr_p = DECL_INITIAL (*expr_p);
+break;
-	case EXC_PTR_EXPR:
-	  /* FIXME make this a decl.  */
+case DECL_EXPR:
-	  ret = GS_ALL_DONE;
+ret = gimplify_decl_expr (expr_p, pre_p);
-	  break;
+break;
-	case BIND_EXPR:
+case BIND_EXPR:
-	  ret = gimplify_bind_expr (expr_p, pre_p);
+ret = gimplify_bind_expr (expr_p, pre_p);
-	  break;
+break;
-	case LOOP_EXPR:
+case LOOP_EXPR:
-	  ret = gimplify_loop_expr (expr_p, pre_p);
+ret = gimplify_loop_expr (expr_p, pre_p);
-	  break;
+break;
-	case SWITCH_EXPR:
+case SWITCH_EXPR:
-	  ret = gimplify_switch_expr (expr_p, pre_p);
+ret = gimplify_switch_expr (expr_p, pre_p);
-	  break;
+break;
-	case EXIT_EXPR:
+case EXIT_EXPR:
-	  ret = gimplify_exit_expr (expr_p);
+ret = gimplify_exit_expr (expr_p);
-	  break;
+break;
-	case GOTO_EXPR:
+case GOTO_EXPR:
-	  /* If the target is not LABEL, then it is a computed jump
+/* If the target is not LABEL, then it is a computed jump
-	     and the target needs to be gimplified.  */
+and the target needs to be gimplified.  */
-	  if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
+if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
-	    {
+{
-	      ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
+ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
-				   NULL, is_gimple_val, fb_rvalue);
+NULL, is_gimple_val, fb_rvalue);
-	      if (ret == GS_ERROR)
+if (ret == GS_ERROR)
-		break;
+break;
-	    }
+}
-	  gimplify_seq_add_stmt (pre_p,
+gimplify_seq_add_stmt (pre_p,
-			  gimple_build_goto (GOTO_DESTINATION (*expr_p)));
+gimple_build_goto (GOTO_DESTINATION (*expr_p)));
-	  break;
+break;
-	case PREDICT_EXPR:
+case PREDICT_EXPR:
-	  gimplify_seq_add_stmt (pre_p,
+gimplify_seq_add_stmt (pre_p,
-			gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p),
+gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p),
-					      PREDICT_EXPR_OUTCOME (*expr_p)));
+PREDICT_EXPR_OUTCOME (*expr_p)));
-	  ret = GS_ALL_DONE;
+ret = GS_ALL_DONE;
-	  break;
+break;
-	case LABEL_EXPR:
+case LABEL_EXPR:
-	  ret = GS_ALL_DONE;
+ret = GS_ALL_DONE;
-	  gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
+gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
-		      == current_function_decl);
+== current_function_decl);
-	  gimplify_seq_add_stmt (pre_p,
+gimplify_seq_add_stmt (pre_p,
-			  gimple_build_label (LABEL_EXPR_LABEL (*expr_p)));
+gimple_build_label (LABEL_EXPR_LABEL (*expr_p)));
-	  break;
+break;
-	case CASE_LABEL_EXPR:
+case CASE_LABEL_EXPR:
-	  ret = gimplify_case_label_expr (expr_p, pre_p);
+ret = gimplify_case_label_expr (expr_p, pre_p);
-	  break;
+break;
-	case RETURN_EXPR:
+case RETURN_EXPR:
-	  ret = gimplify_return_expr (*expr_p, pre_p);
+ret = gimplify_return_expr (*expr_p, pre_p);
-	  break;
+break;
-	case CONSTRUCTOR:
+case CONSTRUCTOR:
-	  /* Don't reduce this in place; let gimplify_init_constructor work its
+/* Don't reduce this in place; let gimplify_init_constructor work its
-	     magic.  Buf if we're just elaborating this for side effects, just
+magic.  Buf if we're just elaborating this for side effects, just
-	     gimplify any element that has side-effects.  */
+gimplify any element that has side-effects.  */
-	  if (fallback == fb_none)
+if (fallback == fb_none)
-	    {
+{
-	      unsigned HOST_WIDE_INT ix;
+unsigned HOST_WIDE_INT ix;
-	      constructor_elt *ce;
+constructor_elt *ce;
-	      tree temp = NULL_TREE;
+tree temp = NULL_TREE;
-	      for (ix = 0;
+for (ix = 0;
-		   VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (*expr_p),
+VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (*expr_p),
-				ix, ce);
+ix, ce);
-		   ix++)
+ix++)
-		if (TREE_SIDE_EFFECTS (ce->value))
+if (TREE_SIDE_EFFECTS (ce->value))
-		  append_to_statement_list (ce->value, &temp);
+append_to_statement_list (ce->value, &temp);
-	      *expr_p = temp;
+*expr_p = temp;
-	      ret = GS_OK;
+ret = GS_OK;
-	    }
+}
-	  /* C99 code may assign to an array in a constructed
+/* C99 code may assign to an array in a constructed
-	     structure or union, and this has undefined behavior only
+structure or union, and this has undefined behavior only
-	     on execution, so create a temporary if an lvalue is
+on execution, so create a temporary if an lvalue is
-	     required.  */
+required.  */
-	  else if (fallback == fb_lvalue)
+else if (fallback == fb_lvalue)
-	    {
+{
-	      *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
+*expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
-	      mark_addressable (*expr_p);
+mark_addressable (*expr_p);
-	    }
+}
-	  else
+else
-	    ret = GS_ALL_DONE;
+ret = GS_ALL_DONE;
-	  break;
+break;
-	  /* The following are special cases that are not handled by the
+/* The following are special cases that are not handled by the
-	     original GIMPLE grammar.  */
+original GIMPLE grammar.  */
-	  /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
+/* SAVE_EXPR nodes are converted into a GIMPLE identifier and
-	     eliminated.  */
+eliminated.  */
-	case SAVE_EXPR:
+case SAVE_EXPR:
-	  ret = gimplify_save_expr (expr_p, pre_p, post_p);
+ret = gimplify_save_expr (expr_p, pre_p, post_p);
-	  break;
+break;
-	case BIT_FIELD_REF:
+case BIT_FIELD_REF:
-	  {
+{
-	    enum gimplify_status r0, r1, r2;
+enum gimplify_status r0, r1, r2;
-	    r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
+r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
-				post_p, is_gimple_lvalue, fb_either);
+post_p, is_gimple_lvalue, fb_either);
-	    r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
+r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
-				post_p, is_gimple_val, fb_rvalue);
+post_p, is_gimple_val, fb_rvalue);
-	    r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
+r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
-				post_p, is_gimple_val, fb_rvalue);
+post_p, is_gimple_val, fb_rvalue);
-	    recalculate_side_effects (*expr_p);
+recalculate_side_effects (*expr_p);
-	    ret = MIN (r0, MIN (r1, r2));
+ret = MIN (r0, MIN (r1, r2));
-	  }
+}
-	  break;
+break;
-	case NON_LVALUE_EXPR:
+case TARGET_MEM_REF:
-	  /* This should have been stripped above.  */
+{
-	  gcc_unreachable ();
+enum gimplify_status r0 = GS_ALL_DONE, r1 = GS_ALL_DONE;
-	case ASM_EXPR:
+if (TMR_SYMBOL (*expr_p))
-	  ret = gimplify_asm_expr (expr_p, pre_p, post_p);
+r0 = gimplify_expr (&TMR_SYMBOL (*expr_p), pre_p,
-	  break;
+post_p, is_gimple_lvalue, fb_either);
+else if (TMR_BASE (*expr_p))
-	case TRY_FINALLY_EXPR:
+r0 = gimplify_expr (&TMR_BASE (*expr_p), pre_p,
-	case TRY_CATCH_EXPR:
+post_p, is_gimple_val, fb_either);
-	  {
+if (TMR_INDEX (*expr_p))
-	    gimple_seq eval, cleanup;
+r1 = gimplify_expr (&TMR_INDEX (*expr_p), pre_p,
-	    gimple try_;
+post_p, is_gimple_val, fb_rvalue);
+/* TMR_STEP and TMR_OFFSET are always integer constants.  */
-	    eval = cleanup = NULL;
+ret = MIN (r0, r1);
-	    gimplify_and_add (TREE_OPERAND (*expr_p, 0), &eval);
+}
-	    gimplify_and_add (TREE_OPERAND (*expr_p, 1), &cleanup);
+break;
-	    /* Don't create bogus GIMPLE_TRY with empty cleanup.  */
-	    if (gimple_seq_empty_p (cleanup))
+case NON_LVALUE_EXPR:
-	      {
+/* This should have been stripped above.  */
-		gimple_seq_add_seq (pre_p, eval);
+gcc_unreachable ();
-		ret = GS_ALL_DONE;
-		break;
+case ASM_EXPR:
-	      }
+ret = gimplify_asm_expr (expr_p, pre_p, post_p);
-	    try_ = gimple_build_try (eval, cleanup,
+break;
-				     TREE_CODE (*expr_p) == TRY_FINALLY_EXPR
-				     ? GIMPLE_TRY_FINALLY
+case TRY_FINALLY_EXPR:
-				     : GIMPLE_TRY_CATCH);
+case TRY_CATCH_EXPR:
-	    if (TREE_CODE (*expr_p) == TRY_CATCH_EXPR)
+{
-	      gimple_try_set_catch_is_cleanup (try_,
+gimple_seq eval, cleanup;
-					       TRY_CATCH_IS_CLEANUP (*expr_p));
+gimple try_;
-	    gimplify_seq_add_stmt (pre_p, try_);
-	    ret = GS_ALL_DONE;
+eval = cleanup = NULL;
-	    break;
+gimplify_and_add (TREE_OPERAND (*expr_p, 0), &eval);
-	  }
+gimplify_and_add (TREE_OPERAND (*expr_p, 1), &cleanup);
+/* Don't create bogus GIMPLE_TRY with empty cleanup.  */
-	case CLEANUP_POINT_EXPR:
+if (gimple_seq_empty_p (cleanup))
-	  ret = gimplify_cleanup_point_expr (expr_p, pre_p);
+{
-	  break;
+gimple_seq_add_seq (pre_p, eval);
+ret = GS_ALL_DONE;
-	case TARGET_EXPR:
+break;
-	  ret = gimplify_target_expr (expr_p, pre_p, post_p);
+}
-	  break;
+try_ = gimple_build_try (eval, cleanup,
+TREE_CODE (*expr_p) == TRY_FINALLY_EXPR
-	case CATCH_EXPR:
+? GIMPLE_TRY_FINALLY
-	  {
+: GIMPLE_TRY_CATCH);
-	    gimple c;
+if (TREE_CODE (*expr_p) == TRY_CATCH_EXPR)
-	    gimple_seq handler = NULL;
+gimple_try_set_catch_is_cleanup (try_,
-	    gimplify_and_add (CATCH_BODY (*expr_p), &handler);
+TRY_CATCH_IS_CLEANUP (*expr_p));
-	    c = gimple_build_catch (CATCH_TYPES (*expr_p), handler);
+gimplify_seq_add_stmt (pre_p, try_);
-	    gimplify_seq_add_stmt (pre_p, c);
+ret = GS_ALL_DONE;
-	    ret = GS_ALL_DONE;
+break;
-	    break;
+}
-	  }
+case CLEANUP_POINT_EXPR:
-	case EH_FILTER_EXPR:
+ret = gimplify_cleanup_point_expr (expr_p, pre_p);
-	  {
+break;
-	    gimple ehf;
-	    gimple_seq failure = NULL;
+case TARGET_EXPR:
+ret = gimplify_target_expr (expr_p, pre_p, post_p);
-	    gimplify_and_add (EH_FILTER_FAILURE (*expr_p), &failure);
+break;
-	    ehf = gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p), failure);
-	    gimple_eh_filter_set_must_not_throw
+case CATCH_EXPR:
-	      (ehf, EH_FILTER_MUST_NOT_THROW (*expr_p));
+{
-	    gimplify_seq_add_stmt (pre_p, ehf);
+gimple c;
-	    ret = GS_ALL_DONE;
+gimple_seq handler = NULL;
-	    break;
+gimplify_and_add (CATCH_BODY (*expr_p), &handler);
-	  }
+c = gimple_build_catch (CATCH_TYPES (*expr_p), handler);
+gimplify_seq_add_stmt (pre_p, c);
-	case CHANGE_DYNAMIC_TYPE_EXPR:
+ret = GS_ALL_DONE;
-	  {
+break;
-	    gimple cdt;
+}
-	    ret = gimplify_expr (&CHANGE_DYNAMIC_TYPE_LOCATION (*expr_p),
+case EH_FILTER_EXPR:
-				 pre_p, post_p, is_gimple_reg, fb_lvalue);
+{
-	    cdt = gimple_build_cdt (CHANGE_DYNAMIC_TYPE_NEW_TYPE (*expr_p),
+gimple ehf;
-				    CHANGE_DYNAMIC_TYPE_LOCATION (*expr_p));
+gimple_seq failure = NULL;
-	    gimplify_seq_add_stmt (pre_p, cdt);
-	    ret = GS_ALL_DONE;
+gimplify_and_add (EH_FILTER_FAILURE (*expr_p), &failure);
-	  }
+ehf = gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p), failure);
-	  break;
+gimple_set_no_warning (ehf, TREE_NO_WARNING (*expr_p));
+gimplify_seq_add_stmt (pre_p, ehf);
-	case OBJ_TYPE_REF:
+ret = GS_ALL_DONE;
-	  {
+break;
-	    enum gimplify_status r0, r1;
+}
-	    r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p,
-				post_p, is_gimple_val, fb_rvalue);
+case OBJ_TYPE_REF:
-	    r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p,
+{
-				post_p, is_gimple_val, fb_rvalue);
+enum gimplify_status r0, r1;
-	    TREE_SIDE_EFFECTS (*expr_p) = 0;
+r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p,
-	    ret = MIN (r0, r1);
+post_p, is_gimple_val, fb_rvalue);
-	  }
+r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p,
-	  break;
+post_p, is_gimple_val, fb_rvalue);
+TREE_SIDE_EFFECTS (*expr_p) = 0;
-	case LABEL_DECL:
+ret = MIN (r0, r1);
-	  /* We get here when taking the address of a label.  We mark
+}
-	     the label as "forced"; meaning it can never be removed and
+break;
-	     it is a potential target for any computed goto.  */
-	  FORCED_LABEL (*expr_p) = 1;
+case LABEL_DECL:
-	  ret = GS_ALL_DONE;
+/* We get here when taking the address of a label.  We mark
-	  break;
+the label as "forced"; meaning it can never be removed and
+it is a potential target for any computed goto.  */
-	case STATEMENT_LIST:
+FORCED_LABEL (*expr_p) = 1;
-	  ret = gimplify_statement_list (expr_p, pre_p);
+ret = GS_ALL_DONE;
-	  break;
+break;
-	case WITH_SIZE_EXPR:
+case STATEMENT_LIST:
-	  {
+ret = gimplify_statement_list (expr_p, pre_p);
-	    gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
+break;
-			   post_p == &internal_post ? NULL : post_p,
-			   gimple_test_f, fallback);
+case WITH_SIZE_EXPR:
-	    gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
+{
-			   is_gimple_val, fb_rvalue);
+gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
-	  }
+post_p == &internal_post ? NULL : post_p,
-	  break;
+gimple_test_f, fallback);
+gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
-	case VAR_DECL:
+is_gimple_val, fb_rvalue);
-	case PARM_DECL:
+}
-	  ret = gimplify_var_or_parm_decl (expr_p);
+break;
-	  break;
+case VAR_DECL:
-	case RESULT_DECL:
+case PARM_DECL:
-	  /* When within an OpenMP context, notice uses of variables.  */
+ret = gimplify_var_or_parm_decl (expr_p);
-	  if (gimplify_omp_ctxp)
+break;
-	    omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
-	  ret = GS_ALL_DONE;
+case RESULT_DECL:
-	  break;
+/* When within an OpenMP context, notice uses of variables.  */
+if (gimplify_omp_ctxp)
-	case SSA_NAME:
+omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
-	  /* Allow callbacks into the gimplifier during optimization.  */
+ret = GS_ALL_DONE;
-	  ret = GS_ALL_DONE;
+break;
-	  break;
+case SSA_NAME:
-	case OMP_PARALLEL:
+/* Allow callbacks into the gimplifier during optimization.  */
-	  gimplify_omp_parallel (expr_p, pre_p);
+ret = GS_ALL_DONE;
-	  ret = GS_ALL_DONE;
+break;
-	  break;
+case OMP_PARALLEL:
-	case OMP_TASK:
+gimplify_omp_parallel (expr_p, pre_p);
-	  gimplify_omp_task (expr_p, pre_p);
+ret = GS_ALL_DONE;
-	  ret = GS_ALL_DONE;
+break;
-	  break;
+case OMP_TASK:
-	case OMP_FOR:
+gimplify_omp_task (expr_p, pre_p);
-	  ret = gimplify_omp_for (expr_p, pre_p);
+ret = GS_ALL_DONE;
-	  break;
+break;
-	case OMP_SECTIONS:
+case OMP_FOR:
-	case OMP_SINGLE:
+ret = gimplify_omp_for (expr_p, pre_p);
-	  gimplify_omp_workshare (expr_p, pre_p);
+break;
-	  ret = GS_ALL_DONE;
-	  break;
+case OMP_SECTIONS:
+case OMP_SINGLE:
-	case OMP_SECTION:
+gimplify_omp_workshare (expr_p, pre_p);
-	case OMP_MASTER:
+ret = GS_ALL_DONE;
-	case OMP_ORDERED:
+break;
-	case OMP_CRITICAL:
-	  {
+case OMP_SECTION:
-	    gimple_seq body = NULL;
+case OMP_MASTER:
-	    gimple g;
+case OMP_ORDERED:
+case OMP_CRITICAL:
-	    gimplify_and_add (OMP_BODY (*expr_p), &body);
+{
-	    switch (TREE_CODE (*expr_p))
+gimple_seq body = NULL;
-	      {
+gimple g;
-	      case OMP_SECTION:
-	        g = gimple_build_omp_section (body);
+gimplify_and_add (OMP_BODY (*expr_p), &body);
-	        break;
+switch (TREE_CODE (*expr_p))
-	      case OMP_MASTER:
+{
-	        g = gimple_build_omp_master (body);
+case OMP_SECTION:
-		break;
+g = gimple_build_omp_section (body);
-	      case OMP_ORDERED:
+break;
-		g = gimple_build_omp_ordered (body);
+case OMP_MASTER:
-		break;
+g = gimple_build_omp_master (body);
-	      case OMP_CRITICAL:
+break;
-		g = gimple_build_omp_critical (body,
+case OMP_ORDERED:
-		    			       OMP_CRITICAL_NAME (*expr_p));
+g = gimple_build_omp_ordered (body);
-		break;
+break;
-	      default:
+case OMP_CRITICAL:
-		gcc_unreachable ();
+g = gimple_build_omp_critical (body,
-	      }
+OMP_CRITICAL_NAME (*expr_p));
-	    gimplify_seq_add_stmt (pre_p, g);
+break;
-	    ret = GS_ALL_DONE;
+default:
-	    break;
+gcc_unreachable ();
-	  }
+}
+gimplify_seq_add_stmt (pre_p, g);
-	case OMP_ATOMIC:
+ret = GS_ALL_DONE;
-	  ret = gimplify_omp_atomic (expr_p, pre_p);
+break;
-	  break;
+}
-	case POINTER_PLUS_EXPR:
+case OMP_ATOMIC:
+ret = gimplify_omp_atomic (expr_p, pre_p);
+break;
+case POINTER_PLUS_EXPR:
 /* Convert ((type *)A)+offset into &A->field_of_type_and_offset.
-	     The second is gimple immediate saving a need for extra statement.
+The second is gimple immediate saving a need for extra statement.
-	   */
+*/
-	  if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
+if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
-	      && (tmp = maybe_fold_offset_to_address
+&& (tmp = maybe_fold_offset_to_address
-			 (TREE_OPERAND (*expr_p, 0), TREE_OPERAND (*expr_p, 1),
+(EXPR_LOCATION (*expr_p),
-		   	  TREE_TYPE (*expr_p))))
+TREE_OPERAND (*expr_p, 0), TREE_OPERAND (*expr_p, 1),
-	    {
+TREE_TYPE (*expr_p))))
-	      *expr_p = tmp;
+{
-	      break;
+*expr_p = tmp;
-	    }
+break;
-	  /* Convert (void *)&a + 4 into (void *)&a[1].  */
+}
-	  if (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == NOP_EXPR
+/* Convert (void *)&a + 4 into (void *)&a[1].  */
-	      && TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
+if (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == NOP_EXPR
-	      && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p,
+&& TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
-									0),0)))
+&& POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p,
-	      && (tmp = maybe_fold_offset_to_address
+0),0)))
-			 (TREE_OPERAND (TREE_OPERAND (*expr_p, 0), 0),
+&& (tmp = maybe_fold_offset_to_address
-			  TREE_OPERAND (*expr_p, 1),
+(EXPR_LOCATION (*expr_p),
-		   	  TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),
+TREE_OPERAND (TREE_OPERAND (*expr_p, 0), 0),
-						   0)))))
+TREE_OPERAND (*expr_p, 1),
-	     {
+TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),
+0)))))
+{
 *expr_p = fold_convert (TREE_TYPE (*expr_p), tmp);
-	       break;
+break;
-	     }
+}
 /* FALLTHRU */
-	default:
+default:
-	  switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
+switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
-	    {
+{
-	    case tcc_comparison:
+case tcc_comparison:
-	      /* Handle comparison of objects of non scalar mode aggregates
+/* Handle comparison of objects of non scalar mode aggregates
-	     	 with a call to memcmp.  It would be nice to only have to do
+with a call to memcmp.  It would be nice to only have to do
-	     	 this for variable-sized objects, but then we'd have to allow
+this for variable-sized objects, but then we'd have to allow
-	     	 the same nest of reference nodes we allow for MODIFY_EXPR and
+the same nest of reference nodes we allow for MODIFY_EXPR and
-	     	 that's too complex.
+that's too complex.
-		 Compare scalar mode aggregates as scalar mode values.  Using
+Compare scalar mode aggregates as scalar mode values.  Using
-		 memcmp for them would be very inefficient at best, and is
+memcmp for them would be very inefficient at best, and is
-		 plain wrong if bitfields are involved.  */
+plain wrong if bitfields are involved.  */
-		{
+{
-		  tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
+tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
-		  if (!AGGREGATE_TYPE_P (type))
+if (!AGGREGATE_TYPE_P (type))
-		    goto expr_2;
+goto expr_2;
-		  else if (TYPE_MODE (type) != BLKmode)
+else if (TYPE_MODE (type) != BLKmode)
-		    ret = gimplify_scalar_mode_aggregate_compare (expr_p);
+ret = gimplify_scalar_mode_aggregate_compare (expr_p);
-		  else
+else
-		    ret = gimplify_variable_sized_compare (expr_p);
+ret = gimplify_variable_sized_compare (expr_p);
-		  break;
+break;
-		}
+}
-	    /* If *EXPR_P does not need to be special-cased, handle it
+/* If *EXPR_P does not need to be special-cased, handle it
-	       according to its class.  */
+according to its class.  */
-	    case tcc_unary:
+case tcc_unary:
-	      ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
+ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
-				   post_p, is_gimple_val, fb_rvalue);
+post_p, is_gimple_val, fb_rvalue);
-	      break;
+break;
-	    case tcc_binary:
+case tcc_binary:
-	    expr_2:
+expr_2:
-	      {
+{
-		enum gimplify_status r0, r1;
+enum gimplify_status r0, r1;
-		r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
+r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
-		                    post_p, is_gimple_val, fb_rvalue);
+post_p, is_gimple_val, fb_rvalue);
-		r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
+r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
-				    post_p, is_gimple_val, fb_rvalue);
+post_p, is_gimple_val, fb_rvalue);
-		ret = MIN (r0, r1);
+ret = MIN (r0, r1);
-		break;
+break;
-	      }
+}
-	    case tcc_declaration:
+case tcc_declaration:
-	    case tcc_constant:
+case tcc_constant:
-	      ret = GS_ALL_DONE;
+ret = GS_ALL_DONE;
-	      goto dont_recalculate;
+goto dont_recalculate;
-	    default:
+default:
-	      gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR
+gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR
-			  || TREE_CODE (*expr_p) == TRUTH_OR_EXPR
+|| TREE_CODE (*expr_p) == TRUTH_OR_EXPR
-			  || TREE_CODE (*expr_p) == TRUTH_XOR_EXPR);
+|| TREE_CODE (*expr_p) == TRUTH_XOR_EXPR);
-	      goto expr_2;
+goto expr_2;
-	    }
+}
-	  recalculate_side_effects (*expr_p);
+recalculate_side_effects (*expr_p);
-	dont_recalculate:
+dont_recalculate:
-	  break;
+break;
-	}
+}
 /* If we replaced *expr_p, gimplify again.  */
 if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr))
-	ret = GS_ALL_DONE;
+ret = GS_ALL_DONE;
 }
 while (ret == GS_OK);
 /* If we encountered an error_mark somewhere nested inside, either
 stub out the statement or propagate the error back out.  */
 if (ret == GS_ERROR)
 {
 if (is_statement)
-	*expr_p = NULL;
+*expr_p = NULL;
 goto out;
 }
 /* This was only valid as a return value from the langhook, which
 we handled.  Make sure it doesn't escape from any other context.  */
 gcc_assert (ret != GS_UNHANDLED);
 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
 {
 /* We aren't looking for a value, and we don't have a valid
-	 statement.  If it doesn't have side-effects, throw it away.  */
+statement.  If it doesn't have side-effects, throw it away.  */
 if (!TREE_SIDE_EFFECTS (*expr_p))
-	*expr_p = NULL;
+*expr_p = NULL;
 else if (!TREE_THIS_VOLATILE (*expr_p))
-	{
+{
-	  /* This is probably a _REF that contains something nested that
+/* This is probably a _REF that contains something nested that
-	     has side effects.  Recurse through the operands to find it.  */
+has side effects.  Recurse through the operands to find it.  */
-	  enum tree_code code = TREE_CODE (*expr_p);
+enum tree_code code = TREE_CODE (*expr_p);
-	  switch (code)
+switch (code)
-	    {
+{
-	    case COMPONENT_REF:
+case COMPONENT_REF:
-	    case REALPART_EXPR:
+case REALPART_EXPR:
-	    case IMAGPART_EXPR:
+case IMAGPART_EXPR:
-	    case VIEW_CONVERT_EXPR:
+case VIEW_CONVERT_EXPR:
-	      gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
+gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
-			     gimple_test_f, fallback);
+gimple_test_f, fallback);
-	      break;
+break;
-	    case ARRAY_REF:
+case ARRAY_REF:
-	    case ARRAY_RANGE_REF:
+case ARRAY_RANGE_REF:
-	      gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
+gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
-			     gimple_test_f, fallback);
+gimple_test_f, fallback);
-	      gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
+gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
-			     gimple_test_f, fallback);
+gimple_test_f, fallback);
-	      break;
+break;
-	    default:
+default:
-	       /* Anything else with side-effects must be converted to
+/* Anything else with side-effects must be converted to
-		  a valid statement before we get here.  */
+a valid statement before we get here.  */
-	      gcc_unreachable ();
+gcc_unreachable ();
-	    }
+}
-	  *expr_p = NULL;
+*expr_p = NULL;
-	}
+}
 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p))
-	       && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
+&& TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
-	{
+{
-	  /* Historically, the compiler has treated a bare reference
+/* Historically, the compiler has treated a bare reference
-	     to a non-BLKmode volatile lvalue as forcing a load.  */
+to a non-BLKmode volatile lvalue as forcing a load.  */
-	  tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
+tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
-	  /* Normally, we do not want to create a temporary for a
+/* Normally, we do not want to create a temporary for a
-	     TREE_ADDRESSABLE type because such a type should not be
+TREE_ADDRESSABLE type because such a type should not be
-	     copied by bitwise-assignment.  However, we make an
+copied by bitwise-assignment.  However, we make an
-	     exception here, as all we are doing here is ensuring that
+exception here, as all we are doing here is ensuring that
-	     we read the bytes that make up the type.  We use
+we read the bytes that make up the type.  We use
-	     create_tmp_var_raw because create_tmp_var will abort when
+create_tmp_var_raw because create_tmp_var will abort when
-	     given a TREE_ADDRESSABLE type.  */
+given a TREE_ADDRESSABLE type.  */
-	  tree tmp = create_tmp_var_raw (type, "vol");
+tree tmp = create_tmp_var_raw (type, "vol");
-	  gimple_add_tmp_var (tmp);
+gimple_add_tmp_var (tmp);
-	  gimplify_assign (tmp, *expr_p, pre_p);
+gimplify_assign (tmp, *expr_p, pre_p);
-	  *expr_p = NULL;
+*expr_p = NULL;
-	}
+}
 else
-	/* We can't do anything useful with a volatile reference to
+/* We can't do anything useful with a volatile reference to
-	   an incomplete type, so just throw it away.  Likewise for
+an incomplete type, so just throw it away.  Likewise for
-	   a BLKmode type, since any implicit inner load should
+a BLKmode type, since any implicit inner load should
-	   already have been turned into an explicit one by the
+already have been turned into an explicit one by the
-	   gimplification process.  */
+gimplification process.  */
-	*expr_p = NULL;
+*expr_p = NULL;
 }
 /* If we are gimplifying at the statement level, we're done.  Tack
 everything together and return.  */
 if (fallback == fb_none || is_statement)
 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
 it out for GC to reclaim it.  */
 *expr_p = NULL_TREE;
 if (!gimple_seq_empty_p (internal_pre)
-	  || !gimple_seq_empty_p (internal_post))
+|| !gimple_seq_empty_p (internal_post))
-	{
+{
-	  gimplify_seq_add_seq (&internal_pre, internal_post);
+gimplify_seq_add_seq (&internal_pre, internal_post);
-	  gimplify_seq_add_seq (pre_p, internal_pre);
+gimplify_seq_add_seq (pre_p, internal_pre);
-	}
+}
 /* The result of gimplifying *EXPR_P is going to be the last few
-	 statements in *PRE_P and *POST_P.  Add location information
+statements in *PRE_P and *POST_P.  Add location information
-	 to all the statements that were added by the gimplification
+to all the statements that were added by the gimplification
-	 helpers.  */
+helpers.  */
 if (!gimple_seq_empty_p (*pre_p))
-	annotate_all_with_location_after (*pre_p, pre_last_gsi, input_location);
+annotate_all_with_location_after (*pre_p, pre_last_gsi, input_location);
 if (!gimple_seq_empty_p (*post_p))
-	annotate_all_with_location_after (*post_p, post_last_gsi,
+annotate_all_with_location_after (*post_p, post_last_gsi,
-					  input_location);
+input_location);
 goto out;
 }
 #ifdef ENABLE_GIMPLE_CHECKING
 if (*expr_p)
 {
 enum tree_code code = TREE_CODE (*expr_p);
 /* These expressions should already be in gimple IR form.  */
 gcc_assert (code != MODIFY_EXPR
-		  && code != ASM_EXPR
+&& code != ASM_EXPR
-		  && code != BIND_EXPR
+&& code != BIND_EXPR
-		  && code != CATCH_EXPR
+&& code != CATCH_EXPR
-		  && (code != COND_EXPR || gimplify_ctxp->allow_rhs_cond_expr)
+&& (code != COND_EXPR || gimplify_ctxp->allow_rhs_cond_expr)
-		  && code != EH_FILTER_EXPR
+&& code != EH_FILTER_EXPR
-		  && code != GOTO_EXPR
+&& code != GOTO_EXPR
-		  && code != LABEL_EXPR
+&& code != LABEL_EXPR
-		  && code != LOOP_EXPR
+&& code != LOOP_EXPR
-		  && code != RESX_EXPR
+&& code != SWITCH_EXPR
-		  && code != SWITCH_EXPR
+&& code != TRY_FINALLY_EXPR
-		  && code != TRY_FINALLY_EXPR
+&& code != OMP_CRITICAL
-		  && code != OMP_CRITICAL
+&& code != OMP_FOR
-		  && code != OMP_FOR
+&& code != OMP_MASTER
-		  && code != OMP_MASTER
+&& code != OMP_ORDERED
-		  && code != OMP_ORDERED
+&& code != OMP_PARALLEL
-		  && code != OMP_PARALLEL
+&& code != OMP_SECTIONS
-		  && code != OMP_SECTIONS
+&& code != OMP_SECTION
-		  && code != OMP_SECTION
+&& code != OMP_SINGLE);
-		  && code != OMP_SINGLE);
 }
 #endif
 /* Otherwise we're gimplifying a subexpression, so the resulting
 value is interesting.  If it's a valid operand that matches
 if ((fallback & fb_lvalue)
 && gimple_seq_empty_p (internal_post)
 && is_gimple_addressable (*expr_p))
 {
 /* An lvalue will do.  Take the address of the expression, store it
-	 in a temporary, and replace the expression with an INDIRECT_REF of
+in a temporary, and replace the expression with an INDIRECT_REF of
-	 that temporary.  */
+that temporary.  */
-tmp = build_fold_addr_expr (*expr_p);
+tmp = build_fold_addr_expr_loc (input_location, *expr_p);
 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (tmp)), tmp);
 }
-else if ((fallback & fb_rvalue) && is_gimple_formal_tmp_or_call_rhs (*expr_p))
+else if ((fallback & fb_rvalue) && is_gimple_reg_rhs_or_call (*expr_p))
 {
 /* An rvalue will do.  Assign the gimplified expression into a
-	 new temporary TMP and replace the original expression with
+new temporary TMP and replace the original expression with
-	 TMP.  First, make sure that the expression has a type so that
+TMP.  First, make sure that the expression has a type so that
-	 it can be assigned into a temporary.  */
+it can be assigned into a temporary.  */
 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
 if (!gimple_seq_empty_p (internal_post) || (fallback & fb_lvalue))
-	/* The postqueue might change the value of the expression between
+/* The postqueue might change the value of the expression between
-	   the initialization and use of the temporary, so we can't use a
+the initialization and use of the temporary, so we can't use a
-	   formal temp.  FIXME do we care?  */
+formal temp.  FIXME do we care?  */
-	*expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
+{
+*expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
+if (TREE_CODE (TREE_TYPE (*expr_p)) == COMPLEX_TYPE
+|| TREE_CODE (TREE_TYPE (*expr_p)) == VECTOR_TYPE)
+DECL_GIMPLE_REG_P (*expr_p) = 1;
+}
 else
-	*expr_p = get_formal_tmp_var (*expr_p, pre_p);
+*expr_p = get_formal_tmp_var (*expr_p, pre_p);
-if (TREE_CODE (*expr_p) != SSA_NAME)
-	DECL_GIMPLE_FORMAL_TEMP_P (*expr_p) = 1;
 }
 else
 {
 #ifdef ENABLE_GIMPLE_CHECKING
 if (!(fallback & fb_mayfail))
-	{
+{
-	  fprintf (stderr, "gimplification failed:\n");
+fprintf (stderr, "gimplification failed:\n");
-	  print_generic_expr (stderr, *expr_p, 0);
+print_generic_expr (stderr, *expr_p, 0);
-	  debug_tree (*expr_p);
+debug_tree (*expr_p);
-	  internal_error ("gimplification failed");
+internal_error ("gimplification failed");
-	}
+}
 #endif
 gcc_assert (fallback & fb_mayfail);
 /* If this is an asm statement, and the user asked for the
-	 impossible, don't die.  Fail and let gimplify_asm_expr
+impossible, don't die.  Fail and let gimplify_asm_expr
-	 issue an error.  */
+issue an error.  */
 ret = GS_ERROR;
 goto out;
 }
 /* Make sure the temporary matches our predicate.  */
 case FIXED_POINT_TYPE:
 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
-	{
+{
-	  TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
+TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
-	  TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
+TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
-	}
+}
 break;
 case ARRAY_TYPE:
 /* These types may not have declarations, so handle them here.  */
 gimplify_type_sizes (TREE_TYPE (type), list_p);
 gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
 /* When not optimizing, ensure VLA bounds aren't removed.  */
 if (!optimize
-	  && TYPE_DOMAIN (type)
+&& TYPE_DOMAIN (type)
-	  && INTEGRAL_TYPE_P (TYPE_DOMAIN (type)))
+&& INTEGRAL_TYPE_P (TYPE_DOMAIN (type)))
-	{
+{
-	  t = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
+t = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
-	  if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
+if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
-	    DECL_IGNORED_P (t) = 0;
+DECL_IGNORED_P (t) = 0;
-	  t = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
+t = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
-	  if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
+if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
-	    DECL_IGNORED_P (t) = 0;
+DECL_IGNORED_P (t) = 0;
-	}
+}
 break;
 case RECORD_TYPE:
 case UNION_TYPE:
 case QUAL_UNION_TYPE:
 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
-	if (TREE_CODE (field) == FIELD_DECL)
+if (TREE_CODE (field) == FIELD_DECL)
-	  {
+{
-	    gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
+gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
-	    gimplify_one_sizepos (&DECL_SIZE (field), list_p);
+gimplify_one_sizepos (&DECL_SIZE (field), list_p);
-	    gimplify_one_sizepos (&DECL_SIZE_UNIT (field), list_p);
+gimplify_one_sizepos (&DECL_SIZE_UNIT (field), list_p);
-	    gimplify_type_sizes (TREE_TYPE (field), list_p);
+gimplify_type_sizes (TREE_TYPE (field), list_p);
-	  }
+}
 break;
 case POINTER_TYPE:
 case REFERENCE_TYPE:
-	/* We used to recurse on the pointed-to type here, which turned out to
+/* We used to recurse on the pointed-to type here, which turned out to
-	   be incorrect because its definition might refer to variables not
+be incorrect because its definition might refer to variables not
-	   yet initialized at this point if a forward declaration is involved.
+yet initialized at this point if a forward declaration is involved.
-	   It was actually useful for anonymous pointed-to types to ensure
+It was actually useful for anonymous pointed-to types to ensure
-	   that the sizes evaluation dominates every possible later use of the
+that the sizes evaluation dominates every possible later use of the
-	   values.  Restricting to such types here would be safe since there
+values.  Restricting to such types here would be safe since there
-	   is no possible forward declaration around, but would introduce an
+is no possible forward declaration around, but would introduce an
-	   undesirable middle-end semantic to anonymity.  We then defer to
+undesirable middle-end semantic to anonymity.  We then defer to
-	   front-ends the responsibility of ensuring that the sizes are
+front-ends the responsibility of ensuring that the sizes are
-	   evaluated both early and late enough, e.g. by attaching artificial
+evaluated both early and late enough, e.g. by attaching artificial
-	   type declarations to the tree.  */
+type declarations to the tree.  */
 break;
 default:
 break;
 }
 *expr_p = create_tmp_var (type, NULL);
 tmp = build1 (NOP_EXPR, type, expr);
 stmt = gimplify_assign (*expr_p, tmp, stmt_p);
 if (EXPR_HAS_LOCATION (expr))
-	gimple_set_location (stmt, *EXPR_LOCUS (expr));
+gimple_set_location (stmt, EXPR_LOCATION (expr));
 else
-	gimple_set_location (stmt, input_location);
+gimple_set_location (stmt, input_location);
 }
 }
 /* Gimplify the body of statements pointed to by BODY_P and return a
 It would seem we don't have to do this for nested functions because
 they are supposed to be output and then the outer function gimplified
 first, but the g++ front end doesn't always do it that way.  */
 unshare_body (body_p, fndecl);
 unvisit_body (body_p, fndecl);
+if (cgraph_node (fndecl)->origin)
+nonlocal_vlas = pointer_set_create ();
 /* Make sure input_location isn't set to something weird.  */
 input_location = DECL_SOURCE_LOCATION (fndecl);
 /* Resolve callee-copies.  This has to be done before processing
 {
 gimplify_seq_add_seq (&parm_stmts, gimple_bind_body (outer_bind));
 gimple_bind_set_body (outer_bind, parm_stmts);
 }
+if (nonlocal_vlas)
+{
+pointer_set_destroy (nonlocal_vlas);
+nonlocal_vlas = NULL;
+}
 pop_gimplify_context (outer_bind);
 gcc_assert (gimplify_ctxp == NULL);
 #ifdef ENABLE_TYPES_CHECKING
 if (!errorcount && !sorrycount)
 return outer_bind;
 }
 /* Entry point to the gimplification pass.  FNDECL is the FUNCTION_DECL
 node for the function we want to gimplify.
 Returns the sequence of GIMPLE statements corresponding to the body
 of FNDECL.  */
 void
 gimplify_function_tree (tree fndecl)
 {
 tree oldfn, parm, ret;
 gimple_seq seq;
 gimple bind;
+gcc_assert (!gimple_body (fndecl));
 oldfn = current_function_decl;
 current_function_decl = fndecl;
 if (DECL_STRUCT_FUNCTION (fndecl))
 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
 {
 /* Preliminarily mark non-addressed complex variables as eligible
 for promotion to gimple registers.  We'll transform their uses
 as we find them.  */
 if ((TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
-	   || TREE_CODE (TREE_TYPE (parm)) == VECTOR_TYPE)
+|| TREE_CODE (TREE_TYPE (parm)) == VECTOR_TYPE)
 && !TREE_THIS_VOLATILE (parm)
 && !needs_to_live_in_memory (parm))
 DECL_GIMPLE_REG_P (parm) = 1;
 }
 gimple_seq_add_stmt (&seq, new_bind);
 gimple_set_body (fndecl, seq);
 }
 DECL_SAVED_TREE (fndecl) = NULL_TREE;
+cfun->curr_properties = PROP_gimple_any;
 current_function_decl = oldfn;
 pop_cfun ();
 }
 switch (gimple_code (stmt))
 {
 case GIMPLE_COND:
 gimplify_expr (gimple_cond_lhs_ptr (stmt), &pre, NULL,
-		     is_gimple_val, fb_rvalue);
+is_gimple_val, fb_rvalue);
 gimplify_expr (gimple_cond_rhs_ptr (stmt), &pre, NULL,
-		     is_gimple_val, fb_rvalue);
+is_gimple_val, fb_rvalue);
 break;
 case GIMPLE_SWITCH:
 gimplify_expr (gimple_switch_index_ptr (stmt), &pre, NULL,
-		     is_gimple_val, fb_rvalue);
+is_gimple_val, fb_rvalue);
 break;
 case GIMPLE_OMP_ATOMIC_LOAD:
 gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt), &pre, NULL,
-		     is_gimple_val, fb_rvalue);
+is_gimple_val, fb_rvalue);
 break;
 case GIMPLE_ASM:
 {
-	size_t i, noutputs = gimple_asm_noutputs (stmt);
+size_t i, noutputs = gimple_asm_noutputs (stmt);
-	const char *constraint, **oconstraints;
+const char *constraint, **oconstraints;
-	bool allows_mem, allows_reg, is_inout;
+bool allows_mem, allows_reg, is_inout;
-	oconstraints
+oconstraints
-	  = (const char **) alloca ((noutputs) * sizeof (const char *));
+= (const char **) alloca ((noutputs) * sizeof (const char *));
-	for (i = 0; i < noutputs; i++)
+for (i = 0; i < noutputs; i++)
-	  {
+{
-	    tree op = gimple_asm_output_op (stmt, i);
+tree op = gimple_asm_output_op (stmt, i);
-	    constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
+constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
-	    oconstraints[i] = constraint;
+oconstraints[i] = constraint;
-	    parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
+parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
-				     &allows_reg, &is_inout);
+&allows_reg, &is_inout);
-	    gimplify_expr (&TREE_VALUE (op), &pre, NULL,
+gimplify_expr (&TREE_VALUE (op), &pre, NULL,
-			   is_inout ? is_gimple_min_lval : is_gimple_lvalue,
+is_inout ? is_gimple_min_lval : is_gimple_lvalue,
-			   fb_lvalue | fb_mayfail);
+fb_lvalue | fb_mayfail);
-	  }
+}
-	for (i = 0; i < gimple_asm_ninputs (stmt); i++)
+for (i = 0; i < gimple_asm_ninputs (stmt); i++)
-	  {
+{
-	    tree op = gimple_asm_input_op (stmt, i);
+tree op = gimple_asm_input_op (stmt, i);
-	    constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
+constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
-	    parse_input_constraint (&constraint, 0, 0, noutputs, 0,
+parse_input_constraint (&constraint, 0, 0, noutputs, 0,
-				    oconstraints, &allows_mem, &allows_reg);
+oconstraints, &allows_mem, &allows_reg);
-	    if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op))) && allows_mem)
+if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op))) && allows_mem)
-	      allows_reg = 0;
+allows_reg = 0;
-	    if (!allows_reg && allows_mem)
+if (!allows_reg && allows_mem)
-	      gimplify_expr (&TREE_VALUE (op), &pre, NULL,
+gimplify_expr (&TREE_VALUE (op), &pre, NULL,
-			     is_gimple_lvalue, fb_lvalue | fb_mayfail);
+is_gimple_lvalue, fb_lvalue | fb_mayfail);
-	    else
+else
-	      gimplify_expr (&TREE_VALUE (op), &pre, NULL,
+gimplify_expr (&TREE_VALUE (op), &pre, NULL,
-			     is_gimple_asm_val, fb_rvalue);
+is_gimple_asm_val, fb_rvalue);
-	  }
+}
 }
 break;
 default:
 /* NOTE: We start gimplifying operands from last to first to
-	 make sure that side-effects on the RHS of calls, assignments
+make sure that side-effects on the RHS of calls, assignments
-	 and ASMs are executed before the LHS.  The ordering is not
+and ASMs are executed before the LHS.  The ordering is not
-	 important for other statements.  */
+important for other statements.  */
 num_ops = gimple_num_ops (stmt);
 orig_lhs = gimple_get_lhs (stmt);
 for (i = num_ops; i > 0; i--)
-	{
+{
-	  tree op = gimple_op (stmt, i - 1);
+tree op = gimple_op (stmt, i - 1);
-	  if (op == NULL_TREE)
+if (op == NULL_TREE)
-	    continue;
+continue;
-	  if (i == 1 && (is_gimple_call (stmt) || is_gimple_assign (stmt)))
+if (i == 1 && (is_gimple_call (stmt) || is_gimple_assign (stmt)))
-	    gimplify_expr (&op, &pre, NULL, is_gimple_lvalue, fb_lvalue);
+gimplify_expr (&op, &pre, NULL, is_gimple_lvalue, fb_lvalue);
-	  else if (i == 2
+else if (i == 2
-		   && is_gimple_assign (stmt)
+&& is_gimple_assign (stmt)
-		   && num_ops == 2
+&& num_ops == 2
-		   && get_gimple_rhs_class (gimple_expr_code (stmt))
+&& get_gimple_rhs_class (gimple_expr_code (stmt))
-		      == GIMPLE_SINGLE_RHS)
+== GIMPLE_SINGLE_RHS)
-	    gimplify_expr (&op, &pre, NULL,
+gimplify_expr (&op, &pre, NULL,
-			   rhs_predicate_for (gimple_assign_lhs (stmt)),
+rhs_predicate_for (gimple_assign_lhs (stmt)),
-			   fb_rvalue);
+fb_rvalue);
-	  else if (i == 2 && is_gimple_call (stmt))
+else if (i == 2 && is_gimple_call (stmt))
-	    {
+{
-	      if (TREE_CODE (op) == FUNCTION_DECL)
+if (TREE_CODE (op) == FUNCTION_DECL)
-		continue;
+continue;
-	      gimplify_expr (&op, &pre, NULL, is_gimple_call_addr, fb_rvalue);
+gimplify_expr (&op, &pre, NULL, is_gimple_call_addr, fb_rvalue);
-	    }
+}
-	  else
+else
-	    gimplify_expr (&op, &pre, NULL, is_gimple_val, fb_rvalue);
+gimplify_expr (&op, &pre, NULL, is_gimple_val, fb_rvalue);
-	  gimple_set_op (stmt, i - 1, op);
+gimple_set_op (stmt, i - 1, op);
-	}
+}
 lhs = gimple_get_lhs (stmt);
 /* If the LHS changed it in a way that requires a simple RHS,
-	 create temporary.  */
+create temporary.  */
-if (lhs && !is_gimple_formal_tmp_var (lhs))
+if (lhs && !is_gimple_reg (lhs))
-	{
+{
-	  bool need_temp = false;
+bool need_temp = false;
-	  if (is_gimple_assign (stmt)
+if (is_gimple_assign (stmt)
-	      && num_ops == 2
+&& num_ops == 2
-	      && get_gimple_rhs_class (gimple_expr_code (stmt))
+&& get_gimple_rhs_class (gimple_expr_code (stmt))
-		 == GIMPLE_SINGLE_RHS)
+== GIMPLE_SINGLE_RHS)
-	    gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
+gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
-			   rhs_predicate_for (gimple_assign_lhs (stmt)),
+rhs_predicate_for (gimple_assign_lhs (stmt)),
-			   fb_rvalue);
+fb_rvalue);
-	  else if (is_gimple_reg (lhs))
+else if (is_gimple_reg (lhs))
-	    {
+{
-	      if (is_gimple_reg_type (TREE_TYPE (lhs)))
+if (is_gimple_reg_type (TREE_TYPE (lhs)))
-		{
+{
-		  if (is_gimple_call (stmt))
+if (is_gimple_call (stmt))
-		    {
+{
-		      i = gimple_call_flags (stmt);
+i = gimple_call_flags (stmt);
-		      if ((i & ECF_LOOPING_CONST_OR_PURE)
+if ((i & ECF_LOOPING_CONST_OR_PURE)
-			  || !(i & (ECF_CONST | ECF_PURE)))
+|| !(i & (ECF_CONST | ECF_PURE)))
-			need_temp = true;
+need_temp = true;
-		    }
+}
-		  if (stmt_can_throw_internal (stmt))
+if (stmt_can_throw_internal (stmt))
-		    need_temp = true;
+need_temp = true;
-		}
+}
-	    }
+}
-	  else
+else
-	    {
+{
-	      if (is_gimple_reg_type (TREE_TYPE (lhs)))
+if (is_gimple_reg_type (TREE_TYPE (lhs)))
-		need_temp = true;
+need_temp = true;
-	      else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
+else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
-		{
+{
-		  if (is_gimple_call (stmt))
+if (is_gimple_call (stmt))
-		    {
+{
-		      tree fndecl = gimple_call_fndecl (stmt);
+tree fndecl = gimple_call_fndecl (stmt);
-		      if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
+if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
-			  && !(fndecl && DECL_RESULT (fndecl)
+&& !(fndecl && DECL_RESULT (fndecl)
-			       && DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
+&& DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
-			need_temp = true;
+need_temp = true;
-		    }
+}
-		  else
+else
-		    need_temp = true;
+need_temp = true;
-		}
+}
-	    }
+}
-	  if (need_temp)
+if (need_temp)
-	    {
+{
-	      tree temp = create_tmp_var (TREE_TYPE (lhs), NULL);
+tree temp = create_tmp_var (TREE_TYPE (lhs), NULL);
-	      DECL_GIMPLE_FORMAL_TEMP_P (temp) = 1;
+if (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE
-	      if (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE
+|| TREE_CODE (TREE_TYPE (lhs)) == VECTOR_TYPE)
-		  || TREE_CODE (TREE_TYPE (lhs)) == VECTOR_TYPE)
+DECL_GIMPLE_REG_P (temp) = 1;
-		DECL_GIMPLE_REG_P (temp) = 1;
+if (TREE_CODE (orig_lhs) == SSA_NAME)
-	      if (TREE_CODE (orig_lhs) == SSA_NAME)
+orig_lhs = SSA_NAME_VAR (orig_lhs);
-		orig_lhs = SSA_NAME_VAR (orig_lhs);
-	      if (TREE_CODE (orig_lhs) == VAR_DECL
+if (gimple_in_ssa_p (cfun))
-		  && DECL_BASED_ON_RESTRICT_P (orig_lhs))
+temp = make_ssa_name (temp, NULL);
-		{
+gimple_set_lhs (stmt, temp);
-		  DECL_BASED_ON_RESTRICT_P (temp) = 1;
+post_stmt = gimple_build_assign (lhs, temp);
-		  SET_DECL_RESTRICT_BASE (temp,
+if (TREE_CODE (lhs) == SSA_NAME)
-					  DECL_GET_RESTRICT_BASE (orig_lhs));
+SSA_NAME_DEF_STMT (lhs) = post_stmt;
-		}
+}
+}
-	      if (gimple_in_ssa_p (cfun))
-		temp = make_ssa_name (temp, NULL);
-	      gimple_set_lhs (stmt, temp);
-	      post_stmt = gimple_build_assign (lhs, temp);
-	      if (TREE_CODE (lhs) == SSA_NAME)
-		SSA_NAME_DEF_STMT (lhs) = post_stmt;
-	    }
-	}
 break;
 }
 if (gimple_referenced_vars (cfun))
 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t))
 add_referenced_var (t);
 if (!gimple_seq_empty_p (pre))
 {
 if (gimple_in_ssa_p (cfun))
-	{
+{
-	  gimple_stmt_iterator i;
+gimple_stmt_iterator i;
-	  for (i = gsi_start (pre); !gsi_end_p (i); gsi_next (&i))
+for (i = gsi_start (pre); !gsi_end_p (i); gsi_next (&i))
-	    mark_symbols_for_renaming (gsi_stmt (i));
+mark_symbols_for_renaming (gsi_stmt (i));
-	}
+}
 gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
 }
 if (post_stmt)
 gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);
 it.  M specifies the way GSI moves after insertion (GSI_SAME_STMT or
 GSI_CONTINUE_LINKING are the usual values).  */
 tree
 force_gimple_operand_gsi (gimple_stmt_iterator *gsi, tree expr,
-			  bool simple_p, tree var, bool before,
+bool simple_p, tree var, bool before,
-			  enum gsi_iterator_update m)
+enum gsi_iterator_update m)
 {
 gimple_seq stmts;
 expr = force_gimple_operand (expr, &stmts, simple_p, var);
 if (!gimple_seq_empty_p (stmts))
 {
 if (gimple_in_ssa_p (cfun))
-	{
+{
-	  gimple_stmt_iterator i;
+gimple_stmt_iterator i;
-	  for (i = gsi_start (stmts); !gsi_end_p (i); gsi_next (&i))
+for (i = gsi_start (stmts); !gsi_end_p (i); gsi_next (&i))
-	    mark_symbols_for_renaming (gsi_stmt (i));
+mark_symbols_for_renaming (gsi_stmt (i));
-	}
+}
 if (before)
-	gsi_insert_seq_before (gsi, stmts, m);
+gsi_insert_seq_before (gsi, stmts, m);
 else
-	gsi_insert_seq_after (gsi, stmts, m);
+gsi_insert_seq_after (gsi, stmts, m);
 }
 return expr;
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimplify.c @ 57:326d9e06c2e3