Migrate logging infrastructure Isolate->Thread

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
 #include "vm/cpu.h"
@@ skipping 619 matching lines @@
                                       Instruction* replacement,
                                       FlowGraph* graph) {
   Definition* current_defn = current->AsDefinition();
   if ((replacement != NULL) && (current_defn != NULL)) {
     Definition* replacement_defn = replacement->AsDefinition();
     ASSERT(replacement_defn != NULL);
     current_defn->ReplaceUsesWith(replacement_defn);
     EnsureSSATempIndex(graph, current_defn, replacement_defn);
 
     if (FLAG_trace_optimization) {
-      ISL_Print("Replacing v%" Pd " with v%" Pd "\n",
+      THR_Print("Replacing v%" Pd " with v%" Pd "\n",
                 current_defn->ssa_temp_index(),
                 replacement_defn->ssa_temp_index());
     }
   } else if (FLAG_trace_optimization) {
     if (current_defn == NULL) {
-      ISL_Print("Removing %s\n", current->DebugName());
+      THR_Print("Removing %s\n", current->DebugName());
     } else {
       ASSERT(!current_defn->HasUses());
-      ISL_Print("Removing v%" Pd ".\n", current_defn->ssa_temp_index());
+      THR_Print("Removing v%" Pd ".\n", current_defn->ssa_temp_index());
     }
   }
   iterator->RemoveCurrentFromGraph();
 }
 
 
 bool FlowGraphOptimizer::Canonicalize() {
   bool changed = false;
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
@@ skipping 1670 matching lines @@
   const Function& function = flow_graph_->function();
   if (function.IsDynamicFunction() &&
       callee_receiver->IsParameter() &&
       (callee_receiver->AsParameter()->index() == 0)) {
     const String& name = (kind == RawFunction::kMethodExtractor)
         ? String::Handle(Z, Field::NameFromGetter(call->function_name()))
         : call->function_name();
     const Class& cls = Class::Handle(Z, function.Owner());
     if (!thread()->cha()->HasOverride(cls, name)) {
       if (FLAG_trace_cha) {
-        ISL_Print("  **(CHA) Instance call needs no check, "
+        THR_Print("  **(CHA) Instance call needs no check, "
             "no overrides of '%s' '%s'\n",
             name.ToCString(), cls.ToCString());
       }
       thread()->cha()->AddToLeafClasses(cls);
       return false;
     }
   }
   return true;
 }
 
@@ skipping 1678 matching lines @@
   if (CHA::IsImplemented(type_class)) return false;
   // Check if there are subclasses.
   if (CHA::HasSubclasses(type_class)) {
     return false;
   }
 
   // Private classes cannot be subclassed by later loaded libs.
   if (!type_class.IsPrivate()) {
     if (FLAG_use_cha_deopt) {
       if (FLAG_trace_cha) {
-        ISL_Print("  **(CHA) Typecheck as class equality since no "
+        THR_Print("  **(CHA) Typecheck as class equality since no "
             "subclasses: %s\n",
             type_class.ToCString());
       }
       thread()->cha()->AddToLeafClasses(type_class);
     } else {
       return false;
     }
   }
   const intptr_t num_type_args = type_class.NumTypeArguments();
   if (num_type_args > 0) {
@@ skipping 563 matching lines @@
       if (field.is_double_initialized()) {
         unboxed_field = true;
       } else if ((setter.usage_counter() > 0) &&
                  ((FLAG_getter_setter_ratio * setter.usage_counter()) >=
                    getter.usage_counter())) {
         unboxed_field = true;
       }
     }
     if (!unboxed_field) {
       if (FLAG_trace_optimization || FLAG_trace_field_guards) {
-        ISL_Print("Disabling unboxing of %s\n", field.ToCString());
+        THR_Print("Disabling unboxing of %s\n", field.ToCString());
         if (!setter.IsNull()) {
           OS::Print("  setter usage count: %" Pd "\n", setter.usage_counter());
         }
         if (!getter.IsNull()) {
           OS::Print("  getter usage count: %" Pd "\n", getter.usage_counter());
         }
       }
       field.set_is_unboxing_candidate(false);
       field.DeoptimizeDependentCode();
     } else {
@@ skipping 208 matching lines @@
 
   // Worklist used to collect dependency graph.
   DefinitionWorklist worklist(flow_graph_, candidates.length());
   for (intptr_t i = 0; i < candidates.length(); i++) {
     BinarySmiOpInstr* op = candidates[i];
     if (op->WasEliminated() || processed->Contains(op->ssa_temp_index())) {
       continue;
     }
 
     if (FLAG_trace_smi_widening) {
-      ISL_Print("analysing candidate: %s\n", op->ToCString());
+      THR_Print("analysing candidate: %s\n", op->ToCString());
     }
     worklist.Clear();
     worklist.Add(op);
 
     // Collect dependency graph. Note: more items are added to worklist
     // inside this loop.
     intptr_t gain = 0;
     for (intptr_t j = 0; j < worklist.definitions().length(); j++) {
       Definition* defn = worklist.definitions()[j];
 
       if (FLAG_trace_smi_widening) {
-        ISL_Print("> %s\n", defn->ToCString());
+        THR_Print("> %s\n", defn->ToCString());
       }
 
       if (defn->IsBinarySmiOp() &&
           BenefitsFromWidening(defn->AsBinarySmiOp())) {
         gain++;
         if (FLAG_trace_smi_widening) {
-          ISL_Print("^ [%" Pd "] (o) %s\n", gain, defn->ToCString());
+          THR_Print("^ [%" Pd "] (o) %s\n", gain, defn->ToCString());
         }
       }
 
       const intptr_t defn_loop = loops[defn->GetBlock()->preorder_number()];
 
       // Process all inputs.
       for (intptr_t k = 0; k < defn->InputCount(); k++) {
         Definition* input = defn->InputAt(k)->definition();
         if (input->IsBinarySmiOp() &&
             CanBeWidened(input->AsBinarySmiOp())) {
           worklist.Add(input);
         } else if (input->IsPhi() && (input->Type()->ToCid() == kSmiCid)) {
           worklist.Add(input);
         } else if (input->IsBinaryMintOp()) {
           // Mint operation produces untagged result. We avoid tagging.
           gain++;
           if (FLAG_trace_smi_widening) {
-            ISL_Print("^ [%" Pd "] (i) %s\n", gain, input->ToCString());
+            THR_Print("^ [%" Pd "] (i) %s\n", gain, input->ToCString());
           }
         } else if (defn_loop == loops[input->GetBlock()->preorder_number()] &&
                    (input->Type()->ToCid() == kSmiCid)) {
           // Input comes from the same loop, is known to be smi and requires
           // untagging.
           // TODO(vegorov) this heuristic assumes that values that are not
           // known to be smi have to be checked and this check can be
           // coalesced with untagging. Start coalescing them.
           gain--;
           if (FLAG_trace_smi_widening) {
-            ISL_Print("v [%" Pd "] (i) %s\n", gain, input->ToCString());
+            THR_Print("v [%" Pd "] (i) %s\n", gain, input->ToCString());
           }
         }
       }
 
       // Process all uses.
       for (Value* use = defn->input_use_list();
            use != NULL;
            use = use->next_use()) {
         Instruction* instr = use->instruction();
         Definition* use_defn = instr->AsDefinition();
         if (use_defn == NULL) {
           // We assume that tagging before returning or pushing argument costs
           // very little compared to the cost of the return/call itself.
           if (!instr->IsReturn() && !instr->IsPushArgument()) {
             gain--;
             if (FLAG_trace_smi_widening) {
-              ISL_Print("v [%" Pd "] (u) %s\n",
+              THR_Print("v [%" Pd "] (u) %s\n",
                         gain,
                         use->instruction()->ToCString());
             }
           }
           continue;
         } else if (use_defn->IsBinarySmiOp() &&
                    CanBeWidened(use_defn->AsBinarySmiOp())) {
           worklist.Add(use_defn);
         } else if (use_defn->IsPhi() &&
                    use_defn->AsPhi()->Type()->ToCid() == kSmiCid) {
           worklist.Add(use_defn);
         } else if (use_defn->IsBinaryMintOp()) {
           // BinaryMintOp requires untagging of its inputs.
           // Converting kUnboxedInt32 to kUnboxedMint is essentially zero cost
           // sign extension operation.
           gain++;
           if (FLAG_trace_smi_widening) {
-            ISL_Print("^ [%" Pd "] (u) %s\n",
+            THR_Print("^ [%" Pd "] (u) %s\n",
                       gain,
                       use->instruction()->ToCString());
           }
         } else if (defn_loop == loops[instr->GetBlock()->preorder_number()]) {
           gain--;
           if (FLAG_trace_smi_widening) {
-            ISL_Print("v [%" Pd "] (u) %s\n",
+            THR_Print("v [%" Pd "] (u) %s\n",
                       gain,
                       use->instruction()->ToCString());
           }
         }
       }
     }
 
     processed->AddAll(worklist.contains_vector());
 
     if (FLAG_trace_smi_widening) {
-      ISL_Print("~ %s gain %" Pd "\n", op->ToCString(), gain);
+      THR_Print("~ %s gain %" Pd "\n", op->ToCString(), gain);
     }
 
     if (gain > 0) {
       // We have positive gain from widening. Convert all BinarySmiOpInstr into
       // BinaryInt32OpInstr and set representation of all phis to kUnboxedInt32.
       for (intptr_t j = 0; j < worklist.definitions().length(); j++) {
         Definition* defn = worklist.definitions()[j];
         ASSERT(defn->IsPhi() || defn->IsBinarySmiOp());
 
         if (defn->IsBinarySmiOp()) {
@@ skipping 107 matching lines @@
   if (current->IsCheckClass()) {
     current->AsCheckClass()->set_licm_hoisted(true);
   } else if (current->IsCheckSmi()) {
     current->AsCheckSmi()->set_licm_hoisted(true);
   } else if (current->IsCheckEitherNonSmi()) {
     current->AsCheckEitherNonSmi()->set_licm_hoisted(true);
   } else if (current->IsCheckArrayBound()) {
     current->AsCheckArrayBound()->set_licm_hoisted(true);
   }
   if (FLAG_trace_optimization) {
-    ISL_Print("Hoisting instruction %s:%" Pd " from B%" Pd " to B%" Pd "\n",
+    THR_Print("Hoisting instruction %s:%" Pd " from B%" Pd " to B%" Pd "\n",
               current->DebugName(),
               current->GetDeoptId(),
               current->GetBlock()->block_id(),
               pre_header->block_id());
   }
   // Move the instruction out of the loop.
   current->RemoveEnvironment();
   if (it != NULL) {
     it->RemoveCurrentFromGraph();
   } else {
@@ skipping 796 matching lines @@
   Place* LookupCanonical(Place* place) const {
     return places_map_->Lookup(place);
   }
 
   void PrintSet(BitVector* set) {
     bool comma = false;
     for (BitVector::Iterator it(set);
          !it.Done();
          it.Advance()) {
       if (comma) {
-        ISL_Print(", ");
+        THR_Print(", ");
       }
-      ISL_Print("%s", places_[it.Current()]->ToCString());
+      THR_Print("%s", places_[it.Current()]->ToCString());
       comma = true;
     }
   }
 
   const PhiPlaceMoves* phi_moves() const { return phi_moves_; }
 
   void RollbackAliasedIdentites() {
     for (intptr_t i = 0; i < identity_rollback_.length(); ++i) {
       identity_rollback_[i]->SetIdentity(AliasIdentity::Unknown());
     }
@@ skipping 74 matching lines @@
 
   void ComputeKillSets() {
     for (intptr_t i = 0; i < aliases_.length(); ++i) {
       const Place* alias = aliases_[i];
       // Add all representatives to the kill set.
       AddAllRepresentatives(alias->id(), alias->id());
       ComputeKillSet(alias);
     }
 
     if (FLAG_trace_load_optimization) {
-      ISL_Print("Aliases KILL sets:\n");
+      THR_Print("Aliases KILL sets:\n");
       for (intptr_t i = 0; i < aliases_.length(); ++i) {
         const Place* alias = aliases_[i];
         BitVector* kill = GetKilledSet(alias->id());
 
-        ISL_Print("%s: ", alias->ToCString());
+        THR_Print("%s: ", alias->ToCString());
         if (kill != NULL) {
           PrintSet(kill);
         }
-        ISL_Print("\n");
+        THR_Print("\n");
       }
     }
   }
 
   void InsertAlias(const Place* alias) {
     aliases_map_.Insert(alias);
     aliases_.Add(alias);
   }
 
   const Place* CanonicalizeAlias(const Place& alias) {
@@ skipping 366 matching lines @@
   PhiPlaceMoves* phi_moves = new(zone) PhiPlaceMoves();
 
   for (intptr_t i = 0; i < places->length(); i++) {
     Place* place = (*places)[i];
 
     if (IsPhiDependentPlace(place)) {
       PhiInstr* phi = place->instance()->AsPhi();
       BlockEntryInstr* block = phi->GetBlock();
 
       if (FLAG_trace_optimization) {
-        ISL_Print("phi dependent place %s\n", place->ToCString());
+        THR_Print("phi dependent place %s\n", place->ToCString());
       }
 
       Place input_place(*place);
       for (intptr_t j = 0; j < phi->InputCount(); j++) {
         input_place.set_instance(phi->InputAt(j)->definition());
 
         Place* result = map->Lookup(&input_place);
         if (result == NULL) {
           result = Place::Wrap(zone, input_place, places->length());
           map->Insert(result);
           places->Add(result);
           if (FLAG_trace_optimization) {
-            ISL_Print("  adding place %s as %" Pd "\n",
+            THR_Print("  adding place %s as %" Pd "\n",
                       result->ToCString(),
                       result->id());
           }
         }
         phi_moves->CreateOutgoingMove(zone,
                                       block->PredecessorAt(j),
                                       result->id(),
                                       place->id());
       }
     }
@@ skipping 35 matching lines @@
         continue;
       }
 
       Place* result = map->Lookup(&place);
       if (result == NULL) {
         result = Place::Wrap(zone, place, places->length());
         map->Insert(result);
         places->Add(result);
 
         if (FLAG_trace_optimization) {
-          ISL_Print("numbering %s as %" Pd "\n",
+          THR_Print("numbering %s as %" Pd "\n",
                     result->ToCString(),
                     result->id());
         }
       }
 
       instr->set_place_id(result->id());
     }
   }
 
   if ((mode == kOptimizeLoads) && !has_loads) {
@@ skipping 248 matching lines @@
         }
 
         const intptr_t place_id = defn->place_id();
         if (gen->Contains(place_id)) {
           // This is a locally redundant load.
           ASSERT((out_values != NULL) && ((*out_values)[place_id] != NULL));
 
           Definition* replacement = (*out_values)[place_id];
           EnsureSSATempIndex(graph_, defn, replacement);
           if (FLAG_trace_optimization) {
-            ISL_Print("Replacing load v%" Pd " with v%" Pd "\n",
+            THR_Print("Replacing load v%" Pd " with v%" Pd "\n",
                       defn->ssa_temp_index(),
                       replacement->ssa_temp_index());
           }
 
           defn->ReplaceUsesWith(replacement);
           instr_it.RemoveCurrentFromGraph();
           forwarded_ = true;
           continue;
         } else if (!kill->Contains(place_id)) {
           // This is an exposed load: it is the first representative of a
@@ skipping 187 matching lines @@
         for (intptr_t i = 0; i < phi_moves->length(); i++) {
           const intptr_t from = (*phi_moves)[i].from();
           const intptr_t to = (*phi_moves)[i].to();
           if (from == to) continue;
 
           (*block_out_values)[to] = (*temp_forwarded_values)[to];
         }
       }
 
       if (FLAG_trace_load_optimization) {
-        ISL_Print("B%" Pd "\n", block->block_id());
-        ISL_Print("  IN: ");
+        THR_Print("B%" Pd "\n", block->block_id());
+        THR_Print("  IN: ");
         aliased_set_->PrintSet(in_[preorder_number]);
-        ISL_Print("\n");
+        THR_Print("\n");
 
-        ISL_Print("  KILL: ");
+        THR_Print("  KILL: ");
         aliased_set_->PrintSet(kill_[preorder_number]);
-        ISL_Print("\n");
+        THR_Print("\n");
 
-        ISL_Print("  OUT: ");
+        THR_Print("  OUT: ");
         aliased_set_->PrintSet(out_[preorder_number]);
-        ISL_Print("\n");
+        THR_Print("\n");
       }
     }
 
     // All blocks were visited. Fill pending phis with inputs
     // that flow on back edges.
     for (intptr_t i = 0; i < pending_phis.length(); i++) {
       FillPhiInputs(pending_phis[i]);
     }
   }
 
@@ skipping 32 matching lines @@
 
       for (BitVector::Iterator loop_it(header->loop_info());
            !loop_it.Done();
            loop_it.Advance()) {
         const intptr_t preorder_number = loop_it.Current();
         loop_gen->RemoveAll(kill_[preorder_number]);
       }
 
       if (FLAG_trace_optimization) {
         for (BitVector::Iterator it(loop_gen); !it.Done(); it.Advance()) {
-          ISL_Print("place %s is loop invariant for B%" Pd "\n",
+          THR_Print("place %s is loop invariant for B%" Pd "\n",
                     aliased_set_->places()[it.Current()]->ToCString(),
                     header->block_id());
         }
       }
 
       invariant_loads->Add(loop_gen);
     }
 
     graph_->set_loop_invariant_loads(invariant_loads);
   }
@@ skipping 50 matching lines @@
       Definition* replacement = (*pred_out_values)[place_id]->Replacement();
       Value* input = new(Z) Value(replacement);
       phi->SetInputAt(i, input);
       replacement->AddInputUse(input);
     }
 
     phi->set_ssa_temp_index(graph_->alloc_ssa_temp_index());
     phis_.Add(phi);  // Postpone phi insertion until after load forwarding.
 
     if (FLAG_trace_load_optimization) {
-      ISL_Print("created pending phi %s for %s at B%" Pd "\n",
+      THR_Print("created pending phi %s for %s at B%" Pd "\n",
                 phi->ToCString(),
                 aliased_set_->places()[place_id]->ToCString(),
                 block->block_id());
     }
   }
 
   // Iterate over basic blocks and replace exposed loads with incoming
   // values.
   void ForwardLoads() {
     for (BlockIterator block_it = graph_->reverse_postorder_iterator();
@@ skipping 18 matching lines @@
         // they might contain values that were replace and removed
         // from the graph by this iteration.
         // To prevent using them we additionally mark definitions themselves
         // as replaced and store a pointer to the replacement.
         replacement = replacement->Replacement();
 
         if (load != replacement) {
           EnsureSSATempIndex(graph_, load, replacement);
 
           if (FLAG_trace_optimization) {
-            ISL_Print("Replacing load v%" Pd " with v%" Pd "\n",
+            THR_Print("Replacing load v%" Pd " with v%" Pd "\n",
                       load->ssa_temp_index(),
                       replacement->ssa_temp_index());
           }
 
           load->ReplaceUsesWith(replacement);
           load->RemoveFromGraph();
           load->SetReplacement(replacement);
           forwarded_ = true;
         }
       }
@@ skipping 168 matching lines @@
       if (!a->IsPhi()) {
         if (Dominates(a, b)) {
           Definition* t = a;
           a = b;
           b = t;
         }
         ASSERT(Dominates(b, a));
       }
 
       if (FLAG_trace_load_optimization) {
-        ISL_Print("Replacing %s with congruent %s\n",
+        THR_Print("Replacing %s with congruent %s\n",
                   a->ToCString(),
                   b->ToCString());
       }
 
       a->ReplaceUsesWith(b);
       if (a->IsPhi()) {
         // We might be replacing a phi introduced by the load forwarding
         // that is not inserted in the graph yet.
         ASSERT(b->IsPhi());
         PhiInstr* phi_a = a->AsPhi();
@@ skipping 185 matching lines @@
           // Loads/stores of final fields do not participate.
           continue;
         }
 
         // Handle stores.
         if (is_store) {
           if (kill->Contains(instr->place_id())) {
             if (!live_in->Contains(instr->place_id()) &&
                 CanEliminateStore(instr)) {
               if (FLAG_trace_optimization) {
-                ISL_Print(
+                THR_Print(
                     "Removing dead store to place %" Pd " in block B%" Pd "\n",
                     instr->place_id(), block->block_id());
               }
               instr_it.RemoveCurrentFromGraph();
             }
           } else if (!live_in->Contains(instr->place_id())) {
             // Mark this store as down-ward exposed: They are the only
             // candidates for the global store elimination.
             if (exposed_stores == NULL) {
               const intptr_t kMaxExposedStoresInitialSize = 5;
@@ skipping 32 matching lines @@
         if ((defn != NULL) && IsLoadEliminationCandidate(defn)) {
           const intptr_t alias = aliased_set_->LookupAliasId(place.ToAlias());
           live_in->AddAll(aliased_set_->GetKilledSet(alias));
           continue;
         }
       }
       exposed_stores_[postorder_number] = exposed_stores;
     }
     if (FLAG_trace_load_optimization) {
       Dump();
-      ISL_Print("---\n");
+      THR_Print("---\n");
     }
   }
 
   void EliminateDeadStores() {
     // Iteration order does not matter here.
     for (BlockIterator block_it = graph_->postorder_iterator();
          !block_it.Done();
          block_it.Advance()) {
       BlockEntryInstr* block = block_it.Current();
       const intptr_t postorder_number = block->postorder_number();
@@ skipping 13 matching lines @@
         ASSERT(!is_load && is_store);
         if (place.IsFinalField()) {
           // Final field do not participate in dead store elimination.
           continue;
         }
         // Eliminate a downward exposed store if the corresponding place is not
         // in live-out.
         if (!live_out->Contains(instr->place_id()) &&
             CanEliminateStore(instr)) {
           if (FLAG_trace_optimization) {
-            ISL_Print("Removing dead store to place %" Pd " block B%" Pd "\n",
+            THR_Print("Removing dead store to place %" Pd " block B%" Pd "\n",
                       instr->place_id(), block->block_id());
           }
           instr->RemoveFromGraph(/* ignored */ false);
         }
       }
     }
   }
 
   FlowGraph* graph_;
   DirectChainedHashMap<PointerKeyValueTrait<Place> >* map_;
@@ skipping 73 matching lines @@
       // Eliminate dead phis and compact the phis_ array of the block.
       intptr_t to_index = 0;
       for (intptr_t i = 0; i < join->phis_->length(); ++i) {
         PhiInstr* phi = (*join->phis_)[i];
         if (phi != NULL) {
           if (!phi->is_alive()) {
             phi->ReplaceUsesWith(flow_graph->constant_null());
             phi->UnuseAllInputs();
             (*join->phis_)[i] = NULL;
             if (FLAG_trace_optimization) {
-              ISL_Print("Removing dead phi v%" Pd "\n", phi->ssa_temp_index());
+              THR_Print("Removing dead phi v%" Pd "\n", phi->ssa_temp_index());
             }
           } else if (phi->IsRedundant()) {
             phi->ReplaceUsesWith(phi->InputAt(0)->definition());
             phi->UnuseAllInputs();
             (*join->phis_)[i] = NULL;
             if (FLAG_trace_optimization) {
-              ISL_Print("Removing redundant phi v%" Pd "\n",
+              THR_Print("Removing redundant phi v%" Pd "\n",
                          phi->ssa_temp_index());
             }
           } else {
             (*join->phis_)[to_index++] = phi;
           }
         }
       }
       if (to_index == 0) {
         join->phis_ = NULL;
       } else {
@@ skipping 522 matching lines @@
 // deoptimization exit. So candidate should only be used in StoreInstanceField
 // instructions that write into fields of the allocated object.
 // We do not support materialization of the object that has type arguments.
 static bool IsAllocationSinkingCandidate(Definition* alloc,
                                          SafeUseCheck check_type) {
   for (Value* use = alloc->input_use_list();
        use != NULL;
        use = use->next_use()) {
     if (!IsSafeUse(use, check_type)) {
       if (FLAG_trace_optimization) {
-        ISL_Print("use of %s at %s is unsafe for allocation sinking\n",
+        THR_Print("use of %s at %s is unsafe for allocation sinking\n",
                   alloc->ToCString(),
                   use->instruction()->ToCString());
       }
       return false;
     }
   }
 
   return true;
 }
 
 
 // If the given use is a store into an object then return an object we are
 // storing into.
 static Definition* StoreInto(Value* use) {
   StoreInstanceFieldInstr* store = use->instruction()->AsStoreInstanceField();
   if (store != NULL) {
     return store->instance()->definition();
   }
 
   return NULL;
 }
 
 
 // Remove the given allocation from the graph. It is not observable.
 // If deoptimization occurs the object will be materialized.
 void AllocationSinking::EliminateAllocation(Definition* alloc) {
   ASSERT(IsAllocationSinkingCandidate(alloc, kStrictCheck));
 
   if (FLAG_trace_optimization) {
-    ISL_Print("removing allocation from the graph: v%" Pd "\n",
+    THR_Print("removing allocation from the graph: v%" Pd "\n",
               alloc->ssa_temp_index());
   }
 
   // As an allocation sinking candidate it is only used in stores to its own
   // fields. Remove these stores.
   for (Value* use = alloc->input_use_list();
        use != NULL;
        use = alloc->input_use_list()) {
     use->instruction()->RemoveFromGraph();
   }
@@ skipping 60 matching lines @@
       }
     }
   } while (changed);
 
   // Shrink the list of candidates removing all unmarked ones.
   intptr_t j = 0;
   for (intptr_t i = 0; i < candidates_.length(); i++) {
     Definition* alloc = candidates_[i];
     if (alloc->Identity().IsAllocationSinkingCandidate()) {
       if (FLAG_trace_optimization) {
-        ISL_Print("discovered allocation sinking candidate: v%" Pd "\n",
+        THR_Print("discovered allocation sinking candidate: v%" Pd "\n",
                   alloc->ssa_temp_index());
       }
 
       if (j != i) {
         candidates_[j] = alloc;
       }
       j++;
     }
   }
   candidates_.TruncateTo(j);
@@ skipping 74 matching lines @@
       }
     }
   } while (changed);
 
   // Remove all failed candidates from the candidates list.
   intptr_t j = 0;
   for (intptr_t i = 0; i < candidates_.length(); i++) {
     Definition* alloc = candidates_[i];
     if (!alloc->Identity().IsAllocationSinkingCandidate()) {
       if (FLAG_trace_optimization) {
-        ISL_Print("allocation v%" Pd " can't be eliminated\n",
+        THR_Print("allocation v%" Pd " can't be eliminated\n",
                   alloc->ssa_temp_index());
       }
 
 #ifdef DEBUG
       for (Value* use = alloc->env_use_list();
            use != NULL;
            use = use->next_use()) {
         ASSERT(use->instruction()->IsMaterializeObject());
       }
 #endif
@@ skipping 328 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, *slots);
   }
 }
 
 
 }  // namespace dart