Add intrinsic helper function

[Flakebi]

Summary

It simplifies getting generic argument types from intrinsics.

[nhaehnle]

This mostly looks good to be, but I do have a quibble.

llvm/include/llvm/IR/Intrinsics.h

225–230

It is fairly common pattern to pass a SmallVectorImpl-reference for functions to fill, so that the caller can decide what size of small vector to provide. I think this would be preferable here. You could then just return a boolean that is false if the function is not an intrinsic (or a broken intrinsic).

[Flakebi]

Now takes a smallvec as argument and returns a bool as suggested.

[nhaehnle]

LGTM

llvm/include/llvm/IR/Intrinsics.h

matchIntrinsicSignature(FunctionType *FTy, ArrayRef<IITDescriptor> &Infos,
                           SmallVectorImpl<Type *> &ArgTys);
 
   /// 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);
 
+  /// Gets the type arguments of an intrinsic call by matching type contraints
+  /// specified by the .td file.
+  ///
+  /// Returns None if the given function is not a valid intrinsic call.
+  Optional<SmallVector<Type *, 4>> getIntrinsicSignature(Function *F);
+
   // 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

Intrinsic::matchIntrinsicVarArg(bool isVarArg,
   IITDescriptor D = Infos.front();
   Infos = Infos.slice(1);
   if (D.Kind == IITDescriptor::VarArg)
     return !isVarArg;
 
   return true;
 }
 
-Optional<Function*> Intrinsic::remangleIntrinsicFunction(Function *F) {
+Optional<SmallVector<Type *, 4>> Intrinsic::getIntrinsicSignature(Function *F) {
   Intrinsic::ID ID = F->getIntrinsicID();
   if (!ID)
     return None;
 
-  FunctionType *FTy = F->getFunctionType();
-  // Accumulate an array of overloaded types for the given intrinsic
-  SmallVector<Type *, 4> ArgTys;
-  {
-    SmallVector<Intrinsic::IITDescriptor, 8> Table;
-    getIntrinsicInfoTableEntries(ID, Table);
-    ArrayRef<Intrinsic::IITDescriptor> TableRef = Table;
+  SmallVector<Type *, 4> ArgTys;
 
-    if (Intrinsic::matchIntrinsicSignature(FTy, TableRef, ArgTys))
-      return None;
-    if (Intrinsic::matchIntrinsicVarArg(FTy->isVarArg(), TableRef))
-      return None;
-  }
+  if (Intrinsic::matchIntrinsicSignature(F->getFunctionType(), TableRef,
+                                         ArgTys) !=
+      Intrinsic::MatchIntrinsicTypesResult::MatchIntrinsicTypes_Match) {
+  }
+  if (Intrinsic::matchIntrinsicVarArg(F->getFunctionType()->isVarArg(),
+                                      TableRef))
+
+  return std::move(ArgTys);
 
+Optional<Function *> Intrinsic::remangleIntrinsicFunction(Function *F) {
+  Optional<SmallVector<Type *, 4>> ArgTys = getIntrinsicSignature(F);
+  if (!ArgTys)
+    return None;
+
+  Intrinsic::ID ID = F->getIntrinsicID();
   StringRef Name = F->getName();
-  if (Name == Intrinsic::getName(ID, ArgTys))
+  if (Name == Intrinsic::getName(ID, *ArgTys))
     return None;
 
-  auto NewDecl = Intrinsic::getDeclaration(F->getParent(), ID, ArgTys);
+  auto NewDecl = Intrinsic::getDeclaration(F->getParent(), ID, *ArgTys);
   NewDecl->setCallingConv(F->getCallingConv());
+  FunctionType *FTy = F->getFunctionType();
   assert(NewDecl->getFunctionType() == FTy && "Shouldn't change the signature");
   return NewDecl;
 }
 
 /// hasAddressTaken - returns true if there are any uses of this function
 /// other than direct calls or invokes to it.
 bool Function::hasAddressTaken(const User* *PutOffender) const {
   for (const Use &U : uses()) {

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

if (!NewNumElts)
     return UndefValue::get(II->getType());
 
   if (NewNumElts >= VWidth && DemandedElts.isMask()) {
     if (DMaskIdx >= 0)
       II->setArgOperand(DMaskIdx, Args[DMaskIdx]);
     return nullptr;
   }
 
-  // Determine the overload types of the original intrinsic.
-  auto IID = II->getIntrinsicID();
-  SmallVector<Intrinsic::IITDescriptor, 16> Table;
-  getIntrinsicInfoTableEntries(IID, Table);
-  ArrayRef<Intrinsic::IITDescriptor> TableRef = Table;
-
   // Validate function argument and return types, extracting overloaded types
   // along the way.
-  FunctionType *FTy = II->getCalledFunction()->getFunctionType();
-  SmallVector<Type *, 6> OverloadTys;
-  Intrinsic::matchIntrinsicSignature(FTy, TableRef, OverloadTys);
+  Optional<SmallVector<Type *, 4>> OverloadTys =
+      Intrinsic::getIntrinsicSignature(II->getCalledFunction());
+  if (!OverloadTys)
+    return nullptr;
 
   Module *M = II->getParent()->getParent()->getParent();
   Type *EltTy = IIVTy->getElementType();
   Type *NewTy =
       (NewNumElts == 1) ? EltTy : FixedVectorType::get(EltTy, NewNumElts);
 
-  OverloadTys[0] = NewTy;
-  Function *NewIntrin = Intrinsic::getDeclaration(M, IID, OverloadTys);
+  (*OverloadTys)[0] = NewTy;
+  Function *NewIntrin =
+      Intrinsic::getDeclaration(M, II->getIntrinsicID(), *OverloadTys);
 
   CallInst *NewCall = Builder.CreateCall(NewIntrin, Args);
   NewCall->takeName(II);
   NewCall->copyMetadata(*II);
 
   if (NewNumElts == 1) {
     return Builder.CreateInsertElement(UndefValue::get(II->getType()), NewCall,
                                        DemandedElts.countTrailingZeros());