Use more fpu multi-load/store instructions 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/dart_entry.h"
@@ skipping 1063 matching lines @@
     __ AddImmediate(index.reg(),
         FlowGraphCompiler::DataOffsetFor(class_id()) - kHeapObjectTag);
   }
   element_address = Address(array, index.reg(), LSL, 0);
 
   if ((representation() == kUnboxedDouble)    ||
       (representation() == kUnboxedMint)      ||
       (representation() == kUnboxedFloat32x4) ||
       (representation() == kUnboxedInt32x4)   ||
       (representation() == kUnboxedFloat64x2)) {
-    QRegister result = locs()->out(0).fpu_reg();
-    DRegister dresult0 = EvenDRegisterOf(result);
-    DRegister dresult1 = OddDRegisterOf(result);
-    Register idx = index.reg();
+    const QRegister result = locs()->out(0).fpu_reg();
+    const DRegister dresult0 = EvenDRegisterOf(result);
+    const Register idx = index.reg();
     switch (class_id()) {
       case kTypedDataInt32ArrayCid:
         __ veorq(result, result, result);
         __ ldr(TMP, element_address);
         // Re-use the index register so we don't have to require a low-numbered
         // Q register.
         // Sign-extend into idx.
         __ Asr(idx, TMP, 31);
         __ vmovdrr(dresult0, TMP, idx);
         break;
@@ skipping 15 matching lines @@
       case kTypedDataFloat64ArrayCid:
         // vldrd does not support indexed addressing.
         __ add(index.reg(), index.reg(), ShifterOperand(array));
         element_address = Address(index.reg(), 0);
         __ vldrd(dresult0, element_address);
         break;
       case kTypedDataFloat64x2ArrayCid:
       case kTypedDataInt32x4ArrayCid:
       case kTypedDataFloat32x4ArrayCid:
         __ add(index.reg(), index.reg(), ShifterOperand(array));
-        // TODO(zra): Maybe use vldmd here.
-        __ LoadDFromOffset(dresult0, index.reg(), 0);
-        __ LoadDFromOffset(dresult1, index.reg(), 2 * kWordSize);
+        __ vldmd(IA, index.reg(), dresult0, 2);
         break;
     }
     return;
   }
 
   Register result = locs()->out(0).reg();
   switch (class_id()) {
     case kTypedDataInt8ArrayCid:
       ASSERT(index_scale() == 1);
       __ ldrsb(result, element_address);
@@ skipping 258 matching lines @@
     }
     case kTypedDataFloat64ArrayCid: {
       DRegister in2 = EvenDRegisterOf(locs()->in(2).fpu_reg());
       __ add(index.reg(), index.reg(), ShifterOperand(array));
       __ StoreDToOffset(in2, index.reg(), 0);
       break;
     }
     case kTypedDataFloat64x2ArrayCid:
     case kTypedDataInt32x4ArrayCid:
     case kTypedDataFloat32x4ArrayCid: {
-      QRegister in = locs()->in(2).fpu_reg();
-      DRegister din0 = EvenDRegisterOf(in);
-      DRegister din1 = OddDRegisterOf(in);
+      const QRegister in = locs()->in(2).fpu_reg();
+      const DRegister din0 = EvenDRegisterOf(in);
       __ add(index.reg(), index.reg(), ShifterOperand(array));
-      __ StoreDToOffset(din0, index.reg(), 0);
-      __ StoreDToOffset(din1, index.reg(), 2 * kWordSize);
+      __ vstmd(IA, index.reg(), din0, 2);
       break;
     }
     default:
       UNREACHABLE();
   }
 }
 
 
 LocationSummary* GuardFieldInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
@@ skipping 380 matching lines @@
   return summary;
 }
 
 
 void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label skip_store;
 
   Register instance_reg = locs()->in(0).reg();
 
   if (IsUnboxedStore() && compiler->is_optimizing()) {
-    DRegister value = EvenDRegisterOf(locs()->in(1).fpu_reg());
-    DRegister value_odd = OddDRegisterOf(locs()->in(1).fpu_reg());
-    Register temp = locs()->temp(0).reg();
-    Register temp2 = locs()->temp(1).reg();
+    const DRegister value = EvenDRegisterOf(locs()->in(1).fpu_reg());
+    const Register temp = locs()->temp(0).reg();
+    const Register temp2 = locs()->temp(1).reg();
     const intptr_t cid = field().UnboxedFieldCid();
 
     if (is_initialization_) {
       const Class* cls = NULL;
       switch (cid) {
         case kDoubleCid:
           cls = &compiler->double_class();
           break;
         case kFloat32x4Cid:
           cls = &compiler->float32x4_class();
@@ skipping 21 matching lines @@
     } else {
       __ ldr(temp, FieldAddress(instance_reg, offset_in_bytes_));
     }
     switch (cid) {
       case kDoubleCid:
         __ Comment("UnboxedDoubleStoreInstanceFieldInstr");
         __ StoreDToOffset(value, temp, Double::value_offset() - kHeapObjectTag);
         break;
       case kFloat32x4Cid:
         __ Comment("UnboxedFloat32x4StoreInstanceFieldInstr");
-        __ StoreDToOffset(value, temp,
+        __ StoreMultipleDToOffset(value, 2, temp,
             Float32x4::value_offset() - kHeapObjectTag);
-        __ StoreDToOffset(value_odd, temp,
-            Float32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
         break;
       case kFloat64x2Cid:
         __ Comment("UnboxedFloat64x2StoreInstanceFieldInstr");
-        __ StoreDToOffset(value, temp,
+        __ StoreMultipleDToOffset(value, 2, temp,
             Float64x2::value_offset() - kHeapObjectTag);
-        __ StoreDToOffset(value_odd, temp,
-            Float64x2::value_offset() + 2 * kWordSize - kHeapObjectTag);
         break;
       default:
         UNREACHABLE();
     }
 
     return;
   }
 
   if (IsPotentialUnboxedStore()) {
-    Register value_reg = locs()->in(1).reg();
-    Register temp = locs()->temp(0).reg();
-    Register temp2 = locs()->temp(1).reg();
-    DRegister fpu_temp = EvenDRegisterOf(locs()->temp(2).fpu_reg());
-    DRegister fpu_temp_odd = OddDRegisterOf(locs()->temp(2).fpu_reg());
+    const Register value_reg = locs()->in(1).reg();
+    const Register temp = locs()->temp(0).reg();
+    const Register temp2 = locs()->temp(1).reg();
+    const DRegister fpu_temp = EvenDRegisterOf(locs()->temp(2).fpu_reg());
 
     Label store_pointer;
     Label store_double;
     Label store_float32x4;
     Label store_float64x2;
 
     __ LoadObject(temp, Field::ZoneHandle(field().raw()));
 
     __ ldr(temp2, FieldAddress(temp, Field::is_nullable_offset()));
     __ CompareImmediate(temp2, kNullCid);
@@ skipping 69 matching lines @@
       __ TryAllocate(compiler->float32x4_class(),
                      slow_path->entry_label(),
                      temp,
                      temp2);
       __ Bind(slow_path->exit_label());
       __ MoveRegister(temp2, temp);
       __ StoreIntoObject(instance_reg,
                          FieldAddress(instance_reg, offset_in_bytes_),
                          temp2);
       __ Bind(&copy_float32x4);
-      // TODO(zra): Maybe use vldmd here.
-      __ LoadDFromOffset(fpu_temp, value_reg,
+      __ LoadMultipleDFromOffset(fpu_temp, 2, value_reg,
           Float32x4::value_offset() - kHeapObjectTag);
-      __ LoadDFromOffset(fpu_temp_odd, value_reg,
-          Float32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
-      __ StoreDToOffset(fpu_temp, temp,
+      __ StoreMultipleDToOffset(fpu_temp, 2, temp,
           Float32x4::value_offset() - kHeapObjectTag);
-      __ StoreDToOffset(fpu_temp_odd, temp,
-          Float32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
       __ b(&skip_store);
     }
 
     {
       __ Bind(&store_float64x2);
       Label copy_float64x2;
       StoreInstanceFieldSlowPath* slow_path =
           new StoreInstanceFieldSlowPath(this, compiler->float64x2_class());
       compiler->AddSlowPathCode(slow_path);
 
       __ ldr(temp, FieldAddress(instance_reg, offset_in_bytes_));
       __ CompareImmediate(temp,
                           reinterpret_cast<intptr_t>(Object::null()));
       __ b(&copy_float64x2, NE);
 
       __ TryAllocate(compiler->float64x2_class(),
                      slow_path->entry_label(),
                      temp,
                      temp2);
       __ Bind(slow_path->exit_label());
       __ MoveRegister(temp2, temp);
       __ StoreIntoObject(instance_reg,
                          FieldAddress(instance_reg, offset_in_bytes_),
                          temp2);
       __ Bind(&copy_float64x2);
-      // TODO(zra): Maybe use vldmd here.
-      __ LoadDFromOffset(fpu_temp, value_reg,
+      __ LoadMultipleDFromOffset(fpu_temp, 2, value_reg,
           Float64x2::value_offset() - kHeapObjectTag);
-      __ LoadDFromOffset(fpu_temp_odd, value_reg,
-          Float64x2::value_offset() + 2 * kWordSize - kHeapObjectTag);
-      __ StoreDToOffset(fpu_temp, temp,
+      __ StoreMultipleDToOffset(fpu_temp, 2, temp,
           Float64x2::value_offset() - kHeapObjectTag);
-      __ StoreDToOffset(fpu_temp_odd, temp,
-          Float64x2::value_offset() + 2 * kWordSize - kHeapObjectTag);
       __ b(&skip_store);
     }
 
     __ Bind(&store_pointer);
   }
 
   if (ShouldEmitStoreBarrier()) {
     Register value_reg = locs()->in(1).reg();
     __ StoreIntoObject(instance_reg,
                        FieldAddress(instance_reg, offset_in_bytes_),
@@ skipping 230 matching lines @@
     locs->AddTemp(Location::RequiresRegister());
   }
   locs->set_out(0, Location::RequiresRegister());
   return locs;
 }
 
 
 void LoadFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instance_reg = locs()->in(0).reg();
   if (IsUnboxedLoad() && compiler->is_optimizing()) {
-    DRegister result = EvenDRegisterOf(locs()->out(0).fpu_reg());
-    DRegister result_odd = OddDRegisterOf(locs()->out(0).fpu_reg());
-    Register temp = locs()->temp(0).reg();
+    const DRegister result = EvenDRegisterOf(locs()->out(0).fpu_reg());
+    const Register temp = locs()->temp(0).reg();
     __ ldr(temp, FieldAddress(instance_reg, offset_in_bytes()));
-    intptr_t cid = field()->UnboxedFieldCid();
+    const intptr_t cid = field()->UnboxedFieldCid();
     switch (cid) {
       case kDoubleCid:
         __ Comment("UnboxedDoubleLoadFieldInstr");
         __ LoadDFromOffset(result, temp,
                            Double::value_offset() - kHeapObjectTag);
         break;
       case kFloat32x4Cid:
         __ Comment("UnboxedFloat32x4LoadFieldInstr");
-        // TODO(zra): Maybe use vldmd here.
-        __ LoadDFromOffset(result, temp,
+        __ LoadMultipleDFromOffset(result, 2, temp,
             Float32x4::value_offset() - kHeapObjectTag);
-        __ LoadDFromOffset(result_odd, temp,
-            Float32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
         break;
       case kFloat64x2Cid:
         __ Comment("UnboxedFloat64x2LoadFieldInstr");
-        // TODO(zra): Maybe use vldmd here.
-        __ LoadDFromOffset(result, temp,
+        __ LoadMultipleDFromOffset(result, 2, temp,
             Float64x2::value_offset() - kHeapObjectTag);
-        __ LoadDFromOffset(result_odd, temp,
-            Float64x2::value_offset() + 2 * kWordSize - kHeapObjectTag);
         break;
       default:
         UNREACHABLE();
     }
     return;
   }
 
   Label done;
   Register result_reg = locs()->out(0).reg();
   if (IsPotentialUnboxedLoad()) {
-    Register temp = locs()->temp(1).reg();
-    DRegister value = EvenDRegisterOf(locs()->temp(0).fpu_reg());
-    DRegister value_odd = OddDRegisterOf(locs()->temp(0).fpu_reg());
+    const Register temp = locs()->temp(1).reg();
+    const DRegister value = EvenDRegisterOf(locs()->temp(0).fpu_reg());
 
     Label load_pointer;
     Label load_double;
     Label load_float32x4;
     Label load_float64x2;
 
     __ LoadObject(result_reg, Field::ZoneHandle(field()->raw()));
 
     FieldAddress field_cid_operand(result_reg, Field::guarded_cid_offset());
     FieldAddress field_nullability_operand(result_reg,
@@ skipping 44 matching lines @@
       __ Bind(&load_float32x4);
       BoxFloat32x4SlowPath* slow_path = new BoxFloat32x4SlowPath(this);
       compiler->AddSlowPathCode(slow_path);
 
       __ TryAllocate(compiler->float32x4_class(),
                      slow_path->entry_label(),
                      result_reg,
                      temp);
       __ Bind(slow_path->exit_label());
       __ ldr(temp, FieldAddress(instance_reg, offset_in_bytes()));
-      // TODO(zra): Maybe use vldmd here.
-      __ LoadDFromOffset(value, temp,
+      __ LoadMultipleDFromOffset(value, 2, temp,
           Float32x4::value_offset() - kHeapObjectTag);
-      __ LoadDFromOffset(value_odd, temp,
-          Float32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
-      __ StoreDToOffset(value, result_reg,
+      __ StoreMultipleDToOffset(value, 2, result_reg,
           Float32x4::value_offset() - kHeapObjectTag);
-      __ StoreDToOffset(value_odd, result_reg,
-          Float32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
       __ b(&done);
     }
 
     {
       __ Bind(&load_float64x2);
       BoxFloat64x2SlowPath* slow_path = new BoxFloat64x2SlowPath(this);
       compiler->AddSlowPathCode(slow_path);
 
       __ TryAllocate(compiler->float64x2_class(),
                      slow_path->entry_label(),
                      result_reg,
                      temp);
       __ Bind(slow_path->exit_label());
       __ ldr(temp, FieldAddress(instance_reg, offset_in_bytes()));
-      // TODO(zra): Maybe use vldmd here.
-      __ LoadDFromOffset(value, temp,
+      __ LoadMultipleDFromOffset(value, 2, temp,
           Float64x2::value_offset() - kHeapObjectTag);
-      __ LoadDFromOffset(value_odd, temp,
-          Float64x2::value_offset() + 2 * kWordSize - kHeapObjectTag);
-      __ StoreDToOffset(value, result_reg,
+      __ StoreMultipleDToOffset(value, 2, result_reg,
           Float64x2::value_offset() - kHeapObjectTag);
-      __ StoreDToOffset(value_odd, result_reg,
-          Float64x2::value_offset() + 2 * kWordSize - kHeapObjectTag);
       __ b(&done);
     }
 
     __ Bind(&load_pointer);
   }
   __ LoadFromOffset(kWord, result_reg,
                     instance_reg, offset_in_bytes() - kHeapObjectTag);
   __ Bind(&done);
 }
 
@@ skipping 822 matching lines @@
   summary->set_temp(0, Location::RequiresRegister());
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void BoxFloat32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   BoxFloat32x4SlowPath* slow_path = new BoxFloat32x4SlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
-  Register out_reg = locs()->out(0).reg();
-  QRegister value = locs()->in(0).fpu_reg();
-  DRegister value_even = EvenDRegisterOf(value);
-  DRegister value_odd = OddDRegisterOf(value);
+  const Register out_reg = locs()->out(0).reg();
+  const QRegister value = locs()->in(0).fpu_reg();
+  const DRegister dvalue0 = EvenDRegisterOf(value);
 
   __ TryAllocate(compiler->float32x4_class(),
                  slow_path->entry_label(),
                  out_reg,
                  locs()->temp(0).reg());
   __ Bind(slow_path->exit_label());
 
-  __ StoreDToOffset(value_even, out_reg,
+  __ StoreMultipleDToOffset(dvalue0, 2, out_reg,
       Float32x4::value_offset() - kHeapObjectTag);
-  __ StoreDToOffset(value_odd, out_reg,
-      Float32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
 }
 
 
 LocationSummary* UnboxFloat32x4Instr::MakeLocationSummary(bool opt) const {
   const intptr_t value_cid = value()->Type()->ToCid();
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = value_cid == kFloat32x4Cid ? 0 : 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
@@ skipping 13 matching lines @@
 
   if (value_cid != kFloat32x4Cid) {
     const Register temp = locs()->temp(0).reg();
     Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptCheckClass);
     __ tst(value, ShifterOperand(kSmiTagMask));
     __ b(deopt, EQ);
     __ CompareClassId(value, kFloat32x4Cid, temp);
     __ b(deopt, NE);
   }
 
-  const DRegister result_even = EvenDRegisterOf(result);
-  const DRegister result_odd = OddDRegisterOf(result);
-  // TODO(zra): Maybe use vldmd here.
-  __ LoadDFromOffset(result_even, value,
+  const DRegister dresult0 = EvenDRegisterOf(result);
+  __ LoadMultipleDFromOffset(dresult0, 2, value,
       Float32x4::value_offset() - kHeapObjectTag);
-  __ LoadDFromOffset(result_odd, value,
-      Float32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
 }
 
 
 LocationSummary* BoxFloat64x2Instr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs,
                           kNumTemps,
                           LocationSummary::kCallOnSlowPath);
   summary->set_in(0, Location::RequiresFpuRegister());
   summary->set_temp(0, Location::RequiresRegister());
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void BoxFloat64x2Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   BoxFloat64x2SlowPath* slow_path = new BoxFloat64x2SlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
-  Register out_reg = locs()->out(0).reg();
-  QRegister value = locs()->in(0).fpu_reg();
-  DRegister value_even = EvenDRegisterOf(value);
-  DRegister value_odd = OddDRegisterOf(value);
+  const Register out_reg = locs()->out(0).reg();
+  const QRegister value = locs()->in(0).fpu_reg();
+  const DRegister dvalue0 = EvenDRegisterOf(value);
 
   __ TryAllocate(compiler->float64x2_class(),
                  slow_path->entry_label(),
                  out_reg,
                  locs()->temp(0).reg());
   __ Bind(slow_path->exit_label());
 
-  __ StoreDToOffset(value_even, out_reg,
+  __ StoreMultipleDToOffset(dvalue0, 2, out_reg,
       Float64x2::value_offset() - kHeapObjectTag);
-  __ StoreDToOffset(value_odd, out_reg,
-      Float64x2::value_offset() + 2 * kWordSize - kHeapObjectTag);
 }
 
 
 LocationSummary* UnboxFloat64x2Instr::MakeLocationSummary(bool opt) const {
   const intptr_t value_cid = value()->Type()->ToCid();
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = value_cid == kFloat64x2Cid ? 0 : 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
@@ skipping 13 matching lines @@
 
   if (value_cid != kFloat64x2Cid) {
     const Register temp = locs()->temp(0).reg();
     Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptCheckClass);
     __ tst(value, ShifterOperand(kSmiTagMask));
     __ b(deopt, EQ);
     __ CompareClassId(value, kFloat64x2Cid, temp);
     __ b(deopt, NE);
   }
 
-  const DRegister result_even = EvenDRegisterOf(result);
-  const DRegister result_odd = OddDRegisterOf(result);
-  // TODO(zra): Maybe use vldmd here.
-  __ LoadDFromOffset(result_even, value,
+  const DRegister dresult0 = EvenDRegisterOf(result);
+  __ LoadMultipleDFromOffset(dresult0, 2, value,
       Float64x2::value_offset() - kHeapObjectTag);
-  __ LoadDFromOffset(result_odd, value,
-      Float64x2::value_offset() + 2 * kWordSize - kHeapObjectTag);
 }
 
 
 LocationSummary* BoxInt32x4Instr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs,
                           kNumTemps,
                           LocationSummary::kCallOnSlowPath);
@@ skipping 33 matching lines @@
 
  private:
   BoxInt32x4Instr* instruction_;
 };
 
 
 void BoxInt32x4Instr::EmitNativeCode(FlowGraphCompiler* compiler) {
   BoxInt32x4SlowPath* slow_path = new BoxInt32x4SlowPath(this);
   compiler->AddSlowPathCode(slow_path);
 
-  Register out_reg = locs()->out(0).reg();
-  QRegister value = locs()->in(0).fpu_reg();
-  DRegister value_even = EvenDRegisterOf(value);
-  DRegister value_odd = OddDRegisterOf(value);
+  const Register out_reg = locs()->out(0).reg();
+  const QRegister value = locs()->in(0).fpu_reg();
+  const DRegister dvalue0 = EvenDRegisterOf(value);
 
   __ TryAllocate(compiler->int32x4_class(),
                  slow_path->entry_label(),
                  out_reg,
                  locs()->temp(0).reg());
   __ Bind(slow_path->exit_label());
-  __ StoreDToOffset(value_even, out_reg,
+  __ StoreMultipleDToOffset(dvalue0, 2, out_reg,
       Int32x4::value_offset() - kHeapObjectTag);
-  __ StoreDToOffset(value_odd, out_reg,
-      Int32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
 }
 
 
 LocationSummary* UnboxInt32x4Instr::MakeLocationSummary(bool opt) const {
   const intptr_t value_cid = value()->Type()->ToCid();
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = value_cid == kInt32x4Cid ? 0 : 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
@@ skipping 13 matching lines @@
 
   if (value_cid != kInt32x4Cid) {
     const Register temp = locs()->temp(0).reg();
     Label* deopt = compiler->AddDeoptStub(deopt_id_, kDeoptCheckClass);
     __ tst(value, ShifterOperand(kSmiTagMask));
     __ b(deopt, EQ);
     __ CompareClassId(value, kInt32x4Cid, temp);
     __ b(deopt, NE);
   }
 
-  const DRegister result_even = EvenDRegisterOf(result);
-  const DRegister result_odd = OddDRegisterOf(result);
-  // TODO(zra): Maybe use vldmd here.
-  __ LoadDFromOffset(result_even, value,
+  const DRegister dresult0 = EvenDRegisterOf(result);
+  __ LoadMultipleDFromOffset(dresult0, 2, value,
       Int32x4::value_offset() - kHeapObjectTag);
-  __ LoadDFromOffset(result_odd, value,
-      Int32x4::value_offset() + 2 * kWordSize - kHeapObjectTag);
 }
 
 
 LocationSummary* BinaryDoubleOpInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresFpuRegister());
   summary->set_in(1, Location::RequiresFpuRegister());
@@ skipping 1348 matching lines @@
   const intptr_t kNumTemps = 0;
   LocationSummary* result =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   result->set_in(0, Location::RegisterLocation(R1));
   result->set_out(0, Location::RegisterLocation(R0));
   return result;
 }
 
 
 void DoubleToIntegerInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Register result = locs()->out(0).reg();
-  Register value_obj = locs()->in(0).reg();
+  const Register result = locs()->out(0).reg();
+  const Register value_obj = locs()->in(0).reg();
   ASSERT(result == R0);
   ASSERT(result != value_obj);
   __ LoadDFromOffset(DTMP, value_obj, Double::value_offset() - kHeapObjectTag);
 
   Label do_call, done;
   // First check for NaN. Checking for minint after the conversion doesn't work
   // on ARM because vcvtid gives 0 for NaN.
   __ vcmpd(DTMP, DTMP);
   __ vmstat();
   __ b(&do_call, VS);
@@ skipping 1026 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM