24#include "llvm/IR/IntrinsicsAMDGPU.h"
29#define DEBUG_TYPE "amdgpu-simplifylib"
35 cl::desc(
"Enable pre-link mode optimizations"),
40 cl::desc(
"Comma separated list of functions to replace with native, or all"),
44#define MATH_PI numbers::pi
45#define MATH_E numbers::e
46#define MATH_SQRT2 numbers::sqrt2
47#define MATH_SQRT1_2 numbers::inv_sqrt2
59 bool UnsafeFPMath =
false;
62 bool AllNative =
false;
86 bool evaluateScalarMathFunc(
const FuncInfo &FInfo,
double &Res0,
double &Res1,
92 std::tuple<Value *, Value *, Value *> insertSinCos(
Value *Arg,
109 bool shouldReplaceLibcallWithIntrinsic(
const CallInst *CI,
110 bool AllowMinSizeF32 =
false,
111 bool AllowF64 =
false,
112 bool AllowStrictFP =
false);
118 bool AllowMinSizeF32 =
false,
119 bool AllowF64 =
false,
120 bool AllowStrictFP =
false);
129 I->replaceAllUsesWith(With);
130 I->eraseFromParent();
151template <
typename IRB>
155 if (
Function *
F = dyn_cast<Function>(Callee.getCallee()))
156 R->setCallingConv(
F->getCallingConv());
160template <
typename IRB>
164 if (
Function *
F = dyn_cast<Function>(Callee.getCallee()))
165 R->setCallingConv(
F->getCallingConv());
171 if (
VectorType *VecTy = dyn_cast<VectorType>(FT->getReturnType()))
172 PowNExpTy = VectorType::get(PowNExpTy, VecTy->getElementCount());
174 return FunctionType::get(FT->getReturnType(),
175 {FT->getParamType(0), PowNExpTy},
false);
333 case AMDGPULibFunc::EI_DIVIDE:
334 case AMDGPULibFunc::EI_COS:
335 case AMDGPULibFunc::EI_EXP:
336 case AMDGPULibFunc::EI_EXP2:
337 case AMDGPULibFunc::EI_EXP10:
338 case AMDGPULibFunc::EI_LOG:
339 case AMDGPULibFunc::EI_LOG2:
340 case AMDGPULibFunc::EI_LOG10:
341 case AMDGPULibFunc::EI_POWR:
342 case AMDGPULibFunc::EI_RECIP:
343 case AMDGPULibFunc::EI_RSQRT:
344 case AMDGPULibFunc::EI_SIN:
345 case AMDGPULibFunc::EI_SINCOS:
346 case AMDGPULibFunc::EI_SQRT:
347 case AMDGPULibFunc::EI_TAN:
368 case AMDGPULibFunc::EI_NCOS:
375 case AMDGPULibFunc::EI_NEXP2:
380 case AMDGPULibFunc::EI_NLOG2:
383 case AMDGPULibFunc::EI_NRSQRT:
385 case AMDGPULibFunc::EI_NSIN:
389 case AMDGPULibFunc::EI_NSQRT:
416bool AMDGPULibCalls::parseFunctionName(
const StringRef &FMangledName,
422 return UnsafeFPMath || FPOp->
isFast();
426 return UnsafeFPMath ||
437 UnsafeFPMath =
F.getFnAttribute(
"unsafe-fp-math").getValueAsBool();
443bool AMDGPULibCalls::useNativeFunc(
const StringRef F)
const {
448 AllNative = useNativeFunc(
"all") ||
453bool AMDGPULibCalls::sincosUseNative(
CallInst *aCI,
const FuncInfo &FInfo) {
454 bool native_sin = useNativeFunc(
"sin");
455 bool native_cos = useNativeFunc(
"cos");
457 if (native_sin && native_cos) {
472 if (sinExpr && cosExpr) {
478 <<
" with native version of sin/cos");
493 if (!parseFunctionName(Callee->getName(), FInfo) || !FInfo.
isMangled() ||
496 !(AllNative || useNativeFunc(FInfo.
getName()))) {
501 return sincosUseNative(aCI, FInfo);
510 <<
" with native version");
522 const FuncInfo &FInfo) {
524 if (!Callee->isDeclaration())
527 assert(Callee->hasName() &&
"Invalid read_pipe/write_pipe function");
528 auto *M = Callee->getParent();
529 std::string
Name = std::string(Callee->getName());
531 if (NumArg != 4 && NumArg != 6)
537 if (!PacketSize || !PacketAlign)
542 if (Alignment !=
Size)
545 unsigned PtrArgLoc = CI->
arg_size() - 3;
550 for (
unsigned I = 0;
I != PtrArgLoc; ++
I)
563 for (
unsigned I = 0;
I != PtrArgLoc; ++
I)
565 Args.push_back(PtrArg);
567 auto *NCI =
B.CreateCall(
F, Args);
578 if (isa<UndefValue>(V))
581 if (
const ConstantFP *CF = dyn_cast<ConstantFP>(V))
582 return CF->getValueAPF().isInteger();
585 for (
unsigned i = 0, e = CDV->getNumElements(); i != e; ++i) {
586 Constant *ConstElt = CDV->getElementAsConstant(i);
587 if (isa<UndefValue>(ConstElt))
589 const ConstantFP *CFP = dyn_cast<ConstantFP>(ConstElt);
601 switch (
I->getOpcode()) {
602 case Instruction::SIToFP:
603 case Instruction::UIToFP:
611 case Instruction::Call: {
614 case Intrinsic::trunc:
615 case Intrinsic::floor:
616 case Intrinsic::ceil:
617 case Intrinsic::rint:
618 case Intrinsic::nearbyint:
619 case Intrinsic::round:
620 case Intrinsic::roundeven:
640 if (!Callee || Callee->isIntrinsic() || CI->
isNoBuiltin())
644 if (!parseFunctionName(Callee->getName(), FInfo))
654 if (TDOFold(CI, FInfo))
668 B.setFastMathFlags(FMF);
673 switch (FInfo.
getId()) {
677 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::exp,
682 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::exp2,
687 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::log,
692 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::log2,
697 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::log10,
700 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::minnum,
703 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::maxnum,
706 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::fma,
true,
709 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::fmuladd,
712 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::fabs,
true,
715 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::copysign,
718 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::floor,
true,
721 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::ceil,
true,
724 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::trunc,
true,
727 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::rint,
true,
730 return tryReplaceLibcallWithSimpleIntrinsic(
B, CI, Intrinsic::round,
true,
733 if (!shouldReplaceLibcallWithIntrinsic(CI,
true,
true))
738 VecTy && !isa<VectorType>(Arg1->
getType())) {
739 Value *SplatArg1 =
B.CreateVectorSplat(VecTy->getElementCount(), Arg1);
745 {CI->getType(), CI->getArgOperand(1)->getType()}));
749 Module *M = Callee->getParent();
752 CallInst *Call = cast<CallInst>(FPOp);
758 FPOp->getOperand(0), 0,
760 Call->setCalledFunction(PowrFunc);
761 return fold_pow(FPOp,
B, PowrInfo) ||
true;
766 FPOp->getFastMathFlags())) {
775 B.CreateFPToSI(FPOp->getOperand(1), PownType->
getParamType(1));
777 Call->removeParamAttrs(
779 Call->setCalledFunction(PownFunc);
780 Call->setArgOperand(1, CastedArg);
781 return fold_pow(FPOp,
B, PownInfo) ||
true;
785 return fold_pow(FPOp,
B, FInfo);
789 return fold_pow(FPOp,
B, FInfo);
791 return fold_rootn(FPOp,
B, FInfo);
794 return tryReplaceLibcallWithSimpleIntrinsic(
795 B, CI, Intrinsic::sqrt,
true,
true,
false);
798 return fold_sincos(FPOp,
B, FInfo);
804 switch (FInfo.
getId()) {
809 return fold_read_write_pipe(CI,
B, FInfo);
818bool AMDGPULibCalls::TDOFold(
CallInst *CI,
const FuncInfo &FInfo) {
824 int const sz = (int)tr.
size();
830 for (
int eltNo = 0; eltNo <
getVecSize(FInfo); ++eltNo) {
832 CV->getElementAsConstant((
unsigned)eltNo));
833 assert(eltval &&
"Non-FP arguments in math function!");
835 for (
int i=0; i < sz; ++i) {
851 for (
unsigned i = 0; i < DVal.
size(); ++i) {
860 LLVM_DEBUG(
errs() <<
"AMDIC: " << *CI <<
" ---> " << *nval <<
"\n");
866 if (
ConstantFP *CF = dyn_cast<ConstantFP>(opr0)) {
867 for (
int i = 0; i < sz; ++i) {
868 if (CF->isExactlyValue(tr[i].input)) {
869 Value *nval = ConstantFP::get(CF->getType(), tr[i].result);
870 LLVM_DEBUG(
errs() <<
"AMDIC: " << *CI <<
" ---> " << *nval <<
"\n");
883#if _XOPEN_SOURCE >= 600 || defined(_ISOC99_SOURCE) || _POSIX_C_SOURCE >= 200112L
892 const FuncInfo &FInfo) {
896 "fold_pow: encounter a wrong function call");
898 Module *
M =
B.GetInsertBlock()->getModule();
904 const APInt *CINT =
nullptr;
909 int ci_opr1 = (CINT ? (int)CINT->
getSExtValue() : 0x1111111);
911 if ((CF && CF->
isZero()) || (CINT && ci_opr1 == 0)) {
914 Constant *cnval = ConstantFP::get(eltType, 1.0);
923 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> " << *opr0 <<
"\n");
929 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> " << *opr0 <<
" * "
931 Value *nval =
B.CreateFMul(opr0, opr0,
"__pow2");
935 if ((CF && CF->
isExactlyValue(-1.0)) || (CINT && ci_opr1 == -1)) {
937 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> 1 / " << *opr0 <<
"\n");
938 Constant *cnval = ConstantFP::get(eltType, 1.0);
942 Value *nval =
B.CreateFDiv(cnval, opr0,
"__powrecip");
954 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> " << FInfo.getName()
955 <<
'(' << *opr0 <<
")\n");
973 int ival = (int)dval;
974 if ((
double)ival == dval) {
977 ci_opr1 = 0x11111111;
982 unsigned abs_opr1 = (ci_opr1 < 0) ? -ci_opr1 : ci_opr1;
983 if (abs_opr1 <= 12) {
987 cnval = ConstantFP::get(eltType, 1.0);
993 Value *valx2 =
nullptr;
995 while (abs_opr1 > 0) {
996 valx2 = valx2 ?
B.CreateFMul(valx2, valx2,
"__powx2") : opr0;
998 nval = nval ?
B.CreateFMul(nval, valx2,
"__powprod") : valx2;
1005 cnval = ConstantFP::get(eltType, 1.0);
1009 nval =
B.CreateFDiv(cnval, nval,
"__1powprod");
1012 << ((ci_opr1 < 0) ?
"1/prod(" :
"prod(") << *opr0
1024 if (ShouldUseIntrinsic)
1032 bool needlog =
false;
1033 bool needabs =
false;
1034 bool needcopysign =
false;
1045 V =
log2(std::abs(V));
1046 cnval = ConstantFP::get(eltType, V);
1061 "Wrong vector size detected");
1066 if (V < 0.0) needcopysign =
true;
1067 V =
log2(std::abs(V));
1072 for (
unsigned i=0; i < DVal.
size(); ++i) {
1093 nval =
B.CreateUnaryIntrinsic(Intrinsic::fabs, opr0,
nullptr,
"__fabs");
1095 nval = cnval ? cnval : opr0;
1099 if (ShouldUseIntrinsic) {
1113 opr1 =
B.CreateSIToFP(opr1, nval->
getType(),
"pownI2F");
1115 nval =
B.CreateFMul(opr1, nval,
"__ylogx");
1123 if (
const auto *vTy = dyn_cast<FixedVectorType>(rTy))
1128 opr_n =
B.CreateZExtOrTrunc(opr_n, nTy,
"__ytou");
1130 opr_n =
B.CreateFPToSI(opr1, nTy,
"__ytou");
1132 Value *sign =
B.CreateShl(opr_n, size-1,
"__yeven");
1133 sign =
B.CreateAnd(
B.CreateBitCast(opr0, nTy), sign,
"__pow_sign");
1134 nval =
B.CreateOr(
B.CreateBitCast(nval, nTy), sign);
1135 nval =
B.CreateBitCast(nval, opr0->
getType());
1139 <<
"exp2(" << *opr1 <<
" * log2(" << *opr0 <<
"))\n");
1146 const FuncInfo &FInfo) {
1160 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> " << *opr0 <<
"\n");
1165 Module *
M =
B.GetInsertBlock()->getModule();
1169 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> sqrt(" << *opr0
1175 }
else if (ci_opr1 == 3) {
1178 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> cbrt(" << *opr0
1184 }
else if (ci_opr1 == -1) {
1185 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> 1.0 / " << *opr0 <<
"\n");
1186 Value *nval =
B.CreateFDiv(ConstantFP::get(opr0->
getType(), 1.0),
1191 }
else if (ci_opr1 == -2) {
1194 LLVM_DEBUG(
errs() <<
"AMDIC: " << *FPOp <<
" ---> rsqrt(" << *opr0
1206 const FuncInfo &FInfo) {
1209 FuncInfo nf = FInfo;
1211 return getFunction(M, nf);
1217bool AMDGPULibCalls::shouldReplaceLibcallWithIntrinsic(
const CallInst *CI,
1218 bool AllowMinSizeF32,
1220 bool AllowStrictFP) {
1235 if (!AllowStrictFP && ParentF->
hasFnAttribute(Attribute::StrictFP))
1238 if (IsF32 && !AllowMinSizeF32 && ParentF->
hasMinSize())
1243void AMDGPULibCalls::replaceLibCallWithSimpleIntrinsic(
IRBuilder<> &
B,
1251 if (Arg0VecTy && !Arg1VecTy) {
1252 Value *SplatRHS =
B.CreateVectorSplat(Arg0VecTy->getElementCount(), Arg1);
1254 }
else if (!Arg0VecTy && Arg1VecTy) {
1255 Value *SplatLHS =
B.CreateVectorSplat(Arg1VecTy->getElementCount(), Arg0);
1264bool AMDGPULibCalls::tryReplaceLibcallWithSimpleIntrinsic(
1266 bool AllowF64,
bool AllowStrictFP) {
1267 if (!shouldReplaceLibcallWithIntrinsic(CI, AllowMinSizeF32, AllowF64,
1270 replaceLibCallWithSimpleIntrinsic(
B, CI, IntrID);
1274std::tuple<Value *, Value *, Value *>
1278 Function *
F =
B.GetInsertBlock()->getParent();
1279 B.SetInsertPointPastAllocas(
F);
1283 if (
Instruction *ArgInst = dyn_cast<Instruction>(Arg)) {
1288 B.SetInsertPoint(ArgInst->getParent(), ++ArgInst->getIterator());
1291 B.SetCurrentDebugLocation(
DL);
1299 Value *CastAlloc =
B.CreateAddrSpaceCast(
Alloc, CosPtrTy);
1307 return {SinCos, LoadCos, SinCos};
1312 const FuncInfo &fInfo) {
1324 CallInst *CI = cast<CallInst>(FPOp);
1326 Function *
F =
B.GetInsertBlock()->getParent();
1332 SinCosLibFuncPrivate.getLeads()[0].PtrKind =
1336 SinCosLibFuncGeneric.getLeads()[0].PtrKind =
1339 FunctionCallee FSinCosPrivate = getFunction(M, SinCosLibFuncPrivate);
1340 FunctionCallee FSinCosGeneric = getFunction(M, SinCosLibFuncGeneric);
1341 FunctionCallee FSinCos = FSinCosPrivate ? FSinCosPrivate : FSinCosGeneric;
1350 const std::string PairName = PartnerInfo.mangle();
1354 const std::string SinCosPrivateName = SinCosLibFuncPrivate.mangle();
1355 const std::string SinCosGenericName = SinCosLibFuncGeneric.mangle();
1364 CallInst *XI = dyn_cast<CallInst>(U);
1372 bool Handled =
true;
1374 if (UCallee->
getName() == SinName)
1376 else if (UCallee->
getName() == CosName)
1378 else if (UCallee->
getName() == SinCosPrivateName ||
1379 UCallee->
getName() == SinCosGenericName)
1386 auto *OtherOp = cast<FPMathOperator>(XI);
1387 FMF &= OtherOp->getFastMathFlags();
1396 B.setFastMathFlags(FMF);
1397 B.setDefaultFPMathTag(FPMath);
1399 B.SetCurrentDebugLocation(DbgLoc);
1401 auto [Sin, Cos, SinCos] = insertSinCos(CArgVal, FMF,
B, FSinCos);
1405 C->replaceAllUsesWith(Res);
1410 replaceTrigInsts(SinCalls, Sin);
1411 replaceTrigInsts(CosCalls, Cos);
1412 replaceTrigInsts(SinCosCalls, SinCos);
1419bool AMDGPULibCalls::evaluateScalarMathFunc(
const FuncInfo &FInfo,
double &Res0,
1425 double opr0 = 0.0, opr1 = 0.0;
1426 ConstantFP *fpopr0 = dyn_cast_or_null<ConstantFP>(copr0);
1427 ConstantFP *fpopr1 = dyn_cast_or_null<ConstantFP>(copr1);
1440 switch (FInfo.getId()) {
1441 default :
return false;
1449 Res0 = log(opr0 + sqrt(opr0*opr0 - 1.0));
1462 Res0 = log(opr0 + sqrt(opr0*opr0 + 1.0));
1475 Res0 = (log(opr0 + 1.0) - log(opr0 - 1.0))/2.0;
1483 Res0 = (opr0 < 0.0) ? -pow(-opr0, 1.0/3.0) : pow(opr0, 1.0/3.0);
1503 Res0 = pow(2.0, opr0);
1507 Res0 = pow(10.0, opr0);
1515 Res0 = log(opr0) / log(2.0);
1519 Res0 = log(opr0) / log(10.0);
1523 Res0 = 1.0 / sqrt(opr0);
1553 Res0 = pow(opr0, opr1);
1557 if (
ConstantInt *iopr1 = dyn_cast_or_null<ConstantInt>(copr1)) {
1558 double val = (double)iopr1->getSExtValue();
1559 Res0 = pow(opr0, val);
1566 if (
ConstantInt *iopr1 = dyn_cast_or_null<ConstantInt>(copr1)) {
1567 double val = (double)iopr1->getSExtValue();
1568 Res0 = pow(opr0, 1.0 / val);
1584bool AMDGPULibCalls::evaluateCall(
CallInst *aCI,
const FuncInfo &FInfo) {
1585 int numArgs = (int)aCI->
arg_size();
1592 if ((copr0 = dyn_cast<Constant>(aCI->
getArgOperand(0))) ==
nullptr)
1597 if ((copr1 = dyn_cast<Constant>(aCI->
getArgOperand(1))) ==
nullptr) {
1606 double DVal0[16], DVal1[16];
1609 if (FuncVecSize == 1) {
1610 if (!evaluateScalarMathFunc(FInfo, DVal0[0], DVal1[0], copr0, copr1)) {
1616 for (
int i = 0; i < FuncVecSize; ++i) {
1619 if (!evaluateScalarMathFunc(FInfo, DVal0[i], DVal1[i], celt0, celt1)) {
1627 if (FuncVecSize == 1) {
1628 nval0 = ConstantFP::get(aCI->
getType(), DVal0[0]);
1630 nval1 = ConstantFP::get(aCI->
getType(), DVal1[0]);
1633 SmallVector <float, 0> FVal0, FVal1;
1634 for (
int i = 0; i < FuncVecSize; ++i)
1638 if (hasTwoResults) {
1639 for (
int i = 0; i < FuncVecSize; ++i)
1647 if (hasTwoResults) {
1654 if (hasTwoResults) {
1657 "math function with ptr arg not supported yet");
1671 bool Changed =
false;
1674 F.printAsOperand(
dbgs(),
false,
F.getParent());
dbgs() <<
'\n';);
1676 for (
auto &BB :
F) {
1683 if (Simplifier.
fold(CI))
1700 bool Changed =
false;
1701 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")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-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.
const Function * getParent() const
Return the enclosing method, or null if none.
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 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, BasicBlock::iterator InsertBefore)
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.
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...
Align getAlignValue() const
Return the constant as an llvm::Align, interpreting 0 as Align(1).
This is an important base class in LLVM.
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.
Convenience struct for specifying and reasoning about fast-math flags.
static FixedVectorType * get(Type *ElementType, unsigned NumElts)
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).
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
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...
const BasicBlock * getParent() const
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.
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.
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.
Base class of all SIMD vector types.
@ 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.
apfloat_match m_APFloatAllowUndef(const APFloat *&Res)
Match APFloat while allowing undefs in splat vector constants.
apint_match m_APIntAllowUndef(const APInt *&Res)
Match APInt while allowing undefs in splat vector constants.
bool match(Val *V, const Pattern &P)
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.