https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82294
Bug ID: 82294
Summary: Array of objects with constexpr constructors
initialized from space-inefficient memory image
Product: gcc
Version: 7.2.0
Status: UNCONFIRMED
Severity: normal
Priority: P3
Component: c++
Assignee: unassigned at gcc dot gnu.org
Reporter: headch at gmail dot com
Target Milestone: ---
Consider the following code:
$ cat test.cpp
struct S {
int x;
explicit constexpr S();
};
constexpr S::S() : x{7} {}
struct T {
S objects[256];
explicit T();
};
T::T() {}
Compile it as follows:
$ g++ -Wall -Wextra -march=native -std=c++17 -Os -c test.cpp
Dumping the resulting object file reveals that T::T() is implemented by
memcpying (depending on the target architecture sometimes inline or sometimes
by an actual memcpy call) a kilobyte of data from .rodata into the array being
initialized. For two or three S objects that might be a good, efficient
solution. For 256 of them, a kilobyte of memory entirely filled with sevens to
serve as an initialization image is rather ridiculous compared to just using a
loop to store seven into the objects one by one. This is especially egregious
considering I was asking to optimize for size!
Making S::S() non-constexpr improves the situation, though it’s hardly an ideal
solution.
This might be related to any of #12245, #56671, #59659, #63728, #68399, or
#71165, but none of them describe quite the same problem. The first five are
about memory or CPU time usage during compilation (not about the generated
code), and #71165 is specifically about aggregate initialization and appears to
be an unrolled loop in code rather than a huge data blob.
