[llvm] bb28324 - [IRBuilder] CreateIntrinsic with implicit mangling
Jay Foad via llvm-commits
llvm-commits at lists.llvm.org
Tue Aug 2 05:21:31 PDT 2022
Author: Jay Foad
Date: 2022-08-02T13:08:35+01:00
New Revision: bb2832410e834ea48264bef911ffa47095aa56e3
URL: https://github.com/llvm/llvm-project/commit/bb2832410e834ea48264bef911ffa47095aa56e3
DIFF: https://github.com/llvm/llvm-project/commit/bb2832410e834ea48264bef911ffa47095aa56e3.diff
LOG: [IRBuilder] CreateIntrinsic with implicit mangling
Add a new IRBuilderBase::CreateIntrinsic which takes the return type and
argument values for the intrinsic call but does not take an explicit
list of types to mangle. Instead the builder works this out from the
intrinsic declaration and the types of the supplied arguments.
This means that the mangling is hidden from the client, which in turn
means that intrinsic definitions can change which arguments are mangled
without requiring any changes to the client code.
Differential Revision: https://reviews.llvm.org/D130776
Added:
Modified:
llvm/include/llvm/IR/IRBuilder.h
llvm/lib/IR/IRBuilder.cpp
llvm/unittests/IR/IRBuilderTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h
index 879084e726cde..6903559da4e89 100644
--- a/llvm/include/llvm/IR/IRBuilder.h
+++ b/llvm/include/llvm/IR/IRBuilder.h
@@ -886,7 +886,7 @@ class IRBuilderBase {
Instruction *FMFSource = nullptr,
const Twine &Name = "");
- /// Create a call to intrinsic \p ID with \p args, mangled using \p Types. If
+ /// 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,
@@ -894,6 +894,14 @@ class IRBuilderBase {
Instruction *FMFSource = nullptr,
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,
+ const Twine &Name = "");
+
/// Create call to the minnum intrinsic.
CallInst *CreateMinNum(Value *LHS, Value *RHS, const Twine &Name = "") {
return CreateBinaryIntrinsic(Intrinsic::minnum, LHS, RHS, nullptr, Name);
diff --git a/llvm/lib/IR/IRBuilder.cpp b/llvm/lib/IR/IRBuilder.cpp
index 0b11fb6c4f4c6..469bd4db57c29 100644
--- a/llvm/lib/IR/IRBuilder.cpp
+++ b/llvm/lib/IR/IRBuilder.cpp
@@ -898,6 +898,33 @@ CallInst *IRBuilderBase::CreateIntrinsic(Intrinsic::ID ID,
return createCallHelper(Fn, Args, Name, FMFSource);
}
+CallInst *IRBuilderBase::CreateIntrinsic(Type *RetTy, Intrinsic::ID ID,
+ ArrayRef<Value *> Args,
+ Instruction *FMFSource,
+ const Twine &Name) {
+ Module *M = BB->getModule();
+
+ SmallVector<Intrinsic::IITDescriptor> Table;
+ Intrinsic::getIntrinsicInfoTableEntries(ID, Table);
+ ArrayRef<Intrinsic::IITDescriptor> TableRef(Table);
+
+ SmallVector<Type *> ArgTys;
+ ArgTys.reserve(Args.size());
+ for (auto &I : Args)
+ ArgTys.push_back(I->getType());
+ FunctionType *FTy = FunctionType::get(RetTy, ArgTys, false);
+ SmallVector<Type *> OverloadTys;
+ Intrinsic::MatchIntrinsicTypesResult Res =
+ matchIntrinsicSignature(FTy, TableRef, OverloadTys);
+ (void)Res;
+ assert(Res == Intrinsic::MatchIntrinsicTypes_Match && TableRef.empty() &&
+ "Wrong types for intrinsic!");
+ // TODO: Handle varargs intrinsics.
+
+ Function *Fn = Intrinsic::getDeclaration(M, ID, OverloadTys);
+ return createCallHelper(Fn, Args, Name, FMFSource);
+}
+
CallInst *IRBuilderBase::CreateConstrainedFPBinOp(
Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource,
const Twine &Name, MDNode *FPMathTag,
diff --git a/llvm/unittests/IR/IRBuilderTest.cpp b/llvm/unittests/IR/IRBuilderTest.cpp
index a0836c6e75e31..4a6c46eae8f8b 100644
--- a/llvm/unittests/IR/IRBuilderTest.cpp
+++ b/llvm/unittests/IR/IRBuilderTest.cpp
@@ -137,6 +137,29 @@ TEST_F(IRBuilderTest, Intrinsics) {
EXPECT_EQ(II->getIntrinsicID(), Intrinsic::set_rounding);
}
+TEST_F(IRBuilderTest, IntrinsicMangling) {
+ IRBuilder<> Builder(BB);
+ Type *VoidTy = Builder.getVoidTy();
+ Type *Int64Ty = Builder.getInt64Ty();
+ Value *Int64Val = Builder.getInt64(0);
+ Value *DoubleVal = PoisonValue::get(Builder.getDoubleTy());
+ CallInst *Call;
+
+ // Mangled return type, no arguments.
+ Call = Builder.CreateIntrinsic(Int64Ty, Intrinsic::coro_size, {});
+ EXPECT_EQ(Call->getCalledFunction()->getName(), "llvm.coro.size.i64");
+
+ // Void return type, mangled argument type.
+ Call =
+ Builder.CreateIntrinsic(VoidTy, Intrinsic::set_loop_iterations, Int64Val);
+ EXPECT_EQ(Call->getCalledFunction()->getName(),
+ "llvm.set.loop.iterations.i64");
+
+ // Mangled return type and argument type.
+ Call = Builder.CreateIntrinsic(Int64Ty, Intrinsic::lround, DoubleVal);
+ EXPECT_EQ(Call->getCalledFunction()->getName(), "llvm.lround.i64.f64");
+}
+
TEST_F(IRBuilderTest, IntrinsicsWithScalableVectors) {
IRBuilder<> Builder(BB);
CallInst *Call;
More information about the llvm-commits
mailing list