Revert new OS and CC detection and related changes since r15923.

src/platform-win32.cc

 // Copyright 2012 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 30 matching lines @@
 #define V8_WIN32_HEADERS_FULL
 #include "win32-headers.h"
 
 #include "v8.h"
 
 #include "codegen.h"
 #include "platform.h"
 #include "simulator.h"
 #include "vm-state-inl.h"
 
-#if V8_CC_MSVC
+#ifdef _MSC_VER
 
 // Case-insensitive bounded string comparisons. Use stricmp() on Win32. Usually
 // defined in strings.h.
 int strncasecmp(const char* s1, const char* s2, int n) {
   return _strnicmp(s1, s2, n);
 }
 
-#endif  // V8_CC_MSVC
+#endif  // _MSC_VER
 
 
 // Extra functions for MinGW. Most of these are the _s functions which are in
 // the Microsoft Visual Studio C++ CRT.
 #ifdef __MINGW32__
 
 
 #ifndef __MINGW64_VERSION_MAJOR
 
 #define _TRUNCATE 0
@@ skipping 92 matching lines @@
 // Copy memory area to disjoint memory area.
 void OS::MemMove(void* dest, const void* src, size_t size) {
   if (size == 0) return;
   // Note: here we rely on dependent reads being ordered. This is true
   // on all architectures we currently support.
   (*memmove_function)(dest, src, size);
 }
 
 #endif  // V8_TARGET_ARCH_IA32
 
-#if V8_OS_WIN64
+#ifdef _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);
 }
-#else
+#else  // Win32
+
 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;
 }
-#endif  // V8_OS_WIN64
+
+#endif  // _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);                   \
 }
 
 UNARY_MATH_FUNCTION(sin, CreateTranscendentalFunction(TranscendentalCache::SIN))
 UNARY_MATH_FUNCTION(cos, CreateTranscendentalFunction(TranscendentalCache::COS))
 UNARY_MATH_FUNCTION(tan, CreateTranscendentalFunction(TranscendentalCache::TAN))
 UNARY_MATH_FUNCTION(log, CreateTranscendentalFunction(TranscendentalCache::LOG))
 UNARY_MATH_FUNCTION(exp, CreateExpFunction())
 UNARY_MATH_FUNCTION(sqrt, CreateSqrtFunction())
 
 #undef UNARY_MATH_FUNCTION
 
 
 void lazily_initialize_fast_exp() {
   if (fast_exp_function == NULL) {
     init_fast_exp_function();
   }
 }
 
 
 void MathSetup() {
-#if V8_OS_WIN64
+#ifdef _WIN64
   init_modulo_function();
 #endif
   init_fast_sin_function();
   init_fast_cos_function();
   init_fast_tan_function();
   init_fast_log_function();
   // fast_exp is initialized lazily.
   init_fast_sqrt_function();
 }
 
@@ skipping 760 matching lines @@
   if (IsDebuggerPresent() || FLAG_break_on_abort) {
     DebugBreak();
   } else {
     // Make the MSVCRT do a silent abort.
     raise(SIGABRT);
   }
 }
 
 
 void OS::DebugBreak() {
-#if V8_CC_MSVC
+#ifdef _MSC_VER
   __debugbreak();
 #else
   ::DebugBreak();
-#endif  // V8_CC_MSVC
+#endif
 }
 
 
 void OS::DumpBacktrace() {
   // Currently unsupported.
 }
 
 
 class Win32MemoryMappedFile : public OS::MemoryMappedFile {
  public:
@@ skipping 327 matching lines @@
   // Read the symbols.
   if (!LoadSymbols(process_handle)) return kStackWalkError;
 
   // Capture current context.
   CONTEXT context;
   RtlCaptureContext(&context);
 
   // Initialize the stack walking
   STACKFRAME64 stack_frame;
   memset(&stack_frame, 0, sizeof(stack_frame));
-#if V8_OS_WIN64
+#ifdef  _WIN64
   stack_frame.AddrPC.Offset = context.Rip;
   stack_frame.AddrFrame.Offset = context.Rbp;
   stack_frame.AddrStack.Offset = context.Rsp;
 #else
   stack_frame.AddrPC.Offset = context.Eip;
   stack_frame.AddrFrame.Offset = context.Ebp;
   stack_frame.AddrStack.Offset = context.Esp;
 #endif
   stack_frame.AddrPC.Mode = AddrModeFlat;
   stack_frame.AddrFrame.Mode = AddrModeFlat;
@@ skipping 88 matching lines @@
 int OS::StackWalk(Vector<OS::StackFrame> frames) { return 0; }
 #endif  // __MINGW32__
 
 
 uint64_t OS::CpuFeaturesImpliedByPlatform() {
   return 0;  // Windows runs on anything.
 }
 
 
 double OS::nan_value() {
-#if V8_CC_MSVC
+#ifdef _MSC_VER
   // Positive Quiet NaN with no payload (aka. Indeterminate) has all bits
   // in mask set, so value equals mask.
   static const __int64 nanval = kQuietNaNMask;
   return *reinterpret_cast<const double*>(&nanval);
-#else  // V8_CC_MSVC
+#else  // _MSC_VER
   return NAN;
-#endif  // V8_CC_MSVC
+#endif  // _MSC_VER
 }
 
 
 int OS::ActivationFrameAlignment() {
-#if V8_OS__WIN64
+#ifdef _WIN64
   return 16;  // Windows 64-bit ABI requires the stack to be 16-byte aligned.
-#elif V8_CC_MINGW
+#elif defined(__MINGW32__)
   // With gcc 4.4 the tree vectorization optimizer can generate code
   // that requires 16 byte alignment such as movdqa on x86.
   return 16;
 #else
   return 8;  // Floating-point math runs faster with 8-byte alignment.
 #endif
 }
 
 
 VirtualMemory::VirtualMemory() : address_(NULL), size_(0) { }
@@ skipping 492 matching lines @@
   limit_mutex = CreateMutex();
 }
 
 
 void OS::TearDown() {
   delete limit_mutex;
 }
 
 
 } }  // namespace v8::internal