Migrate logging infrastructure Isolate->Thread

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/flow_graph_range_analysis.h"
 #include "vm/intermediate_language.h"
 #include "vm/os.h"
 #include "vm/parser.h"
@@ skipping 65 matching lines @@
   return found;
 }
 
 
 bool FlowGraphPrinter::ShouldPrint(const Function& function) {
   return PassesFilter(FLAG_print_flow_graph_filter, function);
 }
 
 
 void FlowGraphPrinter::PrintGraph(const char* phase, FlowGraph* flow_graph) {
-  LogBlock lb(Isolate::Current());
-  ISL_Print("*** BEGIN CFG\n%s\n", phase);
+  LogBlock lb(Thread::Current());
+  THR_Print("*** BEGIN CFG\n%s\n", phase);
   FlowGraphPrinter printer(*flow_graph);
   printer.PrintBlocks();
-  ISL_Print("*** END CFG\n");
+  THR_Print("*** END CFG\n");
   fflush(stdout);
 }
 
 
 void FlowGraphPrinter::PrintBlock(BlockEntryInstr* block,
                                   bool print_locations) {
   // Print the block entry.
   PrintOneInstruction(block, print_locations);
-  ISL_Print("\n");
+  THR_Print("\n");
   // And all the successors in the block.
   for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
     PrintOneInstruction(current, print_locations);
-    ISL_Print("\n");
+    THR_Print("\n");
   }
 }
 
 
 void FlowGraphPrinter::PrintBlocks() {
   if (!function_.IsNull()) {
-    ISL_Print("==== %s\n", function_.ToFullyQualifiedCString());
+    THR_Print("==== %s\n", function_.ToFullyQualifiedCString());
   }
 
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     PrintBlock(block_order_[i], print_locations_);
   }
 }
 
 
 void FlowGraphPrinter::PrintInstruction(Instruction* instr) {
   PrintOneInstruction(instr, print_locations_);
 }
 
 
 void FlowGraphPrinter::PrintOneInstruction(Instruction* instr,
                                            bool print_locations) {
   char str[4000];
   BufferFormatter f(str, sizeof(str));
   instr->PrintTo(&f);
   if (FLAG_print_environments && (instr->env() != NULL)) {
     instr->env()->PrintTo(&f);
   }
   if (print_locations && (instr->HasLocs())) {
     instr->locs()->PrintTo(&f);
   }
   if (instr->lifetime_position() != -1) {
-    ISL_Print("%3" Pd ": ", instr->lifetime_position());
+    THR_Print("%3" Pd ": ", instr->lifetime_position());
   }
-  if (!instr->IsBlockEntry()) ISL_Print("    ");
-  ISL_Print("%s", str);
+  if (!instr->IsBlockEntry()) THR_Print("    ");
+  THR_Print("%s", str);
   if (FLAG_trace_inlining_intervals) {
-    ISL_Print(" iid: %" Pd "", instr->inlining_id());
+    THR_Print(" iid: %" Pd "", instr->inlining_id());
   }
 }
 
 
 void FlowGraphPrinter::PrintTypeCheck(const ParsedFunction& parsed_function,
                                       intptr_t token_pos,
                                       Value* value,
                                       const AbstractType& dst_type,
                                       const String& dst_name,
                                       bool eliminated) {
     const char* compile_type_name = "unknown";
     if (value != NULL && value->reaching_type_ != NULL) {
       compile_type_name = value->reaching_type_->ToCString();
     }
-    ISL_Print("%s type check: compile type %s is %s specific than "
+    THR_Print("%s type check: compile type %s is %s specific than "
               "type '%s' of '%s'.\n",
                          eliminated ? "Eliminated" : "Generated",
                          compile_type_name,
                          eliminated ? "more" : "not more",
                          String::Handle(dst_type.Name()).ToCString(),
                          dst_name.ToCString());
 }
 
 
 void CompileType::PrintTo(BufferFormatter* f) const {
@@ skipping 53 matching lines @@
     f->Print(" cnt:%" Pd " trgt:'%s'", count, target.ToQualifiedCString());
   }
   f->Print("]");
 }
 
 
 void FlowGraphPrinter::PrintICData(const ICData& ic_data) {
   char buffer[1024];
   BufferFormatter f(buffer, sizeof(buffer));
   PrintICDataHelper(&f, ic_data);
-  ISL_Print("%s ", buffer);
+  THR_Print("%s ", buffer);
   const Array& a = Array::Handle(ic_data.arguments_descriptor());
-  ISL_Print(" arg-desc %" Pd "\n", a.Length());
+  THR_Print(" arg-desc %" Pd "\n", a.Length());
 }
 
 
 static void PrintUse(BufferFormatter* f, const Definition& definition) {
   if (definition.HasSSATemp()) {
     if (definition.HasPairRepresentation()) {
       f->Print("v%" Pd ", v%" Pd "", definition.ssa_temp_index(),
                                      definition.ssa_temp_index() + 1);
     } else {
       f->Print("v%" Pd "", definition.ssa_temp_index());
@@ skipping 968 matching lines @@
 }
 
 const char* Environment::ToCString() const {
   char buffer[1024];
   BufferFormatter bf(buffer, 1024);
   PrintTo(&bf);
   return Thread::Current()->zone()->MakeCopyOfString(buffer);
 }
 
 }  // namespace dart