Remove custom win64 modulo code

src/codegen.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/codegen.h"
 
 #if defined(V8_OS_AIX)
 #include <fenv.h>  // NOLINT(build/c++11)
 #endif
 #include "src/bootstrapper.h"
 #include "src/compiler.h"
 #include "src/debug/debug.h"
 #include "src/parser.h"
 #include "src/prettyprinter.h"
 #include "src/profiler/cpu-profiler.h"
 #include "src/rewriter.h"
 #include "src/runtime/runtime.h"
 
 namespace v8 {
 namespace internal {
 
 
-#if defined(_WIN64)
-typedef double (*ModuloFunction)(double, double);
-static ModuloFunction modulo_function = NULL;
-// Defined in codegen-x64.cc.
-ModuloFunction CreateModuloFunction();
-
-void init_modulo_function() {
-  modulo_function = CreateModuloFunction();
-}
-
-
-double modulo(double x, double y) {
-  // Note: here we rely on dependent reads being ordered. This is true
-  // on all architectures we currently support.
-  return (*modulo_function)(x, y);
-}
-#elif defined(_WIN32)
-
+#if defined(V8_OS_WIN)
 double modulo(double x, double y) {
   // Workaround MS fmod bugs. ECMA-262 says:
   // dividend is finite and divisor is an infinity => result equals dividend
   // dividend is a zero and divisor is nonzero finite => result equals dividend
   if (!(std::isfinite(x) && (!std::isfinite(y) && !std::isnan(y))) &&
       !(x == 0 && (y != 0 && std::isfinite(y)))) {
     x = fmod(x, y);
   }
   return x;
 }
 #else  // POSIX
 
 double modulo(double x, double y) {
 #if defined(V8_OS_AIX)
   // AIX raises an underflow exception for (Number.MIN_VALUE % Number.MAX_VALUE)
   feclearexcept(FE_ALL_EXCEPT);
   double result = std::fmod(x, y);
   int exception = fetestexcept(FE_UNDERFLOW);
   return (exception ? x : result);
 #else
   return std::fmod(x, y);
 #endif
 }
-#endif  // defined(_WIN64)
+#endif  // defined(V8_OS_WIN)
 
 
 #define UNARY_MATH_FUNCTION(name, generator)                             \
   static UnaryMathFunctionWithIsolate fast_##name##_function = nullptr;  \
   double std_##name(double x, Isolate* isolate) { return std::name(x); } \
   void init_fast_##name##_function(Isolate* isolate) {                   \
     if (FLAG_fast_math) fast_##name##_function = generator(isolate);     \
     if (!fast_##name##_function) fast_##name##_function = std_##name;    \
   }                                                                      \
   void lazily_initialize_fast_##name(Isolate* isolate) {                 \
@@ skipping 147 matching lines @@
       os << "source_position = " << literal->start_position() << "\n";
     }
     code->Disassemble(debug_name.get(), os);
     os << "--- End code ---\n";
   }
 #endif  // ENABLE_DISASSEMBLER
 }
 
 }  // namespace internal
 }  // namespace v8