Fold away x === null comparisons when propagated cid of x is not kDynamicCid.

runtime/vm/flow_graph_optimizer.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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 3048 matching lines @@
 
 void ConstantPropagator::VisitStoreLocal(StoreLocalInstr* instr) {
   // Instruction is eliminated when translating to SSA.
   UNREACHABLE();
 }
 
 
 void ConstantPropagator::VisitStrictCompare(StrictCompareInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
+
   if (IsNonConstant(left) || IsNonConstant(right)) {
-    SetValue(instr, non_constant_);
+    // TODO(vegorov): incorporate nullability information into the lattice.
+    if ((left.IsNull() && (instr->right()->ResultCid() != kDynamicCid)) ||
+        (right.IsNull() && (instr->left()->ResultCid() != kDynamicCid))) {
+      bool result = left.IsNull() ? (instr->right()->ResultCid() == kNullCid)
+                                  : (instr->left()->ResultCid() == kNullCid);
+      if (instr->kind() == Token::kNE_STRICT) result = !result;
+      SetValue(instr, Bool::ZoneHandle(Bool::Get(result)));
+    } else {
+      SetValue(instr, non_constant_);
+    }
   } else if (IsConstant(left) && IsConstant(right)) {
     bool result = (left.raw() == right.raw());
     if (instr->kind() == Token::kNE_STRICT) result = !result;
     SetValue(instr, Bool::ZoneHandle(Bool::Get(result)));
   }
 }
 
 
 void ConstantPropagator::VisitEqualityCompare(EqualityCompareInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
@@ skipping 316 matching lines @@
 }
 
 
 void ConstantPropagator::Transform() {
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== Before constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 
+  GrowableArray<PhiInstr*> redundant_phis(10);
+
   // We will recompute dominators, block ordering, block ids, block last
   // instructions, previous pointers, predecessors, etc. after eliminating
   // unreachable code.  We do not maintain those properties during the
   // transformation.
   for (BlockIterator b = graph_->reverse_postorder_iterator();
        !b.Done();
        b.Advance()) {
     BlockEntryInstr* block = b.Current();
     if (!reachable_->Contains(block->preorder_number())) {
       if (FLAG_trace_constant_propagation) {
@@ skipping 22 matching lines @@
               }
             }
             ++live_count;
           }
         }
         if (live_count < pred_count) {
           for (intptr_t phi_idx = 0; phi_idx < phis->length(); ++phi_idx) {
             PhiInstr* phi = (*phis)[phi_idx];
             if (phi == NULL) continue;
             phi->inputs_.TruncateTo(live_count);
+            if (live_count == 1) redundant_phis.Add(phi);
           }
         }
       }
     }
 
     for (ForwardInstructionIterator i(block); !i.Done(); i.Advance()) {
       Definition* defn = i.Current()->AsDefinition();
       // Replace constant-valued instructions without observable side
       // effects.  Do this for smis only to avoid having to copy other
       // objects into the heap's old generation.
@@ skipping 55 matching lines @@
         join->LinkTo(next);
       }
     }
   }
 
   graph_->DiscoverBlocks();
   GrowableArray<BitVector*> dominance_frontier;
   graph_->ComputeDominators(&dominance_frontier);
   graph_->ComputeUseLists();
 
+  for (intptr_t i = 0; i < redundant_phis.length(); i++) {
+    PhiInstr* phi = redundant_phis[i];
+    phi->ReplaceUsesWith(phi->InputAt(0)->definition());
+    phi->mark_dead();
+  }
+
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart