DCHECK(!patch_site_.is_bound() && !info_emitted_);

Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);

__ bind(&patch_site_);

__ cmp(reg, reg, cr0);

__ beq(target, cr0); // Always taken before patched.

Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);

DCHECK(!patch_site_.is_bound() && !info_emitted_);

__ bind(&patch_site_);

__ cmp(reg, reg, cr0);

__ bne(target, cr0); // Never taken before patched.

if (patch_site_.is_bound()) {

int delta_to_patch_site = masm_->InstructionsGeneratedSince(&patch_site_);

Register reg;

// I believe this is using reg as the high bits of of the offset

reg.set_code(delta_to_patch_site / kOff16Mask);

__ cmpi(reg, Operand(delta_to_patch_site % kOff16Mask));

#ifdef DEBUG

info_emitted_ = true;

#endif

} else {

__ nop(); // Signals no inlined code.

}

CompilationInfo* info = info_;

profiling_counter_ = isolate()->factory()->NewCell(

Handle<Smi>(Smi::FromInt(FLAG_interrupt_budget), isolate()));

SetFunctionPosition(literal());

Comment cmnt(masm_, "[ function compiled by full code generator");

ProfileEntryHookStub::MaybeCallEntryHook(masm_);

#ifdef DEBUG

if (strlen(FLAG_stop_at) > 0 &&

info->literal()->name()->IsUtf8EqualTo(CStrVector(FLAG_stop_at))) {

__ stop("stop-at");

}

#endif

// Sloppy mode functions and builtins need to replace the receiver with the

// global proxy when called as functions (without an explicit receiver

// object).

if (info->MustReplaceUndefinedReceiverWithGlobalProxy()) {

Label ok;

int receiver_offset = info->scope()->num_parameters() * kPointerSize;

__ LoadP(r5, MemOperand(sp, receiver_offset), r0);

__ CompareRoot(r5, Heap::kUndefinedValueRootIndex);

__ bne(&ok);

__ LoadP(r5, GlobalObjectOperand());

__ LoadP(r5, FieldMemOperand(r5, GlobalObject::kGlobalProxyOffset));

__ StoreP(r5, MemOperand(sp, receiver_offset), r0);

__ bind(&ok);

}

// Open a frame scope to indicate that there is a frame on the stack. The

// MANUAL indicates that the scope shouldn't actually generate code to set up

// the frame (that is done below).

FrameScope frame_scope(masm_, StackFrame::MANUAL);

int prologue_offset = masm_->pc_offset();

if (prologue_offset) {

// Prologue logic requires it's starting address in ip and the

// corresponding offset from the function entry.

prologue_offset += Instruction::kInstrSize;

__ addi(ip, ip, Operand(prologue_offset));

}

info->set_prologue_offset(prologue_offset);

__ Prologue(info->IsCodePreAgingActive(), prologue_offset);

info->AddNoFrameRange(0, masm_->pc_offset());

{

Comment cmnt(masm_, "[ Allocate locals");

int locals_count = info->scope()->num_stack_slots();

// Generators allocate locals, if any, in context slots.

DCHECK(!IsGeneratorFunction(info->literal()->kind()) || locals_count == 0);

if (locals_count > 0) {

if (locals_count >= 128) {

Label ok;

__ Add(ip, sp, -(locals_count * kPointerSize), r0);

__ LoadRoot(r5, Heap::kRealStackLimitRootIndex);

__ cmpl(ip, r5);

__ bc_short(ge, &ok);

__ CallRuntime(Runtime::kThrowStackOverflow, 0);

__ bind(&ok);

}

__ LoadRoot(ip, Heap::kUndefinedValueRootIndex);

int kMaxPushes = FLAG_optimize_for_size ? 4 : 32;

if (locals_count >= kMaxPushes) {

int loop_iterations = locals_count / kMaxPushes;

__ mov(r5, Operand(loop_iterations));

__ mtctr(r5);

Label loop_header;

__ bind(&loop_header);

// Do pushes.

for (int i = 0; i < kMaxPushes; i++) {

__ push(ip);

}

// Continue loop if not done.

__ bdnz(&loop_header);

}

int remaining = locals_count % kMaxPushes;

// Emit the remaining pushes.

for (int i = 0; i < remaining; i++) {

__ push(ip);

}

}

}

bool function_in_register_r4 = true;

// Possibly allocate a local context.

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

// Argument to NewContext is the function, which is still in r4.

Comment cmnt(masm_, "[ Allocate context");

bool need_write_barrier = true;

int slots = info->scope()->num_heap_slots() - Context::MIN_CONTEXT_SLOTS;

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

__ push(r4);

__ Push(info->scope()->GetScopeInfo(info->isolate()));

__ CallRuntime(Runtime::kNewScriptContext, 2);

} else if (slots <= FastNewContextStub::kMaximumSlots) {

FastNewContextStub stub(isolate(), slots);

__ CallStub(&stub);

// Result of FastNewContextStub is always in new space.

need_write_barrier = false;

} else {

__ push(r4);

__ CallRuntime(Runtime::kNewFunctionContext, 1);

}

function_in_register_r4 = false;

// Context is returned in r3. It replaces the context passed to us.

// It's saved in the stack and kept live in cp.

__ mr(cp, r3);

__ StoreP(r3, MemOperand(fp, StandardFrameConstants::kContextOffset));

// Copy any necessary parameters into the context.

int num_parameters = info->scope()->num_parameters();

int first_parameter = info->scope()->has_this_declaration() ? -1 : 0;

for (int i = first_parameter; i < num_parameters; i++) {

Variable* var = (i == -1) ? scope()->receiver() : scope()->parameter(i);

if (var->IsContextSlot()) {

int parameter_offset = StandardFrameConstants::kCallerSPOffset +

(num_parameters - 1 - i) * kPointerSize;

// Load parameter from stack.

__ LoadP(r3, MemOperand(fp, parameter_offset), r0);

// Store it in the context.

MemOperand target = ContextOperand(cp, var->index());

__ StoreP(r3, target, r0);

// Update the write barrier.

if (need_write_barrier) {

__ RecordWriteContextSlot(cp, target.offset(), r3, r6,

kLRHasBeenSaved, kDontSaveFPRegs);

} else if (FLAG_debug_code) {

Label done;

__ JumpIfInNewSpace(cp, r3, &done);

__ Abort(kExpectedNewSpaceObject);

__ bind(&done);

}

}

}

}

PrepareForBailoutForId(BailoutId::Prologue(), NO_REGISTERS);

// Function register is trashed in case we bailout here. But since that

// could happen only when we allocate a context the value of

// |function_in_register_r4| is correct.

// Possibly set up a local binding to the this function which is used in

// derived constructors with super calls.

Variable* this_function_var = scope()->this_function_var();

if (this_function_var != nullptr) {

Comment cmnt(masm_, "[ This function");

if (!function_in_register_r4) {

__ LoadP(r4, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));

// The write barrier clobbers register again, keep it marked as such.

}

SetVar(this_function_var, r4, r3, r5);

}

Variable* new_target_var = scope()->new_target_var();

if (new_target_var != nullptr) {

Comment cmnt(masm_, "[ new.target");

// Get the frame pointer for the calling frame.

__ LoadP(r5, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));

// Skip the arguments adaptor frame if it exists.

__ LoadP(r4, MemOperand(r5, StandardFrameConstants::kContextOffset));

__ CmpSmiLiteral(r4, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);

Label skip;

__ bne(&skip);

__ LoadP(r5, MemOperand(r5, StandardFrameConstants::kCallerFPOffset));

__ bind(&skip);

// Check the marker in the calling frame.

__ LoadP(r4, MemOperand(r5, StandardFrameConstants::kMarkerOffset));

__ CmpSmiLiteral(r4, Smi::FromInt(StackFrame::CONSTRUCT), r0);

Label non_construct_frame, done;

function_in_register_r4 = false;

__ bne(&non_construct_frame);

__ LoadP(r3, MemOperand(

r5, ConstructFrameConstants::kOriginalConstructorOffset));

__ b(&done);

__ bind(&non_construct_frame);

__ LoadRoot(r3, Heap::kUndefinedValueRootIndex);

__ bind(&done);

SetVar(new_target_var, r3, r5, r6);

}

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

if (arguments != NULL) {

// Function uses arguments object.

Comment cmnt(masm_, "[ Allocate arguments object");

if (!function_in_register_r4) {

// Load this again, if it's used by the local context below.

__ LoadP(r6, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));

} else {

__ mr(r6, r4);

}

// Receiver is just before the parameters on the caller's stack.

int num_parameters = info->scope()->num_parameters();

int offset = num_parameters * kPointerSize;

__ addi(r5, fp, Operand(StandardFrameConstants::kCallerSPOffset + offset));

__ LoadSmiLiteral(r4, Smi::FromInt(num_parameters));

__ Push(r6, r5, r4);

// Arguments to ArgumentsAccessStub:

// function, receiver address, parameter count.

// The stub will rewrite receiver and parameter count if the previous

// stack frame was an arguments adapter frame.

ArgumentsAccessStub::Type type;

if (is_strict(language_mode()) || !has_simple_parameters()) {

type = ArgumentsAccessStub::NEW_STRICT;

} else if (literal()->has_duplicate_parameters()) {

type = ArgumentsAccessStub::NEW_SLOPPY_SLOW;

} else {

type = ArgumentsAccessStub::NEW_SLOPPY_FAST;

}

ArgumentsAccessStub stub(isolate(), type);

__ CallStub(&stub);

SetVar(arguments, r3, r4, r5);

}

if (FLAG_trace) {

__ CallRuntime(Runtime::kTraceEnter, 0);

}

// Visit the declarations and body unless there is an illegal

// redeclaration.

if (scope()->HasIllegalRedeclaration()) {

Comment cmnt(masm_, "[ Declarations");

VisitForEffect(scope()->GetIllegalRedeclaration());

} else {

PrepareForBailoutForId(BailoutId::FunctionEntry(), NO_REGISTERS);

{

Comment cmnt(masm_, "[ Declarations");

VisitDeclarations(scope()->declarations());

}

// Assert that the declarations do not use ICs. Otherwise the debugger

// won't be able to redirect a PC at an IC to the correct IC in newly

// recompiled code.

DCHECK_EQ(0, ic_total_count_);

{

Comment cmnt(masm_, "[ Stack check");

PrepareForBailoutForId(BailoutId::Declarations(), NO_REGISTERS);

Label ok;

__ LoadRoot(ip, Heap::kStackLimitRootIndex);

__ cmpl(sp, ip);

__ bc_short(ge, &ok);

__ Call(isolate()->builtins()->StackCheck(), RelocInfo::CODE_TARGET);

__ bind(&ok);

}

{

Comment cmnt(masm_, "[ Body");

DCHECK(loop_depth() == 0);

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

DCHECK(loop_depth() == 0);

}

}

// Always emit a 'return undefined' in case control fell off the end of

// the body.

{

Comment cmnt(masm_, "[ return <undefined>;");

__ LoadRoot(r3, Heap::kUndefinedValueRootIndex);

}

EmitReturnSequence();

if (HasStackOverflow()) {

masm_->AbortConstantPoolBuilding();

}

__ mov(r5, Operand(profiling_counter_));

__ LoadP(r6, FieldMemOperand(r5, Cell::kValueOffset));

__ SubSmiLiteral(r6, r6, Smi::FromInt(delta), r0);

__ StoreP(r6, FieldMemOperand(r5, Cell::kValueOffset), r0);

int reset_value = FLAG_interrupt_budget;

__ mov(r5, Operand(profiling_counter_));

__ LoadSmiLiteral(r6, Smi::FromInt(reset_value));

__ StoreP(r6, FieldMemOperand(r5, Cell::kValueOffset), r0);

Label* back_edge_target) {

Comment cmnt(masm_, "[ Back edge bookkeeping");

Label ok;

DCHECK(back_edge_target->is_bound());

int distance = masm_->SizeOfCodeGeneratedSince(back_edge_target) +

kCodeSizeMultiplier / 2;

int weight = Min(kMaxBackEdgeWeight, Max(1, distance / kCodeSizeMultiplier));

EmitProfilingCounterDecrement(weight);

{

Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);

Assembler::BlockConstantPoolEntrySharingScope prevent_entry_sharing(masm_);

// BackEdgeTable::PatchAt manipulates this sequence.

__ cmpi(r6, Operand::Zero());

__ bc_short(ge, &ok);

__ Call(isolate()->builtins()->InterruptCheck(), RelocInfo::CODE_TARGET);

// Record a mapping of this PC offset to the OSR id. This is used to find

// the AST id from the unoptimized code in order to use it as a key into

// the deoptimization input data found in the optimized code.

RecordBackEdge(stmt->OsrEntryId());

}

EmitProfilingCounterReset();

__ bind(&ok);

PrepareForBailoutForId(stmt->EntryId(), NO_REGISTERS);

// Record a mapping of the OSR id to this PC. This is used if the OSR

// entry becomes the target of a bailout. We don't expect it to be, but

// we want it to work if it is.

PrepareForBailoutForId(stmt->OsrEntryId(), NO_REGISTERS);

Comment cmnt(masm_, "[ Return sequence");

if (return_label_.is_bound()) {

__ b(&return_label_);

} else {

__ bind(&return_label_);

if (FLAG_trace) {

// Push the return value on the stack as the parameter.

// Runtime::TraceExit returns its parameter in r3

__ push(r3);

__ CallRuntime(Runtime::kTraceExit, 1);

}

// Pretend that the exit is a backwards jump to the entry.

int weight = 1;

if (info_->ShouldSelfOptimize()) {

weight = FLAG_interrupt_budget / FLAG_self_opt_count;

} else {

int distance = masm_->pc_offset() + kCodeSizeMultiplier / 2;

weight = Min(kMaxBackEdgeWeight, Max(1, distance / kCodeSizeMultiplier));

}

EmitProfilingCounterDecrement(weight);

Label ok;

__ cmpi(r6, Operand::Zero());

__ bge(&ok);

__ push(r3);

__ Call(isolate()->builtins()->InterruptCheck(), RelocInfo::CODE_TARGET);

__ pop(r3);

EmitProfilingCounterReset();

__ bind(&ok);

// Make sure that the constant pool is not emitted inside of the return

// sequence.

{

Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);

int32_t arg_count = info_->scope()->num_parameters() + 1;

int32_t sp_delta = arg_count * kPointerSize;

SetReturnPosition(literal());

int no_frame_start = __ LeaveFrame(StackFrame::JAVA_SCRIPT, sp_delta);

__ blr();

info_->AddNoFrameRange(no_frame_start, masm_->pc_offset());

}

}

Label* if_false, Label* fall_through) {

Handle<Code> ic = ToBooleanStub::GetUninitialized(isolate());

CallIC(ic, condition->test_id());

__ cmpi(result_register(), Operand::Zero());

Split(ne, if_true, if_false, fall_through);

Label* fall_through, CRegister cr) {

if (if_false == fall_through) {

__ b(cond, if_true, cr);

} else if (if_true == fall_through) {

__ b(NegateCondition(cond), if_false, cr);

} else {

__ b(cond, if_true, cr);

__ b(if_false);

}

DCHECK(var->IsStackAllocated());

// Offset is negative because higher indexes are at lower addresses.

int offset = -var->index() * kPointerSize;

// Adjust by a (parameter or local) base offset.

if (var->IsParameter()) {

offset += (info_->scope()->num_parameters() + 1) * kPointerSize;

} else {

offset += JavaScriptFrameConstants::kLocal0Offset;

}

return MemOperand(fp, offset);

DCHECK(var->IsContextSlot() || var->IsStackAllocated());

if (var->IsContextSlot()) {

int context_chain_length = scope()->ContextChainLength(var->scope());

__ LoadContext(scratch, context_chain_length);

return ContextOperand(scratch, var->index());

} else {

return StackOperand(var);

}

// Use destination as scratch.

MemOperand location = VarOperand(var, dest);

__ LoadP(dest, location, r0);

Register scratch1) {

DCHECK(var->IsContextSlot() || var->IsStackAllocated());

DCHECK(!scratch0.is(src));

DCHECK(!scratch0.is(scratch1));

DCHECK(!scratch1.is(src));

MemOperand location = VarOperand(var, scratch0);

__ StoreP(src, location, r0);

// Emit the write barrier code if the location is in the heap.

if (var->IsContextSlot()) {

__ RecordWriteContextSlot(scratch0, location.offset(), src, scratch1,

kLRHasBeenSaved, kDontSaveFPRegs);

}

bool should_normalize,

Label* if_true,

Label* if_false) {

// Only prepare for bailouts before splits if we're in a test

// context. Otherwise, we let the Visit function deal with the

// preparation to avoid preparing with the same AST id twice.

if (!context()->IsTest()) return;

Label skip;

if (should_normalize) __ b(&skip);

PrepareForBailout(expr, TOS_REG);

if (should_normalize) {

__ LoadRoot(ip, Heap::kTrueValueRootIndex);

__ cmp(r3, ip);

Split(eq, if_true, if_false, NULL);

__ bind(&skip);

}

// The variable in the declaration always resides in the current function

// context.

DCHECK_EQ(0, scope()->ContextChainLength(variable->scope()));

if (generate_debug_code_) {

// Check that we're not inside a with or catch context.

__ LoadP(r4, FieldMemOperand(cp, HeapObject::kMapOffset));

__ CompareRoot(r4, Heap::kWithContextMapRootIndex);

__ Check(ne, kDeclarationInWithContext);

__ CompareRoot(r4, Heap::kCatchContextMapRootIndex);

__ Check(ne, kDeclarationInCatchContext);

}

VariableDeclaration* declaration) {

// If it was not possible to allocate the variable at compile time, we

// need to "declare" it at runtime to make sure it actually exists in the

// local context.

VariableProxy* proxy = declaration->proxy();

VariableMode mode = declaration->mode();

Variable* variable = proxy->var();

bool hole_init = mode == LET || mode == CONST || mode == CONST_LEGACY;

switch (variable->location()) {

case VariableLocation::GLOBAL:

case VariableLocation::UNALLOCATED:

globals_->Add(variable->name(), zone());

globals_->Add(variable->binding_needs_init()

? isolate()->factory()->the_hole_value()

: isolate()->factory()->undefined_value(),

zone());

break;

case VariableLocation::PARAMETER:

case VariableLocation::LOCAL:

if (hole_init) {

Comment cmnt(masm_, "[ VariableDeclaration");

__ LoadRoot(ip, Heap::kTheHoleValueRootIndex);

__ StoreP(ip, StackOperand(variable));

}

break;

case VariableLocation::CONTEXT:

if (hole_init) {

Comment cmnt(masm_, "[ VariableDeclaration");

EmitDebugCheckDeclarationContext(variable);

__ LoadRoot(ip, Heap::kTheHoleValueRootIndex);

__ StoreP(ip, ContextOperand(cp, variable->index()), r0);

// No write barrier since the_hole_value is in old space.

PrepareForBailoutForId(proxy->id(), NO_REGISTERS);

}

break;

case VariableLocation::LOOKUP: {

Comment cmnt(masm_, "[ VariableDeclaration");

__ mov(r5, Operand(variable->name()));

// Declaration nodes are always introduced in one of four modes.

DCHECK(IsDeclaredVariableMode(mode));

// Push initial value, if any.

// Note: For variables we must not push an initial value (such as

// 'undefined') because we may have a (legal) redeclaration and we

// must not destroy the current value.

if (hole_init) {

__ LoadRoot(r3, Heap::kTheHoleValueRootIndex);

__ Push(r5, r3);

} else {

__ LoadSmiLiteral(r3, Smi::FromInt(0)); // Indicates no initial value.

__ Push(r5, r3);

}

__ CallRuntime(IsImmutableVariableMode(mode)

? Runtime::kDeclareReadOnlyLookupSlot

: Runtime::kDeclareLookupSlot,

2);

break;

}

}

FunctionDeclaration* declaration) {

VariableProxy* proxy = declaration->proxy();

Variable* variable = proxy->var();

switch (variable->location()) {

case VariableLocation::GLOBAL:

case VariableLocation::UNALLOCATED: {

globals_->Add(variable->name(), zone());

Handle<SharedFunctionInfo> function =

Compiler::GetSharedFunctionInfo(declaration->fun(), script(), info_);

// Check for stack-overflow exception.

if (function.is_null()) return SetStackOverflow();

globals_->Add(function, zone());

break;

}

case VariableLocation::PARAMETER:

case VariableLocation::LOCAL: {

Comment cmnt(masm_, "[ FunctionDeclaration");

VisitForAccumulatorValue(declaration->fun());

__ StoreP(result_register(), StackOperand(variable));

break;

}

case VariableLocation::CONTEXT: {

Comment cmnt(masm_, "[ FunctionDeclaration");

EmitDebugCheckDeclarationContext(variable);

VisitForAccumulatorValue(declaration->fun());

__ StoreP(result_register(), ContextOperand(cp, variable->index()), r0);

int offset = Context::SlotOffset(variable->index());

// We know that we have written a function, which is not a smi.

__ RecordWriteContextSlot(cp, offset, result_register(), r5,

kLRHasBeenSaved, kDontSaveFPRegs,

EMIT_REMEMBERED_SET, OMIT_SMI_CHECK);

PrepareForBailoutForId(proxy->id(), NO_REGISTERS);

break;

}

case VariableLocation::LOOKUP: {

Comment cmnt(masm_, "[ FunctionDeclaration");

__ mov(r5, Operand(variable->name()));

__ Push(r5);

// Push initial value for function declaration.

VisitForStackValue(declaration->fun());

__ CallRuntime(Runtime::kDeclareLookupSlot, 2);

break;

}

}

// Call the runtime to declare the globals.

__ mov(r4, Operand(pairs));

__ LoadSmiLiteral(r3, Smi::FromInt(DeclareGlobalsFlags()));

__ Push(r4, r3);

__ CallRuntime(Runtime::kDeclareGlobals, 2);

// Return value is ignored.

// Call the runtime to declare the modules.

__ Push(descriptions);

__ CallRuntime(Runtime::kDeclareModules, 1);

// Return value is ignored.

Comment cmnt(masm_, "[ SwitchStatement");

Breakable nested_statement(this, stmt);

SetStatementPosition(stmt);

// Keep the switch value on the stack until a case matches.

VisitForStackValue(stmt->tag());

PrepareForBailoutForId(stmt->EntryId(), NO_REGISTERS);

ZoneList<CaseClause*>* clauses = stmt->cases();

CaseClause* default_clause = NULL; // Can occur anywhere in the list.

Label next_test; // Recycled for each test.

// Compile all the tests with branches to their bodies.

for (int i = 0; i < clauses->length(); i++) {

CaseClause* clause = clauses->at(i);

clause->body_target()->Unuse();

// The default is not a test, but remember it as final fall through.

if (clause->is_default()) {

default_clause = clause;

continue;

}

Comment cmnt(masm_, "[ Case comparison");

__ bind(&next_test);

next_test.Unuse();

// Compile the label expression.

VisitForAccumulatorValue(clause->label());

// Perform the comparison as if via '==='.

__ LoadP(r4, MemOperand(sp, 0)); // Switch value.

bool inline_smi_code = ShouldInlineSmiCase(Token::EQ_STRICT);

JumpPatchSite patch_site(masm_);

if (inline_smi_code) {

Label slow_case;

__ orx(r5, r4, r3);

patch_site.EmitJumpIfNotSmi(r5, &slow_case);

__ cmp(r4, r3);

__ bne(&next_test);

__ Drop(1); // Switch value is no longer needed.

__ b(clause->body_target());

__ bind(&slow_case);

}

// Record position before stub call for type feedback.

SetExpressionPosition(clause);

Handle<Code> ic = CodeFactory::CompareIC(isolate(), Token::EQ_STRICT,

strength(language_mode())).code();

CallIC(ic, clause->CompareId());

patch_site.EmitPatchInfo();

Label skip;

__ b(&skip);

PrepareForBailout(clause, TOS_REG);

__ LoadRoot(ip, Heap::kTrueValueRootIndex);

__ cmp(r3, ip);

__ bne(&next_test);

__ Drop(1);

__ b(clause->body_target());

__ bind(&skip);

__ cmpi(r3, Operand::Zero());

__ bne(&next_test);

__ Drop(1); // Switch value is no longer needed.

__ b(clause->body_target());

}

// Discard the test value and jump to the default if present, otherwise to

// the end of the statement.

__ bind(&next_test);

__ Drop(1); // Switch value is no longer needed.

if (default_clause == NULL) {

__ b(nested_statement.break_label());

} else {

__ b(default_clause->body_target());

}

// Compile all the case bodies.

for (int i = 0; i < clauses->length(); i++) {

Comment cmnt(masm_, "[ Case body");

CaseClause* clause = clauses->at(i);

__ bind(clause->body_target());

PrepareForBailoutForId(clause->EntryId(), NO_REGISTERS);

VisitStatements(clause->statements());

}

__ bind(nested_statement.break_label());

PrepareForBailoutForId(stmt->ExitId(), NO_REGISTERS);