[PATCH] Optimize strlen/strcmp/strncmp/strncpy/fputs on ?: or comma expressions
Jakub Jelinek
jakub@redhat.com
Sat Jun 28 12:45:00 GMT 2003
On Fri, Jun 27, 2003 at 06:56:00PM -0700, Jim Wilson wrote:
> OK.
Thanks.
> Typo "si" should be "is".
>
> I notice that your COND_EXPR support uses recursive calls, but the
> COMPOUND_EXPR support does not. Maybe it should? If you have nested
> COMPOUND_EXPRs, or a COND_EXPR nested inside a COMPOUND_EXPR, your patch
> doesn't help. Not obvious if these cases matter though.
Here is what I've commited. For COMPOUND_EXPR I could use
while (TREE_CODE (src) == COMPOUND_EXPR
&& (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
{
src = TREE_OPERAND (src, 1);
STRIP_NOPS (src);
}
at the beginning of the function itself, but I think calling c_strlen there
is more readable and with tail recursion optimization the end result will be
the same.
2003-06-28 Jakub Jelinek <jakub@redhat.com>
* builtins.c (c_strlen): Add only_value argument.
Handle COND_EXPR and COMPOUND_EXPR.
(expand_builtin_strlen): Optimize also strlen (i++ ? "foo" : "bar").
Adjust c_strlen callers.
(expand_builtin_strcpy, expand_builtin_strncpy,
expand_builtin_strcmp, expand_builtin_strncmp,
expand_builtin_fputs, expand_builtin_sprintf,
fold_builtin): Adjust c_strlen callers.
* gcc.c-torture/execute/builtins/string-8.c: New test.
* gcc.c-torture/execute/builtins/string-8-lib.c: New.
* gcc.c-torture/execute/stdio-opt-1.c (main): Add new tests.
* gcc.c-torture/execute/string-opt-7.c (main): Add new test.
--- gcc/builtins.c.jj 2003-06-28 03:44:30.000000000 -0400
+++ gcc/builtins.c 2003-06-28 03:52:31.000000000 -0400
@@ -85,7 +85,7 @@ static REAL_VALUE_TYPE dconstpi;
static REAL_VALUE_TYPE dconste;
static int get_pointer_alignment (tree, unsigned int);
-static tree c_strlen (tree);
+static tree c_strlen (tree, int);
static const char *c_getstr (tree);
static rtx c_readstr (const char *, enum machine_mode);
static int target_char_cast (tree, char *);
@@ -242,19 +242,42 @@ get_pointer_alignment (tree exp, unsigne
way, because it could contain a zero byte in the middle.
TREE_STRING_LENGTH is the size of the character array, not the string.
+ ONLY_VALUE should be non-zero if the result is not going to be emitted
+ into the instruction stream and zero if it is going to be expanded.
+ E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is non-zero, constant 3
+ is returned, otherwise NULL, since
+ len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
+ evaluate the side-effects.
+
The value returned is of type `ssizetype'.
Unfortunately, string_constant can't access the values of const char
arrays with initializers, so neither can we do so here. */
static tree
-c_strlen (tree src)
+c_strlen (tree src, int only_value)
{
tree offset_node;
HOST_WIDE_INT offset;
int max;
const char *ptr;
+ STRIP_NOPS (src);
+ if (TREE_CODE (src) == COND_EXPR
+ && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
+ {
+ tree len1, len2;
+
+ len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
+ len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
+ if (tree_int_cst_equal (len1, len2))
+ return len1;
+ }
+
+ if (TREE_CODE (src) == COMPOUND_EXPR
+ && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
+ return c_strlen (TREE_OPERAND (src, 1), only_value);
+
src = string_constant (src, &offset_node);
if (src == 0)
return 0;
@@ -2176,10 +2199,22 @@ expand_builtin_strlen (tree arglist, rtx
int align;
/* If the length can be computed at compile-time, return it. */
- len = c_strlen (src);
+ len = c_strlen (src, 0);
if (len)
return expand_expr (len, target, target_mode, EXPAND_NORMAL);
+ /* If the length can be computed at compile-time and is constant
+ integer, but there are side-effects in src, evaluate
+ src for side-effects, then return len.
+ E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
+ can be optimized into: i++; x = 3; */
+ len = c_strlen (src, 1);
+ if (len && TREE_CODE (len) == INTEGER_CST)
+ {
+ expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
+ return expand_expr (len, target, target_mode, EXPAND_NORMAL);
+ }
+
align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
/* If SRC is not a pointer type, don't do this operation inline. */
@@ -2759,7 +2794,7 @@ expand_builtin_strcpy (tree arglist, rtx
return 0;
src = TREE_VALUE (TREE_CHAIN (arglist));
- len = c_strlen (src);
+ len = c_strlen (src, 1);
if (len == 0 || TREE_SIDE_EFFECTS (len))
return 0;
@@ -2802,7 +2837,7 @@ expand_builtin_stpcpy (tree arglist, rtx
because the latter will potentially produce pessimized code
when used to produce the return value. */
src = TREE_VALUE (TREE_CHAIN (arglist));
- if (! c_getstr (src) || ! (len = c_strlen (src)))
+ if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
return 0;
dst = TREE_VALUE (arglist);
@@ -2841,7 +2876,7 @@ expand_builtin_strncpy (tree arglist, rt
return 0;
else
{
- tree slen = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)));
+ tree slen = c_strlen (TREE_VALUE (TREE_CHAIN (arglist)), 1);
tree len = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist)));
tree fn;
@@ -3267,8 +3302,8 @@ expand_builtin_strcmp (tree exp, rtx tar
enum machine_mode insn_mode
= insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
- len1 = c_strlen (arg1);
- len2 = c_strlen (arg2);
+ len1 = c_strlen (arg1, 1);
+ len2 = c_strlen (arg2, 1);
if (len1)
len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
@@ -3414,8 +3449,8 @@ expand_builtin_strncmp (tree exp, rtx ta
enum machine_mode insn_mode
= insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
- len1 = c_strlen (arg1);
- len2 = c_strlen (arg2);
+ len1 = c_strlen (arg1, 1);
+ len2 = c_strlen (arg2, 1);
if (len1)
len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
@@ -4210,7 +4245,7 @@ expand_builtin_fputs (tree arglist, int
/* Get the length of the string passed to fputs. If the length
can't be determined, punt. */
- if (!(len = c_strlen (TREE_VALUE (arglist)))
+ if (!(len = c_strlen (TREE_VALUE (arglist), 1))
|| TREE_CODE (len) != INTEGER_CST)
return 0;
@@ -4549,7 +4584,7 @@ expand_builtin_sprintf (tree arglist, rt
if (target != const0_rtx)
{
- len = c_strlen (arg);
+ len = c_strlen (arg, 1);
if (! len || TREE_CODE (len) != INTEGER_CST)
return 0;
}
@@ -5441,7 +5476,7 @@ fold_builtin (tree exp)
case BUILT_IN_STRLEN:
if (validate_arglist (arglist, POINTER_TYPE, VOID_TYPE))
{
- tree len = c_strlen (TREE_VALUE (arglist));
+ tree len = c_strlen (TREE_VALUE (arglist), 0);
if (len)
{
/* Convert from the internal "sizetype" type to "size_t". */
--- gcc/testsuite/gcc.c-torture/execute/builtins/string-8-lib.c.jj 2003-06-28 03:44:53.000000000 -0400
+++ gcc/testsuite/gcc.c-torture/execute/builtins/string-8-lib.c 2003-06-28 03:44:53.000000000 -0400
@@ -0,0 +1 @@
+#include "lib/strlen.c"
--- gcc/testsuite/gcc.c-torture/execute/builtins/string-8.c.jj 2003-06-28 03:44:53.000000000 -0400
+++ gcc/testsuite/gcc.c-torture/execute/builtins/string-8.c 2003-06-28 03:44:53.000000000 -0400
@@ -0,0 +1,41 @@
+/* Copyright (C) 2003 Free Software Foundation.
+
+ Test strlen optimizations on conditional expressions.
+
+ Written by Jakub Jelinek, June 23, 2003. */
+
+typedef __SIZE_TYPE__ size_t;
+extern char *strcpy (char *, const char *);
+extern int memcmp (const void *, const void *, size_t);
+extern void abort (void);
+extern void exit (int);
+extern int inside_main;
+
+size_t g, h, i, j, k, l;
+
+size_t
+foo (void)
+{
+ if (l)
+ abort ();
+ return ++l;
+}
+
+void
+main_test (void)
+{
+ if (strlen (i ? "foo" + 1 : j ? "bar" + 1 : "baz" + 1) != 2)
+ abort ();
+ if (strlen (g++ ? "foo" : "bar") != 3 || g != 1)
+ abort ();
+ if (strlen (h++ ? "xfoo" + 1 : "bar") != 3 || h != 1)
+ abort ();
+ if (strlen ((i++, "baz")) != 3 || i != 1)
+ abort ();
+ /* The following calls might not optimize strlen call away. */
+ inside_main = 0;
+ if (strlen (j ? "foo" + k++ : "bar" + k++) != 3 || k != 1)
+ abort ();
+ if (strlen (foo () ? "foo" : "bar") != 3 || l != 1)
+ abort ();
+}
--- gcc/testsuite/gcc.c-torture/execute/stdio-opt-1.c.jj 2003-06-23 12:02:03.000000000 -0400
+++ gcc/testsuite/gcc.c-torture/execute/stdio-opt-1.c 2003-06-28 03:44:53.000000000 -0400
@@ -12,6 +12,8 @@ extern void abort(void);
If stdio.h provides one, that is okay. */
extern int fputs();
+int i;
+
int main()
{
FILE *s_array[] = {stdout, NULL}, **s_ptr = s_array;
@@ -51,6 +53,15 @@ int main()
__builtin_fputc ('\n', *s_ptr);
__builtin_fwrite ("hello\n", 1, 6, *s_ptr);
+ /* Check side-effects in conditional expression. */
+ s_ptr = s_array;
+ fputs (i++ ? "f" : "x", *s_ptr++);
+ if (s_ptr != s_array+1 || *s_ptr != 0 || i != 1)
+ abort();
+ fputs (--i ? "\n" : "\n", *--s_ptr);
+ if (s_ptr != s_array || i != 0)
+ abort();
+
return 0;
}
--- gcc/testsuite/gcc.c-torture/execute/string-opt-7.c.jj 2003-06-23 12:02:03.000000000 -0400
+++ gcc/testsuite/gcc.c-torture/execute/string-opt-7.c 2003-06-28 03:44:53.000000000 -0400
@@ -12,6 +12,8 @@ extern int strcmp (const char *, const c
extern int strncmp (const char *, const char *, size_t);
extern void *memset (void *, int, size_t);
+int i;
+
int main ()
{
const char *const src = "hello world";
@@ -62,6 +64,12 @@ int main ()
if (__builtin_strncpy (dst, src, 4) != dst || strncmp (dst, src, 4))
abort();
+ memset (dst, 0, sizeof (dst));
+ if (strncpy (dst, i++ ? "xfoo" + 1 : "bar", 4) != dst
+ || strcmp (dst, "bar")
+ || i != 1)
+ abort ();
+
return 0;
}
Jakub
More information about the Gcc-patches
mailing list