Simplify compilation of relational operators.

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 1059 matching lines @@
       new LoadIndexedInstr(new Value(array),
                            new Value(index),
                            index_scale,
                            array_cid,
                            deopt_id);
   ReplaceCall(call, array_op);
   return true;
 }
 
 
+static bool SmiFitsInDouble() { return kSmiBits < 53; }
+
+
+bool FlowGraphOptimizer::TryReplaceWithRelationalOp(InstanceCallInstr* call,
+                                                    Token::Kind op_kind) {
+  const ICData& ic_data = *call->ic_data();
+  ASSERT(ic_data.num_args_tested() == 2);
+
+  ASSERT(call->ArgumentCount() == 2);
+  Definition* left = call->ArgumentAt(0);
+  Definition* right = call->ArgumentAt(1);
+
+  intptr_t cid = kIllegalCid;
+  if (HasOnlyTwoOf(ic_data, kSmiCid)) {
+    InsertBefore(call,
+                 new CheckSmiInstr(new Value(left), call->deopt_id()),
+                 call->env(),
+                 Definition::kEffect);
+    InsertBefore(call,
+                 new CheckSmiInstr(new Value(right), call->deopt_id()),
+                 call->env(),
+                 Definition::kEffect);
+    cid = kSmiCid;
+  } else if (HasTwoMintOrSmi(ic_data) &&
+             FlowGraphCompiler::SupportsUnboxedMints()) {
+    cid = kMintCid;
+  } else if (HasTwoDoubleOrSmi(ic_data)) {
+    // Use double comparison.
+    if (SmiFitsInDouble()) {
+      cid = kDoubleCid;
+    } else {
+      if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
+        // We cannot use double comparison on two Smi-s. Need polymorphic

[Kevin Millikin (Google), 2013/09/03 13:23:55]

I see that you didn't write this comment in this change, but smi is not a proper
noun, and its plural is just "smis" :)

[Florian Schneider, 2013/09/03 13:55:06]

Done.

+        // call.
+        return false;
+      } else {
+        InsertBefore(call,
+                     new CheckEitherNonSmiInstr(new Value(left),
+                                                new Value(right),
+                                                call->deopt_id()),
+                     call->env(),
+                     Definition::kEffect);
+        cid = kDoubleCid;
+      }
+    }
+  } else {
+    return false;
+  }
+  ASSERT(cid != kIllegalCid);
+  RelationalOpInstr* comp = new RelationalOpInstr(call->token_pos(),
+                                                  op_kind,
+                                                  new Value(left),
+                                                  new Value(right),
+                                                  cid,
+                                                  call->deopt_id());
+  ReplaceCall(call, comp);
+  return true;
+}
+
+
 bool FlowGraphOptimizer::TryReplaceWithBinaryOp(InstanceCallInstr* call,
                                                 Token::Kind op_kind) {
   intptr_t operands_type = kIllegalCid;
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   switch (op_kind) {
     case Token::kADD:
     case Token::kSUB:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
         // Don't generate smi code if the IC data is marked because
@@ skipping 1513 matching lines @@
     instr->set_ic_data(&unary_checks);
     return;
   }
 
   if ((op_kind == Token::kASSIGN_INDEX) && TryReplaceWithStoreIndexed(instr)) {
     return;
   }
   if ((op_kind == Token::kINDEX) && TryReplaceWithLoadIndexed(instr)) {
     return;
   }
+
+  if (Token::IsRelationalOperator(op_kind) &&
+      TryReplaceWithRelationalOp(instr, op_kind)) {
+    return;
+  }
+
   if (Token::IsBinaryOperator(op_kind) &&
       TryReplaceWithBinaryOp(instr, op_kind)) {
     return;
   }
   if (Token::IsPrefixOperator(op_kind) &&
       TryReplaceWithUnaryOp(instr, op_kind)) {
     return;
   }
   if ((op_kind == Token::kGET) && TryInlineInstanceGetter(instr)) {
     return;
@@ skipping 183 matching lines @@
       new Value(instr->ArgumentAt(1)),
       needs_store_barrier);
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
 
-static bool SmiFitsInDouble() { return kSmiBits < 53; }
-
-
-void FlowGraphOptimizer::HandleComparison(ComparisonInstr* comp,
-                                          const ICData& ic_data,
-                                          Instruction* current_instruction) {
-  ASSERT(ic_data.num_args_tested() == 2);
-  ASSERT(comp->operation_cid() == kIllegalCid);
-  if (HasOnlyTwoOf(ic_data, kSmiCid)) {
-    InsertBefore(current_instruction,
-                 new CheckSmiInstr(comp->left()->Copy(), comp->deopt_id()),
-                 current_instruction->env(),
-                 Definition::kEffect);
-    InsertBefore(current_instruction,
-                 new CheckSmiInstr(comp->right()->Copy(), comp->deopt_id()),
-                 current_instruction->env(),
-                 Definition::kEffect);
-    comp->set_operation_cid(kSmiCid);
-  } else if (HasTwoMintOrSmi(ic_data) &&
-             FlowGraphCompiler::SupportsUnboxedMints()) {
-    comp->set_operation_cid(kMintCid);
-  } else if (HasTwoDoubleOrSmi(ic_data)) {
-    // Use double comparison.
-    if (SmiFitsInDouble()) {
-      comp->set_operation_cid(kDoubleCid);
-    } else {
-      if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
-        // We cannot use double comparison on two Smi-s.
-        ASSERT(comp->operation_cid() == kIllegalCid);
-      } else {
-        InsertBefore(current_instruction,
-                     new CheckEitherNonSmiInstr(comp->left()->Copy(),
-                                                comp->right()->Copy(),
-                                                comp->deopt_id()),
-                     current_instruction->env(),
-                     Definition::kEffect);
-        comp->set_operation_cid(kDoubleCid);
-      }
-    }
-  } else {
-    ASSERT(comp->operation_cid() == kIllegalCid);
-  }
-}
-
-
-void FlowGraphOptimizer::HandleRelationalOp(RelationalOpInstr* comp) {
-  if (!comp->HasICData() || (comp->ic_data()->NumberOfChecks() == 0)) {
-    return;
-  }
-  HandleComparison(comp, *comp->ic_data(), current_iterator()->Current());
-}
-
-
-void FlowGraphOptimizer::VisitRelationalOp(RelationalOpInstr* instr) {
-  HandleRelationalOp(instr);
-}
-
-
 bool FlowGraphOptimizer::CanStrictifyEqualityCompare(
     EqualityCompareInstr* compare) {
   // If one of the inputs is null this is a strict comparison.
   if (compare->left()->BindsToConstantNull() ||
       compare->right()->BindsToConstantNull()) {
     return true;
   }
 
   if (compare->left()->Type()->IsNone()) {
     return false;  // We might be running prior to any type propagation passes.
@@ skipping 102 matching lines @@
   if (StrictifyEqualityCompare(comp, current_instruction)) {
     // Based on input types, equality converted to strict-equality.
     return;
   }
 
   if (!comp->HasICData() || (comp->ic_data()->NumberOfChecks() == 0)) {
     return;
   }
 
   const ICData& ic_data = *comp->ic_data();
-  HandleComparison(comp, ic_data, current_instruction);
+  ASSERT(ic_data.num_args_tested() == 2);
+  ASSERT(comp->operation_cid() == kIllegalCid);
+  if (HasOnlyTwoOf(ic_data, kSmiCid)) {
+    InsertBefore(current_instruction,
+                 new CheckSmiInstr(comp->left()->Copy(), comp->deopt_id()),
+                 current_instruction->env(),
+                 Definition::kEffect);
+    InsertBefore(current_instruction,
+                 new CheckSmiInstr(comp->right()->Copy(), comp->deopt_id()),
+                 current_instruction->env(),
+                 Definition::kEffect);
+    comp->set_operation_cid(kSmiCid);
+  } else if (HasTwoMintOrSmi(ic_data) &&
+             FlowGraphCompiler::SupportsUnboxedMints()) {
+    comp->set_operation_cid(kMintCid);
+  } else if (HasTwoDoubleOrSmi(ic_data)) {
+    // Use double comparison.
+    if (SmiFitsInDouble()) {
+      comp->set_operation_cid(kDoubleCid);
+    } else {
+      if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
+        // We cannot use double comparison on two Smi-s.
+        ASSERT(comp->operation_cid() == kIllegalCid);
+      } else {
+        InsertBefore(current_instruction,
+                     new CheckEitherNonSmiInstr(comp->left()->Copy(),
+                                                comp->right()->Copy(),
+                                                comp->deopt_id()),
+                     current_instruction->env(),
+                     Definition::kEffect);
+        comp->set_operation_cid(kDoubleCid);
+      }
+    }
+  }
 
   if (comp->operation_cid() != kIllegalCid) {
     // Done.
     return;
   }
 
   const ICData& unary_checks_0 =
       ICData::ZoneHandle(comp->ic_data()->AsUnaryClassChecks());
   if (StrictifyEqualityCompareWithICData(
         comp, unary_checks_0, current_instruction)) {
@@ skipping 31 matching lines @@
 
 
 
 void FlowGraphOptimizer::VisitEqualityCompare(EqualityCompareInstr* instr) {
   HandleEqualityCompare(instr, instr);
 }
 
 
 void FlowGraphOptimizer::VisitBranch(BranchInstr* instr) {
   ComparisonInstr* comparison = instr->comparison();
-  if (comparison->IsRelationalOp()) {
-    HandleRelationalOp(comparison->AsRelationalOp());
-  } else if (comparison->IsEqualityCompare()) {
+  if (comparison->IsEqualityCompare()) {
     HandleEqualityCompare(comparison->AsEqualityCompare(), instr);
   } else {
     ASSERT(comparison->IsStrictCompare());
     // Nothing to do.
   }
 }
 
 
 static bool MayBeBoxableNumber(intptr_t cid) {
   return (cid == kDynamicCid) ||
@@ skipping 3879 matching lines @@
     new_equality_compare->set_operation_cid(equality_compare->operation_cid());
     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,
-                              Object::null_array());
-    new_relational_op->set_ic_data(relational_op->ic_data());
-    new_relational_op->set_operation_cid(relational_op->operation_cid());
+                              relational_op->operation_cid(),
+                              relational_op->deopt_id());
     new_comparison = new_relational_op;
   }
   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
@@ skipping 512 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