X64 Win64: Reimplement fmod so that it works.

src/x64/codegen-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 201 matching lines @@
   // operand_1 on TOS+1 , operand_2 on TOS+2; Returns operands as
   // floating point numbers in XMM registers.
   static void LoadFloatOperands(MacroAssembler* masm,
                                 XMMRegister dst1,
                                 XMMRegister dst2);
 
   // Code pattern for loading floating point values onto the fp stack.
   // Input values must be either smi or heap number objects (fp values).
   // Requirements:
   // Register version: operands in registers lhs and rhs.
+  // Version without scratch memory pushes and pops the stack to get a
+  // memory cell, the version with scratch memory uses 8 bytes (64 bits)
+  // at that location.
   // Stack version: operands on TOS+1 and TOS+2.
   // Returns operands as floating point numbers on fp stack.
   static void LoadFloatOperands(MacroAssembler* masm);
   static void LoadFloatOperands(MacroAssembler* masm,
                                 Register lhs,
                                 Register rhs);
+  static void LoadFloatOperands(MacroAssembler* masm,
+                                Register lhs,
+                                Register rhs,
+                                const Operand& scratch_memory);
 
   // Code pattern for loading a floating point value and converting it
   // to a 32 bit integer. Input value must be either a smi or a heap number
   // object.
   // Returns operands as 32-bit sign extended integers in a general purpose
   // registers.
   static void LoadInt32Operand(MacroAssembler* masm,
                                const Operand& src,
                                Register dst);
 
@@ skipping 3758 matching lines @@
       answer = frame_->CallRuntime(Runtime::kMath_sin, 1);
       break;
     case COS:
       answer = frame_->CallRuntime(Runtime::kMath_cos, 1);
       break;
   }
   frame_->Push(&answer);
   done.Bind();
 }
 
 

[William Hesse, 2009/10/20 14:50:51]

Could this function be documented more, explaining what it does, how it does it,
and why it does it?

+void CodeGenerator::GenerateNumberMod(ZoneList<Expression*>* args) {
+  ASSERT_EQ(2, args->length());
+#ifdef _WIN64
+  Load(args->at(0));
+  Load(args->at(1));
+  // Allocate rax for using fnstsw_ax.
+  Result tmp = allocator_->Allocate(rax);
+  // Allocate callee save register, for storing value while calling runtime.
+  Result callee_save_result = allocator_->Allocate(r15);
+  Result divisor_result = frame_->Pop();
+  Result dividend_result = frame_->Pop();
+  divisor_result.ToRegister();
+  dividend_result.ToRegister();
+  {
+    // Code uses the physical stack, so it must be in sync.
+    VirtualFrame::SpilledScope scope;
+    Register dividend = dividend_result.reg();
+    Register divisor = divisor_result.reg();
+    Register callee_save = callee_save_result.reg();
+
+    Label done;
+    // Make room on stack for temporary value.
+    __ subq(rsp, Immediate(kPointerSize));
+
+    // Load operands onto FPU stack.
+    // Divisor must go first on stack, so order of operands is really rhs, lhs.
+    FloatingPointHelper::LoadFloatOperands(masm_,
+                                           divisor,
+                                           dividend,
+                                           Operand(rsp, 0));
+
+    // Compute the remainder.
+    {
+      Label partial_remainder_loop;
+      __ bind(&partial_remainder_loop);
+      __ fprem();
+      __ fwait();
+      __ fnstsw_ax();
+      __ testl(rax, Immediate(kCondition2));
+      __ j(not_zero, &partial_remainder_loop);
+    }
+
+    // Result is in ST(0), garbage in ST(1), and original value
+    // of dividend in ST(2). Return ST(0) unless a division by zero or
+    // invalid operation exception has been raised. Status word is in rax.
+
+    Label valid_result;
+    Label allocate_result;
+    // Test for InvalidOperation or division by zero.
+    // In those cases, discard the result and use NaN instead.
+    __ testb(rax, Immediate(kInvalidOperandException | kZeroDivideException));
+    __ j(zero, &valid_result);
+
+    __ fstp(0);  // Pop (garbage) result
+    __ addq(rsp, Immediate(kPointerSize));  // Free stack cell.
+    int64_t kNaNValue = V8_INT64_C(0x7ff8000000000000);
+    // Move NaN to (callee save) register for later storing into new HeapNumber.
+    __ movq(callee_save, kNaNValue, RelocInfo::NONE);
+    __ jmp(&allocate_result);
+
+    // Allocate new space for a HeapNumber (is branched back to if direct heap
+    // allocation fails in the following code).
+    Label gc_req;
+    Label heap_number_allocated;
+    __ bind(&gc_req);
+    // Garbage collection required before allocating a heap number.
+    // Call runtime to do the allocation, and handle the allocation failure.
+    __ CallRuntime(Runtime::kAllocateHeapNumber, 0);
+    __ jmp(&heap_number_allocated);
+
+    __ bind(&valid_result);
+
+    // Result in ST(0), garbage in ST(1) and ST(2).
+    // Pop result and free stack cell.
+    __ fstp_d(Operand(rsp, 0));
+    __ pop(callee_save);
+
+    __ bind(&allocate_result);
+    // Free FPU stack and clear pending FPU exceptions (e.g., Denormal).
+    __ fstp(0);
+    Label no_exceptions_set;
+    __ testb(rax, Immediate(kAnyExceptionMask));
+    __ j(zero, &no_exceptions_set);
+    __ fnclex();
+    __ bind(&no_exceptions_set);
+
+    FloatingPointHelper::AllocateHeapNumber(masm_, &gc_req, dividend, rax);
+    __ bind(&heap_number_allocated);  // Return point for gc_req branch.
+    __ movq(FieldOperand(rax, HeapNumber::kValueOffset), callee_save);
+
+    __ bind(&done);
+  }
+  frame_->Push(&tmp);
+
+#else
+  // Simply call the runtime function. Arguments must be numbers.
+  ASSERT(args->length() == 2);
+  Load(args->at(0));
+  Load(args->at(1));
+
+  Result answer = frame_->CallRuntime(Runtime::kNumberMod, 2);
+  frame_->Push(&answer);
+#endif
+}
+
+
 void CodeGenerator::GenerateClassOf(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   JumpTarget leave, null, function, non_function_constructor;
   Load(args->at(0));  // Load the object.
   Result obj = frame_->Pop();
   obj.ToRegister();
   frame_->Spill(obj.reg());
 
   // If the object is a smi, we return null.
   Condition is_smi = masm_->CheckSmi(obj.reg());
@@ skipping 3300 matching lines @@
   Label load_smi_lhs, load_smi_rhs, done_load_lhs, done;
   __ JumpIfSmi(lhs, &load_smi_lhs);
   __ fld_d(FieldOperand(lhs, HeapNumber::kValueOffset));
   __ bind(&done_load_lhs);
 
   __ JumpIfSmi(rhs, &load_smi_rhs);
   __ fld_d(FieldOperand(rhs, HeapNumber::kValueOffset));
   __ jmp(&done);
 
   __ bind(&load_smi_lhs);
-  __ SmiToInteger64(kScratchRegister, lhs);
-  __ push(kScratchRegister);
-  __ fild_d(Operand(rsp, 0));
-  __ pop(kScratchRegister);
+  __ push(lhs);
+  __ FLoadSmi(Operand(rsp, 0));
+  __ addq(rsp, Immediate(kPointerSize));
   __ jmp(&done_load_lhs);
 
   __ bind(&load_smi_rhs);
-  __ SmiToInteger64(kScratchRegister, rhs);
-  __ push(kScratchRegister);
-  __ fild_d(Operand(rsp, 0));
-  __ pop(kScratchRegister);
+  __ push(rhs);
+  __ FLoadSmi(Operand(rsp, 0));
+  __ addq(rsp, Immediate(kPointerSize));
 
   __ bind(&done);
 }
+
+
+void FloatingPointHelper::LoadFloatOperands(MacroAssembler* masm,
+                                            Register lhs,
+                                            Register rhs,
+                                            const Operand& scratch_memory) {
+  Label load_smi_lhs, load_smi_rhs, done_load_lhs, done;
+  __ JumpIfSmi(lhs, &load_smi_lhs);
+  __ fld_d(FieldOperand(lhs, HeapNumber::kValueOffset));
+  __ bind(&done_load_lhs);
+
+  __ JumpIfSmi(rhs, &load_smi_rhs);
+  __ fld_d(FieldOperand(rhs, HeapNumber::kValueOffset));
+  __ jmp(&done);
+
+  __ bind(&load_smi_lhs);
+  __ movq(scratch_memory, lhs);
+  __ FLoadSmi(scratch_memory);
+  __ jmp(&done_load_lhs);
+
+  __ bind(&load_smi_rhs);
+  __ movq(scratch_memory, rhs);
+  __ FLoadSmi(scratch_memory);
+
+  __ bind(&done);
+}
 
 
 void FloatingPointHelper::CheckNumberOperands(MacroAssembler* masm,
                                               Label* non_float) {
   Label test_other, done;
   // Test if both operands are numbers (heap_numbers or smis).
   // If not, jump to label non_float.
   __ JumpIfSmi(rdx, &test_other);  // argument in rdx is OK
   __ Cmp(FieldOperand(rdx, HeapObject::kMapOffset), Factory::heap_number_map());
   __ j(not_equal, non_float);  // The argument in rdx is not a number.
@@ skipping 341 matching lines @@
 int CompareStub::MinorKey() {
   // Encode the two parameters in a unique 16 bit value.
   ASSERT(static_cast<unsigned>(cc_) < (1 << 15));
   return (static_cast<unsigned>(cc_) << 1) | (strict_ ? 1 : 0);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal