platform-win32.cc revision 756813857a4c2a4d8ad2e805969d5768d3cf43a0
1// Copyright 2006-2008 the V8 project authors. All rights reserved. 2// Redistribution and use in source and binary forms, with or without 3// modification, are permitted provided that the following conditions are 4// met: 5// 6// * Redistributions of source code must retain the above copyright 7// notice, this list of conditions and the following disclaimer. 8// * Redistributions in binary form must reproduce the above 9// copyright notice, this list of conditions and the following 10// disclaimer in the documentation and/or other materials provided 11// with the distribution. 12// * Neither the name of Google Inc. nor the names of its 13// contributors may be used to endorse or promote products derived 14// from this software without specific prior written permission. 15// 16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 28// Platform specific code for Win32. 29#ifndef WIN32_LEAN_AND_MEAN 30// WIN32_LEAN_AND_MEAN implies NOCRYPT and NOGDI. 31#define WIN32_LEAN_AND_MEAN 32#endif 33#ifndef NOMINMAX 34#define NOMINMAX 35#endif 36#ifndef NOKERNEL 37#define NOKERNEL 38#endif 39#ifndef NOUSER 40#define NOUSER 41#endif 42#ifndef NOSERVICE 43#define NOSERVICE 44#endif 45#ifndef NOSOUND 46#define NOSOUND 47#endif 48#ifndef NOMCX 49#define NOMCX 50#endif 51// Require Windows XP or higher (this is required for the RtlCaptureContext 52// function to be present). 53#ifndef _WIN32_WINNT 54#define _WIN32_WINNT 0x501 55#endif 56 57#include <windows.h> 58 59#include <time.h> // For LocalOffset() implementation. 60#include <mmsystem.h> // For timeGetTime(). 61#ifdef __MINGW32__ 62// Require Windows XP or higher when compiling with MinGW. This is for MinGW 63// header files to expose getaddrinfo. 64#undef _WIN32_WINNT 65#define _WIN32_WINNT 0x501 66#endif // __MINGW32__ 67#ifndef __MINGW32__ 68#include <dbghelp.h> // For SymLoadModule64 and al. 69#endif // __MINGW32__ 70#include <limits.h> // For INT_MAX and al. 71#include <tlhelp32.h> // For Module32First and al. 72 73// These additional WIN32 includes have to be right here as the #undef's below 74// makes it impossible to have them elsewhere. 75#include <winsock2.h> 76#include <ws2tcpip.h> 77#include <process.h> // for _beginthreadex() 78#include <stdlib.h> 79 80#undef VOID 81#undef DELETE 82#undef IN 83#undef THIS 84#undef CONST 85#undef NAN 86#undef GetObject 87#undef CreateMutex 88#undef CreateSemaphore 89 90#include "v8.h" 91 92#include "platform.h" 93 94// Extra POSIX/ANSI routines for Win32 when when using Visual Studio C++. Please 95// refer to The Open Group Base Specification for specification of the correct 96// semantics for these functions. 97// (http://www.opengroup.org/onlinepubs/000095399/) 98#ifdef _MSC_VER 99 100namespace v8 { 101namespace internal { 102 103// Test for finite value - usually defined in math.h 104int isfinite(double x) { 105 return _finite(x); 106} 107 108} // namespace v8 109} // namespace internal 110 111// Test for a NaN (not a number) value - usually defined in math.h 112int isnan(double x) { 113 return _isnan(x); 114} 115 116 117// Test for infinity - usually defined in math.h 118int isinf(double x) { 119 return (_fpclass(x) & (_FPCLASS_PINF | _FPCLASS_NINF)) != 0; 120} 121 122 123// Test if x is less than y and both nominal - usually defined in math.h 124int isless(double x, double y) { 125 return isnan(x) || isnan(y) ? 0 : x < y; 126} 127 128 129// Test if x is greater than y and both nominal - usually defined in math.h 130int isgreater(double x, double y) { 131 return isnan(x) || isnan(y) ? 0 : x > y; 132} 133 134 135// Classify floating point number - usually defined in math.h 136int fpclassify(double x) { 137 // Use the MS-specific _fpclass() for classification. 138 int flags = _fpclass(x); 139 140 // Determine class. We cannot use a switch statement because 141 // the _FPCLASS_ constants are defined as flags. 142 if (flags & (_FPCLASS_PN | _FPCLASS_NN)) return FP_NORMAL; 143 if (flags & (_FPCLASS_PZ | _FPCLASS_NZ)) return FP_ZERO; 144 if (flags & (_FPCLASS_PD | _FPCLASS_ND)) return FP_SUBNORMAL; 145 if (flags & (_FPCLASS_PINF | _FPCLASS_NINF)) return FP_INFINITE; 146 147 // All cases should be covered by the code above. 148 ASSERT(flags & (_FPCLASS_SNAN | _FPCLASS_QNAN)); 149 return FP_NAN; 150} 151 152 153// Test sign - usually defined in math.h 154int signbit(double x) { 155 // We need to take care of the special case of both positive 156 // and negative versions of zero. 157 if (x == 0) 158 return _fpclass(x) & _FPCLASS_NZ; 159 else 160 return x < 0; 161} 162 163 164// Case-insensitive bounded string comparisons. Use stricmp() on Win32. Usually 165// defined in strings.h. 166int strncasecmp(const char* s1, const char* s2, int n) { 167 return _strnicmp(s1, s2, n); 168} 169 170#endif // _MSC_VER 171 172 173// Extra functions for MinGW. Most of these are the _s functions which are in 174// the Microsoft Visual Studio C++ CRT. 175#ifdef __MINGW32__ 176 177int localtime_s(tm* out_tm, const time_t* time) { 178 tm* posix_local_time_struct = localtime(time); 179 if (posix_local_time_struct == NULL) return 1; 180 *out_tm = *posix_local_time_struct; 181 return 0; 182} 183 184 185// Not sure this the correct interpretation of _mkgmtime 186time_t _mkgmtime(tm* timeptr) { 187 return mktime(timeptr); 188} 189 190 191int fopen_s(FILE** pFile, const char* filename, const char* mode) { 192 *pFile = fopen(filename, mode); 193 return *pFile != NULL ? 0 : 1; 194} 195 196 197int _vsnprintf_s(char* buffer, size_t sizeOfBuffer, size_t count, 198 const char* format, va_list argptr) { 199 return _vsnprintf(buffer, sizeOfBuffer, format, argptr); 200} 201#define _TRUNCATE 0 202 203 204int strncpy_s(char* strDest, size_t numberOfElements, 205 const char* strSource, size_t count) { 206 strncpy(strDest, strSource, count); 207 return 0; 208} 209 210#endif // __MINGW32__ 211 212// Generate a pseudo-random number in the range 0-2^31-1. Usually 213// defined in stdlib.h. Missing in both Microsoft Visual Studio C++ and MinGW. 214int random() { 215 return rand(); 216} 217 218 219namespace v8 { 220namespace internal { 221 222double ceiling(double x) { 223 return ceil(x); 224} 225 226#ifdef _WIN64 227typedef double (*ModuloFunction)(double, double); 228 229// Defined in codegen-x64.cc. 230ModuloFunction CreateModuloFunction(); 231 232double modulo(double x, double y) { 233 static ModuloFunction function = CreateModuloFunction(); 234 return function(x, y); 235} 236#else // Win32 237 238double modulo(double x, double y) { 239 // Workaround MS fmod bugs. ECMA-262 says: 240 // dividend is finite and divisor is an infinity => result equals dividend 241 // dividend is a zero and divisor is nonzero finite => result equals dividend 242 if (!(isfinite(x) && (!isfinite(y) && !isnan(y))) && 243 !(x == 0 && (y != 0 && isfinite(y)))) { 244 x = fmod(x, y); 245 } 246 return x; 247} 248 249#endif // _WIN64 250 251// ---------------------------------------------------------------------------- 252// The Time class represents time on win32. A timestamp is represented as 253// a 64-bit integer in 100 nano-seconds since January 1, 1601 (UTC). JavaScript 254// timestamps are represented as a doubles in milliseconds since 00:00:00 UTC, 255// January 1, 1970. 256 257class Time { 258 public: 259 // Constructors. 260 Time(); 261 explicit Time(double jstime); 262 Time(int year, int mon, int day, int hour, int min, int sec); 263 264 // Convert timestamp to JavaScript representation. 265 double ToJSTime(); 266 267 // Set timestamp to current time. 268 void SetToCurrentTime(); 269 270 // Returns the local timezone offset in milliseconds east of UTC. This is 271 // the number of milliseconds you must add to UTC to get local time, i.e. 272 // LocalOffset(CET) = 3600000 and LocalOffset(PST) = -28800000. This 273 // routine also takes into account whether daylight saving is effect 274 // at the time. 275 int64_t LocalOffset(); 276 277 // Returns the daylight savings time offset for the time in milliseconds. 278 int64_t DaylightSavingsOffset(); 279 280 // Returns a string identifying the current timezone for the 281 // timestamp taking into account daylight saving. 282 char* LocalTimezone(); 283 284 private: 285 // Constants for time conversion. 286 static const int64_t kTimeEpoc = 116444736000000000LL; 287 static const int64_t kTimeScaler = 10000; 288 static const int64_t kMsPerMinute = 60000; 289 290 // Constants for timezone information. 291 static const int kTzNameSize = 128; 292 static const bool kShortTzNames = false; 293 294 // Timezone information. We need to have static buffers for the 295 // timezone names because we return pointers to these in 296 // LocalTimezone(). 297 static bool tz_initialized_; 298 static TIME_ZONE_INFORMATION tzinfo_; 299 static char std_tz_name_[kTzNameSize]; 300 static char dst_tz_name_[kTzNameSize]; 301 302 // Initialize the timezone information (if not already done). 303 static void TzSet(); 304 305 // Guess the name of the timezone from the bias. 306 static const char* GuessTimezoneNameFromBias(int bias); 307 308 // Return whether or not daylight savings time is in effect at this time. 309 bool InDST(); 310 311 // Return the difference (in milliseconds) between this timestamp and 312 // another timestamp. 313 int64_t Diff(Time* other); 314 315 // Accessor for FILETIME representation. 316 FILETIME& ft() { return time_.ft_; } 317 318 // Accessor for integer representation. 319 int64_t& t() { return time_.t_; } 320 321 // Although win32 uses 64-bit integers for representing timestamps, 322 // these are packed into a FILETIME structure. The FILETIME structure 323 // is just a struct representing a 64-bit integer. The TimeStamp union 324 // allows access to both a FILETIME and an integer representation of 325 // the timestamp. 326 union TimeStamp { 327 FILETIME ft_; 328 int64_t t_; 329 }; 330 331 TimeStamp time_; 332}; 333 334// Static variables. 335bool Time::tz_initialized_ = false; 336TIME_ZONE_INFORMATION Time::tzinfo_; 337char Time::std_tz_name_[kTzNameSize]; 338char Time::dst_tz_name_[kTzNameSize]; 339 340 341// Initialize timestamp to start of epoc. 342Time::Time() { 343 t() = 0; 344} 345 346 347// Initialize timestamp from a JavaScript timestamp. 348Time::Time(double jstime) { 349 t() = static_cast<int64_t>(jstime) * kTimeScaler + kTimeEpoc; 350} 351 352 353// Initialize timestamp from date/time components. 354Time::Time(int year, int mon, int day, int hour, int min, int sec) { 355 SYSTEMTIME st; 356 st.wYear = year; 357 st.wMonth = mon; 358 st.wDay = day; 359 st.wHour = hour; 360 st.wMinute = min; 361 st.wSecond = sec; 362 st.wMilliseconds = 0; 363 SystemTimeToFileTime(&st, &ft()); 364} 365 366 367// Convert timestamp to JavaScript timestamp. 368double Time::ToJSTime() { 369 return static_cast<double>((t() - kTimeEpoc) / kTimeScaler); 370} 371 372 373// Guess the name of the timezone from the bias. 374// The guess is very biased towards the northern hemisphere. 375const char* Time::GuessTimezoneNameFromBias(int bias) { 376 static const int kHour = 60; 377 switch (-bias) { 378 case -9*kHour: return "Alaska"; 379 case -8*kHour: return "Pacific"; 380 case -7*kHour: return "Mountain"; 381 case -6*kHour: return "Central"; 382 case -5*kHour: return "Eastern"; 383 case -4*kHour: return "Atlantic"; 384 case 0*kHour: return "GMT"; 385 case +1*kHour: return "Central Europe"; 386 case +2*kHour: return "Eastern Europe"; 387 case +3*kHour: return "Russia"; 388 case +5*kHour + 30: return "India"; 389 case +8*kHour: return "China"; 390 case +9*kHour: return "Japan"; 391 case +12*kHour: return "New Zealand"; 392 default: return "Local"; 393 } 394} 395 396 397// Initialize timezone information. The timezone information is obtained from 398// windows. If we cannot get the timezone information we fall back to CET. 399// Please notice that this code is not thread-safe. 400void Time::TzSet() { 401 // Just return if timezone information has already been initialized. 402 if (tz_initialized_) return; 403 404 // Initialize POSIX time zone data. 405 _tzset(); 406 // Obtain timezone information from operating system. 407 memset(&tzinfo_, 0, sizeof(tzinfo_)); 408 if (GetTimeZoneInformation(&tzinfo_) == TIME_ZONE_ID_INVALID) { 409 // If we cannot get timezone information we fall back to CET. 410 tzinfo_.Bias = -60; 411 tzinfo_.StandardDate.wMonth = 10; 412 tzinfo_.StandardDate.wDay = 5; 413 tzinfo_.StandardDate.wHour = 3; 414 tzinfo_.StandardBias = 0; 415 tzinfo_.DaylightDate.wMonth = 3; 416 tzinfo_.DaylightDate.wDay = 5; 417 tzinfo_.DaylightDate.wHour = 2; 418 tzinfo_.DaylightBias = -60; 419 } 420 421 // Make standard and DST timezone names. 422 OS::SNPrintF(Vector<char>(std_tz_name_, kTzNameSize), 423 "%S", 424 tzinfo_.StandardName); 425 std_tz_name_[kTzNameSize - 1] = '\0'; 426 OS::SNPrintF(Vector<char>(dst_tz_name_, kTzNameSize), 427 "%S", 428 tzinfo_.DaylightName); 429 dst_tz_name_[kTzNameSize - 1] = '\0'; 430 431 // If OS returned empty string or resource id (like "@tzres.dll,-211") 432 // simply guess the name from the UTC bias of the timezone. 433 // To properly resolve the resource identifier requires a library load, 434 // which is not possible in a sandbox. 435 if (std_tz_name_[0] == '\0' || std_tz_name_[0] == '@') { 436 OS::SNPrintF(Vector<char>(std_tz_name_, kTzNameSize - 1), 437 "%s Standard Time", 438 GuessTimezoneNameFromBias(tzinfo_.Bias)); 439 } 440 if (dst_tz_name_[0] == '\0' || dst_tz_name_[0] == '@') { 441 OS::SNPrintF(Vector<char>(dst_tz_name_, kTzNameSize - 1), 442 "%s Daylight Time", 443 GuessTimezoneNameFromBias(tzinfo_.Bias)); 444 } 445 446 // Timezone information initialized. 447 tz_initialized_ = true; 448} 449 450 451// Return the difference in milliseconds between this and another timestamp. 452int64_t Time::Diff(Time* other) { 453 return (t() - other->t()) / kTimeScaler; 454} 455 456 457// Set timestamp to current time. 458void Time::SetToCurrentTime() { 459 // The default GetSystemTimeAsFileTime has a ~15.5ms resolution. 460 // Because we're fast, we like fast timers which have at least a 461 // 1ms resolution. 462 // 463 // timeGetTime() provides 1ms granularity when combined with 464 // timeBeginPeriod(). If the host application for v8 wants fast 465 // timers, it can use timeBeginPeriod to increase the resolution. 466 // 467 // Using timeGetTime() has a drawback because it is a 32bit value 468 // and hence rolls-over every ~49days. 469 // 470 // To use the clock, we use GetSystemTimeAsFileTime as our base; 471 // and then use timeGetTime to extrapolate current time from the 472 // start time. To deal with rollovers, we resync the clock 473 // any time when more than kMaxClockElapsedTime has passed or 474 // whenever timeGetTime creates a rollover. 475 476 static bool initialized = false; 477 static TimeStamp init_time; 478 static DWORD init_ticks; 479 static const int64_t kHundredNanosecondsPerSecond = 10000000; 480 static const int64_t kMaxClockElapsedTime = 481 60*kHundredNanosecondsPerSecond; // 1 minute 482 483 // If we are uninitialized, we need to resync the clock. 484 bool needs_resync = !initialized; 485 486 // Get the current time. 487 TimeStamp time_now; 488 GetSystemTimeAsFileTime(&time_now.ft_); 489 DWORD ticks_now = timeGetTime(); 490 491 // Check if we need to resync due to clock rollover. 492 needs_resync |= ticks_now < init_ticks; 493 494 // Check if we need to resync due to elapsed time. 495 needs_resync |= (time_now.t_ - init_time.t_) > kMaxClockElapsedTime; 496 497 // Resync the clock if necessary. 498 if (needs_resync) { 499 GetSystemTimeAsFileTime(&init_time.ft_); 500 init_ticks = ticks_now = timeGetTime(); 501 initialized = true; 502 } 503 504 // Finally, compute the actual time. Why is this so hard. 505 DWORD elapsed = ticks_now - init_ticks; 506 this->time_.t_ = init_time.t_ + (static_cast<int64_t>(elapsed) * 10000); 507} 508 509 510// Return the local timezone offset in milliseconds east of UTC. This 511// takes into account whether daylight saving is in effect at the time. 512// Only times in the 32-bit Unix range may be passed to this function. 513// Also, adding the time-zone offset to the input must not overflow. 514// The function EquivalentTime() in date.js guarantees this. 515int64_t Time::LocalOffset() { 516 // Initialize timezone information, if needed. 517 TzSet(); 518 519 Time rounded_to_second(*this); 520 rounded_to_second.t() = rounded_to_second.t() / 1000 / kTimeScaler * 521 1000 * kTimeScaler; 522 // Convert to local time using POSIX localtime function. 523 // Windows XP Service Pack 3 made SystemTimeToTzSpecificLocalTime() 524 // very slow. Other browsers use localtime(). 525 526 // Convert from JavaScript milliseconds past 1/1/1970 0:00:00 to 527 // POSIX seconds past 1/1/1970 0:00:00. 528 double unchecked_posix_time = rounded_to_second.ToJSTime() / 1000; 529 if (unchecked_posix_time > INT_MAX || unchecked_posix_time < 0) { 530 return 0; 531 } 532 // Because _USE_32BIT_TIME_T is defined, time_t is a 32-bit int. 533 time_t posix_time = static_cast<time_t>(unchecked_posix_time); 534 535 // Convert to local time, as struct with fields for day, hour, year, etc. 536 tm posix_local_time_struct; 537 if (localtime_s(&posix_local_time_struct, &posix_time)) return 0; 538 // Convert local time in struct to POSIX time as if it were a UTC time. 539 time_t local_posix_time = _mkgmtime(&posix_local_time_struct); 540 Time localtime(1000.0 * local_posix_time); 541 542 return localtime.Diff(&rounded_to_second); 543} 544 545 546// Return whether or not daylight savings time is in effect at this time. 547bool Time::InDST() { 548 // Initialize timezone information, if needed. 549 TzSet(); 550 551 // Determine if DST is in effect at the specified time. 552 bool in_dst = false; 553 if (tzinfo_.StandardDate.wMonth != 0 || tzinfo_.DaylightDate.wMonth != 0) { 554 // Get the local timezone offset for the timestamp in milliseconds. 555 int64_t offset = LocalOffset(); 556 557 // Compute the offset for DST. The bias parameters in the timezone info 558 // are specified in minutes. These must be converted to milliseconds. 559 int64_t dstofs = -(tzinfo_.Bias + tzinfo_.DaylightBias) * kMsPerMinute; 560 561 // If the local time offset equals the timezone bias plus the daylight 562 // bias then DST is in effect. 563 in_dst = offset == dstofs; 564 } 565 566 return in_dst; 567} 568 569 570// Return the daylight savings time offset for this time. 571int64_t Time::DaylightSavingsOffset() { 572 return InDST() ? 60 * kMsPerMinute : 0; 573} 574 575 576// Returns a string identifying the current timezone for the 577// timestamp taking into account daylight saving. 578char* Time::LocalTimezone() { 579 // Return the standard or DST time zone name based on whether daylight 580 // saving is in effect at the given time. 581 return InDST() ? dst_tz_name_ : std_tz_name_; 582} 583 584 585void OS::Setup() { 586 // Seed the random number generator. 587 // Convert the current time to a 64-bit integer first, before converting it 588 // to an unsigned. Going directly can cause an overflow and the seed to be 589 // set to all ones. The seed will be identical for different instances that 590 // call this setup code within the same millisecond. 591 uint64_t seed = static_cast<uint64_t>(TimeCurrentMillis()); 592 srand(static_cast<unsigned int>(seed)); 593} 594 595 596// Returns the accumulated user time for thread. 597int OS::GetUserTime(uint32_t* secs, uint32_t* usecs) { 598 FILETIME dummy; 599 uint64_t usertime; 600 601 // Get the amount of time that the thread has executed in user mode. 602 if (!GetThreadTimes(GetCurrentThread(), &dummy, &dummy, &dummy, 603 reinterpret_cast<FILETIME*>(&usertime))) return -1; 604 605 // Adjust the resolution to micro-seconds. 606 usertime /= 10; 607 608 // Convert to seconds and microseconds 609 *secs = static_cast<uint32_t>(usertime / 1000000); 610 *usecs = static_cast<uint32_t>(usertime % 1000000); 611 return 0; 612} 613 614 615// Returns current time as the number of milliseconds since 616// 00:00:00 UTC, January 1, 1970. 617double OS::TimeCurrentMillis() { 618 Time t; 619 t.SetToCurrentTime(); 620 return t.ToJSTime(); 621} 622 623// Returns the tickcounter based on timeGetTime. 624int64_t OS::Ticks() { 625 return timeGetTime() * 1000; // Convert to microseconds. 626} 627 628 629// Returns a string identifying the current timezone taking into 630// account daylight saving. 631const char* OS::LocalTimezone(double time) { 632 return Time(time).LocalTimezone(); 633} 634 635 636// Returns the local time offset in milliseconds east of UTC without 637// taking daylight savings time into account. 638double OS::LocalTimeOffset() { 639 // Use current time, rounded to the millisecond. 640 Time t(TimeCurrentMillis()); 641 // Time::LocalOffset inlcudes any daylight savings offset, so subtract it. 642 return static_cast<double>(t.LocalOffset() - t.DaylightSavingsOffset()); 643} 644 645 646// Returns the daylight savings offset in milliseconds for the given 647// time. 648double OS::DaylightSavingsOffset(double time) { 649 int64_t offset = Time(time).DaylightSavingsOffset(); 650 return static_cast<double>(offset); 651} 652 653 654int OS::GetLastError() { 655 return ::GetLastError(); 656} 657 658 659// ---------------------------------------------------------------------------- 660// Win32 console output. 661// 662// If a Win32 application is linked as a console application it has a normal 663// standard output and standard error. In this case normal printf works fine 664// for output. However, if the application is linked as a GUI application, 665// the process doesn't have a console, and therefore (debugging) output is lost. 666// This is the case if we are embedded in a windows program (like a browser). 667// In order to be able to get debug output in this case the the debugging 668// facility using OutputDebugString. This output goes to the active debugger 669// for the process (if any). Else the output can be monitored using DBMON.EXE. 670 671enum OutputMode { 672 UNKNOWN, // Output method has not yet been determined. 673 CONSOLE, // Output is written to stdout. 674 ODS // Output is written to debug facility. 675}; 676 677static OutputMode output_mode = UNKNOWN; // Current output mode. 678 679 680// Determine if the process has a console for output. 681static bool HasConsole() { 682 // Only check the first time. Eventual race conditions are not a problem, 683 // because all threads will eventually determine the same mode. 684 if (output_mode == UNKNOWN) { 685 // We cannot just check that the standard output is attached to a console 686 // because this would fail if output is redirected to a file. Therefore we 687 // say that a process does not have an output console if either the 688 // standard output handle is invalid or its file type is unknown. 689 if (GetStdHandle(STD_OUTPUT_HANDLE) != INVALID_HANDLE_VALUE && 690 GetFileType(GetStdHandle(STD_OUTPUT_HANDLE)) != FILE_TYPE_UNKNOWN) 691 output_mode = CONSOLE; 692 else 693 output_mode = ODS; 694 } 695 return output_mode == CONSOLE; 696} 697 698 699static void VPrintHelper(FILE* stream, const char* format, va_list args) { 700 if (HasConsole()) { 701 vfprintf(stream, format, args); 702 } else { 703 // It is important to use safe print here in order to avoid 704 // overflowing the buffer. We might truncate the output, but this 705 // does not crash. 706 EmbeddedVector<char, 4096> buffer; 707 OS::VSNPrintF(buffer, format, args); 708 OutputDebugStringA(buffer.start()); 709 } 710} 711 712 713FILE* OS::FOpen(const char* path, const char* mode) { 714 FILE* result; 715 if (fopen_s(&result, path, mode) == 0) { 716 return result; 717 } else { 718 return NULL; 719 } 720} 721 722 723// Open log file in binary mode to avoid /n -> /r/n conversion. 724const char* OS::LogFileOpenMode = "wb"; 725 726 727// Print (debug) message to console. 728void OS::Print(const char* format, ...) { 729 va_list args; 730 va_start(args, format); 731 VPrint(format, args); 732 va_end(args); 733} 734 735 736void OS::VPrint(const char* format, va_list args) { 737 VPrintHelper(stdout, format, args); 738} 739 740 741// Print error message to console. 742void OS::PrintError(const char* format, ...) { 743 va_list args; 744 va_start(args, format); 745 VPrintError(format, args); 746 va_end(args); 747} 748 749 750void OS::VPrintError(const char* format, va_list args) { 751 VPrintHelper(stderr, format, args); 752} 753 754 755int OS::SNPrintF(Vector<char> str, const char* format, ...) { 756 va_list args; 757 va_start(args, format); 758 int result = VSNPrintF(str, format, args); 759 va_end(args); 760 return result; 761} 762 763 764int OS::VSNPrintF(Vector<char> str, const char* format, va_list args) { 765 int n = _vsnprintf_s(str.start(), str.length(), _TRUNCATE, format, args); 766 // Make sure to zero-terminate the string if the output was 767 // truncated or if there was an error. 768 if (n < 0 || n >= str.length()) { 769 str[str.length() - 1] = '\0'; 770 return -1; 771 } else { 772 return n; 773 } 774} 775 776 777char* OS::StrChr(char* str, int c) { 778 return const_cast<char*>(strchr(str, c)); 779} 780 781 782void OS::StrNCpy(Vector<char> dest, const char* src, size_t n) { 783 int result = strncpy_s(dest.start(), dest.length(), src, n); 784 USE(result); 785 ASSERT(result == 0); 786} 787 788 789// We keep the lowest and highest addresses mapped as a quick way of 790// determining that pointers are outside the heap (used mostly in assertions 791// and verification). The estimate is conservative, ie, not all addresses in 792// 'allocated' space are actually allocated to our heap. The range is 793// [lowest, highest), inclusive on the low and and exclusive on the high end. 794static void* lowest_ever_allocated = reinterpret_cast<void*>(-1); 795static void* highest_ever_allocated = reinterpret_cast<void*>(0); 796 797 798static void UpdateAllocatedSpaceLimits(void* address, int size) { 799 lowest_ever_allocated = Min(lowest_ever_allocated, address); 800 highest_ever_allocated = 801 Max(highest_ever_allocated, 802 reinterpret_cast<void*>(reinterpret_cast<char*>(address) + size)); 803} 804 805 806bool OS::IsOutsideAllocatedSpace(void* pointer) { 807 if (pointer < lowest_ever_allocated || pointer >= highest_ever_allocated) 808 return true; 809 // Ask the Windows API 810 if (IsBadWritePtr(pointer, 1)) 811 return true; 812 return false; 813} 814 815 816// Get the system's page size used by VirtualAlloc() or the next power 817// of two. The reason for always returning a power of two is that the 818// rounding up in OS::Allocate expects that. 819static size_t GetPageSize() { 820 static size_t page_size = 0; 821 if (page_size == 0) { 822 SYSTEM_INFO info; 823 GetSystemInfo(&info); 824 page_size = RoundUpToPowerOf2(info.dwPageSize); 825 } 826 return page_size; 827} 828 829 830// The allocation alignment is the guaranteed alignment for 831// VirtualAlloc'ed blocks of memory. 832size_t OS::AllocateAlignment() { 833 static size_t allocate_alignment = 0; 834 if (allocate_alignment == 0) { 835 SYSTEM_INFO info; 836 GetSystemInfo(&info); 837 allocate_alignment = info.dwAllocationGranularity; 838 } 839 return allocate_alignment; 840} 841 842 843void* OS::Allocate(const size_t requested, 844 size_t* allocated, 845 bool is_executable) { 846 // The address range used to randomize RWX allocations in OS::Allocate 847 // Try not to map pages into the default range that windows loads DLLs 848 // Note: This does not guarantee RWX regions will be within the 849 // range kAllocationRandomAddressMin to kAllocationRandomAddressMax 850#ifdef V8_HOST_ARCH_64_BIT 851 static const intptr_t kAllocationRandomAddressMin = 0x0000000080000000; 852 static const intptr_t kAllocationRandomAddressMax = 0x000004FFFFFFFFFF; 853#else 854 static const intptr_t kAllocationRandomAddressMin = 0x04000000; 855 static const intptr_t kAllocationRandomAddressMax = 0x4FFFFFFF; 856#endif 857 858 // VirtualAlloc rounds allocated size to page size automatically. 859 size_t msize = RoundUp(requested, static_cast<int>(GetPageSize())); 860 intptr_t address = NULL; 861 862 // Windows XP SP2 allows Data Excution Prevention (DEP). 863 int prot = is_executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE; 864 865 // For exectutable pages try and randomize the allocation address 866 if (prot == PAGE_EXECUTE_READWRITE && msize >= Page::kPageSize) { 867 address = (V8::Random() << kPageSizeBits) | kAllocationRandomAddressMin; 868 address &= kAllocationRandomAddressMax; 869 } 870 871 LPVOID mbase = VirtualAlloc(reinterpret_cast<void *>(address), 872 msize, 873 MEM_COMMIT | MEM_RESERVE, 874 prot); 875 if (mbase == NULL && address != NULL) 876 mbase = VirtualAlloc(NULL, msize, MEM_COMMIT | MEM_RESERVE, prot); 877 878 if (mbase == NULL) { 879 LOG(StringEvent("OS::Allocate", "VirtualAlloc failed")); 880 return NULL; 881 } 882 883 ASSERT(IsAligned(reinterpret_cast<size_t>(mbase), OS::AllocateAlignment())); 884 885 *allocated = msize; 886 UpdateAllocatedSpaceLimits(mbase, static_cast<int>(msize)); 887 return mbase; 888} 889 890 891void OS::Free(void* address, const size_t size) { 892 // TODO(1240712): VirtualFree has a return value which is ignored here. 893 VirtualFree(address, 0, MEM_RELEASE); 894 USE(size); 895} 896 897 898#ifdef ENABLE_HEAP_PROTECTION 899 900void OS::Protect(void* address, size_t size) { 901 // TODO(1240712): VirtualProtect has a return value which is ignored here. 902 DWORD old_protect; 903 VirtualProtect(address, size, PAGE_READONLY, &old_protect); 904} 905 906 907void OS::Unprotect(void* address, size_t size, bool is_executable) { 908 // TODO(1240712): VirtualProtect has a return value which is ignored here. 909 DWORD new_protect = is_executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE; 910 DWORD old_protect; 911 VirtualProtect(address, size, new_protect, &old_protect); 912} 913 914#endif 915 916 917void OS::Sleep(int milliseconds) { 918 ::Sleep(milliseconds); 919} 920 921 922void OS::Abort() { 923 if (!IsDebuggerPresent()) { 924#ifdef _MSC_VER 925 // Make the MSVCRT do a silent abort. 926 _set_abort_behavior(0, _WRITE_ABORT_MSG); 927 _set_abort_behavior(0, _CALL_REPORTFAULT); 928#endif // _MSC_VER 929 abort(); 930 } else { 931 DebugBreak(); 932 } 933} 934 935 936void OS::DebugBreak() { 937#ifdef _MSC_VER 938 __debugbreak(); 939#else 940 ::DebugBreak(); 941#endif 942} 943 944 945class Win32MemoryMappedFile : public OS::MemoryMappedFile { 946 public: 947 Win32MemoryMappedFile(HANDLE file, HANDLE file_mapping, void* memory) 948 : file_(file), file_mapping_(file_mapping), memory_(memory) { } 949 virtual ~Win32MemoryMappedFile(); 950 virtual void* memory() { return memory_; } 951 private: 952 HANDLE file_; 953 HANDLE file_mapping_; 954 void* memory_; 955}; 956 957 958OS::MemoryMappedFile* OS::MemoryMappedFile::create(const char* name, int size, 959 void* initial) { 960 // Open a physical file 961 HANDLE file = CreateFileA(name, GENERIC_READ | GENERIC_WRITE, 962 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, 0, NULL); 963 if (file == NULL) return NULL; 964 // Create a file mapping for the physical file 965 HANDLE file_mapping = CreateFileMapping(file, NULL, 966 PAGE_READWRITE, 0, static_cast<DWORD>(size), NULL); 967 if (file_mapping == NULL) return NULL; 968 // Map a view of the file into memory 969 void* memory = MapViewOfFile(file_mapping, FILE_MAP_ALL_ACCESS, 0, 0, size); 970 if (memory) memmove(memory, initial, size); 971 return new Win32MemoryMappedFile(file, file_mapping, memory); 972} 973 974 975Win32MemoryMappedFile::~Win32MemoryMappedFile() { 976 if (memory_ != NULL) 977 UnmapViewOfFile(memory_); 978 CloseHandle(file_mapping_); 979 CloseHandle(file_); 980} 981 982 983// The following code loads functions defined in DbhHelp.h and TlHelp32.h 984// dynamically. This is to avoid being depending on dbghelp.dll and 985// tlhelp32.dll when running (the functions in tlhelp32.dll have been moved to 986// kernel32.dll at some point so loading functions defines in TlHelp32.h 987// dynamically might not be necessary any more - for some versions of Windows?). 988 989// Function pointers to functions dynamically loaded from dbghelp.dll. 990#define DBGHELP_FUNCTION_LIST(V) \ 991 V(SymInitialize) \ 992 V(SymGetOptions) \ 993 V(SymSetOptions) \ 994 V(SymGetSearchPath) \ 995 V(SymLoadModule64) \ 996 V(StackWalk64) \ 997 V(SymGetSymFromAddr64) \ 998 V(SymGetLineFromAddr64) \ 999 V(SymFunctionTableAccess64) \ 1000 V(SymGetModuleBase64) 1001 1002// Function pointers to functions dynamically loaded from dbghelp.dll. 1003#define TLHELP32_FUNCTION_LIST(V) \ 1004 V(CreateToolhelp32Snapshot) \ 1005 V(Module32FirstW) \ 1006 V(Module32NextW) 1007 1008// Define the decoration to use for the type and variable name used for 1009// dynamically loaded DLL function.. 1010#define DLL_FUNC_TYPE(name) _##name##_ 1011#define DLL_FUNC_VAR(name) _##name 1012 1013// Define the type for each dynamically loaded DLL function. The function 1014// definitions are copied from DbgHelp.h and TlHelp32.h. The IN and VOID macros 1015// from the Windows include files are redefined here to have the function 1016// definitions to be as close to the ones in the original .h files as possible. 1017#ifndef IN 1018#define IN 1019#endif 1020#ifndef VOID 1021#define VOID void 1022#endif 1023 1024// DbgHelp isn't supported on MinGW yet 1025#ifndef __MINGW32__ 1026// DbgHelp.h functions. 1027typedef BOOL (__stdcall *DLL_FUNC_TYPE(SymInitialize))(IN HANDLE hProcess, 1028 IN PSTR UserSearchPath, 1029 IN BOOL fInvadeProcess); 1030typedef DWORD (__stdcall *DLL_FUNC_TYPE(SymGetOptions))(VOID); 1031typedef DWORD (__stdcall *DLL_FUNC_TYPE(SymSetOptions))(IN DWORD SymOptions); 1032typedef BOOL (__stdcall *DLL_FUNC_TYPE(SymGetSearchPath))( 1033 IN HANDLE hProcess, 1034 OUT PSTR SearchPath, 1035 IN DWORD SearchPathLength); 1036typedef DWORD64 (__stdcall *DLL_FUNC_TYPE(SymLoadModule64))( 1037 IN HANDLE hProcess, 1038 IN HANDLE hFile, 1039 IN PSTR ImageName, 1040 IN PSTR ModuleName, 1041 IN DWORD64 BaseOfDll, 1042 IN DWORD SizeOfDll); 1043typedef BOOL (__stdcall *DLL_FUNC_TYPE(StackWalk64))( 1044 DWORD MachineType, 1045 HANDLE hProcess, 1046 HANDLE hThread, 1047 LPSTACKFRAME64 StackFrame, 1048 PVOID ContextRecord, 1049 PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, 1050 PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine, 1051 PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine, 1052 PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress); 1053typedef BOOL (__stdcall *DLL_FUNC_TYPE(SymGetSymFromAddr64))( 1054 IN HANDLE hProcess, 1055 IN DWORD64 qwAddr, 1056 OUT PDWORD64 pdwDisplacement, 1057 OUT PIMAGEHLP_SYMBOL64 Symbol); 1058typedef BOOL (__stdcall *DLL_FUNC_TYPE(SymGetLineFromAddr64))( 1059 IN HANDLE hProcess, 1060 IN DWORD64 qwAddr, 1061 OUT PDWORD pdwDisplacement, 1062 OUT PIMAGEHLP_LINE64 Line64); 1063// DbgHelp.h typedefs. Implementation found in dbghelp.dll. 1064typedef PVOID (__stdcall *DLL_FUNC_TYPE(SymFunctionTableAccess64))( 1065 HANDLE hProcess, 1066 DWORD64 AddrBase); // DbgHelp.h typedef PFUNCTION_TABLE_ACCESS_ROUTINE64 1067typedef DWORD64 (__stdcall *DLL_FUNC_TYPE(SymGetModuleBase64))( 1068 HANDLE hProcess, 1069 DWORD64 AddrBase); // DbgHelp.h typedef PGET_MODULE_BASE_ROUTINE64 1070 1071// TlHelp32.h functions. 1072typedef HANDLE (__stdcall *DLL_FUNC_TYPE(CreateToolhelp32Snapshot))( 1073 DWORD dwFlags, 1074 DWORD th32ProcessID); 1075typedef BOOL (__stdcall *DLL_FUNC_TYPE(Module32FirstW))(HANDLE hSnapshot, 1076 LPMODULEENTRY32W lpme); 1077typedef BOOL (__stdcall *DLL_FUNC_TYPE(Module32NextW))(HANDLE hSnapshot, 1078 LPMODULEENTRY32W lpme); 1079 1080#undef IN 1081#undef VOID 1082 1083// Declare a variable for each dynamically loaded DLL function. 1084#define DEF_DLL_FUNCTION(name) DLL_FUNC_TYPE(name) DLL_FUNC_VAR(name) = NULL; 1085DBGHELP_FUNCTION_LIST(DEF_DLL_FUNCTION) 1086TLHELP32_FUNCTION_LIST(DEF_DLL_FUNCTION) 1087#undef DEF_DLL_FUNCTION 1088 1089// Load the functions. This function has a lot of "ugly" macros in order to 1090// keep down code duplication. 1091 1092static bool LoadDbgHelpAndTlHelp32() { 1093 static bool dbghelp_loaded = false; 1094 1095 if (dbghelp_loaded) return true; 1096 1097 HMODULE module; 1098 1099 // Load functions from the dbghelp.dll module. 1100 module = LoadLibrary(TEXT("dbghelp.dll")); 1101 if (module == NULL) { 1102 return false; 1103 } 1104 1105#define LOAD_DLL_FUNC(name) \ 1106 DLL_FUNC_VAR(name) = \ 1107 reinterpret_cast<DLL_FUNC_TYPE(name)>(GetProcAddress(module, #name)); 1108 1109DBGHELP_FUNCTION_LIST(LOAD_DLL_FUNC) 1110 1111#undef LOAD_DLL_FUNC 1112 1113 // Load functions from the kernel32.dll module (the TlHelp32.h function used 1114 // to be in tlhelp32.dll but are now moved to kernel32.dll). 1115 module = LoadLibrary(TEXT("kernel32.dll")); 1116 if (module == NULL) { 1117 return false; 1118 } 1119 1120#define LOAD_DLL_FUNC(name) \ 1121 DLL_FUNC_VAR(name) = \ 1122 reinterpret_cast<DLL_FUNC_TYPE(name)>(GetProcAddress(module, #name)); 1123 1124TLHELP32_FUNCTION_LIST(LOAD_DLL_FUNC) 1125 1126#undef LOAD_DLL_FUNC 1127 1128 // Check that all functions where loaded. 1129 bool result = 1130#define DLL_FUNC_LOADED(name) (DLL_FUNC_VAR(name) != NULL) && 1131 1132DBGHELP_FUNCTION_LIST(DLL_FUNC_LOADED) 1133TLHELP32_FUNCTION_LIST(DLL_FUNC_LOADED) 1134 1135#undef DLL_FUNC_LOADED 1136 true; 1137 1138 dbghelp_loaded = result; 1139 return result; 1140 // NOTE: The modules are never unloaded and will stay around until the 1141 // application is closed. 1142} 1143 1144 1145// Load the symbols for generating stack traces. 1146static bool LoadSymbols(HANDLE process_handle) { 1147 static bool symbols_loaded = false; 1148 1149 if (symbols_loaded) return true; 1150 1151 BOOL ok; 1152 1153 // Initialize the symbol engine. 1154 ok = _SymInitialize(process_handle, // hProcess 1155 NULL, // UserSearchPath 1156 FALSE); // fInvadeProcess 1157 if (!ok) return false; 1158 1159 DWORD options = _SymGetOptions(); 1160 options |= SYMOPT_LOAD_LINES; 1161 options |= SYMOPT_FAIL_CRITICAL_ERRORS; 1162 options = _SymSetOptions(options); 1163 1164 char buf[OS::kStackWalkMaxNameLen] = {0}; 1165 ok = _SymGetSearchPath(process_handle, buf, OS::kStackWalkMaxNameLen); 1166 if (!ok) { 1167 int err = GetLastError(); 1168 PrintF("%d\n", err); 1169 return false; 1170 } 1171 1172 HANDLE snapshot = _CreateToolhelp32Snapshot( 1173 TH32CS_SNAPMODULE, // dwFlags 1174 GetCurrentProcessId()); // th32ProcessId 1175 if (snapshot == INVALID_HANDLE_VALUE) return false; 1176 MODULEENTRY32W module_entry; 1177 module_entry.dwSize = sizeof(module_entry); // Set the size of the structure. 1178 BOOL cont = _Module32FirstW(snapshot, &module_entry); 1179 while (cont) { 1180 DWORD64 base; 1181 // NOTE the SymLoadModule64 function has the peculiarity of accepting a 1182 // both unicode and ASCII strings even though the parameter is PSTR. 1183 base = _SymLoadModule64( 1184 process_handle, // hProcess 1185 0, // hFile 1186 reinterpret_cast<PSTR>(module_entry.szExePath), // ImageName 1187 reinterpret_cast<PSTR>(module_entry.szModule), // ModuleName 1188 reinterpret_cast<DWORD64>(module_entry.modBaseAddr), // BaseOfDll 1189 module_entry.modBaseSize); // SizeOfDll 1190 if (base == 0) { 1191 int err = GetLastError(); 1192 if (err != ERROR_MOD_NOT_FOUND && 1193 err != ERROR_INVALID_HANDLE) return false; 1194 } 1195 LOG(SharedLibraryEvent( 1196 module_entry.szExePath, 1197 reinterpret_cast<unsigned int>(module_entry.modBaseAddr), 1198 reinterpret_cast<unsigned int>(module_entry.modBaseAddr + 1199 module_entry.modBaseSize))); 1200 cont = _Module32NextW(snapshot, &module_entry); 1201 } 1202 CloseHandle(snapshot); 1203 1204 symbols_loaded = true; 1205 return true; 1206} 1207 1208 1209void OS::LogSharedLibraryAddresses() { 1210 // SharedLibraryEvents are logged when loading symbol information. 1211 // Only the shared libraries loaded at the time of the call to 1212 // LogSharedLibraryAddresses are logged. DLLs loaded after 1213 // initialization are not accounted for. 1214 if (!LoadDbgHelpAndTlHelp32()) return; 1215 HANDLE process_handle = GetCurrentProcess(); 1216 LoadSymbols(process_handle); 1217} 1218 1219 1220// Walk the stack using the facilities in dbghelp.dll and tlhelp32.dll 1221 1222// Switch off warning 4748 (/GS can not protect parameters and local variables 1223// from local buffer overrun because optimizations are disabled in function) as 1224// it is triggered by the use of inline assembler. 1225#pragma warning(push) 1226#pragma warning(disable : 4748) 1227int OS::StackWalk(Vector<OS::StackFrame> frames) { 1228 BOOL ok; 1229 1230 // Load the required functions from DLL's. 1231 if (!LoadDbgHelpAndTlHelp32()) return kStackWalkError; 1232 1233 // Get the process and thread handles. 1234 HANDLE process_handle = GetCurrentProcess(); 1235 HANDLE thread_handle = GetCurrentThread(); 1236 1237 // Read the symbols. 1238 if (!LoadSymbols(process_handle)) return kStackWalkError; 1239 1240 // Capture current context. 1241 CONTEXT context; 1242 RtlCaptureContext(&context); 1243 1244 // Initialize the stack walking 1245 STACKFRAME64 stack_frame; 1246 memset(&stack_frame, 0, sizeof(stack_frame)); 1247#ifdef _WIN64 1248 stack_frame.AddrPC.Offset = context.Rip; 1249 stack_frame.AddrFrame.Offset = context.Rbp; 1250 stack_frame.AddrStack.Offset = context.Rsp; 1251#else 1252 stack_frame.AddrPC.Offset = context.Eip; 1253 stack_frame.AddrFrame.Offset = context.Ebp; 1254 stack_frame.AddrStack.Offset = context.Esp; 1255#endif 1256 stack_frame.AddrPC.Mode = AddrModeFlat; 1257 stack_frame.AddrFrame.Mode = AddrModeFlat; 1258 stack_frame.AddrStack.Mode = AddrModeFlat; 1259 int frames_count = 0; 1260 1261 // Collect stack frames. 1262 int frames_size = frames.length(); 1263 while (frames_count < frames_size) { 1264 ok = _StackWalk64( 1265 IMAGE_FILE_MACHINE_I386, // MachineType 1266 process_handle, // hProcess 1267 thread_handle, // hThread 1268 &stack_frame, // StackFrame 1269 &context, // ContextRecord 1270 NULL, // ReadMemoryRoutine 1271 _SymFunctionTableAccess64, // FunctionTableAccessRoutine 1272 _SymGetModuleBase64, // GetModuleBaseRoutine 1273 NULL); // TranslateAddress 1274 if (!ok) break; 1275 1276 // Store the address. 1277 ASSERT((stack_frame.AddrPC.Offset >> 32) == 0); // 32-bit address. 1278 frames[frames_count].address = 1279 reinterpret_cast<void*>(stack_frame.AddrPC.Offset); 1280 1281 // Try to locate a symbol for this frame. 1282 DWORD64 symbol_displacement; 1283 SmartPointer<IMAGEHLP_SYMBOL64> symbol( 1284 NewArray<IMAGEHLP_SYMBOL64>(kStackWalkMaxNameLen)); 1285 if (symbol.is_empty()) return kStackWalkError; // Out of memory. 1286 memset(*symbol, 0, sizeof(IMAGEHLP_SYMBOL64) + kStackWalkMaxNameLen); 1287 (*symbol)->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64); 1288 (*symbol)->MaxNameLength = kStackWalkMaxNameLen; 1289 ok = _SymGetSymFromAddr64(process_handle, // hProcess 1290 stack_frame.AddrPC.Offset, // Address 1291 &symbol_displacement, // Displacement 1292 *symbol); // Symbol 1293 if (ok) { 1294 // Try to locate more source information for the symbol. 1295 IMAGEHLP_LINE64 Line; 1296 memset(&Line, 0, sizeof(Line)); 1297 Line.SizeOfStruct = sizeof(Line); 1298 DWORD line_displacement; 1299 ok = _SymGetLineFromAddr64( 1300 process_handle, // hProcess 1301 stack_frame.AddrPC.Offset, // dwAddr 1302 &line_displacement, // pdwDisplacement 1303 &Line); // Line 1304 // Format a text representation of the frame based on the information 1305 // available. 1306 if (ok) { 1307 SNPrintF(MutableCStrVector(frames[frames_count].text, 1308 kStackWalkMaxTextLen), 1309 "%s %s:%d:%d", 1310 (*symbol)->Name, Line.FileName, Line.LineNumber, 1311 line_displacement); 1312 } else { 1313 SNPrintF(MutableCStrVector(frames[frames_count].text, 1314 kStackWalkMaxTextLen), 1315 "%s", 1316 (*symbol)->Name); 1317 } 1318 // Make sure line termination is in place. 1319 frames[frames_count].text[kStackWalkMaxTextLen - 1] = '\0'; 1320 } else { 1321 // No text representation of this frame 1322 frames[frames_count].text[0] = '\0'; 1323 1324 // Continue if we are just missing a module (for non C/C++ frames a 1325 // module will never be found). 1326 int err = GetLastError(); 1327 if (err != ERROR_MOD_NOT_FOUND) { 1328 break; 1329 } 1330 } 1331 1332 frames_count++; 1333 } 1334 1335 // Return the number of frames filled in. 1336 return frames_count; 1337} 1338 1339// Restore warnings to previous settings. 1340#pragma warning(pop) 1341 1342#else // __MINGW32__ 1343void OS::LogSharedLibraryAddresses() { } 1344int OS::StackWalk(Vector<OS::StackFrame> frames) { return 0; } 1345#endif // __MINGW32__ 1346 1347 1348uint64_t OS::CpuFeaturesImpliedByPlatform() { 1349 return 0; // Windows runs on anything. 1350} 1351 1352 1353double OS::nan_value() { 1354#ifdef _MSC_VER 1355 // Positive Quiet NaN with no payload (aka. Indeterminate) has all bits 1356 // in mask set, so value equals mask. 1357 static const __int64 nanval = kQuietNaNMask; 1358 return *reinterpret_cast<const double*>(&nanval); 1359#else // _MSC_VER 1360 return NAN; 1361#endif // _MSC_VER 1362} 1363 1364 1365int OS::ActivationFrameAlignment() { 1366#ifdef _WIN64 1367 return 16; // Windows 64-bit ABI requires the stack to be 16-byte aligned. 1368#else 1369 return 8; // Floating-point math runs faster with 8-byte alignment. 1370#endif 1371} 1372 1373 1374void OS::ReleaseStore(volatile AtomicWord* ptr, AtomicWord value) { 1375 MemoryBarrier(); 1376 *ptr = value; 1377} 1378 1379 1380bool VirtualMemory::IsReserved() { 1381 return address_ != NULL; 1382} 1383 1384 1385VirtualMemory::VirtualMemory(size_t size) { 1386 address_ = VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS); 1387 size_ = size; 1388} 1389 1390 1391VirtualMemory::~VirtualMemory() { 1392 if (IsReserved()) { 1393 if (0 == VirtualFree(address(), 0, MEM_RELEASE)) address_ = NULL; 1394 } 1395} 1396 1397 1398bool VirtualMemory::Commit(void* address, size_t size, bool is_executable) { 1399 int prot = is_executable ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE; 1400 if (NULL == VirtualAlloc(address, size, MEM_COMMIT, prot)) { 1401 return false; 1402 } 1403 1404 UpdateAllocatedSpaceLimits(address, static_cast<int>(size)); 1405 return true; 1406} 1407 1408 1409bool VirtualMemory::Uncommit(void* address, size_t size) { 1410 ASSERT(IsReserved()); 1411 return VirtualFree(address, size, MEM_DECOMMIT) != FALSE; 1412} 1413 1414 1415// ---------------------------------------------------------------------------- 1416// Win32 thread support. 1417 1418// Definition of invalid thread handle and id. 1419static const HANDLE kNoThread = INVALID_HANDLE_VALUE; 1420static const DWORD kNoThreadId = 0; 1421 1422 1423class ThreadHandle::PlatformData : public Malloced { 1424 public: 1425 explicit PlatformData(ThreadHandle::Kind kind) { 1426 Initialize(kind); 1427 } 1428 1429 void Initialize(ThreadHandle::Kind kind) { 1430 switch (kind) { 1431 case ThreadHandle::SELF: tid_ = GetCurrentThreadId(); break; 1432 case ThreadHandle::INVALID: tid_ = kNoThreadId; break; 1433 } 1434 } 1435 DWORD tid_; // Win32 thread identifier. 1436}; 1437 1438 1439// Entry point for threads. The supplied argument is a pointer to the thread 1440// object. The entry function dispatches to the run method in the thread 1441// object. It is important that this function has __stdcall calling 1442// convention. 1443static unsigned int __stdcall ThreadEntry(void* arg) { 1444 Thread* thread = reinterpret_cast<Thread*>(arg); 1445 // This is also initialized by the last parameter to _beginthreadex() but we 1446 // don't know which thread will run first (the original thread or the new 1447 // one) so we initialize it here too. 1448 thread->thread_handle_data()->tid_ = GetCurrentThreadId(); 1449 thread->Run(); 1450 return 0; 1451} 1452 1453 1454// Initialize thread handle to invalid handle. 1455ThreadHandle::ThreadHandle(ThreadHandle::Kind kind) { 1456 data_ = new PlatformData(kind); 1457} 1458 1459 1460ThreadHandle::~ThreadHandle() { 1461 delete data_; 1462} 1463 1464 1465// The thread is running if it has the same id as the current thread. 1466bool ThreadHandle::IsSelf() const { 1467 return GetCurrentThreadId() == data_->tid_; 1468} 1469 1470 1471// Test for invalid thread handle. 1472bool ThreadHandle::IsValid() const { 1473 return data_->tid_ != kNoThreadId; 1474} 1475 1476 1477void ThreadHandle::Initialize(ThreadHandle::Kind kind) { 1478 data_->Initialize(kind); 1479} 1480 1481 1482class Thread::PlatformData : public Malloced { 1483 public: 1484 explicit PlatformData(HANDLE thread) : thread_(thread) {} 1485 HANDLE thread_; 1486}; 1487 1488 1489// Initialize a Win32 thread object. The thread has an invalid thread 1490// handle until it is started. 1491 1492Thread::Thread() : ThreadHandle(ThreadHandle::INVALID) { 1493 data_ = new PlatformData(kNoThread); 1494} 1495 1496 1497// Close our own handle for the thread. 1498Thread::~Thread() { 1499 if (data_->thread_ != kNoThread) CloseHandle(data_->thread_); 1500 delete data_; 1501} 1502 1503 1504// Create a new thread. It is important to use _beginthreadex() instead of 1505// the Win32 function CreateThread(), because the CreateThread() does not 1506// initialize thread specific structures in the C runtime library. 1507void Thread::Start() { 1508 data_->thread_ = reinterpret_cast<HANDLE>( 1509 _beginthreadex(NULL, 1510 0, 1511 ThreadEntry, 1512 this, 1513 0, 1514 reinterpret_cast<unsigned int*>( 1515 &thread_handle_data()->tid_))); 1516 ASSERT(IsValid()); 1517} 1518 1519 1520// Wait for thread to terminate. 1521void Thread::Join() { 1522 WaitForSingleObject(data_->thread_, INFINITE); 1523} 1524 1525 1526Thread::LocalStorageKey Thread::CreateThreadLocalKey() { 1527 DWORD result = TlsAlloc(); 1528 ASSERT(result != TLS_OUT_OF_INDEXES); 1529 return static_cast<LocalStorageKey>(result); 1530} 1531 1532 1533void Thread::DeleteThreadLocalKey(LocalStorageKey key) { 1534 BOOL result = TlsFree(static_cast<DWORD>(key)); 1535 USE(result); 1536 ASSERT(result); 1537} 1538 1539 1540void* Thread::GetThreadLocal(LocalStorageKey key) { 1541 return TlsGetValue(static_cast<DWORD>(key)); 1542} 1543 1544 1545void Thread::SetThreadLocal(LocalStorageKey key, void* value) { 1546 BOOL result = TlsSetValue(static_cast<DWORD>(key), value); 1547 USE(result); 1548 ASSERT(result); 1549} 1550 1551 1552 1553void Thread::YieldCPU() { 1554 Sleep(0); 1555} 1556 1557 1558// ---------------------------------------------------------------------------- 1559// Win32 mutex support. 1560// 1561// On Win32 mutexes are implemented using CRITICAL_SECTION objects. These are 1562// faster than Win32 Mutex objects because they are implemented using user mode 1563// atomic instructions. Therefore we only do ring transitions if there is lock 1564// contention. 1565 1566class Win32Mutex : public Mutex { 1567 public: 1568 1569 Win32Mutex() { InitializeCriticalSection(&cs_); } 1570 1571 ~Win32Mutex() { DeleteCriticalSection(&cs_); } 1572 1573 int Lock() { 1574 EnterCriticalSection(&cs_); 1575 return 0; 1576 } 1577 1578 int Unlock() { 1579 LeaveCriticalSection(&cs_); 1580 return 0; 1581 } 1582 1583 private: 1584 CRITICAL_SECTION cs_; // Critical section used for mutex 1585}; 1586 1587 1588Mutex* OS::CreateMutex() { 1589 return new Win32Mutex(); 1590} 1591 1592 1593// ---------------------------------------------------------------------------- 1594// Win32 semaphore support. 1595// 1596// On Win32 semaphores are implemented using Win32 Semaphore objects. The 1597// semaphores are anonymous. Also, the semaphores are initialized to have 1598// no upper limit on count. 1599 1600 1601class Win32Semaphore : public Semaphore { 1602 public: 1603 explicit Win32Semaphore(int count) { 1604 sem = ::CreateSemaphoreA(NULL, count, 0x7fffffff, NULL); 1605 } 1606 1607 ~Win32Semaphore() { 1608 CloseHandle(sem); 1609 } 1610 1611 void Wait() { 1612 WaitForSingleObject(sem, INFINITE); 1613 } 1614 1615 bool Wait(int timeout) { 1616 // Timeout in Windows API is in milliseconds. 1617 DWORD millis_timeout = timeout / 1000; 1618 return WaitForSingleObject(sem, millis_timeout) != WAIT_TIMEOUT; 1619 } 1620 1621 void Signal() { 1622 LONG dummy; 1623 ReleaseSemaphore(sem, 1, &dummy); 1624 } 1625 1626 private: 1627 HANDLE sem; 1628}; 1629 1630 1631Semaphore* OS::CreateSemaphore(int count) { 1632 return new Win32Semaphore(count); 1633} 1634 1635 1636// ---------------------------------------------------------------------------- 1637// Win32 socket support. 1638// 1639 1640class Win32Socket : public Socket { 1641 public: 1642 explicit Win32Socket() { 1643 // Create the socket. 1644 socket_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 1645 } 1646 explicit Win32Socket(SOCKET socket): socket_(socket) { } 1647 virtual ~Win32Socket() { Shutdown(); } 1648 1649 // Server initialization. 1650 bool Bind(const int port); 1651 bool Listen(int backlog) const; 1652 Socket* Accept() const; 1653 1654 // Client initialization. 1655 bool Connect(const char* host, const char* port); 1656 1657 // Shutdown socket for both read and write. 1658 bool Shutdown(); 1659 1660 // Data Transimission 1661 int Send(const char* data, int len) const; 1662 int Receive(char* data, int len) const; 1663 1664 bool SetReuseAddress(bool reuse_address); 1665 1666 bool IsValid() const { return socket_ != INVALID_SOCKET; } 1667 1668 private: 1669 SOCKET socket_; 1670}; 1671 1672 1673bool Win32Socket::Bind(const int port) { 1674 if (!IsValid()) { 1675 return false; 1676 } 1677 1678 sockaddr_in addr; 1679 memset(&addr, 0, sizeof(addr)); 1680 addr.sin_family = AF_INET; 1681 addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 1682 addr.sin_port = htons(port); 1683 int status = bind(socket_, 1684 reinterpret_cast<struct sockaddr *>(&addr), 1685 sizeof(addr)); 1686 return status == 0; 1687} 1688 1689 1690bool Win32Socket::Listen(int backlog) const { 1691 if (!IsValid()) { 1692 return false; 1693 } 1694 1695 int status = listen(socket_, backlog); 1696 return status == 0; 1697} 1698 1699 1700Socket* Win32Socket::Accept() const { 1701 if (!IsValid()) { 1702 return NULL; 1703 } 1704 1705 SOCKET socket = accept(socket_, NULL, NULL); 1706 if (socket == INVALID_SOCKET) { 1707 return NULL; 1708 } else { 1709 return new Win32Socket(socket); 1710 } 1711} 1712 1713 1714bool Win32Socket::Connect(const char* host, const char* port) { 1715 if (!IsValid()) { 1716 return false; 1717 } 1718 1719 // Lookup host and port. 1720 struct addrinfo *result = NULL; 1721 struct addrinfo hints; 1722 memset(&hints, 0, sizeof(addrinfo)); 1723 hints.ai_family = AF_INET; 1724 hints.ai_socktype = SOCK_STREAM; 1725 hints.ai_protocol = IPPROTO_TCP; 1726 int status = getaddrinfo(host, port, &hints, &result); 1727 if (status != 0) { 1728 return false; 1729 } 1730 1731 // Connect. 1732 status = connect(socket_, 1733 result->ai_addr, 1734 static_cast<int>(result->ai_addrlen)); 1735 freeaddrinfo(result); 1736 return status == 0; 1737} 1738 1739 1740bool Win32Socket::Shutdown() { 1741 if (IsValid()) { 1742 // Shutdown socket for both read and write. 1743 int status = shutdown(socket_, SD_BOTH); 1744 closesocket(socket_); 1745 socket_ = INVALID_SOCKET; 1746 return status == SOCKET_ERROR; 1747 } 1748 return true; 1749} 1750 1751 1752int Win32Socket::Send(const char* data, int len) const { 1753 int status = send(socket_, data, len, 0); 1754 return status; 1755} 1756 1757 1758int Win32Socket::Receive(char* data, int len) const { 1759 int status = recv(socket_, data, len, 0); 1760 return status; 1761} 1762 1763 1764bool Win32Socket::SetReuseAddress(bool reuse_address) { 1765 BOOL on = reuse_address ? TRUE : FALSE; 1766 int status = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, 1767 reinterpret_cast<char*>(&on), sizeof(on)); 1768 return status == SOCKET_ERROR; 1769} 1770 1771 1772bool Socket::Setup() { 1773 // Initialize Winsock32 1774 int err; 1775 WSADATA winsock_data; 1776 WORD version_requested = MAKEWORD(1, 0); 1777 err = WSAStartup(version_requested, &winsock_data); 1778 if (err != 0) { 1779 PrintF("Unable to initialize Winsock, err = %d\n", Socket::LastError()); 1780 } 1781 1782 return err == 0; 1783} 1784 1785 1786int Socket::LastError() { 1787 return WSAGetLastError(); 1788} 1789 1790 1791uint16_t Socket::HToN(uint16_t value) { 1792 return htons(value); 1793} 1794 1795 1796uint16_t Socket::NToH(uint16_t value) { 1797 return ntohs(value); 1798} 1799 1800 1801uint32_t Socket::HToN(uint32_t value) { 1802 return htonl(value); 1803} 1804 1805 1806uint32_t Socket::NToH(uint32_t value) { 1807 return ntohl(value); 1808} 1809 1810 1811Socket* OS::CreateSocket() { 1812 return new Win32Socket(); 1813} 1814 1815 1816#ifdef ENABLE_LOGGING_AND_PROFILING 1817 1818// ---------------------------------------------------------------------------- 1819// Win32 profiler support. 1820// 1821// On win32 we use a sampler thread with high priority to sample the program 1822// counter for the profiled thread. 1823 1824class Sampler::PlatformData : public Malloced { 1825 public: 1826 explicit PlatformData(Sampler* sampler) { 1827 sampler_ = sampler; 1828 sampler_thread_ = INVALID_HANDLE_VALUE; 1829 profiled_thread_ = INVALID_HANDLE_VALUE; 1830 } 1831 1832 Sampler* sampler_; 1833 HANDLE sampler_thread_; 1834 HANDLE profiled_thread_; 1835 1836 // Sampler thread handler. 1837 void Runner() { 1838 // Context used for sampling the register state of the profiled thread. 1839 CONTEXT context; 1840 memset(&context, 0, sizeof(context)); 1841 // Loop until the sampler is disengaged, keeping the specified samling freq. 1842 for ( ; sampler_->IsActive(); Sleep(sampler_->interval_)) { 1843 TickSample sample_obj; 1844 TickSample* sample = CpuProfiler::TickSampleEvent(); 1845 if (sample == NULL) sample = &sample_obj; 1846 1847 // We always sample the VM state. 1848 sample->state = VMState::current_state(); 1849 // If profiling, we record the pc and sp of the profiled thread. 1850 if (sampler_->IsProfiling() 1851 && SuspendThread(profiled_thread_) != (DWORD)-1) { 1852 context.ContextFlags = CONTEXT_FULL; 1853 if (GetThreadContext(profiled_thread_, &context) != 0) { 1854#if V8_HOST_ARCH_X64 1855 sample->pc = reinterpret_cast<Address>(context.Rip); 1856 sample->sp = reinterpret_cast<Address>(context.Rsp); 1857 sample->fp = reinterpret_cast<Address>(context.Rbp); 1858#else 1859 sample->pc = reinterpret_cast<Address>(context.Eip); 1860 sample->sp = reinterpret_cast<Address>(context.Esp); 1861 sample->fp = reinterpret_cast<Address>(context.Ebp); 1862#endif 1863 sampler_->SampleStack(sample); 1864 } 1865 ResumeThread(profiled_thread_); 1866 } 1867 1868 // Invoke tick handler with program counter and stack pointer. 1869 sampler_->Tick(sample); 1870 } 1871 } 1872}; 1873 1874 1875// Entry point for sampler thread. 1876static unsigned int __stdcall SamplerEntry(void* arg) { 1877 Sampler::PlatformData* data = 1878 reinterpret_cast<Sampler::PlatformData*>(arg); 1879 data->Runner(); 1880 return 0; 1881} 1882 1883 1884// Initialize a profile sampler. 1885Sampler::Sampler(int interval, bool profiling) 1886 : interval_(interval), profiling_(profiling), active_(false) { 1887 data_ = new PlatformData(this); 1888} 1889 1890 1891Sampler::~Sampler() { 1892 delete data_; 1893} 1894 1895 1896// Start profiling. 1897void Sampler::Start() { 1898 // If we are profiling, we need to be able to access the calling 1899 // thread. 1900 if (IsProfiling()) { 1901 // Get a handle to the calling thread. This is the thread that we are 1902 // going to profile. We need to make a copy of the handle because we are 1903 // going to use it in the sampler thread. Using GetThreadHandle() will 1904 // not work in this case. We're using OpenThread because DuplicateHandle 1905 // for some reason doesn't work in Chrome's sandbox. 1906 data_->profiled_thread_ = OpenThread(THREAD_GET_CONTEXT | 1907 THREAD_SUSPEND_RESUME | 1908 THREAD_QUERY_INFORMATION, 1909 FALSE, 1910 GetCurrentThreadId()); 1911 BOOL ok = data_->profiled_thread_ != NULL; 1912 if (!ok) return; 1913 } 1914 1915 // Start sampler thread. 1916 unsigned int tid; 1917 active_ = true; 1918 data_->sampler_thread_ = reinterpret_cast<HANDLE>( 1919 _beginthreadex(NULL, 0, SamplerEntry, data_, 0, &tid)); 1920 // Set thread to high priority to increase sampling accuracy. 1921 SetThreadPriority(data_->sampler_thread_, THREAD_PRIORITY_TIME_CRITICAL); 1922} 1923 1924 1925// Stop profiling. 1926void Sampler::Stop() { 1927 // Seting active to false triggers termination of the sampler 1928 // thread. 1929 active_ = false; 1930 1931 // Wait for sampler thread to terminate. 1932 WaitForSingleObject(data_->sampler_thread_, INFINITE); 1933 1934 // Release the thread handles 1935 CloseHandle(data_->sampler_thread_); 1936 CloseHandle(data_->profiled_thread_); 1937} 1938 1939 1940#endif // ENABLE_LOGGING_AND_PROFILING 1941 1942} } // namespace v8::internal 1943