CMD_BREAK,

CMD_CONTINUE,

CMD_RETURN,

CMD_ASYNC_RETURN,

CMD_RETHROW

int token = GetTokenForCommand(command, statement);

DCHECK_LT(token, deferred_.size());

DCHECK_EQ(deferred_[token].command, command);

DCHECK_EQ(deferred_[token].statement, statement);

DCHECK_EQ(deferred_[token].token, token);

if (CommandUsesAccumulator(command)) {

builder()->StoreAccumulatorInRegister(result_register_);

}

builder()->LoadLiteral(Smi::FromInt(token));

builder()->StoreAccumulatorInRegister(token_register_);

if (!CommandUsesAccumulator(command)) {

// If we're not saving the accumulator in the result register, shove a

// harmless value there instead so that it is still considered "killed" in

// the liveness analysis. Normally we would LdaUndefined first, but the

// Smi token value is just as good, and by reusing it we save a bytecode.

builder()->StoreAccumulatorInRegister(result_register_);

}

if (command == CMD_RETHROW) {

// Clear message object as we enter the catch block. It will be restored

// if we rethrow.

builder()->LoadTheHole().SetPendingMessage().StoreAccumulatorInRegister(

message_register_);

}

fallthrough_from_try_block_needed_ = true;

builder()->LoadLiteral(Smi::FromInt(

static_cast<int>(TryFinallyContinuationToken::kFallthroughToken)));

builder()->StoreAccumulatorInRegister(token_register_);

// Since we're not saving the accumulator in the result register, shove a

// harmless value there instead so that it is still considered "killed" in

// the liveness analysis. Normally we would LdaUndefined first, but the Smi

// token value is just as good, and by reusing it we save a bytecode.

builder()->StoreAccumulatorInRegister(result_register_);

if (entry.command == CMD_RETHROW) {

// Pending message object is restored on exit.

builder()

->LoadAccumulatorWithRegister(message_register_)

.SetPendingMessage();

}

if (CommandUsesAccumulator(entry.command)) {

builder()->LoadAccumulatorWithRegister(result_register_);

}

execution_control()->PerformCommand(entry.command, entry.statement,

kNoSourcePosition);

if (deferred_.empty()) return;

BytecodeLabel fall_through_from_try_block;

if (deferred_.size() == 1) {

// For a single entry, just jump to the fallthrough if we don't match the

// entry token.

const Entry& entry = deferred_[0];

if (fallthrough_from_try_block_needed_) {

builder()

->LoadLiteral(Smi::FromInt(entry.token))

.CompareReference(token_register_)

.JumpIfFalse(ToBooleanMode::kAlreadyBoolean,

&fall_through_from_try_block);

}

ApplyDeferredCommand(entry);

} else {

// For multiple entries, build a jump table and switch on the token,

// jumping to the fallthrough if none of them match.

//

// If fallthrough from the try block is not needed, generate a jump table

// with one (1) fewer entries and reuse the fallthrough path for the final

// entry.

const int jump_table_base_value =

fallthrough_from_try_block_needed_ ? 0 : 1;

const int jump_table_size =

static_cast<int>(deferred_.size() - jump_table_base_value);

if (jump_table_size == 1) {

DCHECK_EQ(2, deferred_.size());

BytecodeLabel fall_through_to_final_entry;

const Entry& first_entry = deferred_[0];

const Entry& final_entry = deferred_[1];

builder()

->LoadLiteral(Smi::FromInt(first_entry.token))

.CompareReference(token_register_)

.JumpIfFalse(ToBooleanMode::kAlreadyBoolean,

&fall_through_to_final_entry);

ApplyDeferredCommand(first_entry);

builder()->Bind(&fall_through_to_final_entry);

ApplyDeferredCommand(final_entry);

} else {

BytecodeJumpTable* jump_table = builder()->AllocateJumpTable(

jump_table_size, jump_table_base_value);

builder()

->LoadAccumulatorWithRegister(token_register_)

.SwitchOnSmiNoFeedback(jump_table);

const Entry& first_entry = deferred_.front();

if (fallthrough_from_try_block_needed_) {

builder()->Jump(&fall_through_from_try_block);

builder()->Bind(jump_table, first_entry.token);

}

ApplyDeferredCommand(first_entry);

for (const Entry& entry : base::IterateWithoutFirst(deferred_)) {

builder()->Bind(jump_table, entry.token);

ApplyDeferredCommand(entry);

}

}

}

if (fallthrough_from_try_block_needed_) {

builder()->Bind(&fall_through_from_try_block);

}

if (return_token_ == -1) {

return_token_ = GetNewTokenForCommand(CMD_RETURN, nullptr);

}

return return_token_;

if (async_return_token_ == -1) {

async_return_token_ = GetNewTokenForCommand(CMD_ASYNC_RETURN, nullptr);

}

return async_return_token_;

int token = static_cast<int>(deferred_.size());

deferred_.push_back({command, statement, token});

return token;

int source_position) override {

switch (command) {

case CMD_BREAK: // We should never see break/continue in top-level.

case CMD_CONTINUE:

UNREACHABLE();

case CMD_RETURN:

// No need to pop contexts, execution leaves the method body.

generator()->BuildReturn(source_position);

return true;

case CMD_ASYNC_RETURN:

// No need to pop contexts, execution leaves the method body.

generator()->BuildAsyncReturn(source_position);

return true;

case CMD_RETHROW:

// No need to pop contexts, execution leaves the method body.

generator()->BuildReThrow();

return true;

}

return false;

BreakableStatement* statement,

BreakableControlFlowBuilder* control_builder)

: ControlScope(generator),

statement_(statement),

int source_position) override {

if (statement != statement_) return false;

switch (command) {

case CMD_BREAK:

PopContextToExpectedDepth();

control_builder_->Break();

return true;

case CMD_CONTINUE:

case CMD_RETURN:

case CMD_ASYNC_RETURN:

case CMD_RETHROW:

break;

}

return false;

IterationStatement* statement,

LoopBuilder* loop_builder)

: ControlScope(generator),

statement_(statement),

int source_position) override {

if (statement != statement_) return false;

switch (command) {

case CMD_BREAK:

PopContextToExpectedDepth();

loop_builder_->Break();

return true;

case CMD_CONTINUE:

PopContextToExpectedDepth();

loop_builder_->Continue();

return true;

case CMD_RETURN:

case CMD_ASYNC_RETURN:

case CMD_RETHROW:

break;

}

return false;

int source_position) override {

switch (command) {

case CMD_BREAK:

case CMD_CONTINUE:

case CMD_RETURN:

case CMD_ASYNC_RETURN:

break;

case CMD_RETHROW:

// No need to pop contexts, execution re-enters the method body via the

// stack unwinding mechanism which itself restores contexts correctly.

generator()->BuildReThrow();

return true;

}

return false;

TryFinallyBuilder* try_finally_builder,

DeferredCommands* commands)

: ControlScope(generator),

try_finally_builder_(try_finally_builder),

int source_position) override {

switch (command) {

case CMD_BREAK:

case CMD_CONTINUE:

case CMD_RETURN:

case CMD_ASYNC_RETURN:

case CMD_RETHROW:

PopContextToExpectedDepth();

// We don't record source_position here since we don't generate return

// bytecode right here and will generate it later as part of finally

// block. Each return bytecode generated in finally block will get own

// return source position from corresponded return statement or we'll

// use end of function if no return statement is presented.

commands_->RecordCommand(command, statement);

try_finally_builder_->LeaveTry();

return true;

}

return false;

Register result_register,

BytecodeLabels* check_return_value_labels)

: ControlScope(generator),

result_register_(result_register),

int source_position) override {

// Constructors are never async.

DCHECK_NE(CMD_ASYNC_RETURN, command);

if (command == CMD_RETURN) {

PopContextToExpectedDepth();

generator()->builder()->SetStatementPosition(source_position);

generator()->builder()->StoreAccumulatorInRegister(result_register_);

generator()->builder()->Jump(check_return_value_labels_->New());

return true;

}

return false;

: generator_(generator) {

if (generator_->block_coverage_builder_ == nullptr) return;

for (size_t i = 0; i < expr->subsequent_length(); i++) {

coverage_slots_.push_back(

generator_->AllocateNaryBlockCoverageSlotIfEnabled(expr, i));

}

if (generator_->block_coverage_builder_ == nullptr) {

return BlockCoverageBuilder::kNoCoverageArraySlot;

}

DCHECK(coverage_slots_.size() > subsequent_expr_index);

return coverage_slots_[subsequent_expr_index];

// Evaluated for its side effects.

kEffect,

// Evaluated for its value (and side effects).

kValue,

kValueAsPropertyKey,

// Evaluated for control flow (and side effects).

kTest,

: outer_(generator->execution_result()),

allocator_(generator),

kind_(kind),

type_hint_(TypeHint::kUnknown) {

generator->set_execution_result(this);

switch (fallthrough_) {

case TestFallthrough::kThen:

return TestFallthrough::kElse;

case TestFallthrough::kElse:

return TestFallthrough::kThen;

default:

return TestFallthrough::kNone;

}

BytecodeGenerator* generator,

Handle<Script> script,

IsolateT* isolate) {

DCHECK(has_constant_pool_entry_);

Handle<FixedArray> data =

isolate->factory()->NewFixedArray(entry_slots_, AllocationType::kOld);

int array_index = 0;

if (info->scope()->is_module_scope()) {

for (Declaration* decl : *info->scope()->declarations()) {

Variable* var = decl->var();

if (!var->is_used()) continue;

if (var->location() != VariableLocation::MODULE) continue;

#ifdef DEBUG

int start = array_index;

#endif

if (decl->IsFunctionDeclaration()) {

FunctionLiteral* f = static_cast<FunctionDeclaration*>(decl)->fun();

DirectHandle<SharedFunctionInfo> sfi(

Compiler::GetSharedFunctionInfo(f, script, isolate));

// Return a null handle if any initial values can't be created. Caller

// will set stack overflow.

if (sfi.is_null()) return Handle<FixedArray>();

data->set(array_index++, *sfi);

int literal_index = generator->GetCachedCreateClosureSlot(f);

data->set(array_index++, Smi::FromInt(literal_index));

DCHECK(var->IsExport());

data->set(array_index++, Smi::FromInt(var->index()));

DCHECK_EQ(start + kModuleFunctionDeclarationSize, array_index);

} else if (var->IsExport() && var->binding_needs_init()) {

data->set(array_index++, Smi::FromInt(var->index()));

DCHECK_EQ(start + kModuleVariableDeclarationSize, array_index);

}

}

} else {

for (Declaration* decl : *info->scope()->declarations()) {

Variable* var = decl->var();

if (!var->is_used()) continue;

if (var->location() != VariableLocation::UNALLOCATED) continue;

#ifdef DEBUG

int start = array_index;

#endif

if (decl->IsVariableDeclaration()) {

data->set(array_index++, *var->raw_name()->string());

DCHECK_EQ(start + kGlobalVariableDeclarationSize, array_index);

} else {

FunctionLiteral* f = static_cast<FunctionDeclaration*>(decl)->fun();

DirectHandle<SharedFunctionInfo> sfi(

Compiler::GetSharedFunctionInfo(f, script, isolate));

// Return a null handle if any initial values can't be created. Caller

// will set stack overflow.

if (sfi.is_null()) return Handle<FixedArray>();

data->set(array_index++, *sfi);

int literal_index = generator->GetCachedCreateClosureSlot(f);

data->set(array_index++, Smi::FromInt(literal_index));

DCHECK_EQ(start + kGlobalFunctionDeclarationSize, array_index);

}

}

}

DCHECK_EQ(array_index, data->length());

return data;

DCHECK(has_top_level_declaration());

DCHECK(!has_constant_pool_entry_);

constant_pool_entry_ = constant_pool_entry;

has_constant_pool_entry_ = true;

RegisterAllocationScope register_scope(generator_);

if (condition && scope_ != nullptr && !is_in_scope_) {

EnterScope();

} else if (!condition && is_in_scope_) {

ExitScope();