Migrate logging infrastructure Isolate->Thread

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/compiler.h"
 #include "vm/isolate.h"
 #include "vm/log.h"
 #include "vm/longjump.h"
@@ skipping 44 matching lines @@
   libraries_(GrowableObjectArray::Handle(Z, I->object_store()->libraries())),
   pending_functions_(GrowableObjectArray::Handle(Z,
                                                  GrowableObjectArray::New())),
   collected_closures_(GrowableObjectArray::Handle(Z, I->collected_closures())),
   sent_selectors_(Z),
   error_(Error::Handle(Z)) {
 }
 
 
 void Precompiler::DoCompileAll() {
-  LogBlock lb(thread_);
+  LogBlock lb;
 
   // Drop all existing code so we can use the presence of code as an indicator
   // that we have already looked for the function's callees.
   ClearAllCode();
 
   // Start with the allocations and invocations that happen from C++.
   AddRoots();
 
   // TODO(rmacnak): Eagerly add field-invocation functions to all signature
   // classes so closure calls don't go through the runtime.
 
   // Compile newly found targets and add their callees until we reach a fixed
   // point.
   Iterate();
 
   CleanUp();
 
   if (FLAG_trace_precompiler) {
-    ISL_Print("Precompiled %" Pd " functions, %" Pd " dynamic types,"
+    THR_Print("Precompiled %" Pd " functions, %" Pd " dynamic types,"
               " %" Pd " dynamic selectors.\n Dropped %" Pd " functions.\n",
               function_count_,
               class_count_,
               selector_count_,
               dropped_function_count_);
   }
 
   I->set_compilation_allowed(false);
 }
 
@@ skipping 174 matching lines @@
   String& class_name = String::Handle(Z);
   String& function_name = String::Handle(Z);
   for (intptr_t i = 0; kExternallyCalled[i].library_ != NULL; i++) {
     library_name = Symbols::New(kExternallyCalled[i].library_);
     class_name = Symbols::New(kExternallyCalled[i].class_);
     function_name = Symbols::New(kExternallyCalled[i].function_);
 
     lib = Library::LookupLibrary(library_name);
     if (lib.IsNull()) {
       if (FLAG_trace_precompiler) {
-        ISL_Print("WARNING: Missing %s\n", kExternallyCalled[i].library_);
+        THR_Print("WARNING: Missing %s\n", kExternallyCalled[i].library_);
       }
       continue;
     }
 
     if (class_name.raw() == Symbols::TopLevel().raw()) {
       func = lib.LookupFunctionAllowPrivate(function_name);
     } else {
       cls = lib.LookupClassAllowPrivate(class_name);
       if (cls.IsNull()) {
         if (FLAG_trace_precompiler) {
-          ISL_Print("WARNING: Missing %s %s\n",
+          THR_Print("WARNING: Missing %s %s\n",
                     kExternallyCalled[i].library_,
                     kExternallyCalled[i].class_);
         }
         continue;
       }
 
       ASSERT(!cls.IsNull());
       func = cls.LookupFunctionAllowPrivate(function_name);
     }
 
     if (func.IsNull()) {
       if (FLAG_trace_precompiler) {
-        ISL_Print("WARNING: Missing %s %s %s\n",
+        THR_Print("WARNING: Missing %s %s %s\n",
                   kExternallyCalled[i].library_,
                   kExternallyCalled[i].class_,
                   kExternallyCalled[i].function_);
       }
       continue;
     }
 
     AddFunction(func);
   }
 }
@@ skipping 29 matching lines @@
 
   // TODO(rmacnak): DropEmptyClasses();
 }
 
 
 void Precompiler::ProcessFunction(const Function& function) {
   if (!function.HasCode()) {
     function_count_++;
 
     if (FLAG_trace_precompiler) {
-      ISL_Print("Precompiling %" Pd " %s (%" Pd ", %s)\n",
+      THR_Print("Precompiling %" Pd " %s (%" Pd ", %s)\n",
                 function_count_,
                 function.ToLibNamePrefixedQualifiedCString(),
                 function.token_pos(),
                 Function::KindToCString(function.kind()));
     }
 
     ASSERT(!function.is_abstract());
     ASSERT(!function.IsRedirectingFactory());
 
     error_ = Compiler::CompileFunction(thread_, function);
@@ skipping 71 matching lines @@
     // Potential const object. Uninitialized field will harmlessly do a
     // redundant add of the Null class.
     const Object& value = Object::Handle(Z, field.StaticValue());
     const Class& cls = Class::Handle(Z, value.clazz());
     AddClass(cls);
 
     if (field.has_initializer()) {
       if (field.PrecompiledInitializer() != Function::null()) return;
 
       if (FLAG_trace_precompiler) {
-        ISL_Print("Precompiling initializer for %s\n", field.ToCString());
+        THR_Print("Precompiling initializer for %s\n", field.ToCString());
       }
       Compiler::CompileStaticInitializer(field);
 
       const Function& function =
           Function::Handle(Z, field.PrecompiledInitializer());
       AddCalleesOf(function);
     }
   }
 }
 
@@ skipping 11 matching lines @@
 }
 
 
 void Precompiler::AddSelector(const String& selector) {
   if (!IsSent(selector)) {
     sent_selectors_.Add(selector);
     selector_count_++;
     changed_ = true;
 
     if (FLAG_trace_precompiler) {
-      ISL_Print("Enqueueing selector %" Pd " %s\n",
+      THR_Print("Enqueueing selector %" Pd " %s\n",
                 selector_count_,
                 selector.ToCString());
     }
 
     if (!Field::IsGetterName(selector) &&
         !Field::IsSetterName(selector)) {
       // Regular method may be call-through-getter.
       const String& getter = String::Handle(Field::GetterSymbol(selector));
       AddSelector(getter);
     }
   }
 }
 
 
 void Precompiler::AddClass(const Class& cls) {
   if (cls.is_allocated()) return;
 
   class_count_++;
   cls.set_is_allocated();
   changed_ = true;
 
   if (FLAG_trace_precompiler) {
-    ISL_Print("Allocation %" Pd " %s\n", class_count_, cls.ToCString());
+    THR_Print("Allocation %" Pd " %s\n", class_count_, cls.ToCString());
   }
 
   const Class& superclass = Class::Handle(cls.SuperClass());
   if (!superclass.IsNull()) {
     AddClass(superclass);
   }
 }
 
 
 void Precompiler::CheckForNewDynamicFunctions() {
@@ skipping 96 matching lines @@
 
       functions = cls.functions();
       retained_functions = GrowableObjectArray::New();
       for (intptr_t j = 0; j < functions.Length(); j++) {
         function ^= functions.At(j);
         if (function.HasCode()) {
           retained_functions.Add(function);
         } else {
           dropped_function_count_++;
           if (FLAG_trace_precompiler) {
-            ISL_Print("Precompilation dropping %s\n",
+            THR_Print("Precompilation dropping %s\n",
                       function.ToLibNamePrefixedQualifiedCString());
           }
         }
       }
 
       functions = Array::New(retained_functions.Length(), Heap::kOld);
       for (intptr_t j = 0; j < retained_functions.Length(); j++) {
         function ^= retained_functions.At(j);
         functions.SetAt(j, function);
       }
       cls.SetFunctions(functions);
 
       closures = cls.closures();
       if (!closures.IsNull()) {
         for (intptr_t j = 0; j < closures.Length(); j++) {
           function ^= closures.At(j);
           ASSERT(function.HasCode());
         }
       }
     }
   }
 }
 
 }  // namespace dart