[VP] make getFunctionalOpcode return an Optional

[simoll]

Summary

The operation of some VP intrinsics do/will not map to regular instruction opcodes. Returning 'None' seems more intuitive here than 'Instruction::Call'.

[frasercrmck]

LGTM

llvm/include/llvm/IR/IntrinsicInst.h

public:
   static bool classof(const IntrinsicInst *I) {
     return IsVPIntrinsic(I->getIntrinsicID());
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
 
   // Equivalent non-predicated opcode
-  unsigned getFunctionalOpcode() const {
+  Optional<unsigned> getFunctionalOpcode() const {
     return GetFunctionalOpcodeForVP(getIntrinsicID());
   }
 
   // Equivalent non-predicated opcode
-  static unsigned GetFunctionalOpcodeForVP(Intrinsic::ID ID);
+  static Optional<unsigned> GetFunctionalOpcodeForVP(Intrinsic::ID ID);
 };
 
 /// This is the common base class for constrained floating point intrinsics.
 class ConstrainedFPIntrinsic : public IntrinsicInst {
 public:
   bool isUnaryOp() const;
   bool isTernaryOp() const;
   Optional<RoundingMode> getRoundingMode() const;

llvm/lib/CodeGen/ExpandVectorPredication.cpp

 
 Value *
 CachingVPExpander::expandPredicationInBinaryOperator(IRBuilder<> &Builder,
                                                      VPIntrinsic &VPI) {
   assert((isSafeToSpeculativelyExecute(&VPI) ||
           VPI.canIgnoreVectorLengthParam()) &&
          "Implicitly dropping %evl in non-speculatable operator!");
 
-  auto OC = static_cast<Instruction::BinaryOps>(VPI.getFunctionalOpcode());
+  auto OC = static_cast<Instruction::BinaryOps>(*VPI.getFunctionalOpcode());
   assert(Instruction::isBinaryOp(OC));
 
   Value *Op0 = VPI.getOperand(0);
   Value *Op1 = VPI.getOperand(1);
   Value *Mask = VPI.getMaskParam();
 
   // Blend in safe operands.
   if (Mask && !isAllTrueMask(Mask)) {

 }
 
 Value *CachingVPExpander::expandPredication(VPIntrinsic &VPI) {
   LLVM_DEBUG(dbgs() << "Lowering to unpredicated op: " << VPI << '\n');
 
   IRBuilder<> Builder(&VPI);
 
   // Try lowering to a LLVM instruction first.
-  unsigned OC = VPI.getFunctionalOpcode();
+  auto OC = VPI.getFunctionalOpcode();
 
-  if (Instruction::isBinaryOp(OC))
+  if (OC && Instruction::isBinaryOp(*OC))
     return expandPredicationInBinaryOperator(Builder, VPI);
 
   return &VPI;
 }
 
 //// } CachingVPExpander
 
 struct TransformJob {

llvm/lib/IR/IntrinsicInst.cpp

#define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS)                    \
   case Intrinsic::VPID:                                                        \
     break;
 #include "llvm/IR/VPIntrinsics.def"
   }
   return true;
 }
 
 // Equivalent non-predicated opcode
-unsigned VPIntrinsic::GetFunctionalOpcodeForVP(Intrinsic::ID ID) {
-  unsigned FunctionalOC = Instruction::Call;
+Optional<unsigned> VPIntrinsic::GetFunctionalOpcodeForVP(Intrinsic::ID ID) {
+  Optional<unsigned> FunctionalOC;
   switch (ID) {
   default:
     break;
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
 #define HANDLE_VP_TO_OPC(OPC) FunctionalOC = Instruction::OPC;
 #define END_REGISTER_VP_INTRINSIC(...) break;
 #include "llvm/IR/VPIntrinsics.def"
   }

llvm/unittests/IR/VPIntrinsicTest.cpp

TEST_F(VPIntrinsicTest, OpcodeRoundTrip) {
   {
 #define HANDLE_INST(OCNum, OCName, Class) Opcodes.push_back(OCNum);
 #include "llvm/IR/Instruction.def"
   }
 
   unsigned FullTripCounts = 0;
   for (unsigned OC : Opcodes) {
     Intrinsic::ID VPID = VPIntrinsic::GetForOpcode(OC);
-    // no equivalent VP intrinsic available
+    // No equivalent VP intrinsic available.
     if (VPID == Intrinsic::not_intrinsic)
       continue;
 
-    unsigned RoundTripOC = VPIntrinsic::GetFunctionalOpcodeForVP(VPID);
-    // no equivalent Opcode available
-    if (RoundTripOC == Instruction::Call)
+    Optional<unsigned> RoundTripOC =
+        VPIntrinsic::GetFunctionalOpcodeForVP(VPID);
+    // No equivalent Opcode available.
+    if (!RoundTripOC)
       continue;
 
-    ASSERT_EQ(RoundTripOC, OC);
+    ASSERT_EQ(*RoundTripOC, OC);
     ++FullTripCounts;
   }
   ASSERT_NE(FullTripCounts, 0u);
 }
 
 /// Check that going from VP intrinsic to Opcode and back results in the same
 /// intrinsic id.
 TEST_F(VPIntrinsicTest, IntrinsicIDRoundTrip) {
   std::unique_ptr<Module> M = CreateVPDeclarationModule();
   assert(M);
 
   unsigned FullTripCounts = 0;
   for (const auto &VPDecl : *M) {
     auto VPID = VPDecl.getIntrinsicID();
-    unsigned OC = VPIntrinsic::GetFunctionalOpcodeForVP(VPID);
+    Optional<unsigned> OC = VPIntrinsic::GetFunctionalOpcodeForVP(VPID);
 
     // no equivalent Opcode available
-    if (OC == Instruction::Call)
+    if (!OC)
       continue;
 
-    Intrinsic::ID RoundTripVPID = VPIntrinsic::GetForOpcode(OC);
+    Intrinsic::ID RoundTripVPID = VPIntrinsic::GetForOpcode(*OC);
 
     ASSERT_EQ(RoundTripVPID, VPID);
     ++FullTripCounts;
   }
   ASSERT_NE(FullTripCounts, 0u);
 }
 
 } // end anonymous namespace