diff options
Diffstat (limited to 'Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp')
| -rw-r--r-- | Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp | 1782 |
1 files changed, 476 insertions, 1306 deletions
diff --git a/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp b/Source/JavaScriptCore/bytecompiler/NodesCodegen.cpp index 477fa5c73..1ffd4f311 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, 2015 Apple Inc. All rights reserved. +* Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012, 2013 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,25 +28,23 @@ #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 "JSGlobalObject.h" +#include "JSNameScope.h" #include "JSONObject.h" #include "LabelScope.h" #include "Lexer.h" -#include "JSCInlines.h" -#include "JSTemplateRegistryKey.h" +#include "Operations.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> @@ -123,15 +121,6 @@ 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) @@ -145,188 +134,31 @@ RegisterID* RegExpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* d RegisterID* ThisNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - if (m_shouldAlwaysEmitTDZCheck || generator.constructorKind() == ConstructorKind::Derived) - generator.emitTDZCheck(generator.thisRegister()); - if (dst == generator.ignoredResult()) return 0; - - 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; - - RegisterID callee; - callee.setIndex(JSStack::Callee); - - RefPtr<RegisterID> homeObject = generator.emitGetById(generator.newTemporary(), &callee, generator.propertyNames().homeObjectPrivateName); - RefPtr<RegisterID> protoParent = generator.emitGetById(generator.newTemporary(), homeObject.get(), generator.propertyNames().underscoreProto); - return generator.emitGetById(generator.finalDestination(dst), protoParent.get(), generator.propertyNames().constructor); -} - -static RegisterID* emitSuperBaseForCallee(BytecodeGenerator& generator) -{ - RegisterID callee; - callee.setIndex(JSStack::Callee); - - RefPtr<RegisterID> homeObject = generator.emitGetById(generator.newTemporary(), &callee, generator.propertyNames().homeObjectPrivateName); - 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()); + return generator.moveToDestinationIfNeeded(dst, generator.thisRegister()); } // ------------------------------ ResolveNode ---------------------------------- bool ResolveNode::isPure(BytecodeGenerator& generator) const { - return generator.variable(m_ident).offset().isStack(); + return generator.local(m_ident).get(); } RegisterID* ResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - Variable var = generator.variable(m_ident); - if (RegisterID* local = var.local()) { - generator.emitTDZCheckIfNecessary(var, local, nullptr); + if (Local local = generator.local(m_ident)) { if (dst == generator.ignoredResult()) - return nullptr; - - generator.emitProfileType(local, var, m_position, JSTextPosition(-1, m_position.offset + m_ident.length(), -1)); - return generator.moveToDestinationIfNeeded(dst, local); + return 0; + return generator.moveToDestinationIfNeeded(dst, local.get()); } JSTextPosition divot = m_start + m_ident.length(); generator.emitExpressionInfo(divot, m_start, divot); - 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; -} - -#if ENABLE(ES6_TEMPLATE_LITERAL_SYNTAX) -// ------------------------------ 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()); + RefPtr<RegisterID> scope = generator.emitResolveScope(generator.tempDestination(dst), m_ident); + return generator.emitGetFromScope(generator.finalDestination(dst), scope.get(), m_ident, ThrowIfNotFound); } -#endif // ------------------------------ ArrayNode ------------------------------------ @@ -399,7 +231,7 @@ bool ArrayNode::isSimpleArray() const return true; } -ArgumentListNode* ArrayNode::toArgumentList(ParserArena& parserArena, int lineNumber, int startPosition) const +ArgumentListNode* ArrayNode::toArgumentList(VM* vm, int lineNumber, int startPosition) const { ASSERT(!m_elision && !m_optional); ElementNode* ptr = m_element; @@ -408,12 +240,12 @@ ArgumentListNode* ArrayNode::toArgumentList(ParserArena& parserArena, int lineNu JSTokenLocation location; location.line = lineNumber; location.startOffset = startPosition; - ArgumentListNode* head = new (parserArena) ArgumentListNode(location, ptr->value()); + ArgumentListNode* head = new (vm) ArgumentListNode(location, ptr->value()); ArgumentListNode* tail = head; ptr = ptr->next(); for (; ptr; ptr = ptr->next()) { ASSERT(!ptr->elision()); - tail = new (parserArena) ArgumentListNode(location, tail, ptr->value()); + tail = new (vm) ArgumentListNode(location, tail, ptr->value()); } return head; } @@ -422,59 +254,49 @@ ArgumentListNode* ArrayNode::toArgumentList(ParserArena& parserArena, int lineNu RegisterID* ObjectLiteralNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - 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()); + if (!m_list) { + if (dst == generator.ignoredResult()) + return 0; + return generator.emitNewObject(generator.finalDestination(dst)); + } + return generator.emitNode(dst, m_list); } // ------------------------------ 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) - emitPutConstantProperty(generator, dst, *p->m_node); + for (; p && p->m_node->m_type == PropertyNode::Constant; p = p->m_next) { + if (p->m_node->m_name) { + generator.emitDirectPutById(newObj.get(), *p->m_node->name(), generator.emitNode(p->m_node->m_assign)); + continue; + } + RefPtr<RegisterID> propertyName = generator.emitNode(p->m_node->m_expression); + generator.emitDirectPutByVal(newObj.get(), propertyName.get(), generator.emitNode(p->m_node->m_assign)); + } // 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<UniquedStringImpl*, GetterSetterPair, IdentifierRepHash> GetterSetterMap; + typedef HashMap<StringImpl*, GetterSetterPair> 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::Computed) { - hasComputedProperty = true; - break; - } - if (node->m_type & PropertyNode::Constant) + if (node->m_type == PropertyNode::Constant) continue; - // Duplicates are possible. - GetterSetterPair pair(node, static_cast<PropertyNode*>(nullptr)); + GetterSetterPair pair(node, static_cast<PropertyNode*>(0)); 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; - } + if (!result.isNewEntry) + result.iterator->value.second = node; } // Iterate over the remaining properties in the list. @@ -482,28 +304,20 @@ RegisterID* PropertyListNode::emitBytecode(BytecodeGenerator& generator, Registe PropertyNode* node = p->m_node; // Handle regular values. - if (node->m_type & PropertyNode::Constant) { - emitPutConstantProperty(generator, dst, *node); + if (node->m_type == PropertyNode::Constant) { + if (node->name()) { + generator.emitDirectPutById(newObj.get(), *node->name(), generator.emitNode(node->m_assign)); + continue; + } + RefPtr<RegisterID> propertyName = generator.emitNode(p->m_node->m_expression); + generator.emitDirectPutByVal(newObj.get(), propertyName.get(), generator.emitNode(p->m_node->m_assign)); continue; } - + RegisterID* value = generator.emitNode(node->m_assign); - bool isClassProperty = node->needsSuperBinding(); - if (isClassProperty) - emitPutHomeObject(generator, value, dst); - - 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) { - if (node->m_type & PropertyNode::Getter) - generator.emitPutGetterById(dst, *node->name(), value); - else - generator.emitPutSetterById(dst, *node->name(), value); - continue; - } - // This is a get/set property pair. + // 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()); ASSERT(it != map.end()); GetterSetterPair& pair = it->value; @@ -511,123 +325,75 @@ RegisterID* PropertyListNode::emitBytecode(BytecodeGenerator& generator, Registe // 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()); } } - ASSERT(!pair.second || isClassProperty == pair.second->needsSuperBinding()); - if (isClassProperty && pair.second) - emitPutHomeObject(generator, secondReg, dst); - - if (isClassProperty) { - RefPtr<RegisterID> propertyNameRegister = generator.emitLoad(generator.newTemporary(), *node->name()); - generator.emitCallDefineProperty(dst, propertyNameRegister.get(), - nullptr, getterReg.get(), setterReg.get(), BytecodeGenerator::PropertyConfigurable, m_position); - } else - generator.emitPutGetterSetter(dst, *node->name(), getterReg.get(), setterReg.get()); + generator.emitPutGetterSetter(newObj.get(), *node->name(), getterReg.get(), setterReg.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()); + return generator.moveToDestinationIfNeeded(dst, newObj.get()); } // ------------------------------ BracketAccessorNode -------------------------------- RegisterID* BracketAccessorNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - if (m_base->isSuperNode()) { - // FIXME: Should we generate the profiler info? - if (m_subscript->isString()) { - 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 (m_subscript->isString()) { - 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)); + if (m_base->isResolveNode() + && generator.willResolveToArguments(static_cast<ResolveNode*>(m_base)->identifier()) + && !generator.symbolTable().slowArguments()) { RegisterID* property = generator.emitNode(m_subscript); - ret = generator.emitGetByVal(finalDest, base.get(), property); + generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); + return generator.emitGetArgumentByVal(generator.finalDestination(dst), generator.uncheckedRegisterForArguments(), 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()); - - generator.emitProfileType(finalDest, divotStart(), divotEnd()); - return ret; + return generator.emitGetByVal(generator.finalDestination(dst), base.get(), property); } // ------------------------------ DotAccessorNode -------------------------------- RegisterID* DotAccessorNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - RefPtr<RegisterID> base = m_base->isSuperNode() ? emitSuperBaseForCallee(generator) : generator.emitNode(m_base); + 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); generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - RegisterID* finalDest = generator.finalDestination(dst); - RegisterID* ret = generator.emitGetById(finalDest, base.get(), m_ident); - generator.emitProfileType(finalDest, divotStart(), divotEnd()); - return ret; + return generator.emitGetById(generator.finalDestination(dst), base, m_ident); } // ------------------------------ ArgumentListNode ----------------------------- @@ -650,7 +416,6 @@ RegisterID* NewExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID* RefPtr<RegisterID> func = generator.emitNode(m_expr); RefPtr<RegisterID> returnValue = generator.finalDestination(dst, func.get()); CallArguments callArguments(generator, m_args); - generator.emitMove(callArguments.thisRegister(), func.get()); return generator.emitConstruct(returnValue.get(), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd()); } @@ -683,9 +448,8 @@ CallArguments::CallArguments(BytecodeGenerator& generator, ArgumentsNode* argume RegisterID* EvalFunctionCallNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - Variable var = generator.variable(generator.propertyNames().eval); - if (RegisterID* local = var.local()) { - RefPtr<RegisterID> func = generator.emitMove(generator.tempDestination(dst), local); + if (Local local = generator.local(generator.propertyNames().eval)) { + RefPtr<RegisterID> func = generator.emitMove(generator.tempDestination(dst), local.get()); CallArguments callArguments(generator, m_args); generator.emitLoad(callArguments.thisRegister(), jsUndefined()); return generator.emitCallEval(generator.finalDestination(dst, func.get()), func.get(), callArguments, divot(), divotStart(), divotEnd()); @@ -695,10 +459,8 @@ RegisterID* EvalFunctionCallNode::emitBytecode(BytecodeGenerator& generator, Reg CallArguments callArguments(generator, m_args); JSTextPosition newDivot = divotStart() + 4; generator.emitExpressionInfo(newDivot, divotStart(), newDivot); - generator.moveToDestinationIfNeeded( - callArguments.thisRegister(), - generator.emitResolveScope(callArguments.thisRegister(), var)); - generator.emitGetFromScope(func.get(), callArguments.thisRegister(), var, ThrowIfNotFound); + generator.emitResolveScope(callArguments.thisRegister(), generator.propertyNames().eval); + generator.emitGetFromScope(func.get(), callArguments.thisRegister(), generator.propertyNames().eval, ThrowIfNotFound); return generator.emitCallEval(generator.finalDestination(dst, func.get()), func.get(), callArguments, divot(), divotStart(), divotEnd()); } @@ -709,18 +471,8 @@ RegisterID* FunctionCallValueNode::emitBytecode(BytecodeGenerator& generator, Re 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()); - ASSERT(generator.constructorKind() == ConstructorKind::Derived); - generator.emitMove(callArguments.thisRegister(), generator.newTarget()); - RegisterID* ret = generator.emitConstruct(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); - generator.emitMove(generator.thisRegister(), ret); - return ret; - } generator.emitLoad(callArguments.thisRegister(), jsUndefined()); - RegisterID* ret = generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); - generator.emitProfileType(returnValue.get(), divotStart(), divotEnd()); - return ret; + return generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); } // ------------------------------ FunctionCallResolveNode ---------------------------------- @@ -729,18 +481,14 @@ RegisterID* FunctionCallResolveNode::emitBytecode(BytecodeGenerator& generator, { ExpectedFunction expectedFunction = generator.expectedFunctionForIdentifier(m_ident); - 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); + if (Local local = generator.local(m_ident)) { + RefPtr<RegisterID> func = generator.emitMove(generator.tempDestination(dst), local.get()); 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. - RegisterID* ret = generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); - generator.emitProfileType(returnValue.get(), divotStart(), divotEnd()); - return ret; + return generator.emitCall(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); } RefPtr<RegisterID> func = generator.newTemporary(); @@ -749,82 +497,23 @@ RegisterID* FunctionCallResolveNode::emitBytecode(BytecodeGenerator& generator, JSTextPosition newDivot = divotStart() + m_ident.length(); generator.emitExpressionInfo(newDivot, divotStart(), newDivot); - 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.emitCall(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_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())); + generator.emitResolveScope(callArguments.thisRegister(), m_ident); + generator.emitGetFromScope(func.get(), callArguments.thisRegister(), m_ident, ThrowIfNotFound); + return generator.emitCall(returnValue.get(), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd()); } // ------------------------------ FunctionCallBracketNode ---------------------------------- RegisterID* FunctionCallBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - bool baseIsSuper = m_base->isSuperNode(); - bool subscriptIsString = m_subscript->isString(); - - RefPtr<RegisterID> base; - if (baseIsSuper) - base = emitSuperBaseForCallee(generator); - else { - if (subscriptIsString) - base = generator.emitNode(m_base); - else - base = generator.emitNodeForLeftHandSide(m_base, m_subscriptHasAssignments, m_subscript->isPure(generator)); - } - - RefPtr<RegisterID> function; - if (subscriptIsString) { - 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> 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); RefPtr<RegisterID> returnValue = generator.finalDestination(dst, function.get()); CallArguments callArguments(generator, m_args); - if (baseIsSuper) - generator.emitMove(callArguments.thisRegister(), generator.thisRegister()); - else - generator.emitMove(callArguments.thisRegister(), base.get()); - RegisterID* ret = generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); - generator.emitProfileType(returnValue.get(), divotStart(), divotEnd()); - return ret; + generator.emitMove(callArguments.thisRegister(), base.get()); + return generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); } // ------------------------------ FunctionCallDotNode ---------------------------------- @@ -834,16 +523,10 @@ RegisterID* FunctionCallDotNode::emitBytecode(BytecodeGenerator& generator, Regi RefPtr<RegisterID> function = generator.tempDestination(dst); RefPtr<RegisterID> returnValue = generator.finalDestination(dst, function.get()); CallArguments callArguments(generator, m_args); - bool baseIsSuper = m_base->isSuperNode(); - if (baseIsSuper) - generator.emitMove(callArguments.thisRegister(), generator.thisRegister()); - else - generator.emitNode(callArguments.thisRegister(), m_base); + generator.emitNode(callArguments.thisRegister(), m_base); generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd()); - generator.emitGetById(function.get(), baseIsSuper ? emitSuperBaseForCallee(generator) : callArguments.thisRegister(), m_ident); - RegisterID* ret = generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); - generator.emitProfileType(returnValue.get(), divotStart(), divotEnd()); - return ret; + generator.emitGetById(function.get(), callArguments.thisRegister(), m_ident); + return generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); } RegisterID* CallFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) @@ -852,26 +535,11 @@ 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; - 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); + RefPtr<RegisterID> function = generator.emitGetById(generator.tempDestination(dst), base.get(), m_ident); + RefPtr<RegisterID> returnValue = generator.finalDestination(dst, function.get()); + generator.emitJumpIfNotFunctionCall(function.get(), realCall.get()); { - 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.emitCallVarargs(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) { + 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; @@ -879,25 +547,24 @@ RegisterID* CallFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator, CallArguments callArguments(generator, m_args); generator.emitNode(callArguments.thisRegister(), oldList->m_expr); generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); + generator.emitJump(end.get()); + 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(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); + generator.emitJump(end.get()); } } - if (emitCallCheck) { - generator.emitJump(end.get()); - generator.emitLabel(realCall.get()); - { - CallArguments callArguments(generator, m_args); - generator.emitMove(callArguments.thisRegister(), base.get()); - generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); - } - generator.emitLabel(end.get()); + generator.emitLabel(realCall.get()); + { + CallArguments callArguments(generator, m_args); + generator.emitMove(callArguments.thisRegister(), base.get()); + generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); } - generator.emitProfileType(returnValue.get(), divotStart(), divotEnd()); + generator.emitLabel(end.get()); return returnValue.get(); } @@ -918,94 +585,65 @@ 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; + RefPtr<RegisterID> function = generator.emitGetById(generator.tempDestination(dst), base.get(), m_ident); 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.emitCallVarargs(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.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); + 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(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.emitNode(callArguments.thisRegister(), oldList->m_expr); + generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); + } + m_args->m_listNode = oldList; } 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.emitLoad(callArguments.thisRegister(), jsUndefined()); generator.emitCall(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()); - CallArguments callArguments(generator, m_args); - generator.emitLoad(callArguments.thisRegister(), jsUndefined()); - generator.emitCall(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); + 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(returnValue.get(), realFunction.get(), thisRegister.get(), argsRegister.get(), generator.newTemporary(), profileHookRegister.get(), divot(), divotStart(), divotEnd()); } - } 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.emitCallVarargs(returnValue.get(), realFunction.get(), thisRegister.get(), argsRegister.get(), generator.newTemporary(), 0, profileHookRegister.get(), divot(), divotStart(), divotEnd()); - } - if (emitCallCheck) { generator.emitJump(end.get()); - generator.emitLabel(realCall.get()); + } + generator.emitLabel(realCall.get()); + { CallArguments callArguments(generator, m_args); generator.emitMove(callArguments.thisRegister(), base.get()); generator.emitCall(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd()); - generator.emitLabel(end.get()); } - generator.emitProfileType(returnValue.get(), divotStart(), divotEnd()); + generator.emitLabel(end.get()); return returnValue.get(); } @@ -1034,32 +672,30 @@ RegisterID* PostfixNode::emitResolve(BytecodeGenerator& generator, RegisterID* d ResolveNode* resolve = static_cast<ResolveNode*>(m_expr); const Identifier& ident = resolve->identifier(); - 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); + if (Local local = generator.local(ident)) { + RegisterID* localReg = local.get(); + if (local.isReadOnly()) { + generator.emitReadOnlyExceptionIfNeeded(); + localReg = generator.emitMove(generator.tempDestination(dst), localReg); + } + if (local.isCaptured()) { + RefPtr<RegisterID> tempDst = generator.finalDestination(dst); + ASSERT(dst != localReg); + RefPtr<RegisterID> tempDstSrc = generator.newTemporary(); + generator.emitToNumber(tempDst.get(), localReg); + generator.emitMove(tempDstSrc.get(), localReg); + emitIncOrDec(generator, tempDstSrc.get(), m_operator); + generator.emitMove(localReg, tempDstSrc.get()); + return tempDst.get(); } - RefPtr<RegisterID> oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), localReg.get(), m_operator); - generator.emitProfileType(localReg.get(), var, divotStart(), divotEnd()); - return oldValue.get(); + return emitPostIncOrDec(generator, generator.finalDestination(dst), localReg, m_operator); } generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - 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> scope = generator.emitResolveScope(generator.newTemporary(), ident); + RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), ident, ThrowIfNotFound); RefPtr<RegisterID> oldValue = emitPostIncOrDec(generator, generator.finalDestination(dst), value.get(), m_operator); - generator.emitPutToScope(scope.get(), var, value.get(), ThrowIfNotFound); - generator.emitProfileType(value.get(), var, divotStart(), divotEnd()); - + generator.emitPutToScope(scope.get(), ident, value.get(), ThrowIfNotFound); return oldValue.get(); } @@ -1081,7 +717,6 @@ 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); } @@ -1102,7 +737,6 @@ 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); } @@ -1118,23 +752,19 @@ RegisterID* PostfixNode::emitBytecode(BytecodeGenerator& generator, RegisterID* return emitDot(generator, dst); return emitThrowReferenceError(generator, m_operator == OpPlusPlus - ? ASCIILiteral("Postfix ++ operator applied to value that is not a reference.") - : ASCIILiteral("Postfix -- operator applied to value that is not a reference.")); + ? "Postfix ++ operator applied to value that is not a reference." + : "Postfix -- operator applied to value that is not a reference."); } // ------------------------------ DeleteResolveNode ----------------------------------- RegisterID* DeleteResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - Variable var = generator.variable(m_ident); - if (var.local()) { - generator.emitTDZCheckIfNecessary(var, var.local(), nullptr); + if (generator.local(m_ident).get()) return generator.emitLoad(generator.finalDestination(dst), false); - } generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - RefPtr<RegisterID> base = generator.emitResolveScope(dst, var); - generator.emitTDZCheckIfNecessary(var, nullptr, base.get()); + RefPtr<RegisterID> base = generator.emitResolveScope(generator.tempDestination(dst), m_ident); return generator.emitDeleteById(generator.finalDestination(dst, base.get()), base.get(), m_ident); } @@ -1143,24 +773,20 @@ RegisterID* DeleteResolveNode::emitBytecode(BytecodeGenerator& generator, Regist RegisterID* DeleteBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { RefPtr<RegisterID> r0 = generator.emitNode(m_base); - RefPtr<RegisterID> r1 = generator.emitNode(m_subscript); + RegisterID* r1 = generator.emitNode(m_subscript); generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - if (m_base->isSuperNode()) - return emitThrowReferenceError(generator, "Cannot delete a super property"); - return generator.emitDeleteByVal(generator.finalDestination(dst), r0.get(), r1.get()); + return generator.emitDeleteByVal(generator.finalDestination(dst), r0.get(), r1); } // ------------------------------ DeleteDotNode ----------------------------------- RegisterID* DeleteDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - RefPtr<RegisterID> r0 = generator.emitNode(m_base); + RegisterID* r0 = generator.emitNode(m_base); generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - if (m_base->isSuperNode()) - return emitThrowReferenceError(generator, "Cannot delete a super property"); - return generator.emitDeleteById(generator.finalDestination(dst), r0.get(), m_ident); + return generator.emitDeleteById(generator.finalDestination(dst), r0, m_ident); } // ------------------------------ DeleteValueNode ----------------------------------- @@ -1185,21 +811,18 @@ RegisterID* VoidNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst return generator.emitLoad(dst, jsUndefined()); } -// ------------------------------ TypeOfResolveNode ----------------------------------- +// ------------------------------ TypeOfValueNode ----------------------------------- RegisterID* TypeOfResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - Variable var = generator.variable(m_ident); - if (RegisterID* local = var.local()) { - generator.emitTDZCheckIfNecessary(var, local, nullptr); + if (Local local = generator.local(m_ident)) { if (dst == generator.ignoredResult()) return 0; - return generator.emitTypeOf(generator.finalDestination(dst), local); + return generator.emitTypeOf(generator.finalDestination(dst), local.get()); } - RefPtr<RegisterID> scope = generator.emitResolveScope(dst, var); - RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), var, DoNotThrowIfNotFound); - generator.emitTDZCheckIfNecessary(var, value.get(), nullptr); + RefPtr<RegisterID> scope = generator.emitResolveScope(generator.tempDestination(dst), m_ident); + RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), m_ident, DoNotThrowIfNotFound); if (dst == generator.ignoredResult()) return 0; return generator.emitTypeOf(generator.finalDestination(dst, scope.get()), value.get()); @@ -1225,38 +848,28 @@ RegisterID* PrefixNode::emitResolve(BytecodeGenerator& generator, RegisterID* ds ResolveNode* resolve = static_cast<ResolveNode*>(m_expr); const Identifier& ident = resolve->identifier(); - 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()) { + if (Local local = generator.local(ident)) { + RegisterID* localReg = local.get(); + if (local.isReadOnly()) { + generator.emitReadOnlyExceptionIfNeeded(); + localReg = generator.emitMove(generator.tempDestination(dst), localReg); + } + if (local.isCaptured()) { RefPtr<RegisterID> tempDst = generator.tempDestination(dst); - generator.emitMove(tempDst.get(), localReg.get()); + generator.emitMove(tempDst.get(), localReg); emitIncOrDec(generator, tempDst.get(), m_operator); - generator.emitMove(localReg.get(), tempDst.get()); - generator.emitProfileType(localReg.get(), var, divotStart(), divotEnd()); + generator.emitMove(localReg, tempDst.get()); return generator.moveToDestinationIfNeeded(dst, tempDst.get()); } - emitIncOrDec(generator, localReg.get(), m_operator); - return generator.moveToDestinationIfNeeded(dst, localReg.get()); + emitIncOrDec(generator, localReg, m_operator); + return generator.moveToDestinationIfNeeded(dst, localReg); } 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(); - } - + RefPtr<RegisterID> scope = generator.emitResolveScope(generator.tempDestination(dst), ident); + RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), ident, ThrowIfNotFound); emitIncOrDec(generator, value.get(), m_operator); - generator.emitPutToScope(scope.get(), var, value.get(), ThrowIfNotFound); - generator.emitProfileType(value.get(), var, divotStart(), divotEnd()); + generator.emitPutToScope(scope.get(), ident, value.get(), ThrowIfNotFound); return generator.moveToDestinationIfNeeded(dst, value.get()); } @@ -1276,7 +889,6 @@ 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()); } @@ -1295,7 +907,6 @@ 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()); } @@ -1311,17 +922,17 @@ RegisterID* PrefixNode::emitBytecode(BytecodeGenerator& generator, RegisterID* d return emitDot(generator, dst); return emitThrowReferenceError(generator, m_operator == OpPlusPlus - ? ASCIILiteral("Prefix ++ operator applied to value that is not a reference.") - : ASCIILiteral("Prefix -- operator applied to value that is not a reference.")); + ? "Prefix ++ operator applied to value that is not a reference." + : "Prefix -- operator applied to value that is not a reference."); } // ------------------------------ Unary Operation Nodes ----------------------------------- RegisterID* UnaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - RefPtr<RegisterID> src = generator.emitNode(m_expr); + RegisterID* src = generator.emitNode(m_expr); generator.emitExpressionInfo(position(), position(), position()); - return generator.emitUnaryOp(opcodeID(), generator.finalDestination(dst), src.get()); + return generator.emitUnaryOp(opcodeID(), generator.finalDestination(dst), src); } // ------------------------------ BitwiseNotNode ----------------------------------- @@ -1329,8 +940,8 @@ RegisterID* UnaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* RegisterID* BitwiseNotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { RefPtr<RegisterID> src2 = generator.emitLoad(generator.newTemporary(), jsNumber(-1)); - 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())); + RegisterID* src1 = generator.emitNode(m_expr); + return generator.emitBinaryOp(op_bitxor, generator.finalDestination(dst, src1), src1, src2.get(), OperandTypes(m_expr->resultDescriptor(), ResultType::numberTypeIsInt32())); } // ------------------------------ LogicalNotNode ----------------------------------- @@ -1544,20 +1155,20 @@ RegisterID* BinaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* } RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(left, m_rightHasAssignments, right->isPure(generator)); - bool wasTypeof = generator.lastOpcodeID() == op_typeof; - RefPtr<RegisterID> src2 = generator.emitNode(right); + bool wasTypeof = generator.m_lastOpcodeID == op_typeof; + 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.get()); + generator.emitEqualityOp(op_eq, generator.finalDestination(tmp.get(), src1.get()), src1.get(), src2); else if (opcodeID == op_nstricteq) - generator.emitEqualityOp(op_stricteq, generator.finalDestination(tmp.get(), src1.get()), src1.get(), src2.get()); + generator.emitEqualityOp(op_stricteq, generator.finalDestination(tmp.get(), src1.get()), src1.get(), src2); else RELEASE_ASSERT_NOT_REACHED(); return generator.emitUnaryOp(op_not, generator.finalDestination(dst, tmp.get()), tmp.get()); } - RegisterID* result = generator.emitBinaryOp(opcodeID, generator.finalDestination(dst, src1.get()), src1.get(), src2.get(), OperandTypes(left->resultDescriptor(), right->resultDescriptor())); + RegisterID* result = generator.emitBinaryOp(opcodeID, generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(left->resultDescriptor(), right->resultDescriptor())); if (opcodeID == op_urshift && dst != generator.ignoredResult()) return generator.emitUnaryOp(op_unsigned, result, result); return result; @@ -1577,8 +1188,8 @@ RegisterID* EqualNode::emitBytecode(BytecodeGenerator& generator, RegisterID* ds std::swap(left, right); RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(left, m_rightHasAssignments, m_expr2->isPure(generator)); - RefPtr<RegisterID> src2 = generator.emitNode(right); - return generator.emitEqualityOp(op_eq, generator.finalDestination(dst, src1.get()), src1.get(), src2.get()); + RegisterID* src2 = generator.emitNode(right); + return generator.emitEqualityOp(op_eq, generator.finalDestination(dst, src1.get()), src1.get(), src2); } RegisterID* StrictEqualNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) @@ -1589,16 +1200,16 @@ RegisterID* StrictEqualNode::emitBytecode(BytecodeGenerator& generator, Register std::swap(left, right); RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(left, m_rightHasAssignments, m_expr2->isPure(generator)); - RefPtr<RegisterID> src2 = generator.emitNode(right); - return generator.emitEqualityOp(op_stricteq, generator.finalDestination(dst, src1.get()), src1.get(), src2.get()); + RegisterID* src2 = generator.emitNode(right); + return generator.emitEqualityOp(op_stricteq, generator.finalDestination(dst, src1.get()), src1.get(), src2); } RegisterID* ThrowableBinaryOpNode::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); + RegisterID* src2 = generator.emitNode(m_expr2); generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - return generator.emitBinaryOp(opcodeID(), generator.finalDestination(dst, src1.get()), src1.get(), src2.get(), OperandTypes(m_expr1->resultDescriptor(), m_expr2->resultDescriptor())); + return generator.emitBinaryOp(opcodeID(), generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(m_expr1->resultDescriptor(), m_expr2->resultDescriptor())); } RegisterID* InstanceOfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) @@ -1663,18 +1274,14 @@ RegisterID* ConditionalNode::emitBytecode(BytecodeGenerator& generator, Register generator.emitNodeInConditionContext(m_logical, beforeThen.get(), beforeElse.get(), FallThroughMeansTrue); generator.emitLabel(beforeThen.get()); - generator.emitProfileControlFlow(m_expr1->startOffset()); generator.emitNode(newDst.get(), m_expr1); generator.emitJump(afterElse.get()); generator.emitLabel(beforeElse.get()); - generator.emitProfileControlFlow(m_expr1->endOffset() + 1); generator.emitNode(newDst.get(), m_expr2); generator.emitLabel(afterElse.get()); - generator.emitProfileControlFlow(m_expr2->endOffset() + 1); - return newDst.get(); } @@ -1739,102 +1346,60 @@ static ALWAYS_INLINE RegisterID* emitReadModifyAssignment(BytecodeGenerator& gen RegisterID* ReadModifyResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - 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 (Local local = generator.local(m_ident)) { + if (local.isReadOnly()) { + generator.emitReadOnlyExceptionIfNeeded(); + return emitReadModifyAssignment(generator, generator.finalDestination(dst), local.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor())); } - if (generator.leftHandSideNeedsCopy(m_rightHasAssignments, m_right->isPure(generator))) { + if (local.isCaptured() + || generator.leftHandSideNeedsCopy(m_rightHasAssignments, m_right->isPure(generator))) { RefPtr<RegisterID> result = generator.newTemporary(); - generator.emitMove(result.get(), local); + generator.emitMove(result.get(), local.get()); 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()); + generator.emitMove(local.get(), result.get()); 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()); + RegisterID* result = emitReadModifyAssignment(generator, local.get(), local.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor())); return generator.moveToDestinationIfNeeded(dst, result); } + JSTextPosition newDivot = divotStart() + m_ident.length(); generator.emitExpressionInfo(newDivot, divotStart(), newDivot); - 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> scope = generator.emitResolveScope(generator.newTemporary(), m_ident); + RefPtr<RegisterID> value = generator.emitGetFromScope(generator.newTemporary(), scope.get(), m_ident, ThrowIfNotFound); 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 = generator.emitPutToScope(scope.get(), var, result.get(), ThrowIfNotFound); - generator.emitProfileType(result.get(), var, divotStart(), divotEnd()); - return returnResult; + return generator.emitPutToScope(scope.get(), m_ident, result.get(), ThrowIfNotFound); } // ------------------------------ AssignResolveNode ----------------------------------- RegisterID* AssignResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - Variable var = generator.variable(m_ident); - if (RegisterID* local = var.local()) { - RegisterID* result = nullptr; - if (m_assignmentContext == AssignmentContext::AssignmentExpression) - generator.emitTDZCheckIfNecessary(var, local, nullptr); - - if (var.isReadOnly() && m_assignmentContext != AssignmentContext::ConstDeclarationStatement) { - result = generator.emitNode(dst, m_right); // Execute side effects first. - generator.emitReadOnlyExceptionIfNeeded(var); - generator.emitProfileType(result, var, divotStart(), divotEnd()); - } else if (var.isSpecial()) { + if (Local local = generator.local(m_ident)) { + if (local.isReadOnly()) { + generator.emitReadOnlyExceptionIfNeeded(); + return generator.emitNode(dst, m_right); + } + if (local.isCaptured()) { 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); + generator.emitMove(local.get(), tempDst.get()); + return generator.moveToDestinationIfNeeded(dst, tempDst.get()); } - - if (m_assignmentContext == AssignmentContext::DeclarationStatement || m_assignmentContext == AssignmentContext::ConstDeclarationStatement) - generator.liftTDZCheckIfPossible(var); - return result; + RegisterID* result = generator.emitNode(local.get(), m_right); + return generator.moveToDestinationIfNeeded(dst, result); } if (generator.isStrictMode()) generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - RefPtr<RegisterID> scope = generator.emitResolveScope(nullptr, var); - if (m_assignmentContext == AssignmentContext::AssignmentExpression) - generator.emitTDZCheckIfNecessary(var, nullptr, scope.get()); + RefPtr<RegisterID> scope = generator.emitResolveScope(generator.newTemporary(), m_ident); if (dst == generator.ignoredResult()) dst = 0; RefPtr<RegisterID> result = generator.emitNode(dst, m_right); - if (var.isReadOnly() && m_assignmentContext != AssignmentContext::ConstDeclarationStatement) { - 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()); - RegisterID* returnResult = generator.emitPutToScope(scope.get(), var, result.get(), generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound); - generator.emitProfileType(result.get(), var, divotStart(), divotEnd()); - - if (m_assignmentContext == AssignmentContext::DeclarationStatement || m_assignmentContext == AssignmentContext::ConstDeclarationStatement) - generator.liftTDZCheckIfPossible(var); - return returnResult; + return generator.emitPutToScope(scope.get(), m_ident, result.get(), generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound); } // ------------------------------ AssignDotNode ----------------------------------- @@ -1843,11 +1408,10 @@ 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); - RefPtr<RegisterID> result = generator.emitNode(value.get(), m_right); + RegisterID* result = generator.emitNode(value.get(), m_right); generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result.get() : generator.moveToDestinationIfNeeded(generator.tempDestination(result.get()), result.get()); + RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result : generator.moveToDestinationIfNeeded(generator.tempDestination(result), result); generator.emitPutById(base.get(), m_ident, forwardResult); - generator.emitProfileType(forwardResult, divotStart(), divotEnd()); return generator.moveToDestinationIfNeeded(dst, forwardResult); } @@ -1859,19 +1423,17 @@ 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, static_cast<JSC::Operator>(m_operator), OperandTypes(ResultType::unknownType(), m_right->resultDescriptor())); + RegisterID* updatedValue = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, m_operator, OperandTypes(ResultType::unknownType(), m_right->resultDescriptor())); generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - RegisterID* ret = generator.emitPutById(base.get(), m_ident, updatedValue); - generator.emitProfileType(updatedValue, divotStart(), divotEnd()); - return ret; + return generator.emitPutById(base.get(), m_ident, updatedValue); } // ------------------------------ AssignErrorNode ----------------------------------- RegisterID* AssignErrorNode::emitBytecode(BytecodeGenerator& generator, RegisterID*) { - return emitThrowReferenceError(generator, ASCIILiteral("Left side of assignment is not a reference.")); + return emitThrowReferenceError(generator, "Left side of assignment is not a reference."); } // ------------------------------ AssignBracketNode ----------------------------------- @@ -1881,17 +1443,11 @@ 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); - RefPtr<RegisterID> result = generator.emitNode(value.get(), m_right); + RegisterID* result = generator.emitNode(value.get(), m_right); generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result.get() : generator.moveToDestinationIfNeeded(generator.tempDestination(result.get()), result.get()); - - if (m_subscript->isString()) - generator.emitPutById(base.get(), static_cast<StringNode*>(m_subscript)->value(), forwardResult); - else - generator.emitPutByVal(base.get(), property.get(), forwardResult); - - generator.emitProfileType(forwardResult, divotStart(), divotEnd()); + RegisterID* forwardResult = (dst == generator.ignoredResult()) ? result : generator.moveToDestinationIfNeeded(generator.tempDestination(result), result); + generator.emitPutByVal(base.get(), property.get(), forwardResult); return generator.moveToDestinationIfNeeded(dst, forwardResult); } @@ -1904,11 +1460,10 @@ 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, static_cast<JSC::Operator>(m_operator), OperandTypes(ResultType::unknownType(), m_right->resultDescriptor())); + RegisterID* updatedValue = emitReadModifyAssignment(generator, generator.finalDestination(dst, value.get()), value.get(), m_right, 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; } @@ -1917,10 +1472,58 @@ RegisterID* ReadModifyBracketNode::emitBytecode(BytecodeGenerator& generator, Re RegisterID* CommaNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - CommaNode* node = this; - for (; node && node->next(); node = node->next()) - generator.emitNode(generator.ignoredResult(), node->m_expr); - return generator.emitNode(dst, node->m_expr); + 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) +{ + // FIXME: This code does not match the behavior of const in Firefox. + if (Local local = generator.constLocal(m_ident)) { + if (!m_init) + return local.get(); + + if (local.isCaptured()) { + RefPtr<RegisterID> tempDst = generator.newTemporary(); + generator.emitNode(tempDst.get(), m_init); + return generator.emitMove(local.get(), tempDst.get()); + } + + return generator.emitNode(local.get(), 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> scope = generator.emitResolveScope(generator.newTemporary(), m_ident); + return generator.emitPutToScope(scope.get(), m_ident, value.get(), DoNotThrowIfNotFound); +} + +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(), startOffset(), lineStartOffset()); + generator.emitNode(m_next); } // ------------------------------ SourceElements ------------------------------- @@ -1928,13 +1531,15 @@ RegisterID* CommaNode::emitBytecode(BytecodeGenerator& generator, RegisterID* ds inline StatementNode* SourceElements::lastStatement() const { - return m_tail; + size_t size = m_statements.size(); + return size ? m_statements[size - 1] : 0; } inline void SourceElements::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - for (StatementNode* statement = m_head; statement; statement = statement->next()) - generator.emitNode(dst, statement); + size_t size = m_statements.size(); + for (size_t i = 0; i < size; ++i) + generator.emitNode(dst, m_statements[i]); } // ------------------------------ BlockNode ------------------------------------ @@ -1944,7 +1549,7 @@ inline StatementNode* BlockNode::lastStatement() const return m_statements ? m_statements->lastStatement() : 0; } -StatementNode* BlockNode::singleStatement() const +inline StatementNode* BlockNode::singleStatement() const { return m_statements ? m_statements->singleStatement() : 0; } @@ -1953,9 +1558,7 @@ void BlockNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { if (!m_statements) return; - generator.pushLexicalScope(this, true); m_statements->emitBytecode(generator, dst); - generator.popLexicalScope(this); } // ------------------------------ EmptyStatementNode --------------------------- @@ -1981,56 +1584,15 @@ void ExprStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* d generator.emitNode(dst, m_expr); } -// ------------------------------ DeclarationStatement ---------------------------- +// ------------------------------ VarStatementNode ---------------------------- -void DeclarationStatement::emitBytecode(BytecodeGenerator& generator, RegisterID*) +void VarStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*) { ASSERT(m_expr); 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); - 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) @@ -2085,7 +1647,6 @@ 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); @@ -2095,14 +1656,10 @@ void IfElseNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) generator.emitLabel(beforeElse.get()); - if (m_elseBlock) { - generator.emitProfileControlFlow(m_ifBlock->endOffset() + (m_ifBlock->isBlock() ? 1 : 0)); + if (m_elseBlock) generator.emitNode(dst, m_elseBlock); - } generator.emitLabel(afterElse.get()); - StatementNode* endingBlock = m_elseBlock ? m_elseBlock : m_ifBlock; - generator.emitProfileControlFlow(endingBlock->endOffset() + (endingBlock->isBlock() ? 1 : 0)); } // ------------------------------ DoWhileNode ---------------------------------- @@ -2132,13 +1689,12 @@ void WhileNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) LabelScopePtr scope = generator.newLabelScope(LabelScope::Loop); RefPtr<Label> topOfLoop = generator.newLabel(); - generator.emitDebugHook(WillExecuteStatement, m_expr->firstLine(), m_expr->startOffset(), m_expr->lineStartOffset()); + generator.emitDebugHook(WillExecuteStatement, m_expr->lineNo(), m_expr->startOffset(), m_expr->lineStartOffset()); generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), FallThroughMeansTrue); generator.emitLabel(topOfLoop.get()); generator.emitLoopHint(); - generator.emitProfileControlFlow(m_statement->startOffset()); generator.emitNode(dst, m_statement); generator.emitLabel(scope->continueTarget()); @@ -2147,8 +1703,6 @@ void WhileNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) generator.emitNodeInConditionContext(m_expr, topOfLoop.get(), scope->breakTarget(), FallThroughMeansFalse); generator.emitLabel(scope->breakTarget()); - - generator.emitProfileControlFlow(m_statement->endOffset() + (m_statement->isBlock() ? 1 : 0)); } // ------------------------------ ForNode -------------------------------------- @@ -2157,9 +1711,6 @@ void ForNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { LabelScopePtr scope = generator.newLabelScope(LabelScope::Loop); - RegisterID* forLoopSymbolTable = nullptr; - generator.pushLexicalScope(this, true, &forLoopSymbolTable); - generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset()); if (m_expr1) @@ -2171,13 +1722,11 @@ void ForNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) generator.emitLabel(topOfLoop.get()); generator.emitLoopHint(); - generator.emitProfileControlFlow(m_statement->startOffset()); generator.emitNode(dst, m_statement); generator.emitLabel(scope->continueTarget()); generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset()); - generator.prepareLexicalScopeForNextForLoopIteration(this, forLoopSymbolTable); if (m_expr3) generator.emitNode(generator.ignoredResult(), m_expr3); @@ -2187,272 +1736,131 @@ 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 ------------------------------------ -RegisterID* ForInNode::tryGetBoundLocal(BytecodeGenerator& generator) +void ForInNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - if (m_lexpr->isResolveNode()) { - const Identifier& ident = static_cast<ResolveNode*>(m_lexpr)->identifier(); - return generator.variable(ident).local(); + 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->isDestructuringNode()) { - DestructuringAssignmentNode* assignNode = static_cast<DestructuringAssignmentNode*>(m_lexpr); - auto binding = assignNode->bindings(); - if (!binding->isBindingNode()) - return nullptr; + generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset()); - 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<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()); - return nullptr; -} + RefPtr<Label> loopStart = generator.newLabel(); + generator.emitLabel(loopStart.get()); + generator.emitLoopHint(); -void ForInNode::emitLoopHeader(BytecodeGenerator& generator, RegisterID* propertyName) -{ + RegisterID* propertyName; + bool optimizedForinAccess = false; 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, propertyName); - else { + Local local = generator.local(ident); + if (!local.get()) { + propertyName = generator.newTemporary(); + RefPtr<RegisterID> protect = propertyName; if (generator.isStrictMode()) generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - RegisterID* scope = generator.emitResolveScope(nullptr, var); + RegisterID* scope = generator.emitResolveScope(generator.newTemporary(), ident); generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - generator.emitPutToScope(scope, var, propertyName, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound); + generator.emitPutToScope(scope, ident, propertyName, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound); + } else { + expectedSubscript = generator.newTemporary(); + propertyName = expectedSubscript.get(); + generator.emitMove(local.get(), propertyName); + generator.pushOptimisedForIn(expectedSubscript.get(), iter.get(), i.get(), local.get()); + optimizedForinAccess = true; } - generator.emitProfileType(propertyName, var, m_lexpr->position(), JSTextPosition(-1, m_lexpr->position().offset + ident.length(), -1)); - return; - } - if (m_lexpr->isDotAccessorNode()) { + } else 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); - generator.emitProfileType(propertyName, assignNode->divotStart(), assignNode->divotEnd()); - return; - } - if (m_lexpr->isBracketAccessorNode()) { + } else 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; - } - - if (m_lexpr->isDestructuringNode()) { - DestructuringAssignmentNode* assignNode = static_cast<DestructuringAssignmentNode*>(m_lexpr); + } else { + ASSERT(m_lexpr->isDeconstructionNode()); + DeconstructingAssignmentNode* assignNode = static_cast<DeconstructingAssignmentNode*>(m_lexpr); auto binding = assignNode->bindings(); - if (!binding->isBindingNode()) { - assignNode->bindings()->bindValue(generator, propertyName); - return; - } - - auto simpleBinding = static_cast<BindingNode*>(binding); - const Identifier& ident = simpleBinding->boundProperty(); - Variable var = generator.variable(ident); - if (!var.local() || var.isSpecial()) { + if (binding->isBindingNode()) { + auto simpleBinding = static_cast<BindingNode*>(binding); + Identifier ident = simpleBinding->boundProperty(); + Local local = generator.local(ident); + propertyName = local.get(); + if (!propertyName || local.isCaptured()) + goto genericBinding; + expectedSubscript = generator.emitMove(generator.newTemporary(), propertyName); + generator.pushOptimisedForIn(expectedSubscript.get(), iter.get(), i.get(), propertyName); + optimizedForinAccess = true; + goto completedSimpleBinding; + } else { + genericBinding: + propertyName = generator.newTemporary(); + RefPtr<RegisterID> protect(propertyName); assignNode->bindings()->bindValue(generator, propertyName); - return; } - generator.emitMove(var.local(), propertyName); - generator.emitProfileType(propertyName, var, simpleBinding->divotStart(), simpleBinding->divotEnd()); - return; - } - - 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, true, &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()); + completedSimpleBinding: + ; } - // 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.emitNode(dst, m_statement); - generator.emitLabel(scope->breakTarget()); - generator.emitJump(end.get()); - generator.emitLabel(loopEnd.get()); - } + if (optimizedForinAccess) + generator.popOptimisedForIn(); + generator.emitLabel(scope->continueTarget()); + generator.emitNextPropertyName(propertyName, base.get(), i.get(), size.get(), iter.get(), loopStart.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); + generator.emitLabel(scope->breakTarget()); } // ------------------------------ 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.")); + if (!m_lexpr->isLocation()) { + emitThrowReferenceError(generator, "Left side of for-of statement is not a reference."); return; } - - RegisterID* forLoopSymbolTable = nullptr; - generator.pushLexicalScope(this, true, &forLoopSymbolTable); + + LabelScopePtr scope = generator.newLabelScope(LabelScope::Loop); + 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); + if (Local local = generator.local(ident)) + generator.emitMove(local.get(), value); else { if (generator.isStrictMode()) generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - RegisterID* scope = generator.emitResolveScope(nullptr, var); + RegisterID* scope = generator.emitResolveScope(generator.newTemporary(), ident); generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); - generator.emitPutToScope(scope, var, value, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound); + generator.emitPutToScope(scope, ident, value, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound); } - 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(); @@ -2460,7 +1868,6 @@ void ForOfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) 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()); @@ -2468,18 +1875,14 @@ void ForOfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) 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); + ASSERT(m_lexpr->isDeconstructionNode()); + DeconstructingAssignmentNode* assignNode = static_cast<DeconstructingAssignmentNode*>(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)); + generator.emitEnumeration(this, m_expr, extractor); } // ------------------------------ ContinueNode --------------------------------- @@ -2489,10 +1892,10 @@ Label* ContinueNode::trivialTarget(BytecodeGenerator& generator) if (generator.shouldEmitDebugHooks()) return 0; - LabelScopePtr scope = generator.continueTarget(m_ident); + LabelScope* scope = generator.continueTarget(m_ident); ASSERT(scope); - if (generator.labelScopeDepth() != scope->scopeDepth()) + if (generator.scopeDepth() != scope->scopeDepth()) return 0; return scope->continueTarget(); @@ -2502,13 +1905,11 @@ void ContinueNode::emitBytecode(BytecodeGenerator& generator, RegisterID*) { generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset()); - LabelScopePtr scope = generator.continueTarget(m_ident); + LabelScope* scope = generator.continueTarget(m_ident); ASSERT(scope); - generator.emitPopScopes(generator.scopeRegister(), scope->scopeDepth()); + generator.emitPopScopes(scope->scopeDepth()); generator.emitJump(scope->continueTarget()); - - generator.emitProfileControlFlow(endOffset()); } // ------------------------------ BreakNode ------------------------------------ @@ -2518,10 +1919,10 @@ Label* BreakNode::trivialTarget(BytecodeGenerator& generator) if (generator.shouldEmitDebugHooks()) return 0; - LabelScopePtr scope = generator.breakTarget(m_ident); + LabelScope* scope = generator.breakTarget(m_ident); ASSERT(scope); - if (generator.labelScopeDepth() != scope->scopeDepth()) + if (generator.scopeDepth() != scope->scopeDepth()) return 0; return scope->breakTarget(); @@ -2531,13 +1932,11 @@ void BreakNode::emitBytecode(BytecodeGenerator& generator, RegisterID*) { generator.emitDebugHook(WillExecuteStatement, firstLine(), startOffset(), lineStartOffset()); - LabelScopePtr scope = generator.breakTarget(m_ident); + LabelScope* scope = generator.breakTarget(m_ident); ASSERT(scope); - generator.emitPopScopes(generator.scopeRegister(), scope->scopeDepth()); + generator.emitPopScopes(scope->scopeDepth()); generator.emitJump(scope->breakTarget()); - - generator.emitProfileControlFlow(endOffset()); } // ------------------------------ ReturnNode ----------------------------------- @@ -2551,19 +1950,13 @@ void ReturnNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) dst = 0; RefPtr<RegisterID> returnRegister = m_value ? generator.emitNode(dst, m_value) : generator.emitLoad(dst, jsUndefined()); - generator.emitProfileType(returnRegister.get(), ProfileTypeBytecodeFunctionReturnStatement, divotStart(), divotEnd()); - if (generator.isInFinallyBlock()) { + if (generator.scopeDepth()) { returnRegister = generator.emitMove(generator.newTemporary(), returnRegister.get()); - generator.emitPopScopes(generator.scopeRegister(), 0); + generator.emitPopScopes(0); } 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 ------------------------------------- @@ -2576,14 +1969,13 @@ void WithNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) generator.emitExpressionInfo(m_divot, m_divot - m_expressionLength, m_divot); generator.emitPushWithScope(scope.get()); generator.emitNode(dst, m_statement); - generator.emitPopWithScope(); + generator.emitPopScope(); } // ------------------------------ CaseClauseNode -------------------------------- inline void CaseClauseNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { - generator.emitProfileControlFlow(m_startOffset); if (!m_statements) return; m_statements->emitBytecode(generator, dst); @@ -2750,13 +2142,9 @@ void SwitchNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) LabelScopePtr scope = generator.newLabelScope(LabelScope::Switch); RefPtr<RegisterID> r0 = generator.emitNode(m_expr); - - generator.pushLexicalScope(this, false); m_block->emitBytecodeForBlock(generator, r0.get(), dst); - generator.popLexicalScope(this); generator.emitLabel(scope->breakTarget()); - generator.emitProfileControlFlow(endOffset()); } // ------------------------------ LabelNode ------------------------------------ @@ -2784,8 +2172,6 @@ void ThrowNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) RefPtr<RegisterID> expr = generator.emitNode(m_expr); generator.emitExpressionInfo(divot(), divotStart(), divotEnd()); generator.emitThrow(expr.get()); - - generator.emitProfileControlFlow(endOffset()); } // ------------------------------ TryNode -------------------------------------- @@ -2816,20 +2202,17 @@ 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.newTemporary(); - RefPtr<RegisterID> thrownValueRegister = generator.newTemporary(); - generator.popTryAndEmitCatch(tryData, exceptionRegister.get(), thrownValueRegister.get(), here.get(), HandlerType::Catch); + RefPtr<RegisterID> exceptionRegister = generator.popTryAndEmitCatch(tryData, generator.newTemporary(), here.get()); 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.emitPushCatchScope(m_thrownValueIdent, thrownValueRegister.get(), m_catchEnvironment); - generator.emitProfileControlFlow(m_tryBlock->endOffset() + 1); + + generator.emitPushNameScope(m_exceptionIdent, exceptionRegister.get(), DontDelete); generator.emitNode(dst, m_catchBlock); - generator.emitPopCatchScope(m_catchEnvironment); + generator.emitPopScope(); generator.emitLabel(catchEndLabel.get()); } @@ -2840,27 +2223,17 @@ 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.emitProfileControlFlow(finallyStartOffset); generator.emitNode(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> exceptionRegister = generator.newTemporary(); - RefPtr<RegisterID> thrownValueRegister = generator.newTemporary(); - generator.popTryAndEmitCatch(tryData, exceptionRegister.get(), thrownValueRegister.get(), preFinallyLabel.get(), HandlerType::Finally); - generator.emitProfileControlFlow(finallyStartOffset); + RefPtr<RegisterID> tempExceptionRegister = generator.popTryAndEmitCatch(tryData, generator.newTemporary(), preFinallyLabel.get()); generator.emitNode(dst, m_finallyBlock); - generator.emitThrow(exceptionRegister.get()); + generator.emitThrow(tempExceptionRegister.get()); generator.emitLabel(finallyEndLabel.get()); - generator.emitProfileControlFlow(m_finallyBlock->endOffset() + 1); - } else - generator.emitProfileControlFlow(m_catchBlock->endOffset() + 1); - + } } // ------------------------------ ScopeNode ----------------------------- @@ -2880,19 +2253,12 @@ void ProgramNode::emitBytecode(BytecodeGenerator& generator, RegisterID*) RefPtr<RegisterID> dstRegister = generator.newTemporary(); generator.emitLoad(dstRegister.get(), jsUndefined()); - generator.emitProfileControlFlow(startStartOffset()); emitStatementsBytecode(generator, dstRegister.get()); generator.emitDebugHook(DidExecuteProgram, lastLine(), startOffset(), lineStartOffset()); generator.emitEnd(dstRegister.get()); } -// ------------------------------ ModuleProgramNode -------------------- - -void ModuleProgramNode::emitBytecode(BytecodeGenerator&, RegisterID*) -{ -} - // ------------------------------ EvalNode ----------------------------- void EvalNode::emitBytecode(BytecodeGenerator& generator, RegisterID*) @@ -2907,22 +2273,10 @@ void EvalNode::emitBytecode(BytecodeGenerator& generator, RegisterID*) generator.emitEnd(dstRegister.get()); } -// ------------------------------ FunctionNode ----------------------------- +// ------------------------------ FunctionBodyNode ----------------------------- -void FunctionNode::emitBytecode(BytecodeGenerator& generator, RegisterID*) +void FunctionBodyNode::emitBytecode(BytecodeGenerator& generator, RegisterID*) { - 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(®, ProfileTypeBytecodeFunctionArgument, parameter->divotStart(), parameter->divotEnd()); - } - } - - generator.emitProfileControlFlow(startStartOffset()); generator.emitDebugHook(DidEnterCallFrame, startLine(), startStartOffset(), startLineStartOffset()); emitStatementsBytecode(generator, generator.ignoredResult()); @@ -2939,12 +2293,27 @@ void FunctionNode::emitBytecode(BytecodeGenerator& generator, RegisterID*) // If there is no return we must automatically insert one. if (!returnNode) { 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; } + + // 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); + } + } + } } // ------------------------------ FuncDeclNode --------------------------------- @@ -2959,119 +2328,9 @@ RegisterID* FuncExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID* { return generator.emitNewFunctionExpression(generator.finalDestination(dst), this); } - -#if ENABLE(ES6_CLASS_SYNTAX) -// ------------------------------ ClassDeclNode --------------------------------- - -void ClassDeclNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) -{ - generator.emitNode(dst, m_classDeclaration); -} - -// ------------------------------ ClassExprNode --------------------------------- - -RegisterID* ClassExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) -{ - 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.emitThrowTypeError(ASCIILiteral("The superclass's prototype 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); - - return generator.moveToDestinationIfNeeded(dst, constructor.get()); -} -#endif - -// ------------------------------ ImportDeclarationNode ----------------------- - -void ImportDeclarationNode::emitBytecode(BytecodeGenerator&, RegisterID*) -{ -} - -// ------------------------------ ExportAllDeclarationNode -------------------- - -void ExportAllDeclarationNode::emitBytecode(BytecodeGenerator&, RegisterID*) -{ -} - -// ------------------------------ ExportDefaultDeclarationNode ---------------- - -void ExportDefaultDeclarationNode::emitBytecode(BytecodeGenerator&, RegisterID*) -{ -} - -// ------------------------------ ExportLocalDeclarationNode ------------------ - -void ExportLocalDeclarationNode::emitBytecode(BytecodeGenerator&, RegisterID*) -{ -} - -// ------------------------------ ExportNamedDeclarationNode ------------------ - -void ExportNamedDeclarationNode::emitBytecode(BytecodeGenerator&, RegisterID*) -{ -} - -// ------------------------------ DestructuringAssignmentNode ----------------- -RegisterID* DestructuringAssignmentNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) + +// ------------------------------ DeconstructingAssignmentNode ----------------- +RegisterID* DeconstructingAssignmentNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst) { if (RegisterID* result = m_bindings->emitDirectBinding(generator, dst, m_initializer)) return result; @@ -3081,102 +2340,43 @@ RegisterID* DestructuringAssignmentNode::emitBytecode(BytecodeGenerator& generat return generator.moveToDestinationIfNeeded(dst, initializer.get()); } -static void assignDefaultValueIfUndefined(BytecodeGenerator& generator, RegisterID* maybeUndefined, ExpressionNode* defaultValue) +DeconstructionPatternNode::~DeconstructionPatternNode() { - 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; - } - } + for (size_t i = 0; i < m_targetPatterns.size(); i++) { + auto target = m_targetPatterns[i]; + if (!target) + continue; + RefPtr<RegisterID> temp = generator.newTemporary(); + generator.emitLoad(temp.get(), jsNumber(i)); + generator.emitGetByVal(temp.get(), rhs, temp.get()); + target->bindValue(generator, temp.get()); } - - 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->isResolveNode() + && generator.willResolveToArguments(static_cast<ResolveNode*>(rhs)->identifier()) + && !generator.symbolTable().slowArguments()) { + for (size_t i = 0; i < m_targetPatterns.size(); i++) { + auto target = m_targetPatterns[i]; + if (!target) + continue; + + RefPtr<RegisterID> temp = generator.newTemporary(); + generator.emitLoad(temp.get(), jsNumber(i)); + generator.emitGetArgumentByVal(temp.get(), generator.uncheckedRegisterForArguments(), temp.get()); + target->bindValue(generator, temp.get()); + } + if (dst == generator.ignoredResult() || !dst) + return generator.emitLoad(generator.finalDestination(dst), jsUndefined()); + Local local = generator.local(generator.vm()->propertyNames->arguments); + return generator.moveToDestinationIfNeeded(dst, local.get()); + } if (!rhs->isSimpleArray()) return 0; @@ -3194,15 +2394,13 @@ RegisterID* ArrayPatternNode::emitDirectBinding(BytecodeGenerator& generator, Re 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 (m_targetPatterns[i]) + m_targetPatterns[i]->bindValue(generator, registers[i].get()); } if (resultRegister) return generator.moveToDestinationIfNeeded(dst, resultRegister.get()); @@ -3213,24 +2411,13 @@ 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: + if (!m_targetPatterns[i]) { 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; + continue; } + m_targetPatterns[i]->toString(builder); + if (i < m_targetPatterns.size() - 1) + builder.append(','); } builder.append(']'); } @@ -3238,7 +2425,7 @@ void ArrayPatternNode::toString(StringBuilder& builder) const void ArrayPatternNode::collectBoundIdentifiers(Vector<Identifier>& identifiers) const { for (size_t i = 0; i < m_targetPatterns.size(); i++) { - if (DestructuringPatternNode* node = m_targetPatterns[i].pattern) + if (DeconstructionPatternNode* node = m_targetPatterns[i].get()) node->collectBoundIdentifiers(identifiers); } } @@ -3247,11 +2434,13 @@ 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 + if (m_targetPatterns[i].wasString) { + builder.append('"'); + escapeStringToBuilder(builder, m_targetPatterns[i].propertyName.string()); + builder.append('"'); + } else builder.append(m_targetPatterns[i].propertyName.string()); - builder.append(':'); + builder.append(":"); m_targetPatterns[i].pattern->toString(builder); if (i < m_targetPatterns.size() - 1) builder.append(','); @@ -3265,8 +2454,6 @@ void ObjectPatternNode::bindValue(BytecodeGenerator& generator, RegisterID* rhs) auto& target = m_targetPatterns[i]; RefPtr<RegisterID> temp = generator.newTemporary(); generator.emitGetById(temp.get(), rhs, target.propertyName); - if (target.defaultValue) - assignDefaultValueIfUndefined(generator, temp.get(), target.defaultValue); target.pattern->bindValue(generator, temp.get()); } } @@ -3279,36 +2466,19 @@ void ObjectPatternNode::collectBoundIdentifiers(Vector<Identifier>& identifiers) void BindingNode::bindValue(BytecodeGenerator& generator, RegisterID* value) const { - Variable var = generator.variable(m_boundProperty); - if (RegisterID* local = var.local()) { - if (m_bindingContext == AssignmentContext::AssignmentExpression) - generator.emitTDZCheckIfNecessary(var, local, nullptr); - if (var.isReadOnly() && m_bindingContext != AssignmentContext::ConstDeclarationStatement) { - bool threwException = generator.emitReadOnlyExceptionIfNeeded(var); - if (threwException) - return; + if (Local local = generator.local(m_boundProperty)) { + if (local.isReadOnly()) { + generator.emitReadOnlyExceptionIfNeeded(); + return; } - generator.emitMove(local, value); - generator.emitProfileType(local, var, divotStart(), divotEnd()); - if (m_bindingContext == AssignmentContext::DeclarationStatement || m_bindingContext == AssignmentContext::ConstDeclarationStatement) - generator.liftTDZCheckIfPossible(var); + generator.emitMove(local.get(), value); return; } if (generator.isStrictMode()) generator.emitExpressionInfo(divotEnd(), divotStart(), divotEnd()); - RegisterID* scope = generator.emitResolveScope(nullptr, var); + RegisterID* scope = generator.emitResolveScope(generator.newTemporary(), m_boundProperty); generator.emitExpressionInfo(divotEnd(), divotStart(), divotEnd()); - if (m_bindingContext == AssignmentContext::AssignmentExpression) - generator.emitTDZCheckIfNecessary(var, nullptr, scope); - if (var.isReadOnly() && m_bindingContext != AssignmentContext::ConstDeclarationStatement) { - bool threwException = generator.emitReadOnlyExceptionIfNeeded(var); - if (threwException) - return; - } - generator.emitPutToScope(scope, var, value, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound); - generator.emitProfileType(value, var, divotStart(), divotEnd()); - if (m_bindingContext == AssignmentContext::DeclarationStatement || m_bindingContext == AssignmentContext::ConstDeclarationStatement) - generator.liftTDZCheckIfPossible(var); + generator.emitPutToScope(scope, m_boundProperty, value, generator.isStrictMode() ? ThrowIfNotFound : DoNotThrowIfNotFound); return; } |