1 //===- llvm/unittest/Support/ConstantRangeTest.cpp - ConstantRange tests --===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/Support/ConstantRange.h"
12 #include "gtest/gtest.h"
18 class ConstantRangeTest
: public ::testing::Test
{
20 static ConstantRange Full
;
21 static ConstantRange Empty
;
22 static ConstantRange One
;
23 static ConstantRange Some
;
24 static ConstantRange Wrap
;
27 ConstantRange
ConstantRangeTest::Full(16);
28 ConstantRange
ConstantRangeTest::Empty(16, false);
29 ConstantRange
ConstantRangeTest::One(APInt(16, 0xa));
30 ConstantRange
ConstantRangeTest::Some(APInt(16, 0xa), APInt(16, 0xaaa));
31 ConstantRange
ConstantRangeTest::Wrap(APInt(16, 0xaaa), APInt(16, 0xa));
33 TEST_F(ConstantRangeTest
, Basics
) {
34 EXPECT_TRUE(Full
.isFullSet());
35 EXPECT_FALSE(Full
.isEmptySet());
36 EXPECT_TRUE(Full
.inverse().isEmptySet());
37 EXPECT_FALSE(Full
.isWrappedSet());
38 EXPECT_TRUE(Full
.contains(APInt(16, 0x0)));
39 EXPECT_TRUE(Full
.contains(APInt(16, 0x9)));
40 EXPECT_TRUE(Full
.contains(APInt(16, 0xa)));
41 EXPECT_TRUE(Full
.contains(APInt(16, 0xaa9)));
42 EXPECT_TRUE(Full
.contains(APInt(16, 0xaaa)));
44 EXPECT_FALSE(Empty
.isFullSet());
45 EXPECT_TRUE(Empty
.isEmptySet());
46 EXPECT_TRUE(Empty
.inverse().isFullSet());
47 EXPECT_FALSE(Empty
.isWrappedSet());
48 EXPECT_FALSE(Empty
.contains(APInt(16, 0x0)));
49 EXPECT_FALSE(Empty
.contains(APInt(16, 0x9)));
50 EXPECT_FALSE(Empty
.contains(APInt(16, 0xa)));
51 EXPECT_FALSE(Empty
.contains(APInt(16, 0xaa9)));
52 EXPECT_FALSE(Empty
.contains(APInt(16, 0xaaa)));
54 EXPECT_FALSE(One
.isFullSet());
55 EXPECT_FALSE(One
.isEmptySet());
56 EXPECT_FALSE(One
.isWrappedSet());
57 EXPECT_FALSE(One
.contains(APInt(16, 0x0)));
58 EXPECT_FALSE(One
.contains(APInt(16, 0x9)));
59 EXPECT_TRUE(One
.contains(APInt(16, 0xa)));
60 EXPECT_FALSE(One
.contains(APInt(16, 0xaa9)));
61 EXPECT_FALSE(One
.contains(APInt(16, 0xaaa)));
62 EXPECT_FALSE(One
.inverse().contains(APInt(16, 0xa)));
64 EXPECT_FALSE(Some
.isFullSet());
65 EXPECT_FALSE(Some
.isEmptySet());
66 EXPECT_FALSE(Some
.isWrappedSet());
67 EXPECT_FALSE(Some
.contains(APInt(16, 0x0)));
68 EXPECT_FALSE(Some
.contains(APInt(16, 0x9)));
69 EXPECT_TRUE(Some
.contains(APInt(16, 0xa)));
70 EXPECT_TRUE(Some
.contains(APInt(16, 0xaa9)));
71 EXPECT_FALSE(Some
.contains(APInt(16, 0xaaa)));
73 EXPECT_FALSE(Wrap
.isFullSet());
74 EXPECT_FALSE(Wrap
.isEmptySet());
75 EXPECT_TRUE(Wrap
.isWrappedSet());
76 EXPECT_TRUE(Wrap
.contains(APInt(16, 0x0)));
77 EXPECT_TRUE(Wrap
.contains(APInt(16, 0x9)));
78 EXPECT_FALSE(Wrap
.contains(APInt(16, 0xa)));
79 EXPECT_FALSE(Wrap
.contains(APInt(16, 0xaa9)));
80 EXPECT_TRUE(Wrap
.contains(APInt(16, 0xaaa)));
83 TEST_F(ConstantRangeTest
, Equality
) {
84 EXPECT_EQ(Full
, Full
);
85 EXPECT_EQ(Empty
, Empty
);
87 EXPECT_EQ(Some
, Some
);
88 EXPECT_EQ(Wrap
, Wrap
);
89 EXPECT_NE(Full
, Empty
);
91 EXPECT_NE(Full
, Some
);
92 EXPECT_NE(Full
, Wrap
);
93 EXPECT_NE(Empty
, One
);
94 EXPECT_NE(Empty
, Some
);
95 EXPECT_NE(Empty
, Wrap
);
98 EXPECT_NE(Some
, Wrap
);
101 TEST_F(ConstantRangeTest
, SingleElement
) {
102 EXPECT_EQ(Full
.getSingleElement(), static_cast<APInt
*>(NULL
));
103 EXPECT_EQ(Empty
.getSingleElement(), static_cast<APInt
*>(NULL
));
104 EXPECT_EQ(*One
.getSingleElement(), APInt(16, 0xa));
105 EXPECT_EQ(Some
.getSingleElement(), static_cast<APInt
*>(NULL
));
106 EXPECT_EQ(Wrap
.getSingleElement(), static_cast<APInt
*>(NULL
));
108 EXPECT_FALSE(Full
.isSingleElement());
109 EXPECT_FALSE(Empty
.isSingleElement());
110 EXPECT_TRUE(One
.isSingleElement());
111 EXPECT_FALSE(Some
.isSingleElement());
112 EXPECT_FALSE(Wrap
.isSingleElement());
115 TEST_F(ConstantRangeTest
, GetSetSize
) {
116 EXPECT_EQ(Full
.getSetSize(), APInt(16, 0));
117 EXPECT_EQ(Empty
.getSetSize(), APInt(16, 0));
118 EXPECT_EQ(One
.getSetSize(), APInt(16, 1));
119 EXPECT_EQ(Some
.getSetSize(), APInt(16, 0xaa0));
120 EXPECT_EQ(Wrap
.getSetSize(), APInt(16, 0x10000 - 0xaa0));
123 TEST_F(ConstantRangeTest
, GetMinsAndMaxes
) {
124 EXPECT_EQ(Full
.getUnsignedMax(), APInt(16, UINT16_MAX
));
125 EXPECT_EQ(One
.getUnsignedMax(), APInt(16, 0xa));
126 EXPECT_EQ(Some
.getUnsignedMax(), APInt(16, 0xaa9));
127 EXPECT_EQ(Wrap
.getUnsignedMax(), APInt(16, UINT16_MAX
));
129 EXPECT_EQ(Full
.getUnsignedMin(), APInt(16, 0));
130 EXPECT_EQ(One
.getUnsignedMin(), APInt(16, 0xa));
131 EXPECT_EQ(Some
.getUnsignedMin(), APInt(16, 0xa));
132 EXPECT_EQ(Wrap
.getUnsignedMin(), APInt(16, 0));
134 EXPECT_EQ(Full
.getSignedMax(), APInt(16, INT16_MAX
));
135 EXPECT_EQ(One
.getSignedMax(), APInt(16, 0xa));
136 EXPECT_EQ(Some
.getSignedMax(), APInt(16, 0xaa9));
137 EXPECT_EQ(Wrap
.getSignedMax(), APInt(16, INT16_MAX
));
139 EXPECT_EQ(Full
.getSignedMin(), APInt(16, (uint64_t)INT16_MIN
));
140 EXPECT_EQ(One
.getSignedMin(), APInt(16, 0xa));
141 EXPECT_EQ(Some
.getSignedMin(), APInt(16, 0xa));
142 EXPECT_EQ(Wrap
.getSignedMin(), APInt(16, (uint64_t)INT16_MIN
));
145 EXPECT_EQ(ConstantRange(APInt(4, 7), APInt(4, 0)).getSignedMax(),
149 TEST_F(ConstantRangeTest
, Trunc
) {
150 ConstantRange TFull
= Full
.truncate(10);
151 ConstantRange TEmpty
= Empty
.truncate(10);
152 ConstantRange TOne
= One
.truncate(10);
153 ConstantRange TSome
= Some
.truncate(10);
154 ConstantRange TWrap
= Wrap
.truncate(10);
155 EXPECT_TRUE(TFull
.isFullSet());
156 EXPECT_TRUE(TEmpty
.isEmptySet());
157 EXPECT_EQ(TOne
, ConstantRange(APInt(One
.getLower()).trunc(10),
158 APInt(One
.getUpper()).trunc(10)));
159 EXPECT_TRUE(TSome
.isFullSet());
162 TEST_F(ConstantRangeTest
, ZExt
) {
163 ConstantRange ZFull
= Full
.zeroExtend(20);
164 ConstantRange ZEmpty
= Empty
.zeroExtend(20);
165 ConstantRange ZOne
= One
.zeroExtend(20);
166 ConstantRange ZSome
= Some
.zeroExtend(20);
167 ConstantRange ZWrap
= Wrap
.zeroExtend(20);
168 EXPECT_EQ(ZFull
, ConstantRange(APInt(20, 0), APInt(20, 0x10000)));
169 EXPECT_TRUE(ZEmpty
.isEmptySet());
170 EXPECT_EQ(ZOne
, ConstantRange(APInt(One
.getLower()).zext(20),
171 APInt(One
.getUpper()).zext(20)));
172 EXPECT_EQ(ZSome
, ConstantRange(APInt(Some
.getLower()).zext(20),
173 APInt(Some
.getUpper()).zext(20)));
174 EXPECT_EQ(ZWrap
, ConstantRange(APInt(Wrap
.getLower()).zext(20),
175 APInt(Wrap
.getUpper()).zext(20)));
178 TEST_F(ConstantRangeTest
, SExt
) {
179 ConstantRange SFull
= Full
.signExtend(20);
180 ConstantRange SEmpty
= Empty
.signExtend(20);
181 ConstantRange SOne
= One
.signExtend(20);
182 ConstantRange SSome
= Some
.signExtend(20);
183 ConstantRange SWrap
= Wrap
.signExtend(20);
184 EXPECT_EQ(SFull
, ConstantRange(APInt(20, (uint64_t)INT16_MIN
, true),
185 APInt(20, INT16_MAX
+ 1, true)));
186 EXPECT_TRUE(SEmpty
.isEmptySet());
187 EXPECT_EQ(SOne
, ConstantRange(APInt(One
.getLower()).sext(20),
188 APInt(One
.getUpper()).sext(20)));
189 EXPECT_EQ(SSome
, ConstantRange(APInt(Some
.getLower()).sext(20),
190 APInt(Some
.getUpper()).sext(20)));
191 EXPECT_EQ(SWrap
, ConstantRange(APInt(Wrap
.getLower()).sext(20),
192 APInt(Wrap
.getUpper()).sext(20)));
195 TEST_F(ConstantRangeTest
, IntersectWith
) {
196 EXPECT_EQ(Empty
.intersectWith(Full
), Empty
);
197 EXPECT_EQ(Empty
.intersectWith(Empty
), Empty
);
198 EXPECT_EQ(Empty
.intersectWith(One
), Empty
);
199 EXPECT_EQ(Empty
.intersectWith(Some
), Empty
);
200 EXPECT_EQ(Empty
.intersectWith(Wrap
), Empty
);
201 EXPECT_EQ(Full
.intersectWith(Full
), Full
);
202 EXPECT_EQ(Some
.intersectWith(Some
), Some
);
203 EXPECT_EQ(Some
.intersectWith(One
), One
);
204 EXPECT_EQ(Full
.intersectWith(One
), One
);
205 EXPECT_EQ(Full
.intersectWith(Some
), Some
);
206 EXPECT_EQ(Some
.intersectWith(Wrap
), Empty
);
207 EXPECT_EQ(One
.intersectWith(Wrap
), Empty
);
208 EXPECT_EQ(One
.intersectWith(Wrap
), Wrap
.intersectWith(One
));
210 // Klee generated testcase from PR4545.
211 // The intersection of i16 [4, 2) and [6, 5) is disjoint, looking like
212 // 01..4.6789ABCDEF where the dots represent values not in the intersection.
213 ConstantRange
LHS(APInt(16, 4), APInt(16, 2));
214 ConstantRange
RHS(APInt(16, 6), APInt(16, 5));
215 EXPECT_TRUE(LHS
.intersectWith(RHS
) == LHS
);
218 TEST_F(ConstantRangeTest
, UnionWith
) {
219 EXPECT_EQ(Wrap
.unionWith(One
),
220 ConstantRange(APInt(16, 0xaaa), APInt(16, 0xb)));
221 EXPECT_EQ(One
.unionWith(Wrap
), Wrap
.unionWith(One
));
222 EXPECT_EQ(Empty
.unionWith(Empty
), Empty
);
223 EXPECT_EQ(Full
.unionWith(Full
), Full
);
224 EXPECT_EQ(Some
.unionWith(Wrap
), Full
);
227 EXPECT_EQ(ConstantRange(APInt(16, 14), APInt(16, 1)).unionWith(
228 ConstantRange(APInt(16, 0), APInt(16, 8))),
229 ConstantRange(APInt(16, 14), APInt(16, 8)));
230 EXPECT_EQ(ConstantRange(APInt(16, 6), APInt(16, 4)).unionWith(
231 ConstantRange(APInt(16, 4), APInt(16, 0))),
233 EXPECT_EQ(ConstantRange(APInt(16, 1), APInt(16, 0)).unionWith(
234 ConstantRange(APInt(16, 2), APInt(16, 1))),
238 TEST_F(ConstantRangeTest
, SubtractAPInt
) {
239 EXPECT_EQ(Full
.subtract(APInt(16, 4)), Full
);
240 EXPECT_EQ(Empty
.subtract(APInt(16, 4)), Empty
);
241 EXPECT_EQ(Some
.subtract(APInt(16, 4)),
242 ConstantRange(APInt(16, 0x6), APInt(16, 0xaa6)));
243 EXPECT_EQ(Wrap
.subtract(APInt(16, 4)),
244 ConstantRange(APInt(16, 0xaa6), APInt(16, 0x6)));
245 EXPECT_EQ(One
.subtract(APInt(16, 4)),
246 ConstantRange(APInt(16, 0x6)));
249 TEST_F(ConstantRangeTest
, Add
) {
250 EXPECT_EQ(Full
.add(APInt(16, 4)), Full
);
251 EXPECT_EQ(Full
.add(Full
), Full
);
252 EXPECT_EQ(Full
.add(Empty
), Empty
);
253 EXPECT_EQ(Full
.add(One
), Full
);
254 EXPECT_EQ(Full
.add(Some
), Full
);
255 EXPECT_EQ(Full
.add(Wrap
), Full
);
256 EXPECT_EQ(Empty
.add(Empty
), Empty
);
257 EXPECT_EQ(Empty
.add(One
), Empty
);
258 EXPECT_EQ(Empty
.add(Some
), Empty
);
259 EXPECT_EQ(Empty
.add(Wrap
), Empty
);
260 EXPECT_EQ(Empty
.add(APInt(16, 4)), Empty
);
261 EXPECT_EQ(Some
.add(APInt(16, 4)),
262 ConstantRange(APInt(16, 0xe), APInt(16, 0xaae)));
263 EXPECT_EQ(Wrap
.add(APInt(16, 4)),
264 ConstantRange(APInt(16, 0xaae), APInt(16, 0xe)));
265 EXPECT_EQ(One
.add(APInt(16, 4)),
266 ConstantRange(APInt(16, 0xe)));
269 TEST_F(ConstantRangeTest
, Sub
) {
270 EXPECT_EQ(Full
.sub(APInt(16, 4)), Full
);
271 EXPECT_EQ(Full
.sub(Full
), Full
);
272 EXPECT_EQ(Full
.sub(Empty
), Empty
);
273 EXPECT_EQ(Full
.sub(One
), Full
);
274 EXPECT_EQ(Full
.sub(Some
), Full
);
275 EXPECT_EQ(Full
.sub(Wrap
), Full
);
276 EXPECT_EQ(Empty
.sub(Empty
), Empty
);
277 EXPECT_EQ(Empty
.sub(One
), Empty
);
278 EXPECT_EQ(Empty
.sub(Some
), Empty
);
279 EXPECT_EQ(Empty
.sub(Wrap
), Empty
);
280 EXPECT_EQ(Empty
.sub(APInt(16, 4)), Empty
);
281 EXPECT_EQ(Some
.sub(APInt(16, 4)),
282 ConstantRange(APInt(16, 0x6), APInt(16, 0xaa6)));
283 EXPECT_EQ(Wrap
.sub(APInt(16, 4)),
284 ConstantRange(APInt(16, 0xaa6), APInt(16, 0x6)));
285 EXPECT_EQ(One
.sub(APInt(16, 4)),
286 ConstantRange(APInt(16, 0x6)));
289 TEST_F(ConstantRangeTest
, Multiply
) {
290 EXPECT_EQ(Full
.multiply(Full
), Full
);
291 EXPECT_EQ(Full
.multiply(Empty
), Empty
);
292 EXPECT_EQ(Full
.multiply(One
), Full
);
293 EXPECT_EQ(Full
.multiply(Some
), Full
);
294 EXPECT_EQ(Full
.multiply(Wrap
), Full
);
295 EXPECT_EQ(Empty
.multiply(Empty
), Empty
);
296 EXPECT_EQ(Empty
.multiply(One
), Empty
);
297 EXPECT_EQ(Empty
.multiply(Some
), Empty
);
298 EXPECT_EQ(Empty
.multiply(Wrap
), Empty
);
299 EXPECT_EQ(One
.multiply(One
), ConstantRange(APInt(16, 0xa*0xa),
300 APInt(16, 0xa*0xa + 1)));
301 EXPECT_EQ(One
.multiply(Some
), ConstantRange(APInt(16, 0xa*0xa),
302 APInt(16, 0xa*0xaa9 + 1)));
303 EXPECT_EQ(One
.multiply(Wrap
), Full
);
304 EXPECT_EQ(Some
.multiply(Some
), Full
);
305 EXPECT_EQ(Some
.multiply(Wrap
), Full
);
306 EXPECT_EQ(Wrap
.multiply(Wrap
), Full
);
308 // http://llvm.org/PR4545
309 EXPECT_EQ(ConstantRange(APInt(4, 1), APInt(4, 6)).multiply(
310 ConstantRange(APInt(4, 6), APInt(4, 2))),
311 ConstantRange(4, /*isFullSet=*/true));
314 TEST_F(ConstantRangeTest
, UMax
) {
315 EXPECT_EQ(Full
.umax(Full
), Full
);
316 EXPECT_EQ(Full
.umax(Empty
), Empty
);
317 EXPECT_EQ(Full
.umax(Some
), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
318 EXPECT_EQ(Full
.umax(Wrap
), Full
);
319 EXPECT_EQ(Full
.umax(Some
), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
320 EXPECT_EQ(Empty
.umax(Empty
), Empty
);
321 EXPECT_EQ(Empty
.umax(Some
), Empty
);
322 EXPECT_EQ(Empty
.umax(Wrap
), Empty
);
323 EXPECT_EQ(Empty
.umax(One
), Empty
);
324 EXPECT_EQ(Some
.umax(Some
), Some
);
325 EXPECT_EQ(Some
.umax(Wrap
), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
326 EXPECT_EQ(Some
.umax(One
), Some
);
327 // TODO: ConstantRange is currently over-conservative here.
328 EXPECT_EQ(Wrap
.umax(Wrap
), Full
);
329 EXPECT_EQ(Wrap
.umax(One
), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
330 EXPECT_EQ(One
.umax(One
), One
);
333 TEST_F(ConstantRangeTest
, SMax
) {
334 EXPECT_EQ(Full
.smax(Full
), Full
);
335 EXPECT_EQ(Full
.smax(Empty
), Empty
);
336 EXPECT_EQ(Full
.smax(Some
), ConstantRange(APInt(16, 0xa),
337 APInt::getSignedMinValue(16)));
338 EXPECT_EQ(Full
.smax(Wrap
), Full
);
339 EXPECT_EQ(Full
.smax(One
), ConstantRange(APInt(16, 0xa),
340 APInt::getSignedMinValue(16)));
341 EXPECT_EQ(Empty
.smax(Empty
), Empty
);
342 EXPECT_EQ(Empty
.smax(Some
), Empty
);
343 EXPECT_EQ(Empty
.smax(Wrap
), Empty
);
344 EXPECT_EQ(Empty
.smax(One
), Empty
);
345 EXPECT_EQ(Some
.smax(Some
), Some
);
346 EXPECT_EQ(Some
.smax(Wrap
), ConstantRange(APInt(16, 0xa),
347 APInt(16, (uint64_t)INT16_MIN
)));
348 EXPECT_EQ(Some
.smax(One
), Some
);
349 EXPECT_EQ(Wrap
.smax(One
), ConstantRange(APInt(16, 0xa),
350 APInt(16, (uint64_t)INT16_MIN
)));
351 EXPECT_EQ(One
.smax(One
), One
);
354 TEST_F(ConstantRangeTest
, UDiv
) {
355 EXPECT_EQ(Full
.udiv(Full
), Full
);
356 EXPECT_EQ(Full
.udiv(Empty
), Empty
);
357 EXPECT_EQ(Full
.udiv(One
), ConstantRange(APInt(16, 0),
358 APInt(16, 0xffff / 0xa + 1)));
359 EXPECT_EQ(Full
.udiv(Some
), ConstantRange(APInt(16, 0),
360 APInt(16, 0xffff / 0xa + 1)));
361 EXPECT_EQ(Full
.udiv(Wrap
), Full
);
362 EXPECT_EQ(Empty
.udiv(Empty
), Empty
);
363 EXPECT_EQ(Empty
.udiv(One
), Empty
);
364 EXPECT_EQ(Empty
.udiv(Some
), Empty
);
365 EXPECT_EQ(Empty
.udiv(Wrap
), Empty
);
366 EXPECT_EQ(One
.udiv(One
), ConstantRange(APInt(16, 1)));
367 EXPECT_EQ(One
.udiv(Some
), ConstantRange(APInt(16, 0), APInt(16, 2)));
368 EXPECT_EQ(One
.udiv(Wrap
), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
369 EXPECT_EQ(Some
.udiv(Some
), ConstantRange(APInt(16, 0), APInt(16, 0x111)));
370 EXPECT_EQ(Some
.udiv(Wrap
), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
371 EXPECT_EQ(Wrap
.udiv(Wrap
), Full
);
374 TEST_F(ConstantRangeTest
, Shl
) {
375 EXPECT_EQ(Full
.shl(Full
), Full
);
376 EXPECT_EQ(Full
.shl(Empty
), Empty
);
377 EXPECT_EQ(Full
.shl(One
), Full
); // TODO: [0, (-1 << 0xa) + 1)
378 EXPECT_EQ(Full
.shl(Some
), Full
); // TODO: [0, (-1 << 0xa) + 1)
379 EXPECT_EQ(Full
.shl(Wrap
), Full
);
380 EXPECT_EQ(Empty
.shl(Empty
), Empty
);
381 EXPECT_EQ(Empty
.shl(One
), Empty
);
382 EXPECT_EQ(Empty
.shl(Some
), Empty
);
383 EXPECT_EQ(Empty
.shl(Wrap
), Empty
);
384 EXPECT_EQ(One
.shl(One
), ConstantRange(APInt(16, 0xa << 0xa),
385 APInt(16, (0xa << 0xa) + 1)));
386 EXPECT_EQ(One
.shl(Some
), Full
); // TODO: [0xa << 0xa, 0)
387 EXPECT_EQ(One
.shl(Wrap
), Full
); // TODO: [0xa, 0xa << 14 + 1)
388 EXPECT_EQ(Some
.shl(Some
), Full
); // TODO: [0xa << 0xa, 0xfc01)
389 EXPECT_EQ(Some
.shl(Wrap
), Full
); // TODO: [0xa, 0x7ff << 0x5 + 1)
390 EXPECT_EQ(Wrap
.shl(Wrap
), Full
);
393 TEST_F(ConstantRangeTest
, Lshr
) {
394 EXPECT_EQ(Full
.lshr(Full
), Full
);
395 EXPECT_EQ(Full
.lshr(Empty
), Empty
);
396 EXPECT_EQ(Full
.lshr(One
), ConstantRange(APInt(16, 0),
397 APInt(16, (0xffff >> 0xa) + 1)));
398 EXPECT_EQ(Full
.lshr(Some
), ConstantRange(APInt(16, 0),
399 APInt(16, (0xffff >> 0xa) + 1)));
400 EXPECT_EQ(Full
.lshr(Wrap
), Full
);
401 EXPECT_EQ(Empty
.lshr(Empty
), Empty
);
402 EXPECT_EQ(Empty
.lshr(One
), Empty
);
403 EXPECT_EQ(Empty
.lshr(Some
), Empty
);
404 EXPECT_EQ(Empty
.lshr(Wrap
), Empty
);
405 EXPECT_EQ(One
.lshr(One
), ConstantRange(APInt(16, 0)));
406 EXPECT_EQ(One
.lshr(Some
), ConstantRange(APInt(16, 0)));
407 EXPECT_EQ(One
.lshr(Wrap
), ConstantRange(APInt(16, 0), APInt(16, 0xb)));
408 EXPECT_EQ(Some
.lshr(Some
), ConstantRange(APInt(16, 0),
409 APInt(16, (0xaaa >> 0xa) + 1)));
410 EXPECT_EQ(Some
.lshr(Wrap
), ConstantRange(APInt(16, 0), APInt(16, 0xaaa)));
411 EXPECT_EQ(Wrap
.lshr(Wrap
), Full
);
414 } // anonymous namespace