Inline getters of byte array view in the optimized flow graph.

runtime/vm/flow_graph_compiler_ia32.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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 1486 matching lines @@
     case ABOVE:         return unsigned_left > unsigned_right;
     case ABOVE_EQUAL:   return unsigned_left >= unsigned_right;
     default:
       UNIMPLEMENTED();
       return false;
   }
 }
 
 
 FieldAddress FlowGraphCompiler::ElementAddressForIntIndex(intptr_t cid,
+                                                          intptr_t index_scale,
                                                           Register array,
                                                           intptr_t index) {
   const int64_t disp =
-      static_cast<int64_t>(index) * ElementSizeFor(cid) + DataOffsetFor(cid);
+      static_cast<int64_t>(index) * index_scale + DataOffsetFor(cid);
   ASSERT(Utils::IsInt(32, disp));
   return FieldAddress(array, static_cast<int32_t>(disp));
 }
 
 
-FieldAddress FlowGraphCompiler::ElementAddressForRegIndex(intptr_t cid,
-                                                          Register array,
-                                                          Register index) {
-  // Note that index is smi-tagged, (i.e, times 2) for all arrays with element
-  // size > 1. For Uint8Array and OneByteString the index is expected to be
-  // untagged before accessing.
+static ScaleFactor ToScaleFactor(intptr_t index_scale) {

[srdjan, 2013/02/06 17:11:16]

I understand this function but find it confusing (integer index scale is
actually index_scale * 2, except when it is not (index_scale == 1)). 

[Florian Schneider, 2013/02/14 12:20:51]

It is indeed a little subtle. The code before had the same underlying issue
though( that element size 1 is different)

Any suggestions to improve it?

[srdjan, 2013/02/14 16:36:35]

No :-(.

+  // Note that index is expected smi-tagged, (i.e, times 2) for all arrays with
+  // index scale factor > 1. E.g., for Uint8Array and OneByteString the index is
+  // expected to be untagged before accessing.
   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 kInt32ArrayCid:
-      return FieldAddress(array, index, TIMES_2, Int32Array::data_offset());
-    case kUint32ArrayCid:
-      return FieldAddress(array, index, TIMES_2, Uint32Array::data_offset());
-    case kOneByteStringCid:
-      return FieldAddress(array, index, TIMES_1, OneByteString::data_offset());
-    case kTwoByteStringCid:
-      return FieldAddress(array, index, TIMES_1, TwoByteString::data_offset());
+  switch (index_scale) {
+    case 1: return TIMES_1;
+    case 2: return TIMES_1;
+    case 4: return TIMES_2;
+    case 8: return TIMES_4;
     default:
-      UNIMPLEMENTED();
-      return FieldAddress(SPREG, 0);
+      UNREACHABLE();
+      return TIMES_1;
   }
 }
 
 
-Address FlowGraphCompiler::ExternalElementAddressForIntIndex(intptr_t cid,
-                                                             Register array,
-                                                             intptr_t index) {
-  return Address(array, index * ElementSizeFor(cid));
+FieldAddress FlowGraphCompiler::ElementAddressForRegIndex(intptr_t cid,
+                                                          intptr_t index_scale,
+                                                          Register array,
+                                                          Register index) {
+  return FieldAddress(array,
+                      index,
+                      ToScaleFactor(index_scale),
+                      DataOffsetFor(cid));
 }
 
 
-Address FlowGraphCompiler::ExternalElementAddressForRegIndex(intptr_t cid,
-                                                             Register array,
-                                                             Register index) {
+Address FlowGraphCompiler::ExternalElementAddressForIntIndex(
+    intptr_t cid,
+    intptr_t index_scale,
+    Register array,
+    intptr_t index) {
+  return Address(array, index * index_scale);
+}
+
+
+Address FlowGraphCompiler::ExternalElementAddressForRegIndex(
+    intptr_t cid,
+    intptr_t index_scale,
+    Register array,
+    Register index) {
   switch (cid) {
     case kExternalUint8ArrayCid:
-      return Address(array, index, TIMES_1, 0);
+      return Address(array, index, ToScaleFactor(index_scale), 0);
     default:
       UNIMPLEMENTED();
       return Address(SPREG, 0);
   }
 }
 
 
 #undef __
 #define __ compiler_->assembler()->
 
@@ skipping 149 matching lines @@
   __ popl(ECX);
   __ popl(EAX);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32