On 10/07/2016 01:01 PM, Richard Biener wrote:
> On Fri, Oct 7, 2016 at 10:41 AM, Martin Liška <[email protected]> wrote:
>> Resending the patch, where I implemented folding in gimple-fold.c
>>
>> Patch can bootstrap on ppc64le-redhat-linux and survives regression tests.
>
> +/* Fold a call to the str{n}{case}cmp builtin pointed by GSI iterator.
> + FCODE is the name of the builtin. */
>
> wrong comment
Fixed.
>
> +static bool
> +gimple_fold_builtin_memchr (gimple_stmt_iterator *gsi)
>
> + {
> + replace_call_with_value (gsi, build_int_cst (type, 0));
>
> use ptr_type_node (void *) instead of type here and below.
Done.
>
> + HOST_WIDE_INT offset = r - p1;
> + if (compare_tree_int (len, offset) <= 0)
> + {
>
> == 0 can occur in which case we have to return a pointer to the
> first char. I think len < offset can't happen with memchr?
Here I reworked the patch as it's not desired to trigger an undefined behavior
in a host compiler for cases like: memchr ("", 'x', 5). Thus I switched to
strchr
and aforementioned hunk would make sense.
>
> + replace_call_with_value (gsi, build_int_cst (type, 0));
> + return true;
> + }
> + else
> + {
> + tree temp = fold_build_pointer_plus_hwi_loc (loc, arg1, offset);
> + replace_call_with_value (gsi, temp);
>
> That yields valid GIMPLE by chance, I'd prefer if you'd built that to a
> stmt and use the replace-with-vops.
Done.
Apart from that I added handling of lhs and the patch supports folding
of CFN_BUILT_IN_MEMCHR.
One question that comes to my mind is whether there's a possibility
to fully test gimple folding of all cases if some of them are already
eaten by generic folding?
Tests of the series have been running.
Martin
>
> + return true;
> + }
>
>
>> Ready to be installed?
>> Martin
>From 37133bb09ddb23c87bb41ea6fffd5eba5af528fd Mon Sep 17 00:00:00 2001
From: marxin <[email protected]>
Date: Thu, 6 Oct 2016 17:52:45 +0200
Subject: [PATCH 4/5] Fold __builtin_memchr function
gcc/ChangeLog:
2016-10-06 Martin Liska <[email protected]>
* builtins.h(target_char_cst_p): Declare the function.
* builtins.c (fold_builtin_memchr): Remove.
(target_char_cst_p): Move the function from gimple-fold.c.
(fold_builtin_3): Do not call the function.
* gimple-fold.c (gimple_fold_builtin_memchr): New function.
(gimple_fold_builtin): Call the function.
* fold-const-call.c (fold_const_call_1): Handle CFN_BUILT_IN_MEMCHR.
---
gcc/builtins.c | 59 +++++++++---------------------------
gcc/builtins.h | 1 +
gcc/fold-const-call.c | 30 ++++++++++++++++++
gcc/gimple-fold.c | 84 ++++++++++++++++++++++++++++++++++++++++++---------
4 files changed, 115 insertions(+), 59 deletions(-)
diff --git a/gcc/builtins.c b/gcc/builtins.c
index 6696f28..385e78e0 100644
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -148,7 +148,6 @@ static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
static bool validate_arg (const_tree, enum tree_code code);
static rtx expand_builtin_fabs (tree, rtx, rtx);
static rtx expand_builtin_signbit (tree, rtx);
-static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
static tree fold_builtin_memcmp (location_t, tree, tree, tree);
static tree fold_builtin_isascii (location_t, tree);
static tree fold_builtin_toascii (location_t, tree);
@@ -7244,47 +7243,6 @@ fold_builtin_sincos (location_t loc,
fold_build1_loc (loc, REALPART_EXPR, type, call)));
}
-/* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the
- arguments to the call, and TYPE is its return type.
- Return NULL_TREE if no simplification can be made. */
-
-static tree
-fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
-{
- if (!validate_arg (arg1, POINTER_TYPE)
- || !validate_arg (arg2, INTEGER_TYPE)
- || !validate_arg (len, INTEGER_TYPE))
- return NULL_TREE;
- else
- {
- const char *p1;
-
- if (TREE_CODE (arg2) != INTEGER_CST
- || !tree_fits_uhwi_p (len))
- return NULL_TREE;
-
- p1 = c_getstr (arg1);
- if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
- {
- char c;
- const char *r;
- tree tem;
-
- if (target_char_cast (arg2, &c))
- return NULL_TREE;
-
- r = (const char *) memchr (p1, c, tree_to_uhwi (len));
-
- if (r == NULL)
- return build_int_cst (TREE_TYPE (arg1), 0);
-
- tem = fold_build_pointer_plus_hwi_loc (loc, arg1, r - p1);
- return fold_convert_loc (loc, type, tem);
- }
- return NULL_TREE;
- }
-}
-
/* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
Return NULL_TREE if no simplification can be made. */
@@ -8340,9 +8298,6 @@ fold_builtin_3 (location_t loc, tree fndecl,
return do_mpfr_remquo (arg0, arg1, arg2);
break;
- case BUILT_IN_MEMCHR:
- return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
-
case BUILT_IN_BCMP:
case BUILT_IN_MEMCMP:
return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
@@ -9908,3 +9863,17 @@ is_inexpensive_builtin (tree decl)
return false;
}
+
+/* Return true if T is a constant and the value cast to a target char
+ can be represented by a host char.
+ Store the casted char constant in *P if so. */
+
+bool
+target_char_cst_p (tree t, char *p)
+{
+ if (!tree_fits_uhwi_p (t) || CHAR_TYPE_SIZE != HOST_BITS_PER_CHAR)
+ return false;
+
+ *p = (char)tree_to_uhwi (t);
+ return true;
+}
diff --git a/gcc/builtins.h b/gcc/builtins.h
index 8d0acd0..5e83646 100644
--- a/gcc/builtins.h
+++ b/gcc/builtins.h
@@ -97,6 +97,7 @@ extern unsigned HOST_WIDE_INT target_percent;
extern char target_percent_s[3];
extern char target_percent_c[3];
extern char target_percent_s_newline[4];
+extern bool target_char_cst_p (tree t, char *p);
extern internal_fn associated_internal_fn (tree);
extern internal_fn replacement_internal_fn (gcall *);
diff --git a/gcc/fold-const-call.c b/gcc/fold-const-call.c
index bbec177..3cfab5b 100644
--- a/gcc/fold-const-call.c
+++ b/gcc/fold-const-call.c
@@ -28,6 +28,7 @@ along with GCC; see the file COPYING3. If not see
#include "fold-const-call.h"
#include "case-cfn-macros.h"
#include "tm.h" /* For C[LT]Z_DEFINED_AT_ZERO. */
+#include "builtins.h"
/* Functions that test for certain constant types, abstracting away the
decision about whether to check for overflow. */
@@ -1463,6 +1464,35 @@ fold_const_call_1 (combined_fn fn, tree type, tree arg0, tree arg1, tree arg2)
return NULL_TREE;
}
+ switch (fn)
+ {
+ case CFN_BUILT_IN_MEMCHR:
+ {
+ char c;
+ const char *r;
+ if (integer_zerop (arg2))
+ return build_int_cst (type, 0);
+
+ const char *p1 = c_getstr (arg0);
+ if (!tree_fits_uhwi_p (arg2) || !p1 || !target_char_cst_p (arg1, &c))
+ return NULL_TREE;
+
+ r = (const char *)strchr (p1, c);
+
+ if (r == NULL)
+ return build_int_cst (type, 0);
+ else
+ {
+ HOST_WIDE_INT offset = r - p1;
+ if (compare_tree_int (arg2, offset) <= 0)
+ return build_int_cst (type, 0);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+
return NULL_TREE;
}
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index f892d7e..87464af 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -57,20 +57,6 @@ along with GCC; see the file COPYING3. If not see
#include "tree-cfg.h"
#include "fold-const-call.h"
-/* Return true if T is a constant and the value cast to a target char
- can be represented by a host char.
- Store the casted char constant in *P if so. */
-
-static bool
-target_char_cst_p (tree t, char *p)
-{
- if (!tree_fits_uhwi_p (t) || CHAR_TYPE_SIZE != HOST_BITS_PER_CHAR)
- return false;
-
- *p = (char)tree_to_uhwi (t);
- return true;
-}
-
/* Return true when DECL can be referenced from current unit.
FROM_DECL (if non-null) specify constructor of variable DECL was taken from.
We can get declarations that are not possible to reference for various
@@ -1962,6 +1948,74 @@ gimple_fold_builtin_string_compare (gimple_stmt_iterator *gsi)
return false;
}
+/* Fold a call to the memchr pointed by GSI iterator. */
+
+static bool
+gimple_fold_builtin_memchr (gimple_stmt_iterator *gsi)
+{
+ gimple *stmt = gsi_stmt (*gsi);
+ tree lhs = gimple_call_lhs (stmt);
+ tree arg1 = gimple_call_arg (stmt, 0);
+ tree arg2 = gimple_call_arg (stmt, 1);
+ tree len = gimple_call_arg (stmt, 2);
+
+ /* If the LEN parameter is zero, return zero. */
+ if (integer_zerop (len))
+ {
+ replace_call_with_value (gsi, build_int_cst (ptr_type_node, 0));
+ return true;
+ }
+
+ if (TREE_CODE (arg2) != INTEGER_CST
+ || !tree_fits_uhwi_p (len))
+ return false;
+
+ const char *p1 = c_getstr (arg1);
+ if (p1)
+ {
+ char c;
+ const char *r;
+
+ if (!target_char_cst_p (arg2, &c))
+ return false;
+
+ r = (const char *)strchr (p1, c);
+
+ if (r == NULL)
+ {
+ replace_call_with_value (gsi, build_int_cst (ptr_type_node, 0));
+ return true;
+ }
+ else
+ {
+ HOST_WIDE_INT offset = r - p1;
+ if (compare_tree_int (len, offset) <= 0)
+ {
+ replace_call_with_value (gsi, build_int_cst (ptr_type_node, 0));
+ return true;
+ }
+ else
+ {
+ gimple_seq stmts = NULL;
+ if (lhs != NULL_TREE)
+ {
+ tree offset_cst = build_int_cst (TREE_TYPE (len), offset);
+ gassign *stmt = gimple_build_assign (lhs, POINTER_PLUS_EXPR,
+ arg1, offset_cst);
+ gimple_seq_add_stmt_without_update (&stmts, stmt);
+ }
+ else
+ gimple_seq_add_stmt_without_update (&stmts,
+ gimple_build_nop ());
+
+ gsi_replace_with_seq_vops (gsi, stmts);
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
/* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
to the call. IGNORE is true if the value returned
@@ -3189,6 +3243,8 @@ gimple_fold_builtin (gimple_stmt_iterator *gsi)
case BUILT_IN_STRNCMP:
case BUILT_IN_STRNCASECMP:
return gimple_fold_builtin_string_compare (gsi);
+ case BUILT_IN_MEMCHR:
+ return gimple_fold_builtin_memchr (gsi);
case BUILT_IN_FPUTS:
return gimple_fold_builtin_fputs (gsi, gimple_call_arg (stmt, 0),
gimple_call_arg (stmt, 1), false);
--
2.9.2
