Oilpan: Avoid looking up TLS in ThreadState::current()

Source/platform/heap/ThreadState.h

 /*
  * 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 357 matching lines @@
 
     // Associate ThreadState object with the current thread. After this
     // call thread can start using the garbage collected heap infrastructure.
     // It also has to periodically check for safepoints.
     static void attach();
 
     // Disassociate attached ThreadState from the current thread. The thread
     // can no longer use the garbage collected heap after this call.
     static void detach();
 
-    static ThreadState* current() { return **s_threadSpecific; }
+    static ThreadState* current()
+    {
+#if defined(__GLIBC__) || OS(ANDROID) || OS(FREEBSD)
+        // TLS lookup is fast in these platforms.
+        return **s_threadSpecific;
+#else
+        intptr_t dummy;
+        unsigned addressDiff = s_mainThreadStackStart - reinterpret_cast<intptr_t>(&dummy);

[sof, 2014/10/12 07:53:55]

To remain safe, doesn't this need to be ptrdiff_t (or intptr_t) ?

[haraken, 2014/10/12 08:45:50]

Replaced it with uintptr_t. It is important that it is *u*intptr_t to skip a
comparison with 0.

[sof, 2014/10/12 11:39:17]

That type needs to be used for s_maniThreadStackSize also (signed/unsigned
mismatch if not) ?

[haraken, 2014/10/12 12:46:12]

Done.

+        // This is a fast way to judge if we are in the main thread.
+        // If |&dummy| is within |s_mainThreadStackSize| byte from
+        // the stack start of the main thread, we judge that we are in
+        // the main thread.
+        ASSERT(s_mainThreadStackSize);
+        if (LIKELY(addressDiff <= s_mainThreadStackSize)) {
+            ASSERT(**s_threadSpecific == mainThreadState());
+            return mainThreadState();
+        }
+        // TLS lookup is slow.
+        return **s_threadSpecific;
+#endif
+    }
+
     static ThreadState* mainThreadState()
     {
         return reinterpret_cast<ThreadState*>(s_mainThreadStateStorage);
     }
 
     bool isMainThread() const { return this == mainThreadState(); }
     inline bool checkThread() const
     {
         ASSERT(m_thread == currentThread());
         return true;
@@ skipping 344 matching lines @@
     void cleanupPages();
 
     void setLowCollectionRate(bool value) { m_lowCollectionRate = value; }
 
     void performPendingSweepInParallel();
     void waitUntilSweepersDone();
     void unregisterPreFinalizerInternal(void*);
     void invokePreFinalizers(Visitor&);
 
     static WTF::ThreadSpecific<ThreadState*>* s_threadSpecific;
+    static intptr_t s_mainThreadStackStart;
+    static intptr_t s_mainThreadStackSize;
     static SafePointBarrier* s_safePointBarrier;
 
     // This variable is flipped to true after all threads are stoped
     // and outermost GC has started.
     static bool s_inGC;
 
     // We can't create a static member of type ThreadState here
     // because it will introduce global constructor and destructor.
     // We would like to manage lifetime of the ThreadState attached
     // to the main thread explicitly instead and still use normal
@@ skipping 162 matching lines @@
     // whether the page is part of a terminting thread or
     // if the page is traced after being terminated (orphaned).
     uintptr_t m_terminating : 1;
     uintptr_t m_tracedAfterOrphaned : 1;
     uintptr_t m_promptlyFreedSize : 17; // == blinkPageSizeLog2
 };
 
 }
 
 #endif // ThreadState_h