Skip to content

V
V8
Commit 058c5c9f authored by dcarney@chromium.org's avatar dcarney@chromium.org
Browse files
Options

Unify calling to GenerateFastApiCallBody before stubbing it 

R=verwaest@chromium.org

BUG=

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

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@18714 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
parent 80195df5
Hide whitespace changes
Inline Side-by-side
Showing with 428 additions and 505 deletions
src/arm/stub-cache-arm.cc
View file @ 058c5c9f
...@@ -779,64 +779,72 @@ static void CompileCallLoadPropertyWithInterceptor( ...@@ -779,64 +779,72 @@ static void CompileCallLoadPropertyWithInterceptor(
static const int kFastApiCallArguments = FunctionCallbackArguments::kArgsLength; static const int kFastApiCallArguments = FunctionCallbackArguments::kArgsLength;
// Reserves space for the extra arguments to API function in the
// caller's frame.
//
// These arguments are set by CheckPrototypes and GenerateFastApiDirectCall.
static void ReserveSpaceForFastApiCall(MacroAssembler* masm,
Register scratch) {
__ mov(scratch, Operand(Smi::FromInt(0)));
for (int i = 0; i < kFastApiCallArguments; i++) {
__ push(scratch);
}
}
// Undoes the effects of ReserveSpaceForFastApiCall. static void GenerateFastApiCallBody(MacroAssembler* masm,
static void FreeSpaceForFastApiCall(MacroAssembler* masm) { const CallOptimization& optimization,
__ Drop(kFastApiCallArguments); int argc,
} Register holder,
Register scratch1,
Register scratch2,
static void GenerateFastApiDirectCall(MacroAssembler* masm, Register scratch3,
const CallOptimization& optimization, bool restore_context) {
int argc,
bool restore_context) {
// ----------- S t a t e ------------- // ----------- S t a t e -------------
// -- sp[0] - sp[24] : FunctionCallbackInfo, incl. // -- sp[0] : last JS argument
// : holder (set by CheckPrototypes)
// -- sp[28] : last JS argument
// -- ... // -- ...
// -- sp[(argc + 6) * 4] : first JS argument // -- sp[(argc - 1) * 4] : first JS argument
// -- sp[(argc + 7) * 4] : receiver // -- sp[argc * 4] : receiver
// ----------------------------------- // -----------------------------------
ASSERT(optimization.is_simple_api_call());
typedef FunctionCallbackArguments FCA; typedef FunctionCallbackArguments FCA;
STATIC_ASSERT(FCA::kHolderIndex == 0);
STATIC_ASSERT(FCA::kIsolateIndex == 1);
STATIC_ASSERT(FCA::kReturnValueDefaultValueIndex == 2);
STATIC_ASSERT(FCA::kReturnValueOffset == 3);
STATIC_ASSERT(FCA::kDataIndex == 4);
STATIC_ASSERT(FCA::kCalleeIndex == 5);
STATIC_ASSERT(FCA::kContextSaveIndex == 6);
STATIC_ASSERT(FCA::kArgsLength == 7);
ASSERT(!holder.is(cp));
// Save calling context. // Save calling context.
__ str(cp, MemOperand(sp, FCA::kContextSaveIndex * kPointerSize)); __ push(cp);
// Get the function and setup the context. // Get the function and setup the context.
Handle<JSFunction> function = optimization.constant_function(); Handle<JSFunction> function = optimization.constant_function();
__ Move(r5, function); __ Move(scratch1, function);
__ ldr(cp, FieldMemOperand(r5, JSFunction::kContextOffset)); __ ldr(cp, FieldMemOperand(scratch1, JSFunction::kContextOffset));
__ str(r5, MemOperand(sp, FCA::kCalleeIndex * kPointerSize)); __ push(scratch1);
// Construct the FunctionCallbackInfo. // Construct the FunctionCallbackInfo.
Handle<CallHandlerInfo> api_call_info = optimization.api_call_info(); Handle<CallHandlerInfo> api_call_info = optimization.api_call_info();
Handle<Object> call_data(api_call_info->data(), masm->isolate()); Handle<Object> call_data(api_call_info->data(), masm->isolate());
bool call_data_undefined = false;
if (masm->isolate()->heap()->InNewSpace(*call_data)) { if (masm->isolate()->heap()->InNewSpace(*call_data)) {
__ Move(r0, api_call_info); __ Move(scratch1, api_call_info);
__ ldr(r6, FieldMemOperand(r0, CallHandlerInfo::kDataOffset)); __ ldr(scratch1, FieldMemOperand(scratch1, CallHandlerInfo::kDataOffset));
} else if (call_data->IsUndefined()) {
call_data_undefined = true;
__ LoadRoot(scratch3, Heap::kUndefinedValueRootIndex);
} else { } else {
__ Move(r6, call_data); __ Move(scratch1, call_data);
} }
// Store call data. // Store call data.
__ str(r6, MemOperand(sp, FCA::kDataIndex * kPointerSize)); __ push(scratch1);
// Store isolate. if (!call_data_undefined) {
__ mov(r5, Operand(ExternalReference::isolate_address(masm->isolate()))); __ LoadRoot(scratch1, Heap::kUndefinedValueRootIndex);
__ str(r5, MemOperand(sp, FCA::kIsolateIndex * kPointerSize)); }
// Store ReturnValue default and ReturnValue. // Store ReturnValue default and ReturnValue.
__ LoadRoot(r5, Heap::kUndefinedValueRootIndex); __ LoadRoot(scratch1, Heap::kUndefinedValueRootIndex);
__ str(r5, MemOperand(sp, FCA::kReturnValueOffset * kPointerSize)); __ push(scratch1);
__ str(r5, MemOperand(sp, FCA::kReturnValueDefaultValueIndex * kPointerSize)); __ push(scratch1);
// Store isolate.
__ mov(scratch1,
Operand(ExternalReference::isolate_address(masm->isolate())));
__ push(scratch1);
// holder
__ push(holder);
// Prepare arguments. // Prepare arguments.
__ mov(r2, sp); __ mov(r2, sp);
...@@ -893,6 +901,50 @@ static void GenerateFastApiDirectCall(MacroAssembler* masm, ...@@ -893,6 +901,50 @@ static void GenerateFastApiDirectCall(MacroAssembler* masm,
} }
// Generates call to API function.
static void GenerateFastApiCall(MacroAssembler* masm,
const CallOptimization& optimization,
int argc,
Handle<Map> map_to_holder,
CallOptimization::HolderLookup holder_lookup) {
Counters* counters = masm->isolate()->counters();
__ IncrementCounter(counters->call_const_fast_api(), 1, r0, r1);
// Move holder to a register
Register holder_reg = r0;
switch (holder_lookup) {
case CallOptimization::kHolderIsReceiver:
{
ASSERT(map_to_holder.is_null());
__ ldr(holder_reg, MemOperand(sp, argc * kPointerSize));
}
break;
case CallOptimization::kHolderIsPrototypeOfMap:
{
Handle<JSObject> holder(JSObject::cast(map_to_holder->prototype()));
if (!masm->isolate()->heap()->InNewSpace(*holder)) {
__ Move(holder_reg, holder);
} else {
__ Move(holder_reg, map_to_holder);
__ ldr(holder_reg,
FieldMemOperand(holder_reg, Map::kPrototypeOffset));
}
}
break;
case CallOptimization::kHolderNotFound:
UNREACHABLE();
}
GenerateFastApiCallBody(masm,
optimization,
argc,
holder_reg,
r1,
r2,
r3,
false);
}
// Generate call to api function. // Generate call to api function.
static void GenerateFastApiCall(MacroAssembler* masm, static void GenerateFastApiCall(MacroAssembler* masm,
const CallOptimization& optimization, const CallOptimization& optimization,
...@@ -900,26 +952,31 @@ static void GenerateFastApiCall(MacroAssembler* masm, ...@@ -900,26 +952,31 @@ static void GenerateFastApiCall(MacroAssembler* masm,
Register scratch, Register scratch,
int argc, int argc,
Register* values) { Register* values) {
ASSERT(optimization.is_simple_api_call());
ASSERT(!receiver.is(scratch)); ASSERT(!receiver.is(scratch));
__ push(receiver);
typedef FunctionCallbackArguments FCA;
const int stack_space = kFastApiCallArguments + argc + 1;
// Assign stack space for the call arguments.
__ sub(sp, sp, Operand(stack_space * kPointerSize));
// Write holder to stack frame.
__ str(receiver, MemOperand(sp, FCA::kHolderIndex * kPointerSize));
// Write receiver to stack frame.
int index = stack_space - 1;
__ str(receiver, MemOperand(sp, index-- * kPointerSize));
// Write the arguments to stack frame. // Write the arguments to stack frame.
for (int i = 0; i < argc; i++) { for (int i = 0; i < argc; i++) {
ASSERT(!receiver.is(values[i])); Register arg = values[argc-1-i];
ASSERT(!scratch.is(values[i])); ASSERT(!receiver.is(arg));
__ str(values[i], MemOperand(sp, index-- * kPointerSize)); ASSERT(!scratch.is(arg));
__ push(arg);
} }
Register scratch1 = r0;
GenerateFastApiDirectCall(masm, optimization, argc, true); Register scratch2 = r1;
Register scratch3 = r2;
if (!r3.is(receiver)) {
__ mov(r3, receiver);
receiver = r3;
}
// Stack now matches JSFunction abi.
GenerateFastApiCallBody(masm,
optimization,
argc,
receiver,
scratch1,
scratch2,
scratch3,
true);
} }
...@@ -972,39 +1029,17 @@ class CallInterceptorCompiler BASE_EMBEDDED { ...@@ -972,39 +1029,17 @@ class CallInterceptorCompiler BASE_EMBEDDED {
ASSERT(optimization.is_constant_call()); ASSERT(optimization.is_constant_call());
ASSERT(!lookup->holder()->IsGlobalObject()); ASSERT(!lookup->holder()->IsGlobalObject());
Counters* counters = masm->isolate()->counters(); Counters* counters = masm->isolate()->counters();
int depth1 = kInvalidProtoDepth;
int depth2 = kInvalidProtoDepth;
bool can_do_fast_api_call = false;
if (optimization.is_simple_api_call() &&
!lookup->holder()->IsGlobalObject()) {
depth1 = optimization.GetPrototypeDepthOfExpectedType(
object, interceptor_holder);
if (depth1 == kInvalidProtoDepth) {
depth2 = optimization.GetPrototypeDepthOfExpectedType(
interceptor_holder, Handle<JSObject>(lookup->holder()));
}
can_do_fast_api_call =
depth1 != kInvalidProtoDepth || depth2 != kInvalidProtoDepth;
}
__ IncrementCounter(counters->call_const_interceptor(), 1, __ IncrementCounter(counters->call_const_interceptor(), 1,
scratch1, scratch2); scratch1, scratch2);
if (can_do_fast_api_call) {
__ IncrementCounter(counters->call_const_interceptor_fast_api(), 1,
scratch1, scratch2);
ReserveSpaceForFastApiCall(masm, scratch1);
}
// Check that the maps from receiver to interceptor's holder // Check that the maps from receiver to interceptor's holder
// haven't changed and thus we can invoke interceptor. // haven't changed and thus we can invoke interceptor.
Label miss_cleanup; Label miss_cleanup;
Label* miss = can_do_fast_api_call ? &miss_cleanup : miss_label;
Register holder = Register holder =
stub_compiler_->CheckPrototypes( stub_compiler_->CheckPrototypes(
IC::CurrentTypeOf(object, masm->isolate()), receiver, IC::CurrentTypeOf(object, masm->isolate()), receiver,
interceptor_holder, scratch1, scratch2, scratch3, interceptor_holder, scratch1, scratch2, scratch3,
name, depth1, miss); name, miss_label);
// Invoke an interceptor and if it provides a value, // Invoke an interceptor and if it provides a value,
// branch to |regular_invoke|. // branch to |regular_invoke|.
...@@ -1021,37 +1056,42 @@ class CallInterceptorCompiler BASE_EMBEDDED { ...@@ -1021,37 +1056,42 @@ class CallInterceptorCompiler BASE_EMBEDDED {
stub_compiler_->CheckPrototypes( stub_compiler_->CheckPrototypes(
IC::CurrentTypeOf(interceptor_holder, masm->isolate()), holder, IC::CurrentTypeOf(interceptor_holder, masm->isolate()), holder,
handle(lookup->holder()), scratch1, scratch2, scratch3, handle(lookup->holder()), scratch1, scratch2, scratch3,
name, depth2, miss); name, miss_label);
} else { }
// CheckPrototypes has a side effect of fetching a 'holder'
// for API (object which is instanceof for the signature). It's Handle<Map> lookup_map;
// safe to omit it here, as if present, it should be fetched CallOptimization::HolderLookup holder_lookup =
// by the previous CheckPrototypes. CallOptimization::kHolderNotFound;
ASSERT(depth2 == kInvalidProtoDepth); if (optimization.is_simple_api_call() &&
!lookup->holder()->IsGlobalObject()) {
lookup_map = optimization.LookupHolderOfExpectedType(
object, object, interceptor_holder, &holder_lookup);
if (holder_lookup == CallOptimization::kHolderNotFound) {
lookup_map =
optimization.LookupHolderOfExpectedType(
object,
interceptor_holder,
Handle<JSObject>(lookup->holder()),
&holder_lookup);
}
} }
// Invoke function. // Invoke function.
if (can_do_fast_api_call) { if (holder_lookup != CallOptimization::kHolderNotFound) {
GenerateFastApiDirectCall( int argc = arguments_.immediate();
masm, optimization, arguments_.immediate(), false); GenerateFastApiCall(masm,
optimization,
argc,
lookup_map,
holder_lookup);
} else { } else {
Handle<JSFunction> function = optimization.constant_function(); Handle<JSFunction> function = optimization.constant_function();
__ Move(r0, receiver); __ Move(r0, receiver);
stub_compiler_->GenerateJumpFunction(object, function); stub_compiler_->GenerateJumpFunction(object, function);
} }
// Deferred code for fast API call case---clean preallocated space.
if (can_do_fast_api_call) {
__ bind(&miss_cleanup);
FreeSpaceForFastApiCall(masm);
__ b(miss_label);
}
// Invoke a regular function. // Invoke a regular function.
__ bind(&regular_invoke); __ bind(&regular_invoke);
if (can_do_fast_api_call) {
FreeSpaceForFastApiCall(masm);
}
} }
void CompileRegular(MacroAssembler* masm, void CompileRegular(MacroAssembler* masm,
...@@ -1127,7 +1167,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type, ...@@ -1127,7 +1167,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type,
Register scratch1, Register scratch1,
Register scratch2, Register scratch2,
Handle<Name> name, Handle<Name> name,
int save_at_depth,
Label* miss, Label* miss,
PrototypeCheckType check) { PrototypeCheckType check) {
Handle<Map> receiver_map(IC::TypeToMap(*type, isolate())); Handle<Map> receiver_map(IC::TypeToMap(*type, isolate()));
...@@ -1144,11 +1183,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type, ...@@ -1144,11 +1183,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type,
Register reg = object_reg; Register reg = object_reg;
int depth = 0; int depth = 0;
typedef FunctionCallbackArguments FCA;
if (save_at_depth == depth) {
__ str(reg, MemOperand(sp, FCA::kHolderIndex * kPointerSize));
}
Handle<JSObject> current = Handle<JSObject>::null(); Handle<JSObject> current = Handle<JSObject>::null();
if (type->IsConstant()) current = Handle<JSObject>::cast(type->AsConstant()); if (type->IsConstant()) current = Handle<JSObject>::cast(type->AsConstant());
Handle<JSObject> prototype = Handle<JSObject>::null(); Handle<JSObject> prototype = Handle<JSObject>::null();
...@@ -1214,10 +1248,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type, ...@@ -1214,10 +1248,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type,
} }
} }
if (save_at_depth == depth) {
__ str(reg, MemOperand(sp, FCA::kHolderIndex * kPointerSize));
}
// Go to the next object in the prototype chain. // Go to the next object in the prototype chain.
current = prototype; current = prototype;
current_map = handle(current->map()); current_map = handle(current->map());
...@@ -1586,36 +1616,36 @@ Handle<Code> CallStubCompiler::CompileFastApiCall( ...@@ -1586,36 +1616,36 @@ Handle<Code> CallStubCompiler::CompileFastApiCall(
if (object->IsGlobalObject()) return Handle<Code>::null(); if (object->IsGlobalObject()) return Handle<Code>::null();
if (!cell.is_null()) return Handle<Code>::null(); if (!cell.is_null()) return Handle<Code>::null();
if (!object->IsJSObject()) return Handle<Code>::null(); if (!object->IsJSObject()) return Handle<Code>::null();
int depth = optimization.GetPrototypeDepthOfExpectedType( Handle<JSObject> receiver = Handle<JSObject>::cast(object);
Handle<JSObject>::cast(object), holder); CallOptimization::HolderLookup holder_lookup =
if (depth == kInvalidProtoDepth) return Handle<Code>::null(); CallOptimization::kHolderNotFound;
Handle<Map> lookup_map = optimization.LookupHolderOfExpectedType(
receiver, receiver, holder, &holder_lookup);
if (holder_lookup == CallOptimization::kHolderNotFound) {
return Handle<Code>::null();
}
Label miss, miss_before_stack_reserved; Label miss;
GenerateNameCheck(name, &miss_before_stack_reserved); GenerateNameCheck(name, &miss);
// Get the receiver from the stack. // Get the receiver from the stack.
const int argc = arguments().immediate(); const int argc = arguments().immediate();
__ ldr(r1, MemOperand(sp, argc * kPointerSize)); __ ldr(r1, MemOperand(sp, argc * kPointerSize));
// Check that the receiver isn't a smi. // Check that the receiver isn't a smi.
__ JumpIfSmi(r1, &miss_before_stack_reserved); __ JumpIfSmi(r1, &miss);
__ IncrementCounter(counters->call_const(), 1, r0, r3); __ IncrementCounter(counters->call_const(), 1, r0, r3);
__ IncrementCounter(counters->call_const_fast_api(), 1, r0, r3);
ReserveSpaceForFastApiCall(masm(), r0);
// Check that the maps haven't changed and find a Holder as a side effect. // Check that the maps haven't changed and find a Holder as a side effect.
CheckPrototypes( CheckPrototypes(
IC::CurrentTypeOf(object, isolate()), IC::CurrentTypeOf(object, isolate()),
r1, holder, r0, r3, r4, name, depth, &miss); r1, holder, r0, r3, r4, name, &miss);
GenerateFastApiDirectCall(masm(), optimization, argc, false);
__ bind(&miss); GenerateFastApiCall(
FreeSpaceForFastApiCall(masm()); masm(), optimization, argc, lookup_map, holder_lookup);
HandlerFrontendFooter(&miss_before_stack_reserved); HandlerFrontendFooter(&miss);
// Return the generated code. // Return the generated code.
return GetCode(function); return GetCode(function);
......
src/ia32/stub-cache-ia32.cc
View file @ 058c5c9f
...@@ -418,82 +418,55 @@ static void CompileCallLoadPropertyWithInterceptor( ...@@ -418,82 +418,55 @@ static void CompileCallLoadPropertyWithInterceptor(
static const int kFastApiCallArguments = FunctionCallbackArguments::kArgsLength; static const int kFastApiCallArguments = FunctionCallbackArguments::kArgsLength;
// Reserves space for the extra arguments to API function in the
// caller's frame.
//
// These arguments are set by CheckPrototypes and GenerateFastApiCall.
static void ReserveSpaceForFastApiCall(MacroAssembler* masm, Register scratch) {
// ----------- S t a t e -------------
// -- esp[0] : return address
// -- esp[4] : last argument in the internal frame of the caller
// -----------------------------------
__ pop(scratch);
for (int i = 0; i < kFastApiCallArguments; i++) {
__ push(Immediate(Smi::FromInt(0)));
}
__ push(scratch);
}
// Undoes the effects of ReserveSpaceForFastApiCall.
static void FreeSpaceForFastApiCall(MacroAssembler* masm, Register scratch) {
// ----------- S t a t e -------------
// -- esp[0] : return address.
// -- esp[4] : last fast api call extra argument.
// -- ...
// -- esp[kFastApiCallArguments * 4] : first fast api call extra argument.
// -- esp[kFastApiCallArguments * 4 + 4] : last argument in the internal
// frame.
// -----------------------------------
__ pop(scratch);
__ add(esp, Immediate(kPointerSize * kFastApiCallArguments));
__ push(scratch);
}
static void GenerateFastApiCallBody(MacroAssembler* masm, static void GenerateFastApiCallBody(MacroAssembler* masm,
const CallOptimization& optimization, const CallOptimization& optimization,
int argc, int argc,
Register holder,
Register scratch1,
Register scratch2,
Register scratch3,
bool restore_context); bool restore_context);
// Generates call to API function. // Generates call to API function.
static void GenerateFastApiCall(MacroAssembler* masm, static void GenerateFastApiCall(MacroAssembler* masm,
const CallOptimization& optimization, const CallOptimization& optimization,
int argc) { int argc,
typedef FunctionCallbackArguments FCA; Handle<Map> map_to_holder,
// Save calling context. CallOptimization::HolderLookup holder_lookup) {
__ mov(Operand(esp, (1 + FCA::kContextSaveIndex) * kPointerSize), esi); Counters* counters = masm->isolate()->counters();
__ IncrementCounter(counters->call_const_fast_api(), 1);
// Get the function and setup the context.
Handle<JSFunction> function = optimization.constant_function();
__ LoadHeapObject(edi, function);
__ mov(esi, FieldOperand(edi, JSFunction::kContextOffset));
// Construct the FunctionCallbackInfo. // Move holder to a register
__ mov(Operand(esp, (1 + FCA::kCalleeIndex) * kPointerSize), edi); Register holder_reg = eax;
Handle<CallHandlerInfo> api_call_info = optimization.api_call_info(); switch (holder_lookup) {
Handle<Object> call_data(api_call_info->data(), masm->isolate()); case CallOptimization::kHolderIsReceiver:
if (masm->isolate()->heap()->InNewSpace(*call_data)) { {
__ mov(ecx, api_call_info); ASSERT(map_to_holder.is_null());
__ mov(ebx, FieldOperand(ecx, CallHandlerInfo::kDataOffset)); __ mov(holder_reg, Operand(esp, (argc + 1)* kPointerSize));
__ mov(Operand(esp, (1 + FCA::kDataIndex) * kPointerSize), ebx); }
} else { break;
__ mov(Operand(esp, (1 + FCA::kDataIndex) * kPointerSize), case CallOptimization::kHolderIsPrototypeOfMap:
Immediate(call_data)); {
Handle<JSObject> holder(JSObject::cast(map_to_holder->prototype()));
if (!masm->isolate()->heap()->InNewSpace(*holder)) {
__ mov(holder_reg, holder);
} else {
__ mov(holder_reg, map_to_holder);
__ mov(holder_reg, FieldOperand(holder_reg, Map::kPrototypeOffset));
}
}
break;
case CallOptimization::kHolderNotFound:
UNREACHABLE();
} }
__ mov(Operand(esp, (1 + FCA::kIsolateIndex) * kPointerSize), GenerateFastApiCallBody(masm,
Immediate(reinterpret_cast<int>(masm->isolate()))); optimization,
__ mov(Operand(esp, (1 + FCA::kReturnValueOffset) * kPointerSize), argc,
masm->isolate()->factory()->undefined_value()); holder_reg,
__ mov(Operand(esp, (1 + FCA::kReturnValueDefaultValueIndex) * kPointerSize), ebx,
masm->isolate()->factory()->undefined_value()); ecx,
edx,
// Prepare arguments. false);
STATIC_ASSERT(kFastApiCallArguments == 7);
__ lea(eax, Operand(esp, 1 * kPointerSize));
GenerateFastApiCallBody(masm, optimization, argc, false);
} }
...@@ -509,14 +482,10 @@ static void GenerateFastApiCall(MacroAssembler* masm, ...@@ -509,14 +482,10 @@ static void GenerateFastApiCall(MacroAssembler* masm,
Register scratch3, Register scratch3,
int argc, int argc,
Register* values) { Register* values) {
ASSERT(optimization.is_simple_api_call());
// Copy return value. // Copy return value.
__ pop(scratch1); __ pop(scratch1);
// receiver // receiver
__ push(receiver); __ push(receiver);
// Write the arguments to stack frame. // Write the arguments to stack frame.
for (int i = 0; i < argc; i++) { for (int i = 0; i < argc; i++) {
Register arg = values[argc-1-i]; Register arg = values[argc-1-i];
...@@ -526,6 +495,34 @@ static void GenerateFastApiCall(MacroAssembler* masm, ...@@ -526,6 +495,34 @@ static void GenerateFastApiCall(MacroAssembler* masm,
ASSERT(!scratch3.is(arg)); ASSERT(!scratch3.is(arg));
__ push(arg); __ push(arg);
} }
__ push(scratch1);
// Stack now matches JSFunction abi.
GenerateFastApiCallBody(masm,
optimization,
argc,
receiver,
scratch1,
scratch2,
scratch3,
true);
}
static void GenerateFastApiCallBody(MacroAssembler* masm,
const CallOptimization& optimization,
int argc,
Register holder,
Register scratch1,
Register scratch2,
Register scratch3,
bool restore_context) {
// ----------- S t a t e -------------
// -- esp[0] : return address
// -- esp[4] : last argument
// -- ...
// -- esp[argc * 4] : first argument
// -- esp[(argc + 1) * 4] : receiver
ASSERT(optimization.is_simple_api_call());
typedef FunctionCallbackArguments FCA; typedef FunctionCallbackArguments FCA;
...@@ -538,6 +535,9 @@ static void GenerateFastApiCall(MacroAssembler* masm, ...@@ -538,6 +535,9 @@ static void GenerateFastApiCall(MacroAssembler* masm,
STATIC_ASSERT(FCA::kContextSaveIndex == 6); STATIC_ASSERT(FCA::kContextSaveIndex == 6);
STATIC_ASSERT(FCA::kArgsLength == 7); STATIC_ASSERT(FCA::kArgsLength == 7);
__ pop(scratch1);
ASSERT(!holder.is(esi));
// context save // context save
__ push(esi); __ push(esi);
...@@ -566,7 +566,7 @@ static void GenerateFastApiCall(MacroAssembler* masm, ...@@ -566,7 +566,7 @@ static void GenerateFastApiCall(MacroAssembler* masm,
// isolate // isolate
__ push(Immediate(reinterpret_cast<int>(isolate))); __ push(Immediate(reinterpret_cast<int>(isolate)));
// holder // holder
__ push(receiver); __ push(holder);
// store receiver address for GenerateFastApiCallBody // store receiver address for GenerateFastApiCallBody
ASSERT(!scratch1.is(eax)); ASSERT(!scratch1.is(eax));
...@@ -575,28 +575,6 @@ static void GenerateFastApiCall(MacroAssembler* masm, ...@@ -575,28 +575,6 @@ static void GenerateFastApiCall(MacroAssembler* masm,
// return address // return address
__ push(scratch1); __ push(scratch1);
GenerateFastApiCallBody(masm, optimization, argc, true);
}
static void GenerateFastApiCallBody(MacroAssembler* masm,
const CallOptimization& optimization,
int argc,
bool restore_context) {
// ----------- S t a t e -------------
// -- esp[0] : return address
// -- esp[4] - esp[28] : FunctionCallbackInfo, incl.
// : object passing the type check
// (set by CheckPrototypes)
// -- esp[32] : last argument
// -- ...
// -- esp[(argc + 7) * 4] : first argument
// -- esp[(argc + 8) * 4] : receiver
//
// -- eax : receiver address
// -----------------------------------
typedef FunctionCallbackArguments FCA;
// API function gets reference to the v8::Arguments. If CPU profiler // API function gets reference to the v8::Arguments. If CPU profiler
// is enabled wrapper function will be called and we need to pass // is enabled wrapper function will be called and we need to pass
// address of the callback as additional parameter, always allocate // address of the callback as additional parameter, always allocate
...@@ -607,8 +585,6 @@ static void GenerateFastApiCallBody(MacroAssembler* masm, ...@@ -607,8 +585,6 @@ static void GenerateFastApiCallBody(MacroAssembler* masm,
// it's not controlled by GC. // it's not controlled by GC.
const int kApiStackSpace = 4; const int kApiStackSpace = 4;
Handle<CallHandlerInfo> api_call_info = optimization.api_call_info();
// Function address is a foreign pointer outside V8's heap. // Function address is a foreign pointer outside V8's heap.
Address function_address = v8::ToCData<Address>(api_call_info->callback()); Address function_address = v8::ToCData<Address>(api_call_info->callback());
__ PrepareCallApiFunction(kApiArgc + kApiStackSpace); __ PrepareCallApiFunction(kApiArgc + kApiStackSpace);
...@@ -693,38 +669,16 @@ class CallInterceptorCompiler BASE_EMBEDDED { ...@@ -693,38 +669,16 @@ class CallInterceptorCompiler BASE_EMBEDDED {
ASSERT(optimization.is_constant_call()); ASSERT(optimization.is_constant_call());
ASSERT(!lookup->holder()->IsGlobalObject()); ASSERT(!lookup->holder()->IsGlobalObject());
int depth1 = kInvalidProtoDepth;
int depth2 = kInvalidProtoDepth;
bool can_do_fast_api_call = false;
if (optimization.is_simple_api_call() &&
!lookup->holder()->IsGlobalObject()) {
depth1 = optimization.GetPrototypeDepthOfExpectedType(
object, interceptor_holder);
if (depth1 == kInvalidProtoDepth) {
depth2 = optimization.GetPrototypeDepthOfExpectedType(
interceptor_holder, Handle<JSObject>(lookup->holder()));
}
can_do_fast_api_call =
depth1 != kInvalidProtoDepth || depth2 != kInvalidProtoDepth;
}
Counters* counters = masm->isolate()->counters(); Counters* counters = masm->isolate()->counters();
__ IncrementCounter(counters->call_const_interceptor(), 1); __ IncrementCounter(counters->call_const_interceptor(), 1);
if (can_do_fast_api_call) {
__ IncrementCounter(counters->call_const_interceptor_fast_api(), 1);
ReserveSpaceForFastApiCall(masm, scratch1);
}
// Check that the maps from receiver to interceptor's holder // Check that the maps from receiver to interceptor's holder
// haven't changed and thus we can invoke interceptor. // haven't changed and thus we can invoke interceptor.
Label miss_cleanup;
Label* miss = can_do_fast_api_call ? &miss_cleanup : miss_label;
Register holder = Register holder =
stub_compiler_->CheckPrototypes( stub_compiler_->CheckPrototypes(
IC::CurrentTypeOf(object, masm->isolate()), receiver, IC::CurrentTypeOf(object, masm->isolate()), receiver,
interceptor_holder, scratch1, scratch2, scratch3, interceptor_holder, scratch1, scratch2, scratch3,
name, depth1, miss); name, miss_label);
// Invoke an interceptor and if it provides a value, // Invoke an interceptor and if it provides a value,
// branch to |regular_invoke|. // branch to |regular_invoke|.
...@@ -741,35 +695,41 @@ class CallInterceptorCompiler BASE_EMBEDDED { ...@@ -741,35 +695,41 @@ class CallInterceptorCompiler BASE_EMBEDDED {
stub_compiler_->CheckPrototypes( stub_compiler_->CheckPrototypes(
IC::CurrentTypeOf(interceptor_holder, masm->isolate()), holder, IC::CurrentTypeOf(interceptor_holder, masm->isolate()), holder,
handle(lookup->holder()), scratch1, scratch2, scratch3, handle(lookup->holder()), scratch1, scratch2, scratch3,
name, depth2, miss); name, miss_label);
} else { }
// CheckPrototypes has a side effect of fetching a 'holder'
// for API (object which is instanceof for the signature). It's Handle<Map> lookup_map;
// safe to omit it here, as if present, it should be fetched CallOptimization::HolderLookup holder_lookup =
// by the previous CheckPrototypes. CallOptimization::kHolderNotFound;
ASSERT(depth2 == kInvalidProtoDepth); if (optimization.is_simple_api_call() &&
!lookup->holder()->IsGlobalObject()) {
lookup_map = optimization.LookupHolderOfExpectedType(
object, object, interceptor_holder, &holder_lookup);
if (holder_lookup == CallOptimization::kHolderNotFound) {
lookup_map =
optimization.LookupHolderOfExpectedType(
object,
interceptor_holder,
Handle<JSObject>(lookup->holder()),
&holder_lookup);
}
} }
// Invoke function. // Invoke function.
if (can_do_fast_api_call) { if (holder_lookup != CallOptimization::kHolderNotFound) {
GenerateFastApiCall(masm, optimization, arguments_.immediate()); int argc = arguments_.immediate();
GenerateFastApiCall(masm,
optimization,
argc,
lookup_map,
holder_lookup);
} else { } else {
Handle<JSFunction> fun = optimization.constant_function(); Handle<JSFunction> fun = optimization.constant_function();
stub_compiler_->GenerateJumpFunction(object, fun); stub_compiler_->GenerateJumpFunction(object, fun);
} }
// Deferred code for fast API call case---clean preallocated space.
if (can_do_fast_api_call) {
__ bind(&miss_cleanup);
FreeSpaceForFastApiCall(masm, scratch1);
__ jmp(miss_label);
}
// Invoke a regular function. // Invoke a regular function.
__ bind(&regular_invoke); __ bind(&regular_invoke);
if (can_do_fast_api_call) {
FreeSpaceForFastApiCall(masm, scratch1);
}
} }
void CompileRegular(MacroAssembler* masm, void CompileRegular(MacroAssembler* masm,
...@@ -1190,7 +1150,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type, ...@@ -1190,7 +1150,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type,
Register scratch1, Register scratch1,
Register scratch2, Register scratch2,
Handle<Name> name, Handle<Name> name,
int save_at_depth,
Label* miss, Label* miss,
PrototypeCheckType check) { PrototypeCheckType check) {
Handle<Map> receiver_map(IC::TypeToMap(*type, isolate())); Handle<Map> receiver_map(IC::TypeToMap(*type, isolate()));
...@@ -1207,11 +1166,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type, ...@@ -1207,11 +1166,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type,
Register reg = object_reg; Register reg = object_reg;
int depth = 0; int depth = 0;
const int kHolderIndex = FunctionCallbackArguments::kHolderIndex + 1;
if (save_at_depth == depth) {
__ mov(Operand(esp, kHolderIndex * kPointerSize), reg);
}
Handle<JSObject> current = Handle<JSObject>::null(); Handle<JSObject> current = Handle<JSObject>::null();
if (type->IsConstant()) current = Handle<JSObject>::cast(type->AsConstant()); if (type->IsConstant()) current = Handle<JSObject>::cast(type->AsConstant());
Handle<JSObject> prototype = Handle<JSObject>::null(); Handle<JSObject> prototype = Handle<JSObject>::null();
...@@ -1279,10 +1233,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type, ...@@ -1279,10 +1233,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type,
} }
} }
if (save_at_depth == depth) {
__ mov(Operand(esp, kHolderIndex * kPointerSize), reg);
}
// Go to the next object in the prototype chain. // Go to the next object in the prototype chain.
current = prototype; current = prototype;
current_map = handle(current->map()); current_map = handle(current->map());
...@@ -1679,45 +1629,35 @@ Handle<Code> CallStubCompiler::CompileFastApiCall( ...@@ -1679,45 +1629,35 @@ Handle<Code> CallStubCompiler::CompileFastApiCall(
if (object->IsGlobalObject()) return Handle<Code>::null(); if (object->IsGlobalObject()) return Handle<Code>::null();
if (!cell.is_null()) return Handle<Code>::null(); if (!cell.is_null()) return Handle<Code>::null();
if (!object->IsJSObject()) return Handle<Code>::null(); if (!object->IsJSObject()) return Handle<Code>::null();
int depth = optimization.GetPrototypeDepthOfExpectedType( Handle<JSObject> receiver = Handle<JSObject>::cast(object);
Handle<JSObject>::cast(object), holder); CallOptimization::HolderLookup holder_lookup =
if (depth == kInvalidProtoDepth) return Handle<Code>::null(); CallOptimization::kHolderNotFound;
Handle<Map> lookup_map = optimization.LookupHolderOfExpectedType(
Label miss, miss_before_stack_reserved; receiver, receiver, holder, &holder_lookup);
if (holder_lookup == CallOptimization::kHolderNotFound) {
return Handle<Code>::null();
}
GenerateNameCheck(name, &miss_before_stack_reserved); Label miss;
GenerateNameCheck(name, &miss);
// Get the receiver from the stack. // Get the receiver from the stack.
const int argc = arguments().immediate(); const int argc = arguments().immediate();
__ mov(edx, Operand(esp, (argc + 1) * kPointerSize)); __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));
// Check that the receiver isn't a smi. // Check that the receiver isn't a smi.
__ JumpIfSmi(edx, &miss_before_stack_reserved); __ JumpIfSmi(edx, &miss);
Counters* counters = isolate()->counters(); Counters* counters = isolate()->counters();
__ IncrementCounter(counters->call_const(), 1); __ IncrementCounter(counters->call_const(), 1);
__ IncrementCounter(counters->call_const_fast_api(), 1);
// Allocate space for v8::Arguments implicit values. Must be initialized
// before calling any runtime function.
__ sub(esp, Immediate(kFastApiCallArguments * kPointerSize));
// Check that the maps haven't changed and find a Holder as a side effect. // Check that the maps haven't changed and find a Holder as a side effect.
CheckPrototypes(IC::CurrentTypeOf(object, isolate()), edx, holder, CheckPrototypes(IC::CurrentTypeOf(object, isolate()), edx, holder,
ebx, eax, edi, name, depth, &miss); ebx, eax, edi, name, &miss);
// Move the return address on top of the stack.
__ mov(eax, Operand(esp, kFastApiCallArguments * kPointerSize));
__ mov(Operand(esp, 0 * kPointerSize), eax);
// esp[2 * kPointerSize] is uninitialized, esp[3 * kPointerSize] contains GenerateFastApiCall(masm(), optimization, argc, lookup_map, holder_lookup);
// duplicate of return address and will be overwritten.
GenerateFastApiCall(masm(), optimization, argc);
__ bind(&miss); HandlerFrontendFooter(&miss);
__ add(esp, Immediate(kFastApiCallArguments * kPointerSize));
HandlerFrontendFooter(&miss_before_stack_reserved);
// Return the generated code. // Return the generated code.
return GetCode(function); return GetCode(function);
......
src/stub-cache.cc
View file @ 058c5c9f
...@@ -1994,20 +1994,45 @@ CallOptimization::CallOptimization(Handle<JSFunction> function) { ...@@ -1994,20 +1994,45 @@ CallOptimization::CallOptimization(Handle<JSFunction> function) {
} }
int CallOptimization::GetPrototypeDepthOfExpectedType( Handle<Map> CallOptimization::LookupHolderOfExpectedType(
Handle<JSObject> receiver,
Handle<JSObject> object, Handle<JSObject> object,
Handle<JSObject> holder) const { Handle<JSObject> holder,
HolderLookup* holder_lookup) const {
ASSERT(is_simple_api_call()); ASSERT(is_simple_api_call());
if (expected_receiver_type_.is_null()) return 0; ASSERT_EQ(kHolderNotFound, *holder_lookup);
int depth = 0; *holder_lookup = kHolderIsReceiver;
Handle<Map> map_to_holder;
if (expected_receiver_type_.is_null()) {
// no expected type, load from receiver.
return map_to_holder;
}
// walk down the prototype chain to the object
while (!receiver.is_identical_to(object)) {
*holder_lookup = kHolderIsPrototypeOfMap;
map_to_holder = Handle<Map>(receiver->map());
receiver = Handle<JSObject>(JSObject::cast(map_to_holder->prototype()));
ASSERT(!expected_receiver_type_->IsTemplateFor(*map_to_holder));
}
// start looking for the holder
while (!object.is_identical_to(holder)) { while (!object.is_identical_to(holder)) {
if (expected_receiver_type_->IsTemplateFor(object->map())) return depth; Handle<Map> object_map(object->map());
object = Handle<JSObject>(JSObject::cast(object->GetPrototype())); if (expected_receiver_type_->IsTemplateFor(*object_map)) {
if (!object->map()->is_hidden_prototype()) return kInvalidProtoDepth; return map_to_holder;
++depth; }
if (!object_map->is_hidden_prototype()) {
*holder_lookup = kHolderNotFound;
return Handle<Map>::null();
}
*holder_lookup = kHolderIsPrototypeOfMap;
map_to_holder = object_map;
object = Handle<JSObject>(JSObject::cast(object_map->prototype()));
}
if (expected_receiver_type_->IsTemplateFor(holder->map())) {
return map_to_holder;
} }
if (expected_receiver_type_->IsTemplateFor(holder->map())) return depth; *holder_lookup = kHolderNotFound;
return kInvalidProtoDepth; return Handle<Map>::null();
} }
......
src/stub-cache.h
View file @ 058c5c9f
...@@ -483,20 +483,6 @@ class StubCompiler BASE_EMBEDDED { ...@@ -483,20 +483,6 @@ class StubCompiler BASE_EMBEDDED {
Register scratch2, Register scratch2,
Handle<Name> name, Handle<Name> name,
Label* miss, Label* miss,
PrototypeCheckType check = CHECK_ALL_MAPS) {
return CheckPrototypes(type, object_reg, holder, holder_reg, scratch1,
scratch2, name, kInvalidProtoDepth, miss, check);
}
Register CheckPrototypes(Handle<Type> type,
Register object_reg,
Handle<JSObject> holder,
Register holder_reg,
Register scratch1,
Register scratch2,
Handle<Name> name,
int save_at_depth,
Label* miss,
PrototypeCheckType check = CHECK_ALL_MAPS); PrototypeCheckType check = CHECK_ALL_MAPS);
void GenerateBooleanCheck(Register object, Label* miss); void GenerateBooleanCheck(Register object, Label* miss);
...@@ -1028,10 +1014,19 @@ class CallOptimization BASE_EMBEDDED { ...@@ -1028,10 +1014,19 @@ class CallOptimization BASE_EMBEDDED {
return api_call_info_; return api_call_info_;
} }
// Returns the depth of the object having the expected type in the enum HolderLookup {
// prototype chain between the two arguments. kHolderNotFound,
int GetPrototypeDepthOfExpectedType(Handle<JSObject> object, kHolderIsReceiver,
Handle<JSObject> holder) const; kHolderIsPrototypeOfMap
};
// Returns a map whose prototype has the expected type in the
// prototype chain between the two arguments
// null will be returned if the first argument has that property
// lookup will be set accordingly
Handle<Map> LookupHolderOfExpectedType(Handle<JSObject> receiver,
Handle<JSObject> object,
Handle<JSObject> holder,
HolderLookup* holder_lookup) const;
bool IsCompatibleReceiver(Object* receiver) { bool IsCompatibleReceiver(Object* receiver) {
ASSERT(is_simple_api_call()); ASSERT(is_simple_api_call());
......
src/x64/stub-cache-x64.cc
View file @ 058c5c9f
...@@ -392,92 +392,57 @@ static void CompileCallLoadPropertyWithInterceptor( ...@@ -392,92 +392,57 @@ static void CompileCallLoadPropertyWithInterceptor(
static const int kFastApiCallArguments = FunctionCallbackArguments::kArgsLength; static const int kFastApiCallArguments = FunctionCallbackArguments::kArgsLength;
// Reserves space for the extra arguments to API function in the
// caller's frame.
//
// These arguments are set by CheckPrototypes and GenerateFastApiCall.
static void ReserveSpaceForFastApiCall(MacroAssembler* masm, Register scratch) {
// ----------- S t a t e -------------
// -- rsp[0] : return address
// -- rsp[8] : last argument in the internal frame of the caller
// -----------------------------------
__ movq(scratch, StackOperandForReturnAddress(0));
__ subq(rsp, Immediate(kFastApiCallArguments * kPointerSize));
__ movq(StackOperandForReturnAddress(0), scratch);
__ Move(scratch, Smi::FromInt(0));
StackArgumentsAccessor args(rsp, kFastApiCallArguments,
ARGUMENTS_DONT_CONTAIN_RECEIVER);
for (int i = 0; i < kFastApiCallArguments; i++) {
__ movp(args.GetArgumentOperand(i), scratch);
}
}
// Undoes the effects of ReserveSpaceForFastApiCall.
static void FreeSpaceForFastApiCall(MacroAssembler* masm, Register scratch) {
// ----------- S t a t e -------------
// -- rsp[0] : return address.
// -- rsp[8] : last fast api call extra argument.
// -- ...
// -- rsp[kFastApiCallArguments * 8] : first fast api call extra
// argument.
// -- rsp[kFastApiCallArguments * 8 + 8] : last argument in the internal
// frame.
// -----------------------------------
__ movq(scratch, StackOperandForReturnAddress(0));
__ movq(StackOperandForReturnAddress(kFastApiCallArguments * kPointerSize),
scratch);
__ addq(rsp, Immediate(kPointerSize * kFastApiCallArguments));
}
static void GenerateFastApiCallBody(MacroAssembler* masm, static void GenerateFastApiCallBody(MacroAssembler* masm,
const CallOptimization& optimization, const CallOptimization& optimization,
int argc, int argc,
Register holder,
Register scratch1,
Register scratch2,
Register scratch3,
bool restore_context); bool restore_context);
// Generates call to API function. // Generates call to API function.
static void GenerateFastApiCall(MacroAssembler* masm, static void GenerateFastApiCall(MacroAssembler* masm,
const CallOptimization& optimization, const CallOptimization& optimization,
int argc) { int argc,
typedef FunctionCallbackArguments FCA; Handle<Map> map_to_holder,
StackArgumentsAccessor args(rsp, argc + kFastApiCallArguments); CallOptimization::HolderLookup holder_lookup) {
Counters* counters = masm->isolate()->counters();
// Save calling context. __ IncrementCounter(counters->call_const_fast_api(), 1);
int offset = argc + kFastApiCallArguments;
__ movp(args.GetArgumentOperand(offset - FCA::kContextSaveIndex), rsi);
// Get the function and setup the context. // Move holder to a register
Handle<JSFunction> function = optimization.constant_function(); Register holder_reg = rax;
__ Move(rdi, function); switch (holder_lookup) {
__ movp(rsi, FieldOperand(rdi, JSFunction::kContextOffset)); case CallOptimization::kHolderIsReceiver:
// Construct the FunctionCallbackInfo on the stack. {
__ movp(args.GetArgumentOperand(offset - FCA::kCalleeIndex), rdi); ASSERT(map_to_holder.is_null());
Handle<CallHandlerInfo> api_call_info = optimization.api_call_info(); StackArgumentsAccessor args(rsp, argc);
Handle<Object> call_data(api_call_info->data(), masm->isolate()); __ movp(holder_reg, args.GetReceiverOperand());
if (masm->isolate()->heap()->InNewSpace(*call_data)) { }
__ Move(rcx, api_call_info); break;
__ movp(rbx, FieldOperand(rcx, CallHandlerInfo::kDataOffset)); case CallOptimization::kHolderIsPrototypeOfMap:
__ movp(args.GetArgumentOperand(offset - FCA::kDataIndex), rbx); {
} else { Handle<JSObject> holder(JSObject::cast(map_to_holder->prototype()));
__ Move(args.GetArgumentOperand(offset - FCA::kDataIndex), call_data); if (!masm->isolate()->heap()->InNewSpace(*holder)) {
__ Move(holder_reg, holder);
} else {
__ Move(holder_reg, map_to_holder);
__ movp(holder_reg, FieldOperand(holder_reg, Map::kPrototypeOffset));
}
}
break;
case CallOptimization::kHolderNotFound:
UNREACHABLE();
} }
__ Move(kScratchRegister, GenerateFastApiCallBody(masm,
ExternalReference::isolate_address(masm->isolate())); optimization,
__ movp(args.GetArgumentOperand(offset - FCA::kIsolateIndex), argc,
kScratchRegister); holder_reg,
__ LoadRoot(kScratchRegister, Heap::kUndefinedValueRootIndex); rbx,
__ movp(args.GetArgumentOperand(offset - FCA::kReturnValueDefaultValueIndex), rcx,
kScratchRegister); rdx,
__ movp(args.GetArgumentOperand(offset - FCA::kReturnValueOffset), false);
kScratchRegister);
// Prepare arguments.
STATIC_ASSERT(kFastApiCallArguments == 7);
__ lea(rax, args.GetArgumentOperand(offset - FCA::kHolderIndex));
GenerateFastApiCallBody(masm, optimization, argc, false);
} }
...@@ -493,13 +458,9 @@ static void GenerateFastApiCall(MacroAssembler* masm, ...@@ -493,13 +458,9 @@ static void GenerateFastApiCall(MacroAssembler* masm,
Register scratch3, Register scratch3,
int argc, int argc,
Register* values) { Register* values) {
ASSERT(optimization.is_simple_api_call());
__ PopReturnAddressTo(scratch1); __ PopReturnAddressTo(scratch1);
// receiver // receiver
__ push(receiver); __ push(receiver);
// Write the arguments to stack frame. // Write the arguments to stack frame.
for (int i = 0; i < argc; i++) { for (int i = 0; i < argc; i++) {
Register arg = values[argc-1-i]; Register arg = values[argc-1-i];
...@@ -509,6 +470,35 @@ static void GenerateFastApiCall(MacroAssembler* masm, ...@@ -509,6 +470,35 @@ static void GenerateFastApiCall(MacroAssembler* masm,
ASSERT(!scratch3.is(arg)); ASSERT(!scratch3.is(arg));
__ push(arg); __ push(arg);
} }
__ PushReturnAddressFrom(scratch1);
// Stack now matches JSFunction abi.
GenerateFastApiCallBody(masm,
optimization,
argc,
receiver,
scratch1,
scratch2,
scratch3,
true);
}
static void GenerateFastApiCallBody(MacroAssembler* masm,
const CallOptimization& optimization,
int argc,
Register holder,
Register scratch1,
Register scratch2,
Register scratch3,
bool restore_context) {
// ----------- S t a t e -------------
// -- rsp[0] : return address
// -- rsp[8] : last argument
// -- ...
// -- rsp[argc * 8] : first argument
// -- rsp[(argc + 1) * 8] : receiver
// -----------------------------------
ASSERT(optimization.is_simple_api_call());
typedef FunctionCallbackArguments FCA; typedef FunctionCallbackArguments FCA;
...@@ -521,6 +511,9 @@ static void GenerateFastApiCall(MacroAssembler* masm, ...@@ -521,6 +511,9 @@ static void GenerateFastApiCall(MacroAssembler* masm,
STATIC_ASSERT(FCA::kContextSaveIndex == 6); STATIC_ASSERT(FCA::kContextSaveIndex == 6);
STATIC_ASSERT(FCA::kArgsLength == 7); STATIC_ASSERT(FCA::kArgsLength == 7);
__ PopReturnAddressTo(scratch1);
ASSERT(!holder.is(rsi));
// context save // context save
__ push(rsi); __ push(rsi);
...@@ -557,36 +550,13 @@ static void GenerateFastApiCall(MacroAssembler* masm, ...@@ -557,36 +550,13 @@ static void GenerateFastApiCall(MacroAssembler* masm,
ExternalReference::isolate_address(masm->isolate())); ExternalReference::isolate_address(masm->isolate()));
__ push(scratch3); __ push(scratch3);
// holder // holder
__ push(receiver); __ push(holder);
ASSERT(!scratch1.is(rax)); ASSERT(!scratch1.is(rax));
// store receiver address for GenerateFastApiCallBody
__ movp(rax, rsp); __ movp(rax, rsp);
// Push return address back on stack.
__ PushReturnAddressFrom(scratch1); __ PushReturnAddressFrom(scratch1);
GenerateFastApiCallBody(masm, optimization, argc, true);
}
static void GenerateFastApiCallBody(MacroAssembler* masm,
const CallOptimization& optimization,
int argc,
bool restore_context) {
// ----------- S t a t e -------------
// -- rsp[0] : return address
// -- rsp[8] - rsp[56] : FunctionCallbackInfo, incl.
// : object passing the type check
// (set by CheckPrototypes)
// -- rsp[64] : last argument
// -- ...
// -- rsp[(argc + 7) * 8] : first argument
// -- rsp[(argc + 8) * 8] : receiver
//
// rax : receiver address
// -----------------------------------
typedef FunctionCallbackArguments FCA;
Handle<CallHandlerInfo> api_call_info = optimization.api_call_info();
// Function address is a foreign pointer outside V8's heap. // Function address is a foreign pointer outside V8's heap.
Address function_address = v8::ToCData<Address>(api_call_info->callback()); Address function_address = v8::ToCData<Address>(api_call_info->callback());
...@@ -682,38 +652,17 @@ class CallInterceptorCompiler BASE_EMBEDDED { ...@@ -682,38 +652,17 @@ class CallInterceptorCompiler BASE_EMBEDDED {
ASSERT(optimization.is_constant_call()); ASSERT(optimization.is_constant_call());
ASSERT(!lookup->holder()->IsGlobalObject()); ASSERT(!lookup->holder()->IsGlobalObject());
int depth1 = kInvalidProtoDepth;
int depth2 = kInvalidProtoDepth;
bool can_do_fast_api_call = false;
if (optimization.is_simple_api_call() &&
!lookup->holder()->IsGlobalObject()) {
depth1 = optimization.GetPrototypeDepthOfExpectedType(
object, interceptor_holder);
if (depth1 == kInvalidProtoDepth) {
depth2 = optimization.GetPrototypeDepthOfExpectedType(
interceptor_holder, Handle<JSObject>(lookup->holder()));
}
can_do_fast_api_call =
depth1 != kInvalidProtoDepth || depth2 != kInvalidProtoDepth;
}
Counters* counters = masm->isolate()->counters(); Counters* counters = masm->isolate()->counters();
__ IncrementCounter(counters->call_const_interceptor(), 1); __ IncrementCounter(counters->call_const_interceptor(), 1);
if (can_do_fast_api_call) {
__ IncrementCounter(counters->call_const_interceptor_fast_api(), 1);
ReserveSpaceForFastApiCall(masm, scratch1);
}
// Check that the maps from receiver to interceptor's holder // Check that the maps from receiver to interceptor's holder
// haven't changed and thus we can invoke interceptor. // haven't changed and thus we can invoke interceptor.
Label miss_cleanup; Label miss_cleanup;
Label* miss = can_do_fast_api_call ? &miss_cleanup : miss_label;
Register holder = Register holder =
stub_compiler_->CheckPrototypes( stub_compiler_->CheckPrototypes(
IC::CurrentTypeOf(object, masm->isolate()), receiver, IC::CurrentTypeOf(object, masm->isolate()), receiver,
interceptor_holder, scratch1, scratch2, scratch3, interceptor_holder, scratch1, scratch2, scratch3,
name, depth1, miss); name, miss_label);
// Invoke an interceptor and if it provides a value, // Invoke an interceptor and if it provides a value,
// branch to |regular_invoke|. // branch to |regular_invoke|.
...@@ -730,35 +679,41 @@ class CallInterceptorCompiler BASE_EMBEDDED { ...@@ -730,35 +679,41 @@ class CallInterceptorCompiler BASE_EMBEDDED {
stub_compiler_->CheckPrototypes( stub_compiler_->CheckPrototypes(
IC::CurrentTypeOf(interceptor_holder, masm->isolate()), holder, IC::CurrentTypeOf(interceptor_holder, masm->isolate()), holder,
handle(lookup->holder()), scratch1, scratch2, scratch3, handle(lookup->holder()), scratch1, scratch2, scratch3,
name, depth2, miss); name, miss_label);
} else { }
// CheckPrototypes has a side effect of fetching a 'holder'
// for API (object which is instanceof for the signature). It's Handle<Map> lookup_map;
// safe to omit it here, as if present, it should be fetched CallOptimization::HolderLookup holder_lookup =
// by the previous CheckPrototypes. CallOptimization::kHolderNotFound;
ASSERT(depth2 == kInvalidProtoDepth); if (optimization.is_simple_api_call() &&
!lookup->holder()->IsGlobalObject()) {
lookup_map = optimization.LookupHolderOfExpectedType(
object, object, interceptor_holder, &holder_lookup);
if (holder_lookup == CallOptimization::kHolderNotFound) {
lookup_map =
optimization.LookupHolderOfExpectedType(
object,
interceptor_holder,
Handle<JSObject>(lookup->holder()),
&holder_lookup);
}
} }
// Invoke function. // Invoke function.
if (can_do_fast_api_call) { if (holder_lookup != CallOptimization::kHolderNotFound) {
GenerateFastApiCall(masm, optimization, arguments_.immediate()); int argc = arguments_.immediate();
GenerateFastApiCall(masm,
optimization,
argc,
lookup_map,
holder_lookup);
} else { } else {
Handle<JSFunction> fun = optimization.constant_function(); Handle<JSFunction> fun = optimization.constant_function();
stub_compiler_->GenerateJumpFunction(object, fun); stub_compiler_->GenerateJumpFunction(object, fun);
} }
// Deferred code for fast API call case---clean preallocated space.
if (can_do_fast_api_call) {
__ bind(&miss_cleanup);
FreeSpaceForFastApiCall(masm, scratch1);
__ jmp(miss_label);
}
// Invoke a regular function. // Invoke a regular function.
__ bind(&regular_invoke); __ bind(&regular_invoke);
if (can_do_fast_api_call) {
FreeSpaceForFastApiCall(masm, scratch1);
}
} }
void CompileRegular(MacroAssembler* masm, void CompileRegular(MacroAssembler* masm,
...@@ -1120,7 +1075,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type, ...@@ -1120,7 +1075,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type,
Register scratch1, Register scratch1,
Register scratch2, Register scratch2,
Handle<Name> name, Handle<Name> name,
int save_at_depth,
Label* miss, Label* miss,
PrototypeCheckType check) { PrototypeCheckType check) {
Handle<Map> receiver_map(IC::TypeToMap(*type, isolate())); Handle<Map> receiver_map(IC::TypeToMap(*type, isolate()));
...@@ -1139,15 +1093,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type, ...@@ -1139,15 +1093,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type,
Register reg = object_reg; Register reg = object_reg;
int depth = 0; int depth = 0;
StackArgumentsAccessor args(rsp, kFastApiCallArguments,
ARGUMENTS_DONT_CONTAIN_RECEIVER);
const int kHolderIndex = kFastApiCallArguments - 1 -
FunctionCallbackArguments::kHolderIndex;
if (save_at_depth == depth) {
__ movp(args.GetArgumentOperand(kHolderIndex), object_reg);
}
Handle<JSObject> current = Handle<JSObject>::null(); Handle<JSObject> current = Handle<JSObject>::null();
if (type->IsConstant()) current = Handle<JSObject>::cast(type->AsConstant()); if (type->IsConstant()) current = Handle<JSObject>::cast(type->AsConstant());
Handle<JSObject> prototype = Handle<JSObject>::null(); Handle<JSObject> prototype = Handle<JSObject>::null();
...@@ -1213,10 +1158,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type, ...@@ -1213,10 +1158,6 @@ Register StubCompiler::CheckPrototypes(Handle<Type> type,
} }
} }
if (save_at_depth == depth) {
__ movp(args.GetArgumentOperand(kHolderIndex), reg);
}
// Go to the next object in the prototype chain. // Go to the next object in the prototype chain.
current = prototype; current = prototype;
current_map = handle(current->map()); current_map = handle(current->map());
...@@ -1606,43 +1547,35 @@ Handle<Code> CallStubCompiler::CompileFastApiCall( ...@@ -1606,43 +1547,35 @@ Handle<Code> CallStubCompiler::CompileFastApiCall(
if (object->IsGlobalObject()) return Handle<Code>::null(); if (object->IsGlobalObject()) return Handle<Code>::null();
if (!cell.is_null()) return Handle<Code>::null(); if (!cell.is_null()) return Handle<Code>::null();
if (!object->IsJSObject()) return Handle<Code>::null(); if (!object->IsJSObject()) return Handle<Code>::null();
int depth = optimization.GetPrototypeDepthOfExpectedType( Handle<JSObject> receiver = Handle<JSObject>::cast(object);
Handle<JSObject>::cast(object), holder); CallOptimization::HolderLookup holder_lookup =
if (depth == kInvalidProtoDepth) return Handle<Code>::null(); CallOptimization::kHolderNotFound;
Handle<Map> lookup_map = optimization.LookupHolderOfExpectedType(
receiver, receiver, holder, &holder_lookup);
if (holder_lookup == CallOptimization::kHolderNotFound) {
return Handle<Code>::null();
}
Label miss, miss_before_stack_reserved; Label miss;
GenerateNameCheck(name, &miss_before_stack_reserved); GenerateNameCheck(name, &miss);
const int argc = arguments().immediate(); const int argc = arguments().immediate();
StackArgumentsAccessor args(rsp, argc); StackArgumentsAccessor args(rsp, argc);
__ movp(rdx, args.GetReceiverOperand()); __ movp(rdx, args.GetReceiverOperand());
// Check that the receiver isn't a smi. // Check that the receiver isn't a smi.
__ JumpIfSmi(rdx, &miss_before_stack_reserved); __ JumpIfSmi(rdx, &miss);
Counters* counters = isolate()->counters(); Counters* counters = isolate()->counters();
__ IncrementCounter(counters->call_const(), 1); __ IncrementCounter(counters->call_const(), 1);
__ IncrementCounter(counters->call_const_fast_api(), 1);
// Allocate space for v8::Arguments implicit values. Must be initialized
// before calling any runtime function.
__ subq(rsp, Immediate(kFastApiCallArguments * kPointerSize));
// Check that the maps haven't changed and find a Holder as a side effect. // Check that the maps haven't changed and find a Holder as a side effect.
CheckPrototypes(IC::CurrentTypeOf(object, isolate()), rdx, holder, CheckPrototypes(IC::CurrentTypeOf(object, isolate()), rdx, holder,
rbx, rax, rdi, name, depth, &miss); rbx, rax, rdi, name, &miss);
// Move the return address on top of the stack.
__ movq(rax,
StackOperandForReturnAddress(kFastApiCallArguments * kPointerSize));
__ movq(StackOperandForReturnAddress(0), rax);
GenerateFastApiCall(masm(), optimization, argc); GenerateFastApiCall(masm(), optimization, argc, lookup_map, holder_lookup);
__ bind(&miss); HandlerFrontendFooter(&miss);
__ addq(rsp, Immediate(kFastApiCallArguments * kPointerSize));
HandlerFrontendFooter(&miss_before_stack_reserved);
// Return the generated code. // Return the generated code.
return GetCode(function); return GetCode(function);
......
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