Adds single-precision and SIMD load/store to 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 531 matching lines @@
     if (a.type() == Address::PCOffset) {
       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, sz);
+      if (IsSignedOperand(sz)) {
+        EmitLoadStoreReg(LDRS, rt, a, sz);
+      } else {
+        EmitLoadStoreReg(LDR, rt, a, sz);
+      }
     }
   }
   void str(Register rt, Address a, OperandSize sz = kDoubleWord) {
     EmitLoadStoreReg(STR, rt, a, sz);
   }
 
   // Conditional select.
   void csel(Register rd, Register rn, Register rm, Condition cond) {
     EmitCoditionalSelect(CSEL, rd, rn, rm, cond, kDoubleWord);
   }
@@ skipping 97 matching lines @@
   }
   void fabsd(VRegister vd, VRegister vn) {
     EmitFPOneSourceOp(FABSD, vd, vn);
   }
   void fnegd(VRegister vd, VRegister vn) {
     EmitFPOneSourceOp(FNEGD, vd, vn);
   }
   void fsqrtd(VRegister vd, VRegister vn) {
     EmitFPOneSourceOp(FSQRTD, vd, vn);
   }
+  void fcvtsd(VRegister vd, VRegister vn) {
+    EmitFPOneSourceOp(FCVTSD, vd, vn);
+  }
+  void fcvtds(VRegister vd, VRegister vn) {
+    EmitFPOneSourceOp(FCVTDS, vd, vn);
+  }
+  void fldrq(VRegister vt, Address a) {
+    ASSERT(a.type() != Address::PCOffset);
+    EmitLoadStoreReg(FLDRQ, static_cast<Register>(vt), a, kByte);
+  }
+  void fstrq(VRegister vt, Address a) {
+    ASSERT(a.type() != Address::PCOffset);
+    EmitLoadStoreReg(FSTRQ, static_cast<Register>(vt), a, kByte);
+  }
   void fldrd(VRegister vt, Address a) {
     ASSERT(a.type() != Address::PCOffset);
-    EmitLoadStoreReg(FLDR, static_cast<Register>(vt), a, kDoubleWord);
+    EmitLoadStoreReg(FLDR, static_cast<Register>(vt), a, kDWord);
   }
   void fstrd(VRegister vt, Address a) {
     ASSERT(a.type() != Address::PCOffset);
-    EmitLoadStoreReg(FSTR, static_cast<Register>(vt), a, kDoubleWord);
+    EmitLoadStoreReg(FSTR, static_cast<Register>(vt), a, kDWord);
+  }
+  void fldrs(VRegister vt, Address a) {
+    ASSERT(a.type() != Address::PCOffset);
+    EmitLoadStoreReg(FLDR, static_cast<Register>(vt), a, kSWord);
+  }
+  void fstrs(VRegister vt, Address a) {
+    ASSERT(a.type() != Address::PCOffset);
+    EmitLoadStoreReg(FSTR, static_cast<Register>(vt), a, kSWord);
   }
   void fcmpd(VRegister vn, VRegister vm) {
     EmitFPCompareOp(FCMPD, vn, vm);
   }
-  void fcmpzd(VRegister vn) {
+  void fcmpdz(VRegister vn) {
     EmitFPCompareOp(FCMPZD, vn, V0);
   }
   void fmuld(VRegister vd, VRegister vn, VRegister vm) {
     EmitFPTwoSourceOp(FMULD, vd, vn, vm);
   }
   void fdivd(VRegister vd, VRegister vn, VRegister vm) {
     EmitFPTwoSourceOp(FDIVD, vd, vn, vm);
   }
   void faddd(VRegister vd, VRegister vn, VRegister vm) {
     EmitFPTwoSourceOp(FADDD, vd, vn, vm);
@@ skipping 108 matching lines @@
   void AddImmediate(Register dest, Register rn, int64_t imm, Register pp);
   void AddImmediateSetFlags(
       Register dest, Register rn, int64_t imm, Register pp);
   void AndImmediate(Register rd, Register rn, int64_t imm, Register pp);
   void OrImmediate(Register rd, Register rn, int64_t imm, Register pp);
   void XorImmediate(Register rd, Register rn, int64_t imm, Register pp);
   void TestImmediate(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,
-                      OperandSize sz = kDoubleWord);
-  void LoadFieldFromOffset(Register dest, Register base, int32_t offset) {
-    LoadFromOffset(dest, base, offset - kHeapObjectTag);
+                      Register pp, OperandSize sz = kDoubleWord);
+  void LoadFieldFromOffset(
+      Register dest, Register base, int32_t offset, Register pp) {
+    LoadFromOffset(dest, base, offset - kHeapObjectTag, pp);
   }
-  void LoadDFromOffset(VRegister dest, Register base, int32_t offset);
-  void LoadDFieldFromOffset(VRegister dest, Register base, int32_t offset) {
-    LoadDFromOffset(dest, base, offset - kHeapObjectTag);
+  void LoadDFromOffset(
+      VRegister dest, Register base, int32_t offset, Register pp);
+  void LoadDFieldFromOffset(
+      VRegister dest, Register base, int32_t offset, Register pp) {
+    LoadDFromOffset(dest, base, offset - kHeapObjectTag, pp);
+  }
+  void LoadQFromOffset(
+      VRegister dest, Register base, int32_t offset, Register pp);
+  void LoadQFieldFromOffset(
+      VRegister dest, Register base, int32_t offset, Register pp) {
+    LoadQFromOffset(dest, base, offset - kHeapObjectTag, pp);
   }
 
   void StoreToOffset(Register src, Register base, int32_t offset,
-                     OperandSize sz = kDoubleWord);
-  void StoreFieldToOffset(Register src, Register base, int32_t offset) {
-    StoreToOffset(src, base, offset - kHeapObjectTag);
+                     Register pp, OperandSize sz = kDoubleWord);
+  void StoreFieldToOffset(
+      Register src, Register base, int32_t offset, Register pp) {
+    StoreToOffset(src, base, offset - kHeapObjectTag, pp);
   }
-  void StoreDToOffset(VRegister src, Register base, int32_t offset);
-  void StoreDFieldToOffset(VRegister src, Register base, int32_t offset) {
-    StoreDToOffset(src, base, offset - kHeapObjectTag);
+  void StoreDToOffset(
+      VRegister src, Register base, int32_t offset, Register pp);
+  void StoreDFieldToOffset(
+      VRegister src, Register base, int32_t offset, Register pp) {
+    StoreDToOffset(src, base, offset - kHeapObjectTag, pp);
+  }
+  void StoreQToOffset(
+      VRegister src, Register base, int32_t offset, Register pp);
+  void StoreQFieldToOffset(
+      VRegister src, Register base, int32_t offset, Register pp) {
+    StoreQToOffset(src, base, offset - kHeapObjectTag, pp);
   }
 
   // Storing into an object.
   void StoreIntoObject(Register object,
                        const Address& dest,
                        Register value,
                        bool can_value_be_smi = true);
+  void StoreIntoObjectOffset(Register object,
+                             int32_t offset,
+                             Register value,
+                             Register pp,
+                             bool can_value_be_smi = true);
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
                                 Register value);
+  void StoreIntoObjectOffsetNoBarrier(Register object,
+                                      int32_t offset,
+                                      Register value,
+                                      Register pp);
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
                                 const Object& value);
+  void StoreIntoObjectOffsetNoBarrier(Register object,
+                                      int32_t offset,
+                                      const Object& value,
+                                      Register pp);
 
   // Object pool, loading from pool, etc.
   void LoadPoolPointer(Register pp);
 
   // Index of constant pool entries pointing to debugger stubs.
   static const int kBreakpointRuntimeCPIndex = 5;
 
   enum Patchability {
     kPatchable,
     kNotPatchable,
@@ skipping 13 matching lines @@
   void LoadImmediateFixed(Register reg, int64_t imm);
   void LoadImmediate(Register reg, int64_t imm, Register pp);
   void LoadDImmediate(VRegister reg, double immd, Register pp);
 
   void PushObject(const Object& object, Register pp) {
     LoadObject(TMP, object, pp);
     Push(TMP);
   }
   void CompareObject(Register reg, const Object& object, Register pp);
 
-  void LoadClassId(Register result, Register object);
-  void LoadClassById(Register result, Register class_id);
-  void LoadClass(Register result, Register object);
-  void CompareClassId(Register object, intptr_t class_id);
+  void LoadClassId(Register result, Register object, Register pp);
+  void LoadClassById(Register result, Register class_id, Register pp);
+  void LoadClass(Register result, Register object, Register pp);
+  void CompareClassId(Register object, intptr_t class_id, Register pp);
 
   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);
@@ skipping 258 matching lines @@
         (static_cast<int32_t>(hw_idx) << kHWShift) |
         (static_cast<int32_t>(imm) << kImm16Shift);
     Emit(encoding);
   }
 
   void EmitLoadStoreReg(LoadStoreRegOp op, Register rt, Address a,
                         OperandSize sz) {
     const Register crt = ConcreteRegister(rt);
     const int32_t size = Log2OperandSizeBytes(sz);
     const int32_t encoding =
-        op | (size << kSzShift) |
+        op | ((size & 0x3) << kSzShift) |
         (static_cast<int32_t>(crt) << kRtShift) |
         a.encoding();
     Emit(encoding);
   }
 
   void EmitLoadRegLiteral(LoadRegLiteralOp op, Register rt, Address a,
                           OperandSize sz) {
     ASSERT((sz == kDoubleWord) || (sz == kWord) || (sz == kUnsignedWord));
     ASSERT((rt != SP) && (rt != R31));
     const Register crt = ConcreteRegister(rt);
@@ skipping 120 matching lines @@
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_ARM64_H_