First step toward an optimizing compiler:

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(bool, 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) {
+  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++) {
+    __ 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),
       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());
@@ skipping 1231 matching lines @@
 
   ASSERT(!comp->exception_var().is_captured());
   ASSERT(!comp->stacktrace_var().is_captured());
   __ movq(Address(RBP, comp->exception_var().index() * kWordSize),
           kExceptionObjectReg);
   __ movq(Address(RBP, comp->stacktrace_var().index() * kWordSize),
           kStackTraceObjectReg);
 }
 
 
+void FlowGraphCompiler::VisitBinaryOp(BinaryOpComp* 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->count() - 1; i >= 0; i--) {
     Location loc = locs->in(i);
     ASSERT(loc.kind() == Location::kRegister);
@@ skipping 520 matching lines @@
     if (FLAG_print_ast) {
       // Second printing.
       OS::Print("Annotated ");
     }
     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);
   __ 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);
 }
 
 
@@ skipping 12 matching lines @@
                                              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) {
@@ skipping 14 matching lines @@
   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());
 }
 
+#undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64