Fuse comparisons that are used by branches together.

runtime/vm/intermediate_language_ia32.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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 13 matching lines @@
 // on the stack and return the result in a fixed register EAX.
 LocationSummary* Computation::MakeCallSummary() {
   LocationSummary* result = new LocationSummary(0, 0);
   result->set_out(Location::RegisterLocation(EAX));
   return result;
 }
 
 
 void BindInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   computation()->EmitNativeCode(compiler);
-  __ pushl(locs()->out().reg());
+  if (locs()->out().kind() == Location::kRegister) {
+    // TODO(vegorov): this should really happen only for comparisons fused
+    // with branches.  Currrently IR does not provide an easy way to remove
+    // instructions from the graph so we just leave fused comparison in it
+    // but change its result location to be NoLocation.
+    __ pushl(locs()->out().reg());
+  }
 }
 
 
 LocationSummary* ReturnInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
   locs->set_in(0, Location::RegisterLocation(EAX));
   locs->set_temp(0, Location::RequiresRegister());
   return locs;
@@ skipping 111 matching lines @@
 }
 
 
 void AssertBooleanComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register obj = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   // Check that the type of the value is allowed in conditional context.
   // Call the runtime if the object is not bool::true or bool::false.
   Label done;
-  __ CompareObject(obj, Bool::ZoneHandle(Bool::True()));
+  __ CompareObject(obj, compiler->true_value());
   __ j(EQUAL, &done, Assembler::kNearJump);
-  __ CompareObject(obj, Bool::ZoneHandle(Bool::False()));
+  __ CompareObject(obj, compiler->false_value());
   __ j(EQUAL, &done, Assembler::kNearJump);
 
   __ pushl(Immediate(Smi::RawValue(token_index())));  // Source location.
   __ pushl(obj);  // Push the source object.
   compiler->GenerateCallRuntime(cid(),
                                 token_index(),
                                 try_index(),
                                 kConditionTypeErrorRuntimeEntry);
   // We should never return here.
   __ int3();
 
   __ Bind(&done);
   ASSERT(obj == result);
 }
 
 
 LocationSummary* EqualityCompareComp::MakeLocationSummary() const {
   LocationSummary* locs = new LocationSummary(2, 0);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_in(1, Location::RequiresRegister());
-  locs->set_out(Location::RegisterLocation(EAX));
+  if (fused_with_branch() == NULL) {
+    locs->set_out(Location::RegisterLocation(EAX));
+  }
   return locs;
 }
 
 
 void EqualityCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
-  Register result = locs()->out().reg();
-  ASSERT(locs()->out().reg() == EAX);
 
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  Label done, load_true, non_null_compare;
+  Label done, non_null_compare;
   __ cmpl(left, raw_null);
   __ j(NOT_EQUAL, &non_null_compare, Assembler::kNearJump);
   // Comparison with NULL is "===".
   __ cmpl(left, right);
-  __ j(EQUAL, &load_true, Assembler::kNearJump);
-  __ LoadObject(result, bool_false);
-  __ jmp(&done, Assembler::kNearJump);
-  __ Bind(&load_true);
-  __ LoadObject(result, bool_true);
+  if (fused_with_branch() == NULL) {
+    Register result = locs()->out().reg();
+    Label load_true;
+    __ j(EQUAL, &load_true, Assembler::kNearJump);
+    __ LoadObject(result, compiler->false_value());
+    __ jmp(&done, Assembler::kNearJump);
+    __ Bind(&load_true);
+    __ LoadObject(result, compiler->true_value());
+  } else {
+    fused_with_branch()->EmitBranchOnCondition(compiler, EQUAL);
+  }
   __ jmp(&done);
 
   __ Bind(&non_null_compare);
   __ pushl(left);
   __ pushl(right);
   const String& operator_name = String::ZoneHandle(String::NewSymbol("=="));
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 1;
 
   compiler->GenerateInstanceCall(cid(),
                                  token_index(),
                                  try_index(),
                                  operator_name,
                                  kNumberOfArguments,
                                  kNoArgumentNames,
                                  kNumArgumentsChecked);
+  ASSERT(fused_with_branch() != NULL || locs()->out().reg() == EAX);
+
+  if (fused_with_branch() != NULL) {
+    __ CompareObject(EAX, compiler->true_value());
+    fused_with_branch()->EmitBranchOnCondition(compiler, EQUAL);
+  }
+
   __ Bind(&done);
 }
 
 
 LocationSummary* RelationalOpComp::MakeLocationSummary() const {
   if ((operands_class_id() == kSmi) || (operands_class_id() == kDouble)) {
     const intptr_t kNumInputs = 2;
     const intptr_t kNumTemps = 1;
     LocationSummary* summary = new LocationSummary(kNumInputs, kNumTemps);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
-    summary->set_out(Location::RequiresRegister());
+    if (fused_with_branch() == NULL) {
+      summary->set_out(Location::RequiresRegister());
+    }
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
   ASSERT(operands_class_id() == kObject);
   return MakeCallSummary();
 }
 
 
 static Condition TokenKindToSmiCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
     case Token::kNE: return NOT_EQUAL;
     case Token::kLT: return LESS;
     case Token::kGT: return GREATER;
     case Token::kLTE: return LESS_EQUAL;
     case Token::kGTE: return  GREATER_EQUAL;
     default:
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 static void EmitSmiRelationalOp(FlowGraphCompiler* compiler,
                                 RelationalOpComp* comp) {
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
-  Register result = comp->locs()->out().reg();
   Register temp = comp->locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(comp->cid(),
                                         comp->token_index(),
                                         comp->try_index(),
                                         kDeoptSmiCompareSmis,
                                         left,
                                         right);
   __ movl(temp, left);
   __ orl(temp, right);
   __ testl(temp, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
-  Condition condition = TokenKindToSmiCondition(comp->kind());
 
-  Label done, is_true;
+  Condition true_condition = TokenKindToSmiCondition(comp->kind());
   __ cmpl(left, right);
-  __ j(condition, &is_true);
-  __ LoadObject(result, bool_false);
-  __ jmp(&done);
-  __ Bind(&is_true);
-  __ LoadObject(result, bool_true);
-  __ Bind(&done);
+
+  if (comp->fused_with_branch() == NULL) {
+    Register result = comp->locs()->out().reg();
+    Label done, is_true;
+
+    __ j(true_condition, &is_true);
+    __ LoadObject(result, compiler->false_value());
+    __ jmp(&done);
+    __ Bind(&is_true);
+    __ LoadObject(result, compiler->true_value());
+    __ Bind(&done);
+  } else {
+    comp->fused_with_branch()->EmitBranchOnCondition(compiler, true_condition);
+  }
 }
 
 
 static Condition TokenKindToDoubleCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
     case Token::kLT: return BELOW;
     case Token::kGT: return ABOVE;
     case Token::kLTE: return BELOW_EQUAL;
     case Token::kGTE: return ABOVE_EQUAL;
     default:
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 static void EmitDoubleRelationalOp(FlowGraphCompiler* compiler,
                                    RelationalOpComp* comp) {
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
-  Register result = comp->locs()->out().reg();
   // TODO(srdjan): temp is only needed if a conversion Smi->Double occurs.
   Register temp = comp->locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(comp->cid(),
                                         comp->token_index(),
                                         comp->try_index(),
                                         kDeoptDoubleComparison,
                                         left,
                                         right);
   compiler->LoadDoubleOrSmiToXmm(XMM0, left, temp, deopt);
   compiler->LoadDoubleOrSmiToXmm(XMM1, right, temp, deopt);
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
+
   Condition true_condition = TokenKindToDoubleCondition(comp->kind());
-  Label is_false, is_true, done;
   __ comisd(XMM0, XMM1);
-  __ j(PARITY_EVEN, &is_false, Assembler::kNearJump);  // NaN -> false;
-  __ j(true_condition, &is_true, Assembler::kNearJump);
-  __ Bind(&is_false);
-  __ LoadObject(result, bool_false);
-  __ jmp(&done);
-  __ Bind(&is_true);
-  __ LoadObject(result, bool_true);
-  __ Bind(&done);
+
+  if (comp->fused_with_branch() == NULL) {
+    Register result = comp->locs()->out().reg();
+    Label is_false, is_true, done;
+    __ j(PARITY_EVEN, &is_false, Assembler::kNearJump);  // NaN -> false;
+    __ j(true_condition, &is_true, Assembler::kNearJump);
+    __ Bind(&is_false);
+    __ LoadObject(result, compiler->false_value());
+    __ jmp(&done);
+    __ Bind(&is_true);
+    __ LoadObject(result, compiler->true_value());
+    __ Bind(&done);
+  } else {
+    BranchInstr* branch = comp->fused_with_branch();
+    __ j(PARITY_EVEN, compiler->GetBlockLabel(branch->false_successor()));
+    branch->EmitBranchOnCondition(compiler, true_condition);
+  }
 }
 
 
 
 void RelationalOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (operands_class_id() == kSmi) {
     EmitSmiRelationalOp(compiler, this);
     return;
   }
   if (operands_class_id() == kDouble) {
@@ skipping 1070 matching lines @@
     __ DoubleNegate(XMM0);
     __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
   } else {
     UNREACHABLE();
   }
 }
 
 
 LocationSummary* ToDoubleComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
-  const intptr_t kNumTemps = 1;
   if (from() == kDouble) {
+    const intptr_t kNumTemps = 1;
     LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
     locs->set_in(0, Location::RequiresRegister());
+    locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::SameAsFirstInput());
     return locs;
   } else {
     ASSERT(from() == kSmi);
     return LocationSummary::Make(kNumInputs, Location::RegisterLocation(EAX));
   }
 }
 
 
 void ToDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 45 matching lines @@
   __ cvtsi2sd(XMM0, value);
   __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64