Changeset 174401 in webkit for trunk/Source/JavaScriptCore/bytecompiler

Timestamp:

Oct 7, 2014, 11:57:57 AM (11 years ago)

Author:

[email protected]

Message:

Remove op_new_captured_func
​https://bugs.webkit.org/show_bug.cgi?id=137491

Reviewed by Mark Lam.

Removes the op_captured_new_func opcode as part of the work
towards having any magical opcodes that write directly to
named "registers" and then have a follow on op to ensure that
the environment record correctly represents the stack state.

For this we add a non-captured scratch register so we don't
have to have any kind of magic opcode, and instead simply
have sensible creation and move semantics for capturing new
functions.

• bytecode/BytecodeList.json:
• bytecode/BytecodeUseDef.h:

(JSC::computeUsesForBytecodeOffset):
(JSC::computeDefsForBytecodeOffset):

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::dumpBytecode):
(JSC::CodeBlock::CodeBlock):

• bytecompiler/BytecodeGenerator.cpp:

(JSC::BytecodeGenerator::BytecodeGenerator):
(JSC::BytecodeGenerator::emitNewFunction):
(JSC::BytecodeGenerator::emitLazyNewFunction):
(JSC::BytecodeGenerator::emitNewFunctionInternal):

• bytecompiler/BytecodeGenerator.h:
• dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::parseBlock):

• dfg/DFGCapabilities.cpp:

(JSC::DFG::capabilityLevel):

• jit/JIT.cpp:

(JSC::JIT::privateCompileMainPass):

• jit/JIT.h:
• jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_new_captured_func): Deleted.

• llint/LowLevelInterpreter32_64.asm:
• llint/LowLevelInterpreter64.asm:
• runtime/CommonSlowPaths.cpp:

(JSC::SLOW_PATH_DECL): Deleted.

• runtime/CommonSlowPaths.h:

Location:

trunk/Source/JavaScriptCore/bytecompiler

Files:

• BytecodeGenerator.cpp (modified) (5 diffs)
• BytecodeGenerator.h (modified) (1 diff)

trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

@@ -251 +251 @@
         instructions().append(m_lexicalEnvironmentRegister->index());
     }
-
+    RegisterID* scratch = addVar();
     m_symbolTable->setCaptureStart(virtualRegisterForLocal(m_codeBlock->m_numVars).offset());
 
@@ -333 +333 @@
             if (functionBody->captures(ident) || shouldCaptureAllTheThings) {
                 m_functions.add(ident.impl());
-                // We rely on still allocating stack space for captured variables
-                // here.
-                RegisterID* newFunction = emitNewFunction(addVar(ident, IsVariable, IsWatchable), IsCaptured, function);
-                initializeCapturedVariable(newFunction, ident, newFunction);
+                emitNewFunction(scratch, function);
+                initializeCapturedVariable(addVar(ident, IsVariable, IsWatchable), ident, scratch);
             }
         }
@@ -360 +358 @@
                 // as this would complicate lazy instantiation of actual arguments.
                 if (!canLazilyCreateFunctions || ident == propertyNames().arguments)
-                    emitNewFunction(reg.get(), NotCaptured, function);
+                    emitNewFunction(reg.get(), function);
                 else {
                     emitInitLazyRegister(reg.get());
@@ -1658 +1656 @@
 }
 
-RegisterID* BytecodeGenerator::emitNewFunction(RegisterID* dst, CaptureMode captureMode, FunctionBodyNode* function)
-{
-    return emitNewFunctionInternal(dst, captureMode, m_codeBlock->addFunctionDecl(makeFunction(function)), false);
+RegisterID* BytecodeGenerator::emitNewFunction(RegisterID* dst, FunctionBodyNode* function)
+{
+    return emitNewFunctionInternal(dst, m_codeBlock->addFunctionDecl(makeFunction(function)), false);
 }
 
@@ -1668 +1666 @@
     if (ptr.isNewEntry)
         ptr.iterator->value = m_codeBlock->addFunctionDecl(makeFunction(function));
-    return emitNewFunctionInternal(dst, NotCaptured, ptr.iterator->value, true);
-}
-
-RegisterID* BytecodeGenerator::emitNewFunctionInternal(RegisterID* dst, CaptureMode captureMode, unsigned index, bool doNullCheck)
-{
-    emitOpcode(captureMode == IsCaptured ? op_new_captured_func : op_new_func);
+    return emitNewFunctionInternal(dst, ptr.iterator->value, true);
+}
+
+RegisterID* BytecodeGenerator::emitNewFunctionInternal(RegisterID* dst, unsigned index, bool doNullCheck)
+{
+    emitOpcode(op_new_func);
     instructions().append(dst->index());
     instructions().append(index);
-    if (captureMode == IsCaptured) {
-        ASSERT(!doNullCheck);
-        instructions().append(watchableVariable(dst->index()));
-    } else
-        instructions().append(doNullCheck);
+    instructions().append(doNullCheck);
     return dst;
 }

trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h

@@ -450 +450 @@
         RegisterID* emitNewArray(RegisterID* dst, ElementNode*, unsigned length); // stops at first elision
 
-        RegisterID* emitNewFunction(RegisterID* dst, CaptureMode, FunctionBodyNode*);
+        RegisterID* emitNewFunction(RegisterID* dst, FunctionBodyNode*);
         RegisterID* emitLazyNewFunction(RegisterID* dst, FunctionBodyNode* body);
-        RegisterID* emitNewFunctionInternal(RegisterID* dst, CaptureMode, unsigned index, bool shouldNullCheck);
+        RegisterID* emitNewFunctionInternal(RegisterID* dst, unsigned index, bool shouldNullCheck);
         RegisterID* emitNewFunctionExpression(RegisterID* dst, FuncExprNode* func);
         RegisterID* emitNewRegExp(RegisterID* dst, RegExp*);