- Revert to use DEBUG_ASSERT again.

runtime/vm/compiler.cc

 // Copyright (c) 2012, 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/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 301 matching lines @@
       if (reorder_blocks) {
         block_scheduler.AssignEdgeWeights();
       }
 
       if (optimized) {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::ssa_timer,
                          isolate);
         // Transform to SSA (virtual register 0 and no inlining arguments).
         flow_graph->ComputeSSA(0, NULL);
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
         if (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized) {
           FlowGraphPrinter::PrintGraph("After SSA", flow_graph);
         }
       }
 
       // Collect all instance fields that are loaded in the graph and
       // have non-generic type feedback attached to them that can
       // potentially affect optimizations.
       if (optimized) {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphoptimizer_timer,
                          isolate);
 
         FlowGraphOptimizer optimizer(flow_graph);
         optimizer.ApplyICData();
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Optimize (a << b) & c patterns, merge operations.
         // Run early in order to have more opportunity to optimize left shifts.
         optimizer.TryOptimizePatterns();
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Inlining (mutates the flow graph)
         if (FLAG_use_inlining) {
           TimerScope timer(FLAG_compiler_stats,
                            &CompilerStats::graphinliner_timer);
           // Propagate types to create more inlining opportunities.
           FlowGraphTypePropagator::Propagate(flow_graph);
-          ASSERT(flow_graph->VerifyUseLists());
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
           // Use propagated class-ids to create more inlining opportunities.
           optimizer.ApplyClassIds();
-          ASSERT(flow_graph->VerifyUseLists());
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
           FlowGraphInliner inliner(flow_graph);
           inliner.Inline();
           // Use lists are maintained and validated by the inliner.
-          ASSERT(flow_graph->VerifyUseLists());
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         // Propagate types and eliminate more type tests.
         FlowGraphTypePropagator::Propagate(flow_graph);
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Use propagated class-ids to optimize further.
         optimizer.ApplyClassIds();
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Propagate types for potentially newly added instructions by
         // ApplyClassIds(). Must occur before canonicalization.
         FlowGraphTypePropagator::Propagate(flow_graph);
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Do optimizations that depend on the propagated type information.
         if (optimizer.Canonicalize()) {
           // Invoke Canonicalize twice in order to fully canonicalize patterns
           // like "if (a & const == 0) { }".
           optimizer.Canonicalize();
         }
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         BranchSimplifier::Simplify(flow_graph);
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         IfConverter::Simplify(flow_graph);
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         if (FLAG_constant_propagation) {
           ConstantPropagator::Optimize(flow_graph);
-          ASSERT(flow_graph->VerifyUseLists());
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
           // A canonicalization pass to remove e.g. smi checks on smi constants.
           optimizer.Canonicalize();
-          ASSERT(flow_graph->VerifyUseLists());
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
           // Canonicalization introduced more opportunities for constant
           // propagation.
           ConstantPropagator::Optimize(flow_graph);
-          ASSERT(flow_graph->VerifyUseLists());
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         // Propagate types and eliminate even more type tests.
         // Recompute types after constant propagation to infer more precise
         // types for uses that were previously reached by now eliminated phis.
         FlowGraphTypePropagator::Propagate(flow_graph);
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Unbox doubles. Performed after constant propagation to minimize
         // interference from phis merging double values and tagged
         // values coming from dead paths.
         optimizer.SelectRepresentations();
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         if (FLAG_common_subexpression_elimination ||
             FLAG_loop_invariant_code_motion) {
           flow_graph->ComputeBlockEffects();
         }
 
         if (FLAG_common_subexpression_elimination) {
           if (DominatorBasedCSE::Optimize(flow_graph)) {
-            ASSERT(flow_graph->VerifyUseLists());
+            DEBUG_ASSERT(flow_graph->VerifyUseLists());
             // Do another round of CSE to take secondary effects into account:
             // e.g. when eliminating dependent loads (a.x[0] + a.x[0])
             // TODO(fschneider): Change to a one-pass optimization pass.
             DominatorBasedCSE::Optimize(flow_graph);
-            ASSERT(flow_graph->VerifyUseLists());
+            DEBUG_ASSERT(flow_graph->VerifyUseLists());
           }
         }
 
         // Run loop-invariant code motion right after load elimination since it
         // depends on the numbering of loads from the previous load-elimination.
         if (FLAG_loop_invariant_code_motion) {
           LICM licm(flow_graph);
           licm.Optimize();
-          ASSERT(flow_graph->VerifyUseLists());
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
         flow_graph->RemoveRedefinitions();
 
         // Optimize (a << b) & c patterns, merge operations.
         // Run after CSE in order to have more opportunity to merge
         // instructions that have same inputs.
         optimizer.TryOptimizePatterns();
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         DeadStoreElimination::Optimize(flow_graph);
 
         if (FLAG_range_analysis) {
           // Propagate types after store-load-forwarding. Some phis may have
           // become smi phis that can be processed by range analysis.
           FlowGraphTypePropagator::Propagate(flow_graph);
-          ASSERT(flow_graph->VerifyUseLists());
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
           // We have to perform range analysis after LICM because it
           // optimistically moves CheckSmi through phis into loop preheaders
           // making some phis smi.
           optimizer.InferSmiRanges();
-          ASSERT(flow_graph->VerifyUseLists());
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         if (FLAG_constant_propagation) {
           // Constant propagation can use information from range analysis to
           // find unreachable branch targets and eliminate branches that have
           // the same true- and false-target.
           ConstantPropagator::OptimizeBranches(flow_graph);
-          ASSERT(flow_graph->VerifyUseLists());
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         // Recompute types after code movement was done to ensure correct
         // reaching types for hoisted values.
         FlowGraphTypePropagator::Propagate(flow_graph);
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Optimize try-blocks.
         TryCatchAnalyzer::Optimize(flow_graph);
 
         // Detach environments from the instructions that can't deoptimize.
         // Do it before we attempt to perform allocation sinking to minimize
         // amount of materializations it has to perform.
         optimizer.EliminateEnvironments();
 
         DeadCodeElimination::EliminateDeadPhis(flow_graph);
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Attempt to sink allocations of temporary non-escaping objects to
         // the deoptimization path.
         AllocationSinking* sinking = NULL;
         if (FLAG_allocation_sinking &&
             (flow_graph->graph_entry()->SuccessorCount()  == 1)) {
           // TODO(fschneider): Support allocation sinking with try-catch.
           sinking = new AllocationSinking(flow_graph);
           sinking->Optimize();
         }
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Ensure that all phis inserted by optimization passes have consistent
         // representations.
         optimizer.SelectRepresentations();
 
         if (optimizer.Canonicalize()) {
           // To fully remove redundant boxing (e.g. BoxDouble used only in
           // environments and UnboxDouble instructions) instruction we
           // first need to replace all their uses and then fold them away.
           // For now we just repeat Canonicalize twice to do that.
           // TODO(vegorov): implement a separate representation folding pass.
           optimizer.Canonicalize();
         }
-        ASSERT(flow_graph->VerifyUseLists());
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         if (sinking != NULL) {
           // Remove all MaterializeObject instructions inserted by allocation
           // sinking from the flow graph and let them float on the side
           // referenced only from environments. Register allocator will consider
           // them as part of a deoptimization environment.
           sinking->DetachMaterializations();
         }
 
         // Compute and store graph informations (call & instruction counts)
@@ skipping 459 matching lines @@
     const Object& result =
       Object::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart