[Bug c/111211] New: No warning for iterator going out of scope

[Bug c/111211] New: No warning for iterator going out of scope

[lehua.ding at rivai dot ai]

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

            Bug ID: 111211
           Summary: No warning for iterator going out of scope
           Product: gcc
           Version: 14.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c
          Assignee: unassigned at gcc dot gnu.org
          Reporter: lehua.ding at rivai dot ai
  Target Milestone: ---

Compiler Explorer: https://godbolt.org/z/o4qPbovaz

There is a warning reported when the number of iterations is less than or equal
to 7, and no warning reported when it is greater than 7. I feel this behavior
is a bit strange.

[Bug c/111211] No warning for iterator going out of scope

[lehua.ding at rivai dot ai]

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

--- Comment #1 from Lehua Ding <lehua.ding at rivai dot ai> ---
Reproduce:

Compile Command: gcc -O3 -Wall -Wextra

C Code:

```
#include <stdint.h>

int foo (uint64_t ddr0_addr_access)
{
    uint64_t check[1] = {0};

    for (int k = 0; k < 7; k += 1)
    {
        asm volatile ("nop" : "=r"(check[k]) : "r"(ddr0_addr_access));
    }
    return 0;
}

int foo2 (uint64_t ddr0_addr_access)
{
    uint64_t check[1] = {0};

    for (int k = 0; k < 8; k += 1)
    {
        asm volatile ("nop" : "=r"(check[k]) : "r"(ddr0_addr_access));
    }
    return 0;
}
```

Output:

<source>: In function 'foo':
<source>:9:41: warning: array subscript 1 is above array bounds of
'uint64_t[1]' {aka 'long unsigned int[1]'} [-Warray-bounds=]
    9 |         asm volatile ("nop" : "=r"(check[k]) : "r"(ddr0_addr_access));
      |                                    ~~~~~^~~
<source>:5:14: note: while referencing 'check'
    5 |     uint64_t check[1] = {0};
      |              ^~~~~
<source>:9:41: warning: array subscript 2 is above array bounds of
'uint64_t[1]' {aka 'long unsigned int[1]'} [-Warray-bounds=]
    9 |         asm volatile ("nop" : "=r"(check[k]) : "r"(ddr0_addr_access));
      |                                    ~~~~~^~~
<source>:5:14: note: while referencing 'check'
    5 |     uint64_t check[1] = {0};
      |              ^~~~~
<source>:9:41: warning: array subscript 3 is above array bounds of
'uint64_t[1]' {aka 'long unsigned int[1]'} [-Warray-bounds=]
    9 |         asm volatile ("nop" : "=r"(check[k]) : "r"(ddr0_addr_access));
      |                                    ~~~~~^~~
<source>:5:14: note: while referencing 'check'
    5 |     uint64_t check[1] = {0};
      |              ^~~~~
<source>:9:41: warning: array subscript 4 is above array bounds of
'uint64_t[1]' {aka 'long unsigned int[1]'} [-Warray-bounds=]
    9 |         asm volatile ("nop" : "=r"(check[k]) : "r"(ddr0_addr_access));
      |                                    ~~~~~^~~
<source>:5:14: note: while referencing 'check'
    5 |     uint64_t check[1] = {0};
      |              ^~~~~
<source>:9:41: warning: array subscript 5 is above array bounds of
'uint64_t[1]' {aka 'long unsigned int[1]'} [-Warray-bounds=]
    9 |         asm volatile ("nop" : "=r"(check[k]) : "r"(ddr0_addr_access));
      |                                    ~~~~~^~~
<source>:5:14: note: while referencing 'check'
    5 |     uint64_t check[1] = {0};
      |              ^~~~~
<source>:9:41: warning: array subscript 6 is above array bounds of
'uint64_t[1]' {aka 'long unsigned int[1]'} [-Warray-bounds=]
    9 |         asm volatile ("nop" : "=r"(check[k]) : "r"(ddr0_addr_access));
      |                                    ~~~~~^~~
<source>:5:14: note: while referencing 'check'
    5 |     uint64_t check[1] = {0};
      |              ^~~~~
Compiler returned: 0

[Bug c/111211] No warning for iterator going out of scope

[rguenth at gcc dot gnu.org]

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

--- Comment #2 from Richard Biener <rguenth at gcc dot gnu.org> ---
We diagnose this after unrolling, so the difference is whether we unroll or
not.

[Bug c/111211] No warning for iterator going out of scope

[lehua.ding at rivai dot ai]

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

--- Comment #3 from Lehua Ding <lehua.ding at rivai dot ai> ---
(In reply to Richard Biener from comment #2)
> We diagnose this after unrolling, so the difference is whether we unroll or
> not.

But based on the assembly code it looks like both are unrolled.

foo:
        nop
        nop
        nop
        nop
        nop
        nop
        nop
        xor     eax, eax
        ret
foo2:
        nop
        nop
        nop
        nop
        nop
        nop
        nop
        nop
        xor     eax, eax
        ret

[Bug c/111211] No warning for iterator going out of scope

[pinskia at gcc dot gnu.org]

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

--- Comment #4 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to Lehua Ding from comment #3)
> (In reply to Richard Biener from comment #2)
> > We diagnose this after unrolling, so the difference is whether we unroll or
> > not.
> 
> But based on the assembly code it looks like both are unrolled.
> 
> foo:
>         nop
>         nop
>         nop
>         nop
>         nop
>         nop
>         nop
>         xor     eax, eax
>         ret
> foo2:
>         nop
>         nop
>         nop
>         nop
>         nop
>         nop
>         nop
>         nop
>         xor     eax, eax
>         ret

At different times in the pipeline and the warning happens before the second
unrollinb

[Bug tree-optimization/111211] No warning for iterator going out of scope for writing to array of inline-asm

[pinskia at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |inline-asm
            Summary|No warning for iterator     |No warning for iterator
                   |going out of scope          |going out of scope for
                   |                            |writing to array of
                   |                            |inline-asm

--- Comment #5 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Note this is only an issue with inline-asm really and only if write directly in
the array.

If we change the code slightly:
```
#include <stdint.h>
int foo2 (uint64_t ddr0_addr_access)
{
    uint64_t check[1] = {0};

    for (int k = 0; k < 8; k += 1)
    {
        int t;
        asm volatile ("nop" : "=r"(t) : "r"(ddr0_addr_access));
        check[k] = t;
    }
    return 0;
}
```

GCC does warn (though slightly different):
```
<source>:11:18: warning: iteration 1 invokes undefined behavior
[-Waggressive-loop-optimizations]
   11 |         check[k] = t;
      |         ~~~~~~~~~^~~
<source>:7:23: note: within this loop
    7 |     for (int k = 0; k < 8; k += 1)
      |                     ~~^~~
```