dart::Range Class Reference

#include <range_analysis.h>

Inheritance diagram for dart::Range:

Public Member Functions
	Range ()
	Range (RangeBoundary min, RangeBoundary max)
	Range (const Range &other)
Range &	operator= (const Range &other)
void	PrintTo (BaseTextBuffer *f) const
bool	Equals (const Range *other)
const RangeBoundary &	min () const
const RangeBoundary &	max () const
void	set_min (const RangeBoundary &value)
void	set_max (const RangeBoundary &value)
bool	IsPositive () const
bool	IsNegative () const
bool	OnlyLessThanOrEqualTo (int64_t val) const
bool	OnlyGreaterThanOrEqualTo (int64_t val) const
bool	IsWithin (int64_t min_int, int64_t max_int) const
bool	IsWithin (const Range *other) const
bool	Overlaps (int64_t min_int, int64_t max_int) const
bool	IsUnsatisfiable () const
bool	IsSingleton () const
int64_t	Singleton () const
Range	Intersect (const Range *other) const
bool	Fits (RangeBoundary::RangeSize size) const
void	Clamp (RangeBoundary::RangeSize size)
void	ClampToConstant (RangeBoundary::RangeSize size)
void	Write (FlowGraphSerializer *s) const
	Range (FlowGraphDeserializer *d)
Public Member Functions inherited from dart::ZoneAllocated
	ZoneAllocated ()
void *	operator new (size_t size)
void *	operator new (size_t size, Zone *zone)
void	operator delete (void *pointer)

Static Public Member Functions
static bool	IsUnknown (const Range *other)
static Range	Full (RangeBoundary::RangeSize size)
static Range	Full (Representation rep)
static const char *	ToCString (const Range *range)
static RangeBoundary	ConstantMinSmi (const Range *range)
static RangeBoundary	ConstantMaxSmi (const Range *range)
static RangeBoundary	ConstantMin (const Range *range)
static RangeBoundary	ConstantMax (const Range *range)
static RangeBoundary	ConstantMin (const Range *range, RangeBoundary::RangeSize size)
static RangeBoundary	ConstantMax (const Range *range, RangeBoundary::RangeSize size)
static bool	Fits (Range *range, Representation rep)
static void	Add (const Range *left_range, const Range *right_range, RangeBoundary *min, RangeBoundary *max, Definition *left_defn)
static void	Sub (const Range *left_range, const Range *right_range, RangeBoundary *min, RangeBoundary *max, Definition *left_defn)
static void	Mul (const Range *left_range, const Range *right_range, RangeBoundary *min, RangeBoundary *max)
static void	TruncDiv (const Range *left_range, const Range *right_range, RangeBoundary *min, RangeBoundary *max)
static void	Mod (const Range *right_range, RangeBoundary *min, RangeBoundary *max)
static void	Shr (const Range *left_range, const Range *right_range, RangeBoundary *min, RangeBoundary *max)
static void	Ushr (const Range *left_range, const Range *right_range, RangeBoundary *min, RangeBoundary *max)
static void	Shl (const Range *left_range, const Range *right_range, RangeBoundary *min, RangeBoundary *max)
static void	And (const Range *left_range, const Range *right_range, RangeBoundary *min, RangeBoundary *max)
static void	BitwiseOp (const Range *left_range, const Range *right_range, RangeBoundary *min, RangeBoundary *max)
static bool	OnlyPositiveOrZero (const Range &a, const Range &b)
static bool	OnlyNegativeOrZero (const Range &a, const Range &b)
static int64_t	ConstantAbsMax (const Range *range)
static int64_t	ConstantAbsMin (const Range *range)
static void	BinaryOp (const Token::Kind op, const Range *left_range, const Range *right_range, Definition *left_defn, Range *result)

Detailed Description

Definition at line 277 of file range_analysis.h.

Constructor & Destructor Documentation

Range() [1/4]

dart::Range::Range ( )

inline

Definition at line 279 of file range_analysis.h.

: min_(), max_() {}

Range() [2/4]

dart::Range::Range ( RangeBoundary  min, RangeBoundary  max  )

inline

Definition at line 281 of file range_analysis.h.

                                              : min_(min), max_(max) {
    ASSERT(min_.IsUnknown() == max_.IsUnknown());
  }

Range() [3/4]

dart::Range::Range ( const Range &  other )

inline

Definition at line 285 of file range_analysis.h.

      : ZoneAllocated(), min_(other.min_), max_(other.max_) {}

Range() [4/4]

dart::Range::Range ( FlowGraphDeserializer *  d )

explicit

Definition at line 2211 of file il_serializer.cc.

    : min_(RangeBoundary(d)), max_(RangeBoundary(d)) {}

Member Function Documentation

Add()

void dart::Range::Add ( const Range *  left_range, const Range *  right_range, RangeBoundary *  min, RangeBoundary *  max, Definition *  left_defn  )

static

Definition at line 2365 of file range_analysis.cc.

                                       {
  ASSERT(left_range != nullptr);
  ASSERT(right_range != nullptr);
  ASSERT(result_min != nullptr);
  ASSERT(result_max != nullptr);
 
  RangeBoundary left_min = Definition::IsArrayLength(left_defn)
                               ? RangeBoundary::FromDefinition(left_defn)
                               : left_range->min();
 
  RangeBoundary left_max = Definition::IsArrayLength(left_defn)
                               ? RangeBoundary::FromDefinition(left_defn)
                               : left_range->max();
 
  bool overflow = false;
  if (!RangeBoundary::SymbolicAdd(left_min, right_range->min(), result_min)) {
    const auto left_min_bound = left_range->min().LowerBound();
    const auto right_min_bound = right_range->min().LowerBound();
    if (RangeBoundary::WillAddOverflow(left_min_bound, right_min_bound)) {
      overflow = true;
    } else {
      *result_min = RangeBoundary::Add(left_min_bound, right_min_bound);
    }
  }
  if (!RangeBoundary::SymbolicAdd(left_max, right_range->max(), result_max)) {
    const auto left_max_bound = left_range->max().UpperBound();
    const auto right_max_bound = right_range->max().UpperBound();
    if (RangeBoundary::WillAddOverflow(left_max_bound, right_max_bound)) {
      overflow = true;
    } else {
      *result_max = RangeBoundary::Add(left_max_bound, right_max_bound);
    }
  }
  if (overflow) {
    *result_min =
        RangeBoundary::MinConstant(RangeBoundary::kRangeBoundaryInt64);
    *result_max =
        RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64);
  }
}

And()

void dart::Range::And ( const Range *  left_range, const Range *  right_range, RangeBoundary *  min, RangeBoundary *  max  )

static

Definition at line 2318 of file range_analysis.cc.

                                           {
  ASSERT(left_range != nullptr);
  ASSERT(right_range != nullptr);
  ASSERT(result_min != nullptr);
  ASSERT(result_max != nullptr);
 
  if (Range::ConstantMin(right_range).ConstantValue() >= 0) {
    *result_min = RangeBoundary::FromConstant(0);
    *result_max = Range::ConstantMax(right_range);
    return;
  }
 
  if (Range::ConstantMin(left_range).ConstantValue() >= 0) {
    *result_min = RangeBoundary::FromConstant(0);
    *result_max = Range::ConstantMax(left_range);
    return;
  }
 
  BitwiseOp(left_range, right_range, result_min, result_max);
}

BinaryOp()

void dart::Range::BinaryOp ( const Token::Kind  op, const Range *  left_range, const Range *  right_range, Definition *  left_defn, Range *  result  )

static

Definition at line 2573 of file range_analysis.cc.

                                    {
  ASSERT(left_range != nullptr);
  ASSERT(right_range != nullptr);
 
  RangeBoundary min;
  RangeBoundary max;
  ASSERT(min.IsUnknown() && max.IsUnknown());
 
  switch (op) {
    case Token::kADD:
      Range::Add(left_range, right_range, &min, &max, left_defn);
      break;
 
    case Token::kSUB:
      Range::Sub(left_range, right_range, &min, &max, left_defn);
      break;
 
    case Token::kMUL:
      Range::Mul(left_range, right_range, &min, &max);
      break;
 
    case Token::kTRUNCDIV:
      Range::TruncDiv(left_range, right_range, &min, &max);
      break;
 
    case Token::kMOD:
      Range::Mod(right_range, &min, &max);
      break;
 
    case Token::kSHL:
      Range::Shl(left_range, right_range, &min, &max);
      break;
 
    case Token::kSHR:
      Range::Shr(left_range, right_range, &min, &max);
      break;
 
    case Token::kUSHR:
      Range::Ushr(left_range, right_range, &min, &max);
      break;
 
    case Token::kBIT_AND:
      Range::And(left_range, right_range, &min, &max);
      break;
 
    case Token::kBIT_XOR:
    case Token::kBIT_OR:
      Range::BitwiseOp(left_range, right_range, &min, &max);
      break;
 
    default:
      *result =
          Range(RangeBoundary::MinConstant(RangeBoundary::kRangeBoundaryInt64),
                RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64));
      return;
  }
 
  ASSERT(!min.IsUnknown() && !max.IsUnknown());
 
  // Sanity: avoid [l, u] with constants l > u.
  ASSERT(!min.IsConstant() || !max.IsConstant() ||
         min.ConstantValue() <= max.ConstantValue());
 
  *result = Range(min, max);
}

BitwiseOp()

void dart::Range::BitwiseOp ( const Range *  left_range, const Range *  right_range, RangeBoundary *  min, RangeBoundary *  max  )

static

Definition at line 2348 of file range_analysis.cc.

                                                 {
  const int bitsize = Utils::Maximum(BitSize(left_range), BitSize(right_range));
 
  if (left_range->IsPositive() && right_range->IsPositive()) {
    *result_min = RangeBoundary::FromConstant(0);
  } else {
    *result_min =
        RangeBoundary::FromConstant(-(static_cast<uint64_t>(1) << bitsize));
  }
 
  *result_max =
      RangeBoundary::FromConstant((static_cast<uint64_t>(1) << bitsize) - 1);
}

Clamp()

void dart::Range::Clamp

(

RangeBoundary::RangeSize

size

)

Definition at line 2176 of file range_analysis.cc.

                                             {
  min_ = min_.Clamp(size);
  max_ = max_.Clamp(size);
}

ClampToConstant()

void dart::Range::ClampToConstant

(

RangeBoundary::RangeSize

size

)

Definition at line 2181 of file range_analysis.cc.

                                                       {
  min_ = min_.LowerBound().Clamp(size);
  max_ = max_.UpperBound().Clamp(size);
}

ConstantAbsMax()

int64_t dart::Range::ConstantAbsMax ( const Range *  range )

static

Definition at line 2550 of file range_analysis.cc.

                                                {
  if (range == nullptr) {
    return RangeBoundary::kMax;
  }
  const int64_t abs_min =
      Utils::AbsWithSaturation(Range::ConstantMin(range).ConstantValue());
  const int64_t abs_max =
      Utils::AbsWithSaturation(Range::ConstantMax(range).ConstantValue());
  return Utils::Maximum(abs_min, abs_max);
}

ConstantAbsMin()

int64_t dart::Range::ConstantAbsMin ( const Range *  range )

static

Definition at line 2562 of file range_analysis.cc.

                                                {
  if (range == nullptr) {
    return 0;
  }
  const int64_t abs_min =
      Utils::AbsWithSaturation(Range::ConstantMin(range).ConstantValue());
  const int64_t abs_max =
      Utils::AbsWithSaturation(Range::ConstantMax(range).ConstantValue());
  return Utils::Minimum(abs_min, abs_max);
}

ConstantMax() [1/2]

static RangeBoundary dart::Range::ConstantMax ( const Range *  range )

inlinestatic

Definition at line 338 of file range_analysis.h.

                                                       {
    return ConstantMax(range, RangeBoundary::kRangeBoundaryInt64);
  }

ConstantMax() [2/2]

static RangeBoundary dart::Range::ConstantMax ( const Range *  range, RangeBoundary::RangeSize  size  )

inlinestatic

Definition at line 350 of file range_analysis.h.

                                                                {
    if (range == nullptr) {
      return RangeBoundary::MaxConstant(size);
    }
    return range->max().UpperBound().Clamp(size);
  }

ConstantMaxSmi()

static RangeBoundary dart::Range::ConstantMaxSmi ( const Range *  range )

inlinestatic

Definition at line 330 of file range_analysis.h.

                                                          {
    return ConstantMax(range, RangeBoundary::kRangeBoundarySmi);
  }

ConstantMin() [1/2]

static RangeBoundary dart::Range::ConstantMin ( const Range *  range )

inlinestatic

Definition at line 334 of file range_analysis.h.

                                                       {
    return ConstantMin(range, RangeBoundary::kRangeBoundaryInt64);
  }

ConstantMin() [2/2]

static RangeBoundary dart::Range::ConstantMin ( const Range *  range, RangeBoundary::RangeSize  size  )

inlinestatic

Definition at line 342 of file range_analysis.h.

                                                                {
    if (range == nullptr) {
      return RangeBoundary::MinConstant(size);
    }
    return range->min().LowerBound().Clamp(size);
  }

ConstantMinSmi()

static RangeBoundary dart::Range::ConstantMinSmi ( const Range *  range )

inlinestatic

Definition at line 326 of file range_analysis.h.

                                                          {
    return ConstantMin(range, RangeBoundary::kRangeBoundarySmi);
  }

Equals()

bool dart::Range::Equals ( const Range *  other )

inline

Definition at line 311 of file range_analysis.h.

                                  {
    ASSERT(min_.IsUnknown() == max_.IsUnknown());
    if (other == nullptr) {
      return min_.IsUnknown();
    }
    return min_.Equals(other->min_) && max_.Equals(other->max_);
  }

Fits() [1/2]

static bool dart::Range::Fits ( Range *  range, Representation  rep  )

inlinestatic

Definition at line 403 of file range_analysis.h.

                                                     {
    if (range == nullptr) return false;
    if (!RepresentationUtils::IsUnboxedInteger(rep)) return false;
    const Range& other = Range::Full(rep);
    return range->IsWithin(&other);
  }

Fits() [2/2]

bool dart::Range::Fits ( RangeBoundary::RangeSize  size ) const

inline

Definition at line 396 of file range_analysis.h.

                                               {
    return !min().LowerBound().Overflowed(size) &&
           !max().UpperBound().Overflowed(size);
  }

Full() [1/2]

static Range dart::Range::Full ( RangeBoundary::RangeSize  size )

inlinestatic

Definition at line 301 of file range_analysis.h.

                                                 {
    return Range(RangeBoundary::MinConstant(size),
                 RangeBoundary::MaxConstant(size));
  }

Full() [2/2]

Range dart::Range::Full ( Representation  rep )

static

Definition at line 2120 of file range_analysis.cc.

                                    {
  ASSERT(RepresentationUtils::IsUnboxedInteger(rep));
  return Range(RangeBoundary::FromConstant(RepresentationUtils::MinValue(rep)),
               RangeBoundary::FromConstant(RepresentationUtils::MaxValue(rep)));
}

Intersect()

Range dart::Range::Intersect ( const Range *  other ) const

inline

Definition at line 391 of file range_analysis.h.

                                            {
    return Range(RangeBoundary::IntersectionMin(min(), other->min()),
                 RangeBoundary::IntersectionMax(max(), other->max()));
  }

IsNegative()

bool dart::Range::IsNegative

(

)

const

Definition at line 2130 of file range_analysis.cc.

                             {
  return OnlyLessThanOrEqualTo(-1);
}

IsPositive()

bool dart::Range::IsPositive

(

)

const

Definition at line 2126 of file range_analysis.cc.

                             {
  return OnlyGreaterThanOrEqualTo(0);
}

IsSingleton()

bool dart::Range::IsSingleton ( ) const

inline

Definition at line 381 of file range_analysis.h.

                           {
    return min_.IsConstant() && max_.IsConstant() &&
           min_.ConstantValue() == max_.ConstantValue();
  }

IsUnknown()

static bool dart::Range::IsUnknown ( const Range *  other )

inlinestatic

Definition at line 294 of file range_analysis.h.

                                            {
    if (other == nullptr) {
      return true;
    }
    return other->min().IsUnknown();
  }

IsUnsatisfiable()

bool dart::Range::IsUnsatisfiable

(

)

const

Definition at line 2166 of file range_analysis.cc.

                                  {
  // Constant case: For example [0, -1].
  if (Range::ConstantMin(this).ConstantValue() >
      Range::ConstantMax(this).ConstantValue()) {
    return true;
  }
  // Symbol case: For example [v+1, v].
  return DependOnSameSymbol(min(), max()) && min().offset() > max().offset();
}

IsWithin() [1/2]

bool dart::Range::IsWithin

(

const Range *

other

)

const

Definition at line 2149 of file range_analysis.cc.

                                             {
  auto const lower_bound = other->min().LowerBound();
  auto const upper_bound = other->max().UpperBound();
  return IsWithin(other->min().ConstantValue(), other->max().ConstantValue());
}

IsWithin() [2/2]

bool dart::Range::IsWithin	(	int64_t	min_int,
		int64_t	max_int
	)		const

Definition at line 2145 of file range_analysis.cc.

                                                           {
  return OnlyGreaterThanOrEqualTo(min_int) && OnlyLessThanOrEqualTo(max_int);
}

max()

const RangeBoundary & dart::Range::max ( ) const

inline

Definition at line 320 of file range_analysis.h.

{ return max_; }

min()

const RangeBoundary & dart::Range::min ( ) const

inline

Definition at line 319 of file range_analysis.h.

{ return min_; }

Mod()

void dart::Range::Mod ( const Range *  right_range, RangeBoundary *  min, RangeBoundary *  max  )

static

Definition at line 2519 of file range_analysis.cc.

                                           {
  ASSERT(right_range != nullptr);
  ASSERT(result_min != nullptr);
  ASSERT(result_max != nullptr);
  // Each modulo result is positive and bounded by one less than
  // the maximum of the right-hand-side (it is unlikely that the
  // left-hand-side further refines this in typical programs).
  // Note that x % MinInt can be MaxInt and x % 0 always throws.
  const int64_t kModMin = 0;
  int64_t mod_max = kMaxInt64;
  if (Range::ConstantMin(right_range).ConstantValue() != kMinInt64) {
    const int64_t right_max = ConstantAbsMax(right_range);
    mod_max = Utils::Maximum(right_max - 1, kModMin);
  }
  *result_min = RangeBoundary::FromConstant(kModMin);
  *result_max = RangeBoundary::FromConstant(mod_max);
}

Mul()

void dart::Range::Mul ( const Range *  left_range, const Range *  right_range, RangeBoundary *  min, RangeBoundary *  max  )

static

Definition at line 2455 of file range_analysis.cc.

                                           {
  ASSERT(left_range != nullptr);
  ASSERT(right_range != nullptr);
  ASSERT(result_min != nullptr);
  ASSERT(result_max != nullptr);
 
  const int64_t left_max = ConstantAbsMax(left_range);
  const int64_t right_max = ConstantAbsMax(right_range);
  if ((left_max <= -compiler::target::kSmiMin) &&
      (right_max <= -compiler::target::kSmiMin) &&
      ((left_max == 0) || (right_max <= kMaxInt64 / left_max))) {
    // Product of left and right max values stays in 64 bit range.
    const int64_t mul_max = left_max * right_max;
    if (OnlyPositiveOrZero(*left_range, *right_range) ||
        OnlyNegativeOrZero(*left_range, *right_range)) {
      // If both ranges are of the same sign then the range of the result
      // is positive and is between multiplications of absolute minimums
      // and absolute maximums.
      const int64_t mul_min =
          ConstantAbsMin(left_range) * ConstantAbsMin(right_range);
      *result_min = RangeBoundary::FromConstant(mul_min);
      *result_max = RangeBoundary::FromConstant(mul_max);
    } else {
      // If ranges have mixed signs then use conservative approximation:
      // absolute value of the result is less or equal to multiplication
      // of absolute maximums.
      *result_min = RangeBoundary::FromConstant(-mul_max);
      *result_max = RangeBoundary::FromConstant(mul_max);
    }
    return;
  }
 
  *result_min = RangeBoundary::MinConstant(RangeBoundary::kRangeBoundaryInt64);
  *result_max = RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64);
}

OnlyGreaterThanOrEqualTo()

bool dart::Range::OnlyGreaterThanOrEqualTo

(

int64_t

val

)

const

Definition at line 2139 of file range_analysis.cc.

                                                      {
  const RangeBoundary lower_bound = min().LowerBound();
  return lower_bound.ConstantValue() >= val;
}

OnlyLessThanOrEqualTo()

bool dart::Range::OnlyLessThanOrEqualTo

(

int64_t

val

)

const

Definition at line 2134 of file range_analysis.cc.

                                                   {
  const RangeBoundary upper_bound = max().UpperBound();
  return upper_bound.ConstantValue() <= val;
}

OnlyNegativeOrZero()

bool dart::Range::OnlyNegativeOrZero ( const Range &  a, const Range &  b  )

static

Definition at line 2545 of file range_analysis.cc.

                                                             {
  return a.OnlyLessThanOrEqualTo(0) && b.OnlyLessThanOrEqualTo(0);
}

OnlyPositiveOrZero()

bool dart::Range::OnlyPositiveOrZero ( const Range &  a, const Range &  b  )

static

Definition at line 2540 of file range_analysis.cc.

                                                             {
  return a.OnlyGreaterThanOrEqualTo(0) && b.OnlyGreaterThanOrEqualTo(0);
}

operator=()

Range & dart::Range::operator= ( const Range &  other )

inline

Definition at line 288 of file range_analysis.h.

                                       {
    min_ = other.min_;
    max_ = other.max_;
    return *this;
  }

Overlaps()

bool dart::Range::Overlaps	(	int64_t	min_int,
		int64_t	max_int
	)		const

Definition at line 2155 of file range_analysis.cc.

                                                           {
  RangeBoundary lower = min().LowerBound();
  RangeBoundary upper = max().UpperBound();
  const int64_t this_min = lower.ConstantValue();
  const int64_t this_max = upper.ConstantValue();
  if ((this_min <= min_int) && (min_int <= this_max)) return true;
  if ((this_min <= max_int) && (max_int <= this_max)) return true;
  if ((min_int < this_min) && (max_int > this_max)) return true;
  return false;
}

PrintTo()

void dart::Range::PrintTo

(

BaseTextBuffer *

f

)

const

set_max()

void dart::Range::set_max ( const RangeBoundary &  value )

inline

Definition at line 324 of file range_analysis.h.

{ max_ = value; }

set_min()

void dart::Range::set_min ( const RangeBoundary &  value )

inline

Definition at line 322 of file range_analysis.h.

{ min_ = value; }

Shl()

void dart::Range::Shl ( const Range *  left_range, const Range *  right_range, RangeBoundary *  min, RangeBoundary *  max  )

static

Definition at line 2186 of file range_analysis.cc.

                                           {
  ASSERT(left != nullptr);
  ASSERT(right != nullptr);
  ASSERT(result_min != nullptr);
  ASSERT(result_max != nullptr);
  RangeBoundary left_max = Range::ConstantMax(left);
  RangeBoundary left_min = Range::ConstantMin(left);
  // A negative shift count always deoptimizes (and throws), so the minimum
  // shift count is zero.
  int64_t right_max = Utils::Maximum(Range::ConstantMax(right).ConstantValue(),
                                     static_cast<int64_t>(0));
  int64_t right_min = Utils::Maximum(Range::ConstantMin(right).ConstantValue(),
                                     static_cast<int64_t>(0));
  bool overflow = false;
  {
    const auto shift_amount =
        left_min.ConstantValue() > 0 ? right_min : right_max;
    if (RangeBoundary::WillShlOverflow(left_min, shift_amount)) {
      overflow = true;
    } else {
      *result_min = RangeBoundary::Shl(left_min, shift_amount);
    }
  }
  {
    const auto shift_amount =
        left_max.ConstantValue() > 0 ? right_max : right_min;
    if (RangeBoundary::WillShlOverflow(left_max, shift_amount)) {
      overflow = true;
    } else {
      *result_max = RangeBoundary::Shl(left_max, shift_amount);
    }
  }
  if (overflow) {
    *result_min =
        RangeBoundary::MinConstant(RangeBoundary::kRangeBoundaryInt64);
    *result_max =
        RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64);
  }
}

Shr()

void dart::Range::Shr ( const Range *  left_range, const Range *  right_range, RangeBoundary *  min, RangeBoundary *  max  )

static

Definition at line 2229 of file range_analysis.cc.

                                           {
  RangeBoundary left_max = Range::ConstantMax(left);
  RangeBoundary left_min = Range::ConstantMin(left);
  // A negative shift count always deoptimizes (and throws), so the minimum
  // shift count is zero.
  int64_t right_max = Utils::Maximum(Range::ConstantMax(right).ConstantValue(),
                                     static_cast<int64_t>(0));
  int64_t right_min = Utils::Maximum(Range::ConstantMin(right).ConstantValue(),
                                     static_cast<int64_t>(0));
 
  *result_min = RangeBoundary::Shr(
      left_min, left_min.ConstantValue() > 0 ? right_max : right_min);
 
  *result_max = RangeBoundary::Shr(
      left_max, left_max.ConstantValue() > 0 ? right_min : right_max);
}

Singleton()

int64_t dart::Range::Singleton ( ) const

inline

Definition at line 386 of file range_analysis.h.

                            {
    ASSERT(IsSingleton());
    return min_.ConstantValue();
  }

Sub()

void dart::Range::Sub ( const Range *  left_range, const Range *  right_range, RangeBoundary *  min, RangeBoundary *  max, Definition *  left_defn  )

static

Definition at line 2410 of file range_analysis.cc.

                                       {
  ASSERT(left_range != nullptr);
  ASSERT(right_range != nullptr);
  ASSERT(result_min != nullptr);
  ASSERT(result_max != nullptr);
 
  RangeBoundary left_min = Definition::IsArrayLength(left_defn)
                               ? RangeBoundary::FromDefinition(left_defn)
                               : left_range->min();
 
  RangeBoundary left_max = Definition::IsArrayLength(left_defn)
                               ? RangeBoundary::FromDefinition(left_defn)
                               : left_range->max();
 
  bool overflow = false;
  if (!RangeBoundary::SymbolicSub(left_min, right_range->max(), result_min)) {
    const auto left_min_bound = left_range->min().LowerBound();
    const auto right_max_bound = right_range->max().UpperBound();
    if (RangeBoundary::WillSubOverflow(left_min_bound, right_max_bound)) {
      overflow = true;
    } else {
      *result_min = RangeBoundary::Sub(left_min_bound, right_max_bound);
    }
  }
  if (!RangeBoundary::SymbolicSub(left_max, right_range->min(), result_max)) {
    const auto left_max_bound = left_range->max().UpperBound();
    const auto right_min_bound = right_range->min().LowerBound();
    if (RangeBoundary::WillSubOverflow(left_max_bound, right_min_bound)) {
      overflow = true;
    } else {
      *result_max = RangeBoundary::Sub(left_max_bound, right_min_bound);
    }
  }
  if (overflow) {
    *result_min =
        RangeBoundary::MinConstant(RangeBoundary::kRangeBoundaryInt64);
    *result_max =
        RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64);
  }
}

ToCString()

static const char * dart::Range::ToCString ( const Range *  range )

static

TruncDiv()

void dart::Range::TruncDiv ( const Range *  left_range, const Range *  right_range, RangeBoundary *  min, RangeBoundary *  max  )

static

Definition at line 2494 of file range_analysis.cc.

                                                {
  ASSERT(left_range != nullptr);
  ASSERT(right_range != nullptr);
  ASSERT(result_min != nullptr);
  ASSERT(result_max != nullptr);
 
  if (left_range->OnlyGreaterThanOrEqualTo(0) &&
      right_range->OnlyGreaterThanOrEqualTo(1)) {
    const int64_t left_max = ConstantAbsMax(left_range);
    const int64_t left_min = ConstantAbsMin(left_range);
    const int64_t right_max = ConstantAbsMax(right_range);
    const int64_t right_min = ConstantAbsMin(right_range);
 
    *result_max = RangeBoundary::FromConstant(left_max / right_min);
    *result_min = RangeBoundary::FromConstant(left_min / right_max);
    return;
  }
 
  *result_min = RangeBoundary::MinConstant(RangeBoundary::kRangeBoundaryInt64);
  *result_max = RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundaryInt64);
}

Ushr()

void dart::Range::Ushr ( const Range *  left_range, const Range *  right_range, RangeBoundary *  min, RangeBoundary *  max  )

static

Definition at line 2284 of file range_analysis.cc.

                                            {
  const int64_t left_max = Range::ConstantMax(left).ConstantValue();
  const int64_t left_min = Range::ConstantMin(left).ConstantValue();
  // A negative shift count always deoptimizes (and throws), so the minimum
  // shift count is zero.
  const int64_t right_max = Utils::Maximum(
      Range::ConstantMax(right).ConstantValue(), static_cast<int64_t>(0));
  const int64_t right_min = Utils::Maximum(
      Range::ConstantMin(right).ConstantValue(), static_cast<int64_t>(0));
 
  uint64_t unsigned_left_min, unsigned_left_max;
  ConvertRangeToUnsigned(left_min, left_max, &unsigned_left_min,
                         &unsigned_left_max);
 
  const uint64_t unsigned_result_min =
      (right_max >= kBitsPerInt64)
          ? 0
          : unsigned_left_min >> static_cast<uint64_t>(right_max);
  const uint64_t unsigned_result_max =
      (right_min >= kBitsPerInt64)
          ? 0
          : unsigned_left_max >> static_cast<uint64_t>(right_min);
 
  int64_t signed_result_min, signed_result_max;
  ConvertRangeToSigned(unsigned_result_min, unsigned_result_max,
                       &signed_result_min, &signed_result_max);
 
  *result_min = RangeBoundary(signed_result_min);
  *result_max = RangeBoundary(signed_result_max);
}

Write()

void dart::Range::Write

(

FlowGraphSerializer *

s

)

const

Definition at line 2206 of file il_serializer.cc.

                                              {
  min_.Write(s);
  max_.Write(s);
}

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/compiler/backend/range_analysis.h
• third_party/dart-lang/sdk/runtime/vm/compiler/backend/il_serializer.cc
• third_party/dart-lang/sdk/runtime/vm/compiler/backend/range_analysis.cc