// 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 "src/objects.h"
|
|
// Has to be the last include (doesn't have include guards):
|
#include "src/objects/object-macros.h"
|
|
namespace v8 {
|
namespace internal {
|
|
class TemplateInfo : public Struct, public NeverReadOnlySpaceObject {
|
public:
|
using NeverReadOnlySpaceObject::GetHeap;
|
using NeverReadOnlySpaceObject::GetIsolate;
|
|
DECL_ACCESSORS(tag, Object)
|
DECL_ACCESSORS(serial_number, Object)
|
DECL_INT_ACCESSORS(number_of_properties)
|
DECL_ACCESSORS(property_list, Object)
|
DECL_ACCESSORS(property_accessors, Object)
|
|
DECL_VERIFIER(TemplateInfo)
|
|
DECL_CAST(TemplateInfo)
|
|
static const int kTagOffset = HeapObject::kHeaderSize;
|
static const int kSerialNumberOffset = kTagOffset + kPointerSize;
|
static const int kNumberOfProperties = kSerialNumberOffset + kPointerSize;
|
static const int kPropertyListOffset = kNumberOfProperties + kPointerSize;
|
static const int kPropertyAccessorsOffset =
|
kPropertyListOffset + kPointerSize;
|
static const int kHeaderSize = kPropertyAccessorsOffset + kPointerSize;
|
|
static const int kFastTemplateInstantiationsCacheSize = 1 * KB;
|
|
// While we could grow the slow 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 const int kSlowTemplateInstantiationsCacheSize = 1 * MB;
|
|
private:
|
DISALLOW_IMPLICIT_CONSTRUCTORS(TemplateInfo);
|
};
|
|
// See the api-exposed FunctionTemplate for more information.
|
class FunctionTemplateInfo : public TemplateInfo {
|
public:
|
// Handler invoked when calling an instance of this FunctionTemplateInfo.
|
// Either CallInfoHandler or Undefined.
|
DECL_ACCESSORS(call_code, Object)
|
|
// ObjectTemplateInfo or Undefined, used for the prototype property of the
|
// resulting JSFunction instance of this FunctionTemplate.
|
DECL_ACCESSORS(prototype_template, Object)
|
|
// In the case the prototype_template is Undefined we use the
|
// protoype_provider_template to retrieve the instance prototype. Either
|
// contains an ObjectTemplateInfo or Undefined.
|
DECL_ACCESSORS(prototype_provider_template, Object)
|
|
// Used to create protoype chains. The parent_template's prototype is set as
|
// __proto__ of this FunctionTemplate's instance prototype. Is either a
|
// FunctionTemplateInfo or Undefined.
|
DECL_ACCESSORS(parent_template, Object)
|
|
// Returns an InterceptorInfo or Undefined for named properties.
|
DECL_ACCESSORS(named_property_handler, Object)
|
// Returns an InterceptorInfo or Undefined for indexed properties/elements.
|
DECL_ACCESSORS(indexed_property_handler, Object)
|
|
// 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_ACCESSORS(instance_template, Object)
|
|
DECL_ACCESSORS(class_name, Object)
|
|
// If the signature is a FunctionTemplateInfo it is used to check whether the
|
// receiver calling the associated JSFunction is a compatible receiver, i.e.
|
// it is an instance of the signare FunctionTemplateInfo or any of the
|
// receiver's prototypes are.
|
DECL_ACCESSORS(signature, Object)
|
|
// Either a CallHandlerInfo or Undefined. If an instance_call_handler is
|
// provided the instances created from the associated JSFunction are marked as
|
// callable.
|
DECL_ACCESSORS(instance_call_handler, Object)
|
|
DECL_ACCESSORS(access_check_info, Object)
|
DECL_ACCESSORS(shared_function_info, Object)
|
|
// Internal field to store a flag bitfield.
|
DECL_INT_ACCESSORS(flag)
|
|
// "length" property of the final JSFunction.
|
DECL_INT_ACCESSORS(length)
|
|
// Either the_hole or a private symbol. Used to cache the result on
|
// the receiver under the the cached_property_name when this
|
// FunctionTemplateInfo is used as a getter.
|
DECL_ACCESSORS(cached_property_name, Object)
|
|
// Begin flag bits ---------------------
|
DECL_BOOLEAN_ACCESSORS(hidden_prototype)
|
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_provoider_template are instantiated.
|
DECL_BOOLEAN_ACCESSORS(remove_prototype)
|
|
// If set, do not attach a serial number to this FunctionTemplate and thus do
|
// not keep an instance boilerplate around.
|
DECL_BOOLEAN_ACCESSORS(do_not_cache)
|
|
// If not set an access may be performed on calling the associated JSFunction.
|
DECL_BOOLEAN_ACCESSORS(accept_any_receiver)
|
// End flag bits ---------------------
|
|
DECL_CAST(FunctionTemplateInfo)
|
|
// Dispatched behavior.
|
DECL_PRINTER(FunctionTemplateInfo)
|
DECL_VERIFIER(FunctionTemplateInfo)
|
|
static const int kInvalidSerialNumber = 0;
|
|
static const int kCallCodeOffset = TemplateInfo::kHeaderSize;
|
static const int kPrototypeTemplateOffset = kCallCodeOffset + kPointerSize;
|
static const int kPrototypeProviderTemplateOffset =
|
kPrototypeTemplateOffset + kPointerSize;
|
static const int kParentTemplateOffset =
|
kPrototypeProviderTemplateOffset + kPointerSize;
|
static const int kNamedPropertyHandlerOffset =
|
kParentTemplateOffset + kPointerSize;
|
static const int kIndexedPropertyHandlerOffset =
|
kNamedPropertyHandlerOffset + kPointerSize;
|
static const int kInstanceTemplateOffset =
|
kIndexedPropertyHandlerOffset + kPointerSize;
|
static const int kClassNameOffset = kInstanceTemplateOffset + kPointerSize;
|
static const int kSignatureOffset = kClassNameOffset + kPointerSize;
|
static const int kInstanceCallHandlerOffset = kSignatureOffset + kPointerSize;
|
static const int kAccessCheckInfoOffset =
|
kInstanceCallHandlerOffset + kPointerSize;
|
static const int kSharedFunctionInfoOffset =
|
kAccessCheckInfoOffset + kPointerSize;
|
static const int kFlagOffset = kSharedFunctionInfoOffset + kPointerSize;
|
static const int kLengthOffset = kFlagOffset + kPointerSize;
|
static const int kCachedPropertyNameOffset = kLengthOffset + kPointerSize;
|
static const int kSize = kCachedPropertyNameOffset + kPointerSize;
|
|
static Handle<SharedFunctionInfo> GetOrCreateSharedFunctionInfo(
|
Isolate* isolate, Handle<FunctionTemplateInfo> info,
|
MaybeHandle<Name> maybe_name);
|
// Returns parent function template or null.
|
inline FunctionTemplateInfo* GetParent(Isolate* isolate);
|
// Returns true if |object| is an instance of this function template.
|
inline bool IsTemplateFor(JSObject* object);
|
bool IsTemplateFor(Map* map);
|
inline bool instantiated();
|
|
inline bool BreakAtEntry();
|
|
// Helper function for cached accessors.
|
static MaybeHandle<Name> TryGetCachedPropertyName(Isolate* isolate,
|
Handle<Object> getter);
|
|
private:
|
// Bit position in the flag, from least significant bit position.
|
static const int kHiddenPrototypeBit = 0;
|
static const int kUndetectableBit = 1;
|
static const int kNeedsAccessCheckBit = 2;
|
static const int kReadOnlyPrototypeBit = 3;
|
static const int kRemovePrototypeBit = 4;
|
static const int kDoNotCacheBit = 5;
|
static const int kAcceptAnyReceiver = 6;
|
|
DISALLOW_IMPLICIT_CONSTRUCTORS(FunctionTemplateInfo);
|
};
|
|
class ObjectTemplateInfo : public TemplateInfo {
|
public:
|
DECL_ACCESSORS(constructor, Object)
|
DECL_ACCESSORS(data, Object)
|
DECL_INT_ACCESSORS(embedder_field_count)
|
DECL_BOOLEAN_ACCESSORS(immutable_proto)
|
|
DECL_CAST(ObjectTemplateInfo)
|
|
// Dispatched behavior.
|
DECL_PRINTER(ObjectTemplateInfo)
|
DECL_VERIFIER(ObjectTemplateInfo)
|
|
static const int kConstructorOffset = TemplateInfo::kHeaderSize;
|
// LSB is for immutable_proto, higher bits for embedder_field_count
|
static const int kDataOffset = kConstructorOffset + kPointerSize;
|
static const int kSize = kDataOffset + kPointerSize;
|
|
// Starting from given object template's constructor walk up the inheritance
|
// chain till a function template that has an instance template is found.
|
inline ObjectTemplateInfo* GetParent(Isolate* isolate);
|
|
private:
|
class IsImmutablePrototype : public BitField<bool, 0, 1> {};
|
class EmbedderFieldCount
|
: public BitField<int, IsImmutablePrototype::kNext, 29> {};
|
};
|
|
} // namespace internal
|
} // namespace v8
|
|
#include "src/objects/object-macros-undef.h"
|
|
#endif // V8_OBJECTS_TEMPLATES_H_
|
