dart::SSALivenessAnalysis Class Reference

#include <linearscan.h>

Inheritance diagram for dart::SSALivenessAnalysis:

Public Member Functions
	SSALivenessAnalysis (const FlowGraph &flow_graph)
Public Member Functions inherited from dart::LivenessAnalysis
	LivenessAnalysis (intptr_t variable_count, const GrowableArray< BlockEntryInstr * > &postorder)
void	Analyze ()
virtual	~LivenessAnalysis ()
BitVector *	GetLiveInSetAt (intptr_t postorder_number) const
BitVector *	GetLiveOutSetAt (intptr_t postorder_number) const
BitVector *	GetLiveInSet (BlockEntryInstr *block) const
BitVector *	GetKillSet (BlockEntryInstr *block) const
BitVector *	GetLiveOutSet (BlockEntryInstr *block) const
void	Dump ()
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Private Member Functions
virtual void	ComputeInitialSets ()

Additional Inherited Members
Protected Member Functions inherited from dart::LivenessAnalysis
virtual void	ComputeInitialSets ()=0
bool	UpdateLiveOut (const BlockEntryInstr &instr)
bool	UpdateLiveIn (const BlockEntryInstr &instr)
void	ComputeLiveInAndLiveOutSets ()
Zone *	zone () const
Protected Attributes inherited from dart::LivenessAnalysis
Zone *	zone_
const intptr_t	variable_count_
const GrowableArray< BlockEntryInstr * > &	postorder_
GrowableArray< BitVector * >	live_out_
GrowableArray< BitVector * >	kill_
GrowableArray< BitVector * >	live_in_

Detailed Description

Definition at line 39 of file linearscan.h.

Constructor & Destructor Documentation

SSALivenessAnalysis()

dart::SSALivenessAnalysis::SSALivenessAnalysis ( const FlowGraph &  flow_graph )

inlineexplicit

Definition at line 41 of file linearscan.h.

      : LivenessAnalysis(flow_graph.max_vreg(), flow_graph.postorder()),
        graph_entry_(flow_graph.graph_entry()) {}

Member Function Documentation

ComputeInitialSets()

void dart::SSALivenessAnalysis::ComputeInitialSets ( )

privatevirtual

Implements dart::LivenessAnalysis.

Definition at line 171 of file linearscan.cc.

                                             {
  const intptr_t block_count = postorder_.length();
  for (intptr_t i = 0; i < block_count; i++) {
    BlockEntryInstr* block = postorder_[i];
 
    BitVector* kill = kill_[i];
    BitVector* live_in = live_in_[i];
 
    // Iterate backwards starting at the last instruction.
    for (BackwardInstructionIterator it(block); !it.Done(); it.Advance()) {
      Instruction* current = it.Current();
 
      // Initialize location summary for instruction.
      current->InitializeLocationSummary(zone(), true);  // opt
 
      LocationSummary* locs = current->locs();
#if defined(DEBUG)
      locs->DiscoverWritableInputs();
#endif
 
      // Handle definitions.
      Definition* current_def = current->AsDefinition();
      if ((current_def != nullptr) && current_def->HasSSATemp()) {
        kill->Add(current_def->vreg(0));
        live_in->Remove(current_def->vreg(0));
        if (current_def->HasPairRepresentation()) {
          kill->Add(current_def->vreg(1));
          live_in->Remove(current_def->vreg(1));
        }
      }
 
      // Handle uses.
      ASSERT(locs->input_count() == current->InputCount());
      for (intptr_t j = 0; j < current->InputCount(); j++) {
        Value* input = current->InputAt(j);
 
        ASSERT(!locs->in(j).IsConstant() || input->BindsToConstant());
        if (locs->in(j).IsConstant()) continue;
 
        live_in->Add(input->definition()->vreg(0));
        if (input->definition()->HasPairRepresentation()) {
          live_in->Add(input->definition()->vreg(1));
        }
      }
 
      // Process detached MoveArguments interpreting them as
      // fixed register inputs.
      if (current->ArgumentCount() != 0) {
        auto move_arguments = current->GetMoveArguments();
        for (auto move : *move_arguments) {
          if (move->is_register_move()) {
            auto input = move->value();
 
            live_in->Add(input->definition()->vreg(0));
            if (input->definition()->HasPairRepresentation()) {
              live_in->Add(input->definition()->vreg(1));
            }
          }
        }
      }
 
      // Add non-argument uses from the deoptimization environment (pushed
      // arguments are not allocated by the register allocator).
      if (current->env() != nullptr) {
        for (Environment::DeepIterator env_it(current->env()); !env_it.Done();
             env_it.Advance()) {
          Definition* defn = env_it.CurrentValue()->definition();
          if (defn->IsMaterializeObject()) {
            // MaterializeObject instruction is not in the graph.
            // Treat its inputs as part of the environment.
            DeepLiveness(defn->AsMaterializeObject(), live_in);
          } else if (!defn->IsMoveArgument() && !defn->IsConstant()) {
            live_in->Add(defn->vreg(0));
            if (defn->HasPairRepresentation()) {
              live_in->Add(defn->vreg(1));
            }
          }
        }
      }
    }
 
    // Handle phis.
    if (block->IsJoinEntry()) {
      JoinEntryInstr* join = block->AsJoinEntry();
      for (PhiIterator it(join); !it.Done(); it.Advance()) {
        PhiInstr* phi = it.Current();
        ASSERT(phi != nullptr);
        kill->Add(phi->vreg(0));
        live_in->Remove(phi->vreg(0));
        if (phi->HasPairRepresentation()) {
          kill->Add(phi->vreg(1));
          live_in->Remove(phi->vreg(1));
        }
 
        // If a phi input is not defined by the corresponding predecessor it
        // must be marked live-in for that predecessor.
        for (intptr_t k = 0; k < phi->InputCount(); k++) {
          Value* val = phi->InputAt(k);
          if (val->BindsToConstant()) continue;
 
          BlockEntryInstr* pred = block->PredecessorAt(k);
          const intptr_t use = val->definition()->vreg(0);
          if (!kill_[pred->postorder_number()]->Contains(use)) {
            live_in_[pred->postorder_number()]->Add(use);
          }
          if (phi->HasPairRepresentation()) {
            const intptr_t second_use = val->definition()->vreg(1);
            if (!kill_[pred->postorder_number()]->Contains(second_use)) {
              live_in_[pred->postorder_number()]->Add(second_use);
            }
          }
        }
      }
    } else if (auto entry = block->AsBlockEntryWithInitialDefs()) {
      // Initialize location summary for instruction if needed.
      if (entry->IsCatchBlockEntry()) {
        entry->InitializeLocationSummary(zone(), true);  // opt
      }
 
      // Process initial definitions, i.e. parameters and special parameters.
      for (intptr_t i = 0; i < entry->initial_definitions()->length(); i++) {
        Definition* def = (*entry->initial_definitions())[i];
        const intptr_t vreg = def->vreg(0);
        kill_[entry->postorder_number()]->Add(vreg);
        live_in_[entry->postorder_number()]->Remove(vreg);
        if (def->HasPairRepresentation()) {
          kill_[entry->postorder_number()]->Add(def->vreg(1));
          live_in_[entry->postorder_number()]->Remove(def->vreg(1));
        }
      }
    }
  }
}

---

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

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