Revert "Remove classes Computation and BindInstr."

runtime/vm/il_printer.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/il_printer.h"
 
 #include "vm/intermediate_language.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 
@@ skipping 57 matching lines @@
   if (print_locations_ && (instr->locs() != NULL)) {
     instr->locs()->PrintTo(&f);
   }
   if (instr->lifetime_position() != -1) {
     OS::Print("%3d: ", instr->lifetime_position());
   }
   OS::Print("%s", str);
 }
 
 
+void FlowGraphPrinter::PrintComputation(Computation* comp) {
+  char str[1000];
+  BufferFormatter f(str, sizeof(str));
+  comp->PrintTo(&f);
+  OS::Print("%s", str);
+}
+
+
 void FlowGraphPrinter::PrintTypeCheck(const ParsedFunction& parsed_function,
                                       intptr_t token_pos,
                                       Value* value,
                                       const AbstractType& dst_type,
                                       const String& dst_name,
                                       bool eliminated) {
     const Script& script = Script::Handle(parsed_function.function().script());
     const char* compile_type_name = "unknown";
     if (value != NULL) {
       const AbstractType& type = AbstractType::Handle(value->CompileType());
@@ skipping 27 matching lines @@
       }
       const Class& cls =
           Class::Handle(Isolate::Current()->class_table()->At(class_ids[k]));
       f->Print("%s", String::Handle(cls.Name()).ToCString());
     }
   }
   f->Print("]");
 }
 
 
-void Definition::PrintTo(BufferFormatter* f) const {
+void Computation::PrintTo(BufferFormatter* f) const {
   // Do not access 'deopt_id()' as it asserts that the computation can
   // deoptimize.
   f->Print("%s:%d(", DebugName(), deopt_id_);
   PrintOperandsTo(f);
   f->Print(")");
 }
 
 
-void Definition::PrintOperandsTo(BufferFormatter* f) const {
+void Computation::PrintOperandsTo(BufferFormatter* f) const {
   for (int i = 0; i < InputCount(); ++i) {
     if (i > 0) f->Print(", ");
     if (InputAt(i) != NULL) InputAt(i)->PrintTo(f);
   }
 }
 
 
-void Definition::PrintToVisualizer(BufferFormatter* f) const {
-  PrintTo(f);
-}
-
-
 void Value::PrintTo(BufferFormatter* f) const {
   if (definition()->HasSSATemp()) {
     f->Print("v%d", definition()->ssa_temp_index());
   } else {
     f->Print("t%d", definition()->temp_index());
   }
 }
 
 
-void ConstantInstr::PrintOperandsTo(BufferFormatter* f) const {
+void ConstantComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("#%s", value().ToCString());
 }
 
 
-void AssertAssignableInstr::PrintOperandsTo(BufferFormatter* f) const {
+void AssertAssignableComp::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
   f->Print(", %s, '%s'%s",
            String::Handle(dst_type().Name()).ToCString(),
            dst_name().ToCString(),
            is_eliminated() ? " eliminated" : "");
   f->Print(" instantiator(");
   instantiator()->PrintTo(f);
   f->Print(")");
   f->Print(" instantiator_type_arguments(");
   instantiator_type_arguments()->PrintTo(f);
   f->Print(")");
 }
 
 
-void AssertBooleanInstr::PrintOperandsTo(BufferFormatter* f) const {
+void AssertBooleanComp::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
   f->Print("%s", is_eliminated() ? " eliminated" : "");
 }
 
 
-void ArgumentDefinitionTestInstr::PrintOperandsTo(BufferFormatter* f) const {
+void ArgumentDefinitionTestComp::PrintOperandsTo(BufferFormatter* f) const {
   saved_arguments_descriptor()->PrintTo(f);
   f->Print(", ?%s @%d",
            formal_parameter_name().ToCString(),
            formal_parameter_index());
 }
 
 
-void ClosureCallInstr::PrintOperandsTo(BufferFormatter* f) const {
+void ClosureCallComp::PrintOperandsTo(BufferFormatter* f) const {
   for (intptr_t i = 0; i < ArgumentCount(); ++i) {
     if (i > 0) f->Print(", ");
     ArgumentAt(i)->value()->PrintTo(f);
   }
 }
 
 
-void InstanceCallInstr::PrintOperandsTo(BufferFormatter* f) const {
+void InstanceCallComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s", function_name().ToCString());
   for (intptr_t i = 0; i < ArgumentCount(); ++i) {
     f->Print(", ");
     ArgumentAt(i)->value()->PrintTo(f);
   }
   if (HasICData()) {
     PrintICData(f, *ic_data());
   }
 }
 
 
-void PolymorphicInstanceCallInstr::PrintTo(BufferFormatter* f) const {
+void PolymorphicInstanceCallComp::PrintTo(BufferFormatter* f) const {
   f->Print("%s(", DebugName());
   instance_call()->PrintOperandsTo(f);
   f->Print(") ");
   PrintICData(f, ic_data());
 }
 
 
-void StrictCompareInstr::PrintOperandsTo(BufferFormatter* f) const {
+void StrictCompareComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", Token::Str(kind()));
   left()->PrintTo(f);
   f->Print(", ");
   right()->PrintTo(f);
 }
 
 
-void EqualityCompareInstr::PrintOperandsTo(BufferFormatter* f) const {
+void EqualityCompareComp::PrintOperandsTo(BufferFormatter* f) const {
   left()->PrintTo(f);
   f->Print(" %s ", Token::Str(kind()));
   right()->PrintTo(f);
   if (HasICData()) {
     PrintICData(f, *ic_data());
   }
 }
 
 
-void StaticCallInstr::PrintOperandsTo(BufferFormatter* f) const {
+void StaticCallComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s ", String::Handle(function().name()).ToCString());
   for (intptr_t i = 0; i < ArgumentCount(); ++i) {
     if (i > 0) f->Print(", ");
     ArgumentAt(i)->value()->PrintTo(f);
   }
 }
 
 
-void LoadLocalInstr::PrintOperandsTo(BufferFormatter* f) const {
+void LoadLocalComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s lvl:%d", local().name().ToCString(), context_level());
 }
 
 
-void StoreLocalInstr::PrintOperandsTo(BufferFormatter* f) const {
+void StoreLocalComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", local().name().ToCString());
   value()->PrintTo(f);
   f->Print(", lvl: %d", context_level());
 }
 
 
-void NativeCallInstr::PrintOperandsTo(BufferFormatter* f) const {
+void NativeCallComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s", native_name().ToCString());
 }
 
 
-void LoadInstanceFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
+void LoadInstanceFieldComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", String::Handle(field().name()).ToCString());
   instance()->PrintTo(f);
 }
 
 
-void StoreInstanceFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
+void StoreInstanceFieldComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", String::Handle(field().name()).ToCString());
   instance()->PrintTo(f);
   f->Print(", ");
   value()->PrintTo(f);
 }
 
 
-void LoadStaticFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
+void LoadStaticFieldComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s", String::Handle(field().name()).ToCString());
 }
 
 
-void StoreStaticFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
+void StoreStaticFieldComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", String::Handle(field().name()).ToCString());
   value()->PrintTo(f);
 }
 
 
-void InstanceOfInstr::PrintOperandsTo(BufferFormatter* f) const {
+void InstanceOfComp::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
   f->Print(" %s %s",
             negate_result() ? "ISNOT" : "IS",
             String::Handle(type().Name()).ToCString());
   f->Print(" instantiator(");
   instantiator()->PrintTo(f);
   f->Print(")");
   f->Print(" type-arg(");
   instantiator_type_arguments()->PrintTo(f);
   f->Print(")");
 }
 
 
-void RelationalOpInstr::PrintOperandsTo(BufferFormatter* f) const {
+void RelationalOpComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", Token::Str(kind()));
   left()->PrintTo(f);
   f->Print(", ");
   right()->PrintTo(f);
   if (HasICData()) {
     PrintICData(f, *ic_data());
   }
 }
 
 
-void AllocateObjectInstr::PrintOperandsTo(BufferFormatter* f) const {
+void AllocateObjectComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s", Class::Handle(constructor().Owner()).ToCString());
   for (intptr_t i = 0; i < ArgumentCount(); i++) {
     f->Print(", ");
     ArgumentAt(i)->value()->PrintTo(f);
   }
 }
 
 
-void AllocateObjectWithBoundsCheckInstr::PrintOperandsTo(
+void AllocateObjectWithBoundsCheckComp::PrintOperandsTo(
     BufferFormatter* f) const {
   f->Print("%s", Class::Handle(constructor().Owner()).ToCString());
   for (intptr_t i = 0; i < InputCount(); i++) {
     f->Print(", ");
     InputAt(i)->PrintTo(f);
   }
 }
 
 
-void CreateArrayInstr::PrintOperandsTo(BufferFormatter* f) const {
+void CreateArrayComp::PrintOperandsTo(BufferFormatter* f) const {
   for (int i = 0; i < ArgumentCount(); ++i) {
     if (i != 0) f->Print(", ");
     ArgumentAt(i)->value()->PrintTo(f);
   }
   if (ArgumentCount() > 0) f->Print(", ");
   element_type()->PrintTo(f);
 }
 
 
-void CreateClosureInstr::PrintOperandsTo(BufferFormatter* f) const {
+void CreateClosureComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s", function().ToCString());
   for (intptr_t i = 0; i < ArgumentCount(); ++i) {
     if (i > 0) f->Print(", ");
     ArgumentAt(i)->value()->PrintTo(f);
   }
 }
 
 
-void LoadVMFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
+void LoadVMFieldComp::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
   f->Print(", %d", offset_in_bytes());
 }
 
 
-void StoreVMFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
+void StoreVMFieldComp::PrintOperandsTo(BufferFormatter* f) const {
   dest()->PrintTo(f);
   f->Print(", %d, ", offset_in_bytes());
   value()->PrintTo(f);
 }
 
 
-void InstantiateTypeArgumentsInstr::PrintOperandsTo(BufferFormatter* f) const {
+void InstantiateTypeArgumentsComp::PrintOperandsTo(BufferFormatter* f) const {
   const String& type_args = String::Handle(type_arguments().Name());
   f->Print("%s, ", type_args.ToCString());
   instantiator()->PrintTo(f);
 }
 
 
-void ExtractConstructorTypeArgumentsInstr::PrintOperandsTo(
+void ExtractConstructorTypeArgumentsComp::PrintOperandsTo(
     BufferFormatter* f) const {
   const String& type_args = String::Handle(type_arguments().Name());
   f->Print("%s, ", type_args.ToCString());
   instantiator()->PrintTo(f);
 }
 
 
-void AllocateContextInstr::PrintOperandsTo(BufferFormatter* f) const {
+void AllocateContextComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%d", num_context_variables());
 }
 
 
-void CatchEntryInstr::PrintOperandsTo(BufferFormatter* f) const {
+void CatchEntryComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, %s",
            exception_var().name().ToCString(),
            stacktrace_var().name().ToCString());
 }
 
 
-void BinarySmiOpInstr::PrintOperandsTo(BufferFormatter* f) const {
+void BinarySmiOpComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", Token::Str(op_kind()));
   left()->PrintTo(f);
   f->Print(", ");
   right()->PrintTo(f);
 }
 
 
-void BinaryMintOpInstr::PrintOperandsTo(BufferFormatter* f) const {
+void BinaryMintOpComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", Token::Str(op_kind()));
   left()->PrintTo(f);
   f->Print(", ");
   right()->PrintTo(f);
 }
 
 
-void UnboxedDoubleBinaryOpInstr::PrintOperandsTo(BufferFormatter* f) const {
+void UnboxedDoubleBinaryOpComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", Token::Str(op_kind()));
   left()->PrintTo(f);
   f->Print(", ");
   right()->PrintTo(f);
 }
 
 
-void UnarySmiOpInstr::PrintOperandsTo(BufferFormatter* f) const {
+void UnarySmiOpComp::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", Token::Str(op_kind()));
   value()->PrintTo(f);
 }
 
 
-void CheckClassInstr::PrintOperandsTo(BufferFormatter* f) const {
+void CheckClassComp::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
   PrintICData(f, unary_checks());
 }
 
 
 void GraphEntryInstr::PrintTo(BufferFormatter* f) const {
   f->Print("%2d: [graph]", block_id());
   if (start_env_ != NULL) {
     f->Print("\n{\n");
     const GrowableArray<Value*>& values = start_env_->values();
@@ skipping 65 matching lines @@
   } else {
     f->Print("]");
   }
   if (HasParallelMove()) {
     f->Print("\n");
     parallel_move()->PrintTo(f);
   }
 }
 
 
+void BindInstr::PrintTo(BufferFormatter* f) const {
+  if (!is_used()) {
+    f->Print("    ");
+  } else if (HasSSATemp()) {
+    f->Print("    v%d <- ", ssa_temp_index());
+  } else {
+    f->Print("    t%d <- ", temp_index());
+  }
+  computation()->PrintTo(f);
+  PrintPropagatedType(f, *this);
+}
+
+
 void PushArgumentInstr::PrintTo(BufferFormatter* f) const {
   f->Print("    %s ", DebugName());
   value()->PrintTo(f);
 }
 
 
 void ReturnInstr::PrintTo(BufferFormatter* f) const {
   f->Print("    %s:%d ", DebugName(), deopt_id());
   value()->PrintTo(f);
 }
@@ skipping 15 matching lines @@
   } else {
     f->Print("    ");
   }
   f->Print(" goto %d", successor()->block_id());
 }
 
 
 void BranchInstr::PrintTo(BufferFormatter* f) const {
   f->Print("    %s ", DebugName());
   f->Print("if ");
-  comparison()->PrintTo(f);
+  computation()->PrintTo(f);
 
   f->Print(" goto (%d, %d)",
             true_successor()->block_id(),
             false_successor()->block_id());
 }
 
 
 void ParallelMoveInstr::PrintTo(BufferFormatter* f) const {
   f->Print("    %s ", DebugName());
   for (intptr_t i = 0; i < moves_.length(); i++) {
@@ skipping 174 matching lines @@
 void TargetEntryInstr::PrintToVisualizer(BufferFormatter* f) const {
   f->Print("_ [target");
   if (IsCatchEntry()) {
     f->Print(" catch %d]", catch_try_index());
   } else {
     f->Print("]");
   }
 }
 
 
+void BindInstr::PrintToVisualizer(BufferFormatter* f) const {
+  if (!is_used()) {
+    f->Print("_ ");
+  } else if (HasSSATemp()) {
+    f->Print("v%d ", ssa_temp_index());
+  } else {
+    f->Print("t%d ", temp_index());
+  }
+  computation()->PrintTo(f);
+}
+
+
 void PushArgumentInstr::PrintToVisualizer(BufferFormatter* f) const {
   f->Print("_ %s ", DebugName());
   value()->PrintTo(f);
 }
 
 
 void ReturnInstr::PrintToVisualizer(BufferFormatter* f) const {
   f->Print("_ %s:%d ", DebugName(), deopt_id());
   value()->PrintTo(f);
 }
@@ skipping 10 matching lines @@
 
 
 void GotoInstr::PrintToVisualizer(BufferFormatter* f) const {
   f->Print("_ goto B%d", successor()->block_id());
 }
 
 
 void BranchInstr::PrintToVisualizer(BufferFormatter* f) const {
   f->Print("_ %s ", DebugName());
   f->Print("if ");
-  comparison()->PrintTo(f);
+  computation()->PrintTo(f);
   f->Print(" goto (B%d, B%d)",
             true_successor()->block_id(),
             false_successor()->block_id());
 }
 
 
 void ParallelMoveInstr::PrintToVisualizer(BufferFormatter* f) const {
   UNIMPLEMENTED();
 }
 
 
 void Environment::PrintTo(BufferFormatter* f) const {
   f->Print(" env={ ");
   for (intptr_t i = 0; i < values_.length(); ++i) {
     if (i > 0) f->Print(", ");
     values_[i]->PrintTo(f);
     if ((locations_ != NULL) && !locations_[i].IsInvalid()) {
       f->Print(" [");
       locations_[i].PrintTo(f);
       f->Print("]");
     }
   }
   f->Print(" }");
 }
 
 }  // namespace dart