Move the folding of memcmpy to memcmpy_eq to fold all builtins

This is a small cleanup by moving the optimization of memcmp to
memcmp_eq to fab from strlen pass. Since the copy of the other
part of the memcmp strlen optimization to forwprop, this was the
only thing left that strlen can do memcmp.

Note this move will cause memcmp_eq to be used for -Os too.

It also removes the optimization from strlen since both are now
handled elsewhere.

Bootstrapped and tested on x86_64-linux-gnu.

gcc/ChangeLog:

	* tree-ssa-ccp.cc (optimize_memcmp_eq): New function.
	(pass_fold_builtins::execute): Call optimize_memcmp_eq
	for memcmp.
	* tree-ssa-strlen.cc (strlen_pass::handle_builtin_memcmp): Remove.
	(strlen_pass::check_and_optimize_call): Don't call handle_builtin_memcmp.

Signed-off-by: Andrew Pinski <andrew.pinski@oss.qualcomm.com>

diff --git a/gcc/tree-ssa-ccp.cc b/gcc/tree-ssa-ccp.cc
index f33cc042e9fb6590a9fd2b2ac35e55a7e4875bf1..f16b37f193e251122f694d49fc53c03bb496a51a 100644 (file)
--- a/gcc/tree-ssa-ccp.cc
+++ b/gcc/tree-ssa-ccp.cc
@@ -155,6 +155,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "ipa-prop.h"
 #include "internal-fn.h"
 #include "gimple-range.h"
+#include "tree-ssa-strlen.h"
 
 /* Possible lattice values.  */
 typedef enum
@@ -4221,6 +4222,36 @@ public:
 
 }; // class pass_fold_builtins
 
+/* Optimize memcmp STMT into memcmp_eq if it is only used with
+   `== 0` or `!= 0`. */
+
+static void
+optimize_memcmp_eq (gcall *stmt)
+{
+  /* Make sure memcmp arguments are the correct type.  */
+  if (gimple_call_num_args (stmt) != 3)
+    return;
+  tree arg1 = gimple_call_arg (stmt, 0);
+  tree arg2 = gimple_call_arg (stmt, 1);
+  tree len = gimple_call_arg (stmt, 2);
+
+  if (!POINTER_TYPE_P (TREE_TYPE (arg1)))
+    return;
+  if (!POINTER_TYPE_P (TREE_TYPE (arg2)))
+    return;
+  if (!INTEGRAL_TYPE_P (TREE_TYPE (len)))
+    return;
+  /* The return value of the memcmp has to be used
+     equality comparison to zero. */
+  tree res = gimple_call_lhs (stmt);
+
+  if (!res || !use_in_zero_equality (res))
+    return;
+
+  gimple_call_set_fndecl (stmt, builtin_decl_explicit (BUILT_IN_MEMCMP_EQ));
+  update_stmt (stmt);
+}
+
 unsigned int
 pass_fold_builtins::execute (function *fun)
 {
@@ -4285,6 +4316,10 @@ pass_fold_builtins::execute (function *fun)
                  gsi_next (&i);
                  continue;
 
+               case BUILT_IN_MEMCMP:
+                 optimize_memcmp_eq (as_a<gcall*>(stmt));
+                 break;
+
                case BUILT_IN_UNREACHABLE:
                  if (optimize_unreachable (i))
                    cfg_changed = true;

diff --git a/gcc/tree-ssa-strlen.cc b/gcc/tree-ssa-strlen.cc
index 3cef33bf5b0795452caaa0c1049c9d6c9bc07bc3..ade8c7dcadd4692ef60a5d90f37f9ed81c4fc0ec 100644 (file)
--- a/gcc/tree-ssa-strlen.cc
+++ b/gcc/tree-ssa-strlen.cc
@@ -3971,73 +3971,6 @@ use_in_zero_equality (tree res, bool exclusive)
   return first_use;
 }
 
-/* Handle a call to memcmp.  We try to handle small comparisons by
-   converting them to load and compare, and replacing the call to memcmp
-   with a __builtin_memcmp_eq call where possible.
-   return true when call is transformed, return false otherwise.  */
-
-bool
-strlen_pass::handle_builtin_memcmp ()
-{
-  gcall *stmt = as_a <gcall *> (gsi_stmt (m_gsi));
-  tree res = gimple_call_lhs (stmt);
-
-  if (!res || !use_in_zero_equality (res))
-    return false;
-
-  tree arg1 = gimple_call_arg (stmt, 0);
-  tree arg2 = gimple_call_arg (stmt, 1);
-  tree len = gimple_call_arg (stmt, 2);
-  unsigned HOST_WIDE_INT leni;
-
-  if (tree_fits_uhwi_p (len)
-      && (leni = tree_to_uhwi (len)) <= GET_MODE_SIZE (word_mode)
-      && pow2p_hwi (leni))
-    {
-      leni *= CHAR_TYPE_SIZE;
-      unsigned align1 = get_pointer_alignment (arg1);
-      unsigned align2 = get_pointer_alignment (arg2);
-      unsigned align = MIN (align1, align2);
-      scalar_int_mode mode;
-      if (int_mode_for_size (leni, 1).exists (&mode)
-         && (align >= leni || !targetm.slow_unaligned_access (mode, align)))
-       {
-         location_t loc = gimple_location (stmt);
-         tree type, off;
-         type = build_nonstandard_integer_type (leni, 1);
-         gcc_assert (known_eq (GET_MODE_BITSIZE (TYPE_MODE (type)), leni));
-         tree ptrtype = build_pointer_type_for_mode (char_type_node,
-                                                     ptr_mode, true);
-         off = build_int_cst (ptrtype, 0);
-
-         /* Create unaligned types if needed. */
-         tree type1 = type, type2 = type;
-         if (TYPE_ALIGN (type1) > align1)
-           type1 = build_aligned_type (type1, align1);
-         if (TYPE_ALIGN (type2) > align2)
-           type2 = build_aligned_type (type2, align2);
-
-         arg1 = build2_loc (loc, MEM_REF, type1, arg1, off);
-         arg2 = build2_loc (loc, MEM_REF, type2, arg2, off);
-         tree tem1 = fold_const_aggregate_ref (arg1);
-         if (tem1)
-           arg1 = tem1;
-         tree tem2 = fold_const_aggregate_ref (arg2);
-         if (tem2)
-           arg2 = tem2;
-         res = fold_convert_loc (loc, TREE_TYPE (res),
-                                 fold_build2_loc (loc, NE_EXPR,
-                                                  boolean_type_node,
-                                                  arg1, arg2));
-         gimplify_and_update_call_from_tree (&m_gsi, res);
-         return true;
-       }
-    }
-
-  gimple_call_set_fndecl (stmt, builtin_decl_explicit (BUILT_IN_MEMCMP_EQ));
-  return true;
-}
-
 /* Given strinfo IDX for ARG, sets LENRNG[] to the range of lengths
    of the string(s) referenced by ARG if it can be determined.
    If the length cannot be determined, sets *SIZE to the size of
@@ -5528,10 +5461,6 @@ strlen_pass::check_and_optimize_call (bool *zero_write)
       if (handle_builtin_memset (zero_write))
        return false;
       break;
-    case BUILT_IN_MEMCMP:
-      if (handle_builtin_memcmp ())
-       return false;
-      break;
     case BUILT_IN_STRCMP:
     case BUILT_IN_STRNCMP:
       if (handle_builtin_string_cmp ())