Generalize if-conversion to arbitrary smi comparisons.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_optimizer.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 #include "vm/il_printer.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, new_identity_spec, true,
-    "Use new identity check rules for numbers.");
 DEFINE_FLAG(bool, propagate_ic_data, true,
     "Propagate IC data from unoptimized to optimized IC calls.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, trace_optimization);
 DECLARE_FLAG(bool, trace_constant_propagation);
 DECLARE_FLAG(bool, throw_on_javascript_int_overflow);
 
 Definition::Definition()
     : range_(NULL),
@@ skipping 709 matching lines @@
   } else {
     other->LinkTo(next());
     // Remove this definition's input uses.
     UnuseAllInputs();
   }
   set_previous(NULL);
   set_next(NULL);
 }
 
 
-BranchInstr::BranchInstr(ComparisonInstr* comparison, bool is_checked)
-    : comparison_(comparison),
-      is_checked_(is_checked),
-      constrained_type_(NULL),
-      constant_target_(NULL) {
-  ASSERT(comparison->env() == NULL);
-  for (intptr_t i = comparison->InputCount() - 1; i >= 0; --i) {
-    comparison->InputAt(i)->set_instruction(this);
-  }
-}
-
-
-void BranchInstr::RawSetInputAt(intptr_t i, Value* value) {
-  comparison()->RawSetInputAt(i, value);
-}
-
-
 void BranchInstr::SetComparison(ComparisonInstr* new_comparison) {
   for (intptr_t i = new_comparison->InputCount() - 1; i >= 0; --i) {
     Value* input = new_comparison->InputAt(i);
     input->definition()->AddInputUse(input);
     input->set_instruction(this);
   }
   // There should be no need to copy or unuse an environment.
   ASSERT(comparison()->env() == NULL);
   ASSERT(new_comparison->env() == NULL);
   // Remove the current comparison's input uses.
@@ skipping 1130 matching lines @@
 
 void StoreContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Nothing to do.  Context register was loaded by the register allocator.
   ASSERT(locs()->in(0).reg() == CTX);
 }
 
 
 StrictCompareInstr::StrictCompareInstr(intptr_t token_pos,
                                        Token::Kind kind,
                                        Value* left,
-                                       Value* right)
+                                       Value* right,
+                                       bool needs_number_check)
     : ComparisonInstr(token_pos, kind, left, right),
-      needs_number_check_(FLAG_new_identity_spec) {
+      needs_number_check_(needs_number_check) {
   ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
 }
 
 
 LocationSummary* InstanceCallInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void InstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 530 matching lines @@
   range_ = new Range(RangeBoundary::FromConstant(min),
                      RangeBoundary::FromConstant(max));
 }
 
 
 static bool BindsToSmiConstant(Value* value) {
   return value->BindsToConstant() && value->BoundConstant().IsSmi();
 }
 
 
+ComparisonInstr* EqualityCompareInstr::CopyWithNewOperands(Value* new_left,
+                                                           Value* new_right) {
+  return new EqualityCompareInstr(token_pos(),
+                                  kind(),
+                                  new_left,
+                                  new_right,
+                                  operation_cid(),
+                                  deopt_id());
+}
+
+
+ComparisonInstr* RelationalOpInstr::CopyWithNewOperands(Value* new_left,
+                                                        Value* new_right) {
+  return new RelationalOpInstr(token_pos(),
+                               kind(),
+                               new_left,
+                               new_right,
+                               operation_cid(),
+                               deopt_id());
+}
+
+
+ComparisonInstr* StrictCompareInstr::CopyWithNewOperands(Value* new_left,
+                                                         Value* new_right) {
+  return new StrictCompareInstr(token_pos(),
+                                kind(),
+                                new_left,
+                                new_right,
+                                needs_number_check());
+}
+
+
+
+ComparisonInstr* TestSmiInstr::CopyWithNewOperands(Value* new_left,
+                                                   Value* new_right) {
+  return new TestSmiInstr(token_pos(), kind(), new_left, new_right);
+}
+
+
 bool IfThenElseInstr::Supports(ComparisonInstr* comparison,
                                Value* v1,
                                Value* v2) {
-  if (!(comparison->IsStrictCompare() &&
-        !comparison->AsStrictCompare()->needs_number_check()) &&
-      !(comparison->IsEqualityCompare() &&
-        (comparison->AsEqualityCompare()->operation_cid() == kSmiCid))) {
+  bool is_smi_result = BindsToSmiConstant(v1) && BindsToSmiConstant(v2);
+  if (comparison->IsStrictCompare()) {
+    // Strict comparison with number checks calls a stub and is not supported
+    // by if-conversion.
+    return is_smi_result
+        && !comparison->AsStrictCompare()->needs_number_check();
+  }
+  if (comparison->operation_cid() != kSmiCid) {
+    // Non-smi comparisons are not supported by if-conversion.
     return false;
   }
-
-  if (!BindsToSmiConstant(v1) || !BindsToSmiConstant(v2)) {
-    return false;
-  }
-
-  return true;
+  return is_smi_result;
 }
 
 
 void PhiInstr::InferRange() {
   RangeBoundary new_min;
   RangeBoundary new_max;
 
   for (intptr_t i = 0; i < InputCount(); i++) {
     Range* input_range = InputAt(i)->definition()->range();
     if (input_range == NULL) {
@@ skipping 431 matching lines @@
       return kCosRuntimeEntry;
     default:
       UNREACHABLE();
   }
   return kSinRuntimeEntry;
 }
 
 #undef __
 
 }  // namespace dart