return CharUnits(Quantity);
}
- /// fromAlign - Construct a CharUnits quantity from an llvm::Align
+ /// fromQuantity - Construct a CharUnits quantity from an llvm::Align
/// quantity.
- static CharUnits fromAlign(llvm::Align Quantity) {
+ static CharUnits fromQuantity(llvm::Align Quantity) {
return CharUnits(Quantity.value());
}
for (auto *I : Helper->getCustomFieldTypes()) /* custom fields */ {
// TargetOpenCLBlockHelp needs to make sure the struct is packed.
// If necessary, add padding fields to the custom fields.
- unsigned Align = CGM.getDataLayout().getABITypeAlignment(I);
+ unsigned Align = CGM.getDataLayout().getABITypeAlign(I).value();
if (BlockAlign < Align)
BlockAlign = Align;
assert(Offset % Align == 0);
size = varOffset;
// Conversely, we might have to prevent LLVM from inserting padding.
- } else if (CGM.getDataLayout().getABITypeAlignment(varTy) >
+ } else if (CGM.getDataLayout().getABITypeAlign(varTy) >
uint64_t(varAlign.getQuantity())) {
packed = true;
}
const Twine &Name = "tmp") {
// Don't use an alignment that's worse than what LLVM would prefer.
auto PrefAlign = CGF.CGM.getDataLayout().getPrefTypeAlign(Ty);
- CharUnits Align = std::max(MinAlign, CharUnits::fromAlign(PrefAlign));
+ CharUnits Align = std::max(MinAlign, CharUnits::fromQuantity(PrefAlign));
return CGF.CreateTempAlloca(Ty, Align, Name + ".coerce");
}
// Materialize to a temporary.
addr = CreateTempAlloca(
RV.getScalarVal()->getType(),
- CharUnits::fromAlign(std::max(layout->getAlignment(), scalarAlign)),
+ CharUnits::fromQuantity(std::max(layout->getAlignment(), scalarAlign)),
"tmp",
/*ArraySize=*/nullptr, &AllocaAddr);
tempSize = EmitLifetimeStart(scalarSize, AllocaAddr.getPointer());
Address CodeGenFunction::CreateDefaultAlignTempAlloca(llvm::Type *Ty,
const Twine &Name) {
CharUnits Align =
- CharUnits::fromAlign(CGM.getDataLayout().getPrefTypeAlign(Ty));
+ CharUnits::fromQuantity(CGM.getDataLayout().getPrefTypeAlign(Ty));
return CreateTempAlloca(Ty, Align, Name);
}
CharUnits getAlignment(const llvm::Constant *C) const {
return CharUnits::fromQuantity(
- CGM.getDataLayout().getABITypeAlignment(C->getType()));
+ CGM.getDataLayout().getABITypeAlign(C->getType()));
}
CharUnits getSize(llvm::Type *Ty) const {
llvm::GlobalVariable *GV = new llvm::GlobalVariable(
CGM.getModule(), Init->getType(), false,
llvm::GlobalValue::PrivateLinkage, Init, SymbolName);
- GV->setAlignment(
- llvm::Align(CGM.getDataLayout().getABITypeAlignment(Init->getType())));
+ GV->setAlignment(CGM.getDataLayout().getABITypeAlign(Init->getType()));
GV->setSection(SectionName);
CGM.addCompilerUsedGlobal(GV);
}
if (CGM.getTriple().isOSBinFormatMachO())
GV->setSection("__DATA, __objc_data");
- GV->setAlignment(llvm::Align(
- CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ClassnfABITy)));
+ GV->setAlignment(CGM.getDataLayout().getABITypeAlign(ObjCTypes.ClassnfABITy));
if (!CGM.getTriple().isOSBinFormatCOFF())
if (HiddenVisibility)
GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
llvm::GlobalVariable *IvarOffsetGV = ObjCIvarOffsetVariable(ID, Ivar);
IvarOffsetGV->setInitializer(
llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
- IvarOffsetGV->setAlignment(llvm::Align(
- CGM.getDataLayout().getABITypeAlignment(ObjCTypes.IvarOffsetVarTy)));
+ IvarOffsetGV->setAlignment(
+ CGM.getDataLayout().getABITypeAlign(ObjCTypes.IvarOffsetVarTy));
if (!CGM.getTriple().isOSBinFormatCOFF()) {
// FIXME: This matches gcc, but shouldn't the visibility be set on the use
ProtocolRef);
if (!CGM.getTriple().isOSBinFormatMachO())
PTGV->setComdat(CGM.getModule().getOrInsertComdat(ProtocolRef));
- PTGV->setAlignment(llvm::Align(
- CGM.getDataLayout().getABITypeAlignment(ObjCTypes.ProtocolnfABIPtrTy)));
+ PTGV->setAlignment(
+ CGM.getDataLayout().getABITypeAlign(ObjCTypes.ProtocolnfABIPtrTy));
PTGV->setSection(GetSectionName("__objc_protolist",
"coalesced,no_dead_strip"));
PTGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
return CharUnits::fromQuantity(DataLayout.getTypeAllocSize(Type));
}
CharUnits getAlignment(llvm::Type *Type) {
- return CharUnits::fromQuantity(DataLayout.getABITypeAlignment(Type));
+ return CharUnits::fromQuantity(DataLayout.getABITypeAlign(Type));
}
bool isZeroInitializable(const FieldDecl *FD) {
return Types.isZeroInitializable(FD->getType());
llvm::ArrayType *ArrayType =
llvm::ArrayType::get(CGM.Int8PtrTy, Builder.getVTTComponents().size());
- unsigned Align = CGM.getDataLayout().getABITypeAlignment(CGM.Int8PtrTy);
+ llvm::Align Align = CGM.getDataLayout().getABITypeAlign(CGM.Int8PtrTy);
llvm::GlobalVariable *GV = CGM.CreateOrReplaceCXXRuntimeVariable(
Name, ArrayType, llvm::GlobalValue::ExternalLinkage, Align);
if (Linkage == llvm::GlobalVariable::AvailableExternallyLinkage)
Linkage = llvm::GlobalVariable::InternalLinkage;
- unsigned Align = CGM.getDataLayout().getABITypeAlignment(VTType);
+ llvm::Align Align = CGM.getDataLayout().getABITypeAlign(VTType);
// Create the variable that will hold the construction vtable.
llvm::GlobalVariable *VTable =
if (!needsSaving(value)) return saved_type(value, false);
// Otherwise, we need an alloca.
- auto align = CharUnits::fromAlign(
+ auto align = CharUnits::fromQuantity(
CGF.CGM.getDataLayout().getPrefTypeAlign(value->getType()));
Address alloca =
CGF.CreateTempAlloca(value->getType(), align, "cond-cleanup.save");
llvm::GlobalVariable *CodeGenModule::CreateOrReplaceCXXRuntimeVariable(
StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage,
- unsigned Alignment) {
+ llvm::Align Alignment) {
llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
llvm::GlobalVariable *OldGV = nullptr;
!GV->hasAvailableExternallyLinkage())
GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
- GV->setAlignment(llvm::MaybeAlign(Alignment));
+ GV->setAlignment(Alignment);
return GV;
}
llvm::GlobalVariable *
CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty,
llvm::GlobalValue::LinkageTypes Linkage,
- unsigned Alignment);
+ llvm::Align Alignment);
llvm::Function *CreateGlobalInitOrCleanUpFunction(
llvm::FunctionType *ty, const Twine &name, const CGFunctionInfo &FI,
// Advance the offset past that field.
auto &layout = Builder.CGM.getDataLayout();
if (!Packed)
- offset = offset.alignTo(CharUnits::fromQuantity(
- layout.getABITypeAlignment(type)));
+ offset = offset.alignTo(CharUnits::fromQuantity(layout.getABITypeAlign(type)));
offset += CharUnits::fromQuantity(layout.getTypeStoreSize(type));
CachedOffsetEnd = Builder.Buffer.size();
"cannot compute offset when a placeholder is present");
llvm::Type *elementType = element->getType();
if (!Packed)
- offset = offset.alignTo(CharUnits::fromQuantity(
- layout.getABITypeAlignment(elementType)));
+ offset = offset.alignTo(
+ CharUnits::fromQuantity(layout.getABITypeAlign(elementType)));
offset += CharUnits::fromQuantity(layout.getTypeStoreSize(elementType));
} while (++cacheEnd != end);
}
VTable = CGM.CreateOrReplaceCXXRuntimeVariable(
Name, VTableType, llvm::GlobalValue::ExternalLinkage,
- getContext().toCharUnitsFromBits(PAlign).getQuantity());
+ getContext().toCharUnitsFromBits(PAlign).getAsAlign());
VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
// In MS C++ if you have a class with virtual functions in which you are using
guardAlignment = CGF.getSizeAlign();
} else {
guardTy = CGF.Int64Ty;
- guardAlignment = CharUnits::fromQuantity(
- CGM.getDataLayout().getABITypeAlignment(guardTy));
+ guardAlignment =
+ CharUnits::fromQuantity(CGM.getDataLayout().getABITypeAlign(guardTy));
}
}
llvm::PointerType *guardPtrTy = guardTy->getPointerTo(
auto Align = CGM.getContext().getTypeAlignInChars(CGM.getContext().CharTy);
llvm::GlobalVariable *GV = CGM.CreateOrReplaceCXXRuntimeVariable(
- Name, Init->getType(), Linkage, Align.getQuantity());
+ Name, Init->getType(), Linkage, Align.getAsAlign());
GV->setInitializer(Init);
CharUnits Alignment =
CGM.getContext().getTypeAlignInChars(CGM.getContext().IntTy);
llvm::GlobalVariable *GV = CGM.CreateOrReplaceCXXRuntimeVariable(
- Name, VBTableType, Linkage, Alignment.getQuantity());
+ Name, VBTableType, Linkage, Alignment.getAsAlign());
GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
if (RD->hasAttr<DLLImportAttr>())
hasPadding = true;
}
- if (!packed && !entry.Begin.isMultipleOf(
- CharUnits::fromQuantity(
- CGM.getDataLayout().getABITypeAlignment(entry.Type))))
+ if (!packed && !entry.Begin.isMultipleOf(CharUnits::fromQuantity(
+ CGM.getDataLayout().getABITypeAlign(entry.Type))))
packed = true;
elts.push_back(entry.Type);
if (!isPowerOf2(size)) {
size = 1ULL << (llvm::findLastSet(size, llvm::ZB_Undefined) + 1);
}
- assert(size >= CGM.getDataLayout().getABITypeAlignment(type));
+ assert(CGM.getDataLayout().getABITypeAlign(type) <= size);
return CharUnits::fromQuantity(size);
}
// (e.g. i32 and i32) then the resultant struct type ({i32,i32}) won't have
// the second element at offset 8. Check for this:
unsigned LoSize = (unsigned)TD.getTypeAllocSize(Lo);
- unsigned HiAlign = TD.getABITypeAlignment(Hi);
+ llvm::Align HiAlign = TD.getABITypeAlign(Hi);
unsigned HiStart = llvm::alignTo(LoSize, HiAlign);
assert(HiStart != 0 && HiStart <= 8 && "Invalid x86-64 argument pair!");
// FIXME: Our choice of alignment here and below is probably pessimistic.
llvm::Value *V = CGF.Builder.CreateAlignedLoad(
TyLo, CGF.Builder.CreateBitCast(RegLoAddr, PTyLo),
- CharUnits::fromQuantity(getDataLayout().getABITypeAlignment(TyLo)));
+ CharUnits::fromQuantity(getDataLayout().getABITypeAlign(TyLo)));
CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 0));
// Copy the second element.
V = CGF.Builder.CreateAlignedLoad(
TyHi, CGF.Builder.CreateBitCast(RegHiAddr, PTyHi),
- CharUnits::fromQuantity(getDataLayout().getABITypeAlignment(TyHi)));
+ CharUnits::fromQuantity(getDataLayout().getABITypeAlign(TyHi)));
CGF.Builder.CreateStore(V, CGF.Builder.CreateStructGEP(Tmp, 1));
RegAddr = CGF.Builder.CreateElementBitCast(Tmp, LTy);
}
CharUnits Field2Align =
- CharUnits::fromQuantity(getDataLayout().getABITypeAlignment(Field2Ty));
+ CharUnits::fromQuantity(getDataLayout().getABITypeAlign(Field2Ty));
CharUnits Field1End = Field1Off +
CharUnits::fromQuantity(getDataLayout().getTypeStoreSize(Field1Ty));
CharUnits Field2OffNoPadNoPack = Field1End.alignTo(Field2Align);
}
CharUnits Field2Align =
- CharUnits::fromQuantity(getDataLayout().getABITypeAlignment(Field2Ty));
+ CharUnits::fromQuantity(getDataLayout().getABITypeAlign(Field2Ty));
CharUnits Field1End =
Field1Off +
CharUnits::fromQuantity(getDataLayout().getTypeStoreSize(Field1Ty));