Split out fallback stack limit determination.

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/heap/StackFrameDepth.h"
 
 #include "public/platform/Platform.h"
 
 #if OS(WIN)
 #include <stddef.h>
@@ skipping 14 matching lines @@
 #endif
 
 // NEVER_INLINE ensures that |dummy| array on configureLimit() is not optimized away,
 // and the stack frame base register is adjusted |kSafeStackFrameSize|.
 NEVER_INLINE static uintptr_t currentStackFrameBaseOnCallee(const char* dummy)
 {
     s_avoidOptimization = dummy;
     return StackFrameDepth::currentStackFrame();
 }
 
+uintptr_t StackFrameDepth::getFallbackStackLimit()
+{
+    // Allocate an |kSafeStackFrameSize|-sized object on stack and query
+    // stack frame base after it.
+    char dummy[kSafeStackFrameSize];
+
+    // Check that the stack frame can be used.
+    dummy[sizeof(dummy) - 1] = 0;
+#if ENABLE(ASSERT)
+    // Use a larger stack limit for what's acceptable if the platform
+    // thread ends up using the fallback size to decide if switching to
+    // lazy marking is in order.
+    s_isUsingFallbackStackSize = true;
+#endif
+    return currentStackFrameBaseOnCallee(dummy);
+}
+
 void StackFrameDepth::enableStackLimit()
 {
 #if ENABLE(ASSERT)
     s_isEnabled = true;
     s_isUsingFallbackStackSize = false;
 #endif
 
-    static const int kStackRoomSize = 1024;
-
+    // Windows and OSX platforms will always return a non-zero estimate.
     size_t stackSize = getUnderestimatedStackSize();
-    if (stackSize) {
-        Address stackBase = reinterpret_cast<Address>(getStackStart());
-        RELEASE_ASSERT(stackSize > static_cast<const size_t>(kStackRoomSize));
-        size_t stackRoom = stackSize - kStackRoomSize;
-        RELEASE_ASSERT(stackBase > reinterpret_cast<Address>(stackRoom));
-        s_stackFrameLimit = reinterpret_cast<uintptr_t>(stackBase - stackRoom);
+    if (!stackSize) {
+        s_stackFrameLimit = getFallbackStackLimit();
         return;
     }
 
-    // Fallback version
-    // Allocate a 32KB object on stack and query stack frame base after it.
-    char dummy[kSafeStackFrameSize];
-    s_stackFrameLimit = currentStackFrameBaseOnCallee(dummy);
+    static const int kStackRoomSize = 1024;
 
-    // Assert that the stack frame can be used.
-    dummy[sizeof(dummy) - 1] = 0;
-#if ENABLE(ASSERT)
-    // Use a larger stack limit for what's acceptable if the platform
-    // thread ends up using the fallback size to decide if switching to
-    // lazy marking is in order.
-    s_isUsingFallbackStackSize = true;
-#endif
+    Address stackBase = reinterpret_cast<Address>(getStackStart());
+    RELEASE_ASSERT(stackSize > static_cast<const size_t>(kStackRoomSize));
+    size_t stackRoom = stackSize - kStackRoomSize;
+    RELEASE_ASSERT(stackBase > reinterpret_cast<Address>(stackRoom));
+    s_stackFrameLimit = reinterpret_cast<uintptr_t>(stackBase - stackRoom);
 }
 
 size_t StackFrameDepth::getUnderestimatedStackSize()
 {
     // FIXME: ASAN bot uses a fake stack as a thread stack frame,
     // and its size is different from the value which APIs tells us.
 #if defined(ADDRESS_SANITIZER)
     return 0;
 #endif
 
@@ skipping 97 matching lines @@
     return reinterpret_cast<void*>(__readgsqword(offsetof(NT_TIB64, StackBase)));
 #else
     return reinterpret_cast<void*>(__readfsdword(offsetof(NT_TIB, StackBase)));
 #endif
 #else
 #error Unsupported getStackStart on this platform.
 #endif
 }
 
 } // namespace blink