IRBuilder: add CreateIntrinsicByType method

[nhaehnle]

Summary

Allow creating an intrinsic call whose overload types are automatically
deduced based on the given return type and argument types.

The main point of this is to allow external users to create intrinsic
calls while maintaining compatibility if the set of overloaded arguments
changes.

Change-Id: I0f87caacab7c45bcb58774593eeebcd89751851e

[arsenm]

llvm/include/llvm/IR/Intrinsics.h

90

This should probably elaborate a bit more on how this is different. I'm also not sure ByType is the right name. Maybe getDeclarationWithInferredType?

215

Comment what this is for?

[arsenm]

I think an equivalent already went in?

[nhaehnle]

Yes, it did: the overload which has the return type as first argument.

llvm/include/llvm/IR/IRBuilder.h

public:
   /// 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,
                             const Twine &Name = "");
 
+  /// Create a call to intrinsic \p ID with return type \p RetTy and arguments
+  /// \p Args. Type overloads are deduced automatically.
+  ///
+  /// If \p FMFSource is provided, copy fast-math-flags from that instruction to
+  /// the intrinsic.
+  ///
+  /// Var-args functions are not supported.
+  ///
+  /// \note This method is provided specifically as a convenience to external
+  ///       users of LLVM, allowing them to create intrinsics whose overload
+  ///       signature is changing (e.g., a previously fixed type is replaced by
+  ///       an overloadable type).
+  CallInst *CreateIntrinsicByType(Intrinsic::ID ID, Type *RetTy,
+                                  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);
   }
 
   /// Create call to the maxnum intrinsic.
   CallInst *CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name = "") {
     return CreateBinaryIntrinsic(Intrinsic::maxnum, LHS, RHS, nullptr, Name);

llvm/include/llvm/IR/Intrinsics.h

#undef GET_INTRINSIC_ENUM_VALUES
   /// it.
   ///
   /// The Tys parameter is for intrinsics with overloaded types (e.g., those
   /// using iAny, fAny, vAny, or iPTRAny).  For a declaration of an overloaded
   /// intrinsic, Tys must provide exactly one type for each overloaded type in
   /// the intrinsic.
   Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys = None);
 
+  /// Find or create and insert an LLVM function declaration for an intrinsic
+  /// and return it.
+  ///
+  /// Overloaded types are deduced from \p RetTy and \p ArgTys.
+  Function *getDeclarationByType(Module *M, ID id, Type *RetTy,
+                                 ArrayRef<Type *> ArgTys,
+                                 bool IsVarArg = false);
+
   /// Looks up Name in NameTable via binary search. NameTable must be sorted
   /// and all entries must start with "llvm.".  If NameTable contains an exact
   /// match for Name or a prefix of Name followed by a dot, its index in
   /// NameTable is returned. Otherwise, -1 is returned.
   int lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
                                 StringRef Name);
 
   /// Map a GCC builtin name to an intrinsic ID.
#undef GET_INTRINSIC_ENUM_VALUES
   /// Return the IIT table descriptor for the specified intrinsic into an array
   /// of IITDescriptors.
   void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl<IITDescriptor> &T);
 
   enum MatchIntrinsicTypesResult {
     MatchIntrinsicTypes_Match = 0,
     MatchIntrinsicTypes_NoMatchRet = 1,
     MatchIntrinsicTypes_NoMatchArg = 2,
+    MatchIntrinsicTypes_NoMatchVarArg = 3,
   };
 
   /// Match the specified function type with the type constraints specified by
   /// the .td file. If the given type is an overloaded type it is pushed to the
   /// ArgTys vector.
   ///
   /// Returns false if the given type matches with the constraints, true
   /// otherwise.
   MatchIntrinsicTypesResult
   matchIntrinsicSignature(FunctionType *FTy, ArrayRef<IITDescriptor> &Infos,
-                          SmallVectorImpl<Type *> &ArgTys);
+                          SmallVectorImpl<Type *> &OverloadTys);
 
-  /// Verify if the intrinsic has variable arguments. This method is intended to
-  /// be called after all the fixed arguments have been matched first.
-  ///
-  /// This method returns true on error.
-  bool matchIntrinsicVarArg(bool isVarArg, ArrayRef<IITDescriptor> &Infos);
+  MatchIntrinsicTypesResult
+  matchIntrinsicSignature(Type *RetTy, ArrayRef<Type *> ArgTys, bool IsVarArg,
+                          ArrayRef<IITDescriptor> &Infos,
+                          SmallVectorImpl<Type *> &OverloadTys);
 
   /// Gets the type arguments of an intrinsic call by matching type contraints
   /// specified by the .td file. The overloaded types are pushed into the
-  /// AgTys vector.
+  /// OverloadedTys vector.
   ///
   /// Returns false if the given function is not a valid intrinsic call.
-  bool getIntrinsicSignature(Function *F, SmallVectorImpl<Type *> &ArgTys);
+  bool getIntrinsicSignature(Function *F, SmallVectorImpl<Type *> &OverloadTys);
+
+  bool getIntrinsicSignature(ID Id, Type *RetTy, ArrayRef<Type *> ArgTys,
+                             bool IsVarArg,
+                             SmallVectorImpl<Type *> &OverloadTys);
 
   // Checks if the intrinsic name matches with its signature and if not
   // returns the declaration with the same signature and remangled name.
   llvm::Optional<Function*> remangleIntrinsicFunction(Function *F);
 
 } // End Intrinsic namespace
 
 } // End llvm namespace
 
 #endif

llvm/lib/IR/Function.cpp

Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) {
   // There can never be multiple globals with the same name of different types,
   // because intrinsics must be a specific type.
   return cast<Function>(
       M->getOrInsertFunction(getName(id, Tys),
                              getType(M->getContext(), id, Tys))
           .getCallee());
 }
 
+Function *Intrinsic::getDeclarationByType(Module *M, ID id, Type *RetTy,
+                                          ArrayRef<Type *> ArgTys,
+                                          bool IsVarArg) {
+  SmallVector<Type *, 8> OverloadTys;
+  if (!getIntrinsicSignature(id, RetTy, ArgTys, IsVarArg, OverloadTys))
+    return nullptr;
+
+  return cast<Function>(
+      M->getOrInsertFunction(getName(id, OverloadTys),
+                             FunctionType::get(RetTy, ArgTys, IsVarArg))
+          .getCallee());
+}
+
 // This defines the "Intrinsic::getIntrinsicForGCCBuiltin()" method.
 #define GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
 #include "llvm/IR/IntrinsicImpl.inc"
 #undef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN
 
 // This defines the "Intrinsic::getIntrinsicForMSBuiltin()" method.
 #define GET_LLVM_INTRINSIC_FOR_MS_BUILTIN
 #include "llvm/IR/IntrinsicImpl.inc"
switch (D.Kind) {
     }
   }
   llvm_unreachable("unhandled");
 }
 
 Intrinsic::MatchIntrinsicTypesResult
 Intrinsic::matchIntrinsicSignature(FunctionType *FTy,
                                    ArrayRef<Intrinsic::IITDescriptor> &Infos,
-                                   SmallVectorImpl<Type *> &ArgTys) {
+                                   SmallVectorImpl<Type *> &OverloadTys) {
+  return matchIntrinsicSignature(FTy->getReturnType(), FTy->params(),
+                                 FTy->isVarArg(), Infos, OverloadTys);
+}
+
+Intrinsic::MatchIntrinsicTypesResult
+Intrinsic::matchIntrinsicSignature(Type *RetTy, ArrayRef<Type *> ArgTys,
+                                   bool IsVarArg,
+                                   ArrayRef<Intrinsic::IITDescriptor> &Infos,
+                                   SmallVectorImpl<Type *> &OverloadTys) {
   SmallVector<DeferredIntrinsicMatchPair, 2> DeferredChecks;
-  if (matchIntrinsicType(FTy->getReturnType(), Infos, ArgTys, DeferredChecks,
-                         false))
+  if (matchIntrinsicType(RetTy, Infos, OverloadTys, DeferredChecks, false))
     return MatchIntrinsicTypes_NoMatchRet;
 
   unsigned NumDeferredReturnChecks = DeferredChecks.size();
 
-  for (auto Ty : FTy->params())
-    if (matchIntrinsicType(Ty, Infos, ArgTys, DeferredChecks, false))
+  for (auto Ty : ArgTys)
+    if (matchIntrinsicType(Ty, Infos, OverloadTys, DeferredChecks, false))
       return MatchIntrinsicTypes_NoMatchArg;
 
   for (unsigned I = 0, E = DeferredChecks.size(); I != E; ++I) {
     DeferredIntrinsicMatchPair &Check = DeferredChecks[I];
-    if (matchIntrinsicType(Check.first, Check.second, ArgTys, DeferredChecks,
-                           true))
+    if (matchIntrinsicType(Check.first, Check.second, OverloadTys,
+                           DeferredChecks, true))
       return I < NumDeferredReturnChecks ? MatchIntrinsicTypes_NoMatchRet
                                          : MatchIntrinsicTypes_NoMatchArg;
   }
 
-  return MatchIntrinsicTypes_Match;
+  bool InfoVarArg = false;
+  if (!Infos.empty()) {
+    if (Infos.size() >= 2 || Infos.front().Kind != IITDescriptor::VarArg)
+      return MatchIntrinsicTypes_NoMatchArg;
+    Infos = Infos.slice(1);
+    InfoVarArg = true;
   }
 
-bool
-Intrinsic::matchIntrinsicVarArg(bool isVarArg,
-                                ArrayRef<Intrinsic::IITDescriptor> &Infos) {
-  // If there are no descriptors left, then it can't be a vararg.
-  if (Infos.empty())
-    return isVarArg;
+  if (IsVarArg != InfoVarArg)
+    return MatchIntrinsicTypes_NoMatchVarArg;
 
-  // There should be only one descriptor remaining at this point.
-  if (Infos.size() != 1)
-    return true;
-
-  // Check and verify the descriptor.
-  IITDescriptor D = Infos.front();
-  Infos = Infos.slice(1);
-  if (D.Kind == IITDescriptor::VarArg)
-    return !isVarArg;
-
-  return true;
+  return MatchIntrinsicTypes_Match;
 }
 
 bool Intrinsic::getIntrinsicSignature(Function *F,
-                                      SmallVectorImpl<Type *> &ArgTys) {
+                                      SmallVectorImpl<Type *> &OverloadTys) {
   Intrinsic::ID ID = F->getIntrinsicID();
   if (!ID)
     return false;
 
+  FunctionType *FnType = F->getFunctionType();
+  return getIntrinsicSignature(ID, FnType->getReturnType(), FnType->params(),
+                               FnType->isVarArg(), OverloadTys);
+}
+
+bool Intrinsic::getIntrinsicSignature(Intrinsic::ID Id, Type *RetTy,
+                                      ArrayRef<Type *> ArgTys, bool IsVarArg,
+                                      SmallVectorImpl<Type *> &OverloadTys) {
+
   SmallVector<Intrinsic::IITDescriptor, 8> Table;
-  getIntrinsicInfoTableEntries(ID, Table);
+  getIntrinsicInfoTableEntries(Id, Table);
   ArrayRef<Intrinsic::IITDescriptor> TableRef = Table;
 
-  if (Intrinsic::matchIntrinsicSignature(F->getFunctionType(), TableRef,
-                                         ArgTys) !=
-      Intrinsic::MatchIntrinsicTypesResult::MatchIntrinsicTypes_Match) {
-    return false;
-  }
-  if (Intrinsic::matchIntrinsicVarArg(F->getFunctionType()->isVarArg(),
-                                      TableRef))
-    return false;
-  return true;
+  return Intrinsic::matchIntrinsicSignature(RetTy, ArgTys, IsVarArg, TableRef,
+                                            OverloadTys) ==
+         Intrinsic::MatchIntrinsicTypesResult::MatchIntrinsicTypes_Match;
 }
 
 Optional<Function *> Intrinsic::remangleIntrinsicFunction(Function *F) {
   SmallVector<Type *, 4> ArgTys;
   if (!getIntrinsicSignature(F, ArgTys))
     return None;
 
   Intrinsic::ID ID = F->getIntrinsicID();

llvm/lib/IR/IRBuilder.cpp

CallInst *IRBuilderBase::CreateIntrinsic(Intrinsic::ID ID,
                                          ArrayRef<Value *> Args,
                                          Instruction *FMFSource,
                                          const Twine &Name) {
   Module *M = BB->getModule();
   Function *Fn = Intrinsic::getDeclaration(M, ID, Types);
   return createCallHelper(Fn, Args, this, Name, FMFSource);
 }
 
+CallInst *IRBuilderBase::CreateIntrinsicByType(Intrinsic::ID ID, Type *RetTy,
+                                               ArrayRef<Value *> Args,
+                                               Instruction *FMFSource,
+                                               const Twine &Name) {
+  Module *M = BB->getModule();
+  SmallVector<Type *, 8> ArgTys;
+  for (Value *Arg : Args)
+    ArgTys.push_back(Arg->getType());
+  Function *Fn = Intrinsic::getDeclarationByType(M, ID, RetTy, ArgTys);
+  return createCallHelper(Fn, Args, this, Name, FMFSource);
+}
+
 CallInst *IRBuilderBase::CreateConstrainedFPBinOp(
     Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource,
     const Twine &Name, MDNode *FPMathTag,
     Optional<RoundingMode> Rounding,
     Optional<fp::ExceptionBehavior> Except) {
   Value *RoundingV = getConstrainedFPRounding(Rounding);
   Value *ExceptV = getConstrainedFPExcept(Except);
 

llvm/lib/IR/Verifier.cpp

Intrinsic::MatchIntrinsicTypesResult Res =
       Intrinsic::matchIntrinsicSignature(IFTy, TableRef, ArgTys);
   Assert(Res != Intrinsic::MatchIntrinsicTypes_NoMatchRet,
          "Intrinsic has incorrect return type!", IF);
   Assert(Res != Intrinsic::MatchIntrinsicTypes_NoMatchArg,
          "Intrinsic has incorrect argument type!", IF);
 
   // Verify if the intrinsic call matches the vararg property.
   if (IsVarArg)
-    Assert(!Intrinsic::matchIntrinsicVarArg(IsVarArg, TableRef),
+    Assert(Res != Intrinsic::MatchIntrinsicTypes_NoMatchVarArg,
            "Intrinsic was not defined with variable arguments!", IF);
   else
-    Assert(!Intrinsic::matchIntrinsicVarArg(IsVarArg, TableRef),
+    Assert(Res != Intrinsic::MatchIntrinsicTypes_NoMatchVarArg,
            "Callsite was not defined with variable arguments!", IF);
 
   // All descriptors should be absorbed by now.
   Assert(TableRef.empty(), "Intrinsic has too few arguments!", IF);
 
   // Now that we have the intrinsic ID and the actual argument types (and we
   // know they are legal for the intrinsic!) get the intrinsic name through the
   // usual means.  This allows us to verify the mangling of argument types into

llvm/unittests/IR/IRBuilderTest.cpp

TEST_F(IRBuilderTest, Intrinsics) {
   EXPECT_FALSE(II->hasNoNaNs());
 
   Call = Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V}, I);
   II = cast<IntrinsicInst>(Call);
   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
   EXPECT_TRUE(II->hasNoInfs());
   EXPECT_FALSE(II->hasNoNaNs());
 
+  Call = Builder.CreateIntrinsicByType(Intrinsic::fma, V->getType(), {V, V, V});
+  II = cast<IntrinsicInst>(Call);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
+  EXPECT_TRUE(II->hasNoInfs());
+  EXPECT_FALSE(II->hasNoNaNs());
+
   Call = Builder.CreateUnaryIntrinsic(Intrinsic::roundeven, V);
   II = cast<IntrinsicInst>(Call);
   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::roundeven);
   EXPECT_FALSE(II->hasNoInfs());
   EXPECT_FALSE(II->hasNoNaNs());
 }
 
 TEST_F(IRBuilderTest, IntrinsicsWithScalableVectors) {