1 //===--- llvm/unittest/IR/VectorTypesTest.cpp - vector types 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/DerivedTypes.h"
10 #include "llvm/IR/LLVMContext.h"
11 #include "llvm/Support/ScalableSize.h"
12 #include "gtest/gtest.h"
13 using namespace llvm;
14 
15 namespace {
TEST(VectorTypesTest,FixedLength)16 TEST(VectorTypesTest, FixedLength) {
17   LLVMContext Ctx;
18 
19   Type *Int16Ty = Type::getInt16Ty(Ctx);
20   Type *Int32Ty = Type::getInt32Ty(Ctx);
21   Type *Int64Ty = Type::getInt64Ty(Ctx);
22   Type *Float64Ty = Type::getDoubleTy(Ctx);
23 
24   VectorType *V8Int32Ty = VectorType::get(Int32Ty, 8);
25   ASSERT_FALSE(V8Int32Ty->isScalable());
26   EXPECT_EQ(V8Int32Ty->getNumElements(), 8U);
27   EXPECT_EQ(V8Int32Ty->getElementType()->getScalarSizeInBits(), 32U);
28 
29   VectorType *V8Int16Ty = VectorType::get(Int16Ty, {8, false});
30   ASSERT_FALSE(V8Int16Ty->isScalable());
31   EXPECT_EQ(V8Int16Ty->getNumElements(), 8U);
32   EXPECT_EQ(V8Int16Ty->getElementType()->getScalarSizeInBits(), 16U);
33 
34   ElementCount EltCnt(4, false);
35   VectorType *V4Int64Ty = VectorType::get(Int64Ty, EltCnt);
36   ASSERT_FALSE(V4Int64Ty->isScalable());
37   EXPECT_EQ(V4Int64Ty->getNumElements(), 4U);
38   EXPECT_EQ(V4Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
39 
40   VectorType *V2Int64Ty = VectorType::get(Int64Ty, EltCnt/2);
41   ASSERT_FALSE(V2Int64Ty->isScalable());
42   EXPECT_EQ(V2Int64Ty->getNumElements(), 2U);
43   EXPECT_EQ(V2Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
44 
45   VectorType *V8Int64Ty = VectorType::get(Int64Ty, EltCnt*2);
46   ASSERT_FALSE(V8Int64Ty->isScalable());
47   EXPECT_EQ(V8Int64Ty->getNumElements(), 8U);
48   EXPECT_EQ(V8Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
49 
50   VectorType *V4Float64Ty = VectorType::get(Float64Ty, EltCnt);
51   ASSERT_FALSE(V4Float64Ty->isScalable());
52   EXPECT_EQ(V4Float64Ty->getNumElements(), 4U);
53   EXPECT_EQ(V4Float64Ty->getElementType()->getScalarSizeInBits(), 64U);
54 
55   VectorType *ExtTy = VectorType::getExtendedElementVectorType(V8Int16Ty);
56   EXPECT_EQ(ExtTy, V8Int32Ty);
57   ASSERT_FALSE(ExtTy->isScalable());
58   EXPECT_EQ(ExtTy->getNumElements(), 8U);
59   EXPECT_EQ(ExtTy->getElementType()->getScalarSizeInBits(), 32U);
60 
61   VectorType *TruncTy = VectorType::getTruncatedElementVectorType(V8Int32Ty);
62   EXPECT_EQ(TruncTy, V8Int16Ty);
63   ASSERT_FALSE(TruncTy->isScalable());
64   EXPECT_EQ(TruncTy->getNumElements(), 8U);
65   EXPECT_EQ(TruncTy->getElementType()->getScalarSizeInBits(), 16U);
66 
67   VectorType *HalvedTy = VectorType::getHalfElementsVectorType(V4Int64Ty);
68   EXPECT_EQ(HalvedTy, V2Int64Ty);
69   ASSERT_FALSE(HalvedTy->isScalable());
70   EXPECT_EQ(HalvedTy->getNumElements(), 2U);
71   EXPECT_EQ(HalvedTy->getElementType()->getScalarSizeInBits(), 64U);
72 
73   VectorType *DoubledTy = VectorType::getDoubleElementsVectorType(V4Int64Ty);
74   EXPECT_EQ(DoubledTy, V8Int64Ty);
75   ASSERT_FALSE(DoubledTy->isScalable());
76   EXPECT_EQ(DoubledTy->getNumElements(), 8U);
77   EXPECT_EQ(DoubledTy->getElementType()->getScalarSizeInBits(), 64U);
78 
79   VectorType *ConvTy = VectorType::getInteger(V4Float64Ty);
80   EXPECT_EQ(ConvTy, V4Int64Ty);
81   ASSERT_FALSE(ConvTy->isScalable());
82   EXPECT_EQ(ConvTy->getNumElements(), 4U);
83   EXPECT_EQ(ConvTy->getElementType()->getScalarSizeInBits(), 64U);
84 
85   EltCnt = V8Int64Ty->getElementCount();
86   EXPECT_EQ(EltCnt.Min, 8U);
87   ASSERT_FALSE(EltCnt.Scalable);
88 }
89 
TEST(VectorTypesTest,Scalable)90 TEST(VectorTypesTest, Scalable) {
91   LLVMContext Ctx;
92 
93   Type *Int16Ty = Type::getInt16Ty(Ctx);
94   Type *Int32Ty = Type::getInt32Ty(Ctx);
95   Type *Int64Ty = Type::getInt64Ty(Ctx);
96   Type *Float64Ty = Type::getDoubleTy(Ctx);
97 
98   VectorType *ScV8Int32Ty = VectorType::get(Int32Ty, 8, true);
99   ASSERT_TRUE(ScV8Int32Ty->isScalable());
100   EXPECT_EQ(ScV8Int32Ty->getNumElements(), 8U);
101   EXPECT_EQ(ScV8Int32Ty->getElementType()->getScalarSizeInBits(), 32U);
102 
103   VectorType *ScV8Int16Ty = VectorType::get(Int16Ty, {8, true});
104   ASSERT_TRUE(ScV8Int16Ty->isScalable());
105   EXPECT_EQ(ScV8Int16Ty->getNumElements(), 8U);
106   EXPECT_EQ(ScV8Int16Ty->getElementType()->getScalarSizeInBits(), 16U);
107 
108   ElementCount EltCnt(4, true);
109   VectorType *ScV4Int64Ty = VectorType::get(Int64Ty, EltCnt);
110   ASSERT_TRUE(ScV4Int64Ty->isScalable());
111   EXPECT_EQ(ScV4Int64Ty->getNumElements(), 4U);
112   EXPECT_EQ(ScV4Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
113 
114   VectorType *ScV2Int64Ty = VectorType::get(Int64Ty, EltCnt/2);
115   ASSERT_TRUE(ScV2Int64Ty->isScalable());
116   EXPECT_EQ(ScV2Int64Ty->getNumElements(), 2U);
117   EXPECT_EQ(ScV2Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
118 
119   VectorType *ScV8Int64Ty = VectorType::get(Int64Ty, EltCnt*2);
120   ASSERT_TRUE(ScV8Int64Ty->isScalable());
121   EXPECT_EQ(ScV8Int64Ty->getNumElements(), 8U);
122   EXPECT_EQ(ScV8Int64Ty->getElementType()->getScalarSizeInBits(), 64U);
123 
124   VectorType *ScV4Float64Ty = VectorType::get(Float64Ty, EltCnt);
125   ASSERT_TRUE(ScV4Float64Ty->isScalable());
126   EXPECT_EQ(ScV4Float64Ty->getNumElements(), 4U);
127   EXPECT_EQ(ScV4Float64Ty->getElementType()->getScalarSizeInBits(), 64U);
128 
129   VectorType *ExtTy = VectorType::getExtendedElementVectorType(ScV8Int16Ty);
130   EXPECT_EQ(ExtTy, ScV8Int32Ty);
131   ASSERT_TRUE(ExtTy->isScalable());
132   EXPECT_EQ(ExtTy->getNumElements(), 8U);
133   EXPECT_EQ(ExtTy->getElementType()->getScalarSizeInBits(), 32U);
134 
135   VectorType *TruncTy = VectorType::getTruncatedElementVectorType(ScV8Int32Ty);
136   EXPECT_EQ(TruncTy, ScV8Int16Ty);
137   ASSERT_TRUE(TruncTy->isScalable());
138   EXPECT_EQ(TruncTy->getNumElements(), 8U);
139   EXPECT_EQ(TruncTy->getElementType()->getScalarSizeInBits(), 16U);
140 
141   VectorType *HalvedTy = VectorType::getHalfElementsVectorType(ScV4Int64Ty);
142   EXPECT_EQ(HalvedTy, ScV2Int64Ty);
143   ASSERT_TRUE(HalvedTy->isScalable());
144   EXPECT_EQ(HalvedTy->getNumElements(), 2U);
145   EXPECT_EQ(HalvedTy->getElementType()->getScalarSizeInBits(), 64U);
146 
147   VectorType *DoubledTy = VectorType::getDoubleElementsVectorType(ScV4Int64Ty);
148   EXPECT_EQ(DoubledTy, ScV8Int64Ty);
149   ASSERT_TRUE(DoubledTy->isScalable());
150   EXPECT_EQ(DoubledTy->getNumElements(), 8U);
151   EXPECT_EQ(DoubledTy->getElementType()->getScalarSizeInBits(), 64U);
152 
153   VectorType *ConvTy = VectorType::getInteger(ScV4Float64Ty);
154   EXPECT_EQ(ConvTy, ScV4Int64Ty);
155   ASSERT_TRUE(ConvTy->isScalable());
156   EXPECT_EQ(ConvTy->getNumElements(), 4U);
157   EXPECT_EQ(ConvTy->getElementType()->getScalarSizeInBits(), 64U);
158 
159   EltCnt = ScV8Int64Ty->getElementCount();
160   EXPECT_EQ(EltCnt.Min, 8U);
161   ASSERT_TRUE(EltCnt.Scalable);
162 }
163 
164 } // end anonymous namespace
165