Changeset 59064 in webkit for trunk/JavaScriptCore

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):

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• bytecode/CodeBlock.cpp (modified) (4 diffs)
• bytecode/CodeBlock.h (modified) (2 diffs)
• bytecode/Opcode.h (modified) (1 diff)
• bytecompiler/BytecodeGenerator.cpp (modified) (4 diffs)
• bytecompiler/BytecodeGenerator.h (modified) (3 diffs)
• bytecompiler/NodesCodegen.cpp (modified) (1 diff)
• interpreter/Interpreter.cpp (modified) (1 diff)
• jit/JIT.cpp (modified) (1 diff)
• jit/JIT.h (modified) (1 diff)
• jit/JITOpcodes.cpp (modified) (2 diffs)
• jit/JITStubs.cpp (modified) (1 diff)
• jit/JITStubs.h (modified) (1 diff)

trunk/JavaScriptCore/ChangeLog

@@ -34 +34 @@
 
         * JavaScriptCore.pri:
+
+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
+        <rdar://problem/7961634>
+
+        Rollout r57955
+
+        * bytecode/CodeBlock.cpp:
+        (JSC::regexpToSourceString):
+        (JSC::regexpName):
+        (JSC::CodeBlock::dump):
+        (JSC::CodeBlock::shrinkToFit):
+        * bytecode/CodeBlock.h:
+        (JSC::CodeBlock::addRegExp):
+        (JSC::CodeBlock::regexp):
+        * bytecode/Opcode.h:
+        * bytecompiler/BytecodeGenerator.cpp:
+        (JSC::BytecodeGenerator::addRegExp):
+        (JSC::BytecodeGenerator::emitNewRegExp):
+        * bytecompiler/BytecodeGenerator.h:
+        * bytecompiler/NodesCodegen.cpp:
+        (JSC::RegExpNode::emitBytecode):
+        * interpreter/Interpreter.cpp:
+        (JSC::Interpreter::privateExecute):
+        * jit/JIT.cpp:
+        (JSC::JIT::privateCompileMainPass):
+        * jit/JIT.h:
+        * jit/JITOpcodes.cpp:
+        (JSC::JIT::emit_op_new_regexp):
+        * jit/JITStubs.cpp:
+        (JSC::DEFINE_STUB_FUNCTION):
+        * jit/JITStubs.h:
+        (JSC::):
 
 2010-05-09  Oliver Hunt  <[email protected]>

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();

trunk/JavaScriptCore/bytecode/CodeBlock.h

@@ -459 +459 @@
         FunctionExecutable* functionExpr(int index) { return m_functionExprs[index].get(); }
 
+        unsigned addRegExp(RegExp* r) { createRareDataIfNecessary(); unsigned size = m_rareData->m_regexps.size(); m_rareData->m_regexps.append(r); return size; }
+        RegExp* regexp(int index) const { ASSERT(m_rareData); return m_rareData->m_regexps[index].get(); }
+
+
         // Jump Tables
 
@@ -553 +557 @@
             Vector<HandlerInfo> m_exceptionHandlers;
 
+            // Rare Constants
+            Vector<RefPtr<RegExp> > m_regexps;
+
             // Jump Tables
             Vector<SimpleJumpTable> m_immediateSwitchJumpTables;

trunk/JavaScriptCore/bytecode/Opcode.h

@@ -47 +47 @@
         macro(op_new_object, 2) \
         macro(op_new_array, 4) \
+        macro(op_new_regexp, 3) \
         macro(op_mov, 3) \
         \

trunk/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

@@ -35 +35 @@
 #include "JSFunction.h"
 #include "Interpreter.h"
-#include "RegExp.h"
-#include "RegExpObject.h"
 #include "UString.h"
 
@@ -828 +826 @@
 
     return &m_constantPoolRegisters[index];
+}
+
+unsigned BytecodeGenerator::addRegExp(RegExp* r)
+{
+    return m_codeBlock->addRegExp(r);
 }
 
@@ -980 +983 @@
 }
 
-RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, RegExp* regExp)
-{
-    JSValue jsRegExp = new (globalData()) RegExpObject(m_scopeChain->globalObject()->regExpStructure(), regExp);
-    return emitLoad(dst, jsRegExp);
-}
-
 RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, JSValue v)
 {
@@ -1381 +1378 @@
 }
 
+RegisterID* BytecodeGenerator::emitNewRegExp(RegisterID* dst, RegExp* regExp)
+{
+    emitOpcode(op_new_regexp);
+    instructions().append(dst->index());
+    instructions().append(addRegExp(regExp));
+    return dst;
+}
+
+
 RegisterID* BytecodeGenerator::emitNewFunctionExpression(RegisterID* r0, FuncExprNode* n)
 {

trunk/JavaScriptCore/bytecompiler/BytecodeGenerator.h

@@ -265 +265 @@
         RegisterID* emitLoad(RegisterID* dst, double);
         RegisterID* emitLoad(RegisterID* dst, const Identifier&);
-        RegisterID* emitLoad(RegisterID* dst, RegExp* regExp);
         RegisterID* emitLoad(RegisterID* dst, JSValue);
 
@@ -278 +277 @@
         RegisterID* emitNewFunction(RegisterID* dst, FunctionBodyNode* body);
         RegisterID* emitNewFunctionExpression(RegisterID* dst, FuncExprNode* func);
+        RegisterID* emitNewRegExp(RegisterID* dst, RegExp* regExp);
 
         RegisterID* emitMove(RegisterID* dst, RegisterID* src);
@@ -447 +447 @@
         unsigned addConstant(const Identifier&);
         RegisterID* addConstantValue(JSValue);
+        unsigned addRegExp(RegExp*);
 
         PassRefPtr<FunctionExecutable> makeFunction(ExecState* exec, FunctionBodyNode* body)

trunk/JavaScriptCore/bytecompiler/NodesCodegen.cpp

@@ -150 +150 @@
     if (dst == generator.ignoredResult())
         return 0;
-    return generator.emitLoad(generator.finalDestination(dst), regExp.get());
+    return generator.emitNewRegExp(generator.finalDestination(dst), regExp.get());
 }
 

trunk/JavaScriptCore/interpreter/Interpreter.cpp

@@ -1305 +1305 @@
 
         vPC += OPCODE_LENGTH(op_new_array);
+        NEXT_INSTRUCTION();
+    }
+    DEFINE_OPCODE(op_new_regexp) {
+        /* new_regexp dst(r) regExp(re)
+
+           Constructs a new RegExp instance using the original
+           constructor from regexp regExp, and puts the result in
+           register dst.
+        */
+        int dst = vPC[1].u.operand;
+        int regExp = vPC[2].u.operand;
+        callFrame->r(dst) = JSValue(new (globalData) RegExpObject(callFrame->scopeChain()->globalObject->regExpStructure(), callFrame->codeBlock()->regexp(regExp)));
+
+        vPC += OPCODE_LENGTH(op_new_regexp);
         NEXT_INSTRUCTION();
     }

trunk/JavaScriptCore/jit/JIT.cpp

@@ -276 +276 @@
         DEFINE_OP(op_new_func_exp)
         DEFINE_OP(op_new_object)
+        DEFINE_OP(op_new_regexp)
         DEFINE_OP(op_next_pname)
         DEFINE_OP(op_not)

trunk/JavaScriptCore/jit/JIT.h

@@ -695 +695 @@
         void emit_op_new_func_exp(Instruction*);
         void emit_op_new_object(Instruction*);
+        void emit_op_new_regexp(Instruction*);
         void emit_op_get_pnames(Instruction*);
         void emit_op_next_pname(Instruction*);

trunk/JavaScriptCore/jit/JITOpcodes.cpp

@@ -964 +964 @@
 }
 
+void JIT::emit_op_new_regexp(Instruction* currentInstruction)
+{
+    JITStubCall stubCall(this, cti_op_new_regexp);
+    stubCall.addArgument(ImmPtr(m_codeBlock->regexp(currentInstruction[2].u.operand)));
+    stubCall.call(currentInstruction[1].u.operand);
+}
+
 void JIT::emit_op_bitor(Instruction* currentInstruction)
 {
@@ -1630 +1637 @@
 }
 
+void JIT::emit_op_new_regexp(Instruction* currentInstruction)
+{
+    JITStubCall stubCall(this, cti_op_new_regexp);
+    stubCall.addArgument(ImmPtr(m_codeBlock->regexp(currentInstruction[2].u.operand)));
+    stubCall.call(currentInstruction[1].u.operand);
+}
+
 // For both JSValue32_64 and JSValue32
 #if ENABLE(JIT_OPTIMIZE_MOD)

trunk/JavaScriptCore/jit/JITStubs.cpp

@@ -2871 +2871 @@
 }
 
+DEFINE_STUB_FUNCTION(JSObject*, op_new_regexp)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    return new (stackFrame.globalData) RegExpObject(stackFrame.callFrame->lexicalGlobalObject()->regExpStructure(), stackFrame.args[0].regExp());
+}
+
 DEFINE_STUB_FUNCTION(EncodedJSValue, op_bitor)
 {

trunk/JavaScriptCore/jit/JITStubs.h

@@ -358 +358 @@
     JSObject* JIT_STUB cti_op_new_func_exp(STUB_ARGS_DECLARATION);
     JSObject* JIT_STUB cti_op_new_object(STUB_ARGS_DECLARATION);
+    JSObject* JIT_STUB cti_op_new_regexp(STUB_ARGS_DECLARATION);
     JSObject* JIT_STUB cti_op_push_activation(STUB_ARGS_DECLARATION);
     JSObject* JIT_STUB cti_op_push_new_scope(STUB_ARGS_DECLARATION);