V8 Project
Classes | Public Types | Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Member Functions | Static Private Member Functions | List of all members
v8::internal::ConstantPoolArray Class Reference

#include <objects.h>

+ Inheritance diagram for v8::internal::ConstantPoolArray:
+ Collaboration diagram for v8::internal::ConstantPoolArray:

Classes

class  BASE_EMBEDDED
 
class  CodePtrCountField
 
class  HeapPtrCountField
 
class  Int32CountField
 
class  Int64CountField
 
class  IsExtendedField
 
class  TotalCountField
 
class  WeakObjectStateField
 

Public Types

enum  WeakObjectState { NO_WEAK_OBJECTS , WEAK_OBJECTS_IN_OPTIMIZED_CODE , WEAK_OBJECTS_IN_IC }
 
enum  Type {
  INT64 = 0 , CODE_PTR , HEAP_PTR , INT32 ,
  NUMBER_OF_TYPES , FIRST_TYPE = INT64 , LAST_TYPE = INT32
}
 
enum  LayoutSection { SMALL_SECTION = 0 , EXTENDED_SECTION , NUMBER_OF_LAYOUT_SECTIONS }
 
- Public Types inherited from v8::internal::Object
enum  StoreFromKeyed { MAY_BE_STORE_FROM_KEYED , CERTAINLY_NOT_STORE_FROM_KEYED }
 
enum  StorePropertyMode { NORMAL_PROPERTY , SUPER_PROPERTY }
 

Public Member Functions

int first_index (Type type, LayoutSection layout_section)
 
int last_index (Type type, LayoutSection layout_section)
 
int number_of_entries (Type type, LayoutSection layout_section)
 
Type get_type (int index)
 
bool offset_is_type (int offset, Type type)
 
Address get_code_ptr_entry (int index)
 
Object * get_heap_ptr_entry (int index)
 
int64_t get_int64_entry (int index)
 
int32_t get_int32_entry (int index)
 
double get_int64_entry_as_double (int index)
 
void set (int index, Address value)
 
void set (int index, Object *value)
 
void set (int index, int64_t value)
 
void set (int index, double value)
 
void set (int index, int32_t value)
 
void set_at_offset (int offset, int32_t value)
 
void set_at_offset (int offset, int64_t value)
 
void set_at_offset (int offset, double value)
 
void set_at_offset (int offset, Address value)
 
void set_at_offset (int offset, Object *value)
 
void set_weak_object_state (WeakObjectState state)
 
WeakObjectState get_weak_object_state ()
 
bool is_extended_layout ()
 
LayoutSection final_section ()
 
void Init (const NumberOfEntries &small)
 
void InitExtended (const NumberOfEntries &small, const NumberOfEntries &extended)
 
void ClearPtrEntries (Isolate *isolate)
 
int length ()
 
int size ()
 
int OffsetOfElementAt (int index)
 
Object ** RawFieldOfElementAt (int index)
 
void ConstantPoolIterateBody (ObjectVisitor *v)
 
- Public Member Functions inherited from v8::internal::HeapObject
Map * map () const
 
void set_map (Map *value)
 
void set_map_no_write_barrier (Map *value)
 
Map * synchronized_map ()
 
MapWord synchronized_map_word () const
 
void synchronized_set_map (Map *value)
 
void synchronized_set_map_no_write_barrier (Map *value)
 
void synchronized_set_map_word (MapWord map_word)
 
MapWord map_word () const
 
void set_map_word (MapWord map_word)
 
Heap * GetHeap () const
 
Isolate * GetIsolate () const
 
Address address ()
 
void Iterate (ObjectVisitor *v)
 
void IterateBody (InstanceType type, int object_size, ObjectVisitor *v)
 
int Size ()
 
bool MayContainRawValues ()
 
int SizeFromMap (Map *map)
 
WriteBarrierMode GetWriteBarrierMode (const DisallowHeapAllocation &promise)
 
void HeapObjectShortPrint (OStream &os)
 
 STATIC_ASSERT (kMapOffset==Internals::kHeapObjectMapOffset)
 
- Public Member Functions inherited from v8::internal::Object
bool IsObject () const
 
 INLINE (bool IsFixedArrayBase() const)
 
 INLINE (bool IsExternal() const)
 
 INLINE (bool IsAccessorInfo() const)
 
 INLINE (bool IsStruct() const)
 
 INLINE (bool IsSpecObject()) const
 
 INLINE (bool IsSpecFunction()) const
 
 INLINE (bool IsTemplateInfo()) const
 
 INLINE (bool IsNameDictionary() const)
 
 INLINE (bool IsSeededNumberDictionary() const)
 
 INLINE (bool IsUnseededNumberDictionary() const)
 
 INLINE (bool IsOrderedHashSet() const)
 
 INLINE (bool IsOrderedHashMap() const)
 
bool IsCallable () const
 
 INLINE (bool IsUndefined() const)
 
 INLINE (bool IsNull() const)
 
 INLINE (bool IsTheHole() const)
 
 INLINE (bool IsException() const)
 
 INLINE (bool IsUninitialized() const)
 
 INLINE (bool IsTrue() const)
 
 INLINE (bool IsFalse() const)
 
 INLINE (bool IsArgumentsMarker() const)
 
 INLINE (bool IsFiller() const)
 
double Number ()
 
 INLINE (bool IsNaN() const)
 
 INLINE (bool IsMinusZero() const)
 
bool ToInt32 (int32_t *value)
 
bool ToUint32 (uint32_t *value)
 
Representation OptimalRepresentation ()
 
bool FitsRepresentation (Representation representation)
 
Handle< HeapType > OptimalType (Isolate *isolate, Representation representation)
 
bool HasValidElements ()
 
bool HasSpecificClassOf (String *name)
 
bool BooleanValue ()
 
Object * GetHash ()
 
bool SameValue (Object *other)
 
bool SameValueZero (Object *other)
 
bool ToArrayIndex (uint32_t *index)
 
bool IsStringObjectWithCharacterAt (uint32_t index)
 
void VerifyApiCallResultType ()
 
void ShortPrint (FILE *out=stdout)
 
void ShortPrint (StringStream *accumulator)
 

Static Public Member Functions

static int MaxInt64Offset (int number_of_int64)
 
static int SizeFor (const NumberOfEntries &small)
 
static int SizeForExtended (const NumberOfEntries &small, const NumberOfEntries &extended)
 
static int entry_size (Type type)
 
- Static Public Member Functions inherited from v8::internal::HeapObject
static HeapObject * FromAddress (Address address)
 
static Object ** RawField (HeapObject *obj, int offset)
 
static void UpdateMapCodeCache (Handle< HeapObject > object, Handle< Name > name, Handle< Code > code)
 
- Static Public Member Functions inherited from v8::internal::Object
static Handle< Object > NewStorageFor (Isolate *isolate, Handle< Object > object, Representation representation)
 
static Handle< Object > WrapForRead (Isolate *isolate, Handle< Object > object, Representation representation)
 
static MaybeHandle< JSReceiver > ToObject (Isolate *isolate, Handle< Object > object)
 
static MaybeHandle< JSReceiver > ToObject (Isolate *isolate, Handle< Object > object, Handle< Context > context)
 
static MUST_USE_RESULT MaybeHandle< Smi > ToSmi (Isolate *isolate, Handle< Object > object)
 
static MUST_USE_RESULT MaybeHandle< Object > GetProperty (LookupIterator *it)
 
static MUST_USE_RESULT MaybeHandle< Object > SetProperty (Handle< Object > object, Handle< Name > key, Handle< Object > value, StrictMode strict_mode, StoreFromKeyed store_mode=MAY_BE_STORE_FROM_KEYED)
 
static MUST_USE_RESULT MaybeHandle< Object > SetProperty (LookupIterator *it, Handle< Object > value, StrictMode strict_mode, StoreFromKeyed store_mode, StorePropertyMode data_store_mode=NORMAL_PROPERTY)
 
static MUST_USE_RESULT MaybeHandle< Object > WriteToReadOnlyProperty (LookupIterator *it, Handle< Object > value, StrictMode strict_mode)
 
static Handle< Object > SetDataProperty (LookupIterator *it, Handle< Object > value)
 
static MUST_USE_RESULT MaybeHandle< Object > AddDataProperty (LookupIterator *it, Handle< Object > value, PropertyAttributes attributes, StrictMode strict_mode, StoreFromKeyed store_mode)
 
static MUST_USE_RESULT MaybeHandle< Object > GetPropertyOrElement (Handle< Object > object, Handle< Name > key)
 
static MUST_USE_RESULT MaybeHandle< Object > GetProperty (Isolate *isolate, Handle< Object > object, const char *key)
 
static MUST_USE_RESULT MaybeHandle< Object > GetProperty (Handle< Object > object, Handle< Name > key)
 
static MUST_USE_RESULT MaybeHandle< Object > GetPropertyWithAccessor (Handle< Object > receiver, Handle< Name > name, Handle< JSObject > holder, Handle< Object > structure)
 
static MUST_USE_RESULT MaybeHandle< Object > SetPropertyWithAccessor (Handle< Object > receiver, Handle< Name > name, Handle< Object > value, Handle< JSObject > holder, Handle< Object > structure, StrictMode strict_mode)
 
static MUST_USE_RESULT MaybeHandle< Object > GetPropertyWithDefinedGetter (Handle< Object > receiver, Handle< JSReceiver > getter)
 
static MUST_USE_RESULT MaybeHandle< Object > SetPropertyWithDefinedSetter (Handle< Object > receiver, Handle< JSReceiver > setter, Handle< Object > value)
 
static MUST_USE_RESULT MaybeHandle< Object > GetElement (Isolate *isolate, Handle< Object > object, uint32_t index)
 
static MUST_USE_RESULT MaybeHandle< Object > GetElementWithReceiver (Isolate *isolate, Handle< Object > object, Handle< Object > receiver, uint32_t index)
 
static Handle< Smi > GetOrCreateHash (Isolate *isolate, Handle< Object > object)
 

Static Public Attributes

static const int kSmallLayout1Offset = HeapObject::kHeaderSize
 
static const int kSmallLayout2Offset = kSmallLayout1Offset + kInt32Size
 
static const int kHeaderSize = kSmallLayout2Offset + kInt32Size
 
static const int kFirstEntryOffset = ROUND_UP(kHeaderSize, kInt64Size)
 
static const int kSmallLayoutCountBits = 10
 
static const int kMaxSmallEntriesPerType = (1 << kSmallLayoutCountBits) - 1
 
static const int kExtendedInt64CountOffset = 0
 
static const int kExtendedCodePtrCountOffset
 
static const int kExtendedHeapPtrCountOffset
 
static const int kExtendedInt32CountOffset
 
static const int kExtendedFirstOffset
 
- Static Public Attributes inherited from v8::internal::HeapObject
static const int kMapOffset = Object::kHeaderSize
 
static const int kHeaderSize = kMapOffset + kPointerSize
 
- Static Public Attributes inherited from v8::internal::Object
static const int kHeaderSize = 0
 

Private Member Functions

int first_extended_section_index ()
 
int get_extended_section_header_offset ()
 
 DISALLOW_IMPLICIT_CONSTRUCTORS (ConstantPoolArray)
 

Static Private Member Functions

static Type next_type (Type type)
 

Additional Inherited Members

- Protected Member Functions inherited from v8::internal::HeapObject
void IteratePointers (ObjectVisitor *v, int start, int end)
 
void IteratePointer (ObjectVisitor *v, int offset)
 
void IterateNextCodeLink (ObjectVisitor *v, int offset)
 

Detailed Description

Definition at line 2600 of file objects.h.

Member Enumeration Documentation

◆ LayoutSection

enum v8::internal::ConstantPoolArray::LayoutSection
Enumerator
SMALL_SECTION 
EXTENDED_SECTION 
NUMBER_OF_LAYOUT_SECTIONS 

Definition at line 2619 of file objects.h.

2619  {
2620  SMALL_SECTION = 0,
2621  EXTENDED_SECTION,
2622  NUMBER_OF_LAYOUT_SECTIONS
2623  };

◆ Type

enum v8::internal::ConstantPoolArray::Type
Enumerator
INT64 
CODE_PTR 
HEAP_PTR 
INT32 
NUMBER_OF_TYPES 
FIRST_TYPE 
LAST_TYPE 

Definition at line 2608 of file objects.h.

2608  {
2609  INT64 = 0,
2610  CODE_PTR,
2611  HEAP_PTR,
2612  INT32,
2613  // Number of types stored by the ConstantPoolArrays.
2614  NUMBER_OF_TYPES,
2615  FIRST_TYPE = INT64,
2616  LAST_TYPE = INT32
2617  };

◆ WeakObjectState

enum v8::internal::ConstantPoolArray::WeakObjectState
Enumerator
NO_WEAK_OBJECTS 
WEAK_OBJECTS_IN_OPTIMIZED_CODE 
WEAK_OBJECTS_IN_IC 

Definition at line 2602 of file objects.h.

2602  {
2603  NO_WEAK_OBJECTS,
2604  WEAK_OBJECTS_IN_OPTIMIZED_CODE,
2605  WEAK_OBJECTS_IN_IC
2606  };

Member Function Documentation

◆ ClearPtrEntries()

void v8::internal::ConstantPoolArray::ClearPtrEntries ( Isolate *  isolate)

Definition at line 9084 of file objects.cc.

9084  {
9085  Type type[] = { CODE_PTR, HEAP_PTR };
9086  Address default_value[] = {
9087  isolate->builtins()->builtin(Builtins::kIllegal)->entry(),
9088  reinterpret_cast<Address>(isolate->heap()->undefined_value()) };
9089 
9090  for (int i = 0; i < 2; ++i) {
9091  for (int s = 0; s <= final_section(); ++s) {
9092  LayoutSection section = static_cast<LayoutSection>(s);
9093  if (number_of_entries(type[i], section) > 0) {
9094  int offset = OffsetOfElementAt(first_index(type[i], section));
9095  MemsetPointer(
9096  reinterpret_cast<Address*>(HeapObject::RawField(this, offset)),
9097  default_value[i],
9098  number_of_entries(type[i], section));
9099  }
9100  }
9101  }
9102 }
v8::internal::ConstantPoolArray::OffsetOfElementAt
int OffsetOfElementAt(int index)
Definition: objects.h:2792
v8::internal::ConstantPoolArray::first_index
int first_index(Type type, LayoutSection layout_section)
Definition: objects-inl.h:2394
v8::internal::ConstantPoolArray::number_of_entries
int number_of_entries(Type type, LayoutSection layout_section)
Definition: objects-inl.h:2415
v8::internal::HeapObject::RawField
static Object ** RawField(HeapObject *obj, int offset)
Definition: objects-inl.h:1311
v8::internal::MemsetPointer
void MemsetPointer(T **dest, U *value, int counter)
Definition: utils.h:1183
v8::internal::Address
byte * Address
Definition: globals.h:101

References v8::internal::Builtins::builtin(), v8::internal::Isolate::builtins(), CODE_PTR, v8::internal::Code::entry(), final_section(), first_index(), v8::internal::Isolate::heap(), HEAP_PTR, v8::internal::MemsetPointer(), number_of_entries(), OffsetOfElementAt(), and v8::internal::HeapObject::RawField().

Referenced by v8::internal::Heap::AllocateConstantPoolArray(), and v8::internal::Heap::AllocateExtendedConstantPoolArray().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ ConstantPoolIterateBody()

void v8::internal::ConstantPoolArray::ConstantPoolIterateBody ( ObjectVisitor *  v)

Definition at line 9062 of file objects.cc.

9062  {
9063  // Unfortunately the serializer relies on pointers within an object being
9064  // visited in-order, so we have to iterate both the code and heap pointers in
9065  // the small section before doing so in the extended section.
9066  for (int s = 0; s <= final_section(); ++s) {
9067  LayoutSection section = static_cast<LayoutSection>(s);
9068  ConstantPoolArray::Iterator code_iter(this, ConstantPoolArray::CODE_PTR,
9069  section);
9070  while (!code_iter.is_finished()) {
9071  v->VisitCodeEntry(reinterpret_cast<Address>(
9072  RawFieldOfElementAt(code_iter.next_index())));
9073  }
9074 
9075  ConstantPoolArray::Iterator heap_iter(this, ConstantPoolArray::HEAP_PTR,
9076  section);
9077  while (!heap_iter.is_finished()) {
9078  v->VisitPointer(RawFieldOfElementAt(heap_iter.next_index()));
9079  }
9080  }
9081 }
v8::internal::ConstantPoolArray::RawFieldOfElementAt
Object ** RawFieldOfElementAt(int index)
Definition: objects.h:2819

References CODE_PTR, final_section(), HEAP_PTR, and RawFieldOfElementAt().

+ Here is the call graph for this function:

◆ DISALLOW_IMPLICIT_CONSTRUCTORS()

v8::internal::ConstantPoolArray::DISALLOW_IMPLICIT_CONSTRUCTORS ( ConstantPoolArray  )
private

◆ entry_size()

static int v8::internal::ConstantPoolArray::entry_size ( Type  type)
inlinestatic

Definition at line 2776 of file objects.h.

2776  {
2777  switch (type) {
2778  case INT32:
2779  return kInt32Size;
2780  case INT64:
2781  return kInt64Size;
2782  case CODE_PTR:
2783  case HEAP_PTR:
2784  return kPointerSize;
2785  default:
2786  UNREACHABLE();
2787  return 0;
2788  }
2789  }
UNREACHABLE
#define UNREACHABLE()
Definition: logging.h:30
v8::internal::kPointerSize
const int kPointerSize
Definition: globals.h:129
v8::internal::kInt64Size
const int kInt64Size
Definition: globals.h:126
v8::internal::kInt32Size
const int kInt32Size
Definition: globals.h:125

References v8::internal::kInt32Size, v8::internal::kInt64Size, v8::internal::kPointerSize, and UNREACHABLE.

◆ final_section()

ConstantPoolArray::LayoutSection v8::internal::ConstantPoolArray::final_section ( )
inline

Definition at line 2363 of file objects-inl.h.

2363  {
2364  return is_extended_layout() ? EXTENDED_SECTION : SMALL_SECTION;
2365 }

References EXTENDED_SECTION, is_extended_layout(), and SMALL_SECTION.

Referenced by ClearPtrEntries(), and ConstantPoolIterateBody().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ first_extended_section_index()

int v8::internal::ConstantPoolArray::first_extended_section_index ( )
inlineprivate

Definition at line 2368 of file objects-inl.h.

2368  {
2369  DCHECK(is_extended_layout());
2370  uint32_t small_layout_2 = READ_UINT32_FIELD(this, kSmallLayout2Offset);
2371  return TotalCountField::decode(small_layout_2);
2372 }
uint32_t
v8::internal::BitFieldBase::decode
static T decode(U value)
Definition: utils.h:228
v8::internal::ConstantPoolArray::kSmallLayout2Offset
static const int kSmallLayout2Offset
Definition: objects.h:2825
DCHECK
#define DCHECK(condition)
Definition: logging.h:205
READ_UINT32_FIELD
#define READ_UINT32_FIELD(p, offset)
Definition: objects-inl.h:1272

References DCHECK, v8::internal::BitFieldBase< T, shift, size, U >::decode(), is_extended_layout(), kSmallLayout2Offset, and READ_UINT32_FIELD.

Referenced by first_index(), and get_type().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ first_index()

int v8::internal::ConstantPoolArray::first_index ( Type  type,
LayoutSection  layout_section 
)
inline

Definition at line 2394 of file objects-inl.h.

2394  {
2395  int index = 0;
2396  if (section == EXTENDED_SECTION) {
2397  DCHECK(is_extended_layout());
2398  index += first_extended_section_index();
2399  }
2400 
2401  for (Type type_iter = FIRST_TYPE; type_iter < type;
2402  type_iter = next_type(type_iter)) {
2403  index += number_of_entries(type_iter, section);
2404  }
2405 
2406  return index;
2407 }
v8::internal::ConstantPoolArray::next_type
static Type next_type(Type type)
Definition: objects.h:2865

References DCHECK, EXTENDED_SECTION, first_extended_section_index(), FIRST_TYPE, is_extended_layout(), next_type(), and number_of_entries().

Referenced by ClearPtrEntries(), last_index(), and offset_is_type().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_code_ptr_entry()

Address v8::internal::ConstantPoolArray::get_code_ptr_entry ( int  index)
inline

Definition at line 2497 of file objects-inl.h.

2497  {
2498  DCHECK(map() == GetHeap()->constant_pool_array_map());
2499  DCHECK(get_type(index) == CODE_PTR);
2500  return reinterpret_cast<Address>(READ_FIELD(this, OffsetOfElementAt(index)));
2501 }
v8::internal::HeapObject::GetHeap
Heap * GetHeap() const
Definition: objects-inl.h:1379
READ_FIELD
#define READ_FIELD(p, offset)
Definition: objects-inl.h:1179

References CODE_PTR, DCHECK, get_type(), v8::internal::HeapObject::GetHeap(), v8::internal::HeapObject::map(), OffsetOfElementAt(), and READ_FIELD.

+ Here is the call graph for this function:

◆ get_extended_section_header_offset()

int v8::internal::ConstantPoolArray::get_extended_section_header_offset ( )
inlineprivate

Definition at line 2375 of file objects-inl.h.

2375  {
2376  return RoundUp(SizeFor(NumberOfEntries(this, SMALL_SECTION)), kInt64Size);
2377 }
v8::internal::ConstantPoolArray::SizeFor
static int SizeFor(const NumberOfEntries &small)
Definition: objects.h:2755
v8::internal::RoundUp
static void RoundUp(Vector< char > buffer, int *length, int *decimal_point)
Definition: fixed-dtoa.cc:171

References v8::internal::kInt64Size, v8::internal::RoundUp(), SizeFor(), and SMALL_SECTION.

Referenced by InitExtended(), and number_of_entries().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_heap_ptr_entry()

Object * v8::internal::ConstantPoolArray::get_heap_ptr_entry ( int  index)
inline

Definition at line 2504 of file objects-inl.h.

2504  {
2505  DCHECK(map() == GetHeap()->constant_pool_array_map());
2506  DCHECK(get_type(index) == HEAP_PTR);
2507  return READ_FIELD(this, OffsetOfElementAt(index));
2508 }

References DCHECK, get_type(), v8::internal::HeapObject::GetHeap(), HEAP_PTR, v8::internal::HeapObject::map(), OffsetOfElementAt(), and READ_FIELD.

+ Here is the call graph for this function:

◆ get_int32_entry()

int32_t v8::internal::ConstantPoolArray::get_int32_entry ( int  index)
inline

Definition at line 2511 of file objects-inl.h.

2511  {
2512  DCHECK(map() == GetHeap()->constant_pool_array_map());
2513  DCHECK(get_type(index) == INT32);
2514  return READ_INT32_FIELD(this, OffsetOfElementAt(index));
2515 }
READ_INT32_FIELD
#define READ_INT32_FIELD(p, offset)
Definition: objects-inl.h:1278

References DCHECK, get_type(), v8::internal::HeapObject::GetHeap(), INT32, v8::internal::HeapObject::map(), OffsetOfElementAt(), and READ_INT32_FIELD.

+ Here is the call graph for this function:

◆ get_int64_entry()

int64_t v8::internal::ConstantPoolArray::get_int64_entry ( int  index)
inline

Definition at line 2482 of file objects-inl.h.

2482  {
2483  DCHECK(map() == GetHeap()->constant_pool_array_map());
2484  DCHECK(get_type(index) == INT64);
2485  return READ_INT64_FIELD(this, OffsetOfElementAt(index));
2486 }
READ_INT64_FIELD
#define READ_INT64_FIELD(p, offset)
Definition: objects-inl.h:1284

References DCHECK, get_type(), v8::internal::HeapObject::GetHeap(), INT64, v8::internal::HeapObject::map(), OffsetOfElementAt(), and READ_INT64_FIELD.

+ Here is the call graph for this function:

◆ get_int64_entry_as_double()

double v8::internal::ConstantPoolArray::get_int64_entry_as_double ( int  index)
inline

Definition at line 2489 of file objects-inl.h.

2489  {
2490  STATIC_ASSERT(kDoubleSize == kInt64Size);
2491  DCHECK(map() == GetHeap()->constant_pool_array_map());
2492  DCHECK(get_type(index) == INT64);
2493  return READ_DOUBLE_FIELD(this, OffsetOfElementAt(index));
2494 }
v8::internal::HeapObject::STATIC_ASSERT
STATIC_ASSERT(kMapOffset==Internals::kHeapObjectMapOffset)
v8::internal::kDoubleSize
const int kDoubleSize
Definition: globals.h:127
READ_DOUBLE_FIELD
#define READ_DOUBLE_FIELD(p, offset)
Definition: objects-inl.h:1220

References DCHECK, get_type(), v8::internal::HeapObject::GetHeap(), INT64, v8::internal::kDoubleSize, v8::internal::kInt64Size, v8::internal::HeapObject::map(), OffsetOfElementAt(), READ_DOUBLE_FIELD, and v8::internal::HeapObject::STATIC_ASSERT().

+ Here is the call graph for this function:

◆ get_type()

ConstantPoolArray::Type v8::internal::ConstantPoolArray::get_type ( int  index)
inline

Definition at line 2465 of file objects-inl.h.

2465  {
2466  LayoutSection section;
2467  if (is_extended_layout() && index >= first_extended_section_index()) {
2468  section = EXTENDED_SECTION;
2469  } else {
2470  section = SMALL_SECTION;
2471  }
2472 
2473  Type type = FIRST_TYPE;
2474  while (index > last_index(type, section)) {
2475  type = next_type(type);
2476  }
2477  DCHECK(type <= LAST_TYPE);
2478  return type;
2479 }
v8::internal::ConstantPoolArray::last_index
int last_index(Type type, LayoutSection layout_section)
Definition: objects-inl.h:2410

References DCHECK, EXTENDED_SECTION, first_extended_section_index(), FIRST_TYPE, is_extended_layout(), last_index(), LAST_TYPE, next_type(), and SMALL_SECTION.

Referenced by get_code_ptr_entry(), get_heap_ptr_entry(), get_int32_entry(), get_int64_entry(), get_int64_entry_as_double(), and set().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ get_weak_object_state()

ConstantPoolArray::WeakObjectState v8::internal::ConstantPoolArray::get_weak_object_state ( )
inline

Definition at line 2380 of file objects-inl.h.

2380  {
2381  uint32_t small_layout_2 = READ_UINT32_FIELD(this, kSmallLayout2Offset);
2382  return WeakObjectStateField::decode(small_layout_2);
2383 }

References v8::internal::BitFieldBase< T, shift, size, U >::decode(), kSmallLayout2Offset, and READ_UINT32_FIELD.

+ Here is the call graph for this function:

◆ Init()

void v8::internal::ConstantPoolArray::Init ( const NumberOfEntries &  small)
inline

Definition at line 2594 of file objects-inl.h.

2594  {
2595  uint32_t small_layout_1 =
2596  Int64CountField::encode(small.count_of(INT64)) |
2597  CodePtrCountField::encode(small.count_of(CODE_PTR)) |
2598  HeapPtrCountField::encode(small.count_of(HEAP_PTR)) |
2599  IsExtendedField::encode(false);
2600  uint32_t small_layout_2 =
2601  Int32CountField::encode(small.count_of(INT32)) |
2602  TotalCountField::encode(small.total_count()) |
2603  WeakObjectStateField::encode(NO_WEAK_OBJECTS);
2604  WRITE_UINT32_FIELD(this, kSmallLayout1Offset, small_layout_1);
2605  WRITE_UINT32_FIELD(this, kSmallLayout2Offset, small_layout_2);
2606  if (kHeaderSize != kFirstEntryOffset) {
2607  DCHECK(kFirstEntryOffset - kHeaderSize == kInt32Size);
2608  WRITE_UINT32_FIELD(this, kHeaderSize, 0); // Zero out header padding.
2609  }
2610 }
v8::internal::BitFieldBase::encode
static U encode(T value)
Definition: utils.h:217
v8::internal::ConstantPoolArray::kFirstEntryOffset
static const int kFirstEntryOffset
Definition: objects.h:2827
v8::internal::ConstantPoolArray::kHeaderSize
static const int kHeaderSize
Definition: objects.h:2826
v8::internal::ConstantPoolArray::kSmallLayout1Offset
static const int kSmallLayout1Offset
Definition: objects.h:2824
WRITE_UINT32_FIELD
#define WRITE_UINT32_FIELD(p, offset, value)
Definition: objects-inl.h:1275

References CODE_PTR, DCHECK, v8::internal::BitFieldBase< T, shift, size, U >::encode(), HEAP_PTR, INT32, INT64, kFirstEntryOffset, kHeaderSize, v8::internal::kInt32Size, kSmallLayout1Offset, kSmallLayout2Offset, NO_WEAK_OBJECTS, and WRITE_UINT32_FIELD.

Referenced by v8::internal::Heap::AllocateConstantPoolArray(), and InitExtended().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ InitExtended()

void v8::internal::ConstantPoolArray::InitExtended ( const NumberOfEntries &  small,
const NumberOfEntries &  extended 
)
inline

Definition at line 2613 of file objects-inl.h.

2614  {
2615  // Initialize small layout fields first.
2616  Init(small);
2617 
2618  // Set is_extended_layout field.
2619  uint32_t small_layout_1 = READ_UINT32_FIELD(this, kSmallLayout1Offset);
2620  small_layout_1 = IsExtendedField::update(small_layout_1, true);
2621  WRITE_INT32_FIELD(this, kSmallLayout1Offset, small_layout_1);
2622 
2623  // Initialize the extended layout fields.
2624  int extended_header_offset = get_extended_section_header_offset();
2625  WRITE_INT_FIELD(this, extended_header_offset + kExtendedInt64CountOffset,
2626  extended.count_of(INT64));
2627  WRITE_INT_FIELD(this, extended_header_offset + kExtendedCodePtrCountOffset,
2628  extended.count_of(CODE_PTR));
2629  WRITE_INT_FIELD(this, extended_header_offset + kExtendedHeapPtrCountOffset,
2630  extended.count_of(HEAP_PTR));
2631  WRITE_INT_FIELD(this, extended_header_offset + kExtendedInt32CountOffset,
2632  extended.count_of(INT32));
2633 }
v8::internal::BitFieldBase::update
static U update(U previous, T value)
Definition: utils.h:223
v8::internal::ConstantPoolArray::kExtendedInt64CountOffset
static const int kExtendedInt64CountOffset
Definition: objects.h:2845
v8::internal::ConstantPoolArray::kExtendedInt32CountOffset
static const int kExtendedInt32CountOffset
Definition: objects.h:2850
v8::internal::ConstantPoolArray::kExtendedCodePtrCountOffset
static const int kExtendedCodePtrCountOffset
Definition: objects.h:2846
v8::internal::ConstantPoolArray::Init
void Init(const NumberOfEntries &small)
Definition: objects-inl.h:2594
v8::internal::ConstantPoolArray::kExtendedHeapPtrCountOffset
static const int kExtendedHeapPtrCountOffset
Definition: objects.h:2848
WRITE_INT_FIELD
#define WRITE_INT_FIELD(p, offset, value)
Definition: objects-inl.h:1263
WRITE_INT32_FIELD
#define WRITE_INT32_FIELD(p, offset, value)
Definition: objects-inl.h:1281

References CODE_PTR, get_extended_section_header_offset(), HEAP_PTR, Init(), INT32, INT64, kExtendedCodePtrCountOffset, kExtendedHeapPtrCountOffset, kExtendedInt32CountOffset, kExtendedInt64CountOffset, kSmallLayout1Offset, READ_UINT32_FIELD, v8::internal::BitFieldBase< T, shift, size, U >::update(), WRITE_INT32_FIELD, and WRITE_INT_FIELD.

Referenced by v8::internal::Heap::AllocateExtendedConstantPoolArray().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ is_extended_layout()

bool v8::internal::ConstantPoolArray::is_extended_layout ( )
inline

Definition at line 2357 of file objects-inl.h.

2357  {
2358  uint32_t small_layout_1 = READ_UINT32_FIELD(this, kSmallLayout1Offset);
2359  return IsExtendedField::decode(small_layout_1);
2360 }

References v8::internal::BitFieldBase< T, shift, size, U >::decode(), kSmallLayout1Offset, and READ_UINT32_FIELD.

Referenced by v8::internal::Heap::CopyConstantPoolArrayWithMap(), final_section(), first_extended_section_index(), first_index(), get_type(), length(), number_of_entries(), offset_is_type(), and size().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ last_index()

int v8::internal::ConstantPoolArray::last_index ( Type  type,
LayoutSection  layout_section 
)
inline

Definition at line 2410 of file objects-inl.h.

2410  {
2411  return first_index(type, section) + number_of_entries(type, section) - 1;
2412 }

References first_index(), and number_of_entries().

Referenced by get_type(), and offset_is_type().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ length()

int v8::internal::ConstantPoolArray::length ( )
inline

Definition at line 2647 of file objects-inl.h.

2647  {
2648  uint32_t small_layout_2 = READ_UINT32_FIELD(this, kSmallLayout2Offset);
2649  int length = TotalCountField::decode(small_layout_2);
2650  if (is_extended_layout()) {
2651  length += number_of_entries(INT64, EXTENDED_SECTION) +
2652  number_of_entries(CODE_PTR, EXTENDED_SECTION) +
2653  number_of_entries(HEAP_PTR, EXTENDED_SECTION) +
2654  number_of_entries(INT32, EXTENDED_SECTION);
2655  }
2656  return length;
2657 }

References CODE_PTR, v8::internal::BitFieldBase< T, shift, size, U >::decode(), EXTENDED_SECTION, HEAP_PTR, INT32, INT64, is_extended_layout(), kSmallLayout2Offset, number_of_entries(), and READ_UINT32_FIELD.

Referenced by v8::internal::Heap::CopyConstantPoolArray().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ MaxInt64Offset()

static int v8::internal::ConstantPoolArray::MaxInt64Offset ( int  number_of_int64)
inlinestatic

Definition at line 2751 of file objects.h.

2751  {
2752  return kFirstEntryOffset + (number_of_int64 * kInt64Size);
2753  }

References v8::internal::kInt64Size.

◆ next_type()

static Type v8::internal::ConstantPoolArray::next_type ( Type  type)
inlinestaticprivate

Definition at line 2865 of file objects.h.

2865  {
2866  DCHECK(type >= FIRST_TYPE && type < NUMBER_OF_TYPES);
2867  int type_int = static_cast<int>(type);
2868  return static_cast<Type>(++type_int);
2869  }

References DCHECK, and v8::internal::FIRST_TYPE.

Referenced by first_index(), and get_type().

+ Here is the caller graph for this function:

◆ number_of_entries()

int v8::internal::ConstantPoolArray::number_of_entries ( Type  type,
LayoutSection  layout_section 
)
inline

Definition at line 2415 of file objects-inl.h.

2415  {
2416  if (section == SMALL_SECTION) {
2417  uint32_t small_layout_1 = READ_UINT32_FIELD(this, kSmallLayout1Offset);
2418  uint32_t small_layout_2 = READ_UINT32_FIELD(this, kSmallLayout2Offset);
2419  switch (type) {
2420  case INT64:
2421  return Int64CountField::decode(small_layout_1);
2422  case CODE_PTR:
2423  return CodePtrCountField::decode(small_layout_1);
2424  case HEAP_PTR:
2425  return HeapPtrCountField::decode(small_layout_1);
2426  case INT32:
2427  return Int32CountField::decode(small_layout_2);
2428  default:
2429  UNREACHABLE();
2430  return 0;
2431  }
2432  } else {
2433  DCHECK(section == EXTENDED_SECTION && is_extended_layout());
2434  int offset = get_extended_section_header_offset();
2435  switch (type) {
2436  case INT64:
2437  offset += kExtendedInt64CountOffset;
2438  break;
2439  case CODE_PTR:
2440  offset += kExtendedCodePtrCountOffset;
2441  break;
2442  case HEAP_PTR:
2443  offset += kExtendedHeapPtrCountOffset;
2444  break;
2445  case INT32:
2446  offset += kExtendedInt32CountOffset;
2447  break;
2448  default:
2449  UNREACHABLE();
2450  }
2451  return READ_INT_FIELD(this, offset);
2452  }
2453 }
READ_INT_FIELD
#define READ_INT_FIELD(p, offset)
Definition: objects-inl.h:1260

References CODE_PTR, DCHECK, v8::internal::BitFieldBase< T, shift, size, U >::decode(), EXTENDED_SECTION, get_extended_section_header_offset(), HEAP_PTR, INT32, INT64, is_extended_layout(), kExtendedCodePtrCountOffset, kExtendedHeapPtrCountOffset, kExtendedInt32CountOffset, kExtendedInt64CountOffset, kSmallLayout1Offset, kSmallLayout2Offset, READ_INT_FIELD, READ_UINT32_FIELD, SMALL_SECTION, and UNREACHABLE.

Referenced by ClearPtrEntries(), first_index(), last_index(), length(), and v8::internal::ConstantPoolArray::BASE_EMBEDDED::NumberOfEntries().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ offset_is_type()

bool v8::internal::ConstantPoolArray::offset_is_type ( int  offset,
Type  type 
)
inline

Definition at line 2456 of file objects-inl.h.

2456  {
2457  return (offset >= OffsetOfElementAt(first_index(type, SMALL_SECTION)) &&
2458  offset <= OffsetOfElementAt(last_index(type, SMALL_SECTION))) ||
2459  (is_extended_layout() &&
2460  offset >= OffsetOfElementAt(first_index(type, EXTENDED_SECTION)) &&
2461  offset <= OffsetOfElementAt(last_index(type, EXTENDED_SECTION)));
2462 }

References EXTENDED_SECTION, first_index(), is_extended_layout(), last_index(), OffsetOfElementAt(), and SMALL_SECTION.

Referenced by set_at_offset().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ OffsetOfElementAt()

int v8::internal::ConstantPoolArray::OffsetOfElementAt ( int  index)
inline

Definition at line 2792 of file objects.h.

2792  {
2793  int offset;
2794  LayoutSection section;
2795  if (is_extended_layout() && index >= first_extended_section_index()) {
2796  section = EXTENDED_SECTION;
2797  offset = get_extended_section_header_offset() + kExtendedFirstOffset;
2798  } else {
2799  section = SMALL_SECTION;
2800  offset = kFirstEntryOffset;
2801  }
2802 
2803  // Add offsets for the preceding type sections.
2804  DCHECK(index <= last_index(LAST_TYPE, section));
2805  for (Type type = FIRST_TYPE; index > last_index(type, section);
2806  type = next_type(type)) {
2807  offset += entry_size(type) * number_of_entries(type, section);
2808  }
2809 
2810  // Add offset for the index in it's type.
2811  Type type = get_type(index);
2812  offset += entry_size(type) * (index - first_index(type, section));
2813  return offset;
2814  }
v8::internal::ConstantPoolArray::kExtendedFirstOffset
static const int kExtendedFirstOffset
Definition: objects.h:2852
v8::internal::ConstantPoolArray::entry_size
static int entry_size(Type type)
Definition: objects.h:2776

References DCHECK, v8::internal::FIRST_TYPE, and v8::internal::LAST_TYPE.

Referenced by ClearPtrEntries(), get_code_ptr_entry(), get_heap_ptr_entry(), get_int32_entry(), get_int64_entry(), get_int64_entry_as_double(), v8::internal::MarkCompactCollector::MigrateObject(), offset_is_type(), and set().

+ Here is the caller graph for this function:

◆ RawFieldOfElementAt()

Object** v8::internal::ConstantPoolArray::RawFieldOfElementAt ( int  index)
inline

Definition at line 2819 of file objects.h.

2819  {
2820  return HeapObject::RawField(this, OffsetOfElementAt(index));
2821  }

References v8::internal::HeapObject::RawField().

Referenced by ConstantPoolIterateBody().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ set() [1/5]

void v8::internal::ConstantPoolArray::set ( int  index,
Address  value 
)
inline

Definition at line 2533 of file objects-inl.h.

2533  {
2534  DCHECK(map() == GetHeap()->constant_pool_array_map());
2535  DCHECK(get_type(index) == CODE_PTR);
2536  WRITE_FIELD(this, OffsetOfElementAt(index), reinterpret_cast<Object*>(value));
2537 }
v8::internal::Object
kSerializedDataOffset Object
Definition: objects-inl.h:5322
WRITE_FIELD
#define WRITE_FIELD(p, offset, value)
Definition: objects-inl.h:1190

References CODE_PTR, DCHECK, get_type(), v8::internal::HeapObject::GetHeap(), v8::internal::HeapObject::map(), OffsetOfElementAt(), and WRITE_FIELD.

+ Here is the call graph for this function:

◆ set() [2/5]

void v8::internal::ConstantPoolArray::set ( int  index,
double  value 
)
inline

Definition at line 2525 of file objects-inl.h.

2525  {
2526  STATIC_ASSERT(kDoubleSize == kInt64Size);
2527  DCHECK(map() == GetHeap()->constant_pool_array_map());
2528  DCHECK(get_type(index) == INT64);
2529  WRITE_DOUBLE_FIELD(this, OffsetOfElementAt(index), value);
2530 }
WRITE_DOUBLE_FIELD
#define WRITE_DOUBLE_FIELD(p, offset, value)
Definition: objects-inl.h:1240

References DCHECK, get_type(), v8::internal::HeapObject::GetHeap(), INT64, v8::internal::kDoubleSize, v8::internal::kInt64Size, v8::internal::HeapObject::map(), OffsetOfElementAt(), v8::internal::HeapObject::STATIC_ASSERT(), and WRITE_DOUBLE_FIELD.

+ Here is the call graph for this function:

◆ set() [3/5]

void v8::internal::ConstantPoolArray::set ( int  index,
int32_t  value 
)
inline

Definition at line 2549 of file objects-inl.h.

2549  {
2550  DCHECK(map() == GetHeap()->constant_pool_array_map());
2551  DCHECK(get_type(index) == INT32);
2552  WRITE_INT32_FIELD(this, OffsetOfElementAt(index), value);
2553 }

References DCHECK, get_type(), v8::internal::HeapObject::GetHeap(), INT32, v8::internal::HeapObject::map(), OffsetOfElementAt(), and WRITE_INT32_FIELD.

+ Here is the call graph for this function:

◆ set() [4/5]

void v8::internal::ConstantPoolArray::set ( int  index,
int64_t  value 
)
inline

Definition at line 2518 of file objects-inl.h.

2518  {
2519  DCHECK(map() == GetHeap()->constant_pool_array_map());
2520  DCHECK(get_type(index) == INT64);
2521  WRITE_INT64_FIELD(this, OffsetOfElementAt(index), value);
2522 }
WRITE_INT64_FIELD
#define WRITE_INT64_FIELD(p, offset, value)
Definition: objects-inl.h:1287

References DCHECK, get_type(), v8::internal::HeapObject::GetHeap(), INT64, v8::internal::HeapObject::map(), OffsetOfElementAt(), and WRITE_INT64_FIELD.

+ Here is the call graph for this function:

◆ set() [5/5]

void v8::internal::ConstantPoolArray::set ( int  index,
Object *  value 
)
inline

Definition at line 2540 of file objects-inl.h.

2540  {
2541  DCHECK(map() == GetHeap()->constant_pool_array_map());
2542  DCHECK(!GetHeap()->InNewSpace(value));
2543  DCHECK(get_type(index) == HEAP_PTR);
2544  WRITE_FIELD(this, OffsetOfElementAt(index), value);
2545  WRITE_BARRIER(GetHeap(), this, OffsetOfElementAt(index), value);
2546 }
WRITE_BARRIER
#define WRITE_BARRIER(heap, object, offset, value)
Definition: objects-inl.h:1203

References DCHECK, get_type(), v8::internal::HeapObject::GetHeap(), HEAP_PTR, v8::internal::HeapObject::map(), OffsetOfElementAt(), WRITE_BARRIER, and WRITE_FIELD.

+ Here is the call graph for this function:

◆ set_at_offset() [1/5]

void v8::internal::ConstantPoolArray::set_at_offset ( int  offset,
Address  value 
)
inline

Definition at line 2577 of file objects-inl.h.

2577  {
2578  DCHECK(map() == GetHeap()->constant_pool_array_map());
2579  DCHECK(offset_is_type(offset, CODE_PTR));
2580  WRITE_FIELD(this, offset, reinterpret_cast<Object*>(value));
2581  WRITE_BARRIER(GetHeap(), this, offset, reinterpret_cast<Object*>(value));
2582 }
v8::internal::ConstantPoolArray::offset_is_type
bool offset_is_type(int offset, Type type)
Definition: objects-inl.h:2456

References CODE_PTR, DCHECK, v8::internal::HeapObject::GetHeap(), v8::internal::HeapObject::map(), offset_is_type(), WRITE_BARRIER, and WRITE_FIELD.

+ Here is the call graph for this function:

◆ set_at_offset() [2/5]

void v8::internal::ConstantPoolArray::set_at_offset ( int  offset,
double  value 
)
inline

Definition at line 2570 of file objects-inl.h.

2570  {
2571  DCHECK(map() == GetHeap()->constant_pool_array_map());
2572  DCHECK(offset_is_type(offset, INT64));
2573  WRITE_DOUBLE_FIELD(this, offset, value);
2574 }

References DCHECK, v8::internal::HeapObject::GetHeap(), INT64, v8::internal::HeapObject::map(), offset_is_type(), and WRITE_DOUBLE_FIELD.

+ Here is the call graph for this function:

◆ set_at_offset() [3/5]

void v8::internal::ConstantPoolArray::set_at_offset ( int  offset,
int32_t  value 
)
inline

Definition at line 2556 of file objects-inl.h.

2556  {
2557  DCHECK(map() == GetHeap()->constant_pool_array_map());
2558  DCHECK(offset_is_type(offset, INT32));
2559  WRITE_INT32_FIELD(this, offset, value);
2560 }

References DCHECK, v8::internal::HeapObject::GetHeap(), INT32, v8::internal::HeapObject::map(), offset_is_type(), and WRITE_INT32_FIELD.

+ Here is the call graph for this function:

◆ set_at_offset() [4/5]

void v8::internal::ConstantPoolArray::set_at_offset ( int  offset,
int64_t  value 
)
inline

Definition at line 2563 of file objects-inl.h.

2563  {
2564  DCHECK(map() == GetHeap()->constant_pool_array_map());
2565  DCHECK(offset_is_type(offset, INT64));
2566  WRITE_INT64_FIELD(this, offset, value);
2567 }

References DCHECK, v8::internal::HeapObject::GetHeap(), INT64, v8::internal::HeapObject::map(), offset_is_type(), and WRITE_INT64_FIELD.

+ Here is the call graph for this function:

◆ set_at_offset() [5/5]

void v8::internal::ConstantPoolArray::set_at_offset ( int  offset,
Object *  value 
)
inline

Definition at line 2585 of file objects-inl.h.

2585  {
2586  DCHECK(map() == GetHeap()->constant_pool_array_map());
2587  DCHECK(!GetHeap()->InNewSpace(value));
2588  DCHECK(offset_is_type(offset, HEAP_PTR));
2589  WRITE_FIELD(this, offset, value);
2590  WRITE_BARRIER(GetHeap(), this, offset, value);
2591 }

References DCHECK, v8::internal::HeapObject::GetHeap(), HEAP_PTR, v8::internal::HeapObject::map(), offset_is_type(), WRITE_BARRIER, and WRITE_FIELD.

+ Here is the call graph for this function:

◆ set_weak_object_state()

void v8::internal::ConstantPoolArray::set_weak_object_state ( ConstantPoolArray::WeakObjectState  state)
inline

Definition at line 2386 of file objects-inl.h.

2387  {
2388  uint32_t small_layout_2 = READ_UINT32_FIELD(this, kSmallLayout2Offset);
2389  small_layout_2 = WeakObjectStateField::update(small_layout_2, state);
2390  WRITE_INT32_FIELD(this, kSmallLayout2Offset, small_layout_2);
2391 }

References kSmallLayout2Offset, READ_UINT32_FIELD, v8::internal::BitFieldBase< T, shift, size, U >::update(), and WRITE_INT32_FIELD.

+ Here is the call graph for this function:

◆ size()

int v8::internal::ConstantPoolArray::size ( )
inline

Definition at line 2636 of file objects-inl.h.

2636  {
2637  NumberOfEntries small(this, SMALL_SECTION);
2638  if (!is_extended_layout()) {
2639  return SizeFor(small);
2640  } else {
2641  NumberOfEntries extended(this, EXTENDED_SECTION);
2642  return SizeForExtended(small, extended);
2643  }
2644 }
v8::internal::ConstantPoolArray::SizeForExtended
static int SizeForExtended(const NumberOfEntries &small, const NumberOfEntries &extended)
Definition: objects.h:2764

References EXTENDED_SECTION, is_extended_layout(), SizeFor(), SizeForExtended(), and SMALL_SECTION.

Referenced by v8::internal::Heap::CopyConstantPoolArrayWithMap().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ SizeFor()

static int v8::internal::ConstantPoolArray::SizeFor ( const NumberOfEntries &  small)
inlinestatic

Definition at line 2755 of file objects.h.

2755  {
2756  int size = kFirstEntryOffset +
2757  (small.count_of(INT64) * kInt64Size) +
2758  (small.count_of(CODE_PTR) * kPointerSize) +
2759  (small.count_of(HEAP_PTR) * kPointerSize) +
2760  (small.count_of(INT32) * kInt32Size);
2761  return RoundUp(size, kPointerSize);
2762  }

References v8::internal::kInt32Size, v8::internal::kInt64Size, v8::internal::kPointerSize, v8::internal::RoundUp(), and size.

Referenced by v8::internal::Heap::AllocateConstantPoolArray(), v8::internal::Heap::AllocateEmptyConstantPoolArray(), get_extended_section_header_offset(), and size().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ SizeForExtended()

static int v8::internal::ConstantPoolArray::SizeForExtended ( const NumberOfEntries &  small,
const NumberOfEntries &  extended 
)
inlinestatic

Definition at line 2764 of file objects.h.

2765  {
2766  int size = SizeFor(small);
2767  size = RoundUp(size, kInt64Size); // Align extended header to 64 bits.
2768  size += kExtendedFirstOffset +
2769  (extended.count_of(INT64) * kInt64Size) +
2770  (extended.count_of(CODE_PTR) * kPointerSize) +
2771  (extended.count_of(HEAP_PTR) * kPointerSize) +
2772  (extended.count_of(INT32) * kInt32Size);
2773  return RoundUp(size, kPointerSize);
2774  }

References v8::internal::kInt32Size, v8::internal::kInt64Size, v8::internal::kPointerSize, v8::internal::RoundUp(), and size.

Referenced by v8::internal::Heap::AllocateExtendedConstantPoolArray(), and size().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

Member Data Documentation

◆ kExtendedCodePtrCountOffset

const int v8::internal::ConstantPoolArray::kExtendedCodePtrCountOffset
static
Initial value:
=
kExtendedInt64CountOffset + kPointerSize

Definition at line 2846 of file objects.h.

Referenced by InitExtended(), and number_of_entries().

◆ kExtendedFirstOffset

const int v8::internal::ConstantPoolArray::kExtendedFirstOffset
static
Initial value:
=
kExtendedInt32CountOffset + kPointerSize

Definition at line 2852 of file objects.h.

◆ kExtendedHeapPtrCountOffset

const int v8::internal::ConstantPoolArray::kExtendedHeapPtrCountOffset
static
Initial value:
=
kExtendedCodePtrCountOffset + kPointerSize

Definition at line 2848 of file objects.h.

Referenced by InitExtended(), and number_of_entries().

◆ kExtendedInt32CountOffset

const int v8::internal::ConstantPoolArray::kExtendedInt32CountOffset
static
Initial value:
=
kExtendedHeapPtrCountOffset + kPointerSize

Definition at line 2850 of file objects.h.

Referenced by InitExtended(), and number_of_entries().

◆ kExtendedInt64CountOffset

const int v8::internal::ConstantPoolArray::kExtendedInt64CountOffset = 0
static

Definition at line 2845 of file objects.h.

Referenced by InitExtended(), and number_of_entries().

◆ kFirstEntryOffset

const int v8::internal::ConstantPoolArray::kFirstEntryOffset = ROUND_UP(kHeaderSize, kInt64Size)
static

Definition at line 2827 of file objects.h.

Referenced by v8::internal::Heap::CopyConstantPoolArrayWithMap(), and Init().

◆ kHeaderSize

const int v8::internal::ConstantPoolArray::kHeaderSize = kSmallLayout2Offset + kInt32Size
static

Definition at line 2826 of file objects.h.

Referenced by Init().

◆ kMaxSmallEntriesPerType

const int v8::internal::ConstantPoolArray::kMaxSmallEntriesPerType = (1 << kSmallLayoutCountBits) - 1
static

Definition at line 2830 of file objects.h.

Referenced by v8::internal::Heap::AllocateConstantPoolArray(), and v8::internal::Heap::AllocateExtendedConstantPoolArray().

◆ kSmallLayout1Offset

const int v8::internal::ConstantPoolArray::kSmallLayout1Offset = HeapObject::kHeaderSize
static

Definition at line 2824 of file objects.h.

Referenced by Init(), InitExtended(), is_extended_layout(), and number_of_entries().

◆ kSmallLayout2Offset

const int v8::internal::ConstantPoolArray::kSmallLayout2Offset = kSmallLayout1Offset + kInt32Size
static

Definition at line 2825 of file objects.h.

Referenced by first_extended_section_index(), get_weak_object_state(), Init(), length(), number_of_entries(), and set_weak_object_state().

◆ kSmallLayoutCountBits

const int v8::internal::ConstantPoolArray::kSmallLayoutCountBits = 10
static

Definition at line 2829 of file objects.h.

The documentation for this class was generated from the following files: