dart::kernel::SwitchHelper Class Reference

#include <kernel_to_il.h>

Public Member Functions
	SwitchHelper (Zone *zone, TokenPosition position, bool is_exhaustive, const AbstractType &expression_type, SwitchBlock *switch_block, intptr_t case_count)
bool	is_optimizable () const
const TokenPosition &	position () const
bool	is_exhaustive () const
SwitchBlock *	switch_block ()
intptr_t	case_count () const
intptr_t	default_case () const
void	set_default_case (intptr_t index)
const GrowableArray< Fragment > &	case_bodies () const
const GrowableArray< intptr_t > &	case_expression_counts () const
const GrowableArray< SwitchExpression > &	expressions () const
const GrowableArray< SwitchExpression * > &	sorted_expressions () const
const AbstractType &	expression_type () const
const Integer &	expression_min () const
const Integer &	expression_max () const
bool	has_default () const
bool	is_enum_switch () const
int64_t	ExpressionRange () const
bool	RequiresLowerBoundCheck () const
bool	RequiresUpperBoundCheck () const
SwitchDispatch	SelectDispatchStrategy ()
void	AddCaseBody (Fragment body)
void	AddExpression (intptr_t case_index, TokenPosition position, const Instance &value)

Detailed Description

Definition at line 1002 of file kernel_to_il.h.

Constructor & Destructor Documentation

SwitchHelper()

dart::kernel::SwitchHelper::SwitchHelper	(	Zone *	zone,
		TokenPosition	position,
		bool	is_exhaustive,
		const AbstractType &	expression_type,
		SwitchBlock *	switch_block,
		intptr_t	case_count
	)

Definition at line 5833 of file kernel_to_il.cc.

    : zone_(zone),
      position_(position),
      is_exhaustive_(is_exhaustive),
      expression_type_(expression_type),
      switch_block_(switch_block),
      case_count_(case_count),
      case_bodies_(case_count),
      case_expression_counts_(case_count),
      expressions_(case_count),
      sorted_expressions_(case_count) {
  case_expression_counts_.FillWith(0, 0, case_count);
 
  if (expression_type.nullability() == Nullability::kNonNullable) {
    if (expression_type.IsIntType() || expression_type.IsSmiType()) {
      is_optimizable_ = true;
    } else if (expression_type.HasTypeClass() &&
               Class::Handle(zone_, expression_type.type_class())
                   .is_enum_class()) {
      is_optimizable_ = true;
      is_enum_switch_ = true;
    }
  }
}

Member Function Documentation

AddCaseBody()

void dart::kernel::SwitchHelper::AddCaseBody ( Fragment  body )

inline

Definition at line 1066 of file kernel_to_il.h.

{ case_bodies_.Add(body); }

AddExpression()

void dart::kernel::SwitchHelper::AddExpression	(	intptr_t	case_index,
		TokenPosition	position,
		const Instance &	value
	)

Definition at line 6043 of file kernel_to_il.cc.

                                                        {
  case_expression_counts_[case_index]++;
 
  expressions_.Add(SwitchExpression(case_index, position, value));
 
  if (is_optimizable_) {
    // Check the type of the case expression for use in an optimized switch.
    if (!value.IsInstanceOf(expression_type_, Object::null_type_arguments(),
                            Object::null_type_arguments())) {
      is_optimizable_ = false;
    }
  }
}

case_bodies()

const GrowableArray< Fragment > & dart::kernel::SwitchHelper::case_bodies ( ) const

inline

Definition at line 1027 of file kernel_to_il.h.

{ return case_bodies_; }

case_count()

intptr_t dart::kernel::SwitchHelper::case_count ( ) const

inline

Definition at line 1018 of file kernel_to_il.h.

{ return case_count_; }

case_expression_counts()

const GrowableArray< intptr_t > & dart::kernel::SwitchHelper::case_expression_counts ( ) const

inline

Definition at line 1030 of file kernel_to_il.h.

                                                                {
    return case_expression_counts_;
  }

default_case()

intptr_t dart::kernel::SwitchHelper::default_case ( ) const

inline

Definition at line 1021 of file kernel_to_il.h.

{ return default_case_; }

expression_max()

const Integer & dart::kernel::SwitchHelper::expression_max ( ) const

inline

Definition at line 1049 of file kernel_to_il.h.

                                        {
    ASSERT(expression_max_ != nullptr);
    return *expression_max_;
  }

expression_min()

const Integer & dart::kernel::SwitchHelper::expression_min ( ) const

inline

Definition at line 1045 of file kernel_to_il.h.

                                        {
    ASSERT(expression_min_ != nullptr);
    return *expression_min_;
  }

expression_type()

const AbstractType & dart::kernel::SwitchHelper::expression_type ( ) const

inline

Definition at line 1043 of file kernel_to_il.h.

{ return expression_type_; }

ExpressionRange()

int64_t dart::kernel::SwitchHelper::ExpressionRange

(

)

const

Definition at line 5863 of file kernel_to_il.cc.

                                            {
  const int64_t min = expression_min().AsInt64Value();
  const int64_t max = expression_max().AsInt64Value();
  ASSERT(min <= max);
  const uint64_t diff = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
  // Saturate to avoid overflow.
  if (diff > static_cast<uint64_t>(kMaxInt64 - 1)) {
    return kMaxInt64;
  }
  return static_cast<int64_t>(diff + 1);
}

expressions()

const GrowableArray< SwitchExpression > & dart::kernel::SwitchHelper::expressions ( ) const

inline

Definition at line 1034 of file kernel_to_il.h.

                                                             {
    return expressions_;
  }

has_default()

bool dart::kernel::SwitchHelper::has_default ( ) const

inline

Definition at line 1054 of file kernel_to_il.h.

{ return default_case_ >= 0; }

is_enum_switch()

bool dart::kernel::SwitchHelper::is_enum_switch ( ) const

inline

Definition at line 1056 of file kernel_to_il.h.

{ return is_enum_switch_; }

is_exhaustive()

bool dart::kernel::SwitchHelper::is_exhaustive ( ) const

inline

Definition at line 1016 of file kernel_to_il.h.

{ return is_exhaustive_; }

is_optimizable()

bool dart::kernel::SwitchHelper::is_optimizable ( ) const

inline

Definition at line 1014 of file kernel_to_il.h.

{ return is_optimizable_; }

position()

const TokenPosition & dart::kernel::SwitchHelper::position ( ) const

inline

Definition at line 1015 of file kernel_to_il.h.

{ return position_; }

RequiresLowerBoundCheck()

bool dart::kernel::SwitchHelper::RequiresLowerBoundCheck

(

)

const

Definition at line 5875 of file kernel_to_il.cc.

                                                 {
  if (is_enum_switch()) {
    if (expression_min().IsZero()) {
      // Enum indexes are always positive.
      return false;
    }
  }
  return true;
}

RequiresUpperBoundCheck()

bool dart::kernel::SwitchHelper::RequiresUpperBoundCheck

(

)

const

Definition at line 5885 of file kernel_to_il.cc.

                                                 {
  if (is_enum_switch()) {
    return has_default() || !is_exhaustive();
  }
  return true;
}

SelectDispatchStrategy()

SwitchDispatch dart::kernel::SwitchHelper::SelectDispatchStrategy

(

)

Definition at line 5892 of file kernel_to_il.cc.

                                                    {
  // For small to medium-sized switches, binary search is faster than a
  // jump table.
  // Please update runtime/tests/vm/dart/optimized_switch_test.dart
  // when changing this constant.
  const intptr_t kJumpTableMinExpressions = 16;
  // This limit comes from IndirectGotoInstr.
  // Realistically, the current limit should never be hit by any code.
  const intptr_t kJumpTableMaxSize = kMaxInt32;
  // Sometimes the switch expressions don't cover a contiguous range.
  // If the ratio of holes to expressions is too great we fall back to a
  // binary search to avoid code size explosion.
  const double kJumpTableMaxHolesRatio = 1.0;
 
  if (!is_optimizable() || expressions().is_empty()) {
    // The switch is not optimizable, so we can only use linear scan.
    return kSwitchDispatchLinearScan;
  }
 
  if (!CompilerState::Current().is_aot()) {
    // JIT mode supports hot-reload, which currently prevents us from
    // enabling optimized switches.
    return kSwitchDispatchLinearScan;
  }
 
  if (FLAG_force_switch_dispatch_type == kSwitchDispatchLinearScan) {
    return kSwitchDispatchLinearScan;
  }
 
  PrepareForOptimizedSwitch();
 
  if (!is_optimizable()) {
    // While preparing for an optimized switch we might have discovered that
    // the switch is not optimizable after all.
    return kSwitchDispatchLinearScan;
  }
 
  if (FLAG_force_switch_dispatch_type == kSwitchDispatchBinarySearch) {
    return kSwitchDispatchBinarySearch;
  }
 
  const int64_t range = ExpressionRange();
  if (range > kJumpTableMaxSize) {
    return kSwitchDispatchBinarySearch;
  }
 
  const intptr_t num_expressions = expressions().length();
  ASSERT(num_expressions <= range);
 
  const intptr_t max_holes = num_expressions * kJumpTableMaxHolesRatio;
  const int64_t holes = range - num_expressions;
 
  if (FLAG_force_switch_dispatch_type != kSwitchDispatchJumpTable) {
    if (num_expressions < kJumpTableMinExpressions) {
      return kSwitchDispatchBinarySearch;
    }
 
    if (holes > max_holes) {
      return kSwitchDispatchBinarySearch;
    }
  }
 
  // After this point we will use a jump table.
 
  // In the general case, bounds checks are required before a jump table
  // to handle all possible integer values.
  // For enums, the set of possible index values is known and much smaller
  // than the set of all possible integer values. A jump table that covers
  // either or both bounds of the range of index values requires only one or
  // no bounds checks.
  // If the expressions of an enum switch don't cover the full range of
  // values we can try to extend the jump table to cover the full range, but
  // not beyond kJumpTableMaxHolesRatio.
  // The count of enum values is not available when the flow graph is
  // constructed. The lower bound is always 0 so eliminating the lower
  // bound check is still possible by extending expression_min to 0.
  //
  // In the case of an integer switch we try to extend expression_min to 0
  // for a different reason.
  // If the range starts at zero it directly maps to the jump table
  // and we don't need to adjust the switch variable before the
  // jump table.
  if (expression_min().AsInt64Value() > 0) {
    const intptr_t holes_budget = Utils::Minimum(
        // Holes still available.
        max_holes - holes,
        // Entries left in the jump table.
        kJumpTableMaxSize - range);
 
    const int64_t required_holes = expression_min().AsInt64Value();
    if (required_holes <= holes_budget) {
      expression_min_ = &Object::smi_zero();
    }
  }
 
  return kSwitchDispatchJumpTable;
}

set_default_case()

void dart::kernel::SwitchHelper::set_default_case ( intptr_t  index )

inline

Definition at line 1022 of file kernel_to_il.h.

                                        {
    ASSERT(default_case_ == -1);
    default_case_ = index;
  }

sorted_expressions()

const GrowableArray< SwitchExpression * > & dart::kernel::SwitchHelper::sorted_expressions ( ) const

inline

Definition at line 1038 of file kernel_to_il.h.

                                                                     {
    return sorted_expressions_;
  }

switch_block()

SwitchBlock * dart::kernel::SwitchHelper::switch_block ( )

inline

Definition at line 1017 of file kernel_to_il.h.

{ return switch_block_; }

---

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

• third_party/dart-lang/sdk/runtime/vm/compiler/frontend/kernel_to_il.h
• third_party/dart-lang/sdk/runtime/vm/compiler/frontend/kernel_to_il.cc