Enables many language tests for 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 495 matching lines @@
   }
   void lsrv(Register rd, Register rn, Register rm) {
     EmitMiscDP2Source(LSRV, rd, rn, rm, kDoubleWord);
   }
   void asrv(Register rd, Register rn, Register rm) {
     EmitMiscDP2Source(ASRV, rd, rn, rm, kDoubleWord);
   }
   void madd(Register rd, Register rn, Register rm, Register ra) {
     EmitMiscDP3Source(MADD, rd, rn, rm, ra, kDoubleWord);
   }
+  void msub(Register rd, Register rn, Register rm, Register ra) {
+    EmitMiscDP3Source(MSUB, rd, rn, rm, ra, kDoubleWord);
+  }
+  void smulh(Register rd, Register rn, Register rm) {
+    EmitMiscDP3Source(SMULH, rd, rn, rm, R0, kDoubleWord);
+  }
 
   // Move wide immediate.
   void movk(Register rd, uint16_t imm, int hw_idx) {
     ASSERT(rd != SP);
     const Register crd = ConcreteRegister(rd);
     EmitMoveWideOp(MOVK, crd, imm, hw_idx, kDoubleWord);
   }
   void movn(Register rd, uint16_t imm, int hw_idx) {
     ASSERT(rd != SP);
     const Register crd = ConcreteRegister(rd);
@@ skipping 89 matching lines @@
     }
     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));
   }
+  void fmovdd(VRegister vd, VRegister vn) {
+    EmitFPOneSourceOp(FMOVDD, vd, vn);
+  }
 
   void fldrd(VRegister vt, Address a) {
     ASSERT(a.type() != Address::PCOffset);
     EmitLoadStoreReg(FLDR, static_cast<Register>(vt), a, kDoubleWord);
   }
   void fstrd(VRegister vt, Address a) {
     ASSERT(a.type() != Address::PCOffset);
     EmitLoadStoreReg(FSTR, static_cast<Register>(vt), a, kDoubleWord);
   }
 
   // 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));
+    orn(rd, ZR, Operand(rm));
   }
   void neg(Register rd, Register rm) {
     sub(rd, ZR, Operand(rm));
   }
   void negs(Register rd, Register rm) {
     subs(rd, ZR, Operand(rm));
   }
   void mul(Register rd, Register rn, Register rm) {
     madd(rd, rn, rm, ZR);
   }
@@ skipping 74 matching lines @@
   void BranchLinkPatchable(const ExternalLabel* label) {
     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 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);
   }
   void LoadDFromOffset(VRegister dest, Register base, int32_t offset);
   void LoadDFieldFromOffset(VRegister dest, Register base, int32_t offset) {
@@ skipping 430 matching lines @@
   }
 
   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 EmitFPOneSourceOp(FPOneSourceOp op, VRegister vd, VRegister vn) {
+    const int32_t encoding =
+      op |
+      (static_cast<int32_t>(vd) << kVdShift) |
+      (static_cast<int32_t>(vn) << kVnShift);
+    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_