Lazily initialize fast_sqrt() and pass an Isolate parameter to it

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"
@@ skipping 46 matching lines @@
   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)
 
 
-#define UNARY_MATH_FUNCTION(name, generator)             \
-static UnaryMathFunction fast_##name##_function = NULL;  \
-void init_fast_##name##_function() {                     \
-  fast_##name##_function = generator;                    \
-}                                                        \
-double fast_##name(double x) {                           \
-  return (*fast_##name##_function)(x);                   \
-}
+#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) {                 \
+    if (!fast_##name##_function) init_fast_##name##_function(isolate);   \
+  }                                                                      \
+  double fast_##name(double x, Isolate* isolate) {                       \
+    return (*fast_##name##_function)(x, isolate);                        \
+  }
 
-UNARY_MATH_FUNCTION(sqrt, CreateSqrtFunction())
+UNARY_MATH_FUNCTION(sqrt, CreateSqrtFunction)
+UNARY_MATH_FUNCTION(exp, CreateExpFunction)
 
 #undef UNARY_MATH_FUNCTION
 
-static UnaryMathFunctionWithIsolate fast_exp_function = NULL;
-
-
-double std_exp(double x, Isolate* isolate) {
-  return std::exp(x);
-}
-
-
-void init_fast_exp_function(Isolate* isolate) {
-    if (FLAG_fast_math) fast_exp_function = CreateExpFunction(isolate);
-    if (!fast_exp_function) fast_exp_function = std_exp;
-}
-
-
-double fast_exp(double x, Isolate* isolate) {
-  return (*fast_exp_function)(x, isolate);
-}
-
-
-void lazily_initialize_fast_exp(Isolate* isolate) {
-  if (fast_exp_function == nullptr) {
-    init_fast_exp_function(isolate);
-  }
-}
-
 
 #define __ ACCESS_MASM(masm_)
 
 #ifdef DEBUG
 
 Comment::Comment(MacroAssembler* masm, const char* msg)
     : masm_(masm), msg_(msg) {
   __ RecordComment(msg);
 }
 
@@ skipping 126 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