CbC/CbC_gcc: gcc/gimplify.c comparison

comparison gcc/gimplify.c @ 63:b7f97abdc517 gcc-4.6-20100522

update gcc from gcc-4.5.0 to gcc-4.6

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 24 May 2010 12:47:05 +0900
parents	77e2b8dfacca
children	f6334be47118

comparison

equal deleted inserted replaced

-:3c8a44c06a95
+:b7f97abdc517
 /* Tree lowering pass.  This pass converts the GENERIC functions-as-trees
 tree representation into the GIMPLE form.
-Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
 Free Software Foundation, Inc.
 Major work done by Sebastian Pop <s.pop@laposte.net>,
 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
 This file is part of GCC.
 #include "system.h"
 #include "coretypes.h"
 #include "tm.h"
 #include "tree.h"
 #include "rtl.h"
-#include "varray.h"
 #include "gimple.h"
 #include "tree-iterator.h"
 #include "tree-inline.h"
 #include "diagnostic.h"
+#include "tree-pretty-print.h"
 #include "langhooks.h"
 #include "langhooks-def.h"
 #include "tree-flow.h"
 #include "cgraph.h"
 #include "timevar.h"
 #include "except.h"
 #include "hashtab.h"
 #include "flags.h"
-#include "real.h"
 #include "function.h"
 #include "output.h"
 #include "expr.h"
 #include "ggc.h"
 #include "toplev.h"
 enum omp_region_type
 {
 ORT_WORKSHARE = 0,
-ORT_TASK = 1,
 ORT_PARALLEL = 2,
-ORT_COMBINED_PARALLEL = 3
+ORT_COMBINED_PARALLEL = 3,
+ORT_TASK = 4,
+ORT_UNTIED_TASK = 5
 };
 struct gimplify_omp_ctx
 {
 struct gimplify_omp_ctx *outer_context;
 *SEQ_P is NULL, a new sequence is allocated.  This function is
 similar to gimple_seq_add_stmt, but does not scan the operands.
 During gimplification, we need to manipulate statement sequences
 before the def/use vectors have been constructed.  */
-static void
+void
 gimplify_seq_add_stmt (gimple_seq *seq_p, gimple gs)
 {
 gimple_stmt_iterator si;
 if (gs == NULL)
 c->outer_context = gimplify_omp_ctxp;
 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
 c->privatized_types = pointer_set_create ();
 c->location = input_location;
 c->region_type = region_type;
-if (region_type != ORT_TASK)
+if ((region_type & ORT_TASK) == 0)
 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
 else
 c->default_kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
 return c;
 XDELETE (c);
 }
 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
-/* A subroutine of append_to_statement_list{,_force}.  T is not NULL.  */
-static void
-append_to_statement_list_1 (tree t, tree *list_p)
-{
-tree list = *list_p;
-tree_stmt_iterator i;
-if (!list)
-{
-if (t && TREE_CODE (t) == STATEMENT_LIST)
-	{
-	  *list_p = t;
-	  return;
-	}
-*list_p = list = alloc_stmt_list ();
-}
-i = tsi_last (list);
-tsi_link_after (&i, t, TSI_CONTINUE_LINKING);
-}
-/* Add T to the end of the list container pointed to by LIST_P.
-If T is an expression with no effects, it is ignored.  */
-void
-append_to_statement_list (tree t, tree *list_p)
-{
-if (t && TREE_SIDE_EFFECTS (t))
-append_to_statement_list_1 (t, list_p);
-}
-/* Similar, but the statement is always added, regardless of side effects.  */
-void
-append_to_statement_list_force (tree t, tree *list_p)
-{
-if (t != NULL_TREE)
-append_to_statement_list_1 (t, list_p);
-}
 /* Both gimplify the statement T and append it to *SEQ_P.  This function
 behaves exactly as gimplify_stmt, but you don't have to pass T as a
 reference.  */
 gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
 tmp_var = create_tmp_var_raw (type, prefix);
 gimple_add_tmp_var (tmp_var);
 return tmp_var;
+}
+/* Create a new temporary variable declaration of type TYPE by calling
+create_tmp_var and if TYPE is a vector or a complex number, mark the new
+temporary as gimple register.  */
+tree
+create_tmp_reg (tree type, const char *prefix)
+{
+tree tmp;
+tmp = create_tmp_var (type, prefix);
+if (TREE_CODE (type) == COMPLEX_TYPE
+|| TREE_CODE (type) == VECTOR_TYPE)
+DECL_GIMPLE_REG_P (tmp) = 1;
+return tmp;
 }
 /* Create a temporary with a name derived from VAL.  Subroutine of
 lookup_tmp_var; nobody else should call this function.  */
 {
 gimple gs = gsi_stmt (i);
 annotate_one_with_location (gs, location);
 }
 }
+/* This page contains routines to unshare tree nodes, i.e. to duplicate tree
-/* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes.
+nodes that are referenced more than once in GENERIC functions.  This is
+necessary because gimplification (translation into GIMPLE) is performed
+by modifying tree nodes in-place, so gimplication of a shared node in a
+first context could generate an invalid GIMPLE form in a second context.
+This is achieved with a simple mark/copy/unmark algorithm that walks the
+GENERIC representation top-down, marks nodes with TREE_VISITED the first
+time it encounters them, duplicates them if they already have TREE_VISITED
+set, and finally removes the TREE_VISITED marks it has set.
+The algorithm works only at the function level, i.e. it generates a GENERIC
+representation of a function with no nodes shared within the function when
+passed a GENERIC function (except for nodes that are allowed to be shared).
+At the global level, it is also necessary to unshare tree nodes that are
+referenced in more than one function, for the same aforementioned reason.
+This requires some cooperation from the front-end.  There are 2 strategies:
+1. Manual unsharing.  The front-end needs to call unshare_expr on every
+expression that might end up being shared across functions.
+2. Deep unsharing.  This is an extension of regular unsharing.  Instead
+of calling unshare_expr on expressions that might be shared across
+functions, the front-end pre-marks them with TREE_VISITED.  This will
+ensure that they are unshared on the first reference within functions
+when the regular unsharing algorithm runs.  The counterpart is that
+this algorithm must look deeper than for manual unsharing, which is
+specified by LANG_HOOKS_DEEP_UNSHARING.
+If there are only few specific cases of node sharing across functions, it is
+probably easier for a front-end to unshare the expressions manually.  On the
+contrary, if the expressions generated at the global level are as widespread
+as expressions generated within functions, deep unsharing is very likely the
+way to go.  */
+/* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
 These nodes model computations that should only be done once.  If we
 were to unshare something like SAVE_EXPR(i++), the gimplification
 process would create wrong code.  */
 static tree
 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
 {
-enum tree_code code = TREE_CODE (*tp);
+tree t = *tp;
-/* Don't unshare types, decls, constants and SAVE_EXPR nodes.  */
+enum tree_code code = TREE_CODE (t);
-if (TREE_CODE_CLASS (code) == tcc_type
-|| TREE_CODE_CLASS (code) == tcc_declaration
+/* Do not copy SAVE_EXPR or TARGET_EXPR nodes themselves, but copy
-|| TREE_CODE_CLASS (code) == tcc_constant
+their subtrees if we can make sure to do it only once.  */
-|| code == SAVE_EXPR || code == TARGET_EXPR
+if (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
+if (data && !pointer_set_insert ((struct pointer_set_t *)data, t))
-	 uses.  So just avert our eyes and cross our fingers.  Silly Java.  */
+	;
-|| code == BLOCK)
+else
+	*walk_subtrees = 0;
+}
+/* Stop at types, decls, constants like copy_tree_r.  */
+else if (TREE_CODE_CLASS (code) == tcc_type
+	   || TREE_CODE_CLASS (code) == tcc_declaration
+	   || TREE_CODE_CLASS (code) == tcc_constant
+	   /* 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 uses.  So we avert our eyes
+	      and cross our fingers.  Silly Java.  */
+	   || code == BLOCK)
 *walk_subtrees = 0;
+/* Cope with the statement expression extension.  */
+else if (code == STATEMENT_LIST)
+;
+/* Leave the bulk of the work to copy_tree_r itself.  */
 else
 {
 gcc_assert (code != BIND_EXPR);
-copy_tree_r (tp, walk_subtrees, data);
+copy_tree_r (tp, walk_subtrees, NULL);
 }
 return NULL_TREE;
 }
 /* Callback for walk_tree to unshare most of the shared trees rooted at
 *TP.  If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1),
-then *TP is deep copied by calling copy_tree_r.
+then *TP is deep copied by calling mostly_copy_tree_r.  */
-This unshares the same trees as copy_tree_r with the exception of
-SAVE_EXPR nodes.  These nodes model computations that should only be
-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,
+copy_if_shared_r (tree *tp, int *walk_subtrees, void *data)
-		  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 this node has been visited already, unshare it and don't look
 any deeper.  */
 else if (TREE_VISITED (t))
 {
-walk_tree (tp, mostly_copy_tree_r, NULL, NULL);
+walk_tree (tp, mostly_copy_tree_r, data, NULL);
 *walk_subtrees = 0;
 }
-/* Otherwise, mark the tree as visited and keep looking.  */
+/* Otherwise, mark the node as visited and keep looking.  */
 else
 TREE_VISITED (t) = 1;
 return NULL_TREE;
 }
-static tree
+/* Unshare most of the shared trees rooted at *TP. */
-unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
-		  void *data ATTRIBUTE_UNUSED)
+static inline void
-{
+copy_if_shared (tree *tp)
-if (TREE_VISITED (*tp))
+{
-TREE_VISITED (*tp) = 0;
+/* If the language requires deep unsharing, we need a pointer set to make
-else
+sure we don't repeatedly unshare subtrees of unshareable nodes.  */
-*walk_subtrees = 0;
+struct pointer_set_t *visited
+= lang_hooks.deep_unsharing ? pointer_set_create () : NULL;
-return NULL_TREE;
+walk_tree (tp, copy_if_shared_r, visited, NULL);
+if (visited)
+pointer_set_destroy (visited);
 }
 /* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the
 bodies of any nested functions if we are unsharing the entire body of
 FNDECL.  */
 static void
 unshare_body (tree *body_p, tree fndecl)
 {
 struct cgraph_node *cgn = cgraph_node (fndecl);
-walk_tree (body_p, copy_if_shared_r, NULL, NULL);
+copy_if_shared (body_p);
 if (body_p == &DECL_SAVED_TREE (fndecl))
 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
 unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
 }
+/* Callback for walk_tree to unmark the visited trees rooted at *TP.
+Subtrees are walked until the first unvisited node is encountered.  */
+static tree
+unmark_visited_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
+{
+tree t = *tp;
+/* If this node has been visited, unmark it and keep looking.  */
+if (TREE_VISITED (t))
+TREE_VISITED (t) = 0;
+/* Otherwise, don't look any deeper.  */
+else
+*walk_subtrees = 0;
+return NULL_TREE;
+}
+/* Unmark the visited trees rooted at *TP.  */
+static inline void
+unmark_visited (tree *tp)
+{
+walk_tree (tp, unmark_visited_r, NULL, NULL);
+}
 /* Likewise, but mark all trees as not visited.  */
 static void
 unvisit_body (tree *body_p, tree fndecl)
 {
 struct cgraph_node *cgn = cgraph_node (fndecl);
-walk_tree (body_p, unmark_visited_r, NULL, NULL);
+unmark_visited (body_p);
 if (body_p == &DECL_SAVED_TREE (fndecl))
 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
 unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
 }
 we don't want to extend the lifetime of the RESULT_DECL, particularly
 across another call.  In addition, for those aggregates for which
 hard_function_value generates a PARALLEL, we'll die during normal
 expansion of structure assignments; there's special code in expand_return
 to handle this case that does not exist in expand_expr.  */
-if (!result_decl
+if (!result_decl)
-|| aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
+result = NULL_TREE;
-result = result_decl;
+else if (aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
+{
+if (TREE_CODE (DECL_SIZE (result_decl)) != INTEGER_CST)
+	{
+	  if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl)))
+	    gimplify_type_sizes (TREE_TYPE (result_decl), pre_p);
+	  /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
+	     should be effectively allocated by the caller, i.e. all calls to
+	     this function must be subject to the Return Slot Optimization.  */
+	  gimplify_one_sizepos (&DECL_SIZE (result_decl), pre_p);
+	  gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl), pre_p);
+	}
+result = result_decl;
+}
 else if (gimplify_ctxp->return_temp)
 result = gimplify_ctxp->return_temp;
 else
 {
-result = create_tmp_var (TREE_TYPE (result_decl), NULL);
+result = create_tmp_reg (TREE_TYPE (result_decl), NULL);
-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
 	 to how this variable is constructed and initialized, this is never
 	 true.  Give up and never warn.  */
 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
 			fallback_t fallback)
 {
 tree *p;
 VEC(tree,heap) *stack;
-enum gimplify_status ret = GS_OK, tret;
+enum gimplify_status ret = GS_ALL_DONE, tret;
 int i;
 location_t loc = EXPR_LOCATION (*expr_p);
+tree expr = *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);
 /* If the outermost expression is a COMPONENT_REF, canonicalize its type.  */
 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
 {
 canonicalize_component_ref (expr_p);
-ret = MIN (ret, GS_OK);
 }
 VEC_free (tree, heap, stack);
+gcc_assert (*expr_p == expr || ret != GS_ALL_DONE);
 return ret;
 }
 /*  Gimplify the self modifying expression pointed to by EXPR_P
 gimple_boolify (tree expr)
 {
 tree type = TREE_TYPE (expr);
 location_t loc = EXPR_LOCATION (expr);
+if (TREE_CODE (expr) == NE_EXPR
+&& TREE_CODE (TREE_OPERAND (expr, 0)) == CALL_EXPR
+&& integer_zerop (TREE_OPERAND (expr, 1)))
+{
+tree call = TREE_OPERAND (expr, 0);
+tree fn = get_callee_fndecl (call);
+/* For __builtin_expect ((long) (x), y) recurse into x as well
+	 if x is truth_value_p.  */
+if (fn
+	  && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
+	  && DECL_FUNCTION_CODE (fn) == BUILT_IN_EXPECT
+	  && call_expr_nargs (call) == 2)
+	{
+	  tree arg = CALL_EXPR_ARG (call, 0);
+	  if (arg)
+	    {
+	      if (TREE_CODE (arg) == NOP_EXPR
+		  && TREE_TYPE (arg) == TREE_TYPE (call))
+		arg = TREE_OPERAND (arg, 0);
+	      if (truth_value_p (TREE_CODE (arg)))
+		{
+		  arg = gimple_boolify (arg);
+		  CALL_EXPR_ARG (call, 0)
+		    = fold_convert_loc (loc, TREE_TYPE (call), arg);
+		}
+	    }
+	}
+}
 if (TREE_CODE (type) == BOOLEAN_TYPE)
 return expr;
 switch (TREE_CODE (expr))
 {
 static enum gimplify_status
 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
 {
 tree expr = *expr_p;
-tree tmp, type, arm1, arm2;
+tree type = TREE_TYPE (expr);
+location_t loc = EXPR_LOCATION (expr);
+tree tmp, arm1, arm2;
 enum gimplify_status ret;
 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))
+if (!VOID_TYPE_P (type))
 {
+tree then_ = TREE_OPERAND (expr, 1), else_ = TREE_OPERAND (expr, 2);
 tree result;
-/* If an rvalue is ok or we do not require an lvalue, avoid creating
+/* If either an rvalue is ok or we do not require an lvalue, create the
-	 an addressable temporary.  */
+	 temporary.  But we cannot do that if the type is addressable.  */
-if (((fallback & fb_rvalue)
+if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
-	   || !(fallback & fb_lvalue))
 	  && !TREE_ADDRESSABLE (type))
 	{
 	  if (gimplify_ctxp->allow_rhs_cond_expr
 	      /* If either branch has side effects or could trap, it can't be
 		 evaluated unconditionally.  */
-	      && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1))
+	      && !TREE_SIDE_EFFECTS (then_)
-	      && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 1))
+	      && !generic_expr_could_trap_p (then_)
-	      && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 2))
+	      && !TREE_SIDE_EFFECTS (else_)
-	      && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 2)))
+	      && !generic_expr_could_trap_p (else_))
 	    return gimplify_pure_cond_expr (expr_p, pre_p);
-	  result = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
+	  tmp = create_tmp_var (type, "iftmp");
-	  ret = GS_ALL_DONE;
+	  result = tmp;
 	}
+/* Otherwise, only create and copy references to the values.  */
 else
 	{
-	  tree type = build_pointer_type (TREE_TYPE (expr));
+	  type = build_pointer_type (type);
-	  if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
+	  if (!VOID_TYPE_P (TREE_TYPE (then_)))
-	    TREE_OPERAND (expr, 1) =
+	    then_ = build_fold_addr_expr_loc (loc, then_);
-	      build_fold_addr_expr_loc (loc, TREE_OPERAND (expr, 1));
+	  if (!VOID_TYPE_P (TREE_TYPE (else_)))
-	  if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
+	    else_ = build_fold_addr_expr_loc (loc, else_);
-	    TREE_OPERAND (expr, 2) =
-	      build_fold_addr_expr_loc (loc, TREE_OPERAND (expr, 2));
+	  expr
+	    = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
 	  tmp = create_tmp_var (type, "iftmp");
-	  expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
-			 TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
 	  result = build_fold_indirect_ref_loc (loc, tmp);
 	}
-/* Build the then clause, 't1 = a;'.  But don't build an assignment
+/* Build the new then clause, `tmp = then_;'.  But don't build the
-	 if this branch is void; in C++ it can be, if it's a throw.  */
+	 assignment if the value is void; in C++ it can be if it's a throw.  */
-if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
+if (!VOID_TYPE_P (TREE_TYPE (then_)))
-	TREE_OPERAND (expr, 1)
+	TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
-	  = build2 (MODIFY_EXPR, TREE_TYPE (tmp), tmp, TREE_OPERAND (expr, 1));
+/* Similarly, build the new else clause, `tmp = else_;'.  */
-/* Build the else clause, 't1 = b;'.  */
+if (!VOID_TYPE_P (TREE_TYPE (else_)))
-if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
+	TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
-	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.  */
 	    if (size > 0
 		&& num_nonzero_elements > 1
 		&& !can_move_by_pieces (size, align))
 	      {
-		tree new_tree;
 		if (notify_temp_creation)
 		  return GS_ERROR;
-		new_tree = create_tmp_var_raw (type, "C");
+		walk_tree (&ctor, force_labels_r, NULL, NULL);
+		ctor = tree_output_constant_def (ctor);
-		gimple_add_tmp_var (new_tree);
+		if (!useless_type_conversion_p (type, TREE_TYPE (ctor)))
-		TREE_STATIC (new_tree) = 1;
+		  ctor = build1 (VIEW_CONVERT_EXPR, type, ctor);
-		TREE_READONLY (new_tree) = 1;
+		TREE_OPERAND (*expr_p, 1) = ctor;
-		DECL_INITIAL (new_tree) = ctor;
-		if (align > DECL_ALIGN (new_tree))
-		  {
-		    DECL_ALIGN (new_tree) = align;
-		    DECL_USER_ALIGN (new_tree) = 1;
-		  }
-	        walk_tree (&DECL_INITIAL (new_tree), force_labels_r, NULL, NULL);
-		TREE_OPERAND (*expr_p, 1) = new_tree;
 		/* This is no longer an assignment of a CONSTRUCTOR, but
 		   we still may have processing to do on the LHS.  So
 		   pretend we didn't do anything here to let that happen.  */
 		return GS_UNHANDLED;
 	      }
 	  }
+	/* If the target is volatile and we have non-zero elements
+	   initialize the target from a temporary.  */
+	if (TREE_THIS_VOLATILE (object)
+	    && !TREE_ADDRESSABLE (type)
+	    && num_nonzero_elements > 0)
+	  {
+	    tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type), NULL);
+	    TREE_OPERAND (*expr_p, 0) = temp;
+	    *expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
+			      *expr_p,
+			      build2 (MODIFY_EXPR, void_type_node,
+				      object, temp));
+	    return GS_OK;
+	  }
 	if (notify_temp_creation)
 	  return GS_OK;
-	/* If there are nonzero elements, pre-evaluate to capture elements
+	/* If there are nonzero elements and if needed, pre-evaluate to capture
-	   overlapping with the lhs into temporaries.  We must do this before
+	   elements overlapping with the lhs into temporaries.  We must do this
-	   clearing to fetch the values before they are zeroed-out.  */
+	   before clearing to fetch the values before they are zeroed-out.  */
-	if (num_nonzero_elements > 0)
+	if (num_nonzero_elements > 0 && TREE_CODE (*expr_p) != INIT_EXPR)
 	  {
 	    preeval_data.lhs_base_decl = get_base_address (object);
 	    if (!DECL_P (preeval_data.lhs_base_decl))
 	      preeval_data.lhs_base_decl = NULL;
 	    preeval_data.lhs_alias_set = get_alias_set (object);
 {
 tree type = TREE_TYPE (TREE_TYPE (t));
 tree sub = t;
 tree subtype;
-STRIP_USELESS_TYPE_CONVERSION (sub);
+STRIP_NOPS (sub);
 subtype = TREE_TYPE (sub);
 if (!POINTER_TYPE_P (subtype))
 return NULL_TREE;
 if (TREE_CODE (sub) == ADDR_EXPR)
 if (useless_type_conversion_p (type, optype))
 return op;
 /* *(foo *)&fooarray => fooarray[0] */
 if (TREE_CODE (optype) == ARRAY_TYPE
+	  && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype))) == INTEGER_CST
 	  && 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);
-return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
+	 if (TREE_CODE (min_val) == INTEGER_CST)
+	   return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
 }
+/* *(foo *)&complexfoo => __real__ complexfoo */
+else if (TREE_CODE (optype) == COMPLEX_TYPE
+&& useless_type_conversion_p (type, TREE_TYPE (optype)))
+return fold_build1 (REALPART_EXPR, type, op);
+/* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
+else if (TREE_CODE (optype) == VECTOR_TYPE
+&& useless_type_conversion_p (type, TREE_TYPE (optype)))
+{
+tree part_width = TYPE_SIZE (type);
+tree index = bitsize_int (0);
+return fold_build3 (BIT_FIELD_REF, type, op, part_width, index);
+}
+}
+/* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
+if (TREE_CODE (sub) == POINTER_PLUS_EXPR
+&& TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
+{
+tree op00 = TREE_OPERAND (sub, 0);
+tree op01 = TREE_OPERAND (sub, 1);
+tree op00type;
+STRIP_NOPS (op00);
+op00type = TREE_TYPE (op00);
+if (TREE_CODE (op00) == ADDR_EXPR
+	  && TREE_CODE (TREE_TYPE (op00type)) == VECTOR_TYPE
+	  && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (op00type))))
+	{
+	  HOST_WIDE_INT offset = tree_low_cst (op01, 0);
+	  tree part_width = TYPE_SIZE (type);
+	  unsigned HOST_WIDE_INT part_widthi
+	    = tree_low_cst (part_width, 0) / BITS_PER_UNIT;
+	  unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
+	  tree index = bitsize_int (indexi);
+	  if (offset / part_widthi
+	      <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (op00type)))
+	    return fold_build3 (BIT_FIELD_REF, type, TREE_OPERAND (op00, 0),
+				part_width, index);
+	}
+}
+/* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
+if (TREE_CODE (sub) == POINTER_PLUS_EXPR
+&& TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
+{
+tree op00 = TREE_OPERAND (sub, 0);
+tree op01 = TREE_OPERAND (sub, 1);
+tree op00type;
+STRIP_NOPS (op00);
+op00type = TREE_TYPE (op00);
+if (TREE_CODE (op00) == ADDR_EXPR
+	  && TREE_CODE (TREE_TYPE (op00type)) == COMPLEX_TYPE
+	  && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (op00type))))
+	{
+	  tree size = TYPE_SIZE_UNIT (type);
+	  if (tree_int_cst_equal (size, op01))
+	    return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (op00, 0));
+	}
 }
 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
+&& TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype)))) == INTEGER_CST
 && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (subtype))))
 {
 tree type_domain;
 tree min_val = size_zero_node;
 tree osub = sub;
 if (! sub)
 	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);
+if (TREE_CODE (min_val) == INTEGER_CST)
+	return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
 }
 return NULL_TREE;
 }
 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,
 			  bool want_value)
 {
-enum gimplify_status ret = GS_OK;
+enum gimplify_status ret = GS_UNHANDLED;
+bool changed;
-while (ret != GS_UNHANDLED)
-switch (TREE_CODE (*from_p))
+do
 {
-case VAR_DECL:
+changed = false;
-	/* If we're assigning from a read-only variable initialized with
+switch (TREE_CODE (*from_p))
-	   a constructor, do the direct assignment from the constructor,
+	{
-	   but only if neither source nor target are volatile since this
+	case VAR_DECL:
-	   latter assignment might end up being done on a per-field basis.  */
+	  /* If we're assigning from a read-only variable initialized with
-	if (DECL_INITIAL (*from_p)
+	     a constructor, do the direct assignment from the constructor,
-	    && TREE_READONLY (*from_p)
+	     but only if neither source nor target are volatile since this
-	    && !TREE_THIS_VOLATILE (*from_p)
+	     latter assignment might end up being done on a per-field basis.  */
-	    && !TREE_THIS_VOLATILE (*to_p)
+	  if (DECL_INITIAL (*from_p)
-	    && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
+	      && TREE_READONLY (*from_p)
+	      && !TREE_THIS_VOLATILE (*from_p)
+	      && !TREE_THIS_VOLATILE (*to_p)
+	      && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
+	    {
+	      tree old_from = *from_p;
+	      enum gimplify_status subret;
+	      /* Move the constructor into the RHS.  */
+	      *from_p = unshare_expr (DECL_INITIAL (*from_p));
+	      /* Let's see if gimplify_init_constructor will need to put
+		 it in memory.  */
+	      subret = gimplify_init_constructor (expr_p, NULL, NULL,
+						  false, true);
+	      if (subret == GS_ERROR)
+		{
+		  /* If so, revert the change.  */
+		  *from_p = old_from;
+		}
+	      else
+		{
+		  ret = GS_OK;
+		  changed = true;
+		}
+	    }
+	  break;
+	case INDIRECT_REF:
 	  {
-	    tree old_from = *from_p;
+	    /* If we have code like
-	    /* Move the constructor into the RHS.  */
+	     *(const A*)(A*)&x
-	    *from_p = unshare_expr (DECL_INITIAL (*from_p));
-	    /* Let's see if gimplify_init_constructor will need to put
-	       it in memory.  If so, revert the change.  */
-	    ret = gimplify_init_constructor (expr_p, NULL, NULL, false, true);
-	    if (ret == GS_ERROR)
-	      {
-		*from_p = old_from;
-		/* Fall through.  */
-	      }
-	    else
-	      {
-		ret = GS_OK;
-		break;
-	      }
-	  }
-	ret = GS_UNHANDLED;
-	break;
-case INDIRECT_REF:
-	{
-	  /* If we have code like
-	        *(const A*)(A*)&x
 	     where the type of "x" is a (possibly cv-qualified variant
 	     of "A"), treat the entire expression as identical to "x".
 	     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 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;
+		ret = GS_OK;
+		changed = true;
+	      }
+	    break;
+	  }
+	case TARGET_EXPR:
+	  {
+	    /* If we are initializing something from a TARGET_EXPR, strip the
+	       TARGET_EXPR and initialize it directly, if possible.  This can't
+	       be done if the initializer is void, since that implies that the
+	       temporary is set in some non-trivial way.
+	       ??? What about code that pulls out the temp and uses it
+	       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
+	       have any RTL.  In that case, I guess we'll need to replace
+	       references somehow.  */
+	    tree init = TARGET_EXPR_INITIAL (*from_p);
+	    if (init
+		&& !VOID_TYPE_P (TREE_TYPE (init)))
+	      {
+		*from_p = init;
+		ret = GS_OK;
+		changed = true;
+	      }
+	  }
+	  break;
+	case COMPOUND_EXPR:
+	  /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
+	     caught.  */
+	  gimplify_compound_expr (from_p, pre_p, true);
+	  ret = GS_OK;
+	  changed = true;
+	  break;
+	case CONSTRUCTOR:
+	  /* If we're initializing from a CONSTRUCTOR, break this into
+	     individual MODIFY_EXPRs.  */
+	  return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
+					    false);
+	case COND_EXPR:
+	  /* If we're assigning to a non-register type, push the assignment
+	     down into the branches.  This is mandatory for ADDRESSABLE types,
+	     since we cannot generate temporaries for such, but it saves a
+	     copy in other cases as well.  */
+	  if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
 	    {
-	      *from_p = t;
+	      /* This code should mirror the code in gimplify_cond_expr. */
-	      ret = GS_OK;
+	      enum tree_code code = TREE_CODE (*expr_p);
+	      tree cond = *from_p;
+	      tree result = *to_p;
+	      ret = gimplify_expr (&result, pre_p, post_p,
+				   is_gimple_lvalue, fb_lvalue);
+	      if (ret != GS_ERROR)
+		ret = GS_OK;
+	      if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
+		TREE_OPERAND (cond, 1)
+		  = build2 (code, void_type_node, result,
+			    TREE_OPERAND (cond, 1));
+	      if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
+		TREE_OPERAND (cond, 2)
+		  = build2 (code, void_type_node, unshare_expr (result),
+			    TREE_OPERAND (cond, 2));
+	      TREE_TYPE (cond) = void_type_node;
+	      recalculate_side_effects (cond);
+	      if (want_value)
+		{
+		  gimplify_and_add (cond, pre_p);
+		  *expr_p = unshare_expr (result);
+		}
+	      else
+		*expr_p = cond;
+	      return ret;
 	    }
-	  else
-	    ret = GS_UNHANDLED;
 	  break;
-	}
+	case CALL_EXPR:
-case TARGET_EXPR:
+	  /* For calls that return in memory, give *to_p as the CALL_EXPR's
-	{
+	     return slot so that we don't generate a temporary.  */
-	  /* If we are initializing something from a TARGET_EXPR, strip the
+	  if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
-	     TARGET_EXPR and initialize it directly, if possible.  This can't
+	      && aggregate_value_p (*from_p, *from_p))
-	     be done if the initializer is void, since that implies that the
-	     temporary is set in some non-trivial way.
-	     ??? What about code that pulls out the temp and uses it
-	     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
-	     have any RTL.  In that case, I guess we'll need to replace
-	     references somehow.  */
-	  tree init = TARGET_EXPR_INITIAL (*from_p);
-	  if (init
-	      && !VOID_TYPE_P (TREE_TYPE (init)))
 	    {
-	      *from_p = init;
+	      bool use_target;
-	      ret = GS_OK;
+	      if (!(rhs_predicate_for (*to_p))(*from_p))
+		/* If we need a temporary, *to_p isn't accurate.  */
+		use_target = false;
+	      else if (TREE_CODE (*to_p) == RESULT_DECL
+		       && DECL_NAME (*to_p) == NULL_TREE
+		       && needs_to_live_in_memory (*to_p))
+		/* It's OK to use the return slot directly unless it's an NRV. */
+		use_target = true;
+	      else if (is_gimple_reg_type (TREE_TYPE (*to_p))
+		       || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
+		/* Don't force regs into memory.  */
+		use_target = false;
+	      else if (TREE_CODE (*expr_p) == INIT_EXPR)
+		/* It's OK to use the target directly if it's being
+		   initialized. */
+		use_target = true;
+	      else if (!is_gimple_non_addressable (*to_p))
+		/* Don't use the original target if it's already addressable;
+		   if its address escapes, and the called function uses the
+		   NRV optimization, a conforming program could see *to_p
+		   change before the called function returns; see c++/19317.
+		   When optimizing, the return_slot pass marks more functions
+		   as safe after we have escape info.  */
+		use_target = false;
+	      else
+		use_target = true;
+	      if (use_target)
+		{
+		  CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
+		  mark_addressable (*to_p);
+		}
 	    }
-	  else
+	  break;
-	    ret = GS_UNHANDLED;
-	}
+	case WITH_SIZE_EXPR:
-	break;
+	  /* Likewise for calls that return an aggregate of non-constant size,
+	     since we would not be able to generate a temporary at all.  */
-case COMPOUND_EXPR:
+	  if (TREE_CODE (TREE_OPERAND (*from_p, 0)) == CALL_EXPR)
-	/* Remove any COMPOUND_EXPR in the RHS so the following cases will be
+	    {
-	   caught.  */
+	      *from_p = TREE_OPERAND (*from_p, 0);
-	gimplify_compound_expr (from_p, pre_p, true);
+	      /* We don't change ret in this case because the
-	ret = GS_OK;
+		 WITH_SIZE_EXPR might have been added in
-	break;
+		 gimplify_modify_expr, so returning GS_OK would lead to an
+		 infinite loop.  */
-case CONSTRUCTOR:
+	      changed = true;
-	/* If we're initializing from a CONSTRUCTOR, break this into
+	    }
-	   individual MODIFY_EXPRs.  */
+	  break;
-	return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
-					  false);
+	  /* If we're initializing from a container, push the initialization
+	     inside it.  */
-case COND_EXPR:
+	case CLEANUP_POINT_EXPR:
-	/* If we're assigning to a non-register type, push the assignment
+	case BIND_EXPR:
-	   down into the branches.  This is mandatory for ADDRESSABLE types,
+	case STATEMENT_LIST:
-	   since we cannot generate temporaries for such, but it saves a
-	   copy in other cases as well.  */
-	if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
 	  {
-	    /* This code should mirror the code in gimplify_cond_expr. */
+	    tree wrap = *from_p;
-	    enum tree_code code = TREE_CODE (*expr_p);
+	    tree t;
-	    tree cond = *from_p;
-	    tree result = *to_p;
+	    ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
+				 fb_lvalue);
-	    ret = gimplify_expr (&result, pre_p, post_p,
-				 is_gimple_lvalue, fb_lvalue);
 	    if (ret != GS_ERROR)
 	      ret = GS_OK;
-	    if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
+	    t = voidify_wrapper_expr (wrap, *expr_p);
-	      TREE_OPERAND (cond, 1)
+	    gcc_assert (t == *expr_p);
-		= build2 (code, void_type_node, result,
-			  TREE_OPERAND (cond, 1));
-	    if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
-	      TREE_OPERAND (cond, 2)
-		= build2 (code, void_type_node, unshare_expr (result),
-			  TREE_OPERAND (cond, 2));
-	    TREE_TYPE (cond) = void_type_node;
-	    recalculate_side_effects (cond);
 	    if (want_value)
 	      {
-		gimplify_and_add (cond, pre_p);
+		gimplify_and_add (wrap, pre_p);
-		*expr_p = unshare_expr (result);
+		*expr_p = unshare_expr (*to_p);
 	      }
 	    else
-	      *expr_p = cond;
+	      *expr_p = wrap;
-	    return ret;
+	    return GS_OK;
 	  }
-	else
-	  ret = GS_UNHANDLED;
+	case COMPOUND_LITERAL_EXPR:
-	break;
-case CALL_EXPR:
-	/* For calls that return in memory, give *to_p as the CALL_EXPR's
-	   return slot so that we don't generate a temporary.  */
-	if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
-	    && aggregate_value_p (*from_p, *from_p))
 	  {
-	    bool use_target;
+	    tree complit = TREE_OPERAND (*expr_p, 1);
+	    tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (complit);
-	    if (!(rhs_predicate_for (*to_p))(*from_p))
+	    tree decl = DECL_EXPR_DECL (decl_s);
-	      /* If we need a temporary, *to_p isn't accurate.  */
+	    tree init = DECL_INITIAL (decl);
-	      use_target = false;
-	    else if (TREE_CODE (*to_p) == RESULT_DECL
+	    /* struct T x = (struct T) { 0, 1, 2 } can be optimized
-		     && DECL_NAME (*to_p) == NULL_TREE
+	       into struct T x = { 0, 1, 2 } if the address of the
-		     && needs_to_live_in_memory (*to_p))
+	       compound literal has never been taken.  */
-	      /* It's OK to use the return slot directly unless it's an NRV. */
+	    if (!TREE_ADDRESSABLE (complit)
-	      use_target = true;
+		&& !TREE_ADDRESSABLE (decl)
-	    else if (is_gimple_reg_type (TREE_TYPE (*to_p))
+		&& init)
-		     || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
-	      /* Don't force regs into memory.  */
-	      use_target = false;
-	    else if (TREE_CODE (*expr_p) == INIT_EXPR)
-	      /* It's OK to use the target directly if it's being
-		 initialized. */
-	      use_target = true;
-	    else if (!is_gimple_non_addressable (*to_p))
-	      /* Don't use the original target if it's already addressable;
-		 if its address escapes, and the called function uses the
-		 NRV optimization, a conforming program could see *to_p
-		 change before the called function returns; see c++/19317.
-		 When optimizing, the return_slot pass marks more functions
-		 as safe after we have escape info.  */
-	      use_target = false;
-	    else
-	      use_target = true;
-	    if (use_target)
 	      {
-		CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
+		*expr_p = copy_node (*expr_p);
-		mark_addressable (*to_p);
+		TREE_OPERAND (*expr_p, 1) = init;
+		return GS_OK;
 	      }
 	  }
-	ret = GS_UNHANDLED;
+	default:
-	break;
+	  break;
+	}
-	/* If we're initializing from a container, push the initialization
+}
-	   inside it.  */
+while (changed);
-case CLEANUP_POINT_EXPR:
-case BIND_EXPR:
-case STATEMENT_LIST:
-	{
-	  tree wrap = *from_p;
-	  tree t;
-	  ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
-			       fb_lvalue);
-	  if (ret != GS_ERROR)
-	    ret = GS_OK;
-	  t = voidify_wrapper_expr (wrap, *expr_p);
-	  gcc_assert (t == *expr_p);
-	  if (want_value)
-	    {
-	      gimplify_and_add (wrap, pre_p);
-	      *expr_p = unshare_expr (*to_p);
-	    }
-	  else
-	    *expr_p = wrap;
-	  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;
-	break;
-}
 return ret;
 }
 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.  */
 assign = gimple_build_call_from_tree (*from_p);
-gimple_call_set_lhs (assign, *to_p);
+if (!gimple_call_noreturn_p (assign))
+	gimple_call_set_lhs (assign, *to_p);
 }
 else
 {
 assign = gimple_build_assign (*to_p, *from_p);
 gimple_set_location (assign, EXPR_LOCATION (*expr_p));
 }
 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
 }
+/* Notice a threadprivate variable DECL used in OpenMP context CTX.
+This just prints out diagnostics about threadprivate variable uses
+in untied tasks.  If DECL2 is non-NULL, prevent this warning
+on that variable.  */
+static bool
+omp_notice_threadprivate_variable (struct gimplify_omp_ctx *ctx, tree decl,
+				   tree decl2)
+{
+splay_tree_node n;
+if (ctx->region_type != ORT_UNTIED_TASK)
+return false;
+n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
+if (n == NULL)
+{
+error ("threadprivate variable %qE used in untied task", DECL_NAME (decl));
+error_at (ctx->location, "enclosing task");
+splay_tree_insert (ctx->variables, (splay_tree_key)decl, 0);
+}
+if (decl2)
+splay_tree_insert (ctx->variables, (splay_tree_key)decl2, 0);
+return false;
+}
 /* Record the fact that DECL was used within the OpenMP context CTX.
 IN_CODE is true when real code uses DECL, and false when we should
 merely emit default(none) errors.  Return true if DECL is going to
 be remapped and thus DECL shouldn't be gimplified into its
 DECL_VALUE_EXPR (if any).  */
 /* Threadprivate variables are predetermined.  */
 if (is_global_var (decl))
 {
 if (DECL_THREAD_LOCAL_P (decl))
-	return false;
+	return omp_notice_threadprivate_variable (ctx, decl, NULL_TREE);
 if (DECL_HAS_VALUE_EXPR_P (decl))
 	{
 	  tree value = get_base_address (DECL_VALUE_EXPR (decl));
 	  if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
-	    return false;
+	    return omp_notice_threadprivate_variable (ctx, decl, value);
 	}
 }
 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
 if (n == NULL)
 switch (default_kind)
 	{
 	case OMP_CLAUSE_DEFAULT_NONE:
 	  error ("%qE not specified in enclosing parallel",
 		 DECL_NAME (decl));
-	  error_at (ctx->location, "enclosing parallel");
+	  if ((ctx->region_type & ORT_TASK) != 0)
+	    error_at (ctx->location, "enclosing task");
+	  else
+	    error_at (ctx->location, "enclosing parallel");
 	  /* FALLTHRU */
 	case OMP_CLAUSE_DEFAULT_SHARED:
 	  flags |= GOVD_SHARED;
 	  break;
 	case OMP_CLAUSE_DEFAULT_PRIVATE:
 	case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
 	  flags |= GOVD_FIRSTPRIVATE;
 	  break;
 	case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
 	  /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED.  */
-	  gcc_assert (ctx->region_type == ORT_TASK);
+	  gcc_assert ((ctx->region_type & ORT_TASK) != 0);
 	  if (ctx->outer_context)
 	    omp_notice_variable (ctx->outer_context, decl, in_code);
 	  for (octx = ctx->outer_context; octx; octx = octx->outer_context)
 	    {
 	      splay_tree_node n2;
 tree expr = *expr_p;
 gimple g;
 gimple_seq body = NULL;
 struct gimplify_ctx gctx;
-gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr), pre_p, ORT_TASK);
+gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr), pre_p,
+			     find_omp_clause (OMP_TASK_CLAUSES (expr),
+					      OMP_CLAUSE_UNTIED)
+			     ? ORT_UNTIED_TASK : ORT_TASK);
 push_gimplify_context (&gctx);
 g = gimplify_and_return_first (OMP_TASK_BODY (expr), &body);
 if (gimple_code (g) == GIMPLE_BIND)
 tree addr = TREE_OPERAND (*expr_p, 0);
 tree rhs = TREE_OPERAND (*expr_p, 1);
 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
 tree tmp_load;
-tmp_load = create_tmp_var (type, NULL);
+tmp_load = create_tmp_reg (type, NULL);
-if (TREE_CODE (type) == COMPLEX_TYPE || TREE_CODE (type) == VECTOR_TYPE)
-DECL_GIMPLE_REG_P (tmp_load) = 1;
 if (goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0)
 return GS_ERROR;
 if (gimplify_expr (&addr, pre_p, NULL, is_gimple_val, fb_rvalue)
 != GS_ALL_DONE)
 	    continue;
 	}
 else if (ret != GS_UNHANDLED)
 	break;
-ret = GS_OK;
+/* Make sure that all the cases set 'ret' appropriately.  */
+ret = GS_UNHANDLED;
 switch (TREE_CODE (*expr_p))
 	{
 	  /* First deal with the special cases.  */
 	case POSTINCREMENT_EXPR:
 	     required.  */
 	  if (fallback == fb_lvalue)
 	    {
 	      *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
 	      mark_addressable (*expr_p);
+	      ret = GS_OK;
 	    }
 	  break;
 	case CALL_EXPR:
 	  ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
 	     required.  */
 	  if (fallback == fb_lvalue)
 	    {
 	      *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
 	      mark_addressable (*expr_p);
+	      ret = GS_OK;
 	    }
 	  break;
 	case TREE_LIST:
 	  gcc_unreachable ();
 	      || fallback == fb_none)
 	    {
 	      /* Just strip a conversion to void (or in void context) and
 		 try again.  */
 	      *expr_p = TREE_OPERAND (*expr_p, 0);
+	      ret = GS_OK;
 	      break;
 	    }
 	  ret = gimplify_conversion (expr_p);
 	  if (ret == GS_ERROR)
 	  break;
 	case INDIRECT_REF:
 	  *expr_p = fold_indirect_ref_loc (input_location, *expr_p);
 	  if (*expr_p != save_expr)
-	    break;
+	    {
+	      ret = GS_OK;
+	      break;
+	    }
 	  /* else fall through.  */
 	case ALIGN_INDIRECT_REF:
 	case MISALIGNED_INDIRECT_REF:
 	  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
 			       is_gimple_reg, fb_rvalue);
 	     value.  */
 	  /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either.  */
 	  if (fallback & fb_lvalue)
 	    ret = GS_ALL_DONE;
 	  else
-	    *expr_p = DECL_INITIAL (*expr_p);
+	    {
+	      *expr_p = DECL_INITIAL (*expr_p);
+	      ret = GS_OK;
+	    }
 	  break;
 	case DECL_EXPR:
 	  ret = gimplify_decl_expr (expr_p, pre_p);
 	  break;
 	      if (ret == GS_ERROR)
 		break;
 	    }
 	  gimplify_seq_add_stmt (pre_p,
 			  gimple_build_goto (GOTO_DESTINATION (*expr_p)));
+	  ret = GS_ALL_DONE;
 	  break;
 	case PREDICT_EXPR:
 	  gimplify_seq_add_stmt (pre_p,
 			gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p),
 		   ix++)
 		if (TREE_SIDE_EFFECTS (ce->value))
 		  append_to_statement_list (ce->value, &temp);
 	      *expr_p = temp;
-	      ret = GS_OK;
+	      ret = temp ? GS_OK : GS_ALL_DONE;
 	    }
 	  /* C99 code may assign to an array in a constructed
 	     structure or union, and this has undefined behavior only
 	     on execution, so create a temporary if an lvalue is
 	     required.  */
 	  else if (fallback == fb_lvalue)
 	    {
 	      *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
 	      mark_addressable (*expr_p);
+	      ret = GS_OK;
 	    }
 	  else
 	    ret = GS_ALL_DONE;
 	  break;
 	    gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
 			   post_p == &internal_post ? NULL : post_p,
 			   gimple_test_f, fallback);
 	    gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
 			   is_gimple_val, fb_rvalue);
+	    ret = GS_ALL_DONE;
 	  }
 	  break;
 	case VAR_DECL:
 	case PARM_DECL:
 		  (EXPR_LOCATION (*expr_p),
 		   TREE_OPERAND (*expr_p, 0), TREE_OPERAND (*expr_p, 1),
 		   TREE_TYPE (*expr_p))))
 	    {
 	      *expr_p = tmp;
+	      ret = GS_OK;
 	      break;
 	    }
 	  /* Convert (void *)&a + 4 into (void *)&a[1].  */
 	  if (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == NOP_EXPR
 	      && TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
 		   TREE_OPERAND (*expr_p, 1),
 		   TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),
 					    0)))))
 	     {
 *expr_p = fold_convert (TREE_TYPE (*expr_p), tmp);
+	       ret = GS_OK;
 	       break;
 	     }
 /* FALLTHRU */
 	default:
 	dont_recalculate:
 	  break;
 	}
-/* If we replaced *expr_p, gimplify again.  */
+gcc_assert (*expr_p || ret != GS_OK);
-if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr))
-	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.  */
 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.  */
+/* Ensure VLA bounds aren't removed, for -O0 they should be variables
-if (!optimize
+	 with assigned stack slots, for -O1+ -g they should be tracked
-	  && TYPE_DOMAIN (type)
+	 by VTA.  */
+if (TYPE_DOMAIN (type)
 	  && INTEGRAL_TYPE_P (TYPE_DOMAIN (type)))
 	{
 	  t = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
 	  if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
 	    DECL_IGNORED_P (t) = 0;
 outer_bind = gimple_build_bind (NULL_TREE, seq, NULL);
 *body_p = NULL_TREE;
 /* If we had callee-copies statements, insert them at the beginning
-of the function.  */
+of the function and clear DECL_VALUE_EXPR_P on the parameters.  */
 if (!gimple_seq_empty_p (parm_stmts))
 {
+tree parm;
 gimplify_seq_add_seq (&parm_stmts, gimple_bind_body (outer_bind));
 gimple_bind_set_body (outer_bind, parm_stmts);
+for (parm = DECL_ARGUMENTS (current_function_decl);
+	   parm; parm = TREE_CHAIN (parm))
+	if (DECL_HAS_VALUE_EXPR_P (parm))
+	  {
+	    DECL_HAS_VALUE_EXPR_P (parm) = 0;
+	    DECL_IGNORED_P (parm) = 0;
+	  }
 }
 if (nonlocal_vlas)
 {
 pointer_set_destroy (nonlocal_vlas);
 		    need_temp = true;
 		}
 	    }
 	  if (need_temp)
 	    {
-	      tree temp = create_tmp_var (TREE_TYPE (lhs), NULL);
+	      tree temp = create_tmp_reg (TREE_TYPE (lhs), NULL);
-	      if (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE
-		  || TREE_CODE (TREE_TYPE (lhs)) == VECTOR_TYPE)
-		DECL_GIMPLE_REG_P (temp) = 1;
 	      if (TREE_CODE (orig_lhs) == SSA_NAME)
 		orig_lhs = SSA_NAME_VAR (orig_lhs);
 	      if (gimple_in_ssa_p (cfun))
 		temp = make_ssa_name (temp, NULL);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimplify.c @ 63:b7f97abdc517 gcc-4.6-20100522