ARM: Implement fast code for ModI.

src/arm/lithium-codegen-arm.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1020 matching lines @@
   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
     Label ok;
     __ tst(left, Operand(left));
     __ b(ne, &ok);
     __ tst(right, Operand(right));
     __ b(pl, &ok);
     __ b(al, &deoptimize);
     __ bind(&ok);
   }
 
+  // Try a few common cases before using the generic stub.

[Søren Thygesen Gjesse, 2011/01/18 15:58:38]

Maybe extend this comment a bit (it took me some time to find out that you where
subtracting left 0 - 2 times from right).

[Karl Klose, 2011/01/20 02:12:12]

Done.

+  const int kUnfolds = 3;
+  __ mov(scratch, left);
+  for (int i = 0; i < kUnfolds; i++) {
+    // Check if the left hand side is less or equal.
+    if (i == 0) __ cmp(scratch, right);
+    __ mov(result, scratch, LeaveCC, le);
+    __ b(le, &done);
+    if (i < kUnfolds - 1) __ sub(scratch, left, right);

[Søren Thygesen Gjesse, 2011/01/18 15:58:38]

Shouldn't this be

__ sub(scratch, scratch, right, SetCC)

? Or maybe not, but when le is set will scratch not be negative (for positive
left/right)?

[Karl Klose, 2011/01/20 02:12:12]

Thanks for the catch.
On 2011/01/18 15:58:38, Søren Gjesse wrote:

+  }
+
+  // Check for power of two on the right hand side.

[Søren Thygesen Gjesse, 2011/01/18 15:58:38]

I think the code we have in GenericBinaryOpStub does this in fewer instructions.
It works on smis but should work for int32 as well.

  // Check for two positive smis.
  __ orr(smi_test_reg, lhs, Operand(rhs));
  __ tst(smi_test_reg, Operand(0x80000000u | kSmiTagMask));
  __ b(ne, &slow);
  // Check that rhs is a power of two and not zero.
  Register mask_bits = r3;
  __ sub(scratch, rhs, Operand(1), SetCC);
  __ b(mi, &slow);
  __ and_(mask_bits, rhs, Operand(scratch), SetCC);
  __ b(ne, &not_power_of_2);
  // Calculate power of two modulus.
  __ and_(result, lhs, Operand(scratch));

[Karl Klose, 2011/01/20 02:12:12]

Done.

+  const int kMaxPowerOfTwo = 32;
+  for (int i = 2; i <= kMaxPowerOfTwo; i <<= 1) {
+    __ cmp(right, Operand(i));
+    __ and_(result, left, Operand(i-1), LeaveCC, eq);
+    __ b(&done, eq);
+  }
+
   // Call the generic stub. The numbers in r0 and r1 have
   // to be tagged to Smis. If that is not possible, deoptimize.
   DeferredModI* deferred = new DeferredModI(this, instr);
   __ TrySmiTag(left, &deoptimize, scratch);
   __ TrySmiTag(right, &deoptimize, scratch);
 
   __ b(al, deferred->entry());
   __ bind(deferred->exit());
 
   // If the result in r0 is a Smi, untag it, else deoptimize.
   __ BranchOnNotSmi(result, &deoptimize);
-  __ mov(result, Operand(result, ASR, 1));
+  __ SmiUntag(result);
 
   __ b(al, &done);
   __ bind(&deoptimize);
   DeoptimizeIf(al, instr->environment());
   __ bind(&done);
 }
 
 
 void LCodeGen::DoDivI(LDivI* instr) {
   class DeferredDivI: public LDeferredCode {
@@ skipping 2139 matching lines @@
 
 
 void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
   Abort("DoOsrEntry unimplemented.");
 }
 
 
 #undef __
 
 } }  // namespace v8::internal