Separate branch on strict compare into a new IL instruction.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 539 matching lines @@
                                parent, assigned_vars,
                                variable_count, fixed_parameter_count);
   }
 
   // 6. Assign postorder number and add the block entry to the list.
   set_postorder_number(postorder->length());
   postorder->Add(this);
 }
 
 
-void BranchInstr::DiscoverBlocks(
+void ControlInstruction::DiscoverBlocks(
     BlockEntryInstr* current_block,
     GrowableArray<BlockEntryInstr*>* preorder,
     GrowableArray<BlockEntryInstr*>* postorder,
     GrowableArray<intptr_t>* parent,
     GrowableArray<BitVector*>* assigned_vars,
     intptr_t variable_count,
     intptr_t fixed_parameter_count) {
   current_block->set_last_instruction(this);
   // Visit the false successor before the true successor so they appear in
   // true/false order in reverse postorder used as the block ordering in the
@@ skipping 59 matching lines @@
   return 1 + catch_entries_.length();
 }
 
 
 BlockEntryInstr* GraphEntryInstr::SuccessorAt(intptr_t index) const {
   if (index == 0) return normal_entry_;
   return catch_entries_[index - 1];
 }
 
 
-intptr_t BranchInstr::SuccessorCount() const {
+intptr_t ControlInstruction::SuccessorCount() const {
   return 2;
 }
 
 
-BlockEntryInstr* BranchInstr::SuccessorAt(intptr_t index) const {
+BlockEntryInstr* ControlInstruction::SuccessorAt(intptr_t index) const {
   if (index == 0) return true_successor_;
   if (index == 1) return false_successor_;
   UNREACHABLE();
   return NULL;
 }
 
 
 intptr_t GotoInstr::SuccessorCount() const {
   return 1;
 }
@@ skipping 563 matching lines @@
     case ABOVE:         return BELOW_EQUAL;
     case ABOVE_EQUAL:   return BELOW;
     default:
       OS::Print("Error %d\n", condition);
       UNIMPLEMENTED();
       return EQUAL;
   }
 }
 
 
-void BranchInstr::EmitBranchOnCondition(FlowGraphCompiler* compiler,
-                                        Condition true_condition) {
+void ControlInstruction::EmitBranchOnCondition(FlowGraphCompiler* compiler,
+                                               Condition true_condition) {
   if (compiler->IsNextBlock(false_successor())) {
     // If the next block is the false successor we will fall through to it.
     __ j(true_condition, compiler->GetBlockLabel(true_successor()));
   } else {
     // If the next block is the true successor we negate comparison and fall
     // through to it.
     ASSERT(compiler->IsNextBlock(true_successor()));
     Condition false_condition = NegateCondition(true_condition);
     __ j(false_condition, compiler->GetBlockLabel(false_successor()));
   }
@@ skipping 293 matching lines @@
                      ? UseDefinition(values()[i]->AsUse()->definition())
                      : val);
   }
   return copy;
 }
 
 
 #undef __
 
 }  // namespace dart