Remove classes Computation and BindInstr.

runtime/vm/flow_graph_inliner.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_inliner.h"
 
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/il_printer.h"
@@ skipping 10 matching lines @@
 class CallSiteInliner : public FlowGraphVisitor {
  public:
   explicit CallSiteInliner(FlowGraph* flow_graph)
       : FlowGraphVisitor(flow_graph->postorder()),
         caller_graph_(flow_graph),
         next_ssa_temp_index_(flow_graph->max_virtual_register_number()),
         inlined_(false) { }
 
   void TryInlining(const Function& function,
                    GrowableArray<Value*>* arguments,
-                   StaticCallComp* comp,  // TODO(zerny): Generalize to calls.
-                   BindInstr* instr) {
+                   StaticCallInstr* call) {
+    // TODO(zerny): Generalize to all calls.
+
     // Abort if the callee has named parameters.
     if (function.num_optional_parameters() > 0) {
       if (FLAG_trace_inlining) {
         OS::Print("Inline aborted %s\nReason: optional parameters\n",
                   function.ToFullyQualifiedCString());
       }
       return;
     }
 
     // Assuming no optional parameters the actual/formal count should match.
@@ skipping 47 matching lines @@
 
       callee_graph->ComputeUseLists();
 
       // TODO(zerny): Do optimization passes on the callee graph.
 
       // TODO(zerny): If result is more than size threshold then abort.
 
       // TODO(zerny): If effort is less than threshold then inline recursively.
 
       // Plug result in the caller graph.
-      caller_graph_->InlineCall(instr, comp, callee_graph);
+      caller_graph_->InlineCall(call, callee_graph);
       next_ssa_temp_index_ = caller_graph_->max_virtual_register_number();
 
       // Replace all the formal parameters with the actuals.
       for (intptr_t i = 0; i < arguments->length(); ++i) {
         Value* val = callee_graph->graph_entry()->start_env()->values()[i];
         ParameterInstr* param = val->definition()->AsParameter();
         ASSERT(param != NULL);
         param->ReplaceUsesWith((*arguments)[i]->definition());
       }
 
@@ skipping 12 matching lines @@
       isolate->set_long_jump_base(base);
       isolate->set_ic_data_array(old_ic_data.raw());
       if (FLAG_trace_inlining) {
         OS::Print("Inline aborted for %s\nReason: %s\n",
                   function.ToFullyQualifiedCString(),
                   error.ToErrorCString());
       }
     }
   }
 
-  void VisitBind(BindInstr* instr) {
-    instr->computation()->Accept(this, instr);
-  }
-
-  void VisitStaticCall(StaticCallComp* comp, BindInstr* instr) {
+  void VisitStaticCall(StaticCallInstr* instr) {
     if (FLAG_trace_inlining) OS::Print("Static call\n");
-    GrowableArray<Value*> arguments(comp->ArgumentCount());
-    for (int i = 0; i < comp->ArgumentCount(); ++i) {
-      arguments.Add(comp->ArgumentAt(i)->value());
+    GrowableArray<Value*> arguments(instr->ArgumentCount());
+    for (int i = 0; i < instr->ArgumentCount(); ++i) {
+      arguments.Add(instr->ArgumentAt(i)->value());
     }
-    TryInlining(comp->function(), &arguments, comp, instr);
+    TryInlining(instr->function(), &arguments, instr);
   }
 
   bool preformed_inlining() const { return inlined_; }
 
  private:
   FlowGraph* caller_graph_;
   intptr_t next_ssa_temp_index_;
   bool inlined_;
 };
 
@@ skipping 20 matching lines @@
     if (FLAG_trace_inlining && FLAG_print_flow_graph) {
       OS::Print("After Inlining of %s\n", flow_graph_->
                 parsed_function().function().ToFullyQualifiedCString());
       FlowGraphPrinter printer(*flow_graph_);
       printer.PrintBlocks();
     }
   }
 }
 
 }  // namespace dart