forked from OSchip/llvm-project
[ConstantFolding] Refactor function match for better speed (NFC)
Use an `enum` instead of string comparison to match the candidate function. llvm-svn: 371228
This commit is contained in:
Evandro Menezes
parent
121d9114f5
commit
6f1369755d
|
|
@ -1464,40 +1464,45 @@ bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
|
|||
|
||||
if (!F->hasName())
|
||||
return false;
|
||||
StringRef Name = F->getName();
|
||||
|
||||
// In these cases, the check of the length is required. We don't want to
|
||||
// return true for a name like "cos\0blah" which strcmp would return equal to
|
||||
// "cos", but has length 8.
|
||||
StringRef Name = F->getName();
|
||||
switch (Name[0]) {
|
||||
default:
|
||||
return false;
|
||||
case 'a':
|
||||
return Name == "acos" || Name == "asin" || Name == "atan" ||
|
||||
Name == "atan2" || Name == "acosf" || Name == "asinf" ||
|
||||
Name == "atanf" || Name == "atan2f";
|
||||
return Name == "acos" || Name == "acosf" ||
|
||||
Name == "asin" || Name == "asinf" ||
|
||||
Name == "atan" || Name == "atanf" ||
|
||||
Name == "atan2" || Name == "atan2f";
|
||||
case 'c':
|
||||
return Name == "ceil" || Name == "cos" || Name == "cosh" ||
|
||||
Name == "ceilf" || Name == "cosf" || Name == "coshf";
|
||||
return Name == "ceil" || Name == "ceilf" ||
|
||||
Name == "cos" || Name == "cosf" ||
|
||||
Name == "cosh" || Name == "coshf";
|
||||
case 'e':
|
||||
return Name == "exp" || Name == "exp2" || Name == "expf" || Name == "exp2f";
|
||||
return Name == "exp" || Name == "expf" ||
|
||||
Name == "exp2" || Name == "exp2f";
|
||||
case 'f':
|
||||
return Name == "fabs" || Name == "floor" || Name == "fmod" ||
|
||||
Name == "fabsf" || Name == "floorf" || Name == "fmodf";
|
||||
return Name == "fabs" || Name == "fabsf" ||
|
||||
Name == "floor" || Name == "floorf" ||
|
||||
Name == "fmod" || Name == "fmodf";
|
||||
case 'l':
|
||||
return Name == "log" || Name == "log10" || Name == "logf" ||
|
||||
Name == "log10f";
|
||||
return Name == "log" || Name == "logf" ||
|
||||
Name == "log10" || Name == "log10f";
|
||||
case 'p':
|
||||
return Name == "pow" || Name == "powf";
|
||||
case 'r':
|
||||
return Name == "round" || Name == "roundf";
|
||||
case 's':
|
||||
return Name == "sin" || Name == "sinh" || Name == "sqrt" ||
|
||||
Name == "sinf" || Name == "sinhf" || Name == "sqrtf";
|
||||
return Name == "sin" || Name == "sinf" ||
|
||||
Name == "sinh" || Name == "sinhf" ||
|
||||
Name == "sqrt" || Name == "sqrtf";
|
||||
case 't':
|
||||
return Name == "tan" || Name == "tanh" || Name == "tanf" || Name == "tanhf";
|
||||
return Name == "tan" || Name == "tanf" ||
|
||||
Name == "tanh" || Name == "tanhf";
|
||||
case '_':
|
||||
|
||||
// Check for various function names that get used for the math functions
|
||||
// when the header files are preprocessed with the macro
|
||||
// __FINITE_MATH_ONLY__ enabled.
|
||||
|
|
@ -1765,10 +1770,10 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
|
|||
default: break;
|
||||
case Intrinsic::fabs:
|
||||
return ConstantFoldFP(fabs, V, Ty);
|
||||
case Intrinsic::log2:
|
||||
return ConstantFoldFP(Log2, V, Ty);
|
||||
case Intrinsic::log:
|
||||
return ConstantFoldFP(log, V, Ty);
|
||||
case Intrinsic::log2:
|
||||
return ConstantFoldFP(Log2, V, Ty);
|
||||
case Intrinsic::log10:
|
||||
return ConstantFoldFP(log10, V, Ty);
|
||||
case Intrinsic::exp:
|
||||
|
|
@ -1786,104 +1791,118 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
|
|||
if (!TLI)
|
||||
return nullptr;
|
||||
|
||||
char NameKeyChar = Name[0];
|
||||
if (Name[0] == '_' && Name.size() > 2 && Name[1] == '_')
|
||||
NameKeyChar = Name[2];
|
||||
LibFunc Func = NotLibFunc;
|
||||
TLI->getLibFunc(Name, Func);
|
||||
|
||||
switch (NameKeyChar) {
|
||||
case 'a':
|
||||
if ((Name == "acos" && TLI->has(LibFunc_acos)) ||
|
||||
(Name == "acosf" && TLI->has(LibFunc_acosf)) ||
|
||||
(Name == "__acos_finite" && TLI->has(LibFunc_acos_finite)) ||
|
||||
(Name == "__acosf_finite" && TLI->has(LibFunc_acosf_finite)))
|
||||
switch (Func) {
|
||||
default:
|
||||
break;
|
||||
case LibFunc_acos:
|
||||
case LibFunc_acosf:
|
||||
case LibFunc_acos_finite:
|
||||
case LibFunc_acosf_finite:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(acos, V, Ty);
|
||||
else if ((Name == "asin" && TLI->has(LibFunc_asin)) ||
|
||||
(Name == "asinf" && TLI->has(LibFunc_asinf)) ||
|
||||
(Name == "__asin_finite" && TLI->has(LibFunc_asin_finite)) ||
|
||||
(Name == "__asinf_finite" && TLI->has(LibFunc_asinf_finite)))
|
||||
break;
|
||||
case LibFunc_asin:
|
||||
case LibFunc_asinf:
|
||||
case LibFunc_asin_finite:
|
||||
case LibFunc_asinf_finite:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(asin, V, Ty);
|
||||
else if ((Name == "atan" && TLI->has(LibFunc_atan)) ||
|
||||
(Name == "atanf" && TLI->has(LibFunc_atanf)))
|
||||
break;
|
||||
case LibFunc_atan:
|
||||
case LibFunc_atanf:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(atan, V, Ty);
|
||||
break;
|
||||
case 'c':
|
||||
if ((Name == "ceil" && TLI->has(LibFunc_ceil)) ||
|
||||
(Name == "ceilf" && TLI->has(LibFunc_ceilf)))
|
||||
case LibFunc_ceil:
|
||||
case LibFunc_ceilf:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(ceil, V, Ty);
|
||||
else if ((Name == "cos" && TLI->has(LibFunc_cos)) ||
|
||||
(Name == "cosf" && TLI->has(LibFunc_cosf)))
|
||||
break;
|
||||
case LibFunc_cos:
|
||||
case LibFunc_cosf:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(cos, V, Ty);
|
||||
else if ((Name == "cosh" && TLI->has(LibFunc_cosh)) ||
|
||||
(Name == "coshf" && TLI->has(LibFunc_coshf)) ||
|
||||
(Name == "__cosh_finite" && TLI->has(LibFunc_cosh_finite)) ||
|
||||
(Name == "__coshf_finite" && TLI->has(LibFunc_coshf_finite)))
|
||||
break;
|
||||
case LibFunc_cosh:
|
||||
case LibFunc_coshf:
|
||||
case LibFunc_cosh_finite:
|
||||
case LibFunc_coshf_finite:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(cosh, V, Ty);
|
||||
break;
|
||||
case 'e':
|
||||
if ((Name == "exp" && TLI->has(LibFunc_exp)) ||
|
||||
(Name == "expf" && TLI->has(LibFunc_expf)) ||
|
||||
(Name == "__exp_finite" && TLI->has(LibFunc_exp_finite)) ||
|
||||
(Name == "__expf_finite" && TLI->has(LibFunc_expf_finite)))
|
||||
case LibFunc_exp:
|
||||
case LibFunc_expf:
|
||||
case LibFunc_exp_finite:
|
||||
case LibFunc_expf_finite:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(exp, V, Ty);
|
||||
if ((Name == "exp2" && TLI->has(LibFunc_exp2)) ||
|
||||
(Name == "exp2f" && TLI->has(LibFunc_exp2f)) ||
|
||||
(Name == "__exp2_finite" && TLI->has(LibFunc_exp2_finite)) ||
|
||||
(Name == "__exp2f_finite" && TLI->has(LibFunc_exp2f_finite)))
|
||||
// Constant fold exp2(x) as pow(2,x) in case the host doesn't have a
|
||||
// C99 library.
|
||||
break;
|
||||
case LibFunc_exp2:
|
||||
case LibFunc_exp2f:
|
||||
case LibFunc_exp2_finite:
|
||||
case LibFunc_exp2f_finite:
|
||||
if (TLI->has(Func))
|
||||
// Fold exp2(x) as pow(2, x), in case the host lacks a C99 library.
|
||||
return ConstantFoldBinaryFP(pow, 2.0, V, Ty);
|
||||
break;
|
||||
case 'f':
|
||||
if ((Name == "fabs" && TLI->has(LibFunc_fabs)) ||
|
||||
(Name == "fabsf" && TLI->has(LibFunc_fabsf)))
|
||||
case LibFunc_fabs:
|
||||
case LibFunc_fabsf:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(fabs, V, Ty);
|
||||
else if ((Name == "floor" && TLI->has(LibFunc_floor)) ||
|
||||
(Name == "floorf" && TLI->has(LibFunc_floorf)))
|
||||
break;
|
||||
case LibFunc_floor:
|
||||
case LibFunc_floorf:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(floor, V, Ty);
|
||||
break;
|
||||
case 'l':
|
||||
if ((Name == "log" && V > 0 && TLI->has(LibFunc_log)) ||
|
||||
(Name == "logf" && V > 0 && TLI->has(LibFunc_logf)) ||
|
||||
(Name == "__log_finite" && V > 0 &&
|
||||
TLI->has(LibFunc_log_finite)) ||
|
||||
(Name == "__logf_finite" && V > 0 &&
|
||||
TLI->has(LibFunc_logf_finite)))
|
||||
case LibFunc_log:
|
||||
case LibFunc_logf:
|
||||
case LibFunc_log_finite:
|
||||
case LibFunc_logf_finite:
|
||||
if (V > 0.0 && TLI->has(Func))
|
||||
return ConstantFoldFP(log, V, Ty);
|
||||
else if ((Name == "log10" && V > 0 && TLI->has(LibFunc_log10)) ||
|
||||
(Name == "log10f" && V > 0 && TLI->has(LibFunc_log10f)) ||
|
||||
(Name == "__log10_finite" && V > 0 &&
|
||||
TLI->has(LibFunc_log10_finite)) ||
|
||||
(Name == "__log10f_finite" && V > 0 &&
|
||||
TLI->has(LibFunc_log10f_finite)))
|
||||
break;
|
||||
case LibFunc_log10:
|
||||
case LibFunc_log10f:
|
||||
case LibFunc_log10_finite:
|
||||
case LibFunc_log10f_finite:
|
||||
if (V > 0.0 && TLI->has(Func))
|
||||
return ConstantFoldFP(log10, V, Ty);
|
||||
break;
|
||||
case 'r':
|
||||
if ((Name == "round" && TLI->has(LibFunc_round)) ||
|
||||
(Name == "roundf" && TLI->has(LibFunc_roundf)))
|
||||
case LibFunc_round:
|
||||
case LibFunc_roundf:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(round, V, Ty);
|
||||
break;
|
||||
case 's':
|
||||
if ((Name == "sin" && TLI->has(LibFunc_sin)) ||
|
||||
(Name == "sinf" && TLI->has(LibFunc_sinf)))
|
||||
case LibFunc_sin:
|
||||
case LibFunc_sinf:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(sin, V, Ty);
|
||||
else if ((Name == "sinh" && TLI->has(LibFunc_sinh)) ||
|
||||
(Name == "sinhf" && TLI->has(LibFunc_sinhf)) ||
|
||||
(Name == "__sinh_finite" && TLI->has(LibFunc_sinh_finite)) ||
|
||||
(Name == "__sinhf_finite" && TLI->has(LibFunc_sinhf_finite)))
|
||||
break;
|
||||
case LibFunc_sinh:
|
||||
case LibFunc_sinhf:
|
||||
case LibFunc_sinh_finite:
|
||||
case LibFunc_sinhf_finite:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(sinh, V, Ty);
|
||||
else if ((Name == "sqrt" && V >= 0 && TLI->has(LibFunc_sqrt)) ||
|
||||
(Name == "sqrtf" && V >= 0 && TLI->has(LibFunc_sqrtf)))
|
||||
break;
|
||||
case LibFunc_sqrt:
|
||||
case LibFunc_sqrtf:
|
||||
if (V >= 0.0 && TLI->has(Func))
|
||||
return ConstantFoldFP(sqrt, V, Ty);
|
||||
break;
|
||||
case 't':
|
||||
if ((Name == "tan" && TLI->has(LibFunc_tan)) ||
|
||||
(Name == "tanf" && TLI->has(LibFunc_tanf)))
|
||||
case LibFunc_tan:
|
||||
case LibFunc_tanf:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(tan, V, Ty);
|
||||
else if ((Name == "tanh" && TLI->has(LibFunc_tanh)) ||
|
||||
(Name == "tanhf" && TLI->has(LibFunc_tanhf)))
|
||||
return ConstantFoldFP(tanh, V, Ty);
|
||||
break;
|
||||
default:
|
||||
case LibFunc_tanh:
|
||||
case LibFunc_tanhf:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldFP(tanh, V, Ty);
|
||||
break;
|
||||
}
|
||||
return nullptr;
|
||||
|
|
@ -2002,19 +2021,32 @@ static Constant *ConstantFoldScalarCall2(StringRef Name,
|
|||
|
||||
if (!TLI)
|
||||
return nullptr;
|
||||
if ((Name == "pow" && TLI->has(LibFunc_pow)) ||
|
||||
(Name == "powf" && TLI->has(LibFunc_powf)) ||
|
||||
(Name == "__pow_finite" && TLI->has(LibFunc_pow_finite)) ||
|
||||
(Name == "__powf_finite" && TLI->has(LibFunc_powf_finite)))
|
||||
return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
|
||||
if ((Name == "fmod" && TLI->has(LibFunc_fmod)) ||
|
||||
(Name == "fmodf" && TLI->has(LibFunc_fmodf)))
|
||||
return ConstantFoldBinaryFP(fmod, Op1V, Op2V, Ty);
|
||||
if ((Name == "atan2" && TLI->has(LibFunc_atan2)) ||
|
||||
(Name == "atan2f" && TLI->has(LibFunc_atan2f)) ||
|
||||
(Name == "__atan2_finite" && TLI->has(LibFunc_atan2_finite)) ||
|
||||
(Name == "__atan2f_finite" && TLI->has(LibFunc_atan2f_finite)))
|
||||
return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty);
|
||||
|
||||
LibFunc Func = NotLibFunc;
|
||||
TLI->getLibFunc(Name, Func);
|
||||
switch (Func) {
|
||||
default:
|
||||
break;
|
||||
case LibFunc_pow:
|
||||
case LibFunc_powf:
|
||||
case LibFunc_pow_finite:
|
||||
case LibFunc_powf_finite:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty);
|
||||
break;
|
||||
case LibFunc_fmod:
|
||||
case LibFunc_fmodf:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldBinaryFP(fmod, Op1V, Op2V, Ty);
|
||||
break;
|
||||
case LibFunc_atan2:
|
||||
case LibFunc_atan2f:
|
||||
case LibFunc_atan2_finite:
|
||||
case LibFunc_atan2f_finite:
|
||||
if (TLI->has(Func))
|
||||
return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty);
|
||||
break;
|
||||
}
|
||||
} else if (auto *Op2C = dyn_cast<ConstantInt>(Operands[1])) {
|
||||
if (IntrinsicID == Intrinsic::powi && Ty->isHalfTy())
|
||||
return ConstantFP::get(Ty->getContext(),
|
||||
|
|
|
|||
Loading…
Reference in New Issue