Changeset 54843 in webkit for trunk/JavaScriptCore/runtime/JSString.h

Timestamp:

Feb 16, 2010, 4:01:58 PM (15 years ago)

Author:

[email protected]

Message:

​https://bugs.webkit.org/show_bug.cgi?id=34964
Leaks tool reports false memory leaks due to Rope implementation.

Reviewed by Oliver Hunt.

JavaScriptCore:

A rope is a recursive data structure where each node in the rope holds a set of
pointers, each of which may reference either a string (in UStringImpl form) or
another rope node. A low bit in each pointer is used to distinguish between
rope & string elements, in a fashion similar to the recently-removed
PtrAndFlags class (see ​https://bugs.webkit.org/show_bug.cgi?id=33731 ). Again,
this causes a problem for Leaks – refactor to remove the magic pointer
mangling.

Move Rope out from JSString.h and rename to URopeImpl, to match UStringImpl.
Give UStringImpl and URopeImpl a common parent class, UStringOrRopeImpl.
Repurpose an otherwise invalid permutation to flags (static & should report
memory cost) to identify ropes.

This allows us to change the rope's fibers to interrogate the object rather
than storing a bool within the low bits of the pointer (or in some cases the
use of a common parent class removes the need to determine the type at all -
there is a common interface to ref or get the length of either ropes or strings).

• API/JSClassRef.cpp:

(OpaqueJSClass::OpaqueJSClass):
(OpaqueJSClassContextData::OpaqueJSClassContextData):

• bytecompiler/BytecodeGenerator.cpp:

(JSC::keyForCharacterSwitch):

• interpreter/Interpreter.cpp:

(JSC::Interpreter::privateExecute):

• jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

• runtime/ArrayPrototype.cpp:

(JSC::arrayProtoFuncToString):

• runtime/Identifier.cpp:

(JSC::Identifier::equal):
(JSC::Identifier::addSlowCase):

• runtime/JSString.cpp:

(JSC::JSString::resolveRope):

• runtime/JSString.h:

(JSC::):
(JSC::RopeBuilder::JSString):
(JSC::RopeBuilder::~JSString):
(JSC::RopeBuilder::appendStringInConstruct):
(JSC::RopeBuilder::appendValueInConstructAndIncrementLength):
(JSC::RopeBuilder::JSStringFinalizerStruct::JSStringFinalizerStruct):
(JSC::RopeBuilder::JSStringFinalizerStruct::):

• runtime/UString.cpp:

(JSC::UString::toStrictUInt32):
(JSC::equal):

• runtime/UString.h:

(JSC::UString::isEmpty):
(JSC::UString::size):

• runtime/UStringImpl.cpp:

(JSC::URopeImpl::derefFibersNonRecursive):
(JSC::URopeImpl::destructNonRecursive):

• runtime/UStringImpl.h:

(JSC::UStringOrRopeImpl::isRope):
(JSC::UStringOrRopeImpl::length):
(JSC::UStringOrRopeImpl::ref):
(JSC::UStringOrRopeImpl::):
(JSC::UStringOrRopeImpl::operator new):
(JSC::UStringOrRopeImpl::UStringOrRopeImpl):
(JSC::UStringImpl::adopt):
(JSC::UStringImpl::createUninitialized):
(JSC::UStringImpl::tryCreateUninitialized):
(JSC::UStringImpl::data):
(JSC::UStringImpl::cost):
(JSC::UStringImpl::deref):
(JSC::UStringImpl::UStringImpl):
(JSC::UStringImpl::):
(JSC::URopeImpl::tryCreateUninitialized):
(JSC::URopeImpl::initializeFiber):
(JSC::URopeImpl::fiberCount):
(JSC::URopeImpl::fibers):
(JSC::URopeImpl::deref):
(JSC::URopeImpl::URopeImpl):
(JSC::URopeImpl::hasOneRef):
(JSC::UStringOrRopeImpl::deref):

WebCore:

Renamed cUStringImpl::size() to UStringImpl::size()UStringImpl::length()
(matches WebCore::StringImpl).

• bridge/jni/jsc/JavaStringJSC.h:

(JSC::Bindings::JavaStringImpl::length):

• platform/text/AtomicString.cpp:

(WebCore::AtomicString::add):
(WebCore::AtomicString::find):

File:

• trunk/JavaScriptCore/runtime/JSString.h (modified) (11 diffs)

trunk/JavaScriptCore/runtime/JSString.h

@@ -33 +33 @@
 namespace JSC {
 
-    // FIXME: this class is on its way out into a different header.
-    class Rope : public RefCounted<Rope> {
-    public:
-        // A Rope is composed from a set of smaller strings called Fibers.
-        // Each Fiber in a rope is either UString::Rep or another Rope.
-        class Fiber {
-        public:
-            Fiber() : m_value(0) {}
-            Fiber(UString::Rep* string) : m_value(reinterpret_cast<intptr_t>(string)) {}
-            Fiber(Rope* rope) : m_value(reinterpret_cast<intptr_t>(rope) | 1) {}
-
-            Fiber(void* nonFiber) : m_value(reinterpret_cast<intptr_t>(nonFiber)) {}
-
-            void deref()
-            {
-                if (isRope())
-                    rope()->deref();
-                else
-                    string()->deref();
-            }
-
-            Fiber& ref()
-            {
-                if (isString())
-                    string()->ref();
-                else
-                    rope()->ref();
-                return *this;
-            }
-
-            unsigned refAndGetLength()
-            {
-                if (isString()) {
-                    UString::Rep* rep = string();
-                    return rep->ref()->size();
-                } else {
-                    Rope* r = rope();
-                    r->ref();
-                    return r->length();
-                }
-            }
-
-            bool isRope() { return m_value & 1; }
-            Rope* rope() { return reinterpret_cast<Rope*>(m_value & ~1); }
-            bool isString() { return !isRope(); }
-            UString::Rep* string() { return reinterpret_cast<UString::Rep*>(m_value); }
-
-            void* nonFiber() { return reinterpret_cast<void*>(m_value); }
-        private:
-            intptr_t m_value;
-        };
-
-        // Creates a Rope comprising of 'fiberCount' Fibers.
-        // The Rope is constructed in an uninitialized state - initialize must be called for each Fiber in the Rope.
-        static PassRefPtr<Rope> tryCreateUninitialized(unsigned fiberCount)
-        {
-            void* allocation;
-            if (tryFastMalloc(sizeof(Rope) + (fiberCount - 1) * sizeof(Fiber)).getValue(allocation))
-                return adoptRef(new (allocation) Rope(fiberCount));
-            return 0;
-        }
-
-        ~Rope();
-        void destructNonRecursive();
-
-        void initializeFiber(unsigned &index, Fiber& fiber)
-        {
-            m_fibers[index++] = fiber;
-            m_length += fiber.refAndGetLength();
-        }
-        void initializeFiber(unsigned &index, UStringImpl* impl)
-        {
-            m_fibers[index++] = Fiber(impl);
-            m_length += impl->ref()->size();
-        }
-
-        unsigned fiberCount() { return m_fiberCount; }
-        unsigned length() { return m_length; }
-        Fiber& fibers(unsigned index) { return m_fibers[index]; }
-
-    private:
-        Rope(unsigned fiberCount) : m_fiberCount(fiberCount), m_length(0) {}
-        void* operator new(size_t, void* inPlace) { return inPlace; }
-        
-        unsigned m_fiberCount;
-        unsigned m_length;
-        Fiber m_fibers[1];
-    };
-
     class JSString;
 
@@ -156 +67 @@
         friend class JIT;
         friend class JSGlobalData;
+
+        typedef URopeImpl Rope;
 
         class RopeBuilder {
@@ -181 +94 @@
                 if (jsString->isRope()) {
                     for (unsigned i = 0; i < jsString->m_fiberCount; ++i)
-                        append(jsString->m_fibers[i]);
+                        append(jsString->m_other.m_fibers[i]);
                 } else
                     append(jsString->string());
@@ -216 +129 @@
         JSString(JSGlobalData* globalData, PassRefPtr<UString::Rep> value, HasOtherOwnerType)
             : JSCell(globalData->stringStructure.get())
-            , m_length(value->size())
+            , m_length(value->length())
             , m_value(value)
             , m_fiberCount(0)
@@ -226 +139 @@
             , m_fiberCount(1)
         {
-            m_fibers[0] = rope.releaseRef();
+            m_other.m_fibers[0] = rope.releaseRef();
         }
         // This constructor constructs a new string by concatenating s1 & s2.
@@ -290 +203 @@
         {
             // nasty hack because we can't union non-POD types
-            m_fibers[0] = reinterpret_cast<void*>(reinterpret_cast<ptrdiff_t>(finalizer));
-            m_fibers[1] = context;
+            m_other.m_finalizerCallback = finalizer;
+            m_other.m_finalizerContext = context;
             Heap::heap(this)->reportExtraMemoryCost(value.cost());
         }
@@ -299 +212 @@
             ASSERT(vptr() == JSGlobalData::jsStringVPtr);
             for (unsigned i = 0; i < m_fiberCount; ++i)
-                m_fibers[i].deref();
-
-            if (!m_fiberCount && m_fibers[0].nonFiber()) {
-                JSStringFinalizerCallback finalizer = reinterpret_cast<JSStringFinalizerCallback>(m_fibers[0].nonFiber());
-                finalizer(this, m_fibers[1].nonFiber());
-            }
+                m_other.m_fibers[i]->deref();
+
+            if (!m_fiberCount && m_other.m_finalizerCallback)
+                m_other.m_finalizerCallback(this, m_other.m_finalizerContext);
         }
 
@@ -343 +254 @@
         void appendStringInConstruct(unsigned& index, const UString& string)
         {
-            m_fibers[index++] = Rope::Fiber(string.rep()->ref());
+            UStringImpl* impl = string.rep();
+            impl->ref();
+            m_other.m_fibers[index++] = impl;
         }
 
@@ -349 +262 @@
         {
             if (jsString->isRope()) {
-                for (unsigned i = 0; i < jsString->m_fiberCount; ++i)
-                    m_fibers[index++] = jsString->m_fibers[i].ref();
+                for (unsigned i = 0; i < jsString->m_fiberCount; ++i) {
+                    Rope::Fiber fiber = jsString->m_other.m_fibers[i];
+                    fiber->ref();
+                    m_other.m_fibers[index++] = fiber;
+                }
             } else
                 appendStringInConstruct(index, jsString->string());
@@ -365 +281 @@
             } else {
                 UString u(v.toString(exec));
-                m_fibers[index++] = Rope::Fiber(u.rep()->ref());
+                UStringImpl* impl = u.rep();
+                impl->ref();
+                m_other.m_fibers[index++] = impl;
                 m_length += u.size();
             }
@@ -392 +310 @@
         mutable UString m_value;
         mutable unsigned m_fiberCount;
-        mutable Rope::Fiber m_fibers[s_maxInternalRopeLength];
+        // This structure exists to support a temporary workaround for a GC issue.
+        struct JSStringFinalizerStruct {
+            JSStringFinalizerStruct() : m_finalizerCallback(0) {}
+            union {
+                mutable Rope::Fiber m_fibers[s_maxInternalRopeLength];
+                struct {
+                    JSStringFinalizerCallback m_finalizerCallback;
+                    void* m_finalizerContext;
+                };
+            };
+        } m_other;
 
         bool isRope() const { return m_fiberCount; }