unittests/CodeGen/ScalableVectorMVTsTest.cpp

   1 //===-------- llvm/unittest/CodeGen/ScalableVectorMVTsTest.cpp ------------===//
   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/CodeGen/ValueTypes.h"
  10 #include "llvm/IR/DerivedTypes.h"
  11 #include "llvm/IR/LLVMContext.h"
  12 #include "llvm/Support/MachineValueType.h"
  13 #include "llvm/Support/ScalableSize.h"
  14 #include "gtest/gtest.h"
  15
  16 using namespace llvm;
  17
  18 namespace {
  19
  20 TEST(ScalableVectorMVTsTest, IntegerMVTs) {
  21   for (auto VecTy : MVT::integer_scalable_vector_valuetypes()) {
  22     ASSERT_TRUE(VecTy.isValid());
  23     ASSERT_TRUE(VecTy.isInteger());
  24     ASSERT_TRUE(VecTy.isVector());
  25     ASSERT_TRUE(VecTy.isScalableVector());
  26     ASSERT_TRUE(VecTy.getScalarType().isValid());
  27
  28     ASSERT_FALSE(VecTy.isFloatingPoint());
  29   }
  30 }
  31
  32 TEST(ScalableVectorMVTsTest, FloatMVTs) {
  33   for (auto VecTy : MVT::fp_scalable_vector_valuetypes()) {
  34     ASSERT_TRUE(VecTy.isValid());
  35     ASSERT_TRUE(VecTy.isFloatingPoint());
  36     ASSERT_TRUE(VecTy.isVector());
  37     ASSERT_TRUE(VecTy.isScalableVector());
  38     ASSERT_TRUE(VecTy.getScalarType().isValid());
  39
  40     ASSERT_FALSE(VecTy.isInteger());
  41   }
  42 }
  43
  44 TEST(ScalableVectorMVTsTest, HelperFuncs) {
  45   LLVMContext Ctx;
  46
  47   // Create with scalable flag
  48   EVT Vnx4i32 = EVT::getVectorVT(Ctx, MVT::i32, 4, /*Scalable=*/true);
  49   ASSERT_TRUE(Vnx4i32.isScalableVector());
  50
  51   // Create with separate llvm::ElementCount
  52   auto EltCnt = ElementCount(2, true);
  53   EVT Vnx2i32 = EVT::getVectorVT(Ctx, MVT::i32, EltCnt);
  54   ASSERT_TRUE(Vnx2i32.isScalableVector());
  55
  56   // Create with inline llvm::ElementCount
  57   EVT Vnx2i64 = EVT::getVectorVT(Ctx, MVT::i64, {2, true});
  58   ASSERT_TRUE(Vnx2i64.isScalableVector());
  59
  60   // Check that changing scalar types/element count works
  61   EXPECT_EQ(Vnx2i32.widenIntegerVectorElementType(Ctx), Vnx2i64);
  62   EXPECT_EQ(Vnx4i32.getHalfNumVectorElementsVT(Ctx), Vnx2i32);
  63
  64   // Check that overloaded '*' and '/' operators work
  65   EXPECT_EQ(EVT::getVectorVT(Ctx, MVT::i64, EltCnt * 2), MVT::nxv4i64);
  66   EXPECT_EQ(EVT::getVectorVT(Ctx, MVT::i64, EltCnt / 2), MVT::nxv1i64);
  67
  68   // Check that float->int conversion works
  69   EVT Vnx2f64 = EVT::getVectorVT(Ctx, MVT::f64, {2, true});
  70   EXPECT_EQ(Vnx2f64.changeTypeToInteger(), Vnx2i64);
  71
  72   // Check fields inside llvm::ElementCount
  73   EltCnt = Vnx4i32.getVectorElementCount();
  74   EXPECT_EQ(EltCnt.Min, 4U);
  75   ASSERT_TRUE(EltCnt.Scalable);
  76
  77   // Check that fixed-length vector types aren't scalable.
  78   EVT V8i32 = EVT::getVectorVT(Ctx, MVT::i32, 8);
  79   ASSERT_FALSE(V8i32.isScalableVector());
  80   EVT V4f64 = EVT::getVectorVT(Ctx, MVT::f64, {4, false});
  81   ASSERT_FALSE(V4f64.isScalableVector());
  82
  83   // Check that llvm::ElementCount works for fixed-length types.
  84   EltCnt = V8i32.getVectorElementCount();
  85   EXPECT_EQ(EltCnt.Min, 8U);
  86   ASSERT_FALSE(EltCnt.Scalable);
  87 }
  88
  89 TEST(ScalableVectorMVTsTest, IRToVTTranslation) {
  90   LLVMContext Ctx;
  91
  92   Type *Int64Ty = Type::getInt64Ty(Ctx);
  93   VectorType *ScV8Int64Ty = VectorType::get(Int64Ty, {8, true});
  94
  95   // Check that we can map a scalable IR type to an MVT
  96   MVT Mnxv8i64 = MVT::getVT(ScV8Int64Ty);
  97   ASSERT_TRUE(Mnxv8i64.isScalableVector());
  98   ASSERT_EQ(ScV8Int64Ty->getElementCount(), Mnxv8i64.getVectorElementCount());
  99   ASSERT_EQ(MVT::getVT(ScV8Int64Ty->getElementType()),
 100             Mnxv8i64.getScalarType());
 101
 102   // Check that we can map a scalable IR type to an EVT
 103   EVT Enxv8i64 = EVT::getEVT(ScV8Int64Ty);
 104   ASSERT_TRUE(Enxv8i64.isScalableVector());
 105   ASSERT_EQ(ScV8Int64Ty->getElementCount(), Enxv8i64.getVectorElementCount());
 106   ASSERT_EQ(EVT::getEVT(ScV8Int64Ty->getElementType()),
 107             Enxv8i64.getScalarType());
 108 }
 109
 110 TEST(ScalableVectorMVTsTest, VTToIRTranslation) {
 111   LLVMContext Ctx;
 112
 113   EVT Enxv4f64 = EVT::getVectorVT(Ctx, MVT::f64, {4, true});
 114
 115   Type *Ty = Enxv4f64.getTypeForEVT(Ctx);
 116   VectorType *ScV4Float64Ty = cast<VectorType>(Ty);
 117   ASSERT_TRUE(ScV4Float64Ty->isScalable());
 118   ASSERT_EQ(Enxv4f64.getVectorElementCount(), ScV4Float64Ty->getElementCount());
 119   ASSERT_EQ(Enxv4f64.getScalarType().getTypeForEVT(Ctx),
 120             ScV4Float64Ty->getElementType());
 121 }
 122
 123 } // end anonymous namespace