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 TEST(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));
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)));
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)));
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)));
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)));
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)));
70 EXPECT_EQ(Full, Full);
71 EXPECT_EQ(Empty, Empty);
73 EXPECT_EQ(Some, Some);
74 EXPECT_EQ(Wrap, Wrap);
75 EXPECT_NE(Full, Empty);
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);
84 EXPECT_NE(Some, Wrap);
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));
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());
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));
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));
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));
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));
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));
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());
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)));
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)));
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));
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));
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());
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)));
209 EXPECT_TRUE(Full.add(APInt(16, 4)).isFullSet());
210 EXPECT_EQ(Full.add(Empty), Empty);
211 EXPECT_EQ(Full.add(One), Full);
212 EXPECT_EQ(Full.add(Some), Full);
213 EXPECT_EQ(Full.add(Wrap), Full);
214 EXPECT_EQ(Empty.add(Empty), Empty);
215 EXPECT_EQ(Empty.add(One), Empty);
216 EXPECT_EQ(Empty.add(Some), Empty);
217 EXPECT_EQ(Empty.add(Wrap), Empty);
218 EXPECT_TRUE(Empty.add(APInt(16, 4)).isEmptySet());
219 EXPECT_EQ(Some.add(APInt(16, 4)),
220 ConstantRange(APInt(16, 0xe), APInt(16, 0xaae)));
221 EXPECT_EQ(Wrap.add(APInt(16, 4)),
222 ConstantRange(APInt(16, 0xaae), APInt(16, 0xe)));
223 EXPECT_EQ(One.add(APInt(16, 4)),
224 ConstantRange(APInt(16, 0xe)));
226 EXPECT_TRUE(Full.umax(Full).isFullSet());
227 EXPECT_TRUE(Full.umax(Empty).isEmptySet());
228 EXPECT_TRUE(Full.umax(Some).isFullSet());
229 EXPECT_TRUE(Full.umax(Wrap).isFullSet());
230 EXPECT_TRUE(Full.umax(One).isFullSet());
231 EXPECT_EQ(Empty.umax(Empty), Empty);
232 EXPECT_EQ(Empty.umax(Some), Empty);
233 EXPECT_EQ(Empty.umax(Wrap), Empty);
234 EXPECT_EQ(Empty.umax(One), Empty);
235 EXPECT_EQ(Some.umax(Some), Some);
236 EXPECT_EQ(Some.umax(Wrap), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
237 EXPECT_EQ(Some.umax(One), Some);
238 // TODO: ConstantRange is currently over-conservative here.
239 EXPECT_EQ(Wrap.umax(Wrap), Full);
240 EXPECT_EQ(Wrap.umax(One), ConstantRange(APInt(16, 0xa), APInt(16, 0)));
241 EXPECT_EQ(One.umax(One), One);
243 EXPECT_EQ(Full.multiply(Full), Full);
244 EXPECT_EQ(Full.multiply(Empty), Empty);
245 EXPECT_EQ(Full.multiply(One), Full);
246 EXPECT_EQ(Full.multiply(Some), Full);
247 EXPECT_EQ(Full.multiply(Wrap), Full);
248 EXPECT_EQ(Empty.multiply(Empty), Empty);
249 EXPECT_EQ(Empty.multiply(One), Empty);
250 EXPECT_EQ(Empty.multiply(Some), Empty);
251 EXPECT_EQ(Empty.multiply(Wrap), Empty);
252 // TODO: ConstantRange is currently over-conservative here.
253 EXPECT_EQ(One.multiply(One), Full);
254 // TODO: ConstantRange is currently over-conservative here.
255 EXPECT_EQ(One.multiply(Some), Full);
256 // TODO: ConstantRange is currently over-conservative here.
257 EXPECT_EQ(One.multiply(Wrap), Full);
258 // TODO: ConstantRange is currently over-conservative here.
259 EXPECT_EQ(Some.multiply(Some), Full);
260 // TODO: ConstantRange is currently over-conservative here.
261 EXPECT_EQ(Some.multiply(Wrap), Full);
262 // TODO: ConstantRange is currently over-conservative here.
263 EXPECT_EQ(Wrap.multiply(Wrap), Full);
265 EXPECT_TRUE(Full.smax(Full).isFullSet());
266 EXPECT_TRUE(Full.smax(Empty).isEmptySet());
267 EXPECT_TRUE(Full.smax(Some).isFullSet());
268 EXPECT_TRUE(Full.smax(Wrap).isFullSet());
269 EXPECT_TRUE(Full.smax(One).isFullSet());
270 EXPECT_EQ(Empty.smax(Empty), Empty);
271 EXPECT_EQ(Empty.smax(Some), Empty);
272 EXPECT_EQ(Empty.smax(Wrap), Empty);
273 EXPECT_EQ(Empty.smax(One), Empty);
274 EXPECT_EQ(Some.smax(Some), Some);
275 EXPECT_EQ(Some.smax(Wrap), ConstantRange(APInt(16, 0xa),
276 APInt(16, INT16_MIN)));
277 EXPECT_EQ(Some.smax(One), Some);
278 EXPECT_EQ(Wrap.smax(One), ConstantRange(APInt(16, 0xa),
279 APInt(16, INT16_MIN)));
280 EXPECT_EQ(One.smax(One), One);
282 EXPECT_EQ(Full.udiv(Full), Full);
283 EXPECT_EQ(Full.udiv(Empty), Empty);
284 EXPECT_EQ(Full.udiv(One), Full);
285 EXPECT_EQ(Full.udiv(Some), Full);
286 EXPECT_EQ(Full.udiv(Wrap), Full);
287 EXPECT_EQ(Empty.udiv(Empty), Empty);
288 EXPECT_EQ(Empty.udiv(One), Empty);
289 EXPECT_EQ(Empty.udiv(Some), Empty);
290 EXPECT_EQ(Empty.udiv(Wrap), Empty);
291 // TODO: ConstantRange is currently over-conservative here.
292 EXPECT_EQ(One.udiv(One), Full);
293 // TODO: ConstantRange is currently over-conservative here.
294 EXPECT_EQ(One.udiv(Some), Full);
295 // TODO: ConstantRange is currently over-conservative here.
296 EXPECT_EQ(One.udiv(Wrap), Full);
297 // TODO: ConstantRange is currently over-conservative here.
298 EXPECT_EQ(Some.udiv(Some), Full);
299 // TODO: ConstantRange is currently over-conservative here.
300 EXPECT_EQ(Some.udiv(Wrap), Full);
301 // TODO: ConstantRange is currently over-conservative here.
302 EXPECT_EQ(Wrap.udiv(Wrap), Full);
305 } // anonymous namespace