Fuse comparisons that are used by branches together.

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/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
@@ skipping 722 matching lines @@
   ASSERT(stack_trace()->IsUse());
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kReThrowRuntimeEntry);
   __ int3();
 }
 
 
 LocationSummary* BranchInstr::MakeLocationSummary() const {
-  const int kNumInputs = 1;
-  const int kNumTemps = 0;
-  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
-  locs->set_in(0, Location::RequiresRegister());
-  return locs;
+  if (is_fused_with_comparison()) {
+    return LocationSummary::Make(0, Location::NoLocation());
+  } else {
+    const int kNumInputs = 1;
+    const int kNumTemps = 0;
+    LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+    locs->set_in(0, Location::RequiresRegister());
+    return locs;
+  }
 }
 
 
 void BranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Register value = locs()->in(0).reg();
-  __ CompareObject(value,  Bool::ZoneHandle(Bool::True()));
-  if (compiler->IsNextBlock(false_successor())) {
-    // If the next block is the false successor we will fall through to it if
-    // comparison with true fails.
-    __ j(EQUAL, compiler->GetBlockLabel(true_successor()));
-  } else {
-    ASSERT(compiler->IsNextBlock(true_successor()));
-    // If the next block is the true successor we negate comparison and fall
-    // through to it.
-    __ j(NOT_EQUAL, compiler->GetBlockLabel(false_successor()));
+  // If branch was fused with a comparision then no code needs to be emitted.
+  if (!is_fused_with_comparison()) {
+    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 (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()));
+  }
+}
+
 
 LocationSummary* CurrentContextComp::MakeLocationSummary() const {
   return LocationSummary::Make(0, Location::RequiresRegister());
 }
 
 
 void CurrentContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ MoveRegister(locs()->out().reg(), CTX);
 }
 
 
 LocationSummary* StoreContextComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
   summary->set_in(0, Location::RegisterLocation(CTX));
   return summary;
 }
 
 
 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 {
-  return LocationSummary::Make(2, Location::SameAsFirstInput());
+  if (!is_fused_with_branch()) {
+    return LocationSummary::Make(2, Location::SameAsFirstInput());
+  } else {
+    return LocationSummary::Make(2, Location::NoLocation());
+  }
 }
 
 
 void StrictCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
-
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
-  Register result = locs()->out().reg();
 
+  ASSERT(kind() == Token::kEQ_STRICT || kind() == Token::kNE_STRICT);
+  Condition true_condition = (kind() == Token::kEQ_STRICT) ? EQUAL : NOT_EQUAL;
   __ CompareRegisters(left, right);
-  Label load_true, done;
-  if (kind() == Token::kEQ_STRICT) {
-    __ j(EQUAL, &load_true, Assembler::kNearJump);
+
+  if (!is_fused_with_branch()) {
+    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);
   } else {
-    ASSERT(kind() == Token::kNE_STRICT);
-    __ j(NOT_EQUAL, &load_true, Assembler::kNearJump);
+    fused_with_branch()->EmitBranchOnCondition(compiler, true_condition);
   }
-  __ LoadObject(result, bool_false);
-  __ jmp(&done, Assembler::kNearJump);
-  __ Bind(&load_true);
-  __ LoadObject(result, 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 93 matching lines @@
 
 LocationSummary* BooleanNegateComp::MakeLocationSummary() const {
   return LocationSummary::Make(1, Location::RequiresRegister());
 }
 
 
 void BooleanNegateComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label done;
-  __ LoadObject(result, bool_true);
+  __ LoadObject(result, compiler->bool_true());
   __ CompareRegisters(result, value);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
-  __ LoadObject(result, bool_false);
+  __ LoadObject(result, compiler->bool_false());
   __ Bind(&done);
 }
 
 
 LocationSummary* ChainContextComp::MakeLocationSummary() const {
   return LocationSummary::Make(1, Location::NoLocation());
 }
 
 
 void ChainContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 51 matching lines @@
       StubCode::GetAllocationStubForClosure(closure_function));
   const ExternalLabel label(closure_function.ToCString(), stub.EntryPoint());
   compiler->GenerateCall(token_index(), try_index(), &label,
                          PcDescriptors::kOther);
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 #undef __
 
 }  // namespace dart