Relational comparisons for unboxed mints.

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 627 matching lines @@
     __ LoadObject(result, compiler->bool_true());
     __ Bind(&done);
   }
 }
 
 
 static Condition TokenKindToMintCondition(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:
-      UNIMPLEMENTED();
+      UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 static void EmitUnboxedMintEqualityOp(FlowGraphCompiler* compiler,
                                       const LocationSummary& locs,
                                       Token::Kind kind,
                                       BranchInstr* branch) {
   ASSERT(Token::IsEqualityOperator(kind));
@@ skipping 15 matching lines @@
     __ j(true_condition, &is_true);
     __ LoadObject(result, compiler->bool_false());
     __ jmp(&done);
     __ Bind(&is_true);
     __ LoadObject(result, compiler->bool_true());
     __ Bind(&done);
   }
 }
 
 
+static void EmitUnboxedMintComparisonOp(FlowGraphCompiler* compiler,
+                                        const LocationSummary& locs,
+                                        Token::Kind kind,
+                                        BranchInstr* branch) {

[srdjan, 2012/10/29 19:30:25]

Isn't it slower to unbox Mint's for comparison, vs using 4 CPU registers to
compare, especially if we must unbox Mint and Smi when comparing? Please measure
vs current solution where we call out to method with intrinsified prolog.

[Florian Schneider, 2012/10/30 12:09:04]

Yes, in the worst cast where we have two boxed mints the inlined mint code is
~2x faster. I measured the following function executed in a loop 10^8 times:

foo(a, b) => a > b;

Current VM:

real	0m3.938s
user	0m3.920s
sys	0m0.000s

With my change:

real	0m1.829s
user	0m1.810s
sys	0m0.010s

+  XmmRegister left = locs.in(0).xmm_reg();
+  XmmRegister right = locs.in(1).xmm_reg();
+  Register left_tmp = locs.temp(0).reg();
+  Register right_tmp = locs.temp(1).reg();
+  Register result = branch == NULL ? locs.out().reg() : kNoRegister;
+
+  Condition hi_cond = OVERFLOW, lo_cond = OVERFLOW;
+  switch (kind) {
+    case Token::kLT:
+      hi_cond = LESS;
+      lo_cond = BELOW;
+      break;
+    case Token::kGT:
+      hi_cond = GREATER;
+      lo_cond = ABOVE;
+      break;
+    case Token::kLTE:
+      hi_cond = LESS;
+      lo_cond = BELOW_EQUAL;
+      break;
+    case Token::kGTE:
+      hi_cond = GREATER;
+      lo_cond = ABOVE_EQUAL;
+      break;
+    default:
+      break;
+  }
+  ASSERT(hi_cond != OVERFLOW && lo_cond != OVERFLOW);
+  Label is_true, is_false;
+  // Compare upper halves first.
+  __ pextrd(left_tmp, left, Immediate(1));
+  __ pextrd(right_tmp, right, Immediate(1));
+  __ cmpl(left_tmp, right_tmp);
+  if (branch != NULL) {
+    __ j(hi_cond, compiler->GetBlockLabel(branch->true_successor()));
+    __ j(FlowGraphCompiler::FlipCondition(hi_cond),
+         compiler->GetBlockLabel(branch->false_successor()));
+  } else {
+    __ j(hi_cond, &is_true);
+    __ j(FlowGraphCompiler::FlipCondition(hi_cond), &is_false);
+  }
+
+  // If upper is equal, compare lower half.
+  __ pextrd(left_tmp, left, Immediate(0));
+  __ pextrd(right_tmp, right, Immediate(0));
+  __ cmpl(left_tmp, right_tmp);
+  if (branch != NULL) {
+    branch->EmitBranchOnCondition(compiler, lo_cond);
+  } else {
+    Label done;
+    __ j(lo_cond, &is_true);
+    __ Bind(&is_false);
+    __ LoadObject(result, compiler->bool_false());
+    __ jmp(&done);
+    __ Bind(&is_true);
+    __ LoadObject(result, compiler->bool_true());
+    __ Bind(&done);
+  }
+}
+
+
 static Condition TokenKindToDoubleCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
     case Token::kNE: return NOT_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();
@@ skipping 99 matching lines @@
   }
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
   __ CompareObject(EAX, compiler->bool_true());
   branch->EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
+  if (operands_class_id() == kMintCid) {
+    const intptr_t kNumTemps = 2;
+    LocationSummary* locs =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+    locs->set_in(0, Location::RequiresXmmRegister());
+    locs->set_in(1, Location::RequiresXmmRegister());
+    locs->set_temp(0, Location::RequiresRegister());
+    locs->set_temp(1, Location::RequiresRegister());
+    locs->set_out(Location::RequiresRegister());
+    return locs;
+  }
   if (operands_class_id() == kDoubleCid) {
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresXmmRegister());
     summary->set_in(1, Location::RequiresXmmRegister());
     summary->set_out(Location::RequiresRegister());
     return summary;
   } else if (operands_class_id() == kSmiCid) {
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 10 matching lines @@
   locs->set_out(Location::RegisterLocation(EAX));
   return locs;
 }
 
 
 void RelationalOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (operands_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), NULL);
     return;
   }
+  if (operands_class_id() == kMintCid) {
+    EmitUnboxedMintComparisonOp(compiler, *locs(), kind(), NULL);
+    return;
+  }
   if (operands_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL);
     return;
   }
 
   // Push arguments for the call.
   // TODO(fschneider): Split this instruction into different types to avoid
   // explicitly pushing arguments to the call here.
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
@@ skipping 39 matching lines @@
                                  locs());
 }
 
 
 void RelationalOpInstr::EmitBranchCode(FlowGraphCompiler* compiler,
                                        BranchInstr* branch) {
   if (operands_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
+  if (operands_class_id() == kMintCid) {
+    EmitUnboxedMintComparisonOp(compiler, *locs(), kind(), branch);
+    return;
+  }
   if (operands_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   EmitNativeCode(compiler);
   __ CompareObject(EAX, compiler->bool_true());
   branch->EmitBranchOnCondition(compiler, EQUAL);
 }
 
 
@@ skipping 1534 matching lines @@
     case Token::kBIT_AND: __ andpd(left, right); break;
     case Token::kBIT_OR:  __ orpd(left, right); break;
     case Token::kBIT_XOR: __ xorpd(left, right); break;
     case Token::kADD:
     case Token::kSUB: {
       Register lo = locs()->temp(0).reg();
       Register hi = locs()->temp(1).reg();
       Label* deopt  = compiler->AddDeoptStub(deopt_id(),
                                              kDeoptBinaryMintOp);
       Label done, overflow;
-      __ pextrd(lo, right, Immediate(0));  // Lower half left
-      __ pextrd(hi, right, Immediate(1));  // Upper half left
+      __ pextrd(lo, right, Immediate(0));  // Lower half
+      __ pextrd(hi, right, Immediate(1));  // Upper half
       __ subl(ESP, Immediate(2 * kWordSize));
       __ movq(Address(ESP, 0), left);
       if (op_kind() == Token::kADD) {
         __ addl(Address(ESP, 0), lo);
         __ adcl(Address(ESP, 1 * kWordSize), hi);
       } else {
         __ subl(Address(ESP, 0), lo);
         __ sbbl(Address(ESP, 1 * kWordSize), hi);
       }
       __ j(OVERFLOW, &overflow);
@@ skipping 99 matching lines @@
   __ pcmpeqq(XMM0, XMM0);  // Generate all 1's.
   __ pxor(value, XMM0);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64