mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-12-14 15:19:33 +00:00
Rename DataLayout variables TD -> DL
llvm-svn: 191927
This commit is contained in:
Matt Arsenault
parent
a88c415234
commit
c43ade894d
@ -85,7 +85,7 @@ static inline CallInst *extractMallocCall(Value *I,
|
||||
/// isArrayMalloc - Returns the corresponding CallInst if the instruction
|
||||
/// is a call to malloc whose array size can be determined and the array size
|
||||
/// is not constant 1. Otherwise, return NULL.
|
||||
const CallInst *isArrayMalloc(const Value *I, const DataLayout *TD,
|
||||
const CallInst *isArrayMalloc(const Value *I, const DataLayout *DL,
|
||||
const TargetLibraryInfo *TLI);
|
||||
|
||||
/// getMallocType - Returns the PointerType resulting from the malloc call.
|
||||
@ -107,7 +107,7 @@ Type *getMallocAllocatedType(const CallInst *CI, const TargetLibraryInfo *TLI);
|
||||
/// then return that multiple. For non-array mallocs, the multiple is
|
||||
/// constant 1. Otherwise, return NULL for mallocs whose array size cannot be
|
||||
/// determined.
|
||||
Value *getMallocArraySize(CallInst *CI, const DataLayout *TD,
|
||||
Value *getMallocArraySize(CallInst *CI, const DataLayout *DL,
|
||||
const TargetLibraryInfo *TLI,
|
||||
bool LookThroughSExt = false);
|
||||
|
||||
@ -147,7 +147,7 @@ static inline CallInst *isFreeCall(Value *I, const TargetLibraryInfo *TLI) {
|
||||
/// underlying object pointed to by Ptr.
|
||||
/// If RoundToAlign is true, then Size is rounded up to the aligment of allocas,
|
||||
/// byval arguments, and global variables.
|
||||
bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout *TD,
|
||||
bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout *DL,
|
||||
const TargetLibraryInfo *TLI, bool RoundToAlign = false);
|
||||
|
||||
|
||||
@ -159,7 +159,7 @@ typedef std::pair<APInt, APInt> SizeOffsetType;
|
||||
class ObjectSizeOffsetVisitor
|
||||
: public InstVisitor<ObjectSizeOffsetVisitor, SizeOffsetType> {
|
||||
|
||||
const DataLayout *TD;
|
||||
const DataLayout *DL;
|
||||
const TargetLibraryInfo *TLI;
|
||||
bool RoundToAlign;
|
||||
unsigned IntTyBits;
|
||||
@ -173,7 +173,7 @@ class ObjectSizeOffsetVisitor
|
||||
}
|
||||
|
||||
public:
|
||||
ObjectSizeOffsetVisitor(const DataLayout *TD, const TargetLibraryInfo *TLI,
|
||||
ObjectSizeOffsetVisitor(const DataLayout *DL, const TargetLibraryInfo *TLI,
|
||||
LLVMContext &Context, bool RoundToAlign = false);
|
||||
|
||||
SizeOffsetType compute(Value *V);
|
||||
@ -220,7 +220,7 @@ class ObjectSizeOffsetEvaluator
|
||||
typedef DenseMap<const Value*, WeakEvalType> CacheMapTy;
|
||||
typedef SmallPtrSet<const Value*, 8> PtrSetTy;
|
||||
|
||||
const DataLayout *TD;
|
||||
const DataLayout *DL;
|
||||
const TargetLibraryInfo *TLI;
|
||||
LLVMContext &Context;
|
||||
BuilderTy Builder;
|
||||
@ -235,7 +235,7 @@ class ObjectSizeOffsetEvaluator
|
||||
SizeOffsetEvalType compute_(Value *V);
|
||||
|
||||
public:
|
||||
ObjectSizeOffsetEvaluator(const DataLayout *TD, const TargetLibraryInfo *TLI,
|
||||
ObjectSizeOffsetEvaluator(const DataLayout *DL, const TargetLibraryInfo *TLI,
|
||||
LLVMContext &Context);
|
||||
SizeOffsetEvalType compute(Value *V);
|
||||
|
||||
|
||||
@ -205,7 +205,7 @@ const CallInst *llvm::extractMallocCall(const Value *I,
|
||||
return isMallocLikeFn(I, TLI) ? dyn_cast<CallInst>(I) : 0;
|
||||
}
|
||||
|
||||
static Value *computeArraySize(const CallInst *CI, const DataLayout *TD,
|
||||
static Value *computeArraySize(const CallInst *CI, const DataLayout *DL,
|
||||
const TargetLibraryInfo *TLI,
|
||||
bool LookThroughSExt = false) {
|
||||
if (!CI)
|
||||
@ -213,12 +213,12 @@ static Value *computeArraySize(const CallInst *CI, const DataLayout *TD,
|
||||
|
||||
// The size of the malloc's result type must be known to determine array size.
|
||||
Type *T = getMallocAllocatedType(CI, TLI);
|
||||
if (!T || !T->isSized() || !TD)
|
||||
if (!T || !T->isSized() || !DL)
|
||||
return 0;
|
||||
|
||||
unsigned ElementSize = TD->getTypeAllocSize(T);
|
||||
unsigned ElementSize = DL->getTypeAllocSize(T);
|
||||
if (StructType *ST = dyn_cast<StructType>(T))
|
||||
ElementSize = TD->getStructLayout(ST)->getSizeInBytes();
|
||||
ElementSize = DL->getStructLayout(ST)->getSizeInBytes();
|
||||
|
||||
// If malloc call's arg can be determined to be a multiple of ElementSize,
|
||||
// return the multiple. Otherwise, return NULL.
|
||||
@ -235,10 +235,10 @@ static Value *computeArraySize(const CallInst *CI, const DataLayout *TD,
|
||||
/// is a call to malloc whose array size can be determined and the array size
|
||||
/// is not constant 1. Otherwise, return NULL.
|
||||
const CallInst *llvm::isArrayMalloc(const Value *I,
|
||||
const DataLayout *TD,
|
||||
const DataLayout *DL,
|
||||
const TargetLibraryInfo *TLI) {
|
||||
const CallInst *CI = extractMallocCall(I, TLI);
|
||||
Value *ArraySize = computeArraySize(CI, TD, TLI);
|
||||
Value *ArraySize = computeArraySize(CI, DL, TLI);
|
||||
|
||||
if (ConstantInt *ConstSize = dyn_cast_or_null<ConstantInt>(ArraySize))
|
||||
if (ConstSize->isOne())
|
||||
@ -296,11 +296,11 @@ Type *llvm::getMallocAllocatedType(const CallInst *CI,
|
||||
/// then return that multiple. For non-array mallocs, the multiple is
|
||||
/// constant 1. Otherwise, return NULL for mallocs whose array size cannot be
|
||||
/// determined.
|
||||
Value *llvm::getMallocArraySize(CallInst *CI, const DataLayout *TD,
|
||||
Value *llvm::getMallocArraySize(CallInst *CI, const DataLayout *DL,
|
||||
const TargetLibraryInfo *TLI,
|
||||
bool LookThroughSExt) {
|
||||
assert(isMallocLikeFn(CI, TLI) && "getMallocArraySize and not malloc call");
|
||||
return computeArraySize(CI, TD, TLI, LookThroughSExt);
|
||||
return computeArraySize(CI, DL, TLI, LookThroughSExt);
|
||||
}
|
||||
|
||||
|
||||
@ -362,12 +362,12 @@ const CallInst *llvm::isFreeCall(const Value *I, const TargetLibraryInfo *TLI) {
|
||||
/// object size in Size if successful, and false otherwise.
|
||||
/// If RoundToAlign is true, then Size is rounded up to the aligment of allocas,
|
||||
/// byval arguments, and global variables.
|
||||
bool llvm::getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout *TD,
|
||||
bool llvm::getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout *DL,
|
||||
const TargetLibraryInfo *TLI, bool RoundToAlign) {
|
||||
if (!TD)
|
||||
if (!DL)
|
||||
return false;
|
||||
|
||||
ObjectSizeOffsetVisitor Visitor(TD, TLI, Ptr->getContext(), RoundToAlign);
|
||||
ObjectSizeOffsetVisitor Visitor(DL, TLI, Ptr->getContext(), RoundToAlign);
|
||||
SizeOffsetType Data = Visitor.compute(const_cast<Value*>(Ptr));
|
||||
if (!Visitor.bothKnown(Data))
|
||||
return false;
|
||||
@ -394,12 +394,12 @@ APInt ObjectSizeOffsetVisitor::align(APInt Size, uint64_t Align) {
|
||||
return Size;
|
||||
}
|
||||
|
||||
ObjectSizeOffsetVisitor::ObjectSizeOffsetVisitor(const DataLayout *TD,
|
||||
ObjectSizeOffsetVisitor::ObjectSizeOffsetVisitor(const DataLayout *DL,
|
||||
const TargetLibraryInfo *TLI,
|
||||
LLVMContext &Context,
|
||||
bool RoundToAlign)
|
||||
: TD(TD), TLI(TLI), RoundToAlign(RoundToAlign) {
|
||||
IntegerType *IntTy = TD->getIntPtrType(Context);
|
||||
: DL(DL), TLI(TLI), RoundToAlign(RoundToAlign) {
|
||||
IntegerType *IntTy = DL->getIntPtrType(Context);
|
||||
IntTyBits = IntTy->getBitWidth();
|
||||
Zero = APInt::getNullValue(IntTyBits);
|
||||
}
|
||||
@ -442,7 +442,7 @@ SizeOffsetType ObjectSizeOffsetVisitor::visitAllocaInst(AllocaInst &I) {
|
||||
if (!I.getAllocatedType()->isSized())
|
||||
return unknown();
|
||||
|
||||
APInt Size(IntTyBits, TD->getTypeAllocSize(I.getAllocatedType()));
|
||||
APInt Size(IntTyBits, DL->getTypeAllocSize(I.getAllocatedType()));
|
||||
if (!I.isArrayAllocation())
|
||||
return std::make_pair(align(Size, I.getAlignment()), Zero);
|
||||
|
||||
@ -461,7 +461,7 @@ SizeOffsetType ObjectSizeOffsetVisitor::visitArgument(Argument &A) {
|
||||
return unknown();
|
||||
}
|
||||
PointerType *PT = cast<PointerType>(A.getType());
|
||||
APInt Size(IntTyBits, TD->getTypeAllocSize(PT->getElementType()));
|
||||
APInt Size(IntTyBits, DL->getTypeAllocSize(PT->getElementType()));
|
||||
return std::make_pair(align(Size, A.getParamAlignment()), Zero);
|
||||
}
|
||||
|
||||
@ -534,7 +534,7 @@ ObjectSizeOffsetVisitor::visitExtractValueInst(ExtractValueInst&) {
|
||||
SizeOffsetType ObjectSizeOffsetVisitor::visitGEPOperator(GEPOperator &GEP) {
|
||||
SizeOffsetType PtrData = compute(GEP.getPointerOperand());
|
||||
APInt Offset(IntTyBits, 0);
|
||||
if (!bothKnown(PtrData) || !GEP.accumulateConstantOffset(*TD, Offset))
|
||||
if (!bothKnown(PtrData) || !GEP.accumulateConstantOffset(*DL, Offset))
|
||||
return unknown();
|
||||
|
||||
return std::make_pair(PtrData.first, PtrData.second + Offset);
|
||||
@ -550,7 +550,7 @@ SizeOffsetType ObjectSizeOffsetVisitor::visitGlobalVariable(GlobalVariable &GV){
|
||||
if (!GV.hasDefinitiveInitializer())
|
||||
return unknown();
|
||||
|
||||
APInt Size(IntTyBits, TD->getTypeAllocSize(GV.getType()->getElementType()));
|
||||
APInt Size(IntTyBits, DL->getTypeAllocSize(GV.getType()->getElementType()));
|
||||
return std::make_pair(align(Size, GV.getAlignment()), Zero);
|
||||
}
|
||||
|
||||
@ -586,12 +586,11 @@ SizeOffsetType ObjectSizeOffsetVisitor::visitInstruction(Instruction &I) {
|
||||
return unknown();
|
||||
}
|
||||
|
||||
|
||||
ObjectSizeOffsetEvaluator::ObjectSizeOffsetEvaluator(const DataLayout *TD,
|
||||
const TargetLibraryInfo *TLI,
|
||||
ObjectSizeOffsetEvaluator::ObjectSizeOffsetEvaluator(const DataLayout *DL,
|
||||
const TargetLibraryInfo *TLI,
|
||||
LLVMContext &Context)
|
||||
: TD(TD), TLI(TLI), Context(Context), Builder(Context, TargetFolder(TD)) {
|
||||
IntTy = TD->getIntPtrType(Context);
|
||||
: DL(DL), TLI(TLI), Context(Context), Builder(Context, TargetFolder(DL)) {
|
||||
IntTy = DL->getIntPtrType(Context);
|
||||
Zero = ConstantInt::get(IntTy, 0);
|
||||
}
|
||||
|
||||
@ -615,7 +614,7 @@ SizeOffsetEvalType ObjectSizeOffsetEvaluator::compute(Value *V) {
|
||||
}
|
||||
|
||||
SizeOffsetEvalType ObjectSizeOffsetEvaluator::compute_(Value *V) {
|
||||
ObjectSizeOffsetVisitor Visitor(TD, TLI, Context);
|
||||
ObjectSizeOffsetVisitor Visitor(DL, TLI, Context);
|
||||
SizeOffsetType Const = Visitor.compute(V);
|
||||
if (Visitor.bothKnown(Const))
|
||||
return std::make_pair(ConstantInt::get(Context, Const.first),
|
||||
@ -675,7 +674,7 @@ SizeOffsetEvalType ObjectSizeOffsetEvaluator::visitAllocaInst(AllocaInst &I) {
|
||||
assert(I.isArrayAllocation());
|
||||
Value *ArraySize = I.getArraySize();
|
||||
Value *Size = ConstantInt::get(ArraySize->getType(),
|
||||
TD->getTypeAllocSize(I.getAllocatedType()));
|
||||
DL->getTypeAllocSize(I.getAllocatedType()));
|
||||
Size = Builder.CreateMul(Size, ArraySize);
|
||||
return std::make_pair(Size, Zero);
|
||||
}
|
||||
@ -727,7 +726,7 @@ ObjectSizeOffsetEvaluator::visitGEPOperator(GEPOperator &GEP) {
|
||||
if (!bothKnown(PtrData))
|
||||
return unknown();
|
||||
|
||||
Value *Offset = EmitGEPOffset(&Builder, *TD, &GEP, /*NoAssumptions=*/true);
|
||||
Value *Offset = EmitGEPOffset(&Builder, *DL, &GEP, /*NoAssumptions=*/true);
|
||||
Offset = Builder.CreateAdd(PtrData.second, Offset);
|
||||
return std::make_pair(PtrData.first, Offset);
|
||||
}
|
||||
|
||||
@ -284,13 +284,13 @@ void AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
|
||||
|
||||
SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM);
|
||||
|
||||
const DataLayout *TD = TM.getDataLayout();
|
||||
uint64_t Size = TD->getTypeAllocSize(GV->getType()->getElementType());
|
||||
const DataLayout *DL = TM.getDataLayout();
|
||||
uint64_t Size = DL->getTypeAllocSize(GV->getType()->getElementType());
|
||||
|
||||
// If the alignment is specified, we *must* obey it. Overaligning a global
|
||||
// with a specified alignment is a prompt way to break globals emitted to
|
||||
// sections and expected to be contiguous (e.g. ObjC metadata).
|
||||
unsigned AlignLog = getGVAlignmentLog2(GV, *TD);
|
||||
unsigned AlignLog = getGVAlignmentLog2(GV, *DL);
|
||||
|
||||
if (DD)
|
||||
DD->setSymbolSize(GVSym, Size);
|
||||
@ -398,7 +398,7 @@ void AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
|
||||
// - __tlv_bootstrap - used to make sure support exists
|
||||
// - spare pointer, used when mapped by the runtime
|
||||
// - pointer to mangled symbol above with initializer
|
||||
unsigned PtrSize = TD->getPointerSizeInBits()/8;
|
||||
unsigned PtrSize = DL->getPointerSizeInBits()/8;
|
||||
OutStreamer.EmitSymbolValue(GetExternalSymbolSymbol("_tlv_bootstrap"),
|
||||
PtrSize);
|
||||
OutStreamer.EmitIntValue(0, PtrSize);
|
||||
@ -1317,8 +1317,8 @@ void AsmPrinter::EmitXXStructorList(const Constant *List, bool isCtor) {
|
||||
}
|
||||
|
||||
// Emit the function pointers in the target-specific order
|
||||
const DataLayout *TD = TM.getDataLayout();
|
||||
unsigned Align = Log2_32(TD->getPointerPrefAlignment());
|
||||
const DataLayout *DL = TM.getDataLayout();
|
||||
unsigned Align = Log2_32(DL->getPointerPrefAlignment());
|
||||
std::stable_sort(Structors.begin(), Structors.end(), less_first());
|
||||
for (unsigned i = 0, e = Structors.size(); i != e; ++i) {
|
||||
const MCSection *OutputSection =
|
||||
@ -1412,7 +1412,7 @@ void AsmPrinter::EmitLabelOffsetDifference(const MCSymbol *Hi, uint64_t Offset,
|
||||
void AsmPrinter::EmitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset,
|
||||
unsigned Size, bool IsSectionRelative)
|
||||
const {
|
||||
if (MAI->needsDwarfSectionOffsetDirective() && IsSectionRelative) {
|
||||
if (MAI->needsDwarfSectionOffsetDirective() && IsSectionRelative) {
|
||||
OutStreamer.EmitCOFFSecRel32(Label);
|
||||
return;
|
||||
}
|
||||
@ -1493,10 +1493,10 @@ static const MCExpr *lowerConstant(const Constant *CV, AsmPrinter &AP) {
|
||||
report_fatal_error(OS.str());
|
||||
}
|
||||
case Instruction::GetElementPtr: {
|
||||
const DataLayout &TD = *AP.TM.getDataLayout();
|
||||
const DataLayout &DL = *AP.TM.getDataLayout();
|
||||
// Generate a symbolic expression for the byte address
|
||||
APInt OffsetAI(TD.getPointerSizeInBits(), 0);
|
||||
cast<GEPOperator>(CE)->accumulateConstantOffset(TD, OffsetAI);
|
||||
APInt OffsetAI(DL.getPointerSizeInBits(), 0);
|
||||
cast<GEPOperator>(CE)->accumulateConstantOffset(DL, OffsetAI);
|
||||
|
||||
const MCExpr *Base = lowerConstant(CE->getOperand(0), AP);
|
||||
if (!OffsetAI)
|
||||
@ -1517,17 +1517,17 @@ static const MCExpr *lowerConstant(const Constant *CV, AsmPrinter &AP) {
|
||||
return lowerConstant(CE->getOperand(0), AP);
|
||||
|
||||
case Instruction::IntToPtr: {
|
||||
const DataLayout &TD = *AP.TM.getDataLayout();
|
||||
const DataLayout &DL = *AP.TM.getDataLayout();
|
||||
// Handle casts to pointers by changing them into casts to the appropriate
|
||||
// integer type. This promotes constant folding and simplifies this code.
|
||||
Constant *Op = CE->getOperand(0);
|
||||
Op = ConstantExpr::getIntegerCast(Op, TD.getIntPtrType(CV->getContext()),
|
||||
Op = ConstantExpr::getIntegerCast(Op, DL.getIntPtrType(CV->getContext()),
|
||||
false/*ZExt*/);
|
||||
return lowerConstant(Op, AP);
|
||||
}
|
||||
|
||||
case Instruction::PtrToInt: {
|
||||
const DataLayout &TD = *AP.TM.getDataLayout();
|
||||
const DataLayout &DL = *AP.TM.getDataLayout();
|
||||
// Support only foldable casts to/from pointers that can be eliminated by
|
||||
// changing the pointer to the appropriately sized integer type.
|
||||
Constant *Op = CE->getOperand(0);
|
||||
@ -1537,13 +1537,13 @@ static const MCExpr *lowerConstant(const Constant *CV, AsmPrinter &AP) {
|
||||
|
||||
// We can emit the pointer value into this slot if the slot is an
|
||||
// integer slot equal to the size of the pointer.
|
||||
if (TD.getTypeAllocSize(Ty) == TD.getTypeAllocSize(Op->getType()))
|
||||
if (DL.getTypeAllocSize(Ty) == DL.getTypeAllocSize(Op->getType()))
|
||||
return OpExpr;
|
||||
|
||||
// Otherwise the pointer is smaller than the resultant integer, mask off
|
||||
// the high bits so we are sure to get a proper truncation if the input is
|
||||
// a constant expr.
|
||||
unsigned InBits = TD.getTypeAllocSizeInBits(Op->getType());
|
||||
unsigned InBits = DL.getTypeAllocSizeInBits(Op->getType());
|
||||
const MCExpr *MaskExpr = MCConstantExpr::Create(~0ULL >> (64-InBits), Ctx);
|
||||
return MCBinaryExpr::CreateAnd(OpExpr, MaskExpr, Ctx);
|
||||
}
|
||||
@ -1694,9 +1694,9 @@ static void emitGlobalConstantDataSequential(const ConstantDataSequential *CDS,
|
||||
}
|
||||
}
|
||||
|
||||
const DataLayout &TD = *AP.TM.getDataLayout();
|
||||
unsigned Size = TD.getTypeAllocSize(CDS->getType());
|
||||
unsigned EmittedSize = TD.getTypeAllocSize(CDS->getType()->getElementType()) *
|
||||
const DataLayout &DL = *AP.TM.getDataLayout();
|
||||
unsigned Size = DL.getTypeAllocSize(CDS->getType());
|
||||
unsigned EmittedSize = DL.getTypeAllocSize(CDS->getType()->getElementType()) *
|
||||
CDS->getNumElements();
|
||||
if (unsigned Padding = Size - EmittedSize)
|
||||
AP.OutStreamer.EmitZeros(Padding);
|
||||
@ -1722,9 +1722,9 @@ static void emitGlobalConstantVector(const ConstantVector *CV, AsmPrinter &AP) {
|
||||
for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i)
|
||||
emitGlobalConstantImpl(CV->getOperand(i), AP);
|
||||
|
||||
const DataLayout &TD = *AP.TM.getDataLayout();
|
||||
unsigned Size = TD.getTypeAllocSize(CV->getType());
|
||||
unsigned EmittedSize = TD.getTypeAllocSize(CV->getType()->getElementType()) *
|
||||
const DataLayout &DL = *AP.TM.getDataLayout();
|
||||
unsigned Size = DL.getTypeAllocSize(CV->getType());
|
||||
unsigned EmittedSize = DL.getTypeAllocSize(CV->getType()->getElementType()) *
|
||||
CV->getType()->getNumElements();
|
||||
if (unsigned Padding = Size - EmittedSize)
|
||||
AP.OutStreamer.EmitZeros(Padding);
|
||||
@ -1732,15 +1732,15 @@ static void emitGlobalConstantVector(const ConstantVector *CV, AsmPrinter &AP) {
|
||||
|
||||
static void emitGlobalConstantStruct(const ConstantStruct *CS, AsmPrinter &AP) {
|
||||
// Print the fields in successive locations. Pad to align if needed!
|
||||
const DataLayout *TD = AP.TM.getDataLayout();
|
||||
unsigned Size = TD->getTypeAllocSize(CS->getType());
|
||||
const StructLayout *Layout = TD->getStructLayout(CS->getType());
|
||||
const DataLayout *DL = AP.TM.getDataLayout();
|
||||
unsigned 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);
|
||||
|
||||
// Check if padding is needed and insert one or more 0s.
|
||||
uint64_t FieldSize = TD->getTypeAllocSize(Field->getType());
|
||||
uint64_t FieldSize = DL->getTypeAllocSize(Field->getType());
|
||||
uint64_t PadSize = ((i == e-1 ? Size : Layout->getElementOffset(i+1))
|
||||
- Layout->getElementOffset(i)) - FieldSize;
|
||||
SizeSoFar += FieldSize + PadSize;
|
||||
@ -1797,13 +1797,13 @@ static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP) {
|
||||
}
|
||||
|
||||
// Emit the tail padding for the long double.
|
||||
const DataLayout &TD = *AP.TM.getDataLayout();
|
||||
AP.OutStreamer.EmitZeros(TD.getTypeAllocSize(CFP->getType()) -
|
||||
TD.getTypeStoreSize(CFP->getType()));
|
||||
const DataLayout &DL = *AP.TM.getDataLayout();
|
||||
AP.OutStreamer.EmitZeros(DL.getTypeAllocSize(CFP->getType()) -
|
||||
DL.getTypeStoreSize(CFP->getType()));
|
||||
}
|
||||
|
||||
static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP) {
|
||||
const DataLayout *TD = AP.TM.getDataLayout();
|
||||
const DataLayout *DL = AP.TM.getDataLayout();
|
||||
unsigned BitWidth = CI->getBitWidth();
|
||||
|
||||
// Copy the value as we may massage the layout for constants whose bit width
|
||||
@ -1820,7 +1820,7 @@ static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP) {
|
||||
// Big endian:
|
||||
// * Record the extra bits to emit.
|
||||
// * Realign the raw data to emit the chunks of 64-bits.
|
||||
if (TD->isBigEndian()) {
|
||||
if (DL->isBigEndian()) {
|
||||
// Basically the structure of the raw data is a chunk of 64-bits cells:
|
||||
// 0 1 BitWidth / 64
|
||||
// [chunk1][chunk2] ... [chunkN].
|
||||
@ -1841,7 +1841,7 @@ static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP) {
|
||||
// quantities at a time.
|
||||
const uint64_t *RawData = Realigned.getRawData();
|
||||
for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) {
|
||||
uint64_t Val = TD->isBigEndian() ? RawData[e - i - 1] : RawData[i];
|
||||
uint64_t Val = DL->isBigEndian() ? RawData[e - i - 1] : RawData[i];
|
||||
AP.OutStreamer.EmitIntValue(Val, 8);
|
||||
}
|
||||
|
||||
@ -1859,8 +1859,8 @@ static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP) {
|
||||
}
|
||||
|
||||
static void emitGlobalConstantImpl(const Constant *CV, AsmPrinter &AP) {
|
||||
const DataLayout *TD = AP.TM.getDataLayout();
|
||||
uint64_t Size = TD->getTypeAllocSize(CV->getType());
|
||||
const DataLayout *DL = AP.TM.getDataLayout();
|
||||
uint64_t Size = DL->getTypeAllocSize(CV->getType());
|
||||
if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV))
|
||||
return AP.OutStreamer.EmitZeros(Size);
|
||||
|
||||
@ -1908,7 +1908,7 @@ static void emitGlobalConstantImpl(const Constant *CV, AsmPrinter &AP) {
|
||||
// If the constant expression's size is greater than 64-bits, then we have
|
||||
// to emit the value in chunks. Try to constant fold the value and emit it
|
||||
// that way.
|
||||
Constant *New = ConstantFoldConstantExpression(CE, TD);
|
||||
Constant *New = ConstantFoldConstantExpression(CE, DL);
|
||||
if (New && New != CE)
|
||||
return emitGlobalConstantImpl(New, AP);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user