unittests/CodeGen/LowLevelTypeTest.cpp

   1 //===- llvm/unittest/CodeGen/GlobalISel/LowLevelTypeTest.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/LowLevelType.h"
  10 #include "llvm/IR/DataLayout.h"
  11 #include "llvm/IR/DerivedTypes.h"
  12 #include "llvm/IR/LLVMContext.h"
  13 #include "llvm/IR/Type.h"
  14 #include "gtest/gtest.h"
  15
  16 using namespace llvm;
  17
  18 namespace {
  19
  20 TEST(LowLevelTypeTest, Scalar) {
  21   LLVMContext C;
  22   DataLayout DL("");
  23
  24   for (unsigned S : {1U, 17U, 32U, 64U, 0xfffffU}) {
  25     const LLT Ty = LLT::scalar(S);
  26
  27     // Test kind.
  28     ASSERT_TRUE(Ty.isValid());
  29     ASSERT_TRUE(Ty.isScalar());
  30
  31     ASSERT_FALSE(Ty.isPointer());
  32     ASSERT_FALSE(Ty.isVector());
  33
  34     // Test sizes.
  35     EXPECT_EQ(S, Ty.getSizeInBits());
  36     EXPECT_EQ(S, Ty.getScalarSizeInBits());
  37
  38     // Test equality operators.
  39     EXPECT_TRUE(Ty == Ty);
  40     EXPECT_FALSE(Ty != Ty);
  41
  42     // Test Type->LLT conversion.
  43     Type *IRTy = IntegerType::get(C, S);
  44     EXPECT_EQ(Ty, getLLTForType(*IRTy, DL));
  45   }
  46 }
  47
  48 TEST(LowLevelTypeTest, Vector) {
  49   LLVMContext C;
  50   DataLayout DL("");
  51
  52   for (unsigned S : {1U, 17U, 32U, 64U, 0xfffU}) {
  53     for (uint16_t Elts : {2U, 3U, 4U, 32U, 0xffU}) {
  54       const LLT STy = LLT::scalar(S);
  55       const LLT VTy = LLT::vector(Elts, S);
  56
  57       // Test the alternative vector().
  58       {
  59         const LLT VSTy = LLT::vector(Elts, STy);
  60         EXPECT_EQ(VTy, VSTy);
  61       }
  62
  63       // Test getElementType().
  64       EXPECT_EQ(STy, VTy.getElementType());
  65
  66       // Test kind.
  67       ASSERT_TRUE(VTy.isValid());
  68       ASSERT_TRUE(VTy.isVector());
  69
  70       ASSERT_FALSE(VTy.isScalar());
  71       ASSERT_FALSE(VTy.isPointer());
  72
  73       // Test sizes.
  74       EXPECT_EQ(S * Elts, VTy.getSizeInBits());
  75       EXPECT_EQ(S, VTy.getScalarSizeInBits());
  76       EXPECT_EQ(Elts, VTy.getNumElements());
  77
  78       // Test equality operators.
  79       EXPECT_TRUE(VTy == VTy);
  80       EXPECT_FALSE(VTy != VTy);
  81
  82       // Test inequality operators on..
  83       // ..different kind.
  84       EXPECT_NE(VTy, STy);
  85
  86       // Test Type->LLT conversion.
  87       Type *IRSTy = IntegerType::get(C, S);
  88       Type *IRTy = VectorType::get(IRSTy, Elts);
  89       EXPECT_EQ(VTy, getLLTForType(*IRTy, DL));
  90     }
  91   }
  92 }
  93
  94 TEST(LowLevelTypeTest, ScalarOrVector) {
  95   // Test version with number of bits for scalar type.
  96   EXPECT_EQ(LLT::scalar(32), LLT::scalarOrVector(1, 32));
  97   EXPECT_EQ(LLT::vector(2, 32), LLT::scalarOrVector(2, 32));
  98
  99   // Test version with LLT for scalar type.
 100   EXPECT_EQ(LLT::scalar(32), LLT::scalarOrVector(1, LLT::scalar(32)));
 101   EXPECT_EQ(LLT::vector(2, 32), LLT::scalarOrVector(2, LLT::scalar(32)));
 102
 103   // Test with pointer elements.
 104   EXPECT_EQ(LLT::pointer(1, 32), LLT::scalarOrVector(1, LLT::pointer(1, 32)));
 105   EXPECT_EQ(LLT::vector(2, LLT::pointer(1, 32)),
 106             LLT::scalarOrVector(2, LLT::pointer(1, 32)));
 107 }
 108
 109 TEST(LowLevelTypeTest, ChangeElementType) {
 110   const LLT P0 = LLT::pointer(0, 32);
 111   const LLT P1 = LLT::pointer(1, 64);
 112
 113   const LLT S32 = LLT::scalar(32);
 114   const LLT S64 = LLT::scalar(64);
 115
 116   const LLT V2S32 = LLT::vector(2, 32);
 117   const LLT V2S64 = LLT::vector(2, 64);
 118
 119   const LLT V2P0 = LLT::vector(2, P0);
 120   const LLT V2P1 = LLT::vector(2, P1);
 121
 122   EXPECT_EQ(S64, S32.changeElementType(S64));
 123   EXPECT_EQ(S32, S32.changeElementType(S32));
 124
 125   EXPECT_EQ(S32, S64.changeElementSize(32));
 126   EXPECT_EQ(S32, S32.changeElementSize(32));
 127
 128   EXPECT_EQ(V2S64, V2S32.changeElementType(S64));
 129   EXPECT_EQ(V2S32, V2S64.changeElementType(S32));
 130
 131   EXPECT_EQ(V2S64, V2S32.changeElementSize(64));
 132   EXPECT_EQ(V2S32, V2S64.changeElementSize(32));
 133
 134   EXPECT_EQ(P0, S32.changeElementType(P0));
 135   EXPECT_EQ(S32, P0.changeElementType(S32));
 136
 137   EXPECT_EQ(V2P1, V2P0.changeElementType(P1));
 138   EXPECT_EQ(V2S32, V2P0.changeElementType(S32));
 139 }
 140
 141 #ifdef GTEST_HAS_DEATH_TEST
 142 #ifndef NDEBUG
 143
 144 // Invalid to directly change the element size for pointers.
 145 TEST(LowLevelTypeTest, ChangeElementTypeDeath) {
 146   const LLT P0 = LLT::pointer(0, 32);
 147   const LLT V2P0 = LLT::vector(2, P0);
 148
 149   EXPECT_DEATH(P0.changeElementSize(64),
 150                "invalid to directly change element size for pointers");
 151   EXPECT_DEATH(V2P0.changeElementSize(64),
 152                "invalid to directly change element size for pointers");
 153
 154   // Make sure this still fails even without a change in size.
 155   EXPECT_DEATH(P0.changeElementSize(32),
 156                "invalid to directly change element size for pointers");
 157   EXPECT_DEATH(V2P0.changeElementSize(32),
 158                "invalid to directly change element size for pointers");
 159 }
 160
 161 #endif
 162 #endif
 163
 164 TEST(LowLevelTypeTest, Pointer) {
 165   LLVMContext C;
 166   DataLayout DL("p64:64:64-p127:512:512:512-p16777215:65528:8");
 167
 168   for (unsigned AS : {0U, 1U, 127U, 0xffffU,
 169         static_cast<unsigned>(maxUIntN(23)),
 170         static_cast<unsigned>(maxUIntN(24))}) {
 171     for (unsigned NumElts : {2, 3, 4, 256, 65535}) {
 172       const LLT Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
 173       const LLT VTy = LLT::vector(NumElts, Ty);
 174
 175       // Test kind.
 176       ASSERT_TRUE(Ty.isValid());
 177       ASSERT_TRUE(Ty.isPointer());
 178
 179       ASSERT_FALSE(Ty.isScalar());
 180       ASSERT_FALSE(Ty.isVector());
 181
 182       ASSERT_TRUE(VTy.isValid());
 183       ASSERT_TRUE(VTy.isVector());
 184       ASSERT_TRUE(VTy.getElementType().isPointer());
 185
 186       EXPECT_EQ(Ty, VTy.getElementType());
 187       EXPECT_EQ(Ty.getSizeInBits(), VTy.getScalarSizeInBits());
 188
 189       // Test address space.
 190       EXPECT_EQ(AS, Ty.getAddressSpace());
 191       EXPECT_EQ(AS, VTy.getElementType().getAddressSpace());
 192
 193       // Test equality operators.
 194       EXPECT_TRUE(Ty == Ty);
 195       EXPECT_FALSE(Ty != Ty);
 196       EXPECT_TRUE(VTy == VTy);
 197       EXPECT_FALSE(VTy != VTy);
 198
 199       // Test Type->LLT conversion.
 200       Type *IRTy = PointerType::get(IntegerType::get(C, 8), AS);
 201       EXPECT_EQ(Ty, getLLTForType(*IRTy, DL));
 202       Type *IRVTy =
 203         VectorType::get(PointerType::get(IntegerType::get(C, 8), AS), NumElts);
 204       EXPECT_EQ(VTy, getLLTForType(*IRVTy, DL));
 205     }
 206   }
 207 }
 208
 209 TEST(LowLevelTypeTest, Invalid) {
 210   const LLT Ty;
 211
 212   ASSERT_FALSE(Ty.isValid());
 213   ASSERT_FALSE(Ty.isScalar());
 214   ASSERT_FALSE(Ty.isPointer());
 215   ASSERT_FALSE(Ty.isVector());
 216 }
 217
 218 }