[Bug tree-optimization/97260] New: memcmp of constant string and local constant array not folded

[Bug tree-optimization/97260] New: memcmp of constant string and local constant array not folded

[msebor at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

            Bug ID: 97260
           Summary: memcmp of constant string and local constant array not
                    folded
           Product: gcc
           Version: 11.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: tree-optimization
          Assignee: unassigned at gcc dot gnu.org
          Reporter: msebor at gcc dot gnu.org
  Target Milestone: ---

GCC fails to fold the memcmp call below into a constant.  Clang folds it
successfully.

$ cat x.c && gcc -O2 -S -Wall -Wextra -fdump-tree-optimized=/dev/stdout
-o/dev/stdout x.c
int f (void)
{
  const char a[] = "1234";
  return __builtin_memcmp (a, "1234", 4);
}
        .file   "x.c"
        .text

;; Function f (f, funcdef_no=0, decl_uid=1931, cgraph_uid=1, symbol_order=0)

f ()
{
  const char a[5];
  int _3;

  <bb 2> [local count: 1073741824]:
  a = "1234";
  _3 = __builtin_memcmp (&a, "1234", 4);
  a ={v} {CLOBBER};
  return _3;

}


        .section        .rodata.str1.1,"aMS",@progbits,1
.LC0:
        .string "1234"
        .text
        .p2align 4
        .globl  f
        .type   f, @function
f:
.LFB0:
        .cfi_startproc
        subq    $24, %rsp
        .cfi_def_cfa_offset 32
        movl    $4, %edx
        movl    $.LC0, %esi
        leaq    11(%rsp), %rdi
        movl    $875770417, 11(%rsp)
        movb    $0, 15(%rsp)
        call    memcmp
        addq    $24, %rsp
        .cfi_def_cfa_offset 8
        ret
        .cfi_endproc
.LFE0:
        .size   f, .-f
        .ident  "GCC: (GNU) 11.0.0 20200930 (experimental)"
        .section        .note.GNU-stack,"",@progbits

[Bug tree-optimization/97260] [9/10/11 regression] memcmp of constant string and local constant array not folded

[msebor at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

Martin Sebor <msebor at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
      Known to work|                            |4.8.5
      Known to fail|                            |10.2.0, 11.0, 9.3.0
             Blocks|                            |83819
            Summary|memcmp of constant string   |[9/10/11 regression] memcmp
                   |and local constant array    |of constant string and
                   |not folded                  |local constant array not
                   |                            |folded

--- Comment #1 from Martin Sebor <msebor at gcc dot gnu.org> ---
It appears that GCC was able to fold such calls until version 4.8.  Starting
with 4.9 it can't anymore.


Referenced Bugs:

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83819
[Bug 83819] [meta-bug] missing strlen optimizations

[Bug tree-optimization/97260] [9/10/11 regression] memcmp of constant string and local constant array not folded

[msebor at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

--- Comment #2 from Martin Sebor <msebor at gcc dot gnu.org> ---
Bisection points to r200211 as the first commit after which the call wasn't
folded:

commit 6a6dac5293ee21d9aed0d394a0cb23948bb1efad
Author: Jan Hubicka <jh@suse.cz>
Date:   Wed Jun 19 20:06:12 2013 +0200

    cgraph.h (const_value_known_p): Replace by ...


            * cgraph.h (const_value_known_p): Replace by ...
            (ctor_for_folding): .. this one.
            * cgraphunit.c (process_function_and_variable_attributes): Use it.
            * lto-cgraph.c (compute_ltrans_boundary): Use ctor_for_folding.
            * expr.c (expand_expr_real_1): Likewise.
            (string_constant): Likewise.
            * tree-ssa-loop-ivcanon.c (constant_after_peeling): Likewise.
            * ipa.c (process_references): Likewise.
            (symtab_remove_unreachable_nodes): Likewise.
            * ipa-inline-analysis.c (param_change_prob): Likewise.
            * gimple-fold.c (canonicalize_constructor_val): Likewise.
            (get_base_constructor): Likwise.
            * varpool.c (varpool_remove_node): Likewise.
            (varpool_remove_initializer): LIkewise.
            (dump_varpool_node): LIkwise.
            (const_value_known_p): Rewrite to ...
            (ctor_for_folding): ... this one.

            * lto-partition.c (add_references_to_partition): Use
            ctor_for_folding.

            * gcc.dg/tree-ssa/attr-alias-2.c: New testcase.

    From-SVN: r200211

[Bug tree-optimization/97260] [9/10/11 regression] memcmp of constant string and local constant array not folded

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
     Ever confirmed|0                           |1
           Keywords|                            |missed-optimization
             Status|UNCONFIRMED                 |NEW
   Target Milestone|---                         |9.4
   Last reconfirmed|                            |2020-10-01

--- Comment #3 from Richard Biener <rguenth at gcc dot gnu.org> ---
  const char a[5];
  int _3;

  <bb 2> [local count: 1073741824]:
  a = "1234";
  _3 = __builtin_memcmp (&a, "1234", 4);

so somehow the const initializer is no longer visible here that makes it
impossible for the generic folding machinery to pick up the opportunity.

I guess 4.8 folded it in GENERIC before the gimplifier(?) lowered the
const initializer.

In particular we're still calling fold_builtin_memcmp via

#0  fold_builtin_memcmp (loc=266991, arg1=<nop_expr 0x7ffff694b1c0>, 
    arg2=<nop_expr 0x7ffff694b1e0>, len=<integer_cst 0x7ffff6941fc0>)
    at /home/rguenther/src/gcc3/gcc/builtins.c:9799
#1  0x0000000000ba58dc in fold_builtin_3 (loc=266991, 
    fndecl=<function_decl 0x7ffff68b8500 __builtin_memcmp>, 
    arg0=<nop_expr 0x7ffff694b1c0>, arg1=<nop_expr 0x7ffff694b1e0>, 
    arg2=<integer_cst 0x7ffff6941fc0>)
    at /home/rguenther/src/gcc3/gcc/builtins.c:10844
#2  0x0000000000ba5a31 in fold_builtin_n (loc=266991, expr=<tree 0x0>, 
    fndecl=<function_decl 0x7ffff68b8500 __builtin_memcmp>, 
    args=0x7ffff6939cd8, nargs=3)
    at /home/rguenther/src/gcc3/gcc/builtins.c:10907
#3  0x0000000000ba61dc in fold_builtin_call_array (loc=266991, 
    fn=<addr_expr 0x7ffff694b1a0>, n=3, argarray=0x7ffff6939cd8)
    at /home/rguenther/src/gcc3/gcc/builtins.c:11040
#4  0x0000000000e2cc44 in fold_build_call_array_loc (loc=266991, 
    type=<integer_type 0x7ffff68255e8 int>, fn=<addr_expr 0x7ffff694b1a0>, 
    nargs=3, argarray=0x7ffff6939cd8)
    at /home/rguenther/src/gcc3/gcc/fold-const.c:13373
#5  0x00000000009f4434 in build_function_call_vec (loc=266991, arg_loc=..., 
    function=<addr_expr 0x7ffff694b1a0>, params=0x7ffff6939cd0 = {...}, 
    origtypes=0x7ffff6939cf8 = {...}, 
    orig_fundecl=<function_decl 0x7ffff68b8500 __builtin_memcmp>)
    at /home/rguenther/src/gcc3/gcc/c/c-typeck.c:3151
#6  0x00000000009f4a3b in c_build_function_call_vec (loc=266991, arg_loc=..., 
    function=<function_decl 0x7ffff68b8500 __builtin_memcmp>, 
    params=0x7ffff6939cd0 = {...}, origtypes=0x7ffff6939cf8 = {...})
    at /home/rguenther/src/gcc3/gcc/c/c-typeck.c:3206
#7  0x0000000000a4ec6b in c_parser_postfix_expression_after_primary (
    parser=0x7ffff7ff5ab0, expr_loc=266991, expr=...)
    at /home/rguenther/src/gcc3/gcc/c/c-parser.c:10549
#8  0x0000000000a4dbec in c_parser_postfix_expression (parser=0x7ffff7ff5ab0)
    at /home/rguenther/src/gcc3/gcc/c/c-parser.c:10222
#9  0x0000000000a4730e in c_parser_unary_expression (parser=0x7ffff7ff5ab0)
    at /home/rguenther/src/gcc3/gcc/c/c-parser.c:8315
#10 0x0000000000a467fc in c_parser_cast_expression (parser=0x7ffff7ff5ab0, 
    after=0x0) at /home/rguenther/src/gcc3/gcc/c/c-parser.c:8154
#11 0x0000000000a44e7a in c_parser_binary_expression (parser=0x7ffff7ff5ab0, 
    after=0x0, omp_atomic_lhs=<tree 0x0>)
    at /home/rguenther/src/gcc3/gcc/c/c-parser.c:7957
#12 0x0000000000a4466d in c_parser_conditional_expression (
    parser=0x7ffff7ff5ab0, after=0x0, omp_atomic_lhs=<tree 0x0>)
    at /home/rguenther/src/gcc3/gcc/c/c-parser.c:7691

but that doesn't do anything fancy, in particular

  /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
  if (operand_equal_p (arg1, arg2, 0))
    return omit_one_operand_loc (loc, integer_type_node, integer_zero_node,
len);

doesn't trigger on

(gdb) p debug_generic_expr (arg1)
(const void *) &a
$2 = void
(gdb) p debug_generic_expr (arg2)
(const void *) "1234"
$3 = void

        arg:0 <var_decl 0x7ffff7ff5b40 a type <array_type 0x7ffff6945738>
            readonly addressable used read BLK t5.c:3:14
            size <integer_cst 0x7ffff6941f90 constant 40>
            unit-size <integer_cst 0x7ffff6941f60 constant 5>
            align:8 warn_if_not_align:0 context <function_decl 0x7ffff693d600
f> initial <string_cst 0x7ffff694b0a0>>

and the gimplifier already produces

f ()
{
  int D.1935;
  const char a[5];

  try
    {
      a = "1234";
      D.1935 = __builtin_memcmp (&a, "1234", 4);
      return D.1935;
    }
  finally
    {
      a = {CLOBBER};
    }
}

so iff then this is something for the strlen opt pass which tracks
stores and it becomes sth like

int f (void)
{
  char a[] = "5678910";
  memcpy (a, "1234", 4);
  return __builtin_memcmp (a, "1234", 4);
}

which isn't folded either.

[Bug tree-optimization/97260] [9/10/11 regression] memcmp of constant string and local constant array not folded

[msebor at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

--- Comment #4 from Martin Sebor <msebor at gcc dot gnu.org> ---
It should be possible to handle in the strlen pass.

[Bug tree-optimization/97260] [9/10/11 regression] memcmp of constant string and local constant array not folded

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Priority|P3                          |P2

[Bug tree-optimization/97260] [9/10/11 regression] memcmp of constant string and local constant array not folded

[jakub at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jakub at gcc dot gnu.org

--- Comment #5 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
So, can't we just restore back the folding in the FE to get rid of the
regression, e.g. by (completely untested so far):
--- gcc/varpool.c.jj    2021-01-04 10:25:37.347250651 +0100
+++ gcc/varpool.c       2021-01-25 16:35:58.475198684 +0100
@@ -412,6 +412,12 @@ ctor_for_folding (tree decl)
   if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
     {
       gcc_assert (!TREE_PUBLIC (decl));
+      /* Unless this is called during FE folding.  */
+      if (!in_gimple_form
+         && TREE_READONLY (decl)
+         && !TREE_SIDE_EFFECTS (decl)
+         && DECL_INITIAL (decl))
+       return DECL_INITIAL (decl);
       return error_mark_node;
     }

As for strlen pass, it has currently infrastructure only for tracking 0 vs.
non-zero byte length, not exact constant bytes pointed by each pointer, that
would make the pass significantly more expensive.
Sure, we could have some hacks to handle some common cases where a variable is
initialized just once by some string literal or other constant byte sequence
and then never modified later, but that doesn't look like GCC 11 material.

[Bug tree-optimization/97260] [9/10/11 regression] memcmp of constant string and local constant array not folded

[cvs-commit at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

--- Comment #6 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Jakub Jelinek <jakub@gcc.gnu.org>:

https://gcc.gnu.org/g:efc9ccbfd0ca4da6bf0aba913df6f77f56044dc2

commit r11-6922-gefc9ccbfd0ca4da6bf0aba913df6f77f56044dc2
Author: Jakub Jelinek <jakub@redhat.com>
Date:   Wed Jan 27 10:08:46 2021 +0100

    varpool: Restore GENERIC TREE_READONLY automatic var optimization [PR7260]

    In 4.8 and earlier we used to fold the following to 0 during GENERIC
folding,
    but we don't do that anymore because ctor_for_folding etc. has been turned
into a
    GIMPLE centric API, but as the testcase shows, it is invoked even during
    GENERIC folding and there the automatic vars still should have meaningful
    initializers.  I've verified that the C++ FE drops TREE_READONLY on
    automatic vars with const qualified types if they require non-constant
    (runtime) initialization.

    2021-01-27  Jakub Jelinek  <jakub@redhat.com>

            PR tree-optimization/97260
            * varpool.c: Include tree-pass.h.
            (ctor_for_folding): In GENERIC return DECL_INITIAL for
TREE_READONLY
            non-TREE_SIDE_EFFECTS automatic variables.

            * gcc.dg/tree-ssa/pr97260.c: New test.

[Bug tree-optimization/97260] [9/10 regression] memcmp of constant string and local constant array not folded

[jakub at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
            Summary|[9/10/11 regression] memcmp |[9/10 regression] memcmp of
                   |of constant string and      |constant string and local
                   |local constant array not    |constant array not folded
                   |folded                      |

--- Comment #7 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Fixed on the trunk.  For possible GIMPLE optimizations we should clone this PR
I'd say and we shouldn't backport this fix.

[Bug tree-optimization/97260] [9/10 regression] memcmp of constant string and local constant array not folded

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|9.4                         |9.5

--- Comment #8 from Richard Biener <rguenth at gcc dot gnu.org> ---
GCC 9.4 is being released, retargeting bugs to GCC 9.5.

[Bug tree-optimization/97260] [10 regression] memcmp of constant string and local constant array not folded

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|9.5                         |10.4

--- Comment #9 from Richard Biener <rguenth at gcc dot gnu.org> ---
GCC 9 branch is being closed

[Bug tree-optimization/97260] [10 regression] memcmp of constant string and local constant array not folded

[jakub at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|10.4                        |10.5

--- Comment #10 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
GCC 10.4 is being released, retargeting bugs to GCC 10.5.

[Bug tree-optimization/97260] [10 regression] memcmp of constant string and local constant array not folded

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97260

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
      Known to fail|                            |10.5.0
      Known to work|                            |11.1.0
   Target Milestone|10.5                        |11.0
         Resolution|---                         |FIXED
             Status|NEW                         |RESOLVED

--- Comment #11 from Richard Biener <rguenth at gcc dot gnu.org> ---
Fixed in GCC 11.