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 832 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
843 bool restore_context) { | 843 bool restore_context) { |
844 // ----------- S t a t e ------------- | 844 // ----------- S t a t e ------------- |
845 // -- sp[0] - sp[24] : FunctionCallbackInfo, incl. | 845 // -- sp[0] - sp[24] : FunctionCallbackInfo, incl. |
846 // : holder (set by CheckPrototypes) | 846 // : holder (set by CheckPrototypes) |
847 // -- sp[28] : last JS argument | 847 // -- sp[28] : last JS argument |
848 // -- ... | 848 // -- ... |
849 // -- sp[(argc + 6) * 4] : first JS argument | 849 // -- sp[(argc + 6) * 4] : first JS argument |
850 // -- sp[(argc + 7) * 4] : receiver | 850 // -- sp[(argc + 7) * 4] : receiver |
851 // ----------------------------------- | 851 // ----------------------------------- |
852 typedef FunctionCallbackArguments FCA; | 852 typedef FunctionCallbackArguments FCA; |
853 const int kArgs = kFastApiCallArguments; | |
854 // Save calling context. | 853 // Save calling context. |
855 __ str(cp, | 854 __ str(cp, MemOperand(sp, FCA::kContextSaveIndex * kPointerSize)); |
856 MemOperand(sp, (kArgs - 1 + FCA::kContextSaveIndex) * kPointerSize)); | |
857 // Get the function and setup the context. | 855 // Get the function and setup the context. |
858 Handle<JSFunction> function = optimization.constant_function(); | 856 Handle<JSFunction> function = optimization.constant_function(); |
859 __ LoadHeapObject(r5, function); | 857 __ LoadHeapObject(r5, function); |
860 __ ldr(cp, FieldMemOperand(r5, JSFunction::kContextOffset)); | 858 __ ldr(cp, FieldMemOperand(r5, JSFunction::kContextOffset)); |
861 __ str(r5, MemOperand(sp, (kArgs - 1 + FCA::kCalleeIndex) * kPointerSize)); | 859 __ str(r5, MemOperand(sp, FCA::kCalleeIndex * kPointerSize)); |
862 | 860 |
863 // Construct the FunctionCallbackInfo. | 861 // Construct the FunctionCallbackInfo. |
864 Handle<CallHandlerInfo> api_call_info = optimization.api_call_info(); | 862 Handle<CallHandlerInfo> api_call_info = optimization.api_call_info(); |
865 Handle<Object> call_data(api_call_info->data(), masm->isolate()); | 863 Handle<Object> call_data(api_call_info->data(), masm->isolate()); |
866 if (masm->isolate()->heap()->InNewSpace(*call_data)) { | 864 if (masm->isolate()->heap()->InNewSpace(*call_data)) { |
867 __ Move(r0, api_call_info); | 865 __ Move(r0, api_call_info); |
868 __ ldr(r6, FieldMemOperand(r0, CallHandlerInfo::kDataOffset)); | 866 __ ldr(r6, FieldMemOperand(r0, CallHandlerInfo::kDataOffset)); |
869 } else { | 867 } else { |
870 __ Move(r6, call_data); | 868 __ Move(r6, call_data); |
871 } | 869 } |
872 // Store call data. | 870 // Store call data. |
873 __ str(r6, MemOperand(sp, (kArgs - 1 + FCA::kDataIndex) * kPointerSize)); | 871 __ str(r6, MemOperand(sp, FCA::kDataIndex * kPointerSize)); |
874 // Store isolate. | 872 // Store isolate. |
875 __ mov(r5, Operand(ExternalReference::isolate_address(masm->isolate()))); | 873 __ mov(r5, Operand(ExternalReference::isolate_address(masm->isolate()))); |
876 __ str(r5, MemOperand(sp, (kArgs - 1 + FCA::kIsolateIndex) * kPointerSize)); | 874 __ str(r5, MemOperand(sp, FCA::kIsolateIndex * kPointerSize)); |
877 // Store ReturnValue default and ReturnValue. | 875 // Store ReturnValue default and ReturnValue. |
878 __ LoadRoot(r5, Heap::kUndefinedValueRootIndex); | 876 __ LoadRoot(r5, Heap::kUndefinedValueRootIndex); |
879 __ str(r5, | 877 __ str(r5, MemOperand(sp, FCA::kReturnValueOffset * kPointerSize)); |
880 MemOperand(sp, (kArgs - 1 + FCA::kReturnValueOffset) * kPointerSize)); | 878 __ str(r5, MemOperand(sp, FCA::kReturnValueDefaultValueIndex * kPointerSize)); |
881 __ str( | |
882 r5, | |
883 MemOperand( | |
884 sp, (kArgs - 1 + FCA::kReturnValueDefaultValueIndex) * kPointerSize)); | |
885 | 879 |
886 // Prepare arguments. | 880 // Prepare arguments. |
887 __ add(r2, sp, Operand((kArgs - 1) * kPointerSize)); | 881 __ mov(r2, sp); |
888 | 882 |
889 // Allocate the v8::Arguments structure in the arguments' space since | 883 // Allocate the v8::Arguments structure in the arguments' space since |
890 // it's not controlled by GC. | 884 // it's not controlled by GC. |
891 const int kApiStackSpace = 4; | 885 const int kApiStackSpace = 4; |
892 | 886 |
893 FrameScope frame_scope(masm, StackFrame::MANUAL); | 887 FrameScope frame_scope(masm, StackFrame::MANUAL); |
894 __ EnterExitFrame(false, kApiStackSpace); | 888 __ EnterExitFrame(false, kApiStackSpace); |
895 | 889 |
896 // r0 = v8::Arguments& | 890 // r0 = FunctionCallbackInfo& |
897 // Arguments is after the return address. | 891 // Arguments is after the return address. |
898 __ add(r0, sp, Operand(1 * kPointerSize)); | 892 __ add(r0, sp, Operand(1 * kPointerSize)); |
899 // v8::Arguments::implicit_args_ | 893 // FunctionCallbackInfo::implicit_args_ |
900 __ str(r2, MemOperand(r0, 0 * kPointerSize)); | 894 __ str(r2, MemOperand(r0, 0 * kPointerSize)); |
901 // v8::Arguments::values_ | 895 // FunctionCallbackInfo::values_ |
902 __ add(ip, r2, Operand(argc * kPointerSize)); | 896 __ add(ip, r2, Operand((kFastApiCallArguments - 1 + argc) * kPointerSize)); |
903 __ str(ip, MemOperand(r0, 1 * kPointerSize)); | 897 __ str(ip, MemOperand(r0, 1 * kPointerSize)); |
904 // v8::Arguments::length_ = argc | 898 // FunctionCallbackInfo::length_ = argc |
905 __ mov(ip, Operand(argc)); | 899 __ mov(ip, Operand(argc)); |
906 __ str(ip, MemOperand(r0, 2 * kPointerSize)); | 900 __ str(ip, MemOperand(r0, 2 * kPointerSize)); |
907 // v8::Arguments::is_construct_call = 0 | 901 // FunctionCallbackInfo::is_construct_call = 0 |
908 __ mov(ip, Operand::Zero()); | 902 __ mov(ip, Operand::Zero()); |
909 __ str(ip, MemOperand(r0, 3 * kPointerSize)); | 903 __ str(ip, MemOperand(r0, 3 * kPointerSize)); |
910 | 904 |
911 const int kStackUnwindSpace = argc + kArgs + 1; | 905 const int kStackUnwindSpace = argc + kFastApiCallArguments + 1; |
912 Address function_address = v8::ToCData<Address>(api_call_info->callback()); | 906 Address function_address = v8::ToCData<Address>(api_call_info->callback()); |
913 ApiFunction fun(function_address); | 907 ApiFunction fun(function_address); |
914 ExternalReference::Type type = ExternalReference::DIRECT_API_CALL; | 908 ExternalReference::Type type = ExternalReference::DIRECT_API_CALL; |
915 ExternalReference ref = ExternalReference(&fun, | 909 ExternalReference ref = ExternalReference(&fun, |
916 type, | 910 type, |
917 masm->isolate()); | 911 masm->isolate()); |
918 Address thunk_address = FUNCTION_ADDR(&InvokeFunctionCallback); | 912 Address thunk_address = FUNCTION_ADDR(&InvokeFunctionCallback); |
919 ExternalReference::Type thunk_type = ExternalReference::PROFILING_API_CALL; | 913 ExternalReference::Type thunk_type = ExternalReference::PROFILING_API_CALL; |
920 ApiFunction thunk_fun(thunk_address); | 914 ApiFunction thunk_fun(thunk_address); |
921 ExternalReference thunk_ref = ExternalReference(&thunk_fun, thunk_type, | 915 ExternalReference thunk_ref = ExternalReference(&thunk_fun, thunk_type, |
922 masm->isolate()); | 916 masm->isolate()); |
923 | 917 |
924 AllowExternalCallThatCantCauseGC scope(masm); | 918 AllowExternalCallThatCantCauseGC scope(masm); |
925 MemOperand context_restore_operand( | 919 MemOperand context_restore_operand( |
926 fp, (kArgs + 1 + FCA::kContextSaveIndex) * kPointerSize); | 920 fp, (2 + FCA::kContextSaveIndex) * kPointerSize); |
927 MemOperand return_value_operand( | 921 MemOperand return_value_operand(fp, |
928 fp, (kArgs + 1 + FCA::kReturnValueOffset) * kPointerSize); | 922 (2 + FCA::kReturnValueOffset) * kPointerSize); |
| 923 |
929 __ CallApiFunctionAndReturn(ref, | 924 __ CallApiFunctionAndReturn(ref, |
930 function_address, | 925 function_address, |
931 thunk_ref, | 926 thunk_ref, |
932 r1, | 927 r1, |
933 kStackUnwindSpace, | 928 kStackUnwindSpace, |
934 return_value_operand, | 929 return_value_operand, |
935 restore_context ? | 930 restore_context ? |
936 &context_restore_operand : NULL); | 931 &context_restore_operand : NULL); |
937 } | 932 } |
938 | 933 |
939 | 934 |
940 // Generate call to api function. | 935 // Generate call to api function. |
941 static void GenerateFastApiCall(MacroAssembler* masm, | 936 static void GenerateFastApiCall(MacroAssembler* masm, |
942 const CallOptimization& optimization, | 937 const CallOptimization& optimization, |
943 Register receiver, | 938 Register receiver, |
944 Register scratch, | 939 Register scratch, |
945 int argc, | 940 int argc, |
946 Register* values) { | 941 Register* values) { |
947 ASSERT(optimization.is_simple_api_call()); | 942 ASSERT(optimization.is_simple_api_call()); |
948 ASSERT(!receiver.is(scratch)); | 943 ASSERT(!receiver.is(scratch)); |
949 | 944 |
| 945 typedef FunctionCallbackArguments FCA; |
950 const int stack_space = kFastApiCallArguments + argc + 1; | 946 const int stack_space = kFastApiCallArguments + argc + 1; |
951 const int kHolderIndex = kFastApiCallArguments + | |
952 FunctionCallbackArguments::kHolderIndex - 1; | |
953 // Assign stack space for the call arguments. | 947 // Assign stack space for the call arguments. |
954 __ sub(sp, sp, Operand(stack_space * kPointerSize)); | 948 __ sub(sp, sp, Operand(stack_space * kPointerSize)); |
955 // Write holder to stack frame. | 949 // Write holder to stack frame. |
956 __ str(receiver, MemOperand(sp, kHolderIndex * kPointerSize)); | 950 __ str(receiver, MemOperand(sp, FCA::kHolderIndex * kPointerSize)); |
957 // Write receiver to stack frame. | 951 // Write receiver to stack frame. |
958 int index = stack_space - 1; | 952 int index = stack_space - 1; |
959 __ str(receiver, MemOperand(sp, index * kPointerSize)); | 953 __ str(receiver, MemOperand(sp, index * kPointerSize)); |
960 // Write the arguments to stack frame. | 954 // Write the arguments to stack frame. |
961 for (int i = 0; i < argc; i++) { | 955 for (int i = 0; i < argc; i++) { |
962 ASSERT(!receiver.is(values[i])); | 956 ASSERT(!receiver.is(values[i])); |
963 ASSERT(!scratch.is(values[i])); | 957 ASSERT(!scratch.is(values[i])); |
964 __ str(receiver, MemOperand(sp, index-- * kPointerSize)); | 958 __ str(receiver, MemOperand(sp, index-- * kPointerSize)); |
965 } | 959 } |
966 | 960 |
(...skipping 229 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1196 Register StubCompiler::CheckPrototypes(Handle<JSObject> object, | 1190 Register StubCompiler::CheckPrototypes(Handle<JSObject> object, |
1197 Register object_reg, | 1191 Register object_reg, |
1198 Handle<JSObject> holder, | 1192 Handle<JSObject> holder, |
1199 Register holder_reg, | 1193 Register holder_reg, |
1200 Register scratch1, | 1194 Register scratch1, |
1201 Register scratch2, | 1195 Register scratch2, |
1202 Handle<Name> name, | 1196 Handle<Name> name, |
1203 int save_at_depth, | 1197 int save_at_depth, |
1204 Label* miss, | 1198 Label* miss, |
1205 PrototypeCheckType check) { | 1199 PrototypeCheckType check) { |
1206 const int kHolderIndex = kFastApiCallArguments + | |
1207 FunctionCallbackArguments::kHolderIndex - 1; | |
1208 // Make sure that the type feedback oracle harvests the receiver map. | 1200 // Make sure that the type feedback oracle harvests the receiver map. |
1209 // TODO(svenpanne) Remove this hack when all ICs are reworked. | 1201 // TODO(svenpanne) Remove this hack when all ICs are reworked. |
1210 __ mov(scratch1, Operand(Handle<Map>(object->map()))); | 1202 __ mov(scratch1, Operand(Handle<Map>(object->map()))); |
1211 | 1203 |
1212 Handle<JSObject> first = object; | 1204 Handle<JSObject> first = object; |
1213 // Make sure there's no overlap between holder and object registers. | 1205 // Make sure there's no overlap between holder and object registers. |
1214 ASSERT(!scratch1.is(object_reg) && !scratch1.is(holder_reg)); | 1206 ASSERT(!scratch1.is(object_reg) && !scratch1.is(holder_reg)); |
1215 ASSERT(!scratch2.is(object_reg) && !scratch2.is(holder_reg) | 1207 ASSERT(!scratch2.is(object_reg) && !scratch2.is(holder_reg) |
1216 && !scratch2.is(scratch1)); | 1208 && !scratch2.is(scratch1)); |
1217 | 1209 |
1218 // Keep track of the current object in register reg. | 1210 // Keep track of the current object in register reg. |
1219 Register reg = object_reg; | 1211 Register reg = object_reg; |
1220 int depth = 0; | 1212 int depth = 0; |
1221 | 1213 |
| 1214 typedef FunctionCallbackArguments FCA; |
1222 if (save_at_depth == depth) { | 1215 if (save_at_depth == depth) { |
1223 __ str(reg, MemOperand(sp, kHolderIndex * kPointerSize)); | 1216 __ str(reg, MemOperand(sp, FCA::kHolderIndex * kPointerSize)); |
1224 } | 1217 } |
1225 | 1218 |
1226 // Check the maps in the prototype chain. | 1219 // Check the maps in the prototype chain. |
1227 // Traverse the prototype chain from the object and do map checks. | 1220 // Traverse the prototype chain from the object and do map checks. |
1228 Handle<JSObject> current = object; | 1221 Handle<JSObject> current = object; |
1229 while (!current.is_identical_to(holder)) { | 1222 while (!current.is_identical_to(holder)) { |
1230 ++depth; | 1223 ++depth; |
1231 | 1224 |
1232 // Only global objects and objects that do not require access | 1225 // Only global objects and objects that do not require access |
1233 // checks are allowed in stubs. | 1226 // checks are allowed in stubs. |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1272 // The prototype is in new space; we cannot store a reference to it | 1265 // The prototype is in new space; we cannot store a reference to it |
1273 // in the code. Load it from the map. | 1266 // in the code. Load it from the map. |
1274 __ ldr(reg, FieldMemOperand(map_reg, Map::kPrototypeOffset)); | 1267 __ ldr(reg, FieldMemOperand(map_reg, Map::kPrototypeOffset)); |
1275 } else { | 1268 } else { |
1276 // The prototype is in old space; load it directly. | 1269 // The prototype is in old space; load it directly. |
1277 __ mov(reg, Operand(prototype)); | 1270 __ mov(reg, Operand(prototype)); |
1278 } | 1271 } |
1279 } | 1272 } |
1280 | 1273 |
1281 if (save_at_depth == depth) { | 1274 if (save_at_depth == depth) { |
1282 __ str(reg, MemOperand(sp, kHolderIndex * kPointerSize)); | 1275 __ str(reg, MemOperand(sp, FCA::kHolderIndex * kPointerSize)); |
1283 } | 1276 } |
1284 | 1277 |
1285 // Go to the next object in the prototype chain. | 1278 // Go to the next object in the prototype chain. |
1286 current = prototype; | 1279 current = prototype; |
1287 } | 1280 } |
1288 | 1281 |
1289 // Log the check depth. | 1282 // Log the check depth. |
1290 LOG(isolate(), IntEvent("check-maps-depth", depth + 1)); | 1283 LOG(isolate(), IntEvent("check-maps-depth", depth + 1)); |
1291 | 1284 |
1292 if (!holder.is_identical_to(first) || check == CHECK_ALL_MAPS) { | 1285 if (!holder.is_identical_to(first) || check == CHECK_ALL_MAPS) { |
(...skipping 138 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1431 GenerateFastApiCall( | 1424 GenerateFastApiCall( |
1432 masm(), call_optimization, receiver(), scratch3(), 0, NULL); | 1425 masm(), call_optimization, receiver(), scratch3(), 0, NULL); |
1433 } | 1426 } |
1434 | 1427 |
1435 | 1428 |
1436 void BaseLoadStubCompiler::GenerateLoadCallback( | 1429 void BaseLoadStubCompiler::GenerateLoadCallback( |
1437 Register reg, | 1430 Register reg, |
1438 Handle<ExecutableAccessorInfo> callback) { | 1431 Handle<ExecutableAccessorInfo> callback) { |
1439 // Build AccessorInfo::args_ list on the stack and push property name below | 1432 // Build AccessorInfo::args_ list on the stack and push property name below |
1440 // the exit frame to make GC aware of them and store pointers to them. | 1433 // the exit frame to make GC aware of them and store pointers to them. |
1441 STATIC_ASSERT(PropertyCallbackArguments::kThisIndex == 0); | 1434 STATIC_ASSERT(PropertyCallbackArguments::kHolderIndex == 0); |
1442 STATIC_ASSERT(PropertyCallbackArguments::kDataIndex == -1); | 1435 STATIC_ASSERT(PropertyCallbackArguments::kIsolateIndex == 1); |
1443 STATIC_ASSERT(PropertyCallbackArguments::kReturnValueOffset == -2); | 1436 STATIC_ASSERT(PropertyCallbackArguments::kReturnValueDefaultValueIndex == 2); |
1444 STATIC_ASSERT(PropertyCallbackArguments::kReturnValueDefaultValueIndex == -3); | 1437 STATIC_ASSERT(PropertyCallbackArguments::kReturnValueOffset == 3); |
1445 STATIC_ASSERT(PropertyCallbackArguments::kIsolateIndex == -4); | 1438 STATIC_ASSERT(PropertyCallbackArguments::kDataIndex == 4); |
1446 STATIC_ASSERT(PropertyCallbackArguments::kHolderIndex == -5); | 1439 STATIC_ASSERT(PropertyCallbackArguments::kThisIndex == 5); |
| 1440 STATIC_ASSERT(PropertyCallbackArguments::kArgsLength == 6); |
1447 ASSERT(!scratch2().is(reg)); | 1441 ASSERT(!scratch2().is(reg)); |
1448 ASSERT(!scratch3().is(reg)); | 1442 ASSERT(!scratch3().is(reg)); |
1449 ASSERT(!scratch4().is(reg)); | 1443 ASSERT(!scratch4().is(reg)); |
1450 __ push(receiver()); | 1444 __ push(receiver()); |
1451 __ mov(scratch2(), sp); // scratch2 = AccessorInfo::args_ | |
1452 if (heap()->InNewSpace(callback->data())) { | 1445 if (heap()->InNewSpace(callback->data())) { |
1453 __ Move(scratch3(), callback); | 1446 __ Move(scratch3(), callback); |
1454 __ ldr(scratch3(), FieldMemOperand(scratch3(), | 1447 __ ldr(scratch3(), FieldMemOperand(scratch3(), |
1455 ExecutableAccessorInfo::kDataOffset)); | 1448 ExecutableAccessorInfo::kDataOffset)); |
1456 } else { | 1449 } else { |
1457 __ Move(scratch3(), Handle<Object>(callback->data(), isolate())); | 1450 __ Move(scratch3(), Handle<Object>(callback->data(), isolate())); |
1458 } | 1451 } |
1459 __ push(scratch3()); | 1452 __ push(scratch3()); |
1460 __ LoadRoot(scratch3(), Heap::kUndefinedValueRootIndex); | 1453 __ LoadRoot(scratch3(), Heap::kUndefinedValueRootIndex); |
1461 __ mov(scratch4(), scratch3()); | 1454 __ mov(scratch4(), scratch3()); |
1462 __ Push(scratch3(), scratch4()); | 1455 __ Push(scratch3(), scratch4()); |
1463 __ mov(scratch4(), | 1456 __ mov(scratch4(), |
1464 Operand(ExternalReference::isolate_address(isolate()))); | 1457 Operand(ExternalReference::isolate_address(isolate()))); |
1465 __ Push(scratch4(), reg, name()); | 1458 __ Push(scratch4(), reg); |
| 1459 __ mov(scratch2(), sp); // scratch2 = PropertyAccessorInfo::args_ |
| 1460 __ push(name()); |
1466 __ mov(r0, sp); // r0 = Handle<Name> | 1461 __ mov(r0, sp); // r0 = Handle<Name> |
1467 | 1462 |
1468 const int kApiStackSpace = 1; | 1463 const int kApiStackSpace = 1; |
1469 FrameScope frame_scope(masm(), StackFrame::MANUAL); | 1464 FrameScope frame_scope(masm(), StackFrame::MANUAL); |
1470 __ EnterExitFrame(false, kApiStackSpace); | 1465 __ EnterExitFrame(false, kApiStackSpace); |
1471 | 1466 |
1472 // Create AccessorInfo instance on the stack above the exit frame with | 1467 // Create PropertyAccessorInfo instance on the stack above the exit frame with |
1473 // scratch2 (internal::Object** args_) as the data. | 1468 // scratch2 (internal::Object** args_) as the data. |
1474 __ str(scratch2(), MemOperand(sp, 1 * kPointerSize)); | 1469 __ str(scratch2(), MemOperand(sp, 1 * kPointerSize)); |
1475 __ add(r1, sp, Operand(1 * kPointerSize)); // r1 = AccessorInfo& | 1470 __ add(r1, sp, Operand(1 * kPointerSize)); // r1 = AccessorInfo& |
1476 | 1471 |
1477 const int kStackUnwindSpace = PropertyCallbackArguments::kArgsLength + 1; | 1472 const int kStackUnwindSpace = PropertyCallbackArguments::kArgsLength + 1; |
1478 Address getter_address = v8::ToCData<Address>(callback->getter()); | 1473 Address getter_address = v8::ToCData<Address>(callback->getter()); |
1479 | 1474 |
1480 ApiFunction fun(getter_address); | 1475 ApiFunction fun(getter_address); |
1481 ExternalReference::Type type = ExternalReference::DIRECT_GETTER_CALL; | 1476 ExternalReference::Type type = ExternalReference::DIRECT_GETTER_CALL; |
1482 ExternalReference ref = ExternalReference(&fun, type, isolate()); | 1477 ExternalReference ref = ExternalReference(&fun, type, isolate()); |
(...skipping 1710 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3193 // ----------------------------------- | 3188 // ----------------------------------- |
3194 TailCallBuiltin(masm, Builtins::kKeyedLoadIC_MissForceGeneric); | 3189 TailCallBuiltin(masm, Builtins::kKeyedLoadIC_MissForceGeneric); |
3195 } | 3190 } |
3196 | 3191 |
3197 | 3192 |
3198 #undef __ | 3193 #undef __ |
3199 | 3194 |
3200 } } // namespace v8::internal | 3195 } } // namespace v8::internal |
3201 | 3196 |
3202 #endif // V8_TARGET_ARCH_ARM | 3197 #endif // V8_TARGET_ARCH_ARM |
OLD | NEW |