X64 Win64: Reimplement fmod so that it works.

src/x64/assembler-x64.h

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // 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.
 //
@@ skipping 265 matching lines @@
 // The result of negating a hint is as if the corresponding condition
 // were negated by NegateCondition.  That is, no_hint is mapped to
 // itself and not_taken and taken are mapped to each other.
 inline Hint NegateHint(Hint hint) {
   return (hint == no_hint)
       ? no_hint
       : ((hint == not_taken) ? taken : not_taken);
 }
 
 
+// FPU status word bits
+
+enum FPUStatus {
+  kInvalidOperandException = 0x01,
+  kDenormalizedOperandException = 0x02,
+  kZeroDivideException = 0x04,
+  kOverflowException = 0x08,
+  kUnderflowException = 0x10,
+  kPrecisionException = 0x20,
+  kAnyExceptionMask = 0x3f,  // All of the above.
+  kStackFault = 0x40,
+  kErrorSummary = 0x80,
+  kCondition0 = 0x100,
+  kCondition1 = 0x200,
+  kCondition2 = 0x400,
+  kCondition3 = 0x4000
+};
+
+
 // -----------------------------------------------------------------------------
 // Machine instruction Immediates
 
 class Immediate BASE_EMBEDDED {
  public:
   explicit Immediate(int32_t value) : value_(value) {}
 
  private:
   int32_t value_;
 
@@ skipping 24 matching lines @@
   Operand(Register base,
           Register index,
           ScaleFactor scale,
           int32_t disp);
 
   // [index*scale + disp/r]
   Operand(Register index,
           ScaleFactor scale,
           int32_t disp);
 
+  // New operand based on previous operand and a fixed displacement.
+  Operand(const Operand& base, int32_t displacement);
+
  private:
   byte rex_;
   byte buf_[10];
   // The number of bytes in buf_.
   unsigned int len_;
-  RelocInfo::Mode rmode_;
 
   // Set the ModR/M byte without an encoded 'reg' register. The
   // register is encoded later as part of the emit_operand operation.
   // set_modrm can be called before or after set_sib and set_disp*.
   inline void set_modrm(int mod, Register rm);
 
   // Set the SIB byte if one is needed. Sets the length to 2 rather than 1.
   inline void set_sib(ScaleFactor scale, Register index, Register base);
 
   // Adds operand displacement fields (offsets added to the memory address).
@@ skipping 579 matching lines @@
   }
 
   void xor_(const Operand& dst, Register src) {
     arithmetic_op(0x31, src, dst);
   }
 
   void xor_(Register dst, Immediate src) {
     immediate_arithmetic_op(0x6, dst, src);
   }
 
+  void xorl(Register dst, Immediate src) {
+    immediate_arithmetic_op_32(0x6, dst, src);
+  }
+
   void xor_(const Operand& dst, Immediate src) {
     immediate_arithmetic_op(0x6, dst, src);
   }
 
   // Bit operations.
   void bt(const Operand& dst, Register src);
   void bts(const Operand& dst, Register src);
 
   // Miscellaneous
   void clc();
@@ skipping 54 matching lines @@
   void fld(int i);
 
   void fld1();
   void fldz();
 
   void fld_s(const Operand& adr);
   void fld_d(const Operand& adr);
 
   void fstp_s(const Operand& adr);
   void fstp_d(const Operand& adr);
+  void fst_d(const Operand& adr);
+  void fstp(int stack_slot);
+  void fst(int stack_slot);
 
   void fild_s(const Operand& adr);
   void fild_d(const Operand& adr);
 
   void fist_s(const Operand& adr);
 
   void fistp_s(const Operand& adr);
   void fistp_d(const Operand& adr);
 
   void fisttp_s(const Operand& adr);
@@ skipping 14 matching lines @@
   void fmulp(int i = 1);
   void fdivp(int i = 1);
   void fprem();
   void fprem1();
 
   void fxch(int i = 1);
   void fincstp();
   void ffree(int i = 0);
 
   void ftst();
+  void fucom(int i);
   void fucomp(int i);
   void fucompp();
   void fcompp();
   void fnstsw_ax();
   void fwait();
   void fnclex();
+  void fxam();
 
   void fsin();
   void fcos();
 
   void frndint();
 
   void sahf();
 
   // SSE2 instructions
   void movsd(const Operand& dst, XMMRegister src);
@@ skipping 296 matching lines @@
  private:
   Assembler* assembler_;
 #ifdef DEBUG
   int space_before_;
 #endif
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_ASSEMBLER_X64_H_