dart::AllocationSinking Class Reference

#include <redundancy_elimination.h>

Inheritance diagram for dart::AllocationSinking:

Public Member Functions
	AllocationSinking (FlowGraph *flow_graph)
const GrowableArray< Definition * > &	candidates () const
MaterializeObjectInstr *	MaterializationFor (Definition *alloc, Instruction *exit)
void	Optimize ()
void	DetachMaterializations ()
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)

Detailed Description

Definition at line 19 of file redundancy_elimination.h.

Constructor & Destructor Documentation

AllocationSinking()

dart::AllocationSinking::AllocationSinking ( FlowGraph *  flow_graph )

inlineexplicit

Definition at line 21 of file redundancy_elimination.h.

      : flow_graph_(flow_graph), candidates_(5), materializations_(5) {}

Member Function Documentation

candidates()

const GrowableArray< Definition * > & dart::AllocationSinking::candidates ( ) const

inline

Definition at line 24 of file redundancy_elimination.h.

{ return candidates_; }

DetachMaterializations()

void dart::AllocationSinking::DetachMaterializations

(

)

Definition at line 3767 of file redundancy_elimination.cc.

                                               {
  for (MaterializeObjectInstr* mat : materializations_) {
    mat->previous()->LinkTo(mat->next());
    mat->set_next(nullptr);
    mat->set_previous(nullptr);
  }
}

MaterializationFor()

MaterializeObjectInstr * dart::AllocationSinking::MaterializationFor	(	Definition *	alloc,
		Instruction *	exit
	)

Definition at line 3803 of file redundancy_elimination.cc.

                       {
  if (exit->IsMaterializeObject()) {
    exit = ExitForMaterialization(exit->AsMaterializeObject());
  }
 
  for (MaterializeObjectInstr* mat = exit->previous()->AsMaterializeObject();
       mat != nullptr; mat = mat->previous()->AsMaterializeObject()) {
    if (mat->allocation() == alloc) {
      return mat;
    }
  }
 
  return nullptr;
}

Optimize()

void dart::AllocationSinking::Optimize

(

)

Definition at line 3689 of file redundancy_elimination.cc.

                                 {
  // Allocation sinking depends on load forwarding, so give up early if load
  // forwarding is disabled.
  if (!FLAG_load_cse || flow_graph_->is_huge_method()) {
    return;
  }
 
  CollectCandidates();
 
  // Insert MaterializeObject instructions that will describe the state of the
  // object at all deoptimization points. Each inserted materialization looks
  // like this (where v_0 is allocation that we are going to eliminate):
  //   v_1     <- LoadField(v_0, field_1)
  //           ...
  //   v_N     <- LoadField(v_0, field_N)
  //   v_{N+1} <- MaterializeObject(field_1 = v_1, ..., field_N = v_N)
  //
  // For typed data objects materialization looks like this:
  //   v_1     <- LoadIndexed(v_0, index_1)
  //           ...
  //   v_N     <- LoadIndexed(v_0, index_N)
  //   v_{N+1} <- MaterializeObject([index_1] = v_1, ..., [index_N] = v_N)
  //
  // For arrays materialization looks like this:
  //   v_1     <- LoadIndexed(v_0, index_1)
  //           ...
  //   v_N     <- LoadIndexed(v_0, index_N)
  //   v_{N+1} <- LoadField(v_0, Array.type_arguments)
  //   v_{N+2} <- MaterializeObject([index_1] = v_1, ..., [index_N] = v_N,
  //                                type_arguments = v_{N+1})
  //
  for (intptr_t i = 0; i < candidates_.length(); i++) {
    InsertMaterializations(candidates_[i]);
  }
 
  // Run load forwarding to eliminate LoadField/LoadIndexed instructions
  // inserted above.
  //
  // All loads will be successfully eliminated because:
  //   a) they use fields/constant indices and thus provide precise aliasing
  //      information
  //   b) candidate does not escape and thus its fields/elements are not
  //      affected by external effects from calls.
  LoadOptimizer::OptimizeGraph(flow_graph_);
 
  NormalizeMaterializations();
 
  RemoveUnusedMaterializations();
 
  // If any candidates are no longer eligible for allocation sinking abort
  // the optimization for them and undo any changes we did in preparation.
  DiscoverFailedCandidates();
 
  // At this point we have computed the state of object at each deoptimization
  // point and we can eliminate it. Loads inserted above were forwarded so there
  // are no uses of the allocation outside other candidates to eliminate, just
  // as in the beginning of the pass.
  for (intptr_t i = 0; i < candidates_.length(); i++) {
    EliminateAllocation(candidates_[i]);
  }
 
  // Process materializations and unbox their arguments: materializations
  // are part of the environment and can materialize boxes for double/mint/simd
  // values when needed.
  // TODO(vegorov): handle all box types here.
  for (intptr_t i = 0; i < materializations_.length(); i++) {
    MaterializeObjectInstr* mat = materializations_[i];
    for (intptr_t j = 0; j < mat->InputCount(); j++) {
      Definition* defn = mat->InputAt(j)->definition();
      if (defn->IsBox()) {
        mat->InputAt(j)->BindTo(defn->InputAt(0)->definition());
      }
    }
  }
}

---

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

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