Lines Matching refs:Handle
90 void IC::TraceIC(const char* type, Handle<Object> name) {
100 void IC::TraceIC(const char* type, Handle<Object> name, State old_state,
183 target_ = handle(raw_target(), isolate);
212 Handle<SharedFunctionInfo> shared(GetSharedFunctionInfo(), isolate());
235 Handle<JSObject> holder = it->GetHolder<JSObject>();
257 bool IC::TryRemoveInvalidPrototypeDependentStub(Handle<Object> receiver,
258 Handle<String> name) {
275 Handle<Map> old_map(first_map);
282 Handle<Map> ic_holder_map(GetICCacheHolder(receiver_map(), isolate(), &flag));
296 Handle<JSGlobalObject> global = Handle<JSGlobalObject>::cast(receiver);
307 bool IC::IsNameCompatibleWithPrototypeFailure(Handle<Object> name) {
320 void IC::UpdateState(Handle<Object> receiver, Handle<Object> name) {
330 Handle<String>::cast(name))) {
338 Handle<Object> object, Handle<Object> key) {
344 MaybeHandle<Object> IC::ReferenceError(Handle<Name> name) {
528 Handle<Code> code = pre_monomorphic_stub(
556 Handle<Code> KeyedLoadIC::ChooseMegamorphicStub(Isolate* isolate,
568 static bool MigrateDeprecated(Handle<Object> object) {
570 Handle<JSObject> receiver = Handle<JSObject>::cast(object);
572 JSObject::MigrateInstance(Handle<JSObject>::cast(object));
592 void IC::ConfigureVectorState(Handle<Name> name, Handle<Map> map,
593 Handle<Code> handler) {
615 void IC::ConfigureVectorState(Handle<Name> name, MapHandleList* maps,
651 MaybeHandle<Object> LoadIC::Load(Handle<Object> object, Handle<Name> name) {
669 Handle<Object> result;
680 Handle<String> str_name = Handle<String>::cast(name);
681 Handle<JSGlobalObject> global = Handle<JSGlobalObject>::cast(object);
682 Handle<ScriptContextTable> script_contexts(
687 Handle<Object> result =
714 Handle<Object> result;
730 Handle<Map> new_receiver_map) {
743 bool IC::UpdatePolymorphicIC(Handle<Name> name, Handle<Code> code) {
746 Handle<Map> map = receiver_map();
756 Handle<Map> current_map = maps.at(i);
786 Handle<Code> ic;
808 void IC::UpdateMonomorphicIC(Handle<Code> handler, Handle<Name> name) {
814 void IC::CopyICToMegamorphicCache(Handle<Name> name) {
840 void IC::PatchCache(Handle<Name> name, Handle<Code> code) {
879 Handle<Code> LoadIC::initialize_stub(Isolate* isolate,
885 Handle<Code> LoadIC::initialize_stub_in_optimized_code(
891 Handle<Code> KeyedLoadIC::initialize_stub(Isolate* isolate,
897 Handle<Code> KeyedLoadIC::initialize_stub_in_optimized_code(
908 static Handle<Code> KeyedStoreICInitializeStubHelper(
927 return Handle<Code>();
931 Handle<Code> KeyedStoreIC::initialize_stub(Isolate* isolate,
944 Handle<Code> KeyedStoreIC::initialize_stub_in_optimized_code(
956 Handle<Code> KeyedStoreIC::ChooseMegamorphicStub(Isolate* isolate,
963 Handle<Code> LoadIC::megamorphic_stub() {
969 Handle<Code> LoadIC::SimpleFieldLoad(FieldIndex index) {
975 bool IsCompatibleReceiver(LookupIterator* lookup, Handle<Map> receiver_map) {
978 Handle<Object> accessors = lookup->GetAccessors();
980 Handle<ExecutableAccessorInfo> info =
981 Handle<ExecutableAccessorInfo>::cast(accessors);
988 Handle<Object> getter(Handle<AccessorPair>::cast(accessors)->getter(),
990 Handle<JSObject> holder = lookup->GetHolder<JSObject>();
991 Handle<Object> receiver = lookup->GetReceiver();
993 Handle<JSFunction> function = Handle<JSFunction>::cast(getter);
1017 Handle<Code> code;
1061 Handle<Code> IC::ComputeHandler(LookupIterator* lookup, Handle<Object> value) {
1065 Handle<Map> stub_holder_map = IC::GetHandlerCacheHolder(
1068 Handle<Code> code = PropertyHandlerCompiler::Find(
1083 Map* map = Handle<HeapObject>::cast(lookup->GetReceiver())->map();
1111 Handle<Code> LoadIC::CompileHandler(LookupIterator* lookup,
1112 Handle<Object> unused,
1114 Handle<Object> receiver = lookup->GetReceiver();
1131 !Handle<JSFunction>::cast(receiver)
1134 Handle<Code> stub;
1139 Handle<Map> map = receiver_map();
1140 Handle<JSObject> holder = lookup->GetHolder<JSObject>();
1171 Handle<Object> accessors = lookup->GetAccessors();
1173 Handle<ExecutableAccessorInfo> info =
1174 Handle<ExecutableAccessorInfo>::cast(accessors);
1187 Handle<Object> getter(Handle<AccessorPair>::cast(accessors)->getter(),
1193 Handle<JSFunction> function = Handle<JSFunction>::cast(getter);
1225 Handle<PropertyCell> cell = lookup->GetPropertyCell();
1226 Handle<Code> code = compiler.CompileLoadGlobal(
1230 Handle<Map> stub_holder_map =
1279 static Handle<Object> TryConvertKey(Handle<Object> key, Isolate* isolate) {
1283 double value = Handle<HeapNumber>::cast(key)->value();
1289 key = handle(Smi::FromInt(int_value), isolate);
1299 Handle<Code> KeyedLoadIC::LoadElementStub(Handle<HeapObject> receiver) {
1300 Handle<Code> null_handle;
1301 Handle<Map> receiver_map(receiver->map(), isolate());
1307 Handle<Code> handler =
1310 ConfigureVectorState(Handle<Name>::null(), receiver_map, handler);
1324 Handle<JSObject>::cast(receiver)->GetElementsKind())) {
1325 Handle<Code> handler =
1328 ConfigureVectorState(Handle<Name>::null(), receiver_map, handler);
1354 ConfigureVectorState(Handle<Name>::null(), &target_receiver_maps, &handlers);
1359 MaybeHandle<Object> KeyedLoadIC::Load(Handle<Object> object,
1360 Handle<Object> key) {
1362 Handle<Object> result;
1370 Handle<Object> load_handle;
1371 Handle<Code> stub = megamorphic_stub();
1379 LoadIC::Load(object, Handle<Name>::cast(key)),
1383 Handle<HeapObject> receiver = Handle<HeapObject>::cast(object);
1401 Handle<Object> result;
1410 bool StoreIC::LookupForWrite(LookupIterator* it, Handle<Object> value,
1413 Handle<Object> receiver = it->GetReceiver();
1415 DCHECK(!Handle<JSObject>::cast(receiver)->map()->is_deprecated());
1425 Handle<JSObject> holder = it->GetHolder<JSObject>();
1444 Handle<JSObject> holder = it->GetHolder<JSObject>();
1473 MaybeHandle<Object> StoreIC::Store(Handle<Object> object, Handle<Name> name,
1474 Handle<Object> value,
1489 Handle<Object> result;
1499 Handle<String> str_name = Handle<String>::cast(name);
1500 Handle<JSGlobalObject> global = Handle<JSGlobalObject>::cast(object);
1501 Handle<ScriptContextTable> script_contexts(
1506 Handle<Context> script_context = ScriptContextTable::GetContext(
1512 Handle<Object> previous_value =
1535 Handle<Object> result;
1550 Handle<HeapObject>::cast(object)->map()->is_observed()) {
1551 Handle<Object> result;
1568 Handle<Code> CallIC::initialize_stub(Isolate* isolate, int argc,
1571 Handle<Code> code = stub.GetCode();
1576 Handle<Code> CallIC::initialize_stub_in_optimized_code(
1579 Handle<Code> code = stub.GetCode();
1584 static Handle<Code> StoreICInitializeStubHelper(
1587 Handle<Code> ic = PropertyICCompiler::ComputeStore(
1593 Handle<Code> StoreIC::initialize_stub(Isolate* isolate,
1604 Handle<Code> StoreIC::initialize_stub_in_optimized_code(
1619 Handle<Code> StoreIC::megamorphic_stub() {
1634 Handle<Code> StoreIC::slow_stub() const {
1644 Handle<Code> StoreIC::pre_monomorphic_stub(Isolate* isolate,
1651 void StoreIC::UpdateCaches(LookupIterator* lookup, Handle<Object> value,
1665 Handle<Code> code = use_ic ? ComputeHandler(lookup, value) : slow_stub();
1672 static Handle<Code> PropertyCellStoreHandler(
1673 Isolate* isolate, Handle<JSObject> receiver, Handle<JSGlobalObject> holder,
1674 Handle<Name> name, Handle<PropertyCell> cell, PropertyCellType type) {
1688 Handle<Code> StoreIC::CompileHandler(LookupIterator* lookup,
1689 Handle<Object> value,
1694 Handle<JSObject> receiver = Handle<JSObject>::cast(lookup->GetReceiver());
1695 Handle<JSObject> holder = lookup->GetHolder<JSObject>();
1707 isolate(), store_target, Handle<JSGlobalObject>::cast(store_target),
1712 Handle<Map> transition = lookup->transition_map();
1735 Handle<Object> accessors = lookup->GetAccessors();
1737 Handle<ExecutableAccessorInfo> info =
1738 Handle<ExecutableAccessorInfo>::cast(accessors);
1757 Handle<Object> setter(Handle<AccessorPair>::cast(accessors)->setter(),
1763 Handle<JSFunction> function = Handle<JSFunction>::cast(setter);
1790 isolate(), receiver, Handle<JSGlobalObject>::cast(holder),
1803 Handle<HeapType> field_type = lookup->GetFieldType();
1832 Handle<Code> KeyedStoreIC::StoreElementStub(Handle<Map> receiver_map,
1834 Handle<Code> null_handle;
1835 // Don't handle megamorphic property accesses for INTERCEPTORS or
1847 Handle<Map> monomorphic_map =
1850 Handle<Code> handler =
1853 ConfigureVectorState(Handle<Name>::null(), monomorphic_map, handler);
1859 // superset of the original IC. Handle those here if the receiver map hasn't
1862 Handle<Map> previous_receiver_map = target_receiver_maps.at(0);
1864 Handle<Map> transitioned_receiver_map = receiver_map;
1877 Handle<Code> handler =
1880 ConfigureVectorState(Handle<Name>::null(), transitioned_receiver_map,
1889 // grow at the end of the array, handle OOB accesses or copy COW arrays
1891 Handle<Code> handler =
1894 ConfigureVectorState(Handle<Name>::null(), receiver_map, handler);
1905 Handle<Map> transitioned_receiver_map =
1913 // won't help, use the megamorphic stub which can handle everything.
1964 Handle<Map> KeyedStoreIC::ComputeTransitionedMap(
1965 Handle<Map> map, KeyedAccessStoreMode store_mode) {
1994 bool IsOutOfBoundsAccess(Handle<JSObject> receiver, uint32_t index) {
2005 static KeyedAccessStoreMode GetStoreMode(Handle<JSObject> receiver,
2006 uint32_t index, Handle<Object> value) {
2013 // Handle growing array in stub if necessary.
2028 // Handle only in-bounds elements accesses.
2054 MaybeHandle<Object> KeyedStoreIC::Store(Handle<Object> object,
2055 Handle<Object> key,
2056 Handle<Object> value) {
2060 Handle<Object> result;
2072 Handle<Object> store_handle;
2073 Handle<Code> stub = megamorphic_stub();
2081 StoreIC::Store(object, Handle<Name>::cast(key), value,
2101 Handle<HeapObject> heap_object = Handle<HeapObject>::cast(object);
2108 Handle<Map> old_receiver_map;
2113 Handle<JSObject> receiver = Handle<JSObject>::cast(object);
2114 old_receiver_map = handle(receiver->map(), isolate());
2171 void CallIC::HandleMiss(Handle<Object> function) {
2172 Handle<Object> name = isolate()->factory()->empty_string();
2185 Handle<JSFunction> js_function = Handle<JSFunction>::cast(function);
2187 Handle<JSFunction> array_function =
2188 Handle<JSFunction>(isolate()->native_context()->array_function());
2204 Handle<JSFunction> js_function = Handle<JSFunction>::cast(function);
2205 name = handle(js_function->shared()->name(), isolate());
2225 Handle<Object> function = args.at<Object>(0);
2226 Handle<TypeFeedbackVector> vector = args.at<TypeFeedbackVector>(1);
2227 Handle<Smi> slot = args.at<Smi>(2);
2240 Handle<Object> receiver = args.at<Object>(0);
2241 Handle<Name> key = args.at<Name>(1);
2242 Handle<Object> result;
2245 Handle<Smi> slot = args.at<Smi>(2);
2246 Handle<TypeFeedbackVector> vector = args.at<TypeFeedbackVector>(3);
2250 // set up outside the IC, handle that here.
2272 Handle<Object> receiver = args.at<Object>(0);
2273 Handle<Object> key = args.at<Object>(1);
2274 Handle<Object> result;
2277 Handle<Smi> slot = args.at<Smi>(2);
2278 Handle<TypeFeedbackVector> vector = args.at<TypeFeedbackVector>(3);
2291 Handle<Object> receiver = args.at<Object>(0);
2292 Handle<Object> key = args.at<Object>(1);
2293 Handle<Object> result;
2296 Handle<Smi> slot = args.at<Smi>(2);
2297 Handle<TypeFeedbackVector> vector = args.at<TypeFeedbackVector>(3);
2312 Handle<Object> receiver = args.at<Object>(0);
2313 Handle<Name> key = args.at<Name>(1);
2314 Handle<Object> value = args.at<Object>(2);
2315 Handle<Object> result;
2318 Handle<Smi> slot = args.at<Smi>(3);
2319 Handle<TypeFeedbackVector> vector = args.at<TypeFeedbackVector>(4);
2343 Handle<Object> receiver = args.at<Object>(0);
2344 Handle<Name> key = args.at<Name>(1);
2345 Handle<Object> value = args.at<Object>(2);
2346 Handle<Object> result;
2354 Handle<Smi> slot;
2355 Handle<TypeFeedbackVector> vector;
2359 slot = handle(
2395 Handle<Object> receiver = args.at<Object>(0);
2396 Handle<Object> key = args.at<Object>(1);
2397 Handle<Object> value = args.at<Object>(2);
2398 Handle<Object> result;
2401 Handle<Smi> slot = args.at<Smi>(3);
2402 Handle<TypeFeedbackVector> vector = args.at<TypeFeedbackVector>(4);
2416 Handle<Object> receiver = args.at<Object>(0);
2417 Handle<Object> key = args.at<Object>(1);
2418 Handle<Object> value = args.at<Object>(2);
2419 Handle<Object> result;
2422 Handle<Smi> slot = args.at<Smi>(3);
2423 Handle<TypeFeedbackVector> vector = args.at<TypeFeedbackVector>(4);
2437 Handle<Object> object = args.at<Object>(0);
2438 Handle<Object> key = args.at<Object>(1);
2439 Handle<Object> value = args.at<Object>(2);
2444 Handle<Object> result;
2455 Handle<Object> object = args.at<Object>(0);
2456 Handle<Object> key = args.at<Object>(1);
2457 Handle<Object> value = args.at<Object>(2);
2462 Handle<Object> result;
2476 Handle<Object> object = args.at<Object>(0);
2477 Handle<Object> key = args.at<Object>(1);
2478 Handle<Object> value = args.at<Object>(2);
2479 Handle<Map> map = args.at<Map>(3);
2485 JSObject::TransitionElementsKind(Handle<JSObject>::cast(object),
2488 Handle<Object> result;
2497 Handle<AllocationSite> allocation_site, Handle<Object> left,
2498 Handle<Object> right) {
2502 Handle<Object> result;
2580 Handle<Code> target;
2629 Handle<Object> left = args.at<Object>(BinaryOpICStub::kLeft);
2630 Handle<Object> right = args.at<Object>(BinaryOpICStub::kRight);
2632 Handle<Object> result;
2635 ic.Transition(Handle<AllocationSite>::null(), left, right));
2644 Handle<AllocationSite> allocation_site =
2646 Handle<Object> left = args.at<Object>(BinaryOpWithAllocationSiteStub::kLeft);
2647 Handle<Object> right =
2650 Handle<Object> result;
2668 Handle<Code> CompareIC::GetUninitialized(Isolate* isolate, Token::Value op,
2677 Code* CompareIC::UpdateCaches(Handle<Object> x, Handle<Object> y) {
2691 Handle<Map>(Handle<JSReceiver>::cast(x)->map(), isolate()));
2693 Handle<Code> new_target = stub.GetCode();
2743 Handle<Object> CompareNilIC::DoCompareNilSlow(Isolate* isolate, NilValue nil,
2744 Handle<Object> object) {
2752 Handle<Object> CompareNilIC::CompareNil(Handle<Object> object) {
2766 Handle<Code> code;
2768 Handle<Map> monomorphic_map(already_monomorphic && FirstTargetMap() != NULL
2783 Handle<Object> object = args.at<Object>(0);
2796 Handle<Object> ToBooleanIC::ToBoolean(Handle<Object> object) {
2799 Handle<Code> code = stub.GetCode();
2809 Handle<Object> object = args.at<Object>(0);
2816 Handle<JSObject> receiver = args.at<JSObject>(0);
2817 Handle<JSObject> holder = args.at<JSObject>(1);
2818 Handle<HeapObject> callback_or_cell = args.at<HeapObject>(2);
2819 Handle<Name> name = args.at<Name>(3);
2820 Handle<Object> value = args.at<Object>(4);
2823 Handle<ExecutableAccessorInfo> callback(
2854 Handle<Name> name =
2856 Handle<JSObject> receiver =
2858 Handle<JSObject> holder =
2863 Handle<Object> result;
2878 Handle<Name> name =
2880 Handle<JSObject> receiver =
2882 Handle<JSObject> holder =
2885 Handle<Object> result;
2912 Handle<JSObject> receiver = args.at<JSObject>(0);
2913 Handle<Name> name = args.at<Name>(1);
2914 Handle<Object> value = args.at<Object>(2);
2920 Handle<Object> current = PrototypeIterator::GetCurrent(iter);
2922 Handle<JSObject>::cast(current)->HasNamedInterceptor()) {
2929 Handle<Object> result;
2940 Handle<JSObject> receiver = args.at<JSObject>(0);
2943 Handle<Object> result;
2956 Handle<Object> receiver = args.at<Object>(0);
2957 Handle<Name> key = args.at<Name>(1);
2958 Handle<Object> result;
2961 Handle<Smi> slot = args.at<Smi>(2);
2962 Handle<TypeFeedbackVector> vector = args.at<TypeFeedbackVector>(3);
2966 // set up outside the IC, handle that here.
