// Return false if bailed out.
static bool CompileParsedFunctionHelper(const ParsedFunction& parsed_function,
                                        bool optimized) {

  bool is_compiled = false;
  Isolate* isolate = Isolate::Current();

FlowGraph* flow_graph = NULL;
if (optimized) {
  ASSERT(parsed_function.function().HasCode());
  FlowGraphPrinter::Printf("path optimized\n");
  // Extract type feedback before the graph is built, as the graph
  // builder uses it to attach it to nodes.
  // Do not use type feedback to optimize a function that was
  // deoptimized too often.
  if (parsed_function.function().deoptimization_counter() <
      FLAG_deoptimization_counter_threshold) {
    const Code& unoptimized_code =
          Code::Handle(parsed_function.function().unoptimized_code());
    isolate->set_ic_data_array(
          unoptimized_code.ExtractTypeFeedbackArray());
  }
}

// Build the flow graph.
FlowGraphBuilder builder(parsed_function);
flow_graph = builder.BuildGraph(FlowGraphBuilder::kNotInlining,
                                0);  // The initial loop depth is zero.

if (optimized) {                                // 最適化オプション
  // Transform to SSA (virtual register 0 and no inlining arguments).
  flow_graph->ComputeSSA(0, NULL);              // definevalueのnumberを振りなおす。Phiの生成。
}

if (optimized) {
  flow_graph->ComputeUseLists();                // def-useチェインの再計算。

  FlowGraphOptimizer optimizer(flow_graph);
  optimizer.ApplyICData();                      // 全IRをvisitorで走査して、型付けと高速な中間表現への置換を行う。

  // Compute the use lists.
  flow_graph->ComputeUseLists();                // def-useチェインの再計算。

// Inlining (mutates the flow graph)
if (FLAG_use_inlining) {
  FlowGraphInliner inliner(flow_graph);
  inliner.Inline();
  // Use lists are maintained and validated by the inliner.
}

  // Propagate types and eliminate more type tests.
  if (FLAG_propagate_types) {
    FlowGraphTypePropagator propagator(flow_graph);
    propagator.PropagateTypes();  // 型情報を後方に伝搬します。
  }

  // Propagate sminess from CheckSmi to phis.
  optimizer.PropagateSminess();   // 型情報を元に、不要なCheckSmiを畳み込みます。

  // Use propagated class-ids to optimize further.
  optimizer.ApplyClassIds();      // 型情報を元に、InstanceCallを高速なcallに置き換えます。

  // Do optimizations that depend on the propagated type information.
  // TODO(srdjan): Should this be called CanonicalizeComputations?
  optimizer.OptimizeComputations(); // 型情報を元に、命令の融合と高速な中間表現への置換を行います。

  // Unbox doubles.
  flow_graph->ComputeUseLists();
  optimizer.SelectRepresentations();  // 型情報を元に、Guardの挿入とUnboxing(DoubleとMintとSmi)を行います。

  if (FLAG_constant_propagation ||
      FLAG_common_subexpression_elimination) {
    flow_graph->ComputeUseLists();    // def-useリストを再計算
  }
  if (FLAG_constant_propagation) {
    ConstantPropagator::Optimize(flow_graph);
    // A canonicalization pass to remove e.g. smi checks on smi constants.
    optimizer.OptimizeComputations(); // 定数伝搬を行います。
  }
  if (FLAG_common_subexpression_elimination) {
    if (DominatorBasedCSE::Optimize(flow_graph)) { // GVN1回目です。共通な中間表現を畳み込みます。
      // Do another round of CSE to take secondary effects into account:
      // e.g. when eliminating dependent loads (a.x[0] + a.x[0])
      // TODO(fschneider): Change to a one-pass optimization pass.
      DominatorBasedCSE::Optimize(flow_graph);  // GVN2回目です。
    }
  }
  if (FLAG_loop_invariant_code_motion &&
      (parsed_function.function().deoptimization_counter() <
       (FLAG_deoptimization_counter_threshold - 1))) {
    LICM::Optimize(flow_graph);       // ループ不変式の移動を行います。
  }

  if (FLAG_range_analysis) {
    // We have to perform range analysis after LICM because it
    // optimistically moves CheckSmi through phis into loop preheaders
    // making some phis smi.
    flow_graph->ComputeUseLists();    // def-useリストを再計算
    optimizer.InferSmiRanges();       // 値のレンジ解析を行います。
  }

  // Perform register allocation on the SSA graph.
  FlowGraphAllocator allocator(*flow_graph);
  allocator.AllocateRegisters();      // 各中間表現のin,outルールを参照し、LinearScanレジスタ割付を行います。
}

Assembler assembler;
FlowGraphCompiler graph_compiler(&assembler,
                                 *flow_graph,
                                 optimized);
{
  graph_compiler.CompileGraph(); //機種依存のCompileGraphを呼び出します。
}

{
  const Function& function = parsed_function.function();
  const Code& code = Code::Handle(
      Code::FinalizeCode(function, &assembler, optimized)); // アセンブルして、Code領域に書き込みます。
  code.set_is_optimized(optimized);
  graph_compiler.FinalizePcDescriptors(code);
  graph_compiler.FinalizeDeoptInfo(code);
  graph_compiler.FinalizeStackmaps(code);
  graph_compiler.FinalizeVarDescriptors(code);
  graph_compiler.FinalizeExceptionHandlers(code);
  graph_compiler.FinalizeComments(code);
  graph_compiler.FinalizeStaticCallTargetsTable(code);
  if (optimized) {                                  // JITコンパイルしたコードを設定します。
    CodePatcher::PatchEntry(Code::Handle(function.CurrentCode()));
    function.SetCode(code);
  } else {
    function.set_unoptimized_code(code);
    function.SetCode(code);
  }
}