unittests/CodeGen/LowLevelTypeTest.cpp

   1 //===- llvm/unittest/CodeGen/GlobalISel/LowLevelTypeTest.cpp --------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/CodeGen/LowLevelType.h"
  11 #include "llvm/IR/DataLayout.h"
  12 #include "llvm/IR/DerivedTypes.h"
  13 #include "llvm/IR/LLVMContext.h"
  14 #include "llvm/IR/Type.h"
  15 #include "gtest/gtest.h"
  16
  17 using namespace llvm;
  18
  19 // Define a pretty printer to help debugging when things go wrong.
  20 namespace llvm {
  21 std::ostream &
  22 operator<<(std::ostream &OS, const llvm::LLT Ty) {
  23   std::string Repr;
  24   raw_string_ostream SS{Repr};
  25   Ty.print(SS);
  26   OS << SS.str();
  27   return OS;
  28 }
  29 }
  30
  31 namespace {
  32
  33 TEST(LowLevelTypeTest, Scalar) {
  34   LLVMContext C;
  35   DataLayout DL("");
  36
  37   for (unsigned S : {1U, 17U, 32U, 64U, 0xfffffU}) {
  38     const LLT Ty = LLT::scalar(S);
  39
  40     // Test kind.
  41     ASSERT_TRUE(Ty.isValid());
  42     ASSERT_TRUE(Ty.isScalar());
  43
  44     ASSERT_FALSE(Ty.isPointer());
  45     ASSERT_FALSE(Ty.isVector());
  46
  47     // Test sizes.
  48     EXPECT_EQ(S, Ty.getSizeInBits());
  49     EXPECT_EQ(S, Ty.getScalarSizeInBits());
  50
  51     // Test equality operators.
  52     EXPECT_TRUE(Ty == Ty);
  53     EXPECT_FALSE(Ty != Ty);
  54
  55     // Test Type->LLT conversion.
  56     Type *IRTy = IntegerType::get(C, S);
  57     EXPECT_EQ(Ty, getLLTForType(*IRTy, DL));
  58   }
  59 }
  60
  61 TEST(LowLevelTypeTest, Vector) {
  62   LLVMContext C;
  63   DataLayout DL("");
  64
  65   for (unsigned S : {1U, 17U, 32U, 64U, 0xfffU}) {
  66     for (uint16_t Elts : {2U, 3U, 4U, 32U, 0xffU}) {
  67       const LLT STy = LLT::scalar(S);
  68       const LLT VTy = LLT::vector(Elts, S);
  69
  70       // Test the alternative vector().
  71       {
  72         const LLT VSTy = LLT::vector(Elts, STy);
  73         EXPECT_EQ(VTy, VSTy);
  74       }
  75
  76       // Test getElementType().
  77       EXPECT_EQ(STy, VTy.getElementType());
  78
  79       // Test kind.
  80       ASSERT_TRUE(VTy.isValid());
  81       ASSERT_TRUE(VTy.isVector());
  82
  83       ASSERT_FALSE(VTy.isScalar());
  84       ASSERT_FALSE(VTy.isPointer());
  85
  86       // Test sizes.
  87       EXPECT_EQ(S * Elts, VTy.getSizeInBits());
  88       EXPECT_EQ(S, VTy.getScalarSizeInBits());
  89       EXPECT_EQ(Elts, VTy.getNumElements());
  90
  91       // Test equality operators.
  92       EXPECT_TRUE(VTy == VTy);
  93       EXPECT_FALSE(VTy != VTy);
  94
  95       // Test inequality operators on..
  96       // ..different kind.
  97       EXPECT_NE(VTy, STy);
  98
  99       // Test Type->LLT conversion.
 100       Type *IRSTy = IntegerType::get(C, S);
 101       Type *IRTy = VectorType::get(IRSTy, Elts);
 102       EXPECT_EQ(VTy, getLLTForType(*IRTy, DL));
 103     }
 104   }
 105 }
 106
 107 TEST(LowLevelTypeTest, Pointer) {
 108   LLVMContext C;
 109   DataLayout DL("");
 110
 111   for (unsigned AS : {0U, 1U, 127U, 0xffffU}) {
 112     const LLT Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
 113     const LLT VTy = LLT::vector(4, Ty);
 114
 115     // Test kind.
 116     ASSERT_TRUE(Ty.isValid());
 117     ASSERT_TRUE(Ty.isPointer());
 118
 119     ASSERT_FALSE(Ty.isScalar());
 120     ASSERT_FALSE(Ty.isVector());
 121
 122     ASSERT_TRUE(VTy.isValid());
 123     ASSERT_TRUE(VTy.isVector());
 124     ASSERT_TRUE(VTy.getElementType().isPointer());
 125
 126     // Test addressspace.
 127     EXPECT_EQ(AS, Ty.getAddressSpace());
 128     EXPECT_EQ(AS, VTy.getElementType().getAddressSpace());
 129
 130     // Test equality operators.
 131     EXPECT_TRUE(Ty == Ty);
 132     EXPECT_FALSE(Ty != Ty);
 133     EXPECT_TRUE(VTy == VTy);
 134     EXPECT_FALSE(VTy != VTy);
 135
 136     // Test Type->LLT conversion.
 137     Type *IRTy = PointerType::get(IntegerType::get(C, 8), AS);
 138     EXPECT_EQ(Ty, getLLTForType(*IRTy, DL));
 139     Type *IRVTy =
 140         VectorType::get(PointerType::get(IntegerType::get(C, 8), AS), 4);
 141     EXPECT_EQ(VTy, getLLTForType(*IRVTy, DL));
 142   }
 143 }
 144
 145 TEST(LowLevelTypeTest, Invalid) {
 146   const LLT Ty;
 147
 148   ASSERT_FALSE(Ty.isValid());
 149   ASSERT_FALSE(Ty.isScalar());
 150   ASSERT_FALSE(Ty.isPointer());
 151   ASSERT_FALSE(Ty.isVector());
 152 }
 153
 154 }