`_mm256_zeroall()` can't initialize register variables

I want to zero all YMM registers like this.=:

#include <immintrin.h>

void fn(float *out) {
    register __m256 r0;
    _mm256_zeroall();
    _mm256_storeu_ps(out, r0);
}

But gcc/clang gives me a warning:

warning: 'r0' is used uninitialized [-Wuninitialized]

It's okay to use _mm256_setzero_ps() but both the code and generated assembly is ugly.
If I have 12 defined register varaibles, the gcc is likely to generate 12 vmovaps and the clang is likely to generate 12 vxorps instruction. In the worst case, the gcc would generate memset function call and many vmovaps.
I just want a single vzeroall instruction.

Is there any way to let compiler know that _mm256_zeroall() will zeros all register without handwriting asm?

Edit 1:
In fact I'm writing a matrix product program, which need to clear many registers at the beginning. To simplify the question, I use the most simple code for question.

I've confirmed vzeroall is not slow compare to many vmovaps/vxorps on Zen 3, and vzeroall has smaller code size, which is more cache friendly.

Remove register qualifier doesn't work on GCC/Clang. It generates the same assembly as the previous one.

I've found that I can specify the register name on GCC to elimiate the warning, like this:

register __m256 r0 asm("ymm0");

But clang doen't obey the define and still generate the same warning.

The answer is that, while the instruction's name is vzeroall, it only zeroes out the first 16 vector registers and leave the others unchanged. As a result, the allocator may choose an upper register for your store, which leads to wrong behaviour.

Some more discussion:

Firstly, you are not actually programming in assembly, you are programming in C++ (albeit x86 intrinsics), if you need a variable multiple times, you just use it multiple times, and the compiler will decide to spill if it is necessary. In contrast, even if you define multiple _mm256_setzero_ps(), the compiler will idealise them into a single variable.

Secondly, why do you need multiple zero registers, I believe that most avx instructions are non-destructive, except merge-masking instructions, but merge-masking operations on zero is equivalent to just doing a zero-masking instead. As you said it is for multiple accumulators, and I see that the compilers do not perform loop peeling, then you can manually peel the first iteration instead, which will remove excessive initialisations of zero registers (example).