Fix bugs in load elimination and type propagation.

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 26 matching lines @@
 DEFINE_FLAG(bool, disassemble, false, "Disassemble dart code.");
 DEFINE_FLAG(bool, disassemble_optimized, false, "Disassemble optimized code.");
 DEFINE_FLAG(bool, trace_bailout, false, "Print bailout from ssa compiler.");
 DEFINE_FLAG(bool, trace_compiler, false, "Trace compiler operations.");
 DEFINE_FLAG(bool, constant_propagation, true,
     "Do conditional constant propagation/unreachable code elimination.");
 DEFINE_FLAG(bool, common_subexpression_elimination, true,
     "Do common subexpression elimination.");
 DEFINE_FLAG(bool, loop_invariant_code_motion, true,
     "Do loop invariant code motion.");
-DEFINE_FLAG(bool, propagate_types, true, "Do static type propagation.");
 DEFINE_FLAG(bool, allocation_sinking, true,
     "Attempt to sink temporary allocations to side exits");
 DEFINE_FLAG(int, deoptimization_counter_threshold, 16,
     "How many times we allow deoptimization before we disallow optimization.");
 DEFINE_FLAG(int, deoptimization_counter_licm_threshold, 8,
     "How many times we allow deoptimization before we disable LICM.");
 DEFINE_FLAG(bool, use_inlining, true, "Enable call-site inlining");
 DEFINE_FLAG(bool, range_analysis, true, "Enable range analysis");
 DEFINE_FLAG(bool, reorder_basic_blocks, true, "Enable basic-block reordering.");
 DEFINE_FLAG(bool, verify_compiler, false,
@@ skipping 284 matching lines @@
         // TODO(srdjan): Moved before inlining until environment use list can
         // be used to detect when shift-left is outside the scope of bit-and.
         optimizer.TryOptimizeLeftShiftWithBitAndPattern();
         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.
-          if (FLAG_propagate_types) {
-            FlowGraphTypePropagator propagator(flow_graph);
-            propagator.Propagate();
-            DEBUG_ASSERT(flow_graph->VerifyUseLists());
-          }
+          FlowGraphTypePropagator::Propagate(flow_graph);
 
           // Use propagated class-ids to create more inlining opportunities.
           optimizer.ApplyClassIds();
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
           FlowGraphInliner inliner(flow_graph);
           inliner.Inline();
           // Use lists are maintained and validated by the inliner.
           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());
-        }
+        FlowGraphTypePropagator::Propagate(flow_graph);
 
         // 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());
 
         BranchSimplifier::Simplify(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         IfConverter::Simplify(flow_graph);
         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());
           // Canonicalization introduced more opportunities for constant
           // propagation.
           ConstantPropagator::Optimize(flow_graph);
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
         // Propagate types and eliminate even more type tests.
-        if (FLAG_propagate_types) {
-          // Recompute types after constant propagation to infer more precise
-          // types for uses that were previously reached by now eliminated phis.
-          FlowGraphTypePropagator propagator(flow_graph);
-          propagator.Propagate();
-          DEBUG_ASSERT(flow_graph->VerifyUseLists());
-        }
+        // Recompute types after constant propagation to infer more precise
+        // types for uses that were previously reached by now eliminated phis.
+        FlowGraphTypePropagator::Propagate(flow_graph);
 
         // Unbox doubles. Performed after constant propagation to minimize
         // interference from phis merging double values and tagged
-        // values comming from dead paths.
+        // values coming from dead paths.
         optimizer.SelectRepresentations();
         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)) {
             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 &&
             (function.deoptimization_counter() <
              FLAG_deoptimization_counter_licm_threshold)) {
           LICM licm(flow_graph);
           licm.Optimize();
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
         flow_graph->RemoveRedefinitions();
 
         if (FLAG_range_analysis) {
-          if (FLAG_propagate_types) {
-            // Propagate types after store-load-forwarding. Some phis may have
-            // become smi phis that can be processed by range analysis.
-            FlowGraphTypePropagator propagator(flow_graph);
-            propagator.Propagate();
-            DEBUG_ASSERT(flow_graph->VerifyUseLists());
-          }
+          // Propagate types after store-load-forwarding. Some phis may have
+          // become smi phis that can be processed by range analysis.
+          FlowGraphTypePropagator::Propagate(flow_graph);
+
           // 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());
         }
 
         if (FLAG_constant_propagation) {
           // Constant propagation can use information from range analysis to
           // find unreachable branch targets.
           ConstantPropagator::OptimizeBranches(flow_graph);
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
 
-        if (FLAG_propagate_types) {
-          // Recompute types after code movement was done to ensure correct
-          // reaching types for hoisted values.
-          FlowGraphTypePropagator propagator(flow_graph);
-          propagator.Propagate();
-          DEBUG_ASSERT(flow_graph->VerifyUseLists());
-        }
+        // Recompute types after code movement was done to ensure correct
+        // reaching types for hoisted values.
+        FlowGraphTypePropagator::Propagate(flow_graph);
 
         // 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();
 
         // Attempt to sink allocations of temporary non-escaping objects to
@@ skipping 464 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