Generalize if-conversion to arbitrary smi comparisons.

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/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 1344 matching lines @@
                     call->deopt_id(),
                     call->env(),
                     call);
       cid = kSmiCid;
     } else {
       // Shortcut for equality with null.
       ConstantInstr* right_const = right->AsConstant();
       ConstantInstr* left_const = left->AsConstant();
       if ((right_const != NULL && right_const->value().IsNull()) ||
           (left_const != NULL && left_const->value().IsNull())) {
-        StrictCompareInstr* comp = new StrictCompareInstr(call->token_pos(),
-                                                          Token::kEQ_STRICT,
-                                                          new Value(left),
-                                                          new Value(right));
+        StrictCompareInstr* comp =
+            new StrictCompareInstr(call->token_pos(),
+                                   Token::kEQ_STRICT,
+                                   new Value(left),
+                                   new Value(right),
+                                   false);  // No number check.
         ReplaceCall(call, comp);
         return true;
       }
       return false;
     }
   }
   ASSERT(cid != kIllegalCid);
   EqualityCompareInstr* comp = new EqualityCompareInstr(call->token_pos(),
                                                         op_kind,
                                                         new Value(left),
@@ skipping 4885 matching lines @@
 }
 
 
 void ConstantPropagator::VisitStoreLocal(StoreLocalInstr* instr) {
   // Instruction is eliminated when translating to SSA.
   UNREACHABLE();
 }
 
 
 void ConstantPropagator::VisitIfThenElse(IfThenElseInstr* instr) {
-  ASSERT(Token::IsEqualityOperator(instr->kind()));
-
-  const Object& left = instr->left()->definition()->constant_value();
-  const Object& right = instr->right()->definition()->constant_value();
-
-  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 ||
-          instr->kind() == Token::kNE) {
-        result = !result;
-      }
-      SetValue(instr, Smi::Handle(
-          Smi::New(result ? instr->if_true() : instr->if_false())));
-    } else {
-      SetValue(instr, non_constant_);
-    }
-  } else if (IsConstant(left) && IsConstant(right)) {
-    bool result = (left.raw() == right.raw());
-    if (instr->kind() == Token::kNE_STRICT ||
-        instr->kind() == Token::kNE) {
-      result = !result;
-    }
-    SetValue(instr, Smi::Handle(
-        Smi::New(result ? instr->if_true() : instr->if_false())));
+  instr->comparison()->Accept(this);
+  const Object& value = instr->comparison()->constant_value();
+  if (IsNonConstant(value)) {
+    SetValue(instr, non_constant_);
+  } else if (IsConstant(value)) {
+    ASSERT(value.IsBool());

[Kevin Millikin (Google), 2013/11/22 14:09:34]

Probably should assert that it's also not IsNull()?

+    bool result = Bool::Cast(value).value();
+    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()) {
     // Fold x === x, and x !== x to true/false.
@@ skipping 1043 matching lines @@
       new JoinEntryInstr(target->block_id(), target->try_index());
   join->InheritDeoptTarget(target);
   join->LinkTo(target->next());
   join->set_last_instruction(target->last_instruction());
   target->UnuseAllInputs();
   return join;
 }
 
 
 BranchInstr* BranchSimplifier::CloneBranch(BranchInstr* branch,
-                                           Value* left,
-                                           Value* right) {
+                                           Value* new_left,
+                                           Value* new_right) {
   ComparisonInstr* comparison = branch->comparison();
-  ComparisonInstr* new_comparison = NULL;
-  if (comparison->IsStrictCompare()) {
-    new_comparison = new StrictCompareInstr(comparison->token_pos(),
-                                            comparison->kind(),
-                                            left,
-                                            right);
-  } else if (comparison->IsEqualityCompare()) {
-    EqualityCompareInstr* equality_compare = comparison->AsEqualityCompare();
-    EqualityCompareInstr* new_equality_compare =
-        new EqualityCompareInstr(equality_compare->token_pos(),
-                                 comparison->kind(),
-                                 left,
-                                 right,
-                                 equality_compare->operation_cid(),
-                                 equality_compare->deopt_id());
-    new_comparison = new_equality_compare;
-  } else {
-    ASSERT(comparison->IsRelationalOp());
-    RelationalOpInstr* relational_op = comparison->AsRelationalOp();
-    RelationalOpInstr* new_relational_op =
-        new RelationalOpInstr(relational_op->token_pos(),
-                              comparison->kind(),
-                              left,
-                              right,
-                              relational_op->operation_cid(),
-                              relational_op->deopt_id());
-    new_comparison = new_relational_op;
-  }
+  ComparisonInstr* new_comparison =
+      comparison->CopyWithNewOperands(new_left, new_right);
   return new BranchInstr(new_comparison, branch->is_checked());
 }
 
 
 void BranchSimplifier::Simplify(FlowGraph* flow_graph) {
   // Optimize some branches that test the value of a phi.  When it is safe
   // to do so, push the branch to each of the predecessor blocks.  This is
   // an optimization when (a) it can avoid materializing a boolean object at
   // the phi only to test its value, and (b) it can expose opportunities for
   // constant propagation and unreachable code elimination.  This
@@ skipping 191 matching lines @@
         BranchInstr* branch = pred->last_instruction()->AsBranch();
         ComparisonInstr* comparison = branch->comparison();
 
         // Check if the platform supports efficient branchless IfThenElseInstr
         // for the given combination of comparison and values flowing from
         // false and true paths.
         if (IfThenElseInstr::Supports(comparison, v1, v2)) {
           Value* if_true = (pred1 == branch->true_successor()) ? v1 : v2;
           Value* if_false = (pred2 == branch->true_successor()) ? v1 : v2;
 
+          ComparisonInstr* new_comparison =
+              comparison->CopyWithNewOperands(comparison->left()->Copy(),
+                                              comparison->right()->Copy());
           IfThenElseInstr* if_then_else = new IfThenElseInstr(
-              comparison->kind(),
-              comparison->InputAt(0)->Copy(),
-              comparison->InputAt(1)->Copy(),
+              new_comparison,
               if_true->Copy(),
               if_false->Copy());
           flow_graph->InsertBefore(branch,
                                    if_then_else,
                                    NULL,
                                    Definition::kValue);
 
           phi->ReplaceUsesWith(if_then_else);
 
           // Connect IfThenElseInstr to the first instruction in the merge block
@@ skipping 291 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart