Fix crash when getVFABIMappings is called with an indirect call instruction

[fpetrogalli]

llvm/unittests/Analysis/VectorFunctionABITest.cpp

12

Is this needed?

634

Very elegant, but is this unique_ptr needed?

[sanwou01]

llvm/unittests/Analysis/VectorFunctionABITest.cpp

12

For the definition of parseAssemblyString, yes.

634

"borrowed" from other unit tests, so I can only take credit for finding it. I do think the unique_ptr is needed: parseAssemblyString passes ownership of the Module to us, so it'd be rude to drop it on the floor.

[fpetrogalli]

Thank you @sanwou01 ! LGTM, with a nit: please double check those header included are needed before submitting.

Cheers,

Francesco

llvm/unittests/Analysis/VectorFunctionABITest.cpp

12

Are you sure? parseAssemblyString is used on line 26, it works even without this include line. Can you double check this before submitting? Same for <memory>

634

:facepalm:, yes, I used unique_ptr too in the tests class VFABIParserTest. My bad.

llvm/include/llvm/Analysis/VectorUtils.h

class VFDatabase {
   /// List of vector functions descriptors associated to the call
   /// instruction.
   const SmallVector<VFInfo, 8> ScalarToVectorMappings;
 
   /// Retrieve the scalar-to-vector mappings associated to the rule of
   /// a vector Function ABI.
   static void getVFABIMappings(const CallInst &CI,
                                SmallVectorImpl<VFInfo> &Mappings) {
+    if (CI.isIndirectCall())
+      return;
+
     const StringRef ScalarName = CI.getCalledFunction()->getName();
 
     SmallVector<std::string, 8> ListOfStrings;
     // The check for the vector-function-abi-variant attribute is done when
     // retrieving the vector variant names here.
     VFABI::getVectorVariantNames(CI, ListOfStrings);
     if (ListOfStrings.empty())
       return;

llvm/unittests/Analysis/VectorFunctionABITest.cpp

 //===------- VectorFunctionABITest.cpp - VFABI Unittests  ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/InstIterator.h"
+#include "llvm/IRReader/IRReader.h"
 #include "gtest/gtest.h"
+#include <memory>
 
 using namespace llvm;
 
 namespace {
 // Test fixture needed that holds the veariables needed by the parser.
 class VFABIParserTest : public ::testing::Test {
 private:
   // Parser output.

 }
 
 TEST_F(VFABIParserTest, ZeroIsInvalidVLEN) {
   EXPECT_FALSE(invokeParser("_ZGVeM0v_sin"));
   EXPECT_FALSE(invokeParser("_ZGVeN0v_sin"));
   EXPECT_FALSE(invokeParser("_ZGVsM0v_sin"));
   EXPECT_FALSE(invokeParser("_ZGVsN0v_sin"));
 }
+
+static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) {
+  SMDiagnostic Err;
+  std::unique_ptr<Module> Mod = parseAssemblyString(IR, Err, C);
+  if (!Mod)
+    Err.print("VectorFunctionABITests", errs());
+  return Mod;
+}
+
+TEST(VFABIGetMappingsTest, IndirectCallInst) {
+  LLVMContext C;
+  std::unique_ptr<Module> M = parseIR(C, R"IR(
+define void @call(void () * %f) {
+entry:
+  call void %f()
+  ret void
+}
+)IR");
+  auto F = dyn_cast_or_null<Function>(M->getNamedValue("call"));
+  ASSERT_TRUE(F);
+  auto CI = dyn_cast<CallInst>(&F->front().front());
+  ASSERT_TRUE(CI);
+  ASSERT_TRUE(CI->isIndirectCall());
+  auto Mappings = VFDatabase::getMappings(*CI);
+  EXPECT_EQ(Mappings.size(), (unsigned)0);
+}