Optimized loads/stores for scalar list: Uint8Clamped, Int8, Int16, Uint16.

runtime/vm/flow_graph_compiler.cc

 // Copyright (c) 2012, 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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
@@ skipping 1023 matching lines @@
 
 intptr_t FlowGraphCompiler::ElementSizeFor(intptr_t cid) {
   switch (cid) {
     case kArrayCid:
     case kImmutableArrayCid:
       return Array::kBytesPerElement;
     case kFloat32ArrayCid:
       return Float32Array::kBytesPerElement;
     case kFloat64ArrayCid:
       return Float64Array::kBytesPerElement;
+    case kInt8ArrayCid:
+      return Int8Array::kBytesPerElement;
     case kUint8ArrayCid:
       return Uint8Array::kBytesPerElement;
     case kUint8ClampedArrayCid:
       return Uint8ClampedArray::kBytesPerElement;
+    case kInt16ArrayCid:
+      return Int16Array::kBytesPerElement;
+    case kUint16ArrayCid:
+      return Uint16Array::kBytesPerElement;
     case kOneByteStringCid:
       return OneByteString::kBytesPerElement;
     case kTwoByteStringCid:
       return TwoByteString::kBytesPerElement;
+    case kExternalUint8ArrayCid:
+      return ExternalUint8Array::kBytesPerElement;
     default:
       UNIMPLEMENTED();
       return 0;
   }
 }
 
 
 intptr_t FlowGraphCompiler::DataOffsetFor(intptr_t cid) {
   switch (cid) {
     case kArrayCid:
     case kImmutableArrayCid:
       return Array::data_offset();
     case kFloat32ArrayCid:
       return Float32Array::data_offset();
     case kFloat64ArrayCid:
       return Float64Array::data_offset();
+    case kInt8ArrayCid:
+      return Int8Array::data_offset();
     case kUint8ArrayCid:
       return Uint8Array::data_offset();
     case kUint8ClampedArrayCid:
       return Uint8ClampedArray::data_offset();
+    case kInt16ArrayCid:
+      return Int16Array::data_offset();
+    case kUint16ArrayCid:
+      return Uint16Array::data_offset();
     case kOneByteStringCid:
       return OneByteString::data_offset();
     case kTwoByteStringCid:
       return TwoByteString::data_offset();
     default:
       UNIMPLEMENTED();
       return Array::data_offset();
   }
 }
 
@@ skipping 17 matching lines @@
   ASSERT(kSmiTagShift == 1);
   switch (cid) {
     case kArrayCid:
     case kImmutableArrayCid:
       return FieldAddress(
           array, index, TIMES_HALF_WORD_SIZE, Array::data_offset());
     case kFloat32ArrayCid:
       return FieldAddress(array, index, TIMES_2, Float32Array::data_offset());
     case kFloat64ArrayCid:
       return FieldAddress(array, index, TIMES_4, Float64Array::data_offset());
+    case kInt8ArrayCid:
+      return FieldAddress(array, index, TIMES_1, Int8Array::data_offset());
     case kUint8ArrayCid:
       return FieldAddress(array, index, TIMES_1, Uint8Array::data_offset());
     case kUint8ClampedArrayCid:
       return
           FieldAddress(array, index, TIMES_1, Uint8ClampedArray::data_offset());
+    case kInt16ArrayCid:
+      return FieldAddress(array, index, TIMES_1, Int16Array::data_offset());
+    case kUint16ArrayCid:
+      return FieldAddress(array, index, TIMES_1, Uint16Array::data_offset());
     case kOneByteStringCid:
       return FieldAddress(array, index, TIMES_1, OneByteString::data_offset());
     case kTwoByteStringCid:
       return FieldAddress(array, index, TIMES_1, TwoByteString::data_offset());
     default:
       UNIMPLEMENTED();
       return FieldAddress(SPREG, 0);
   }
 }
 
 
+Address FlowGraphCompiler::ExternalElementAddressForIntIndex(intptr_t cid,
+                                                             Register array,
+                                                             intptr_t index) {
+  return Address(array, index * ElementSizeFor(cid));
+}
+
+
+Address FlowGraphCompiler::ExternalElementAddressForRegIndex(intptr_t cid,
+                                                             Register array,
+                                                             Register index) {
+  switch (cid) {
+    case kExternalUint8ArrayCid:
+      return Address(array, index, TIMES_1, 0);
+    default:
+      UNIMPLEMENTED();
+      return Address(SPREG, 0);
+  }
+}
+
+
 // Returns true if checking against this type is a direct class id comparison.
 bool FlowGraphCompiler::TypeCheckAsClassEquality(const AbstractType& type) {
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   // Requires CHA, which can be applied in optimized code only,
   if (!FLAG_use_cha || !is_optimizing()) return false;
   if (!type.IsInstantiated()) return false;
   const Class& type_class = Class::Handle(type.type_class());
   // Signature classes have different type checking rules.
   if (type_class.IsSignatureClass()) return false;
   // Could be an interface check?
   if (type_class.is_implemented()) return false;
   const intptr_t type_cid = type_class.id();
   if (CHA::HasSubclasses(type_cid)) return false;
   if (type_class.HasTypeArguments()) {
     // Only raw types can be directly compared, thus disregarding type
     // arguments.
     const AbstractTypeArguments& type_arguments =
         AbstractTypeArguments::Handle(type.arguments());
     const bool is_raw_type = type_arguments.IsNull() ||
         type_arguments.IsRaw(type_arguments.Length());
     return is_raw_type;
   }
   return true;
 }
 
 }  // namespace dart