Remove two more places where we computed use lists and add verification.

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/code_generator.h"
@@ skipping 36 matching lines @@
 DEFINE_FLAG(bool, propagate_types, true, "Do static type propagation.");
 DEFINE_FLAG(int, deoptimization_counter_threshold, 16,
     "How many times we allow deoptimization before we disallow optimization.");
 DEFINE_FLAG(bool, use_inlining, true, "Enable call-site inlining");
 DEFINE_FLAG(bool, range_analysis, true, "Enable range analysis");
 DEFINE_FLAG(bool, verify_compiler, false,
     "Enable compiler verification assertions");
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(bool, print_flow_graph_optimized);
 DECLARE_FLAG(bool, trace_failed_optimization_attempts);
-DECLARE_FLAG(bool, trace_type_propagation);
 
 // Compile a function. Should call only if the function has not been compiled.
 //   Arg0: function object.
 DEFINE_RUNTIME_ENTRY(CompileFunction, 1) {
   ASSERT(arguments.ArgCount() == kCompileFunctionRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   ASSERT(!function.HasCode());
   const Error& error = Error::Handle(Compiler::CompileFunction(function));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
@@ skipping 85 matching lines @@
       FlowGraphBuilder builder(parsed_function, NULL);  // NULL = not inlining.
       flow_graph = builder.BuildGraph();
     }
 
     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);
+      flow_graph->ComputeUseLists();
     }
 
     if (FLAG_print_flow_graph ||
         (optimized && FLAG_print_flow_graph_optimized)) {
       OS::Print("Before Optimizations\n");
       FlowGraphPrinter printer(*flow_graph);
       printer.PrintBlocks();
     }
 
     if (optimized) {
       TimerScope timer(FLAG_compiler_stats,
                        &CompilerStats::graphoptimizer_timer,
                        isolate);
 
-      flow_graph->ComputeUseLists();
-
       FlowGraphOptimizer optimizer(flow_graph);
       optimizer.ApplyICData();
+      DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
       // Inlining (mutates the flow graph)
       if (FLAG_use_inlining) {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_timer);
         FlowGraphInliner inliner(flow_graph);
         inliner.Inline();
         // Use lists are maintained and validated by the inliner.
-      }
-
-      if (FLAG_trace_type_propagation) {
-        OS::Print("Before type propagation:\n");
-        FlowGraphPrinter printer(*flow_graph);
-        printer.PrintBlocks();
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
       }
 
       // Propagate types and eliminate more type tests.
       if (FLAG_propagate_types) {
         FlowGraphTypePropagator propagator(flow_graph);
         propagator.Propagate();
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
       }
 
-      if (FLAG_trace_type_propagation) {
-        OS::Print("After type propagation:\n");
-        FlowGraphPrinter printer(*flow_graph);
-        printer.PrintBlocks();
-      }
-
-      flow_graph->ComputeUseLists();
-
       // Use propagated class-ids to optimize further.
       optimizer.ApplyClassIds();
+      DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
       // Do optimizations that depend on the propagated type information.
       optimizer.Canonicalize();
+      DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
       if (FLAG_constant_propagation) {
         ConstantPropagator::Optimize(flow_graph);
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
         // A canonicalization pass to remove e.g. smi checks on smi constants.
         optimizer.Canonicalize();
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
       }
 
       // Unbox doubles. Performed after constant propagation to minimize
       // interference from phis merging double values and tagged
       // values comming from dead paths.
       optimizer.SelectRepresentations();
+      DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
       if (FLAG_common_subexpression_elimination) {
         if (DominatorBasedCSE::Optimize(flow_graph)) {
+          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);
+          DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
       }
       if (FLAG_loop_invariant_code_motion &&
           (parsed_function.function().deoptimization_counter() <
            (FLAG_deoptimization_counter_threshold - 1))) {
         LICM::Optimize(flow_graph);
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
       }
 
       if (FLAG_range_analysis) {
         // We have to perform range analysis after LICM because it
         // optimistically moves CheckSmi through phis into loop preheaders
         // making some phis smi.
         optimizer.InferSmiRanges();
+        DEBUG_ASSERT(flow_graph->VerifyUseLists());
       }
 
       // The final canonicalization pass before the code generation.
       optimizer.Canonicalize();
+      DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
       // Perform register allocation on the SSA graph.
       FlowGraphAllocator allocator(*flow_graph);
       allocator.AllocateRegisters();
 
       if (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized) {
         OS::Print("After Optimizations:\n");
         FlowGraphPrinter printer(*flow_graph);
         printer.PrintBlocks();
       }
@@ skipping 384 matching lines @@
       Object::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart