Fast path for ThreadSpecific for main thread on TLS-slow platforms

third_party/WebKit/Source/platform/heap/ThreadState.cpp

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 34 matching lines @@
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/instrumentation/tracing/web_memory_allocator_dump.h"
 #include "platform/instrumentation/tracing/web_process_memory_dump.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebTraceLocation.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/DataLog.h"
 #include "wtf/PtrUtil.h"
+#include "wtf/StackUtil.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/allocator/Partitions.h"
 #include <memory>
 #include <v8.h>
 
 #if OS(WIN)
 #include <stddef.h>
 #include <windows.h>
 #include <winnt.h>
 #endif
 
 #if defined(MEMORY_SANITIZER)
 #include <sanitizer/msan_interface.h>
 #endif
 
 #if OS(FREEBSD)
 #include <pthread_np.h>
 #endif
 
 namespace blink {
 
 WTF::ThreadSpecific<ThreadState*>* ThreadState::s_threadSpecific = nullptr;
-uintptr_t ThreadState::s_mainThreadStackStart = 0;
-uintptr_t ThreadState::s_mainThreadUnderestimatedStackSize = 0;
 uint8_t ThreadState::s_mainThreadStateStorage[sizeof(ThreadState)];
 
 const size_t defaultAllocatedObjectSizeThreshold = 100 * 1024;
 
 const char* ThreadState::gcReasonString(BlinkGC::GCReason reason) {
   switch (reason) {
     case BlinkGC::IdleGC:
       return "IdleGC";
     case BlinkGC::PreciseGC:
       return "PreciseGC";
@@ skipping 46 matching lines @@
   }
 
  private:
   ThreadState* m_state;
   bool m_shouldResumeThreads;
 };
 
 ThreadState::ThreadState()
     : m_thread(currentThread()),
       m_persistentRegion(WTF::makeUnique<PersistentRegion>()),
-#if OS(WIN) && COMPILER(MSVC)
-      m_threadStackSize(0),
-#endif
-      m_startOfStack(
-          reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart())),
-      m_endOfStack(
-          reinterpret_cast<intptr_t*>(StackFrameDepth::getStackStart())),
+      m_startOfStack(reinterpret_cast<intptr_t*>(WTF::getStackStart())),
+      m_endOfStack(reinterpret_cast<intptr_t*>(WTF::getStackStart())),
       m_safePointScopeMarker(nullptr),
       m_atSafePoint(false),
       m_interruptors(),
       m_sweepForbidden(false),
       m_noAllocationCount(0),
       m_gcForbiddenCount(0),
       m_mixinsBeingConstructedCount(0),
       m_accumulatedSweepingTime(0),
       m_vectorBackingArenaIndex(BlinkGC::Vector1ArenaIndex),
       m_currentArenaAges(0),
@@ skipping 11 matching lines @@
 #if defined(LEAK_SANITIZER)
       m_disabledStaticPersistentsRegistration(0),
 #endif
       m_allocatedObjectSize(0),
       m_markedObjectSize(0),
       m_reportedMemoryToV8(0) {
   ASSERT(checkThread());
   ASSERT(!**s_threadSpecific);
   **s_threadSpecific = this;
 
-  if (isMainThread()) {
-    s_mainThreadStackStart =
-        reinterpret_cast<uintptr_t>(m_startOfStack) - sizeof(void*);
-    size_t underestimatedStackSize =
-        StackFrameDepth::getUnderestimatedStackSize();
-    if (underestimatedStackSize > sizeof(void*)) {
-      s_mainThreadUnderestimatedStackSize =
-          underestimatedStackSize - sizeof(void*);
-    }
-  }
   m_heap = new ThreadHeap();
   ASSERT(m_heap);
   m_heap->attach(this);
 
   for (int arenaIndex = 0; arenaIndex < BlinkGC::LargeObjectArenaIndex;
        arenaIndex++)
     m_arenas[arenaIndex] = new NormalPageArena(this, arenaIndex);
   m_arenas[BlinkGC::LargeObjectArenaIndex] =
       new LargeObjectArena(this, BlinkGC::LargeObjectArenaIndex);
 
   m_likelyToBePromptlyFreed =
       wrapArrayUnique(new int[likelyToBePromptlyFreedArraySize]);
   clearArenaAges();
 }
 
 ThreadState::~ThreadState() {
   ASSERT(checkThread());
   for (int i = 0; i < BlinkGC::NumberOfArenas; ++i)
     delete m_arenas[i];
 
   **s_threadSpecific = nullptr;
-  if (isMainThread()) {
-    s_mainThreadStackStart = 0;
-    s_mainThreadUnderestimatedStackSize = 0;
-  }
 }
 
-#if OS(WIN) && COMPILER(MSVC)
-size_t ThreadState::threadStackSize() {
-  if (m_threadStackSize)
-    return m_threadStackSize;
-
-  // Notice that we cannot use the TIB's StackLimit for the stack end, as it
-  // tracks the end of the committed range. We're after the end of the reserved
-  // stack area (most of which will be uncommitted, most times.)
-  MEMORY_BASIC_INFORMATION stackInfo;
-  memset(&stackInfo, 0, sizeof(MEMORY_BASIC_INFORMATION));
-  size_t resultSize =
-      VirtualQuery(&stackInfo, &stackInfo, sizeof(MEMORY_BASIC_INFORMATION));
-  DCHECK_GE(resultSize, sizeof(MEMORY_BASIC_INFORMATION));
-  Address stackEnd = reinterpret_cast<Address>(stackInfo.AllocationBase);
-
-  Address stackStart =
-      reinterpret_cast<Address>(StackFrameDepth::getStackStart());
-  RELEASE_ASSERT(stackStart && stackStart > stackEnd);
-  m_threadStackSize = static_cast<size_t>(stackStart - stackEnd);
-  // When the third last page of the reserved stack is accessed as a
-  // guard page, the second last page will be committed (along with removing
-  // the guard bit on the third last) _and_ a stack overflow exception
-  // is raised.
-  //
-  // We have zero interest in running into stack overflow exceptions while
-  // marking objects, so simply consider the last three pages + one above
-  // as off-limits and adjust the reported stack size accordingly.
-  //
-  // http://blogs.msdn.com/b/satyem/archive/2012/08/13/thread-s-stack-memory-management.aspx
-  // explains the details.
-  RELEASE_ASSERT(m_threadStackSize > 4 * 0x1000);
-  m_threadStackSize -= 4 * 0x1000;
-  return m_threadStackSize;
-}
-#endif
-
 void ThreadState::attachMainThread() {
   RELEASE_ASSERT(!ProcessHeap::s_shutdownComplete);
   s_threadSpecific = new WTF::ThreadSpecific<ThreadState*>();
   new (s_mainThreadStateStorage) ThreadState();
 }
 
 void ThreadState::attachCurrentThread() {
   RELEASE_ASSERT(!ProcessHeap::s_shutdownComplete);
   new ThreadState();
 }
@@ skipping 1064 matching lines @@
 
 #ifdef ADDRESS_SANITIZER
 // When we are running under AddressSanitizer with
 // detect_stack_use_after_return=1 then stack marker obtained from
 // SafePointScope will point into a fake stack.  Detect this case by checking if
 // it falls in between current stack frame and stack start and use an arbitrary
 // high enough value for it.  Don't adjust stack marker in any other case to
 // match behavior of code running without AddressSanitizer.
 NO_SANITIZE_ADDRESS static void* adjustScopeMarkerForAdressSanitizer(
     void* scopeMarker) {
-  Address start = reinterpret_cast<Address>(StackFrameDepth::getStackStart());
+  Address start = reinterpret_cast<Address>(WTF::getStackStart());
   Address end = reinterpret_cast<Address>(&start);
   RELEASE_ASSERT(end < start);
 
   if (end <= scopeMarker && scopeMarker < start)
     return scopeMarker;
 
   // 256 is as good an approximation as any else.
   const size_t bytesToCopy = sizeof(Address) * 256;
   if (static_cast<size_t>(start - end) < bytesToCopy)
     return start;
@@ skipping 489 matching lines @@
     collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep,
                    BlinkGC::ForcedGC);
     size_t liveObjects = heap().heapStats().markedObjectSize();
     if (liveObjects == previousLiveObjects)
       break;
     previousLiveObjects = liveObjects;
   }
 }
 
 }  // namespace blink