A64: Implement LMathFloorOfDiv and enable the instruction in hydrogen

src/a64/lithium-codegen-a64.cc

 // Copyright 2013 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 3571 matching lines @@
   __ Fccmp(input, input, NoFlag, eq);
   __ B(&done, eq);
 
   __ Bind(&deopt);
   Deoptimize(instr->environment());
 
   __ Bind(&done);
 }
 
 
+void LCodeGen::DoMathFloorOfDiv(LMathFloorOfDiv* instr) {
+  const Register result = ToRegister32(instr->result());
+  const Register left = ToRegister32(instr->left());
+  const Register right = ToRegister32(instr->right());
+  const Register remainder = ToRegister32(instr->temp());

[jbramley, 2014/01/23 14:15:13]

We don't usually declare these as 'const'. If we're going to start doing that,
we should probably make a big change and do them all at once.

+
+  // Check for x / 0.
+  DeoptimizeIfZero(right, instr->environment());
+
+  // Check for (kMinInt / -1).
+  if (instr->hydrogen()->CheckFlag(HValue::kCanOverflow)) {
+    __ Cmp(left, kMinInt);

[jbramley, 2014/01/23 14:15:13]

This will generate two instructions because cmp can't take the immediate
0x8000...00. Instead, use Cmp(left, 1); the V flag will be set if (and only if)
left was kMinInt. In context:

__ Cmp(left, 1);
__ Ccmp(right, -1, ZFlag, vs);
DeoptimizeIf(eq, ...);

+    __ Ccmp(right, -1, ZFlag, eq);
+    DeoptimizeIf(eq, instr->environment());
+  }
+
+  // Check for (0 / -x) that will produce negative zero.
+  if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
+    __ Cmp(right, 0);
+    __ Ccmp(left, 0, ZFlag, mi);
+    // "right" can't be null because the code would have already been
+    // deoptimized. The Z flag is set only if (right < 0) and (left == 0).
+    // In this case we need to deoptimize to produce a -0.
+    DeoptimizeIf(eq, instr->environment());
+  }
+
+  Label done;
+  __ Sdiv(result, left, right);

[jbramley, 2014/01/23 14:15:13]

This can't cause an exception on ARM, so it can go right at the top to
speculatively calculate the result before we've checked for x/0, kMinInt/-1 and
the like.

+  // If both operands have the same sign then we are done.
+  __ Eor(remainder, left, Operand(right));

[jbramley, 2014/01/23 14:15:13]

We have an implicit constructor for Operand (for simple registers and constants)
so you can just write 'right'.

+  __ Tbz(remainder, kWSignBit, &done);
+
+  // Check if the result needs to be corrected.
+  __ Mul(remainder, result, right);
+  __ Sub(remainder, remainder, left);

[jbramley, 2014/01/23 14:15:13]

You can use Msub here instead of Mul and Sub:
__ Msub(remainder, result, right, left);

This produces a result with the opposite sign (left - result * right) but that's
fine for a compare-with-zero.

+  __ Cmp(remainder, 0);

[baptiste.afsa1, 2014/01/23 13:54:19]

You can merge this two instructions into a Cbz.

+  __ B(eq, &done);
+  __ Sub(result, result, Operand(1));

[jbramley, 2014/01/23 14:15:13]

We have an implicit constructor for Operand (for simple registers and constants)
so you can just write '1'.

+
+  __ Bind(&done);
+}
+
+
 void LCodeGen::DoMathLog(LMathLog* instr) {
   ASSERT(ToDoubleRegister(instr->result()).is(d0));
   TranscendentalCacheStub stub(TranscendentalCache::LOG,
                                TranscendentalCacheStub::UNTAGGED);
   CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
   ASSERT(ToDoubleRegister(instr->result()).Is(d0));
 }
 
 
 void LCodeGen::DoMathPowHalf(LMathPowHalf* instr) {
@@ skipping 1577 matching lines @@
   __ Bind(&out_of_object);
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal