X64 Win64: Reimplement fmod so that it works.

src/x64/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 @@
   } else if (is_int8(disp)) {
     set_modrm(1, rsp);
     set_disp8(disp);
   } else {
     set_modrm(2, rsp);
     set_disp32(disp);
   }
 }
 
 
+Operand::Operand(const Operand& base, int32_t displacement_delta) {
+  rex_ = base.rex_;
+  len_ = 1;
+  byte modrm = base.buf_[0];
+  ASSERT_NE(0xC0, modrm & 0xC0);  // Must be a memory operand.
+  if ((modrm & 7) == rsp.code()) {
+    // Has SIB byte
+    buf_[1] = base.buf_[1];
+    len_ = 2;
+  }
+  int old_displacement;
+  switch (modrm >> 6) {
+    case 0:
+      // No current displacement, unless base is rbp/r13.
+      if ((modrm & 7) != rbp.code()) {
+        old_displacement = 0;
+        break;
+      }
+      // Fallthrough to 32-bit displacement.
+    case 2:
+      // Current 32-bit displacement.
+      old_displacement =
+          Memory::int32_at(const_cast<Address>(base.buf_ + len_));
+      break;
+    case 1:
+      // Current 8-bit displacement.
+      old_displacement = static_cast<int8_t>(base.buf_[len_]);
+      break;
+    default:
+      UNREACHABLE();
+      old_displacement = 0;  // Seems to be used uninitialized otherwise.
+  }
+  int32_t displacement = old_displacement + displacement_delta;
+  modrm = modrm & 0x3f;
+  if (displacement == 0 && (modrm & 7) != rbp.code()) {
+    // Zero mod part of ModR/M and no displacement.
+  } else if (is_int8(displacement)) {
+    modrm = modrm | 0x40;
+    set_disp8(displacement);
+  } else {
+    modrm = modrm | 0x80u;
+    set_disp32(displacement);
+  }
+  buf_[0] = modrm;
+}
+
+
 // -----------------------------------------------------------------------------
 // Implementation of Assembler
 
 #ifdef GENERATED_CODE_COVERAGE
 static void InitCoverageLog();
 #endif
 
 byte* Assembler::spare_buffer_ = NULL;
 
 Assembler::Assembler(void* buffer, int buffer_size)
@@ skipping 1695 matching lines @@
 
 void Assembler::fstp_d(const Operand& adr) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   emit_optional_rex_32(adr);
   emit(0xDD);
   emit_operand(3, adr);
 }
 
 
+void Assembler::fst_d(const Operand& adr) {
+  EnsureSpace ensure_space(this);
+  last_pc_ = pc_;
+  emit_optional_rex_32(adr);
+  emit(0xDD);
+  emit_operand(2, adr);
+}
+
+
+void Assembler::fstp(int stack_slot) {
+  ASSERT(is_uint3(stack_slot));
+  EnsureSpace ensure_space(this);
+  last_pc_ = pc_;
+  emit(0xDD);
+  emit(0xD8 + stack_slot);
+}
+
+void Assembler::fst(int stack_slot) {
+  ASSERT(is_uint3(stack_slot));
+  EnsureSpace ensure_space(this);
+  last_pc_ = pc_;
+  emit(0xDD);
+  emit(0xD0 + stack_slot);
+}
+
 void Assembler::fild_s(const Operand& adr) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   emit_optional_rex_32(adr);
   emit(0xDB);
   emit_operand(0, adr);
 }
 
 
 void Assembler::fild_d(const Operand& adr) {
@@ skipping 185 matching lines @@
 
 
 void Assembler::ftst() {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   emit(0xD9);
   emit(0xE4);
 }
 
 
+void Assembler::fucom(int i) {
+  EnsureSpace ensure_space(this);
+  last_pc_ = pc_;
+  emit_farith(0xDD, 0xE0, i);
+}
+
+
 void Assembler::fucomp(int i) {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   emit_farith(0xDD, 0xE8, i);
 }
 
 
 void Assembler::fucompp() {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
@@ skipping 11 matching lines @@
 
 
 void Assembler::fnstsw_ax() {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   emit(0xDF);
   emit(0xE0);
 }
 
 
+void Assembler::fxam() {
+  EnsureSpace ensure_space(this);
+  last_pc_ = pc_;
+  emit(0xD9);
+  emit(0xE5);
+}
+
 void Assembler::fwait() {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
   emit(0x9B);
 }
 
 
 void Assembler::frndint() {
   EnsureSpace ensure_space(this);
   last_pc_ = pc_;
@@ skipping 248 matching lines @@
     written_position_ = current_position_;
   }
 }
 
 
 const int RelocInfo::kApplyMask = RelocInfo::kCodeTargetMask |
                                   1 << RelocInfo::INTERNAL_REFERENCE |
                                   1 << RelocInfo::JS_RETURN;
 
 } }  // namespace v8::internal