Generalize if-conversion to arbitrary smi comparisons.

runtime/vm/flow_graph_builder.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_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 415 matching lines @@
                              call_block->try_index());
     false_block->InheritDeoptTargetAfter(call_);
     false_block->LinkTo(call_->next());
     call_block->ReplaceAsPredecessorWith(false_block);
 
     ConstantInstr* true_const = caller_graph_->GetConstant(Bool::True());
     BranchInstr* branch =
         new BranchInstr(new StrictCompareInstr(call_block->start_pos(),
                                                Token::kEQ_STRICT,
                                                new Value(true_const),
-                                               new Value(true_const)));
+                                               new Value(true_const),
+                                               false));  // No number check.
     branch->InheritDeoptTarget(call_);
     *branch->true_successor_address() = callee_entry;
     *branch->false_successor_address() = false_block;
 
     call_->previous()->AppendInstruction(branch);
     call_block->set_last_instruction(branch);
 
     // Update dominator tree.
     call_block->AddDominatedBlock(callee_entry);
     call_block->AddDominatedBlock(false_block);
@@ skipping 379 matching lines @@
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
     value = Bind(new AssertBooleanInstr(condition_token_pos(), value));
   }
   Value* constant_true = Bind(new ConstantInstr(Bool::True()));
   StrictCompareInstr* comp =
       new StrictCompareInstr(condition_token_pos(),
                              Token::kEQ_STRICT,
                              value,
-                             constant_true);
-  comp->set_needs_number_check(false);
+                             constant_true,
+                             false);  // No number check.
   BranchInstr* branch = new BranchInstr(comp);
   AddInstruction(branch);
   CloseFragment();
 
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::MergeBranchWithComparison(ComparisonInstr* comp) {
   BranchInstr* branch;
   if (Token::IsStrictEqualityOperator(comp->kind())) {
     ASSERT(comp->IsStrictCompare());
     branch = new BranchInstr(comp);
   } else if (Token::IsEqualityOperator(comp->kind()) &&
              (comp->left()->BindsToConstantNull() ||
               comp->right()->BindsToConstantNull())) {
     branch = new BranchInstr(new StrictCompareInstr(
         comp->token_pos(),
         (comp->kind() == Token::kEQ) ? Token::kEQ_STRICT : Token::kNE_STRICT,
         comp->left(),
-        comp->right()));
+        comp->right(),
+        false));  // No number check.
   } else {
     branch = new BranchInstr(comp, FLAG_enable_type_checks);
   }
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::MergeBranchWithNegate(BooleanNegateInstr* neg) {
   ASSERT(!FLAG_enable_type_checks);
   Value* constant_true = Bind(new ConstantInstr(Bool::True()));
   StrictCompareInstr* comp =
       new StrictCompareInstr(condition_token_pos(),
                              Token::kNE_STRICT,
                              neg->value(),
-                             constant_true);
-  comp->set_needs_number_check(false);
+                             constant_true,
+                             false);  // No number check.
   BranchInstr* branch = new BranchInstr(comp);
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::ReturnDefinition(Definition* definition) {
   ComparisonInstr* comp = definition->AsComparison();
@@ skipping 305 matching lines @@
     if (FLAG_enable_type_checks) {
       right_value =
           for_right.Bind(new AssertBooleanInstr(node->right()->token_pos(),
                                                 right_value));
     }
     Value* constant_true = for_right.Bind(new ConstantInstr(Bool::True()));
     Value* compare =
         for_right.Bind(new StrictCompareInstr(node->token_pos(),
                                               Token::kEQ_STRICT,
                                               right_value,
-                                              constant_true));
+                                              constant_true,
+                                              false));  // No number check.
     for_right.Do(BuildStoreExprTemp(compare));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner());
       Value* constant_false = for_false.Bind(new ConstantInstr(Bool::False()));
       for_false.Do(BuildStoreExprTemp(constant_false));
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
       ValueGraphVisitor for_true(owner());
@@ skipping 314 matching lines @@
                                                            intptr_t token_pos) {
   ValueGraphVisitor for_left_value(owner());
   left->Visit(&for_left_value);
   Append(for_left_value);
   ValueGraphVisitor for_right_value(owner());
   right->Visit(&for_right_value);
   Append(for_right_value);
   StrictCompareInstr* comp = new StrictCompareInstr(token_pos,
                                                     kind,
                                                     for_left_value.value(),
-                                                    for_right_value.value());
+                                                    for_right_value.value(),
+                                                    true);  // Number check.
   return comp;
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 // TODO(srdjan): Implement new equality.
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsTypeTestOperator(node->kind())) {
@@ skipping 1533 matching lines @@
   const Function& function = owner()->parsed_function()->function();
   if (!function.IsClosureFunction()) {
     MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(function);
     switch (kind) {
       case MethodRecognizer::kObjectEquals: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         LocalVariable* other_var =
             node->scope()->LookupVariable(Symbols::Other(),
                                           true);  // Test only.
         Value* other = Bind(new LoadLocalInstr(*other_var));
+        // Receiver is not a number because numbers override equality.
+        const bool kNoNumberCheck = false;
         StrictCompareInstr* compare =
             new StrictCompareInstr(node->token_pos(),
                                    Token::kEQ_STRICT,
                                    receiver,
-                                   other);
-        // Receiver is not a number because numbers override equality.
-        compare->set_needs_number_check(false);
+                                   other,
+                                   kNoNumberCheck);
         return ReturnDefinition(compare);
       }
       case MethodRecognizer::kStringBaseLength:
       case MethodRecognizer::kStringBaseIsEmpty: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         // Treat length loads as mutable (i.e. affected by side effects) to
         // avoid hoisting them since we can't hoist the preceding class-check.
         // This is because of externalization of strings that affects their
         // class-id.
         const bool is_immutable = false;
         LoadFieldInstr* load = new LoadFieldInstr(
             receiver,
             String::length_offset(),
             Type::ZoneHandle(Type::SmiType()),
             is_immutable);
         load->set_result_cid(kSmiCid);
         load->set_recognized_kind(MethodRecognizer::kStringBaseLength);
         if (kind == MethodRecognizer::kStringBaseLength) {
           return ReturnDefinition(load);
         }
         ASSERT(kind == MethodRecognizer::kStringBaseIsEmpty);
         Value* zero_val = Bind(new ConstantInstr(Smi::ZoneHandle(Smi::New(0))));
         Value* load_val = Bind(load);
         StrictCompareInstr* compare =
             new StrictCompareInstr(node->token_pos(),
                                    Token::kEQ_STRICT,
                                    load_val,
-                                   zero_val);
+                                   zero_val,
+                                   false);  // No number check.
         return ReturnDefinition(compare);
       }
       case MethodRecognizer::kGrowableArrayLength:
       case MethodRecognizer::kObjectArrayLength:
       case MethodRecognizer::kImmutableArrayLength:
       case MethodRecognizer::kTypedDataLength: {
         Value* receiver = Bind(BuildLoadThisVar(node->scope()));
         const bool is_immutable =
             (kind != MethodRecognizer::kGrowableArrayLength);
         LoadFieldInstr* load = new LoadFieldInstr(
@@ skipping 896 matching lines @@
                                   LanguageError::kError,
                                   Heap::kNew,
                                   "FlowGraphBuilder Bailout: %s %s",
                                   String::Handle(function.name()).ToCString(),
                                   reason));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart