dart::TestPipeline Class Reference

#include <il_test_helper.h>

Inheritance diagram for dart::TestPipeline:

Public Member Functions
	TestPipeline (const Function &function, CompilerPass::PipelineMode mode, bool is_optimizing=true)
	~TestPipeline ()
	TestPipeline (CompilerPass::PipelineMode mode, std::function< FlowGraph *()> fn)
FlowGraph *	RunPasses (std::initializer_list< CompilerPass::Id > passes)
void	RunAdditionalPasses (std::initializer_list< CompilerPass::Id > passes)
void	RunForcedOptimizedAfterSSAPasses ()
void	CompileGraphAndAttachFunction ()
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Detailed Description

Definition at line 73 of file il_test_helper.h.

Constructor & Destructor Documentation

TestPipeline() [1/2]

dart::TestPipeline::TestPipeline ( const Function &  function, CompilerPass::PipelineMode  mode, bool  is_optimizing = true  )

inline

Definition at line 75 of file il_test_helper.h.

      : thread_(Thread::Current()),
        compiler_state_(thread_,
                        mode == CompilerPass::PipelineMode::kAOT,
                        is_optimizing,
                        CompilerState::ShouldTrace(function)),
        hierarchy_info_(thread_),
        speculative_policy_(std::unique_ptr<SpeculativeInliningPolicy>(
            new SpeculativeInliningPolicy(/*enable_suppresson=*/false))),
        mode_(mode),
        flow_graph_(nullptr),
        function_(function),
        parsed_function_(nullptr) {}

~TestPipeline()

dart::TestPipeline::~TestPipeline ( )

inline

Definition at line 90 of file il_test_helper.h.

{ delete pass_state_; }

TestPipeline() [2/2]

dart::TestPipeline::TestPipeline ( CompilerPass::PipelineMode  mode, std::function< FlowGraph *()>  fn  )

inline

Definition at line 92 of file il_test_helper.h.

      : thread_(Thread::Current()),
        compiler_state_(thread_,
                        mode == CompilerPass::PipelineMode::kAOT,
                        /*is_optimizing=*/true,
                        CompilerTracing::kOff),
        hierarchy_info_(thread_),
        speculative_policy_(std::unique_ptr<SpeculativeInliningPolicy>(
            new SpeculativeInliningPolicy(/*enable_suppresson=*/false))),
        mode_(mode),
        flow_graph_(fn()),
        function_(flow_graph_->function()),
        parsed_function_(
            const_cast<ParsedFunction*>(&flow_graph_->parsed_function())) {}

Member Function Documentation

CompileGraphAndAttachFunction()

void dart::TestPipeline::CompileGraphAndAttachFunction

(

)

Definition at line 218 of file il_test_helper.cc.

                                                 {
  Zone* zone = thread_->zone();
  const bool optimized = true;
 
  SpeculativeInliningPolicy speculative_policy(/*enable_suppression=*/false);
 
#if defined(TARGET_ARCH_X64) || defined(TARGET_ARCH_IA32)
  const intptr_t far_branch_level = 0;
#else
  const intptr_t far_branch_level = 1;
#endif
 
  ASSERT(pass_state_->inline_id_to_function.length() ==
         pass_state_->caller_inline_id.length());
  compiler::ObjectPoolBuilder object_pool_builder;
  compiler::Assembler assembler(&object_pool_builder, far_branch_level);
  FlowGraphCompiler graph_compiler(
      &assembler, flow_graph_, *parsed_function_, optimized,
      &speculative_policy, pass_state_->inline_id_to_function,
      pass_state_->inline_id_to_token_pos, pass_state_->caller_inline_id,
      ic_data_array_);
 
  graph_compiler.CompileGraph();
 
  const auto& deopt_info_array =
      Array::Handle(zone, graph_compiler.CreateDeoptInfo(&assembler));
  const auto pool_attachment = Code::PoolAttachment::kAttachPool;
  Code& code = Code::Handle();
  {
    SafepointWriteRwLocker ml(thread_,
                              thread_->isolate_group()->program_lock());
    code ^= Code::FinalizeCode(&graph_compiler, &assembler, pool_attachment,
                               optimized, nullptr);
  }
  code.set_is_optimized(optimized);
  code.set_owner(function_);
 
  graph_compiler.FinalizePcDescriptors(code);
  code.set_deopt_info_array(deopt_info_array);
 
  graph_compiler.FinalizeStackMaps(code);
  graph_compiler.FinalizeVarDescriptors(code);
  graph_compiler.FinalizeExceptionHandlers(code);
  graph_compiler.FinalizeCatchEntryMovesMap(code);
  graph_compiler.FinalizeStaticCallTargetsTable(code);
  graph_compiler.FinalizeCodeSourceMap(code);
 
  {
    SafepointWriteRwLocker ml(thread_,
                              thread_->isolate_group()->program_lock());
    if (optimized) {
      function_.InstallOptimizedCode(code);
    } else {
      function_.set_unoptimized_code(code);
      function_.AttachCode(code);
    }
  }
 
  // We expect there to be no deoptimizations.
  if (mode_ == CompilerPass::kAOT) {
    EXPECT(deopt_info_array.IsNull() || deopt_info_array.Length() == 0);
  }
 
#if !defined(PRODUCT)
  if (FLAG_disassemble_optimized) {
    Disassembler::DisassembleCode(function_, code, optimized);
  }
#endif
}

RunAdditionalPasses()

void dart::TestPipeline::RunAdditionalPasses

(

std::initializer_list< CompilerPass::Id >

passes

)

Definition at line 178 of file il_test_helper.cc.

                                                {
  JitCallSpecializer jit_call_specializer(flow_graph_,
                                          speculative_policy_.get());
  AotCallSpecializer aot_call_specializer(/*precompiler=*/nullptr, flow_graph_,
                                          speculative_policy_.get());
  if (mode_ == CompilerPass::kAOT) {
    pass_state_->call_specializer = &aot_call_specializer;
  } else {
    pass_state_->call_specializer = &jit_call_specializer;
  }
 
  flow_graph_ = CompilerPass::RunPipelineWithPasses(pass_state_, passes);
  pass_state_->call_specializer = nullptr;
}

RunForcedOptimizedAfterSSAPasses()

void dart::TestPipeline::RunForcedOptimizedAfterSSAPasses

(

)

Definition at line 194 of file il_test_helper.cc.

                                                    {
  RunAdditionalPasses({
      CompilerPass::kSetOuterInliningId,
      CompilerPass::kTypePropagation,
      CompilerPass::kCanonicalize,
      CompilerPass::kBranchSimplify,
      CompilerPass::kIfConvert,
      CompilerPass::kConstantPropagation,
      CompilerPass::kTypePropagation,
      CompilerPass::kSelectRepresentations_Final,
      CompilerPass::kTypePropagation,
      CompilerPass::kTryCatchOptimization,
      CompilerPass::kEliminateEnvironments,
      CompilerPass::kEliminateDeadPhis,
      CompilerPass::kDCE,
      CompilerPass::kCanonicalize,
      CompilerPass::kDelayAllocations,
      CompilerPass::kEliminateWriteBarriers,
      CompilerPass::kFinalizeGraph,
      CompilerPass::kAllocateRegisters,
      CompilerPass::kReorderBlocks,
  });
}

RunPasses()

FlowGraph * dart::TestPipeline::RunPasses

(

std::initializer_list< CompilerPass::Id >

passes

)

Definition at line 116 of file il_test_helper.cc.

                                                {
  auto thread = Thread::Current();
  auto zone = thread->zone();
  const bool optimized = true;
  const intptr_t osr_id = Compiler::kNoOSRDeoptId;
 
  // We assume that prebuilt graph is already in SSA form so we should
  // avoid running ComputeSSA on it (it will just crash).
  const bool is_ssa = (flow_graph_ != nullptr);
  if (flow_graph_ == nullptr) {
    auto pipeline = CompilationPipeline::New(zone, function_);
 
    parsed_function_ = new (zone)
        ParsedFunction(thread, Function::ZoneHandle(zone, function_.ptr()));
    pipeline->ParseFunction(parsed_function_);
 
    // Extract type feedback before the graph is built, as the graph
    // builder uses it to attach it to nodes.
    ic_data_array_ = new (zone) ZoneGrowableArray<const ICData*>();
    if (mode_ == CompilerPass::kJIT) {
      function_.RestoreICDataMap(ic_data_array_, /*clone_ic_data=*/false);
    }
 
    flow_graph_ = pipeline->BuildFlowGraph(zone, parsed_function_,
                                           ic_data_array_, osr_id, optimized);
  }
 
  if (mode_ == CompilerPass::kAOT) {
    flow_graph_->PopulateWithICData(function_);
  }
 
  if (mode_ == CompilerPass::kJIT && flow_graph_->should_reorder_blocks()) {
    BlockScheduler::AssignEdgeWeights(flow_graph_);
  }
 
  pass_state_ =
      new CompilerPassState(thread, flow_graph_, speculative_policy_.get());
 
  if (optimized) {
    JitCallSpecializer jit_call_specializer(flow_graph_,
                                            speculative_policy_.get());
    AotCallSpecializer aot_call_specializer(
        /*precompiler=*/nullptr, flow_graph_, speculative_policy_.get());
    if (mode_ == CompilerPass::kAOT) {
      pass_state_->call_specializer = &aot_call_specializer;
    } else {
      pass_state_->call_specializer = &jit_call_specializer;
    }
 
    if (passes.size() > 0) {
      flow_graph_ = CompilerPass::RunPipelineWithPasses(pass_state_, passes);
    } else {
      flow_graph_ = CompilerPass::RunPipeline(mode_, pass_state_,
                                              /*compute_ssa=*/!is_ssa);
    }
    pass_state_->call_specializer = nullptr;
  }
 
  return flow_graph_;
}

---

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

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