GCC extremely slow on compiling large std::array of a non-trivial type

Question

I have these two simple classes:

#include <type_traits>

struct trivial {
    int m;
};
 
struct non_trivial {
    non_trivial() {}
};

static_assert(std::is_trivial<trivial>::value, "");
static_assert(!std::is_trivial<non_trivial>::value, "");

and I'm measuring compilation time of this simple code with respect to the std::array size, using non_trivial as type:

#include <array>

void foo() {
    std::array<non_trivial, 1000> v;
}

and everything is fine: the compilation time, measured by godbolt, seems to be constant changing the size, and pretty similar between clang 12, GCC 11 and MSVC 19.28. The time is about 800 ms for all the compilers of the test.

But if I add the aggregate initialization to v:

#include <array>

void foo() {
    std::array<non_trivial, 1000> v{};
}

then the compilation time of GCC seems to grow faster than linearly with the size:

• 1000: 676 ms
• 2000: 877 ms
• 4000: 1228 ms
• 8000: 2083 ms
• 16000: 5544 ms
• 32000: 17862 ms

while clang and MSVC compilation times seem not sensitive to the aggregate initialization.

Also, if I replace non_trivial with trivial as array type, the effect has not been detected. The effect seems not to depend on the optimization level used.

According to this question, my two cases should be equivalent because the default initialization of std::array of non-trivial types should invoke the default constructor on all elements, that is exactly the same of an empty aggregate initialization.

It seems to me a bug in the GCC, present in every version supporting at least c++11. Do you have any suggestion about it?

You may find my test here.