| // 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. |
| |
| #ifndef V8_OBJECTS_H_ |
| #define V8_OBJECTS_H_ |
| |
| #include <iosfwd> |
| #include <memory> |
| |
| #include "include/v8-internal.h" |
| #include "include/v8.h" |
| #include "include/v8config.h" |
| #include "src/assert-scope.h" |
| #include "src/base/bits.h" |
| #include "src/base/build_config.h" |
| #include "src/base/flags.h" |
| #include "src/base/logging.h" |
| #include "src/checks.h" |
| #include "src/constants-arch.h" |
| #include "src/elements-kind.h" |
| #include "src/field-index.h" |
| #include "src/flags.h" |
| #include "src/message-template.h" |
| #include "src/objects-definitions.h" |
| #include "src/property-details.h" |
| #include "src/roots.h" |
| #include "src/utils.h" |
| |
| |
| // Has to be the last include (doesn't have include guards): |
| #include "src/objects/object-macros.h" |
| |
| // |
| // Most object types in the V8 JavaScript are described in this file. |
| // |
| // Inheritance hierarchy: |
| // - Object |
| // - Smi (immediate small integer) |
| // - HeapObject (superclass for everything allocated in the heap) |
| // - JSReceiver (suitable for property access) |
| // - JSObject |
| // - JSArray |
| // - JSArrayBuffer |
| // - JSArrayBufferView |
| // - JSTypedArray |
| // - JSDataView |
| // - JSBoundFunction |
| // - JSCollection |
| // - JSSet |
| // - JSMap |
| // - JSStringIterator |
| // - JSSetIterator |
| // - JSMapIterator |
| // - JSWeakCollection |
| // - JSWeakMap |
| // - JSWeakSet |
| // - JSRegExp |
| // - JSFunction |
| // - JSGeneratorObject |
| // - JSGlobalObject |
| // - JSGlobalProxy |
| // - JSValue |
| // - JSDate |
| // - JSMessageObject |
| // - JSModuleNamespace |
| // - JSV8BreakIterator // If V8_INTL_SUPPORT enabled. |
| // - JSCollator // If V8_INTL_SUPPORT enabled. |
| // - JSDateTimeFormat // If V8_INTL_SUPPORT enabled. |
| // - JSListFormat // If V8_INTL_SUPPORT enabled. |
| // - JSLocale // If V8_INTL_SUPPORT enabled. |
| // - JSNumberFormat // If V8_INTL_SUPPORT enabled. |
| // - JSPluralRules // If V8_INTL_SUPPORT enabled. |
| // - JSRelativeTimeFormat // If V8_INTL_SUPPORT enabled. |
| // - JSSegmentIterator // If V8_INTL_SUPPORT enabled. |
| // - JSSegmenter // If V8_INTL_SUPPORT enabled. |
| // - WasmExceptionObject |
| // - WasmGlobalObject |
| // - WasmInstanceObject |
| // - WasmMemoryObject |
| // - WasmModuleObject |
| // - WasmTableObject |
| // - JSProxy |
| // - FixedArrayBase |
| // - ByteArray |
| // - BytecodeArray |
| // - FixedArray |
| // - FrameArray |
| // - HashTable |
| // - Dictionary |
| // - StringTable |
| // - StringSet |
| // - CompilationCacheTable |
| // - MapCache |
| // - OrderedHashTable |
| // - OrderedHashSet |
| // - OrderedHashMap |
| // - FeedbackMetadata |
| // - TemplateList |
| // - TransitionArray |
| // - ScopeInfo |
| // - ModuleInfo |
| // - ScriptContextTable |
| // - FixedDoubleArray |
| // - Name |
| // - String |
| // - SeqString |
| // - SeqOneByteString |
| // - SeqTwoByteString |
| // - SlicedString |
| // - ConsString |
| // - ThinString |
| // - ExternalString |
| // - ExternalOneByteString |
| // - ExternalTwoByteString |
| // - InternalizedString |
| // - SeqInternalizedString |
| // - SeqOneByteInternalizedString |
| // - SeqTwoByteInternalizedString |
| // - ConsInternalizedString |
| // - ExternalInternalizedString |
| // - ExternalOneByteInternalizedString |
| // - ExternalTwoByteInternalizedString |
| // - Symbol |
| // - Context |
| // - NativeContext |
| // - HeapNumber |
| // - BigInt |
| // - Cell |
| // - DescriptorArray |
| // - PropertyCell |
| // - PropertyArray |
| // - Code |
| // - AbstractCode, a wrapper around Code or BytecodeArray |
| // - Map |
| // - Oddball |
| // - Foreign |
| // - SmallOrderedHashTable |
| // - SmallOrderedHashMap |
| // - SmallOrderedHashSet |
| // - SharedFunctionInfo |
| // - Struct |
| // - AccessorInfo |
| // - AsmWasmData |
| // - PromiseReaction |
| // - PromiseCapability |
| // - AccessorPair |
| // - AccessCheckInfo |
| // - InterceptorInfo |
| // - CallHandlerInfo |
| // - EnumCache |
| // - TemplateInfo |
| // - FunctionTemplateInfo |
| // - ObjectTemplateInfo |
| // - Script |
| // - DebugInfo |
| // - BreakPoint |
| // - BreakPointInfo |
| // - StackFrameInfo |
| // - SourcePositionTableWithFrameCache |
| // - CodeCache |
| // - PrototypeInfo |
| // - Microtask |
| // - CallbackTask |
| // - CallableTask |
| // - PromiseReactionJobTask |
| // - PromiseFulfillReactionJobTask |
| // - PromiseRejectReactionJobTask |
| // - PromiseResolveThenableJobTask |
| // - Module |
| // - ModuleInfoEntry |
| // - FeedbackCell |
| // - FeedbackVector |
| // - PreParsedScopeData |
| // - UncompiledData |
| // - UncompiledDataWithoutPreParsedScope |
| // - UncompiledDataWithPreParsedScope |
| // |
| // Formats of Object*: |
| // Smi: [31 bit signed int] 0 |
| // HeapObject: [32 bit direct pointer] (4 byte aligned) | 01 |
| |
| namespace v8 { |
| namespace internal { |
| |
| struct InliningPosition; |
| class PropertyDescriptorObject; |
| |
| // SKIP_WRITE_BARRIER skips the write barrier. |
| // UPDATE_WEAK_WRITE_BARRIER skips the marking part of the write barrier and |
| // only performs the generational part. |
| // UPDATE_WRITE_BARRIER is doing the full barrier, marking and generational. |
| enum WriteBarrierMode { |
| SKIP_WRITE_BARRIER, |
| UPDATE_WEAK_WRITE_BARRIER, |
| UPDATE_WRITE_BARRIER |
| }; |
| |
| |
| // PropertyNormalizationMode is used to specify whether to keep |
| // inobject properties when normalizing properties of a JSObject. |
| enum PropertyNormalizationMode { |
| CLEAR_INOBJECT_PROPERTIES, |
| KEEP_INOBJECT_PROPERTIES |
| }; |
| |
| |
| // Indicates whether transitions can be added to a source map or not. |
| enum TransitionFlag { |
| INSERT_TRANSITION, |
| OMIT_TRANSITION |
| }; |
| |
| |
| // Indicates whether the transition is simple: the target map of the transition |
| // either extends the current map with a new property, or it modifies the |
| // property that was added last to the current map. |
| enum SimpleTransitionFlag { |
| SIMPLE_PROPERTY_TRANSITION, |
| PROPERTY_TRANSITION, |
| SPECIAL_TRANSITION |
| }; |
| |
| // Indicates whether we are only interested in the descriptors of a particular |
| // map, or in all descriptors in the descriptor array. |
| enum DescriptorFlag { |
| ALL_DESCRIPTORS, |
| OWN_DESCRIPTORS |
| }; |
| |
| // Instance size sentinel for objects of variable size. |
| const int kVariableSizeSentinel = 0; |
| |
| // We may store the unsigned bit field as signed Smi value and do not |
| // use the sign bit. |
| const int kStubMajorKeyBits = 8; |
| const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1; |
| |
| // Result of an abstract relational comparison of x and y, implemented according |
| // to ES6 section 7.2.11 Abstract Relational Comparison. |
| enum class ComparisonResult { |
| kLessThan, // x < y |
| kEqual, // x = y |
| kGreaterThan, // x > y |
| kUndefined // at least one of x or y was undefined or NaN |
| }; |
| |
| // (Returns false whenever {result} is kUndefined.) |
| bool ComparisonResultToBool(Operation op, ComparisonResult result); |
| |
| enum class OnNonExistent { kThrowReferenceError, kReturnUndefined }; |
| |
| class AbstractCode; |
| class AccessorPair; |
| class AccessCheckInfo; |
| class AllocationSite; |
| class ByteArray; |
| class Cell; |
| class ConsString; |
| class DependentCode; |
| class ElementsAccessor; |
| class EnumCache; |
| class FixedArrayBase; |
| class FixedDoubleArray; |
| class FunctionLiteral; |
| class FunctionTemplateInfo; |
| class JSAsyncGeneratorObject; |
| class JSGlobalProxy; |
| class JSPromise; |
| class JSProxy; |
| class KeyAccumulator; |
| class LayoutDescriptor; |
| class LookupIterator; |
| class FieldType; |
| class Module; |
| class ModuleInfoEntry; |
| class ObjectHashTable; |
| class ObjectTemplateInfo; |
| class ObjectVisitor; |
| class PreParsedScopeData; |
| class PropertyArray; |
| class PropertyCell; |
| class PropertyDescriptor; |
| class RegExpMatchInfo; |
| class RootVisitor; |
| class SafepointEntry; |
| class ScriptContextTable; |
| class SharedFunctionInfo; |
| class StringStream; |
| class Symbol; |
| class FeedbackCell; |
| class FeedbackMetadata; |
| class FeedbackVector; |
| class UncompiledData; |
| class TemplateInfo; |
| class TransitionArray; |
| class TemplateList; |
| class WasmInstanceObject; |
| class WasmMemoryObject; |
| template <typename T> |
| class ZoneForwardList; |
| |
| #ifdef OBJECT_PRINT |
| #define DECL_PRINTER(Name) void Name##Print(std::ostream& os); // NOLINT |
| #else |
| #define DECL_PRINTER(Name) |
| #endif |
| |
| #define OBJECT_TYPE_LIST(V) \ |
| V(Smi) \ |
| V(LayoutDescriptor) \ |
| V(HeapObject) \ |
| V(Primitive) \ |
| V(Number) \ |
| V(Numeric) |
| |
| #define HEAP_OBJECT_ORDINARY_TYPE_LIST_BASE(V) \ |
| V(AbstractCode) \ |
| V(AccessCheckNeeded) \ |
| V(AllocationSite) \ |
| V(ArrayList) \ |
| V(BigInt) \ |
| V(BigIntWrapper) \ |
| V(ObjectBoilerplateDescription) \ |
| V(Boolean) \ |
| V(BooleanWrapper) \ |
| V(BreakPoint) \ |
| V(BreakPointInfo) \ |
| V(ByteArray) \ |
| V(BytecodeArray) \ |
| V(CallHandlerInfo) \ |
| V(Callable) \ |
| V(Cell) \ |
| V(ClassBoilerplate) \ |
| V(Code) \ |
| V(CodeDataContainer) \ |
| V(CompilationCacheTable) \ |
| V(ConsString) \ |
| V(Constructor) \ |
| V(Context) \ |
| V(CoverageInfo) \ |
| V(DataHandler) \ |
| V(DeoptimizationData) \ |
| V(DependentCode) \ |
| V(DescriptorArray) \ |
| V(EmbedderDataArray) \ |
| V(EphemeronHashTable) \ |
| V(EnumCache) \ |
| V(ExternalOneByteString) \ |
| V(ExternalString) \ |
| V(ExternalTwoByteString) \ |
| V(FeedbackCell) \ |
| V(FeedbackMetadata) \ |
| V(FeedbackVector) \ |
| V(Filler) \ |
| V(FixedArray) \ |
| V(FixedArrayBase) \ |
| V(FixedArrayExact) \ |
| V(FixedBigInt64Array) \ |
| V(FixedBigUint64Array) \ |
| V(FixedDoubleArray) \ |
| V(FixedFloat32Array) \ |
| V(FixedFloat64Array) \ |
| V(FixedInt16Array) \ |
| V(FixedInt32Array) \ |
| V(FixedInt8Array) \ |
| V(FixedTypedArrayBase) \ |
| V(FixedUint16Array) \ |
| V(FixedUint32Array) \ |
| V(FixedUint8Array) \ |
| V(FixedUint8ClampedArray) \ |
| V(Foreign) \ |
| V(FrameArray) \ |
| V(FreeSpace) \ |
| V(Function) \ |
| V(GlobalDictionary) \ |
| V(HandlerTable) \ |
| V(HeapNumber) \ |
| V(InternalizedString) \ |
| V(JSArgumentsObject) \ |
| V(JSArgumentsObjectWithLength) \ |
| V(JSArray) \ |
| V(JSArrayBuffer) \ |
| V(JSArrayBufferView) \ |
| V(JSArrayIterator) \ |
| V(JSAsyncFromSyncIterator) \ |
| V(JSAsyncFunctionObject) \ |
| V(JSAsyncGeneratorObject) \ |
| V(JSBoundFunction) \ |
| V(JSCollection) \ |
| V(JSContextExtensionObject) \ |
| V(JSDataView) \ |
| V(JSDate) \ |
| V(JSError) \ |
| V(JSFunction) \ |
| V(JSGeneratorObject) \ |
| V(JSGlobalObject) \ |
| V(JSGlobalProxy) \ |
| V(JSMap) \ |
| V(JSMapIterator) \ |
| V(JSMessageObject) \ |
| V(JSModuleNamespace) \ |
| V(JSObject) \ |
| V(JSPromise) \ |
| V(JSProxy) \ |
| V(JSReceiver) \ |
| V(JSRegExp) \ |
| V(JSRegExpResult) \ |
| V(JSRegExpStringIterator) \ |
| V(JSSet) \ |
| V(JSSetIterator) \ |
| V(JSSloppyArgumentsObject) \ |
| V(JSStringIterator) \ |
| V(JSTypedArray) \ |
| V(JSValue) \ |
| V(JSWeakCell) \ |
| V(JSWeakRef) \ |
| V(JSWeakCollection) \ |
| V(JSWeakFactory) \ |
| V(JSWeakFactoryCleanupIterator) \ |
| V(JSWeakMap) \ |
| V(JSWeakSet) \ |
| V(LoadHandler) \ |
| V(Map) \ |
| V(MapCache) \ |
| V(Microtask) \ |
| V(ModuleInfo) \ |
| V(MutableHeapNumber) \ |
| V(Name) \ |
| V(NameDictionary) \ |
| V(NativeContext) \ |
| V(NormalizedMapCache) \ |
| V(NumberDictionary) \ |
| V(NumberWrapper) \ |
| V(ObjectHashSet) \ |
| V(ObjectHashTable) \ |
| V(Oddball) \ |
| V(OrderedHashMap) \ |
| V(OrderedHashSet) \ |
| V(OrderedNameDictionary) \ |
| V(PreParsedScopeData) \ |
| V(PromiseReactionJobTask) \ |
| V(PropertyArray) \ |
| V(PropertyCell) \ |
| V(PropertyDescriptorObject) \ |
| V(RegExpMatchInfo) \ |
| V(ScopeInfo) \ |
| V(ScriptContextTable) \ |
| V(ScriptWrapper) \ |
| V(SeqOneByteString) \ |
| V(SeqString) \ |
| V(SeqTwoByteString) \ |
| V(SharedFunctionInfo) \ |
| V(SimpleNumberDictionary) \ |
| V(SlicedString) \ |
| V(SloppyArgumentsElements) \ |
| V(SmallOrderedHashMap) \ |
| V(SmallOrderedHashSet) \ |
| V(SmallOrderedNameDictionary) \ |
| V(SourcePositionTableWithFrameCache) \ |
| V(StoreHandler) \ |
| V(String) \ |
| V(StringSet) \ |
| V(StringTable) \ |
| V(StringWrapper) \ |
| V(Struct) \ |
| V(Symbol) \ |
| V(SymbolWrapper) \ |
| V(TemplateInfo) \ |
| V(TemplateList) \ |
| V(TemplateObjectDescription) \ |
| V(ThinString) \ |
| V(TransitionArray) \ |
| V(UncompiledData) \ |
| V(UncompiledDataWithPreParsedScope) \ |
| V(UncompiledDataWithoutPreParsedScope) \ |
| V(Undetectable) \ |
| V(UniqueName) \ |
| V(WasmExceptionObject) \ |
| V(WasmGlobalObject) \ |
| V(WasmInstanceObject) \ |
| V(WasmMemoryObject) \ |
| V(WasmModuleObject) \ |
| V(WasmTableObject) \ |
| V(WeakFixedArray) \ |
| V(WeakArrayList) |
| |
| #ifdef V8_INTL_SUPPORT |
| #define HEAP_OBJECT_ORDINARY_TYPE_LIST(V) \ |
| HEAP_OBJECT_ORDINARY_TYPE_LIST_BASE(V) \ |
| V(JSV8BreakIterator) \ |
| V(JSCollator) \ |
| V(JSDateTimeFormat) \ |
| V(JSListFormat) \ |
| V(JSLocale) \ |
| V(JSNumberFormat) \ |
| V(JSPluralRules) \ |
| V(JSRelativeTimeFormat) \ |
| V(JSSegmentIterator) \ |
| V(JSSegmenter) |
| #else |
| #define HEAP_OBJECT_ORDINARY_TYPE_LIST(V) HEAP_OBJECT_ORDINARY_TYPE_LIST_BASE(V) |
| #endif // V8_INTL_SUPPORT |
| |
| #define HEAP_OBJECT_TEMPLATE_TYPE_LIST(V) \ |
| V(Dictionary) \ |
| V(HashTable) |
| |
| #define HEAP_OBJECT_TYPE_LIST(V) \ |
| HEAP_OBJECT_ORDINARY_TYPE_LIST(V) \ |
| HEAP_OBJECT_TEMPLATE_TYPE_LIST(V) |
| |
| #define ODDBALL_LIST(V) \ |
| V(Undefined, undefined_value) \ |
| V(Null, null_value) \ |
| V(TheHole, the_hole_value) \ |
| V(Exception, exception) \ |
| V(Uninitialized, uninitialized_value) \ |
| V(True, true_value) \ |
| V(False, false_value) \ |
| V(ArgumentsMarker, arguments_marker) \ |
| V(OptimizedOut, optimized_out) \ |
| V(StaleRegister, stale_register) |
| |
| // The element types selection for CreateListFromArrayLike. |
| enum class ElementTypes { kAll, kStringAndSymbol }; |
| |
| // TODO(3770): Get rid of this indirection when the migration is complete. |
| typedef AbstractCode AbstractCodeArgType; |
| typedef ByteArray ByteArrayArgType; |
| typedef FixedArray FixedArrayArgType; |
| typedef FixedDoubleArray FixedDoubleArrayArgType; |
| typedef Foreign* ForeignArgType; |
| typedef HeapObject* HeapObjectArgType; |
| typedef JSArray JSArrayArgType; |
| typedef JSAsyncGeneratorObject JSAsyncGeneratorObjectArgType; |
| typedef JSFunction JSFunctionArgType; |
| typedef JSGlobalProxy JSGlobalProxyArgType; |
| typedef JSObject JSObjectArgType; |
| typedef JSPromise JSPromiseArgType; |
| typedef JSProxy JSProxyArgType; |
| typedef Map MapArgType; |
| typedef Object* ObjectArgType; |
| typedef RegExpMatchInfo RegExpMatchInfoArgType; |
| typedef ScriptContextTable ScriptContextTableArgType; |
| typedef SharedFunctionInfo SharedFunctionInfoArgType; |
| typedef SimpleNumberDictionary SimpleNumberDictionaryArgType; |
| typedef Smi SmiArgType; |
| typedef String StringArgType; |
| typedef Symbol SymbolArgType; |
| typedef TemplateList TemplateListArgType; |
| typedef WasmInstanceObject WasmInstanceObjectArgType; |
| typedef WasmMemoryObject WasmMemoryObjectArgType; |
| |
| // Object is the abstract superclass for all classes in the |
| // object hierarchy. |
| // Object does not use any virtual functions to avoid the |
| // allocation of the C++ vtable. |
| // Since both Smi and HeapObject are subclasses of Object no |
| // data members can be present in Object. |
| class Object { |
| public: |
| // Type testing. |
| bool IsObject() const { return true; } |
| |
| // Syntax compatibility with ObjectPtr, so the same macros can consume |
| // arguments of either type. |
| Address ptr() const { return reinterpret_cast<Address>(this); } |
| |
| #define IS_TYPE_FUNCTION_DECL(Type) V8_INLINE bool Is##Type() const; |
| OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL) |
| HEAP_OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL) |
| #undef IS_TYPE_FUNCTION_DECL |
| |
| V8_INLINE bool IsExternal(Isolate* isolate) const; |
| |
| // Oddball checks are faster when they are raw pointer comparisons, so the |
| // isolate/read-only roots overloads should be preferred where possible. |
| #define IS_TYPE_FUNCTION_DECL(Type, Value) \ |
| V8_INLINE bool Is##Type(Isolate* isolate) const; \ |
| V8_INLINE bool Is##Type(ReadOnlyRoots roots) const; \ |
| V8_INLINE bool Is##Type() const; |
| ODDBALL_LIST(IS_TYPE_FUNCTION_DECL) |
| #undef IS_TYPE_FUNCTION_DECL |
| |
| V8_INLINE bool IsNullOrUndefined(Isolate* isolate) const; |
| V8_INLINE bool IsNullOrUndefined(ReadOnlyRoots roots) const; |
| V8_INLINE bool IsNullOrUndefined() const; |
| |
| enum class Conversion { kToNumber, kToNumeric }; |
| |
| #define RETURN_FAILURE(isolate, should_throw, call) \ |
| do { \ |
| if ((should_throw) == kDontThrow) { \ |
| return Just(false); \ |
| } else { \ |
| isolate->Throw(*isolate->factory()->call); \ |
| return Nothing<bool>(); \ |
| } \ |
| } while (false) |
| |
| #define MAYBE_RETURN(call, value) \ |
| do { \ |
| if ((call).IsNothing()) return value; \ |
| } while (false) |
| |
| #define MAYBE_RETURN_NULL(call) MAYBE_RETURN(call, MaybeHandle<Object>()) |
| |
| #define MAYBE_ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, dst, call) \ |
| do { \ |
| Isolate* __isolate__ = (isolate); \ |
| if (!(call).To(&dst)) { \ |
| DCHECK(__isolate__->has_pending_exception()); \ |
| return ReadOnlyRoots(__isolate__).exception(); \ |
| } \ |
| } while (false) |
| |
| #define DECL_STRUCT_PREDICATE(NAME, Name, name) V8_INLINE bool Is##Name() const; |
| STRUCT_LIST(DECL_STRUCT_PREDICATE) |
| #undef DECL_STRUCT_PREDICATE |
| |
| // ES6, #sec-isarray. NOT to be confused with %_IsArray. |
| V8_INLINE |
| V8_WARN_UNUSED_RESULT static Maybe<bool> IsArray(Handle<Object> object); |
| |
| V8_INLINE bool IsSmallOrderedHashTable() const; |
| |
| // Extract the number. |
| inline double Number() const; |
| V8_INLINE bool IsNaN() const; |
| V8_INLINE bool IsMinusZero() const; |
| V8_EXPORT_PRIVATE bool ToInt32(int32_t* value); |
| inline bool ToUint32(uint32_t* value) const; |
| |
| inline Representation OptimalRepresentation(); |
| |
| inline ElementsKind OptimalElementsKind(); |
| |
| inline bool FitsRepresentation(Representation representation); |
| |
| // Checks whether two valid primitive encodings of a property name resolve to |
| // the same logical property. E.g., the smi 1, the string "1" and the double |
| // 1 all refer to the same property, so this helper will return true. |
| inline bool KeyEquals(Object* other); |
| |
| inline bool FilterKey(PropertyFilter filter); |
| |
| Handle<FieldType> OptimalType(Isolate* isolate, |
| Representation representation); |
| |
| inline static Handle<Object> NewStorageFor(Isolate* isolate, |
| Handle<Object> object, |
| Representation representation); |
| |
| inline static Handle<Object> WrapForRead(Isolate* isolate, |
| Handle<Object> object, |
| Representation representation); |
| |
| // Returns true if the object is of the correct type to be used as a |
| // implementation of a JSObject's elements. |
| inline bool HasValidElements(); |
| |
| // ECMA-262 9.2. |
| bool BooleanValue(Isolate* isolate); |
| |
| // ES6 section 7.2.11 Abstract Relational Comparison |
| V8_WARN_UNUSED_RESULT static Maybe<ComparisonResult> Compare( |
| Isolate* isolate, Handle<Object> x, Handle<Object> y); |
| |
| // ES6 section 7.2.12 Abstract Equality Comparison |
| V8_WARN_UNUSED_RESULT static Maybe<bool> Equals(Isolate* isolate, |
| Handle<Object> x, |
| Handle<Object> y); |
| |
| // ES6 section 7.2.13 Strict Equality Comparison |
| bool StrictEquals(Object* that); |
| |
| // ES6 section 7.1.13 ToObject |
| // Convert to a JSObject if needed. |
| // native_context is used when creating wrapper object. |
| // |
| // Passing a non-null method_name allows us to give a more informative |
| // error message for those cases where ToObject is being called on |
| // the receiver of a built-in method. |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<JSReceiver> ToObject( |
| Isolate* isolate, Handle<Object> object, |
| const char* method_name = nullptr); |
| V8_WARN_UNUSED_RESULT static MaybeHandle<JSReceiver> ToObject( |
| Isolate* isolate, Handle<Object> object, Handle<Context> native_context, |
| const char* method_name = nullptr); |
| |
| // ES6 section 9.2.1.2, OrdinaryCallBindThis for sloppy callee. |
| V8_WARN_UNUSED_RESULT static MaybeHandle<JSReceiver> ConvertReceiver( |
| Isolate* isolate, Handle<Object> object); |
| |
| // ES6 section 7.1.14 ToPropertyKey |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Name> ToName( |
| Isolate* isolate, Handle<Object> input); |
| |
| // ES6 section 7.1.1 ToPrimitive |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToPrimitive( |
| Handle<Object> input, ToPrimitiveHint hint = ToPrimitiveHint::kDefault); |
| |
| // ES6 section 7.1.3 ToNumber |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToNumber( |
| Isolate* isolate, Handle<Object> input); |
| |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToNumeric( |
| Isolate* isolate, Handle<Object> input); |
| |
| // ES6 section 7.1.4 ToInteger |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToInteger( |
| Isolate* isolate, Handle<Object> input); |
| |
| // ES6 section 7.1.5 ToInt32 |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToInt32( |
| Isolate* isolate, Handle<Object> input); |
| |
| // ES6 section 7.1.6 ToUint32 |
| V8_WARN_UNUSED_RESULT inline static MaybeHandle<Object> ToUint32( |
| Isolate* isolate, Handle<Object> input); |
| |
| // ES6 section 7.1.12 ToString |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<String> ToString( |
| Isolate* isolate, Handle<Object> input); |
| |
| static Handle<String> NoSideEffectsToString(Isolate* isolate, |
| Handle<Object> input); |
| |
| // ES6 section 7.1.14 ToPropertyKey |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToPropertyKey( |
| Isolate* isolate, Handle<Object> value); |
| |
| // ES6 section 7.1.15 ToLength |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToLength( |
| Isolate* isolate, Handle<Object> input); |
| |
| // ES6 section 7.1.17 ToIndex |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToIndex( |
| Isolate* isolate, Handle<Object> input, MessageTemplate error_index); |
| |
| // ES6 section 7.3.9 GetMethod |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> GetMethod( |
| Handle<JSReceiver> receiver, Handle<Name> name); |
| |
| // ES6 section 7.3.17 CreateListFromArrayLike |
| V8_WARN_UNUSED_RESULT static MaybeHandle<FixedArray> CreateListFromArrayLike( |
| Isolate* isolate, Handle<Object> object, ElementTypes element_types); |
| |
| // Get length property and apply ToLength. |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> GetLengthFromArrayLike( |
| Isolate* isolate, Handle<JSReceiver> object); |
| |
| // ES6 section 12.5.6 The typeof Operator |
| static Handle<String> TypeOf(Isolate* isolate, Handle<Object> object); |
| |
| // ES6 section 12.7 Additive Operators |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> Add(Isolate* isolate, |
| Handle<Object> lhs, |
| Handle<Object> rhs); |
| |
| // ES6 section 12.9 Relational Operators |
| V8_WARN_UNUSED_RESULT static inline Maybe<bool> GreaterThan(Isolate* isolate, |
| Handle<Object> x, |
| Handle<Object> y); |
| V8_WARN_UNUSED_RESULT static inline Maybe<bool> GreaterThanOrEqual( |
| Isolate* isolate, Handle<Object> x, Handle<Object> y); |
| V8_WARN_UNUSED_RESULT static inline Maybe<bool> LessThan(Isolate* isolate, |
| Handle<Object> x, |
| Handle<Object> y); |
| V8_WARN_UNUSED_RESULT static inline Maybe<bool> LessThanOrEqual( |
| Isolate* isolate, Handle<Object> x, Handle<Object> y); |
| |
| // ES6 section 7.3.19 OrdinaryHasInstance (C, O). |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> OrdinaryHasInstance( |
| Isolate* isolate, Handle<Object> callable, Handle<Object> object); |
| |
| // ES6 section 12.10.4 Runtime Semantics: InstanceofOperator(O, C) |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> InstanceOf( |
| Isolate* isolate, Handle<Object> object, Handle<Object> callable); |
| |
| V8_EXPORT_PRIVATE V8_WARN_UNUSED_RESULT static MaybeHandle<Object> |
| GetProperty(LookupIterator* it, |
| OnNonExistent on_non_existent = OnNonExistent::kReturnUndefined); |
| |
| // ES6 [[Set]] (when passed kDontThrow) |
| // Invariants for this and related functions (unless stated otherwise): |
| // 1) When the result is Nothing, an exception is pending. |
| // 2) When passed kThrowOnError, the result is never Just(false). |
| // In some cases, an exception is thrown regardless of the ShouldThrow |
| // argument. These cases are either in accordance with the spec or not |
| // covered by it (eg., concerning API callbacks). |
| V8_WARN_UNUSED_RESULT static Maybe<bool> SetProperty( |
| LookupIterator* it, Handle<Object> value, LanguageMode language_mode, |
| StoreOrigin store_origin); |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> SetProperty( |
| Isolate* isolate, Handle<Object> object, Handle<Name> name, |
| Handle<Object> value, LanguageMode language_mode, |
| StoreOrigin store_origin = StoreOrigin::kMaybeKeyed); |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> SetPropertyOrElement( |
| Isolate* isolate, Handle<Object> object, Handle<Name> name, |
| Handle<Object> value, LanguageMode language_mode, |
| StoreOrigin store_origin = StoreOrigin::kMaybeKeyed); |
| |
| V8_WARN_UNUSED_RESULT static Maybe<bool> SetSuperProperty( |
| LookupIterator* it, Handle<Object> value, LanguageMode language_mode, |
| StoreOrigin store_origin); |
| |
| V8_WARN_UNUSED_RESULT static Maybe<bool> CannotCreateProperty( |
| Isolate* isolate, Handle<Object> receiver, Handle<Object> name, |
| Handle<Object> value, ShouldThrow should_throw); |
| V8_WARN_UNUSED_RESULT static Maybe<bool> WriteToReadOnlyProperty( |
| LookupIterator* it, Handle<Object> value, ShouldThrow should_throw); |
| V8_WARN_UNUSED_RESULT static Maybe<bool> WriteToReadOnlyProperty( |
| Isolate* isolate, Handle<Object> receiver, Handle<Object> name, |
| Handle<Object> value, ShouldThrow should_throw); |
| V8_WARN_UNUSED_RESULT static Maybe<bool> RedefineIncompatibleProperty( |
| Isolate* isolate, Handle<Object> name, Handle<Object> value, |
| ShouldThrow should_throw); |
| V8_WARN_UNUSED_RESULT static Maybe<bool> SetDataProperty( |
| LookupIterator* it, Handle<Object> value); |
| V8_WARN_UNUSED_RESULT static Maybe<bool> AddDataProperty( |
| LookupIterator* it, Handle<Object> value, PropertyAttributes attributes, |
| ShouldThrow should_throw, StoreOrigin store_origin); |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> GetPropertyOrElement( |
| Isolate* isolate, Handle<Object> object, Handle<Name> name); |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> GetPropertyOrElement( |
| Handle<Object> receiver, Handle<Name> name, Handle<JSReceiver> holder); |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> GetProperty( |
| Isolate* isolate, Handle<Object> object, Handle<Name> name); |
| |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> GetPropertyWithAccessor( |
| LookupIterator* it); |
| V8_WARN_UNUSED_RESULT static Maybe<bool> SetPropertyWithAccessor( |
| LookupIterator* it, Handle<Object> value, ShouldThrow should_throw); |
| |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> GetPropertyWithDefinedGetter( |
| Handle<Object> receiver, Handle<JSReceiver> getter); |
| V8_WARN_UNUSED_RESULT static Maybe<bool> SetPropertyWithDefinedSetter( |
| Handle<Object> receiver, Handle<JSReceiver> setter, Handle<Object> value, |
| ShouldThrow should_throw); |
| |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> GetElement( |
| Isolate* isolate, Handle<Object> object, uint32_t index); |
| |
| V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> SetElement( |
| Isolate* isolate, Handle<Object> object, uint32_t index, |
| Handle<Object> value, LanguageMode language_mode); |
| |
| // Returns the permanent hash code associated with this object. May return |
| // undefined if not yet created. |
| inline Object* GetHash(); |
| |
| // Returns the permanent hash code associated with this object depending on |
| // the actual object type. May create and store a hash code if needed and none |
| // exists. |
| Smi GetOrCreateHash(Isolate* isolate); |
| |
| // Checks whether this object has the same value as the given one. This |
| // function is implemented according to ES5, section 9.12 and can be used |
| // to implement the Object.is function. |
| V8_EXPORT_PRIVATE bool SameValue(Object* other); |
| |
| // Checks whether this object has the same value as the given one. |
| // +0 and -0 are treated equal. Everything else is the same as SameValue. |
| // This function is implemented according to ES6, section 7.2.4 and is used |
| // by ES6 Map and Set. |
| bool SameValueZero(Object* other); |
| |
| // ES6 section 9.4.2.3 ArraySpeciesCreate (part of it) |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ArraySpeciesConstructor( |
| Isolate* isolate, Handle<Object> original_array); |
| |
| // ES6 section 7.3.20 SpeciesConstructor ( O, defaultConstructor ) |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> SpeciesConstructor( |
| Isolate* isolate, Handle<JSReceiver> recv, |
| Handle<JSFunction> default_ctor); |
| |
| // Tries to convert an object to an array length. Returns true and sets the |
| // output parameter if it succeeds. |
| inline bool ToArrayLength(uint32_t* index) const; |
| |
| // Tries to convert an object to an array index. Returns true and sets the |
| // output parameter if it succeeds. Equivalent to ToArrayLength, but does not |
| // allow kMaxUInt32. |
| V8_WARN_UNUSED_RESULT inline bool ToArrayIndex(uint32_t* index) const; |
| |
| // Returns true if the result of iterating over the object is the same |
| // (including observable effects) as simply accessing the properties between 0 |
| // and length. |
| bool IterationHasObservableEffects(); |
| |
| DECL_VERIFIER(Object) |
| #ifdef VERIFY_HEAP |
| // Verify a pointer is a valid object pointer. |
| static void VerifyPointer(Isolate* isolate, Object* p); |
| #endif |
| |
| inline void VerifyApiCallResultType(); |
| |
| // Prints this object without details. |
| void ShortPrint(FILE* out = stdout); |
| |
| // Prints this object without details to a message accumulator. |
| void ShortPrint(StringStream* accumulator); |
| |
| void ShortPrint(std::ostream& os); // NOLINT |
| |
| DECL_CAST(Object) |
| |
| // Layout description. |
| static const int kHeaderSize = 0; // Object does not take up any space. |
| |
| #ifdef OBJECT_PRINT |
| // For our gdb macros, we should perhaps change these in the future. |
| void Print(); |
| |
| // Prints this object with details. |
| void Print(std::ostream& os); // NOLINT |
| #else |
| void Print() { ShortPrint(); } |
| void Print(std::ostream& os) { ShortPrint(os); } // NOLINT |
| #endif |
| |
| private: |
| friend class LookupIterator; |
| friend class StringStream; |
| |
| // Return the map of the root of object's prototype chain. |
| Map GetPrototypeChainRootMap(Isolate* isolate) const; |
| |
| // Returns a non-SMI for JSReceivers, but returns the hash code for |
| // simple objects. This avoids a double lookup in the cases where |
| // we know we will add the hash to the JSReceiver if it does not |
| // already exist. |
| // |
| // Despite its size, this needs to be inlined for performance |
| // reasons. |
| static inline Object* GetSimpleHash(Object* object); |
| |
| // Helper for SetProperty and SetSuperProperty. |
| // Return value is only meaningful if [found] is set to true on return. |
| V8_WARN_UNUSED_RESULT static Maybe<bool> SetPropertyInternal( |
| LookupIterator* it, Handle<Object> value, LanguageMode language_mode, |
| StoreOrigin store_origin, bool* found); |
| |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Name> ConvertToName( |
| Isolate* isolate, Handle<Object> input); |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToPropertyKey( |
| Isolate* isolate, Handle<Object> value); |
| V8_WARN_UNUSED_RESULT static MaybeHandle<String> ConvertToString( |
| Isolate* isolate, Handle<Object> input); |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToNumberOrNumeric( |
| Isolate* isolate, Handle<Object> input, Conversion mode); |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToInteger( |
| Isolate* isolate, Handle<Object> input); |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToInt32( |
| Isolate* isolate, Handle<Object> input); |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToUint32( |
| Isolate* isolate, Handle<Object> input); |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToLength( |
| Isolate* isolate, Handle<Object> input); |
| V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToIndex( |
| Isolate* isolate, Handle<Object> input, MessageTemplate error_index); |
| |
| DISALLOW_IMPLICIT_CONSTRUCTORS(Object); |
| }; |
| |
| // In objects.h to be usable without objects-inl.h inclusion. |
| bool Object::IsSmi() const { return HAS_SMI_TAG(ptr()); } |
| bool Object::IsHeapObject() const { |
| DCHECK_EQ(!IsSmi(), Internals::HasHeapObjectTag(ptr())); |
| return !IsSmi(); |
| } |
| |
| struct Brief { |
| V8_EXPORT_PRIVATE explicit Brief(const Object* v); |
| explicit Brief(const MaybeObject v); |
| // {value} is a tagged heap object reference (weak or strong), equivalent to |
| // a MaybeObject's payload. It has a plain Address type to keep #includes |
| // lightweight. |
| const Address value; |
| }; |
| |
| V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os, const Brief& v); |
| |
| // Heap objects typically have a map pointer in their first word. However, |
| // during GC other data (e.g. mark bits, forwarding addresses) is sometimes |
| // encoded in the first word. The class MapWord is an abstraction of the |
| // value in a heap object's first word. |
| class MapWord { |
| public: |
| // Normal state: the map word contains a map pointer. |
| |
| // Create a map word from a map pointer. |
| static inline MapWord FromMap(const Map map); |
| |
| // View this map word as a map pointer. |
| inline Map ToMap() const; |
| |
| // Scavenge collection: the map word of live objects in the from space |
| // contains a forwarding address (a heap object pointer in the to space). |
| |
| // True if this map word is a forwarding address for a scavenge |
| // collection. Only valid during a scavenge collection (specifically, |
| // when all map words are heap object pointers, i.e. not during a full GC). |
| inline bool IsForwardingAddress() const; |
| |
| // Create a map word from a forwarding address. |
| static inline MapWord FromForwardingAddress(HeapObject* object); |
| |
| // View this map word as a forwarding address. |
| inline HeapObject* ToForwardingAddress(); |
| |
| static inline MapWord FromRawValue(uintptr_t value) { |
| return MapWord(value); |
| } |
| |
| inline uintptr_t ToRawValue() { |
| return value_; |
| } |
| |
| private: |
| // HeapObject calls the private constructor and directly reads the value. |
| friend class HeapObject; |
| friend class HeapObjectPtr; |
| |
| explicit MapWord(Address value) : value_(value) {} |
| |
| Address value_; |
| }; |
| |
| |
| // HeapObject is the superclass for all classes describing heap allocated |
| // objects. |
| class HeapObject: public Object { |
| public: |
| // [map]: Contains a map which contains the object's reflective |
| // information. |
| inline Map map() const; |
| inline void set_map(Map value); |
| |
| inline MapWordSlot map_slot() const; |
| |
| // The no-write-barrier version. This is OK if the object is white and in |
| // new space, or if the value is an immortal immutable object, like the maps |
| // of primitive (non-JS) objects like strings, heap numbers etc. |
| inline void set_map_no_write_barrier(Map value); |
| |
| // Get the map using acquire load. |
| inline Map synchronized_map() const; |
| inline MapWord synchronized_map_word() const; |
| |
| // Set the map using release store |
| inline void synchronized_set_map(Map value); |
| inline void synchronized_set_map_word(MapWord map_word); |
| |
| // Initialize the map immediately after the object is allocated. |
| // Do not use this outside Heap. |
| inline void set_map_after_allocation( |
| Map value, WriteBarrierMode mode = UPDATE_WRITE_BARRIER); |
| |
| // During garbage collection, the map word of a heap object does not |
| // necessarily contain a map pointer. |
| inline MapWord map_word() const; |
| inline void set_map_word(MapWord map_word); |
| |
| // TODO(v8:7464): Once RO_SPACE is shared between isolates, this method can be |
| // removed as ReadOnlyRoots will be accessible from a global variable. For now |
| // this method exists to help remove GetIsolate/GetHeap from HeapObject, in a |
| // way that doesn't require passing Isolate/Heap down huge call chains or to |
| // places where it might not be safe to access it. |
| inline ReadOnlyRoots GetReadOnlyRoots() const; |
| |
| #define IS_TYPE_FUNCTION_DECL(Type) V8_INLINE bool Is##Type() const; |
| HEAP_OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL) |
| #undef IS_TYPE_FUNCTION_DECL |
| |
| V8_INLINE bool IsExternal(Isolate* isolate) const; |
| |
| // Oddball checks are faster when they are raw pointer comparisons, so the |
| // isolate/read-only roots overloads should be preferred where possible. |
| #define IS_TYPE_FUNCTION_DECL(Type, Value) \ |
| V8_INLINE bool Is##Type(Isolate* isolate) const; \ |
| V8_INLINE bool Is##Type(ReadOnlyRoots roots) const; \ |
| V8_INLINE bool Is##Type() const; |
| ODDBALL_LIST(IS_TYPE_FUNCTION_DECL) |
| #undef IS_TYPE_FUNCTION_DECL |
| |
| V8_INLINE bool IsNullOrUndefined(Isolate* isolate) const; |
| V8_INLINE bool IsNullOrUndefined(ReadOnlyRoots roots) const; |
| V8_INLINE bool IsNullOrUndefined() const; |
| |
| #define DECL_STRUCT_PREDICATE(NAME, Name, name) V8_INLINE bool Is##Name() const; |
| STRUCT_LIST(DECL_STRUCT_PREDICATE) |
| #undef DECL_STRUCT_PREDICATE |
| |
| // Converts an address to a HeapObject pointer. |
| static inline HeapObject* FromAddress(Address address) { |
| DCHECK_TAG_ALIGNED(address); |
| return reinterpret_cast<HeapObject*>(address + kHeapObjectTag); |
| } |
| |
| // Returns the address of this HeapObject. |
| inline Address address() const { |
| return reinterpret_cast<Address>(this) - kHeapObjectTag; |
| } |
| |
| // Iterates over pointers contained in the object (including the Map). |
| // If it's not performance critical iteration use the non-templatized |
| // version. |
| void Iterate(ObjectVisitor* v); |
| |
| template <typename ObjectVisitor> |
| inline void IterateFast(ObjectVisitor* v); |
| |
| // Iterates over all pointers contained in the object except the |
| // first map pointer. The object type is given in the first |
| // parameter. This function does not access the map pointer in the |
| // object, and so is safe to call while the map pointer is modified. |
| // If it's not performance critical iteration use the non-templatized |
| // version. |
| void IterateBody(ObjectVisitor* v); |
| void IterateBody(Map map, int object_size, ObjectVisitor* v); |
| |
| template <typename ObjectVisitor> |
| inline void IterateBodyFast(ObjectVisitor* v); |
| |
| template <typename ObjectVisitor> |
| inline void IterateBodyFast(Map map, int object_size, ObjectVisitor* v); |
| |
| // Returns true if the object contains a tagged value at given offset. |
| // It is used for invalid slots filtering. If the offset points outside |
| // of the object or to the map word, the result is UNDEFINED (!!!). |
| bool IsValidSlot(Map map, int offset); |
| |
| // Returns the heap object's size in bytes |
| inline int Size() const; |
| |
| // Given a heap object's map pointer, returns the heap size in bytes |
| // Useful when the map pointer field is used for other purposes. |
| // GC internal. |
| inline int SizeFromMap(Map map) const; |
| |
| // Returns the field at offset in obj, as a read/write Object* reference. |
| // Does no checking, and is safe to use during GC, while maps are invalid. |
| // Does not invoke write barrier, so should only be assigned to |
| // during marking GC. |
| inline ObjectSlot RawField(int byte_offset) const; |
| static inline ObjectSlot RawField(const HeapObject* obj, int offset); |
| inline MaybeObjectSlot RawMaybeWeakField(int byte_offset) const; |
| static inline MaybeObjectSlot RawMaybeWeakField(HeapObject* obj, int offset); |
| |
| DECL_CAST(HeapObject) |
| |
| // Return the write barrier mode for this. Callers of this function |
| // must be able to present a reference to an DisallowHeapAllocation |
| // object as a sign that they are not going to use this function |
| // from code that allocates and thus invalidates the returned write |
| // barrier mode. |
| inline WriteBarrierMode GetWriteBarrierMode( |
| const DisallowHeapAllocation& promise); |
| |
| // Dispatched behavior. |
| void HeapObjectShortPrint(std::ostream& os); // NOLINT |
| #ifdef OBJECT_PRINT |
| void PrintHeader(std::ostream& os, const char* id); // NOLINT |
| #endif |
| DECL_PRINTER(HeapObject) |
| DECL_VERIFIER(HeapObject) |
| #ifdef VERIFY_HEAP |
| inline void VerifyObjectField(Isolate* isolate, int offset); |
| inline void VerifySmiField(int offset); |
| inline void VerifyMaybeObjectField(Isolate* isolate, int offset); |
| |
| // Verify a pointer is a valid HeapObject pointer that points to object |
| // areas in the heap. |
| static void VerifyHeapPointer(Isolate* isolate, Object* p); |
| #endif |
| |
| static inline AllocationAlignment RequiredAlignment(Map map); |
| |
| // Whether the object needs rehashing. That is the case if the object's |
| // content depends on FLAG_hash_seed. When the object is deserialized into |
| // a heap with a different hash seed, these objects need to adapt. |
| inline bool NeedsRehashing() const; |
| |
| // Rehashing support is not implemented for all objects that need rehashing. |
| // With objects that need rehashing but cannot be rehashed, rehashing has to |
| // be disabled. |
| bool CanBeRehashed() const; |
| |
| // Rehash the object based on the layout inferred from its map. |
| void RehashBasedOnMap(Isolate* isolate); |
| |
| // Layout description. |
| // First field in a heap object is map. |
| static const int kMapOffset = Object::kHeaderSize; |
| static const int kHeaderSize = kMapOffset + kPointerSize; |
| |
| STATIC_ASSERT(kMapOffset == Internals::kHeapObjectMapOffset); |
| |
| inline Address GetFieldAddress(int field_offset) const; |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(HeapObject); |
| }; |
| |
| // Mixin class for objects that can never be in RO space. |
| // TODO(leszeks): Add checks in the factory that we never allocate these objects |
| // in RO space. |
| class NeverReadOnlySpaceObject { |
| public: |
| // The Heap the object was allocated in. Used also to access Isolate. |
| inline Heap* GetHeap() const; |
| |
| // Convenience method to get current isolate. |
| inline Isolate* GetIsolate() const; |
| }; |
| |
| template <int start_offset, int end_offset, int size> |
| class FixedBodyDescriptor; |
| |
| template <int start_offset> |
| class FlexibleBodyDescriptor; |
| |
| template <int start_offset> |
| class FlexibleWeakBodyDescriptor; |
| |
| template <class ParentBodyDescriptor, class ChildBodyDescriptor> |
| class SubclassBodyDescriptor; |
| |
| // The HeapNumber class describes heap allocated numbers that cannot be |
| // represented in a Smi (small integer). MutableHeapNumber is the same, but its |
| // number value can change over time (it is used only as property storage). |
| // HeapNumberBase merely exists to avoid code duplication. |
| class HeapNumberBase : public HeapObject { |
| public: |
| // [value]: number value. |
| inline double value() const; |
| inline void set_value(double value); |
| |
| inline uint64_t value_as_bits() const; |
| inline void set_value_as_bits(uint64_t bits); |
| |
| inline int get_exponent(); |
| inline int get_sign(); |
| |
| // Layout description. |
| static const int kValueOffset = HeapObject::kHeaderSize; |
| // IEEE doubles are two 32 bit words. The first is just mantissa, the second |
| // is a mixture of sign, exponent and mantissa. The offsets of two 32 bit |
| // words within double numbers are endian dependent and they are set |
| // accordingly. |
| #if defined(V8_TARGET_LITTLE_ENDIAN) |
| static const int kMantissaOffset = kValueOffset; |
| static const int kExponentOffset = kValueOffset + 4; |
| #elif defined(V8_TARGET_BIG_ENDIAN) |
| static const int kMantissaOffset = kValueOffset + 4; |
| static const int kExponentOffset = kValueOffset; |
| #else |
| #error Unknown byte ordering |
| #endif |
| |
| static const int kSize = kValueOffset + kDoubleSize; |
| static const uint32_t kSignMask = 0x80000000u; |
| static const uint32_t kExponentMask = 0x7ff00000u; |
| static const uint32_t kMantissaMask = 0xfffffu; |
| static const int kMantissaBits = 52; |
| static const int kExponentBits = 11; |
| static const int kExponentBias = 1023; |
| static const int kExponentShift = 20; |
| static const int kInfinityOrNanExponent = |
| (kExponentMask >> kExponentShift) - kExponentBias; |
| static const int kMantissaBitsInTopWord = 20; |
| static const int kNonMantissaBitsInTopWord = 12; |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(HeapNumberBase) |
| }; |
| |
| class HeapNumber : public HeapNumberBase { |
| public: |
| DECL_CAST(HeapNumber) |
| V8_EXPORT_PRIVATE void HeapNumberPrint(std::ostream& os); |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(HeapNumber) |
| }; |
| |
| class MutableHeapNumber : public HeapNumberBase { |
| public: |
| DECL_CAST(MutableHeapNumber) |
| V8_EXPORT_PRIVATE void MutableHeapNumberPrint(std::ostream& os); |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(MutableHeapNumber) |
| }; |
| |
| enum EnsureElementsMode { |
| DONT_ALLOW_DOUBLE_ELEMENTS, |
| ALLOW_COPIED_DOUBLE_ELEMENTS, |
| ALLOW_CONVERTED_DOUBLE_ELEMENTS |
| }; |
| |
| |
| // Indicator for one component of an AccessorPair. |
| enum AccessorComponent { |
| ACCESSOR_GETTER, |
| ACCESSOR_SETTER |
| }; |
| |
| enum class GetKeysConversion { |
| kKeepNumbers = static_cast<int>(v8::KeyConversionMode::kKeepNumbers), |
| kConvertToString = static_cast<int>(v8::KeyConversionMode::kConvertToString) |
| }; |
| |
| enum class KeyCollectionMode { |
| kOwnOnly = static_cast<int>(v8::KeyCollectionMode::kOwnOnly), |
| kIncludePrototypes = |
| static_cast<int>(v8::KeyCollectionMode::kIncludePrototypes) |
| }; |
| |
| // FreeSpace are fixed-size free memory blocks used by the heap and GC. |
| // They look like heap objects (are heap object tagged and have a map) so that |
| // the heap remains iterable. They have a size and a next pointer. |
| // The next pointer is the raw address of the next FreeSpace object (or NULL) |
| // in the free list. |
| class FreeSpace: public HeapObject { |
| public: |
| // [size]: size of the free space including the header. |
| inline int size() const; |
| inline void set_size(int value); |
| |
| inline int relaxed_read_size() const; |
| inline void relaxed_write_size(int value); |
| |
| inline int Size(); |
| |
| // Accessors for the next field. |
| inline FreeSpace* next(); |
| inline void set_next(FreeSpace* next); |
| |
| inline static FreeSpace* cast(HeapObject* obj); |
| |
| // Dispatched behavior. |
| DECL_PRINTER(FreeSpace) |
| DECL_VERIFIER(FreeSpace) |
| |
| // Layout description. |
| // Size is smi tagged when it is stored. |
| static const int kSizeOffset = HeapObject::kHeaderSize; |
| static const int kNextOffset = POINTER_SIZE_ALIGN(kSizeOffset + kPointerSize); |
| static const int kSize = kNextOffset + kPointerSize; |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(FreeSpace); |
| }; |
| |
| class PrototypeInfo; |
| |
| // An abstract superclass, a marker class really, for simple structure classes. |
| // It doesn't carry much functionality but allows struct classes to be |
| // identified in the type system. |
| class Struct: public HeapObject { |
| public: |
| inline void InitializeBody(int object_size); |
| DECL_CAST(Struct) |
| void BriefPrintDetails(std::ostream& os); |
| }; |
| |
| class Tuple2 : public Struct { |
| public: |
| DECL_ACCESSORS(value1, Object) |
| DECL_ACCESSORS(value2, Object) |
| |
| DECL_CAST(Tuple2) |
| |
| // Dispatched behavior. |
| DECL_PRINTER(Tuple2) |
| DECL_VERIFIER(Tuple2) |
| void BriefPrintDetails(std::ostream& os); |
| |
| static const int kValue1Offset = HeapObject::kHeaderSize; |
| static const int kValue2Offset = kValue1Offset + kPointerSize; |
| static const int kSize = kValue2Offset + kPointerSize; |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(Tuple2); |
| }; |
| |
| class Tuple3 : public Tuple2 { |
| public: |
| DECL_ACCESSORS(value3, Object) |
| |
| DECL_CAST(Tuple3) |
| |
| // Dispatched behavior. |
| DECL_PRINTER(Tuple3) |
| DECL_VERIFIER(Tuple3) |
| void BriefPrintDetails(std::ostream& os); |
| |
| static const int kValue3Offset = Tuple2::kSize; |
| static const int kSize = kValue3Offset + kPointerSize; |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(Tuple3); |
| }; |
| |
| // Utility superclass for stack-allocated objects that must be updated |
| // on gc. It provides two ways for the gc to update instances, either |
| // iterating or updating after gc. |
| class Relocatable { |
| public: |
| explicit inline Relocatable(Isolate* isolate); |
| inline virtual ~Relocatable(); |
| virtual void IterateInstance(RootVisitor* v) {} |
| virtual void PostGarbageCollection() { } |
| |
| static void PostGarbageCollectionProcessing(Isolate* isolate); |
| static int ArchiveSpacePerThread(); |
| static char* ArchiveState(Isolate* isolate, char* to); |
| static char* RestoreState(Isolate* isolate, char* from); |
| static void Iterate(Isolate* isolate, RootVisitor* v); |
| static void Iterate(RootVisitor* v, Relocatable* top); |
| static char* Iterate(RootVisitor* v, char* t); |
| |
| private: |
| Isolate* isolate_; |
| Relocatable* prev_; |
| }; |
| |
| |
| // The Oddball describes objects null, undefined, true, and false. |
| class Oddball: public HeapObject { |
| public: |
| // [to_number_raw]: Cached raw to_number computed at startup. |
| inline double to_number_raw() const; |
| inline void set_to_number_raw(double value); |
| inline void set_to_number_raw_as_bits(uint64_t bits); |
| |
| // [to_string]: Cached to_string computed at startup. |
| DECL_ACCESSORS2(to_string, String) |
| |
| // [to_number]: Cached to_number computed at startup. |
| DECL_ACCESSORS(to_number, Object) |
| |
| // [typeof]: Cached type_of computed at startup. |
| DECL_ACCESSORS2(type_of, String) |
| |
| inline byte kind() const; |
| inline void set_kind(byte kind); |
| |
| // ES6 section 7.1.3 ToNumber for Boolean, Null, Undefined. |
| V8_WARN_UNUSED_RESULT static inline Handle<Object> ToNumber( |
| Isolate* isolate, Handle<Oddball> input); |
| |
| DECL_CAST(Oddball) |
| |
| // Dispatched behavior. |
| DECL_VERIFIER(Oddball) |
| |
| // Initialize the fields. |
| static void Initialize(Isolate* isolate, Handle<Oddball> oddball, |
| const char* to_string, Handle<Object> to_number, |
| const char* type_of, byte kind); |
| |
| // Layout description. |
| static const int kToNumberRawOffset = HeapObject::kHeaderSize; |
| static const int kToStringOffset = kToNumberRawOffset + kDoubleSize; |
| static const int kToNumberOffset = kToStringOffset + kPointerSize; |
| static const int kTypeOfOffset = kToNumberOffset + kPointerSize; |
| static const int kKindOffset = kTypeOfOffset + kPointerSize; |
| static const int kSize = kKindOffset + kPointerSize; |
| |
| static const byte kFalse = 0; |
| static const byte kTrue = 1; |
| static const byte kNotBooleanMask = static_cast<byte>(~1); |
| static const byte kTheHole = 2; |
| static const byte kNull = 3; |
| static const byte kArgumentsMarker = 4; |
| static const byte kUndefined = 5; |
| static const byte kUninitialized = 6; |
| static const byte kOther = 7; |
| static const byte kException = 8; |
| static const byte kOptimizedOut = 9; |
| static const byte kStaleRegister = 10; |
| static const byte kSelfReferenceMarker = 10; |
| |
| typedef FixedBodyDescriptor<kToStringOffset, kTypeOfOffset + kPointerSize, |
| kSize> BodyDescriptor; |
| |
| STATIC_ASSERT(kToNumberRawOffset == HeapNumber::kValueOffset); |
| STATIC_ASSERT(kKindOffset == Internals::kOddballKindOffset); |
| STATIC_ASSERT(kNull == Internals::kNullOddballKind); |
| STATIC_ASSERT(kUndefined == Internals::kUndefinedOddballKind); |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(Oddball); |
| }; |
| |
| |
| class Cell: public HeapObject { |
| public: |
| // [value]: value of the cell. |
| DECL_ACCESSORS(value, Object) |
| |
| DECL_CAST(Cell) |
| |
| static inline Cell* FromValueAddress(Address value) { |
| Object* result = FromAddress(value - kValueOffset); |
| return static_cast<Cell*>(result); |
| } |
| |
| inline Address ValueAddress() { |
| return address() + kValueOffset; |
| } |
| |
| // Dispatched behavior. |
| DECL_PRINTER(Cell) |
| DECL_VERIFIER(Cell) |
| |
| // Layout description. |
| static const int kValueOffset = HeapObject::kHeaderSize; |
| static const int kSize = kValueOffset + kPointerSize; |
| |
| typedef FixedBodyDescriptor<kValueOffset, |
| kValueOffset + kPointerSize, |
| kSize> BodyDescriptor; |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(Cell); |
| }; |
| |
| // This is a special cell used to maintain both the link between a |
| // closure and it's feedback vector, as well as a way to count the |
| // number of closures created for a certain function per native |
| // context. There's at most one FeedbackCell for each function in |
| // a native context. |
| class FeedbackCell : public Struct { |
| public: |
| // [value]: value of the cell. |
| DECL_ACCESSORS(value, HeapObject) |
| |
| DECL_CAST(FeedbackCell) |
| |
| // Dispatched behavior. |
| DECL_PRINTER(FeedbackCell) |
| DECL_VERIFIER(FeedbackCell) |
| |
| static const int kValueOffset = HeapObject::kHeaderSize; |
| static const int kSize = kValueOffset + kPointerSize; |
| |
| typedef FixedBodyDescriptor<kValueOffset, kValueOffset + kPointerSize, kSize> |
| BodyDescriptor; |
| |
| private: |
| DISALLOW_IMPLICIT_CONSTRUCTORS(FeedbackCell); |
| }; |
| |
| // Foreign describes objects pointing from JavaScript to C structures. |
| class Foreign: public HeapObject { |
| public: |
| // [address]: field containing the address. |
| inline Address foreign_address(); |
| |
| static inline bool IsNormalized(Object* object); |
| |
| DECL_CAST(Foreign) |
| |
| // Dispatched behavior. |
| DECL_PRINTER(Foreign) |
| DECL_VERIFIER(Foreign) |
| |
| // Layout description. |
| |
| static const int kForeignAddressOffset = HeapObject::kHeaderSize; |
| static const int kSize = kForeignAddressOffset + kPointerSize; |
| |
| STATIC_ASSERT(kForeignAddressOffset == Internals::kForeignAddressOffset); |
| |
| class BodyDescriptor; |
| |
| private: |
| friend class Factory; |
| friend class SerializerDeserializer; |
| friend class StartupSerializer; |
| |
| inline void set_foreign_address(Address value); |
| |
| DISALLOW_IMPLICIT_CONSTRUCTORS(Foreign); |
| }; |
| |
| // Support for JavaScript accessors: A pair of a getter and a setter. Each |
| // accessor can either be |
| // * a JavaScript function or proxy: a real accessor |
| // * a FunctionTemplateInfo: a real (lazy) accessor |
| // * undefined: considered an accessor by the spec, too, strangely enough |
| // * null: an accessor which has not been set |
| class AccessorPair: public Struct { |
| public: |
| DECL_ACCESSORS(getter, Object) |
| DECL_ACCESSORS(setter, Object) |
| |
| DECL_CAST(AccessorPair) |
| |
| static Handle<AccessorPair> Copy(Isolate* isolate, Handle<AccessorPair> pair); |
| |
| inline Object* get(AccessorComponent component); |
| inline void set(AccessorComponent component, Object* value); |
| |
| // Note: Returns undefined if the component is not set. |
| static Handle<Object> GetComponent(Isolate* isolate, |
| Handle<AccessorPair> accessor_pair, |
| AccessorComponent component); |
| |
| // Set both components, skipping arguments which are a JavaScript null. |
| inline void SetComponents(Object* getter, Object* setter); |
| |
| inline bool Equals(AccessorPair* pair); |
| inline bool Equals(Object* getter_value, Object* setter_value); |
| |
| inline bool ContainsAccessor(); |
| |
| // Dispatched behavior. |
| DECL_PRINTER(AccessorPair) |
| DECL_VERIFIER(AccessorPair) |
| |
| static const int kGetterOffset = HeapObject::kHeaderSize; |
| static const int kSetterOffset = kGetterOffset + kPointerSize; |
| static const int kSize = kSetterOffset + kPointerSize; |
| |
| private: |
| // Strangely enough, in addition to functions and harmony proxies, the spec |
| // requires us to consider undefined as a kind of accessor, too: |
| // var obj = {}; |
| // Object.defineProperty(obj, "foo", {get: undefined}); |
| // assertTrue("foo" in obj); |
| inline bool IsJSAccessor(Object* obj); |
| |
| DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorPair); |
| }; |
| |
| // BooleanBit is a helper class for setting and getting a bit in an integer. |
| class BooleanBit : public AllStatic { |
| public: |
| static inline bool get(int value, int bit_position) { |
| return (value & (1 << bit_position)) != 0; |
| } |
| |
| static inline int set(int value, int bit_position, bool v) { |
| if (v) { |
| value |= (1 << bit_position); |
| } else { |
| value &= ~(1 << bit_position); |
| } |
| return value; |
| } |
| }; |
| |
| |
| } // NOLINT, false-positive due to second-order macros. |
| } // NOLINT, false-positive due to second-order macros. |
| |
| #include "src/objects/object-macros-undef.h" |
| |
| #endif // V8_OBJECTS_H_ |
