Previously I wrote:


  [Template parameter objects of array type] are permitted to overlap or be
coalesced, just like initializer_lists and string literals. Clang trunk
isn’t smart enough to coalesce potentially non-unique objects [but]
GCC, once it implements define_static_array, will presumably make them the same.


Well, GCC 16 has an experimental implementation of define_static_array
(compile with g++ -std=c++26 -freflection), and it does not coalesce
template parameter objects of array type in the way I expected. Digging deeper
into why not, I learned that there are at least three ways compilers and linkers
(on ELF — that is, non-Windows — platforms) conspire to “merge”
potentially non-unique objects:


  Merging at the compiler level (for initializer_list backing arrays)
  Sections with SHF_MERGE (for string literals and backing arrays)
  Sections with SHF_GROUP, a.k.a. COMDAT sections (for inline variables)

Authored by Arthur O'Dwyer, Quuxplusone offers  explorations of C++ programming language features, standard library design, and modern C++ development practices. Readers can delve into advanced topics such as template metaprogramming, design patterns, and effective use of language features. Additionally, they can learn about best practices for writing efficient and maintainable C++ code, optimizing performance, and leveraging the latest language standards.

Arthur O'Dwyer

A deep dive into how ELF-based compilers and linkers merge potentially non-unique objects using three distinct mechanisms: compiler-level merging for initializer_list backing arrays, SHF_MERGE sections for string literals and fixed-size data, and SHF_GROUP (COMDAT) sections for inline variables and template instantiations. The post explores why GCC 16's experimental define_static_array implementation doesn't coalesce template parameter objects of array type as expected, explaining the fundamental tradeoffs between data-addressed (SHF_MERGE) and name-addressed (COMDAT) deduplication. It concludes that no existing combination of these tools achieves ideal behavior for C++26's define_static_array, and speculates on potential future linker extensions.

ELF’s ways to combine potentially non-unique objects