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 1508 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1519 Register reg = CheckPrototypes(object, r0, holder, r1, r3, r4, name, &miss); | 1519 Register reg = CheckPrototypes(object, r0, holder, r1, r3, r4, name, &miss); |
1520 GenerateFastPropertyLoad(masm(), r1, reg, holder, index); | 1520 GenerateFastPropertyLoad(masm(), r1, reg, holder, index); |
1521 | 1521 |
1522 GenerateCallFunction(masm(), object, arguments(), &miss, extra_state_); | 1522 GenerateCallFunction(masm(), object, arguments(), &miss, extra_state_); |
1523 | 1523 |
1524 // Handle call cache miss. | 1524 // Handle call cache miss. |
1525 __ bind(&miss); | 1525 __ bind(&miss); |
1526 GenerateMissBranch(); | 1526 GenerateMissBranch(); |
1527 | 1527 |
1528 // Return the generated code. | 1528 // Return the generated code. |
1529 return GetCode(FIELD, name); | 1529 return GetCode(Code::FIELD, name); |
1530 } | 1530 } |
1531 | 1531 |
1532 | 1532 |
1533 Handle<Code> CallStubCompiler::CompileArrayPushCall( | 1533 Handle<Code> CallStubCompiler::CompileArrayPushCall( |
1534 Handle<Object> object, | 1534 Handle<Object> object, |
1535 Handle<JSObject> holder, | 1535 Handle<JSObject> holder, |
1536 Handle<JSGlobalPropertyCell> cell, | 1536 Handle<JSGlobalPropertyCell> cell, |
1537 Handle<JSFunction> function, | 1537 Handle<JSFunction> function, |
1538 Handle<String> name) { | 1538 Handle<String> name) { |
1539 // ----------- S t a t e ------------- | 1539 // ----------- S t a t e ------------- |
(...skipping 524 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2064 // because the function makes no use of it. | 2064 // because the function makes no use of it. |
2065 __ bind(&slow); | 2065 __ bind(&slow); |
2066 __ InvokeFunction( | 2066 __ InvokeFunction( |
2067 function, arguments(), JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD); | 2067 function, arguments(), JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD); |
2068 | 2068 |
2069 __ bind(&miss); | 2069 __ bind(&miss); |
2070 // r2: function name. | 2070 // r2: function name. |
2071 GenerateMissBranch(); | 2071 GenerateMissBranch(); |
2072 | 2072 |
2073 // Return the generated code. | 2073 // Return the generated code. |
2074 return cell.is_null() ? GetCode(function) : GetCode(NORMAL, name); | 2074 return cell.is_null() ? GetCode(function) : GetCode(Code::NORMAL, name); |
2075 } | 2075 } |
2076 | 2076 |
2077 | 2077 |
2078 Handle<Code> CallStubCompiler::CompileMathFloorCall( | 2078 Handle<Code> CallStubCompiler::CompileMathFloorCall( |
2079 Handle<Object> object, | 2079 Handle<Object> object, |
2080 Handle<JSObject> holder, | 2080 Handle<JSObject> holder, |
2081 Handle<JSGlobalPropertyCell> cell, | 2081 Handle<JSGlobalPropertyCell> cell, |
2082 Handle<JSFunction> function, | 2082 Handle<JSFunction> function, |
2083 Handle<String> name) { | 2083 Handle<String> name) { |
2084 // ----------- S t a t e ------------- | 2084 // ----------- S t a t e ------------- |
(...skipping 125 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2210 // Tail call the full function. We do not have to patch the receiver | 2210 // Tail call the full function. We do not have to patch the receiver |
2211 // because the function makes no use of it. | 2211 // because the function makes no use of it. |
2212 __ InvokeFunction( | 2212 __ InvokeFunction( |
2213 function, arguments(), JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD); | 2213 function, arguments(), JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD); |
2214 | 2214 |
2215 __ bind(&miss); | 2215 __ bind(&miss); |
2216 // r2: function name. | 2216 // r2: function name. |
2217 GenerateMissBranch(); | 2217 GenerateMissBranch(); |
2218 | 2218 |
2219 // Return the generated code. | 2219 // Return the generated code. |
2220 return cell.is_null() ? GetCode(function) : GetCode(NORMAL, name); | 2220 return cell.is_null() ? GetCode(function) : GetCode(Code::NORMAL, name); |
2221 } | 2221 } |
2222 | 2222 |
2223 | 2223 |
2224 Handle<Code> CallStubCompiler::CompileMathAbsCall( | 2224 Handle<Code> CallStubCompiler::CompileMathAbsCall( |
2225 Handle<Object> object, | 2225 Handle<Object> object, |
2226 Handle<JSObject> holder, | 2226 Handle<JSObject> holder, |
2227 Handle<JSGlobalPropertyCell> cell, | 2227 Handle<JSGlobalPropertyCell> cell, |
2228 Handle<JSFunction> function, | 2228 Handle<JSFunction> function, |
2229 Handle<String> name) { | 2229 Handle<String> name) { |
2230 // ----------- S t a t e ------------- | 2230 // ----------- S t a t e ------------- |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2309 // because the function makes no use of it. | 2309 // because the function makes no use of it. |
2310 __ bind(&slow); | 2310 __ bind(&slow); |
2311 __ InvokeFunction( | 2311 __ InvokeFunction( |
2312 function, arguments(), JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD); | 2312 function, arguments(), JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD); |
2313 | 2313 |
2314 __ bind(&miss); | 2314 __ bind(&miss); |
2315 // r2: function name. | 2315 // r2: function name. |
2316 GenerateMissBranch(); | 2316 GenerateMissBranch(); |
2317 | 2317 |
2318 // Return the generated code. | 2318 // Return the generated code. |
2319 return cell.is_null() ? GetCode(function) : GetCode(NORMAL, name); | 2319 return cell.is_null() ? GetCode(function) : GetCode(Code::NORMAL, name); |
2320 } | 2320 } |
2321 | 2321 |
2322 | 2322 |
2323 Handle<Code> CallStubCompiler::CompileFastApiCall( | 2323 Handle<Code> CallStubCompiler::CompileFastApiCall( |
2324 const CallOptimization& optimization, | 2324 const CallOptimization& optimization, |
2325 Handle<Object> object, | 2325 Handle<Object> object, |
2326 Handle<JSObject> holder, | 2326 Handle<JSObject> holder, |
2327 Handle<JSGlobalPropertyCell> cell, | 2327 Handle<JSGlobalPropertyCell> cell, |
2328 Handle<JSFunction> function, | 2328 Handle<JSFunction> function, |
2329 Handle<String> name) { | 2329 Handle<String> name) { |
(...skipping 196 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2526 // Restore receiver. | 2526 // Restore receiver. |
2527 __ ldr(r0, MemOperand(sp, argc * kPointerSize)); | 2527 __ ldr(r0, MemOperand(sp, argc * kPointerSize)); |
2528 | 2528 |
2529 GenerateCallFunction(masm(), object, arguments(), &miss, extra_state_); | 2529 GenerateCallFunction(masm(), object, arguments(), &miss, extra_state_); |
2530 | 2530 |
2531 // Handle call cache miss. | 2531 // Handle call cache miss. |
2532 __ bind(&miss); | 2532 __ bind(&miss); |
2533 GenerateMissBranch(); | 2533 GenerateMissBranch(); |
2534 | 2534 |
2535 // Return the generated code. | 2535 // Return the generated code. |
2536 return GetCode(INTERCEPTOR, name); | 2536 return GetCode(Code::INTERCEPTOR, name); |
2537 } | 2537 } |
2538 | 2538 |
2539 | 2539 |
2540 Handle<Code> CallStubCompiler::CompileCallGlobal( | 2540 Handle<Code> CallStubCompiler::CompileCallGlobal( |
2541 Handle<JSObject> object, | 2541 Handle<JSObject> object, |
2542 Handle<GlobalObject> holder, | 2542 Handle<GlobalObject> holder, |
2543 Handle<JSGlobalPropertyCell> cell, | 2543 Handle<JSGlobalPropertyCell> cell, |
2544 Handle<JSFunction> function, | 2544 Handle<JSFunction> function, |
2545 Handle<String> name) { | 2545 Handle<String> name) { |
2546 // ----------- S t a t e ------------- | 2546 // ----------- S t a t e ------------- |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2584 __ ldr(r3, FieldMemOperand(r1, JSFunction::kCodeEntryOffset)); | 2584 __ ldr(r3, FieldMemOperand(r1, JSFunction::kCodeEntryOffset)); |
2585 __ InvokeCode(r3, expected, arguments(), JUMP_FUNCTION, | 2585 __ InvokeCode(r3, expected, arguments(), JUMP_FUNCTION, |
2586 NullCallWrapper(), call_kind); | 2586 NullCallWrapper(), call_kind); |
2587 | 2587 |
2588 // Handle call cache miss. | 2588 // Handle call cache miss. |
2589 __ bind(&miss); | 2589 __ bind(&miss); |
2590 __ IncrementCounter(counters->call_global_inline_miss(), 1, r1, r3); | 2590 __ IncrementCounter(counters->call_global_inline_miss(), 1, r1, r3); |
2591 GenerateMissBranch(); | 2591 GenerateMissBranch(); |
2592 | 2592 |
2593 // Return the generated code. | 2593 // Return the generated code. |
2594 return GetCode(NORMAL, name); | 2594 return GetCode(Code::NORMAL, name); |
2595 } | 2595 } |
2596 | 2596 |
2597 | 2597 |
2598 Handle<Code> StoreStubCompiler::CompileStoreField(Handle<JSObject> object, | 2598 Handle<Code> StoreStubCompiler::CompileStoreField(Handle<JSObject> object, |
2599 int index, | 2599 int index, |
2600 Handle<Map> transition, | 2600 Handle<Map> transition, |
2601 Handle<String> name) { | 2601 Handle<String> name) { |
2602 // ----------- S t a t e ------------- | 2602 // ----------- S t a t e ------------- |
2603 // -- r0 : value | 2603 // -- r0 : value |
2604 // -- r1 : receiver | 2604 // -- r1 : receiver |
2605 // -- r2 : name | 2605 // -- r2 : name |
2606 // -- lr : return address | 2606 // -- lr : return address |
2607 // ----------------------------------- | 2607 // ----------------------------------- |
2608 Label miss; | 2608 Label miss; |
2609 | 2609 |
2610 GenerateStoreField(masm(), | 2610 GenerateStoreField(masm(), |
2611 object, | 2611 object, |
2612 index, | 2612 index, |
2613 transition, | 2613 transition, |
2614 name, | 2614 name, |
2615 r1, r2, r3, r4, | 2615 r1, r2, r3, r4, |
2616 &miss); | 2616 &miss); |
2617 __ bind(&miss); | 2617 __ bind(&miss); |
2618 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss(); | 2618 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss(); |
2619 __ Jump(ic, RelocInfo::CODE_TARGET); | 2619 __ Jump(ic, RelocInfo::CODE_TARGET); |
2620 | 2620 |
2621 // Return the generated code. | 2621 // Return the generated code. |
2622 return GetCode(transition.is_null() ? FIELD : MAP_TRANSITION, name); | 2622 return GetCode(transition.is_null() |
| 2623 ? Code::FIELD |
| 2624 : Code::MAP_TRANSITION, name); |
2623 } | 2625 } |
2624 | 2626 |
2625 | 2627 |
2626 Handle<Code> StoreStubCompiler::CompileStoreCallback( | 2628 Handle<Code> StoreStubCompiler::CompileStoreCallback( |
2627 Handle<JSObject> object, | 2629 Handle<JSObject> object, |
2628 Handle<AccessorInfo> callback, | 2630 Handle<AccessorInfo> callback, |
2629 Handle<String> name) { | 2631 Handle<String> name) { |
2630 // ----------- S t a t e ------------- | 2632 // ----------- S t a t e ------------- |
2631 // -- r0 : value | 2633 // -- r0 : value |
2632 // -- r1 : receiver | 2634 // -- r1 : receiver |
(...skipping 24 matching lines...) Expand all Loading... |
2657 ExternalReference(IC_Utility(IC::kStoreCallbackProperty), | 2659 ExternalReference(IC_Utility(IC::kStoreCallbackProperty), |
2658 masm()->isolate()); | 2660 masm()->isolate()); |
2659 __ TailCallExternalReference(store_callback_property, 4, 1); | 2661 __ TailCallExternalReference(store_callback_property, 4, 1); |
2660 | 2662 |
2661 // Handle store cache miss. | 2663 // Handle store cache miss. |
2662 __ bind(&miss); | 2664 __ bind(&miss); |
2663 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss(); | 2665 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss(); |
2664 __ Jump(ic, RelocInfo::CODE_TARGET); | 2666 __ Jump(ic, RelocInfo::CODE_TARGET); |
2665 | 2667 |
2666 // Return the generated code. | 2668 // Return the generated code. |
2667 return GetCode(CALLBACKS, name); | 2669 return GetCode(Code::CALLBACKS, name); |
2668 } | 2670 } |
2669 | 2671 |
2670 | 2672 |
2671 Handle<Code> StoreStubCompiler::CompileStoreViaSetter( | 2673 Handle<Code> StoreStubCompiler::CompileStoreViaSetter( |
2672 Handle<JSObject> receiver, | 2674 Handle<JSObject> receiver, |
2673 Handle<JSFunction> setter, | 2675 Handle<JSFunction> setter, |
2674 Handle<String> name) { | 2676 Handle<String> name) { |
2675 // ----------- S t a t e ------------- | 2677 // ----------- S t a t e ------------- |
2676 // -- r0 : value | 2678 // -- r0 : value |
2677 // -- r1 : receiver | 2679 // -- r1 : receiver |
(...skipping 24 matching lines...) Expand all Loading... |
2702 // Restore context register. | 2704 // Restore context register. |
2703 __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset)); | 2705 __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset)); |
2704 } | 2706 } |
2705 __ Ret(); | 2707 __ Ret(); |
2706 | 2708 |
2707 __ bind(&miss); | 2709 __ bind(&miss); |
2708 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss(); | 2710 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss(); |
2709 __ Jump(ic, RelocInfo::CODE_TARGET); | 2711 __ Jump(ic, RelocInfo::CODE_TARGET); |
2710 | 2712 |
2711 // Return the generated code. | 2713 // Return the generated code. |
2712 return GetCode(CALLBACKS, name); | 2714 return GetCode(Code::CALLBACKS, name); |
2713 } | 2715 } |
2714 | 2716 |
2715 | 2717 |
2716 Handle<Code> StoreStubCompiler::CompileStoreInterceptor( | 2718 Handle<Code> StoreStubCompiler::CompileStoreInterceptor( |
2717 Handle<JSObject> receiver, | 2719 Handle<JSObject> receiver, |
2718 Handle<String> name) { | 2720 Handle<String> name) { |
2719 // ----------- S t a t e ------------- | 2721 // ----------- S t a t e ------------- |
2720 // -- r0 : value | 2722 // -- r0 : value |
2721 // -- r1 : receiver | 2723 // -- r1 : receiver |
2722 // -- r2 : name | 2724 // -- r2 : name |
(...skipping 24 matching lines...) Expand all Loading... |
2747 ExternalReference(IC_Utility(IC::kStoreInterceptorProperty), | 2749 ExternalReference(IC_Utility(IC::kStoreInterceptorProperty), |
2748 masm()->isolate()); | 2750 masm()->isolate()); |
2749 __ TailCallExternalReference(store_ic_property, 4, 1); | 2751 __ TailCallExternalReference(store_ic_property, 4, 1); |
2750 | 2752 |
2751 // Handle store cache miss. | 2753 // Handle store cache miss. |
2752 __ bind(&miss); | 2754 __ bind(&miss); |
2753 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss(); | 2755 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss(); |
2754 __ Jump(ic, RelocInfo::CODE_TARGET); | 2756 __ Jump(ic, RelocInfo::CODE_TARGET); |
2755 | 2757 |
2756 // Return the generated code. | 2758 // Return the generated code. |
2757 return GetCode(INTERCEPTOR, name); | 2759 return GetCode(Code::INTERCEPTOR, name); |
2758 } | 2760 } |
2759 | 2761 |
2760 | 2762 |
2761 Handle<Code> StoreStubCompiler::CompileStoreGlobal( | 2763 Handle<Code> StoreStubCompiler::CompileStoreGlobal( |
2762 Handle<GlobalObject> object, | 2764 Handle<GlobalObject> object, |
2763 Handle<JSGlobalPropertyCell> cell, | 2765 Handle<JSGlobalPropertyCell> cell, |
2764 Handle<String> name) { | 2766 Handle<String> name) { |
2765 // ----------- S t a t e ------------- | 2767 // ----------- S t a t e ------------- |
2766 // -- r0 : value | 2768 // -- r0 : value |
2767 // -- r1 : receiver | 2769 // -- r1 : receiver |
(...skipping 25 matching lines...) Expand all Loading... |
2793 __ IncrementCounter(counters->named_store_global_inline(), 1, r4, r3); | 2795 __ IncrementCounter(counters->named_store_global_inline(), 1, r4, r3); |
2794 __ Ret(); | 2796 __ Ret(); |
2795 | 2797 |
2796 // Handle store cache miss. | 2798 // Handle store cache miss. |
2797 __ bind(&miss); | 2799 __ bind(&miss); |
2798 __ IncrementCounter(counters->named_store_global_inline_miss(), 1, r4, r3); | 2800 __ IncrementCounter(counters->named_store_global_inline_miss(), 1, r4, r3); |
2799 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss(); | 2801 Handle<Code> ic = masm()->isolate()->builtins()->StoreIC_Miss(); |
2800 __ Jump(ic, RelocInfo::CODE_TARGET); | 2802 __ Jump(ic, RelocInfo::CODE_TARGET); |
2801 | 2803 |
2802 // Return the generated code. | 2804 // Return the generated code. |
2803 return GetCode(NORMAL, name); | 2805 return GetCode(Code::NORMAL, name); |
2804 } | 2806 } |
2805 | 2807 |
2806 | 2808 |
2807 Handle<Code> LoadStubCompiler::CompileLoadNonexistent(Handle<String> name, | 2809 Handle<Code> LoadStubCompiler::CompileLoadNonexistent(Handle<String> name, |
2808 Handle<JSObject> object, | 2810 Handle<JSObject> object, |
2809 Handle<JSObject> last) { | 2811 Handle<JSObject> last) { |
2810 // ----------- S t a t e ------------- | 2812 // ----------- S t a t e ------------- |
2811 // -- r0 : receiver | 2813 // -- r0 : receiver |
2812 // -- lr : return address | 2814 // -- lr : return address |
2813 // ----------------------------------- | 2815 // ----------------------------------- |
(...skipping 14 matching lines...) Expand all Loading... |
2828 | 2830 |
2829 // Return undefined if maps of the full prototype chain are still the | 2831 // Return undefined if maps of the full prototype chain are still the |
2830 // same and no global property with this name contains a value. | 2832 // same and no global property with this name contains a value. |
2831 __ LoadRoot(r0, Heap::kUndefinedValueRootIndex); | 2833 __ LoadRoot(r0, Heap::kUndefinedValueRootIndex); |
2832 __ Ret(); | 2834 __ Ret(); |
2833 | 2835 |
2834 __ bind(&miss); | 2836 __ bind(&miss); |
2835 GenerateLoadMiss(masm(), Code::LOAD_IC); | 2837 GenerateLoadMiss(masm(), Code::LOAD_IC); |
2836 | 2838 |
2837 // Return the generated code. | 2839 // Return the generated code. |
2838 return GetCode(NONEXISTENT, factory()->empty_string()); | 2840 return GetCode(Code::NONEXISTENT, factory()->empty_string()); |
2839 } | 2841 } |
2840 | 2842 |
2841 | 2843 |
2842 Handle<Code> LoadStubCompiler::CompileLoadField(Handle<JSObject> object, | 2844 Handle<Code> LoadStubCompiler::CompileLoadField(Handle<JSObject> object, |
2843 Handle<JSObject> holder, | 2845 Handle<JSObject> holder, |
2844 int index, | 2846 int index, |
2845 Handle<String> name) { | 2847 Handle<String> name) { |
2846 // ----------- S t a t e ------------- | 2848 // ----------- S t a t e ------------- |
2847 // -- r0 : receiver | 2849 // -- r0 : receiver |
2848 // -- r2 : name | 2850 // -- r2 : name |
2849 // -- lr : return address | 2851 // -- lr : return address |
2850 // ----------------------------------- | 2852 // ----------------------------------- |
2851 Label miss; | 2853 Label miss; |
2852 | 2854 |
2853 GenerateLoadField(object, holder, r0, r3, r1, r4, index, name, &miss); | 2855 GenerateLoadField(object, holder, r0, r3, r1, r4, index, name, &miss); |
2854 __ bind(&miss); | 2856 __ bind(&miss); |
2855 GenerateLoadMiss(masm(), Code::LOAD_IC); | 2857 GenerateLoadMiss(masm(), Code::LOAD_IC); |
2856 | 2858 |
2857 // Return the generated code. | 2859 // Return the generated code. |
2858 return GetCode(FIELD, name); | 2860 return GetCode(Code::FIELD, name); |
2859 } | 2861 } |
2860 | 2862 |
2861 | 2863 |
2862 Handle<Code> LoadStubCompiler::CompileLoadCallback( | 2864 Handle<Code> LoadStubCompiler::CompileLoadCallback( |
2863 Handle<String> name, | 2865 Handle<String> name, |
2864 Handle<JSObject> object, | 2866 Handle<JSObject> object, |
2865 Handle<JSObject> holder, | 2867 Handle<JSObject> holder, |
2866 Handle<AccessorInfo> callback) { | 2868 Handle<AccessorInfo> callback) { |
2867 // ----------- S t a t e ------------- | 2869 // ----------- S t a t e ------------- |
2868 // -- r0 : receiver | 2870 // -- r0 : receiver |
2869 // -- r2 : name | 2871 // -- r2 : name |
2870 // -- lr : return address | 2872 // -- lr : return address |
2871 // ----------------------------------- | 2873 // ----------------------------------- |
2872 Label miss; | 2874 Label miss; |
2873 GenerateLoadCallback(object, holder, r0, r2, r3, r1, r4, callback, name, | 2875 GenerateLoadCallback(object, holder, r0, r2, r3, r1, r4, callback, name, |
2874 &miss); | 2876 &miss); |
2875 __ bind(&miss); | 2877 __ bind(&miss); |
2876 GenerateLoadMiss(masm(), Code::LOAD_IC); | 2878 GenerateLoadMiss(masm(), Code::LOAD_IC); |
2877 | 2879 |
2878 // Return the generated code. | 2880 // Return the generated code. |
2879 return GetCode(CALLBACKS, name); | 2881 return GetCode(Code::CALLBACKS, name); |
2880 } | 2882 } |
2881 | 2883 |
2882 | 2884 |
2883 Handle<Code> LoadStubCompiler::CompileLoadViaGetter( | 2885 Handle<Code> LoadStubCompiler::CompileLoadViaGetter( |
2884 Handle<String> name, | 2886 Handle<String> name, |
2885 Handle<JSObject> receiver, | 2887 Handle<JSObject> receiver, |
2886 Handle<JSObject> holder, | 2888 Handle<JSObject> holder, |
2887 Handle<JSFunction> getter) { | 2889 Handle<JSFunction> getter) { |
2888 // ----------- S t a t e ------------- | 2890 // ----------- S t a t e ------------- |
2889 // -- r0 : receiver | 2891 // -- r0 : receiver |
(...skipping 17 matching lines...) Expand all Loading... |
2907 | 2909 |
2908 // Restore context register. | 2910 // Restore context register. |
2909 __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset)); | 2911 __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset)); |
2910 } | 2912 } |
2911 __ Ret(); | 2913 __ Ret(); |
2912 | 2914 |
2913 __ bind(&miss); | 2915 __ bind(&miss); |
2914 GenerateLoadMiss(masm(), Code::LOAD_IC); | 2916 GenerateLoadMiss(masm(), Code::LOAD_IC); |
2915 | 2917 |
2916 // Return the generated code. | 2918 // Return the generated code. |
2917 return GetCode(CALLBACKS, name); | 2919 return GetCode(Code::CALLBACKS, name); |
2918 } | 2920 } |
2919 | 2921 |
2920 | 2922 |
2921 Handle<Code> LoadStubCompiler::CompileLoadConstant(Handle<JSObject> object, | 2923 Handle<Code> LoadStubCompiler::CompileLoadConstant(Handle<JSObject> object, |
2922 Handle<JSObject> holder, | 2924 Handle<JSObject> holder, |
2923 Handle<JSFunction> value, | 2925 Handle<JSFunction> value, |
2924 Handle<String> name) { | 2926 Handle<String> name) { |
2925 // ----------- S t a t e ------------- | 2927 // ----------- S t a t e ------------- |
2926 // -- r0 : receiver | 2928 // -- r0 : receiver |
2927 // -- r2 : name | 2929 // -- r2 : name |
2928 // -- lr : return address | 2930 // -- lr : return address |
2929 // ----------------------------------- | 2931 // ----------------------------------- |
2930 Label miss; | 2932 Label miss; |
2931 | 2933 |
2932 GenerateLoadConstant(object, holder, r0, r3, r1, r4, value, name, &miss); | 2934 GenerateLoadConstant(object, holder, r0, r3, r1, r4, value, name, &miss); |
2933 __ bind(&miss); | 2935 __ bind(&miss); |
2934 GenerateLoadMiss(masm(), Code::LOAD_IC); | 2936 GenerateLoadMiss(masm(), Code::LOAD_IC); |
2935 | 2937 |
2936 // Return the generated code. | 2938 // Return the generated code. |
2937 return GetCode(CONSTANT_FUNCTION, name); | 2939 return GetCode(Code::CONSTANT_FUNCTION, name); |
2938 } | 2940 } |
2939 | 2941 |
2940 | 2942 |
2941 Handle<Code> LoadStubCompiler::CompileLoadInterceptor(Handle<JSObject> object, | 2943 Handle<Code> LoadStubCompiler::CompileLoadInterceptor(Handle<JSObject> object, |
2942 Handle<JSObject> holder, | 2944 Handle<JSObject> holder, |
2943 Handle<String> name) { | 2945 Handle<String> name) { |
2944 // ----------- S t a t e ------------- | 2946 // ----------- S t a t e ------------- |
2945 // -- r0 : receiver | 2947 // -- r0 : receiver |
2946 // -- r2 : name | 2948 // -- r2 : name |
2947 // -- lr : return address | 2949 // -- lr : return address |
2948 // ----------------------------------- | 2950 // ----------------------------------- |
2949 Label miss; | 2951 Label miss; |
2950 | 2952 |
2951 LookupResult lookup(isolate()); | 2953 LookupResult lookup(isolate()); |
2952 LookupPostInterceptor(holder, name, &lookup); | 2954 LookupPostInterceptor(holder, name, &lookup); |
2953 GenerateLoadInterceptor(object, holder, &lookup, r0, r2, r3, r1, r4, name, | 2955 GenerateLoadInterceptor(object, holder, &lookup, r0, r2, r3, r1, r4, name, |
2954 &miss); | 2956 &miss); |
2955 __ bind(&miss); | 2957 __ bind(&miss); |
2956 GenerateLoadMiss(masm(), Code::LOAD_IC); | 2958 GenerateLoadMiss(masm(), Code::LOAD_IC); |
2957 | 2959 |
2958 // Return the generated code. | 2960 // Return the generated code. |
2959 return GetCode(INTERCEPTOR, name); | 2961 return GetCode(Code::INTERCEPTOR, name); |
2960 } | 2962 } |
2961 | 2963 |
2962 | 2964 |
2963 Handle<Code> LoadStubCompiler::CompileLoadGlobal( | 2965 Handle<Code> LoadStubCompiler::CompileLoadGlobal( |
2964 Handle<JSObject> object, | 2966 Handle<JSObject> object, |
2965 Handle<GlobalObject> holder, | 2967 Handle<GlobalObject> holder, |
2966 Handle<JSGlobalPropertyCell> cell, | 2968 Handle<JSGlobalPropertyCell> cell, |
2967 Handle<String> name, | 2969 Handle<String> name, |
2968 bool is_dont_delete) { | 2970 bool is_dont_delete) { |
2969 // ----------- S t a t e ------------- | 2971 // ----------- S t a t e ------------- |
(...skipping 21 matching lines...) Expand all Loading... |
2991 __ mov(r0, r4); | 2993 __ mov(r0, r4); |
2992 Counters* counters = masm()->isolate()->counters(); | 2994 Counters* counters = masm()->isolate()->counters(); |
2993 __ IncrementCounter(counters->named_load_global_stub(), 1, r1, r3); | 2995 __ IncrementCounter(counters->named_load_global_stub(), 1, r1, r3); |
2994 __ Ret(); | 2996 __ Ret(); |
2995 | 2997 |
2996 __ bind(&miss); | 2998 __ bind(&miss); |
2997 __ IncrementCounter(counters->named_load_global_stub_miss(), 1, r1, r3); | 2999 __ IncrementCounter(counters->named_load_global_stub_miss(), 1, r1, r3); |
2998 GenerateLoadMiss(masm(), Code::LOAD_IC); | 3000 GenerateLoadMiss(masm(), Code::LOAD_IC); |
2999 | 3001 |
3000 // Return the generated code. | 3002 // Return the generated code. |
3001 return GetCode(NORMAL, name); | 3003 return GetCode(Code::NORMAL, name); |
3002 } | 3004 } |
3003 | 3005 |
3004 | 3006 |
3005 Handle<Code> KeyedLoadStubCompiler::CompileLoadField(Handle<String> name, | 3007 Handle<Code> KeyedLoadStubCompiler::CompileLoadField(Handle<String> name, |
3006 Handle<JSObject> receiver, | 3008 Handle<JSObject> receiver, |
3007 Handle<JSObject> holder, | 3009 Handle<JSObject> holder, |
3008 int index) { | 3010 int index) { |
3009 // ----------- S t a t e ------------- | 3011 // ----------- S t a t e ------------- |
3010 // -- lr : return address | 3012 // -- lr : return address |
3011 // -- r0 : key | 3013 // -- r0 : key |
3012 // -- r1 : receiver | 3014 // -- r1 : receiver |
3013 // ----------------------------------- | 3015 // ----------------------------------- |
3014 Label miss; | 3016 Label miss; |
3015 | 3017 |
3016 // Check the key is the cached one. | 3018 // Check the key is the cached one. |
3017 __ cmp(r0, Operand(name)); | 3019 __ cmp(r0, Operand(name)); |
3018 __ b(ne, &miss); | 3020 __ b(ne, &miss); |
3019 | 3021 |
3020 GenerateLoadField(receiver, holder, r1, r2, r3, r4, index, name, &miss); | 3022 GenerateLoadField(receiver, holder, r1, r2, r3, r4, index, name, &miss); |
3021 __ bind(&miss); | 3023 __ bind(&miss); |
3022 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); | 3024 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); |
3023 | 3025 |
3024 return GetCode(FIELD, name); | 3026 return GetCode(Code::FIELD, name); |
3025 } | 3027 } |
3026 | 3028 |
3027 | 3029 |
3028 Handle<Code> KeyedLoadStubCompiler::CompileLoadCallback( | 3030 Handle<Code> KeyedLoadStubCompiler::CompileLoadCallback( |
3029 Handle<String> name, | 3031 Handle<String> name, |
3030 Handle<JSObject> receiver, | 3032 Handle<JSObject> receiver, |
3031 Handle<JSObject> holder, | 3033 Handle<JSObject> holder, |
3032 Handle<AccessorInfo> callback) { | 3034 Handle<AccessorInfo> callback) { |
3033 // ----------- S t a t e ------------- | 3035 // ----------- S t a t e ------------- |
3034 // -- lr : return address | 3036 // -- lr : return address |
3035 // -- r0 : key | 3037 // -- r0 : key |
3036 // -- r1 : receiver | 3038 // -- r1 : receiver |
3037 // ----------------------------------- | 3039 // ----------------------------------- |
3038 Label miss; | 3040 Label miss; |
3039 | 3041 |
3040 // Check the key is the cached one. | 3042 // Check the key is the cached one. |
3041 __ cmp(r0, Operand(name)); | 3043 __ cmp(r0, Operand(name)); |
3042 __ b(ne, &miss); | 3044 __ b(ne, &miss); |
3043 | 3045 |
3044 GenerateLoadCallback(receiver, holder, r1, r0, r2, r3, r4, callback, name, | 3046 GenerateLoadCallback(receiver, holder, r1, r0, r2, r3, r4, callback, name, |
3045 &miss); | 3047 &miss); |
3046 __ bind(&miss); | 3048 __ bind(&miss); |
3047 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); | 3049 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); |
3048 | 3050 |
3049 return GetCode(CALLBACKS, name); | 3051 return GetCode(Code::CALLBACKS, name); |
3050 } | 3052 } |
3051 | 3053 |
3052 | 3054 |
3053 Handle<Code> KeyedLoadStubCompiler::CompileLoadConstant( | 3055 Handle<Code> KeyedLoadStubCompiler::CompileLoadConstant( |
3054 Handle<String> name, | 3056 Handle<String> name, |
3055 Handle<JSObject> receiver, | 3057 Handle<JSObject> receiver, |
3056 Handle<JSObject> holder, | 3058 Handle<JSObject> holder, |
3057 Handle<JSFunction> value) { | 3059 Handle<JSFunction> value) { |
3058 // ----------- S t a t e ------------- | 3060 // ----------- S t a t e ------------- |
3059 // -- lr : return address | 3061 // -- lr : return address |
3060 // -- r0 : key | 3062 // -- r0 : key |
3061 // -- r1 : receiver | 3063 // -- r1 : receiver |
3062 // ----------------------------------- | 3064 // ----------------------------------- |
3063 Label miss; | 3065 Label miss; |
3064 | 3066 |
3065 // Check the key is the cached one. | 3067 // Check the key is the cached one. |
3066 __ cmp(r0, Operand(name)); | 3068 __ cmp(r0, Operand(name)); |
3067 __ b(ne, &miss); | 3069 __ b(ne, &miss); |
3068 | 3070 |
3069 GenerateLoadConstant(receiver, holder, r1, r2, r3, r4, value, name, &miss); | 3071 GenerateLoadConstant(receiver, holder, r1, r2, r3, r4, value, name, &miss); |
3070 __ bind(&miss); | 3072 __ bind(&miss); |
3071 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); | 3073 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); |
3072 | 3074 |
3073 // Return the generated code. | 3075 // Return the generated code. |
3074 return GetCode(CONSTANT_FUNCTION, name); | 3076 return GetCode(Code::CONSTANT_FUNCTION, name); |
3075 } | 3077 } |
3076 | 3078 |
3077 | 3079 |
3078 Handle<Code> KeyedLoadStubCompiler::CompileLoadInterceptor( | 3080 Handle<Code> KeyedLoadStubCompiler::CompileLoadInterceptor( |
3079 Handle<JSObject> receiver, | 3081 Handle<JSObject> receiver, |
3080 Handle<JSObject> holder, | 3082 Handle<JSObject> holder, |
3081 Handle<String> name) { | 3083 Handle<String> name) { |
3082 // ----------- S t a t e ------------- | 3084 // ----------- S t a t e ------------- |
3083 // -- lr : return address | 3085 // -- lr : return address |
3084 // -- r0 : key | 3086 // -- r0 : key |
3085 // -- r1 : receiver | 3087 // -- r1 : receiver |
3086 // ----------------------------------- | 3088 // ----------------------------------- |
3087 Label miss; | 3089 Label miss; |
3088 | 3090 |
3089 // Check the key is the cached one. | 3091 // Check the key is the cached one. |
3090 __ cmp(r0, Operand(name)); | 3092 __ cmp(r0, Operand(name)); |
3091 __ b(ne, &miss); | 3093 __ b(ne, &miss); |
3092 | 3094 |
3093 LookupResult lookup(isolate()); | 3095 LookupResult lookup(isolate()); |
3094 LookupPostInterceptor(holder, name, &lookup); | 3096 LookupPostInterceptor(holder, name, &lookup); |
3095 GenerateLoadInterceptor(receiver, holder, &lookup, r1, r0, r2, r3, r4, name, | 3097 GenerateLoadInterceptor(receiver, holder, &lookup, r1, r0, r2, r3, r4, name, |
3096 &miss); | 3098 &miss); |
3097 __ bind(&miss); | 3099 __ bind(&miss); |
3098 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); | 3100 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); |
3099 | 3101 |
3100 return GetCode(INTERCEPTOR, name); | 3102 return GetCode(Code::INTERCEPTOR, name); |
3101 } | 3103 } |
3102 | 3104 |
3103 | 3105 |
3104 Handle<Code> KeyedLoadStubCompiler::CompileLoadArrayLength( | 3106 Handle<Code> KeyedLoadStubCompiler::CompileLoadArrayLength( |
3105 Handle<String> name) { | 3107 Handle<String> name) { |
3106 // ----------- S t a t e ------------- | 3108 // ----------- S t a t e ------------- |
3107 // -- lr : return address | 3109 // -- lr : return address |
3108 // -- r0 : key | 3110 // -- r0 : key |
3109 // -- r1 : receiver | 3111 // -- r1 : receiver |
3110 // ----------------------------------- | 3112 // ----------------------------------- |
3111 Label miss; | 3113 Label miss; |
3112 | 3114 |
3113 // Check the key is the cached one. | 3115 // Check the key is the cached one. |
3114 __ cmp(r0, Operand(name)); | 3116 __ cmp(r0, Operand(name)); |
3115 __ b(ne, &miss); | 3117 __ b(ne, &miss); |
3116 | 3118 |
3117 GenerateLoadArrayLength(masm(), r1, r2, &miss); | 3119 GenerateLoadArrayLength(masm(), r1, r2, &miss); |
3118 __ bind(&miss); | 3120 __ bind(&miss); |
3119 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); | 3121 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); |
3120 | 3122 |
3121 return GetCode(CALLBACKS, name); | 3123 return GetCode(Code::CALLBACKS, name); |
3122 } | 3124 } |
3123 | 3125 |
3124 | 3126 |
3125 Handle<Code> KeyedLoadStubCompiler::CompileLoadStringLength( | 3127 Handle<Code> KeyedLoadStubCompiler::CompileLoadStringLength( |
3126 Handle<String> name) { | 3128 Handle<String> name) { |
3127 // ----------- S t a t e ------------- | 3129 // ----------- S t a t e ------------- |
3128 // -- lr : return address | 3130 // -- lr : return address |
3129 // -- r0 : key | 3131 // -- r0 : key |
3130 // -- r1 : receiver | 3132 // -- r1 : receiver |
3131 // ----------------------------------- | 3133 // ----------------------------------- |
3132 Label miss; | 3134 Label miss; |
3133 | 3135 |
3134 Counters* counters = masm()->isolate()->counters(); | 3136 Counters* counters = masm()->isolate()->counters(); |
3135 __ IncrementCounter(counters->keyed_load_string_length(), 1, r2, r3); | 3137 __ IncrementCounter(counters->keyed_load_string_length(), 1, r2, r3); |
3136 | 3138 |
3137 // Check the key is the cached one. | 3139 // Check the key is the cached one. |
3138 __ cmp(r0, Operand(name)); | 3140 __ cmp(r0, Operand(name)); |
3139 __ b(ne, &miss); | 3141 __ b(ne, &miss); |
3140 | 3142 |
3141 GenerateLoadStringLength(masm(), r1, r2, r3, &miss, true); | 3143 GenerateLoadStringLength(masm(), r1, r2, r3, &miss, true); |
3142 __ bind(&miss); | 3144 __ bind(&miss); |
3143 __ DecrementCounter(counters->keyed_load_string_length(), 1, r2, r3); | 3145 __ DecrementCounter(counters->keyed_load_string_length(), 1, r2, r3); |
3144 | 3146 |
3145 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); | 3147 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); |
3146 | 3148 |
3147 return GetCode(CALLBACKS, name); | 3149 return GetCode(Code::CALLBACKS, name); |
3148 } | 3150 } |
3149 | 3151 |
3150 | 3152 |
3151 Handle<Code> KeyedLoadStubCompiler::CompileLoadFunctionPrototype( | 3153 Handle<Code> KeyedLoadStubCompiler::CompileLoadFunctionPrototype( |
3152 Handle<String> name) { | 3154 Handle<String> name) { |
3153 // ----------- S t a t e ------------- | 3155 // ----------- S t a t e ------------- |
3154 // -- lr : return address | 3156 // -- lr : return address |
3155 // -- r0 : key | 3157 // -- r0 : key |
3156 // -- r1 : receiver | 3158 // -- r1 : receiver |
3157 // ----------------------------------- | 3159 // ----------------------------------- |
3158 Label miss; | 3160 Label miss; |
3159 | 3161 |
3160 Counters* counters = masm()->isolate()->counters(); | 3162 Counters* counters = masm()->isolate()->counters(); |
3161 __ IncrementCounter(counters->keyed_load_function_prototype(), 1, r2, r3); | 3163 __ IncrementCounter(counters->keyed_load_function_prototype(), 1, r2, r3); |
3162 | 3164 |
3163 // Check the name hasn't changed. | 3165 // Check the name hasn't changed. |
3164 __ cmp(r0, Operand(name)); | 3166 __ cmp(r0, Operand(name)); |
3165 __ b(ne, &miss); | 3167 __ b(ne, &miss); |
3166 | 3168 |
3167 GenerateLoadFunctionPrototype(masm(), r1, r2, r3, &miss); | 3169 GenerateLoadFunctionPrototype(masm(), r1, r2, r3, &miss); |
3168 __ bind(&miss); | 3170 __ bind(&miss); |
3169 __ DecrementCounter(counters->keyed_load_function_prototype(), 1, r2, r3); | 3171 __ DecrementCounter(counters->keyed_load_function_prototype(), 1, r2, r3); |
3170 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); | 3172 GenerateLoadMiss(masm(), Code::KEYED_LOAD_IC); |
3171 | 3173 |
3172 return GetCode(CALLBACKS, name); | 3174 return GetCode(Code::CALLBACKS, name); |
3173 } | 3175 } |
3174 | 3176 |
3175 | 3177 |
3176 Handle<Code> KeyedLoadStubCompiler::CompileLoadElement( | 3178 Handle<Code> KeyedLoadStubCompiler::CompileLoadElement( |
3177 Handle<Map> receiver_map) { | 3179 Handle<Map> receiver_map) { |
3178 // ----------- S t a t e ------------- | 3180 // ----------- S t a t e ------------- |
3179 // -- lr : return address | 3181 // -- lr : return address |
3180 // -- r0 : key | 3182 // -- r0 : key |
3181 // -- r1 : receiver | 3183 // -- r1 : receiver |
3182 // ----------------------------------- | 3184 // ----------------------------------- |
3183 ElementsKind elements_kind = receiver_map->elements_kind(); | 3185 ElementsKind elements_kind = receiver_map->elements_kind(); |
3184 Handle<Code> stub = KeyedLoadElementStub(elements_kind).GetCode(); | 3186 Handle<Code> stub = KeyedLoadElementStub(elements_kind).GetCode(); |
3185 | 3187 |
3186 __ DispatchMap(r1, r2, receiver_map, stub, DO_SMI_CHECK); | 3188 __ DispatchMap(r1, r2, receiver_map, stub, DO_SMI_CHECK); |
3187 | 3189 |
3188 Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Miss(); | 3190 Handle<Code> ic = isolate()->builtins()->KeyedLoadIC_Miss(); |
3189 __ Jump(ic, RelocInfo::CODE_TARGET); | 3191 __ Jump(ic, RelocInfo::CODE_TARGET); |
3190 | 3192 |
3191 // Return the generated code. | 3193 // Return the generated code. |
3192 return GetCode(NORMAL, factory()->empty_string()); | 3194 return GetCode(Code::NORMAL, factory()->empty_string()); |
3193 } | 3195 } |
3194 | 3196 |
3195 | 3197 |
3196 Handle<Code> KeyedLoadStubCompiler::CompileLoadPolymorphic( | 3198 Handle<Code> KeyedLoadStubCompiler::CompileLoadPolymorphic( |
3197 MapHandleList* receiver_maps, | 3199 MapHandleList* receiver_maps, |
3198 CodeHandleList* handler_ics) { | 3200 CodeHandleList* handler_ics) { |
3199 // ----------- S t a t e ------------- | 3201 // ----------- S t a t e ------------- |
3200 // -- lr : return address | 3202 // -- lr : return address |
3201 // -- r0 : key | 3203 // -- r0 : key |
3202 // -- r1 : receiver | 3204 // -- r1 : receiver |
3203 // ----------------------------------- | 3205 // ----------------------------------- |
3204 Label miss; | 3206 Label miss; |
3205 __ JumpIfSmi(r1, &miss); | 3207 __ JumpIfSmi(r1, &miss); |
3206 | 3208 |
3207 int receiver_count = receiver_maps->length(); | 3209 int receiver_count = receiver_maps->length(); |
3208 __ ldr(r2, FieldMemOperand(r1, HeapObject::kMapOffset)); | 3210 __ ldr(r2, FieldMemOperand(r1, HeapObject::kMapOffset)); |
3209 for (int current = 0; current < receiver_count; ++current) { | 3211 for (int current = 0; current < receiver_count; ++current) { |
3210 __ mov(ip, Operand(receiver_maps->at(current))); | 3212 __ mov(ip, Operand(receiver_maps->at(current))); |
3211 __ cmp(r2, ip); | 3213 __ cmp(r2, ip); |
3212 __ Jump(handler_ics->at(current), RelocInfo::CODE_TARGET, eq); | 3214 __ Jump(handler_ics->at(current), RelocInfo::CODE_TARGET, eq); |
3213 } | 3215 } |
3214 | 3216 |
3215 __ bind(&miss); | 3217 __ bind(&miss); |
3216 Handle<Code> miss_ic = isolate()->builtins()->KeyedLoadIC_Miss(); | 3218 Handle<Code> miss_ic = isolate()->builtins()->KeyedLoadIC_Miss(); |
3217 __ Jump(miss_ic, RelocInfo::CODE_TARGET, al); | 3219 __ Jump(miss_ic, RelocInfo::CODE_TARGET, al); |
3218 | 3220 |
3219 // Return the generated code. | 3221 // Return the generated code. |
3220 return GetCode(NORMAL, factory()->empty_string(), MEGAMORPHIC); | 3222 return GetCode(Code::NORMAL, factory()->empty_string(), MEGAMORPHIC); |
3221 } | 3223 } |
3222 | 3224 |
3223 | 3225 |
3224 Handle<Code> KeyedStoreStubCompiler::CompileStoreField(Handle<JSObject> object, | 3226 Handle<Code> KeyedStoreStubCompiler::CompileStoreField(Handle<JSObject> object, |
3225 int index, | 3227 int index, |
3226 Handle<Map> transition, | 3228 Handle<Map> transition, |
3227 Handle<String> name) { | 3229 Handle<String> name) { |
3228 // ----------- S t a t e ------------- | 3230 // ----------- S t a t e ------------- |
3229 // -- r0 : value | 3231 // -- r0 : value |
3230 // -- r1 : name | 3232 // -- r1 : name |
(...skipping 18 matching lines...) Expand all Loading... |
3249 name, | 3251 name, |
3250 r2, r1, r3, r4, | 3252 r2, r1, r3, r4, |
3251 &miss); | 3253 &miss); |
3252 __ bind(&miss); | 3254 __ bind(&miss); |
3253 | 3255 |
3254 __ DecrementCounter(counters->keyed_store_field(), 1, r3, r4); | 3256 __ DecrementCounter(counters->keyed_store_field(), 1, r3, r4); |
3255 Handle<Code> ic = masm()->isolate()->builtins()->KeyedStoreIC_Miss(); | 3257 Handle<Code> ic = masm()->isolate()->builtins()->KeyedStoreIC_Miss(); |
3256 __ Jump(ic, RelocInfo::CODE_TARGET); | 3258 __ Jump(ic, RelocInfo::CODE_TARGET); |
3257 | 3259 |
3258 // Return the generated code. | 3260 // Return the generated code. |
3259 return GetCode(transition.is_null() ? FIELD : MAP_TRANSITION, name); | 3261 return GetCode(transition.is_null() |
| 3262 ? Code::FIELD |
| 3263 : Code::MAP_TRANSITION, name); |
3260 } | 3264 } |
3261 | 3265 |
3262 | 3266 |
3263 Handle<Code> KeyedStoreStubCompiler::CompileStoreElement( | 3267 Handle<Code> KeyedStoreStubCompiler::CompileStoreElement( |
3264 Handle<Map> receiver_map) { | 3268 Handle<Map> receiver_map) { |
3265 // ----------- S t a t e ------------- | 3269 // ----------- S t a t e ------------- |
3266 // -- r0 : value | 3270 // -- r0 : value |
3267 // -- r1 : key | 3271 // -- r1 : key |
3268 // -- r2 : receiver | 3272 // -- r2 : receiver |
3269 // -- lr : return address | 3273 // -- lr : return address |
3270 // -- r3 : scratch | 3274 // -- r3 : scratch |
3271 // ----------------------------------- | 3275 // ----------------------------------- |
3272 ElementsKind elements_kind = receiver_map->elements_kind(); | 3276 ElementsKind elements_kind = receiver_map->elements_kind(); |
3273 bool is_js_array = receiver_map->instance_type() == JS_ARRAY_TYPE; | 3277 bool is_js_array = receiver_map->instance_type() == JS_ARRAY_TYPE; |
3274 Handle<Code> stub = | 3278 Handle<Code> stub = |
3275 KeyedStoreElementStub(is_js_array, elements_kind, grow_mode_).GetCode(); | 3279 KeyedStoreElementStub(is_js_array, elements_kind, grow_mode_).GetCode(); |
3276 | 3280 |
3277 __ DispatchMap(r2, r3, receiver_map, stub, DO_SMI_CHECK); | 3281 __ DispatchMap(r2, r3, receiver_map, stub, DO_SMI_CHECK); |
3278 | 3282 |
3279 Handle<Code> ic = isolate()->builtins()->KeyedStoreIC_Miss(); | 3283 Handle<Code> ic = isolate()->builtins()->KeyedStoreIC_Miss(); |
3280 __ Jump(ic, RelocInfo::CODE_TARGET); | 3284 __ Jump(ic, RelocInfo::CODE_TARGET); |
3281 | 3285 |
3282 // Return the generated code. | 3286 // Return the generated code. |
3283 return GetCode(NORMAL, factory()->empty_string()); | 3287 return GetCode(Code::NORMAL, factory()->empty_string()); |
3284 } | 3288 } |
3285 | 3289 |
3286 | 3290 |
3287 Handle<Code> KeyedStoreStubCompiler::CompileStorePolymorphic( | 3291 Handle<Code> KeyedStoreStubCompiler::CompileStorePolymorphic( |
3288 MapHandleList* receiver_maps, | 3292 MapHandleList* receiver_maps, |
3289 CodeHandleList* handler_stubs, | 3293 CodeHandleList* handler_stubs, |
3290 MapHandleList* transitioned_maps) { | 3294 MapHandleList* transitioned_maps) { |
3291 // ----------- S t a t e ------------- | 3295 // ----------- S t a t e ------------- |
3292 // -- r0 : value | 3296 // -- r0 : value |
3293 // -- r1 : key | 3297 // -- r1 : key |
(...skipping 18 matching lines...) Expand all Loading... |
3312 __ Jump(handler_stubs->at(i), RelocInfo::CODE_TARGET, al); | 3316 __ Jump(handler_stubs->at(i), RelocInfo::CODE_TARGET, al); |
3313 __ bind(&next_map); | 3317 __ bind(&next_map); |
3314 } | 3318 } |
3315 } | 3319 } |
3316 | 3320 |
3317 __ bind(&miss); | 3321 __ bind(&miss); |
3318 Handle<Code> miss_ic = isolate()->builtins()->KeyedStoreIC_Miss(); | 3322 Handle<Code> miss_ic = isolate()->builtins()->KeyedStoreIC_Miss(); |
3319 __ Jump(miss_ic, RelocInfo::CODE_TARGET, al); | 3323 __ Jump(miss_ic, RelocInfo::CODE_TARGET, al); |
3320 | 3324 |
3321 // Return the generated code. | 3325 // Return the generated code. |
3322 return GetCode(NORMAL, factory()->empty_string(), MEGAMORPHIC); | 3326 return GetCode(Code::NORMAL, factory()->empty_string(), MEGAMORPHIC); |
3323 } | 3327 } |
3324 | 3328 |
3325 | 3329 |
3326 Handle<Code> ConstructStubCompiler::CompileConstructStub( | 3330 Handle<Code> ConstructStubCompiler::CompileConstructStub( |
3327 Handle<JSFunction> function) { | 3331 Handle<JSFunction> function) { |
3328 // ----------- S t a t e ------------- | 3332 // ----------- S t a t e ------------- |
3329 // -- r0 : argc | 3333 // -- r0 : argc |
3330 // -- r1 : constructor | 3334 // -- r1 : constructor |
3331 // -- lr : return address | 3335 // -- lr : return address |
3332 // -- [sp] : last argument | 3336 // -- [sp] : last argument |
(...skipping 1342 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4675 __ Jump(ic_slow, RelocInfo::CODE_TARGET); | 4679 __ Jump(ic_slow, RelocInfo::CODE_TARGET); |
4676 } | 4680 } |
4677 } | 4681 } |
4678 | 4682 |
4679 | 4683 |
4680 #undef __ | 4684 #undef __ |
4681 | 4685 |
4682 } } // namespace v8::internal | 4686 } } // namespace v8::internal |
4683 | 4687 |
4684 #endif // V8_TARGET_ARCH_ARM | 4688 #endif // V8_TARGET_ARCH_ARM |
OLD | NEW |