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

Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);

__ bind(&patch_site_);

__ andi(at, reg, 0);

// Always taken before patched.

__ BranchShort(target, eq, at, Operand(zero_reg));

Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);

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

__ bind(&patch_site_);

__ andi(at, reg, 0);

// Never taken before patched.

__ BranchShort(target, ne, at, Operand(zero_reg));

if (patch_site_.is_bound()) {

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

Register reg = Register::from_code(delta_to_patch_site / kImm16Mask);

__ andi(zero_reg, reg, delta_to_patch_site % kImm16Mask);

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

__ lw(at, MemOperand(sp, receiver_offset));

__ LoadRoot(a2, Heap::kUndefinedValueRootIndex);

__ Branch(&ok, ne, a2, Operand(at));

__ lw(a2, GlobalObjectOperand());

__ lw(a2, FieldMemOperand(a2, GlobalObject::kGlobalProxyOffset));

__ sw(a2, MemOperand(sp, receiver_offset));

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

info->set_prologue_offset(masm_->pc_offset());

__ Prologue(info->IsCodePreAgingActive());

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;

__ Subu(t5, sp, Operand(locals_count * kPointerSize));

__ LoadRoot(a2, Heap::kRealStackLimitRootIndex);

__ Branch(&ok, hs, t5, Operand(a2));

__ CallRuntime(Runtime::kThrowStackOverflow, 0);

__ bind(&ok);

}

__ LoadRoot(t5, Heap::kUndefinedValueRootIndex);

int kMaxPushes = FLAG_optimize_for_size ? 4 : 32;

if (locals_count >= kMaxPushes) {

int loop_iterations = locals_count / kMaxPushes;

__ li(a2, Operand(loop_iterations));

Label loop_header;

__ bind(&loop_header);

// Do pushes.

__ Subu(sp, sp, Operand(kMaxPushes * kPointerSize));

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

__ sw(t5, MemOperand(sp, i * kPointerSize));

}

// Continue loop if not done.

__ Subu(a2, a2, Operand(1));

__ Branch(&loop_header, ne, a2, Operand(zero_reg));

}

int remaining = locals_count % kMaxPushes;

// Emit the remaining pushes.

__ Subu(sp, sp, Operand(remaining * kPointerSize));

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

__ sw(t5, MemOperand(sp, i * kPointerSize));

}

}

}

bool function_in_register_a1 = true;

// Possibly allocate a local context.

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

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

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

bool need_write_barrier = true;

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

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

__ push(a1);

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

__ CallRuntime(Runtime::kNewFunctionContext, 1);

}

function_in_register_a1 = false;

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

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

__ mov(cp, v0);

__ sw(v0, 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.

__ lw(a0, MemOperand(fp, parameter_offset));

// Store it in the context.

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

__ sw(a0, target);

// Update the write barrier.

if (need_write_barrier) {

__ RecordWriteContextSlot(

cp, target.offset(), a0, a3, kRAHasBeenSaved, kDontSaveFPRegs);

} else if (FLAG_debug_code) {

Label done;

__ JumpIfInNewSpace(cp, a0, &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_a1| 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_a1) {

__ lw(a1, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));

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

}

SetVar(this_function_var, a1, a2, a3);

}

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.

__ lw(a2, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));

// Skip the arguments adaptor frame if it exists.

Label check_frame_marker;

__ lw(a1, MemOperand(a2, StandardFrameConstants::kContextOffset));

__ Branch(&check_frame_marker, ne, a1,

Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));

__ lw(a2, MemOperand(a2, StandardFrameConstants::kCallerFPOffset));

// Check the marker in the calling frame.

__ bind(&check_frame_marker);

__ lw(a1, MemOperand(a2, StandardFrameConstants::kMarkerOffset));

function_in_register_a1 = false;

Label non_construct_frame, done;

__ Branch(&non_construct_frame, ne, a1,

Operand(Smi::FromInt(StackFrame::CONSTRUCT)));

__ lw(v0,

MemOperand(a2, ConstructFrameConstants::kOriginalConstructorOffset));

__ Branch(&done);

__ bind(&non_construct_frame);

__ LoadRoot(v0, Heap::kUndefinedValueRootIndex);

__ bind(&done);

SetVar(new_target_var, v0, a2, a3);

}

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

if (arguments != NULL) {

// Function uses arguments object.

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

if (!function_in_register_a1) {

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

__ lw(a3, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));

} else {

__ mov(a3, a1);

}

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

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

int offset = num_parameters * kPointerSize;

__ Addu(a2, fp,

Operand(StandardFrameConstants::kCallerSPOffset + offset));

__ li(a1, Operand(Smi::FromInt(num_parameters)));

__ Push(a3, a2, a1);

// Arguments to ArgumentsAccessStub:

// function, receiver address, parameter count.

// The stub will rewrite receiever 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, v0, a1, a2);

}

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(at, Heap::kStackLimitRootIndex);

__ Branch(&ok, hs, sp, Operand(at));

Handle<Code> stack_check = isolate()->builtins()->StackCheck();

PredictableCodeSizeScope predictable(masm_,

masm_->CallSize(stack_check, RelocInfo::CODE_TARGET));

__ Call(stack_check, 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(v0, Heap::kUndefinedValueRootIndex);

}

EmitReturnSequence();

__ li(a2, Operand(profiling_counter_));

__ lw(a3, FieldMemOperand(a2, Cell::kValueOffset));

__ Subu(a3, a3, Operand(Smi::FromInt(delta)));

__ sw(a3, FieldMemOperand(a2, Cell::kValueOffset));

int reset_value = FLAG_interrupt_budget;

if (info_->is_debug()) {

// Detect debug break requests as soon as possible.

reset_value = FLAG_interrupt_budget >> 4;

}

__ li(a2, Operand(profiling_counter_));

__ li(a3, Operand(Smi::FromInt(reset_value)));

__ sw(a3, FieldMemOperand(a2, Cell::kValueOffset));

Label* back_edge_target) {

// The generated code is used in Deoptimizer::PatchStackCheckCodeAt so we need

// to make sure it is constant. Branch may emit a skip-or-jump sequence

// instead of the normal Branch. It seems that the "skip" part of that

// sequence is about as long as this Branch would be so it is safe to ignore

// that.

Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);

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

Label ok;

DCHECK(back_edge_target->is_bound());

int distance = masm_->SizeOfCodeGeneratedSince(back_edge_target);

int weight = Min(kMaxBackEdgeWeight,

Max(1, distance / kCodeSizeMultiplier));

EmitProfilingCounterDecrement(weight);

__ slt(at, a3, zero_reg);

__ beq(at, zero_reg, &ok);

// Call will emit a li t9 first, so it is safe to use the delay slot.

__ 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()) {

__ Branch(&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 v0.

__ push(v0);

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

weight = Min(kMaxBackEdgeWeight,

Max(1, distance / kCodeSizeMultiplier));

}

EmitProfilingCounterDecrement(weight);

Label ok;

__ Branch(&ok, ge, a3, Operand(zero_reg));

__ push(v0);

__ Call(isolate()->builtins()->InterruptCheck(),

RelocInfo::CODE_TARGET);

__ pop(v0);

EmitProfilingCounterReset();

__ bind(&ok);

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

// sequence.

{ Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);

// Here we use masm_-> instead of the __ macro to avoid the code coverage

// tool from instrumenting as we rely on the code size here.

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

int32_t sp_delta = arg_count * kPointerSize;

SetReturnPosition(literal());

masm_->mov(sp, fp);

int no_frame_start = masm_->pc_offset();

masm_->MultiPop(static_cast<RegList>(fp.bit() | ra.bit()));

masm_->Addu(sp, sp, Operand(sp_delta));

masm_->Jump(ra);

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

}

}

Label* if_true,

Label* if_false,

Label* fall_through) {

__ mov(a0, result_register());

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

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

__ mov(at, zero_reg);

Split(ne, v0, Operand(at), if_true, if_false, fall_through);

Register lhs,

const Operand& rhs,

Label* if_true,

Label* if_false,

Label* fall_through) {

if (if_false == fall_through) {

__ Branch(if_true, cc, lhs, rhs);

} else if (if_true == fall_through) {

__ Branch(if_false, NegateCondition(cc), lhs, rhs);

} else {

__ Branch(if_true, cc, lhs, rhs);

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

__ lw(dest, location);

Register src,

Register scratch0,

Register scratch1) {

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

DCHECK(!scratch0.is(src));

DCHECK(!scratch0.is(scratch1));

DCHECK(!scratch1.is(src));

MemOperand location = VarOperand(var, scratch0);

__ sw(src, location);

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

if (var->IsContextSlot()) {

__ RecordWriteContextSlot(scratch0,

location.offset(),

src,

scratch1,

kRAHasBeenSaved,

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) __ Branch(&skip);

PrepareForBailout(expr, TOS_REG);

if (should_normalize) {

__ LoadRoot(t0, Heap::kTrueValueRootIndex);

Split(eq, a0, Operand(t0), 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.

__ lw(a1, FieldMemOperand(cp, HeapObject::kMapOffset));

__ LoadRoot(t0, Heap::kWithContextMapRootIndex);

__ Check(ne, kDeclarationInWithContext,

a1, Operand(t0));

__ LoadRoot(t0, Heap::kCatchContextMapRootIndex);

__ Check(ne, kDeclarationInCatchContext,

a1, Operand(t0));

}

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(t0, Heap::kTheHoleValueRootIndex);

__ sw(t0, StackOperand(variable));

}

break;

case VariableLocation::CONTEXT:

if (hole_init) {

Comment cmnt(masm_, "[ VariableDeclaration");

EmitDebugCheckDeclarationContext(variable);

__ LoadRoot(at, Heap::kTheHoleValueRootIndex);

__ sw(at, ContextOperand(cp, variable->index()));

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

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

}

break;

case VariableLocation::LOOKUP: {

Comment cmnt(masm_, "[ VariableDeclaration");

__ li(a2, 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(a0, Heap::kTheHoleValueRootIndex);

} else {

DCHECK(Smi::FromInt(0) == 0);

__ mov(a0, zero_reg); // Smi::FromInt(0) indicates no initial value.

}

__ Push(a2, a0);

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

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

break;

}

case VariableLocation::CONTEXT: {

Comment cmnt(masm_, "[ FunctionDeclaration");

EmitDebugCheckDeclarationContext(variable);

VisitForAccumulatorValue(declaration->fun());

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

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

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

__ RecordWriteContextSlot(cp,

offset,

result_register(),

a2,

kRAHasBeenSaved,

kDontSaveFPRegs,

EMIT_REMEMBERED_SET,

OMIT_SMI_CHECK);

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

break;

}

case VariableLocation::LOOKUP: {

Comment cmnt(masm_, "[ FunctionDeclaration");

__ li(a2, Operand(variable->name()));

__ Push(a2);

// Push initial value for function declaration.

VisitForStackValue(declaration->fun());

__ CallRuntime(Runtime::kDeclareLookupSlot, 2);

break;

}

}

// Call the runtime to declare the globals.

__ li(a1, Operand(pairs));

__ li(a0, Operand(Smi::FromInt(DeclareGlobalsFlags())));

__ Push(a1, a0);

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

__ mov(a0, result_register()); // CompareStub requires args in a0, a1.

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

__ lw(a1, MemOperand(sp, 0)); // Switch value.

bool inline_smi_code = ShouldInlineSmiCase(Token::EQ_STRICT);

JumpPatchSite patch_site(masm_);

if (inline_smi_code) {

Label slow_case;

__ or_(a2, a1, a0);

patch_site.EmitJumpIfNotSmi(a2, &slow_case);

__ Branch(&next_test, ne, a1, Operand(a0));

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

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