v8::internal::CodeCache Class Reference

#include <objects.h>

Inheritance diagram for v8::internal::CodeCache:

Collaboration diagram for v8::internal::CodeCache:

Public Member Functions
Object *	Lookup (Name *name, Code::Flags flags)
int	GetIndex (Object *name, Code *code)
void	RemoveByIndex (Object *name, Code *code, int index)
Public Member Functions inherited from v8::internal::Struct
void	InitializeBody (int object_size)
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 void	Update (Handle< CodeCache > cache, Handle< Name > name, Handle< Code > code)
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	kDefaultCacheOffset = HeapObject::kHeaderSize
static const int	kNormalTypeCacheOffset
static const int	kSize = kNormalTypeCacheOffset + kPointerSize
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
Object *	LookupDefaultCache (Name *name, Code::Flags flags)
Object *	LookupNormalTypeCache (Name *name, Code::Flags flags)
	DISALLOW_IMPLICIT_CONSTRUCTORS (CodeCache)

Static Private Member Functions
static void	UpdateDefaultCache (Handle< CodeCache > code_cache, Handle< Name > name, Handle< Code > code)
static void	UpdateNormalTypeCache (Handle< CodeCache > code_cache, Handle< Name > name, Handle< Code > code)

Static Private Attributes
static const int	kCodeCacheEntrySize = 2
static const int	kCodeCacheEntryNameOffset = 0
static const int	kCodeCacheEntryCodeOffset = 1

Additional Inherited Members
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 }
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 7891 of file objects.h.

Member Function Documentation

DISALLOW_IMPLICIT_CONSTRUCTORS()

v8::internal::CodeCache::DISALLOW_IMPLICIT_CONSTRUCTORS ( CodeCache  )

private

GetIndex()

int v8::internal::CodeCache::GetIndex	(	Object *	name,
		Code *	code
	)

Definition at line 7409 of file objects.cc.

                                                {
  if (code->type() == Code::NORMAL) {
    if (normal_type_cache()->IsUndefined()) return -1;
    CodeCacheHashTable* cache = CodeCacheHashTable::cast(normal_type_cache());
    return cache->GetIndex(Name::cast(name), code->flags());
  }
 
  FixedArray* array = default_cache();
  int len = array->length();
  for (int i = 0; i < len; i += kCodeCacheEntrySize) {
    if (array->get(i + kCodeCacheEntryCodeOffset) == code) return i + 1;
  }
  return -1;
}

References v8::internal::Code::flags(), v8::internal::FixedArray::get(), v8::internal::CodeCacheHashTable::GetIndex(), v8::internal::FixedArrayBase::length(), name, v8::internal::Code::NORMAL, and v8::internal::Code::type().

Here is the call graph for this function:

Lookup()

Object * v8::internal::CodeCache::Lookup	(	Name *	name,
		Code::Flags	flags
	)

Definition at line 7370 of file objects.cc.

                                                     {
  Object* result = LookupDefaultCache(name, Code::RemoveTypeFromFlags(flags));
  if (result->IsCode()) {
    if (Code::cast(result)->flags() == flags) return result;
    return GetHeap()->undefined_value();
  }
  return LookupNormalTypeCache(name, flags);
}

References v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::HeapObject::GetHeap(), name, and v8::internal::Code::RemoveTypeFromFlags().

Here is the call graph for this function:

LookupDefaultCache()

Object * v8::internal::CodeCache::LookupDefaultCache ( Name *  name, Code::Flags  flags  )

private

Definition at line 7380 of file objects.cc.

                                                                 {
  FixedArray* cache = default_cache();
  int length = cache->length();
  for (int i = 0; i < length; i += kCodeCacheEntrySize) {
    Object* key = cache->get(i + kCodeCacheEntryNameOffset);
    // Skip deleted elements.
    if (key->IsNull()) continue;
    if (key->IsUndefined()) return key;
    if (name->Equals(Name::cast(key))) {
      Code* code = Code::cast(cache->get(i + kCodeCacheEntryCodeOffset));
      if (Code::RemoveTypeFromFlags(code->flags()) == flags) {
        return code;
      }
    }
  }
  return GetHeap()->undefined_value();
}

References v8::internal::Code::flags(), v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::FixedArray::get(), v8::internal::HeapObject::GetHeap(), v8::internal::FixedArrayBase::length(), name, and v8::internal::Code::RemoveTypeFromFlags().

Here is the call graph for this function:

LookupNormalTypeCache()

Object * v8::internal::CodeCache::LookupNormalTypeCache ( Name *  name, Code::Flags  flags  )

private

Definition at line 7399 of file objects.cc.

                                                                    {
  if (!normal_type_cache()->IsUndefined()) {
    CodeCacheHashTable* cache = CodeCacheHashTable::cast(normal_type_cache());
    return cache->Lookup(name, flags);
  } else {
    return GetHeap()->undefined_value();
  }
}

References v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::HeapObject::GetHeap(), v8::internal::CodeCacheHashTable::Lookup(), and name.

Here is the call graph for this function:

RemoveByIndex()

void v8::internal::CodeCache::RemoveByIndex	(	Object *	name,
		Code *	code,
		int	index
	)

Definition at line 7425 of file objects.cc.

                                                                 {
  if (code->type() == Code::NORMAL) {
    DCHECK(!normal_type_cache()->IsUndefined());
    CodeCacheHashTable* cache = CodeCacheHashTable::cast(normal_type_cache());
    DCHECK(cache->GetIndex(Name::cast(name), code->flags()) == index);
    cache->RemoveByIndex(index);
  } else {
    FixedArray* array = default_cache();
    DCHECK(array->length() >= index && array->get(index)->IsCode());
    // Use null instead of undefined for deleted elements to distinguish
    // deleted elements from unused elements.  This distinction is used
    // when looking up in the cache and when updating the cache.
    DCHECK_EQ(1, kCodeCacheEntryCodeOffset - kCodeCacheEntryNameOffset);
    array->set_null(index - 1);  // Name.
    array->set_null(index);  // Code.
  }
}

References DCHECK, DCHECK_EQ, v8::internal::Code::flags(), v8::internal::FixedArray::get(), v8::internal::CodeCacheHashTable::GetIndex(), v8::internal::FixedArrayBase::length(), name, v8::internal::Code::NORMAL, v8::internal::CodeCacheHashTable::RemoveByIndex(), v8::internal::FixedArray::set_null(), and v8::internal::Code::type().

Here is the call graph for this function:

Update()

void v8::internal::CodeCache::Update ( Handle< CodeCache >  cache, Handle< Name >  name, Handle< Code >  code  )

static

Definition at line 7280 of file objects.cc.

                                                                        {
  // The number of monomorphic stubs for normal load/store/call IC's can grow to
  // a large number and therefore they need to go into a hash table. They are
  // used to load global properties from cells.
  if (code->type() == Code::NORMAL) {
    // Make sure that a hash table is allocated for the normal load code cache.
    if (code_cache->normal_type_cache()->IsUndefined()) {
      Handle<Object> result =
          CodeCacheHashTable::New(code_cache->GetIsolate(),
                                  CodeCacheHashTable::kInitialSize);
      code_cache->set_normal_type_cache(*result);
    }
    UpdateNormalTypeCache(code_cache, name, code);
  } else {
    DCHECK(code_cache->default_cache()->IsFixedArray());
    UpdateDefaultCache(code_cache, name, code);
  }
}

References DCHECK, v8::internal::CodeCacheHashTable::kInitialSize, name, v8::internal::HashTable< CodeCacheHashTable, CodeCacheHashTableShape, HashTableKey * >::New(), and v8::internal::Code::NORMAL.

Referenced by v8::internal::Map::UpdateCodeCache().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateDefaultCache()

void v8::internal::CodeCache::UpdateDefaultCache ( Handle< CodeCache >  code_cache, Handle< Name >  name, Handle< Code >  code  )

staticprivate

Definition at line 7301 of file objects.cc.

                                                                        {
  // When updating the default code cache we disregard the type encoded in the
  // flags. This allows call constant stubs to overwrite call field
  // stubs, etc.
  Code::Flags flags = Code::RemoveTypeFromFlags(code->flags());
 
  // First check whether we can update existing code cache without
  // extending it.
  Handle<FixedArray> cache = handle(code_cache->default_cache());
  int length = cache->length();
  {
    DisallowHeapAllocation no_alloc;
    int deleted_index = -1;
    for (int i = 0; i < length; i += kCodeCacheEntrySize) {
      Object* key = cache->get(i);
      if (key->IsNull()) {
        if (deleted_index < 0) deleted_index = i;
        continue;
      }
      if (key->IsUndefined()) {
        if (deleted_index >= 0) i = deleted_index;
        cache->set(i + kCodeCacheEntryNameOffset, *name);
        cache->set(i + kCodeCacheEntryCodeOffset, *code);
        return;
      }
      if (name->Equals(Name::cast(key))) {
        Code::Flags found =
            Code::cast(cache->get(i + kCodeCacheEntryCodeOffset))->flags();
        if (Code::RemoveTypeFromFlags(found) == flags) {
          cache->set(i + kCodeCacheEntryCodeOffset, *code);
          return;
        }
      }
    }
 
    // Reached the end of the code cache.  If there were deleted
    // elements, reuse the space for the first of them.
    if (deleted_index >= 0) {
      cache->set(deleted_index + kCodeCacheEntryNameOffset, *name);
      cache->set(deleted_index + kCodeCacheEntryCodeOffset, *code);
      return;
    }
  }
 
  // Extend the code cache with some new entries (at least one). Must be a
  // multiple of the entry size.
  int new_length = length + ((length >> 1)) + kCodeCacheEntrySize;
  new_length = new_length - new_length % kCodeCacheEntrySize;
  DCHECK((new_length % kCodeCacheEntrySize) == 0);
  cache = FixedArray::CopySize(cache, new_length);
 
  // Add the (name, code) pair to the new cache.
  cache->set(length + kCodeCacheEntryNameOffset, *name);
  cache->set(length + kCodeCacheEntryCodeOffset, *code);
  code_cache->set_default_cache(*cache);
}

References v8::internal::FixedArray::CopySize(), DCHECK, v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::handle(), name, and v8::internal::Code::RemoveTypeFromFlags().

Here is the call graph for this function:

UpdateNormalTypeCache()

void v8::internal::CodeCache::UpdateNormalTypeCache ( Handle< CodeCache >  code_cache, Handle< Name >  name, Handle< Code >  code  )

staticprivate

Definition at line 7360 of file objects.cc.

                                                                        {
  // Adding a new entry can cause a new cache to be allocated.
  Handle<CodeCacheHashTable> cache(
      CodeCacheHashTable::cast(code_cache->normal_type_cache()));
  Handle<Object> new_cache = CodeCacheHashTable::Put(cache, name, code);
  code_cache->set_normal_type_cache(*new_cache);
}

References name, and v8::internal::CodeCacheHashTable::Put().

Here is the call graph for this function:

Member Data Documentation

kCodeCacheEntryCodeOffset

const int v8::internal::CodeCache::kCodeCacheEntryCodeOffset = 1

staticprivate

Definition at line 7936 of file objects.h.

kCodeCacheEntryNameOffset

const int v8::internal::CodeCache::kCodeCacheEntryNameOffset = 0

staticprivate

Definition at line 7935 of file objects.h.

kCodeCacheEntrySize

const int v8::internal::CodeCache::kCodeCacheEntrySize = 2

staticprivate

Definition at line 7934 of file objects.h.

kDefaultCacheOffset

const int v8::internal::CodeCache::kDefaultCacheOffset = HeapObject::kHeaderSize

static

Definition at line 7919 of file objects.h.

Referenced by v8::internal::V8HeapExplorer::ExtractCodeCacheReferences().

kNormalTypeCacheOffset

const int v8::internal::CodeCache::kNormalTypeCacheOffset

static

Initial value:

=
      kDefaultCacheOffset + kPointerSize

Definition at line 7920 of file objects.h.

Referenced by v8::internal::V8HeapExplorer::ExtractCodeCacheReferences().

kSize

const int v8::internal::CodeCache::kSize = kNormalTypeCacheOffset + kPointerSize

static

Definition at line 7922 of file objects.h.

---

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

• /mnt/V8SourceCode/src/objects.h
• /mnt/V8SourceCode/src/objects.cc