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, Pointer) {
110   LLVMContext C;
111   DataLayout DL("p64:64:64-p127:512:512:512-p16777215:65528:8");
112 
113   for (unsigned AS : {0U, 1U, 127U, 0xffffU,
114         static_cast<unsigned>(maxUIntN(23)),
115         static_cast<unsigned>(maxUIntN(24))}) {
116     for (unsigned NumElts : {2, 3, 4, 256, 65535}) {
117       const LLT Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS));
118       const LLT VTy = LLT::vector(NumElts, Ty);
119 
120       // Test kind.
121       ASSERT_TRUE(Ty.isValid());
122       ASSERT_TRUE(Ty.isPointer());
123 
124       ASSERT_FALSE(Ty.isScalar());
125       ASSERT_FALSE(Ty.isVector());
126 
127       ASSERT_TRUE(VTy.isValid());
128       ASSERT_TRUE(VTy.isVector());
129       ASSERT_TRUE(VTy.getElementType().isPointer());
130 
131       EXPECT_EQ(Ty, VTy.getElementType());
132       EXPECT_EQ(Ty.getSizeInBits(), VTy.getScalarSizeInBits());
133 
134       // Test address space.
135       EXPECT_EQ(AS, Ty.getAddressSpace());
136       EXPECT_EQ(AS, VTy.getElementType().getAddressSpace());
137 
138       // Test equality operators.
139       EXPECT_TRUE(Ty == Ty);
140       EXPECT_FALSE(Ty != Ty);
141       EXPECT_TRUE(VTy == VTy);
142       EXPECT_FALSE(VTy != VTy);
143 
144       // Test Type->LLT conversion.
145       Type *IRTy = PointerType::get(IntegerType::get(C, 8), AS);
146       EXPECT_EQ(Ty, getLLTForType(*IRTy, DL));
147       Type *IRVTy =
148         VectorType::get(PointerType::get(IntegerType::get(C, 8), AS), NumElts);
149       EXPECT_EQ(VTy, getLLTForType(*IRVTy, DL));
150     }
151   }
152 }
153 
154 TEST(LowLevelTypeTest, Invalid) {
155   const LLT Ty;
156 
157   ASSERT_FALSE(Ty.isValid());
158   ASSERT_FALSE(Ty.isScalar());
159   ASSERT_FALSE(Ty.isPointer());
160   ASSERT_FALSE(Ty.isVector());
161 }
162 
163 }
164