Enables simple static call 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 507 matching lines @@
     const Register crd = ConcreteRegister(rd);
     EmitMoveWideOp(MOVN, crd, imm, hw_idx, kDoubleWord);
   }
   void movz(Register rd, uint16_t imm, int hw_idx) {
     ASSERT(rd != SP);
     const Register crd = ConcreteRegister(rd);
     EmitMoveWideOp(MOVZ, crd, imm, hw_idx, kDoubleWord);
   }
 
   // Loads and Stores.
-  void ldr(Register rt, Address a) {
+  void ldr(Register rt, Address a, OperandSize sz = kDoubleWord) {
     if (a.type() == Address::PCOffset) {
-      EmitLoadRegLiteral(LDRpc, rt, a, kDoubleWord);
+      ASSERT(sz == kDoubleWord);
+      EmitLoadRegLiteral(LDRpc, rt, a, sz);
     } else {
       // If we are doing pre-/post-indexing, and the base and result registers
       // are the same, then the result of the load will be clobbered by the
       // writeback, which is unlikely to be useful.
       ASSERT(((a.type() != Address::PreIndex) &&
               (a.type() != Address::PostIndex)) ||
              (rt != a.base()));
-      EmitLoadStoreReg(LDR, rt, a, kDoubleWord);
+      EmitLoadStoreReg(LDR, rt, a, sz);
     }
   }
-  void str(Register rt, Address a) {
-    EmitLoadStoreReg(STR, rt, a, kDoubleWord);
+  void str(Register rt, Address a, OperandSize sz = kDoubleWord) {
+    EmitLoadStoreReg(STR, rt, a, sz);
   }
 
   // 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.
@@ skipping 124 matching lines @@
     LoadExternalLabel(TMP, label, kPatchable, PP);
     blr(TMP);
   }
 
   // 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, Register pp);
   void CompareImmediate(Register rn, int64_t imm, Register pp);
-  void LoadFromOffset(Register dest, Register base, int32_t offset);
+
+  void LoadFromOffset(Register dest, Register base, int32_t offset,
+                      OperandSize sz = kDoubleWord);
   void LoadFieldFromOffset(Register dest, Register base, int32_t offset) {
     LoadFromOffset(dest, base, offset - kHeapObjectTag);
   }
-  void StoreToOffset(Register dest, Register base, int32_t offset);
+
+  void StoreToOffset(Register dest, Register base, int32_t offset,
+                     OperandSize sz = kDoubleWord);
   void StoreFieldToOffset(Register dest, Register base, int32_t offset) {
     StoreToOffset(dest, base, offset - kHeapObjectTag);
   }
 
   // Storing into an object.
   void StoreIntoObject(Register object,
                        const Address& dest,
                        Register value,
                        bool can_value_be_smi = true);
   void StoreIntoObjectNoBarrier(Register object,
@@ skipping 33 matching lines @@
   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);
 
-  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(bool load_pp = false);
+  void LeaveStubFrame();
 
  private:
   AssemblerBuffer buffer_;  // Contains position independent code.
 
   // Objects and patchable jump targets.
   GrowableObjectArray& object_pool_;
 
   // Patchability of pool entries.
   GrowableArray<Patchability> patchable_pool_entries_;
 
@@ skipping 299 matching lines @@
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_ARM64_H_