Clang, increase upper bound of partially initialized array sizes

[OfekShochat]

Summary

fixes issue with emitting partially initialized constant arrays larger than 2^32.
issue #57353 on github.

[shafik]

clang/lib/Sema/SemaInit.cpp

866

setElementIndex(...) takes unsigned as well and therefore InitializedEntity also uses unsigned.

I briefly looked at this with another bug https://github.com/llvm/llvm-project/issues/57317

and I believe the 32 bit assumption is made in a lot of this code in this area.

[efriedma]

clang/lib/Sema/SemaInit.cpp

866

You don't need to solve everything at once...

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

3167

Can you split this into a separate patch (with an appropriate testcase)?

[OfekShochat]

Clang, increase upper bound of partially initialized array sizes

fixes issue with emitting partially initialized constant arrays larger than 2^32.
issue #57353 on github.

[OfekShochat]

I created a diff for the AsmPrinter part, its at D133845

clang/lib/Sema/SemaInit.cpp

866

oh, right, should I change that after I split the diff in AsmPrinter to another patch?

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

3167

yep

[OfekShochat]

@efriedma would you be able to commit this?

clang/lib/CodeGen/CGExprConstant.cpp

bool ConstantAggregateBuilder::split(size_t Index, CharUnits Hint) {
   // We don't need to do this to handle bit-fields because we always eagerly
   // split them into 1-byte chunks.
 
   return false;
 }
 
 static llvm::Constant *
 EmitArrayConstant(CodeGenModule &CGM, llvm::ArrayType *DesiredType,
-                  llvm::Type *CommonElementType, unsigned ArrayBound,
+                  llvm::Type *CommonElementType, uint64_t ArrayBound,
                   SmallVectorImpl<llvm::Constant *> &Elements,
                   llvm::Constant *Filler);
 
 llvm::Constant *ConstantAggregateBuilder::buildFrom(
     CodeGenModule &CGM, ArrayRef<llvm::Constant *> Elems,
     ArrayRef<CharUnits> Offsets, CharUnits StartOffset, CharUnits Size,
     bool NaturalLayout, llvm::Type *DesiredTy, bool AllowOversized) {
   ConstantAggregateBuilderUtils Utils(CGM);
tryEmitGlobalCompoundLiteral(ConstantEmitter &emitter,
   emitter.finalize(GV);
   GV->setAlignment(Align.getAsAlign());
   CGM.setAddrOfConstantCompoundLiteral(E, GV);
   return ConstantAddress(GV, GV->getValueType(), Align);
 }
 
 static llvm::Constant *
 EmitArrayConstant(CodeGenModule &CGM, llvm::ArrayType *DesiredType,
-                  llvm::Type *CommonElementType, unsigned ArrayBound,
+                  llvm::Type *CommonElementType, uint64_t ArrayBound,
                   SmallVectorImpl<llvm::Constant *> &Elements,
                   llvm::Constant *Filler) {
   // Figure out how long the initial prefix of non-zero elements is.
-  unsigned NonzeroLength = ArrayBound;
+  uint64_t NonzeroLength = ArrayBound;
   if (Elements.size() < NonzeroLength && Filler->isNullValue())
     NonzeroLength = Elements.size();
   if (NonzeroLength == Elements.size()) {
     while (NonzeroLength > 0 && Elements[NonzeroLength - 1]->isNullValue())
       --NonzeroLength;
   }
 
   if (NonzeroLength == 0)
llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E,
                                                 QualType T) {
     return Visit(E->getSubExpr(), T);
   }
 
   llvm::Constant *EmitArrayInitialization(InitListExpr *ILE, QualType T) {
     auto *CAT = CGM.getContext().getAsConstantArrayType(ILE->getType());
     assert(CAT && "can't emit array init for non-constant-bound array");
     unsigned NumInitElements = ILE->getNumInits();
-    unsigned NumElements = CAT->getSize().getZExtValue();
+    uint64_t NumElements = CAT->getSize().getZExtValue();
 
     // Initialising an array requires us to automatically
     // initialise any elements that have not been initialised explicitly
-    unsigned NumInitableElts = std::min(NumInitElements, NumElements);
+    uint64_t NumInitableElts = std::min((uint64_t)NumInitElements, NumElements);
 
     QualType EltType = CAT->getElementType();
 
     // Initialize remaining array elements.
     llvm::Constant *fillC = nullptr;
     if (Expr *filler = ILE->getArrayFiller()) {
       fillC = Emitter.tryEmitAbstractForMemory(filler, EltType);
       if (!fillC)

clang/lib/Sema/SemaInit.cpp

if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
     }
 
     return;
   }
 
   QualType ElementType;
 
   InitializedEntity ElementEntity = Entity;
-  unsigned NumInits = ILE->getNumInits();
-  unsigned NumElements = NumInits;
+  uint64_t NumInits = ILE->getNumInits();
+  uint64_t NumElements = NumInits;
   if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
     ElementType = AType->getElementType();
     if (const auto *CAType = dyn_cast<ConstantArrayType>(AType))
       NumElements = CAType->getSize().getZExtValue();
     // For an array new with an unknown bound, ask for one additional element
     // in order to populate the array filler.
     if (Entity.isVariableLengthArrayNew())
       ++NumElements;
     ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
                                                          0, Entity);
   } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
     ElementType = VType->getElementType();
     NumElements = VType->getNumElements();
     ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
                                                          0, Entity);
   } else
     ElementType = ILE->getType();
 
   bool SkipEmptyInitChecks = false;
-  for (unsigned Init = 0; Init != NumElements; ++Init) {
+  for (uint64_t Init = 0; Init != NumElements; ++Init) {
     if (hadError)
       return;
 
     if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
         ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
       ElementEntity.setElementIndex(Init);
 
     if (Init >= NumInits && (ILE->hasArrayFiller() || SkipEmptyInitChecks))
       return;
 
     Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr);
     if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
       ILE->setInit(Init, ILE->getArrayFiller());
     else if (!InitExpr && !ILE->hasArrayFiller()) {

clang/test/CodeGen/big-array-init.c

+// RUN: %clang_cc1 %s -O0 -triple x86_64-unknown-linux-gnu -S -emit-llvm -o - | FileCheck %s
+/* checks for #57353, arrays that are larger than 2^32 were emitting wrongly. */
+
+// CHECK: @bad_char = global <{ i8, [4294967295 x i8] }> <{ i8 1, [4294967295 x i8] zeroinitializer }>, align 16
+char bad_char[4294967296] = {1};
+// CHECK: @bad_int = global <{ i32, [1073741823 x i32] }> <{ i32 1, [1073741823 x i32] zeroinitializer }>, align 16
+int bad_int[1073741824] = {1};

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (unsigned Padding = Size - EmittedSize)
     AP.OutStreamer->emitZeros(Padding);
 }
 
 static void emitGlobalConstantStruct(const DataLayout &DL,
                                      const ConstantStruct *CS, AsmPrinter &AP,
                                      const Constant *BaseCV, uint64_t Offset,
                                      AsmPrinter::AliasMapTy *AliasList) {
   // Print the fields in successive locations. Pad to align if needed!
-  unsigned Size = DL.getTypeAllocSize(CS->getType());
+  uint64_t Size = DL.getTypeAllocSize(CS->getType());
   const StructLayout *Layout = DL.getStructLayout(CS->getType());
   uint64_t SizeSoFar = 0;
   for (unsigned I = 0, E = CS->getNumOperands(); I != E; ++I) {
     const Constant *Field = CS->getOperand(I);
 
     // Print the actual field value.
     emitGlobalConstantImpl(DL, Field, AP, BaseCV, Offset + SizeSoFar,
                            AliasList);
if (NumUses >= 0)
     AP.GlobalGOTEquivs[GOTEquivSym] = std::make_pair(GV, NumUses);
 }
 
 static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *CV,
                                    AsmPrinter &AP, const Constant *BaseCV,
                                    uint64_t Offset,
                                    AsmPrinter::AliasMapTy *AliasList) {
   emitGlobalAliasInline(AP, Offset, AliasList);
-  uint64_t Size = DL.getTypeAllocSize(CV->getType());
+  unsigned Size = DL.getTypeAllocSize(CV->getType());
 
   // Globals with sub-elements such as combinations of arrays and structs
   // are handled recursively by emitGlobalConstantImpl. Keep track of the
   // constant symbol base and the current position with BaseCV and Offset.
   if (!BaseCV && CV->hasOneUse())
     BaseCV = dyn_cast<Constant>(CV->user_back());
 
   if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV))