Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / llvm / a3755d8d366fdd7a2415b93ac0253f8e677c9dfd / . / unittests / Support / ConstantRangeTest.cpp
blob: c5c575031d12ef5de2470beed8046c0daf10cefd [file] [log] [blame]
Dan Gohmana3755d82009-07-09 22:07:27 +0000[diff] [blame^]1//===- llvm/unittest/Support/ConstantRangeTest.cpp - ConstantRange tests --===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "llvm/Support/ConstantRange.h"
11
12#include "gtest/gtest.h"
13
14using namespace llvm;
15
16namespace {
17
18TEST(ConstantRangeTest, Unsigned) {
19 ConstantRange Full(16);
20 ConstantRange Empty(16, false);
21 ConstantRange One(APInt(16, 0xa));
22 ConstantRange Some(APInt(16, 0xa), APInt(16, 0xaaa));
23 ConstantRange Wrap(APInt(16, 0xaaa), APInt(16, 0xa));
24
25 EXPECT_TRUE(Full.isFullSet());
26 EXPECT_FALSE(Full.isEmptySet());
27 EXPECT_FALSE(Full.isWrappedSet());
28 EXPECT_TRUE(Full.contains(APInt(16, 0x0)));
29 EXPECT_TRUE(Full.contains(APInt(16, 0x9)));
30 EXPECT_TRUE(Full.contains(APInt(16, 0xa)));
31 EXPECT_TRUE(Full.contains(APInt(16, 0xaa9)));
32 EXPECT_TRUE(Full.contains(APInt(16, 0xaaa)));
33
34 EXPECT_FALSE(Empty.isFullSet());
35 EXPECT_TRUE(Empty.isEmptySet());
36 EXPECT_FALSE(Empty.isWrappedSet());
37 EXPECT_FALSE(Empty.contains(APInt(16, 0x0)));
38 EXPECT_FALSE(Empty.contains(APInt(16, 0x9)));
39 EXPECT_FALSE(Empty.contains(APInt(16, 0xa)));
40 EXPECT_FALSE(Empty.contains(APInt(16, 0xaa9)));
41 EXPECT_FALSE(Empty.contains(APInt(16, 0xaaa)));
42
43 EXPECT_FALSE(One.isFullSet());
44 EXPECT_FALSE(One.isEmptySet());
45 EXPECT_FALSE(One.isWrappedSet());
46 EXPECT_FALSE(One.contains(APInt(16, 0x0)));
47 EXPECT_FALSE(One.contains(APInt(16, 0x9)));
48 EXPECT_TRUE(One.contains(APInt(16, 0xa)));
49 EXPECT_FALSE(One.contains(APInt(16, 0xaa9)));
50 EXPECT_FALSE(One.contains(APInt(16, 0xaaa)));
51
52 EXPECT_FALSE(Some.isFullSet());
53 EXPECT_FALSE(Some.isEmptySet());
54 EXPECT_FALSE(Some.isWrappedSet());
55 EXPECT_FALSE(Some.contains(APInt(16, 0x0)));
56 EXPECT_FALSE(Some.contains(APInt(16, 0x9)));
57 EXPECT_TRUE(Some.contains(APInt(16, 0xa)));
58 EXPECT_TRUE(Some.contains(APInt(16, 0xaa9)));
59 EXPECT_FALSE(Some.contains(APInt(16, 0xaaa)));
60
61 EXPECT_FALSE(Wrap.isFullSet());
62 EXPECT_FALSE(Wrap.isEmptySet());
63 EXPECT_TRUE(Wrap.isWrappedSet());
64 EXPECT_TRUE(Wrap.contains(APInt(16, 0x0)));
65 EXPECT_TRUE(Wrap.contains(APInt(16, 0x9)));
66 EXPECT_FALSE(Wrap.contains(APInt(16, 0xa)));
67 EXPECT_FALSE(Wrap.contains(APInt(16, 0xaa9)));
68 EXPECT_TRUE(Wrap.contains(APInt(16, 0xaaa)));
69
70 EXPECT_EQ(Full, Full);
71 EXPECT_EQ(Empty, Empty);
72 EXPECT_EQ(One, One);
73 EXPECT_EQ(Some, Some);
74 EXPECT_EQ(Wrap, Wrap);
75 EXPECT_NE(Full, Empty);
76 EXPECT_NE(Full, One);
77 EXPECT_NE(Full, Some);
78 EXPECT_NE(Full, Wrap);
79 EXPECT_NE(Empty, One);
80 EXPECT_NE(Empty, Some);
81 EXPECT_NE(Empty, Wrap);
82 EXPECT_NE(One, Some);
83 EXPECT_NE(One, Wrap);
84 EXPECT_NE(Some, Wrap);
85
86 EXPECT_EQ(Full.getSingleElement(), static_cast<APInt *>(NULL));
87 EXPECT_EQ(Empty.getSingleElement(), static_cast<APInt *>(NULL));
88 EXPECT_EQ(*One.getSingleElement(), APInt(16, 0xa));
89 EXPECT_EQ(Some.getSingleElement(), static_cast<APInt *>(NULL));
90 EXPECT_EQ(Wrap.getSingleElement(), static_cast<APInt *>(NULL));
91
92 EXPECT_FALSE(Full.isSingleElement());
93 EXPECT_FALSE(Empty.isSingleElement());
94 EXPECT_TRUE(One.isSingleElement());
95 EXPECT_FALSE(Some.isSingleElement());
96 EXPECT_FALSE(Wrap.isSingleElement());
97
98 EXPECT_EQ(Full.getSetSize(), APInt(16, 0));
99 EXPECT_EQ(Empty.getSetSize(), APInt(16, 0));
100 EXPECT_EQ(One.getSetSize(), APInt(16, 1));
101 EXPECT_EQ(Some.getSetSize(), APInt(16, 0xaa0));
102 EXPECT_EQ(Wrap.getSetSize(), APInt(16, 0x10000 - 0xaa0));
103
104 EXPECT_EQ(Full.getUnsignedMax(), APInt(16, UINT16_MAX));
105 EXPECT_EQ(One.getUnsignedMax(), APInt(16, 0xa));
106 EXPECT_EQ(Some.getUnsignedMax(), APInt(16, 0xaa9));
107 EXPECT_EQ(Wrap.getUnsignedMax(), APInt(16, UINT16_MAX));
108
109 EXPECT_EQ(Full.getUnsignedMin(), APInt(16, 0));
110 EXPECT_EQ(One.getUnsignedMin(), APInt(16, 0xa));
111 EXPECT_EQ(Some.getUnsignedMin(), APInt(16, 0xa));
112 EXPECT_EQ(Wrap.getUnsignedMin(), APInt(16, 0));
113
114 EXPECT_EQ(Full.getSignedMax(), APInt(16, INT16_MAX));
115 EXPECT_EQ(One.getSignedMax(), APInt(16, 0xa));
116 EXPECT_EQ(Some.getSignedMax(), APInt(16, 0xaa9));
117 EXPECT_EQ(Wrap.getSignedMax(), APInt(16, INT16_MAX));
118
119 EXPECT_EQ(Full.getSignedMin(), APInt(16, INT16_MIN));
120 EXPECT_EQ(One.getSignedMin(), APInt(16, 0xa));
121 EXPECT_EQ(Some.getSignedMin(), APInt(16, 0xa));
122 EXPECT_EQ(Wrap.getSignedMin(), APInt(16, INT16_MIN));
123
124 ConstantRange TFull = Full.truncate(10);
125 ConstantRange TEmpty = Empty.truncate(10);
126 ConstantRange TOne = One.truncate(10);
127 ConstantRange TSome = Some.truncate(10);
128 ConstantRange TWrap = Wrap.truncate(10);
129 EXPECT_TRUE(TFull.isFullSet());
130 EXPECT_TRUE(TEmpty.isEmptySet());
131 EXPECT_EQ(TOne, ConstantRange(APInt(One.getLower()).trunc(10),
132 APInt(One.getUpper()).trunc(10)));
133 // TODO: ConstantRange is currently over-conservative here.
134 EXPECT_TRUE(TSome.isFullSet());
135
136 ConstantRange ZFull = Full.zeroExtend(20);
137 ConstantRange ZEmpty = Empty.zeroExtend(20);
138 ConstantRange ZOne = One.zeroExtend(20);
139 ConstantRange ZSome = Some.zeroExtend(20);
140 ConstantRange ZWrap = Wrap.zeroExtend(20);
141 EXPECT_EQ(ZFull, ConstantRange(APInt(20, 0), APInt(20, 0x10000)));
142 EXPECT_TRUE(ZEmpty.isEmptySet());
143 EXPECT_EQ(ZOne, ConstantRange(APInt(One.getLower()).zext(20),
144 APInt(One.getUpper()).zext(20)));
145 EXPECT_EQ(ZSome, ConstantRange(APInt(Some.getLower()).zext(20),
146 APInt(Some.getUpper()).zext(20)));
147 EXPECT_EQ(ZWrap, ConstantRange(APInt(Wrap.getLower()).zext(20),
148 APInt(Wrap.getUpper()).zext(20)));
149
150 ConstantRange SFull = Full.signExtend(20);
151 ConstantRange SEmpty = Empty.signExtend(20);
152 ConstantRange SOne = One.signExtend(20);
153 ConstantRange SSome = Some.signExtend(20);
154 ConstantRange SWrap = Wrap.signExtend(20);
155 EXPECT_EQ(SFull, ConstantRange(APInt(20, INT16_MIN, true),
156 APInt(20, INT16_MAX, true)));
157 EXPECT_TRUE(SEmpty.isEmptySet());
158 EXPECT_EQ(SOne, ConstantRange(APInt(One.getLower()).sext(20),
159 APInt(One.getUpper()).sext(20)));
160 EXPECT_EQ(SSome, ConstantRange(APInt(Some.getLower()).sext(20),
161 APInt(Some.getUpper()).sext(20)));
162 EXPECT_EQ(SWrap, ConstantRange(APInt(Wrap.getLower()).sext(20),
163 APInt(Wrap.getUpper()).sext(20)));
164
165 EXPECT_TRUE(Empty.intersectWith(Full).isEmptySet());
166 EXPECT_TRUE(Empty.intersectWith(Empty).isEmptySet());
167 EXPECT_TRUE(Empty.intersectWith(One).isEmptySet());
168 EXPECT_TRUE(Empty.intersectWith(Some).isEmptySet());
169 EXPECT_TRUE(Empty.intersectWith(Wrap).isEmptySet());
170 EXPECT_TRUE(Full.intersectWith(Full).isFullSet());
171 EXPECT_TRUE(Some.intersectWith(Some) == Some);
172 EXPECT_TRUE(Some.intersectWith(One) == One);
173 EXPECT_TRUE(Full.intersectWith(One) == One);
174 EXPECT_TRUE(Full.intersectWith(Some) == Some);
175 EXPECT_TRUE(Some.intersectWith(Wrap).isEmptySet());
176 EXPECT_TRUE(One.intersectWith(Wrap).isEmptySet());
177 EXPECT_EQ(One.intersectWith(Wrap), Wrap.intersectWith(One));
178
179 EXPECT_TRUE(Empty.maximalIntersectWith(Full).isEmptySet());
180 EXPECT_TRUE(Empty.maximalIntersectWith(Empty).isEmptySet());
181 EXPECT_TRUE(Empty.maximalIntersectWith(One).isEmptySet());
182 EXPECT_TRUE(Empty.maximalIntersectWith(Some).isEmptySet());
183 EXPECT_TRUE(Empty.maximalIntersectWith(Wrap).isEmptySet());
184 EXPECT_TRUE(Full.maximalIntersectWith(Full).isFullSet());
185 EXPECT_TRUE(Some.maximalIntersectWith(Some) == Some);
186 EXPECT_TRUE(Some.maximalIntersectWith(One) == One);
187 EXPECT_TRUE(Full.maximalIntersectWith(One) == One);
188 EXPECT_TRUE(Full.maximalIntersectWith(Some) == Some);
189 EXPECT_TRUE(Some.maximalIntersectWith(Wrap).isEmptySet());
190 EXPECT_TRUE(One.maximalIntersectWith(Wrap).isEmptySet());
191 EXPECT_EQ(One.maximalIntersectWith(Wrap), Wrap.maximalIntersectWith(One));
192
193 EXPECT_EQ(Wrap.unionWith(One),
194 ConstantRange(APInt(16, 0xaaa), APInt(16, 0xb)));
195 EXPECT_EQ(One.unionWith(Wrap), Wrap.unionWith(One));
196 EXPECT_TRUE(Empty.unionWith(Empty).isEmptySet());
197 EXPECT_TRUE(Full.unionWith(Full).isFullSet());
198 EXPECT_TRUE(Some.unionWith(Wrap).isFullSet());
199
200 EXPECT_TRUE(Full.subtract(APInt(16, 4)).isFullSet());
201 EXPECT_TRUE(Empty.subtract(APInt(16, 4)).isEmptySet());
202 EXPECT_EQ(Some.subtract(APInt(16, 4)),
203 ConstantRange(APInt(16, 0x6), APInt(16, 0xaa6)));
204 EXPECT_EQ(Wrap.subtract(APInt(16, 4)),
205 ConstantRange(APInt(16, 0xaa6), APInt(16, 0x6)));
206 EXPECT_EQ(One.subtract(APInt(16, 4)),
207 ConstantRange(APInt(16, 0x6)));
208
209 EXPECT_TRUE(Full.add(APInt(16, 4)).isFullSet());
210 EXPECT_TRUE(Empty.add(APInt(16, 4)).isEmptySet());
211 EXPECT_EQ(Some.add(APInt(16, 4)),
212 ConstantRange(APInt(16, 0xe), APInt(16, 0xaae)));
213 EXPECT_EQ(Wrap.add(APInt(16, 4)),
214 ConstantRange(APInt(16, 0xaae), APInt(16, 0xe)));
215 EXPECT_EQ(One.add(APInt(16, 4)),
216 ConstantRange(APInt(16, 0xe)));
217
218 EXPECT_TRUE(Full.umax(Full).isFullSet());
219 EXPECT_TRUE(Full.umax(Empty).isEmptySet());
220 EXPECT_TRUE(Full.umax(Some).isFullSet());
221 EXPECT_TRUE(Full.umax(Wrap).isFullSet());
222 EXPECT_TRUE(Full.umax(One).isFullSet());
223 EXPECT_EQ(Empty.umax(Empty), Empty);
224 EXPECT_EQ(Empty.umax(Some), Empty);
225 EXPECT_EQ(Empty.umax(Wrap), Empty);
226 EXPECT_EQ(Empty.umax(One), Empty);
227 EXPECT_EQ(Some.umax(Some), Some);
228 EXPECT_EQ(Some.umax(Wrap), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
229 EXPECT_EQ(Some.umax(One), Some);
230 // TODO: ConstantRange is currently over-conservative here.
231 EXPECT_EQ(Wrap.umax(Wrap), Full);
232 EXPECT_EQ(Wrap.umax(One), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
233 EXPECT_EQ(One.umax(One), One);
234
235 EXPECT_EQ(Full.multiply(Full), Full);
236 EXPECT_EQ(Full.multiply(Empty), Empty);
237 EXPECT_EQ(Full.multiply(One), Full);
238 EXPECT_EQ(Full.multiply(Some), Full);
239 EXPECT_EQ(Full.multiply(Wrap), Full);
240 EXPECT_EQ(Empty.multiply(Empty), Empty);
241 EXPECT_EQ(Empty.multiply(One), Empty);
242 EXPECT_EQ(Empty.multiply(Some), Empty);
243 EXPECT_EQ(Empty.multiply(Wrap), Empty);
244 // TODO: ConstantRange is currently over-conservative here.
245 EXPECT_EQ(One.multiply(One), Full);
246 // TODO: ConstantRange is currently over-conservative here.
247 EXPECT_EQ(One.multiply(Some), Full);
248 // TODO: ConstantRange is currently over-conservative here.
249 EXPECT_EQ(One.multiply(Wrap), Full);
250 // TODO: ConstantRange is currently over-conservative here.
251 EXPECT_EQ(Some.multiply(Some), Full);
252 // TODO: ConstantRange is currently over-conservative here.
253 EXPECT_EQ(Some.multiply(Wrap), Full);
254 // TODO: ConstantRange is currently over-conservative here.
255 EXPECT_EQ(Wrap.multiply(Wrap), Full);
256
257 EXPECT_EQ(Full.smax(Full), Full);
258 EXPECT_EQ(Full.smax(Empty), Empty);
259 EXPECT_EQ(Full.smax(One), Full);
260 EXPECT_EQ(Full.smax(Some), Full);
261 EXPECT_EQ(Full.smax(Wrap), Full);
262 EXPECT_EQ(Empty.smax(Empty), Empty);
263 EXPECT_EQ(Empty.smax(One), Empty);
264 EXPECT_EQ(Empty.smax(Some), Empty);
265 EXPECT_EQ(Empty.smax(Wrap), Empty);
266 // TODO: ConstantRange is currently over-conservative here.
267 EXPECT_EQ(One.smax(One), Full);
268 // TODO: ConstantRange is currently over-conservative here.
269 EXPECT_EQ(One.smax(Some), Full);
270 // TODO: ConstantRange is currently over-conservative here.
271 EXPECT_EQ(One.smax(Wrap), Full);
272 // TODO: ConstantRange is currently over-conservative here.
273 EXPECT_EQ(Some.smax(Some), Full);
274 // TODO: ConstantRange is currently over-conservative here.
275 EXPECT_EQ(Some.smax(Wrap), Full);
276 // TODO: ConstantRange is currently over-conservative here.
277 EXPECT_EQ(Wrap.smax(Wrap), Full);
278
279 EXPECT_EQ(Full.udiv(Full), Full);
280 EXPECT_EQ(Full.udiv(Empty), Empty);
281 EXPECT_EQ(Full.udiv(One), Full);
282 EXPECT_EQ(Full.udiv(Some), Full);
283 EXPECT_EQ(Full.udiv(Wrap), Full);
284 EXPECT_EQ(Empty.udiv(Empty), Empty);
285 EXPECT_EQ(Empty.udiv(One), Empty);
286 EXPECT_EQ(Empty.udiv(Some), Empty);
287 EXPECT_EQ(Empty.udiv(Wrap), Empty);
288 // TODO: ConstantRange is currently over-conservative here.
289 EXPECT_EQ(One.udiv(One), Full);
290 // TODO: ConstantRange is currently over-conservative here.
291 EXPECT_EQ(One.udiv(Some), Full);
292 // TODO: ConstantRange is currently over-conservative here.
293 EXPECT_EQ(One.udiv(Wrap), Full);
294 // TODO: ConstantRange is currently over-conservative here.
295 EXPECT_EQ(Some.udiv(Some), Full);
296 // TODO: ConstantRange is currently over-conservative here.
297 EXPECT_EQ(Some.udiv(Wrap), Full);
298 // TODO: ConstantRange is currently over-conservative here.
299 EXPECT_EQ(Wrap.udiv(Wrap), Full);
300
301}
302
303TEST(ConstantRangeTest, Signed) {
304 ConstantSignedRange Full(16);
305 ConstantSignedRange Empty(16, false);
306 ConstantSignedRange One(APInt(16, 0xa));
307 ConstantSignedRange Some(APInt(16, 0xa), APInt(16, 0xaaa));
308 ConstantSignedRange Wrap(APInt(16, 0xaaa), APInt(16, 0xa));
309
310 EXPECT_TRUE(Full.isFullSet());
311 EXPECT_FALSE(Full.isEmptySet());
312 EXPECT_FALSE(Full.isWrappedSet());
313 EXPECT_TRUE(Full.contains(APInt(16, 0x0)));
314 EXPECT_TRUE(Full.contains(APInt(16, 0x9)));
315 EXPECT_TRUE(Full.contains(APInt(16, 0xa)));
316 EXPECT_TRUE(Full.contains(APInt(16, 0xaa9)));
317 EXPECT_TRUE(Full.contains(APInt(16, 0xaaa)));
318
319 EXPECT_FALSE(Empty.isFullSet());
320 EXPECT_TRUE(Empty.isEmptySet());
321 EXPECT_FALSE(Empty.isWrappedSet());
322 EXPECT_FALSE(Empty.contains(APInt(16, 0x0)));
323 EXPECT_FALSE(Empty.contains(APInt(16, 0x9)));
324 EXPECT_FALSE(Empty.contains(APInt(16, 0xa)));
325 EXPECT_FALSE(Empty.contains(APInt(16, 0xaa9)));
326 EXPECT_FALSE(Empty.contains(APInt(16, 0xaaa)));
327
328 EXPECT_FALSE(One.isFullSet());
329 EXPECT_FALSE(One.isEmptySet());
330 EXPECT_FALSE(One.isWrappedSet());
331 EXPECT_FALSE(One.contains(APInt(16, 0x0)));
332 EXPECT_FALSE(One.contains(APInt(16, 0x9)));
333 EXPECT_TRUE(One.contains(APInt(16, 0xa)));
334 EXPECT_FALSE(One.contains(APInt(16, 0xaa9)));
335 EXPECT_FALSE(One.contains(APInt(16, 0xaaa)));
336
337 EXPECT_FALSE(Some.isFullSet());
338 EXPECT_FALSE(Some.isEmptySet());
339 EXPECT_FALSE(Some.isWrappedSet());
340 EXPECT_FALSE(Some.contains(APInt(16, 0x0)));
341 EXPECT_FALSE(Some.contains(APInt(16, 0x9)));
342 EXPECT_TRUE(Some.contains(APInt(16, 0xa)));
343 EXPECT_TRUE(Some.contains(APInt(16, 0xaa9)));
344 EXPECT_FALSE(Some.contains(APInt(16, 0xaaa)));
345
346 EXPECT_FALSE(Wrap.isFullSet());
347 EXPECT_FALSE(Wrap.isEmptySet());
348 EXPECT_TRUE(Wrap.isWrappedSet());
349 EXPECT_TRUE(Wrap.contains(APInt(16, 0x0)));
350 EXPECT_TRUE(Wrap.contains(APInt(16, 0x9)));
351 EXPECT_FALSE(Wrap.contains(APInt(16, 0xa)));
352 EXPECT_FALSE(Wrap.contains(APInt(16, 0xaa9)));
353 EXPECT_TRUE(Wrap.contains(APInt(16, 0xaaa)));
354
355 EXPECT_EQ(Full, Full);
356 EXPECT_EQ(Empty, Empty);
357 EXPECT_EQ(One, One);
358 EXPECT_EQ(Some, Some);
359 EXPECT_EQ(Wrap, Wrap);
360 EXPECT_NE(Full, Empty);
361 EXPECT_NE(Full, One);
362 EXPECT_NE(Full, Some);
363 EXPECT_NE(Full, Wrap);
364 EXPECT_NE(Empty, One);
365 EXPECT_NE(Empty, Some);
366 EXPECT_NE(Empty, Wrap);
367 EXPECT_NE(One, Some);
368 EXPECT_NE(One, Wrap);
369 EXPECT_NE(Some, Wrap);
370
371 EXPECT_EQ(Full.getSingleElement(), static_cast<APInt *>(NULL));
372 EXPECT_EQ(Empty.getSingleElement(), static_cast<APInt *>(NULL));
373 EXPECT_EQ(*One.getSingleElement(), APInt(16, 0xa));
374 EXPECT_EQ(Some.getSingleElement(), static_cast<APInt *>(NULL));
375 EXPECT_EQ(Wrap.getSingleElement(), static_cast<APInt *>(NULL));
376
377 EXPECT_FALSE(Full.isSingleElement());
378 EXPECT_FALSE(Empty.isSingleElement());
379 EXPECT_TRUE(One.isSingleElement());
380 EXPECT_FALSE(Some.isSingleElement());
381 EXPECT_FALSE(Wrap.isSingleElement());
382
383 EXPECT_EQ(Full.getSetSize(), APInt(16, 0));
384 EXPECT_EQ(Empty.getSetSize(), APInt(16, 0));
385 EXPECT_EQ(One.getSetSize(), APInt(16, 1));
386 EXPECT_EQ(Some.getSetSize(), APInt(16, 0xaa0));
387 EXPECT_EQ(Wrap.getSetSize(), APInt(16, 0x10000 - 0xaa0));
388
389 EXPECT_EQ(Full.getSignedMax(), APInt(16, INT16_MAX, true));
390 EXPECT_EQ(One.getSignedMax(), APInt(16, 0xa));
391 EXPECT_EQ(Some.getSignedMax(), APInt(16, 0xaa9));
392 EXPECT_EQ(Wrap.getSignedMax(), APInt(16, INT16_MAX));
393
394 EXPECT_EQ(Full.getSignedMin(), APInt(16, INT16_MIN));
395 EXPECT_EQ(One.getSignedMin(), APInt(16, 0xa));
396 EXPECT_EQ(Some.getSignedMin(), APInt(16, 0xa));
397 EXPECT_EQ(Wrap.getSignedMin(), APInt(16, INT16_MIN));
398
399 EXPECT_EQ(Full.getUnsignedMax(), APInt(16, UINT16_MAX, true));
400 EXPECT_EQ(One.getUnsignedMax(), APInt(16, 0xa));
401 EXPECT_EQ(Some.getUnsignedMax(), APInt(16, 0xaa9));
402 EXPECT_EQ(Wrap.getUnsignedMax(), APInt(16, UINT16_MAX));
403
404 EXPECT_EQ(Full.getUnsignedMin(), APInt(16, 0));
405 EXPECT_EQ(One.getUnsignedMin(), APInt(16, 0xa));
406 EXPECT_EQ(Some.getUnsignedMin(), APInt(16, 0xa));
407 EXPECT_EQ(Wrap.getUnsignedMin(), APInt(16, 0));
408
409 ConstantSignedRange TFull = Full.truncate(10);
410 ConstantSignedRange TEmpty = Empty.truncate(10);
411 ConstantSignedRange TOne = One.truncate(10);
412 ConstantSignedRange TSome = Some.truncate(10);
413 ConstantSignedRange TWrap = Wrap.truncate(10);
414 EXPECT_TRUE(TFull.isFullSet());
415 EXPECT_TRUE(TEmpty.isEmptySet());
416 // TODO: ConstantSignedRange is currently over-conservative here.
417 EXPECT_TRUE(TOne.isFullSet());
418 // TODO: ConstantSignedRange is currently over-conservative here.
419 EXPECT_TRUE(TSome.isFullSet());
420 // TODO: ConstantSignedRange is currently over-conservative here.
421 EXPECT_TRUE(TWrap.isFullSet());
422
423 ConstantSignedRange ZFull = Full.zeroExtend(20);
424 ConstantSignedRange ZEmpty = Empty.zeroExtend(20);
425 ConstantSignedRange ZOne = One.zeroExtend(20);
426 ConstantSignedRange ZSome = Some.zeroExtend(20);
427 ConstantSignedRange ZWrap = Wrap.zeroExtend(20);
428 EXPECT_EQ(ZFull, ConstantSignedRange(APInt(20, 0), APInt(20, 0x10000)));
429 EXPECT_TRUE(ZEmpty.isEmptySet());
430 EXPECT_EQ(ZOne, ConstantSignedRange(APInt(One.getLower()).zext(20),
431 APInt(One.getUpper()).zext(20)));
432 EXPECT_EQ(ZSome, ConstantSignedRange(APInt(Some.getLower()).zext(20),
433 APInt(Some.getUpper()).zext(20)));
434 EXPECT_EQ(ZWrap, ConstantSignedRange(APInt(Wrap.getLower()).zext(20),
435 APInt(Wrap.getUpper()).zext(20)));
436
437 ConstantSignedRange SFull = Full.signExtend(20);
438 ConstantSignedRange SEmpty = Empty.signExtend(20);
439 ConstantSignedRange SOne = One.signExtend(20);
440 ConstantSignedRange SSome = Some.signExtend(20);
441 ConstantSignedRange SWrap = Wrap.signExtend(20);
442 EXPECT_EQ(SFull, ConstantSignedRange(APInt(20, INT16_MIN),
443 APInt(20, INT16_MAX+1)));
444 EXPECT_TRUE(SEmpty.isEmptySet());
445 EXPECT_EQ(SOne, ConstantSignedRange(APInt(One.getLower()).sext(20),
446 APInt(One.getUpper()).sext(20)));
447 EXPECT_EQ(SSome, ConstantSignedRange(APInt(Some.getLower()).sext(20),
448 APInt(Some.getUpper()).sext(20)));
449 EXPECT_EQ(SWrap, ConstantSignedRange(APInt(Wrap.getLower()).sext(20),
450 APInt(Wrap.getUpper()).sext(20)));
451
452 EXPECT_TRUE(Empty.intersectWith(Full).isEmptySet());
453 EXPECT_TRUE(Empty.intersectWith(Empty).isEmptySet());
454 EXPECT_TRUE(Empty.intersectWith(One).isEmptySet());
455 EXPECT_TRUE(Empty.intersectWith(Some).isEmptySet());
456 EXPECT_TRUE(Empty.intersectWith(Wrap).isEmptySet());
457 EXPECT_TRUE(Full.intersectWith(Full).isFullSet());
458 EXPECT_TRUE(Some.intersectWith(Some) == Some);
459 EXPECT_TRUE(Some.intersectWith(One) == One);
460 EXPECT_TRUE(Full.intersectWith(One) == One);
461 EXPECT_TRUE(Full.intersectWith(Some) == Some);
462 EXPECT_TRUE(Some.intersectWith(Wrap).isEmptySet());
463 EXPECT_TRUE(One.intersectWith(Wrap).isEmptySet());
464 EXPECT_EQ(One.intersectWith(Wrap), Wrap.intersectWith(One));
465
466 EXPECT_TRUE(Empty.maximalIntersectWith(Full).isEmptySet());
467 EXPECT_TRUE(Empty.maximalIntersectWith(Empty).isEmptySet());
468 EXPECT_TRUE(Empty.maximalIntersectWith(One).isEmptySet());
469 EXPECT_TRUE(Empty.maximalIntersectWith(Some).isEmptySet());
470 EXPECT_TRUE(Empty.maximalIntersectWith(Wrap).isEmptySet());
471 EXPECT_TRUE(Full.maximalIntersectWith(Full).isFullSet());
472 EXPECT_TRUE(Some.maximalIntersectWith(Some) == Some);
473 EXPECT_TRUE(Some.maximalIntersectWith(One) == One);
474 EXPECT_TRUE(Full.maximalIntersectWith(One) == One);
475 EXPECT_TRUE(Full.maximalIntersectWith(Some) == Some);
476 EXPECT_TRUE(Some.maximalIntersectWith(Wrap).isEmptySet());
477 EXPECT_TRUE(One.maximalIntersectWith(Wrap).isEmptySet());
478 EXPECT_EQ(One.maximalIntersectWith(Wrap), Wrap.maximalIntersectWith(One));
479
480 EXPECT_EQ(Wrap.unionWith(One),
481 ConstantSignedRange(APInt(16, 0xaaa), APInt(16, 0xb)));
482 EXPECT_EQ(One.unionWith(Wrap), Wrap.unionWith(One));
483 EXPECT_TRUE(Empty.unionWith(Empty).isEmptySet());
484 EXPECT_TRUE(Full.unionWith(Full).isFullSet());
485 EXPECT_TRUE(Some.unionWith(Wrap).isFullSet());
486
487 EXPECT_TRUE(Full.subtract(APInt(16, 4)).isFullSet());
488 EXPECT_TRUE(Empty.subtract(APInt(16, 4)).isEmptySet());
489 EXPECT_EQ(Some.subtract(APInt(16, 4)),
490 ConstantSignedRange(APInt(16, 0x6), APInt(16, 0xaa6)));
491 EXPECT_EQ(Wrap.subtract(APInt(16, 4)),
492 ConstantSignedRange(APInt(16, 0xaa6), APInt(16, 0x6)));
493 EXPECT_EQ(One.subtract(APInt(16, 4)),
494 ConstantSignedRange(APInt(16, 0x6)));
495
496 EXPECT_TRUE(Full.smax(Full).isFullSet());
497 EXPECT_TRUE(Full.smax(Empty).isEmptySet());
498 EXPECT_TRUE(Full.smax(Some).isFullSet());
499 EXPECT_TRUE(Full.smax(Wrap).isFullSet());
500 EXPECT_TRUE(Full.smax(One).isFullSet());
501 EXPECT_EQ(Empty.smax(Empty), Empty);
502 EXPECT_EQ(Empty.smax(Some), Empty);
503 EXPECT_EQ(Empty.smax(Wrap), Empty);
504 EXPECT_EQ(Empty.smax(One), Empty);
505 EXPECT_EQ(Some.smax(Some), Some);
506 EXPECT_EQ(Some.smax(Wrap), ConstantSignedRange(APInt(16, 0xa),
507 APInt(16, INT16_MIN)));
508 EXPECT_EQ(Some.smax(One), Some);
509 // TODO: ConstantSignedRange is currently over-conservative here.
510 EXPECT_EQ(Wrap.smax(Wrap), Full);
511 EXPECT_EQ(Wrap.smax(One), ConstantSignedRange(APInt(16, 0xa),
512 APInt(16, INT16_MIN)));
513 EXPECT_EQ(One.smax(One), One);
514
515 EXPECT_EQ(Full.add(Full), Full);
516 EXPECT_EQ(Full.add(Empty), Empty);
517 EXPECT_EQ(Full.add(One), Full);
518 EXPECT_EQ(Full.add(Some), Full);
519 EXPECT_EQ(Full.add(Wrap), Full);
520 EXPECT_EQ(Empty.add(Empty), Empty);
521 EXPECT_EQ(Empty.add(One), Empty);
522 EXPECT_EQ(Empty.add(Some), Empty);
523 EXPECT_EQ(Empty.add(Wrap), Empty);
524 // TODO: ConstantSignedRange is currently over-conservative here.
525 EXPECT_EQ(One.add(One), Full);
526 // TODO: ConstantSignedRange is currently over-conservative here.
527 EXPECT_EQ(One.add(Some), Full);
528 // TODO: ConstantSignedRange is currently over-conservative here.
529 EXPECT_EQ(One.add(Wrap), Full);
530 // TODO: ConstantSignedRange is currently over-conservative here.
531 EXPECT_EQ(Some.add(Some), Full);
532 // TODO: ConstantSignedRange is currently over-conservative here.
533 EXPECT_EQ(Some.add(Wrap), Full);
534 // TODO: ConstantSignedRange is currently over-conservative here.
535 EXPECT_EQ(Wrap.add(Wrap), Full);
536
537 EXPECT_EQ(Full.multiply(Full), Full);
538 EXPECT_EQ(Full.multiply(Empty), Empty);
539 EXPECT_EQ(Full.multiply(One), Full);
540 EXPECT_EQ(Full.multiply(Some), Full);
541 EXPECT_EQ(Full.multiply(Wrap), Full);
542 EXPECT_EQ(Empty.multiply(Empty), Empty);
543 EXPECT_EQ(Empty.multiply(One), Empty);
544 EXPECT_EQ(Empty.multiply(Some), Empty);
545 EXPECT_EQ(Empty.multiply(Wrap), Empty);
546 // TODO: ConstantSignedRange is currently over-conservative here.
547 EXPECT_EQ(One.multiply(One), Full);
548 // TODO: ConstantSignedRange is currently over-conservative here.
549 EXPECT_EQ(One.multiply(Some), Full);
550 // TODO: ConstantSignedRange is currently over-conservative here.
551 EXPECT_EQ(One.multiply(Wrap), Full);
552 // TODO: ConstantSignedRange is currently over-conservative here.
553 EXPECT_EQ(Some.multiply(Some), Full);
554 // TODO: ConstantSignedRange is currently over-conservative here.
555 EXPECT_EQ(Some.multiply(Wrap), Full);
556 // TODO: ConstantSignedRange is currently over-conservative here.
557 EXPECT_EQ(Wrap.multiply(Wrap), Full);
558
559 EXPECT_EQ(Full.umax(Full), Full);
560 EXPECT_EQ(Full.umax(Empty), Empty);
561 EXPECT_EQ(Full.umax(One), Full);
562 EXPECT_EQ(Full.umax(Some), Full);
563 EXPECT_EQ(Full.umax(Wrap), Full);
564 EXPECT_EQ(Empty.umax(Empty), Empty);
565 EXPECT_EQ(Empty.umax(One), Empty);
566 EXPECT_EQ(Empty.umax(Some), Empty);
567 EXPECT_EQ(Empty.umax(Wrap), Empty);
568 // TODO: ConstantSignedRange is currently over-conservative here.
569 EXPECT_EQ(One.umax(One), Full);
570 // TODO: ConstantSignedRange is currently over-conservative here.
571 EXPECT_EQ(One.umax(Some), Full);
572 // TODO: ConstantSignedRange is currently over-conservative here.
573 EXPECT_EQ(One.umax(Wrap), Full);
574 // TODO: ConstantSignedRange is currently over-conservative here.
575 EXPECT_EQ(Some.umax(Some), Full);
576 // TODO: ConstantSignedRange is currently over-conservative here.
577 EXPECT_EQ(Some.umax(Wrap), Full);
578 // TODO: ConstantSignedRange is currently over-conservative here.
579 EXPECT_EQ(Wrap.umax(Wrap), Full);
580}
581
582} // anonymous namespace