#include "config.h"

#include "Nodes.h"

#include "NodeConstructors.h"

#include "BuiltinNames.h"

#include "BytecodeGenerator.h"

#include "CallFrame.h"

#include "Debugger.h"

#include "JIT.h"

#include "JSFunction.h"

#include "JSGeneratorFunction.h"

#include "JSGlobalObject.h"

#include "JSONObject.h"

#include "LabelScope.h"

#include "Lexer.h"

#include "JSCInlines.h"

#include "JSTemplateRegistryKey.h"

#include "Parser.h"

#include "PropertyNameArray.h"

#include "RegExpCache.h"

#include "RegExpObject.h"

#include "SamplingTool.h"

#include "StackAlignment.h"

#include "TemplateRegistryKey.h"

#include <wtf/Assertions.h>

#include <wtf/RefCountedLeakCounter.h>

#include <wtf/Threading.h>

using namespace WTF;

namespace JSC {

void ExpressionNode::emitBytecodeInConditionContext(BytecodeGenerator& generator, Label* trueTarget, Label* falseTarget, FallThroughMode fallThroughMode)

}

RegisterID* ThrowableExpressionData::emitThrowReferenceError(BytecodeGenerator& generator, const String& message)

{

generator.emitExpressionInfo(divot(), divotStart(), divotEnd());

generator.emitThrowReferenceError(message);

return generator.newTemporary();

}

void ConstantNode::emitBytecodeInConditionContext(BytecodeGenerator& generator, Label* trueTarget, Label* falseTarget, FallThroughMode fallThroughMode)

}

RegisterID* ConstantNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

if (dst == generator.ignoredResult())

return 0;

return generator.emitLoad(dst, jsValue(generator));

}

JSValue StringNode::jsValue(BytecodeGenerator& generator) const

{

return generator.addStringConstant(m_value);

}

RegisterID* NumberNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

if (dst == generator.ignoredResult())

return nullptr;

return generator.emitLoad(dst, jsValue(generator), isIntegerNode() ? SourceCodeRepresentation::Integer : SourceCodeRepresentation::Double);

}

RegisterID* RegExpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

if (dst == generator.ignoredResult())

return 0;

return generator.emitNewRegExp(generator.finalDestination(dst), RegExp::create(*generator.vm(), m_pattern.string(), regExpFlags(m_flags.string())));

}

RegisterID* ThisNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

if (generator.constructorKind() == ConstructorKind::Derived && generator.needsToUpdateArrowFunctionContext())

generator.emitLoadThisFromArrowFunctionLexicalEnvironment();

if (m_shouldAlwaysEmitTDZCheck || generator.constructorKind() == ConstructorKind::Derived || generator.isDerivedConstructorContext())

generator.emitTDZCheck(generator.thisRegister());

if (dst == generator.ignoredResult())

return 0;

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;

}

RegisterID* SuperNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

if (dst == generator.ignoredResult())

return 0;

if (generator.isDerivedConstructorContext())

return generator.emitGetById(generator.finalDestination(dst), generator.emitLoadDerivedConstructorFromArrowFunctionLexicalEnvironment(), generator.propertyNames().underscoreProto);

RegisterID callee;

callee.setIndex(JSStack::Callee);

return generator.emitGetById(generator.finalDestination(dst), &callee, generator.propertyNames().underscoreProto);

}

static RegisterID* emitHomeObjectForCallee(BytecodeGenerator& generator)

{

if (generator.isDerivedClassContext() || generator.isDerivedConstructorContext()) {

RegisterID* derivedConstructor = generator.emitLoadDerivedConstructorFromArrowFunctionLexicalEnvironment();

return generator.emitGetById(generator.newTemporary(), derivedConstructor, generator.propertyNames().homeObjectPrivateName);

}

RegisterID callee;

callee.setIndex(JSStack::Callee);

return generator.emitGetById(generator.newTemporary(), &callee, generator.propertyNames().homeObjectPrivateName);

}

static RegisterID* emitSuperBaseForCallee(BytecodeGenerator& generator)

{

RefPtr<RegisterID> homeObject = emitHomeObjectForCallee(generator);

return generator.emitGetById(generator.newTemporary(), homeObject.get(), generator.propertyNames().underscoreProto);

}

RegisterID* NewTargetNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

if (dst == generator.ignoredResult())

return nullptr;

return generator.moveToDestinationIfNeeded(dst, generator.newTarget());

}

bool ResolveNode::isPure(BytecodeGenerator& generator) const

{

return generator.variable(m_ident).offset().isStack();

}

RegisterID* ResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

Variable var = generator.variable(m_ident);

if (RegisterID* local = var.local()) {

generator.emitTDZCheckIfNecessary(var, local, nullptr);

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

}

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;

}

RegisterID* TemplateStringNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

if (dst == generator.ignoredResult())

return nullptr;

return generator.emitLoad(dst, JSValue(generator.addStringConstant(cooked())));

}

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

}

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

}

RegisterID* ArrayNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

// FIXME: Should we put all of this code into emitNewArray?

unsigned length = 0;

ElementNode* firstPutElement;

for (firstPutElement = m_element; firstPutElement; firstPutElement = firstPutElement->next()) {

if (firstPutElement->elision() || firstPutElement->value()->isSpreadExpression())

break;

++length;

}

if (!firstPutElement && !m_elision)

return generator.emitNewArray(generator.finalDestination(dst), m_element, length);

RefPtr<RegisterID> array = generator.emitNewArray(generator.tempDestination(dst), m_element, length);

ElementNode* n = firstPutElement;

for (; n; n = n->next()) {

if (n->value()->isSpreadExpression())

goto handleSpread;

RegisterID* value = generator.emitNode(n->value());

length += n->elision();

generator.emitPutByIndex(array.get(), length++, value);

}

if (m_elision) {

RegisterID* value = generator.emitLoad(0, jsNumber(m_elision + length));

generator.emitPutById(array.get(), generator.propertyNames().length, value);

}

return generator.moveToDestinationIfNeeded(dst, array.get());

handleSpread:

RefPtr<RegisterID> index = generator.emitLoad(generator.newTemporary(), jsNumber(length));

auto spreader = [array, index](BytecodeGenerator& generator, RegisterID* value)

{

generator.emitDirectPutByVal(array.get(), index.get(), value);

generator.emitInc(index.get());

};

for (; n; n = n->next()) {

if (n->elision())

generator.emitBinaryOp(op_add, index.get(), index.get(), generator.emitLoad(0, jsNumber(n->elision())), OperandTypes(ResultType::numberTypeIsInt32(), ResultType::numberTypeIsInt32()));

if (n->value()->isSpreadExpression()) {

SpreadExpressionNode* spread = static_cast<SpreadExpressionNode*>(n->value());

generator.emitEnumeration(spread, spread->expression(), spreader);

} else {

generator.emitDirectPutByVal(array.get(), index.get(), generator.emitNode(n->value()));

generator.emitInc(index.get());

}

}

if (m_elision) {

generator.emitBinaryOp(op_add, index.get(), index.get(), generator.emitLoad(0, jsNumber(m_elision)), OperandTypes(ResultType::numberTypeIsInt32(), ResultType::numberTypeIsInt32()));

generator.emitPutById(array.get(), generator.propertyNames().length, index.get());

}

return generator.moveToDestinationIfNeeded(dst, array.get());

}

bool ArrayNode::isSimpleArray() const

}

ArgumentListNode* ArrayNode::toArgumentList(ParserArena& parserArena, int lineNumber, int startPosition) const

{

ASSERT(!m_elision && !m_optional);

ElementNode* ptr = m_element;

if (!ptr)

return 0;

JSTokenLocation location;

location.line = lineNumber;

location.startOffset = startPosition;

ArgumentListNode* head = new (parserArena) 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());

}

return head;

}

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

}

static inline void emitPutHomeObject(BytecodeGenerator& generator, RegisterID* function, RegisterID* homeObject)

{

generator.emitPutById(function, generator.propertyNames().homeObjectPrivateName, homeObject);

}

RegisterID* PropertyListNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

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

// 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;

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)

continue;

// Duplicates are possible.

GetterSetterPair pair(node, static_cast<PropertyNode*>(nullptr));

GetterSetterMap::AddResult result = map.add(node->name()->impl(), pair);

if (!result.isNewEntry) {

if (result.iterator->value.first->m_type == node->m_type)

result.iterator->value.first = node;

else

result.iterator->value.second = node;

}

}

// Iterate over the remaining properties in the list.

for (; p; p = p->m_next) {

PropertyNode* node = p->m_node;

// Handle regular values.

if (node->m_type & PropertyNode::Constant) {

emitPutConstantProperty(generator, dst, *node);

continue;

}

RefPtr<RegisterID> value = generator.emitNode(node->m_assign);

bool isClassProperty = node->needsSuperBinding();

if (isClassProperty)

emitPutHomeObject(generator, value.get(), dst);

unsigned attribute = isClassProperty ? (Accessor | DontEnum) : Accessor;

ASSERT(node->m_type & (PropertyNode::Getter | PropertyNode::Setter));

// This is a get/set property which may be overridden by a computed property later.

if (hasComputedProperty) {

// Computed accessors.

if (node->m_type & PropertyNode::Computed) {

RefPtr<RegisterID> propertyName = generator.emitNode(node->m_expression);

if (node->m_type & PropertyNode::Getter)

generator.emitPutGetterByVal(dst, propertyName.get(), attribute, value.get());

else

generator.emitPutSetterByVal(dst, propertyName.get(), attribute, value.get());

continue;

}

if (node->m_type & PropertyNode::Getter)

generator.emitPutGetterById(dst, *node->name(), attribute, value.get());

else

generator.emitPutSetterById(dst, *node->name(), attribute, value.get());

continue;

}

// This is a get/set property pair.

GetterSetterMap::iterator it = map.find(node->name()->impl());

ASSERT(it != map.end());

GetterSetterPair& pair = it->value;

// Was this already generated as a part of its partner?

if (pair.second == node)

continue;

// Generate the paired node now.

RefPtr<RegisterID> getterReg;

RefPtr<RegisterID> setterReg;

RegisterID* secondReg = nullptr;

if (node->m_type & PropertyNode::Getter) {

getterReg = value;

if (pair.second) {

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

setterReg = value;

if (pair.second) {

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

generator.emitPutGetterSetter(dst, *node->name(), attribute, getterReg.get(), setterReg.get());

}

}

return dst;

}

void PropertyListNode::emitPutConstantProperty(BytecodeGenerator& generator, RegisterID* newObj, PropertyNode& node)

}

static bool isNonIndexStringElement(ExpressionNode& element)

{

return element.isString() && !parseIndex(static_cast<StringNode&>(element).value());

}

RegisterID* BracketAccessorNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

if (m_base->isSuperNode()) {

// FIXME: Should we generate the profiler info?

if (isNonIndexStringElement(*m_subscript)) {

const Identifier& id = static_cast<StringNode*>(m_subscript)->value();

return generator.emitGetById(generator.finalDestination(dst), emitSuperBaseForCallee(generator), id);

}

return generator.emitGetByVal(generator.finalDestination(dst), emitSuperBaseForCallee(generator), generator.emitNode(m_subscript));

}

RegisterID* ret;

RegisterID* finalDest = generator.finalDestination(dst);

if (isNonIndexStringElement(*m_subscript)) {

RefPtr<RegisterID> base = generator.emitNode(m_base);

ret = generator.emitGetById(finalDest, base.get(), static_cast<StringNode*>(m_subscript)->value());

} else {

RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base, m_subscriptHasAssignments, m_subscript->isPure(generator));

RegisterID* property = generator.emitNode(m_subscript);

ret = generator.emitGetByVal(finalDest, base.get(), property);

}

generator.emitExpressionInfo(divot(), divotStart(), divotEnd());

generator.emitProfileType(finalDest, divotStart(), divotEnd());

return ret;

}

RegisterID* DotAccessorNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

RefPtr<RegisterID> base = m_base->isSuperNode() ? emitSuperBaseForCallee(generator) : 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;

}

RegisterID* ArgumentListNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

ASSERT(m_expr);

return generator.emitNode(dst, m_expr);

}

RegisterID* NewExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

ExpectedFunction expectedFunction;

if (m_expr->isResolveNode())

expectedFunction = generator.expectedFunctionForIdentifier(static_cast<ResolveNode*>(m_expr)->identifier());

else

expectedFunction = NoExpectedFunction;

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

}

CallArguments::CallArguments(BytecodeGenerator& generator, ArgumentsNode* argumentsNode, unsigned additionalArguments)

}

RegisterID* EvalFunctionCallNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

// We need try to load 'this' before call eval in constructor, because 'this' can created by 'super' in some of the arrow function

// var A = class A {

// constructor () { this.id = 'A'; }

// }

//

// var B = class B extend A {

// constructor () {

// var arrow = () => super();

// arrow();

// eval("this.id = 'B'");

// }

// }

if (generator.constructorKind() == ConstructorKind::Derived && generator.needsToUpdateArrowFunctionContext())

generator.emitLoadThisFromArrowFunctionLexicalEnvironment();

Variable var = generator.variable(generator.propertyNames().eval);

if (RegisterID* local = var.local()) {

RefPtr<RegisterID> func = generator.emitMove(generator.tempDestination(dst), local);

CallArguments callArguments(generator, m_args);

generator.emitLoad(callArguments.thisRegister(), jsUndefined());

return generator.emitCallEval(generator.finalDestination(dst, func.get()), func.get(), callArguments, divot(), divotStart(), divotEnd());

}

RefPtr<RegisterID> func = generator.newTemporary();

CallArguments callArguments(generator, m_args);

JSTextPosition newDivot = divotStart() + 4;

generator.emitExpressionInfo(newDivot, divotStart(), newDivot);

generator.moveToDestinationIfNeeded(

callArguments.thisRegister(),

generator.emitResolveScope(callArguments.thisRegister(), var));

generator.emitGetFromScope(func.get(), callArguments.thisRegister(), var, ThrowIfNotFound);

return generator.emitCallEval(generator.finalDestination(dst, func.get()), func.get(), callArguments, divot(), divotStart(), divotEnd());

}

RegisterID* FunctionCallValueNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

RefPtr<RegisterID> func = generator.emitNode(m_expr);

RefPtr<RegisterID> returnValue = generator.finalDestination(dst, func.get());

CallArguments callArguments(generator, m_args);

if (m_expr->isSuperNode()) {

ASSERT(generator.isConstructor() || generator.derivedContextType() == DerivedContextType::DerivedConstructorContext);

ASSERT(generator.constructorKind() == ConstructorKind::Derived || generator.derivedContextType() == DerivedContextType::DerivedConstructorContext);

generator.emitMove(callArguments.thisRegister(), generator.newTarget());

RegisterID* ret = generator.emitConstruct(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());

generator.emitMove(generator.thisRegister(), ret);

bool isConstructorKindDerived = generator.constructorKind() == ConstructorKind::Derived;

if (generator.isDerivedConstructorContext() || (isConstructorKindDerived && generator.needsToUpdateArrowFunctionContext()))

generator.emitPutThisToArrowFunctionContextScope();

return ret;

}

generator.emitLoad(callArguments.thisRegister(), jsUndefined());

RegisterID* ret = generator.emitCallInTailPosition(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());

generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());

return ret;

}

RegisterID* FunctionCallResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

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

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.emitCallInTailPosition(returnValue.get(), func.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());

generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());

return ret;

}

RefPtr<RegisterID> func = generator.newTemporary();

RefPtr<RegisterID> returnValue = generator.finalDestination(dst, func.get());

CallArguments callArguments(generator, m_args);

JSTextPosition newDivot = divotStart() + m_ident.length();

generator.emitExpressionInfo(newDivot, divotStart(), newDivot);

generator.moveToDestinationIfNeeded(

callArguments.thisRegister(),

generator.emitResolveScope(callArguments.thisRegister(), var));

generator.emitGetFromScope(func.get(), callArguments.thisRegister(), var, ThrowIfNotFound);

generator.emitTDZCheckIfNecessary(var, func.get(), nullptr);

RegisterID* ret = generator.emitCallInTailPosition(returnValue.get(), func.get(), expectedFunction, callArguments, divot(), divotStart(), divotEnd());

generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());

return ret;

}

RegisterID* BytecodeIntrinsicNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

return (this->*m_emitter)(generator, dst);

}

RegisterID* BytecodeIntrinsicNode::emit_intrinsic_assert(BytecodeGenerator& generator, RegisterID* dst)

{

#ifndef NDEBUG

ArgumentListNode* node = m_args->m_listNode;

RefPtr<RegisterID> condition = generator.emitNode(node);

generator.emitAssert(condition.get(), node->firstLine());

return dst;

#else

UNUSED_PARAM(generator);

return dst;

#endif

}

RegisterID* BytecodeIntrinsicNode::emit_intrinsic_putByValDirect(BytecodeGenerator& generator, RegisterID* dst)

{

ArgumentListNode* node = m_args->m_listNode;

RefPtr<RegisterID> base = generator.emitNode(node);

node = node->m_next;

RefPtr<RegisterID> index = generator.emitNode(node);

node = node->m_next;

RefPtr<RegisterID> value = generator.emitNode(node);

ASSERT(!node->m_next);

return generator.moveToDestinationIfNeeded(dst, generator.emitDirectPutByVal(base.get(), index.get(), value.get()));

}

RegisterID* BytecodeIntrinsicNode::emit_intrinsic_toString(BytecodeGenerator& generator, RegisterID* dst)

{

ArgumentListNode* node = m_args->m_listNode;

RefPtr<RegisterID> src = generator.emitNode(node);

ASSERT(!node->m_next);

return generator.moveToDestinationIfNeeded(dst, generator.emitToString(generator.tempDestination(dst), src.get()));

}

RegisterID* BytecodeIntrinsicNode::emit_intrinsic_isObject(BytecodeGenerator& generator, RegisterID* dst)

{

ArgumentListNode* node = m_args->m_listNode;

RefPtr<RegisterID> src = generator.emitNode(node);

ASSERT(!node->m_next);

return generator.moveToDestinationIfNeeded(dst, generator.emitIsObject(generator.tempDestination(dst), src.get()));

}

#define JSC_DECLARE_BYTECODE_INTRINSIC_CONSTANT_GENERATORS(name) \

RegisterID* BytecodeIntrinsicNode::emit_intrinsic_##name(BytecodeGenerator& generator, RegisterID* dst) \

{ \

ASSERT(!m_args); \

ASSERT(type() == Type::Constant); \

if (dst == generator.ignoredResult()) \

return nullptr; \

return generator.emitLoad(dst, generator.vm()->bytecodeIntrinsicRegistry().name##Value(generator)); \

}

JSC_COMMON_BYTECODE_INTRINSIC_CONSTANTS_EACH_NAME(JSC_DECLARE_BYTECODE_INTRINSIC_CONSTANT_GENERATORS)

#undef JSC_DECLARE_BYTECODE_INTRINSIC_CONSTANT_GENERATORS

RegisterID* FunctionCallBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

bool baseIsSuper = m_base->isSuperNode();

bool subscriptIsNonIndexString = isNonIndexStringElement(*m_subscript);

RefPtr<RegisterID> base;

if (baseIsSuper)

base = emitSuperBaseForCallee(generator);

else {

if (subscriptIsNonIndexString)

base = generator.emitNode(m_base);

else

base = generator.emitNodeForLeftHandSide(m_base, m_subscriptHasAssignments, m_subscript->isPure(generator));

}

RefPtr<RegisterID> function;

if (subscriptIsNonIndexString) {

generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());

function = generator.emitGetById(generator.tempDestination(dst), base.get(), static_cast<StringNode*>(m_subscript)->value());

} else {

RefPtr<RegisterID> property = generator.emitNode(m_subscript);

generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());

function = generator.emitGetByVal(generator.tempDestination(dst), base.get(), property.get());

}

RefPtr<RegisterID> returnValue = generator.finalDestination(dst, function.get());

CallArguments callArguments(generator, m_args);

if (baseIsSuper)

generator.emitMove(callArguments.thisRegister(), generator.thisRegister());

else

generator.emitMove(callArguments.thisRegister(), base.get());

RegisterID* ret = generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());

generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());

return ret;

}

RegisterID* FunctionCallDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

RefPtr<RegisterID> function = generator.tempDestination(dst);

RefPtr<RegisterID> returnValue = generator.finalDestination(dst, function.get());

CallArguments callArguments(generator, m_args);

bool baseIsSuper = m_base->isSuperNode();

if (baseIsSuper) {

generator.emitTDZCheck(generator.thisRegister());

generator.emitMove(callArguments.thisRegister(), generator.thisRegister());

} else

generator.emitNode(callArguments.thisRegister(), m_base);

generator.emitExpressionInfo(subexpressionDivot(), subexpressionStart(), subexpressionEnd());

generator.emitGetById(function.get(), baseIsSuper ? emitSuperBaseForCallee(generator) : callArguments.thisRegister(), m_ident);

RegisterID* ret = generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());

generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());

return ret;

}

RegisterID* CallFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

RefPtr<Label> realCall = generator.newLabel();

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

{

if (m_args->m_listNode && m_args->m_listNode->m_expr && m_args->m_listNode->m_expr->isSpreadExpression()) {

RefPtr<RegisterID> profileHookRegister;

if (generator.shouldEmitProfileHooks())

profileHookRegister = generator.newTemporary();

SpreadExpressionNode* spread = static_cast<SpreadExpressionNode*>(m_args->m_listNode->m_expr);

ExpressionNode* subject = spread->expression();

RefPtr<RegisterID> argumentsRegister;

argumentsRegister = generator.emitNode(subject);

generator.emitExpressionInfo(spread->divot(), spread->divotStart(), spread->divotEnd());

RefPtr<RegisterID> thisRegister = generator.emitGetByVal(generator.newTemporary(), argumentsRegister.get(), generator.emitLoad(0, jsNumber(0)));

generator.emitCallVarargsInTailPosition(returnValue.get(), base.get(), thisRegister.get(), argumentsRegister.get(), generator.newTemporary(), 1, profileHookRegister.get(), divot(), divotStart(), divotEnd());

} else if (m_args->m_listNode && m_args->m_listNode->m_expr) {

ArgumentListNode* oldList = m_args->m_listNode;

m_args->m_listNode = m_args->m_listNode->m_next;

RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());

CallArguments callArguments(generator, m_args);

generator.emitNode(callArguments.thisRegister(), oldList->m_expr);

generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());

m_args->m_listNode = oldList;

} else {

RefPtr<RegisterID> realFunction = generator.emitMove(generator.tempDestination(dst), base.get());

CallArguments callArguments(generator, m_args);

generator.emitLoad(callArguments.thisRegister(), jsUndefined());

generator.emitCallInTailPosition(returnValue.get(), realFunction.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());

}

}

if (emitCallCheck) {

generator.emitJump(end.get());

generator.emitLabel(realCall.get());

{

CallArguments callArguments(generator, m_args);

generator.emitMove(callArguments.thisRegister(), base.get());

generator.emitCallInTailPosition(returnValue.get(), function.get(), NoExpectedFunction, callArguments, divot(), divotStart(), divotEnd());

}

generator.emitLabel(end.get());

}

generator.emitProfileType(returnValue.get(), divotStart(), divotEnd());

return returnValue.get();

}

static bool areTrivialApplyArguments(ArgumentsNode* args)

}

RegisterID* ApplyFunctionCallDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)

{

// A few simple cases can be trivially handled as ordinary function calls.

// function.apply(), function.apply(arg) -> identical to function.call

// function.apply(thisArg, [arg0, arg1, ...]) -> can be trivially coerced into function.call(thisArg, arg0, arg1, ...) and saves object allocation

bool mayBeCall = areTrivialApplyArguments(m_args);