Optimize loads and stores to Int32Array and Uint32Array.

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 579 matching lines @@
     case kUint8ClampedArrayCid:
     case kInt16ArrayCid:
     case kUint16ArrayCid:
       // Check that value is always smi.
       value_check = call->ic_data()->AsUnaryClassChecksForArgNr(2);
       if ((value_check.NumberOfChecks() != 1) ||
           (value_check.GetReceiverClassIdAt(0) != kSmiCid)) {
         return false;
       }
       break;
-
+    case kInt32ArrayCid:
+    case kUint32ArrayCid: {
+      // Check if elements fit into a smi or the platform supports unboxed
+      // mints.
+      if ((kSmiBits < 32) && !FlowGraphCompiler::SupportsUnboxedMints()) {
+        return false;
+      }
+      // Check that value is always smi (or mint, if the platform has unboxed
+      // mints (ia32 with at least SSE 4.1)

[Kevin Millikin (Google), 2013/01/21 15:16:01]

The lack of period (and the unbalanced parens

[Florian Schneider, 2013/01/21 16:03:25]

Done.

+      value_check = call->ic_data()->AsUnaryClassChecksForArgNr(2);

[Kevin Millikin (Google), 2013/01/21 15:16:01]

ArgNr? Srsly?

+      for (intptr_t i = 0; i < value_check.NumberOfChecks(); i++) {
+        intptr_t cid = value_check.GetReceiverClassIdAt(i);
+        if (FlowGraphCompiler::SupportsUnboxedMints()) {
+          if ((cid != kSmiCid) && (cid != kMintCid)) {
+            return false;
+          }
+        } else if (cid != kSmiCid) {
+          return false;
+        }
+      }
+      break;
+    }
     case kFloat32ArrayCid:
     case kFloat64ArrayCid: {
       // Check that value is always double.
       value_check = call->ic_data()->AsUnaryClassChecksForArgNr(2);
       if ((value_check.NumberOfChecks() != 1) ||
           (value_check.GetReceiverClassIdAt(0) != kDoubleCid)) {
         return false;
       }
       break;
     }
@@ skipping 27 matching lines @@
         InsertBefore(call, load_type_args, NULL, Definition::kValue);
         instantiator = array->Copy();
         type_args = new Value(load_type_args);
         break;
       }
       case kInt8ArrayCid:
       case kUint8ArrayCid:
       case kUint8ClampedArrayCid:
       case kInt16ArrayCid:
       case kUint16ArrayCid:
+      case kInt32ArrayCid:
+      case kUint32ArrayCid:
         ASSERT(value_type.IsIntType());
         // Fall through.
       case kFloat32ArrayCid:
       case kFloat64ArrayCid: {
         instantiator = new Value(flow_graph_->constant_null());
         type_args = new Value(flow_graph_->constant_null());
         ASSERT((class_id != kFloat32ArrayCid && class_id != kFloat64ArrayCid) ||
                value_type.IsDoubleType());
         ASSERT(value_type.IsInstantiated());
         break;
@@ skipping 12 matching lines @@
     InsertBefore(call, assert_value, NULL, Definition::kValue);
   }
 
   Value* array = NULL;
   Value* index = NULL;
   intptr_t array_cid = PrepareIndexedOp(call, class_id, &array, &index);
   Value* value = call->ArgumentAt(2)->value();
   // Check if store barrier is needed.
   bool needs_store_barrier = true;
   if (!value_check.IsNull()) {
-    ASSERT(value_check.NumberOfChecks() == 1);
-    if (value_check.GetReceiverClassIdAt(0) == kSmiCid) {
+    needs_store_barrier = false;
+    if (value_check.NumberOfChecks() == 1 &&
+        value_check.GetReceiverClassIdAt(0) == kSmiCid) {
       InsertBefore(call,
                    new CheckSmiInstr(value->Copy(), call->deopt_id()),
                    call->env(),
                    Definition::kEffect);
-      needs_store_barrier = false;
     } else {
-      ASSERT(value_check.GetReceiverClassIdAt(0) == kDoubleCid);
       InsertBefore(call,
                    new CheckClassInstr(value->Copy(),
                                        call->deopt_id(),
                                        value_check),
                    call->env(),
                    Definition::kEffect);
-      needs_store_barrier = false;
     }
   }
 
   Definition* array_op =
       new StoreIndexedInstr(array, index, value,
                             needs_store_barrier, array_cid, call->deopt_id());
   call->ReplaceWith(array_op, current_iterator());
   RemovePushArguments(call);
   return true;
 }
 
 
 
 bool FlowGraphOptimizer::TryReplaceWithLoadIndexed(InstanceCallInstr* call) {
   const intptr_t class_id = ReceiverClassId(call);
   switch (class_id) {
     case kArrayCid:
     case kImmutableArrayCid:
     case kGrowableObjectArrayCid:
     case kFloat32ArrayCid:
     case kFloat64ArrayCid:
     case kInt8ArrayCid:
     case kUint8ArrayCid:
     case kUint8ClampedArrayCid:
     case kExternalUint8ArrayCid:
     case kInt16ArrayCid:
     case kUint16ArrayCid:
-      // Acceptable load index classes.
+      break;
+    case kInt32ArrayCid:
+    case kUint32ArrayCid:
+      // Check if elements fit into a smi or the platform supports unboxed
+      // mints.
+      if ((kSmiBits < 32) && !FlowGraphCompiler::SupportsUnboxedMints()) {
+        return false;
+      }
       break;
     default:
       return false;
   }
   Value* array = NULL;
   Value* index = NULL;
   intptr_t array_cid = PrepareIndexedOp(call, class_id, &array, &index);
   Definition* array_op = new LoadIndexedInstr(array, index, array_cid);
   call->ReplaceWith(array_op, current_iterator());
   RemovePushArguments(call);
@@ skipping 3808 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart