CbC/CbC_gcc: gcc/gimplify.c comparison

comparison gcc/gimplify.c @ 69:1b10fe6932e1

merge 69

author	Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Sun, 21 Aug 2011 07:53:12 +0900
parents	326d9e06c2e3 f6334be47118
children	b81903832de2

comparison

equal deleted inserted replaced

-:b362627d71ba
+:1b10fe6932e1
 /* 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, 2011
 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 "config.h"
 #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"
+#include "diagnostic-core.h"
 #include "target.h"
-#include "optabs.h"
 #include "pointer-set.h"
 #include "splay-tree.h"
 #include "vec.h"
 #include "gimple.h"
 #ifndef noCbC
 #include "cbc-tree.h"
 #endif
 #include "tree-pass.h"
+#include "langhooks-def.h"	/* FIXME: for lhd_set_decl_assembler_name.  */
+#include "expr.h"		/* FIXME: for can_move_by_pieces
+				   and STACK_CHECK_MAX_VAR_SIZE.  */
 enum gimplify_omp_var_data
 {
 GOVD_SEEN = 1,
 GOVD_EXPLICIT = 2,
 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;
 void
 mark_addressable (tree x)
 {
 while (handled_component_p (x))
 x = TREE_OPERAND (x, 0);
+if (TREE_CODE (x) == MEM_REF
+&& TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
+x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
 if (TREE_CODE (x) != VAR_DECL
 && TREE_CODE (x) != PARM_DECL
 && TREE_CODE (x) != RESULT_DECL)
-return ;
+return;
 TREE_ADDRESSABLE (x) = 1;
 }
 /* Return a hash value for a formal temporary table entry.  */
 return 0;
 if (!operand_equal_p (t1, t2, 0))
 return 0;
+#ifdef ENABLE_CHECKING
 /* Only allow them to compare equal if they also hash equal; otherwise
 results are nondeterminate, and we fail bootstrap comparison.  */
 gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2));
+#endif
 return 1;
 }
 /* Link gimple statement GS to the end of the sequence *SEQ_P.  If
 *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.  */
 return ret;
 }
 /* Return true if T is a CALL_EXPR or an expression that can be
-assignmed to a temporary.  Note that this predicate should only be
+assigned 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_reg_rhs_or_call (tree t)
 || 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_LOC_OR_HERE (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);
 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);
+	  DECL_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
 associated BLOCK for debugging purposes.  The key point here
 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
 }
 void
 gimple_add_tmp_var (tree tmp)
 {
-gcc_assert (!TREE_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
+gcc_assert (!DECL_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
 /* Later processing assumes that the object size is constant, which might
 not be true at this point.  Force the use of a constant upper bound in
 this case.  */
 if (!host_integerp (DECL_SIZE_UNIT (tmp), 1))
 DECL_CONTEXT (tmp) = current_function_decl;
 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
 if (gimplify_ctxp)
 {
-TREE_CHAIN (tmp) = gimplify_ctxp->temps;
+DECL_CHAIN (tmp) = gimplify_ctxp->temps;
 gimplify_ctxp->temps = tmp;
 /* Mark temporaries local within the nearest enclosing parallel.  */
 if (gimplify_omp_ctxp)
 {
 {
 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, TARGET_EXPR or BIND_EXPR nodes themselves, but
-|| TREE_CODE_CLASS (code) == tcc_constant
+copy 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 || code == BIND_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
-{
+copy_tree_r (tp, walk_subtrees, NULL);
-gcc_assert (code != BIND_EXPR);
-copy_tree_r (tp, walk_subtrees, data);
-}
 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);
 }
 gimple_seq body;
 tree temp = voidify_wrapper_expr (bind_expr, NULL);
 /* Mark variables seen in this bind expr.  */
-for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t))
+for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
 {
 if (TREE_CODE (t) == VAR_DECL)
 {
 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
 if (DECL_HARD_REGISTER (t) && !is_global_var (t) && cfun)
 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.  */
-We exclude complex types if not optimizing because they can be
+if ((TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
-subject to partial stores in GNU C by means of the __real__ and
+	   || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
-__imag__ operators and we cannot promote them to total stores
+	  && !TREE_THIS_VOLATILE (t)
-(see gimplify_modify_expr_complex_part).  */
+	  && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
-if (optimize
+	  && !needs_to_live_in_memory (t))
-&& (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
+	DECL_GIMPLE_REG_P (t) = 1;
-|| 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);
 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.  */
 SET_DECL_VALUE_EXPR (decl, t);
 DECL_HAS_VALUE_EXPR_P (decl) = 1;
 t = built_in_decls[BUILT_IN_ALLOCA];
 t = build_call_expr (t, 1, DECL_SIZE_UNIT (decl));
+/* The call has been built for a variable-sized object.  */
+ALLOCA_FOR_VAR_P (t) = 1;
 t = fold_convert (ptr_type, t);
 t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
 gimplify_and_add (t, seq_p);
 && flag_stack_check == GENERIC_STACK_CHECK
 && compare_tree_int (DECL_SIZE_UNIT (decl),
 STACK_CHECK_MAX_VAR_SIZE) > 0))
 gimplify_vla_decl (decl, seq_p);
+/* Some front ends do not explicitly declare all anonymous
+	 artificial variables.  We compensate here by declaring the
+	 variables, though it would be better if the front ends would
+	 explicitly declare them.  */
+if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
+	  && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
+	gimple_add_tmp_var (decl);
 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
-variables, though it would be better if the front ends would
-explicitly declare them.  */
-if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
-&& DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
-gimple_add_tmp_var (decl);
 }
 return GS_ALL_DONE;
 }
 /* Sort the case labels in LABEL_VEC in place in ascending order.  */
 void
 sort_case_labels (VEC(tree,heap)* label_vec)
 {
-size_t len = VEC_length (tree, label_vec);
+VEC_qsort (tree, label_vec, compare_case_labels);
-qsort (VEC_address (tree, label_vec), len, sizeof (tree),
-compare_case_labels);
 }
 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
 branch to.  */
 if (TREE_CODE (decl) == VAR_DECL
 && !DECL_SEEN_IN_BIND_EXPR_P (decl)
 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
 && decl_function_context (decl) == current_function_decl)
 {
-gcc_assert (errorcount || sorrycount);
+gcc_assert (seen_error ());
 return GS_ERROR;
 }
 /* When within an OpenMP context, notice uses of variables.  */
 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
 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
+	  && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
-&& nonlocal_vlas != NULL
+	  && nonlocal_vlas != NULL
-&& TREE_CODE (value_expr) == INDIRECT_REF
+	  && TREE_CODE (value_expr) == INDIRECT_REF
-&& TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
+	  && TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
-&& decl_function_context (decl) != current_function_decl)
+	  && decl_function_context (decl) != current_function_decl)
-{
+	{
-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 && !pointer_set_insert (nonlocal_vlas, decl))
+	  if (!ctx && !pointer_set_insert (nonlocal_vlas, decl))
-{
+	    {
-tree copy = copy_node (decl), block;
+	      tree copy = copy_node (decl), block;
-lang_hooks.dup_lang_specific_decl (copy);
+	      lang_hooks.dup_lang_specific_decl (copy);
-SET_DECL_RTL (copy, NULL_RTX);
+	      SET_DECL_RTL (copy, 0);
-TREE_USED (copy) = 1;
+	      TREE_USED (copy) = 1;
-block = DECL_INITIAL (current_function_decl);
+	      block = DECL_INITIAL (current_function_decl);
-TREE_CHAIN (copy) = BLOCK_VARS (block);
+	      DECL_CHAIN (copy) = BLOCK_VARS (block);
-BLOCK_VARS (block) = copy;
+	      BLOCK_VARS (block) = copy;
-SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
+	      SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
-DECL_HAS_VALUE_EXPR_P (copy) = 1;
+	      DECL_HAS_VALUE_EXPR_P (copy) = 1;
-}
+	    }
-}
+	}
 *expr_p = unshare_expr (value_expr);
 return GS_OK;
 }
 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
 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.  */
+gimple_stmt_iterator gsi;
 call = gimple_build_call_from_tree (*expr_p);
 gimplify_seq_add_stmt (pre_p, call);
+gsi = gsi_last (*pre_p);
+fold_stmt (&gsi);
 *expr_p = NULL_TREE;
 }
 return ret;
 }
 /* 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)
-{
+	{
-/* Keep the original source location on the first 'if'.  */
+	  /* Keep the original source location on the first 'if'.  */
-location_t locus = EXPR_HAS_LOCATION (expr)
+	  location_t locus = EXPR_LOC_OR_HERE (expr);
-? EXPR_LOCATION (expr) : input_location;
+	  TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
-TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
+	  /* Set the source location of the && on the second 'if'.  */
-/* Set the source location of the && on the second 'if'.  */
+	  if (EXPR_HAS_LOCATION (pred))
-if (EXPR_HAS_LOCATION (pred))
+	    SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
-SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
+	  then_ = shortcut_cond_expr (expr);
-then_ = shortcut_cond_expr (expr);
+	  then_se = then_ && TREE_SIDE_EFFECTS (then_);
-then_se = then_ && TREE_SIDE_EFFECTS (then_);
+	  pred = TREE_OPERAND (pred, 0);
-pred = TREE_OPERAND (pred, 0);
+	  expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
-expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
+	  SET_EXPR_LOCATION (expr, locus);
-SET_EXPR_LOCATION (expr, locus);
+	}
-}
 }
 if (!then_se)
 {
 /* If there is no 'then', turn
 if (a || b); else d
 into
 if (a); else if (b); else d.  */
 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
-{
+	{
-/* Keep the original source location on the first 'if'.  */
+	  /* Keep the original source location on the first 'if'.  */
-location_t locus = EXPR_HAS_LOCATION (expr)
+	  location_t locus = EXPR_LOC_OR_HERE (expr);
-? EXPR_LOCATION (expr) : input_location;
+	  TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
-TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
+	  /* Set the source location of the || on the second 'if'.  */
-/* Set the source location of the || on the second 'if'.  */
+	  if (EXPR_HAS_LOCATION (pred))
-if (EXPR_HAS_LOCATION (pred))
+	    SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
-SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
+	  else_ = shortcut_cond_expr (expr);
-else_ = shortcut_cond_expr (expr);
+	  else_se = else_ && TREE_SIDE_EFFECTS (else_);
-else_se = else_ && TREE_SIDE_EFFECTS (else_);
+	  pred = TREE_OPERAND (pred, 0);
-pred = TREE_OPERAND (pred, 0);
+	  expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
-expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
+	  SET_EXPR_LOCATION (expr, locus);
-SET_EXPR_LOCATION (expr, locus);
+	}
-}
 }
 /* If we're done, great.  */
 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
 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,
-EXPR_HAS_LOCATION (expr)
+			    EXPR_LOC_OR_HERE (expr));
-? EXPR_LOCATION (expr) : input_location);
 /* If our last subexpression already has a terminal label, reuse it.  */
 if (else_se)
 t = expr_last (else_);
 else if (then_se)
 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,
-EXPR_HAS_LOCATION (expr)
+			  EXPR_LOC_OR_HERE (expr));
-? EXPR_LOCATION (expr) : input_location);
 expr = NULL;
 append_to_statement_list (pred, &expr);
 append_to_statement_list (then_, &expr);
 tree
 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))
-&& !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 (then_)
-&& !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1))
+	      && !generic_expr_could_trap_p (then_)
-&& !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 1))
+	      && !TREE_SIDE_EFFECTS (else_)
-&& !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 2))
+	      && !generic_expr_could_trap_p (else_))
-&& !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);
+	  tmp = create_tmp_var (type, "iftmp");
-result = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
+	  result = tmp;
-ret = GS_ALL_DONE;
+	}
-}
+/* 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");
+	  tmp = create_tmp_var (type, "iftmp");
-expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
+	  result = build_simple_mem_ref_loc (loc, tmp);
-TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
+	}
-result = build_fold_indirect_ref_loc (loc, tmp);
+/* Build the new then clause, `tmp = then_;'.  But don't build the
-}
+	 assignment if the value is void; in C++ it can be if it's a throw.  */
+if (!VOID_TYPE_P (TREE_TYPE (then_)))
-/* Build the then clause, 't1 = a;'.  But don't build an assignment
+	TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
-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)
+/* Similarly, build the new else clause, `tmp = else_;'.  */
-TREE_OPERAND (expr, 1)
+if (!VOID_TYPE_P (TREE_TYPE (else_)))
-= build2 (MODIFY_EXPR, TREE_TYPE (tmp), tmp, TREE_OPERAND (expr, 1));
+	TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
-/* Build the else clause, 't1 = b;'.  */
-if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
-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.  */
 /* tmp = memcpy() */
 t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
 gimple_call_set_lhs (gs, t);
 gimplify_seq_add_stmt (seq_p, gs);
-*expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
+*expr_p = build_simple_mem_ref (t);
 return GS_ALL_DONE;
 }
 gimplify_seq_add_stmt (seq_p, gs);
 *expr_p = NULL;
 return t;
 /* If the constructor component is indirect, determine if we have a
 potential overlap with the lhs.  The only bits of information we
 have to go on at this point are addressability and alias sets.  */
-if (TREE_CODE (t) == INDIRECT_REF
+if ((INDIRECT_REF_P (t)
+|| TREE_CODE (t) == MEM_REF)
 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
 return t;
 /* If the constructor component is a call, determine if it can hide a
-potential overlap with the lhs through an INDIRECT_REF like above.  */
+potential overlap with the lhs through an INDIRECT_REF like above.
+??? Ugh - this is completely broken.  In fact this whole analysis
+doesn't look conservative.  */
 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))
 {
 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++)
+FOR_EACH_VEC_ELT (constructor_elt, v, ix, ce)
-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.  */
 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;
+		if (notify_temp_creation)
+		  return GS_ERROR;
-if (notify_temp_creation)
-return GS_ERROR;
+		walk_tree (&ctor, force_labels_r, NULL, NULL);
+		ctor = tree_output_constant_def (ctor);
-new_tree = create_tmp_var_raw (type, "C");
+		if (!useless_type_conversion_p (type, TREE_TYPE (ctor)))
+		  ctor = build1 (VIEW_CONVERT_EXPR, type, ctor);
-gimple_add_tmp_var (new_tree);
+		TREE_OPERAND (*expr_p, 1) = ctor;
-TREE_STATIC (new_tree) = 1;
-TREE_READONLY (new_tree) = 1;
+		/* This is no longer an assignment of a CONSTRUCTOR, but
-DECL_INITIAL (new_tree) = ctor;
+		   we still may have processing to do on the LHS.  So
-if (align > DECL_ALIGN (new_tree))
+		   pretend we didn't do anything here to let that happen.  */
-{
+		return GS_UNHANDLED;
-DECL_ALIGN (new_tree) = align;
+	      }
-DECL_USER_ALIGN (new_tree) = 1;
+	  }
-}
-walk_tree (&DECL_INITIAL (new_tree), force_labels_r, NULL, NULL);
+	/* If the target is volatile, we have non-zero elements and more than
+	   one field to assign, initialize the target from a temporary.  */
-TREE_OPERAND (*expr_p, 1) = new_tree;
+	if (TREE_THIS_VOLATILE (object)
+	    && !TREE_ADDRESSABLE (type)
-/* This is no longer an assignment of a CONSTRUCTOR, but
+	    && num_nonzero_elements > 0
-we still may have processing to do on the LHS.  So
+	    && VEC_length (constructor_elt, elts) > 1)
-pretend we didn't do anything here to let that happen.  */
+	  {
-return GS_UNHANDLED;
+	    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,
-if (notify_temp_creation)
+			      build2 (MODIFY_EXPR, void_type_node,
-return GS_OK;
+				      object, temp));
+	    return GS_OK;
-/* If there are nonzero elements, pre-evaluate to capture elements
+	  }
-overlapping with the lhs into temporaries.  We must do this before
-clearing to fetch the values before they are zeroed-out.  */
+	if (notify_temp_creation)
-if (num_nonzero_elements > 0)
+	  return GS_OK;
-{
-preeval_data.lhs_base_decl = get_base_address (object);
+	/* If there are nonzero elements and if needed, pre-evaluate to capture
-if (!DECL_P (preeval_data.lhs_base_decl))
+	   elements overlapping with the lhs into temporaries.  We must do this
-preeval_data.lhs_base_decl = NULL;
+	   before clearing to fetch the values before they are zeroed-out.  */
-preeval_data.lhs_alias_set = get_alias_set (object);
+	if (num_nonzero_elements > 0 && TREE_CODE (*expr_p) != INIT_EXPR)
+	  {
-gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
+	    preeval_data.lhs_base_decl = get_base_address (object);
-pre_p, post_p, &preeval_data);
+	    if (!DECL_P (preeval_data.lhs_base_decl))
-}
+	      preeval_data.lhs_base_decl = NULL;
+	    preeval_data.lhs_alias_set = get_alias_set (object);
-if (cleared)
-{
+	    gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
-/* Zap the CONSTRUCTOR element list, which simplifies this case.
+					pre_p, post_p, &preeval_data);
-Note that we still have to gimplify, in order to handle the
+	  }
-case of variable sized types.  Avoid shared tree structures.  */
-CONSTRUCTOR_ELTS (ctor) = NULL;
+	if (cleared)
-TREE_SIDE_EFFECTS (ctor) = 0;
+	  {
-object = unshare_expr (object);
+	    /* Zap the CONSTRUCTOR element list, which simplifies this case.
-gimplify_stmt (expr_p, pre_p);
+	       Note that we still have to gimplify, in order to handle the
-}
+	       case of variable sized types.  Avoid shared tree structures.  */
+	    CONSTRUCTOR_ELTS (ctor) = NULL;
-/* If we have not block cleared the object, or if there are nonzero
+	    TREE_SIDE_EFFECTS (ctor) = 0;
-elements in the constructor, add assignments to the individual
+	    object = unshare_expr (object);
-scalar fields of the object.  */
+	    gimplify_stmt (expr_p, pre_p);
-if (!cleared || num_nonzero_elements > 0)
+	  }
-gimplify_init_ctor_eval (object, elts, pre_p, cleared);
+	/* If we have not block cleared the object, or if there are nonzero
-*expr_p = NULL_TREE;
+	   elements in the constructor, add assignments to the individual
+	   scalar fields of the object.  */
+	if (!cleared || num_nonzero_elements > 0)
+	  gimplify_init_ctor_eval (object, elts, pre_p, cleared);
+	*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 = build_zero_cst (TREE_TYPE (type));
-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_EACH_VEC_ELT (constructor_elt, elts, ix, ce)
-{
+	  {
-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?  */
 from the langhooks point of view. */
 tree
 gimple_fold_indirect_ref (tree t)
 {
-tree type = TREE_TYPE (TREE_TYPE (t));
+tree ptype = TREE_TYPE (t), type = TREE_TYPE (ptype);
 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
-&& useless_type_conversion_p (type, TREE_TYPE (optype)))
+	  && 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);
+}
+}
+/* *(p + CST) -> ...  */
+if (TREE_CODE (sub) == POINTER_PLUS_EXPR
+&& TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
+{
+tree addr = TREE_OPERAND (sub, 0);
+tree off = TREE_OPERAND (sub, 1);
+tree addrtype;
+STRIP_NOPS (addr);
+addrtype = TREE_TYPE (addr);
+/* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
+if (TREE_CODE (addr) == ADDR_EXPR
+	  && TREE_CODE (TREE_TYPE (addrtype)) == VECTOR_TYPE
+	  && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (addrtype))))
+	{
+HOST_WIDE_INT offset = tree_low_cst (off, 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 (addrtype)))
+return fold_build3 (BIT_FIELD_REF, type, TREE_OPERAND (addr, 0),
+part_width, index);
+	}
+/* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
+if (TREE_CODE (addr) == ADDR_EXPR
+	  && TREE_CODE (TREE_TYPE (addrtype)) == COMPLEX_TYPE
+	  && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (addrtype))))
+{
+tree size = TYPE_SIZE_UNIT (type);
+if (tree_int_cst_equal (size, off))
+return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (addr, 0));
+}
+/* *(p + CST) -> MEM_REF <p, CST>.  */
+if (TREE_CODE (addr) != ADDR_EXPR
+	  || DECL_P (TREE_OPERAND (addr, 0)))
+	return fold_build2 (MEM_REF, type,
+			    addr,
+			    build_int_cst_wide (ptype,
+						TREE_INT_CST_LOW (off),
+						TREE_INT_CST_HIGH (off)));
 }
 /* *(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 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;
+	      enum gimplify_status subret;
-/* Let's see if gimplify_init_constructor will need to put
-it in memory.  If so, revert the change.  */
+	      /* Move the constructor into the RHS.  */
-ret = gimplify_init_constructor (expr_p, NULL, NULL, false, true);
+	      *from_p = unshare_expr (DECL_INITIAL (*from_p));
-if (ret == GS_ERROR)
-{
+	      /* Let's see if gimplify_init_constructor will need to put
-*from_p = old_from;
+		 it in memory.  */
-/* Fall through.  */
+	      subret = gimplify_init_constructor (expr_p, NULL, NULL,
-}
+						  false, true);
-else
+	      if (subret == GS_ERROR)
-{
+		{
-ret = GS_OK;
+		  /* If so, revert the change.  */
-break;
+		  *from_p = old_from;
-}
+		}
-}
+	      else
-ret = GS_UNHANDLED;
+		{
-break;
+		  ret = GS_OK;
-case INDIRECT_REF:
+		  changed = true;
-{
+		}
-/* If we have code like
+	    }
+	  break;
-*(const A*)(A*)&x
+	case INDIRECT_REF:
+	  {
-where the type of "x" is a (possibly cv-qualified variant
+	    /* If we have code like
-of "A"), treat the entire expression as identical to "x".
-This kind of code arises in C++ when an object is bound
+	     *(const A*)(A*)&x
-to a const reference, and if "x" is a TARGET_EXPR we want
-to take advantage of the optimization below.  */
+	     where the type of "x" is a (possibly cv-qualified variant
-tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
+	     of "A"), treat the entire expression as identical to "x".
-if (t)
+	     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
-*from_p = t;
+	     to take advantage of the optimization below.  */
-ret = GS_OK;
+	    bool volatile_p = TREE_THIS_VOLATILE (*from_p);
-}
+	    tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
-else
+	    if (t)
-ret = GS_UNHANDLED;
+	      {
-break;
+		if (TREE_THIS_VOLATILE (t) != volatile_p)
-}
+		  {
+		    if (TREE_CODE_CLASS (TREE_CODE (t)) == tcc_declaration)
-case TARGET_EXPR:
+		      t = build_simple_mem_ref_loc (EXPR_LOCATION (*from_p),
-{
+						    build_fold_addr_expr (t));
-/* If we are initializing something from a TARGET_EXPR, strip the
+		    if (REFERENCE_CLASS_P (t))
-TARGET_EXPR and initialize it directly, if possible.  This can't
+		      TREE_THIS_VOLATILE (t) = volatile_p;
-be done if the initializer is void, since that implies that the
+		  }
-temporary is set in some non-trivial way.
+		*from_p = t;
+		ret = GS_OK;
-??? What about code that pulls out the temp and uses it
+		changed = true;
-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
+	    break;
-have any RTL.  In that case, I guess we'll need to replace
+	  }
-references somehow.  */
-tree init = TARGET_EXPR_INITIAL (*from_p);
+	case TARGET_EXPR:
+	  {
-if (init
+	    /* If we are initializing something from a TARGET_EXPR, strip the
-&& !VOID_TYPE_P (TREE_TYPE (init)))
+	       TARGET_EXPR and initialize it directly, if possible.  This can't
-{
+	       be done if the initializer is void, since that implies that the
-*from_p = init;
+	       temporary is set in some non-trivial way.
-ret = GS_OK;
-}
+	       ??? What about code that pulls out the temp and uses it
-else
+	       elsewhere? I think that such code never uses the TARGET_EXPR as
-ret = GS_UNHANDLED;
+	       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
-break;
+	       references somehow.  */
+	    tree init = TARGET_EXPR_INITIAL (*from_p);
-case COMPOUND_EXPR:
-/* Remove any COMPOUND_EXPR in the RHS so the following cases will be
+	    if (init
-caught.  */
+		&& !VOID_TYPE_P (TREE_TYPE (init)))
-gimplify_compound_expr (from_p, pre_p, true);
+	      {
-ret = GS_OK;
+		*from_p = init;
-break;
+		ret = GS_OK;
+		changed = true;
-case CONSTRUCTOR:
+	      }
-/* 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);
+	case COMPOUND_EXPR:
+	  /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
-case COND_EXPR:
+	     caught.  */
-/* If we're assigning to a non-register type, push the assignment
+	  gimplify_compound_expr (from_p, pre_p, true);
-down into the branches.  This is mandatory for ADDRESSABLE types,
+	  ret = GS_OK;
-since we cannot generate temporaries for such, but it saves a
+	  changed = true;
-copy in other cases as well.  */
+	  break;
-if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
-{
+	case CONSTRUCTOR:
-/* This code should mirror the code in gimplify_cond_expr. */
+	  /* If we already made some changes, let the front end have a
-enum tree_code code = TREE_CODE (*expr_p);
+	     crack at this before we break it down.  */
-tree cond = *from_p;
+	  if (ret != GS_UNHANDLED)
-tree result = *to_p;
+	    break;
+	  /* If we're initializing from a CONSTRUCTOR, break this into
-ret = gimplify_expr (&result, pre_p, post_p,
+	     individual MODIFY_EXPRs.  */
-is_gimple_lvalue, fb_lvalue);
+	  return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
-if (ret != GS_ERROR)
+					    false);
-ret = GS_OK;
+	case COND_EXPR:
-if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
+	  /* If we're assigning to a non-register type, push the assignment
-TREE_OPERAND (cond, 1)
+	     down into the branches.  This is mandatory for ADDRESSABLE types,
-= build2 (code, void_type_node, result,
+	     since we cannot generate temporaries for such, but it saves a
-TREE_OPERAND (cond, 1));
+	     copy in other cases as well.  */
-if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
+	  if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
-TREE_OPERAND (cond, 2)
+	    {
-= build2 (code, void_type_node, unshare_expr (result),
+	      /* This code should mirror the code in gimplify_cond_expr. */
-TREE_OPERAND (cond, 2));
+	      enum tree_code code = TREE_CODE (*expr_p);
+	      tree cond = *from_p;
-TREE_TYPE (cond) = void_type_node;
+	      tree result = *to_p;
-recalculate_side_effects (cond);
+	      ret = gimplify_expr (&result, pre_p, post_p,
-if (want_value)
+				   is_gimple_lvalue, fb_lvalue);
-{
+	      if (ret != GS_ERROR)
-gimplify_and_add (cond, pre_p);
+		ret = GS_OK;
-*expr_p = unshare_expr (result);
-}
+	      if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
-else
+		TREE_OPERAND (cond, 1)
-*expr_p = cond;
+		  = build2 (code, void_type_node, result,
-return ret;
+			    TREE_OPERAND (cond, 1));
-}
+	      if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
-else
+		TREE_OPERAND (cond, 2)
-ret = GS_UNHANDLED;
+		  = build2 (code, void_type_node, unshare_expr (result),
-break;
+			    TREE_OPERAND (cond, 2));
-case CALL_EXPR:
+	      TREE_TYPE (cond) = void_type_node;
-/* For calls that return in memory, give *to_p as the CALL_EXPR's
+	      recalculate_side_effects (cond);
-return slot so that we don't generate a temporary.  */
-if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
+	      if (want_value)
-&& aggregate_value_p (*from_p, *from_p))
+		{
-{
+		  gimplify_and_add (cond, pre_p);
-bool use_target;
+		  *expr_p = unshare_expr (result);
+		}
-if (!(rhs_predicate_for (*to_p))(*from_p))
+	      else
-/* If we need a temporary, *to_p isn't accurate.  */
+		*expr_p = cond;
-use_target = false;
+	      return ret;
-else if (TREE_CODE (*to_p) == RESULT_DECL
+	    }
-&& DECL_NAME (*to_p) == NULL_TREE
+	  break;
-&& needs_to_live_in_memory (*to_p))
-/* It's OK to use the return slot directly unless it's an NRV. */
+	case CALL_EXPR:
-use_target = true;
+	  /* For calls that return in memory, give *to_p as the CALL_EXPR's
-else if (is_gimple_reg_type (TREE_TYPE (*to_p))
+	     return slot so that we don't generate a temporary.  */
-|| (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
+	  if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
-/* Don't force regs into memory.  */
+	      && aggregate_value_p (*from_p, *from_p))
-use_target = false;
+	    {
-else if (TREE_CODE (*expr_p) == INIT_EXPR)
+	      bool use_target;
-/* It's OK to use the target directly if it's being
-initialized. */
+	      if (!(rhs_predicate_for (*to_p))(*from_p))
-use_target = true;
+		/* If we need a temporary, *to_p isn't accurate.  */
-else if (!is_gimple_non_addressable (*to_p))
+		use_target = false;
-/* Don't use the original target if it's already addressable;
+	      else if (TREE_CODE (*to_p) == RESULT_DECL
-if its address escapes, and the called function uses the
+		       && DECL_NAME (*to_p) == NULL_TREE
-NRV optimization, a conforming program could see *to_p
+		       && needs_to_live_in_memory (*to_p))
-change before the called function returns; see c++/19317.
+		/* It's OK to use the return slot directly unless it's an NRV. */
-When optimizing, the return_slot pass marks more functions
+		use_target = true;
-as safe after we have escape info.  */
+	      else if (is_gimple_reg_type (TREE_TYPE (*to_p))
-use_target = false;
+		       || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
-else
+		/* Don't force regs into memory.  */
-use_target = true;
+		use_target = false;
+	      else if (TREE_CODE (*expr_p) == INIT_EXPR)
-if (use_target)
+		/* It's OK to use the target directly if it's being
-{
+		   initialized. */
-CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
+		use_target = true;
-mark_addressable (*to_p);
+	      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
-ret = GS_UNHANDLED;
+		   change before the called function returns; see c++/19317.
-break;
+		   When optimizing, the return_slot pass marks more functions
+		   as safe after we have escape info.  */
-/* If we're initializing from a container, push the initialization
+		use_target = false;
-inside it.  */
+	      else
-case CLEANUP_POINT_EXPR:
+		use_target = true;
-case BIND_EXPR:
-case STATEMENT_LIST:
+	      if (use_target)
-{
+		{
-tree wrap = *from_p;
+		  CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
-tree t;
+		  mark_addressable (*to_p);
+		}
-ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
+	    }
-fb_lvalue);
+	  break;
-if (ret != GS_ERROR)
-ret = GS_OK;
+	case WITH_SIZE_EXPR:
+	  /* Likewise for calls that return an aggregate of non-constant size,
-t = voidify_wrapper_expr (wrap, *expr_p);
+	     since we would not be able to generate a temporary at all.  */
-gcc_assert (t == *expr_p);
+	  if (TREE_CODE (TREE_OPERAND (*from_p, 0)) == CALL_EXPR)
+	    {
-if (want_value)
+	      *from_p = TREE_OPERAND (*from_p, 0);
-{
+	      /* We don't change ret in this case because the
-gimplify_and_add (wrap, pre_p);
+		 WITH_SIZE_EXPR might have been added in
-*expr_p = unshare_expr (*to_p);
+		 gimplify_modify_expr, so returning GS_OK would lead to an
-}
+		 infinite loop.  */
-else
+	      changed = true;
-*expr_p = wrap;
+	    }
-return GS_OK;
+	  break;
-}
+	  /* If we're initializing from a container, push the initialization
-case COMPOUND_LITERAL_EXPR:
+	     inside it.  */
-{
+	case CLEANUP_POINT_EXPR:
-tree complit = TREE_OPERAND (*expr_p, 1);
+	case BIND_EXPR:
-tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (complit);
+	case STATEMENT_LIST:
-tree decl = DECL_EXPR_DECL (decl_s);
+	  {
-tree init = DECL_INITIAL (decl);
+	    tree wrap = *from_p;
+	    tree t;
-/* struct T x = (struct T) { 0, 1, 2 } can be optimized
-into struct T x = { 0, 1, 2 } if the address of the
+	    ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
-compound literal has never been taken.  */
+				 fb_lvalue);
-if (!TREE_ADDRESSABLE (complit)
+	    if (ret != GS_ERROR)
-&& !TREE_ADDRESSABLE (decl)
+	      ret = GS_OK;
-&& init)
-{
+	    t = voidify_wrapper_expr (wrap, *expr_p);
-*expr_p = copy_node (*expr_p);
+	    gcc_assert (t == *expr_p);
-TREE_OPERAND (*expr_p, 1) = init;
-return GS_OK;
+	    if (want_value)
-}
+	      {
-}
+		gimplify_and_add (wrap, pre_p);
+		*expr_p = unshare_expr (*to_p);
-default:
+	      }
-ret = GS_UNHANDLED;
+	    else
-break;
+	      *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:
+	  break;
+	}
+}
+while (changed);
 return ret;
 }
 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
 /* Try to alleviate the effects of the gimplification creating artificial
 temporaries (see for example is_gimple_reg_rhs) on the debug info.  */
 if (!gimplify_ctxp->into_ssa
-&& DECL_P (*from_p)
+&& TREE_CODE (*from_p) == VAR_DECL
 && DECL_IGNORED_P (*from_p)
 && DECL_P (*to_p)
 && !DECL_IGNORED_P (*to_p))
 {
 if (!DECL_NAME (*from_p) && 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 (want_value && TREE_THIS_VOLATILE (*to_p))
+*from_p = get_initialized_tmp_var (*from_p, pre_p, post_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.  */
 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));
 gimple_set_lhs (assign, *to_p);
 }
 if (want_value)
 {
-*expr_p = unshare_expr (*to_p);
+*expr_p = TREE_THIS_VOLATILE (*to_p) ? *from_p : unshare_expr (*to_p);
 return GS_OK;
 }
 else
 *expr_p = NULL;
 with a call to BUILT_IN_MEMCMP.  */
 static enum gimplify_status
 gimplify_variable_sized_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 t, arg, dest, src;
+tree t, arg, dest, src, expr;
-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_loc (loc, op1);
 dest = build_fold_addr_expr_loc (loc, op0);
 t = implicit_built_in_decls[BUILT_IN_MEMCMP];
 t = build_call_expr_loc (loc, t, 3, dest, src, arg);
-*expr_p
+expr
 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
+SET_EXPR_LOCATION (expr, loc);
+*expr_p = expr;
 return GS_OK;
 }
 /*  Gimplify a comparison between two aggregate objects of integral scalar
 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
 expressions may be generated internally by the compiler (e.g.,
 builtins like __builtin_va_end).  */
 }
 }
 /* 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,
+	  tree inputv = TREE_VALUE (link);
-is_gimple_lvalue, fb_lvalue | fb_mayfail);
+	  STRIP_NOPS (inputv);
-mark_addressable (TREE_VALUE (link));
+	  if (TREE_CODE (inputv) == PREDECREMENT_EXPR
-if (tret == GS_ERROR)
+	      || TREE_CODE (inputv) == PREINCREMENT_EXPR
-{
+	      || TREE_CODE (inputv) == POSTDECREMENT_EXPR
-if (EXPR_HAS_LOCATION (TREE_VALUE (link)))
+	      || TREE_CODE (inputv) == POSTINCREMENT_EXPR)
-input_location = EXPR_LOCATION (TREE_VALUE (link));
+	    TREE_VALUE (link) = error_mark_node;
-error ("memory input %d is not directly addressable", i);
+	  tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
-ret = tret;
+				is_gimple_lvalue, fb_lvalue | fb_mayfail);
-}
+	  mark_addressable (TREE_VALUE (link));
-}
+	  if (tret == GS_ERROR)
+	    {
+	      if (EXPR_HAS_LOCATION (TREE_VALUE (link)))
+	        input_location = EXPR_LOCATION (TREE_VALUE (link));
+	      error ("memory input %d is not directly addressable", i);
+	      ret = tret;
+	    }
+	}
 else
 {
 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
 is_gimple_asm_val, fb_rvalue);
 if (tret == GS_ERROR)
 {
 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,
+	      if (!gimple_wce_cleanup_eh_only (wce))
-gimple_wce_cleanup (wce),
+		gsi_insert_seq_before_without_update (&iter,
-GSI_SAME_STMT);
+						      gimple_wce_cleanup (wce),
-gsi_remove (&iter, true);
+						      GSI_SAME_STMT);
-break;
+	      gsi_remove (&iter, true);
-}
+	      break;
-else
+	    }
-{
+	  else
-gimple gtry;
+	    {
-gimple_seq seq;
+	      gimple gtry;
-enum gimple_try_flags kind;
+	      gimple_seq seq;
+	      enum gimple_try_flags kind;
-if (gimple_wce_cleanup_eh_only (wce))
-kind = GIMPLE_TRY_CATCH;
+	      if (gimple_wce_cleanup_eh_only (wce))
-else
+		kind = GIMPLE_TRY_CATCH;
-kind = GIMPLE_TRY_FINALLY;
+	      else
-seq = gsi_split_seq_after (iter);
+		kind = GIMPLE_TRY_FINALLY;
+	      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);
 }
 gimple wce;
 gimple_seq cleanup_stmts = NULL;
 /* Errors can result in improperly nested cleanups.  Which results in
 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR.  */
-if (errorcount || sorrycount)
+if (seen_error ())
 return;
 if (gimple_conditional_context ())
 {
 /* If we're in a conditional context, this is more complex.  We only
 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 = DECL_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:
 if (flags & GOVD_SHARED)
 flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
 | (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))
+else if (! (flags & GOVD_LOCAL)
-omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
+	       && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl))))
+	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));
 omp_notice_variable (ctx, t, true);
 }
 }
 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
 /* 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));
+	  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 omp_notice_threadprivate_variable (ctx, decl, value);
-}
+	}
 }
 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
 if (n == NULL)
 {
 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
 default_kind = kind;
 switch (default_kind)
-{
+	{
-case OMP_CLAUSE_DEFAULT_NONE:
+	case OMP_CLAUSE_DEFAULT_NONE:
-error ("%qE not specified in enclosing parallel",
+	  error ("%qE not specified in enclosing parallel",
-DECL_NAME (decl));
+		 DECL_NAME (lang_hooks.decls.omp_report_decl (decl)));
-error_at (ctx->location, "enclosing parallel");
+	  if ((ctx->region_type & ORT_TASK) != 0)
-/* FALLTHRU */
+	    error_at (ctx->location, "enclosing task");
-case OMP_CLAUSE_DEFAULT_SHARED:
+	  else
-flags |= GOVD_SHARED;
+	    error_at (ctx->location, "enclosing parallel");
-break;
+	  /* FALLTHRU */
-case OMP_CLAUSE_DEFAULT_PRIVATE:
+	case OMP_CLAUSE_DEFAULT_SHARED:
-flags |= GOVD_PRIVATE;
+	  flags |= GOVD_SHARED;
-break;
+	  break;
-case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
+	case OMP_CLAUSE_DEFAULT_PRIVATE:
-flags |= GOVD_FIRSTPRIVATE;
+	  flags |= GOVD_PRIVATE;
-break;
+	  break;
-case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
+	case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
-/* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED.  */
+	  flags |= GOVD_FIRSTPRIVATE;
-gcc_assert (ctx->region_type == ORT_TASK);
+	  break;
-if (ctx->outer_context)
+	case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
-omp_notice_variable (ctx->outer_context, decl, in_code);
+	  /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED.  */
-for (octx = ctx->outer_context; octx; octx = octx->outer_context)
+	  gcc_assert ((ctx->region_type & ORT_TASK) != 0);
-{
+	  if (ctx->outer_context)
-splay_tree_node n2;
+	    omp_notice_variable (ctx->outer_context, decl, in_code);
+	  for (octx = ctx->outer_context; octx; octx = octx->outer_context)
-n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
+	    {
-if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
+	      splay_tree_node n2;
-{
-flags |= GOVD_FIRSTPRIVATE;
+	      n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
-break;
+	      if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
-}
+		{
-if ((octx->region_type & ORT_PARALLEL) != 0)
+		  flags |= GOVD_FIRSTPRIVATE;
-break;
+		  break;
-}
+		}
-if (flags & GOVD_FIRSTPRIVATE)
+	      if ((octx->region_type & ORT_PARALLEL) != 0)
-break;
+		break;
-if (octx == NULL
+	    }
-&& (TREE_CODE (decl) == PARM_DECL
+	  if (flags & GOVD_FIRSTPRIVATE)
-|| (!is_global_var (decl)
+	    break;
-&& DECL_CONTEXT (decl) == current_function_decl)))
+	  if (octx == NULL
-{
+	      && (TREE_CODE (decl) == PARM_DECL
-flags |= GOVD_FIRSTPRIVATE;
+		  || (!is_global_var (decl)
-break;
+		      && DECL_CONTEXT (decl) == current_function_decl)))
-}
+	    {
-flags |= GOVD_SHARED;
+	      flags |= GOVD_FIRSTPRIVATE;
-break;
+	      break;
-default:
+	    }
-gcc_unreachable ();
+	  flags |= GOVD_SHARED;
-}
+	  break;
+	default:
+	  gcc_unreachable ();
+	}
 if ((flags & GOVD_PRIVATE)
 && lang_hooks.decls.omp_private_outer_ref (decl))
 flags |= GOVD_PRIVATE_OUTER_REF;
 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)
 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p, lhs_addr,
 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,
+	case TRUTH_AND_EXPR:
-lhs_addr, lhs_var);
+	case TRUTH_OR_EXPR:
-saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
+	case TRUTH_XOR_EXPR:
-lhs_addr, lhs_var);
+	  saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
+					 lhs_addr, lhs_var);
+	case TRUTH_NOT_EXPR:
+	  saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
+					 lhs_addr, lhs_var);
+	  break;
+	default:
+	  break;
+	}
 break;
 default:
 break;
 }
 break;
 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)
 returning to the caller, the sequence POST_P is appended to
 the main output sequence PRE_P.
 GIMPLE_TEST_F points to a function that takes a tree T and
 returns nonzero if T is in the GIMPLE form requested by the
-caller.  The GIMPLE predicates are in tree-gimple.c.
+caller.  The GIMPLE predicates are in gimple.c.
 FALLBACK tells the function what sort of a temporary we want if
 gimplification cannot produce an expression that complies with
 GIMPLE_TEST_F.
 || gimple_test_f == is_gimple_condexpr
 || gimple_test_f == is_gimple_mem_rhs
 || gimple_test_f == is_gimple_mem_rhs_or_call
 || gimple_test_f == is_gimple_reg_rhs
 || gimple_test_f == is_gimple_reg_rhs_or_call
-|| gimple_test_f == is_gimple_asm_val)
+|| gimple_test_f == is_gimple_asm_val
+	   || gimple_test_f == is_gimple_mem_ref_addr)
 gcc_assert (fallback & fb_rvalue);
 else if (gimple_test_f == is_gimple_min_lval
 || gimple_test_f == is_gimple_lvalue)
 gcc_assert (fallback & fb_lvalue);
 else if (gimple_test_f == is_gimple_addressable)
 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.  */
+	  /* 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);
-}
+	      ret = GS_OK;
-break;
+	    }
+	  break;
-case CALL_EXPR:
-ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
+	case CALL_EXPR:
+	  ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
-/* C99 code may assign to an array in a structure returned
-from a function, and this has undefined behavior only on
+	  /* C99 code may assign to an array in a structure returned
-execution, so create a temporary if an lvalue is
+	     from a function, and this has undefined behavior only on
-required.  */
+	     execution, so create a temporary if an lvalue is
-if (fallback == fb_lvalue)
+	     required.  */
-{
+	  if (fallback == fb_lvalue)
-*expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
+	    {
-mark_addressable (*expr_p);
+	      *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
-}
+	      mark_addressable (*expr_p);
-break;
+	      ret = GS_OK;
+	    }
-case TREE_LIST:
+	  break;
-gcc_unreachable ();
+	case TREE_LIST:
-case COMPOUND_EXPR:
+	  gcc_unreachable ();
-ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
-break;
+	case COMPOUND_EXPR:
+	  ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
-case COMPOUND_LITERAL_EXPR:
+	  break;
-ret = gimplify_compound_literal_expr (expr_p, pre_p);
-break;
+	case COMPOUND_LITERAL_EXPR:
+	  ret = gimplify_compound_literal_expr (expr_p, pre_p);
-case MODIFY_EXPR:
+	  break;
-case INIT_EXPR:
-ret = gimplify_modify_expr (expr_p, pre_p, post_p,
+	case MODIFY_EXPR:
-fallback != fb_none);
+	case INIT_EXPR:
-break;
+	  ret = gimplify_modify_expr (expr_p, pre_p, post_p,
+				      fallback != fb_none);
-case TRUTH_ANDIF_EXPR:
+	  break;
-case TRUTH_ORIF_EXPR:
-/* Pass the source location of the outer expression.  */
+	case TRUTH_ANDIF_EXPR:
-ret = gimplify_boolean_expr (expr_p, saved_location);
+	case TRUTH_ORIF_EXPR:
-break;
+	  /* Pass the source location of the outer expression.  */
+	  ret = gimplify_boolean_expr (expr_p, saved_location);
-case TRUTH_NOT_EXPR:
+	  break;
-if (TREE_CODE (TREE_TYPE (*expr_p)) != BOOLEAN_TYPE)
-{
+	case TRUTH_NOT_EXPR:
-tree type = TREE_TYPE (*expr_p);
+	  if (TREE_CODE (TREE_TYPE (*expr_p)) != BOOLEAN_TYPE)
-*expr_p = fold_convert (type, gimple_boolify (*expr_p));
+	    {
-ret = GS_OK;
+	      tree type = TREE_TYPE (*expr_p);
-break;
+	      *expr_p = fold_convert (type, gimple_boolify (*expr_p));
-}
+	      ret = GS_OK;
+	      break;
-ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
+	    }
-is_gimple_val, fb_rvalue);
-recalculate_side_effects (*expr_p);
+	  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
-break;
+			       is_gimple_val, fb_rvalue);
+	  recalculate_side_effects (*expr_p);
-case ADDR_EXPR:
+	  break;
-ret = gimplify_addr_expr (expr_p, pre_p, post_p);
-break;
+	case ADDR_EXPR:
+	  ret = gimplify_addr_expr (expr_p, pre_p, post_p);
-case VA_ARG_EXPR:
+	  break;
-ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
-break;
+	case VA_ARG_EXPR:
+	  ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
-CASE_CONVERT:
+	  break;
-if (IS_EMPTY_STMT (*expr_p))
-{
+	CASE_CONVERT:
-ret = GS_ALL_DONE;
+	  if (IS_EMPTY_STMT (*expr_p))
-break;
+	    {
-}
+	      ret = GS_ALL_DONE;
+	      break;
-if (VOID_TYPE_P (TREE_TYPE (*expr_p))
+	    }
-|| fallback == fb_none)
-{
+	  if (VOID_TYPE_P (TREE_TYPE (*expr_p))
-/* Just strip a conversion to void (or in void context) and
+	      || fallback == fb_none)
-try again.  */
+	    {
-*expr_p = TREE_OPERAND (*expr_p, 0);
+	      /* Just strip a conversion to void (or in void context) and
-break;
+		 try again.  */
-}
+	      *expr_p = TREE_OPERAND (*expr_p, 0);
+	      ret = GS_OK;
-ret = gimplify_conversion (expr_p);
+	      break;
-if (ret == GS_ERROR)
+	    }
-break;
-if (*expr_p != save_expr)
+	  ret = gimplify_conversion (expr_p);
-break;
+	  if (ret == GS_ERROR)
-/* FALLTHRU */
+	    break;
+	  if (*expr_p != save_expr)
-case FIX_TRUNC_EXPR:
+	    break;
-/* unary_expr: ... | '(' cast ')' val | ...  */
+	  /* FALLTHRU */
-ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
-is_gimple_val, fb_rvalue);
+	case FIX_TRUNC_EXPR:
-recalculate_side_effects (*expr_p);
+	  /* unary_expr: ... | '(' cast ')' val | ...  */
-break;
+	  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
+			       is_gimple_val, fb_rvalue);
-case INDIRECT_REF:
+	  recalculate_side_effects (*expr_p);
-*expr_p = fold_indirect_ref_loc (input_location, *expr_p);
+	  break;
-if (*expr_p != save_expr)
-break;
+	case INDIRECT_REF:
-/* else fall through.  */
+	  {
-case ALIGN_INDIRECT_REF:
+	    bool volatilep = TREE_THIS_VOLATILE (*expr_p);
-case MISALIGNED_INDIRECT_REF:
+	    bool notrap = TREE_THIS_NOTRAP (*expr_p);
-ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
+	    tree saved_ptr_type = TREE_TYPE (TREE_OPERAND (*expr_p, 0));
-is_gimple_reg, fb_rvalue);
-recalculate_side_effects (*expr_p);
+	    *expr_p = fold_indirect_ref_loc (input_location, *expr_p);
-break;
+	    if (*expr_p != save_expr)
+	      {
-/* Constants need not be gimplified.  */
+		ret = GS_OK;
-case INTEGER_CST:
+		break;
-case REAL_CST:
+	      }
-case FIXED_CST:
-case STRING_CST:
+	    ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
-case COMPLEX_CST:
+				 is_gimple_reg, fb_rvalue);
-case VECTOR_CST:
+	    if (ret == GS_ERROR)
-ret = GS_ALL_DONE;
+	      break;
-break;
+	    recalculate_side_effects (*expr_p);
-case CONST_DECL:
+	    *expr_p = fold_build2_loc (input_location, MEM_REF,
-/* If we require an lvalue, such as for ADDR_EXPR, retain the
+				       TREE_TYPE (*expr_p),
-CONST_DECL node.  Otherwise the decl is replaceable by its
+				       TREE_OPERAND (*expr_p, 0),
-value.  */
+				       build_int_cst (saved_ptr_type, 0));
-/* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either.  */
+	    TREE_THIS_VOLATILE (*expr_p) = volatilep;
-if (fallback & fb_lvalue)
+	    TREE_THIS_NOTRAP (*expr_p) = notrap;
-ret = GS_ALL_DONE;
+	    ret = GS_OK;
-else
+	    break;
-*expr_p = DECL_INITIAL (*expr_p);
+	  }
-break;
+	/* We arrive here through the various re-gimplifcation paths.  */
-case DECL_EXPR:
+	case MEM_REF:
-ret = gimplify_decl_expr (expr_p, pre_p);
+	  /* First try re-folding the whole thing.  */
-break;
+	  tmp = fold_binary (MEM_REF, TREE_TYPE (*expr_p),
+			     TREE_OPERAND (*expr_p, 0),
-case BIND_EXPR:
+			     TREE_OPERAND (*expr_p, 1));
-ret = gimplify_bind_expr (expr_p, pre_p);
+	  if (tmp)
-break;
+	    {
+	      *expr_p = tmp;
-case LOOP_EXPR:
+	      recalculate_side_effects (*expr_p);
-ret = gimplify_loop_expr (expr_p, pre_p);
+	      ret = GS_OK;
-break;
+	      break;
+	    }
-case SWITCH_EXPR:
+	  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
-ret = gimplify_switch_expr (expr_p, pre_p);
+			       is_gimple_mem_ref_addr, fb_rvalue);
-break;
+	  if (ret == GS_ERROR)
+	    break;
-case EXIT_EXPR:
+	  recalculate_side_effects (*expr_p);
-ret = gimplify_exit_expr (expr_p);
+	  ret = GS_ALL_DONE;
-break;
+	  break;
-case GOTO_EXPR:
+	  /* Constants need not be gimplified.  */
-/* If the target is not LABEL, then it is a computed jump
+	case INTEGER_CST:
-and the target needs to be gimplified.  */
+	case REAL_CST:
-if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
+	case FIXED_CST:
-{
+	case STRING_CST:
-ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
+	case COMPLEX_CST:
-NULL, is_gimple_val, fb_rvalue);
+	case VECTOR_CST:
-if (ret == GS_ERROR)
+	  ret = GS_ALL_DONE;
-break;
+	  break;
-}
-gimplify_seq_add_stmt (pre_p,
+	case CONST_DECL:
-gimple_build_goto (GOTO_DESTINATION (*expr_p)));
+	  /* If we require an lvalue, such as for ADDR_EXPR, retain the
-break;
+	     CONST_DECL node.  Otherwise the decl is replaceable by its
+	     value.  */
-case PREDICT_EXPR:
+	  /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either.  */
-gimplify_seq_add_stmt (pre_p,
+	  if (fallback & fb_lvalue)
-gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p),
+	    ret = GS_ALL_DONE;
-PREDICT_EXPR_OUTCOME (*expr_p)));
+	  else
-ret = GS_ALL_DONE;
+	    {
-break;
+	      *expr_p = DECL_INITIAL (*expr_p);
+	      ret = GS_OK;
-case LABEL_EXPR:
+	    }
-ret = GS_ALL_DONE;
+	  break;
-gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
-== current_function_decl);
+	case DECL_EXPR:
-gimplify_seq_add_stmt (pre_p,
+	  ret = gimplify_decl_expr (expr_p, pre_p);
-gimple_build_label (LABEL_EXPR_LABEL (*expr_p)));
+	  break;
-break;
+	case BIND_EXPR:
-case CASE_LABEL_EXPR:
+	  ret = gimplify_bind_expr (expr_p, pre_p);
-ret = gimplify_case_label_expr (expr_p, pre_p);
+	  break;
-break;
+	case LOOP_EXPR:
-case RETURN_EXPR:
+	  ret = gimplify_loop_expr (expr_p, pre_p);
-ret = gimplify_return_expr (*expr_p, pre_p);
+	  break;
-break;
+	case SWITCH_EXPR:
-case CONSTRUCTOR:
+	  ret = gimplify_switch_expr (expr_p, pre_p);
-/* Don't reduce this in place; let gimplify_init_constructor work its
+	  break;
-magic.  Buf if we're just elaborating this for side effects, just
-gimplify any element that has side-effects.  */
+	case EXIT_EXPR:
-if (fallback == fb_none)
+	  ret = gimplify_exit_expr (expr_p);
-{
+	  break;
-unsigned HOST_WIDE_INT ix;
-constructor_elt *ce;
+	case GOTO_EXPR:
-tree temp = NULL_TREE;
+	  /* If the target is not LABEL, then it is a computed jump
-for (ix = 0;
+	     and the target needs to be gimplified.  */
-VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (*expr_p),
+	  if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
-ix, ce);
+	    {
-ix++)
+	      ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
-if (TREE_SIDE_EFFECTS (ce->value))
+				   NULL, is_gimple_val, fb_rvalue);
-append_to_statement_list (ce->value, &temp);
+	      if (ret == GS_ERROR)
+		break;
-*expr_p = temp;
+	    }
-ret = GS_OK;
+	  gimplify_seq_add_stmt (pre_p,
-}
+			  gimple_build_goto (GOTO_DESTINATION (*expr_p)));
-/* C99 code may assign to an array in a constructed
+	  ret = GS_ALL_DONE;
-structure or union, and this has undefined behavior only
+	  break;
-on execution, so create a temporary if an lvalue is
-required.  */
+	case PREDICT_EXPR:
-else if (fallback == fb_lvalue)
+	  gimplify_seq_add_stmt (pre_p,
-{
+			gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p),
-*expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
+					      PREDICT_EXPR_OUTCOME (*expr_p)));
-mark_addressable (*expr_p);
+	  ret = GS_ALL_DONE;
-}
+	  break;
-else
-ret = GS_ALL_DONE;
+	case LABEL_EXPR:
-break;
+	  ret = GS_ALL_DONE;
+	  gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
-/* The following are special cases that are not handled by the
+		      == current_function_decl);
-original GIMPLE grammar.  */
+	  gimplify_seq_add_stmt (pre_p,
+			  gimple_build_label (LABEL_EXPR_LABEL (*expr_p)));
-/* SAVE_EXPR nodes are converted into a GIMPLE identifier and
+	  break;
-eliminated.  */
-case SAVE_EXPR:
+	case CASE_LABEL_EXPR:
-ret = gimplify_save_expr (expr_p, pre_p, post_p);
+	  ret = gimplify_case_label_expr (expr_p, pre_p);
-break;
+	  break;
-case BIT_FIELD_REF:
+	case RETURN_EXPR:
-{
+	  ret = gimplify_return_expr (*expr_p, pre_p);
-enum gimplify_status r0, r1, r2;
+	  break;
-r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
+	case CONSTRUCTOR:
-post_p, is_gimple_lvalue, fb_either);
+	  /* Don't reduce this in place; let gimplify_init_constructor work its
-r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
+	     magic.  Buf if we're just elaborating this for side effects, just
-post_p, is_gimple_val, fb_rvalue);
+	     gimplify any element that has side-effects.  */
-r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
+	  if (fallback == fb_none)
-post_p, is_gimple_val, fb_rvalue);
+	    {
-recalculate_side_effects (*expr_p);
+	      unsigned HOST_WIDE_INT ix;
+	      tree val;
-ret = MIN (r0, MIN (r1, r2));
+	      tree temp = NULL_TREE;
-}
+	      FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p), ix, val)
-break;
+		if (TREE_SIDE_EFFECTS (val))
+		  append_to_statement_list (val, &temp);
-case TARGET_MEM_REF:
-{
+	      *expr_p = temp;
-enum gimplify_status r0 = GS_ALL_DONE, r1 = GS_ALL_DONE;
+	      ret = temp ? GS_OK : GS_ALL_DONE;
+	    }
-if (TMR_SYMBOL (*expr_p))
+	  /* C99 code may assign to an array in a constructed
-r0 = gimplify_expr (&TMR_SYMBOL (*expr_p), pre_p,
+	     structure or union, and this has undefined behavior only
-post_p, is_gimple_lvalue, fb_either);
+	     on execution, so create a temporary if an lvalue is
-else if (TMR_BASE (*expr_p))
+	     required.  */
-r0 = gimplify_expr (&TMR_BASE (*expr_p), pre_p,
+	  else if (fallback == fb_lvalue)
-post_p, is_gimple_val, fb_either);
+	    {
-if (TMR_INDEX (*expr_p))
+	      *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
-r1 = gimplify_expr (&TMR_INDEX (*expr_p), pre_p,
+	      mark_addressable (*expr_p);
-post_p, is_gimple_val, fb_rvalue);
+	      ret = GS_OK;
-/* TMR_STEP and TMR_OFFSET are always integer constants.  */
+	    }
-ret = MIN (r0, r1);
+	  else
-}
+	    ret = GS_ALL_DONE;
-break;
+	  break;
-case NON_LVALUE_EXPR:
+	  /* The following are special cases that are not handled by the
-/* This should have been stripped above.  */
+	     original GIMPLE grammar.  */
-gcc_unreachable ();
+	  /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
-case ASM_EXPR:
+	     eliminated.  */
-ret = gimplify_asm_expr (expr_p, pre_p, post_p);
+	case SAVE_EXPR:
-break;
+	  ret = gimplify_save_expr (expr_p, pre_p, post_p);
+	  break;
-case TRY_FINALLY_EXPR:
-case TRY_CATCH_EXPR:
+	case BIT_FIELD_REF:
-{
+	  {
-gimple_seq eval, cleanup;
+	    enum gimplify_status r0, r1, r2;
-gimple try_;
+	    r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
-eval = cleanup = NULL;
+				post_p, is_gimple_lvalue, fb_either);
-gimplify_and_add (TREE_OPERAND (*expr_p, 0), &eval);
+	    r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
-gimplify_and_add (TREE_OPERAND (*expr_p, 1), &cleanup);
+				post_p, is_gimple_val, fb_rvalue);
-/* Don't create bogus GIMPLE_TRY with empty cleanup.  */
+	    r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
-if (gimple_seq_empty_p (cleanup))
+				post_p, is_gimple_val, fb_rvalue);
-{
+	    recalculate_side_effects (*expr_p);
-gimple_seq_add_seq (pre_p, eval);
-ret = GS_ALL_DONE;
+	    ret = MIN (r0, MIN (r1, r2));
-break;
+	  }
-}
+	  break;
-try_ = gimple_build_try (eval, cleanup,
-TREE_CODE (*expr_p) == TRY_FINALLY_EXPR
+	case TARGET_MEM_REF:
-? GIMPLE_TRY_FINALLY
+	  {
-: GIMPLE_TRY_CATCH);
+	    enum gimplify_status r0 = GS_ALL_DONE, r1 = GS_ALL_DONE;
-if (TREE_CODE (*expr_p) == TRY_CATCH_EXPR)
-gimple_try_set_catch_is_cleanup (try_,
+	    if (TMR_BASE (*expr_p))
-TRY_CATCH_IS_CLEANUP (*expr_p));
+	      r0 = gimplify_expr (&TMR_BASE (*expr_p), pre_p,
-gimplify_seq_add_stmt (pre_p, try_);
+				  post_p, is_gimple_mem_ref_addr, fb_either);
-ret = GS_ALL_DONE;
+	    if (TMR_INDEX (*expr_p))
-break;
+	      r1 = gimplify_expr (&TMR_INDEX (*expr_p), pre_p,
-}
+				  post_p, is_gimple_val, fb_rvalue);
+	    if (TMR_INDEX2 (*expr_p))
-case CLEANUP_POINT_EXPR:
+	      r1 = gimplify_expr (&TMR_INDEX2 (*expr_p), pre_p,
-ret = gimplify_cleanup_point_expr (expr_p, pre_p);
+				  post_p, is_gimple_val, fb_rvalue);
-break;
+	    /* TMR_STEP and TMR_OFFSET are always integer constants.  */
+	    ret = MIN (r0, r1);
-case TARGET_EXPR:
+	  }
-ret = gimplify_target_expr (expr_p, pre_p, post_p);
+	  break;
-break;
+	case NON_LVALUE_EXPR:
-case CATCH_EXPR:
+	  /* This should have been stripped above.  */
-{
+	  gcc_unreachable ();
-gimple c;
-gimple_seq handler = NULL;
+	case ASM_EXPR:
-gimplify_and_add (CATCH_BODY (*expr_p), &handler);
+	  ret = gimplify_asm_expr (expr_p, pre_p, post_p);
-c = gimple_build_catch (CATCH_TYPES (*expr_p), handler);
+	  break;
-gimplify_seq_add_stmt (pre_p, c);
-ret = GS_ALL_DONE;
+	case TRY_FINALLY_EXPR:
-break;
+	case TRY_CATCH_EXPR:
-}
+	  {
+	    gimple_seq eval, cleanup;
-case EH_FILTER_EXPR:
+	    gimple try_;
-{
-gimple ehf;
+	    eval = cleanup = NULL;
-gimple_seq failure = NULL;
+	    gimplify_and_add (TREE_OPERAND (*expr_p, 0), &eval);
+	    gimplify_and_add (TREE_OPERAND (*expr_p, 1), &cleanup);
-gimplify_and_add (EH_FILTER_FAILURE (*expr_p), &failure);
+	    /* Don't create bogus GIMPLE_TRY with empty cleanup.  */
-ehf = gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p), failure);
+	    if (gimple_seq_empty_p (cleanup))
-gimple_set_no_warning (ehf, TREE_NO_WARNING (*expr_p));
+	      {
-gimplify_seq_add_stmt (pre_p, ehf);
+		gimple_seq_add_seq (pre_p, eval);
-ret = GS_ALL_DONE;
+		ret = GS_ALL_DONE;
-break;
+		break;
-}
+	      }
+	    try_ = gimple_build_try (eval, cleanup,
-case OBJ_TYPE_REF:
+				     TREE_CODE (*expr_p) == TRY_FINALLY_EXPR
-{
+				     ? GIMPLE_TRY_FINALLY
-enum gimplify_status r0, r1;
+				     : GIMPLE_TRY_CATCH);
-r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p,
+	    if (TREE_CODE (*expr_p) == TRY_CATCH_EXPR)
-post_p, is_gimple_val, fb_rvalue);
+	      gimple_try_set_catch_is_cleanup (try_,
-r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p,
+					       TRY_CATCH_IS_CLEANUP (*expr_p));
-post_p, is_gimple_val, fb_rvalue);
+	    gimplify_seq_add_stmt (pre_p, try_);
-TREE_SIDE_EFFECTS (*expr_p) = 0;
+	    ret = GS_ALL_DONE;
-ret = MIN (r0, r1);
+	    break;
-}
+	  }
-break;
+	case CLEANUP_POINT_EXPR:
-case LABEL_DECL:
+	  ret = gimplify_cleanup_point_expr (expr_p, pre_p);
-/* 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 TARGET_EXPR:
-FORCED_LABEL (*expr_p) = 1;
+	  ret = gimplify_target_expr (expr_p, pre_p, post_p);
-ret = GS_ALL_DONE;
+	  break;
-break;
+	case CATCH_EXPR:
-case STATEMENT_LIST:
+	  {
-ret = gimplify_statement_list (expr_p, pre_p);
+	    gimple c;
-break;
+	    gimple_seq handler = NULL;
+	    gimplify_and_add (CATCH_BODY (*expr_p), &handler);
-case WITH_SIZE_EXPR:
+	    c = gimple_build_catch (CATCH_TYPES (*expr_p), handler);
-{
+	    gimplify_seq_add_stmt (pre_p, c);
-gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
+	    ret = GS_ALL_DONE;
-post_p == &internal_post ? NULL : post_p,
+	    break;
-gimple_test_f, fallback);
+	  }
-gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
-is_gimple_val, fb_rvalue);
+	case EH_FILTER_EXPR:
-}
+	  {
-break;
+	    gimple ehf;
+	    gimple_seq failure = NULL;
-case VAR_DECL:
-case PARM_DECL:
+	    gimplify_and_add (EH_FILTER_FAILURE (*expr_p), &failure);
-ret = gimplify_var_or_parm_decl (expr_p);
+	    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 RESULT_DECL:
+	    ret = GS_ALL_DONE;
-/* When within an OpenMP context, notice uses of variables.  */
+	    break;
-if (gimplify_omp_ctxp)
+	  }
-omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
-ret = GS_ALL_DONE;
+	case OBJ_TYPE_REF:
-break;
+	  {
+	    enum gimplify_status r0, r1;
-case SSA_NAME:
+	    r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p,
-/* Allow callbacks into the gimplifier during optimization.  */
+				post_p, is_gimple_val, fb_rvalue);
-ret = GS_ALL_DONE;
+	    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 OMP_PARALLEL:
+	    ret = MIN (r0, r1);
-gimplify_omp_parallel (expr_p, pre_p);
+	  }
-ret = GS_ALL_DONE;
+	  break;
-break;
+	case LABEL_DECL:
-case OMP_TASK:
+	  /* We get here when taking the address of a label.  We mark
-gimplify_omp_task (expr_p, pre_p);
+	     the label as "forced"; meaning it can never be removed and
-ret = GS_ALL_DONE;
+	     it is a potential target for any computed goto.  */
-break;
+	  FORCED_LABEL (*expr_p) = 1;
+	  ret = GS_ALL_DONE;
-case OMP_FOR:
+	  break;
-ret = gimplify_omp_for (expr_p, pre_p);
-break;
+	case STATEMENT_LIST:
+	  ret = gimplify_statement_list (expr_p, pre_p);
-case OMP_SECTIONS:
+	  break;
-case OMP_SINGLE:
-gimplify_omp_workshare (expr_p, pre_p);
+	case WITH_SIZE_EXPR:
-ret = GS_ALL_DONE;
+	  {
-break;
+	    gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
+			   post_p == &internal_post ? NULL : post_p,
-case OMP_SECTION:
+			   gimple_test_f, fallback);
-case OMP_MASTER:
+	    gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
-case OMP_ORDERED:
+			   is_gimple_val, fb_rvalue);
-case OMP_CRITICAL:
+	    ret = GS_ALL_DONE;
-{
+	  }
-gimple_seq body = NULL;
+	  break;
-gimple g;
+	case VAR_DECL:
-gimplify_and_add (OMP_BODY (*expr_p), &body);
+	case PARM_DECL:
-switch (TREE_CODE (*expr_p))
+	  ret = gimplify_var_or_parm_decl (expr_p);
-{
+	  break;
-case OMP_SECTION:
-g = gimple_build_omp_section (body);
+	case RESULT_DECL:
-break;
+	  /* When within an OpenMP context, notice uses of variables.  */
-case OMP_MASTER:
+	  if (gimplify_omp_ctxp)
-g = gimple_build_omp_master (body);
+	    omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
-break;
+	  ret = GS_ALL_DONE;
-case OMP_ORDERED:
+	  break;
-g = gimple_build_omp_ordered (body);
-break;
+	case SSA_NAME:
-case OMP_CRITICAL:
+	  /* Allow callbacks into the gimplifier during optimization.  */
-g = gimple_build_omp_critical (body,
+	  ret = GS_ALL_DONE;
-OMP_CRITICAL_NAME (*expr_p));
+	  break;
-break;
-default:
+	case OMP_PARALLEL:
-gcc_unreachable ();
+	  gimplify_omp_parallel (expr_p, pre_p);
-}
+	  ret = GS_ALL_DONE;
-gimplify_seq_add_stmt (pre_p, g);
+	  break;
-ret = GS_ALL_DONE;
-break;
+	case OMP_TASK:
-}
+	  gimplify_omp_task (expr_p, pre_p);
+	  ret = GS_ALL_DONE;
-case OMP_ATOMIC:
+	  break;
-ret = gimplify_omp_atomic (expr_p, pre_p);
-break;
+	case OMP_FOR:
+	  ret = gimplify_omp_for (expr_p, pre_p);
-case POINTER_PLUS_EXPR:
+	  break;
+	case OMP_SECTIONS:
+	case OMP_SINGLE:
+	  gimplify_omp_workshare (expr_p, pre_p);
+	  ret = GS_ALL_DONE;
+	  break;
+	case OMP_SECTION:
+	case OMP_MASTER:
+	case OMP_ORDERED:
+	case OMP_CRITICAL:
+	  {
+	    gimple_seq body = NULL;
+	    gimple g;
+	    gimplify_and_add (OMP_BODY (*expr_p), &body);
+	    switch (TREE_CODE (*expr_p))
+	      {
+	      case OMP_SECTION:
+	        g = gimple_build_omp_section (body);
+	        break;
+	      case OMP_MASTER:
+	        g = gimple_build_omp_master (body);
+		break;
+	      case OMP_ORDERED:
+		g = gimple_build_omp_ordered (body);
+		break;
+	      case OMP_CRITICAL:
+		g = gimple_build_omp_critical (body,
+		    			       OMP_CRITICAL_NAME (*expr_p));
+		break;
+	      default:
+		gcc_unreachable ();
+	      }
+	    gimplify_seq_add_stmt (pre_p, g);
+	    ret = GS_ALL_DONE;
+	    break;
+	  }
+	case OMP_ATOMIC:
+	  ret = gimplify_omp_atomic (expr_p, pre_p);
+	  break;
+	case TRUTH_AND_EXPR:
+	case TRUTH_OR_EXPR:
+	case TRUTH_XOR_EXPR:
+	  /* Classified as tcc_expression.  */
+	  goto expr_2;
+	case FMA_EXPR:
+	  /* Classified as tcc_expression.  */
+	  goto expr_3;
+	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
-(EXPR_LOCATION (*expr_p),
+		  (EXPR_LOCATION (*expr_p),
-TREE_OPERAND (*expr_p, 0), TREE_OPERAND (*expr_p, 1),
+		   TREE_OPERAND (*expr_p, 0), TREE_OPERAND (*expr_p, 1),
-TREE_TYPE (*expr_p))))
+		   TREE_TYPE (*expr_p))))
-{
+	    {
-*expr_p = tmp;
+	      *expr_p = tmp;
-break;
+	      ret = GS_OK;
-}
+	      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)))
-(EXPR_LOCATION (*expr_p),
+	      && (tmp = maybe_fold_offset_to_address
-TREE_OPERAND (TREE_OPERAND (*expr_p, 0), 0),
+		  (EXPR_LOCATION (*expr_p),
-TREE_OPERAND (*expr_p, 1),
+		   TREE_OPERAND (TREE_OPERAND (*expr_p, 0), 0),
-TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),
+		   TREE_OPERAND (*expr_p, 1),
-0)))))
+		   TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),
-{
+					    0)))))
+	     {
 *expr_p = fold_convert (TREE_TYPE (*expr_p), tmp);
-break;
+	       ret = GS_OK;
-}
+	       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:
+	    expr_3:
-case tcc_constant:
+	      {
-ret = GS_ALL_DONE;
+		enum gimplify_status r0, r1, r2;
-goto dont_recalculate;
+		r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
-default:
+		                    post_p, is_gimple_val, fb_rvalue);
-gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR
+		r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
-|| TREE_CODE (*expr_p) == TRUTH_OR_EXPR
+				    post_p, is_gimple_val, fb_rvalue);
-|| TREE_CODE (*expr_p) == TRUTH_XOR_EXPR);
+		r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
-goto expr_2;
+				    post_p, is_gimple_val, fb_rvalue);
-}
+		ret = MIN (MIN (r0, r1), r2);
-recalculate_side_effects (*expr_p);
+		break;
+	      }
-dont_recalculate:
-break;
+	    case tcc_declaration:
-}
+	    case tcc_constant:
+	      ret = GS_ALL_DONE;
-/* If we replaced *expr_p, gimplify again.  */
+	      goto dont_recalculate;
-if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr))
-ret = GS_ALL_DONE;
+	    default:
+	      gcc_unreachable ();
+	    }
+	  recalculate_side_effects (*expr_p);
+	dont_recalculate:
+	  break;
+	}
+gcc_assert (*expr_p || ret != GS_OK);
 }
 while (ret == GS_OK);
 /* If we encountered an error_mark somewhere nested inside, either
 stub out the statement or propagate the error back out.  */
 /* An lvalue will do.  Take the address of the expression, store it
 in a temporary, and replace the expression with an INDIRECT_REF of
 that temporary.  */
 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);
+*expr_p = build_simple_mem_ref (tmp);
 }
 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
 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.  */
-&& INTEGRAL_TYPE_P (TYPE_DOMAIN (type)))
+if (!(TYPE_NAME (type)
-{
+	    && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
-t = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
+	    && DECL_IGNORED_P (TYPE_NAME (type)))
-if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
+	  && TYPE_DOMAIN (type)
-DECL_IGNORED_P (t) = 0;
+	  && INTEGRAL_TYPE_P (TYPE_DOMAIN (type)))
-t = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
+	{
-if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
+	  t = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
-DECL_IGNORED_P (t) = 0;
+	  if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
-}
+	    DECL_IGNORED_P (t) = 0;
+	  t = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
+	  if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
+	    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))
+for (field = TYPE_FIELDS (type); field; field = DECL_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
 gimple stmt;
 *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_LOC_OR_HERE (expr));
-gimple_set_location (stmt, EXPR_LOCATION (expr));
-else
-gimple_set_location (stmt, input_location);
 }
 }
 /* Gimplify the body of statements pointed to by BODY_P and return a
 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 = DECL_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);
 pop_gimplify_context (outer_bind);
 gcc_assert (gimplify_ctxp == NULL);
 #ifdef ENABLE_TYPES_CHECKING
-if (!errorcount && !sorrycount)
+if (!seen_error ())
 verify_types_in_gimple_seq (gimple_bind_body (outer_bind));
 #endif
 timevar_pop (TV_TREE_GIMPLIFY);
 input_location = saved_location;
 return outer_bind;
+}
+typedef char *char_p; /* For DEF_VEC_P.  */
+DEF_VEC_P(char_p);
+DEF_VEC_ALLOC_P(char_p,heap);
+/* Return whether we should exclude FNDECL from instrumentation.  */
+static bool
+flag_instrument_functions_exclude_p (tree fndecl)
+{
+VEC(char_p,heap) *vec;
+vec = (VEC(char_p,heap) *) flag_instrument_functions_exclude_functions;
+if (VEC_length (char_p, vec) > 0)
+{
+const char *name;
+int i;
+char *s;
+name = lang_hooks.decl_printable_name (fndecl, 0);
+FOR_EACH_VEC_ELT (char_p, vec, i, s)
+	if (strstr (name, s) != NULL)
+	  return true;
+}
+vec = (VEC(char_p,heap) *) flag_instrument_functions_exclude_files;
+if (VEC_length (char_p, vec) > 0)
+{
+const char *name;
+int i;
+char *s;
+name = DECL_SOURCE_FILE (fndecl);
+FOR_EACH_VEC_ELT (char_p, vec, i, s)
+	if (strstr (name, s) != NULL)
+	  return true;
+}
+return false;
 }
 /* Entry point to the gimplification pass.  FNDECL is the FUNCTION_DECL
 node for the function we want to gimplify.
 if (DECL_STRUCT_FUNCTION (fndecl))
 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
 else
 push_struct_function (fndecl);
-for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = TREE_CHAIN (parm))
+for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = DECL_CHAIN (parm))
 {
 /* 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 x;
 gimple new_bind;
 gimple tf;
 gimple_seq cleanup = NULL, body = NULL;
+tree tmp_var;
+gimple call;
+x = implicit_built_in_decls[BUILT_IN_RETURN_ADDRESS];
+call = gimple_build_call (x, 1, integer_zero_node);
+tmp_var = create_tmp_var (ptr_type_node, "return_addr");
+gimple_call_set_lhs (call, tmp_var);
+gimplify_seq_add_stmt (&cleanup, call);
 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_EXIT];
-gimplify_seq_add_stmt (&cleanup, gimple_build_call (x, 0));
+call = gimple_build_call (x, 2,
+				build_fold_addr_expr (current_function_decl),
+				tmp_var);
+gimplify_seq_add_stmt (&cleanup, call);
 tf = gimple_build_try (seq, cleanup, GIMPLE_TRY_FINALLY);
+x = implicit_built_in_decls[BUILT_IN_RETURN_ADDRESS];
+call = gimple_build_call (x, 1, integer_zero_node);
+tmp_var = create_tmp_var (ptr_type_node, "return_addr");
+gimple_call_set_lhs (call, tmp_var);
+gimplify_seq_add_stmt (&body, call);
 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_ENTER];
-gimplify_seq_add_stmt (&body, gimple_build_call (x, 0));
+call = gimple_build_call (x, 2,
+				build_fold_addr_expr (current_function_decl),
+				tmp_var);
+gimplify_seq_add_stmt (&body, call);
 gimplify_seq_add_stmt (&body, tf);
 new_bind = gimple_build_bind (NULL, body, gimple_bind_block (bind));
 /* Clear the block for BIND, since it is no longer directly inside
 the function, but within a try block.  */
 gimple_bind_set_block (bind, NULL);
 lhs = gimple_get_lhs (stmt);
 /* If the LHS changed it in a way that requires a simple RHS,
 create temporary.  */
 if (lhs && !is_gimple_reg (lhs))
-{
+	{
-bool need_temp = false;
+	  bool need_temp = false;
-if (is_gimple_assign (stmt)
-&& num_ops == 2
+	  if (is_gimple_assign (stmt)
-&& get_gimple_rhs_class (gimple_expr_code (stmt))
+	      && num_ops == 2
-== GIMPLE_SINGLE_RHS)
+	      && get_gimple_rhs_class (gimple_expr_code (stmt))
-gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
+		 == GIMPLE_SINGLE_RHS)
-rhs_predicate_for (gimple_assign_lhs (stmt)),
+	    gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
-fb_rvalue);
+			   rhs_predicate_for (gimple_assign_lhs (stmt)),
-else if (is_gimple_reg (lhs))
+			   fb_rvalue);
-{
+	  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);
+		    {
-if ((i & ECF_LOOPING_CONST_OR_PURE)
+		      i = gimple_call_flags (stmt);
-|| !(i & (ECF_CONST | ECF_PURE)))
+		      if ((i & ECF_LOOPING_CONST_OR_PURE)
-need_temp = true;
+			  || !(i & (ECF_CONST | ECF_PURE)))
-}
+			need_temp = true;
-if (stmt_can_throw_internal (stmt))
+		    }
-need_temp = true;
+		  if (stmt_can_throw_internal (stmt))
-}
+		    need_temp = true;
-}
+		}
-else
+	    }
-{
+	  else
-if (is_gimple_reg_type (TREE_TYPE (lhs)))
+	    {
-need_temp = true;
+	      if (is_gimple_reg_type (TREE_TYPE (lhs)))
-else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
+		need_temp = true;
-{
+	      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)
-&& !(fndecl && DECL_RESULT (fndecl)
+		      if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
-&& DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
+			  && !(fndecl && DECL_RESULT (fndecl)
-need_temp = true;
+			       && DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
-}
+			need_temp = true;
-else
+		    }
-need_temp = true;
+		  else
-}
+		    need_temp = true;
-}
+		}
-if (need_temp)
+	    }
-{
+	  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)
+	      if (TREE_CODE (orig_lhs) == SSA_NAME)
-DECL_GIMPLE_REG_P (temp) = 1;
+		orig_lhs = SSA_NAME_VAR (orig_lhs);
-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);
-if (gimple_in_ssa_p (cfun))
+	      gimple_set_lhs (stmt, temp);
-temp = make_ssa_name (temp, NULL);
+	      post_stmt = gimple_build_assign (lhs, temp);
-gimple_set_lhs (stmt, temp);
+	      if (TREE_CODE (lhs) == SSA_NAME)
-post_stmt = gimple_build_assign (lhs, temp);
+		SSA_NAME_DEF_STMT (lhs) = post_stmt;
-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))
 gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);
 pop_gimplify_context (NULL);
 }
+/* Expands EXPR to list of gimple statements STMTS.  GIMPLE_TEST_F specifies
+the predicate that will hold for the result.  If VAR is not NULL, make the
+base variable of the final destination be VAR if suitable.  */
+tree
+force_gimple_operand_1 (tree expr, gimple_seq *stmts,
+			gimple_predicate gimple_test_f, tree var)
+{
+tree t;
+enum gimplify_status ret;
+struct gimplify_ctx gctx;
+*stmts = NULL;
+/* gimple_test_f might be more strict than is_gimple_val, make
+sure we pass both.  Just checking gimple_test_f doesn't work
+because most gimple predicates do not work recursively.  */
+if (is_gimple_val (expr)
+&& (*gimple_test_f) (expr))
+return expr;
+push_gimplify_context (&gctx);
+gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
+gimplify_ctxp->allow_rhs_cond_expr = true;
+if (var)
+expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
+if (TREE_CODE (expr) != MODIFY_EXPR
+&& TREE_TYPE (expr) == void_type_node)
+{
+gimplify_and_add (expr, stmts);
+expr = NULL_TREE;
+}
+else
+{
+ret = gimplify_expr (&expr, stmts, NULL, gimple_test_f, fb_rvalue);
+gcc_assert (ret != GS_ERROR);
+}
+if (gimple_referenced_vars (cfun))
+for (t = gimplify_ctxp->temps; t ; t = DECL_CHAIN (t))
+add_referenced_var (t);
+pop_gimplify_context (NULL);
+return expr;
+}
 /* Expands EXPR to list of gimple statements STMTS.  If SIMPLE is true,
 force the result to be either ssa_name or an invariant, otherwise
 just force it to be a rhs expression.  If VAR is not NULL, make the
 base variable of the final destination be VAR if suitable.  */
 tree
 force_gimple_operand (tree expr, gimple_seq *stmts, bool simple, tree var)
 {
-tree t;
+return force_gimple_operand_1 (expr, stmts,
-enum gimplify_status ret;
+				 simple ? is_gimple_val : is_gimple_reg_rhs,
-gimple_predicate gimple_test_f;
+				 var);
-struct gimplify_ctx gctx;
+}
-*stmts = NULL;
+/* Invokes force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
+and VAR.  If some statements are produced, emits them at GSI.
-if (is_gimple_val (expr))
+If BEFORE is true.  the statements are appended before GSI, otherwise
-return expr;
+they are appended after it.  M specifies the way GSI moves after
+insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values).  */
-gimple_test_f = simple ? is_gimple_val : is_gimple_reg_rhs;
+tree
-push_gimplify_context (&gctx);
+force_gimple_operand_gsi_1 (gimple_stmt_iterator *gsi, tree expr,
-gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
+			    gimple_predicate gimple_test_f,
-gimplify_ctxp->allow_rhs_cond_expr = true;
+			    tree var, bool before,
+			    enum gsi_iterator_update m)
-if (var)
+{
-expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
+gimple_seq stmts;
-if (TREE_CODE (expr) != MODIFY_EXPR
+expr = force_gimple_operand_1 (expr, &stmts, gimple_test_f, var);
-&& TREE_TYPE (expr) == void_type_node)
-{
+if (!gimple_seq_empty_p (stmts))
-gimplify_and_add (expr, stmts);
+{
-expr = NULL_TREE;
+if (gimple_in_ssa_p (cfun))
-}
+	{
-else
+	  gimple_stmt_iterator i;
-{
-ret = gimplify_expr (&expr, stmts, NULL, gimple_test_f, fb_rvalue);
+	  for (i = gsi_start (stmts); !gsi_end_p (i); gsi_next (&i))
-gcc_assert (ret != GS_ERROR);
+	    mark_symbols_for_renaming (gsi_stmt (i));
-}
+	}
-if (gimple_referenced_vars (cfun))
+if (before)
-for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t))
+	gsi_insert_seq_before (gsi, stmts, m);
-add_referenced_var (t);
+else
+	gsi_insert_seq_after (gsi, stmts, m);
-pop_gimplify_context (NULL);
+}
 return expr;
 }
-/* Invokes force_gimple_operand for EXPR with parameters SIMPLE_P and VAR.  If
+/* Invokes force_gimple_operand_1 for EXPR with parameter VAR.
-some statements are produced, emits them at GSI.  If BEFORE is true.
+If SIMPLE is true, force the result to be either ssa_name or an invariant,
-the statements are appended before GSI, otherwise they are appended after
+otherwise just force it to be a rhs expression.  If some statements are
-it.  M specifies the way GSI moves after insertion (GSI_SAME_STMT or
+produced, emits them at GSI.  If BEFORE is true, the statements are
-GSI_CONTINUE_LINKING are the usual values).  */
+appended before GSI, otherwise they are appended after 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,
 enum gsi_iterator_update m)
 {
-gimple_seq stmts;
+return force_gimple_operand_gsi_1 (gsi, expr,
+				     simple_p
-expr = force_gimple_operand (expr, &stmts, simple_p, var);
+				     ? is_gimple_val : is_gimple_reg_rhs,
+				     var, before, m);
-if (!gimple_seq_empty_p (stmts))
+}
-{
-if (gimple_in_ssa_p (cfun))
-{
-gimple_stmt_iterator i;
-for (i = gsi_start (stmts); !gsi_end_p (i); gsi_next (&i))
-mark_symbols_for_renaming (gsi_stmt (i));
-}
-if (before)
-gsi_insert_seq_before (gsi, stmts, m);
-else
-gsi_insert_seq_after (gsi, stmts, m);
-}
-return expr;
-}
 #include "gt-gimplify.h"

Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimplify.c @ 69:1b10fe6932e1