memcpy code optimized with -Os because of limited buffer scope

I have the following C code, which works fine without optimization (-O0) but has unexpected behavior when using -Os:

#include <stdint.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>

static bool functionA(uint8_t* ptr1)
{
    for (int i = 0; i < 16; i++)
    {
        ptr1[i] = i;
    }
    printf("functionA\n");
    return true;
}

static bool functionB(uint8_t* ptr1)
{
    bool retVal = false;
    uint8_t ptr2[16] = {0};

    if (functionA(ptr2))
    {
        retVal = true;
        memcpy(ptr1, ptr2, 16);
    }

    return retVal;
}


int main(void)
{
    const uint8_t* p = NULL;
    const uint8_t BUF[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};

    for (int i = 1; i <= 2; i++)
    {
        if (i == 1)
        {
            uint8_t buff32[32] = {0x5};

            if (functionB(buff32))
            {
                p = buff32;
                break;
            }

            continue;

        }
        else
        {
            p = BUF;
        }
    }

    for(int i = 0; i < 16; i++)
    {
        printf("%x ", p[i]);
    }

    printf("\n");
    return 0;
}

When compiling the code with "-O0", I have the result:

functionA
0 1 2 3 4 5 6 7 8 9 a b c d e f

However, with "-Os" or "-O3" (not "-O2"):

functionA
16 24 97 6b fc 7f 0 0 8d f2 b7 c ed 55 0 0

I tried on godbolt with different compilers like ARM GCC 10.3.1 and I see that the code of the memcpy in "functionB" is not compiled. Changing the scope of the buff32 at the beginning of the main seems to solve the issue. It seems that GCC judges that the buffer is no longer used in its scope and considers it as unused, hence optimizes it.

Is it possible to get a warning from the compiler?
Is it an undefined behavior?

When executing the first iteration of the loop if functionB is true then you assign the value of buff32 to the variable p.
Now p points to the beginning of buff32 that is an array on the stack. When you call break and exit the loop the stack frame is freed and so p points to a stack space that is not in use anymore.
If you move the definition of buff32 out of the loop (like you said you did in the question) that space is valid until the program exits so you don't get that problem.

That is why the @Ted-Lyngmo comment says that the sanitizers report a stack-use-after-scope.

The scope of buff32 is the issue.
See comment from @Ted Lyngmo

Not knowing your question it's difficult to say but
your code should probably read like this:

int main(void)
{
    const uint8_t* p = NULL;
    const uint8_t BUF[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
    uint8_t buff32[32] = {0};  //<<--HERE

    for (int i = 1; i <= 2; i++)
    {
        if (i == 1)
        {
            memset(buff32, '
int main(void)
{
const uint8_t* p = NULL;
const uint8_t BUF[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
uint8_t buff32[32] = {0};  //<<--HERE
for (int i = 1; i <= 2; i++)
{
if (i == 1)
{
memset(buff32, '\0', sizeof(buff32)); //<<---HERE
buff32[0] = 0x5; //<<---HERE
if (functionB(buff32))
{
p = buff32;
break;
}
continue;
}
else
{
p = BUF;
}
}
for(int i = 0; i < 16; i++)
{
printf("%x ", p[i]);
}
printf("\n");
return 0;
}
', sizeof(buff32)); //<<---HERE
            buff32[0] = 0x5; //<<---HERE
            if (functionB(buff32))
            {
                p = buff32;
                break;
            }

            continue;

        }
        else
        {
            p = BUF;
        }
    }

    for(int i = 0; i < 16; i++)
    {
        printf("%x ", p[i]);
    }

    printf("\n");
    return 0;
}