[CodeGen] Fix the type of the constant that is used to zero-initialize a flexible array member

[ahatanak]

Summary

EmitArrayConstant was incorrectly returning a zeroinitializer of zero-element array type when the initializer expression wasn't empty.

This fixes an assertion added in https://reviews.llvm.org/D123649. See the discussion here: https://reviews.llvm.org/D123649#4362210

[efriedma]

clang/lib/CodeGen/CGExprConstant.cpp

964

Not sure I like this fix. If we're going to pass in the DesiredType to indicate the correct result type, the caller should make sure it uses the correct type; we shouldn't need to correct it after the fact.

[ahatanak]

Fix the desired type of incomplete arrays that is passed to EmitArrayConstant.

[aaron.ballman]

LGTM, but I'll leave it to @efriedma to do the final sign-off.

[efriedma]

LGTM

clang/lib/CodeGen/CGExprConstant.cpp

EmitArrayConstant(CodeGenModule &CGM, llvm::ArrayType *DesiredType,
   if (NonzeroLength == Elements.size()) {
     while (NonzeroLength > 0 && Elements[NonzeroLength - 1]->isNullValue())
       --NonzeroLength;
   }
 
   if (NonzeroLength == 0)
     return llvm::ConstantAggregateZero::get(DesiredType);
 
   // Add a zeroinitializer array filler if we have lots of trailing zeroes.
   unsigned TrailingZeroes = ArrayBound - NonzeroLength;
   if (TrailingZeroes >= 8) {
     assert(Elements.size() >= NonzeroLength &&
            "missing initializer for non-zero element");
 
     // If all the elements had the same type up to the trailing zeroes, emit a
     // struct of two arrays (the nonzero data and the zeroinitializer).
     if (CommonElementType && NonzeroLength >= 8) {
for (unsigned I = 0; I < NumInitElts; ++I) {
         CommonElementType = C->getType();
       else if (C->getType() != CommonElementType)
         CommonElementType = nullptr;
       Elts.push_back(C);
     }
 
     llvm::ArrayType *Desired =
         cast<llvm::ArrayType>(CGM.getTypes().ConvertType(DestType));
+
+    // Fix the type of incomplete arrays if the initializer isn't empty.
+    if (DestType->isIncompleteArrayType() && !Elts.empty())
+      Desired = llvm::ArrayType::get(Desired->getElementType(), Elts.size());
+
     return EmitArrayConstant(CGM, Desired, CommonElementType, NumElements, Elts,
                              Filler);
   }
   case APValue::MemberPointer:
     return CGM.getCXXABI().EmitMemberPointer(Value, DestType);
   }
   llvm_unreachable("Unknown APValue kind");
 }

clang/test/CodeGenCXX/flexible-array-init.cpp

 void g() {
   static A d = { f(), { f(), f() } }; // expected-error {{cannot compile this flexible array initializer yet}}
 }
 #endif
 #ifdef FAIL3
 struct B { int x; char y; char z[]; };
 B e = {f(), f(), f(), f()}; // expected-error {{cannot compile this flexible array initializer yet}}
 #endif
+
+namespace zero_initializer {
+A a0{0, 0}, a1{0, {0, 0}};
+// CHECK: @_ZN16zero_initializer2a0E = global { i32, [1 x i32] } zeroinitializer,
+// CHECK: @_ZN16zero_initializer2a1E = global { i32, [2 x i32] } zeroinitializer,
+
+struct S { int x[]; };
+
+S s{0};
+// CHECK: @_ZN16zero_initializer1sE = global { [1 x i32] } zeroinitializer,
+}