Adds single-precision and SIMD load/store to arm64.

runtime/vm/intermediate_language_arm64.cc

 // Copyright (c) 2014, 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_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 991 matching lines @@
       (representation() == kUnboxedFloat64x2)) {
     const VRegister result = locs()->out(0).fpu_reg();
     switch (class_id()) {
       case kTypedDataInt32ArrayCid:
       case kTypedDataUint32ArrayCid:
         // TODO(zra): Add when we have simd.
         UNIMPLEMENTED();
         break;
       case kTypedDataFloat32ArrayCid:
         // Load single precision float.
-        // TODO(zra): Add when we add single precision floats.
-        UNIMPLEMENTED();
+        __ fldrs(result, element_address);
         break;
       case kTypedDataFloat64ArrayCid:
         // Load double precision float.
         __ fldrd(result, element_address);
         break;
       case kTypedDataFloat64x2ArrayCid:
       case kTypedDataInt32x4ArrayCid:
       case kTypedDataFloat32x4ArrayCid:
         // TODO(zra): Add when we have simd.
         UNIMPLEMENTED();
@@ skipping 110 matching lines @@
       // Mints are stored in Q registers. For smis, use a writable register
       // because the value must be untagged before storing.
       if (value()->IsSmiValue()) {
         locs->set_in(2, Location::WritableRegister());
       } else {
         // TODO(zra): Implement when we add simd loads and stores.
         UNIMPLEMENTED();
       }
       break;
     case kTypedDataFloat32ArrayCid:
-      // TODO(zra): Implement when we add float store.
-      UNIMPLEMENTED();
-      break;
     case kTypedDataFloat64ArrayCid:  // TODO(srdjan): Support Float64 constants.
       locs->set_in(2, Location::RequiresFpuRegister());
       break;
     case kTypedDataInt32x4ArrayCid:
     case kTypedDataFloat32x4ArrayCid:
     case kTypedDataFloat64x2ArrayCid:
       // TODO(zra): Implement when we add simd loads and stores.
       UNIMPLEMENTED();
       break;
     default:
       UNREACHABLE();
       return NULL;
   }
   return locs;
 }
 
 
 void StoreIndexedInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Register array = locs()->in(0).reg();
+  const Register array = locs()->in(0).reg();
   Location index = locs()->in(1);
 
   Address element_address(kNoRegister, 0);
   ASSERT(index.IsRegister());  // TODO(regis): Revisit.
   // Note that index is expected smi-tagged, (i.e, times 2) for all arrays
   // with index scale factor > 1. E.g., for Uint8Array and OneByteString the
   // index is expected to be untagged before accessing.
   ASSERT(kSmiTagShift == 1);
   switch (index_scale()) {
     case 1: {
@@ skipping 21 matching lines @@
   if (!IsExternal()) {
     ASSERT(this->array()->definition()->representation() == kTagged);
     __ AddImmediate(index.reg(), index.reg(),
         FlowGraphCompiler::DataOffsetFor(class_id()) - kHeapObjectTag, PP);
   }
   element_address = Address(array, index.reg(), UXTX, Address::Unscaled);
 
   switch (class_id()) {
     case kArrayCid:
       if (ShouldEmitStoreBarrier()) {
-        Register value = locs()->in(2).reg();
+        const Register value = locs()->in(2).reg();
         __ StoreIntoObject(array, element_address, value);
       } else if (locs()->in(2).IsConstant()) {
         const Object& constant = locs()->in(2).constant();
         __ StoreIntoObjectNoBarrier(array, element_address, constant);
       } else {
-        Register value = locs()->in(2).reg();
+        const Register value = locs()->in(2).reg();
         __ StoreIntoObjectNoBarrier(array, element_address, value);
       }
       break;
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kOneByteStringCid: {
       if (locs()->in(2).IsConstant()) {
         const Smi& constant = Smi::Cast(locs()->in(2).constant());
         __ LoadImmediate(TMP, static_cast<int8_t>(constant.Value()), PP);
         __ str(TMP, element_address, kUnsignedByte);
       } else {
-        Register value = locs()->in(2).reg();
+        const Register value = locs()->in(2).reg();
         __ SmiUntag(value);
         __ str(value, element_address, kUnsignedByte);
       }
       break;
     }
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid: {
       if (locs()->in(2).IsConstant()) {
         const Smi& constant = Smi::Cast(locs()->in(2).constant());
         intptr_t value = constant.Value();
         // Clamp to 0x0 or 0xFF respectively.
         if (value > 0xFF) {
           value = 0xFF;
         } else if (value < 0) {
           value = 0;
         }
         __ LoadImmediate(TMP, static_cast<int8_t>(value), PP);
         __ str(TMP, element_address, kUnsignedByte);
       } else {
-        Register value = locs()->in(2).reg();
+        const Register value = locs()->in(2).reg();
         Label store_value;
         __ SmiUntag(value);
         __ CompareImmediate(value, 0xFF, PP);
         // Clamp to 0x00 or 0xFF respectively.
         __ b(&store_value, LS);
         __ LoadImmediate(TMP, 0x00, PP);
         __ LoadImmediate(TMP2, 0xFF, PP);
         __ csel(value, TMP, value, LE);
         __ csel(value, TMP2, value, GT);
         __ Bind(&store_value);
         __ str(value, element_address, kUnsignedByte);
       }
       break;
     }
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
-      Register value = locs()->in(2).reg();
+      const Register value = locs()->in(2).reg();
       __ SmiUntag(value);
       __ str(value, element_address, kUnsignedHalfword);
       break;
     }
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid: {
       if (value()->IsSmiValue()) {
         ASSERT(RequiredInputRepresentation(2) == kTagged);
-        Register value = locs()->in(2).reg();
+        const Register value = locs()->in(2).reg();
         __ SmiUntag(value);
-        __ str(value, element_address);
+        __ str(value, element_address, kUnsignedWord);
       } else {
         // TODO(zra): Implement when we add simd loads and stores.
         UNIMPLEMENTED();
       }
       break;
     }
-    case kTypedDataFloat32ArrayCid:
-      // TODO(zra): Implement when we add float store.
-      UNIMPLEMENTED();
+    case kTypedDataFloat32ArrayCid: {
+      const VRegister in2 = locs()->in(2).fpu_reg();
+      __ add(index.reg(), index.reg(), Operand(array));
+      __ fstrs(in2, Address(index.reg()));
       break;
+    }
     case kTypedDataFloat64ArrayCid: {
-      VRegister in2 = locs()->in(2).fpu_reg();
+      const VRegister in2 = locs()->in(2).fpu_reg();
       __ add(index.reg(), index.reg(), Operand(array));
       __ StoreDToOffset(in2, index.reg(), 0);
       break;
     }
     case kTypedDataFloat64x2ArrayCid:
     case kTypedDataInt32x4ArrayCid:
     case kTypedDataFloat32x4ArrayCid: {
       // TODO(zra): Implement when we add simd loads and stores.
       UNIMPLEMENTED();
       break;
@@ skipping 415 matching lines @@
     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;
-        // TODO(zra): Implement these when we add fpu loads and stores.
         case kFloat32x4Cid:
+          cls = &compiler->float32x4_class();
+          break;
         case kFloat64x2Cid:
-          UNIMPLEMENTED();
+          cls = &compiler->float64x2_class();
           break;
         default:
           UNREACHABLE();
       }
 
       StoreInstanceFieldSlowPath* slow_path =
           new StoreInstanceFieldSlowPath(this, *cls);
       compiler->AddSlowPathCode(slow_path);
 
       __ TryAllocate(*cls,
                      slow_path->entry_label(),
                      temp,
                      temp2,
                      PP);
       __ Bind(slow_path->exit_label());
       __ mov(temp2, temp);
-      __ StoreIntoObject(instance_reg,
-                         FieldAddress(instance_reg, offset_in_bytes_),
-                         temp2);
+      __ StoreIntoObjectOffset(instance_reg, offset_in_bytes_, temp2);
     } else {
       __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes_);
     }
     switch (cid) {
       case kDoubleCid:
         __ Comment("UnboxedDoubleStoreInstanceFieldInstr");
         __ StoreDFieldToOffset(value, temp, Double::value_offset());
         break;
       case kFloat32x4Cid:
+        __ Comment("UnboxedFloat32x4StoreInstanceFieldInstr");
+        __ StoreQFieldToOffset(value, temp, Float32x4::value_offset());
+        break;
       case kFloat64x2Cid:
-        UNIMPLEMENTED();
+        __ Comment("UnboxedFloat64x2StoreInstanceFieldInstr");
+        __ StoreQFieldToOffset(value, temp, Float64x2::value_offset());
         break;
       default:
         UNREACHABLE();
     }
 
     return;
   }
 
   if (IsPotentialUnboxedStore()) {
     const Register value_reg = locs()->in(1).reg();
@@ skipping 48 matching lines @@
       __ CompareObject(temp, Object::null_object(), PP);
       __ b(&copy_double, NE);
 
       __ TryAllocate(compiler->double_class(),
                      slow_path->entry_label(),
                      temp,
                      temp2,
                      PP);
       __ Bind(slow_path->exit_label());
       __ mov(temp2, temp);
-      __ StoreIntoObject(instance_reg,
-                         FieldAddress(instance_reg, offset_in_bytes_),
-                         temp2);
+      __ StoreIntoObjectOffset(instance_reg, offset_in_bytes_, temp2);
       __ Bind(&copy_double);
       __ LoadDFieldFromOffset(fpu_temp, value_reg, Double::value_offset());
       __ StoreDFieldToOffset(fpu_temp, temp, Double::value_offset());
       __ b(&skip_store);
     }
 
-    // TODO(zra): Implement these when we add simd loads and stores.
     {
       __ Bind(&store_float32x4);
-      __ Stop("Float32x4 Unimplemented");
+      Label copy_float32x4;
+      StoreInstanceFieldSlowPath* slow_path =
+          new StoreInstanceFieldSlowPath(this, compiler->float32x4_class());
+      compiler->AddSlowPathCode(slow_path);
+
+      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes_);
+      __ CompareObject(temp, Object::null_object(), PP);
+      __ b(&copy_float32x4, NE);
+
+      __ TryAllocate(compiler->float32x4_class(),
+                     slow_path->entry_label(),
+                     temp,
+                     temp2,
+                     PP);
+      __ Bind(slow_path->exit_label());
+      __ mov(temp2, temp);
+      __ StoreIntoObjectOffset(instance_reg, offset_in_bytes_, temp2);
+      __ Bind(&copy_float32x4);
+      __ LoadQFieldFromOffset(fpu_temp, value_reg, Float32x4::value_offset());
+      __ StoreQFieldToOffset(fpu_temp, value_reg, Float32x4::value_offset());
+      __ b(&skip_store);
     }
 
     {
       __ Bind(&store_float64x2);
-      __ Stop("Float64x2 Unimplemented");
+      Label copy_float64x2;
+      StoreInstanceFieldSlowPath* slow_path =
+          new StoreInstanceFieldSlowPath(this, compiler->float64x2_class());
+      compiler->AddSlowPathCode(slow_path);
+
+      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes_);
+      __ CompareObject(temp, Object::null_object(), PP);
+      __ b(&copy_float64x2, NE);
+
+      __ TryAllocate(compiler->float64x2_class(),
+                     slow_path->entry_label(),
+                     temp,
+                     temp2,
+                     PP);
+      __ Bind(slow_path->exit_label());
+      __ mov(temp2, temp);
+      __ StoreIntoObjectOffset(instance_reg, offset_in_bytes_, temp2);
+      __ Bind(&copy_float64x2);
+      __ LoadQFieldFromOffset(fpu_temp, value_reg, Float64x2::value_offset());
+      __ StoreQFieldToOffset(fpu_temp, value_reg, Float64x2::value_offset());
+      __ b(&skip_store);
     }
 
     __ Bind(&store_pointer);
   }
 
   if (ShouldEmitStoreBarrier()) {
-    Register value_reg = locs()->in(1).reg();
-    __ StoreIntoObject(instance_reg,
-                       FieldAddress(instance_reg, offset_in_bytes_),
-                       value_reg,
-                       CanValueBeSmi());
+    const Register value_reg = locs()->in(1).reg();
+    __ StoreIntoObjectOffset(
+        instance_reg, offset_in_bytes_, value_reg, CanValueBeSmi());
   } else {
     if (locs()->in(1).IsConstant()) {
-      __ StoreIntoObjectNoBarrier(
+      __ StoreIntoObjectOffsetNoBarrier(
           instance_reg,
-          FieldAddress(instance_reg, offset_in_bytes_),
+          offset_in_bytes_,
           locs()->in(1).constant());
     } else {
-      Register value_reg = locs()->in(1).reg();
-      __ StoreIntoObjectNoBarrier(instance_reg,
-          FieldAddress(instance_reg, offset_in_bytes_), value_reg);
+      const Register value_reg = locs()->in(1).reg();
+      __ StoreIntoObjectOffsetNoBarrier(
+          instance_reg,
+          offset_in_bytes_,
+          value_reg);
     }
   }
   __ Bind(&skip_store);
 }
 
 
 LocationSummary* LoadStaticFieldInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
@@ skipping 24 matching lines @@
   return locs;
 }
 
 
 void StoreStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
 
   __ LoadObject(temp, field(), PP);
   if (this->value()->NeedsStoreBuffer()) {
-    __ StoreIntoObject(temp,
-        FieldAddress(temp, Field::value_offset()), value, CanValueBeSmi());
+    __ StoreIntoObjectOffset(
+        temp, Field::value_offset(), value, CanValueBeSmi());
   } else {
-    __ StoreIntoObjectNoBarrier(
-        temp, FieldAddress(temp, Field::value_offset()), value);
+    __ StoreIntoObjectOffsetNoBarrier(temp, Field::value_offset(), value);
   }
 }
 
 
 LocationSummary* InstanceOfInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 3;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   summary->set_in(0, Location::RegisterLocation(R0));
@@ skipping 1639 matching lines @@
   return NULL;
 }
 
 
 void DoubleToDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* DoubleToFloatInstr::MakeLocationSummary(bool opt) const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* result =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  result->set_in(0, Location::RequiresFpuRegister());
+  result->set_out(0, Location::RequiresFpuRegister());
+  return result;
 }
 
 
 void DoubleToFloatInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  const VRegister value = locs()->in(0).fpu_reg();
+  const VRegister result = locs()->out(0).fpu_reg();
+  __ fcvtsd(result, value);
 }
 
 
 LocationSummary* FloatToDoubleInstr::MakeLocationSummary(bool opt) const {
-  UNIMPLEMENTED();
-  return NULL;
+  const intptr_t kNumInputs = 1;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* result =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  result->set_in(0, Location::RequiresFpuRegister());
+  result->set_out(0, Location::RequiresFpuRegister());
+  return result;
 }
 
 
 void FloatToDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  UNIMPLEMENTED();
+  const VRegister value = locs()->in(0).fpu_reg();
+  const VRegister result = locs()->out(0).fpu_reg();
+  __ fcvtds(result, value);
 }
 
 
 LocationSummary* InvokeMathCFunctionInstr::MakeLocationSummary(bool opt) const {
   ASSERT((InputCount() == 1) || (InputCount() == 2));
   const intptr_t kNumTemps = 0;
   LocationSummary* result =
       new LocationSummary(InputCount(), kNumTemps, LocationSummary::kCall);
   result->set_in(0, Location::FpuRegisterLocation(V0));
   if (InputCount() == 2) {
@@ skipping 655 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64