dart::CallTargets Class Reference

#include <il.h>

Inheritance diagram for dart::CallTargets:

Public Member Functions
	CallTargets (Zone *zone)
TargetInfo *	TargetAt (int i) const
intptr_t	AggregateCallCount () const
StaticTypeExactnessState	MonomorphicExactness () const
bool	HasSingleTarget () const
bool	HasSingleRecognizedTarget () const
const Function &	FirstTarget () const
const Function &	MostPopularTarget () const
void	Print () const
bool	ReceiverIs (intptr_t cid) const
bool	ReceiverIsSmiOrMint () const
void	Write (FlowGraphSerializer *s) const
	CallTargets (FlowGraphDeserializer *d)
Public Member Functions inherited from dart::Cids
	Cids (Zone *zone)
bool	Equals (const Cids &other) const
bool	HasClassId (intptr_t cid) const
void	Add (CidRange *target)
CidRange &	operator[] (intptr_t index) const
CidRange *	At (int index) const
intptr_t	length () const
void	SetLength (intptr_t len)
bool	is_empty () const
void	Sort (int compare(CidRange *const *a, CidRange *const *b))
bool	IsMonomorphic () const
intptr_t	MonomorphicReceiverCid () const
intptr_t	ComputeLowestCid () const
intptr_t	ComputeHighestCid () const
Public Member Functions inherited from dart::ZoneAllocated
	ZoneAllocated ()
void *	operator new (size_t size)
void *	operator new (size_t size, Zone *zone)
void	operator delete (void *pointer)

Static Public Member Functions
static const CallTargets *	CreateMonomorphic (Zone *zone, intptr_t receiver_cid, const Function &target)
static const CallTargets *	Create (Zone *zone, const ICData &ic_data)
static const CallTargets *	CreateAndExpand (Zone *zone, const ICData &ic_data)
Static Public Member Functions inherited from dart::Cids
static Cids *	CreateForArgument (Zone *zone, const BinaryFeedback &binary_feedback, int argument_number)
static Cids *	CreateMonomorphic (Zone *zone, intptr_t cid)

Additional Inherited Members
Protected Attributes inherited from dart::Cids
GrowableArray< CidRange * >	cid_ranges_

Detailed Description

Definition at line 780 of file il.h.

Constructor & Destructor Documentation

CallTargets() [1/2]

dart::CallTargets::CallTargets ( Zone *  zone )

inlineexplicit

Definition at line 782 of file il.h.

: Cids(zone) {}

CallTargets() [2/2]

dart::CallTargets::CallTargets ( FlowGraphDeserializer *  d )

explicit

Definition at line 305 of file il_serializer.cc.

                                                 : Cids(d->zone()) {
  const intptr_t len = d->Read<intptr_t>();
  cid_ranges_.EnsureLength(len, nullptr);
  for (intptr_t i = 0; i < len; ++i) {
    const intptr_t cid_start = d->Read<intptr_t>();
    const intptr_t cid_end = d->Read<intptr_t>();
    const Function& target = d->Read<const Function&>();
    const intptr_t count = d->Read<intptr_t>();
    const StaticTypeExactnessState exactness =
        StaticTypeExactnessState::Decode(d->Read<int8_t>());
    TargetInfo* t = new (d->zone())
        TargetInfo(cid_start, cid_end, &target, count, exactness);
    cid_ranges_[i] = t;
  }
}

Member Function Documentation

AggregateCallCount()

intptr_t dart::CallTargets::AggregateCallCount

(

)

const

Definition at line 5528 of file il.cc.

                                               {
  intptr_t sum = 0;
  for (int i = 0; i < length(); i++) {
    sum += TargetAt(i)->count;
  }
  return sum;
}

Create()

const CallTargets * dart::CallTargets::Create ( Zone *  zone, const ICData &  ic_data  )

static

Definition at line 4129 of file il.cc.

                                                                        {
  CallTargets* targets = new (zone) CallTargets(zone);
  targets->CreateHelper(zone, ic_data);
  targets->Sort(OrderById);
  targets->MergeIntoRanges();
  return targets;
}

CreateAndExpand()

const CallTargets * dart::CallTargets::CreateAndExpand ( Zone *  zone, const ICData &  ic_data  )

static

Definition at line 4137 of file il.cc.

                                                                       {
  CallTargets& targets = *new (zone) CallTargets(zone);
  targets.CreateHelper(zone, ic_data);
 
  if (targets.is_empty() || targets.IsMonomorphic()) {
    return &targets;
  }
 
  targets.Sort(OrderById);
 
  Array& args_desc_array = Array::Handle(zone, ic_data.arguments_descriptor());
  ArgumentsDescriptor args_desc(args_desc_array);
  String& name = String::Handle(zone, ic_data.target_name());
 
  Function& fn = Function::Handle(zone);
 
  intptr_t length = targets.length();
 
  // Merging/extending cid ranges is also done in Cids::CreateAndExpand.
  // If changing this code, consider also adjusting Cids code.
 
  // Spread class-ids to preceding classes where a lookup yields the same
  // method.  A polymorphic target is not really the same method since its
  // behaviour depends on the receiver class-id, so we don't spread the
  // class-ids in that case.
  for (int idx = 0; idx < length; idx++) {
    int lower_limit_cid = (idx == 0) ? -1 : targets[idx - 1].cid_end;
    auto target_info = targets.TargetAt(idx);
    const Function& target = *target_info->target;
    if (target.is_polymorphic_target()) continue;
    for (int i = target_info->cid_start - 1; i > lower_limit_cid; i--) {
      bool class_is_abstract = false;
      if (FlowGraphCompiler::LookupMethodFor(i, name, args_desc, &fn,
                                             &class_is_abstract) &&
          fn.ptr() == target.ptr()) {
        if (!class_is_abstract) {
          target_info->cid_start = i;
          target_info->exactness = StaticTypeExactnessState::NotTracking();
        }
      } else {
        break;
      }
    }
  }
 
  // Spread class-ids to following classes where a lookup yields the same
  // method.
  const intptr_t max_cid = IsolateGroup::Current()->class_table()->NumCids();
  for (int idx = 0; idx < length; idx++) {
    int upper_limit_cid =
        (idx == length - 1) ? max_cid : targets[idx + 1].cid_start;
    auto target_info = targets.TargetAt(idx);
    const Function& target = *target_info->target;
    if (target.is_polymorphic_target()) continue;
    // The code below makes attempt to avoid spreading class-id range
    // into a suffix that consists purely of abstract classes to
    // shorten the range.
    // However such spreading is beneficial when it allows to
    // merge to consecutive ranges.
    intptr_t cid_end_including_abstract = target_info->cid_end;
    for (int i = target_info->cid_end + 1; i < upper_limit_cid; i++) {
      bool class_is_abstract = false;
      if (FlowGraphCompiler::LookupMethodFor(i, name, args_desc, &fn,
                                             &class_is_abstract) &&
          fn.ptr() == target.ptr()) {
        cid_end_including_abstract = i;
        if (!class_is_abstract) {
          target_info->cid_end = i;
          target_info->exactness = StaticTypeExactnessState::NotTracking();
        }
      } else {
        break;
      }
    }
 
    // Check if we have a suffix that consists of abstract classes
    // and expand into it if that would allow us to merge this
    // range with subsequent range.
    if ((cid_end_including_abstract > target_info->cid_end) &&
        (idx < length - 1) &&
        ((cid_end_including_abstract + 1) == targets[idx + 1].cid_start) &&
        (target.ptr() == targets.TargetAt(idx + 1)->target->ptr())) {
      target_info->cid_end = cid_end_including_abstract;
      target_info->exactness = StaticTypeExactnessState::NotTracking();
    }
  }
  targets.MergeIntoRanges();
  return &targets;
}

CreateMonomorphic()

const CallTargets * dart::CallTargets::CreateMonomorphic ( Zone *  zone, intptr_t  receiver_cid, const Function &  target  )

static

Definition at line 4118 of file il.cc.

                                                                          {
  CallTargets* targets = new (zone) CallTargets(zone);
  const intptr_t count = 1;
  targets->cid_ranges_.Add(new (zone) TargetInfo(
      receiver_cid, receiver_cid, &Function::ZoneHandle(zone, target.ptr()),
      count, StaticTypeExactnessState::NotTracking()));
  return targets;
}

FirstTarget()

const Function & dart::CallTargets::FirstTarget

(

)

const

Definition at line 5513 of file il.cc.

                                               {
  ASSERT(length() != 0);
  DEBUG_ASSERT(TargetAt(0)->target->IsNotTemporaryScopedHandle());
  return *TargetAt(0)->target;
}

HasSingleRecognizedTarget()

bool dart::CallTargets::HasSingleRecognizedTarget

(

)

const

Definition at line 5500 of file il.cc.

                                                  {
  if (!HasSingleTarget()) return false;
  return FirstTarget().recognized_kind() != MethodRecognizer::kUnknown;
}

HasSingleTarget()

bool dart::CallTargets::HasSingleTarget

(

)

const

Definition at line 5505 of file il.cc.

                                        {
  if (length() == 0) return false;
  for (int i = 0; i < length(); i++) {
    if (TargetAt(i)->target->ptr() != TargetAt(0)->target->ptr()) return false;
  }
  return true;
}

MonomorphicExactness()

StaticTypeExactnessState dart::CallTargets::MonomorphicExactness

(

)

const

Definition at line 811 of file il.cc.

                                                                 {
  ASSERT(IsMonomorphic());
  return TargetAt(0)->exactness;
}

MostPopularTarget()

const Function & dart::CallTargets::MostPopularTarget

(

)

const

Definition at line 5519 of file il.cc.

                                                     {
  ASSERT(length() != 0);
  DEBUG_ASSERT(TargetAt(0)->target->IsNotTemporaryScopedHandle());
  for (int i = 1; i < length(); i++) {
    ASSERT(TargetAt(i)->count <= TargetAt(0)->count);
  }
  return *TargetAt(0)->target;
}

Print()

void dart::CallTargets::Print

(

)

const

Definition at line 4258 of file il.cc.

                              {
  for (intptr_t i = 0; i < length(); i++) {
    THR_Print("cid = [%" Pd ", %" Pd "], count = %" Pd ", target = %s\n",
              TargetAt(i)->cid_start, TargetAt(i)->cid_end, TargetAt(i)->count,
              TargetAt(i)->target->ToQualifiedCString());
  }
}

ReceiverIs()

bool dart::CallTargets::ReceiverIs ( intptr_t  cid ) const

inline

Definition at line 808 of file il.h.

                                      {
    return IsMonomorphic() && MonomorphicReceiverCid() == cid;
  }

ReceiverIsSmiOrMint()

bool dart::CallTargets::ReceiverIsSmiOrMint ( ) const

inline

Definition at line 811 of file il.h.

                                   {
    if (cid_ranges_.is_empty()) {
      return false;
    }
    for (intptr_t i = 0, n = cid_ranges_.length(); i < n; i++) {
      for (intptr_t j = cid_ranges_[i]->cid_start; j <= cid_ranges_[i]->cid_end;
           j++) {
        if (j != kSmiCid && j != kMintCid) {
          return false;
        }
      }
    }
    return true;
  }

TargetAt()

TargetInfo * dart::CallTargets::TargetAt ( int  i ) const

inline

Definition at line 796 of file il.h.

{ return static_cast<TargetInfo*>(At(i)); }

Write()

void dart::CallTargets::Write

(

FlowGraphSerializer *

s

)

const

Definition at line 292 of file il_serializer.cc.

                                                    {
  const intptr_t len = cid_ranges_.length();
  s->Write<intptr_t>(len);
  for (intptr_t i = 0; i < len; ++i) {
    TargetInfo* t = TargetAt(i);
    s->Write<intptr_t>(t->cid_start);
    s->Write<intptr_t>(t->cid_end);
    s->Write<const Function&>(*(t->target));
    s->Write<intptr_t>(t->count);
    s->Write<int8_t>(t->exactness.Encode());
  }
}

---

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