[clang] Add tests for statement expression in initializers

[wanders]

Summary

The commit 683e83c5

[Clang][C++2b] P2242R3: Non-literal variables [...] in constexpr

fixed a code generation bug when using (C-extension) statement
expressions inside initializer expressions.

Before that commit a nested static initializer inside the statement
expression would not be emitted, causing it to be zero initialized.

It is a bit surprising (at least to me) that a commit implementing a new
C++ feature would fix this code generation bug. Zooming in it is the
change done in ExprConstant.cpp that helps. That changes so that
"ESR_Failed" is returned in more cases, causing the expression to not be
deemed constant. This fixes the code generation as instead the compiler
has to resort to generating a dynamic initializer.

That commit also meant that some statement expressions (in particular
the ones using static variables) that previously were accepted now are
errors due to not being constant (matching GCC behavior).

Given how a seemingly unrelated change caused this behavior to change,
it is probably a good thing to add at least some rudimentary tests for
these kind expressions.

[wanders]

One week gentle ping.
+ added reviewers from the https://reviews.llvm.org/D111400 patch that fixed the bug these tests covers.

[erichkeane]

The command line on one of the tests is a little strange to me, and I don't see the need for the -std=gnu11 on either, but the test content itself looks fine enough to me.

clang/test/CodeGen/stmtexpr-init.c

2

why the -std=gnu11 here? I would assume our default would be enough? Also, why the opt-flag? That likely is unnecessary/will cause 'bad things' to happen. Clang tests typically don't use the opt flags.

[aaron.ballman]

Thanks for adding some more test coverage! Would it be worth mentioning the miscompile fix in the release notes more explicitly?

clang/test/Sema/stmtexpr-init.c

2

I'd remove the gnu11 from here as well (we default to being in GNU mode anyway).

[wanders]

In D127201#3578077, @aaron.ballman wrote:

Thanks for adding some more test coverage! Would it be worth mentioning the miscompile fix in the release notes more explicitly?

Yes, might be a good idea, in particualar as some cases which were accepted (but miscompiled) now gives compilation errors.

Will add something to release notes.

clang/test/CodeGen/stmtexpr-init.c

2

why the -std=gnu11 here? I would assume our default would be enough? Also, why the opt-flag? That likely is unnecessary/will cause 'bad things' to happen. Clang tests typically don't use the opt flags.

Right, gnu11 shouldn't be needed.

The -O flag was there as that made the optimizer remove some of the dynamic initialization things making it easier to see the pattern to match on. But I see now that the checks I ended up doing matches just fine without it.

So will drop these. Thanks.

[wanders]

Updated diff with:

• Release note
• Cleaned up command line options in RUN commands
• Fixed type mimatch pointed out by @kimgr (out of band)

[aaron.ballman]

LGTM! (The precommit CI failures appear to be unrelated to the changes in this patch.) Thanks for the additional test coverage!

clang/docs/ReleaseNotes.rst

- Unscoped and scoped enumeration types can no longer be initialized from a
   type.
 - Allow use of an elaborated type specifier as a ``_Generic`` selection
   association in C++ mode. This fixes
   `Issue 55562 <https://github.com/llvm/llvm-project/issues/55562>`_.
 - Clang will allow calling a ``consteval`` function in a default argument. This
   fixes `Issue 48230 <https://github.com/llvm/llvm-project/issues/48230>`_.
 - Fixed memory leak due to ``VarTemplateSpecializationDecl`` using
   ``TemplateArgumentListInfo`` instead of ``ASTTemplateArgumentListInfo``.
+- An initializer for a static variable declaration, which is nested
+  inside a statement expression in an aggregate initializer, is now
+  emitted as a dynamic initializer. Previously the variable would
+  incorrectly be zero-initialized. In contexts where a dynamic
+  initializer is not allowed this is now diagnosed as an error.
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - ``-Wliteral-range`` will warn on floating-point equality comparisons with
   constants that are not representable in a casted value. For example,
   ``(float) f == 0.1`` is always false.
 - ``-Winline-namespace-reopened-noninline`` now takes into account that the
   ``inline`` keyword must appear on the original but not necessarily all

clang/test/CodeGen/stmtexpr-init.c

+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+void escape(const void *);
+
+// CHECK-DAG: internal global i8 99
+
+void T1(void) {
+  const char *x[1] = {({static char _x = 99; &_x; })};
+  escape(x);
+}
+
+struct sized_array {
+  int count;
+  int entries[];
+};
+
+#define N_ARGS(...) (sizeof((int[]){__VA_ARGS__}) / sizeof(int))
+
+#define ARRAY_PTR(...) ({                                                    \
+  static const struct sized_array _a = {N_ARGS(__VA_ARGS__), {__VA_ARGS__}}; \
+  &_a;                                                                       \
+})
+
+struct outer {
+  const struct sized_array *a;
+};
+
+void T2(void) {
+  // CHECK-DAG: internal constant { i32, [2 x i32] } { i32 2, [2 x i32] [i32 50, i32 60] }
+  const struct sized_array *A = ARRAY_PTR(50, 60);
+
+  // CHECK-DAG: internal constant { i32, [3 x i32] } { i32 3, [3 x i32] [i32 10, i32 20, i32 30] }
+  struct outer X = {ARRAY_PTR(10, 20, 30)};
+
+  escape(A);
+  escape(&X);
+}

clang/test/Sema/stmtexpr-init.c

+// RUN: %clang_cc1 -verify -fsyntax-only %s
+
+static int *z[1] = {({ static int _x = 70; &_x; })}; // expected-error {{statement expression not allowed at file scope}}
+
+void T1(void) {
+  int *x[1] = {({ static int _x = 10; &_x; })}; // expected-no-error
+
+  /* Before commit
+     683e83c5 [Clang][C++2b] P2242R3: Non-literal variables [...] in constexpr
+     (i.e in clang-14 and earlier)
+     this was silently accepted, but generated incorrect code.
+  */
+  static int *y[1] = {({ static int _x = 20; &_x; })}; // expected-error {{initializer element is not a compile-time constant}}
+}