Revert "Cross-compiling from Linux to Android requires -lrt for the host toolset.", "Fix Visual Stu…

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 20 matching lines @@
 // on Windows XP. Make sure MINGW_HAS_SECURE_API is not defined to
 // disable definition of secure API functions in standard headers that
 // would conflict with our own implementation.
 #ifdef __MINGW32__
 #include <_mingw.h>
 #ifdef MINGW_HAS_SECURE_API
 #undef MINGW_HAS_SECURE_API
 #endif  // MINGW_HAS_SECURE_API
 #endif  // __MINGW32__
 
+#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"
 
 #ifdef _MSC_VER
@@ skipping 187 matching lines @@
   init_fast_sqrt_function();
 }
 
 
 // ----------------------------------------------------------------------------
 // The Time class represents time on win32. A timestamp is represented as
 // a 64-bit integer in 100 nanoseconds since January 1, 1601 (UTC). JavaScript
 // timestamps are represented as a doubles in milliseconds since 00:00:00 UTC,
 // January 1, 1970.
 
-class Win32Time {
+class Time {
  public:
   // Constructors.
-  explicit Win32Time(double jstime);
-  Win32Time(int year, int mon, int day, int hour, int min, int sec);
+  Time();
+  explicit Time(double jstime);
+  Time(int year, int mon, int day, int hour, int min, int sec);
 
   // Convert timestamp to JavaScript representation.
   double ToJSTime();
 
+  // Set timestamp to current time.
+  void SetToCurrentTime();
+
   // Returns the local timezone offset in milliseconds east of UTC. This is
   // the number of milliseconds you must add to UTC to get local time, i.e.
   // LocalOffset(CET) = 3600000 and LocalOffset(PST) = -28800000. This
   // routine also takes into account whether daylight saving is effect
   // at the time.
   int64_t LocalOffset();
 
   // Returns the daylight savings time offset for the time in milliseconds.
   int64_t DaylightSavingsOffset();
 
@@ skipping 21 matching lines @@
 
   // Initialize the timezone information (if not already done).
   static void TzSet();
 
   // Guess the name of the timezone from the bias.
   static const char* GuessTimezoneNameFromBias(int bias);
 
   // Return whether or not daylight savings time is in effect at this time.
   bool InDST();
 
+  // Return the difference (in milliseconds) between this timestamp and
+  // another timestamp.
+  int64_t Diff(Time* other);
+
   // Accessor for FILETIME representation.
   FILETIME& ft() { return time_.ft_; }
 
   // Accessor for integer representation.
   int64_t& t() { return time_.t_; }
 
   // Although win32 uses 64-bit integers for representing timestamps,
   // these are packed into a FILETIME structure. The FILETIME structure
   // is just a struct representing a 64-bit integer. The TimeStamp union
   // 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 Win32Time::tz_initialized_ = false;
-TIME_ZONE_INFORMATION Win32Time::tzinfo_;
-char Win32Time::std_tz_name_[kTzNameSize];
-char Win32Time::dst_tz_name_[kTzNameSize];
+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;
+}
 
 
 // Initialize timestamp from a JavaScript timestamp.
-Win32Time::Win32Time(double jstime) {
+Time::Time(double jstime) {
   t() = static_cast<int64_t>(jstime) * kTimeScaler + kTimeEpoc;
 }
 
 
 // Initialize timestamp from date/time components.
-Win32Time::Win32Time(int year, int mon, int day, int hour, int min, int sec) {
+Time::Time(int year, int mon, int day, int hour, int min, int sec) {
   SYSTEMTIME st;
   st.wYear = year;
   st.wMonth = mon;
   st.wDay = day;
   st.wHour = hour;
   st.wMinute = min;
   st.wSecond = sec;
   st.wMilliseconds = 0;
   SystemTimeToFileTime(&st, &ft());
 }
 
 
 // Convert timestamp to JavaScript timestamp.
-double Win32Time::ToJSTime() {
+double Time::ToJSTime() {
   return static_cast<double>((t() - kTimeEpoc) / kTimeScaler);
 }
 
 
 // Guess the name of the timezone from the bias.
 // The guess is very biased towards the northern hemisphere.
-const char* Win32Time::GuessTimezoneNameFromBias(int bias) {
+const char* Time::GuessTimezoneNameFromBias(int bias) {
   static const int kHour = 60;
   switch (-bias) {
     case -9*kHour: return "Alaska";
     case -8*kHour: return "Pacific";
     case -7*kHour: return "Mountain";
     case -6*kHour: return "Central";
     case -5*kHour: return "Eastern";
     case -4*kHour: return "Atlantic";
     case  0*kHour: return "GMT";
     case +1*kHour: return "Central Europe";
     case +2*kHour: return "Eastern Europe";
     case +3*kHour: return "Russia";
     case +5*kHour + 30: return "India";
     case +8*kHour: return "China";
     case +9*kHour: return "Japan";
     case +12*kHour: return "New Zealand";
     default: return "Local";
   }
 }
 
 
 // Initialize timezone information. The timezone information is obtained from
 // windows. If we cannot get the timezone information we fall back to CET.
 // Please notice that this code is not thread-safe.
-void Win32Time::TzSet() {
+void Time::TzSet() {
   // Just return if timezone information has already been initialized.
   if (tz_initialized_) return;
 
   // Initialize POSIX time zone data.
   _tzset();
   // Obtain timezone information from operating system.
   memset(&tzinfo_, 0, sizeof(tzinfo_));
   if (GetTimeZoneInformation(&tzinfo_) == TIME_ZONE_ID_INVALID) {
     // If we cannot get timezone information we fall back to CET.
     tzinfo_.Bias = -60;
@@ skipping 28 matching lines @@
     OS::SNPrintF(Vector<char>(dst_tz_name_, kTzNameSize - 1),
                  "%s Daylight Time",
                  GuessTimezoneNameFromBias(tzinfo_.Bias));
   }
 
   // Timezone information initialized.
   tz_initialized_ = true;
 }
 
 
+// Return the difference in milliseconds between this and another timestamp.
+int64_t Time::Diff(Time* other) {
+  return (t() - other->t()) / kTimeScaler;
+}
+
+
+// Set timestamp to current time.
+void Time::SetToCurrentTime() {
+  // The default GetSystemTimeAsFileTime has a ~15.5ms resolution.
+  // Because we're fast, we like fast timers which have at least a
+  // 1ms resolution.
+  //
+  // timeGetTime() provides 1ms granularity when combined with
+  // timeBeginPeriod().  If the host application for v8 wants fast
+  // timers, it can use timeBeginPeriod to increase the resolution.
+  //
+  // Using timeGetTime() has a drawback because it is a 32bit value
+  // and hence rolls-over every ~49days.
+  //
+  // To use the clock, we use GetSystemTimeAsFileTime as our base;
+  // and then use timeGetTime to extrapolate current time from the
+  // start time.  To deal with rollovers, we resync the clock
+  // any time when more than kMaxClockElapsedTime has passed or
+  // whenever timeGetTime creates a rollover.
+
+  static bool initialized = false;
+  static TimeStamp init_time;
+  static DWORD init_ticks;
+  static const int64_t kHundredNanosecondsPerSecond = 10000000;
+  static const int64_t kMaxClockElapsedTime =
+      60*kHundredNanosecondsPerSecond;  // 1 minute
+
+  // If we are uninitialized, we need to resync the clock.
+  bool needs_resync = !initialized;
+
+  // Get the current time.
+  TimeStamp time_now;
+  GetSystemTimeAsFileTime(&time_now.ft_);
+  DWORD ticks_now = timeGetTime();
+
+  // Check if we need to resync due to clock rollover.
+  needs_resync |= ticks_now < init_ticks;
+
+  // Check if we need to resync due to elapsed time.
+  needs_resync |= (time_now.t_ - init_time.t_) > kMaxClockElapsedTime;
+
+  // Check if we need to resync due to backwards time change.
+  needs_resync |= time_now.t_ < init_time.t_;
+
+  // Resync the clock if necessary.
+  if (needs_resync) {
+    GetSystemTimeAsFileTime(&init_time.ft_);
+    init_ticks = ticks_now = timeGetTime();
+    initialized = true;
+  }
+
+  // Finally, compute the actual time.  Why is this so hard.
+  DWORD elapsed = ticks_now - init_ticks;
+  this->time_.t_ = init_time.t_ + (static_cast<int64_t>(elapsed) * 10000);
+}
+
+
 // Return the local timezone offset in milliseconds east of UTC. This
 // takes into account whether daylight saving is in effect at the time.
 // Only times in the 32-bit Unix range may be passed to this function.
 // Also, adding the time-zone offset to the input must not overflow.
 // The function EquivalentTime() in date.js guarantees this.
-int64_t Win32Time::LocalOffset() {
+int64_t Time::LocalOffset() {
   // Initialize timezone information, if needed.
   TzSet();
 
-  Win32Time rounded_to_second(*this);
+  Time rounded_to_second(*this);
   rounded_to_second.t() = rounded_to_second.t() / 1000 / kTimeScaler *
       1000 * kTimeScaler;
   // Convert to local time using POSIX localtime function.
   // Windows XP Service Pack 3 made SystemTimeToTzSpecificLocalTime()
   // very slow.  Other browsers use localtime().
 
   // Convert from JavaScript milliseconds past 1/1/1970 0:00:00 to
   // POSIX seconds past 1/1/1970 0:00:00.
   double unchecked_posix_time = rounded_to_second.ToJSTime() / 1000;
   if (unchecked_posix_time > INT_MAX || unchecked_posix_time < 0) {
@@ skipping 10 matching lines @@
     return (tzinfo_.Bias + tzinfo_.DaylightBias) * -kMsPerMinute;
   } else if (posix_local_time_struct.tm_isdst == 0) {
     return (tzinfo_.Bias + tzinfo_.StandardBias) * -kMsPerMinute;
   } else {
     return tzinfo_.Bias * -kMsPerMinute;
   }
 }
 
 
 // Return whether or not daylight savings time is in effect at this time.
-bool Win32Time::InDST() {
+bool Time::InDST() {
   // Initialize timezone information, if needed.
   TzSet();
 
   // Determine if DST is in effect at the specified time.
   bool in_dst = false;
   if (tzinfo_.StandardDate.wMonth != 0 || tzinfo_.DaylightDate.wMonth != 0) {
     // Get the local timezone offset for the timestamp in milliseconds.
     int64_t offset = LocalOffset();
 
     // Compute the offset for DST. The bias parameters in the timezone info
     // are specified in minutes. These must be converted to milliseconds.
     int64_t dstofs = -(tzinfo_.Bias + tzinfo_.DaylightBias) * kMsPerMinute;
 
     // If the local time offset equals the timezone bias plus the daylight
     // bias then DST is in effect.
     in_dst = offset == dstofs;
   }
 
   return in_dst;
 }
 
 
 // Return the daylight savings time offset for this time.
-int64_t Win32Time::DaylightSavingsOffset() {
+int64_t Time::DaylightSavingsOffset() {
   return InDST() ? 60 * kMsPerMinute : 0;
 }
 
 
 // Returns a string identifying the current timezone for the
 // timestamp taking into account daylight saving.
-char* Win32Time::LocalTimezone() {
+char* Time::LocalTimezone() {
   // 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();
@@ skipping 21 matching lines @@
   // Convert to seconds and microseconds
   *secs = static_cast<uint32_t>(usertime / 1000000);
   *usecs = static_cast<uint32_t>(usertime % 1000000);
   return 0;
 }
 
 
 // Returns current time as the number of milliseconds since
 // 00:00:00 UTC, January 1, 1970.
 double OS::TimeCurrentMillis() {
-  return Time::Now().ToJsTime();
+  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 Win32Time(time).LocalTimezone();
+  return Time(time).LocalTimezone();
 }
 
 
 // Returns the local time offset in milliseconds east of UTC without
 // taking daylight savings time into account.
 double OS::LocalTimeOffset() {
   // Use current time, rounded to the millisecond.
-  Win32Time t(TimeCurrentMillis());
+  Time t(TimeCurrentMillis());
   // Time::LocalOffset inlcudes any daylight savings offset, so subtract it.
   return static_cast<double>(t.LocalOffset() - t.DaylightSavingsOffset());
 }
 
 
 // Returns the daylight savings offset in milliseconds for the given
 // time.
 double OS::DaylightSavingsOffset(double time) {
-  int64_t offset = Win32Time(time).DaylightSavingsOffset();
+  int64_t offset = Time(time).DaylightSavingsOffset();
   return static_cast<double>(offset);
 }
 
 
 int OS::GetLastError() {
   return ::GetLastError();
 }
 
 
 int OS::GetCurrentProcessId() {
@@ skipping 1326 matching lines @@
   limit_mutex = CreateMutex();
 }
 
 
 void OS::TearDown() {
   delete limit_mutex;
 }
 
 
 } }  // namespace v8::internal