// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/api/api-natives.h"
#include "src/api/api-inl.h"
#include "src/common/globals.h"
#include "src/common/message-template.h"
#include "src/execution/isolate-inl.h"
#include "src/execution/protectors-inl.h"
#include "src/flags/flags.h"
#include "src/heap/heap-inl.h"
#include "src/logging/runtime-call-stats-scope.h"
#include "src/objects/api-callbacks.h"
#include "src/objects/lookup.h"
#include "src/objects/templates.h"
namespace v8 {
namespace internal {
namespace {
class V8_NODISCARD InvokeScope {
public:
explicit InvokeScope(Isolate* isolate)
: isolate_(isolate), save_context_(isolate) {}
~InvokeScope() {
bool has_exception = isolate_->has_exception();
if (has_exception) {
isolate_->ReportPendingMessages();
} else {
isolate_->clear_pending_message();
}
}
private:
Isolate* isolate_;
SaveContext save_context_;
};
MaybeHandle<JSObject> InstantiateObject(Isolate* isolate,
DirectHandle<ObjectTemplateInfo> data,
DirectHandle<JSReceiver> new_target,
bool is_prototype);
MaybeHandle<JSFunction> InstantiateFunction(
Isolate* isolate, DirectHandle<NativeContext> native_context,
DirectHandle<FunctionTemplateInfo> data,
MaybeDirectHandle<Name> maybe_name = {});
MaybeHandle<JSFunction> InstantiateFunction(
Isolate* isolate, DirectHandle<FunctionTemplateInfo> data,
MaybeDirectHandle<Name> maybe_name = {}) {
return InstantiateFunction(isolate, isolate->native_context(), data,
maybe_name);
}
MaybeDirectHandle<Object> Instantiate(Isolate* isolate,
DirectHandle<Object> data,
MaybeDirectHandle<Name> maybe_name = {}) {
if (IsFunctionTemplateInfo(*data)) {
return InstantiateFunction(isolate, Cast<FunctionTemplateInfo>(data),
maybe_name);
} else if (IsObjectTemplateInfo(*data)) {
return InstantiateObject(isolate, Cast<ObjectTemplateInfo>(data), {},
false);
} else {
return data;
}
}
MaybeDirectHandle<Object> DefineAccessorProperty(
Isolate* isolate, DirectHandle<JSObject> object, DirectHandle<Name> name,
DirectHandle<Object> getter, DirectHandle<Object> setter,
PropertyAttributes attributes) {
DCHECK_IMPLIES(IsFunctionTemplateInfo(*getter),
Cast<FunctionTemplateInfo>(*getter)->is_cacheable());
DCHECK_IMPLIES(IsFunctionTemplateInfo(*setter),
Cast<FunctionTemplateInfo>(*setter)->is_cacheable());
if (IsFunctionTemplateInfo(*getter) &&
Cast<FunctionTemplateInfo>(*getter)->BreakAtEntry(isolate)) {
ASSIGN_RETURN_ON_EXCEPTION(
isolate, getter,
InstantiateFunction(isolate, Cast<FunctionTemplateInfo>(getter)));
DirectHandle<Code> trampoline = BUILTIN_CODE(isolate, DebugBreakTrampoline);
Cast<JSFunction>(getter)->UpdateCode(isolate, *trampoline);
}
if (IsFunctionTemplateInfo(*setter) &&
Cast<FunctionTemplateInfo>(*setter)->BreakAtEntry(isolate)) {
ASSIGN_RETURN_ON_EXCEPTION(
isolate, setter,
InstantiateFunction(isolate, Cast<FunctionTemplateInfo>(setter)));
DirectHandle<Code> trampoline = BUILTIN_CODE(isolate, DebugBreakTrampoline);
Cast<JSFunction>(setter)->UpdateCode(isolate, *trampoline);
}
RETURN_ON_EXCEPTION(isolate, JSObject::DefineOwnAccessorIgnoreAttributes(
object, name, getter, setter, attributes));
return object;
}
MaybeDirectHandle<Object> DefineDataProperty(Isolate* isolate,
DirectHandle<JSObject> object,
DirectHandle<Name> name,
DirectHandle<Object> prop_data,
PropertyAttributes attributes) {
DirectHandle<Object> value;
ASSIGN_RETURN_ON_EXCEPTION(isolate, value,
Instantiate(isolate, prop_data, name));
PropertyKey key(isolate, name);
LookupIterator it(isolate, object, key, LookupIterator::OWN_SKIP_INTERCEPTOR);
#ifdef DEBUG
Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
DCHECK(maybe.IsJust());
if (it.IsFound()) {
THROW_NEW_ERROR(
isolate,
NewTypeError(MessageTemplate::kDuplicateTemplateProperty, name));
}
#endif
MAYBE_RETURN_NULL(Object::AddDataProperty(&it, value, attributes,
Just(ShouldThrow::kThrowOnError),
StoreOrigin::kNamed));
return value;
}
void DisableAccessChecks(Isolate* isolate, DirectHandle<JSObject> object) {
DirectHandle<Map> old_map(object->map(), isolate);
// Copy map so it won't interfere constructor's initial map.
DirectHandle<Map> new_map =
Map::Copy(isolate, old_map, "DisableAccessChecks");
new_map->set_is_access_check_needed(false);
JSObject::MigrateToMap(isolate, object, new_map);
}
void EnableAccessChecks(Isolate* isolate, DirectHandle<JSObject> object) {
DirectHandle<Map> old_map(object->map(), isolate);
// Copy map so it won't interfere constructor's initial map.
DirectHandle<Map> new_map = Map::Copy(isolate, old_map, "EnableAccessChecks");
new_map->set_is_access_check_needed(true);
new_map->set_may_have_interesting_properties(true);
JSObject::MigrateToMap(isolate, object, new_map);
}
class V8_NODISCARD AccessCheckDisableScope {
public:
AccessCheckDisableScope(Isolate* isolate, DirectHandle<JSObject> obj)
: isolate_(isolate),
disabled_(obj->map()->is_access_check_needed()),
obj_(obj) {
if (disabled_) {
DisableAccessChecks(isolate_, obj_);
}
}
~AccessCheckDisableScope() {
if (disabled_) {
EnableAccessChecks(isolate_, obj_);
}
}
private:
Isolate* isolate_;
const bool disabled_;
DirectHandle<JSObject> obj_;
};
Tagged<Object> GetIntrinsic(Isolate* isolate, v8::Intrinsic intrinsic) {
DirectHandle<Context> native_context = isolate->native_context();
DCHECK(!native_context.is_null());
switch (intrinsic) {
#define GET_INTRINSIC_VALUE(name, iname) \
case v8::k##name: \
return native_context->iname();
V8_INTRINSICS_LIST(GET_INTRINSIC_VALUE)
#undef GET_INTRINSIC_VALUE
}
return Tagged<Object>();
}
template <typename TemplateInfoT>
MaybeHandle<JSObject> ConfigureInstance(Isolate* isolate, Handle<JSObject> obj,
DirectHandle<TemplateInfoT> data) {
RCS_SCOPE(isolate, RuntimeCallCounterId::kConfigureInstance);
HandleScope scope(isolate);
// Disable access checks while instantiating the object.
AccessCheckDisableScope access_check_scope(isolate, obj);
// Walk the inheritance chain and copy all accessors to current object.
int max_number_of_properties = 0;
Tagged<TemplateInfoT> info = *data;
while (!info.is_null()) {
Tagged<Object> props = info->property_accessors();
if (!IsUndefined(props)) {
max_number_of_properties += Cast<ArrayList>(props)->length();
}
info = info->GetParent(isolate);
}
if (max_number_of_properties > 0) {
int valid_descriptors = 0;
// Use a temporary FixedArray to accumulate unique accessors.
DirectHandle<FixedArray> array =
isolate->factory()->NewFixedArray(max_number_of_properties);
// TODO(leszeks): Avoid creating unnecessary handles for cases where we
// don't need to append anything.
for (DirectHandle<TemplateInfoT> temp(*data, isolate); !(*temp).is_null();
temp = direct_handle(temp->GetParent(isolate), isolate)) {
// Accumulate accessors.
Tagged<Object> maybe_properties = temp->property_accessors();
if (!IsUndefined(maybe_properties)) {
valid_descriptors = AccessorInfo::AppendUnique(
isolate, direct_handle(maybe_properties, isolate), array,
valid_descriptors);
}
}
// Install accumulated accessors.
for (int i = 0; i < valid_descriptors; i++) {
DirectHandle<AccessorInfo> accessor(Cast<AccessorInfo>(array->get(i)),
isolate);
DirectHandle<Name> name(Cast<Name>(accessor->name()), isolate);
JSObject::SetAccessor(obj, name, accessor,
accessor->initial_property_attributes())
.Assert();
}
}
Tagged<Object> maybe_property_list = data->property_list();
if (IsUndefined(maybe_property_list)) return obj;
DirectHandle<ArrayList> properties(Cast<ArrayList>(maybe_property_list),
isolate);
// The properties list consists of tuples describing each property:
// - <name, property details, property value> (data property),
// - <name, property details, getter, setter> (accessor property),
// - <name, intrinsic marker, property details, property value>
// (intrinsic data property).
// See ApiNatives::AddDataProperty()/AddAccessorProperty() for details.
int properties_length = properties->length();
if (properties_length == 0) return obj;
int properties_count = 0;
for (int i = 0; i < properties_length;) {
auto name = direct_handle(Cast<Name>(properties->get(i++)), isolate);
Tagged<Object> bit = properties->get(i++);
if (IsSmi(bit)) {
PropertyDetails details(Cast<Smi>(bit));
PropertyAttributes attributes = details.attributes();
PropertyKind kind = details.kind();
if (kind == PropertyKind::kData) {
auto prop_data = handle(properties->get(i++), isolate);
RETURN_ON_EXCEPTION(isolate, DefineDataProperty(isolate, obj, name,
prop_data, attributes));
} else {
auto getter = direct_handle(properties->get(i++), isolate);
auto setter = direct_handle(properties->get(i++), isolate);
RETURN_ON_EXCEPTION(
isolate, DefineAccessorProperty(isolate, obj, name, getter, setter,
attributes));
}
} else {
// Intrinsic data property --- Get appropriate value from the current
// context.
PropertyDetails details(Cast<Smi>(properties->get(i++)));
PropertyAttributes attributes = details.attributes();
DCHECK_EQ(PropertyKind::kData, details.kind());
v8::Intrinsic intrinsic =
static_cast<v8::Intrinsic>(Smi::ToInt(properties->get(i++)));
auto prop_data = handle(GetIntrinsic(isolate, intrinsic), isolate);
RETURN_ON_EXCEPTION(isolate, DefineDataProperty(isolate, obj, name,
prop_data, attributes));
}
DCHECK_LE(i, properties_length);
properties_count++;
}
CHECK_EQ(properties_count, data->number_of_properties());
return obj;
}
bool IsSimpleInstantiation(Isolate* isolate, Tagged<ObjectTemplateInfo> info,
Tagged<JSReceiver> new_target) {
DisallowGarbageCollection no_gc;
if (!IsJSFunction(new_target)) return false;
Tagged<JSFunction> fun = Cast<JSFunction>(new_target);
if (!fun->shared()->IsApiFunction()) return false;
if (fun->shared()->api_func_data() != info->constructor()) return false;
if (info->immutable_proto()) return false;
return fun->native_context() == isolate->raw_native_context();
}
MaybeHandle<JSObject> InstantiateObject(Isolate* isolate,
DirectHandle<ObjectTemplateInfo> info,
DirectHandle<JSReceiver> new_target,
bool is_prototype) {
RCS_SCOPE(isolate, RuntimeCallCounterId::kInstantiateObject);
DirectHandle<JSFunction> constructor;
bool should_cache = info->is_cacheable();
if (!new_target.is_null()) {
if (IsSimpleInstantiation(isolate, *info, *new_target)) {
constructor = Cast<JSFunction>(new_target);
} else {
// Disable caching for subclass instantiation.
should_cache = false;
}
}
// Fast path.
Handle<JSObject> result;
if (should_cache) {
if (TemplateInfo::ProbeInstantiationsCache<JSObject>(
isolate, isolate->native_context(), info,
TemplateInfo::CachingMode::kLimited)
.ToHandle(&result)) {
return isolate->factory()->CopyJSObject(result);
}
}
if (constructor.is_null()) {
Tagged<Object> maybe_constructor_info = info->constructor();
if (IsUndefined(maybe_constructor_info)) {
constructor = isolate->object_function();
} else {
// Enter a new scope. Recursion could otherwise create a lot of handles.
HandleScope scope(isolate);
DirectHandle<FunctionTemplateInfo> cons_templ(
Cast<FunctionTemplateInfo>(maybe_constructor_info), isolate);
DirectHandle<JSFunction> tmp_constructor;
ASSIGN_RETURN_ON_EXCEPTION(isolate, tmp_constructor,
InstantiateFunction(isolate, cons_templ));
constructor = scope.CloseAndEscape(tmp_constructor);
}
if (new_target.is_null()) new_target = constructor;
}
const auto new_js_object_type =
constructor->has_initial_map() &&
IsJSApiWrapperObjectMap(constructor->initial_map())
? NewJSObjectType::kMaybeEmbedderFieldsAndApiWrapper
: NewJSObjectType::kMaybeEmbedderFieldsAndNoApiWrapper;
Handle<JSObject> object;
ASSIGN_RETURN_ON_EXCEPTION(
isolate, object,
JSObject::New(constructor, new_target, {}, new_js_object_type));
if (is_prototype) JSObject::OptimizeAsPrototype(object);
ASSIGN_RETURN_ON_EXCEPTION(isolate, result,
ConfigureInstance(isolate, object, info));
if (info->immutable_proto()) {
JSObject::SetImmutableProto(isolate, object);
}
if (!is_prototype) {
// Keep prototypes in slow-mode. Let them be lazily turned fast later on.
// TODO(dcarney): is this necessary?
JSObject::MigrateSlowToFast(result, 0, "ApiNatives::InstantiateObject");
// Don't cache prototypes.
if (should_cache) {
TemplateInfo::CacheTemplateInstantiation(
isolate, isolate->native_context(), info,
TemplateInfo::CachingMode::kLimited, result);
result = isolate->factory()->CopyJSObject(result);
}
}
return result;
}
namespace {
MaybeDirectHandle<Object> GetInstancePrototype(
Isolate* isolate, DirectHandle<Object> function_template) {
// Enter a new scope. Recursion could otherwise create a lot of handles.
HandleScope scope(isolate);
DirectHandle<JSFunction> parent_instance;
ASSIGN_RETURN_ON_EXCEPTION(
isolate, parent_instance,
InstantiateFunction(isolate,
Cast<FunctionTemplateInfo>(function_template)));
Handle<Object> instance_prototype;
// TODO(cbruni): decide what to do here.
ASSIGN_RETURN_ON_EXCEPTION(
isolate, instance_prototype,
JSReceiver::GetProperty(isolate, parent_instance,
isolate->factory()->prototype_string()));
return scope.CloseAndEscape(instance_prototype);
}
} // namespace
MaybeHandle<JSFunction> InstantiateFunction(
Isolate* isolate, DirectHandle<NativeContext> native_context,
DirectHandle<FunctionTemplateInfo> info,
MaybeDirectHandle<Name> maybe_name) {
RCS_SCOPE(isolate, RuntimeCallCounterId::kInstantiateFunction);
bool should_cache = info->is_cacheable();
if (should_cache) {
Handle<JSObject> result;
if (TemplateInfo::ProbeInstantiationsCache<JSObject>(
isolate, native_context, info,
TemplateInfo::CachingMode::kUnlimited)
.ToHandle(&result)) {
return Cast<JSFunction>(result);
}
}
DirectHandle<Object> prototype;
if (!info->remove_prototype()) {
DirectHandle<Object> prototype_templ(info->GetPrototypeTemplate(), isolate);
if (IsUndefined(*prototype_templ)) {
DirectHandle<Object> protoype_provider_templ(
info->GetPrototypeProviderTemplate(), isolate);
if (IsUndefined(*protoype_provider_templ)) {
prototype = isolate->factory()->NewJSObject(
direct_handle(native_context->object_function(), isolate));
} else {
ASSIGN_RETURN_ON_EXCEPTION(
isolate, prototype,
GetInstancePrototype(isolate, protoype_provider_templ));
}
} else {
ASSIGN_RETURN_ON_EXCEPTION(
isolate, prototype,
InstantiateObject(isolate, Cast<ObjectTemplateInfo>(prototype_templ),
DirectHandle<JSReceiver>(), true));
}
DirectHandle<Object> parent(info->GetParentTemplate(), isolate);
if (!IsUndefined(*parent)) {
DirectHandle<Object> parent_prototype;
ASSIGN_RETURN_ON_EXCEPTION(isolate, parent_prototype,
GetInstancePrototype(isolate, parent));
DirectHandle<JSPrototype> checked_parent_prototype;
CHECK(TryCast(parent_prototype, &checked_parent_prototype));
JSObject::ForceSetPrototype(isolate, Cast<JSObject>(prototype),
checked_parent_prototype);
}
}
InstanceType function_type = JS_SPECIAL_API_OBJECT_TYPE;
if (!info->needs_access_check() &&
IsUndefined(info->GetNamedPropertyHandler()) &&
IsUndefined(info->GetIndexedPropertyHandler())) {
function_type = JS_API_OBJECT_TYPE;
DCHECK(InstanceTypeChecker::IsJSApiObject(function_type));
}
Handle<JSFunction> function = ApiNatives::CreateApiFunction(
isolate, native_context, info, prototype, function_type, maybe_name);
if (should_cache) {
// Cache the function.
TemplateInfo::CacheTemplateInstantiation(
isolate, native_context, info, TemplateInfo::CachingMode::kUnlimited,
function);
}
MaybeDirectHandle<JSObject> result =
ConfigureInstance(isolate, function, info);
if (result.is_null()) {
// Uncache on error.
TemplateInfo::UncacheTemplateInstantiation(
isolate, native_context, info, TemplateInfo::CachingMode::kUnlimited);
return {};
}
info->set_published(true);
return function;
}
void AddPropertyToPropertyList(Isolate* isolate,
DirectHandle<TemplateInfoWithProperties> info,
base::Vector<DirectHandle<Object>> data) {
Tagged<Object> maybe_list = info->property_list();
DirectHandle<ArrayList> list;
if (IsUndefined(maybe_list)) {
list = ArrayList::New(isolate, static_cast<int>(data.size()),
AllocationType::kOld);
} else {
list = direct_handle(Cast<ArrayList>(maybe_list), isolate);
}
info->set_number_of_properties(info->number_of_properties() + 1);
for (DirectHandle<Object> value : data) {
if (value.is_null()) {
value = Cast<Object>(isolate->factory()->undefined_value());
}
list = ArrayList::Add(isolate, list, value);
}
info->set_property_list(*list);
}
} // namespace
// static
DirectHandle<FunctionTemplateInfo>
ApiNatives::CreateAccessorFunctionTemplateInfo(
Isolate* i_isolate, FunctionCallback callback, int length,
SideEffectType side_effect_type) {
// TODO(v8:5962): move FunctionTemplateNew() from api.cc here.
auto isolate = reinterpret_cast<v8::Isolate*>(i_isolate);
Local<FunctionTemplate> func_template = FunctionTemplate::New(
isolate, callback, v8::Local<Value>{}, v8::Local<v8::Signature>{}, length,
v8::ConstructorBehavior::kThrow, side_effect_type);
return Utils::OpenDirectHandle(*func_template);
}
MaybeHandle<JSFunction> ApiNatives::InstantiateFunction(
Isolate* isolate, DirectHandle<NativeContext> native_context,
DirectHandle<FunctionTemplateInfo> data,
MaybeDirectHandle<Name> maybe_name) {
InvokeScope invoke_scope(isolate);
return ::i::InstantiateFunction(isolate, native_context, data, maybe_name);
}
MaybeHandle<JSFunction> ApiNatives::InstantiateFunction(
Isolate* isolate, DirectHandle<FunctionTemplateInfo> data,
MaybeDirectHandle<Name> maybe_name) {
InvokeScope invoke_scope(isolate);
return ::i::InstantiateFunction(isolate, data, maybe_name);
}
MaybeHandle<JSObject> ApiNatives::InstantiateObject(
Isolate* isolate, DirectHandle<ObjectTemplateInfo> data,
DirectHandle<JSReceiver> new_target) {
InvokeScope invoke_scope(isolate);
return ::i::InstantiateObject(isolate, data, new_target, false);
}
MaybeHandle<JSObject> ApiNatives::InstantiateRemoteObject(
DirectHandle<ObjectTemplateInfo> data) {
Isolate* isolate = Isolate::Current();
InvokeScope invoke_scope(isolate);
DirectHandle<FunctionTemplateInfo> constructor(
Cast<FunctionTemplateInfo>(data->constructor()), isolate);
DirectHandle<Map> object_map = isolate->factory()->NewContextlessMap(
JS_SPECIAL_API_OBJECT_TYPE,
JSSpecialObject::kHeaderSize +
data->embedder_field_count() * kEmbedderDataSlotSize,
TERMINAL_FAST_ELEMENTS_KIND);
object_map->SetConstructor(*constructor);
object_map->set_is_access_check_needed(true);
object_map->set_may_have_interesting_properties(true);
Handle<JSObject> object = isolate->factory()->NewJSObjectFromMap(
object_map, AllocationType::kYoung, DirectHandle<AllocationSite>::null(),
NewJSObjectType::kMaybeEmbedderFieldsAndApiWrapper);
JSObject::ForceSetPrototype(isolate, object,
isolate->factory()->null_value());
return object;
}
void ApiNatives::AddDataProperty(Isolate* isolate,
DirectHandle<TemplateInfoWithProperties> info,
DirectHandle<Name> name,
DirectHandle<Object> value,
PropertyAttributes attributes) {
if (IsString(*name)) {
name = isolate->factory()->InternalizeString(Cast<String>(name));
}
PropertyDetails details(PropertyKind::kData, attributes,
PropertyConstness::kMutable);
DirectHandle<Object> data[] = {name, direct_handle(details.AsSmi(), isolate),
value};
AddPropertyToPropertyList(isolate, info, base::VectorOf(data));
}
void ApiNatives::AddDataProperty(Isolate* isolate,
DirectHandle<TemplateInfoWithProperties> info,
DirectHandle<Name> name,
v8::Intrinsic intrinsic,
PropertyAttributes attributes) {
if (IsString(*name)) {
name = isolate->factory()->InternalizeString(Cast<String>(name));
}
auto value = direct_handle(Smi::FromInt(intrinsic), isolate);
auto intrinsic_marker = isolate->factory()->true_value();
PropertyDetails details(PropertyKind::kData, attributes,
PropertyConstness::kMutable);
DirectHandle<Object> data[] = {
name, intrinsic_marker, direct_handle(details.AsSmi(), isolate), value};
AddPropertyToPropertyList(isolate, info, base::VectorOf(data));
}
void ApiNatives::AddAccessorProperty(
Isolate* isolate, DirectHandle<TemplateInfoWithProperties> info,
DirectHandle<Name> name, DirectHandle<FunctionTemplateInfo> getter,
DirectHandle<FunctionTemplateInfo> setter, PropertyAttributes attributes) {
if (IsString(*name)) {
name = isolate->factory()->InternalizeString(Cast<String>(name));
}
if (!getter.is_null()) getter->set_published(true);
if (!setter.is_null()) setter->set_published(true);
PropertyDetails details(PropertyKind::kAccessor, attributes,
PropertyConstness::kMutable);
DirectHandle<Object> data[] = {name, direct_handle(details.AsSmi(), isolate),
getter, setter};
AddPropertyToPropertyList(isolate, info, base::VectorOf(data));
}
void ApiNatives::AddNativeDataProperty(
Isolate* isolate, DirectHandle<TemplateInfoWithProperties> info,
DirectHandle<AccessorInfo> property) {
Tagged<Object> maybe_list = info->property_accessors();
DirectHandle<ArrayList> list;
if (IsUndefined(maybe_list)) {
list = ArrayList::New(isolate, 1, AllocationType::kOld);
} else {
list = direct_handle(Cast<ArrayList>(maybe_list), isolate);
}
list = ArrayList::Add(isolate, list, property);
info->set_property_accessors(*list);
}
Handle<JSFunction> ApiNatives::CreateApiFunction(
Isolate* isolate, DirectHandle<NativeContext> native_context,
DirectHandle<FunctionTemplateInfo> obj, DirectHandle<Object> prototype,
InstanceType type, MaybeDirectHandle<Name> maybe_name) {
RCS_SCOPE(isolate, RuntimeCallCounterId::kCreateApiFunction);
DirectHandle<SharedFunctionInfo> shared =
FunctionTemplateInfo::GetOrCreateSharedFunctionInfo(isolate, obj,
maybe_name);
// To simplify things, API functions always have shared name.
DCHECK(shared->HasSharedName());
Handle<JSFunction> result =
Factory::JSFunctionBuilder{isolate, shared, native_context}.Build();
if (obj->remove_prototype()) {
DCHECK(prototype.is_null());
DCHECK(result->shared()->IsApiFunction());
DCHECK(!IsConstructor(*result));
DCHECK(!result->has_prototype_slot());
return result;
}
// Down from here is only valid for API functions that can be used as a
// constructor (don't set the "remove prototype" flag).
DCHECK(result->has_prototype_slot());
if (obj->read_only_prototype()) {
result->set_map(isolate,
*isolate->sloppy_function_with_readonly_prototype_map());
}
if (IsTheHole(*prototype)) {
prototype = isolate->factory()->NewFunctionPrototype(result);
} else if (IsUndefined(obj->GetPrototypeProviderTemplate())) {
JSObject::AddProperty(isolate, Cast<JSObject>(prototype),
isolate->factory()->constructor_string(), result,
DONT_ENUM);
}
int embedder_field_count = 0;
bool immutable_proto = false;
if (!IsUndefined(obj->GetInstanceTemplate())) {
DirectHandle<ObjectTemplateInfo> GetInstanceTemplate(
Cast<ObjectTemplateInfo>(obj->GetInstanceTemplate()), isolate);
embedder_field_count = GetInstanceTemplate->embedder_field_count();
immutable_proto = GetInstanceTemplate->immutable_proto();
}
// JSFunction requires information about the prototype slot.
DCHECK(!InstanceTypeChecker::IsJSFunction(type));
int instance_size = JSObject::GetHeaderSize(type) +
kEmbedderDataSlotSize * embedder_field_count;
DirectHandle<JSInterceptorMap> map =
Cast<JSInterceptorMap>(isolate->factory()->NewContextfulMap(
native_context, ExtendedMapKind::kJSInterceptorMap, type,
instance_size, TERMINAL_FAST_ELEMENTS_KIND));
map->init_flags_and_clear_extended_padding();
// Complete initialization of map's interceptor fields and set interceptor
// related bits.
{
Tagged<UnionOf<Undefined, InterceptorInfo>> maybe_interceptor =
obj->GetNamedPropertyHandler();
if (!IsUndefined(maybe_interceptor)) {
map->set_has_named_interceptor(true);
map->set_may_have_interesting_properties(true);
map->set_named_interceptor(Cast<InterceptorInfo>(maybe_interceptor));
} else {
map->set_named_interceptor(
ReadOnlyRoots(isolate).noop_named_interceptor_info());
}
maybe_interceptor = obj->GetIndexedPropertyHandler();
if (!IsUndefined(maybe_interceptor)) {
map->set_has_indexed_interceptor(true);
auto info = Cast<InterceptorInfo>(maybe_interceptor);
map->set_indexed_interceptor(info);
if (v8_flags.fast_api_iterable_to_list &&
info->has_indexed_iterable_to_list()) {
map->set_supports_fast_iterable_to_list(true);
}
} else {
map->set_indexed_interceptor(
ReadOnlyRoots(isolate).noop_indexed_interceptor_info());
}
// Initialize with invalidated cell, it'll be healed lazily upon the
// first usage.
map->set_fast_case_validity_cell(
ReadOnlyRoots(isolate).invalid_prototype_validity_cell());
}
// Mark as undetectable if needed.
if (obj->undetectable()) {
// We only allow callable undetectable receivers here, since this whole
// undetectable business is only to support document.all, which is both
// undetectable and callable. If we ever see the need to have an object
// that is undetectable but not callable, we need to update the types.h
// to allow encoding this.
CHECK(!IsUndefined(obj->GetInstanceCallHandler()));
if (Protectors::IsNoUndetectableObjectsIntact(isolate)) {
Protectors::InvalidateNoUndetectableObjects(isolate);
}
map->set_is_undetectable(true);
}
// Mark as needs_access_check if needed.
if (obj->needs_access_check()) {
map->set_is_access_check_needed(true);
map->set_may_have_interesting_properties(true);
}
// Mark instance as callable in the map.
if (!IsUndefined(obj->GetInstanceCallHandler())) {
map->set_is_callable(true);
map->set_is_constructor(!obj->undetectable());
}
if (immutable_proto) map->set_is_immutable_proto(true);
JSFunction::SetInitialMap(isolate, result, map, Cast<JSObject>(prototype));
if (map->supports_fast_iterable_to_list()) {
// %CheckFastIterableToListPrototype() relies on the constness tracking
// which requires the prototype to be in fast mode.
DirectHandle<Map> proto_map(Cast<JSObject>(prototype)->map(), isolate);
Map::SetShouldBeFastPrototypeMap(proto_map, true, isolate);
}
return result;
}
} // namespace internal
} // namespace v8