Begins work on arm64 floating point instructions.

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 583 matching lines @@
   }
   void ret(Register rn = R30) {
     EmitUnconditionalBranchRegOp(RET, rn);
   }
 
   // Exceptions.
   void hlt(uint16_t imm) {
     EmitExceptionGenOp(HLT, imm);
   }
 
+  // Double floating point.
+  bool fmovdi(VRegister vd, double immd) {
+    int64_t imm64 = bit_cast<int64_t, double>(immd);
+    const uint8_t bit7 = imm64 >> 63;
+    const uint8_t bit6 = (~(imm64 >> 62)) & 0x1;
+    const uint8_t bit54 = (imm64 >> 52) & 0x3;
+    const uint8_t bit30 = (imm64 >> 48) & 0xf;
+    const uint8_t imm8 = (bit7 << 7) | (bit6 << 6) | (bit54 << 4) | bit30;
+    const int64_t expimm8 = Instr::VFPExpandImm(imm8);
+    if (imm64 != expimm8) {
+      return false;
+    }
+    EmitFPImm(FMOVDI, vd, imm8);
+    return true;
+  }
+  void fmovdr(VRegister vd, Register rn) {
+    EmitFPIntCvtOp(FMOVDR, static_cast<Register>(vd), rn);
+  }
+  void fmovrd(Register rd, VRegister vn) {
+    EmitFPIntCvtOp(FMOVRD, rd, static_cast<Register>(vn));
+  }
+
   // Aliases.
   void mov(Register rd, Register rn) {
     if ((rd == SP) || (rn == SP)) {
       add(rd, rn, Operand(0));
     } else {
       orr(rd, ZR, Operand(rn));
     }
   }
   void mvn(Register rd, Register rm) {
     orr(rd, ZR, Operand(rm));
@@ skipping 129 matching lines @@
   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 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);
@@ skipping 344 matching lines @@
     const int32_t size = (sz == kDoubleWord) ? B31 : 0;
     const int32_t encoding =
         op | size |
         (static_cast<int32_t>(crd) << kRdShift) |
         (static_cast<int32_t>(crn) << kRnShift) |
         (static_cast<int32_t>(crm) << kRmShift) |
         (static_cast<int32_t>(cond) << kSelCondShift);
     Emit(encoding);
   }
 
+  void EmitFPImm(FPImmOp op, VRegister vd, uint8_t imm8) {
+    const int32_t encoding =
+        op |
+        (static_cast<int32_t>(vd) << kVdShift) |
+        (imm8 << kImm8Shift);
+    Emit(encoding);
+  }
+
+  void EmitFPIntCvtOp(FPIntCvtOp op, Register rd, Register rn) {
+    const int32_t encoding =
+        op |
+        (static_cast<int32_t>(rd) << kRdShift) |
+        (static_cast<int32_t>(rn) << kRnShift);
+    Emit(encoding);
+  }
+
   void StoreIntoObjectFilter(Register object, Register value, Label* no_update);
 
   // Shorter filtering sequence that assumes that value is not a smi.
   void StoreIntoObjectFilterNoSmi(Register object,
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_ARM64_H_