Changeset 143384 in webkit

Timestamp:

Feb 19, 2013 2:29:03 PM (11 years ago)

Author:

ggaren@apple.com

Message:

Unreviewed, rolling in r143348.
​http://trac.webkit.org/changeset/143348
​https://bugs.webkit.org/show_bug.cgi?id=110242

The bug was that isEmptyValue() was returning true for the deleted value.
Fixed this and simplified things further by delegating to m_sourceCode
for both isNull() and isHashTableDeletedValue(), so they can't be out of
sync.

• runtime/CodeCache.cpp:

(JSC::CodeCache::getFunctionExecutableFromGlobalCode):

• runtime/CodeCache.h:

(JSC::SourceCodeKey::SourceCodeKey):
(JSC::SourceCodeKey::isHashTableDeletedValue):
(JSC::SourceCodeKey::hash):
(JSC::SourceCodeKey::length):
(JSC::SourceCodeKey::isNull):
(JSC::SourceCodeKey::operator==):
(SourceCodeKey):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• parser/SourceCode.h (modified) (2 diffs)
• runtime/CodeCache.cpp (modified) (1 diff)
• runtime/CodeCache.h (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2013-02-18  Geoffrey Garen  <ggaren@apple.com>
+
+        Unreviewed, rolling in r143348.
+        http://trac.webkit.org/changeset/143348
+        https://bugs.webkit.org/show_bug.cgi?id=110242
+
+        The bug was that isEmptyValue() was returning true for the deleted value.
+        Fixed this and simplified things further by delegating to m_sourceCode
+        for both isNull() and isHashTableDeletedValue(), so they can't be out of
+        sync.
+
+        * runtime/CodeCache.cpp:
+        (JSC::CodeCache::getFunctionExecutableFromGlobalCode):
+        * runtime/CodeCache.h:
+        (JSC::SourceCodeKey::SourceCodeKey):
+        (JSC::SourceCodeKey::isHashTableDeletedValue):
+        (JSC::SourceCodeKey::hash):
+        (JSC::SourceCodeKey::length):
+        (JSC::SourceCodeKey::isNull):
+        (JSC::SourceCodeKey::operator==):
+        (SourceCodeKey):
+
 2013-02-15  Martin Robinson  <mrobinson@igalia.com>
 

trunk/Source/JavaScriptCore/parser/SourceCode.h

@@ -45 +45 @@
         }
 
+        SourceCode(WTF::HashTableDeletedValueType)
+            : m_provider(WTF::HashTableDeletedValue)
+        {
+        }
+
         SourceCode(PassRefPtr<SourceProvider> provider, int firstLine = 1)
             : m_provider(provider)
@@ -60 +65 @@
         {
         }
+
+        bool isHashTableDeletedValue() const { return m_provider.isHashTableDeletedValue(); }
 
         String toString() const

trunk/Source/JavaScriptCore/runtime/CodeCache.cpp

@@ -106 +106 @@
 UnlinkedFunctionExecutable* CodeCache::getFunctionExecutableFromGlobalCode(JSGlobalData& globalData, const Identifier& name, const SourceCode& source, ParserError& error)
 {
-    SourceCodeKey key = SourceCodeKey(source, name.string(), SourceCodeKey::FunctionCallType, JSParseNormal);
+    SourceCodeKey key = SourceCodeKey(source, name.string(), SourceCodeKey::FunctionType, JSParseNormal);
     const Strong<JSCell>* result = m_sourceCode.find(key);
     if (result)

trunk/Source/JavaScriptCore/runtime/CodeCache.h

@@ -56 +56 @@
 class SourceCodeKey {
 public:
-    enum CodeType { EvalType, ProgramType, FunctionCallType, FunctionConstructType };
+    enum CodeType { EvalType, ProgramType, FunctionType };
 
     SourceCodeKey()
-        : m_flags(0)
     {
     }
 
     SourceCodeKey(const SourceCode& sourceCode, const String& name, CodeType codeType, JSParserStrictness jsParserStrictness)
-        : m_sourceString(sourceCode.toString())
+        : m_sourceCode(sourceCode)
         , m_name(name)
         , m_flags((codeType << 1) | jsParserStrictness)
+        , m_hash(string().impl()->hash())
     {
     }
 
     SourceCodeKey(WTF::HashTableDeletedValueType)
-        : m_sourceString(WTF::HashTableDeletedValue)
+        : m_sourceCode(WTF::HashTableDeletedValue)
     {
     }
 
-    bool isHashTableDeletedValue() const { return m_sourceString.isHashTableDeletedValue(); }
+    bool isHashTableDeletedValue() const { return m_sourceCode.isHashTableDeletedValue(); }
 
-    unsigned hash() const { return m_sourceString.impl()->hash(); }
+    unsigned hash() const { return m_hash; }
 
-    size_t length() const { return m_sourceString.length(); }
+    size_t length() const { return m_sourceCode.length(); }
 
-    bool isNull() const { return m_sourceString.isNull(); }
+    bool isNull() const { return m_sourceCode.isNull(); }
+
+    // To save memory, we compute our string on demand. It's expected that source
+    // providers cache their strings to make this efficient.
+    String string() const { return m_sourceCode.toString(); }
 
     bool operator==(const SourceCodeKey& other) const
     {
-        return m_flags == other.m_flags
+        return m_hash == other.m_hash
+            && length() == other.length()
+            && m_flags == other.m_flags
             && m_name == other.m_name
-            && m_sourceString == other.m_sourceString;
+            && string() == other.string();
     }
 
 private:
-    String m_sourceString;
+    SourceCode m_sourceCode;
     String m_name;
     unsigned m_flags;
+    unsigned m_hash;
 };