Port code generator to x64.

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 25 matching lines @@
 
 void Assembler::call(Label* label) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   static const int kSize = 5;
   EmitUint8(0xE8);
   EmitLabel(label, kSize);
 }
 
 
 void Assembler::call(const ExternalLabel* label) {
-  movq(TMP, Immediate(label->address()));
-  call(TMP);
+  AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+  intptr_t call_start = buffer_.GetPosition();
+
+  // Encode movq(TMP, Immediate(label->address())), but always as imm64.
+  EmitRegisterREX(TMP, REX_W);
+  EmitUint8(0xB8 | (TMP & 7));
+  EmitInt64(label->address());
+
+  // Encode call(TMP).
+  Operand operand(TMP);
+  EmitOperandREX(2, operand, REX_NONE);
+  EmitUint8(0xFF);
+  EmitOperand(2, operand);
+
+  ASSERT((buffer_.GetPosition() - call_start) == kCallExternalLabelSize);
 }
 
 
 void Assembler::pushq(Register reg) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitRegisterREX(reg, REX_NONE);
   EmitUint8(0x50 | (reg & 7));
 }
 
 
@@ skipping 817 matching lines @@
 }
 
 
 void Assembler::subq(Register reg, const Immediate& imm) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitRegisterREX(reg, REX_W);
   EmitComplex(5, Operand(reg), imm);
 }
 
 
+void Assembler::subq(Register reg, const Address& address) {
+  AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+  EmitOperandREX(reg, address, REX_W);
+  EmitUint8(0x2B);
+  EmitOperand(reg & 7, address);
+}
+
+
 void Assembler::shll(Register reg, const Immediate& imm) {
   EmitGenericShift(false, 4, reg, imm);
 }
 
 
 void Assembler::shll(Register operand, Register shifter) {
   EmitGenericShift(false, 4, operand, shifter);
 }
 
 
@@ skipping 132 matching lines @@
   EmitUint8(0xC9);
 }
 
 
 void Assembler::ret() {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xC3);
 }
 
 
-void Assembler::nop() {
+void Assembler::nop(int size) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
-  EmitUint8(0x90);
+  // There are nops up to size 15, but for now just provide up to size 8.
+  ASSERT(0 < size && size <= MAX_NOP_SIZE);
+  switch (size) {
+    case 1:
+      EmitUint8(0x90);
+      break;
+    case 2:
+      EmitUint8(0x66);
+      EmitUint8(0x90);
+      break;
+    case 3:
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x00);
+      break;
+    case 4:
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x40);
+      EmitUint8(0x00);
+      break;
+    case 5:
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x44);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      break;
+    case 6:
+      EmitUint8(0x66);
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x44);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      break;
+    case 7:
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x80);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      break;
+    case 8:
+      EmitUint8(0x0F);
+      EmitUint8(0x1F);
+      EmitUint8(0x84);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      EmitUint8(0x00);
+      break;
+    default:
+      UNIMPLEMENTED();
+  }
 }
 
 
 void Assembler::int3() {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xCC);
 }
 
 
 void Assembler::hlt() {
@@ skipping 21 matching lines @@
     EmitUint8(0x70 + condition);
     EmitNearLabelLink(label);
   } else {
     EmitUint8(0x0F);
     EmitUint8(0x80 + condition);
     EmitLabelLink(label);
   }
 }
 
 
+void Assembler::j(Condition condition, const ExternalLabel* label) {
+  Label no_jump;
+  j(static_cast<Condition>(condition ^ 1), &no_jump);  // Negate condition.
+  jmp(label);
+  Bind(&no_jump);
+}
+
+
 void Assembler::jmp(Register reg) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   Operand operand(reg);
   EmitOperandREX(4, operand, REX_NONE);
   EmitUint8(0xFF);
   EmitOperand(4, operand);
 }
 
 
 void Assembler::jmp(Label* label, bool near) {
@@ skipping 14 matching lines @@
     EmitUint8(0xEB);
     EmitNearLabelLink(label);
   } else {
     EmitUint8(0xE9);
     EmitLabelLink(label);
   }
 }
 
 
 void Assembler::jmp(const ExternalLabel* label) {
-  movq(TMP, Immediate(label->address()));
-  jmp(TMP);
+  AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+  intptr_t call_start = buffer_.GetPosition();
+
+  // Encode movq(TMP, Immediate(label->address())), but always as imm64.
+  EmitRegisterREX(TMP, REX_W);
+  EmitUint8(0xB8 | (TMP & 7));
+  EmitInt64(label->address());
+
+  // Encode jmp(TMP).
+  Operand operand(TMP);
+  EmitOperandREX(4, operand, REX_NONE);
+  EmitUint8(0xFF);
+  EmitOperand(4, operand);
+
+  ASSERT((buffer_.GetPosition() - call_start) == kCallExternalLabelSize);
 }
 
 
 void Assembler::lock() {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xF0);
 }
 
 
 void Assembler::cmpxchgl(const Address& address, Register reg) {
@@ skipping 60 matching lines @@
   if (object.IsSmi()) {
     cmpq(reg, Immediate(reinterpret_cast<int64_t>(object.raw())));
   } else {
     ASSERT(reg != TMP);
     LoadObject(TMP, object);
     cmpq(reg, TMP);
   }
 }
 
 
+void Assembler::StoreIntoObject(Register object,
+                                const FieldAddress& dest,
+                                Register value) {
+  // TODO(iposva): Add write barrier.
+  movq(dest, value);
+}
+
+
 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)));
   int3();
 }
 
@@ skipping 40 matching lines @@
   entry.CallFromDart(this);
 }
 
 
 void Assembler::CallRuntimeFromStub(const RuntimeEntry& entry) {
   entry.CallFromStub(this);
 }
 
 
 void Assembler::Align(int alignment, int offset) {
-  UNIMPLEMENTED();
+  ASSERT(Utils::IsPowerOfTwo(alignment));
+  int pos = offset + buffer_.GetPosition();
+  int mod = pos & (alignment - 1);
+  if (mod == 0) {
+    return;
+  }
+  int bytes_needed = alignment - mod;
+  while (bytes_needed > MAX_NOP_SIZE) {
+    nop(MAX_NOP_SIZE);
+    bytes_needed -= MAX_NOP_SIZE;
+  }
+  if (bytes_needed) {
+    nop(bytes_needed);
+  }
+  ASSERT(((offset + buffer_.GetPosition()) & (alignment-1)) == 0);
 }
 
 
 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.
   ASSERT((operand.encoding_[0] & 0x38) == 0);
   EmitUint8(operand.encoding_[0] + (rm << 3));
@@ skipping 102 matching lines @@
   } else {
     EmitRegisterREX(operand, REX_NONE);
   }
   EmitUint8(0xD3);
   EmitOperand(rm, Operand(operand));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64