Refactor and simplify manual inlining in the flow graph optimizer.

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/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 1148 matching lines @@
     case MethodRecognizer::kFloat64x2ArraySetIndexed:
       return kTypedDataFloat64x2ArrayCid;
 
     default:
       break;
   }
   return kIllegalCid;
 }
 
 
-bool FlowGraphOptimizer::TryReplaceWithStoreIndexed(InstanceCallInstr* call) {
+bool FlowGraphOptimizer::TryReplaceWithIndexedOp(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
   if (!call->HasICData()) return false;
   const ICData& ic_data =
       ICData::Handle(I, call->ic_data()->AsUnaryClassChecks());
   if (ic_data.NumberOfChecks() != 1) {
     return false;
   }
-  ASSERT(ic_data.NumberOfUsedChecks() == 1);
-  ASSERT(ic_data.HasOneTarget());
-
-  const Function& target = Function::Handle(I, 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);
-    push->ReplaceUsesWith(push->value()->definition());
-    push->RemoveFromGraph();
-  }
-  // Replace all uses of this definition with the result.
-  call->ReplaceUsesWith(last);
-  // Finally insert the sequence other definition in place of this one in the
-  // graph.
-  call->previous()->LinkTo(entry->next());
-  entry->UnuseAllInputs();  // Entry block is not in the graph.
-  last->LinkTo(call);
-  // Remove through the iterator.
-  ASSERT(current_iterator()->Current() == call);
-  current_iterator()->RemoveCurrentFromGraph();
-  call->set_previous(NULL);
-  call->set_next(NULL);
-  return true;
+  return TryReplaceInstanceCallWithInline(call);
 }
 
 
 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 = receiver;
   Definition* index = call->ArgumentAt(1);
   Definition* stored_value = call->ArgumentAt(2);
 
@@ skipping 171 matching lines @@
     case MethodRecognizer::kImmutableArrayGetIndexed:
     case MethodRecognizer::kObjectArrayGetIndexed:
     case MethodRecognizer::kGrowableArrayGetIndexed:
     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, receiver, ic_data, entry, last);
+      return InlineGetIndexed(kind, call, receiver, entry, last);
     case MethodRecognizer::kFloat32ArrayGetIndexed:
     case MethodRecognizer::kFloat64ArrayGetIndexed:
       if (!CanUnboxDouble()) {
         return false;
       }
-      return InlineGetIndexed(kind, call, receiver, ic_data, entry, last);
+      return InlineGetIndexed(kind, call, receiver, entry, last);
     case MethodRecognizer::kFloat32x4ArrayGetIndexed:
     case MethodRecognizer::kFloat64x2ArrayGetIndexed:
       if (!ShouldInlineSimd()) {
         return false;
       }
-      return InlineGetIndexed(kind, call, receiver, ic_data, entry, last);
+      return InlineGetIndexed(kind, call, receiver, entry, last);
     case MethodRecognizer::kInt32ArrayGetIndexed:
     case MethodRecognizer::kUint32ArrayGetIndexed:
       if (!CanUnboxInt32()) return false;
-      return InlineGetIndexed(kind, call, receiver, ic_data, entry, last);
+      return InlineGetIndexed(kind, call, receiver, entry, last);
 
     case MethodRecognizer::kInt64ArrayGetIndexed:
       if (!ShouldInlineInt64ArrayOps()) {
         return false;
       }
-      return InlineGetIndexed(kind, call, receiver, ic_data, entry, last);
+      return InlineGetIndexed(kind, call, receiver, 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, receiver, token_pos,
-                              &ic_data, value_check, entry, last);
+                              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, receiver, token_pos,
-                              &ic_data, value_check, entry, last);
+                              value_check, entry, last);
     case MethodRecognizer::kInt32ArraySetIndexed:
     case MethodRecognizer::kUint32ArraySetIndexed:
       // Check that value is always smi or mint. We use Int32/Uint32 unboxing
       // which can only deal unbox these values.
       value_check = ic_data.AsUnaryClassChecksForArgNr(2);
       if (!HasOnlySmiOrMint(value_check)) {
         return false;
       }
       return InlineSetIndexed(kind, target, call, receiver, token_pos,
-                              &ic_data, value_check, entry, last);
+                              value_check, entry, last);
     case MethodRecognizer::kInt64ArraySetIndexed:
       if (!ShouldInlineInt64ArrayOps()) {
         return false;
       }
       return InlineSetIndexed(kind, target, call, receiver, token_pos,
-                              &ic_data, value_check, entry, last);
+                              value_check, entry, last);
     case MethodRecognizer::kFloat32ArraySetIndexed:
     case MethodRecognizer::kFloat64ArraySetIndexed:
       if (!CanUnboxDouble()) {
         return false;
       }
       // 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, receiver, token_pos,
-                              &ic_data, value_check, entry, last);
+                              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, receiver, token_pos,
-                              &ic_data, value_check, entry, last);
+                              value_check, entry, last);
     case MethodRecognizer::kFloat64x2ArraySetIndexed:
       if (!ShouldInlineSimd()) {
         return false;
       }
       // Check that value is always a Float32x4.
       if (!ArgIsAlways(kFloat64x2Cid, ic_data, 2)) {
         return false;
       }
       value_check = ic_data.AsUnaryClassChecksForArgNr(2);
       return InlineSetIndexed(kind, target, call, receiver, token_pos,
-                              &ic_data, value_check, entry, last);
+                              value_check, entry, last);
     case MethodRecognizer::kByteArrayBaseGetInt8:
       return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataInt8ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetUint8:
       return InlineByteArrayViewLoad(call, receiver, receiver_cid,
                                      kTypedDataUint8ArrayCid,
                                      ic_data, entry, last);
     case MethodRecognizer::kByteArrayBaseGetInt16:
       return InlineByteArrayViewLoad(call, receiver, receiver_cid,
@@ skipping 180 matching lines @@
                                      FlowGraph::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 = receiver;
   Definition* index = call->ArgumentAt(1);
   *entry = new(I) TargetEntryInstr(flow_graph()->allocate_block_id(),
                                    call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(I, call);
@@ skipping 30 matching lines @@
     *last = new(I) FloatToDoubleInstr(new(I) Value(*last), deopt_id);
     flow_graph()->AppendTo(cursor,
                            *last,
                            deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
                            FlowGraph::kValue);
   }
   return true;
 }
 
 
-bool FlowGraphOptimizer::TryReplaceWithLoadIndexed(InstanceCallInstr* call) {
-  // Check for monomorphic IC data.
-  if (!call->HasICData()) return false;
-  const ICData& ic_data =
-      ICData::Handle(I, call->ic_data()->AsUnaryClassChecks());
-  if (ic_data.NumberOfChecks() != 1) {
-    return false;
-  }
-  ASSERT(ic_data.NumberOfUsedChecks() == 1);
-  ASSERT(ic_data.HasOneTarget());
-
-  const Function& target = Function::Handle(I, 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);
-    push->ReplaceUsesWith(push->value()->definition());
-    push->RemoveFromGraph();
-  }
-  // Replace all uses of this definition with the result.
-  call->ReplaceUsesWith(last);
-  // Finally insert the sequence other definition in place of this one in the
-  // graph.
-  call->previous()->LinkTo(entry->next());
-  entry->UnuseAllInputs();  // Entry block is not in the graph.
-  last->LinkTo(call);
-  // Remove through the iterator.
-  ASSERT(current_iterator()->Current() == call);
-  current_iterator()->RemoveCurrentFromGraph();
-  call->set_previous(NULL);
-  call->set_next(NULL);
-  return true;
-}
-
-
 // Return true if d is a string of length one (a constant or result from
 // from string-from-char-code instruction.
 static bool IsLengthOneString(Definition* d) {
   if (d->IsConstant()) {
     const Object& obj = d->AsConstant()->value();
     if (obj.IsString()) {
       return String::Cast(obj).Length() == 1;
     } else {
       return false;
     }
@@ skipping 885 matching lines @@
     // inlining in FlowGraphInliner.
     return false;
   }
   InlineImplicitInstanceGetter(call);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceInstanceCallWithInline(
     InstanceCallInstr* call) {
-  ASSERT(call->HasICData());
   Function& target = Function::Handle(I);
   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,
@@ skipping 1545 matching lines @@
   const intptr_t max_checks = (op_kind == Token::kEQ)
       ? FLAG_max_equality_polymorphic_checks
       : FLAG_max_polymorphic_checks;
   if ((unary_checks.NumberOfChecks() > max_checks) &&
       InstanceCallNeedsClassCheck(instr, RawFunction::kRegularFunction)) {
     // Too many checks, it will be megamorphic which needs unary checks.
     instr->set_ic_data(&unary_checks);
     return;
   }
 
-  if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithStoreIndexed(instr)) {
+  if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithIndexedOp(instr)) {
     return;
   }
-  if ((op_kind == Token::kINDEX) && TryReplaceWithLoadIndexed(instr)) {
+  if ((op_kind == Token::kINDEX) && TryReplaceWithIndexedOp(instr)) {
     return;
   }
 
   if (op_kind == Token::kEQ && TryReplaceWithEqualityOp(instr, op_kind)) {
     return;
   }
 
   if (Token::IsRelationalOperator(op_kind) &&
       TryReplaceWithRelationalOp(instr, op_kind)) {
     return;
@@ skipping 4175 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, *slots);
   }
 }
 
 
 }  // namespace dart