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 37 matching lines @@
   // where PushArgument is handled by BindInstr::EmitNativeCode.
   if (compiler->is_optimizing()) {
     Location value = locs()->in(0);
     if (value.IsRegister()) {
       __ Push(value.reg());
     } else if (value.IsConstant()) {
       __ PushObject(value.constant(), PP);
     } else {
       ASSERT(value.IsStackSlot());
       const intptr_t value_offset = value.ToStackSlotOffset();
-      __ LoadFromOffset(TMP, FP, value_offset);
+      __ LoadFromOffset(TMP, FP, value_offset, PP);
       __ Push(TMP);
     }
   }
 }
 
 
 LocationSummary* ReturnInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
@@ skipping 125 matching lines @@
   // Load arguments descriptor in R4.
   int argument_count = ArgumentCount();
   const Array& arguments_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(argument_count,
                                                  argument_names()));
   __ LoadObject(R4, arguments_descriptor, PP);
 
   // R4: Arguments descriptor.
   // R0: Function.
   ASSERT(locs()->in(0).reg() == R0);
-  __ LoadFieldFromOffset(R2, R0, Function::code_offset());
+  __ LoadFieldFromOffset(R2, R0, Function::code_offset(), PP);
 
   // R2: code.
   // R5: Smi 0 (no IC data; the lazy-compile stub expects a GC-safe value).
   __ LoadImmediate(R5, 0, PP);
-  __ LoadFieldFromOffset(R2, R2, Code::instructions_offset());
+  __ LoadFieldFromOffset(R2, R2, Code::instructions_offset(), PP);
   __ AddImmediate(R2, R2, Instructions::HeaderSize() - kHeapObjectTag, PP);
   __ blr(R2);
   compiler->AddCurrentDescriptor(PcDescriptors::kClosureCall,
                                  deopt_id(),
                                  token_pos());
   compiler->RecordSafepoint(locs());
   // Marks either the continuation point in unoptimized code or the
   // deoptimization point in optimized code, after call.
   const intptr_t deopt_id_after = Isolate::ToDeoptAfter(deopt_id());
   if (compiler->is_optimizing()) {
@@ skipping 11 matching lines @@
 
 LocationSummary* LoadLocalInstr::MakeLocationSummary(bool opt) const {
   return LocationSummary::Make(0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void LoadLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out(0).reg();
-  __ LoadFromOffset(result, FP, local().index() * kWordSize);
+  __ LoadFromOffset(result, FP, local().index() * kWordSize, PP);
 }
 
 
 LocationSummary* StoreLocalInstr::MakeLocationSummary(bool opt) const {
   return LocationSummary::Make(1,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
 
 
 void StoreLocalInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   ASSERT(result == value);  // Assert that register assignment is correct.
-  __ StoreToOffset(value, FP, local().index() * kWordSize);
+  __ StoreToOffset(value, FP, local().index() * kWordSize, PP);
 }
 
 
 LocationSummary* ConstantInstr::MakeLocationSummary(bool opt) const {
   return LocationSummary::Make(0,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
@@ skipping 317 matching lines @@
 
   Label* deopt = CanDeoptimize() ?
       compiler->AddDeoptStub(deopt_id(), ICData::kDeoptTestCids) : NULL;
 
   const intptr_t true_result = (kind() == Token::kIS) ? 1 : 0;
   const ZoneGrowableArray<intptr_t>& data = cid_results();
   ASSERT(data[0] == kSmiCid);
   bool result = data[1] == true_result;
   __ tsti(val_reg, kSmiTagMask);
   __ b(result ? labels.true_label : labels.false_label, EQ);
-  __ LoadClassId(cid_reg, val_reg);
+  __ LoadClassId(cid_reg, val_reg, PP);
 
   for (intptr_t i = 2; i < data.length(); i += 2) {
     const intptr_t test_cid = data[i];
     ASSERT(test_cid != kSmiCid);
     result = data[i + 1] == true_result;
     __ CompareImmediate(cid_reg, test_cid, PP);
     __ b(result ? labels.true_label : labels.false_label, EQ);
   }
   // No match found, deoptimize or false.
   if (deopt == NULL) {
@@ skipping 182 matching lines @@
   return LocationSummary::Make(kNumInputs,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 void StringToCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(cid_ == kOneByteStringCid);
   Register str = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
-  __ LoadFieldFromOffset(result, str, String::length_offset());
+  __ LoadFieldFromOffset(result, str, String::length_offset(), PP);
   __ CompareImmediate(result, Smi::RawValue(1), PP);
   __ LoadImmediate(TMP, Smi::RawValue(-1), PP);
   __ ldr(TMP2, FieldAddress(str, OneByteString::data_offset()), kUnsignedByte);
   __ csel(result, TMP, result, NE);
   __ csel(result, TMP2, result, EQ);
   __ SmiTag(result);
 }
 
 
 LocationSummary* StringInterpolateInstr::MakeLocationSummary(bool opt) const {
@@ skipping 43 matching lines @@
 
 void LoadClassIdInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register object = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
   Label load, done;
   __ tsti(object, kSmiTagMask);
   __ b(&load, NE);
   __ LoadImmediate(result, Smi::RawValue(kSmiCid), PP);
   __ b(&done);
   __ Bind(&load);
-  __ LoadClassId(result, object);
+  __ LoadClassId(result, object, PP);
   __ SmiTag(result);
   __ Bind(&done);
 }
 
 
 CompileType LoadIndexedInstr::ComputeType() const {
   switch (class_id_) {
     case kArrayCid:
     case kImmutableArrayCid:
       return CompileType::Dynamic();
@@ skipping 130 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);
+      __ StoreDToOffset(in2, index.reg(), 0, PP);
       break;
     }
     case kTypedDataFloat64x2ArrayCid:
     case kTypedDataInt32x4ArrayCid:
     case kTypedDataFloat32x4ArrayCid: {
       // TODO(zra): Implement when we add simd loads and stores.
       UNIMPLEMENTED();
       break;
     }
     default:
       UNREACHABLE();
   }
 }
 
 
 static void LoadValueCid(FlowGraphCompiler* compiler,
                          Register value_cid_reg,
                          Register value_reg,
                          Label* value_is_smi = NULL) {
   Label done;
   if (value_is_smi == NULL) {
     __ LoadImmediate(value_cid_reg, kSmiCid, PP);
   }
   __ tsti(value_reg, kSmiTagMask);
   if (value_is_smi == NULL) {
     __ b(&done, EQ);
   } else {
     __ b(value_is_smi, EQ);
   }
-  __ LoadClassId(value_cid_reg, value_reg);
+  __ LoadClassId(value_cid_reg, value_reg, PP);
   __ Bind(&done);
 }
 
 
 LocationSummary* GuardFieldInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, 0, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   const bool field_has_length = field().needs_length_check();
@@ skipping 67 matching lines @@
     if (value_cid == kDynamicCid) {
       LoadValueCid(compiler, value_cid_reg, value_reg);
       Label skip_length_check;
       __ ldr(TMP, field_cid_operand);
       __ CompareRegisters(value_cid_reg, TMP);
       __ b(&skip_length_check, NE);
       if (field_has_length) {
         ASSERT(temp_reg != kNoRegister);
         // Field guard may have remembered list length, check it.
         if ((field_cid == kArrayCid) || (field_cid == kImmutableArrayCid)) {
-          __ LoadFieldFromOffset(temp_reg, value_reg, Array::length_offset());
+          __ LoadFieldFromOffset(
+              temp_reg, value_reg, Array::length_offset(), PP);
           __ CompareImmediate(temp_reg, Smi::RawValue(field_length), PP);
         } else if (RawObject::IsTypedDataClassId(field_cid)) {
           __ LoadFieldFromOffset(
-              temp_reg, value_reg, TypedData::length_offset());
+              temp_reg, value_reg, TypedData::length_offset(), PP);
           __ CompareImmediate(temp_reg, Smi::RawValue(field_length), PP);
         } else {
           ASSERT(field_cid == kIllegalCid);
           ASSERT(field_length == Field::kUnknownFixedLength);
           // At compile time we do not know the type of the field nor its
           // length. At execution time we may have set the class id and
           // list length so we compare the guarded length with the
           // list length here, without this check the list length could change
           // without triggering a deoptimization.
           Label check_array, length_compared, no_fixed_length;
           // If length is negative the length guard is either disabled or
           // has not been initialized, either way it is safe to skip the
           // length check.
           __ ldr(TMP, field_length_operand);
           __ CompareImmediate(TMP, 0, PP);
           __ b(&skip_length_check, LT);
           __ CompareImmediate(value_cid_reg, kNullCid, PP);
           __ b(&no_fixed_length, EQ);
           // Check for typed data array.
           __ CompareImmediate(value_cid_reg, kTypedDataInt32x4ArrayCid, PP);
           __ b(&no_fixed_length, GT);
           __ CompareImmediate(value_cid_reg, kTypedDataInt8ArrayCid, PP);
           // Could still be a regular array.
           __ b(&check_array, LT);
           __ LoadFieldFromOffset(
-              temp_reg, value_reg, TypedData::length_offset());
+              temp_reg, value_reg, TypedData::length_offset(), PP);
           __ ldr(TMP, field_length_operand);
           __ CompareRegisters(temp_reg, TMP);
           __ b(&length_compared);
           // Check for regular array.
           __ Bind(&check_array);
           __ CompareImmediate(value_cid_reg, kImmutableArrayCid, PP);
           __ b(&no_fixed_length, GT);
           __ CompareImmediate(value_cid_reg, kArrayCid, PP);
           __ b(&no_fixed_length, LT);
-          __ LoadFieldFromOffset(temp_reg, value_reg, Array::length_offset());
+          __ LoadFieldFromOffset(
+              temp_reg, value_reg, Array::length_offset(), PP);
           __ ldr(TMP, field_length_operand);
           __ CompareRegisters(temp_reg, TMP);
           __ b(&length_compared);
           __ Bind(&no_fixed_length);
           __ b(fail);
           __ Bind(&length_compared);
           // Following branch cannot not occur, fall through.
         }
         __ b(fail, NE);
       }
       __ Bind(&skip_length_check);
       __ ldr(TMP, field_nullability_operand);
       __ CompareRegisters(value_cid_reg, TMP);
     } else if (value_cid == kNullCid) {
       __ ldr(value_cid_reg, field_nullability_operand);
       __ CompareImmediate(value_cid_reg, value_cid, PP);
     } else {
       Label skip_length_check;
       __ ldr(value_cid_reg, field_cid_operand);
       __ CompareImmediate(value_cid_reg, value_cid, PP);
       __ b(&skip_length_check, NE);
       if (field_has_length) {
         ASSERT(value_cid_reg != kNoRegister);
         ASSERT(temp_reg != kNoRegister);
         if ((value_cid == kArrayCid) || (value_cid == kImmutableArrayCid)) {
-          __ LoadFieldFromOffset(temp_reg, value_reg, Array::length_offset());
+          __ LoadFieldFromOffset(
+              temp_reg, value_reg, Array::length_offset(), PP);
           __ CompareImmediate(temp_reg, Smi::RawValue(field_length), PP);
         } else if (RawObject::IsTypedDataClassId(value_cid)) {
           __ LoadFieldFromOffset(
-              temp_reg, value_reg, TypedData::length_offset());
+              temp_reg, value_reg, TypedData::length_offset(), PP);
           __ CompareImmediate(temp_reg, Smi::RawValue(field_length), PP);
         } else if (field_cid != kIllegalCid) {
           ASSERT(field_cid != value_cid);
           ASSERT(field_length >= 0);
           // Field has a known class id and length. At compile time it is
           // known that the value's class id is not a fixed length list.
           __ b(fail);
         } else {
           ASSERT(field_cid == kIllegalCid);
           ASSERT(field_length == Field::kUnknownFixedLength);
@@ skipping 18 matching lines @@
         __ CompareImmediate(value_cid_reg, kNullCid, PP);
         __ b(&no_fixed_length, EQ);
         // Check for typed data array.
         __ CompareImmediate(value_cid_reg, kTypedDataInt32x4ArrayCid, PP);
         __ b(&no_fixed_length, GT);
         __ CompareImmediate(value_cid_reg, kTypedDataInt8ArrayCid, PP);
         // Could still be a regular array.
         __ b(&check_array, LT);
         // Destroy value_cid_reg (safe because we are finished with it).
         __ LoadFieldFromOffset(
-            value_cid_reg, value_reg, TypedData::length_offset());
+            value_cid_reg, value_reg, TypedData::length_offset(), PP);
         __ str(value_cid_reg, field_length_operand);
         __ b(&length_set);  // Updated field length typed data array.
         // Check for regular array.
         __ Bind(&check_array);
         __ CompareImmediate(value_cid_reg, kImmutableArrayCid, PP);
         __ b(&no_fixed_length, GT);
         __ CompareImmediate(value_cid_reg, kArrayCid, PP);
         __ b(&no_fixed_length, LT);
         // Destroy value_cid_reg (safe because we are finished with it).
         __ LoadFieldFromOffset(
-            value_cid_reg, value_reg, Array::length_offset());
+            value_cid_reg, value_reg, Array::length_offset(), PP);
         __ str(value_cid_reg, field_length_operand);
         // Updated field length from regular array.
         __ b(&length_set);
         __ Bind(&no_fixed_length);
         __ LoadImmediate(TMP, Smi::RawValue(Field::kNoFixedLength), PP);
         __ str(TMP, field_length_operand);
         __ Bind(&length_set);
       }
     } else {
       __ LoadImmediate(TMP, value_cid, PP);
       __ str(TMP, field_cid_operand);
       __ str(TMP, field_nullability_operand);
       if (field_has_length) {
         if ((value_cid == kArrayCid) || (value_cid == kImmutableArrayCid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ LoadFieldFromOffset(
-              value_cid_reg, value_reg, Array::length_offset());
+              value_cid_reg, value_reg, Array::length_offset(), PP);
           __ str(value_cid_reg, field_length_operand);
         } else if (RawObject::IsTypedDataClassId(value_cid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ LoadFieldFromOffset(
-              value_cid_reg, value_reg, TypedData::length_offset());
+              value_cid_reg, value_reg, TypedData::length_offset(), PP);
           __ str(value_cid_reg, field_length_operand);
         } else {
           __ LoadImmediate(TMP, Smi::RawValue(Field::kNoFixedLength), PP);
           __ str(TMP, field_length_operand);
         }
       }
     }
 
     if (deopt == NULL) {
       ASSERT(!compiler->is_optimizing());
       __ b(&ok);
       __ Bind(fail);
 
-      __ LoadFieldFromOffset(TMP, field_reg, Field::guarded_cid_offset());
+      __ LoadFieldFromOffset(TMP, field_reg, Field::guarded_cid_offset(), PP);
       __ CompareImmediate(TMP, kDynamicCid, PP);
       __ b(&ok, EQ);
 
       __ Push(field_reg);
       __ Push(value_reg);
       __ CallRuntime(kUpdateFieldCidRuntimeEntry, 2);
       __ Drop(2);  // Drop the field and the value.
     }
   } else {
     ASSERT(compiler->is_optimizing());
     ASSERT(deopt != NULL);
     // Field guard class has been initialized and is known.
     if (field_reg != kNoRegister) {
       __ LoadObject(field_reg, Field::ZoneHandle(field().raw()), PP);
     }
     if (value_cid == kDynamicCid) {
       // Field's guarded class id is fixed by value's class id is not known.
       __ tsti(value_reg, kSmiTagMask);
 
       if (field_cid != kSmiCid) {
         __ b(fail, EQ);
-        __ LoadClassId(value_cid_reg, value_reg);
+        __ LoadClassId(value_cid_reg, value_reg, PP);
         __ CompareImmediate(value_cid_reg, field_cid, PP);
       }
 
       if (field_has_length) {
         __ b(fail, NE);
         // Classes are same, perform guarded list length check.
         ASSERT(field_reg != kNoRegister);
         ASSERT(value_cid_reg != kNoRegister);
         FieldAddress field_length_operand(
             field_reg, Field::guarded_list_length_offset());
         if ((field_cid == kArrayCid) || (field_cid == kImmutableArrayCid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ LoadFieldFromOffset(
-              value_cid_reg, value_reg, Array::length_offset());
+              value_cid_reg, value_reg, Array::length_offset(), PP);
         } else if (RawObject::IsTypedDataClassId(field_cid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ LoadFieldFromOffset(
-              value_cid_reg, value_reg, TypedData::length_offset());
+              value_cid_reg, value_reg, TypedData::length_offset(), PP);
         }
         __ ldr(TMP, field_length_operand);
         __ CompareRegisters(value_cid_reg, TMP);
       }
 
       if (field().is_nullable() && (field_cid != kNullCid)) {
         __ b(&ok, EQ);
         __ CompareObject(value_reg, Object::null_object(), PP);
       }
       __ b(fail, NE);
     } else {
       // Both value's and field's class id is known.
       if ((value_cid != field_cid) && (value_cid != nullability)) {
         __ b(fail);
       } else if (field_has_length && (value_cid == field_cid)) {
         ASSERT(value_cid_reg != kNoRegister);
         if ((field_cid == kArrayCid) || (field_cid == kImmutableArrayCid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ LoadFieldFromOffset(
-              value_cid_reg, value_reg, Array::length_offset());
+              value_cid_reg, value_reg, Array::length_offset(), PP);
         } else if (RawObject::IsTypedDataClassId(field_cid)) {
           // Destroy value_cid_reg (safe because we are finished with it).
           __ LoadFieldFromOffset(
-              value_cid_reg, value_reg, TypedData::length_offset());
+              value_cid_reg, value_reg, TypedData::length_offset(), PP);
         }
         __ CompareImmediate(value_cid_reg, field_length, PP);
         __ b(fail, NE);
       } else {
         UNREACHABLE();
       }
     }
   }
   __ Bind(&ok);
 }
@@ skipping 75 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, PP);
     } else {
-      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes_);
+      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes_, PP);
     }
     switch (cid) {
       case kDoubleCid:
         __ Comment("UnboxedDoubleStoreInstanceFieldInstr");
-        __ StoreDFieldToOffset(value, temp, Double::value_offset());
+        __ StoreDFieldToOffset(value, temp, Double::value_offset(), PP);
         break;
       case kFloat32x4Cid:
+        __ Comment("UnboxedFloat32x4StoreInstanceFieldInstr");
+        __ StoreQFieldToOffset(value, temp, Float32x4::value_offset(), PP);
+        break;
       case kFloat64x2Cid:
-        UNIMPLEMENTED();
+        __ Comment("UnboxedFloat64x2StoreInstanceFieldInstr");
+        __ StoreQFieldToOffset(value, temp, Float64x2::value_offset(), PP);
         break;
       default:
         UNREACHABLE();
     }
 
     return;
   }
 
   if (IsPotentialUnboxedStore()) {
     const Register value_reg = locs()->in(1).reg();
     const Register temp = locs()->temp(0).reg();
     const Register temp2 = locs()->temp(1).reg();
     const VRegister fpu_temp = locs()->temp(2).fpu_reg();
 
     Label store_pointer;
     Label store_double;
     Label store_float32x4;
     Label store_float64x2;
 
     __ LoadObject(temp, Field::ZoneHandle(field().raw()), PP);
 
-    __ LoadFieldFromOffset(temp2, temp, Field::is_nullable_offset());
+    __ LoadFieldFromOffset(temp2, temp, Field::is_nullable_offset(), PP);
     __ CompareImmediate(temp2, kNullCid, PP);
     __ b(&store_pointer, EQ);
 
     __ LoadFromOffset(
-        temp2, temp, Field::kind_bits_offset() - kHeapObjectTag, kUnsignedByte);
+        temp2, temp, Field::kind_bits_offset() - kHeapObjectTag,
+        PP, kUnsignedByte);
     __ tsti(temp2, 1 << Field::kUnboxingCandidateBit);
     __ b(&store_pointer, EQ);
 
-    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset());
+    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP);
     __ CompareImmediate(temp2, kDoubleCid, PP);
     __ b(&store_double, EQ);
 
-    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset());
+    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP);
     __ CompareImmediate(temp2, kFloat32x4Cid, PP);
     __ b(&store_float32x4, EQ);
 
-    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset());
+    __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP);
     __ CompareImmediate(temp2, kFloat64x2Cid, PP);
     __ b(&store_float64x2, EQ);
 
     // Fall through.
     __ b(&store_pointer);
 
     if (!compiler->is_optimizing()) {
         locs()->live_registers()->Add(locs()->in(0));
         locs()->live_registers()->Add(locs()->in(1));
     }
 
     {
       __ Bind(&store_double);
       Label copy_double;
       StoreInstanceFieldSlowPath* slow_path =
           new StoreInstanceFieldSlowPath(this, compiler->double_class());
       compiler->AddSlowPathCode(slow_path);
 
-      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes_);
+      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes_, PP);
       __ 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, PP);
       __ Bind(&copy_double);
-      __ LoadDFieldFromOffset(fpu_temp, value_reg, Double::value_offset());
-      __ StoreDFieldToOffset(fpu_temp, temp, Double::value_offset());
+      __ LoadDFieldFromOffset(fpu_temp, value_reg, Double::value_offset(), PP);
+      __ StoreDFieldToOffset(fpu_temp, temp, Double::value_offset(), PP);
       __ 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_, PP);
+      __ 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, PP);
+      __ Bind(&copy_float32x4);
+      __ LoadQFieldFromOffset(
+          fpu_temp, value_reg, Float32x4::value_offset(), PP);
+      __ StoreQFieldToOffset(
+          fpu_temp, value_reg, Float32x4::value_offset(), PP);
+      __ 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_, PP);
+      __ 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, PP);
+      __ Bind(&copy_float64x2);
+      __ LoadQFieldFromOffset(
+          fpu_temp, value_reg, Float64x2::value_offset(), PP);
+      __ StoreQFieldToOffset(
+          fpu_temp, value_reg, Float64x2::value_offset(), PP);
+      __ 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, PP, CanValueBeSmi());
   } else {
     if (locs()->in(1).IsConstant()) {
-      __ StoreIntoObjectNoBarrier(
+      __ StoreIntoObjectOffsetNoBarrier(
           instance_reg,
-          FieldAddress(instance_reg, offset_in_bytes_),
-          locs()->in(1).constant());
+          offset_in_bytes_,
+          locs()->in(1).constant(),
+          PP);
     } 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,
+          PP);
     }
   }
   __ Bind(&skip_store);
 }
 
 
 LocationSummary* LoadStaticFieldInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_out(0, Location::RequiresRegister());
   return summary;
 }
 
 
 // When the parser is building an implicit static getter for optimization,
 // it can generate a function body where deoptimization ids do not line up
 // with the unoptimized code.
 //
 // This is safe only so long as LoadStaticFieldInstr cannot deoptimize.
 void LoadStaticFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register field = locs()->in(0).reg();
   Register result = locs()->out(0).reg();
-  __ LoadFieldFromOffset(result, field, Field::value_offset());
+  __ LoadFieldFromOffset(result, field, Field::value_offset(), PP);
 }
 
 
 LocationSummary* StoreStaticFieldInstr::MakeLocationSummary(bool opt) const {
   LocationSummary* locs = new LocationSummary(1, 1, LocationSummary::kNoCall);
   locs->set_in(0, value()->NeedsStoreBuffer() ? Location::WritableRegister()
                                               : Location::RequiresRegister());
   locs->set_temp(0, Location::RequiresRegister());
   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, PP, CanValueBeSmi());
   } else {
-    __ StoreIntoObjectNoBarrier(
-        temp, FieldAddress(temp, Field::value_offset()), value);
+    __ StoreIntoObjectOffsetNoBarrier(temp, Field::value_offset(), value, PP);
   }
 }
 
 
 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 96 matching lines @@
   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()) {
     const VRegister result = locs()->out(0).fpu_reg();
     const Register temp = locs()->temp(0).reg();
-    __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes());
+    __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes(), PP);
     const intptr_t cid = field()->UnboxedFieldCid();
     switch (cid) {
       case kDoubleCid:
         __ Comment("UnboxedDoubleLoadFieldInstr");
-        __ LoadDFieldFromOffset(result, temp, Double::value_offset());
+        __ LoadDFieldFromOffset(result, temp, Double::value_offset(), PP);
         break;
       case kFloat32x4Cid:
       case kFloat64x2Cid:
         UNIMPLEMENTED();
         break;
       default:
         UNREACHABLE();
     }
     return;
   }
@@ skipping 42 matching lines @@
       __ Bind(&load_double);
       BoxDoubleSlowPath* slow_path = new BoxDoubleSlowPath(this);
       compiler->AddSlowPathCode(slow_path);
 
       __ TryAllocate(compiler->double_class(),
                      slow_path->entry_label(),
                      result_reg,
                      temp,
                      PP);
       __ Bind(slow_path->exit_label());
-      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes());
-      __ LoadDFieldFromOffset(value, temp, Double::value_offset());
-      __ StoreDFieldToOffset(value, result_reg, Double::value_offset());
+      __ LoadFieldFromOffset(temp, instance_reg, offset_in_bytes(), PP);
+      __ LoadDFieldFromOffset(value, temp, Double::value_offset(), PP);
+      __ StoreDFieldToOffset(value, result_reg, Double::value_offset(), PP);
       __ b(&done);
     }
 
     // TODO(zra): Implement these when we add simd loads and stores.
     {
       __ Bind(&load_float32x4);
       __ Stop("Float32x4 Unimplemented");
     }
 
     {
       __ Bind(&load_float64x2);
       __ Stop("Float64x2 Unimplemented");
     }
 
     __ Bind(&load_pointer);
   }
-  __ LoadFieldFromOffset(result_reg, instance_reg, offset_in_bytes());
+  __ LoadFieldFromOffset(result_reg, instance_reg, offset_in_bytes(), PP);
   __ Bind(&done);
 }
 
 
 LocationSummary* InstantiateTypeInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(R0));
@@ skipping 49 matching lines @@
   // instantiated from null becomes a vector of dynamic, then use null as
   // the type arguments.
   Label type_arguments_instantiated;
   const intptr_t len = type_arguments().Length();
   if (type_arguments().IsRawInstantiatedRaw(len)) {
     __ CompareObject(instantiator_reg, Object::null_object(), PP);
     __ b(&type_arguments_instantiated, EQ);
   }
 
   __ LoadObject(R2, type_arguments(), PP);
-  __ LoadFieldFromOffset(R2, R2, TypeArguments::instantiations_offset());
+  __ LoadFieldFromOffset(R2, R2, TypeArguments::instantiations_offset(), PP);
   __ AddImmediate(R2, R2, Array::data_offset() - kHeapObjectTag, PP);
   // The instantiations cache is initialized with Object::zero_array() and is
   // therefore guaranteed to contain kNoInstantiator. No length check needed.
   Label loop, found, slow_case;
   __ Bind(&loop);
-  __ LoadFromOffset(R1, R2, 0 * kWordSize);  // Cached instantiator.
+  __ LoadFromOffset(R1, R2, 0 * kWordSize, PP);  // Cached instantiator.
   __ CompareRegisters(R1, R0);
   __ b(&found, EQ);
   __ AddImmediate(R2, R2, 2 * kWordSize, PP);
   __ CompareImmediate(R1, Smi::RawValue(StubCode::kNoInstantiator), PP);
   __ b(&loop, NE);
   __ b(&slow_case);
   __ Bind(&found);
-  __ LoadFromOffset(R0, R2, 1 * kWordSize);  // Cached instantiated args.
+  __ LoadFromOffset(R0, R2, 1 * kWordSize, PP);  // Cached instantiated args.
   __ b(&type_arguments_instantiated);
 
   __ Bind(&slow_case);
   // Instantiate non-null type arguments.
   // A runtime call to instantiate the type arguments is required.
   __ PushObject(Object::ZoneHandle(), PP);  // Make room for the result.
   __ PushObject(type_arguments(), PP);
   __ Push(instantiator_reg);  // Push instantiator type arguments.
   compiler->GenerateRuntimeCall(token_pos(),
                                 deopt_id(),
@@ skipping 82 matching lines @@
   // Restore SP from FP as we are coming from a throw and the code for
   // popping arguments has not been run.
   const intptr_t fp_sp_dist =
       (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
   ASSERT(fp_sp_dist <= 0);
   __ AddImmediate(SP, FP, fp_sp_dist, PP);
 
   // Restore stack and initialize the two exception variables:
   // exception and stack trace variables.
   __ StoreToOffset(kExceptionObjectReg,
-                   FP, exception_var().index() * kWordSize);
+                   FP, exception_var().index() * kWordSize, PP);
   __ StoreToOffset(kStackTraceObjectReg,
-                   FP, stacktrace_var().index() * kWordSize);
+                   FP, stacktrace_var().index() * kWordSize, PP);
 }
 
 
 LocationSummary* CheckStackOverflowInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs,
                           kNumTemps,
                           LocationSummary::kCallOnSlowPath);
@@ skipping 62 matching lines @@
   __ CompareRegisters(SP, TMP);
   __ b(slow_path->entry_label(), LS);
   if (compiler->CanOSRFunction() && in_loop()) {
     Register temp = locs()->temp(0).reg();
     // In unoptimized code check the usage counter to trigger OSR at loop
     // stack checks.  Use progressively higher thresholds for more deeply
     // nested loops to attempt to hit outer loops with OSR when possible.
     __ LoadObject(temp, compiler->parsed_function().function(), PP);
     intptr_t threshold =
         FLAG_optimization_counter_threshold * (loop_depth() + 1);
-    __ LoadFieldFromOffset(temp, temp, Function::usage_counter_offset());
+    __ LoadFieldFromOffset(temp, temp, Function::usage_counter_offset(), PP);
     __ CompareImmediate(temp, threshold, PP);
     __ b(slow_path->osr_entry_label(), GE);
   }
   if (compiler->ForceSlowPathForStackOverflow()) {
     __ b(slow_path->entry_label());
   }
   __ Bind(slow_path->exit_label());
 }
 
 
@@ skipping 472 matching lines @@
 
   const Register out_reg = locs()->out(0).reg();
   const VRegister value = locs()->in(0).fpu_reg();
 
   __ TryAllocate(compiler->double_class(),
                  slow_path->entry_label(),
                  out_reg,
                  locs()->temp(0).reg(),
                  PP);
   __ Bind(slow_path->exit_label());
-  __ StoreDFieldToOffset(value, out_reg, Double::value_offset());
+  __ StoreDFieldToOffset(value, out_reg, Double::value_offset(), PP);
 }
 
 
 LocationSummary* UnboxDoubleInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_out(0, Location::RequiresFpuRegister());
   return summary;
 }
 
 
 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 VRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid == kDoubleCid) {
-    __ LoadDFieldFromOffset(result, value, Double::value_offset());
+    __ LoadDFieldFromOffset(result, value, Double::value_offset(), PP);
   } else if (value_cid == kSmiCid) {
     __ Asr(TMP, value, kSmiTagSize);  // Untag input before conversion.
     __ scvtfd(result, TMP);
   } else {
     Label* deopt = compiler->AddDeoptStub(deopt_id_,
                                           ICData::kDeoptBinaryDoubleOp);
     if (value_type->is_nullable() &&
         (value_type->ToNullableCid() == kDoubleCid)) {
       __ CompareObject(value, Object::null_object(), PP);
       __ b(deopt, EQ);
       // It must be double now.
-      __ LoadDFieldFromOffset(result, value, Double::value_offset());
+      __ LoadDFieldFromOffset(result, value, Double::value_offset(), PP);
     } else {
       Label is_smi, done;
       __ tsti(value, kSmiTagMask);
       __ b(&is_smi, EQ);
-      __ CompareClassId(value, kDoubleCid);
+      __ CompareClassId(value, kDoubleCid, PP);
       __ b(deopt, NE);
-      __ LoadDFieldFromOffset(result, value, Double::value_offset());
+      __ LoadDFieldFromOffset(result, value, Double::value_offset(), PP);
       __ b(&done);
       __ Bind(&is_smi);
       __ Asr(TMP, value, kSmiTagSize);  // Copy and untag.
       __ scvtfd(result, TMP);
       __ Bind(&done);
     }
   }
 }
 
 
@@ skipping 554 matching lines @@
   result->set_out(0, Location::RegisterLocation(R0));
   return result;
 }
 
 
 void DoubleToIntegerInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register result = locs()->out(0).reg();
   const Register value_obj = locs()->in(0).reg();
   ASSERT(result == R0);
   ASSERT(result != value_obj);
-  __ LoadDFieldFromOffset(VTMP, value_obj, Double::value_offset());
+  __ LoadDFieldFromOffset(VTMP, value_obj, Double::value_offset(), PP);
 
   Label do_call, done;
   // First check for NaN. Checking for minint after the conversion doesn't work
   // on ARM64 because fcvtzds gives 0 for NaN.
   __ fcmpd(VTMP, VTMP);
   __ b(&do_call, VS);
 
   __ fcvtzds(result, VTMP);
   // Overflow is signaled with minint.
 
@@ skipping 54 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 233 matching lines @@
                                  instance_call()->token_pos(),
                                  target,
                                  instance_call()->ArgumentCount(),
                                  instance_call()->argument_names(),
                                  locs());
     return;
   }
 
   // Load receiver into R0.
   __ LoadFromOffset(
-      R0, SP, (instance_call()->ArgumentCount() - 1) * kWordSize);
+      R0, SP, (instance_call()->ArgumentCount() - 1) * kWordSize, PP);
 
   LoadValueCid(compiler, R2, R0,
                (ic_data().GetReceiverClassIdAt(0) == kSmiCid) ? NULL : deopt);
 
   compiler->EmitTestAndCall(ic_data(),
                             R2,  // Class id register.
                             instance_call()->ArgumentCount(),
                             instance_call()->argument_names(),
                             deopt,
                             deopt_id(),
@@ skipping 46 matching lines @@
   Label is_ok;
   intptr_t cix = 0;
   if (unary_checks().GetReceiverClassIdAt(cix) == kSmiCid) {
     __ tsti(value, kSmiTagMask);
     __ b(&is_ok, EQ);
     cix++;  // Skip first check.
   } else {
     __ tsti(value, kSmiTagMask);
     __ b(deopt, EQ);
   }
-  __ LoadClassId(temp, value);
+  __ LoadClassId(temp, value, PP);
   const intptr_t num_checks = unary_checks().NumberOfChecks();
   for (intptr_t i = cix; i < num_checks; i++) {
     ASSERT(unary_checks().GetReceiverClassIdAt(i) != kSmiCid);
     __ CompareImmediate(temp, unary_checks().GetReceiverClassIdAt(i), PP);
     if (i == (num_checks - 1)) {
       __ b(deopt, NE);
     } else {
       __ b(&is_ok, EQ);
     }
   }
@@ skipping 334 matching lines @@
   compiler->GenerateCall(token_pos(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   __ Drop(ArgumentCount());  // Discard arguments.
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64