Polymorphic inlining for some recognized methods in the optimizing compiler.

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/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 1372 matching lines @@
     // Reset value types if guarded_cid was used.
     for (Value::Iterator it(load->input_use_list());
          !it.Done();
          it.Advance()) {
       it.Current()->SetReachingType(NULL);
     }
   }
 }
 
 
-void FlowGraphOptimizer::InlineArrayLengthGetter(InstanceCallInstr* call,
-                                                 intptr_t length_offset,
-                                                 bool is_immutable,
-                                                 MethodRecognizer::Kind kind) {
-  AddReceiverCheck(call);
-
-  LoadFieldInstr* load = new LoadFieldInstr(
-      new Value(call->ArgumentAt(0)),
-      length_offset,
-      Type::ZoneHandle(Type::SmiType()),
-      is_immutable);
-  load->set_result_cid(kSmiCid);
-  load->set_recognized_kind(kind);
-  ReplaceCall(call, load);
-}
-
-
 void FlowGraphOptimizer::InlineGrowableArrayCapacityGetter(
     InstanceCallInstr* call) {
   AddReceiverCheck(call);
 
   // TODO(srdjan): type of load should be GrowableObjectArrayType.
   LoadFieldInstr* data_load = new LoadFieldInstr(
       new Value(call->ArgumentAt(0)),
       Array::data_offset(),
       Type::ZoneHandle(Type::DynamicType()));
   data_load->set_result_cid(kArrayCid);
@@ skipping 19 matching lines @@
       new Value(str),
       String::length_offset(),
       Type::ZoneHandle(Type::SmiType()),
       is_immutable);
   load->set_result_cid(kSmiCid);
   load->set_recognized_kind(MethodRecognizer::kStringBaseLength);
   return load;
 }
 
 
-void FlowGraphOptimizer::InlineStringLengthGetter(InstanceCallInstr* call) {
-  AddReceiverCheck(call);
-  LoadFieldInstr* load = BuildLoadStringLength(call->ArgumentAt(0));
-  ReplaceCall(call, load);
-}
-
-
 void FlowGraphOptimizer::InlineStringIsEmptyGetter(InstanceCallInstr* call) {
   AddReceiverCheck(call);
 
   LoadFieldInstr* load = BuildLoadStringLength(call->ArgumentAt(0));
   InsertBefore(call, load, NULL, Definition::kValue);
 
   ConstantInstr* zero = flow_graph()->GetConstant(Smi::Handle(Smi::New(0)));
   StrictCompareInstr* compare =
       new StrictCompareInstr(call->token_pos(),
                              Token::kEQ_STRICT,
                              new Value(load),
                              new Value(zero));
   ReplaceCall(call, compare);
 }
 
 
 void FlowGraphOptimizer::InlineObjectCid(InstanceCallInstr* call) {
   LoadClassIdInstr* load = new LoadClassIdInstr(new Value(call->ArgumentAt(0)));
   ReplaceCall(call, load);
 }
 
 
-static intptr_t OffsetForLengthGetter(MethodRecognizer::Kind kind) {
-  switch (kind) {
-    case MethodRecognizer::kObjectArrayLength:
-    case MethodRecognizer::kImmutableArrayLength:
-      return Array::length_offset();
-    case MethodRecognizer::kTypedDataLength:
-      // .length is defined in _TypedList which is the base class for internal
-      // and external typed data.
-      ASSERT(TypedData::length_offset() == ExternalTypedData::length_offset());
-      return TypedData::length_offset();
-    case MethodRecognizer::kGrowableArrayLength:
-      return GrowableObjectArray::length_offset();
-    default:
-      UNREACHABLE();
-      return 0;
-  }
-}
-
-
 bool FlowGraphOptimizer::InlineFloat32x4Getter(InstanceCallInstr* call,
                                                MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
                     call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
@@ skipping 164 matching lines @@
   // Not an implicit getter.
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   // VM objects length getter.
   switch (recognized_kind) {
     case MethodRecognizer::kObjectCid: {
       InlineObjectCid(call);
       return true;
     }
-    case MethodRecognizer::kObjectArrayLength:
-    case MethodRecognizer::kImmutableArrayLength:
-    case MethodRecognizer::kTypedDataLength:
-    case MethodRecognizer::kGrowableArrayLength: {
-      if (!ic_data.HasOneTarget()) {
-        // TODO(srdjan): Implement for mutiple targets.
-        return false;
-      }
-      const bool is_immutable =
-          (recognized_kind == MethodRecognizer::kObjectArrayLength) ||
-          (recognized_kind == MethodRecognizer::kImmutableArrayLength) ||
-          (recognized_kind == MethodRecognizer::kTypedDataLength);
-      InlineArrayLengthGetter(call,
-                              OffsetForLengthGetter(recognized_kind),
-                              is_immutable,
-                              recognized_kind);
-      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;
     case MethodRecognizer::kFloat32x4ShuffleX:
     case MethodRecognizer::kFloat32x4ShuffleY:
     case MethodRecognizer::kFloat32x4ShuffleZ:
     case MethodRecognizer::kFloat32x4ShuffleW:
     case MethodRecognizer::kFloat32x4GetSignMask:
       if (!ic_data.HasReceiverClassId(kFloat32x4Cid) ||
           !ic_data.HasOneTarget()) {
         return false;
       }
       return InlineFloat32x4Getter(call, recognized_kind);
     case MethodRecognizer::kUint32x4GetFlagX:
     case MethodRecognizer::kUint32x4GetFlagY:
     case MethodRecognizer::kUint32x4GetFlagZ:
     case MethodRecognizer::kUint32x4GetFlagW:
     case MethodRecognizer::kUint32x4GetSignMask: {
       if (!ic_data.HasReceiverClassId(kUint32x4Cid) ||
           !ic_data.HasOneTarget()) {
         return false;
       }
       return InlineUint32x4Getter(call, recognized_kind);
     }
     default:
-      ASSERT(recognized_kind == MethodRecognizer::kUnknown);
+      break;
   }
   return false;
 }
 
 
 LoadIndexedInstr* FlowGraphOptimizer::BuildStringCodeUnitAt(
     InstanceCallInstr* call,
     intptr_t cid) {
   Definition* str = call->ArgumentAt(0);
   Definition* index = call->ArgumentAt(1);
@@ skipping 5823 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart