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

runtime/vm/assembler_x64.h

 // 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.
 
 #ifndef VM_ASSEMBLER_X64_H_
 #define VM_ASSEMBLER_X64_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_x64.h directly; use assembler.h instead.
 #endif
 
 #include "vm/assert.h"
 #include "vm/constants_x64.h"
 #include "vm/utils.h"
 
 namespace dart {
 
 // Forward declarations.
 class RuntimeEntry;
 
 
 #if defined(TESTING) || defined(DEBUG)
 
+#if defined(TARGET_OS_WINDOWS)
+// The compiler may dynamically align the stack on Windows, so do not check.
+#define CHECK_STACK_ALIGNMENT { }
+#else
 #define CHECK_STACK_ALIGNMENT {                                                \
-  UNIMPLEMENTED();                                                             \
+  uword current_sp;                                                            \
+  asm volatile("mov %%rsp, %[current_sp]" : [current_sp] "=r" (current_sp));   \
+  ASSERT((OS::ActivationFrameAlignment() == 0) ||                              \
+         (Utils::IsAligned(current_sp, OS::ActivationFrameAlignment())));      \
 }
+#endif
 
 #else
 
 #define CHECK_STACK_ALIGNMENT { }
 
 #endif
 
 
 class Immediate : public ValueObject {
  public:
@@ skipping 18 matching lines @@
  public:
   uint8_t rex() const {
     return rex_;
   }
 
   uint8_t mod() const {
     return (encoding_at(0) >> 6) & 3;
   }
 
   Register rm() const {
-    int rm_rex = (rex_ & 1) << 3;
+    int rm_rex = (rex_ & REX_B) << 3;
     return static_cast<Register>(rm_rex + (encoding_at(0) & 7));
   }
 
   ScaleFactor scale() const {
     return static_cast<ScaleFactor>((encoding_at(1) >> 6) & 3);
   }
 
   Register index() const {
-    int index_rex = (rex_ & 2) << 2;
+    int index_rex = (rex_ & REX_X) << 2;
     return static_cast<Register>(index_rex + ((encoding_at(1) >> 3) & 7));
   }
 
   Register base() const {
-    int base_rex = (rex_ & 1) << 3;
+    int base_rex = (rex_ & REX_B) << 3;
     return static_cast<Register>(base_rex + (encoding_at(1) & 7));
   }
 
   int8_t disp8() const {
     ASSERT(length_ >= 2);
     return static_cast<int8_t>(encoding_[length_ - 1]);
   }
 
   int32_t disp32() const {
     ASSERT(length_ >= 5);
     return bit_copy<int32_t>(encoding_[length_ - 4]);
   }
 
  protected:
-  Operand() : length_(0), rex_(0) { }
+  Operand() : length_(0), rex_(REX_NONE) { }
 
   void SetModRM(int mod, Register rm) {
     ASSERT((mod & ~3) == 0);
-    if (rm > 7) rex_ |= 1;
+    if ((rm > 7) && !((rm == R12) && (mod != 3))) {
+      rex_ |= REX_B;
+    }
     encoding_[0] = (mod << 6) | (rm & 7);
     length_ = 1;
   }
 
   void SetSIB(ScaleFactor scale, Register index, Register base) {
     ASSERT(length_ == 1);
     ASSERT((scale & ~3) == 0);
     if (base > 7) {
-      ASSERT((rex_ & 1) == 0);  // Must not have REX.B already set.
-      rex_ |= 1;
+      ASSERT((rex_ & REX_B) == 0);  // Must not have REX.B already set.
+      rex_ |= REX_B;
     }
-    if (index > 7) rex_ |= 2;
+    if (index > 7) rex_ |= REX_X;
     encoding_[1] = (scale << 6) | ((index & 7) << 3) | (base & 7);
     length_ = 2;
   }
 
   void SetDisp8(int8_t disp) {
     ASSERT(length_ == 1 || length_ == 2);
     encoding_[length_++] = static_cast<uint8_t>(disp);
   }
 
   void SetDisp32(int32_t disp) {
     ASSERT(length_ == 1 || length_ == 2);
     memmove(&encoding_[length_], &disp, sizeof(disp));
     length_ += sizeof(disp);
   }
 
  private:
   uint8_t length_;
   uint8_t rex_;
   uint8_t encoding_[6];
 
-  explicit Operand(Register reg) : rex_(0) { SetModRM(3, reg); }
+  explicit Operand(Register reg) : rex_(REX_NONE) { SetModRM(3, reg); }
 
   // Get the operand encoding byte at the given index.
   uint8_t encoding_at(int index) const {
     ASSERT(index >= 0 && index < length_);
     return encoding_[index];
   }
 
   // Returns whether or not this operand is really the given register in
   // disguise. Used from the assembler to generate better encodings.
   bool IsRegister(Register reg) const {
-    return ((reg > 7 ? 1 : 0) == (rex_ & 1))  // REX.B match.
+    return ((reg > 7 ? 1 : 0) == (rex_ & REX_B))  // REX.B match.
         && ((encoding_at(0) & 0xF8) == 0xC0)  // Addressing mode is register.
         && ((encoding_at(0) & 0x07) == reg);  // Register codes match.
   }
 
 
   friend class Assembler;
 
   // TODO(5411081): Add DISALLOW_COPY_AND_ASSIGN(Operand) once the mac
   // build issue is resolved.
 };
 
 
 class Address : public Operand {
  public:
   Address(Register base, int32_t disp) {
-    if (disp == 0 && base != RBP) {
+    if ((disp == 0) && ((base & 7) != RBP)) {
       SetModRM(0, base);
-      if (base == RSP) SetSIB(TIMES_1, RSP, base);
+      if ((base & 7) == RSP) {
+        SetSIB(TIMES_1, RSP, base);
+      }
     } else if (Utils::IsInt(8, disp)) {
       SetModRM(1, base);
-      if (base == RSP) SetSIB(TIMES_1, RSP, base);
+      if ((base & 7) == RSP) {
+        SetSIB(TIMES_1, RSP, base);
+      }
       SetDisp8(disp);
     } else {
       SetModRM(2, base);
-      if (base == RSP) SetSIB(TIMES_1, RSP, base);
+      if ((base & 7) == RSP) {
+        SetSIB(TIMES_1, RSP, base);
+      }
       SetDisp32(disp);
     }
   }
 
   Address(Register index, ScaleFactor scale, int32_t disp) {
     ASSERT(index != RSP);  // Illegal addressing mode.
     SetModRM(0, RSP);
     SetSIB(scale, index, RBP);
     SetDisp32(disp);
   }
 
   Address(Register base, Register index, ScaleFactor scale, int32_t disp) {
     ASSERT(index != RSP);  // Illegal addressing mode.
-    if (disp == 0 && base != RBP) {
+    if ((disp == 0) && ((base & 7) != RBP)) {
       SetModRM(0, RSP);
       SetSIB(scale, index, base);
     } else if (Utils::IsInt(8, disp)) {
       SetModRM(1, RSP);
       SetSIB(scale, index, base);
       SetDisp8(disp);
     } else {
       SetModRM(2, RSP);
       SetSIB(scale, index, base);
       SetDisp32(disp);
@@ skipping 107 matching lines @@
    */
   void call(Register reg);
   void call(const Address& address);
   void call(Label* label);
   void call(const ExternalLabel* label);
 
   static const intptr_t kCallExternalLabelSize = 5;
 
   void pushq(Register reg);
   void pushq(const Address& address);
+  void pushq(const Immediate& imm);
 
   void popq(Register reg);
   void popq(const Address& address);
 
   void movl(Register dst, Register src);
   void movl(Register dst, const Immediate& imm);
   void movl(Register dst, const Address& src);
   void movl(const Address& dst, Register src);
 
   void movzxb(Register dst, Register src);
@@ skipping 44 matching lines @@
 
   void xchgl(Register dst, Register src);
   void xchgq(Register dst, Register src);
 
   void cmpl(Register reg, const Immediate& imm);
   void cmpl(Register reg0, Register reg1);
   void cmpl(Register reg, const Address& address);
   void cmpl(const Address& address, const Immediate& imm);
 
   void cmpq(Register reg, const Immediate& imm);
+  void cmpq(const Address& address, Register reg);
   void cmpq(const Address& address, const Immediate& imm);
   void cmpq(Register reg0, Register reg1);
   void cmpq(Register reg, const Address& address);
 
   void testl(Register reg1, Register reg2);
   void testl(Register reg, const Immediate& imm);
 
   void testq(Register reg1, Register reg2);
   void testq(Register reg, const Immediate& imm);
 
@@ skipping 115 matching lines @@
   void EnterFrame(intptr_t frame_space);
   void LeaveFrame();
 
   void CallRuntimeFromDart(const RuntimeEntry& entry);
   void CallRuntimeFromStub(const RuntimeEntry& entry);
 
   /*
    * Misc. functionality.
    */
   void SmiTag(Register reg) {
-    addl(reg, reg);
+    addq(reg, reg);
   }
 
   void SmiUntag(Register reg) {
-    sarl(reg, Immediate(kSmiTagSize));
+    sarq(reg, Immediate(kSmiTagSize));
   }
 
   int PreferredLoopAlignment() { return 16; }
   void Align(int alignment, int offset);
   void Bind(Label* label);
 
   int CodeSize() const { return buffer_.Size(); }
   int prolog_offset() const { return prolog_offset_; }
   const ZoneGrowableArray<int>& GetPointerOffsets() const {
     return buffer_.pointer_offsets();
@@ skipping 34 matching lines @@
   void EmitNearLabelLink(Label* label);
 
   void EmitGenericShift(bool wide, int rm, Register reg, const Immediate& imm);
   void EmitGenericShift(bool wide, int rm, Register operand, Register shifter);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 
-enum {
-  REX_NONE = 0,
-  REX_B    = 1 << 0,
-  REX_X    = 1 << 1,
-  REX_R    = 1 << 2,
-  REX_W    = 1 << 3
-};
-
-
 inline void Assembler::EmitUint8(uint8_t value) {
   buffer_.Emit<uint8_t>(value);
 }
 
 
 inline void Assembler::EmitInt32(int32_t value) {
   buffer_.Emit<int32_t>(value);
 }
 
 
 inline void Assembler::EmitInt64(int64_t value) {
   buffer_.Emit<int64_t>(value);
 }
 
 
 inline void Assembler::EmitRegisterREX(Register reg, uint8_t rex) {
   ASSERT(reg != kNoRegister);
   rex |= (reg > 7 ? REX_B : REX_NONE);
-  if (rex != 0) EmitUint8(0x40 | rex);
+  if (rex != REX_NONE) EmitUint8(REX_PREFIX | rex);
 }
 
 
 inline void Assembler::EmitOperandREX(int rm,
                                       const Operand& operand,
                                       uint8_t rex) {
   rex |= (rm > 7 ? REX_R : REX_NONE) | operand.rex();
-  if (rex != 0) EmitUint8(0x40 | rex);
+  if (rex != REX_NONE) EmitUint8(REX_PREFIX | rex);
 }
 
 
 inline void Assembler::EmitFixup(AssemblerFixup* fixup) {
   buffer_.EmitFixup(fixup);
 }
 
 
 inline void Assembler::EmitOperandSizeOverride() {
   EmitUint8(0x66);
 }
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_X64_H_