xref: /llvm-project/llvm/unittests/CodeGen/GlobalISel/GISelUtilsTest.cpp (revision c21a3776c94eef46ea43192c6d0b8df6258b6489) 
1 //===- GISelUtilsTest.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 "GISelMITest.h"
10 #include "llvm/CodeGen/GlobalISel/Utils.h"
11 #include "gtest/gtest.h"
12 
13 using namespace llvm;
14 
15 namespace {
16 static const LLT S1 = LLT::scalar(1);
17 static const LLT S8 = LLT::scalar(8);
18 static const LLT S16 = LLT::scalar(16);
19 static const LLT S32 = LLT::scalar(32);
20 static const LLT S64 = LLT::scalar(64);
21 static const LLT P0 = LLT::pointer(0, 64);
22 static const LLT P1 = LLT::pointer(1, 32);
23 
24 static const LLT V2S8 = LLT::fixed_vector(2, 8);
25 static const LLT V4S8 = LLT::fixed_vector(4, 8);
26 static const LLT V8S8 = LLT::fixed_vector(8, 8);
27 
28 static const LLT V2S16 = LLT::fixed_vector(2, 16);
29 static const LLT V3S16 = LLT::fixed_vector(3, 16);
30 static const LLT V4S16 = LLT::fixed_vector(4, 16);
31 
32 static const LLT V2S32 = LLT::fixed_vector(2, 32);
33 static const LLT V3S32 = LLT::fixed_vector(3, 32);
34 static const LLT V4S32 = LLT::fixed_vector(4, 32);
35 static const LLT V6S32 = LLT::fixed_vector(6, 32);
36 
37 static const LLT V2S64 = LLT::fixed_vector(2, 64);
38 static const LLT V3S64 = LLT::fixed_vector(3, 64);
39 static const LLT V4S64 = LLT::fixed_vector(4, 64);
40 
41 static const LLT V2P0 = LLT::fixed_vector(2, P0);
42 static const LLT V3P0 = LLT::fixed_vector(3, P0);
43 static const LLT V4P0 = LLT::fixed_vector(4, P0);
44 static const LLT V6P0 = LLT::fixed_vector(6, P0);
45 
46 static const LLT V2P1 = LLT::fixed_vector(2, P1);
47 static const LLT V4P1 = LLT::fixed_vector(4, P1);
48 
49 static const LLT NXV1S1 = LLT::scalable_vector(1, S1);
50 static const LLT NXV2S1 = LLT::scalable_vector(2, S1);
51 static const LLT NXV3S1 = LLT::scalable_vector(3, S1);
52 static const LLT NXV4S1 = LLT::scalable_vector(4, S1);
53 static const LLT NXV12S1 = LLT::scalable_vector(12, S1);
54 static const LLT NXV32S1 = LLT::scalable_vector(32, S1);
55 static const LLT NXV64S1 = LLT::scalable_vector(64, S1);
56 static const LLT NXV128S1 = LLT::scalable_vector(128, S1);
57 static const LLT NXV384S1 = LLT::scalable_vector(384, S1);
58 
59 static const LLT NXV1S32 = LLT::scalable_vector(1, S32);
60 static const LLT NXV2S32 = LLT::scalable_vector(2, S32);
61 static const LLT NXV3S32 = LLT::scalable_vector(3, S32);
62 static const LLT NXV4S32 = LLT::scalable_vector(4, S32);
63 static const LLT NXV8S32 = LLT::scalable_vector(8, S32);
64 static const LLT NXV12S32 = LLT::scalable_vector(12, S32);
65 static const LLT NXV24S32 = LLT::scalable_vector(24, S32);
66 
67 static const LLT NXV1S64 = LLT::scalable_vector(1, S64);
68 static const LLT NXV2S64 = LLT::scalable_vector(2, S64);
69 static const LLT NXV3S64 = LLT::scalable_vector(3, S64);
70 static const LLT NXV4S64 = LLT::scalable_vector(4, S64);
71 static const LLT NXV6S64 = LLT::scalable_vector(6, S64);
72 static const LLT NXV12S64 = LLT::scalable_vector(12, S64);
73 
74 static const LLT NXV1P0 = LLT::scalable_vector(1, P0);
75 static const LLT NXV2P0 = LLT::scalable_vector(2, P0);
76 static const LLT NXV3P0 = LLT::scalable_vector(3, P0);
77 static const LLT NXV4P0 = LLT::scalable_vector(4, P0);
78 static const LLT NXV12P0 = LLT::scalable_vector(12, P0);
79 
80 static void collectNonCopyMI(SmallVectorImpl<MachineInstr *> &MIList,
81                              MachineFunction *MF) {
82   for (auto &MBB : *MF)
83     for (MachineInstr &MI : MBB) {
84       if (MI.getOpcode() != TargetOpcode::COPY)
85         MIList.push_back(&MI);
86     }
87 }
88 
89 TEST(GISelUtilsTest, getGCDType) {
90   EXPECT_EQ(S1, getGCDType(S1, S1));
91   EXPECT_EQ(S32, getGCDType(S32, S32));
92   EXPECT_EQ(S1, getGCDType(S1, S32));
93   EXPECT_EQ(S1, getGCDType(S32, S1));
94   EXPECT_EQ(S16, getGCDType(S16, S32));
95   EXPECT_EQ(S16, getGCDType(S32, S16));
96 
97   EXPECT_EQ(V2S32, getGCDType(V2S32, V2S32));
98   EXPECT_EQ(S32, getGCDType(V3S32, V2S32));
99   EXPECT_EQ(S32, getGCDType(V2S32, V3S32));
100 
101   EXPECT_EQ(V2S16, getGCDType(V4S16, V2S16));
102   EXPECT_EQ(V2S16, getGCDType(V2S16, V4S16));
103 
104   EXPECT_EQ(V2S32, getGCDType(V4S32, V2S32));
105   EXPECT_EQ(V2S32, getGCDType(V2S32, V4S32));
106 
107   EXPECT_EQ(S16, getGCDType(P0, S16));
108   EXPECT_EQ(S16, getGCDType(S16, P0));
109 
110   EXPECT_EQ(S32, getGCDType(P0, S32));
111   EXPECT_EQ(S32, getGCDType(S32, P0));
112 
113   EXPECT_EQ(P0, getGCDType(P0, S64));
114   EXPECT_EQ(S64, getGCDType(S64, P0));
115 
116   EXPECT_EQ(S32, getGCDType(P0, P1));
117   EXPECT_EQ(S32, getGCDType(P1, P0));
118 
119   EXPECT_EQ(P0, getGCDType(V3P0, V2P0));
120   EXPECT_EQ(P0, getGCDType(V2P0, V3P0));
121 
122   EXPECT_EQ(P0, getGCDType(P0, V2P0));
123   EXPECT_EQ(P0, getGCDType(V2P0, P0));
124 
125 
126   EXPECT_EQ(V2P0, getGCDType(V2P0, V2P0));
127   EXPECT_EQ(P0, getGCDType(V3P0, V2P0));
128   EXPECT_EQ(P0, getGCDType(V2P0, V3P0));
129   EXPECT_EQ(V2P0, getGCDType(V4P0, V2P0));
130 
131   EXPECT_EQ(V2P0, getGCDType(V2P0, V4P1));
132   EXPECT_EQ(V4P1, getGCDType(V4P1, V2P0));
133 
134   EXPECT_EQ(V2P0, getGCDType(V4P0, V4P1));
135   EXPECT_EQ(V4P1, getGCDType(V4P1, V4P0));
136 
137   // Elements have same size, but have different pointeriness, so prefer the
138   // original element type.
139   EXPECT_EQ(V2P0, getGCDType(V2P0, V4S64));
140   EXPECT_EQ(V2S64, getGCDType(V4S64, V2P0));
141 
142   EXPECT_EQ(V2S16, getGCDType(V2S16, V4P1));
143   EXPECT_EQ(P1, getGCDType(V4P1, V2S16));
144   EXPECT_EQ(V2P1, getGCDType(V4P1, V4S16));
145   EXPECT_EQ(V4S16, getGCDType(V4S16, V2P1));
146 
147   EXPECT_EQ(P0, getGCDType(P0, V2S64));
148   EXPECT_EQ(S64, getGCDType(V2S64, P0));
149 
150   EXPECT_EQ(S16, getGCDType(V2S16, V3S16));
151   EXPECT_EQ(S16, getGCDType(V3S16, V2S16));
152   EXPECT_EQ(S16, getGCDType(V3S16, S16));
153   EXPECT_EQ(S16, getGCDType(S16, V3S16));
154 
155   EXPECT_EQ(V2S16, getGCDType(V2S16, V2S32));
156   EXPECT_EQ(S32, getGCDType(V2S32, V2S16));
157 
158   EXPECT_EQ(V4S8, getGCDType(V4S8, V2S32));
159   EXPECT_EQ(S32, getGCDType(V2S32, V4S8));
160 
161   // Test cases where neither element type nicely divides.
162   EXPECT_EQ(LLT::scalar(3),
163             getGCDType(LLT::fixed_vector(3, 5), LLT::fixed_vector(2, 6)));
164   EXPECT_EQ(LLT::scalar(3),
165             getGCDType(LLT::fixed_vector(2, 6), LLT::fixed_vector(3, 5)));
166 
167   // Have to go smaller than a pointer element.
168   EXPECT_EQ(LLT::scalar(3), getGCDType(LLT::fixed_vector(2, LLT::pointer(3, 6)),
169                                        LLT::fixed_vector(3, 5)));
170   EXPECT_EQ(LLT::scalar(3),
171             getGCDType(LLT::fixed_vector(3, 5),
172                        LLT::fixed_vector(2, LLT::pointer(3, 6))));
173 
174   EXPECT_EQ(V4S8, getGCDType(V4S8, S32));
175   EXPECT_EQ(S32, getGCDType(S32, V4S8));
176   EXPECT_EQ(V4S8, getGCDType(V4S8, P1));
177   EXPECT_EQ(P1, getGCDType(P1, V4S8));
178 
179   EXPECT_EQ(V2S8, getGCDType(V2S8, V4S16));
180   EXPECT_EQ(S16, getGCDType(V4S16, V2S8));
181 
182   EXPECT_EQ(S8, getGCDType(V2S8, LLT::fixed_vector(4, 2)));
183   EXPECT_EQ(LLT::fixed_vector(4, 2), getGCDType(LLT::fixed_vector(4, 2), S8));
184 
185   EXPECT_EQ(LLT::pointer(4, 8),
186             getGCDType(LLT::fixed_vector(2, LLT::pointer(4, 8)),
187                        LLT::fixed_vector(4, 2)));
188 
189   EXPECT_EQ(LLT::fixed_vector(4, 2),
190             getGCDType(LLT::fixed_vector(4, 2),
191                        LLT::fixed_vector(2, LLT::pointer(4, 8))));
192 
193   EXPECT_EQ(LLT::scalar(4), getGCDType(LLT::fixed_vector(3, 4), S8));
194   EXPECT_EQ(LLT::scalar(4), getGCDType(S8, LLT::fixed_vector(3, 4)));
195 
196   // Scalable -> Scalable
197   EXPECT_EQ(NXV1S1, getGCDType(NXV1S1, NXV1S32));
198   EXPECT_EQ(NXV1S32, getGCDType(NXV1S64, NXV1S32));
199   EXPECT_EQ(NXV1S32, getGCDType(NXV1S32, NXV1S64));
200   EXPECT_EQ(NXV1P0, getGCDType(NXV1P0, NXV1S64));
201   EXPECT_EQ(NXV1S64, getGCDType(NXV1S64, NXV1P0));
202 
203   EXPECT_EQ(NXV4S1, getGCDType(NXV4S1, NXV4S32));
204   EXPECT_EQ(NXV2S64, getGCDType(NXV4S64, NXV4S32));
205   EXPECT_EQ(NXV4S32, getGCDType(NXV4S32, NXV4S64));
206   EXPECT_EQ(NXV4P0, getGCDType(NXV4P0, NXV4S64));
207   EXPECT_EQ(NXV4S64, getGCDType(NXV4S64, NXV4P0));
208 
209   EXPECT_EQ(NXV4S1, getGCDType(NXV4S1, NXV2S32));
210   EXPECT_EQ(NXV1S64, getGCDType(NXV4S64, NXV2S32));
211   EXPECT_EQ(NXV4S32, getGCDType(NXV4S32, NXV2S64));
212   EXPECT_EQ(NXV2P0, getGCDType(NXV4P0, NXV2S64));
213   EXPECT_EQ(NXV2S64, getGCDType(NXV4S64, NXV2P0));
214 
215   EXPECT_EQ(NXV2S1, getGCDType(NXV2S1, NXV4S32));
216   EXPECT_EQ(NXV2S64, getGCDType(NXV2S64, NXV4S32));
217   EXPECT_EQ(NXV2S32, getGCDType(NXV2S32, NXV4S64));
218   EXPECT_EQ(NXV2P0, getGCDType(NXV2P0, NXV4S64));
219   EXPECT_EQ(NXV2S64, getGCDType(NXV2S64, NXV4P0));
220 
221   EXPECT_EQ(NXV1S1, getGCDType(NXV3S1, NXV4S32));
222   EXPECT_EQ(NXV1S64, getGCDType(NXV3S64, NXV4S32));
223   EXPECT_EQ(NXV1S32, getGCDType(NXV3S32, NXV4S64));
224   EXPECT_EQ(NXV1P0, getGCDType(NXV3P0, NXV4S64));
225   EXPECT_EQ(NXV1S64, getGCDType(NXV3S64, NXV4P0));
226 
227   EXPECT_EQ(NXV1S1, getGCDType(NXV3S1, NXV4S1));
228   EXPECT_EQ(NXV1S32, getGCDType(NXV3S32, NXV4S32));
229   EXPECT_EQ(NXV1S64, getGCDType(NXV3S64, NXV4S64));
230   EXPECT_EQ(NXV1P0, getGCDType(NXV3P0, NXV4P0));
231 
232   // Scalable, Scalar
233 
234   EXPECT_EQ(S1, getGCDType(NXV1S1, S1));
235   EXPECT_EQ(S1, getGCDType(NXV1S1, S32));
236   EXPECT_EQ(S1, getGCDType(NXV1S32, S1));
237   EXPECT_EQ(S32, getGCDType(NXV1S32, S32));
238   EXPECT_EQ(S32, getGCDType(NXV1S32, S64));
239   EXPECT_EQ(S1, getGCDType(NXV2S32, S1));
240   EXPECT_EQ(S32, getGCDType(NXV2S32, S32));
241   EXPECT_EQ(S32, getGCDType(NXV2S32, S64));
242 
243   EXPECT_EQ(S1, getGCDType(S1, NXV1S1));
244   EXPECT_EQ(S1, getGCDType(S32, NXV1S1));
245   EXPECT_EQ(S1, getGCDType(S1, NXV1S32));
246   EXPECT_EQ(S32, getGCDType(S32, NXV1S32));
247   EXPECT_EQ(S32, getGCDType(S64, NXV1S32));
248   EXPECT_EQ(S1, getGCDType(S1, NXV2S32));
249   EXPECT_EQ(S32, getGCDType(S32, NXV2S32));
250   EXPECT_EQ(S32, getGCDType(S64, NXV2S32));
251 }
252 
253 TEST(GISelUtilsTest, getLCMType) {
254   EXPECT_EQ(S1, getLCMType(S1, S1));
255   EXPECT_EQ(S32, getLCMType(S32, S1));
256   EXPECT_EQ(S32, getLCMType(S1, S32));
257   EXPECT_EQ(S32, getLCMType(S32, S32));
258 
259   EXPECT_EQ(S32, getLCMType(S32, S16));
260   EXPECT_EQ(S32, getLCMType(S16, S32));
261 
262   EXPECT_EQ(S64, getLCMType(S64, P0));
263   EXPECT_EQ(P0, getLCMType(P0, S64));
264 
265   EXPECT_EQ(P0, getLCMType(S32, P0));
266   EXPECT_EQ(P0, getLCMType(P0, S32));
267 
268   EXPECT_EQ(S32, getLCMType(S32, P1));
269   EXPECT_EQ(P1, getLCMType(P1, S32));
270   EXPECT_EQ(P0, getLCMType(P0, P0));
271   EXPECT_EQ(P1, getLCMType(P1, P1));
272 
273   EXPECT_EQ(P0, getLCMType(P0, P1));
274   EXPECT_EQ(P0, getLCMType(P1, P0));
275 
276   EXPECT_EQ(V2S32, getLCMType(V2S32, V2S32));
277   EXPECT_EQ(V2S32, getLCMType(V2S32, S32));
278   EXPECT_EQ(V2S32, getLCMType(S32, V2S32));
279   EXPECT_EQ(V2S32, getLCMType(V2S32, V2S32));
280   EXPECT_EQ(V6S32, getLCMType(V2S32, V3S32));
281   EXPECT_EQ(V6S32, getLCMType(V3S32, V2S32));
282   EXPECT_EQ(LLT::fixed_vector(12, S32), getLCMType(V4S32, V3S32));
283   EXPECT_EQ(LLT::fixed_vector(12, S32), getLCMType(V3S32, V4S32));
284 
285   EXPECT_EQ(V2P0, getLCMType(V2P0, V2P0));
286   EXPECT_EQ(V2P0, getLCMType(V2P0, P0));
287   EXPECT_EQ(V2P0, getLCMType(P0, V2P0));
288   EXPECT_EQ(V2P0, getLCMType(V2P0, V2P0));
289   EXPECT_EQ(V6P0, getLCMType(V2P0, V3P0));
290   EXPECT_EQ(V6P0, getLCMType(V3P0, V2P0));
291   EXPECT_EQ(LLT::fixed_vector(12, P0), getLCMType(V4P0, V3P0));
292   EXPECT_EQ(LLT::fixed_vector(12, P0), getLCMType(V3P0, V4P0));
293 
294   EXPECT_EQ(LLT::fixed_vector(12, S64), getLCMType(V4S64, V3P0));
295   EXPECT_EQ(LLT::fixed_vector(12, P0), getLCMType(V3P0, V4S64));
296 
297   EXPECT_EQ(LLT::fixed_vector(12, P0), getLCMType(V4P0, V3S64));
298   EXPECT_EQ(LLT::fixed_vector(12, S64), getLCMType(V3S64, V4P0));
299 
300   EXPECT_EQ(V2P0, getLCMType(V2P0, S32));
301   EXPECT_EQ(V4S32, getLCMType(S32, V2P0));
302   EXPECT_EQ(V2P0, getLCMType(V2P0, S64));
303   EXPECT_EQ(V2S64, getLCMType(S64, V2P0));
304 
305 
306   EXPECT_EQ(V2P0, getLCMType(V2P0, V2P1));
307   EXPECT_EQ(V4P1, getLCMType(V2P1, V2P0));
308 
309   EXPECT_EQ(V2P0, getLCMType(V2P0, V4P1));
310   EXPECT_EQ(V4P1, getLCMType(V4P1, V2P0));
311 
312 
313   EXPECT_EQ(V2S32, getLCMType(V2S32, S64));
314   EXPECT_EQ(S64, getLCMType(S64, V2S32));
315 
316   EXPECT_EQ(V4S16, getLCMType(V4S16, V2S32));
317   EXPECT_EQ(V2S32, getLCMType(V2S32, V4S16));
318 
319   EXPECT_EQ(V2S32, getLCMType(V2S32, V4S8));
320   EXPECT_EQ(V8S8, getLCMType(V4S8, V2S32));
321 
322   EXPECT_EQ(V2S16, getLCMType(V2S16, V4S8));
323   EXPECT_EQ(V4S8, getLCMType(V4S8, V2S16));
324 
325   EXPECT_EQ(LLT::fixed_vector(6, S16), getLCMType(V3S16, V4S8));
326   EXPECT_EQ(LLT::fixed_vector(12, S8), getLCMType(V4S8, V3S16));
327   EXPECT_EQ(V4S16, getLCMType(V4S16, V4S8));
328   EXPECT_EQ(V8S8, getLCMType(V4S8, V4S16));
329 
330   EXPECT_EQ(LLT::fixed_vector(6, 4), getLCMType(LLT::fixed_vector(3, 4), S8));
331   EXPECT_EQ(LLT::fixed_vector(3, 8), getLCMType(S8, LLT::fixed_vector(3, 4)));
332 
333   EXPECT_EQ(LLT::fixed_vector(6, 4),
334             getLCMType(LLT::fixed_vector(3, 4), LLT::pointer(4, 8)));
335   EXPECT_EQ(LLT::fixed_vector(3, LLT::pointer(4, 8)),
336             getLCMType(LLT::pointer(4, 8), LLT::fixed_vector(3, 4)));
337 
338   EXPECT_EQ(V2S64, getLCMType(V2S64, P0));
339   EXPECT_EQ(V2P0, getLCMType(P0, V2S64));
340 
341   EXPECT_EQ(V2S64, getLCMType(V2S64, P1));
342   EXPECT_EQ(V4P1, getLCMType(P1, V2S64));
343 
344   // Scalable, Scalable
345   EXPECT_EQ(NXV32S1, getLCMType(NXV1S1, NXV1S32));
346   EXPECT_EQ(NXV1S64, getLCMType(NXV1S64, NXV1S32));
347   EXPECT_EQ(NXV2S32, getLCMType(NXV1S32, NXV1S64));
348   EXPECT_EQ(NXV1P0, getLCMType(NXV1P0, NXV1S64));
349   EXPECT_EQ(NXV1S64, getLCMType(NXV1S64, NXV1P0));
350 
351   EXPECT_EQ(NXV128S1, getLCMType(NXV4S1, NXV4S32));
352   EXPECT_EQ(NXV4S64, getLCMType(NXV4S64, NXV4S32));
353   EXPECT_EQ(NXV8S32, getLCMType(NXV4S32, NXV4S64));
354   EXPECT_EQ(NXV4P0, getLCMType(NXV4P0, NXV4S64));
355   EXPECT_EQ(NXV4S64, getLCMType(NXV4S64, NXV4P0));
356 
357   EXPECT_EQ(NXV64S1, getLCMType(NXV4S1, NXV2S32));
358   EXPECT_EQ(NXV4S64, getLCMType(NXV4S64, NXV2S32));
359   EXPECT_EQ(NXV4S32, getLCMType(NXV4S32, NXV2S64));
360   EXPECT_EQ(NXV4P0, getLCMType(NXV4P0, NXV2S64));
361   EXPECT_EQ(NXV4S64, getLCMType(NXV4S64, NXV2P0));
362 
363   EXPECT_EQ(NXV128S1, getLCMType(NXV2S1, NXV4S32));
364   EXPECT_EQ(NXV2S64, getLCMType(NXV2S64, NXV4S32));
365   EXPECT_EQ(NXV8S32, getLCMType(NXV2S32, NXV4S64));
366   EXPECT_EQ(NXV4P0, getLCMType(NXV2P0, NXV4S64));
367   EXPECT_EQ(NXV4S64, getLCMType(NXV2S64, NXV4P0));
368 
369   EXPECT_EQ(NXV384S1, getLCMType(NXV3S1, NXV4S32));
370   EXPECT_EQ(NXV6S64, getLCMType(NXV3S64, NXV4S32));
371   EXPECT_EQ(NXV24S32, getLCMType(NXV3S32, NXV4S64));
372   EXPECT_EQ(NXV12P0, getLCMType(NXV3P0, NXV4S64));
373   EXPECT_EQ(NXV12S64, getLCMType(NXV3S64, NXV4P0));
374 
375   EXPECT_EQ(NXV12S1, getLCMType(NXV3S1, NXV4S1));
376   EXPECT_EQ(NXV12S32, getLCMType(NXV3S32, NXV4S32));
377   EXPECT_EQ(NXV12S64, getLCMType(NXV3S64, NXV4S64));
378   EXPECT_EQ(NXV12P0, getLCMType(NXV3P0, NXV4P0));
379 
380   // Scalable, Scalar
381 
382   EXPECT_EQ(NXV1S1, getLCMType(NXV1S1, S1));
383   EXPECT_EQ(NXV32S1, getLCMType(NXV1S1, S32));
384   EXPECT_EQ(NXV1S32, getLCMType(NXV1S32, S1));
385   EXPECT_EQ(NXV1S32, getLCMType(NXV1S32, S32));
386   EXPECT_EQ(NXV2S32, getLCMType(NXV1S32, S64));
387   EXPECT_EQ(NXV2S32, getLCMType(NXV2S32, S1));
388   EXPECT_EQ(NXV2S32, getLCMType(NXV2S32, S32));
389   EXPECT_EQ(NXV2S32, getLCMType(NXV2S32, S64));
390 
391   EXPECT_EQ(NXV1S1, getLCMType(S1, NXV1S1));
392   EXPECT_EQ(NXV1S32, getLCMType(S32, NXV1S1));
393   EXPECT_EQ(NXV32S1, getLCMType(S1, NXV1S32));
394   EXPECT_EQ(NXV1S32, getLCMType(S32, NXV1S32));
395   EXPECT_EQ(NXV1S64, getLCMType(S64, NXV1S32));
396   EXPECT_EQ(NXV64S1, getLCMType(S1, NXV2S32));
397   EXPECT_EQ(NXV2S32, getLCMType(S32, NXV2S32));
398   EXPECT_EQ(NXV1S64, getLCMType(S64, NXV2S32));
399 }
400 
401 TEST_F(AArch64GISelMITest, ConstFalseTest) {
402   setUp();
403   if (!TM)
404     GTEST_SKIP();
405   const auto &TLI = *B.getMF().getSubtarget().getTargetLowering();
406   bool BooleanChoices[2] = {true, false};
407 
408   // AArch64 uses ZeroOrOneBooleanContent for scalars, and
409   // ZeroOrNegativeOneBooleanContent for vectors.
410   for (auto IsVec : BooleanChoices) {
411     for (auto IsFP : BooleanChoices) {
412       EXPECT_TRUE(isConstFalseVal(TLI, 0, IsVec, IsFP));
413       EXPECT_FALSE(isConstFalseVal(TLI, 1, IsVec, IsFP));
414 
415       // This would be true with UndefinedBooleanContent.
416       EXPECT_FALSE(isConstFalseVal(TLI, 2, IsVec, IsFP));
417     }
418   }
419 }
420 
421 TEST_F(AMDGPUGISelMITest, isConstantOrConstantSplatVectorFP) {
422   StringRef MIRString =
423       "  %cst0:_(s32) = G_FCONSTANT float 2.000000e+00\n"
424       "  %cst1:_(s32) = G_FCONSTANT float 0.0\n"
425       "  %cst2:_(s64) = G_FCONSTANT double 3.000000e-02\n"
426       "  %cst3:_(s32) = G_CONSTANT i32 2\n"
427       "  %cst4:_(<2 x s32>) = G_BUILD_VECTOR %cst0(s32), %cst0(s32)\n"
428       "  %cst5:_(<2 x s32>) = G_BUILD_VECTOR %cst1(s32), %cst0(s32)\n"
429       "  %cst6:_(<2 x s64>) = G_BUILD_VECTOR %cst2(s64), %cst2(s64)\n"
430       "  %cst7:_(<2 x s32>) = G_BUILD_VECTOR %cst3(s32), %cst3:_(s32)\n"
431       "  %cst8:_(<4 x s32>) = G_CONCAT_VECTORS %cst4:_(<2 x s32>), %cst4:_(<2 "
432       "x s32>)\n"
433       "  %cst9:_(<4 x s64>) = G_CONCAT_VECTORS %cst6:_(<2 x s64>), %cst6:_(<2 "
434       "x s64>)\n"
435       "  %cst10:_(<4 x s32>) = G_CONCAT_VECTORS %cst4:_(<2 x s32>), %cst5:_(<2 "
436       "x s32>)\n"
437       "  %cst11:_(<4 x s32>) = G_CONCAT_VECTORS %cst7:_(<2 x s32>), %cst7:_(<2 "
438       "x s32>)\n"
439       "  %cst12:_(s32) = G_IMPLICIT_DEF \n"
440       "  %cst13:_(<2 x s32>) = G_BUILD_VECTOR %cst12(s32), %cst12(s32)\n"
441       "  %cst14:_(<2 x s32>) = G_BUILD_VECTOR %cst0(s32), %cst12(s32)\n"
442       "  %cst15:_(<4 x s32>) = G_CONCAT_VECTORS %cst4:_(<2 x s32>), "
443       "%cst14:_(<2 "
444       "x s32>)\n";
445 
446   SmallVector<MachineInstr *, 16> MIList;
447 
448   setUp(MIRString);
449   if (!TM)
450     GTEST_SKIP();
451 
452   collectNonCopyMI(MIList, MF);
453 
454   EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[0], *MRI).has_value());
455   auto val = isConstantOrConstantSplatVectorFP(*MIList[0], *MRI).value();
456   EXPECT_EQ(2.0, val.convertToFloat());
457 
458   EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[1], *MRI).has_value());
459   val = isConstantOrConstantSplatVectorFP(*MIList[1], *MRI).value();
460   EXPECT_EQ(0.0, val.convertToFloat());
461 
462   EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[2], *MRI).has_value());
463   val = isConstantOrConstantSplatVectorFP(*MIList[2], *MRI).value();
464   EXPECT_EQ(0.03, val.convertToDouble());
465 
466   EXPECT_FALSE(isConstantOrConstantSplatVectorFP(*MIList[3], *MRI).has_value());
467 
468   EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[4], *MRI).has_value());
469   val = isConstantOrConstantSplatVectorFP(*MIList[4], *MRI).value();
470   EXPECT_EQ(2.0, val.convertToFloat());
471 
472   EXPECT_FALSE(isConstantOrConstantSplatVectorFP(*MIList[5], *MRI).has_value());
473 
474   EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[6], *MRI).has_value());
475   val = isConstantOrConstantSplatVectorFP(*MIList[6], *MRI).value();
476   EXPECT_EQ(0.03, val.convertToDouble());
477 
478   EXPECT_FALSE(isConstantOrConstantSplatVectorFP(*MIList[7], *MRI).has_value());
479 
480   EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[8], *MRI).has_value());
481   val = isConstantOrConstantSplatVectorFP(*MIList[8], *MRI).value();
482   EXPECT_EQ(2.0, val.convertToFloat());
483 
484   EXPECT_TRUE(isConstantOrConstantSplatVectorFP(*MIList[9], *MRI).has_value());
485   val = isConstantOrConstantSplatVectorFP(*MIList[9], *MRI).value();
486   EXPECT_EQ(0.03, val.convertToDouble());
487 
488   EXPECT_FALSE(
489       isConstantOrConstantSplatVectorFP(*MIList[10], *MRI).has_value());
490 
491   EXPECT_FALSE(
492       isConstantOrConstantSplatVectorFP(*MIList[11], *MRI).has_value());
493 
494   EXPECT_FALSE(
495       isConstantOrConstantSplatVectorFP(*MIList[12], *MRI).has_value());
496 
497   EXPECT_FALSE(
498       isConstantOrConstantSplatVectorFP(*MIList[13], *MRI).has_value());
499 
500   EXPECT_FALSE(
501       isConstantOrConstantSplatVectorFP(*MIList[14], *MRI).has_value());
502 
503   EXPECT_FALSE(
504       isConstantOrConstantSplatVectorFP(*MIList[15], *MRI).has_value());
505 }
506 }
507