[Bug tree-optimization/108017] New: ptr+v >= ptr + d should converted into (long)v >= CST(/sizeof(*ptr))

[Bug tree-optimization/108017] New: ptr+v >= ptr + d should converted into (long)v >= CST(/sizeof(*ptr))

[pinskia at gcc dot gnu.org]

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

            Bug ID: 108017
           Summary: ptr+v >= ptr + d should converted into (long)v >=
                    CST(/sizeof(*ptr))
           Product: gcc
           Version: 13.0
            Status: UNCONFIRMED
          Keywords: missed-optimization
          Severity: normal
          Priority: P3
         Component: tree-optimization
          Assignee: unassigned at gcc dot gnu.org
          Reporter: pinskia at gcc dot gnu.org
  Target Milestone: ---

Take:
```
_Bool f(int *a, __SIZE_TYPE__ t, __SIZE_TYPE__ t1)
{
    int *b = a + t;
    int *c = a + t1;
    return c >= b;
}

_Bool f1(int *a, __SIZE_TYPE__ t, __SIZE_TYPE__ t1)
{
    long tt = t;
    long tt1 = t1;
    return tt1 >= tt;
}
```
These two should give the same code.

LLVM does this optimization.

I noticed this while looking into the code from the blog at
https://lemire.me/blog/2022/12/06/optimizing-compilers-reload-vector-constants-needlessly/
(but not vector constant issue though).

[Bug tree-optimization/108017] ptr+v >= ptr + d should converted into (long)v >= CST(/sizeof(*ptr))

[rguenth at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
     Ever confirmed|0                           |1
   Last reconfirmed|                            |2022-12-08

--- Comment #1 from Richard Biener <rguenth at gcc dot gnu.org> ---
We do this for &x + C {!=,==} &x' + C' - I think we're afraid of relational
compares here though, even with TYPE_OVERFLOW_UNDEFINED.

/* (&a+b) !=/== (&a[1] + c) ->  sizeof(a[0]) + b !=/== c */
(for neeq (ne eq)
 (simplify 
  (neeq (pointer_plus ADDR_EXPR@0 @1) (pointer_plus ADDR_EXPR@2 @3))
   (with { poly_int64 diff; tree inner_type = TREE_TYPE (@1);}
    (if (ptr_difference_const (@0, @2, &diff))
     (neeq (plus { build_int_cst_type (inner_type, diff); } @1) @3)))))

that could be relaxed to general @0/@2 (at some cost) and to
relational compares with TYPE_OVERFLOW_UNDEFINED.

[Bug tree-optimization/108017] ptr+v >= ptr + d should converted into (long)v >= CST(/sizeof(*ptr))

[pinskia at gcc dot gnu.org]

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

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           See Also|                            |https://gcc.gnu.org/bugzill
                   |                            |a/show_bug.cgi?id=94356

--- Comment #2 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
I think this is the more generialized form of bug 94356.