blob: c3457563a653265cb10d6398366960fb50808e11 [file] [log] [blame]
// Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/ic/stub-cache.h"
#include "src/ast/ast.h"
#include "src/base/bits.h"
#include "src/heap/heap-inl.h" // For InYoungGeneration().
#include "src/ic/ic-inl.h"
#include "src/logging/counters.h"
#include "src/objects/tagged-value-inl.h"
namespace v8 {
namespace internal {
StubCache::StubCache(Isolate* isolate) : isolate_(isolate) {
// Ensure the nullptr (aka Smi::zero()) which StubCache::Get() returns
// when the entry is not found is not considered as a handler.
DCHECK(!IC::IsHandler(MaybeObject()));
}
void StubCache::Initialize() {
DCHECK(base::bits::IsPowerOfTwo(kPrimaryTableSize));
DCHECK(base::bits::IsPowerOfTwo(kSecondaryTableSize));
Clear();
}
// Hash algorithm for the primary table. This algorithm is replicated in
// the AccessorAssembler. Returns an index into the table that
// is scaled by 1 << kCacheIndexShift.
int StubCache::PrimaryOffset(Name name, Map map) {
// Compute the hash of the name (use entire hash field).
uint32_t field = name.RawHash();
DCHECK(Name::IsHashFieldComputed(field));
// Using only the low bits in 64-bit mode is unlikely to increase the
// risk of collision even if the heap is spread over an area larger than
// 4Gb (and not at all if it isn't).
uint32_t map_low32bits =
static_cast<uint32_t>(map.ptr() ^ (map.ptr() >> kPrimaryTableBits));
// Base the offset on a simple combination of name and map.
uint32_t key = map_low32bits + field;
return key & ((kPrimaryTableSize - 1) << kCacheIndexShift);
}
// Hash algorithm for the secondary table. This algorithm is replicated in
// assembler. This hash should be sufficiently different from the primary one
// in order to avoid collisions for minified code with short names.
// Returns an index into the table that is scaled by 1 << kCacheIndexShift.
int StubCache::SecondaryOffset(Name name, Map old_map) {
uint32_t name_low32bits = static_cast<uint32_t>(name.ptr());
uint32_t map_low32bits = static_cast<uint32_t>(old_map.ptr());
uint32_t key = (map_low32bits + name_low32bits);
key = key + (key >> kSecondaryTableBits);
return key & ((kSecondaryTableSize - 1) << kCacheIndexShift);
}
int StubCache::PrimaryOffsetForTesting(Name name, Map map) {
return PrimaryOffset(name, map);
}
int StubCache::SecondaryOffsetForTesting(Name name, Map map) {
return SecondaryOffset(name, map);
}
#ifdef DEBUG
namespace {
bool CommonStubCacheChecks(StubCache* stub_cache, Name name, Map map,
MaybeObject handler) {
// Validate that the name and handler do not move on scavenge, and that we
// can use identity checks instead of structural equality checks.
DCHECK(!Heap::InYoungGeneration(name));
DCHECK(!Heap::InYoungGeneration(handler));
DCHECK(name.IsUniqueName());
if (handler->ptr() != kNullAddress) DCHECK(IC::IsHandler(handler));
return true;
}
} // namespace
#endif
void StubCache::Set(Name name, Map map, MaybeObject handler) {
DCHECK(CommonStubCacheChecks(this, name, map, handler));
// Compute the primary entry.
int primary_offset = PrimaryOffset(name, map);
Entry* primary = entry(primary_, primary_offset);
MaybeObject old_handler(
TaggedValue::ToMaybeObject(isolate(), primary->value));
// If the primary entry has useful data in it, we retire it to the
// secondary cache before overwriting it.
if (old_handler != MaybeObject::FromObject(
isolate()->builtins()->code(Builtin::kIllegal)) &&
!primary->map.IsSmi()) {
Map old_map =
Map::cast(StrongTaggedValue::ToObject(isolate(), primary->map));
Name old_name =
Name::cast(StrongTaggedValue::ToObject(isolate(), primary->key));
int secondary_offset = SecondaryOffset(old_name, old_map);
Entry* secondary = entry(secondary_, secondary_offset);
*secondary = *primary;
}
// Update primary cache.
primary->key = StrongTaggedValue(name);
primary->value = TaggedValue(handler);
primary->map = StrongTaggedValue(map);
isolate()->counters()->megamorphic_stub_cache_updates()->Increment();
}
MaybeObject StubCache::Get(Name name, Map map) {
DCHECK(CommonStubCacheChecks(this, name, map, MaybeObject()));
int primary_offset = PrimaryOffset(name, map);
Entry* primary = entry(primary_, primary_offset);
if (primary->key == name && primary->map == map) {
return TaggedValue::ToMaybeObject(isolate(), primary->value);
}
int secondary_offset = SecondaryOffset(name, map);
Entry* secondary = entry(secondary_, secondary_offset);
if (secondary->key == name && secondary->map == map) {
return TaggedValue::ToMaybeObject(isolate(), secondary->value);
}
return MaybeObject();
}
void StubCache::Clear() {
MaybeObject empty =
MaybeObject::FromObject(isolate_->builtins()->code(Builtin::kIllegal));
Name empty_string = ReadOnlyRoots(isolate()).empty_string();
for (int i = 0; i < kPrimaryTableSize; i++) {
primary_[i].key = StrongTaggedValue(empty_string);
primary_[i].map = StrongTaggedValue(Smi::zero());
primary_[i].value = TaggedValue(empty);
}
for (int j = 0; j < kSecondaryTableSize; j++) {
secondary_[j].key = StrongTaggedValue(empty_string);
secondary_[j].map = StrongTaggedValue(Smi::zero());
secondary_[j].value = TaggedValue(empty);
}
}
} // namespace internal
} // namespace v8