A64: Synchronize with r15545.

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 129 matching lines @@
 }
 
 
 double ceiling(double x) {
   return ceil(x);
 }
 
 
 static Mutex* limit_mutex = NULL;
 
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
 static void MemMoveWrapper(void* dest, const void* src, size_t size) {
   memmove(dest, src, size);
 }
 
+
 // Initialize to library version so we can call this at any time during startup.
 static OS::MemMoveFunction memmove_function = &MemMoveWrapper;
 
 // Defined in codegen-ia32.cc.
 OS::MemMoveFunction CreateMemMoveFunction();
 
 // 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
 
 #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  // 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
@@ skipping 123 matching lines @@
   // allows access to both a FILETIME and an integer representation of
   // the timestamp.
   union TimeStamp {
     FILETIME ft_;
     int64_t t_;
   };
 
   TimeStamp time_;
 };
 
+
 // Static variables.
 bool Time::tz_initialized_ = false;
 TIME_ZONE_INFORMATION Time::tzinfo_;
 char Time::std_tz_name_[kTzNameSize];
 char Time::dst_tz_name_[kTzNameSize];
 
 
 // Initialize timestamp to start of epoc.
 Time::Time() {
   t() = 0;
@@ skipping 239 matching lines @@
   // Return the standard or DST time zone name based on whether daylight
   // saving is in effect at the given time.
   return InDST() ? dst_tz_name_ : std_tz_name_;
 }
 
 
 void OS::PostSetUp() {
   // Math functions depend on CPU features therefore they are initialized after
   // CPU.
   MathSetup();
-#if defined(V8_TARGET_ARCH_IA32)
+#if V8_TARGET_ARCH_IA32
   OS::MemMoveFunction generated_memmove = CreateMemMoveFunction();
   if (generated_memmove != NULL) {
     memmove_function = generated_memmove;
   }
 #endif
 }
 
 
 // Returns the accumulated user time for thread.
 int OS::GetUserTime(uint32_t* secs,  uint32_t* usecs) {
@@ skipping 15 matching lines @@
 
 
 // Returns current time as the number of milliseconds since
 // 00:00:00 UTC, January 1, 1970.
 double OS::TimeCurrentMillis() {
   Time t;
   t.SetToCurrentTime();
   return t.ToJSTime();
 }
 
+
 // Returns the tickcounter based on timeGetTime.
 int64_t OS::Ticks() {
   return timeGetTime() * 1000;  // Convert to microseconds.
 }
 
 
 // Returns a string identifying the current timezone taking into
 // account daylight saving.
 const char* OS::LocalTimezone(double time) {
   return Time(time).LocalTimezone();
@@ skipping 813 matching lines @@
       }
     }
 
     frames_count++;
   }
 
   // Return the number of frames filled in.
   return frames_count;
 }
 
+
 // Restore warnings to previous settings.
 #pragma warning(pop)
 
 #else  // __MINGW32__
 void OS::LogSharedLibraryAddresses() { }
 void OS::SignalCodeMovingGC() { }
 int OS::StackWalk(Vector<OS::StackFrame> frames) { return 0; }
 #endif  // __MINGW32__
 
 
@@ skipping 10 matching lines @@
   return *reinterpret_cast<const double*>(&nanval);
 #else  // _MSC_VER
   return NAN;
 #endif  // _MSC_VER
 }
 
 
 int OS::ActivationFrameAlignment() {
 #ifdef _WIN64
   return 16;  // Windows 64-bit ABI requires the stack to be 16-byte aligned.
+#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) { }
 
 
 VirtualMemory::VirtualMemory(size_t size)
@@ skipping 489 matching lines @@
   limit_mutex = CreateMutex();
 }
 
 
 void OS::TearDown() {
   delete limit_mutex;
 }
 
 
 } }  // namespace v8::internal