Lines Matching refs:Handle
74 Handle<HeapType> Object::OptimalType(Isolate* isolate,
80 Handle<Map> map(HeapObject::cast(this)->map(), isolate);
91 Handle<Object> object,
92 Handle<Context> native_context) {
93 if (object->IsJSReceiver()) return Handle<JSReceiver>::cast(object);
94 Handle<JSFunction> constructor;
96 constructor = handle(native_context->number_function(), isolate);
99 Handle<HeapObject>::cast(object)->map()->GetConstructorFunctionIndex();
103 constructor = handle(
107 Handle<JSObject> result = isolate->factory()->NewJSObject(constructor);
108 Handle<JSValue>::cast(result)->set_value(*object);
114 MaybeHandle<Name> Object::ToName(Isolate* isolate, Handle<Object> input) {
118 if (input->IsName()) return Handle<Name>::cast(input);
124 MaybeHandle<Object> Object::ToNumber(Handle<Object> input) {
130 return String::ToNumber(Handle<String>::cast(input));
133 return Oddball::ToNumber(Handle<Oddball>::cast(input));
135 Isolate* const isolate = Handle<HeapObject>::cast(input)->GetIsolate();
145 isolate, input, JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(input),
153 MaybeHandle<Object> Object::ToInteger(Isolate* isolate, Handle<Object> input) {
160 MaybeHandle<Object> Object::ToInt32(Isolate* isolate, Handle<Object> input) {
167 MaybeHandle<Object> Object::ToUint32(Isolate* isolate, Handle<Object> input) {
174 MaybeHandle<String> Object::ToString(Isolate* isolate, Handle<Object> input) {
177 return Handle<String>::cast(input);
180 return handle(Handle<Oddball>::cast(input)->to_string(), isolate);
190 return Simd128Value::ToString(Handle<Simd128Value>::cast(input));
193 isolate, input, JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(input),
201 MaybeHandle<Object> Object::ToLength(Isolate* isolate, Handle<Object> input) {
254 bool NumberEquals(Handle<Object> x, Handle<Object> y) {
262 Maybe<ComparisonResult> Object::Compare(Handle<Object> x, Handle<Object> y,
274 String::Compare(Handle<String>::cast(x), Handle<String>::cast(y)));
284 Isolate* const isolate = Handle<HeapObject>::cast(x)->GetIsolate();
289 Isolate* const isolate = Handle<HeapObject>::cast(y)->GetIsolate();
300 Maybe<bool> Object::Equals(Handle<Object> x, Handle<Object> y) {
306 return Just(NumberEquals(*x, Handle<Oddball>::cast(y)->to_number()));
308 return Just(NumberEquals(x, String::ToNumber(Handle<String>::cast(y))));
310 if (!JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(y))
320 String::Equals(Handle<String>::cast(x), Handle<String>::cast(y)));
322 x = String::ToNumber(Handle<String>::cast(x));
325 x = String::ToNumber(Handle<String>::cast(x));
326 return Just(NumberEquals(*x, Handle<Oddball>::cast(y)->to_number()));
328 if (!JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(y))
339 return Just(NumberEquals(Handle<Oddball>::cast(x)->to_number(), *y));
341 y = String::ToNumber(Handle<String>::cast(y));
342 return Just(NumberEquals(Handle<Oddball>::cast(x)->to_number(), *y));
344 if (!JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(y))
348 x = Oddball::ToNumber(Handle<Oddball>::cast(x));
356 if (!JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(y))
365 return Just(Simd128Value::Equals(Handle<Simd128Value>::cast(x),
366 Handle<Simd128Value>::cast(y)));
368 if (!JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(y))
381 y = Oddball::ToNumber(Handle<Oddball>::cast(y));
382 } else if (!JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(x))
411 Handle<String> Object::TypeOf(Isolate* isolate, Handle<Object> object) {
430 MaybeHandle<Object> Object::Multiply(Isolate* isolate, Handle<Object> lhs,
431 Handle<Object> rhs, Strength strength) {
446 MaybeHandle<Object> Object::Divide(Isolate* isolate, Handle<Object> lhs,
447 Handle<Object> rhs, Strength strength) {
462 MaybeHandle<Object> Object::Modulus(Isolate* isolate, Handle<Object> lhs,
463 Handle<Object> rhs, Strength strength) {
478 MaybeHandle<Object> Object::Add(Isolate* isolate, Handle<Object> lhs,
479 Handle<Object> rhs, Strength strength) {
483 return isolate->factory()->NewConsString(Handle<String>::cast(lhs),
484 Handle<String>::cast(rhs));
497 return isolate->factory()->NewConsString(Handle<String>::cast(lhs),
498 Handle<String>::cast(rhs));
507 MaybeHandle<Object> Object::Subtract(Isolate* isolate, Handle<Object> lhs,
508 Handle<Object> rhs, Strength strength) {
523 MaybeHandle<Object> Object::ShiftLeft(Isolate* isolate, Handle<Object> lhs,
524 Handle<Object> rhs, Strength strength) {
540 MaybeHandle<Object> Object::ShiftRight(Isolate* isolate, Handle<Object> lhs,
541 Handle<Object> rhs, Strength strength) {
558 Handle<Object> lhs,
559 Handle<Object> rhs,
576 MaybeHandle<Object> Object::BitwiseAnd(Isolate* isolate, Handle<Object> lhs,
577 Handle<Object> rhs, Strength strength) {
593 MaybeHandle<Object> Object::BitwiseOr(Isolate* isolate, Handle<Object> lhs,
594 Handle<Object> rhs, Strength strength) {
610 MaybeHandle<Object> Object::BitwiseXor(Isolate* isolate, Handle<Object> lhs,
611 Handle<Object> rhs, Strength strength) {
626 Maybe<bool> Object::IsArray(Handle<Object> object) {
629 Handle<JSProxy> proxy = Handle<JSProxy>::cast(object);
637 return Object::IsArray(handle(proxy->target(), isolate));
643 bool Object::IsPromise(Handle<Object> object) {
645 auto js_object = Handle<JSObject>::cast(object);
658 MaybeHandle<Object> Object::GetMethod(Handle<JSReceiver> receiver,
659 Handle<Name> name) {
660 Handle<Object> func;
678 Isolate* isolate, Handle<Object> object, ElementTypes element_types) {
690 Handle<Object> raw_length_obj;
695 Handle<Object> raw_length_number;
707 Handle<FixedArray> list = isolate->factory()->NewFixedArray(len);
713 Handle<Object> next;
730 next = isolate->factory()->InternalizeName(Handle<Name>::cast(next));
793 Handle<Object> result;
828 Handle<JSProxy> proxy,
829 Handle<Name> name,
830 Handle<Object> receiver,
841 Handle<Name> trap_name = isolate->factory()->get_string();
844 Handle<Object> handler(proxy->handler(), isolate);
853 Handle<JSReceiver> target(proxy->target(), isolate);
855 Handle<Object> trap;
858 Object::GetMethod(Handle<JSReceiver>::cast(handler), trap_name), Object);
867 Handle<Object> trap_result;
868 Handle<Object> args[] = {target, name, receiver};
913 Handle<Object> JSReceiver::GetDataProperty(Handle<JSReceiver> object,
914 Handle<Name> name) {
921 Handle<Object> JSReceiver::GetDataProperty(LookupIterator* it) {
1033 MaybeHandle<JSObject> JSObject::New(Handle<JSFunction> constructor,
1034 Handle<JSReceiver> new_target,
1035 Handle<AllocationSite> site) {
1047 Handle<Map> initial_map;
1051 Handle<JSObject> result =
1059 Handle<FixedArray> JSObject::EnsureWritableFastElements(
1060 Handle<JSObject> object) {
1063 Handle<FixedArray> elems(FixedArray::cast(object->elements()), isolate);
1065 Handle<FixedArray> writable_elems = isolate->factory()->CopyFixedArrayWithMap(
1075 MaybeHandle<Object> JSProxy::GetPrototype(Handle<JSProxy> proxy) {
1077 Handle<String> trap_name = isolate->factory()->getPrototypeOf_string();
1090 Handle<JSReceiver> target(proxy->target(), isolate);
1091 Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
1094 Handle<Object> trap;
1102 Handle<Object> argv[] = {target};
1103 Handle<Object> handler_proto;
1119 Handle<Object> target_proto;
1137 Handle<Object> structure = it->GetAccessors();
1138 Handle<Object> receiver = it->GetReceiver();
1146 Handle<JSObject> holder = it->GetHolder<JSObject>();
1147 Handle<Name> name = it->GetName();
1148 Handle<ExecutableAccessorInfo> info =
1149 Handle<ExecutableAccessorInfo>::cast(structure);
1168 Handle<Object> return_value = v8::Utils::OpenHandle(*result);
1170 // Rebox handle before return.
1171 return handle(*return_value, isolate);
1175 Handle<Object> getter(AccessorPair::cast(*structure)->getter(), isolate);
1179 receiver, Handle<JSReceiver>::cast(getter));
1187 Handle<AccessorInfo> info,
1188 Handle<Map> map) {
1197 Handle<Object> value,
1200 Handle<Object> structure = it->GetAccessors();
1201 Handle<Object> receiver = it->GetReceiver();
1209 Handle<JSObject> holder = it->GetHolder<JSObject>();
1210 Handle<Name> name = it->GetName();
1211 Handle<ExecutableAccessorInfo> info =
1212 Handle<ExecutableAccessorInfo>::cast(structure);
1235 Handle<Object> setter(AccessorPair::cast(*structure)->setter(), isolate);
1239 receiver, Handle<JSReceiver>::cast(setter), value, should_throw);
1249 Handle<Object> receiver,
1250 Handle<JSReceiver> getter) {
1271 Maybe<bool> Object::SetPropertyWithDefinedSetter(Handle<Object> receiver,
1272 Handle<JSReceiver> setter,
1273 Handle<Object> value,
1277 Handle<Object> argv[] = { value };
1286 bool Object::IsErrorObject(Isolate* isolate, Handle<Object> object) {
1289 Handle<Name> symbol = isolate->factory()->stack_trace_symbol();
1291 JSReceiver::HasOwnProperty(Handle<JSReceiver>::cast(object), symbol);
1322 Handle<JSObject> checked = it->GetHolder<JSObject>();
1329 Handle<Object> result;
1337 Handle<Name> name = it->GetName();
1350 Handle<JSObject> checked = it->GetHolder<JSObject>();
1371 Handle<Object> accessors = it->GetAccessors();
1382 LookupIterator* it, Handle<Object> value, ShouldThrow should_throw) {
1383 Handle<JSObject> checked = it->GetHolder<JSObject>();
1394 void JSObject::SetNormalizedProperty(Handle<JSObject> object,
1395 Handle<Name> name,
1396 Handle<Object> value,
1401 Handle<String>::cast(name));
1405 Handle<GlobalDictionary> property_dictionary(object->global_dictionary());
1422 Handle<NameDictionary> property_dictionary(object->property_dictionary());
1440 Maybe<bool> Object::HasInPrototypeChain(Isolate* isolate, Handle<Object> object,
1441 Handle<Object> proto) {
1520 Handle<Smi> Object::GetOrCreateHash(Isolate* isolate, Handle<Object> object) {
1521 Handle<Object> hash(object->GetSimpleHash(), isolate);
1522 if (hash->IsSmi()) return Handle<Smi>::cast(hash);
1525 return JSReceiver::GetOrCreateIdentityHash(Handle<JSReceiver>::cast(object));
1611 Isolate* isolate, Handle<Object> original_array) {
1612 Handle<Context> native_context = isolate->native_context();
1614 return Handle<Object>(native_context->array_function(), isolate);
1616 Handle<Object> constructor = isolate->factory()->undefined_value();
1626 Handle<Context> constructor_context;
1629 JSReceiver::GetFunctionRealm(Handle<JSReceiver>::cast(constructor)),
1648 return Handle<Object>(native_context->array_function(), isolate);
1717 Handle<String> String::SlowFlatten(Handle<ConsString> cons,
1725 Handle<SeqString> result;
1727 Handle<SeqOneByteString> flat = isolate->factory()->NewRawOneByteString(
1733 Handle<SeqTwoByteString> flat = isolate->factory()->NewRawTwoByteString(
2058 FILE* file, Handle<JSObject> object,
2059 ElementsKind from_kind, Handle<FixedArrayBase> from_elements,
2060 ElementsKind to_kind, Handle<FixedArrayBase> to_elements) {
2079 Handle<Map> map, Handle<Context> native_context) {
2083 return handle(
2397 Handle<String> Simd128Value::ToString(Handle<Simd128Value> input) {
2399 if (input->Is##Type()) return Type::ToString(Handle<Type>::cast(input));
2403 return Handle<String>::null();
2408 Handle<String> Float32x4::ToString(Handle<Float32x4> input) {
2423 Handle<String> Type::ToString(Handle<Type> input) { \
2441 Handle<String> Type::ToString(Handle<Type> input) { \
2504 MaybeHandle<String> JSReceiver::BuiltinStringTag(Handle<JSReceiver> object) {
2519 return handle(object->class_name(), isolate);
2524 Handle<String> JSReceiver::GetConstructorName(Handle<JSReceiver> receiver) {
2540 return handle(name, isolate);
2546 Handle<Object> maybe_tag = JSReceiver::GetDataProperty(
2548 if (maybe_tag->IsString()) return Handle<String>::cast(maybe_tag);
2552 if (iter.IsAtEnd()) return handle(receiver->class_name());
2553 Handle<JSReceiver> start = PrototypeIterator::GetCurrent<JSReceiver>(iter);
2556 Handle<Object> maybe_constructor = JSReceiver::GetDataProperty(&it);
2557 Handle<String> result = isolate->factory()->Object_string();
2562 if (name->length() > 0) result = handle(name, isolate);
2566 ? handle(receiver->class_name())
2590 static Handle<Object> WrapType(Handle<HeapType> type) {
2596 MaybeHandle<Map> Map::CopyWithField(Handle<Map> map,
2597 Handle<Name> name,
2598 Handle<HeapType> type,
2621 Handle<Object> wrapped_type(WrapType(type));
2625 Handle<Map> new_map = Map::CopyAddDescriptor(map, &new_field_desc, flag);
2635 MaybeHandle<Map> Map::CopyWithConstant(Handle<Map> map,
2636 Handle<Name> name,
2637 Handle<Object> constant,
2651 void JSObject::AddSlowProperty(Handle<JSObject> object,
2652 Handle<Name> name,
2653 Handle<Object> value,
2658 Handle<GlobalDictionary> dict(object->global_dictionary());
2680 Handle<GlobalDictionary> result =
2685 Handle<NameDictionary> dict(object->property_dictionary());
2687 Handle<NameDictionary> result =
2694 MaybeHandle<Object> JSObject::EnqueueChangeRecord(Handle<JSObject> object,
2696 Handle<Name> name,
2697 Handle<Object> old_value) {
2702 Handle
2703 Handle<Object> args[] = { type, object, name, old_value };
2707 Handle<JSFunction>(isolate->observers_notify_change()),
2764 void JSObject::UpdatePrototypeUserRegistration(Handle<Map> old_map,
2765 Handle<Map> new_map,
2791 void JSObject::MigrateToMap(Handle<JSObject> object, Handle<Map> new_map,
2797 Handle<Map> old_map(object->map());
2858 void JSObject::MigrateFastToFast(Handle<JSObject> object, Handle<Map> new_map) {
2860 Handle<Map> old_map(object->map());
2888 Handle<Object> value = isolate->factory()->NewHeapNumber(0, MUTABLE);
2900 Handle<FixedArray> old_storage = handle(object->properties(), isolate);
2901 Handle<FixedArray> new_storage =
2905 Handle<Object> value;
2924 Handle<FixedArray> array = isolate->factory()->NewFixedArray(total_size);
2926 Handle<DescriptorArray> old_descriptors(old_map->instance_descriptors());
2927 Handle<DescriptorArray> new_descriptors(new_map->instance_descriptors());
2941 Handle<Object> value;
2952 value = handle(old_descriptors->GetValue(i), isolate);
2962 value = handle(object->RawFastPropertyAt(index), isolate);
2965 value = handle(Smi::FromInt(0), isolate);
2983 Handle<Object> value;
3052 Handle<Map> Map::CopyGeneralizeAllRepresentations(
3053 Handle<Map> map, int modify_index, StoreMode store_mode, PropertyKind kind,
3056 Handle<DescriptorArray> old_descriptors(map->instance_descriptors(), isolate);
3058 Handle<DescriptorArray> descriptors =
3068 Handle<LayoutDescriptor> new_layout_descriptor(
3070 Handle<Map> new_map = CopyReplaceDescriptors(
3081 DataDescriptor d(handle(descriptors->GetKey(modify_index), isolate),
3229 void Map::UpdateFieldType(int descriptor, Handle<Name> name,
3231 Handle<Object> new_wrapped_type) {
3261 Handle<HeapType> Map::GeneralizeFieldType(Representation rep1,
3262 Handle<HeapType> type1,
3264 Handle<HeapType> type2,
3279 void Map::GeneralizeFieldType(Handle<Map> map, int modify_index,
3281 Handle<HeapType> new_field_type) {
3285 Handle<DescriptorArray> old_descriptors(map->instance_descriptors(), isolate);
3288 Handle<HeapType> old_field_type(old_descriptors->GetFieldType(modify_index),
3303 Handle<Map> field_owner(map->FindFieldOwner(modify_index), isolate);
3304 Handle<DescriptorArray> descriptors(
3313 Handle<Name> name(descriptors->GetKey(modify_index));
3315 Handle<Object> wrapped_type(WrapType(new_field_type));
3332 static inline Handle<HeapType> GetFieldType(Isolate* isolate,
3333 Handle<DescriptorArray> descriptors,
3343 return handle(descriptors->GetFieldType(descriptor), isolate);
3377 Handle<Map> Map::ReconfigureProperty(Handle<Map> old_map, int modify_index,
3381 Handle<HeapType> new_field_type,
3387 Handle<DescriptorArray> old_descriptors(
3413 Handle<Map> field_owner(old_map->FindFieldOwner(modify_index), isolate);
3427 Handle<Map> root_map(old_map->FindRootMap(), isolate);
3469 Handle<Map> target_map = root_map;
3502 Handle<Map> tmp_map(transition, isolate);
3504 Handle<DescriptorArray> tmp_descriptors = handle(
3527 Handle<HeapType> next_field_type;
3531 Handle<HeapType> old_field_type =
3540 Handle<HeapType> old_field_type =
3557 Handle<DescriptorArray> target_descriptors(
3596 Handle<Map> tmp_map(transition, isolate);
3597 Handle<DescriptorArray> tmp_descriptors(
3617 target_descriptors = handle(target_map->instance_descriptors(), isolate);
3624 Handle<DescriptorArray> new_descriptors = DescriptorArray::Allocate(
3639 Descriptor d(handle(old_descriptors->GetKey(i), isolate),
3640 handle(old_descriptors->GetValue(i), isolate),
3647 Handle<Name> target_key(target_descriptors->GetKey(i), isolate);
3695 Handle<HeapType> target_field_type =
3699 Handle<HeapType> next_field_type;
3705 Handle<HeapType> old_field_type =
3713 Handle<HeapType> old_field_type =
3720 Handle<Object> wrapped_type(WrapType(next_field_type));
3731 Descriptor d(target_key, handle(target_descriptors->GetValue(i), isolate),
3740 Handle<Name> old_key(old_descriptors->GetKey(i), isolate);
3772 Handle<HeapType> next_field_type;
3776 Handle<HeapType> old_field_type =
3784 Handle<HeapType> old_field_type =
3790 Handle<Object> wrapped_type(WrapType(next_field_type));
3802 Descriptor d(old_key, handle(old_descriptors->GetValue(i), isolate),
3813 Handle<Map> split_map(root_map->FindLastMatchMap(
3852 Handle<HeapType> old_field_type =
3854 ? handle(old_descriptors->GetFieldType(modify_index), isolate)
3856 handle(old_descriptors->GetValue(modify_index), isolate),
3858 Handle<HeapType> new_field_type =
3860 ? handle(new_descriptors->GetFieldType(modify_index), isolate)
3862 handle(new_descriptors->GetValue(modify_index), isolate),
3871 Handle<LayoutDescriptor> new_layout_descriptor =
3874 Handle<Map> new_map =
3886 Handle<Map> Map::GeneralizeAllFieldRepresentations(
3887 Handle<Map> map) {
3888 Handle<DescriptorArray> descriptors(map->instance_descriptors());
3902 MaybeHandle<Map> Map::TryUpdate(Handle<Map> old_map) {
3985 return handle(new_map);
3990 Handle<Map> Map::Update(Handle<Map> map) {
3999 Handle<Object> value) {
4006 Handle<InterceptorInfo> interceptor(it->GetInterceptor());
4009 Handle<JSObject> holder = it->GetHolder<JSObject>();
4022 Handle<Name> name = it->name();
4041 Handle<Object> result_internal = v8::Utils::OpenHandle(*result);
4050 MaybeHandle<Object> Object::SetProperty(Handle<Object> object,
4051 Handle<Name> name, Handle<Object> value,
4061 Handle<Object> value,
4110 Handle<Object> accessors = it->GetAccessors();
4155 Maybe<bool> Object::SetProperty(LookupIterator* it, Handle<Object> value,
4172 Maybe<bool> Object::SetSuperProperty(LookupIterator* it, Handle<Object> value,
4194 Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(it->GetReceiver());
4268 Handle<Object> receiver,
4269 Handle<Object> name,
4282 Handle<Object> receiver,
4283 Handle<Object> name,
4284 Handle<Object> value,
4294 Handle<Object> value,
4302 Handle<Object> receiver,
4303 Handle<Object> name,
4304 Handle<Object> value,
4313 Handle<Object> name,
4314 Handle<Object> value,
4321 Maybe<bool> Object::SetDataProperty(LookupIterator* it, Handle<Object> value) {
4324 Handle<JSObject> receiver = Handle<JSObject>::cast(it->GetReceiver());
4338 Handle<Object> to_assign = value;
4353 if (Handle<JSArrayBufferView>::cast(receiver)->WasNeutered()) {
4386 Handle<JSArray> object) {
4389 Handle<Object> args[] = {object};
4392 isolate, Handle<JSFunction>(isolate->observers_begin_perform_splice()),
4398 Handle<JSArray> object) {
4401 Handle<Object> args[] = {object};
4404 isolate, Handle<JSFunction>(isolate->observers_end_perform_splice()),
4410 Handle<JSArray> object, uint32_t index, Handle<JSArray> deleted,
4414 Handle<Object> index_object = isolate->factory()->NewNumberFromUint(index);
4415 Handle<Object> add_count_object =
4418 Handle<Object> args[] = {object, index_object, deleted, add_count_object};
4421 isolate, Handle<JSFunction>(isolate->observers_enqueue_splice()),
4426 Maybe<bool> Object::AddDataProperty(LookupIterator* it, Handle<Object> value,
4438 Handle<JSObject> receiver = it->GetStoreTarget();
4455 Handle<JSArray> array = Handle<JSArray>::cast(receiver);
4514 void Map::EnsureDescriptorSlack(Handle<Map> map, int slack) {
4518 Handle<DescriptorArray> descriptors(map->instance_descriptors());
4522 Handle<DescriptorArray> new_descriptors = DescriptorArray::CopyUpTo(
4559 Handle<typename T::Array> array,
4568 Handle<AccessorInfo> entry(AccessorInfo::cast(callbacks->get(i)));
4570 Handle<String> key =
4572 Handle<String>(String::cast(entry->name())));
4580 Handle<AccessorInfo> entry(AccessorInfo::cast(callbacks->get(i)));
4581 Handle<Name> key(Name::cast(entry->name()));
4594 static bool Contains(Handle<Name> key,
4595 Handle<AccessorInfo> entry,
4597 Handle<DescriptorArray> array) {
4601 static void Insert(Handle<Name> key,
4602 Handle<AccessorInfo> entry,
4604 Handle<DescriptorArray> array) {
4614 static bool Contains(Handle<Name> key,
4615 Handle<AccessorInfo> entry,
4617 Handle<FixedArray> array) {
4623 static void Insert(Handle<Name> key,
4624 Handle<AccessorInfo> entry,
4626 Handle<FixedArray> array) {
4633 void Map::AppendCallbackDescriptors(Handle<Map> map,
4634 Handle<Object> descriptors) {
4636 Handle<DescriptorArray> array(map->instance_descriptors());
4644 int AccessorInfo::AppendUnique(Handle<Object> descriptors,
4645 Handle<FixedArray> array,
4664 Handle<Map> Map::FindTransitionedMap(Handle<Map> map,
4681 return transition == nullptr ? Handle<Map>() : handle(transition);
4722 Handle<WeakCell> Map::WeakCellForMap(Handle<Map> map) {
4725 return Handle<WeakCell>(WeakCell::cast(map->weak_cell_cache()));
4727 Handle<WeakCell> weak_cell = isolate->factory()->NewWeakCell(map);
4733 static Handle<Map> AddMissingElementsTransitions(Handle<Map> map,
4737 Handle<Map> current_map = map;
4764 Handle<Map> Map::TransitionElementsTo(Handle<Map> map,
4774 return handle(native_context->slow_aliased_arguments_map());
4779 return handle(native_context->fast_aliased_arguments_map());
4790 return handle(Map::cast(maybe_transitioned_map), isolate);
4801 return handle(Map::cast(map->GetBackPointer()));
4821 Handle<Map> Map::AsElementsKind(Handle<Map> map, ElementsKind kind) {
4822 Handle<Map> closest_map(FindClosestElementsTransition(*map, kind));
4832 Handle<Map> JSObject::GetElementsTransitionMap(Handle<JSObject> object,
4834 Handle<Map> map(object->map());
4839 void JSProxy::Revoke(Handle<JSProxy> proxy) {
4846 Maybe<bool> JSProxy::HasProperty(Isolate* isolate, Handle<JSProxy> proxy,
4847 Handle<Name> name) {
4852 Handle<Object> handler(proxy->handler(), isolate);
4861 Handle<JSReceiver> target(proxy->target(), isolate);
4863 Handle<Object> trap;
4865 isolate, trap, Object::GetMethod(Handle<JSReceiver>::cast(handler),
4874 Handle<Object> trap_result_obj;
4875 Handle<Object> args[] = {target, name};
4913 Maybe<bool> JSProxy::SetProperty(Handle<JSProxy> proxy, Handle<Name> name,
4914 Handle<Object> value, Handle<Object> receiver,
4920 Handle<String> trap_name = factory->set_string();
4929 Handle<JSReceiver> target(proxy->target(), isolate);
4930 Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
4932 Handle<Object> trap;
4942 Handle<Object> trap_result;
4943 Handle<Object> args[] = {target, name, value, receiver};
4982 Maybe<bool> JSProxy::DeletePropertyOrElement(Handle<JSProxy> proxy,
4983 Handle<Name> name,
4991 Handle<String> trap_name = factory->deleteProperty_string();
4998 Handle<JSReceiver> target(proxy->target(), isolate);
4999 Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
5001 Handle<Object> trap;
5008 Handle<Object> trap_result;
5009 Handle<Object> args[] = {target, name};
5035 MaybeHandle<JSProxy> JSProxy::New(Isolate* isolate, Handle<Object> target,
5036 Handle<Object> handler) {
5055 return isolate->factory()->NewJSProxy(Handle<JSReceiver>::cast(target),
5056 Handle<JSReceiver>::cast(handler));
5061 MaybeHandle<Context> JSProxy::GetFunctionRealm(Handle<JSProxy> proxy) {
5067 Handle<JSReceiver> target(JSReceiver::cast(proxy->target()));
5074 Handle<JSBoundFunction> function) {
5077 handle(function->bound_target_function()));
5082 Handle<Context> JSFunction::GetFunctionRealm(Handle<JSFunction> function) {
5084 return handle(function->context()->native_context());
5089 MaybeHandle<Context> JSObject::GetFunctionRealm(Handle<JSObject> object) {
5092 return handle(object->GetCreationContext());
5097 MaybeHandle<Context> JSReceiver::GetFunctionRealm(Handle<JSReceiver> receiver) {
5099 return JSProxy::GetFunctionRealm(Handle<JSProxy>::cast(receiver));
5103 return JSFunction::GetFunctionRealm(Handle<JSFunction>::cast(receiver));
5108 Handle<JSBoundFunction>::cast(receiver));
5111 return JSObject::GetFunctionRealm(Handle<JSObject>::cast(receiver));
5127 void JSObject::AllocateStorageForMap(Handle<JSObject> object, Handle<Map> map) {
5148 void JSObject::MigrateInstance(Handle<JSObject> object) {
5149 Handle<Map> original_map(object->map());
5150 Handle<Map> map = Map::Update(original_map);
5165 bool JSObject::TryMigrateInstance(Handle<JSObject> object) {
5168 Handle<Map> original_map(object->map(), isolate);
5169 Handle<Map> new_map;
5186 void JSObject::AddProperty(Handle<JSObject> object, Handle<Name> name,
5187 Handle<Object> value,
5208 void ExecutableAccessorInfo::ClearSetter(Handle<ExecutableAccessorInfo> info) {
5209 Handle<Object> object = v8::FromCData(info->GetIsolate(), nullptr);
5219 LookupIterator* it, Handle<Object> value, PropertyAttributes attributes,
5228 LookupIterator* it, Handle<Object> value, PropertyAttributes attributes,
5230 Handle<JSObject> object = Handle<JSObject>::cast(it->GetReceiver());
5266 Handle<Object> accessors = it->GetAccessors();
5283 Handle<ExecutableAccessorInfo> new_data = Accessors::CloneAccessor(
5284 it->isolate(), Handle<ExecutableAccessorInfo>::cast(accessors));
5314 Handle<Object> old_value = it->factory()->the_hole_value();
5352 Handle<JSObject> object, Handle<Name> name, Handle<Object> value,
5361 Handle<JSObject> object, uint32_t index, Handle<Object> value,
5370 Handle<JSObject> object, Handle<Name> name, Handle<Object> value,
5387 Handle<JSObject> holder = it->GetHolder<JSObject>();
5388 Handle<InterceptorInfo> interceptor(it->GetInterceptor());
5405 Handle<Name> name = it->name();
5431 Handle<Name> name = it->name();
5478 Handle<NormalizedMapCache> NormalizedMapCache::New(Isolate* isolate) {
5479 Handle<FixedArray> array(
5481 return Handle<NormalizedMapCache>::cast(array);
5485 MaybeHandle<Map> NormalizedMapCache::Get(Handle<Map> fast_map,
5493 return handle(Map::cast(value));
5497 void NormalizedMapCache::Set(Handle<Map> fast_map,
5498 Handle<Map> normalized_map) {
5513 void HeapObject::UpdateMapCodeCache(Handle<HeapObject> object,
5514 Handle<Name> name,
5515 Handle<Code> code) {
5516 Handle<Map> map(object->map());
5521 void JSObject::NormalizeProperties(Handle<JSObject> object,
5527 Handle<Map> map(object->map());
5528 Handle<Map> new_map = Map::Normalize(map, mode, reason);
5534 void JSObject::MigrateFastToSlow(Handle<JSObject> object,
5535 Handle<Map> new_map,
5544 Handle<Map> map(object->map());
5554 Handle<NameDictionary> dictionary =
5557 Handle<DescriptorArray> descs(map->instance_descriptors());
5560 Handle<Name> key(descs->GetKey(i));
5563 Handle<Object> value(descs->GetConstant(i), isolate);
5571 Handle<Object> value;
5576 value = handle(object->RawFastPropertyAt(index), isolate);
5579 Handle<HeapNumber> old = Handle<HeapNumber>::cast(value);
5590 Handle<Object> value(object->RawFastPropertyAt(index), isolate);
5597 Handle<Object> value(descs->GetCallbacksObject(i), isolate);
5651 void JSObject::MigrateSlowToFast(Handle<JSObject> object,
5658 Handle<NameDictionary> dictionary(object->property_dictionary());
5665 Handle<FixedArray> iteration_order;
5688 Handle<Map> old_map(object->map(), isolate);
5693 Handle<Map> new_map = Map::CopyDropDescriptors(old_map);
5719 Handle<DescriptorArray> descriptors = DescriptorArray::Allocate(
5731 Handle<FixedArray> fields = factory->NewFixedArray(
5743 Handle<Name> key(Name::cast(k), isolate);
5752 DataConstantDescriptor d(key, handle(value, isolate),
5769 AccessorConstantDescriptor d(key, handle(value, isolate),
5780 Handle<LayoutDescriptor> layout_descriptor = LayoutDescriptor::New(
5798 void JSObject::ResetElements(Handle<JSObject> object) {
5802 Handle<SeededNumberDictionary> new_elements =
5811 static Handle<SeededNumberDictionary> CopyFastElementsToDictionary(
5812 Handle<FixedArrayBase> array, int length,
5813 Handle<SeededNumberDictionary> dictionary, bool used_as_prototype) {
5818 Handle<Object> value;
5820 Handle<FixedDoubleArray> double_array =
5821 Handle<FixedDoubleArray>::cast(array);
5828 value = handle(Handle<FixedArray>::cast(array)->get(i), isolate);
5850 Handle<SeededNumberDictionary> JSObject::GetNormalizedElementDictionary(
5851 Handle<JSObject> object, Handle<FixedArrayBase> elements) {
5859 ? Smi::cast(Handle<JSArray>::cast(object)->length())->value()
5862 Handle<SeededNumberDictionary> dictionary =
5869 Handle<SeededNumberDictionary> JSObject::NormalizeElements(
5870 Handle<JSObject> object) {
5875 Handle<FixedArrayBase> elements(object->elements(), isolate);
5879 elements = handle(FixedArrayBase::cast(parameter_map->get(1)), isolate);
5883 return Handle<SeededNumberDictionary>::cast(elements);
5890 Handle<SeededNumberDictionary> dictionary =
5896 Handle<Map> new_map = JSObject::GetElementsTransitionMap(object, target_kind);
5936 void JSObject::SetIdentityHash(Handle<JSObject> object, Handle<Smi> hash) {
5939 Handle<Name> hash_code_symbol(isolate->heap()->hash_code_symbol());
5945 static Handle<Smi> GetOrCreateIdentityHashHelper(Handle<ProxyType> proxy) {
5948 Handle<Object> maybe_hash(proxy->hash(), isolate);
5949 if (maybe_hash->IsSmi()) return Handle<Smi>::cast(maybe_hash);
5951 Handle<Smi> hash(GenerateIdentityHash(isolate), isolate);
5963 Handle<Name> hash_code_symbol(isolate->heap()->hash_code_symbol());
5964 Handle<Object> stored_value =
5965 Object::GetPropertyOrElement(Handle<Object>(this, isolate),
5972 Handle<Smi> JSObject::GetOrCreateIdentityHash(Handle<JSObject> object) {
5974 return GetOrCreateIdentityHashHelper(Handle<JSGlobalProxy>::cast(object));
5978 Handle<Object> maybe_hash(object->GetIdentityHash(), isolate);
5979 if (maybe_hash->IsSmi()) return Handle<Smi>::cast(maybe_hash);
5981 Handle<Smi> hash(GenerateIdentityHash(isolate), isolate);
5982 Handle<Name> hash_code_symbol(isolate->heap()->hash_code_symbol());
5993 Handle<Smi> JSProxy::GetOrCreateIdentityHash(Handle<JSProxy> proxy) {
5998 Object* JSObject::GetHiddenProperty(Handle<Name> key) {
6020 Handle<Object> JSObject::SetHiddenProperty(Handle<JSObject> object,
6021 Handle<Name> key,
6022 Handle<Object> value) {
6037 Handle<Object> inline_value(object->GetHiddenPropertiesHashTable(), isolate);
6039 Handle<ObjectHashTable> hashtable =
6043 Handle<ObjectHashTable> new_table = ObjectHashTable::Put(hashtable, key,
6056 void JSObject::DeleteHiddenProperty(Handle<JSObject> object, Handle<Name> key) {
6072 Handle<ObjectHashTable> hashtable(ObjectHashTable::cast(inline_value));
6078 bool JSObject::HasHiddenProperties(Handle<JSObject> object) {
6079 Handle<Name> hidden = object->GetIsolate()->factory()->hidden_string();
6114 LookupIterator it(handle(this), isolate->factory()->hidden_string(),
6121 Handle<ObjectHashTable> JSObject::GetOrCreateHiddenPropertiesHashtable(
6122 Handle<JSObject> object) {
6126 Handle<Object> inline_value(object->GetHiddenPropertiesHashTable(), isolate);
6128 return Handle<ObjectHashTable>::cast(inline_value);
6131 Handle<ObjectHashTable> hashtable = ObjectHashTable::New(
6140 Handle<Object> JSObject::SetHiddenPropertiesHashTable(Handle<JSObject> object,
6141 Handle<Object> value) {
6144 Handle<Name> name = isolate->factory()->hidden_string();
6157 Handle<InterceptorInfo> interceptor(it->GetInterceptor());
6160 Handle<JSObject> holder = it->GetHolder<JSObject>();
6175 Handle<Name> name = it->name();
6189 Handle<Object> result_internal = v8::Utils::OpenHandle(*result);
6196 void JSReceiver::DeleteNormalizedProperty(Handle<JSReceiver> object,
6197 Handle<Name> name, int entry) {
6203 Handle<GlobalDictionary> dictionary(
6213 Handle<NameDictionary> dictionary(object->property_dictionary());
6217 Handle<NameDictionary> new_properties =
6241 Handle<JSObject> receiver = Handle<JSObject>::cast(it->GetReceiver());
6247 Handle<Object> old_value = it->factory()->the_hole_value();
6310 Maybe<bool> JSReceiver::DeleteElement(Handle<JSReceiver> object, uint32_t index,
6318 Maybe<bool> JSReceiver::DeleteProperty(Handle<JSReceiver> object,
6319 Handle<Name> name,
6326 Maybe<bool> JSReceiver::DeletePropertyOrElement(Handle<JSReceiver> object,
6327 Handle<Name> name,
6336 MaybeHandle<Object> ToPropertyKey(Isolate* isolate, Handle<Object> value) {
6341 Handle<Object> key;
6352 return handle(Smi::FromInt(static_cast<int>(uint_value)), isolate);
6361 Object* JSReceiver::DefineProperty(Isolate* isolate, Handle<Object> object,
6362 Handle<Object> key,
6363 Handle<Object> attributes) {
6366 Handle<String> fun_name =
6382 isolate, Handle<JSReceiver>::cast(object), key, &desc, THROW_ON_ERROR);
6394 Handle<Object> object,
6395 Handle<Object> properties) {
6398 Handle<String> fun_name =
6406 Handle<JSReceiver> props;
6414 Handle<FixedArray> keys;
6424 Handle<Object> next_key(keys->get(i), isolate);
6439 Handle<Object> desc_obj;
6459 DefineOwnProperty(isolate, Handle<JSReceiver>::cast(object),
6472 Handle<JSReceiver> object,
6473 Handle<Object> key,
6477 return JSArray::DefineOwnProperty(isolate, Handle<JSArray>::cast(object),
6481 return JSProxy::DefineOwnProperty(isolate, Handle<JSProxy>::cast(object),
6487 // DefineOwnPropertyIgnoreAttributes, can handle arguments (ES6 9.4.4.2)
6490 return OrdinaryDefineOwnProperty(isolate, Handle<JSObject>::cast(object), key,
6497 Handle<JSObject> object,
6498 Handle<Object> key,
6534 // - handle interceptors correctly
6535 // - handle accessors correctly (which might change the holder's map)
6538 Handle<JSObject> object = Handle<JSObject>::cast(it->GetReceiver());
6550 PropertyDescriptor* current, Handle<Name> property_name,
6564 ShouldThrow should_throw, Handle<Name> property_name) {
6567 Handle<JSObject> object;
6568 if (it != NULL) object = Handle<JSObject>::cast(it->GetReceiver());
6597 Handle<Object> value(
6600 : Handle<Object>::cast(isolate->factory()->undefined_value()));
6617 Handle<Object> getter(
6620 : Handle<Object>::cast(isolate->factory()->null_value()));
6621 Handle<Object> setter(
6624 : Handle<Object>::cast(isolate->factory()->null_value()));
6789 Handle<Object> value(
6793 : Handle<Object>::cast(
6802 Handle<Object> getter(
6807 : Handle<Object>::cast(isolate->factory()->null_value()));
6808 Handle<Object> setter(
6813 : Handle<Object>::cast(isolate->factory()->null_value()));
6827 Handle<Object> value,
6830 Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(it->GetReceiver());
6849 Handle<Object> value) {
6856 if (!JSObject::IsExtensible(Handle<JSObject>::cast(it->GetReceiver())))
6871 bool PropertyKeyToArrayLength(Handle<Object> value, uint32_t* length) {
6879 bool PropertyKeyToArrayIndex(Handle<Object> index_obj, uint32_t* output) {
6886 Maybe<bool> JSArray::DefineOwnProperty(Isolate* isolate, Handle<JSArray> o,
6887 Handle<Object> name,
6952 Handle<Object> length_object,
6958 Handle<String>::cast(length_object)->AsArrayIndex(output)) {
6963 Handle<Object> uint32_v;
6969 Handle<Object> number_v;
6976 Handle<Object> exception =
6988 Maybe<bool> JSArray::ArraySetLength(Isolate* isolate, Handle<JSArray> a,
7078 Maybe<bool> JSProxy::DefineOwnProperty(Isolate* isolate, Handle<JSProxy> proxy,
7079 Handle<Object> key,
7083 if (key->IsSymbol() && Handle<Symbol>::cast(key)->IsPrivate()) {
7084 return AddPrivateProperty(isolate, proxy, Handle<Symbol>::cast(key), desc,
7087 Handle<String> trap_name = isolate->factory()->defineProperty_string();
7091 Handle<Object> handler(proxy->handler(), isolate);
7100 Handle<JSReceiver> target(proxy->target(), isolate);
7102 Handle<Object> trap;
7105 Object::GetMethod(Handle<JSReceiver>::cast(handler), trap_name),
7114 Handle<Object> desc_obj = desc->ToObject(isolate);
7117 Handle<Name> property_name =
7119 ? Handle<Name>::cast(key)
7120 : Handle<Name>::cast(isolate->factory()->NumberToString(key));
7123 Handle<Object> trap_result_obj;
7124 Handle<Object> args[] = {target, property_name, desc_obj};
7190 Maybe<bool> JSProxy::AddPrivateProperty(Isolate* isolate, Handle<JSProxy> proxy,
7191 Handle<Symbol> private_name,
7201 Handle<Object> value =
7204 : Handle<Object>::cast(isolate->factory()->undefined_value());
7215 Handle<NameDictionary> dict(proxy->property_dictionary());
7217 Handle<NameDictionary> result =
7226 Handle<JSReceiver> object,
7227 Handle<Object> key,
7267 Handle<Object> value;
7277 Handle<AccessorPair> accessors =
7278 Handle<AccessorPair>::cast(it->GetAccessors());
7280 desc->set_get(handle(accessors->GetComponent(ACCESSOR_GETTER), isolate));
7282 desc->set_set(handle(accessors->GetComponent(ACCESSOR_SETTER), isolate));
7299 Handle<JSProxy> proxy,
7300 Handle<Name> name,
7305 Handle<String> trap_name =
7309 Handle<Object> handler(proxy->handler(), isolate);
7318 Handle<JSReceiver> target(proxy->target(), isolate);
7320 Handle<Object> trap;
7323 Object::GetMethod(Handle<JSReceiver>::cast(handler), trap_name),
7331 Handle<Object> trap_result_obj;
7332 Handle<Object> args[] = {target, name};
7547 Maybe<bool> JSReceiver::SetIntegrityLevel(Handle<JSReceiver> receiver,
7553 Handle<JSObject> object = Handle<JSObject>::cast(receiver);
7572 Handle<FixedArray> keys;
7585 Handle<Object> key(keys->get(i), isolate);
7594 Handle<Object> key(keys->get(i), isolate);
7613 Maybe<bool> JSReceiver::TestIntegrityLevel(Handle<JSReceiver> object,
7622 Handle<FixedArray> keys;
7627 Handle<Object> key(keys->get(i), isolate);
7645 Maybe<bool> JSReceiver::PreventExtensions(Handle<JSReceiver> object,
7648 return JSProxy::PreventExtensions(Handle<JSProxy>::cast(object),
7652 return JSObject::PreventExtensions(Handle<JSObject>::cast(object),
7657 Maybe<bool> JSProxy::PreventExtensions(Handle<JSProxy> proxy,
7662 Handle<String> trap_name = factory->preventExtensions_string();
7669 Handle<JSReceiver> target(proxy->target(), isolate);
7670 Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
7672 Handle<Object> trap;
7679 Handle<Object> trap_result;
7680 Handle<Object> args[] = {target};
7703 Maybe<bool> JSObject::PreventExtensions(Handle<JSObject> object,
7712 !isolate->MayAccess(handle(isolate->context()), object)) {
7731 Handle<SeededNumberDictionary> dictionary = NormalizeElements(object);
7741 // TODO(adamk): Extend the NormalizedMapCache to handle non-extensible maps.
7742 Handle<Map> new_map = Map::Copy(handle(object->map()), "PreventExtensions");
7751 EnqueueChangeRecord(object, "preventExtensions", Handle<Name>(),
7759 Maybe<bool> JSReceiver::IsExtensible(Handle<JSReceiver> object) {
7761 return JSProxy::IsExtensible(Handle<JSProxy>::cast(object));
7763 return Just(JSObject::IsExtensible(Handle<JSObject>::cast(object)));
7767 Maybe<bool> JSProxy::IsExtensible(Handle<JSProxy> proxy) {
7771 Handle<String> trap_name = factory->isExtensible_string();
7778 Handle<JSReceiver> target(proxy->target(), isolate);
7779 Handle<JSReceiver> handler(JSReceiver::cast(proxy->handler()), isolate);
7781 Handle<Object> trap;
7788 Handle<Object> trap_result;
7789 Handle<Object> args[] = {target};
7808 bool JSObject::IsExtensible(Handle<JSObject> object) {
7811 !isolate->MayAccess(handle(isolate->context()), object)) {
7850 Handle<JSObject> object, ShouldThrow should_throw) {
7859 !isolate->MayAccess(handle(isolate->context()), object)) {
7876 Handle<SeededNumberDictionary> new_element_dictionary;
7881 ? Smi::cast(Handle<JSArray>::cast(object)->length())->value()
7886 object, handle(object->elements()));
7889 Handle<Symbol> transition_marker;
7899 Handle<Map> old_map(object->map(), isolate);
7903 Handle<Map> transition_map(transition, isolate);
7910 Handle<Map> new_map = Map::CopyForPreventExtensions(
7920 // TODO(adamk): Extend the NormalizedMapCache to handle non-extensible maps.
7921 Handle<Map> new_map =
7922 Map::Copy(handle(object->map()), "SlowCopyForPreventExtensions");
7968 void JSObject::SetObserved(Handle<JSObject> object) {
7972 Handle<Map> new_map;
7973 Handle<Map> old_map(object->map(), isolate);
7978 new_map = handle(transition, isolate);
7990 Handle<Object> JSObject::FastPropertyAt(Handle<JSObject> object,
7998 Handle<Object> raw_value(object->RawFastPropertyAt(index), isolate);
8012 MUST_USE_RESULT MaybeHandle<JSObject> StructureWalk(Handle<JSObject> object);
8016 Handle<JSObject> object,
8017 Handle<JSObject> value) {
8018 Handle<AllocationSite> current_site = site_context()->EnterNewScope();
8038 Handle<JSObject> object) {
8056 Handle<JSObject> copy;
8058 Handle<AllocationSite> site_to_pass;
8082 Handle<DescriptorArray> descriptors(copy->map()->instance_descriptors());
8094 Handle<Object> value(object->RawFastPropertyAt(index), isolate);
8098 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
8121 Handle<FixedArray> names = accumulator.GetKeys();
8124 Handle<Name> name(Name::cast(names->get(i)));
8125 Handle<Object> value =
8128 Handle<JSObject> result;
8131 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
8149 Handle<FixedArray> elements(FixedArray::cast(copy->elements()));
8158 Handle<Object> value(elements->get(i), isolate);
8163 Handle<JSObject> result;
8166 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
8177 Handle<SeededNumberDictionary> element_dictionary(
8183 Handle<Object> value(element_dictionary->ValueAt(i), isolate);
8185 Handle<JSObject> result;
8188 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
8222 Handle<JSObject> object,
8227 Handle<JSObject> for_assert;
8234 Handle<JSObject> object,
8239 Handle<JSObject> for_assert;
8246 MaybeHandle<Object> JSReceiver::ToPrimitive(Handle<JSReceiver> receiver,
8249 Handle<Object> exotic_to_prim;
8254 Handle<Object> hint_string;
8266 Handle<Object> result;
8284 Handle<JSReceiver> receiver, OrdinaryToPrimitiveHint hint) {
8286 Handle<String> method_names[2];
8297 for (Handle<String> name : method_names) {
8298 Handle<Object> method;
8302 Handle<Object> result;
8435 static bool ContainsOnlyValidKeys(Handle<FixedArray> array) {
8445 static Handle<FixedArray> ReduceFixedArrayTo(
8446 Handle<FixedArray> array, int length) {
8450 Handle<FixedArray> new_array =
8459 Handle<FixedArray> GetFastEnumPropertyKeys(Isolate* isolate,
8460 Handle<JSObject> object,
8462 Handle<Map> map(object->map());
8463 Handle<DescriptorArray> descs =
8464 Handle<DescriptorArray>(map->instance_descriptors(), isolate);
8480 Handle<FixedArray> keys(descs->GetEnumCache(), isolate);
8500 Handle<FixedArray> storage =
8502 Handle<FixedArray> indices =
8515 indices = Handle<FixedArray>();
8536 Handle<FixedArray> JSObject::GetEnumPropertyKeys(Handle<JSObject> object,
8542 Handle<GlobalDictionary> dictionary(object->global_dictionary());
8545 return Handle<FixedArray>(isolate->heap()->empty_fixed_array());
8547 Handle<FixedArray> storage = isolate->factory()->NewFixedArray(length);
8551 Handle<NameDictionary> dictionary(object->property_dictionary());
8554 return Handle<FixedArray>(isolate->heap()->empty_fixed_array());
8556 Handle<FixedArray> storage = isolate->factory()->NewFixedArray(length);
8569 Handle<JSReceiver> receiver,
8570 Handle<JSObject> object,
8578 Handle<InterceptorInfo> interceptor(type == kIndexed
8599 Handle<JSObject>::cast(v8::Utils::OpenHandle(*result))
8604 Handle<JSObject>::cast(v8::Utils::OpenHandle(*result)));
8607 Handle<JSObject>::cast(v8::Utils::OpenHandle(*result)));
8616 Handle<JSReceiver> receiver,
8617 Handle<JSObject> object,
8624 !isolate->MayAccess(handle(isolate->context()), object)) {
8654 Handle<JSFunction> arguments_function(
8668 Handle<FixedArray> enum_keys =
8687 Handle<JSReceiver> receiver,
8688 Handle<JSReceiver> object,
8698 Handle<JSReceiver> current =
8704 Handle<JSProxy>::cast(current),
8709 isolate, receiver, Handle<JSProxy>::cast(current), accumulator);
8714 Handle<JSObject>::cast(current), &filter,
8727 Maybe<bool> JSProxy::Enumerate(Isolate* isolate, Handle<JSReceiver> receiver,
8728 Handle<JSProxy> proxy,
8732 Handle<Object> handler(proxy->handler(), isolate);
8742 Handle<JSReceiver> target(proxy->target(), isolate);
8744 Handle<Object> trap;
8746 isolate, trap, Object::GetMethod(Handle<JSReceiver>::cast(handler),
8758 Handle<Object> trap_result_array;
8759 Handle<Object> args[] = {trap, handler, target};
8767 accumulator->AddKeysFromProxy(Handle<JSObject>::cast(trap_result_array));
8776 Handle<JSReceiver> receiver,
8777 Handle<JSProxy> proxy,
8782 Handle<Object> handler(proxy->handler(), isolate);
8791 Handle<JSReceiver> target(proxy->target(), isolate);
8793 Handle<Object> trap;
8795 isolate, trap, Object::GetMethod(Handle<JSReceiver>::cast(handler),
8805 Handle<Object> trap_result_array;
8806 Handle<Object> args[] = {target};
8813 Handle<FixedArray> trap_result;
8824 Handle<FixedArray> target_keys;
8831 Handle<FixedArray> target_configurable_keys = target_keys;
8833 Handle<FixedArray> target_nonconfigurable_keys =
8841 isolate, target, handle(target_keys->get(i), isolate), &desc);
8882 MessageTemplate::kProxyOwnKeysMissing, handle(key, isolate)));
8902 MessageTemplate::kProxyOwnKeysMissing, handle(key, isolate)));
8921 MaybeHandle<FixedArray> JSReceiver::GetKeys(Handle<JSReceiver> object,
8931 Handle<FixedArray> keys = accumulator.GetKeys(keys_conversion);
8967 MaybeHandle<Object> JSObject::DefineAccessor(Handle<JSObject> object,
8968 Handle<Name> name,
8969 Handle<Object> getter,
8970 Handle<Object> setter,
8981 Handle<Object> getter,
8982 Handle<Object> setter,
8995 Handle<JSObject> object = Handle<JSObject>::cast(it->GetReceiver());
9001 Handle<Object> old_value = isolate->factory()->the_hole_value();
9038 MaybeHandle<Object> JSObject::SetAccessor(Handle<JSObject> object,
9039 Handle<AccessorInfo> info) {
9041 Handle<Name> name(Name::cast(info->name()), isolate);
9079 MaybeHandle<Object> JSObject::GetAccessor(Handle<JSObject> object,
9080 Handle<Name> name,
9112 Handle<Object> maybe_pair = it.GetAccessors();
9114 return handle(
9167 Handle<Map> Map::RawCopy(Handle<Map> map, int instance_size) {
9169 Handle<Map> result =
9171 Handle<Object> prototype(map->prototype(), isolate);
9192 Handle<Map> Map::Normalize(Handle<Map> fast_map, PropertyNormalizationMode mode,
9197 Handle<Object> maybe_cache(isolate->native_context()->normalized_map_cache(),
9200 Handle<NormalizedMapCache> cache;
9201 if (use_cache) cache = Handle<NormalizedMapCache>::cast(maybe_cache);
9203 Handle<Map> new_map;
9213 Handle<Map> fresh = Map::CopyNormalized(fast_map, mode);
9258 Handle<Map> Map::CopyNormalized(Handle<Map> map,
9265 Handle<Map> result = RawCopy(map, new_instance_size);
9282 Handle<Map> Map::CopyInitialMap(Handle<Map> map, int instance_size,
9304 Handle<Map> result = RawCopy(map, instance_size);
9325 Handle<Map> Map::CopyDropDescriptors(Handle<Map> map) {
9326 Handle<Map> result = RawCopy(map, map->instance_size());
9339 Handle<Map> Map::ShareDescriptor(Handle<Map> map,
9340 Handle<DescriptorArray> descriptors,
9348 Handle<Map> result = CopyDropDescriptors(map);
9349 Handle<Name> name = descriptor->GetKey();
9359 descriptors = handle(map->instance_descriptors());
9363 Handle<LayoutDescriptor> layout_descriptor =
9366 : handle(LayoutDescriptor::FastPointerLayout(), map->GetIsolate());
9409 void Map::ConnectTransition(Handle<Map> parent, Handle<Map> child,
9410 Handle<Name> name, SimpleTransitionFlag flag) {
9434 Handle<Map> Map::CopyReplaceDescriptors(
9435 Handle<Map> map, Handle<DescriptorArray> descriptors,
9436 Handle<LayoutDescriptor> layout_descriptor, TransitionFlag flag,
9441 Handle<Map> result = CopyDropDescriptors(map);
9448 Handle<Name> name;
9485 Handle<Map> Map::AddMissingTransitions(
9486 Handle<Map> split_map, Handle<DescriptorArray> descriptors,
9487 Handle<LayoutDescriptor> full_layout_descriptor) {
9499 Handle<Map> last_map = CopyDropDescriptors(split_map);
9508 Handle<Map> map = split_map;
9510 Handle<Map> new_map = CopyDropDescriptors(map);
9523 void Map::InstallDescriptors(Handle<Map> parent, Handle<Map> child,
9525 Handle<DescriptorArray> descriptors,
9526 Handle<LayoutDescriptor> full_layout_descriptor) {
9543 Handle<LayoutDescriptor> layout_descriptor =
9558 Handle<Name> name = handle(descriptors->GetKey(new_descriptor));
9563 Handle<Map> Map::CopyAsElementsKind(Handle<Map> map, ElementsKind kind,
9582 Handle<Map> new_map = CopyForTransition(map, "CopyAsElementsKind");
9586 Handle<Name> name = isolate->factory()->elements_transition_symbol();
9592 Handle<Map> new_map = Copy(map, "CopyAsElementsKind");
9598 Handle<Map> Map::AsLanguageMode(Handle<Map> initial_map,
9608 Handle<Symbol> transition_symbol;
9611 Handle<Map> function_map(
9629 return handle(maybe_transition, isolate);
9635 Handle<Map> map =
9650 Handle<Map> Map::CopyForObserved(Handle<Map> map) {
9659 Handle<Map> new_map = CopyForTransition(map, "CopyForObserved");
9662 Handle<Name> name = isolate->factory()->observed_symbol();
9668 Handle<Map> new_map = Map::Copy(map, "CopyForObserved");
9674 Handle<Map> Map::CopyForTransition(Handle<Map> map, const char* reason) {
9676 Handle<Map> new_map = CopyDropDescriptors(map);
9687 Handle<DescriptorArray> descriptors(map->instance_descriptors());
9689 Handle<DescriptorArray> new_descriptors =
9691 Handle<LayoutDescriptor> new_layout_descriptor(map->GetLayoutDescriptor(),
9708 Handle<Map> Map::Copy(Handle<Map> map, const char* reason) {
9709 Handle<DescriptorArray> descriptors(map->instance_descriptors());
9711 Handle<DescriptorArray> new_descriptors =
9713 Handle<LayoutDescriptor> new_layout_descriptor(map->GetLayoutDescriptor(),
9721 Handle<Map> Map::Create(Isolate* isolate, int inobject_properties) {
9722 Handle<Map> copy =
9723 Copy(handle(isolate->object_function()->initial_map()), "MapCreate");
9747 Handle<Map> Map::CopyForPreventExtensions(Handle<Map> map,
9749 Handle<Symbol> transition_marker,
9753 Handle<DescriptorArray> new_desc = DescriptorArray::CopyUpToAddAttributes(
9754 handle(map->instance_descriptors(), isolate), num_descriptors,
9756 Handle<LayoutDescriptor> new_layout_descriptor(map->GetLayoutDescriptor(),
9758 Handle<Map> new_map = CopyReplaceDescriptors(
9792 Handle<Map> Map::PrepareForDataProperty(Handle<Map> map, int descriptor,
9793 Handle<Object> value) {
9800 Handle<DescriptorArray> descriptors(map->instance_descriptors());
9808 Handle<HeapType> type = value->OptimalType(isolate, representation);
9815 Handle<Map> Map::TransitionToDataProperty(Handle<Map> map, Handle<Name> name,
9816 Handle<Object> value,
9828 Handle<Map> transition(maybe_transition);
9845 Handle<HeapType> type = value->OptimalType(isolate, representation);
9850 Handle<Map> result;
9869 Handle<Map> Map::ReconfigureExistingProperty(Handle<Map> map, int descriptor,
9888 Handle<Map> new_map = ReconfigureProperty(
9895 Handle<Map> Map::TransitionToAccessorProperty(Handle<Map> map,
9896 Handle<Name> name,
9898 Handle<Object> accessor,
9915 Handle<Map> transition(maybe_transition, isolate);
9923 Handle<Object> maybe_pair(descriptors->GetValue(descriptor), isolate);
9928 Handle<AccessorPair> pair = Handle<AccessorPair>::cast(maybe_pair);
9936 Handle<AccessorPair> pair;
9952 Handle<Object> maybe_pair(old_descriptors->GetValue(descriptor), isolate);
9957 Object* current = Handle<AccessorPair>::cast(maybe_pair)->get(component);
9964 pair = AccessorPair::Copy(Handle<AccessorPair>::cast(maybe_pair));
9979 Handle<Map> Map::CopyAddDescriptor(Handle<Map> map,
9982 Handle<DescriptorArray> descriptors(map->instance_descriptors());
9995 Handle<DescriptorArray> new_descriptors =
9999 Handle<LayoutDescriptor> new_layout_descriptor =
10002 : handle(LayoutDescriptor::FastPointerLayout(), map->GetIsolate());
10010 Handle<Map> Map::CopyInsertDescriptor(Handle<Map> map,
10013 Handle<DescriptorArray> old_descriptors(map->instance_descriptors());
10027 Handle<DescriptorArray> DescriptorArray::CopyUpTo(
10028 Handle<DescriptorArray> desc,
10036 Handle<DescriptorArray> DescriptorArray::CopyUpToAddAttributes(
10037 Handle<DescriptorArray> desc,
10047 Handle<DescriptorArray> descriptors =
10066 handle(key), handle(value, desc->GetIsolate()), details);
10097 Handle<Map> Map::CopyReplaceDescriptor(Handle<Map> map,
10098 Handle<DescriptorArray> descriptors,
10105 Handle<Name> key = descriptor->GetKey();
10108 Handle<DescriptorArray> new_descriptors = DescriptorArray::CopyUpTo(
10112 Handle<LayoutDescriptor> new_layout_descriptor = LayoutDescriptor::New(
10125 void Map::UpdateCodeCache(Handle<Map> map,
10126 Handle<Name> name,
10127 Handle<Code> code) {
10132 Handle<Object> result = isolate->factory()->NewCodeCache();
10137 Handle<CodeCache> code_cache(CodeCache::cast(map->code_cache()), isolate);
10170 Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code) {
10177 Handle<Object> result =
10191 Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code) {
10199 Handle<FixedArray> cache = handle(code_cache->default_cache());
10251 Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code) {
10253 Handle<CodeCacheHashTable> cache(
10255 Handle<Object> new_cache = CodeCacheHashTable::Put(cache, name, code);
10340 CodeCacheHashTableKey(Handle<Name> name, Code::Flags flags)
10343 CodeCacheHashTableKey(Handle<Name> name, Handle<Code> code)
10370 MUST_USE_RESULT Handle<Object> AsHandle(Isolate* isolate) override {
10371 Handle<Code> code = code_.ToHandleChecked();
10372 Handle<FixedArray> pair = isolate->factory()->NewFixedArray(2);
10379 Handle<Name> name_;
10388 CodeCacheHashTableKey key(handle(name), flags);
10395 Handle<CodeCacheHashTable> CodeCacheHashTable::Put(
10396 Handle<CodeCacheHashTable> cache, Handle<Name> name, Handle<Code> code) {
10399 Handle<CodeCacheHashTable> new_cache = EnsureCapacity(cache, 1, &key);
10402 Handle<Object> k = key.AsHandle(cache->GetIsolate());
10413 CodeCacheHashTableKey key(handle(name), flags);
10428 void PolymorphicCodeCache::Update(Handle<PolymorphicCodeCache> code_cache,
10431 Handle<Code> code) {
10434 Handle<PolymorphicCodeCacheHashTable> result =
10444 Handle<PolymorphicCodeCacheHashTable> hash_table =
10445 handle(PolymorphicCodeCacheHashTable::cast(code_cache->cache()));
10446 Handle<PolymorphicCodeCacheHashTable> new_cache =
10452 Handle<Object> PolymorphicCodeCache::Lookup(MapHandleList* maps,
10457 return Handle<Object>(hash_table->Lookup(maps, flags), GetIsolate());
10518 MUST_USE_RESULT Handle<Object> AsHandle(Isolate* isolate) override {
10522 Handle<FixedArray> list =
10539 maps->Add(Handle<Map>(Map::cast(list->get(i))));
10560 Handle<PolymorphicCodeCacheHashTable> PolymorphicCodeCacheHashTable::Put(
10561 Handle<PolymorphicCodeCacheHashTable> hash_table,
10564 Handle<Code> code) {
10566 Handle<PolymorphicCodeCacheHashTable> cache =
10570 Handle<Object> obj = key.AsHandle(hash_table->GetIsolate());
10608 void WeakFixedArray::Set(Handle<WeakFixedArray> array, int index,
10609 Handle<HeapObject> value) {
10611 Handle<WeakCell> cell =
10612 value->IsMap() ? Map::WeakCellForMap(Handle<Map>::cast(value))
10614 Handle<FixedArray>::cast(array)->set(index + kFirstIndex, *cell);
10623 Handle<WeakFixedArray> WeakFixedArray::Add(Handle<Object> maybe_array,
10624 Handle<HeapObject> value,
10626 Handle<WeakFixedArray> array =
10628 ? Allocate(value->GetIsolate(), 1, Handle<WeakFixedArray>::null())
10629 : Handle<WeakFixedArray>::cast(maybe_array);
10651 Handle<WeakFixedArray> new_array =
10708 bool WeakFixedArray::Remove(Handle<HeapObject> value) {
10726 Handle<WeakFixedArray> WeakFixedArray::Allocate(
10727 Isolate* isolate, int size, Handle<WeakFixedArray> initialize_from) {
10729 Handle<FixedArray> result =
10734 Handle<FixedArray> raw_source = Handle<FixedArray>::cast(initialize_from);
10746 return Handle<WeakFixedArray>::cast(result);
10750 Handle<ArrayList> ArrayList::Add(Handle<ArrayList> array, Handle<Object> obj,
10764 Handle<ArrayList> ArrayList::Add(Handle<ArrayList> array, Handle<Object> obj1,
10765 Handle<Object> obj2, AddMode mode) {
10784 Handle<ArrayList> ArrayList::EnsureSpace(Handle<ArrayList> array, int length) {
10792 array = Handle<ArrayList>::cast(
10800 Handle<DescriptorArray> DescriptorArray::Allocate(Isolate* isolate,
10809 Handle<FixedArray> result = factory->NewFixedArray(LengthFor(size), TENURED);
10813 return Handle<DescriptorArray>::cast(result);
10829 void DescriptorArray::SetEnumCache(Handle<DescriptorArray> descriptors,
10831 Handle<FixedArray> new_cache,
10832 Handle<FixedArray> new_index_cache) {
10855 Descriptor desc(handle(src->GetKey(index)),
10856 handle(value, src->GetIsolate()),
10917 Handle<AccessorPair> AccessorPair::Copy(Handle<AccessorPair> pair) {
10918 Handle<AccessorPair> copy = pair->GetIsolate()->factory()->NewAccessorPair();
10931 Handle<DeoptimizationInputData> DeoptimizationInputData::New(
10933 return Handle<DeoptimizationInputData>::cast(
10939 Handle<DeoptimizationOutputData> DeoptimizationOutputData::New(
10943 Handle<FixedArray> result;
10950 return Handle<DeoptimizationOutputData>::cast(result);
10955 Handle<LiteralsArray> LiteralsArray::New(Isolate* isolate,
10956 Handle<TypeFeedbackVector> vector,
10959 Handle<FixedArray> literals = isolate->factory()->NewFixedArray(
10961 Handle<LiteralsArray> casted_literals = Handle<LiteralsArray>::cast(literals);
11026 MaybeHandle<String> Name::ToFunctionName(Handle<Name> name) {
11027 if (name->IsString()) return Handle<String>::cast(name);
11030 Handle<Object> description(Handle<Symbol>::cast(name)->name(), isolate);
11034 builder.AppendString(Handle<String>::cast(description));
11067 Handle<Object> String::ToNumber(Handle<String> subject) {
11082 if (len == 0) return handle(Smi::FromInt(0), isolate);
11085 uint8_t const* data = Handle<SeqOneByteString>::cast(subject)->GetChars();
11118 return handle(Smi::FromInt(d), isolate);
11322 FlatStringReader::FlatStringReader(Isolate* isolate, Handle<String> str)
11340 Handle<String> str(str_);
11643 Handle<FixedArray> String::CalculateLineEnds(Handle<String> src,
11668 Handle<FixedArray> array = isolate->factory()->NewFixedArray(line_count);
11869 bool String::SlowEquals(Handle<String> one, Handle<String> two) {
11920 ComparisonResult String::Compare(Handle<String> x, Handle<String> y) {
12081 Handle<String> SeqString::Truncate(Handle<SeqString> string, int new_length) {
12151 // Handle some edge cases
12352 Handle<SharedFunctionInfo> shared, Handle<Code> code) {
12358 Handle<WeakCell> cell = isolate->factory()->NewWeakCell(code);
12369 Handle<SharedFunctionInfo> shared, Handle<Context> native_context,
12370 Handle<HeapObject> code, Handle<LiteralsArray> literals,
12380 Handle<FixedArray> new_code_map;
12389 Handle<FixedArray> old_code_map(shared->optimized_code_map(), isolate);
12400 Handle<WeakCell> code_cell = isolate->factory()->NewWeakCell(code);
12403 Handle<WeakCell> literals_cell =
12433 Handle<WeakCell> code_cell = code->IsUndefined()
12436 Handle<WeakCell> literals_cell = isolate->factory()->NewWeakCell(literals);
12588 static bool PrototypeBenefitsFromNormalization(Handle<JSObject> object) {
12608 void JSObject::OptimizeAsPrototype(Handle<JSObject> object,
12616 Handle<Map> previous_map(object->map());
12622 Handle<Map> new_map = Map::Copy(handle(object->map()), "CopyAsPrototype");
12646 void JSObject::ReoptimizeIfPrototype(Handle<JSObject> object) {
12653 void JSObject::LazyRegisterPrototypeUser(Handle<Map> user, Isolate* isolate) {
12659 Handle<Map> current_user = user;
12660 Handle<PrototypeInfo> current_user_info =
12667 Handle<Object> maybe_proto = PrototypeIterator::GetCurrent(iter);
12671 Handle<JSObject> proto = Handle<JSObject>::cast(maybe_proto);
12672 Handle<PrototypeInfo> proto_info =
12674 Handle<Object> maybe_registry(proto_info->prototype_users(), isolate);
12676 Handle<WeakFixedArray> new_array =
12689 current_user = handle(proto->map(), isolate);
12698 bool JSObject::UnregisterPrototypeUser(Handle<Map> user, Isolate* isolate) {
12709 Handle<JSObject> prototype(JSObject::cast(user->prototype()), isolate);
12710 Handle<PrototypeInfo> user_info =
12718 Handle<PrototypeInfo> proto_info(PrototypeInfo::cast(maybe_proto_info),
12767 Handle<PrototypeInfo> Map::GetOrCreatePrototypeInfo(Handle<JSObject> prototype,
12771 return handle(PrototypeInfo::cast(maybe_proto_info), isolate);
12773 Handle<PrototypeInfo> proto_info = isolate->factory()->NewPrototypeInfo();
12780 Handle<PrototypeInfo> Map::GetOrCreatePrototypeInfo(Handle<Map> prototype_map,
12784 return handle(PrototypeInfo::cast(maybe_proto_info), isolate);
12786 Handle<PrototypeInfo> proto_info = isolate->factory()->NewPrototypeInfo();
12793 Handle<Cell> Map::GetOrCreatePrototypeChainValidityCell(Handle<Map> map,
12795 Handle<Object> maybe_prototype(map->prototype(), isolate);
12796 if (!maybe_prototype->IsJSObject()) return Handle<Cell>::null();
12797 Handle<JSObject> prototype = Handle<JSObject>::cast(maybe_prototype);
12800 JSObject::LazyRegisterPrototypeUser(handle(prototype->map(), isolate),
12802 Handle<PrototypeInfo> proto_info =
12807 Handle<Cell> cell(Cell::cast(maybe_cell), isolate);
12813 Handle<Cell> cell = isolate->factory()->NewCell(
12814 handle(Smi::FromInt(Map::kPrototypeChainValid), isolate));
12821 void Map::SetPrototype(Handle<Map> map, Handle<Object> prototype,
12824 Handle<JSObject> prototype_jsobj = Handle<JSObject>::cast(prototype);
12833 Handle<Object> CacheInitialJSArrayMaps(
12834 Handle<Context> native_context, Handle<Map> initial_map) {
12839 Handle<Map> current_map = initial_map;
12845 Handle<Map> new_map;
12848 new_map = handle(maybe_elements_transition);
12861 void JSFunction::SetInstancePrototype(Handle<JSFunction> function,
12862 Handle<Object> value) {
12876 Handle<Map> initial_map(function->initial_map(), isolate);
12885 Handle<Map> new_map = Map::Copy(initial_map, "SetInstancePrototype");
12893 Handle<Context> native_context(function->context()->native_context(),
12895 Handle<Object> array_function(
12900 Handle<Map> new_strong_map = Map::Copy(new_map, "SetInstancePrototype");
12916 JSObject::OptimizeAsPrototype(Handle<JSObject>::cast(value),
12924 void JSFunction::SetPrototype(Handle<JSFunction> function,
12925 Handle<Object> value) {
12927 Handle<Object> construct_prototype = value;
12937 Handle<Map> new_map = Map::Copy(handle(function->map()), "SetPrototype");
12943 construct_prototype = handle(
12977 void JSFunction::SetInitialMap(Handle<JSFunction> function, Handle<Map> map,
12978 Handle<Object> prototype) {
13064 void JSFunction::EnsureHasInitialMap(Handle<JSFunction> function) {
13086 Handle<Map> map = isolate->factory()->NewMap(instance_type, instance_size);
13092 Handle<Object> prototype;
13094 prototype = handle(function->instance_prototype(), isolate);
13111 Handle<JSFunction> constructor,
13112 Handle<JSReceiver> new_target) {
13115 Handle<Map> constructor_initial_map(constructor->initial_map(), isolate);
13122 Handle<JSFunction> function = Handle<JSFunction>::cast(new_target);
13128 return handle(function->initial_map(), isolate);
13137 Handle<Object> prototype(function->instance_prototype(), isolate);
13151 Handle<Map> map =
13166 Handle<Object> prototype;
13168 Handle<JSFunction> function = Handle<JSFunction>::cast(new_target);
13171 prototype = handle(function->prototype(), isolate);
13173 Handle<String> prototype_string = isolate->factory()->prototype_string();
13180 constructor_initial_map = handle(constructor->initial_map(), isolate);
13188 Handle
13192 Handle<Object> maybe_index = JSReceiver::GetDataProperty(
13196 Handle<JSFunction> realm_constructor(JSFunction::cast(context->get(index)));
13197 prototype = handle(realm_constructor->prototype(), isolate);
13200 Handle<Map> map = Map::CopyInitialMap(constructor_initial_map);
13254 Handle<String> JSFunction::GetName(Handle<JSFunction> function) {
13256 Handle<Object> name =
13258 if (name->IsString()) return Handle<String>::cast(name);
13259 return handle(function->shared()->DebugName(), isolate);
13263 Handle<String> JSFunction::GetDebugName(Handle<JSFunction> function) {
13265 Handle<Object> name = JSReceiver::GetDataProperty(
13267 if (name->IsString()) return Handle<String>::cast(name);
13277 Handle<String> NativeCodeFunctionSourceString(
13278 Handle<SharedFunctionInfo> shared_info) {
13283 builder.AppendString(handle(String::cast(shared_info->name()), isolate));
13294 Handle<String> JSBoundFunction::ToString(Handle<JSBoundFunction> function) {
13301 Handle<String> JSFunction::ToString(Handle<JSFunction> function) {
13303 Handle<SharedFunctionInfo> shared_info(function->shared(), isolate);
13312 Handle<Object> class_start_position = JSReceiver::GetDataProperty(
13315 Handle<Object> class_end_position = JSReceiver::GetDataProperty(
13317 Handle<String> script_source(
13320 script_source, Handle<Smi>::cast(class_start_position)->value(),
13321 Handle<Smi>::cast(class_end_position)->value());
13343 builder.AppendString(handle(String::cast(shared_info->name()), isolate));
13346 builder.AppendString(Handle<String>::cast(shared_info->GetSourceCode()));
13351 void Oddball::Initialize(Isolate* isolate, Handle<Oddball> oddball,
13352 const char* to_string, Handle<Object> to_number,
13354 Handle<String> internalized_to_string =
13356 Handle<String> internalized_type_of =
13365 void Script::InitLineEnds(Handle<Script> script) {
13372 Handle<FixedArray> empty = isolate->factory()->NewFixedArray(0);
13378 Handle<String> src(String::cast(script->source()), isolate);
13380 Handle<FixedArray> array = String::CalculateLineEnds(src, true);
13391 int Script::GetColumnNumber(Handle<Script> script, int code_pos) {
13429 int Script::GetLineNumber(Handle<Script> script, int code_pos) {
13453 Handle<Object> Script::GetNameOrSourceURL(Handle<Script> script) {
13455 Handle<String> name_or_source_url_key =
13458 Handle<JSObject> script_wrapper = Script::GetWrapper(script);
13459 Handle<Object> property = Object::GetProperty(
13462 Handle<Object> result;
13473 Handle<JSObject> Script::GetWrapper(Handle<Script> script) {
13477 Handle<WeakCell> cell(WeakCell::cast(script->wrapper()));
13479 // Return a handle for the existing script wrapper from the cache.
13480 return handle(JSObject::cast(cell->value()));
13489 Handle<JSFunction> constructor = isolate->script_function();
13490 Handle<JSValue> result =
13491 Handle<JSValue>::cast(isolate->factory()->NewJSObject(constructor));
13493 Handle<WeakCell> cell = isolate->factory()->NewWeakCell(result);
13506 return Handle<SharedFunctionInfo>(shared);
13542 void SharedFunctionInfo::SetScript(Handle<SharedFunctionInfo> shared,
13543 Handle<Object> script_object) {
13551 Handle<Object> list;
13553 Handle<Script> script = Handle<Script>::cast(script_object);
13554 list = handle(script->shared_function_infos(), isolate);
13571 Handle<Script> script = Handle<Script>::cast(script_object);
13609 Handle<Object> SharedFunctionInfo::GetSourceCode() {
13611 Handle<String> source(String::cast(Script::cast(script())->source()));
13771 Handle<SharedFunctionInfo> shared_info, FunctionLiteral* lit) {
14039 Handle<Object> p = it.rinfo()->target_object_handle(origin);
14042 Handle<Cell> cell = it.rinfo()->target_cell_handle();
14047 Handle<Object> p = it.rinfo()->target_object_handle(origin);
14057 Handle<Object> p = it.rinfo()->code_age_stub_handle(origin);
14192 if (object->IsMap()) maps->Add(handle(Map::cast(object)));
14239 code_list->Add(Handle<Code>(code));
14263 return handle(code);
14548 Handle<WeakCell> Code::WeakCellFor(Handle<Code> code) {
14551 if (raw_cell != NULL) return Handle<WeakCell>(raw_cell);
14552 Handle<WeakCell> cell = code->GetIsolate()->factory()->NewWeakCell(code);
15045 void JSArray::Initialize(Handle<JSArray> array, int capacity, int length) {
15056 Handle<JSObject> object,
15058 List<Handle<Object> >* old_values,
15064 Handle<Object> value =
15066 ? Handle<Object>::cast(isolate->factory()->the_hole_value())
15074 void JSArray::SetLength(Handle<JSArray> array, uint32_t new_length) {
15084 MaybeHandle<Object> JSArray::ObservableSetLength(Handle<JSArray> array,
15093 List<Handle<Object> > old_values;
15094 Handle<Object> old_length_handle(array->length(), isolate);
15109 Handle<FixedArray> keys = isolate->factory()->NewFixedArray(num_elements);
15149 Handle<JSArray> deleted = isolate->factory()->NewJSArray(0);
15170 void Map::AddDependentCode(Handle<Map> map,
15172 Handle<Code> code) {
15173 Handle<WeakCell> cell = Code::WeakCellFor(code);
15174 Handle<DependentCode> codes = DependentCode::InsertWeakCode(
15175 Handle<DependentCode>(map->dependent_code()), group, cell);
15180 Handle<DependentCode> DependentCode::InsertCompilationDependencies(
15181 Handle<DependentCode> entries, DependencyGroup group,
15182 Handle<Foreign> info) {
15187 Handle<DependentCode> DependentCode::InsertWeakCode(
15188 Handle<DependentCode> entries, DependencyGroup group,
15189 Handle<WeakCell> code_cell) {
15194 Handle<DependentCode> DependentCode::Insert(Handle<DependentCode> entries,
15196 Handle<Object> object) {
15203 Handle<DependentCode> old_next(entries->next_link());
15204 Handle<DependentCode> new_next = Insert(old_next, group, object);
15227 Handle<DependentCode> DependentCode::New(DependencyGroup group,
15228 Handle<Object> object,
15229 Handle<DependentCode> next) {
15231 Handle<DependentCode> result = Handle<DependentCode>::cast(
15240 Handle<DependentCode> DependentCode::EnsureSpace(
15241 Handle<DependentCode> entries) {
15246 return Handle<DependentCode>::cast(
15465 Handle<Map> Map::TransitionToPrototype(Handle<Map> map,
15466 Handle<Object> prototype,
15468 Handle<Map> new_map = TransitionArray::GetPrototypeTransition(map, prototype);
15478 Maybe<bool> JSReceiver::SetPrototype(Handle<JSReceiver> object,
15479 Handle<Object> value, bool from_javascript,
15482 return JSProxy::SetPrototype(Handle<JSProxy>::cast(object), value,
15485 return JSObject::SetPrototype(Handle<JSObject>::cast(object), value,
15492 Maybe<bool> JSProxy::SetPrototype(Handle<JSProxy> proxy, Handle<Object> value,
15497 Handle<Name> trap_name = isolate->factory()->setPrototypeOf_string();
15501 Handle<Object> handler(proxy->handler(), isolate);
15510 Handle<JSReceiver> target(proxy->target(), isolate);
15512 Handle<Object> trap;
15515 Object::GetMethod(Handle<JSReceiver>::cast(handler), trap_name),
15523 Handle<Object> argv[] = {target, value};
15524 Handle<Object> trap_result;
15541 Handle<Object> target_proto;
15560 Maybe<bool> JSObject::SetPrototype(Handle<JSObject> object,
15561 Handle<Object> value, bool from_javascript,
15566 Handle<Object> old_value;
15578 Handle<Object> new_value;
15595 Maybe<bool> JSObject::SetPrototypeUnobserved(Handle<JSObject> object,
15596 Handle<Object> value,
15607 !isolate->MayAccess(handle(isolate->context()), object)) {
15632 Handle<JSObject> real_receiver = object;
15645 Handle<Map> map(real_receiver->map());
15682 Handle<Map> new_map = Map::TransitionToPrototype(map, value, mode);
15700 void JSObject::EnsureCanContainElements(Handle<JSObject> object,
15718 void JSObject::ValidateElements(Handle<JSObject> object) {
15757 Handle<FixedArrayBase> backing_store(FixedArrayBase::cast(elements()));
15817 MaybeHandle<Object> JSObject::AddDataElement(Handle<JSObject> object,
15819 Handle<Object> value,
15828 Maybe<bool> JSObject::AddDataElement(Handle<JSObject> object, uint32_t index,
15829 Handle<Object> value,
15839 Handle<Object> old_length_handle;
15843 old_length_handle = handle(JSArray::cast(*object)->length(), isolate);
15879 Handle<Object> new_length_handle;
15889 Handle<JSArray> array = Handle<JSArray>::cast(object);
15890 Handle<String> name = isolate->factory()->Uint32ToString(index);
15905 Handle<JSArray> deleted = isolate->factory()->NewJSArray(0);
15911 Handle<String> name = isolate->factory()->Uint32ToString(index);
15963 void AllocationSite::DigestTransitionFeedback(Handle<AllocationSite> site,
15968 Handle<JSArray> transition_info =
15969 handle(JSArray::cast(site->transition_info()));
16029 void JSObject::UpdateAllocationSite(Handle<JSObject> object,
16036 Handle<AllocationSite> site;
16044 site = handle(memento->GetAllocationSite());
16050 void JSObject::TransitionElementsKind(Handle<JSObject> object,
16071 Handle<Map> new_map = GetElementsTransitionMap(object, to_kind);
16074 Handle<FixedArrayBase> elms(object->elements());
16102 bool JSArray::HasReadOnlyLength(Handle<JSArray> array) {
16112 bool JSArray::WouldChangeReadOnlyLength(Handle<JSArray> array,
16225 Handle<InterceptorInfo> interceptor = it->GetInterceptor();
16230 Handle<JSObject> holder = it->GetHolder<JSObject>();
16243 Handle<Name> name = it->name();
16260 Handle<Object> result_internal = v8::Utils::OpenHandle(*result);
16263 // Rebox handle before return
16264 return handle(*result_internal, isolate);
16268 Maybe<bool> JSObject::HasRealNamedProperty(Handle<JSObject> object,
16269 Handle<Name> name) {
16276 Maybe<bool> JSObject::HasRealElementProperty(Handle<JSObject> object,
16285 Maybe<bool> JSObject::HasRealNamedCallbackProperty(Handle<JSObject> object,
16286 Handle<Name> name) {
16412 Handle<DescriptorArray> descs(map()->instance_descriptors());
16427 GlobalDictionary::CollectKeysTo(handle(global_dictionary()), keys, filter);
16429 NameDictionary::CollectKeysTo(handle(property_dictionary()), keys, filter);
16449 void JSObject::CollectOwnElementKeys(Handle<JSObject> object,
16603 Handle<Object> object) {
16607 Handle<JSReceiver> receiver;
16610 Handle<String> tag;
16612 Handle<Object> to_string_tag;
16618 tag = Handle<String>::cast(to_string_tag);
16663 StringSharedKey(Handle<String> source, Handle<SharedFunctionInfo> shared,
16733 Handle<Object> AsHandle(Isolate* isolate) override {
16734 Handle<FixedArray> array = isolate->factory()->NewFixedArray(4);
16743 Handle<String> source_;
16744 Handle<SharedFunctionInfo> shared_;
16752 JSRegExp::Flags RegExpFlagsFromString(Handle<String> flags, bool* success) {
16792 MaybeHandle<JSRegExp> JSRegExp::New(Handle<String> pattern, Flags flags) {
16794 Handle<JSFunction> constructor = isolate->regexp_function();
16795 Handle<JSRegExp> regexp =
16796 Handle<JSRegExp>::cast(isolate->factory()->NewJSObject(constructor));
16803 MaybeHandle<JSRegExp> JSRegExp::New(Handle<String> pattern,
16804 Handle<String> flags_string) {
16819 Handle<JSRegExp> JSRegExp::Copy(Handle<JSRegExp> regexp) {
16821 return Handle<JSRegExp>::cast(isolate->factory()->CopyJSObject(regexp));
16826 inline int CountRequiredEscapes(Handle<String> source) {
16838 inline Handle<StringType> WriteEscapedRegExpSource(Handle<String> source,
16839 Handle<StringType> result) {
16855 Handle<String> source) {
16864 Handle<SeqOneByteString> result;
16870 Handle<SeqTwoByteString> result;
16880 MaybeHandle<JSRegExp> JSRegExp::Initialize(Handle<JSRegExp> regexp,
16881 Handle<String> source,
16882 Handle<String> flags_string) {
16897 MaybeHandle<JSRegExp> JSRegExp::Initialize(Handle<JSRegExp> regexp,
16898 Handle<String> source, Flags flags) {
16905 Handle<String> escaped_source;
16925 Handle
16939 RegExpKey(Handle<String> string, JSRegExp::Flags flags)
16954 Handle<Object> AsHandle(Isolate* isolate) override {
16971 Handle<String> string_;
16976 Handle<Object> OneByteStringKey::AsHandle(Isolate* isolate) {
16982 Handle<Object> TwoByteStringKey::AsHandle(Isolate* isolate) {
16988 Handle<Object> SeqOneByteSubStringKey::AsHandle(Isolate* isolate) {
17004 explicit InternalizedStringKey(Handle<String> string)
17017 Handle<Object> AsHandle(Isolate* isolate) override {
17021 Handle<Map> map;
17036 Handle<String> string_;
17054 Handle<Derived> HashTable<Derived, Shape, Key>::New(
17071 Handle<FixedArray> array = factory->NewFixedArray(length, pretenure);
17073 Handle<Derived> table = Handle<Derived>::cast(array);
17084 int NameDictionaryBase<Derived, Shape>::FindEntry(Handle<Name> key) {
17125 Handle<Derived> new_table,
17228 Handle<Derived> HashTable<Derived, Shape, Key>::EnsureCapacity(
17229 Handle<Derived> table,
17243 Handle<Derived> new_table = HashTable::New(
17271 Handle<Derived> HashTable<Derived, Shape, Key>::Shrink(Handle<Derived> table,
17291 Handle<Derived> new_table = HashTable::New(
17328 Handle<Object> >;
17330 template class HashTable<WeakHashTable, WeakHashTableShape<2>, Handle<Object> >;
17332 template class Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >;
17335 Handle<Name> >;
17345 template Handle<SeededNumberDictionary>
17349 template Handle<UnseededNumberDictionary>
17353 template Handle<NameDictionary>
17354 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
17357 template Handle<GlobalDictionary>
17358 Dictionary<GlobalDictionary, GlobalDictionaryShape, Handle<Name> >::New(
17361 template Handle<SeededNumberDictionary>
17363 AtPut(Handle<SeededNumberDictionary>, uint32_t, Handle<Object>);
17365 template Handle<UnseededNumberDictionary>
17367 AtPut(Handle<UnseededNumberDictionary>, uint32_t, Handle<Object>);
17374 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
17377 template Handle<Object>
17378 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::DeleteProperty(
17379 Handle<NameDictionary>, int);
17381 template Handle<Object>
17383 uint32_t>::DeleteProperty(Handle<SeededNumberDictionary>, int);
17385 template Handle<NameDictionary>
17386 HashTable<NameDictionary, NameDictionaryShape, Handle<Name> >::
17389 template Handle<NameDictionary>
17390 HashTable<NameDictionary, NameDictionaryShape, Handle<Name> >::
17391 Shrink(Handle<NameDictionary>, Handle<Name>);
17393 template Handle<SeededNumberDictionary>
17395 Shrink(Handle<SeededNumberDictionary>, uint32_t);
17397 template Handle<NameDictionary>
17398 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::Add(
17399 Handle<NameDictionary>, Handle<Name>, Handle<Object>, PropertyDetails);
17401 template Handle<GlobalDictionary>
17402 Dictionary<GlobalDictionary, GlobalDictionaryShape, Handle<Name> >::Add(
17403 Handle<GlobalDictionary>, Handle<Name>, Handle<Object>,
17406 template Handle<FixedArray> Dictionary<
17408 Handle<Name> >::BuildIterationIndicesArray(Handle<NameDictionary>);
17410 template Handle<FixedArray> Dictionary<
17412 Handle<Name> >::GenerateNewEnumerationIndices(Handle<NameDictionary>);
17414 template Handle<SeededNumberDictionary>
17416 Add(Handle<SeededNumberDictionary>,
17418 Handle<Object>,
17421 template Handle<UnseededNumberDictionary>
17423 Add(Handle<UnseededNumberDictionary>,
17425 Handle<Object>,
17428 template Handle<SeededNumberDictionary>
17430 EnsureCapacity(Handle<SeededNumberDictionary>, int, uint32_t);
17432 template Handle<UnseededNumberDictionary>
17434 EnsureCapacity(Handle<UnseededNumberDictionary>, int, uint32_t);
17437 Handle<Name> >::SetRequiresCopyOnCapacityChange();
17439 template Handle<NameDictionary>
17440 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
17441 EnsureCapacity(Handle<NameDictionary>, int, Handle<Name>);
17450 Handle<Name>);
17453 Handle<Object> JSObject::PrepareSlowElementsForSort(
17454 Handle<JSObject> object, uint32_t limit) {
17460 Handle<SeededNumberDictionary> dict(object->element_dictionary(), isolate);
17461 Handle<SeededNumberDictionary> new_dict =
17467 Handle<Smi> bailout(Smi::FromInt(-1), isolate);
17481 Handle<Object> value(dict->ValueAt(i), isolate);
17498 Handle<Object> result = SeededNumberDictionary::AddNumberEntry(
17509 Handle<Object> result = SeededNumberDictionary::AddNumberEntry(
17525 Handle<Object> result = SeededNumberDictionary::AddNumberEntry(
17545 Handle<Object> JSObject::PrepareElementsForSort(Handle<JSObject> object,
17550 return handle(Smi::FromInt(-1), isolate);
17556 Handle<SeededNumberDictionary> dict(object->element_dictionary());
17563 Handle<Map> new_map =
17568 Handle<FixedArray> fast_elements =
17576 return handle(Smi::FromInt(
17587 Handle<FixedArrayBase> elements_base(object->elements());
17593 return handle(Smi::FromInt(0), isolate);
17706 void JSGlobalObject::InvalidatePropertyCell(Handle<JSGlobalObject> global,
17707 Handle<Name> name) {
17709 auto dictionary = handle(global->global_dictionary());
17717 Handle<PropertyCell> JSGlobalObject::EnsurePropertyCell(
17718 Handle<JSGlobalObject> global, Handle<Name> name) {
17720 auto dictionary = handle(global->global_dictionary());
17722 Handle<PropertyCell> cell;
17726 cell = handle(PropertyCell::cast(dictionary->ValueAt(entry)));
17793 Handle<Object> AsHandle(Isolate* isolate) override {
17809 Handle<String> string) {
17819 Handle<String> string) {
17820 Handle<StringTable> string_table = isolate->factory()->string_table();
17826 Handle<String> result(String::cast(string_table->KeyAt(entry)), isolate);
17837 Handle<StringTable> string_table = isolate->factory()->string_table();
17843 Handle<String> result(String::cast(string_table->KeyAt(entry)), isolate);
17852 Handle<StringTable> table = isolate->factory()->string_table();
17854 InternalizedStringKey dummy_key(Handle<String>::null());
17860 Handle<String> StringTable::LookupString(Isolate* isolate,
17861 Handle<String> string) {
17867 Handle<String> StringTable::LookupKey(Isolate* isolate, HashTableKey* key) {
17868 Handle<StringTable> table = isolate->factory()->string_table();
17873 return handle(String::cast(table->KeyAt(entry)), isolate);
17880 Handle<Object> string = key->AsHandle(isolate);
17891 return Handle<String>::cast(string);
17896 Handle<StringTable> table = isolate->factory()->string_table();
17903 Handle<Object> CompilationCacheTable::Lookup(Handle<String> src,
17904 Handle<Context> context,
17907 Handle<SharedFunctionInfo> shared(context->closure()->shared());
17913 return Handle<Object>(get(index + 1), isolate);
17917 Handle<Object> CompilationCacheTable::LookupEval(
17918 Handle<String> src, Handle<SharedFunctionInfo> outer_info,
17928 return Handle<Object>(get(EntryToIndex(entry) + 1), isolate);
17932 Handle<Object> CompilationCacheTable::LookupRegExp(Handle<String> src,
17939 return Handle<Object>(get(EntryToIndex(entry) + 1), isolate);
17943 Handle<CompilationCacheTable> CompilationCacheTable::Put(
17944 Handle<CompilationCacheTable> cache, Handle<String> src,
17945 Handle<Context> context, LanguageMode language_mode, Handle<Object> value) {
17947 Handle<SharedFunctionInfo> shared(context->closure()->shared());
17950 Handle<Object> k = key.AsHandle(isolate);
17962 Handle<Object> k =
17971 Handle<CompilationCacheTable> CompilationCacheTable::PutEval(
17972 Handle<CompilationCacheTable> cache, Handle<String> src,
17973 Handle<SharedFunctionInfo> outer_info, Handle<SharedFunctionInfo> value,
17978 Handle<Object> k = key.AsHandle(isolate);
17990 Handle<Object> k =
17999 Handle<CompilationCacheTable> CompilationCacheTable::PutRegExp(
18000 Handle<CompilationCacheTable> cache, Handle<String> src,
18001 JSRegExp::Flags flags, Handle<FixedArray> value) {
18062 explicit StringsKey(Handle<FixedArray> strings) : strings_(strings) { }
18086 Handle<Object> AsHandle(Isolate* isolate) override { return strings_; }
18089 Handle<FixedArray> strings_;
18094 Handle<Derived> Dictionary<Derived, Shape, Key>::New(
18099 Handle<Derived> dict = DerivedHashTable::New(isolate,
18111 Handle<FixedArray> Dictionary<Derived, Shape, Key>::BuildIterationIndicesArray(
18112 Handle<Derived> dictionary) {
18116 Handle<FixedArray> iteration_order = factory->NewFixedArray(length);
18117 Handle<FixedArray> enumeration_order = factory->NewFixedArray(length);
18140 Handle<FixedArray>
18142 Handle<Derived> dictionary) {
18145 Handle<FixedArray> iteration_order = BuildIterationIndicesArray(dictionary);
18178 Handle<Derived> Dictionary<Derived, Shape, Key>::EnsureCapacity(
18179 Handle<Derived> dictionary, int n, Key key) {
18191 Handle<Object> Dictionary<Derived, Shape, Key>::DeleteProperty(
18192 Handle<Derived> dictionary, int entry) {
18205 Handle<Derived> Dictionary<Derived, Shape, Key>::AtPut(
18206 Handle<Derived> dictionary, Key key, Handle<Object> value) {
18228 Handle<Derived> Dictionary<Derived, Shape, Key>::Add(
18229 Handle<Derived> dictionary,
18231 Handle<Object> value,
18246 Handle<Derived> dictionary,
18248 Handle<Object> value,
18252 Handle<Object> k = Shape::AsHandle(dictionary->GetIsolate(), key);
18295 Handle<SeededNumberDictionary> SeededNumberDictionary::AddNumberEntry(
18296 Handle<SeededNumberDictionary> dictionary, uint32_t key,
18297 Handle<Object> value, PropertyDetails details, bool used_as_prototype) {
18304 Handle<UnseededNumberDictionary> UnseededNumberDictionary::AddNumberEntry(
18305 Handle<UnseededNumberDictionary> dictionary,
18307 Handle<Object> value) {
18313 Handle<SeededNumberDictionary> SeededNumberDictionary::AtNumberPut(
18314 Handle<SeededNumberDictionary> dictionary, uint32_t key,
18315 Handle<Object> value, bool used_as_prototype) {
18321 Handle<UnseededNumberDictionary> UnseededNumberDictionary::AtNumberPut(
18322 Handle<UnseededNumberDictionary> dictionary,
18324 Handle<Object> value) {
18329 Handle<SeededNumberDictionary> SeededNumberDictionary::Set(
18330 Handle<SeededNumberDictionary> dictionary, uint32_t key,
18331 Handle<Object> value, PropertyDetails details, bool used_as_prototype) {
18338 Handle<Object> object_key =
18345 Handle<UnseededNumberDictionary> UnseededNumberDictionary::Set(
18346 Handle<UnseededNumberDictionary> dictionary,
18348 Handle<Object> value) {
18351 Handle<Object> object_key =
18457 Handle<Dictionary<Derived, Shape, Key> > dictionary, KeyAccumulator* keys,
18460 Handle<FixedArray> array =
18517 Object* ObjectHashTable::Lookup(Isolate* isolate, Handle<Object> key,
18528 Object* ObjectHashTable::Lookup(Handle<Object> key) {
18543 Object* ObjectHashTable::Lookup(Handle<Object> key, int32_t hash) {
18548 Handle<ObjectHashTable> ObjectHashTable::Put(Handle<ObjectHashTable> table,
18549 Handle<Object> key,
18550 Handle<Object> value) {
18562 Handle<ObjectHashTable> ObjectHashTable::Put(Handle<ObjectHashTable> table,
18563 Handle<Object> key,
18564 Handle<Object> value,
18586 Handle<ObjectHashTable> ObjectHashTable::Remove(Handle<ObjectHashTable> table,
18587 Handle<Object> key,
18601 Handle<ObjectHashTable> ObjectHashTable::Remove(Handle<ObjectHashTable> table,
18602 Handle<Object> key,
18633 Object* WeakHashTable::Lookup(Handle<HeapObject> key) {
18642 Handle<WeakHashTable> WeakHashTable::Put(Handle<WeakHashTable> table,
18643 Handle<HeapObject> key,
18644 Handle<HeapObject> value) {
18653 Handle<WeakCell> key_cell = key->GetIsolate()->factory()->NewWeakCell(key);
18663 void WeakHashTable::AddEntry(int entry, Handle<WeakCell> key_cell,
18664 Handle<HeapObject> value) {
18673 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Allocate(
18685 Handle<FixedArray> backing_store = isolate->factory()->NewFixedArray(
18689 Handle<Derived> table = Handle<Derived>::cast(backing_store);
18701 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::EnsureGrowable(
18702 Handle<Derived> table) {
18717 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Shrink(
18718 Handle<Derived> table) {
18729 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Clear(
18730 Handle<Derived> table) {
18733 Handle<Derived> new_table =
18746 Handle<Derived> table, Handle<Object> key) {
18758 Handle<OrderedHashSet> OrderedHashSet::Add(Handle<OrderedHashSet> table,
18759 Handle<Object> key) {
18788 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Rehash(
18789 Handle<Derived> table, int new_capacity) {
18792 Handle<Derived> new_table =
18832 template Handle<OrderedHashSet>
18836 template Handle<OrderedHashSet>
18838 Handle<OrderedHashSet> table);
18840 template Handle<OrderedHashSet>
18842 Handle<OrderedHashSet> table);
18844 template Handle<OrderedHashSet>
18846 Handle<OrderedHashSet> table);
18849 Handle<OrderedHashSet> table, Handle<Object> key);
18852 template Handle<OrderedHashMap>
18856 template Handle<OrderedHashMap>
18858 Handle<OrderedHashMap> table);
18860 template Handle<OrderedHashMap>
18862 Handle<OrderedHashMap> table);
18864 template Handle<OrderedHashMap>
18866 Handle<OrderedHashMap> table);
18869 Handle<OrderedHashMap> table, Handle<Object> key);
18976 void JSSet::Initialize(Handle<JSSet> set, Isolate* isolate) {
18977 Handle<OrderedHashSet> table = isolate->factory()->NewOrderedHashSet();
18982 void JSSet::Clear(Handle<JSSet> set) {
18983 Handle<OrderedHashSet> table(OrderedHashSet::cast(set->table()));
18989 void JSMap::Initialize(Handle<JSMap> map, Isolate* isolate) {
18990 Handle<OrderedHashMap> table = isolate->factory()->NewOrderedHashMap();
18995 void JSMap::Clear(Handle<JSMap> map) {
18996 Handle<OrderedHashMap> table(OrderedHashMap::cast(map->table()));
19002 void JSWeakCollection::Initialize(Handle<JSWeakCollection> weak_collection,
19004 Handle<ObjectHashTable> table = ObjectHashTable::New(isolate, 0);
19009 void JSWeakCollection::Set(Handle<JSWeakCollection> weak_collection,
19010 Handle<Object> key, Handle<Object> value,
19013 Handle<ObjectHashTable> table(
19016 Handle<ObjectHashTable> new_table =
19026 bool JSWeakCollection::Delete(Handle<JSWeakCollection> weak_collection,
19027 Handle<Object> key, int32_t hash) {
19029 Handle<ObjectHashTable> table(
19033 Handle<ObjectHashTable> new_table =
19068 void DebugInfo::ClearBreakPoint(Handle<DebugInfo> debug_info,
19070 Handle<Object> break_point_object) {
19071 Handle<Object> break_point_info(debug_info->GetBreakPointInfo(code_position),
19075 Handle<BreakPointInfo>::cast(break_point_info),
19080 void DebugInfo::SetBreakPoint(Handle<DebugInfo> debug_info,
19084 Handle<Object> break_point_object) {
19086 Handle<Object> break_point_info(debug_info->GetBreakPointInfo(code_position),
19090 Handle<BreakPointInfo>::cast(break_point_info),
19106 Handle<FixedArray> old_break_points =
19107 Handle<FixedArray>(FixedArray::cast(debug_info->break_points()));
19108 Handle<FixedArray> new_break_points =
19122 Handle<BreakPointInfo> new_break_point_info = Handle<BreakPointInfo>::cast(
19135 Handle<Object> DebugInfo::GetBreakPointObjects(int code_position) {
19140 return Handle<Object>(
19161 Handle<Object> DebugInfo::FindBreakPointInfo(
19162 Handle<DebugInfo> debug_info, Handle<Object> break_point_object) {
19167 Handle<BreakPointInfo> break_point_info = Handle<BreakPointInfo>(
19198 void BreakPointInfo::ClearBreakPoint(Handle<BreakPointInfo> break_point_info,
19199 Handle<Object> break_point_object) {
19213 Handle<FixedArray> old_array =
19214 Handle<FixedArray>(
19216 Handle<FixedArray> new_array =
19233 void BreakPointInfo::SetBreakPoint(Handle<BreakPointInfo> break_point_info,
19234 Handle<Object> break_point_object) {
19246 Handle<FixedArray> array = isolate->factory()->NewFixedArray(2);
19253 Handle<FixedArray> old_array =
19254 Handle<FixedArray>(
19256 Handle<FixedArray> new_array =
19270 Handle<BreakPointInfo> break_point_info,
19271 Handle<Object> break_point_object) {
19301 MaybeHandle<JSDate> JSDate::New(Handle<JSFunction> constructor,
19302 Handle<JSReceiver> new_target, double tv) {
19304 Handle<JSObject> result;
19312 Handle<Object> value = isolate->factory()->NewNumber(tv);
19313 Handle<JSDate>::cast(result)->SetValue(*value, std::isnan(tv));
19314 return Handle<JSDate>::cast(result);
19426 Handle<Object> JSDate::SetValue(Handle<JSDate> date, double v) {
19428 Handle<Object> value = isolate->factory()->NewNumber(v);
19454 MaybeHandle<Object> JSDate::ToPrimitive(Handle<JSReceiver> receiver,
19455 Handle<Object> hint) {
19458 Handle<String> hint_string = Handle<String>::cast(hint);
19503 void JSArrayBuffer::Setup(Handle<JSArrayBuffer> array_buffer, Isolate* isolate,
19516 Handle<Object> byte_length =
19532 bool JSArrayBuffer::SetupAllocatingData(Handle<JSArrayBuffer> array_buffer,
19558 Handle<JSArrayBuffer> JSTypedArray::MaterializeArrayBuffer(
19559 Handle<JSTypedArray> typed_array) {
19561 Handle<Map> map(typed_array->map());
19566 Handle<FixedTypedArrayBase> fixed_typed_array(
19569 Handle<JSArrayBuffer> buffer(JSArrayBuffer::cast(typed_array->buffer()),
19587 Handle<FixedTypedArrayBase> new_elements =
19598 Handle<JSArrayBuffer> JSTypedArray::GetBuffer() {
19599 Handle<JSArrayBuffer> array_buffer(JSArrayBuffer::cast(buffer()),
19605 Handle<JSTypedArray> self(this);
19610 Handle<PropertyCell> PropertyCell::InvalidateEntry(
19611 Handle<GlobalDictionary> dictionary, int entry) {
19615 Handle<PropertyCell> cell(PropertyCell::cast(dictionary->ValueAt(entry)));
19645 static bool RemainsConstantType(Handle<PropertyCell> cell,
19646 Handle<Object> value) {
19659 PropertyCellType PropertyCell::UpdatedType(Handle<PropertyCell> cell,
19660 Handle<Object> value,
19696 void PropertyCell::UpdateCell(Handle<GlobalDictionary> dictionary, int entry,
19697 Handle<Object> value, PropertyDetails details) {
19700 Handle<PropertyCell> cell(PropertyCell::cast(dictionary->ValueAt(entry)));
19737 void PropertyCell::SetValueWithInvalidation(Handle<PropertyCell> cell,
19738 Handle<Object> new_value) {
