src/arm/stub-cache-arm.cc - Issue 8332003: Handlify CallStubCompiler::CompileCallField.

Unified Diff: src/arm/stub-cache-arm.cc

Issue 8332003: Handlify CallStubCompiler::CompileCallField. (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge

Patch Set: Rename some functions on ARM. Created 9 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: src/arm/stub-cache-arm.cc

diff --git a/src/arm/stub-cache-arm.cc b/src/arm/stub-cache-arm.cc

index ce9eefadad77d22c5c415c50395eff01a8074d58..545c06c1dcca75863909d6641a2e60da4b04b0d2 100644

--- a/src/arm/stub-cache-arm.cc

+++ b/src/arm/stub-cache-arm.cc

@@ -95,7 +95,63 @@ static void ProbeTable(Isolate* isolate,

// must always call a backup property check that is complete.

// This function is safe to call if the receiver has fast properties.

// Name must be a symbol and receiver must be a heap object.

-MUST_USE_RESULT static MaybeObject* GenerateDictionaryNegativeLookup(

+static void GenerateDictionaryNegativeLookup(MacroAssembler* masm,

+ Label* miss_label,

+ Register receiver,

+ Handle<String> name,

+ Register scratch0,

+ Register scratch1) {

+ ASSERT(name->IsSymbol());

+ Counters* counters = masm->isolate()->counters();

+ __ IncrementCounter(counters->negative_lookups(), 1, scratch0, scratch1);

+ __ IncrementCounter(counters->negative_lookups_miss(), 1, scratch0, scratch1);

+ Label done;

+ const int kInterceptorOrAccessCheckNeededMask =

+ (1 << Map::kHasNamedInterceptor) | (1 << Map::kIsAccessCheckNeeded);

+ // Bail out if the receiver has a named interceptor or requires access checks.

+ Register map = scratch1;

+ __ ldr(map, FieldMemOperand(receiver, HeapObject::kMapOffset));

+ __ ldrb(scratch0, FieldMemOperand(map, Map::kBitFieldOffset));

+ __ tst(scratch0, Operand(kInterceptorOrAccessCheckNeededMask));

+ __ b(ne, miss_label);

+ // Check that receiver is a JSObject.

+ __ ldrb(scratch0, FieldMemOperand(map, Map::kInstanceTypeOffset));

+ __ cmp(scratch0, Operand(FIRST_SPEC_OBJECT_TYPE));

+ __ b(lt, miss_label);

+ // Load properties array.

+ Register properties = scratch0;

+ __ ldr(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));

+ // Check that the properties array is a dictionary.

+ __ ldr(map, FieldMemOperand(properties, HeapObject::kMapOffset));

+ Register tmp = properties;

+ __ LoadRoot(tmp, Heap::kHashTableMapRootIndex);

+ __ cmp(map, tmp);

+ __ b(ne, miss_label);

+ // Restore the temporarily used register.

+ __ ldr(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));

+ StringDictionaryLookupStub::GenerateNegativeLookup(masm,

Kevin Millikin (Chromium) 2011/10/24 15:55:12 This is the only change from the original.

+ miss_label,

+ &done,

+ receiver,

+ properties,

+ name,

+ scratch1);

+ __ bind(&done);

+ __ DecrementCounter(counters->negative_lookups_miss(), 1, scratch0, scratch1);

+// TODO(kmillikin): Eliminate this function when the stub cache is fully

+// handlified.

+MUST_USE_RESULT static MaybeObject* TryGenerateDictionaryNegativeLookup(

MacroAssembler* masm,

Label* miss_label,

@@ -138,7 +194,7 @@ MUST_USE_RESULT static MaybeObject* GenerateDictionaryNegativeLookup(

__ ldr(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));

- MaybeObject* result = StringDictionaryLookupStub::GenerateNegativeLookup(

+ MaybeObject* result = StringDictionaryLookupStub::TryGenerateNegativeLookup(

masm,

miss_label,

&done,

@@ -259,8 +315,10 @@ void StubCompiler::GenerateDirectLoadGlobalFunctionPrototype(

// are loaded directly otherwise the property is loaded from the properties

// fixed array.

void StubCompiler::GenerateFastPropertyLoad(MacroAssembler* masm,

- Register dst, Register src,

- JSObject* holder, int index) {

+ Register dst,

+ Register src,

+ Handle<JSObject> holder,

+ int index) {

// Adjust for the number of properties stored in the holder.

index -= holder->map()->inobject_properties();

if (index < 0) {

@@ -480,7 +538,7 @@ void StubCompiler::GenerateLoadMiss(MacroAssembler* masm, Code::Kind kind) {

static void GenerateCallFunction(MacroAssembler* masm,

- Object* object,

+ Handle<Object> object,

const ParameterCount& arguments,

Label* miss,

Code::ExtraICState extra_ic_state) {

@@ -868,7 +926,26 @@ class CallInterceptorCompiler BASE_EMBEDDED {

// Generate code to check that a global property cell is empty. Create

// the property cell at compilation time if no cell exists for the

// property.

-MUST_USE_RESULT static MaybeObject* GenerateCheckPropertyCell(

+static void GenerateCheckPropertyCell(MacroAssembler* masm,

+ Handle<GlobalObject> global,

+ Handle<String> name,

+ Register scratch,

+ Label* miss) {

+ Handle<JSGlobalPropertyCell> cell =

+ GlobalObject::EnsurePropertyCell(global, name);

+ ASSERT(cell->value()->IsTheHole());

+ __ mov(scratch, Operand(cell));

+ __ ldr(scratch,

+ FieldMemOperand(scratch, JSGlobalPropertyCell::kValueOffset));

+ __ LoadRoot(ip, Heap::kTheHoleValueRootIndex);

+ __ cmp(scratch, ip);

+ __ b(ne, miss);

+// TODO(kmillikin): Eliminate this function when the stub cache is fully

+// handlified.

+MUST_USE_RESULT static MaybeObject* TryGenerateCheckPropertyCell(

MacroAssembler* masm,

GlobalObject* global,

String* name,

@@ -889,9 +966,32 @@ MUST_USE_RESULT static MaybeObject* GenerateCheckPropertyCell(

return cell;

}

// Calls GenerateCheckPropertyCell for each global object in the prototype chain

// from object to (but not including) holder.

-MUST_USE_RESULT static MaybeObject* GenerateCheckPropertyCells(

+static void GenerateCheckPropertyCells(MacroAssembler* masm,

+ Handle<JSObject> object,

+ Handle<JSObject> holder,

+ Handle<String> name,

+ Register scratch,

+ Label* miss) {

+ Handle<JSObject> current = object;

+ while (!current.is_identical_to(holder)) {

+ if (current->IsGlobalObject()) {

+ GenerateCheckPropertyCell(masm,

+ Handle<GlobalObject>::cast(current),

+ name,

+ scratch,

+ miss);

+ }

+ current = Handle<JSObject>(JSObject::cast(current->GetPrototype()));

+ }

+// TODO(kmillikin): Eliminate this function when the stub cache is fully

+// handlified.

+MUST_USE_RESULT static MaybeObject* TryGenerateCheckPropertyCells(

MacroAssembler* masm,

JSObject* object,

JSObject* holder,

@@ -902,7 +1002,7 @@ MUST_USE_RESULT static MaybeObject* GenerateCheckPropertyCells(

while (current != holder) {

if (current->IsGlobalObject()) {

// Returns a cell or a failure.

- MaybeObject* result = GenerateCheckPropertyCell(

+ MaybeObject* result = TryGenerateCheckPropertyCell(

masm,

GlobalObject::cast(current),

name,

@@ -1027,6 +1127,112 @@ static void GenerateUInt2Double(MacroAssembler* masm,

#define __ ACCESS_MASM(masm())

+Register StubCompiler::CheckPrototypes(Handle<JSObject> object,

+ Register object_reg,

+ Handle<JSObject> holder,

+ Register holder_reg,

+ Register scratch1,

+ Register scratch2,

+ Handle<String> name,

+ int save_at_depth,

+ Label* miss) {

+ // Make sure there's no overlap between holder and object registers.

+ ASSERT(!scratch1.is(object_reg) && !scratch1.is(holder_reg));

+ ASSERT(!scratch2.is(object_reg) && !scratch2.is(holder_reg)

+ && !scratch2.is(scratch1));

+ // Keep track of the current object in register reg.

+ Register reg = object_reg;

+ int depth = 0;

+ if (save_at_depth == depth) {

+ __ str(reg, MemOperand(sp));

+ }

+ // Check the maps in the prototype chain.

+ // Traverse the prototype chain from the object and do map checks.

+ Handle<JSObject> current = object;

+ while (!current.is_identical_to(holder)) {

+ ++depth;

+ // Only global objects and objects that do not require access

+ // checks are allowed in stubs.

+ ASSERT(current->IsJSGlobalProxy() || !current->IsAccessCheckNeeded());

+ Handle<JSObject> prototype(JSObject::cast(current->GetPrototype()));

+ if (!current->HasFastProperties() &&

+ !current->IsJSGlobalObject() &&

+ !current->IsJSGlobalProxy()) {

+ if (!name->IsSymbol()) {

+ name = factory()->LookupSymbol(name);

+ }

+ ASSERT(current->property_dictionary()->FindEntry(*name) ==

+ StringDictionary::kNotFound);

+ GenerateDictionaryNegativeLookup(masm(), miss, reg, name,

+ scratch1, scratch2);

+ __ ldr(scratch1, FieldMemOperand(reg, HeapObject::kMapOffset));

+ reg = holder_reg; // From now on the object will be in holder_reg.

+ __ ldr(reg, FieldMemOperand(scratch1, Map::kPrototypeOffset));

+ } else {

+ Handle<Map> current_map(current->map());

+ __ ldr(scratch1, FieldMemOperand(reg, HeapObject::kMapOffset));

+ __ cmp(scratch1, Operand(current_map));

+ // Branch on the result of the map check.

+ __ b(ne, miss);

+ // Check access rights to the global object. This has to happen after

+ // the map check so that we know that the object is actually a global

+ // object.

+ if (current->IsJSGlobalProxy()) {

+ __ CheckAccessGlobalProxy(reg, scratch2, miss);

+ }

+ reg = holder_reg; // From now on the object will be in holder_reg.

+ if (heap()->InNewSpace(*prototype)) {

+ // The prototype is in new space; we cannot store a reference to it

+ // in the code. Load it from the map.

+ __ ldr(reg, FieldMemOperand(scratch1, Map::kPrototypeOffset));

+ } else {

+ // The prototype is in old space; load it directly.

+ __ mov(reg, Operand(prototype));

+ }

+ if (save_at_depth == depth) {

+ __ str(reg, MemOperand(sp));

+ }

+ // Go to the next object in the prototype chain.

+ current = prototype;

+ }

+ // Log the check depth.

+ LOG(masm()->isolate(), IntEvent("check-maps-depth", depth + 1));

+ // Check the holder map.

+ __ ldr(scratch1, FieldMemOperand(reg, HeapObject::kMapOffset));

+ __ cmp(scratch1, Operand(Handle<Map>(current->map())));

+ __ b(ne, miss);

+ // Perform security check for access to the global object.

+ ASSERT(holder->IsJSGlobalProxy() || !holder->IsAccessCheckNeeded());

+ if (holder->IsJSGlobalProxy()) {

+ __ CheckAccessGlobalProxy(reg, scratch1, miss);

+ }

+ // If we've skipped any global objects, it's not enough to verify that

+ // their maps haven't changed. We also need to check that the property

+ // cell for the property is still empty.

+ GenerateCheckPropertyCells(masm(), object, holder, name, scratch1, miss);

+ // Return the register containing the holder.

+ return reg;

+// TODO(kmillikin): Eliminate this function when the stub cache is fully

+// handlified.

JSObject* holder,

@@ -1076,12 +1282,13 @@ Register StubCompiler::CheckPrototypes(JSObject* object,

ASSERT(current->property_dictionary()->FindEntry(name) ==

StringDictionary::kNotFound);

- MaybeObject* negative_lookup = GenerateDictionaryNegativeLookup(masm(),

- miss,

- reg,

- name,

- scratch1,

- scratch2);

+ MaybeObject* negative_lookup =

+ TryGenerateDictionaryNegativeLookup(masm(),

+ miss,

+ reg,

+ name,

+ scratch1,

+ scratch2);

if (negative_lookup->IsFailure()) {

set_failure(Failure::cast(negative_lookup));

return reg;

@@ -1150,17 +1357,17 @@ Register StubCompiler::CheckPrototypes(JSObject* object,

ASSERT(holder->IsJSGlobalProxy() || !holder->IsAccessCheckNeeded());

if (holder->IsJSGlobalProxy()) {

__ CheckAccessGlobalProxy(reg, scratch1, miss);

- };

+ }

// If we've skipped any global objects, it's not enough to verify

// that their maps haven't changed. We also need to check that the

// property cell for the property is still empty.

- MaybeObject* result = GenerateCheckPropertyCells(masm(),

- object,

- holder,

- name,

- scratch1,

- miss);

+ MaybeObject* result = TryGenerateCheckPropertyCells(masm(),

+ object,

+ holder,

+ name,

+ scratch1,

+ miss);

if (result->IsFailure()) set_failure(Failure::cast(result));

// Return the register containing the holder.

@@ -1184,7 +1391,7 @@ void StubCompiler::GenerateLoadField(JSObject* object,

CheckPrototypes(object, receiver, holder, scratch1, scratch2, scratch3,

name, miss);

- GenerateFastPropertyLoad(masm(), r0, reg, holder, index);

+ GenerateFastPropertyLoad(masm(), r0, reg, Handle<JSObject>(holder), index);

__ Ret();

}

@@ -1365,7 +1572,8 @@ void StubCompiler::GenerateLoadInterceptor(JSObject* object,

// We found FIELD property in prototype chain of interceptor's holder.

// Retrieve a field from field's holder.

GenerateFastPropertyLoad(masm(), r0, holder_reg,

- lookup->holder(), lookup->GetFieldIndex());

+ Handle<JSObject>(lookup->holder()),

+ lookup->GetFieldIndex());

__ Ret();

} else {

// We found CALLBACKS property in prototype chain of interceptor's

@@ -1416,9 +1624,9 @@ void StubCompiler::GenerateLoadInterceptor(JSObject* object,

}

-void CallStubCompiler::GenerateNameCheck(String* name, Label* miss) {

+void CallStubCompiler::GenerateNameCheck(Handle<String> name, Label* miss) {

if (kind_ == Code::KEYED_CALL_IC) {

- __ cmp(r2, Operand(Handle<String>(name)));

+ __ cmp(r2, Operand(name));

__ b(ne, miss);

}

@@ -1478,7 +1686,18 @@ void CallStubCompiler::GenerateLoadFunctionFromCell(JSGlobalPropertyCell* cell,

}

-MaybeObject* CallStubCompiler::GenerateMissBranch() {

+void CallStubCompiler::GenerateMissBranch() {

+ Handle<Code> code =

+ isolate()->stub_cache()->ComputeCallMiss(arguments().immediate(),

+ kind_,

+ extra_state_);

+ __ Jump(code, RelocInfo::CODE_TARGET);

+// TODO(kmillikin): Eliminate this function when the stub cache is fully

+// handlified.

+MaybeObject* CallStubCompiler::TryGenerateMissBranch() {

MaybeObject* maybe_obj =

isolate()->stub_cache()->TryComputeCallMiss(arguments().immediate(),

kind_,

@@ -1490,10 +1709,10 @@ MaybeObject* CallStubCompiler::GenerateMissBranch() {

}

-MaybeObject* CallStubCompiler::CompileCallField(JSObject* object,

- JSObject* holder,

+Handle<Code> CallStubCompiler::CompileCallField(Handle<JSObject> object,

Kevin Millikin (Chromium) 2011/10/24 15:55:12 This function is the only stub compiler one that w

+ Handle<JSObject> holder,

int index,

- String* name) {

+ Handle<String> name) {

// ----------- S t a t e -------------

// -- r2 : name

// -- lr : return address

@@ -1517,8 +1736,7 @@ MaybeObject* CallStubCompiler::CompileCallField(JSObject* object,

// Handle call cache miss.

__ bind(&miss);

- MaybeObject* maybe_result = GenerateMissBranch();

- if (maybe_result->IsFailure()) return maybe_result;

+ GenerateMissBranch();

// Return the generated code.

return GetCode(FIELD, name);

@@ -1543,7 +1761,7 @@ MaybeObject* CallStubCompiler::CompileArrayPushCall(Object* object,

Label miss;

- GenerateNameCheck(name, &miss);

+ GenerateNameCheck(Handle<String>(name), &miss);

@@ -1709,11 +1927,11 @@ MaybeObject* CallStubCompiler::CompileArrayPushCall(Object* object,

// Handle call cache miss.

__ bind(&miss);

- MaybeObject* maybe_result = GenerateMissBranch();

+ MaybeObject* maybe_result = TryGenerateMissBranch();

if (maybe_result->IsFailure()) return maybe_result;

// Return the generated code.

- return GetCode(function);

+ return TryGetCode(function);

}

@@ -1738,7 +1956,7 @@ MaybeObject* CallStubCompiler::CompileArrayPopCall(Object* object,

- GenerateNameCheck(name, &miss);

+ GenerateNameCheck(Handle<String>(name), &miss);

// Get the receiver from the stack

const int argc = arguments().immediate();

@@ -1798,11 +2016,11 @@ MaybeObject* CallStubCompiler::CompileArrayPopCall(Object* object,

// Handle call cache miss.

__ bind(&miss);

- MaybeObject* maybe_result = GenerateMissBranch();

+ MaybeObject* maybe_result = TryGenerateMissBranch();

if (maybe_result->IsFailure()) return maybe_result;

// Return the generated code.

- return GetCode(function);

+ return TryGetCode(function);

}

@@ -1836,7 +2054,7 @@ MaybeObject* CallStubCompiler::CompileStringCharCodeAtCall(

index_out_of_range_label = &miss;

}

- GenerateNameCheck(name, &name_miss);

+ GenerateNameCheck(Handle<String>(name), &name_miss);

// Check that the maps starting from the prototype haven't changed.

GenerateDirectLoadGlobalFunctionPrototype(masm(),

@@ -1884,11 +2102,11 @@ MaybeObject* CallStubCompiler::CompileStringCharCodeAtCall(

// Restore function name in r2.

__ Move(r2, Handle<String>(name));

__ bind(&name_miss);

- MaybeObject* maybe_result = GenerateMissBranch();

+ MaybeObject* maybe_result = TryGenerateMissBranch();

if (maybe_result->IsFailure()) return maybe_result;

// Return the generated code.

- return GetCode(function);

+ return TryGetCode(function);

}

@@ -1922,7 +2140,7 @@ MaybeObject* CallStubCompiler::CompileStringCharAtCall(

index_out_of_range_label = &miss;

}

- GenerateNameCheck(name, &name_miss);

+ GenerateNameCheck(Handle<String>(name), &name_miss);

// Check that the maps starting from the prototype haven't changed.

GenerateDirectLoadGlobalFunctionPrototype(masm(),

@@ -1972,11 +2190,11 @@ MaybeObject* CallStubCompiler::CompileStringCharAtCall(

// Restore function name in r2.

__ Move(r2, Handle<String>(name));

__ bind(&name_miss);

- MaybeObject* maybe_result = GenerateMissBranch();

+ MaybeObject* maybe_result = TryGenerateMissBranch();

if (maybe_result->IsFailure()) return maybe_result;

// Return the generated code.

- return GetCode(function);

+ return TryGetCode(function);

}

@@ -2001,7 +2219,7 @@ MaybeObject* CallStubCompiler::CompileStringFromCharCodeCall(

if (!object->IsJSObject() || argc != 1) return heap()->undefined_value();

Label miss;

- GenerateNameCheck(name, &miss);

+ GenerateNameCheck(Handle<String>(name), &miss);

if (cell == NULL) {

__ ldr(r1, MemOperand(sp, 1 * kPointerSize));

@@ -2044,11 +2262,11 @@ MaybeObject* CallStubCompiler::CompileStringFromCharCodeCall(

__ bind(&miss);

// r2: function name.

- MaybeObject* maybe_result = GenerateMissBranch();

+ MaybeObject* maybe_result = TryGenerateMissBranch();

if (maybe_result->IsFailure()) return maybe_result;

// Return the generated code.

- return (cell == NULL) ? GetCode(function) : GetCode(NORMAL, name);

+ return (cell == NULL) ? TryGetCode(function) : TryGetCode(NORMAL, name);

}

@@ -2078,7 +2296,7 @@ MaybeObject* CallStubCompiler::CompileMathFloorCall(Object* object,

if (!object->IsJSObject() || argc != 1) return heap()->undefined_value();

Label miss, slow;

- GenerateNameCheck(name, &miss);

+ GenerateNameCheck(Handle<String>(name), &miss);

if (cell == NULL) {

__ ldr(r1, MemOperand(sp, 1 * kPointerSize));

@@ -2192,11 +2410,11 @@ MaybeObject* CallStubCompiler::CompileMathFloorCall(Object* object,

__ bind(&miss);

// r2: function name.

- MaybeObject* maybe_result = GenerateMissBranch();

+ MaybeObject* maybe_result = TryGenerateMissBranch();

if (maybe_result->IsFailure()) return maybe_result;

// Return the generated code.

- return (cell == NULL) ? GetCode(function) : GetCode(NORMAL, name);

+ return (cell == NULL) ? TryGetCode(function) : TryGetCode(NORMAL, name);

}

@@ -2220,7 +2438,7 @@ MaybeObject* CallStubCompiler::CompileMathAbsCall(Object* object,

if (!object->IsJSObject() || argc != 1) return heap()->undefined_value();

Label miss;

- GenerateNameCheck(name, &miss);

+ GenerateNameCheck(Handle<String>(name), &miss);

if (cell == NULL) {

__ ldr(r1, MemOperand(sp, 1 * kPointerSize));

@@ -2293,11 +2511,11 @@ MaybeObject* CallStubCompiler::CompileMathAbsCall(Object* object,

__ bind(&miss);

// r2: function name.

- MaybeObject* maybe_result = GenerateMissBranch();

+ MaybeObject* maybe_result = TryGenerateMissBranch();

if (maybe_result->IsFailure()) return maybe_result;

// Return the generated code.

- return (cell == NULL) ? GetCode(function) : GetCode(NORMAL, name);

+ return (cell == NULL) ? TryGetCode(function) : TryGetCode(NORMAL, name);

}

@@ -2322,7 +2540,7 @@ MaybeObject* CallStubCompiler::CompileFastApiCall(

Label miss, miss_before_stack_reserved;

- GenerateNameCheck(name, &miss_before_stack_reserved);

+ GenerateNameCheck(Handle<String>(name), &miss_before_stack_reserved);

// Get the receiver from the stack.

const int argc = arguments().immediate();

@@ -2347,11 +2565,11 @@ MaybeObject* CallStubCompiler::CompileFastApiCall(

FreeSpaceForFastApiCall(masm());

__ bind(&miss_before_stack_reserved);

- MaybeObject* maybe_result = GenerateMissBranch();

+ MaybeObject* maybe_result = TryGenerateMissBranch();

if (maybe_result->IsFailure()) return maybe_result;

// Return the generated code.

- return GetCode(function);

+ return TryGetCode(function);

}

@@ -2375,7 +2593,7 @@ MaybeObject* CallStubCompiler::CompileCallConstant(Object* object,

Label miss;

- GenerateNameCheck(name, &miss);

+ GenerateNameCheck(Handle<String>(name), &miss);

// Get the receiver from the stack

const int argc = arguments().immediate();

@@ -2481,11 +2699,11 @@ MaybeObject* CallStubCompiler::CompileCallConstant(Object* object,

// Handle call cache miss.

__ bind(&miss);

- MaybeObject* maybe_result = GenerateMissBranch();

+ MaybeObject* maybe_result = TryGenerateMissBranch();

if (maybe_result->IsFailure()) return maybe_result;

// Return the generated code.

- return GetCode(function);

+ return TryGetCode(function);

}

@@ -2499,7 +2717,7 @@ MaybeObject* CallStubCompiler::CompileCallInterceptor(JSObject* object,

Label miss;

- GenerateNameCheck(name, &miss);

+ GenerateNameCheck(Handle<String>(name), &miss);

// Get the number of arguments.

const int argc = arguments().immediate();

@@ -2530,15 +2748,16 @@ MaybeObject* CallStubCompiler::CompileCallInterceptor(JSObject* object,

// Restore receiver.

__ ldr(r0, MemOperand(sp, argc * kPointerSize));

- GenerateCallFunction(masm(), object, arguments(), &miss, extra_state_);

+ GenerateCallFunction(masm(), Handle<Object>(object), arguments(), &miss,

+ extra_state_);

// Handle call cache miss.

__ bind(&miss);

- MaybeObject* maybe_result = GenerateMissBranch();

+ MaybeObject* maybe_result = TryGenerateMissBranch();

if (maybe_result->IsFailure()) return maybe_result;

// Return the generated code.

- return GetCode(INTERCEPTOR, name);

+ return TryGetCode(INTERCEPTOR, name);

}

@@ -2563,7 +2782,7 @@ MaybeObject* CallStubCompiler::CompileCallGlobal(JSObject* object,

Label miss;

- GenerateNameCheck(name, &miss);

+ GenerateNameCheck(Handle<String>(name), &miss);

// Get the number of arguments.

const int argc = arguments().immediate();

@@ -2600,11 +2819,11 @@ MaybeObject* CallStubCompiler::CompileCallGlobal(JSObject* object,

// Handle call cache miss.

__ bind(&miss);

__ IncrementCounter(counters->call_global_inline_miss(), 1, r1, r3);

- MaybeObject* maybe_result = GenerateMissBranch();

+ MaybeObject* maybe_result = TryGenerateMissBranch();

if (maybe_result->IsFailure()) return maybe_result;

// Return the generated code.

- return GetCode(NORMAL, name);

+ return TryGetCode(NORMAL, name);

}

@@ -2802,11 +3021,11 @@ MaybeObject* LoadStubCompiler::CompileLoadNonexistent(String* name,

// If the last object in the prototype chain is a global object,

// check that the global property cell is empty.

if (last->IsGlobalObject()) {

- MaybeObject* cell = GenerateCheckPropertyCell(masm(),

- GlobalObject::cast(last),

- name,

- r1,

- &miss);

+ MaybeObject* cell = TryGenerateCheckPropertyCell(masm(),

+ GlobalObject::cast(last),

+ name,

+ r1,

+ &miss);

if (cell->IsFailure()) {

miss.Unuse();

return cell;

« src/arm/code-stubs-arm.cc ('K') | « src/arm/code-stubs-arm.cc ('k') | src/ia32/code-stubs-ia32.h » ('j') | src/x64/stub-cache-x64.cc » ('J')