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

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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 432 matching lines @@
 
   if (unboxed != current) {
     phi->set_representation(unboxed);
     return true;
   }
 
   return false;
 }
 
 
-void FlowGraphOptimizer::UnboxPhis() {
-  GrowableArray<PhiInstr*> worklist(5);
-
-  // Convervatively unbox all phis that were proven to be of Double,
-  // Float32x4, or Uint32x4 type.
-  for (intptr_t i = 0; i < block_order_.length(); ++i) {
-    JoinEntryInstr* join_entry = block_order_[i]->AsJoinEntry();
-    if (join_entry != NULL) {
-      for (PhiIterator it(join_entry); !it.Done(); it.Advance()) {
-        PhiInstr* phi = it.Current();
-        if (UnboxPhi(phi)) {
-          worklist.Add(phi);
-        }
-      }
-    }
-  }
-
-  while (!worklist.is_empty()) {
-    PhiInstr* phi = worklist.RemoveLast();
-    InsertConversionsFor(phi);
-
-    for (intptr_t i = 0; i < phi->InputCount(); i++) {
-      ConvertUse(phi->InputAt(i),
-                 phi->InputAt(i)->definition()->representation());
-    }
-  }
-}
-
-
 void FlowGraphOptimizer::SelectRepresentations() {
   // Convervatively unbox all phis that were proven to be of Double,
   // Float32x4, or Uint32x4 type.
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     JoinEntryInstr* join_entry = block_order_[i]->AsJoinEntry();
     if (join_entry != NULL) {
       for (PhiIterator it(join_entry); !it.Done(); it.Advance()) {
         PhiInstr* phi = it.Current();
         UnboxPhi(phi);
       }
@@ skipping 4323 matching lines @@
   GrowableArray<BlockEntryInstr*> ignored;
   ConstantPropagator cp(graph, ignored);
   cp.Analyze();
   cp.Transform();
 }
 
 
 void ConstantPropagator::OptimizeBranches(FlowGraph* graph) {
   GrowableArray<BlockEntryInstr*> ignored;
   ConstantPropagator cp(graph, ignored);
+  cp.Analyze();
   cp.VisitBranches();
   cp.Transform();
 }
 
 
 void ConstantPropagator::SetReachable(BlockEntryInstr* block) {
   if (!reachable_->Contains(block->preorder_number())) {
     reachable_->Add(block->preorder_number());
     block_worklist_.Add(block);
   }
@@ skipping 318 matching lines @@
     SetValue(instr, Smi::Handle(
         Smi::New(result ? instr->if_true() : instr->if_false())));
   }
 }
 
 
 void ConstantPropagator::VisitStrictCompare(StrictCompareInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
 
+  if (instr->left()->definition() == instr->right()->definition()) {

[srdjan, 2013/06/12 16:37:51]

Yes, thanks to the spec that now says identical(NAN, NAN) => true

+    // Fold x === x, and x !== x to true/false.
+    SetValue(instr,
+             (instr->kind() == Token::kEQ_STRICT)
+               ? Bool::True()
+               : Bool::False());
+    return;
+  }
+
   if (IsNonConstant(left) || IsNonConstant(right)) {
     // TODO(vegorov): incorporate nullability information into the lattice.
     if ((left.IsNull() && instr->right()->Type()->HasDecidableNullability()) ||
         (right.IsNull() && instr->left()->Type()->HasDecidableNullability())) {
       bool result = left.IsNull() ? instr->right()->Type()->IsNull()
                                   : instr->left()->Type()->IsNull();
       if (instr->kind() == Token::kNE_STRICT) result = !result;
       SetValue(instr, result ? Bool::True() : Bool::False());
     } else {
       SetValue(instr, non_constant_);
@@ skipping 20 matching lines @@
     default:
       UNREACHABLE();
       return false;
   }
 }
 
 
 void ConstantPropagator::VisitEqualityCompare(EqualityCompareInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
+
+  if (instr->left()->definition() == instr->right()->definition()) {
+    // Fold x == x, and x != x to true/false for numbers and checked strict
+    // comparisons.
+    if (instr->is_checked_strict_equal() ||
+        RawObject::IsNumberClassId(instr->receiver_class_id())) {

[srdjan, 2013/06/12 16:37:51]

This is wrong for identical(NAN, NAN), which returns false. You can do this only
for int types.

[Florian Schneider, 2013/06/13 08:15:43]

Done.

[Lasse Reichstein Nielsen, 2013/06/13 08:21:25]

Is this correct? I.e. if
  var NAN = 0.0/0.0;
  print(identical(NAN,NAN));  
will it be able to print false?
I would have expected it to print true for identical(NAN,NAN), but false for
(NAN==NAN).

+      return SetValue(instr,
+                      (instr->kind() == Token::kEQ)
+                        ? Bool::True()
+                        : Bool::False());
+    }
+  }
+
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     if (left.IsInteger() && right.IsInteger()) {
       const bool result = CompareIntegers(instr->kind(),
                                           Integer::Cast(left),
                                           Integer::Cast(right));
       SetValue(instr, result ? Bool::True() : Bool::False());
     } else {
       SetValue(instr, non_constant_);
@@ skipping 1379 matching lines @@
 
   // Insert materializations at environment uses.
   const Class& cls = Class::Handle(alloc->constructor().Owner());
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, cls, *fields);
   }
 }
 
 
 }  // namespace dart