// Copyright 2016 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/codegen/external-reference-table.h" #include "src/builtins/accessors.h" #include "src/codegen/external-reference.h" #include "src/ic/stub-cache.h" #include "src/logging/counters.h" #if defined(DEBUG) && defined(V8_OS_LINUX) && !defined(V8_OS_ANDROID) #define SYMBOLIZE_FUNCTION #include <execinfo.h> #include <vector> #include "src/base/platform/wrappers.h" #endif // DEBUG && V8_OS_LINUX && !V8_OS_ANDROID namespace v8 { 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, #define ADD_STATS_COUNTER_NAME(name, ...) "StatsCounter::" #name, // static // clang-format off 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", // Native code counters: STATS_COUNTER_NATIVE_CODE_LIST(ADD_STATS_COUNTER_NAME) }; // clang-format on #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 #undef ADD_STATS_COUNTER_NAME // Forward declarations for C++ builtins. #define FORWARD_DECLARE(Name) \ Address Builtin_##Name(int argc, Address* args, Isolate* isolate); BUILTIN_LIST_C(FORWARD_DECLARE) #undef FORWARD_DECLARE void ExternalReferenceTable::Init(Isolate* isolate) { int index = 0; // kNullAddress is preserved through serialization/deserialization. Add(kNullAddress, &index); AddReferences(isolate, &index); AddBuiltins(&index); AddRuntimeFunctions(&index); AddIsolateAddresses(isolate, &index); AddAccessors(&index); AddStubCache(isolate, &index); AddNativeCodeStatsCounters(isolate, &index); is_initialized_ = static_cast<uint32_t>(true); CHECK_EQ(kSize, index); } const char* ExternalReferenceTable::ResolveSymbol(void* address) { #ifdef SYMBOLIZE_FUNCTION char** names = backtrace_symbols(&address, 1); const char* name = names[0]; // The array of names is malloc'ed. However, each name string is static // and do not need to be freed. base::Free(names); return name; #else return "<unresolved>"; #endif // SYMBOLIZE_FUNCTION } void ExternalReferenceTable::Add(Address address, int* index) { ref_addr_[(*index)++] = address; } void ExternalReferenceTable::AddReferences(Isolate* isolate, int* index) { CHECK_EQ(kSpecialReferenceCount, *index); #define ADD_EXTERNAL_REFERENCE(name, desc) \ Add(ExternalReference::name().address(), index); EXTERNAL_REFERENCE_LIST(ADD_EXTERNAL_REFERENCE) #undef ADD_EXTERNAL_REFERENCE #define ADD_EXTERNAL_REFERENCE(name, desc) \ Add(ExternalReference::name(isolate).address(), index); EXTERNAL_REFERENCE_LIST_WITH_ISOLATE(ADD_EXTERNAL_REFERENCE) #undef ADD_EXTERNAL_REFERENCE CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount, *index); } void ExternalReferenceTable::AddBuiltins(int* index) { CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount, *index); static const Address c_builtins[] = { #define DEF_ENTRY(Name, ...) FUNCTION_ADDR(&Builtin_##Name), BUILTIN_LIST_C(DEF_ENTRY) #undef DEF_ENTRY }; for (Address addr : c_builtins) { Add(ExternalReference::Create(addr).address(), index); } CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + kBuiltinsReferenceCount, *index); } void ExternalReferenceTable::AddRuntimeFunctions(int* index) { CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + kBuiltinsReferenceCount, *index); static constexpr Runtime::FunctionId runtime_functions[] = { #define RUNTIME_ENTRY(name, ...) Runtime::k##name, FOR_EACH_INTRINSIC(RUNTIME_ENTRY) #undef RUNTIME_ENTRY }; for (Runtime::FunctionId fId : runtime_functions) { Add(ExternalReference::Create(fId).address(), index); } CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + kBuiltinsReferenceCount + kRuntimeReferenceCount, *index); } void ExternalReferenceTable::AddIsolateAddresses(Isolate* isolate, int* index) { CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + kBuiltinsReferenceCount + kRuntimeReferenceCount, *index); for (int i = 0; i < IsolateAddressId::kIsolateAddressCount; ++i) { Add(isolate->get_address_from_id(static_cast<IsolateAddressId>(i)), index); } CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + kBuiltinsReferenceCount + kRuntimeReferenceCount + kIsolateAddressReferenceCount, *index); } void ExternalReferenceTable::AddAccessors(int* index) { CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + kBuiltinsReferenceCount + kRuntimeReferenceCount + kIsolateAddressReferenceCount, *index); static const Address accessors[] = { // Getters: #define ACCESSOR_INFO_DECLARATION(_, __, AccessorName, ...) \ FUNCTION_ADDR(&Accessors::AccessorName##Getter), ACCESSOR_INFO_LIST_GENERATOR(ACCESSOR_INFO_DECLARATION, /* not used */) #undef ACCESSOR_INFO_DECLARATION // Setters: #define ACCESSOR_SETTER_DECLARATION(name) FUNCTION_ADDR(&Accessors::name), ACCESSOR_SETTER_LIST(ACCESSOR_SETTER_DECLARATION) #undef ACCESSOR_SETTER_DECLARATION }; for (Address addr : accessors) { Add(addr, index); } CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + kBuiltinsReferenceCount + kRuntimeReferenceCount + kIsolateAddressReferenceCount + kAccessorReferenceCount, *index); } void ExternalReferenceTable::AddStubCache(Isolate* isolate, int* index) { CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + kBuiltinsReferenceCount + kRuntimeReferenceCount + kIsolateAddressReferenceCount + kAccessorReferenceCount, *index); StubCache* load_stub_cache = isolate->load_stub_cache(); // Stub cache tables Add(load_stub_cache->key_reference(StubCache::kPrimary).address(), index); Add(load_stub_cache->value_reference(StubCache::kPrimary).address(), index); Add(load_stub_cache->map_reference(StubCache::kPrimary).address(), index); Add(load_stub_cache->key_reference(StubCache::kSecondary).address(), index); Add(load_stub_cache->value_reference(StubCache::kSecondary).address(), index); Add(load_stub_cache->map_reference(StubCache::kSecondary).address(), index); StubCache* store_stub_cache = isolate->store_stub_cache(); // Stub cache tables Add(store_stub_cache->key_reference(StubCache::kPrimary).address(), index); Add(store_stub_cache->value_reference(StubCache::kPrimary).address(), index); Add(store_stub_cache->map_reference(StubCache::kPrimary).address(), index); Add(store_stub_cache->key_reference(StubCache::kSecondary).address(), index); Add(store_stub_cache->value_reference(StubCache::kSecondary).address(), index); Add(store_stub_cache->map_reference(StubCache::kSecondary).address(), index); CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + kBuiltinsReferenceCount + kRuntimeReferenceCount + kIsolateAddressReferenceCount + kAccessorReferenceCount + kStubCacheReferenceCount, *index); } Address ExternalReferenceTable::GetStatsCounterAddress(StatsCounter* counter) { int* address = counter->Enabled() ? counter->GetInternalPointer() : reinterpret_cast<int*>(&dummy_stats_counter_); return reinterpret_cast<Address>(address); } void ExternalReferenceTable::AddNativeCodeStatsCounters(Isolate* isolate, int* index) { CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + kBuiltinsReferenceCount + kRuntimeReferenceCount + kIsolateAddressReferenceCount + kAccessorReferenceCount + kStubCacheReferenceCount, *index); Counters* counters = isolate->counters(); #define SC(name, caption) Add(GetStatsCounterAddress(counters->name()), index); STATS_COUNTER_NATIVE_CODE_LIST(SC) #undef SC CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount + kBuiltinsReferenceCount + kRuntimeReferenceCount + kIsolateAddressReferenceCount + kAccessorReferenceCount + kStubCacheReferenceCount + kStatsCountersReferenceCount, *index); CHECK_EQ(kSize, *index); } } // namespace internal } // namespace v8 #undef SYMBOLIZE_FUNCTION