ARM: Implement DoDivI in the lithium code generator.

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 814 matching lines @@
   // Nothing to do.
 }
 
 
 void LCodeGen::DoModI(LModI* instr) {
   Abort("DoModI unimplemented.");
 }
 
 
 void LCodeGen::DoDivI(LDivI* instr) {
-  Abort("DoDivI unimplemented.");
+  const Register left = ToRegister(instr->left());
+  const Register right = ToRegister(instr->right());
+  const Register scratch = scratch0();
+  const Register result = ToRegister(instr->result());
+
+  // Check for x / 0.
+  if (instr->hydrogen()->CheckFlag(HValue::kCanBeDivByZero)) {
+    __ tst(right, right);
+    DeoptimizeIf(eq, instr->environment());
+  }
+
+  // Check for (0 / -x) that will produce negative zero.
+  if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
+    Label left_not_zero;
+    __ tst(left, Operand(left));
+    __ b(ne, &left_not_zero);
+    __ tst(right, Operand(right));
+    DeoptimizeIf(mi, instr->environment());
+    __ bind(&left_not_zero);
+  }
+
+  // Check for (-kMinInt / -1).
+  if (instr->hydrogen()->CheckFlag(HValue::kCanOverflow)) {
+    Label left_not_min_int;
+    __ cmp(left, Operand(kMinInt));
+    __ b(ne, &left_not_min_int);
+    __ cmp(right, Operand(-1));
+    DeoptimizeIf(eq, instr->environment());
+    __ bind(&left_not_min_int);
+  }
+
+  Label done, deoptimize;
+  // Test for a few common cases first.
+  __ cmp(right, Operand(1));
+  __ mov(result, left, LeaveCC, eq);
+  __ b(eq, &done);
+
+  __ cmp(right, Operand(2));
+  __ tst(left, Operand(1), eq);
+  __ mov(result, Operand(left, ASR, 1), LeaveCC, eq);
+  __ b(eq, &done);
+
+  __ cmp(right, Operand(4));
+  __ tst(left, Operand(3), eq);
+  __ mov(result, Operand(left, ASR, 2), LeaveCC, eq);
+  __ b(eq, &done);
+
+  // Call the generic stub. The numbers in r0 and r1 have
+  // to be tagged to Smis. If that is not possible, deoptimize.
+  const int32_t kTwoHighestBits = 3<<30;

[Søren Thygesen Gjesse, 2011/01/13 08:28:38]

In other parts of the code we write this as 0xc0000000 without using a constant.

[Karl Klose, 2011/01/13 13:52:31]

I have created a TrySmiTag instruction in the macro assembler to abstract over
this code.

+  __ and_(scratch, left, Operand(kTwoHighestBits));

[Søren Thygesen Gjesse, 2011/01/13 08:28:38]

You can use SetCC on the and instruction to set the Z flag if scratch is zero.
Then you only need one cmp for the 0xc0000000 case. You could also take a look
at Smi::IsValid in objects-inl.h. There 0x4000000 is added and the result is
checked against 0x80000000 (unsigned). Maybe add a SmiTag  instruction variant
to the macro assembler which jumps to a label if the value does not fit in a
smi.

[Karl Klose, 2011/01/13 13:52:31]

s.a.

+  __ cmp(scratch, Operand(1 << 31));
+  __ cmp(scratch, Operand(1 << 30), ne);
+  __ b(eq, &deoptimize);

[Søren Thygesen Gjesse, 2011/01/13 08:28:38]

There is a SmiTag instruction in the macro assembler.

[Karl Klose, 2011/01/13 13:52:31]

s.a.

+  __ mov(left, Operand(left, LSL, 1));
+
+  __ and_(scratch, right, Operand(kTwoHighestBits));
+  __ cmp(scratch, Operand(1 << 31));
+  __ cmp(scratch, Operand(1 << 30), ne);
+  __ b(eq, &deoptimize);
+  __ mov(right, Operand(right, LSL, 1));
+
+  GenericBinaryOpStub stub(Token::DIV, OVERWRITE_LEFT, left, right);

[Søren Thygesen Gjesse, 2011/01/13 08:28:38]

The LDivI instruction is not marked as call which means that it will not spill
registers to the stack. Therefore it is not safe to call a stub. It needs to be
called from deferred code and marked with "RecordSafepointWithRegisters". As the
GenericBinaryOpStub might touch floating point registers as well we need to have
a safepoint with both registers and doubles.

[Karl Klose, 2011/01/13 13:52:31]

Done.

+  __ CallStub(&stub);
+
+  // If the result in r0 is a Smi, untag it, else deoptimize.
+  __ BranchOnNotSmi(result, &deoptimize);
+  __ mov(result, Operand(result, ASR, 1));
+  __ b(&done);
+
+  __ bind(&deoptimize);
+  DeoptimizeIf(al, instr->environment());
+  __ bind(&done);
+
 }
 
 
 void LCodeGen::DoMulI(LMulI* instr) {
   Register scratch = scratch0();
   Register left = ToRegister(instr->left());
   Register right = EmitLoadRegister(instr->right(), scratch);
 
   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero) &&
       !instr->right()->IsConstantOperand()) {
@@ skipping 1984 matching lines @@
 
 
 void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
   Abort("DoOsrEntry unimplemented.");
 }
 
 
 #undef __
 
 } }  // namespace v8::internal