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()
+    {
+        intptr_t dummy;
+        unsigned addressDiff = s_mainThreadStackStart - reinterpret_cast<intptr_t>(&dummy);
+        // This is a hacky, fast way to determine if we are in the main thread.
+        // If the address of the |dummy| is within 1 MB from the stack start of
+        // the main thread, we judge that we are in the main thread.
+        if (LIKELY(addressDiff <= 1024 * 1024)) {

[Mads Ager (chromium), 2014/10/10 13:44:36]

There is no way to guarantee that the stack is at least 1MB so this is not safe.
Imagine that the system decides to use stacks of size 512kB each. Then you can
get in a situation where objects that belong in a worker thread heap will be
allocated in the main heap.

To avoid thread-local access we should use the affinity support that we already
have. We decided to just go through thread-local for anything that is not a Node
or a CSS object. We can revisit that by modifying the thread affinity traits. 

+            ASSERT(**s_threadSpecific == mainThreadState());
+            return mainThreadState();
+        }
+        // TLS lookup is slow.
+        return **s_threadSpecific;
+    }
+
     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 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