dart::IntConverterInstr Class Reference

#include <il.h>

Inheritance diagram for dart::IntConverterInstr:

Public Member Functions
	IntConverterInstr (Representation from, Representation to, Value *value, intptr_t deopt_id)
Value *	value () const
Representation	from () const
Representation	to () const
bool	is_truncating () const
void	mark_truncating ()
Definition *	Canonicalize (FlowGraph *flow_graph)
virtual bool	ComputeCanDeoptimize () const
virtual Representation	representation () const
virtual Representation	RequiredInputRepresentation (intptr_t idx) const
virtual bool	AttributesEqual (const Instruction &other) const
virtual intptr_t	DeoptimizationTarget () const
virtual void	InferRange (RangeAnalysis *analysis, Range *range)
virtual bool	MayCreateUnsafeUntaggedPointer () const
	DECLARE_INSTRUCTION (IntConverter)
	DECLARE_ATTRIBUTES_NAMED (("from", "to", "is_truncating"),(from(), to(), is_truncating())) PRINT_OPERANDS_TO_SUPPORT DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(IntConverterInstr
Public Member Functions inherited from dart::TemplateDefinition< 1, NoThrow, Pure >
	TemplateDefinition (intptr_t deopt_id=DeoptId::kNone)
	TemplateDefinition (const InstructionSource &source, intptr_t deopt_id=DeoptId::kNone)
virtual intptr_t	InputCount () const
virtual Value *	InputAt (intptr_t i) const
virtual bool	MayThrow () const

Public Attributes
	TemplateDefinition

Additional Inherited Members
Public Types inherited from dart::TemplateDefinition< 1, NoThrow, Pure >
using	BaseClass = typename Pure< Definition, PureDefinition >::Base
Protected Attributes inherited from dart::TemplateDefinition< 1, NoThrow, Pure >
EmbeddedArray< Value *, N >	inputs_

Detailed Description

Definition at line 10964 of file il.h.

Constructor & Destructor Documentation

IntConverterInstr()

dart::IntConverterInstr::IntConverterInstr ( Representation  from, Representation  to, Value *  value, intptr_t  deopt_id  )

inline

Definition at line 10966 of file il.h.

      : TemplateDefinition(deopt_id),
        from_representation_(from),
        to_representation_(to),
        is_truncating_(to == kUnboxedUint32) {
    ASSERT(from != to);
    // Integer conversion doesn't currently handle non-native representations.
    ASSERT_EQUAL(Boxing::NativeRepresentation(from), from);
    ASSERT_EQUAL(Boxing::NativeRepresentation(to), to);
    ASSERT(from == kUnboxedInt64 || from == kUnboxedUint32 ||
           from == kUnboxedInt32 || from == kUntagged);
    ASSERT(to == kUnboxedInt64 || to == kUnboxedUint32 || to == kUnboxedInt32 ||
           to == kUntagged);
    ASSERT(from != kUntagged || to == kUnboxedIntPtr || to == kUnboxedAddress);
    ASSERT(to != kUntagged || from == kUnboxedIntPtr ||
           from == kUnboxedAddress);
    // Don't allow conversions from unsafe untagged addresses.
    ASSERT(!value->definition()->MayCreateUnsafeUntaggedPointer());
    SetInputAt(0, value);
  }

Member Function Documentation

AttributesEqual()

virtual bool dart::IntConverterInstr::AttributesEqual ( const Instruction &  other ) const

inlinevirtual

Definition at line 11009 of file il.h.

                                                               {
    ASSERT(other.IsIntConverter());
    auto const converter = other.AsIntConverter();
    return (converter->from() == from()) && (converter->to() == to()) &&
           (converter->is_truncating() == is_truncating());
  }

Canonicalize()

Definition * dart::IntConverterInstr::Canonicalize

(

FlowGraph *

flow_graph

)

Definition at line 3438 of file il.cc.

                                                                 {
  if (!HasUses()) return nullptr;
 
  // Fold IntConverter({Unboxed}Constant(...)) to UnboxedConstant.
  if (auto constant = value()->definition()->AsConstant()) {
    if (from() != kUntagged && to() != kUntagged &&
        constant->representation() == from() && constant->value().IsInteger()) {
      const int64_t value = Integer::Cast(constant->value()).AsInt64Value();
      const int64_t result =
          Evaluator::TruncateTo(Evaluator::TruncateTo(value, from()), to());
      if (is_truncating() || (value == result)) {
        auto& box = Integer::Handle(Integer::New(result, Heap::kOld));
        box ^= box.Canonicalize(flow_graph->thread());
        return flow_graph->GetConstant(box, to());
      }
    }
  }
 
  // Fold IntCoverter(b->c, IntConverter(a->b, v)) into IntConverter(a->c, v).
  IntConverterInstr* first_converter = value()->definition()->AsIntConverter();
  if ((first_converter != nullptr) &&
      (first_converter->representation() == from())) {
    const auto intermediate_rep = first_converter->representation();
    // Only eliminate intermediate conversion if it does not change the value.
    auto src_defn = first_converter->value()->definition();
    if (intermediate_rep == kUntagged) {
      // Both conversions are no-ops, as the other representations must be
      // kUnboxedIntPtr.
    } else if (!Range::Fits(src_defn->range(), intermediate_rep)) {
      return this;
    }
 
    // Otherwise it is safe to discard any other conversions from and then back
    // to the same integer type.
    if (first_converter->from() == to()) {
      return src_defn;
    }
 
    // Do not merge conversions where the first starts from Untagged or the
    // second ends at Untagged, since we expect to see either UnboxedIntPtr
    // or UnboxedFfiIntPtr as the other type in an Untagged conversion.
    if ((first_converter->from() == kUntagged) || (to() == kUntagged)) {
      return this;
    }
 
    IntConverterInstr* converter = new IntConverterInstr(
        first_converter->from(), representation(),
        first_converter->value()->CopyWithType(),
        (to() == kUnboxedInt32) ? GetDeoptId() : DeoptId::kNone);
    if ((representation() == kUnboxedInt32) && is_truncating()) {
      converter->mark_truncating();
    }
    flow_graph->InsertBefore(this, converter, env(), FlowGraph::kValue);
    return converter;
  }
 
  UnboxInt64Instr* unbox_defn = value()->definition()->AsUnboxInt64();
  if (unbox_defn != nullptr && (from() == kUnboxedInt64) &&
      (to() == kUnboxedInt32) && unbox_defn->HasOnlyInputUse(value())) {
    // TODO(vegorov): there is a duplication of code between UnboxedIntConverter
    // and code path that unboxes Mint into Int32. We should just schedule
    // these instructions close to each other instead of fusing them.
    Definition* replacement =
        new UnboxInt32Instr(is_truncating() ? UnboxInt32Instr::kTruncate
                                            : UnboxInt32Instr::kNoTruncation,
                            unbox_defn->value()->CopyWithType(), GetDeoptId());
    flow_graph->InsertBefore(this, replacement, env(), FlowGraph::kValue);
    return replacement;
  }
 
  return this;
}

ComputeCanDeoptimize()

bool dart::IntConverterInstr::ComputeCanDeoptimize ( ) const

virtual

Definition at line 2025 of file il.cc.

                                                   {
  return (to() == kUnboxedInt32) && !is_truncating() &&
         !RangeUtils::Fits(value()->definition()->range(),
                           RangeBoundary::kRangeBoundaryInt32);
}

DECLARE_ATTRIBUTES_NAMED()

dart::IntConverterInstr::DECLARE_ATTRIBUTES_NAMED	(	("from", "to", "is_truncating")	,
		(from(), to(), is_truncating())
	)

DECLARE_INSTRUCTION()

dart::IntConverterInstr::DECLARE_INSTRUCTION

(

IntConverter

)

DeoptimizationTarget()

virtual intptr_t dart::IntConverterInstr::DeoptimizationTarget ( ) const

inlinevirtual

Definition at line 11016 of file il.h.

{ return GetDeoptId(); }

from()

Representation dart::IntConverterInstr::from ( ) const

inline

Definition at line 10992 of file il.h.

{ return from_representation_; }

InferRange()

void dart::IntConverterInstr::InferRange ( RangeAnalysis *  analysis, Range *  range  )

virtual

Definition at line 3097 of file range_analysis.cc.

                                                                        {
  ASSERT(to() != kUntagged);  // Not an integer-valued definition.
  ASSERT(RepresentationUtils::IsUnboxedInteger(to()));
  ASSERT(from() == kUntagged || RepresentationUtils::IsUnboxedInteger(from()));
 
  const Range* const value_range = value()->definition()->range();
  const Range to_range = Range::Full(to());
 
  if (from() == kUntagged) {
    ASSERT(value_range == nullptr);  // Not an integer-valued definition.
    *range = to_range;
  } else if (Range::IsUnknown(value_range)) {
    *range = to_range;
  } else if (RepresentationUtils::ValueSize(to()) >
                 RepresentationUtils::ValueSize(from()) &&
             (!RepresentationUtils::IsUnsignedInteger(to()) ||
              RepresentationUtils::IsUnsignedInteger(from()))) {
    // All signed unboxed ints of larger sizes can represent all values for
    // signed or unsigned unboxed ints of smaller sizes, and all unsigned
    // unboxed ints of larger sizes can represent all values for unsigned
    // boxed ints of smaller sizes.
    *range = *value_range;
  } else if (is_truncating()) {
    // Either the bits are being reinterpreted (if the two representations
    // are the same size) or a larger value is being truncated. That means
    // we need to determine whether or not the value range lies within the
    // range of numbers that have the same representation (modulo truncation).
    const Range common_range = Range::Full(from()).Intersect(&to_range);
    if (value_range->IsWithin(&common_range)) {
      *range = *value_range;
    } else {
      // In most cases, if there are non-representable values, then no
      // assumptions can be made about the converted value.
      *range = to_range;
    }
  } else {
    // The conversion deoptimizes if the value is outside the range represented
    // by to(), so we can just take the intersection.
    *range = value_range->Intersect(&to_range);
  }
 
  ASSERT_VALID_RANGE_FOR_REPRESENTATION(this, range, to());
}

is_truncating()

bool dart::IntConverterInstr::is_truncating ( ) const

inline

Definition at line 10994 of file il.h.

{ return is_truncating_; }

mark_truncating()

void dart::IntConverterInstr::mark_truncating ( )

inline

Definition at line 10996 of file il.h.

{ is_truncating_ = true; }

MayCreateUnsafeUntaggedPointer()

virtual bool dart::IntConverterInstr::MayCreateUnsafeUntaggedPointer ( ) const

inlinevirtual

Definition at line 11020 of file il.h.

                                                      {
    // The compiler no longer converts between unsafe untagged pointers and
    // unboxed integers.
    return false;
  }

representation()

virtual Representation dart::IntConverterInstr::representation ( ) const

inlinevirtual

Definition at line 11002 of file il.h.

{ return to(); }

RequiredInputRepresentation()

virtual Representation dart::IntConverterInstr::RequiredInputRepresentation ( intptr_t  idx ) const

inlinevirtual

Definition at line 11004 of file il.h.

                                                                         {
    ASSERT(idx == 0);
    return from();
  }

to()

Representation dart::IntConverterInstr::to ( ) const

inline

Definition at line 10993 of file il.h.

{ return to_representation_; }

value()

Value * dart::IntConverterInstr::value ( ) const

inline

Definition at line 10990 of file il.h.

{ return inputs_[0]; }

Member Data Documentation

TemplateDefinition

dart::IntConverterInstr::TemplateDefinition

Definition at line 11039 of file il.h.

---

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

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