Add 64-bit stubs to call into the runtime and to call native functions.

runtime/vm/assembler_x64.cc

 // Copyright (c) 2011, 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"
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/assembler.h"
 #include "vm/heap.h"
 #include "vm/memory_region.h"
@@ skipping 45 matching lines @@
 
 
 void Assembler::pushq(const Address& address) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitOperandREX(6, address, REX_NONE);
   EmitUint8(0xFF);
   EmitOperand(6, address);
 }
 
 
+void Assembler::pushq(const Immediate& imm) {
+  if (imm.is_int32()) {
+    AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+    EmitUint8(0x68);
+    EmitImmediate(imm);
+  } else {
+    movq(TMP, imm);
+    pushq(TMP);
+  }
+}
+
+
 void Assembler::popq(Register reg) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitRegisterREX(reg, REX_NONE);
   EmitUint8(0x58 | (reg & 7));
 }
 
 
 void Assembler::popq(const Address& address) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitOperandREX(0, address, REX_NONE);
@@ skipping 192 matching lines @@
 
 void Assembler::movq(const Address& dst, Register src) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitOperandREX(src, dst, REX_W);
   EmitUint8(0x89);
   EmitOperand(src & 7, dst);
 }
 
 
 void Assembler::movq(const Address& dst, const Immediate& imm) {
-  AssemblerBuffer::EnsureCapacity ensured(&buffer_);
-  ASSERT(imm.is_int32());
-  Operand operand(dst);
-  EmitOperandREX(0, operand, REX_W);
-  EmitUint8(0xC7);
-  EmitOperand(0, operand);
-  EmitImmediate(imm);
+  if (imm.is_int32()) {
+    AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+    Operand operand(dst);
+    EmitOperandREX(0, operand, REX_W);
+    EmitUint8(0xC7);
+    EmitOperand(0, operand);
+    EmitImmediate(imm);
+  } else {
+    movq(TMP, imm);
+    movq(dst, TMP);
+  }
 }
 
 
 void Assembler::movsxl(Register dst, const Address& src) {
   UNIMPLEMENTED();
 }
 
 
 void Assembler::leaq(Register dst, const Address& src) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
@@ skipping 234 matching lines @@
 
 
 void Assembler::cmpl(const Address& address, const Immediate& imm) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   Operand operand(address);
   EmitOperandREX(7, operand, REX_NONE);
   EmitComplex(7, operand, imm);
 }
 
 
+void Assembler::cmpq(const Address& address, Register reg) {

[srdjan, 2011/12/06 17:37:44]

Could you add tests for the new operations/mode in assembler_test_x64?

[regis, 2011/12/06 21:41:52]

Done.

+  AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+  EmitOperandREX(reg, address, REX_W);
+  EmitUint8(0x39);
+  EmitOperand(reg & 7, address);
+}
+
+
 void Assembler::cmpq(const Address& address, const Immediate& imm) {
-  AssemblerBuffer::EnsureCapacity ensured(&buffer_);
-  Operand operand(address);
-  EmitOperandREX(7, operand, REX_W);
-  EmitComplex(7, operand, imm);
+  if (imm.is_int32()) {
+    AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+    Operand operand(address);
+    EmitOperandREX(7, operand, REX_W);
+    EmitComplex(7, operand, imm);
+  } else {
+    movq(TMP, imm);
+    cmpq(address, TMP);
+  }
 }
 
 
 void Assembler::cmpq(Register reg, const Immediate& imm) {
-  AssemblerBuffer::EnsureCapacity ensured(&buffer_);
-  EmitRegisterREX(reg, REX_W);
-  EmitComplex(7, Operand(reg), imm);
+  if (imm.is_int32()) {
+    AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+    EmitRegisterREX(reg, REX_W);
+    EmitComplex(7, Operand(reg), imm);
+  } else {
+    movq(TMP, imm);
+    cmpq(reg, TMP);
+  }
 }
 
 
 void Assembler::cmpq(Register reg0, Register reg1) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   Operand operand(reg1);
   EmitOperandREX(reg0, operand, REX_W);
   EmitUint8(0x3B);
   EmitOperand(reg0 & 7, operand);
 }
@@ skipping 246 matching lines @@
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0x0F);
   EmitUint8(0xAF);
   EmitOperand(dst, Operand(src));
 }
 
 
 void Assembler::imull(Register reg, const Immediate& imm) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0x69);
-  EmitOperand(reg, Operand(reg));
+  EmitOperand(reg & 7, Operand(reg));
   EmitImmediate(imm);
 }
 
 
 void Assembler::imulq(Register dst, Register src) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   Operand operand(src);
   EmitOperandREX(dst, operand, REX_W);
   EmitUint8(0x0F);
   EmitUint8(0xAF);
@@ skipping 289 matching lines @@
     if (value == 1) {
       decq(reg);
     } else if (value != 0) {
       subq(reg, Immediate(value));
     }
   }
 }
 
 
 void Assembler::LoadObject(Register dst, const Object& object) {
-  ASSERT(object.IsZoneHandle());
-  AssemblerBuffer::EnsureCapacity ensured(&buffer_);
-  EmitRegisterREX(dst, REX_W);
-  EmitUint8(0xB8 | (dst & 7));
-  buffer_.EmitObject(object);
+  if (object.IsSmi()) {
+    movq(dst, Immediate(reinterpret_cast<int64_t>(object.raw())));
+  } else {
+    ASSERT(object.IsZoneHandle());
+    AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+    EmitRegisterREX(dst, REX_W);
+    EmitUint8(0xB8 | (dst & 7));
+    buffer_.EmitObject(object);
+  }
 }
 
 
 void Assembler::PushObject(const Object& object) {
-  LoadObject(TMP, object);
-  pushq(TMP);
+  if (object.IsSmi()) {
+    pushq(Immediate(reinterpret_cast<int64_t>(object.raw())));
+  } else {
+    LoadObject(TMP, object);
+    pushq(TMP);
+  }
 }
 
 
 void Assembler::CompareObject(Register reg, const Object& object) {
-  ASSERT(reg != TMP);
-  LoadObject(TMP, object);
-  cmpq(reg, TMP);
+  if (object.IsSmi()) {
+    cmpq(reg, Immediate(reinterpret_cast<int64_t>(object.raw())));
+  } else {
+    ASSERT(reg != TMP);
+    LoadObject(TMP, object);
+    cmpq(reg, TMP);
+  }
 }
 
 
 void Assembler::Stop(const char* message) {
   // Emit the lower half and the higher half of the message address as immediate
   // operands in the test rax instructions, followed by the int3 instruction.
   // Execution can be resumed with the 'cont' command in gdb.
   int64_t message_address = reinterpret_cast<int64_t>(message);
   testl(RAX, Immediate(Utils::Low32Bits(message_address)));
   testl(RAX, Immediate(Utils::High32Bits(message_address)));
@@ skipping 13 matching lines @@
   while (label->HasNear()) {
     int position = label->NearPosition();
     int offset = bound - (position + 1);
     ASSERT(Utils::IsInt(8, offset));
     buffer_.Store<int8_t>(position, offset);
   }
   label->BindTo(bound);
 }
 
 
+void Assembler::EnterFrame(intptr_t frame_size) {
+  if (prolog_offset_ == -1) {
+    prolog_offset_ = CodeSize();
+  }
+  pushq(RBP);
+  movq(RBP, RSP);
+  if (frame_size != 0) {
+    Immediate frame_space(frame_size);
+    subq(RSP, frame_space);
+  }
+}
+
+
+void Assembler::LeaveFrame() {
+  movq(RSP, RBP);
+  popq(RBP);
+}
+
+
+void Assembler::CallRuntimeFromDart(const RuntimeEntry& entry) {
+  entry.CallFromDart(this);
+}
+
+
+void Assembler::CallRuntimeFromStub(const RuntimeEntry& entry) {
+  entry.CallFromStub(this);
+}
+
+
 void Assembler::Align(int alignment, int offset) {
   UNIMPLEMENTED();
 }
 
 
 void Assembler::EmitOperand(int rm, const Operand& operand) {
   ASSERT(rm >= 0 && rm < 8);
   const int length = operand.length_;
   ASSERT(length > 0);
   // Emit the ModRM byte updated with the given RM value.
@@ skipping 16 matching lines @@
 void Assembler::EmitImmediate(const Immediate& imm) {
   if (imm.is_int32()) {
     EmitInt32(static_cast<int32_t>(imm.value()));
   } else {
     EmitInt64(imm.value());
   }
 }
 
 
 void Assembler::EmitComplex(int rm,
-                                  const Operand& operand,
-                                  const Immediate& immediate) {
+                            const Operand& operand,
+                            const Immediate& immediate) {
   ASSERT(rm >= 0 && rm < 8);
   ASSERT(immediate.is_int32());
   if (immediate.is_int8()) {
     // Use sign-extended 8-bit immediate.
     EmitUint8(0x83);
     EmitOperand(rm, operand);
     EmitUint8(immediate.value() & 0xFF);
   } else if (operand.IsRegister(RAX)) {
     // Use short form if the destination is rax.
     EmitUint8(0x05 + (rm << 3));
@@ skipping 66 matching lines @@
   } else {
     EmitRegisterREX(operand, REX_NONE);
   }
   EmitUint8(0xD3);
   EmitOperand(rm, Operand(operand));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64