[llvm] [IRBuilder] Refactor FMF interface (PR #121657)
via llvm-commits
llvm-commits at lists.llvm.org
Sun Jan 5 01:36:21 PST 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-ir
Author: Yingwei Zheng (dtcxzyw)
<details>
<summary>Changes</summary>
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 `FMFSource` to replace the original parameter `Instruction *FMFSource` in IRBuilder. To maximize the compatibility, it accepts an instruction or a specified FMF.
This patch also removes the use of `FastMathFlagGuard` in some simple cases.
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:
- (modified) llvm/include/llvm/IR/IRBuilder.h (+121-119)
- (modified) llvm/lib/IR/IRBuilder.cpp (+30-29)
- (modified) llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp (+2-4)
- (modified) llvm/lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp (+3-5)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp (+7-12)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp (+14-23)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp (+8-8)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp (+12-22)
- (modified) llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp (+8-13)
- (modified) llvm/lib/Transforms/Utils/SimplifyCFG.cpp (+5-10)
- (modified) llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp (+19-33)
- (modified) llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp (+3-4)
``````````diff
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]
``````````
</details>
https://github.com/llvm/llvm-project/pull/121657
More information about the llvm-commits
mailing list