X64: Convert doubles to int32 inline (without calling runtime).

src/x64/macro-assembler-x64.cc

 // Copyright 2009 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 237 matching lines @@
                                       Label* then_label) {
   Label ok;
   testl(result, result);
   j(not_zero, &ok);
   testl(op, op);
   j(sign, then_label);
   bind(&ok);
 }
 
 
+void MacroAssembler::DoubleToInteger32(Register dst,
+                                       Register src,
+                                       Register scratch) {
+  Label no_bits_in_range, left_shift, apply_sign, positive_sign, done;
+  ASSERT(!src.is(scratch));
+  ASSERT(!src.is(kScratchRegister));
+  ASSERT(!scratch.is(kScratchRegister));
+
+  movq(scratch, src);
+  movq(rcx, src);
+  shr(rcx, Immediate(52));  // Move exponent to bottom of register.
+  andl(rcx, Immediate(0x7ff)); // sign bit be gone.
+  subl(rcx, Immediate(0x3ff)); // bias substracted.
+  // If exponent in range 0..83, there is a significant bit in
+  // the 0..2^32 range.
+  cmpl(rcx, Immediate(52 + 31));
+  j(above, &no_bits_in_range);
+  subl(rcx, Immediate(52));
+  j(greater_equal, &left_shift);
+  // right shift by 52-(e-bias)
+  negl(rcx);
+  shr(scratch);
+  cmpl(rcx, Immediate(20));
+  j(less_equal, &apply_sign);
+
+  // Add implicit leading one.
+  subl(rcx, Immediate(52));  // Get back original exponent.
+  negl(rcx);
+  movl(kScratchRegister, Immediate(1));
+  shll(kScratchRegister);
+  orl(scratch, kScratchRegister);
+  // Mask away exponent and sign bits.
+  addl(kScratchRegister, kScratchRegister);
+  subl(kScratchRegister, Immediate(1));

[Lasse Reichstein, 2009/10/07 16:54:24]

Just noticed that the previous two lines could be done with one lea instruction.

+  andl(scratch, kScratchRegister);
+  jmp(&apply_sign);
+
+  bind(&no_bits_in_range);
+  // All significant digits of the number is either below the
+  // decimal point or at or above 2^32 (or the value is an infinity
+  // or NaN). Return zero in all these cases.
+  xor_(dst, dst);
+  jmp(&done);
+
+  bind(&left_shift);
+  // Shift left by e-bias-52.
+  shll(scratch);
+
+  bind(&apply_sign);
+  testq(src, src);
+  j(positive, &positive_sign);
+  neg(scratch);
+  bind(&positive_sign);
+  if (!dst.is(scratch)) {
+    movl(dst, scratch);
+  }
+  bind(&done);
+}
+
+
 void MacroAssembler::Abort(const char* msg) {
   // We want to pass the msg string like a smi to avoid GC
   // problems, however msg is not guaranteed to be aligned
   // properly. Instead, we pass an aligned pointer that is
   // a proper v8 smi, but also pass the alignment difference
   // from the real pointer as a smi.
   intptr_t p1 = reinterpret_cast<intptr_t>(msg);
   intptr_t p0 = (p1 & ~kSmiTagMask) + kSmiTag;
   // Note: p0 might not be a valid Smi *value*, but it has a valid Smi tag.
   ASSERT(reinterpret_cast<Object*>(p0)->IsSmi());
@@ skipping 1887 matching lines @@
   // Indicate that code has changed.
   CPU::FlushICache(address_, size_);
 
   // Check that the code was patched as expected.
   ASSERT(masm_.pc_ == address_ + size_);
   ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
 }
 
 
 } }  // namespace v8::internal