Simplified createFunctionType method

It accepts ScalarFTy and VecRetTy. As the latter is not kept in VFABI,
it should instead come from the original Instruction/Callinst.

This change allows further simplification in tests. Also, methods like
the test `_ZGVnN3lLRUlnLnRnUn_foo`, which contains only scalar parameters,
would still return a valid FunctionType. This is an edge case that will
only be encountered in tests though.

Author: paschalis-mpeis

llvm/include/llvm/Analysis/VectorUtils.h

@@ -197,11 +197,10 @@ void getVectorVariantNames(const CallInst &CI,
                            SmallVectorImpl<std::string> &VariantMappings);
 
 /// Returns a pair of the vectorized FunctionType and the mask's position when
-/// there's one, otherwise -1. It rejects any non vectorized calls as this
-/// method should be called at a point where the Instruction \p I is already
-/// vectorized.
+/// there's one, otherwise -1.
 std::optional<std::pair<FunctionType *, int>>
-createFunctionType(const VFInfo &Info, const Instruction *I, const Module *M);
+createFunctionType(const VFInfo &Info, const FunctionType *ScalarFTy,
+                   Type *VecRetTy, const Module *M);
 } // end namespace VFABI
 
 /// The Vector Function Database.

llvm/lib/Analysis/VectorUtils.cpp

@@ -1479,32 +1479,17 @@ void VFABI::getVectorVariantNames(
   }
 }
 
-// Returns whether any of the operands or return type of \p I are vectors.
-static bool isVectorized(const Instruction *I) {
-  if (I->getType()->isVectorTy())
-    return true;
-  for (auto &U : I->operands())
-    if (U->getType()->isVectorTy())
-      return true;
-  return false;
-}
-
 std::optional<std::pair<FunctionType *, int>>
-VFABI::createFunctionType(const VFInfo &Info, const Instruction *I,
-                          const Module *M) {
-  // only vectorized calls should reach this method
-  if (!isVectorized(I))
-    return std::nullopt;
-
+VFABI::createFunctionType(const VFInfo &Info, const FunctionType *ScalarFTy,
+                          Type *VecRetTy, const Module *M) {
   ElementCount VF = Info.Shape.VF;
-  // get vectorized operands
-  const bool IsCall = isa<CallBase>(I);
-  SmallVector<Type *, 8> VecParams;
-  for (auto [i, U] : enumerate(I->operands())) {
-    // ignore the function pointer when the Instruction is a call
-    if (IsCall && i == I->getNumOperands() - 1)
-      break;
-    VecParams.push_back(U->getType());
+  // Create vector parameter types
+  SmallVector<Type *, 8> VecTypes;
+  for (auto [STy, VFParam] : zip(ScalarFTy->params(), Info.Shape.Parameters)) {
+    if (VFParam.ParamKind == VFParamKind::Vector)
+      VecTypes.push_back(VectorType::get(STy, VF));
+    else
+      VecTypes.push_back(STy);
   }
 
   // Get mask's position mask and append one if not present in the Instruction.
@@ -1515,14 +1500,10 @@ VFABI::createFunctionType(const VFInfo &Info, const Instruction *I,
       return std::nullopt;
 
     MaskPos = OptMaskPos.value();
-    // 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);
-    }
+    VectorType *MaskTy = VectorType::get(Type::getInt1Ty(M->getContext()), VF);
+    VecTypes.insert(VecTypes.begin() + MaskPos, MaskTy);
   }
-  FunctionType *VecFTy = FunctionType::get(I->getType(), VecParams, false);
+  FunctionType *VecFTy = FunctionType::get(VecRetTy, VecTypes, false);
   return std::make_pair(VecFTy, MaskPos);
 }
 

llvm/unittests/Analysis/VectorFunctionABITest.cpp

@@ -98,10 +98,9 @@ class VFABIParserTest : public ::testing::Test {
   /// number and type of arguments with both the ScalarFTy and the operands of
   /// the call.
   bool checkFunctionType() {
-    // Create a mock vectorized CallInst using dummy values and then use it to
-    // create a vector FunctionType. In the case of scalable ISAs, the created
-    // vector FunctionType might have a mask parameter Type, however, this input
-    // CallInst will not have a mask operand.
+    // For scalable ISAs, the created vector FunctionType might have a mask
+    // parameter Type, according to VFABI. Regardless, this input CallInst,
+    // despite being a vectorized call, it will not have a masked operand.
     SmallVector<Value *, 8> Args;
     SmallVector<Type *, 8> CallTypes;
     for (auto [VFParam, STy] :
@@ -117,47 +116,21 @@ class VFABIParserTest : public ::testing::Test {
 
     // Mangled names do not currently encode return Type information. Generally,
     // return types are vectors, so use one.
-    Type *RetTy = ScalarFTy->getReturnType();
-    if (!RetTy->isVoidTy())
-      RetTy = VectorType::get(RetTy, Info.Shape.VF);
+    Type *VecRetTy = ScalarFTy->getReturnType();
+    if (!VecRetTy->isVoidTy())
+      VecRetTy = VectorType::get(VecRetTy, Info.Shape.VF);
 
     FunctionCallee F = M->getOrInsertFunction(
-        VectorName, FunctionType::get(RetTy, CallTypes, false));
+        VectorName, FunctionType::get(VecRetTy, CallTypes, false));
     std::unique_ptr<CallInst> CI(CallInst::Create(F, Args));
 
     // Use VFInfo and the mock CallInst to create a FunctionType that will
-    // include a mask where relevant.
-    auto OptVecFTyPos = VFABI::createFunctionType(Info, CI.get(), M.get());
+    // include a mask when relevant.
+    auto OptVecFTyPos =
+        VFABI::createFunctionType(Info, ScalarFTy, VecRetTy, M.get());
     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.
@@ -324,7 +297,7 @@ TEST_F(VFABIParserTest, LinearWithCompileTimeNegativeStep) {
   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
   EXPECT_FALSE(isMasked());
   EXPECT_TRUE(matchParametersNum());
-  EXPECT_FALSE(checkFunctionType()); // invalid: all operands are scalar
+  EXPECT_TRUE(checkFunctionType());
   EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_EQ(Parameters.size(), (unsigned)4);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Linear, -1}));
@@ -389,7 +362,7 @@ TEST_F(VFABIParserTest, LinearWithoutCompileTime) {
   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
   EXPECT_FALSE(isMasked());
   EXPECT_TRUE(matchParametersNum());
-  EXPECT_FALSE(checkFunctionType()); // invalid: all operands are scalar
+  EXPECT_TRUE(checkFunctionType());
   EXPECT_EQ(Parameters.size(), (unsigned)8);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Linear, 1}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearVal, 1}));
@@ -452,7 +425,7 @@ TEST_F(VFABIParserTest, ParseUniform) {
   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
   EXPECT_FALSE(isMasked());
   EXPECT_TRUE(matchParametersNum());
-  EXPECT_FALSE(checkFunctionType()); // invalid: all operands are scalar
+  EXPECT_TRUE(checkFunctionType());
   EXPECT_EQ(VF, ElementCount::getFixed(2));
   EXPECT_EQ(Parameters.size(), (unsigned)1);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Uniform, 0}));