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

Timestamp:

Apr 7, 2009, 2:15:33 PM (16 years ago)

Author:

[email protected]

Message:

2009-04-07 David Levin <​[email protected]>

Reviewed by Sam Weinig and Geoff Garen.

​https://bugs.webkit.org/show_bug.cgi?id=25039
UString refactoring to support UChar* sharing.

No change in sunspider perf.

• runtime/SmallStrings.cpp: (JSC::SmallStringsStorage::SmallStringsStorage):
• runtime/UString.cpp: (JSC::initializeStaticBaseString): (JSC::initializeUString): (JSC::UString::BaseString::isShared): Encapsulate the meaning behind the refcount == 1 checks because this needs to do slightly more when sharing is added. (JSC::concatenate): (JSC::UString::append): (JSC::UString::operator=):
• runtime/UString.h: Make m_baseString part of a union to get rid of casts, but make it protected because it is tricky to use it correctly since it is only valid when the Rep is not a BaseString. The void* will be filled in when sharing is added.

Add constructors due to the making members protected and it make ensuring proper
initialization work better (like in SmallStringsStorage).
(JSC::UString::Rep::create):
(JSC::UString::Rep::Rep):
(JSC::UString::Rep::):
(JSC::UString::BaseString::BaseString):
(JSC::UString::Rep::setBaseString):
(JSC::UString::Rep::baseString):

File:

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

trunk/JavaScriptCore/runtime/UString.h

@@ -80 +80 @@
             friend class JIT;
 
-            static PassRefPtr<Rep> create(UChar*, int);
+            static PassRefPtr<Rep> create(UChar* buffer, int length)
+            {
+                return adoptRef(new BaseString(buffer, length));
+            }
+
             static PassRefPtr<Rep> createCopying(const UChar*, int);
             static PassRefPtr<Rep> create(PassRefPtr<Rep> base, int offset, int length);
@@ -125 +129 @@
             mutable unsigned _hash;
             PtrAndFlags<IdentifierTable, UStringFlags> m_identifierTableAndFlags;
-            void* m_baseString; // If "this" is a BaseString instance, it is 0. BaseString* otherwise.
 
             static BaseString& null() { return *nullBaseString; }
             static BaseString& empty() { return *emptyBaseString; }
 
+        protected:
+            Rep(int length)
+                : offset(0)
+                , len(length)
+                , rc(1)
+                , _hash(0)
+                , m_nothing(0)
+            {
+            }
+
+            Rep(PassRefPtr<BaseString> base, int offsetInBase, int length)
+                : offset(offsetInBase)
+                , len(length)
+                , rc(1)
+                , _hash(0)
+                , m_baseString(base.releaseRef())
+            {
+                checkConsistency();
+            }
+
+            union {
+                // If !baseIsSelf()
+                BaseString* m_baseString;
+                // If baseIsSelf()
+                void* m_nothing;
+            };
+
         private:
+            // For SmallStringStorage which allocates an array and does initialization manually.
+            Rep() { }
+
+            friend class SmallStringsStorage;
             friend void initializeUString();
             static BaseString* nullBaseString;
@@ -136 +170 @@
         };
 
+
         struct BaseString : public Rep {
-            BaseString()
-            {
-                m_identifierTableAndFlags.setFlag(BaseStringFlag);
-            }
+            bool isShared() { return rc != 1; }
 
             // potentially shared data.
@@ -150 +182 @@
 
             size_t reportedCost;
+
+        private:
+            BaseString(UChar* buffer, int length)
+                : Rep(length)
+                , buf(buffer)
+                , preCapacity(0)
+                , usedPreCapacity(0)
+                , capacity(length)
+                , usedCapacity(length)
+                , reportedCost(0)
+            {
+                m_identifierTableAndFlags.setFlag(BaseStringFlag);
+                checkConsistency();
+            }
+
+            friend struct Rep;
+            friend class SmallStringsStorage;
+            friend void initializeUString();
         };
 
@@ -321 +371 @@
     bool equal(const UString::Rep*, const UString::Rep*);
 
+    inline PassRefPtr<UString::Rep> UString::Rep::create(PassRefPtr<UString::Rep> rep, int offset, int length)
+    {
+        ASSERT(rep);
+        rep->checkConsistency();
+
+        int repOffset = rep->offset;
+
+        PassRefPtr<BaseString> base = rep->baseString();
+
+        ASSERT(-(offset + repOffset) <= base->usedPreCapacity);
+        ASSERT(offset + repOffset + length <= base->usedCapacity);
+
+        // Steal the single reference this Rep was created with.
+        return adoptRef(new Rep(base, repOffset + offset, length));
+    }
+
     inline UChar* UString::Rep::data() const
     {
@@ -339 +405 @@
     {
         ASSERT(base != this);
+        ASSERT(!baseIsSelf());
         m_baseString = base.releaseRef();
     }
@@ -344 +411 @@
     inline UString::BaseString* UString::Rep::baseString()
     {
-        return reinterpret_cast<BaseString*>(baseIsSelf() ? this : m_baseString);
+        return baseIsSelf() ? reinterpret_cast<BaseString*>(this) : m_baseString;
     }
 
     inline const UString::BaseString* UString::Rep::baseString() const
     {
-        return const_cast<const BaseString*>(const_cast<Rep*>(this)->baseString());
+        return const_cast<Rep*>(this)->baseString();
     }