Restrict lvalue-to-rvalue conversions in CGExprConstant.

[efriedma]

Summary

We were generating wrong code for cxx20-consteval-crash.cpp: instead of loading a value of a variable, we were using its address as the initializer.

Found while adding code to verify the size of constant initializers.

[Miss_Grape]

clang/lib/CodeGen/CGExprConstant.cpp

1096

Could you add a test case?

[rsmith]

LGTM

[aaron.ballman]

LGTM, thanks for catching this (sorry, pretty sure this was my bug)!

[efriedma]

clang/lib/CodeGen/CGExprConstant.cpp

1096

Compound literals are covered by existing testcases, if that's what you're asking.

clang/lib/CodeGen/CGExprConstant.cpp

case CK_AddressSpaceConversion: {
       if (!C) return nullptr;
       LangAS destAS = E->getType()->getPointeeType().getAddressSpace();
       LangAS srcAS = subExpr->getType()->getPointeeType().getAddressSpace();
       llvm::Type *destTy = ConvertType(E->getType());
       return CGM.getTargetCodeGenInfo().performAddrSpaceCast(CGM, C, srcAS,
                                                              destAS, destTy);
     }
 
-    case CK_LValueToRValue:
+    case CK_LValueToRValue: {
+      // We don't really support doing lvalue-to-rvalue conversions here; any
+      // interesting conversions should be done in Evaluate().  But as a
+      // special case, allow compound literals to support the gcc extension
+      // allowing "struct x {int x;} x = (struct x) {};".
+      if (auto *E = dyn_cast<CompoundLiteralExpr>(subExpr->IgnoreParens()))
+        return Visit(E->getInitializer(), destType);
+      return nullptr;
+    }
+
     case CK_AtomicToNonAtomic:
     case CK_NonAtomicToAtomic:
     case CK_NoOp:
     case CK_ConstructorConversion:
       return Visit(subExpr, destType);
 
     case CK_IntToOCLSampler:
       llvm_unreachable("global sampler variables are not generated");

clang/test/CodeGenCXX/cxx20-consteval-crash.cpp

 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 %s -emit-llvm -o - | FileCheck %s
 
 namespace PR50787 {
 // This code would previously cause a crash.
 extern int x_;
 consteval auto& X() { return x_; }
 constexpr auto& x1 = X();
 auto x2 = X();
 
 // CHECK: @_ZN7PR507872x_E = external global i32, align 4
 // CHECK-NEXT: @_ZN7PR507872x1E = constant i32* @_ZN7PR507872x_E, align 8
-// CHECK-NEXT: @_ZN7PR507872x2E = global i32* @_ZN7PR507872x_E, align 4
+// CHECK-NEXT: @_ZN7PR507872x2E = global i32 0, align 4
 }
 
 namespace PR51484 {
 // This code would previously cause a crash.
 struct X { int val; };
 consteval X g() { return {0}; }
 void f() { g(); }
 
-// CHECK: define dso_local void @_ZN7PR514841fEv() #0 {
+// CHECK: define dso_local void @_ZN7PR514841fEv() #1 {
 // CHECK: entry:
 // CHECK-NOT: call i32 @_ZN7PR514841gEv()
 // CHECK:  ret void
 // CHECK: }
 }
 
 namespace Issue54578 {
 inline consteval unsigned char operator""_UC(const unsigned long long n) {