Avoids vmovsr on ARM.

runtime/vm/intermediate_language_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/intermediate_language.h"
 
 #include "vm/cpu.h"
@@ skipping 3604 matching lines @@
 void UnboxDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   CompileType* value_type = value()->Type();
   const intptr_t value_cid = value_type->ToCid();
   const Register value = locs()->in(0).reg();
   const DRegister result = EvenDRegisterOf(locs()->out(0).fpu_reg());
 
   if (value_cid == kDoubleCid) {
     __ LoadDFromOffset(result, value, Double::value_offset() - kHeapObjectTag);
   } else if (value_cid == kSmiCid) {
     __ SmiUntag(IP, value);
-    __ vmovsr(STMP, IP);
+    __ vmovdr(DTMP, 0, IP);
     __ vcvtdi(result, STMP);
   } else {
     Label* deopt = compiler->AddDeoptStub(deopt_id_,
                                           ICData::kDeoptBinaryDoubleOp);
     const Register temp = locs()->temp(0).reg();
     if (value_type->is_nullable() &&
         (value_type->ToNullableCid() == kDoubleCid)) {
       __ CompareImmediate(value, reinterpret_cast<intptr_t>(Object::null()));
       __ b(deopt, EQ);
       // It must be double now.
       __ LoadDFromOffset(result, value,
           Double::value_offset() - kHeapObjectTag);
     } else {
       Label is_smi, done;
       __ tst(value, Operand(kSmiTagMask));
       __ b(&is_smi, EQ);
       __ CompareClassId(value, kDoubleCid, temp);
       __ b(deopt, NE);
       __ LoadDFromOffset(result, value,
           Double::value_offset() - kHeapObjectTag);
       __ b(&done);
       __ Bind(&is_smi);
       __ SmiUntag(IP, value);
-      __ vmovsr(STMP, IP);
+      __ vmovdr(DTMP, 0, IP);
       __ vcvtdi(result, STMP);
       __ Bind(&done);
     }
   }
 }
 
 
 LocationSummary* BoxFloat32x4Instr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
   const intptr_t kNumInputs = 1;
@@ skipping 1127 matching lines @@
 LocationSummary* Int32x4ConstructorInstr::MakeLocationSummary(
     Isolate* isolate, bool opt) const {
   const intptr_t kNumInputs = 4;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_in(1, Location::RequiresRegister());
   summary->set_in(2, Location::RequiresRegister());
   summary->set_in(3, Location::RequiresRegister());
-  // Low (< 7) Q register needed for the vmovsr instruction.
-  summary->set_out(0, Location::FpuRegisterLocation(Q6));
+  summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void Int32x4ConstructorInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register v0 = locs()->in(0).reg();
   const Register v1 = locs()->in(1).reg();
   const Register v2 = locs()->in(2).reg();
   const Register v3 = locs()->in(3).reg();
   const QRegister result = locs()->out(0).fpu_reg();
   const DRegister dresult0 = EvenDRegisterOf(result);
   const DRegister dresult1 = OddDRegisterOf(result);
-  const SRegister sresult0 = EvenSRegisterOf(dresult0);
-  const SRegister sresult1 = OddSRegisterOf(dresult0);
-  const SRegister sresult2 = EvenSRegisterOf(dresult1);
-  const SRegister sresult3 = OddSRegisterOf(dresult1);
   __ veorq(result, result, result);
-  __ vmovsr(sresult0, v0);
-  __ vmovsr(sresult1, v1);
-  __ vmovsr(sresult2, v2);
-  __ vmovsr(sresult3, v3);
+  __ vmovdrr(dresult0, v0, v1);
+  __ vmovdrr(dresult1, v2, v3);
 }
 
 
 LocationSummary* Int32x4BoolConstructorInstr::MakeLocationSummary(
     Isolate* isolate, bool opt) const {
   const intptr_t kNumInputs = 4;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_in(1, Location::RequiresRegister());
   summary->set_in(2, Location::RequiresRegister());
   summary->set_in(3, Location::RequiresRegister());
   summary->set_temp(0, Location::RequiresRegister());
-  // Low (< 7) Q register needed for the vmovsr instruction.
-  summary->set_out(0, Location::FpuRegisterLocation(Q6));
+  summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void Int32x4BoolConstructorInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register v0 = locs()->in(0).reg();
   const Register v1 = locs()->in(1).reg();
   const Register v2 = locs()->in(2).reg();
   const Register v3 = locs()->in(3).reg();
   const Register temp = locs()->temp(0).reg();
   const QRegister result = locs()->out(0).fpu_reg();
   const DRegister dresult0 = EvenDRegisterOf(result);
   const DRegister dresult1 = OddDRegisterOf(result);
-  const SRegister sresult0 = EvenSRegisterOf(dresult0);
-  const SRegister sresult1 = OddSRegisterOf(dresult0);
-  const SRegister sresult2 = EvenSRegisterOf(dresult1);
-  const SRegister sresult3 = OddSRegisterOf(dresult1);
 
   __ veorq(result, result, result);
   __ LoadImmediate(temp, 0xffffffff);
 
-  __ CompareObject(v0, Bool::True());
-  __ vmovsr(sresult0, temp, EQ);
+  __ LoadObject(IP, Bool::True());
+  __ cmp(v0, Operand(IP));
+  __ vmovdr(dresult0, 0, temp, EQ);
 
-  __ CompareObject(v1, Bool::True());
-  __ vmovsr(sresult1, temp, EQ);
+  __ cmp(v1, Operand(IP));
+  __ vmovdr(dresult0, 1, temp, EQ);
 
-  __ CompareObject(v2, Bool::True());
-  __ vmovsr(sresult2, temp, EQ);
+  __ cmp(v2, Operand(IP));
+  __ vmovdr(dresult1, 0, temp, EQ);
 
-  __ CompareObject(v3, Bool::True());
-  __ vmovsr(sresult3, temp, EQ);
+  __ cmp(v3, Operand(IP));
+  __ vmovdr(dresult1, 1, temp, EQ);
 }
 
 
 LocationSummary* Int32x4GetFlagInstr::MakeLocationSummary(Isolate* isolate,
                                                           bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   // Low (< 7) Q registers are needed for the vmovrs instruction.
@@ skipping 72 matching lines @@
 
 
 LocationSummary* Int32x4SetFlagInstr::MakeLocationSummary(Isolate* isolate,
                                                           bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresFpuRegister());
   summary->set_in(1, Location::RequiresRegister());
-  // Low (< 7) Q register needed for the vmovsr instruction.
-  summary->set_out(0, Location::FpuRegisterLocation(Q6));
+  summary->set_out(0, Location::RequiresFpuRegister());
   return summary;
 }
 
 
 void Int32x4SetFlagInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const QRegister mask = locs()->in(0).fpu_reg();
   const Register flag = locs()->in(1).reg();
   const QRegister result = locs()->out(0).fpu_reg();
 
   const DRegister dresult0 = EvenDRegisterOf(result);
   const DRegister dresult1 = OddDRegisterOf(result);
-  const SRegister sresult0 = EvenSRegisterOf(dresult0);
-  const SRegister sresult1 = OddSRegisterOf(dresult0);
-  const SRegister sresult2 = EvenSRegisterOf(dresult1);
-  const SRegister sresult3 = OddSRegisterOf(dresult1);
 
   if (result != mask) {
     __ vmovq(result, mask);
   }
 
   __ CompareObject(flag, Bool::True());
   __ LoadImmediate(TMP, 0xffffffff, EQ);
   __ LoadImmediate(TMP, 0, NE);
   switch (op_kind()) {
     case MethodRecognizer::kInt32x4WithFlagX:
-      __ vmovsr(sresult0, TMP);
+      __ vmovdr(dresult0, 0, TMP);
       break;
     case MethodRecognizer::kInt32x4WithFlagY:
-      __ vmovsr(sresult1, TMP);
+      __ vmovdr(dresult0, 1, TMP);
       break;
     case MethodRecognizer::kInt32x4WithFlagZ:
-      __ vmovsr(sresult2, TMP);
+      __ vmovdr(dresult1, 0, TMP);
       break;
     case MethodRecognizer::kInt32x4WithFlagW:
-      __ vmovsr(sresult3, TMP);
+      __ vmovdr(dresult1, 1, TMP);
       break;
     default: UNREACHABLE();
   }
 }
 
 
 LocationSummary* Int32x4ToFloat32x4Instr::MakeLocationSummary(Isolate* isolate,
                                                               bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
@@ skipping 248 matching lines @@
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   result->set_in(0, Location::RequiresRegister());
   result->set_out(0, Location::RequiresFpuRegister());
   return result;
 }
 
 
 void Int32ToDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register value = locs()->in(0).reg();
   const DRegister result = EvenDRegisterOf(locs()->out(0).fpu_reg());
-  __ vmovsr(STMP, value);
+  __ vmovdr(DTMP, 0, value);
   __ vcvtdi(result, STMP);
 }
 
 
 LocationSummary* SmiToDoubleInstr::MakeLocationSummary(Isolate* isolate,
                                                        bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* result = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
   result->set_in(0, Location::RequiresRegister());
   result->set_out(0, Location::RequiresFpuRegister());
   return result;
 }
 
 
 void SmiToDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register value = locs()->in(0).reg();
   const DRegister result = EvenDRegisterOf(locs()->out(0).fpu_reg());
   __ SmiUntag(IP, value);
-  __ vmovsr(STMP, IP);
+  __ vmovdr(DTMP, 0, IP);
   __ vcvtdi(result, STMP);
 }
 
 
 LocationSummary* MintToDoubleInstr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
   UNIMPLEMENTED();
   return NULL;
 }
 
@@ skipping 1734 matching lines @@
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ LoadImmediate(R4, kInvalidObjectPointer);
   __ LoadImmediate(R5, kInvalidObjectPointer);
 #endif
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM