Fixes ARM multiplication instruction version checking.

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 899 matching lines @@
   __ str(R0, Address(R6, Bigint::kBytesPerDigit, Address::PostIndex));
   __ b(&carry_loop, NE);
 
   __ Bind(&done);
   // Returning Object::null() is not required, since this method is private.
   __ Ret();
 }
 
 
 void Intrinsifier::Bigint_mulAdd(Assembler* assembler) {
-  if (TargetCPUFeatures::arm_version() != ARMv7) {
-    return;
-  }
   // Pseudo code:
   // static int _mulAdd(Uint32List x_digits, int xi,
   //                    Uint32List m_digits, int i,
   //                    Uint32List a_digits, int j, int n) {
   //   uint32_t x = x_digits[xi >> 1];  // xi is Smi.
   //   if (x == 0 || n == 0) {
   //     return 1;
   //   }
   //   uint32_t* mip = &m_digits[i >> 1];  // i is Smi.
   //   uint32_t* ajp = &a_digits[j >> 1];  // j is Smi.
@@ skipping 82 matching lines @@
   __ str(R0, Address(R5, Bigint::kBytesPerDigit, Address::PostIndex));
   __ b(&propagate_carry_loop, CS);
 
   __ Bind(&done);
   __ mov(R0, Operand(Smi::RawValue(1)));  // One digit processed.
   __ Ret();
 }
 
 
 void Intrinsifier::Bigint_sqrAdd(Assembler* assembler) {
-  if (TargetCPUFeatures::arm_version() != ARMv7) {
-    return;
-  }
   // Pseudo code:
   // static int _sqrAdd(Uint32List x_digits, int i,
   //                    Uint32List a_digits, int used) {
   //   uint32_t* xip = &x_digits[i >> 1];  // i is Smi.
   //   uint32_t x = *xip++;
   //   if (x == 0) return 1;
   //   uint32_t* ajp = &a_digits[i];  // j == 2*i, i is Smi.
   //   uint32_t aj = *ajp;
   //   uint64_t t = x*x + aj;
   //   *ajp++ = low32(t);
@@ skipping 99 matching lines @@
   __ Ret();
 }
 
 
 void Intrinsifier::Bigint_estQuotientDigit(Assembler* assembler) {
   // No unsigned 64-bit / 32-bit divide instruction.
 }
 
 
 void Intrinsifier::Montgomery_mulMod(Assembler* assembler) {
-  if (TargetCPUFeatures::arm_version() != ARMv7) {
-    return;
-  }
   // Pseudo code:
   // static int _mulMod(Uint32List args, Uint32List digits, int i) {
   //   uint32_t rho = args[_RHO];  // _RHO == 2.
   //   uint32_t d = digits[i >> 1];  // i is Smi.
   //   uint64_t t = rho*d;
   //   args[_MU] = t mod DIGIT_BASE;  // _MU == 4.
   //   return 1;
   // }
 
   // R4 = args
@@ skipping 277 matching lines @@
     __ b(&double_op);
     __ Bind(&fall_through);
   }
 }
 
 
 //    var state = ((_A * (_state[kSTATE_LO])) + _state[kSTATE_HI]) & _MASK_64;
 //    _state[kSTATE_LO] = state & _MASK_32;
 //    _state[kSTATE_HI] = state >> 32;
 void Intrinsifier::Random_nextState(Assembler* assembler) {
-  // No 32x32 -> 64 bit multiply/accumulate on ARMv5 or ARMv6.
-  if (TargetCPUFeatures::arm_version() == ARMv7) {
-    const Library& math_lib = Library::Handle(Library::MathLibrary());
-    ASSERT(!math_lib.IsNull());
-    const Class& random_class = Class::Handle(
-        math_lib.LookupClassAllowPrivate(Symbols::_Random()));
-    ASSERT(!random_class.IsNull());
-    const Field& state_field = Field::ZoneHandle(
-        random_class.LookupInstanceField(Symbols::_state()));
-    ASSERT(!state_field.IsNull());
-    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);
+  const Library& math_lib = Library::Handle(Library::MathLibrary());
+  ASSERT(!math_lib.IsNull());
+  const Class& random_class = Class::Handle(
+      math_lib.LookupClassAllowPrivate(Symbols::_Random()));
+  ASSERT(!random_class.IsNull());
+  const Field& state_field = Field::ZoneHandle(
+      random_class.LookupInstanceField(Symbols::_state()));
+  ASSERT(!state_field.IsNull());
+  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);
 
-    __ ldr(R0, Address(SP, 0 * kWordSize));  // Receiver.
-    __ ldr(R1, FieldAddress(R0, state_field.Offset()));  // Field '_state'.
-    // Addresses of _state[0] and _state[1].
+  __ 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 = Instance::DataOffsetFor(kTypedDataUint32ArrayCid);
-    const int64_t disp_1 = disp_0 +
-        Instance::ElementSizeFor(kTypedDataUint32ArrayCid);
+  const int64_t disp_0 = Instance::DataOffsetFor(kTypedDataUint32ArrayCid);
+  const int64_t disp_1 = disp_0 +
+      Instance::ElementSizeFor(kTypedDataUint32ArrayCid);
 
-    __ LoadImmediate(R0, a_int32_value);
-    __ LoadFromOffset(kWord, R2, R1, disp_0 - kHeapObjectTag);
-    __ LoadFromOffset(kWord, R3, R1, disp_1 - kHeapObjectTag);
-    __ mov(R6, Operand(0));  // Zero extend unsigned _state[kSTATE_HI].
-    // Unsigned 32-bit multiply and 64-bit accumulate into R6:R3.
-    __ umlal(R3, R6, R0, R2);  // R6:R3 <- R6:R3 + R0 * R2.
-    __ StoreToOffset(kWord, R3, R1, disp_0 - kHeapObjectTag);
-    __ StoreToOffset(kWord, R6, R1, disp_1 - kHeapObjectTag);
-    __ Ret();
-  }
+  __ LoadImmediate(R0, a_int32_value);
+  __ LoadFromOffset(kWord, R2, R1, disp_0 - kHeapObjectTag);
+  __ LoadFromOffset(kWord, R3, R1, disp_1 - kHeapObjectTag);
+  __ mov(R6, Operand(0));  // Zero extend unsigned _state[kSTATE_HI].
+  // Unsigned 32-bit multiply and 64-bit accumulate into R6:R3.
+  __ umlal(R3, R6, R0, R2);  // R6:R3 <- R6:R3 + R0 * R2.
+  __ StoreToOffset(kWord, R3, R1, disp_0 - kHeapObjectTag);
+  __ StoreToOffset(kWord, R6, R1, disp_1 - kHeapObjectTag);
+  __ Ret();
 }
 
 
 void Intrinsifier::ObjectEquals(Assembler* assembler) {
   __ ldr(R0, Address(SP, 0 * kWordSize));
   __ ldr(R1, Address(SP, 1 * kWordSize));
   __ cmp(R0, Operand(R1));
   __ LoadObject(R0, Bool::False(), NE);
   __ LoadObject(R0, Bool::True(), EQ);
   __ Ret();
@@ skipping 459 matching lines @@
   Isolate* isolate = Isolate::Current();
   __ LoadImmediate(R1, reinterpret_cast<uword>(isolate));
   // Set return value to Isolate::current_tag_.
   __ ldr(R0, Address(R1, Isolate::current_tag_offset()));
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM