Remove the instruction pointer from computations.

runtime/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 113 matching lines @@
   return ICDataHasReceiverClassId(ic_data, kDouble);
 }
 
 
 static bool HasOnlyTwoDouble(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1) &&
       ICDataHasReceiverArgumentClassIds(ic_data, kDouble, kDouble);
 }
 
 
-bool FlowGraphOptimizer::TryReplaceWithBinaryOp(InstanceCallComp* comp,
+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:
       if (HasOnlyTwoSmi(ic_data)) {
         operands_type = BinaryOpComp::kSmiOperands;
@@ skipping 27 matching lines @@
       if (HasOnlyTwoSmi(ic_data)) {
         operands_type = BinaryOpComp::kSmiOperands;
       } else {
         return false;
       }
       break;
     default:
       UNREACHABLE();
   };
 
-  ASSERT(comp->instr() != NULL);
   ASSERT(comp->InputCount() == 2);
   Value* left = comp->InputAt(0);
   Value* right = comp->InputAt(1);
   BinaryOpComp* bin_op =
       new BinaryOpComp(op_kind,
                        operands_type,
                        comp,
                        left,
                        right);
   bin_op->set_ic_data(comp->ic_data());
-  comp->ReplaceWith(bin_op);
+  instr->set_computation(bin_op);
   return true;
 }
 
 
-bool FlowGraphOptimizer::TryReplaceWithUnaryOp(InstanceCallComp* comp,
+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->instr() != NULL);
   ASSERT(comp->InputCount() == 1);
   Computation* unary_op = NULL;
   if (HasOneSmi(*comp->ic_data())) {
     unary_op = new UnarySmiOpComp(op_kind, comp, comp->InputAt(0));
   } else if (HasOneDouble(*comp->ic_data()) && (op_kind == Token::kNEGATE)) {
     unary_op = new NumberNegateComp(comp, comp->InputAt(0));
   }
   if (unary_op != NULL) {
     unary_op->set_ic_data(comp->ic_data());
-    comp->ReplaceWith(unary_op);
+    instr->set_computation(unary_op);
     return true;
   }
   return false;
 }
 
 
 // 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);
@@ skipping 51 matching lines @@
       // This will make sure that Smi is first if it exists.
       result.AddReceiverCheck(class_id,
                               Function::Handle(ic_data.GetTargetAt(i)));
     }
   }
   return result.raw();
 }
 
 
 // Only unique implicit instance getters can be currently handled.
-bool FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallComp* comp) {
+bool FlowGraphOptimizer::TryInlineInstanceGetter(BindInstr* instr,
+                                                 InstanceCallComp* comp) {
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   ASSERT(class_ids.length() == 1);
 
   if (target.kind() == RawFunction::kImplicitGetter) {
     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);
     load->set_ic_data(comp->ic_data());
-    comp->ReplaceWith(load);
+    instr->set_computation(load);
     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) ||
@@ skipping 13 matching lines @@
         break;
       default:
         UNREACHABLE();
     }
     LoadVMFieldComp* load = new LoadVMFieldComp(
         comp->InputAt(0),
         length_offset,
         Type::ZoneHandle(Type::IntInterface()));
     load->set_original(comp);
     load->set_ic_data(comp->ic_data());
-    comp->ReplaceWith(load);
+    instr->set_computation(load);
     return true;
   }
 
   if (recognized_kind == MethodRecognizer::kStringBaseLength) {
     ASSERT(HasOneTarget(ic_data));
     LoadVMFieldComp* load = new LoadVMFieldComp(
         comp->InputAt(0),
         String::length_offset(),
         Type::ZoneHandle(Type::IntInterface()));
     load->set_original(comp);
     load->set_ic_data(comp->ic_data());
-    comp->ReplaceWith(load);
+    instr->set_computation(load);
     return true;
   }
   return false;
 }
 
 
 // Inline only simple, frequently called core library methods.
-bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallComp* comp) {
+bool FlowGraphOptimizer::TryInlineInstanceMethod(BindInstr* instr,
+                                                 InstanceCallComp* comp) {
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   if ((ic_data.NumberOfChecks() == 0) || !HasOneTarget(ic_data)) {
     // No type feedback collected.
     return false;
   }
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   ObjectKind from_kind;
   if (recognized_kind == MethodRecognizer::kDoubleToDouble) {
     from_kind = kDouble;
   } 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);
-  coerce->set_instr(comp->instr());
-  comp->instr()->replace_computation(coerce);
+  instr->set_computation(coerce);
   return true;
 }
 
 
 
 
-void FlowGraphOptimizer::VisitInstanceCall(InstanceCallComp* comp) {
+void FlowGraphOptimizer::VisitInstanceCall(InstanceCallComp* comp,
+                                           BindInstr* instr) {
   if (comp->HasICData() && (comp->ic_data()->NumberOfChecks() > 0)) {
     const Token::Kind op_kind = comp->token_kind();
     if (Token::IsBinaryToken(op_kind) &&
-        TryReplaceWithBinaryOp(comp, op_kind)) {
+        TryReplaceWithBinaryOp(instr, comp, op_kind)) {
       return;
     }
-    if (Token::IsUnaryToken(op_kind) && TryReplaceWithUnaryOp(comp, op_kind)) {
+    if (Token::IsUnaryToken(op_kind) &&
+        TryReplaceWithUnaryOp(instr, comp, op_kind)) {
       return;
     }
-    if ((op_kind == Token::kGET) && TryInlineInstanceGetter(comp)) {
+    if ((op_kind == Token::kGET) && TryInlineInstanceGetter(instr, comp)) {
       return;
     }
-    if (TryInlineInstanceMethod(comp)) {
+    if (TryInlineInstanceMethod(instr, comp)) {
       return;
     }
     const intptr_t kMaxChecks = 4;
     if (comp->ic_data()->NumberOfChecks() <= kMaxChecks) {
       PolymorphicInstanceCallComp* call = new PolymorphicInstanceCallComp(comp);
       ICData& unary_checks =
           ICData::ZoneHandle(ToUnaryClassChecks(*comp->ic_data()));
       call->set_ic_data(&unary_checks);
-      comp->ReplaceWith(call);
+      instr->set_computation(call);
     }
   } else {
     // Mark it for deopt.
     PolymorphicInstanceCallComp* call = new PolymorphicInstanceCallComp(comp);
     call->set_ic_data(&ICData::ZoneHandle());
-    comp->ReplaceWith(call);
+    instr->set_computation(call);
   }
 }
 
 
-void FlowGraphOptimizer::VisitStaticCall(StaticCallComp* comp) {
+void FlowGraphOptimizer::VisitStaticCall(StaticCallComp* comp,
+                                         BindInstr* instr) {
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(comp->function());
   if (recognized_kind == MethodRecognizer::kMathSqrt) {
     comp->set_recognized(MethodRecognizer::kMathSqrt);
   }
 }
 
 
-bool FlowGraphOptimizer::TryInlineInstanceSetter(InstanceSetterComp* comp) {
+bool FlowGraphOptimizer::TryInlineInstanceSetter(BindInstr* instr,
+                                                 InstanceSetterComp* comp) {
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
   if (!HasOneTarget(ic_data)) {
     // TODO(srdjan): Implement when not all targets are the same.
     return false;
   }
   Function& target = Function::Handle();
   intptr_t class_id;
   ic_data.GetOneClassCheckAt(0, &class_id, &target);
   if (target.kind() != RawFunction::kImplicitSetter) {
     // Not an implicit setter.
     // TODO(srdjan): Inline special setters.
     return false;
   }
   // Inline implicit instance setter.
   const Field& field = Field::Handle(GetField(class_id, comp->field_name()));
   ASSERT(!field.IsNull());
   StoreInstanceFieldComp* store = new StoreInstanceFieldComp(
       field,
       comp->InputAt(0),
       comp->InputAt(1),
       comp);
   store->set_ic_data(comp->ic_data());
-  comp->ReplaceWith(store);
+  instr->set_computation(store);
   return true;
 }
 
 
 
-void FlowGraphOptimizer::VisitInstanceSetter(InstanceSetterComp* comp) {
+void FlowGraphOptimizer::VisitInstanceSetter(InstanceSetterComp* comp,
+                                             BindInstr* instr) {
   // TODO(srdjan): Add assignable check node if --enable_type_checks.
   if (comp->HasICData() && !FLAG_enable_type_checks) {
-    if (TryInlineInstanceSetter(comp)) {
+    if (TryInlineInstanceSetter(instr, comp)) {
       return;
     }
   }
   // TODO(srdjan): Polymorphic dispatch to setters or deoptimize.
 }
 
 
 enum IndexedAccessType {
   kIndexedLoad,
   kIndexedStore
@@ skipping 10 matching lines @@
   if (ic_data.NumberOfChecks() != 1) return kIllegalObjectKind;
   ASSERT(HasOneTarget(ic_data));
 
   Function& target = Function::Handle();
   intptr_t class_id;
   ic_data.GetOneClassCheckAt(0, &class_id, &target);
   return class_id;
 }
 
 
-void FlowGraphOptimizer::VisitLoadIndexed(LoadIndexedComp* comp) {
+void FlowGraphOptimizer::VisitLoadIndexed(LoadIndexedComp* comp,
+                                          BindInstr* instr) {
   const intptr_t class_id = ReceiverClassId(comp);
   switch (class_id) {
     case kArray:
     case kImmutableArray:
     case kGrowableObjectArray:
       comp->set_receiver_type(static_cast<ObjectKind>(class_id));
   }
 }
 
 
-void FlowGraphOptimizer::VisitStoreIndexed(StoreIndexedComp* comp) {
+void FlowGraphOptimizer::VisitStoreIndexed(StoreIndexedComp* comp,
+                                           BindInstr* instr) {
   if (FLAG_enable_type_checks) return;
 
   const intptr_t class_id = ReceiverClassId(comp);
   switch (class_id) {
     case kArray:
     case kGrowableObjectArray:
       comp->set_receiver_type(static_cast<ObjectKind>(class_id));
   }
 }
 
 
-static void TryFuseComparisonWithBranch(ComparisonComp* comp) {
-  Instruction* instr = comp->instr();
+static void TryFuseComparisonWithBranch(BindInstr* instr,
+                                        ComparisonComp* comp) {
   Instruction* next_instr = instr->successor();
   if ((next_instr != NULL) && next_instr->IsBranch()) {
     BranchInstr* branch = next_instr->AsBranch();
     UseVal* use = branch->value()->AsUse();
     if (instr == use->definition()) {
       comp->MarkFusedWithBranch(branch);
       branch->MarkFusedWithComparison();
       return;
     }
   }
   if ((next_instr != NULL) && next_instr->IsBind()) {
     Computation* next_comp = next_instr->AsBind()->computation();
     if (next_comp->IsBooleanNegate()) {
       Instruction* next_next_instr = next_instr->successor();
       if ((next_next_instr != NULL) && next_next_instr->IsBranch()) {
         BooleanNegateComp* negate = next_comp->AsBooleanNegate();
         BranchInstr* branch = next_next_instr->AsBranch();
-        if ((branch->value()->AsUse()->definition() == negate->instr()) &&
+        if ((branch->value()->AsUse()->definition() == next_instr) &&
             (negate->value()->AsUse()->definition() == instr)) {
           comp->MarkFusedWithBranch(branch);
           branch->MarkFusedWithComparison();
           branch->set_is_negated(true);
           instr->set_successor(next_next_instr);
           return;
         }
       }
     }
   }
 }
 
 
-void FlowGraphOptimizer::VisitRelationalOp(RelationalOpComp* comp) {
+void FlowGraphOptimizer::VisitRelationalOp(RelationalOpComp* comp,
+                                           BindInstr* instr) {
   if (!comp->HasICData()) return;
 
   const ICData& ic_data = *comp->ic_data();
   if (ic_data.NumberOfChecks() == 0) return;
   // TODO(srdjan): Add multiple receiver type support.
   if (ic_data.NumberOfChecks() != 1) return;
   ASSERT(HasOneTarget(ic_data));
 
   if (HasOnlyTwoSmi(ic_data)) {
     comp->set_operands_class_id(kSmi);
   } else if (HasOnlyTwoDouble(ic_data)) {
     comp->set_operands_class_id(kDouble);
   } else {
     return;
   }
 
   // For smi and double comparisons if the next instruction is a conditional
   // branch that uses the value of this comparison mark them as fused together
   // to avoid materializing a boolean value.
-  TryFuseComparisonWithBranch(comp);
+  TryFuseComparisonWithBranch(instr, comp);
 }
 
 
-void FlowGraphOptimizer::VisitStrictCompare(StrictCompareComp* comp) {
-  TryFuseComparisonWithBranch(comp);
+void FlowGraphOptimizer::VisitStrictCompare(StrictCompareComp* comp,
+                                            BindInstr* instr) {
+  TryFuseComparisonWithBranch(instr, comp);
 }
 
 
-void FlowGraphOptimizer::VisitEqualityCompare(EqualityCompareComp* comp) {
+void FlowGraphOptimizer::VisitEqualityCompare(EqualityCompareComp* comp,
+                                              BindInstr* instr) {
   if (comp->HasICData()) {
     // Replace binary checks with unary ones since EmitNative expects it.
     ICData& unary_checks =
         ICData::Handle(ToUnaryClassChecks(*comp->ic_data()));
     comp->set_ic_data(&unary_checks);
   }
 
-  TryFuseComparisonWithBranch(comp);
+  TryFuseComparisonWithBranch(instr, comp);
 }
 
 
 void FlowGraphOptimizer::VisitBind(BindInstr* instr) {
-  instr->computation()->Accept(this);
+  instr->computation()->Accept(this, instr);
 }
 
 
 
 FlowGraphAnalyzer::FlowGraphAnalyzer(
     const GrowableArray<BlockEntryInstr*>& blocks)
         :blocks_(blocks), is_leaf_(false) {}
 
 
 void FlowGraphAnalyzer::Analyze() {
   is_leaf_ = true;
   for (intptr_t i = 0; i < blocks_.length(); ++i) {
     BlockEntryInstr* block_entry = blocks_[i];
     Instruction* instr = block_entry->successor();
     while ((instr != NULL) && !instr->IsBlockEntry()) {
       LocationSummary* locs = instr->locs();
       if (locs != NULL) {
         if (locs->is_call()) {
           is_leaf_ = false;
           return;
         }
       }
       instr = instr->successor();
     }
   }
 }
 
 }  // namespace dart