FlowGraphCompiler is not a visitor any longer. Start consolidating shared code between the x64 and …

runtime/vm/flow_graph_compiler_x64.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 14 matching lines @@
 
 DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
 DEFINE_FLAG(bool, trace_functions, false, "Trace entry of each function.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, intrinsify);
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, print_ast);
 DECLARE_FLAG(bool, report_usage_count);
 DECLARE_FLAG(bool, code_comments);
 
-class DeoptimizationStub : public ZoneAllocated {
- public:
-  DeoptimizationStub(intptr_t deopt_id,
-                     intptr_t deopt_token_index,
-                     intptr_t try_index,
-                     DeoptReasonId reason)
-      : deopt_id_(deopt_id),
-        deopt_token_index_(deopt_token_index),
-        try_index_(try_index),
-        reason_(reason),
-        registers_(2),
-        entry_label_() {}
 
-  void Push(Register reg) { registers_.Add(reg); }
-  Label* entry_label() { return &entry_label_; }
-
-  void GenerateCode(FlowGraphCompiler* compiler);
-
- private:
-  const intptr_t deopt_id_;
-  const intptr_t deopt_token_index_;
-  const intptr_t try_index_;
-  const DeoptReasonId reason_;
-  GrowableArray<Register> registers_;
-  Label entry_label_;
-
-  DISALLOW_COPY_AND_ASSIGN(DeoptimizationStub);
-};
-
-
-void DeoptimizationStub::GenerateCode(FlowGraphCompiler* compiler) {
+void DeoptimizationStub::GenerateCode(FlowGraphCompilerShared* compiler) {
   Assembler* assem = compiler->assembler();
 #define __ assem->
   __ Comment("Deopt stub for id %d", deopt_id_);
   __ Bind(entry_label());
   for (intptr_t i = 0; i < registers_.length(); i++) {
     if (registers_[i] != kNoRegister) {
       __ pushq(registers_[i]);
     }
   }
   __ movq(RAX, Immediate(Smi::RawValue(reason_)));
   __ call(&StubCode::DeoptimizeLabel());
   compiler->AddCurrentDescriptor(PcDescriptors::kOther,
                                  deopt_id_,
                                  deopt_token_index_,
                                  try_index_);
 #undef __
 }
 
 
 FlowGraphCompiler::FlowGraphCompiler(
     Assembler* assembler,
     const ParsedFunction& parsed_function,
     const GrowableArray<BlockEntryInstr*>& block_order,
     bool is_optimizing)
-    : FlowGraphVisitor(block_order),
-      assembler_(assembler),
-      parsed_function_(parsed_function),
-      block_info_(block_order.length()),
-      current_block_(NULL),
-      pc_descriptors_list_(NULL),
-      stackmap_builder_(NULL),
-      exception_handlers_list_(NULL),
-      deopt_stubs_(),
-      is_optimizing_(is_optimizing) {
-}
-
-
-void FlowGraphCompiler::InitCompiler() {
-  pc_descriptors_list_ = new DescriptorList();
-  exception_handlers_list_ = new ExceptionHandlerList();
-  block_info_.Clear();
-  for (int i = 0; i < block_order_.length(); ++i) {
-    block_info_.Add(new BlockInfo());
-  }
-}
-
-
-FlowGraphCompiler::~FlowGraphCompiler() {
-  // BlockInfos are zone-allocated, so their destructors are not called.
-  // Verify the labels explicitly here.
-  for (int i = 0; i < block_info_.length(); ++i) {
-    ASSERT(!block_info_[i]->label.IsLinked());
-    ASSERT(!block_info_[i]->label.HasNear());
-  }
-}
-
-
-intptr_t FlowGraphCompiler::StackSize() const {
-  return parsed_function_.stack_local_count() +
-      parsed_function_.copied_parameter_count();
-}
+    : FlowGraphCompilerShared(assembler,
+                              parsed_function,
+                              block_order,
+                              is_optimizing) {}
 
 
 void FlowGraphCompiler::Bailout(const char* reason) {
   const char* kFormat = "FlowGraphCompiler Bailout: %s %s.";
-  const char* function_name = parsed_function_.function().ToCString();
+  const char* function_name = parsed_function().function().ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
-#define __ assembler_->
+#define __ assembler()->
 
 
 // Jumps to labels 'is_instance' or 'is_not_instance' respectively, if
 // type test is conclusive, otherwise fallthrough if a type test could not
 // be completed.
 // RAX: instance (must survive),
 RawSubtypeTestCache*
 FlowGraphCompiler::GenerateInstantiatedTypeWithArgumentsTest(
     intptr_t cid,
     intptr_t token_index,
@@ skipping 462 matching lines @@
     } else {
       __ LoadObject(dst, value->AsConstant()->value());
     }
   } else {
     ASSERT(value->IsUse());
     __ popq(dst);
   }
 }
 
 
-void FlowGraphCompiler::VisitUse(UseVal* val) {
-  // UseVal is never visited during code generation.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitConstant(ConstantVal* val) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitAssertAssignable(AssertAssignableComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitAssertBoolean(AssertBooleanComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
 void FlowGraphCompiler::EmitInstanceCall(intptr_t cid,
                                          intptr_t token_index,
                                          intptr_t try_index,
                                          const String& function_name,
                                          intptr_t argument_count,
                                          const Array& argument_names,
                                          intptr_t checked_argument_count) {
   ICData& ic_data =
-      ICData::ZoneHandle(ICData::New(parsed_function_.function(),
+      ICData::ZoneHandle(ICData::New(parsed_function().function(),
                                      function_name,
                                      cid,
                                      checked_argument_count));
   const Array& arguments_descriptor =
       CodeGenerator::ArgumentsDescriptor(argument_count, argument_names);
   __ LoadObject(RBX, ic_data);
   __ LoadObject(R10, arguments_descriptor);
 
   uword label_address = 0;
   switch (checked_argument_count) {
@@ skipping 24 matching lines @@
   __ LoadObject(R10, arguments_descriptor);
 
   GenerateCall(token_index,
                try_index,
                &StubCode::CallStaticFunctionLabel(),
                PcDescriptors::kFuncCall);
   __ Drop(argument_count);
 }
 
 
-void FlowGraphCompiler::VisitCurrentContext(CurrentContextComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitStoreContext(StoreContextComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitClosureCall(ClosureCallComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitInstanceCall(InstanceCallComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitStrictCompare(StrictCompareComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitEqualityCompare(EqualityCompareComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitStaticCall(StaticCallComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitLoadLocal(LoadLocalComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitStoreLocal(StoreLocalComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitNativeCall(NativeCallComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitLoadInstanceField(LoadInstanceFieldComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitStoreInstanceField(StoreInstanceFieldComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-
-void FlowGraphCompiler::VisitLoadStaticField(LoadStaticFieldComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitStoreStaticField(StoreStaticFieldComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitStoreIndexed(StoreIndexedComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitInstanceSetter(InstanceSetterComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitStaticSetter(StaticSetterComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitBooleanNegate(BooleanNegateComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
 // Optimize instanceof type test by adding inlined tests for:
 // - NULL -> return false.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - RAX: object.
 // - RDX: instantiator type arguments or raw_null.
 // - RCX: instantiator or raw_null.
 // Destroys RCX and RDX.
 // Returns:
@@ skipping 64 matching lines @@
   __ jmp(&done, Assembler::kNearJump);
 
   __ Bind(&is_instance);
   __ LoadObject(RAX, negate_result ? bool_false : bool_true);
   __ Bind(&done);
   __ popq(RDX);  // Remove pushed instantiator type arguments..
   __ popq(RCX);  // Remove pushed instantiator.
 }
 
 
-void FlowGraphCompiler::VisitInstanceOf(InstanceOfComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitAllocateObject(AllocateObjectComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitAllocateObjectWithBoundsCheck(
-    AllocateObjectWithBoundsCheckComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitCreateArray(CreateArrayComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitCreateClosure(CreateClosureComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitLoadVMField(LoadVMFieldComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitStoreVMField(StoreVMFieldComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitInstantiateTypeArguments(
-    InstantiateTypeArgumentsComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitExtractConstructorTypeArguments(
-    ExtractConstructorTypeArgumentsComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitExtractConstructorInstantiator(
-    ExtractConstructorInstantiatorComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitAllocateContext(AllocateContextComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitChainContext(ChainContextComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitCloneContext(CloneContextComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitCatchEntry(CatchEntryComp* comp) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitBinaryOp(BinaryOpComp* comp) {
-  UNIMPLEMENTED();
-}
-
-
-void FlowGraphCompiler::VisitUnarySmiOp(UnarySmiOpComp* comp) {
-  UNIMPLEMENTED();
-}
-
-
-void FlowGraphCompiler::VisitNumberNegate(NumberNegateComp* comp) {
-  UNIMPLEMENTED();
-}
-
-
 void FlowGraphCompiler::EmitInstructionPrologue(Instruction* instr) {
   LocationSummary* locs = instr->locs();
   ASSERT(locs != NULL);
 
   locs->AllocateRegisters();
 
   // Load instruction inputs into allocated registers.
   for (intptr_t i = locs->input_count() - 1; i >= 0; i--) {
     Location loc = locs->in(i);
     ASSERT(loc.kind() == Location::kRegister);
     __ popq(loc.reg());
   }
 }
 
 
 void FlowGraphCompiler::VisitBlocks() {
-  for (intptr_t i = 0; i < block_order_.length(); ++i) {
+  for (intptr_t i = 0; i < block_order().length(); ++i) {
     __ Comment("B%d", i);
     // Compile the block entry.
-    current_block_ = block_order_[i];
-    Instruction* instr = current_block()->Accept(this);
+    set_current_block(block_order()[i]);
+    current_block()->PrepareEntry(this);
+    Instruction* instr = current_block()->StraightLineSuccessor();
     // Compile all successors until an exit, branch, or a block entry.
     while ((instr != NULL) && !instr->IsBlockEntry()) {
       if (FLAG_code_comments) EmitComment(instr);
-      if (instr->locs() != NULL) {
-        EmitInstructionPrologue(instr);
-        instr->EmitNativeCode(this);
-        instr = instr->StraightLineSuccessor();
-      } else {
-        instr = instr->Accept(this);
-      }
+      ASSERT(instr->locs() != NULL);
+      EmitInstructionPrologue(instr);
+      instr->EmitNativeCode(this);
+      instr = instr->StraightLineSuccessor();
     }
 
     BlockEntryInstr* successor =
         (instr == NULL) ? NULL : instr->AsBlockEntry();
     if (successor != NULL) {
       // Block ended with a "goto".  We can fall through if it is the
       // next block in the list.  Otherwise, we need a jump.
-      if ((i == block_order_.length() - 1) ||
-          (block_order_[i + 1] != successor)) {
-        __ jmp(&block_info_[successor->postorder_number()]->label);
+      if ((i == block_order().length() - 1) ||
+          (block_order()[i + 1] != successor)) {
+        __ jmp(GetBlockLabel(successor));
       }
     }
   }
 }
 
 
 void FlowGraphCompiler::EmitComment(Instruction* instr) {
   char buffer[80];
   BufferFormatter f(buffer, sizeof(buffer));
   instr->PrintTo(&f);
   __ Comment("@%d: %s", instr->cid(), buffer);
 }
 
 
-void FlowGraphCompiler::VisitGraphEntry(GraphEntryInstr* instr) {
-  // Nothing to do.
-}
-
-
-void FlowGraphCompiler::VisitJoinEntry(JoinEntryInstr* instr) {
-  __ Bind(&block_info_[instr->postorder_number()]->label);
-}
-
-
-void FlowGraphCompiler::VisitTargetEntry(TargetEntryInstr* instr) {
-  __ Bind(&block_info_[instr->postorder_number()]->label);
-  if (instr->HasTryIndex()) {
-    exception_handlers_list_->AddHandler(instr->try_index(),
-                                         assembler_->CodeSize());
-  }
-}
-
-
-void FlowGraphCompiler::VisitDo(DoInstr* instr) {
-  instr->computation()->Accept(this);
-}
-
-
-void FlowGraphCompiler::VisitBind(BindInstr* instr) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitReturn(ReturnInstr* instr) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitThrow(ThrowInstr* instr) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-void FlowGraphCompiler::VisitReThrow(ReThrowInstr* instr) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
-
-void FlowGraphCompiler::VisitBranch(BranchInstr* instr) {
-  // Moved to intermediate_language_x64.cc.
-  UNREACHABLE();
-}
-
-
 // Copied from CodeGenerator::CopyParameters (CodeGenerator will be deprecated).
 void FlowGraphCompiler::CopyParameters() {
-  const Function& function = parsed_function_.function();
-  LocalScope* scope = parsed_function_.node_sequence()->scope();
+  const Function& function = parsed_function().function();
+  LocalScope* scope = parsed_function().node_sequence()->scope();
   const int num_fixed_params = function.num_fixed_parameters();
   const int num_opt_params = function.num_optional_parameters();
-  ASSERT(parsed_function_.first_parameter_index() ==
+  ASSERT(parsed_function().first_parameter_index() ==
          ParsedFunction::kFirstLocalSlotIndex);
   // Copy positional arguments.
   // Check that no fewer than num_fixed_params positional arguments are passed
   // in and that no more than num_params arguments are passed in.
   // Passed argument i at fp[1 + argc - i]
   // copied to fp[ParsedFunction::kFirstLocalSlotIndex - i].
   const int num_params = num_fixed_params + num_opt_params;
 
   // Total number of args is the first Smi in args descriptor array (R10).
   __ movq(RBX, FieldAddress(R10, Array::data_offset()));
@@ skipping 80 matching lines @@
     // fp[1 + argc - arg_pos].
     __ movq(RAX, Address(RDI, kWordSize));  // RAX is arg_pos as Smi.
     __ addq(RDI, Immediate(2 * kWordSize));  // Point to next name/pos pair.
     __ negq(RAX);
     Address argument_addr(RBX, RAX, TIMES_4, 0);  // RAX is a negative Smi.
     __ movq(RAX, argument_addr);
     __ jmp(&assign_optional_parameter, Assembler::kNearJump);
     __ Bind(&load_default_value);
     // Load RAX with default argument at pos.
     const Object& value = Object::ZoneHandle(
-        parsed_function_.default_parameter_values().At(
+        parsed_function().default_parameter_values().At(
             param_pos - num_fixed_params));
     __ LoadObject(RAX, value);
     __ Bind(&assign_optional_parameter);
     // Assign RAX to fp[ParsedFunction::kFirstLocalSlotIndex - param_pos].
     // We do not use the final allocation index of the variable here, i.e.
     // scope->VariableAt(i)->index(), because captured variables still need
     // to be copied to the context that is not yet allocated.
     const Address param_addr(
         RBP, (ParsedFunction::kFirstLocalSlotIndex - param_pos) * kWordSize);
     __ movq(param_addr, RAX);
@@ skipping 79 matching lines @@
       !FLAG_report_usage_count &&
       (FLAG_optimization_counter_threshold >= 0) &&
       !Isolate::Current()->debugger()->IsActive();
 }
 
 
 void FlowGraphCompiler::IntrinsifyGetter() {
   // TOS: return address.
   // +1 : receiver.
   // Sequence node has one return node, its input is load field node.
-  const SequenceNode& sequence_node = *parsed_function_.node_sequence();
+  const SequenceNode& sequence_node = *parsed_function().node_sequence();
   ASSERT(sequence_node.length() == 1);
   ASSERT(sequence_node.NodeAt(0)->IsReturnNode());
   const ReturnNode& return_node = *sequence_node.NodeAt(0)->AsReturnNode();
   ASSERT(return_node.value()->IsLoadInstanceFieldNode());
   const LoadInstanceFieldNode& load_node =
       *return_node.value()->AsLoadInstanceFieldNode();
   __ movq(RAX, Address(RSP, 1 * kWordSize));
   __ movq(RAX, FieldAddress(RAX, load_node.field().Offset()));
   __ ret();
 }
 
 
 void FlowGraphCompiler::IntrinsifySetter() {
   // TOS: return address.
   // +1 : value
   // +2 : receiver.
   // Sequence node has one store node and one return NULL node.
-  const SequenceNode& sequence_node = *parsed_function_.node_sequence();
+  const SequenceNode& sequence_node = *parsed_function().node_sequence();
   ASSERT(sequence_node.length() == 2);
   ASSERT(sequence_node.NodeAt(0)->IsStoreInstanceFieldNode());
   ASSERT(sequence_node.NodeAt(1)->IsReturnNode());
   const StoreInstanceFieldNode& store_node =
       *sequence_node.NodeAt(0)->AsStoreInstanceFieldNode();
   __ movq(RAX, Address(RSP, 2 * kWordSize));  // Receiver.
   __ movq(RBX, Address(RSP, 1 * kWordSize));  // Value.
   __ StoreIntoObject(RAX, FieldAddress(RAX, store_node.field().Offset()), RBX);
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   __ movq(RAX, raw_null);
   __ ret();
 }
 
 
 // Returns 'true' if code generation for this function is complete, i.e.,
 // no fall-through to regular code is needed.
 bool FlowGraphCompiler::TryIntrinsify() {
   if (!CanOptimize()) return false;
   // Intrinsification skips arguments checks, therefore disable if in checked
   // mode.
   if (FLAG_intrinsify && !FLAG_trace_functions && !FLAG_enable_type_checks) {
-    if ((parsed_function_.function().kind() == RawFunction::kImplicitGetter)) {
+    if ((parsed_function().function().kind() == RawFunction::kImplicitGetter)) {
       IntrinsifyGetter();
       return true;
     }
-    if ((parsed_function_.function().kind() == RawFunction::kImplicitSetter)) {
+    if ((parsed_function().function().kind() == RawFunction::kImplicitSetter)) {
       IntrinsifySetter();
       return true;
     }
   }
   // Even if an intrinsified version of the function was successfully
   // generated, it may fall through to the non-intrinsified method body.
   if (!FLAG_trace_functions) {
-    return Intrinsifier::Intrinsify(parsed_function_.function(), assembler_);
+    return Intrinsifier::Intrinsify(parsed_function().function(), assembler());
   }
   return false;
 }
 
 
 void FlowGraphCompiler::CompileGraph() {
   InitCompiler();
   if (TryIntrinsify()) {
     // Make it patchable: code must have a minimum code size, nop(2) increases
     // the minimum code size appropriately.
     __ nop(2);
     __ int3();
     __ jmp(&StubCode::FixCallersTargetLabel());
     return;
   }
   // Specialized version of entry code from CodeGenerator::GenerateEntryCode.
-  const Function& function = parsed_function_.function();
+  const Function& function = parsed_function().function();
 
   const int parameter_count = function.num_fixed_parameters();
-  const int num_copied_params = parsed_function_.copied_parameter_count();
-  const int local_count = parsed_function_.stack_local_count();
-  AssemblerMacros::EnterDartFrame(assembler_, (StackSize() * kWordSize));
+  const int num_copied_params = parsed_function().copied_parameter_count();
+  const int local_count = parsed_function().stack_local_count();
+  AssemblerMacros::EnterDartFrame(assembler(), (StackSize() * kWordSize));
 
   // We check the number of passed arguments when we have to copy them due to
   // the presence of optional named parameters.
   // No such checking code is generated if only fixed parameters are declared,
   // unless we are debug mode or unless we are compiling a closure.
   if (num_copied_params == 0) {
 #ifdef DEBUG
     const bool check_arguments = true;
 #else
     const bool check_arguments = function.IsClosureFunction();
@@ skipping 15 matching lines @@
       }
       __ Bind(&argc_in_range);
     }
   } else {
     CopyParameters();
   }
 
   // Initialize locals to null.
   if (local_count > 0) {
     __ movq(RAX, Immediate(reinterpret_cast<intptr_t>(Object::null())));
-    const int base = parsed_function_.first_stack_local_index();
+    const int base = parsed_function().first_stack_local_index();
     for (int i = 0; i < local_count; ++i) {
       // Subtract index i (locals lie at lower addresses than RBP).
       __ movq(Address(RBP, (base - i) * kWordSize), RAX);
     }
   }
 
   // Generate stack overflow check.
   __ movq(TMP, Immediate(Isolate::Current()->stack_limit_address()));
   __ cmpq(RSP, Address(TMP, 0));
   Label no_stack_overflow;
   __ j(ABOVE, &no_stack_overflow, Assembler::kNearJump);
   GenerateCallRuntime(AstNode::kNoId,
                       function.token_index(),
                       CatchClauseNode::kInvalidTryIndex,
                       kStackOverflowRuntimeEntry);
   __ Bind(&no_stack_overflow);
 
   if (FLAG_print_scopes) {
     // Print the function scope (again) after generating the prologue in order
     // to see annotations such as allocation indices of locals.
     if (FLAG_print_ast) {
       // Second printing.
       OS::Print("Annotated ");
     }
-    AstPrinter::PrintFunctionScope(parsed_function_);
+    AstPrinter::PrintFunctionScope(parsed_function());
   }
 
   VisitBlocks();
 
   __ int3();
   GenerateDeferredCode();
   // Emit function patching code. This will be swapped with the first 13 bytes
   // at entry point.
-  pc_descriptors_list_->AddDescriptor(PcDescriptors::kPatchCode,
-                                      assembler_->CodeSize(),
-                                      AstNode::kNoId,
-                                      0,
-                                      -1);
+  pc_descriptors_list()->AddDescriptor(PcDescriptors::kPatchCode,
+                                       assembler()->CodeSize(),
+                                       AstNode::kNoId,
+                                       0,
+                                       -1);
   __ jmp(&StubCode::FixCallersTargetLabel());
 }
 
 
-void FlowGraphCompiler::GenerateDeferredCode() {
-  for (intptr_t i = 0; i < deopt_stubs_.length(); i++) {
-    deopt_stubs_[i]->GenerateCode(this);
-  }
-}
-
-
 // Infrastructure copied from class CodeGenerator.
 void FlowGraphCompiler::GenerateCall(intptr_t token_index,
                                      intptr_t try_index,
                                      const ExternalLabel* label,
                                      PcDescriptors::Kind kind) {
   __ call(label);
   AddCurrentDescriptor(kind, AstNode::kNoId, token_index, try_index);
 }
 
 
 void FlowGraphCompiler::GenerateCallRuntime(intptr_t cid,
                                             intptr_t token_index,
                                             intptr_t try_index,
                                             const RuntimeEntry& entry) {
   __ CallRuntime(entry);
   AddCurrentDescriptor(PcDescriptors::kOther, cid, token_index, try_index);
 }
 
 
-// Uses current pc position and try-index.
-void FlowGraphCompiler::AddCurrentDescriptor(PcDescriptors::Kind kind,
-                                             intptr_t cid,
-                                             intptr_t token_index,
-                                             intptr_t try_index) {
-  pc_descriptors_list_->AddDescriptor(kind,
-                                      assembler_->CodeSize(),
-                                      cid,
-                                      token_index,
-                                      try_index);
-}
-
-
-Label* FlowGraphCompiler::AddDeoptStub(intptr_t deopt_id,
-                                       intptr_t deopt_token_index,
-                                       intptr_t try_index,
-                                       DeoptReasonId reason,
-                                       Register reg1,
-                                       Register reg2) {
-  DeoptimizationStub* stub =
-      new DeoptimizationStub(deopt_id, deopt_token_index, try_index, reason);
-  stub->Push(reg1);
-  stub->Push(reg2);
-  deopt_stubs_.Add(stub);
-  return stub->entry_label();
-}
-
-
-void FlowGraphCompiler::FinalizePcDescriptors(const Code& code) {
-  ASSERT(pc_descriptors_list_ != NULL);
-  const PcDescriptors& descriptors = PcDescriptors::Handle(
-      pc_descriptors_list_->FinalizePcDescriptors(code.EntryPoint()));
-  descriptors.Verify(parsed_function_.function().is_optimizable());
-  code.set_pc_descriptors(descriptors);
-}
-
-
-void FlowGraphCompiler::FinalizeStackmaps(const Code& code) {
-  if (stackmap_builder_ == NULL) {
-    // The unoptimizing compiler has no stack maps.
-    code.set_stackmaps(Array::Handle());
-  } else {
-    // Finalize the stack map array and add it to the code object.
-    code.set_stackmaps(
-        Array::Handle(stackmap_builder_->FinalizeStackmaps(code)));
-  }
-}
-
-
-void FlowGraphCompiler::FinalizeVarDescriptors(const Code& code) {
-  const LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle(
-          parsed_function_.node_sequence()->scope()->GetVarDescriptors());
-  code.set_var_descriptors(var_descs);
-}
-
-
-void FlowGraphCompiler::FinalizeExceptionHandlers(const Code& code) {
-  ASSERT(exception_handlers_list_ != NULL);
-  const ExceptionHandlers& handlers = ExceptionHandlers::Handle(
-      exception_handlers_list_->FinalizeExceptionHandlers(code.EntryPoint()));
-  code.set_exception_handlers(handlers);
-}
-
-
 void FlowGraphCompiler::FinalizeComments(const Code& code) {
-  code.set_comments(assembler_->GetCodeComments());
+  code.set_comments(assembler()->GetCodeComments());
 }
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64