24#include "llvm/IR/IntrinsicsAMDGPU.h"
30#define DEBUG_TYPE "amdgpu-simplifylib"
36 cl::desc(
"Enable pre-link mode optimizations"),
41 cl::desc(
"Comma separated list of functions to replace with native, or all"),
45#define MATH_PI numbers::pi
46#define MATH_E numbers::e
47#define MATH_SQRT2 numbers::sqrt2
48#define MATH_SQRT1_2 numbers::inv_sqrt2
60 bool UnsafeFPMath =
false;
63 bool AllNative =
false;
87 bool evaluateScalarMathFunc(
const FuncInfo &FInfo,
double &Res0,
double &Res1,
93 std::tuple<Value *, Value *, Value *> insertSinCos(
Value *Arg,
110 bool shouldReplaceLibcallWithIntrinsic(
const CallInst *CI,
111 bool AllowMinSizeF32 =
false,
112 bool AllowF64 =
false,
113 bool AllowStrictFP =
false);
119 bool AllowMinSizeF32 =
false,
120 bool AllowF64 =
false,
121 bool AllowStrictFP =
false);
130 I->replaceAllUsesWith(With);
131 I->eraseFromParent();
152template <
typename IRB>
156 if (
Function *
F = dyn_cast<Function>(Callee.getCallee()))
157 R->setCallingConv(
F->getCallingConv());
161template <
typename IRB>
165 if (
Function *
F = dyn_cast<Function>(Callee.getCallee()))
166 R->setCallingConv(
F->getCallingConv());
172 if (
VectorType *VecTy = dyn_cast<VectorType>(FT->getReturnType()))
173 PowNExpTy = VectorType::get(PowNExpTy, VecTy->getElementCount());
175 return FunctionType::get(FT->getReturnType(),
176 {FT->getParamType(0), PowNExpTy},
false);
334 case AMDGPULibFunc::EI_DIVIDE:
335 case AMDGPULibFunc::EI_COS:
336 case AMDGPULibFunc::EI_EXP:
337 case AMDGPULibFunc::EI_EXP2:
338 case AMDGPULibFunc::EI_EXP10:
339 case AMDGPULibFunc::EI_LOG:
340 case AMDGPULibFunc::EI_LOG2:
341 case AMDGPULibFunc::EI_LOG10:
342 case AMDGPULibFunc::EI_POWR:
343 case AMDGPULibFunc::EI_RECIP:
344 case AMDGPULibFunc::EI_RSQRT:
345 case AMDGPULibFunc::EI_SIN:
346 case AMDGPULibFunc::EI_SINCOS:
347 case AMDGPULibFunc::EI_SQRT:
348 case AMDGPULibFunc::EI_TAN:
369 case AMDGPULibFunc::EI_NCOS:
376 case AMDGPULibFunc::EI_NEXP2:
381 case AMDGPULibFunc::EI_NLOG2:
384 case AMDGPULibFunc::EI_NRSQRT:
386 case AMDGPULibFunc::EI_NSIN:
390 case AMDGPULibFunc::EI_NSQRT:
417bool AMDGPULibCalls::parseFunctionName(
const StringRef &FMangledName,
423 return UnsafeFPMath || FPOp->
isFast();
427 return UnsafeFPMath ||
438 UnsafeFPMath =
F.getFnAttribute(
"unsafe-fp-math").getValueAsBool();
444bool AMDGPULibCalls::useNativeFunc(
const StringRef F)
const {
449 AllNative = useNativeFunc(
"all") ||
454bool AMDGPULibCalls::sincosUseNative(
CallInst *aCI,
const FuncInfo &FInfo) {
455 bool native_sin = useNativeFunc(
"sin");
456 bool native_cos = useNativeFunc(
"cos");
458 if (native_sin && native_cos) {
473 if (sinExpr && cosExpr) {
481 <<
" with native version of sin/cos");
496 if (!parseFunctionName(Callee->getName(), FInfo) || !FInfo.
isMangled() ||
499 !(AllNative || useNativeFunc(FInfo.
getName()))) {
504 return sincosUseNative(aCI, FInfo);
513 <<
" with native version");
525 const FuncInfo &FInfo) {
527 if (!Callee->isDeclaration())
530 assert(Callee->hasName() &&
"Invalid read_pipe/write_pipe function");
531 auto *M = Callee->getParent();
532 std::string
Name = std::string(Callee->getName());
534 if (NumArg != 4 && NumArg != 6)
540 if (!PacketSize || !PacketAlign)
545 if (Alignment !=
Size)
548 unsigned PtrArgLoc = CI->
arg_size() - 3;
553 for (
unsigned I = 0;
I != PtrArgLoc; ++
I)
566 for (
unsigned I = 0;
I != PtrArgLoc; ++
I)
568 Args.push_back(PtrArg);
570 auto *NCI =
B.CreateCall(
F, Args);
581 if (isa<PoisonValue>(V))
583 if (isa<UndefValue>(V))
586 if (
const ConstantFP *CF = dyn_cast<ConstantFP>(V))
587 return CF->getValueAPF().isInteger();
589 auto *VFVTy = dyn_cast<FixedVectorType>(V->getType());
590 const Constant *CV = dyn_cast<Constant>(V);
592 unsigned NumElts = VFVTy->getNumElements();
593 for (
unsigned i = 0; i != NumElts; ++i) {
597 if (isa<PoisonValue>(Elt))
600 const ConstantFP *CFP = dyn_cast<ConstantFP>(Elt);
612 switch (
I->getOpcode()) {
613 case Instruction::SIToFP:
614 case Instruction::UIToFP:
622 case Instruction::Call: {
625 case Intrinsic::trunc:
626 case Intrinsic::floor:
627 case Intrinsic::ceil:
628 case Intrinsic::rint:
629 case Intrinsic::nearbyint:
630 case Intrinsic::round:
631 case Intrinsic::roundeven:
651 if (!Callee || Callee->isIntrinsic() || CI->
isNoBuiltin())
655 if (!parseFunctionName(Callee->getName(), FInfo))
665 if (TDOFold(CI, FInfo))
670 B.setIsFPConstrained(
true);
681 B.setFastMathFlags(FMF);
686 switch (FInfo.
getId()) {
690 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::exp,
695 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::exp2,
700 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::log,
705 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::log2,
710 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::log10,
713 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::minnum,
716 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::maxnum,
719 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::fma,
true,
722 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::fmuladd,
725 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::fabs,
true,
728 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::copysign,
731 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::floor,
true,
734 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::ceil,
true,
737 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::trunc,
true,
740 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::rint,
true,
743 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::round,
true,
746 if (!shouldReplaceLibcallWithIntrinsic(CI,
true,
true))
751 VecTy && !isa<VectorType>(Arg1->
getType())) {
752 Value *SplatArg1 =
B.CreateVectorSplat(VecTy->getElementCount(), Arg1);
758 {CI->getType(), CI->getArgOperand(1)->getType()}));
762 Module *M = Callee->getParent();
765 CallInst *Call = cast<CallInst>(FPOp);
771 FPOp->getOperand(0), 0,
773 Call->setCalledFunction(PowrFunc);
774 return fold_pow(FPOp,
B, PowrInfo) ||
true;
779 FPOp->getFastMathFlags())) {
788 B.CreateFPToSI(FPOp->getOperand(1), PownType->
getParamType(1));
790 Call->removeParamAttrs(
792 Call->setCalledFunction(PownFunc);
793 Call->setArgOperand(1, CastedArg);
794 return fold_pow(FPOp,
B, PownInfo) ||
true;
798 return fold_pow(FPOp,
B, FInfo);
802 return fold_pow(FPOp,
B, FInfo);
804 return fold_rootn(FPOp,
B, FInfo);
807 return tryReplaceLibcallWithSimpleIntrinsic(
808 B, CI, Intrinsic::sqrt,
true,
true,
false);
811 return fold_sincos(FPOp,
B, FInfo);
817 switch (FInfo.
getId()) {
822 return fold_read_write_pipe(CI,
B, FInfo);
831bool AMDGPULibCalls::TDOFold(
CallInst *CI,
const FuncInfo &FInfo) {
837 int const sz = (int)tr.
size();
843 for (
int eltNo = 0; eltNo <
getVecSize(FInfo); ++eltNo) {
845 CV->getElementAsConstant((
unsigned)eltNo));
846 assert(eltval &&
"Non-FP arguments in math function!");
848 for (
int i=0; i < sz; ++i) {
864 for (
unsigned i = 0; i < DVal.
size(); ++i) {
873 LLVM_DEBUG(
errs() <<
"AMDIC: " << *CI <<
" ---> " << *nval <<
"\n");
879 if (
ConstantFP *CF = dyn_cast<ConstantFP>(opr0)) {
880 for (
int i = 0; i < sz; ++i) {
881 if (CF->isExactlyValue(tr[i].input)) {
882 Value *nval = ConstantFP::get(CF->getType(), tr[i].result);
883 LLVM_DEBUG(
errs() <<
"AMDIC: " << *CI <<
" ---> " << *nval <<
"\n");
896#if _XOPEN_SOURCE >= 600 || defined(_ISOC99_SOURCE) || _POSIX_C_SOURCE >= 200112L
905 const FuncInfo &FInfo) {
909 "fold_pow: encounter a wrong function call");
911 Module *
M =
B.GetInsertBlock()->getModule();
917 const APInt *CINT =
nullptr;
922 int ci_opr1 = (CINT ? (int)CINT->
getSExtValue() : 0x1111111);
924 if ((CF && CF->
isZero()) || (CINT && ci_opr1 == 0)) {
927 Constant *cnval = ConstantFP::get(eltType, 1.0);
936 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> " << *opr0 <<
"\n");
942 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> " << *opr0 <<
" * "
944 Value *nval =
B.CreateFMul(opr0, opr0,
"__pow2");
948 if ((CF && CF->
isExactlyValue(-1.0)) || (CINT && ci_opr1 == -1)) {
950 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> 1 / " << *opr0 <<
"\n");
951 Constant *cnval = ConstantFP::get(eltType, 1.0);
955 Value *nval =
B.CreateFDiv(cnval, opr0,
"__powrecip");
967 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> " << FInfo.getName()
968 <<
'(' << *opr0 <<
")\n");
986 int ival = (int)dval;
987 if ((
double)ival == dval) {
990 ci_opr1 = 0x11111111;
995 unsigned abs_opr1 = (ci_opr1 < 0) ? -ci_opr1 : ci_opr1;
996 if (abs_opr1 <= 12) {
1000 cnval = ConstantFP::get(eltType, 1.0);
1006 Value *valx2 =
nullptr;
1008 while (abs_opr1 > 0) {
1009 valx2 = valx2 ?
B.CreateFMul(valx2, valx2,
"__powx2") : opr0;
1011 nval = nval ?
B.CreateFMul(nval, valx2,
"__powprod") : valx2;
1018 cnval = ConstantFP::get(eltType, 1.0);
1022 nval =
B.CreateFDiv(cnval, nval,
"__1powprod");
1025 << ((ci_opr1 < 0) ?
"1/prod(" :
"prod(") << *opr0
1037 if (ShouldUseIntrinsic)
1045 bool needlog =
false;
1046 bool needabs =
false;
1047 bool needcopysign =
false;
1058 V =
log2(std::abs(V));
1059 cnval = ConstantFP::get(eltType, V);
1074 "Wrong vector size detected");
1079 if (V < 0.0) needcopysign =
true;
1080 V =
log2(std::abs(V));
1085 for (
unsigned i=0; i < DVal.
size(); ++i) {
1106 nval =
B.CreateUnaryIntrinsic(Intrinsic::fabs, opr0,
nullptr,
"__fabs");
1108 nval = cnval ? cnval : opr0;
1112 if (ShouldUseIntrinsic) {
1126 opr1 =
B.CreateSIToFP(opr1, nval->
getType(),
"pownI2F");
1128 nval =
B.CreateFMul(opr1, nval,
"__ylogx");
1137 opr_n =
B.CreateZExtOrTrunc(opr_n, nTy,
"__ytou");
1139 opr_n =
B.CreateFPToSI(opr1, nTy,
"__ytou");
1141 Value *sign =
B.CreateShl(opr_n, size-1,
"__yeven");
1142 sign =
B.CreateAnd(
B.CreateBitCast(opr0, nTy), sign,
"__pow_sign");
1143 nval =
B.CreateOr(
B.CreateBitCast(nval, nTy), sign);
1144 nval =
B.CreateBitCast(nval, opr0->
getType());
1148 <<
"exp2(" << *opr1 <<
" * log2(" << *opr0 <<
"))\n");
1155 const FuncInfo &FInfo) {
1159 const APInt *CINT =
nullptr;
1163 Function *Parent =
B.GetInsertBlock()->getParent();
1166 if (ci_opr1 == 1 && !Parent->
hasFnAttribute(Attribute::StrictFP)) {
1170 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> " << *opr0 <<
'\n');
1175 Module *
M =
B.GetInsertBlock()->getModule();
1177 CallInst *CI = cast<CallInst>(FPOp);
1179 shouldReplaceLibcallWithIntrinsic(CI,
1183 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> sqrt(" << *opr0 <<
")\n");
1185 CallInst *NewCall =
B.CreateUnaryIntrinsic(Intrinsic::sqrt, opr0, CI);
1192 NewCall->
setMetadata(LLVMContext::MD_fpmath, FPMD);
1201 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> cbrt(" << *opr0
1207 }
else if (ci_opr1 == -1) {
1208 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> 1.0 / " << *opr0 <<
"\n");
1209 Value *nval =
B.CreateFDiv(ConstantFP::get(opr0->
getType(), 1.0),
1216 if (ci_opr1 == -2 &&
1217 shouldReplaceLibcallWithIntrinsic(CI,
1231 CallInst *Sqrt =
B.CreateUnaryIntrinsic(Intrinsic::sqrt, opr0, CI);
1233 B.CreateFDiv(ConstantFP::get(opr0->
getType(), 1.0), Sqrt));
1238 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> rsqrt(" << *opr0
1249 const FuncInfo &FInfo) {
1252 FuncInfo nf = FInfo;
1254 return getFunction(M, nf);
1260bool AMDGPULibCalls::shouldReplaceLibcallWithIntrinsic(
const CallInst *CI,
1261 bool AllowMinSizeF32,
1263 bool AllowStrictFP) {
1278 if (!AllowStrictFP && ParentF->
hasFnAttribute(Attribute::StrictFP))
1281 if (IsF32 && !AllowMinSizeF32 && ParentF->
hasMinSize())
1286void AMDGPULibCalls::replaceLibCallWithSimpleIntrinsic(
IRBuilder<> &
B,
1294 if (Arg0VecTy && !Arg1VecTy) {
1295 Value *SplatRHS =
B.CreateVectorSplat(Arg0VecTy->getElementCount(), Arg1);
1297 }
else if (!Arg0VecTy && Arg1VecTy) {
1298 Value *SplatLHS =
B.CreateVectorSplat(Arg1VecTy->getElementCount(), Arg0);
1307bool AMDGPULibCalls::tryReplaceLibcallWithSimpleIntrinsic(
1309 bool AllowF64,
bool AllowStrictFP) {
1310 if (!shouldReplaceLibcallWithIntrinsic(CI, AllowMinSizeF32, AllowF64,
1313 replaceLibCallWithSimpleIntrinsic(
B, CI, IntrID);
1317std::tuple<Value *, Value *, Value *>
1321 Function *
F =
B.GetInsertBlock()->getParent();
1322 B.SetInsertPointPastAllocas(
F);
1326 if (
Instruction *ArgInst = dyn_cast<Instruction>(Arg)) {
1331 B.SetInsertPoint(ArgInst->getParent(), ++ArgInst->getIterator());
1334 B.SetCurrentDebugLocation(
DL);
1342 Value *CastAlloc =
B.CreateAddrSpaceCast(
Alloc, CosPtrTy);
1350 return {SinCos, LoadCos, SinCos};
1355 const FuncInfo &fInfo) {
1367 CallInst *CI = cast<CallInst>(FPOp);
1369 Function *
F =
B.GetInsertBlock()->getParent();
1375 SinCosLibFuncPrivate.getLeads()[0].PtrKind =
1379 SinCosLibFuncGeneric.getLeads()[0].PtrKind =
1382 FunctionCallee FSinCosPrivate = getFunction(M, SinCosLibFuncPrivate);
1383 FunctionCallee FSinCosGeneric = getFunction(M, SinCosLibFuncGeneric);
1384 FunctionCallee FSinCos = FSinCosPrivate ? FSinCosPrivate : FSinCosGeneric;
1393 const std::string PairName = PartnerInfo.mangle();
1397 const std::string SinCosPrivateName = SinCosLibFuncPrivate.mangle();
1398 const std::string SinCosGenericName = SinCosLibFuncGeneric.mangle();
1407 CallInst *XI = dyn_cast<CallInst>(U);
1415 bool Handled =
true;
1417 if (UCallee->
getName() == SinName)
1419 else if (UCallee->
getName() == CosName)
1421 else if (UCallee->
getName() == SinCosPrivateName ||
1422 UCallee->
getName() == SinCosGenericName)
1429 auto *OtherOp = cast<FPMathOperator>(XI);
1430 FMF &= OtherOp->getFastMathFlags();
1439 B.setFastMathFlags(FMF);
1440 B.setDefaultFPMathTag(FPMath);
1442 B.SetCurrentDebugLocation(DbgLoc);
1444 auto [Sin, Cos, SinCos] = insertSinCos(CArgVal, FMF,
B, FSinCos);
1448 C->replaceAllUsesWith(Res);
1453 replaceTrigInsts(SinCalls, Sin);
1454 replaceTrigInsts(CosCalls, Cos);
1455 replaceTrigInsts(SinCosCalls, SinCos);
1462bool AMDGPULibCalls::evaluateScalarMathFunc(
const FuncInfo &FInfo,
double &Res0,
1468 double opr0 = 0.0, opr1 = 0.0;
1469 ConstantFP *fpopr0 = dyn_cast_or_null<ConstantFP>(copr0);
1470 ConstantFP *fpopr1 = dyn_cast_or_null<ConstantFP>(copr1);
1483 switch (FInfo.getId()) {
1484 default :
return false;
1492 Res0 = log(opr0 + sqrt(opr0*opr0 - 1.0));
1505 Res0 = log(opr0 + sqrt(opr0*opr0 + 1.0));
1518 Res0 = (log(opr0 + 1.0) - log(opr0 - 1.0))/2.0;
1526 Res0 = (opr0 < 0.0) ? -pow(-opr0, 1.0/3.0) : pow(opr0, 1.0/3.0);
1546 Res0 = pow(2.0, opr0);
1550 Res0 = pow(10.0, opr0);
1558 Res0 = log(opr0) / log(2.0);
1562 Res0 = log(opr0) / log(10.0);
1566 Res0 = 1.0 / sqrt(opr0);
1596 Res0 = pow(opr0, opr1);
1600 if (
ConstantInt *iopr1 = dyn_cast_or_null<ConstantInt>(copr1)) {
1601 double val = (double)iopr1->getSExtValue();
1602 Res0 = pow(opr0, val);
1609 if (
ConstantInt *iopr1 = dyn_cast_or_null<ConstantInt>(copr1)) {
1610 double val = (double)iopr1->getSExtValue();
1611 Res0 = pow(opr0, 1.0 / val);
1627bool AMDGPULibCalls::evaluateCall(
CallInst *aCI,
const FuncInfo &FInfo) {
1628 int numArgs = (int)aCI->
arg_size();
1635 if ((copr0 = dyn_cast<Constant>(aCI->
getArgOperand(0))) ==
nullptr)
1640 if ((copr1 = dyn_cast<Constant>(aCI->
getArgOperand(1))) ==
nullptr) {
1649 double DVal0[16], DVal1[16];
1652 if (FuncVecSize == 1) {
1653 if (!evaluateScalarMathFunc(FInfo, DVal0[0], DVal1[0], copr0, copr1)) {
1659 for (
int i = 0; i < FuncVecSize; ++i) {
1662 if (!evaluateScalarMathFunc(FInfo, DVal0[i], DVal1[i], celt0, celt1)) {
1670 if (FuncVecSize == 1) {
1671 nval0 = ConstantFP::get(aCI->
getType(), DVal0[0]);
1673 nval1 = ConstantFP::get(aCI->
getType(), DVal1[0]);
1676 SmallVector <float, 0> FVal0, FVal1;
1677 for (
int i = 0; i < FuncVecSize; ++i)
1681 if (hasTwoResults) {
1682 for (
int i = 0; i < FuncVecSize; ++i)
1690 if (hasTwoResults) {
1697 if (hasTwoResults) {
1700 "math function with ptr arg not supported yet");
1714 bool Changed =
false;
1717 F.printAsOperand(
dbgs(),
false,
F.getParent());
dbgs() <<
'\n';);
1719 for (
auto &BB :
F) {
1726 if (Simplifier.
fold(CI))
1743 bool Changed =
false;
1744 for (
auto &BB :
F) {
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static bool isKnownIntegral(const Value *V, const DataLayout &DL, FastMathFlags FMF)
static const TableEntry tbl_log[]
static const TableEntry tbl_tgamma[]
static AMDGPULibFunc::EType getArgType(const AMDGPULibFunc &FInfo)
static const TableEntry tbl_expm1[]
static const TableEntry tbl_asinpi[]
static const TableEntry tbl_cos[]
static const TableEntry tbl_exp10[]
static CallInst * CreateCallEx(IRB &B, FunctionCallee Callee, Value *Arg, const Twine &Name="")
static CallInst * CreateCallEx2(IRB &B, FunctionCallee Callee, Value *Arg1, Value *Arg2, const Twine &Name="")
static const TableEntry tbl_rsqrt[]
static const TableEntry tbl_atanh[]
static const TableEntry tbl_cosh[]
static const TableEntry tbl_asin[]
static const TableEntry tbl_sinh[]
static const TableEntry tbl_acos[]
static const TableEntry tbl_tan[]
static const TableEntry tbl_cospi[]
static const TableEntry tbl_tanpi[]
static cl::opt< bool > EnablePreLink("amdgpu-prelink", cl::desc("Enable pre-link mode optimizations"), cl::init(false), cl::Hidden)
static bool HasNative(AMDGPULibFunc::EFuncId id)
ArrayRef< TableEntry > TableRef
static int getVecSize(const AMDGPULibFunc &FInfo)
static const TableEntry tbl_sin[]
static const TableEntry tbl_atan[]
static const TableEntry tbl_log2[]
static const TableEntry tbl_acospi[]
static const TableEntry tbl_sqrt[]
static const TableEntry tbl_asinh[]
static TableRef getOptTable(AMDGPULibFunc::EFuncId id)
static const TableEntry tbl_acosh[]
static const TableEntry tbl_exp[]
static const TableEntry tbl_cbrt[]
static const TableEntry tbl_sinpi[]
static const TableEntry tbl_atanpi[]
static FunctionType * getPownType(FunctionType *FT)
static const TableEntry tbl_erf[]
static const TableEntry tbl_log10[]
static const TableEntry tbl_erfc[]
static cl::list< std::string > UseNative("amdgpu-use-native", cl::desc("Comma separated list of functions to replace with native, or all"), cl::CommaSeparated, cl::ValueOptional, cl::Hidden)
static const TableEntry tbl_tanh[]
static const TableEntry tbl_exp2[]
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
#define DEBUG_WITH_TYPE(TYPE, X)
DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug information.
AMD GCN specific subclass of TargetSubtarget.
FunctionAnalysisManager FAM
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static void replaceCall(FPMathOperator *I, Value *With)
bool isUnsafeFiniteOnlyMath(const FPMathOperator *FPOp) const
bool canIncreasePrecisionOfConstantFold(const FPMathOperator *FPOp) const
static void replaceCall(Instruction *I, Value *With)
bool useNative(CallInst *CI)
void initFunction(Function &F, FunctionAnalysisManager &FAM)
bool isUnsafeMath(const FPMathOperator *FPOp) const
static unsigned getEPtrKindFromAddrSpace(unsigned AS)
Wrapper class for AMDGPULIbFuncImpl.
static bool parse(StringRef MangledName, AMDGPULibFunc &Ptr)
std::string getName() const
Get unmangled name for mangled library function and name for unmangled library function.
static FunctionCallee getOrInsertFunction(llvm::Module *M, const AMDGPULibFunc &fInfo)
void setPrefix(ENamePrefix PFX)
bool isCompatibleSignature(const FunctionType *FuncTy) const
Param * getLeads()
Get leading parameters for mangled lib functions.
ENamePrefix getPrefix() const
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 ...
float convertToFloat() const
Converts this APFloat to host float value.
Class for arbitrary precision integers.
int64_t getSExtValue() const
Get sign extended value.
an instruction to allocate memory on the stack
A container for analyses that lazily runs them and caches their results.
PassT::Result * getCachedResult(IRUnitT &IR) const
Get the cached result of an analysis pass for a given IR unit.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
bool empty() const
empty - Check if the array is empty.
A function analysis which provides an AssumptionCache.
A cache of @llvm.assume calls within a function.
InstListType::iterator iterator
Instruction iterators...
bool isNoBuiltin() const
Return true if the call should not be treated as a call to a builtin.
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
bool isStrictFP() const
Determine if the call requires strict floating point semantics.
bool isNoInline() const
Return true if the call should not be inlined.
Value * getArgOperand(unsigned i) const
void setArgOperand(unsigned i, Value *v)
FunctionType * getFunctionType() const
Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
unsigned arg_size() const
AttributeList getAttributes() const
Return the parameter attributes for this call.
void setCalledFunction(Function *Fn)
Sets the function called, including updating the function type.
This class represents a function call, abstracting a target machine's calling convention.
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
unsigned getNumElements() const
Return the number of elements in the array or vector.
Constant * getElementAsConstant(unsigned i) const
Return a Constant for a specified index's element.
APFloat getElementAsAPFloat(unsigned i) const
If this is a sequential container of floating point type, return the specified element as an APFloat.
A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
static Constant * getSplat(unsigned NumElts, Constant *Elt)
Return a ConstantVector with the specified constant in each element.
static Constant * get(LLVMContext &Context, ArrayRef< uint8_t > Elts)
get() constructors - Return a constant with vector type with an element count and element type matchi...
ConstantFP - Floating Point Values [float, double].
const APFloat & getValue() const
const APFloat & getValueAPF() const
bool isExactlyValue(const APFloat &V) const
We don't rely on operator== working on double values, as it returns true for things that are clearly ...
This is the shared class of boolean and integer constants.
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Align getAlignValue() const
Return the constant as an llvm::Align, interpreting 0 as Align(1).
This is an important base class in LLVM.
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
static DILocation * getMergedLocations(ArrayRef< DILocation * > Locs)
Try to combine the vector of locations passed as input in a single one.
A parsed version of the target data layout string in and methods for querying it.
Analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Utility class for floating point operations which can have information about relaxed accuracy require...
bool isFast() const
Test if this operation allows all non-strict floating-point transforms.
bool hasNoNaNs() const
Test if this operation's arguments and results are assumed not-NaN.
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags.
bool hasNoInfs() const
Test if this operation's arguments and results are assumed not-infinite.
bool hasApproxFunc() const
Test if this operation allows approximations of math library functions or intrinsics.
float getFPAccuracy() const
Get the maximum error permitted by this operation in ULPs.
Convenience struct for specifying and reasoning about fast-math flags.
void setAllowContract(bool B=true)
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
FunctionType * getFunctionType()
Class to represent function types.
Type * getParamType(unsigned i) const
Parameter type accessors.
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
bool hasMinSize() const
Optimize this function for minimum size (-Oz).
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
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.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
static MDNode * getMostGenericFPMath(MDNode *A, MDNode *B)
A Module instance is used to store all the information related to an LLVM module.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
An instruction for storing to memory.
StringRef - Represent a constant reference to a string, i.e.
Analysis pass providing the TargetLibraryInfo.
Provides information about what library functions are available for the current target.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type.
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
Type * getWithNewType(Type *EltTy) const
Given vector type, change the element type, whilst keeping the old number of elements.
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
static IntegerType * getInt32Ty(LLVMContext &C)
bool isIntegerTy() const
True if this is an instance of IntegerType.
TypeSize getPrimitiveSizeInBits() const LLVM_READONLY
Return the basic size of this type if it is a primitive type.
Type * getScalarType() const
If this is a vector type, return the element type, otherwise return 'this'.
void dropAllReferences()
Drop all references to operands.
Value * getOperand(unsigned i) const
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
iterator_range< user_iterator > users()
LLVMContext & getContext() const
All values hold a context through their type.
StringRef getName() const
Return a constant reference to the value's name.
void takeName(Value *V)
Transfer the name from V to this value.
Base class of all SIMD vector types.
const ParentTy * getParent() const
self_iterator getIterator()
@ FLAT_ADDRESS
Address space for flat memory.
@ PRIVATE_ADDRESS
Address space for private memory.
AttributeMask typeIncompatible(Type *Ty, AttributeSafetyKind ASK=ASK_ALL)
Which attributes cannot be applied to a type.
@ C
The default llvm calling convention, compatible with C.
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
bool match(Val *V, const Pattern &P)
apint_match m_APIntAllowPoison(const APInt *&Res)
Match APInt while allowing poison in splat vector constants.
apfloat_match m_APFloatAllowPoison(const APFloat *&Res)
Match APFloat while allowing poison in splat vector constants.
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
static double log2(double V)
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
bool isKnownNeverInfinity(const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if the floating-point scalar value is not an infinity or if the floating-point vector val...
bool isKnownNeverInfOrNaN(const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if the floating-point value can never contain a NaN or infinity.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
bool cannotBeOrderedLessThanZero(const Value *V, unsigned Depth, const SimplifyQuery &SQ)
Return true if we can prove that the specified FP value is either NaN or never less than -0....
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
This struct is a compact representation of a valid (non-zero power of two) alignment.