Skip to content

V
V8
Commit dca02862 authored by Clemens Hammacher's avatar Clemens Hammacher Committed by Commit Bot
Browse files
Options

Store external reference names in a static array 

Names of external references are statically known, so there is no need
to store them in the dynamically generated ExternalReferenceTable.
This saves 7.4kB per Isolate, plus ~46.4kB binary size.

R=mstarzinger@chromium.org

Bug: v8:8562
Change-Id: Ia494de38474e0a7308563ab6d1797ff488b0a072
Reviewed-on: https://chromium-review.googlesource.com/c/1369947Reviewed-by: 's avatarMichael Starzinger <mstarzinger@chromium.org>
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58128}
parent 0c8c3118
Show whitespace changes
Inline Side-by-side
Showing with 88 additions and 94 deletions
src/external-reference-table.cc
View file @ dca02862
...@@ -18,6 +18,51 @@ ...@@ -18,6 +18,51 @@
namespace v8 { namespace v8 {
namespace internal { namespace internal {
#define ADD_EXT_REF_NAME(name, desc) desc,
#define ADD_BUILTIN_NAME(Name, ...) "Builtin_" #Name,
#define ADD_RUNTIME_FUNCTION(name, ...) "Runtime::" #name,
#define ADD_ISOLATE_ADDR(Name, name) "Isolate::" #name "_address",
#define ADD_ACCESSOR_INFO_NAME(_, __, AccessorName, ...) \
"Accessors::" #AccessorName "Getter",
#define ADD_ACCESSOR_SETTER_NAME(name) "Accessors::" #name,
// static
const char* const
ExternalReferenceTable::ref_name_[ExternalReferenceTable::kSize] = {
// Special references:
"nullptr",
// External references:
EXTERNAL_REFERENCE_LIST(ADD_EXT_REF_NAME)
EXTERNAL_REFERENCE_LIST_WITH_ISOLATE(ADD_EXT_REF_NAME)
// Builtins:
BUILTIN_LIST_C(ADD_BUILTIN_NAME)
// Runtime functions:
FOR_EACH_INTRINSIC(ADD_RUNTIME_FUNCTION)
// Isolate addresses:
FOR_EACH_ISOLATE_ADDRESS_NAME(ADD_ISOLATE_ADDR)
// Accessors:
ACCESSOR_INFO_LIST_GENERATOR(ADD_ACCESSOR_INFO_NAME, /* not used */)
ACCESSOR_SETTER_LIST(ADD_ACCESSOR_SETTER_NAME)
// Stub cache:
"Load StubCache::primary_->key",
"Load StubCache::primary_->value",
"Load StubCache::primary_->map",
"Load StubCache::secondary_->key",
"Load StubCache::secondary_->value",
"Load StubCache::secondary_->map",
"Store StubCache::primary_->key",
"Store StubCache::primary_->value",
"Store StubCache::primary_->map",
"Store StubCache::secondary_->key",
"Store StubCache::secondary_->value",
"Store StubCache::secondary_->map",
};
#undef ADD_EXT_REF_NAME
#undef ADD_BUILTIN_NAME
#undef ADD_RUNTIME_FUNCTION
#undef ADD_ISOLATE_ADDR
#undef ADD_ACCESSOR_INFO_NAME
#undef ADD_ACCESSOR_SETTER_NAME
// Forward declarations for C++ builtins. // Forward declarations for C++ builtins.
#define FORWARD_DECLARE(Name) \ #define FORWARD_DECLARE(Name) \
Object* Builtin_##Name(int argc, Address* args, Isolate* isolate); Object* Builtin_##Name(int argc, Address* args, Isolate* isolate);
...@@ -28,7 +73,7 @@ void ExternalReferenceTable::Init(Isolate* isolate) { ...@@ -28,7 +73,7 @@ void ExternalReferenceTable::Init(Isolate* isolate) {
int index = 0; int index = 0;
// kNullAddress is preserved through serialization/deserialization. // kNullAddress is preserved through serialization/deserialization.
Add(kNullAddress, "nullptr", &index); Add(kNullAddress, &index);
AddReferences(isolate, &index); AddReferences(isolate, &index);
AddBuiltins(&index); AddBuiltins(&index);
AddRuntimeFunctions(&index); AddRuntimeFunctions(&index);
...@@ -54,21 +99,20 @@ const char* ExternalReferenceTable::ResolveSymbol(void* address) { ...@@ -54,21 +99,20 @@ const char* ExternalReferenceTable::ResolveSymbol(void* address) {
#endif // SYMBOLIZE_FUNCTION #endif // SYMBOLIZE_FUNCTION
} }
void ExternalReferenceTable::Add(Address address, const char* name, void ExternalReferenceTable::Add(Address address, int* index) {
int* index) { ref_addr_[(*index)++] = address;
refs_[(*index)++] = {address, name};
} }
void ExternalReferenceTable::AddReferences(Isolate* isolate, int* index) { void ExternalReferenceTable::AddReferences(Isolate* isolate, int* index) {
CHECK_EQ(kSpecialReferenceCount, *index); CHECK_EQ(kSpecialReferenceCount, *index);
#define ADD_EXTERNAL_REFERENCE(name, desc) \ #define ADD_EXTERNAL_REFERENCE(name, desc) \
Add(ExternalReference::name().address(), desc, index); Add(ExternalReference::name().address(), index);
EXTERNAL_REFERENCE_LIST(ADD_EXTERNAL_REFERENCE) EXTERNAL_REFERENCE_LIST(ADD_EXTERNAL_REFERENCE)
#undef ADD_EXTERNAL_REFERENCE #undef ADD_EXTERNAL_REFERENCE
#define ADD_EXTERNAL_REFERENCE(name, desc) \ #define ADD_EXTERNAL_REFERENCE(name, desc) \
Add(ExternalReference::name(isolate).address(), desc, index); Add(ExternalReference::name(isolate).address(), index);
EXTERNAL_REFERENCE_LIST_WITH_ISOLATE(ADD_EXTERNAL_REFERENCE) EXTERNAL_REFERENCE_LIST_WITH_ISOLATE(ADD_EXTERNAL_REFERENCE)
#undef ADD_EXTERNAL_REFERENCE #undef ADD_EXTERNAL_REFERENCE
...@@ -78,18 +122,13 @@ void ExternalReferenceTable::AddReferences(Isolate* isolate, int* index) { ...@@ -78,18 +122,13 @@ void ExternalReferenceTable::AddReferences(Isolate* isolate, int* index) {
void ExternalReferenceTable::AddBuiltins(int* index) { void ExternalReferenceTable::AddBuiltins(int* index) {
CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount, *index); CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount, *index);
struct CBuiltinEntry { static const Address c_builtins[] = {
Address address; #define DEF_ENTRY(Name, ...) FUNCTION_ADDR(&Builtin_##Name),
const char* name;
};
static const CBuiltinEntry c_builtins[] = {
#define DEF_ENTRY(Name, ...) {FUNCTION_ADDR(&Builtin_##Name), "Builtin_" #Name},
BUILTIN_LIST_C(DEF_ENTRY) BUILTIN_LIST_C(DEF_ENTRY)
#undef DEF_ENTRY #undef DEF_ENTRY
}; };
for (unsigned i = 0; i < arraysize(c_builtins); ++i) { for (Address addr : c_builtins) {
Add(ExternalReference::Create(c_builtins[i].address).address(), Add(ExternalReference::Create(addr).address(), index);
c_builtins[i].name, index);
} }
CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount +
...@@ -102,20 +141,14 @@ void ExternalReferenceTable::AddRuntimeFunctions(int* index) { ...@@ -102,20 +141,14 @@ void ExternalReferenceTable::AddRuntimeFunctions(int* index) {
kBuiltinsReferenceCount, kBuiltinsReferenceCount,
*index); *index);
struct RuntimeEntry { static constexpr Runtime::FunctionId runtime_functions[] = {
Runtime::FunctionId id; #define RUNTIME_ENTRY(name, ...) Runtime::k##name,
const char* name;
};
static const RuntimeEntry runtime_functions[] = {
#define RUNTIME_ENTRY(name, i1, i2) {Runtime::k##name, "Runtime::" #name},
FOR_EACH_INTRINSIC(RUNTIME_ENTRY) FOR_EACH_INTRINSIC(RUNTIME_ENTRY)
#undef RUNTIME_ENTRY #undef RUNTIME_ENTRY
}; };
for (unsigned i = 0; i < arraysize(runtime_functions); ++i) { for (Runtime::FunctionId fId : runtime_functions) {
ExternalReference ref = ExternalReference::Create(runtime_functions[i].id); Add(ExternalReference::Create(fId).address(), index);
Add(ref.address(), runtime_functions[i].name, index);
} }
CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount +
...@@ -128,16 +161,8 @@ void ExternalReferenceTable::AddIsolateAddresses(Isolate* isolate, int* index) { ...@@ -128,16 +161,8 @@ void ExternalReferenceTable::AddIsolateAddresses(Isolate* isolate, int* index) {
kBuiltinsReferenceCount + kRuntimeReferenceCount, kBuiltinsReferenceCount + kRuntimeReferenceCount,
*index); *index);
// Top addresses
static const char* address_names[] = {
#define BUILD_NAME_LITERAL(Name, name) "Isolate::" #name "_address",
FOR_EACH_ISOLATE_ADDRESS_NAME(BUILD_NAME_LITERAL) nullptr
#undef BUILD_NAME_LITERAL
};
for (int i = 0; i < IsolateAddressId::kIsolateAddressCount; ++i) { for (int i = 0; i < IsolateAddressId::kIsolateAddressCount; ++i) {
Add(isolate->get_address_from_id(static_cast<IsolateAddressId>(i)), Add(isolate->get_address_from_id(static_cast<IsolateAddressId>(i)), index);
address_names[i], index);
} }
CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount +
...@@ -152,32 +177,20 @@ void ExternalReferenceTable::AddAccessors(int* index) { ...@@ -152,32 +177,20 @@ void ExternalReferenceTable::AddAccessors(int* index) {
kIsolateAddressReferenceCount, kIsolateAddressReferenceCount,
*index); *index);
// Accessors static const Address accessors[] = {
struct AccessorRefTable { // Getters:
Address address; #define ACCESSOR_INFO_DECLARATION(_, __, AccessorName, ...) \
const char* name; FUNCTION_ADDR(&Accessors::AccessorName##Getter),
};
static const AccessorRefTable getters[] = {
#define ACCESSOR_INFO_DECLARATION(_, accessor_name, AccessorName, ...) \
{FUNCTION_ADDR(&Accessors::AccessorName##Getter), \
"Accessors::" #AccessorName "Getter"}, /* NOLINT(whitespace/indent) */
ACCESSOR_INFO_LIST_GENERATOR(ACCESSOR_INFO_DECLARATION, /* not used */) ACCESSOR_INFO_LIST_GENERATOR(ACCESSOR_INFO_DECLARATION, /* not used */)
#undef ACCESSOR_INFO_DECLARATION #undef ACCESSOR_INFO_DECLARATION
}; // Setters:
static const AccessorRefTable setters[] = { #define ACCESSOR_SETTER_DECLARATION(name) FUNCTION_ADDR(&Accessors::name),
#define ACCESSOR_SETTER_DECLARATION(name) \
{ FUNCTION_ADDR(&Accessors::name), "Accessors::" #name},
ACCESSOR_SETTER_LIST(ACCESSOR_SETTER_DECLARATION) ACCESSOR_SETTER_LIST(ACCESSOR_SETTER_DECLARATION)
#undef ACCESSOR_SETTER_DECLARATION #undef ACCESSOR_SETTER_DECLARATION
}; };
for (unsigned i = 0; i < arraysize(getters); ++i) { for (Address addr : accessors) {
Add(getters[i].address, getters[i].name, index); Add(addr, index);
}
for (unsigned i = 0; i < arraysize(setters); ++i) {
Add(setters[i].address, setters[i].name, index);
} }
CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount +
...@@ -195,34 +208,23 @@ void ExternalReferenceTable::AddStubCache(Isolate* isolate, int* index) { ...@@ -195,34 +208,23 @@ void ExternalReferenceTable::AddStubCache(Isolate* isolate, int* index) {
StubCache* load_stub_cache = isolate->load_stub_cache(); StubCache* load_stub_cache = isolate->load_stub_cache();
// Stub cache tables // Stub cache tables
Add(load_stub_cache->key_reference(StubCache::kPrimary).address(), Add(load_stub_cache->key_reference(StubCache::kPrimary).address(), index);
"Load StubCache::primary_->key", index); Add(load_stub_cache->value_reference(StubCache::kPrimary).address(), index);
Add(load_stub_cache->value_reference(StubCache::kPrimary).address(), Add(load_stub_cache->map_reference(StubCache::kPrimary).address(), index);
"Load StubCache::primary_->value", index); Add(load_stub_cache->key_reference(StubCache::kSecondary).address(), index);
Add(load_stub_cache->map_reference(StubCache::kPrimary).address(), Add(load_stub_cache->value_reference(StubCache::kSecondary).address(), index);
"Load StubCache::primary_->map", index); Add(load_stub_cache->map_reference(StubCache::kSecondary).address(), index);
Add(load_stub_cache->key_reference(StubCache::kSecondary).address(),
"Load StubCache::secondary_->key", index);
Add(load_stub_cache->value_reference(StubCache::kSecondary).address(),
"Load StubCache::secondary_->value", index);
Add(load_stub_cache->map_reference(StubCache::kSecondary).address(),
"Load StubCache::secondary_->map", index);
StubCache* store_stub_cache = isolate->store_stub_cache(); StubCache* store_stub_cache = isolate->store_stub_cache();
// Stub cache tables // Stub cache tables
Add(store_stub_cache->key_reference(StubCache::kPrimary).address(), Add(store_stub_cache->key_reference(StubCache::kPrimary).address(), index);
"Store StubCache::primary_->key", index); Add(store_stub_cache->value_reference(StubCache::kPrimary).address(), index);
Add(store_stub_cache->value_reference(StubCache::kPrimary).address(), Add(store_stub_cache->map_reference(StubCache::kPrimary).address(), index);
"Store StubCache::primary_->value", index); Add(store_stub_cache->key_reference(StubCache::kSecondary).address(), index);
Add(store_stub_cache->map_reference(StubCache::kPrimary).address(),
"Store StubCache::primary_->map", index);
Add(store_stub_cache->key_reference(StubCache::kSecondary).address(),
"Store StubCache::secondary_->key", index);
Add(store_stub_cache->value_reference(StubCache::kSecondary).address(), Add(store_stub_cache->value_reference(StubCache::kSecondary).address(),
"Store StubCache::secondary_->value", index); index);
Add(store_stub_cache->map_reference(StubCache::kSecondary).address(), Add(store_stub_cache->map_reference(StubCache::kSecondary).address(), index);
"Store StubCache::secondary_->map", index);
CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount +
kBuiltinsReferenceCount + kRuntimeReferenceCount + kBuiltinsReferenceCount + kRuntimeReferenceCount +
......
src/external-reference-table.h
View file @ dca02862
...@@ -42,11 +42,11 @@ class ExternalReferenceTable { ...@@ -42,11 +42,11 @@ class ExternalReferenceTable {
kBuiltinsReferenceCount + kRuntimeReferenceCount + kBuiltinsReferenceCount + kRuntimeReferenceCount +
kIsolateAddressReferenceCount + kAccessorReferenceCount + kIsolateAddressReferenceCount + kAccessorReferenceCount +
kStubCacheReferenceCount; kStubCacheReferenceCount;
static constexpr uint32_t kEntrySize = 2 * kPointerSize; static constexpr uint32_t kEntrySize = kPointerSize;
static constexpr uint32_t kSizeInBytes = kSize * kEntrySize + 2 * kUInt32Size; static constexpr uint32_t kSizeInBytes = kSize * kEntrySize + 2 * kUInt32Size;
Address address(uint32_t i) { return refs_[i].address; } Address address(uint32_t i) const { return ref_addr_[i]; }
const char* name(uint32_t i) { return refs_[i].name; } const char* name(uint32_t i) const { return ref_name_[i]; }
bool is_initialized() const { return is_initialized_ != 0; } bool is_initialized() const { return is_initialized_ != 0; }
...@@ -54,7 +54,6 @@ class ExternalReferenceTable { ...@@ -54,7 +54,6 @@ class ExternalReferenceTable {
static constexpr uint32_t OffsetOfEntry(uint32_t i) { static constexpr uint32_t OffsetOfEntry(uint32_t i) {
// Used in CodeAssembler::LookupExternalReference. // Used in CodeAssembler::LookupExternalReference.
STATIC_ASSERT(offsetof(ExternalReferenceEntry, address) == 0);
return i * kEntrySize; return i * kEntrySize;
} }
...@@ -69,17 +68,7 @@ class ExternalReferenceTable { ...@@ -69,17 +68,7 @@ class ExternalReferenceTable {
void Init(Isolate* isolate); void Init(Isolate* isolate);
private: private:
struct ExternalReferenceEntry { void Add(Address address, int* index);
Address address;
const char* name;
ExternalReferenceEntry() : address(kNullAddress), name(nullptr) {}
ExternalReferenceEntry(Address address, const char* name)
: address(address), name(name) {}
};
STATIC_ASSERT(kEntrySize == sizeof(ExternalReferenceEntry));
void Add(Address address, const char* name, int* index);
void AddReferences(Isolate* isolate, int* index); void AddReferences(Isolate* isolate, int* index);
void AddBuiltins(int* index); void AddBuiltins(int* index);
...@@ -88,7 +77,10 @@ class ExternalReferenceTable { ...@@ -88,7 +77,10 @@ class ExternalReferenceTable {
void AddAccessors(int* index); void AddAccessors(int* index);
void AddStubCache(Isolate* isolate, int* index); void AddStubCache(Isolate* isolate, int* index);
ExternalReferenceEntry refs_[kSize]; STATIC_ASSERT(sizeof(Address) == kEntrySize);
Address ref_addr_[kSize];
static const char* const ref_name_[kSize];
uint32_t is_initialized_ = 0; // Not bool to guarantee deterministic size. uint32_t is_initialized_ = 0; // Not bool to guarantee deterministic size.
uint32_t unused_padding_ = 0; // For alignment. uint32_t unused_padding_ = 0; // For alignment.
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment