Source/WTF/wtf/WTFThreadData.h

   1 /*
   2  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  *
  25  */
  26
  27 #ifndef WTFThreadData_h
  28 #define WTFThreadData_h
  29
  30 #include <wtf/HashMap.h>
  31 #include <wtf/HashSet.h>
  32 #include <wtf/Noncopyable.h>
  33 #include <wtf/StackBounds.h>
  34 #include <wtf/text/StringHash.h>
  35 #include <wtf/ThreadSpecific.h>
  36 #include <wtf/Threading.h>
  37
  38 #if USE(JSC)
  39 // FIXME: This is a temporary layering violation while we move more string code to WTF.
  40 namespace JSC {
  41
  42 typedef HashMap<const char*, RefPtr<StringImpl>, PtrHash<const char*> > LiteralIdentifierTable;
  43
  44 class IdentifierTable {
  45     WTF_MAKE_FAST_ALLOCATED;
  46 public:
  47     ~IdentifierTable();
  48
  49     HashSet<StringImpl*>::AddResult add(StringImpl* value);
  50     template<typename U, typename V>
  51     HashSet<StringImpl*>::AddResult add(U value);
  52
  53     bool remove(StringImpl* r)
  54     {
  55         HashSet<StringImpl*>::iterator iter = m_table.find(r);
  56         if (iter == m_table.end())
  57             return false;
  58         m_table.remove(iter);
  59         return true;
  60     }
  61
  62     LiteralIdentifierTable& literalTable() { return m_literalTable; }
  63
  64 private:
  65     HashSet<StringImpl*> m_table;
  66     LiteralIdentifierTable m_literalTable;
  67 };
  68
  69 }
  70 #endif
  71
  72 namespace WTF {
  73
  74 class AtomicStringTable;
  75
  76 typedef void (*AtomicStringTableDestructor)(AtomicStringTable*);
  77
  78 class WTFThreadData {
  79     WTF_MAKE_NONCOPYABLE(WTFThreadData);
  80 public:
  81     WTF_EXPORT_PRIVATE WTFThreadData();
  82     WTF_EXPORT_PRIVATE ~WTFThreadData();
  83
  84     AtomicStringTable* atomicStringTable()
  85     {
  86         return m_atomicStringTable;
  87     }
  88
  89 #if USE(JSC)
  90     JSC::IdentifierTable* currentIdentifierTable()
  91     {
  92         return m_currentIdentifierTable;
  93     }
  94
  95     JSC::IdentifierTable* setCurrentIdentifierTable(JSC::IdentifierTable* identifierTable)
  96     {
  97         JSC::IdentifierTable* oldIdentifierTable = m_currentIdentifierTable;
  98         m_currentIdentifierTable = identifierTable;
  99         return oldIdentifierTable;
 100     }
 101
 102     void resetCurrentIdentifierTable()
 103     {
 104         m_currentIdentifierTable = m_defaultIdentifierTable;
 105     }
 106
 107     const StackBounds& stack() const
 108     {
 109         return m_stackBounds;
 110     }
 111 #endif
 112
 113 #if ENABLE(TIZEN_USE_STACKPOINTER_AT_WEBPROCESS_STARTUP)
 114     void* jsStackOrigin() const
 115     {
 116         return m_jsStackOrigin ? m_jsStackOrigin : stack().origin();
 117     }
 118
 119     void setJsStackOrigin(void* o)
 120     {
 121         m_jsStackOrigin = o;
 122     }
 123 #endif
 124
 125
 126 private:
 127     AtomicStringTable* m_atomicStringTable;
 128     AtomicStringTableDestructor m_atomicStringTableDestructor;
 129
 130 #if USE(JSC)
 131     JSC::IdentifierTable* m_defaultIdentifierTable;
 132     JSC::IdentifierTable* m_currentIdentifierTable;
 133     StackBounds m_stackBounds;
 134 #if ENABLE(TIZEN_USE_STACKPOINTER_AT_WEBPROCESS_STARTUP)
 135     void*       m_jsStackOrigin;
 136 #endif
 137 #endif
 138
 139     static WTF_EXPORTDATA ThreadSpecific<WTFThreadData>* staticData;
 140     friend WTFThreadData& wtfThreadData();
 141     friend class AtomicStringTable;
 142 };
 143
 144 inline WTFThreadData& wtfThreadData()
 145 {
 146     // WRT WebCore:
 147     //    WTFThreadData is used on main thread before it could possibly be used
 148     //    on secondary ones, so there is no need for synchronization here.
 149     // WRT JavaScriptCore:
 150     //    wtfThreadData() is initially called from initializeThreading(), ensuring
 151     //    this is initially called in a pthread_once locked context.
 152     if (!WTFThreadData::staticData)
 153         WTFThreadData::staticData = new ThreadSpecific<WTFThreadData>;
 154     return **WTFThreadData::staticData;
 155 }
 156
 157 } // namespace WTF
 158
 159 using WTF::WTFThreadData;
 160 using WTF::wtfThreadData;
 161
 162 #endif // WTFThreadData_h