[IRBuilder] Refactor FMF interface #121657
Merged
+231
−282
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
nikic
reviewed
Jan 4, 2025
llvm/lib/IR/IRBuilder.cpp
Outdated
| const Twine &Name) { | ||
| Module *M = BB->getModule(); | ||
| Function *Fn = Intrinsic::getOrInsertDeclaration(M, ID, {LHS->getType()}); | ||
| if (Value *V = Folder.FoldBinaryIntrinsic(ID, LHS, RHS, Fn->getReturnType(), | ||
| FMFSource)) | ||
| FMFSource.Source)) |
There was a problem hiding this comment.
It looks like this is the only direct usage of Source. Can we change FoldBinaryIntrinsic to accept FMF instead? simplifyBinaryIntrinsic only inspects Call for FMF and ConstantFoldIntrinsicCall2 uses it to access additional information from constrainted intrinsics. Using FMFSource for that is very questionable, so we can just not pass the parameter for that IRBuilderFolder implementation.
There was a problem hiding this comment.
It is used to flush denormal values according to the parent function attributes of FMFSource. But I think the denormal handling is also poor in other places of IRBuilder (e.g, CreateFAddFMF) :(
|
@llvm/pr-subscribers-backend-aarch64 @llvm/pr-subscribers-llvm-ir Author: Yingwei Zheng (dtcxzyw) ChangesUp to now, the only way to set specified FMF flags in IRBuilder is to use This patch introduces a helper class Compile-time impact: https://llvm-compile-time-tracker.com/compare.php?from=f87a9db8322643ccbc324e317a75b55903129b55&to=9397e712f6010be15ccf62f12740e9b4a67de2f4&stat=instructions%3Au Patch is 50.28 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/121657.diff 12 Files Affected:
diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h
index 8cdfa27ece9378..b73309175f20d1 100644
--- a/llvm/include/llvm/IR/IRBuilder.h
+++ b/llvm/include/llvm/IR/IRBuilder.h
@@ -87,6 +87,23 @@ class IRBuilderCallbackInserter : public IRBuilderDefaultInserter {
}
};
+/// This provides a helper for copying FMF from an instruction or setting
+/// specified flags.
+class FMFSource {
+ std::optional<FastMathFlags> FMF;
+
+public:
+ FMFSource() = default;
+ FMFSource(Instruction *Source) {
+ if (Source)
+ FMF = Source->getFastMathFlags();
+ }
+ FMFSource(FastMathFlags FMF) : FMF(FMF) {}
+ FastMathFlags get(FastMathFlags Default) const {
+ return FMF.value_or(Default);
+ }
+};
+
/// Common base class shared among various IRBuilders.
class IRBuilderBase {
/// Pairs of (metadata kind, MDNode *) that should be added to all newly
@@ -958,29 +975,27 @@ class IRBuilderBase {
/// Create a call to intrinsic \p ID with 1 operand which is mangled on its
/// type.
CallInst *CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
- Instruction *FMFSource = nullptr,
+ FMFSource FMFSource = {},
const Twine &Name = "");
/// Create a call to intrinsic \p ID with 2 operands which is mangled on the
/// first type.
Value *CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS,
- Instruction *FMFSource = nullptr,
+ FMFSource FMFSource = {},
const Twine &Name = "");
/// Create a call to intrinsic \p ID with \p Args, mangled using \p Types. If
/// \p FMFSource is provided, copy fast-math-flags from that instruction to
/// the intrinsic.
CallInst *CreateIntrinsic(Intrinsic::ID ID, ArrayRef<Type *> Types,
- ArrayRef<Value *> Args,
- Instruction *FMFSource = nullptr,
+ ArrayRef<Value *> Args, FMFSource FMFSource = {},
const Twine &Name = "");
/// Create a call to intrinsic \p ID with \p RetTy and \p Args. If
/// \p FMFSource is provided, copy fast-math-flags from that instruction to
/// the intrinsic.
CallInst *CreateIntrinsic(Type *RetTy, Intrinsic::ID ID,
- ArrayRef<Value *> Args,
- Instruction *FMFSource = nullptr,
+ ArrayRef<Value *> Args, FMFSource FMFSource = {},
const Twine &Name = "");
/// Create call to the minnum intrinsic.
@@ -1026,15 +1041,14 @@ class IRBuilderBase {
}
/// Create call to the copysign intrinsic.
- Value *CreateCopySign(Value *LHS, Value *RHS,
- Instruction *FMFSource = nullptr,
+ Value *CreateCopySign(Value *LHS, Value *RHS, FMFSource FMFSource = {},
const Twine &Name = "") {
return CreateBinaryIntrinsic(Intrinsic::copysign, LHS, RHS, FMFSource,
Name);
}
/// Create call to the ldexp intrinsic.
- Value *CreateLdexp(Value *Src, Value *Exp, Instruction *FMFSource = nullptr,
+ Value *CreateLdexp(Value *Src, Value *Exp, FMFSource FMFSource = {},
const Twine &Name = "") {
assert(!IsFPConstrained && "TODO: Support strictfp");
return CreateIntrinsic(Intrinsic::ldexp, {Src->getType(), Exp->getType()},
@@ -1555,144 +1569,113 @@ class IRBuilderBase {
Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
MDNode *FPMD = nullptr) {
- if (IsFPConstrained)
- return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
- L, R, nullptr, Name, FPMD);
-
- if (Value *V = Folder.FoldBinOpFMF(Instruction::FAdd, L, R, FMF))
- return V;
- Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
- return Insert(I, Name);
+ return CreateFAddFMF(L, R, {}, Name, FPMD);
}
- /// Copy fast-math-flags from an instruction rather than using the builder's
- /// default FMF.
- Value *CreateFAddFMF(Value *L, Value *R, Instruction *FMFSource,
- const Twine &Name = "") {
+ Value *CreateFAddFMF(Value *L, Value *R, FMFSource FMFSource,
+ const Twine &Name = "", MDNode *FPMD = nullptr) {
if (IsFPConstrained)
return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
- L, R, FMFSource, Name);
+ L, R, FMFSource, Name, FPMD);
- FastMathFlags FMF = FMFSource->getFastMathFlags();
- if (Value *V = Folder.FoldBinOpFMF(Instruction::FAdd, L, R, FMF))
+ if (Value *V =
+ Folder.FoldBinOpFMF(Instruction::FAdd, L, R, FMFSource.get(FMF)))
return V;
- Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr, FMF);
+ Instruction *I =
+ setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMFSource.get(FMF));
return Insert(I, Name);
}
Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
MDNode *FPMD = nullptr) {
- if (IsFPConstrained)
- return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
- L, R, nullptr, Name, FPMD);
-
- if (Value *V = Folder.FoldBinOpFMF(Instruction::FSub, L, R, FMF))
- return V;
- Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
- return Insert(I, Name);
+ return CreateFSubFMF(L, R, {}, Name, FPMD);
}
- /// Copy fast-math-flags from an instruction rather than using the builder's
- /// default FMF.
- Value *CreateFSubFMF(Value *L, Value *R, Instruction *FMFSource,
- const Twine &Name = "") {
+ Value *CreateFSubFMF(Value *L, Value *R, FMFSource FMFSource,
+ const Twine &Name = "", MDNode *FPMD = nullptr) {
if (IsFPConstrained)
return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
- L, R, FMFSource, Name);
+ L, R, FMFSource, Name, FPMD);
- FastMathFlags FMF = FMFSource->getFastMathFlags();
- if (Value *V = Folder.FoldBinOpFMF(Instruction::FSub, L, R, FMF))
+ if (Value *V =
+ Folder.FoldBinOpFMF(Instruction::FSub, L, R, FMFSource.get(FMF)))
return V;
- Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr, FMF);
+ Instruction *I =
+ setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMFSource.get(FMF));
return Insert(I, Name);
}
Value *CreateFMul(Value *L, Value *R, const Twine &Name = "",
MDNode *FPMD = nullptr) {
- if (IsFPConstrained)
- return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
- L, R, nullptr, Name, FPMD);
-
- if (Value *V = Folder.FoldBinOpFMF(Instruction::FMul, L, R, FMF))
- return V;
- Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
- return Insert(I, Name);
+ return CreateFMulFMF(L, R, {}, Name, FPMD);
}
- /// Copy fast-math-flags from an instruction rather than using the builder's
- /// default FMF.
- Value *CreateFMulFMF(Value *L, Value *R, Instruction *FMFSource,
- const Twine &Name = "") {
+ Value *CreateFMulFMF(Value *L, Value *R, FMFSource FMFSource,
+ const Twine &Name = "", MDNode *FPMD = nullptr) {
if (IsFPConstrained)
return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
- L, R, FMFSource, Name);
+ L, R, FMFSource, Name, FPMD);
- FastMathFlags FMF = FMFSource->getFastMathFlags();
- if (Value *V = Folder.FoldBinOpFMF(Instruction::FMul, L, R, FMF))
+ if (Value *V =
+ Folder.FoldBinOpFMF(Instruction::FMul, L, R, FMFSource.get(FMF)))
return V;
- Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr, FMF);
+ Instruction *I =
+ setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMFSource.get(FMF));
return Insert(I, Name);
}
Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "",
MDNode *FPMD = nullptr) {
- if (IsFPConstrained)
- return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
- L, R, nullptr, Name, FPMD);
-
- if (Value *V = Folder.FoldBinOpFMF(Instruction::FDiv, L, R, FMF))
- return V;
- Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
- return Insert(I, Name);
+ return CreateFDivFMF(L, R, {}, Name, FPMD);
}
- /// Copy fast-math-flags from an instruction rather than using the builder's
- /// default FMF.
- Value *CreateFDivFMF(Value *L, Value *R, Instruction *FMFSource,
- const Twine &Name = "") {
+ Value *CreateFDivFMF(Value *L, Value *R, FMFSource FMFSource,
+ const Twine &Name = "", MDNode *FPMD = nullptr) {
if (IsFPConstrained)
return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
- L, R, FMFSource, Name);
+ L, R, FMFSource, Name, FPMD);
- FastMathFlags FMF = FMFSource->getFastMathFlags();
- if (Value *V = Folder.FoldBinOpFMF(Instruction::FDiv, L, R, FMF))
+ if (Value *V =
+ Folder.FoldBinOpFMF(Instruction::FDiv, L, R, FMFSource.get(FMF)))
return V;
- Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), nullptr, FMF);
+ Instruction *I =
+ setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMFSource.get(FMF));
return Insert(I, Name);
}
Value *CreateFRem(Value *L, Value *R, const Twine &Name = "",
MDNode *FPMD = nullptr) {
- if (IsFPConstrained)
- return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
- L, R, nullptr, Name, FPMD);
-
- if (Value *V = Folder.FoldBinOpFMF(Instruction::FRem, L, R, FMF)) return V;
- Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
- return Insert(I, Name);
+ return CreateFRemFMF(L, R, {}, Name, FPMD);
}
- /// Copy fast-math-flags from an instruction rather than using the builder's
- /// default FMF.
- Value *CreateFRemFMF(Value *L, Value *R, Instruction *FMFSource,
- const Twine &Name = "") {
+ Value *CreateFRemFMF(Value *L, Value *R, FMFSource FMFSource,
+ const Twine &Name = "", MDNode *FPMD = nullptr) {
if (IsFPConstrained)
return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
- L, R, FMFSource, Name);
+ L, R, FMFSource, Name, FPMD);
- FastMathFlags FMF = FMFSource->getFastMathFlags();
- if (Value *V = Folder.FoldBinOpFMF(Instruction::FRem, L, R, FMF)) return V;
- Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr, FMF);
+ if (Value *V =
+ Folder.FoldBinOpFMF(Instruction::FRem, L, R, FMFSource.get(FMF)))
+ return V;
+ Instruction *I =
+ setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMFSource.get(FMF));
return Insert(I, Name);
}
Value *CreateBinOp(Instruction::BinaryOps Opc,
Value *LHS, Value *RHS, const Twine &Name = "",
MDNode *FPMathTag = nullptr) {
- if (Value *V = Folder.FoldBinOp(Opc, LHS, RHS)) return V;
+ return CreateBinOpFMF(Opc, LHS, RHS, {}, Name, FPMathTag);
+ }
+
+ Value *CreateBinOpFMF(Instruction::BinaryOps Opc, Value *LHS, Value *RHS,
+ FMFSource FMFSource, const Twine &Name = "",
+ MDNode *FPMathTag = nullptr) {
+ if (Value *V = Folder.FoldBinOp(Opc, LHS, RHS))
+ return V;
Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
if (isa<FPMathOperator>(BinOp))
- setFPAttrs(BinOp, FPMathTag, FMF);
+ setFPAttrs(BinOp, FPMathTag, FMFSource.get(FMF));
return Insert(BinOp, Name);
}
@@ -1731,13 +1714,13 @@ class IRBuilderBase {
}
CallInst *CreateConstrainedFPBinOp(
- Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
+ Intrinsic::ID ID, Value *L, Value *R, FMFSource FMFSource = {},
const Twine &Name = "", MDNode *FPMathTag = nullptr,
std::optional<RoundingMode> Rounding = std::nullopt,
std::optional<fp::ExceptionBehavior> Except = std::nullopt);
CallInst *CreateConstrainedFPUnroundedBinOp(
- Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
+ Intrinsic::ID ID, Value *L, Value *R, FMFSource FMFSource = {},
const Twine &Name = "", MDNode *FPMathTag = nullptr,
std::optional<fp::ExceptionBehavior> Except = std::nullopt);
@@ -1752,21 +1735,17 @@ class IRBuilderBase {
Value *CreateFNeg(Value *V, const Twine &Name = "",
MDNode *FPMathTag = nullptr) {
- if (Value *Res = Folder.FoldUnOpFMF(Instruction::FNeg, V, FMF))
- return Res;
- return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMF),
- Name);
+ return CreateFNegFMF(V, {}, Name, FPMathTag);
}
- /// Copy fast-math-flags from an instruction rather than using the builder's
- /// default FMF.
- Value *CreateFNegFMF(Value *V, Instruction *FMFSource,
- const Twine &Name = "") {
- FastMathFlags FMF = FMFSource->getFastMathFlags();
- if (Value *Res = Folder.FoldUnOpFMF(Instruction::FNeg, V, FMF))
+ Value *CreateFNegFMF(Value *V, FMFSource FMFSource, const Twine &Name = "",
+ MDNode *FPMathTag = nullptr) {
+ if (Value *Res =
+ Folder.FoldUnOpFMF(Instruction::FNeg, V, FMFSource.get(FMF)))
return Res;
- return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr, FMF),
- Name);
+ return Insert(
+ setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMFSource.get(FMF)),
+ Name);
}
Value *CreateNot(Value *V, const Twine &Name = "") {
@@ -2127,19 +2106,31 @@ class IRBuilderBase {
Value *CreateFPTrunc(Value *V, Type *DestTy, const Twine &Name = "",
MDNode *FPMathTag = nullptr) {
+ return CreateFPTruncFMF(V, DestTy, {}, Name, FPMathTag);
+ }
+
+ Value *CreateFPTruncFMF(Value *V, Type *DestTy, FMFSource FMFSource,
+ const Twine &Name = "", MDNode *FPMathTag = nullptr) {
if (IsFPConstrained)
return CreateConstrainedFPCast(
- Intrinsic::experimental_constrained_fptrunc, V, DestTy, nullptr, Name,
- FPMathTag);
- return CreateCast(Instruction::FPTrunc, V, DestTy, Name, FPMathTag);
+ Intrinsic::experimental_constrained_fptrunc, V, DestTy, FMFSource,
+ Name, FPMathTag);
+ return CreateCast(Instruction::FPTrunc, V, DestTy, Name, FPMathTag,
+ FMFSource);
}
Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "",
MDNode *FPMathTag = nullptr) {
+ return CreateFPExtFMF(V, DestTy, {}, Name, FPMathTag);
+ }
+
+ Value *CreateFPExtFMF(Value *V, Type *DestTy, FMFSource FMFSource,
+ const Twine &Name = "", MDNode *FPMathTag = nullptr) {
if (IsFPConstrained)
return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fpext,
- V, DestTy, nullptr, Name, FPMathTag);
- return CreateCast(Instruction::FPExt, V, DestTy, Name, FPMathTag);
+ V, DestTy, FMFSource, Name, FPMathTag);
+ return CreateCast(Instruction::FPExt, V, DestTy, Name, FPMathTag,
+ FMFSource);
}
Value *CreatePtrToInt(Value *V, Type *DestTy,
@@ -2187,14 +2178,15 @@ class IRBuilderBase {
}
Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy,
- const Twine &Name = "", MDNode *FPMathTag = nullptr) {
+ const Twine &Name = "", MDNode *FPMathTag = nullptr,
+ FMFSource FMFSource = {}) {
if (V->getType() == DestTy)
return V;
if (Value *Folded = Folder.FoldCast(Op, V, DestTy))
return Folded;
Instruction *Cast = CastInst::Create(Op, V, DestTy);
if (isa<FPMathOperator>(Cast))
- setFPAttrs(Cast, FPMathTag, FMF);
+ setFPAttrs(Cast, FPMathTag, FMFSource.get(FMF));
return Insert(Cast, Name);
}
@@ -2255,9 +2247,8 @@ class IRBuilderBase {
}
CallInst *CreateConstrainedFPCast(
- Intrinsic::ID ID, Value *V, Type *DestTy,
- Instruction *FMFSource = nullptr, const Twine &Name = "",
- MDNode *FPMathTag = nullptr,
+ Intrinsic::ID ID, Value *V, Type *DestTy, FMFSource FMFSource = {},
+ const Twine &Name = "", MDNode *FPMathTag = nullptr,
std::optional<RoundingMode> Rounding = std::nullopt,
std::optional<fp::ExceptionBehavior> Except = std::nullopt);
@@ -2392,7 +2383,16 @@ class IRBuilderBase {
// Note that this differs from CreateFCmpS only if IsFPConstrained is true.
Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
const Twine &Name = "", MDNode *FPMathTag = nullptr) {
- return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, false);
+ return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, {}, false);
+ }
+
+ // Create a quiet floating-point comparison (i.e. one that raises an FP
+ // exception only in the case where an input is a signaling NaN).
+ // Note that this differs from CreateFCmpS only if IsFPConstrained is true.
+ Value *CreateFCmpFMF(CmpInst::Predicate P, Value *LHS, Value *RHS,
+ FMFSource FMFSource, const Twine &Name = "",
+ MDNode *FPMathTag = nullptr) {
+ return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, FMFSource, false);
}
Value *CreateCmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS,
@@ -2407,14 +2407,14 @@ class IRBuilderBase {
// Note that this differs from CreateFCmp only if IsFPConstrained is true.
Value *CreateFCmpS(CmpInst::Predicate P, Value *LHS, Value *RHS,
const Twine &Name = "", MDNode *FPMathTag = nullptr) {
- return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, true);
+ return CreateFCmpHelper(P, LHS, RHS, Name, FPMathTag, {}, true);
}
private:
// Helper routine to create either a signaling or a quiet FP comparison.
Value *CreateFCmpHelper(CmpInst::Predicate P, Value *LHS, Value *RHS,
const Twine &Name, MDNode *FPMathTag,
- bool IsSignaling);
+ FMFSource FMFSource, bool IsSignaling);
public:
CallInst *CreateConstrainedFPCmp(
@@ -2436,8 +2436,7 @@ class IRBuilderBase {
private:
CallInst *createCallHelper(Function *Callee, ArrayRef<Value *> Ops,
- const Twine &Name = "",
- Instruction *FMFSource = nullptr,
+ const Twine &Name = "", FMFSource FMFSource = {},
ArrayRef<OperandBundleDef> OpBundles = {});
public:
@@ -2483,6 +2482,9 @@ class IRBuilderBase {
Value *CreateSelect(Value *C, Value *True, Value *False,
const Twine &Name = "", Instruction *MDFrom = nullptr);
+ Value *CreateSelectFMF(Value *C, Value *True, Value *False,
+ FMFSource FMFSource, const Twine &Name = "",
+ Instruction *MDFrom = nullptr);
VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
return Insert(new VAArgInst(List, Ty), Name);
diff --git a/llvm/lib/IR/IRBuilder.cpp b/llvm/lib/IR/IRBuilder.cpp
index f340f7aafdc76f..27b499e42a4e4c 100644
--- a/llvm/lib/IR/IRBuilder.cpp
+++ b/llvm/lib/IR/IRBuilder.cpp
@@ -78,11 +78,11 @@ void IRBuilderBase::SetInstDebugLocation(Instruction *I) const {
CallInst *
IRBuilderBase::createCallHelper(Function *Callee, ArrayRef<Value *> Ops,
- const Twine &Name, Instruction *FMFSource,
+ const Twine &Name, FMFSource FMFS...
[truncated]
|
nikic
approved these changes
Jan 5, 2025
llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
Outdated
Show resolved
Hide resolved
|
LGTM |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Up to now, the only way to set specified FMF flags in IRBuilder is to use
FastMathFlagGuard. It makes the code ugly and hard to maintain.This patch introduces a helper class
FMFSourceto replace the original parameterInstruction *FMFSourcein IRBuilder. To maximize the compatibility, it accepts an instruction or a specified FMF.This patch also removes the use of
FastMathFlagGuardin some simple cases.Compile-time impact: https://llvm-compile-time-tracker.com/compare.php?from=f87a9db8322643ccbc324e317a75b55903129b55&to=9397e712f6010be15ccf62f12740e9b4a67de2f4&stat=instructions%3Au