1 | //===- ConstantRange.h - Represent a range ----------------------*- C++ -*-===// |
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 | // Represent a range of possible values that may occur when the program is run |
10 | // for an integral value. This keeps track of a lower and upper bound for the |
11 | // constant, which MAY wrap around the end of the numeric range. To do this, it |
12 | // keeps track of a [lower, upper) bound, which specifies an interval just like |
13 | // STL iterators. When used with boolean values, the following are important |
14 | // ranges: : |
15 | // |
16 | // [F, F) = {} = Empty set |
17 | // [T, F) = {T} |
18 | // [F, T) = {F} |
19 | // [T, T) = {F, T} = Full set |
20 | // |
21 | // The other integral ranges use min/max values for special range values. For |
22 | // example, for 8-bit types, it uses: |
23 | // [0, 0) = {} = Empty set |
24 | // [255, 255) = {0..255} = Full Set |
25 | // |
26 | // Note that ConstantRange can be used to represent either signed or |
27 | // unsigned ranges. |
28 | // |
29 | //===----------------------------------------------------------------------===// |
30 | |
31 | #ifndef LLVM_IR_CONSTANTRANGE_H |
32 | #define LLVM_IR_CONSTANTRANGE_H |
33 | |
34 | #include "llvm/ADT/APInt.h" |
35 | #include "llvm/IR/InstrTypes.h" |
36 | #include "llvm/IR/Instruction.h" |
37 | #include "llvm/Support/Compiler.h" |
38 | #include <cstdint> |
39 | |
40 | namespace llvm { |
41 | |
42 | class MDNode; |
43 | class raw_ostream; |
44 | struct KnownBits; |
45 | |
46 | /// This class represents a range of values. |
47 | class LLVM_NODISCARD ConstantRange { |
48 | APInt Lower, Upper; |
49 | |
50 | /// Create empty constant range with same bitwidth. |
51 | ConstantRange getEmpty() const { |
52 | return ConstantRange(getBitWidth(), false); |
53 | } |
54 | |
55 | /// Create full constant range with same bitwidth. |
56 | ConstantRange getFull() const { |
57 | return ConstantRange(getBitWidth(), true); |
58 | } |
59 | |
60 | public: |
61 | /// Initialize a full or empty set for the specified bit width. |
62 | explicit ConstantRange(uint32_t BitWidth, bool isFullSet); |
63 | |
64 | /// Initialize a range to hold the single specified value. |
65 | ConstantRange(APInt Value); |
66 | |
67 | /// Initialize a range of values explicitly. This will assert out if |
68 | /// Lower==Upper and Lower != Min or Max value for its type. It will also |
69 | /// assert out if the two APInt's are not the same bit width. |
70 | ConstantRange(APInt Lower, APInt Upper); |
71 | |
72 | /// Create empty constant range with the given bit width. |
73 | static ConstantRange getEmpty(uint32_t BitWidth) { |
74 | return ConstantRange(BitWidth, false); |
75 | } |
76 | |
77 | /// Create full constant range with the given bit width. |
78 | static ConstantRange getFull(uint32_t BitWidth) { |
79 | return ConstantRange(BitWidth, true); |
80 | } |
81 | |
82 | /// Create non-empty constant range with the given bounds. If Lower and |
83 | /// Upper are the same, a full range is returned. |
84 | static ConstantRange getNonEmpty(APInt Lower, APInt Upper) { |
85 | if (Lower == Upper) |
86 | return getFull(Lower.getBitWidth()); |
87 | return ConstantRange(std::move(Lower), std::move(Upper)); |
88 | } |
89 | |
90 | /// Initialize a range based on a known bits constraint. The IsSigned flag |
91 | /// indicates whether the constant range should not wrap in the signed or |
92 | /// unsigned domain. |
93 | static ConstantRange fromKnownBits(const KnownBits &Known, bool IsSigned); |
94 | |
95 | /// Produce the smallest range such that all values that may satisfy the given |
96 | /// predicate with any value contained within Other is contained in the |
97 | /// returned range. Formally, this returns a superset of |
98 | /// 'union over all y in Other . { x : icmp op x y is true }'. If the exact |
99 | /// answer is not representable as a ConstantRange, the return value will be a |
100 | /// proper superset of the above. |
101 | /// |
102 | /// Example: Pred = ult and Other = i8 [2, 5) returns Result = [0, 4) |
103 | static ConstantRange makeAllowedICmpRegion(CmpInst::Predicate Pred, |
104 | const ConstantRange &Other); |
105 | |
106 | /// Produce the largest range such that all values in the returned range |
107 | /// satisfy the given predicate with all values contained within Other. |
108 | /// Formally, this returns a subset of |
109 | /// 'intersection over all y in Other . { x : icmp op x y is true }'. If the |
110 | /// exact answer is not representable as a ConstantRange, the return value |
111 | /// will be a proper subset of the above. |
112 | /// |
113 | /// Example: Pred = ult and Other = i8 [2, 5) returns [0, 2) |
114 | static ConstantRange makeSatisfyingICmpRegion(CmpInst::Predicate Pred, |
115 | const ConstantRange &Other); |
116 | |
117 | /// Produce the exact range such that all values in the returned range satisfy |
118 | /// the given predicate with any value contained within Other. Formally, this |
119 | /// returns the exact answer when the superset of 'union over all y in Other |
120 | /// is exactly same as the subset of intersection over all y in Other. |
121 | /// { x : icmp op x y is true}'. |
122 | /// |
123 | /// Example: Pred = ult and Other = i8 3 returns [0, 3) |
124 | static ConstantRange makeExactICmpRegion(CmpInst::Predicate Pred, |
125 | const APInt &Other); |
126 | |
127 | /// Does the predicate \p Pred hold between ranges this and \p Other? |
128 | /// NOTE: false does not mean that inverse predicate holds! |
129 | bool icmp(CmpInst::Predicate Pred, const ConstantRange &Other) const; |
130 | |
131 | /// Produce the largest range containing all X such that "X BinOp Y" is |
132 | /// guaranteed not to wrap (overflow) for *all* Y in Other. However, there may |
133 | /// be *some* Y in Other for which additional X not contained in the result |
134 | /// also do not overflow. |
135 | /// |
136 | /// NoWrapKind must be one of OBO::NoUnsignedWrap or OBO::NoSignedWrap. |
137 | /// |
138 | /// Examples: |
139 | /// typedef OverflowingBinaryOperator OBO; |
140 | /// #define MGNR makeGuaranteedNoWrapRegion |
141 | /// MGNR(Add, [i8 1, 2), OBO::NoSignedWrap) == [-128, 127) |
142 | /// MGNR(Add, [i8 1, 2), OBO::NoUnsignedWrap) == [0, -1) |
143 | /// MGNR(Add, [i8 0, 1), OBO::NoUnsignedWrap) == Full Set |
144 | /// MGNR(Add, [i8 -1, 6), OBO::NoSignedWrap) == [INT_MIN+1, INT_MAX-4) |
145 | /// MGNR(Sub, [i8 1, 2), OBO::NoSignedWrap) == [-127, 128) |
146 | /// MGNR(Sub, [i8 1, 2), OBO::NoUnsignedWrap) == [1, 0) |
147 | static ConstantRange makeGuaranteedNoWrapRegion(Instruction::BinaryOps BinOp, |
148 | const ConstantRange &Other, |
149 | unsigned NoWrapKind); |
150 | |
151 | /// Produce the range that contains X if and only if "X BinOp Other" does |
152 | /// not wrap. |
153 | static ConstantRange makeExactNoWrapRegion(Instruction::BinaryOps BinOp, |
154 | const APInt &Other, |
155 | unsigned NoWrapKind); |
156 | |
157 | /// Returns true if ConstantRange calculations are supported for intrinsic |
158 | /// with \p IntrinsicID. |
159 | static bool isIntrinsicSupported(Intrinsic::ID IntrinsicID); |
160 | |
161 | /// Compute range of intrinsic result for the given operand ranges. |
162 | static ConstantRange intrinsic(Intrinsic::ID IntrinsicID, |
163 | ArrayRef<ConstantRange> Ops); |
164 | |
165 | /// Set up \p Pred and \p RHS such that |
166 | /// ConstantRange::makeExactICmpRegion(Pred, RHS) == *this. Return true if |
167 | /// successful. |
168 | bool getEquivalentICmp(CmpInst::Predicate &Pred, APInt &RHS) const; |
169 | |
170 | /// Return the lower value for this range. |
171 | const APInt &getLower() const { return Lower; } |
172 | |
173 | /// Return the upper value for this range. |
174 | const APInt &getUpper() const { return Upper; } |
175 | |
176 | /// Get the bit width of this ConstantRange. |
177 | uint32_t getBitWidth() const { return Lower.getBitWidth(); } |
178 | |
179 | /// Return true if this set contains all of the elements possible |
180 | /// for this data-type. |
181 | bool isFullSet() const; |
182 | |
183 | /// Return true if this set contains no members. |
184 | bool isEmptySet() const; |
185 | |
186 | /// Return true if this set wraps around the unsigned domain. Special cases: |
187 | /// * Empty set: Not wrapped. |
188 | /// * Full set: Not wrapped. |
189 | /// * [X, 0) == [X, Max]: Not wrapped. |
190 | bool isWrappedSet() const; |
191 | |
192 | /// Return true if the exclusive upper bound wraps around the unsigned |
193 | /// domain. Special cases: |
194 | /// * Empty set: Not wrapped. |
195 | /// * Full set: Not wrapped. |
196 | /// * [X, 0): Wrapped. |
197 | bool isUpperWrapped() const; |
198 | |
199 | /// Return true if this set wraps around the signed domain. Special cases: |
200 | /// * Empty set: Not wrapped. |
201 | /// * Full set: Not wrapped. |
202 | /// * [X, SignedMin) == [X, SignedMax]: Not wrapped. |
203 | bool isSignWrappedSet() const; |
204 | |
205 | /// Return true if the (exclusive) upper bound wraps around the signed |
206 | /// domain. Special cases: |
207 | /// * Empty set: Not wrapped. |
208 | /// * Full set: Not wrapped. |
209 | /// * [X, SignedMin): Wrapped. |
210 | bool isUpperSignWrapped() const; |
211 | |
212 | /// Return true if the specified value is in the set. |
213 | bool contains(const APInt &Val) const; |
214 | |
215 | /// Return true if the other range is a subset of this one. |
216 | bool contains(const ConstantRange &CR) const; |
217 | |
218 | /// If this set contains a single element, return it, otherwise return null. |
219 | const APInt *getSingleElement() const { |
220 | if (Upper == Lower + 1) |
221 | return &Lower; |
222 | return nullptr; |
223 | } |
224 | |
225 | /// If this set contains all but a single element, return it, otherwise return |
226 | /// null. |
227 | const APInt *getSingleMissingElement() const { |
228 | if (Lower == Upper + 1) |
229 | return &Upper; |
230 | return nullptr; |
231 | } |
232 | |
233 | /// Return true if this set contains exactly one member. |
234 | bool isSingleElement() const { return getSingleElement() != nullptr; } |
235 | |
236 | /// Compare set size of this range with the range CR. |
237 | bool isSizeStrictlySmallerThan(const ConstantRange &CR) const; |
238 | |
239 | /// Compare set size of this range with Value. |
240 | bool isSizeLargerThan(uint64_t MaxSize) const; |
241 | |
242 | /// Return true if all values in this range are negative. |
243 | bool isAllNegative() const; |
244 | |
245 | /// Return true if all values in this range are non-negative. |
246 | bool isAllNonNegative() const; |
247 | |
248 | /// Return the largest unsigned value contained in the ConstantRange. |
249 | APInt getUnsignedMax() const; |
250 | |
251 | /// Return the smallest unsigned value contained in the ConstantRange. |
252 | APInt getUnsignedMin() const; |
253 | |
254 | /// Return the largest signed value contained in the ConstantRange. |
255 | APInt getSignedMax() const; |
256 | |
257 | /// Return the smallest signed value contained in the ConstantRange. |
258 | APInt getSignedMin() const; |
259 | |
260 | /// Return true if this range is equal to another range. |
261 | bool operator==(const ConstantRange &CR) const { |
262 | return Lower == CR.Lower && Upper == CR.Upper; |
263 | } |
264 | bool operator!=(const ConstantRange &CR) const { |
265 | return !operator==(CR); |
266 | } |
267 | |
268 | /// Compute the maximal number of active bits needed to represent every value |
269 | /// in this range. |
270 | unsigned getActiveBits() const; |
271 | |
272 | /// Compute the maximal number of bits needed to represent every value |
273 | /// in this signed range. |
274 | unsigned getMinSignedBits() const; |
275 | |
276 | /// Subtract the specified constant from the endpoints of this constant range. |
277 | ConstantRange subtract(const APInt &CI) const; |
278 | |
279 | /// Subtract the specified range from this range (aka relative complement of |
280 | /// the sets). |
281 | ConstantRange difference(const ConstantRange &CR) const; |
282 | |
283 | /// If represented precisely, the result of some range operations may consist |
284 | /// of multiple disjoint ranges. As only a single range may be returned, any |
285 | /// range covering these disjoint ranges constitutes a valid result, but some |
286 | /// may be more useful than others depending on context. The preferred range |
287 | /// type specifies whether a range that is non-wrapping in the unsigned or |
288 | /// signed domain, or has the smallest size, is preferred. If a signedness is |
289 | /// preferred but all ranges are non-wrapping or all wrapping, then the |
290 | /// smallest set size is preferred. If there are multiple smallest sets, any |
291 | /// one of them may be returned. |
292 | enum PreferredRangeType { Smallest, Unsigned, Signed }; |
293 | |
294 | /// Return the range that results from the intersection of this range with |
295 | /// another range. If the intersection is disjoint, such that two results |
296 | /// are possible, the preferred range is determined by the PreferredRangeType. |
297 | ConstantRange intersectWith(const ConstantRange &CR, |
298 | PreferredRangeType Type = Smallest) const; |
299 | |
300 | /// Return the range that results from the union of this range |
301 | /// with another range. The resultant range is guaranteed to include the |
302 | /// elements of both sets, but may contain more. For example, [3, 9) union |
303 | /// [12,15) is [3, 15), which includes 9, 10, and 11, which were not included |
304 | /// in either set before. |
305 | ConstantRange unionWith(const ConstantRange &CR, |
306 | PreferredRangeType Type = Smallest) const; |
307 | |
308 | /// Return a new range representing the possible values resulting |
309 | /// from an application of the specified cast operator to this range. \p |
310 | /// BitWidth is the target bitwidth of the cast. For casts which don't |
311 | /// change bitwidth, it must be the same as the source bitwidth. For casts |
312 | /// which do change bitwidth, the bitwidth must be consistent with the |
313 | /// requested cast and source bitwidth. |
314 | ConstantRange castOp(Instruction::CastOps CastOp, |
315 | uint32_t BitWidth) const; |
316 | |
317 | /// Return a new range in the specified integer type, which must |
318 | /// be strictly larger than the current type. The returned range will |
319 | /// correspond to the possible range of values if the source range had been |
320 | /// zero extended to BitWidth. |
321 | ConstantRange zeroExtend(uint32_t BitWidth) const; |
322 | |
323 | /// Return a new range in the specified integer type, which must |
324 | /// be strictly larger than the current type. The returned range will |
325 | /// correspond to the possible range of values if the source range had been |
326 | /// sign extended to BitWidth. |
327 | ConstantRange signExtend(uint32_t BitWidth) const; |
328 | |
329 | /// Return a new range in the specified integer type, which must be |
330 | /// strictly smaller than the current type. The returned range will |
331 | /// correspond to the possible range of values if the source range had been |
332 | /// truncated to the specified type. |
333 | ConstantRange truncate(uint32_t BitWidth) const; |
334 | |
335 | /// Make this range have the bit width given by \p BitWidth. The |
336 | /// value is zero extended, truncated, or left alone to make it that width. |
337 | ConstantRange zextOrTrunc(uint32_t BitWidth) const; |
338 | |
339 | /// Make this range have the bit width given by \p BitWidth. The |
340 | /// value is sign extended, truncated, or left alone to make it that width. |
341 | ConstantRange sextOrTrunc(uint32_t BitWidth) const; |
342 | |
343 | /// Return a new range representing the possible values resulting |
344 | /// from an application of the specified binary operator to an left hand side |
345 | /// of this range and a right hand side of \p Other. |
346 | ConstantRange binaryOp(Instruction::BinaryOps BinOp, |
347 | const ConstantRange &Other) const; |
348 | |
349 | /// Return a new range representing the possible values resulting |
350 | /// from an application of the specified overflowing binary operator to a |
351 | /// left hand side of this range and a right hand side of \p Other given |
352 | /// the provided knowledge about lack of wrapping \p NoWrapKind. |
353 | ConstantRange overflowingBinaryOp(Instruction::BinaryOps BinOp, |
354 | const ConstantRange &Other, |
355 | unsigned NoWrapKind) const; |
356 | |
357 | /// Return a new range representing the possible values resulting |
358 | /// from an addition of a value in this range and a value in \p Other. |
359 | ConstantRange add(const ConstantRange &Other) const; |
360 | |
361 | /// Return a new range representing the possible values resulting |
362 | /// from an addition with wrap type \p NoWrapKind of a value in this |
363 | /// range and a value in \p Other. |
364 | /// If the result range is disjoint, the preferred range is determined by the |
365 | /// \p PreferredRangeType. |
366 | ConstantRange addWithNoWrap(const ConstantRange &Other, unsigned NoWrapKind, |
367 | PreferredRangeType RangeType = Smallest) const; |
368 | |
369 | /// Return a new range representing the possible values resulting |
370 | /// from a subtraction of a value in this range and a value in \p Other. |
371 | ConstantRange sub(const ConstantRange &Other) const; |
372 | |
373 | /// Return a new range representing the possible values resulting |
374 | /// from an subtraction with wrap type \p NoWrapKind of a value in this |
375 | /// range and a value in \p Other. |
376 | /// If the result range is disjoint, the preferred range is determined by the |
377 | /// \p PreferredRangeType. |
378 | ConstantRange subWithNoWrap(const ConstantRange &Other, unsigned NoWrapKind, |
379 | PreferredRangeType RangeType = Smallest) const; |
380 | |
381 | /// Return a new range representing the possible values resulting |
382 | /// from a multiplication of a value in this range and a value in \p Other, |
383 | /// treating both this and \p Other as unsigned ranges. |
384 | ConstantRange multiply(const ConstantRange &Other) const; |
385 | |
386 | /// Return a new range representing the possible values resulting |
387 | /// from a signed maximum of a value in this range and a value in \p Other. |
388 | ConstantRange smax(const ConstantRange &Other) const; |
389 | |
390 | /// Return a new range representing the possible values resulting |
391 | /// from an unsigned maximum of a value in this range and a value in \p Other. |
392 | ConstantRange umax(const ConstantRange &Other) const; |
393 | |
394 | /// Return a new range representing the possible values resulting |
395 | /// from a signed minimum of a value in this range and a value in \p Other. |
396 | ConstantRange smin(const ConstantRange &Other) const; |
397 | |
398 | /// Return a new range representing the possible values resulting |
399 | /// from an unsigned minimum of a value in this range and a value in \p Other. |
400 | ConstantRange umin(const ConstantRange &Other) const; |
401 | |
402 | /// Return a new range representing the possible values resulting |
403 | /// from an unsigned division of a value in this range and a value in |
404 | /// \p Other. |
405 | ConstantRange udiv(const ConstantRange &Other) const; |
406 | |
407 | /// Return a new range representing the possible values resulting |
408 | /// from a signed division of a value in this range and a value in |
409 | /// \p Other. Division by zero and division of SignedMin by -1 are considered |
410 | /// undefined behavior, in line with IR, and do not contribute towards the |
411 | /// result. |
412 | ConstantRange sdiv(const ConstantRange &Other) const; |
413 | |
414 | /// Return a new range representing the possible values resulting |
415 | /// from an unsigned remainder operation of a value in this range and a |
416 | /// value in \p Other. |
417 | ConstantRange urem(const ConstantRange &Other) const; |
418 | |
419 | /// Return a new range representing the possible values resulting |
420 | /// from a signed remainder operation of a value in this range and a |
421 | /// value in \p Other. |
422 | ConstantRange srem(const ConstantRange &Other) const; |
423 | |
424 | /// Return a new range representing the possible values resulting from |
425 | /// a binary-xor of a value in this range by an all-one value, |
426 | /// aka bitwise complement operation. |
427 | ConstantRange binaryNot() const; |
428 | |
429 | /// Return a new range representing the possible values resulting |
430 | /// from a binary-and of a value in this range by a value in \p Other. |
431 | ConstantRange binaryAnd(const ConstantRange &Other) const; |
432 | |
433 | /// Return a new range representing the possible values resulting |
434 | /// from a binary-or of a value in this range by a value in \p Other. |
435 | ConstantRange binaryOr(const ConstantRange &Other) const; |
436 | |
437 | /// Return a new range representing the possible values resulting |
438 | /// from a binary-xor of a value in this range by a value in \p Other. |
439 | ConstantRange binaryXor(const ConstantRange &Other) const; |
440 | |
441 | /// Return a new range representing the possible values resulting |
442 | /// from a left shift of a value in this range by a value in \p Other. |
443 | /// TODO: This isn't fully implemented yet. |
444 | ConstantRange shl(const ConstantRange &Other) const; |
445 | |
446 | /// Return a new range representing the possible values resulting from a |
447 | /// logical right shift of a value in this range and a value in \p Other. |
448 | ConstantRange lshr(const ConstantRange &Other) const; |
449 | |
450 | /// Return a new range representing the possible values resulting from a |
451 | /// arithmetic right shift of a value in this range and a value in \p Other. |
452 | ConstantRange ashr(const ConstantRange &Other) const; |
453 | |
454 | /// Perform an unsigned saturating addition of two constant ranges. |
455 | ConstantRange uadd_sat(const ConstantRange &Other) const; |
456 | |
457 | /// Perform a signed saturating addition of two constant ranges. |
458 | ConstantRange sadd_sat(const ConstantRange &Other) const; |
459 | |
460 | /// Perform an unsigned saturating subtraction of two constant ranges. |
461 | ConstantRange usub_sat(const ConstantRange &Other) const; |
462 | |
463 | /// Perform a signed saturating subtraction of two constant ranges. |
464 | ConstantRange ssub_sat(const ConstantRange &Other) const; |
465 | |
466 | /// Perform an unsigned saturating multiplication of two constant ranges. |
467 | ConstantRange umul_sat(const ConstantRange &Other) const; |
468 | |
469 | /// Perform a signed saturating multiplication of two constant ranges. |
470 | ConstantRange smul_sat(const ConstantRange &Other) const; |
471 | |
472 | /// Perform an unsigned saturating left shift of this constant range by a |
473 | /// value in \p Other. |
474 | ConstantRange ushl_sat(const ConstantRange &Other) const; |
475 | |
476 | /// Perform a signed saturating left shift of this constant range by a |
477 | /// value in \p Other. |
478 | ConstantRange sshl_sat(const ConstantRange &Other) const; |
479 | |
480 | /// Return a new range that is the logical not of the current set. |
481 | ConstantRange inverse() const; |
482 | |
483 | /// Calculate absolute value range. If the original range contains signed |
484 | /// min, then the resulting range will contain signed min if and only if |
485 | /// \p IntMinIsPoison is false. |
486 | ConstantRange abs(bool IntMinIsPoison = false) const; |
487 | |
488 | /// Represents whether an operation on the given constant range is known to |
489 | /// always or never overflow. |
490 | enum class OverflowResult { |
491 | /// Always overflows in the direction of signed/unsigned min value. |
492 | AlwaysOverflowsLow, |
493 | /// Always overflows in the direction of signed/unsigned max value. |
494 | AlwaysOverflowsHigh, |
495 | /// May or may not overflow. |
496 | MayOverflow, |
497 | /// Never overflows. |
498 | NeverOverflows, |
499 | }; |
500 | |
501 | /// Return whether unsigned add of the two ranges always/never overflows. |
502 | OverflowResult unsignedAddMayOverflow(const ConstantRange &Other) const; |
503 | |
504 | /// Return whether signed add of the two ranges always/never overflows. |
505 | OverflowResult signedAddMayOverflow(const ConstantRange &Other) const; |
506 | |
507 | /// Return whether unsigned sub of the two ranges always/never overflows. |
508 | OverflowResult unsignedSubMayOverflow(const ConstantRange &Other) const; |
509 | |
510 | /// Return whether signed sub of the two ranges always/never overflows. |
511 | OverflowResult signedSubMayOverflow(const ConstantRange &Other) const; |
512 | |
513 | /// Return whether unsigned mul of the two ranges always/never overflows. |
514 | OverflowResult unsignedMulMayOverflow(const ConstantRange &Other) const; |
515 | |
516 | /// Print out the bounds to a stream. |
517 | void print(raw_ostream &OS) const; |
518 | |
519 | /// Allow printing from a debugger easily. |
520 | void dump() const; |
521 | }; |
522 | |
523 | inline raw_ostream &operator<<(raw_ostream &OS, const ConstantRange &CR) { |
524 | CR.print(OS); |
525 | return OS; |
526 | } |
527 | |
528 | /// Parse out a conservative ConstantRange from !range metadata. |
529 | /// |
530 | /// E.g. if RangeMD is !{i32 0, i32 10, i32 15, i32 20} then return [0, 20). |
531 | ConstantRange getConstantRangeFromMetadata(const MDNode &RangeMD); |
532 | |
533 | } // end namespace llvm |
534 | |
535 | #endif // LLVM_IR_CONSTANTRANGE_H |
536 | |