OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 1269 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1280 // If we've skipped any global objects, it's not enough to verify that | 1280 // If we've skipped any global objects, it's not enough to verify that |
1281 // their maps haven't changed. We also need to check that the property | 1281 // their maps haven't changed. We also need to check that the property |
1282 // cell for the property is still empty. | 1282 // cell for the property is still empty. |
1283 GenerateCheckPropertyCells(masm(), object, holder, name, scratch1, miss); | 1283 GenerateCheckPropertyCells(masm(), object, holder, name, scratch1, miss); |
1284 | 1284 |
1285 // Return the register containing the holder. | 1285 // Return the register containing the holder. |
1286 return reg; | 1286 return reg; |
1287 } | 1287 } |
1288 | 1288 |
1289 | 1289 |
1290 void LoadStubCompiler::HandlerFrontendFooter(Handle<Name> name, | 1290 void LoadStubCompiler::HandlerFrontendFooter(Handle<Name> name, Label* miss) { |
1291 Label* success, | |
1292 Label* miss) { | |
1293 if (!miss->is_unused()) { | 1291 if (!miss->is_unused()) { |
1294 __ Branch(success); | 1292 Label success; |
| 1293 __ Branch(&success); |
1295 __ bind(miss); | 1294 __ bind(miss); |
1296 TailCallBuiltin(masm(), MissBuiltin(kind())); | 1295 TailCallBuiltin(masm(), MissBuiltin(kind())); |
| 1296 __ bind(&success); |
1297 } | 1297 } |
1298 } | 1298 } |
1299 | 1299 |
1300 | 1300 |
1301 void StoreStubCompiler::HandlerFrontendFooter(Handle<Name> name, | 1301 void StoreStubCompiler::HandlerFrontendFooter(Handle<Name> name, Label* miss) { |
1302 Label* success, | |
1303 Label* miss) { | |
1304 if (!miss->is_unused()) { | 1302 if (!miss->is_unused()) { |
1305 __ b(success); | 1303 Label success; |
| 1304 __ Branch(&success); |
1306 GenerateRestoreName(masm(), miss, name); | 1305 GenerateRestoreName(masm(), miss, name); |
1307 TailCallBuiltin(masm(), MissBuiltin(kind())); | 1306 TailCallBuiltin(masm(), MissBuiltin(kind())); |
| 1307 __ bind(&success); |
1308 } | 1308 } |
1309 } | 1309 } |
1310 | 1310 |
1311 | 1311 |
1312 Register LoadStubCompiler::CallbackHandlerFrontend( | 1312 Register LoadStubCompiler::CallbackHandlerFrontend( |
1313 Handle<JSObject> object, | 1313 Handle<Object> object, |
1314 Register object_reg, | 1314 Register object_reg, |
1315 Handle<JSObject> holder, | 1315 Handle<JSObject> holder, |
1316 Handle<Name> name, | 1316 Handle<Name> name, |
1317 Label* success, | |
1318 Handle<Object> callback) { | 1317 Handle<Object> callback) { |
1319 Label miss; | 1318 Label miss; |
1320 | 1319 |
1321 Register reg = HandlerFrontendHeader(object, object_reg, holder, name, &miss); | 1320 Register reg = HandlerFrontendHeader(object, object_reg, holder, name, &miss); |
1322 | 1321 |
1323 if (!holder->HasFastProperties() && !holder->IsJSGlobalObject()) { | 1322 if (!holder->HasFastProperties() && !holder->IsJSGlobalObject()) { |
1324 ASSERT(!reg.is(scratch2())); | 1323 ASSERT(!reg.is(scratch2())); |
1325 ASSERT(!reg.is(scratch3())); | 1324 ASSERT(!reg.is(scratch3())); |
1326 ASSERT(!reg.is(scratch4())); | 1325 ASSERT(!reg.is(scratch4())); |
1327 | 1326 |
(...skipping 15 matching lines...) Expand all Loading... |
1343 // If probing finds an entry in the dictionary, scratch3 contains the | 1342 // If probing finds an entry in the dictionary, scratch3 contains the |
1344 // pointer into the dictionary. Check that the value is the callback. | 1343 // pointer into the dictionary. Check that the value is the callback. |
1345 Register pointer = scratch3(); | 1344 Register pointer = scratch3(); |
1346 const int kElementsStartOffset = NameDictionary::kHeaderSize + | 1345 const int kElementsStartOffset = NameDictionary::kHeaderSize + |
1347 NameDictionary::kElementsStartIndex * kPointerSize; | 1346 NameDictionary::kElementsStartIndex * kPointerSize; |
1348 const int kValueOffset = kElementsStartOffset + kPointerSize; | 1347 const int kValueOffset = kElementsStartOffset + kPointerSize; |
1349 __ lw(scratch2(), FieldMemOperand(pointer, kValueOffset)); | 1348 __ lw(scratch2(), FieldMemOperand(pointer, kValueOffset)); |
1350 __ Branch(&miss, ne, scratch2(), Operand(callback)); | 1349 __ Branch(&miss, ne, scratch2(), Operand(callback)); |
1351 } | 1350 } |
1352 | 1351 |
1353 HandlerFrontendFooter(name, success, &miss); | 1352 HandlerFrontendFooter(name, &miss); |
1354 return reg; | 1353 return reg; |
1355 } | 1354 } |
1356 | 1355 |
1357 | 1356 |
1358 void LoadStubCompiler::GenerateLoadField(Register reg, | 1357 void LoadStubCompiler::GenerateLoadField(Register reg, |
1359 Handle<JSObject> holder, | 1358 Handle<JSObject> holder, |
1360 PropertyIndex field, | 1359 PropertyIndex field, |
1361 Representation representation) { | 1360 Representation representation) { |
1362 if (!reg.is(receiver())) __ mov(receiver(), reg); | 1361 if (!reg.is(receiver())) __ mov(receiver(), reg); |
1363 if (kind() == Code::LOAD_IC) { | 1362 if (kind() == Code::LOAD_IC) { |
(...skipping 89 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1453 thunk_ref, | 1452 thunk_ref, |
1454 a2, | 1453 a2, |
1455 kStackUnwindSpace, | 1454 kStackUnwindSpace, |
1456 MemOperand(fp, 6 * kPointerSize), | 1455 MemOperand(fp, 6 * kPointerSize), |
1457 NULL); | 1456 NULL); |
1458 } | 1457 } |
1459 | 1458 |
1460 | 1459 |
1461 void LoadStubCompiler::GenerateLoadInterceptor( | 1460 void LoadStubCompiler::GenerateLoadInterceptor( |
1462 Register holder_reg, | 1461 Register holder_reg, |
1463 Handle<JSObject> object, | 1462 Handle<Object> object, |
1464 Handle<JSObject> interceptor_holder, | 1463 Handle<JSObject> interceptor_holder, |
1465 LookupResult* lookup, | 1464 LookupResult* lookup, |
1466 Handle<Name> name) { | 1465 Handle<Name> name) { |
1467 ASSERT(interceptor_holder->HasNamedInterceptor()); | 1466 ASSERT(interceptor_holder->HasNamedInterceptor()); |
1468 ASSERT(!interceptor_holder->GetNamedInterceptor()->getter()->IsUndefined()); | 1467 ASSERT(!interceptor_holder->GetNamedInterceptor()->getter()->IsUndefined()); |
1469 | 1468 |
1470 // So far the most popular follow ups for interceptor loads are FIELD | 1469 // So far the most popular follow ups for interceptor loads are FIELD |
1471 // and CALLBACKS, so inline only them, other cases may be added | 1470 // and CALLBACKS, so inline only them, other cases may be added |
1472 // later. | 1471 // later. |
1473 bool compile_followup_inline = false; | 1472 bool compile_followup_inline = false; |
(...skipping 1069 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2543 FreeSpaceForFastApiCall(masm()); | 2542 FreeSpaceForFastApiCall(masm()); |
2544 | 2543 |
2545 __ bind(&miss_before_stack_reserved); | 2544 __ bind(&miss_before_stack_reserved); |
2546 GenerateMissBranch(); | 2545 GenerateMissBranch(); |
2547 | 2546 |
2548 // Return the generated code. | 2547 // Return the generated code. |
2549 return GetCode(function); | 2548 return GetCode(function); |
2550 } | 2549 } |
2551 | 2550 |
2552 | 2551 |
| 2552 void StubCompiler::GenerateBooleanCheck(Register object, Label* miss) { |
| 2553 Label success; |
| 2554 // Check that the object is a boolean. |
| 2555 __ LoadRoot(at, Heap::kTrueValueRootIndex); |
| 2556 __ Branch(&success, eq, object, Operand(at)); |
| 2557 __ LoadRoot(at, Heap::kFalseValueRootIndex); |
| 2558 __ Branch(miss, ne, object, Operand(at)); |
| 2559 __ bind(&success); |
| 2560 } |
| 2561 |
| 2562 |
2553 void CallStubCompiler::CompileHandlerFrontend(Handle<Object> object, | 2563 void CallStubCompiler::CompileHandlerFrontend(Handle<Object> object, |
2554 Handle<JSObject> holder, | 2564 Handle<JSObject> holder, |
2555 Handle<Name> name, | 2565 Handle<Name> name, |
2556 CheckType check, | 2566 CheckType check) { |
2557 Label* success) { | |
2558 // ----------- S t a t e ------------- | 2567 // ----------- S t a t e ------------- |
2559 // -- a2 : name | 2568 // -- a2 : name |
2560 // -- ra : return address | 2569 // -- ra : return address |
2561 // ----------------------------------- | 2570 // ----------------------------------- |
2562 Label miss; | 2571 Label miss; |
2563 GenerateNameCheck(name, &miss); | 2572 GenerateNameCheck(name, &miss); |
2564 | 2573 |
2565 // Get the receiver from the stack. | 2574 // Get the receiver from the stack. |
2566 const int argc = arguments().immediate(); | 2575 const int argc = arguments().immediate(); |
2567 __ lw(a1, MemOperand(sp, argc * kPointerSize)); | 2576 __ lw(a1, MemOperand(sp, argc * kPointerSize)); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2623 __ bind(&fast); | 2632 __ bind(&fast); |
2624 // Check that the maps starting from the prototype haven't changed. | 2633 // Check that the maps starting from the prototype haven't changed. |
2625 GenerateDirectLoadGlobalFunctionPrototype( | 2634 GenerateDirectLoadGlobalFunctionPrototype( |
2626 masm(), Context::NUMBER_FUNCTION_INDEX, a0, &miss); | 2635 masm(), Context::NUMBER_FUNCTION_INDEX, a0, &miss); |
2627 CheckPrototypes( | 2636 CheckPrototypes( |
2628 Handle<JSObject>(JSObject::cast(object->GetPrototype(isolate()))), | 2637 Handle<JSObject>(JSObject::cast(object->GetPrototype(isolate()))), |
2629 a0, holder, a3, a1, t0, name, &miss); | 2638 a0, holder, a3, a1, t0, name, &miss); |
2630 break; | 2639 break; |
2631 } | 2640 } |
2632 case BOOLEAN_CHECK: { | 2641 case BOOLEAN_CHECK: { |
2633 Label fast; | 2642 GenerateBooleanCheck(a1, &miss); |
2634 // Check that the object is a boolean. | 2643 |
2635 __ LoadRoot(t0, Heap::kTrueValueRootIndex); | |
2636 __ Branch(&fast, eq, a1, Operand(t0)); | |
2637 __ LoadRoot(t0, Heap::kFalseValueRootIndex); | |
2638 __ Branch(&miss, ne, a1, Operand(t0)); | |
2639 __ bind(&fast); | |
2640 // Check that the maps starting from the prototype haven't changed. | 2644 // Check that the maps starting from the prototype haven't changed. |
2641 GenerateDirectLoadGlobalFunctionPrototype( | 2645 GenerateDirectLoadGlobalFunctionPrototype( |
2642 masm(), Context::BOOLEAN_FUNCTION_INDEX, a0, &miss); | 2646 masm(), Context::BOOLEAN_FUNCTION_INDEX, a0, &miss); |
2643 CheckPrototypes( | 2647 CheckPrototypes( |
2644 Handle<JSObject>(JSObject::cast(object->GetPrototype(isolate()))), | 2648 Handle<JSObject>(JSObject::cast(object->GetPrototype(isolate()))), |
2645 a0, holder, a3, a1, t0, name, &miss); | 2649 a0, holder, a3, a1, t0, name, &miss); |
2646 break; | 2650 break; |
2647 } | 2651 } |
2648 } | 2652 } |
2649 | 2653 |
2650 __ jmp(success); | 2654 Label success; |
| 2655 __ Branch(&success); |
2651 | 2656 |
2652 // Handle call cache miss. | 2657 // Handle call cache miss. |
2653 __ bind(&miss); | 2658 __ bind(&miss); |
2654 | 2659 |
2655 GenerateMissBranch(); | 2660 GenerateMissBranch(); |
| 2661 |
| 2662 __ bind(&success); |
2656 } | 2663 } |
2657 | 2664 |
2658 | 2665 |
2659 void CallStubCompiler::CompileHandlerBackend(Handle<JSFunction> function) { | 2666 void CallStubCompiler::CompileHandlerBackend(Handle<JSFunction> function) { |
2660 CallKind call_kind = CallICBase::Contextual::decode(extra_state_) | 2667 CallKind call_kind = CallICBase::Contextual::decode(extra_state_) |
2661 ? CALL_AS_FUNCTION | 2668 ? CALL_AS_FUNCTION |
2662 : CALL_AS_METHOD; | 2669 : CALL_AS_METHOD; |
2663 ParameterCount expected(function); | 2670 ParameterCount expected(function); |
2664 __ InvokeFunction(function, expected, arguments(), | 2671 __ InvokeFunction(function, expected, arguments(), |
2665 JUMP_FUNCTION, NullCallWrapper(), call_kind); | 2672 JUMP_FUNCTION, NullCallWrapper(), call_kind); |
2666 } | 2673 } |
2667 | 2674 |
2668 | 2675 |
2669 Handle<Code> CallStubCompiler::CompileCallConstant( | 2676 Handle<Code> CallStubCompiler::CompileCallConstant( |
2670 Handle<Object> object, | 2677 Handle<Object> object, |
2671 Handle<JSObject> holder, | 2678 Handle<JSObject> holder, |
2672 Handle<Name> name, | 2679 Handle<Name> name, |
2673 CheckType check, | 2680 CheckType check, |
2674 Handle<JSFunction> function) { | 2681 Handle<JSFunction> function) { |
2675 if (HasCustomCallGenerator(function)) { | 2682 if (HasCustomCallGenerator(function)) { |
2676 Handle<Code> code = CompileCustomCall(object, holder, | 2683 Handle<Code> code = CompileCustomCall(object, holder, |
2677 Handle<Cell>::null(), | 2684 Handle<Cell>::null(), |
2678 function, Handle<String>::cast(name), | 2685 function, Handle<String>::cast(name), |
2679 Code::CONSTANT); | 2686 Code::CONSTANT); |
2680 // A null handle means bail out to the regular compiler code below. | 2687 // A null handle means bail out to the regular compiler code below. |
2681 if (!code.is_null()) return code; | 2688 if (!code.is_null()) return code; |
2682 } | 2689 } |
2683 | 2690 |
2684 Label success; | 2691 CompileHandlerFrontend(object, holder, name, check); |
2685 | |
2686 CompileHandlerFrontend(object, holder, name, check, &success); | |
2687 __ bind(&success); | |
2688 CompileHandlerBackend(function); | 2692 CompileHandlerBackend(function); |
2689 | 2693 |
2690 // Return the generated code. | 2694 // Return the generated code. |
2691 return GetCode(function); | 2695 return GetCode(function); |
2692 } | 2696 } |
2693 | 2697 |
2694 | 2698 |
2695 Handle<Code> CallStubCompiler::CompileCallInterceptor(Handle<JSObject> object, | 2699 Handle<Code> CallStubCompiler::CompileCallInterceptor(Handle<JSObject> object, |
2696 Handle<JSObject> holder, | 2700 Handle<JSObject> holder, |
2697 Handle<Name> name) { | 2701 Handle<Name> name) { |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2791 // Return the generated code. | 2795 // Return the generated code. |
2792 return GetCode(Code::NORMAL, name); | 2796 return GetCode(Code::NORMAL, name); |
2793 } | 2797 } |
2794 | 2798 |
2795 | 2799 |
2796 Handle<Code> StoreStubCompiler::CompileStoreCallback( | 2800 Handle<Code> StoreStubCompiler::CompileStoreCallback( |
2797 Handle<JSObject> object, | 2801 Handle<JSObject> object, |
2798 Handle<JSObject> holder, | 2802 Handle<JSObject> holder, |
2799 Handle<Name> name, | 2803 Handle<Name> name, |
2800 Handle<ExecutableAccessorInfo> callback) { | 2804 Handle<ExecutableAccessorInfo> callback) { |
2801 Label success; | 2805 HandlerFrontend(object, receiver(), holder, name); |
2802 HandlerFrontend(object, receiver(), holder, name, &success); | |
2803 __ bind(&success); | |
2804 | 2806 |
2805 // Stub never generated for non-global objects that require access | 2807 // Stub never generated for non-global objects that require access |
2806 // checks. | 2808 // checks. |
2807 ASSERT(holder->IsJSGlobalProxy() || !holder->IsAccessCheckNeeded()); | 2809 ASSERT(holder->IsJSGlobalProxy() || !holder->IsAccessCheckNeeded()); |
2808 | 2810 |
2809 __ push(receiver()); // Receiver. | 2811 __ push(receiver()); // Receiver. |
2810 __ li(at, Operand(callback)); // Callback info. | 2812 __ li(at, Operand(callback)); // Callback info. |
2811 __ push(at); | 2813 __ push(at); |
2812 __ li(at, Operand(name)); | 2814 __ li(at, Operand(name)); |
2813 __ Push(at, value()); | 2815 __ Push(at, value()); |
2814 | 2816 |
2815 // Do tail-call to the runtime system. | 2817 // Do tail-call to the runtime system. |
2816 ExternalReference store_callback_property = | 2818 ExternalReference store_callback_property = |
2817 ExternalReference(IC_Utility(IC::kStoreCallbackProperty), isolate()); | 2819 ExternalReference(IC_Utility(IC::kStoreCallbackProperty), isolate()); |
2818 __ TailCallExternalReference(store_callback_property, 4, 1); | 2820 __ TailCallExternalReference(store_callback_property, 4, 1); |
2819 | 2821 |
2820 // Return the generated code. | 2822 // Return the generated code. |
2821 return GetCode(kind(), Code::CALLBACKS, name); | 2823 return GetCode(kind(), Code::CALLBACKS, name); |
2822 } | 2824 } |
2823 | 2825 |
2824 | 2826 |
2825 Handle<Code> StoreStubCompiler::CompileStoreCallback( | 2827 Handle<Code> StoreStubCompiler::CompileStoreCallback( |
2826 Handle<JSObject> object, | 2828 Handle<JSObject> object, |
2827 Handle<JSObject> holder, | 2829 Handle<JSObject> holder, |
2828 Handle<Name> name, | 2830 Handle<Name> name, |
2829 const CallOptimization& call_optimization) { | 2831 const CallOptimization& call_optimization) { |
2830 Label success; | 2832 HandlerFrontend(object, receiver(), holder, name); |
2831 HandlerFrontend(object, receiver(), holder, name, &success); | |
2832 __ bind(&success); | |
2833 | 2833 |
2834 Register values[] = { value() }; | 2834 Register values[] = { value() }; |
2835 GenerateFastApiCall( | 2835 GenerateFastApiCall( |
2836 masm(), call_optimization, receiver(), scratch3(), 1, values); | 2836 masm(), call_optimization, receiver(), scratch3(), 1, values); |
2837 | 2837 |
2838 // Return the generated code. | 2838 // Return the generated code. |
2839 return GetCode(kind(), Code::CALLBACKS, name); | 2839 return GetCode(kind(), Code::CALLBACKS, name); |
2840 } | 2840 } |
2841 | 2841 |
2842 | 2842 |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2918 // Handle store cache miss. | 2918 // Handle store cache miss. |
2919 __ bind(&miss); | 2919 __ bind(&miss); |
2920 TailCallBuiltin(masm(), MissBuiltin(kind())); | 2920 TailCallBuiltin(masm(), MissBuiltin(kind())); |
2921 | 2921 |
2922 // Return the generated code. | 2922 // Return the generated code. |
2923 return GetCode(kind(), Code::INTERCEPTOR, name); | 2923 return GetCode(kind(), Code::INTERCEPTOR, name); |
2924 } | 2924 } |
2925 | 2925 |
2926 | 2926 |
2927 Handle<Code> LoadStubCompiler::CompileLoadNonexistent( | 2927 Handle<Code> LoadStubCompiler::CompileLoadNonexistent( |
2928 Handle<JSObject> object, | 2928 Handle<Object> object, |
2929 Handle<JSObject> last, | 2929 Handle<JSObject> last, |
2930 Handle<Name> name, | 2930 Handle<Name> name, |
2931 Handle<JSGlobalObject> global) { | 2931 Handle<JSGlobalObject> global) { |
2932 Label success; | 2932 NonexistentHandlerFrontend(object, last, name, global); |
2933 | 2933 |
2934 NonexistentHandlerFrontend(object, last, name, &success, global); | |
2935 | |
2936 __ bind(&success); | |
2937 // Return undefined if maps of the full prototype chain is still the same. | 2934 // Return undefined if maps of the full prototype chain is still the same. |
2938 __ LoadRoot(v0, Heap::kUndefinedValueRootIndex); | 2935 __ LoadRoot(v0, Heap::kUndefinedValueRootIndex); |
2939 __ Ret(); | 2936 __ Ret(); |
2940 | 2937 |
2941 // Return the generated code. | 2938 // Return the generated code. |
2942 return GetCode(kind(), Code::NONEXISTENT, name); | 2939 return GetCode(kind(), Code::NONEXISTENT, name); |
2943 } | 2940 } |
2944 | 2941 |
2945 | 2942 |
2946 Register* LoadStubCompiler::registers() { | 2943 Register* LoadStubCompiler::registers() { |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3018 } | 3015 } |
3019 __ Ret(); | 3016 __ Ret(); |
3020 } | 3017 } |
3021 | 3018 |
3022 | 3019 |
3023 #undef __ | 3020 #undef __ |
3024 #define __ ACCESS_MASM(masm()) | 3021 #define __ ACCESS_MASM(masm()) |
3025 | 3022 |
3026 | 3023 |
3027 Handle<Code> LoadStubCompiler::CompileLoadGlobal( | 3024 Handle<Code> LoadStubCompiler::CompileLoadGlobal( |
3028 Handle<JSObject> object, | 3025 Handle<Object> object, |
3029 Handle<GlobalObject> global, | 3026 Handle<GlobalObject> global, |
3030 Handle<PropertyCell> cell, | 3027 Handle<PropertyCell> cell, |
3031 Handle<Name> name, | 3028 Handle<Name> name, |
3032 bool is_dont_delete) { | 3029 bool is_dont_delete) { |
3033 Label success, miss; | 3030 Label miss; |
3034 | 3031 |
3035 HandlerFrontendHeader(object, receiver(), global, name, &miss); | 3032 HandlerFrontendHeader(object, receiver(), global, name, &miss); |
3036 | 3033 |
3037 // Get the value from the cell. | 3034 // Get the value from the cell. |
3038 __ li(a3, Operand(cell)); | 3035 __ li(a3, Operand(cell)); |
3039 __ lw(t0, FieldMemOperand(a3, Cell::kValueOffset)); | 3036 __ lw(t0, FieldMemOperand(a3, Cell::kValueOffset)); |
3040 | 3037 |
3041 // Check for deleted property if property can actually be deleted. | 3038 // Check for deleted property if property can actually be deleted. |
3042 if (!is_dont_delete) { | 3039 if (!is_dont_delete) { |
3043 __ LoadRoot(at, Heap::kTheHoleValueRootIndex); | 3040 __ LoadRoot(at, Heap::kTheHoleValueRootIndex); |
3044 __ Branch(&miss, eq, t0, Operand(at)); | 3041 __ Branch(&miss, eq, t0, Operand(at)); |
3045 } | 3042 } |
3046 | 3043 |
3047 HandlerFrontendFooter(name, &success, &miss); | 3044 HandlerFrontendFooter(name, &miss); |
3048 __ bind(&success); | |
3049 | 3045 |
3050 Counters* counters = isolate()->counters(); | 3046 Counters* counters = isolate()->counters(); |
3051 __ IncrementCounter(counters->named_load_global_stub(), 1, a1, a3); | 3047 __ IncrementCounter(counters->named_load_global_stub(), 1, a1, a3); |
3052 __ Ret(USE_DELAY_SLOT); | 3048 __ Ret(USE_DELAY_SLOT); |
3053 __ mov(v0, t0); | 3049 __ mov(v0, t0); |
3054 | 3050 |
3055 // Return the generated code. | 3051 // Return the generated code. |
3056 return GetCode(kind(), Code::NORMAL, name); | 3052 return GetCode(kind(), Code::NORMAL, name); |
3057 } | 3053 } |
3058 | 3054 |
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3171 // ----------------------------------- | 3167 // ----------------------------------- |
3172 TailCallBuiltin(masm, Builtins::kKeyedLoadIC_MissForceGeneric); | 3168 TailCallBuiltin(masm, Builtins::kKeyedLoadIC_MissForceGeneric); |
3173 } | 3169 } |
3174 | 3170 |
3175 | 3171 |
3176 #undef __ | 3172 #undef __ |
3177 | 3173 |
3178 } } // namespace v8::internal | 3174 } } // namespace v8::internal |
3179 | 3175 |
3180 #endif // V8_TARGET_ARCH_MIPS | 3176 #endif // V8_TARGET_ARCH_MIPS |
OLD | NEW |