Refactor building arguments for InstanceCall and fix deoptimization environment for pushed argument…

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/flow_graph_builder.h"
 #include "vm/il_printer.h"
 #include "vm/object_store.h"
 
@@ skipping 96 matching lines @@
   return ICDataHasReceiverClassId(ic_data, kDouble);
 }
 
 
 static bool HasOnlyTwoDouble(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1) &&
       ICDataHasReceiverArgumentClassIds(ic_data, kDouble, kDouble);
 }
 
 
+static void RemovePushArguments(InstanceCallComp* comp) {
+  // Remove original push arguments.
+  for (intptr_t i = 0; i < comp->ArgumentCount(); ++i) {
+    comp->ArgumentAt(i)->RemoveFromGraph();
+  }
+}
+
+
 bool FlowGraphOptimizer::TryReplaceWithBinaryOp(BindInstr* instr,
                                                 InstanceCallComp* comp,
                                                 Token::Kind op_kind) {
   BinaryOpComp::OperandsType operands_type = BinaryOpComp::kDynamicOperands;
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   switch (op_kind) {
     case Token::kADD:
     case Token::kSUB:
     case Token::kMUL:
@@ skipping 29 matching lines @@
       if (HasOnlyTwoSmi(ic_data)) {
         operands_type = BinaryOpComp::kSmiOperands;
       } else {
         return false;
       }
       break;
     default:
       UNREACHABLE();
   };
 
-  ASSERT(comp->InputCount() == 2);
-  Value* left = comp->InputAt(0);
-  Value* right = comp->InputAt(1);
+  ASSERT(comp->ArgumentCount() == 2);
+  Value* left = comp->ArgumentAt(0)->value();
+  Value* right = comp->ArgumentAt(1)->value();
   BinaryOpComp* bin_op =
       new BinaryOpComp(op_kind,
                        operands_type,
                        comp,
                        left,
                        right);
   bin_op->set_ic_data(comp->ic_data());
   instr->set_computation(bin_op);
+  RemovePushArguments(comp);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithUnaryOp(BindInstr* instr,
                                                InstanceCallComp* comp,
                                                Token::Kind op_kind) {
   if (comp->ic_data()->NumberOfChecks() != 1) {
     // TODO(srdjan): Not yet supported.
     return false;
   }
-  ASSERT(comp->InputCount() == 1);
+  ASSERT(comp->ArgumentCount() == 1);
   Computation* unary_op = NULL;
   if (HasOneSmi(*comp->ic_data())) {
-    unary_op = new UnarySmiOpComp(op_kind, comp, comp->InputAt(0));
+    unary_op = new UnarySmiOpComp(op_kind, comp, comp->ArgumentAt(0)->value());
   } else if (HasOneDouble(*comp->ic_data()) && (op_kind == Token::kNEGATE)) {
-    unary_op = new NumberNegateComp(comp, comp->InputAt(0));
+    unary_op = new NumberNegateComp(comp, comp->ArgumentAt(0)->value());
   }
-  if (unary_op != NULL) {
-    unary_op->set_ic_data(comp->ic_data());
-    instr->set_computation(unary_op);
-    return true;
-  }
-  return false;
+  if (unary_op == NULL) return false;
+
+  unary_op->set_ic_data(comp->ic_data());
+  instr->set_computation(unary_op);
+  RemovePushArguments(comp);
+  return true;
 }
 
 
 // Returns true if all targets are the same.
 // TODO(srdjan): if targets are native use their C_function to compare.
 static bool HasOneTarget(const ICData& ic_data) {
   ASSERT(ic_data.NumberOfChecks() > 0);
   const Function& first_target = Function::Handle(ic_data.GetTargetAt(0));
   Function& test_target = Function::Handle();
   for (intptr_t i = 1; i < ic_data.NumberOfChecks(); i++) {
@@ skipping 39 matching lines @@
     if (!HasOneTarget(ic_data)) {
       // TODO(srdjan): Implement for mutiple targets.
       return false;
     }
     // Inline implicit instance getter.
     const String& field_name =
         String::Handle(Field::NameFromGetter(comp->function_name()));
     const Field& field = Field::Handle(GetField(class_ids[0], field_name));
     ASSERT(!field.IsNull());
     LoadInstanceFieldComp* load = new LoadInstanceFieldComp(
-        field, comp->InputAt(0), comp);
+        field, comp->ArgumentAt(0)->value(), comp);
     load->set_ic_data(comp->ic_data());
     instr->set_computation(load);
+    RemovePushArguments(comp);
     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 (!HasOneTarget(ic_data)) {
       // TODO(srdjan): Implement for mutiple targets.
       return false;
     }
     intptr_t length_offset = -1;
     switch (recognized_kind) {
       case MethodRecognizer::kObjectArrayLength:
       case MethodRecognizer::kImmutableArrayLength:
         length_offset = Array::length_offset();
         break;
       case MethodRecognizer::kGrowableArrayLength:
         length_offset = GrowableObjectArray::length_offset();
         break;
       default:
         UNREACHABLE();
     }
     LoadVMFieldComp* load = new LoadVMFieldComp(
-        comp->InputAt(0),
+        comp->ArgumentAt(0)->value(),
         length_offset,
         Type::ZoneHandle(Type::IntInterface()));
     load->set_original(comp);
     load->set_ic_data(comp->ic_data());
     instr->set_computation(load);
+    RemovePushArguments(comp);
     return true;
   }
 
   if (recognized_kind == MethodRecognizer::kStringBaseLength) {
     if (!HasOneTarget(ic_data)) {
       // Target is not only StringBase_get_length.
       return false;
     }
     ASSERT(HasOneTarget(ic_data));
     LoadVMFieldComp* load = new LoadVMFieldComp(
-        comp->InputAt(0),
+        comp->ArgumentAt(0)->value(),
         String::length_offset(),
         Type::ZoneHandle(Type::IntInterface()));
     load->set_original(comp);
     load->set_ic_data(comp->ic_data());
     instr->set_computation(load);
+    RemovePushArguments(comp);
     return true;
   }
   return false;
 }
 
 
 // Inline only simple, frequently called core library methods.
 bool FlowGraphOptimizer::TryInlineInstanceMethod(BindInstr* instr,
                                                  InstanceCallComp* comp) {
   ASSERT(comp->HasICData());
@@ skipping 14 matching lines @@
   } else if (recognized_kind == MethodRecognizer::kIntegerToDouble) {
     from_kind = kSmi;
   } else {
     return false;
   }
 
   if (class_ids[0] != from_kind) {
     return false;
   }
   ToDoubleComp* coerce = new ToDoubleComp(
-      comp->InputAt(0), from_kind, comp);
+      comp->ArgumentAt(0)->value(), from_kind, comp);
   instr->set_computation(coerce);
+  RemovePushArguments(comp);
   return true;
 }
 
 
 
 
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallComp* comp,
                                            BindInstr* instr) {
   if (comp->HasICData() && (comp->ic_data()->NumberOfChecks() > 0)) {
     const Token::Kind op_kind = comp->token_kind();
@@ skipping 181 matching lines @@
       LocationSummary* locs = it.Current()->locs();
       if ((locs != NULL) && locs->is_call()) {
         is_leaf_ = false;
         return;
       }
     }
   }
 }
 
 }  // namespace dart