Revert "VM: New calling convention for generated code."

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 1134 matching lines @@
     fldrd(reg, Address(SP, 1 * kDoubleSize, Address::PostIndex));
   }
   void PopQuad(VRegister reg) {
     fldrq(reg, Address(SP, 1 * kQuadSize, Address::PostIndex));
   }
   void TagAndPushPP() {
     // Add the heap object tag back to PP before putting it on the stack.
     add(TMP, PP, Operand(kHeapObjectTag));
     str(TMP, Address(SP, -1 * kWordSize, Address::PreIndex));
   }
-  void TagAndPushPPAndPcMarker() {
-    COMPILE_ASSERT(CODE_REG != TMP2);
+  void TagAndPushPPAndPcMarker(Register pc_marker_reg) {
+    ASSERT(pc_marker_reg != TMP2);
     // Add the heap object tag back to PP before putting it on the stack.
     add(TMP2, PP, Operand(kHeapObjectTag));
-    stp(TMP2, CODE_REG,
+    stp(TMP2, pc_marker_reg,
         Address(SP, -2 * kWordSize, Address::PairPreIndex));
   }
   void PopAndUntagPP() {
     ldr(PP, Address(SP, 1 * kWordSize, Address::PostIndex));
     sub(PP, PP, Operand(kHeapObjectTag));
     // The caller of PopAndUntagPP() must explicitly allow use of popped PP.
     set_constant_pool_allowed(false);
   }
   void tst(Register rn, Operand o) {
     ands(ZR, rn, o);
@@ skipping 21 matching lines @@
   void SmiUntag(Register dst, Register src) {
     AsrImmediate(dst, src, kSmiTagSize);
   }
   void SmiTag(Register reg) {
     LslImmediate(reg, reg, kSmiTagSize);
   }
   void SmiTag(Register dst, Register src) {
     LslImmediate(dst, src, kSmiTagSize);
   }
 
-  void Branch(const StubEntry& stub_entry,
-              Register pp,
-              Patchability patchable = kNotPatchable);
+  void Branch(const StubEntry& stub_entry);
   void BranchPatchable(const StubEntry& stub_entry);
 
-  void BranchLink(const StubEntry& stub_entry,
-                  Patchability patchable = kNotPatchable);
+  void BranchLink(const ExternalLabel* label);
+  void BranchLink(const StubEntry& stub_entry);
 
+  // BranchLinkPatchable must be a fixed-length sequence so we can patch it
+  // with the debugger.
   void BranchLinkPatchable(const StubEntry& stub_entry);
 
   // Macros accepting a pp Register argument may attempt to load values from
   // the object pool when possible. Unless you are sure that the untagged object
   // pool pointer is in another register, or that it is not available at all,
   // PP should be passed for pp.
   void AddImmediate(Register dest, Register rn, int64_t imm);
   void AddImmediateSetFlags(Register dest, Register rn, int64_t imm);
   void SubImmediateSetFlags(Register dest, Register rn, int64_t imm);
   void AndImmediate(Register rd, Register rn, int64_t imm);
@@ skipping 57 matching lines @@
   // Object pool, loading from pool, etc.
   void LoadPoolPointer(Register pp = PP);
 
   bool constant_pool_allowed() const {
     return constant_pool_allowed_;
   }
   void set_constant_pool_allowed(bool b) {
     constant_pool_allowed_ = b;
   }
 
+  void LoadWordFromPoolOffset(Register dst, uint32_t offset);
+  void LoadWordFromPoolOffsetFixed(Register dst, uint32_t offset);
   intptr_t FindImmediate(int64_t imm);
   bool CanLoadFromObjectPool(const Object& object) const;
   void LoadExternalLabel(Register dst, const ExternalLabel* label);
   void LoadNativeEntry(Register dst, const ExternalLabel* label);
   void LoadExternalLabelFixed(Register dst,
                               const ExternalLabel* label,
                               Patchability patchable);
   void LoadFunctionFromCalleePool(Register dst,
                                   const Function& function,
                                   Register new_pp);
@@ skipping 35 matching lines @@
 
   // When entering Dart code from C++, we copy the system stack pointer (CSP)
   // to the Dart stack pointer (SP), and reserve a little space for the stack
   // to grow.
   void SetupDartSP(intptr_t reserved_space) {
     ASSERT(Utils::IsAligned(reserved_space, 16));
     mov(SP, CSP);
     sub(CSP, CSP, Operand(reserved_space));
   }
 
-  void CheckCodePointer();
-  void RestoreCodePointer();
-
   void EnterDartFrame(intptr_t frame_size, Register new_pp = kNoRegister);
   void EnterOsrFrame(intptr_t extra_size, Register new_pp);
-  void LeaveDartFrame(RestorePP restore_pp = kRestoreCallerPP);
+  void LeaveDartFrame();
 
   void EnterCallRuntimeFrame(intptr_t frame_size);
   void LeaveCallRuntimeFrame();
   void CallRuntime(const RuntimeEntry& entry, intptr_t argument_count);
 
   // Set up a stub frame so that the stack traversal code can easily identify
   // a stub frame.
   void EnterStubFrame();
   void LeaveStubFrame();
 
@@ skipping 63 matching lines @@
     intptr_t pc_offset_;
     const String& comment_;
 
     DISALLOW_COPY_AND_ASSIGN(CodeComment);
   };
 
   GrowableArray<CodeComment*> comments_;
 
   bool constant_pool_allowed_;
 
-  void LoadWordFromPoolOffset(Register dst, uint32_t offset, Register pp = PP);
-  void LoadWordFromPoolOffsetFixed(Register dst, uint32_t offset);
+  void Branch(const ExternalLabel* label);
+  void BranchPatchable(const ExternalLabel* label);
+  void BranchLinkPatchable(const ExternalLabel* label);
 
   void LoadObjectHelper(Register dst, const Object& obj, bool is_unique);
 
   void AddSubHelper(OperandSize os, bool set_flags, bool subtract,
                     Register rd, Register rn, Operand o) {
     ASSERT((rd != R31) && (rn != R31));
     const Register crd = ConcreteRegister(rd);
     const Register crn = ConcreteRegister(rn);
     if (o.type() == Operand::Immediate) {
       ASSERT(rn != ZR);
@@ skipping 482 matching lines @@
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_ARM64_H_