dart::RedefinitionInstr Class Reference

#include <il.h>

Inheritance diagram for dart::RedefinitionInstr:

Public Member Functions
	RedefinitionInstr (Value *value, bool inserted_by_constant_propagation=false)
Value *	value () const
virtual CompileType	ComputeType () const
virtual bool	RecomputeType ()
virtual Definition *	Canonicalize (FlowGraph *flow_graph)
void	set_constrained_type (CompileType *type)
CompileType *	constrained_type () const
bool	inserted_by_constant_propagation () const
virtual bool	ComputeCanDeoptimize () const
virtual bool	HasUnknownSideEffects () const
virtual Value *	RedefinedValue () const
Public Member Functions inherited from dart::TemplateDefinition< 1, NoThrow >
	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

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

Detailed Description

Definition at line 4080 of file il.h.

Constructor & Destructor Documentation

RedefinitionInstr()

dart::RedefinitionInstr::RedefinitionInstr ( Value *  value, bool  inserted_by_constant_propagation = false  )

inlineexplicit

Definition at line 4082 of file il.h.

      : constrained_type_(nullptr),
        inserted_by_constant_propagation_(inserted_by_constant_propagation) {
    SetInputAt(0, value);
  }

Member Function Documentation

Canonicalize()

Definition * dart::RedefinitionInstr::Canonicalize ( FlowGraph *  flow_graph )

virtual

Definition at line 2628 of file il.cc.

                                                                 {
  // Must not remove Redefinitions without uses until LICM, even though
  // Redefinition might not have any uses itself it can still be dominating
  // uses of the value it redefines and must serve as a barrier for those
  // uses. RenameUsesDominatedByRedefinitions would normalize the graph and
  // route those uses through this redefinition.
  if (!HasUses() && !flow_graph->is_licm_allowed()) {
    return nullptr;
  }
  if (constrained_type() != nullptr &&
      constrained_type()->IsEqualTo(value()->Type())) {
    return value()->definition();
  }
  return this;
}

ComputeCanDeoptimize()

virtual bool dart::RedefinitionInstr::ComputeCanDeoptimize ( ) const

inlinevirtual

Definition at line 4105 of file il.h.

{ return false; }

ComputeType()

CompileType dart::RedefinitionInstr::ComputeType ( ) const

virtual

Definition at line 1118 of file type_propagator.cc.

                                                 {
  if (constrained_type_ != nullptr) {
    // Check if the type associated with this redefinition is more specific
    // than the type of its input. If yes, return it. Otherwise, fall back
    // to the input's type.
 
    // If either type is non-nullable, the resulting type is non-nullable.
    const bool is_nullable =
        value()->Type()->is_nullable() && constrained_type_->is_nullable();
    // The resulting type can be the sentinel value only if both types can be.
    const bool can_be_sentinel = value()->Type()->can_be_sentinel() &&
                                 constrained_type_->can_be_sentinel();
 
    // If either type has a concrete cid, stick with it.
    if (value()->Type()->ToNullableCid() != kDynamicCid) {
      return CompileType(is_nullable, can_be_sentinel,
                         value()->Type()->ToNullableCid(), nullptr);
    }
    if (constrained_type_->ToNullableCid() != kDynamicCid) {
      return CompileType(is_nullable, can_be_sentinel,
                         constrained_type_->ToNullableCid(), nullptr);
    }
 
    CompileType result(
        value()->Type()->IsSubtypeOf(*constrained_type_->ToAbstractType())
            ? *value()->Type()
            : *constrained_type_);
    if (!is_nullable) {
      result = result.CopyNonNullable();
    }
    if (!can_be_sentinel) {
      result = result.CopyNonSentinel();
    }
    return result;
  }
  return *value()->Type();
}

constrained_type()

CompileType * dart::RedefinitionInstr::constrained_type ( ) const

inline

Definition at line 4099 of file il.h.

{ return constrained_type_; }

HasUnknownSideEffects()

virtual bool dart::RedefinitionInstr::HasUnknownSideEffects ( ) const

inlinevirtual

Definition at line 4106 of file il.h.

{ return false; }

inserted_by_constant_propagation()

bool dart::RedefinitionInstr::inserted_by_constant_propagation ( ) const

inline

Definition at line 4101 of file il.h.

                                                {
    return inserted_by_constant_propagation_;
  }

RecomputeType()

bool dart::RedefinitionInstr::RecomputeType ( )

virtual

Definition at line 1156 of file type_propagator.cc.

                                      {
  return UpdateType(ComputeType());
}

RedefinedValue()

Value * dart::RedefinitionInstr::RedefinedValue ( ) const

virtual

Definition at line 543 of file il.cc.

                                               {
  return value();
}

set_constrained_type()

void dart::RedefinitionInstr::set_constrained_type ( CompileType *  type )

inline

Definition at line 4098 of file il.h.

{ constrained_type_ = type; }

value()

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

inline

Definition at line 4091 of file il.h.

{ return inputs_[0]; }

---

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/type_propagator.cc