// For function-level control.

switch (cmd) {

case CMD_THROW:

builder()->BuildThrow(value);

return true;

case CMD_RETURN:

builder()->BuildReturn(value);

return true;

case CMD_BREAK:

case CMD_CONTINUE:

break;

}

return false;

Command command; // The command type being applied on this path.

Statement* statement; // The target statement for the command or {NULL}.

Node* token; // A token identifying this particular path.

SwitchBuilder dispatch(owner_, static_cast<int>(deferred_.size()));

dispatch.BeginSwitch();

for (size_t i = 0; i < deferred_.size(); ++i) {

Node* condition = NewPathDispatchCondition(token, deferred_[i].token);

dispatch.BeginLabel(static_cast<int>(i), condition);

dispatch.EndLabel();

}

for (size_t i = 0; i < deferred_.size(); ++i) {

dispatch.BeginCase(static_cast<int>(i));

owner_->execution_control()->PerformCommand(

deferred_[i].command, deferred_[i].statement, value);

dispatch.EndCase();

}

dispatch.EndSwitch();

if (target != target_) return false; // We are not the command target.

switch (cmd) {

case CMD_BREAK:

control_->Break();

return true;

case CMD_CONTINUE:

case CMD_THROW:

case CMD_RETURN:

break;

}

return false;

if (target != target_) return false; // We are not the command target.

switch (cmd) {

case CMD_BREAK:

control_->Break();

return true;

case CMD_CONTINUE:

control_->Continue();

return true;

case CMD_THROW:

case CMD_RETURN:

break;

}

return false;

: ControlScope(owner), control_(control) {

builder()->try_nesting_level_++; // Increment nesting.

builder()->try_catch_nesting_level_++;

switch (cmd) {

case CMD_THROW:

control_->Throw(value);

return true;

case CMD_BREAK:

case CMD_CONTINUE:

case CMD_RETURN:

break;

}

return false;

TryFinallyBuilder* control)

: ControlScope(owner), commands_(commands), control_(control) {

builder()->try_nesting_level_++; // Increment nesting.

Node* token = commands_->RecordCommand(cmd, target, value);

control_->LeaveTry(token, value);

return true;

: builder_(builder), frame_state_before_(nullptr) {

frame_state_before_ = id_before == BailoutId::None()

? builder_->jsgraph()->EmptyFrameState()

: builder_->environment()->Checkpoint(id_before);

OutputFrameStateCombine combine) {

int count = OperatorProperties::GetFrameStateInputCount(node->op());

DCHECK_LE(count, 2);

if (count >= 1) {

// Add the frame state for after the operation.

DCHECK_EQ(IrOpcode::kDead,

NodeProperties::GetFrameStateInput(node, 0)->opcode());

Node* frame_state_after =

id_after == BailoutId::None()

? builder_->jsgraph()->EmptyFrameState()

: builder_->environment()->Checkpoint(id_after, combine);

NodeProperties::ReplaceFrameStateInput(node, 0, frame_state_after);

}

if (count >= 2) {

// Add the frame state for before the operation.

DCHECK_EQ(IrOpcode::kDead,

NodeProperties::GetFrameStateInput(node, 1)->opcode());

NodeProperties::ReplaceFrameStateInput(node, 1, frame_state_before_);

}

JSGraph* jsgraph, LoopAssignmentAnalysis* loop,

JSTypeFeedbackTable* js_type_feedback)

: local_zone_(local_zone),

info_(info),

jsgraph_(jsgraph),

environment_(nullptr),

ast_context_(nullptr),

globals_(0, local_zone),

execution_control_(nullptr),

execution_context_(nullptr),

try_catch_nesting_level_(0),

try_nesting_level_(0),

input_buffer_size_(0),

input_buffer_(nullptr),

exit_controls_(local_zone),

loop_assignment_analysis_(loop),

state_values_cache_(jsgraph),

liveness_analyzer_(static_cast<size_t>(info->scope()->num_stack_slots()),

local_zone),

frame_state_function_info_(common()->CreateFrameStateFunctionInfo(

FrameStateType::kJavaScriptFunction, info->num_parameters() + 1,

info->scope()->num_stack_slots(), info->shared_info(),

CALL_MAINTAINS_NATIVE_CONTEXT)),

js_type_feedback_(js_type_feedback) {

InitializeAstVisitor(info->isolate(), local_zone);

Scope* scope = info()->scope();

DCHECK(graph() != NULL);

// Set up the basic structure of the graph. Outputs for {Start} are the formal

// parameters (including the receiver) plus context and closure.

int actual_parameter_count = info()->num_parameters_including_this() + 2;

graph()->SetStart(graph()->NewNode(common()->Start(actual_parameter_count)));

// Initialize the top-level environment.

Environment env(this, scope, graph()->start());

set_environment(&env);

if (info()->is_osr()) {

// Use OSR normal entry as the start of the top-level environment.

// It will be replaced with {Dead} after typing and optimizations.

NewNode(common()->OsrNormalEntry());

}

// Initialize the incoming context.

ContextScope incoming(this, scope, GetFunctionContext());

// Initialize control scope.

ControlScope control(this);

// TODO(mstarzinger): For now we cannot assume that the {this} parameter is

// not {the_hole}, because for derived classes {this} has a TDZ and the

// JSConstructStubForDerived magically passes {the_hole} as a receiver.

if (scope->has_this_declaration() && scope->receiver()->is_const_mode()) {

env.RawParameterBind(0, jsgraph()->TheHoleConstant());

}

// Build receiver check for sloppy mode if necessary.

// TODO(mstarzinger/verwaest): Should this be moved back into the CallIC?

if (scope->has_this_declaration()) {

Node* original_receiver = env.RawParameterLookup(0);

Node* patched_receiver = BuildPatchReceiverToGlobalProxy(original_receiver);

env.RawParameterBind(0, patched_receiver);

}

// Build function context only if there are context allocated variables.

if (info()->num_heap_slots() > 0) {

// Push a new inner context scope for the function.

Node* inner_context = BuildLocalFunctionContext(GetFunctionContext());

ContextScope top_context(this, scope, inner_context);

CreateGraphBody(stack_check);

} else {

// Simply use the outer function context in building the graph.

CreateGraphBody(stack_check);

}

// Finish the basic structure of the graph.

DCHECK_NE(0u, exit_controls_.size());

int const input_count = static_cast<int>(exit_controls_.size());

Node** const inputs = &exit_controls_.front();

Node* end = graph()->NewNode(common()->End(input_count), input_count, inputs);

graph()->SetEnd(end);

// Compute local variable liveness information and use it to relax

// frame states.

ClearNonLiveSlotsInFrameStates();

// Failures indicated by stack overflow.

return !HasStackOverflow();

Scope* scope = info()->scope();

// Build the arguments object if it is used.

BuildArgumentsObject(scope->arguments());

// Build assignment to {.this_function} variable if it is used.

BuildThisFunctionVariable(scope->this_function_var());

// Build assignment to {new.target} variable if it is used.

BuildNewTargetVariable(scope->new_target_var());

// Emit tracing call if requested to do so.

if (FLAG_trace) {

NewNode(javascript()->CallRuntime(Runtime::kTraceEnter, 0));

}

// Visit illegal re-declaration and bail out if it exists.

if (scope->HasIllegalRedeclaration()) {

VisitForEffect(scope->GetIllegalRedeclaration());

return;

}

// Visit declarations within the function scope.

VisitDeclarations(scope->declarations());

// Build a stack-check before the body.

if (stack_check) {

Node* node = NewNode(javascript()->StackCheck());

PrepareFrameState(node, BailoutId::FunctionEntry());

}

// Visit statements in the function body.

VisitStatements(info()->literal()->body());

// Emit tracing call if requested to do so.

if (FLAG_trace) {

// TODO(mstarzinger): Only traces implicit return.

Node* return_value = jsgraph()->UndefinedConstant();

NewNode(javascript()->CallRuntime(Runtime::kTraceExit, 1), return_value);

}

// Return 'undefined' in case we can fall off the end.

BuildReturn(jsgraph()->UndefinedConstant());

if (!FLAG_analyze_environment_liveness ||

!info()->is_deoptimization_enabled()) {

return;

}

NonLiveFrameStateSlotReplacer replacer(

&state_values_cache_, jsgraph()->UndefinedConstant(),

liveness_analyzer()->local_count(), local_zone());

Variable* arguments = info()->scope()->arguments();

if (arguments != nullptr && arguments->IsStackAllocated()) {

replacer.MarkPermanentlyLive(arguments->index());

}

liveness_analyzer()->Run(&replacer);

if (FLAG_trace_environment_liveness) {

OFStream os(stdout);

liveness_analyzer()->Print(os);

}

if (expr == NULL) {

return environment()->Push(jsgraph()->NullConstant());

}

VisitForValue(expr);

if (expr == NULL) {

return environment()->Push(jsgraph()->TheHoleConstant());

}

VisitForValue(expr);