Changeset 59064 in webkit for trunk/JavaScriptCore/bytecode/CodeBlock.cpp

Timestamp:

May 9, 2010, 6:41:07 PM (15 years ago)

Author:

[email protected]

Message:

2010-05-09 Geoffrey Garen <​[email protected]>

Reviewed by Oliver Hunt.

Reserve a large-ish initial capacity for Lexer::m_buffer16.

SunSpider says 0.3% faster.

m_buffer16 is used when parsing complex strings -- for example, strings
with escape sequences in them. These kinds of strings can be really long,
and we want to avoid repeatedly copying as we grow m_buffer16.

The net memory cost is quite low, since it's proporitional to source
code we already have in memory, and we throw away m_buffer16 right when
we're done parsing.

• parser/Lexer.cpp: (JSC::Lexer::Lexer): No need to reserve initial capacity in our constructor, since setCode will be called before we're asked to lex anything. (JSC::Lexer::setCode): Reserve enough space to lex half the source code as a complex string without having to copy. (JSC::Lexer::clear): No need to reserve initial capacity here either, since setCode will be called before we're asked to lex anything.

2010-05-09 Oliver Hunt <​[email protected]>

Reviewed by Gavin Barraclough.

REGRESSION(r57955): RegExp literals should not actually be cached, so r57955 should be rolled out.
​https://bugs.webkit.org/show_bug.cgi?id=38828

Replace incorrect test for caching regexp literals with ones that tests that they are not cached.

• fast/js/regexp-literals-are-constants-expected.txt: Removed.
• fast/js/regexp-literals-are-constants.html: Removed.
• fast/js/regexp-literals-arent-constants-expected.txt: Added.
• fast/js/regexp-literals-arent-constants.html: Added.
• fast/js/script-tests/regexp-literals-are-constants.js: Removed.
• fast/js/script-tests/regexp-literals-arent-constants.js: Added. (test1): (returnRegExpLiteral): (returnConditionalRegExpLiteral):

File:

• trunk/JavaScriptCore/bytecode/CodeBlock.cpp (modified) (4 diffs)

trunk/JavaScriptCore/bytecode/CodeBlock.cpp

@@ -90 +90 @@
 }
 
+static UString regexpToSourceString(RegExp* regExp)
+{
+    char postfix[5] = { '/', 0, 0, 0, 0 };
+    int index = 1;
+    if (regExp->global())
+        postfix[index++] = 'g';
+    if (regExp->ignoreCase())
+        postfix[index++] = 'i';
+    if (regExp->multiline())
+        postfix[index] = 'm';
+
+    return makeString("/", regExp->pattern(), postfix);
+}
+
+static CString regexpName(int re, RegExp* regexp)
+{
+    return makeString(regexpToSourceString(regexp), "(@re", UString::from(re), ")").UTF8String();
+}
+
 static UString pointerToSourceString(void* p)
 {
@@ -350 +369 @@
     }
 
+    if (m_rareData && !m_rareData->m_regexps.isEmpty()) {
+        printf("\nm_regexps:\n");
+        size_t i = 0;
+        do {
+            printf("  re%u = %s\n", static_cast<unsigned>(i), regexpToSourceString(m_rareData->m_regexps[i].get()).ascii());
+            ++i;
+        } while (i < m_rareData->m_regexps.size());
+    }
+
 #if ENABLE(JIT)
     if (!m_globalResolveInfos.isEmpty() || !m_structureStubInfos.isEmpty())
@@ -485 +513 @@
             int argc = (++it)->u.operand;
             printf("[%4d] new_array\t %s, %s, %d\n", location, registerName(exec, dst).data(), registerName(exec, argv).data(), argc);
+            break;
+        }
+        case op_new_regexp: {
+            int r0 = (++it)->u.operand;
+            int re0 = (++it)->u.operand;
+            printf("[%4d] new_regexp\t %s, %s\n", location, registerName(exec, r0).data(), regexpName(re0, regexp(re0)).data());
             break;
         }
@@ -1696 +1730 @@
     if (m_rareData) {
         m_rareData->m_exceptionHandlers.shrinkToFit();
+        m_rareData->m_regexps.shrinkToFit();
         m_rareData->m_immediateSwitchJumpTables.shrinkToFit();
         m_rareData->m_characterSwitchJumpTables.shrinkToFit();