Enables more tests for SIMMIPS.

runtime/vm/assembler_arm_test.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/assembler.h"
 #include "vm/os.h"
 #include "vm/unit_test.h"
@@ skipping 171 matching lines @@
 ASSEMBLER_TEST_GENERATE(SingleFPOperations, assembler) {
   __ LoadSImmediate(S0, 12.3f);
   __ LoadSImmediate(S1, 3.4f);
   __ vnegs(S0, S0);  // -12.3f
   __ vabss(S0, S0);  // 12.3f
   __ vadds(S0, S0, S1);  // 15.7f
   __ vmuls(S0, S0, S1);  // 53.38f
   __ vsubs(S0, S0, S1);  // 49.98f
   __ vdivs(S0, S0, S1);  // 14.7f
   __ vsqrts(S0, S0);  // 3.8340579f
-  __ vmovrs(R0, S0);
   __ bx(LR);
 }
 
 
 ASSEMBLER_TEST_RUN(SingleFPOperations, test) {
   EXPECT(test != NULL);
   typedef float (*SingleFPOperations)();
   float res = EXECUTE_TEST_CODE_FLOAT(SingleFPOperations, test->entry());
   EXPECT_FLOAT_EQ(3.8340579f, res, 0.001f);
 }
 
 
 ASSEMBLER_TEST_GENERATE(DoubleFPOperations, assembler) {
   __ LoadDImmediate(D0, 12.3, R0);
   __ LoadDImmediate(D1, 3.4, R0);
   __ vnegd(D0, D0);  // -12.3
   __ vabsd(D0, D0);  // 12.3
   __ vaddd(D0, D0, D1);  // 15.7
   __ vmuld(D0, D0, D1);  // 53.38
   __ vsubd(D0, D0, D1);  // 49.98
   __ vdivd(D0, D0, D1);  // 14.7
   __ vsqrtd(D0, D0);  // 3.8340579
-  __ vmovrrd(R0, R1, D0);
   __ bx(LR);
 }
 
 
 ASSEMBLER_TEST_RUN(DoubleFPOperations, test) {
   EXPECT(test != NULL);
   typedef double (*DoubleFPOperations)();
   double res = EXECUTE_TEST_CODE_DOUBLE(DoubleFPOperations, test->entry());
   EXPECT_FLOAT_EQ(3.8340579, res, 0.001);
 }
@@ skipping 14 matching lines @@
 ASSEMBLER_TEST_RUN(DoubleSqrtNeg, test) {
   EXPECT(test != NULL);
   typedef int (*DoubleSqrtNeg)();
   EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(DoubleSqrtNeg, test->entry()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(IntToDoubleConversion, assembler) {
   __ mov(R3, ShifterOperand(6));
   __ vmovsr(S3, R3);
-  __ vcvtdi(D1, S3);
-  __ vmovrrd(R0, R1, D1);
+  __ vcvtdi(D0, S3);
   __ bx(LR);
 }
 
 
 ASSEMBLER_TEST_RUN(IntToDoubleConversion, test) {
   typedef double (*IntToDoubleConversionCode)();
   EXPECT(test != NULL);
   double res = EXECUTE_TEST_CODE_DOUBLE(IntToDoubleConversionCode,
                                         test->entry());
   EXPECT_FLOAT_EQ(6.0, res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(LongToDoubleConversion, assembler) {
   int64_t value = 60000000000LL;
   __ LoadImmediate(R0, Utils::Low32Bits(value));
   __ LoadImmediate(R1, Utils::High32Bits(value));
   __ vmovsr(S0, R0);
   __ vmovsr(S2, R1);
   __ vcvtdu(D0, S0);
   __ vcvtdi(D1, S2);
   __ LoadDImmediate(D2, 1.0 * (1LL << 32), R0);
   __ vmlad(D0, D1, D2);
-  __ vmovrrd(R0, R1, D0);
   __ bx(LR);
 }
 
 
 ASSEMBLER_TEST_RUN(LongToDoubleConversion, test) {
   typedef double (*LongToDoubleConversionCode)();
   EXPECT(test != NULL);
   double res = EXECUTE_TEST_CODE_DOUBLE(LongToDoubleConversionCode,
                                         test->entry());
   EXPECT_FLOAT_EQ(60000000000.0, res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(IntToFloatConversion, assembler) {
   __ mov(R3, ShifterOperand(6));
   __ vmovsr(S3, R3);
-  __ vcvtsi(S1, S3);
-  __ vmovrs(R0, S1);
+  __ vcvtsi(S0, S3);
   __ bx(LR);
 }
 
 
 ASSEMBLER_TEST_RUN(IntToFloatConversion, test) {
   typedef float (*IntToFloatConversionCode)();
   EXPECT(test != NULL);
   float res = EXECUTE_TEST_CODE_FLOAT(IntToFloatConversionCode, test->entry());
   EXPECT_FLOAT_EQ(6.0, res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(FloatToIntConversion, assembler) {
-  __ vmovsr(S1, R0);
-  __ vcvtis(S0, S1);
-  __ vmovrs(R0, S0);
+  __ vcvtis(S1, S0);
+  __ vmovrs(R0, S1);
   __ bx(LR);
 }
 
 
 ASSEMBLER_TEST_RUN(FloatToIntConversion, test) {
   typedef int (*FloatToIntConversion)(float arg);
   EXPECT(test != NULL);
   EXPECT_EQ(12,
             EXECUTE_TEST_CODE_INT32_F(FloatToIntConversion, test->entry(),
                                       12.8f));
   EXPECT_EQ(INT_MIN,
             EXECUTE_TEST_CODE_INT32_F(FloatToIntConversion, test->entry(),
                                       -FLT_MAX));
   EXPECT_EQ(INT_MAX,
             EXECUTE_TEST_CODE_INT32_F(FloatToIntConversion, test->entry(),
                                       FLT_MAX));
 }
 
 
 ASSEMBLER_TEST_GENERATE(DoubleToIntConversion, assembler) {
-  __ vmovdrr(D1, R0, R1);
-  __ vcvtid(S0, D1);
+  __ vcvtid(S0, D0);
   __ vmovrs(R0, S0);
   __ bx(LR);
 }
 
 
 ASSEMBLER_TEST_RUN(DoubleToIntConversion, test) {
   typedef int (*DoubleToIntConversion)(double arg);
   EXPECT(test != NULL);
   EXPECT_EQ(12,
             EXECUTE_TEST_CODE_INT32_D(DoubleToIntConversion, test->entry(),
                                       12.8));
   EXPECT_EQ(INT_MIN,
             EXECUTE_TEST_CODE_INT32_D(DoubleToIntConversion, test->entry(),
                                       -DBL_MAX));
   EXPECT_EQ(INT_MAX,
             EXECUTE_TEST_CODE_INT32_D(DoubleToIntConversion, test->entry(),
                                       DBL_MAX));
 }
 
 
 ASSEMBLER_TEST_GENERATE(FloatToDoubleConversion, assembler) {
-  __ LoadSImmediate(S1, 12.8f);
-  __ vcvtds(D2, S1);
-  __ vmovrrd(R0, R1, D2);
+  __ LoadSImmediate(S2, 12.8f);
+  __ vcvtds(D0, S2);
   __ bx(LR);
 }
 
 
 ASSEMBLER_TEST_RUN(FloatToDoubleConversion, test) {
   typedef double (*FloatToDoubleConversionCode)();
   EXPECT(test != NULL);
   double res = EXECUTE_TEST_CODE_DOUBLE(FloatToDoubleConversionCode,
                                         test->entry());
   EXPECT_FLOAT_EQ(12.8, res, 0.001);
 }
 
 
 ASSEMBLER_TEST_GENERATE(DoubleToFloatConversion, assembler) {
   __ LoadDImmediate(D1, 12.8, R0);
-  __ vcvtsd(S3, D1);
-  __ vmovrs(R0, S3);
+  __ vcvtsd(S0, D1);
   __ bx(LR);
 }
 
 
 ASSEMBLER_TEST_RUN(DoubleToFloatConversion, test) {
   typedef float (*DoubleToFloatConversionCode)();
   EXPECT(test != NULL);
   float res = EXECUTE_TEST_CODE_FLOAT(DoubleToFloatConversionCode,
                                       test->entry());
   EXPECT_FLOAT_EQ(12.8, res, 0.001);
@@ skipping 1183 matching lines @@
   __ StoreIntoObject(R2,
                      FieldAddress(R2, GrowableObjectArray::data_offset()),
                      R1);
   __ PopList((1 << CTX) | (1 << LR));
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM