dart::ParameterInstr Class Reference

#include <il.h>

Inheritance diagram for dart::ParameterInstr:

Public Member Functions
	ParameterInstr (BlockEntryInstr *block, intptr_t env_index, intptr_t param_index, const Location &loc, Representation representation)
	DECLARE_ATTRIBUTES_NAMED (("index", "location"),(index(), location())) intptr_t env_index() const
intptr_t	index () const
intptr_t	param_index () const
const Location &	location () const
virtual BlockEntryInstr *	GetBlock ()
void	set_block (BlockEntryInstr *block)
virtual Representation	representation () const
virtual Representation	RequiredInputRepresentation (intptr_t index) const
virtual bool	ComputeCanDeoptimize () const
virtual bool	HasUnknownSideEffects () const
virtual uword	Hash () const
virtual CompileType	ComputeType () const
	DISALLOW_COPY_AND_ASSIGN (ParameterInstr)
Public Member Functions inherited from dart::TemplateDefinition< 0, 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

Public Attributes
DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS(ParameterInstr, TemplateDefinition, FIELD_LIST) DECLARE_EXTRA_SERIALIZATION private Location	location_

Static Public Attributes
static constexpr intptr_t	kNotFunctionParameter = -1

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

Detailed Description

Definition at line 2900 of file il.h.

Constructor & Destructor Documentation

ParameterInstr()

dart::ParameterInstr::ParameterInstr ( BlockEntryInstr *  block, intptr_t  env_index, intptr_t  param_index, const Location &  loc, Representation  representation  )

inline

Definition at line 2906 of file il.h.

      : env_index_(env_index),
        param_index_(param_index),
        representation_(representation),
        block_(block),
        location_(loc) {}

Member Function Documentation

ComputeCanDeoptimize()

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

inlinevirtual

Definition at line 2941 of file il.h.

{ return false; }

ComputeType()

CompileType dart::ParameterInstr::ComputeType ( ) const

virtual

Definition at line 1195 of file type_propagator.cc.

                                              {
  // Note that returning the declared type of the formal parameter would be
  // incorrect, because ParameterInstr is used as input to the type check
  // verifying the run time type of the passed-in parameter and this check would
  // always be wrongly eliminated.
  // However there are parameters that are known to match their declared type:
  // for example receiver.
  GraphEntryInstr* graph_entry = block_->AsGraphEntry();
  if (graph_entry == nullptr) {
    if (auto function_entry = block_->AsFunctionEntry()) {
      graph_entry = function_entry->graph_entry();
    } else if (auto osr_entry = block_->AsOsrEntry()) {
      graph_entry = osr_entry->graph_entry();
    } else if (auto catch_entry = block_->AsCatchBlockEntry()) {
      graph_entry = catch_entry->graph_entry();
    } else {
      UNREACHABLE();
    }
  }
  // Parameters at OSR entries have type dynamic.
  //
  // TODO(kmillikin): Use the actual type of the parameter at OSR entry.
  // The code below is not safe for OSR because it doesn't necessarily use
  // the correct scope.
  if (graph_entry->IsCompiledForOsr()) {
    // Parameter at OSR entry may correspond to a late local variable.
    return CompileType::DynamicOrSentinel();
  }
 
  const ParsedFunction& pf = graph_entry->parsed_function();
  const Function& function = pf.function();
  if (function.IsIrregexpFunction()) {
    // In irregexp functions, types of input parameters are known and immutable.
    // Set parameter types here in order to prevent unnecessary CheckClassInstr
    // from being generated.
    switch (env_index()) {
      case RegExpMacroAssembler::kParamRegExpIndex:
        return CompileType::FromCid(kRegExpCid);
      case RegExpMacroAssembler::kParamStringIndex:
        return CompileType::FromCid(function.string_specialization_cid());
      case RegExpMacroAssembler::kParamStartOffsetIndex:
        return CompileType::FromCid(kSmiCid);
      default:
        UNREACHABLE();
    }
    UNREACHABLE();
    return CompileType::Dynamic();
  }
 
  const intptr_t param_index = this->param_index();
  if (param_index >= 0) {
    // Parameter is the receiver.
    if ((param_index == 0) &&
        (function.IsDynamicFunction() || function.IsGenerativeConstructor())) {
      const AbstractType& type = pf.RawParameterVariable(0)->static_type();
      if (type.IsObjectType() || type.IsNullType()) {
        // Receiver can be null.
        return CompileType(CompileType::kCanBeNull,
                           CompileType::kCannotBeSentinel, kIllegalCid, &type);
      }
 
      // Receiver can't be null but can be an instance of a subclass.
      intptr_t cid = kDynamicCid;
 
      if (type.type_class_id() != kIllegalCid) {
        Thread* thread = Thread::Current();
        const Class& type_class = Class::Handle(type.type_class());
        if (!CHA::HasSubclasses(type_class)) {
          if (type_class.IsPrivate()) {
            // Private classes can never be subclassed by later loaded libs.
            cid = type_class.id();
          } else {
            if (FLAG_use_cha_deopt ||
                thread->isolate_group()->all_classes_finalized()) {
              if (FLAG_trace_cha) {
                THR_Print(
                    "  **(CHA) Computing exact type of receiver, "
                    "no subclasses: %s\n",
                    type_class.ToCString());
              }
              if (FLAG_use_cha_deopt) {
                thread->compiler_state()
                    .cha()
                    .AddToGuardedClassesForSubclassCount(type_class,
                                                         /*subclass_count=*/0);
              }
              cid = type_class.id();
            }
          }
        }
      }
 
      return CompileType(CompileType::kCannotBeNull,
                         CompileType::kCannotBeSentinel, cid, &type);
    }
 
    const bool is_unchecked_entry_param =
        graph_entry->unchecked_entry() == block_;
 
    const LocalVariable* param = (pf.scope() != nullptr)
                                     ? pf.ParameterVariable(param_index)
                                     : pf.RawParameterVariable(param_index);
    ASSERT(param != nullptr);
 
    CompileType* inferred_type = nullptr;
    intptr_t inferred_cid = kDynamicCid;
    bool inferred_nullable = true;
    if (!block_->IsCatchBlockEntry()) {
      inferred_type = param->inferred_arg_type();
 
      if (inferred_type != nullptr) {
        // Use inferred type if it is an int.
        if (inferred_type->IsNullableInt()) {
          TraceStrongModeType(this, inferred_type);
          return *inferred_type;
        }
        // Otherwise use inferred cid and nullability.
        inferred_cid = inferred_type->ToNullableCid();
        inferred_nullable = inferred_type->is_nullable();
      }
    }
    // If parameter type was checked by caller, then use Dart type annotation,
    // plus non-nullability from inferred type if known.
    // Do not trust static parameter type of 'operator ==' as it is a
    // non-nullable Object but VM handles comparison with null in
    // the callee, so 'operator ==' can take null as an argument.
    if ((function.name() != Symbols::EqualOperator().ptr()) &&
        (param->was_type_checked_by_caller() ||
         (is_unchecked_entry_param &&
          !param->is_explicit_covariant_parameter()))) {
      const AbstractType& static_type = param->static_type();
      CompileType result(
          inferred_nullable && !static_type.IsStrictlyNonNullable(),
          block_->IsCatchBlockEntry() && param->is_late(),
          inferred_cid == kDynamicCid ? kIllegalCid : inferred_cid,
          &static_type);
      TraceStrongModeType(this, &result);
      return result;
    }
    // Last resort: use inferred type as is.
    if (inferred_type != nullptr) {
      TraceStrongModeType(this, inferred_type);
      return *inferred_type;
    }
  }
 
  if (block_->IsCatchBlockEntry()) {
    // Parameter of a catch block may correspond to a late local variable.
    return CompileType::DynamicOrSentinel();
  }
 
  return CompileType::Dynamic();
}

DECLARE_ATTRIBUTES_NAMED()

dart::ParameterInstr::DECLARE_ATTRIBUTES_NAMED ( ("index", "location")  , (index(), location())    ) const

inline

Definition at line 2918 of file il.h.

                             { return env_index_; }

DISALLOW_COPY_AND_ASSIGN()

dart::ParameterInstr::DISALLOW_COPY_AND_ASSIGN

(

ParameterInstr

)

GetBlock()

virtual BlockEntryInstr * dart::ParameterInstr::GetBlock ( )

inlinevirtual

Definition at line 2931 of file il.h.

{ return block_; }

Hash()

virtual uword dart::ParameterInstr::Hash ( ) const

inlinevirtual

Definition at line 2945 of file il.h.

                             {
    UNREACHABLE();
    return 0;
  }

HasUnknownSideEffects()

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

inlinevirtual

Definition at line 2943 of file il.h.

{ return false; }

index()

intptr_t dart::ParameterInstr::index ( ) const

inline

Definition at line 2922 of file il.h.

{ return env_index(); }

location()

const Location & dart::ParameterInstr::location ( ) const

inline

Definition at line 2928 of file il.h.

{ return location_; }

param_index()

intptr_t dart::ParameterInstr::param_index ( ) const

inline

Definition at line 2926 of file il.h.

{ return param_index_; }

representation()

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

inlinevirtual

Definition at line 2934 of file il.h.

{ return representation_; }

RequiredInputRepresentation()

virtual Representation dart::ParameterInstr::RequiredInputRepresentation ( intptr_t  index ) const

inlinevirtual

Definition at line 2936 of file il.h.

                                                                           {
    UNREACHABLE();
    return kTagged;
  }

set_block()

void dart::ParameterInstr::set_block ( BlockEntryInstr *  block )

inline

Definition at line 2932 of file il.h.

{ block_ = block; }

Member Data Documentation

kNotFunctionParameter

constexpr intptr_t dart::ParameterInstr::kNotFunctionParameter = -1

staticconstexpr

Definition at line 2904 of file il.h.

location_

DECLARE_INSTRUCTION_SERIALIZABLE_FIELDS (ParameterInstr, TemplateDefinition, FIELD_LIST) DECLARE_EXTRA_SERIALIZATION private Location dart::ParameterInstr::location_

Definition at line 2967 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/type_propagator.cc