Port flow_graph*, disassembler to ISL_Print

runtime/vm/flow_graph_range_analysis.cc

 // Copyright (c) 2014, 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_range_analysis.h"
 
 #include "vm/bit_vector.h"
 #include "vm/il_printer.h"
 
 namespace dart {
@@ skipping 165 matching lines @@
     JoinEntryInstr* join = block->AsJoinEntry();
     if (join != NULL && join->loop_info() != NULL) {
       loop_variables.Clear();
 
       for (PhiIterator phi_it(join); !phi_it.Done(); phi_it.Advance()) {
         PhiInstr* current = phi_it.Current();
 
         InductionVariableInfo* info = DetectSimpleInductionVariable(current);
         if (info != NULL) {
           if (FLAG_trace_range_analysis) {
-            OS::Print("Simple loop variable: %s bound <%s>\n",
+            ISL_Print("Simple loop variable: %s bound <%s>\n",
                        current->ToCString(),
                        info->limit() != NULL ?
                            info->limit()->ToCString() : "?");
           }
 
           loop_variables.Add(info);
         }
       }
     }
 
@@ skipping 491 matching lines @@
         range = Range(WidenMin(defn->range(), &range, size),
                       WidenMax(defn->range(), &range, size));
       } else if (op == NARROW) {
         range = Range(NarrowMin(defn->range(), &range, size),
                       NarrowMax(defn->range(), &range, size));
       }
     }
 
     if (!range.Equals(defn->range())) {
       if (FLAG_trace_range_analysis) {
-        OS::Print("%c [%" Pd "] %s:  %s => %s\n",
+        ISL_Print("%c [%" Pd "] %s:  %s => %s\n",
                   OpPrefix(op),
                   iteration,
                   defn->ToCString(),
                   Range::ToCString(defn->range()),
                   Range::ToCString(&range));
       }
       defn->set_range(range);
       return true;
     }
   }
@@ skipping 282 matching lines @@
         flow_graph_(flow_graph),
         scheduler_(flow_graph) { }
 
   void TryGeneralize(CheckArrayBoundInstr* check,
                      const RangeBoundary& array_length) {
     Definition* upper_bound =
         ConstructUpperBound(check->index()->definition(), check);
     if (upper_bound == UnwrapConstraint(check->index()->definition())) {
       // Unable to construct upper bound for the index.
       if (FLAG_trace_range_analysis) {
-        OS::Print("Failed to construct upper bound for %s index\n",
+        ISL_Print("Failed to construct upper bound for %s index\n",
                   check->ToCString());
       }
       return;
     }
 
     // Re-associate subexpressions inside upper_bound to collect all constants
     // together. This will expose more redundancies when we are going to emit
     // upper bound through scheduler.
     if (!Simplify(&upper_bound, NULL)) {
       if (FLAG_trace_range_analysis) {
-        OS::Print("Failed to simplify upper bound for %s index\n",
+        ISL_Print("Failed to simplify upper bound for %s index\n",
                   check->ToCString());
       }
       return;
     }
     upper_bound = ApplyConstraints(upper_bound, check);
     range_analysis_->AssignRangesRecursively(upper_bound);
 
     // We are going to constrain any symbols participating in + and * operations
     // to guarantee that they are positive. Find all symbols that need
     // constraining. If there is a subtraction subexpression with non-positive
     // range give up on generalization for simplicity.
     GrowableArray<Definition*> non_positive_symbols;
     if (!FindNonPositiveSymbols(&non_positive_symbols, upper_bound)) {
       if (FLAG_trace_range_analysis) {
-        OS::Print("Failed to generalize %s index to %s"
+        ISL_Print("Failed to generalize %s index to %s"
                   " (can't ensure positivity)\n",
                   check->ToCString(),
                   IndexBoundToCString(upper_bound));
       }
       return;
     }
 
     // Check that we can statically prove that lower bound of the index is
     // non-negative under the assumption that all potentially non-positive
     // symbols are positive.
@@ skipping 13 matching lines @@
       ConstructLowerBound(check->index()->definition(), check);
     // No need to simplify lower bound before applying constraints as
     // we are not going to emit it.
     lower_bound = ApplyConstraints(lower_bound, check, &positive_constraints);
     range_analysis_->AssignRangesRecursively(lower_bound);
 
     if (!RangeUtils::IsPositive(lower_bound->range())) {
       // Can't prove that lower bound is positive even with additional checks
       // against potentially non-positive symbols. Give up.
       if (FLAG_trace_range_analysis) {
-        OS::Print("Failed to generalize %s index to %s"
+        ISL_Print("Failed to generalize %s index to %s"
                   " (lower bound is not positive)\n",
                   check->ToCString(),
                   IndexBoundToCString(upper_bound));
       }
       return;
     }
 
     if (FLAG_trace_range_analysis) {
-      OS::Print("For %s computed index bounds [%s, %s]\n",
+      ISL_Print("For %s computed index bounds [%s, %s]\n",
                 check->ToCString(),
                 IndexBoundToCString(lower_bound),
                 IndexBoundToCString(upper_bound));
     }
 
     // At this point we know that 0 <= index < UpperBound(index) under
     // certain preconditions. Start by emitting this preconditions.
     scheduler_.Start();
 
     ConstantInstr* max_smi =
         flow_graph_->GetConstant(Smi::Handle(Smi::New(Smi::kMaxValue)));
     for (intptr_t i = 0; i < non_positive_symbols.length(); i++) {
       CheckArrayBoundInstr* precondition = new CheckArrayBoundInstr(
           new Value(max_smi),
           new Value(non_positive_symbols[i]),
           Isolate::kNoDeoptId);
       precondition->mark_generalized();
       precondition = scheduler_.Emit(precondition, check);
       if (precondition == NULL) {
         if (FLAG_trace_range_analysis) {
-          OS::Print("  => failed to insert positivity constraint\n");
+          ISL_Print("  => failed to insert positivity constraint\n");
         }
         scheduler_.Rollback();
         return;
       }
     }
 
     CheckArrayBoundInstr* new_check = new CheckArrayBoundInstr(
           new Value(UnwrapConstraint(check->length()->definition())),
           new Value(upper_bound),
           Isolate::kNoDeoptId);
     new_check->mark_generalized();
     if (new_check->IsRedundant(array_length)) {
       if (FLAG_trace_range_analysis) {
-        OS::Print("  => generalized check is redundant\n");
+        ISL_Print("  => generalized check is redundant\n");
       }
       RemoveGeneralizedCheck(check);
       return;
     }
 
     new_check = scheduler_.Emit(new_check, check);
     if (new_check != NULL) {
       if (FLAG_trace_range_analysis) {
-        OS::Print("  => generalized check was hoisted into B%" Pd "\n",
+        ISL_Print("  => generalized check was hoisted into B%" Pd "\n",
                   new_check->GetBlock()->block_id());
       }
       RemoveGeneralizedCheck(check);
     } else {
       if (FLAG_trace_range_analysis) {
-        OS::Print("  => generalized check can't be hoisted\n");
+        ISL_Print("  => generalized check can't be hoisted\n");
       }
       scheduler_.Rollback();
     }
   }
 
   static void RemoveGeneralizedCheck(CheckArrayBoundInstr* check) {
     BinarySmiOpInstr* binary_op =
         check->index()->definition()->AsBinarySmiOp();
     if (binary_op != NULL) {
       binary_op->set_can_overflow(false);
@@ skipping 429 matching lines @@
         // TODO(vegorov): replace Constraint with an uncoditional
         // deoptimization and kill all dominated dead code.
         continue;
       }
 
       BranchInstr* branch =
           target->PredecessorAt(0)->last_instruction()->AsBranch();
       if (target == branch->true_successor()) {
         // True unreachable.
         if (FLAG_trace_constant_propagation) {
-          OS::Print("Range analysis: True unreachable (B%" Pd ")\n",
+          ISL_Print("Range analysis: True unreachable (B%" Pd ")\n",
                     branch->true_successor()->block_id());
         }
         branch->set_constant_target(branch->false_successor());
       } else {
         ASSERT(target == branch->false_successor());
         // False unreachable.
         if (FLAG_trace_constant_propagation) {
-          OS::Print("Range analysis: False unreachable (B%" Pd ")\n",
+          ISL_Print("Range analysis: False unreachable (B%" Pd ")\n",
                     branch->false_successor()->block_id());
         }
         branch->set_constant_target(branch->true_successor());
       }
     }
   }
 }
 
 
 void RangeAnalysis::RemoveConstraints() {
@@ skipping 70 matching lines @@
   isolate_ = flow_graph_->isolate();
   ASSERT(isolate_ != NULL);
   Zone* zone = flow_graph_->zone();
   selected_uint32_defs_ =
       new(zone) BitVector(zone, flow_graph_->current_ssa_temp_index());
 }
 
 
 void IntegerInstructionSelector::Select() {
   if (FLAG_trace_integer_ir_selection) {
-    OS::Print("---- starting integer ir selection -------\n");
+    ISL_Print("---- starting integer ir selection -------\n");
   }
   FindPotentialUint32Definitions();
   FindUint32NarrowingDefinitions();
   Propagate();
   ReplaceInstructions();
   if (FLAG_trace_integer_ir_selection) {
-    OS::Print("---- after integer ir selection -------\n");
+    ISL_Print("---- after integer ir selection -------\n");
     FlowGraphPrinter printer(*flow_graph_);
     printer.PrintBlocks();
   }
 }
 
 
 bool IntegerInstructionSelector::IsPotentialUint32Definition(Definition* def) {
   // TODO(johnmccutchan): Consider Smi operations, to avoid unnecessary tagging
   // & untagged of intermediate results.
   // TODO(johnmccutchan): Consider phis.
   return def->IsBoxInt64() ||
          def->IsUnboxInt64() ||
          def->IsBinaryMintOp() ||
          def->IsShiftMintOp()  ||
          def->IsUnaryMintOp();
 }
 
 
 void IntegerInstructionSelector::FindPotentialUint32Definitions() {
   if (FLAG_trace_integer_ir_selection) {
-    OS::Print("++++ Finding potential Uint32 definitions:\n");
+    ISL_Print("++++ Finding potential Uint32 definitions:\n");
   }
 
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done();
        block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
 
     for (ForwardInstructionIterator instr_it(block);
          !instr_it.Done();
          instr_it.Advance()) {
       Instruction* current = instr_it.Current();
       Definition* defn = current->AsDefinition();
       if ((defn != NULL) && defn->HasSSATemp()) {
         if (IsPotentialUint32Definition(defn)) {
           if (FLAG_trace_integer_ir_selection) {
-           OS::Print("Adding %s\n", current->ToCString());
+           ISL_Print("Adding %s\n", current->ToCString());
           }
           potential_uint32_defs_.Add(defn);
         }
       }
     }
   }
 }
 
 
 // BinaryMintOp masks and stores into unsigned typed arrays that truncate the
@@ skipping 13 matching lines @@
     return true;
   }
   // TODO(johnmccutchan): Add typed array stores.
   return false;
 }
 
 
 void IntegerInstructionSelector::FindUint32NarrowingDefinitions() {
   ASSERT(selected_uint32_defs_ != NULL);
   if (FLAG_trace_integer_ir_selection) {
-    OS::Print("++++ Selecting Uint32 definitions:\n");
-    OS::Print("++++ Initial set:\n");
+    ISL_Print("++++ Selecting Uint32 definitions:\n");
+    ISL_Print("++++ Initial set:\n");
   }
   for (intptr_t i = 0; i < potential_uint32_defs_.length(); i++) {
     Definition* defn = potential_uint32_defs_[i];
     if (IsUint32NarrowingDefinition(defn)) {
       if (FLAG_trace_integer_ir_selection) {
-        OS::Print("Adding %s\n", defn->ToCString());
+        ISL_Print("Adding %s\n", defn->ToCString());
       }
       selected_uint32_defs_->Add(defn->ssa_temp_index());
     }
   }
 }
 
 
 bool IntegerInstructionSelector::AllUsesAreUint32Narrowing(Value* list_head) {
   for (Value::Iterator it(list_head);
        !it.Done();
@@ skipping 39 matching lines @@
          AllUsesAreUint32Narrowing(def->env_use_list());
 }
 
 
 void IntegerInstructionSelector::Propagate() {
   ASSERT(selected_uint32_defs_ != NULL);
   bool changed = true;
   intptr_t iteration = 0;
   while (changed) {
     if (FLAG_trace_integer_ir_selection) {
-      OS::Print("+++ Iteration: %" Pd "\n", iteration++);
+      ISL_Print("+++ Iteration: %" Pd "\n", iteration++);
     }
     changed = false;
     for (intptr_t i = 0; i < potential_uint32_defs_.length(); i++) {
       Definition* defn = potential_uint32_defs_[i];
       if (selected_uint32_defs_->Contains(defn->ssa_temp_index())) {
         // Already marked as a candidate, skip.
         continue;
       }
       if (defn->IsConstant()) {
         // Skip constants.
         continue;
       }
       if (CanBecomeUint32(defn)) {
         if (FLAG_trace_integer_ir_selection) {
-          OS::Print("Adding %s\n", defn->ToCString());
+          ISL_Print("Adding %s\n", defn->ToCString());
         }
         // Found a new candidate.
         selected_uint32_defs_->Add(defn->ssa_temp_index());
         // Haven't reached fixed point yet.
         changed = true;
       }
     }
   }
   if (FLAG_trace_integer_ir_selection) {
-    OS::Print("Reached fixed point\n");
+    ISL_Print("Reached fixed point\n");
   }
 }
 
 
 Definition* IntegerInstructionSelector::ConstructReplacementFor(
     Definition* def) {
   // Should only see mint definitions.
   ASSERT(IsPotentialUint32Definition(def));
   // Should not see constant instructions.
   ASSERT(!def->IsConstant());
@@ skipping 26 matching lines @@
     intptr_t deopt_id = op->DeoptimizationTarget();
     return new(I) ShiftUint32OpInstr(op_kind, left, right, deopt_id);
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 void IntegerInstructionSelector::ReplaceInstructions() {
   if (FLAG_trace_integer_ir_selection) {
-    OS::Print("++++ Replacing instructions:\n");
+    ISL_Print("++++ Replacing instructions:\n");
   }
   for (intptr_t i = 0; i < potential_uint32_defs_.length(); i++) {
     Definition* defn = potential_uint32_defs_[i];
     if (!selected_uint32_defs_->Contains(defn->ssa_temp_index())) {
       // Not a candidate.
       continue;
     }
     Definition* replacement = ConstructReplacementFor(defn);
     ASSERT(replacement != NULL);
     if (FLAG_trace_integer_ir_selection) {
-      OS::Print("Replacing %s with %s\n", defn->ToCString(),
+      ISL_Print("Replacing %s with %s\n", defn->ToCString(),
                                           replacement->ToCString());
     }
     if (!Range::IsUnknown(defn->range())) {
       replacement->set_range(*defn->range());
     }
     defn->ReplaceWith(replacement, NULL);
     ASSERT(flow_graph_->VerifyUseLists());
   }
 }
 
@@ skipping 1235 matching lines @@
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 }  // namespace dart