Remove more feature in product mode

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 166 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) {
+          if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
             THR_Print("Simple loop variable: %s bound <%s>\n",
                        current->ToCString(),
                        info->limit() != NULL ?
                            info->limit()->ToCString() : "?");
           }
 
           loop_variables.Add(info);
         }
       }
     }
@@ skipping 489 matching lines @@
       if (op == WIDEN) {
         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) {
+      if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
         THR_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 @@
       : range_analysis_(range_analysis),
         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) {
+      if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
         THR_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) {
+      if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
         THR_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) {
+      if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
         THR_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
@@ skipping 13 matching lines @@
     Definition* lower_bound =
       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) {
+      if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
         THR_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) {
+    if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
       THR_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();
 
@@ skipping 586 matching lines @@
 
 
 void IntegerInstructionSelector::Select() {
   if (FLAG_trace_integer_ir_selection) {
     THR_Print("---- starting integer ir selection -------\n");
   }
   FindPotentialUint32Definitions();
   FindUint32NarrowingDefinitions();
   Propagate();
   ReplaceInstructions();
-  if (FLAG_trace_integer_ir_selection) {
+  if (FLAG_support_il_printer && FLAG_trace_integer_ir_selection) {
     THR_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.
@@ skipping 16 matching lines @@
        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) {
+          if (FLAG_support_il_printer && FLAG_trace_integer_ir_selection) {
            THR_Print("Adding %s\n", current->ToCString());
           }
           potential_uint32_defs_.Add(defn);
         }
       }
     }
   }
 }
 
 
@@ skipping 20 matching lines @@
 
 void IntegerInstructionSelector::FindUint32NarrowingDefinitions() {
   ASSERT(selected_uint32_defs_ != NULL);
   if (FLAG_trace_integer_ir_selection) {
     THR_Print("++++ Selecting Uint32 definitions:\n");
     THR_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) {
+      if (FLAG_support_il_printer && FLAG_trace_integer_ir_selection) {
         THR_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);
@@ skipping 54 matching lines @@
       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) {
+        if (FLAG_support_il_printer && FLAG_trace_integer_ir_selection) {
           THR_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) {
@@ skipping 47 matching lines @@
     THR_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) {
+    if (FLAG_support_il_printer && FLAG_trace_integer_ir_selection) {
       THR_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 1250 matching lines @@
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 }  // namespace dart