* gimplify.c (gimplify_cond_expr): Use THEN_ and ELSE_ local variables.

	Use VOID_TYPE_P for all void type tests.  Adjust TYPE variable instead
	of shadowing it.  Fix comments.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@158737 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 07f7629..7d15bf0 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,9 @@
+2010-04-26  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gimplify.c (gimplify_cond_expr): Use THEN_ and ELSE_ local variables.
+       Use VOID_TYPE_P for all void type tests.  Adjust TYPE variable instead
+       of shadowing it.  Fix comments.
+
 2010-04-26  Jan Hubicka  <jh@suse.cz>
 
        * cgraph.c (cgraph_create_node): Set node frequency to normal.
@@ -8,15 +14,19 @@
        * lto-cgraph.c (lto_output_node): Output node frequency.
        (input_overwrite_node): Input node frequency.
        * tre-ssa-loop-ivopts (computation_cost): Update.
-       * lto-streamer-out.c (output_function): Do not output function frequency.
-       * predict.c (maybe_hot_frequency_p): Update and handle functions executed once.
+       * lto-streamer-out.c (output_function): Do not output function
+       frequency.
+       * predict.c (maybe_hot_frequency_p): Update and handle functions
+       executed once.
        (cgraph_maybe_hot_edge_p): Likewise; use cgraph frequency instead of
        attribute lookup.
        (probably_never_executed_bb_p, optimize_function_for_size_p): Update.
-       (compute_function_frequency): Set noreturn functions to be executed once.
+       (compute_function_frequency): Set noreturn functions to be executed
+       once.
        (choose_function_section): Update.
        * lto-streamer-in.c (input_function): Do not input function frequency.
-       * function.c (allocate_struct_function): Do not initialize function frequency.
+       * function.c (allocate_struct_function): Do not initialize function
+       frequency.
        * function.h (function_frequency): Remove.
        (struct function): Remove function frequency.
        * ipa-profile.c (CGRAPH_NODE_FREQUENCY): Remove.

diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 287d621..2f4e120 100644 (file)
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -2867,71 +2867,67 @@ 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
-        an addressable temporary.  */
-      if (((fallback & fb_rvalue)
-          || !(fallback & fb_lvalue))
+      /* If either an rvalue is ok or we do not require an lvalue, create the
+        temporary.  But we cannot do that if the type is addressable.  */
+      if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
          && !TREE_ADDRESSABLE (type))
        {
          if (gimplify_ctxp->allow_rhs_cond_expr
              /* If either branch has side effects or could trap, it can't be
                 evaluated unconditionally.  */
-             && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1))
-             && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 1))
-             && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 2))
-             && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 2)))
+             && !TREE_SIDE_EFFECTS (then_)
+             && !generic_expr_could_trap_p (then_)
+             && !TREE_SIDE_EFFECTS (else_)
+             && !generic_expr_could_trap_p (else_))
            return gimplify_pure_cond_expr (expr_p, pre_p);
 
-         result = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
-         ret = GS_ALL_DONE;
+         tmp = create_tmp_var (type, "iftmp");
+         result = tmp;
        }
+
+      /* Otherwise, only create and copy references to the values.  */
       else
        {
-         tree type = build_pointer_type (TREE_TYPE (expr));
+         type = build_pointer_type (type);
 
-         if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
-           TREE_OPERAND (expr, 1) =
-             build_fold_addr_expr_loc (loc, TREE_OPERAND (expr, 1));
+         if (!VOID_TYPE_P (TREE_TYPE (then_)))
+           then_ = build_fold_addr_expr_loc (loc, then_);
 
-         if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
-           TREE_OPERAND (expr, 2) =
-             build_fold_addr_expr_loc (loc, TREE_OPERAND (expr, 2));
+         if (!VOID_TYPE_P (TREE_TYPE (else_)))
+           else_ = build_fold_addr_expr_loc (loc, else_);
+ 
+         expr
+           = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
 
          tmp = create_tmp_var (type, "iftmp");
-
-         expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
-                        TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
-
          result = build_fold_indirect_ref_loc (loc, tmp);
        }
 
-      /* Build the then clause, 't1 = a;'.  But don't build an assignment
-        if this branch is void; in C++ it can be, if it's a throw.  */
-      if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
-       TREE_OPERAND (expr, 1)
-         = build2 (MODIFY_EXPR, TREE_TYPE (tmp), tmp, TREE_OPERAND (expr, 1));
+      /* 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_)))
+       TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
 
-      /* 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));
+      /* Similarly, build the new else clause, `tmp = else_;'.  */
+      if (!VOID_TYPE_P (TREE_TYPE (else_)))
+       TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
 
       TREE_TYPE (expr) = void_type_node;
       recalculate_side_effects (expr);