Cleanup of branch code generation (no change in functionality).

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"
@@ skipping 469 matching lines @@
 void Instruction::RemoveEnvironment() {
   for (Environment::DeepIterator it(env()); !it.Done(); it.Advance()) {
     it.CurrentValue()->RemoveFromUseList();
   }
   env_ = NULL;
 }
 
 
 Instruction* Instruction::RemoveFromGraph(bool return_previous) {
   ASSERT(!IsBlockEntry());
-  ASSERT(!IsControl());
+  ASSERT(!IsBranch());
   ASSERT(!IsThrow());
   ASSERT(!IsReturn());
   ASSERT(!IsReThrow());
   ASSERT(!IsGoto());
   ASSERT(previous() != NULL);
   // We cannot assert that the instruction, if it is a definition, has no
   // uses.  This function is used to remove instructions from the graph and
   // reinsert them elsewhere (e.g., hoisting).
   Instruction* prev_instr = previous();
   Instruction* next_instr = next();
@@ skipping 581 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 ControlInstruction::SuccessorCount() const {
+intptr_t BranchInstr::SuccessorCount() const {
   return 2;
 }
 
 
-BlockEntryInstr* ControlInstruction::SuccessorAt(intptr_t index) const {
+BlockEntryInstr* BranchInstr::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 1365 matching lines @@
 
 
 void IfThenElseInstr::InferRange() {
   const intptr_t min = Utils::Minimum(if_true_, if_false_);
   const intptr_t max = Utils::Maximum(if_true_, if_false_);
   range_ = new Range(RangeBoundary::FromConstant(min),
                      RangeBoundary::FromConstant(max));
 }
 
 
+static bool BindsToSmiConstant(Value* value) {
+  return value->BindsToConstant() && value->BoundConstant().IsSmi();
+}
+
+
+bool IfThenElseInstr::Supports(ComparisonInstr* comparison,
+                               Value* v1,
+                               Value* v2) {
+  if (!(comparison->IsStrictCompare() &&
+        !comparison->AsStrictCompare()->needs_number_check()) &&
+      !(comparison->IsEqualityCompare() &&
+        (comparison->AsEqualityCompare()->operation_cid() == kSmiCid))) {
+    return false;
+  }
+
+  if (!BindsToSmiConstant(v1) || !BindsToSmiConstant(v2)) {
+    return false;
+  }
+
+  return true;
+}
+
+
 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) {
       range_ = Range::Unknown();
       return;
     }
@@ skipping 428 matching lines @@
       return kCosRuntimeEntry;
     default:
       UNREACHABLE();
   }
   return kSinRuntimeEntry;
 }
 
 #undef __
 
 }  // namespace dart