Lines Matching refs:Handle
128 Handle<String> name,
261 // Cache miss: Fall-through and let caller handle the miss by
299 Handle<JSFunction> function(
302 __ li(prototype, Handle<Map>(function->initial_map()));
314 Handle<JSObject> holder,
422 Handle<JSObject> object,
424 Handle<Map> transition,
434 __ CheckMap(receiver_reg, scratch, Handle<Map>(object->map()), miss_label,
519 Handle<Code> code = (kind == Code::LOAD_IC)
527 Handle<Object> object,
559 Handle<JSObject> holder_obj) {
561 Handle<InterceptorInfo> interceptor(holder_obj->GetNamedInterceptor());
576 Handle<JSObject> holder_obj) {
625 Handle<JSFunction> function = optimization.constant_function();
630 Handle<CallHandlerInfo> api_call_info = optimization.api_call_info();
631 Handle<Object> call_data(api_call_info->data());
655 // will handle setting up a0.
695 Handle<JSObject> object,
696 Handle<JSObject> holder,
697 Handle<String> name,
721 Handle<JSObject> object,
726 Handle<JSObject> interceptor_holder,
728 Handle<String> name,
743 interceptor_holder, Handle<JSObject>(lookup->holder()));
780 Handle<JSObject>(lookup->holder()),
817 Handle<JSObject> object,
822 Handle<String> name,
823 Handle<JSObject> interceptor_holder,
850 Handle<JSObject> holder_obj,
882 Handle<GlobalObject> global,
883 Handle<String> name,
886 Handle<JSGlobalPropertyCell> cell =
900 Handle<JSObject> object,
901 Handle<JSObject> holder,
902 Handle<String> name,
905 Handle<JSObject> current = object;
909 Handle<GlobalObject>::cast(current),
914 current = Handle<JSObject>(JSObject::cast(current->GetPrototype()));
1039 Register StubCompiler::CheckPrototypes(Handle<JSObject> object,
1041 Handle<JSObject> holder,
1045 Handle<String> name,
1063 Handle<JSObject> current = object;
1071 Handle<JSObject> prototype(JSObject::cast(current->GetPrototype()));
1088 Handle<Map> current_map(current->map());
1121 __ CheckMap(reg, scratch1, Handle<Map>(current->map()), miss,
1140 void StubCompiler::GenerateLoadField(Handle<JSObject> object,
1141 Handle<JSObject> holder,
1147 Handle<String> name,
1160 void StubCompiler::GenerateLoadConstant(Handle<JSObject> object,
1161 Handle<JSObject> holder,
1166 Handle<JSFunction> value,
1167 Handle<String> name,
1182 void StubCompiler::GenerateLoadCallback(Handle<JSObject> object,
1183 Handle<JSObject> holder,
1189 Handle<AccessorInfo> callback,
1190 Handle<String> name,
1207 __ li(scratch3, Handle<Object>(callback->data()));
1211 __ mov(a1, sp); // a1 (first argument - see note below) = Handle<String>
1216 // will handle setting up a0.
1239 void StubCompiler::GenerateLoadInterceptor(Handle<JSObject> object,
1240 Handle<JSObject> interceptor_holder,
1247 Handle<String> name,
1317 Handle<JSObject>(lookup->holder()),
1329 Handle<JSObject>(lookup->holder()),
1336 Handle<AccessorInfo> callback(
1379 void CallStubCompiler::GenerateNameCheck(Handle<String> name, Label* miss) {
1386 void CallStubCompiler::GenerateGlobalReceiverCheck(Handle<JSObject> object,
1387 Handle<JSObject> holder,
1388 Handle<String> name,
1405 Handle<JSGlobalPropertyCell> cell,
1406 Handle<JSFunction> function,
1424 __ li(a3, Handle<SharedFunctionInfo>(function->shared()));
1434 Handle<Code> code =
1442 Handle<Code> CallStubCompiler::CompileCallField(Handle<JSObject> object,
1443 Handle<JSObject> holder,
1445 Handle<String> name) {
1467 // Handle call cache miss.
1476 Handle<Code> CallStubCompiler::CompileArrayPushCall(
1477 Handle<Object> object,
1478 Handle<JSObject> holder,
1479 Handle<JSGlobalPropertyCell> cell,
1480 Handle<JSFunction> function,
1481 Handle<String> name) {
1491 if (!object->IsJSArray() || !cell.is_null()) return Handle<Code>::null();
1507 CheckPrototypes(Handle<JSObject>::cast(object), receiver, holder, a3, v0, t0,
1677 // Handle call cache miss.
1686 Handle<Code> CallStubCompiler::CompileArrayPopCall(
1687 Handle<Object> object,
1688 Handle
1689 Handle<JSGlobalPropertyCell> cell,
1690 Handle<JSFunction> function,
1691 Handle<String> name) {
1701 if (!object->IsJSArray() || !cell.is_null()) return Handle<Code>::null();
1715 CheckPrototypes(Handle<JSObject>::cast(object), receiver, holder, elements,
1763 // Handle call cache miss.
1772 Handle<Code> CallStubCompiler::CompileStringCharCodeAtCall(
1773 Handle<Object> object,
1774 Handle<JSObject> holder,
1775 Handle<JSGlobalPropertyCell> cell,
1776 Handle<JSFunction> function,
1777 Handle<String> name) {
1787 if (!object->IsString() || !cell.is_null()) return Handle<Code>::null();
1810 CheckPrototypes(Handle<JSObject>(JSObject::cast(object->GetPrototype())),
1855 Handle<Code> CallStubCompiler::CompileStringCharAtCall(
1856 Handle<Object> object,
1857 Handle<JSObject> holder,
1858 Handle<JSGlobalPropertyCell> cell,
1859 Handle<JSFunction> function,
1860 Handle<String> name) {
1870 if (!object->IsString() || !cell.is_null()) return Handle<Code>::null();
1890 CheckPrototypes(Handle<JSObject>(JSObject::cast(object->GetPrototype())),
1937 Handle<Code> CallStubCompiler::CompileStringFromCharCodeCall(
1938 Handle<Object> object,
1939 Handle<JSObject> holder,
1940 Handle<JSGlobalPropertyCell> cell,
1941 Handle<JSFunction> function,
1942 Handle<String> name) {
1955 if (!object->IsJSObject() || argc != 1) return Handle<Code>::null();
1966 CheckPrototypes(Handle<JSObject>::cast(object), a1, holder, v0, a3, t0,
1970 GenerateGlobalReceiverCheck(Handle<JSObject>::cast(object), holder, name,
2010 Handle<Code> CallStubCompiler::CompileMathFloorCall(
2011 Handle<Object> object,
2012 Handle<JSObject> holder,
2013 Handle<JSGlobalPropertyCell> cell,
2014 Handle<JSFunction> function,
2015 Handle<String> name) {
2025 return Handle<Code>::null();
2032 if (!object->IsJSObject() || argc != 1) return Handle<Code>::null();
2041 CheckPrototypes(Handle<JSObject>::cast(object), a1, holder, a0, a3, t0,
2045 GenerateGlobalReceiverCheck(Handle<JSObject>::cast(object), holder, name,
2144 Handle<Code> CallStubCompiler::CompileMathAbsCall(
2145 Handle<Object> object,
2146 Handle<JSObject> holder,
2147 Handle<JSGlobalPropertyCell> cell,
2148 Handle<JSFunction> function,
2149 Handle<String> name) {
2161 if (!object->IsJSObject() || argc != 1) return Handle<Code>::null();
2170 CheckPrototypes(Handle<JSObject>::cast(object), a1, holder, v0, a3, t0,
2174 GenerateGlobalReceiverCheck(Handle<JSObject>::cast(object), holder, name,
2245 Handle<Code> CallStubCompiler::CompileFastApiCall(
2247 Handle<Object> object,
2248 Handle<JSObject> holder,
2249 Handle<JSGlobalPropertyCell> cell,
2250 Handle<JSFunction> function,
2251 Handle<String> name) {
2258 if (object->IsGlobalObject()) return Handle<Code>::null();
2259 if (!cell.is_null()) return Handle<Code>::null();
2260 if (!object->IsJSObject()) return Handle<Code>::null();
2262 Handle<JSObject>::cast(object), holder);
2263 if (depth == kInvalidProtoDepth) return Handle<Code>::null();
2282 CheckPrototypes(Handle<JSObject>::cast(object), a1, holder, a0, a3, t0, name,
2298 Handle<Code> CallStubCompiler::CompileCallConstant(Handle<Object> object,
2299 Handle<JSObject> holder,
2300 Handle<JSFunction> function,
2301 Handle<String> name,
2308 Handle<Code> code = CompileCustomCall(object, holder,
2309 Handle<JSGlobalPropertyCell>::null(),
2311 // A null handle means bail out to the regular compiler code below.
2337 CheckPrototypes(Handle<JSObject>::cast(object), a1, holder, a0, a3, t0,
2357 Handle<JSObject>(JSObject::cast(object->GetPrototype())),
2378 Handle<JSObject>(JSObject::cast(object->GetPrototype())),
2400 Handle<JSObject>(JSObject::cast(object->GetPrototype())),
2416 // Handle call cache miss.
2426 Handle<Code> CallStubCompiler::CompileCallInterceptor(Handle<JSObject> object,
2427 Handle<JSObject> holder,
2428 Handle<String> name) {
2457 // Handle call cache miss.
2466 Handle<Code> CallStubCompiler::CompileCallGlobal(
2467 Handle<JSObject> object,
2468 Handle<GlobalObject> holder,
2469 Handle<JSGlobalPropertyCell> cell,
2470 Handle<JSFunction> function,
2471 Handle<String> name) {
2478 Handle<Code> code = CompileCustomCall(object, holder, cell, function, name);
2479 // A null handle means bail out to the regular compiler code below.
2515 // Handle call cache miss.
2525 Handle<Code> StoreStubCompiler::CompileStoreField(Handle<JSObject> object,
2527 Handle<Map> transition,
2528 Handle<String> name) {
2540 __ li(a2, Operand(Handle<String>(name))); // Restore name.
2541 Handle<Code> ic = masm()->isolate()->builtins()->Builtins::StoreIC_Miss();
2549 Handle<Code> StoreStubCompiler::CompileStoreCallback(
2550 Handle<JSObject> object,
2551 Handle<AccessorInfo> callback,
2552 Handle<String> name) {
2562 __ CheckMap(a1, a3, Handle<Map>(object->map()), &miss,
2584 // Handle store cache miss.
2586 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss();
2594 Handle<Code> StoreStubCompiler::CompileStoreInterceptor(
2595 Handle<JSObject> receiver,
2596 Handle<String> name) {
2606 __ CheckMap(a1, a3, Handle<Map>(receiver->map()), &miss,
2629 // Handle store cache miss.
2631 Handle<Code> ic = masm()->isolate()->builtins()->Builtins::StoreIC_Miss();
2639 Handle<Code> StoreStubCompiler::CompileStoreGlobal(
2640 Handle<GlobalObject> object,
2641 Handle<JSGlobalPropertyCell> cell,
2642 Handle<String> name) {
2653 __ Branch(&miss, ne, a3, Operand(Handle<Map>(object->map())));
2673 // Handle store cache miss.
2676 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss();
2684 Handle<Code> LoadStubCompiler::CompileLoadNonexistent(Handle<String> name,
2685 Handle<JSObject> object,
2686 Handle<JSObject> last) {
2703 masm(), Handle<GlobalObject>::cast(last), name, a1, &miss);
2718 Handle<Code> LoadStubCompiler::CompileLoadField(Handle<JSObject> object,
2719 Handle<JSObject> holder,
2721 Handle<String> name) {
2740 Handle<Code> LoadStubCompiler::CompileLoadCallback(
2741 Handle<String> name,
2742 Handle<JSObject> object,
2743 Handle<JSObject> holder,
2744 Handle<AccessorInfo> callback) {
2761 Handle<Code> LoadStubCompiler::CompileLoadConstant(Handle<JSObject> object,
2762 Handle<JSObject> holder,
2763 Handle<JSFunction> value,
2764 Handle<String> name) {
2781 Handle<Code> LoadStubCompiler::CompileLoadInterceptor(Handle<JSObject> object,
2782 Handle<JSObject> holder,
2783 Handle<String> name) {
2804 Handle<Code> LoadStubCompiler::CompileLoadGlobal(
2805 Handle<JSObject> object,
2806 Handle<GlobalObject> holder,
2807 Handle<JSGlobalPropertyCell> cell,
2808 Handle<String> name,
2845 Handle<Code> KeyedLoadStubCompiler::CompileLoadField(Handle<String> name,
2846 Handle<JSObject> receiver,
2847 Handle<JSObject> holder,
2867 Handle<Code> KeyedLoadStubCompiler::CompileLoadCallback(
2868 Handle<String> name,
2869 Handle<JSObject> receiver,
2870 Handle<JSObject> holder,
2871 Handle<AccessorInfo> callback) {
2891 Handle<Code> KeyedLoadStubCompiler::CompileLoadConstant(
2892 Handle<String> name,
2893 Handle<JSObject> receiver,
2894 Handle<JSObject> holder,
2895 Handle<JSFunction> value) {
2915 Handle<Code> KeyedLoadStubCompiler::CompileLoadInterceptor(
2916 Handle<JSObject> receiver,
2917 Handle<JSObject> holder,
2918 Handle<String> name) {
2940 Handle<Code> KeyedLoadStubCompiler::CompileLoadArrayLength(
2941 Handle<String> name) {
2960 Handle<Code> KeyedLoadStubCompiler::CompileLoadStringLength(
2961 Handle<String> name) {
2985 Handle<Code> KeyedLoadStubCompiler::CompileLoadFunctionPrototype(
2986 Handle<String> name) {
3009 Handle<Code> KeyedLoadStubCompiler::CompileLoadElement(
3010 Handle<Map> receiver_map) {
3017 Handle<Code> stub = KeyedLoadElementStub(elements_kind).GetCode();
3021 Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Miss();
3029 Handle<Code> KeyedLoadStubCompiler::CompileLoadPolymorphic(
3048 Handle<Code> miss_ic = isolate()->builtins()->KeyedLoadIC_Miss();
3056 Handle<Code> KeyedStoreStubCompiler::CompileStoreField(Handle<JSObject> object,
3058 Handle<Map> transition,
3059 Handle<String> name) {
3081 Handle<Code> ic = masm()->isolate()->builtins()->KeyedStoreIC_Miss();
3089 Handle<Code> KeyedStoreStubCompiler::CompileStoreElement(
3090 Handle<Map> receiver_map) {
3100 Handle<Code> stub =
3105 Handle<Code> ic = isolate()->builtins()->KeyedStoreIC_Miss();
3113 Handle<Code> KeyedStoreStubCompiler::CompileStorePolymorphic(
3143 Handle<Code> miss_ic = isolate()->builtins()->KeyedStoreIC_Miss();
3151 Handle<Code> ConstructStubCompiler::CompileConstructStub(
3152 Handle<JSFunction> function) {
3231 Handle<SharedFunctionInfo> shared(function->shared());
3250 Handle<Object> constant(shared->GetThisPropertyAssignmentConstant(i));
3284 // Jump to the generic stub in case the specialized code cannot handle the
3287 Handle<Code> generic_construct_stub =
3329 Handle<Code> slow_ic =
3342 Handle<Code> miss_ic =
3522 // handle either of the top two bits being set in the value.
3703 Handle<Code> stub =
3740 // Handle both smis and HeapNumbers in the fast path. Go to the
4080 Handle<Code> slow_ic =
4093 Handle<Code> miss_ic =
4134 Handle<Code> stub =
4198 Handle<Code> slow_ic =
4203 Handle<Code> miss_ic =
4297 Handle<Code> ic =
4302 Handle<Code> ic_miss = masm->isolate()->builtins()->KeyedStoreIC_Miss();
4367 Handle<Code> ic_slow = masm->isolate()->builtins()->KeyedStoreIC_Slow();
4438 // Handle store cache miss, replacing the ic with the generic stub.
4440 Handle<Code> ic =
4445 Handle<Code> ic_miss = masm->isolate()->builtins()->KeyedStoreIC_Miss();
4511 Handle<Code> ic_slow = masm->isolate()->builtins()->KeyedStoreIC_Slow();
