Move ToI conversions to the MacroAssembler

src/ia32/macro-assembler-ia32.cc

 // Copyright 2012 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 143 matching lines @@
 void MacroAssembler::ClampUint8(Register reg) {
   Label done;
   test(reg, Immediate(0xFFFFFF00));
   j(zero, &done, Label::kNear);
   setcc(negative, reg);  // 1 if negative, 0 if positive.
   dec_b(reg);  // 0 if negative, 255 if positive.
   bind(&done);
 }
 
 
+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;
 
 
 void MacroAssembler::LoadUint32(XMMRegister dst,
                                 Register src,
                                 XMMRegister scratch) {
   Label done;
   cmp(src, Immediate(0));
   movdbl(scratch,
@@ skipping 3013 matching lines @@
   j(greater, &no_memento_available);
   cmp(MemOperand(scratch_reg, -AllocationMemento::kSize),
       Immediate(Handle<Map>(isolate()->heap()->allocation_memento_map())));
   bind(&no_memento_available);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32