Enables first codegen test on arm64.

runtime/vm/assembler_arm64.h

 // Copyright (c) 2014, 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_ARM64_H_
 #define VM_ASSEMBLER_ARM64_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_arm64.h directly; use assembler.h instead.
 #endif
@@ skipping 392 matching lines @@
 
   // Emit data (e.g encoded instruction or immediate) in instruction stream.
   void Emit(int32_t value);
 
   // On some other platforms, we draw a distinction between safe and unsafe
   // smis.
   static bool IsSafe(const Object& object) { return true; }
   static bool IsSafeSmi(const Object& object) { return object.IsSmi(); }
 
   // Addition and subtraction.
+  // For add and sub, to use SP for rn, o must be of type Operand::Extend.
+  // For an unmodified rm in this case, use Operand(rm, UXTX, 0);
   void add(Register rd, Register rn, Operand o) {
     AddSubHelper(kDoubleWord, false, false, rd, rn, o);
   }
   void adds(Register rd, Register rn, Operand o) {
     AddSubHelper(kDoubleWord, true, false, rd, rn, o);
   }
   void addw(Register rd, Register rn, Operand o) {
     AddSubHelper(kWord, false, false, rd, rn, o);
   }
   void sub(Register rd, Register rn, Operand o) {
@@ skipping 112 matching lines @@
              (rt != a.base()));
       EmitLoadStoreReg(LDR, rt, a, kDoubleWord);
     }
   }
   void str(Register rt, Address a) {
     EmitLoadStoreReg(STR, rt, a, kDoubleWord);
   }
 
   // Comparison.
   // rn cmp o.
+  // For add and sub, to use SP for rn, o must be of type Operand::Extend.
+  // For an unmodified rm in this case, use Operand(rm, UXTX, 0);
   void cmp(Register rn, Operand o) {
     subs(ZR, rn, o);
   }
   // rn cmp -o.
   void cmn(Register rn, Operand o) {
     adds(ZR, rn, o);
   }
 
+  void CompareRegisters(Register rn, Register rm) {
+    if (rn == SP) {
+      // UXTX 0 on a 64-bit register (rm) is a nop, but forces R31 to be
+      // interpreted as SP.
+      cmp(SP, Operand(rm, UXTX, 0));
+    } else {
+      cmp(rn, Operand(rm));
+    }
+  }
+
   // Conditional branch.
   void b(Label* label, Condition cond = AL) {
     EmitBranch(BCOND, cond, label);
   }
 
   // TODO(zra): branch and link with imm26 offset.
   // TODO(zra): cbz, cbnz.
 
   // Branch, link, return.
   void br(Register rn) {
@@ skipping 63 matching lines @@
   }
   void Asr(Register rd, Register rn, int shift) {
     add(rd, ZR, Operand(rn, ASR, shift));
   }
 
   void SmiUntag(Register reg) {
     Asr(reg, reg, kSmiTagSize);
   }
 
   // Branching to ExternalLabels.
-  void Branch(const ExternalLabel* label) {
-    LoadExternalLabel(TMP, label, kPatchable, PP);
+  void BranchPatchable(const ExternalLabel* label, Register pp) {
+    LoadExternalLabel(TMP, label, kPatchable, pp);
     br(TMP);
   }
 
-  void BranchPatchable(const ExternalLabel* label) {
-    LoadPatchableImmediate(TMP, label->address());
+  void Branch(const ExternalLabel* label, Register pp) {
+    LoadExternalLabel(TMP, label, kNotPatchable, pp);
+    br(TMP);
+  }
+
+  // Fixed length branch to label.
+  void BranchFixed(const ExternalLabel* label) {
+    LoadImmediateFixed(TMP, label->address());
     br(TMP);
   }
 
   void BranchLink(const ExternalLabel* label, Register pp) {
     if (Isolate::Current() == Dart::vm_isolate()) {
       LoadImmediate(TMP, label->address(), kNoRegister);
       blr(TMP);
     } else {
       LoadExternalLabel(TMP, label, kNotPatchable, pp);
       blr(TMP);
@@ skipping 44 matching lines @@
   intptr_t FindExternalLabel(const ExternalLabel* label,
                              Patchability patchable);
   intptr_t FindObject(const Object& obj, Patchability patchable);
   intptr_t FindImmediate(int64_t imm);
   bool CanLoadObjectFromPool(const Object& object);
   bool CanLoadImmediateFromPool(int64_t imm, Register pp);
   void LoadExternalLabel(Register dst, const ExternalLabel* label,
                          Patchability patchable, Register pp);
   void LoadObject(Register dst, const Object& obj, Register pp);
   void LoadDecodableImmediate(Register reg, int64_t imm, Register pp);
-  void LoadPatchableImmediate(Register reg, int64_t imm);
+  void LoadImmediateFixed(Register reg, int64_t imm);
   void LoadImmediate(Register reg, int64_t imm, Register pp);
 
   void PushObject(const Object& object, Register pp) {
     LoadObject(TMP, object, pp);
     Push(TMP);
   }
 
   void EnterFrame(intptr_t frame_size);
   void LeaveFrame();
 
   void EnterDartFrame(intptr_t frame_size);
+  void EnterDartFrameWithInfo(intptr_t frame_size, Register new_pp);
+  void EnterOsrFrame(intptr_t extra_size, Register new_pp);
   void LeaveDartFrame();
 
   void EnterCallRuntimeFrame(intptr_t frame_size);
   void LeaveCallRuntimeFrame();
 
   void CallRuntime(const RuntimeEntry& entry, intptr_t argument_count);
 
  private:
   AssemblerBuffer buffer_;  // Contains position independent code.
 
@@ skipping 305 matching lines @@
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_ARM64_H_