Inline ByteArrayBase.length in the flow graph optimizer.

runtime/vm/flow_graph_optimizer.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/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 956 matching lines @@
       length_offset,
       Type::ZoneHandle(Type::SmiType()),
       is_immutable);
   load->set_result_cid(kSmiCid);
   load->set_recognized_kind(kind);
   call->ReplaceWith(load, current_iterator());
   RemovePushArguments(call);
 }
 
 
-void FlowGraphOptimizer::InlineGArrayCapacityGetter(InstanceCallInstr* call) {
+void FlowGraphOptimizer::InlineGrowableArrayCapacityGetter(
+    InstanceCallInstr* call) {
   // Check receiver class.
   AddCheckClass(call, call->ArgumentAt(0)->value()->Copy());
 
   // TODO(srdjan): type of load should be GrowableObjectArrayType.
   LoadFieldInstr* data_load = new LoadFieldInstr(
       call->ArgumentAt(0)->value(),
       Array::data_offset(),
       Type::ZoneHandle(Type::DynamicType()));
   data_load->set_result_cid(kArrayCid);
   InsertBefore(call, data_load, NULL, Definition::kValue);
@@ skipping 45 matching lines @@
 
   StrictCompareInstr* compare =
       new StrictCompareInstr(Token::kEQ_STRICT,
                              new Value(load),
                              new Value(zero));
   call->ReplaceWith(compare, current_iterator());
   RemovePushArguments(call);
 }
 
 
+static intptr_t OffsetForLengthGetter(MethodRecognizer::Kind kind) {
+  switch (kind) {
+    case MethodRecognizer::kObjectArrayLength:
+    case MethodRecognizer::kImmutableArrayLength:
+      return Array::length_offset();
+    case MethodRecognizer::kByteArrayBaseLength:
+      return ByteArray::length_offset();
+    case MethodRecognizer::kGrowableArrayLength:
+      return GrowableObjectArray::length_offset();
+    default:
+      UNREACHABLE();
+      return 0;
+  }
+}
+
+
 // Only unique implicit instance getters can be currently handled.
 bool FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
   Function& target = Function::Handle(ic_data.GetTargetAt(0));
   if (target.kind() == RawFunction::kImplicitGetter) {
     if (!ic_data.HasOneTarget()) {
       // TODO(srdjan): Implement for mutiple targets.
       return false;
     }
     InlineImplicitInstanceGetter(call);
     return true;
   }
 
   // Not an implicit getter.
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   // VM objects length getter.
-  if ((recognized_kind == MethodRecognizer::kObjectArrayLength) ||
-      (recognized_kind == MethodRecognizer::kImmutableArrayLength) ||
-      (recognized_kind == MethodRecognizer::kGrowableArrayLength)) {
-    if (!ic_data.HasOneTarget()) {
-      // TODO(srdjan): Implement for mutiple targets.
-      return false;
+  switch (recognized_kind) {
+    case MethodRecognizer::kObjectArrayLength:
+    case MethodRecognizer::kImmutableArrayLength:
+    case MethodRecognizer::kByteArrayBaseLength:
+    case MethodRecognizer::kGrowableArrayLength: {
+      if (!ic_data.HasOneTarget()) {
+        // TODO(srdjan): Implement for mutiple targets.
+        return false;
+      }
+      const bool is_immutable =
+          (recognized_kind != MethodRecognizer::kGrowableArrayLength);
+      InlineArrayLengthGetter(call,
+                              OffsetForLengthGetter(recognized_kind),
+                              is_immutable,
+                              recognized_kind);
+      return true;
     }
-    switch (recognized_kind) {
-      case MethodRecognizer::kObjectArrayLength:
-      case MethodRecognizer::kImmutableArrayLength:
-        InlineArrayLengthGetter(call,
-                                Array::length_offset(),
-                                true,
-                                recognized_kind);
-        break;
-      case MethodRecognizer::kGrowableArrayLength:
-        InlineArrayLengthGetter(call,
-                                GrowableObjectArray::length_offset(),
-                                false,
-                                recognized_kind);
-        break;
-      default:
-        UNREACHABLE();
-    }
-    return true;
+    case MethodRecognizer::kGrowableArrayCapacity:
+      InlineGrowableArrayCapacityGetter(call);
+      return true;
+    case MethodRecognizer::kStringBaseLength:
+      if (!ic_data.HasOneTarget()) {
+        // Target is not only StringBase_get_length.
+        return false;
+      }
+      InlineStringLengthGetter(call);
+      return true;
+    case MethodRecognizer::kStringBaseIsEmpty:
+      if (!ic_data.HasOneTarget()) {
+        // Target is not only StringBase_get_isEmpty.
+        return false;
+      }
+      InlineStringIsEmptyGetter(call);
+      return true;
+    default:
+      ASSERT(recognized_kind == MethodRecognizer::kUnknown);
   }
-
-  if (recognized_kind == MethodRecognizer::kGrowableArrayCapacity) {
-    InlineGArrayCapacityGetter(call);
-    return true;
-  }
-
-  if (recognized_kind == MethodRecognizer::kStringBaseLength) {
-    if (!ic_data.HasOneTarget()) {
-      // Target is not only StringBase_get_length.
-      return false;
-    }
-    InlineStringLengthGetter(call);
-    return true;
-  }
-
-  if (recognized_kind == MethodRecognizer::kStringBaseIsEmpty) {
-    if (!ic_data.HasOneTarget()) {
-      // Target is not only StringBase_get_isEmpty.
-      return false;
-    }
-    InlineStringIsEmptyGetter(call);
-    return true;
-  }
-
   return false;
 }
 
 
 StringCharCodeAtInstr* FlowGraphOptimizer::BuildStringCharCodeAt(
     InstanceCallInstr* call,
     intptr_t cid) {
   Value* str = call->ArgumentAt(0)->value();
   Value* index = call->ArgumentAt(1)->value();
   AddCheckClass(call, str->Copy());
@@ skipping 3143 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart