revert: ipa-cp.c (ipa_get_jf_pass_through_result): Handle unary expressions.

2016-11-10  Kugan Vivekanandarajah  <kuganv@linaro.org>

	Revert
	2016-11-09  Kugan Vivekanandarajah  <kuganv@linaro.org>

	* ipa-cp.c (ipa_get_jf_pass_through_result): Handle unary expressions.
	(propagate_vr_accross_jump_function): Likewise.
	* ipa-prop.c (ipa_set_jf_unary_pass_through): New.
	(load_from_param_1): New.
	(load_from_unmodified_param): Factor common part into load_from_param_1.
	(load_from_param): New.
	(compute_complex_assign_jump_func): Handle unary expressions.
	(ipa_write_jump_function): Likewise.
	(ipa_read_jump_function): Likewise.

From-SVN: r242032

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index c9034e8dca4efe3fd7b6469125623080bf856594..2e3819eac6e86f77420a9e6b32bd3e623192be3b 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,18 @@
+2016-11-10  Kugan Vivekanandarajah  <kuganv@linaro.org>
+
+       Revert
+       2016-11-09  Kugan Vivekanandarajah  <kuganv@linaro.org>
+
+       * ipa-cp.c (ipa_get_jf_pass_through_result): Handle unary expressions.
+       (propagate_vr_accross_jump_function): Likewise.
+       * ipa-prop.c (ipa_set_jf_unary_pass_through): New.
+       (load_from_param_1): New.
+       (load_from_unmodified_param): Factor common part into load_from_param_1.
+       (load_from_param): New.
+       (compute_complex_assign_jump_func): Handle unary expressions.
+       (ipa_write_jump_function): Likewise.
+       (ipa_read_jump_function): Likewise.
+
 2016-11-09  Segher Boessenkool  <segher@kernel.crashing.org>
 
        * simplify-rtx.c (simplify_binary_operation_1): Simplify

diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c
index 0f34682753e38d4b8e14613fc387caf14a480b92..79e621a174af8271cf917eb015f107f30832800a 100644 (file)
--- a/gcc/ipa-cp.c
+++ b/gcc/ipa-cp.c
@@ -1219,19 +1219,13 @@ ipa_get_jf_pass_through_result (struct ipa_jump_func *jfunc, tree input)
     return NULL_TREE;
 
   if (TREE_CODE_CLASS (ipa_get_jf_pass_through_operation (jfunc))
-      == tcc_unary)
-    res = fold_unary (ipa_get_jf_pass_through_operation (jfunc),
-                     TREE_TYPE (input), input);
+      == tcc_comparison)
+    restype = boolean_type_node;
   else
-    {
-      if (TREE_CODE_CLASS (ipa_get_jf_pass_through_operation (jfunc))
-         == tcc_comparison)
-       restype = boolean_type_node;
-      else
-       restype = TREE_TYPE (input);
-      res = fold_binary (ipa_get_jf_pass_through_operation (jfunc), restype,
-                        input, ipa_get_jf_pass_through_operand (jfunc));
-    }
+    restype = TREE_TYPE (input);
+  res = fold_binary (ipa_get_jf_pass_through_operation (jfunc), restype,
+                    input, ipa_get_jf_pass_through_operand (jfunc));
+
   if (res && !is_gimple_ip_invariant (res))
     return NULL_TREE;
 
@@ -1870,25 +1864,6 @@ propagate_vr_accross_jump_function (cgraph_edge *cs,
 
       if (ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR)
        return dest_lat->meet_with (src_lats->m_value_range);
-      else if (param_type
-              && (TREE_CODE_CLASS (ipa_get_jf_pass_through_operation (jfunc))
-                  == tcc_unary))
-       {
-         value_range vr;
-         memset (&vr, 0, sizeof (vr));
-         tree operand_type = ipa_get_type (caller_info, src_idx);
-         enum tree_code operation = ipa_get_jf_pass_through_operation (jfunc);
-
-         if (src_lats->m_value_range.bottom_p ())
-           return false;
-
-         extract_range_from_unary_expr (&vr,
-                                        operation,
-                                        param_type,
-                                        &src_lats->m_value_range.m_vr,
-                                        operand_type);
-         return dest_lat->meet_with (&vr);
-       }
     }
   else if (jfunc->type == IPA_JF_CONST)
     {

diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
index 8312c5a9f6baf2bd166c5967db43df081dc4ecf1..74fe199ea71a4b0ba858c47d060a5cb9441877dc 100644 (file)
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -446,18 +446,6 @@ ipa_set_jf_simple_pass_through (struct ipa_jump_func *jfunc, int formal_id,
   jfunc->value.pass_through.agg_preserved = agg_preserved;
 }
 
-/* Set JFUNC to be an unary pass through jump function.  */
-
-static void
-ipa_set_jf_unary_pass_through (struct ipa_jump_func *jfunc, int formal_id,
-                              enum tree_code operation)
-{
-  jfunc->type = IPA_JF_PASS_THROUGH;
-  jfunc->value.pass_through.operand = NULL_TREE;
-  jfunc->value.pass_through.formal_id = formal_id;
-  jfunc->value.pass_through.operation = operation;
-  jfunc->value.pass_through.agg_preserved = false;
-}
 /* Set JFUNC to be an arithmetic pass through jump function.  */
 
 static void
@@ -861,31 +849,6 @@ parm_preserved_before_stmt_p (struct ipa_func_body_info *fbi, int index,
   return !modified;
 }
 
-/* Main worker for load_from_unmodified_param and load_from_param.
-   If STMT is an assignment that loads a value from an parameter declaration,
-   return the index of the parameter in ipa_node_params.  Otherwise return -1.  */
-
-static int
-load_from_param_1 (struct ipa_func_body_info *fbi,
-                  vec<ipa_param_descriptor> descriptors,
-                  gimple *stmt)
-{
-  int index;
-  tree op1;
-
-  gcc_checking_assert (is_gimple_assign (stmt));
-  op1 = gimple_assign_rhs1 (stmt);
-  if (TREE_CODE (op1) != PARM_DECL)
-    return -1;
-
-  index = ipa_get_param_decl_index_1 (descriptors, op1);
-  if (index < 0
-      || !parm_preserved_before_stmt_p (fbi, index, stmt, op1))
-    return -1;
-
-  return index;
-}
-
 /* If STMT is an assignment that loads a value from an parameter declaration,
    return the index of the parameter in ipa_node_params which has not been
    modified.  Otherwise return -1.  */
@@ -895,29 +858,22 @@ load_from_unmodified_param (struct ipa_func_body_info *fbi,
                            vec<ipa_param_descriptor> descriptors,
                            gimple *stmt)
 {
+  int index;
+  tree op1;
+
   if (!gimple_assign_single_p (stmt))
     return -1;
 
-  return load_from_param_1 (fbi, descriptors, stmt);
-}
-
-/* If STMT is an assignment that loads a value from an parameter declaration,
-   return the index of the parameter in ipa_node_params.  Otherwise return -1.  */
-
-static int
-load_from_param (struct ipa_func_body_info *fbi,
-                vec<ipa_param_descriptor> descriptors,
-                gimple *stmt)
-{
-  if (!is_gimple_assign (stmt))
+  op1 = gimple_assign_rhs1 (stmt);
+  if (TREE_CODE (op1) != PARM_DECL)
     return -1;
 
-  enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
-  if ((get_gimple_rhs_class (rhs_code) != GIMPLE_SINGLE_RHS)
-      && (get_gimple_rhs_class (rhs_code) != GIMPLE_UNARY_RHS))
+  index = ipa_get_param_decl_index_1 (descriptors, op1);
+  if (index < 0
+      || !parm_preserved_before_stmt_p (fbi, index, stmt, op1))
     return -1;
 
-  return load_from_param_1 (fbi, descriptors, stmt);
+  return index;
 }
 
 /* Return true if memory reference REF (which must be a load through parameter
@@ -1153,7 +1109,6 @@ compute_complex_assign_jump_func (struct ipa_func_body_info *fbi,
   tree op1, tc_ssa, base, ssa;
   bool reverse;
   int index;
-  gimple *stmt2 = stmt;
 
   op1 = gimple_assign_rhs1 (stmt);
 
@@ -1162,16 +1117,13 @@ compute_complex_assign_jump_func (struct ipa_func_body_info *fbi,
       if (SSA_NAME_IS_DEFAULT_DEF (op1))
        index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
       else
-       {
-         index = load_from_param (fbi, info->descriptors,
-                                  SSA_NAME_DEF_STMT (op1));
-         stmt2 = SSA_NAME_DEF_STMT (op1);
-       }
+       index = load_from_unmodified_param (fbi, info->descriptors,
+                                           SSA_NAME_DEF_STMT (op1));
       tc_ssa = op1;
     }
   else
     {
-      index = load_from_param (fbi, info->descriptors, stmt);
+      index = load_from_unmodified_param (fbi, info->descriptors, stmt);
       tc_ssa = gimple_assign_lhs (stmt);
     }
 
@@ -1195,13 +1147,6 @@ compute_complex_assign_jump_func (struct ipa_func_body_info *fbi,
          bool agg_p = parm_ref_data_pass_through_p (fbi, index, call, tc_ssa);
          ipa_set_jf_simple_pass_through (jfunc, index, agg_p);
        }
-      else if (is_gimple_assign (stmt2)
-              && (gimple_expr_code (stmt2) != NOP_EXPR)
-              && (TREE_CODE_CLASS (gimple_expr_code (stmt2)) == tcc_unary))
-       {
-         ipa_set_jf_unary_pass_through (jfunc, index,
-                                        gimple_assign_rhs_code (stmt2));
-       }
       return;
     }
 
@@ -4721,11 +4666,6 @@ ipa_write_jump_function (struct output_block *ob,
          bp_pack_value (&bp, jump_func->value.pass_through.agg_preserved, 1);
          streamer_write_bitpack (&bp);
        }
-      else if (TREE_CODE_CLASS (jump_func->value.pass_through.operation)
-              == tcc_unary)
-       {
-         streamer_write_uhwi (ob, jump_func->value.pass_through.formal_id);
-       }
       else
        {
          stream_write_tree (ob, jump_func->value.pass_through.operand, true);
@@ -4805,11 +4745,6 @@ ipa_read_jump_function (struct lto_input_block *ib,
          bool agg_preserved = bp_unpack_value (&bp, 1);
          ipa_set_jf_simple_pass_through (jump_func, formal_id, agg_preserved);
        }
-      else if (TREE_CODE_CLASS (operation) == tcc_unary)
-       {
-         int formal_id =  streamer_read_uhwi (ib);
-         ipa_set_jf_unary_pass_through (jump_func, formal_id, operation);
-       }
       else
        {
          tree operand = stream_read_tree (ib, data_in);