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 1320 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1331 if (target_receiver_maps.length() > kMaxKeyedPolymorphism) { | 1331 if (target_receiver_maps.length() > kMaxKeyedPolymorphism) { |
1332 TRACE_GENERIC_IC(isolate(), "KeyedIC", "max polymorph exceeded"); | 1332 TRACE_GENERIC_IC(isolate(), "KeyedIC", "max polymorph exceeded"); |
1333 return generic_stub(); | 1333 return generic_stub(); |
1334 } | 1334 } |
1335 | 1335 |
1336 return isolate()->stub_cache()->ComputeLoadElementPolymorphic( | 1336 return isolate()->stub_cache()->ComputeLoadElementPolymorphic( |
1337 &target_receiver_maps); | 1337 &target_receiver_maps); |
1338 } | 1338 } |
1339 | 1339 |
1340 | 1340 |
1341 MaybeObject* KeyedLoadIC::Load(Handle<Object> object, | 1341 MaybeObject* KeyedLoadIC::LoadForceGeneric(Handle<Object> object, |
1342 Handle<Object> key, | 1342 Handle<Object> key) { |
1343 ICMissMode miss_mode) { | 1343 set_target(*generic_stub()); |
| 1344 return Runtime::GetObjectPropertyOrFail(isolate(), object, key); |
| 1345 } |
| 1346 |
| 1347 |
| 1348 MaybeObject* KeyedLoadIC::Load(Handle<Object> object, Handle<Object> key) { |
1344 if (MigrateDeprecated(object)) { | 1349 if (MigrateDeprecated(object)) { |
1345 return Runtime::GetObjectPropertyOrFail(isolate(), object, key); | 1350 return Runtime::GetObjectPropertyOrFail(isolate(), object, key); |
1346 } | 1351 } |
1347 | 1352 |
1348 MaybeObject* maybe_object = NULL; | 1353 MaybeObject* maybe_object = NULL; |
1349 Handle<Code> stub = generic_stub(); | 1354 Handle<Code> stub = generic_stub(); |
1350 | 1355 |
1351 // Check for values that can be converted into an internalized string directly | 1356 // Check for values that can be converted into an internalized string directly |
1352 // or is representable as a smi. | 1357 // or is representable as a smi. |
1353 key = TryConvertKey(key, isolate()); | 1358 key = TryConvertKey(key, isolate()); |
1354 | 1359 |
1355 if (key->IsInternalizedString()) { | 1360 if (key->IsInternalizedString()) { |
1356 maybe_object = LoadIC::Load(object, Handle<String>::cast(key)); | 1361 maybe_object = LoadIC::Load(object, Handle<String>::cast(key)); |
1357 if (maybe_object->IsFailure()) return maybe_object; | 1362 if (maybe_object->IsFailure()) return maybe_object; |
1358 } else if (FLAG_use_ic && !object->IsAccessCheckNeeded()) { | 1363 } else if (FLAG_use_ic && !object->IsAccessCheckNeeded()) { |
1359 ASSERT(!object->IsJSGlobalProxy()); | 1364 ASSERT(!object->IsJSGlobalProxy()); |
1360 if (miss_mode != MISS_FORCE_GENERIC) { | 1365 if (object->IsString() && key->IsNumber()) { |
1361 if (object->IsString() && key->IsNumber()) { | 1366 if (state() == UNINITIALIZED) stub = string_stub(); |
1362 if (state() == UNINITIALIZED) stub = string_stub(); | 1367 } else if (object->IsJSObject()) { |
1363 } else if (object->IsJSObject()) { | 1368 Handle<JSObject> receiver = Handle<JSObject>::cast(object); |
1364 Handle<JSObject> receiver = Handle<JSObject>::cast(object); | 1369 if (receiver->elements()->map() == |
1365 if (receiver->elements()->map() == | 1370 isolate()->heap()->non_strict_arguments_elements_map()) { |
1366 isolate()->heap()->non_strict_arguments_elements_map()) { | 1371 stub = non_strict_arguments_stub(); |
1367 stub = non_strict_arguments_stub(); | 1372 } else if (receiver->HasIndexedInterceptor()) { |
1368 } else if (receiver->HasIndexedInterceptor()) { | 1373 stub = indexed_interceptor_stub(); |
1369 stub = indexed_interceptor_stub(); | 1374 } else if (!key->ToSmi()->IsFailure() && |
1370 } else if (!key->ToSmi()->IsFailure() && | 1375 (!target().is_identical_to(non_strict_arguments_stub()))) { |
1371 (!target().is_identical_to(non_strict_arguments_stub()))) { | 1376 stub = LoadElementStub(receiver); |
1372 stub = LoadElementStub(receiver); | |
1373 } | |
1374 } | 1377 } |
1375 } | 1378 } |
1376 } | 1379 } |
1377 | 1380 |
1378 if (!is_target_set()) { | 1381 if (!is_target_set()) { |
1379 if (*stub == *generic_stub()) { | 1382 if (*stub == *generic_stub()) { |
1380 TRACE_GENERIC_IC(isolate(), "KeyedLoadIC", "set generic"); | 1383 TRACE_GENERIC_IC(isolate(), "KeyedLoadIC", "set generic"); |
1381 } | 1384 } |
1382 ASSERT(!stub.is_null()); | 1385 ASSERT(!stub.is_null()); |
1383 set_target(*stub); | 1386 set_target(*stub); |
(...skipping 524 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1908 Heap* heap = receiver->GetHeap(); | 1911 Heap* heap = receiver->GetHeap(); |
1909 if (receiver->elements()->map() == heap->fixed_cow_array_map()) { | 1912 if (receiver->elements()->map() == heap->fixed_cow_array_map()) { |
1910 return STORE_NO_TRANSITION_HANDLE_COW; | 1913 return STORE_NO_TRANSITION_HANDLE_COW; |
1911 } else { | 1914 } else { |
1912 return STANDARD_STORE; | 1915 return STANDARD_STORE; |
1913 } | 1916 } |
1914 } | 1917 } |
1915 } | 1918 } |
1916 | 1919 |
1917 | 1920 |
| 1921 MaybeObject* KeyedStoreIC::StoreForceGeneric(Handle<Object> object, |
| 1922 Handle<Object> key, |
| 1923 Handle<Object> value) { |
| 1924 set_target(*generic_stub()); |
| 1925 Handle<Object> result = Runtime::SetObjectProperty(isolate(), object, |
| 1926 key, |
| 1927 value, |
| 1928 NONE, |
| 1929 strict_mode()); |
| 1930 RETURN_IF_EMPTY_HANDLE(isolate(), result); |
| 1931 return *result; |
| 1932 } |
| 1933 |
| 1934 |
1918 MaybeObject* KeyedStoreIC::Store(Handle<Object> object, | 1935 MaybeObject* KeyedStoreIC::Store(Handle<Object> object, |
1919 Handle<Object> key, | 1936 Handle<Object> key, |
1920 Handle<Object> value, | 1937 Handle<Object> value) { |
1921 ICMissMode miss_mode) { | |
1922 if (MigrateDeprecated(object)) { | 1938 if (MigrateDeprecated(object)) { |
1923 Handle<Object> result = Runtime::SetObjectProperty(isolate(), object, | 1939 Handle<Object> result = Runtime::SetObjectProperty(isolate(), object, |
1924 key, | 1940 key, |
1925 value, | 1941 value, |
1926 NONE, | 1942 NONE, |
1927 strict_mode()); | 1943 strict_mode()); |
1928 RETURN_IF_EMPTY_HANDLE(isolate(), result); | 1944 RETURN_IF_EMPTY_HANDLE(isolate(), result); |
1929 return *result; | 1945 return *result; |
1930 } | 1946 } |
1931 | 1947 |
(...skipping 18 matching lines...) Expand all Loading... |
1950 // Don't use ICs for maps of the objects in Array's prototype chain. We | 1966 // Don't use ICs for maps of the objects in Array's prototype chain. We |
1951 // expect to be able to trap element sets to objects with those maps in | 1967 // expect to be able to trap element sets to objects with those maps in |
1952 // the runtime to enable optimization of element hole access. | 1968 // the runtime to enable optimization of element hole access. |
1953 Handle<HeapObject> heap_object = Handle<HeapObject>::cast(object); | 1969 Handle<HeapObject> heap_object = Handle<HeapObject>::cast(object); |
1954 if (heap_object->map()->IsMapInArrayPrototypeChain()) use_ic = false; | 1970 if (heap_object->map()->IsMapInArrayPrototypeChain()) use_ic = false; |
1955 } | 1971 } |
1956 | 1972 |
1957 if (use_ic) { | 1973 if (use_ic) { |
1958 ASSERT(!object->IsJSGlobalProxy()); | 1974 ASSERT(!object->IsJSGlobalProxy()); |
1959 | 1975 |
1960 if (miss_mode != MISS_FORCE_GENERIC) { | 1976 if (object->IsJSObject()) { |
1961 if (object->IsJSObject()) { | 1977 Handle<JSObject> receiver = Handle<JSObject>::cast(object); |
1962 Handle<JSObject> receiver = Handle<JSObject>::cast(object); | 1978 bool key_is_smi_like = key->IsSmi() || !key->ToSmi()->IsFailure(); |
1963 bool key_is_smi_like = key->IsSmi() || !key->ToSmi()->IsFailure(); | 1979 if (receiver->elements()->map() == |
1964 if (receiver->elements()->map() == | 1980 isolate()->heap()->non_strict_arguments_elements_map()) { |
1965 isolate()->heap()->non_strict_arguments_elements_map()) { | 1981 stub = non_strict_arguments_stub(); |
1966 stub = non_strict_arguments_stub(); | 1982 } else if (key_is_smi_like && |
1967 } else if (key_is_smi_like && | 1983 !(target().is_identical_to(non_strict_arguments_stub()))) { |
1968 !(target().is_identical_to(non_strict_arguments_stub()))) { | 1984 // We should go generic if receiver isn't a dictionary, but our |
1969 // We should go generic if receiver isn't a dictionary, but our | 1985 // prototype chain does have dictionary elements. This ensures that |
1970 // prototype chain does have dictionary elements. This ensures that | 1986 // other non-dictionary receivers in the polymorphic case benefit |
1971 // other non-dictionary receivers in the polymorphic case benefit | 1987 // from fast path keyed stores. |
1972 // from fast path keyed stores. | 1988 if (!(receiver->map()->DictionaryElementsInPrototypeChainOnly())) { |
1973 if (!(receiver->map()->DictionaryElementsInPrototypeChainOnly())) { | 1989 KeyedAccessStoreMode store_mode = |
1974 KeyedAccessStoreMode store_mode = | 1990 GetStoreMode(receiver, key, value); |
1975 GetStoreMode(receiver, key, value); | 1991 stub = StoreElementStub(receiver, store_mode); |
1976 stub = StoreElementStub(receiver, store_mode); | |
1977 } | |
1978 } | 1992 } |
1979 } | 1993 } |
1980 } | 1994 } |
1981 } | 1995 } |
1982 } | 1996 } |
1983 | 1997 |
1984 if (!is_target_set()) { | 1998 if (!is_target_set()) { |
1985 if (*stub == *generic_stub()) { | 1999 if (*stub == *generic_stub()) { |
1986 TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "set generic"); | 2000 TRACE_GENERIC_IC(isolate(), "KeyedStoreIC", "set generic"); |
1987 } | 2001 } |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2066 | 2080 |
2067 | 2081 |
2068 // Used from ic-<arch>.cc | 2082 // Used from ic-<arch>.cc |
2069 RUNTIME_FUNCTION(MaybeObject*, KeyedLoadIC_Miss) { | 2083 RUNTIME_FUNCTION(MaybeObject*, KeyedLoadIC_Miss) { |
2070 HandleScope scope(isolate); | 2084 HandleScope scope(isolate); |
2071 ASSERT(args.length() == 2); | 2085 ASSERT(args.length() == 2); |
2072 KeyedLoadIC ic(IC::NO_EXTRA_FRAME, isolate); | 2086 KeyedLoadIC ic(IC::NO_EXTRA_FRAME, isolate); |
2073 Handle<Object> receiver = args.at<Object>(0); | 2087 Handle<Object> receiver = args.at<Object>(0); |
2074 Handle<Object> key = args.at<Object>(1); | 2088 Handle<Object> key = args.at<Object>(1); |
2075 ic.UpdateState(receiver, key); | 2089 ic.UpdateState(receiver, key); |
2076 return ic.Load(receiver, key, MISS); | 2090 return ic.Load(receiver, key); |
2077 } | 2091 } |
2078 | 2092 |
2079 | 2093 |
2080 RUNTIME_FUNCTION(MaybeObject*, KeyedLoadIC_MissFromStubFailure) { | 2094 RUNTIME_FUNCTION(MaybeObject*, KeyedLoadIC_MissFromStubFailure) { |
2081 HandleScope scope(isolate); | 2095 HandleScope scope(isolate); |
2082 ASSERT(args.length() == 2); | 2096 ASSERT(args.length() == 2); |
2083 KeyedLoadIC ic(IC::EXTRA_CALL_FRAME, isolate); | 2097 KeyedLoadIC ic(IC::EXTRA_CALL_FRAME, isolate); |
2084 Handle<Object> receiver = args.at<Object>(0); | 2098 Handle<Object> receiver = args.at<Object>(0); |
2085 Handle<Object> key = args.at<Object>(1); | 2099 Handle<Object> key = args.at<Object>(1); |
2086 ic.UpdateState(receiver, key); | 2100 ic.UpdateState(receiver, key); |
2087 return ic.Load(receiver, key, MISS); | 2101 return ic.Load(receiver, key); |
2088 } | 2102 } |
2089 | 2103 |
2090 | 2104 |
2091 RUNTIME_FUNCTION(MaybeObject*, KeyedLoadIC_MissForceGeneric) { | 2105 RUNTIME_FUNCTION(MaybeObject*, KeyedLoadIC_MissForceGeneric) { |
2092 HandleScope scope(isolate); | 2106 HandleScope scope(isolate); |
2093 ASSERT(args.length() == 2); | 2107 ASSERT(args.length() == 2); |
2094 KeyedLoadIC ic(IC::NO_EXTRA_FRAME, isolate); | 2108 KeyedLoadIC ic(IC::NO_EXTRA_FRAME, isolate); |
2095 Handle<Object> receiver = args.at<Object>(0); | 2109 Handle<Object> receiver = args.at<Object>(0); |
2096 Handle<Object> key = args.at<Object>(1); | 2110 Handle<Object> key = args.at<Object>(1); |
2097 ic.UpdateState(receiver, key); | 2111 ic.UpdateState(receiver, key); |
2098 return ic.Load(receiver, key, MISS_FORCE_GENERIC); | 2112 return ic.LoadForceGeneric(receiver, key); |
2099 } | 2113 } |
2100 | 2114 |
2101 | 2115 |
2102 // Used from ic-<arch>.cc. | 2116 // Used from ic-<arch>.cc. |
2103 RUNTIME_FUNCTION(MaybeObject*, StoreIC_Miss) { | 2117 RUNTIME_FUNCTION(MaybeObject*, StoreIC_Miss) { |
2104 HandleScope scope(isolate); | 2118 HandleScope scope(isolate); |
2105 ASSERT(args.length() == 3); | 2119 ASSERT(args.length() == 3); |
2106 StoreIC ic(IC::NO_EXTRA_FRAME, isolate); | 2120 StoreIC ic(IC::NO_EXTRA_FRAME, isolate); |
2107 Handle<Object> receiver = args.at<Object>(0); | 2121 Handle<Object> receiver = args.at<Object>(0); |
2108 Handle<String> key = args.at<String>(1); | 2122 Handle<String> key = args.at<String>(1); |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2197 | 2211 |
2198 | 2212 |
2199 // Used from ic-<arch>.cc. | 2213 // Used from ic-<arch>.cc. |
2200 RUNTIME_FUNCTION(MaybeObject*, KeyedStoreIC_Miss) { | 2214 RUNTIME_FUNCTION(MaybeObject*, KeyedStoreIC_Miss) { |
2201 HandleScope scope(isolate); | 2215 HandleScope scope(isolate); |
2202 ASSERT(args.length() == 3); | 2216 ASSERT(args.length() == 3); |
2203 KeyedStoreIC ic(IC::NO_EXTRA_FRAME, isolate); | 2217 KeyedStoreIC ic(IC::NO_EXTRA_FRAME, isolate); |
2204 Handle<Object> receiver = args.at<Object>(0); | 2218 Handle<Object> receiver = args.at<Object>(0); |
2205 Handle<Object> key = args.at<Object>(1); | 2219 Handle<Object> key = args.at<Object>(1); |
2206 ic.UpdateState(receiver, key); | 2220 ic.UpdateState(receiver, key); |
2207 return ic.Store(receiver, key, args.at<Object>(2), MISS); | 2221 return ic.Store(receiver, key, args.at<Object>(2)); |
2208 } | 2222 } |
2209 | 2223 |
2210 | 2224 |
2211 RUNTIME_FUNCTION(MaybeObject*, KeyedStoreIC_MissFromStubFailure) { | 2225 RUNTIME_FUNCTION(MaybeObject*, KeyedStoreIC_MissFromStubFailure) { |
2212 HandleScope scope(isolate); | 2226 HandleScope scope(isolate); |
2213 ASSERT(args.length() == 3); | 2227 ASSERT(args.length() == 3); |
2214 KeyedStoreIC ic(IC::EXTRA_CALL_FRAME, isolate); | 2228 KeyedStoreIC ic(IC::EXTRA_CALL_FRAME, isolate); |
2215 Handle<Object> receiver = args.at<Object>(0); | 2229 Handle<Object> receiver = args.at<Object>(0); |
2216 Handle<Object> key = args.at<Object>(1); | 2230 Handle<Object> key = args.at<Object>(1); |
2217 ic.UpdateState(receiver, key); | 2231 ic.UpdateState(receiver, key); |
2218 return ic.Store(receiver, key, args.at<Object>(2), MISS); | 2232 return ic.Store(receiver, key, args.at<Object>(2)); |
2219 } | 2233 } |
2220 | 2234 |
2221 | 2235 |
2222 RUNTIME_FUNCTION(MaybeObject*, StoreIC_Slow) { | 2236 RUNTIME_FUNCTION(MaybeObject*, StoreIC_Slow) { |
2223 HandleScope scope(isolate); | 2237 HandleScope scope(isolate); |
2224 ASSERT(args.length() == 3); | 2238 ASSERT(args.length() == 3); |
2225 StoreIC ic(IC::NO_EXTRA_FRAME, isolate); | 2239 StoreIC ic(IC::NO_EXTRA_FRAME, isolate); |
2226 Handle<Object> object = args.at<Object>(0); | 2240 Handle<Object> object = args.at<Object>(0); |
2227 Handle<Object> key = args.at<Object>(1); | 2241 Handle<Object> key = args.at<Object>(1); |
2228 Handle<Object> value = args.at<Object>(2); | 2242 Handle<Object> value = args.at<Object>(2); |
(...skipping 24 matching lines...) Expand all Loading... |
2253 } | 2267 } |
2254 | 2268 |
2255 | 2269 |
2256 RUNTIME_FUNCTION(MaybeObject*, KeyedStoreIC_MissForceGeneric) { | 2270 RUNTIME_FUNCTION(MaybeObject*, KeyedStoreIC_MissForceGeneric) { |
2257 HandleScope scope(isolate); | 2271 HandleScope scope(isolate); |
2258 ASSERT(args.length() == 3); | 2272 ASSERT(args.length() == 3); |
2259 KeyedStoreIC ic(IC::NO_EXTRA_FRAME, isolate); | 2273 KeyedStoreIC ic(IC::NO_EXTRA_FRAME, isolate); |
2260 Handle<Object> receiver = args.at<Object>(0); | 2274 Handle<Object> receiver = args.at<Object>(0); |
2261 Handle<Object> key = args.at<Object>(1); | 2275 Handle<Object> key = args.at<Object>(1); |
2262 ic.UpdateState(receiver, key); | 2276 ic.UpdateState(receiver, key); |
2263 return ic.Store(receiver, key, args.at<Object>(2), MISS_FORCE_GENERIC); | 2277 return ic.StoreForceGeneric(receiver, key, args.at<Object>(2)); |
2264 } | 2278 } |
2265 | 2279 |
2266 | 2280 |
2267 RUNTIME_FUNCTION(MaybeObject*, ElementsTransitionAndStoreIC_Miss) { | 2281 RUNTIME_FUNCTION(MaybeObject*, ElementsTransitionAndStoreIC_Miss) { |
2268 HandleScope scope(isolate); | 2282 HandleScope scope(isolate); |
2269 ASSERT(args.length() == 4); | 2283 ASSERT(args.length() == 4); |
2270 KeyedStoreIC ic(IC::EXTRA_CALL_FRAME, isolate); | 2284 KeyedStoreIC ic(IC::EXTRA_CALL_FRAME, isolate); |
2271 Handle<Object> value = args.at<Object>(0); | 2285 Handle<Object> value = args.at<Object>(0); |
2272 Handle<Map> map = args.at<Map>(1); | 2286 Handle<Map> map = args.at<Map>(1); |
2273 Handle<Object> key = args.at<Object>(2); | 2287 Handle<Object> key = args.at<Object>(2); |
(...skipping 456 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2730 #undef ADDR | 2744 #undef ADDR |
2731 }; | 2745 }; |
2732 | 2746 |
2733 | 2747 |
2734 Address IC::AddressFromUtilityId(IC::UtilityId id) { | 2748 Address IC::AddressFromUtilityId(IC::UtilityId id) { |
2735 return IC_utilities[id]; | 2749 return IC_utilities[id]; |
2736 } | 2750 } |
2737 | 2751 |
2738 | 2752 |
2739 } } // namespace v8::internal | 2753 } } // namespace v8::internal |
OLD | NEW |