Use std:: on symbols declared in C++-style C headers.

src/assembler.cc

 // 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 920 matching lines @@
 
     math_exp_constants_array = new double[9];
     // Input values smaller than this always return 0.
     math_exp_constants_array[0] = -708.39641853226408;
     // Input values larger than this always return +Infinity.
     math_exp_constants_array[1] = 709.78271289338397;
     math_exp_constants_array[2] = V8_INFINITY;
     // The rest is black magic. Do not attempt to understand it. It is
     // loosely based on the "expd" function published at:
     // http://herumi.blogspot.com/2011/08/fast-double-precision-exponential.html
-    const double constant3 = (1 << kTableSizeBits) / log(2.0);
+    const double constant3 = (1 << kTableSizeBits) / std::log(2.0);
     math_exp_constants_array[3] = constant3;
     math_exp_constants_array[4] =
         static_cast<double>(static_cast<int64_t>(3) << 51);
     math_exp_constants_array[5] = 1 / constant3;
     math_exp_constants_array[6] = 3.0000000027955394;
     math_exp_constants_array[7] = 0.16666666685227835;
     math_exp_constants_array[8] = 1;
 
     math_exp_log_table_array = new double[kTableSize];
     for (int i = 0; i < kTableSize; i++) {
-      double value = pow(2, i / kTableSizeDouble);
+      double value = std::pow(2, i / kTableSizeDouble);
       uint64_t bits = BitCast<uint64_t, double>(value);
       bits &= (static_cast<uint64_t>(1) << 52) - 1;
       double mantissa = BitCast<double, uint64_t>(bits);
       math_exp_log_table_array[i] = mantissa;
     }
 
     math_exp_data_initialized = true;
   }
 }
 
@@ skipping 422 matching lines @@
   return ExternalReference(isolate->regexp_stack()->memory_size_address());
 }
 
 #endif  // V8_INTERPRETED_REGEXP
 
 
 ExternalReference ExternalReference::math_log_double_function(
     Isolate* isolate) {
   typedef double (*d2d)(double x);
   return ExternalReference(Redirect(isolate,
-                                    FUNCTION_ADDR(static_cast<d2d>(log)),
+                                    FUNCTION_ADDR(static_cast<d2d>(std::log)),
                                     BUILTIN_FP_CALL));
 }
 
 
 ExternalReference ExternalReference::math_exp_constants(int constant_index) {
   ASSERT(math_exp_data_initialized);
   return ExternalReference(
       reinterpret_cast<void*>(math_exp_constants_array + constant_index));
 }
 
@@ skipping 50 matching lines @@
 }
 
 
 double power_double_double(double x, double y) {
 #if defined(__MINGW64_VERSION_MAJOR) && \
     (!defined(__MINGW64_VERSION_RC) || __MINGW64_VERSION_RC < 1)
   // MinGW64 has a custom implementation for pow.  This handles certain
   // special cases that are different.
   if ((x == 0.0 || std::isinf(x)) && std::isfinite(y)) {
     double f;
     if (modf(y, &f) != 0.0) return ((x == 0.0) ^ (y > 0)) ? V8_INFINITY : 0;

[Benedikt Meurer, 2014/01/07 08:20:27]

std::modf

   }
 
   if (x == 2.0) {
     int y_int = static_cast<int>(y);
     if (y == y_int) return ldexp(1.0, y_int);

[Benedikt Meurer, 2014/01/07 08:20:27]

std::ldexp

   }
 #endif
 
   // The checks for special cases can be dropped in ia32 because it has already
   // been done in generated code before bailing out here.
   if (std::isnan(y) || ((x == 1 || x == -1) && std::isinf(y))) {
     return OS::nan_value();
   }
-  return pow(x, y);
+  return std::pow(x, y);
 }
 
 
 ExternalReference ExternalReference::power_double_double_function(
     Isolate* isolate) {
   return ExternalReference(Redirect(isolate,
                                     FUNCTION_ADDR(power_double_double),
                                     BUILTIN_FP_FP_CALL));
 }
 
@@ skipping 98 matching lines @@
     assembler_->RecordRelocInfo(RelocInfo::POSITION, state_.current_position);
     state_.written_position = state_.current_position;
     written = true;
   }
 
   // Return whether something was written.
   return written;
 }
 
 } }  // namespace v8::internal