Enable language tests on SIMARM and mark 14 of them as failing.

runtime/vm/intrinsifier_arm.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"  // Needed here to get TARGET_ARCH_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 815 matching lines @@
 }
 
 
 bool Intrinsifier::Integer_bitOr(Assembler* assembler) {
   return Integer_bitOrFromInteger(assembler);
 }
 
 
 bool Intrinsifier::Integer_bitXorFromInteger(Assembler* assembler) {
   Label fall_through;
-  __ Untested("Intrinsifier::Integer_bitXorFromInteger");
 
   TestBothArgumentsSmis(assembler, &fall_through);  // checks two smis
   __ eor(R0, R0, ShifterOperand(R1));
 
   __ Ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
@@ skipping 272 matching lines @@
 // Both arguments on stack, arg0 (left) is a double, arg1 (right) is of unknown
 // type. Return true or false object in the register R0. Any NaN argument
 // returns false. Any non-double arg1 causes control flow to fall through to the
 // slow case (compiled method body).
 static bool CompareDoubles(Assembler* assembler, Condition true_condition) {
   Label fall_through, is_smi, double_op;
 
   TestLastArgumentIsDouble(assembler, &is_smi, &fall_through);
   // Both arguments are double, right operand is in R0.
 
-  __ AddImmediate(R0, Double::value_offset() - kHeapObjectTag);
-  __ vldrd(D1, Address(R0));
+  __ LoadDFromOffset(D1, R0, Double::value_offset() - kHeapObjectTag);
   __ Bind(&double_op);
   __ ldr(R0, Address(SP, 1 * kWordSize));  // Left argument.
-  __ AddImmediate(R0, Double::value_offset() - kHeapObjectTag);
-  __ vldrd(D0, Address(R0));
+  __ LoadDFromOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
 
   __ vcmpd(D0, D1);
   __ vmstat();
   __ LoadObject(R0, Bool::False());
   // Return false if D0 or D1 was NaN before checking true condition.
   __ bx(LR, VS);
   __ LoadObject(R0, Bool::True(), true_condition);
   __ Ret();
 
   __ Bind(&is_smi);  // Convert R0 to a double.
@@ skipping 31 matching lines @@
 }
 
 
 // Expects left argument to be double (receiver). Right argument is unknown.
 // Both arguments are on stack.
 static bool DoubleArithmeticOperations(Assembler* assembler, Token::Kind kind) {
   Label fall_through;
 
   TestLastArgumentIsDouble(assembler, &fall_through, &fall_through);
   // Both arguments are double, right operand is in R0.
-  // Can't use FieldAddress here. R0 is heap-object-tagged, so the offset will
-  // not be 4-byte aligned.
-  __ AddImmediate(R0, Double::value_offset() - kHeapObjectTag);
-  __ vldrd(D1, Address(R0));
+  __ LoadDFromOffset(D1, R0, Double::value_offset() - kHeapObjectTag);
   __ ldr(R0, Address(SP, 1 * kWordSize));  // Left argument.
-  __ AddImmediate(R0, Double::value_offset() - kHeapObjectTag);
-  __ vldrd(D0, Address(R0));
+  __ LoadDFromOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   switch (kind) {
     case Token::kADD: __ vaddd(D0, D0, D1); break;
     case Token::kSUB: __ vsubd(D0, D0, D1); break;
     case Token::kMUL: __ vmuld(D0, D0, D1); break;
     case Token::kDIV: __ vdivd(D0, D0, D1); break;
     default: UNREACHABLE();
   }
   const Class& double_class = Class::Handle(
       Isolate::Current()->object_store()->double_class());
   __ TryAllocate(double_class, &fall_through, R0);  // Result register.
-  __ AddImmediate(R1, R0, Double::value_offset() - kHeapObjectTag);
-  __ vstrd(D0, Address(R1));
+  __ StoreDToOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   __ Ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 bool Intrinsifier::Double_add(Assembler* assembler) {
   return DoubleArithmeticOperations(assembler, Token::kADD);
 }
 
@@ skipping 43 matching lines @@
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ tst(R0, ShifterOperand(kSmiTagMask));
   __ b(&fall_through, NE);
   // Is Smi.
   __ SmiUntag(R0);
   __ vmovsr(S0, R0);
   __ vcvtdi(D0, S0);
   const Class& double_class = Class::Handle(
       Isolate::Current()->object_store()->double_class());
   __ TryAllocate(double_class, &fall_through, R0);  // Result register.
-  __ AddImmediate(R1, R0, Double::value_offset() - kHeapObjectTag);
-  __ vstrd(D0, Address(R1));
+  __ StoreDToOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   __ Ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 bool Intrinsifier::Double_getIsNaN(Assembler* assembler) {
   Label is_true;
   __ ldr(R0, Address(SP, 0 * kWordSize));
-  __ AddImmediate(R0, Double::value_offset() - kHeapObjectTag);
-  __ vldrd(D0, Address(R0));
+  __ LoadDFromOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   __ vcmpd(D0, D0);
   __ vmstat();
   __ LoadObject(R0, Bool::False(), VC);
   __ LoadObject(R0, Bool::True(), VS);
   __ Ret();
   return true;
 }
 
 
 bool Intrinsifier::Double_getIsNegative(Assembler* assembler) {
   Label is_false, is_true, is_zero;
-  __ Untested("Intrinsifier::Double_getIsNegative");
   __ ldr(R0, Address(SP, 0 * kWordSize));
-  __ AddImmediate(R0, Double::value_offset() - kHeapObjectTag);
-  __ vldrd(D0, Address(R0));
+  __ LoadDFromOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   __ LoadDImmediate(D1, 0.0, R1);
   __ vcmpd(D0, D1);
   __ vmstat();
   __ b(&is_false, VS);  // NaN -> false.
   __ b(&is_zero, EQ);  // Check for negative zero.
   __ b(&is_false, CS);  // >= 0 -> false.
 
   __ Bind(&is_true);
   __ LoadObject(R0, Bool::True());
   __ Ret();
 
   __ Bind(&is_false);
   __ LoadObject(R0, Bool::False());
   __ Ret();
 
   __ Bind(&is_zero);
   // Check for negative zero by looking at the sign bit.
   __ vmovrrd(R0, R1, D0);  // R1:R0 <- D0, so sign bit is in bit 31 of R1.
   __ mov(R1, ShifterOperand(R1, LSR, 31));
   __ tst(R1, ShifterOperand(1));
   __ b(&is_true, NE);  // Sign bit set.
   __ b(&is_false);
   return true;
 }
 
 
 bool Intrinsifier::Double_toInt(Assembler* assembler) {
   __ ldr(R0, Address(SP, 0 * kWordSize));
-  __ AddImmediate(R0, Double::value_offset() - kHeapObjectTag);
-  __ vldrd(D0, Address(R0));
+  __ LoadDFromOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   __ vcvtid(S0, D0);
   __ vmovrs(R0, S0);
   // Overflow is signaled with minint.
   Label fall_through;
   // Check for overflow and that it fits into Smi.
   __ CompareImmediate(R0, 0xC0000000);
   __ b(&fall_through, MI);
   __ SmiTag(R0);
   __ Ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 bool Intrinsifier::Math_sqrt(Assembler* assembler) {
   Label fall_through, is_smi, double_op;
-  __ Untested("Intrinsifier::Math_sqrt");
   TestLastArgumentIsDouble(assembler, &is_smi, &fall_through);
   // Argument is double and is in R0.
-  __ AddImmediate(R0, Double::value_offset() - kHeapObjectTag);
-  __ vldrd(D1, Address(R0));
+  __ LoadDFromOffset(D1, R0, Double::value_offset() - kHeapObjectTag);
   __ Bind(&double_op);
   __ vsqrtd(D0, D1);
   const Class& double_class = Class::Handle(
       Isolate::Current()->object_store()->double_class());
   __ TryAllocate(double_class, &fall_through, R0);  // Result register.
-  __ AddImmediate(R1, R0, Double::value_offset() - kHeapObjectTag);
-  __ vstrd(D0, Address(R1));
+  __ StoreDToOffset(D0, R0, Double::value_offset() - kHeapObjectTag);
   __ Ret();
   __ Bind(&is_smi);
   __ SmiUntag(R0);
   __ vmovsr(S0, R0);
   __ vcvtdi(D1, S0);
   __ b(&double_op);
   __ Bind(&fall_through);
   return false;
 }
 
@@ skipping 23 matching lines @@
   const Field& random_A_field = Field::ZoneHandle(
       random_class.LookupStaticField(Symbols::_A()));
   ASSERT(!random_A_field.IsNull());
   ASSERT(random_A_field.is_const());
   const Instance& a_value = Instance::Handle(random_A_field.value());
   const int64_t a_int_value = Integer::Cast(a_value).AsInt64Value();
   // 'a_int_value' is a mask.
   ASSERT(Utils::IsUint(32, a_int_value));
   int32_t a_int32_value = static_cast<int32_t>(a_int_value);
 
-  __ Untested("Random_nextState");
-
   __ ldr(R0, Address(SP, 0 * kWordSize));  // Receiver.
   __ ldr(R1, FieldAddress(R0, state_field.Offset()));  // Field '_state'.
   // Addresses of _state[0] and _state[1].
 
   const int64_t disp_0 =
       FlowGraphCompiler::DataOffsetFor(kTypedDataUint32ArrayCid);
 
   const int64_t disp_1 =
       FlowGraphCompiler::ElementSizeFor(kTypedDataUint32ArrayCid) +
       FlowGraphCompiler::DataOffsetFor(kTypedDataUint32ArrayCid);
@@ skipping 288 matching lines @@
   __ Bind(&ok);
   __ Ret();
 
   __ Bind(&fall_through);
   return false;
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM