[Bug tree-optimization/105329] [12/13 Regression] Bogus restrict warning when assigning 1-char string literal to std::string since r12-3347-g8af8abfbbace49e6

["rguenth at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |rguenth at gcc dot gnu.org
   Target Milestone|---                         |12.0

--- Comment #8 from Richard Biener <rguenth at gcc dot gnu.org> ---
Btw, requires -std=c++20 but -O2 is enough, -O3 not needed.

To quote again:

if (_22 >= &MEM <const char[2]> [(void *)"5" + 1B])
  goto <bb 10>; [50.00%]
else
  goto <bb 11>; [50.00%]

<bb 11> [local count: 44944954]:
if (_22 <= "5")
  goto <bb 12>; [50.00%]
else
  goto <bb 13>; [50.00%]

<bb 13> [local count: 22472477]:
_48 = _22 - "5";
if (_48 == 1)
  goto <bb 14>; [34.00%]
else
  goto <bb 15>; [66.00%]

the "simple" thing we fail to thread is

  if (_22 >= _1 + 1)
    ;
  else
    {
       if (_22 <= _1)
          ; // this must be true, _22 < _1 is true even
    }

in fact we fail to canonicalize _22 >= &MEM <const char[2]> [(void *)"5" + 1B]
to _22 > "5".  fold_comparison via maybe_canonicalize_comparison does such
thing but not for pointers or &MEM.

The following (too special) simplifies the above to

  <bb 9> [local count: 89889908]:
  if (_22 > &MEM <const char[2]> [(void *)"5"])
    goto <bb 10>; [50.00%]
  else
    goto <bb 11>; [50.00%]

  <bb 11> [local count: 44944954]:
  if (_22 <= "5")
    goto <bb 12>; [50.00%]
  else
    goto <bb 13>; [50.00%]

but we still won't simplify the second compare.

diff --git a/gcc/match.pd b/gcc/match.pd
index 6d691d302b3..cb16694a150 100644
--- a/gcc/match.pd
+++ b/gcc/match.pd
@@ -5397,6 +5397,18 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT)
        (if (known_eq (off, 0))
         { constant_boolean_node (cmp == EQ_EXPR, type); }))))))))

+(for cmp (ge le)
+     cmpp (gt lt)
+ (simplify
+  (cmp:c @0 addr@1)
+  (with
+    { tree m = TREE_OPERAND (@1, 0); }
+    (if (TREE_CODE (m) == MEM_REF
+        && integer_onep (TREE_OPERAND (m, 1)))
+     (cmpp @0 { build1 (ADDR_EXPR, TREE_TYPE (@1),
+                       build2 (MEM_REF, TREE_TYPE (m), TREE_OPERAND (m, 0),
+                               build_zero_cst (TREE_TYPE (TREE_OPERAND (m,
1))))); })))))
+
 /* Equality compare simplifications from fold_binary  */
 (for cmp (eq ne)


The ifcombine eventually arrives in

Breakpoint 5, tree_ssa_ifcombine_bb_1 (inner_cond_bb=<basic_block
0x7ffff463bf08 (11)>, outer_cond_bb=<basic_block 0x7ffff4740af8 (9)>,
then_bb=<basic_block 0x7ffff463bf70 (12)>, else_bb=<basic_block 0x7ffff47728f0
(13)>, phi_pred_bb=<basic_block 0x7ffff463bf08 (11)>) at
/home/rguenther/src/gcc-12-branch/gcc/tree-ssa-ifcombine.cc:646
646       if (phi_pred_bb != else_bb
<bb 9> [local count: 89889908]:
if (_22 > &MEM <const char[2]> [(void *)"5"])
  goto <bb 10>; [50.00%]
else
  goto <bb 11>; [50.00%]

$7 = void
<bb 11> [local count: 44944954]:
if (_22 <= "5")
  goto <bb 12>; [50.00%]
else
  goto <bb 13>; [50.00%]

$8 = void

but the CFG doesn't resemble any of the forms it handles and it does not
try to catch the case where the inner condition would simplify (basically
thread it without any code duplication).  So it doesn't really fit
ifcombine.

The old VRP pass sees

  <bb 12> [local count: 44944954]:
  _112 = ASSERT_EXPR <_22, _22 <= &MEM <const char[2]> [(void *)"5"]>;
  if (_112 <= "5")
    goto <bb 13>; [50.00%]
  else
    goto <bb 14>; [50.00%]

but concludes

xtract_range_from_stmt visiting:
_112 = ASSERT_EXPR <_22, _22 <= &MEM <const char[2]> [(void *)"5"]>;
Found new range for _112: char * VARYING

extract_range_from_stmt visiting:
if (_112 <= "5")

Visiting conditional with predicate: if (_112 <= "5")

With known ranges
        _112: char * VARYING

Predicate evaluates to: DON'T KNOW

it might reason that _22 <= &MEM <const char[2]> [(void *)"5"] means
_22 == &"5" and track the range of _22 as constant.

That said, we relied on jump threading for these kind of simplifications
but we are not good at this particular case.