50#define DEBUG_TYPE "simplify-lib-calls"
55 cl::desc(
"Enable unsafe double to float "
56 "shrinking for math lib calls"));
63 cl::desc(
"Enable hot/cold operator new library calls"));
72 "Enable optimization of existing hot/cold operator new library calls"),
76 "Do not optimize existing hot/cold operator new library calls"),
78 "Only optimize existing hot/cold operator new library calls "
79 "if determined to be cold"),
82 "Always optimize existing hot/cold operator new library calls"),
85 "Always optimize existing hot/cold operator new library calls")),
89 cl::desc(
"Enable transformation of nobuiltin operator new library calls"));
92 cl::desc(
"Take the minimum of compiler hint and existing hint when "
93 "optimizing existing hot/cold operator new library calls"));
104struct HotColdHintParser :
public cl::parser<unsigned> {
105 HotColdHintParser(cl::Option &O) : cl::parser<unsigned>(
O) {}
107 bool parse(cl::Option &O, StringRef ArgName, StringRef Arg,
unsigned &
Value) {
109 return O.error(
"'" + Arg +
"' value invalid for uint argument!");
112 return O.error(
"'" + Arg +
"' value must be in the range [0, 255]!");
126 cl::desc(
"Value to pass to hot/cold operator new for cold allocation"));
129 cl::desc(
"Value to pass to hot/cold operator new for "
130 "notcold (warm) allocation"));
133 cl::desc(
"Value to pass to hot/cold operator new for hot allocation"));
137 "Value to pass to hot/cold operator new for ambiguous allocation"));
144 return Func == LibFunc_abs || Func == LibFunc_labs ||
145 Func == LibFunc_llabs || Func == LibFunc_strlen;
150 for (
User *U :
V->users()) {
152 if (IC->isEquality() && IC->getOperand(1) == With)
162 return OI->getType()->isFloatingPointTy();
168 return OI->getType()->isFP128Ty();
201 bool Negate = Str[0] ==
'-';
202 if (Str[0] ==
'-' || Str[0] ==
'+') {
203 Str = Str.drop_front();
214 uint64_t Max = AsSigned && Negate ? 1 : 0;
218 if (Str.size() > 1) {
220 if (
toUpper((
unsigned char)Str[1]) ==
'X') {
221 if (Str.size() == 2 || (
Base &&
Base != 16))
226 Str = Str.drop_front(2);
232 }
else if (
Base == 0)
242 for (
unsigned i = 0; i != Str.size(); ++i) {
243 unsigned char DigVal = Str[i];
245 DigVal = DigVal -
'0';
249 DigVal = DigVal -
'A' + 10;
262 if (VFlow || Result > Max)
270 Value *StrEnd =
B.CreateInBoundsGEP(
B.getInt8Ty(), StrBeg,
Off,
"endptr");
271 B.CreateStore(StrEnd, EndPtr);
282 return ConstantInt::get(RetTy, Result, AsSigned);
286 for (
User *U :
V->users()) {
289 if (
C->isNullValue())
317 for (
unsigned ArgNo : ArgNos) {
318 uint64_t DerefBytes = DereferenceableBytes;
323 DereferenceableBytes);
343 for (
unsigned ArgNo : ArgNos) {
369 DerefMin = std::min(
X,
Y);
390 NewCI->
getContext(), {NewCI->getAttributes(), Old.getAttributes()}));
407 return Len >= Str.size() ? Str : Str.substr(0, Len);
432 return copyFlags(*CI, emitStrLenMemCpy(Src, Dst, Len,
B));
446 Value *CpyDst =
B.CreateInBoundsGEP(
B.getInt8Ty(), Dst, DstLen,
"endptr");
451 TLI->getAsSizeT(Len + 1, *
B.getModule()));
495 return copyFlags(*CI, emitStrLenMemCpy(Src, Dst, SrcLen,
B));
508 Type *CharTy =
B.getInt8Ty();
509 Value *Char0 =
B.CreateLoad(CharTy, Src);
510 CharVal =
B.CreateTrunc(CharVal, CharTy);
511 Value *Cmp =
B.CreateICmpEQ(Char0, CharVal,
"char0cmp");
516 Cmp =
B.CreateLogicalAnd(
And, Cmp);
524 return B.CreateSelect(Cmp, Src, NullPtr);
546 FunctionType *FT =
Callee->getFunctionType();
547 unsigned IntBits = TLI->getIntSize();
548 if (!FT->getParamType(1)->isIntegerTy(IntBits))
551 unsigned SizeTBits = TLI->getSizeTSize(*CI->
getModule());
555 ConstantInt::get(SizeTTy, Len),
B,
564 return B.CreateIntToPtr(
B.getTrue(), CI->
getType());
573 return B.CreateInBoundsGEP(
B.getInt8Ty(), SrcStr, StrLen,
"strchr");
586 return B.CreateInBoundsGEP(
B.getInt8Ty(), SrcStr,
B.getInt64(
I),
"strchr");
598 if (CharC && CharC->
isZero())
603 unsigned SizeTBits = TLI->getSizeTSize(*CI->
getModule());
609 Value *
Size = ConstantInt::get(SizeTTy, NBytes);
616 return ConstantInt::get(CI->
getType(), 0);
618 StringRef Str1, Str2;
623 if (HasStr1 && HasStr2)
625 std::clamp(Str1.
compare(Str2), -1, 1));
627 if (HasStr1 && Str1.
empty())
628 return B.CreateNeg(
B.CreateZExt(
629 B.CreateLoad(
B.getInt8Ty(), Str2P,
"strcmpload"), CI->
getType()));
631 if (HasStr2 && Str2.
empty())
632 return B.CreateZExt(
B.CreateLoad(
B.getInt8Ty(), Str1P,
"strcmpload"),
646 TLI->getAsSizeT(std::min(Len1, Len2), *CI->
getModule()),
651 SimplifyQuery SQ(DL, TLI, DT, AC, CI);
652 if (!HasStr1 && HasStr2) {
657 }
else if (HasStr1 && !HasStr2) {
679 return ConstantInt::get(CI->
getType(), 0);
691 return ConstantInt::get(CI->
getType(), 0);
696 StringRef Str1, Str2;
701 if (HasStr1 && HasStr2) {
706 std::clamp(SubStr1.
compare(SubStr2), -1, 1));
709 if (HasStr1 && Str1.
empty())
710 return B.CreateNeg(
B.CreateZExt(
711 B.CreateLoad(
B.getInt8Ty(), Str2P,
"strcmpload"), CI->
getType()));
713 if (HasStr2 && Str2.
empty())
714 return B.CreateZExt(
B.CreateLoad(
B.getInt8Ty(), Str1P,
"strcmpload"),
725 if (!HasStr1 && HasStr2) {
726 Len2 = std::min(Len2,
Length);
731 }
else if (HasStr1 && !HasStr2) {
732 Len1 = std::min(Len1,
Length);
746 if (SrcLen &&
Size) {
748 if (SrcLen <= Size->getZExtValue() + 1)
770 CallInst *NewCI =
B.CreateMemCpy(Dst,
Align(1), Src,
Align(1),
785 return StrLen ?
B.CreateInBoundsGEP(
B.getInt8Ty(), Dst, StrLen) :
nullptr;
796 Value *DstEnd =
B.CreateInBoundsGEP(
797 B.getInt8Ty(), Dst, TLI->getAsSizeT(Len - 1, *CI->
getModule()));
801 CallInst *NewCI =
B.CreateMemCpy(Dst,
Align(1), Src,
Align(1), LenV);
820 NBytes = SizeC->getZExtValue();
829 B.CreateStore(
B.getInt8(0), Dst);
845 bool NulTerm = SrcLen < NBytes;
854 SrcLen = std::min(SrcLen,
uint64_t(Str.size()));
855 NBytes = std::min(NBytes - 1, SrcLen);
860 B.CreateStore(
B.getInt8(0), Dst);
861 return ConstantInt::get(CI->
getType(), 0);
867 CallInst *NewCI =
B.CreateMemCpy(Dst,
Align(1), Src,
Align(1),
868 TLI->getAsSizeT(NBytes, *CI->
getModule()));
872 Value *EndOff = ConstantInt::get(CI->
getType(), NBytes);
873 Value *EndPtr =
B.CreateInBoundsGEP(
B.getInt8Ty(), Dst, EndOff);
874 B.CreateStore(
B.getInt8(0), EndPtr);
880 return ConstantInt::get(CI->
getType(), SrcLen);
885Value *LibCallSimplifier::optimizeStringNCpy(
CallInst *CI,
bool RetEnd,
902 N = SizeC->getZExtValue();
909 Type *CharTy =
B.getInt8Ty();
910 Value *CharVal =
B.CreateLoad(CharTy, Src,
"stxncpy.char0");
911 B.CreateStore(CharVal, Dst);
917 Value *ZeroChar = ConstantInt::get(CharTy, 0);
918 Value *
Cmp =
B.CreateICmpEQ(CharVal, ZeroChar,
"stpncpy.char0cmp");
920 Value *Off1 =
B.getInt32(1);
921 Value *EndPtr =
B.CreateInBoundsGEP(CharTy, Dst, Off1,
"stpncpy.end");
922 return B.CreateSelect(Cmp, Dst, EndPtr,
"stpncpy.sel");
937 CI->
getAttributes().getParamAttrs(0).getAlignment().valueOrOne();
938 CallInst *NewCI =
B.CreateMemSet(Dst,
B.getInt8(
'\0'),
Size, MemSetAlign);
946 if (
N > SrcLen + 1) {
955 std::string SrcStr = Str.str();
958 SrcStr.resize(
N,
'\0');
959 Src =
B.CreateGlobalString(SrcStr,
"str", 0,
965 CallInst *NewCI =
B.CreateMemCpy(Dst,
Align(1), Src,
Align(1),
974 return B.CreateInBoundsGEP(
B.getInt8Ty(), Dst,
Off,
"endptr");
991 return B.CreateZExt(
B.CreateLoad(CharTy, Src,
"char0"),
997 if (BoundCst->isZero())
999 return ConstantInt::get(CI->
getType(), 0);
1001 if (BoundCst->isOne()) {
1003 Value *CharVal =
B.CreateLoad(CharTy, Src,
"strnlen.char0");
1004 Value *ZeroChar = ConstantInt::get(CharTy, 0);
1005 Value *
Cmp =
B.CreateICmpNE(CharVal, ZeroChar,
"strnlen.char0cmp");
1006 return B.CreateZExt(Cmp, CI->
getType());
1012 Value *LenC = ConstantInt::get(CI->
getType(), Len - 1);
1016 return B.CreateBinaryIntrinsic(Intrinsic::umin, LenC, Bound);
1033 unsigned BW = DL.getIndexTypeSizeInBits(
GEP->getType());
1034 SmallMapVector<Value *, APInt, 4> VarOffsets;
1035 APInt ConstOffset(BW, 0);
1036 assert(CharSize % 8 == 0 &&
"Expected a multiple of 8 sized CharSize");
1038 if (!
GEP->collectOffset(DL, BW, VarOffsets, ConstOffset) ||
1039 VarOffsets.
size() != 1 || ConstOffset != 0 ||
1040 VarOffsets.
begin()->second != CharSize / 8)
1043 ConstantDataArraySlice Slice;
1046 if (Slice.
Array ==
nullptr) {
1069 if ((
Known.isNonNegative() &&
Known.getMaxValue().ule(NullTermIdx)) ||
1071 NullTermIdx == Slice.
Length - 1)) {
1073 return B.CreateSub(ConstantInt::get(CI->
getType(), NullTermIdx),
1083 if (LenTrue && LenFalse) {
1085 return OptimizationRemark(
"instcombine",
"simplify-libcalls", CI)
1086 <<
"folded strlen(select) to select of constants";
1088 return B.CreateSelect(
SI->getCondition(),
1089 ConstantInt::get(CI->
getType(), LenTrue - 1),
1090 ConstantInt::get(CI->
getType(), LenFalse - 1),
"",
1099 if (
Value *
V = optimizeStringLength(CI,
B, 8))
1107 if (
Value *
V = optimizeStringLength(CI,
B, 8, Bound))
1117 unsigned WCharSize =
M.getWCharSize();
1119 if (
Value *
V = optimizeStringLength(CI,
B, WCharSize * 8))
1133 if ((HasS1 &&
S1.empty()) || (HasS2 && S2.
empty()))
1137 if (HasS1 && HasS2) {
1138 size_t I =
S1.find_first_of(S2);
1143 B.getInt64(
I),
"strpbrk");
1147 if (HasS2 && S2.
size() == 1)
1172 if ((HasS1 &&
S1.empty()) || (HasS2 && S2.
empty()))
1176 if (HasS1 && HasS2) {
1177 size_t Pos =
S1.find_first_not_of(S2);
1180 return ConstantInt::get(CI->
getType(), Pos);
1192 if (HasS1 &&
S1.empty())
1196 if (HasS1 && HasS2) {
1197 size_t Pos =
S1.find_first_of(S2);
1200 return ConstantInt::get(CI->
getType(), Pos);
1204 if (HasS2 && S2.
empty())
1221 StrLen,
B, DL, TLI);
1229 replaceAllUsesWith(Old, Cmp);
1235 StringRef SearchStr, ToFindStr;
1240 if (HasStr2 && ToFindStr.
empty())
1244 if (HasStr1 && HasStr2) {
1251 return B.CreateConstInBoundsGEP1_64(
B.getInt8Ty(), CI->
getArgOperand(0),
1256 if (HasStr2 && ToFindStr.
size() == 1) {
1277 if (LenC->
isOne()) {
1280 Value *Val =
B.CreateLoad(
B.getInt8Ty(), SrcStr,
"memrchr.char0");
1282 CharVal =
B.CreateTrunc(CharVal,
B.getInt8Ty());
1283 Value *
Cmp =
B.CreateICmpEQ(Val, CharVal,
"memrchr.char0cmp");
1284 return B.CreateSelectWithUnknownProfile(Cmp, SrcStr, NullPtr,
DEBUG_TYPE,
1293 if (Str.size() == 0)
1302 if (Str.size() < EndOff)
1317 return B.CreateInBoundsGEP(
B.getInt8Ty(), SrcStr,
B.getInt64(Pos));
1319 if (Str.find(Str[Pos]) == Pos) {
1326 Value *SrcPlus =
B.CreateInBoundsGEP(
B.getInt8Ty(), SrcStr,
1327 B.getInt64(Pos),
"memrchr.ptr_plus");
1328 return B.CreateSelectWithUnknownProfile(Cmp, NullPtr, SrcPlus,
DEBUG_TYPE,
1334 Str = Str.substr(0, EndOff);
1342 Type *Int8Ty =
B.getInt8Ty();
1343 Value *NNeZ =
B.CreateICmpNE(
Size, ConstantInt::get(SizeTy, 0));
1345 CharVal =
B.CreateTrunc(CharVal, Int8Ty);
1347 B.CreateICmpEQ(ConstantInt::get(Int8Ty, (
unsigned char)Str[0]), CharVal);
1348 Value *
And =
B.CreateLogicalAnd(NNeZ, CEqS0);
1351 Value *SizeM1 =
B.CreateSub(
Size, ConstantInt::get(SizeTy, 1));
1353 B.CreateInBoundsGEP(Int8Ty, SrcStr, SizeM1,
"memrchr.ptr_plus");
1354 return B.CreateSelectWithUnknownProfile(
And, SrcPlus, NullPtr,
DEBUG_TYPE,
1378 if (LenC->
isOne()) {
1381 Value *Val =
B.CreateLoad(
B.getInt8Ty(), SrcStr,
"memchr.char0");
1383 CharVal =
B.CreateTrunc(CharVal,
B.getInt8Ty());
1384 Value *
Cmp =
B.CreateICmpEQ(Val, CharVal,
"memchr.char0cmp");
1388 return B.CreateSelectWithUnknownProfile(Cmp, SrcStr, NullPtr,
DEBUG_TYPE,
1409 Value *SrcPlus =
B.CreateInBoundsGEP(
B.getInt8Ty(), SrcStr,
B.getInt64(Pos),
1413 return B.CreateSelectWithUnknownProfile(Cmp, NullPtr, SrcPlus,
DEBUG_TYPE);
1416 if (Str.size() == 0)
1425 size_t Pos = Str.find_first_not_of(Str[0]);
1441 CharVal =
B.CreateTrunc(CharVal, Int8Ty);
1443 Value *Sel1 = NullPtr;
1446 Value *PosVal = ConstantInt::get(SizeTy, Pos);
1447 Value *StrPos = ConstantInt::get(Int8Ty, (
unsigned char)Str[Pos]);
1448 Value *CEqSPos =
B.CreateICmpEQ(CharVal, StrPos);
1450 Value *
And =
B.CreateAnd(CEqSPos, NGtPos);
1451 Value *SrcPlus =
B.CreateInBoundsGEP(
B.getInt8Ty(), SrcStr, PosVal);
1454 Sel1 =
B.CreateSelectWithUnknownProfile(
And, SrcPlus, NullPtr,
DEBUG_TYPE,
1458 Value *Str0 = ConstantInt::get(Int8Ty, (
unsigned char)Str[0]);
1459 Value *CEqS0 =
B.CreateICmpEQ(Str0, CharVal);
1460 Value *NNeZ =
B.CreateICmpNE(
Size, ConstantInt::get(SizeTy, 0));
1464 return B.CreateSelectWithUnknownProfile(
And, SrcStr, Sel1,
DEBUG_TYPE,
1496 *std::max_element(
reinterpret_cast<const unsigned char *
>(Str.begin()),
1497 reinterpret_cast<const unsigned char *
>(Str.end()));
1504 if (!DL.fitsInLegalInteger(Max + 1)) {
1510 std::string SortedStr = Str.str();
1513 unsigned NonContRanges = 1;
1514 for (
size_t i = 1; i < SortedStr.size(); ++i) {
1515 if (SortedStr[i] > SortedStr[i - 1] + 1) {
1522 if (NonContRanges > 2)
1526 CharVal =
B.CreateTrunc(CharVal,
B.getInt8Ty());
1529 for (
unsigned char C : SortedStr)
1530 CharCompares.
push_back(
B.CreateICmpEQ(CharVal,
B.getInt8(
C)));
1532 return B.CreateIntToPtr(
B.CreateOr(CharCompares), CI->
getType());
1537 unsigned char Width =
NextPowerOf2(std::max((
unsigned char)7, Max));
1543 Value *BitfieldC =
B.getInt(Bitfield);
1547 C =
B.CreateAnd(
C,
B.getIntN(Width, 0xFF));
1554 Value *Shl =
B.CreateShl(
B.getIntN(Width, 1ULL),
C);
1555 Value *
Bits =
B.CreateIsNotNull(
B.CreateAnd(Shl, BitfieldC),
"memchr.bits");
1559 Value *Memchr =
B.CreateLogicalAnd(Bounds, Bits,
"memchr");
1565 return B.CreateIntToPtr(Memchr, CI->
getType());
1589 if (Pos == MinSize ||
1590 (StrNCmp && (LStr[Pos] ==
'\0' && RStr[Pos] ==
'\0'))) {
1598 if (LStr[Pos] != RStr[Pos])
1603 typedef unsigned char UChar;
1604 int IRes = UChar(LStr[Pos]) < UChar(RStr[Pos]) ? -1 : 1;
1605 Value *MaxSize = ConstantInt::get(
Size->getType(), Pos);
1608 return B.CreateSelect(Cmp,
Zero, Res);
1620 Value *LHSV =
B.CreateZExt(
B.CreateLoad(
B.getInt8Ty(),
LHS,
"lhsc"),
1622 Value *RHSV =
B.CreateZExt(
B.CreateLoad(
B.getInt8Ty(),
RHS,
"rhsc"),
1624 return B.CreateSub(LHSV, RHSV,
"chardiff");
1632 Align PrefAlignment =
DL.getPrefTypeAlign(IntType);
1635 Value *LHSV =
nullptr;
1639 Value *RHSV =
nullptr;
1648 LHSV =
B.CreateLoad(IntType,
LHS,
"lhsv");
1650 RHSV =
B.CreateLoad(IntType,
RHS,
"rhsv");
1651 return B.CreateZExt(
B.CreateICmpNE(LHSV, RHSV), CI->
getType(),
"memcmp");
1659Value *LibCallSimplifier::optimizeMemCmpBCmpCommon(
CallInst *CI,
1679 if (
Value *
V = optimizeMemCmpBCmpCommon(CI,
B))
1697 return optimizeMemCmpBCmpCommon(CI,
B);
1723 if (
N->isNullValue())
1736 if (
N->getZExtValue() <= SrcStr.
size()) {
1745 ConstantInt::get(
N->getType(), std::min(
uint64_t(Pos + 1),
N->getZExtValue()));
1748 return Pos + 1 <=
N->getZExtValue()
1749 ?
B.CreateInBoundsGEP(
B.getInt8Ty(), Dst, NewN)
1763 return B.CreateInBoundsGEP(
B.getInt8Ty(), Dst,
N);
1796 if (MDNode *MD = CI->
getMetadata(LLVMContext::MD_alloc_token))
1797 MallocCI->setMetadata(LLVMContext::MD_alloc_token, MD);
1806Value *LibCallSimplifier::maybeOptimizeNoBuiltinOperatorNew(
CallInst *CI,
1813 LibFunc
Func = TLI->getLibFunc(*Callee);
1814 if (Func == NotLibFunc)
1818 case LibFunc_ZnwmRKSt9nothrow_t:
1819 case LibFunc_ZnwmSt11align_val_t:
1820 case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t:
1822 case LibFunc_ZnamRKSt9nothrow_t:
1823 case LibFunc_ZnamSt11align_val_t:
1824 case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t:
1825 case LibFunc_size_returning_new:
1826 case LibFunc_size_returning_new_aligned:
1833 case LibFunc_Znwm12__hot_cold_t:
1834 case LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t:
1835 case LibFunc_ZnwmSt11align_val_t12__hot_cold_t:
1836 case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
1837 case LibFunc_Znam12__hot_cold_t:
1838 case LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t:
1839 case LibFunc_ZnamSt11align_val_t12__hot_cold_t:
1840 case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
1841 case LibFunc_size_returning_new_hot_cold:
1842 case LibFunc_size_returning_new_aligned_hot_cold:
1851 return optimizeNew(CI,
B, Func);
1864 bool IsCold =
false;
1865 if (CI->
getAttributes().getFnAttr(
"memprof").getValueAsString() ==
"cold") {
1868 }
else if (CI->
getAttributes().getFnAttr(
"memprof").getValueAsString() ==
1871 else if (CI->
getAttributes().getFnAttr(
"memprof").getValueAsString() ==
"hot")
1873 else if (CI->
getAttributes().getFnAttr(
"memprof").getValueAsString() ==
1879 bool ShouldOptimizeExistingHotColdNew =
1884 Value *HotColdVal =
B.getInt8(HotCold);
1885 auto getHotColdHintForExisting = [&](uint8_t HotCold) ->
Value * {
1891 ExistingHint =
B.CreateTruncOrBitCast(ExistingHint,
B.getInt8Ty());
1895 return B.CreateBinaryIntrinsic(Intrinsic::umin, ExistingHint, HotColdVal);
1905 Value *NewCall =
nullptr;
1907 case LibFunc_Znwm12__hot_cold_t:
1908 if (ShouldOptimizeExistingHotColdNew)
1910 LibFunc_Znwm12__hot_cold_t,
1911 getHotColdHintForExisting(HotCold));
1915 LibFunc_Znwm12__hot_cold_t, HotColdVal);
1917 case LibFunc_Znam12__hot_cold_t:
1918 if (ShouldOptimizeExistingHotColdNew)
1920 LibFunc_Znam12__hot_cold_t,
1921 getHotColdHintForExisting(HotCold));
1925 LibFunc_Znam12__hot_cold_t, HotColdVal);
1927 case LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t:
1928 if (ShouldOptimizeExistingHotColdNew)
1931 TLI, LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t,
1932 getHotColdHintForExisting(HotCold));
1934 case LibFunc_ZnwmRKSt9nothrow_t:
1937 LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t, HotColdVal);
1939 case LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t:
1940 if (ShouldOptimizeExistingHotColdNew)
1943 TLI, LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t,
1944 getHotColdHintForExisting(HotCold));
1946 case LibFunc_ZnamRKSt9nothrow_t:
1949 LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t, HotColdVal);
1951 case LibFunc_ZnwmSt11align_val_t12__hot_cold_t:
1952 if (ShouldOptimizeExistingHotColdNew)
1955 TLI, LibFunc_ZnwmSt11align_val_t12__hot_cold_t,
1956 getHotColdHintForExisting(HotCold));
1958 case LibFunc_ZnwmSt11align_val_t:
1961 LibFunc_ZnwmSt11align_val_t12__hot_cold_t, HotColdVal);
1963 case LibFunc_ZnamSt11align_val_t12__hot_cold_t:
1964 if (ShouldOptimizeExistingHotColdNew)
1967 TLI, LibFunc_ZnamSt11align_val_t12__hot_cold_t,
1968 getHotColdHintForExisting(HotCold));
1970 case LibFunc_ZnamSt11align_val_t:
1973 LibFunc_ZnamSt11align_val_t12__hot_cold_t, HotColdVal);
1975 case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
1976 if (ShouldOptimizeExistingHotColdNew)
1979 TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t,
1980 getHotColdHintForExisting(HotCold));
1982 case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t:
1985 TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t,
1988 case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
1989 if (ShouldOptimizeExistingHotColdNew)
1992 TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t,
1993 getHotColdHintForExisting(HotCold));
1995 case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t:
1998 TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t,
2001 case LibFunc_size_returning_new:
2003 LibFunc_size_returning_new_hot_cold,
2006 case LibFunc_size_returning_new_hot_cold:
2007 if (ShouldOptimizeExistingHotColdNew)
2009 CI->
getArgOperand(0),
B, TLI, LibFunc_size_returning_new_hot_cold,
2010 getHotColdHintForExisting(HotCold), CI->
getType());
2012 case LibFunc_size_returning_new_aligned:
2015 LibFunc_size_returning_new_aligned_hot_cold, HotColdVal, CI->
getType());
2017 case LibFunc_size_returning_new_aligned_hot_cold:
2018 if (ShouldOptimizeExistingHotColdNew)
2021 LibFunc_size_returning_new_aligned_hot_cold,
2022 getHotColdHintForExisting(HotCold), CI->
getType());
2070 Value *
Op = Cast->getOperand(0);
2071 if (
Op->getType()->isFloatTy())
2080 return ConstantFP::get(Const->getContext(),
F);
2088 bool isPrecise =
false) {
2120 CallerName.
size() == (CalleeName.
size() + 1) &&
2133 R =
isBinary ?
B.CreateIntrinsic(IID,
B.getFloatTy(),
V)
2134 :
B.CreateIntrinsic(IID,
B.getFloatTy(),
V[0]);
2142 return B.CreateFPExt(R,
B.getDoubleTy());
2148 bool isPrecise =
false) {
2155 bool isPrecise =
false) {
2162 if (!RetTy || RetTy->getNumElements() != 2 ||
2163 !RetTy->getElementType(0)->getScalarType()->isDoubleTy())
2169 if (Ext->getOperand(0)->getType()->getScalarType()->isFloatTy())
2170 X = Ext->getOperand(0);
2180 if (!Cast || !Cast->getType()->getScalarType()->isFloatTy())
2188 Value *NewCall =
B.CreateIntrinsic(Intrinsic::sincos,
X->getType(),
X);
2190 LLVMContext::MD_fpmath, CI->
getMetadata(LLVMContext::MD_fpmath));
2192 for (
unsigned I = 0;
I != 2; ++
I) {
2193 Value *Ext =
B.CreateFPExt(
B.CreateExtractValue(NewCall,
I),
2194 RetTy->getElementType(
I));
2195 Res =
B.CreateInsertValue(Res, Ext,
I);
2210 assert(
Op->getType()->isArrayTy() &&
"Unexpected signature for cabs!");
2212 Real =
B.CreateExtractValue(
Op, 0,
"real");
2213 Imag =
B.CreateExtractValue(
Op, 1,
"imag");
2223 Value *AbsOp =
nullptr;
2225 if (ConstReal->isZero())
2229 if (ConstImag->isZero())
2234 return copyFlags(*CI,
B.CreateFAbs(AbsOp, CI,
"cabs"));
2241 Value *RealReal =
B.CreateFMulFMF(Real, Real, CI);
2242 Value *ImagImag =
B.CreateFMulFMF(Imag, Imag, CI);
2244 *CI,
B.CreateUnaryIntrinsic(Intrinsic::sqrt,
2245 B.CreateFAddFMF(RealReal, ImagImag, CI), CI,
2256 unsigned BitWidth =
Op->getType()->getScalarSizeInBits();
2258 Type *IntTy =
Op->getType()->getWithNewBitWidth(DstWidth);
2260 :
B.CreateZExt(
Op, IntTy);
2295 CalleeFn ? TLI->getLibFunc(CalleeFn->
getName()) : NotLibFunc;
2300 LibFunc LibFnFloat, LibFnDouble, LibFnLongDouble;
2308 ExpName = TLI->getName(LibFunc_exp);
2309 ID = Intrinsic::exp;
2310 LibFnFloat = LibFunc_expf;
2311 LibFnDouble = LibFunc_exp;
2312 LibFnLongDouble = LibFunc_expl;
2317 ExpName = TLI->getName(LibFunc_exp2);
2318 ID = Intrinsic::exp2;
2319 LibFnFloat = LibFunc_exp2f;
2320 LibFnDouble = LibFunc_exp2;
2321 LibFnLongDouble = LibFunc_exp2l;
2328 ?
B.CreateUnaryIntrinsic(ID,
FMul,
nullptr, ExpName)
2337 substituteInParent(BaseFn, ExpFn);
2348 AttributeList NoAttrs;
2350 const bool UseIntrinsic =
Pow->doesNotAccessMemory();
2356 hasFloatFn(M, TLI, Ty, LibFunc_ldexp, LibFunc_ldexpf, LibFunc_ldexpl))) {
2361 Constant *One = ConstantFP::get(Ty, 1.0);
2365 {Ty, ExpoI->getType()},
2366 {One, ExpoI},
Pow,
"exp2"));
2370 One, ExpoI, TLI, LibFunc_ldexp, LibFunc_ldexpf,
2371 LibFunc_ldexpl,
B, NoAttrs));
2376 if (
hasFloatFn(M, TLI, Ty, LibFunc_exp2, LibFunc_exp2f, LibFunc_exp2l)) {
2379 BaseR = BaseR / *BaseF;
2381 const APFloat *NF = IsReciprocal ? &BaseR : BaseF;
2383 if ((IsInteger || IsReciprocal) &&
2386 NI > 1 && NI.isPowerOf2()) {
2387 double N = NI.logBase2() * (IsReciprocal ? -1.0 : 1.0);
2388 Value *
FMul =
B.CreateFMul(Expo, ConstantFP::get(Ty,
N),
"mul");
2389 if (
Pow->doesNotAccessMemory())
2395 LibFunc_exp2l,
B, NoAttrs));
2401 hasFloatFn(M, TLI, Ty, LibFunc_exp10, LibFunc_exp10f, LibFunc_exp10l)) {
2403 if (
Pow->doesNotAccessMemory()) {
2404 return B.CreateIntrinsic(Intrinsic::exp10, {Ty}, {Expo},
Pow,
"exp10", {},
2409 LibFunc_exp10f, LibFunc_exp10l,
2419 "pow(1.0, y) should have been simplified earlier!");
2428 Value *
FMul =
B.CreateFMul(Log, Expo,
"mul");
2429 if (
Pow->doesNotAccessMemory())
2432 else if (
hasFloatFn(M, TLI, Ty, LibFunc_exp2, LibFunc_exp2f,
2436 LibFunc_exp2l,
B, NoAttrs));
2448 return B.CreateUnaryIntrinsic(Intrinsic::sqrt,
V,
nullptr,
"sqrt");
2451 if (
hasFloatFn(M,
TLI,
V->getType(), LibFunc_sqrt, LibFunc_sqrtf,
2457 LibFunc_sqrtl,
B, Attrs);
2464 Value *Sqrt, *
Base =
Pow->getArgOperand(0), *Expo =
Pow->getArgOperand(1);
2475 if (ExpoF->
isNegative() && (!
Pow->hasApproxFunc() && !
Pow->hasAllowReassoc()))
2482 if (!
Pow->doesNotAccessMemory() && !
Pow->hasNoInfs() &&
2484 Base, SimplifyQuery(DL, TLI, DT, AC,
Pow,
true,
true, DC)))
2493 if (!
Pow->hasNoSignedZeros())
2494 Sqrt =
B.CreateFAbs(Sqrt,
nullptr,
"abs");
2500 if (!
Pow->hasNoInfs()) {
2503 Value *FCmp =
B.CreateFCmpOEQ(
Base, NegInf,
"isinf");
2504 Sqrt =
B.CreateSelect(FCmp, PosInf, Sqrt);
2518 Sqrt =
B.CreateFDiv(ConstantFP::get(Ty, 1.0), Sqrt,
"reciprocal");
2527 return B.CreateIntrinsic(Intrinsic::powi, Types, Args);
2532 Value *Expo =
Pow->getArgOperand(1);
2537 bool AllowApprox =
Pow->hasApproxFunc();
2541 IRBuilderBase::FastMathFlagGuard Guard(
B);
2542 B.setFastMathFlags(
Pow->getFastMathFlags());
2549 if (
Value *Exp = replacePowWithExp(
Pow,
B))
2556 return B.CreateFDiv(ConstantFP::get(Ty, 1.0),
Base,
"reciprocal");
2560 return ConstantFP::get(Ty, 1.0);
2568 return B.CreateFMul(
Base,
Base,
"square");
2570 if (
Value *Sqrt = replacePowWithSqrt(
Pow,
B))
2581 Value *Sqrt =
nullptr;
2582 if (!ExpoA.isInteger()) {
2596 if (!ExpoI.isInteger())
2608 APSInt IntExpo(TLI->getIntSize(),
false);
2615 Base, ConstantInt::get(
B.getIntNTy(TLI->getIntSize()), IntExpo),
2619 return B.CreateFMul(PowI, Sqrt);
2635 if (UnsafeFPShrink && Name == TLI->getName(LibFunc_pow) &&
2636 hasFloatVersion(M, Name)) {
2648 Value *Ret =
nullptr;
2649 if (UnsafeFPShrink && Name == TLI->getName(LibFunc_exp2) &&
2650 hasFloatVersion(M, Name))
2659 const bool UseIntrinsic =
Callee->isIntrinsic();
2670 hasFloatFn(M, TLI, Ty, LibFunc_ldexp, LibFunc_ldexpf, LibFunc_ldexpl))) {
2672 Constant *One = ConstantFP::get(Ty, 1.0);
2675 return copyFlags(*CI,
B.CreateIntrinsic(Intrinsic::ldexp,
2676 {Ty, Exp->getType()},
2680 IRBuilderBase::FastMathFlagGuard Guard(
B);
2683 One, Exp, TLI, LibFunc_ldexp, LibFunc_ldexpf,
2684 LibFunc_ldexpl,
B, AttributeList()));
2708 StringRef LogNm = LogFn->
getName();
2713 if (UnsafeFPShrink && (LogFn->
isIntrinsic() || hasFloatVersion(
Mod, LogNm)))
2717 LibFunc LogLb, ExpLb, Exp2Lb, Exp10Lb, PowLb;
2720 LogLb = TLI->getLibFunc(LogNm);
2721 if (LogLb != NotLibFunc) {
2724 LogID = Intrinsic::log;
2725 ExpLb = LibFunc_expf;
2726 Exp2Lb = LibFunc_exp2f;
2727 Exp10Lb = LibFunc_exp10f;
2728 PowLb = LibFunc_powf;
2731 LogID = Intrinsic::log;
2732 ExpLb = LibFunc_exp;
2733 Exp2Lb = LibFunc_exp2;
2734 Exp10Lb = LibFunc_exp10;
2735 PowLb = LibFunc_pow;
2738 LogID = Intrinsic::log;
2739 ExpLb = LibFunc_expl;
2740 Exp2Lb = LibFunc_exp2l;
2741 Exp10Lb = LibFunc_exp10l;
2742 PowLb = LibFunc_powl;
2745 LogID = Intrinsic::log2;
2746 ExpLb = LibFunc_expf;
2747 Exp2Lb = LibFunc_exp2f;
2748 Exp10Lb = LibFunc_exp10f;
2749 PowLb = LibFunc_powf;
2752 LogID = Intrinsic::log2;
2753 ExpLb = LibFunc_exp;
2754 Exp2Lb = LibFunc_exp2;
2755 Exp10Lb = LibFunc_exp10;
2756 PowLb = LibFunc_pow;
2759 LogID = Intrinsic::log2;
2760 ExpLb = LibFunc_expl;
2761 Exp2Lb = LibFunc_exp2l;
2762 Exp10Lb = LibFunc_exp10l;
2763 PowLb = LibFunc_powl;
2765 case LibFunc_log10f:
2766 LogID = Intrinsic::log10;
2767 ExpLb = LibFunc_expf;
2768 Exp2Lb = LibFunc_exp2f;
2769 Exp10Lb = LibFunc_exp10f;
2770 PowLb = LibFunc_powf;
2773 LogID = Intrinsic::log10;
2774 ExpLb = LibFunc_exp;
2775 Exp2Lb = LibFunc_exp2;
2776 Exp10Lb = LibFunc_exp10;
2777 PowLb = LibFunc_pow;
2779 case LibFunc_log10l:
2780 LogID = Intrinsic::log10;
2781 ExpLb = LibFunc_expl;
2782 Exp2Lb = LibFunc_exp2l;
2783 Exp10Lb = LibFunc_exp10l;
2784 PowLb = LibFunc_powl;
2791 bool IsKnownNoErrno =
Log->hasNoNaNs() &&
Log->hasNoInfs();
2792 if (!IsKnownNoErrno) {
2793 SimplifyQuery SQ(DL, TLI, DT, AC, Log,
true,
true, DC);
2800 Known.cannotBeOrderedLessThanZero() &&
2801 Known.isKnownNeverLogicalZero(
F->getDenormalMode(FltSem));
2803 if (IsKnownNoErrno) {
2804 Value *NewLog =
B.CreateUnaryIntrinsic(LogID,
Log->getArgOperand(0), Log);
2806 I->copyMetadata(*Log);
2811 }
else if (LogID == Intrinsic::log || LogID == Intrinsic::log2 ||
2812 LogID == Intrinsic::log10) {
2814 ExpLb = LibFunc_expf;
2815 Exp2Lb = LibFunc_exp2f;
2816 Exp10Lb = LibFunc_exp10f;
2817 PowLb = LibFunc_powf;
2819 ExpLb = LibFunc_exp;
2820 Exp2Lb = LibFunc_exp2;
2821 Exp10Lb = LibFunc_exp10;
2822 PowLb = LibFunc_pow;
2833 IRBuilderBase::FastMathFlagGuard Guard(
B);
2837 LibFunc ArgLb = TLI->getLibFunc(*Arg);
2840 AttributeList NoAttrs;
2841 if (ArgLb == PowLb || ArgID == Intrinsic::pow || ArgID == Intrinsic::powi) {
2843 Log->doesNotAccessMemory()
2844 ?
B.CreateUnaryIntrinsic(LogID, Arg->
getOperand(0),
nullptr,
"log")
2848 if (ArgID == Intrinsic::powi)
2849 Y =
B.CreateSIToFP(
Y, Ty,
"cast");
2850 Value *MulY =
B.CreateFMul(
Y, LogX,
"mul");
2853 substituteInParent(Arg, MulY);
2858 if (ArgLb == ExpLb || ArgLb == Exp2Lb || ArgLb == Exp10Lb ||
2859 ArgID == Intrinsic::exp || ArgID == Intrinsic::exp2 ||
2860 ArgID == Intrinsic::exp10) {
2862 if (ArgLb == ExpLb || ArgID == Intrinsic::exp)
2865 else if (ArgLb == Exp2Lb || ArgID == Intrinsic::exp2)
2866 Eul = ConstantFP::get(
Log->getType(), 2.0);
2868 Eul = ConstantFP::get(
Log->getType(), 10.0);
2869 Value *LogE =
Log->doesNotAccessMemory()
2870 ?
B.CreateUnaryIntrinsic(LogID, Eul,
nullptr,
"log")
2875 substituteInParent(Arg, MulY);
2892 LibFunc ArgLb = TLI->getLibFunc(*Arg);
2894 LibFunc SqrtLb, ExpLb, Exp2Lb, Exp10Lb;
2896 SqrtLb = TLI->getLibFunc(SqrtFn->
getName());
2897 if (SqrtLb != NotLibFunc)
2900 ExpLb = LibFunc_expf;
2901 Exp2Lb = LibFunc_exp2f;
2902 Exp10Lb = LibFunc_exp10f;
2905 ExpLb = LibFunc_exp;
2906 Exp2Lb = LibFunc_exp2;
2907 Exp10Lb = LibFunc_exp10;
2910 ExpLb = LibFunc_expl;
2911 Exp2Lb = LibFunc_exp2l;
2912 Exp10Lb = LibFunc_exp10l;
2919 ExpLb = LibFunc_expf;
2920 Exp2Lb = LibFunc_exp2f;
2921 Exp10Lb = LibFunc_exp10f;
2923 ExpLb = LibFunc_exp;
2924 Exp2Lb = LibFunc_exp2;
2925 Exp10Lb = LibFunc_exp10;
2931 if (ArgLb != ExpLb && ArgLb != Exp2Lb && ArgLb != Exp10Lb &&
2932 ArgID != Intrinsic::exp && ArgID != Intrinsic::exp2)
2935 IRBuilderBase::InsertPointGuard Guard(
B);
2936 B.SetInsertPoint(Arg);
2939 B.CreateFMulFMF(ExpOperand, ConstantFP::get(ExpOperand->getType(), 0.5),
2949 Value *Ret =
nullptr;
2954 (
Callee->getName() ==
"sqrt" ||
2955 Callee->getIntrinsicID() == Intrinsic::sqrt))
2958 if (
Value *Opt = mergeSqrtToExp(CI,
B))
2965 if (!
I ||
I->getOpcode() != Instruction::FMul || !
I->isFast())
2971 Value *Op0 =
I->getOperand(0);
2972 Value *Op1 =
I->getOperand(1);
2973 Value *RepeatOp =
nullptr;
2974 Value *OtherOp =
nullptr;
3005 Value *FabsCall =
B.CreateFAbs(RepeatOp,
I,
"fabs");
3011 B.CreateUnaryIntrinsic(Intrinsic::sqrt, OtherOp,
I,
"sqrt");
3012 return copyFlags(*CI,
B.CreateFMulFMF(FabsCall, SqrtCall,
I));
3023 SimplifyQuery SQ(DL, TLI, DT, AC, CI,
true,
true, DC);
3026 KnownFPClass Known1 =
3029 const fltSemantics &FltSem =
3040Value *LibCallSimplifier::optimizeTrigInversionPairs(
CallInst *CI,
3044 Value *Ret =
nullptr;
3046 if (UnsafeFPShrink &&
3047 (Name ==
"tan" || Name ==
"atanh" || Name ==
"sinh" || Name ==
"cosh" ||
3049 hasFloatVersion(M, Name))
3058 if (!CI->
isFast() || !OpC->isFast())
3067 LibFunc
Func =
F ? TLI->getLibFunc(
F->getName()) : NotLibFunc;
3069 LibFunc inverseFunc = llvm::StringSwitch<LibFunc>(
Callee->getName())
3070 .Case(
"tan", LibFunc_atan)
3071 .Case(
"atanh", LibFunc_tanh)
3072 .Case(
"sinh", LibFunc_asinh)
3073 .Case(
"cosh", LibFunc_acosh)
3074 .Case(
"tanf", LibFunc_atanf)
3075 .Case(
"atanhf", LibFunc_tanhf)
3076 .Case(
"sinhf", LibFunc_asinhf)
3077 .Case(
"coshf", LibFunc_acoshf)
3078 .Case(
"tanl", LibFunc_atanl)
3079 .Case(
"atanhl", LibFunc_tanhl)
3080 .Case(
"sinhl", LibFunc_asinhl)
3081 .Case(
"coshl", LibFunc_acoshl)
3082 .Case(
"asinh", LibFunc_sinh)
3083 .Case(
"asinhf", LibFunc_sinhf)
3084 .Case(
"asinhl", LibFunc_sinhl)
3085 .Default(NotLibFunc);
3086 if (Func == inverseFunc)
3087 Ret = OpC->getArgOperand(0);
3109 Name =
"__sincospif_stret";
3118 Name =
"__sincospi_stret";
3124 LibFunc TheLibFunc =
TLI->getLibFunc(Name);
3131 B.SetInsertPoint(++ArgInst->getIterator());
3135 BasicBlock &EntryBB =
B.GetInsertBlock()->getParent()->getEntryBlock();
3136 B.SetInsertPoint(EntryBB.
begin());
3139 SinCos =
B.CreateCall(Callee, Arg,
"sincospi");
3142 Sin =
B.CreateExtractValue(SinCos, 0,
"sinpi");
3143 Cos =
B.CreateExtractValue(SinCos, 1,
"cospi");
3145 Sin =
B.CreateExtractElement(SinCos,
uint64_t{0},
"sinpi");
3146 Cos =
B.CreateExtractElement(SinCos,
uint64_t{1},
"cospi");
3156 return Mode.inputsMayBePositiveZero() ||
Mode.outputsMayBePositiveZero();
3187Value *LibCallSimplifier::optimizeSymmetric(
CallInst *CI, LibFunc Func,
3216 case LibFunc_asinhf:
3217 case LibFunc_asinhl:
3261 for (User *U : Arg->
users())
3262 classifyArgUse(U,
F, IsFloat, SinCalls, CosCalls, SinCosCalls);
3268 Value *Sin, *Cos, *SinCos;
3273 auto replaceTrigInsts = [
this](SmallVectorImpl<CallInst *> &Calls,
3275 for (CallInst *
C : Calls)
3276 replaceAllUsesWith(
C, Res);
3279 replaceTrigInsts(SinCalls, Sin);
3280 replaceTrigInsts(CosCalls, Cos);
3281 replaceTrigInsts(SinCosCalls, SinCos);
3283 return IsSin ? Sin : Cos;
3286void LibCallSimplifier::classifyArgUse(
3301 LibFunc
Func =
Callee ? TLI->getLibFunc(*Callee) : NotLibFunc;
3306 if (Func == LibFunc_sinpif)
3308 else if (Func == LibFunc_cospif)
3310 else if (Func == LibFunc_sincospif_stret)
3313 if (Func == LibFunc_sinpi)
3315 else if (Func == LibFunc_cospi)
3317 else if (Func == LibFunc_sincospi_stret)
3339 unsigned IntBW = TLI->getIntSize();
3340 APSInt QuotInt(IntBW,
false);
3347 B.CreateAlignedStore(
3350 return ConstantFP::get(CI->
getType(), Rem);
3377 return ConstantFP::get(CI->
getType(), Difference);
3389 Type *ArgType =
Op->getType();
3390 Value *
V =
B.CreateIntrinsic(Intrinsic::cttz, {ArgType}, {
Op,
B.getTrue()},
3392 V =
B.CreateAdd(
V, ConstantInt::get(
V->getType(), 1));
3393 V =
B.CreateIntCast(
V, RetType,
false);
3396 Value *S =
B.CreateSelect(
Cond,
V, ConstantInt::get(RetType, 0));
3410 Type *ArgType =
Op->getType();
3411 Value *
V =
B.CreateIntrinsic(Intrinsic::ctlz, {ArgType}, {
Op,
B.getFalse()},
3415 return B.CreateIntCast(
V, CI->
getType(),
false);
3422 Value *IsNeg =
B.CreateIsNeg(
X);
3423 Value *NegX =
B.CreateNSWNeg(
X,
"neg");
3424 return B.CreateSelect(IsNeg, NegX,
X);
3430 Type *ArgType =
Op->getType();
3431 Op =
B.CreateSub(
Op, ConstantInt::get(ArgType,
'0'),
"isdigittmp");
3432 Op =
B.CreateICmpULT(
Op, ConstantInt::get(ArgType, 10),
"isdigit");
3439 Type *ArgType =
Op->getType();
3440 Op =
B.CreateICmpULT(
Op, ConstantInt::get(ArgType, 128),
"isascii");
3447 ConstantInt::get(CI->
getType(), 0x7F));
3477 return convertStrToInt(CI, Str, EndPtr, CInt->getSExtValue(), AsSigned,
B);
3509 if (!Callee || !Callee->isDeclaration())
3518 if (StreamArg >= (
int)CI->
arg_size())
3526 return GV->
getName() ==
"stderr";
3531 StringRef FormatStr;
3536 if (FormatStr.
empty())
3547 if (FormatStr.
size() == 1 || FormatStr ==
"%%") {
3551 Value *IntChar = ConstantInt::get(IntTy, (unsigned char)FormatStr[0]);
3552 return copyFlags(*CI, emitPutChar(IntChar, B, TLI));
3556 if (FormatStr ==
"%s" && CI->
arg_size() > 1) {
3557 StringRef OperandStr;
3558 if (!getConstantStringInfo(CI->getOperand(1), OperandStr))
3561 if (OperandStr.empty())
3564 if (OperandStr.size() == 1) {
3568 Value *IntChar = ConstantInt::get(IntTy, (unsigned char)OperandStr[0]);
3569 return copyFlags(*CI, emitPutChar(IntChar, B, TLI));
3572 if (OperandStr.back() ==
'\n') {
3573 if (!isLibFuncEmittable(CI->getModule(), TLI, LibFunc_puts))
3575 OperandStr = OperandStr.drop_back();
3576 Value *GV = B.CreateGlobalString(OperandStr,
"str");
3577 return copyFlags(*CI, emitPutS(GV, B, TLI));
3583 if (FormatStr.
back() ==
'\n' &&
3585 if (!isLibFuncEmittable(CI->getModule(), TLI, LibFunc_puts))
3589 FormatStr = FormatStr.drop_back();
3590 Value *GV = B.CreateGlobalString(FormatStr,
"str");
3591 return copyFlags(*CI, emitPutS(GV, B, TLI));
3596 if (FormatStr ==
"%c" && CI->
arg_size() > 1 &&
3600 Value *IntChar = B.CreateIntCast(CI->getArgOperand(1), IntTy, false);
3601 return copyFlags(*CI, emitPutChar(IntChar, B, TLI));
3605 if (FormatStr ==
"%s\n" && CI->
arg_size() > 1 &&
3615 FunctionType *FT =
Callee->getFunctionType();
3616 if (
Value *
V = optimizePrintFString(CI,
B)) {
3627 Callee->getAttributes());
3629 New->setCalledFunction(IPrintFFn);
3639 Callee->getAttributes());
3641 New->setCalledFunction(SmallPrintFFn);
3649Value *LibCallSimplifier::optimizeSPrintFString(
CallInst *CI,
3652 StringRef FormatStr;
3668 return ConstantInt::get(CI->
getType(), FormatStr.
size());
3673 if (FormatStr.
size() != 2 || FormatStr[0] !=
'%' || CI->
arg_size() < 3)
3677 if (FormatStr[1] ==
'c') {
3683 B.CreateStore(
V, Ptr);
3684 Ptr =
B.CreateInBoundsGEP(
B.getInt8Ty(), Ptr,
B.getInt32(1),
"nul");
3685 B.CreateStore(
B.getInt8(0), Ptr);
3687 return ConstantInt::get(CI->
getType(), 1);
3690 if (FormatStr[1] ==
's') {
3703 TLI->getAsSizeT(SrcLen, *CI->
getModule()));
3705 return ConstantInt::get(CI->
getType(), SrcLen - 1);
3708 Value *PtrDiff =
B.CreatePtrDiff(
V, Dest);
3709 return B.CreateIntCast(PtrDiff, CI->
getType(),
false);
3720 B.CreateAdd(Len, ConstantInt::get(
Len->getType(), 1),
"leninc");
3724 return B.CreateIntCast(Len, CI->
getType(),
false);
3732 FunctionType *FT =
Callee->getFunctionType();
3733 if (
Value *
V = optimizeSPrintFString(CI,
B)) {
3744 FT,
Callee->getAttributes());
3746 New->setCalledFunction(SIPrintFFn);
3756 Callee->getAttributes());
3758 New->setCalledFunction(SmallSPrintFFn);
3774 assert(StrArg || (
N < 2 && Str.size() == 1));
3776 unsigned IntBits = TLI->getIntSize();
3778 if (Str.size() > IntMax)
3784 Value *StrLen = ConstantInt::get(CI->
getType(), Str.size());
3794 NCopy = Str.size() + 1;
3799 if (NCopy && StrArg)
3802 TLI->getAsSizeT(NCopy, *CI->
getModule())));
3811 Value *NulOff =
B.getIntN(IntBits, NCopy);
3812 Value *DstEnd =
B.CreateInBoundsGEP(Int8Ty, DstArg, NulOff,
"endptr");
3813 B.CreateStore(ConstantInt::get(Int8Ty, 0), DstEnd);
3817Value *LibCallSimplifier::optimizeSnPrintFString(
CallInst *CI,
3835 StringRef FormatStr;
3846 return emitSnPrintfMemCpy(CI, FmtArg, FormatStr,
N,
B);
3851 if (FormatStr.
size() != 2 || FormatStr[0] !=
'%' || CI->
arg_size() != 4)
3855 if (FormatStr[1] ==
'c') {
3860 StringRef CharStr(
"*");
3861 return emitSnPrintfMemCpy(CI,
nullptr, CharStr,
N,
B);
3868 Value *Ptr = DstArg;
3869 B.CreateStore(
V, Ptr);
3870 Ptr =
B.CreateInBoundsGEP(
B.getInt8Ty(), Ptr,
B.getInt32(1),
"nul");
3871 B.CreateStore(
B.getInt8(0), Ptr);
3872 return ConstantInt::get(CI->
getType(), 1);
3875 if (FormatStr[1] !=
's')
3884 return emitSnPrintfMemCpy(CI, StrArg, Str,
N,
B);
3888 if (
Value *
V = optimizeSnPrintFString(CI,
B)) {
3897Value *LibCallSimplifier::optimizeFPrintFString(
CallInst *CI,
3899 optimizeErrorReporting(CI,
B, 0);
3902 StringRef FormatStr;
3926 if (FormatStr.
size() != 2 || FormatStr[0] !=
'%' || CI->
arg_size() < 3)
3930 if (FormatStr[1] ==
'c') {
3934 Type *IntTy =
B.getIntNTy(TLI->getIntSize());
3940 if (FormatStr[1] ==
's') {
3953 FunctionType *FT =
Callee->getFunctionType();
3954 if (
Value *
V = optimizeFPrintFString(CI,
B)) {
3963 FT,
Callee->getAttributes());
3965 New->setCalledFunction(FIPrintFFn);
3974 auto SmallFPrintFFn =
3976 Callee->getAttributes());
3978 New->setCalledFunction(SmallFPrintFFn);
3987 optimizeErrorReporting(CI,
B, 3);
3992 if (SizeC && CountC) {
3997 return ConstantInt::get(CI->
getType(), 0);
4004 Value *Cast =
B.CreateIntCast(Char, IntTy,
true,
"chari");
4006 return NewCI ? ConstantInt::get(CI->
getType(), 1) : nullptr;
4014 optimizeErrorReporting(CI,
B, 1);
4032 unsigned SizeTBits = TLI->getSizeTSize(*CI->
getModule());
4037 ConstantInt::get(SizeTTy, Len - 1),
4077bool LibCallSimplifier::hasFloatVersion(
const Module *M,
StringRef FuncName) {
4078 SmallString<20> FloatFuncName = FuncName;
4079 FloatFuncName +=
'f';
4083Value *LibCallSimplifier::optimizeStringMemoryLibCall(
CallInst *CI,
4087 LibFunc
Func = TLI->getLibFunc(*Callee);
4095 "Optimizing string/memory libcall would change the calling convention");
4097 case LibFunc_strcat:
4098 return optimizeStrCat(CI, Builder);
4099 case LibFunc_strncat:
4100 return optimizeStrNCat(CI, Builder);
4101 case LibFunc_strchr:
4102 return optimizeStrChr(CI, Builder);
4103 case LibFunc_strrchr:
4104 return optimizeStrRChr(CI, Builder);
4105 case LibFunc_strcmp:
4106 return optimizeStrCmp(CI, Builder);
4107 case LibFunc_strncmp:
4108 return optimizeStrNCmp(CI, Builder);
4109 case LibFunc_strcpy:
4110 return optimizeStrCpy(CI, Builder);
4111 case LibFunc_stpcpy:
4112 return optimizeStpCpy(CI, Builder);
4113 case LibFunc_strlcpy:
4114 return optimizeStrLCpy(CI, Builder);
4115 case LibFunc_stpncpy:
4116 return optimizeStringNCpy(CI,
true, Builder);
4117 case LibFunc_strncpy:
4118 return optimizeStringNCpy(CI,
false, Builder);
4119 case LibFunc_strlen:
4120 return optimizeStrLen(CI, Builder);
4121 case LibFunc_strnlen:
4122 return optimizeStrNLen(CI, Builder);
4123 case LibFunc_strpbrk:
4124 return optimizeStrPBrk(CI, Builder);
4125 case LibFunc_strndup:
4126 return optimizeStrNDup(CI, Builder);
4127 case LibFunc_strtol:
4128 case LibFunc_strtod:
4129 case LibFunc_strtof:
4130 case LibFunc_strtoul:
4131 case LibFunc_strtoll:
4132 case LibFunc_strtold:
4133 case LibFunc_strtoull:
4134 return optimizeStrTo(CI, Builder);
4135 case LibFunc_strspn:
4136 return optimizeStrSpn(CI, Builder);
4137 case LibFunc_strcspn:
4138 return optimizeStrCSpn(CI, Builder);
4139 case LibFunc_strstr:
4140 return optimizeStrStr(CI, Builder);
4141 case LibFunc_memchr:
4142 return optimizeMemChr(CI, Builder);
4143 case LibFunc_memrchr:
4144 return optimizeMemRChr(CI, Builder);
4146 return optimizeBCmp(CI, Builder);
4147 case LibFunc_memcmp:
4148 return optimizeMemCmp(CI, Builder);
4149 case LibFunc_memcpy:
4150 return optimizeMemCpy(CI, Builder);
4151 case LibFunc_memccpy:
4152 return optimizeMemCCpy(CI, Builder);
4153 case LibFunc_mempcpy:
4154 return optimizeMemPCpy(CI, Builder);
4155 case LibFunc_memmove:
4156 return optimizeMemMove(CI, Builder);
4157 case LibFunc_memset:
4158 return optimizeMemSet(CI, Builder);
4159 case LibFunc_realloc:
4160 return optimizeRealloc(CI, Builder);
4161 case LibFunc_wcslen:
4162 return optimizeWcslen(CI, Builder);
4164 return optimizeBCopy(CI, Builder);
4166 case LibFunc_ZnwmRKSt9nothrow_t:
4167 case LibFunc_ZnwmSt11align_val_t:
4168 case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t:
4170 case LibFunc_ZnamRKSt9nothrow_t:
4171 case LibFunc_ZnamSt11align_val_t:
4172 case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t:
4173 case LibFunc_Znwm12__hot_cold_t:
4174 case LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t:
4175 case LibFunc_ZnwmSt11align_val_t12__hot_cold_t:
4176 case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
4177 case LibFunc_Znam12__hot_cold_t:
4178 case LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t:
4179 case LibFunc_ZnamSt11align_val_t12__hot_cold_t:
4180 case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t:
4181 case LibFunc_size_returning_new:
4182 case LibFunc_size_returning_new_hot_cold:
4183 case LibFunc_size_returning_new_aligned:
4184 case LibFunc_size_returning_new_aligned_hot_cold:
4185 return optimizeNew(CI, Builder, Func);
4201 if (CharSeq.
empty())
4202 Fill =
APInt(32, 0);
4209Value *LibCallSimplifier::optimizeFloatingPointLibCall(
CallInst *CI,
4218 if (
Value *
V = optimizeSymmetric(CI, Func, Builder))
4222 case LibFunc_sinpif:
4224 return optimizeSinCosPi(CI,
true, Builder);
4225 case LibFunc_cospif:
4227 return optimizeSinCosPi(CI,
false, Builder);
4241 return optimizePow(CI, Builder);
4245 return optimizeExp2(CI, Builder);
4247 case LibFunc_ldexpf:
4248 case LibFunc_ldexpl:
4249 case LibFunc_scalbn:
4250 case LibFunc_scalbnf:
4251 case LibFunc_scalbnl:
4268 if (
Value *
V = optimizeSqrt(CI, Builder))
4276 return optimizeFMod(CI, Builder);
4280 case LibFunc_log10f:
4282 case LibFunc_log10l:
4283 case LibFunc_log1pf:
4285 case LibFunc_log1pl:
4292 return optimizeLog(CI, Builder);
4300 case LibFunc_asinhf:
4301 case LibFunc_asinhl:
4306 case LibFunc_atanhf:
4307 case LibFunc_atanhl:
4308 return optimizeTrigInversionPairs(CI, Builder);
4313 case LibFunc_floorf:
4315 case LibFunc_floorl:
4317 case LibFunc_roundf:
4319 case LibFunc_roundl:
4321 case LibFunc_roundevenf:
4322 case LibFunc_roundeven:
4323 case LibFunc_roundevenl:
4325 case LibFunc_nearbyintf:
4326 case LibFunc_nearbyint:
4327 case LibFunc_nearbyintl:
4333 case LibFunc_truncf:
4335 case LibFunc_truncl:
4339 if (UnsafeFPShrink &&
4345 CI, Builder, Func == LibFunc_sin ? Intrinsic::sin : Intrinsic::cos);
4359 case LibFunc_copysign:
4364 case LibFunc_copysignf:
4365 case LibFunc_copysignl:
4370 return optimizeFdim(CI, Builder);
4374 return optimizeFMinFMax(CI, Builder, Intrinsic::minnum);
4378 return optimizeFMinFMax(CI, Builder, Intrinsic::maxnum);
4379 case LibFunc_fminimum_numf:
4380 case LibFunc_fminimum_num:
4381 case LibFunc_fminimum_numl:
4383 case LibFunc_fmaximum_numf:
4384 case LibFunc_fmaximum_num:
4385 case LibFunc_fmaximum_numl:
4390 return optimizeCAbs(CI, Builder);
4391 case LibFunc_remquo:
4392 case LibFunc_remquof:
4393 case LibFunc_remquol:
4394 return optimizeRemquo(CI, Builder);
4409 LibFunc Func = TLI->getLibFunc(*Callee);
4422 return maybeOptimizeNoBuiltinOperatorNew(CI, Builder);
4431 Builder.setDefaultOperandBundles(OpBundles);
4439 UnsafeFPShrink =
true;
4443 if (!IsCallingConvC)
4447 switch (
II->getIntrinsicID()) {
4448 case Intrinsic::pow:
4449 return optimizePow(CI, Builder);
4450 case Intrinsic::exp2:
4451 return optimizeExp2(CI, Builder);
4452 case Intrinsic::log:
4453 case Intrinsic::log2:
4454 case Intrinsic::log10:
4455 return optimizeLog(CI, Builder);
4456 case Intrinsic::sqrt:
4457 return optimizeSqrt(CI, Builder);
4458 case Intrinsic::memset:
4459 return optimizeMemSet(CI, Builder);
4460 case Intrinsic::memcpy:
4461 return optimizeMemCpy(CI, Builder);
4462 case Intrinsic::memmove:
4463 return optimizeMemMove(CI, Builder);
4464 case Intrinsic::sin:
4465 case Intrinsic::cos:
4469 case Intrinsic::sincos:
4479 if (
Value *SimplifiedFortifiedCI =
4480 FortifiedSimplifier.optimizeCall(CI, Builder))
4481 return SimplifiedFortifiedCI;
4488 if (
Value *V = optimizeStringMemoryLibCall(CI, Builder))
4490 if (
Value *V = optimizeFloatingPointLibCall(CI, Func, Builder))
4496 return optimizeFFS(CI, Builder);
4500 return optimizeFls(CI, Builder);
4504 return optimizeAbs(CI, Builder);
4505 case LibFunc_isdigit:
4506 return optimizeIsDigit(CI, Builder);
4507 case LibFunc_isascii:
4508 return optimizeIsAscii(CI, Builder);
4509 case LibFunc_toascii:
4510 return optimizeToAscii(CI, Builder);
4514 return optimizeAtoi(CI, Builder);
4515 case LibFunc_strtol:
4516 case LibFunc_strtoll:
4517 return optimizeStrToInt(CI, Builder,
true);
4518 case LibFunc_strtoul:
4519 case LibFunc_strtoull:
4520 return optimizeStrToInt(CI, Builder,
false);
4521 case LibFunc_printf:
4522 return optimizePrintF(CI, Builder);
4523 case LibFunc_sprintf:
4524 return optimizeSPrintF(CI, Builder);
4525 case LibFunc_snprintf:
4526 return optimizeSnPrintF(CI, Builder);
4527 case LibFunc_fprintf:
4528 return optimizeFPrintF(CI, Builder);
4529 case LibFunc_fwrite:
4530 return optimizeFWrite(CI, Builder);
4532 return optimizeFPuts(CI, Builder);
4534 return optimizePuts(CI, Builder);
4535 case LibFunc_perror:
4536 return optimizeErrorReporting(CI, Builder);
4537 case LibFunc_vfprintf:
4538 case LibFunc_fiprintf:
4539 return optimizeErrorReporting(CI, Builder, 0);
4542 return optimizeExit(CI);
4556 : FortifiedSimplifier(TLI), DL(DL), TLI(TLI), DT(DT), DC(DC), AC(AC),
4557 ORE(ORE), BFI(BFI), PSI(PSI), Replacer(Replacer), Eraser(Eraser) {}
4564void LibCallSimplifier::eraseFromParent(
Instruction *
I) {
4603bool FortifiedLibCallSimplifier::isFortifiedCallFoldable(
4604 CallInst *CI,
unsigned ObjSizeOp, std::optional<unsigned> SizeOp,
4605 std::optional<unsigned> StrOp, std::optional<unsigned> FlagOp) {
4610 if (!Flag || !
Flag->isZero())
4617 if (ConstantInt *ObjSizeCI =
4619 if (ObjSizeCI->isMinusOne())
4622 if (OnlyLowerUnknownSize)
4632 return ObjSizeCI->getZExtValue() >=
Len;
4636 if (ConstantInt *SizeCI =
4638 return ObjSizeCI->getZExtValue() >= SizeCI->getZExtValue();
4644Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(
CallInst *CI,
4646 if (isFortifiedCallFoldable(CI, 3, 2)) {
4656Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(
CallInst *CI,
4658 if (isFortifiedCallFoldable(CI, 3, 2)) {
4668Value *FortifiedLibCallSimplifier::optimizeMemSetChk(
CallInst *CI,
4670 if (isFortifiedCallFoldable(CI, 3, 2)) {
4680Value *FortifiedLibCallSimplifier::optimizeMemPCpyChk(
CallInst *CI,
4683 if (isFortifiedCallFoldable(CI, 3, 2))
4691Value *FortifiedLibCallSimplifier::optimizeStrpCpyChk(
CallInst *CI,
4699 if (Func == LibFunc_stpcpy_chk && !OnlyLowerUnknownSize && Dst == Src) {
4701 return StrLen ?
B.CreateInBoundsGEP(
B.getInt8Ty(), Dst, StrLen) :
nullptr;
4709 if (isFortifiedCallFoldable(CI, 2, std::nullopt, 1)) {
4710 if (Func == LibFunc_strcpy_chk)
4716 if (OnlyLowerUnknownSize)
4726 unsigned SizeTBits = TLI->getSizeTSize(*CI->
getModule());
4728 Value *LenV = ConstantInt::get(SizeTTy, Len);
4732 if (Ret && Func == LibFunc_stpcpy_chk)
4733 return B.CreateInBoundsGEP(
B.getInt8Ty(), Dst,
4734 ConstantInt::get(SizeTTy, Len - 1));
4738Value *FortifiedLibCallSimplifier::optimizeStrLenChk(
CallInst *CI,
4740 if (isFortifiedCallFoldable(CI, 1, std::nullopt, 0))
4746Value *FortifiedLibCallSimplifier::optimizeStrpNCpyChk(
CallInst *CI,
4749 if (isFortifiedCallFoldable(CI, 3, 2)) {
4750 if (Func == LibFunc_strncpy_chk)
4763Value *FortifiedLibCallSimplifier::optimizeMemCCpyChk(
CallInst *CI,
4765 if (isFortifiedCallFoldable(CI, 4, 3))
4773Value *FortifiedLibCallSimplifier::optimizeSNPrintfChk(
CallInst *CI,
4775 if (isFortifiedCallFoldable(CI, 3, 1, std::nullopt, 2)) {
4785Value *FortifiedLibCallSimplifier::optimizeSPrintfChk(
CallInst *CI,
4787 if (isFortifiedCallFoldable(CI, 2, std::nullopt, std::nullopt, 1)) {
4791 VariadicArgs,
B, TLI));
4797Value *FortifiedLibCallSimplifier::optimizeStrCatChk(
CallInst *CI,
4799 if (isFortifiedCallFoldable(CI, 2))
4806Value *FortifiedLibCallSimplifier::optimizeStrLCat(
CallInst *CI,
4808 if (isFortifiedCallFoldable(CI, 3))
4816Value *FortifiedLibCallSimplifier::optimizeStrNCatChk(
CallInst *CI,
4818 if (isFortifiedCallFoldable(CI, 3))
4826Value *FortifiedLibCallSimplifier::optimizeStrLCpyChk(
CallInst *CI,
4828 if (isFortifiedCallFoldable(CI, 3))
4836Value *FortifiedLibCallSimplifier::optimizeVSNPrintfChk(
CallInst *CI,
4838 if (isFortifiedCallFoldable(CI, 3, 1, std::nullopt, 2))
4846Value *FortifiedLibCallSimplifier::optimizeVSPrintfChk(
CallInst *CI,
4848 if (isFortifiedCallFoldable(CI, 2, std::nullopt, std::nullopt, 1))
4878 Builder.setDefaultOperandBundles(OpBundles);
4882 LibFunc Func = TLI->getLibFunc(*Callee);
4883 if (Func == NotLibFunc)
4891 case LibFunc_memcpy_chk:
4892 return optimizeMemCpyChk(CI, Builder);
4893 case LibFunc_mempcpy_chk:
4894 return optimizeMemPCpyChk(CI, Builder);
4895 case LibFunc_memmove_chk:
4896 return optimizeMemMoveChk(CI, Builder);
4897 case LibFunc_memset_chk:
4898 return optimizeMemSetChk(CI, Builder);
4899 case LibFunc_stpcpy_chk:
4900 case LibFunc_strcpy_chk:
4901 return optimizeStrpCpyChk(CI, Builder, Func);
4902 case LibFunc_strlen_chk:
4903 return optimizeStrLenChk(CI, Builder);
4904 case LibFunc_stpncpy_chk:
4905 case LibFunc_strncpy_chk:
4906 return optimizeStrpNCpyChk(CI, Builder, Func);
4907 case LibFunc_memccpy_chk:
4908 return optimizeMemCCpyChk(CI, Builder);
4909 case LibFunc_snprintf_chk:
4910 return optimizeSNPrintfChk(CI, Builder);
4911 case LibFunc_sprintf_chk:
4912 return optimizeSPrintfChk(CI, Builder);
4913 case LibFunc_strcat_chk:
4914 return optimizeStrCatChk(CI, Builder);
4915 case LibFunc_strlcat_chk:
4916 return optimizeStrLCat(CI, Builder);
4917 case LibFunc_strncat_chk:
4918 return optimizeStrNCatChk(CI, Builder);
4919 case LibFunc_strlcpy_chk:
4920 return optimizeStrLCpyChk(CI, Builder);
4921 case LibFunc_vsnprintf_chk:
4922 return optimizeVSNPrintfChk(CI, Builder);
4923 case LibFunc_vsprintf_chk:
4924 return optimizeVSPrintfChk(CI, Builder);
4933 : TLI(TLI), OnlyLowerUnknownSize(OnlyLowerUnknownSize) {}
const TargetLowering & TLI
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements the APSInt class, which is a simple class that represents an arbitrary sized int...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Module.h This file contains the declarations for the Module class.
static bool mayFlushDenormalsToPositiveZero(const CallInst *CI)
Flushing a denormal to +0.0 breaks f(-x) = -f(x) for odd f.
static llvm::Error parse(GsymDataExtractor &Data, uint64_t BaseAddr, LineEntryCallback const &Callback)
uint64_t IntrinsicInst * II
static bool isBinary(MachineInstr &MI)
This file contains the declarations for profiling metadata utility functions.
SmallVector< MachineOperand, 4 > Cond
static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))
static bool isOnlyUsedInEqualityComparison(Value *V, Value *With)
Return true if it is only used in equality comparisons with With.
static Value * optimizeSinCosDoubleFP(CallInst *CI, IRBuilderBase &B)
Shrink double -> float for llvm.sincos.
static void annotateNonNullAndDereferenceable(CallInst *CI, ArrayRef< unsigned > ArgNos, Value *Size, const DataLayout &DL)
static cl::opt< unsigned, false, HotColdHintParser > ColdNewHintValue("cold-new-hint-value", cl::Hidden, cl::init(1), cl::desc("Value to pass to hot/cold operator new for cold allocation"))
static bool insertSinCosCall(IRBuilderBase &B, Function *OrigCallee, Value *Arg, bool UseFloat, Value *&Sin, Value *&Cos, Value *&SinCos, const TargetLibraryInfo *TLI)
static Value * mergeAttributesAndFlags(CallInst *NewCI, const CallInst &Old)
static cl::opt< bool > OptimizeHotColdNew("optimize-hot-cold-new", cl::Hidden, cl::init(false), cl::desc("Enable hot/cold operator new library calls"))
static Value * optimizeBinaryDoubleFP(CallInst *CI, IRBuilderBase &B, const TargetLibraryInfo *TLI, bool isPrecise=false)
Shrink double -> float for binary functions.
static cl::opt< OptimizeExistingHotColdNewKind > OptimizeExistingHotColdNew("optimize-existing-hot-cold-new", cl::Hidden, cl::desc("Enable optimization of existing hot/cold operator new library calls"), cl::values(clEnumValN(OptimizeExistingHotColdNewKind::None, "none", "Do not optimize existing hot/cold operator new library calls"), clEnumValN(OptimizeExistingHotColdNewKind::Cold, "cold", "Only optimize existing hot/cold operator new library calls " "if determined to be cold"), clEnumValN(OptimizeExistingHotColdNewKind::Always, "always", "Always optimize existing hot/cold operator new library calls"), clEnumValN(OptimizeExistingHotColdNewKind::Always, "", "Always optimize existing hot/cold operator new library calls")), cl::init(OptimizeExistingHotColdNewKind::None), cl::ValueOptional)
static cl::opt< bool > MinExistingHotColdNewHint("min-existing-hot-cold-new-hint", cl::Hidden, cl::init(false), cl::desc("Take the minimum of compiler hint and existing hint when " "optimizing existing hot/cold operator new library calls"))
static bool ignoreCallingConv(LibFunc Func)
static void annotateDereferenceableBytes(CallInst *CI, ArrayRef< unsigned > ArgNos, uint64_t DereferenceableBytes)
static void copyFPMath(const CallInst &Old, Value *New)
Preserve the accuracy requirement of Old on the replacement New.
static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg)
static Value * optimizeDoubleFP(CallInst *CI, IRBuilderBase &B, bool isBinary, const TargetLibraryInfo *TLI, bool isPrecise=false)
Shrink double -> float functions.
static Value * optimizeSymmetricCall(CallInst *CI, bool IsEven, IRBuilderBase &B)
static Value * getSqrtCall(Value *V, AttributeList Attrs, bool NoErrno, Module *M, IRBuilderBase &B, const TargetLibraryInfo *TLI)
static Value * replaceBinaryCall(CallInst *CI, IRBuilderBase &B, Intrinsic::ID IID)
static Value * valueHasFloatPrecision(Value *Val)
Return a variant of Val with float type.
static void annotateNonNullNoUndefBasedOnAccess(CallInst *CI, ArrayRef< unsigned > ArgNos, uint64_t CharSize=1)
static Value * optimizeMemCmpConstantSize(CallInst *CI, Value *LHS, Value *RHS, uint64_t Len, IRBuilderBase &B, const DataLayout &DL)
static Value * createPowWithIntegerExponent(Value *Base, Value *Expo, Module *M, IRBuilderBase &B)
static Value * convertStrToInt(CallInst *CI, StringRef &Str, Value *EndPtr, uint64_t Base, bool AsSigned, IRBuilderBase &B)
static Value * memChrToCharCompare(CallInst *CI, Value *NBytes, IRBuilderBase &B, const DataLayout &DL)
static Value * copyFlags(const CallInst &Old, Value *New)
static bool canTransformToMemCmp(CallInst *CI, Value *Str, uint64_t Len, const SimplifyQuery &SQ)
static StringRef substr(StringRef Str, uint64_t Len)
static cl::opt< unsigned, false, HotColdHintParser > HotNewHintValue("hot-new-hint-value", cl::Hidden, cl::init(254), cl::desc("Value to pass to hot/cold operator new for hot allocation"))
static bool isTrigLibCall(CallInst *CI)
static Value * optimizeNaN(CallInst *CI)
Constant folding nan/nanf/nanl.
static bool isOnlyUsedInComparisonWithZero(Value *V)
static Value * replaceUnaryCall(CallInst *CI, IRBuilderBase &B, Intrinsic::ID IID)
static bool callHasFloatingPointArgument(const CallInst *CI)
static Value * optimizeUnaryDoubleFP(CallInst *CI, IRBuilderBase &B, const TargetLibraryInfo *TLI, bool isPrecise=false)
Shrink double -> float for unary functions.
static bool callHasFP128Argument(const CallInst *CI)
static cl::opt< bool > OptimizeNoBuiltinHotColdNew("optimize-nobuiltin-hot-cold-new-new", cl::Hidden, cl::init(false), cl::desc("Enable transformation of nobuiltin operator new library calls"))
static cl::opt< unsigned, false, HotColdHintParser > AmbiguousNewHintValue("ambiguous-new-hint-value", cl::Hidden, cl::init(222), cl::desc("Value to pass to hot/cold operator new for ambiguous allocation"))
static Value * optimizeMemCmpVarSize(CallInst *CI, Value *LHS, Value *RHS, Value *Size, bool StrNCmp, IRBuilderBase &B, const DataLayout &DL)
static Value * getIntToFPVal(Value *I2F, IRBuilderBase &B, unsigned DstWidth)
static cl::opt< bool > EnableUnsafeFPShrink("enable-double-float-shrink", cl::Hidden, cl::init(false), cl::desc("Enable unsafe double to float " "shrinking for math lib calls"))
static cl::opt< unsigned, false, HotColdHintParser > NotColdNewHintValue("notcold-new-hint-value", cl::Hidden, cl::init(128), cl::desc("Value to pass to hot/cold operator new for " "notcold (warm) allocation"))
OptimizeExistingHotColdNewKind
This file defines the SmallString class.
static TableGen::Emitter::Opt Y("gen-skeleton-entry", EmitSkeleton, "Generate example skeleton entry")
static SymbolRef::Type getType(const Symbol *Sym)
static const fltSemantics & IEEEsingle()
static constexpr roundingMode rmTowardZero
static constexpr roundingMode rmTowardNegative
static constexpr roundingMode rmNearestTiesToEven
opStatus
IEEE-754R 7: Default exception handling.
opStatus divide(const APFloat &RHS, roundingMode RM)
bool isFiniteNonZero() const
LLVM_ABI opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
opStatus subtract(const APFloat &RHS, roundingMode RM)
LLVM_ABI double convertToDouble() const
Converts this APFloat to host double value.
bool isExactlyValue(double V) const
We don't rely on operator== working on double values, as it returns true for things that are clearly ...
opStatus add(const APFloat &RHS, roundingMode RM)
const fltSemantics & getSemantics() const
LLVM_ABI float convertToFloat() const
Converts this APFloat to host float value.
opStatus remainder(const APFloat &RHS)
opStatus convertToInteger(MutableArrayRef< integerPart > Input, unsigned int Width, bool IsSigned, roundingMode RM, bool *IsExact) const
Class for arbitrary precision integers.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
A cache of @llvm.assume calls within a function.
static LLVM_ABI Attribute getWithDereferenceableBytes(LLVMContext &Context, uint64_t Bytes)
static LLVM_ABI Attribute getWithCaptureInfo(LLVMContext &Context, CaptureInfo CI)
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
void addFnAttr(Attribute::AttrKind Kind)
Adds the attribute to the function.
void removeParamAttrs(unsigned ArgNo, const AttributeMask &AttrsToRemove)
Removes the attributes from the given argument.
LLVM_ABI void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
bool isNoBuiltin() const
Return true if the call should not be treated as a call to a builtin.
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Removes the attribute from the given argument.
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
bool doesNotAccessMemory(unsigned OpNo) const
void removeRetAttrs(const AttributeMask &AttrsToRemove)
Removes the attributes from the return value.
bool hasFnAttr(Attribute::AttrKind Kind) const
Determine whether this call has the given attribute.
bool isStrictFP() const
Determine if the call requires strict floating point semantics.
AttributeSet getParamAttributes(unsigned ArgNo) const
Return the param attributes for this call.
uint64_t getParamDereferenceableBytes(unsigned i) const
Extract the number of dereferenceable bytes for a call or parameter (0=unknown).
LLVM_ABI bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
MaybeAlign getParamAlign(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
AttributeSet getRetAttributes() const
Return the return attributes for this call.
void setAttributes(AttributeList A)
Set the attributes for this call.
bool doesNotThrow() const
Determine if the call cannot unwind.
Value * getArgOperand(unsigned i) const
uint64_t getParamDereferenceableOrNullBytes(unsigned i) const
Extract the number of dereferenceable_or_null bytes for a parameter (0=unknown).
LLVM_ABI Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
unsigned arg_size() const
AttributeList getAttributes() const
Return the attributes for this call.
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
LLVM_ABI Function * getCaller()
Helper to get the caller (the parent function).
This class represents a function call, abstracting a target machine's calling convention.
bool isNoTailCall() const
TailCallKind getTailCallKind() const
bool isMustTailCall() const
static CaptureInfo none()
Create CaptureInfo that does not capture any components of the pointer.
@ ICMP_UGT
unsigned greater than
@ ICMP_ULT
unsigned less than
@ ICMP_ULE
unsigned less or equal
Predicate getPredicate() const
Return the predicate for this instruction.
LLVM_ABI uint64_t getElementAsInteger(uint64_t i) const
If this is a sequential container of integers (of any size), return the specified element in the low ...
ConstantFP - Floating Point Values [float, double].
static LLVM_ABI ConstantFP * getZero(Type *Ty, bool Negative=false)
static LLVM_ABI ConstantFP * getQNaN(Type *Ty, bool Negative=false, APInt *Payload=nullptr)
static LLVM_ABI ConstantFP * getInfinity(Type *Ty, bool Negative=false)
This is the shared class of boolean and integer constants.
bool isOne() const
This is just a convenience method to make client code smaller for a common case.
static ConstantInt * getSigned(IntegerType *Ty, int64_t V, bool ImplicitTrunc=false)
Return a ConstantInt with the specified value for the specified type.
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
This is an important base class in LLVM.
static LLVM_ABI Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
A parsed version of the target data layout string in and methods for querying it.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
This class represents an extension of floating point types.
This class represents a truncation of floating point types.
void setNoSignedZeros(bool B=true)
static FastMathFlags getFast()
static LLVM_ABI FixedVectorType * get(Type *ElementType, unsigned NumElts)
LLVM_ABI FortifiedLibCallSimplifier(const TargetLibraryInfo *TLI, bool OnlyLowerUnknownSize=false)
LLVM_ABI Value * optimizeCall(CallInst *CI, IRBuilderBase &B)
Take the given call instruction and return a more optimal value to replace the instruction with or 0 ...
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
AttributeList getAttributes() const
Return the attribute list for this Function.
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
DenormalMode getDenormalMode(const fltSemantics &FPType) const
Returns the denormal handling type for the default rounding mode of the function.
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
LLVM_ABI bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Module * getParent()
Get the module that this global value is contained inside of...
This instruction compares its operands according to the predicate given to the constructor.
Common base class shared among various IRBuilders.
Value * CreateLdexp(Value *Src, Value *Exp, FMFSource FMFSource={}, const Twine &Name="")
Create call to the ldexp intrinsic.
LLVM_ABI Instruction * clone() const
Create a copy of 'this' instruction that is identical in all ways except the following:
LLVM_ABI bool hasNoNaNs() const LLVM_READONLY
Determine whether the no-NaNs flag is set.
LLVM_ABI void copyIRFlags(const Value *V, bool IncludeWrapFlags=true)
Convenience method to copy supported exact, fast-math, and (optionally) wrapping flags from V to this...
LLVM_ABI const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
LLVM_ABI bool isFast() const LLVM_READONLY
Determine whether all fast-math-flags are set.
LLVM_ABI const Function * getFunction() const
Return the function this instruction belongs to.
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
iterator_range< user_iterator > users()
LLVM_ABI FastMathFlags getFastMathFlags() const LLVM_READONLY
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
LLVM_ABI void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
LLVM_ABI bool hasAllowReassoc() const LLVM_READONLY
Determine whether the allow-reassociation flag is set.
LLVM_ABI const DataLayout & getDataLayout() const
Get the data layout of the module this instruction belongs to.
Class to represent integer types.
static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
A wrapper class for inspecting calls to intrinsic functions.
bool isKnownNeverInfinity() const
Return true if it's known this can never be an infinity.
static constexpr FPClassTest OrderedLessThanZeroMask
LLVM_ABI bool isKnownNeverLogicalZero(DenormalMode Mode) const
Return true if it's known this can never be interpreted as a zero.
LLVM_ABI LibCallSimplifier(const DataLayout &DL, const TargetLibraryInfo *TLI, DominatorTree *DT, DomConditionCache *DC, AssumptionCache *AC, OptimizationRemarkEmitter &ORE, BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI, function_ref< void(Instruction *, Value *)> Replacer=&replaceAllUsesWithDefault, function_ref< void(Instruction *)> Eraser=&eraseFromParentDefault)
LLVM_ABI Value * optimizeCall(CallInst *CI, IRBuilderBase &B)
optimizeCall - Take the given call instruction and return a more optimal value to replace the instruc...
An instruction for reading from memory.
Value * getPointerOperand()
static constexpr uint32_t kLikelyBranchWeight
The weight for a branch taken with high probability.
static constexpr uint32_t kUnlikelyBranchWeight
The weight for a branch taken with low probability.
A Module instance is used to store all the information related to an LLVM module.
const Triple & getTargetTriple() const
Get the target triple which is a string describing the target host.
static LLVM_ABI PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Analysis providing profile information.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Represent a constant reference to a string, i.e.
static constexpr size_t npos
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
constexpr bool empty() const
Check if the string is empty.
char back() const
Get the last character in the string.
constexpr size_t size() const
Get the string size.
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
bool ends_with(StringRef Suffix) const
Check if this string ends with the given Suffix.
int compare(StringRef RHS) const
Compare two strings; the result is negative, zero, or positive if this string is lexicographically le...
static LLVM_ABI StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
static LLVM_ABI bool isCallingConvCCompatible(CallBase *CI)
Returns true if call site / callee has cdecl-compatible calling conventions.
Provides information about what library functions are available for the current target.
Triple - Helper class for working with autoconf configuration names.
The instances of the Type class are immutable: once they are created, they are never changed.
LLVM_ABI unsigned getIntegerBitWidth() const
bool isVectorTy() const
True if this is an instance of VectorType.
bool isPointerTy() const
True if this is an instance of PointerType.
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
LLVM_ABI unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
static LLVM_ABI IntegerType * getInt8Ty(LLVMContext &C)
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
bool isStructTy() const
True if this is an instance of StructType.
LLVM_ABI TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
bool isIntegerTy() const
True if this is an instance of IntegerType.
static LLVM_ABI IntegerType * getIntNTy(LLVMContext &C, unsigned N)
LLVM_ABI const fltSemantics & getFltSemantics() const
bool isVoidTy() const
Return true if this is 'void'.
A Use represents the edge between a Value definition and its users.
void setOperand(unsigned i, Value *Val)
Value * getOperand(unsigned i) const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
LLVM_ABI void setMetadata(unsigned KindID, MDNode *Node)
Set a particular kind of metadata attachment.
bool hasOneUse() const
Return true if there is exactly one use of this value.
LLVMContext & getContext() const
All values hold a context through their type.
iterator_range< user_iterator > users()
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
LLVM_ABI void takeName(Value *V)
Transfer the name from V to this value.
An efficient, type-erasing, non-owning reference to a callable.
const ParentTy * getParent() const
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
Flag
These should be considered private to the implementation of the MCInstrDesc class.
OneUse_match< SubPat > m_OneUse(const SubPat &SP)
ap_match< APInt > m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.
BinaryOp_match< LHS, RHS, Instruction::FMul > m_FMul(const LHS &L, const RHS &R)
bool match(Val *V, const Pattern &P)
match_deferred< Value > m_Deferred(Value *const &V)
Like m_Specific(), but works if the specific value to match is determined as part of the same match()...
cstfp_pred_ty< is_any_zero_fp > m_AnyZeroFP()
Match a floating-point negative zero or positive zero.
ap_match< APFloat > m_APFloat(const APFloat *&Res)
Match a ConstantFP or splatted ConstantVector, binding the specified pointer to the contained APFloat...
ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)
Matches SelectInst.
specific_fpval m_SpecificFP(double V)
Match a specific floating point value or vector with all elements equal to the value.
auto m_CopySign(const Opnd0 &Op0, const Opnd1 &Op1)
auto m_Value()
Match an arbitrary value and ignore it.
specific_fpval m_FPOne()
Match a float 1.0 or vector with all elements equal to 1.0.
FNeg_match< OpTy, true > m_FNegOrFSubNegZero(const OpTy &X)
Match fneg X or fsub -0.0, X.
auto m_FAbs(const Opnd0 &Op0)
auto m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
initializer< Ty > init(const Ty &Val)
NodeAddr< FuncNode * > Func
friend class Instruction
Iterator for Instructions in a `BasicBlock.
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
LLVM_ABI Value * emitHotColdSizeReturningNewAligned(Value *Num, Value *Align, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, Value *HotCold, Type *RetTy)
LLVM_ABI Value * emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs)
Emit a call to the unary function named 'Name' (e.g.
LLVM_ABI KnownFPClass computeKnownFPClass(const Value *V, const APInt &DemandedElts, FPClassTest InterestedClasses, const SimplifyQuery &SQ, unsigned Depth=0)
Determine which floating-point classes are valid for V, and return them in KnownFPClass bit sets.
LLVM_ABI cl::opt< bool > ProfcheckDisableMetadataFixes
LLVM_ABI Value * emitStrChr(Value *Ptr, char C, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strchr function to the builder, for the specified pointer and character.
constexpr uint64_t maxUIntN(uint64_t N)
Gets the maximum value for a N-bit unsigned integer.
LLVM_ABI Value * emitPutChar(Value *Char, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the putchar function. This assumes that Char is an 'int'.
LLVM_ABI Value * emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the __memcpy_chk function to the builder.
LLVM_ABI Value * emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strncpy function to the builder, for the specified pointer arguments and length.
LLVM_ABI bool isKnownNeverInfinity(const Value *V, const SimplifyQuery &SQ, unsigned Depth=0)
Return true if the floating-point scalar value is not an infinity or if the floating-point vector val...
@ Known
Known to have no common set bits.
LLVM_ABI void setExplicitlyUnknownBranchWeightsIfProfiled(Instruction &I, StringRef PassName, const Function *F=nullptr)
Like setExplicitlyUnknownBranchWeights(...), but only sets unknown branch weights in the new instruct...
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
APFloat abs(APFloat X)
Returns the absolute value of the argument.
LLVM_ABI bool getConstantStringInfo(const Value *V, StringRef &Str, bool TrimAtNul=true)
This function computes the length of a null-terminated C string pointed to by V.
LLVM_ABI Value * emitSPrintf(Value *Dest, Value *Fmt, ArrayRef< Value * > VariadicArgs, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the sprintf function.
LLVM_ABI bool getConstantDataArrayInfo(const Value *V, ConstantDataArraySlice &Slice, unsigned ElementSize, uint64_t Offset=0)
Returns true if the value V is a pointer into a ConstantDataArray.
LLVM_ABI Value * emitMemRChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memrchr function, analogously to emitMemChr.
LLVM_ABI Value * emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strlcat function.
LLVM_ABI bool shouldOptimizeForSize(const MachineFunction *MF, ProfileSummaryInfo *PSI, const MachineBlockFrequencyInfo *BFI, PGSOQueryType QueryType=PGSOQueryType::Other)
Returns true if machine function MF is suggested to be size-optimized based on the profile.
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
LLVM_ABI void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
LLVM_ABI bool hasFloatFn(const Module *M, const TargetLibraryInfo *TLI, Type *Ty, LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn)
Check whether the overloaded floating point function corresponding to Ty is available.
LLVM_ABI Value * emitHotColdNewNoThrow(Value *Num, Value *NoThrow, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, Value *HotCold)
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
LLVM_ABI Value * emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strncat function.
LLVM_ABI bool isLibFuncEmittable(const Module *M, const TargetLibraryInfo *TLI, LibFunc TheLibFunc)
Check whether the library function is available on target and also that it in the current Module is a...
LLVM_ABI void setBranchWeights(Instruction &I, ArrayRef< uint32_t > Weights, bool IsExpected, bool ElideAllZero=false)
Create a new branch_weights metadata node and add or overwrite a prof metadata reference to instructi...
LLVM_ABI Value * emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the vsnprintf function.
auto dyn_cast_or_null(const Y &Val)
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI Value * emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the strncmp function to the builder.
LLVM_ABI Value * emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memcmp function.
LLVM_ABI Value * emitBinaryFloatFnCall(Value *Op1, Value *Op2, const TargetLibraryInfo *TLI, StringRef Name, IRBuilderBase &B, const AttributeList &Attrs)
Emit a call to the binary function named 'Name' (e.g.
bool isAlpha(char C)
Checks if character C is a valid letter as classified by "C" locale.
LLVM_ABI Value * emitFPutS(Value *Str, Value *File, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the fputs function.
LLVM_ABI Value * emitStrDup(Value *Ptr, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strdup function to the builder, for the specified pointer.
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
void sort(IteratorTy Start, IteratorTy End)
LLVM_ABI Value * emitHotColdNewAligned(Value *Num, Value *Align, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, Value *HotCold)
LLVM_ABI Value * emitHotColdNewAlignedNoThrow(Value *Num, Value *Align, Value *NoThrow, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, Value *HotCold)
LLVM_ABI bool NullPointerIsDefined(const Function *F, unsigned AS=0)
Check whether null pointer dereferencing is considered undefined behavior for a given function or an ...
LLVM_ABI Value * emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the bcmp function.
bool isDigit(char C)
Checks if character C is one of the 10 decimal digits.
std::enable_if_t< std::is_unsigned_v< T >, T > SaturatingMultiplyAdd(T X, T Y, T A, bool *ResultOverflowed=nullptr)
Multiply two unsigned integers, X and Y, and add the unsigned integer, A to the product.
LLVM_ABI uint64_t GetStringLength(const Value *V, unsigned CharSize=8)
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'.
LLVM_ABI FunctionCallee getOrInsertLibFunc(Module *M, const TargetLibraryInfo &TLI, LibFunc TheLibFunc, FunctionType *T, AttributeList AttributeList)
Calls getOrInsertFunction() and then makes sure to add mandatory argument attributes.
LLVM_ABI Value * emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the strlen function to the builder, for the specified pointer.
LLVM_ABI Value * emitFPutC(Value *Char, Value *File, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the fputc function.
LLVM_ABI Value * emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the stpncpy function to the builder, for the specified pointer arguments and length.
LLVM_ABI Value * emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strcat function.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
LLVM_ABI Value * emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the vsprintf function.
LLVM_ABI bool isKnownNonZero(const Value *V, const SimplifyQuery &Q, unsigned Depth=0)
Return true if the given value is known to be non-zero when defined.
LLVM_ABI Value * emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the fwrite function.
LLVM_ABI Value * emitSNPrintf(Value *Dest, Value *Size, Value *Fmt, ArrayRef< Value * > Args, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the snprintf function.
@ Mod
The access may modify the value stored in memory.
LLVM_ABI Value * emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the stpcpy function to the builder, for the specified pointer arguments.
@ And
Bitwise or logical AND of integers.
char toUpper(char x)
Returns the corresponding uppercase character if x is lowercase.
LLVM_ABI bool isOnlyUsedInZeroEqualityComparison(const Instruction *CtxI)
DWARFExpression::Operation Op
@ NearestTiesToEven
roundTiesToEven.
constexpr int64_t maxIntN(int64_t N)
Gets the maximum value for a N-bit signed integer.
constexpr unsigned BitWidth
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
LLVM_ABI Value * emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the malloc function.
LLVM_ABI Value * emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the memchr function.
bool isSpace(char C)
Checks whether character C is whitespace in the "C" locale.
Align getKnownAlignment(Value *V, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
Try to infer an alignment for the specified pointer.
LLVM_ABI Value * emitPutS(Value *Str, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the puts function. This assumes that Str is some pointer.
LLVM_ABI Value * emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the memccpy function.
LLVM_ABI Value * emitHotColdNew(Value *Num, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, Value *HotCold)
Emit a call to the hot/cold operator new function.
LLVM_ABI Constant * ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty, APInt Offset, const DataLayout &DL)
Return the value that a load from C with offset Offset would produce if it is constant and determinab...
LLVM_ABI Value * emitHotColdSizeReturningNew(Value *Num, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, Value *HotCold, Type *RetTy)
LLVM_ABI bool isDereferenceablePointer(const Value *V, Type *Ty, const SimplifyQuery &Q, bool IgnoreFree=false)
Equivalent to isDereferenceableAndAlignedPointer with an alignment of 1.
LLVM_ABI Value * emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strlcpy function.
LLVM_ABI Value * emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI)
Emit a call to the strcpy function to the builder, for the specified pointer arguments.
@ Always
Always emit .debug_str_offsets talbes as DWARF64 for testing.
LLVM_ABI Value * emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI)
Emit a call to the mempcpy function.
constexpr uint64_t NextPowerOf2(uint64_t A)
Returns the next power of two (in 64-bits) that is strictly greater than A.
This struct is a compact representation of a valid (non-zero power of two) alignment.
uint64_t Length
Length of the slice.
uint64_t Offset
Slice starts at this Offset.
const ConstantDataArray * Array
ConstantDataArray pointer.
Represent subnormal handling kind for floating point instruction inputs and outputs.