Fix StoreIndexedInstr input representation requirements for Int32/Uint32 arrays.

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/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 1346 matching lines @@
   }
 
   if (array_cid == kTypedDataFloat32ArrayCid) {
     stored_value =
         new(I) DoubleToFloatInstr(
             new(I) Value(stored_value), call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     NULL,
                                     FlowGraph::kValue);
+  } else if (array_cid == kTypedDataInt32ArrayCid) {
+    stored_value = new(I) UnboxInt32Instr(
+        new(I) Value(stored_value),
+        call->deopt_id());
+    stored_value->AsUnboxIntN()->mark_truncating();
+    cursor = flow_graph()->AppendTo(cursor,
+                                    stored_value,
+                                    call->env(),
+                                    FlowGraph::kValue);
+  } else if (array_cid == kTypedDataUint32ArrayCid) {
+    stored_value = new(I) UnboxUint32Instr(
+        new(I) Value(stored_value),
+        call->deopt_id());
+    ASSERT(stored_value->AsUnboxIntN()->is_truncating());
+    cursor = flow_graph()->AppendTo(cursor,
+                                    stored_value,
+                                    call->env(),
+                                    FlowGraph::kValue);
   }
 
+

[Florian Schneider, 2014/09/11 09:38:53]

Remove extra \n.

[Vyacheslav Egorov (Google), 2014/09/11 11:49:17]

Done.

   const intptr_t index_scale = Instance::ElementSizeFor(array_cid);
   *last = new(I) StoreIndexedInstr(new(I) Value(array),
                                    new(I) Value(index),
                                    new(I) Value(stored_value),
                                    needs_store_barrier,
                                    index_scale,
                                    array_cid,
                                    call->deopt_id(),
                                    call->token_pos());
   flow_graph()->AppendTo(cursor,
@@ skipping 60 matching lines @@
     case MethodRecognizer::kInt16ArraySetIndexed:
     case MethodRecognizer::kUint16ArraySetIndexed:
       if (!ArgIsAlways(kSmiCid, ic_data, 2)) {
         return false;
       }
       value_check = ic_data.AsUnaryClassChecksForArgNr(2);
       return InlineSetIndexed(kind, target, call, receiver, token_pos,
                               &ic_data, value_check, entry, last);
     case MethodRecognizer::kInt32ArraySetIndexed:
     case MethodRecognizer::kUint32ArraySetIndexed:
-      if (!CanUnboxInt32()) {
-        return false;
-      }
       // Check that value is always smi or mint, if the platform has unboxed
       // mints (ia32 with at least SSE 4.1).

[Florian Schneider, 2014/09/11 09:38:53]

This comment is now out of date.

[Vyacheslav Egorov (Google), 2014/09/11 11:49:17]

Done.

       value_check = ic_data.AsUnaryClassChecksForArgNr(2);
-      if (FlowGraphCompiler::SupportsUnboxedMints()) {
-        if (!HasOnlySmiOrMint(value_check)) {
-          return false;
-        }
-      } else if (!HasOnlyOneSmi(value_check)) {
+      if (!HasOnlySmiOrMint(value_check)) {
         return false;
       }
       return InlineSetIndexed(kind, target, call, receiver, token_pos,
                               &ic_data, value_check, entry, last);
     case MethodRecognizer::kFloat32ArraySetIndexed:
     case MethodRecognizer::kFloat64ArraySetIndexed:
       if (!CanUnboxDouble()) {
         return false;
       }
       // Check that value is always double.
@@ skipping 93 matching lines @@
                                       ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseSetInt16:
       return InlineByteArrayViewStore(target, call, receiver, receiver_cid,
                                       kTypedDataInt16ArrayCid,
                                       ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseSetUint16:
       return InlineByteArrayViewStore(target, call, receiver, receiver_cid,
                                       kTypedDataUint16ArrayCid,
                                       ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseSetInt32:
-      if (!CanUnboxInt32()) {
-        return false;
-      }
       return InlineByteArrayViewStore(target, call, receiver, receiver_cid,
                                       kTypedDataInt32ArrayCid,
                                       ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseSetUint32:
-      if (!CanUnboxInt32()) {
-        return false;
-      }
       return InlineByteArrayViewStore(target, call, receiver, receiver_cid,
                                       kTypedDataUint32ArrayCid,
                                       ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseSetFloat32:
       if (!CanUnboxDouble()) {
         return false;
       }
       return InlineByteArrayViewStore(target, call, receiver, receiver_cid,
                                       kTypedDataFloat32ArrayCid,
                                       ic_data, entry, last);
@@ skipping 2122 matching lines @@
                                 Object::empty_array(),  // Dummy args. descr.
                                 Isolate::kNoDeoptId,
                                 1);
       value_check.AddReceiverCheck(kSmiCid, target);
       break;
     }
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
     // Prevent excessive deoptimization, assume full 32 bits used, and therefore
     // generate Mint on 32-bit architectures.
-    if (kSmiBits >= 32) {
+      if (kSmiBits >= 32) {
         value_check = ICData::New(flow_graph_->parsed_function().function(),
                                   i_call->function_name(),
                                   Object::empty_array(),  // Dummy args. descr.
                                   Isolate::kNoDeoptId,
                                   1);
         value_check.AddReceiverCheck(kSmiCid, target);
       }
       break;
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid: {
@@ skipping 37 matching lines @@
                   call);
   }
 
   if (view_cid == kTypedDataFloat32ArrayCid) {
     stored_value = new(I) DoubleToFloatInstr(
         new(I) Value(stored_value), call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     NULL,
                                     FlowGraph::kValue);
+  } else if (view_cid == kTypedDataInt32ArrayCid) {
+    stored_value = new(I) UnboxInt32Instr(
+        new(I) Value(stored_value),
+        call->deopt_id());
+    stored_value->AsUnboxIntN()->mark_truncating();
+    cursor = flow_graph()->AppendTo(cursor,
+                                    stored_value,
+                                    call->env(),
+                                    FlowGraph::kValue);
+  } else if (view_cid == kTypedDataUint32ArrayCid) {
+    stored_value = new(I) UnboxUint32Instr(
+        new(I) Value(stored_value),
+        call->deopt_id());
+    ASSERT(stored_value->AsUnboxIntN()->is_truncating());
+    cursor = flow_graph()->AppendTo(cursor,
+                                    stored_value,
+                                    call->env(),
+                                    FlowGraph::kValue);
   }
 
   StoreBarrierType needs_store_barrier = kNoStoreBarrier;
   *last = new(I) StoreIndexedInstr(new(I) Value(array),
                                    new(I) Value(index),
                                    new(I) Value(stored_value),
                                    needs_store_barrier,
                                    1,  // Index scale
                                    view_cid,
                                    call->deopt_id(),
@@ skipping 4483 matching lines @@
             SetValue(instr, non_constant_);
             break;
           }
           result = result.CheckAndCanonicalize(NULL);
           ASSERT(!result.IsNull());
           SetValue(instr, result);
           break;
         }
         case Token::kSHL:
         case Token::kSHR:
-          if (left.IsSmi() && right.IsSmi()) {
+          if (left.IsSmi() &&
+              right.IsSmi() &&
+              (Smi::Cast(right).Value() >= 0)) {
             Instance& result = Integer::ZoneHandle(I,
                 Smi::Cast(left_int).ShiftOp(op_kind, Smi::Cast(right_int)));
-            if (result.IsNull()) {
-              // TODO(regis): A bigint operation is required. Invoke dart?
-              // Punt for now.
-              SetValue(instr, non_constant_);
-              break;
-            }
             result = result.CheckAndCanonicalize(NULL);
             ASSERT(!result.IsNull());
             SetValue(instr, result);
           } else {
             SetValue(instr, non_constant_);
           }
           break;
         case Token::kBIT_AND:
         case Token::kBIT_OR:
         case Token::kBIT_XOR: {
@@ skipping 1770 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart