dart::FlowGraphAllocator Class Reference

#include <linearscan.h>

Inheritance diagram for dart::FlowGraphAllocator:

Public Member Functions
	FlowGraphAllocator (const FlowGraph &flow_graph, bool intrinsic_mode=false)
void	AllocateRegisters ()
LiveRange *	GetLiveRange (intptr_t vreg)
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Static Public Member Functions
static DART_FORCE_INLINE void	SetLifetimePosition (Instruction *instr, intptr_t pos)
static DART_FORCE_INLINE bool	HasLifetimePosition (Instruction *instr)
static DART_FORCE_INLINE intptr_t	GetLifetimePosition (const Instruction *instr)

Static Public Attributes
static constexpr intptr_t	kDoubleSpillFactor

Detailed Description

Definition at line 55 of file linearscan.h.

Constructor & Destructor Documentation

FlowGraphAllocator()

dart::FlowGraphAllocator::FlowGraphAllocator ( const FlowGraph &  flow_graph, bool  intrinsic_mode = false  )

explicit

Definition at line 88 of file linearscan.cc.

    : flow_graph_(flow_graph),
      reaching_defs_(flow_graph),
      value_representations_(flow_graph.max_vreg()),
      block_order_(BlockOrderForAllocation(flow_graph)),
      postorder_(flow_graph.postorder()),
      instructions_(),
      block_entries_(),
      extra_loop_info_(),
      liveness_(flow_graph),
      vreg_count_(flow_graph.max_vreg()),
      live_ranges_(flow_graph.max_vreg()),
      unallocated_cpu_(),
      unallocated_fpu_(),
      cpu_regs_(),
      fpu_regs_(),
      blocked_cpu_registers_(),
      blocked_fpu_registers_(),
      spilled_(),
      safepoints_(),
      register_kind_(),
      number_of_registers_(0),
      registers_(),
      blocked_registers_(),
      unallocated_(),
      spill_slots_(),
      quad_spill_slots_(),
      untagged_spill_slots_(),
      cpu_spill_slot_count_(0),
      intrinsic_mode_(intrinsic_mode) {
  for (intptr_t i = 0; i < vreg_count_; i++) {
    live_ranges_.Add(nullptr);
  }
  for (intptr_t i = 0; i < vreg_count_; i++) {
    value_representations_.Add(kNoRepresentation);
  }
 
  // All registers are marked as "not blocked" (array initialized to false).
  // Mark the unavailable ones as "blocked" (true).
  for (intptr_t i = 0; i < kNumberOfCpuRegisters; i++) {
    if ((kDartAvailableCpuRegs & (1 << i)) == 0) {
      blocked_cpu_registers_[i] = true;
    }
  }
 
  // FpuTMP is used as scratch by optimized code and parallel move resolver.
  blocked_fpu_registers_[FpuTMP] = true;
 
  // Block additional registers needed preserved when generating intrinsics.
  // TODO(fschneider): Handle saving and restoring these registers when
  // generating intrinsic code.
  if (intrinsic_mode) {
    blocked_cpu_registers_[ARGS_DESC_REG] = true;
 
#if !defined(TARGET_ARCH_IA32)
    // Need to preserve CODE_REG to be able to store the PC marker
    // and load the pool pointer.
    blocked_cpu_registers_[CODE_REG] = true;
#endif
  }
}

Member Function Documentation

AllocateRegisters()

void dart::FlowGraphAllocator::AllocateRegisters

(

)

Definition at line 3441 of file linearscan.cc.

                                           {
  CollectRepresentations();
 
  liveness_.Analyze();
 
  NumberInstructions();
 
  // Reserve spill slot for :suspend_state synthetic variable before
  // reserving spill slots for parameter variables.
  AllocateSpillSlotForSuspendState();
 
  BuildLiveRanges();
 
  // Update stackmaps after all safepoints are collected.
  UpdateStackmapsForSuspendState();
 
  if (FLAG_print_ssa_liveranges && CompilerState::ShouldTrace()) {
    const Function& function = flow_graph_.function();
    THR_Print("-- [before ssa allocator] ranges [%s] ---------\n",
              function.ToFullyQualifiedCString());
    PrintLiveRanges();
    THR_Print("----------------------------------------------\n");
 
    THR_Print("-- [before ssa allocator] ir [%s] -------------\n",
              function.ToFullyQualifiedCString());
    if (FLAG_support_il_printer) {
#ifndef PRODUCT
      FlowGraphPrinter printer(flow_graph_, true);
      printer.PrintBlocks();
#endif
    }
    THR_Print("----------------------------------------------\n");
  }
 
  PrepareForAllocation(Location::kRegister, kNumberOfCpuRegisters,
                       unallocated_cpu_, cpu_regs_, blocked_cpu_registers_);
  AllocateUnallocatedRanges();
  // GraphEntryInstr::fixed_slot_count() stack slots are reserved for catch
  // entries. When allocating a spill slot, AllocateSpillSlotFor() accounts for
  // these reserved slots and allocates spill slots on top of them.
  // However, if there are no spill slots allocated, we still need to reserve
  // slots for catch entries in the spill area.
  cpu_spill_slot_count_ = Utils::Maximum(
      spill_slots_.length(), flow_graph_.graph_entry()->fixed_slot_count());
  spill_slots_.Clear();
  quad_spill_slots_.Clear();
  untagged_spill_slots_.Clear();
 
  PrepareForAllocation(Location::kFpuRegister, kNumberOfFpuRegisters,
                       unallocated_fpu_, fpu_regs_, blocked_fpu_registers_);
  AllocateUnallocatedRanges();
 
  GraphEntryInstr* entry = block_order_[0]->AsGraphEntry();
  ASSERT(entry != nullptr);
  intptr_t double_spill_slot_count = spill_slots_.length() * kDoubleSpillFactor;
  entry->set_spill_slot_count(cpu_spill_slot_count_ + double_spill_slot_count +
                              flow_graph_.max_argument_slot_count());
 
  RemoveFrameIfNotNeeded();
 
  AllocateOutgoingArguments();
 
  ResolveControlFlow();
 
  ScheduleParallelMoves();
 
  if (FLAG_print_ssa_liveranges && CompilerState::ShouldTrace()) {
    const Function& function = flow_graph_.function();
 
    THR_Print("-- [after ssa allocator] ranges [%s] ---------\n",
              function.ToFullyQualifiedCString());
    PrintLiveRanges();
    THR_Print("----------------------------------------------\n");
 
    THR_Print("-- [after ssa allocator] ir [%s] -------------\n",
              function.ToFullyQualifiedCString());
    if (FLAG_support_il_printer) {
#ifndef PRODUCT
      FlowGraphPrinter printer(flow_graph_, true);
      printer.PrintBlocks();
#endif
    }
    THR_Print("----------------------------------------------\n");
  }
}

GetLifetimePosition()

static DART_FORCE_INLINE intptr_t dart::FlowGraphAllocator::GetLifetimePosition ( const Instruction *  instr )

inlinestatic

Definition at line 78 of file linearscan.h.

                                {
    return instr->GetPassSpecificId(CompilerPass::kAllocateRegisters);
  }

GetLiveRange()

LiveRange * dart::FlowGraphAllocator::GetLiveRange

(

intptr_t

vreg

)

Definition at line 431 of file linearscan.cc.

                                                         {
  if (live_ranges_[vreg] == nullptr) {
    Representation rep = value_representations_[vreg];
    ASSERT(rep != kNoRepresentation);
    live_ranges_[vreg] = new LiveRange(vreg, rep);
  }
  return live_ranges_[vreg];
}

HasLifetimePosition()

static DART_FORCE_INLINE bool dart::FlowGraphAllocator::HasLifetimePosition ( Instruction *  instr )

inlinestatic

Definition at line 74 of file linearscan.h.

                                                                        {
    return instr->HasPassSpecificId(CompilerPass::kAllocateRegisters);
  }

SetLifetimePosition()

static DART_FORCE_INLINE void dart::FlowGraphAllocator::SetLifetimePosition ( Instruction *  instr, intptr_t  pos  )

inlinestatic

Definition at line 69 of file linearscan.h.

                                                                  {
    instr->SetPassSpecificId(CompilerPass::kAllocateRegisters, pos);
  }

Member Data Documentation

kDoubleSpillFactor

constexpr intptr_t dart::FlowGraphAllocator::kDoubleSpillFactor

staticconstexpr

Initial value:

=
      kDoubleSize / compiler::target::kWordSize

Definition at line 58 of file linearscan.h.

---

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