LCOV - code coverage report
Current view: top level - src - objects.h (source / functions) Hit Total Coverage
Test: app.info Lines: 15 17 88.2 %
Date: 2019-04-17 Functions: 4 4 100.0 %

          Line data    Source code
       1             : // Copyright 2015 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_OBJECTS_H_
       6             : #define V8_OBJECTS_H_
       7             : 
       8             : #include <iosfwd>
       9             : #include <memory>
      10             : 
      11             : #include "include/v8-internal.h"
      12             : #include "include/v8.h"
      13             : #include "include/v8config.h"
      14             : #include "src/assert-scope.h"
      15             : #include "src/base/bits.h"
      16             : #include "src/base/build_config.h"
      17             : #include "src/base/flags.h"
      18             : #include "src/base/logging.h"
      19             : #include "src/checks.h"
      20             : #include "src/constants-arch.h"
      21             : #include "src/elements-kind.h"
      22             : #include "src/field-index.h"
      23             : #include "src/flags.h"
      24             : #include "src/message-template.h"
      25             : #include "src/objects-definitions.h"
      26             : #include "src/property-details.h"
      27             : #include "src/utils.h"
      28             : 
      29             : // Has to be the last include (doesn't have include guards):
      30             : #include "src/objects/object-macros.h"
      31             : 
      32             : //
      33             : // Most object types in the V8 JavaScript are described in this file.
      34             : //
      35             : // Inheritance hierarchy:
      36             : // - Object
      37             : //   - Smi          (immediate small integer)
      38             : //   - HeapObject   (superclass for everything allocated in the heap)
      39             : //     - JSReceiver  (suitable for property access)
      40             : //       - JSObject
      41             : //         - JSArray
      42             : //         - JSArrayBuffer
      43             : //         - JSArrayBufferView
      44             : //           - JSTypedArray
      45             : //           - JSDataView
      46             : //         - JSBoundFunction
      47             : //         - JSCollection
      48             : //           - JSSet
      49             : //           - JSMap
      50             : //         - JSStringIterator
      51             : //         - JSSetIterator
      52             : //         - JSMapIterator
      53             : //         - JSWeakCollection
      54             : //           - JSWeakMap
      55             : //           - JSWeakSet
      56             : //         - JSRegExp
      57             : //         - JSFunction
      58             : //         - JSGeneratorObject
      59             : //         - JSGlobalObject
      60             : //         - JSGlobalProxy
      61             : //         - JSValue
      62             : //           - JSDate
      63             : //         - JSMessageObject
      64             : //         - JSModuleNamespace
      65             : //         - JSV8BreakIterator     // If V8_INTL_SUPPORT enabled.
      66             : //         - JSCollator            // If V8_INTL_SUPPORT enabled.
      67             : //         - JSDateTimeFormat      // If V8_INTL_SUPPORT enabled.
      68             : //         - JSListFormat          // If V8_INTL_SUPPORT enabled.
      69             : //         - JSLocale              // If V8_INTL_SUPPORT enabled.
      70             : //         - JSNumberFormat        // If V8_INTL_SUPPORT enabled.
      71             : //         - JSPluralRules         // If V8_INTL_SUPPORT enabled.
      72             : //         - JSRelativeTimeFormat  // If V8_INTL_SUPPORT enabled.
      73             : //         - JSSegmentIterator     // If V8_INTL_SUPPORT enabled.
      74             : //         - JSSegmenter           // If V8_INTL_SUPPORT enabled.
      75             : //         - WasmExceptionObject
      76             : //         - WasmGlobalObject
      77             : //         - WasmInstanceObject
      78             : //         - WasmMemoryObject
      79             : //         - WasmModuleObject
      80             : //         - WasmTableObject
      81             : //       - JSProxy
      82             : //     - FixedArrayBase
      83             : //       - ByteArray
      84             : //       - BytecodeArray
      85             : //       - FixedArray
      86             : //         - FrameArray
      87             : //         - HashTable
      88             : //           - Dictionary
      89             : //           - StringTable
      90             : //           - StringSet
      91             : //           - CompilationCacheTable
      92             : //           - MapCache
      93             : //         - OrderedHashTable
      94             : //           - OrderedHashSet
      95             : //           - OrderedHashMap
      96             : //         - FeedbackMetadata
      97             : //         - TemplateList
      98             : //         - TransitionArray
      99             : //         - ScopeInfo
     100             : //         - ModuleInfo
     101             : //         - ScriptContextTable
     102             : //         - ClosureFeedbackCellArray
     103             : //       - FixedDoubleArray
     104             : //     - Name
     105             : //       - String
     106             : //         - SeqString
     107             : //           - SeqOneByteString
     108             : //           - SeqTwoByteString
     109             : //         - SlicedString
     110             : //         - ConsString
     111             : //         - ThinString
     112             : //         - ExternalString
     113             : //           - ExternalOneByteString
     114             : //           - ExternalTwoByteString
     115             : //         - InternalizedString
     116             : //           - SeqInternalizedString
     117             : //             - SeqOneByteInternalizedString
     118             : //             - SeqTwoByteInternalizedString
     119             : //           - ConsInternalizedString
     120             : //           - ExternalInternalizedString
     121             : //             - ExternalOneByteInternalizedString
     122             : //             - ExternalTwoByteInternalizedString
     123             : //       - Symbol
     124             : //     - Context
     125             : //       - NativeContext
     126             : //     - HeapNumber
     127             : //     - BigInt
     128             : //     - Cell
     129             : //     - DescriptorArray
     130             : //     - PropertyCell
     131             : //     - PropertyArray
     132             : //     - Code
     133             : //     - AbstractCode, a wrapper around Code or BytecodeArray
     134             : //     - Map
     135             : //     - Oddball
     136             : //     - Foreign
     137             : //     - SmallOrderedHashTable
     138             : //       - SmallOrderedHashMap
     139             : //       - SmallOrderedHashSet
     140             : //     - SharedFunctionInfo
     141             : //     - Struct
     142             : //       - AccessorInfo
     143             : //       - AsmWasmData
     144             : //       - PromiseReaction
     145             : //       - PromiseCapability
     146             : //       - AccessorPair
     147             : //       - AccessCheckInfo
     148             : //       - InterceptorInfo
     149             : //       - CallHandlerInfo
     150             : //       - EnumCache
     151             : //       - TemplateInfo
     152             : //         - FunctionTemplateInfo
     153             : //         - ObjectTemplateInfo
     154             : //       - Script
     155             : //       - DebugInfo
     156             : //       - BreakPoint
     157             : //       - BreakPointInfo
     158             : //       - StackFrameInfo
     159             : //       - StackTraceFrame
     160             : //       - SourcePositionTableWithFrameCache
     161             : //       - CodeCache
     162             : //       - PrototypeInfo
     163             : //       - Microtask
     164             : //         - CallbackTask
     165             : //         - CallableTask
     166             : //         - PromiseReactionJobTask
     167             : //           - PromiseFulfillReactionJobTask
     168             : //           - PromiseRejectReactionJobTask
     169             : //         - PromiseResolveThenableJobTask
     170             : //       - Module
     171             : //       - ModuleInfoEntry
     172             : //     - FeedbackCell
     173             : //     - FeedbackVector
     174             : //     - PreparseData
     175             : //     - UncompiledData
     176             : //       - UncompiledDataWithoutPreparseData
     177             : //       - UncompiledDataWithPreparseData
     178             : //
     179             : // Formats of Object::ptr_:
     180             : //  Smi:        [31 bit signed int] 0
     181             : //  HeapObject: [32 bit direct pointer] (4 byte aligned) | 01
     182             : 
     183             : namespace v8 {
     184             : namespace internal {
     185             : 
     186             : struct InliningPosition;
     187             : class PropertyDescriptorObject;
     188             : 
     189             : // SKIP_WRITE_BARRIER skips the write barrier.
     190             : // UPDATE_WEAK_WRITE_BARRIER skips the marking part of the write barrier and
     191             : // only performs the generational part.
     192             : // UPDATE_WRITE_BARRIER is doing the full barrier, marking and generational.
     193             : enum WriteBarrierMode {
     194             :   SKIP_WRITE_BARRIER,
     195             :   UPDATE_WEAK_WRITE_BARRIER,
     196             :   UPDATE_EPHEMERON_KEY_WRITE_BARRIER,
     197             :   UPDATE_WRITE_BARRIER
     198             : };
     199             : 
     200             : // PropertyNormalizationMode is used to specify whether to keep
     201             : // inobject properties when normalizing properties of a JSObject.
     202             : enum PropertyNormalizationMode {
     203             :   CLEAR_INOBJECT_PROPERTIES,
     204             :   KEEP_INOBJECT_PROPERTIES
     205             : };
     206             : 
     207             : 
     208             : // Indicates whether transitions can be added to a source map or not.
     209             : enum TransitionFlag {
     210             :   INSERT_TRANSITION,
     211             :   OMIT_TRANSITION
     212             : };
     213             : 
     214             : 
     215             : // Indicates whether the transition is simple: the target map of the transition
     216             : // either extends the current map with a new property, or it modifies the
     217             : // property that was added last to the current map.
     218             : enum SimpleTransitionFlag {
     219             :   SIMPLE_PROPERTY_TRANSITION,
     220             :   PROPERTY_TRANSITION,
     221             :   SPECIAL_TRANSITION
     222             : };
     223             : 
     224             : // Indicates whether we are only interested in the descriptors of a particular
     225             : // map, or in all descriptors in the descriptor array.
     226             : enum DescriptorFlag {
     227             :   ALL_DESCRIPTORS,
     228             :   OWN_DESCRIPTORS
     229             : };
     230             : 
     231             : // Instance size sentinel for objects of variable size.
     232             : const int kVariableSizeSentinel = 0;
     233             : 
     234             : // We may store the unsigned bit field as signed Smi value and do not
     235             : // use the sign bit.
     236             : const int kStubMajorKeyBits = 8;
     237             : const int kStubMinorKeyBits = kSmiValueSize - kStubMajorKeyBits - 1;
     238             : 
     239             : // Result of an abstract relational comparison of x and y, implemented according
     240             : // to ES6 section 7.2.11 Abstract Relational Comparison.
     241             : enum class ComparisonResult {
     242             :   kLessThan,     // x < y
     243             :   kEqual,        // x = y
     244             :   kGreaterThan,  // x > y
     245             :   kUndefined     // at least one of x or y was undefined or NaN
     246             : };
     247             : 
     248             : // (Returns false whenever {result} is kUndefined.)
     249             : bool ComparisonResultToBool(Operation op, ComparisonResult result);
     250             : 
     251             : enum class OnNonExistent { kThrowReferenceError, kReturnUndefined };
     252             : 
     253             : class AbstractCode;
     254             : class AccessorPair;
     255             : class AccessCheckInfo;
     256             : class AllocationSite;
     257             : class ByteArray;
     258             : class CachedTemplateObject;
     259             : class Cell;
     260             : class ClosureFeedbackCellArray;
     261             : class ConsString;
     262             : class DependentCode;
     263             : class ElementsAccessor;
     264             : class EnumCache;
     265             : class FixedArrayBase;
     266             : class FixedDoubleArray;
     267             : class FreeSpace;
     268             : class FunctionLiteral;
     269             : class FunctionTemplateInfo;
     270             : class JSAsyncGeneratorObject;
     271             : class JSGlobalProxy;
     272             : class JSPromise;
     273             : class JSProxy;
     274             : class JSProxyRevocableResult;
     275             : class KeyAccumulator;
     276             : class LayoutDescriptor;
     277             : class LookupIterator;
     278             : class FieldType;
     279             : class Module;
     280             : class ModuleInfoEntry;
     281             : class MutableHeapNumber;
     282             : class ObjectHashTable;
     283             : class ObjectTemplateInfo;
     284             : class ObjectVisitor;
     285             : class PreparseData;
     286             : class PropertyArray;
     287             : class PropertyCell;
     288             : class PropertyDescriptor;
     289             : class PrototypeInfo;
     290             : class ReadOnlyRoots;
     291             : class RegExpMatchInfo;
     292             : class RootVisitor;
     293             : class SafepointEntry;
     294             : class ScriptContextTable;
     295             : class SharedFunctionInfo;
     296             : class StringStream;
     297             : class Symbol;
     298             : class FeedbackCell;
     299             : class FeedbackMetadata;
     300             : class FeedbackVector;
     301             : class UncompiledData;
     302             : class TemplateInfo;
     303             : class TransitionArray;
     304             : class TemplateList;
     305             : class WasmInstanceObject;
     306             : class WasmMemoryObject;
     307             : template <typename T>
     308             : class ZoneForwardList;
     309             : 
     310             : #ifdef OBJECT_PRINT
     311             : #define DECL_PRINTER(Name) void Name##Print(std::ostream& os);  // NOLINT
     312             : #else
     313             : #define DECL_PRINTER(Name)
     314             : #endif
     315             : 
     316             : #define OBJECT_TYPE_LIST(V) \
     317             :   V(Smi)                    \
     318             :   V(LayoutDescriptor)       \
     319             :   V(HeapObject)             \
     320             :   V(Primitive)              \
     321             :   V(Number)                 \
     322             :   V(Numeric)
     323             : 
     324             : #define HEAP_OBJECT_ORDINARY_TYPE_LIST_BASE(V) \
     325             :   V(AbstractCode)                              \
     326             :   V(AccessCheckNeeded)                         \
     327             :   V(AllocationSite)                            \
     328             :   V(ArrayList)                                 \
     329             :   V(BigInt)                                    \
     330             :   V(BigIntWrapper)                             \
     331             :   V(ObjectBoilerplateDescription)              \
     332             :   V(Boolean)                                   \
     333             :   V(BooleanWrapper)                            \
     334             :   V(BreakPoint)                                \
     335             :   V(BreakPointInfo)                            \
     336             :   V(ByteArray)                                 \
     337             :   V(BytecodeArray)                             \
     338             :   V(CachedTemplateObject)                      \
     339             :   V(CallHandlerInfo)                           \
     340             :   V(Callable)                                  \
     341             :   V(Cell)                                      \
     342             :   V(ClassBoilerplate)                          \
     343             :   V(Code)                                      \
     344             :   V(CodeDataContainer)                         \
     345             :   V(CompilationCacheTable)                     \
     346             :   V(ConsString)                                \
     347             :   V(Constructor)                               \
     348             :   V(Context)                                   \
     349             :   V(CoverageInfo)                              \
     350             :   V(ClosureFeedbackCellArray)                  \
     351             :   V(DataHandler)                               \
     352             :   V(DeoptimizationData)                        \
     353             :   V(DependentCode)                             \
     354             :   V(DescriptorArray)                           \
     355             :   V(EmbedderDataArray)                         \
     356             :   V(EphemeronHashTable)                        \
     357             :   V(EnumCache)                                 \
     358             :   V(ExternalOneByteString)                     \
     359             :   V(ExternalString)                            \
     360             :   V(ExternalTwoByteString)                     \
     361             :   V(FeedbackCell)                              \
     362             :   V(FeedbackMetadata)                          \
     363             :   V(FeedbackVector)                            \
     364             :   V(Filler)                                    \
     365             :   V(FixedArray)                                \
     366             :   V(FixedArrayBase)                            \
     367             :   V(FixedArrayExact)                           \
     368             :   V(FixedBigInt64Array)                        \
     369             :   V(FixedBigUint64Array)                       \
     370             :   V(FixedDoubleArray)                          \
     371             :   V(FixedFloat32Array)                         \
     372             :   V(FixedFloat64Array)                         \
     373             :   V(FixedInt16Array)                           \
     374             :   V(FixedInt32Array)                           \
     375             :   V(FixedInt8Array)                            \
     376             :   V(FixedTypedArrayBase)                       \
     377             :   V(FixedUint16Array)                          \
     378             :   V(FixedUint32Array)                          \
     379             :   V(FixedUint8Array)                           \
     380             :   V(FixedUint8ClampedArray)                    \
     381             :   V(Foreign)                                   \
     382             :   V(FrameArray)                                \
     383             :   V(FreeSpace)                                 \
     384             :   V(Function)                                  \
     385             :   V(GlobalDictionary)                          \
     386             :   V(HandlerTable)                              \
     387             :   V(HeapNumber)                                \
     388             :   V(InternalizedString)                        \
     389             :   V(JSArgumentsObject)                         \
     390             :   V(JSArgumentsObjectWithLength)               \
     391             :   V(JSArray)                                   \
     392             :   V(JSArrayBuffer)                             \
     393             :   V(JSArrayBufferView)                         \
     394             :   V(JSArrayIterator)                           \
     395             :   V(JSAsyncFromSyncIterator)                   \
     396             :   V(JSAsyncFunctionObject)                     \
     397             :   V(JSAsyncGeneratorObject)                    \
     398             :   V(JSBoundFunction)                           \
     399             :   V(JSCollection)                              \
     400             :   V(JSContextExtensionObject)                  \
     401             :   V(JSDataView)                                \
     402             :   V(JSDate)                                    \
     403             :   V(JSError)                                   \
     404             :   V(JSFunction)                                \
     405             :   V(JSGeneratorObject)                         \
     406             :   V(JSGlobalObject)                            \
     407             :   V(JSGlobalProxy)                             \
     408             :   V(JSMap)                                     \
     409             :   V(JSMapIterator)                             \
     410             :   V(JSMessageObject)                           \
     411             :   V(JSModuleNamespace)                         \
     412             :   V(JSObject)                                  \
     413             :   V(JSPromise)                                 \
     414             :   V(JSProxy)                                   \
     415             :   V(JSReceiver)                                \
     416             :   V(JSRegExp)                                  \
     417             :   V(JSRegExpResult)                            \
     418             :   V(JSRegExpStringIterator)                    \
     419             :   V(JSSet)                                     \
     420             :   V(JSSetIterator)                             \
     421             :   V(JSSloppyArgumentsObject)                   \
     422             :   V(JSStringIterator)                          \
     423             :   V(JSTypedArray)                              \
     424             :   V(JSValue)                                   \
     425             :   V(JSWeakRef)                                 \
     426             :   V(JSWeakCollection)                          \
     427             :   V(JSFinalizationGroup)                       \
     428             :   V(JSFinalizationGroupCleanupIterator)        \
     429             :   V(JSWeakMap)                                 \
     430             :   V(JSWeakSet)                                 \
     431             :   V(LoadHandler)                               \
     432             :   V(Map)                                       \
     433             :   V(MapCache)                                  \
     434             :   V(Microtask)                                 \
     435             :   V(ModuleInfo)                                \
     436             :   V(MutableHeapNumber)                         \
     437             :   V(Name)                                      \
     438             :   V(NameDictionary)                            \
     439             :   V(NativeContext)                             \
     440             :   V(NormalizedMapCache)                        \
     441             :   V(NumberDictionary)                          \
     442             :   V(NumberWrapper)                             \
     443             :   V(ObjectHashSet)                             \
     444             :   V(ObjectHashTable)                           \
     445             :   V(Oddball)                                   \
     446             :   V(OrderedHashMap)                            \
     447             :   V(OrderedHashSet)                            \
     448             :   V(OrderedNameDictionary)                     \
     449             :   V(PreparseData)                              \
     450             :   V(PromiseReactionJobTask)                    \
     451             :   V(PropertyArray)                             \
     452             :   V(PropertyCell)                              \
     453             :   V(PropertyDescriptorObject)                  \
     454             :   V(RegExpMatchInfo)                           \
     455             :   V(ScopeInfo)                                 \
     456             :   V(ScriptContextTable)                        \
     457             :   V(ScriptWrapper)                             \
     458             :   V(SeqOneByteString)                          \
     459             :   V(SeqString)                                 \
     460             :   V(SeqTwoByteString)                          \
     461             :   V(SharedFunctionInfo)                        \
     462             :   V(SimpleNumberDictionary)                    \
     463             :   V(SlicedString)                              \
     464             :   V(SloppyArgumentsElements)                   \
     465             :   V(SmallOrderedHashMap)                       \
     466             :   V(SmallOrderedHashSet)                       \
     467             :   V(SmallOrderedNameDictionary)                \
     468             :   V(SourcePositionTableWithFrameCache)         \
     469             :   V(StoreHandler)                              \
     470             :   V(String)                                    \
     471             :   V(StringSet)                                 \
     472             :   V(StringTable)                               \
     473             :   V(StringWrapper)                             \
     474             :   V(Struct)                                    \
     475             :   V(Symbol)                                    \
     476             :   V(SymbolWrapper)                             \
     477             :   V(TemplateInfo)                              \
     478             :   V(TemplateList)                              \
     479             :   V(TemplateObjectDescription)                 \
     480             :   V(ThinString)                                \
     481             :   V(TransitionArray)                           \
     482             :   V(UncompiledData)                            \
     483             :   V(UncompiledDataWithPreparseData)            \
     484             :   V(UncompiledDataWithoutPreparseData)         \
     485             :   V(Undetectable)                              \
     486             :   V(UniqueName)                                \
     487             :   V(WasmExceptionObject)                       \
     488             :   V(WasmGlobalObject)                          \
     489             :   V(WasmInstanceObject)                        \
     490             :   V(WasmMemoryObject)                          \
     491             :   V(WasmModuleObject)                          \
     492             :   V(WasmTableObject)                           \
     493             :   V(WeakFixedArray)                            \
     494             :   V(WeakArrayList)                             \
     495             :   V(WeakCell)
     496             : 
     497             : #ifdef V8_INTL_SUPPORT
     498             : #define HEAP_OBJECT_ORDINARY_TYPE_LIST(V) \
     499             :   HEAP_OBJECT_ORDINARY_TYPE_LIST_BASE(V)  \
     500             :   V(JSV8BreakIterator)                    \
     501             :   V(JSCollator)                           \
     502             :   V(JSDateTimeFormat)                     \
     503             :   V(JSListFormat)                         \
     504             :   V(JSLocale)                             \
     505             :   V(JSNumberFormat)                       \
     506             :   V(JSPluralRules)                        \
     507             :   V(JSRelativeTimeFormat)                 \
     508             :   V(JSSegmentIterator)                    \
     509             :   V(JSSegmenter)
     510             : #else
     511             : #define HEAP_OBJECT_ORDINARY_TYPE_LIST(V) HEAP_OBJECT_ORDINARY_TYPE_LIST_BASE(V)
     512             : #endif  // V8_INTL_SUPPORT
     513             : 
     514             : #define HEAP_OBJECT_TEMPLATE_TYPE_LIST(V) \
     515             :   V(Dictionary)                           \
     516             :   V(HashTable)
     517             : 
     518             : #define HEAP_OBJECT_TYPE_LIST(V)    \
     519             :   HEAP_OBJECT_ORDINARY_TYPE_LIST(V) \
     520             :   HEAP_OBJECT_TEMPLATE_TYPE_LIST(V)
     521             : 
     522             : #define ODDBALL_LIST(V)                 \
     523             :   V(Undefined, undefined_value)         \
     524             :   V(Null, null_value)                   \
     525             :   V(TheHole, the_hole_value)            \
     526             :   V(Exception, exception)               \
     527             :   V(Uninitialized, uninitialized_value) \
     528             :   V(True, true_value)                   \
     529             :   V(False, false_value)                 \
     530             :   V(ArgumentsMarker, arguments_marker)  \
     531             :   V(OptimizedOut, optimized_out)        \
     532             :   V(StaleRegister, stale_register)
     533             : 
     534             : // The element types selection for CreateListFromArrayLike.
     535             : enum class ElementTypes { kAll, kStringAndSymbol };
     536             : 
     537             : // TODO(mythria): Move this to a better place.
     538             : ShouldThrow GetShouldThrow(Isolate* isolate, Maybe<ShouldThrow> should_throw);
     539             : 
     540             : // Object is the abstract superclass for all classes in the
     541             : // object hierarchy.
     542             : // Object does not use any virtual functions to avoid the
     543             : // allocation of the C++ vtable.
     544             : // There must only be a single data member in Object: the Address ptr,
     545             : // containing the tagged heap pointer that this Object instance refers to.
     546             : // For a design overview, see https://goo.gl/Ph4CGz.
     547             : class Object {
     548             :  public:
     549   568934545 :   constexpr Object() : ptr_(kNullAddress) {}
     550   469086150 :   explicit constexpr Object(Address ptr) : ptr_(ptr) {}
     551             : 
     552             :   // Make clang on Linux catch what MSVC complains about on Windows:
     553             :   operator bool() const = delete;
     554             : 
     555    82428900 :   bool operator==(const Object that) const { return this->ptr() == that.ptr(); }
     556    29395912 :   bool operator!=(const Object that) const { return this->ptr() != that.ptr(); }
     557             :   // Usage in std::set requires operator<.
     558     3613617 :   bool operator<(const Object that) const { return this->ptr() < that.ptr(); }
     559             : 
     560             :   // Returns the tagged "(heap) object pointer" representation of this object.
     561 59197373395 :   constexpr Address ptr() const { return ptr_; }
     562             : 
     563             :   // These operator->() overloads are required for handlified code.
     564             :   Object* operator->() { return this; }
     565             :   const Object* operator->() const { return this; }
     566             : 
     567             :   // Type testing.
     568             :   bool IsObject() const { return true; }
     569             : 
     570             : #define IS_TYPE_FUNCTION_DECL(Type) V8_INLINE bool Is##Type() const;
     571             :   OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL)
     572             :   HEAP_OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL)
     573             : #undef IS_TYPE_FUNCTION_DECL
     574             : 
     575             : // Oddball checks are faster when they are raw pointer comparisons, so the
     576             : // isolate/read-only roots overloads should be preferred where possible.
     577             : #define IS_TYPE_FUNCTION_DECL(Type, Value)            \
     578             :   V8_INLINE bool Is##Type(Isolate* isolate) const;    \
     579             :   V8_INLINE bool Is##Type(ReadOnlyRoots roots) const; \
     580             :   V8_INLINE bool Is##Type() const;
     581             :   ODDBALL_LIST(IS_TYPE_FUNCTION_DECL)
     582             : #undef IS_TYPE_FUNCTION_DECL
     583             : 
     584             :   V8_INLINE bool IsNullOrUndefined(Isolate* isolate) const;
     585             :   V8_INLINE bool IsNullOrUndefined(ReadOnlyRoots roots) const;
     586             :   V8_INLINE bool IsNullOrUndefined() const;
     587             : 
     588             :   enum class Conversion { kToNumber, kToNumeric };
     589             : 
     590             : #define RETURN_FAILURE(isolate, should_throw, call) \
     591             :   do {                                              \
     592             :     if ((should_throw) == kDontThrow) {             \
     593             :       return Just(false);                           \
     594             :     } else {                                        \
     595             :       isolate->Throw(*isolate->factory()->call);    \
     596             :       return Nothing<bool>();                       \
     597             :     }                                               \
     598             :   } while (false)
     599             : 
     600             : #define MAYBE_RETURN(call, value)         \
     601             :   do {                                    \
     602             :     if ((call).IsNothing()) return value; \
     603             :   } while (false)
     604             : 
     605             : #define MAYBE_RETURN_NULL(call) MAYBE_RETURN(call, MaybeHandle<Object>())
     606             : 
     607             : #define MAYBE_ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, dst, call) \
     608             :   do {                                                               \
     609             :     Isolate* __isolate__ = (isolate);                                \
     610             :     if (!(call).To(&dst)) {                                          \
     611             :       DCHECK(__isolate__->has_pending_exception());                  \
     612             :       return ReadOnlyRoots(__isolate__).exception();                 \
     613             :     }                                                                \
     614             :   } while (false)
     615             : 
     616             : #define DECL_STRUCT_PREDICATE(NAME, Name, name) V8_INLINE bool Is##Name() const;
     617             :   STRUCT_LIST(DECL_STRUCT_PREDICATE)
     618             : #undef DECL_STRUCT_PREDICATE
     619             : 
     620             :   // ES6, #sec-isarray.  NOT to be confused with %_IsArray.
     621             :   V8_INLINE
     622             :   V8_WARN_UNUSED_RESULT static Maybe<bool> IsArray(Handle<Object> object);
     623             : 
     624             :   V8_INLINE bool IsHashTableBase() const;
     625             :   V8_INLINE bool IsSmallOrderedHashTable() const;
     626             : 
     627             :   // Extract the number.
     628             :   inline double Number() const;
     629             :   V8_INLINE bool IsNaN() const;
     630             :   V8_INLINE bool IsMinusZero() const;
     631             :   V8_EXPORT_PRIVATE bool ToInt32(int32_t* value);
     632             :   inline bool ToUint32(uint32_t* value) const;
     633             : 
     634             :   inline Representation OptimalRepresentation();
     635             : 
     636             :   inline ElementsKind OptimalElementsKind();
     637             : 
     638             :   inline bool FitsRepresentation(Representation representation);
     639             : 
     640             :   inline bool FilterKey(PropertyFilter filter);
     641             : 
     642             :   Handle<FieldType> OptimalType(Isolate* isolate,
     643             :                                 Representation representation);
     644             : 
     645             :   V8_EXPORT_PRIVATE static Handle<Object> NewStorageFor(
     646             :       Isolate* isolate, Handle<Object> object, Representation representation);
     647             : 
     648             :   static Handle<Object> WrapForRead(Isolate* isolate, Handle<Object> object,
     649             :                                     Representation representation);
     650             : 
     651             :   // Returns true if the object is of the correct type to be used as a
     652             :   // implementation of a JSObject's elements.
     653             :   inline bool HasValidElements();
     654             : 
     655             :   // ECMA-262 9.2.
     656             :   V8_EXPORT_PRIVATE bool BooleanValue(Isolate* isolate);
     657             :   Object ToBoolean(Isolate* isolate);
     658             : 
     659             :   // ES6 section 7.2.11 Abstract Relational Comparison
     660             :   V8_EXPORT_PRIVATE V8_WARN_UNUSED_RESULT static Maybe<ComparisonResult>
     661             :   Compare(Isolate* isolate, Handle<Object> x, Handle<Object> y);
     662             : 
     663             :   // ES6 section 7.2.12 Abstract Equality Comparison
     664             :   V8_EXPORT_PRIVATE V8_WARN_UNUSED_RESULT static Maybe<bool> Equals(
     665             :       Isolate* isolate, Handle<Object> x, Handle<Object> y);
     666             : 
     667             :   // ES6 section 7.2.13 Strict Equality Comparison
     668             :   V8_EXPORT_PRIVATE bool StrictEquals(Object that);
     669             : 
     670             :   // ES6 section 7.1.13 ToObject
     671             :   // Convert to a JSObject if needed.
     672             :   // native_context is used when creating wrapper object.
     673             :   //
     674             :   // Passing a non-null method_name allows us to give a more informative
     675             :   // error message for those cases where ToObject is being called on
     676             :   // the receiver of a built-in method.
     677             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<JSReceiver> ToObject(
     678             :       Isolate* isolate, Handle<Object> object,
     679             :       const char* method_name = nullptr);
     680             :   V8_WARN_UNUSED_RESULT static MaybeHandle<JSReceiver> ToObjectImpl(
     681             :       Isolate* isolate, Handle<Object> object,
     682             :       const char* method_name = nullptr);
     683             : 
     684             :   // ES6 section 9.2.1.2, OrdinaryCallBindThis for sloppy callee.
     685             :   V8_WARN_UNUSED_RESULT static MaybeHandle<JSReceiver> ConvertReceiver(
     686             :       Isolate* isolate, Handle<Object> object);
     687             : 
     688             :   // ES6 section 7.1.14 ToPropertyKey
     689             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Name> ToName(
     690             :       Isolate* isolate, Handle<Object> input);
     691             : 
     692             :   // ES6 section 7.1.1 ToPrimitive
     693             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToPrimitive(
     694             :       Handle<Object> input, ToPrimitiveHint hint = ToPrimitiveHint::kDefault);
     695             : 
     696             :   // ES6 section 7.1.3 ToNumber
     697             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToNumber(
     698             :       Isolate* isolate, Handle<Object> input);
     699             : 
     700             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToNumeric(
     701             :       Isolate* isolate, Handle<Object> input);
     702             : 
     703             :   // ES6 section 7.1.4 ToInteger
     704             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToInteger(
     705             :       Isolate* isolate, Handle<Object> input);
     706             : 
     707             :   // ES6 section 7.1.5 ToInt32
     708             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToInt32(
     709             :       Isolate* isolate, Handle<Object> input);
     710             : 
     711             :   // ES6 section 7.1.6 ToUint32
     712             :   V8_WARN_UNUSED_RESULT inline static MaybeHandle<Object> ToUint32(
     713             :       Isolate* isolate, Handle<Object> input);
     714             : 
     715             :   // ES6 section 7.1.12 ToString
     716             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<String> ToString(
     717             :       Isolate* isolate, Handle<Object> input);
     718             : 
     719             :   V8_EXPORT_PRIVATE static Handle<String> NoSideEffectsToString(
     720             :       Isolate* isolate, Handle<Object> input);
     721             : 
     722             :   // ES6 section 7.1.14 ToPropertyKey
     723             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToPropertyKey(
     724             :       Isolate* isolate, Handle<Object> value);
     725             : 
     726             :   // ES6 section 7.1.15 ToLength
     727             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToLength(
     728             :       Isolate* isolate, Handle<Object> input);
     729             : 
     730             :   // ES6 section 7.1.17 ToIndex
     731             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> ToIndex(
     732             :       Isolate* isolate, Handle<Object> input, MessageTemplate error_index);
     733             : 
     734             :   // ES6 section 7.3.9 GetMethod
     735             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> GetMethod(
     736             :       Handle<JSReceiver> receiver, Handle<Name> name);
     737             : 
     738             :   // ES6 section 7.3.17 CreateListFromArrayLike
     739             :   V8_WARN_UNUSED_RESULT static MaybeHandle<FixedArray> CreateListFromArrayLike(
     740             :       Isolate* isolate, Handle<Object> object, ElementTypes element_types);
     741             : 
     742             :   // Get length property and apply ToLength.
     743             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> GetLengthFromArrayLike(
     744             :       Isolate* isolate, Handle<JSReceiver> object);
     745             : 
     746             :   // ES6 section 12.5.6 The typeof Operator
     747             :   static Handle<String> TypeOf(Isolate* isolate, Handle<Object> object);
     748             : 
     749             :   // ES6 section 12.7 Additive Operators
     750             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> Add(Isolate* isolate,
     751             :                                                        Handle<Object> lhs,
     752             :                                                        Handle<Object> rhs);
     753             : 
     754             :   // ES6 section 12.9 Relational Operators
     755             :   V8_WARN_UNUSED_RESULT static inline Maybe<bool> GreaterThan(Isolate* isolate,
     756             :                                                               Handle<Object> x,
     757             :                                                               Handle<Object> y);
     758             :   V8_WARN_UNUSED_RESULT static inline Maybe<bool> GreaterThanOrEqual(
     759             :       Isolate* isolate, Handle<Object> x, Handle<Object> y);
     760             :   V8_WARN_UNUSED_RESULT static inline Maybe<bool> LessThan(Isolate* isolate,
     761             :                                                            Handle<Object> x,
     762             :                                                            Handle<Object> y);
     763             :   V8_WARN_UNUSED_RESULT static inline Maybe<bool> LessThanOrEqual(
     764             :       Isolate* isolate, Handle<Object> x, Handle<Object> y);
     765             : 
     766             :   // ES6 section 7.3.19 OrdinaryHasInstance (C, O).
     767             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> OrdinaryHasInstance(
     768             :       Isolate* isolate, Handle<Object> callable, Handle<Object> object);
     769             : 
     770             :   // ES6 section 12.10.4 Runtime Semantics: InstanceofOperator(O, C)
     771             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> InstanceOf(
     772             :       Isolate* isolate, Handle<Object> object, Handle<Object> callable);
     773             : 
     774             :   V8_EXPORT_PRIVATE V8_WARN_UNUSED_RESULT static MaybeHandle<Object>
     775             :   GetProperty(LookupIterator* it,
     776             :               OnNonExistent on_non_existent = OnNonExistent::kReturnUndefined);
     777             : 
     778             :   // ES6 [[Set]] (when passed kDontThrow)
     779             :   // Invariants for this and related functions (unless stated otherwise):
     780             :   // 1) When the result is Nothing, an exception is pending.
     781             :   // 2) When passed kThrowOnError, the result is never Just(false).
     782             :   // In some cases, an exception is thrown regardless of the ShouldThrow
     783             :   // argument.  These cases are either in accordance with the spec or not
     784             :   // covered by it (eg., concerning API callbacks).
     785             :   V8_EXPORT_PRIVATE V8_WARN_UNUSED_RESULT static Maybe<bool> SetProperty(
     786             :       LookupIterator* it, Handle<Object> value, StoreOrigin store_origin,
     787             :       Maybe<ShouldThrow> should_throw = Nothing<ShouldThrow>());
     788             :   V8_EXPORT_PRIVATE V8_WARN_UNUSED_RESULT static MaybeHandle<Object>
     789             :   SetProperty(Isolate* isolate, Handle<Object> object, Handle<Name> name,
     790             :               Handle<Object> value,
     791             :               StoreOrigin store_origin = StoreOrigin::kMaybeKeyed,
     792             :               Maybe<ShouldThrow> should_throw = Nothing<ShouldThrow>());
     793             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> SetPropertyOrElement(
     794             :       Isolate* isolate, Handle<Object> object, Handle<Name> name,
     795             :       Handle<Object> value,
     796             :       Maybe<ShouldThrow> should_throw = Nothing<ShouldThrow>(),
     797             :       StoreOrigin store_origin = StoreOrigin::kMaybeKeyed);
     798             : 
     799             :   V8_WARN_UNUSED_RESULT static Maybe<bool> SetSuperProperty(
     800             :       LookupIterator* it, Handle<Object> value, StoreOrigin store_origin,
     801             :       Maybe<ShouldThrow> should_throw = Nothing<ShouldThrow>());
     802             : 
     803             :   V8_WARN_UNUSED_RESULT static Maybe<bool> CannotCreateProperty(
     804             :       Isolate* isolate, Handle<Object> receiver, Handle<Object> name,
     805             :       Handle<Object> value, Maybe<ShouldThrow> should_throw);
     806             :   V8_WARN_UNUSED_RESULT static Maybe<bool> WriteToReadOnlyProperty(
     807             :       LookupIterator* it, Handle<Object> value,
     808             :       Maybe<ShouldThrow> should_throw);
     809             :   V8_WARN_UNUSED_RESULT static Maybe<bool> WriteToReadOnlyProperty(
     810             :       Isolate* isolate, Handle<Object> receiver, Handle<Object> name,
     811             :       Handle<Object> value, ShouldThrow should_throw);
     812             :   V8_WARN_UNUSED_RESULT static Maybe<bool> RedefineIncompatibleProperty(
     813             :       Isolate* isolate, Handle<Object> name, Handle<Object> value,
     814             :       Maybe<ShouldThrow> should_throw);
     815             :   V8_WARN_UNUSED_RESULT static Maybe<bool> SetDataProperty(
     816             :       LookupIterator* it, Handle<Object> value);
     817             :   V8_WARN_UNUSED_RESULT static Maybe<bool> AddDataProperty(
     818             :       LookupIterator* it, Handle<Object> value, PropertyAttributes attributes,
     819             :       Maybe<ShouldThrow> should_throw, StoreOrigin store_origin);
     820             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> GetPropertyOrElement(
     821             :       Isolate* isolate, Handle<Object> object, Handle<Name> name);
     822             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> GetPropertyOrElement(
     823             :       Handle<Object> receiver, Handle<Name> name, Handle<JSReceiver> holder);
     824             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> GetProperty(
     825             :       Isolate* isolate, Handle<Object> object, Handle<Name> name);
     826             : 
     827             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> GetPropertyWithAccessor(
     828             :       LookupIterator* it);
     829             :   V8_WARN_UNUSED_RESULT static Maybe<bool> SetPropertyWithAccessor(
     830             :       LookupIterator* it, Handle<Object> value,
     831             :       Maybe<ShouldThrow> should_throw);
     832             : 
     833             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> GetPropertyWithDefinedGetter(
     834             :       Handle<Object> receiver, Handle<JSReceiver> getter);
     835             :   V8_WARN_UNUSED_RESULT static Maybe<bool> SetPropertyWithDefinedSetter(
     836             :       Handle<Object> receiver, Handle<JSReceiver> setter, Handle<Object> value,
     837             :       Maybe<ShouldThrow> should_throw);
     838             : 
     839             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> GetElement(
     840             :       Isolate* isolate, Handle<Object> object, uint32_t index);
     841             : 
     842             :   V8_WARN_UNUSED_RESULT static inline MaybeHandle<Object> SetElement(
     843             :       Isolate* isolate, Handle<Object> object, uint32_t index,
     844             :       Handle<Object> value, ShouldThrow should_throw);
     845             : 
     846             :   // Returns the permanent hash code associated with this object. May return
     847             :   // undefined if not yet created.
     848             :   inline Object GetHash();
     849             : 
     850             :   // Returns the permanent hash code associated with this object depending on
     851             :   // the actual object type. May create and store a hash code if needed and none
     852             :   // exists.
     853             :   V8_EXPORT_PRIVATE Smi GetOrCreateHash(Isolate* isolate);
     854             : 
     855             :   // Checks whether this object has the same value as the given one.  This
     856             :   // function is implemented according to ES5, section 9.12 and can be used
     857             :   // to implement the Object.is function.
     858             :   V8_EXPORT_PRIVATE bool SameValue(Object other);
     859             : 
     860             :   // A part of SameValue which handles Number vs. Number case.
     861             :   // Treats NaN == NaN and +0 != -0.
     862             :   inline static bool SameNumberValue(double number1, double number2);
     863             : 
     864             :   // Checks whether this object has the same value as the given one.
     865             :   // +0 and -0 are treated equal. Everything else is the same as SameValue.
     866             :   // This function is implemented according to ES6, section 7.2.4 and is used
     867             :   // by ES6 Map and Set.
     868             :   bool SameValueZero(Object other);
     869             : 
     870             :   // ES6 section 9.4.2.3 ArraySpeciesCreate (part of it)
     871             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ArraySpeciesConstructor(
     872             :       Isolate* isolate, Handle<Object> original_array);
     873             : 
     874             :   // ES6 section 7.3.20 SpeciesConstructor ( O, defaultConstructor )
     875             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> SpeciesConstructor(
     876             :       Isolate* isolate, Handle<JSReceiver> recv,
     877             :       Handle<JSFunction> default_ctor);
     878             : 
     879             :   // Tries to convert an object to an array length. Returns true and sets the
     880             :   // output parameter if it succeeds.
     881             :   inline bool ToArrayLength(uint32_t* index) const;
     882             : 
     883             :   // Tries to convert an object to an array index. Returns true and sets the
     884             :   // output parameter if it succeeds. Equivalent to ToArrayLength, but does not
     885             :   // allow kMaxUInt32.
     886             :   V8_WARN_UNUSED_RESULT inline bool ToArrayIndex(uint32_t* index) const;
     887             : 
     888             :   // Returns true if the result of iterating over the object is the same
     889             :   // (including observable effects) as simply accessing the properties between 0
     890             :   // and length.
     891             :   bool IterationHasObservableEffects();
     892             : 
     893             :   //
     894             :   // The following GetHeapObjectXX methods mimic corresponding functionality
     895             :   // in MaybeObject. Having them here allows us to unify code that processes
     896             :   // ObjectSlots and MaybeObjectSlots.
     897             :   //
     898             : 
     899             :   // If this Object is a strong pointer to a HeapObject, returns true and
     900             :   // sets *result. Otherwise returns false.
     901             :   inline bool GetHeapObjectIfStrong(HeapObject* result) const;
     902             : 
     903             :   // If this Object is a strong pointer to a HeapObject (weak pointers are not
     904             :   // expected), returns true and sets *result. Otherwise returns false.
     905             :   inline bool GetHeapObject(HeapObject* result) const;
     906             : 
     907             :   // DCHECKs that this Object is a strong pointer to a HeapObject and returns
     908             :   // the HeapObject.
     909             :   inline HeapObject GetHeapObject() const;
     910             : 
     911             :   // Always returns false because Object is not expected to be a weak pointer
     912             :   // to a HeapObject.
     913             :   inline bool GetHeapObjectIfWeak(HeapObject* result) const {
     914             :     DCHECK(!HasWeakHeapObjectTag(ptr()));
     915             :     return false;
     916             :   }
     917             :   // Always returns false because Object is not expected to be a weak pointer
     918             :   // to a HeapObject.
     919             :   inline bool IsCleared() const { return false; }
     920             : 
     921             :   EXPORT_DECL_VERIFIER(Object)
     922             : 
     923             : #ifdef VERIFY_HEAP
     924             :   // Verify a pointer is a valid object pointer.
     925             :   static void VerifyPointer(Isolate* isolate, Object p);
     926             : #endif
     927             : 
     928             :   inline void VerifyApiCallResultType();
     929             : 
     930             :   // Prints this object without details.
     931             :   V8_EXPORT_PRIVATE void ShortPrint(FILE* out = stdout) const;
     932             : 
     933             :   // Prints this object without details to a message accumulator.
     934             :   V8_EXPORT_PRIVATE void ShortPrint(StringStream* accumulator) const;
     935             : 
     936             :   V8_EXPORT_PRIVATE void ShortPrint(std::ostream& os) const;  // NOLINT
     937             : 
     938             :   inline static Object cast(Object object) { return object; }
     939             :   inline static Object unchecked_cast(Object object) { return object; }
     940             : 
     941             :   // Layout description.
     942             :   static const int kHeaderSize = 0;  // Object does not take up any space.
     943             : 
     944             : #ifdef OBJECT_PRINT
     945             :   // For our gdb macros, we should perhaps change these in the future.
     946             :   V8_EXPORT_PRIVATE void Print() const;
     947             : 
     948             :   // Prints this object with details.
     949             :   V8_EXPORT_PRIVATE void Print(std::ostream& os) const;  // NOLINT
     950             : #else
     951          24 :   void Print() const { ShortPrint(); }
     952           0 :   void Print(std::ostream& os) const { ShortPrint(os); }  // NOLINT
     953             : #endif
     954             : 
     955             :   // For use with std::unordered_set.
     956             :   struct Hasher {
     957             :     size_t operator()(const Object o) const {
     958             :       return std::hash<v8::internal::Address>{}(o.ptr());
     959             :     }
     960             :   };
     961             : 
     962             :   // For use with std::map.
     963             :   struct Comparer {
     964             :     bool operator()(const Object a, const Object b) const {
     965           0 :       return a.ptr() < b.ptr();
     966             :     }
     967             :   };
     968             : 
     969             :  private:
     970             :   friend class CompressedObjectSlot;
     971             :   friend class FullObjectSlot;
     972             :   friend class LookupIterator;
     973             :   friend class StringStream;
     974             : 
     975             :   // Return the map of the root of object's prototype chain.
     976             :   Map GetPrototypeChainRootMap(Isolate* isolate) const;
     977             : 
     978             :   // Returns a non-SMI for JSReceivers, but returns the hash code for
     979             :   // simple objects.  This avoids a double lookup in the cases where
     980             :   // we know we will add the hash to the JSReceiver if it does not
     981             :   // already exist.
     982             :   //
     983             :   // Despite its size, this needs to be inlined for performance
     984             :   // reasons.
     985             :   static inline Object GetSimpleHash(Object object);
     986             : 
     987             :   // Helper for SetProperty and SetSuperProperty.
     988             :   // Return value is only meaningful if [found] is set to true on return.
     989             :   V8_WARN_UNUSED_RESULT static Maybe<bool> SetPropertyInternal(
     990             :       LookupIterator* it, Handle<Object> value, Maybe<ShouldThrow> should_throw,
     991             :       StoreOrigin store_origin, bool* found);
     992             : 
     993             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Name> ConvertToName(
     994             :       Isolate* isolate, Handle<Object> input);
     995             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToPropertyKey(
     996             :       Isolate* isolate, Handle<Object> value);
     997             :   V8_EXPORT_PRIVATE V8_WARN_UNUSED_RESULT static MaybeHandle<String>
     998             :   ConvertToString(Isolate* isolate, Handle<Object> input);
     999             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToNumberOrNumeric(
    1000             :       Isolate* isolate, Handle<Object> input, Conversion mode);
    1001             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToInteger(
    1002             :       Isolate* isolate, Handle<Object> input);
    1003             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToInt32(
    1004             :       Isolate* isolate, Handle<Object> input);
    1005             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToUint32(
    1006             :       Isolate* isolate, Handle<Object> input);
    1007             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToLength(
    1008             :       Isolate* isolate, Handle<Object> input);
    1009             :   V8_WARN_UNUSED_RESULT static MaybeHandle<Object> ConvertToIndex(
    1010             :       Isolate* isolate, Handle<Object> input, MessageTemplate error_index);
    1011             : 
    1012             :   Address ptr_;
    1013             : };
    1014             : 
    1015             : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os, const Object& obj);
    1016             : 
    1017             : // In objects.h to be usable without objects-inl.h inclusion.
    1018 21408995718 : bool Object::IsSmi() const { return HAS_SMI_TAG(ptr()); }
    1019             : bool Object::IsHeapObject() const {
    1020             :   DCHECK_EQ(!IsSmi(), Internals::HasHeapObjectTag(ptr()));
    1021    31076844 :   return !IsSmi();
    1022             : }
    1023             : 
    1024             : struct Brief {
    1025             :   V8_EXPORT_PRIVATE explicit Brief(const Object v);
    1026             :   explicit Brief(const MaybeObject v);
    1027             :   // {value} is a tagged heap object reference (weak or strong), equivalent to
    1028             :   // a MaybeObject's payload. It has a plain Address type to keep #includes
    1029             :   // lightweight.
    1030             :   const Address value;
    1031             : };
    1032             : 
    1033             : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os, const Brief& v);
    1034             : 
    1035             : // Objects should never have the weak tag; this variant is for overzealous
    1036             : // checking.
    1037             : V8_INLINE static bool HasWeakHeapObjectTag(const Object value) {
    1038             :   return ((value->ptr() & kHeapObjectTagMask) == kWeakHeapObjectTag);
    1039             : }
    1040             : 
    1041             : // Heap objects typically have a map pointer in their first word.  However,
    1042             : // during GC other data (e.g. mark bits, forwarding addresses) is sometimes
    1043             : // encoded in the first word.  The class MapWord is an abstraction of the
    1044             : // value in a heap object's first word.
    1045             : class MapWord {
    1046             :  public:
    1047             :   // Normal state: the map word contains a map pointer.
    1048             : 
    1049             :   // Create a map word from a map pointer.
    1050             :   static inline MapWord FromMap(const Map map);
    1051             : 
    1052             :   // View this map word as a map pointer.
    1053             :   inline Map ToMap() const;
    1054             : 
    1055             :   // Scavenge collection: the map word of live objects in the from space
    1056             :   // contains a forwarding address (a heap object pointer in the to space).
    1057             : 
    1058             :   // True if this map word is a forwarding address for a scavenge
    1059             :   // collection.  Only valid during a scavenge collection (specifically,
    1060             :   // when all map words are heap object pointers, i.e. not during a full GC).
    1061             :   inline bool IsForwardingAddress() const;
    1062             : 
    1063             :   // Create a map word from a forwarding address.
    1064             :   static inline MapWord FromForwardingAddress(HeapObject object);
    1065             : 
    1066             :   // View this map word as a forwarding address.
    1067             :   inline HeapObject ToForwardingAddress();
    1068             : 
    1069             :   static inline MapWord FromRawValue(uintptr_t value) {
    1070             :     return MapWord(value);
    1071             :   }
    1072             : 
    1073             :   inline uintptr_t ToRawValue() {
    1074             :     return value_;
    1075             :   }
    1076             : 
    1077             :  private:
    1078             :   // HeapObject calls the private constructor and directly reads the value.
    1079             :   friend class HeapObject;
    1080             : 
    1081             :   explicit MapWord(Address value) : value_(value) {}
    1082             : 
    1083             :   Address value_;
    1084             : };
    1085             : 
    1086             : template <int start_offset, int end_offset, int size>
    1087             : class FixedBodyDescriptor;
    1088             : 
    1089             : template <int start_offset>
    1090             : class FlexibleBodyDescriptor;
    1091             : 
    1092             : template <int start_offset>
    1093             : class FlexibleWeakBodyDescriptor;
    1094             : 
    1095             : template <class ParentBodyDescriptor, class ChildBodyDescriptor>
    1096             : class SubclassBodyDescriptor;
    1097             : 
    1098             : enum EnsureElementsMode {
    1099             :   DONT_ALLOW_DOUBLE_ELEMENTS,
    1100             :   ALLOW_COPIED_DOUBLE_ELEMENTS,
    1101             :   ALLOW_CONVERTED_DOUBLE_ELEMENTS
    1102             : };
    1103             : 
    1104             : 
    1105             : // Indicator for one component of an AccessorPair.
    1106             : enum AccessorComponent {
    1107             :   ACCESSOR_GETTER,
    1108             :   ACCESSOR_SETTER
    1109             : };
    1110             : 
    1111             : enum class GetKeysConversion {
    1112             :   kKeepNumbers = static_cast<int>(v8::KeyConversionMode::kKeepNumbers),
    1113             :   kConvertToString = static_cast<int>(v8::KeyConversionMode::kConvertToString)
    1114             : };
    1115             : 
    1116             : enum class KeyCollectionMode {
    1117             :   kOwnOnly = static_cast<int>(v8::KeyCollectionMode::kOwnOnly),
    1118             :   kIncludePrototypes =
    1119             :       static_cast<int>(v8::KeyCollectionMode::kIncludePrototypes)
    1120             : };
    1121             : 
    1122             : // Utility superclass for stack-allocated objects that must be updated
    1123             : // on gc.  It provides two ways for the gc to update instances, either
    1124             : // iterating or updating after gc.
    1125             : class Relocatable {
    1126             :  public:
    1127             :   explicit inline Relocatable(Isolate* isolate);
    1128             :   inline virtual ~Relocatable();
    1129         413 :   virtual void IterateInstance(RootVisitor* v) {}
    1130       31567 :   virtual void PostGarbageCollection() { }
    1131             : 
    1132             :   static void PostGarbageCollectionProcessing(Isolate* isolate);
    1133             :   static int ArchiveSpacePerThread();
    1134             :   static char* ArchiveState(Isolate* isolate, char* to);
    1135             :   static char* RestoreState(Isolate* isolate, char* from);
    1136             :   static void Iterate(Isolate* isolate, RootVisitor* v);
    1137             :   static void Iterate(RootVisitor* v, Relocatable* top);
    1138             :   static char* Iterate(RootVisitor* v, char* t);
    1139             : 
    1140             :  private:
    1141             :   Isolate* isolate_;
    1142             :   Relocatable* prev_;
    1143             : };
    1144             : 
    1145             : // BooleanBit is a helper class for setting and getting a bit in an integer.
    1146             : class BooleanBit : public AllStatic {
    1147             :  public:
    1148             :   static inline bool get(int value, int bit_position) {
    1149    65062013 :     return (value & (1 << bit_position)) != 0;
    1150             :   }
    1151             : 
    1152             :   static inline int set(int value, int bit_position, bool v) {
    1153    17215597 :     if (v) {
    1154     8005986 :       value |= (1 << bit_position);
    1155             :     } else {
    1156    11178356 :       value &= ~(1 << bit_position);
    1157             :     }
    1158             :     return value;
    1159             :   }
    1160             : };
    1161             : 
    1162             : 
    1163             : }  // NOLINT, false-positive due to second-order macros.
    1164             : }  // NOLINT, false-positive due to second-order macros.
    1165             : 
    1166             : #include "src/objects/object-macros-undef.h"
    1167             : 
    1168             : #endif  // V8_OBJECTS_H_

Generated by: LCOV version 1.10