JavaScriptCore-7601.1.46.3.tar.gz

[apple/javascriptcore.git] / runtime / SmallStrings.cpp

diff --git a/runtime/SmallStrings.cpp b/runtime/SmallStrings.cpp
index 8741e9bd29a53220d916f9971c20278fb04de1e4..9c6a43ae2138f4eefeba6e1d02bc2ead19e4de51 100644 (file)
--- a/runtime/SmallStrings.cpp
+++ b/runtime/SmallStrings.cpp
@@ -26,18 +26,15 @@
 #include "config.h"
 #include "SmallStrings.h"
 
 #include "config.h"
 #include "SmallStrings.h"
 

+#include "HeapRootVisitor.h"

 #include "JSGlobalObject.h"
 #include "JSString.h"
 #include "JSGlobalObject.h"
 #include "JSString.h"

+#include "JSCInlines.h"

 #include <wtf/Noncopyable.h>
 #include <wtf/Noncopyable.h>

-#include <wtf/PassOwnPtr.h>
+#include <wtf/text/StringImpl.h>

 
 namespace JSC {
 
 
 namespace JSC {
 

-static inline bool isMarked(JSCell* string)
-{
-    return string && Heap::isMarked(string);
-}
-

 class SmallStringsStorage {
     WTF_MAKE_NONCOPYABLE(SmallStringsStorage); WTF_MAKE_FAST_ALLOCATED;
 public:
 class SmallStringsStorage {
     WTF_MAKE_NONCOPYABLE(SmallStringsStorage); WTF_MAKE_FAST_ALLOCATED;
 public:


@@ -56,91 +53,85 @@ private:
 
 SmallStringsStorage::SmallStringsStorage()
 {
 
 SmallStringsStorage::SmallStringsStorage()
 {

-    UChar* characterBuffer = 0;
+    LChar* characterBuffer = 0;

     RefPtr<StringImpl> baseString = StringImpl::createUninitialized(singleCharacterStringCount, characterBuffer);
     for (unsigned i = 0; i < singleCharacterStringCount; ++i) {
         characterBuffer[i] = i;
     RefPtr<StringImpl> baseString = StringImpl::createUninitialized(singleCharacterStringCount, characterBuffer);
     for (unsigned i = 0; i < singleCharacterStringCount; ++i) {
         characterBuffer[i] = i;

-        m_reps[i] = StringImpl::create(baseString, i, 1);
+        m_reps[i] = AtomicStringImpl::add(PassRefPtr<StringImpl>(StringImpl::createSubstringSharingImpl(baseString, i, 1)).get());

     }
 }
 
 SmallStrings::SmallStrings()
     }
 }
 
 SmallStrings::SmallStrings()

+    : m_emptyString(0)
+#define JSC_COMMON_STRINGS_ATTRIBUTE_INITIALIZE(name) , m_##name(0)
+    JSC_COMMON_STRINGS_EACH_NAME(JSC_COMMON_STRINGS_ATTRIBUTE_INITIALIZE)
+#undef JSC_COMMON_STRINGS_ATTRIBUTE_INITIALIZE
+    , m_nullObjectString(nullptr)
+    , m_undefinedObjectString(nullptr)
+    , m_needsToBeVisited(true)

 {
     COMPILE_ASSERT(singleCharacterStringCount == sizeof(m_singleCharacterStrings) / sizeof(m_singleCharacterStrings[0]), IsNumCharactersConstInSyncWithClassUsage);
 {
     COMPILE_ASSERT(singleCharacterStringCount == sizeof(m_singleCharacterStrings) / sizeof(m_singleCharacterStrings[0]), IsNumCharactersConstInSyncWithClassUsage);

-    clear();
-}

 
 

-SmallStrings::~SmallStrings()
-{
+    for (unsigned i = 0; i < singleCharacterStringCount; ++i)
+        m_singleCharacterStrings[i] = 0;

 }
 
 }
 

-void SmallStrings::visitChildren(HeapRootVisitor& heapRootMarker)
+void SmallStrings::initializeCommonStrings(VM& vm)

 {
 {

-    /*
-       Our hypothesis is that small strings are very common. So, we cache them
-       to avoid GC churn. However, in cases where this hypothesis turns out to
-       be false -- including the degenerate case where all JavaScript execution
-       has terminated -- we don't want to waste memory.
-
-       To test our hypothesis, we check if any small string has been marked. If
-       so, it's probably reasonable to mark the rest. If not, we clear the cache.
-     */
-
-    bool isAnyStringMarked = isMarked(m_emptyString);
-    for (unsigned i = 0; i < singleCharacterStringCount && !isAnyStringMarked; ++i)
-        isAnyStringMarked = isMarked(m_singleCharacterStrings[i]);
-    
-    if (!isAnyStringMarked) {
-        clear();
-        return;
-    }
-    
-    if (m_emptyString)
-        heapRootMarker.mark(&m_emptyString);
-    for (unsigned i = 0; i < singleCharacterStringCount; ++i) {
-        if (m_singleCharacterStrings[i])
-            heapRootMarker.mark(&m_singleCharacterStrings[i]);
-    }
+    createEmptyString(&vm);
+    for (unsigned i = 0; i <= maxSingleCharacterString; ++i)
+        createSingleCharacterString(&vm, i);
+#define JSC_COMMON_STRINGS_ATTRIBUTE_INITIALIZE(name) initialize(&vm, m_##name, #name);
+    JSC_COMMON_STRINGS_EACH_NAME(JSC_COMMON_STRINGS_ATTRIBUTE_INITIALIZE)
+#undef JSC_COMMON_STRINGS_ATTRIBUTE_INITIALIZE
+    initialize(&vm, m_nullObjectString, "[object Null]");
+    initialize(&vm, m_undefinedObjectString, "[object Undefined]");

 }
 
 }
 

-void SmallStrings::clear()
+void SmallStrings::visitStrongReferences(SlotVisitor& visitor)

 {
 {

-    m_emptyString = 0;
-    for (unsigned i = 0; i < singleCharacterStringCount; ++i)
-        m_singleCharacterStrings[i] = 0;
+    m_needsToBeVisited = false;
+    visitor.appendUnbarrieredPointer(&m_emptyString);
+    for (unsigned i = 0; i <= maxSingleCharacterString; ++i)
+        visitor.appendUnbarrieredPointer(m_singleCharacterStrings + i);
+#define JSC_COMMON_STRINGS_ATTRIBUTE_VISIT(name) visitor.appendUnbarrieredPointer(&m_##name);
+    JSC_COMMON_STRINGS_EACH_NAME(JSC_COMMON_STRINGS_ATTRIBUTE_VISIT)
+#undef JSC_COMMON_STRINGS_ATTRIBUTE_VISIT
+    visitor.appendUnbarrieredPointer(&m_nullObjectString);
+    visitor.appendUnbarrieredPointer(&m_undefinedObjectString);

 }
 
 }
 

-unsigned SmallStrings::count() const
+SmallStrings::~SmallStrings()

 {
 {

-    unsigned count = 0;
-    if (m_emptyString)
-        ++count;
-    for (unsigned i = 0; i < singleCharacterStringCount; ++i) {
-        if (m_singleCharacterStrings[i])
-            ++count;
-    }
-    return count;

 }
 
 }
 

-void SmallStrings::createEmptyString(JSGlobalData* globalData)
+void SmallStrings::createEmptyString(VM* vm)

 {
     ASSERT(!m_emptyString);
 {
     ASSERT(!m_emptyString);

-    m_emptyString = new (globalData) JSString(globalData, "", JSString::HasOtherOwner);
+    m_emptyString = JSString::createHasOtherOwner(*vm, StringImpl::empty());
+    m_needsToBeVisited = true;

 }
 
 }
 

-void SmallStrings::createSingleCharacterString(JSGlobalData* globalData, unsigned char character)
+void SmallStrings::createSingleCharacterString(VM* vm, unsigned char character)

 {
     if (!m_storage)
 {
     if (!m_storage)

-        m_storage = adoptPtr(new SmallStringsStorage);
+        m_storage = std::make_unique<SmallStringsStorage>();

     ASSERT(!m_singleCharacterStrings[character]);
     ASSERT(!m_singleCharacterStrings[character]);

-    m_singleCharacterStrings[character] = new (globalData) JSString(globalData, PassRefPtr<StringImpl>(m_storage->rep(character)), JSString::HasOtherOwner);
+    m_singleCharacterStrings[character] = JSString::createHasOtherOwner(*vm, PassRefPtr<StringImpl>(m_storage->rep(character)));
+    m_needsToBeVisited = true;

 }
 
 StringImpl* SmallStrings::singleCharacterStringRep(unsigned char character)
 {
     if (!m_storage)
 }
 
 StringImpl* SmallStrings::singleCharacterStringRep(unsigned char character)
 {
     if (!m_storage)

-        m_storage = adoptPtr(new SmallStringsStorage);
+        m_storage = std::make_unique<SmallStringsStorage>();

     return m_storage->rep(character);
 }
 
     return m_storage->rep(character);
 }
 

+void SmallStrings::initialize(VM* vm, JSString*& string, const char* value)
+{
+    string = JSString::create(*vm, Identifier::fromString(vm, value).impl());
+    m_needsToBeVisited = true;
+}
+

 } // namespace JSC
 } // namespace JSC