[VP] getDeclarationForParams

[simoll]

Summary

VPIntrinsic::getDeclarationForParams creates a vp intrinsic declaration for parameters you want to call it with.
This is in preparation of a new builder class that makes emitting vp intrinsic code nearly as convenient as using a plain ir builder (aka VectorBuilder, to be used by D99750).

[craig.topper]

llvm/lib/IR/IntrinsicInst.cpp

430

Is this written this way because of the TODO? It seems like this could just be

auto *VPFunc = Intrinsic::getDeclaration(M, VPID, Params[0]->getType());

Which avoids the SmallVector.

[simoll]

• Simplified w/o ShortTypeVec

[simoll]

llvm/lib/IR/IntrinsicInst.cpp

430

It's because of the todo.. other intrinsics will need multiple demangling types (eg vp.fptosi). No reason not to simplify it for now, though.

[simoll]

Are we ok with this one?

[craig.topper]

LGTM

[vkmr]

LGTM.

[frasercrmck]

Might as well throw my hat in here, LGTM.

llvm/include/llvm/IR/IntrinsicInst.h

static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
   /// @}
 };
 
 /// This is the common base class for vector predication intrinsics.
 class VPIntrinsic : public IntrinsicInst {
 public:
+  /// \brief Declares a llvm.vp.* intrinsic in \p M that matches the parameters
+  /// \p Params.
+  static Function *getDeclarationForParams(Module *M, Intrinsic::ID,
+                                           ArrayRef<Value *> Params);
+
   static Optional<unsigned> getMaskParamPos(Intrinsic::ID IntrinsicID);
   static Optional<unsigned> getVectorLengthParamPos(Intrinsic::ID IntrinsicID);
 
   /// The llvm.vp.* intrinsics for this instruction Opcode
   static Intrinsic::ID getForOpcode(unsigned OC);
 
   // Whether \p ID is a VP intrinsic ID.
   static bool isVPIntrinsic(Intrinsic::ID);

llvm/lib/IR/IntrinsicInst.cpp

bool VPIntrinsic::canIgnoreVectorLengthParam() const {
 
   uint64_t VLNum = VLConst->getZExtValue();
   if (VLNum >= EC.getKnownMinValue())
     return true;
 
   return false;
 }
 
+Function *VPIntrinsic::getDeclarationForParams(Module *M, Intrinsic::ID VPID,
+                                               ArrayRef<Value *> Params) {
+  assert(isVPIntrinsic(VPID) && "not a VP intrinsic");
+
+  // TODO: Extend this for other VP intrinsics as they are upstreamed. This
+  // works for binary arithmetic VP intrinsics.
+  auto *VPFunc = Intrinsic::getDeclaration(M, VPID, Params[0]->getType());
+  assert(VPFunc && "Could not declare VP intrinsic");
+  return VPFunc;
+}
+
 Instruction::BinaryOps BinaryOpIntrinsic::getBinaryOp() const {
   switch (getIntrinsicID()) {
   case Intrinsic::uadd_with_overflow:
   case Intrinsic::sadd_with_overflow:
   case Intrinsic::uadd_sat:
   case Intrinsic::sadd_sat:
     return Instruction::Add;
   case Intrinsic::usub_with_overflow:

llvm/unittests/IR/VPIntrinsicTest.cpp

for (const auto &VPDecl : *M) {
     Intrinsic::ID RoundTripVPID = VPIntrinsic::getForOpcode(*OC);
 
     ASSERT_EQ(RoundTripVPID, VPID);
     ++FullTripCounts;
   }
   ASSERT_NE(FullTripCounts, 0u);
 }
 
+/// Check that VPIntrinsic::getDeclarationForParams works.
+TEST_F(VPIntrinsicTest, VPIntrinsicDeclarationForParams) {
+  std::unique_ptr<Module> M = CreateVPDeclarationModule();
+  assert(M);
+
+  auto OutM = std::make_unique<Module>("", M->getContext());
+
+  for (auto &F : *M) {
+    auto *FuncTy = F.getFunctionType();
+
+    // Declare intrinsic anew with explicit types.
+    std::vector<Value *> Values;
+    for (auto *ParamTy : FuncTy->params())
+      Values.push_back(UndefValue::get(ParamTy));
+
+    ASSERT_NE(F.getIntrinsicID(), Intrinsic::not_intrinsic);
+    auto *NewDecl = VPIntrinsic::getDeclarationForParams(
+        OutM.get(), F.getIntrinsicID(), Values);
+    ASSERT_TRUE(NewDecl);
+
+    // Check that 'old decl' == 'new decl'.
+    ASSERT_EQ(F.getIntrinsicID(), NewDecl->getIntrinsicID());
+    auto ItNewParams = NewDecl->getFunctionType()->param_begin();
+    auto EndItNewParams = NewDecl->getFunctionType()->param_end();
+    for (auto *ParamTy : FuncTy->params()) {
+      ASSERT_NE(ItNewParams, EndItNewParams);
+      ASSERT_EQ(*ItNewParams, ParamTy);
+      ++ItNewParams;
+    }
+  }
+}
+
 } // end anonymous namespace