Skip to content

V
V8
Commit 2c674d4c authored by palfia@homejinni.com's avatar palfia@homejinni.com
Browse files
Options

MIPS: Use the HandlerFrontendHeader in most call compilers. 

Port r18125 (e541c68d)

BUG=
R=gergely@homejinni.com

Review URL: https://codereview.chromium.org/96043002

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@18142 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
parent 268f224f
Show whitespace changes
Inline Side-by-side
Showing with 115 additions and 332 deletions
src/mips/stub-cache-mips.cc
View file @ 2c674d4c
...@@ -746,11 +746,11 @@ static void GenerateCallFunction(MacroAssembler* masm, ...@@ -746,11 +746,11 @@ static void GenerateCallFunction(MacroAssembler* masm,
__ GetObjectType(a1, a3, a3); __ GetObjectType(a1, a3, a3);
__ Branch(miss, ne, a3, Operand(JS_FUNCTION_TYPE)); __ Branch(miss, ne, a3, Operand(JS_FUNCTION_TYPE));
// Patch the receiver on the stack with the global proxy if
// necessary.
if (object->IsGlobalObject()) { if (object->IsGlobalObject()) {
const int argc = arguments.immediate();
const int receiver_offset = argc * kPointerSize;
__ lw(a3, FieldMemOperand(a0, GlobalObject::kGlobalReceiverOffset)); __ lw(a3, FieldMemOperand(a0, GlobalObject::kGlobalReceiverOffset));
__ sw(a3, MemOperand(sp, arguments.immediate() * kPointerSize)); __ sw(a3, MemOperand(sp, receiver_offset));
} }
// Invoke the function. // Invoke the function.
...@@ -1527,25 +1527,6 @@ void CallStubCompiler::GenerateNameCheck(Handle<Name> name, Label* miss) { ...@@ -1527,25 +1527,6 @@ void CallStubCompiler::GenerateNameCheck(Handle<Name> name, Label* miss) {
} }
void CallStubCompiler::GenerateGlobalReceiverCheck(Handle<JSObject> object,
Handle<JSObject> holder,
Handle<Name> name,
Label* miss) {
ASSERT(holder->IsGlobalObject());
// Get the number of arguments.
const int argc = arguments().immediate();
// Get the receiver from the stack.
__ lw(a0, MemOperand(sp, argc * kPointerSize));
// Check that the maps haven't changed.
__ JumpIfSmi(a0, miss);
CheckPrototypes(
IC::CurrentTypeOf(object, isolate()), a0, holder, a3, a1, t0, name, miss);
}
void CallStubCompiler::GenerateLoadFunctionFromCell( void CallStubCompiler::GenerateLoadFunctionFromCell(
Handle<Cell> cell, Handle<Cell> cell,
Handle<JSFunction> function, Handle<JSFunction> function,
...@@ -1588,33 +1569,16 @@ Handle<Code> CallStubCompiler::CompileCallField(Handle<JSObject> object, ...@@ -1588,33 +1569,16 @@ Handle<Code> CallStubCompiler::CompileCallField(Handle<JSObject> object,
Handle<JSObject> holder, Handle<JSObject> holder,
PropertyIndex index, PropertyIndex index,
Handle<Name> name) { Handle<Name> name) {
// ----------- S t a t e -------------
// -- a2 : name
// -- ra : return address
// -----------------------------------
Label miss; Label miss;
GenerateNameCheck(name, &miss); Register reg = HandlerFrontendHeader(
object, holder, name, RECEIVER_MAP_CHECK, &miss);
const int argc = arguments().immediate();
// Get the receiver of the function from the stack into a0.
__ lw(a0, MemOperand(sp, argc * kPointerSize));
// Check that the receiver isn't a smi.
__ JumpIfSmi(a0, &miss, t0);
// Do the right check and compute the holder register.
Register reg = CheckPrototypes(
IC::CurrentTypeOf(object, isolate()),
a0, holder, a1, a3, t0, name, &miss);
GenerateFastPropertyLoad(masm(), a1, reg, index.is_inobject(holder), GenerateFastPropertyLoad(masm(), a1, reg, index.is_inobject(holder),
index.translate(holder), Representation::Tagged()); index.translate(holder), Representation::Tagged());
GenerateCallFunction(masm(), object, arguments(), &miss, extra_state_); GenerateCallFunction(masm(), object, arguments(), &miss, extra_state_);
// Handle call cache miss. HandlerFrontendFooter(&miss);
__ bind(&miss);
GenerateMissBranch();
// Return the generated code. // Return the generated code.
return GetCode(Code::FAST, name); return GetCode(Code::FAST, name);
...@@ -1630,31 +1594,16 @@ Handle<Code> CallStubCompiler::CompileArrayCodeCall( ...@@ -1630,31 +1594,16 @@ Handle<Code> CallStubCompiler::CompileArrayCodeCall(
Code::StubType type) { Code::StubType type) {
Label miss; Label miss;
// Check that function is still array. HandlerFrontendHeader(object, holder, name, RECEIVER_MAP_CHECK, &miss);
const int argc = arguments().immediate(); if (!cell.is_null()) {
GenerateNameCheck(name, &miss);
Register receiver = a1;
if (cell.is_null()) {
__ lw(receiver, MemOperand(sp, argc * kPointerSize));
// Check that the receiver isn't a smi.
__ JumpIfSmi(receiver, &miss);
// Check that the maps haven't changed.
CheckPrototypes(
IC::CurrentTypeOf(object, isolate()), receiver, holder,
a3, a0, t0, name, &miss);
} else {
ASSERT(cell->value() == *function); ASSERT(cell->value() == *function);
GenerateGlobalReceiverCheck(Handle<JSObject>::cast(object), holder, name,
&miss);
GenerateLoadFunctionFromCell(cell, function, &miss); GenerateLoadFunctionFromCell(cell, function, &miss);
} }
Handle<AllocationSite> site = isolate()->factory()->NewAllocationSite(); Handle<AllocationSite> site = isolate()->factory()->NewAllocationSite();
site->SetElementsKind(GetInitialFastElementsKind()); site->SetElementsKind(GetInitialFastElementsKind());
Handle<Cell> site_feedback_cell = isolate()->factory()->NewCell(site); Handle<Cell> site_feedback_cell = isolate()->factory()->NewCell(site);
const int argc = arguments().immediate();
__ li(a0, Operand(argc)); __ li(a0, Operand(argc));
__ li(a2, Operand(site_feedback_cell)); __ li(a2, Operand(site_feedback_cell));
__ li(a1, Operand(function)); __ li(a1, Operand(function));
...@@ -1662,8 +1611,7 @@ Handle<Code> CallStubCompiler::CompileArrayCodeCall( ...@@ -1662,8 +1611,7 @@ Handle<Code> CallStubCompiler::CompileArrayCodeCall(
ArrayConstructorStub stub(isolate()); ArrayConstructorStub stub(isolate());
__ TailCallStub(&stub); __ TailCallStub(&stub);
__ bind(&miss); HandlerFrontendFooter(&miss);
GenerateMissBranch();
// Return the generated code. // Return the generated code.
return GetCode(type, name); return GetCode(type, name);
...@@ -1677,14 +1625,6 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall( ...@@ -1677,14 +1625,6 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall(
Handle<JSFunction> function, Handle<JSFunction> function,
Handle<String> name, Handle<String> name,
Code::StubType type) { Code::StubType type) {
// ----------- S t a t e -------------
// -- a2 : name
// -- ra : return address
// -- sp[(argc - n - 1) * 4] : arg[n] (zero-based)
// -- ...
// -- sp[argc * 4] : receiver
// -----------------------------------
// If object is not an array or is observed, bail out to regular call. // If object is not an array or is observed, bail out to regular call.
if (!object->IsJSArray() || if (!object->IsJSArray() ||
!cell.is_null() || !cell.is_null() ||
...@@ -1693,22 +1633,11 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall( ...@@ -1693,22 +1633,11 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall(
} }
Label miss; Label miss;
HandlerFrontendHeader(object, holder, name, RECEIVER_MAP_CHECK, &miss);
Register receiver = a0;
Register scratch = a1;
GenerateNameCheck(name, &miss);
Register receiver = a1;
// Get the receiver from the stack.
const int argc = arguments().immediate(); const int argc = arguments().immediate();
__ lw(receiver, MemOperand(sp, argc * kPointerSize));
// Check that the receiver isn't a smi.
__ JumpIfSmi(receiver, &miss);
// Check that the maps haven't changed.
CheckPrototypes(
IC::CurrentTypeOf(object, isolate()), receiver, holder,
a3, v0, t0, name, &miss);
if (argc == 0) { if (argc == 0) {
// Nothing to do, just return the length. // Nothing to do, just return the length.
...@@ -1726,34 +1655,34 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall( ...@@ -1726,34 +1655,34 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall(
// Check that the elements are in fast mode and writable. // Check that the elements are in fast mode and writable.
__ CheckMap(elements, __ CheckMap(elements,
v0, scratch,
Heap::kFixedArrayMapRootIndex, Heap::kFixedArrayMapRootIndex,
&check_double, &check_double,
DONT_DO_SMI_CHECK); DONT_DO_SMI_CHECK);
// Get the array's length into v0 and calculate new length. // Get the array's length into scratch and calculate new length.
__ lw(v0, FieldMemOperand(receiver, JSArray::kLengthOffset)); __ lw(scratch, FieldMemOperand(receiver, JSArray::kLengthOffset));
STATIC_ASSERT(kSmiTagSize == 1); STATIC_ASSERT(kSmiTagSize == 1);
STATIC_ASSERT(kSmiTag == 0); STATIC_ASSERT(kSmiTag == 0);
__ Addu(v0, v0, Operand(Smi::FromInt(argc))); __ Addu(scratch, scratch, Operand(Smi::FromInt(argc)));
// Get the elements' length. // Get the elements' length.
__ lw(t0, FieldMemOperand(elements, FixedArray::kLengthOffset)); __ lw(t0, FieldMemOperand(elements, FixedArray::kLengthOffset));
// Check if we could survive without allocation. // Check if we could survive without allocation.
__ Branch(&attempt_to_grow_elements, gt, v0, Operand(t0)); __ Branch(&attempt_to_grow_elements, gt, scratch, Operand(t0));
// Check if value is a smi. // Check if value is a smi.
__ lw(t0, MemOperand(sp, (argc - 1) * kPointerSize)); __ lw(t0, MemOperand(sp, (argc - 1) * kPointerSize));
__ JumpIfNotSmi(t0, &with_write_barrier); __ JumpIfNotSmi(t0, &with_write_barrier);
// Save new length. // Save new length.
__ sw(v0, FieldMemOperand(receiver, JSArray::kLengthOffset)); __ sw(scratch, FieldMemOperand(receiver, JSArray::kLengthOffset));
// Store the value. // Store the value.
// We may need a register containing the address end_elements below, // We may need a register containing the address end_elements below,
// so write back the value in end_elements. // so write back the value in end_elements.
__ sll(end_elements, v0, kPointerSizeLog2 - kSmiTagSize); __ sll(end_elements, scratch, kPointerSizeLog2 - kSmiTagSize);
__ Addu(end_elements, elements, end_elements); __ Addu(end_elements, elements, end_elements);
const int kEndElementsOffset = const int kEndElementsOffset =
FixedArray::kHeaderSize - kHeapObjectTag - argc * kPointerSize; FixedArray::kHeaderSize - kHeapObjectTag - argc * kPointerSize;
...@@ -1761,38 +1690,39 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall( ...@@ -1761,38 +1690,39 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall(
__ sw(t0, MemOperand(end_elements)); __ sw(t0, MemOperand(end_elements));
// Check for a smi. // Check for a smi.
__ mov(v0, scratch);
__ DropAndRet(argc + 1); __ DropAndRet(argc + 1);
__ bind(&check_double); __ bind(&check_double);
// Check that the elements are in fast mode and writable. // Check that the elements are in fast mode and writable.
__ CheckMap(elements, __ CheckMap(elements,
a0, scratch,
Heap::kFixedDoubleArrayMapRootIndex, Heap::kFixedDoubleArrayMapRootIndex,
&call_builtin, &call_builtin,
DONT_DO_SMI_CHECK); DONT_DO_SMI_CHECK);
// Get the array's length into v0 and calculate new length. // Get the array's length into scratch and calculate new length.
__ lw(v0, FieldMemOperand(receiver, JSArray::kLengthOffset)); __ lw(scratch, FieldMemOperand(receiver, JSArray::kLengthOffset));
STATIC_ASSERT(kSmiTagSize == 1); STATIC_ASSERT(kSmiTagSize == 1);
STATIC_ASSERT(kSmiTag == 0); STATIC_ASSERT(kSmiTag == 0);
__ Addu(v0, v0, Operand(Smi::FromInt(argc))); __ Addu(scratch, scratch, Operand(Smi::FromInt(argc)));
// Get the elements' length. // Get the elements' length.
__ lw(t0, FieldMemOperand(elements, FixedArray::kLengthOffset)); __ lw(t0, FieldMemOperand(elements, FixedArray::kLengthOffset));
// Check if we could survive without allocation. // Check if we could survive without allocation.
__ Branch(&call_builtin, gt, v0, Operand(t0)); __ Branch(&call_builtin, gt, scratch, Operand(t0));
__ lw(t0, MemOperand(sp, (argc - 1) * kPointerSize)); __ lw(t0, MemOperand(sp, (argc - 1) * kPointerSize));
__ StoreNumberToDoubleElements( __ StoreNumberToDoubleElements(
t0, v0, elements, a3, t1, a2, t0, scratch, elements, a3, t1, a2,
&call_builtin, argc * kDoubleSize); &call_builtin, argc * kDoubleSize);
// Save new length. // Save new length.
__ sw(v0, FieldMemOperand(receiver, JSArray::kLengthOffset)); __ sw(scratch, FieldMemOperand(receiver, JSArray::kLengthOffset));
// Check for a smi. __ mov(v0, scratch);
__ DropAndRet(argc + 1); __ DropAndRet(argc + 1);
__ bind(&with_write_barrier); __ bind(&with_write_barrier);
...@@ -1842,12 +1772,12 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall( ...@@ -1842,12 +1772,12 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall(
} }
// Save new length. // Save new length.
__ sw(v0, FieldMemOperand(receiver, JSArray::kLengthOffset)); __ sw(scratch, FieldMemOperand(receiver, JSArray::kLengthOffset));
// Store the value. // Store the value.
// We may need a register containing the address end_elements below, // We may need a register containing the address end_elements below,
// so write back the value in end_elements. // so write back the value in end_elements.
__ sll(end_elements, v0, kPointerSizeLog2 - kSmiTagSize); __ sll(end_elements, scratch, kPointerSizeLog2 - kSmiTagSize);
__ Addu(end_elements, elements, end_elements); __ Addu(end_elements, elements, end_elements);
__ Addu(end_elements, end_elements, kEndElementsOffset); __ Addu(end_elements, end_elements, kEndElementsOffset);
__ sw(t0, MemOperand(end_elements)); __ sw(t0, MemOperand(end_elements));
...@@ -1859,10 +1789,11 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall( ...@@ -1859,10 +1789,11 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall(
kDontSaveFPRegs, kDontSaveFPRegs,
EMIT_REMEMBERED_SET, EMIT_REMEMBERED_SET,
OMIT_SMI_CHECK); OMIT_SMI_CHECK);
__ mov(v0, scratch);
__ DropAndRet(argc + 1); __ DropAndRet(argc + 1);
__ bind(&attempt_to_grow_elements); __ bind(&attempt_to_grow_elements);
// v0: array's length + 1. // scratch: array's length + 1.
// t0: elements' length. // t0: elements' length.
if (!FLAG_inline_new) { if (!FLAG_inline_new) {
...@@ -1885,7 +1816,7 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall( ...@@ -1885,7 +1816,7 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall(
const int kAllocationDelta = 4; const int kAllocationDelta = 4;
// Load top and check if it is the end of elements. // Load top and check if it is the end of elements.
__ sll(end_elements, v0, kPointerSizeLog2 - kSmiTagSize); __ sll(end_elements, scratch, kPointerSizeLog2 - kSmiTagSize);
__ Addu(end_elements, elements, end_elements); __ Addu(end_elements, elements, end_elements);
__ Addu(end_elements, end_elements, Operand(kEndElementsOffset)); __ Addu(end_elements, end_elements, Operand(kEndElementsOffset));
__ li(t3, Operand(new_space_allocation_top)); __ li(t3, Operand(new_space_allocation_top));
...@@ -1909,11 +1840,12 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall( ...@@ -1909,11 +1840,12 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall(
} }
// Update elements' and array's sizes. // Update elements' and array's sizes.
__ sw(v0, FieldMemOperand(receiver, JSArray::kLengthOffset)); __ sw(scratch, FieldMemOperand(receiver, JSArray::kLengthOffset));
__ Addu(t0, t0, Operand(Smi::FromInt(kAllocationDelta))); __ Addu(t0, t0, Operand(Smi::FromInt(kAllocationDelta)));
__ sw(t0, FieldMemOperand(elements, FixedArray::kLengthOffset)); __ sw(t0, FieldMemOperand(elements, FixedArray::kLengthOffset));
// Elements are in new space, so write barrier is not required. // Elements are in new space, so write barrier is not required.
__ mov(v0, scratch);
__ DropAndRet(argc + 1); __ DropAndRet(argc + 1);
} }
__ bind(&call_builtin); __ bind(&call_builtin);
...@@ -1921,9 +1853,7 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall( ...@@ -1921,9 +1853,7 @@ Handle<Code> CallStubCompiler::CompileArrayPushCall(
ExternalReference(Builtins::c_ArrayPush, isolate()), argc + 1, 1); ExternalReference(Builtins::c_ArrayPush, isolate()), argc + 1, 1);
} }
// Handle call cache miss. HandlerFrontendFooter(&miss);
__ bind(&miss);
GenerateMissBranch();
// Return the generated code. // Return the generated code.
return GetCode(type, name); return GetCode(type, name);
...@@ -1937,14 +1867,6 @@ Handle<Code> CallStubCompiler::CompileArrayPopCall( ...@@ -1937,14 +1867,6 @@ Handle<Code> CallStubCompiler::CompileArrayPopCall(
Handle<JSFunction> function, Handle<JSFunction> function,
Handle<String> name, Handle<String> name,
Code::StubType type) { Code::StubType type) {
// ----------- S t a t e -------------
// -- a2 : name
// -- ra : return address
// -- sp[(argc - n - 1) * 4] : arg[n] (zero-based)
// -- ...
// -- sp[argc * 4] : receiver
// -----------------------------------
// If object is not an array or is observed, bail out to regular call. // If object is not an array or is observed, bail out to regular call.
if (!object->IsJSArray() || if (!object->IsJSArray() ||
!cell.is_null() || !cell.is_null() ||
...@@ -1953,27 +1875,17 @@ Handle<Code> CallStubCompiler::CompileArrayPopCall( ...@@ -1953,27 +1875,17 @@ Handle<Code> CallStubCompiler::CompileArrayPopCall(
} }
Label miss, return_undefined, call_builtin; Label miss, return_undefined, call_builtin;
Register receiver = a1; Register receiver = a0;
Register scratch = a1;
Register elements = a3; Register elements = a3;
GenerateNameCheck(name, &miss); HandlerFrontendHeader(object, holder, name, RECEIVER_MAP_CHECK, &miss);
// Get the receiver from the stack.
const int argc = arguments().immediate();
__ lw(receiver, MemOperand(sp, argc * kPointerSize));
// Check that the receiver isn't a smi.
__ JumpIfSmi(receiver, &miss);
// Check that the maps haven't changed.
CheckPrototypes(
IC::CurrentTypeOf(object, isolate()), receiver, holder,
elements, t0, v0, name, &miss);
// Get the elements array of the object. // Get the elements array of the object.
__ lw(elements, FieldMemOperand(receiver, JSArray::kElementsOffset)); __ lw(elements, FieldMemOperand(receiver, JSArray::kElementsOffset));
// Check that the elements are in fast mode and writable. // Check that the elements are in fast mode and writable.
__ CheckMap(elements, __ CheckMap(elements,
v0, scratch,
Heap::kFixedArrayMapRootIndex, Heap::kFixedArrayMapRootIndex,
&call_builtin, &call_builtin,
DONT_DO_SMI_CHECK); DONT_DO_SMI_CHECK);
...@@ -1991,14 +1903,16 @@ Handle<Code> CallStubCompiler::CompileArrayPopCall( ...@@ -1991,14 +1903,16 @@ Handle<Code> CallStubCompiler::CompileArrayPopCall(
// expensive shift first, and use an offset later on. // expensive shift first, and use an offset later on.
__ sll(t1, t0, kPointerSizeLog2 - kSmiTagSize); __ sll(t1, t0, kPointerSizeLog2 - kSmiTagSize);
__ Addu(elements, elements, t1); __ Addu(elements, elements, t1);
__ lw(v0, FieldMemOperand(elements, FixedArray::kHeaderSize)); __ lw(scratch, FieldMemOperand(elements, FixedArray::kHeaderSize));
__ Branch(&call_builtin, eq, v0, Operand(t2)); __ Branch(&call_builtin, eq, scratch, Operand(t2));
// Set the array's length. // Set the array's length.
__ sw(t0, FieldMemOperand(receiver, JSArray::kLengthOffset)); __ sw(t0, FieldMemOperand(receiver, JSArray::kLengthOffset));
// Fill with the hole. // Fill with the hole.
__ sw(t2, FieldMemOperand(elements, FixedArray::kHeaderSize)); __ sw(t2, FieldMemOperand(elements, FixedArray::kHeaderSize));
const int argc = arguments().immediate();
__ mov(v0, scratch);
__ DropAndRet(argc + 1); __ DropAndRet(argc + 1);
__ bind(&return_undefined); __ bind(&return_undefined);
...@@ -2009,9 +1923,7 @@ Handle<Code> CallStubCompiler::CompileArrayPopCall( ...@@ -2009,9 +1923,7 @@ Handle<Code> CallStubCompiler::CompileArrayPopCall(
__ TailCallExternalReference( __ TailCallExternalReference(
ExternalReference(Builtins::c_ArrayPop, isolate()), argc + 1, 1); ExternalReference(Builtins::c_ArrayPop, isolate()), argc + 1, 1);
// Handle call cache miss. HandlerFrontendFooter(&miss);
__ bind(&miss);
GenerateMissBranch();
// Return the generated code. // Return the generated code.
return GetCode(type, name); return GetCode(type, name);
...@@ -2025,18 +1937,9 @@ Handle<Code> CallStubCompiler::CompileStringCharCodeAtCall( ...@@ -2025,18 +1937,9 @@ Handle<Code> CallStubCompiler::CompileStringCharCodeAtCall(
Handle<JSFunction> function, Handle<JSFunction> function,
Handle<String> name, Handle<String> name,
Code::StubType type) { Code::StubType type) {
// ----------- S t a t e -------------
// -- a2 : function name
// -- ra : return address
// -- sp[(argc - n - 1) * 4] : arg[n] (zero-based)
// -- ...
// -- sp[argc * 4] : receiver
// -----------------------------------
// If object is not a string, bail out to regular call. // If object is not a string, bail out to regular call.
if (!object->IsString() || !cell.is_null()) return Handle<Code>::null(); if (!object->IsString() || !cell.is_null()) return Handle<Code>::null();
const int argc = arguments().immediate();
Label miss; Label miss;
Label name_miss; Label name_miss;
Label index_out_of_range; Label index_out_of_range;
...@@ -2049,22 +1952,12 @@ Handle<Code> CallStubCompiler::CompileStringCharCodeAtCall( ...@@ -2049,22 +1952,12 @@ Handle<Code> CallStubCompiler::CompileStringCharCodeAtCall(
index_out_of_range_label = &miss; index_out_of_range_label = &miss;
} }
GenerateNameCheck(name, &name_miss); HandlerFrontendHeader(object, holder, name, STRING_CHECK, &name_miss);
// Check that the maps starting from the prototype haven't changed. Register receiver = a0;
GenerateDirectLoadGlobalFunctionPrototype(masm(),
Context::STRING_FUNCTION_INDEX,
v0,
&miss);
ASSERT(!object.is_identical_to(holder));
Handle<JSObject> prototype(JSObject::cast(object->GetPrototype(isolate())));
CheckPrototypes(
IC::CurrentTypeOf(prototype, isolate()),
v0, holder, a1, a3, t0, name, &miss);
Register receiver = a1;
Register index = t1; Register index = t1;
Register result = v0; Register result = a1;
const int argc = arguments().immediate();
__ lw(receiver, MemOperand(sp, argc * kPointerSize)); __ lw(receiver, MemOperand(sp, argc * kPointerSize));
if (argc > 0) { if (argc > 0) {
__ lw(index, MemOperand(sp, (argc - 1) * kPointerSize)); __ lw(index, MemOperand(sp, (argc - 1) * kPointerSize));
...@@ -2080,6 +1973,7 @@ Handle<Code> CallStubCompiler::CompileStringCharCodeAtCall( ...@@ -2080,6 +1973,7 @@ Handle<Code> CallStubCompiler::CompileStringCharCodeAtCall(
index_out_of_range_label, index_out_of_range_label,
STRING_INDEX_IS_NUMBER); STRING_INDEX_IS_NUMBER);
generator.GenerateFast(masm()); generator.GenerateFast(masm());
__ mov(v0, result);
__ DropAndRet(argc + 1); __ DropAndRet(argc + 1);
StubRuntimeCallHelper call_helper; StubRuntimeCallHelper call_helper;
...@@ -2109,14 +2003,6 @@ Handle<Code> CallStubCompiler::CompileStringCharAtCall( ...@@ -2109,14 +2003,6 @@ Handle<Code> CallStubCompiler::CompileStringCharAtCall(
Handle<JSFunction> function, Handle<JSFunction> function,
Handle<String> name, Handle<String> name,
Code::StubType type) { Code::StubType type) {
// ----------- S t a t e -------------
// -- a2 : function name
// -- ra : return address
// -- sp[(argc - n - 1) * 4] : arg[n] (zero-based)
// -- ...
// -- sp[argc * 4] : receiver
// -----------------------------------
// If object is not a string, bail out to regular call. // If object is not a string, bail out to regular call.
if (!object->IsString() || !cell.is_null()) return Handle<Code>::null(); if (!object->IsString() || !cell.is_null()) return Handle<Code>::null();
...@@ -2130,24 +2016,13 @@ Handle<Code> CallStubCompiler::CompileStringCharAtCall( ...@@ -2130,24 +2016,13 @@ Handle<Code> CallStubCompiler::CompileStringCharAtCall(
DEFAULT_STRING_STUB)) { DEFAULT_STRING_STUB)) {
index_out_of_range_label = &miss; index_out_of_range_label = &miss;
} }
GenerateNameCheck(name, &name_miss);
// Check that the maps starting from the prototype haven't changed. HandlerFrontendHeader(object, holder, name, STRING_CHECK, &name_miss);
GenerateDirectLoadGlobalFunctionPrototype(masm(),
Context::STRING_FUNCTION_INDEX,
v0,
&miss);
ASSERT(!object.is_identical_to(holder));
Handle<JSObject> prototype(JSObject::cast(object->GetPrototype(isolate())));
CheckPrototypes(
IC::CurrentTypeOf(prototype, isolate()),
v0, holder, a1, a3, t0, name, &miss);
Register receiver = v0; Register receiver = a0;
Register index = t1; Register index = t1;
Register scratch = a3; Register scratch = a3;
Register result = v0; Register result = a1;
__ lw(receiver, MemOperand(sp, argc * kPointerSize));
if (argc > 0) { if (argc > 0) {
__ lw(index, MemOperand(sp, (argc - 1) * kPointerSize)); __ lw(index, MemOperand(sp, (argc - 1) * kPointerSize));
} else { } else {
...@@ -2163,6 +2038,7 @@ Handle<Code> CallStubCompiler::CompileStringCharAtCall( ...@@ -2163,6 +2038,7 @@ Handle<Code> CallStubCompiler::CompileStringCharAtCall(
index_out_of_range_label, index_out_of_range_label,
STRING_INDEX_IS_NUMBER); STRING_INDEX_IS_NUMBER);
generator.GenerateFast(masm()); generator.GenerateFast(masm());
__ mov(v0, result);
__ DropAndRet(argc + 1); __ DropAndRet(argc + 1);
StubRuntimeCallHelper call_helper; StubRuntimeCallHelper call_helper;
...@@ -2192,14 +2068,6 @@ Handle<Code> CallStubCompiler::CompileStringFromCharCodeCall( ...@@ -2192,14 +2068,6 @@ Handle<Code> CallStubCompiler::CompileStringFromCharCodeCall(
Handle<JSFunction> function, Handle<JSFunction> function,
Handle<String> name, Handle<String> name,
Code::StubType type) { Code::StubType type) {
// ----------- S t a t e -------------
// -- a2 : function name
// -- ra : return address
// -- sp[(argc - n - 1) * 4] : arg[n] (zero-based)
// -- ...
// -- sp[argc * 4] : receiver
// -----------------------------------
const int argc = arguments().immediate(); const int argc = arguments().immediate();
// If the object is not a JSObject or we got an unexpected number of // If the object is not a JSObject or we got an unexpected number of
...@@ -2207,21 +2075,9 @@ Handle<Code> CallStubCompiler::CompileStringFromCharCodeCall( ...@@ -2207,21 +2075,9 @@ Handle<Code> CallStubCompiler::CompileStringFromCharCodeCall(
if (!object->IsJSObject() || argc != 1) return Handle<Code>::null(); if (!object->IsJSObject() || argc != 1) return Handle<Code>::null();
Label miss; Label miss;
GenerateNameCheck(name, &miss); HandlerFrontendHeader(object, holder, name, RECEIVER_MAP_CHECK, &miss);
if (!cell.is_null()) {
if (cell.is_null()) {
__ lw(a1, MemOperand(sp, 1 * kPointerSize));
STATIC_ASSERT(kSmiTag == 0);
__ JumpIfSmi(a1, &miss);
CheckPrototypes(
IC::CurrentTypeOf(object, isolate()),
a1, holder, v0, a3, t0, name, &miss);
} else {
ASSERT(cell->value() == *function); ASSERT(cell->value() == *function);
GenerateGlobalReceiverCheck(Handle<JSObject>::cast(object), holder, name,
&miss);
GenerateLoadFunctionFromCell(cell, function, &miss); GenerateLoadFunctionFromCell(cell, function, &miss);
} }
...@@ -2251,9 +2107,7 @@ Handle<Code> CallStubCompiler::CompileStringFromCharCodeCall( ...@@ -2251,9 +2107,7 @@ Handle<Code> CallStubCompiler::CompileStringFromCharCodeCall(
__ InvokeFunction(function, expected, arguments(), __ InvokeFunction(function, expected, arguments(),
JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD); JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD);
__ bind(&miss); HandlerFrontendFooter(&miss);
// a2: function name.
GenerateMissBranch();
// Return the generated code. // Return the generated code.
return GetCode(type, name); return GetCode(type, name);
...@@ -2267,34 +2121,15 @@ Handle<Code> CallStubCompiler::CompileMathFloorCall( ...@@ -2267,34 +2121,15 @@ Handle<Code> CallStubCompiler::CompileMathFloorCall(
Handle<JSFunction> function, Handle<JSFunction> function,
Handle<String> name, Handle<String> name,
Code::StubType type) { Code::StubType type) {
// ----------- S t a t e -------------
// -- a2 : function name
// -- ra : return address
// -- sp[(argc - n - 1) * 4] : arg[n] (zero-based)
// -- ...
// -- sp[argc * 4] : receiver
// -----------------------------------
const int argc = arguments().immediate(); const int argc = arguments().immediate();
// If the object is not a JSObject or we got an unexpected number of // If the object is not a JSObject or we got an unexpected number of
// arguments, bail out to the regular call. // arguments, bail out to the regular call.
if (!object->IsJSObject() || argc != 1) return Handle<Code>::null(); if (!object->IsJSObject() || argc != 1) return Handle<Code>::null();
Label miss, slow; Label miss, slow;
GenerateNameCheck(name, &miss); HandlerFrontendHeader(object, holder, name, RECEIVER_MAP_CHECK, &miss);
if (!cell.is_null()) {
if (cell.is_null()) {
__ lw(a1, MemOperand(sp, 1 * kPointerSize));
STATIC_ASSERT(kSmiTag == 0);
__ JumpIfSmi(a1, &miss);
CheckPrototypes(
IC::CurrentTypeOf(object, isolate()),
a1, holder, a0, a3, t0, name, &miss);
} else {
ASSERT(cell->value() == *function); ASSERT(cell->value() == *function);
GenerateGlobalReceiverCheck(Handle<JSObject>::cast(object), holder, name,
&miss);
GenerateLoadFunctionFromCell(cell, function, &miss); GenerateLoadFunctionFromCell(cell, function, &miss);
} }
...@@ -2382,9 +2217,7 @@ Handle<Code> CallStubCompiler::CompileMathFloorCall( ...@@ -2382,9 +2217,7 @@ Handle<Code> CallStubCompiler::CompileMathFloorCall(
__ InvokeFunction(function, expected, arguments(), __ InvokeFunction(function, expected, arguments(),
JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD); JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD);
__ bind(&miss); HandlerFrontendFooter(&miss);
// a2: function name.
GenerateMissBranch();
// Return the generated code. // Return the generated code.
return GetCode(type, name); return GetCode(type, name);
...@@ -2398,14 +2231,6 @@ Handle<Code> CallStubCompiler::CompileMathAbsCall( ...@@ -2398,14 +2231,6 @@ Handle<Code> CallStubCompiler::CompileMathAbsCall(
Handle<JSFunction> function, Handle<JSFunction> function,
Handle<String> name, Handle<String> name,
Code::StubType type) { Code::StubType type) {
// ----------- S t a t e -------------
// -- a2 : function name
// -- ra : return address
// -- sp[(argc - n - 1) * 4] : arg[n] (zero-based)
// -- ...
// -- sp[argc * 4] : receiver
// -----------------------------------
const int argc = arguments().immediate(); const int argc = arguments().immediate();
// If the object is not a JSObject or we got an unexpected number of // If the object is not a JSObject or we got an unexpected number of
// arguments, bail out to the regular call. // arguments, bail out to the regular call.
...@@ -2413,18 +2238,9 @@ Handle<Code> CallStubCompiler::CompileMathAbsCall( ...@@ -2413,18 +2238,9 @@ Handle<Code> CallStubCompiler::CompileMathAbsCall(
Label miss; Label miss;
GenerateNameCheck(name, &miss); HandlerFrontendHeader(object, holder, name, RECEIVER_MAP_CHECK, &miss);
if (cell.is_null()) { if (!cell.is_null()) {
__ lw(a1, MemOperand(sp, 1 * kPointerSize));
STATIC_ASSERT(kSmiTag == 0);
__ JumpIfSmi(a1, &miss);
CheckPrototypes(
IC::CurrentTypeOf(object, isolate()),
a1, holder, v0, a3, t0, name, &miss);
} else {
ASSERT(cell->value() == *function); ASSERT(cell->value() == *function);
GenerateGlobalReceiverCheck(Handle<JSObject>::cast(object), holder, name,
&miss);
GenerateLoadFunctionFromCell(cell, function, &miss); GenerateLoadFunctionFromCell(cell, function, &miss);
} }
...@@ -2483,9 +2299,7 @@ Handle<Code> CallStubCompiler::CompileMathAbsCall( ...@@ -2483,9 +2299,7 @@ Handle<Code> CallStubCompiler::CompileMathAbsCall(
__ InvokeFunction(function, expected, arguments(), __ InvokeFunction(function, expected, arguments(),
JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD); JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD);
__ bind(&miss); HandlerFrontendFooter(&miss);
// a2: function name.
GenerateMissBranch();
// Return the generated code. // Return the generated code.
return GetCode(type, name); return GetCode(type, name);
...@@ -2557,24 +2371,37 @@ void StubCompiler::GenerateBooleanCheck(Register object, Label* miss) { ...@@ -2557,24 +2371,37 @@ void StubCompiler::GenerateBooleanCheck(Register object, Label* miss) {
} }
void CallStubCompiler::CompileHandlerFrontend(Handle<Object> object, void CallStubCompiler::PatchGlobalProxy(Handle<Object> object) {
if (object->IsGlobalObject()) {
const int argc = arguments().immediate();
const int receiver_offset = argc * kPointerSize;
__ lw(a3, FieldMemOperand(a0, GlobalObject::kGlobalReceiverOffset));
__ sw(a3, MemOperand(sp, receiver_offset));
}
}
Register CallStubCompiler::HandlerFrontendHeader(Handle<Object> object,
Handle<JSObject> holder, Handle<JSObject> holder,
Handle<Name> name, Handle<Name> name,
CheckType check) { CheckType check,
Label* miss) {
// ----------- S t a t e ------------- // ----------- S t a t e -------------
// -- a2 : name // -- a2 : name
// -- ra : return address // -- ra : return address
// ----------------------------------- // -----------------------------------
Label miss; GenerateNameCheck(name, miss);
GenerateNameCheck(name, &miss);
Register reg = a0;
// Get the receiver from the stack. // Get the receiver from the stack.
const int argc = arguments().immediate(); const int argc = arguments().immediate();
__ lw(a1, MemOperand(sp, argc * kPointerSize)); const int receiver_offset = argc * kPointerSize;
__ lw(a0, MemOperand(sp, receiver_offset));
// Check that the receiver isn't a smi. // Check that the receiver isn't a smi.
if (check != NUMBER_CHECK) { if (check != NUMBER_CHECK) {
__ JumpIfSmi(a1, &miss); __ JumpIfSmi(a0, miss);
} }
// Make sure that it's okay not to patch the on stack receiver // Make sure that it's okay not to patch the on stack receiver
...@@ -2582,86 +2409,62 @@ void CallStubCompiler::CompileHandlerFrontend(Handle<Object> object, ...@@ -2582,86 +2409,62 @@ void CallStubCompiler::CompileHandlerFrontend(Handle<Object> object,
ASSERT(!object->IsGlobalObject() || check == RECEIVER_MAP_CHECK); ASSERT(!object->IsGlobalObject() || check == RECEIVER_MAP_CHECK);
switch (check) { switch (check) {
case RECEIVER_MAP_CHECK: case RECEIVER_MAP_CHECK:
__ IncrementCounter(isolate()->counters()->call_const(), 1, a0, a3); __ IncrementCounter(isolate()->counters()->call_const(), 1, a1, a3);
// Check that the maps haven't changed. // Check that the maps haven't changed.
CheckPrototypes( reg = CheckPrototypes(
IC::CurrentTypeOf(object, isolate()), IC::CurrentTypeOf(object, isolate()),
a1, holder, a0, a3, t0, name, &miss); reg, holder, a1, a3, t0, name, miss);
// Patch the receiver on the stack with the global proxy if
// necessary.
if (object->IsGlobalObject()) {
__ lw(a3, FieldMemOperand(a1, GlobalObject::kGlobalReceiverOffset));
__ sw(a3, MemOperand(sp, argc * kPointerSize));
}
break; break;
case STRING_CHECK: { case STRING_CHECK: {
// Check that the object is a string. // Check that the object is a string.
__ GetObjectType(a1, a3, a3); __ GetObjectType(reg, a3, a3);
__ Branch(&miss, Ugreater_equal, a3, Operand(FIRST_NONSTRING_TYPE)); __ Branch(miss, Ugreater_equal, a3, Operand(FIRST_NONSTRING_TYPE));
// Check that the maps starting from the prototype haven't changed. // Check that the maps starting from the prototype haven't changed.
GenerateDirectLoadGlobalFunctionPrototype( GenerateDirectLoadGlobalFunctionPrototype(
masm(), Context::STRING_FUNCTION_INDEX, a0, &miss); masm(), Context::STRING_FUNCTION_INDEX, a1, miss);
Handle<Object> prototype(object->GetPrototype(isolate()), isolate());
CheckPrototypes(
IC::CurrentTypeOf(prototype, isolate()),
a0, holder, a3, a1, t0, name, &miss);
break; break;
} }
case SYMBOL_CHECK: { case SYMBOL_CHECK: {
// Check that the object is a symbol. // Check that the object is a symbol.
__ GetObjectType(a1, a1, a3); __ GetObjectType(reg, a1, a3);
__ Branch(&miss, ne, a3, Operand(SYMBOL_TYPE)); __ Branch(miss, ne, a3, Operand(SYMBOL_TYPE));
// Check that the maps starting from the prototype haven't changed. // Check that the maps starting from the prototype haven't changed.
GenerateDirectLoadGlobalFunctionPrototype( GenerateDirectLoadGlobalFunctionPrototype(
masm(), Context::SYMBOL_FUNCTION_INDEX, a0, &miss); masm(), Context::SYMBOL_FUNCTION_INDEX, a1, miss);
Handle<Object> prototype(object->GetPrototype(isolate()), isolate());
CheckPrototypes(
IC::CurrentTypeOf(prototype, isolate()),
a0, holder, a3, a1, t0, name, &miss);
break; break;
} }
case NUMBER_CHECK: { case NUMBER_CHECK: {
Label fast; Label fast;
// Check that the object is a smi or a heap number. // Check that the object is a smi or a heap number.
__ JumpIfSmi(a1, &fast); __ JumpIfSmi(reg, &fast);
__ GetObjectType(a1, a0, a0); __ GetObjectType(reg, a3, a3);
__ Branch(&miss, ne, a0, Operand(HEAP_NUMBER_TYPE)); __ Branch(miss, ne, a3, Operand(HEAP_NUMBER_TYPE));
__ bind(&fast); __ bind(&fast);
// Check that the maps starting from the prototype haven't changed. // Check that the maps starting from the prototype haven't changed.
GenerateDirectLoadGlobalFunctionPrototype( GenerateDirectLoadGlobalFunctionPrototype(
masm(), Context::NUMBER_FUNCTION_INDEX, a0, &miss); masm(), Context::NUMBER_FUNCTION_INDEX, a1, miss);
Handle<Object> prototype(object->GetPrototype(isolate()), isolate());
CheckPrototypes(
IC::CurrentTypeOf(prototype, isolate()),
a0, holder, a3, a1, t0, name, &miss);
break; break;
} }
case BOOLEAN_CHECK: { case BOOLEAN_CHECK: {
GenerateBooleanCheck(a1, &miss); GenerateBooleanCheck(reg, miss);
// Check that the maps starting from the prototype haven't changed. // Check that the maps starting from the prototype haven't changed.
GenerateDirectLoadGlobalFunctionPrototype( GenerateDirectLoadGlobalFunctionPrototype(
masm(), Context::BOOLEAN_FUNCTION_INDEX, a0, &miss); masm(), Context::BOOLEAN_FUNCTION_INDEX, a1, miss);
Handle<Object> prototype(object->GetPrototype(isolate()), isolate());
CheckPrototypes(
IC::CurrentTypeOf(prototype, isolate()),
a0, holder, a3, a1, t0, name, &miss);
break; break;
} }
} }
Label success; if (check != RECEIVER_MAP_CHECK) {
__ Branch(&success); Handle<Object> prototype(object->GetPrototype(isolate()), isolate());
reg = CheckPrototypes(
// Handle call cache miss. IC::CurrentTypeOf(prototype, isolate()),
__ bind(&miss); a1, holder, a1, a3, t0, name, miss);
}
GenerateMissBranch();
__ bind(&success); return reg;
} }
...@@ -2690,8 +2493,11 @@ Handle<Code> CallStubCompiler::CompileCallConstant( ...@@ -2690,8 +2493,11 @@ Handle<Code> CallStubCompiler::CompileCallConstant(
if (!code.is_null()) return code; if (!code.is_null()) return code;
} }
CompileHandlerFrontend(object, holder, name, check); Label miss;
HandlerFrontendHeader(object, holder, name, check, &miss);
PatchGlobalProxy(object);
CompileHandlerBackend(function); CompileHandlerBackend(function);
HandlerFrontendFooter(&miss);
// Return the generated code. // Return the generated code.
return GetCode(function); return GetCode(function);
...@@ -2701,11 +2507,6 @@ Handle<Code> CallStubCompiler::CompileCallConstant( ...@@ -2701,11 +2507,6 @@ Handle<Code> CallStubCompiler::CompileCallConstant(
Handle<Code> CallStubCompiler::CompileCallInterceptor(Handle<JSObject> object, Handle<Code> CallStubCompiler::CompileCallInterceptor(Handle<JSObject> object,
Handle<JSObject> holder, Handle<JSObject> holder,
Handle<Name> name) { Handle<Name> name) {
// ----------- S t a t e -------------
// -- a2 : name
// -- ra : return address
// -----------------------------------
Label miss; Label miss;
GenerateNameCheck(name, &miss); GenerateNameCheck(name, &miss);
...@@ -2744,11 +2545,6 @@ Handle<Code> CallStubCompiler::CompileCallGlobal( ...@@ -2744,11 +2545,6 @@ Handle<Code> CallStubCompiler::CompileCallGlobal(
Handle<PropertyCell> cell, Handle<PropertyCell> cell,
Handle<JSFunction> function, Handle<JSFunction> function,
Handle<Name> name) { Handle<Name> name) {
// ----------- S t a t e -------------
// -- a2 : name
// -- ra : return address
// -----------------------------------
if (HasCustomCallGenerator(function)) { if (HasCustomCallGenerator(function)) {
Handle<Code> code = CompileCustomCall( Handle<Code> code = CompileCustomCall(
object, holder, cell, function, Handle<String>::cast(name), object, holder, cell, function, Handle<String>::cast(name),
...@@ -2758,19 +2554,9 @@ Handle<Code> CallStubCompiler::CompileCallGlobal( ...@@ -2758,19 +2554,9 @@ Handle<Code> CallStubCompiler::CompileCallGlobal(
} }
Label miss; Label miss;
GenerateNameCheck(name, &miss); HandlerFrontendHeader(object, holder, name, RECEIVER_MAP_CHECK, &miss);
// Get the number of arguments.
const int argc = arguments().immediate();
GenerateGlobalReceiverCheck(object, holder, name, &miss);
GenerateLoadFunctionFromCell(cell, function, &miss); GenerateLoadFunctionFromCell(cell, function, &miss);
PatchGlobalProxy(object);
// Patch the receiver on the stack with the global proxy if
// necessary.
if (object->IsGlobalObject()) {
__ lw(a3, FieldMemOperand(a0, GlobalObject::kGlobalReceiverOffset));
__ sw(a3, MemOperand(sp, argc * kPointerSize));
}
// Set up the context (function already in r1). // Set up the context (function already in r1).
__ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset)); __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
...@@ -2789,10 +2575,7 @@ Handle<Code> CallStubCompiler::CompileCallGlobal( ...@@ -2789,10 +2575,7 @@ Handle<Code> CallStubCompiler::CompileCallGlobal(
__ InvokeCode(a3, expected, arguments(), JUMP_FUNCTION, __ InvokeCode(a3, expected, arguments(), JUMP_FUNCTION,
NullCallWrapper(), call_kind); NullCallWrapper(), call_kind);
// Handle call cache miss. HandlerFrontendFooter(&miss);
__ bind(&miss);
__ IncrementCounter(counters->call_global_inline_miss(), 1, a1, a3);
GenerateMissBranch();
// Return the generated code. // Return the generated code.
return GetCode(Code::NORMAL, name); return GetCode(Code::NORMAL, name);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment