More guarding of code under #ifndef PRODUCT ... #endif

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 1006 matching lines @@
     }
     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)) {
+#ifndef PRODUCT
       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));
       }
+#endif  // !PRODUCT
       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.
     GrowableArray<ConstraintInstr*> positive_constraints(
         non_positive_symbols.length());
     Range* positive_range = new Range(
         RangeBoundary::FromConstant(0),
         RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundarySmi));
     for (intptr_t i = 0; i < non_positive_symbols.length(); i++) {
       Definition* symbol = non_positive_symbols[i];
       positive_constraints.Add(new ConstraintInstr(
           new Value(symbol),
           positive_range));
     }
 
     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.
+#ifndef PRODUCT
       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));
       }
+#endif  // !PRODUCT
       return;
     }
 
+#ifndef PRODUCT
     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));
     }
+#endif  // !PRODUCT
 
     // 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),
@@ skipping 402 matching lines @@
     for (intptr_t i = 0; i < defn->InputCount(); i++) {
       defn->InputAt(i)->set_definition(
           ApplyConstraints(defn->InputAt(i)->definition(),
                            post_dominator,
                            constraints));
     }
 
     return defn;
   }
 
+#ifndef PRODUCT
   static void PrettyPrintIndexBoundRecursively(BufferFormatter* f,
                                                Definition* index_bound) {
     BinarySmiOpInstr* binary_op = index_bound->AsBinarySmiOp();
     if (binary_op != NULL) {
       f->Print("(");
       PrettyPrintIndexBoundRecursively(f, binary_op->left()->definition());
       f->Print(" %s ", Token::Str(binary_op->op_kind()));
       PrettyPrintIndexBoundRecursively(f, binary_op->right()->definition());
       f->Print(")");
     } else if (index_bound->IsConstant()) {
       f->Print("%" Pd "",
                Smi::Cast(index_bound->AsConstant()->value()).Value());
     } else {
       f->Print("v%" Pd "", index_bound->ssa_temp_index());
     }
     f->Print(" {%s}", Range::ToCString(index_bound->range()));
   }
 
 
   static const char* IndexBoundToCString(Definition* index_bound) {
     char buffer[1024];
     BufferFormatter f(buffer, sizeof(buffer));
     PrettyPrintIndexBoundRecursively(&f, index_bound);
     return Thread::Current()->zone()->MakeCopyOfString(buffer);
   }
+#endif  // !PRODUCT
 
   RangeAnalysis* range_analysis_;
   FlowGraph* flow_graph_;
   Scheduler scheduler_;
 };
 
 
 void RangeAnalysis::EliminateRedundantBoundsChecks() {
   if (FLAG_array_bounds_check_elimination) {
     const Function& function = flow_graph_->function();
@@ skipping 1628 matching lines @@
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 }  // namespace dart