summaryrefslogtreecommitdiff
path: root/Source/JavaScriptCore/bytecompiler
diff options
context:
space:
mode:
Diffstat (limited to 'Source/JavaScriptCore/bytecompiler')
-rw-r--r--Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp3562
-rw-r--r--Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h859
-rw-r--r--Source/JavaScriptCore/bytecompiler/Label.h6
-rw-r--r--Source/JavaScriptCore/bytecompiler/LabelScope.h10
-rw-r--r--Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp2461
-rw-r--r--Source/JavaScriptCore/bytecompiler/RegisterID.h29
-rw-r--r--Source/JavaScriptCore/bytecompiler/SetForScope.h62
-rw-r--r--Source/JavaScriptCore/bytecompiler/StaticPropertyAnalysis.h6
-rw-r--r--Source/JavaScriptCore/bytecompiler/StaticPropertyAnalyzer.h2
9 files changed, 5244 insertions, 1753 deletions
diff --git a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
index 1fcc83ad9..ae8b4762c 100644
--- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
+++ b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2008, 2009, 2012, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2008, 2009, 2012-2015 Apple Inc. All rights reserved.
* Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
* Copyright (C) 2012 Igalia, S.L.
*
@@ -12,7 +12,7 @@
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
- * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ * 3. Neither the name of Apple Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
@@ -31,16 +31,21 @@
#include "config.h"
#include "BytecodeGenerator.h"
-#include "BatchedTransitionOptimizer.h"
+#include "BuiltinExecutables.h"
+#include "BytecodeLivenessAnalysis.h"
#include "Interpreter.h"
-#include "JSActivation.h"
#include "JSFunction.h"
-#include "JSNameScope.h"
+#include "JSGeneratorFunction.h"
+#include "JSLexicalEnvironment.h"
+#include "JSTemplateRegistryKey.h"
#include "LowLevelInterpreter.h"
-#include "Operations.h"
+#include "JSCInlines.h"
#include "Options.h"
+#include "StackAlignment.h"
#include "StrongInlines.h"
#include "UnlinkedCodeBlock.h"
+#include "UnlinkedInstructionStream.h"
+#include <wtf/StdLibExtras.h>
#include <wtf/text/WTFString.h>
using namespace std;
@@ -53,37 +58,49 @@ void Label::setLocation(unsigned location)
unsigned size = m_unresolvedJumps.size();
for (unsigned i = 0; i < size; ++i)
- m_generator->m_instructions[m_unresolvedJumps[i].second].u.operand = m_location - m_unresolvedJumps[i].first;
+ m_generator.instructions()[m_unresolvedJumps[i].second].u.operand = m_location - m_unresolvedJumps[i].first;
}
-#ifndef NDEBUG
-void ResolveResult::checkValidity()
-{
- switch (m_type) {
- case Register:
- case ReadOnlyRegister:
- ASSERT(m_local);
- return;
- case Dynamic:
- ASSERT(!m_local);
- return;
- case Lexical:
- case ReadOnlyLexical:
- ASSERT(!m_local);
- return;
- default:
- RELEASE_ASSERT_NOT_REACHED();
- }
-}
-#endif
-
ParserError BytecodeGenerator::generate()
{
SamplingRegion samplingRegion("Bytecode Generation");
-
- m_codeBlock->setThisRegister(m_thisRegister.index());
- m_scopeNode->emitBytecode(*this);
+ m_codeBlock->setThisRegister(m_thisRegister.virtualRegister());
+
+ // If we have declared a variable named "arguments" and we are using arguments then we should
+ // perform that assignment now.
+ if (m_needToInitializeArguments)
+ initializeVariable(variable(propertyNames().arguments), m_argumentsRegister);
+
+ if (m_restParameter)
+ m_restParameter->emit(*this);
+
+ {
+ RefPtr<RegisterID> temp = newTemporary();
+ RefPtr<RegisterID> globalScope;
+ for (auto functionPair : m_functionsToInitialize) {
+ FunctionMetadataNode* metadata = functionPair.first;
+ FunctionVariableType functionType = functionPair.second;
+ emitNewFunction(temp.get(), metadata);
+ if (functionType == NormalFunctionVariable)
+ initializeVariable(variable(metadata->ident()), temp.get());
+ else if (functionType == GlobalFunctionVariable) {
+ if (!globalScope) {
+ // We know this will resolve to the global object because our parser/global initialization code
+ // doesn't allow let/const/class variables to have the same names as functions.
+ RefPtr<RegisterID> globalObjectScope = emitResolveScope(nullptr, Variable(metadata->ident()));
+ globalScope = newBlockScopeVariable();
+ emitMove(globalScope.get(), globalObjectScope.get());
+ }
+ emitPutToScope(globalScope.get(), Variable(metadata->ident()), temp.get(), ThrowIfNotFound, NotInitialization);
+ } else
+ RELEASE_ASSERT_NOT_REACHED();
+ }
+ }
+
+ bool callingClassConstructor = constructorKind() != ConstructorKind::None && !isConstructor();
+ if (!callingClassConstructor)
+ m_scopeNode->emitBytecode(*this);
m_staticPropertyAnalyzer.kill();
@@ -117,16 +134,13 @@ ParserError BytecodeGenerator::generate()
if (end <= start)
continue;
- ASSERT(range.tryData->targetScopeDepth != UINT_MAX);
- UnlinkedHandlerInfo info = {
- static_cast<uint32_t>(start), static_cast<uint32_t>(end),
- static_cast<uint32_t>(range.tryData->target->bind()),
- range.tryData->targetScopeDepth
- };
+ ASSERT(range.tryData->handlerType != HandlerType::Illegal);
+ UnlinkedHandlerInfo info(static_cast<uint32_t>(start), static_cast<uint32_t>(end),
+ static_cast<uint32_t>(range.tryData->target->bind()), range.tryData->handlerType);
m_codeBlock->addExceptionHandler(info);
}
- m_codeBlock->instructions() = RefCountedArray<UnlinkedInstruction>(m_instructions);
+ m_codeBlock->setInstructions(std::make_unique<UnlinkedInstructionStream>(m_instructions));
m_codeBlock->shrinkToFit();
@@ -135,431 +149,863 @@ ParserError BytecodeGenerator::generate()
return ParserError(ParserError::ErrorNone);
}
-bool BytecodeGenerator::addVar(const Identifier& ident, bool isConstant, RegisterID*& r0)
-{
- int index = m_calleeRegisters.size();
- SymbolTableEntry newEntry(index, isConstant ? ReadOnly : 0);
- SymbolTable::AddResult result = symbolTable().add(ident.impl(), newEntry);
-
- if (!result.isNewEntry) {
- r0 = &registerFor(result.iterator->value.getIndex());
- return false;
- }
-
- r0 = addVar();
- return true;
-}
-
-void BytecodeGenerator::preserveLastVar()
-{
- if ((m_firstConstantIndex = m_calleeRegisters.size()) != 0)
- m_lastVar = &m_calleeRegisters.last();
-}
-
-BytecodeGenerator::BytecodeGenerator(VM& vm, JSScope*, ProgramNode* programNode, UnlinkedProgramCodeBlock* codeBlock, DebuggerMode debuggerMode, ProfilerMode profilerMode)
- : m_shouldEmitDebugHooks(debuggerMode == DebuggerOn)
- , m_shouldEmitProfileHooks(profilerMode == ProfilerOn)
- , m_symbolTable(0)
+BytecodeGenerator::BytecodeGenerator(VM& vm, ProgramNode* programNode, UnlinkedProgramCodeBlock* codeBlock, DebuggerMode debuggerMode, ProfilerMode profilerMode, const VariableEnvironment* parentScopeTDZVariables)
+ : m_shouldEmitDebugHooks(Options::forceDebuggerBytecodeGeneration() || debuggerMode == DebuggerOn)
+ , m_shouldEmitProfileHooks(Options::forceProfilerBytecodeGeneration() || profilerMode == ProfilerOn)
, m_scopeNode(programNode)
, m_codeBlock(vm, codeBlock)
, m_thisRegister(CallFrame::thisArgumentOffset())
- , m_emptyValueRegister(0)
- , m_globalObjectRegister(0)
- , m_finallyDepth(0)
- , m_dynamicScopeDepth(0)
, m_codeType(GlobalCode)
- , m_nextConstantOffset(0)
- , m_globalConstantIndex(0)
- , m_hasCreatedActivation(true)
- , m_firstLazyFunction(0)
- , m_lastLazyFunction(0)
- , m_staticPropertyAnalyzer(&m_instructions)
, m_vm(&vm)
- , m_lastOpcodeID(op_end)
-#ifndef NDEBUG
- , m_lastOpcodePosition(0)
-#endif
- , m_stack(vm, wtfThreadData().stack())
- , m_usesExceptions(false)
- , m_expressionTooDeep(false)
+ , m_needsToUpdateArrowFunctionContext(programNode->usesArrowFunction() || programNode->usesEval())
{
- if (m_shouldEmitDebugHooks)
- m_codeBlock->setNeedsFullScopeChain(true);
+ ASSERT_UNUSED(parentScopeTDZVariables, !parentScopeTDZVariables->size());
+
+ for (auto& constantRegister : m_linkTimeConstantRegisters)
+ constantRegister = nullptr;
+
+ allocateCalleeSaveSpace();
m_codeBlock->setNumParameters(1); // Allocate space for "this"
- emitOpcode(op_enter);
+ emitEnter();
+
+ allocateAndEmitScope();
- const VarStack& varStack = programNode->varStack();
const FunctionStack& functionStack = programNode->functionStack();
for (size_t i = 0; i < functionStack.size(); ++i) {
- FunctionBodyNode* function = functionStack[i];
- UnlinkedFunctionExecutable* unlinkedFunction = makeFunction(function);
- codeBlock->addFunctionDeclaration(*m_vm, function->ident(), unlinkedFunction);
+ FunctionMetadataNode* function = functionStack[i];
+ m_functionsToInitialize.append(std::make_pair(function, GlobalFunctionVariable));
+ }
+ if (Options::validateBytecode()) {
+ for (auto& entry : programNode->varDeclarations())
+ RELEASE_ASSERT(entry.value.isVar());
+ }
+ codeBlock->setVariableDeclarations(programNode->varDeclarations());
+ codeBlock->setLexicalDeclarations(programNode->lexicalVariables());
+ // Even though this program may have lexical variables that go under TDZ, when linking the get_from_scope/put_to_scope
+ // operations we emit we will have ResolveTypes that implictly do TDZ checks. Therefore, we don't need
+ // additional TDZ checks on top of those. This is why we can omit pushing programNode->lexicalVariables()
+ // to the TDZ stack.
+
+ if (needsToUpdateArrowFunctionContext()) {
+ initializeArrowFunctionContextScopeIfNeeded();
+ emitPutThisToArrowFunctionContextScope();
}
-
- for (size_t i = 0; i < varStack.size(); ++i)
- codeBlock->addVariableDeclaration(*varStack[i].first, !!(varStack[i].second & DeclarationStacks::IsConstant));
-
}
-BytecodeGenerator::BytecodeGenerator(VM& vm, JSScope* scope, FunctionBodyNode* functionBody, UnlinkedFunctionCodeBlock* codeBlock, DebuggerMode debuggerMode, ProfilerMode profilerMode)
- : m_shouldEmitDebugHooks(debuggerMode == DebuggerOn)
- , m_shouldEmitProfileHooks(profilerMode == ProfilerOn)
- , m_symbolTable(codeBlock->symbolTable())
- , m_scopeNode(functionBody)
- , m_scope(vm, scope)
+BytecodeGenerator::BytecodeGenerator(VM& vm, FunctionNode* functionNode, UnlinkedFunctionCodeBlock* codeBlock, DebuggerMode debuggerMode, ProfilerMode profilerMode, const VariableEnvironment* parentScopeTDZVariables)
+ : m_shouldEmitDebugHooks(Options::forceDebuggerBytecodeGeneration() || debuggerMode == DebuggerOn)
+ , m_shouldEmitProfileHooks(Options::forceProfilerBytecodeGeneration() || profilerMode == ProfilerOn)
+ , m_scopeNode(functionNode)
, m_codeBlock(vm, codeBlock)
- , m_activationRegister(0)
- , m_emptyValueRegister(0)
- , m_globalObjectRegister(0)
- , m_finallyDepth(0)
- , m_dynamicScopeDepth(0)
, m_codeType(FunctionCode)
- , m_nextConstantOffset(0)
- , m_globalConstantIndex(0)
- , m_hasCreatedActivation(false)
- , m_firstLazyFunction(0)
- , m_lastLazyFunction(0)
- , m_staticPropertyAnalyzer(&m_instructions)
, m_vm(&vm)
- , m_lastOpcodeID(op_end)
-#ifndef NDEBUG
- , m_lastOpcodePosition(0)
-#endif
- , m_stack(vm, wtfThreadData().stack())
- , m_usesExceptions(false)
- , m_expressionTooDeep(false)
+ , m_isBuiltinFunction(codeBlock->isBuiltinFunction())
+ , m_usesNonStrictEval(codeBlock->usesEval() && !codeBlock->isStrictMode())
+ // FIXME: We should be able to have tail call elimination with the profiler
+ // enabled. This is currently not possible because the profiler expects
+ // op_will_call / op_did_call pairs before and after a call, which are not
+ // compatible with tail calls (we have no way of emitting op_did_call).
+ // https://bugs.webkit.org/show_bug.cgi?id=148819
+ , m_inTailPosition(Options::useTailCalls() && !isConstructor() && constructorKind() == ConstructorKind::None && isStrictMode() && !m_shouldEmitProfileHooks)
+ , m_needsToUpdateArrowFunctionContext(functionNode->usesArrowFunction() || functionNode->usesEval())
+ , m_derivedContextType(codeBlock->derivedContextType())
{
- if (m_shouldEmitDebugHooks)
- m_codeBlock->setNeedsFullScopeChain(true);
+ for (auto& constantRegister : m_linkTimeConstantRegisters)
+ constantRegister = nullptr;
- m_symbolTable->setUsesNonStrictEval(codeBlock->usesEval() && !codeBlock->isStrictMode());
- m_symbolTable->setParameterCountIncludingThis(functionBody->parameters()->size() + 1);
+ if (m_isBuiltinFunction)
+ m_shouldEmitDebugHooks = false;
- emitOpcode(op_enter);
- if (m_codeBlock->needsFullScopeChain()) {
- m_activationRegister = addVar();
- emitInitLazyRegister(m_activationRegister);
- m_codeBlock->setActivationRegister(m_activationRegister->index());
+ allocateCalleeSaveSpace();
+
+ SymbolTable* functionSymbolTable = SymbolTable::create(*m_vm);
+ functionSymbolTable->setUsesNonStrictEval(m_usesNonStrictEval);
+ int symbolTableConstantIndex = addConstantValue(functionSymbolTable)->index();
+
+ Vector<Identifier> boundParameterProperties;
+ FunctionParameters& parameters = *functionNode->parameters();
+ if (!parameters.hasDefaultParameterValues()) {
+ // If we do have default parameters, they will be allocated in a separate scope.
+ for (size_t i = 0; i < parameters.size(); i++) {
+ auto pattern = parameters.at(i).first;
+ if (pattern->isBindingNode())
+ continue;
+ pattern->collectBoundIdentifiers(boundParameterProperties);
+ }
}
- m_symbolTable->setCaptureStart(m_codeBlock->m_numVars);
+ SourceParseMode parseMode = codeBlock->parseMode();
- if (functionBody->usesArguments() || codeBlock->usesEval() || m_shouldEmitDebugHooks) { // May reify arguments object.
- RegisterID* unmodifiedArgumentsRegister = addVar(); // Anonymous, so it can't be modified by user code.
- RegisterID* argumentsRegister = addVar(propertyNames().arguments, false); // Can be changed by assigning to 'arguments'.
+ bool containsArrowOrEvalButNotInArrowBlock = needsToUpdateArrowFunctionContext() && !m_codeBlock->isArrowFunction();
+ bool shouldCaptureSomeOfTheThings = m_shouldEmitDebugHooks || functionNode->needsActivation() || containsArrowOrEvalButNotInArrowBlock;
- // We can save a little space by hard-coding the knowledge that the two
- // 'arguments' values are stored in consecutive registers, and storing
- // only the index of the assignable one.
- codeBlock->setArgumentsRegister(argumentsRegister->index());
- ASSERT_UNUSED(unmodifiedArgumentsRegister, unmodifiedArgumentsRegister->index() == JSC::unmodifiedArgumentsRegister(codeBlock->argumentsRegister()));
+ bool shouldCaptureAllOfTheThings = m_shouldEmitDebugHooks || codeBlock->usesEval();
+ bool needsArguments = (functionNode->usesArguments() || codeBlock->usesEval() || (functionNode->usesArrowFunction() && !codeBlock->isArrowFunction()));
- emitInitLazyRegister(argumentsRegister);
- emitInitLazyRegister(unmodifiedArgumentsRegister);
-
- if (m_codeBlock->isStrictMode()) {
- emitOpcode(op_create_arguments);
- instructions().append(argumentsRegister->index());
- }
+ // Generator never provides "arguments". "arguments" reference will be resolved in an upper generator function scope.
+ if (parseMode == SourceParseMode::GeneratorBodyMode)
+ needsArguments = false;
+
+ if (parseMode == SourceParseMode::GeneratorWrapperFunctionMode && needsArguments) {
+ // Generator does not provide "arguments". Instead, wrapping GeneratorFunction provides "arguments".
+ // This is because arguments of a generator should be evaluated before starting it.
+ // To workaround it, we evaluate these arguments as arguments of a wrapping generator function, and reference it from a generator.
+ //
+ // function *gen(a, b = hello())
+ // {
+ // return {
+ // @generatorNext: function (@generator, @generatorState, @generatorValue, @generatorResumeMode)
+ // {
+ // arguments; // This `arguments` should reference to the gen's arguments.
+ // ...
+ // }
+ // }
+ // }
+ shouldCaptureSomeOfTheThings = true;
+ }
- // The debugger currently retrieves the arguments object from an activation rather than pulling
- // it from a call frame. In the long-term it should stop doing that (<rdar://problem/6911886>),
- // but for now we force eager creation of the arguments object when debugging.
- if (m_shouldEmitDebugHooks) {
- emitOpcode(op_create_arguments);
- instructions().append(argumentsRegister->index());
+ if (shouldCaptureAllOfTheThings)
+ functionNode->varDeclarations().markAllVariablesAsCaptured();
+
+ auto captures = [&] (UniquedStringImpl* uid) -> bool {
+ if (!shouldCaptureSomeOfTheThings)
+ return false;
+ if (needsArguments && uid == propertyNames().arguments.impl()) {
+ // Actually, we only need to capture the arguments object when we "need full activation"
+ // because of name scopes. But historically we did it this way, so for now we just preserve
+ // the old behavior.
+ // FIXME: https://bugs.webkit.org/show_bug.cgi?id=143072
+ return true;
}
+ return functionNode->captures(uid);
+ };
+ auto varKind = [&] (UniquedStringImpl* uid) -> VarKind {
+ return captures(uid) ? VarKind::Scope : VarKind::Stack;
+ };
+
+ emitEnter();
+
+ allocateAndEmitScope();
+
+ m_calleeRegister.setIndex(JSStack::Callee);
+
+ initializeParameters(parameters);
+
+ // Before emitting a scope creation, emit a generator prologue that contains jump based on a generator's state.
+ if (parseMode == SourceParseMode::GeneratorBodyMode) {
+ m_generatorRegister = &m_parameters[1];
+
+ // Jump with switch_imm based on @generatorState. We don't take the coroutine styled generator implementation.
+ // When calling `next()`, we would like to enter the same prologue instead of jumping based on the saved instruction pointer.
+ // It's suitale for inlining, because it just inlines one `next` function implementation.
+
+ beginGenerator(generatorStateRegister());
+
+ // Initial state.
+ emitGeneratorStateLabel();
+ }
+
+ if (functionNameIsInScope(functionNode->ident(), functionNode->functionMode())) {
+ ASSERT(parseMode != SourceParseMode::GeneratorBodyMode);
+ bool isDynamicScope = functionNameScopeIsDynamic(codeBlock->usesEval(), codeBlock->isStrictMode());
+ bool isFunctionNameCaptured = captures(functionNode->ident().impl());
+ bool markAsCaptured = isDynamicScope || isFunctionNameCaptured;
+ emitPushFunctionNameScope(functionNode->ident(), &m_calleeRegister, markAsCaptured);
}
- bool shouldCaptureAllTheThings = m_shouldEmitDebugHooks || codeBlock->usesEval();
+ if (shouldCaptureSomeOfTheThings) {
+ m_lexicalEnvironmentRegister = addVar();
+ // We can allocate the "var" environment if we don't have default parameter expressions. If we have
+ // default parameter expressions, we have to hold off on allocating the "var" environment because
+ // the parent scope of the "var" environment is the parameter environment.
+ if (!parameters.hasDefaultParameterValues())
+ initializeVarLexicalEnvironment(symbolTableConstantIndex);
+ }
+ // Figure out some interesting facts about our arguments.
bool capturesAnyArgumentByName = false;
- Vector<RegisterID*, 0, UnsafeVectorOverflow> capturedArguments;
- if (functionBody->hasCapturedVariables() || shouldCaptureAllTheThings) {
- FunctionParameters& parameters = *functionBody->parameters();
- capturedArguments.resize(parameters.size());
+ if (functionNode->hasCapturedVariables()) {
+ FunctionParameters& parameters = *functionNode->parameters();
for (size_t i = 0; i < parameters.size(); ++i) {
- capturedArguments[i] = 0;
- if (!functionBody->captures(parameters.at(i)) && !shouldCaptureAllTheThings)
+ auto pattern = parameters.at(i).first;
+ if (!pattern->isBindingNode())
continue;
- capturesAnyArgumentByName = true;
- capturedArguments[i] = addVar();
+ const Identifier& ident = static_cast<const BindingNode*>(pattern)->boundProperty();
+ capturesAnyArgumentByName |= captures(ident.impl());
}
}
+
+ if (capturesAnyArgumentByName)
+ ASSERT(m_lexicalEnvironmentRegister);
- if (capturesAnyArgumentByName && !codeBlock->isStrictMode()) {
- size_t parameterCount = m_symbolTable->parameterCount();
- OwnArrayPtr<SlowArgument> slowArguments = adoptArrayPtr(new SlowArgument[parameterCount]);
- for (size_t i = 0; i < parameterCount; ++i) {
- if (!capturedArguments[i]) {
- ASSERT(slowArguments[i].status == SlowArgument::Normal);
- slowArguments[i].index = CallFrame::argumentOffset(i);
- continue;
- }
- slowArguments[i].status = SlowArgument::Captured;
- slowArguments[i].index = capturedArguments[i]->index();
- }
- m_symbolTable->setSlowArguments(slowArguments.release());
- }
-
- RegisterID* calleeRegister = resolveCallee(functionBody); // May push to the scope chain and/or add a captured var.
-
- const DeclarationStacks::FunctionStack& functionStack = functionBody->functionStack();
- const DeclarationStacks::VarStack& varStack = functionBody->varStack();
-
- // Captured variables and functions go first so that activations don't have
- // to step over the non-captured locals to mark them.
- m_hasCreatedActivation = false;
- if (functionBody->hasCapturedVariables()) {
- for (size_t i = 0; i < functionStack.size(); ++i) {
- FunctionBodyNode* function = functionStack[i];
- const Identifier& ident = function->ident();
- if (functionBody->captures(ident)) {
- if (!m_hasCreatedActivation) {
- m_hasCreatedActivation = true;
- emitOpcode(op_create_activation);
- instructions().append(m_activationRegister->index());
+ // Need to know what our functions are called. Parameters have some goofy behaviors when it
+ // comes to functions of the same name.
+ for (FunctionMetadataNode* function : functionNode->functionStack())
+ m_functions.add(function->ident().impl());
+
+ if (needsArguments) {
+ // Create the arguments object now. We may put the arguments object into the activation if
+ // it is captured. Either way, we create two arguments object variables: one is our
+ // private variable that is immutable, and another that is the user-visible variable. The
+ // immutable one is only used here, or during formal parameter resolutions if we opt for
+ // DirectArguments.
+
+ m_argumentsRegister = addVar();
+ m_argumentsRegister->ref();
+ }
+
+ // http://www.ecma-international.org/ecma-262/6.0/index.html#sec-functiondeclarationinstantiation
+ // This implements IsSimpleParameterList in the Ecma 2015 spec.
+ // If IsSimpleParameterList is false, we will create a strict-mode like arguments object.
+ // IsSimpleParameterList is false if the argument list contains any default parameter values,
+ // a rest parameter, or any destructuring patterns.
+ // FIXME: Take into account destructuring to make isSimpleParameterList false. https://bugs.webkit.org/show_bug.cgi?id=151450
+ bool isSimpleParameterList = !parameters.hasDefaultParameterValues() && !m_restParameter;
+ if (needsArguments && !codeBlock->isStrictMode() && isSimpleParameterList) {
+ // If we captured any formal parameter by name, then we use ScopedArguments. Otherwise we
+ // use DirectArguments. With ScopedArguments, we lift all of our arguments into the
+ // activation.
+
+ if (capturesAnyArgumentByName) {
+ functionSymbolTable->setArgumentsLength(vm, parameters.size());
+
+ // For each parameter, we have two possibilities:
+ // Either it's a binding node with no function overlap, in which case it gets a name
+ // in the symbol table - or it just gets space reserved in the symbol table. Either
+ // way we lift the value into the scope.
+ for (unsigned i = 0; i < parameters.size(); ++i) {
+ ScopeOffset offset = functionSymbolTable->takeNextScopeOffset();
+ functionSymbolTable->setArgumentOffset(vm, i, offset);
+ if (UniquedStringImpl* name = visibleNameForParameter(parameters.at(i).first)) {
+ VarOffset varOffset(offset);
+ SymbolTableEntry entry(varOffset);
+ // Stores to these variables via the ScopedArguments object will not do
+ // notifyWrite(), since that would be cumbersome. Also, watching formal
+ // parameters when "arguments" is in play is unlikely to be super profitable.
+ // So, we just disable it.
+ entry.disableWatching();
+ functionSymbolTable->set(name, entry);
}
- m_functions.add(ident.impl());
- emitNewFunction(addVar(ident, false), function);
+ emitOpcode(op_put_to_scope);
+ instructions().append(m_lexicalEnvironmentRegister->index());
+ instructions().append(UINT_MAX);
+ instructions().append(virtualRegisterForArgument(1 + i).offset());
+ instructions().append(GetPutInfo(ThrowIfNotFound, LocalClosureVar, NotInitialization).operand());
+ instructions().append(symbolTableConstantIndex);
+ instructions().append(offset.offset());
}
+
+ // This creates a scoped arguments object and copies the overflow arguments into the
+ // scope. It's the equivalent of calling ScopedArguments::createByCopying().
+ emitOpcode(op_create_scoped_arguments);
+ instructions().append(m_argumentsRegister->index());
+ instructions().append(m_lexicalEnvironmentRegister->index());
+ } else {
+ // We're going to put all parameters into the DirectArguments object. First ensure
+ // that the symbol table knows that this is happening.
+ for (unsigned i = 0; i < parameters.size(); ++i) {
+ if (UniquedStringImpl* name = visibleNameForParameter(parameters.at(i).first))
+ functionSymbolTable->set(name, SymbolTableEntry(VarOffset(DirectArgumentsOffset(i))));
+ }
+
+ emitOpcode(op_create_direct_arguments);
+ instructions().append(m_argumentsRegister->index());
}
- for (size_t i = 0; i < varStack.size(); ++i) {
- const Identifier& ident = *varStack[i].first;
- if (functionBody->captures(ident))
- addVar(ident, varStack[i].second & DeclarationStacks::IsConstant);
+ } else if (!parameters.hasDefaultParameterValues()) {
+ // Create the formal parameters the normal way. Any of them could be captured, or not. If
+ // captured, lift them into the scope. We can not do this if we have default parameter expressions
+ // because when default parameter expressions exist, they belong in their own lexical environment
+ // separate from the "var" lexical environment.
+ for (unsigned i = 0; i < parameters.size(); ++i) {
+ UniquedStringImpl* name = visibleNameForParameter(parameters.at(i).first);
+ if (!name)
+ continue;
+
+ if (!captures(name)) {
+ // This is the easy case - just tell the symbol table about the argument. It will
+ // be accessed directly.
+ functionSymbolTable->set(name, SymbolTableEntry(VarOffset(virtualRegisterForArgument(1 + i))));
+ continue;
+ }
+
+ ScopeOffset offset = functionSymbolTable->takeNextScopeOffset();
+ const Identifier& ident =
+ static_cast<const BindingNode*>(parameters.at(i).first)->boundProperty();
+ functionSymbolTable->set(name, SymbolTableEntry(VarOffset(offset)));
+
+ emitOpcode(op_put_to_scope);
+ instructions().append(m_lexicalEnvironmentRegister->index());
+ instructions().append(addConstant(ident));
+ instructions().append(virtualRegisterForArgument(1 + i).offset());
+ instructions().append(GetPutInfo(ThrowIfNotFound, LocalClosureVar, NotInitialization).operand());
+ instructions().append(symbolTableConstantIndex);
+ instructions().append(offset.offset());
}
}
- bool canLazilyCreateFunctions = !functionBody->needsActivationForMoreThanVariables() && !m_shouldEmitDebugHooks;
- if (!canLazilyCreateFunctions && !m_hasCreatedActivation) {
- m_hasCreatedActivation = true;
- emitOpcode(op_create_activation);
- instructions().append(m_activationRegister->index());
+
+ if (needsArguments && (codeBlock->isStrictMode() || !isSimpleParameterList)) {
+ // Allocate an out-of-bands arguments object.
+ emitOpcode(op_create_out_of_band_arguments);
+ instructions().append(m_argumentsRegister->index());
}
-
- m_symbolTable->setCaptureEnd(codeBlock->m_numVars);
-
- m_firstLazyFunction = codeBlock->m_numVars;
- for (size_t i = 0; i < functionStack.size(); ++i) {
- FunctionBodyNode* function = functionStack[i];
+
+ // Now declare all variables.
+ for (const Identifier& ident : boundParameterProperties) {
+ ASSERT(!parameters.hasDefaultParameterValues());
+ createVariable(ident, varKind(ident.impl()), functionSymbolTable);
+ }
+ for (FunctionMetadataNode* function : functionNode->functionStack()) {
const Identifier& ident = function->ident();
- if (!functionBody->captures(ident)) {
- m_functions.add(ident.impl());
- RefPtr<RegisterID> reg = addVar(ident, false);
- // Don't lazily create functions that override the name 'arguments'
- // as this would complicate lazy instantiation of actual arguments.
- if (!canLazilyCreateFunctions || ident == propertyNames().arguments)
- emitNewFunction(reg.get(), function);
- else {
- emitInitLazyRegister(reg.get());
- m_lazyFunctions.set(reg->index(), function);
- }
- }
+ createVariable(ident, varKind(ident.impl()), functionSymbolTable);
+ m_functionsToInitialize.append(std::make_pair(function, NormalFunctionVariable));
}
- m_lastLazyFunction = canLazilyCreateFunctions ? codeBlock->m_numVars : m_firstLazyFunction;
- for (size_t i = 0; i < varStack.size(); ++i) {
- const Identifier& ident = *varStack[i].first;
- if (!functionBody->captures(ident))
- addVar(ident, varStack[i].second & DeclarationStacks::IsConstant);
+ for (auto& entry : functionNode->varDeclarations()) {
+ ASSERT(!entry.value.isLet() && !entry.value.isConst());
+ if (!entry.value.isVar()) // This is either a parameter or callee.
+ continue;
+ // Variables named "arguments" are never const.
+ createVariable(Identifier::fromUid(m_vm, entry.key.get()), varKind(entry.key.get()), functionSymbolTable, IgnoreExisting);
}
- if (shouldCaptureAllTheThings)
- m_symbolTable->setCaptureEnd(codeBlock->m_numVars);
+ // There are some variables that need to be preinitialized to something other than Undefined:
+ //
+ // - "arguments": unless it's used as a function or parameter, this should refer to the
+ // arguments object.
+ //
+ // - functions: these always override everything else.
+ //
+ // The most logical way to do all of this is to initialize none of the variables until now,
+ // and then initialize them in BytecodeGenerator::generate() in such an order that the rules
+ // for how these things override each other end up holding. We would initialize "arguments" first,
+ // then all arguments, then the functions.
+ //
+ // But some arguments are already initialized by default, since if they aren't captured and we
+ // don't have "arguments" then we just point the symbol table at the stack slot of those
+ // arguments. We end up initializing the rest of the arguments that have an uncomplicated
+ // binding (i.e. don't involve destructuring) above when figuring out how to lay them out,
+ // because that's just the simplest thing. This means that when we initialize them, we have to
+ // watch out for the things that override arguments (namely, functions).
+
+ // This is our final act of weirdness. "arguments" is overridden by everything except the
+ // callee. We add it to the symbol table if it's not already there and it's not an argument.
+ if (needsArguments) {
+ // If "arguments" is overridden by a function or destructuring parameter name, then it's
+ // OK for us to call createVariable() because it won't change anything. It's also OK for
+ // us to them tell BytecodeGenerator::generate() to write to it because it will do so
+ // before it initializes functions and destructuring parameters. But if "arguments" is
+ // overridden by a "simple" function parameter, then we have to bail: createVariable()
+ // would assert and BytecodeGenerator::generate() would write the "arguments" after the
+ // argument value had already been properly initialized.
+
+ bool haveParameterNamedArguments = false;
+ for (unsigned i = 0; i < parameters.size(); ++i) {
+ UniquedStringImpl* name = visibleNameForParameter(parameters.at(i).first);
+ if (name == propertyNames().arguments.impl()) {
+ haveParameterNamedArguments = true;
+ break;
+ }
+ }
- FunctionParameters& parameters = *functionBody->parameters();
- m_parameters.grow(parameters.size() + 1); // reserve space for "this"
+ // Do not create arguments variable in case of Arrow function. Value will be loaded from parent scope
+ if (!haveParameterNamedArguments && !m_codeBlock->isArrowFunction()) {
+ createVariable(
+ propertyNames().arguments, varKind(propertyNames().arguments.impl()), functionSymbolTable);
- // Add "this" as a parameter
- int nextParameterIndex = CallFrame::thisArgumentOffset();
- m_thisRegister.setIndex(nextParameterIndex--);
- m_codeBlock->addParameter();
-
- for (size_t i = 0; i < parameters.size(); ++i, --nextParameterIndex) {
- int index = nextParameterIndex;
- if (capturedArguments.size() && capturedArguments[i]) {
- ASSERT((functionBody->hasCapturedVariables() && functionBody->captures(parameters.at(i))) || shouldCaptureAllTheThings);
- index = capturedArguments[i]->index();
- RegisterID original(nextParameterIndex);
- emitMove(capturedArguments[i], &original);
+ m_needToInitializeArguments = true;
}
- addParameter(parameters.at(i), index);
}
- preserveLastVar();
- // We declare the callee's name last because it should lose to a var, function, and/or parameter declaration.
- addCallee(functionBody, calleeRegister);
+ m_newTargetRegister = addVar();
+ switch (parseMode) {
+ case SourceParseMode::GeneratorWrapperFunctionMode: {
+ m_generatorRegister = addVar();
- if (isConstructor()) {
- emitCreateThis(&m_thisRegister);
- } else if (!codeBlock->isStrictMode() && (functionBody->usesThis() || codeBlock->usesEval() || m_shouldEmitDebugHooks)) {
- UnlinkedValueProfile profile = emitProfiledOpcode(op_convert_this);
+ // FIXME: Emit to_this only when Generator uses it.
+ // https://bugs.webkit.org/show_bug.cgi?id=151586
+ m_codeBlock->addPropertyAccessInstruction(instructions().size());
+ emitOpcode(op_to_this);
instructions().append(kill(&m_thisRegister));
- instructions().append(profile);
+ instructions().append(0);
+ instructions().append(0);
+
+ emitMove(m_generatorRegister, &m_calleeRegister);
+ emitCreateThis(m_generatorRegister);
+ break;
+ }
+
+ case SourceParseMode::GeneratorBodyMode: {
+ // |this| is already filled correctly before here.
+ emitLoad(m_newTargetRegister, jsUndefined());
+ break;
+ }
+
+ default: {
+ if (SourceParseMode::ArrowFunctionMode != parseMode) {
+ if (isConstructor()) {
+ emitMove(m_newTargetRegister, &m_thisRegister);
+ if (constructorKind() == ConstructorKind::Derived)
+ emitMoveEmptyValue(&m_thisRegister);
+ else
+ emitCreateThis(&m_thisRegister);
+ } else if (constructorKind() != ConstructorKind::None) {
+ emitThrowTypeError("Cannot call a class constructor");
+ } else if (functionNode->usesThis() || codeBlock->usesEval()) {
+ m_codeBlock->addPropertyAccessInstruction(instructions().size());
+ emitOpcode(op_to_this);
+ instructions().append(kill(&m_thisRegister));
+ instructions().append(0);
+ instructions().append(0);
+ }
+ }
+ break;
+ }
}
+
+ // All "addVar()"s needs to happen before "initializeDefaultParameterValuesAndSetupFunctionScopeStack()" is called
+ // because a function's default parameter ExpressionNodes will use temporary registers.
+ m_TDZStack.append(std::make_pair(*parentScopeTDZVariables, false));
+ initializeDefaultParameterValuesAndSetupFunctionScopeStack(parameters, functionNode, functionSymbolTable, symbolTableConstantIndex, captures);
+
+ // Loading |this| inside an arrow function must be done after initializeDefaultParameterValuesAndSetupFunctionScopeStack()
+ // because that function sets up the SymbolTable stack and emitLoadThisFromArrowFunctionLexicalEnvironment()
+ // consults the SymbolTable stack
+ if (SourceParseMode::ArrowFunctionMode == parseMode && (functionNode->usesThis() || isDerivedClassContext() || isDerivedConstructorContext()))
+ emitLoadThisFromArrowFunctionLexicalEnvironment();
+
+ if (needsToUpdateArrowFunctionContext() && !codeBlock->isArrowFunction()) {
+ initializeArrowFunctionContextScopeIfNeeded(functionSymbolTable);
+ emitPutThisToArrowFunctionContextScope();
+ emitPutNewTargetToArrowFunctionContextScope();
+ emitPutDerivedConstructorToArrowFunctionContextScope();
+ }
+
+ pushLexicalScope(m_scopeNode, TDZCheckOptimization::Optimize);
}
-BytecodeGenerator::BytecodeGenerator(VM& vm, JSScope* scope, EvalNode* evalNode, UnlinkedEvalCodeBlock* codeBlock, DebuggerMode debuggerMode, ProfilerMode profilerMode)
- : m_shouldEmitDebugHooks(debuggerMode == DebuggerOn)
- , m_shouldEmitProfileHooks(profilerMode == ProfilerOn)
- , m_symbolTable(codeBlock->symbolTable())
+BytecodeGenerator::BytecodeGenerator(VM& vm, EvalNode* evalNode, UnlinkedEvalCodeBlock* codeBlock, DebuggerMode debuggerMode, ProfilerMode profilerMode, const VariableEnvironment* parentScopeTDZVariables)
+ : m_shouldEmitDebugHooks(Options::forceDebuggerBytecodeGeneration() || debuggerMode == DebuggerOn)
+ , m_shouldEmitProfileHooks(Options::forceProfilerBytecodeGeneration() || profilerMode == ProfilerOn)
, m_scopeNode(evalNode)
- , m_scope(vm, scope)
, m_codeBlock(vm, codeBlock)
, m_thisRegister(CallFrame::thisArgumentOffset())
- , m_emptyValueRegister(0)
- , m_globalObjectRegister(0)
- , m_finallyDepth(0)
- , m_dynamicScopeDepth(0)
, m_codeType(EvalCode)
- , m_nextConstantOffset(0)
- , m_globalConstantIndex(0)
- , m_hasCreatedActivation(true)
- , m_firstLazyFunction(0)
- , m_lastLazyFunction(0)
- , m_staticPropertyAnalyzer(&m_instructions)
, m_vm(&vm)
- , m_lastOpcodeID(op_end)
-#ifndef NDEBUG
- , m_lastOpcodePosition(0)
-#endif
- , m_stack(vm, wtfThreadData().stack())
- , m_usesExceptions(false)
- , m_expressionTooDeep(false)
+ , m_usesNonStrictEval(codeBlock->usesEval() && !codeBlock->isStrictMode())
+ , m_needsToUpdateArrowFunctionContext(evalNode->usesArrowFunction() || evalNode->usesEval())
+ , m_derivedContextType(codeBlock->derivedContextType())
{
- m_codeBlock->setNeedsFullScopeChain(true);
+ for (auto& constantRegister : m_linkTimeConstantRegisters)
+ constantRegister = nullptr;
+
+ allocateCalleeSaveSpace();
- m_symbolTable->setUsesNonStrictEval(codeBlock->usesEval() && !codeBlock->isStrictMode());
m_codeBlock->setNumParameters(1);
- emitOpcode(op_enter);
+ emitEnter();
+
+ allocateAndEmitScope();
const DeclarationStacks::FunctionStack& functionStack = evalNode->functionStack();
for (size_t i = 0; i < functionStack.size(); ++i)
m_codeBlock->addFunctionDecl(makeFunction(functionStack[i]));
- const DeclarationStacks::VarStack& varStack = evalNode->varStack();
- unsigned numVariables = varStack.size();
+ const VariableEnvironment& varDeclarations = evalNode->varDeclarations();
+ unsigned numVariables = varDeclarations.size();
Vector<Identifier, 0, UnsafeVectorOverflow> variables;
variables.reserveCapacity(numVariables);
- for (size_t i = 0; i < numVariables; ++i)
- variables.append(*varStack[i].first);
+ for (auto& entry : varDeclarations) {
+ ASSERT(entry.value.isVar());
+ ASSERT(entry.key->isAtomic() || entry.key->isSymbol());
+ variables.append(Identifier::fromUid(m_vm, entry.key.get()));
+ }
codeBlock->adoptVariables(variables);
- preserveLastVar();
+
+ m_TDZStack.append(std::make_pair(*parentScopeTDZVariables, false));
+
+ if (codeBlock->isArrowFunctionContext() && evalNode->usesThis())
+ emitLoadThisFromArrowFunctionLexicalEnvironment();
+
+ if (needsToUpdateArrowFunctionContext() && !codeBlock->isArrowFunctionContext()) {
+ initializeArrowFunctionContextScopeIfNeeded();
+ emitPutThisToArrowFunctionContextScope();
+ }
+
+ pushLexicalScope(m_scopeNode, TDZCheckOptimization::Optimize);
}
-BytecodeGenerator::~BytecodeGenerator()
+BytecodeGenerator::BytecodeGenerator(VM& vm, ModuleProgramNode* moduleProgramNode, UnlinkedModuleProgramCodeBlock* codeBlock, DebuggerMode debuggerMode, ProfilerMode profilerMode, const VariableEnvironment* parentScopeTDZVariables)
+ : m_shouldEmitDebugHooks(Options::forceDebuggerBytecodeGeneration() || debuggerMode == DebuggerOn)
+ , m_shouldEmitProfileHooks(Options::forceProfilerBytecodeGeneration() || profilerMode == ProfilerOn)
+ , m_scopeNode(moduleProgramNode)
+ , m_codeBlock(vm, codeBlock)
+ , m_thisRegister(CallFrame::thisArgumentOffset())
+ , m_codeType(ModuleCode)
+ , m_vm(&vm)
+ , m_usesNonStrictEval(false)
+ , m_needsToUpdateArrowFunctionContext(moduleProgramNode->usesArrowFunction() || moduleProgramNode->usesEval())
{
+ ASSERT_UNUSED(parentScopeTDZVariables, !parentScopeTDZVariables->size());
+
+ for (auto& constantRegister : m_linkTimeConstantRegisters)
+ constantRegister = nullptr;
+
+ if (m_isBuiltinFunction)
+ m_shouldEmitDebugHooks = false;
+
+ allocateCalleeSaveSpace();
+
+ SymbolTable* moduleEnvironmentSymbolTable = SymbolTable::create(*m_vm);
+ moduleEnvironmentSymbolTable->setUsesNonStrictEval(m_usesNonStrictEval);
+ moduleEnvironmentSymbolTable->setScopeType(SymbolTable::ScopeType::LexicalScope);
+
+ bool shouldCaptureAllOfTheThings = m_shouldEmitDebugHooks || codeBlock->usesEval();
+ if (shouldCaptureAllOfTheThings)
+ moduleProgramNode->varDeclarations().markAllVariablesAsCaptured();
+
+ auto captures = [&] (UniquedStringImpl* uid) -> bool {
+ return moduleProgramNode->captures(uid);
+ };
+ auto lookUpVarKind = [&] (UniquedStringImpl* uid, const VariableEnvironmentEntry& entry) -> VarKind {
+ // Allocate the exported variables in the module environment.
+ if (entry.isExported())
+ return VarKind::Scope;
+
+ // Allocate the namespace variables in the module environment to instantiate
+ // it from the outside of the module code.
+ if (entry.isImportedNamespace())
+ return VarKind::Scope;
+
+ if (entry.isCaptured())
+ return VarKind::Scope;
+ return captures(uid) ? VarKind::Scope : VarKind::Stack;
+ };
+
+ emitEnter();
+
+ allocateAndEmitScope();
+
+ m_calleeRegister.setIndex(JSStack::Callee);
+
+ m_codeBlock->setNumParameters(1); // Allocate space for "this"
+
+ // Now declare all variables.
+
+ for (auto& entry : moduleProgramNode->varDeclarations()) {
+ ASSERT(!entry.value.isLet() && !entry.value.isConst());
+ if (!entry.value.isVar()) // This is either a parameter or callee.
+ continue;
+ // Imported bindings are not allocated in the module environment as usual variables' way.
+ // These references remain the "Dynamic" in the unlinked code block. Later, when linking
+ // the code block, we resolve the reference to the "ModuleVar".
+ if (entry.value.isImported() && !entry.value.isImportedNamespace())
+ continue;
+ createVariable(Identifier::fromUid(m_vm, entry.key.get()), lookUpVarKind(entry.key.get(), entry.value), moduleEnvironmentSymbolTable, IgnoreExisting);
+ }
+
+ VariableEnvironment& lexicalVariables = moduleProgramNode->lexicalVariables();
+ instantiateLexicalVariables(lexicalVariables, moduleEnvironmentSymbolTable, ScopeRegisterType::Block, lookUpVarKind);
+
+ // We keep the symbol table in the constant pool.
+ RegisterID* constantSymbolTable = nullptr;
+ if (vm.typeProfiler())
+ constantSymbolTable = addConstantValue(moduleEnvironmentSymbolTable);
+ else
+ constantSymbolTable = addConstantValue(moduleEnvironmentSymbolTable->cloneScopePart(*m_vm));
+
+ m_TDZStack.append(std::make_pair(lexicalVariables, true));
+ m_symbolTableStack.append(SymbolTableStackEntry { Strong<SymbolTable>(*m_vm, moduleEnvironmentSymbolTable), m_topMostScope, false, constantSymbolTable->index() });
+ emitPrefillStackTDZVariables(lexicalVariables, moduleEnvironmentSymbolTable);
+
+ // makeFunction assumes that there's correct TDZ stack entries.
+ // So it should be called after putting our lexical environment to the TDZ stack correctly.
+
+ for (FunctionMetadataNode* function : moduleProgramNode->functionStack()) {
+ const auto& iterator = moduleProgramNode->varDeclarations().find(function->ident().impl());
+ RELEASE_ASSERT(iterator != moduleProgramNode->varDeclarations().end());
+ RELEASE_ASSERT(!iterator->value.isImported());
+
+ VarKind varKind = lookUpVarKind(iterator->key.get(), iterator->value);
+ if (varKind == VarKind::Scope) {
+ // http://www.ecma-international.org/ecma-262/6.0/#sec-moduledeclarationinstantiation
+ // Section 15.2.1.16.4, step 16-a-iv-1.
+ // All heap allocated function declarations should be instantiated when the module environment
+ // is created. They include the exported function declarations and not-exported-but-heap-allocated
+ // function declarations. This is required because exported function should be instantiated before
+ // executing the any module in the dependency graph. This enables the modules to link the imported
+ // bindings before executing the any module code.
+ //
+ // And since function declarations are instantiated before executing the module body code, the spec
+ // allows the functions inside the module to be executed before its module body is executed under
+ // the circular dependencies. The following is the example.
+ //
+ // Module A (executed first):
+ // import { b } from "B";
+ // // Here, the module "B" is not executed yet, but the function declaration is already instantiated.
+ // // So we can call the function exported from "B".
+ // b();
+ //
+ // export function a() {
+ // }
+ //
+ // Module B (executed second):
+ // import { a } from "A";
+ //
+ // export function b() {
+ // c();
+ // }
+ //
+ // // c is not exported, but since it is referenced from the b, we should instantiate it before
+ // // executing the "B" module code.
+ // function c() {
+ // a();
+ // }
+ //
+ // Module EntryPoint (executed last):
+ // import "B";
+ // import "A";
+ //
+ m_codeBlock->addFunctionDecl(makeFunction(function));
+ } else {
+ // Stack allocated functions can be allocated when executing the module's body.
+ m_functionsToInitialize.append(std::make_pair(function, NormalFunctionVariable));
+ }
+ }
+
+ // Remember the constant register offset to the top-most symbol table. This symbol table will be
+ // cloned in the code block linking. After that, to create the module environment, we retrieve
+ // the cloned symbol table from the linked code block by using this offset.
+ codeBlock->setModuleEnvironmentSymbolTableConstantRegisterOffset(constantSymbolTable->index());
}
-RegisterID* BytecodeGenerator::emitInitLazyRegister(RegisterID* reg)
+BytecodeGenerator::~BytecodeGenerator()
{
- emitOpcode(op_init_lazy_reg);
- instructions().append(reg->index());
- return reg;
}
-RegisterID* BytecodeGenerator::resolveCallee(FunctionBodyNode* functionBodyNode)
+void BytecodeGenerator::initializeDefaultParameterValuesAndSetupFunctionScopeStack(
+ FunctionParameters& parameters, FunctionNode* functionNode, SymbolTable* functionSymbolTable,
+ int symbolTableConstantIndex, const std::function<bool (UniquedStringImpl*)>& captures)
{
- if (functionBodyNode->ident().isNull() || !functionBodyNode->functionNameIsInScope())
- return 0;
+ Vector<std::pair<Identifier, RefPtr<RegisterID>>> valuesToMoveIntoVars;
+ if (parameters.hasDefaultParameterValues()) {
+ // Refer to the ES6 spec section 9.2.12: http://www.ecma-international.org/ecma-262/6.0/index.html#sec-functiondeclarationinstantiation
+ // This implements step 21.
+ VariableEnvironment environment;
+ Vector<Identifier> allParameterNames;
+ for (unsigned i = 0; i < parameters.size(); i++)
+ parameters.at(i).first->collectBoundIdentifiers(allParameterNames);
+ IdentifierSet parameterSet;
+ for (auto& ident : allParameterNames) {
+ parameterSet.add(ident.impl());
+ auto addResult = environment.add(ident);
+ addResult.iterator->value.setIsLet(); // When we have default parameter expressions, parameters act like "let" variables.
+ if (captures(ident.impl()))
+ addResult.iterator->value.setIsCaptured();
+ }
+
+ // This implements step 25 of section 9.2.12.
+ pushLexicalScopeInternal(environment, TDZCheckOptimization::Optimize, NestedScopeType::IsNotNested, nullptr, TDZRequirement::UnderTDZ, ScopeType::LetConstScope, ScopeRegisterType::Block);
- m_calleeRegister.setIndex(JSStack::Callee);
+ RefPtr<RegisterID> temp = newTemporary();
+ for (unsigned i = 0; i < parameters.size(); i++) {
+ std::pair<DestructuringPatternNode*, ExpressionNode*> parameter = parameters.at(i);
+ if (parameter.first->isRestParameter())
+ continue;
+ RefPtr<RegisterID> parameterValue = &registerFor(virtualRegisterForArgument(1 + i));
+ emitMove(temp.get(), parameterValue.get());
+ if (parameter.second) {
+ RefPtr<RegisterID> condition = emitIsUndefined(newTemporary(), parameterValue.get());
+ RefPtr<Label> skipDefaultParameterBecauseNotUndefined = newLabel();
+ emitJumpIfFalse(condition.get(), skipDefaultParameterBecauseNotUndefined.get());
+ emitNode(temp.get(), parameter.second);
+ emitLabel(skipDefaultParameterBecauseNotUndefined.get());
+ }
+
+ parameter.first->bindValue(*this, temp.get());
+ }
+
+ // Final act of weirdness for default parameters. If a "var" also
+ // has the same name as a parameter, it should start out as the
+ // value of that parameter. Note, though, that they will be distinct
+ // bindings.
+ // This is step 28 of section 9.2.12.
+ for (auto& entry : functionNode->varDeclarations()) {
+ if (!entry.value.isVar()) // This is either a parameter or callee.
+ continue;
- // If non-strict eval is in play, we use a separate object in the scope chain for the callee's name.
- if ((m_codeBlock->usesEval() && !m_codeBlock->isStrictMode()) || m_shouldEmitDebugHooks) {
- emitOpcode(op_push_name_scope);
- instructions().append(addConstant(functionBodyNode->ident()));
- instructions().append(m_calleeRegister.index());
- instructions().append(ReadOnly | DontDelete);
- return 0;
+ if (parameterSet.contains(entry.key)) {
+ Identifier ident = Identifier::fromUid(m_vm, entry.key.get());
+ Variable var = variable(ident);
+ RegisterID* scope = emitResolveScope(nullptr, var);
+ RefPtr<RegisterID> value = emitGetFromScope(newTemporary(), scope, var, DoNotThrowIfNotFound);
+ valuesToMoveIntoVars.append(std::make_pair(ident, value));
+ }
+ }
+
+ // Functions with default parameter expressions must have a separate environment
+ // record for parameters and "var"s. The "var" environment record must have the
+ // parameter environment record as its parent.
+ // See step 28 of section 9.2.12.
+ if (m_lexicalEnvironmentRegister)
+ initializeVarLexicalEnvironment(symbolTableConstantIndex);
}
- if (!functionBodyNode->captures(functionBodyNode->ident()))
- return &m_calleeRegister;
+ if (m_lexicalEnvironmentRegister)
+ pushScopedControlFlowContext();
+ m_symbolTableStack.append(SymbolTableStackEntry{ Strong<SymbolTable>(*m_vm, functionSymbolTable), m_lexicalEnvironmentRegister, false, symbolTableConstantIndex });
- // Move the callee into the captured section of the stack.
- return emitMove(addVar(), &m_calleeRegister);
+ // This completes step 28 of section 9.2.12.
+ for (unsigned i = 0; i < valuesToMoveIntoVars.size(); i++) {
+ ASSERT(parameters.hasDefaultParameterValues());
+ Variable var = variable(valuesToMoveIntoVars[i].first);
+ RegisterID* scope = emitResolveScope(nullptr, var);
+ emitPutToScope(scope, var, valuesToMoveIntoVars[i].second.get(), DoNotThrowIfNotFound, NotInitialization);
+ }
+
+ if (!parameters.hasDefaultParameterValues()) {
+ ASSERT(!valuesToMoveIntoVars.size());
+ // Initialize destructuring parameters the old way as if we don't have any default parameter values.
+ // If we have default parameter values, we handle this case above.
+ for (unsigned i = 0; i < parameters.size(); i++) {
+ DestructuringPatternNode* pattern = parameters.at(i).first;
+ if (!pattern->isBindingNode() && !pattern->isRestParameter()) {
+ RefPtr<RegisterID> parameterValue = &registerFor(virtualRegisterForArgument(1 + i));
+ pattern->bindValue(*this, parameterValue.get());
+ }
+ }
+ }
}
-void BytecodeGenerator::addCallee(FunctionBodyNode* functionBodyNode, RegisterID* calleeRegister)
+void BytecodeGenerator::initializeArrowFunctionContextScopeIfNeeded(SymbolTable* symbolTable)
{
- if (functionBodyNode->ident().isNull() || !functionBodyNode->functionNameIsInScope())
+ if (m_arrowFunctionContextLexicalEnvironmentRegister != nullptr)
return;
+
+ if (m_lexicalEnvironmentRegister != nullptr) {
+ m_arrowFunctionContextLexicalEnvironmentRegister = m_lexicalEnvironmentRegister;
+
+ if (!m_codeBlock->isArrowFunction()) {
+ ScopeOffset offset;
+
+ offset = symbolTable->takeNextScopeOffset();
+ symbolTable->set(propertyNames().thisIdentifier.impl(), SymbolTableEntry(VarOffset(offset)));
+
+ if (m_codeType == FunctionCode) {
+ offset = symbolTable->takeNextScopeOffset();
+ symbolTable->set(propertyNames().newTargetLocalPrivateName.impl(), SymbolTableEntry(VarOffset(offset)));
+ }
+
+ if (isConstructor() && constructorKind() == ConstructorKind::Derived) {
+ offset = symbolTable->takeNextScopeOffset();
+ symbolTable->set(propertyNames().derivedConstructorPrivateName.impl(), SymbolTableEntry(VarOffset(offset)));
+ }
+ }
- // If non-strict eval is in play, we use a separate object in the scope chain for the callee's name.
- if ((m_codeBlock->usesEval() && !m_codeBlock->isStrictMode()) || m_shouldEmitDebugHooks)
return;
+ }
- ASSERT(calleeRegister);
- symbolTable().add(functionBodyNode->ident().impl(), SymbolTableEntry(calleeRegister->index(), ReadOnly));
-}
+ VariableEnvironment environment;
+ auto addResult = environment.add(propertyNames().thisIdentifier);
+ addResult.iterator->value.setIsCaptured();
+ addResult.iterator->value.setIsConst();
+
+ if (m_codeType == FunctionCode) {
+ auto addTarget = environment.add(propertyNames().newTargetLocalPrivateName);
+ addTarget.iterator->value.setIsCaptured();
+ addTarget.iterator->value.setIsLet();
+ }
-void BytecodeGenerator::addParameter(const Identifier& ident, int parameterIndex)
-{
- // Parameters overwrite var declarations, but not function declarations.
- StringImpl* rep = ident.impl();
- if (!m_functions.contains(rep)) {
- symbolTable().set(rep, parameterIndex);
- RegisterID& parameter = registerFor(parameterIndex);
- parameter.setIndex(parameterIndex);
+ if (isConstructor() && constructorKind() == ConstructorKind::Derived) {
+ auto derivedConstructor = environment.add(propertyNames().derivedConstructorPrivateName);
+ derivedConstructor.iterator->value.setIsCaptured();
+ derivedConstructor.iterator->value.setIsLet();
}
- // To maintain the calling convention, we have to allocate unique space for
- // each parameter, even if the parameter doesn't make it into the symbol table.
- m_codeBlock->addParameter();
+ size_t size = m_symbolTableStack.size();
+ pushLexicalScopeInternal(environment, TDZCheckOptimization::Optimize, NestedScopeType::IsNotNested, nullptr, TDZRequirement::UnderTDZ, ScopeType::LetConstScope, ScopeRegisterType::Block);
+
+ ASSERT_UNUSED(size, m_symbolTableStack.size() == size + 1);
+
+ m_arrowFunctionContextLexicalEnvironmentRegister = m_symbolTableStack.last().m_scope;
}
-bool BytecodeGenerator::willResolveToArguments(const Identifier& ident)
+RegisterID* BytecodeGenerator::initializeNextParameter()
{
- if (ident != propertyNames().arguments)
- return false;
-
- if (!shouldOptimizeLocals())
- return false;
-
- SymbolTableEntry entry = symbolTable().get(ident.impl());
- if (entry.isNull())
- return false;
+ VirtualRegister reg = virtualRegisterForArgument(m_codeBlock->numParameters());
+ RegisterID& parameter = registerFor(reg);
+ parameter.setIndex(reg.offset());
+ m_codeBlock->addParameter();
+ return &parameter;
+}
- if (m_codeBlock->usesArguments() && m_codeType == FunctionCode)
- return true;
-
- return false;
+void BytecodeGenerator::initializeParameters(FunctionParameters& parameters)
+{
+ // Make sure the code block knows about all of our parameters, and make sure that parameters
+ // needing destructuring are noted.
+ m_parameters.grow(parameters.size() + 1); // reserve space for "this"
+ m_thisRegister.setIndex(initializeNextParameter()->index()); // this
+ for (unsigned i = 0; i < parameters.size(); ++i) {
+ auto pattern = parameters.at(i).first;
+ if (pattern->isRestParameter()) {
+ RELEASE_ASSERT(!m_restParameter);
+ m_restParameter = static_cast<RestParameterNode*>(pattern);
+ } else
+ initializeNextParameter();
+ }
}
-RegisterID* BytecodeGenerator::uncheckedRegisterForArguments()
+void BytecodeGenerator::initializeVarLexicalEnvironment(int symbolTableConstantIndex)
{
- ASSERT(willResolveToArguments(propertyNames().arguments));
+ RELEASE_ASSERT(m_lexicalEnvironmentRegister);
+ emitOpcode(op_create_lexical_environment);
+ instructions().append(m_lexicalEnvironmentRegister->index());
+ instructions().append(scopeRegister()->index());
+ instructions().append(symbolTableConstantIndex);
+ instructions().append(addConstantValue(jsUndefined())->index());
- SymbolTableEntry entry = symbolTable().get(propertyNames().arguments.impl());
- ASSERT(!entry.isNull());
- return &registerFor(entry.getIndex());
+ emitOpcode(op_mov);
+ instructions().append(scopeRegister()->index());
+ instructions().append(m_lexicalEnvironmentRegister->index());
}
-RegisterID* BytecodeGenerator::createLazyRegisterIfNecessary(RegisterID* reg)
+UniquedStringImpl* BytecodeGenerator::visibleNameForParameter(DestructuringPatternNode* pattern)
{
- if (m_lastLazyFunction <= reg->index() || reg->index() < m_firstLazyFunction)
- return reg;
- emitLazyNewFunction(reg, m_lazyFunctions.get(reg->index()));
- return reg;
+ if (pattern->isBindingNode()) {
+ const Identifier& ident = static_cast<const BindingNode*>(pattern)->boundProperty();
+ if (!m_functions.contains(ident.impl()))
+ return ident.impl();
+ }
+ return nullptr;
}
RegisterID* BytecodeGenerator::newRegister()
{
- m_calleeRegisters.append(m_calleeRegisters.size());
- m_codeBlock->m_numCalleeRegisters = max<int>(m_codeBlock->m_numCalleeRegisters, m_calleeRegisters.size());
- return &m_calleeRegisters.last();
+ m_calleeLocals.append(virtualRegisterForLocal(m_calleeLocals.size()));
+ int numCalleeLocals = max<int>(m_codeBlock->m_numCalleeLocals, m_calleeLocals.size());
+ numCalleeLocals = WTF::roundUpToMultipleOf(stackAlignmentRegisters(), numCalleeLocals);
+ m_codeBlock->m_numCalleeLocals = numCalleeLocals;
+ return &m_calleeLocals.last();
+}
+
+void BytecodeGenerator::reclaimFreeRegisters()
+{
+ while (m_calleeLocals.size() && !m_calleeLocals.last().refCount())
+ m_calleeLocals.removeLast();
+}
+
+RegisterID* BytecodeGenerator::newBlockScopeVariable()
+{
+ reclaimFreeRegisters();
+
+ return newRegister();
}
RegisterID* BytecodeGenerator::newTemporary()
{
- // Reclaim free register IDs.
- while (m_calleeRegisters.size() && !m_calleeRegisters.last().refCount())
- m_calleeRegisters.removeLast();
-
+ reclaimFreeRegisters();
+
RegisterID* result = newRegister();
result->setTemporary();
return result;
@@ -572,9 +1018,9 @@ LabelScopePtr BytecodeGenerator::newLabelScope(LabelScope::Type type, const Iden
m_labelScopes.removeLast();
// Allocate new label scope.
- LabelScope scope(type, name, scopeDepth(), newLabel(), type == LabelScope::Loop ? newLabel() : PassRefPtr<Label>()); // Only loops have continue targets.
+ LabelScope scope(type, name, labelScopeDepth(), newLabel(), type == LabelScope::Loop ? newLabel() : PassRefPtr<Label>()); // Only loops have continue targets.
m_labelScopes.append(scope);
- return LabelScopePtr(&m_labelScopes, m_labelScopes.size() - 1);
+ return LabelScopePtr(m_labelScopes, m_labelScopes.size() - 1);
}
PassRefPtr<Label> BytecodeGenerator::newLabel()
@@ -584,7 +1030,7 @@ PassRefPtr<Label> BytecodeGenerator::newLabel()
m_labels.removeLast();
// Allocate new label ID.
- m_labels.append(this);
+ m_labels.append(*this);
return &m_labels.last();
}
@@ -622,20 +1068,12 @@ void BytecodeGenerator::emitOpcode(OpcodeID opcodeID)
UnlinkedArrayProfile BytecodeGenerator::newArrayProfile()
{
-#if ENABLE(VALUE_PROFILER)
return m_codeBlock->addArrayProfile();
-#else
- return 0;
-#endif
}
UnlinkedArrayAllocationProfile BytecodeGenerator::newArrayAllocationProfile()
{
-#if ENABLE(VALUE_PROFILER)
return m_codeBlock->addArrayAllocationProfile();
-#else
- return 0;
-#endif
}
UnlinkedObjectAllocationProfile BytecodeGenerator::newObjectAllocationProfile()
@@ -645,18 +1083,27 @@ UnlinkedObjectAllocationProfile BytecodeGenerator::newObjectAllocationProfile()
UnlinkedValueProfile BytecodeGenerator::emitProfiledOpcode(OpcodeID opcodeID)
{
-#if ENABLE(VALUE_PROFILER)
UnlinkedValueProfile result = m_codeBlock->addValueProfile();
-#else
- UnlinkedValueProfile result = 0;
-#endif
emitOpcode(opcodeID);
return result;
}
+void BytecodeGenerator::emitEnter()
+{
+ emitOpcode(op_enter);
+ emitWatchdog();
+}
+
void BytecodeGenerator::emitLoopHint()
{
emitOpcode(op_loop_hint);
+ emitWatchdog();
+}
+
+void BytecodeGenerator::emitWatchdog()
+{
+ if (vm()->watchdog())
+ emitOpcode(op_watchdog);
}
void BytecodeGenerator::retrieveLastBinaryOp(int& dstIndex, int& src1Index, int& src2Index)
@@ -954,12 +1401,18 @@ PassRefPtr<Label> BytecodeGenerator::emitJumpIfNotFunctionApply(RegisterID* cond
return target;
}
+bool BytecodeGenerator::hasConstant(const Identifier& ident) const
+{
+ UniquedStringImpl* rep = ident.impl();
+ return m_identifierMap.contains(rep);
+}
+
unsigned BytecodeGenerator::addConstant(const Identifier& ident)
{
- StringImpl* rep = ident.impl();
+ UniquedStringImpl* rep = ident.impl();
IdentifierMap::AddResult result = m_identifierMap.add(rep, m_codeBlock->numberOfIdentifiers());
if (result.isNewEntry)
- m_codeBlock->addIdentifier(Identifier(m_vm, rep));
+ m_codeBlock->addIdentifier(ident);
return result.iterator->value;
}
@@ -978,34 +1431,68 @@ RegisterID* BytecodeGenerator::addConstantEmptyValue()
return m_emptyValueRegister;
}
-RegisterID* BytecodeGenerator::addConstantValue(JSValue v)
+RegisterID* BytecodeGenerator::addConstantValue(JSValue v, SourceCodeRepresentation sourceCodeRepresentation)
{
if (!v)
return addConstantEmptyValue();
int index = m_nextConstantOffset;
- JSValueMap::AddResult result = m_jsValueMap.add(JSValue::encode(v), m_nextConstantOffset);
+
+ if (sourceCodeRepresentation == SourceCodeRepresentation::Double && v.isInt32())
+ v = jsDoubleNumber(v.asNumber());
+ EncodedJSValueWithRepresentation valueMapKey { JSValue::encode(v), sourceCodeRepresentation };
+ JSValueMap::AddResult result = m_jsValueMap.add(valueMapKey, m_nextConstantOffset);
if (result.isNewEntry) {
m_constantPoolRegisters.append(FirstConstantRegisterIndex + m_nextConstantOffset);
++m_nextConstantOffset;
- m_codeBlock->addConstant(v);
+ m_codeBlock->addConstant(v, sourceCodeRepresentation);
} else
index = result.iterator->value;
return &m_constantPoolRegisters[index];
}
+RegisterID* BytecodeGenerator::emitMoveLinkTimeConstant(RegisterID* dst, LinkTimeConstant type)
+{
+ unsigned constantIndex = static_cast<unsigned>(type);
+ if (!m_linkTimeConstantRegisters[constantIndex]) {
+ int index = m_nextConstantOffset;
+ m_constantPoolRegisters.append(FirstConstantRegisterIndex + m_nextConstantOffset);
+ ++m_nextConstantOffset;
+ m_codeBlock->addConstant(type);
+ m_linkTimeConstantRegisters[constantIndex] = &m_constantPoolRegisters[index];
+ }
+
+ emitOpcode(op_mov);
+ instructions().append(dst->index());
+ instructions().append(m_linkTimeConstantRegisters[constantIndex]->index());
+
+ return dst;
+}
+
unsigned BytecodeGenerator::addRegExp(RegExp* r)
{
return m_codeBlock->addRegExp(r);
}
+RegisterID* BytecodeGenerator::emitMoveEmptyValue(RegisterID* dst)
+{
+ RefPtr<RegisterID> emptyValue = addConstantEmptyValue();
+
+ emitOpcode(op_mov);
+ instructions().append(dst->index());
+ instructions().append(emptyValue->index());
+ return dst;
+}
+
RegisterID* BytecodeGenerator::emitMove(RegisterID* dst, RegisterID* src)
{
- m_staticPropertyAnalyzer.mov(dst->index(), src->index());
+ ASSERT(src != m_emptyValueRegister);
+ m_staticPropertyAnalyzer.mov(dst->index(), src->index());
emitOpcode(op_mov);
instructions().append(dst->index());
instructions().append(src->index());
+
return dst;
}
@@ -1088,7 +1575,7 @@ RegisterID* BytecodeGenerator::emitEqualityOp(OpcodeID opcodeID, RegisterID* dst
}
if (value == "object") {
rewindUnaryOp();
- emitOpcode(op_is_object);
+ emitOpcode(op_is_object_or_null);
instructions().append(dst->index());
instructions().append(srcIndex);
return dst;
@@ -1110,35 +1597,117 @@ RegisterID* BytecodeGenerator::emitEqualityOp(OpcodeID opcodeID, RegisterID* dst
return dst;
}
-RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, bool b)
+void BytecodeGenerator::emitTypeProfilerExpressionInfo(const JSTextPosition& startDivot, const JSTextPosition& endDivot)
{
- return emitLoad(dst, jsBoolean(b));
+ ASSERT(vm()->typeProfiler());
+
+ unsigned start = startDivot.offset; // Ranges are inclusive of their endpoints, AND 0 indexed.
+ unsigned end = endDivot.offset - 1; // End Ranges already go one past the inclusive range, so subtract 1.
+ unsigned instructionOffset = instructions().size() - 1;
+ m_codeBlock->addTypeProfilerExpressionInfo(instructionOffset, start, end);
+}
+
+void BytecodeGenerator::emitProfileType(RegisterID* registerToProfile, ProfileTypeBytecodeFlag flag)
+{
+ if (!vm()->typeProfiler())
+ return;
+
+ if (!registerToProfile)
+ return;
+
+ emitOpcode(op_profile_type);
+ instructions().append(registerToProfile->index());
+ instructions().append(0);
+ instructions().append(flag);
+ instructions().append(0);
+ instructions().append(resolveType());
+
+ // Don't emit expression info for this version of profile type. This generally means
+ // we're profiling information for something that isn't in the actual text of a JavaScript
+ // program. For example, implicit return undefined from a function call.
}
-RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, double number)
+void BytecodeGenerator::emitProfileType(RegisterID* registerToProfile, const JSTextPosition& startDivot, const JSTextPosition& endDivot)
{
- // FIXME: Our hash tables won't hold infinity, so we make a new JSValue each time.
- // Later we can do the extra work to handle that like the other cases. They also don't
- // work correctly with NaN as a key.
- if (std::isnan(number) || number == HashTraits<double>::emptyValue() || HashTraits<double>::isDeletedValue(number))
- return emitLoad(dst, jsNumber(number));
- JSValue& valueInMap = m_numberMap.add(number, JSValue()).iterator->value;
- if (!valueInMap)
- valueInMap = jsNumber(number);
- return emitLoad(dst, valueInMap);
+ emitProfileType(registerToProfile, ProfileTypeBytecodeDoesNotHaveGlobalID, startDivot, endDivot);
+}
+
+void BytecodeGenerator::emitProfileType(RegisterID* registerToProfile, ProfileTypeBytecodeFlag flag, const JSTextPosition& startDivot, const JSTextPosition& endDivot)
+{
+ if (!vm()->typeProfiler())
+ return;
+
+ if (!registerToProfile)
+ return;
+
+ // The format of this instruction is: op_profile_type regToProfile, TypeLocation*, flag, identifier?, resolveType?
+ emitOpcode(op_profile_type);
+ instructions().append(registerToProfile->index());
+ instructions().append(0);
+ instructions().append(flag);
+ instructions().append(0);
+ instructions().append(resolveType());
+
+ emitTypeProfilerExpressionInfo(startDivot, endDivot);
+}
+
+void BytecodeGenerator::emitProfileType(RegisterID* registerToProfile, const Variable& var, const JSTextPosition& startDivot, const JSTextPosition& endDivot)
+{
+ if (!vm()->typeProfiler())
+ return;
+
+ if (!registerToProfile)
+ return;
+
+ ProfileTypeBytecodeFlag flag;
+ int symbolTableOrScopeDepth;
+ if (var.local() || var.offset().isScope()) {
+ flag = ProfileTypeBytecodeLocallyResolved;
+ symbolTableOrScopeDepth = var.symbolTableConstantIndex();
+ } else {
+ flag = ProfileTypeBytecodeClosureVar;
+ symbolTableOrScopeDepth = localScopeDepth();
+ }
+
+ // The format of this instruction is: op_profile_type regToProfile, TypeLocation*, flag, identifier?, resolveType?
+ emitOpcode(op_profile_type);
+ instructions().append(registerToProfile->index());
+ instructions().append(symbolTableOrScopeDepth);
+ instructions().append(flag);
+ instructions().append(addConstant(var.ident()));
+ instructions().append(resolveType());
+
+ emitTypeProfilerExpressionInfo(startDivot, endDivot);
+}
+
+void BytecodeGenerator::emitProfileControlFlow(int textOffset)
+{
+ if (vm()->controlFlowProfiler()) {
+ RELEASE_ASSERT(textOffset >= 0);
+ size_t bytecodeOffset = instructions().size();
+ m_codeBlock->addOpProfileControlFlowBytecodeOffset(bytecodeOffset);
+
+ emitOpcode(op_profile_control_flow);
+ instructions().append(textOffset);
+ }
+}
+
+RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, bool b)
+{
+ return emitLoad(dst, jsBoolean(b));
}
RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, const Identifier& identifier)
{
- JSString*& stringInMap = m_stringMap.add(identifier.impl(), 0).iterator->value;
+ JSString*& stringInMap = m_stringMap.add(identifier.impl(), nullptr).iterator->value;
if (!stringInMap)
stringInMap = jsOwnedString(vm(), identifier.string());
return emitLoad(dst, JSValue(stringInMap));
}
-RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, JSValue v)
+RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, JSValue v, SourceCodeRepresentation sourceCodeRepresentation)
{
- RegisterID* constantID = addConstantValue(v);
+ RegisterID* constantID = addConstantValue(v, sourceCodeRepresentation);
if (dst)
return emitMove(dst, constantID);
return constantID;
@@ -1152,249 +1721,571 @@ RegisterID* BytecodeGenerator::emitLoadGlobalObject(RegisterID* dst)
++m_nextConstantOffset;
m_codeBlock->addConstant(JSValue());
m_globalObjectRegister = &m_constantPoolRegisters[index];
- m_codeBlock->setGlobalObjectRegister(index);
+ m_codeBlock->setGlobalObjectRegister(VirtualRegister(index));
}
if (dst)
emitMove(dst, m_globalObjectRegister);
return m_globalObjectRegister;
}
-ResolveResult BytecodeGenerator::resolve(const Identifier& property)
+template<typename LookUpVarKindFunctor>
+bool BytecodeGenerator::instantiateLexicalVariables(const VariableEnvironment& lexicalVariables, SymbolTable* symbolTable, ScopeRegisterType scopeRegisterType, LookUpVarKindFunctor lookUpVarKind)
{
- if (property == propertyNames().thisIdentifier)
- return ResolveResult::registerResolve(thisRegister(), ResolveResult::ReadOnlyFlag);
+ bool hasCapturedVariables = false;
+ {
+ ConcurrentJITLocker locker(symbolTable->m_lock);
+ for (auto& entry : lexicalVariables) {
+ ASSERT(entry.value.isLet() || entry.value.isConst());
+ ASSERT(!entry.value.isVar());
+ SymbolTableEntry symbolTableEntry = symbolTable->get(locker, entry.key.get());
+ ASSERT(symbolTableEntry.isNull());
+
+ // Imported bindings which are not the namespace bindings are not allocated
+ // in the module environment as usual variables' way.
+ // And since these types of the variables only seen in the module environment,
+ // other lexical environment need not to take care this.
+ if (entry.value.isImported() && !entry.value.isImportedNamespace())
+ continue;
- // Check if the property should be allocated in a register.
- if (m_codeType != GlobalCode && shouldOptimizeLocals() && m_symbolTable) {
- SymbolTableEntry entry = symbolTable().get(property.impl());
- if (!entry.isNull()) {
- if (property == propertyNames().arguments)
- createArgumentsIfNecessary();
- unsigned flags = entry.isReadOnly() ? ResolveResult::ReadOnlyFlag : 0;
- RegisterID* local = createLazyRegisterIfNecessary(&registerFor(entry.getIndex()));
- return ResolveResult::registerResolve(local, flags);
+ VarKind varKind = lookUpVarKind(entry.key.get(), entry.value);
+ VarOffset varOffset;
+ if (varKind == VarKind::Scope) {
+ varOffset = VarOffset(symbolTable->takeNextScopeOffset(locker));
+ hasCapturedVariables = true;
+ } else {
+ ASSERT(varKind == VarKind::Stack);
+ RegisterID* local;
+ if (scopeRegisterType == ScopeRegisterType::Block) {
+ local = newBlockScopeVariable();
+ local->ref();
+ } else
+ local = addVar();
+ varOffset = VarOffset(local->virtualRegister());
+ }
+
+ SymbolTableEntry newEntry(varOffset, entry.value.isConst() ? ReadOnly : 0);
+ symbolTable->add(locker, entry.key.get(), newEntry);
}
}
- // Cases where we cannot statically optimize the lookup.
- if (property == propertyNames().arguments || !canOptimizeNonLocals())
- return ResolveResult::dynamicResolve();
-
- if (!m_scope || m_codeType != FunctionCode || m_shouldEmitDebugHooks)
- return ResolveResult::dynamicResolve();
-
- ScopeChainIterator iter = m_scope->begin();
- ScopeChainIterator end = m_scope->end();
- size_t depth = m_codeBlock->needsFullScopeChain();
- unsigned flags = 0;
- for (; iter != end; ++iter, ++depth) {
- JSObject* currentScope = iter.get();
- if (!currentScope->isStaticScopeObject())
- return ResolveResult::dynamicResolve();
-
- JSSymbolTableObject* currentVariableObject = jsCast<JSSymbolTableObject*>(currentScope);
- SymbolTableEntry entry = currentVariableObject->symbolTable()->get(property.impl());
-
- // Found the property
- if (!entry.isNull()) {
- if (entry.isReadOnly())
- flags |= ResolveResult::ReadOnlyFlag;
- if (++iter == end)
- return ResolveResult::dynamicResolve();
-#if !ASSERT_DISABLED
- if (JSActivation* activation = jsDynamicCast<JSActivation*>(currentVariableObject))
- ASSERT(activation->isValid(entry));
-#endif
- return ResolveResult::lexicalResolve(entry.getIndex(), depth, flags);
- }
- bool scopeRequiresDynamicChecks = false;
- if (currentVariableObject->isDynamicScope(scopeRequiresDynamicChecks))
- break;
- if (scopeRequiresDynamicChecks)
- flags |= ResolveResult::DynamicFlag;
+ return hasCapturedVariables;
+}
+
+void BytecodeGenerator::emitPrefillStackTDZVariables(const VariableEnvironment& lexicalVariables, SymbolTable* symbolTable)
+{
+ // Prefill stack variables with the TDZ empty value.
+ // Scope variables will be initialized to the TDZ empty value when JSLexicalEnvironment is allocated.
+ for (auto& entry : lexicalVariables) {
+ // Imported bindings which are not the namespace bindings are not allocated
+ // in the module environment as usual variables' way.
+ // And since these types of the variables only seen in the module environment,
+ // other lexical environment need not to take care this.
+ if (entry.value.isImported() && !entry.value.isImportedNamespace())
+ continue;
+
+ SymbolTableEntry symbolTableEntry = symbolTable->get(entry.key.get());
+ ASSERT(!symbolTableEntry.isNull());
+ VarOffset offset = symbolTableEntry.varOffset();
+ if (offset.isScope())
+ continue;
+
+ ASSERT(offset.isStack());
+ emitMoveEmptyValue(&registerFor(offset.stackOffset()));
}
+}
- return ResolveResult::dynamicResolve();
+void BytecodeGenerator::pushLexicalScope(VariableEnvironmentNode* node, TDZCheckOptimization tdzCheckOptimization, NestedScopeType nestedScopeType, RegisterID** constantSymbolTableResult)
+{
+ VariableEnvironment& environment = node->lexicalVariables();
+ pushLexicalScopeInternal(environment, tdzCheckOptimization, nestedScopeType, constantSymbolTableResult, TDZRequirement::UnderTDZ, ScopeType::LetConstScope, ScopeRegisterType::Block);
}
-ResolveResult BytecodeGenerator::resolveConstDecl(const Identifier& property)
+void BytecodeGenerator::pushLexicalScopeInternal(VariableEnvironment& environment, TDZCheckOptimization tdzCheckOptimization, NestedScopeType nestedScopeType,
+ RegisterID** constantSymbolTableResult, TDZRequirement tdzRequirement, ScopeType scopeType, ScopeRegisterType scopeRegisterType)
{
- // Register-allocated const declarations.
- if (m_codeType == FunctionCode && m_symbolTable) {
- SymbolTableEntry entry = symbolTable().get(property.impl());
- if (!entry.isNull()) {
- unsigned flags = entry.isReadOnly() ? ResolveResult::ReadOnlyFlag : 0;
- RegisterID* local = createLazyRegisterIfNecessary(&registerFor(entry.getIndex()));
- return ResolveResult::registerResolve(local, flags);
+ if (!environment.size())
+ return;
+
+ if (m_shouldEmitDebugHooks)
+ environment.markAllVariablesAsCaptured();
+
+ Strong<SymbolTable> symbolTable(*m_vm, SymbolTable::create(*m_vm));
+ switch (scopeType) {
+ case ScopeType::CatchScope:
+ symbolTable->setScopeType(SymbolTable::ScopeType::CatchScope);
+ break;
+ case ScopeType::LetConstScope:
+ symbolTable->setScopeType(SymbolTable::ScopeType::LexicalScope);
+ break;
+ case ScopeType::FunctionNameScope:
+ symbolTable->setScopeType(SymbolTable::ScopeType::FunctionNameScope);
+ break;
+ }
+
+ if (nestedScopeType == NestedScopeType::IsNested)
+ symbolTable->markIsNestedLexicalScope();
+
+ auto lookUpVarKind = [] (UniquedStringImpl*, const VariableEnvironmentEntry& entry) -> VarKind {
+ return entry.isCaptured() ? VarKind::Scope : VarKind::Stack;
+ };
+
+ bool hasCapturedVariables = instantiateLexicalVariables(environment, symbolTable.get(), scopeRegisterType, lookUpVarKind);
+
+ RegisterID* newScope = nullptr;
+ RegisterID* constantSymbolTable = nullptr;
+ int symbolTableConstantIndex = 0;
+ if (vm()->typeProfiler()) {
+ constantSymbolTable = addConstantValue(symbolTable.get());
+ symbolTableConstantIndex = constantSymbolTable->index();
+ }
+ if (hasCapturedVariables) {
+ if (scopeRegisterType == ScopeRegisterType::Block) {
+ newScope = newBlockScopeVariable();
+ newScope->ref();
+ } else
+ newScope = addVar();
+ if (!constantSymbolTable) {
+ ASSERT(!vm()->typeProfiler());
+ constantSymbolTable = addConstantValue(symbolTable->cloneScopePart(*m_vm));
+ symbolTableConstantIndex = constantSymbolTable->index();
}
+ if (constantSymbolTableResult)
+ *constantSymbolTableResult = constantSymbolTable;
+
+ emitOpcode(op_create_lexical_environment);
+ instructions().append(newScope->index());
+ instructions().append(scopeRegister()->index());
+ instructions().append(constantSymbolTable->index());
+ instructions().append(addConstantValue(tdzRequirement == TDZRequirement::UnderTDZ ? jsTDZValue() : jsUndefined())->index());
+
+ emitMove(scopeRegister(), newScope);
+
+ pushScopedControlFlowContext();
}
- return ResolveResult::dynamicResolve();
-}
+ m_symbolTableStack.append(SymbolTableStackEntry{ symbolTable, newScope, false, symbolTableConstantIndex });
+ bool canOptimizeTDZChecks = tdzCheckOptimization == TDZCheckOptimization::Optimize;
+ if (tdzRequirement == TDZRequirement::UnderTDZ)
+ m_TDZStack.append(std::make_pair(environment, canOptimizeTDZChecks));
-void BytecodeGenerator::emitCheckHasInstance(RegisterID* dst, RegisterID* value, RegisterID* base, Label* target)
-{
- size_t begin = instructions().size();
- emitOpcode(op_check_has_instance);
- instructions().append(dst->index());
- instructions().append(value->index());
- instructions().append(base->index());
- instructions().append(target->bind(begin, instructions().size()));
+ if (tdzRequirement == TDZRequirement::UnderTDZ)
+ emitPrefillStackTDZVariables(environment, symbolTable.get());
}
-RegisterID* BytecodeGenerator::emitInstanceOf(RegisterID* dst, RegisterID* value, RegisterID* basePrototype)
-{
- emitOpcode(op_instanceof);
- instructions().append(dst->index());
- instructions().append(value->index());
- instructions().append(basePrototype->index());
- return dst;
+void BytecodeGenerator::popLexicalScope(VariableEnvironmentNode* node)
+{
+ VariableEnvironment& environment = node->lexicalVariables();
+ popLexicalScopeInternal(environment, TDZRequirement::UnderTDZ);
}
-bool BytecodeGenerator::shouldAvoidResolveGlobal()
+void BytecodeGenerator::popLexicalScopeInternal(VariableEnvironment& environment, TDZRequirement tdzRequirement)
{
- return !m_labelScopes.size();
+ // NOTE: This function only makes sense for scopes that aren't ScopeRegisterType::Var (only function name scope right now is ScopeRegisterType::Var).
+ // This doesn't make sense for ScopeRegisterType::Var because we deref RegisterIDs here.
+ if (!environment.size())
+ return;
+
+ if (m_shouldEmitDebugHooks)
+ environment.markAllVariablesAsCaptured();
+
+ SymbolTableStackEntry stackEntry = m_symbolTableStack.takeLast();
+ Strong<SymbolTable> symbolTable = stackEntry.m_symbolTable;
+ ConcurrentJITLocker locker(symbolTable->m_lock);
+ bool hasCapturedVariables = false;
+ for (auto& entry : environment) {
+ if (entry.value.isCaptured()) {
+ hasCapturedVariables = true;
+ continue;
+ }
+ SymbolTableEntry symbolTableEntry = symbolTable->get(locker, entry.key.get());
+ ASSERT(!symbolTableEntry.isNull());
+ VarOffset offset = symbolTableEntry.varOffset();
+ ASSERT(offset.isStack());
+ RegisterID* local = &registerFor(offset.stackOffset());
+ local->deref();
+ }
+
+ if (hasCapturedVariables) {
+ RELEASE_ASSERT(stackEntry.m_scope);
+ emitPopScope(scopeRegister(), stackEntry.m_scope);
+ popScopedControlFlowContext();
+ stackEntry.m_scope->deref();
+ }
+
+ if (tdzRequirement == TDZRequirement::UnderTDZ)
+ m_TDZStack.removeLast();
}
-RegisterID* BytecodeGenerator::emitResolve(RegisterID* dst, const ResolveResult& resolveResult, const Identifier& property)
+void BytecodeGenerator::prepareLexicalScopeForNextForLoopIteration(VariableEnvironmentNode* node, RegisterID* loopSymbolTable)
{
+ VariableEnvironment& environment = node->lexicalVariables();
+ if (!environment.size())
+ return;
+ if (m_shouldEmitDebugHooks)
+ environment.markAllVariablesAsCaptured();
+ if (!environment.hasCapturedVariables())
+ return;
- if (resolveResult.isStatic())
- return emitGetStaticVar(dst, resolveResult, property);
+ RELEASE_ASSERT(loopSymbolTable);
- UnlinkedValueProfile profile = emitProfiledOpcode(op_resolve);
- instructions().append(kill(dst));
- instructions().append(addConstant(property));
- instructions().append(getResolveOperations(property));
- instructions().append(profile);
- return dst;
+ // This function needs to do setup for a for loop's activation if any of
+ // the for loop's lexically declared variables are captured (that is, variables
+ // declared in the loop header, not the loop body). This function needs to
+ // make a copy of the current activation and copy the values from the previous
+ // activation into the new activation because each iteration of a for loop
+ // gets a new activation.
+
+ SymbolTableStackEntry stackEntry = m_symbolTableStack.last();
+ Strong<SymbolTable> symbolTable = stackEntry.m_symbolTable;
+ RegisterID* loopScope = stackEntry.m_scope;
+ ASSERT(symbolTable->scopeSize());
+ ASSERT(loopScope);
+ Vector<std::pair<RegisterID*, Identifier>> activationValuesToCopyOver;
+
+ {
+ ConcurrentJITLocker locker(symbolTable->m_lock);
+ activationValuesToCopyOver.reserveInitialCapacity(symbolTable->scopeSize());
+
+ for (auto end = symbolTable->end(locker), ptr = symbolTable->begin(locker); ptr != end; ++ptr) {
+ if (!ptr->value.varOffset().isScope())
+ continue;
+
+ RefPtr<UniquedStringImpl> ident = ptr->key;
+ Identifier identifier = Identifier::fromUid(m_vm, ident.get());
+
+ RegisterID* transitionValue = newBlockScopeVariable();
+ transitionValue->ref();
+ emitGetFromScope(transitionValue, loopScope, variableForLocalEntry(identifier, ptr->value, loopSymbolTable->index(), true), DoNotThrowIfNotFound);
+ activationValuesToCopyOver.uncheckedAppend(std::make_pair(transitionValue, identifier));
+ }
+ }
+
+ // We need this dynamic behavior of the executing code to ensure
+ // each loop iteration has a new activation object. (It's pretty ugly).
+ // Also, this new activation needs to be assigned to the same register
+ // as the previous scope because the loop body is compiled under
+ // the assumption that the scope's register index is constant even
+ // though the value in that register will change on each loop iteration.
+ RefPtr<RegisterID> parentScope = emitGetParentScope(newTemporary(), loopScope);
+ emitMove(scopeRegister(), parentScope.get());
+
+ emitOpcode(op_create_lexical_environment);
+ instructions().append(loopScope->index());
+ instructions().append(scopeRegister()->index());
+ instructions().append(loopSymbolTable->index());
+ instructions().append(addConstantValue(jsTDZValue())->index());
+
+ emitMove(scopeRegister(), loopScope);
+
+ {
+ ConcurrentJITLocker locker(symbolTable->m_lock);
+ for (auto pair : activationValuesToCopyOver) {
+ const Identifier& identifier = pair.second;
+ SymbolTableEntry entry = symbolTable->get(locker, identifier.impl());
+ RELEASE_ASSERT(!entry.isNull());
+ RegisterID* transitionValue = pair.first;
+ emitPutToScope(loopScope, variableForLocalEntry(identifier, entry, loopSymbolTable->index(), true), transitionValue, DoNotThrowIfNotFound, NotInitialization);
+ transitionValue->deref();
+ }
+ }
}
-RegisterID* BytecodeGenerator::emitResolveBase(RegisterID* dst, const ResolveResult& resolveResult, const Identifier& property)
+Variable BytecodeGenerator::variable(const Identifier& property, ThisResolutionType thisResolutionType)
{
- if (!resolveResult.isDynamic()) {
- // Global object is the base
- return emitLoadGlobalObject(dst);
+ if (property == propertyNames().thisIdentifier && thisResolutionType == ThisResolutionType::Local) {
+ return Variable(property, VarOffset(thisRegister()->virtualRegister()), thisRegister(),
+ ReadOnly, Variable::SpecialVariable, 0, false);
+ }
+
+ // We can optimize lookups if the lexical variable is found before a "with" or "catch"
+ // scope because we're guaranteed static resolution. If we have to pass through
+ // a "with" or "catch" scope we loose this guarantee.
+ // We can't optimize cases like this:
+ // {
+ // let x = ...;
+ // with (o) {
+ // doSomethingWith(x);
+ // }
+ // }
+ // Because we can't gaurantee static resolution on x.
+ // But, in this case, we are guaranteed static resolution:
+ // {
+ // let x = ...;
+ // with (o) {
+ // let x = ...;
+ // doSomethingWith(x);
+ // }
+ // }
+ for (unsigned i = m_symbolTableStack.size(); i--; ) {
+ SymbolTableStackEntry& stackEntry = m_symbolTableStack[i];
+ if (stackEntry.m_isWithScope)
+ return Variable(property);
+ Strong<SymbolTable>& symbolTable = stackEntry.m_symbolTable;
+ SymbolTableEntry symbolTableEntry = symbolTable->get(property.impl());
+ if (symbolTableEntry.isNull())
+ continue;
+ bool resultIsCallee = false;
+ if (symbolTable->scopeType() == SymbolTable::ScopeType::FunctionNameScope) {
+ if (m_usesNonStrictEval) {
+ // We don't know if an eval has introduced a "var" named the same thing as the function name scope variable name.
+ // We resort to dynamic lookup to answer this question.
+ Variable result = Variable(property);
+ return result;
+ }
+ resultIsCallee = true;
+ }
+ Variable result = variableForLocalEntry(property, symbolTableEntry, stackEntry.m_symbolTableConstantIndex, symbolTable->scopeType() == SymbolTable::ScopeType::LexicalScope);
+ if (resultIsCallee)
+ result.setIsReadOnly();
+ return result;
}
- // We can't optimise at all :-(
- UnlinkedValueProfile profile = emitProfiledOpcode(op_resolve_base);
- instructions().append(kill(dst));
- instructions().append(addConstant(property));
- instructions().append(false);
- instructions().append(getResolveBaseOperations(property));
- instructions().append(0);
- instructions().append(profile);
- return dst;
+ return Variable(property);
}
-RegisterID* BytecodeGenerator::emitResolveBaseForPut(RegisterID* dst, const ResolveResult&, const Identifier& property, NonlocalResolveInfo& verifier)
+Variable BytecodeGenerator::variableForLocalEntry(
+ const Identifier& property, const SymbolTableEntry& entry, int symbolTableConstantIndex, bool isLexicallyScoped)
{
- // We can't optimise at all :-(
- UnlinkedValueProfile profile = emitProfiledOpcode(op_resolve_base);
- instructions().append(kill(dst));
- instructions().append(addConstant(property));
- instructions().append(m_codeBlock->isStrictMode());
- uint32_t putToBaseIndex = 0;
- instructions().append(getResolveBaseForPutOperations(property, putToBaseIndex));
- verifier.resolved(putToBaseIndex);
- instructions().append(putToBaseIndex);
- instructions().append(profile);
- return dst;
+ VarOffset offset = entry.varOffset();
+
+ RegisterID* local;
+ if (offset.isStack())
+ local = &registerFor(offset.stackOffset());
+ else
+ local = nullptr;
+
+ return Variable(property, offset, local, entry.getAttributes(), Variable::NormalVariable, symbolTableConstantIndex, isLexicallyScoped);
}
-RegisterID* BytecodeGenerator::emitResolveWithBaseForPut(RegisterID* baseDst, RegisterID* propDst, const ResolveResult& resolveResult, const Identifier& property, NonlocalResolveInfo& verifier)
+void BytecodeGenerator::createVariable(
+ const Identifier& property, VarKind varKind, SymbolTable* symbolTable, ExistingVariableMode existingVariableMode)
{
- ASSERT_UNUSED(resolveResult, !resolveResult.isStatic());
- UnlinkedValueProfile profile = emitProfiledOpcode(op_resolve_with_base);
- instructions().append(kill(baseDst));
- instructions().append(propDst->index());
- instructions().append(addConstant(property));
- uint32_t putToBaseIndex = 0;
- instructions().append(getResolveWithBaseForPutOperations(property, putToBaseIndex));
- verifier.resolved(putToBaseIndex);
- instructions().append(putToBaseIndex);
- instructions().append(profile);
- return baseDst;
+ ASSERT(property != propertyNames().thisIdentifier);
+ ConcurrentJITLocker locker(symbolTable->m_lock);
+ SymbolTableEntry entry = symbolTable->get(locker, property.impl());
+
+ if (!entry.isNull()) {
+ if (existingVariableMode == IgnoreExisting)
+ return;
+
+ // Do some checks to ensure that the variable we're being asked to create is sufficiently
+ // compatible with the one we have already created.
+
+ VarOffset offset = entry.varOffset();
+
+ // We can't change our minds about whether it's captured.
+ if (offset.kind() != varKind) {
+ dataLog(
+ "Trying to add variable called ", property, " as ", varKind,
+ " but it was already added as ", offset, ".\n");
+ RELEASE_ASSERT_NOT_REACHED();
+ }
+
+ return;
+ }
+
+ VarOffset varOffset;
+ if (varKind == VarKind::Scope)
+ varOffset = VarOffset(symbolTable->takeNextScopeOffset(locker));
+ else {
+ ASSERT(varKind == VarKind::Stack);
+ varOffset = VarOffset(virtualRegisterForLocal(m_calleeLocals.size()));
+ }
+ SymbolTableEntry newEntry(varOffset, 0);
+ symbolTable->add(locker, property.impl(), newEntry);
+
+ if (varKind == VarKind::Stack) {
+ RegisterID* local = addVar();
+ RELEASE_ASSERT(local->index() == varOffset.stackOffset().offset());
+ }
}
-RegisterID* BytecodeGenerator::emitResolveWithThis(RegisterID* baseDst, RegisterID* propDst, const ResolveResult& resolveResult, const Identifier& property)
+RegisterID* BytecodeGenerator::emitOverridesHasInstance(RegisterID* dst, RegisterID* constructor, RegisterID* hasInstanceValue)
{
- if (resolveResult.isStatic()) {
- emitLoad(baseDst, jsUndefined());
- emitGetStaticVar(propDst, resolveResult, property);
- return baseDst;
+ emitOpcode(op_overrides_has_instance);
+ instructions().append(dst->index());
+ instructions().append(constructor->index());
+ instructions().append(hasInstanceValue->index());
+ return dst;
+}
+
+// Indicates the least upper bound of resolve type based on local scope. The bytecode linker
+// will start with this ResolveType and compute the least upper bound including intercepting scopes.
+ResolveType BytecodeGenerator::resolveType()
+{
+ for (unsigned i = m_symbolTableStack.size(); i--; ) {
+ if (m_symbolTableStack[i].m_isWithScope)
+ return Dynamic;
+ if (m_usesNonStrictEval && m_symbolTableStack[i].m_symbolTable->scopeType() == SymbolTable::ScopeType::FunctionNameScope) {
+ // We never want to assign to a FunctionNameScope. Returning Dynamic here achieves this goal.
+ // If we aren't in non-strict eval mode, then NodesCodeGen needs to take care not to emit
+ // a put_to_scope with the destination being the function name scope variable.
+ return Dynamic;
+ }
}
- UnlinkedValueProfile profile = emitProfiledOpcode(op_resolve_with_this);
- instructions().append(kill(baseDst));
- instructions().append(propDst->index());
- instructions().append(addConstant(property));
- instructions().append(getResolveWithThisOperations(property));
- instructions().append(profile);
- return baseDst;
+ if (m_usesNonStrictEval)
+ return GlobalPropertyWithVarInjectionChecks;
+ return GlobalProperty;
}
-RegisterID* BytecodeGenerator::emitGetStaticVar(RegisterID* dst, const ResolveResult& resolveResult, const Identifier&)
+RegisterID* BytecodeGenerator::emitResolveScope(RegisterID* dst, const Variable& variable)
{
- ASSERT(m_codeType == FunctionCode);
- switch (resolveResult.type()) {
- case ResolveResult::Register:
- case ResolveResult::ReadOnlyRegister:
- if (dst == ignoredResult())
- return 0;
- return moveToDestinationIfNeeded(dst, resolveResult.local());
+ switch (variable.offset().kind()) {
+ case VarKind::Stack:
+ return nullptr;
+
+ case VarKind::DirectArgument:
+ return argumentsRegister();
+
+ case VarKind::Scope:
+ // This always refers to the activation that *we* allocated, and not the current scope that code
+ // lives in. Note that this will change once we have proper support for block scoping. Once that
+ // changes, it will be correct for this code to return scopeRegister(). The only reason why we
+ // don't do that already is that m_lexicalEnvironment is required by ConstDeclNode. ConstDeclNode
+ // requires weird things because it is a shameful pile of nonsense, but block scoping would make
+ // that code sensible and obviate the need for us to do bad things.
+ for (unsigned i = m_symbolTableStack.size(); i--; ) {
+ SymbolTableStackEntry& stackEntry = m_symbolTableStack[i];
+ // We should not resolve a variable to VarKind::Scope if a "with" scope lies in between the current
+ // scope and the resolved scope.
+ RELEASE_ASSERT(!stackEntry.m_isWithScope);
+
+ if (stackEntry.m_symbolTable->get(variable.ident().impl()).isNull())
+ continue;
+
+ RegisterID* scope = stackEntry.m_scope;
+ RELEASE_ASSERT(scope);
+ return scope;
+ }
- case ResolveResult::Lexical:
- case ResolveResult::ReadOnlyLexical: {
- UnlinkedValueProfile profile = emitProfiledOpcode(op_get_scoped_var);
- instructions().append(dst->index());
- instructions().append(resolveResult.index());
- instructions().append(resolveResult.depth());
- instructions().append(profile);
+ RELEASE_ASSERT_NOT_REACHED();
+ return nullptr;
+
+ case VarKind::Invalid:
+ // Indicates non-local resolution.
+
+ m_codeBlock->addPropertyAccessInstruction(instructions().size());
+
+ // resolve_scope dst, id, ResolveType, depth
+ dst = tempDestination(dst);
+ emitOpcode(op_resolve_scope);
+ instructions().append(kill(dst));
+ instructions().append(scopeRegister()->index());
+ instructions().append(addConstant(variable.ident()));
+ instructions().append(resolveType());
+ instructions().append(localScopeDepth());
+ instructions().append(0);
return dst;
}
+
+ RELEASE_ASSERT_NOT_REACHED();
+ return nullptr;
+}
- default:
- RELEASE_ASSERT_NOT_REACHED();
- return 0;
+RegisterID* BytecodeGenerator::emitGetFromScope(RegisterID* dst, RegisterID* scope, const Variable& variable, ResolveMode resolveMode)
+{
+ switch (variable.offset().kind()) {
+ case VarKind::Stack:
+ return emitMove(dst, variable.local());
+
+ case VarKind::DirectArgument: {
+ UnlinkedValueProfile profile = emitProfiledOpcode(op_get_from_arguments);
+ instructions().append(kill(dst));
+ instructions().append(scope->index());
+ instructions().append(variable.offset().capturedArgumentsOffset().offset());
+ instructions().append(profile);
+ return dst;
}
+
+ case VarKind::Scope:
+ case VarKind::Invalid: {
+ m_codeBlock->addPropertyAccessInstruction(instructions().size());
+
+ // get_from_scope dst, scope, id, GetPutInfo, Structure, Operand
+ UnlinkedValueProfile profile = emitProfiledOpcode(op_get_from_scope);
+ instructions().append(kill(dst));
+ instructions().append(scope->index());
+ instructions().append(addConstant(variable.ident()));
+ instructions().append(GetPutInfo(resolveMode, variable.offset().isScope() ? LocalClosureVar : resolveType(), NotInitialization).operand());
+ instructions().append(localScopeDepth());
+ instructions().append(variable.offset().isScope() ? variable.offset().scopeOffset().offset() : 0);
+ instructions().append(profile);
+ return dst;
+ } }
+
+ RELEASE_ASSERT_NOT_REACHED();
}
-RegisterID* BytecodeGenerator::emitInitGlobalConst(const Identifier& identifier, RegisterID* value)
+RegisterID* BytecodeGenerator::emitPutToScope(RegisterID* scope, const Variable& variable, RegisterID* value, ResolveMode resolveMode, InitializationMode initializationMode)
{
- ASSERT(m_codeType == GlobalCode);
- emitOpcode(op_init_global_const_nop);
- instructions().append(0);
- instructions().append(value->index());
- instructions().append(0);
- instructions().append(addConstant(identifier));
- return value;
+ switch (variable.offset().kind()) {
+ case VarKind::Stack:
+ emitMove(variable.local(), value);
+ return value;
+
+ case VarKind::DirectArgument:
+ emitOpcode(op_put_to_arguments);
+ instructions().append(scope->index());
+ instructions().append(variable.offset().capturedArgumentsOffset().offset());
+ instructions().append(value->index());
+ return value;
+
+ case VarKind::Scope:
+ case VarKind::Invalid: {
+ m_codeBlock->addPropertyAccessInstruction(instructions().size());
+
+ // put_to_scope scope, id, value, GetPutInfo, Structure, Operand
+ emitOpcode(op_put_to_scope);
+ instructions().append(scope->index());
+ instructions().append(addConstant(variable.ident()));
+ instructions().append(value->index());
+ ScopeOffset offset;
+ if (variable.offset().isScope()) {
+ offset = variable.offset().scopeOffset();
+ instructions().append(GetPutInfo(resolveMode, LocalClosureVar, initializationMode).operand());
+ instructions().append(variable.symbolTableConstantIndex());
+ } else {
+ ASSERT(resolveType() != LocalClosureVar);
+ instructions().append(GetPutInfo(resolveMode, resolveType(), initializationMode).operand());
+ instructions().append(localScopeDepth());
+ }
+ instructions().append(!!offset ? offset.offset() : 0);
+ return value;
+ } }
+
+ RELEASE_ASSERT_NOT_REACHED();
}
-RegisterID* BytecodeGenerator::emitPutStaticVar(const ResolveResult& resolveResult, const Identifier&, RegisterID* value)
+RegisterID* BytecodeGenerator::initializeVariable(const Variable& variable, RegisterID* value)
{
- ASSERT(m_codeType == FunctionCode);
- switch (resolveResult.type()) {
- case ResolveResult::Register:
- case ResolveResult::ReadOnlyRegister:
- return moveToDestinationIfNeeded(resolveResult.local(), value);
+ RELEASE_ASSERT(variable.offset().kind() != VarKind::Invalid);
+ RegisterID* scope = emitResolveScope(nullptr, variable);
+ return emitPutToScope(scope, variable, value, ThrowIfNotFound, NotInitialization);
+}
- case ResolveResult::Lexical:
- case ResolveResult::ReadOnlyLexical:
- emitOpcode(op_put_scoped_var);
- instructions().append(resolveResult.index());
- instructions().append(resolveResult.depth());
- instructions().append(value->index());
- return value;
+RegisterID* BytecodeGenerator::emitInstanceOf(RegisterID* dst, RegisterID* value, RegisterID* basePrototype)
+{
+ emitOpcode(op_instanceof);
+ instructions().append(dst->index());
+ instructions().append(value->index());
+ instructions().append(basePrototype->index());
+ return dst;
+}
- default:
- RELEASE_ASSERT_NOT_REACHED();
- return 0;
- }
+RegisterID* BytecodeGenerator::emitInstanceOfCustom(RegisterID* dst, RegisterID* value, RegisterID* constructor, RegisterID* hasInstanceValue)
+{
+ emitOpcode(op_instanceof_custom);
+ instructions().append(dst->index());
+ instructions().append(value->index());
+ instructions().append(constructor->index());
+ instructions().append(hasInstanceValue->index());
+ return dst;
}
RegisterID* BytecodeGenerator::emitGetById(RegisterID* dst, RegisterID* base, const Identifier& property)
{
+ ASSERT_WITH_MESSAGE(!parseIndex(property), "Indexed properties should be handled with get_by_val.");
+
m_codeBlock->addPropertyAccessInstruction(instructions().size());
UnlinkedValueProfile profile = emitProfiledOpcode(op_get_by_id);
@@ -1409,18 +2300,10 @@ RegisterID* BytecodeGenerator::emitGetById(RegisterID* dst, RegisterID* base, co
return dst;
}
-RegisterID* BytecodeGenerator::emitGetArgumentsLength(RegisterID* dst, RegisterID* base)
-{
- emitOpcode(op_get_arguments_length);
- instructions().append(dst->index());
- ASSERT(base->index() == m_codeBlock->argumentsRegister());
- instructions().append(base->index());
- instructions().append(addConstant(propertyNames().length));
- return dst;
-}
-
RegisterID* BytecodeGenerator::emitPutById(RegisterID* base, const Identifier& property, RegisterID* value)
{
+ ASSERT_WITH_MESSAGE(!parseIndex(property), "Indexed properties should be handled with put_by_val.");
+
unsigned propertyIndex = addConstant(property);
m_staticPropertyAnalyzer.putById(base->index(), propertyIndex);
@@ -1431,26 +2314,19 @@ RegisterID* BytecodeGenerator::emitPutById(RegisterID* base, const Identifier& p
instructions().append(base->index());
instructions().append(propertyIndex);
instructions().append(value->index());
- instructions().append(0);
- instructions().append(0);
- instructions().append(0);
- instructions().append(0);
- instructions().append(0);
- return value;
-}
+ instructions().append(0); // old structure
+ instructions().append(0); // offset
+ instructions().append(0); // new structure
+ instructions().append(0); // structure chain
+ instructions().append(static_cast<int>(PutByIdNone)); // is not direct
-RegisterID* BytecodeGenerator::emitPutToBase(RegisterID* base, const Identifier& property, RegisterID* value, NonlocalResolveInfo& resolveInfo)
-{
- emitOpcode(op_put_to_base);
- instructions().append(base->index());
- instructions().append(addConstant(property));
- instructions().append(value->index());
- instructions().append(resolveInfo.put());
return value;
}
-RegisterID* BytecodeGenerator::emitDirectPutById(RegisterID* base, const Identifier& property, RegisterID* value)
+RegisterID* BytecodeGenerator::emitDirectPutById(RegisterID* base, const Identifier& property, RegisterID* value, PropertyNode::PutType putType)
{
+ ASSERT_WITH_MESSAGE(!parseIndex(property), "Indexed properties should be handled with put_by_val(direct).");
+
unsigned propertyIndex = addConstant(property);
m_staticPropertyAnalyzer.putById(base->index(), propertyIndex);
@@ -1461,66 +2337,106 @@ RegisterID* BytecodeGenerator::emitDirectPutById(RegisterID* base, const Identif
instructions().append(base->index());
instructions().append(propertyIndex);
instructions().append(value->index());
- instructions().append(0);
- instructions().append(0);
- instructions().append(0);
- instructions().append(0);
- instructions().append(
- property != m_vm->propertyNames->underscoreProto
- && PropertyName(property).asIndex() == PropertyName::NotAnIndex);
+ instructions().append(0); // old structure
+ instructions().append(0); // offset
+ instructions().append(0); // new structure
+ instructions().append(0); // structure chain (unused if direct)
+ instructions().append(static_cast<int>((putType == PropertyNode::KnownDirect || property != m_vm->propertyNames->underscoreProto) ? PutByIdIsDirect : PutByIdNone));
return value;
}
-void BytecodeGenerator::emitPutGetterSetter(RegisterID* base, const Identifier& property, RegisterID* getter, RegisterID* setter)
+void BytecodeGenerator::emitPutGetterById(RegisterID* base, const Identifier& property, unsigned attributes, RegisterID* getter)
+{
+ unsigned propertyIndex = addConstant(property);
+ m_staticPropertyAnalyzer.putById(base->index(), propertyIndex);
+
+ emitOpcode(op_put_getter_by_id);
+ instructions().append(base->index());
+ instructions().append(propertyIndex);
+ instructions().append(attributes);
+ instructions().append(getter->index());
+}
+
+void BytecodeGenerator::emitPutSetterById(RegisterID* base, const Identifier& property, unsigned attributes, RegisterID* setter)
+{
+ unsigned propertyIndex = addConstant(property);
+ m_staticPropertyAnalyzer.putById(base->index(), propertyIndex);
+
+ emitOpcode(op_put_setter_by_id);
+ instructions().append(base->index());
+ instructions().append(propertyIndex);
+ instructions().append(attributes);
+ instructions().append(setter->index());
+}
+
+void BytecodeGenerator::emitPutGetterSetter(RegisterID* base, const Identifier& property, unsigned attributes, RegisterID* getter, RegisterID* setter)
{
unsigned propertyIndex = addConstant(property);
m_staticPropertyAnalyzer.putById(base->index(), propertyIndex);
- emitOpcode(op_put_getter_setter);
+ emitOpcode(op_put_getter_setter_by_id);
instructions().append(base->index());
instructions().append(propertyIndex);
+ instructions().append(attributes);
instructions().append(getter->index());
instructions().append(setter->index());
}
-RegisterID* BytecodeGenerator::emitDeleteById(RegisterID* dst, RegisterID* base, const Identifier& property)
+void BytecodeGenerator::emitPutGetterByVal(RegisterID* base, RegisterID* property, unsigned attributes, RegisterID* getter)
{
- emitOpcode(op_del_by_id);
- instructions().append(dst->index());
+ emitOpcode(op_put_getter_by_val);
instructions().append(base->index());
- instructions().append(addConstant(property));
- return dst;
+ instructions().append(property->index());
+ instructions().append(attributes);
+ instructions().append(getter->index());
}
-RegisterID* BytecodeGenerator::emitGetArgumentByVal(RegisterID* dst, RegisterID* base, RegisterID* property)
+void BytecodeGenerator::emitPutSetterByVal(RegisterID* base, RegisterID* property, unsigned attributes, RegisterID* setter)
{
- UnlinkedArrayProfile arrayProfile = newArrayProfile();
- UnlinkedValueProfile profile = emitProfiledOpcode(op_get_argument_by_val);
- instructions().append(kill(dst));
- ASSERT(base->index() == m_codeBlock->argumentsRegister());
+ emitOpcode(op_put_setter_by_val);
instructions().append(base->index());
instructions().append(property->index());
- instructions().append(arrayProfile);
- instructions().append(profile);
+ instructions().append(attributes);
+ instructions().append(setter->index());
+}
+
+RegisterID* BytecodeGenerator::emitDeleteById(RegisterID* dst, RegisterID* base, const Identifier& property)
+{
+ emitOpcode(op_del_by_id);
+ instructions().append(dst->index());
+ instructions().append(base->index());
+ instructions().append(addConstant(property));
return dst;
}
RegisterID* BytecodeGenerator::emitGetByVal(RegisterID* dst, RegisterID* base, RegisterID* property)
{
for (size_t i = m_forInContextStack.size(); i > 0; i--) {
- ForInContext& context = m_forInContextStack[i - 1];
- if (context.propertyRegister == property) {
- emitOpcode(op_get_by_pname);
- instructions().append(dst->index());
- instructions().append(base->index());
- instructions().append(property->index());
- instructions().append(context.expectedSubscriptRegister->index());
- instructions().append(context.iterRegister->index());
- instructions().append(context.indexRegister->index());
- return dst;
+ ForInContext* context = m_forInContextStack[i - 1].get();
+ if (context->local() != property)
+ continue;
+
+ if (!context->isValid())
+ break;
+
+ if (context->type() == ForInContext::IndexedForInContextType) {
+ property = static_cast<IndexedForInContext*>(context)->index();
+ break;
}
+
+ ASSERT(context->type() == ForInContext::StructureForInContextType);
+ StructureForInContext* structureContext = static_cast<StructureForInContext*>(context);
+ UnlinkedValueProfile profile = emitProfiledOpcode(op_get_direct_pname);
+ instructions().append(kill(dst));
+ instructions().append(base->index());
+ instructions().append(property->index());
+ instructions().append(structureContext->index()->index());
+ instructions().append(structureContext->enumerator()->index());
+ instructions().append(profile);
+ return dst;
}
+
UnlinkedArrayProfile arrayProfile = newArrayProfile();
UnlinkedValueProfile profile = emitProfiledOpcode(op_get_by_val);
instructions().append(kill(dst));
@@ -1539,6 +2455,18 @@ RegisterID* BytecodeGenerator::emitPutByVal(RegisterID* base, RegisterID* proper
instructions().append(property->index());
instructions().append(value->index());
instructions().append(arrayProfile);
+
+ return value;
+}
+
+RegisterID* BytecodeGenerator::emitDirectPutByVal(RegisterID* base, RegisterID* property, RegisterID* value)
+{
+ UnlinkedArrayProfile arrayProfile = newArrayProfile();
+ emitOpcode(op_put_by_val_direct);
+ instructions().append(base->index());
+ instructions().append(property->index());
+ instructions().append(value->index());
+ instructions().append(arrayProfile);
return value;
}
@@ -1560,24 +2488,83 @@ RegisterID* BytecodeGenerator::emitPutByIndex(RegisterID* base, unsigned index,
return value;
}
-RegisterID* BytecodeGenerator::emitCreateThis(RegisterID* dst)
+RegisterID* BytecodeGenerator::emitAssert(RegisterID* condition, int line)
{
- RefPtr<RegisterID> func = newTemporary();
-
- UnlinkedValueProfile profile = emitProfiledOpcode(op_get_callee);
- instructions().append(func->index());
- instructions().append(profile);
+ emitOpcode(op_assert);
+ instructions().append(condition->index());
+ instructions().append(line);
+ return condition;
+}
+RegisterID* BytecodeGenerator::emitCreateThis(RegisterID* dst)
+{
size_t begin = instructions().size();
- m_staticPropertyAnalyzer.createThis(m_thisRegister.index(), begin + 3);
+ m_staticPropertyAnalyzer.createThis(dst->index(), begin + 3);
+ m_codeBlock->addPropertyAccessInstruction(instructions().size());
emitOpcode(op_create_this);
- instructions().append(m_thisRegister.index());
- instructions().append(func->index());
+ instructions().append(dst->index());
+ instructions().append(dst->index());
+ instructions().append(0);
instructions().append(0);
return dst;
}
+void BytecodeGenerator::emitTDZCheck(RegisterID* target)
+{
+ emitOpcode(op_check_tdz);
+ instructions().append(target->index());
+}
+
+bool BytecodeGenerator::needsTDZCheck(const Variable& variable)
+{
+ for (unsigned i = m_TDZStack.size(); i--;) {
+ VariableEnvironment& identifiers = m_TDZStack[i].first;
+ if (identifiers.contains(variable.ident().impl()))
+ return true;
+ }
+
+ return false;
+}
+
+void BytecodeGenerator::emitTDZCheckIfNecessary(const Variable& variable, RegisterID* target, RegisterID* scope)
+{
+ if (needsTDZCheck(variable)) {
+ if (target)
+ emitTDZCheck(target);
+ else {
+ RELEASE_ASSERT(!variable.isLocal() && scope);
+ RefPtr<RegisterID> result = emitGetFromScope(newTemporary(), scope, variable, DoNotThrowIfNotFound);
+ emitTDZCheck(result.get());
+ }
+ }
+}
+
+void BytecodeGenerator::liftTDZCheckIfPossible(const Variable& variable)
+{
+ RefPtr<UniquedStringImpl> identifier(variable.ident().impl());
+ for (unsigned i = m_TDZStack.size(); i--;) {
+ VariableEnvironment& environment = m_TDZStack[i].first;
+ if (environment.contains(identifier)) {
+ bool isSyntacticallyAbleToOptimizeTDZ = m_TDZStack[i].second;
+ if (isSyntacticallyAbleToOptimizeTDZ) {
+ bool wasRemoved = environment.remove(identifier);
+ RELEASE_ASSERT(wasRemoved);
+ }
+ break;
+ }
+ }
+}
+
+void BytecodeGenerator::getVariablesUnderTDZ(VariableEnvironment& result)
+{
+ for (auto& pair : m_TDZStack) {
+ VariableEnvironment& environment = pair.first;
+ for (auto entry : environment)
+ result.add(entry.key.get());
+ }
+}
+
RegisterID* BytecodeGenerator::emitNewObject(RegisterID* dst)
{
size_t begin = instructions().size();
@@ -1597,7 +2584,7 @@ unsigned BytecodeGenerator::addConstantBuffer(unsigned length)
JSString* BytecodeGenerator::addStringConstant(const Identifier& identifier)
{
- JSString*& stringInMap = m_stringMap.add(identifier.impl(), 0).iterator->value;
+ JSString*& stringInMap = m_stringMap.add(identifier.impl(), nullptr).iterator->value;
if (!stringInMap) {
stringInMap = jsString(vm(), identifier.string());
addConstantValue(stringInMap);
@@ -1605,6 +2592,16 @@ JSString* BytecodeGenerator::addStringConstant(const Identifier& identifier)
return stringInMap;
}
+JSTemplateRegistryKey* BytecodeGenerator::addTemplateRegistryKeyConstant(const TemplateRegistryKey& templateRegistryKey)
+{
+ JSTemplateRegistryKey*& templateRegistryKeyInMap = m_templateRegistryKeyMap.add(templateRegistryKey, nullptr).iterator->value;
+ if (!templateRegistryKeyInMap) {
+ templateRegistryKeyInMap = JSTemplateRegistryKey::create(*vm(), templateRegistryKey);
+ addConstantValue(templateRegistryKeyInMap);
+ }
+ return templateRegistryKeyInMap;
+}
+
RegisterID* BytecodeGenerator::emitNewArray(RegisterID* dst, ElementNode* elements, unsigned length)
{
#if !ASSERT_DISABLED
@@ -1643,13 +2640,16 @@ RegisterID* BytecodeGenerator::emitNewArray(RegisterID* dst, ElementNode* elemen
Vector<RefPtr<RegisterID>, 16, UnsafeVectorOverflow> argv;
for (ElementNode* n = elements; n; n = n->next()) {
- if (n->elision())
+ if (!length)
break;
+ length--;
+ ASSERT(!n->value()->isSpreadExpression());
argv.append(newTemporary());
// op_new_array requires the initial values to be a sequential range of registers
- ASSERT(argv.size() == 1 || argv[argv.size() - 1]->index() == argv[argv.size() - 2]->index() + 1);
+ ASSERT(argv.size() == 1 || argv[argv.size() - 1]->index() == argv[argv.size() - 2]->index() - 1);
emitNode(argv.last().get(), n->value());
}
+ ASSERT(!length);
emitOpcode(op_new_array);
instructions().append(dst->index());
instructions().append(argv.size() ? argv[0]->index() : 0); // argv
@@ -1658,26 +2658,13 @@ RegisterID* BytecodeGenerator::emitNewArray(RegisterID* dst, ElementNode* elemen
return dst;
}
-RegisterID* BytecodeGenerator::emitNewFunction(RegisterID* dst, FunctionBodyNode* function)
+RegisterID* BytecodeGenerator::emitNewArrayWithSize(RegisterID* dst, RegisterID* length)
{
- return emitNewFunctionInternal(dst, m_codeBlock->addFunctionDecl(makeFunction(function)), false);
-}
-
-RegisterID* BytecodeGenerator::emitLazyNewFunction(RegisterID* dst, FunctionBodyNode* function)
-{
- FunctionOffsetMap::AddResult ptr = m_functionOffsets.add(function, 0);
- if (ptr.isNewEntry)
- ptr.iterator->value = m_codeBlock->addFunctionDecl(makeFunction(function));
- return emitNewFunctionInternal(dst, ptr.iterator->value, true);
-}
-
-RegisterID* BytecodeGenerator::emitNewFunctionInternal(RegisterID* dst, unsigned index, bool doNullCheck)
-{
- createActivationIfNecessary();
- emitOpcode(op_new_func);
+ emitOpcode(op_new_array_with_size);
instructions().append(dst->index());
- instructions().append(index);
- instructions().append(doNullCheck);
+ instructions().append(length->index());
+ instructions().append(newArrayAllocationProfile());
+
return dst;
}
@@ -1689,49 +2676,80 @@ RegisterID* BytecodeGenerator::emitNewRegExp(RegisterID* dst, RegExp* regExp)
return dst;
}
-RegisterID* BytecodeGenerator::emitNewFunctionExpression(RegisterID* r0, FuncExprNode* n)
+void BytecodeGenerator::emitNewFunctionExpressionCommon(RegisterID* dst, BaseFuncExprNode* func)
{
- FunctionBodyNode* function = n->body();
+ FunctionMetadataNode* function = func->metadata();
unsigned index = m_codeBlock->addFunctionExpr(makeFunction(function));
+
+ OpcodeID opcodeID = op_new_func_exp;
+ switch (function->parseMode()) {
+ case SourceParseMode::GeneratorWrapperFunctionMode: {
+ opcodeID = op_new_generator_func_exp;
+ break;
+ }
+ case SourceParseMode::ArrowFunctionMode: {
+ opcodeID = op_new_arrow_func_exp;
+ break;
+ }
+ default: {
+ break;
+ }
+ }
- createActivationIfNecessary();
- emitOpcode(op_new_func_exp);
- instructions().append(r0->index());
+ emitOpcode(opcodeID);
+ instructions().append(dst->index());
+ instructions().append(scopeRegister()->index());
instructions().append(index);
- return r0;
}
-RegisterID* BytecodeGenerator::emitCall(RegisterID* dst, RegisterID* func, ExpectedFunction expectedFunction, CallArguments& callArguments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
+RegisterID* BytecodeGenerator::emitNewFunctionExpression(RegisterID* dst, FuncExprNode* func)
{
- return emitCall(op_call, dst, func, expectedFunction, callArguments, divot, divotStart, divotEnd);
+ emitNewFunctionExpressionCommon(dst, func);
+ return dst;
}
-void BytecodeGenerator::createArgumentsIfNecessary()
+RegisterID* BytecodeGenerator::emitNewArrowFunctionExpression(RegisterID* dst, ArrowFuncExprNode* func)
{
- if (m_codeType != FunctionCode)
- return;
-
- if (!m_codeBlock->usesArguments())
- return;
+ ASSERT(func->metadata()->parseMode() == SourceParseMode::ArrowFunctionMode);
+ emitNewFunctionExpressionCommon(dst, func);
+ return dst;
+}
- // If we're in strict mode we tear off the arguments on function
- // entry, so there's no need to check if we need to create them
- // now
- if (m_codeBlock->isStrictMode())
- return;
+RegisterID* BytecodeGenerator::emitNewDefaultConstructor(RegisterID* dst, ConstructorKind constructorKind, const Identifier& name)
+{
+ UnlinkedFunctionExecutable* executable = m_vm->builtinExecutables()->createDefaultConstructor(constructorKind, name);
+ executable->setInvalidTypeProfilingOffsets();
- emitOpcode(op_create_arguments);
- instructions().append(m_codeBlock->argumentsRegister());
+ unsigned index = m_codeBlock->addFunctionExpr(executable);
+
+ emitOpcode(op_new_func_exp);
+ instructions().append(dst->index());
+ instructions().append(scopeRegister()->index());
+ instructions().append(index);
+ return dst;
}
-void BytecodeGenerator::createActivationIfNecessary()
+RegisterID* BytecodeGenerator::emitNewFunction(RegisterID* dst, FunctionMetadataNode* function)
{
- if (m_hasCreatedActivation)
- return;
- if (!m_codeBlock->needsFullScopeChain())
- return;
- emitOpcode(op_create_activation);
- instructions().append(m_activationRegister->index());
+ unsigned index = m_codeBlock->addFunctionDecl(makeFunction(function));
+ if (function->parseMode() == SourceParseMode::GeneratorWrapperFunctionMode)
+ emitOpcode(op_new_generator_func);
+ else
+ emitOpcode(op_new_func);
+ instructions().append(dst->index());
+ instructions().append(scopeRegister()->index());
+ instructions().append(index);
+ return dst;
+}
+
+RegisterID* BytecodeGenerator::emitCall(RegisterID* dst, RegisterID* func, ExpectedFunction expectedFunction, CallArguments& callArguments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
+{
+ return emitCall(op_call, dst, func, expectedFunction, callArguments, divot, divotStart, divotEnd);
+}
+
+RegisterID* BytecodeGenerator::emitCallInTailPosition(RegisterID* dst, RegisterID* func, ExpectedFunction expectedFunction, CallArguments& callArguments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
+{
+ return emitCall(m_inTailPosition ? op_tail_call : op_call, dst, func, expectedFunction, callArguments, divot, divotStart, divotEnd);
}
RegisterID* BytecodeGenerator::emitCallEval(RegisterID* dst, RegisterID* func, CallArguments& callArguments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
@@ -1741,9 +2759,9 @@ RegisterID* BytecodeGenerator::emitCallEval(RegisterID* dst, RegisterID* func, C
ExpectedFunction BytecodeGenerator::expectedFunctionForIdentifier(const Identifier& identifier)
{
- if (identifier == m_vm->propertyNames->Object)
+ if (identifier == m_vm->propertyNames->Object || identifier == m_vm->propertyNames->ObjectPrivateName)
return ExpectObjectConstructor;
- if (identifier == m_vm->propertyNames->Array)
+ if (identifier == m_vm->propertyNames->Array || identifier == m_vm->propertyNames->ArrayPrivateName)
return ExpectArrayConstructor;
return NoExpectedFunction;
}
@@ -1784,12 +2802,9 @@ ExpectedFunction BytecodeGenerator::emitExpectedFunctionSnippet(RegisterID* dst,
instructions().append(realCall->bind(begin, instructions().size()));
if (dst != ignoredResult()) {
- if (callArguments.argumentCountIncludingThis() == 2) {
- emitOpcode(op_new_array_with_size);
- instructions().append(dst->index());
- instructions().append(callArguments.argumentRegister(0)->index());
- instructions().append(newArrayAllocationProfile());
- } else {
+ if (callArguments.argumentCountIncludingThis() == 2)
+ emitNewArrayWithSize(dst, callArguments.argumentRegister(0));
+ else {
ASSERT(callArguments.argumentCountIncludingThis() == 1);
emitOpcode(op_new_array);
instructions().append(dst->index());
@@ -1816,7 +2831,7 @@ ExpectedFunction BytecodeGenerator::emitExpectedFunctionSnippet(RegisterID* dst,
RegisterID* BytecodeGenerator::emitCall(OpcodeID opcodeID, RegisterID* dst, RegisterID* func, ExpectedFunction expectedFunction, CallArguments& callArguments, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
{
- ASSERT(opcodeID == op_call || opcodeID == op_call_eval);
+ ASSERT(opcodeID == op_call || opcodeID == op_call_eval || opcodeID == op_tail_call);
ASSERT(func->refCount());
if (m_shouldEmitProfileHooks)
@@ -1824,9 +2839,20 @@ RegisterID* BytecodeGenerator::emitCall(OpcodeID opcodeID, RegisterID* dst, Regi
// Generate code for arguments.
unsigned argument = 0;
- for (ArgumentListNode* n = callArguments.argumentsNode()->m_listNode; n; n = n->m_next)
- emitNode(callArguments.argumentRegister(argument++), n);
-
+ if (callArguments.argumentsNode()) {
+ ArgumentListNode* n = callArguments.argumentsNode()->m_listNode;
+ if (n && n->m_expr->isSpreadExpression()) {
+ RELEASE_ASSERT(!n->m_next);
+ auto expression = static_cast<SpreadExpressionNode*>(n->m_expr)->expression();
+ RefPtr<RegisterID> argumentRegister;
+ argumentRegister = expression->emitBytecode(*this, callArguments.argumentRegister(0));
+ RefPtr<RegisterID> thisRegister = emitMove(newTemporary(), callArguments.thisRegister());
+ return emitCallVarargs(opcodeID == op_tail_call ? op_tail_call_varargs : op_call_varargs, dst, func, callArguments.thisRegister(), argumentRegister.get(), newTemporary(), 0, callArguments.profileHookRegister(), divot, divotStart, divotEnd);
+ }
+ for (; n; n = n->m_next)
+ emitNode(callArguments.argumentRegister(argument++), n);
+ }
+
// Reserve space for call frame.
Vector<RefPtr<RegisterID>, JSStack::CallFrameHeaderSize, UnsafeVectorOverflow> callFrame;
for (int i = 0; i < JSStack::CallFrameHeaderSize; ++i)
@@ -1844,21 +2870,17 @@ RegisterID* BytecodeGenerator::emitCall(OpcodeID opcodeID, RegisterID* dst, Regi
// Emit call.
UnlinkedArrayProfile arrayProfile = newArrayProfile();
- emitOpcode(opcodeID);
- instructions().append(func->index()); // func
- instructions().append(callArguments.argumentCountIncludingThis()); // argCount
- instructions().append(callArguments.registerOffset()); // registerOffset
-#if ENABLE(LLINT)
+ UnlinkedValueProfile profile = emitProfiledOpcode(opcodeID);
+ ASSERT(dst);
+ ASSERT(dst != ignoredResult());
+ instructions().append(dst->index());
+ instructions().append(func->index());
+ instructions().append(callArguments.argumentCountIncludingThis());
+ instructions().append(callArguments.stackOffset());
instructions().append(m_codeBlock->addLLIntCallLinkInfo());
-#else
instructions().append(0);
-#endif
instructions().append(arrayProfile);
- if (dst != ignoredResult()) {
- UnlinkedValueProfile profile = emitProfiledOpcode(op_call_put_result);
- instructions().append(kill(dst));
- instructions().append(profile);
- }
+ instructions().append(profile);
if (expectedFunction != NoExpectedFunction)
emitLabel(done.get());
@@ -1871,7 +2893,22 @@ RegisterID* BytecodeGenerator::emitCall(OpcodeID opcodeID, RegisterID* dst, Regi
return dst;
}
-RegisterID* BytecodeGenerator::emitCallVarargs(RegisterID* dst, RegisterID* func, RegisterID* thisRegister, RegisterID* arguments, RegisterID* firstFreeRegister, RegisterID* profileHookRegister, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
+RegisterID* BytecodeGenerator::emitCallVarargs(RegisterID* dst, RegisterID* func, RegisterID* thisRegister, RegisterID* arguments, RegisterID* firstFreeRegister, int32_t firstVarArgOffset, RegisterID* profileHookRegister, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
+{
+ return emitCallVarargs(op_call_varargs, dst, func, thisRegister, arguments, firstFreeRegister, firstVarArgOffset, profileHookRegister, divot, divotStart, divotEnd);
+}
+
+RegisterID* BytecodeGenerator::emitCallVarargsInTailPosition(RegisterID* dst, RegisterID* func, RegisterID* thisRegister, RegisterID* arguments, RegisterID* firstFreeRegister, int32_t firstVarArgOffset, RegisterID* profileHookRegister, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
+{
+ return emitCallVarargs(m_inTailPosition ? op_tail_call_varargs : op_call_varargs, dst, func, thisRegister, arguments, firstFreeRegister, firstVarArgOffset, profileHookRegister, divot, divotStart, divotEnd);
+}
+
+RegisterID* BytecodeGenerator::emitConstructVarargs(RegisterID* dst, RegisterID* func, RegisterID* thisRegister, RegisterID* arguments, RegisterID* firstFreeRegister, int32_t firstVarArgOffset, RegisterID* profileHookRegister, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
+{
+ return emitCallVarargs(op_construct_varargs, dst, func, thisRegister, arguments, firstFreeRegister, firstVarArgOffset, profileHookRegister, divot, divotStart, divotEnd);
+}
+
+RegisterID* BytecodeGenerator::emitCallVarargs(OpcodeID opcode, RegisterID* dst, RegisterID* func, RegisterID* thisRegister, RegisterID* arguments, RegisterID* firstFreeRegister, int32_t firstVarArgOffset, RegisterID* profileHookRegister, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd)
{
if (m_shouldEmitProfileHooks) {
emitMove(profileHookRegister, func);
@@ -1882,16 +2919,17 @@ RegisterID* BytecodeGenerator::emitCallVarargs(RegisterID* dst, RegisterID* func
emitExpressionInfo(divot, divotStart, divotEnd);
// Emit call.
- emitOpcode(op_call_varargs);
+ UnlinkedArrayProfile arrayProfile = newArrayProfile();
+ UnlinkedValueProfile profile = emitProfiledOpcode(opcode);
+ ASSERT(dst != ignoredResult());
+ instructions().append(dst->index());
instructions().append(func->index());
- instructions().append(thisRegister->index());
+ instructions().append(thisRegister ? thisRegister->index() : 0);
instructions().append(arguments->index());
instructions().append(firstFreeRegister->index());
- if (dst != ignoredResult()) {
- UnlinkedValueProfile profile = emitProfiledOpcode(op_call_put_result);
- instructions().append(kill(dst));
- instructions().append(profile);
- }
+ instructions().append(firstVarArgOffset);
+ instructions().append(arrayProfile);
+ instructions().append(profile);
if (m_shouldEmitProfileHooks) {
emitOpcode(op_profile_did_call);
instructions().append(profileHookRegister->index());
@@ -1899,28 +2937,65 @@ RegisterID* BytecodeGenerator::emitCallVarargs(RegisterID* dst, RegisterID* func
return dst;
}
-RegisterID* BytecodeGenerator::emitReturn(RegisterID* src)
+void BytecodeGenerator::emitCallDefineProperty(RegisterID* newObj, RegisterID* propertyNameRegister,
+ RegisterID* valueRegister, RegisterID* getterRegister, RegisterID* setterRegister, unsigned options, const JSTextPosition& position)
{
- if (m_codeBlock->needsFullScopeChain()) {
- emitOpcode(op_tear_off_activation);
- instructions().append(m_activationRegister->index());
+ RefPtr<RegisterID> descriptorRegister = emitNewObject(newTemporary());
+
+ RefPtr<RegisterID> trueRegister = emitLoad(newTemporary(), true);
+ if (options & PropertyConfigurable)
+ emitDirectPutById(descriptorRegister.get(), propertyNames().configurable, trueRegister.get(), PropertyNode::Unknown);
+ if (options & PropertyWritable)
+ emitDirectPutById(descriptorRegister.get(), propertyNames().writable, trueRegister.get(), PropertyNode::Unknown);
+ else if (valueRegister) {
+ RefPtr<RegisterID> falseRegister = emitLoad(newTemporary(), false);
+ emitDirectPutById(descriptorRegister.get(), propertyNames().writable, falseRegister.get(), PropertyNode::Unknown);
}
+ if (options & PropertyEnumerable)
+ emitDirectPutById(descriptorRegister.get(), propertyNames().enumerable, trueRegister.get(), PropertyNode::Unknown);
- if (m_codeBlock->usesArguments() && m_codeBlock->numParameters() != 1 && !m_codeBlock->isStrictMode()) {
- emitOpcode(op_tear_off_arguments);
- instructions().append(m_codeBlock->argumentsRegister());
- instructions().append(m_activationRegister ? m_activationRegister->index() : emitLoad(0, JSValue())->index());
- }
+ if (valueRegister)
+ emitDirectPutById(descriptorRegister.get(), propertyNames().value, valueRegister, PropertyNode::Unknown);
+ if (getterRegister)
+ emitDirectPutById(descriptorRegister.get(), propertyNames().get, getterRegister, PropertyNode::Unknown);
+ if (setterRegister)
+ emitDirectPutById(descriptorRegister.get(), propertyNames().set, setterRegister, PropertyNode::Unknown);
+
+ RefPtr<RegisterID> definePropertyRegister = emitMoveLinkTimeConstant(newTemporary(), LinkTimeConstant::DefinePropertyFunction);
+
+ CallArguments callArguments(*this, nullptr, 3);
+ emitLoad(callArguments.thisRegister(), jsUndefined());
+ emitMove(callArguments.argumentRegister(0), newObj);
+ emitMove(callArguments.argumentRegister(1), propertyNameRegister);
+ emitMove(callArguments.argumentRegister(2), descriptorRegister.get());
+
+ emitCall(newTemporary(), definePropertyRegister.get(), NoExpectedFunction, callArguments, position, position, position);
+}
+
+RegisterID* BytecodeGenerator::emitReturn(RegisterID* src)
+{
+ if (isConstructor()) {
+ bool derived = constructorKind() == ConstructorKind::Derived;
+ if (derived && src->index() == m_thisRegister.index())
+ emitTDZCheck(src);
+
+ RefPtr<Label> isObjectLabel = newLabel();
+ emitJumpIfTrue(emitIsObject(newTemporary(), src), isObjectLabel.get());
+
+ if (derived) {
+ RefPtr<Label> isUndefinedLabel = newLabel();
+ emitJumpIfTrue(emitIsUndefined(newTemporary(), src), isUndefinedLabel.get());
+ emitThrowTypeError("Cannot return a non-object type in the constructor of a derived class.");
+ emitLabel(isUndefinedLabel.get());
+ if (constructorKind() == ConstructorKind::Derived)
+ emitTDZCheck(&m_thisRegister);
+ }
+
+ emitUnaryNoDstOp(op_ret, &m_thisRegister);
- // Constructors use op_ret_object_or_this to check the result is an
- // object, unless we can trivially determine the check is not
- // necessary (currently, if the return value is 'this').
- if (isConstructor() && (src->index() != m_thisRegister.index())) {
- emitOpcode(op_ret_object_or_this);
- instructions().append(src->index());
- instructions().append(m_thisRegister.index());
- return src;
+ emitLabel(isObjectLabel.get());
}
+
return emitUnaryNoDstOp(op_ret, src);
}
@@ -1941,6 +3016,16 @@ RegisterID* BytecodeGenerator::emitConstruct(RegisterID* dst, RegisterID* func,
// Generate code for arguments.
unsigned argument = 0;
if (ArgumentsNode* argumentsNode = callArguments.argumentsNode()) {
+
+ ArgumentListNode* n = callArguments.argumentsNode()->m_listNode;
+ if (n && n->m_expr->isSpreadExpression()) {
+ RELEASE_ASSERT(!n->m_next);
+ auto expression = static_cast<SpreadExpressionNode*>(n->m_expr)->expression();
+ RefPtr<RegisterID> argumentRegister;
+ argumentRegister = expression->emitBytecode(*this, callArguments.argumentRegister(0));
+ return emitConstructVarargs(dst, func, callArguments.thisRegister(), argumentRegister.get(), newTemporary(), 0, callArguments.profileHookRegister(), divot, divotStart, divotEnd);
+ }
+
for (ArgumentListNode* n = argumentsNode->m_listNode; n; n = n->m_next)
emitNode(callArguments.argumentRegister(argument++), n);
}
@@ -1960,21 +3045,16 @@ RegisterID* BytecodeGenerator::emitConstruct(RegisterID* dst, RegisterID* func,
RefPtr<Label> done = newLabel();
expectedFunction = emitExpectedFunctionSnippet(dst, func, expectedFunction, callArguments, done.get());
- emitOpcode(op_construct);
- instructions().append(func->index()); // func
- instructions().append(callArguments.argumentCountIncludingThis()); // argCount
- instructions().append(callArguments.registerOffset()); // registerOffset
-#if ENABLE(LLINT)
+ UnlinkedValueProfile profile = emitProfiledOpcode(op_construct);
+ ASSERT(dst != ignoredResult());
+ instructions().append(dst->index());
+ instructions().append(func->index());
+ instructions().append(callArguments.argumentCountIncludingThis());
+ instructions().append(callArguments.stackOffset());
instructions().append(m_codeBlock->addLLIntCallLinkInfo());
-#else
instructions().append(0);
-#endif
instructions().append(0);
- if (dst != ignoredResult()) {
- UnlinkedValueProfile profile = emitProfiledOpcode(op_call_put_result);
- instructions().append(kill(dst));
- instructions().append(profile);
- }
+ instructions().append(profile);
if (expectedFunction != NoExpectedFunction)
emitLabel(done.get());
@@ -2004,28 +3084,53 @@ void BytecodeGenerator::emitToPrimitive(RegisterID* dst, RegisterID* src)
instructions().append(src->index());
}
-RegisterID* BytecodeGenerator::emitPushWithScope(RegisterID* scope)
+void BytecodeGenerator::emitGetScope()
{
- ControlFlowContext context;
- context.isFinallyBlock = false;
- m_scopeContextStack.append(context);
- m_dynamicScopeDepth++;
+ emitOpcode(op_get_scope);
+ instructions().append(scopeRegister()->index());
+}
- return emitUnaryNoDstOp(op_push_with_scope, scope);
+RegisterID* BytecodeGenerator::emitPushWithScope(RegisterID* objectScope)
+{
+ pushScopedControlFlowContext();
+ RegisterID* newScope = newBlockScopeVariable();
+ newScope->ref();
+
+ emitOpcode(op_push_with_scope);
+ instructions().append(newScope->index());
+ instructions().append(objectScope->index());
+ instructions().append(scopeRegister()->index());
+
+ emitMove(scopeRegister(), newScope);
+ m_symbolTableStack.append(SymbolTableStackEntry{ Strong<SymbolTable>(), newScope, true, 0 });
+
+ return newScope;
}
-void BytecodeGenerator::emitPopScope()
+RegisterID* BytecodeGenerator::emitGetParentScope(RegisterID* dst, RegisterID* scope)
{
- ASSERT(m_scopeContextStack.size());
- ASSERT(!m_scopeContextStack.last().isFinallyBlock);
+ emitOpcode(op_get_parent_scope);
+ instructions().append(dst->index());
+ instructions().append(scope->index());
+ return dst;
+}
- emitOpcode(op_pop_scope);
+void BytecodeGenerator::emitPopScope(RegisterID* dst, RegisterID* scope)
+{
+ RefPtr<RegisterID> parentScope = emitGetParentScope(newTemporary(), scope);
+ emitMove(dst, parentScope.get());
+}
- m_scopeContextStack.removeLast();
- m_dynamicScopeDepth--;
+void BytecodeGenerator::emitPopWithScope()
+{
+ emitPopScope(scopeRegister(), scopeRegister());
+ popScopedControlFlowContext();
+ SymbolTableStackEntry stackEntry = m_symbolTableStack.takeLast();
+ stackEntry.m_scope->deref();
+ RELEASE_ASSERT(stackEntry.m_isWithScope);
}
-void BytecodeGenerator::emitDebugHook(DebugHookID debugHookID, unsigned firstLine, unsigned lastLine, unsigned charOffset, unsigned lineStart)
+void BytecodeGenerator::emitDebugHook(DebugHookID debugHookID, unsigned line, unsigned charOffset, unsigned lineStart)
{
#if ENABLE(DEBUG_WITH_BREAKPOINT)
if (debugHookID != DidReachBreakpoint)
@@ -2034,29 +3139,59 @@ void BytecodeGenerator::emitDebugHook(DebugHookID debugHookID, unsigned firstLin
if (!m_shouldEmitDebugHooks)
return;
#endif
- JSTextPosition divot(firstLine, charOffset, lineStart);
+ JSTextPosition divot(line, charOffset, lineStart);
emitExpressionInfo(divot, divot, divot);
- unsigned charPosition = charOffset - m_scopeNode->source().startOffset();
emitOpcode(op_debug);
instructions().append(debugHookID);
- instructions().append(firstLine);
- instructions().append(lastLine);
- instructions().append(charPosition);
+ instructions().append(false);
}
void BytecodeGenerator::pushFinallyContext(StatementNode* finallyBlock)
{
+ // Reclaim free label scopes.
+ while (m_labelScopes.size() && !m_labelScopes.last().refCount())
+ m_labelScopes.removeLast();
+
ControlFlowContext scope;
scope.isFinallyBlock = true;
FinallyContext context = {
finallyBlock,
+ nullptr,
+ nullptr,
+ static_cast<unsigned>(m_scopeContextStack.size()),
+ static_cast<unsigned>(m_switchContextStack.size()),
+ static_cast<unsigned>(m_forInContextStack.size()),
+ static_cast<unsigned>(m_tryContextStack.size()),
+ static_cast<unsigned>(m_labelScopes.size()),
+ static_cast<unsigned>(m_symbolTableStack.size()),
+ m_finallyDepth,
+ m_localScopeDepth
+ };
+ scope.finallyContext = context;
+ m_scopeContextStack.append(scope);
+ m_finallyDepth++;
+}
+
+void BytecodeGenerator::pushIteratorCloseContext(RegisterID* iterator, ThrowableExpressionData* node)
+{
+ // Reclaim free label scopes.
+ while (m_labelScopes.size() && !m_labelScopes.last().refCount())
+ m_labelScopes.removeLast();
+
+ ControlFlowContext scope;
+ scope.isFinallyBlock = true;
+ FinallyContext context = {
+ nullptr,
+ iterator,
+ node,
static_cast<unsigned>(m_scopeContextStack.size()),
static_cast<unsigned>(m_switchContextStack.size()),
static_cast<unsigned>(m_forInContextStack.size()),
static_cast<unsigned>(m_tryContextStack.size()),
static_cast<unsigned>(m_labelScopes.size()),
+ static_cast<unsigned>(m_symbolTableStack.size()),
m_finallyDepth,
- m_dynamicScopeDepth
+ m_localScopeDepth
};
scope.finallyContext = context;
m_scopeContextStack.append(scope);
@@ -2067,12 +3202,27 @@ void BytecodeGenerator::popFinallyContext()
{
ASSERT(m_scopeContextStack.size());
ASSERT(m_scopeContextStack.last().isFinallyBlock);
+ ASSERT(m_scopeContextStack.last().finallyContext.finallyBlock);
+ ASSERT(!m_scopeContextStack.last().finallyContext.iterator);
+ ASSERT(!m_scopeContextStack.last().finallyContext.enumerationNode);
ASSERT(m_finallyDepth > 0);
m_scopeContextStack.removeLast();
m_finallyDepth--;
}
-LabelScope* BytecodeGenerator::breakTarget(const Identifier& name)
+void BytecodeGenerator::popIteratorCloseContext()
+{
+ ASSERT(m_scopeContextStack.size());
+ ASSERT(m_scopeContextStack.last().isFinallyBlock);
+ ASSERT(!m_scopeContextStack.last().finallyContext.finallyBlock);
+ ASSERT(m_scopeContextStack.last().finallyContext.iterator);
+ ASSERT(m_scopeContextStack.last().finallyContext.enumerationNode);
+ ASSERT(m_finallyDepth > 0);
+ m_scopeContextStack.removeLast();
+ m_finallyDepth--;
+}
+
+LabelScopePtr BytecodeGenerator::breakTarget(const Identifier& name)
{
// Reclaim free label scopes.
//
@@ -2088,7 +3238,7 @@ LabelScope* BytecodeGenerator::breakTarget(const Identifier& name)
}
if (!m_labelScopes.size())
- return 0;
+ return LabelScopePtr::null();
// We special-case the following, which is a syntax error in Firefox:
// label:
@@ -2098,58 +3248,79 @@ LabelScope* BytecodeGenerator::breakTarget(const Identifier& name)
LabelScope* scope = &m_labelScopes[i];
if (scope->type() != LabelScope::NamedLabel) {
ASSERT(scope->breakTarget());
- return scope;
+ return LabelScopePtr(m_labelScopes, i);
}
}
- return 0;
+ return LabelScopePtr::null();
}
for (int i = m_labelScopes.size() - 1; i >= 0; --i) {
LabelScope* scope = &m_labelScopes[i];
if (scope->name() && *scope->name() == name) {
ASSERT(scope->breakTarget());
- return scope;
+ return LabelScopePtr(m_labelScopes, i);
}
}
- return 0;
+ return LabelScopePtr::null();
}
-LabelScope* BytecodeGenerator::continueTarget(const Identifier& name)
+LabelScopePtr BytecodeGenerator::continueTarget(const Identifier& name)
{
// Reclaim free label scopes.
while (m_labelScopes.size() && !m_labelScopes.last().refCount())
m_labelScopes.removeLast();
if (!m_labelScopes.size())
- return 0;
+ return LabelScopePtr::null();
if (name.isEmpty()) {
for (int i = m_labelScopes.size() - 1; i >= 0; --i) {
LabelScope* scope = &m_labelScopes[i];
if (scope->type() == LabelScope::Loop) {
ASSERT(scope->continueTarget());
- return scope;
+ return LabelScopePtr(m_labelScopes, i);
}
}
- return 0;
+ return LabelScopePtr::null();
}
// Continue to the loop nested nearest to the label scope that matches
// 'name'.
- LabelScope* result = 0;
+ LabelScopePtr result = LabelScopePtr::null();
for (int i = m_labelScopes.size() - 1; i >= 0; --i) {
LabelScope* scope = &m_labelScopes[i];
if (scope->type() == LabelScope::Loop) {
ASSERT(scope->continueTarget());
- result = scope;
+ result = LabelScopePtr(m_labelScopes, i);
}
if (scope->name() && *scope->name() == name)
- return result; // may be 0
+ return result; // may be null.
}
- return 0;
+ return LabelScopePtr::null();
}
-void BytecodeGenerator::emitComplexPopScopes(ControlFlowContext* topScope, ControlFlowContext* bottomScope)
+void BytecodeGenerator::allocateCalleeSaveSpace()
+{
+ size_t virtualRegisterCountForCalleeSaves = CodeBlock::llintBaselineCalleeSaveSpaceAsVirtualRegisters();
+
+ for (size_t i = 0; i < virtualRegisterCountForCalleeSaves; i++) {
+ RegisterID* localRegister = addVar();
+ localRegister->ref();
+ m_localRegistersForCalleeSaveRegisters.append(localRegister);
+ }
+}
+
+void BytecodeGenerator::allocateAndEmitScope()
+{
+ m_scopeRegister = addVar();
+ m_scopeRegister->ref();
+ m_codeBlock->setScopeRegister(scopeRegister()->virtualRegister());
+ emitGetScope();
+ m_topMostScope = addVar();
+ emitMove(m_topMostScope, scopeRegister());
+}
+
+void BytecodeGenerator::emitComplexPopScopes(RegisterID* scope, ControlFlowContext* topScope, ControlFlowContext* bottomScope)
{
while (topScope > bottomScope) {
// First we count the number of dynamic scopes we need to remove to get
@@ -2165,8 +3336,11 @@ void BytecodeGenerator::emitComplexPopScopes(ControlFlowContext* topScope, Contr
if (nNormalScopes) {
// We need to remove a number of dynamic scopes to get to the next
// finally block
- while (nNormalScopes--)
- emitOpcode(op_pop_scope);
+ RefPtr<RegisterID> parentScope = newTemporary();
+ while (nNormalScopes--) {
+ parentScope = emitGetParentScope(parentScope.get(), scope);
+ emitMove(scope, parentScope.get());
+ }
// If topScope == bottomScope then there isn't a finally block left to emit.
if (topScope == bottomScope)
@@ -2175,8 +3349,9 @@ void BytecodeGenerator::emitComplexPopScopes(ControlFlowContext* topScope, Contr
Vector<ControlFlowContext> savedScopeContextStack;
Vector<SwitchInfo> savedSwitchContextStack;
- Vector<ForInContext> savedForInContextStack;
+ Vector<std::unique_ptr<ForInContext>> savedForInContextStack;
Vector<TryContext> poppedTryContexts;
+ Vector<SymbolTableStackEntry> savedSymbolTableStack;
LabelScopeStore savedLabelScopes;
while (topScope > bottomScope && topScope->isFinallyBlock) {
RefPtr<Label> beforeFinally = emitLabel(newLabel().get());
@@ -2189,6 +3364,7 @@ void BytecodeGenerator::emitComplexPopScopes(ControlFlowContext* topScope, Contr
bool flipForIns = finallyContext.forInContextStackSize != m_forInContextStack.size();
bool flipTries = finallyContext.tryContextStackSize != m_tryContextStack.size();
bool flipLabelScopes = finallyContext.labelScopesSize != m_labelScopes.size();
+ bool flipSymbolTableStack = finallyContext.symbolTableStackSize != m_symbolTableStack.size();
int topScopeIndex = -1;
int bottomScopeIndex = -1;
if (flipScopes) {
@@ -2202,7 +3378,7 @@ void BytecodeGenerator::emitComplexPopScopes(ControlFlowContext* topScope, Contr
m_switchContextStack.shrink(finallyContext.switchContextStackSize);
}
if (flipForIns) {
- savedForInContextStack = m_forInContextStack;
+ savedForInContextStack.swap(m_forInContextStack);
m_forInContextStack.shrink(finallyContext.forInContextStackSize);
}
if (flipTries) {
@@ -2223,14 +3399,24 @@ void BytecodeGenerator::emitComplexPopScopes(ControlFlowContext* topScope, Contr
while (m_labelScopes.size() > finallyContext.labelScopesSize)
m_labelScopes.removeLast();
}
+ if (flipSymbolTableStack) {
+ savedSymbolTableStack = m_symbolTableStack;
+ m_symbolTableStack.shrink(finallyContext.symbolTableStackSize);
+ }
int savedFinallyDepth = m_finallyDepth;
m_finallyDepth = finallyContext.finallyDepth;
- int savedDynamicScopeDepth = m_dynamicScopeDepth;
- m_dynamicScopeDepth = finallyContext.dynamicScopeDepth;
-
- // Emit the finally block.
- emitNode(finallyContext.finallyBlock);
+ int savedDynamicScopeDepth = m_localScopeDepth;
+ m_localScopeDepth = finallyContext.dynamicScopeDepth;
+ if (finallyContext.finallyBlock) {
+ // Emit the finally block.
+ emitNode(finallyContext.finallyBlock);
+ } else {
+ // Emit the IteratorClose block.
+ ASSERT(finallyContext.iterator);
+ emitIteratorClose(finallyContext.iterator, finallyContext.enumerationNode);
+ }
+
RefPtr<Label> afterFinally = emitLabel(newLabel().get());
// Restore the state of the world.
@@ -2242,7 +3428,7 @@ void BytecodeGenerator::emitComplexPopScopes(ControlFlowContext* topScope, Contr
if (flipSwitches)
m_switchContextStack = savedSwitchContextStack;
if (flipForIns)
- m_forInContextStack = savedForInContextStack;
+ m_forInContextStack.swap(savedForInContextStack);
if (flipTries) {
ASSERT(m_tryContextStack.size() == finallyContext.tryContextStackSize);
for (unsigned i = poppedTryContexts.size(); i--;) {
@@ -2254,64 +3440,42 @@ void BytecodeGenerator::emitComplexPopScopes(ControlFlowContext* topScope, Contr
}
if (flipLabelScopes)
m_labelScopes = savedLabelScopes;
+ if (flipSymbolTableStack)
+ m_symbolTableStack = savedSymbolTableStack;
m_finallyDepth = savedFinallyDepth;
- m_dynamicScopeDepth = savedDynamicScopeDepth;
+ m_localScopeDepth = savedDynamicScopeDepth;
--topScope;
}
}
}
-void BytecodeGenerator::emitPopScopes(int targetScopeDepth)
+void BytecodeGenerator::emitPopScopes(RegisterID* scope, int targetScopeDepth)
{
- ASSERT(scopeDepth() - targetScopeDepth >= 0);
+ ASSERT(labelScopeDepth() - targetScopeDepth >= 0);
- size_t scopeDelta = scopeDepth() - targetScopeDepth;
+ size_t scopeDelta = labelScopeDepth() - targetScopeDepth;
ASSERT(scopeDelta <= m_scopeContextStack.size());
if (!scopeDelta)
return;
if (!m_finallyDepth) {
- while (scopeDelta--)
- emitOpcode(op_pop_scope);
+ RefPtr<RegisterID> parentScope = newTemporary();
+ while (scopeDelta--) {
+ parentScope = emitGetParentScope(parentScope.get(), scope);
+ emitMove(scope, parentScope.get());
+ }
return;
}
- emitComplexPopScopes(&m_scopeContextStack.last(), &m_scopeContextStack.last() - scopeDelta);
-}
-
-RegisterID* BytecodeGenerator::emitGetPropertyNames(RegisterID* dst, RegisterID* base, RegisterID* i, RegisterID* size, Label* breakTarget)
-{
- size_t begin = instructions().size();
-
- emitOpcode(op_get_pnames);
- instructions().append(dst->index());
- instructions().append(base->index());
- instructions().append(i->index());
- instructions().append(size->index());
- instructions().append(breakTarget->bind(begin, instructions().size()));
- return dst;
-}
-
-RegisterID* BytecodeGenerator::emitNextPropertyName(RegisterID* dst, RegisterID* base, RegisterID* i, RegisterID* size, RegisterID* iter, Label* target)
-{
- size_t begin = instructions().size();
-
- emitOpcode(op_next_pname);
- instructions().append(dst->index());
- instructions().append(base->index());
- instructions().append(i->index());
- instructions().append(size->index());
- instructions().append(iter->index());
- instructions().append(target->bind(begin, instructions().size()));
- return dst;
+ emitComplexPopScopes(scope, &m_scopeContextStack.last(), &m_scopeContextStack.last() - scopeDelta);
}
TryData* BytecodeGenerator::pushTry(Label* start)
{
TryData tryData;
tryData.target = newLabel();
- tryData.targetScopeDepth = UINT_MAX;
+ tryData.handlerType = HandlerType::Illegal;
m_tryData.append(tryData);
TryData* result = &m_tryData.last();
@@ -2324,7 +3488,7 @@ TryData* BytecodeGenerator::pushTry(Label* start)
return result;
}
-RegisterID* BytecodeGenerator::popTryAndEmitCatch(TryData* tryData, RegisterID* targetRegister, Label* end)
+void BytecodeGenerator::popTryAndEmitCatch(TryData* tryData, RegisterID* exceptionRegister, RegisterID* thrownValueRegister, Label* end, HandlerType handlerType)
{
m_usesExceptions = true;
@@ -2338,31 +3502,98 @@ RegisterID* BytecodeGenerator::popTryAndEmitCatch(TryData* tryData, RegisterID*
m_tryContextStack.removeLast();
emitLabel(tryRange.tryData->target.get());
- tryRange.tryData->targetScopeDepth = m_dynamicScopeDepth;
+ tryRange.tryData->handlerType = handlerType;
emitOpcode(op_catch);
- instructions().append(targetRegister->index());
- return targetRegister;
+ instructions().append(exceptionRegister->index());
+ instructions().append(thrownValueRegister->index());
+
+ bool foundLocalScope = false;
+ for (unsigned i = m_symbolTableStack.size(); i--; ) {
+ // Note that if we don't find a local scope in the current function/program,
+ // we must grab the outer-most scope of this bytecode generation.
+ if (m_symbolTableStack[i].m_scope) {
+ foundLocalScope = true;
+ emitMove(scopeRegister(), m_symbolTableStack[i].m_scope);
+ break;
+ }
+ }
+ if (!foundLocalScope)
+ emitMove(scopeRegister(), m_topMostScope);
+}
+
+int BytecodeGenerator::localScopeDepth() const
+{
+ return m_localScopeDepth;
+}
+
+int BytecodeGenerator::labelScopeDepth() const
+{
+ return localScopeDepth() + m_finallyDepth;
}
void BytecodeGenerator::emitThrowReferenceError(const String& message)
{
emitOpcode(op_throw_static_error);
- instructions().append(addConstantValue(addStringConstant(Identifier(m_vm, message)))->index());
+ instructions().append(addConstantValue(addStringConstant(Identifier::fromString(m_vm, message)))->index());
instructions().append(true);
}
-void BytecodeGenerator::emitPushNameScope(const Identifier& property, RegisterID* value, unsigned attributes)
+void BytecodeGenerator::emitThrowTypeError(const String& message)
+{
+ emitOpcode(op_throw_static_error);
+ instructions().append(addConstantValue(addStringConstant(Identifier::fromString(m_vm, message)))->index());
+ instructions().append(false);
+}
+
+void BytecodeGenerator::emitPushFunctionNameScope(const Identifier& property, RegisterID* callee, bool isCaptured)
+{
+ // There is some nuance here:
+ // If we're in strict mode code, the function name scope variable acts exactly like a "const" variable.
+ // If we're not in strict mode code, we want to allow bogus assignments to the name scoped variable.
+ // This means any assignment to the variable won't throw, but it won't actually assign a new value to it.
+ // To accomplish this, we don't report that this scope is a lexical scope. This will prevent
+ // any throws when trying to assign to the variable (while still ensuring it keeps its original
+ // value). There is some ugliness and exploitation of a leaky abstraction here, but it's better than
+ // having a completely new op code and a class to handle name scopes which are so close in functionality
+ // to lexical environments.
+ VariableEnvironment nameScopeEnvironment;
+ auto addResult = nameScopeEnvironment.add(property);
+ if (isCaptured)
+ addResult.iterator->value.setIsCaptured();
+ addResult.iterator->value.setIsConst(); // The function name scope name acts like a const variable.
+ unsigned numVars = m_codeBlock->m_numVars;
+ pushLexicalScopeInternal(nameScopeEnvironment, TDZCheckOptimization::Optimize, NestedScopeType::IsNotNested, nullptr, TDZRequirement::NotUnderTDZ, ScopeType::FunctionNameScope, ScopeRegisterType::Var);
+ ASSERT_UNUSED(numVars, m_codeBlock->m_numVars == static_cast<int>(numVars + 1)); // Should have only created one new "var" for the function name scope.
+ bool shouldTreatAsLexicalVariable = isStrictMode();
+ Variable functionVar = variableForLocalEntry(property, m_symbolTableStack.last().m_symbolTable->get(property.impl()), m_symbolTableStack.last().m_symbolTableConstantIndex, shouldTreatAsLexicalVariable);
+ emitPutToScope(m_symbolTableStack.last().m_scope, functionVar, callee, ThrowIfNotFound, NotInitialization);
+}
+
+void BytecodeGenerator::pushScopedControlFlowContext()
{
ControlFlowContext context;
context.isFinallyBlock = false;
m_scopeContextStack.append(context);
- m_dynamicScopeDepth++;
+ m_localScopeDepth++;
+}
- emitOpcode(op_push_name_scope);
- instructions().append(addConstant(property));
- instructions().append(value->index());
- instructions().append(attributes);
+void BytecodeGenerator::popScopedControlFlowContext()
+{
+ ASSERT(m_scopeContextStack.size());
+ ASSERT(!m_scopeContextStack.last().isFinallyBlock);
+ m_scopeContextStack.removeLast();
+ m_localScopeDepth--;
+}
+
+void BytecodeGenerator::emitPushCatchScope(VariableEnvironment& environment)
+{
+ pushLexicalScopeInternal(environment, TDZCheckOptimization::Optimize, NestedScopeType::IsNotNested, nullptr, TDZRequirement::NotUnderTDZ, ScopeType::CatchScope, ScopeRegisterType::Block);
+}
+
+void BytecodeGenerator::emitPopCatchScope(VariableEnvironment& environment)
+{
+ popLexicalScopeInternal(environment, TDZRequirement::NotUnderTDZ);
}
void BytecodeGenerator::beginSwitch(RegisterID* scrutineeRegister, SwitchInfo::SwitchType type)
@@ -2400,19 +3631,6 @@ static int32_t keyForImmediateSwitch(ExpressionNode* node, int32_t min, int32_t
return key - min;
}
-static void prepareJumpTableForImmediateSwitch(UnlinkedSimpleJumpTable& jumpTable, int32_t switchAddress, uint32_t clauseCount, RefPtr<Label>* labels, ExpressionNode** nodes, int32_t min, int32_t max)
-{
- jumpTable.min = min;
- jumpTable.branchOffsets.resize(max - min + 1);
- jumpTable.branchOffsets.fill(0);
- for (uint32_t i = 0; i < clauseCount; ++i) {
- // We're emitting this after the clause labels should have been fixed, so
- // the labels should not be "forward" references
- ASSERT(!labels[i]->isForward());
- jumpTable.add(keyForImmediateSwitch(nodes[i], min, max), labels[i]->bind(switchAddress, switchAddress + 3));
- }
-}
-
static int32_t keyForCharacterSwitch(ExpressionNode* node, int32_t min, int32_t max)
{
UNUSED_PARAM(max);
@@ -2426,7 +3644,10 @@ static int32_t keyForCharacterSwitch(ExpressionNode* node, int32_t min, int32_t
return key - min;
}
-static void prepareJumpTableForCharacterSwitch(UnlinkedSimpleJumpTable& jumpTable, int32_t switchAddress, uint32_t clauseCount, RefPtr<Label>* labels, ExpressionNode** nodes, int32_t min, int32_t max)
+static void prepareJumpTableForSwitch(
+ UnlinkedSimpleJumpTable& jumpTable, int32_t switchAddress, uint32_t clauseCount,
+ RefPtr<Label>* labels, ExpressionNode** nodes, int32_t min, int32_t max,
+ int32_t (*keyGetter)(ExpressionNode*, int32_t min, int32_t max))
{
jumpTable.min = min;
jumpTable.branchOffsets.resize(max - min + 1);
@@ -2435,7 +3656,7 @@ static void prepareJumpTableForCharacterSwitch(UnlinkedSimpleJumpTable& jumpTabl
// We're emitting this after the clause labels should have been fixed, so
// the labels should not be "forward" references
ASSERT(!labels[i]->isForward());
- jumpTable.add(keyForCharacterSwitch(nodes[i], min, max), labels[i]->bind(switchAddress, switchAddress + 3));
+ jumpTable.add(keyGetter(nodes[i], min, max), labels[i]->bind(switchAddress, switchAddress + 3));
}
}
@@ -2456,25 +3677,34 @@ void BytecodeGenerator::endSwitch(uint32_t clauseCount, RefPtr<Label>* labels, E
{
SwitchInfo switchInfo = m_switchContextStack.last();
m_switchContextStack.removeLast();
- if (switchInfo.switchType == SwitchInfo::SwitchImmediate) {
- instructions()[switchInfo.bytecodeOffset + 1] = m_codeBlock->numberOfImmediateSwitchJumpTables();
+
+ switch (switchInfo.switchType) {
+ case SwitchInfo::SwitchImmediate:
+ case SwitchInfo::SwitchCharacter: {
+ instructions()[switchInfo.bytecodeOffset + 1] = m_codeBlock->numberOfSwitchJumpTables();
instructions()[switchInfo.bytecodeOffset + 2] = defaultLabel->bind(switchInfo.bytecodeOffset, switchInfo.bytecodeOffset + 3);
- UnlinkedSimpleJumpTable& jumpTable = m_codeBlock->addImmediateSwitchJumpTable();
- prepareJumpTableForImmediateSwitch(jumpTable, switchInfo.bytecodeOffset, clauseCount, labels, nodes, min, max);
- } else if (switchInfo.switchType == SwitchInfo::SwitchCharacter) {
- instructions()[switchInfo.bytecodeOffset + 1] = m_codeBlock->numberOfCharacterSwitchJumpTables();
- instructions()[switchInfo.bytecodeOffset + 2] = defaultLabel->bind(switchInfo.bytecodeOffset, switchInfo.bytecodeOffset + 3);
+ UnlinkedSimpleJumpTable& jumpTable = m_codeBlock->addSwitchJumpTable();
+ prepareJumpTableForSwitch(
+ jumpTable, switchInfo.bytecodeOffset, clauseCount, labels, nodes, min, max,
+ switchInfo.switchType == SwitchInfo::SwitchImmediate
+ ? keyForImmediateSwitch
+ : keyForCharacterSwitch);
+ break;
+ }
- UnlinkedSimpleJumpTable& jumpTable = m_codeBlock->addCharacterSwitchJumpTable();
- prepareJumpTableForCharacterSwitch(jumpTable, switchInfo.bytecodeOffset, clauseCount, labels, nodes, min, max);
- } else {
- ASSERT(switchInfo.switchType == SwitchInfo::SwitchString);
+ case SwitchInfo::SwitchString: {
instructions()[switchInfo.bytecodeOffset + 1] = m_codeBlock->numberOfStringSwitchJumpTables();
instructions()[switchInfo.bytecodeOffset + 2] = defaultLabel->bind(switchInfo.bytecodeOffset, switchInfo.bytecodeOffset + 3);
UnlinkedStringJumpTable& jumpTable = m_codeBlock->addStringSwitchJumpTable();
prepareJumpTableForStringSwitch(jumpTable, switchInfo.bytecodeOffset, clauseCount, labels, nodes);
+ break;
+ }
+
+ default:
+ RELEASE_ASSERT_NOT_REACHED();
+ break;
}
}
@@ -2488,26 +3718,632 @@ RegisterID* BytecodeGenerator::emitThrowExpressionTooDeepException()
return newTemporary();
}
-void BytecodeGenerator::setIsNumericCompareFunction(bool isNumericCompareFunction)
+bool BytecodeGenerator::isArgumentNumber(const Identifier& ident, int argumentNumber)
{
- m_codeBlock->setIsNumericCompareFunction(isNumericCompareFunction);
+ RegisterID* registerID = variable(ident).local();
+ if (!registerID)
+ return false;
+ return registerID->index() == CallFrame::argumentOffset(argumentNumber);
}
-bool BytecodeGenerator::isArgumentNumber(const Identifier& ident, int argumentNumber)
+bool BytecodeGenerator::emitReadOnlyExceptionIfNeeded(const Variable& variable)
{
- RegisterID* registerID = resolve(ident).local();
- if (!registerID || registerID->index() >= 0)
- return 0;
- return registerID->index() == CallFrame::argumentOffset(argumentNumber);
+ // If we're in strict mode, we always throw.
+ // If we're not in strict mode, we throw for "const" variables but not the function callee.
+ if (isStrictMode() || variable.isConst()) {
+ emitOpcode(op_throw_static_error);
+ instructions().append(addConstantValue(addStringConstant(Identifier::fromString(m_vm, StrictModeReadonlyPropertyWriteError)))->index());
+ instructions().append(false);
+ return true;
+ }
+ return false;
+}
+
+void BytecodeGenerator::emitEnumeration(ThrowableExpressionData* node, ExpressionNode* subjectNode, const std::function<void(BytecodeGenerator&, RegisterID*)>& callBack, VariableEnvironmentNode* forLoopNode, RegisterID* forLoopSymbolTable)
+{
+ RefPtr<RegisterID> subject = newTemporary();
+ emitNode(subject.get(), subjectNode);
+ RefPtr<RegisterID> iterator = emitGetById(newTemporary(), subject.get(), propertyNames().iteratorSymbol);
+ {
+ CallArguments args(*this, nullptr);
+ emitMove(args.thisRegister(), subject.get());
+ emitCall(iterator.get(), iterator.get(), NoExpectedFunction, args, node->divot(), node->divotStart(), node->divotEnd());
+ }
+
+ RefPtr<Label> loopDone = newLabel();
+ // RefPtr<Register> iterator's lifetime must be longer than IteratorCloseContext.
+ pushIteratorCloseContext(iterator.get(), node);
+ {
+ LabelScopePtr scope = newLabelScope(LabelScope::Loop);
+ RefPtr<RegisterID> value = newTemporary();
+ emitLoad(value.get(), jsUndefined());
+
+ emitJump(scope->continueTarget());
+
+ RefPtr<Label> loopStart = newLabel();
+ emitLabel(loopStart.get());
+ emitLoopHint();
+
+ RefPtr<Label> tryStartLabel = newLabel();
+ emitLabel(tryStartLabel.get());
+ TryData* tryData = pushTry(tryStartLabel.get());
+ callBack(*this, value.get());
+ emitJump(scope->continueTarget());
+
+ // IteratorClose sequence for throw-ed control flow.
+ {
+ RefPtr<Label> catchHere = emitLabel(newLabel().get());
+ RefPtr<RegisterID> exceptionRegister = newTemporary();
+ RefPtr<RegisterID> thrownValueRegister = newTemporary();
+ popTryAndEmitCatch(tryData, exceptionRegister.get(),
+ thrownValueRegister.get(), catchHere.get(), HandlerType::SynthesizedFinally);
+
+ RefPtr<Label> catchDone = newLabel();
+
+ RefPtr<RegisterID> returnMethod = emitGetById(newTemporary(), iterator.get(), propertyNames().returnKeyword);
+ emitJumpIfTrue(emitIsUndefined(newTemporary(), returnMethod.get()), catchDone.get());
+
+ RefPtr<Label> returnCallTryStart = newLabel();
+ emitLabel(returnCallTryStart.get());
+ TryData* returnCallTryData = pushTry(returnCallTryStart.get());
+
+ CallArguments returnArguments(*this, nullptr);
+ emitMove(returnArguments.thisRegister(), iterator.get());
+ emitCall(value.get(), returnMethod.get(), NoExpectedFunction, returnArguments, node->divot(), node->divotStart(), node->divotEnd());
+
+ emitLabel(catchDone.get());
+ emitThrow(exceptionRegister.get());
+
+ // Absorb exception.
+ popTryAndEmitCatch(returnCallTryData, newTemporary(),
+ newTemporary(), catchDone.get(), HandlerType::SynthesizedFinally);
+ emitThrow(exceptionRegister.get());
+ }
+
+ emitLabel(scope->continueTarget());
+ if (forLoopNode)
+ prepareLexicalScopeForNextForLoopIteration(forLoopNode, forLoopSymbolTable);
+
+ {
+ emitIteratorNext(value.get(), iterator.get(), node);
+ emitJumpIfTrue(emitGetById(newTemporary(), value.get(), propertyNames().done), loopDone.get());
+ emitGetById(value.get(), value.get(), propertyNames().value);
+ emitJump(loopStart.get());
+ }
+
+ emitLabel(scope->breakTarget());
+ }
+
+ // IteratorClose sequence for break-ed control flow.
+ popIteratorCloseContext();
+ emitIteratorClose(iterator.get(), node);
+ emitLabel(loopDone.get());
}
-void BytecodeGenerator::emitReadOnlyExceptionIfNeeded()
+RegisterID* BytecodeGenerator::emitGetTemplateObject(RegisterID* dst, TaggedTemplateNode* taggedTemplate)
{
- if (!isStrictMode())
+ TemplateRegistryKey::StringVector rawStrings;
+ TemplateRegistryKey::StringVector cookedStrings;
+
+ TemplateStringListNode* templateString = taggedTemplate->templateLiteral()->templateStrings();
+ for (; templateString; templateString = templateString->next()) {
+ rawStrings.append(templateString->value()->raw().impl());
+ cookedStrings.append(templateString->value()->cooked().impl());
+ }
+
+ RefPtr<RegisterID> getTemplateObject = nullptr;
+ Variable var = variable(propertyNames().getTemplateObjectPrivateName);
+ if (RegisterID* local = var.local())
+ getTemplateObject = emitMove(newTemporary(), local);
+ else {
+ getTemplateObject = newTemporary();
+ RefPtr<RegisterID> scope = newTemporary();
+ moveToDestinationIfNeeded(scope.get(), emitResolveScope(scope.get(), var));
+ emitGetFromScope(getTemplateObject.get(), scope.get(), var, ThrowIfNotFound);
+ }
+
+ CallArguments arguments(*this, nullptr);
+ emitLoad(arguments.thisRegister(), JSValue(addTemplateRegistryKeyConstant(TemplateRegistryKey(rawStrings, cookedStrings))));
+ return emitCall(dst, getTemplateObject.get(), NoExpectedFunction, arguments, taggedTemplate->divot(), taggedTemplate->divotStart(), taggedTemplate->divotEnd());
+}
+
+RegisterID* BytecodeGenerator::emitGetEnumerableLength(RegisterID* dst, RegisterID* base)
+{
+ emitOpcode(op_get_enumerable_length);
+ instructions().append(dst->index());
+ instructions().append(base->index());
+ return dst;
+}
+
+RegisterID* BytecodeGenerator::emitHasGenericProperty(RegisterID* dst, RegisterID* base, RegisterID* propertyName)
+{
+ emitOpcode(op_has_generic_property);
+ instructions().append(dst->index());
+ instructions().append(base->index());
+ instructions().append(propertyName->index());
+ return dst;
+}
+
+RegisterID* BytecodeGenerator::emitHasIndexedProperty(RegisterID* dst, RegisterID* base, RegisterID* propertyName)
+{
+ UnlinkedArrayProfile arrayProfile = newArrayProfile();
+ emitOpcode(op_has_indexed_property);
+ instructions().append(dst->index());
+ instructions().append(base->index());
+ instructions().append(propertyName->index());
+ instructions().append(arrayProfile);
+ return dst;
+}
+
+RegisterID* BytecodeGenerator::emitHasStructureProperty(RegisterID* dst, RegisterID* base, RegisterID* propertyName, RegisterID* enumerator)
+{
+ emitOpcode(op_has_structure_property);
+ instructions().append(dst->index());
+ instructions().append(base->index());
+ instructions().append(propertyName->index());
+ instructions().append(enumerator->index());
+ return dst;
+}
+
+RegisterID* BytecodeGenerator::emitGetPropertyEnumerator(RegisterID* dst, RegisterID* base)
+{
+ emitOpcode(op_get_property_enumerator);
+ instructions().append(dst->index());
+ instructions().append(base->index());
+ return dst;
+}
+
+RegisterID* BytecodeGenerator::emitEnumeratorStructurePropertyName(RegisterID* dst, RegisterID* enumerator, RegisterID* index)
+{
+ emitOpcode(op_enumerator_structure_pname);
+ instructions().append(dst->index());
+ instructions().append(enumerator->index());
+ instructions().append(index->index());
+ return dst;
+}
+
+RegisterID* BytecodeGenerator::emitEnumeratorGenericPropertyName(RegisterID* dst, RegisterID* enumerator, RegisterID* index)
+{
+ emitOpcode(op_enumerator_generic_pname);
+ instructions().append(dst->index());
+ instructions().append(enumerator->index());
+ instructions().append(index->index());
+ return dst;
+}
+
+RegisterID* BytecodeGenerator::emitToIndexString(RegisterID* dst, RegisterID* index)
+{
+ emitOpcode(op_to_index_string);
+ instructions().append(dst->index());
+ instructions().append(index->index());
+ return dst;
+}
+
+
+RegisterID* BytecodeGenerator::emitIsObject(RegisterID* dst, RegisterID* src)
+{
+ emitOpcode(op_is_object);
+ instructions().append(dst->index());
+ instructions().append(src->index());
+ return dst;
+}
+
+RegisterID* BytecodeGenerator::emitIsUndefined(RegisterID* dst, RegisterID* src)
+{
+ emitOpcode(op_is_undefined);
+ instructions().append(dst->index());
+ instructions().append(src->index());
+ return dst;
+}
+
+RegisterID* BytecodeGenerator::emitIteratorNext(RegisterID* dst, RegisterID* iterator, const ThrowableExpressionData* node)
+{
+ {
+ RefPtr<RegisterID> next = emitGetById(newTemporary(), iterator, propertyNames().next);
+ CallArguments nextArguments(*this, nullptr);
+ emitMove(nextArguments.thisRegister(), iterator);
+ emitCall(dst, next.get(), NoExpectedFunction, nextArguments, node->divot(), node->divotStart(), node->divotEnd());
+ }
+ {
+ RefPtr<Label> typeIsObject = newLabel();
+ emitJumpIfTrue(emitIsObject(newTemporary(), dst), typeIsObject.get());
+ emitThrowTypeError(ASCIILiteral("Iterator result interface is not an object."));
+ emitLabel(typeIsObject.get());
+ }
+ return dst;
+}
+
+RegisterID* BytecodeGenerator::emitIteratorNextWithValue(RegisterID* dst, RegisterID* iterator, RegisterID* value, const ThrowableExpressionData* node)
+{
+ {
+ RefPtr<RegisterID> next = emitGetById(newTemporary(), iterator, propertyNames().next);
+ CallArguments nextArguments(*this, nullptr, 1);
+ emitMove(nextArguments.thisRegister(), iterator);
+ emitMove(nextArguments.argumentRegister(0), value);
+ emitCall(dst, next.get(), NoExpectedFunction, nextArguments, node->divot(), node->divotStart(), node->divotEnd());
+ }
+ {
+ RefPtr<Label> typeIsObject = newLabel();
+ emitJumpIfTrue(emitIsObject(newTemporary(), dst), typeIsObject.get());
+ emitThrowTypeError(ASCIILiteral("Iterator result interface is not an object."));
+ emitLabel(typeIsObject.get());
+ }
+ return dst;
+}
+
+void BytecodeGenerator::emitIteratorClose(RegisterID* iterator, const ThrowableExpressionData* node)
+{
+ RefPtr<Label> done = newLabel();
+ RefPtr<RegisterID> returnMethod = emitGetById(newTemporary(), iterator, propertyNames().returnKeyword);
+ emitJumpIfTrue(emitIsUndefined(newTemporary(), returnMethod.get()), done.get());
+
+ RefPtr<RegisterID> value = newTemporary();
+ CallArguments returnArguments(*this, nullptr);
+ emitMove(returnArguments.thisRegister(), iterator);
+ emitCall(value.get(), returnMethod.get(), NoExpectedFunction, returnArguments, node->divot(), node->divotStart(), node->divotEnd());
+ emitJumpIfTrue(emitIsObject(newTemporary(), value.get()), done.get());
+ emitThrowTypeError(ASCIILiteral("Iterator result interface is not an object."));
+ emitLabel(done.get());
+}
+
+void BytecodeGenerator::pushIndexedForInScope(RegisterID* localRegister, RegisterID* indexRegister)
+{
+ if (!localRegister)
return;
- emitOpcode(op_throw_static_error);
- instructions().append(addConstantValue(addStringConstant(Identifier(m_vm, StrictModeReadonlyPropertyWriteError)))->index());
- instructions().append(false);
+ m_forInContextStack.append(std::make_unique<IndexedForInContext>(localRegister, indexRegister));
+}
+
+void BytecodeGenerator::popIndexedForInScope(RegisterID* localRegister)
+{
+ if (!localRegister)
+ return;
+ m_forInContextStack.removeLast();
+}
+
+RegisterID* BytecodeGenerator::emitLoadArrowFunctionLexicalEnvironment()
+{
+ ASSERT(m_codeBlock->isArrowFunction() || m_codeBlock->isArrowFunctionContext() || constructorKind() == ConstructorKind::Derived);
+
+ return emitResolveScope(nullptr, variable(propertyNames().thisIdentifier, ThisResolutionType::Scoped));
+}
+
+void BytecodeGenerator::emitLoadThisFromArrowFunctionLexicalEnvironment()
+{
+ emitGetFromScope(thisRegister(), emitLoadArrowFunctionLexicalEnvironment(), variable(propertyNames().thisIdentifier, ThisResolutionType::Scoped), DoNotThrowIfNotFound);
+}
+
+RegisterID* BytecodeGenerator::emitLoadNewTargetFromArrowFunctionLexicalEnvironment()
+{
+ m_isNewTargetLoadedInArrowFunction = true;
+
+ Variable newTargetVar = variable(propertyNames().newTargetLocalPrivateName);
+ emitMove(m_newTargetRegister, emitGetFromScope(newTemporary(), emitLoadArrowFunctionLexicalEnvironment(), newTargetVar, ThrowIfNotFound));
+
+ return m_newTargetRegister;
+}
+
+RegisterID* BytecodeGenerator::emitLoadDerivedConstructorFromArrowFunctionLexicalEnvironment()
+{
+ Variable protoScopeVar = variable(propertyNames().derivedConstructorPrivateName);
+ return emitGetFromScope(newTemporary(), emitLoadArrowFunctionLexicalEnvironment(), protoScopeVar, ThrowIfNotFound);
+}
+
+void BytecodeGenerator::emitPutNewTargetToArrowFunctionContextScope()
+{
+ ASSERT(m_arrowFunctionContextLexicalEnvironmentRegister != nullptr);
+
+ Variable newTargetVar = variable(propertyNames().newTargetLocalPrivateName);
+ emitPutToScope(m_arrowFunctionContextLexicalEnvironmentRegister, newTargetVar, newTarget(), DoNotThrowIfNotFound, Initialization);
+}
+
+void BytecodeGenerator::emitPutDerivedConstructorToArrowFunctionContextScope()
+{
+ if ((isConstructor() && constructorKind() == ConstructorKind::Derived) || m_codeBlock->isClassContext()) {
+ ASSERT(m_arrowFunctionContextLexicalEnvironmentRegister);
+
+ Variable protoScope = variable(propertyNames().derivedConstructorPrivateName);
+ emitPutToScope(m_arrowFunctionContextLexicalEnvironmentRegister, protoScope, &m_calleeRegister, DoNotThrowIfNotFound, Initialization);
+ }
+}
+
+void BytecodeGenerator::emitPutThisToArrowFunctionContextScope()
+{
+ ASSERT(isDerivedConstructorContext() || m_arrowFunctionContextLexicalEnvironmentRegister != nullptr);
+
+ Variable thisVar = variable(propertyNames().thisIdentifier, ThisResolutionType::Scoped);
+ RegisterID* scope = isDerivedConstructorContext() ? emitLoadArrowFunctionLexicalEnvironment() : m_arrowFunctionContextLexicalEnvironmentRegister;
+
+ emitPutToScope(scope, thisVar, thisRegister(), DoNotThrowIfNotFound, NotInitialization);
+}
+
+void BytecodeGenerator::pushStructureForInScope(RegisterID* localRegister, RegisterID* indexRegister, RegisterID* propertyRegister, RegisterID* enumeratorRegister)
+{
+ if (!localRegister)
+ return;
+ m_forInContextStack.append(std::make_unique<StructureForInContext>(localRegister, indexRegister, propertyRegister, enumeratorRegister));
+}
+
+void BytecodeGenerator::popStructureForInScope(RegisterID* localRegister)
+{
+ if (!localRegister)
+ return;
+ m_forInContextStack.removeLast();
+}
+
+void BytecodeGenerator::invalidateForInContextForLocal(RegisterID* localRegister)
+{
+ // Lexically invalidating ForInContexts is kind of weak sauce, but it only occurs if
+ // either of the following conditions is true:
+ //
+ // (1) The loop iteration variable is re-assigned within the body of the loop.
+ // (2) The loop iteration variable is captured in the lexical scope of the function.
+ //
+ // These two situations occur sufficiently rarely that it's okay to use this style of
+ // "analysis" to make iteration faster. If we didn't want to do this, we would either have
+ // to perform some flow-sensitive analysis to see if/when the loop iteration variable was
+ // reassigned, or we'd have to resort to runtime checks to see if the variable had been
+ // reassigned from its original value.
+ for (size_t i = m_forInContextStack.size(); i > 0; i--) {
+ ForInContext* context = m_forInContextStack[i - 1].get();
+ if (context->local() != localRegister)
+ continue;
+ context->invalidate();
+ break;
+ }
+}
+
+RegisterID* BytecodeGenerator::emitRestParameter(RegisterID* result, unsigned numParametersToSkip)
+{
+ RefPtr<RegisterID> restArrayLength = newTemporary();
+ emitOpcode(op_get_rest_length);
+ instructions().append(restArrayLength->index());
+ instructions().append(numParametersToSkip);
+
+ emitNewArrayWithSize(result, restArrayLength.get());
+
+ emitOpcode(op_copy_rest);
+ instructions().append(result->index());
+ instructions().append(restArrayLength->index());
+ instructions().append(numParametersToSkip);
+
+ return result;
+}
+
+void BytecodeGenerator::emitRequireObjectCoercible(RegisterID* value, const String& error)
+{
+ // FIXME: op_jneq_null treats "undetectable" objects as null/undefined. RequireObjectCoercible
+ // thus incorrectly throws a TypeError for interfaces like HTMLAllCollection.
+ RefPtr<Label> target = newLabel();
+ size_t begin = instructions().size();
+ emitOpcode(op_jneq_null);
+ instructions().append(value->index());
+ instructions().append(target->bind(begin, instructions().size()));
+ emitThrowTypeError(error);
+ emitLabel(target.get());
+}
+
+void BytecodeGenerator::emitYieldPoint(RegisterID* argument)
+{
+ RefPtr<Label> mergePoint = newLabel();
+ size_t yieldPointIndex = m_generatorResumeLabels.size();
+ emitGeneratorStateChange(yieldPointIndex);
+ // First yield point is used for initial sequence.
+ unsigned liveCalleeLocalsIndex = yieldPointIndex - 1;
+ emitSave(mergePoint.get(), liveCalleeLocalsIndex);
+ emitReturn(argument);
+ emitResume(mergePoint.get(), liveCalleeLocalsIndex);
+}
+
+void BytecodeGenerator::emitSave(Label* mergePoint, unsigned liveCalleeLocalsIndex)
+{
+ size_t begin = instructions().size();
+ emitOpcode(op_save);
+ instructions().append(m_generatorRegister->index());
+ instructions().append(liveCalleeLocalsIndex);
+ instructions().append(mergePoint->bind(begin, instructions().size()));
+}
+
+void BytecodeGenerator::emitResume(Label* mergePoint, unsigned liveCalleeLocalsIndex)
+{
+ emitGeneratorStateLabel();
+ emitOpcode(op_resume);
+ instructions().append(m_generatorRegister->index());
+ instructions().append(liveCalleeLocalsIndex);
+ emitLabel(mergePoint);
+}
+
+RegisterID* BytecodeGenerator::emitYield(RegisterID* argument)
+{
+ emitYieldPoint(argument);
+
+ RefPtr<Label> normalLabel = newLabel();
+ RefPtr<RegisterID> condition = newTemporary();
+ emitEqualityOp(op_stricteq, condition.get(), generatorResumeModeRegister(), emitLoad(nullptr, jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorResumeMode::NormalMode))));
+ emitJumpIfTrue(condition.get(), normalLabel.get());
+
+ RefPtr<Label> throwLabel = newLabel();
+ emitEqualityOp(op_stricteq, condition.get(), generatorResumeModeRegister(), emitLoad(nullptr, jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorResumeMode::ThrowMode))));
+ emitJumpIfTrue(condition.get(), throwLabel.get());
+ // Return.
+ {
+ RefPtr<RegisterID> returnRegister = generatorValueRegister();
+ if (isInFinallyBlock()) {
+ returnRegister = emitMove(newTemporary(), returnRegister.get());
+ emitPopScopes(scopeRegister(), 0);
+ }
+ emitReturn(returnRegister.get());
+ }
+
+ // Throw.
+ emitLabel(throwLabel.get());
+ emitThrow(generatorValueRegister());
+
+ // Normal.
+ emitLabel(normalLabel.get());
+ return generatorValueRegister();
+}
+
+RegisterID* BytecodeGenerator::emitDelegateYield(RegisterID* argument, ThrowableExpressionData* node)
+{
+ RefPtr<RegisterID> value = newTemporary();
+ {
+ RefPtr<RegisterID> iterator = emitGetById(newTemporary(), argument, propertyNames().iteratorSymbol);
+ {
+ CallArguments args(*this, nullptr);
+ emitMove(args.thisRegister(), argument);
+ emitCall(iterator.get(), iterator.get(), NoExpectedFunction, args, node->divot(), node->divotStart(), node->divotEnd());
+ }
+
+ RefPtr<Label> loopDone = newLabel();
+ {
+ RefPtr<Label> nextElement = newLabel();
+ emitLoad(value.get(), jsUndefined());
+
+ emitJump(nextElement.get());
+
+ RefPtr<Label> loopStart = newLabel();
+ emitLabel(loopStart.get());
+ emitLoopHint();
+
+ {
+ emitYieldPoint(value.get());
+
+ RefPtr<Label> normalLabel = newLabel();
+ RefPtr<Label> returnLabel = newLabel();
+ {
+ RefPtr<RegisterID> condition = newTemporary();
+ emitEqualityOp(op_stricteq, condition.get(), generatorResumeModeRegister(), emitLoad(nullptr, jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorResumeMode::NormalMode))));
+ emitJumpIfTrue(condition.get(), normalLabel.get());
+
+ emitEqualityOp(op_stricteq, condition.get(), generatorResumeModeRegister(), emitLoad(nullptr, jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorResumeMode::ReturnMode))));
+ emitJumpIfTrue(condition.get(), returnLabel.get());
+
+ // Fallthrough to ThrowMode.
+ }
+
+ RefPtr<Label> returnSequence = newLabel();
+ RefPtr<Label> returnWithIteratorResult = newLabel();
+ RefPtr<RegisterID> returnIteratorResult = newTemporary();
+ // Throw.
+ {
+ RefPtr<Label> throwMethodFound = newLabel();
+ RefPtr<RegisterID> throwMethod = emitGetById(newTemporary(), iterator.get(), propertyNames().throwKeyword);
+ emitJumpIfFalse(emitIsUndefined(newTemporary(), throwMethod.get()), throwMethodFound.get());
+
+ emitIteratorClose(iterator.get(), node);
+ emitThrowTypeError(ASCIILiteral("Delegated generator does not have a 'throw' method."));
+
+ emitLabel(throwMethodFound.get());
+ CallArguments throwArguments(*this, nullptr, 1);
+ emitMove(throwArguments.thisRegister(), iterator.get());
+ emitMove(throwArguments.argumentRegister(0), generatorValueRegister());
+ emitCall(returnIteratorResult.get(), throwMethod.get(), NoExpectedFunction, throwArguments, node->divot(), node->divotStart(), node->divotEnd());
+ emitJump(returnWithIteratorResult.get());
+ }
+
+ // Return.
+ emitLabel(returnLabel.get());
+ {
+ RefPtr<Label> returnMethodFound = newLabel();
+ RefPtr<RegisterID> returnMethod = emitGetById(newTemporary(), iterator.get(), propertyNames().returnKeyword);
+ emitJumpIfFalse(emitIsUndefined(newTemporary(), returnMethod.get()), returnMethodFound.get());
+
+ emitMove(value.get(), generatorValueRegister());
+ emitJump(returnSequence.get());
+
+ emitLabel(returnMethodFound.get());
+ CallArguments returnArguments(*this, nullptr, 1);
+ emitMove(returnArguments.thisRegister(), iterator.get());
+ emitMove(returnArguments.argumentRegister(0), generatorValueRegister());
+ emitCall(returnIteratorResult.get(), returnMethod.get(), NoExpectedFunction, returnArguments, node->divot(), node->divotStart(), node->divotEnd());
+
+ // Fallthrough to returnWithIteratorResult.
+ }
+
+ emitLabel(returnWithIteratorResult.get());
+ {
+ RefPtr<Label> returnIteratorResultIsObject = newLabel();
+ emitJumpIfTrue(emitIsObject(newTemporary(), returnIteratorResult.get()), returnIteratorResultIsObject.get());
+ emitThrowTypeError(ASCIILiteral("Iterator result interface is not an object."));
+
+ emitLabel(returnIteratorResultIsObject.get());
+ RefPtr<Label> returnFromGenerator = newLabel();
+ emitJumpIfTrue(emitGetById(newTemporary(), returnIteratorResult.get(), propertyNames().done), returnFromGenerator.get());
+
+ emitGetById(value.get(), returnIteratorResult.get(), propertyNames().value);
+ emitJump(loopStart.get());
+
+ emitLabel(returnFromGenerator.get());
+ emitGetById(value.get(), returnIteratorResult.get(), propertyNames().value);
+
+ // Fallthrough to returnSequence.
+ }
+
+ emitLabel(returnSequence.get());
+ {
+ if (isInFinallyBlock())
+ emitPopScopes(scopeRegister(), 0);
+ emitReturn(value.get());
+ }
+
+ // Normal.
+ emitLabel(normalLabel.get());
+ emitMove(value.get(), generatorValueRegister());
+ }
+
+ emitLabel(nextElement.get());
+ {
+ emitIteratorNextWithValue(value.get(), iterator.get(), value.get(), node);
+ emitJumpIfTrue(emitGetById(newTemporary(), value.get(), propertyNames().done), loopDone.get());
+ emitGetById(value.get(), value.get(), propertyNames().value);
+ emitJump(loopStart.get());
+ }
+ }
+ emitLabel(loopDone.get());
+ }
+
+ emitGetById(value.get(), value.get(), propertyNames().value);
+ return value.get();
+}
+
+
+void BytecodeGenerator::emitGeneratorStateChange(int32_t state)
+{
+ RegisterID* completedState = emitLoad(nullptr, jsNumber(state));
+ emitPutById(generatorRegister(), propertyNames().generatorStatePrivateName, completedState);
+}
+
+void BytecodeGenerator::emitGeneratorStateLabel()
+{
+ RefPtr<Label> label = newLabel();
+ m_generatorResumeLabels.append(label.get());
+ emitLabel(label.get());
+}
+
+void BytecodeGenerator::beginGenerator(RegisterID* state)
+{
+ beginSwitch(state, SwitchInfo::SwitchImmediate);
+}
+
+void BytecodeGenerator::endGenerator(Label* defaultLabel)
+{
+ SwitchInfo switchInfo = m_switchContextStack.last();
+ m_switchContextStack.removeLast();
+
+ instructions()[switchInfo.bytecodeOffset + 1] = m_codeBlock->numberOfSwitchJumpTables();
+ instructions()[switchInfo.bytecodeOffset + 2] = defaultLabel->bind(switchInfo.bytecodeOffset, switchInfo.bytecodeOffset + 3);
+
+ UnlinkedSimpleJumpTable& jumpTable = m_codeBlock->addSwitchJumpTable();
+ int32_t switchAddress = switchInfo.bytecodeOffset;
+ jumpTable.min = 0;
+ jumpTable.branchOffsets.resize(m_generatorResumeLabels.size() + 1);
+ jumpTable.branchOffsets.fill(0);
+ for (uint32_t i = 0; i < m_generatorResumeLabels.size(); ++i) {
+ // We're emitting this after the clause labels should have been fixed, so
+ // the labels should not be "forward" references
+ ASSERT(!m_generatorResumeLabels[i]->isForward());
+ jumpTable.add(i, m_generatorResumeLabels[i]->bind(switchAddress, switchAddress + 3));
+ }
}
} // namespace JSC
diff --git a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
index c8a3ed6ef..f2c7ac5c1 100644
--- a/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
+++ b/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2008, 2009, 2012, 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2008, 2009, 2012-2015 Apple Inc. All rights reserved.
* Copyright (C) 2008 Cameron Zwarich <cwzwarich@uwaterloo.ca>
* Copyright (C) 2012 Igalia, S.L.
*
@@ -12,7 +12,7 @@
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
- * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ * 3. Neither the name of Apple Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
@@ -39,21 +39,25 @@
#include "Interpreter.h"
#include "ParserError.h"
#include "RegisterID.h"
+#include "SetForScope.h"
#include "SymbolTable.h"
#include "Debugger.h"
#include "Nodes.h"
#include "StaticPropertyAnalyzer.h"
+#include "TemplateRegistryKey.h"
#include "UnlinkedCodeBlock.h"
-#include "VMStackBounds.h"
+
+#include <functional>
+
#include <wtf/PassRefPtr.h>
#include <wtf/SegmentedVector.h>
#include <wtf/Vector.h>
+
namespace JSC {
class Identifier;
- class Label;
- class JSScope;
+ class JSTemplateRegistryKey;
enum ExpectedFunction {
NoExpectedFunction,
@@ -61,32 +65,36 @@ namespace JSC {
ExpectArrayConstructor
};
+ enum class ThisResolutionType { Local, Scoped };
+
class CallArguments {
public:
- CallArguments(BytecodeGenerator& generator, ArgumentsNode* argumentsNode);
+ CallArguments(BytecodeGenerator&, ArgumentsNode*, unsigned additionalArguments = 0);
RegisterID* thisRegister() { return m_argv[0].get(); }
RegisterID* argumentRegister(unsigned i) { return m_argv[i + 1].get(); }
- unsigned registerOffset() { return m_argv.last()->index() + CallFrame::offsetFor(argumentCountIncludingThis()); }
- unsigned argumentCountIncludingThis() { return m_argv.size(); }
+ unsigned stackOffset() { return -m_argv[0]->index() + JSStack::CallFrameHeaderSize; }
+ unsigned argumentCountIncludingThis() { return m_argv.size() - m_padding; }
RegisterID* profileHookRegister() { return m_profileHookRegister.get(); }
ArgumentsNode* argumentsNode() { return m_argumentsNode; }
private:
- void newArgument(BytecodeGenerator&);
-
RefPtr<RegisterID> m_profileHookRegister;
ArgumentsNode* m_argumentsNode;
Vector<RefPtr<RegisterID>, 8, UnsafeVectorOverflow> m_argv;
+ unsigned m_padding;
};
struct FinallyContext {
StatementNode* finallyBlock;
+ RegisterID* iterator;
+ ThrowableExpressionData* enumerationNode;
unsigned scopeContextStackSize;
unsigned switchContextStackSize;
unsigned forInContextStackSize;
unsigned tryContextStackSize;
unsigned labelScopesSize;
+ unsigned symbolTableStackSize;
int finallyDepth;
int dynamicScopeDepth;
};
@@ -96,183 +104,212 @@ namespace JSC {
FinallyContext finallyContext;
};
- struct ForInContext {
- RefPtr<RegisterID> expectedSubscriptRegister;
- RefPtr<RegisterID> iterRegister;
- RefPtr<RegisterID> indexRegister;
- RefPtr<RegisterID> propertyRegister;
- };
-
- struct TryData {
- RefPtr<Label> target;
- unsigned targetScopeDepth;
- };
-
- struct TryContext {
- RefPtr<Label> start;
- TryData* tryData;
- };
-
- struct TryRange {
- RefPtr<Label> start;
- RefPtr<Label> end;
- TryData* tryData;
- };
-
- class ResolveResult {
+ class ForInContext {
+ WTF_MAKE_FAST_ALLOCATED;
public:
- enum Flags {
- // The property is locally bound, in a register.
- RegisterFlag = 0x1,
- // We need to traverse the scope chain at runtime, checking for
- // non-strict eval and/or `with' nodes.
- DynamicFlag = 0x2,
- // The resolved binding is immutable.
- ReadOnlyFlag = 0x4,
- // The property has a static location
- StaticFlag = 0x8,
- // Entry at scope distance "m_depth" and located at "m_index"
- ScopedFlag = 0x10
- };
-
- enum Type {
- // The property is local, and stored in a register.
- Register = RegisterFlag | StaticFlag,
- // A read-only local, created by "const".
- ReadOnlyRegister = RegisterFlag | ReadOnlyFlag | StaticFlag,
- // Lexically fixed location in the scope chain
- Lexical = ScopedFlag | StaticFlag,
- // A read-only Lexical, created by "const".
- ReadOnlyLexical = ScopedFlag | ReadOnlyFlag | StaticFlag,
- // Any other form of lookup
- Dynamic = DynamicFlag,
- };
-
- static ResolveResult registerResolve(RegisterID *local, unsigned flags)
+ ForInContext(RegisterID* localRegister)
+ : m_localRegister(localRegister)
+ , m_isValid(true)
{
- return ResolveResult(Register | flags, local);
}
- static ResolveResult dynamicResolve()
- {
- return ResolveResult(Dynamic, 0);
- }
- static ResolveResult lexicalResolve(int index, size_t depth, unsigned flags)
+
+ virtual ~ForInContext()
{
- if (flags & DynamicFlag)
- return dynamicResolve();
- return ResolveResult(Lexical | flags, index, depth);
}
- unsigned type() const { return m_type; }
- // Returns the register corresponding to a local variable, or 0 if no
- // such register exists. Registers returned by ResolveResult::local() do
- // not require explicit reference counting.
- RegisterID* local() const { return m_local; }
+ bool isValid() const { return m_isValid; }
+ void invalidate() { m_isValid = false; }
- bool isRegister() const { return m_type & RegisterFlag; }
- bool isStatic() const { return (m_type & StaticFlag) && !isDynamic(); }
- bool isDynamic() const { return m_type & DynamicFlag; }
- bool isReadOnly() const { return (m_type & ReadOnlyFlag) && !isDynamic(); }
+ enum ForInContextType {
+ StructureForInContextType,
+ IndexedForInContextType
+ };
+ virtual ForInContextType type() const = 0;
- unsigned depth() const { ASSERT(isStatic()); return m_depth; }
- int32_t index() const { ASSERT(isStatic()); return m_index; }
+ RegisterID* local() const { return m_localRegister.get(); }
private:
- ResolveResult(unsigned type, RegisterID* local)
- : m_type(type)
- , m_local(local)
- , m_index(0)
- , m_depth(0)
+ RefPtr<RegisterID> m_localRegister;
+ bool m_isValid;
+ };
+
+ class StructureForInContext : public ForInContext {
+ public:
+ StructureForInContext(RegisterID* localRegister, RegisterID* indexRegister, RegisterID* propertyRegister, RegisterID* enumeratorRegister)
+ : ForInContext(localRegister)
+ , m_indexRegister(indexRegister)
+ , m_propertyRegister(propertyRegister)
+ , m_enumeratorRegister(enumeratorRegister)
{
-#ifndef NDEBUG
- checkValidity();
-#endif
}
- ResolveResult(unsigned type, int index, unsigned depth)
- : m_type(type)
- , m_local(0)
- , m_index(index)
- , m_depth(depth)
+ virtual ForInContextType type() const
{
-#ifndef NDEBUG
- checkValidity();
-#endif
+ return StructureForInContextType;
}
-#ifndef NDEBUG
- void checkValidity();
-#endif
+ RegisterID* index() const { return m_indexRegister.get(); }
+ RegisterID* property() const { return m_propertyRegister.get(); }
+ RegisterID* enumerator() const { return m_enumeratorRegister.get(); }
- unsigned m_type;
- RegisterID* m_local; // Local register, if RegisterFlag is set
- int m_index;
- unsigned m_depth;
+ private:
+ RefPtr<RegisterID> m_indexRegister;
+ RefPtr<RegisterID> m_propertyRegister;
+ RefPtr<RegisterID> m_enumeratorRegister;
};
- struct NonlocalResolveInfo {
- friend class BytecodeGenerator;
- NonlocalResolveInfo()
- : m_state(Unused)
+ class IndexedForInContext : public ForInContext {
+ public:
+ IndexedForInContext(RegisterID* localRegister, RegisterID* indexRegister)
+ : ForInContext(localRegister)
+ , m_indexRegister(indexRegister)
{
}
- ~NonlocalResolveInfo()
+
+ virtual ForInContextType type() const
{
- ASSERT(m_state == Put);
+ return IndexedForInContextType;
}
+
+ RegisterID* index() const { return m_indexRegister.get(); }
+
private:
- void resolved(uint32_t putToBaseIndex)
+ RefPtr<RegisterID> m_indexRegister;
+ };
+
+ struct TryData {
+ RefPtr<Label> target;
+ HandlerType handlerType;
+ };
+
+ struct TryContext {
+ RefPtr<Label> start;
+ TryData* tryData;
+ };
+
+ class Variable {
+ public:
+ enum VariableKind { NormalVariable, SpecialVariable };
+
+ Variable()
+ : m_offset()
+ , m_local(nullptr)
+ , m_attributes(0)
+ , m_kind(NormalVariable)
+ , m_symbolTableConstantIndex(0) // This is meaningless here for this kind of Variable.
+ , m_isLexicallyScoped(false)
+ {
+ }
+
+ Variable(const Identifier& ident)
+ : m_ident(ident)
+ , m_local(nullptr)
+ , m_attributes(0)
+ , m_kind(NormalVariable) // This is somewhat meaningless here for this kind of Variable.
+ , m_symbolTableConstantIndex(0) // This is meaningless here for this kind of Variable.
+ , m_isLexicallyScoped(false)
{
- ASSERT(putToBaseIndex);
- ASSERT(m_state == Unused);
- m_state = Resolved;
- m_putToBaseIndex = putToBaseIndex;
}
- uint32_t put()
+
+ Variable(const Identifier& ident, VarOffset offset, RegisterID* local, unsigned attributes, VariableKind kind, int symbolTableConstantIndex, bool isLexicallyScoped)
+ : m_ident(ident)
+ , m_offset(offset)
+ , m_local(local)
+ , m_attributes(attributes)
+ , m_kind(kind)
+ , m_symbolTableConstantIndex(symbolTableConstantIndex)
+ , m_isLexicallyScoped(isLexicallyScoped)
{
- ASSERT(m_state == Resolved);
- m_state = Put;
- return m_putToBaseIndex;
}
- enum State { Unused, Resolved, Put };
- State m_state;
- uint32_t m_putToBaseIndex;
+
+ // If it's unset, then it is a non-locally-scoped variable. If it is set, then it could be
+ // a stack variable, a scoped variable in a local scope, or a variable captured in the
+ // direct arguments object.
+ bool isResolved() const { return !!m_offset; }
+ int symbolTableConstantIndex() const { ASSERT(isResolved() && !isSpecial()); return m_symbolTableConstantIndex; }
+
+ const Identifier& ident() const { return m_ident; }
+
+ VarOffset offset() const { return m_offset; }
+ bool isLocal() const { return m_offset.isStack(); }
+ RegisterID* local() const { return m_local; }
+
+ bool isReadOnly() const { return m_attributes & ReadOnly; }
+ bool isSpecial() const { return m_kind != NormalVariable; }
+ bool isConst() const { return isReadOnly() && m_isLexicallyScoped; }
+ void setIsReadOnly() { m_attributes |= ReadOnly; }
+
+ private:
+ Identifier m_ident;
+ VarOffset m_offset;
+ RegisterID* m_local;
+ unsigned m_attributes;
+ VariableKind m_kind;
+ int m_symbolTableConstantIndex;
+ bool m_isLexicallyScoped;
+ };
+
+ struct TryRange {
+ RefPtr<Label> start;
+ RefPtr<Label> end;
+ TryData* tryData;
+ };
+
+ enum ProfileTypeBytecodeFlag {
+ ProfileTypeBytecodeClosureVar,
+ ProfileTypeBytecodeLocallyResolved,
+ ProfileTypeBytecodeDoesNotHaveGlobalID,
+ ProfileTypeBytecodeFunctionArgument,
+ ProfileTypeBytecodeFunctionReturnStatement
};
class BytecodeGenerator {
WTF_MAKE_FAST_ALLOCATED;
+ WTF_MAKE_NONCOPYABLE(BytecodeGenerator);
public:
- typedef DeclarationStacks::VarStack VarStack;
typedef DeclarationStacks::FunctionStack FunctionStack;
- BytecodeGenerator(VM&, JSScope*, ProgramNode*, UnlinkedProgramCodeBlock*, DebuggerMode, ProfilerMode);
- BytecodeGenerator(VM&, JSScope*, FunctionBodyNode*, UnlinkedFunctionCodeBlock*, DebuggerMode, ProfilerMode);
- BytecodeGenerator(VM&, JSScope*, EvalNode*, UnlinkedEvalCodeBlock*, DebuggerMode, ProfilerMode);
+ BytecodeGenerator(VM&, ProgramNode*, UnlinkedProgramCodeBlock*, DebuggerMode, ProfilerMode, const VariableEnvironment*);
+ BytecodeGenerator(VM&, FunctionNode*, UnlinkedFunctionCodeBlock*, DebuggerMode, ProfilerMode, const VariableEnvironment*);
+ BytecodeGenerator(VM&, EvalNode*, UnlinkedEvalCodeBlock*, DebuggerMode, ProfilerMode, const VariableEnvironment*);
+ BytecodeGenerator(VM&, ModuleProgramNode*, UnlinkedModuleProgramCodeBlock*, DebuggerMode, ProfilerMode, const VariableEnvironment*);
~BytecodeGenerator();
VM* vm() const { return m_vm; }
+ ParserArena& parserArena() const { return m_scopeNode->parserArena(); }
const CommonIdentifiers& propertyNames() const { return *m_vm->propertyNames; }
- bool isConstructor() { return m_codeBlock->isConstructor(); }
+ bool isConstructor() const { return m_codeBlock->isConstructor(); }
+ DerivedContextType derivedContextType() const { return m_derivedContextType; }
+ bool usesArrowFunction() const { return m_scopeNode->usesArrowFunction(); }
+ bool needsToUpdateArrowFunctionContext() const { return m_needsToUpdateArrowFunctionContext; }
+ bool usesEval() const { return m_scopeNode->usesEval(); }
+ bool usesThis() const { return m_scopeNode->usesThis(); }
+ ConstructorKind constructorKind() const { return m_codeBlock->constructorKind(); }
+ SuperBinding superBinding() const { return m_codeBlock->superBinding(); }
ParserError generate();
bool isArgumentNumber(const Identifier&, int);
- void setIsNumericCompareFunction(bool isNumericCompareFunction);
-
- bool willResolveToArguments(const Identifier&);
- RegisterID* uncheckedRegisterForArguments();
-
- // Resolve an identifier, given the current compile-time scope chain.
- ResolveResult resolve(const Identifier&);
- // Behaves as resolve does, but ignores dynamic scope as
- // dynamic scope should not interfere with const initialisation
- ResolveResult resolveConstDecl(const Identifier&);
-
+ Variable variable(const Identifier&, ThisResolutionType = ThisResolutionType::Local);
+
+ enum ExistingVariableMode { VerifyExisting, IgnoreExisting };
+ void createVariable(const Identifier&, VarKind, SymbolTable*, ExistingVariableMode = VerifyExisting); // Creates the variable, or asserts that the already-created variable is sufficiently compatible.
+
// Returns the register storing "this"
RegisterID* thisRegister() { return &m_thisRegister; }
+ RegisterID* argumentsRegister() { return m_argumentsRegister; }
+ RegisterID* newTarget()
+ {
+ return !m_codeBlock->isArrowFunction() || m_isNewTargetLoadedInArrowFunction
+ ? m_newTargetRegister : emitLoadNewTargetFromArrowFunctionLexicalEnvironment();
+ }
+
+ RegisterID* scopeRegister() { return m_scopeRegister; }
+
+ RegisterID* generatorRegister() { return m_generatorRegister; }
// Returns the next available temporary register. Registers returned by
// newTemporary require a modified form of reference counting: any
@@ -290,6 +327,13 @@ namespace JSC {
RegisterID* ignoredResult() { return &m_ignoredResultRegister; }
+ // This will be allocated in the temporary region of registers, but it will
+ // not be marked as a temporary. This will ensure that finalDestination() does
+ // not overwrite a block scope variable that it mistakes as a temporary. These
+ // registers can be (and are) reclaimed when the lexical scope they belong to
+ // is no longer on the symbol table stack.
+ RegisterID* newBlockScopeVariable();
+
// Returns a place to write intermediate values of an operation
// which reuses dst if it is safe to do so.
RegisterID* tempDestination(RegisterID* dst)
@@ -308,20 +352,9 @@ namespace JSC {
return newTemporary();
}
- // Returns the place to write the final output of an operation.
- RegisterID* finalDestinationOrIgnored(RegisterID* originalDst, RegisterID* tempDst = 0)
- {
- if (originalDst)
- return originalDst;
- ASSERT(tempDst != ignoredResult());
- if (tempDst && tempDst->isTemporary())
- return tempDst;
- return newTemporary();
- }
-
RegisterID* destinationForAssignResult(RegisterID* dst)
{
- if (dst && dst != ignoredResult() && m_codeBlock->needsFullScopeChain())
+ if (dst && dst != ignoredResult())
return dst->isTemporary() ? dst : newTemporary();
return 0;
}
@@ -337,9 +370,15 @@ namespace JSC {
void emitNode(RegisterID* dst, StatementNode* n)
{
+ SetForScope<bool> tailPositionPoisoner(m_inTailPosition, false);
+ return emitNodeInTailPosition(dst, n);
+ }
+
+ void emitNodeInTailPosition(RegisterID* dst, StatementNode* n)
+ {
// Node::emitCode assumes that dst, if provided, is either a local or a referenced temporary.
ASSERT(!dst || dst == ignoredResult() || !dst->isTemporary() || dst->refCount());
- if (!m_stack.isSafeToRecurse()) {
+ if (!m_vm->isSafeToRecurse()) {
emitThrowExpressionTooDeepException();
return;
}
@@ -348,26 +387,42 @@ namespace JSC {
void emitNode(StatementNode* n)
{
- emitNode(0, n);
+ emitNode(nullptr, n);
+ }
+
+ void emitNodeInTailPosition(StatementNode* n)
+ {
+ emitNodeInTailPosition(nullptr, n);
}
RegisterID* emitNode(RegisterID* dst, ExpressionNode* n)
{
+ SetForScope<bool> tailPositionPoisoner(m_inTailPosition, false);
+ return emitNodeInTailPosition(dst, n);
+ }
+
+ RegisterID* emitNodeInTailPosition(RegisterID* dst, ExpressionNode* n)
+ {
// Node::emitCode assumes that dst, if provided, is either a local or a referenced temporary.
ASSERT(!dst || dst == ignoredResult() || !dst->isTemporary() || dst->refCount());
- if (!m_stack.isSafeToRecurse())
+ if (!m_vm->isSafeToRecurse())
return emitThrowExpressionTooDeepException();
return n->emitBytecode(*this, dst);
}
RegisterID* emitNode(ExpressionNode* n)
{
- return emitNode(0, n);
+ return emitNode(nullptr, n);
+ }
+
+ RegisterID* emitNodeInTailPosition(ExpressionNode* n)
+ {
+ return emitNodeInTailPosition(nullptr, n);
}
void emitNodeInConditionContext(ExpressionNode* n, Label* trueTarget, Label* falseTarget, FallThroughMode fallThroughMode)
{
- if (!m_stack.isSafeToRecurse()) {
+ if (!m_vm->isSafeToRecurse()) {
emitThrowExpressionTooDeepException();
return;
}
@@ -396,16 +451,21 @@ namespace JSC {
lineStart -= sourceOffset;
else
lineStart = 0;
- ASSERT(divotOffset >= lineStart);
+
+ if (divotOffset < lineStart)
+ return;
+
unsigned column = divotOffset - lineStart;
unsigned instructionOffset = instructions().size();
- m_codeBlock->addExpressionInfo(instructionOffset, divotOffset, startOffset, endOffset, line, column);
+ if (!m_isBuiltinFunction)
+ m_codeBlock->addExpressionInfo(instructionOffset, divotOffset, startOffset, endOffset, line, column);
}
+
ALWAYS_INLINE bool leftHandSideNeedsCopy(bool rightHasAssignments, bool rightIsPure)
{
- return (m_codeType != FunctionCode || m_codeBlock->needsFullScopeChain() || rightHasAssignments) && !rightIsPure;
+ return (m_codeType != FunctionCode || rightHasAssignments) && !rightIsPure;
}
ALWAYS_INLINE PassRefPtr<RegisterID> emitNodeForLeftHandSide(ExpressionNode* n, bool rightHasAssignments, bool rightIsPure)
@@ -419,10 +479,28 @@ namespace JSC {
return emitNode(n);
}
+ private:
+ void emitTypeProfilerExpressionInfo(const JSTextPosition& startDivot, const JSTextPosition& endDivot);
+ public:
+
+ // This doesn't emit expression info. If using this, make sure you shouldn't be emitting text offset.
+ void emitProfileType(RegisterID* registerToProfile, ProfileTypeBytecodeFlag);
+ // These variables are associated with variables in a program. They could be Locals, LocalClosureVar, or ClosureVar.
+ void emitProfileType(RegisterID* registerToProfile, const Variable&, const JSTextPosition& startDivot, const JSTextPosition& endDivot);
+
+ void emitProfileType(RegisterID* registerToProfile, ProfileTypeBytecodeFlag, const JSTextPosition& startDivot, const JSTextPosition& endDivot);
+ // These are not associated with variables and don't have a global id.
+ void emitProfileType(RegisterID* registerToProfile, const JSTextPosition& startDivot, const JSTextPosition& endDivot);
+
+ void emitProfileControlFlow(int);
+
+ RegisterID* emitLoadArrowFunctionLexicalEnvironment();
+ void emitLoadThisFromArrowFunctionLexicalEnvironment();
+ RegisterID* emitLoadNewTargetFromArrowFunctionLexicalEnvironment();
+
RegisterID* emitLoad(RegisterID* dst, bool);
- RegisterID* emitLoad(RegisterID* dst, double);
RegisterID* emitLoad(RegisterID* dst, const Identifier&);
- RegisterID* emitLoad(RegisterID* dst, JSValue);
+ RegisterID* emitLoad(RegisterID* dst, JSValue, SourceCodeRepresentation = SourceCodeRepresentation::Other);
RegisterID* emitLoadGlobalObject(RegisterID* dst);
RegisterID* emitUnaryOp(OpcodeID, RegisterID* dst, RegisterID* src);
@@ -431,55 +509,72 @@ namespace JSC {
RegisterID* emitUnaryNoDstOp(OpcodeID, RegisterID* src);
RegisterID* emitCreateThis(RegisterID* dst);
+ void emitTDZCheck(RegisterID* target);
+ bool needsTDZCheck(const Variable&);
+ void emitTDZCheckIfNecessary(const Variable&, RegisterID* target, RegisterID* scope);
+ void liftTDZCheckIfPossible(const Variable&);
RegisterID* emitNewObject(RegisterID* dst);
RegisterID* emitNewArray(RegisterID* dst, ElementNode*, unsigned length); // stops at first elision
+ RegisterID* emitNewArrayWithSize(RegisterID* dst, RegisterID* length);
- RegisterID* emitNewFunction(RegisterID* dst, FunctionBodyNode* body);
- RegisterID* emitLazyNewFunction(RegisterID* dst, FunctionBodyNode* body);
- RegisterID* emitNewFunctionInternal(RegisterID* dst, unsigned index, bool shouldNullCheck);
+ RegisterID* emitNewFunction(RegisterID* dst, FunctionMetadataNode*);
RegisterID* emitNewFunctionExpression(RegisterID* dst, FuncExprNode* func);
+ RegisterID* emitNewDefaultConstructor(RegisterID* dst, ConstructorKind, const Identifier& name);
+ RegisterID* emitNewArrowFunctionExpression(RegisterID*, ArrowFuncExprNode*);
RegisterID* emitNewRegExp(RegisterID* dst, RegExp*);
+ RegisterID* emitMoveLinkTimeConstant(RegisterID* dst, LinkTimeConstant);
+ RegisterID* emitMoveEmptyValue(RegisterID* dst);
RegisterID* emitMove(RegisterID* dst, RegisterID* src);
RegisterID* emitToNumber(RegisterID* dst, RegisterID* src) { return emitUnaryOp(op_to_number, dst, src); }
+ RegisterID* emitToString(RegisterID* dst, RegisterID* src) { return emitUnaryOp(op_to_string, dst, src); }
RegisterID* emitInc(RegisterID* srcDst);
RegisterID* emitDec(RegisterID* srcDst);
- void emitCheckHasInstance(RegisterID* dst, RegisterID* value, RegisterID* base, Label* target);
+ RegisterID* emitOverridesHasInstance(RegisterID* dst, RegisterID* constructor, RegisterID* hasInstanceValue);
RegisterID* emitInstanceOf(RegisterID* dst, RegisterID* value, RegisterID* basePrototype);
+ RegisterID* emitInstanceOfCustom(RegisterID* dst, RegisterID* value, RegisterID* constructor, RegisterID* hasInstanceValue);
RegisterID* emitTypeOf(RegisterID* dst, RegisterID* src) { return emitUnaryOp(op_typeof, dst, src); }
RegisterID* emitIn(RegisterID* dst, RegisterID* property, RegisterID* base) { return emitBinaryOp(op_in, dst, property, base, OperandTypes()); }
- RegisterID* emitGetStaticVar(RegisterID* dst, const ResolveResult&, const Identifier&);
- RegisterID* emitPutStaticVar(const ResolveResult&, const Identifier&, RegisterID* value);
- RegisterID* emitInitGlobalConst(const Identifier&, RegisterID* value);
-
- RegisterID* emitResolve(RegisterID* dst, const ResolveResult&, const Identifier& property);
- RegisterID* emitResolveBase(RegisterID* dst, const ResolveResult&, const Identifier& property);
- RegisterID* emitResolveBaseForPut(RegisterID* dst, const ResolveResult&, const Identifier& property, NonlocalResolveInfo&);
- RegisterID* emitResolveWithBaseForPut(RegisterID* baseDst, RegisterID* propDst, const ResolveResult&, const Identifier& property, NonlocalResolveInfo&);
- RegisterID* emitResolveWithThis(RegisterID* baseDst, RegisterID* propDst, const ResolveResult&, const Identifier& property);
-
- RegisterID* emitPutToBase(RegisterID* base, const Identifier&, RegisterID* value, NonlocalResolveInfo&);
-
RegisterID* emitGetById(RegisterID* dst, RegisterID* base, const Identifier& property);
- RegisterID* emitGetArgumentsLength(RegisterID* dst, RegisterID* base);
RegisterID* emitPutById(RegisterID* base, const Identifier& property, RegisterID* value);
- RegisterID* emitDirectPutById(RegisterID* base, const Identifier& property, RegisterID* value);
+ RegisterID* emitDirectPutById(RegisterID* base, const Identifier& property, RegisterID* value, PropertyNode::PutType);
RegisterID* emitDeleteById(RegisterID* dst, RegisterID* base, const Identifier&);
RegisterID* emitGetByVal(RegisterID* dst, RegisterID* base, RegisterID* property);
RegisterID* emitGetArgumentByVal(RegisterID* dst, RegisterID* base, RegisterID* property);
RegisterID* emitPutByVal(RegisterID* base, RegisterID* property, RegisterID* value);
+ RegisterID* emitDirectPutByVal(RegisterID* base, RegisterID* property, RegisterID* value);
RegisterID* emitDeleteByVal(RegisterID* dst, RegisterID* base, RegisterID* property);
RegisterID* emitPutByIndex(RegisterID* base, unsigned index, RegisterID* value);
- void emitPutGetterSetter(RegisterID* base, const Identifier& property, RegisterID* getter, RegisterID* setter);
+
+ RegisterID* emitAssert(RegisterID* condition, int line);
+
+ void emitPutGetterById(RegisterID* base, const Identifier& property, unsigned propertyDescriptorOptions, RegisterID* getter);
+ void emitPutSetterById(RegisterID* base, const Identifier& property, unsigned propertyDescriptorOptions, RegisterID* setter);
+ void emitPutGetterSetter(RegisterID* base, const Identifier& property, unsigned attributes, RegisterID* getter, RegisterID* setter);
+ void emitPutGetterByVal(RegisterID* base, RegisterID* property, unsigned propertyDescriptorOptions, RegisterID* getter);
+ void emitPutSetterByVal(RegisterID* base, RegisterID* property, unsigned propertyDescriptorOptions, RegisterID* setter);
ExpectedFunction expectedFunctionForIdentifier(const Identifier&);
RegisterID* emitCall(RegisterID* dst, RegisterID* func, ExpectedFunction, CallArguments&, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
+ RegisterID* emitCallInTailPosition(RegisterID* dst, RegisterID* func, ExpectedFunction, CallArguments&, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
RegisterID* emitCallEval(RegisterID* dst, RegisterID* func, CallArguments&, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
- RegisterID* emitCallVarargs(RegisterID* dst, RegisterID* func, RegisterID* thisRegister, RegisterID* arguments, RegisterID* firstFreeRegister, RegisterID* profileHookRegister, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
- RegisterID* emitLoadVarargs(RegisterID* argCountDst, RegisterID* thisRegister, RegisterID* args);
+ RegisterID* emitCallVarargs(RegisterID* dst, RegisterID* func, RegisterID* thisRegister, RegisterID* arguments, RegisterID* firstFreeRegister, int32_t firstVarArgOffset, RegisterID* profileHookRegister, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
+ RegisterID* emitCallVarargsInTailPosition(RegisterID* dst, RegisterID* func, RegisterID* thisRegister, RegisterID* arguments, RegisterID* firstFreeRegister, int32_t firstVarArgOffset, RegisterID* profileHookRegister, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
+
+ enum PropertyDescriptorOption {
+ PropertyConfigurable = 1,
+ PropertyWritable = 1 << 1,
+ PropertyEnumerable = 1 << 2,
+ };
+ void emitCallDefineProperty(RegisterID* newObj, RegisterID* propertyNameRegister,
+ RegisterID* valueRegister, RegisterID* getterRegister, RegisterID* setterRegister, unsigned options, const JSTextPosition&);
+
+ void emitEnumeration(ThrowableExpressionData* enumerationNode, ExpressionNode* subjectNode, const std::function<void(BytecodeGenerator&, RegisterID*)>& callBack, VariableEnvironmentNode* = nullptr, RegisterID* forLoopSymbolTable = nullptr);
+
+ RegisterID* emitGetTemplateObject(RegisterID* dst, TaggedTemplateNode*);
RegisterID* emitReturn(RegisterID* src);
RegisterID* emitEnd(RegisterID* src) { return emitUnaryNoDstOp(op_end, src); }
@@ -488,6 +583,13 @@ namespace JSC {
RegisterID* emitStrcat(RegisterID* dst, RegisterID* src, int count);
void emitToPrimitive(RegisterID* dst, RegisterID* src);
+ ResolveType resolveType();
+ RegisterID* emitResolveConstantLocal(RegisterID* dst, const Variable&);
+ RegisterID* emitResolveScope(RegisterID* dst, const Variable&);
+ RegisterID* emitGetFromScope(RegisterID* dst, RegisterID* scope, const Variable&, ResolveMode);
+ RegisterID* emitPutToScope(RegisterID* scope, const Variable&, RegisterID* value, ResolveMode, InitializationMode);
+ RegisterID* initializeVariable(const Variable&, RegisterID* value);
+
PassRefPtr<Label> emitLabel(Label*);
void emitLoopHint();
PassRefPtr<Label> emitJump(Label* target);
@@ -495,17 +597,38 @@ namespace JSC {
PassRefPtr<Label> emitJumpIfFalse(RegisterID* cond, Label* target);
PassRefPtr<Label> emitJumpIfNotFunctionCall(RegisterID* cond, Label* target);
PassRefPtr<Label> emitJumpIfNotFunctionApply(RegisterID* cond, Label* target);
- void emitPopScopes(int targetScopeDepth);
+ void emitPopScopes(RegisterID* srcDst, int targetScopeDepth);
+
+ void emitEnter();
+ void emitWatchdog();
+
+ RegisterID* emitHasIndexedProperty(RegisterID* dst, RegisterID* base, RegisterID* propertyName);
+ RegisterID* emitHasStructureProperty(RegisterID* dst, RegisterID* base, RegisterID* propertyName, RegisterID* enumerator);
+ RegisterID* emitHasGenericProperty(RegisterID* dst, RegisterID* base, RegisterID* propertyName);
+ RegisterID* emitGetPropertyEnumerator(RegisterID* dst, RegisterID* base);
+ RegisterID* emitGetEnumerableLength(RegisterID* dst, RegisterID* base);
+ RegisterID* emitGetStructurePropertyEnumerator(RegisterID* dst, RegisterID* base, RegisterID* length);
+ RegisterID* emitGetGenericPropertyEnumerator(RegisterID* dst, RegisterID* base, RegisterID* length, RegisterID* structureEnumerator);
+ RegisterID* emitEnumeratorStructurePropertyName(RegisterID* dst, RegisterID* enumerator, RegisterID* index);
+ RegisterID* emitEnumeratorGenericPropertyName(RegisterID* dst, RegisterID* enumerator, RegisterID* index);
+ RegisterID* emitToIndexString(RegisterID* dst, RegisterID* index);
+
+ RegisterID* emitIsObject(RegisterID* dst, RegisterID* src);
+ RegisterID* emitIsUndefined(RegisterID* dst, RegisterID* src);
+ void emitRequireObjectCoercible(RegisterID* value, const String& error);
+
+ RegisterID* emitIteratorNext(RegisterID* dst, RegisterID* iterator, const ThrowableExpressionData* node);
+ RegisterID* emitIteratorNextWithValue(RegisterID* dst, RegisterID* iterator, RegisterID* value, const ThrowableExpressionData* node);
+ void emitIteratorClose(RegisterID* iterator, const ThrowableExpressionData* node);
- RegisterID* emitGetPropertyNames(RegisterID* dst, RegisterID* base, RegisterID* i, RegisterID* size, Label* breakTarget);
- RegisterID* emitNextPropertyName(RegisterID* dst, RegisterID* base, RegisterID* i, RegisterID* size, RegisterID* iter, Label* target);
+ RegisterID* emitRestParameter(RegisterID* result, unsigned numParametersToSkip);
- void emitReadOnlyExceptionIfNeeded();
+ bool emitReadOnlyExceptionIfNeeded(const Variable&);
// Start a try block. 'start' must have been emitted.
TryData* pushTry(Label* start);
// End a try block. 'end' must have been emitted.
- RegisterID* popTryAndEmitCatch(TryData*, RegisterID* targetRegister, Label* end);
+ void popTryAndEmitCatch(TryData*, RegisterID* exceptionRegister, RegisterID* thrownValueRegister, Label* end, HandlerType);
void emitThrow(RegisterID* exc)
{
@@ -514,37 +637,54 @@ namespace JSC {
}
void emitThrowReferenceError(const String& message);
+ void emitThrowTypeError(const String& message);
- void emitPushNameScope(const Identifier& property, RegisterID* value, unsigned attributes);
+ void emitPushCatchScope(VariableEnvironment&);
+ void emitPopCatchScope(VariableEnvironment&);
- RegisterID* emitPushWithScope(RegisterID* scope);
- void emitPopScope();
+ void emitGetScope();
+ RegisterID* emitPushWithScope(RegisterID* objectScope);
+ void emitPopWithScope();
+ void emitPutThisToArrowFunctionContextScope();
+ void emitPutNewTargetToArrowFunctionContextScope();
+ void emitPutDerivedConstructorToArrowFunctionContextScope();
+ RegisterID* emitLoadDerivedConstructorFromArrowFunctionLexicalEnvironment();
- void emitDebugHook(DebugHookID, unsigned firstLine, unsigned lastLine, unsigned charOffset, unsigned lineStart);
+ void emitDebugHook(DebugHookID, unsigned line, unsigned charOffset, unsigned lineStart);
- int scopeDepth() { return m_dynamicScopeDepth + m_finallyDepth; }
- bool hasFinaliser() { return m_finallyDepth != 0; }
+ bool isInFinallyBlock() { return m_finallyDepth > 0; }
void pushFinallyContext(StatementNode* finallyBlock);
void popFinallyContext();
+ void pushIteratorCloseContext(RegisterID* iterator, ThrowableExpressionData* enumerationNode);
+ void popIteratorCloseContext();
- void pushOptimisedForIn(RegisterID* expectedBase, RegisterID* iter, RegisterID* index, RegisterID* propertyRegister)
- {
- ForInContext context = { expectedBase, iter, index, propertyRegister };
- m_forInContextStack.append(context);
- }
-
- void popOptimisedForIn()
- {
- m_forInContextStack.removeLast();
- }
+ void pushIndexedForInScope(RegisterID* local, RegisterID* index);
+ void popIndexedForInScope(RegisterID* local);
+ void pushStructureForInScope(RegisterID* local, RegisterID* index, RegisterID* property, RegisterID* enumerator);
+ void popStructureForInScope(RegisterID* local);
+ void invalidateForInContextForLocal(RegisterID* local);
- LabelScope* breakTarget(const Identifier&);
- LabelScope* continueTarget(const Identifier&);
+ LabelScopePtr breakTarget(const Identifier&);
+ LabelScopePtr continueTarget(const Identifier&);
void beginSwitch(RegisterID*, SwitchInfo::SwitchType);
void endSwitch(uint32_t clauseCount, RefPtr<Label>*, ExpressionNode**, Label* defaultLabel, int32_t min, int32_t range);
+ void emitYieldPoint(RegisterID*);
+ void emitSave(Label* mergePoint, unsigned liveCalleeLocalsIndex);
+ void emitResume(Label* mergePoint, unsigned liveCalleeLocalsIndex);
+
+ void emitGeneratorStateLabel();
+ void emitGeneratorStateChange(int32_t state);
+ RegisterID* emitYield(RegisterID* argument);
+ RegisterID* emitDelegateYield(RegisterID* argument, ThrowableExpressionData*);
+ void beginGenerator(RegisterID*);
+ void endGenerator(Label* defaultLabel);
+ RegisterID* generatorStateRegister() { return &m_parameters[2]; }
+ RegisterID* generatorValueRegister() { return &m_parameters[3]; }
+ RegisterID* generatorResumeModeRegister() { return &m_parameters[4]; }
+
CodeType codeType() const { return m_codeType; }
bool shouldEmitProfileHooks() { return m_shouldEmitProfileHooks; }
@@ -552,9 +692,42 @@ namespace JSC {
bool isStrictMode() const { return m_codeBlock->isStrictMode(); }
- private:
- friend class Label;
+ SourceParseMode parseMode() const { return m_codeBlock->parseMode(); }
+
+ bool isBuiltinFunction() const { return m_isBuiltinFunction; }
+
+ OpcodeID lastOpcodeID() const { return m_lastOpcodeID; }
+ bool isDerivedConstructorContext() { return m_derivedContextType == DerivedContextType::DerivedConstructorContext; }
+ bool isDerivedClassContext() { return m_derivedContextType == DerivedContextType::DerivedMethodContext; }
+ bool isArrowFunction() { return m_codeBlock->isArrowFunction(); }
+
+ enum class TDZCheckOptimization { Optimize, DoNotOptimize };
+ enum class NestedScopeType { IsNested, IsNotNested };
+ private:
+ enum class TDZRequirement { UnderTDZ, NotUnderTDZ };
+ enum class ScopeType { CatchScope, LetConstScope, FunctionNameScope };
+ enum class ScopeRegisterType { Var, Block };
+ void pushLexicalScopeInternal(VariableEnvironment&, TDZCheckOptimization, NestedScopeType, RegisterID** constantSymbolTableResult, TDZRequirement, ScopeType, ScopeRegisterType);
+ void popLexicalScopeInternal(VariableEnvironment&, TDZRequirement);
+ template<typename LookUpVarKindFunctor>
+ bool instantiateLexicalVariables(const VariableEnvironment&, SymbolTable*, ScopeRegisterType, LookUpVarKindFunctor);
+ void emitPrefillStackTDZVariables(const VariableEnvironment&, SymbolTable*);
+ void emitPopScope(RegisterID* dst, RegisterID* scope);
+ RegisterID* emitGetParentScope(RegisterID* dst, RegisterID* scope);
+ void emitPushFunctionNameScope(const Identifier& property, RegisterID* value, bool isCaptured);
+ void emitNewFunctionExpressionCommon(RegisterID*, BaseFuncExprNode*);
+
+ public:
+ void pushLexicalScope(VariableEnvironmentNode*, TDZCheckOptimization, NestedScopeType = NestedScopeType::IsNotNested, RegisterID** constantSymbolTableResult = nullptr);
+ void popLexicalScope(VariableEnvironmentNode*);
+ void prepareLexicalScopeForNextForLoopIteration(VariableEnvironmentNode*, RegisterID* loopSymbolTable);
+ int labelScopeDepth() const;
+
+ private:
+ void reclaimFreeRegisters();
+ Variable variableForLocalEntry(const Identifier&, const SymbolTableEntry&, int symbolTableConstantIndex, bool isLexicallyScoped);
+
void emitOpcode(OpcodeID);
UnlinkedArrayAllocationProfile newArrayAllocationProfile();
UnlinkedObjectAllocationProfile newObjectAllocationProfile();
@@ -572,16 +745,13 @@ namespace JSC {
ALWAYS_INLINE void rewindBinaryOp();
ALWAYS_INLINE void rewindUnaryOp();
- void emitComplexPopScopes(ControlFlowContext* topScope, ControlFlowContext* bottomScope);
+ void allocateCalleeSaveSpace();
+ void allocateAndEmitScope();
+ void emitComplexPopScopes(RegisterID*, ControlFlowContext* topScope, ControlFlowContext* bottomScope);
typedef HashMap<double, JSValue> NumberMap;
- typedef HashMap<StringImpl*, JSString*, IdentifierRepHash> IdentifierStringMap;
- typedef struct {
- int resolveOperations;
- int putOperations;
- } ResolveCacheEntry;
- typedef HashMap<StringImpl*, ResolveCacheEntry, IdentifierRepHash> IdentifierResolvePutMap;
- typedef HashMap<StringImpl*, uint32_t, IdentifierRepHash> IdentifierResolveMap;
+ typedef HashMap<UniquedStringImpl*, JSString*, IdentifierRepHash> IdentifierStringMap;
+ typedef HashMap<TemplateRegistryKey, JSTemplateRegistryKey*> TemplateRegistryKeyMap;
// Helper for emitCall() and emitConstruct(). This works because the set of
// expected functions have identical behavior for both call and construct
@@ -592,235 +762,176 @@ namespace JSC {
RegisterID* newRegister();
- // Adds a var slot and maps it to the name ident in symbolTable().
- RegisterID* addVar(const Identifier& ident, bool isConstant)
- {
- RegisterID* local;
- addVar(ident, isConstant, local);
- return local;
- }
-
- // Ditto. Returns true if a new RegisterID was added, false if a pre-existing RegisterID was re-used.
- bool addVar(const Identifier&, bool isConstant, RegisterID*&);
-
- // Adds an anonymous var slot. To give this slot a name, add it to symbolTable().
+ // Adds an anonymous local var slot. To give this slot a name, add it to symbolTable().
RegisterID* addVar()
{
++m_codeBlock->m_numVars;
- return newRegister();
+ RegisterID* result = newRegister();
+ ASSERT(VirtualRegister(result->index()).toLocal() == m_codeBlock->m_numVars - 1);
+ result->ref(); // We should never free this slot.
+ return result;
}
- // Returns the index of the added var.
- void addParameter(const Identifier&, int parameterIndex);
- RegisterID* resolveCallee(FunctionBodyNode*);
- void addCallee(FunctionBodyNode*, RegisterID*);
-
- void preserveLastVar();
- bool shouldAvoidResolveGlobal();
-
- RegisterID& registerFor(int index)
+ // Initializes the stack form the parameter; does nothing for the symbol table.
+ RegisterID* initializeNextParameter();
+ UniquedStringImpl* visibleNameForParameter(DestructuringPatternNode*);
+
+ RegisterID& registerFor(VirtualRegister reg)
{
- if (index >= 0)
- return m_calleeRegisters[index];
+ if (reg.isLocal())
+ return m_calleeLocals[reg.toLocal()];
- if (index == JSStack::Callee)
+ if (reg.offset() == JSStack::Callee)
return m_calleeRegister;
ASSERT(m_parameters.size());
- return m_parameters[index + m_parameters.size() + JSStack::CallFrameHeaderSize];
+ return m_parameters[reg.toArgument()];
}
+ bool hasConstant(const Identifier&) const;
unsigned addConstant(const Identifier&);
- RegisterID* addConstantValue(JSValue);
+ RegisterID* addConstantValue(JSValue, SourceCodeRepresentation = SourceCodeRepresentation::Other);
RegisterID* addConstantEmptyValue();
unsigned addRegExp(RegExp*);
unsigned addConstantBuffer(unsigned length);
- UnlinkedFunctionExecutable* makeFunction(FunctionBodyNode* body)
+ UnlinkedFunctionExecutable* makeFunction(FunctionMetadataNode* metadata)
{
- return UnlinkedFunctionExecutable::create(m_vm, m_scopeNode->source(), body);
- }
-
- RegisterID* emitInitLazyRegister(RegisterID*);
-
- public:
- JSString* addStringConstant(const Identifier&);
-
- Vector<UnlinkedInstruction, 0, UnsafeVectorOverflow>& instructions() { return m_instructions; }
+ DerivedContextType newDerivedContextType = DerivedContextType::None;
- SharedSymbolTable& symbolTable() { return *m_symbolTable; }
+ if (metadata->parseMode() == SourceParseMode::ArrowFunctionMode) {
+ if (constructorKind() == ConstructorKind::Derived || isDerivedConstructorContext())
+ newDerivedContextType = DerivedContextType::DerivedConstructorContext;
+ else if (m_codeBlock->isClassContext() || isDerivedClassContext())
+ newDerivedContextType = DerivedContextType::DerivedMethodContext;
+ }
- bool shouldOptimizeLocals()
- {
- if (m_dynamicScopeDepth)
- return false;
+ VariableEnvironment variablesUnderTDZ;
+ getVariablesUnderTDZ(variablesUnderTDZ);
- if (m_codeType != FunctionCode)
- return false;
+ // FIXME: These flags, ParserModes and propagation to XXXCodeBlocks should be reorganized.
+ // https://bugs.webkit.org/show_bug.cgi?id=151547
+ SourceParseMode parseMode = metadata->parseMode();
+ ConstructAbility constructAbility = ConstructAbility::CanConstruct;
+ if (parseMode == SourceParseMode::GetterMode || parseMode == SourceParseMode::SetterMode || parseMode == SourceParseMode::ArrowFunctionMode || parseMode == SourceParseMode::GeneratorWrapperFunctionMode)
+ constructAbility = ConstructAbility::CannotConstruct;
+ else if (parseMode == SourceParseMode::MethodMode && metadata->constructorKind() == ConstructorKind::None)
+ constructAbility = ConstructAbility::CannotConstruct;
- return true;
+ return UnlinkedFunctionExecutable::create(m_vm, m_scopeNode->source(), metadata, isBuiltinFunction() ? UnlinkedBuiltinFunction : UnlinkedNormalFunction, constructAbility, variablesUnderTDZ, newDerivedContextType);
}
- bool canOptimizeNonLocals()
- {
- if (m_dynamicScopeDepth)
- return false;
+ void getVariablesUnderTDZ(VariableEnvironment&);
- if (m_codeType == EvalCode)
- return false;
+ RegisterID* emitConstructVarargs(RegisterID* dst, RegisterID* func, RegisterID* thisRegister, RegisterID* arguments, RegisterID* firstFreeRegister, int32_t firstVarArgOffset, RegisterID* profileHookRegister, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
+ RegisterID* emitCallVarargs(OpcodeID, RegisterID* dst, RegisterID* func, RegisterID* thisRegister, RegisterID* arguments, RegisterID* firstFreeRegister, int32_t firstVarArgOffset, RegisterID* profileHookRegister, const JSTextPosition& divot, const JSTextPosition& divotStart, const JSTextPosition& divotEnd);
- if (m_codeType == FunctionCode && m_codeBlock->usesEval())
- return false;
+ void initializeParameters(FunctionParameters&);
+ void initializeVarLexicalEnvironment(int symbolTableConstantIndex);
+ void initializeDefaultParameterValuesAndSetupFunctionScopeStack(FunctionParameters&, FunctionNode*, SymbolTable*, int symbolTableConstantIndex, const std::function<bool (UniquedStringImpl*)>& captures);
+ void initializeArrowFunctionContextScopeIfNeeded(SymbolTable* = nullptr);
- return true;
- }
+ public:
+ JSString* addStringConstant(const Identifier&);
+ JSTemplateRegistryKey* addTemplateRegistryKeyConstant(const TemplateRegistryKey&);
+
+ Vector<UnlinkedInstruction, 0, UnsafeVectorOverflow>& instructions() { return m_instructions; }
RegisterID* emitThrowExpressionTooDeepException();
- void createArgumentsIfNecessary();
- void createActivationIfNecessary();
- RegisterID* createLazyRegisterIfNecessary(RegisterID*);
-
+ private:
Vector<UnlinkedInstruction, 0, UnsafeVectorOverflow> m_instructions;
bool m_shouldEmitDebugHooks;
bool m_shouldEmitProfileHooks;
- SharedSymbolTable* m_symbolTable;
+ struct SymbolTableStackEntry {
+ Strong<SymbolTable> m_symbolTable;
+ RegisterID* m_scope;
+ bool m_isWithScope;
+ int m_symbolTableConstantIndex;
+ };
+ Vector<SymbolTableStackEntry> m_symbolTableStack;
+ Vector<std::pair<VariableEnvironment, bool>> m_TDZStack;
- ScopeNode* m_scopeNode;
- Strong<JSScope> m_scope;
+ ScopeNode* const m_scopeNode;
Strong<UnlinkedCodeBlock> m_codeBlock;
// Some of these objects keep pointers to one another. They are arranged
// to ensure a sane destruction order that avoids references to freed memory.
- HashSet<RefPtr<StringImpl>, IdentifierRepHash> m_functions;
+ HashSet<RefPtr<UniquedStringImpl>, IdentifierRepHash> m_functions;
RegisterID m_ignoredResultRegister;
RegisterID m_thisRegister;
RegisterID m_calleeRegister;
- RegisterID* m_activationRegister;
- RegisterID* m_emptyValueRegister;
- RegisterID* m_globalObjectRegister;
+ RegisterID* m_scopeRegister { nullptr };
+ RegisterID* m_topMostScope { nullptr };
+ RegisterID* m_argumentsRegister { nullptr };
+ RegisterID* m_lexicalEnvironmentRegister { nullptr };
+ RegisterID* m_generatorRegister { nullptr };
+ RegisterID* m_emptyValueRegister { nullptr };
+ RegisterID* m_globalObjectRegister { nullptr };
+ RegisterID* m_newTargetRegister { nullptr };
+ RegisterID* m_linkTimeConstantRegisters[LinkTimeConstantCount];
+ RegisterID* m_arrowFunctionContextLexicalEnvironmentRegister { nullptr };
+
+ SegmentedVector<RegisterID*, 16> m_localRegistersForCalleeSaveRegisters;
SegmentedVector<RegisterID, 32> m_constantPoolRegisters;
- SegmentedVector<RegisterID, 32> m_calleeRegisters;
+ SegmentedVector<RegisterID, 32> m_calleeLocals;
SegmentedVector<RegisterID, 32> m_parameters;
SegmentedVector<Label, 32> m_labels;
LabelScopeStore m_labelScopes;
- RefPtr<RegisterID> m_lastVar;
- int m_finallyDepth;
- int m_dynamicScopeDepth;
- CodeType m_codeType;
+ int m_finallyDepth { 0 };
+ int m_localScopeDepth { 0 };
+ const CodeType m_codeType;
+
+ int localScopeDepth() const;
+ void pushScopedControlFlowContext();
+ void popScopedControlFlowContext();
Vector<ControlFlowContext, 0, UnsafeVectorOverflow> m_scopeContextStack;
Vector<SwitchInfo> m_switchContextStack;
- Vector<ForInContext> m_forInContextStack;
+ Vector<std::unique_ptr<ForInContext>> m_forInContextStack;
Vector<TryContext> m_tryContextStack;
+ Vector<RefPtr<Label>> m_generatorResumeLabels;
+ enum FunctionVariableType : uint8_t { NormalFunctionVariable, GlobalFunctionVariable };
+ Vector<std::pair<FunctionMetadataNode*, FunctionVariableType>> m_functionsToInitialize;
+ bool m_needToInitializeArguments { false };
+ RestParameterNode* m_restParameter { nullptr };
Vector<TryRange> m_tryRanges;
SegmentedVector<TryData, 8> m_tryData;
- int m_firstConstantIndex;
- int m_nextConstantOffset;
- unsigned m_globalConstantIndex;
-
- int m_globalVarStorageOffset;
+ int m_nextConstantOffset { 0 };
- bool m_hasCreatedActivation;
- int m_firstLazyFunction;
- int m_lastLazyFunction;
- HashMap<unsigned int, FunctionBodyNode*, WTF::IntHash<unsigned int>, WTF::UnsignedWithZeroKeyHashTraits<unsigned int> > m_lazyFunctions;
- typedef HashMap<FunctionBodyNode*, unsigned> FunctionOffsetMap;
+ typedef HashMap<FunctionMetadataNode*, unsigned> FunctionOffsetMap;
FunctionOffsetMap m_functionOffsets;
// Constant pool
IdentifierMap m_identifierMap;
+
+ typedef HashMap<EncodedJSValueWithRepresentation, unsigned, EncodedJSValueWithRepresentationHash, EncodedJSValueWithRepresentationHashTraits> JSValueMap;
JSValueMap m_jsValueMap;
- NumberMap m_numberMap;
IdentifierStringMap m_stringMap;
+ TemplateRegistryKeyMap m_templateRegistryKeyMap;
- uint32_t getResolveOperations(const Identifier& property)
- {
- if (m_dynamicScopeDepth)
- return m_codeBlock->addResolve();
- IdentifierResolveMap::AddResult result = m_resolveCacheMap.add(property.impl(), 0);
- if (result.isNewEntry)
- result.iterator->value = m_codeBlock->addResolve();
- return result.iterator->value;
- }
-
- uint32_t getResolveWithThisOperations(const Identifier& property)
- {
- if (m_dynamicScopeDepth)
- return m_codeBlock->addResolve();
- IdentifierResolveMap::AddResult result = m_resolveWithThisCacheMap.add(property.impl(), 0);
- if (result.isNewEntry)
- result.iterator->value = m_codeBlock->addResolve();
- return result.iterator->value;
- }
-
- uint32_t getResolveBaseOperations(IdentifierResolvePutMap& map, const Identifier& property, uint32_t& putToBaseOperation)
- {
- if (m_dynamicScopeDepth) {
- putToBaseOperation = m_codeBlock->addPutToBase();
- return m_codeBlock->addResolve();
- }
- ResolveCacheEntry entry = {-1, -1};
- IdentifierResolvePutMap::AddResult result = map.add(property.impl(), entry);
- if (result.isNewEntry)
- result.iterator->value.resolveOperations = m_codeBlock->addResolve();
- if (result.iterator->value.putOperations == -1)
- result.iterator->value.putOperations = getPutToBaseOperation(property);
- putToBaseOperation = result.iterator->value.putOperations;
- return result.iterator->value.resolveOperations;
- }
-
- uint32_t getResolveBaseOperations(const Identifier& property)
- {
- uint32_t scratch;
- return getResolveBaseOperations(m_resolveBaseMap, property, scratch);
- }
-
- uint32_t getResolveBaseForPutOperations(const Identifier& property, uint32_t& putToBaseOperation)
- {
- return getResolveBaseOperations(m_resolveBaseForPutMap, property, putToBaseOperation);
- }
-
- uint32_t getResolveWithBaseForPutOperations(const Identifier& property, uint32_t& putToBaseOperation)
- {
- return getResolveBaseOperations(m_resolveWithBaseForPutMap, property, putToBaseOperation);
- }
-
- uint32_t getPutToBaseOperation(const Identifier& property)
- {
- if (m_dynamicScopeDepth)
- return m_codeBlock->addPutToBase();
- IdentifierResolveMap::AddResult result = m_putToBaseMap.add(property.impl(), 0);
- if (result.isNewEntry)
- result.iterator->value = m_codeBlock->addPutToBase();
- return result.iterator->value;
- }
-
- IdentifierResolveMap m_putToBaseMap;
- IdentifierResolveMap m_resolveCacheMap;
- IdentifierResolveMap m_resolveWithThisCacheMap;
- IdentifierResolvePutMap m_resolveBaseMap;
- IdentifierResolvePutMap m_resolveBaseForPutMap;
- IdentifierResolvePutMap m_resolveWithBaseForPutMap;
-
- StaticPropertyAnalyzer m_staticPropertyAnalyzer;
+ StaticPropertyAnalyzer m_staticPropertyAnalyzer { &m_instructions };
VM* m_vm;
- OpcodeID m_lastOpcodeID;
+ OpcodeID m_lastOpcodeID = op_end;
#ifndef NDEBUG
- size_t m_lastOpcodePosition;
+ size_t m_lastOpcodePosition { 0 };
#endif
- VMStackBounds m_stack;
-
- bool m_usesExceptions;
- bool m_expressionTooDeep;
+ bool m_usesExceptions { false };
+ bool m_expressionTooDeep { false };
+ bool m_isBuiltinFunction { false };
+ bool m_usesNonStrictEval { false };
+ bool m_inTailPosition { false };
+ bool m_needsToUpdateArrowFunctionContext;
+ bool m_isNewTargetLoadedInArrowFunction { false };
+ DerivedContextType m_derivedContextType { DerivedContextType::None };
};
}
diff --git a/Source/JavaScriptCore/bytecompiler/Label.h b/Source/JavaScriptCore/bytecompiler/Label.h
index d29ab8ff3..b76c648bf 100644
--- a/Source/JavaScriptCore/bytecompiler/Label.h
+++ b/Source/JavaScriptCore/bytecompiler/Label.h
@@ -10,7 +10,7 @@
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
- * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ * 3. Neither the name of Apple Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
@@ -41,7 +41,7 @@ namespace JSC {
class Label {
public:
- explicit Label(BytecodeGenerator* generator)
+ explicit Label(BytecodeGenerator& generator)
: m_refCount(0)
, m_location(invalidLocation)
, m_generator(generator)
@@ -82,7 +82,7 @@ namespace JSC {
int m_refCount;
unsigned m_location;
- BytecodeGenerator* m_generator;
+ BytecodeGenerator& m_generator;
mutable JumpVector m_unresolvedJumps;
};
diff --git a/Source/JavaScriptCore/bytecompiler/LabelScope.h b/Source/JavaScriptCore/bytecompiler/LabelScope.h
index 2df6f1b9b..9b84cb3f9 100644
--- a/Source/JavaScriptCore/bytecompiler/LabelScope.h
+++ b/Source/JavaScriptCore/bytecompiler/LabelScope.h
@@ -10,7 +10,7 @@
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
- * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ * 3. Neither the name of Apple Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
@@ -85,8 +85,8 @@ namespace JSC {
, m_index(0)
{
}
- LabelScopePtr(LabelScopeStore* owner, size_t index)
- : m_owner(owner)
+ LabelScopePtr(LabelScopeStore& owner, size_t index)
+ : m_owner(&owner)
, m_index(index)
{
m_owner->at(index).ref();
@@ -117,11 +117,15 @@ namespace JSC {
m_owner->at(m_index).deref();
}
+ bool operator!() const { return !m_owner; }
+
LabelScope& operator*() { ASSERT(m_owner); return m_owner->at(m_index); }
LabelScope* operator->() { ASSERT(m_owner); return &m_owner->at(m_index); }
const LabelScope& operator*() const { ASSERT(m_owner); return m_owner->at(m_index); }
const LabelScope* operator->() const { ASSERT(m_owner); return &m_owner->at(m_index); }
+ static LabelScopePtr null() { return LabelScopePtr(); }
+
private:
LabelScopeStore* m_owner;
size_t m_index;
diff --git a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp b/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
index 2062df3d9..4f6e8fbb4 100644
--- a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
+++ b/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp
@@ -1,7 +1,7 @@
/*
* Copyright (C) 1999-2002 Harri Porten (porten@kde.org)
* Copyright (C) 2001 Peter Kelly (pmk@post.com)
-* Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012, 2013 Apple Inc. All rights reserved.
+* Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012, 2013, 2015 Apple Inc. All rights reserved.
* Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
* Copyright (C) 2007 Maks Orlovich
* Copyright (C) 2007 Eric Seidel <eric@webkit.org>
@@ -28,21 +28,26 @@
#include "Nodes.h"
#include "NodeConstructors.h"
+#include "BuiltinNames.h"
#include "BytecodeGenerator.h"
#include "CallFrame.h"
#include "Debugger.h"
#include "JIT.h"
#include "JSFunction.h"
+#include "JSGeneratorFunction.h"
#include "JSGlobalObject.h"
-#include "JSNameScope.h"
+#include "JSONObject.h"
#include "LabelScope.h"
#include "Lexer.h"
-#include "Operations.h"
+#include "JSCInlines.h"
+#include "JSTemplateRegistryKey.h"
#include "Parser.h"
#include "PropertyNameArray.h"
#include "RegExpCache.h"
#include "RegExpObject.h"
#include "SamplingTool.h"
+#include "StackAlignment.h"
+#include "TemplateRegistryKey.h"
#include <wtf/Assertions.h>
#include <wtf/RefCountedLeakCounter.h>
#include <wtf/Threading.h>
@@ -119,6 +124,15 @@ JSValue StringNode::jsValue(BytecodeGenerator& generator) const
return generator.addStringConstant(m_value);
}
+// ------------------------------ NumberNode ----------------------------------
+
+RegisterID* NumberNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (dst == generator.ignoredResult())
+ return nullptr;
+ return generator.emitLoad(dst, jsValue(generator), isIntegerNode() ? SourceCodeRepresentation::Integer : SourceCodeRepresentation::Double);
+}
+
// ------------------------------ RegExpNode -----------------------------------
RegisterID* RegExpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
@@ -132,30 +146,197 @@ RegisterID* RegExpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* d
RegisterID* ThisNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
+ if (generator.constructorKind() == ConstructorKind::Derived && generator.needsToUpdateArrowFunctionContext())
+ generator.emitLoadThisFromArrowFunctionLexicalEnvironment();
+
+ if (m_shouldAlwaysEmitTDZCheck || generator.constructorKind() == ConstructorKind::Derived || generator.isDerivedConstructorContext())
+ generator.emitTDZCheck(generator.thisRegister());
+
if (dst == generator.ignoredResult())
return 0;
- return generator.moveToDestinationIfNeeded(dst, generator.thisRegister());
+
+ RegisterID* result = generator.moveToDestinationIfNeeded(dst, generator.thisRegister());
+ static const unsigned thisLength = 4;
+ generator.emitProfileType(generator.thisRegister(), position(), JSTextPosition(-1, position().offset + thisLength, -1));
+ return result;
+}
+
+// ------------------------------ SuperNode -------------------------------------
+
+RegisterID* SuperNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (dst == generator.ignoredResult())
+ return 0;
+
+ if (generator.isDerivedConstructorContext())
+ return generator.emitGetById(generator.finalDestination(dst), generator.emitLoadDerivedConstructorFromArrowFunctionLexicalEnvironment(), generator.propertyNames().underscoreProto);
+
+ RegisterID callee;
+ callee.setIndex(JSStack::Callee);
+ return generator.emitGetById(generator.finalDestination(dst), &callee, generator.propertyNames().underscoreProto);
+}
+
+static RegisterID* emitHomeObjectForCallee(BytecodeGenerator& generator)
+{
+ if (generator.isDerivedClassContext() || generator.isDerivedConstructorContext()) {
+ RegisterID* derivedConstructor = generator.emitLoadDerivedConstructorFromArrowFunctionLexicalEnvironment();
+ return generator.emitGetById(generator.newTemporary(), derivedConstructor, generator.propertyNames().homeObjectPrivateName);
+ }
+
+ RegisterID callee;
+ callee.setIndex(JSStack::Callee);
+ return generator.emitGetById(generator.newTemporary(), &callee, generator.propertyNames().homeObjectPrivateName);
+}
+
+static RegisterID* emitSuperBaseForCallee(BytecodeGenerator& generator)
+{
+ RefPtr<RegisterID> homeObject = emitHomeObjectForCallee(generator);
+ return generator.emitGetById(generator.newTemporary(), homeObject.get(), generator.propertyNames().underscoreProto);
+}
+
+// ------------------------------ NewTargetNode ----------------------------------
+
+RegisterID* NewTargetNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (dst == generator.ignoredResult())
+ return nullptr;
+
+ return generator.moveToDestinationIfNeeded(dst, generator.newTarget());
}
// ------------------------------ ResolveNode ----------------------------------
bool ResolveNode::isPure(BytecodeGenerator& generator) const
{
- return generator.resolve(m_ident).isStatic();
+ return generator.variable(m_ident).offset().isStack();
}
RegisterID* ResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- ResolveResult resolveResult = generator.resolve(m_ident);
- if (RegisterID* local = resolveResult.local()) {
+ Variable var = generator.variable(m_ident);
+ if (RegisterID* local = var.local()) {
+ generator.emitTDZCheckIfNecessary(var, local, nullptr);
if (dst == generator.ignoredResult())
- return 0;
+ return nullptr;
+
+ generator.emitProfileType(local, var, m_position, JSTextPosition(-1, m_position.offset + m_ident.length(), -1));
return generator.moveToDestinationIfNeeded(dst, local);
}
-
+
JSTextPosition divot = m_start + m_ident.length();
generator.emitExpressionInfo(divot, m_start, divot);
- return generator.emitResolve(generator.finalDestination(dst), resolveResult, m_ident);
+ RefPtr<RegisterID> scope = generator.emitResolveScope(dst, var);
+ RegisterID* finalDest = generator.finalDestination(dst);
+ RegisterID* result = generator.emitGetFromScope(finalDest, scope.get(), var, ThrowIfNotFound);
+ generator.emitTDZCheckIfNecessary(var, finalDest, nullptr);
+ generator.emitProfileType(finalDest, var, m_position, JSTextPosition(-1, m_position.offset + m_ident.length(), -1));
+ return result;
+}
+
+// ------------------------------ TemplateStringNode -----------------------------------
+
+RegisterID* TemplateStringNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (dst == generator.ignoredResult())
+ return nullptr;
+ return generator.emitLoad(dst, JSValue(generator.addStringConstant(cooked())));
+}
+
+// ------------------------------ TemplateLiteralNode -----------------------------------
+
+RegisterID* TemplateLiteralNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (!m_templateExpressions) {
+ TemplateStringNode* templateString = m_templateStrings->value();
+ ASSERT_WITH_MESSAGE(!m_templateStrings->next(), "Only one template element exists because there's no expression in a given template literal.");
+ return generator.emitNode(dst, templateString);
+ }
+
+ Vector<RefPtr<RegisterID>, 16> temporaryRegisters;
+
+ TemplateStringListNode* templateString = m_templateStrings;
+ TemplateExpressionListNode* templateExpression = m_templateExpressions;
+ for (; templateExpression; templateExpression = templateExpression->next(), templateString = templateString->next()) {
+ // Evaluate TemplateString.
+ if (!templateString->value()->cooked().isEmpty()) {
+ temporaryRegisters.append(generator.newTemporary());
+ generator.emitNode(temporaryRegisters.last().get(), templateString->value());
+ }
+
+ // Evaluate Expression.
+ temporaryRegisters.append(generator.newTemporary());
+ generator.emitNode(temporaryRegisters.last().get(), templateExpression->value());
+ generator.emitToString(temporaryRegisters.last().get(), temporaryRegisters.last().get());
+ }
+
+ // Evaluate tail TemplateString.
+ if (!templateString->value()->cooked().isEmpty()) {
+ temporaryRegisters.append(generator.newTemporary());
+ generator.emitNode(temporaryRegisters.last().get(), templateString->value());
+ }
+
+ return generator.emitStrcat(generator.finalDestination(dst, temporaryRegisters[0].get()), temporaryRegisters[0].get(), temporaryRegisters.size());
+}
+
+// ------------------------------ TaggedTemplateNode -----------------------------------
+
+RegisterID* TaggedTemplateNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ ExpectedFunction expectedFunction = NoExpectedFunction;
+ RefPtr<RegisterID> tag = nullptr;
+ RefPtr<RegisterID> base = nullptr;
+ if (!m_tag->isLocation()) {
+ tag = generator.newTemporary();
+ tag = generator.emitNode(tag.get(), m_tag);
+ } else if (m_tag->isResolveNode()) {
+ ResolveNode* resolve = static_cast<ResolveNode*>(m_tag);
+ const Identifier& identifier = resolve->identifier();
+ expectedFunction = generator.expectedFunctionForIdentifier(identifier);
+
+ Variable var = generator.variable(identifier);
+ if (RegisterID* local = var.local())
+ tag = generator.emitMove(generator.newTemporary(), local);
+ else {
+ tag = generator.newTemporary();
+ base = generator.newTemporary();
+
+ JSTextPosition newDivot = divotStart() + identifier.length();
+ generator.emitExpressionInfo(newDivot, divotStart(), newDivot);
+ generator.moveToDestinationIfNeeded(base.get(), generator.emitResolveScope(base.get(), var));
+ generator.emitGetFromScope(tag.get(), base.get(), var, ThrowIfNotFound);
+ }
+ } else if (m_tag->isBracketAccessorNode()) {
+ BracketAccessorNode* bracket = static_cast<BracketAccessorNode*>(m_tag);
+ base = generator.newTemporary();
+ base = generator.emitNode(base.get(), bracket->base());
+ RefPtr<RegisterID> property = generator.emitNode(bracket->subscript());
+ tag = generator.emitGetByVal(generator.newTemporary(), base.get(), property.get());
+ } else {
+ ASSERT(m_tag->isDotAccessorNode());
+ DotAccessorNode* dot = static_cast<DotAccessorNode*>(m_tag);
+ base = generator.newTemporary();
+ base = generator.emitNode(base.get(), dot->base());
+ tag = generator.emitGetById(generator.newTemporary(), base.get(), dot->identifier());
+ }
+
+ RefPtr<RegisterID> templateObject = generator.emitGetTemplateObject(generator.newTemporary(), this);
+
+ unsigned expressionsCount = 0;
+ for (TemplateExpressionListNode* templateExpression = m_templateLiteral->templateExpressions(); templateExpression; templateExpression = templateExpression->next())
+ ++expressionsCount;
+
+ CallArguments callArguments(generator, nullptr, 1 + expressionsCount);
+ if (base)
+ generator.emitMove(callArguments.thisRegister(), base.get());
+ else
+ generator.emitLoad(callArguments.thisRegister(), jsUndefined());
+
+ unsigned argumentIndex = 0;
+ generator.emitMove(callArguments.argumentRegister(argumentIndex++), templateObject.get());
+ for (TemplateExpressionListNode* templateExpression = m_templateLiteral->templateExpressions(); templateExpression; templateExpression = templateExpression->next())
+ generator.emitNode(callArguments.argumentRegister(argumentIndex++), templateExpression->value());
+
+ return generator.emitCall(generator.finalDestination(dst, tag.get()), tag.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd());
}
// ------------------------------ ArrayNode ------------------------------------
@@ -167,7 +348,7 @@ RegisterID* ArrayNode::emitBytecode(BytecodeGenerator& generator, RegisterID* ds
unsigned length = 0;
ElementNode* firstPutElement;
for (firstPutElement = m_element; firstPutElement; firstPutElement = firstPutElement->next()) {
- if (firstPutElement->elision())
+ if (firstPutElement->elision() || firstPutElement->value()->isSpreadExpression())
break;
++length;
}
@@ -176,8 +357,10 @@ RegisterID* ArrayNode::emitBytecode(BytecodeGenerator& generator, RegisterID* ds
return generator.emitNewArray(generator.finalDestination(dst), m_element, length);
RefPtr<RegisterID> array = generator.emitNewArray(generator.tempDestination(dst), m_element, length);
-
- for (ElementNode* n = firstPutElement; n; n = n->next()) {
+ ElementNode* n = firstPutElement;
+ for (; n; n = n->next()) {
+ if (n->value()->isSpreadExpression())
+ goto handleSpread;
RegisterID* value = generator.emitNode(n->value());
length += n->elision();
generator.emitPutByIndex(array.get(), length++, value);
@@ -189,6 +372,31 @@ RegisterID* ArrayNode::emitBytecode(BytecodeGenerator& generator, RegisterID* ds
}
return generator.moveToDestinationIfNeeded(dst, array.get());
+
+handleSpread:
+ RefPtr<RegisterID> index = generator.emitLoad(generator.newTemporary(), jsNumber(length));
+ auto spreader = [array, index](BytecodeGenerator& generator, RegisterID* value)
+ {
+ generator.emitDirectPutByVal(array.get(), index.get(), value);
+ generator.emitInc(index.get());
+ };
+ for (; n; n = n->next()) {
+ if (n->elision())
+ generator.emitBinaryOp(op_add, index.get(), index.get(), generator.emitLoad(0, jsNumber(n->elision())), OperandTypes(ResultType::numberTypeIsInt32(), ResultType::numberTypeIsInt32()));
+ if (n->value()->isSpreadExpression()) {
+ SpreadExpressionNode* spread = static_cast<SpreadExpressionNode*>(n->value());
+ generator.emitEnumeration(spread, spread->expression(), spreader);
+ } else {
+ generator.emitDirectPutByVal(array.get(), index.get(), generator.emitNode(n->value()));
+ generator.emitInc(index.get());
+ }
+ }
+
+ if (m_elision) {
+ generator.emitBinaryOp(op_add, index.get(), index.get(), generator.emitLoad(0, jsNumber(m_elision)), OperandTypes(ResultType::numberTypeIsInt32(), ResultType::numberTypeIsInt32()));
+ generator.emitPutById(array.get(), generator.propertyNames().length, index.get());
+ }
+ return generator.moveToDestinationIfNeeded(dst, array.get());
}
bool ArrayNode::isSimpleArray() const
@@ -202,7 +410,7 @@ bool ArrayNode::isSimpleArray() const
return true;
}
-ArgumentListNode* ArrayNode::toArgumentList(VM* vm, int lineNumber, int startPosition) const
+ArgumentListNode* ArrayNode::toArgumentList(ParserArena& parserArena, int lineNumber, int startPosition) const
{
ASSERT(!m_elision && !m_optional);
ElementNode* ptr = m_element;
@@ -211,12 +419,12 @@ ArgumentListNode* ArrayNode::toArgumentList(VM* vm, int lineNumber, int startPos
JSTokenLocation location;
location.line = lineNumber;
location.startOffset = startPosition;
- ArgumentListNode* head = new (vm) ArgumentListNode(location, ptr->value());
+ ArgumentListNode* head = new (parserArena) ArgumentListNode(location, ptr->value());
ArgumentListNode* tail = head;
ptr = ptr->next();
for (; ptr; ptr = ptr->next()) {
ASSERT(!ptr->elision());
- tail = new (vm) ArgumentListNode(location, tail, ptr->value());
+ tail = new (parserArena) ArgumentListNode(location, tail, ptr->value());
}
return head;
}
@@ -225,134 +433,223 @@ ArgumentListNode* ArrayNode::toArgumentList(VM* vm, int lineNumber, int startPos
RegisterID* ObjectLiteralNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- if (!m_list) {
- if (dst == generator.ignoredResult())
- return 0;
- return generator.emitNewObject(generator.finalDestination(dst));
- }
- return generator.emitNode(dst, m_list);
+ if (!m_list) {
+ if (dst == generator.ignoredResult())
+ return 0;
+ return generator.emitNewObject(generator.finalDestination(dst));
+ }
+ RefPtr<RegisterID> newObj = generator.emitNewObject(generator.tempDestination(dst));
+ generator.emitNode(newObj.get(), m_list);
+ return generator.moveToDestinationIfNeeded(dst, newObj.get());
}
// ------------------------------ PropertyListNode -----------------------------
+static inline void emitPutHomeObject(BytecodeGenerator& generator, RegisterID* function, RegisterID* homeObject)
+{
+ generator.emitPutById(function, generator.propertyNames().homeObjectPrivateName, homeObject);
+}
+
RegisterID* PropertyListNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- RefPtr<RegisterID> newObj = generator.tempDestination(dst);
-
- generator.emitNewObject(newObj.get());
-
// Fast case: this loop just handles regular value properties.
PropertyListNode* p = this;
- for (; p && p->m_node->m_type == PropertyNode::Constant; p = p->m_next)
- generator.emitDirectPutById(newObj.get(), p->m_node->name(), generator.emitNode(p->m_node->m_assign));
+ for (; p && (p->m_node->m_type & PropertyNode::Constant); p = p->m_next)
+ emitPutConstantProperty(generator, dst, *p->m_node);
// Were there any get/set properties?
if (p) {
+ // Build a list of getter/setter pairs to try to put them at the same time. If we encounter
+ // a computed property, just emit everything as that may override previous values.
+ bool hasComputedProperty = false;
+
typedef std::pair<PropertyNode*, PropertyNode*> GetterSetterPair;
- typedef HashMap<StringImpl*, GetterSetterPair> GetterSetterMap;
+ typedef HashMap<UniquedStringImpl*, GetterSetterPair, IdentifierRepHash> GetterSetterMap;
GetterSetterMap map;
// Build a map, pairing get/set values together.
for (PropertyListNode* q = p; q; q = q->m_next) {
PropertyNode* node = q->m_node;
- if (node->m_type == PropertyNode::Constant)
+ if (node->m_type & PropertyNode::Computed) {
+ hasComputedProperty = true;
+ break;
+ }
+ if (node->m_type & PropertyNode::Constant)
continue;
- GetterSetterPair pair(node, static_cast<PropertyNode*>(0));
- GetterSetterMap::AddResult result = map.add(node->name().impl(), pair);
- if (!result.isNewEntry)
- result.iterator->value.second = node;
+ // Duplicates are possible.
+ GetterSetterPair pair(node, static_cast<PropertyNode*>(nullptr));
+ GetterSetterMap::AddResult result = map.add(node->name()->impl(), pair);
+ if (!result.isNewEntry) {
+ if (result.iterator->value.first->m_type == node->m_type)
+ result.iterator->value.first = node;
+ else
+ result.iterator->value.second = node;
+ }
}
// Iterate over the remaining properties in the list.
for (; p; p = p->m_next) {
PropertyNode* node = p->m_node;
- RegisterID* value = generator.emitNode(node->m_assign);
// Handle regular values.
- if (node->m_type == PropertyNode::Constant) {
- generator.emitDirectPutById(newObj.get(), node->name(), value);
+ if (node->m_type & PropertyNode::Constant) {
+ emitPutConstantProperty(generator, dst, *node);
+ continue;
+ }
+
+ RefPtr<RegisterID> value = generator.emitNode(node->m_assign);
+ bool isClassProperty = node->needsSuperBinding();
+ if (isClassProperty)
+ emitPutHomeObject(generator, value.get(), dst);
+ unsigned attribute = isClassProperty ? (Accessor | DontEnum) : Accessor;
+
+ ASSERT(node->m_type & (PropertyNode::Getter | PropertyNode::Setter));
+
+ // This is a get/set property which may be overridden by a computed property later.
+ if (hasComputedProperty) {
+ // Computed accessors.
+ if (node->m_type & PropertyNode::Computed) {
+ RefPtr<RegisterID> propertyName = generator.emitNode(node->m_expression);
+ if (node->m_type & PropertyNode::Getter)
+ generator.emitPutGetterByVal(dst, propertyName.get(), attribute, value.get());
+ else
+ generator.emitPutSetterByVal(dst, propertyName.get(), attribute, value.get());
+ continue;
+ }
+
+ if (node->m_type & PropertyNode::Getter)
+ generator.emitPutGetterById(dst, *node->name(), attribute, value.get());
+ else
+ generator.emitPutSetterById(dst, *node->name(), attribute, value.get());
continue;
}
- // This is a get/set property, find its entry in the map.
- ASSERT(node->m_type == PropertyNode::Getter || node->m_type == PropertyNode::Setter);
- GetterSetterMap::iterator it = map.find(node->name().impl());
+ // This is a get/set property pair.
+ GetterSetterMap::iterator it = map.find(node->name()->impl());
ASSERT(it != map.end());
GetterSetterPair& pair = it->value;
// Was this already generated as a part of its partner?
if (pair.second == node)
continue;
-
+
// Generate the paired node now.
RefPtr<RegisterID> getterReg;
RefPtr<RegisterID> setterReg;
+ RegisterID* secondReg = nullptr;
- if (node->m_type == PropertyNode::Getter) {
+ if (node->m_type & PropertyNode::Getter) {
getterReg = value;
if (pair.second) {
- ASSERT(pair.second->m_type == PropertyNode::Setter);
+ ASSERT(pair.second->m_type & PropertyNode::Setter);
setterReg = generator.emitNode(pair.second->m_assign);
+ secondReg = setterReg.get();
} else {
setterReg = generator.newTemporary();
generator.emitLoad(setterReg.get(), jsUndefined());
}
} else {
- ASSERT(node->m_type == PropertyNode::Setter);
+ ASSERT(node->m_type & PropertyNode::Setter);
setterReg = value;
if (pair.second) {
- ASSERT(pair.second->m_type == PropertyNode::Getter);
+ ASSERT(pair.second->m_type & PropertyNode::Getter);
getterReg = generator.emitNode(pair.second->m_assign);
+ secondReg = getterReg.get();
} else {
getterReg = generator.newTemporary();
generator.emitLoad(getterReg.get(), jsUndefined());
}
}
- generator.emitPutGetterSetter(newObj.get(), node->name(), getterReg.get(), setterReg.get());
+ ASSERT(!pair.second || isClassProperty == pair.second->needsSuperBinding());
+ if (isClassProperty && pair.second)
+ emitPutHomeObject(generator, secondReg, dst);
+
+ generator.emitPutGetterSetter(dst, *node->name(), attribute, getterReg.get(), setterReg.get());
}
}
- return generator.moveToDestinationIfNeeded(dst, newObj.get());
+ return dst;
+}
+
+void PropertyListNode::emitPutConstantProperty(BytecodeGenerator& generator, RegisterID* newObj, PropertyNode& node)
+{
+ RefPtr<RegisterID> value = generator.emitNode(node.m_assign);
+ if (node.needsSuperBinding()) {
+ emitPutHomeObject(generator, value.get(), newObj);
+
+ RefPtr<RegisterID> propertyNameRegister;
+ if (node.name())
+ propertyNameRegister = generator.emitLoad(generator.newTemporary(), *node.name());
+ else
+ propertyNameRegister = generator.emitNode(node.m_expression);
+
+ generator.emitCallDefineProperty(newObj, propertyNameRegister.get(),
+ value.get(), nullptr, nullptr, BytecodeGenerator::PropertyConfigurable | BytecodeGenerator::PropertyWritable, m_position);
+ return;
+ }
+ if (const auto* identifier = node.name()) {
+ Optional<uint32_t> optionalIndex = parseIndex(*identifier);
+ if (!optionalIndex) {
+ generator.emitDirectPutById(newObj, *identifier, value.get(), node.putType());
+ return;
+ }
+
+ RefPtr<RegisterID> index = generator.emitLoad(generator.newTemporary(), jsNumber(optionalIndex.value()));
+ generator.emitDirectPutByVal(newObj, index.get(), value.get());
+ return;
+ }
+ RefPtr<RegisterID> propertyName = generator.emitNode(node.m_expression);
+ generator.emitDirectPutByVal(newObj, propertyName.get(), value.get());
}
// ------------------------------ BracketAccessorNode --------------------------------
+static bool isNonIndexStringElement(ExpressionNode& element)
+{
+ return element.isString() && !parseIndex(static_cast<StringNode&>(element).value());
+}
+
RegisterID* BracketAccessorNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- if (m_base->isResolveNode()
- && generator.willResolveToArguments(static_cast<ResolveNode*>(m_base)->identifier())
- && !generator.symbolTable().slowArguments()) {
+ if (m_base->isSuperNode()) {
+ // FIXME: Should we generate the profiler info?
+ if (isNonIndexStringElement(*m_subscript)) {
+ const Identifier& id = static_cast<StringNode*>(m_subscript)->value();
+ return generator.emitGetById(generator.finalDestination(dst), emitSuperBaseForCallee(generator), id);
+ }
+ return generator.emitGetByVal(generator.finalDestination(dst), emitSuperBaseForCallee(generator), generator.emitNode(m_subscript));
+ }
+
+ RegisterID* ret;
+ RegisterID* finalDest = generator.finalDestination(dst);
+
+ if (isNonIndexStringElement(*m_subscript)) {
+ RefPtr<RegisterID> base = generator.emitNode(m_base);
+ ret = generator.emitGetById(finalDest, base.get(), static_cast<StringNode*>(m_subscript)->value());
+ } else {
+ RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base, m_subscriptHasAssignments, m_subscript->isPure(generator));
RegisterID* property = generator.emitNode(m_subscript);
- generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- return generator.emitGetArgumentByVal(generator.finalDestination(dst), generator.uncheckedRegisterForArguments(), property);
+ ret = generator.emitGetByVal(finalDest, base.get(), property);
}
- RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base, m_subscriptHasAssignments, m_subscript->isPure(generator));
- RegisterID* property = generator.emitNode(m_subscript);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- return generator.emitGetByVal(generator.finalDestination(dst), base.get(), property);
+
+ generator.emitProfileType(finalDest, divotStart(), divotEnd());
+ return ret;
}
// ------------------------------ DotAccessorNode --------------------------------
RegisterID* DotAccessorNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- if (m_ident == generator.propertyNames().length) {
- if (!m_base->isResolveNode())
- goto nonArgumentsPath;
- ResolveNode* resolveNode = static_cast<ResolveNode*>(m_base);
- if (!generator.willResolveToArguments(resolveNode->identifier()))
- goto nonArgumentsPath;
- generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- return generator.emitGetArgumentsLength(generator.finalDestination(dst), generator.uncheckedRegisterForArguments());
- }
-
-nonArgumentsPath:
- RegisterID* base = generator.emitNode(m_base);
+ RefPtr<RegisterID> base = m_base->isSuperNode() ? emitSuperBaseForCallee(generator) : generator.emitNode(m_base);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- return generator.emitGetById(generator.finalDestination(dst), base, m_ident);
+ RegisterID* finalDest = generator.finalDestination(dst);
+ RegisterID* ret = generator.emitGetById(finalDest, base.get(), m_ident);
+ generator.emitProfileType(finalDest, divotStart(), divotEnd());
+ return ret;
}
// ------------------------------ ArgumentListNode -----------------------------
@@ -373,17 +670,20 @@ RegisterID* NewExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID*
else
expectedFunction = NoExpectedFunction;
RefPtr<RegisterID> func = generator.emitNode(m_expr);
+ RefPtr<RegisterID> returnValue = generator.finalDestination(dst, func.get());
CallArguments callArguments(generator, m_args);
- return generator.emitConstruct(generator.finalDestinationOrIgnored(dst), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.emitMove(callArguments.thisRegister(), func.get());
+ return generator.emitConstruct(returnValue.get(), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd());
}
-inline CallArguments::CallArguments(BytecodeGenerator& generator, ArgumentsNode* argumentsNode)
+CallArguments::CallArguments(BytecodeGenerator& generator, ArgumentsNode* argumentsNode, unsigned additionalArguments)
: m_argumentsNode(argumentsNode)
+ , m_padding(0)
{
if (generator.shouldEmitProfileHooks())
m_profileHookRegister = generator.newTemporary();
- size_t argumentCountIncludingThis = 1; // 'this' register.
+ size_t argumentCountIncludingThis = 1 + additionalArguments; // 'this' register.
if (argumentsNode) {
for (ArgumentListNode* node = argumentsNode->m_listNode; node; node = node->m_next)
++argumentCountIncludingThis;
@@ -392,26 +692,56 @@ inline CallArguments::CallArguments(BytecodeGenerator& generator, ArgumentsNode*
m_argv.grow(argumentCountIncludingThis);
for (int i = argumentCountIncludingThis - 1; i >= 0; --i) {
m_argv[i] = generator.newTemporary();
- ASSERT(static_cast<size_t>(i) == m_argv.size() - 1 || m_argv[i]->index() == m_argv[i + 1]->index() + 1);
+ ASSERT(static_cast<size_t>(i) == m_argv.size() - 1 || m_argv[i]->index() == m_argv[i + 1]->index() - 1);
}
-}
-inline void CallArguments::newArgument(BytecodeGenerator& generator)
-{
- RefPtr<RegisterID> tmp = generator.newTemporary();
- ASSERT(m_argv.isEmpty() || tmp->index() == m_argv.last()->index() + 1); // Calling convention assumes that all arguments are contiguous.
- m_argv.append(tmp.release());
+ // We need to ensure that the frame size is stack-aligned
+ while ((JSStack::CallFrameHeaderSize + m_argv.size()) % stackAlignmentRegisters()) {
+ m_argv.insert(0, generator.newTemporary());
+ m_padding++;
+ }
+
+ while (stackOffset() % stackAlignmentRegisters()) {
+ m_argv.insert(0, generator.newTemporary());
+ m_padding++;
+ }
}
// ------------------------------ EvalFunctionCallNode ----------------------------------
RegisterID* EvalFunctionCallNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- RefPtr<RegisterID> func = generator.tempDestination(dst);
+ // We need try to load 'this' before call eval in constructor, because 'this' can created by 'super' in some of the arrow function
+ // var A = class A {
+ // constructor () { this.id = 'A'; }
+ // }
+ //
+ // var B = class B extend A {
+ // constructor () {
+ // var arrow = () => super();
+ // arrow();
+ // eval("this.id = 'B'");
+ // }
+ // }
+ if (generator.constructorKind() == ConstructorKind::Derived && generator.needsToUpdateArrowFunctionContext())
+ generator.emitLoadThisFromArrowFunctionLexicalEnvironment();
+
+ Variable var = generator.variable(generator.propertyNames().eval);
+ if (RegisterID* local = var.local()) {
+ RefPtr<RegisterID> func = generator.emitMove(generator.tempDestination(dst), local);
+ CallArguments callArguments(generator, m_args);
+ generator.emitLoad(callArguments.thisRegister(), jsUndefined());
+ return generator.emitCallEval(generator.finalDestination(dst, func.get()), func.get(), callArguments, divot(), divotStart(), divotEnd());
+ }
+
+ RefPtr<RegisterID> func = generator.newTemporary();
CallArguments callArguments(generator, m_args);
JSTextPosition newDivot = divotStart() + 4;
generator.emitExpressionInfo(newDivot, divotStart(), newDivot);
- generator.emitResolveWithThis(callArguments.thisRegister(), func.get(), generator.resolve(generator.propertyNames().eval), generator.propertyNames().eval);
+ generator.moveToDestinationIfNeeded(
+ callArguments.thisRegister(),
+ generator.emitResolveScope(callArguments.thisRegister(), var));
+ generator.emitGetFromScope(func.get(), callArguments.thisRegister(), var, ThrowIfNotFound);
return generator.emitCallEval(generator.finalDestination(dst, func.get()), func.get(), callArguments, divot(), divotStart(), divotEnd());
}
@@ -420,9 +750,25 @@ RegisterID* EvalFunctionCallNode::emitBytecode(BytecodeGenerator& generator, Reg
RegisterID* FunctionCallValueNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
RefPtr<RegisterID> func = generator.emitNode(m_expr);
+ RefPtr<RegisterID> returnValue = generator.finalDestination(dst, func.get());
CallArguments callArguments(generator, m_args);
+ if (m_expr->isSuperNode()) {
+ ASSERT(generator.isConstructor() || generator.derivedContextType() == DerivedContextType::DerivedConstructorContext);
+ ASSERT(generator.constructorKind() == ConstructorKind::Derived || generator.derivedContextType() == DerivedContextType::DerivedConstructorContext);
+ generator.emitMove(callArguments.thisRegister(), generator.newTarget());
+ RegisterID* ret = generator.emitConstruct(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.emitMove(generator.thisRegister(), ret);
+
+ bool isConstructorKindDerived = generator.constructorKind() == ConstructorKind::Derived;
+ if (generator.isDerivedConstructorContext() || (isConstructorKindDerived && generator.needsToUpdateArrowFunctionContext()))
+ generator.emitPutThisToArrowFunctionContextScope();
+
+ return ret;
+ }
generator.emitLoad(callArguments.thisRegister(), jsUndefined());
- return generator.emitCall(generator.finalDestinationOrIgnored(dst, func.get()), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ RegisterID* ret = generator.emitCallInTailPosition(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());
+ return ret;
}
// ------------------------------ FunctionCallResolveNode ----------------------------------
@@ -430,45 +776,138 @@ RegisterID* FunctionCallValueNode::emitBytecode(BytecodeGenerator& generator, Re
RegisterID* FunctionCallResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
ExpectedFunction expectedFunction = generator.expectedFunctionForIdentifier(m_ident);
- ResolveResult resolveResult = generator.resolve(m_ident);
- if (RegisterID* local = resolveResult.local()) {
+ Variable var = generator.variable(m_ident);
+ if (RegisterID* local = var.local()) {
+ generator.emitTDZCheckIfNecessary(var, local, nullptr);
RefPtr<RegisterID> func = generator.emitMove(generator.tempDestination(dst), local);
+ RefPtr<RegisterID> returnValue = generator.finalDestination(dst, func.get());
CallArguments callArguments(generator, m_args);
generator.emitLoad(callArguments.thisRegister(), jsUndefined());
// This passes NoExpectedFunction because we expect that if the function is in a
// local variable, then it's not one of our built-in constructors.
- return generator.emitCall(generator.finalDestinationOrIgnored(dst, callArguments.thisRegister()), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
- }
-
- if (resolveResult.isStatic()) {
- RefPtr<RegisterID> func = generator.newTemporary();
- CallArguments callArguments(generator, m_args);
- generator.emitGetStaticVar(func.get(), resolveResult, m_ident);
- generator.emitLoad(callArguments.thisRegister(), jsUndefined());
- return generator.emitCall(generator.finalDestinationOrIgnored(dst, func.get()), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ RegisterID* ret = generator.emitCallInTailPosition(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());
+ return ret;
}
RefPtr<RegisterID> func = generator.newTemporary();
+ RefPtr<RegisterID> returnValue = generator.finalDestination(dst, func.get());
CallArguments callArguments(generator, m_args);
JSTextPosition newDivot = divotStart() + m_ident.length();
generator.emitExpressionInfo(newDivot, divotStart(), newDivot);
- generator.emitResolveWithThis(callArguments.thisRegister(), func.get(), resolveResult, m_ident);
- return generator.emitCall(generator.finalDestinationOrIgnored(dst, func.get()), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.moveToDestinationIfNeeded(
+ callArguments.thisRegister(),
+ generator.emitResolveScope(callArguments.thisRegister(), var));
+ generator.emitGetFromScope(func.get(), callArguments.thisRegister(), var, ThrowIfNotFound);
+ generator.emitTDZCheckIfNecessary(var, func.get(), nullptr);
+ RegisterID* ret = generator.emitCallInTailPosition(returnValue.get(), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());
+ return ret;
+}
+
+// ------------------------------ BytecodeIntrinsicNode ----------------------------------
+
+RegisterID* BytecodeIntrinsicNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ return (this->*m_emitter)(generator, dst);
+}
+
+RegisterID* BytecodeIntrinsicNode::emit_intrinsic_assert(BytecodeGenerator& generator, RegisterID* dst)
+{
+#ifndef NDEBUG
+ ArgumentListNode* node = m_args->m_listNode;
+ RefPtr<RegisterID> condition = generator.emitNode(node);
+ generator.emitAssert(condition.get(), node->firstLine());
+ return dst;
+#else
+ UNUSED_PARAM(generator);
+ return dst;
+#endif
+}
+
+RegisterID* BytecodeIntrinsicNode::emit_intrinsic_putByValDirect(BytecodeGenerator& generator, RegisterID* dst)
+{
+ ArgumentListNode* node = m_args->m_listNode;
+ RefPtr<RegisterID> base = generator.emitNode(node);
+ node = node->m_next;
+ RefPtr<RegisterID> index = generator.emitNode(node);
+ node = node->m_next;
+ RefPtr<RegisterID> value = generator.emitNode(node);
+
+ ASSERT(!node->m_next);
+
+ return generator.moveToDestinationIfNeeded(dst, generator.emitDirectPutByVal(base.get(), index.get(), value.get()));
+}
+
+RegisterID* BytecodeIntrinsicNode::emit_intrinsic_toString(BytecodeGenerator& generator, RegisterID* dst)
+{
+ ArgumentListNode* node = m_args->m_listNode;
+ RefPtr<RegisterID> src = generator.emitNode(node);
+ ASSERT(!node->m_next);
+
+ return generator.moveToDestinationIfNeeded(dst, generator.emitToString(generator.tempDestination(dst), src.get()));
+}
+
+RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isObject(BytecodeGenerator& generator, RegisterID* dst)
+{
+ ArgumentListNode* node = m_args->m_listNode;
+ RefPtr<RegisterID> src = generator.emitNode(node);
+ ASSERT(!node->m_next);
+
+ return generator.moveToDestinationIfNeeded(dst, generator.emitIsObject(generator.tempDestination(dst), src.get()));
}
+
+#define JSC_DECLARE_BYTECODE_INTRINSIC_CONSTANT_GENERATORS(name) \
+ RegisterID* BytecodeIntrinsicNode::emit_intrinsic_##name(BytecodeGenerator& generator, RegisterID* dst) \
+ { \
+ ASSERT(!m_args); \
+ ASSERT(type() == Type::Constant); \
+ if (dst == generator.ignoredResult()) \
+ return nullptr; \
+ return generator.emitLoad(dst, generator.vm()->bytecodeIntrinsicRegistry().name##Value(generator)); \
+ }
+ JSC_COMMON_BYTECODE_INTRINSIC_CONSTANTS_EACH_NAME(JSC_DECLARE_BYTECODE_INTRINSIC_CONSTANT_GENERATORS)
+#undef JSC_DECLARE_BYTECODE_INTRINSIC_CONSTANT_GENERATORS
+
// ------------------------------ FunctionCallBracketNode ----------------------------------
RegisterID* FunctionCallBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- RefPtr<RegisterID> base = generator.emitNode(m_base);
- RegisterID* property = generator.emitNode(m_subscript);
- generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
- RefPtr<RegisterID> function = generator.emitGetByVal(generator.tempDestination(dst), base.get(), property);
+ bool baseIsSuper = m_base->isSuperNode();
+ bool subscriptIsNonIndexString = isNonIndexStringElement(*m_subscript);
+
+ RefPtr<RegisterID> base;
+ if (baseIsSuper)
+ base = emitSuperBaseForCallee(generator);
+ else {
+ if (subscriptIsNonIndexString)
+ base = generator.emitNode(m_base);
+ else
+ base = generator.emitNodeForLeftHandSide(m_base, m_subscriptHasAssignments, m_subscript->isPure(generator));
+ }
+
+ RefPtr<RegisterID> function;
+ if (subscriptIsNonIndexString) {
+ generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
+ function = generator.emitGetById(generator.tempDestination(dst), base.get(), static_cast<StringNode*>(m_subscript)->value());
+ } else {
+ RefPtr<RegisterID> property = generator.emitNode(m_subscript);
+ generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
+ function = generator.emitGetByVal(generator.tempDestination(dst), base.get(), property.get());
+ }
+
+ RefPtr<RegisterID> returnValue = generator.finalDestination(dst, function.get());
CallArguments callArguments(generator, m_args);
- generator.emitMove(callArguments.thisRegister(), base.get());
- return generator.emitCall(generator.finalDestinationOrIgnored(dst, function.get()), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ if (baseIsSuper)
+ generator.emitMove(callArguments.thisRegister(), generator.thisRegister());
+ else
+ generator.emitMove(callArguments.thisRegister(), base.get());
+ RegisterID* ret = generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());
+ return ret;
}
// ------------------------------ FunctionCallDotNode ----------------------------------
@@ -476,11 +915,19 @@ RegisterID* FunctionCallBracketNode::emitBytecode(BytecodeGenerator& generator,
RegisterID* FunctionCallDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
RefPtr<RegisterID> function = generator.tempDestination(dst);
+ RefPtr<RegisterID> returnValue = generator.finalDestination(dst, function.get());
CallArguments callArguments(generator, m_args);
- generator.emitNode(callArguments.thisRegister(), m_base);
+ bool baseIsSuper = m_base->isSuperNode();
+ if (baseIsSuper) {
+ generator.emitTDZCheck(generator.thisRegister());
+ generator.emitMove(callArguments.thisRegister(), generator.thisRegister());
+ } else
+ generator.emitNode(callArguments.thisRegister(), m_base);
generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
- generator.emitGetById(function.get(), callArguments.thisRegister(), m_ident);
- return generator.emitCall(generator.finalDestinationOrIgnored(dst, function.get()), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.emitGetById(function.get(), baseIsSuper ? emitSuperBaseForCallee(generator) : callArguments.thisRegister(), m_ident);
+ RegisterID* ret = generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());
+ return ret;
}
RegisterID* CallFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
@@ -489,37 +936,53 @@ RegisterID* CallFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator,
RefPtr<Label> end = generator.newLabel();
RefPtr<RegisterID> base = generator.emitNode(m_base);
generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
- RefPtr<RegisterID> function = generator.emitGetById(generator.tempDestination(dst), base.get(), m_ident);
- RefPtr<RegisterID> finalDestinationOrIgnored = generator.finalDestinationOrIgnored(dst, function.get());
- generator.emitJumpIfNotFunctionCall(function.get(), realCall.get());
+ RefPtr<RegisterID> function;
+ bool emitCallCheck = !generator.isBuiltinFunction();
+ if (emitCallCheck) {
+ function = generator.emitGetById(generator.tempDestination(dst), base.get(), generator.propertyNames().builtinNames().callPublicName());
+ generator.emitJumpIfNotFunctionCall(function.get(), realCall.get());
+ }
+ RefPtr<RegisterID> returnValue = generator.finalDestination(dst);
{
- if (m_args->m_listNode && m_args->m_listNode->m_expr) {
+ if (m_args->m_listNode && m_args->m_listNode->m_expr && m_args->m_listNode->m_expr->isSpreadExpression()) {
+ RefPtr<RegisterID> profileHookRegister;
+ if (generator.shouldEmitProfileHooks())
+ profileHookRegister = generator.newTemporary();
+ SpreadExpressionNode* spread = static_cast<SpreadExpressionNode*>(m_args->m_listNode->m_expr);
+ ExpressionNode* subject = spread->expression();
+ RefPtr<RegisterID> argumentsRegister;
+ argumentsRegister = generator.emitNode(subject);
+ generator.emitExpressionInfo(spread->divot(), spread->divotStart(), spread->divotEnd());
+ RefPtr<RegisterID> thisRegister = generator.emitGetByVal(generator.newTemporary(), argumentsRegister.get(), generator.emitLoad(0, jsNumber(0)));
+ generator.emitCallVarargsInTailPosition(returnValue.get(), base.get(), thisRegister.get(), argumentsRegister.get(), generator.newTemporary(), 1, profileHookRegister.get(), divot(), divotStart(), divotEnd());
+ } else if (m_args->m_listNode && m_args->m_listNode->m_expr) {
ArgumentListNode* oldList = m_args->m_listNode;
m_args->m_listNode = m_args->m_listNode->m_next;
RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
CallArguments callArguments(generator, m_args);
generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
- generator.emitCall(finalDestinationOrIgnored.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
- generator.emitJump(end.get());
-
+ generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
m_args->m_listNode = oldList;
} else {
RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
CallArguments callArguments(generator, m_args);
generator.emitLoad(callArguments.thisRegister(), jsUndefined());
- generator.emitCall(finalDestinationOrIgnored.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
- generator.emitJump(end.get());
+ generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
}
}
- generator.emitLabel(realCall.get());
- {
- CallArguments callArguments(generator, m_args);
- generator.emitMove(callArguments.thisRegister(), base.get());
- generator.emitCall(finalDestinationOrIgnored.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ if (emitCallCheck) {
+ generator.emitJump(end.get());
+ generator.emitLabel(realCall.get());
+ {
+ CallArguments callArguments(generator, m_args);
+ generator.emitMove(callArguments.thisRegister(), base.get());
+ generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ }
+ generator.emitLabel(end.get());
}
- generator.emitLabel(end.get());
- return finalDestinationOrIgnored.get();
+ generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());
+ return returnValue.get();
}
static bool areTrivialApplyArguments(ArgumentsNode* args)
@@ -539,66 +1002,95 @@ RegisterID* ApplyFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator,
RefPtr<Label> end = generator.newLabel();
RefPtr<RegisterID> base = generator.emitNode(m_base);
generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
- RefPtr<RegisterID> function = generator.emitGetById(generator.tempDestination(dst), base.get(), m_ident);
- RefPtr<RegisterID> finalDestinationOrIgnored = generator.finalDestinationOrIgnored(dst, function.get());
- generator.emitJumpIfNotFunctionApply(function.get(), realCall.get());
- {
- if (mayBeCall) {
- if (m_args->m_listNode && m_args->m_listNode->m_expr) {
- ArgumentListNode* oldList = m_args->m_listNode;
- if (m_args->m_listNode->m_next) {
- ASSERT(m_args->m_listNode->m_next->m_expr->isSimpleArray());
- ASSERT(!m_args->m_listNode->m_next->m_next);
- m_args->m_listNode = static_cast<ArrayNode*>(m_args->m_listNode->m_next->m_expr)->toArgumentList(generator.vm(), 0, 0);
- RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
- CallArguments callArguments(generator, m_args);
- generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
- generator.emitCall(finalDestinationOrIgnored.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
- } else {
- m_args->m_listNode = m_args->m_listNode->m_next;
- RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
- CallArguments callArguments(generator, m_args);
- generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
- generator.emitCall(finalDestinationOrIgnored.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
- }
- m_args->m_listNode = oldList;
+ RefPtr<RegisterID> function;
+ RefPtr<RegisterID> returnValue = generator.finalDestination(dst, function.get());
+ bool emitCallCheck = !generator.isBuiltinFunction();
+ if (emitCallCheck) {
+ function = generator.emitGetById(generator.tempDestination(dst), base.get(), generator.propertyNames().builtinNames().applyPublicName());
+ generator.emitJumpIfNotFunctionApply(function.get(), realCall.get());
+ }
+ if (mayBeCall) {
+ if (m_args->m_listNode && m_args->m_listNode->m_expr) {
+ ArgumentListNode* oldList = m_args->m_listNode;
+ if (m_args->m_listNode->m_expr->isSpreadExpression()) {
+ SpreadExpressionNode* spread = static_cast<SpreadExpressionNode*>(m_args->m_listNode->m_expr);
+ RefPtr<RegisterID> profileHookRegister;
+ if (generator.shouldEmitProfileHooks())
+ profileHookRegister = generator.newTemporary();
+ RefPtr<RegisterID> realFunction = generator.emitMove(generator.newTemporary(), base.get());
+ RefPtr<RegisterID> index = generator.emitLoad(generator.newTemporary(), jsNumber(0));
+ RefPtr<RegisterID> thisRegister = generator.emitLoad(generator.newTemporary(), jsUndefined());
+ RefPtr<RegisterID> argumentsRegister = generator.emitLoad(generator.newTemporary(), jsUndefined());
+
+ auto extractor = [&thisRegister, &argumentsRegister, &index](BytecodeGenerator& generator, RegisterID* value)
+ {
+ RefPtr<Label> haveThis = generator.newLabel();
+ RefPtr<Label> end = generator.newLabel();
+ RefPtr<RegisterID> compareResult = generator.newTemporary();
+ RefPtr<RegisterID> indexZeroCompareResult = generator.emitBinaryOp(op_eq, compareResult.get(), index.get(), generator.emitLoad(0, jsNumber(0)), OperandTypes(ResultType::numberTypeIsInt32(), ResultType::numberTypeIsInt32()));
+ generator.emitJumpIfFalse(indexZeroCompareResult.get(), haveThis.get());
+ generator.emitMove(thisRegister.get(), value);
+ generator.emitLoad(index.get(), jsNumber(1));
+ generator.emitJump(end.get());
+ generator.emitLabel(haveThis.get());
+ RefPtr<RegisterID> indexOneCompareResult = generator.emitBinaryOp(op_eq, compareResult.get(), index.get(), generator.emitLoad(0, jsNumber(1)), OperandTypes(ResultType::numberTypeIsInt32(), ResultType::numberTypeIsInt32()));
+ generator.emitJumpIfFalse(indexOneCompareResult.get(), end.get());
+ generator.emitMove(argumentsRegister.get(), value);
+ generator.emitLoad(index.get(), jsNumber(2));
+ generator.emitLabel(end.get());
+ };
+ generator.emitEnumeration(this, spread->expression(), extractor);
+ generator.emitCallVarargsInTailPosition(returnValue.get(), realFunction.get(), thisRegister.get(), argumentsRegister.get(), generator.newTemporary(), 0, profileHookRegister.get(), divot(), divotStart(), divotEnd());
+ } else if (m_args->m_listNode->m_next) {
+ ASSERT(m_args->m_listNode->m_next->m_expr->isSimpleArray());
+ ASSERT(!m_args->m_listNode->m_next->m_next);
+ m_args->m_listNode = static_cast<ArrayNode*>(m_args->m_listNode->m_next->m_expr)->toArgumentList(generator.parserArena(), 0, 0);
+ RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
+ CallArguments callArguments(generator, m_args);
+ generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
+ generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
} else {
+ m_args->m_listNode = m_args->m_listNode->m_next;
RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
CallArguments callArguments(generator, m_args);
- generator.emitLoad(callArguments.thisRegister(), jsUndefined());
- generator.emitCall(finalDestinationOrIgnored.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.emitNode(callArguments.thisRegister(), oldList->m_expr);
+ generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
}
+ m_args->m_listNode = oldList;
} else {
- ASSERT(m_args->m_listNode && m_args->m_listNode->m_next);
- RefPtr<RegisterID> profileHookRegister;
- if (generator.shouldEmitProfileHooks())
- profileHookRegister = generator.newTemporary();
RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
- RefPtr<RegisterID> thisRegister = generator.emitNode(m_args->m_listNode->m_expr);
- RefPtr<RegisterID> argsRegister;
- ArgumentListNode* args = m_args->m_listNode->m_next;
- if (args->m_expr->isResolveNode() && generator.willResolveToArguments(static_cast<ResolveNode*>(args->m_expr)->identifier()))
- argsRegister = generator.uncheckedRegisterForArguments();
- else
- argsRegister = generator.emitNode(args->m_expr);
-
- // Function.prototype.apply ignores extra arguments, but we still
- // need to evaluate them for side effects.
- while ((args = args->m_next))
- generator.emitNode(args->m_expr);
-
- generator.emitCallVarargs(finalDestinationOrIgnored.get(), realFunction.get(), thisRegister.get(), argsRegister.get(), generator.newTemporary(), profileHookRegister.get(), divot(), divotStart(), divotEnd());
+ CallArguments callArguments(generator, m_args);
+ generator.emitLoad(callArguments.thisRegister(), jsUndefined());
+ generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
}
- generator.emitJump(end.get());
+ } else {
+ ASSERT(m_args->m_listNode && m_args->m_listNode->m_next);
+ RefPtr<RegisterID> profileHookRegister;
+ if (generator.shouldEmitProfileHooks())
+ profileHookRegister = generator.newTemporary();
+ RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());
+ RefPtr<RegisterID> thisRegister = generator.emitNode(m_args->m_listNode->m_expr);
+ RefPtr<RegisterID> argsRegister;
+ ArgumentListNode* args = m_args->m_listNode->m_next;
+ argsRegister = generator.emitNode(args->m_expr);
+
+ // Function.prototype.apply ignores extra arguments, but we still
+ // need to evaluate them for side effects.
+ while ((args = args->m_next))
+ generator.emitNode(args->m_expr);
+
+ generator.emitCallVarargsInTailPosition(returnValue.get(), realFunction.get(), thisRegister.get(), argsRegister.get(), generator.newTemporary(), 0, profileHookRegister.get(), divot(), divotStart(), divotEnd());
}
- generator.emitLabel(realCall.get());
- {
+ if (emitCallCheck) {
+ generator.emitJump(end.get());
+ generator.emitLabel(realCall.get());
CallArguments callArguments(generator, m_args);
generator.emitMove(callArguments.thisRegister(), base.get());
- generator.emitCall(finalDestinationOrIgnored.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());
+ generator.emitLabel(end.get());
}
- generator.emitLabel(end.get());
- return finalDestinationOrIgnored.get();
+ generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());
+ return returnValue.get();
}
// ------------------------------ PostfixNode ----------------------------------
@@ -626,29 +1118,34 @@ RegisterID* PostfixNode::emitResolve(BytecodeGenerator& generator, RegisterID* d
ResolveNode* resolve = static_cast<ResolveNode*>(m_expr);
const Identifier& ident = resolve->identifier();
- ResolveResult resolveResult = generator.resolve(ident);
-
- if (RefPtr<RegisterID> local = resolveResult.local()) {
- if (resolveResult.isReadOnly()) {
- generator.emitReadOnlyExceptionIfNeeded();
- local = generator.emitMove(generator.tempDestination(dst), local.get());
+ Variable var = generator.variable(ident);
+ if (RegisterID* local = var.local()) {
+ generator.emitTDZCheckIfNecessary(var, local, nullptr);
+ RefPtr<RegisterID> localReg = local;
+ if (var.isReadOnly()) {
+ generator.emitReadOnlyExceptionIfNeeded(var);
+ localReg = generator.emitMove(generator.tempDestination(dst), local);
}
- return emitPostIncOrDec(generator, generator.finalDestination(dst), local.get(), m_operator);
- }
-
- if (resolveResult.isStatic() && !resolveResult.isReadOnly()) {
- RefPtr<RegisterID> value = generator.emitGetStaticVar(generator.newTemporary(), resolveResult, ident);
- RefPtr<RegisterID> oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
- generator.emitPutStaticVar(resolveResult, ident, value.get());
+ RefPtr<RegisterID> oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), localReg.get(), m_operator);
+ generator.emitProfileType(localReg.get(), var, divotStart(), divotEnd());
return oldValue.get();
}
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- RefPtr<RegisterID> value = generator.newTemporary();
- NonlocalResolveInfo resolveInfo;
- RefPtr<RegisterID> base = generator.emitResolveWithBaseForPut(generator.newTemporary(), value.get(), resolveResult, ident, resolveInfo);
+ RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);
+ RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, ThrowIfNotFound);
+ generator.emitTDZCheckIfNecessary(var, value.get(), nullptr);
+ if (var.isReadOnly()) {
+ bool threwException = generator.emitReadOnlyExceptionIfNeeded(var);
+ if (threwException)
+ return value.get();
+ }
RefPtr<RegisterID> oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator);
- generator.emitPutToBase(base.get(), ident, value.get(), resolveInfo);
+ if (!var.isReadOnly()) {
+ generator.emitPutToScope(scope.get(), var, value.get(), ThrowIfNotFound, NotInitialization);
+ generator.emitProfileType(value.get(), var, divotStart(), divotEnd());
+ }
+
return oldValue.get();
}
@@ -670,6 +1167,7 @@ RegisterID* PostfixNode::emitBracket(BytecodeGenerator& generator, RegisterID* d
RegisterID* oldValue = emitPostIncOrDec(generator, generator.tempDestination(dst), value.get(), m_operator);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
generator.emitPutByVal(base.get(), property.get(), value.get());
+ generator.emitProfileType(value.get(), divotStart(), divotEnd());
return generator.moveToDestinationIfNeeded(dst, oldValue);
}
@@ -690,6 +1188,7 @@ RegisterID* PostfixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)
RegisterID* oldValue = emitPostIncOrDec(generator, generator.tempDestination(dst), value.get(), m_operator);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
generator.emitPutById(base.get(), ident, value.get());
+ generator.emitProfileType(value.get(), divotStart(), divotEnd());
return generator.moveToDestinationIfNeeded(dst, oldValue);
}
@@ -705,21 +1204,24 @@ RegisterID* PostfixNode::emitBytecode(BytecodeGenerator& generator, RegisterID*
return emitDot(generator, dst);
return emitThrowReferenceError(generator, m_operator == OpPlusPlus
- ? "Postfix ++ operator applied to value that is not a reference."
- : "Postfix -- operator applied to value that is not a reference.");
+ ? ASCIILiteral("Postfix ++ operator applied to value that is not a reference.")
+ : ASCIILiteral("Postfix -- operator applied to value that is not a reference."));
}
// ------------------------------ DeleteResolveNode -----------------------------------
RegisterID* DeleteResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- ResolveResult resolveResult = generator.resolve(m_ident);
- if (resolveResult.isRegister())
+ Variable var = generator.variable(m_ident);
+ if (var.local()) {
+ generator.emitTDZCheckIfNecessary(var, var.local(), nullptr);
return generator.emitLoad(generator.finalDestination(dst), false);
+ }
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- RegisterID* base = generator.emitResolveBase(generator.tempDestination(dst), resolveResult, m_ident);
- return generator.emitDeleteById(generator.finalDestination(dst, base), base, m_ident);
+ RefPtr<RegisterID> base = generator.emitResolveScope(dst, var);
+ generator.emitTDZCheckIfNecessary(var, nullptr, base.get());
+ return generator.emitDeleteById(generator.finalDestination(dst, base.get()), base.get(), m_ident);
}
// ------------------------------ DeleteBracketNode -----------------------------------
@@ -727,20 +1229,24 @@ RegisterID* DeleteResolveNode::emitBytecode(BytecodeGenerator& generator, Regist
RegisterID* DeleteBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
RefPtr<RegisterID> r0 = generator.emitNode(m_base);
- RegisterID* r1 = generator.emitNode(m_subscript);
+ RefPtr<RegisterID> r1 = generator.emitNode(m_subscript);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- return generator.emitDeleteByVal(generator.finalDestination(dst), r0.get(), r1);
+ if (m_base->isSuperNode())
+ return emitThrowReferenceError(generator, "Cannot delete a super property");
+ return generator.emitDeleteByVal(generator.finalDestination(dst), r0.get(), r1.get());
}
// ------------------------------ DeleteDotNode -----------------------------------
RegisterID* DeleteDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- RegisterID* r0 = generator.emitNode(m_base);
+ RefPtr<RegisterID> r0 = generator.emitNode(m_base);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- return generator.emitDeleteById(generator.finalDestination(dst), r0, m_ident);
+ if (m_base->isSuperNode())
+ return emitThrowReferenceError(generator, "Cannot delete a super property");
+ return generator.emitDeleteById(generator.finalDestination(dst), r0.get(), m_ident);
}
// ------------------------------ DeleteValueNode -----------------------------------
@@ -765,27 +1271,24 @@ RegisterID* VoidNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst
return generator.emitLoad(dst, jsUndefined());
}
-// ------------------------------ TypeOfValueNode -----------------------------------
+// ------------------------------ TypeOfResolveNode -----------------------------------
RegisterID* TypeOfResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- ResolveResult resolveResult = generator.resolve(m_ident);
- if (RegisterID* local = resolveResult.local()) {
+ Variable var = generator.variable(m_ident);
+ if (RegisterID* local = var.local()) {
+ generator.emitTDZCheckIfNecessary(var, local, nullptr);
if (dst == generator.ignoredResult())
return 0;
return generator.emitTypeOf(generator.finalDestination(dst), local);
}
- if (resolveResult.isStatic()) {
- RefPtr<RegisterID> scratch = generator.emitGetStaticVar(generator.tempDestination(dst), resolveResult, m_ident);
- return generator.emitTypeOf(generator.finalDestination(dst, scratch.get()), scratch.get());
- }
-
- RefPtr<RegisterID> scratch = generator.emitResolveBase(generator.tempDestination(dst), resolveResult, m_ident);
- generator.emitGetById(scratch.get(), scratch.get(), m_ident);
+ RefPtr<RegisterID> scope = generator.emitResolveScope(dst, var);
+ RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, DoNotThrowIfNotFound);
+ generator.emitTDZCheckIfNecessary(var, value.get(), nullptr);
if (dst == generator.ignoredResult())
return 0;
- return generator.emitTypeOf(generator.finalDestination(dst, scratch.get()), scratch.get());
+ return generator.emitTypeOf(generator.finalDestination(dst, scope.get()), value.get());
}
// ------------------------------ TypeOfValueNode -----------------------------------
@@ -808,30 +1311,41 @@ RegisterID* PrefixNode::emitResolve(BytecodeGenerator& generator, RegisterID* ds
ResolveNode* resolve = static_cast<ResolveNode*>(m_expr);
const Identifier& ident = resolve->identifier();
- ResolveResult resolveResult = generator.resolve(ident);
- if (RefPtr<RegisterID> local = resolveResult.local()) {
- if (resolveResult.isReadOnly()) {
- generator.emitReadOnlyExceptionIfNeeded();
- local = generator.emitMove(generator.tempDestination(dst), local.get());
+ Variable var = generator.variable(ident);
+ if (RegisterID* local = var.local()) {
+ generator.emitTDZCheckIfNecessary(var, local, nullptr);
+ RefPtr<RegisterID> localReg = local;
+ if (var.isReadOnly()) {
+ generator.emitReadOnlyExceptionIfNeeded(var);
+ localReg = generator.emitMove(generator.tempDestination(dst), localReg.get());
+ } else if (generator.vm()->typeProfiler()) {
+ RefPtr<RegisterID> tempDst = generator.tempDestination(dst);
+ generator.emitMove(tempDst.get(), localReg.get());
+ emitIncOrDec(generator, tempDst.get(), m_operator);
+ generator.emitMove(localReg.get(), tempDst.get());
+ generator.emitProfileType(localReg.get(), var, divotStart(), divotEnd());
+ return generator.moveToDestinationIfNeeded(dst, tempDst.get());
}
- emitIncOrDec(generator, local.get(), m_operator);
- return generator.moveToDestinationIfNeeded(dst, local.get());
+ emitIncOrDec(generator, localReg.get(), m_operator);
+ return generator.moveToDestinationIfNeeded(dst, localReg.get());
}
- if (resolveResult.isStatic() && !resolveResult.isReadOnly()) {
- RefPtr<RegisterID> propDst = generator.emitGetStaticVar(generator.tempDestination(dst), resolveResult, ident);
- emitIncOrDec(generator, propDst.get(), m_operator);
- generator.emitPutStaticVar(resolveResult, ident, propDst.get());
- return generator.moveToDestinationIfNeeded(dst, propDst.get());
+ generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
+ RefPtr<RegisterID> scope = generator.emitResolveScope(dst, var);
+ RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, ThrowIfNotFound);
+ generator.emitTDZCheckIfNecessary(var, value.get(), nullptr);
+ if (var.isReadOnly()) {
+ bool threwException = generator.emitReadOnlyExceptionIfNeeded(var);
+ if (threwException)
+ return value.get();
}
- generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- RefPtr<RegisterID> propDst = generator.tempDestination(dst);
- NonlocalResolveInfo resolveVerifier;
- RefPtr<RegisterID> base = generator.emitResolveWithBaseForPut(generator.newTemporary(), propDst.get(), resolveResult, ident, resolveVerifier);
- emitIncOrDec(generator, propDst.get(), m_operator);
- generator.emitPutToBase(base.get(), ident, propDst.get(), resolveVerifier);
- return generator.moveToDestinationIfNeeded(dst, propDst.get());
+ emitIncOrDec(generator, value.get(), m_operator);
+ if (!var.isReadOnly()) {
+ generator.emitPutToScope(scope.get(), var, value.get(), ThrowIfNotFound, NotInitialization);
+ generator.emitProfileType(value.get(), var, divotStart(), divotEnd());
+ }
+ return generator.moveToDestinationIfNeeded(dst, value.get());
}
RegisterID* PrefixNode::emitBracket(BytecodeGenerator& generator, RegisterID* dst)
@@ -850,6 +1364,7 @@ RegisterID* PrefixNode::emitBracket(BytecodeGenerator& generator, RegisterID* ds
emitIncOrDec(generator, value, m_operator);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
generator.emitPutByVal(base.get(), property.get(), value);
+ generator.emitProfileType(value, divotStart(), divotEnd());
return generator.moveToDestinationIfNeeded(dst, propDst.get());
}
@@ -868,6 +1383,7 @@ RegisterID* PrefixNode::emitDot(BytecodeGenerator& generator, RegisterID* dst)
emitIncOrDec(generator, value, m_operator);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
generator.emitPutById(base.get(), ident, value);
+ generator.emitProfileType(value, divotStart(), divotEnd());
return generator.moveToDestinationIfNeeded(dst, propDst.get());
}
@@ -883,17 +1399,17 @@ RegisterID* PrefixNode::emitBytecode(BytecodeGenerator& generator, RegisterID* d
return emitDot(generator, dst);
return emitThrowReferenceError(generator, m_operator == OpPlusPlus
- ? "Prefix ++ operator applied to value that is not a reference."
- : "Prefix -- operator applied to value that is not a reference.");
+ ? ASCIILiteral("Prefix ++ operator applied to value that is not a reference.")
+ : ASCIILiteral("Prefix -- operator applied to value that is not a reference."));
}
// ------------------------------ Unary Operation Nodes -----------------------------------
RegisterID* UnaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- RegisterID* src = generator.emitNode(m_expr);
+ RefPtr<RegisterID> src = generator.emitNode(m_expr);
generator.emitExpressionInfo(position(), position(), position());
- return generator.emitUnaryOp(opcodeID(), generator.finalDestination(dst), src);
+ return generator.emitUnaryOp(opcodeID(), generator.finalDestination(dst), src.get());
}
// ------------------------------ BitwiseNotNode -----------------------------------
@@ -901,8 +1417,8 @@ RegisterID* UnaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID*
RegisterID* BitwiseNotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
RefPtr<RegisterID> src2 = generator.emitLoad(generator.newTemporary(), jsNumber(-1));
- RegisterID* src1 = generator.emitNode(m_expr);
- return generator.emitBinaryOp(op_bitxor, generator.finalDestination(dst, src1), src1, src2.get(), OperandTypes(m_expr->resultDescriptor(), ResultType::numberTypeIsInt32()));
+ RefPtr<RegisterID> src1 = generator.emitNode(m_expr);
+ return generator.emitBinaryOp(op_bitxor, generator.finalDestination(dst, src1.get()), src1.get(), src2.get(), OperandTypes(m_expr->resultDescriptor(), ResultType::numberTypeIsInt32()));
}
// ------------------------------ LogicalNotNode -----------------------------------
@@ -1116,20 +1632,23 @@ RegisterID* BinaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID*
}
RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(left, m_rightHasAssignments, right->isPure(generator));
- bool wasTypeof = generator.m_lastOpcodeID == op_typeof;
- RegisterID* src2 = generator.emitNode(right);
+ bool wasTypeof = generator.lastOpcodeID() == op_typeof;
+ RefPtr<RegisterID> src2 = generator.emitNode(right);
generator.emitExpressionInfo(position(), position(), position());
if (wasTypeof && (opcodeID == op_neq || opcodeID == op_nstricteq)) {
RefPtr<RegisterID> tmp = generator.tempDestination(dst);
if (opcodeID == op_neq)
- generator.emitEqualityOp(op_eq, generator.finalDestination(tmp.get(), src1.get()), src1.get(), src2);
+ generator.emitEqualityOp(op_eq, generator.finalDestination(tmp.get(), src1.get()), src1.get(), src2.get());
else if (opcodeID == op_nstricteq)
- generator.emitEqualityOp(op_stricteq, generator.finalDestination(tmp.get(), src1.get()), src1.get(), src2);
+ generator.emitEqualityOp(op_stricteq, generator.finalDestination(tmp.get(), src1.get()), src1.get(), src2.get());
else
RELEASE_ASSERT_NOT_REACHED();
return generator.emitUnaryOp(op_not, generator.finalDestination(dst, tmp.get()), tmp.get());
}
- return generator.emitBinaryOp(opcodeID, generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(left->resultDescriptor(), right->resultDescriptor()));
+ RegisterID* result = generator.emitBinaryOp(opcodeID, generator.finalDestination(dst, src1.get()), src1.get(), src2.get(), OperandTypes(left->resultDescriptor(), right->resultDescriptor()));
+ if (opcodeID == op_urshift && dst != generator.ignoredResult())
+ return generator.emitUnaryOp(op_unsigned, result, result);
+ return result;
}
RegisterID* EqualNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
@@ -1146,8 +1665,8 @@ RegisterID* EqualNode::emitBytecode(BytecodeGenerator& generator, RegisterID* ds
std::swap(left, right);
RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(left, m_rightHasAssignments, m_expr2->isPure(generator));
- RegisterID* src2 = generator.emitNode(right);
- return generator.emitEqualityOp(op_eq, generator.finalDestination(dst, src1.get()), src1.get(), src2);
+ RefPtr<RegisterID> src2 = generator.emitNode(right);
+ return generator.emitEqualityOp(op_eq, generator.finalDestination(dst, src1.get()), src1.get(), src2.get());
}
RegisterID* StrictEqualNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
@@ -1158,36 +1677,63 @@ RegisterID* StrictEqualNode::emitBytecode(BytecodeGenerator& generator, Register
std::swap(left, right);
RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(left, m_rightHasAssignments, m_expr2->isPure(generator));
- RegisterID* src2 = generator.emitNode(right);
- return generator.emitEqualityOp(op_stricteq, generator.finalDestination(dst, src1.get()), src1.get(), src2);
+ RefPtr<RegisterID> src2 = generator.emitNode(right);
+ return generator.emitEqualityOp(op_stricteq, generator.finalDestination(dst, src1.get()), src1.get(), src2.get());
}
RegisterID* ThrowableBinaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1, m_rightHasAssignments, m_expr2->isPure(generator));
- RegisterID* src2 = generator.emitNode(m_expr2);
+ RefPtr<RegisterID> src2 = generator.emitNode(m_expr2);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- return generator.emitBinaryOp(opcodeID(), generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(m_expr1->resultDescriptor(), m_expr2->resultDescriptor()));
+ return generator.emitBinaryOp(opcodeID(), generator.finalDestination(dst, src1.get()), src1.get(), src2.get(), OperandTypes(m_expr1->resultDescriptor(), m_expr2->resultDescriptor()));
}
RegisterID* InstanceOfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1, m_rightHasAssignments, m_expr2->isPure(generator));
- RefPtr<RegisterID> src2 = generator.emitNode(m_expr2);
+ RefPtr<RegisterID> hasInstanceValue = generator.newTemporary();
+ RefPtr<RegisterID> isObject = generator.newTemporary();
+ RefPtr<RegisterID> isCustom = generator.newTemporary();
RefPtr<RegisterID> prototype = generator.newTemporary();
- RefPtr<RegisterID> dstReg = generator.finalDestination(dst, src1.get());
- RefPtr<Label> target = generator.newLabel();
+ RefPtr<RegisterID> value = generator.emitNodeForLeftHandSide(m_expr1, m_rightHasAssignments, m_expr2->isPure(generator));
+ RefPtr<RegisterID> constructor = generator.emitNode(m_expr2);
+ RefPtr<RegisterID> dstReg = generator.finalDestination(dst, value.get());
+ RefPtr<Label> custom = generator.newLabel();
+ RefPtr<Label> done = generator.newLabel();
+ RefPtr<Label> typeError = generator.newLabel();
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- generator.emitCheckHasInstance(dstReg.get(), src1.get(), src2.get(), target.get());
+ generator.emitIsObject(isObject.get(), constructor.get());
+ generator.emitJumpIfFalse(isObject.get(), typeError.get());
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- generator.emitGetById(prototype.get(), src2.get(), generator.vm()->propertyNames->prototype);
+ generator.emitGetById(hasInstanceValue.get(), constructor.get(), generator.vm()->propertyNames->hasInstanceSymbol);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- RegisterID* result = generator.emitInstanceOf(dstReg.get(), src1.get(), prototype.get());
- generator.emitLabel(target.get());
- return result;
+ generator.emitOverridesHasInstance(isCustom.get(), constructor.get(), hasInstanceValue.get());
+
+ generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
+ generator.emitJumpIfTrue(isCustom.get(), custom.get());
+
+ generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
+ generator.emitGetById(prototype.get(), constructor.get(), generator.vm()->propertyNames->prototype);
+
+ generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
+ generator.emitInstanceOf(dstReg.get(), value.get(), prototype.get());
+
+ generator.emitJump(done.get());
+
+ generator.emitLabel(typeError.get());
+ generator.emitThrowTypeError("Right hand side of instanceof is not an object");
+
+ generator.emitLabel(custom.get());
+
+ generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
+ generator.emitInstanceOfCustom(dstReg.get(), value.get(), constructor.get(), hasInstanceValue.get());
+
+ generator.emitLabel(done.get());
+
+ return dstReg.get();
}
// ------------------------------ LogicalOpNode ----------------------------
@@ -1202,7 +1748,7 @@ RegisterID* LogicalOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID
generator.emitJumpIfFalse(temp.get(), target.get());
else
generator.emitJumpIfTrue(temp.get(), target.get());
- generator.emitNode(temp.get(), m_expr2);
+ generator.emitNodeInTailPosition(temp.get(), m_expr2);
generator.emitLabel(target.get());
return generator.moveToDestinationIfNeeded(dst, temp.get());
@@ -1232,14 +1778,18 @@ RegisterID* ConditionalNode::emitBytecode(BytecodeGenerator& generator, Register
generator.emitNodeInConditionContext(m_logical, beforeThen.get(), beforeElse.get(), FallThroughMeansTrue);
generator.emitLabel(beforeThen.get());
- generator.emitNode(newDst.get(), m_expr1);
+ generator.emitProfileControlFlow(m_expr1->startOffset());
+ generator.emitNodeInTailPosition(newDst.get(), m_expr1);
generator.emitJump(afterElse.get());
generator.emitLabel(beforeElse.get());
- generator.emitNode(newDst.get(), m_expr2);
+ generator.emitProfileControlFlow(m_expr1->endOffset() + 1);
+ generator.emitNodeInTailPosition(newDst.get(), m_expr2);
generator.emitLabel(afterElse.get());
+ generator.emitProfileControlFlow(m_expr2->endOffset() + 1);
+
return newDst.get();
}
@@ -1296,17 +1846,23 @@ static ALWAYS_INLINE RegisterID* emitReadModifyAssignment(BytecodeGenerator& gen
// If this is required the node is passed as 'emitExpressionInfoForMe'; do so now.
if (emitExpressionInfoForMe)
generator.emitExpressionInfo(emitExpressionInfoForMe->divot(), emitExpressionInfoForMe->divotStart(), emitExpressionInfoForMe->divotEnd());
- return generator.emitBinaryOp(opcodeID, dst, src1, src2, types);
+ RegisterID* result = generator.emitBinaryOp(opcodeID, dst, src1, src2, types);
+ if (oper == OpURShift)
+ return generator.emitUnaryOp(op_unsigned, result, result);
+ return result;
}
RegisterID* ReadModifyResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- ResolveResult resolveResult = generator.resolve(m_ident);
-
- if (RegisterID *local = resolveResult.local()) {
- if (resolveResult.isReadOnly()) {
- generator.emitReadOnlyExceptionIfNeeded();
- return emitReadModifyAssignment(generator, generator.finalDestination(dst), local, m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
+ JSTextPosition newDivot = divotStart() + m_ident.length();
+ Variable var = generator.variable(m_ident);
+ if (RegisterID* local = var.local()) {
+ generator.emitTDZCheckIfNecessary(var, local, nullptr);
+ if (var.isReadOnly()) {
+ generator.emitReadOnlyExceptionIfNeeded(var);
+ RegisterID* result = emitReadModifyAssignment(generator, generator.finalDestination(dst), local, m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
+ generator.emitProfileType(result, divotStart(), divotEnd());
+ return result;
}
if (generator.leftHandSideNeedsCopy(m_rightHasAssignments, m_right->isPure(generator))) {
@@ -1314,61 +1870,94 @@ RegisterID* ReadModifyResolveNode::emitBytecode(BytecodeGenerator& generator, Re
generator.emitMove(result.get(), local);
emitReadModifyAssignment(generator, result.get(), result.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
generator.emitMove(local, result.get());
+ generator.invalidateForInContextForLocal(local);
+ generator.emitProfileType(local, divotStart(), divotEnd());
return generator.moveToDestinationIfNeeded(dst, result.get());
}
RegisterID* result = emitReadModifyAssignment(generator, local, local, m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
+ generator.invalidateForInContextForLocal(local);
+ generator.emitProfileType(result, divotStart(), divotEnd());
return generator.moveToDestinationIfNeeded(dst, result);
}
- if (resolveResult.isStatic() && !resolveResult.isReadOnly()) {
- RefPtr<RegisterID> src1 = generator.emitGetStaticVar(generator.tempDestination(dst), resolveResult, m_ident);
- RegisterID* result = emitReadModifyAssignment(generator, generator.finalDestination(dst, src1.get()), src1.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
- generator.emitPutStaticVar(resolveResult, m_ident, result);
- return result;
- }
-
- RefPtr<RegisterID> src1 = generator.tempDestination(dst);
- JSTextPosition newDivot = divotStart() + m_ident.length();
generator.emitExpressionInfo(newDivot, divotStart(), newDivot);
- NonlocalResolveInfo resolveVerifier;
- RefPtr<RegisterID> base = generator.emitResolveWithBaseForPut(generator.newTemporary(), src1.get(), resolveResult, m_ident, resolveVerifier);
- RegisterID* result = emitReadModifyAssignment(generator, generator.finalDestination(dst, src1.get()), src1.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()), this);
- return generator.emitPutToBase(base.get(), m_ident, result, resolveVerifier);
+ RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);
+ RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, ThrowIfNotFound);
+ generator.emitTDZCheckIfNecessary(var, value.get(), nullptr);
+ if (var.isReadOnly()) {
+ bool threwException = generator.emitReadOnlyExceptionIfNeeded(var);
+ if (threwException)
+ return value.get();
+ }
+ RefPtr<RegisterID> result = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()), this);
+ RegisterID* returnResult = result.get();
+ if (!var.isReadOnly()) {
+ returnResult = generator.emitPutToScope(scope.get(), var, result.get(), ThrowIfNotFound, NotInitialization);
+ generator.emitProfileType(result.get(), var, divotStart(), divotEnd());
+ }
+ return returnResult;
}
// ------------------------------ AssignResolveNode -----------------------------------
RegisterID* AssignResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- ResolveResult resolveResult = generator.resolve(m_ident);
-
- if (RegisterID* local = resolveResult.local()) {
- if (resolveResult.isReadOnly()) {
- generator.emitReadOnlyExceptionIfNeeded();
- return generator.emitNode(dst, m_right);
+ Variable var = generator.variable(m_ident);
+ bool isReadOnly = var.isReadOnly() && m_assignmentContext != AssignmentContext::ConstDeclarationStatement;
+ if (RegisterID* local = var.local()) {
+ RegisterID* result = nullptr;
+ if (m_assignmentContext == AssignmentContext::AssignmentExpression)
+ generator.emitTDZCheckIfNecessary(var, local, nullptr);
+
+ if (isReadOnly) {
+ result = generator.emitNode(dst, m_right); // Execute side effects first.
+ generator.emitReadOnlyExceptionIfNeeded(var);
+ generator.emitProfileType(result, var, divotStart(), divotEnd());
+ } else if (var.isSpecial()) {
+ RefPtr<RegisterID> tempDst = generator.tempDestination(dst);
+ generator.emitNode(tempDst.get(), m_right);
+ generator.emitMove(local, tempDst.get());
+ generator.emitProfileType(local, var, divotStart(), divotEnd());
+ generator.invalidateForInContextForLocal(local);
+ result = generator.moveToDestinationIfNeeded(dst, tempDst.get());
+ } else {
+ RegisterID* right = generator.emitNode(local, m_right);
+ generator.emitProfileType(right, var, divotStart(), divotEnd());
+ generator.invalidateForInContextForLocal(local);
+ result = generator.moveToDestinationIfNeeded(dst, right);
}
- RegisterID* result = generator.emitNode(local, m_right);
- return generator.moveToDestinationIfNeeded(dst, result);
- }
- if (resolveResult.isStatic() && !resolveResult.isReadOnly()) {
- if (dst == generator.ignoredResult())
- dst = 0;
- RegisterID* value = generator.emitNode(dst, m_right);
- generator.emitPutStaticVar(resolveResult, m_ident, value);
- return value;
+ if (m_assignmentContext == AssignmentContext::DeclarationStatement || m_assignmentContext == AssignmentContext::ConstDeclarationStatement)
+ generator.liftTDZCheckIfPossible(var);
+ return result;
}
- NonlocalResolveInfo resolveVerifier;
if (generator.isStrictMode())
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- RefPtr<RegisterID> base = generator.emitResolveBaseForPut(generator.newTemporary(), resolveResult, m_ident, resolveVerifier);
+ RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);
+ if (m_assignmentContext == AssignmentContext::AssignmentExpression)
+ generator.emitTDZCheckIfNecessary(var, nullptr, scope.get());
if (dst == generator.ignoredResult())
dst = 0;
- RegisterID* value = generator.emitNode(dst, m_right);
+ RefPtr<RegisterID> result = generator.emitNode(dst, m_right);
+ if (isReadOnly) {
+ RegisterID* result = generator.emitNode(dst, m_right); // Execute side effects first.
+ bool threwException = generator.emitReadOnlyExceptionIfNeeded(var);
+ if (threwException)
+ return result;
+ }
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- return generator.emitPutToBase(base.get(), m_ident, value, resolveVerifier);
+ RegisterID* returnResult = result.get();
+ if (!isReadOnly) {
+ returnResult = generator.emitPutToScope(scope.get(), var, result.get(), generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound,
+ m_assignmentContext == AssignmentContext::ConstDeclarationStatement || m_assignmentContext == AssignmentContext::DeclarationStatement ? Initialization : NotInitialization);
+ generator.emitProfileType(result.get(), var, divotStart(), divotEnd());
+ }
+
+ if (m_assignmentContext == AssignmentContext::DeclarationStatement || m_assignmentContext == AssignmentContext::ConstDeclarationStatement)
+ generator.liftTDZCheckIfPossible(var);
+ return returnResult;
}
// ------------------------------ AssignDotNode -----------------------------------
@@ -1377,10 +1966,11 @@ RegisterID* AssignDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID
{
RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base, m_rightHasAssignments, m_right->isPure(generator));
RefPtr<RegisterID> value = generator.destinationForAssignResult(dst);
- RegisterID* result = generator.emitNode(value.get(), m_right);
+ RefPtr<RegisterID> result = generator.emitNode(value.get(), m_right);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result : generator.moveToDestinationIfNeeded(generator.tempDestination(result), result);
+ RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result.get() : generator.moveToDestinationIfNeeded(generator.tempDestination(result.get()), result.get());
generator.emitPutById(base.get(), m_ident, forwardResult);
+ generator.emitProfileType(forwardResult, divotStart(), divotEnd());
return generator.moveToDestinationIfNeeded(dst, forwardResult);
}
@@ -1392,17 +1982,19 @@ RegisterID* ReadModifyDotNode::emitBytecode(BytecodeGenerator& generator, Regist
generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
RefPtr<RegisterID> value = generator.emitGetById(generator.tempDestination(dst), base.get(), m_ident);
- RegisterID* updatedValue = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
+ RegisterID* updatedValue = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, static_cast<JSC::Operator>(m_operator), OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- return generator.emitPutById(base.get(), m_ident, updatedValue);
+ RegisterID* ret = generator.emitPutById(base.get(), m_ident, updatedValue);
+ generator.emitProfileType(updatedValue, divotStart(), divotEnd());
+ return ret;
}
// ------------------------------ AssignErrorNode -----------------------------------
RegisterID* AssignErrorNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
- return emitThrowReferenceError(generator, "Left side of assignment is not a reference.");
+ return emitThrowReferenceError(generator, ASCIILiteral("Left side of assignment is not a reference."));
}
// ------------------------------ AssignBracketNode -----------------------------------
@@ -1412,11 +2004,17 @@ RegisterID* AssignBracketNode::emitBytecode(BytecodeGenerator& generator, Regist
RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base, m_subscriptHasAssignments || m_rightHasAssignments, m_subscript->isPure(generator) && m_right->isPure(generator));
RefPtr<RegisterID> property = generator.emitNodeForLeftHandSide(m_subscript, m_rightHasAssignments, m_right->isPure(generator));
RefPtr<RegisterID> value = generator.destinationForAssignResult(dst);
- RegisterID* result = generator.emitNode(value.get(), m_right);
+ RefPtr<RegisterID> result = generator.emitNode(value.get(), m_right);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result : generator.moveToDestinationIfNeeded(generator.tempDestination(result), result);
- generator.emitPutByVal(base.get(), property.get(), forwardResult);
+ RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result.get() : generator.moveToDestinationIfNeeded(generator.tempDestination(result.get()), result.get());
+
+ if (isNonIndexStringElement(*m_subscript))
+ generator.emitPutById(base.get(), static_cast<StringNode*>(m_subscript)->value(), forwardResult);
+ else
+ generator.emitPutByVal(base.get(), property.get(), forwardResult);
+
+ generator.emitProfileType(forwardResult, divotStart(), divotEnd());
return generator.moveToDestinationIfNeeded(dst, forwardResult);
}
@@ -1429,10 +2027,11 @@ RegisterID* ReadModifyBracketNode::emitBytecode(BytecodeGenerator& generator, Re
generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());
RefPtr<RegisterID> value = generator.emitGetByVal(generator.tempDestination(dst), base.get(), property.get());
- RegisterID* updatedValue = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
+ RegisterID* updatedValue = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, static_cast<JSC::Operator>(m_operator), OperandTypes(ResultType::unknownType(), m_right->resultDescriptor()));
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
generator.emitPutByVal(base.get(), property.get(), updatedValue);
+ generator.emitProfileType(updatedValue, divotStart(), divotEnd());
return updatedValue;
}
@@ -1441,54 +2040,10 @@ RegisterID* ReadModifyBracketNode::emitBytecode(BytecodeGenerator& generator, Re
RegisterID* CommaNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- ASSERT(m_expressions.size() > 1);
- for (size_t i = 0; i < m_expressions.size() - 1; i++)
- generator.emitNode(generator.ignoredResult(), m_expressions[i]);
- return generator.emitNode(dst, m_expressions.last());
-}
-
-// ------------------------------ ConstDeclNode ------------------------------------
-
-RegisterID* ConstDeclNode::emitCodeSingle(BytecodeGenerator& generator)
-{
- ResolveResult resolveResult = generator.resolveConstDecl(m_ident);
-
- // FIXME: This code does not match the behavior of const in Firefox.
- if (RegisterID* local = resolveResult.local()) {
- if (!m_init)
- return local;
-
- return generator.emitNode(local, m_init);
- }
-
- RefPtr<RegisterID> value = m_init ? generator.emitNode(m_init) : generator.emitLoad(0, jsUndefined());
-
- if (generator.codeType() == GlobalCode)
- return generator.emitInitGlobalConst(m_ident, value.get());
-
- if (generator.codeType() != EvalCode)
- return value.get();
-
- // FIXME: This will result in incorrect assignment if m_ident exists in an intervening with scope.
- RefPtr<RegisterID> base = generator.emitResolveBase(generator.newTemporary(), resolveResult, m_ident);
- return generator.emitPutById(base.get(), m_ident, value.get());
-}
-
-RegisterID* ConstDeclNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
-{
- RegisterID* result = 0;
- for (ConstDeclNode* n = this; n; n = n->m_next)
- result = n->emitCodeSingle(generator);
-
- return result;
-}
-
-// ------------------------------ ConstStatementNode -----------------------------
-
-void ConstStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
-{
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
- generator.emitNode(m_next);
+ CommaNode* node = this;
+ for (; node && node->next(); node = node->next())
+ generator.emitNode(generator.ignoredResult(), node->m_expr);
+ return generator.emitNodeInTailPosition(dst, node->m_expr);
}
// ------------------------------ SourceElements -------------------------------
@@ -1496,15 +2051,13 @@ void ConstStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
inline StatementNode* SourceElements::lastStatement() const
{
- size_t size = m_statements.size();
- return size ? m_statements[size - 1] : 0;
+ return m_tail;
}
inline void SourceElements::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- size_t size = m_statements.size();
- for (size_t i = 0; i < size; ++i)
- generator.emitNode(dst, m_statements[i]);
+ for (StatementNode* statement = m_head; statement; statement = statement->next())
+ generator.emitNodeInTailPosition(dst, statement);
}
// ------------------------------ BlockNode ------------------------------------
@@ -1514,7 +2067,7 @@ inline StatementNode* BlockNode::lastStatement() const
return m_statements ? m_statements->lastStatement() : 0;
}
-inline StatementNode* BlockNode::singleStatement() const
+StatementNode* BlockNode::singleStatement() const
{
return m_statements ? m_statements->singleStatement() : 0;
}
@@ -1523,21 +2076,23 @@ void BlockNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
if (!m_statements)
return;
+ generator.pushLexicalScope(this, BytecodeGenerator::TDZCheckOptimization::Optimize, BytecodeGenerator::NestedScopeType::IsNested);
m_statements->emitBytecode(generator, dst);
+ generator.popLexicalScope(this);
}
// ------------------------------ EmptyStatementNode ---------------------------
void EmptyStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
}
// ------------------------------ DebuggerStatementNode ---------------------------
void DebuggerStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
- generator.emitDebugHook(DidReachBreakpoint, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(DidReachBreakpoint, lastLine(), startOffset(), lineStartOffset());
}
// ------------------------------ ExprStatementNode ----------------------------
@@ -1545,19 +2100,60 @@ void DebuggerStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterI
void ExprStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
ASSERT(m_expr);
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
generator.emitNode(dst, m_expr);
}
-// ------------------------------ VarStatementNode ----------------------------
+// ------------------------------ DeclarationStatement ----------------------------
-void VarStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
+void DeclarationStatement::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
ASSERT(m_expr);
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
generator.emitNode(m_expr);
}
+// ------------------------------ EmptyVarExpression ----------------------------
+
+RegisterID* EmptyVarExpression::emitBytecode(BytecodeGenerator& generator, RegisterID*)
+{
+ // It's safe to return null here because this node will always be a child node of DeclarationStatement which ignores our return value.
+ if (!generator.vm()->typeProfiler())
+ return nullptr;
+
+ Variable var = generator.variable(m_ident);
+ if (RegisterID* local = var.local())
+ generator.emitProfileType(local, var, position(), JSTextPosition(-1, position().offset + m_ident.length(), -1));
+ else {
+ RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);
+ RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, DoNotThrowIfNotFound);
+ generator.emitProfileType(value.get(), var, position(), JSTextPosition(-1, position().offset + m_ident.length(), -1));
+ }
+
+ return nullptr;
+}
+
+// ------------------------------ EmptyLetExpression ----------------------------
+
+RegisterID* EmptyLetExpression::emitBytecode(BytecodeGenerator& generator, RegisterID*)
+{
+ // Lexical declarations like 'let' must move undefined into their variables so we don't
+ // get TDZ errors for situations like this: `let x; x;`
+ Variable var = generator.variable(m_ident);
+ if (RegisterID* local = var.local()) {
+ generator.emitLoad(local, jsUndefined());
+ generator.emitProfileType(local, var, position(), JSTextPosition(-1, position().offset + m_ident.length(), -1));
+ } else {
+ RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);
+ RefPtr<RegisterID> value = generator.emitLoad(nullptr, jsUndefined());
+ generator.emitPutToScope(scope.get(), var, value.get(), generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound, Initialization);
+ generator.emitProfileType(value.get(), var, position(), JSTextPosition(-1, position().offset + m_ident.length(), -1));
+ }
+
+ // It's safe to return null here because this node will always be a child node of DeclarationStatement which ignores our return value.
+ return nullptr;
+}
+
// ------------------------------ IfElseNode ---------------------------------------
static inline StatementNode* singleStatement(StatementNode* statementNode)
@@ -1599,7 +2195,7 @@ bool IfElseNode::tryFoldBreakAndContinue(BytecodeGenerator& generator, Statement
void IfElseNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
RefPtr<Label> beforeThen = generator.newLabel();
RefPtr<Label> beforeElse = generator.newLabel();
@@ -1612,19 +2208,24 @@ void IfElseNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
generator.emitNodeInConditionContext(m_condition, trueTarget, falseTarget, fallThroughMode);
generator.emitLabel(beforeThen.get());
+ generator.emitProfileControlFlow(m_ifBlock->startOffset());
if (!didFoldIfBlock) {
- generator.emitNode(dst, m_ifBlock);
+ generator.emitNodeInTailPosition(dst, m_ifBlock);
if (m_elseBlock)
generator.emitJump(afterElse.get());
}
generator.emitLabel(beforeElse.get());
- if (m_elseBlock)
- generator.emitNode(dst, m_elseBlock);
+ if (m_elseBlock) {
+ generator.emitProfileControlFlow(m_ifBlock->endOffset() + (m_ifBlock->isBlock() ? 1 : 0));
+ generator.emitNodeInTailPosition(dst, m_elseBlock);
+ }
generator.emitLabel(afterElse.get());
+ StatementNode* endingBlock = m_elseBlock ? m_elseBlock : m_ifBlock;
+ generator.emitProfileControlFlow(endingBlock->endOffset() + (endingBlock->isBlock() ? 1 : 0));
}
// ------------------------------ DoWhileNode ----------------------------------
@@ -1636,12 +2237,12 @@ void DoWhileNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
RefPtr<Label> topOfLoop = generator.newLabel();
generator.emitLabel(topOfLoop.get());
generator.emitLoopHint();
- generator.emitDebugHook(WillExecuteStatement, lastLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, lastLine(), startOffset(), lineStartOffset());
- generator.emitNode(dst, m_statement);
+ generator.emitNodeInTailPosition(dst, m_statement);
generator.emitLabel(scope->continueTarget());
- generator.emitDebugHook(WillExecuteStatement, lastLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, lastLine(), startOffset(), lineStartOffset());
generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), FallThroughMeansFalse);
generator.emitLabel(scope->breakTarget());
@@ -1654,20 +2255,23 @@ void WhileNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
LabelScopePtr scope = generator.newLabelScope(LabelScope::Loop);
RefPtr<Label> topOfLoop = generator.newLabel();
- generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->lineNo(), m_expr->startOffset(), m_expr->lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, m_expr->firstLine(), m_expr->startOffset(), m_expr->lineStartOffset());
generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), FallThroughMeansTrue);
generator.emitLabel(topOfLoop.get());
generator.emitLoopHint();
- generator.emitNode(dst, m_statement);
+ generator.emitProfileControlFlow(m_statement->startOffset());
+ generator.emitNodeInTailPosition(dst, m_statement);
generator.emitLabel(scope->continueTarget());
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), FallThroughMeansFalse);
generator.emitLabel(scope->breakTarget());
+
+ generator.emitProfileControlFlow(m_statement->endOffset() + (m_statement->isBlock() ? 1 : 0));
}
// ------------------------------ ForNode --------------------------------------
@@ -1676,7 +2280,10 @@ void ForNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
LabelScopePtr scope = generator.newLabelScope(LabelScope::Loop);
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ RegisterID* forLoopSymbolTable = nullptr;
+ generator.pushLexicalScope(this, BytecodeGenerator::TDZCheckOptimization::Optimize, BytecodeGenerator::NestedScopeType::IsNested, &forLoopSymbolTable);
+
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
if (m_expr1)
generator.emitNode(generator.ignoredResult(), m_expr1);
@@ -1687,11 +2294,13 @@ void ForNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
generator.emitLabel(topOfLoop.get());
generator.emitLoopHint();
+ generator.emitProfileControlFlow(m_statement->startOffset());
- generator.emitNode(dst, m_statement);
+ generator.emitNodeInTailPosition(dst, m_statement);
generator.emitLabel(scope->continueTarget());
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
+ generator.prepareLexicalScopeForNextForLoopIteration(this, forLoopSymbolTable);
if (m_expr3)
generator.emitNode(generator.ignoredResult(), m_expr3);
@@ -1701,87 +2310,299 @@ void ForNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
generator.emitJump(topOfLoop.get());
generator.emitLabel(scope->breakTarget());
+ generator.popLexicalScope(this);
+ generator.emitProfileControlFlow(m_statement->endOffset() + (m_statement->isBlock() ? 1 : 0));
}
// ------------------------------ ForInNode ------------------------------------
-void ForInNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+RegisterID* ForInNode::tryGetBoundLocal(BytecodeGenerator& generator)
{
- LabelScopePtr scope = generator.newLabelScope(LabelScope::Loop);
-
- if (!m_lexpr->isLocation()) {
- emitThrowReferenceError(generator, "Left side of for-in statement is not a reference.");
- return;
+ if (m_lexpr->isResolveNode()) {
+ const Identifier& ident = static_cast<ResolveNode*>(m_lexpr)->identifier();
+ return generator.variable(ident).local();
}
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
-
- if (m_init)
- generator.emitNode(generator.ignoredResult(), m_init);
-
- RefPtr<RegisterID> base = generator.newTemporary();
- generator.emitNode(base.get(), m_expr);
- RefPtr<RegisterID> i = generator.newTemporary();
- RefPtr<RegisterID> size = generator.newTemporary();
- RefPtr<RegisterID> expectedSubscript;
- RefPtr<RegisterID> iter = generator.emitGetPropertyNames(generator.newTemporary(), base.get(), i.get(), size.get(), scope->breakTarget());
- generator.emitJump(scope->continueTarget());
+ if (m_lexpr->isDestructuringNode()) {
+ DestructuringAssignmentNode* assignNode = static_cast<DestructuringAssignmentNode*>(m_lexpr);
+ auto binding = assignNode->bindings();
+ if (!binding->isBindingNode())
+ return nullptr;
+
+ auto simpleBinding = static_cast<BindingNode*>(binding);
+ const Identifier& ident = simpleBinding->boundProperty();
+ Variable var = generator.variable(ident);
+ if (var.isSpecial())
+ return nullptr;
+ return var.local();
+ }
- RefPtr<Label> loopStart = generator.newLabel();
- generator.emitLabel(loopStart.get());
- generator.emitLoopHint();
+ return nullptr;
+}
- RegisterID* propertyName;
- bool optimizedForinAccess = false;
+void ForInNode::emitLoopHeader(BytecodeGenerator& generator, RegisterID* propertyName)
+{
if (m_lexpr->isResolveNode()) {
const Identifier& ident = static_cast<ResolveNode*>(m_lexpr)->identifier();
- ResolveResult resolveResult = generator.resolve(ident);
- propertyName = resolveResult.local();
- if (!propertyName) {
- propertyName = generator.newTemporary();
- RefPtr<RegisterID> protect = propertyName;
- NonlocalResolveInfo resolveVerifier;
+ Variable var = generator.variable(ident);
+ if (RegisterID* local = var.local())
+ generator.emitMove(local, propertyName);
+ else {
if (generator.isStrictMode())
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- RegisterID* base = generator.emitResolveBaseForPut(generator.newTemporary(), resolveResult, ident, resolveVerifier);
-
+ RegisterID* scope = generator.emitResolveScope(nullptr, var);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
- generator.emitPutToBase(base, ident, propertyName, resolveVerifier);
- } else {
- expectedSubscript = generator.emitMove(generator.newTemporary(), propertyName);
- generator.pushOptimisedForIn(expectedSubscript.get(), iter.get(), i.get(), propertyName);
- optimizedForinAccess = true;
+ generator.emitPutToScope(scope, var, propertyName, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound, NotInitialization);
}
- } else if (m_lexpr->isDotAccessorNode()) {
+ generator.emitProfileType(propertyName, var, m_lexpr->position(), JSTextPosition(-1, m_lexpr->position().offset + ident.length(), -1));
+ return;
+ }
+ if (m_lexpr->isDotAccessorNode()) {
DotAccessorNode* assignNode = static_cast<DotAccessorNode*>(m_lexpr);
const Identifier& ident = assignNode->identifier();
- propertyName = generator.newTemporary();
- RefPtr<RegisterID> protect = propertyName;
RegisterID* base = generator.emitNode(assignNode->base());
-
generator.emitExpressionInfo(assignNode->divot(), assignNode->divotStart(), assignNode->divotEnd());
generator.emitPutById(base, ident, propertyName);
- } else {
- ASSERT(m_lexpr->isBracketAccessorNode());
+ generator.emitProfileType(propertyName, assignNode->divotStart(), assignNode->divotEnd());
+ return;
+ }
+ if (m_lexpr->isBracketAccessorNode()) {
BracketAccessorNode* assignNode = static_cast<BracketAccessorNode*>(m_lexpr);
- propertyName = generator.newTemporary();
- RefPtr<RegisterID> protect = propertyName;
RefPtr<RegisterID> base = generator.emitNode(assignNode->base());
RegisterID* subscript = generator.emitNode(assignNode->subscript());
-
generator.emitExpressionInfo(assignNode->divot(), assignNode->divotStart(), assignNode->divotEnd());
generator.emitPutByVal(base.get(), subscript, propertyName);
- }
+ generator.emitProfileType(propertyName, assignNode->divotStart(), assignNode->divotEnd());
+ return;
+ }
- generator.emitNode(dst, m_statement);
+ if (m_lexpr->isDestructuringNode()) {
+ DestructuringAssignmentNode* assignNode = static_cast<DestructuringAssignmentNode*>(m_lexpr);
+ auto binding = assignNode->bindings();
+ if (!binding->isBindingNode()) {
+ assignNode->bindings()->bindValue(generator, propertyName);
+ return;
+ }
- if (optimizedForinAccess)
- generator.popOptimisedForIn();
+ auto simpleBinding = static_cast<BindingNode*>(binding);
+ const Identifier& ident = simpleBinding->boundProperty();
+ Variable var = generator.variable(ident);
+ if (!var.local() || var.isSpecial()) {
+ assignNode->bindings()->bindValue(generator, propertyName);
+ return;
+ }
+ generator.emitMove(var.local(), propertyName);
+ generator.emitProfileType(propertyName, var, simpleBinding->divotStart(), simpleBinding->divotEnd());
+ return;
+ }
- generator.emitLabel(scope->continueTarget());
- generator.emitNextPropertyName(propertyName, base.get(), i.get(), size.get(), iter.get(), loopStart.get());
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
- generator.emitLabel(scope->breakTarget());
+ RELEASE_ASSERT_NOT_REACHED();
+}
+
+void ForInNode::emitMultiLoopBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (!m_lexpr->isAssignmentLocation()) {
+ emitThrowReferenceError(generator, ASCIILiteral("Left side of for-in statement is not a reference."));
+ return;
+ }
+
+ RefPtr<Label> end = generator.newLabel();
+
+ RegisterID* forLoopSymbolTable = nullptr;
+ generator.pushLexicalScope(this, BytecodeGenerator::TDZCheckOptimization::Optimize, BytecodeGenerator::NestedScopeType::IsNested, &forLoopSymbolTable);
+
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
+
+ RefPtr<RegisterID> base = generator.newTemporary();
+ RefPtr<RegisterID> length;
+ RefPtr<RegisterID> enumerator;
+ generator.emitNode(base.get(), m_expr);
+ RefPtr<RegisterID> local = this->tryGetBoundLocal(generator);
+ RefPtr<RegisterID> enumeratorIndex;
+
+ int profilerStartOffset = m_statement->startOffset();
+ int profilerEndOffset = m_statement->endOffset() + (m_statement->isBlock() ? 1 : 0);
+
+ enumerator = generator.emitGetPropertyEnumerator(generator.newTemporary(), base.get());
+
+ // Indexed property loop.
+ {
+ LabelScopePtr scope = generator.newLabelScope(LabelScope::Loop);
+ RefPtr<Label> loopStart = generator.newLabel();
+ RefPtr<Label> loopEnd = generator.newLabel();
+
+ length = generator.emitGetEnumerableLength(generator.newTemporary(), enumerator.get());
+ RefPtr<RegisterID> i = generator.emitLoad(generator.newTemporary(), jsNumber(0));
+ RefPtr<RegisterID> propertyName = generator.newTemporary();
+
+ generator.emitLabel(loopStart.get());
+ generator.emitLoopHint();
+
+ RefPtr<RegisterID> result = generator.emitEqualityOp(op_less, generator.newTemporary(), i.get(), length.get());
+ generator.emitJumpIfFalse(result.get(), loopEnd.get());
+ generator.emitHasIndexedProperty(result.get(), base.get(), i.get());
+ generator.emitJumpIfFalse(result.get(), scope->continueTarget());
+
+ generator.emitToIndexString(propertyName.get(), i.get());
+ this->emitLoopHeader(generator, propertyName.get());
+
+ generator.emitProfileControlFlow(profilerStartOffset);
+
+ generator.pushIndexedForInScope(local.get(), i.get());
+ generator.emitNode(dst, m_statement);
+ generator.popIndexedForInScope(local.get());
+
+ generator.emitProfileControlFlow(profilerEndOffset);
+
+ generator.emitLabel(scope->continueTarget());
+ generator.prepareLexicalScopeForNextForLoopIteration(this, forLoopSymbolTable);
+ generator.emitInc(i.get());
+ generator.emitJump(loopStart.get());
+
+ generator.emitLabel(scope->breakTarget());
+ generator.emitJump(end.get());
+ generator.emitLabel(loopEnd.get());
+ }
+
+ // Structure property loop.
+ {
+ LabelScopePtr scope = generator.newLabelScope(LabelScope::Loop);
+ RefPtr<Label> loopStart = generator.newLabel();
+ RefPtr<Label> loopEnd = generator.newLabel();
+
+ enumeratorIndex = generator.emitLoad(generator.newTemporary(), jsNumber(0));
+ RefPtr<RegisterID> propertyName = generator.newTemporary();
+ generator.emitEnumeratorStructurePropertyName(propertyName.get(), enumerator.get(), enumeratorIndex.get());
+
+ generator.emitLabel(loopStart.get());
+ generator.emitLoopHint();
+
+ RefPtr<RegisterID> result = generator.emitUnaryOp(op_eq_null, generator.newTemporary(), propertyName.get());
+ generator.emitJumpIfTrue(result.get(), loopEnd.get());
+ generator.emitHasStructureProperty(result.get(), base.get(), propertyName.get(), enumerator.get());
+ generator.emitJumpIfFalse(result.get(), scope->continueTarget());
+
+ this->emitLoopHeader(generator, propertyName.get());
+
+ generator.emitProfileControlFlow(profilerStartOffset);
+
+ generator.pushStructureForInScope(local.get(), enumeratorIndex.get(), propertyName.get(), enumerator.get());
+ generator.emitNode(dst, m_statement);
+ generator.popStructureForInScope(local.get());
+
+ generator.emitProfileControlFlow(profilerEndOffset);
+
+ generator.emitLabel(scope->continueTarget());
+ generator.prepareLexicalScopeForNextForLoopIteration(this, forLoopSymbolTable);
+ generator.emitInc(enumeratorIndex.get());
+ generator.emitEnumeratorStructurePropertyName(propertyName.get(), enumerator.get(), enumeratorIndex.get());
+ generator.emitJump(loopStart.get());
+
+ generator.emitLabel(scope->breakTarget());
+ generator.emitJump(end.get());
+ generator.emitLabel(loopEnd.get());
+ }
+
+ // Generic property loop.
+ {
+ LabelScopePtr scope = generator.newLabelScope(LabelScope::Loop);
+ RefPtr<Label> loopStart = generator.newLabel();
+ RefPtr<Label> loopEnd = generator.newLabel();
+
+ RefPtr<RegisterID> propertyName = generator.newTemporary();
+
+ generator.emitEnumeratorGenericPropertyName(propertyName.get(), enumerator.get(), enumeratorIndex.get());
+
+ generator.emitLabel(loopStart.get());
+ generator.emitLoopHint();
+
+ RefPtr<RegisterID> result = generator.emitUnaryOp(op_eq_null, generator.newTemporary(), propertyName.get());
+ generator.emitJumpIfTrue(result.get(), loopEnd.get());
+
+ generator.emitHasGenericProperty(result.get(), base.get(), propertyName.get());
+ generator.emitJumpIfFalse(result.get(), scope->continueTarget());
+
+ this->emitLoopHeader(generator, propertyName.get());
+
+ generator.emitProfileControlFlow(profilerStartOffset);
+
+ generator.emitNode(dst, m_statement);
+
+ generator.emitLabel(scope->continueTarget());
+ generator.prepareLexicalScopeForNextForLoopIteration(this, forLoopSymbolTable);
+ generator.emitInc(enumeratorIndex.get());
+ generator.emitEnumeratorGenericPropertyName(propertyName.get(), enumerator.get(), enumeratorIndex.get());
+ generator.emitJump(loopStart.get());
+
+ generator.emitLabel(scope->breakTarget());
+ generator.emitJump(end.get());
+ generator.emitLabel(loopEnd.get());
+ }
+
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
+ generator.emitLabel(end.get());
+ generator.popLexicalScope(this);
+ generator.emitProfileControlFlow(profilerEndOffset);
+}
+
+void ForInNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ this->emitMultiLoopBytecode(generator, dst);
+}
+
+// ------------------------------ ForOfNode ------------------------------------
+void ForOfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (!m_lexpr->isAssignmentLocation()) {
+ emitThrowReferenceError(generator, ASCIILiteral("Left side of for-of statement is not a reference."));
+ return;
+ }
+
+ RegisterID* forLoopSymbolTable = nullptr;
+ generator.pushLexicalScope(this, BytecodeGenerator::TDZCheckOptimization::Optimize, BytecodeGenerator::NestedScopeType::IsNested, &forLoopSymbolTable);
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
+ auto extractor = [this, dst](BytecodeGenerator& generator, RegisterID* value)
+ {
+ if (m_lexpr->isResolveNode()) {
+ const Identifier& ident = static_cast<ResolveNode*>(m_lexpr)->identifier();
+ Variable var = generator.variable(ident);
+ if (RegisterID* local = var.local())
+ generator.emitMove(local, value);
+ else {
+ if (generator.isStrictMode())
+ generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
+ RegisterID* scope = generator.emitResolveScope(nullptr, var);
+ generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
+ generator.emitPutToScope(scope, var, value, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound, NotInitialization);
+ }
+ generator.emitProfileType(value, var, m_lexpr->position(), JSTextPosition(-1, m_lexpr->position().offset + ident.length(), -1));
+ } else if (m_lexpr->isDotAccessorNode()) {
+ DotAccessorNode* assignNode = static_cast<DotAccessorNode*>(m_lexpr);
+ const Identifier& ident = assignNode->identifier();
+ RefPtr<RegisterID> base = generator.emitNode(assignNode->base());
+
+ generator.emitExpressionInfo(assignNode->divot(), assignNode->divotStart(), assignNode->divotEnd());
+ generator.emitPutById(base.get(), ident, value);
+ generator.emitProfileType(value, assignNode->divotStart(), assignNode->divotEnd());
+ } else if (m_lexpr->isBracketAccessorNode()) {
+ BracketAccessorNode* assignNode = static_cast<BracketAccessorNode*>(m_lexpr);
+ RefPtr<RegisterID> base = generator.emitNode(assignNode->base());
+ RegisterID* subscript = generator.emitNode(assignNode->subscript());
+
+ generator.emitExpressionInfo(assignNode->divot(), assignNode->divotStart(), assignNode->divotEnd());
+ generator.emitPutByVal(base.get(), subscript, value);
+ generator.emitProfileType(value, assignNode->divotStart(), assignNode->divotEnd());
+ } else {
+ ASSERT(m_lexpr->isDestructuringNode());
+ DestructuringAssignmentNode* assignNode = static_cast<DestructuringAssignmentNode*>(m_lexpr);
+ assignNode->bindings()->bindValue(generator, value);
+ }
+ generator.emitProfileControlFlow(m_statement->startOffset());
+ generator.emitNode(dst, m_statement);
+ };
+ generator.emitEnumeration(this, m_expr, extractor, this, forLoopSymbolTable);
+ generator.popLexicalScope(this);
+ generator.emitProfileControlFlow(m_statement->endOffset() + (m_statement->isBlock() ? 1 : 0));
}
// ------------------------------ ContinueNode ---------------------------------
@@ -1791,10 +2612,10 @@ Label* ContinueNode::trivialTarget(BytecodeGenerator& generator)
if (generator.shouldEmitDebugHooks())
return 0;
- LabelScope* scope = generator.continueTarget(m_ident);
+ LabelScopePtr scope = generator.continueTarget(m_ident);
ASSERT(scope);
- if (generator.scopeDepth() != scope->scopeDepth())
+ if (generator.labelScopeDepth() != scope->scopeDepth())
return 0;
return scope->continueTarget();
@@ -1802,13 +2623,15 @@ Label* ContinueNode::trivialTarget(BytecodeGenerator& generator)
void ContinueNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
- LabelScope* scope = generator.continueTarget(m_ident);
+ LabelScopePtr scope = generator.continueTarget(m_ident);
ASSERT(scope);
- generator.emitPopScopes(scope->scopeDepth());
+ generator.emitPopScopes(generator.scopeRegister(), scope->scopeDepth());
generator.emitJump(scope->continueTarget());
+
+ generator.emitProfileControlFlow(endOffset());
}
// ------------------------------ BreakNode ------------------------------------
@@ -1818,10 +2641,10 @@ Label* BreakNode::trivialTarget(BytecodeGenerator& generator)
if (generator.shouldEmitDebugHooks())
return 0;
- LabelScope* scope = generator.breakTarget(m_ident);
+ LabelScopePtr scope = generator.breakTarget(m_ident);
ASSERT(scope);
- if (generator.scopeDepth() != scope->scopeDepth())
+ if (generator.labelScopeDepth() != scope->scopeDepth())
return 0;
return scope->breakTarget();
@@ -1829,52 +2652,62 @@ Label* BreakNode::trivialTarget(BytecodeGenerator& generator)
void BreakNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
- LabelScope* scope = generator.breakTarget(m_ident);
+ LabelScopePtr scope = generator.breakTarget(m_ident);
ASSERT(scope);
- generator.emitPopScopes(scope->scopeDepth());
+ generator.emitPopScopes(generator.scopeRegister(), scope->scopeDepth());
generator.emitJump(scope->breakTarget());
+
+ generator.emitProfileControlFlow(endOffset());
}
// ------------------------------ ReturnNode -----------------------------------
void ReturnNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
ASSERT(generator.codeType() == FunctionCode);
if (dst == generator.ignoredResult())
dst = 0;
- RefPtr<RegisterID> returnRegister = m_value ? generator.emitNode(dst, m_value) : generator.emitLoad(dst, jsUndefined());
- if (generator.scopeDepth()) {
+ RefPtr<RegisterID> returnRegister = m_value ? generator.emitNodeInTailPosition(dst, m_value) : generator.emitLoad(dst, jsUndefined());
+
+ generator.emitProfileType(returnRegister.get(), ProfileTypeBytecodeFunctionReturnStatement, divotStart(), divotEnd());
+ if (generator.isInFinallyBlock()) {
returnRegister = generator.emitMove(generator.newTemporary(), returnRegister.get());
- generator.emitPopScopes(0);
+ generator.emitPopScopes(generator.scopeRegister(), 0);
}
- generator.emitDebugHook(WillLeaveCallFrame, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillLeaveCallFrame, lastLine(), startOffset(), lineStartOffset());
generator.emitReturn(returnRegister.get());
+ generator.emitProfileControlFlow(endOffset());
+ // Emitting an unreachable return here is needed in case this op_profile_control_flow is the
+ // last opcode in a CodeBlock because a CodeBlock's instructions must end with a terminal opcode.
+ if (generator.vm()->controlFlowProfiler())
+ generator.emitReturn(generator.emitLoad(nullptr, jsUndefined()));
}
// ------------------------------ WithNode -------------------------------------
void WithNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
RefPtr<RegisterID> scope = generator.emitNode(m_expr);
generator.emitExpressionInfo(m_divot, m_divot - m_expressionLength, m_divot);
generator.emitPushWithScope(scope.get());
- generator.emitNode(dst, m_statement);
- generator.emitPopScope();
+ generator.emitNodeInTailPosition(dst, m_statement);
+ generator.emitPopWithScope();
}
// ------------------------------ CaseClauseNode --------------------------------
inline void CaseClauseNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
+ generator.emitProfileControlFlow(m_startOffset);
if (!m_statements)
return;
m_statements->emitBytecode(generator, dst);
@@ -2036,26 +2869,30 @@ void CaseBlockNode::emitBytecodeForBlock(BytecodeGenerator& generator, RegisterI
void SwitchNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
LabelScopePtr scope = generator.newLabelScope(LabelScope::Switch);
RefPtr<RegisterID> r0 = generator.emitNode(m_expr);
+
+ generator.pushLexicalScope(this, BytecodeGenerator::TDZCheckOptimization::DoNotOptimize, BytecodeGenerator::NestedScopeType::IsNested);
m_block->emitBytecodeForBlock(generator, r0.get(), dst);
+ generator.popLexicalScope(this);
generator.emitLabel(scope->breakTarget());
+ generator.emitProfileControlFlow(endOffset());
}
// ------------------------------ LabelNode ------------------------------------
void LabelNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
ASSERT(!generator.breakTarget(m_name));
LabelScopePtr scope = generator.newLabelScope(LabelScope::NamedLabel, &m_name);
- generator.emitNode(dst, m_statement);
+ generator.emitNodeInTailPosition(dst, m_statement);
generator.emitLabel(scope->breakTarget());
}
@@ -2064,13 +2901,15 @@ void LabelNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
void ThrowNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
{
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
if (dst == generator.ignoredResult())
dst = 0;
RefPtr<RegisterID> expr = generator.emitNode(m_expr);
generator.emitExpressionInfo(divot(), divotStart(), divotEnd());
generator.emitThrow(expr.get());
+
+ generator.emitProfileControlFlow(endOffset());
}
// ------------------------------ TryNode --------------------------------------
@@ -2080,7 +2919,7 @@ void TryNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
// NOTE: The catch and finally blocks must be labeled explicitly, so the
// optimizer knows they may be jumped to from anywhere.
- generator.emitDebugHook(WillExecuteStatement, firstLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset());
ASSERT(m_catchBlock || m_finallyBlock);
@@ -2101,17 +2940,24 @@ void TryNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
// Uncaught exception path: the catch block.
RefPtr<Label> here = generator.emitLabel(generator.newLabel().get());
- RefPtr<RegisterID> exceptionRegister = generator.popTryAndEmitCatch(tryData, generator.newTemporary(), here.get());
+ RefPtr<RegisterID> exceptionRegister = generator.newTemporary();
+ RefPtr<RegisterID> thrownValueRegister = generator.newTemporary();
+ generator.popTryAndEmitCatch(tryData, exceptionRegister.get(), thrownValueRegister.get(), here.get(), HandlerType::Catch);
if (m_finallyBlock) {
// If the catch block throws an exception and we have a finally block, then the finally
// block should "catch" that exception.
tryData = generator.pushTry(here.get());
}
-
- generator.emitPushNameScope(m_exceptionIdent, exceptionRegister.get(), DontDelete);
- generator.emitNode(dst, m_catchBlock);
- generator.emitPopScope();
+
+ generator.emitPushCatchScope(m_lexicalVariables);
+ m_catchPattern->bindValue(generator, thrownValueRegister.get());
+ generator.emitProfileControlFlow(m_tryBlock->endOffset() + 1);
+ if (m_finallyBlock)
+ generator.emitNode(dst, m_catchBlock);
+ else
+ generator.emitNodeInTailPosition(dst, m_catchBlock);
+ generator.emitPopCatchScope(m_lexicalVariables);
generator.emitLabel(catchEndLabel.get());
}
@@ -2122,17 +2968,27 @@ void TryNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
RefPtr<Label> finallyEndLabel = generator.newLabel();
+ int finallyStartOffset = m_catchBlock ? m_catchBlock->endOffset() + 1 : m_tryBlock->endOffset() + 1;
+
// Normal path: run the finally code, and jump to the end.
- generator.emitNode(dst, m_finallyBlock);
+ generator.emitProfileControlFlow(finallyStartOffset);
+ generator.emitNodeInTailPosition(dst, m_finallyBlock);
+ generator.emitProfileControlFlow(m_finallyBlock->endOffset() + 1);
generator.emitJump(finallyEndLabel.get());
// Uncaught exception path: invoke the finally block, then re-throw the exception.
- RefPtr<RegisterID> tempExceptionRegister = generator.popTryAndEmitCatch(tryData, generator.newTemporary(), preFinallyLabel.get());
- generator.emitNode(dst, m_finallyBlock);
- generator.emitThrow(tempExceptionRegister.get());
+ RefPtr<RegisterID> exceptionRegister = generator.newTemporary();
+ RefPtr<RegisterID> thrownValueRegister = generator.newTemporary();
+ generator.popTryAndEmitCatch(tryData, exceptionRegister.get(), thrownValueRegister.get(), preFinallyLabel.get(), HandlerType::Finally);
+ generator.emitProfileControlFlow(finallyStartOffset);
+ generator.emitNodeInTailPosition(dst, m_finallyBlock);
+ generator.emitThrow(exceptionRegister.get());
generator.emitLabel(finallyEndLabel.get());
- }
+ generator.emitProfileControlFlow(m_finallyBlock->endOffset() + 1);
+ } else
+ generator.emitProfileControlFlow(m_catchBlock->endOffset() + 1);
+
}
// ------------------------------ ScopeNode -----------------------------
@@ -2144,74 +3000,156 @@ inline void ScopeNode::emitStatementsBytecode(BytecodeGenerator& generator, Regi
m_statements->emitBytecode(generator, dst);
}
-// ------------------------------ ProgramNode -----------------------------
-
-void ProgramNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
+static void emitProgramNodeBytecode(BytecodeGenerator& generator, ScopeNode& scopeNode)
{
- generator.emitDebugHook(WillExecuteProgram, startLine(), startLine(), startStartOffset(), startLineStartOffset());
+ generator.emitDebugHook(WillExecuteProgram, scopeNode.startLine(), scopeNode.startStartOffset(), scopeNode.startLineStartOffset());
RefPtr<RegisterID> dstRegister = generator.newTemporary();
generator.emitLoad(dstRegister.get(), jsUndefined());
- emitStatementsBytecode(generator, dstRegister.get());
+ generator.emitProfileControlFlow(scopeNode.startStartOffset());
+ scopeNode.emitStatementsBytecode(generator, dstRegister.get());
- generator.emitDebugHook(DidExecuteProgram, lastLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(DidExecuteProgram, scopeNode.lastLine(), scopeNode.startOffset(), scopeNode.lineStartOffset());
generator.emitEnd(dstRegister.get());
}
+// ------------------------------ ProgramNode -----------------------------
+
+void ProgramNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
+{
+ emitProgramNodeBytecode(generator, *this);
+}
+
+// ------------------------------ ModuleProgramNode --------------------
+
+void ModuleProgramNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
+{
+ emitProgramNodeBytecode(generator, *this);
+}
+
// ------------------------------ EvalNode -----------------------------
void EvalNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
- generator.emitDebugHook(WillExecuteProgram, startLine(), startLine(), startStartOffset(), startLineStartOffset());
+ generator.emitDebugHook(WillExecuteProgram, startLine(), startStartOffset(), startLineStartOffset());
RefPtr<RegisterID> dstRegister = generator.newTemporary();
generator.emitLoad(dstRegister.get(), jsUndefined());
emitStatementsBytecode(generator, dstRegister.get());
- generator.emitDebugHook(DidExecuteProgram, lastLine(), lastLine(), startOffset(), lineStartOffset());
+ generator.emitDebugHook(DidExecuteProgram, lastLine(), startOffset(), lineStartOffset());
generator.emitEnd(dstRegister.get());
}
-// ------------------------------ FunctionBodyNode -----------------------------
+// ------------------------------ FunctionNode -----------------------------
-void FunctionBodyNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
+void FunctionNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
{
- generator.emitDebugHook(DidEnterCallFrame, startLine(), startLine(), startStartOffset(), startLineStartOffset());
- emitStatementsBytecode(generator, generator.ignoredResult());
+ if (generator.vm()->typeProfiler()) {
+ for (size_t i = 0; i < m_parameters->size(); i++) {
+ // Destructuring parameters are handled in destructuring nodes.
+ if (!m_parameters->at(i).first->isBindingNode())
+ continue;
+ BindingNode* parameter = static_cast<BindingNode*>(m_parameters->at(i).first);
+ RegisterID reg(CallFrame::argumentOffset(i));
+ generator.emitProfileType(&reg, ProfileTypeBytecodeFunctionArgument, parameter->divotStart(), parameter->divotEnd());
+ }
+ }
+
+ generator.emitProfileControlFlow(startStartOffset());
+ generator.emitDebugHook(DidEnterCallFrame, startLine(), startStartOffset(), startLineStartOffset());
+
+ switch (generator.parseMode()) {
+ case SourceParseMode::GeneratorWrapperFunctionMode: {
+ StatementNode* singleStatement = this->singleStatement();
+ ASSERT(singleStatement->isExprStatement());
+ ExprStatementNode* exprStatement = static_cast<ExprStatementNode*>(singleStatement);
+ ExpressionNode* expr = exprStatement->expr();
+ ASSERT(expr->isFuncExprNode());
+ FuncExprNode* funcExpr = static_cast<FuncExprNode*>(expr);
- StatementNode* singleStatement = this->singleStatement();
- ReturnNode* returnNode = 0;
+ RefPtr<RegisterID> next = generator.newTemporary();
+ generator.emitNode(next.get(), funcExpr);
- // Check for a return statement at the end of a function composed of a single block.
- if (singleStatement && singleStatement->isBlock()) {
- StatementNode* lastStatementInBlock = static_cast<BlockNode*>(singleStatement)->lastStatement();
- if (lastStatementInBlock && lastStatementInBlock->isReturnNode())
- returnNode = static_cast<ReturnNode*>(lastStatementInBlock);
+ if (generator.superBinding() == SuperBinding::Needed) {
+ RefPtr<RegisterID> homeObject = emitHomeObjectForCallee(generator);
+ emitPutHomeObject(generator, next.get(), homeObject.get());
+ }
+
+ // FIXME: Currently, we just create an object and store generator related fields as its properties for ease.
+ // But to make it efficient, we will introduce JSGenerator class, add opcode new_generator and use its C++ fields instead of these private properties.
+ // https://bugs.webkit.org/show_bug.cgi?id=151545
+
+ generator.emitDirectPutById(generator.generatorRegister(), generator.propertyNames().generatorNextPrivateName, next.get(), PropertyNode::KnownDirect);
+
+ generator.emitDirectPutById(generator.generatorRegister(), generator.propertyNames().generatorThisPrivateName, generator.thisRegister(), PropertyNode::KnownDirect);
+
+ RegisterID* initialState = generator.emitLoad(nullptr, jsNumber(0));
+ generator.emitDirectPutById(generator.generatorRegister(), generator.propertyNames().generatorStatePrivateName, initialState, PropertyNode::KnownDirect);
+
+ generator.emitDirectPutById(generator.generatorRegister(), generator.propertyNames().generatorFramePrivateName, generator.emitLoad(nullptr, jsNull()), PropertyNode::KnownDirect);
+
+ ASSERT(startOffset() >= lineStartOffset());
+ generator.emitDebugHook(WillLeaveCallFrame, lastLine(), startOffset(), lineStartOffset());
+ generator.emitReturn(generator.generatorRegister());
+ break;
}
- // If there is no return we must automatically insert one.
- if (!returnNode) {
- RegisterID* r0 = generator.isConstructor() ? generator.thisRegister() : generator.emitLoad(0, jsUndefined());
- ASSERT((startOffset() - 1) >= lineStartOffset());
- generator.emitDebugHook(WillLeaveCallFrame, lastLine(), lastLine(), startOffset() - 1, lineStartOffset());
- generator.emitReturn(r0);
- return;
+ case SourceParseMode::GeneratorBodyMode: {
+ RefPtr<Label> generatorBodyLabel = generator.newLabel();
+ {
+ RefPtr<RegisterID> condition = generator.newTemporary();
+ generator.emitEqualityOp(op_stricteq, condition.get(), generator.generatorResumeModeRegister(), generator.emitLoad(nullptr, jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorResumeMode::NormalMode))));
+ generator.emitJumpIfTrue(condition.get(), generatorBodyLabel.get());
+
+ RefPtr<Label> throwLabel = generator.newLabel();
+ generator.emitEqualityOp(op_stricteq, condition.get(), generator.generatorResumeModeRegister(), generator.emitLoad(nullptr, jsNumber(static_cast<int32_t>(JSGeneratorFunction::GeneratorResumeMode::ThrowMode))));
+ generator.emitJumpIfTrue(condition.get(), throwLabel.get());
+
+ generator.emitReturn(generator.generatorValueRegister());
+
+ generator.emitLabel(throwLabel.get());
+ generator.emitThrow(generator.generatorValueRegister());
+ }
+
+ generator.emitLabel(generatorBodyLabel.get());
+
+ emitStatementsBytecode(generator, generator.ignoredResult());
+
+ RefPtr<Label> done = generator.newLabel();
+ generator.emitLabel(done.get());
+ generator.emitReturn(generator.emitLoad(nullptr, jsUndefined()));
+ generator.endGenerator(done.get());
+ break;
}
- // If there is a return statment, and it is the only statement in the function, check if this is a numeric compare.
- if (static_cast<BlockNode*>(singleStatement)->singleStatement()) {
- ExpressionNode* returnValueExpression = returnNode->value();
- if (returnValueExpression && returnValueExpression->isSubtract()) {
- ExpressionNode* lhsExpression = static_cast<SubNode*>(returnValueExpression)->lhs();
- ExpressionNode* rhsExpression = static_cast<SubNode*>(returnValueExpression)->rhs();
- if (lhsExpression->isResolveNode()
- && rhsExpression->isResolveNode()
- && generator.isArgumentNumber(static_cast<ResolveNode*>(lhsExpression)->identifier(), 0)
- && generator.isArgumentNumber(static_cast<ResolveNode*>(rhsExpression)->identifier(), 1)) {
-
- generator.setIsNumericCompareFunction(true);
- }
+ default: {
+ emitStatementsBytecode(generator, generator.ignoredResult());
+
+ StatementNode* singleStatement = this->singleStatement();
+ ReturnNode* returnNode = 0;
+
+ // Check for a return statement at the end of a function composed of a single block.
+ if (singleStatement && singleStatement->isBlock()) {
+ StatementNode* lastStatementInBlock = static_cast<BlockNode*>(singleStatement)->lastStatement();
+ if (lastStatementInBlock && lastStatementInBlock->isReturnNode())
+ returnNode = static_cast<ReturnNode*>(lastStatementInBlock);
+ }
+
+ // If there is no return we must automatically insert one.
+ if (!returnNode) {
+ if (generator.constructorKind() == ConstructorKind::Derived && generator.needsToUpdateArrowFunctionContext())
+ generator.emitLoadThisFromArrowFunctionLexicalEnvironment(); // Arrow function can invoke 'super' in constructor and before leave constructor we need load 'this' from lexical arrow function environment
+
+ RegisterID* r0 = generator.isConstructor() ? generator.thisRegister() : generator.emitLoad(0, jsUndefined());
+ generator.emitProfileType(r0, ProfileTypeBytecodeFunctionReturnStatement); // Do not emit expression info for this profile because it's not in the user's source code.
+ ASSERT(startOffset() >= lineStartOffset());
+ generator.emitDebugHook(WillLeaveCallFrame, lastLine(), startOffset(), lineStartOffset());
+ generator.emitReturn(r0);
+ return;
}
+ break;
+ }
}
}
@@ -2228,4 +3166,527 @@ RegisterID* FuncExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID*
return generator.emitNewFunctionExpression(generator.finalDestination(dst), this);
}
+// ------------------------------ ArrowFuncExprNode ---------------------------------
+
+RegisterID* ArrowFuncExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ return generator.emitNewArrowFunctionExpression(generator.finalDestination(dst), this);
+}
+
+// ------------------------------ YieldExprNode --------------------------------
+
+RegisterID* YieldExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (!delegate()) {
+ RefPtr<RegisterID> arg = nullptr;
+ if (argument()) {
+ arg = generator.newTemporary();
+ generator.emitNode(arg.get(), argument());
+ } else
+ arg = generator.emitLoad(nullptr, jsUndefined());
+ RefPtr<RegisterID> value = generator.emitYield(arg.get());
+ if (dst == generator.ignoredResult())
+ return nullptr;
+ return generator.emitMove(generator.finalDestination(dst), value.get());
+ }
+ RefPtr<RegisterID> arg = generator.newTemporary();
+ generator.emitNode(arg.get(), argument());
+ RefPtr<RegisterID> value = generator.emitDelegateYield(arg.get(), this);
+ if (dst == generator.ignoredResult())
+ return nullptr;
+ return generator.emitMove(generator.finalDestination(dst), value.get());
+}
+
+// ------------------------------ ClassDeclNode ---------------------------------
+
+void ClassDeclNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ generator.emitNode(dst, m_classDeclaration);
+}
+
+// ------------------------------ ClassExprNode ---------------------------------
+
+RegisterID* ClassExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (!m_name.isNull())
+ generator.pushLexicalScope(this, BytecodeGenerator::TDZCheckOptimization::Optimize, BytecodeGenerator::NestedScopeType::IsNested);
+
+ RefPtr<RegisterID> superclass;
+ if (m_classHeritage) {
+ superclass = generator.newTemporary();
+ generator.emitNode(superclass.get(), m_classHeritage);
+ }
+
+ RefPtr<RegisterID> constructor;
+
+ // FIXME: Make the prototype non-configurable & non-writable.
+ if (m_constructorExpression)
+ constructor = generator.emitNode(dst, m_constructorExpression);
+ else {
+ constructor = generator.emitNewDefaultConstructor(generator.finalDestination(dst),
+ m_classHeritage ? ConstructorKind::Derived : ConstructorKind::Base, m_name);
+ }
+
+ const auto& propertyNames = generator.propertyNames();
+ RefPtr<RegisterID> prototype = generator.emitNewObject(generator.newTemporary());
+
+ if (superclass) {
+ RefPtr<RegisterID> protoParent = generator.newTemporary();
+ generator.emitLoad(protoParent.get(), jsNull());
+
+ RefPtr<RegisterID> tempRegister = generator.newTemporary();
+
+ // FIXME: Throw TypeError if it's a generator function.
+ RefPtr<Label> superclassIsUndefinedLabel = generator.newLabel();
+ generator.emitJumpIfTrue(generator.emitIsUndefined(tempRegister.get(), superclass.get()), superclassIsUndefinedLabel.get());
+
+ RefPtr<Label> superclassIsNullLabel = generator.newLabel();
+ generator.emitJumpIfTrue(generator.emitUnaryOp(op_eq_null, tempRegister.get(), superclass.get()), superclassIsNullLabel.get());
+
+ RefPtr<Label> superclassIsObjectLabel = generator.newLabel();
+ generator.emitJumpIfTrue(generator.emitIsObject(tempRegister.get(), superclass.get()), superclassIsObjectLabel.get());
+ generator.emitLabel(superclassIsUndefinedLabel.get());
+ generator.emitThrowTypeError(ASCIILiteral("The superclass is not an object."));
+ generator.emitLabel(superclassIsObjectLabel.get());
+ generator.emitGetById(protoParent.get(), superclass.get(), generator.propertyNames().prototype);
+
+ RefPtr<Label> protoParentIsObjectOrNullLabel = generator.newLabel();
+ generator.emitJumpIfTrue(generator.emitUnaryOp(op_is_object_or_null, tempRegister.get(), protoParent.get()), protoParentIsObjectOrNullLabel.get());
+ generator.emitJumpIfTrue(generator.emitUnaryOp(op_is_function, tempRegister.get(), protoParent.get()), protoParentIsObjectOrNullLabel.get());
+ generator.emitThrowTypeError(ASCIILiteral("The value of the superclass's prototype property is not an object."));
+ generator.emitLabel(protoParentIsObjectOrNullLabel.get());
+
+ generator.emitDirectPutById(constructor.get(), generator.propertyNames().underscoreProto, superclass.get(), PropertyNode::Unknown);
+ generator.emitLabel(superclassIsNullLabel.get());
+ generator.emitDirectPutById(prototype.get(), generator.propertyNames().underscoreProto, protoParent.get(), PropertyNode::Unknown);
+
+ emitPutHomeObject(generator, constructor.get(), prototype.get());
+ }
+
+ RefPtr<RegisterID> constructorNameRegister = generator.emitLoad(generator.newTemporary(), propertyNames.constructor);
+ generator.emitCallDefineProperty(prototype.get(), constructorNameRegister.get(), constructor.get(), nullptr, nullptr,
+ BytecodeGenerator::PropertyConfigurable | BytecodeGenerator::PropertyWritable, m_position);
+
+ RefPtr<RegisterID> prototypeNameRegister = generator.emitLoad(generator.newTemporary(), propertyNames.prototype);
+ generator.emitCallDefineProperty(constructor.get(), prototypeNameRegister.get(), prototype.get(), nullptr, nullptr, 0, m_position);
+
+ if (m_staticMethods)
+ generator.emitNode(constructor.get(), m_staticMethods);
+
+ if (m_instanceMethods)
+ generator.emitNode(prototype.get(), m_instanceMethods);
+
+ if (!m_name.isNull()) {
+ Variable classNameVar = generator.variable(m_name);
+ RELEASE_ASSERT(classNameVar.isResolved());
+ RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, classNameVar);
+ generator.emitPutToScope(scope.get(), classNameVar, constructor.get(), ThrowIfNotFound, Initialization);
+ generator.popLexicalScope(this);
+ }
+
+ return generator.moveToDestinationIfNeeded(dst, constructor.get());
+}
+
+// ------------------------------ ImportDeclarationNode -----------------------
+
+void ImportDeclarationNode::emitBytecode(BytecodeGenerator&, RegisterID*)
+{
+ // Do nothing at runtime.
+}
+
+// ------------------------------ ExportAllDeclarationNode --------------------
+
+void ExportAllDeclarationNode::emitBytecode(BytecodeGenerator&, RegisterID*)
+{
+ // Do nothing at runtime.
+}
+
+// ------------------------------ ExportDefaultDeclarationNode ----------------
+
+void ExportDefaultDeclarationNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ ASSERT(m_declaration);
+ generator.emitNode(dst, m_declaration);
+}
+
+// ------------------------------ ExportLocalDeclarationNode ------------------
+
+void ExportLocalDeclarationNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ ASSERT(m_declaration);
+ generator.emitNode(dst, m_declaration);
+}
+
+// ------------------------------ ExportNamedDeclarationNode ------------------
+
+void ExportNamedDeclarationNode::emitBytecode(BytecodeGenerator&, RegisterID*)
+{
+ // Do nothing at runtime.
+}
+
+// ------------------------------ DestructuringAssignmentNode -----------------
+RegisterID* DestructuringAssignmentNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
+{
+ if (RegisterID* result = m_bindings->emitDirectBinding(generator, dst, m_initializer))
+ return result;
+ RefPtr<RegisterID> initializer = generator.tempDestination(dst);
+ generator.emitNode(initializer.get(), m_initializer);
+ m_bindings->bindValue(generator, initializer.get());
+ return generator.moveToDestinationIfNeeded(dst, initializer.get());
+}
+
+static void assignDefaultValueIfUndefined(BytecodeGenerator& generator, RegisterID* maybeUndefined, ExpressionNode* defaultValue)
+{
+ ASSERT(defaultValue);
+ RefPtr<Label> isNotUndefined = generator.newLabel();
+ generator.emitJumpIfFalse(generator.emitIsUndefined(generator.newTemporary(), maybeUndefined), isNotUndefined.get());
+ generator.emitNode(maybeUndefined, defaultValue);
+ generator.emitLabel(isNotUndefined.get());
+}
+
+void ArrayPatternNode::bindValue(BytecodeGenerator& generator, RegisterID* rhs) const
+{
+ RefPtr<RegisterID> iterator = generator.newTemporary();
+ {
+ generator.emitGetById(iterator.get(), rhs, generator.propertyNames().iteratorSymbol);
+ CallArguments args(generator, nullptr);
+ generator.emitMove(args.thisRegister(), rhs);
+ generator.emitCall(iterator.get(), iterator.get(), NoExpectedFunction, args, divot(), divotStart(), divotEnd());
+ }
+
+ if (m_targetPatterns.isEmpty()) {
+ generator.emitIteratorClose(iterator.get(), this);
+ return;
+ }
+
+ RefPtr<RegisterID> done;
+ for (auto& target : m_targetPatterns) {
+ switch (target.bindingType) {
+ case BindingType::Elision:
+ case BindingType::Element: {
+ RefPtr<Label> iterationSkipped = generator.newLabel();
+ if (!done)
+ done = generator.newTemporary();
+ else
+ generator.emitJumpIfTrue(done.get(), iterationSkipped.get());
+
+ RefPtr<RegisterID> value = generator.newTemporary();
+ generator.emitIteratorNext(value.get(), iterator.get(), this);
+ generator.emitGetById(done.get(), value.get(), generator.propertyNames().done);
+ generator.emitJumpIfTrue(done.get(), iterationSkipped.get());
+ generator.emitGetById(value.get(), value.get(), generator.propertyNames().value);
+
+ {
+ RefPtr<Label> valueIsSet = generator.newLabel();
+ generator.emitJump(valueIsSet.get());
+ generator.emitLabel(iterationSkipped.get());
+ generator.emitLoad(value.get(), jsUndefined());
+ generator.emitLabel(valueIsSet.get());
+ }
+
+ if (target.bindingType == BindingType::Element) {
+ if (target.defaultValue)
+ assignDefaultValueIfUndefined(generator, value.get(), target.defaultValue);
+ target.pattern->bindValue(generator, value.get());
+ }
+ break;
+ }
+
+ case BindingType::RestElement: {
+ RefPtr<RegisterID> array = generator.emitNewArray(generator.newTemporary(), 0, 0);
+
+ RefPtr<Label> iterationDone = generator.newLabel();
+ if (!done)
+ done = generator.newTemporary();
+ else
+ generator.emitJumpIfTrue(done.get(), iterationDone.get());
+
+ RefPtr<RegisterID> index = generator.newTemporary();
+ generator.emitLoad(index.get(), jsNumber(0));
+ RefPtr<Label> loopStart = generator.newLabel();
+ generator.emitLabel(loopStart.get());
+
+ RefPtr<RegisterID> value = generator.newTemporary();
+ generator.emitIteratorNext(value.get(), iterator.get(), this);
+ generator.emitGetById(done.get(), value.get(), generator.propertyNames().done);
+ generator.emitJumpIfTrue(done.get(), iterationDone.get());
+ generator.emitGetById(value.get(), value.get(), generator.propertyNames().value);
+
+ generator.emitDirectPutByVal(array.get(), index.get(), value.get());
+ generator.emitInc(index.get());
+ generator.emitJump(loopStart.get());
+
+ generator.emitLabel(iterationDone.get());
+ target.pattern->bindValue(generator, array.get());
+ break;
+ }
+ }
+ }
+
+ RefPtr<Label> iteratorClosed = generator.newLabel();
+ generator.emitJumpIfTrue(done.get(), iteratorClosed.get());
+ generator.emitIteratorClose(iterator.get(), this);
+ generator.emitLabel(iteratorClosed.get());
+}
+
+RegisterID* ArrayPatternNode::emitDirectBinding(BytecodeGenerator& generator, RegisterID* dst, ExpressionNode* rhs)
+{
+ if (!rhs->isSimpleArray())
+ return nullptr;
+
+ ElementNode* elementNodes = static_cast<ArrayNode*>(rhs)->elements();
+ Vector<ExpressionNode*> elements;
+ for (; elementNodes; elementNodes = elementNodes->next()) {
+ ExpressionNode* value = elementNodes->value();
+ if (value->isSpreadExpression())
+ return nullptr;
+ elements.append(value);
+ }
+
+ RefPtr<RegisterID> resultRegister;
+ if (dst && dst != generator.ignoredResult())
+ resultRegister = generator.emitNewArray(generator.newTemporary(), 0, 0);
+ if (m_targetPatterns.size() != elements.size())
+ return nullptr;
+ Vector<RefPtr<RegisterID>> registers;
+ registers.reserveCapacity(m_targetPatterns.size());
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ registers.uncheckedAppend(generator.newTemporary());
+ generator.emitNode(registers.last().get(), elements[i]);
+ if (m_targetPatterns[i].defaultValue)
+ assignDefaultValueIfUndefined(generator, registers.last().get(), m_targetPatterns[i].defaultValue);
+ if (resultRegister)
+ generator.emitPutByIndex(resultRegister.get(), i, registers.last().get());
+ }
+
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ if (m_targetPatterns[i].pattern)
+ m_targetPatterns[i].pattern->bindValue(generator, registers[i].get());
+ }
+ if (resultRegister)
+ return generator.moveToDestinationIfNeeded(dst, resultRegister.get());
+ return generator.emitLoad(generator.finalDestination(dst), jsUndefined());
+}
+
+void ArrayPatternNode::toString(StringBuilder& builder) const
+{
+ builder.append('[');
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ const auto& target = m_targetPatterns[i];
+
+ switch (target.bindingType) {
+ case BindingType::Elision:
+ builder.append(',');
+ break;
+
+ case BindingType::Element:
+ target.pattern->toString(builder);
+ if (i < m_targetPatterns.size() - 1)
+ builder.append(',');
+ break;
+
+ case BindingType::RestElement:
+ builder.append("...");
+ target.pattern->toString(builder);
+ break;
+ }
+ }
+ builder.append(']');
+}
+
+void ArrayPatternNode::collectBoundIdentifiers(Vector<Identifier>& identifiers) const
+{
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ if (DestructuringPatternNode* node = m_targetPatterns[i].pattern)
+ node->collectBoundIdentifiers(identifiers);
+ }
+}
+
+void ObjectPatternNode::toString(StringBuilder& builder) const
+{
+ builder.append('{');
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ if (m_targetPatterns[i].wasString)
+ builder.appendQuotedJSONString(m_targetPatterns[i].propertyName.string());
+ else
+ builder.append(m_targetPatterns[i].propertyName.string());
+ builder.append(':');
+ m_targetPatterns[i].pattern->toString(builder);
+ if (i < m_targetPatterns.size() - 1)
+ builder.append(',');
+ }
+ builder.append('}');
+}
+
+void ObjectPatternNode::bindValue(BytecodeGenerator& generator, RegisterID* rhs) const
+{
+ generator.emitRequireObjectCoercible(rhs, ASCIILiteral("Right side of assignment cannot be destructured"));
+ for (size_t i = 0; i < m_targetPatterns.size(); i++) {
+ auto& target = m_targetPatterns[i];
+ RefPtr<RegisterID> temp = generator.newTemporary();
+ if (!target.propertyExpression) {
+ // Should not emit get_by_id for indexed ones.
+ Optional<uint32_t> optionalIndex = parseIndex(target.propertyName);
+ if (!optionalIndex)
+ generator.emitGetById(temp.get(), rhs, target.propertyName);
+ else {
+ RefPtr<RegisterID> index = generator.emitLoad(generator.newTemporary(), jsNumber(optionalIndex.value()));
+ generator.emitGetByVal(temp.get(), rhs, index.get());
+ }
+ } else {
+ RefPtr<RegisterID> propertyName = generator.emitNode(target.propertyExpression);
+ generator.emitGetByVal(temp.get(), rhs, propertyName.get());
+ }
+
+ if (target.defaultValue)
+ assignDefaultValueIfUndefined(generator, temp.get(), target.defaultValue);
+ target.pattern->bindValue(generator, temp.get());
+ }
+}
+
+void ObjectPatternNode::collectBoundIdentifiers(Vector<Identifier>& identifiers) const
+{
+ for (size_t i = 0; i < m_targetPatterns.size(); i++)
+ m_targetPatterns[i].pattern->collectBoundIdentifiers(identifiers);
+}
+
+void BindingNode::bindValue(BytecodeGenerator& generator, RegisterID* value) const
+{
+ Variable var = generator.variable(m_boundProperty);
+ bool isReadOnly = var.isReadOnly() && m_bindingContext != AssignmentContext::ConstDeclarationStatement;
+ if (RegisterID* local = var.local()) {
+ if (m_bindingContext == AssignmentContext::AssignmentExpression)
+ generator.emitTDZCheckIfNecessary(var, local, nullptr);
+ if (isReadOnly) {
+ generator.emitReadOnlyExceptionIfNeeded(var);
+ return;
+ }
+ generator.emitMove(local, value);
+ generator.emitProfileType(local, var, divotStart(), divotEnd());
+ if (m_bindingContext == AssignmentContext::DeclarationStatement || m_bindingContext == AssignmentContext::ConstDeclarationStatement)
+ generator.liftTDZCheckIfPossible(var);
+ return;
+ }
+ if (generator.isStrictMode())
+ generator.emitExpressionInfo(divotEnd(), divotStart(), divotEnd());
+ RegisterID* scope = generator.emitResolveScope(nullptr, var);
+ generator.emitExpressionInfo(divotEnd(), divotStart(), divotEnd());
+ if (m_bindingContext == AssignmentContext::AssignmentExpression)
+ generator.emitTDZCheckIfNecessary(var, nullptr, scope);
+ if (isReadOnly) {
+ generator.emitReadOnlyExceptionIfNeeded(var);
+ return;
+ }
+ generator.emitPutToScope(scope, var, value, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound,
+ m_bindingContext == AssignmentContext::ConstDeclarationStatement || m_bindingContext == AssignmentContext::DeclarationStatement ? Initialization : NotInitialization);
+ generator.emitProfileType(value, var, divotStart(), divotEnd());
+ if (m_bindingContext == AssignmentContext::DeclarationStatement || m_bindingContext == AssignmentContext::ConstDeclarationStatement)
+ generator.liftTDZCheckIfPossible(var);
+ return;
+}
+
+void BindingNode::toString(StringBuilder& builder) const
+{
+ builder.append(m_boundProperty.string());
+}
+
+void BindingNode::collectBoundIdentifiers(Vector<Identifier>& identifiers) const
+{
+ identifiers.append(m_boundProperty);
+}
+
+void AssignmentElementNode::collectBoundIdentifiers(Vector<Identifier>&) const
+{
+}
+
+void AssignmentElementNode::bindValue(BytecodeGenerator& generator, RegisterID* value) const
+{
+ if (m_assignmentTarget->isResolveNode()) {
+ ResolveNode* lhs = static_cast<ResolveNode*>(m_assignmentTarget);
+ Variable var = generator.variable(lhs->identifier());
+ bool isReadOnly = var.isReadOnly();
+ if (RegisterID* local = var.local()) {
+ generator.emitTDZCheckIfNecessary(var, local, nullptr);
+
+ if (isReadOnly)
+ generator.emitReadOnlyExceptionIfNeeded(var);
+ else {
+ generator.invalidateForInContextForLocal(local);
+ generator.moveToDestinationIfNeeded(local, value);
+ generator.emitProfileType(local, divotStart(), divotEnd());
+ }
+ return;
+ }
+ if (generator.isStrictMode())
+ generator.emitExpressionInfo(divotEnd(), divotStart(), divotEnd());
+ RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);
+ generator.emitTDZCheckIfNecessary(var, nullptr, scope.get());
+ if (isReadOnly) {
+ bool threwException = generator.emitReadOnlyExceptionIfNeeded(var);
+ if (threwException)
+ return;
+ }
+ generator.emitExpressionInfo(divotEnd(), divotStart(), divotEnd());
+ if (!isReadOnly) {
+ generator.emitPutToScope(scope.get(), var, value, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound, NotInitialization);
+ generator.emitProfileType(value, var, divotStart(), divotEnd());
+ }
+ } else if (m_assignmentTarget->isDotAccessorNode()) {
+ DotAccessorNode* lhs = static_cast<DotAccessorNode*>(m_assignmentTarget);
+ RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(lhs->base(), true, false);
+ generator.emitExpressionInfo(divotEnd(), divotStart(), divotEnd());
+ generator.emitPutById(base.get(), lhs->identifier(), value);
+ generator.emitProfileType(value, divotStart(), divotEnd());
+ } else if (m_assignmentTarget->isBracketAccessorNode()) {
+ BracketAccessorNode* lhs = static_cast<BracketAccessorNode*>(m_assignmentTarget);
+ RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(lhs->base(), true, false);
+ RefPtr<RegisterID> property = generator.emitNodeForLeftHandSide(lhs->subscript(), true, false);
+ generator.emitExpressionInfo(divotEnd(), divotStart(), divotEnd());
+ generator.emitPutByVal(base.get(), property.get(), value);
+ generator.emitProfileType(value, divotStart(), divotEnd());
+ }
+}
+
+void AssignmentElementNode::toString(StringBuilder& builder) const
+{
+ if (m_assignmentTarget->isResolveNode())
+ builder.append(static_cast<ResolveNode*>(m_assignmentTarget)->identifier().string());
+}
+
+void RestParameterNode::collectBoundIdentifiers(Vector<Identifier>& identifiers) const
+{
+ identifiers.append(m_name);
+}
+void RestParameterNode::toString(StringBuilder& builder) const
+{
+ builder.append(m_name.string());
+}
+void RestParameterNode::bindValue(BytecodeGenerator&, RegisterID*) const
+{
+ RELEASE_ASSERT_NOT_REACHED();
+}
+void RestParameterNode::emit(BytecodeGenerator& generator)
+{
+ Variable var = generator.variable(m_name);
+ if (RegisterID* local = var.local()) {
+ generator.emitRestParameter(local, m_numParametersToSkip);
+ generator.emitProfileType(local, var, m_divotStart, m_divotEnd);
+ return;
+ }
+
+ RefPtr<RegisterID> restParameterArray = generator.newTemporary();
+ generator.emitRestParameter(restParameterArray.get(), m_numParametersToSkip);
+ generator.emitProfileType(restParameterArray.get(), var, m_divotStart, m_divotEnd);
+ RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var);
+ generator.emitExpressionInfo(m_divotEnd, m_divotStart, m_divotEnd);
+ generator.emitPutToScope(scope.get(), var, restParameterArray.get(), generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound, Initialization);
+}
+
+
+RegisterID* SpreadExpressionNode::emitBytecode(BytecodeGenerator&, RegisterID*)
+{
+ RELEASE_ASSERT_NOT_REACHED();
+ return 0;
+}
+
} // namespace JSC
diff --git a/Source/JavaScriptCore/bytecompiler/RegisterID.h b/Source/JavaScriptCore/bytecompiler/RegisterID.h
index 78d49d290..688c8b9c8 100644
--- a/Source/JavaScriptCore/bytecompiler/RegisterID.h
+++ b/Source/JavaScriptCore/bytecompiler/RegisterID.h
@@ -10,7 +10,7 @@
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
- * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+ * 3. Neither the name of Apple Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
@@ -29,6 +29,8 @@
#ifndef RegisterID_h
#define RegisterID_h
+#include "VirtualRegister.h"
+
#include <wtf/Assertions.h>
#include <wtf/VectorTraits.h>
@@ -46,9 +48,19 @@ namespace JSC {
{
}
+ RegisterID(VirtualRegister virtualRegister)
+ : m_refCount(0)
+ , m_virtualRegister(virtualRegister)
+ , m_isTemporary(false)
+#ifndef NDEBUG
+ , m_didSetIndex(true)
+#endif
+ {
+ }
+
explicit RegisterID(int index)
: m_refCount(0)
- , m_index(index)
+ , m_virtualRegister(VirtualRegister(index))
, m_isTemporary(false)
#ifndef NDEBUG
, m_didSetIndex(true)
@@ -58,11 +70,10 @@ namespace JSC {
void setIndex(int index)
{
- ASSERT(!m_refCount);
#ifndef NDEBUG
m_didSetIndex = true;
#endif
- m_index = index;
+ m_virtualRegister = VirtualRegister(index);
}
void setTemporary()
@@ -73,7 +84,13 @@ namespace JSC {
int index() const
{
ASSERT(m_didSetIndex);
- return m_index;
+ return m_virtualRegister.offset();
+ }
+
+ VirtualRegister virtualRegister() const
+ {
+ ASSERT(m_virtualRegister.isValid());
+ return m_virtualRegister;
}
bool isTemporary()
@@ -100,7 +117,7 @@ namespace JSC {
private:
int m_refCount;
- int m_index;
+ VirtualRegister m_virtualRegister;
bool m_isTemporary;
#ifndef NDEBUG
bool m_didSetIndex;
diff --git a/Source/JavaScriptCore/bytecompiler/SetForScope.h b/Source/JavaScriptCore/bytecompiler/SetForScope.h
new file mode 100644
index 000000000..eef76aef4
--- /dev/null
+++ b/Source/JavaScriptCore/bytecompiler/SetForScope.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2015 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SetForScope_h
+#define SetForScope_h
+
+#include <wtf/StdLibExtras.h>
+
+namespace JSC {
+
+template<typename T>
+class SetForScope {
+public:
+ SetForScope(T& currentValue, const T& newValue)
+ : m_ref(currentValue)
+ , m_oldValue(currentValue)
+ {
+ m_ref = newValue;
+ }
+
+ SetForScope(T& currentValue, T&& newValue)
+ : m_ref(currentValue)
+ , m_oldValue(currentValue)
+ {
+ currentValue = WTFMove(newValue);
+ }
+
+ ~SetForScope()
+ {
+ m_ref = m_oldValue;
+ }
+
+private:
+ T& m_ref;
+ T m_oldValue;
+};
+
+}; // namespace JSC
+
+#endif // SetForScope_h
diff --git a/Source/JavaScriptCore/bytecompiler/StaticPropertyAnalysis.h b/Source/JavaScriptCore/bytecompiler/StaticPropertyAnalysis.h
index 78ee17adf..5a9918dd1 100644
--- a/Source/JavaScriptCore/bytecompiler/StaticPropertyAnalysis.h
+++ b/Source/JavaScriptCore/bytecompiler/StaticPropertyAnalysis.h
@@ -35,9 +35,9 @@ namespace JSC {
// Reference count indicates number of live registers that alias this object.
class StaticPropertyAnalysis : public RefCounted<StaticPropertyAnalysis> {
public:
- static PassRefPtr<StaticPropertyAnalysis> create(Vector<UnlinkedInstruction, 0, UnsafeVectorOverflow>* instructions, unsigned target)
+ static Ref<StaticPropertyAnalysis> create(Vector<UnlinkedInstruction, 0, UnsafeVectorOverflow>* instructions, unsigned target)
{
- return adoptRef(new StaticPropertyAnalysis(instructions, target));
+ return adoptRef(*new StaticPropertyAnalysis(instructions, target));
}
void addPropertyIndex(unsigned propertyIndex) { m_propertyIndexes.add(propertyIndex); }
@@ -58,7 +58,7 @@ private:
Vector<UnlinkedInstruction, 0, UnsafeVectorOverflow>* m_instructions;
unsigned m_target;
- typedef HashSet<unsigned, WTF::IntHash<unsigned>, WTF::UnsignedWithZeroKeyHashTraits<unsigned> > PropertyIndexSet;
+ typedef HashSet<unsigned, WTF::IntHash<unsigned>, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> PropertyIndexSet;
PropertyIndexSet m_propertyIndexes;
};
diff --git a/Source/JavaScriptCore/bytecompiler/StaticPropertyAnalyzer.h b/Source/JavaScriptCore/bytecompiler/StaticPropertyAnalyzer.h
index dd7f0ab38..e63fef86a 100644
--- a/Source/JavaScriptCore/bytecompiler/StaticPropertyAnalyzer.h
+++ b/Source/JavaScriptCore/bytecompiler/StaticPropertyAnalyzer.h
@@ -50,7 +50,7 @@ private:
void kill(StaticPropertyAnalysis*);
Vector<UnlinkedInstruction, 0, UnsafeVectorOverflow>* m_instructions;
- typedef HashMap<int, RefPtr<StaticPropertyAnalysis>, WTF::IntHash<int>, WTF::UnsignedWithZeroKeyHashTraits<int> > AnalysisMap;
+ typedef HashMap<int, RefPtr<StaticPropertyAnalysis>, WTF::IntHash<int>, WTF::UnsignedWithZeroKeyHashTraits<int>> AnalysisMap;
AnalysisMap m_analyses;
};
View Lorry Controller Status