More preparation for removal of dart:scalarlist

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 798 matching lines @@
       case kExternalTypedDataUint8ClampedArrayCid:
       case kTypedDataInt16ArrayCid:
       case kTypedDataUint16ArrayCid:
       case kTypedDataInt32ArrayCid:
       case kTypedDataUint32ArrayCid:
         ASSERT(value_type.IsIntType());
         // Fall through.
       case kTypedDataFloat32ArrayCid:
       case kTypedDataFloat64ArrayCid: {
         type_args = instantiator = flow_graph_->constant_null();
-        ASSERT((class_id != kFloat32ArrayCid &&
-                class_id != kFloat64ArrayCid &&
-                class_id != kTypedDataFloat32ArrayCid &&
+        ASSERT((class_id != kTypedDataFloat32ArrayCid &&
                 class_id != kTypedDataFloat64ArrayCid) ||
                value_type.IsDoubleType());
         ASSERT(value_type.IsInstantiated());
         break;
       }
       default:
         // TODO(fschneider): Add support for other array types.
         UNREACHABLE();
     }
     AssertAssignableInstr* assert_value =
         new AssertAssignableInstr(call->token_pos(),
                                   new Value(stored_value),
                                   new Value(instantiator),
                                   new Value(type_args),
                                   value_type,
                                   Symbols::Value());
     // Newly inserted instructions that can deoptimize or throw an exception
     // must have a deoptimization id that is valid for lookup in the unoptimized
     // code.
     assert_value->deopt_id_ = call->deopt_id();
     InsertBefore(call, assert_value, call->env(), Definition::kValue);
   }
 
   intptr_t array_cid = PrepareIndexedOp(call, class_id, &array, &index);
   // Check if store barrier is needed. Byte arrays don't need a store barrier.
   StoreBarrierType needs_store_barrier =
-      RawObject::IsByteArrayClassId(array_cid)
-          ? kNoStoreBarrier
-          : kEmitStoreBarrier;
+      (RawObject::IsTypedDataClassId(array_cid) ||
+       RawObject::IsTypedDataViewClassId(array_cid) ||
+       RawObject::IsExternalTypedDataClassId(array_cid)) ? kNoStoreBarrier
+                                                         : kEmitStoreBarrier;
   if (!value_check.IsNull()) {
     // No store barrier needed because checked value is a smi, an unboxed mint
     // or unboxed double.
     needs_store_barrier = kNoStoreBarrier;
     AddCheckClass(stored_value, value_check, call->deopt_id(), call->env(),
                   call);
   }
 
   intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
   Definition* array_op = new StoreIndexedInstr(new Value(array),
@@ skipping 755 matching lines @@
     InstanceCallInstr* call,
     intptr_t receiver_cid,
     intptr_t view_cid) {
   Definition* array = call->ArgumentAt(0);
   PrepareByteArrayViewOp(call, receiver_cid, view_cid, &array);
 
   // Optimistically build a smi-checked load for Int32 and Uint32
   // loads on ia32 like we do for normal array loads, and only revert to
   // mint case after deoptimizing here.
   intptr_t deopt_id = Isolate::kNoDeoptId;
-  if ((view_cid == kInt32ArrayCid || view_cid == kUint32ArrayCid) &&
+  if ((view_cid == kTypedDataInt32ArrayCid ||
+       view_cid == kTypedDataUint32ArrayCid) &&
       call->ic_data()->deopt_reason() == kDeoptUnknown) {
     deopt_id = call->deopt_id();
   }
   Definition* byte_index = call->ArgumentAt(1);
   LoadIndexedInstr* array_op = new LoadIndexedInstr(new Value(array),
                                                     new Value(byte_index),
                                                     1,  // Index scale.
                                                     view_cid,
                                                     deopt_id);
   ReplaceCall(call, array_op);
@@ skipping 1471 matching lines @@
             // because only those values that are in the GEN set
             // will ever be used.
             gen->RemoveAll(kill_by_offset_[offset_in_words]);
 
             // Only forward stores to normal arrays and float64 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() == kFloat64ArrayCid) {
+                array_store->class_id() == kTypedDataFloat64ArrayCid) {
               Definition* load = map_->Lookup(instr->AsDefinition());
               if (load != NULL) {
                 // Store has a corresponding numbered load. Try forwarding
                 // stored value to it.
                 gen->Add(load->expr_id());
                 if (out_values == NULL) out_values = CreateBlockOutValues();
                 (*out_values)[load->expr_id()] = GetStoredValue(instr);
               }
             }
           }
@@ skipping 1485 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