| /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- |
| * vim: set ts=8 sts=4 et sw=4 tw=99: |
| * This Source Code Form is subject to the terms of the Mozilla Public |
| * License, v. 2.0. If a copy of the MPL was not distributed with this |
| * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
| |
| #ifndef jit_RangeAnalysis_h |
| #define jit_RangeAnalysis_h |
| |
| #include "mozilla/FloatingPoint.h" |
| #include "mozilla/MathAlgorithms.h" |
| |
| #include "jit/IonAnalysis.h" |
| #include "jit/MIR.h" |
| |
| // windows.h defines those, which messes with the definitions below. |
| #undef min |
| #undef max |
| |
| namespace js { |
| namespace jit { |
| |
| class MBasicBlock; |
| class MIRGraph; |
| |
| // An upper bound computed on the number of backedges a loop will take. |
| // This count only includes backedges taken while running Ion code: for OSR |
| // loops, this will exclude iterations that executed in the interpreter or in |
| // baseline compiled code. |
| struct LoopIterationBound : public TempObject |
| { |
| // Loop for which this bound applies. |
| MBasicBlock* header; |
| |
| // Test from which this bound was derived; after executing exactly 'bound' |
| // times this test will exit the loop. Code in the loop body which this |
| // test dominates (will include the backedge) will execute at most 'bound' |
| // times. Other code in the loop will execute at most '1 + Max(bound, 0)' |
| // times. |
| MTest* test; |
| |
| // Symbolic bound computed for the number of backedge executions. The terms |
| // in this bound are all loop invariant. |
| LinearSum boundSum; |
| |
| // Linear sum for the number of iterations already executed, at the start |
| // of the loop header. This will use loop invariant terms and header phis. |
| LinearSum currentSum; |
| |
| LoopIterationBound(MBasicBlock* header, MTest* test, LinearSum boundSum, LinearSum currentSum) |
| : header(header), test(test), |
| boundSum(boundSum), currentSum(currentSum) |
| { |
| } |
| }; |
| |
| typedef Vector<LoopIterationBound*, 0, SystemAllocPolicy> LoopIterationBoundVector; |
| |
| // A symbolic upper or lower bound computed for a term. |
| struct SymbolicBound : public TempObject |
| { |
| private: |
| SymbolicBound(LoopIterationBound* loop, LinearSum sum) |
| : loop(loop), sum(sum) |
| { |
| } |
| |
| public: |
| // Any loop iteration bound from which this was derived. |
| // |
| // If non-nullptr, then 'sum' is only valid within the loop body, at |
| // points dominated by the loop bound's test (see LoopIterationBound). |
| // |
| // If nullptr, then 'sum' is always valid. |
| LoopIterationBound* loop; |
| |
| static SymbolicBound* New(TempAllocator& alloc, LoopIterationBound* loop, LinearSum sum) { |
| return new(alloc) SymbolicBound(loop, sum); |
| } |
| |
| // Computed symbolic bound, see above. |
| LinearSum sum; |
| |
| void dump(GenericPrinter& out) const; |
| void dump() const; |
| }; |
| |
| class RangeAnalysis |
| { |
| protected: |
| bool blockDominates(MBasicBlock* b, MBasicBlock* b2); |
| void replaceDominatedUsesWith(MDefinition* orig, MDefinition* dom, |
| MBasicBlock* block); |
| |
| protected: |
| MIRGenerator* mir; |
| MIRGraph& graph_; |
| |
| TempAllocator& alloc() const; |
| |
| public: |
| RangeAnalysis(MIRGenerator* mir, MIRGraph& graph) : |
| mir(mir), graph_(graph) {} |
| bool addBetaNodes(); |
| bool analyze(); |
| bool addRangeAssertions(); |
| bool removeBetaNodes(); |
| bool prepareForUCE(bool* shouldRemoveDeadCode); |
| bool tryRemovingGuards(); |
| bool truncate(); |
| |
| // Any iteration bounds discovered for loops in the graph. |
| LoopIterationBoundVector loopIterationBounds; |
| |
| private: |
| bool analyzeLoop(MBasicBlock* header); |
| LoopIterationBound* analyzeLoopIterationCount(MBasicBlock* header, |
| MTest* test, BranchDirection direction); |
| void analyzeLoopPhi(MBasicBlock* header, LoopIterationBound* loopBound, MPhi* phi); |
| bool tryHoistBoundsCheck(MBasicBlock* header, MBoundsCheck* ins); |
| }; |
| |
| class Range : public TempObject { |
| public: |
| // Int32 are signed. INT32_MAX is pow(2,31)-1 and INT32_MIN is -pow(2,31), |
| // so the greatest exponent we need is 31. |
| static const uint16_t MaxInt32Exponent = 31; |
| |
| // UInt32 are unsigned. UINT32_MAX is pow(2,32)-1, so it's the greatest |
| // value that has an exponent of 31. |
| static const uint16_t MaxUInt32Exponent = 31; |
| |
| // Maximal exponenent under which we have no precission loss on double |
| // operations. Double has 52 bits of mantissa, so 2^52+1 cannot be |
| // represented without loss. |
| static const uint16_t MaxTruncatableExponent = mozilla::FloatingPoint<double>::kExponentShift; |
| |
| // Maximum exponent for finite values. |
| static const uint16_t MaxFiniteExponent = mozilla::FloatingPoint<double>::kExponentBias; |
| |
| // An special exponent value representing all non-NaN values. This |
| // includes finite values and the infinities. |
| static const uint16_t IncludesInfinity = MaxFiniteExponent + 1; |
| |
| // An special exponent value representing all possible double-precision |
| // values. This includes finite values, the infinities, and NaNs. |
| static const uint16_t IncludesInfinityAndNaN = UINT16_MAX; |
| |
| // This range class uses int32_t ranges, but has several interfaces which |
| // use int64_t, which either holds an int32_t value, or one of the following |
| // special values which mean a value which is beyond the int32 range, |
| // potentially including infinity or NaN. These special values are |
| // guaranteed to compare greater, and less than, respectively, any int32_t |
| // value. |
| static const int64_t NoInt32UpperBound = int64_t(JSVAL_INT_MAX) + 1; |
| static const int64_t NoInt32LowerBound = int64_t(JSVAL_INT_MIN) - 1; |
| |
| enum FractionalPartFlag { |
| ExcludesFractionalParts = false, |
| IncludesFractionalParts = true |
| }; |
| enum NegativeZeroFlag { |
| ExcludesNegativeZero = false, |
| IncludesNegativeZero = true |
| }; |
| |
| private: |
| // Absolute ranges. |
| // |
| // We represent ranges where the endpoints can be in the set: |
| // {-infty} U [INT_MIN, INT_MAX] U {infty}. A bound of +/- |
| // infty means that the value may have overflowed in that |
| // direction. When computing the range of an integer |
| // instruction, the ranges of the operands can be clamped to |
| // [INT_MIN, INT_MAX], since if they had overflowed they would |
| // no longer be integers. This is important for optimizations |
| // and somewhat subtle. |
| // |
| // N.B.: All of the operations that compute new ranges based |
| // on existing ranges will ignore the hasInt32*Bound_ flags of the |
| // input ranges; that is, they implicitly clamp the ranges of |
| // the inputs to [INT_MIN, INT_MAX]. Therefore, while our range might |
| // be unbounded (and could overflow), when using this information to |
| // propagate through other ranges, we disregard this fact; if that code |
| // executes, then the overflow did not occur, so we may safely assume |
| // that the range is [INT_MIN, INT_MAX] instead. |
| // |
| // To facilitate this trick, we maintain the invariants that: |
| // 1) hasInt32LowerBound_ == false implies lower_ == JSVAL_INT_MIN |
| // 2) hasInt32UpperBound_ == false implies upper_ == JSVAL_INT_MAX |
| // |
| // As a second and less precise range analysis, we represent the maximal |
| // exponent taken by a value. The exponent is calculated by taking the |
| // absolute value and looking at the position of the highest bit. All |
| // exponent computation have to be over-estimations of the actual result. On |
| // the Int32 this over approximation is rectified. |
| |
| int32_t lower_; |
| int32_t upper_; |
| |
| bool hasInt32LowerBound_; |
| bool hasInt32UpperBound_; |
| |
| FractionalPartFlag canHaveFractionalPart_ : 1; |
| NegativeZeroFlag canBeNegativeZero_ : 1; |
| uint16_t max_exponent_; |
| |
| // Any symbolic lower or upper bound computed for this term. |
| const SymbolicBound* symbolicLower_; |
| const SymbolicBound* symbolicUpper_; |
| |
| // This function simply makes several MOZ_ASSERTs to verify the internal |
| // consistency of this range. |
| void assertInvariants() const { |
| // Basic sanity :). |
| MOZ_ASSERT(lower_ <= upper_); |
| |
| // When hasInt32LowerBound_ or hasInt32UpperBound_ are false, we set |
| // lower_ and upper_ to these specific values as it simplifies the |
| // implementation in some places. |
| MOZ_ASSERT_IF(!hasInt32LowerBound_, lower_ == JSVAL_INT_MIN); |
| MOZ_ASSERT_IF(!hasInt32UpperBound_, upper_ == JSVAL_INT_MAX); |
| |
| // max_exponent_ must be one of three possible things. |
| MOZ_ASSERT(max_exponent_ <= MaxFiniteExponent || |
| max_exponent_ == IncludesInfinity || |
| max_exponent_ == IncludesInfinityAndNaN); |
| |
| // Forbid the max_exponent_ field from implying better bounds for |
| // lower_/upper_ fields. We have to add 1 to the max_exponent_ when |
| // canHaveFractionalPart_ is true in order to accomodate |
| // fractional offsets. For example, 2147483647.9 is greater than |
| // INT32_MAX, so a range containing that value will have |
| // hasInt32UpperBound_ set to false, however that value also has |
| // exponent 30, which is strictly less than MaxInt32Exponent. For |
| // another example, 1.9 has an exponent of 0 but requires upper_ to be |
| // at least 2, which has exponent 1. |
| mozilla::DebugOnly<uint32_t> adjustedExponent = max_exponent_ + |
| (canHaveFractionalPart_ ? 1 : 0); |
| MOZ_ASSERT_IF(!hasInt32LowerBound_ || !hasInt32UpperBound_, |
| adjustedExponent >= MaxInt32Exponent); |
| MOZ_ASSERT(adjustedExponent >= mozilla::FloorLog2(mozilla::Abs(upper_))); |
| MOZ_ASSERT(adjustedExponent >= mozilla::FloorLog2(mozilla::Abs(lower_))); |
| |
| // The following are essentially static assertions, but FloorLog2 isn't |
| // trivially suitable for constexpr :(. |
| MOZ_ASSERT(mozilla::FloorLog2(JSVAL_INT_MIN) == MaxInt32Exponent); |
| MOZ_ASSERT(mozilla::FloorLog2(JSVAL_INT_MAX) == 30); |
| MOZ_ASSERT(mozilla::FloorLog2(UINT32_MAX) == MaxUInt32Exponent); |
| MOZ_ASSERT(mozilla::FloorLog2(0) == 0); |
| } |
| |
| // Set the lower_ and hasInt32LowerBound_ values. |
| void setLowerInit(int64_t x) { |
| if (x > JSVAL_INT_MAX) { |
| lower_ = JSVAL_INT_MAX; |
| hasInt32LowerBound_ = true; |
| } else if (x < JSVAL_INT_MIN) { |
| lower_ = JSVAL_INT_MIN; |
| hasInt32LowerBound_ = false; |
| } else { |
| lower_ = int32_t(x); |
| hasInt32LowerBound_ = true; |
| } |
| } |
| // Set the upper_ and hasInt32UpperBound_ values. |
| void setUpperInit(int64_t x) { |
| if (x > JSVAL_INT_MAX) { |
| upper_ = JSVAL_INT_MAX; |
| hasInt32UpperBound_ = false; |
| } else if (x < JSVAL_INT_MIN) { |
| upper_ = JSVAL_INT_MIN; |
| hasInt32UpperBound_ = true; |
| } else { |
| upper_ = int32_t(x); |
| hasInt32UpperBound_ = true; |
| } |
| } |
| |
| // Compute the least exponent value that would be compatible with the |
| // values of lower() and upper(). |
| // |
| // Note: |
| // exponent of JSVAL_INT_MIN == 31 |
| // exponent of JSVAL_INT_MAX == 30 |
| uint16_t exponentImpliedByInt32Bounds() const { |
| // The number of bits needed to encode |max| is the power of 2 plus one. |
| uint32_t max = Max(mozilla::Abs(lower()), mozilla::Abs(upper())); |
| uint16_t result = mozilla::FloorLog2(max); |
| MOZ_ASSERT(result == (max == 0 ? 0 : mozilla::ExponentComponent(double(max)))); |
| return result; |
| } |
| |
| // When converting a range which contains fractional values to a range |
| // containing only integers, the old max_exponent_ value may imply a better |
| // lower and/or upper bound than was previously available, because they no |
| // longer need to be conservative about fractional offsets and the ends of |
| // the range. |
| // |
| // Given an exponent value and pointers to the lower and upper bound values, |
| // this function refines the lower and upper bound values to the tighest |
| // bound for integer values implied by the exponent. |
| static void refineInt32BoundsByExponent(uint16_t e, |
| int32_t* l, bool* lb, |
| int32_t* h, bool* hb) |
| { |
| if (e < MaxInt32Exponent) { |
| // pow(2, max_exponent_+1)-1 to compute a maximum absolute value. |
| int32_t limit = (uint32_t(1) << (e + 1)) - 1; |
| *h = Min(*h, limit); |
| *l = Max(*l, -limit); |
| *hb = true; |
| *lb = true; |
| } |
| } |
| |
| // If the value of any of the fields implies a stronger possible value for |
| // any other field, update that field to the stronger value. The range must |
| // be completely valid before and it is guaranteed to be kept valid. |
| void optimize() { |
| assertInvariants(); |
| |
| if (hasInt32Bounds()) { |
| // Examine lower() and upper(), and if they imply a better exponent |
| // bound than max_exponent_, set that value as the new |
| // max_exponent_. |
| uint16_t newExponent = exponentImpliedByInt32Bounds(); |
| if (newExponent < max_exponent_) { |
| max_exponent_ = newExponent; |
| assertInvariants(); |
| } |
| |
| // If we have a completely precise range, the value is an integer, |
| // since we can only represent integers. |
| if (canHaveFractionalPart_ && lower_ == upper_) { |
| canHaveFractionalPart_ = ExcludesFractionalParts; |
| assertInvariants(); |
| } |
| } |
| |
| // If the range doesn't include zero, it doesn't include negative zero. |
| if (canBeNegativeZero_ && !canBeZero()) { |
| canBeNegativeZero_ = ExcludesNegativeZero; |
| assertInvariants(); |
| } |
| } |
| |
| // Set the range fields to the given raw values. |
| void rawInitialize(int32_t l, bool lb, int32_t h, bool hb, |
| FractionalPartFlag canHaveFractionalPart, |
| NegativeZeroFlag canBeNegativeZero, |
| uint16_t e) |
| { |
| lower_ = l; |
| upper_ = h; |
| hasInt32LowerBound_ = lb; |
| hasInt32UpperBound_ = hb; |
| canHaveFractionalPart_ = canHaveFractionalPart; |
| canBeNegativeZero_ = canBeNegativeZero; |
| max_exponent_ = e; |
| optimize(); |
| } |
| |
| // Construct a range from the given raw values. |
| Range(int32_t l, bool lb, int32_t h, bool hb, |
| FractionalPartFlag canHaveFractionalPart, |
| NegativeZeroFlag canBeNegativeZero, |
| uint16_t e) |
| : symbolicLower_(nullptr), |
| symbolicUpper_(nullptr) |
| { |
| rawInitialize(l, lb, h, hb, canHaveFractionalPart, canBeNegativeZero, e); |
| } |
| |
| public: |
| Range() |
| : symbolicLower_(nullptr), |
| symbolicUpper_(nullptr) |
| { |
| setUnknown(); |
| } |
| |
| Range(int64_t l, int64_t h, |
| FractionalPartFlag canHaveFractionalPart, |
| NegativeZeroFlag canBeNegativeZero, |
| uint16_t e) |
| : symbolicLower_(nullptr), |
| symbolicUpper_(nullptr) |
| { |
| set(l, h, canHaveFractionalPart, canBeNegativeZero, e); |
| } |
| |
| Range(const Range& other) |
| : lower_(other.lower_), |
| upper_(other.upper_), |
| hasInt32LowerBound_(other.hasInt32LowerBound_), |
| hasInt32UpperBound_(other.hasInt32UpperBound_), |
| canHaveFractionalPart_(other.canHaveFractionalPart_), |
| canBeNegativeZero_(other.canBeNegativeZero_), |
| max_exponent_(other.max_exponent_), |
| symbolicLower_(nullptr), |
| symbolicUpper_(nullptr) |
| { |
| assertInvariants(); |
| } |
| |
| // Construct a range from the given MDefinition. This differs from the |
| // MDefinition's range() method in that it describes the range of values |
| // *after* any bailout checks. |
| explicit Range(const MDefinition* def); |
| |
| static Range* NewInt32Range(TempAllocator& alloc, int32_t l, int32_t h) { |
| return new(alloc) Range(l, h, ExcludesFractionalParts, ExcludesNegativeZero, MaxInt32Exponent); |
| } |
| |
| // Construct an int32 range containing just i. This is just a convenience |
| // wrapper around NewInt32Range. |
| static Range* NewInt32SingletonRange(TempAllocator& alloc, int32_t i) { |
| return NewInt32Range(alloc, i, i); |
| } |
| |
| static Range* NewUInt32Range(TempAllocator& alloc, uint32_t l, uint32_t h) { |
| // For now, just pass them to the constructor as int64_t values. |
| // They'll become unbounded if they're not in the int32_t range. |
| return new(alloc) Range(l, h, ExcludesFractionalParts, ExcludesNegativeZero, MaxUInt32Exponent); |
| } |
| |
| // Construct a range containing values >= l and <= h. Note that this |
| // function treats negative zero as equal to zero, as >= and <= do. If the |
| // range includes zero, it is assumed to include negative zero too. |
| static Range* NewDoubleRange(TempAllocator& alloc, double l, double h) { |
| if (mozilla::IsNaN(l) && mozilla::IsNaN(h)) |
| return nullptr; |
| |
| Range* r = new(alloc) Range(); |
| r->setDouble(l, h); |
| return r; |
| } |
| |
| // Construct the strictest possible range containing d, or null if d is NaN. |
| // This function treats negative zero as distinct from zero, since this |
| // makes the strictest possible range containin zero a range which |
| // contains one value rather than two. |
| static Range* NewDoubleSingletonRange(TempAllocator& alloc, double d) { |
| if (mozilla::IsNaN(d)) |
| return nullptr; |
| |
| Range* r = new(alloc) Range(); |
| r->setDoubleSingleton(d); |
| return r; |
| } |
| |
| void dump(GenericPrinter& out) const; |
| void dump() const; |
| bool update(const Range* other); |
| |
| // Unlike the other operations, unionWith is an in-place |
| // modification. This is to avoid a bunch of useless extra |
| // copying when chaining together unions when handling Phi |
| // nodes. |
| void unionWith(const Range* other); |
| static Range* intersect(TempAllocator& alloc, const Range* lhs, const Range* rhs, |
| bool* emptyRange); |
| static Range* add(TempAllocator& alloc, const Range* lhs, const Range* rhs); |
| static Range* sub(TempAllocator& alloc, const Range* lhs, const Range* rhs); |
| static Range* mul(TempAllocator& alloc, const Range* lhs, const Range* rhs); |
| static Range* and_(TempAllocator& alloc, const Range* lhs, const Range* rhs); |
| static Range* or_(TempAllocator& alloc, const Range* lhs, const Range* rhs); |
| static Range* xor_(TempAllocator& alloc, const Range* lhs, const Range* rhs); |
| static Range* not_(TempAllocator& alloc, const Range* op); |
| static Range* lsh(TempAllocator& alloc, const Range* lhs, int32_t c); |
| static Range* rsh(TempAllocator& alloc, const Range* lhs, int32_t c); |
| static Range* ursh(TempAllocator& alloc, const Range* lhs, int32_t c); |
| static Range* lsh(TempAllocator& alloc, const Range* lhs, const Range* rhs); |
| static Range* rsh(TempAllocator& alloc, const Range* lhs, const Range* rhs); |
| static Range* ursh(TempAllocator& alloc, const Range* lhs, const Range* rhs); |
| static Range* abs(TempAllocator& alloc, const Range* op); |
| static Range* min(TempAllocator& alloc, const Range* lhs, const Range* rhs); |
| static Range* max(TempAllocator& alloc, const Range* lhs, const Range* rhs); |
| static Range* floor(TempAllocator& alloc, const Range* op); |
| static Range* ceil(TempAllocator& alloc, const Range* op); |
| static Range* sign(TempAllocator& alloc, const Range* op); |
| |
| static bool negativeZeroMul(const Range* lhs, const Range* rhs); |
| |
| bool isUnknownInt32() const { |
| return isInt32() && lower() == INT32_MIN && upper() == INT32_MAX; |
| } |
| |
| bool isUnknown() const { |
| return !hasInt32LowerBound_ && |
| !hasInt32UpperBound_ && |
| canHaveFractionalPart_ && |
| canBeNegativeZero_ && |
| max_exponent_ == IncludesInfinityAndNaN; |
| } |
| |
| bool hasInt32LowerBound() const { |
| return hasInt32LowerBound_; |
| } |
| bool hasInt32UpperBound() const { |
| return hasInt32UpperBound_; |
| } |
| |
| // Test whether the value is known to be within [INT32_MIN,INT32_MAX]. |
| // Note that this does not necessarily mean the value is an integer. |
| bool hasInt32Bounds() const { |
| return hasInt32LowerBound() && hasInt32UpperBound(); |
| } |
| |
| // Test whether the value is known to be representable as an int32. |
| bool isInt32() const { |
| return hasInt32Bounds() && |
| !canHaveFractionalPart_ && |
| !canBeNegativeZero_; |
| } |
| |
| // Test whether the given value is known to be either 0 or 1. |
| bool isBoolean() const { |
| return lower() >= 0 && upper() <= 1 && |
| !canHaveFractionalPart_ && |
| !canBeNegativeZero_; |
| } |
| |
| bool canHaveRoundingErrors() const { |
| return canHaveFractionalPart_ || |
| canBeNegativeZero_ || |
| max_exponent_ >= MaxTruncatableExponent; |
| } |
| |
| // Test if an integer x belongs to the range. |
| bool contains(int32_t x) const { |
| return x >= lower_ && x <= upper_; |
| } |
| |
| // Test whether the range contains zero (of either sign). |
| bool canBeZero() const { |
| return contains(0); |
| } |
| |
| // Test whether the range contains NaN values. |
| bool canBeNaN() const { |
| return max_exponent_ == IncludesInfinityAndNaN; |
| } |
| |
| // Test whether the range contains infinities or NaN values. |
| bool canBeInfiniteOrNaN() const { |
| return max_exponent_ >= IncludesInfinity; |
| } |
| |
| FractionalPartFlag canHaveFractionalPart() const { |
| return canHaveFractionalPart_; |
| } |
| |
| NegativeZeroFlag canBeNegativeZero() const { |
| return canBeNegativeZero_; |
| } |
| |
| uint16_t exponent() const { |
| MOZ_ASSERT(!canBeInfiniteOrNaN()); |
| return max_exponent_; |
| } |
| |
| uint16_t numBits() const { |
| return exponent() + 1; // 2^0 -> 1 |
| } |
| |
| // Return the lower bound. Asserts that the value has an int32 bound. |
| int32_t lower() const { |
| MOZ_ASSERT(hasInt32LowerBound()); |
| return lower_; |
| } |
| |
| // Return the upper bound. Asserts that the value has an int32 bound. |
| int32_t upper() const { |
| MOZ_ASSERT(hasInt32UpperBound()); |
| return upper_; |
| } |
| |
| // Test whether all values in this range can are finite and negative. |
| bool isFiniteNegative() const { |
| return upper_ < 0 && !canBeInfiniteOrNaN(); |
| } |
| |
| // Test whether all values in this range can are finite and non-negative. |
| bool isFiniteNonNegative() const { |
| return lower_ >= 0 && !canBeInfiniteOrNaN(); |
| } |
| |
| // Test whether a value in this range can possibly be a finite |
| // negative value. Note that "negative zero" is not considered negative. |
| bool canBeFiniteNegative() const { |
| return lower_ < 0; |
| } |
| |
| // Test whether a value in this range can possibly be a finite |
| // non-negative value. |
| bool canBeFiniteNonNegative() const { |
| return upper_ >= 0; |
| } |
| |
| // Test whether a value in this range can have the sign bit set (not |
| // counting NaN, where the sign bit is meaningless). |
| bool canHaveSignBitSet() const { |
| return !hasInt32LowerBound() || canBeFiniteNegative() || canBeNegativeZero(); |
| } |
| |
| // Set this range to have a lower bound not less than x. |
| void refineLower(int32_t x) { |
| assertInvariants(); |
| hasInt32LowerBound_ = true; |
| lower_ = Max(lower_, x); |
| optimize(); |
| } |
| |
| // Set this range to have an upper bound not greater than x. |
| void refineUpper(int32_t x) { |
| assertInvariants(); |
| hasInt32UpperBound_ = true; |
| upper_ = Min(upper_, x); |
| optimize(); |
| } |
| |
| // Set this range to exclude negative zero. |
| void refineToExcludeNegativeZero() { |
| assertInvariants(); |
| canBeNegativeZero_ = ExcludesNegativeZero; |
| optimize(); |
| } |
| |
| void setInt32(int32_t l, int32_t h) { |
| hasInt32LowerBound_ = true; |
| hasInt32UpperBound_ = true; |
| lower_ = l; |
| upper_ = h; |
| canHaveFractionalPart_ = ExcludesFractionalParts; |
| canBeNegativeZero_ = ExcludesNegativeZero; |
| max_exponent_ = exponentImpliedByInt32Bounds(); |
| assertInvariants(); |
| } |
| |
| // Set this range to include values >= l and <= h. Note that this |
| // function treats negative zero as equal to zero, as >= and <= do. If the |
| // range includes zero, it is assumed to include negative zero too. |
| void setDouble(double l, double h); |
| |
| // Set this range to the narrowest possible range containing d. |
| // This function treats negative zero as distinct from zero, since this |
| // makes the narrowest possible range containin zero a range which |
| // contains one value rather than two. |
| void setDoubleSingleton(double d); |
| |
| void setUnknown() { |
| set(NoInt32LowerBound, NoInt32UpperBound, |
| IncludesFractionalParts, |
| IncludesNegativeZero, |
| IncludesInfinityAndNaN); |
| MOZ_ASSERT(isUnknown()); |
| } |
| |
| void set(int64_t l, int64_t h, |
| FractionalPartFlag canHaveFractionalPart, |
| NegativeZeroFlag canBeNegativeZero, |
| uint16_t e) |
| { |
| max_exponent_ = e; |
| canHaveFractionalPart_ = canHaveFractionalPart; |
| canBeNegativeZero_ = canBeNegativeZero; |
| setLowerInit(l); |
| setUpperInit(h); |
| optimize(); |
| } |
| |
| // Make the lower end of this range at least INT32_MIN, and make |
| // the upper end of this range at most INT32_MAX. |
| void clampToInt32(); |
| |
| // If this range exceeds int32_t range, at either or both ends, change |
| // it to int32_t range. Otherwise do nothing. |
| void wrapAroundToInt32(); |
| |
| // If this range exceeds [0, 32) range, at either or both ends, change |
| // it to the [0, 32) range. Otherwise do nothing. |
| void wrapAroundToShiftCount(); |
| |
| // If this range exceeds [0, 1] range, at either or both ends, change |
| // it to the [0, 1] range. Otherwise do nothing. |
| void wrapAroundToBoolean(); |
| |
| const SymbolicBound* symbolicLower() const { |
| return symbolicLower_; |
| } |
| const SymbolicBound* symbolicUpper() const { |
| return symbolicUpper_; |
| } |
| |
| void setSymbolicLower(SymbolicBound* bound) { |
| symbolicLower_ = bound; |
| } |
| void setSymbolicUpper(SymbolicBound* bound) { |
| symbolicUpper_ = bound; |
| } |
| }; |
| |
| } // namespace jit |
| } // namespace js |
| |
| #endif /* jit_RangeAnalysis_h */ |
