[VP] Make getMaskParamPos/getVectorLengthParamPos return unsigned. Lowercase function names.

[craig.topper]

Summary

Parameter positions seem like they should be unsigned.

While there, make function names lowercase per coding standards.

[craig.topper]

clang-format

[frasercrmck]

I was tempted to do this while working on D103027 so you get my LGTM. I'll let @simoll see it first though.

llvm/lib/IR/IntrinsicInst.cpp

297–298

You could fold this into the ifs if you wanted. Same in getVectorLengthParam

[simoll]

+1 for folding variables into ifs while you're at it.

LGTM

[craig.topper]

Fold checks into if.
Rebase after D103027

[frasercrmck]

Since @simoll's happy, 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:
-  static Optional<int> GetMaskParamPos(Intrinsic::ID IntrinsicID);
-  static Optional<int> GetVectorLengthParamPos(Intrinsic::ID IntrinsicID);
+  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);
+  static Intrinsic::ID getForOpcode(unsigned OC);
 
   // Whether \p ID is a VP intrinsic ID.
-  static bool IsVPIntrinsic(Intrinsic::ID);
+  static bool isVPIntrinsic(Intrinsic::ID);
 
   /// \return the mask parameter or nullptr.
   Value *getMaskParam() const;
   void setMaskParam(Value *);
 
   /// \return the vector length parameter or nullptr.
   Value *getVectorLengthParam() const;
   void setVectorLengthParam(Value *);
 
   /// \return whether the vector length param can be ignored.
   bool canIgnoreVectorLengthParam() const;
 
   /// \return the static element count (vector number of elements) the vector
   /// length parameter applies to.
   ElementCount getStaticVectorLength() const;
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const IntrinsicInst *I) {
-    return IsVPIntrinsic(I->getIntrinsicID());
+    return isVPIntrinsic(I->getIntrinsicID());
   }
   static bool classof(const Value *V) {
     return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
   }
 
   // Equivalent non-predicated opcode
   Optional<unsigned> getFunctionalOpcode() const {
-    return GetFunctionalOpcodeForVP(getIntrinsicID());
+    return getFunctionalOpcodeForVP(getIntrinsicID());
   }
 
   // Equivalent non-predicated opcode
-  static Optional<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/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visitVectorPredicationIntrinsic(
   unsigned Opcode = getISDForVPIntrinsic(VPIntrin);
 
   SmallVector<EVT, 4> ValueVTs;
   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
   ComputeValueVTs(TLI, DAG.getDataLayout(), VPIntrin.getType(), ValueVTs);
   SDVTList VTs = DAG.getVTList(ValueVTs);
 
   auto EVLParamPos =
-      VPIntrinsic::GetVectorLengthParamPos(VPIntrin.getIntrinsicID());
+      VPIntrinsic::getVectorLengthParamPos(VPIntrin.getIntrinsicID());
 
   MVT EVLParamVT = TLI.getVPExplicitVectorLengthTy();
   assert(EVLParamVT.isScalarInteger() && EVLParamVT.bitsGE(MVT::i32) &&
          "Unexpected target EVL type");
 
   // Request operands.
   SmallVector<SDValue, 7> OpValues;
-  for (int I = 0; I < (int)VPIntrin.getNumArgOperands(); ++I) {
+  for (unsigned I = 0; I < VPIntrin.getNumArgOperands(); ++I) {
     auto Op = getValue(VPIntrin.getArgOperand(I));
     if (I == EVLParamPos)
       Op = DAG.getNode(ISD::ZERO_EXTEND, DL, EVLParamVT, Op);
     OpValues.push_back(Op);
   }
 
   SDValue Result = DAG.getNode(Opcode, DL, VTs, OpValues);
   setValue(&VPIntrin, Result);

llvm/lib/IR/IntrinsicInst.cpp

 
 ElementCount VPIntrinsic::getStaticVectorLength() const {
   auto GetVectorLengthOfType = [](const Type *T) -> ElementCount {
     auto VT = cast<VectorType>(T);
     auto ElemCount = VT->getElementCount();
     return ElemCount;
   };
 
-  auto VPMask = getMaskParam();
+  Value *VPMask = getMaskParam();
+  assert(VPMask && "No mask param?");
   return GetVectorLengthOfType(VPMask->getType());
 }
 
 Value *VPIntrinsic::getMaskParam() const {
-  auto maskPos = GetMaskParamPos(getIntrinsicID());
-  if (maskPos)
-    return getArgOperand(maskPos.getValue());
+  if (auto MaskPos = getMaskParamPos(getIntrinsicID()))
+    return getArgOperand(MaskPos.getValue());
   return nullptr;
 }
 
 void VPIntrinsic::setMaskParam(Value *NewMask) {
-  auto MaskPos = GetMaskParamPos(getIntrinsicID());
+  auto MaskPos = getMaskParamPos(getIntrinsicID());
   setArgOperand(*MaskPos, NewMask);
 }
 
 Value *VPIntrinsic::getVectorLengthParam() const {
-  auto vlenPos = GetVectorLengthParamPos(getIntrinsicID());
-  if (vlenPos)
-    return getArgOperand(vlenPos.getValue());
+  if (auto EVLPos = getVectorLengthParamPos(getIntrinsicID()))
+    return getArgOperand(EVLPos.getValue());
   return nullptr;
 }
 
 void VPIntrinsic::setVectorLengthParam(Value *NewEVL) {
-  auto EVLPos = GetVectorLengthParamPos(getIntrinsicID());
+  auto EVLPos = getVectorLengthParamPos(getIntrinsicID());
   setArgOperand(*EVLPos, NewEVL);
 }
 
-Optional<int> VPIntrinsic::GetMaskParamPos(Intrinsic::ID IntrinsicID) {
+Optional<unsigned> VPIntrinsic::getMaskParamPos(Intrinsic::ID IntrinsicID) {
   switch (IntrinsicID) {
   default:
     return None;
 
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS)                    \
   case Intrinsic::VPID:                                                        \
     return MASKPOS;
 #include "llvm/IR/VPIntrinsics.def"
   }
 }
 
-Optional<int> VPIntrinsic::GetVectorLengthParamPos(Intrinsic::ID IntrinsicID) {
+Optional<unsigned>
+VPIntrinsic::getVectorLengthParamPos(Intrinsic::ID IntrinsicID) {
   switch (IntrinsicID) {
   default:
     return None;
 
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS)                    \
   case Intrinsic::VPID:                                                        \
     return VLENPOS;
 #include "llvm/IR/VPIntrinsics.def"
   }
 }
 
-bool VPIntrinsic::IsVPIntrinsic(Intrinsic::ID ID) {
+bool VPIntrinsic::isVPIntrinsic(Intrinsic::ID ID) {
   switch (ID) {
   default:
     return false;
 
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, MASKPOS, VLENPOS)                    \
   case Intrinsic::VPID:                                                        \
     break;
 #include "llvm/IR/VPIntrinsics.def"
   }
   return true;
 }
 
 // Equivalent non-predicated opcode
-Optional<unsigned> VPIntrinsic::GetFunctionalOpcodeForVP(Intrinsic::ID ID) {
+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"
   }
 
   return FunctionalOC;
 }
 
-Intrinsic::ID VPIntrinsic::GetForOpcode(unsigned IROPC) {
+Intrinsic::ID VPIntrinsic::getForOpcode(unsigned IROPC) {
   switch (IROPC) {
   default:
     return Intrinsic::not_intrinsic;
 
 #define HANDLE_VP_TO_OPC(OPC) case Instruction::OPC:
 #define END_REGISTER_VP_INTRINSIC(VPID) return Intrinsic::VPID;
 #include "llvm/IR/VPIntrinsics.def"
   }

llvm/unittests/IR/VPIntrinsicTest.cpp

TEST_F(VPIntrinsicTest, VPModuleComplete) {
   std::unique_ptr<Module> M = CreateVPDeclarationModule();
   assert(M);
 
   // Check that all @llvm.vp.* functions in the module are recognized vp
   // intrinsics.
   std::set<Intrinsic::ID> SeenIDs;
   for (const auto &VPDecl : *M) {
     ASSERT_TRUE(VPDecl.isIntrinsic());
-    ASSERT_TRUE(VPIntrinsic::IsVPIntrinsic(VPDecl.getIntrinsicID()));
+    ASSERT_TRUE(VPIntrinsic::isVPIntrinsic(VPDecl.getIntrinsicID()));
     SeenIDs.insert(VPDecl.getIntrinsicID());
   }
 
   // Check that every registered VP intrinsic has an instance in the test
   // module.
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...)                                 \
   ASSERT_TRUE(SeenIDs.count(Intrinsic::VPID));
 #include "llvm/IR/VPIntrinsics.def"
for (auto &I : F->getEntryBlock()) {
 
     ASSERT_LT(i, NumExpected);
     ASSERT_EQ(Expected[i], VPI->canIgnoreVectorLengthParam());
     ++i;
   }
 }
 
 /// Check that the argument returned by
-/// VPIntrinsic::Get<X>ParamPos(Intrinsic::ID) has the expected type.
+/// VPIntrinsic::get<X>ParamPos(Intrinsic::ID) has the expected type.
 TEST_F(VPIntrinsicTest, GetParamPos) {
   std::unique_ptr<Module> M = CreateVPDeclarationModule();
   assert(M);
 
   for (Function &F : *M) {
     ASSERT_TRUE(F.isIntrinsic());
-    Optional<int> MaskParamPos =
-        VPIntrinsic::GetMaskParamPos(F.getIntrinsicID());
+    Optional<unsigned> MaskParamPos =
+        VPIntrinsic::getMaskParamPos(F.getIntrinsicID());
     if (MaskParamPos.hasValue()) {
       Type *MaskParamType = F.getArg(MaskParamPos.getValue())->getType();
       ASSERT_TRUE(MaskParamType->isVectorTy());
       ASSERT_TRUE(cast<VectorType>(MaskParamType)->getElementType()->isIntegerTy(1));
     }
 
-    Optional<int> VecLenParamPos =
-        VPIntrinsic::GetVectorLengthParamPos(F.getIntrinsicID());
+    Optional<unsigned> VecLenParamPos =
+        VPIntrinsic::getVectorLengthParamPos(F.getIntrinsicID());
     if (VecLenParamPos.hasValue()) {
       Type *VecLenParamType = F.getArg(VecLenParamPos.getValue())->getType();
       ASSERT_TRUE(VecLenParamType->isIntegerTy(32));
     }
   }
 }
 
 /// Check that going from Opcode to VP intrinsic and back results in the same
 /// Opcode.
 TEST_F(VPIntrinsicTest, OpcodeRoundTrip) {
   std::vector<unsigned> Opcodes;
   Opcodes.reserve(100);
 
   {
 #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);
+    Intrinsic::ID VPID = VPIntrinsic::getForOpcode(OC);
     // No equivalent VP intrinsic available.
     if (VPID == Intrinsic::not_intrinsic)
       continue;
 
     Optional<unsigned> RoundTripOC =
-        VPIntrinsic::GetFunctionalOpcodeForVP(VPID);
+        VPIntrinsic::getFunctionalOpcodeForVP(VPID);
     // No equivalent Opcode available.
     if (!RoundTripOC)
       continue;
 
     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();
-    Optional<unsigned> OC = VPIntrinsic::GetFunctionalOpcodeForVP(VPID);
+    Optional<unsigned> OC = VPIntrinsic::getFunctionalOpcodeForVP(VPID);
 
     // no equivalent Opcode available
     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