dart::StaticTypeExactnessState Class Reference

#include <static_type_exactness_state.h>

Public Member Functions
bool	IsTracking () const
bool	IsUninitialized () const
bool	IsHasExactSuperClass () const
bool	IsHasExactSuperType () const
bool	IsTriviallyExact () const
bool	NeedsFieldGuard () const
bool	IsExactOrUninitialized () const
bool	IsExact () const
const char *	ToCString () const
StaticTypeExactnessState	CollapseSuperTypeExactness () const
int8_t	Encode () const
int8_t	GetTypeArgumentsOffsetInWords () const

Static Public Member Functions
static StaticTypeExactnessState	TriviallyExact (intptr_t type_arguments_offset_in_bytes)
static bool	CanRepresentAsTriviallyExact (intptr_t type_arguments_offset_in_bytes)
static StaticTypeExactnessState	HasExactSuperType ()
static StaticTypeExactnessState	HasExactSuperClass ()
static StaticTypeExactnessState	NotExact ()
static StaticTypeExactnessState	NotTracking ()
static StaticTypeExactnessState	Uninitialized ()
static StaticTypeExactnessState	Compute (const Type &static_type, const Instance &value, bool print_trace=false)
static StaticTypeExactnessState	Decode (int8_t value)

Static Public Attributes
static constexpr int8_t	kUninitialized = 0

Detailed Description

Definition at line 36 of file static_type_exactness_state.h.

Member Function Documentation

CanRepresentAsTriviallyExact()

static bool dart::StaticTypeExactnessState::CanRepresentAsTriviallyExact ( intptr_t  type_arguments_offset_in_bytes )

inlinestatic

Definition at line 56 of file static_type_exactness_state.h.

                                               {
    return Utils::IsInt(8, type_arguments_offset_in_bytes);
  }

CollapseSuperTypeExactness()

StaticTypeExactnessState dart::StaticTypeExactnessState::CollapseSuperTypeExactness ( ) const

inline

Definition at line 119 of file static_type_exactness_state.h.

                                                              {
    return IsHasExactSuperClass() ? HasExactSuperType() : *this;
  }

Compute()

StaticTypeExactnessState dart::StaticTypeExactnessState::Compute ( const Type &  static_type, const Instance &  value, bool  print_trace = false  )

static

Definition at line 12800 of file object.cc.

                        {
  ASSERT(!value.IsNull());  // Should be handled by the caller.
  ASSERT(value.ptr() != Object::sentinel().ptr());
  ASSERT(value.ptr() != Object::transition_sentinel().ptr());
 
  Thread* thread = Thread::Current();
  Zone* const zone = thread->zone();
  const TypeArguments& static_type_args =
      TypeArguments::Handle(zone, static_type.GetInstanceTypeArguments(thread));
 
  TypeArguments& args = TypeArguments::Handle(zone);
 
  ASSERT(static_type.IsFinalized());
  const Class& cls = Class::Handle(zone, value.clazz());
  GrowableArray<const Type*> path(10);
 
  bool is_super_class = true;
  if (!cls.FindInstantiationOf(zone, static_type, &path,
                               /*consider_only_super_classes=*/true)) {
    is_super_class = false;
    bool found_super_interface =
        cls.FindInstantiationOf(zone, static_type, &path);
    ASSERT(found_super_interface);
  }
 
  // Trivial case: field has type G<T0, ..., Tn> and value has type
  // G<U0, ..., Un>. Check if type arguments match.
  if (path.is_empty()) {
    ASSERT(cls.ptr() == static_type.type_class());
    args = value.GetTypeArguments();
    // TODO(dartbug.com/34170) Evaluate if comparing relevant subvectors (that
    // disregards superclass own arguments) improves precision of the
    // tracking.
    if (args.ptr() == static_type_args.ptr()) {
      return TrivialTypeExactnessFor(cls);
    }
 
    if (print_trace) {
      THR_Print("  expected %s got %s type arguments\n",
                SafeTypeArgumentsToCString(static_type_args),
                SafeTypeArgumentsToCString(args));
    }
    return StaticTypeExactnessState::NotExact();
  }
 
  // Value has type C<U0, ..., Un> and field has type G<T0, ..., Tn> and G != C.
  // Compute C<X0, ..., Xn> at G (Xi are free type arguments).
  // Path array contains a chain of immediate supertypes S0 <: S1 <: ... Sn,
  // such that S0 is an immediate supertype of C and Sn is G<...>.
  // Each Si might depend on type parameters of the previous supertype S{i-1}.
  // To compute C<X0, ..., Xn> at G we walk the chain backwards and
  // instantiate Si using type parameters of S{i-1} which gives us a type
  // depending on type parameters of S{i-2}.
  Type& type = Type::Handle(zone, path.Last()->ptr());
  for (intptr_t i = path.length() - 2; (i >= 0) && !type.IsInstantiated();
       i--) {
    args = path[i]->GetInstanceTypeArguments(thread, /*canonicalize=*/false);
    type ^= type.InstantiateFrom(args, TypeArguments::null_type_arguments(),
                                 kAllFree, Heap::kNew);
  }
 
  if (type.IsInstantiated()) {
    // C<X0, ..., Xn> at G is fully instantiated and does not depend on
    // Xi. In this case just check if type arguments match.
    args = type.GetInstanceTypeArguments(thread, /*canonicalize=*/false);
    if (args.Equals(static_type_args)) {
      return is_super_class ? StaticTypeExactnessState::HasExactSuperClass()
                            : StaticTypeExactnessState::HasExactSuperType();
    }
 
    if (print_trace) {
      THR_Print("  expected %s got %s type arguments\n",
                SafeTypeArgumentsToCString(static_type_args),
                SafeTypeArgumentsToCString(args));
    }
 
    return StaticTypeExactnessState::NotExact();
  }
 
  // The most complicated case: C<X0, ..., Xn> at G depends on
  // Xi values. To compare type arguments we would need to instantiate
  // it fully from value's type arguments and compare with <U0, ..., Un>.
  // However this would complicate fast path in the native code. To avoid this
  // complication we would optimize for the trivial case: we check if
  // C<X0, ..., Xn> at G is exactly G<X0, ..., Xn> which means we can simply
  // compare values type arguments (<T0, ..., Tn>) to fields type arguments
  // (<U0, ..., Un>) to establish if field type is exact.
  ASSERT(cls.IsGeneric());
  const intptr_t num_type_params = cls.NumTypeParameters();
  bool trivial_case =
      (num_type_params ==
       Class::Handle(zone, static_type.type_class()).NumTypeParameters()) &&
      (value.GetTypeArguments() == static_type_args.ptr());
  if (!trivial_case && FLAG_trace_field_guards) {
    THR_Print("Not a simple case: %" Pd " vs %" Pd
              " type parameters, %s vs %s type arguments\n",
              num_type_params,
              Class::Handle(zone, static_type.type_class()).NumTypeParameters(),
              SafeTypeArgumentsToCString(
                  TypeArguments::Handle(zone, value.GetTypeArguments())),
              SafeTypeArgumentsToCString(static_type_args));
  }
 
  AbstractType& type_arg = AbstractType::Handle(zone);
  args = type.GetInstanceTypeArguments(thread, /*canonicalize=*/false);
  for (intptr_t i = 0; (i < num_type_params) && trivial_case; i++) {
    type_arg = args.TypeAt(i);
    if (!type_arg.IsTypeParameter() ||
        (TypeParameter::Cast(type_arg).index() != i)) {
      if (FLAG_trace_field_guards) {
        THR_Print("  => encountered %s at index % " Pd "\n",
                  type_arg.ToCString(), i);
      }
      trivial_case = false;
    }
  }
 
  return trivial_case ? TrivialTypeExactnessFor(cls)
                      : StaticTypeExactnessState::NotExact();
}

Decode()

static StaticTypeExactnessState dart::StaticTypeExactnessState::Decode ( int8_t  value )

inlinestatic

Definition at line 123 of file static_type_exactness_state.h.

                                                              {
    return StaticTypeExactnessState(value);
  }

Encode()

int8_t dart::StaticTypeExactnessState::Encode ( ) const

inline

Definition at line 127 of file static_type_exactness_state.h.

{ return value_; }

GetTypeArgumentsOffsetInWords()

int8_t dart::StaticTypeExactnessState::GetTypeArgumentsOffsetInWords ( ) const

inline

Definition at line 128 of file static_type_exactness_state.h.

                                               {
    ASSERT(IsTriviallyExact());
    return value_;
  }

HasExactSuperClass()

static StaticTypeExactnessState dart::StaticTypeExactnessState::HasExactSuperClass ( )

inlinestatic

Definition at line 77 of file static_type_exactness_state.h.

                                                              {
    return StaticTypeExactnessState(kHasExactSuperClass);
  }

HasExactSuperType()

static StaticTypeExactnessState dart::StaticTypeExactnessState::HasExactSuperType ( )

inlinestatic

Definition at line 73 of file static_type_exactness_state.h.

                                                             {
    return StaticTypeExactnessState(kHasExactSuperType);
  }

IsExact()

bool dart::StaticTypeExactnessState::IsExact ( ) const

inline

Definition at line 112 of file static_type_exactness_state.h.

                       {
    return IsTriviallyExact() || IsHasExactSuperType() ||
           IsHasExactSuperClass();
  }

IsExactOrUninitialized()

bool dart::StaticTypeExactnessState::IsExactOrUninitialized ( ) const

inline

Definition at line 111 of file static_type_exactness_state.h.

{ return value_ > kNotExact; }

IsHasExactSuperClass()

bool dart::StaticTypeExactnessState::IsHasExactSuperClass ( ) const

inline

Definition at line 107 of file static_type_exactness_state.h.

{ return value_ == kHasExactSuperClass; }

IsHasExactSuperType()

bool dart::StaticTypeExactnessState::IsHasExactSuperType ( ) const

inline

Definition at line 108 of file static_type_exactness_state.h.

{ return value_ == kHasExactSuperType; }

IsTracking()

bool dart::StaticTypeExactnessState::IsTracking ( ) const

inline

Definition at line 105 of file static_type_exactness_state.h.

{ return value_ != kNotTracking; }

IsTriviallyExact()

bool dart::StaticTypeExactnessState::IsTriviallyExact ( ) const

inline

Definition at line 109 of file static_type_exactness_state.h.

{ return value_ > kUninitialized; }

IsUninitialized()

bool dart::StaticTypeExactnessState::IsUninitialized ( ) const

inline

Definition at line 106 of file static_type_exactness_state.h.

{ return value_ == kUninitialized; }

NeedsFieldGuard()

bool dart::StaticTypeExactnessState::NeedsFieldGuard ( ) const

inline

Definition at line 110 of file static_type_exactness_state.h.

{ return value_ >= kUninitialized; }

NotExact()

static StaticTypeExactnessState dart::StaticTypeExactnessState::NotExact ( )

inlinestatic

Definition at line 88 of file static_type_exactness_state.h.

                                                    {
    return StaticTypeExactnessState(kNotExact);
  }

NotTracking()

static StaticTypeExactnessState dart::StaticTypeExactnessState::NotTracking ( )

inlinestatic

Definition at line 93 of file static_type_exactness_state.h.

                                                       {
    return StaticTypeExactnessState(kNotTracking);
  }

ToCString()

const char * dart::StaticTypeExactnessState::ToCString

(

)

const

Definition at line 12924 of file object.cc.

                                                      {
  if (!IsTracking()) {
    return "not-tracking";
  } else if (!IsExactOrUninitialized()) {
    return "not-exact";
  } else if (IsTriviallyExact()) {
    return Thread::Current()->zone()->PrintToString(
        "trivially-exact(%hhu)", GetTypeArgumentsOffsetInWords());
  } else if (IsHasExactSuperType()) {
    return "has-exact-super-type";
  } else if (IsHasExactSuperClass()) {
    return "has-exact-super-class";
  } else {
    ASSERT(IsUninitialized());
    return "uninitialized-exactness";
  }
}

TriviallyExact()

static StaticTypeExactnessState dart::StaticTypeExactnessState::TriviallyExact ( intptr_t  type_arguments_offset_in_bytes )

inlinestatic

Definition at line 49 of file static_type_exactness_state.h.

                                               {
    ASSERT((type_arguments_offset_in_bytes > 0) &&
           Utils::IsInt(8, type_arguments_offset_in_bytes));
    return StaticTypeExactnessState(type_arguments_offset_in_bytes);
  }

Uninitialized()

static StaticTypeExactnessState dart::StaticTypeExactnessState::Uninitialized ( )

inlinestatic

Definition at line 97 of file static_type_exactness_state.h.

                                                         {
    return StaticTypeExactnessState(kUninitialized);
  }

Member Data Documentation

kUninitialized

constexpr int8_t dart::StaticTypeExactnessState::kUninitialized = 0

staticconstexpr

Definition at line 133 of file static_type_exactness_state.h.

---

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

• third_party/dart-lang/sdk/runtime/vm/static_type_exactness_state.h
• third_party/dart-lang/sdk/runtime/vm/object.cc