[Bug c/99156] New: __builtin_expect affects the interpretation of its first operand

[Bug c/99156] New: __builtin_expect affects the interpretation of its first operand

[zhan3299 at purdue dot edu]

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

            Bug ID: 99156
           Summary: __builtin_expect affects the interpretation of its
                    first operand
           Product: gcc
           Version: 11.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c
          Assignee: unassigned at gcc dot gnu.org
          Reporter: zhan3299 at purdue dot edu
  Target Milestone: ---

I hope it does not bother. I try to refer to a bug in llvm which may also
affect gcc.  

Following are copied-and-pasted from the discussion about a similar bug in
clang (https://bugs.llvm.org/show_bug.cgi?id=49239#c3). 

Specifically, 

> int maybe_vla(int n) {
>    goto label;
>    int arr[({0;})];
> label:
>    return sizeof(arr);
> }
> 
> ... is rejected by both Clang and GCC because the statement-expression is not an ICE, but
> 
> int maybe_vla(int n) {
>     goto label;
>     int arr[__builtin_expect(({0;}), 0)];
> label:
>     return sizeof(arr);
> }
> 
> ... is accepted. This seems like a bug in both compilers to me: __builtin_expect isn't supposed to affect the interpretation of its first operand, and presumably shouldn't be weakening the strict ICE checks.


case 1: https://godbolt.org/z/zWGEfx
case 2: https://godbolt.org/z/bejfcc

[Bug c/99156] __builtin_expect affects the interpretation of its first operand

[marxin at gcc dot gnu.org]

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

Martin Liška <marxin at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|                            |2021-02-19
     Ever confirmed|0                           |1
             Status|UNCONFIRMED                 |NEW
                 CC|                            |marxin at gcc dot gnu.org

--- Comment #1 from Martin Liška <marxin at gcc dot gnu.org> ---
Yes, I can confirm the issue. Thanks for the report.

[Bug c/99156] __builtin_expect affects the interpretation of its first operand

[zhan3299 at purdue dot edu]

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

--- Comment #2 from zhan3299 at purdue dot edu ---
(In reply to Martin Liška from comment #1)
> Yes, I can confirm the issue. Thanks for the report.

Many thanks for your prompt reply. Additionally, I have to give credit to
Richard Smith for finding the root cause.

[Bug c/99156] __builtin_expect is folded too soon allowing an non-integer-constant-expr to become an integer-const-expr

[pinskia at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
            Summary|__builtin_expect affects    |__builtin_expect is folded
                   |the interpretation of its   |too soon allowing an
                   |first operand               |non-integer-constant-expr
                   |                            |to become an
                   |                            |integer-const-expr
                 CC|                            |pinskia at gcc dot gnu.org

--- Comment #3 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Here is another example which shows the problem even further:
int maybe_vla(int n) {
    goto label;
    int arr[__builtin_expect(n-n, 0)];
label:
    return sizeof(arr);
}

int main() { return maybe_vla(0); }

---- CUT ----
Basically __builtin_expect is folded too soon which allows the argument to be
considered a constant integer expression :).