Explicit conversions for Float32 array loads/stores.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 1202 matching lines @@
     // an unboxed double, an unboxed Float32x4, or unboxed Int32x4.
     needs_store_barrier = kNoStoreBarrier;
     Instruction* check =
         GetCheckClass(stored_value, value_check, call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     check,
                                     call->env(),
                                     Definition::kEffect);
   }
 
+  if (array_cid == kTypedDataFloat32ArrayCid) {
+    stored_value =
+        new DoubleToFloatInstr(new Value(stored_value), call->deopt_id());
+    cursor = flow_graph()->AppendTo(cursor,
+                                    stored_value,
+                                    NULL,
+                                    Definition::kValue);
+  }
+
   intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
   *last = new StoreIndexedInstr(new Value(array),
                                 new Value(index),
                                 new Value(stored_value),
                                 needs_store_barrier,
                                 index_scale,
                                 array_cid,
                                 call->deopt_id());
   flow_graph()->AppendTo(cursor,
                          *last,
@@ skipping 276 matching lines @@
         call->deopt_id() : Isolate::kNoDeoptId;
   }
 
   // Array load and return.
   intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
   *last = new LoadIndexedInstr(new Value(array),
                                new Value(index),
                                index_scale,
                                array_cid,
                                deopt_id);
-  flow_graph()->AppendTo(cursor,
-                         *last,
-                         deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
-                         Definition::kValue);
+  cursor = flow_graph()->AppendTo(
+      cursor,
+      *last,
+      deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
+      Definition::kValue);
+
+  if (array_cid == kTypedDataFloat32ArrayCid) {
+    *last = new FloatToDoubleInstr(new Value(*last), deopt_id);
+    flow_graph()->AppendTo(cursor,
+                           *last,
+                           deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
+                           Definition::kValue);
+  }
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithLoadIndexed(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
   if (!call->HasICData()) return false;
   const ICData& ic_data = ICData::Handle(call->ic_data()->AsUnaryClassChecks());
   if (ic_data.NumberOfChecks() != 1) return false;
   ASSERT(ic_data.HasOneTarget());
@@ skipping 1625 matching lines @@
     // Assume mixed Mint/Smi if this instruction caused deoptimization once.
     deopt_id = (ic_data.deopt_reason() == kDeoptUnknown) ?
         call->deopt_id() : Isolate::kNoDeoptId;
   }
 
   *last = new LoadIndexedInstr(new Value(array),
                                new Value(index),
                                1,
                                view_cid,
                                deopt_id);
-  flow_graph()->AppendTo(cursor,
-                         *last,
-                         deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
-                         Definition::kValue);
+  cursor = flow_graph()->AppendTo(
+      cursor,
+      *last,
+      deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
+      Definition::kValue);
+
+  if (view_cid == kTypedDataFloat32ArrayCid) {
+    *last = new FloatToDoubleInstr(new Value(*last), deopt_id);
+    flow_graph()->AppendTo(cursor,
+                           *last,
+                           deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
+                           Definition::kValue);
+  }
   return true;
 }
 
 
 bool FlowGraphOptimizer::InlineByteArrayViewStore(const Function& target,
                                                   Instruction* call,
                                                   Definition* receiver,
                                                   intptr_t array_cid,
                                                   intptr_t view_cid,
                                                   const ICData& ic_data,
@@ skipping 90 matching lines @@
     default:
       // Array cids are already checked in the caller.
       UNREACHABLE();
   }
 
   Definition* stored_value = call->ArgumentAt(2);
   if (!value_check.IsNull()) {
     AddCheckClass(stored_value, value_check, call->deopt_id(), call->env(),
                   call);
   }
+
+  if (view_cid == kTypedDataFloat32ArrayCid) {
+    stored_value =
+        new DoubleToFloatInstr(new Value(stored_value), call->deopt_id());
+    cursor = flow_graph()->AppendTo(cursor,
+                                    stored_value,
+                                    NULL,
+                                    Definition::kValue);
+  }
+
   StoreBarrierType needs_store_barrier = kNoStoreBarrier;
   *last = new StoreIndexedInstr(new Value(array),
                                 new Value(index),
                                 new Value(stored_value),
                                 needs_store_barrier,
                                 1,  // Index scale
                                 view_cid,
                                 call->deopt_id());
 
   flow_graph()->AppendTo(cursor,
@@ skipping 1964 matching lines @@
       if (comma) {
         OS::Print(", ");
       }
       OS::Print("%s", places_[it.Current()]->ToCString());
       comma = true;
     }
   }
 
   const PhiPlaceMoves* phi_moves() const { return phi_moves_; }
 
-  // Returns true if the result of AllocateObject can be aliased by some
-  // other SSA variable and false otherwise. Currently simply checks if
+  // Returns true if the result of an allocation instruction can be aliased by
+  // some other SSA variable and false otherwise. Currently simply checks if
   // this value is stored in a field, escapes to another function or
   // participates in a phi.
   static bool CanBeAliased(AllocateObjectInstr* alloc) {
     if (alloc->identity() == AllocateObjectInstr::kUnknown) {
       bool escapes = false;
       for (Value* use = alloc->input_use_list();
            use != NULL;
            use = use->next_use()) {
         Instruction* instr = use->instruction();
         if (instr->IsPushArgument() ||
@@ skipping 440 matching lines @@
             gen->RemoveAll(killed);
           }
 
           // Only forward stores to normal arrays, float64, and simd arrays
           // to loads because other array stores (intXX/uintXX/float32)
           // may implicitly convert the value stored.
           StoreIndexedInstr* array_store = instr->AsStoreIndexed();
           if ((array_store == NULL) ||
               (array_store->class_id() == kArrayCid) ||
               (array_store->class_id() == kTypedDataFloat64ArrayCid) ||
+              (array_store->class_id() == kTypedDataFloat32ArrayCid) ||
               (array_store->class_id() == kTypedDataFloat32x4ArrayCid)) {
             bool is_load = false;
             Place store_place(instr, &is_load);
             ASSERT(!is_load);
             Place* place = map_->Lookup(&store_place);
             if (place != NULL) {
               // Store has a corresponding numbered place that might have a
               // load. Try forwarding stored value to it.
               gen->Add(place->id());
               if (out_values == NULL) out_values = CreateBlockOutValues();
@@ skipping 1695 matching lines @@
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitDoubleToDouble(DoubleToDoubleInstr* instr) {
   // TODO(kmillikin): Handle conversion.
   SetValue(instr, non_constant_);
 }
 
 
+void ConstantPropagator::VisitDoubleToFloat(DoubleToFloatInstr* instr) {
+  // TODO(kmillikin): Handle conversion.
+  SetValue(instr, non_constant_);
+}
+
+
+void ConstantPropagator::VisitFloatToDouble(FloatToDoubleInstr* instr) {
+  // TODO(kmillikin): Handle conversion.
+  SetValue(instr, non_constant_);
+}
+
+
 void ConstantPropagator::VisitInvokeMathCFunction(
     InvokeMathCFunctionInstr* instr) {
   // TODO(kmillikin): Handle conversion.
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitMergedMath(MergedMathInstr* instr) {
   // TODO(srdjan): Handle merged instruction.
   SetValue(instr, non_constant_);
@@ skipping 1057 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart