Unboxed load/store indexed of Float32x4

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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 345 matching lines @@
     if ((constant != NULL) && constant->value().IsSmi()) {
       const double dbl_val = Smi::Cast(constant->value()).AsDoubleValue();
       const Double& dbl_obj =
           Double::ZoneHandle(Double::New(dbl_val, Heap::kOld));
       ConstantInstr* double_const = new ConstantInstr(dbl_obj);
       InsertBefore(insert_before, double_const, NULL, Definition::kValue);
       converted = new UnboxDoubleInstr(new Value(double_const), deopt_id);
     } else {
       converted = new UnboxDoubleInstr(use->CopyWithType(), deopt_id);
     }
+  } else if ((from == kTagged) && (to == kUnboxedFloat32x4)) {
+    ASSERT((deopt_target != NULL) ||
+           (use->Type()->ToCid() == kFloat32x4Cid));
+    const intptr_t deopt_id = (deopt_target != NULL) ?
+        deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
+    converted = new UnboxFloat32x4Instr(use->CopyWithType(), deopt_id);
+  } else if ((from == kUnboxedFloat32x4) && (to == kTagged)) {
+    converted = new BoxFloat32x4Instr(use->CopyWithType(), NULL);
   }
   ASSERT(converted != NULL);
   use->BindTo(converted);
   InsertBefore(insert_before, converted, use->instruction()->env(),
                Definition::kValue);
 }
 
 
 void FlowGraphOptimizer::InsertConversionsFor(Definition* def) {
   const Representation from_rep = def->representation();
@@ skipping 497 matching lines @@
 bool FlowGraphOptimizer::TryReplaceWithLoadIndexed(InstanceCallInstr* call) {
   const intptr_t class_id = ReceiverClassId(call);
   // Set deopt_id to a valid id if the LoadIndexedInstr can cause deopt.
   intptr_t deopt_id = Isolate::kNoDeoptId;
   switch (class_id) {
     case kArrayCid:
     case kImmutableArrayCid:
     case kGrowableObjectArrayCid:
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
+    case kTypedDataFloat32x4ArrayCid:
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
       break;
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid: {
@@ skipping 570 matching lines @@
     case kTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
+    case kTypedDataFloat32x4ArrayCid:
       return true;
     default:
       return false;
   }
 }
 
 
 // Inline only simple, frequently called core library methods.
 bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
@@ skipping 113 matching lines @@
             call, class_ids[0], kTypedDataInt32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetUint32:
         return BuildByteArrayViewLoad(
             call, class_ids[0], kTypedDataUint32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetFloat32:
         return BuildByteArrayViewLoad(
             call, class_ids[0], kTypedDataFloat32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetFloat64:
         return BuildByteArrayViewLoad(
             call, class_ids[0], kTypedDataFloat64ArrayCid);
+      case MethodRecognizer::kByteArrayBaseGetFloat32x4:
+        return BuildByteArrayViewLoad(
+            call, class_ids[0], kTypedDataFloat32x4ArrayCid);
 
       // ByteArray setters.
       case MethodRecognizer::kByteArrayBaseSetInt8:
         return BuildByteArrayViewStore(
             call, class_ids[0], kTypedDataInt8ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint8:
         return BuildByteArrayViewStore(
             call, class_ids[0], kTypedDataUint8ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetInt16:
         return BuildByteArrayViewStore(
             call, class_ids[0], kTypedDataInt16ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint16:
         return BuildByteArrayViewStore(
             call, class_ids[0], kTypedDataUint16ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetInt32:
         return BuildByteArrayViewStore(
             call, class_ids[0], kTypedDataInt32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint32:
         return BuildByteArrayViewStore(
             call, class_ids[0], kTypedDataUint32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat32:
         return BuildByteArrayViewStore(
             call, class_ids[0], kTypedDataFloat32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat64:
         return BuildByteArrayViewStore(
             call, class_ids[0], kTypedDataFloat64ArrayCid);
+      case MethodRecognizer::kByteArrayBaseSetFloat32x4:
+        return BuildByteArrayViewStore(
+            call, class_ids[0], kTypedDataFloat32x4ArrayCid);
       default:
         // Unsupported method.
         return false;
     }
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::BuildByteArrayViewLoad(
@@ skipping 62 matching lines @@
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid: {
       // Check that value is always double.
       value_check = ICData::New(Function::Handle(),
                                 String::Handle(),
                                 Isolate::kNoDeoptId,
                                 1);
       value_check.AddReceiverCheck(kDoubleCid, Function::Handle());
       break;
     }
+    case kTypedDataFloat32x4ArrayCid: {
+      // Check that value is always Float32x4.
+      value_check = ICData::New(Function::Handle(),
+                                String::Handle(),
+                                Isolate::kNoDeoptId,
+                                1);
+      value_check.AddReceiverCheck(kFloat32x4Cid, Function::Handle());
+      break;
+    }
     default:
       // Array cids are already checked in the caller.
       UNREACHABLE();
       return NULL;
   }
 
   Definition* index = call->ArgumentAt(1);
   Definition* stored_value = call->ArgumentAt(2);
   if (!value_check.IsNull()) {
     AddCheckClass(stored_value, value_check, call->deopt_id(), call->env(),
@@ skipping 2623 matching lines @@
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle conversion.
     SetValue(instr, non_constant_);
   }
 }
 
 
+void ConstantPropagator::VisitUnboxFloat32x4(UnboxFloat32x4Instr* instr) {
+  const Object& value = instr->value()->definition()->constant_value();
+  if (IsNonConstant(value)) {
+    SetValue(instr, non_constant_);
+  } else if (IsConstant(value)) {
+    // TODO(kmillikin): Handle conversion.
+    SetValue(instr, non_constant_);
+  }
+}
+
+
+void ConstantPropagator::VisitBoxFloat32x4(BoxFloat32x4Instr* instr) {
+  const Object& value = instr->value()->definition()->constant_value();
+  if (IsNonConstant(value)) {
+    SetValue(instr, non_constant_);
+  } else if (IsConstant(value)) {
+    // TODO(kmillikin): Handle conversion.
+    SetValue(instr, non_constant_);
+  }
+}
+
+
 void ConstantPropagator::Analyze() {
   GraphEntryInstr* entry = graph_->graph_entry();
   reachable_->Add(entry->preorder_number());
   block_worklist_.Add(entry);
 
   while (true) {
     if (block_worklist_.is_empty()) {
       if (definition_worklist_.is_empty()) break;
       Definition* definition = definition_worklist_.RemoveLast();
       definition_marks_->Remove(definition->ssa_temp_index());
@@ skipping 376 matching lines @@
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
 
 
 }  // namespace dart