Revert "Revert "Upgrade to 5.0.71.48"" DO NOT MERGE
This reverts commit f2e3994fa5148cc3d9946666f0b0596290192b0e,
and updates the x64 makefile properly so it doesn't break that
build.
FPIIM-449
Change-Id: Ib83e35bfbae6af627451c926a9650ec57c045605
(cherry picked from commit 109988c7ccb6f3fd1a58574fa3dfb88beaef6632)
diff --git a/src/interpreter/bytecode-generator.cc b/src/interpreter/bytecode-generator.cc
index 959e155..6f4dc27 100644
--- a/src/interpreter/bytecode-generator.cc
+++ b/src/interpreter/bytecode-generator.cc
@@ -27,19 +27,26 @@
: generator_(generator),
scope_(scope),
outer_(generator_->execution_context()),
- register_(generator_->NextContextRegister()),
+ register_(Register::current_context()),
depth_(0),
should_pop_context_(should_pop_context) {
if (outer_) {
depth_ = outer_->depth_ + 1;
- generator_->builder()->PushContext(register_);
+
+ // Push the outer context into a new context register.
+ Register outer_context_reg(builder()->first_context_register().index() +
+ outer_->depth_);
+ outer_->set_register(outer_context_reg);
+ generator_->builder()->PushContext(outer_context_reg);
}
generator_->set_execution_context(this);
}
~ContextScope() {
if (outer_ && should_pop_context_) {
+ DCHECK_EQ(register_.index(), Register::current_context().index());
generator_->builder()->PopContext(outer_->reg());
+ outer_->set_register(register_);
}
generator_->set_execution_context(outer_);
}
@@ -67,6 +74,10 @@
Register reg() const { return register_; }
private:
+ const BytecodeArrayBuilder* builder() const { return generator_->builder(); }
+
+ void set_register(Register reg) { register_ = reg; }
+
BytecodeGenerator* generator_;
Scope* scope_;
ContextScope* outer_;
@@ -81,30 +92,141 @@
class BytecodeGenerator::ControlScope BASE_EMBEDDED {
public:
explicit ControlScope(BytecodeGenerator* generator)
- : generator_(generator), outer_(generator->execution_control()) {
+ : generator_(generator), outer_(generator->execution_control()),
+ context_(generator->execution_context()) {
generator_->set_execution_control(this);
}
virtual ~ControlScope() { generator_->set_execution_control(outer()); }
void Break(Statement* stmt) { PerformCommand(CMD_BREAK, stmt); }
void Continue(Statement* stmt) { PerformCommand(CMD_CONTINUE, stmt); }
+ void ReturnAccumulator() { PerformCommand(CMD_RETURN, nullptr); }
+ void ReThrowAccumulator() { PerformCommand(CMD_RETHROW, nullptr); }
+
+ class DeferredCommands;
protected:
- enum Command { CMD_BREAK, CMD_CONTINUE };
+ enum Command { CMD_BREAK, CMD_CONTINUE, CMD_RETURN, CMD_RETHROW };
void PerformCommand(Command command, Statement* statement);
virtual bool Execute(Command command, Statement* statement) = 0;
BytecodeGenerator* generator() const { return generator_; }
ControlScope* outer() const { return outer_; }
+ ContextScope* context() const { return context_; }
private:
BytecodeGenerator* generator_;
ControlScope* outer_;
+ ContextScope* context_;
DISALLOW_COPY_AND_ASSIGN(ControlScope);
};
+// Helper class for a try-finally control scope. It can record intercepted
+// control-flow commands that cause entry into a finally-block, and re-apply
+// them after again leaving that block. Special tokens are used to identify
+// paths going through the finally-block to dispatch after leaving the block.
+class BytecodeGenerator::ControlScope::DeferredCommands final {
+ public:
+ DeferredCommands(BytecodeGenerator* generator, Register token_register,
+ Register result_register)
+ : generator_(generator),
+ deferred_(generator->zone()),
+ token_register_(token_register),
+ result_register_(result_register) {}
+
+ // One recorded control-flow command.
+ struct Entry {
+ Command command; // The command type being applied on this path.
+ Statement* statement; // The target statement for the command or {nullptr}.
+ int token; // A token identifying this particular path.
+ };
+
+ // Records a control-flow command while entering the finally-block. This also
+ // generates a new dispatch token that identifies one particular path. This
+ // expects the result to be in the accumulator.
+ void RecordCommand(Command command, Statement* statement) {
+ int token = static_cast<int>(deferred_.size());
+ deferred_.push_back({command, statement, token});
+
+ builder()->StoreAccumulatorInRegister(result_register_);
+ builder()->LoadLiteral(Smi::FromInt(token));
+ builder()->StoreAccumulatorInRegister(token_register_);
+ }
+
+ // Records the dispatch token to be used to identify the re-throw path when
+ // the finally-block has been entered through the exception handler. This
+ // expects the exception to be in the accumulator.
+ void RecordHandlerReThrowPath() {
+ // The accumulator contains the exception object.
+ RecordCommand(CMD_RETHROW, nullptr);
+ }
+
+ // Records the dispatch token to be used to identify the implicit fall-through
+ // path at the end of a try-block into the corresponding finally-block.
+ void RecordFallThroughPath() {
+ builder()->LoadLiteral(Smi::FromInt(-1));
+ builder()->StoreAccumulatorInRegister(token_register_);
+ }
+
+ // Applies all recorded control-flow commands after the finally-block again.
+ // This generates a dynamic dispatch on the token from the entry point.
+ void ApplyDeferredCommands() {
+ // The fall-through path is covered by the default case, hence +1 here.
+ SwitchBuilder dispatch(builder(), static_cast<int>(deferred_.size() + 1));
+ for (size_t i = 0; i < deferred_.size(); ++i) {
+ Entry& entry = deferred_[i];
+ builder()->LoadLiteral(Smi::FromInt(entry.token));
+ builder()->CompareOperation(Token::EQ_STRICT, token_register_);
+ dispatch.Case(static_cast<int>(i));
+ }
+ dispatch.DefaultAt(static_cast<int>(deferred_.size()));
+ for (size_t i = 0; i < deferred_.size(); ++i) {
+ Entry& entry = deferred_[i];
+ dispatch.SetCaseTarget(static_cast<int>(i));
+ builder()->LoadAccumulatorWithRegister(result_register_);
+ execution_control()->PerformCommand(entry.command, entry.statement);
+ }
+ dispatch.SetCaseTarget(static_cast<int>(deferred_.size()));
+ }
+
+ BytecodeArrayBuilder* builder() { return generator_->builder(); }
+ ControlScope* execution_control() { return generator_->execution_control(); }
+
+ private:
+ BytecodeGenerator* generator_;
+ ZoneVector<Entry> deferred_;
+ Register token_register_;
+ Register result_register_;
+};
+
+
+// Scoped class for dealing with control flow reaching the function level.
+class BytecodeGenerator::ControlScopeForTopLevel final
+ : public BytecodeGenerator::ControlScope {
+ public:
+ explicit ControlScopeForTopLevel(BytecodeGenerator* generator)
+ : ControlScope(generator) {}
+
+ protected:
+ bool Execute(Command command, Statement* statement) override {
+ switch (command) {
+ case CMD_BREAK:
+ case CMD_CONTINUE:
+ break;
+ case CMD_RETURN:
+ generator()->builder()->Return();
+ return true;
+ case CMD_RETHROW:
+ generator()->builder()->ReThrow();
+ return true;
+ }
+ return false;
+ }
+};
+
+
// Scoped class for enabling break inside blocks and switch blocks.
class BytecodeGenerator::ControlScopeForBreakable final
: public BytecodeGenerator::ControlScope {
@@ -117,13 +239,15 @@
control_builder_(control_builder) {}
protected:
- virtual bool Execute(Command command, Statement* statement) {
+ bool Execute(Command command, Statement* statement) override {
if (statement != statement_) return false;
switch (command) {
case CMD_BREAK:
control_builder_->Break();
return true;
case CMD_CONTINUE:
+ case CMD_RETURN:
+ case CMD_RETHROW:
break;
}
return false;
@@ -148,7 +272,7 @@
loop_builder_(loop_builder) {}
protected:
- virtual bool Execute(Command command, Statement* statement) {
+ bool Execute(Command command, Statement* statement) override {
if (statement != statement_) return false;
switch (command) {
case CMD_BREAK:
@@ -157,6 +281,9 @@
case CMD_CONTINUE:
loop_builder_->Continue();
return true;
+ case CMD_RETURN:
+ case CMD_RETHROW:
+ break;
}
return false;
}
@@ -167,12 +294,84 @@
};
+// Scoped class for enabling 'throw' in try-catch constructs.
+class BytecodeGenerator::ControlScopeForTryCatch final
+ : public BytecodeGenerator::ControlScope {
+ public:
+ ControlScopeForTryCatch(BytecodeGenerator* generator,
+ TryCatchBuilder* try_catch_builder)
+ : ControlScope(generator) {
+ generator->try_catch_nesting_level_++;
+ }
+ virtual ~ControlScopeForTryCatch() {
+ generator()->try_catch_nesting_level_--;
+ }
+
+ protected:
+ bool Execute(Command command, Statement* statement) override {
+ switch (command) {
+ case CMD_BREAK:
+ case CMD_CONTINUE:
+ case CMD_RETURN:
+ break;
+ case CMD_RETHROW:
+ generator()->builder()->ReThrow();
+ return true;
+ }
+ return false;
+ }
+};
+
+
+// Scoped class for enabling control flow through try-finally constructs.
+class BytecodeGenerator::ControlScopeForTryFinally final
+ : public BytecodeGenerator::ControlScope {
+ public:
+ ControlScopeForTryFinally(BytecodeGenerator* generator,
+ TryFinallyBuilder* try_finally_builder,
+ DeferredCommands* commands)
+ : ControlScope(generator),
+ try_finally_builder_(try_finally_builder),
+ commands_(commands) {
+ generator->try_finally_nesting_level_++;
+ }
+ virtual ~ControlScopeForTryFinally() {
+ generator()->try_finally_nesting_level_--;
+ }
+
+ protected:
+ bool Execute(Command command, Statement* statement) override {
+ switch (command) {
+ case CMD_BREAK:
+ case CMD_CONTINUE:
+ case CMD_RETURN:
+ case CMD_RETHROW:
+ commands_->RecordCommand(command, statement);
+ try_finally_builder_->LeaveTry();
+ return true;
+ }
+ return false;
+ }
+
+ private:
+ TryFinallyBuilder* try_finally_builder_;
+ DeferredCommands* commands_;
+};
+
+
void BytecodeGenerator::ControlScope::PerformCommand(Command command,
Statement* statement) {
ControlScope* current = this;
+ ContextScope* context = this->context();
do {
- if (current->Execute(command, statement)) return;
+ if (current->Execute(command, statement)) { return; }
current = current->outer();
+ if (current->context() != context) {
+ // Pop context to the expected depth.
+ // TODO(rmcilroy): Only emit a single context pop.
+ generator()->builder()->PopContext(current->context()->reg());
+ context = current->context();
+ }
} while (current != nullptr);
UNREACHABLE();
}
@@ -183,7 +382,8 @@
explicit RegisterAllocationScope(BytecodeGenerator* generator)
: generator_(generator),
outer_(generator->register_allocator()),
- allocator_(builder()) {
+ allocator_(builder()->zone(),
+ builder()->temporary_register_allocator()) {
generator_->set_register_allocator(this);
}
@@ -205,11 +405,11 @@
// walk the full context chain and compute the list of consecutive
// reservations in the innerscopes.
UNIMPLEMENTED();
- return Register(-1);
+ return Register::invalid_value();
}
}
- void PrepareForConsecutiveAllocations(size_t count) {
+ void PrepareForConsecutiveAllocations(int count) {
allocator_.PrepareForConsecutiveAllocations(count);
}
@@ -330,7 +530,7 @@
virtual void SetResultInRegister(Register reg) {
DCHECK(builder()->RegisterIsParameterOrLocal(reg) ||
- (builder()->RegisterIsTemporary(reg) &&
+ (builder()->TemporaryRegisterIsLive(reg) &&
!allocator()->RegisterIsAllocatedInThisScope(reg)));
result_register_ = reg;
set_result_identified();
@@ -342,32 +542,36 @@
Register result_register_;
};
-
BytecodeGenerator::BytecodeGenerator(Isolate* isolate, Zone* zone)
: isolate_(isolate),
zone_(zone),
- builder_(isolate, zone),
+ builder_(nullptr),
info_(nullptr),
scope_(nullptr),
globals_(0, zone),
execution_control_(nullptr),
execution_context_(nullptr),
execution_result_(nullptr),
- register_allocator_(nullptr) {
+ register_allocator_(nullptr),
+ try_catch_nesting_level_(0),
+ try_finally_nesting_level_(0) {
InitializeAstVisitor(isolate);
}
-
Handle<BytecodeArray> BytecodeGenerator::MakeBytecode(CompilationInfo* info) {
set_info(info);
set_scope(info->scope());
+ // Initialize bytecode array builder.
+ set_builder(new (zone()) BytecodeArrayBuilder(
+ isolate(), zone(), info->num_parameters_including_this(),
+ scope()->MaxNestedContextChainLength(), scope()->num_stack_slots()));
+
// Initialize the incoming context.
ContextScope incoming_context(this, scope(), false);
- builder()->set_parameter_count(info->num_parameters_including_this());
- builder()->set_locals_count(scope()->num_stack_slots());
- builder()->set_context_count(scope()->MaxNestedContextChainLength());
+ // Initialize control scope.
+ ControlScopeForTopLevel control(this);
// Build function context only if there are context allocated variables.
if (scope()->NeedsContext()) {
@@ -380,9 +584,10 @@
MakeBytecodeBody();
}
+ builder()->EnsureReturn(info->literal());
set_scope(nullptr);
set_info(nullptr);
- return builder_.ToBytecodeArray();
+ return builder()->ToBytecodeArray();
}
@@ -390,11 +595,10 @@
// Build the arguments object if it is used.
VisitArgumentsObject(scope()->arguments());
- // TODO(mythria): Build rest arguments array if it is used.
+ // Build rest arguments array if it is used.
int rest_index;
- if (scope()->rest_parameter(&rest_index)) {
- UNIMPLEMENTED();
- }
+ Variable* rest_parameter = scope()->rest_parameter(&rest_index);
+ VisitRestArgumentsArray(rest_parameter);
// Build assignment to {.this_function} variable if it is used.
VisitThisFunctionVariable(scope()->this_function_var());
@@ -409,37 +613,40 @@
// Visit illegal re-declaration and bail out if it exists.
if (scope()->HasIllegalRedeclaration()) {
- Visit(scope()->GetIllegalRedeclaration());
+ VisitForEffect(scope()->GetIllegalRedeclaration());
return;
}
// Visit declarations within the function scope.
VisitDeclarations(scope()->declarations());
+ // Perform a stack-check before the body.
+ builder()->StackCheck();
+
// Visit statements in the function body.
VisitStatements(info()->literal()->body());
}
void BytecodeGenerator::VisitBlock(Block* stmt) {
- BlockBuilder block_builder(this->builder());
- ControlScopeForBreakable execution_control(this, stmt, &block_builder);
-
- if (stmt->scope() == NULL) {
- // Visit statements in the same scope, no declarations.
- VisitStatements(stmt->statements());
+ // Visit declarations and statements.
+ if (stmt->scope() != nullptr && stmt->scope()->NeedsContext()) {
+ VisitNewLocalBlockContext(stmt->scope());
+ ContextScope scope(this, stmt->scope());
+ VisitBlockDeclarationsAndStatements(stmt);
} else {
- // Visit declarations and statements in a block scope.
- if (stmt->scope()->NeedsContext()) {
- VisitNewLocalBlockContext(stmt->scope());
- ContextScope scope(this, stmt->scope());
- VisitDeclarations(stmt->scope()->declarations());
- VisitStatements(stmt->statements());
- } else {
- VisitDeclarations(stmt->scope()->declarations());
- VisitStatements(stmt->statements());
- }
+ VisitBlockDeclarationsAndStatements(stmt);
}
+}
+
+
+void BytecodeGenerator::VisitBlockDeclarationsAndStatements(Block* stmt) {
+ BlockBuilder block_builder(builder());
+ ControlScopeForBreakable execution_control(this, stmt, &block_builder);
+ if (stmt->scope() != nullptr) {
+ VisitDeclarations(stmt->scope()->declarations());
+ }
+ VisitStatements(stmt->statements());
if (stmt->labels() != nullptr) block_builder.EndBlock();
}
@@ -480,9 +687,31 @@
variable->index());
}
break;
- case VariableLocation::LOOKUP:
- UNIMPLEMENTED();
+ case VariableLocation::LOOKUP: {
+ DCHECK(IsDeclaredVariableMode(mode));
+
+ register_allocator()->PrepareForConsecutiveAllocations(3);
+ Register name = register_allocator()->NextConsecutiveRegister();
+ Register init_value = register_allocator()->NextConsecutiveRegister();
+ Register attributes = register_allocator()->NextConsecutiveRegister();
+
+ builder()->LoadLiteral(variable->name()).StoreAccumulatorInRegister(name);
+ if (hole_init) {
+ builder()->LoadTheHole().StoreAccumulatorInRegister(init_value);
+ } else {
+ // For variables, we must not use an initial value (such as 'undefined')
+ // because we may have a (legal) redeclaration and we must not destroy
+ // the current value.
+ builder()
+ ->LoadLiteral(Smi::FromInt(0))
+ .StoreAccumulatorInRegister(init_value);
+ }
+ builder()
+ ->LoadLiteral(Smi::FromInt(variable->DeclarationPropertyAttributes()))
+ .StoreAccumulatorInRegister(attributes)
+ .CallRuntime(Runtime::kDeclareLookupSlot, name, 3);
break;
+ }
}
}
@@ -503,7 +732,10 @@
case VariableLocation::PARAMETER:
case VariableLocation::LOCAL: {
VisitForAccumulatorValue(decl->fun());
- VisitVariableAssignment(variable, FeedbackVectorSlot::Invalid());
+ DCHECK(variable->mode() == LET || variable->mode() == VAR ||
+ variable->mode() == CONST);
+ VisitVariableAssignment(variable, Token::INIT,
+ FeedbackVectorSlot::Invalid());
break;
}
case VariableLocation::CONTEXT: {
@@ -513,8 +745,20 @@
variable->index());
break;
}
- case VariableLocation::LOOKUP:
- UNIMPLEMENTED();
+ case VariableLocation::LOOKUP: {
+ register_allocator()->PrepareForConsecutiveAllocations(3);
+ Register name = register_allocator()->NextConsecutiveRegister();
+ Register literal = register_allocator()->NextConsecutiveRegister();
+ Register attributes = register_allocator()->NextConsecutiveRegister();
+ builder()->LoadLiteral(variable->name()).StoreAccumulatorInRegister(name);
+
+ VisitForAccumulatorValue(decl->fun());
+ builder()
+ ->StoreAccumulatorInRegister(literal)
+ .LoadLiteral(Smi::FromInt(variable->DeclarationPropertyAttributes()))
+ .StoreAccumulatorInRegister(attributes)
+ .CallRuntime(Runtime::kDeclareLookupSlot, name, 3);
+ }
}
}
@@ -533,7 +777,10 @@
ZoneList<Declaration*>* declarations) {
RegisterAllocationScope register_scope(this);
DCHECK(globals()->empty());
- AstVisitor::VisitDeclarations(declarations);
+ for (int i = 0; i < declarations->length(); i++) {
+ RegisterAllocationScope register_scope(this);
+ Visit(declarations->at(i));
+ }
if (globals()->empty()) return;
int array_index = 0;
Handle<FixedArray> data = isolate()->factory()->NewFixedArray(
@@ -569,6 +816,7 @@
void BytecodeGenerator::VisitExpressionStatement(ExpressionStatement* stmt) {
+ builder()->SetStatementPosition(stmt);
VisitForEffect(stmt->expression());
}
@@ -624,12 +872,16 @@
void BytecodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
VisitForAccumulatorValue(stmt->expression());
- builder()->Return();
+ builder()->SetStatementPosition(stmt);
+ execution_control()->ReturnAccumulator();
}
void BytecodeGenerator::VisitWithStatement(WithStatement* stmt) {
- UNIMPLEMENTED();
+ VisitForAccumulatorValue(stmt->expression());
+ builder()->CastAccumulatorToJSObject();
+ VisitNewLocalWithContext();
+ VisitInScope(stmt->statement(), stmt->scope());
}
@@ -657,8 +909,7 @@
// Perform label comparison as if via '===' with tag.
VisitForAccumulatorValue(clause->label());
- builder()->CompareOperation(Token::Value::EQ_STRICT, tag,
- language_mode_strength());
+ builder()->CompareOperation(Token::Value::EQ_STRICT, tag);
switch_builder.Case(i);
}
@@ -688,20 +939,25 @@
UNREACHABLE();
}
+void BytecodeGenerator::VisitIterationBody(IterationStatement* stmt,
+ LoopBuilder* loop_builder) {
+ ControlScopeForIteration execution_control(this, stmt, loop_builder);
+ builder()->StackCheck();
+ Visit(stmt->body());
+}
void BytecodeGenerator::VisitDoWhileStatement(DoWhileStatement* stmt) {
LoopBuilder loop_builder(builder());
- ControlScopeForIteration execution_control(this, stmt, &loop_builder);
loop_builder.LoopHeader();
if (stmt->cond()->ToBooleanIsFalse()) {
- Visit(stmt->body());
+ VisitIterationBody(stmt, &loop_builder);
loop_builder.Condition();
} else if (stmt->cond()->ToBooleanIsTrue()) {
loop_builder.Condition();
- Visit(stmt->body());
+ VisitIterationBody(stmt, &loop_builder);
loop_builder.JumpToHeader();
} else {
- Visit(stmt->body());
+ VisitIterationBody(stmt, &loop_builder);
loop_builder.Condition();
VisitForAccumulatorValue(stmt->cond());
loop_builder.JumpToHeaderIfTrue();
@@ -709,7 +965,6 @@
loop_builder.EndLoop();
}
-
void BytecodeGenerator::VisitWhileStatement(WhileStatement* stmt) {
if (stmt->cond()->ToBooleanIsFalse()) {
// If the condition is false there is no need to generate the loop.
@@ -717,14 +972,13 @@
}
LoopBuilder loop_builder(builder());
- ControlScopeForIteration execution_control(this, stmt, &loop_builder);
loop_builder.LoopHeader();
loop_builder.Condition();
if (!stmt->cond()->ToBooleanIsTrue()) {
VisitForAccumulatorValue(stmt->cond());
loop_builder.BreakIfFalse();
}
- Visit(stmt->body());
+ VisitIterationBody(stmt, &loop_builder);
loop_builder.JumpToHeader();
loop_builder.EndLoop();
}
@@ -741,15 +995,13 @@
}
LoopBuilder loop_builder(builder());
- ControlScopeForIteration execution_control(this, stmt, &loop_builder);
-
loop_builder.LoopHeader();
loop_builder.Condition();
if (stmt->cond() && !stmt->cond()->ToBooleanIsTrue()) {
VisitForAccumulatorValue(stmt->cond());
loop_builder.BreakIfFalse();
}
- Visit(stmt->body());
+ VisitIterationBody(stmt, &loop_builder);
if (stmt->next() != nullptr) {
loop_builder.Next();
Visit(stmt->next());
@@ -770,7 +1022,7 @@
switch (assign_type) {
case VARIABLE: {
Variable* variable = expr->AsVariableProxy()->var();
- VisitVariableAssignment(variable, slot);
+ VisitVariableAssignment(variable, Token::ASSIGN, slot);
break;
}
case NAMED_PROPERTY: {
@@ -795,9 +1047,40 @@
language_mode());
break;
}
- case NAMED_SUPER_PROPERTY:
- case KEYED_SUPER_PROPERTY:
- UNIMPLEMENTED();
+ case NAMED_SUPER_PROPERTY: {
+ RegisterAllocationScope register_scope(this);
+ register_allocator()->PrepareForConsecutiveAllocations(4);
+ Register receiver = register_allocator()->NextConsecutiveRegister();
+ Register home_object = register_allocator()->NextConsecutiveRegister();
+ Register name = register_allocator()->NextConsecutiveRegister();
+ Register value = register_allocator()->NextConsecutiveRegister();
+ builder()->StoreAccumulatorInRegister(value);
+ SuperPropertyReference* super_property =
+ property->obj()->AsSuperPropertyReference();
+ VisitForRegisterValue(super_property->this_var(), receiver);
+ VisitForRegisterValue(super_property->home_object(), home_object);
+ builder()
+ ->LoadLiteral(property->key()->AsLiteral()->AsPropertyName())
+ .StoreAccumulatorInRegister(name);
+ BuildNamedSuperPropertyStore(receiver, home_object, name, value);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ RegisterAllocationScope register_scope(this);
+ register_allocator()->PrepareForConsecutiveAllocations(4);
+ Register receiver = register_allocator()->NextConsecutiveRegister();
+ Register home_object = register_allocator()->NextConsecutiveRegister();
+ Register key = register_allocator()->NextConsecutiveRegister();
+ Register value = register_allocator()->NextConsecutiveRegister();
+ builder()->StoreAccumulatorInRegister(value);
+ SuperPropertyReference* super_property =
+ property->obj()->AsSuperPropertyReference();
+ VisitForRegisterValue(super_property->this_var(), receiver);
+ VisitForRegisterValue(super_property->home_object(), home_object);
+ VisitForRegisterValue(property->key(), key);
+ BuildKeyedSuperPropertyStore(receiver, home_object, key, value);
+ break;
+ }
}
}
@@ -810,7 +1093,6 @@
}
LoopBuilder loop_builder(builder());
- ControlScopeForIteration control_scope(this, stmt, &loop_builder);
BytecodeLabel subject_null_label, subject_undefined_label, not_object_label;
// Prepare the state for executing ForIn.
@@ -821,10 +1103,14 @@
builder()->CastAccumulatorToJSObject();
builder()->JumpIfNull(¬_object_label);
builder()->StoreAccumulatorInRegister(receiver);
- Register cache_type = register_allocator()->NewRegister();
- Register cache_array = register_allocator()->NewRegister();
- Register cache_length = register_allocator()->NewRegister();
- builder()->ForInPrepare(cache_type, cache_array, cache_length);
+
+ register_allocator()->PrepareForConsecutiveAllocations(3);
+ Register cache_type = register_allocator()->NextConsecutiveRegister();
+ Register cache_array = register_allocator()->NextConsecutiveRegister();
+ Register cache_length = register_allocator()->NextConsecutiveRegister();
+ // Used as kRegTriple8 and kRegPair8 in ForInPrepare and ForInNext.
+ USE(cache_array);
+ builder()->ForInPrepare(cache_type);
// Set up loop counter
Register index = register_allocator()->NewRegister();
@@ -836,10 +1122,11 @@
loop_builder.Condition();
builder()->ForInDone(index, cache_length);
loop_builder.BreakIfTrue();
- builder()->ForInNext(receiver, cache_type, cache_array, index);
+ DCHECK(Register::AreContiguous(cache_type, cache_array));
+ builder()->ForInNext(receiver, index, cache_type);
loop_builder.ContinueIfUndefined();
VisitForInAssignment(stmt->each(), stmt->EachFeedbackSlot());
- Visit(stmt->body());
+ VisitIterationBody(stmt, &loop_builder);
loop_builder.Next();
builder()->ForInStep(index);
builder()->StoreAccumulatorInRegister(index);
@@ -852,31 +1139,127 @@
void BytecodeGenerator::VisitForOfStatement(ForOfStatement* stmt) {
- UNIMPLEMENTED();
+ LoopBuilder loop_builder(builder());
+ ControlScopeForIteration control_scope(this, stmt, &loop_builder);
+
+ VisitForEffect(stmt->assign_iterator());
+
+ loop_builder.LoopHeader();
+ loop_builder.Next();
+ VisitForEffect(stmt->next_result());
+ VisitForAccumulatorValue(stmt->result_done());
+ loop_builder.BreakIfTrue();
+
+ VisitForEffect(stmt->assign_each());
+ VisitIterationBody(stmt, &loop_builder);
+ loop_builder.JumpToHeader();
+ loop_builder.EndLoop();
}
void BytecodeGenerator::VisitTryCatchStatement(TryCatchStatement* stmt) {
- if (FLAG_ignition_fake_try_catch) {
+ TryCatchBuilder try_control_builder(builder());
+ Register no_reg;
+
+ // Preserve the context in a dedicated register, so that it can be restored
+ // when the handler is entered by the stack-unwinding machinery.
+ // TODO(mstarzinger): Be smarter about register allocation.
+ Register context = register_allocator()->NewRegister();
+ builder()->MoveRegister(Register::current_context(), context);
+
+ // Evaluate the try-block inside a control scope. This simulates a handler
+ // that is intercepting 'throw' control commands.
+ try_control_builder.BeginTry(context);
+ {
+ ControlScopeForTryCatch scope(this, &try_control_builder);
Visit(stmt->try_block());
- return;
}
- UNIMPLEMENTED();
+ try_control_builder.EndTry();
+
+ // Create a catch scope that binds the exception.
+ VisitNewLocalCatchContext(stmt->variable());
+ builder()->StoreAccumulatorInRegister(context);
+
+ // Clear message object as we enter the catch block.
+ builder()->CallRuntime(Runtime::kInterpreterClearPendingMessage, no_reg, 0);
+
+ // Load the catch context into the accumulator.
+ builder()->LoadAccumulatorWithRegister(context);
+
+ // Evaluate the catch-block.
+ VisitInScope(stmt->catch_block(), stmt->scope());
+ try_control_builder.EndCatch();
}
void BytecodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
- if (FLAG_ignition_fake_try_catch) {
+ TryFinallyBuilder try_control_builder(builder(), IsInsideTryCatch());
+ Register no_reg;
+
+ // We keep a record of all paths that enter the finally-block to be able to
+ // dispatch to the correct continuation point after the statements in the
+ // finally-block have been evaluated.
+ //
+ // The try-finally construct can enter the finally-block in three ways:
+ // 1. By exiting the try-block normally, falling through at the end.
+ // 2. By exiting the try-block with a function-local control flow transfer
+ // (i.e. through break/continue/return statements).
+ // 3. By exiting the try-block with a thrown exception.
+ //
+ // The result register semantics depend on how the block was entered:
+ // - ReturnStatement: It represents the return value being returned.
+ // - ThrowStatement: It represents the exception being thrown.
+ // - BreakStatement/ContinueStatement: Undefined and not used.
+ // - Falling through into finally-block: Undefined and not used.
+ Register token = register_allocator()->NewRegister();
+ Register result = register_allocator()->NewRegister();
+ ControlScope::DeferredCommands commands(this, token, result);
+
+ // Preserve the context in a dedicated register, so that it can be restored
+ // when the handler is entered by the stack-unwinding machinery.
+ // TODO(mstarzinger): Be smarter about register allocation.
+ Register context = register_allocator()->NewRegister();
+ builder()->MoveRegister(Register::current_context(), context);
+
+ // Evaluate the try-block inside a control scope. This simulates a handler
+ // that is intercepting all control commands.
+ try_control_builder.BeginTry(context);
+ {
+ ControlScopeForTryFinally scope(this, &try_control_builder, &commands);
Visit(stmt->try_block());
- Visit(stmt->finally_block());
- return;
}
- UNIMPLEMENTED();
+ try_control_builder.EndTry();
+
+ // Record fall-through and exception cases.
+ commands.RecordFallThroughPath();
+ try_control_builder.LeaveTry();
+ try_control_builder.BeginHandler();
+ commands.RecordHandlerReThrowPath();
+
+ // Pending message object is saved on entry.
+ try_control_builder.BeginFinally();
+ Register message = context; // Reuse register.
+
+ // Clear message object as we enter the finally block.
+ builder()
+ ->CallRuntime(Runtime::kInterpreterClearPendingMessage, no_reg, 0)
+ .StoreAccumulatorInRegister(message);
+
+ // Evaluate the finally-block.
+ Visit(stmt->finally_block());
+ try_control_builder.EndFinally();
+
+ // Pending message object is restored on exit.
+ builder()->CallRuntime(Runtime::kInterpreterSetPendingMessage, message, 1);
+
+ // Dynamic dispatch after the finally-block.
+ commands.ApplyDeferredCommands();
}
void BytecodeGenerator::VisitDebuggerStatement(DebuggerStatement* stmt) {
- UNIMPLEMENTED();
+ builder()->SetStatementPosition(stmt);
+ builder()->Debugger();
}
@@ -892,18 +1275,166 @@
void BytecodeGenerator::VisitClassLiteral(ClassLiteral* expr) {
- UNIMPLEMENTED();
+ if (expr->scope()->ContextLocalCount() > 0) {
+ VisitNewLocalBlockContext(expr->scope());
+ ContextScope scope(this, expr->scope());
+ VisitDeclarations(expr->scope()->declarations());
+ VisitClassLiteralContents(expr);
+ } else {
+ VisitDeclarations(expr->scope()->declarations());
+ VisitClassLiteralContents(expr);
+ }
}
+void BytecodeGenerator::VisitClassLiteralContents(ClassLiteral* expr) {
+ VisitClassLiteralForRuntimeDefinition(expr);
+
+ // Load the "prototype" from the constructor.
+ register_allocator()->PrepareForConsecutiveAllocations(2);
+ Register literal = register_allocator()->NextConsecutiveRegister();
+ Register prototype = register_allocator()->NextConsecutiveRegister();
+ Handle<String> name = isolate()->factory()->prototype_string();
+ FeedbackVectorSlot slot = expr->PrototypeSlot();
+ builder()
+ ->StoreAccumulatorInRegister(literal)
+ .LoadNamedProperty(literal, name, feedback_index(slot))
+ .StoreAccumulatorInRegister(prototype);
+
+ VisitClassLiteralProperties(expr, literal, prototype);
+ builder()->CallRuntime(Runtime::kFinalizeClassDefinition, literal, 2);
+ // Assign to class variable.
+ if (expr->class_variable_proxy() != nullptr) {
+ Variable* var = expr->class_variable_proxy()->var();
+ FeedbackVectorSlot slot = expr->NeedsProxySlot()
+ ? expr->ProxySlot()
+ : FeedbackVectorSlot::Invalid();
+ VisitVariableAssignment(var, Token::INIT, slot);
+ }
+ execution_result()->SetResultInAccumulator();
+}
+
+void BytecodeGenerator::VisitClassLiteralForRuntimeDefinition(
+ ClassLiteral* expr) {
+ AccumulatorResultScope result_scope(this);
+ register_allocator()->PrepareForConsecutiveAllocations(4);
+ Register extends = register_allocator()->NextConsecutiveRegister();
+ Register constructor = register_allocator()->NextConsecutiveRegister();
+ Register start_position = register_allocator()->NextConsecutiveRegister();
+ Register end_position = register_allocator()->NextConsecutiveRegister();
+
+ VisitForAccumulatorValueOrTheHole(expr->extends());
+ builder()->StoreAccumulatorInRegister(extends);
+
+ VisitForAccumulatorValue(expr->constructor());
+ builder()
+ ->StoreAccumulatorInRegister(constructor)
+ .LoadLiteral(Smi::FromInt(expr->start_position()))
+ .StoreAccumulatorInRegister(start_position)
+ .LoadLiteral(Smi::FromInt(expr->end_position()))
+ .StoreAccumulatorInRegister(end_position)
+ .CallRuntime(Runtime::kDefineClass, extends, 4);
+ result_scope.SetResultInAccumulator();
+}
+
+void BytecodeGenerator::VisitClassLiteralProperties(ClassLiteral* expr,
+ Register literal,
+ Register prototype) {
+ RegisterAllocationScope register_scope(this);
+ register_allocator()->PrepareForConsecutiveAllocations(5);
+ Register receiver = register_allocator()->NextConsecutiveRegister();
+ Register key = register_allocator()->NextConsecutiveRegister();
+ Register value = register_allocator()->NextConsecutiveRegister();
+ Register attr = register_allocator()->NextConsecutiveRegister();
+ Register set_function_name = register_allocator()->NextConsecutiveRegister();
+
+ bool attr_assigned = false;
+ Register old_receiver = Register::invalid_value();
+
+ // Create nodes to store method values into the literal.
+ for (int i = 0; i < expr->properties()->length(); i++) {
+ ObjectLiteral::Property* property = expr->properties()->at(i);
+
+ // Set-up receiver.
+ Register new_receiver = property->is_static() ? literal : prototype;
+ if (new_receiver != old_receiver) {
+ builder()->MoveRegister(new_receiver, receiver);
+ old_receiver = new_receiver;
+ }
+
+ VisitForAccumulatorValue(property->key());
+ builder()->CastAccumulatorToName().StoreAccumulatorInRegister(key);
+ // The static prototype property is read only. We handle the non computed
+ // property name case in the parser. Since this is the only case where we
+ // need to check for an own read only property we special case this so we do
+ // not need to do this for every property.
+ if (property->is_static() && property->is_computed_name()) {
+ VisitClassLiteralStaticPrototypeWithComputedName(key);
+ }
+ VisitForAccumulatorValue(property->value());
+ builder()->StoreAccumulatorInRegister(value);
+
+ VisitSetHomeObject(value, receiver, property);
+
+ if (!attr_assigned) {
+ builder()
+ ->LoadLiteral(Smi::FromInt(DONT_ENUM))
+ .StoreAccumulatorInRegister(attr);
+ attr_assigned = true;
+ }
+
+ switch (property->kind()) {
+ case ObjectLiteral::Property::CONSTANT:
+ case ObjectLiteral::Property::MATERIALIZED_LITERAL:
+ case ObjectLiteral::Property::PROTOTYPE:
+ // Invalid properties for ES6 classes.
+ UNREACHABLE();
+ break;
+ case ObjectLiteral::Property::COMPUTED: {
+ builder()
+ ->LoadLiteral(Smi::FromInt(property->NeedsSetFunctionName()))
+ .StoreAccumulatorInRegister(set_function_name);
+ builder()->CallRuntime(Runtime::kDefineDataPropertyInLiteral, receiver,
+ 5);
+ break;
+ }
+ case ObjectLiteral::Property::GETTER: {
+ builder()->CallRuntime(Runtime::kDefineGetterPropertyUnchecked,
+ receiver, 4);
+ break;
+ }
+ case ObjectLiteral::Property::SETTER: {
+ builder()->CallRuntime(Runtime::kDefineSetterPropertyUnchecked,
+ receiver, 4);
+ break;
+ }
+ }
+ }
+}
+
+void BytecodeGenerator::VisitClassLiteralStaticPrototypeWithComputedName(
+ Register key) {
+ BytecodeLabel done;
+ builder()
+ ->LoadLiteral(isolate()->factory()->prototype_string())
+ .CompareOperation(Token::Value::EQ_STRICT, key)
+ .JumpIfFalse(&done)
+ .CallRuntime(Runtime::kThrowStaticPrototypeError, Register(0), 0)
+ .Bind(&done);
+}
void BytecodeGenerator::VisitNativeFunctionLiteral(
NativeFunctionLiteral* expr) {
- UNIMPLEMENTED();
+ // Find or build a shared function info for the native function template.
+ Handle<SharedFunctionInfo> shared_info =
+ Compiler::GetSharedFunctionInfoForNative(expr->extension(), expr->name());
+ builder()->CreateClosure(shared_info, NOT_TENURED);
+ execution_result()->SetResultInAccumulator();
}
void BytecodeGenerator::VisitDoExpression(DoExpression* expr) {
- UNIMPLEMENTED();
+ VisitBlock(expr->block());
+ VisitVariableProxy(expr->result());
}
@@ -964,10 +1495,13 @@
builder()->CreateObjectLiteral(expr->constant_properties(),
expr->literal_index(),
expr->ComputeFlags(true));
- Register literal;
+
+ // Allocate in the outer scope since this register is used to return the
+ // expression's results to the caller.
+ Register literal = register_allocator()->outer()->NewRegister();
+ builder()->StoreAccumulatorInRegister(literal);
// Store computed values into the literal.
- bool literal_in_accumulator = true;
int property_index = 0;
AccessorTable accessor_table(zone());
for (; property_index < expr->properties()->length(); property_index++) {
@@ -975,12 +1509,6 @@
if (property->is_computed_name()) break;
if (property->IsCompileTimeValue()) continue;
- if (literal_in_accumulator) {
- literal = register_allocator()->NewRegister();
- builder()->StoreAccumulatorInRegister(literal);
- literal_in_accumulator = false;
- }
-
RegisterAllocationScope inner_register_scope(this);
Literal* literal_key = property->key()->AsLiteral();
switch (property->kind()) {
@@ -995,21 +1523,31 @@
if (literal_key->value()->IsInternalizedString()) {
if (property->emit_store()) {
VisitForAccumulatorValue(property->value());
- builder()->StoreNamedProperty(
- literal, literal_key->AsPropertyName(),
- feedback_index(property->GetSlot(0)), language_mode());
+ if (FunctionLiteral::NeedsHomeObject(property->value())) {
+ RegisterAllocationScope register_scope(this);
+ Register value = register_allocator()->NewRegister();
+ builder()->StoreAccumulatorInRegister(value);
+ builder()->StoreNamedProperty(
+ literal, literal_key->AsPropertyName(),
+ feedback_index(property->GetSlot(0)), language_mode());
+ VisitSetHomeObject(value, literal, property, 1);
+ } else {
+ builder()->StoreNamedProperty(
+ literal, literal_key->AsPropertyName(),
+ feedback_index(property->GetSlot(0)), language_mode());
+ }
} else {
VisitForEffect(property->value());
}
} else {
- register_allocator()->PrepareForConsecutiveAllocations(3);
+ register_allocator()->PrepareForConsecutiveAllocations(4);
+ Register literal_argument =
+ register_allocator()->NextConsecutiveRegister();
Register key = register_allocator()->NextConsecutiveRegister();
Register value = register_allocator()->NextConsecutiveRegister();
Register language = register_allocator()->NextConsecutiveRegister();
- // TODO(oth): This is problematic - can't assume contiguous here.
- // literal is allocated in outer register scope, whereas key, value,
- // language are in another.
- DCHECK(Register::AreContiguous(literal, key, value, language));
+
+ builder()->MoveRegister(literal, literal_argument);
VisitForAccumulatorValue(property->key());
builder()->StoreAccumulatorInRegister(key);
VisitForAccumulatorValue(property->value());
@@ -1018,20 +1556,23 @@
builder()
->LoadLiteral(Smi::FromInt(SLOPPY))
.StoreAccumulatorInRegister(language)
- .CallRuntime(Runtime::kSetProperty, literal, 4);
+ .CallRuntime(Runtime::kSetProperty, literal_argument, 4);
VisitSetHomeObject(value, literal, property);
}
}
break;
}
case ObjectLiteral::Property::PROTOTYPE: {
- register_allocator()->PrepareForConsecutiveAllocations(1);
DCHECK(property->emit_store());
+ register_allocator()->PrepareForConsecutiveAllocations(2);
+ Register literal_argument =
+ register_allocator()->NextConsecutiveRegister();
Register value = register_allocator()->NextConsecutiveRegister();
- DCHECK(Register::AreContiguous(literal, value));
+
+ builder()->MoveRegister(literal, literal_argument);
VisitForAccumulatorValue(property->value());
builder()->StoreAccumulatorInRegister(value).CallRuntime(
- Runtime::kInternalSetPrototype, literal, 2);
+ Runtime::kInternalSetPrototype, literal_argument, 2);
break;
}
case ObjectLiteral::Property::GETTER:
@@ -1052,12 +1593,14 @@
for (AccessorTable::Iterator it = accessor_table.begin();
it != accessor_table.end(); ++it) {
RegisterAllocationScope inner_register_scope(this);
- register_allocator()->PrepareForConsecutiveAllocations(4);
+ register_allocator()->PrepareForConsecutiveAllocations(5);
+ Register literal_argument = register_allocator()->NextConsecutiveRegister();
Register name = register_allocator()->NextConsecutiveRegister();
Register getter = register_allocator()->NextConsecutiveRegister();
Register setter = register_allocator()->NextConsecutiveRegister();
Register attr = register_allocator()->NextConsecutiveRegister();
- DCHECK(Register::AreContiguous(literal, name, getter, setter, attr));
+
+ builder()->MoveRegister(literal, literal_argument);
VisitForAccumulatorValue(it->first);
builder()->StoreAccumulatorInRegister(name);
VisitObjectLiteralAccessor(literal, it->second->getter, getter);
@@ -1065,7 +1608,8 @@
builder()
->LoadLiteral(Smi::FromInt(NONE))
.StoreAccumulatorInRegister(attr)
- .CallRuntime(Runtime::kDefineAccessorPropertyUnchecked, literal, 5);
+ .CallRuntime(Runtime::kDefineAccessorPropertyUnchecked,
+ literal_argument, 5);
}
// Object literals have two parts. The "static" part on the left contains no
@@ -1078,67 +1622,69 @@
// compile them into a series of "SetOwnProperty" runtime calls. This will
// preserve insertion order.
for (; property_index < expr->properties()->length(); property_index++) {
- if (literal_in_accumulator) {
- literal = register_allocator()->NewRegister();
- builder()->StoreAccumulatorInRegister(literal);
- literal_in_accumulator = false;
- }
-
ObjectLiteral::Property* property = expr->properties()->at(property_index);
RegisterAllocationScope inner_register_scope(this);
+
if (property->kind() == ObjectLiteral::Property::PROTOTYPE) {
DCHECK(property->emit_store());
- Register value = register_allocator()->NewRegister();
- DCHECK(Register::AreContiguous(literal, value));
+ register_allocator()->PrepareForConsecutiveAllocations(2);
+ Register literal_argument =
+ register_allocator()->NextConsecutiveRegister();
+ Register value = register_allocator()->NextConsecutiveRegister();
+
+ builder()->MoveRegister(literal, literal_argument);
VisitForAccumulatorValue(property->value());
builder()->StoreAccumulatorInRegister(value).CallRuntime(
- Runtime::kInternalSetPrototype, literal, 2);
+ Runtime::kInternalSetPrototype, literal_argument, 2);
continue;
}
- register_allocator()->PrepareForConsecutiveAllocations(3);
+ register_allocator()->PrepareForConsecutiveAllocations(5);
+ Register literal_argument = register_allocator()->NextConsecutiveRegister();
Register key = register_allocator()->NextConsecutiveRegister();
Register value = register_allocator()->NextConsecutiveRegister();
Register attr = register_allocator()->NextConsecutiveRegister();
- DCHECK(Register::AreContiguous(literal, key, value, attr));
+ DCHECK(Register::AreContiguous(literal_argument, key, value, attr));
+ Register set_function_name =
+ register_allocator()->NextConsecutiveRegister();
+ builder()->MoveRegister(literal, literal_argument);
VisitForAccumulatorValue(property->key());
builder()->CastAccumulatorToName().StoreAccumulatorInRegister(key);
VisitForAccumulatorValue(property->value());
builder()->StoreAccumulatorInRegister(value);
VisitSetHomeObject(value, literal, property);
builder()->LoadLiteral(Smi::FromInt(NONE)).StoreAccumulatorInRegister(attr);
- Runtime::FunctionId function_id = static_cast<Runtime::FunctionId>(-1);
switch (property->kind()) {
case ObjectLiteral::Property::CONSTANT:
case ObjectLiteral::Property::COMPUTED:
case ObjectLiteral::Property::MATERIALIZED_LITERAL:
- function_id = Runtime::kDefineDataPropertyUnchecked;
+ builder()
+ ->LoadLiteral(Smi::FromInt(property->NeedsSetFunctionName()))
+ .StoreAccumulatorInRegister(set_function_name);
+ builder()->CallRuntime(Runtime::kDefineDataPropertyInLiteral,
+ literal_argument, 5);
break;
case ObjectLiteral::Property::PROTOTYPE:
UNREACHABLE(); // Handled specially above.
break;
case ObjectLiteral::Property::GETTER:
- function_id = Runtime::kDefineGetterPropertyUnchecked;
+ builder()->CallRuntime(Runtime::kDefineGetterPropertyUnchecked,
+ literal_argument, 4);
break;
case ObjectLiteral::Property::SETTER:
- function_id = Runtime::kDefineSetterPropertyUnchecked;
+ builder()->CallRuntime(Runtime::kDefineSetterPropertyUnchecked,
+ literal_argument, 4);
break;
}
- builder()->CallRuntime(function_id, literal, 4);
}
// Transform literals that contain functions to fast properties.
if (expr->has_function()) {
- DCHECK(!literal_in_accumulator);
builder()->CallRuntime(Runtime::kToFastProperties, literal, 1);
}
- if (!literal_in_accumulator) {
- // Restore literal array into accumulator.
- builder()->LoadAccumulatorWithRegister(literal);
- }
- execution_result()->SetResultInAccumulator();
+ execution_result()->SetResultInRegister(literal);
}
@@ -1156,10 +1702,7 @@
array_index++) {
Expression* subexpr = expr->values()->at(array_index);
if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
- if (subexpr->IsSpread()) {
- // TODO(rmcilroy): Deal with spread expressions.
- UNIMPLEMENTED();
- }
+ DCHECK(!subexpr->IsSpread());
if (literal_in_accumulator) {
index = register_allocator()->NewRegister();
@@ -1189,14 +1732,25 @@
VisitVariableLoad(proxy->var(), proxy->VariableFeedbackSlot());
}
+void BytecodeGenerator::BuildHoleCheckForVariableLoad(VariableMode mode,
+ Handle<String> name) {
+ if (mode == CONST_LEGACY) {
+ BytecodeLabel end_label;
+ builder()->JumpIfNotHole(&end_label).LoadUndefined().Bind(&end_label);
+ } else if (mode == LET || mode == CONST) {
+ BuildThrowIfHole(name);
+ }
+}
void BytecodeGenerator::VisitVariableLoad(Variable* variable,
FeedbackVectorSlot slot,
TypeofMode typeof_mode) {
+ VariableMode mode = variable->mode();
switch (variable->location()) {
case VariableLocation::LOCAL: {
Register source(Register(variable->index()));
builder()->LoadAccumulatorWithRegister(source);
+ BuildHoleCheckForVariableLoad(mode, variable->name());
execution_result()->SetResultInAccumulator();
break;
}
@@ -1205,13 +1759,14 @@
// index -1 but is parameter index 0 in BytecodeArrayBuilder).
Register source = builder()->Parameter(variable->index() + 1);
builder()->LoadAccumulatorWithRegister(source);
+ BuildHoleCheckForVariableLoad(mode, variable->name());
execution_result()->SetResultInAccumulator();
break;
}
case VariableLocation::GLOBAL:
case VariableLocation::UNALLOCATED: {
builder()->LoadGlobal(variable->name(), feedback_index(slot),
- language_mode(), typeof_mode);
+ typeof_mode);
execution_result()->SetResultInAccumulator();
break;
}
@@ -1237,10 +1792,10 @@
.StoreAccumulatorInRegister(context_reg);
}
}
+
builder()->LoadContextSlot(context_reg, variable->index());
+ BuildHoleCheckForVariableLoad(mode, variable->name());
execution_result()->SetResultInAccumulator();
- // TODO(rmcilroy): Perform check for uninitialized legacy const, const and
- // let variables.
break;
}
case VariableLocation::LOOKUP: {
@@ -1251,14 +1806,12 @@
}
}
-
void BytecodeGenerator::VisitVariableLoadForAccumulatorValue(
Variable* variable, FeedbackVectorSlot slot, TypeofMode typeof_mode) {
AccumulatorResultScope accumulator_result(this);
VisitVariableLoad(variable, slot, typeof_mode);
}
-
Register BytecodeGenerator::VisitVariableLoadForRegisterValue(
Variable* variable, FeedbackVectorSlot slot, TypeofMode typeof_mode) {
RegisterResultScope register_scope(this);
@@ -1266,20 +1819,150 @@
return register_scope.ResultRegister();
}
+void BytecodeGenerator::BuildNamedSuperPropertyLoad(Register receiver,
+ Register home_object,
+ Register name) {
+ DCHECK(Register::AreContiguous(receiver, home_object, name));
+ builder()->CallRuntime(Runtime::kLoadFromSuper, receiver, 3);
+}
+
+void BytecodeGenerator::BuildKeyedSuperPropertyLoad(Register receiver,
+ Register home_object,
+ Register key) {
+ DCHECK(Register::AreContiguous(receiver, home_object, key));
+ builder()->CallRuntime(Runtime::kLoadKeyedFromSuper, receiver, 3);
+}
+
+void BytecodeGenerator::BuildNamedSuperPropertyStore(Register receiver,
+ Register home_object,
+ Register name,
+ Register value) {
+ DCHECK(Register::AreContiguous(receiver, home_object, name, value));
+ Runtime::FunctionId function_id = is_strict(language_mode())
+ ? Runtime::kStoreToSuper_Strict
+ : Runtime::kStoreToSuper_Sloppy;
+ builder()->CallRuntime(function_id, receiver, 4);
+}
+
+void BytecodeGenerator::BuildKeyedSuperPropertyStore(Register receiver,
+ Register home_object,
+ Register key,
+ Register value) {
+ DCHECK(Register::AreContiguous(receiver, home_object, key, value));
+ Runtime::FunctionId function_id = is_strict(language_mode())
+ ? Runtime::kStoreKeyedToSuper_Strict
+ : Runtime::kStoreKeyedToSuper_Sloppy;
+ builder()->CallRuntime(function_id, receiver, 4);
+}
+
+void BytecodeGenerator::BuildThrowReferenceError(Handle<String> name) {
+ RegisterAllocationScope register_scope(this);
+ Register name_reg = register_allocator()->NewRegister();
+ builder()->LoadLiteral(name).StoreAccumulatorInRegister(name_reg).CallRuntime(
+ Runtime::kThrowReferenceError, name_reg, 1);
+}
+
+void BytecodeGenerator::BuildThrowIfHole(Handle<String> name) {
+ // TODO(interpreter): Can the parser reduce the number of checks
+ // performed? Or should there be a ThrowIfHole bytecode.
+ BytecodeLabel no_reference_error;
+ builder()->JumpIfNotHole(&no_reference_error);
+ BuildThrowReferenceError(name);
+ builder()->Bind(&no_reference_error);
+}
+
+void BytecodeGenerator::BuildThrowIfNotHole(Handle<String> name) {
+ // TODO(interpreter): Can the parser reduce the number of checks
+ // performed? Or should there be a ThrowIfNotHole bytecode.
+ BytecodeLabel no_reference_error, reference_error;
+ builder()
+ ->JumpIfNotHole(&reference_error)
+ .Jump(&no_reference_error)
+ .Bind(&reference_error);
+ BuildThrowReferenceError(name);
+ builder()->Bind(&no_reference_error);
+}
+
+void BytecodeGenerator::BuildThrowReassignConstant(Handle<String> name) {
+ // TODO(mythria): This will be replaced by a new bytecode that throws an
+ // appropriate error depending on the whether the value is a hole or not.
+ BytecodeLabel const_assign_error;
+ builder()->JumpIfNotHole(&const_assign_error);
+ BuildThrowReferenceError(name);
+ builder()
+ ->Bind(&const_assign_error)
+ .CallRuntime(Runtime::kThrowConstAssignError, Register(), 0);
+}
+
+void BytecodeGenerator::BuildHoleCheckForVariableAssignment(Variable* variable,
+ Token::Value op) {
+ VariableMode mode = variable->mode();
+ DCHECK(mode != CONST_LEGACY);
+ if (mode == CONST && op != Token::INIT) {
+ // Non-intializing assignments to constant is not allowed.
+ BuildThrowReassignConstant(variable->name());
+ } else if (mode == LET && op != Token::INIT) {
+ // Perform an initialization check for let declared variables.
+ // E.g. let x = (x = 20); is not allowed.
+ BuildThrowIfHole(variable->name());
+ } else {
+ DCHECK(variable->is_this() && mode == CONST && op == Token::INIT);
+ // Perform an initialization check for 'this'. 'this' variable is the
+ // only variable able to trigger bind operations outside the TDZ
+ // via 'super' calls.
+ BuildThrowIfNotHole(variable->name());
+ }
+}
void BytecodeGenerator::VisitVariableAssignment(Variable* variable,
+ Token::Value op,
FeedbackVectorSlot slot) {
+ VariableMode mode = variable->mode();
+ RegisterAllocationScope assignment_register_scope(this);
+ BytecodeLabel end_label;
+ bool hole_check_required =
+ (mode == CONST_LEGACY) || (mode == LET && op != Token::INIT) ||
+ (mode == CONST && op != Token::INIT) ||
+ (mode == CONST && op == Token::INIT && variable->is_this());
switch (variable->location()) {
+ case VariableLocation::PARAMETER:
case VariableLocation::LOCAL: {
- // TODO(rmcilroy): support const mode initialization.
- Register destination(variable->index());
- builder()->StoreAccumulatorInRegister(destination);
- break;
- }
- case VariableLocation::PARAMETER: {
- // The parameter indices are shifted by 1 (receiver is variable
- // index -1 but is parameter index 0 in BytecodeArrayBuilder).
- Register destination(builder()->Parameter(variable->index() + 1));
+ Register destination;
+ if (VariableLocation::PARAMETER == variable->location()) {
+ destination = Register(builder()->Parameter(variable->index() + 1));
+ } else {
+ destination = Register(variable->index());
+ }
+
+ if (hole_check_required) {
+ // Load destination to check for hole.
+ Register value_temp = register_allocator()->NewRegister();
+ builder()
+ ->StoreAccumulatorInRegister(value_temp)
+ .LoadAccumulatorWithRegister(destination);
+
+ if (mode == CONST_LEGACY && op == Token::INIT) {
+ // Perform an intialization check for legacy constants.
+ builder()
+ ->JumpIfNotHole(&end_label)
+ .MoveRegister(value_temp, destination)
+ .Bind(&end_label)
+ .LoadAccumulatorWithRegister(value_temp);
+ // Break here because the value should not be stored unconditionally.
+ break;
+ } else if (mode == CONST_LEGACY && op != Token::INIT) {
+ DCHECK(!is_strict(language_mode()));
+ // Ensure accumulator is in the correct state.
+ builder()->LoadAccumulatorWithRegister(value_temp);
+ // Break here, non-initializing assignments to legacy constants are
+ // ignored.
+ break;
+ } else {
+ BuildHoleCheckForVariableAssignment(variable, op);
+ builder()->LoadAccumulatorWithRegister(value_temp);
+ }
+ }
+
builder()->StoreAccumulatorInRegister(destination);
break;
}
@@ -1290,10 +1973,10 @@
break;
}
case VariableLocation::CONTEXT: {
- // TODO(rmcilroy): support const mode initialization.
int depth = execution_context()->ContextChainDepth(variable->scope());
ContextScope* context = execution_context()->Previous(depth);
Register context_reg;
+
if (context) {
context_reg = context->reg();
} else {
@@ -1315,11 +1998,63 @@
}
builder()->LoadAccumulatorWithRegister(value_temp);
}
+
+ if (hole_check_required) {
+ // Load destination to check for hole.
+ Register value_temp = register_allocator()->NewRegister();
+ builder()
+ ->StoreAccumulatorInRegister(value_temp)
+ .LoadContextSlot(context_reg, variable->index());
+
+ if (mode == CONST_LEGACY && op == Token::INIT) {
+ // Perform an intialization check for legacy constants.
+ builder()
+ ->JumpIfNotHole(&end_label)
+ .LoadAccumulatorWithRegister(value_temp)
+ .StoreContextSlot(context_reg, variable->index())
+ .Bind(&end_label);
+ builder()->LoadAccumulatorWithRegister(value_temp);
+ // Break here because the value should not be stored unconditionally.
+ // The above code performs the store conditionally.
+ break;
+ } else if (mode == CONST_LEGACY && op != Token::INIT) {
+ DCHECK(!is_strict(language_mode()));
+ // Ensure accumulator is in the correct state.
+ builder()->LoadAccumulatorWithRegister(value_temp);
+ // Break here, non-initializing assignments to legacy constants are
+ // ignored.
+ break;
+ } else {
+ BuildHoleCheckForVariableAssignment(variable, op);
+ builder()->LoadAccumulatorWithRegister(value_temp);
+ }
+ }
+
builder()->StoreContextSlot(context_reg, variable->index());
break;
}
case VariableLocation::LOOKUP: {
- builder()->StoreLookupSlot(variable->name(), language_mode());
+ if (mode == CONST_LEGACY && op == Token::INIT) {
+ register_allocator()->PrepareForConsecutiveAllocations(3);
+ Register value = register_allocator()->NextConsecutiveRegister();
+ Register context = register_allocator()->NextConsecutiveRegister();
+ Register name = register_allocator()->NextConsecutiveRegister();
+
+ // InitializeLegacyConstLookupSlot runtime call returns the 'value'
+ // passed to it. So, accumulator will have its original contents when
+ // runtime call returns.
+ builder()
+ ->StoreAccumulatorInRegister(value)
+ .MoveRegister(execution_context()->reg(), context)
+ .LoadLiteral(variable->name())
+ .StoreAccumulatorInRegister(name)
+ .CallRuntime(Runtime::kInitializeLegacyConstLookupSlot, value, 3);
+ } else if (mode == CONST_LEGACY && op != Token::INIT) {
+ // Non-intializing assignments to legacy constants are ignored.
+ DCHECK(!is_strict(language_mode()));
+ } else {
+ builder()->StoreLookupSlot(variable->name(), language_mode());
+ }
break;
}
}
@@ -1327,8 +2062,8 @@
void BytecodeGenerator::VisitAssignment(Assignment* expr) {
- DCHECK(expr->target()->IsValidReferenceExpression());
- Register object, key;
+ DCHECK(expr->target()->IsValidReferenceExpressionOrThis());
+ Register object, key, home_object, value;
Handle<String> name;
// Left-hand side can only be a property, a global or a variable slot.
@@ -1358,9 +2093,35 @@
}
break;
}
- case NAMED_SUPER_PROPERTY:
- case KEYED_SUPER_PROPERTY:
- UNIMPLEMENTED();
+ case NAMED_SUPER_PROPERTY: {
+ register_allocator()->PrepareForConsecutiveAllocations(4);
+ object = register_allocator()->NextConsecutiveRegister();
+ home_object = register_allocator()->NextConsecutiveRegister();
+ key = register_allocator()->NextConsecutiveRegister();
+ value = register_allocator()->NextConsecutiveRegister();
+ SuperPropertyReference* super_property =
+ property->obj()->AsSuperPropertyReference();
+ VisitForRegisterValue(super_property->this_var(), object);
+ VisitForRegisterValue(super_property->home_object(), home_object);
+ builder()
+ ->LoadLiteral(property->key()->AsLiteral()->AsPropertyName())
+ .StoreAccumulatorInRegister(key);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ register_allocator()->PrepareForConsecutiveAllocations(4);
+ object = register_allocator()->NextConsecutiveRegister();
+ home_object = register_allocator()->NextConsecutiveRegister();
+ key = register_allocator()->NextConsecutiveRegister();
+ value = register_allocator()->NextConsecutiveRegister();
+ builder()->StoreAccumulatorInRegister(value);
+ SuperPropertyReference* super_property =
+ property->obj()->AsSuperPropertyReference();
+ VisitForRegisterValue(super_property->this_var(), object);
+ VisitForRegisterValue(super_property->home_object(), home_object);
+ VisitForRegisterValue(property->key(), key);
+ break;
+ }
}
// Evaluate the value and potentially handle compound assignments by loading
@@ -1378,8 +2139,7 @@
FeedbackVectorSlot slot = property->PropertyFeedbackSlot();
old_value = register_allocator()->NewRegister();
builder()
- ->LoadNamedProperty(object, name, feedback_index(slot),
- language_mode())
+ ->LoadNamedProperty(object, name, feedback_index(slot))
.StoreAccumulatorInRegister(old_value);
break;
}
@@ -1389,18 +2149,25 @@
FeedbackVectorSlot slot = property->PropertyFeedbackSlot();
old_value = register_allocator()->NewRegister();
builder()
- ->LoadKeyedProperty(object, feedback_index(slot), language_mode())
+ ->LoadKeyedProperty(object, feedback_index(slot))
.StoreAccumulatorInRegister(old_value);
break;
}
- case NAMED_SUPER_PROPERTY:
- case KEYED_SUPER_PROPERTY:
- UNIMPLEMENTED();
+ case NAMED_SUPER_PROPERTY: {
+ old_value = register_allocator()->NewRegister();
+ BuildNamedSuperPropertyLoad(object, home_object, key);
+ builder()->StoreAccumulatorInRegister(old_value);
break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ old_value = register_allocator()->NewRegister();
+ BuildKeyedSuperPropertyLoad(object, home_object, key);
+ builder()->StoreAccumulatorInRegister(old_value);
+ break;
+ }
}
VisitForAccumulatorValue(expr->value());
- builder()->BinaryOperation(expr->binary_op(), old_value,
- language_mode_strength());
+ builder()->BinaryOperation(expr->binary_op(), old_value);
} else {
VisitForAccumulatorValue(expr->value());
}
@@ -1412,7 +2179,7 @@
// TODO(oth): The VisitVariableAssignment() call is hard to reason about.
// Is the value in the accumulator safe? Yes, but scary.
Variable* variable = expr->target()->AsVariableProxy()->var();
- VisitVariableAssignment(variable, slot);
+ VisitVariableAssignment(variable, expr->op(), slot);
break;
}
case NAMED_PROPERTY:
@@ -1423,9 +2190,16 @@
builder()->StoreKeyedProperty(object, key, feedback_index(slot),
language_mode());
break;
- case NAMED_SUPER_PROPERTY:
- case KEYED_SUPER_PROPERTY:
- UNIMPLEMENTED();
+ case NAMED_SUPER_PROPERTY: {
+ builder()->StoreAccumulatorInRegister(value);
+ BuildNamedSuperPropertyStore(object, home_object, key, value);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ builder()->StoreAccumulatorInRegister(value);
+ BuildKeyedSuperPropertyStore(object, home_object, key, value);
+ break;
+ }
}
execution_result()->SetResultInAccumulator();
}
@@ -1437,6 +2211,11 @@
void BytecodeGenerator::VisitThrow(Throw* expr) {
VisitForAccumulatorValue(expr->exception());
builder()->Throw();
+ // Throw statments are modeled as expression instead of statments. These are
+ // converted from assignment statements in Rewriter::ReWrite pass. An
+ // assignment statement expects a value in the accumulator. This is a hack to
+ // avoid DCHECK fails assert accumulator has been set.
+ execution_result()->SetResultInAccumulator();
}
@@ -1449,34 +2228,84 @@
case NAMED_PROPERTY: {
builder()->LoadNamedProperty(obj,
expr->key()->AsLiteral()->AsPropertyName(),
- feedback_index(slot), language_mode());
+ feedback_index(slot));
break;
}
case KEYED_PROPERTY: {
VisitForAccumulatorValue(expr->key());
- builder()->LoadKeyedProperty(obj, feedback_index(slot), language_mode());
+ builder()->LoadKeyedProperty(obj, feedback_index(slot));
break;
}
case NAMED_SUPER_PROPERTY:
+ VisitNamedSuperPropertyLoad(expr, Register::invalid_value());
+ break;
case KEYED_SUPER_PROPERTY:
- UNIMPLEMENTED();
+ VisitKeyedSuperPropertyLoad(expr, Register::invalid_value());
+ break;
}
execution_result()->SetResultInAccumulator();
}
-
void BytecodeGenerator::VisitPropertyLoadForAccumulator(Register obj,
Property* expr) {
AccumulatorResultScope result_scope(this);
VisitPropertyLoad(obj, expr);
}
+void BytecodeGenerator::VisitNamedSuperPropertyLoad(Property* property,
+ Register opt_receiver_out) {
+ RegisterAllocationScope register_scope(this);
+ register_allocator()->PrepareForConsecutiveAllocations(3);
-void BytecodeGenerator::VisitProperty(Property* expr) {
- Register obj = VisitForRegisterValue(expr->obj());
- VisitPropertyLoad(obj, expr);
+ Register receiver, home_object, name;
+ receiver = register_allocator()->NextConsecutiveRegister();
+ home_object = register_allocator()->NextConsecutiveRegister();
+ name = register_allocator()->NextConsecutiveRegister();
+ SuperPropertyReference* super_property =
+ property->obj()->AsSuperPropertyReference();
+ VisitForRegisterValue(super_property->this_var(), receiver);
+ VisitForRegisterValue(super_property->home_object(), home_object);
+ builder()
+ ->LoadLiteral(property->key()->AsLiteral()->AsPropertyName())
+ .StoreAccumulatorInRegister(name);
+ BuildNamedSuperPropertyLoad(receiver, home_object, name);
+
+ if (opt_receiver_out.is_valid()) {
+ builder()->MoveRegister(receiver, opt_receiver_out);
+ }
}
+void BytecodeGenerator::VisitKeyedSuperPropertyLoad(Property* property,
+ Register opt_receiver_out) {
+ RegisterAllocationScope register_scope(this);
+ register_allocator()->PrepareForConsecutiveAllocations(3);
+
+ Register receiver, home_object, key;
+ receiver = register_allocator()->NextConsecutiveRegister();
+ home_object = register_allocator()->NextConsecutiveRegister();
+ key = register_allocator()->NextConsecutiveRegister();
+ SuperPropertyReference* super_property =
+ property->obj()->AsSuperPropertyReference();
+ VisitForRegisterValue(super_property->this_var(), receiver);
+ VisitForRegisterValue(super_property->home_object(), home_object);
+ VisitForRegisterValue(property->key(), key);
+ BuildKeyedSuperPropertyLoad(receiver, home_object, key);
+
+ if (opt_receiver_out.is_valid()) {
+ builder()->MoveRegister(receiver, opt_receiver_out);
+ }
+}
+
+void BytecodeGenerator::VisitProperty(Property* expr) {
+ LhsKind property_kind = Property::GetAssignType(expr);
+ if (property_kind != NAMED_SUPER_PROPERTY &&
+ property_kind != KEYED_SUPER_PROPERTY) {
+ Register obj = VisitForRegisterValue(expr->obj());
+ VisitPropertyLoad(obj, expr);
+ } else {
+ VisitPropertyLoad(Register::invalid_value(), expr);
+ }
+}
Register BytecodeGenerator::VisitArguments(ZoneList<Expression*>* args) {
if (args->length() == 0) {
@@ -1510,18 +2339,21 @@
return first_arg;
}
-
void BytecodeGenerator::VisitCall(Call* expr) {
Expression* callee_expr = expr->expression();
Call::CallType call_type = expr->GetCallType(isolate());
+ if (call_type == Call::SUPER_CALL) {
+ return VisitCallSuper(expr);
+ }
+
// Prepare the callee and the receiver to the function call. This depends on
// the semantics of the underlying call type.
// The receiver and arguments need to be allocated consecutively for
// Call(). We allocate the callee and receiver consecutively for calls to
- // kLoadLookupSlot. Future optimizations could avoid this there are no
- // arguments or the receiver and arguments are already consecutive.
+ // %LoadLookupSlotForCall. Future optimizations could avoid this there are
+ // no arguments or the receiver and arguments are already consecutive.
ZoneList<Expression*>* args = expr->arguments();
register_allocator()->PrepareForConsecutiveAllocations(args->length() + 2);
Register callee = register_allocator()->NextConsecutiveRegister();
@@ -1551,18 +2383,16 @@
case Call::POSSIBLY_EVAL_CALL: {
if (callee_expr->AsVariableProxy()->var()->IsLookupSlot()) {
RegisterAllocationScope inner_register_scope(this);
- register_allocator()->PrepareForConsecutiveAllocations(2);
- Register context = register_allocator()->NextConsecutiveRegister();
- Register name = register_allocator()->NextConsecutiveRegister();
+ Register name = register_allocator()->NewRegister();
- // Call LoadLookupSlot to get the callee and receiver.
+ // Call %LoadLookupSlotForCall to get the callee and receiver.
DCHECK(Register::AreContiguous(callee, receiver));
Variable* variable = callee_expr->AsVariableProxy()->var();
builder()
- ->MoveRegister(Register::function_context(), context)
- .LoadLiteral(variable->name())
+ ->LoadLiteral(variable->name())
.StoreAccumulatorInRegister(name)
- .CallRuntimeForPair(Runtime::kLoadLookupSlot, context, 2, callee);
+ .CallRuntimeForPair(Runtime::kLoadLookupSlotForCall, name, 1,
+ callee);
break;
}
// Fall through.
@@ -1574,10 +2404,21 @@
builder()->StoreAccumulatorInRegister(callee);
break;
}
- case Call::NAMED_SUPER_PROPERTY_CALL:
- case Call::KEYED_SUPER_PROPERTY_CALL:
+ case Call::NAMED_SUPER_PROPERTY_CALL: {
+ Property* property = callee_expr->AsProperty();
+ VisitNamedSuperPropertyLoad(property, receiver);
+ builder()->StoreAccumulatorInRegister(callee);
+ break;
+ }
+ case Call::KEYED_SUPER_PROPERTY_CALL: {
+ Property* property = callee_expr->AsProperty();
+ VisitKeyedSuperPropertyLoad(property, receiver);
+ builder()->StoreAccumulatorInRegister(callee);
+ break;
+ }
case Call::SUPER_CALL:
- UNIMPLEMENTED();
+ UNREACHABLE();
+ break;
}
// Evaluate all arguments to the function call and store in sequential
@@ -1615,12 +2456,39 @@
.StoreAccumulatorInRegister(callee);
}
- // TODO(rmcilroy): Use CallIC to allow call type feedback.
- builder()->Call(callee, receiver, args->length(),
- feedback_index(expr->CallFeedbackICSlot()));
+ builder()->SetExpressionPosition(expr);
+ builder()->Call(callee, receiver, 1 + args->length(),
+ feedback_index(expr->CallFeedbackICSlot()),
+ expr->tail_call_mode());
execution_result()->SetResultInAccumulator();
}
+void BytecodeGenerator::VisitCallSuper(Call* expr) {
+ RegisterAllocationScope register_scope(this);
+ SuperCallReference* super = expr->expression()->AsSuperCallReference();
+
+ // Prepare the constructor to the super call.
+ Register this_function = register_allocator()->NewRegister();
+ VisitForAccumulatorValue(super->this_function_var());
+ builder()
+ ->StoreAccumulatorInRegister(this_function)
+ .CallRuntime(Runtime::kInlineGetSuperConstructor, this_function, 1);
+
+ Register constructor = this_function; // Re-use dead this_function register.
+ builder()->StoreAccumulatorInRegister(constructor);
+
+ ZoneList<Expression*>* args = expr->arguments();
+ Register first_arg = VisitArguments(args);
+
+ // The new target is loaded into the accumulator from the
+ // {new.target} variable.
+ VisitForAccumulatorValue(super->new_target_var());
+
+ // Call construct.
+ builder()->SetExpressionPosition(expr);
+ builder()->New(constructor, first_arg, args->length());
+ execution_result()->SetResultInAccumulator();
+}
void BytecodeGenerator::VisitCallNew(CallNew* expr) {
Register constructor = register_allocator()->NewRegister();
@@ -1629,27 +2497,31 @@
ZoneList<Expression*>* args = expr->arguments();
Register first_arg = VisitArguments(args);
- builder()->New(constructor, first_arg, args->length());
+
+ builder()->SetExpressionPosition(expr);
+ // The accumulator holds new target which is the same as the
+ // constructor for CallNew.
+ builder()
+ ->LoadAccumulatorWithRegister(constructor)
+ .New(constructor, first_arg, args->length());
execution_result()->SetResultInAccumulator();
}
void BytecodeGenerator::VisitCallRuntime(CallRuntime* expr) {
ZoneList<Expression*>* args = expr->arguments();
- Register receiver;
if (expr->is_jsruntime()) {
// Allocate a register for the receiver and load it with undefined.
- register_allocator()->PrepareForConsecutiveAllocations(args->length() + 1);
- receiver = register_allocator()->NextConsecutiveRegister();
+ register_allocator()->PrepareForConsecutiveAllocations(1 + args->length());
+ Register receiver = register_allocator()->NextConsecutiveRegister();
builder()->LoadUndefined().StoreAccumulatorInRegister(receiver);
- }
- // Evaluate all arguments to the runtime call.
- Register first_arg = VisitArguments(args);
-
- if (expr->is_jsruntime()) {
- DCHECK(args->length() == 0 || first_arg.index() == receiver.index() + 1);
- builder()->CallJSRuntime(expr->context_index(), receiver, args->length());
+ Register first_arg = VisitArguments(args);
+ CHECK(args->length() == 0 || first_arg.index() == receiver.index() + 1);
+ builder()->CallJSRuntime(expr->context_index(), receiver,
+ 1 + args->length());
} else {
+ // Evaluate all arguments to the runtime call.
+ Register first_arg = VisitArguments(args);
Runtime::FunctionId function_id = expr->function()->function_id;
builder()->CallRuntime(function_id, first_arg, args->length());
}
@@ -1755,7 +2627,11 @@
break;
}
case VariableLocation::LOOKUP: {
- builder()->LoadLiteral(variable->name()).DeleteLookupSlot();
+ Register name_reg = register_allocator()->NewRegister();
+ builder()
+ ->LoadLiteral(variable->name())
+ .StoreAccumulatorInRegister(name_reg)
+ .CallRuntime(Runtime::kDeleteLookupSlot, name_reg, 1);
break;
}
default:
@@ -1781,7 +2657,7 @@
bool is_postfix = expr->is_postfix();
// Evaluate LHS expression and get old value.
- Register obj, key, old_value;
+ Register object, home_object, key, old_value, value;
Handle<String> name;
switch (assign_type) {
case VARIABLE: {
@@ -1792,26 +2668,53 @@
}
case NAMED_PROPERTY: {
FeedbackVectorSlot slot = property->PropertyFeedbackSlot();
- obj = VisitForRegisterValue(property->obj());
+ object = VisitForRegisterValue(property->obj());
name = property->key()->AsLiteral()->AsPropertyName();
- builder()->LoadNamedProperty(obj, name, feedback_index(slot),
- language_mode());
+ builder()->LoadNamedProperty(object, name, feedback_index(slot));
break;
}
case KEYED_PROPERTY: {
FeedbackVectorSlot slot = property->PropertyFeedbackSlot();
- obj = VisitForRegisterValue(property->obj());
+ object = VisitForRegisterValue(property->obj());
// Use visit for accumulator here since we need the key in the accumulator
// for the LoadKeyedProperty.
key = register_allocator()->NewRegister();
VisitForAccumulatorValue(property->key());
builder()->StoreAccumulatorInRegister(key).LoadKeyedProperty(
- obj, feedback_index(slot), language_mode());
+ object, feedback_index(slot));
break;
}
- case NAMED_SUPER_PROPERTY:
- case KEYED_SUPER_PROPERTY:
- UNIMPLEMENTED();
+ case NAMED_SUPER_PROPERTY: {
+ register_allocator()->PrepareForConsecutiveAllocations(4);
+ object = register_allocator()->NextConsecutiveRegister();
+ home_object = register_allocator()->NextConsecutiveRegister();
+ key = register_allocator()->NextConsecutiveRegister();
+ value = register_allocator()->NextConsecutiveRegister();
+ SuperPropertyReference* super_property =
+ property->obj()->AsSuperPropertyReference();
+ VisitForRegisterValue(super_property->this_var(), object);
+ VisitForRegisterValue(super_property->home_object(), home_object);
+ builder()
+ ->LoadLiteral(property->key()->AsLiteral()->AsPropertyName())
+ .StoreAccumulatorInRegister(key);
+ BuildNamedSuperPropertyLoad(object, home_object, key);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ register_allocator()->PrepareForConsecutiveAllocations(4);
+ object = register_allocator()->NextConsecutiveRegister();
+ home_object = register_allocator()->NextConsecutiveRegister();
+ key = register_allocator()->NextConsecutiveRegister();
+ value = register_allocator()->NextConsecutiveRegister();
+ builder()->StoreAccumulatorInRegister(value);
+ SuperPropertyReference* super_property =
+ property->obj()->AsSuperPropertyReference();
+ VisitForRegisterValue(super_property->this_var(), object);
+ VisitForRegisterValue(super_property->home_object(), home_object);
+ VisitForRegisterValue(property->key(), key);
+ BuildKeyedSuperPropertyLoad(object, home_object, key);
+ break;
+ }
}
// Convert old value into a number.
@@ -1826,29 +2729,36 @@
}
// Perform +1/-1 operation.
- builder()->CountOperation(expr->binary_op(), language_mode_strength());
+ builder()->CountOperation(expr->binary_op());
// Store the value.
FeedbackVectorSlot feedback_slot = expr->CountSlot();
switch (assign_type) {
case VARIABLE: {
Variable* variable = expr->expression()->AsVariableProxy()->var();
- VisitVariableAssignment(variable, feedback_slot);
+ VisitVariableAssignment(variable, expr->op(), feedback_slot);
break;
}
case NAMED_PROPERTY: {
- builder()->StoreNamedProperty(obj, name, feedback_index(feedback_slot),
+ builder()->StoreNamedProperty(object, name, feedback_index(feedback_slot),
language_mode());
break;
}
case KEYED_PROPERTY: {
- builder()->StoreKeyedProperty(obj, key, feedback_index(feedback_slot),
+ builder()->StoreKeyedProperty(object, key, feedback_index(feedback_slot),
language_mode());
break;
}
- case NAMED_SUPER_PROPERTY:
- case KEYED_SUPER_PROPERTY:
- UNIMPLEMENTED();
+ case NAMED_SUPER_PROPERTY: {
+ builder()->StoreAccumulatorInRegister(value);
+ BuildNamedSuperPropertyStore(object, home_object, key, value);
+ break;
+ }
+ case KEYED_SUPER_PROPERTY: {
+ builder()->StoreAccumulatorInRegister(value);
+ BuildKeyedSuperPropertyStore(object, home_object, key, value);
+ break;
+ }
}
// Restore old value for postfix expressions.
@@ -1881,7 +2791,7 @@
void BytecodeGenerator::VisitCompareOperation(CompareOperation* expr) {
Register lhs = VisitForRegisterValue(expr->left());
VisitForAccumulatorValue(expr->right());
- builder()->CompareOperation(expr->op(), lhs, language_mode_strength());
+ builder()->CompareOperation(expr->op(), lhs);
execution_result()->SetResultInAccumulator();
}
@@ -1889,7 +2799,7 @@
void BytecodeGenerator::VisitArithmeticExpression(BinaryOperation* expr) {
Register lhs = VisitForRegisterValue(expr->left());
VisitForAccumulatorValue(expr->right());
- builder()->BinaryOperation(expr->op(), lhs, language_mode_strength());
+ builder()->BinaryOperation(expr->op(), lhs);
execution_result()->SetResultInAccumulator();
}
@@ -1908,13 +2818,15 @@
void BytecodeGenerator::VisitSuperCallReference(SuperCallReference* expr) {
- UNIMPLEMENTED();
+ // Handled by VisitCall().
+ UNREACHABLE();
}
void BytecodeGenerator::VisitSuperPropertyReference(
SuperPropertyReference* expr) {
- UNIMPLEMENTED();
+ builder()->CallRuntime(Runtime::kThrowUnsupportedSuperError, Register(0), 0);
+ execution_result()->SetResultInAccumulator();
}
@@ -1962,8 +2874,7 @@
}
-void BytecodeGenerator::VisitRewritableAssignmentExpression(
- RewritableAssignmentExpression* expr) {
+void BytecodeGenerator::VisitRewritableExpression(RewritableExpression* expr) {
Visit(expr->expression());
}
@@ -2040,6 +2951,40 @@
execution_result()->SetResultInAccumulator();
}
+void BytecodeGenerator::VisitNewLocalWithContext() {
+ AccumulatorResultScope accumulator_execution_result(this);
+
+ register_allocator()->PrepareForConsecutiveAllocations(2);
+ Register extension_object = register_allocator()->NextConsecutiveRegister();
+ Register closure = register_allocator()->NextConsecutiveRegister();
+
+ builder()->StoreAccumulatorInRegister(extension_object);
+ VisitFunctionClosureForContext();
+ builder()->StoreAccumulatorInRegister(closure).CallRuntime(
+ Runtime::kPushWithContext, extension_object, 2);
+ execution_result()->SetResultInAccumulator();
+}
+
+void BytecodeGenerator::VisitNewLocalCatchContext(Variable* variable) {
+ AccumulatorResultScope accumulator_execution_result(this);
+ DCHECK(variable->IsContextSlot());
+
+ // Allocate a new local block context.
+ register_allocator()->PrepareForConsecutiveAllocations(3);
+ Register name = register_allocator()->NextConsecutiveRegister();
+ Register exception = register_allocator()->NextConsecutiveRegister();
+ Register closure = register_allocator()->NextConsecutiveRegister();
+
+ builder()
+ ->StoreAccumulatorInRegister(exception)
+ .LoadLiteral(variable->name())
+ .StoreAccumulatorInRegister(name);
+ VisitFunctionClosureForContext();
+ builder()->StoreAccumulatorInRegister(closure).CallRuntime(
+ Runtime::kPushCatchContext, name, 3);
+ execution_result()->SetResultInAccumulator();
+}
+
void BytecodeGenerator::VisitObjectLiteralAccessor(
Register home_object, ObjectLiteralProperty* property, Register value_out) {
@@ -2053,14 +2998,17 @@
}
}
-
void BytecodeGenerator::VisitSetHomeObject(Register value, Register home_object,
ObjectLiteralProperty* property,
int slot_number) {
Expression* expr = property->value();
- if (!FunctionLiteral::NeedsHomeObject(expr)) return;
-
- UNIMPLEMENTED();
+ if (FunctionLiteral::NeedsHomeObject(expr)) {
+ Handle<Name> name = isolate()->factory()->home_object_symbol();
+ FeedbackVectorSlot slot = property->GetSlot(slot_number);
+ builder()
+ ->LoadAccumulatorWithRegister(home_object)
+ .StoreNamedProperty(value, name, feedback_index(slot), language_mode());
+ }
}
@@ -2076,19 +3024,26 @@
? CreateArgumentsType::kUnmappedArguments
: CreateArgumentsType::kMappedArguments;
builder()->CreateArguments(type);
- VisitVariableAssignment(variable, FeedbackVectorSlot::Invalid());
+ VisitVariableAssignment(variable, Token::ASSIGN,
+ FeedbackVectorSlot::Invalid());
}
+void BytecodeGenerator::VisitRestArgumentsArray(Variable* rest) {
+ if (rest == nullptr) return;
+
+ // Allocate and initialize a new rest parameter and assign to the {rest}
+ // variable.
+ builder()->CreateArguments(CreateArgumentsType::kRestParameter);
+ DCHECK(rest->IsContextSlot() || rest->IsStackAllocated());
+ VisitVariableAssignment(rest, Token::ASSIGN, FeedbackVectorSlot::Invalid());
+}
void BytecodeGenerator::VisitThisFunctionVariable(Variable* variable) {
if (variable == nullptr) return;
- // TODO(rmcilroy): Remove once we have tests which exercise this code path.
- UNIMPLEMENTED();
-
// Store the closure we were called with in the given variable.
builder()->LoadAccumulatorWithRegister(Register::function_closure());
- VisitVariableAssignment(variable, FeedbackVectorSlot::Invalid());
+ VisitVariableAssignment(variable, Token::INIT, FeedbackVectorSlot::Invalid());
}
@@ -2097,7 +3052,7 @@
// Store the new target we were called with in the given variable.
builder()->LoadAccumulatorWithRegister(Register::new_target());
- VisitVariableAssignment(variable, FeedbackVectorSlot::Invalid());
+ VisitVariableAssignment(variable, Token::INIT, FeedbackVectorSlot::Invalid());
}
@@ -2114,6 +3069,12 @@
Context::NATIVE_CONTEXT_INDEX)
.StoreAccumulatorInRegister(native_context)
.LoadContextSlot(native_context, Context::CLOSURE_INDEX);
+ } else if (closure_scope->is_eval_scope()) {
+ // Contexts created by a call to eval have the same closure as the
+ // context calling eval, not the anonymous closure containing the eval
+ // code. Fetch it from the context.
+ builder()->LoadContextSlot(execution_context()->reg(),
+ Context::CLOSURE_INDEX);
} else {
DCHECK(closure_scope->is_function_scope());
builder()->LoadAccumulatorWithRegister(Register::function_closure());
@@ -2128,6 +3089,13 @@
Visit(expr);
}
+void BytecodeGenerator::VisitForAccumulatorValueOrTheHole(Expression* expr) {
+ if (expr == nullptr) {
+ builder()->LoadTheHole();
+ } else {
+ VisitForAccumulatorValue(expr);
+ }
+}
// Visits the expression |expr| and discards the result.
void BytecodeGenerator::VisitForEffect(Expression* expr) {
@@ -2144,22 +3112,19 @@
return register_scope.ResultRegister();
}
+// Visits the expression |expr| and stores the expression result in
+// |destination|.
+void BytecodeGenerator::VisitForRegisterValue(Expression* expr,
+ Register destination) {
+ AccumulatorResultScope register_scope(this);
+ Visit(expr);
+ builder()->StoreAccumulatorInRegister(destination);
+}
-Register BytecodeGenerator::NextContextRegister() const {
- if (execution_context() == nullptr) {
- // Return the incoming function context for the outermost execution context.
- return Register::function_context();
- }
- Register previous = execution_context()->reg();
- if (previous == Register::function_context()) {
- // If the previous context was the incoming function context, then the next
- // context register is the first local context register.
- return builder_.first_context_register();
- } else {
- // Otherwise use the next local context register.
- DCHECK_LT(previous.index(), builder_.last_context_register().index());
- return Register(previous.index() + 1);
- }
+void BytecodeGenerator::VisitInScope(Statement* stmt, Scope* scope) {
+ ContextScope context_scope(this, scope);
+ DCHECK(scope->declarations()->is_empty());
+ Visit(stmt);
}
@@ -2168,11 +3133,6 @@
}
-Strength BytecodeGenerator::language_mode_strength() const {
- return strength(language_mode());
-}
-
-
int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
return info()->feedback_vector()->GetIndex(slot);
}