Introduce locations based code generation.

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"
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/code_generator.h"
 #include "vm/debugger.h"
 #include "vm/disassembler.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
+#include "vm/locations.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 
 namespace dart {
 
 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);
@@ skipping 512 matching lines @@
                    comp->token_index(),
                    comp->try_index(),
                    comp->function_name(),
                    comp->ArgumentCount(),
                    comp->argument_names(),
                    comp->checked_argument_count());
 }
 
 
 void FlowGraphCompiler::VisitStrictCompare(StrictCompareComp* comp) {
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
-  LoadValue(RDX, comp->right());
-  LoadValue(RAX, comp->left());
-  __ cmpq(RAX, RDX);
-  Label load_true, done;
-  if (comp->kind() == Token::kEQ_STRICT) {
-    __ j(EQUAL, &load_true, Assembler::kNearJump);
-  } else {
-    __ j(NOT_EQUAL, &load_true, Assembler::kNearJump);
-  }
-  __ LoadObject(RAX, bool_false);
-  __ jmp(&done, Assembler::kNearJump);
-  __ Bind(&load_true);
-  __ LoadObject(RAX, bool_true);
-  __ Bind(&done);
+  UNREACHABLE();

[srdjan, 2012/05/21 16:05:22]

Why is that (add comment)? Wait, this is part of the new code emission
structure?

[Vyacheslav Egorov (Google), 2012/05/21 19:53:46]

Yes, native template were moved. I added a comment.

 }
 
 
 void FlowGraphCompiler::VisitEqualityCompare(EqualityCompareComp* comp) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label done, load_true, non_null_compare;
   LoadValue(RDX, comp->right());
@@ skipping 539 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::EmitInstructionPrologue(Instruction* instr) {
+  LocationSummary* locs = instr->locs();
+  ASSERT(locs != NULL);
+
+  // TODO(vegorov): share this !!!
+  locs->AllocateRegisters();
+
+  // Load instruction inputs into allocated registers.
+  for (intptr_t i = locs->count() - 1; i >= 0; i--) {
+    Location loc = locs->in(i);
+    if (loc.kind() == Location::kRegister) {
+      __ popq(loc.AsRegister());
+    }

[srdjan, 2012/05/21 16:05:22]

else? UNIMPLEMENTED? check location is stack OK?

[Vyacheslav Egorov (Google), 2012/05/21 19:53:46]

Added assert.

+  }
+}
+
+
 void FlowGraphCompiler::VisitBlocks() {
   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);
     // Compile all successors until an exit, branch, or a block entry.
     while ((instr != NULL) && !instr->IsBlockEntry()) {
       if (FLAG_code_comments) EmitComment(instr);
-      instr = instr->Accept(this);
+      if (instr->locs() != NULL) {
+        EmitInstructionPrologue(instr);
+        instr->EmitNativeCode(this);
+        instr = instr->StraightLineSuccessor();
+      } else {
+        instr = instr->Accept(this);
+      }
     }
 
     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);
@@ skipping 29 matching lines @@
   }
 }
 
 
 void FlowGraphCompiler::VisitDo(DoInstr* instr) {
   instr->computation()->Accept(this);
 }
 
 
 void FlowGraphCompiler::VisitBind(BindInstr* instr) {
+  ASSERT(instr->locs() == NULL);
+
+  // If instruction does not have special location requirements
+  // then it returns result in register RAX.
   instr->computation()->Accept(this);
   __ pushq(RAX);
 }
 
 
 void FlowGraphCompiler::VisitReturn(ReturnInstr* instr) {
   LoadValue(RAX, instr->value());
   if (!is_optimizing()) {
     // Count only in unoptimized code.
     // TODO(srdjan): Replace the counting code with a type feedback
@@ skipping 520 matching lines @@
 
 
 void FlowGraphCompiler::FinalizeComments(const Code& code) {
   code.set_comments(assembler_->GetCodeComments());
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64