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