Make constant propagation to fold x == x and re-run type propagation for better range analysis.

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 388 matching lines @@
       if (FLAG_loop_invariant_code_motion &&
           (function.deoptimization_counter() <
            (FLAG_deoptimization_counter_threshold - 1))) {
         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());
+        }
         // 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());
       }
 
-      // The final canonicalization pass before the code generation.
       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());
       }
 
       // 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
       // the deoptimization path.
       AllocationSinking* sinking = NULL;
       if (FLAG_allocation_sinking) {
         sinking = new AllocationSinking(flow_graph);
         sinking->Optimize();
       }
 
       // Ensure that all phis inserted by optimization passes have consistent
       // representations.
-      optimizer.UnboxPhis();
+      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();
       }
       DEBUG_ASSERT(flow_graph->VerifyUseLists());
@@ skipping 410 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