[Isolates] RegExpStack and memory allocation limits (statics #6)

src/platform-win32.cc

 // Copyright 2006-2008 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 205 matching lines @@
 }
 
 
 namespace v8 {
 namespace internal {
 
 double ceiling(double x) {
   return ceil(x);
 }
 
+
+static Mutex* limit_mutex = NULL;
+
+
 #ifdef _WIN64
 typedef double (*ModuloFunction)(double, double);
 
 // Defined in codegen-x64.cc.
 ModuloFunction CreateModuloFunction();
 
 double modulo(double x, double y) {
   static ModuloFunction function = CreateModuloFunction();
   return function(x, y);
 }
@@ skipping 347 matching lines @@
 
 
 void OS::Setup() {
   // Seed the random number generator.
   // Convert the current time to a 64-bit integer first, before converting it
   // to an unsigned. Going directly can cause an overflow and the seed to be
   // set to all ones. The seed will be identical for different instances that
   // call this setup code within the same millisecond.
   uint64_t seed = static_cast<uint64_t>(TimeCurrentMillis());
   srand(static_cast<unsigned int>(seed));
+  limit_mutex = CreateMutex();
 }
 
 
 // Returns the accumulated user time for thread.
 int OS::GetUserTime(uint32_t* secs,  uint32_t* usecs) {
   FILETIME dummy;
   uint64_t usertime;
 
   // Get the amount of time that the thread has executed in user mode.
   if (!GetThreadTimes(GetCurrentThread(), &dummy, &dummy, &dummy,
@@ skipping 181 matching lines @@
 // We keep the lowest and highest addresses mapped as a quick way of
 // determining that pointers are outside the heap (used mostly in assertions
 // and verification).  The estimate is conservative, ie, not all addresses in
 // 'allocated' space are actually allocated to our heap.  The range is
 // [lowest, highest), inclusive on the low and and exclusive on the high end.
 static void* lowest_ever_allocated = reinterpret_cast<void*>(-1);
 static void* highest_ever_allocated = reinterpret_cast<void*>(0);
 
 
 static void UpdateAllocatedSpaceLimits(void* address, int size) {
+  ASSERT(limit_mutex != NULL);
+  ScopedLock lock(limit_mutex);
+
   lowest_ever_allocated = Min(lowest_ever_allocated, address);
   highest_ever_allocated =
       Max(highest_ever_allocated,
           reinterpret_cast<void*>(reinterpret_cast<char*>(address) + size));
 }
 
 
 bool OS::IsOutsideAllocatedSpace(void* pointer) {
   if (pointer < lowest_ever_allocated || pointer >= highest_ever_allocated)
     return true;
@@ skipping 1098 matching lines @@
 
   // Release the thread handles
   CloseHandle(data_->sampler_thread_);
   CloseHandle(data_->profiled_thread_);
 }
 
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 } }  // namespace v8::internal