Bug fix and cleanup of inlining of recognized [] methods.

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 674 matching lines @@
   }
   call->ReplaceWith(replacement, current_iterator());
 }
 
 
 static intptr_t ReceiverClassId(InstanceCallInstr* call) {
   if (!call->HasICData()) return kIllegalCid;
 
   const ICData& ic_data = ICData::Handle(call->ic_data()->AsUnaryClassChecks());
 
-  if (ic_data.NumberOfChecks() == 0) return kIllegalCid;
-  // TODO(vegorov): Add multiple receiver type support.
   if (ic_data.NumberOfChecks() != 1) return kIllegalCid;
   ASSERT(ic_data.HasOneTarget());
 
   Function& target = Function::Handle();
   intptr_t class_id;
   ic_data.GetOneClassCheckAt(0, &class_id, &target);
   return class_id;
 }
 
 
@@ skipping 355 matching lines @@
     case MethodRecognizer::kGrowableArrayGetIndexed:
     case MethodRecognizer::kFloat32ArrayGetIndexed:
     case MethodRecognizer::kFloat64ArrayGetIndexed:
     case MethodRecognizer::kInt8ArrayGetIndexed:
     case MethodRecognizer::kUint8ArrayGetIndexed:
     case MethodRecognizer::kUint8ClampedArrayGetIndexed:
     case MethodRecognizer::kExternalUint8ArrayGetIndexed:
     case MethodRecognizer::kExternalUint8ClampedArrayGetIndexed:
     case MethodRecognizer::kInt16ArrayGetIndexed:
     case MethodRecognizer::kUint16ArrayGetIndexed:
+      return TryInlineGetIndexed(kind, call, ic_data, entry, last);
+    case MethodRecognizer::kFloat32x4ArrayGetIndexed:
+      if (!ShouldInlineSimd()) return false;
+      return TryInlineGetIndexed(kind, call, ic_data, entry, last);
     case MethodRecognizer::kInt32ArrayGetIndexed:
     case MethodRecognizer::kUint32ArrayGetIndexed:
-    case MethodRecognizer::kFloat32x4ArrayGetIndexed:
+      if (!CanUnboxInt32()) return false;
       return TryInlineGetIndexed(kind, call, ic_data, entry, last);
     default:
       return false;
   }
 }
 
 
 bool FlowGraphOptimizer::TryInlineGetIndexed(MethodRecognizer::Kind kind,
                                              Instruction* call,
                                              const ICData& ic_data,
@@ skipping 84 matching lines @@
                                deopt_id);
   flow_graph()->AppendTo(cursor,
                          *last,
                          deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
                          Definition::kValue);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithLoadIndexed(InstanceCallInstr* call) {
-  const intptr_t class_id = ReceiverClassId(call);
-  switch (class_id) {
-    case kArrayCid:
-    case kImmutableArrayCid:
-    case kGrowableObjectArrayCid:
-    case kTypedDataFloat32ArrayCid:
-    case kTypedDataFloat64ArrayCid:
-    case kTypedDataInt8ArrayCid:
-    case kTypedDataUint8ArrayCid:
-    case kTypedDataUint8ClampedArrayCid:
-    case kExternalTypedDataUint8ArrayCid:
-    case kExternalTypedDataUint8ClampedArrayCid:
-    case kTypedDataInt16ArrayCid:
-    case kTypedDataUint16ArrayCid:
-      break;
-    case kTypedDataFloat32x4ArrayCid:
-      if (!ShouldInlineSimd()) {
-        return false;
-      }
-      break;
-    case kTypedDataInt32ArrayCid:
-    case kTypedDataUint32ArrayCid:
-        if (!CanUnboxInt32()) return false;
-      break;
-    default:
-      return false;
+  // Check for monomorphic IC data.
+  if (!call->HasICData()) return false;
+  const ICData& ic_data = ICData::Handle(call->ic_data()->AsUnaryClassChecks());
+  if (ic_data.NumberOfChecks() != 1) return false;
+  ASSERT(ic_data.HasOneTarget());
+
+  const Function& target = Function::Handle(ic_data.GetTargetAt(0));
+  TargetEntryInstr* entry;
+  Definition* last;
+  if (!TryInlineRecognizedMethod(target,
+                                 call,
+                                 *call->ic_data(),
+                                 &entry, &last)) {
+    return false;
   }
 
-  const Function& target =
-      Function::Handle(call->ic_data()->GetTargetAt(0));
-  TargetEntryInstr* entry;
-  Definition* last;
-  ASSERT(class_id == MethodKindToCid(MethodRecognizer::RecognizeKind(target)));
-  bool success = TryInlineRecognizedMethod(target,
-                                           call,
-                                           *call->ic_data(),
-                                           &entry, &last);
-  ASSERT(success);
   // Insert receiver class check.
   AddReceiverCheck(call);
   // Remove the original push arguments.
   for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
     PushArgumentInstr* push = call->PushArgumentAt(i);
     push->ReplaceUsesWith(push->value()->definition());
     push->RemoveFromGraph();
   }
   // Replace all uses of this definition with the result.
   call->ReplaceUsesWith(last);
@@ skipping 6426 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