[llvm] aa1b64c - [BuildLibCalls] Use TLI to get 'int' and 'size_t' type sizes
Bjorn Pettersson via llvm-commits
llvm-commits at lists.llvm.org
Tue Oct 4 03:52:43 PDT 2022
Author: Bjorn Pettersson
Date: 2022-10-04T12:52:05+02:00
New Revision: aa1b64cc425665a529816505eea272927ab6a589
URL: https://github.com/llvm/llvm-project/commit/aa1b64cc425665a529816505eea272927ab6a589
DIFF: https://github.com/llvm/llvm-project/commit/aa1b64cc425665a529816505eea272927ab6a589.diff
LOG: [BuildLibCalls] Use TLI to get 'int' and 'size_t' type sizes
Stop assuming that an 'int' is 32 bits in helpers that emit libcalls
to lib functions that had 'int' in the signature. For most targets
this is NFC. For a target with 16 bit 'int' type this could help out
detecting if trying to emit a libcall with incorrect signature.
Similarly we now derive the type mapping to 'size_t' by asking TLI
about the size of 'size_t'. This should be NFC (at least for in-tree
targets) since getSizeTSize(), in TLI, is deriving the size in the
same way as DataLayout::getIntPtrType().
Differential Revision: https://reviews.llvm.org/D135065
Added:
Modified:
llvm/include/llvm/IR/IRBuilder.h
llvm/include/llvm/Transforms/Utils/BuildLibCalls.h
llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
llvm/lib/Transforms/Scalar/MergeICmps.cpp
llvm/lib/Transforms/Utils/BuildLibCalls.cpp
llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h
index a718dc487386f..f402ebfe806bc 100644
--- a/llvm/include/llvm/IR/IRBuilder.h
+++ b/llvm/include/llvm/IR/IRBuilder.h
@@ -558,7 +558,8 @@ class IRBuilderBase {
return Type::getInt8PtrTy(Context, AddrSpace);
}
- /// Fetch the type representing a pointer to an integer value.
+ /// Fetch the type of an integer with size at least as big as that of a
+ /// pointer in the given address space.
IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) {
return DL.getIntPtrType(Context, AddrSpace);
}
diff --git a/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h b/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h
index ae287c0fa1636..8941ca4889ada 100644
--- a/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h
+++ b/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h
@@ -237,7 +237,7 @@ namespace llvm {
const TargetLibraryInfo *TLI);
/// Emit a call to the fwrite function. This assumes that Ptr is a pointer,
- /// Size is an 'intptr_t', and File is a pointer to FILE.
+ /// Size is an 'size_t', and File is a pointer to FILE.
Value *emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B,
const DataLayout &DL, const TargetLibraryInfo *TLI);
diff --git a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
index 2f9988bfe8a40..0036020dd6ee1 100644
--- a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
+++ b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
@@ -1788,10 +1788,9 @@ struct DSEState {
!memoryIsNotModifiedBetween(Malloc, MemSet, BatchAA, DL, &DT))
return false;
IRBuilder<> IRB(Malloc);
- const auto &DL = Malloc->getModule()->getDataLayout();
- auto *Calloc =
- emitCalloc(ConstantInt::get(IRB.getIntPtrTy(DL), 1),
- Malloc->getArgOperand(0), IRB, TLI);
+ Type *SizeTTy = Malloc->getArgOperand(0)->getType();
+ auto *Calloc = emitCalloc(ConstantInt::get(SizeTTy, 1),
+ Malloc->getArgOperand(0), IRB, TLI);
if (!Calloc)
return false;
MemorySSAUpdater Updater(&MSSA);
diff --git a/llvm/lib/Transforms/Scalar/MergeICmps.cpp b/llvm/lib/Transforms/Scalar/MergeICmps.cpp
index ce01ae5b26926..e0223dbf889ff 100644
--- a/llvm/lib/Transforms/Scalar/MergeICmps.cpp
+++ b/llvm/lib/Transforms/Scalar/MergeICmps.cpp
@@ -645,14 +645,18 @@ static BasicBlock *mergeComparisons(ArrayRef<BCECmpBlock> Comparisons,
Comparisons.begin(), Comparisons.end(), 0u,
[](int Size, const BCECmpBlock &C) { return Size + C.SizeBits(); });
+ // memcmp expects a 'size_t' argument and returns 'int'.
+ unsigned SizeTBits = TLI.getSizeTSize(*Phi.getModule());
+ unsigned IntBits = TLI.getIntSize();
+
// Create memcmp() == 0.
const auto &DL = Phi.getModule()->getDataLayout();
Value *const MemCmpCall = emitMemCmp(
Lhs, Rhs,
- ConstantInt::get(DL.getIntPtrType(Context), TotalSizeBits / 8), Builder,
- DL, &TLI);
+ ConstantInt::get(Builder.getIntNTy(SizeTBits), TotalSizeBits / 8),
+ Builder, DL, &TLI);
IsEqual = Builder.CreateICmpEQ(
- MemCmpCall, ConstantInt::get(Type::getInt32Ty(Context), 0));
+ MemCmpCall, ConstantInt::get(Builder.getIntNTy(IntBits), 0));
}
BasicBlock *const PhiBB = Phi.getParent();
diff --git a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp
index 80e882d59f690..b55af3bb48f71 100644
--- a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp
+++ b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp
@@ -1421,6 +1421,15 @@ Value *llvm::castToCStr(Value *V, IRBuilderBase &B) {
return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
}
+static IntegerType *getIntTy(IRBuilderBase &B, const TargetLibraryInfo *TLI) {
+ return B.getIntNTy(TLI->getIntSize());
+}
+
+static IntegerType *getSizeTTy(IRBuilderBase &B, const TargetLibraryInfo *TLI) {
+ const Module *M = B.GetInsertBlock()->getModule();
+ return B.getIntNTy(TLI->getSizeTSize(*M));
+}
+
static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
ArrayRef<Type *> ParamTypes,
ArrayRef<Value *> Operands, IRBuilderBase &B,
@@ -1443,8 +1452,7 @@ static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
const TargetLibraryInfo *TLI) {
- LLVMContext &Context = B.GetInsertBlock()->getContext();
- Type *SizeTTy = DL.getIntPtrType(Context);
+ Type *SizeTTy = getSizeTTy(B, TLI);
return emitLibCall(LibFunc_strlen, SizeTTy,
B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI);
}
@@ -1458,16 +1466,15 @@ Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B,
Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
const TargetLibraryInfo *TLI) {
Type *I8Ptr = B.getInt8PtrTy();
- Type *IntTy = B.getInt32Ty();
+ Type *IntTy = getIntTy(B, TLI);
return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, IntTy},
{castToCStr(Ptr, B), ConstantInt::get(IntTy, C)}, B, TLI);
}
Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
const DataLayout &DL, const TargetLibraryInfo *TLI) {
- LLVMContext &Context = B.GetInsertBlock()->getContext();
- Type *SizeTTy = DL.getIntPtrType(Context);
- Type *IntTy = B.getInt32Ty();
+ Type *IntTy = getIntTy(B, TLI);
+ Type *SizeTTy = getSizeTTy(B, TLI);
return emitLibCall(
LibFunc_strncmp, IntTy,
{B.getInt8PtrTy(), B.getInt8PtrTy(), SizeTTy},
@@ -1491,7 +1498,7 @@ Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B,
Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
const TargetLibraryInfo *TLI) {
Type *I8Ptr = B.getInt8PtrTy();
- Type *SizeTTy = Len->getType();
+ Type *SizeTTy = getSizeTTy(B, TLI);
return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, SizeTTy},
{castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
}
@@ -1499,7 +1506,7 @@ Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
const TargetLibraryInfo *TLI) {
Type *I8Ptr = B.getInt8PtrTy();
- Type *SizeTTy = Len->getType();
+ Type *SizeTTy = getSizeTTy(B, TLI);
return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, SizeTTy},
{castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
}
@@ -1514,9 +1521,8 @@ Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
AttributeList AS;
AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
Attribute::NoUnwind);
- LLVMContext &Context = B.GetInsertBlock()->getContext();
Type *I8Ptr = B.getInt8PtrTy();
- Type *SizeTTy = DL.getIntPtrType(Context);
+ Type *SizeTTy = getSizeTTy(B, TLI);
FunctionCallee MemCpy = getOrInsertLibFunc(M, *TLI, LibFunc_memcpy_chk,
AttributeList::get(M->getContext(), AS), I8Ptr,
I8Ptr, I8Ptr, SizeTTy, SizeTTy);
@@ -1531,9 +1537,8 @@ Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
Value *llvm::emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
const DataLayout &DL, const TargetLibraryInfo *TLI) {
- LLVMContext &Context = B.GetInsertBlock()->getContext();
Type *I8Ptr = B.getInt8PtrTy();
- Type *SizeTTy = DL.getIntPtrType(Context);
+ Type *SizeTTy = getSizeTTy(B, TLI);
return emitLibCall(LibFunc_mempcpy, I8Ptr,
{I8Ptr, I8Ptr, SizeTTy},
{Dst, Src, Len}, B, TLI);
@@ -1541,10 +1546,9 @@ Value *llvm::emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
const DataLayout &DL, const TargetLibraryInfo *TLI) {
- LLVMContext &Context = B.GetInsertBlock()->getContext();
Type *I8Ptr = B.getInt8PtrTy();
- Type *IntTy = B.getInt32Ty();
- Type *SizeTTy = DL.getIntPtrType(Context);
+ Type *IntTy = getIntTy(B, TLI);
+ Type *SizeTTy = getSizeTTy(B, TLI);
return emitLibCall(LibFunc_memchr, I8Ptr,
{I8Ptr, IntTy, SizeTTy},
{castToCStr(Ptr, B), Val, Len}, B, TLI);
@@ -1552,10 +1556,9 @@ Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
Value *llvm::emitMemRChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
const DataLayout &DL, const TargetLibraryInfo *TLI) {
- LLVMContext &Context = B.GetInsertBlock()->getContext();
Type *I8Ptr = B.getInt8PtrTy();
- Type *IntTy = B.getInt32Ty();
- Type *SizeTTy = DL.getIntPtrType(Context);
+ Type *IntTy = getIntTy(B, TLI);
+ Type *SizeTTy = getSizeTTy(B, TLI);
return emitLibCall(LibFunc_memrchr, I8Ptr,
{I8Ptr, IntTy, SizeTTy},
{castToCStr(Ptr, B), Val, Len}, B, TLI);
@@ -1563,45 +1566,40 @@ Value *llvm::emitMemRChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
const DataLayout &DL, const TargetLibraryInfo *TLI) {
- LLVMContext &Context = B.GetInsertBlock()->getContext();
Type *I8Ptr = B.getInt8PtrTy();
- Type *IntTy = B.getInt32Ty();
- Type *SizeTTy = DL.getIntPtrType(Context);
- return emitLibCall(
- LibFunc_memcmp, IntTy,
- {I8Ptr, I8Ptr, SizeTTy},
- {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
+ Type *IntTy = getIntTy(B, TLI);
+ Type *SizeTTy = getSizeTTy(B, TLI);
+ return emitLibCall(LibFunc_memcmp, IntTy,
+ {I8Ptr, I8Ptr, SizeTTy},
+ {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
}
Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
const DataLayout &DL, const TargetLibraryInfo *TLI) {
- LLVMContext &Context = B.GetInsertBlock()->getContext();
Type *I8Ptr = B.getInt8PtrTy();
- Type *IntTy = B.getInt32Ty();
- Type *SizeTTy = DL.getIntPtrType(Context);
- return emitLibCall(
- LibFunc_bcmp, IntTy,
- {I8Ptr, I8Ptr, SizeTTy},
- {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
+ Type *IntTy = getIntTy(B, TLI);
+ Type *SizeTTy = getSizeTTy(B, TLI);
+ return emitLibCall(LibFunc_bcmp, IntTy,
+ {I8Ptr, I8Ptr, SizeTTy},
+ {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
}
Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
IRBuilderBase &B, const TargetLibraryInfo *TLI) {
Type *I8Ptr = B.getInt8PtrTy();
- Type *IntTy = B.getInt32Ty();
- Type *SizeTTy = Len->getType();
- return emitLibCall(
- LibFunc_memccpy, I8Ptr,
- {I8Ptr, I8Ptr, IntTy, SizeTTy},
- {Ptr1, Ptr2, Val, Len}, B, TLI);
+ Type *IntTy = getIntTy(B, TLI);
+ Type *SizeTTy = getSizeTTy(B, TLI);
+ return emitLibCall(LibFunc_memccpy, I8Ptr,
+ {I8Ptr, I8Ptr, IntTy, SizeTTy},
+ {Ptr1, Ptr2, Val, Len}, B, TLI);
}
Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
const TargetLibraryInfo *TLI) {
Type *I8Ptr = B.getInt8PtrTy();
- Type *IntTy = B.getInt32Ty();
- Type *SizeTTy = Size->getType();
+ Type *IntTy = getIntTy(B, TLI);
+ Type *SizeTTy = getSizeTTy(B, TLI);
SmallVector<Value *, 8> Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)};
llvm::append_range(Args, VariadicArgs);
return emitLibCall(LibFunc_snprintf, IntTy,
@@ -1613,7 +1611,7 @@ Value *llvm::emitSPrintf(Value *Dest, Value *Fmt,
ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
const TargetLibraryInfo *TLI) {
Type *I8Ptr = B.getInt8PtrTy();
- Type *IntTy = B.getInt32Ty();
+ Type *IntTy = getIntTy(B, TLI);
SmallVector<Value *, 8> Args{castToCStr(Dest, B), castToCStr(Fmt, B)};
llvm::append_range(Args, VariadicArgs);
return emitLibCall(LibFunc_sprintf, IntTy,
@@ -1631,7 +1629,7 @@ Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B,
Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
const TargetLibraryInfo *TLI) {
Type *I8Ptr = B.getInt8PtrTy();
- Type *SizeTTy = Size->getType();
+ Type *SizeTTy = getSizeTTy(B, TLI);
return emitLibCall(LibFunc_strlcpy, SizeTTy,
{I8Ptr, I8Ptr, SizeTTy},
{castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
@@ -1640,7 +1638,7 @@ Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
const TargetLibraryInfo *TLI) {
Type *I8Ptr = B.getInt8PtrTy();
- Type *SizeTTy = Size->getType();
+ Type *SizeTTy = getSizeTTy(B, TLI);
return emitLibCall(LibFunc_strlcat, SizeTTy,
{I8Ptr, I8Ptr, SizeTTy},
{castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
@@ -1649,7 +1647,7 @@ Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
const TargetLibraryInfo *TLI) {
Type *I8Ptr = B.getInt8PtrTy();
- Type *SizeTTy = Size->getType();
+ Type *SizeTTy = getSizeTTy(B, TLI);
return emitLibCall(LibFunc_strncat, I8Ptr,
{I8Ptr, I8Ptr, SizeTTy},
{castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
@@ -1658,8 +1656,8 @@ Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
IRBuilderBase &B, const TargetLibraryInfo *TLI) {
Type *I8Ptr = B.getInt8PtrTy();
- Type *IntTy = B.getInt32Ty();
- Type *SizeTTy = Size->getType();
+ Type *IntTy = getIntTy(B, TLI);
+ Type *SizeTTy = getSizeTTy(B, TLI);
return emitLibCall(
LibFunc_vsnprintf, IntTy,
{I8Ptr, SizeTTy, I8Ptr, VAList->getType()},
@@ -1669,7 +1667,7 @@ Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList,
IRBuilderBase &B, const TargetLibraryInfo *TLI) {
Type *I8Ptr = B.getInt8PtrTy();
- Type *IntTy = B.getInt32Ty();
+ Type *IntTy = getIntTy(B, TLI);
return emitLibCall(LibFunc_vsprintf, IntTy,
{I8Ptr, I8Ptr, VAList->getType()},
{castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI);
@@ -1800,7 +1798,7 @@ Value *llvm::emitPutChar(Value *Char, IRBuilderBase &B,
if (!isLibFuncEmittable(M, TLI, LibFunc_putchar))
return nullptr;
- Type *IntTy = Char->getType();
+ Type *IntTy = getIntTy(B, TLI);
StringRef PutCharName = TLI->getName(LibFunc_putchar);
FunctionCallee PutChar = getOrInsertLibFunc(M, *TLI, LibFunc_putchar,
IntTy, IntTy);
@@ -1819,7 +1817,7 @@ Value *llvm::emitPutS(Value *Str, IRBuilderBase &B,
if (!isLibFuncEmittable(M, TLI, LibFunc_puts))
return nullptr;
- Type *IntTy = B.getInt32Ty();
+ Type *IntTy = getIntTy(B, TLI);
StringRef PutsName = TLI->getName(LibFunc_puts);
FunctionCallee PutS = getOrInsertLibFunc(M, *TLI, LibFunc_puts, IntTy,
B.getInt8PtrTy());
@@ -1837,7 +1835,7 @@ Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilderBase &B,
if (!isLibFuncEmittable(M, TLI, LibFunc_fputc))
return nullptr;
- Type *IntTy = B.getInt32Ty();
+ Type *IntTy = getIntTy(B, TLI);
StringRef FPutcName = TLI->getName(LibFunc_fputc);
FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fputc, IntTy,
IntTy, File->getType());
@@ -1859,7 +1857,7 @@ Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilderBase &B,
if (!isLibFuncEmittable(M, TLI, LibFunc_fputs))
return nullptr;
- Type *IntTy = B.getInt32Ty();
+ Type *IntTy = getIntTy(B, TLI);
StringRef FPutsName = TLI->getName(LibFunc_fputs);
FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fputs, IntTy,
B.getInt8PtrTy(), File->getType());
@@ -1879,8 +1877,7 @@ Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B,
if (!isLibFuncEmittable(M, TLI, LibFunc_fwrite))
return nullptr;
- LLVMContext &Context = B.GetInsertBlock()->getContext();
- Type *SizeTTy = DL.getIntPtrType(Context);
+ Type *SizeTTy = getSizeTTy(B, TLI);
StringRef FWriteName = TLI->getName(LibFunc_fwrite);
FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fwrite,
SizeTTy, B.getInt8PtrTy(), SizeTTy,
@@ -1890,7 +1887,7 @@ Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B,
inferNonMandatoryLibFuncAttrs(M, FWriteName, *TLI);
CallInst *CI =
B.CreateCall(F, {castToCStr(Ptr, B), Size,
- ConstantInt::get(DL.getIntPtrType(Context), 1), File});
+ ConstantInt::get(SizeTTy, 1), File});
if (const Function *Fn =
dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
@@ -1905,8 +1902,7 @@ Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL,
return nullptr;
StringRef MallocName = TLI->getName(LibFunc_malloc);
- LLVMContext &Context = B.GetInsertBlock()->getContext();
- Type *SizeTTy = DL.getIntPtrType(Context);
+ Type *SizeTTy = getSizeTTy(B, TLI);
FunctionCallee Malloc = getOrInsertLibFunc(M, *TLI, LibFunc_malloc,
B.getInt8PtrTy(), SizeTTy);
inferNonMandatoryLibFuncAttrs(M, MallocName, *TLI);
@@ -1926,9 +1922,7 @@ Value *llvm::emitCalloc(Value *Num, Value *Size, IRBuilderBase &B,
return nullptr;
StringRef CallocName = TLI.getName(LibFunc_calloc);
- LLVMContext &Context = B.GetInsertBlock()->getContext();
- const DataLayout &DL = M->getDataLayout();
- Type *SizeTTy = DL.getIntPtrType(Context);
+ Type *SizeTTy = getSizeTTy(B, &TLI);
FunctionCallee Calloc = getOrInsertLibFunc(M, TLI, LibFunc_calloc,
B.getInt8PtrTy(), SizeTTy, SizeTTy);
inferNonMandatoryLibFuncAttrs(M, CallocName, TLI);
diff --git a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
index b39b0e3903f16..abd5099494e51 100644
--- a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
@@ -433,14 +433,16 @@ Value *LibCallSimplifier::optimizeStrChr(CallInst *CI, IRBuilderBase &B) {
Function *Callee = CI->getCalledFunction();
FunctionType *FT = Callee->getFunctionType();
- if (!FT->getParamType(1)->isIntegerTy(32)) // memchr needs i32.
+ unsigned IntBits = TLI->getIntSize();
+ if (!FT->getParamType(1)->isIntegerTy(IntBits)) // memchr needs 'int'.
return nullptr;
- return copyFlags(
- *CI,
- emitMemChr(SrcStr, CharVal, // include nul.
- ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len), B,
- DL, TLI));
+ unsigned SizeTBits = TLI->getSizeTSize(*CI->getModule());
+ Type *SizeTTy = IntegerType::get(CI->getContext(), SizeTBits);
+ return copyFlags(*CI,
+ emitMemChr(SrcStr, CharVal, // include nul.
+ ConstantInt::get(SizeTTy, Len), B,
+ DL, TLI));
}
if (CharC->isZero()) {
@@ -487,11 +489,13 @@ Value *LibCallSimplifier::optimizeStrRChr(CallInst *CI, IRBuilderBase &B) {
return nullptr;
}
+ unsigned SizeTBits = TLI->getSizeTSize(*CI->getModule());
+ Type *SizeTTy = IntegerType::get(CI->getContext(), SizeTBits);
+
// Try to expand strrchr to the memrchr nonstandard extension if it's
// available, or simply fail otherwise.
uint64_t NBytes = Str.size() + 1; // Include the terminating nul.
- Type *IntPtrType = DL.getIntPtrType(CI->getContext());
- Value *Size = ConstantInt::get(IntPtrType, NBytes);
+ Value *Size = ConstantInt::get(SizeTTy, NBytes);
return copyFlags(*CI, emitMemRChr(SrcStr, CharVal, Size, B, DL, TLI));
}
@@ -3190,10 +3194,11 @@ Value *LibCallSimplifier::optimizeFPrintFString(CallInst *CI,
if (FormatStr.contains('%'))
return nullptr; // We found a format specifier.
+ unsigned SizeTBits = TLI->getSizeTSize(*CI->getModule());
+ Type *SizeTTy = IntegerType::get(CI->getContext(), SizeTBits);
return copyFlags(
*CI, emitFWrite(CI->getArgOperand(1),
- ConstantInt::get(DL.getIntPtrType(CI->getContext()),
- FormatStr.size()),
+ ConstantInt::get(SizeTTy, FormatStr.size()),
CI->getArgOperand(0), B, DL, TLI));
}
@@ -3304,10 +3309,12 @@ Value *LibCallSimplifier::optimizeFPuts(CallInst *CI, IRBuilderBase &B) {
return nullptr;
// Known to have no uses (see above).
+ unsigned SizeTBits = TLI->getSizeTSize(*CI->getModule());
+ Type *SizeTTy = IntegerType::get(CI->getContext(), SizeTBits);
return copyFlags(
*CI,
emitFWrite(CI->getArgOperand(0),
- ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len - 1),
+ ConstantInt::get(SizeTTy, Len - 1),
CI->getArgOperand(1), B, DL, TLI));
}
More information about the llvm-commits
mailing list