Move ToI conversions to the MacroAssembler

src/ia32/macro-assembler-ia32.cc

Index: src/ia32/macro-assembler-ia32.cc
diff --git a/src/ia32/macro-assembler-ia32.cc b/src/ia32/macro-assembler-ia32.cc
index 8b1be3cf17262f7c7c5d9de2d8a755af7982b937..5efef38b96df94513c8eb16d6d881db30cb20c06 100644
--- a/src/ia32/macro-assembler-ia32.cc
+++ b/src/ia32/macro-assembler-ia32.cc
@@ -161,6 +161,191 @@ void MacroAssembler::ClampUint8(Register reg) {
 }
 
 
+void MacroAssembler::SlowTruncateToI(Register input_reg, Register result_reg,
+    int index) {
+  DoubleToIStub stub(input_reg, result_reg, index, true);
+  call(stub.GetCode(isolate()), RelocInfo::CODE_TARGET);
+}
+
+
+void MacroAssembler::TruncateDoubleToI(
+    XMMRegister input_reg, Register result_reg) {
+  Label done;
+  cvttsd2si(result_reg, Operand(input_reg));
+  cmp(result_reg, 0x80000000u);
+  j(not_equal, &done, Label::kNear);
+
+  sub(esp, Immediate(kDoubleSize));
+  movdbl(MemOperand(esp, 0), input_reg);
+  SlowTruncateToI(esp, result_reg, 0);
+  add(esp, Immediate(kDoubleSize));
+  bind(&done);
+}
+
+
+void MacroAssembler::DoubleToI(XMMRegister input_reg, Register result_reg,
+      XMMRegister scratch, bool bailout_on_minus_zero,
+      Label* conversion_failed, Label* done, Label::Distance dst) {
+  cvttsd2si(result_reg, Operand(input_reg));
+  cvtsi2sd(scratch, Operand(result_reg));
+  ucomisd(scratch, input_reg);
+  j(not_equal, conversion_failed, dst);
+  j(parity_even, conversion_failed, dst);  // NaN.
+  if (bailout_on_minus_zero) {
+    test(result_reg, Operand(result_reg));
+    j(not_zero, done, dst);
+    movmskpd(result_reg, input_reg);
+    and_(result_reg, 1);
+    j(not_zero, conversion_failed, dst);
+  }
+  jmp(done, dst);
+}
+
+
+void MacroAssembler::TruncateHeapNumberToI(Register input_reg,
+    Register result_reg) {
+  Label done, slow_case;
+
+  if (CpuFeatures::IsSupported(SSE3)) {
+    CpuFeatureScope scope(this, SSE3);
+    Label convert;
+    // Use more powerful conversion when sse3 is available.
+    // Load x87 register with heap number.
+    fld_d(FieldOperand(input_reg, HeapNumber::kValueOffset));
+    // Get exponent alone and check for too-big exponent.
+    mov(result_reg, FieldOperand(input_reg, HeapNumber::kExponentOffset));
+    and_(result_reg, HeapNumber::kExponentMask);
+    const uint32_t kTooBigExponent =
+        (HeapNumber::kExponentBias + 63) << HeapNumber::kExponentShift;
+    cmp(Operand(result_reg), Immediate(kTooBigExponent));
+    j(greater_equal, &slow_case, Label::kNear);
+
+    // Reserve space for 64 bit answer.
+    sub(Operand(esp), Immediate(kDoubleSize));
+    // Do conversion, which cannot fail because we checked the exponent.
+    fisttp_d(Operand(esp, 0));
+    mov(result_reg, Operand(esp, 0));  // Low word of answer is the result.
+    add(Operand(esp), Immediate(kDoubleSize));
+    jmp(&done, Label::kNear);
+
+    // Slow case.
+    bind(&slow_case);
+    if (input_reg.is(result_reg)) {
+      // Input is clobbered. Restore number from fpu stack
+      sub(Operand(esp), Immediate(kDoubleSize));
+      fstp_d(Operand(esp, 0));
+      SlowTruncateToI(esp, result_reg, 0);
+      add(esp, Immediate(kDoubleSize));
+    } else {
+      fstp(0);
+      SlowTruncateToI(input_reg, result_reg);
+    }
+  } else if (CpuFeatures::IsSupported(SSE2)) {
+    CpuFeatureScope scope(this, SSE2);
+    movdbl(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));
+    cvttsd2si(result_reg, Operand(xmm0));
+    cmp(result_reg, 0x80000000u);
+    j(not_equal, &done, Label::kNear);
+    // Check if the input was 0x8000000 (kMinInt).
+    // If no, then we got an overflow and we deoptimize.
+    ExternalReference min_int = ExternalReference::address_of_min_int();
+    ucomisd(xmm0, Operand::StaticVariable(min_int));
+    j(not_equal, &slow_case, Label::kNear);
+    j(parity_even, &slow_case, Label::kNear);  // NaN.
+    jmp(&done, Label::kNear);
+
+    // Slow case.
+    bind(&slow_case);
+    if (input_reg.is(result_reg)) {
+      // Input is clobbered. Restore number from double scratch.
+      sub(esp, Immediate(kDoubleSize));
+      movdbl(MemOperand(esp, 0), xmm0);
+      SlowTruncateToI(esp, result_reg, 0);
+      add(esp, Immediate(kDoubleSize));
+    } else {
+      SlowTruncateToI(input_reg, result_reg);
+    }
+  } else {
+    ASSERT(Serializer::enabled());
+    // TODO(olivf) If we ever hit this assert, it means that a DoubleToIStub is
+    // used in a snapshoted stub. In that case we should probably add a fast
+    // case here, which e.g. covers exponents < 31.
+    SlowTruncateToI(input_reg, result_reg);
+  }
+  bind(&done);
+}
+
+
+void MacroAssembler::TaggedToI(Register input_reg, Register result_reg,

[danno, 2013/08/09 13:27:25]

Why not just pass is no_reg to temp (removing the Maybe<>) argument for cases
that don't have a pre-allocated temp? I think that makes the interface much
cleaner and that's what we do elsewhere.

[oliv, 2013/08/12 12:18:47]

Done.

+    Maybe<XMMRegister> temp, bool bailout_on_minus_zero,
+    Label* bailout, Label* done) {
+
+  cmp(FieldOperand(input_reg, HeapObject::kMapOffset),
+      isolate()->factory()->heap_number_map());
+  j(not_equal, bailout, Label::kNear);
+
+  if (CpuFeatures::IsSafeForSnapshot(SSE2) && temp.has_value) {

[danno, 2013/08/09 13:27:25]

if temp == no_reg, then why not just just do:

temp = xmm1;
subi (esp, esp, Immediate(kDoubleSize));
movdbl(MemOperand(esp, 0), temp);

... existing code ...

addi (esp, esp, Immediate(kDoubleSize));

I think it probably will still be much faster than the x87 code.

[oliv, 2013/08/12 12:18:47]

not sure what you mean by existing code. but actually we currently always have a
temp, so lets just assert that.

+    CpuFeatureScope scope(this, SSE2);
+
+    XMMRegister xmm_temp = temp.value;
+    movdbl(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));
+    cvttsd2si(result_reg, Operand(xmm0));
+    cvtsi2sd(xmm_temp, Operand(result_reg));
+    ucomisd(xmm0, xmm_temp);
+    RecordComment("Deferred TaggedToI: lost precision");
+    j(not_equal, bailout, Label::kNear);
+    RecordComment("Deferred TaggedToI: NaN");
+    j(parity_even, bailout, Label::kNear);
+    if (bailout_on_minus_zero) {
+      test(result_reg, Operand(result_reg));
+      j(not_zero, done, Label::kNear);
+      movmskpd(result_reg, xmm0);
+      and_(result_reg, 1);
+      RecordComment("Deferred TaggedToI: minus zero");
+      j(not_zero, bailout, Label::kNear);
+    }
+    jmp(done, Label::kNear);
+  } else {
+    // TODO(olivf) Converting a number on the fpu is actually quite slow. We
+    // should first try a fast conversion and then bailout to this slow case.
+    Label bailout_pop, zero_check;
+    sub(esp, Immediate(kPointerSize));
+    fld_d(FieldOperand(input_reg, HeapNumber::kValueOffset));
+    if (bailout_on_minus_zero) fld(0);
+    fild_d(FieldOperand(input_reg, HeapNumber::kValueOffset));
+    fist_s(MemOperand(esp, 0));
+    FCmp();
+    pop(result_reg);
+    j(not_equal, bailout_on_minus_zero ? &bailout_pop : bailout,
+        Label::kNear);
+    j(parity_even, bailout_on_minus_zero ? &bailout_pop : bailout,
+        Label::kNear);  // NaN.
+    if (bailout_on_minus_zero) {
+      test(result_reg, Operand(result_reg));
+      j(zero, &zero_check, Label::kNear);
+      fstp(0);
+      jmp(done, Label::kNear);
+      bind(&zero_check);
+      // To check for minus zero, we load the value again as float, and check
+      // if that is still 0.
+      sub(esp, Immediate(kPointerSize));
+      fstp_s(Operand(esp, 0));
+      pop(result_reg);
+      test(result_reg, Operand(result_reg));
+      j(zero, done, Label::kNear);
+      jmp(bailout, Label::kNear);
+
+      bind(&bailout_pop);
+      fstp(0);
+      jmp(bailout, Label::kNear);
+    } else {
+      jmp(done, Label::kNear);
+    }
+  }

[danno, 2013/08/09 13:27:25]

Why do you need an explicit done label? Falling through should be the "done"
continuation after the current instruction without an explicit jump is cleaner,
that's what seems natural for  most cases above and I think adding a jmp to pc+4
is pretty silly in those cases.

[oliv, 2013/08/12 12:18:47]

Done.

+}
+
+
+
 static double kUint32Bias =
     static_cast<double>(static_cast<uint32_t>(0xFFFFFFFF)) + 1;