Changeset 39815 in webkit for trunk/JavaScriptCore/runtime/UString.h

Timestamp:

Jan 11, 2009, 7:19:23 PM (16 years ago)

Author:

Darin Adler

Message:

2009-01-11 David Levin <​[email protected]>

Reviewed by Darin Adler.

​https://bugs.webkit.org/show_bug.cgi?id=23175

Separate out BaseString information from UString::Rep and make all baseString access go through
a member function, so that it may be used for something else (in the future) in the BaseString
case.

• runtime/SmallStrings.cpp: (JSC::SmallStringsStorage::rep): (JSC::SmallStringsStorage::SmallStringsStorage): (JSC::SmallStrings::SmallStrings): (JSC::SmallStrings::mark): Adjust to account for the changes in UString and put the UString in place in SmallStringsStorage to aid in locality of reference among the UChar[] and UString::Rep's.

• runtime/SmallStrings.h:
• runtime/UString.cpp: (JSC::initializeStaticBaseString): (JSC::initializeUString): (JSC::UString::Rep::create): (JSC::UString::Rep::destroy): (JSC::UString::Rep::checkConsistency): (JSC::expandCapacity): (JSC::UString::expandPreCapacity): (JSC::concatenate): (JSC::UString::append): (JSC::UString::operator=):
• runtime/UString.h: (JSC::UString::Rep::baseIsSelf): (JSC::UString::Rep::setBaseString): (JSC::UString::Rep::baseString): (JSC::UString::Rep::): (JSC::UString::Rep::null): (JSC::UString::Rep::empty): (JSC::UString::Rep::data): (JSC::UString::cost): Separate out the items out used by base strings from those used in Rep's that only point to base strings. (This potentially saves 24 bytes per Rep.)

File:

• trunk/JavaScriptCore/runtime/UString.h (modified) (10 diffs)

trunk/JavaScriptCore/runtime/UString.h

@@ -28 +28 @@
 #include <string.h>
 #include <wtf/Assertions.h>
-#include <wtf/FastMalloc.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/PtrAndFlags.h>
@@ -77 +76 @@
 
     public:
-        struct Rep {
+        struct BaseString;
+        struct Rep : Noncopyable {
             friend class JIT;
 
@@ -90 +90 @@
             void destroy();
 
-            bool baseIsSelf() const { return baseString == this; }
-            UChar* data() const { return baseString->buf + baseString->preCapacity + offset; }
+            bool baseIsSelf() const { return m_identifierTableAndFlags.isFlagSet(BaseStringFlag); }
+            UChar* data() const;
             int size() const { return len; }
 
@@ -105 +105 @@
 
             bool isStatic() const { return m_identifierTableAndFlags.isFlagSet(StaticFlag); }
-            void setStatic(bool v) { ASSERT(!identifierTable()); if (v) m_identifierTableAndFlags.setFlag(StaticFlag); else m_identifierTableAndFlags.clearFlag(StaticFlag); }
+            void setStatic(bool);
+            void setBaseString(PassRefPtr<BaseString>);
+            BaseString* baseString();
+            const BaseString* baseString() const;
 
             Rep* ref() { ++rc; return this; }
@@ -112 +115 @@
             void checkConsistency() const;
             enum UStringFlags {
-                StaticFlag
+                StaticFlag,
+                BaseStringFlag
             };
 
@@ -121 +125 @@
             mutable unsigned _hash;
             PtrAndFlags<IdentifierTable, UStringFlags> m_identifierTableAndFlags;
-            UString::Rep* baseString;
-            size_t reportedCost;
-
-            // potentially shared data. 0 if backed up by a base string.
-            UChar* buf;
-            int usedCapacity;
-            int capacity;
-            int usedPreCapacity;
-            int preCapacity;
-
-            static Rep& null() { return *nullBaseString; }
-            static Rep& empty() { return *emptyBaseString; }
+            void* m_baseString; // If "this" is a BaseString instance, it is 0. BaseString* otherwise.
+
+            static BaseString& null() { return *nullBaseString; }
+            static BaseString& empty() { return *emptyBaseString; }
+
         private:
             friend void initializeUString();
-            static Rep* nullBaseString;
-            static Rep* emptyBaseString;
+            static BaseString* nullBaseString;
+            static BaseString* emptyBaseString;
+        };
+
+        struct BaseString : public Rep {
+            BaseString()
+            {
+                m_identifierTableAndFlags.setFlag(BaseStringFlag);
+            }
+
+            // potentially shared data.
+            UChar* buf;
+            int preCapacity;
+            int usedPreCapacity;
+            int capacity;
+            int usedCapacity;
+
+            size_t reportedCost;
         };
 
@@ -254 +267 @@
 
     private:
-        int usedCapacity() const;
-        int usedPreCapacity() const;
         void expandCapacity(int requiredLength);
         void expandPreCapacity(int requiredPreCap);
@@ -309 +320 @@
 
     bool equal(const UString::Rep*, const UString::Rep*);
+
+    inline UChar* UString::Rep::data() const
+    {
+        const BaseString* base = baseString();
+        return base->buf + base->preCapacity + offset;
+    }
+
+    inline void UString::Rep::setStatic(bool v)
+    {
+        ASSERT(!identifierTable());
+        if (v)
+            m_identifierTableAndFlags.setFlag(StaticFlag);
+        else
+            m_identifierTableAndFlags.clearFlag(StaticFlag);
+    }
+
+    inline void UString::Rep::setBaseString(PassRefPtr<BaseString> base)
+    {
+        ASSERT(base != this);
+        m_baseString = base.releaseRef();
+    }
+
+    inline UString::BaseString* UString::Rep::baseString()
+    {
+        return reinterpret_cast<BaseString*>(baseIsSelf() ? this : m_baseString);
+    }
+
+    inline const UString::BaseString* UString::Rep::baseString() const
+    {
+        return const_cast<const BaseString*>(const_cast<Rep*>(this)->baseString());
+    }
 
 #ifdef NDEBUG
@@ -340 +382 @@
     inline size_t UString::cost() const
     {
-        size_t capacity = (m_rep->baseString->capacity + m_rep->baseString->preCapacity) * sizeof(UChar);
-        size_t reportedCost = m_rep->baseString->reportedCost;
+        BaseString* base = m_rep->baseString();
+        size_t capacity = (base->capacity + base->preCapacity) * sizeof(UChar);
+        size_t reportedCost = base->reportedCost;
         ASSERT(capacity >= reportedCost);
 
@@ -349 +392 @@
             return 0;
 
-        m_rep->baseString->reportedCost = capacity;
+        base->reportedCost = capacity;
 
         return capacityDelta;