Fuse compare with branch at graph building time.

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_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 152 matching lines @@
 void CreateArrayComp::SetInputAt(intptr_t i, Value* value) {
   if (i == 0) {
     inputs_[0] = value;
   } else {
     (*elements_)[i - 1] = value;
   }
 }
 
 
 intptr_t BranchInstr::InputCount() const {
-  return is_fused_with_comparison() ? fused_with_comparison_->InputCount() : 1;
+  return 2;
 }
 
 
 Value* BranchInstr::InputAt(intptr_t i) const {
-  if (is_fused_with_comparison()) {
-    return fused_with_comparison_->InputAt(i);
-  }
-  if (i == 0) return value();
+  if (i == 0) return left();
+  if (i == 1) return right();
   UNREACHABLE();
   return NULL;
 }
 
 
 void BranchInstr::SetInputAt(intptr_t i, Value* value) {
-  ASSERT(!is_fused_with_comparison());
   if (i == 0) {
-    value_ = value;
-    return;
+    left_ = value;
+  } else if (i == 1) {
+    right_ = value;
+  } else {
+    UNREACHABLE();
   }
-  UNREACHABLE();
 }
 
 
 intptr_t ParallelMoveInstr::InputCount() const {
   UNREACHABLE();
   return 0;
 }
 
 
 Value* ParallelMoveInstr::InputAt(intptr_t i) const {
@@ skipping 826 matching lines @@
 
 void GotoInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // We can fall through if the successor is the next block in the list.
   // Otherwise, we need a jump.
   if (!compiler->IsNextBlock(successor())) {
     __ jmp(compiler->GetBlockLabel(successor()));
   }
 }
 
 
-LocationSummary* BranchInstr::MakeLocationSummary() const {
-  if (is_fused_with_comparison()) {
-    return fused_with_comparison_->locs();
-  } else {
-    const int kNumInputs = 1;
-    const int kNumTemps = 0;
-    LocationSummary* locs = new LocationSummary(kNumInputs,
-                                                kNumTemps,
-                                                LocationSummary::kNoCall);
-    locs->set_in(0, Location::RequiresRegister());
-    return locs;
-  }
-}
-
-
-void BranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  if (is_fused_with_comparison()) {
-    fused_with_comparison_->EmitNativeCode(compiler);
-  } else {
-    Register value = locs()->in(0).reg();
-    __ CompareObject(value, compiler->bool_true());
-    EmitBranchOnCondition(compiler, EQUAL);
-  }
-}
-
-
 static Condition NegateCondition(Condition condition) {
   switch (condition) {
     case EQUAL:         return NOT_EQUAL;
     case NOT_EQUAL:     return EQUAL;
     case LESS:          return GREATER_EQUAL;
     case LESS_EQUAL:    return GREATER;
     case GREATER:       return LESS_EQUAL;
     case GREATER_EQUAL: return LESS;
     case BELOW:         return ABOVE_EQUAL;
     case BELOW_EQUAL:   return ABOVE;
     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) {
-  if (is_negated()) {
-    true_condition = NegateCondition(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 19 matching lines @@
 }
 
 
 void StoreContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Nothing to do.  Context register were loaded by register allocator.
   ASSERT(locs()->in(0).reg() == CTX);
 }
 
 
 LocationSummary* StrictCompareComp::MakeLocationSummary() const {
-  if (is_fused_with_branch()) {
-    const intptr_t kNumInputs = 2;
-    const intptr_t kNumTemps = 0;
-    LocationSummary* locs = new LocationSummary(kNumInputs,
-                                                kNumTemps,
-                                                LocationSummary::kNoCall);
-    locs->set_in(0, Location::RequiresRegister());
-    locs->set_in(1, Location::RequiresRegister());
-    return locs;
-  } else {
-    return LocationSummary::Make(2, Location::SameAsFirstInput());
-  }
+  return LocationSummary::Make(2, Location::SameAsFirstInput());
 }
 
 
 void StrictCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
 
   ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
   Condition true_condition = (kind() == Token::kEQ_STRICT) ? EQUAL : NOT_EQUAL;
   __ CompareRegisters(left, right);
 
-  if (is_fused_with_branch()) {
-    fused_with_branch()->EmitBranchOnCondition(compiler, true_condition);
-  } else {
-    Register result = locs()->out().reg();
-    Label load_true, done;
-    __ j(true_condition, &load_true, Assembler::kNearJump);
-    __ LoadObject(result, compiler->bool_false());
-    __ jmp(&done, Assembler::kNearJump);
-    __ Bind(&load_true);
-    __ LoadObject(result, compiler->bool_true());
-    __ Bind(&done);
-  }
+  Register result = locs()->out().reg();
+  Label load_true, done;
+  __ j(true_condition, &load_true, Assembler::kNearJump);
+  __ LoadObject(result, compiler->bool_false());
+  __ jmp(&done, Assembler::kNearJump);
+  __ Bind(&load_true);
+  __ LoadObject(result, compiler->bool_true());
+  __ Bind(&done);
 }
 
 
 void ClosureCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(VerifyCallComputation(this));
   // The arguments to the stub include the closure.  The arguments
   // descriptor describes the closure's arguments (and so does not include
   // the closure).
   Register temp_reg = locs()->temp(0).reg();
   int argument_count = ArgumentCount();
@@ skipping 183 matching lines @@
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_pos(), try_index(), &label,
                          PcDescriptors::kOther);
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 
 #undef __
 
 }  // namespace dart