[PoC][Clang] Use TypeSize instead of uint64_t for getTypeAllocSize().

[HsiangKai]

Summary

The return type of getTypeAllocSize() is TypeSize. We do not rely on the implicit conversion to uint64_t. The return value may be scalable values.

[sdesmalen]

clang/lib/CodeGen/CGCall.cpp

2856

Can we assume their scalable flags must match? In that case, it's best to assert this.

llvm::TypeSize::isKnownLE() should be used with some caution, because isKnownLE(4, vscale x 4) evaluates to true, so if their scalable flags don't match, this may lead to surprising results.

4929

This doesn't seem correct for scalable vectors.
If you expect it to work only for fixed-width vectors, you should use getFixedSize instead.

[HsiangKai]

Address comments.

clang/lib/CodeGen/CGCall.cpp

case ABIArgInfo::Direct: {
       // Pointer to store into.
       Address Ptr = emitAddressAtOffset(*this, Alloca, ArgI);
 
       // Fast-isel and the optimizer generally like scalar values better than
       // FCAs, so we flatten them if this is safe to do for this argument.
       llvm::StructType *STy = dyn_cast<llvm::StructType>(ArgI.getCoerceToType());
       if (ArgI.isDirect() && ArgI.getCanBeFlattened() && STy &&
           STy->getNumElements() > 1) {
-        uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy);
+        llvm::TypeSize SrcSize = CGM.getDataLayout().getTypeAllocSize(STy);
         llvm::Type *DstTy = Ptr.getElementType();
-        uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy);
+        llvm::TypeSize DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy);
 
         Address AddrToStoreInto = Address::invalid();
-        if (SrcSize <= DstSize) {
+        if (llvm::TypeSize::isKnownLE(SrcSize, DstSize)) {
           AddrToStoreInto = Builder.CreateElementBitCast(Ptr, STy);
         } else {
           AddrToStoreInto =
             CreateTempAlloca(STy, Alloca.getAlignment(), "coerce");
         }
 
         assert(STy->getNumElements() == NumIRArgs);
         if (STy->containsScalableVectorType()) {
           llvm::Value *Val = llvm::UndefValue::get(STy);
           for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
             auto AI = Fn->getArg(FirstIRArg + i);
             AI->setName(Arg->getName() + ".coerce" + Twine(i));
             Val = Builder.CreateInsertValue(Val, AI, i);
           }
           Builder.CreateStore(Val, AddrToStoreInto);
         } else {
           for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
             auto AI = Fn->getArg(FirstIRArg + i);
             AI->setName(Arg->getName() + ".coerce" + Twine(i));
             Address EltPtr = Builder.CreateStructGEP(AddrToStoreInto, i);
             Builder.CreateStore(AI, EltPtr);
           }
         }
 
-        if (SrcSize > DstSize) {
+        if (llvm::TypeSize::isKnownGT(SrcSize, DstSize)) {
           Builder.CreateMemCpy(Ptr, AddrToStoreInto, DstSize);
         }
 
       } else {
         // Simple case, just do a coerced store of the argument into the alloca.
         assert(NumIRArgs == 1);
         auto AI = Fn->getArg(FirstIRArg);
         AI->setName(Arg->getName() + ".coerce");
case ABIArgInfo::Direct: {
       Src = emitAddressAtOffset(*this, Src, ArgInfo);
 
       // Fast-isel and the optimizer generally like scalar values better than
       // FCAs, so we flatten them if this is safe to do for this argument.
       llvm::StructType *STy =
             dyn_cast<llvm::StructType>(ArgInfo.getCoerceToType());
       if (STy && ArgInfo.isDirect() && ArgInfo.getCanBeFlattened()) {
         llvm::Type *SrcTy = Src.getElementType();
-        uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy);
-        uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(STy);
+        llvm::TypeSize SrcSize = CGM.getDataLayout().getTypeAllocSize(SrcTy);
+        llvm::TypeSize DstSize = CGM.getDataLayout().getTypeAllocSize(STy);
 
         // If the source type is smaller than the destination type of the
         // coerce-to logic, copy the source value into a temp alloca the size
         // of the destination type to allow loading all of it. The bits past
         // the source value are left undef.
-        if (SrcSize < DstSize) {
+        if (llvm::TypeSize::isKnownLT(SrcSize, DstSize)) {
           Address TempAlloca
             = CreateTempAlloca(STy, Src.getAlignment(),
                                Src.getName() + ".coerce");
-          Builder.CreateMemCpy(TempAlloca, Src, SrcSize);
+          Builder.CreateMemCpy(TempAlloca, Src, SrcSize.getKnownMinSize());
           Src = TempAlloca;
         } else {
           Src = Builder.CreateBitCast(Src,
                                       STy->getPointerTo(Src.getAddressSpace()));
         }
 
         assert(NumIRArgs == STy->getNumElements());
         if (STy->containsScalableVectorType()) {

clang/lib/CodeGen/CGRecordLayoutBuilder.cpp

struct CGRecordLowering {
   /// Gets the llvm Basesubobject type from a CXXRecordDecl.
   llvm::Type *getStorageType(const CXXRecordDecl *RD) {
     return Types.getCGRecordLayout(RD).getBaseSubobjectLLVMType();
   }
   CharUnits bitsToCharUnits(uint64_t BitOffset) {
     return Context.toCharUnitsFromBits(BitOffset);
   }
   CharUnits getSize(llvm::Type *Type) {
-    return CharUnits::fromQuantity(DataLayout.getTypeAllocSize(Type));
+    return CharUnits::fromQuantity(
+        DataLayout.getTypeAllocSize(Type).getKnownMinValue());
   }
   CharUnits getAlignment(llvm::Type *Type) {
     return CharUnits::fromQuantity(DataLayout.getABITypeAlignment(Type));
   }
   bool isZeroInitializable(const FieldDecl *FD) {
     return Types.isZeroInitializable(FD->getType());
   }
   bool isZeroInitializable(const RecordDecl *RD) {
if (getContext().getLangOpts().DumpRecordLayouts) {
     RL->print(llvm::outs());
   }
 
 #ifndef NDEBUG
   // Verify that the computed LLVM struct size matches the AST layout size.
   const ASTRecordLayout &Layout = getContext().getASTRecordLayout(D);
 
   uint64_t TypeSizeInBits = getContext().toBits(Layout.getSize());
-  assert(TypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(Ty) &&
+  assert(TypeSizeInBits ==
+             getDataLayout().getTypeAllocSizeInBits(Ty).getKnownMinValue() &&
          "Type size mismatch!");
 
   if (BaseTy) {
     CharUnits NonVirtualSize  = Layout.getNonVirtualSize();
 
     uint64_t AlignedNonVirtualTypeSizeInBits =
       getContext().toBits(NonVirtualSize);
 
-    assert(AlignedNonVirtualTypeSizeInBits ==
-           getDataLayout().getTypeAllocSizeInBits(BaseTy) &&
-           "Type size mismatch!");
+    assert(
+        AlignedNonVirtualTypeSizeInBits ==
+            getDataLayout().getTypeAllocSizeInBits(BaseTy).getKnownMinValue() &&
   }
 
   // Verify that the LLVM and AST field offsets agree.
   llvm::StructType *ST = RL->getLLVMType();
   const llvm::StructLayout *SL = getDataLayout().getStructLayout(ST);
 
   const ASTRecordLayout &AST_RL = getContext().getASTRecordLayout(D);
   RecordDecl::field_iterator it = D->field_begin();
   for (unsigned i = 0, e = AST_RL.getFieldCount(); i != e; ++i, ++it) {
     const FieldDecl *FD = *it;
 
     // Ignore zero-sized fields.
     if (FD->isZeroSize(getContext()))
       continue;
 
     // For non-bit-fields, just check that the LLVM struct offset matches the
     // AST offset.
     if (!FD->isBitField()) {
       unsigned FieldNo = RL->getLLVMFieldNo(FD);
-      assert(AST_RL.getFieldOffset(i) == SL->getElementOffsetInBits(FieldNo) &&
+      assert(AST_RL.getFieldOffset(i) ==
+                 SL->getElementOffsetInBits(FieldNo).getKnownMinSize() &&
              "Invalid field offset!");
       continue;
     }
 
     // Ignore unnamed bit-fields.
     if (!FD->getDeclName())
       continue;