1 | //===- llvm/unittest/IR/ShuffleVectorInstTest.cpp - Shuffle 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/Instructions.h" |
10 | #include "gtest/gtest.h" |
11 | |
12 | using namespace llvm; |
13 | |
14 | namespace { |
15 | |
16 | TEST(ShuffleVectorInst, isIdentityMask) { |
17 | ASSERT_TRUE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3}, 4)); |
18 | ASSERT_TRUE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3, -1}, 5)); |
19 | ASSERT_TRUE(ShuffleVectorInst::isIdentityMask({0, 1, -1, 3}, 4)); |
20 | |
21 | ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3}, 3)); |
22 | ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3, -1}, 4)); |
23 | ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, -1, 3}, 3)); |
24 | |
25 | ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3}, 5)); |
26 | ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3, -1}, 6)); |
27 | ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, -1, 3}, 5)); |
28 | |
29 | ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 4}, 4)); |
30 | ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, -1, 2, 4}, 4)); |
31 | } |
32 | |
33 | TEST(ShuffleVectorInst, isSelectMask) { |
34 | ASSERT_TRUE(ShuffleVectorInst::isSelectMask({0, 5, 6, 3}, 4)); |
35 | |
36 | ASSERT_FALSE(ShuffleVectorInst::isSelectMask({0, 5, 6, 3}, 3)); |
37 | ASSERT_FALSE(ShuffleVectorInst::isSelectMask({0, 5, 6, 3}, 5)); |
38 | |
39 | ASSERT_FALSE(ShuffleVectorInst::isSelectMask({0, 1, 2, 3}, 4)); |
40 | } |
41 | |
42 | TEST(ShuffleVectorInst, isReverseMask) { |
43 | ASSERT_TRUE(ShuffleVectorInst::isReverseMask({3, 2, 1, 0}, 4)); |
44 | ASSERT_TRUE(ShuffleVectorInst::isReverseMask({-1, -1, 1, 0}, 4)); |
45 | |
46 | ASSERT_FALSE(ShuffleVectorInst::isReverseMask({3, 2, 1, 0}, 3)); |
47 | ASSERT_FALSE(ShuffleVectorInst::isReverseMask({-1, -1, 1, 0}, 3)); |
48 | ASSERT_FALSE(ShuffleVectorInst::isReverseMask({3, 2, 1, 0}, 5)); |
49 | ASSERT_FALSE(ShuffleVectorInst::isReverseMask({-1, -1, 1, 0}, 5)); |
50 | |
51 | ASSERT_FALSE(ShuffleVectorInst::isReverseMask({4, 3, 2, 1}, 4)); |
52 | } |
53 | |
54 | TEST(ShuffleVectorInst, isZeroEltSplatMask) { |
55 | ASSERT_TRUE(ShuffleVectorInst::isZeroEltSplatMask({0, 0, 0, 0}, 4)); |
56 | ASSERT_TRUE(ShuffleVectorInst::isZeroEltSplatMask({0, -1, 0, -1}, 4)); |
57 | |
58 | ASSERT_FALSE(ShuffleVectorInst::isZeroEltSplatMask({0, 0, 0, 0}, 3)); |
59 | ASSERT_FALSE(ShuffleVectorInst::isZeroEltSplatMask({0, -1, 0, -1}, 3)); |
60 | ASSERT_FALSE(ShuffleVectorInst::isZeroEltSplatMask({0, 0, 0, 0}, 5)); |
61 | ASSERT_FALSE(ShuffleVectorInst::isZeroEltSplatMask({0, -1, 0, -1}, 5)); |
62 | |
63 | ASSERT_FALSE(ShuffleVectorInst::isZeroEltSplatMask({1, 1, 1, 1}, 4)); |
64 | } |
65 | |
66 | TEST(ShuffleVectorInst, isTransposeMask) { |
67 | ASSERT_TRUE(ShuffleVectorInst::isTransposeMask({0, 4, 2, 6}, 4)); |
68 | ASSERT_TRUE(ShuffleVectorInst::isTransposeMask({1, 5, 3, 7}, 4)); |
69 | |
70 | ASSERT_FALSE(ShuffleVectorInst::isTransposeMask({0, 4, 2, 6}, 3)); |
71 | ASSERT_FALSE(ShuffleVectorInst::isTransposeMask({1, 5, 3, 7}, 3)); |
72 | ASSERT_FALSE(ShuffleVectorInst::isTransposeMask({0, 4, 2, 6}, 5)); |
73 | ASSERT_FALSE(ShuffleVectorInst::isTransposeMask({1, 5, 3, 7}, 5)); |
74 | |
75 | ASSERT_FALSE(ShuffleVectorInst::isTransposeMask({2, 6, 4, 8}, 4)); |
76 | } |
77 | |
78 | TEST(ShuffleVectorInst, isSpliceMask) { |
79 | int Index; |
80 | |
81 | ASSERT_TRUE(ShuffleVectorInst::isSpliceMask({0, 1, 2, 3}, 4, Index)); |
82 | ASSERT_EQ(0, Index); |
83 | |
84 | ASSERT_TRUE(ShuffleVectorInst::isSpliceMask({1, 2, 3, 4, 5, 6, 7}, 7, Index)); |
85 | ASSERT_EQ(1, Index); |
86 | |
87 | ASSERT_FALSE(ShuffleVectorInst::isSpliceMask({0, 1, 2, 3}, 3, Index)); |
88 | ASSERT_FALSE( |
89 | ShuffleVectorInst::isSpliceMask({1, 2, 3, 4, 5, 6, 7}, 6, Index)); |
90 | ASSERT_FALSE(ShuffleVectorInst::isSpliceMask({0, 1, 2, 3}, 5, Index)); |
91 | ASSERT_FALSE( |
92 | ShuffleVectorInst::isSpliceMask({1, 2, 3, 4, 5, 6, 7}, 8, Index)); |
93 | |
94 | ASSERT_FALSE(ShuffleVectorInst::isSpliceMask({4, 5, 6, 7}, 4, Index)); |
95 | } |
96 | |
97 | TEST(ShuffleVectorInst, isExtractSubvectorMask) { |
98 | int Index; |
99 | |
100 | ASSERT_TRUE( |
101 | ShuffleVectorInst::isExtractSubvectorMask({0, 1, 2, 3}, 8, Index)); |
102 | ASSERT_EQ(0, Index); |
103 | |
104 | ASSERT_TRUE( |
105 | ShuffleVectorInst::isExtractSubvectorMask({-1, 3, 4, 5}, 8, Index)); |
106 | ASSERT_EQ(2, Index); |
107 | |
108 | ASSERT_FALSE( |
109 | ShuffleVectorInst::isExtractSubvectorMask({1, 2, 3, -1}, 4, Index)); |
110 | } |
111 | |
112 | TEST(ShuffleVectorInst, isInsertSubvectorMask) { |
113 | int NumSubElts, Index; |
114 | |
115 | ASSERT_TRUE(ShuffleVectorInst::isInsertSubvectorMask( |
116 | {8, 9, 10, 11, 4, 5, 6, 7}, 8, NumSubElts, Index)); |
117 | ASSERT_EQ(0, Index); |
118 | ASSERT_EQ(4, NumSubElts); |
119 | |
120 | ASSERT_TRUE( |
121 | ShuffleVectorInst::isInsertSubvectorMask({0, 2}, 2, NumSubElts, Index)); |
122 | ASSERT_EQ(1, Index); |
123 | ASSERT_EQ(1, NumSubElts); |
124 | } |
125 | |
126 | TEST(ShuffleVectorInst, isReplicationMask) { |
127 | int ReplicationFactor, VF; |
128 | |
129 | ASSERT_TRUE(ShuffleVectorInst::isReplicationMask({0, 0, 1, 1, 2, 2, 3, 3}, |
130 | ReplicationFactor, VF)); |
131 | ASSERT_EQ(2, ReplicationFactor); |
132 | ASSERT_EQ(4, VF); |
133 | |
134 | ASSERT_TRUE(ShuffleVectorInst::isReplicationMask( |
135 | {0, 0, 0, 1, 1, 1, -1, -1, -1, 3, 3, 3, 4, 4, 4}, ReplicationFactor, VF)); |
136 | ASSERT_EQ(3, ReplicationFactor); |
137 | ASSERT_EQ(5, VF); |
138 | } |
139 | |
140 | TEST(ShuffleVectorInst, isOneUseSingleSourceMask) { |
141 | ASSERT_TRUE( |
142 | ShuffleVectorInst::isOneUseSingleSourceMask({0, 1, 2, 3, 3, 2, 0, 1}, 4)); |
143 | ASSERT_TRUE( |
144 | ShuffleVectorInst::isOneUseSingleSourceMask({2, 3, 4, 5, 6, 7, 0, 1}, 8)); |
145 | |
146 | ASSERT_FALSE(ShuffleVectorInst::isOneUseSingleSourceMask( |
147 | {0, -1, 2, 3, 3, 2, 0, 1}, 4)); |
148 | ASSERT_FALSE( |
149 | ShuffleVectorInst::isOneUseSingleSourceMask({0, 1, 2, 3, 3, 3, 1, 0}, 4)); |
150 | } |
151 | |
152 | TEST(ShuffleVectorInst, isInterleaveMask) { |
153 | SmallVector<unsigned> StartIndexes; |
154 | ASSERT_TRUE(ShuffleVectorInst::isInterleaveMask({0, 4, 1, 5, 2, 6, 3, 7}, 2, |
155 | 8, StartIndexes)); |
156 | ASSERT_EQ(StartIndexes, SmallVector<unsigned>({0, 4})); |
157 | |
158 | ASSERT_FALSE( |
159 | ShuffleVectorInst::isInterleaveMask({0, 4, 1, 6, 2, 6, 3, 7}, 2, 8)); |
160 | |
161 | ASSERT_TRUE(ShuffleVectorInst::isInterleaveMask({4, 0, 5, 1, 6, 2, 7, 3}, 2, |
162 | 8, StartIndexes)); |
163 | ASSERT_EQ(StartIndexes, SmallVector<unsigned>({4, 0})); |
164 | |
165 | ASSERT_TRUE(ShuffleVectorInst::isInterleaveMask({4, 0, -1, 1, -1, 2, 7, 3}, 2, |
166 | 8, StartIndexes)); |
167 | ASSERT_EQ(StartIndexes, SmallVector<unsigned>({4, 0})); |
168 | |
169 | ASSERT_TRUE(ShuffleVectorInst::isInterleaveMask({0, 2, 4, 1, 3, 5}, 3, 6, |
170 | StartIndexes)); |
171 | ASSERT_EQ(StartIndexes, SmallVector<unsigned>({0, 2, 4})); |
172 | |
173 | ASSERT_TRUE(ShuffleVectorInst::isInterleaveMask({4, -1, 0, 5, 3, 1}, 3, 6, |
174 | StartIndexes)); |
175 | ASSERT_EQ(StartIndexes, SmallVector<unsigned>({4, 2, 0})); |
176 | |
177 | ASSERT_FALSE( |
178 | ShuffleVectorInst::isInterleaveMask({8, 2, 12, 4, 9, 3, 13, 5}, 4, 8)); |
179 | } |
180 | |
181 | } // end anonymous namespace |
182 | |