Separate the array/string .length load from the bounds check.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 1646 matching lines @@
 Instruction* Instruction::Canonicalize(FlowGraphOptimizer* optimizer) {
   return this;
 }
 
 
 Definition* Definition::Canonicalize(FlowGraphOptimizer* optimizer) {
   return this;
 }
 
 
+bool LoadFieldInstr::IsImmutableLengthLoad() const {
+  switch (recognized_kind()) {
+    case MethodRecognizer::kObjectArrayLength:
+    case MethodRecognizer::kImmutableArrayLength:
+    case MethodRecognizer::kByteArrayBaseLength:
+    case MethodRecognizer::kStringBaseLength:

[srdjan, 2013/02/01 19:01:28]

Why not add the byte arrays as well?

[Florian Schneider, 2013/02/06 13:08:19]

Byte arrays are handled by kByteArrayBaseLength above.

+      return true;
+    default:
+      return false;
+  }
+}
+
+
+MethodRecognizer::Kind LoadFieldInstr::RecognizedKindFromArrayCid(
+    intptr_t cid) {
+  switch (cid) {
+    case kArrayCid:
+      return MethodRecognizer::kObjectArrayLength;
+    case kImmutableArrayCid:
+      return MethodRecognizer::kImmutableArrayLength;
+    case kGrowableObjectArrayCid:
+      return MethodRecognizer::kGrowableArrayLength;
+    case kInt8ArrayCid:
+    case kUint8ArrayCid:
+    case kUint8ClampedArrayCid:
+    case kExternalUint8ArrayCid:
+    case kInt16ArrayCid:
+    case kUint16ArrayCid:
+    case kInt32ArrayCid:
+    case kUint32ArrayCid:
+    case kInt64ArrayCid:
+    case kUint64ArrayCid:
+    case kFloat32ArrayCid:
+    case kFloat64ArrayCid:
+      return MethodRecognizer::kByteArrayBaseLength;
+    default:
+      UNREACHABLE();
+      return MethodRecognizer::kUnknown;
+  }
+}
+
+
+Definition* LoadFieldInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
+  if (!IsImmutableLengthLoad()) return this;
+
+  // For fixed length arrays if the array is the result of a known constructor
+  // call we can replace the length load with the length argument passed to
+  // the constructor.
+  StaticCallInstr* call = value()->definition()->AsStaticCall();
+  if (call != NULL &&
+      call->is_known_constructor() &&
+      call->ResultCid() == kArrayCid) {
+    return call->ArgumentAt(1)->value()->definition();
+  }
+  return this;
+}
+
+
 Definition* AssertBooleanInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
   const intptr_t value_cid = value()->ResultCid();
   return (value_cid == kBoolCid) ? value()->definition() : this;
 }
 
 
 Definition* AssertAssignableInstr::Canonicalize(FlowGraphOptimizer* optimizer) {
   // (1) Replace the assert with its input if the input has a known compatible
   // class-id. The class-ids handled here are those that are known to be
   // results of IL instructions.
@@ skipping 827 matching lines @@
 
     *result = RangeBoundary::FromDefinition(b.symbol(), offset);
     return true;
   }
   return false;
 }
 
 
 static bool IsArrayLength(Definition* defn) {
   LoadFieldInstr* load = defn->AsLoadField();
-  return (load != NULL) &&
-      ((load->recognized_kind() == MethodRecognizer::kObjectArrayLength) ||
-       (load->recognized_kind() == MethodRecognizer::kImmutableArrayLength));
+  return (load != NULL) && load->IsImmutableLengthLoad();
 }
 
 
 void BinarySmiOpInstr::InferRange() {
   // TODO(vegorov): canonicalize BinarySmiOp to always have constant on the
   // right and a non-constant on the left.
   Definition* left_defn = left()->definition();
 
   Range* left_range = left_defn->range();
   Range* right_range = right()->definition()->range();
@@ skipping 242 matching lines @@
     default:
       UNREACHABLE();
   }
   return kPowRuntimeEntry;
 }
 
 
 #undef __
 
 }  // namespace dart