VM: Fix bug in polymorphic 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 814 matching lines @@
   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(ic_data.GetReceiverClassIdAt(0),
                                  target,
                                  call,
+                                 call->ArgumentAt(0),
                                  call->token_pos(),
                                  *call->ic_data(),
                                  &entry, &last)) {
     return false;
   }
   // 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);
@@ skipping 13 matching lines @@
   call->set_previous(NULL);
   call->set_next(NULL);
   return true;
 }
 
 
 bool FlowGraphOptimizer::InlineSetIndexed(
     MethodRecognizer::Kind kind,
     const Function& target,
     Instruction* call,
+    Definition* receiver,
     intptr_t token_pos,
     const ICData* ic_data,
     const ICData& value_check,
     TargetEntryInstr** entry,
     Definition** last) {
   intptr_t array_cid = MethodKindToCid(kind);
   ASSERT(array_cid != kIllegalCid);
 
-  Definition* array = call->ArgumentAt(0);
+  Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
   Definition* stored_value = call->ArgumentAt(2);
 
   *entry = new TargetEntryInstr(flow_graph()->allocate_block_id(),
                                 call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(call);
   Instruction* cursor = *entry;
   if (FLAG_enable_type_checks) {
     // Only type check for the value. A type check for the index is not
     // needed here because we insert a deoptimizing smi-check for the case
@@ skipping 105 matching lines @@
                          *last,
                          call->env(),
                          Definition::kEffect);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryInlineRecognizedMethod(intptr_t receiver_cid,
                                                    const Function& target,
                                                    Instruction* call,
+                                                   Definition* receiver,
                                                    intptr_t token_pos,
                                                    const ICData& ic_data,
                                                    TargetEntryInstr** entry,
                                                    Definition** last) {
   ICData& value_check = ICData::ZoneHandle();
   MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(target);
   switch (kind) {
     // Recognized [] operators.
     case MethodRecognizer::kImmutableArrayGetIndexed:
     case MethodRecognizer::kObjectArrayGetIndexed:
     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 InlineGetIndexed(kind, call, ic_data, entry, last);
+      return InlineGetIndexed(kind, call, receiver, ic_data, entry, last);
     case MethodRecognizer::kFloat32x4ArrayGetIndexed:
       if (!ShouldInlineSimd()) return false;
-      return InlineGetIndexed(kind, call, ic_data, entry, last);
+      return InlineGetIndexed(kind, call, receiver, ic_data, entry, last);
     case MethodRecognizer::kInt32ArrayGetIndexed:
     case MethodRecognizer::kUint32ArrayGetIndexed:
       if (!CanUnboxInt32()) return false;
-      return InlineGetIndexed(kind, call, ic_data, entry, last);
+      return InlineGetIndexed(kind, call, receiver, ic_data, entry, last);
 
     // Recognized []= operators.
     case MethodRecognizer::kObjectArraySetIndexed:
     case MethodRecognizer::kGrowableArraySetIndexed:
       if (ArgIsAlways(kSmiCid, ic_data, 2)) {
         value_check = ic_data.AsUnaryClassChecksForArgNr(2);
       }
-      return InlineSetIndexed(kind, target, call, token_pos,
+      return InlineSetIndexed(kind, target, call, receiver, token_pos,
                               &ic_data, value_check, entry, last);
     case MethodRecognizer::kInt8ArraySetIndexed:
     case MethodRecognizer::kUint8ArraySetIndexed:
     case MethodRecognizer::kUint8ClampedArraySetIndexed:
     case MethodRecognizer::kExternalUint8ArraySetIndexed:
     case MethodRecognizer::kExternalUint8ClampedArraySetIndexed:
     case MethodRecognizer::kInt16ArraySetIndexed:
     case MethodRecognizer::kUint16ArraySetIndexed:
       if (!ArgIsAlways(kSmiCid, ic_data, 2)) return false;
       value_check = ic_data.AsUnaryClassChecksForArgNr(2);
-      return InlineSetIndexed(kind, target, call, token_pos,
+      return InlineSetIndexed(kind, target, call, receiver, token_pos,
                               &ic_data, value_check, entry, last);
     case MethodRecognizer::kInt32ArraySetIndexed:
     case MethodRecognizer::kUint32ArraySetIndexed:
       if (!CanUnboxInt32()) return false;
       // Check that value is always smi or mint, if the platform has unboxed
       // mints (ia32 with at least SSE 4.1).
       value_check = ic_data.AsUnaryClassChecksForArgNr(2);
       if (FlowGraphCompiler::SupportsUnboxedMints()) {
         if (!HasOnlySmiOrMint(value_check)) {
           return false;
         }
       } else if (!HasOnlyOneSmi(value_check)) {
         return false;
       }
-      return InlineSetIndexed(kind, target, call, token_pos,
+      return InlineSetIndexed(kind, target, call, receiver, token_pos,
                               &ic_data, value_check, entry, last);
     case MethodRecognizer::kFloat32ArraySetIndexed:
     case MethodRecognizer::kFloat64ArraySetIndexed:
       // Check that value is always double.
       if (!ArgIsAlways(kDoubleCid, ic_data, 2)) return false;
       value_check = ic_data.AsUnaryClassChecksForArgNr(2);
-      return InlineSetIndexed(kind, target, call, token_pos,
+      return InlineSetIndexed(kind, target, call, receiver, token_pos,
                               &ic_data, value_check, entry, last);
     case MethodRecognizer::kFloat32x4ArraySetIndexed:
       if (!ShouldInlineSimd()) return false;
       // Check that value is always a Float32x4.
       if (!ArgIsAlways(kFloat32x4Cid, ic_data, 2)) return false;
       value_check = ic_data.AsUnaryClassChecksForArgNr(2);
-      return InlineSetIndexed(kind, target, call, token_pos,
+      return InlineSetIndexed(kind, target, call, receiver, token_pos,
                               &ic_data, value_check, entry, last);
     case MethodRecognizer::kByteArrayBaseGetInt8:
-      return InlineByteArrayViewLoad(call, receiver_cid,
+      return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataInt8ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetUint8:
-      return InlineByteArrayViewLoad(call, receiver_cid,
+      return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataUint8ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetInt16:
-      return InlineByteArrayViewLoad(call, receiver_cid,
+      return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataInt16ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetUint16:
-      return InlineByteArrayViewLoad(call, receiver_cid,
+      return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataUint16ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetInt32:
       if (!CanUnboxInt32()) return false;
-      return InlineByteArrayViewLoad(call, receiver_cid,
+      return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataInt32ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetUint32:
       if (!CanUnboxInt32()) return false;
-      return InlineByteArrayViewLoad(call, receiver_cid,
+      return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataUint32ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetFloat32:
-      return InlineByteArrayViewLoad(call, receiver_cid,
+      return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataFloat32ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetFloat64:
-      return InlineByteArrayViewLoad(call, receiver_cid,
+      return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataFloat64ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetFloat32x4:
       if (!ShouldInlineSimd()) return false;
-      return InlineByteArrayViewLoad(call, receiver_cid,
+      return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataFloat32x4ArrayCid,
                                      ic_data, entry, last);
     default:
       return false;
   }
 }
 
 
 intptr_t FlowGraphOptimizer::PrepareInlineIndexedOp(Instruction* call,
                                                     intptr_t array_cid,
@@ skipping 53 matching lines @@
                                      elements,
                                      NULL,
                                      Definition::kValue);
     *array = elements;
   }
   return array_cid;
 }
 
 bool FlowGraphOptimizer::InlineGetIndexed(MethodRecognizer::Kind kind,
                                           Instruction* call,
+                                          Definition* receiver,
                                           const ICData& ic_data,
                                           TargetEntryInstr** entry,
                                           Definition** last) {
   intptr_t array_cid = MethodKindToCid(kind);
   ASSERT(array_cid != kIllegalCid);
 
-  Definition* array = call->ArgumentAt(0);
+  Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
   *entry = new TargetEntryInstr(flow_graph()->allocate_block_id(),
                                 call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(call);
   Instruction* cursor = *entry;
 
   array_cid = PrepareInlineIndexedOp(call,
                                      array_cid,
                                      &array,
                                      index,
@@ skipping 29 matching lines @@
   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(ic_data.GetReceiverClassIdAt(0),
                                  target,
                                  call,
+                                 call->ArgumentAt(0),
                                  call->token_pos(),
                                  *call->ic_data(),
                                  &entry, &last)) {
     return false;
   }
 
   // Insert receiver class check.
   AddReceiverCheck(call);
   // Remove the original push arguments.
   for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
@@ skipping 1221 matching lines @@
       ReplaceCall(call, setFlag);
       return true;
     }
     default:
       return false;
   }
 }
 
 
 bool FlowGraphOptimizer::InlineByteArrayViewLoad(Instruction* call,
+                                                 Definition* receiver,
                                                  intptr_t array_cid,
                                                  intptr_t view_cid,
                                                  const ICData& ic_data,
                                                  TargetEntryInstr** entry,
                                                  Definition** last) {
   ASSERT(array_cid != kIllegalCid);
-  Definition* array = call->ArgumentAt(0);
+  Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
   *entry = new TargetEntryInstr(flow_graph()->allocate_block_id(),
                                 call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(call);
   Instruction* cursor = *entry;
 
   array_cid = PrepareInlineByteArrayViewOp(call,
                                            array_cid,
                                            view_cid,
                                            &array,
@@ skipping 115 matching lines @@
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   call->ic_data()->GetCheckAt(0, &class_ids, &target);
   const intptr_t receiver_cid = class_ids[0];
 
   TargetEntryInstr* entry;
   Definition* last;
   if (!TryInlineRecognizedMethod(receiver_cid,
                                  target,
                                  call,
+                                 call->ArgumentAt(0),
                                  call->token_pos(),
                                  *call->ic_data(),
                                  &entry, &last)) {
     return false;
   }
 
   // Insert receiver class check.
   AddReceiverCheck(call);
   // Remove the original push arguments.
   for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
@@ skipping 5227 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