Lines Matching full:handle
47 Handle<HeapType> Object::OptimalType(Isolate* isolate,
53 Handle<Map> map(HeapObject::cast(this)->map(), isolate);
66 Handle<Object> object,
67 Handle<Context> native_context) {
68 if (object->IsJSReceiver()) return Handle<JSReceiver>::cast(object);
69 Handle<JSFunction> constructor;
71 constructor = handle(native_context->number_function(), isolate);
73 constructor = handle(native_context->boolean_function(), isolate);
75 constructor = handle(native_context->string_function(), isolate);
77 constructor = handle(native_context->symbol_function(), isolate);
81 Handle<JSObject> result = isolate->factory()->NewJSObject(constructor);
82 Handle<JSValue>::cast(result)->set_value(*object);
140 Handle<Object> JSObject::GetDataProperty(Handle<JSObject> object,
141 Handle<Name> key) {
148 Handle<Object> JSObject::GetDataProperty(LookupIterator* it) {
243 static Handle<Object> PerformCompare(const BitmaskCompareDescriptor& descriptor,
272 static Handle<Object> PerformCompare(const PointerCompareDescriptor& descriptor,
282 static Handle<Object> GetPrimitiveValue(
329 static Handle<Object> GetDeclaredAccessorProperty(
330 Handle<Object> receiver,
331 Handle<DeclaredAccessorInfo> info,
342 return handle(*CheckedCast<Object*>(current), isolate);
383 Handle<FixedArray> JSObject::EnsureWritableFastElements(
384 Handle<JSObject> object) {
387 Handle<FixedArray> elems(FixedArray::cast(object->elements()), isolate);
389 Handle<FixedArray> writable_elems = isolate->factory()->CopyFixedArrayWithMap(
397 MaybeHandle<Object> JSProxy::GetPropertyWithHandler(Handle<JSProxy> proxy,
398 Handle<Object> receiver,
399 Handle<Name> name) {
405 Handle<Object> args[] = { receiver, name };
411 MaybeHandle<Object> Object::GetPropertyWithAccessor(Handle<Object> receiver,
412 Handle<Name> name,
413 Handle<JSObject> holder,
414 Handle<Object> structure) {
419 Handle<AccessorInfo> info = Handle<AccessorInfo>::cast(structure);
421 Handle<Object> args[2] = { name, receiver };
430 Handle<DeclaredAccessorInfo>::cast(structure),
434 Handle<ExecutableAccessorInfo> data =
435 Handle<ExecutableAccessorInfo>::cast(structure);
442 v8::Handle<v8::Value> result =
448 Handle<Object> return_value = v8::Utils::OpenHandle(*result);
450 // Rebox handle before return.
451 return handle(*return_value, isolate);
455 Handle<Object> getter(Handle<AccessorPair>::cast(structure)->getter(),
460 receiver, Handle<JSReceiver>::cast(getter));
468 Handle<AccessorInfo> info,
469 Handle<HeapType> type) {
471 Handle<Map> map = IC::TypeToMap(*type, isolate);
479 Handle<Object> receiver, Handle<Name> name, Handle<Object> value,
480 Handle<JSObject> holder, Handle<Object> structure, StrictMode strict_mode) {
492 Handle<Object> args[2] = { name, receiver };
512 Handle<Object> setter(AccessorPair::cast(*structure)->setter(), isolate);
516 receiver, Handle<JSReceiver>::cast(setter), value);
519 Handle<Object> args[2] = { name, holder };
526 // TODO(dcarney): Handle correctly.
537 Handle<Object> receiver,
538 Handle<JSReceiver> getter) {
541 // Handle stepping into a getter if step into is active.
545 Handle<JSFunction>::cast(getter), Handle<Object>::null(), 0, false);
553 Handle<Object> receiver,
554 Handle<JSReceiver> setter,
555 Handle<Object> value) {
559 // Handle stepping into a setter if step into is active.
563 Handle<JSFunction>::cast(setter), Handle<Object>::null(), 0, false);
566 Handle<Object> argv[] = { value };
577 Handle<Object> accessors = it->GetAccessors();
589 Handle<JSObject> checked = it->GetHolder<JSObject>();
603 Handle<JSObject> checked = it->GetHolder<JSObject>();
616 Handle<Object> accessors = it->GetAccessors();
627 LookupIterator* it, Handle<Object> value, StrictMode strict_mode) {
628 Handle<JSObject> checked = it->GetHolder<JSObject>();
641 void JSObject::SetNormalizedProperty(Handle<JSObject> object,
642 Handle<Name> name,
643 Handle<Object> value,
646 Handle<NameDictionary> property_dictionary(object->property_dictionary());
650 Handle<String>::cast(name));
655 Handle<Object> store_value = value;
681 Handle<PropertyCell> cell(
692 Handle<Object> JSObject::DeleteNormalizedProperty(Handle<JSObject> object,
693 Handle<Name> name,
697 Handle<NameDictionary> dictionary(object->property_dictionary());
709 Handle<Map> new_map = Map::CopyDropDescriptors(handle(object->map()));
713 Handle<PropertyCell> cell(PropertyCell::cast(dictionary->ValueAt(entry)));
714 Handle<Object> value = isolate->factory()->the_hole_value();
718 Handle<Object> deleted(
721 Handle<NameDictionary> new_properties =
748 Handle<Object> object,
749 Handle<Object> receiver,
766 Handle<JSProxy>::cast(PrototypeIterator::GetCurrent(iter)), receiver,
773 Handle<JSObject> js_object =
774 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
790 Handle<Object> result;
856 Handle<Smi> Object::GetOrCreateHash(Isolate* isolate, Handle<Object> object) {
857 Handle<Object> hash(object->GetHash(), isolate);
858 if (hash->IsSmi()) return Handle<Smi>::cast(hash);
861 return JSReceiver::GetOrCreateIdentityHash(Handle<JSReceiver>::cast(object));
959 Handle<String> String::SlowFlatten(Handle<ConsString> cons,
967 Handle<SeqString> result;
969 Handle<SeqOneByteString> flat = isolate->factory()->NewRawOneByteString(
975 Handle<SeqTwoByteString> flat = isolate->factory()->NewRawTwoByteString(
1284 FILE* file, Handle<JSObject> object,
1285 ElementsKind from_kind, Handle<FixedArrayBase> from_elements,
1286 ElementsKind to_kind, Handle<FixedArrayBase> to_elements) {
1530 // Handle header
1532 // Handle object body
1710 MaybeHandle<Map> Map::CopyWithField(Handle<Map> map,
1711 Handle<Name> name,
1712 Handle<HeapType> type,
1736 Handle<Map> new_map = Map::CopyAddDescriptor(map, &new_field_desc, flag);
1746 MaybeHandle<Map> Map::CopyWithConstant(Handle<Map> map,
1747 Handle<Name> name,
1748 Handle<Object> constant,
1762 void JSObject::AddSlowProperty(Handle<JSObject> object,
1763 Handle<Name> name,
1764 Handle<Object> value,
1768 Handle<NameDictionary> dict(object->property_dictionary());
1773 Handle<PropertyCell> cell(PropertyCell::cast(dict->ValueAt(entry)));
1783 Handle<PropertyCell> cell = isolate->factory()->NewPropertyCell(value);
1788 Handle<NameDictionary> result =
1809 void JSObject::EnqueueChangeRecord(Handle<JSObject> object,
1811 Handle<Name> name,
1812 Handle<Object> old_value) {
1817 Handle<String> type = isolate->factory()->InternalizeUtf8String(type_str);
1818 Handle<Object> args[] = { type, object, name, old_value };
1822 Handle<JSFunction>(isolate->observers_notify_change()),
1879 void Map::ConnectElementsTransition(Handle<Map> parent, Handle<Map> child) {
1881 Handle<Name> name = isolate->factory()->elements_transition_symbol();
1886 void JSObject::MigrateToMap(Handle<JSObject> object, Handle<Map> new_map) {
1890 Handle<Map> old_map(object->map());
1930 void JSObject::MigrateFastToFast(Handle<JSObject> object, Handle<Map> new_map) {
1932 Handle<Map> old_map(object->map());
1955 Handle<Object> value = isolate->factory()->NewHeapNumber(0, MUTABLE);
1967 Handle<FixedArray> old_storage = handle(object->properties(), isolate);
1968 Handle<FixedArray> new_storage =
1972 Handle<Object> value;
1991 Handle<FixedArray> array = isolate->factory()->NewFixedArray(total_size);
1993 Handle<DescriptorArray> old_descriptors(old_map->instance_descriptors());
1994 Handle<DescriptorArray> new_descriptors(new_map->instance_descriptors());
2015 Handle<Object> value(raw_value, isolate);
2019 value = handle(Smi::FromInt(0), isolate);
2035 Handle<Object> value;
2084 void JSObject::GeneralizeFieldRepresentation(Handle<JSObject> object,
2087 Handle<HeapType> new_field_type) {
2088 Handle<Map> new_map = Map::GeneralizeRepresentation(
2089 handle(object->map()), modify_index, new_representation, new_field_type,
2105 Handle<Map> Map::CopyGeneralizeAllRepresentations(Handle<Map> map,
2111 Handle<Map> new_map = Copy(map);
2128 FieldDescriptor d(handle(descriptors->GetKey(modify_index), isolate),
2158 Handle<Map> Map::CopyGeneralizeAllRepresentations(Handle<Map> map,
2277 void Map::UpdateFieldType(int descriptor, Handle<Name> name,
2278 Handle<HeapType> new_type) {
2297 Handle<HeapType> Map::GeneralizeFieldType(Handle<HeapType> type1,
2298 Handle<HeapType> type2,
2304 Handle<HeapType> type = HeapType::Union(type1, type2, isolate);
2317 void Map::GeneralizeFieldType(Handle<Map> map,
2319 Handle<HeapType> new_field_type) {
2323 Handle<HeapType> old_field_type(
2333 Handle<Map> field_owner(map->FindFieldOwner(modify_index), isolate);
2334 Handle<DescriptorArray> descriptors(
2343 Handle<Name> name(descriptors->GetKey(modify_index));
2378 Handle<Map> Map::GeneralizeRepresentation(Handle<Map> old_map,
2381 Handle<HeapType> new_field_type,
2385 Handle<DescriptorArray> old_descriptors(
2415 Handle<Map> root_map(old_map->FindRootMap(), isolate);
2432 Handle<Map> target_map = root_map;
2436 Handle<Map> tmp_map(target_map->GetTransition(j), isolate);
2437 Handle<DescriptorArray> tmp_descriptors = handle(
2461 Handle<HeapType> old_field_type = (old_type == FIELD)
2462 ? handle(old_descriptors->GetFieldType(i), isolate)
2483 Handle<DescriptorArray> target_descriptors(
2502 Handle<Map> tmp_map(target_map->GetTransition(j), isolate);
2503 Handle<DescriptorArray> tmp_descriptors(
2519 target_descriptors = handle(target_map->instance_descriptors(), isolate);
2526 Handle<DescriptorArray> new_descriptors = DescriptorArray::Allocate(
2539 Descriptor d(handle(old_descriptors->GetKey(i), isolate),
2540 handle(old_descriptors->GetValue(i), isolate),
2547 Handle<Name> target_key(target_descriptors->GetKey(i), isolate);
2562 Handle<HeapType> old_field_type = (old_details.type() == FIELD)
2563 ? handle(old_descriptors->GetFieldType(i), isolate)
2566 Handle<HeapType> target_field_type = (target_details.type() == FIELD)
2567 ? handle(target_descriptors->GetFieldType(i), isolate)
2585 handle(target_descriptors->GetValue(i), isolate),
2594 Handle<Name> old_key(old_descriptors->GetKey(i), isolate);
2600 Handle<HeapType> old_field_type(
2627 handle(old_descriptors->GetValue(i), isolate),
2639 Handle<Map> split_map(root_map->FindLastMatchMap(
2650 Handle<HeapType> old_field_type = (old_details.type() == FIELD)
2651 ? handle(old_descriptors->GetFieldType(modify_index), isolate)
2652 : HeapType::Constant(handle(old_descriptors->GetValue(modify_index),
2654 Handle<HeapType> new_field_type = (new_details.type() == FIELD)
2655 ? handle(new_descriptors->GetFieldType(modify_index), isolate)
2656 : HeapType::Constant(handle(new_descriptors->GetValue(modify_index),
2666 Handle<Map> new_map = split_map;
2676 Handle<Map> Map::GeneralizeAllFieldRepresentations(
2677 Handle<Map> map) {
2678 Handle<DescriptorArray> descriptors(map->instance_descriptors());
2691 MaybeHandle<Map> Map::TryUpdate(Handle<Map> map) {
2692 Handle<Map> proto_map(map);
2694 Handle<JSObject> holder(JSObject::cast(proto_map->prototype()));
2695 proto_map = Handle<Map>(holder->map());
2697 Handle<Map>(holder->map());
2705 Handle<Map> Map::Update(Handle<Map> map) {
2714 MaybeHandle<Map> Map::TryUpdateInternal(Handle<Map> old_map) {
2769 return handle(new_map);
2774 Handle<Object> value) {
2778 Handle<String> name_string = Handle<String>::cast(it->name());
2779 Handle<JSObject> holder = it->GetHolder<JSObject>();
2780 Handle<InterceptorInfo> interceptor(holder->GetNamedInterceptor());
2789 v8::Handle<v8::Value> result = args.Call(
2798 MaybeHandle<Object> Object::SetProperty(Handle<Object> object,
2799 Handle<Name> name, Handle<Object> value,
2808 Handle<Object> value,
2899 Handle<Object> args[1] = {it->name()};
2910 Handle<Object> value,
2914 Handle<Object> args[] = {it->name(), it->GetReceiver()};
2922 Handle<Object> Object::SetDataProperty(LookupIterator* it,
2923 Handle<Object> value) {
2926 Handle<JSObject> receiver = Handle<JSObject>::cast(it->GetReceiver());
2958 Handle<Object> value,
2968 Handle<JSObject> receiver = it->GetStoreTarget();
2980 Handle<Object> args[1] = {it->name()};
3010 Handle<JSObject> object,
3012 Handle<Object> value,
3020 Handle<JSProxy>::cast(PrototypeIterator::GetCurrent(iter)), object,
3024 Handle<JSObject> js_proto =
3025 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
3029 Handle<SeededNumberDictionary> dictionary(js_proto->element_dictionary());
3035 Handle<Object> structure(dictionary->ValueAt(entry), isolate);
3046 void Map::EnsureDescriptorSlack(Handle<Map> map, int slack) {
3050 Handle<DescriptorArray> descriptors(map->instance_descriptors());
3054 Handle<DescriptorArray> new_descriptors = DescriptorArray::CopyUpTo(
3089 Handle<typename T::Array> array,
3098 Handle<AccessorInfo> entry(AccessorInfo::cast(callbacks->get(i)));
3100 Handle<String> key =
3102 Handle<String>(String::cast(entry->name())));
3110 Handle<AccessorInfo> entry(AccessorInfo::cast(callbacks->get(i)));
3111 Handle<Name> key(Name::cast(entry->name()));
3124 static bool Contains(Handle<Name> key,
3125 Handle<AccessorInfo> entry,
3127 Handle<DescriptorArray> array) {
3131 static void Insert(Handle<Name> key,
3132 Handle<AccessorInfo> entry,
3134 Handle<DescriptorArray> array) {
3144 static bool Contains(Handle<Name> key,
3145 Handle<AccessorInfo> entry,
3147 Handle<FixedArray> array) {
3153 static void Insert(Handle<Name> key,
3154 Handle<AccessorInfo> entry,
3156 Handle<FixedArray> array) {
3163 void Map::AppendCallbackDescriptors(Handle<Map> map,
3164 Handle<Object> descriptors) {
3166 Handle<DescriptorArray> array(map->instance_descriptors());
3174 int AccessorInfo::AppendUnique(Handle<Object> descriptors,
3175 Handle<FixedArray> array,
3185 static bool ContainsMap(MapHandleList* maps, Handle<Map> map) {
3195 static Handle<T> MaybeNull(T* p) {
3196 if (p == NULL) return Handle<T>::null();
3197 return Handle<T>(p);
3201 Handle<Map> Map::FindTransitionedMap(MapHandleList* candidates) {
3203 Handle<Map> transitioned_map = Handle<Map>::null();
3204 Handle<Map> current_map(this);
3209 Handle<Map> maybe_transitioned_map =
3283 static Handle<Map> AddMissingElementsTransitions(Handle<Map> map,
3287 Handle<Map> current_map = map;
3310 Handle<Map> Map::TransitionElementsTo(Handle<Map> map,
3324 return handle(Map::cast(maybe_transitioned_map));
3333 Handle<Map> Map::TransitionElementsToSlow(Handle<Map> map,
3363 Handle<Map> Map::AsElementsKind(Handle<Map> map, ElementsKind kind) {
3364 Handle<Map> closest_map(FindClosestElementsTransition(*map, kind));
3374 Handle<Map> JSObject::GetElementsTransitionMap(Handle<JSObject> object,
3376 Handle<Map> map(object->map());
3381 Maybe<bool> JSProxy::HasPropertyWithHandler(Handle<JSProxy> proxy,
3382 Handle<Name> name) {
3388 Handle<Object> args[] = { name };
3389 Handle<Object> result;
3399 MaybeHandle<Object> JSProxy::SetPropertyWithHandler(Handle<JSProxy> proxy,
3400 Handle<Object> receiver,
3401 Handle<Name> name,
3402 Handle<Object> value,
3409 Handle<Object> args[] = { receiver, name, value };
3424 Handle<JSProxy> proxy, Handle<Object> receiver, Handle<Name> name,
3425 Handle<Object> value, StrictMode strict_mode, bool* done) {
3427 Handle<Object> handler(proxy->handler(), isolate); // Trap might morph proxy.
3436 Handle<Object> args[] = { name };
3437 Handle<Object> result;
3442 Handle<Object>(),
3453 Handle<Object> argv[] = { result };
3454 Handle<Object> desc;
3465 Handle<String> configurable_name =
3468 Handle<Object> configurable =
3472 Handle<String> trap = isolate->factory()->InternalizeOneByteString(
3474 Handle<Object> args[] = { handler, trap, name };
3482 Handle<String> hasWritable_name =
3485 Handle<Object> hasWritable =
3489 Handle<String> writable_name = isolate->factory()->InternalizeOneByteString(
3491 Handle<Object> writable =
3497 Handle<Object> args[] = { name, receiver };
3504 Handle<String> set_name =
3506 Handle<Object> setter = Object::GetProperty(desc, set_name).ToHandleChecked();
3510 receiver, Handle<JSReceiver>::cast(setter), value);
3514 Handle<Object> args2[] = { name, proxy };
3522 Handle<JSProxy> proxy, Handle<Name> name, DeleteMode mode) {
3528 Handle<Object> args[] = { name };
3529 Handle<Object> result;
3534 Handle<Object>(),
3541 Handle<Object> handler(proxy->handler(), isolate);
3542 Handle<String> trap_name = isolate->factory()->InternalizeOneByteString(
3544 Handle<Object> args[] = { handler, trap_name };
3554 Handle<JSProxy> proxy, uint32_t index, DeleteMode mode) {
3556 Handle<String> name = isolate->factory()->Uint32ToString(index);
3562 Handle<JSProxy> proxy, Handle<Object> receiver, Handle<Name> name) {
3569 Handle<Object> args[] = { name };
3570 Handle<Object> result;
3573 proxy->CallTrap(proxy, "getPropertyDescriptor", Handle<Object>(),
3579 Handle<Object> argv[] = { result };
3580 Handle<Object> desc;
3588 Handle<String> enum_n = isolate->factory()->InternalizeOneByteString(
3590 Handle<Object> enumerable;
3594 Handle<String> conf_n = isolate->factory()->InternalizeOneByteString(
3596 Handle
3600 Handle<String> writ_n = isolate->factory()->InternalizeOneByteString(
3602 Handle<Object> writable;
3607 Handle<String> set_n = isolate->factory()->InternalizeOneByteString(
3609 Handle<Object> setter;
3617 Handle<Object> handler(proxy->handler(), isolate);
3618 Handle<String> trap = isolate->factory()->InternalizeOneByteString(
3620 Handle<Object> args[] = { handler, trap, name };
3621 Handle<Object> error;
3637 Handle<JSProxy> proxy, Handle<JSReceiver> receiver, uint32_t index) {
3639 Handle<String> name = isolate->factory()->Uint32ToString(index);
3644 void JSProxy::Fix(Handle<JSProxy> proxy) {
3648 Handle<Object> hash(proxy->GetIdentityHash(), isolate);
3660 JSObject::SetIdentityHash(Handle<JSObject>::cast(proxy),
3661 Handle<Smi>::cast(hash));
3666 MaybeHandle<Object> JSProxy::CallTrap(Handle<JSProxy> proxy,
3668 Handle<Object> derived,
3670 Handle<Object> argv[]) {
3672 Handle<Object> handler(proxy->handler(), isolate);
3674 Handle<String> trap_name = isolate->factory()->InternalizeUtf8String(name);
3675 Handle<Object> trap;
3683 Handle<Object> args[] = { handler, trap_name };
3689 trap = Handle<Object>(derived);
3696 void JSObject::AllocateStorageForMap(Handle<JSObject> object, Handle<Map> map) {
3717 void JSObject::MigrateInstance(Handle<JSObject> object) {
3718 Handle<Map> original_map(object->map());
3719 Handle<Map> map = Map::Update(original_map);
3729 bool JSObject::TryMigrateInstance(Handle<JSObject> object) {
3732 Handle<Map> original_map(object->map(), isolate);
3733 Handle<Map> new_map;
3745 void JSObject::MigrateToNewProperty(Handle<JSObject> object,
3746 Handle<Map> map,
3747 Handle<Object> value) {
3775 void JSObject::AddProperty(Handle<JSObject> object, Handle<Name> name,
3776 Handle<Object> value,
3798 Handle<JSObject> object,
3799 Handle<Name> name,
3800 Handle<Object> value,
3823 Handle<Object> old_value = it.isolate()->factory()->the_hole_value();
3827 Handle<Object> accessors = it.GetAccessors();
3841 Handle<Object> result;
3859 !Handle<JSFunction>::cast(object)->should_have_prototype()) {
3867 Handle<ExecutableAccessorInfo> new_data = Accessors::CloneAccessor(
3868 it.isolate(), Handle<ExecutableAccessorInfo>::cast(accessors));
3900 Handle<Object> old_value = it.isolate()->factory()->the_hole_value();
3930 Handle<JSObject> holder,
3931 Handle<Object> receiver,
3932 Handle<Name> name) {
3943 Handle<InterceptorInfo> interceptor(holder->GetNamedInterceptor());
3951 v8::Handle<v8::Integer> result =
3952 args.Call(query, v8::Utils::ToLocal(Handle<String>::cast(name)));
3962 v8::Handle<v8::Value> result =
3963 args.Call(getter, v8::Utils::ToLocal(Handle<String>::cast(name)));
3973 Handle<JSReceiver> object, Handle<Name> name) {
4015 Handle<JSObject> object, Handle<JSReceiver> receiver, uint32_t index,
4033 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), receiver,
4049 Handle<JSObject> object, Handle<JSReceiver> receiver, uint32_t index,
4058 Handle<InterceptorInfo> interceptor(object->GetIndexedInterceptor());
4066 v8::Handle<v8::Integer> result = args.Call(query, index);
4075 v8::Handle<v8::Value> result = args.Call(getter, index);
4085 Handle<JSObject> object, Handle<JSReceiver> receiver, uint32_t index,
4091 // Handle [] on String objects.
4102 Handle<JSProxy>::cast(PrototypeIterator::GetCurrent(iter)), receiver,
4107 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), receiver,
4112 Handle<NormalizedMapCache> NormalizedMapCache::New(Isolate* isolate) {
4113 Handle<FixedArray> array(
4115 return Handle<NormalizedMapCache>::cast(array);
4119 MaybeHandle<Map> NormalizedMapCache::Get(Handle<Map> fast_map,
4127 return handle(Map::cast(value));
4131 void NormalizedMapCache::Set(Handle<Map> fast_map,
4132 Handle<Map> normalized_map) {
4147 void HeapObject::UpdateMapCodeCache(Handle<HeapObject> object,
4148 Handle<Name> name,
4149 Handle<Code> code) {
4150 Handle<Map> map(object->map());
4155 void JSObject::NormalizeProperties(Handle<JSObject> object,
4160 Handle<Map> map(object->map());
4161 Handle<Map> new_map = Map::Normalize(map, mode);
4167 void JSObject::MigrateFastToSlow(Handle<JSObject> object,
4168 Handle<Map> new_map,
4177 Handle<Map> map(object->map());
4187 Handle<NameDictionary> dictionary =
4190 Handle<DescriptorArray> descs(map->instance_descriptors());
4195 Handle<Name> key(descs->GetKey(i));
4196 Handle<Object> value(descs->GetConstant(i), isolate);
4203 Handle<Name> key(descs->GetKey(i));
4205 Handle<Object> value(
4209 Handle<HeapNumber> old = Handle<HeapNumber>::cast(value);
4218 Handle<Name> key(descs->GetKey(i));
4219 Handle<Object> value(descs->GetCallbacksObject(i), isolate);
4268 void JSObject::MigrateSlowToFast(Handle<JSObject> object,
4274 Handle<NameDictionary> dictionary(object->property_dictionary());
4306 Handle<Map> new_map = Map::CopyDropDescriptors(handle(object->map()));
4322 Handle<DescriptorArray> descriptors = DescriptorArray::Allocate(
4334 Handle<FixedArray> fields = factory->NewFixedArray(
4343 Handle<Name> key;
4345 key = handle(Symbol::cast(k));
4349 key = factory->InternalizeString(handle(String::cast(k)));
4358 handle(value, isolate),
4378 handle(value, isolate),
4405 void JSObject::ResetElements(Handle<JSObject> object) {
4409 Handle<SeededNumberDictionary> new_elements =
4418 static Handle<SeededNumberDictionary> CopyFastElementsToDictionary(
4419 Handle<FixedArrayBase> array,
4421 Handle<SeededNumberDictionary> dictionary) {
4426 Handle<Object> value;
4428 Handle<FixedDoubleArray> double_array =
4429 Handle<FixedDoubleArray>::cast(array);
4436 value = handle(Handle<FixedArray>::cast(array)->get(i), isolate);
4448 Handle<SeededNumberDictionary> JSObject::NormalizeElements(
4449 Handle<JSObject> object) {
4455 Handle<FixedArrayBase> array(FixedArrayBase::cast(object->elements()));
4459 array = handle(FixedArrayBase::cast(
4460 Handle<FixedArray>::cast(array)->get(1)));
4462 if (array->IsDictionary()) return Handle<SeededNumberDictionary>::cast(array);
4469 ? Smi::cast(Handle<JSArray>::cast(object)->length())->value()
4474 Handle<SeededNumberDictionary> dictionary =
4485 Handle<Map> new_map =
4523 void JSObject::SetIdentityHash(Handle<JSObject> object, Handle<Smi> hash) {
4531 static Handle<Smi> GetOrCreateIdentityHashHelper(Handle<ProxyType> proxy) {
4534 Handle<Object> maybe_hash(proxy->hash(), isolate);
4535 if (maybe_hash->IsSmi()) return Handle<Smi>::cast(maybe_hash);
4537 Handle<Smi> hash(GenerateIdentityHash(isolate), isolate);
4557 Handle<Smi> JSObject::GetOrCreateIdentityHash(Handle<JSObject> object) {
4559 return GetOrCreateIdentityHashHelper(Handle<JSGlobalProxy>::cast(object));
4564 Handle<Object> maybe_hash(object->GetIdentityHash(), isolate);
4565 if (maybe_hash->IsSmi()) return Handle<Smi>::cast(maybe_hash);
4567 Handle<Smi> hash(GenerateIdentityHash(isolate), isolate);
4578 Handle<Smi> JSProxy::GetOrCreateIdentityHash(Handle<JSProxy> proxy) {
4583 Object* JSObject::GetHiddenProperty(Handle<Name> key) {
4600 // Handle inline-stored identity hash.
4616 Handle<Object> JSObject::SetHiddenProperty(Handle<JSObject> object,
4617 Handle<Name> key,
4618 Handle<Object> value) {
4631 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), key,
4636 Handle<Object> inline_value(object->GetHiddenPropertiesHashTable(), isolate);
4645 Handle<ObjectHashTable> hashtable =
4649 Handle<ObjectHashTable> new_table = ObjectHashTable::Put(hashtable, key,
4662 void JSObject::DeleteHiddenProperty(Handle<JSObject> object, Handle<Name> key) {
4671 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), key);
4680 Handle<ObjectHashTable> hashtable(ObjectHashTable::cast(inline_value));
4686 bool JSObject::HasHiddenProperties(Handle<JSObject> object) {
4687 Handle<Name> hidden = object->GetIsolate()->factory()->hidden_string();
4722 LookupIterator it(handle(this), isolate->factory()->hidden_string(),
4729 Handle<ObjectHashTable> JSObject::GetOrCreateHiddenPropertiesHashtable(
4730 Handle<JSObject> object) {
4734 Handle<Object> inline_value(object->GetHiddenPropertiesHashTable(), isolate);
4736 return Handle<ObjectHashTable>::cast(inline_value);
4739 Handle<ObjectHashTable> hashtable = ObjectHashTable::New(
4755 Handle<Object> JSObject::SetHiddenPropertiesHashTable(Handle<JSObject> object,
4756 Handle<Object> value) {
4759 Handle<Name> name = isolate->factory()->hidden_string();
4766 Handle<JSObject> holder, Handle<JSObject> receiver, Handle<Name> name) {
4772 Handle<InterceptorInfo> interceptor(holder->GetNamedInterceptor());
4781 v8::Handle<v8::Boolean> result =
4782 args.Call(deleter, v8::Utils::ToLocal(Handle<String>::cast(name)));
4787 Handle<Object> result_internal = v8::Utils::OpenHandle(*result);
4790 return handle(*result_internal, isolate);
4795 Handle<JSObject> object,
4804 Handle<InterceptorInfo> interceptor(object->GetIndexedInterceptor());
4812 v8::Handle<v8::Boolean> result = args.Call(deleter, index);
4816 Handle<Object> result_internal = v8::Utils::OpenHandle(*result);
4819 return handle(*result_internal, isolate);
4827 MaybeHandle<Object> JSObject::DeleteElement(Handle<JSObject> object,
4844 Handle<Object> name = factory->NewNumberFromUint(index);
4845 Handle<Object> args[2] = { name, object };
4858 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), index,
4862 Handle<Object> old_value;
4870 old_value = Handle<Object>::cast(factory->the_hole_value());
4885 Handle<Object> result;
4892 Handle<String> name = factory->Uint32ToString(index);
4901 MaybeHandle<Object> JSObject::DeleteProperty(Handle<JSObject> object,
4902 Handle<Name> name,
4921 Handle<Object> old_value = it.isolate()->factory()->the_hole_value();
4954 Handle<Object> args[2] = {name, object};
4966 Handle<JSObject> holder = it.GetHolder<JSObject>();
4974 Handle<Object> result =
4991 MaybeHandle<Object> JSReceiver::DeleteElement(Handle<JSReceiver> object,
4996 Handle<JSProxy>::cast(object), index, mode);
4998 return JSObject::DeleteElement(Handle<JSObject>::cast(object), index, mode);
5002 MaybeHandle<Object> JSReceiver::DeleteProperty(Handle<JSReceiver> object,
5003 Handle<Name> name,
5007 Handle<JSProxy>::cast(object), name, mode);
5009 return JSObject::DeleteProperty(Handle<JSObject>::cast(object), name, mode);
5148 MaybeHandle<Object> JSObject::PreventExtensions(Handle<JSObject> object) {
5166 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)));
5179 Handle<SeededNumberDictionary> dictionary = NormalizeElements(object);
5188 // TODO(adamk): Extend the NormalizedMapCache to handle non-extensible maps.
5189 Handle<Map> new_map = Map::Copy(handle(object->map()));
5196 EnqueueChangeRecord(object, "preventExtensions", Handle<Name>(),
5228 MaybeHandle<Object> JSObject::Freeze(Handle<JSObject> object) {
5248 return Freeze(Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)));
5260 Handle<SeededNumberDictionary> new_element_dictionary;
5263 ? Smi::cast(Handle<JSArray>::cast(object)->length())->value()
5274 handle(object->elements()), length, new_element_dictionary);
5282 Handle<Map> old_map(object->map(), isolate);
5286 Handle<Map> transition_map(old_map->GetTransition(transition_index));
5293 Handle<Map> new_map = Map::CopyForFreeze(old_map);
5301 // TODO(adamk): Extend the NormalizedMapCache to handle non-extensible maps.
5302 Handle<Map> new_map = Map::Copy(handle(object->map()));
5329 void JSObject::SetObserved(Handle<JSObject> object) {
5333 Handle<Map> new_map;
5334 Handle<Map> old_map(object->map(), isolate);
5339 new_map = handle(old_map->GetTransition(transition_index), isolate);
5351 Handle<Object> JSObject::FastPropertyAt(Handle<JSObject> object,
5355 Handle<Object> raw_value(object->RawFastPropertyAt(index), isolate);
5369 MUST_USE_RESULT MaybeHandle<JSObject> StructureWalk(Handle<JSObject> object);
5373 Handle<JSObject> object,
5374 Handle<JSObject> value) {
5375 Handle<AllocationSite> current_site = site_context()->EnterNewScope();
5395 Handle<JSObject> object) {
5413 Handle<JSObject> copy;
5415 Handle<AllocationSite> site_to_pass;
5439 Handle<DescriptorArray> descriptors(copy->map()->instance_descriptors());
5445 Handle<Object> value(object->RawFastPropertyAt(index), isolate);
5449 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
5460 Handle<FixedArray> names =
5465 Handle<String> key_string(String::cast(names->get(i)));
5474 Handle<Object> value =
5477 Handle<JSObject> result;
5480 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
5498 Handle<FixedArray> elements(FixedArray::cast(copy->elements()));
5507 Handle<Object> value(elements->get(i), isolate);
5512 Handle<JSObject> result;
5515 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
5526 Handle<SeededNumberDictionary> element_dictionary(
5532 Handle<Object> value(element_dictionary->ValueAt(i), isolate);
5534 Handle<JSObject> result;
5537 VisitElementOrProperty(copy, Handle<JSObject>::cast(value)),
5571 Handle<JSObject> object,
5576 Handle<JSObject> for_assert;
5583 Handle<JSObject> object,
5588 Handle<JSObject> for_assert;
5666 static bool ContainsOnlyValidKeys(Handle<FixedArray> array) {
5676 static Handle<FixedArray> ReduceFixedArrayTo(
5677 Handle<FixedArray> array, int length) {
5681 Handle<FixedArray> new_array =
5688 static Handle<FixedArray> GetEnumPropertyKeys(Handle<JSObject> object,
5708 Handle<FixedArray> keys(desc->GetEnumCache(), isolate);
5721 Handle<Map> map(object->map());
5731 Handle<FixedArray> storage = isolate->factory()->NewFixedArray(
5733 Handle<FixedArray> indices = isolate->factory()->NewFixedArray(
5736 Handle<DescriptorArray> descs =
5737 Handle<DescriptorArray>(object->map()->instance_descriptors(), isolate);
5749 indices = Handle<FixedArray>();
5761 Handle<FixedArray> bridge_storage =
5774 Handle<NameDictionary> dictionary(object->property_dictionary());
5777 return Handle<FixedArray>(isolate->heap()->empty_fixed_array());
5779 Handle<FixedArray> storage = isolate->factory()->NewFixedArray(length);
5786 MaybeHandle<FixedArray> JSReceiver::GetKeys(Handle<JSReceiver> object,
5790 Handle<FixedArray> content = isolate->factory()->empty_fixed_array();
5791 Handle<JSFunction> arguments_function(
5799 Handle<JSProxy> proxy(JSProxy::cast(*PrototypeIterator::GetCurrent(iter)),
5801 Handle<Object> args[] = { proxy };
5802 Handle<Object> names;
5814 content, Handle<JSObject>::cast(names)),
5819 Handle<JSObject> current =
5820 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
5832 Handle<FixedArray> element_keys =
5843 Handle<JSObject> result;
5880 Handle<JSObject> result;
5926 void JSObject::DefineElementAccessor(Handle<JSObject> object,
5928 Handle<Object> getter,
5929 Handle<Object> setter,
5985 Handle<AccessorPair> accessors = isolate->factory()->NewAccessorPair();
6013 void JSObject::SetElementCallback(Handle<JSObject> object,
6015 Handle<Object> structure,
6022 Handle<SeededNumberDictionary> dictionary = NormalizeElements(object);
6053 void JSObject::SetPropertyCallback(Handle<JSObject> object,
6054 Handle<Name> name,
6055 Handle<Object> structure,
6066 Handle<Map> new_map = Map::CopyDropDescriptors(handle(object->map()));
6084 MaybeHandle<Object> JSObject::DefineAccessor(Handle<JSObject> object,
6085 Handle<Name> name,
6086 Handle<Object> getter,
6087 Handle<Object> setter,
6102 DefineAccessor(Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)),
6112 if (name->IsString()) name = String::Flatten(Handle<String>::cast(name));
6117 Handle<Object> old_value = isolate->factory()->the_hole_value();
6177 MaybeHandle<Object> JSObject::SetAccessor(Handle<JSObject> object,
6178 Handle<AccessorInfo> info) {
6181 Handle<Name> name(Name::cast(info->name()));
6196 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), info);
6204 if (name->IsString()) name = String::Flatten(Handle<String>::cast(name));
6257 MaybeHandle<Object> JSObject::GetAccessor(Handle<JSObject> object,
6258 Handle<Name> name,
6272 Handle<Object> current = PrototypeIterator::GetCurrent(iter);
6275 !isolate->MayNamedAccess(Handle<JSObject>::cast(current), name,
6277 isolate->ReportFailedAccessCheck(Handle<JSObject>::cast(current),
6284 Handle<JSObject>::cast(current)->HasDictionaryElements()) {
6292 return handle(AccessorPair::cast(element)->GetComponent(component),
6321 Handle<Object> maybe_pair = it.GetAccessors();
6323 return handle(
6364 Handle<Map> Map::RawCopy(Handle<Map> map, int instance_size) {
6365 Handle<Map> result = map->GetIsolate()->factory()->NewMap(
6387 Handle<Map> Map::Normalize(Handle<Map> fast_map,
6392 Handle<Object> maybe_cache(isolate->native_context()->normalized_map_cache(),
6395 Handle<NormalizedMapCache> cache;
6396 if (use_cache) cache = Handle<NormalizedMapCache>::cast(maybe_cache);
6398 Handle<Map> new_map;
6408 Handle<Map> fresh = Map::CopyNormalized(fast_map, mode);
6433 Handle<Map> Map::CopyNormalized(Handle<Map> map,
6440 Handle<Map> result = RawCopy(map, new_instance_size);
6457 Handle<Map> Map::CopyDropDescriptors(Handle<Map> map) {
6458 Handle<Map> result = RawCopy(map, map->instance_size());
6472 Handle<Map> Map::ShareDescriptor(Handle<Map> map,
6473 Handle<DescriptorArray> descriptors,
6481 Handle<Map> result = CopyDropDescriptors(map);
6482 Handle<Name> name = descriptor->GetKey();
6491 descriptors = handle(map->instance_descriptors());
6508 void Map::ConnectTransition(Handle<Map> parent, Handle<Map> child,
6509 Handle<Name> name, SimpleTransitionFlag flag) {
6514 Handle<TransitionArray> transitions =
6522 Handle<Map> Map::CopyReplaceDescriptors(Handle<Map> map,
6523 Handle<DescriptorArray> descriptors,
6529 Handle<Map> result = CopyDropDescriptors(map);
6534 Handle<Name> name;
6554 Handle<Map> Map::CopyInstallDescriptors(Handle<Map> map,
6556 Handle<DescriptorArray> descriptors) {
6559 Handle<Map> result = CopyDropDescriptors(map);
6574 Handle<Name> name = handle(descriptors->GetKey(new_descriptor));
6581 Handle<Map> Map::CopyAsElementsKind(Handle<Map> map, ElementsKind kind,
6602 Handle<Map> new_map = CopyDropDescriptors(map);
6614 Handle<Map> new_map = Copy(map);
6626 Handle<Map> Map::CopyForObserved(Handle<Map> map) {
6633 Handle<Map> new_map;
6646 Handle<Name> name = isolate->factory()->observed_symbol();
6653 Handle<Map> Map::Copy(Handle<Map> map) {
6654 Handle<DescriptorArray> descriptors(map->instance_descriptors());
6656 Handle<DescriptorArray> new_descriptors =
6663 Handle<Map> Map::Create(Isolate* isolate, int inobject_properties) {
6664 Handle<Map> copy = Copy(handle(isolate->object_function()->initial_map()));
6688 Handle<Map> Map::CopyForFreeze(Handle<Map> map) {
6691 Handle<DescriptorArray> new_desc = DescriptorArray::CopyUpToAddAttributes(
6692 handle(map->instance_descriptors(), isolate), num_descriptors, FROZEN);
6693 Handle<Map> new_map = CopyReplaceDescriptors(
6727 Handle<Map> Map::PrepareForDataProperty(Handle<Map> map, int descriptor,
6728 Handle<Object> value) {
6735 Handle<DescriptorArray> descriptors(map->instance_descriptors());
6741 Handle<HeapType> type = value->OptimalType(isolate, representation);
6748 Handle<Map> Map::TransitionToDataProperty(Handle<Map> map, Handle<Name> name,
6749 Handle<Object> value,
6760 Handle<Map> transition(map->GetTransition(index));
6763 // TODO(verwaest): Handle attributes better.
6779 Handle<HeapType> type = value->OptimalType(isolate, representation);
6784 Handle<Map> result;
6793 Handle<Map> Map::ReconfigureDataProperty(Handle<Map> map, int descriptor,
6805 Handle<Map> Map::TransitionToAccessorProperty(Handle<Map> map,
6806 Handle<Name> name,
6808 Handle<Object> accessor,
6829 Handle<Map> transition(map->GetTransition(index));
6842 // TODO(verwaest): Handle attributes better.
6847 Handle<Object> maybe_pair(descriptors->GetValue(descriptor), isolate);
6852 Handle<AccessorPair> pair = Handle<AccessorPair>::cast(maybe_pair);
6860 Handle<AccessorPair> pair;
6873 Handle<Object> maybe_pair(old_descriptors->GetValue(descriptor), isolate);
6878 Object* current = Handle<AccessorPair>::cast(maybe_pair)->get(component);
6885 pair = AccessorPair::Copy(Handle<AccessorPair>::cast(maybe_pair));
6900 Handle<Map> Map::CopyAddDescriptor(Handle<Map> map,
6903 Handle<DescriptorArray> descriptors(map->instance_descriptors());
6914 Handle<DescriptorArray> new_descriptors = DescriptorArray::CopyUpTo(
6923 Handle<Map> Map::CopyInsertDescriptor(Handle<Map> map,
6926 Handle<DescriptorArray> old_descriptors(map->instance_descriptors());
6940 Handle<DescriptorArray> DescriptorArray::CopyUpTo(
6941 Handle<DescriptorArray> desc,
6949 Handle<DescriptorArray> DescriptorArray::CopyUpToAddAttributes(
6950 Handle<DescriptorArray> desc,
6960 Handle<DescriptorArray> descriptors =
6980 handle(key), handle(value, desc->GetIsolate()), details);
6995 Handle<Map> Map::CopyReplaceDescriptor(Handle<Map> map,
6996 Handle<DescriptorArray> descriptors,
7003 Handle<Name> key = descriptor->GetKey();
7006 Handle<DescriptorArray> new_descriptors = DescriptorArray::CopyUpTo(
7019 void Map::UpdateCodeCache(Handle<Map> map,
7020 Handle<Name> name,
7021 Handle<Code> code) {
7026 Handle<Object> result = isolate->factory()->NewCodeCache();
7031 Handle<CodeCache> code_cache(CodeCache::cast(map->code_cache()), isolate);
7270 Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code) {
7277 Handle<Object> result =
7291 Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code) {
7299 Handle<FixedArray> cache = handle(code_cache->default_cache());
7350 Handle<CodeCache> code_cache, Handle<Name> name, Handle<Code> code) {
7352 Handle<CodeCacheHashTable> cache(
7354 Handle<Object> new_cache = CodeCacheHashTable::Put(cache, name, code);
7439 CodeCacheHashTableKey(Handle<Name> name, Code::Flags flags)
7442 CodeCacheHashTableKey(Handle<Name> name, Handle<Code> code)
7469 MUST_USE_RESULT Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
7470 Handle<Code> code = code_.ToHandleChecked();
7471 Handle<FixedArray> pair = isolate->factory()->NewFixedArray(2);
7478 Handle<Name> name_;
7487 CodeCacheHashTableKey key(handle(name), flags);
7494 Handle<CodeCacheHashTable> CodeCacheHashTable::Put(
7495 Handle<CodeCacheHashTable> cache, Handle<Name> name, Handle<Code> code) {
7498 Handle<CodeCacheHashTable> new_cache = EnsureCapacity(cache, 1, &key);
7501 Handle<Object> k = key.AsHandle(cache->GetIsolate());
7512 CodeCacheHashTableKey key(handle(name), flags);
7527 void PolymorphicCodeCache::Update(Handle<PolymorphicCodeCache> code_cache,
7530 Handle<Code> code) {
7533 Handle<PolymorphicCodeCacheHashTable> result =
7543 Handle<PolymorphicCodeCacheHashTable> hash_table =
7544 handle(PolymorphicCodeCacheHashTable::cast(code_cache->cache()));
7545 Handle<PolymorphicCodeCacheHashTable> new_cache =
7551 Handle<Object> PolymorphicCodeCache::Lookup(MapHandleList* maps,
7556 return Handle<Object>(hash_table->Lookup(maps, flags), GetIsolate());
7619 MUST_USE_RESULT Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
7623 Handle<FixedArray> list =
7640 maps->Add(Handle<Map>(Map::cast(list->get(i))));
7661 Handle<PolymorphicCodeCacheHashTable> PolymorphicCodeCacheHashTable::Put(
7662 Handle<PolymorphicCodeCacheHashTable> hash_table,
7665 Handle<Code> code) {
7667 Handle<PolymorphicCodeCacheHashTable> cache =
7671 Handle<Object> obj = key.AsHandle(hash_table->GetIsolate());
7689 Handle<FixedArray> content,
7690 Handle<JSObject> array) {
7693 Handle<FixedArray> result;
7712 MaybeHandle<FixedArray> FixedArray::UnionOfKeys(Handle<FixedArray> first,
7713 Handle<FixedArray> second) {
7715 Handle<FixedArray> result;
7719 Handle<Object>::null(), // receiver
7720 Handle<JSObject>::null(), // holder
7722 Handle<FixedArrayBase>::cast(second)),
7738 Handle<FixedArray> FixedArray::CopySize(
7739 Handle<FixedArray> array, int new_length, PretenureFlag pretenure) {
7742 Handle<FixedArray> result =
7779 Handle<DescriptorArray> DescriptorArray::Allocate(Isolate* isolate,
7788 Handle<FixedArray> result = factory->NewFixedArray(LengthFor(size));
7792 return Handle<DescriptorArray>::cast(result);
7827 Descriptor desc(handle(src->GetKey(index)),
7828 handle(value, src->GetIsolate()),
7893 Handle<AccessorPair> AccessorPair::Copy(Handle<AccessorPair> pair) {
7894 Handle<AccessorPair> copy = pair->GetIsolate()->factory()->NewAccessorPair();
7907 Handle<DeoptimizationInputData> DeoptimizationInputData::New(
7910 return Handle<DeoptimizationInputData>::cast(
7916 Handle<DeoptimizationOutputData> DeoptimizationOutputData::New(
7920 Handle<FixedArray> result;
7927 return Handle<DeoptimizationOutputData>::cast(result);
8151 FlatStringReader::FlatStringReader(Isolate* isolate, Handle<String> str)
8169 Handle<String> str(str_);
8472 Handle<FixedArray> String::CalculateLineEnds(Handle<String> src,
8497 Handle<FixedArray> array = isolate->factory()->NewFixedArray(line_count);
8705 bool String::SlowEquals(Handle<String> one, Handle<String> two) {
8872 Handle<String> SeqString::Truncate(Handle<SeqString> string, int new_length) {
8949 // Handle some edge cases
9143 Handle<JSFunction> JSFunction::CloneClosure(Handle<JSFunction> function) {
9145 Handle<Map> map(function->map());
9146 Handle<SharedFunctionInfo> shared(function->shared());
9147 Handle<Context> context(function->context());
9148 Handle<JSFunction> clone =
9158 Handle<Object> original_prototype(map->prototype(), isolate);
9168 Handle<SharedFunctionInfo> shared,
9169 Handle<Context> native_context,
9170 Handle<Code> code,
9171 Handle<FixedArray> literals,
9177 Handle<FixedArray> new_code_map;
9178 Handle<Object> value(shared->optimized_code_map(), isolate);
9188 Handle<FixedArray> old_code_map = Handle<FixedArray>::cast(value);
9312 void JSObject::OptimizeAsPrototype(Handle<JSObject> object,
9325 Handle<Map> new_map = Map::Copy(handle(object->map()));
9332 void JSObject::ReoptimizeIfPrototype(Handle<JSObject> object) {
9338 Handle<Object> CacheInitialJSArrayMaps(
9339 Handle<Context> native_context, Handle<Map> initial_map) {
9343 Handle<FixedArray> maps = factory->NewFixedArrayWithHoles(
9346 Handle<Map> current_map = initial_map;
9352 Handle<Map> new_map;
9355 new_map = handle(current_map->elements_transition_map());
9369 void JSFunction::SetInstancePrototype(Handle<JSFunction> function,
9370 Handle<Object> value) {
9386 Handle<Map> initial_map(function->initial_map(), isolate);
9395 Handle<Map> new_map = Map::Copy(initial_map);
9405 CacheInitialJSArrayMaps(handle(native_context, isolate), new_map);
9422 void JSFunction::SetPrototype(Handle<JSFunction> function,
9423 Handle<Object> value) {
9425 Handle<Object> construct_prototype = value;
9435 Handle<Map> new_map = Map::Copy(handle(function->map()));
9441 construct_prototype = handle(
9474 void JSFunction::SetInitialMap(Handle<JSFunction> function, Handle<Map> map,
9475 Handle<Object> prototype) {
9477 Handle<JSObject> js_proto = Handle<JSObject>::cast(prototype);
9486 void JSFunction::EnsureHasInitialMap(Handle<JSFunction> function) {
9504 Handle<Map> map = isolate->factory()->NewMap(instance_type, instance_size);
9507 Handle<Object> prototype;
9509 prototype = handle(function->instance_prototype(), isolate);
9518 JSFunction::SetInitialMap(function, map, Handle<JSReceiver>::cast(prototype));
9580 Handle<Oddball> oddball,
9582 Handle<Object> to_number,
9584 Handle<String> internalized_to_string =
9592 void Script::InitLineEnds(Handle<Script> script) {
9599 Handle<FixedArray> empty = isolate->factory()->NewFixedArray(0);
9605 Handle<String> src(String::cast(script->source()), isolate);
9607 Handle<FixedArray> array = String::CalculateLineEnds(src, true);
9618 int Script::GetColumnNumber(Handle<Script> script, int code_pos) {
9656 int Script::GetLineNumber(Handle<Script> script, int code_pos) {
9680 Handle<Object> Script::GetNameOrSourceURL(Handle<Script> script) {
9682 Handle<String> name_or_source_url_key =
9685 Handle<JSObject> script_wrapper = Script::GetWrapper(script);
9686 Handle<Object> property = Object::GetProperty(
9689 Handle<JSFunction> method = Handle<JSFunction>::cast(property);
9690 Handle<Object> result;
9703 // collector will call the weak callback on the global handle
9705 // handle.
9724 Handle<JSObject> Script::GetWrapper(Handle<Script> script) {
9726 // Return a handle for the existing script wrapper from the cache.
9727 return Handle<JSValue>(
9733 Handle<JSFunction> constructor = isolate->script_function();
9734 Handle<JSValue> result =
9735 Handle<JSValue>::cast(isolate->factory()->NewJSObject(constructor));
9739 // Create a new weak global handle and use it to cache the wrapper
9742 Handle<Object> handle = isolate->global_handles()->Create(*result);
9743 GlobalHandles::MakeWeak(handle.location(),
9744 reinterpret_cast<void*>(handle.location()),
9747 reinterpret_cast<Address>(handle.location()));
9765 Handle<Object> SharedFunctionInfo::GetSourceCode() {
9767 Handle<String> source(String::cast(Script::cast(script())->source()));
10142 Handle<Object> p = it.rinfo()->target_object_handle(origin);
10145 Handle<Cell> cell = it.rinfo()->target_cell_handle();
10150 Handle<Object> p = it.rinfo()->target_object_handle(origin);
10160 Handle<Object> p = it.rinfo()->code_age_stub_handle(origin);
10290 if (object->IsMap()) maps->Add(handle(Map::cast(object)));
10320 code_list->Add(Handle<Code>(code));
10340 return handle(code);
10956 Handle<FixedArray> JSObject::SetFastElementsCapacityAndLength(
10957 Handle<JSObject> object,
10965 Handle<FixedArray> new_elements =
10988 Handle<FixedArrayBase> old_elements(object->elements());
10993 Handle<Map> new_map = (new_elements_kind != elements_kind)
10995 : handle(object->map());
11002 Handle<FixedArray> parameter_map = Handle<FixedArray>::cast(old_elements);
11012 Handle<JSArray>::cast(object)->set_length(Smi::FromInt(length));
11018 void JSObject::SetFastDoubleElementsCapacityAndLength(Handle<JSObject> object,
11024 Handle<FixedArrayBase> elems =
11036 Handle<Map> new_map = GetElementsTransitionMap(object, new_elements_kind);
11038 Handle<FixedArrayBase> old_elements(object->elements());
11051 Handle<JSArray>::cast(object)->set_length(Smi::FromInt(length));
11057 void JSArray::Initialize(Handle<JSArray> array, int capacity, int length) {
11064 void JSArray::Expand(Handle<JSArray> array, int required_size) {
11074 Handle<JSObject> object,
11076 List<Handle<Object> >* old_values,
11083 Handle<Object> value;
11085 value = Handle<Object>::cast(isolate->factory()->the_hole_value());
11094 static void EnqueueSpliceRecord(Handle<JSArray> object,
11096 Handle<JSArray> deleted,
11100 Handle<Object> index_object = isolate->factory()->NewNumberFromUint(index);
11101 Handle<Object> add_count_object =
11104 Handle<Object> args[] =
11108 Handle<JSFunction>(isolate->observers_enqueue_splice()),
11115 static void BeginPerformSplice(Handle<JSArray> object) {
11118 Handle<Object> args[] = { object };
11121 Handle<JSFunction>(isolate->observers_begin_perform_splice()),
11128 static void EndPerformSplice(Handle<JSArray> object) {
11131 Handle<Object> args[] = { object };
11134 Handle<JSFunction>(isolate->observers_end_perform_splice()),
11142 Handle<JSArray> array,
11143 Handle<Object> new_length_handle) {
11163 List<Handle<Object> > old_values;
11164 Handle<Object> old_length_handle(array->length(), isolate);
11182 Handle<FixedArray> keys = isolate->factory()->NewFixedArray(num_elements);
11192 Handle<Object> hresult;
11220 Handle<JSArray> deleted = isolate->factory()->NewJSArray(0);
11241 Handle<Map> Map::GetPrototypeTransition(Handle<Map> map,
11242 Handle<Object> prototype) {
11252 return Handle<Map>(Map::cast(result));
11255 return Handle<Map>();
11259 Handle<Map> Map::PutPrototypeTransition(Handle<Map> map,
11260 Handle<Object> prototype,
11261 Handle<Map> target_map) {
11272 Handle<FixedArray> cache(map->GetPrototypeTransitions());
11319 void Map::AddDependentCompilationInfo(Handle<Map> map,
11322 Handle<DependentCode> codes =
11323 DependentCode::Insert(handle(map->dependent_code(), info->isolate()),
11331 void Map::AddDependentCode(Handle<Map> map,
11333 Handle<Code> code) {
11334 Handle<DependentCode> codes = DependentCode::Insert(
11335 Handle<DependentCode>(map->dependent_code()), group, code);
11341 void Map::AddDependentIC(Handle<Map> map,
11342 Handle<Code> stub) {
11371 DependentCode* DependentCode::ForObject(Handle<HeapObject> object,
11375 return Handle<PropertyCell>::cast(object)->dependent_code();
11378 return Handle<AllocationSite>::cast(object)->dependent_code();
11380 return Handle<Map>::cast(object)->dependent_code();
11384 Handle<DependentCode> DependentCode::Insert(Handle<DependentCode> entries,
11386 Handle<Object> object) {
11398 Handle<DependentCode> new_entries = Handle<DependentCode>::cast(
11558 void DependentCode::AddToDependentICList(Handle<Code> stub) {
11620 Handle<Map> Map::TransitionToPrototype(Handle<Map> map,
11621 Handle<Object> prototype) {
11622 Handle<Map> new_map = GetPrototypeTransition(map, prototype);
11632 MaybeHandle<Object> JSObject::SetPrototype(Handle<JSObject> object,
11633 Handle<Object> value,
11654 Handle<Object> args[] = { object };
11677 Handle<JSObject> real_receiver = object;
11685 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter));
11691 Handle<Map> map(real_receiver->map());
11699 JSObject::OptimizeAsPrototype(Handle<JSObject>::cast(value), mode);
11702 Handle<Map> new_map = Map::TransitionToPrototype(map, value);
11720 void JSObject::EnsureCanContainElements(Handle<JSObject> object,
11734 Handle<JSObject> object,
11741 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), index);
11752 Handle<JSObject> object,
11754 Handle<Object> value,
11765 Handle<InterceptorInfo> interceptor(object->GetIndexedInterceptor());
11773 v8::Handle<v8::Value> result =
11787 Handle<JSObject> object,
11788 Handle<Object> receiver,
11789 Handle<Object> structure,
11791 Handle<Object> holder) {
11796 Handle<ExecutableAccessorInfo> data =
11797 Handle<ExecutableAccessorInfo>::cast(structure);
11802 Handle<JSObject> holder_handle = Handle<JSObject>::cast(holder);
11803 Handle<Object> number = isolate->factory()->NewNumberFromUint(index);
11804 Handle<String> key = isolate->factory()->NumberToString(number);
11808 v8::Handle<v8::Value> result = args.Call(call_fun, v8::Utils::ToLocal(key));
11811 Handle<Object> result_internal = v8::Utils::OpenHandle(*result);
11813 // Rebox handle before return.
11814 return handle(*result_internal, isolate);
11819 Handle<Object> getter(Handle<AccessorPair>::cast(structure)->getter(),
11824 receiver, Handle<JSReceiver>::cast(getter));
11832 receiver, Handle<DeclaredAccessorInfo>::cast(structure), isolate);
11840 MaybeHandle<Object> JSObject::SetElementWithCallback(Handle<JSObject> object,
11841 Handle<Object> structure,
11843 Handle<Object> value,
11844 Handle<JSObject> holder,
11854 Handle<ExecutableAccessorInfo> data =
11855 Handle<ExecutableAccessorInfo>::cast(structure);
11860 Handle<Object> number = isolate->factory()->NewNumberFromUint(index);
11861 Handle<String> key(isolate->factory()->NumberToString(number));
11873 Handle<Object> setter(AccessorPair::cast(*structure)->setter(), isolate);
11877 object, Handle<JSReceiver>::cast(setter), value);
11880 Handle<Object> key(isolate->factory()->NewNumberFromUint(index));
11881 Handle<Object> args[2] = { key, holder };
11888 // TODO(dcarney): Handle correctly.
11923 MaybeHandle<Object> JSObject::SetFastElement(Handle<JSObject> object,
11925 Handle<Object> value,
11942 Handle<FixedArray> backing_store(FixedArray::cast(object->elements()));
11945 backing_store = handle(FixedArray::cast(backing_store->get(1)));
11965 CHECK(Handle<JSArray>::cast(object)->length()->ToArrayIndex(&array_length));
12023 Handle
12033 Handle<FixedArray> new_elements =
12045 Handle<JSArray>::cast(object)->set_length(Smi::FromInt(array_length));
12052 Handle<JSObject> object,
12054 Handle<Object> value,
12064 Handle<FixedArray> elements(FixedArray::cast(object->elements()));
12067 Handle<SeededNumberDictionary> dictionary(is_arguments
12073 Handle<Object> element(dictionary->ValueAt(entry), isolate);
12091 Handle<Object> number = isolate->factory()->NewNumberFromUint(index);
12092 Handle<Object> args[2] = { number, object };
12100 Handle<AliasedArgumentsEntry> entry =
12101 Handle<AliasedArgumentsEntry>::cast(element);
12102 Handle<Context> context(Context::cast(elements->get(0)));
12127 Handle<Object> number = isolate->factory()->NewNumberFromUint(index);
12128 Handle<String> name = isolate->factory()->NumberToString(number);
12129 Handle<Object> args[1] = { name };
12137 Handle<SeededNumberDictionary> new_dictionary =
12152 JSArray::JSArrayUpdateLengthFromIndex(Handle<JSArray>::cast(object), index,
12160 CHECK(Handle<JSArray>::cast(object)->length()->ToArrayIndex(&new_length));
12189 Handle<JSObject> object,
12191 Handle<Object> value,
12196 Handle<FixedArrayBase> base_elms(FixedArrayBase::cast(object->elements()));
12203 Handle<FixedDoubleArray>::cast(base_elms)->is_the_hole(index))) {
12216 CHECK(Handle<JSArray>::cast(object)->length()->ToArrayIndex(&length));
12225 Handle<Object> result;
12235 ? static_cast<double>(Handle<Smi>::cast(value)->value())
12236 : Handle<HeapNumber>::cast(value)->value();
12248 Handle<FixedDoubleArray> elms(FixedDoubleArray::cast(object->elements()));
12254 Handle<JSArray>::cast(object)->length()->ToArrayIndex(&array_length));
12256 Handle<JSArray>::cast(object)->set_length(Smi::FromInt(index + 1));
12287 MaybeHandle<Object> JSReceiver::SetElement(Handle<JSReceiver> object,
12289 Handle<Object> value,
12294 Handle<JSProxy>::cast(object), object, index, value, strict_mode);
12297 Handle<JSObject>::cast(object), index, value, attributes, strict_mode);
12301 MaybeHandle<Object> JSObject::SetOwnElement(Handle<JSObject> object,
12303 Handle<Object> value,
12310 MaybeHandle<Object> JSObject::SetElement(Handle<JSObject> object,
12312 Handle<Object> value,
12342 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), index,
12350 Handle<Object> number = isolate->factory()->NewNumberFromUint(index);
12351 Handle<Object> args[] = { object, number };
12359 Handle<SeededNumberDictionary> dictionary = NormalizeElements(object);
12377 Handle<Object> old_value = isolate->factory()->the_hole_value();
12378 Handle<Object> old_length_handle;
12379 Handle<Object> new_length_handle;
12387 old_length_handle = handle(Handle<JSArray>::cast(object)->length(),
12392 Handle<Object> result;
12404 Handle<String> name = isolate->factory()->Uint32ToString(index);
12412 Handle<JSArray>::cast(object)->length())) {
12413 new_length_handle = handle(Handle<JSArray>::cast(object)->length(),
12420 BeginPerformSplice(Handle<JSArray>::cast(object));
12424 EndPerformSplice(Handle<JSArray>::cast(object));
12425 Handle<JSArray> deleted = isolate->factory()->NewJSArray(0);
12426 EnqueueSpliceRecord(Handle<JSArray>::cast(object), old_length, deleted,
12434 Handle<Object> new_value =
12450 Handle<JSObject> object,
12452 Handle<Object> value,
12472 Handle<JSArray>::cast(object), index)) {
12476 return JSArray::ReadOnlyLengthError(Handle<JSArray>::cast(object));
12492 Handle<External##Type##Array> array( \
12497 Handle<Fixed##Type##Array> array( \
12511 Handle<FixedArray> parameter_map(FixedArray::cast(object->elements()));
12513 Handle<Object> probe = index < length - 2 ?
12514 Handle<Object>(parameter_map->get(index + 2), isolate) :
12515 Handle<Object>();
12517 Handle<Context> context(Context::cast(parameter_map->get(0)));
12518 int context_index = Handle<Smi>::cast(probe)->value();
12526 value = Handle<Object>::cast(
12530 Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1)));
12580 void AllocationSite::DigestTransitionFeedback(Handle<AllocationSite> site,
12585 Handle<JSArray> transition_info =
12586 handle(JSArray::cast(site->transition_info()));
12634 void AllocationSite::AddDependentCompilationInfo(Handle<AllocationSite> site,
12638 Handle<DependentCode> dep(site->dependent_code());
12639 Handle<DependentCode> codes =
12642 info->dependencies(group)->Add(Handle<HeapObject>(*site), info->zone());
12659 void JSObject::UpdateAllocationSite(Handle<JSObject> object,
12666 Handle<AllocationSite> site;
12674 site = handle(memento->GetAllocationSite());
12680 void JSObject::TransitionElementsKind(Handle<JSObject> object,
12703 Handle<Map> new_map = GetElementsTransitionMap(object, to_kind);
12706 Handle<FixedArrayBase> elms(object->elements());
12712 Handle<FixedArrayBase> elms(object->elements());
12717 Object* raw_length = Handle<JSArray>::cast(object)->length();
12762 void JSArray::JSArrayUpdateLengthFromIndex(Handle<JSArray> array,
12764 Handle<Object> value) {
12770 Handle<Object> len = array->GetIsolate()->factory()->NewNumber(
12777 bool JSArray::IsReadOnlyLengthDescriptor(Handle<Map> jsarray_map) {
12781 Handle<Name> length_string = isolate->factory()->length_string();
12787 bool JSArray::WouldChangeReadOnlyLength(Handle<JSArray> array,
12803 MaybeHandle<Object> JSArray::ReadOnlyLengthError(Handle<JSArray> array) {
12805 Handle<Name> length = isolate->factory()->length_string();
12806 Handle<Object> args[2] = { length, array };
12814 Handle<JSObject> object,
12815 Handle<Object> receiver,
12823 Handle<InterceptorInfo> interceptor(object->GetIndexedInterceptor(), isolate);
12831 v8::Handle<v8::Value> result = args.Call(getter, index);
12834 Handle<Object> result_internal = v8::Utils::OpenHandle(*result);
12836 // Rebox handle before return.
12837 return handle(*result_internal, isolate);
12842 Handle<Object> result;
12938 bool JSObject::WouldConvertToSlowElements(Handle<Object> key) {
12941 Handle<FixedArrayBase> backing_store(FixedArrayBase::cast(elements()));
13097 Handle<JSObject> holder,
13098 Handle<Object> receiver,
13099 Handle<Name> name) {
13105 Handle<InterceptorInfo> interceptor(holder->GetNamedInterceptor(), isolate);
13106 Handle<String> name_string = Handle<String>::cast(name);
13116 v8::Handle<v8::Value> result =
13121 Handle<Object> result_internal = v8::Utils::OpenHandle(*result);
13123 // Rebox handle before return
13124 return handle(*result_internal, isolate);
13131 Handle<JSObject> object, Handle<JSReceiver> receiver) {
13133 Handle<InterceptorInfo> interceptor(object->GetNamedInterceptor());
13136 v8::Handle<v8::Object> result;
13150 return handle(*v8::Utils::OpenHandle(*result), isolate);
13156 Handle<JSObject> object, Handle<JSReceiver> receiver) {
13158 Handle<InterceptorInfo> interceptor(object->GetIndexedInterceptor());
13161 v8::Handle<v8::Object> result;
13175 return handle(*v8::Utils::OpenHandle(*result), isolate);
13179 Maybe<bool> JSObject::HasRealNamedProperty(Handle<JSObject> object,
13180 Handle<Name> key) {
13188 Maybe<bool> JSObject::HasRealElementProperty(Handle<JSObject> object,
13207 Handle<JSObject>::cast(PrototypeIterator::GetCurrent(iter)), index);
13217 Maybe<bool> JSObject::HasRealNamedCallbackProperty(Handle<JSObject> object,
13218 Handle<Name> key) {
13530 StringSharedKey(Handle<String> source,
13531 Handle<SharedFunctionInfo> shared,
13593 Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
13594 Handle<FixedArray> array = isolate->factory()->NewFixedArray(4);
13603 Handle<String> source_;
13604 Handle<SharedFunctionInfo> shared_;
13613 RegExpKey(Handle<String> string, JSRegExp::Flags flags)
13629 Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
13646 Handle<String> string_;
13651 Handle<Object> OneByteStringKey::AsHandle(Isolate* isolate) {
13657 Handle<Object> TwoByteStringKey::AsHandle(Isolate* isolate) {
13663 Handle<Object> SeqOneByteSubStringKey::AsHandle(Isolate* isolate) {
13679 explicit InternalizedStringKey(Handle<String> string)
13692 virtual Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
13696 Handle<Map> map;
13711 Handle<String> string_;
13730 Handle<Derived> HashTable<Derived, Shape, Key>::New(
13746 Handle<FixedArray> array = factory->NewFixedArray(length, pretenure);
13748 Handle<Derived> table = Handle<Derived>::cast(array);
13758 int NameDictionary::FindEntry(Handle<Name> key) {
13799 Handle<Derived> new_table,
13902 Handle<Derived> HashTable<Derived, Shape, Key>::EnsureCapacity(
13903 Handle<Derived> table,
13923 Handle<Derived> new_table = HashTable::New(
13935 Handle<Derived> HashTable<Derived, Shape, Key>::Shrink(Handle<Derived> table,
13955 Handle<Derived> new_table = HashTable::New(
13994 Handle<Object> >;
13996 template class HashTable<WeakHashTable, WeakHashTableShape<2>, Handle<Object> >;
13998 template class Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >;
14008 template Handle<SeededNumberDictionary>
14012 template Handle<UnseededNumberDictionary>
14016 template Handle<NameDictionary>
14017 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
14020 template Handle<SeededNumberDictionary>
14022 AtPut(Handle<SeededNumberDictionary>, uint32_t, Handle<Object>);
14024 template Handle<UnseededNumberDictionary>
14026 AtPut(Handle<UnseededNumberDictionary>, uint32_t, Handle<Object>);
14033 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
14045 template Handle<Object>
14046 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::DeleteProperty(
14047 Handle<NameDictionary>, int, JSObject::DeleteMode);
14049 template Handle<Object>
14051 DeleteProperty(Handle<SeededNumberDictionary>, int, JSObject::DeleteMode);
14053 template Handle<NameDictionary>
14054 HashTable<NameDictionary, NameDictionaryShape, Handle<Name> >::
14057 template Handle<NameDictionary>
14058 HashTable<NameDictionary, NameDictionaryShape, Handle<Name> >::
14059 Shrink(Handle<NameDictionary>, Handle<Name>);
14061 template Handle<SeededNumberDictionary>
14063 Shrink(Handle<SeededNumberDictionary>, uint32_t);
14065 template void Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
14071 NameDictionary, NameDictionaryShape, Handle<Name> >::SortMode);
14074 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
14077 template Handle<NameDictionary>
14078 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::Add(
14079 Handle<NameDictionary>, Handle<Name>, Handle<Object>, PropertyDetails);
14082 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
14083 GenerateNewEnumerationIndices(Handle<NameDictionary>);
14089 template Handle<SeededNumberDictionary>
14091 Add(Handle<SeededNumberDictionary>,
14093 Handle<Object>,
14096 template Handle<UnseededNumberDictionary>
14098 Add(Handle<UnseededNumberDictionary>,
14100 Handle<Object>,
14103 template Handle<SeededNumberDictionary>
14105 EnsureCapacity(Handle<SeededNumberDictionary>, int, uint32_t);
14107 template Handle<UnseededNumberDictionary>
14109 EnsureCapacity(Handle<UnseededNumberDictionary>, int, uint32_t);
14111 template Handle<NameDictionary>
14112 Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
14113 EnsureCapacity(Handle<NameDictionary>, int, Handle<Name>);
14120 int Dictionary<NameDictionary, NameDictionaryShape, Handle<Name> >::
14128 Handle<Object> JSObject::PrepareSlowElementsForSort(
14129 Handle<JSObject> object, uint32_t limit) {
14135 Handle<SeededNumberDictionary> dict(object->element_dictionary(), isolate);
14136 Handle<SeededNumberDictionary> new_dict =
14142 Handle<Smi> bailout(Smi::FromInt(-1), isolate);
14156 Handle<Object> value(dict->ValueAt(i), isolate);
14173 Handle<Object> result = SeededNumberDictionary::AddNumberEntry(
14184 Handle<Object> result = SeededNumberDictionary::AddNumberEntry(
14200 Handle<Object> result = SeededNumberDictionary::AddNumberEntry(
14219 Handle<Object> JSObject::PrepareElementsForSort(Handle<JSObject> object,
14224 return handle(Smi::FromInt(-1), isolate);
14230 Handle<SeededNumberDictionary> dict(object->element_dictionary());
14237 Handle<Map> new_map =
14242 Handle<FixedArray> fast_elements =
14251 return handle(Smi::FromInt(
14262 Handle<FixedArrayBase> elements_base(object->elements());
14268 return handle(Smi::FromInt(0), isolate);
14382 Handle<Object> ExternalUint8ClampedArray::SetValue(
14383 Handle<ExternalUint8ClampedArray> array,
14385 Handle<Object> value) {
14389 int int_value = Handle<Smi>::cast(value)->value();
14398 double double_value = Handle<HeapNumber>::cast(value)->value();
14416 return handle(Smi::FromInt(clamped_value), array->GetIsolate());
14421 static Handle<Object> ExternalArrayIntSetter(
14423 Handle<ExternalArrayClass> receiver,
14425 Handle<Object> value) {
14429 int int_value = Handle<Smi>::cast(value)->value();
14432 double double_value = Handle<HeapNumber>::cast(value)->value();
14445 Handle<Object> ExternalInt8Array::SetValue(Handle<ExternalInt8Array> array,
14447 Handle<Object> value) {
14453 Handle<Object> ExternalUint8Array::SetValue(Handle<ExternalUint8Array> array,
14455 Handle<Object> value) {
14461 Handle<Object> ExternalInt16Array::SetValue(Handle<ExternalInt16Array> array,
14463 Handle<Object> value) {
14469 Handle<Object> ExternalUint16Array::SetValue(Handle<ExternalUint16Array> array,
14471 Handle<Object> value) {
14477 Handle<Object> ExternalInt32Array::SetValue(Handle<ExternalInt32Array> array,
14479 Handle<Object> value) {
14485 Handle<Object> ExternalUint32Array::SetValue(
14486 Handle<ExternalUint32Array> array,
14488 Handle<Object> value) {
14492 int int_value = Handle<Smi>::cast(value)->value();
14495 double double_value = Handle<HeapNumber>::cast(value)->value();
14508 Handle<Object> ExternalFloat32Array::SetValue(
14509 Handle<ExternalFloat32Array> array,
14511 Handle<Object> value) {
14515 int int_value = Handle<Smi>::cast(value)->value();
14518 double double_value = Handle<HeapNumber>::cast(value)->value();
14531 Handle<Object> ExternalFloat64Array::SetValue(
14532 Handle<ExternalFloat64Array> array,
14534 Handle<Object> value) {
14550 Handle<PropertyCell> JSGlobalObject::EnsurePropertyCell(
14551 Handle<JSGlobalObject> global,
14552 Handle<Name> name) {
14557 Handle<PropertyCell> cell = isolate->factory()->NewPropertyCell(
14561 Handle<NameDictionary> dictionary = NameDictionary::Add(
14562 handle(global->property_dictionary()), name, cell, details);
14568 return handle(PropertyCell::cast(value));
14623 Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
14639 Handle<String> string) {
14649 Handle<String> string) {
14650 Handle<StringTable> string_table = isolate->factory()->string_table();
14656 Handle<String> result(String::cast(string_table->KeyAt(entry)), isolate);
14667 Handle<StringTable> string_table = isolate->factory()->string_table();
14673 Handle<String> result(String::cast(string_table->KeyAt(entry)), isolate);
14680 Handle<String> StringTable::LookupString(Isolate* isolate,
14681 Handle<String> string) {
14687 Handle<String> StringTable::LookupKey(Isolate* isolate, HashTableKey* key) {
14688 Handle<StringTable> table = isolate->factory()->string_table();
14693 return handle(String::cast(table->KeyAt(entry)), isolate);
14700 Handle<Object> string = key->AsHandle(isolate);
14711 return Handle<String>::cast(string);
14715 Handle<Object> CompilationCacheTable::Lookup(Handle<String> src,
14716 Handle<Context> context) {
14718 Handle<SharedFunctionInfo> shared(context->closure()->shared());
14723 return Handle<Object>(get(EntryToIndex(entry) + 1), isolate);
14727 Handle<Object> CompilationCacheTable::LookupEval(
14728 Handle<String> src, Handle<SharedFunctionInfo> outer_info,
14736 return Handle<Object>(get(EntryToIndex(entry) + 1), isolate);
14740 Handle<Object> CompilationCacheTable::LookupRegExp(Handle<String> src,
14747 return Handle<Object>(get(EntryToIndex(entry) + 1), isolate);
14751 Handle<CompilationCacheTable> CompilationCacheTable::Put(
14752 Handle<CompilationCacheTable> cache, Handle<String> src,
14753 Handle<Context> context, Handle<Object> value) {
14755 Handle<SharedFunctionInfo> shared(context->closure()->shared());
14759 Handle<Object> k = key.AsHandle(isolate);
14768 Handle<CompilationCacheTable> CompilationCacheTable::PutEval(
14769 Handle<CompilationCacheTable> cache, Handle<String> src,
14770 Handle<SharedFunctionInfo> outer_info, Handle<SharedFunctionInfo> value,
14775 Handle<Object> k = key.AsHandle(isolate);
14784 Handle<CompilationCacheTable> CompilationCacheTable::PutRegExp(
14785 Handle<CompilationCacheTable> cache, Handle<String> src,
14786 JSRegExp::Flags flags, Handle<FixedArray> value) {
14818 explicit StringsKey(Handle<FixedArray> strings) : strings_(strings) { }
14842 Handle<Object> AsHandle(Isolate* isolate) OVERRIDE { return strings_; }
14845 Handle<FixedArray> strings_;
14851 StringsKey key(handle(array));
14858 Handle<MapCache> MapCache::Put(
14859 Handle<MapCache> map_cache, Handle<FixedArray> array, Handle<Map> value) {
14862 Handle<MapCache> new_cache = EnsureCapacity(map_cache, 1, &key);
14872 Handle<Derived> Dictionary<Derived, Shape, Key>::New(
14877 Handle<Derived> dict = DerivedHashTable::New(isolate,
14890 Handle<Derived> dictionary) {
14895 Handle<FixedArray> iteration_order = factory->NewFixedArray(length);
14901 Handle<FixedArray> enumeration_order = factory->NewFixedArray(length);
14942 Handle<Derived> Dictionary<Derived, Shape, Key>::EnsureCapacity(
14943 Handle<Derived> dictionary, int n, Key key) {
14955 Handle<Object> Dictionary<Derived, Shape, Key>::DeleteProperty(
14956 Handle<Derived> dictionary,
14974 Handle<Derived> Dictionary<Derived, Shape, Key>::AtPut(
14975 Handle<Derived> dictionary, Key key, Handle<Object> value) {
14997 Handle<Derived> Dictionary<Derived, Shape, Key>::Add(
14998 Handle<Derived> dictionary,
15000 Handle<Object> value,
15015 Handle<Derived> dictionary,
15017 Handle<Object> value,
15021 Handle<Object> k = Shape::AsHandle(dictionary->GetIsolate(), key);
15061 Handle<SeededNumberDictionary> SeededNumberDictionary::AddNumberEntry(
15062 Handle<SeededNumberDictionary> dictionary,
15064 Handle<Object> value,
15072 Handle<UnseededNumberDictionary> UnseededNumberDictionary::AddNumberEntry(
15073 Handle<UnseededNumberDictionary> dictionary,
15075 Handle<Object> value) {
15081 Handle<SeededNumberDictionary> SeededNumberDictionary::AtNumberPut(
15082 Handle<SeededNumberDictionary> dictionary,
15084 Handle<Object> value) {
15090 Handle<UnseededNumberDictionary> UnseededNumberDictionary::AtNumberPut(
15091 Handle<UnseededNumberDictionary> dictionary,
15093 Handle<Object> value) {
15098 Handle<SeededNumberDictionary> SeededNumberDictionary::Set(
15099 Handle<SeededNumberDictionary> dictionary,
15101 Handle<Object> value,
15111 Handle<Object> object_key =
15118 Handle<UnseededNumberDictionary> UnseededNumberDictionary::Set(
15119 Handle<UnseededNumberDictionary> dictionary,
15121 Handle<Object> value) {
15124 Handle<Object> object_key =
15260 Object* ObjectHashTable::Lookup(Handle<Object> key) {
15275 Handle<ObjectHashTable> ObjectHashTable::Put(Handle<ObjectHashTable> table,
15276 Handle<Object> key,
15277 Handle<Object> value) {
15284 Handle<Smi> hash = Object::GetOrCreateHash(isolate, key);
15303 Handle<ObjectHashTable> ObjectHashTable::Remove(Handle<ObjectHashTable> table,
15304 Handle<Object> key,
15340 Object* WeakHashTable::Lookup(Handle<Object> key) {
15349 Handle<WeakHashTable> WeakHashTable::Put(Handle<WeakHashTable> table,
15350 Handle<Object> key,
15351 Handle<Object> value) {
15372 Handle<Object> key,
15373 Handle<Object> value) {
15385 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Allocate(
15397 Handle<FixedArray> backing_store = isolate->factory()->NewFixedArray(
15401 Handle<Derived> table = Handle<Derived>::cast(backing_store);
15413 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::EnsureGrowable(
15414 Handle<Derived> table) {
15429 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Shrink(
15430 Handle<Derived> table) {
15441 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Clear(
15442 Handle<Derived> table) {
15445 Handle<Derived> new_table =
15458 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Remove(
15459 Handle<Derived> table, Handle<Object> key, bool* was_present) {
15472 Handle<Derived> OrderedHashTable<Derived, Iterator, entrysize>::Rehash(
15473 Handle<Derived> table, int new_capacity) {
15476 Handle<Derived> new_table =
15518 Handle<Object> key, int hash) {
15535 Handle<Object> key) {
15571 template Handle<OrderedHashSet>
15575 template Handle<OrderedHashSet>
15577 Handle<OrderedHashSet> table);
15579 template Handle<OrderedHashSet>
15581 Handle<OrderedHashSet> table);
15583 template Handle<OrderedHashSet>
15585 Handle<OrderedHashSet> table);
15587 template Handle<OrderedHashSet>
15589 Handle<OrderedHashSet> table, Handle<Object> key, bool* was_present);
15592 Handle<Object> key, int hash);
15594 Handle<Object> key);
15603 template Handle<OrderedHashMap>
15607 template Handle<OrderedHashMap>
15609 Handle<OrderedHashMap> table);
15611 template Handle<OrderedHashMap>
15613 Handle<OrderedHashMap> table);
15615 template Handle<OrderedHashMap>
15617 Handle<OrderedHashMap> table);
15619 template Handle<OrderedHashMap>
15621 Handle<OrderedHashMap> table, Handle<Object> key, bool* was_present);
15624 Handle<Object> key, int hash);
15626 Handle<Object> key);
15635 bool OrderedHashSet::Contains(Handle<Object> key) {
15640 Handle<OrderedHashSet> OrderedHashSet::Add(Handle<OrderedHashSet> table,
15641 Handle<Object> key) {
15653 Object* OrderedHashMap::Lookup(Handle<Object> key) {
15661 Handle<OrderedHashMap> OrderedHashMap::Put(Handle<OrderedHashMap> table,
15662 Handle<Object> key,
15663 Handle<Object> value) {
15809 Handle<DeclaredAccessorDescriptor> DeclaredAccessorDescriptor::Create(
15812 Handle<DeclaredAccessorDescriptor> previous) {
15816 Handle<ByteArray> serialized_descriptor =
15818 Handle<DeclaredAccessorDescriptor> value =
15864 void DebugInfo::ClearBreakPoint(Handle<DebugInfo> debug_info,
15866 Handle<Object> break_point_object) {
15867 Handle<Object> break_point_info(debug_info->GetBreakPointInfo(code_position),
15871 Handle<BreakPointInfo>::cast(break_point_info),
15876 void DebugInfo::SetBreakPoint(Handle<DebugInfo> debug_info,
15880 Handle<Object> break_point_object) {
15882 Handle<Object> break_point_info(debug_info->GetBreakPointInfo(code_position),
15886 Handle<BreakPointInfo>::cast(break_point_info),
15902 Handle<FixedArray> old_break_points =
15903 Handle<FixedArray>(FixedArray::cast(debug_info->break_points()));
15904 Handle<FixedArray> new_break_points =
15918 Handle<BreakPointInfo> new_break_point_info = Handle<BreakPointInfo>::cast(
15956 Object* DebugInfo::FindBreakPointInfo(Handle<DebugInfo> debug_info,
15957 Handle<Object> break_point_object) {
15962 Handle<BreakPointInfo> break_point_info =
15963 Handle<BreakPointInfo>(BreakPointInfo::cast(
15993 void BreakPointInfo::ClearBreakPoint(Handle<BreakPointInfo> break_point_info,
15994 Handle<Object> break_point_object) {
16008 Handle<FixedArray> old_array =
16009 Handle<FixedArray>(
16011 Handle<FixedArray> new_array =
16028 void BreakPointInfo::SetBreakPoint(Handle<BreakPointInfo> break_point_info,
16029 Handle<Object> break_point_object) {
16041 Handle<FixedArray> array = isolate->factory()->NewFixedArray(2);
16048 Handle<FixedArray> old_array =
16049 Handle<FixedArray>(
16051 Handle<FixedArray> new_array =
16065 Handle<BreakPointInfo> break_point_info,
16066 Handle<Object> break_point_object) {
16265 Handle<JSArrayBuffer> JSTypedArray::MaterializeArrayBuffer(
16266 Handle<JSTypedArray> typed_array) {
16268 Handle<Map> map(typed_array->map());
16273 Handle<Map> new_map = Map::TransitionElementsTo(
16277 Handle<JSArrayBuffer> buffer = isolate->factory()->NewJSArrayBuffer();
16278 Handle<FixedTypedArrayBase> fixed_typed_array(
16285 Handle<ExternalArray> new_elements =
16299 Handle<JSArrayBuffer> JSTypedArray::GetBuffer() {
16300 Handle<Object> result(buffer(), GetIsolate());
16303 return Handle<JSArrayBuffer>::cast(result);
16305 Handle<JSTypedArray> self(this);
16321 Handle<HeapType> PropertyCell::UpdatedType(Handle<PropertyCell> cell,
16322 Handle<Object> value) {
16324 Handle<HeapType> old_type(cell->type(), isolate);
16325 Handle<HeapType> new_type = HeapType::Constant(value, isolate);
16340 void PropertyCell::SetValueInferType(Handle<PropertyCell> cell,
16341 Handle<Object> value) {
16344 Handle<HeapType> new_type = UpdatedType(cell, value);
16351 void PropertyCell::AddDependentCompilationInfo(Handle<PropertyCell> cell,
16353 Handle<DependentCode> codes =
16354 DependentCode::Insert(handle(cell->dependent_code(), info->isolate()),
