llvm/unittests/IR/VectorBuilderTest.cpp

   1 //===--------- VectorBuilderTest.cpp - VectorBuilder unit tests -----------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/IR/VectorBuilder.h"
  10 #include "llvm/IR/Constants.h"
  11 #include "llvm/IR/IRBuilder.h"
  12 #include "llvm/IR/IntrinsicInst.h"
  13 #include "llvm/IR/LLVMContext.h"
  14 #include "llvm/IR/Module.h"
  15 #include "gtest/gtest.h"
  16
  17 using namespace llvm;
  18
  19 namespace {
  20
  21 static unsigned VectorNumElements = 8;
  22
  23 class VectorBuilderTest : public testing::Test {
  24 protected:
  25   LLVMContext Context;
  26
  27   VectorBuilderTest() : Context() {}
  28
  29   std::unique_ptr<Module> createBuilderModule(Function *&Func, BasicBlock *&BB,
  30                                               Value *&Mask, Value *&EVL) {
  31     auto Mod = std::make_unique<Module>("TestModule", Context);
  32     auto *Int32Ty = Type::getInt32Ty(Context);
  33     auto *Mask8Ty =
  34         FixedVectorType::get(Type::getInt1Ty(Context), VectorNumElements);
  35     auto *VoidFuncTy =
  36         FunctionType::get(Type::getVoidTy(Context), {Mask8Ty, Int32Ty}, false);
  37     Func =
  38         Function::Create(VoidFuncTy, GlobalValue::ExternalLinkage, "bla", *Mod);
  39     Mask = Func->getArg(0);
  40     EVL = Func->getArg(1);
  41     BB = BasicBlock::Create(Context, "entry", Func);
  42
  43     return Mod;
  44   }
  45 };
  46
  47 /// Check that creating binary arithmetic VP intrinsics works.
  48 TEST_F(VectorBuilderTest, TestCreateBinaryInstructions) {
  49   Function *F;
  50   BasicBlock *BB;
  51   Value *Mask, *EVL;
  52   auto Mod = createBuilderModule(F, BB, Mask, EVL);
  53
  54   IRBuilder<> Builder(BB);
  55   VectorBuilder VBuild(Builder);
  56   VBuild.setMask(Mask).setEVL(EVL);
  57
  58   auto *FloatVecTy =
  59       FixedVectorType::get(Type::getFloatTy(Context), VectorNumElements);
  60   auto *IntVecTy =
  61       FixedVectorType::get(Type::getInt32Ty(Context), VectorNumElements);
  62
  63 #define HANDLE_BINARY_INST(NUM, OPCODE, INSTCLASS)                             \
  64   {                                                                            \
  65     auto VPID = VPIntrinsic::getForOpcode(Instruction::OPCODE);                \
  66     bool IsFP = (#INSTCLASS)[0] == 'F';                                        \
  67     auto *ValueTy = IsFP ? FloatVecTy : IntVecTy;                              \
  68     Value *Op = UndefValue::get(ValueTy);                                      \
  69     auto *I = VBuild.createVectorInstruction(Instruction::OPCODE, ValueTy,     \
  70                                              {Op, Op});                        \
  71     ASSERT_TRUE(isa<VPIntrinsic>(I));                                          \
  72     auto *VPIntrin = cast<VPIntrinsic>(I);                                     \
  73     ASSERT_EQ(VPIntrin->getIntrinsicID(), VPID);                               \
  74     ASSERT_EQ(VPIntrin->getMaskParam(), Mask);                                 \
  75     ASSERT_EQ(VPIntrin->getVectorLengthParam(), EVL);                          \
  76   }
  77 #include "llvm/IR/Instruction.def"
  78 }
  79
  80 static bool isAllTrueMask(Value *Val, unsigned NumElements) {
  81   auto *ConstMask = dyn_cast<Constant>(Val);
  82   if (!ConstMask)
  83     return false;
  84
  85   // Structure check.
  86   if (!ConstMask->isAllOnesValue())
  87     return false;
  88
  89   // Type check.
  90   auto *MaskVecTy = cast<FixedVectorType>(ConstMask->getType());
  91   if (MaskVecTy->getNumElements() != NumElements)
  92     return false;
  93
  94   return MaskVecTy->getElementType()->isIntegerTy(1);
  95 }
  96
  97 /// Check that creating binary arithmetic VP intrinsics works.
  98 TEST_F(VectorBuilderTest, TestCreateBinaryInstructions_FixedVector_NoMask) {
  99   Function *F;
 100   BasicBlock *BB;
 101   Value *Mask, *EVL;
 102   auto Mod = createBuilderModule(F, BB, Mask, EVL);
 103
 104   IRBuilder<> Builder(BB);
 105   VectorBuilder VBuild(Builder);
 106   VBuild.setEVL(EVL).setStaticVL(VectorNumElements);
 107
 108   auto *FloatVecTy =
 109       FixedVectorType::get(Type::getFloatTy(Context), VectorNumElements);
 110   auto *IntVecTy =
 111       FixedVectorType::get(Type::getInt32Ty(Context), VectorNumElements);
 112
 113 #define HANDLE_BINARY_INST(NUM, OPCODE, INSTCLASS)                             \
 114   {                                                                            \
 115     auto VPID = VPIntrinsic::getForOpcode(Instruction::OPCODE);                \
 116     bool IsFP = (#INSTCLASS)[0] == 'F';                                        \
 117     Type *ValueTy = IsFP ? FloatVecTy : IntVecTy;                              \
 118     Value *Op = UndefValue::get(ValueTy);                                      \
 119     auto *I = VBuild.createVectorInstruction(Instruction::OPCODE, ValueTy,     \
 120                                              {Op, Op});                        \
 121     ASSERT_TRUE(isa<VPIntrinsic>(I));                                          \
 122     auto *VPIntrin = cast<VPIntrinsic>(I);                                     \
 123     ASSERT_EQ(VPIntrin->getIntrinsicID(), VPID);                               \
 124     ASSERT_TRUE(isAllTrueMask(VPIntrin->getMaskParam(), VectorNumElements));   \
 125     ASSERT_EQ(VPIntrin->getVectorLengthParam(), EVL);                          \
 126   }
 127 #include "llvm/IR/Instruction.def"
 128 }
 129
 130 static bool isLegalConstEVL(Value *Val, unsigned ExpectedEVL) {
 131   auto *ConstEVL = dyn_cast<ConstantInt>(Val);
 132   if (!ConstEVL)
 133     return false;
 134
 135   // Value check.
 136   if (ConstEVL->getZExtValue() != ExpectedEVL)
 137     return false;
 138
 139   // Type check.
 140   return ConstEVL->getType()->isIntegerTy(32);
 141 }
 142
 143 /// Check that creating binary arithmetic VP intrinsics works.
 144 TEST_F(VectorBuilderTest, TestCreateBinaryInstructions_FixedVector_NoEVL) {
 145   Function *F;
 146   BasicBlock *BB;
 147   Value *Mask, *EVL;
 148   auto Mod = createBuilderModule(F, BB, Mask, EVL);
 149
 150   IRBuilder<> Builder(BB);
 151   VectorBuilder VBuild(Builder);
 152   VBuild.setMask(Mask).setStaticVL(VectorNumElements);
 153
 154   auto *FloatVecTy =
 155       FixedVectorType::get(Type::getFloatTy(Context), VectorNumElements);
 156   auto *IntVecTy =
 157       FixedVectorType::get(Type::getInt32Ty(Context), VectorNumElements);
 158
 159 #define HANDLE_BINARY_INST(NUM, OPCODE, INSTCLASS)                             \
 160   {                                                                            \
 161     auto VPID = VPIntrinsic::getForOpcode(Instruction::OPCODE);                \
 162     bool IsFP = (#INSTCLASS)[0] == 'F';                                        \
 163     Type *ValueTy = IsFP ? FloatVecTy : IntVecTy;                              \
 164     Value *Op = UndefValue::get(ValueTy);                                      \
 165     auto *I = VBuild.createVectorInstruction(Instruction::OPCODE, ValueTy,     \
 166                                              {Op, Op});                        \
 167     ASSERT_TRUE(isa<VPIntrinsic>(I));                                          \
 168     auto *VPIntrin = cast<VPIntrinsic>(I);                                     \
 169     ASSERT_EQ(VPIntrin->getIntrinsicID(), VPID);                               \
 170     ASSERT_EQ(VPIntrin->getMaskParam(), Mask);                                 \
 171     ASSERT_TRUE(                                                               \
 172         isLegalConstEVL(VPIntrin->getVectorLengthParam(), VectorNumElements)); \
 173   }
 174 #include "llvm/IR/Instruction.def"
 175 }
 176
 177 /// Check that creating binary arithmetic VP intrinsics works.
 178 TEST_F(VectorBuilderTest,
 179        TestCreateBinaryInstructions_FixedVector_NoMask_NoEVL) {
 180   Function *F;
 181   BasicBlock *BB;
 182   Value *Mask, *EVL;
 183   auto Mod = createBuilderModule(F, BB, Mask, EVL);
 184
 185   IRBuilder<> Builder(BB);
 186   VectorBuilder VBuild(Builder);
 187   VBuild.setStaticVL(VectorNumElements);
 188
 189   auto *FloatVecTy =
 190       FixedVectorType::get(Type::getFloatTy(Context), VectorNumElements);
 191   auto *IntVecTy =
 192       FixedVectorType::get(Type::getInt32Ty(Context), VectorNumElements);
 193
 194 #define HANDLE_BINARY_INST(NUM, OPCODE, INSTCLASS)                             \
 195   {                                                                            \
 196     auto VPID = VPIntrinsic::getForOpcode(Instruction::OPCODE);                \
 197     bool IsFP = (#INSTCLASS)[0] == 'F';                                        \
 198     Type *ValueTy = IsFP ? FloatVecTy : IntVecTy;                              \
 199     Value *Op = UndefValue::get(ValueTy);                                      \
 200     auto *I = VBuild.createVectorInstruction(Instruction::OPCODE, ValueTy,     \
 201                                              {Op, Op});                        \
 202     ASSERT_TRUE(isa<VPIntrinsic>(I));                                          \
 203     auto *VPIntrin = cast<VPIntrinsic>(I);                                     \
 204     ASSERT_EQ(VPIntrin->getIntrinsicID(), VPID);                               \
 205     ASSERT_TRUE(isAllTrueMask(VPIntrin->getMaskParam(), VectorNumElements));   \
 206     ASSERT_TRUE(                                                               \
 207         isLegalConstEVL(VPIntrin->getVectorLengthParam(), VectorNumElements)); \
 208   }
 209 #include "llvm/IR/Instruction.def"
 210 }
 211 /// Check that creating vp.load/vp.store works.
 212 TEST_F(VectorBuilderTest, TestCreateLoadStore) {
 213   Function *F;
 214   BasicBlock *BB;
 215   Value *Mask, *EVL;
 216   auto Mod = createBuilderModule(F, BB, Mask, EVL);
 217
 218   IRBuilder<> Builder(BB);
 219   VectorBuilder VBuild(Builder);
 220   VBuild.setMask(Mask).setEVL(EVL);
 221
 222   auto *FloatVecTy =
 223       FixedVectorType::get(Type::getFloatTy(Context), VectorNumElements);
 224   auto *FloatVecPtrTy = FloatVecTy->getPointerTo();
 225
 226   Value *FloatVecPtr = UndefValue::get(FloatVecPtrTy);
 227   Value *FloatVec = UndefValue::get(FloatVecTy);
 228
 229   // vp.load
 230   auto LoadVPID = VPIntrinsic::getForOpcode(Instruction::Load);
 231   auto *LoadIntrin = VBuild.createVectorInstruction(Instruction::Load,
 232                                                     FloatVecTy, {FloatVecPtr});
 233   ASSERT_TRUE(isa<VPIntrinsic>(LoadIntrin));
 234   auto *VPLoad = cast<VPIntrinsic>(LoadIntrin);
 235   ASSERT_EQ(VPLoad->getIntrinsicID(), LoadVPID);
 236   ASSERT_EQ(VPLoad->getMemoryPointerParam(), FloatVecPtr);
 237
 238   // vp.store
 239   auto *VoidTy = Builder.getVoidTy();
 240   auto StoreVPID = VPIntrinsic::getForOpcode(Instruction::Store);
 241   auto *StoreIntrin = VBuild.createVectorInstruction(Instruction::Store, VoidTy,
 242                                                      {FloatVec, FloatVecPtr});
 243   ASSERT_TRUE(isa<VPIntrinsic>(LoadIntrin));
 244   auto *VPStore = cast<VPIntrinsic>(StoreIntrin);
 245   ASSERT_EQ(VPStore->getIntrinsicID(), StoreVPID);
 246   ASSERT_EQ(VPStore->getMemoryPointerParam(), FloatVecPtr);
 247   ASSERT_EQ(VPStore->getMemoryDataParam(), FloatVec);
 248 }
 249
 250 /// Check that the SilentlyReturnNone error handling mode works.
 251 TEST_F(VectorBuilderTest, TestFail_SilentlyReturnNone) {
 252   Function *F;
 253   BasicBlock *BB;
 254   Value *Mask, *EVL;
 255   auto Mod = createBuilderModule(F, BB, Mask, EVL);
 256
 257   IRBuilder<> Builder(BB);
 258   auto *VoidTy = Builder.getVoidTy();
 259   VectorBuilder VBuild(Builder, VectorBuilder::Behavior::SilentlyReturnNone);
 260   VBuild.setMask(Mask).setEVL(EVL);
 261   auto *Val = VBuild.createVectorInstruction(Instruction::Br, VoidTy, {});
 262   ASSERT_EQ(Val, nullptr);
 263 }
 264
 265 /// Check that the ReportAndFail error handling mode aborts as advertised.
 266 TEST_F(VectorBuilderTest, TestFail_ReportAndAbort) {
 267   Function *F;
 268   BasicBlock *BB;
 269   Value *Mask, *EVL;
 270   auto Mod = createBuilderModule(F, BB, Mask, EVL);
 271
 272   IRBuilder<> Builder(BB);
 273   auto *VoidTy = Builder.getVoidTy();
 274   VectorBuilder VBuild(Builder, VectorBuilder::Behavior::ReportAndAbort);
 275   VBuild.setMask(Mask).setEVL(EVL);
 276   ASSERT_DEATH({ VBuild.createVectorInstruction(Instruction::Br, VoidTy, {}); },
 277                "No VPIntrinsic for this opcode");
 278 }
 279
 280 } // end anonymous namespace