// Copyright 2018 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.
#ifndef V8_OBJECTS_TEMPLATES_H_
#define V8_OBJECTS_TEMPLATES_H_
#include <stdint.h>
#include <optional>
#include <span>
#include <string_view>
#include "include/v8-exception.h"
#include "src/base/bit-field.h"
#include "src/handles/handles.h"
#include "src/objects/contexts.h"
#include "src/objects/struct.h"
// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"
namespace v8 {
class CFunctionInfo;
class StructBodyDescriptor;
namespace internal {
class FunctionTemplateRareData;
struct CFunctionWithSignature {
const Address address;
const CFunctionInfo* signature;
CFunctionWithSignature(const Address address, const CFunctionInfo* signature)
: address(address), signature(signature) {}
};
V8_OBJECT class TemplateInfo : public HeapObject {
V8_IT_ABSTRACT;
public:
static const int kFastTemplateInstantiationsCacheSize = 1 * KB;
// While we could grow the cache until we run out of memory, we put
// a limit on it anyway to not crash for embedders that re-create templates
// instead of caching them.
static constexpr int kMaxTemplateInstantiationsCacheSize = 1 * MB;
// Initial serial number value.
static const int kUninitializedSerialNumber = 0;
// Serial numbers less than this must not be reused.
static const int kFirstNonUniqueSerialNumber =
kFastTemplateInstantiationsCacheSize;
DECL_BOOLEAN_ACCESSORS(is_cacheable)
DECL_BOOLEAN_ACCESSORS(should_promote_to_read_only)
DECL_PRIMITIVE_ACCESSORS(serial_number, uint32_t)
// Initializes serial number if necessary and returns it.
uint32_t EnsureHasSerialNumber(Isolate* isolate);
inline uint32_t GetHash() const;
inline uint32_t template_info_flags() const;
inline void set_template_info_flags(uint32_t value);
// Whether or not to cache every instance: when we materialize a getter or
// setter from an lazy AccessorPair, we rely on this cache to be able to
// always return the same getter or setter. However, objects will be cloned
// anyways, so it's not observable if we didn't cache an instance.
// Furthermore, a badly behaved embedder might create an unlimited number of
// objects, so we limit the cache for those cases.
enum class CachingMode { kLimited, kUnlimited };
template <typename ReturnType>
static MaybeHandle<ReturnType> ProbeInstantiationsCache(
Isolate* isolate, DirectHandle<NativeContext> native_context,
DirectHandle<TemplateInfo> info, CachingMode caching_mode) {
return Cast<ReturnType>(
ProbeInstantiationsCache(isolate, native_context, info, caching_mode));
}
static MaybeHandle<Object> ProbeInstantiationsCache(
Isolate* isolate, DirectHandle<NativeContext> native_context,
DirectHandle<TemplateInfo> info, CachingMode caching_mode);
static void CacheTemplateInstantiation(
Isolate* isolate, DirectHandle<NativeContext> native_context,
DirectHandle<TemplateInfo> info, CachingMode caching_mode,
DirectHandle<Object> object);
static void UncacheTemplateInstantiation(
Isolate* isolate, DirectHandle<NativeContext> native_context,
DirectHandle<TemplateInfo> info, CachingMode caching_mode);
// Bit position in the template_info_base_flags, from least significant bit
// position.
using IsCacheableBit = base::BitField<bool, 0, 1, uint32_t>;
using ShouldPromoteToReadOnlyBit = IsCacheableBit::Next<bool, 1>;
using SerialNumberBits = ShouldPromoteToReadOnlyBit::Next<uint32_t, 29>;
TaggedMember<Smi> template_info_flags_;
} V8_OBJECT_END;
V8_OBJECT class TemplateInfoWithProperties : public TemplateInfo {
V8_IT_ABSTRACT;
public:
inline int number_of_properties() const;
inline void set_number_of_properties(int value);
inline Tagged<UnionOf<ArrayList, Undefined>> property_list() const;
inline void set_property_list(Tagged<UnionOf<ArrayList, Undefined>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<ArrayList, Undefined>> property_accessors() const;
inline void set_property_accessors(
Tagged<UnionOf<ArrayList, Undefined>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
TaggedMember<Smi> number_of_properties_;
TaggedMember<UnionOf<ArrayList, Undefined>> property_list_;
TaggedMember<UnionOf<ArrayList, Undefined>> property_accessors_;
} V8_OBJECT_END;
// Contains data members that are rarely set on a FunctionTemplateInfo.
V8_OBJECT class FunctionTemplateRareData : public Struct {
public:
inline Tagged<UnionOf<Undefined, ObjectTemplateInfo>> prototype_template()
const;
inline void set_prototype_template(
Tagged<UnionOf<Undefined, ObjectTemplateInfo>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<Undefined, FunctionTemplateInfo>>
prototype_provider_template() const;
inline void set_prototype_provider_template(
Tagged<UnionOf<Undefined, FunctionTemplateInfo>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<Undefined, FunctionTemplateInfo>> parent_template()
const;
inline void set_parent_template(
Tagged<UnionOf<Undefined, FunctionTemplateInfo>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<Undefined, InterceptorInfo>> named_property_handler()
const;
inline void set_named_property_handler(
Tagged<UnionOf<Undefined, InterceptorInfo>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<Undefined, InterceptorInfo>> indexed_property_handler()
const;
inline void set_indexed_property_handler(
Tagged<UnionOf<Undefined, InterceptorInfo>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<Undefined, ObjectTemplateInfo>> instance_template()
const;
inline void set_instance_template(
Tagged<UnionOf<Undefined, ObjectTemplateInfo>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<Undefined, FunctionTemplateInfo>>
instance_call_handler() const;
inline void set_instance_call_handler(
Tagged<UnionOf<Undefined, FunctionTemplateInfo>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<Undefined, AccessCheckInfo>> access_check_info() const;
inline void set_access_check_info(
Tagged<UnionOf<Undefined, AccessCheckInfo>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<FixedArray> c_function_overloads() const;
inline void set_c_function_overloads(
Tagged<FixedArray> value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
DECL_PRINTER(FunctionTemplateRareData)
DECL_VERIFIER(FunctionTemplateRareData)
using BodyDescriptor = StructBodyDescriptor;
public:
TaggedMember<UnionOf<Undefined, ObjectTemplateInfo>> prototype_template_;
TaggedMember<UnionOf<Undefined, FunctionTemplateInfo>>
prototype_provider_template_;
TaggedMember<UnionOf<Undefined, FunctionTemplateInfo>> parent_template_;
TaggedMember<UnionOf<Undefined, InterceptorInfo>> named_property_handler_;
TaggedMember<UnionOf<Undefined, InterceptorInfo>> indexed_property_handler_;
TaggedMember<UnionOf<Undefined, ObjectTemplateInfo>> instance_template_;
TaggedMember<UnionOf<Undefined, FunctionTemplateInfo>> instance_call_handler_;
TaggedMember<UnionOf<Undefined, AccessCheckInfo>> access_check_info_;
TaggedMember<FixedArray> c_function_overloads_;
} V8_OBJECT_END;
// See the api-exposed FunctionTemplate for more information.
V8_OBJECT class FunctionTemplateInfo : public TemplateInfoWithProperties {
public:
#define DECL_RARE_ACCESSORS(Name, CamelName, ...) \
inline Tagged<__VA_ARGS__> Get##CamelName() const; \
static inline void Set##CamelName( \
Isolate* isolate, \
DirectHandle<FunctionTemplateInfo> function_template_info, \
DirectHandle<__VA_ARGS__> Name);
// ObjectTemplateInfo or Undefined, used for the prototype property of the
// resulting JSFunction instance of this FunctionTemplate.
DECL_RARE_ACCESSORS(prototype_template, PrototypeTemplate,
UnionOf<Undefined, ObjectTemplateInfo>)
// In the case the prototype_template is Undefined we use the
// prototype_provider_template to retrieve the instance prototype. Either
// contains an FunctionTemplateInfo or Undefined.
DECL_RARE_ACCESSORS(prototype_provider_template, PrototypeProviderTemplate,
UnionOf<Undefined, FunctionTemplateInfo>)
// Used to create prototype chains. The parent_template's prototype is set as
// __proto__ of this FunctionTemplate's instance prototype. Is either a
// FunctionTemplateInfo or Undefined.
DECL_RARE_ACCESSORS(parent_template, ParentTemplate,
UnionOf<Undefined, FunctionTemplateInfo>)
// Returns an InterceptorInfo or Undefined for named properties.
DECL_RARE_ACCESSORS(named_property_handler, NamedPropertyHandler,
UnionOf<Undefined, InterceptorInfo>)
// Returns an InterceptorInfo or Undefined for indexed properties/elements.
DECL_RARE_ACCESSORS(indexed_property_handler, IndexedPropertyHandler,
UnionOf<Undefined, InterceptorInfo>)
// An ObjectTemplateInfo that is used when instantiating the JSFunction
// associated with this FunctionTemplateInfo. Contains either an
// ObjectTemplateInfo or Undefined. A default instance_template is assigned
// upon first instantiation if it's Undefined.
DECL_RARE_ACCESSORS(instance_template, InstanceTemplate,
UnionOf<Undefined, ObjectTemplateInfo>)
// Either a FunctionTemplateInfo or Undefined. If an instance_call_handler is
// provided the instances created from the associated JSFunction are marked as
// callable.
DECL_RARE_ACCESSORS(instance_call_handler, InstanceCallHandler,
UnionOf<Undefined, FunctionTemplateInfo>)
DECL_RARE_ACCESSORS(access_check_info, AccessCheckInfo,
UnionOf<Undefined, AccessCheckInfo>)
DECL_RARE_ACCESSORS(c_function_overloads, CFunctionOverloads, FixedArray)
#undef DECL_RARE_ACCESSORS
DECL_PRIMITIVE_ACCESSORS(flag, uint32_t)
DECL_RELAXED_UINT32_ACCESSORS(flag)
// Begin flag bits ---------------------
// This FunctionTemplateInfo is just a storage for callback function and
// callback data for a callable ObjectTemplate object.
DECL_BOOLEAN_ACCESSORS(is_object_template_call_handler)
DECL_BOOLEAN_ACCESSORS(has_side_effects)
DECL_BOOLEAN_ACCESSORS(undetectable)
// If set, object instances created by this function requires access check.
DECL_BOOLEAN_ACCESSORS(needs_access_check)
DECL_BOOLEAN_ACCESSORS(read_only_prototype)
// If set, do not create a prototype property for the associated
// JSFunction. This bit implies that neither the prototype_template nor the
// prototype_provider_template are instantiated.
DECL_BOOLEAN_ACCESSORS(remove_prototype)
// If not set an access may be performed on calling the associated JSFunction.
DECL_BOOLEAN_ACCESSORS(accept_any_receiver)
// This flag is used to check that the FunctionTemplateInfo instance is not
// changed after it became visible to TurboFan (either set in a
// SharedFunctionInfo or an accessor), because TF relies on immutability to
// safely read concurrently.
DECL_BOOLEAN_ACCESSORS(published)
// This specifies the permissible range of instance type of objects that can
// be allowed to be used as receivers with the given template.
DECL_PRIMITIVE_GETTER(allowed_receiver_instance_type_range_start,
InstanceType)
DECL_PRIMITIVE_GETTER(allowed_receiver_instance_type_range_end, InstanceType)
// End flag bits ---------------------
inline InstanceType GetInstanceType() const;
inline void SetInstanceType(int api_instance_type);
inline void SetAllowedReceiverInstanceTypeRange(int api_instance_type_start,
int api_instance_type_end);
static Handle<SharedFunctionInfo> GetOrCreateSharedFunctionInfo(
Isolate* isolate, DirectHandle<FunctionTemplateInfo> info,
MaybeDirectHandle<Name> maybe_name);
static Handle<SharedFunctionInfo> GetOrCreateSharedFunctionInfo(
LocalIsolate* isolate, DirectHandle<FunctionTemplateInfo> info,
DirectHandle<Name> maybe_name) {
// We don't support streaming compilation of scripts with natives, so we
// don't need an off-thread implementation of this.
UNREACHABLE();
}
// Returns parent function template or a null FunctionTemplateInfo.
inline Tagged<FunctionTemplateInfo> GetParent(Isolate* isolate);
// Returns true if |object| is an instance of this function template.
inline bool IsTemplateFor(Tagged<JSObject> object) const;
bool IsTemplateFor(Tagged<Map> map) const;
// Returns true if |object| is an API object and is constructed by this
// particular function template (skips walking up the chain of inheriting
// functions that is done by IsTemplateFor).
bool IsLeafTemplateForApiObject(Tagged<Object> object) const;
inline bool instantiated();
static void SealAndPrepareForPromotionToReadOnly(
Isolate* isolate, DirectHandle<FunctionTemplateInfo> info);
bool BreakAtEntry(Isolate* isolate);
bool HasInstanceType();
// Helper function for cached accessors.
static std::optional<Tagged<Name>> TryGetCachedPropertyName(
Isolate* isolate, Tagged<Object> getter);
// Fast API overloads.
uint32_t GetCFunctionsCount() const;
CFunctionWithSignature GetCFunction(uint32_t index) const;
// Bit position in the flag, from least significant bit position.
using IsObjectTemplateCallHandlerBit = base::BitField<bool, 0, 1, uint32_t>;
using HasSideEffectsBit = IsObjectTemplateCallHandlerBit::Next<bool, 1>;
using UndetectableBit = HasSideEffectsBit::Next<bool, 1>;
using NeedsAccessCheckBit = UndetectableBit::Next<bool, 1>;
using ReadOnlyPrototypeBit = NeedsAccessCheckBit::Next<bool, 1>;
using RemovePrototypeBit = ReadOnlyPrototypeBit::Next<bool, 1>;
using AcceptAnyReceiverBit = RemovePrototypeBit::Next<bool, 1>;
using PublishedBit = AcceptAnyReceiverBit::Next<bool, 1>;
using AllowedReceiverInstanceTypeRangeStartBits =
PublishedBit::Next<InstanceType, 12>;
using AllowedReceiverInstanceTypeRangeEndBits =
AllowedReceiverInstanceTypeRangeStartBits::Next<InstanceType, 12>;
// C function pointer that can be called from native code.
inline Address callback(IsolateForSandbox isolate) const;
inline void set_callback(IsolateForSandbox isolate, Address value);
inline void init_callback(IsolateForSandbox isolate, Address value);
inline void RemoveCallbackRedirectionForSerialization(
IsolateForSandbox isolate);
inline void RestoreCallbackRedirectionAfterDeserialization(
IsolateForSandbox isolate);
template <class IsolateT>
inline bool has_callback(IsolateT* isolate) const;
DECL_PRINTER(FunctionTemplateInfo)
DECL_VERIFIER(FunctionTemplateInfo)
class BodyDescriptor;
private:
// For ease of use of the BITFIELD macro.
inline int32_t relaxed_flag() const;
inline void set_relaxed_flag(int32_t flags);
// Enforce using SetInstanceType() and SetAllowedReceiverInstanceTypeRange()
// instead of raw accessors.
void set_instance_type(int value);
DECL_PRIMITIVE_SETTER(allowed_receiver_instance_type_range_start,
InstanceType)
DECL_PRIMITIVE_SETTER(allowed_receiver_instance_type_range_end, InstanceType)
static constexpr int kNoJSApiObjectType = 0;
static inline Tagged<FunctionTemplateRareData> EnsureFunctionTemplateRareData(
Isolate* isolate,
DirectHandle<FunctionTemplateInfo> function_template_info);
static Tagged<FunctionTemplateRareData> AllocateFunctionTemplateRareData(
Isolate* isolate,
DirectHandle<FunctionTemplateInfo> function_template_info);
public:
inline Tagged<UnionOf<String, Undefined>> class_name() const;
inline void set_class_name(Tagged<UnionOf<String, Undefined>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<String, Undefined>> interface_name() const;
inline void set_interface_name(Tagged<UnionOf<String, Undefined>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<FunctionTemplateInfo, Undefined>> signature() const;
inline void set_signature(
Tagged<UnionOf<FunctionTemplateInfo, Undefined>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<FunctionTemplateRareData, Undefined>> rare_data() const;
inline Tagged<UnionOf<FunctionTemplateRareData, Undefined>> rare_data(
AcquireLoadTag tag) const;
inline void set_rare_data(
Tagged<UnionOf<FunctionTemplateRareData, Undefined>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline void set_rare_data(
Tagged<UnionOf<FunctionTemplateRareData, Undefined>> value,
ReleaseStoreTag tag, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<UnionOf<SharedFunctionInfo, Undefined>> shared_function_info()
const;
inline void set_shared_function_info(
Tagged<UnionOf<SharedFunctionInfo, Undefined>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<Object> cached_property_name() const;
inline void set_cached_property_name(
Tagged<Object> value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline Tagged<Object> callback_data() const;
inline Tagged<Object> callback_data(AcquireLoadTag tag) const;
inline void set_callback_data(Tagged<Object> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline void set_callback_data(Tagged<Object> value, ReleaseStoreTag tag,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline int16_t length() const;
inline void set_length(int16_t value);
inline InstanceType instance_type() const;
inline void set_instance_type(InstanceType value);
inline uint32_t exception_context() const;
inline void set_exception_context(uint32_t value);
TaggedMember<UnionOf<String, Undefined>> class_name_;
TaggedMember<UnionOf<String, Undefined>> interface_name_;
TaggedMember<UnionOf<FunctionTemplateInfo, Undefined>> signature_;
TaggedMember<UnionOf<FunctionTemplateRareData, Undefined>> rare_data_;
TaggedMember<UnionOf<SharedFunctionInfo, Undefined>> shared_function_info_;
TaggedMember<Object> cached_property_name_;
TaggedMember<Object> callback_data_;
uint32_t flag_;
int16_t length_;
InstanceType instance_type_;
uint32_t exception_context_;
#if TAGGED_SIZE_8_BYTES
uint32_t optional_padding_;
#endif
ExternalPointerMember<kFunctionTemplateInfoCallbackTag> callback_;
} V8_OBJECT_END;
V8_OBJECT class ObjectTemplateInfo : public TemplateInfoWithProperties {
public:
DECL_INT_ACCESSORS(embedder_field_count)
DECL_BOOLEAN_ACCESSORS(immutable_proto)
DECL_BOOLEAN_ACCESSORS(code_like)
// Starting from given object template's constructor walk up the inheritance
// chain till a function template that has an instance template is found.
inline Tagged<ObjectTemplateInfo> GetParent(Isolate* isolate);
static void SealAndPrepareForPromotionToReadOnly(
Isolate* isolate, DirectHandle<ObjectTemplateInfo> info);
using BodyDescriptor = StructBodyDescriptor;
DECL_PRINTER(ObjectTemplateInfo)
DECL_VERIFIER(ObjectTemplateInfo)
inline Tagged<UnionOf<FunctionTemplateInfo, Undefined>> constructor() const;
inline void set_constructor(
Tagged<UnionOf<FunctionTemplateInfo, Undefined>> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
inline int data() const;
inline void set_data(int value);
TaggedMember<UnionOf<FunctionTemplateInfo, Undefined>> constructor_;
TaggedMember<Smi> data_;
private:
using IsImmutablePrototypeBit = base::BitField<bool, 0, 1, uint32_t>;
using IsCodeKindBit = IsImmutablePrototypeBit::Next<bool, 1>;
using EmbedderFieldCountBits = IsCodeKindBit::Next<int32_t, 28>;
friend class TorqueGeneratedBitFieldAsserts;
} V8_OBJECT_END;
V8_OBJECT class DictionaryTemplateInfo : public TemplateInfo {
public:
using BodyDescriptor = StructBodyDescriptor;
static DirectHandle<DictionaryTemplateInfo> Create(
Isolate* isolate, const std::span<const std::string_view>& names);
static DirectHandle<JSObject> NewInstance(
DirectHandle<NativeContext> context,
DirectHandle<DictionaryTemplateInfo> self,
const std::span<MaybeLocal<Value>>& property_values);
DECL_PRINTER(DictionaryTemplateInfo)
DECL_VERIFIER(DictionaryTemplateInfo)
inline Tagged<FixedArray> property_names() const;
inline void set_property_names(Tagged<FixedArray> value,
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
TaggedMember<FixedArray> property_names_;
} V8_OBJECT_END;
} // namespace internal
} // namespace v8
#include "src/objects/object-macros-undef.h"
#endif // V8_OBJECTS_TEMPLATES_H_