Handle already masked Instructions.

'createFunctionType' should be able to create the correct FunctionType,
regardless of whether the input Instruction was masked or not.
It uses VFInfo to figure out if the input Instruction was already
masked, and if so it does not append another mask Type.

In checks, create two mock CallInsts, one with a mask and one without
and verify that they have the same number of parameters.

Author: paschalis-mpeis

llvm/lib/Analysis/VectorUtils.cpp

@@ -1507,16 +1507,20 @@ VFABI::createFunctionType(const VFInfo &Info, const Instruction *I,
     VecParams.push_back(U->getType());
   }
 
-  // Append a mask and get its position.
+  // Get mask's position mask and append one if not present in the Instruction.
   int MaskPos = -1;
   if (Info.isMasked()) {
     auto OptMaskPos = Info.getParamIndexForOptionalMask();
     if (!OptMaskPos)
       return std::nullopt;
 
     MaskPos = OptMaskPos.value();
-    VectorType *MaskTy = VectorType::get(Type::getInt1Ty(M->getContext()), VF);
-    VecParams.insert(VecParams.begin() + MaskPos, MaskTy);
+    // append a mask only when it's missing
+    if (VecParams.size() == Info.Shape.Parameters.size() - 1) {
+      VectorType *MaskTy =
+          VectorType::get(Type::getInt1Ty(M->getContext()), VF);
+      VecParams.insert(VecParams.begin() + MaskPos, MaskTy);
+    }
   }
   FunctionType *VecFTy = FunctionType::get(I->getType(), VecParams, false);
   return std::make_pair(VecFTy, MaskPos);

llvm/unittests/Analysis/VectorFunctionABITest.cpp

@@ -131,6 +131,33 @@ class VFABIParserTest : public ::testing::Test {
     if (!OptVecFTyPos)
       return false;
 
+    // Ensure that masked Instructions are handled
+    if (isMasked()) {
+      // In case of a masked call, try creating another mock CallInst that is
+      // masked. createFunctionType should be able to handle this.
+      SmallVector<Type *, 8> CallTypesInclMask(CallTypes);
+      SmallVector<Value *, 8> ArgsInclMask(Args);
+      Type *MaskTy = VectorType::get(Type::getInt1Ty(M->getContext()), VF);
+      CallTypesInclMask.push_back(MaskTy);
+      ArgsInclMask.push_back(Constant::getNullValue(MaskTy));
+
+      FunctionCallee FMasked = M->getOrInsertFunction(
+          VectorName + "_Masked",
+          FunctionType::get(RetTy, CallTypesInclMask, false));
+      std::unique_ptr<CallInst> CIMasked(
+          CallInst::Create(FMasked, ArgsInclMask));
+      auto OptVecFTyMaskedPos =
+          VFABI::createFunctionType(Info, CIMasked.get(), M.get());
+      if (!OptVecFTyMaskedPos)
+        return false;
+
+      // Both FunctionTypes should have the same number of parameters.
+      assert(
+          (OptVecFTyPos->first->getNumParams() ==
+           OptVecFTyMaskedPos->first->getNumParams()) &&
+          "createFunctionType should accept masked or non masked Instructions");
+    }
+
     FunctionType *VecFTy = OptVecFTyPos->first;
     // Check that vectorized parameters' size match with VFInfo.
     // Both may include a mask.