Add Uint32x4List to typed_data

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 794 matching lines @@
       return kTypedDataInt32ArrayCid;
 
     case MethodRecognizer::kUint32ArrayGetIndexed:
     case MethodRecognizer::kUint32ArraySetIndexed:
       return kTypedDataUint32ArrayCid;
 
     case MethodRecognizer::kFloat32x4ArrayGetIndexed:
     case MethodRecognizer::kFloat32x4ArraySetIndexed:
       return kTypedDataFloat32x4ArrayCid;
 
+    case MethodRecognizer::kUint32x4ArrayGetIndexed:
+    case MethodRecognizer::kUint32x4ArraySetIndexed:
+      return kTypedDataUint32x4ArrayCid;
+
     default:
       break;
   }
   return kIllegalCid;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithStoreIndexed(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
   if (!call->HasICData()) return false;
@@ skipping 286 matching lines @@
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetFloat64:
       return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataFloat64ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetFloat32x4:
       if (!ShouldInlineSimd()) return false;
       return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataFloat32x4ArrayCid,
                                      ic_data, entry, last);
+    case MethodRecognizer::kByteArrayBaseGetUint32x4:
+      if (!ShouldInlineSimd()) return false;
+      return InlineByteArrayViewLoad(call, receiver, receiver_cid,
+                                     kTypedDataUint32x4ArrayCid,
+                                     ic_data, entry, last);
     default:
       return false;
   }
 }
 
 
 intptr_t FlowGraphOptimizer::PrepareInlineIndexedOp(Instruction* call,
                                                     intptr_t array_cid,
                                                     Definition** array,
                                                     Definition* index,
@@ skipping 779 matching lines @@
     case kExternalTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid:
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid:
     case kTypedDataFloat32x4ArrayCid:
+    case kTypedDataUint32x4ArrayCid:
       return true;
     default:
       return false;
   }
 }
 
 
 // Inline only simple, frequently called core library methods.
 bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
@@ skipping 153 matching lines @@
       case MethodRecognizer::kByteArrayBaseGetInt32:
         return BuildByteArrayViewLoad(call, kTypedDataInt32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetUint32:
         return BuildByteArrayViewLoad(call, kTypedDataUint32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetFloat32:
         return BuildByteArrayViewLoad(call, kTypedDataFloat32ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetFloat64:
         return BuildByteArrayViewLoad(call, kTypedDataFloat64ArrayCid);
       case MethodRecognizer::kByteArrayBaseGetFloat32x4:
         return BuildByteArrayViewLoad(call, kTypedDataFloat32x4ArrayCid);
+      case MethodRecognizer::kByteArrayBaseGetUint32x4:
+        return BuildByteArrayViewLoad(call, kTypedDataUint32x4ArrayCid);
 
       // ByteArray setters.
       case MethodRecognizer::kByteArrayBaseSetInt8:
         return BuildByteArrayViewStore(call, kTypedDataInt8ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint8:
         return BuildByteArrayViewStore(call, kTypedDataUint8ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetInt16:
         return BuildByteArrayViewStore(call, kTypedDataInt16ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint16:
         return BuildByteArrayViewStore(call, kTypedDataUint16ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetInt32:
         return BuildByteArrayViewStore(call, kTypedDataInt32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetUint32:
         return BuildByteArrayViewStore(call, kTypedDataUint32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat32:
         return BuildByteArrayViewStore(call, kTypedDataFloat32ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat64:
         return BuildByteArrayViewStore(call, kTypedDataFloat64ArrayCid);
       case MethodRecognizer::kByteArrayBaseSetFloat32x4:
         return BuildByteArrayViewStore(call, kTypedDataFloat32x4ArrayCid);
+      case MethodRecognizer::kByteArrayBaseSetUint32x4:
+        return BuildByteArrayViewStore(call, kTypedDataUint32x4ArrayCid);
       default:
         // Unsupported method.
         return false;
     }
   }
 
   if ((class_ids[0] == kFloat32x4Cid) && (ic_data.NumberOfChecks() == 1)) {
     return TryInlineFloat32x4Method(call, recognized_kind);
   }
 
@@ skipping 486 matching lines @@
                                      NULL,
                                      Definition::kValue);
     *array = elements;
   }
   return array_cid;
 }
 
 
 bool FlowGraphOptimizer::BuildByteArrayViewLoad(InstanceCallInstr* call,
                                                 intptr_t view_cid) {
-  if ((view_cid == kTypedDataFloat32x4ArrayCid) && !ShouldInlineSimd()) {
+  bool simd_view = (view_cid == kTypedDataFloat32x4ArrayCid) ||
+                   (view_cid == kTypedDataUint32x4ArrayCid);
+  if (simd_view && !ShouldInlineSimd()) {
     return false;
   }
 
   ASSERT(call->HasICData());
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   call->ic_data()->GetCheckAt(0, &class_ids, &target);
   const intptr_t receiver_cid = class_ids[0];
 
   TargetEntryInstr* entry;
@@ skipping 27 matching lines @@
   ASSERT(current_iterator()->Current() == call);
   current_iterator()->RemoveCurrentFromGraph();
   call->set_previous(NULL);
   call->set_next(NULL);
   return true;
 }
 
 
 bool FlowGraphOptimizer::BuildByteArrayViewStore(InstanceCallInstr* call,
                                                  intptr_t view_cid) {
-  if ((view_cid == kTypedDataFloat32x4ArrayCid) && !ShouldInlineSimd()) {
+  bool simd_view = (view_cid == kTypedDataFloat32x4ArrayCid) ||
+                   (view_cid == kTypedDataUint32x4ArrayCid);
+  if (simd_view && !ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->HasICData());
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   call->ic_data()->GetCheckAt(0, &class_ids, &target);
   const intptr_t receiver_cid = class_ids[0];
 
   Definition* array = call->ArgumentAt(0);
   PrepareByteArrayViewOp(call, receiver_cid, view_cid, &array);
@@ skipping 33 matching lines @@
     case kTypedDataFloat64ArrayCid: {
       // Check that value is always double.
       value_check = ICData::New(flow_graph_->parsed_function().function(),
                                 call->function_name(),
                                 Object::empty_array(),  // Dummy args. descr.
                                 Isolate::kNoDeoptId,
                                 1);
       value_check.AddReceiverCheck(kDoubleCid, target);
       break;
     }
+    case kTypedDataUint32x4ArrayCid: {
+      // Check that value is always Uint32x4.
+      value_check = ICData::New(flow_graph_->parsed_function().function(),
+                                call->function_name(),
+                                Object::empty_array(),  // Dummy args. descr.
+                                Isolate::kNoDeoptId,
+                                1);
+      value_check.AddReceiverCheck(kUint32x4Cid, target);
+      break;
+    }
     case kTypedDataFloat32x4ArrayCid: {
       // Check that value is always Float32x4.
       value_check = ICData::New(flow_graph_->parsed_function().function(),
                                 call->function_name(),
                                 Object::empty_array(),  // Dummy args. descr.
                                 Isolate::kNoDeoptId,
                                 1);
       value_check.AddReceiverCheck(kFloat32x4Cid, target);
       break;
     }
@@ skipping 5152 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