[serializer] print use count of external references.

src/external-reference-table.cc

 // 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/external-reference-table.h"
 
 #include "src/accessors.h"
 #include "src/assembler.h"
 #include "src/builtins/builtins.h"
 #include "src/counters.h"
 #include "src/deoptimizer.h"
 #include "src/ic/stub-cache.h"
 
+#if defined(DEBUG) && defined(V8_OS_LINUX) && !defined(V8_OS_ANDROID)
+#define SYMBOLIZE_FUNCTION
+#include <execinfo.h>
+#endif  // DEBUG && V8_OS_LINUX && !V8_OS_ANDROID
+
 namespace v8 {
 namespace internal {
 
 // Forward declarations for C++ builtins.
 #define FORWARD_DECLARE(Name) \
   Object* Builtin_##Name(int argc, Object** args, Isolate* isolate);
 BUILTIN_LIST_C(FORWARD_DECLARE)
 #undef FORWARD_DECLARE
 
 ExternalReferenceTable* ExternalReferenceTable::instance(Isolate* isolate) {
@@ skipping 12 matching lines @@
   AddReferences(isolate);
   AddBuiltins(isolate);
   AddRuntimeFunctions(isolate);
   AddIsolateAddresses(isolate);
   AddAccessors(isolate);
   AddStubCache(isolate);
   AddDeoptEntries(isolate);
   AddApiReferences(isolate);
 }
 
+#ifdef DEBUG
+void ExternalReferenceTable::ResetCount() {
+  for (ExternalReferenceEntry& entry : refs_) entry.count = 0;
+}
+
+void ExternalReferenceTable::PrintCount() {
+  for (int i = 0; i < refs_.length(); i++) {
+    v8::base::OS::Print("index=%5d count=%5d  %-60s\n", i, refs_[i].count,
+                        refs_[i].name);
+  }
+}
+#endif  // DEBUG
+
+// static
+const char* ExternalReferenceTable::ResolveSymbol(void* address) {
+#ifdef SYMBOLIZE_FUNCTION
+  return backtrace_symbols(&address, 1)[0];
+#else
+  return "<unresolved>";
+#endif  // SYMBOLIZE_FUNCTION
+}
+
 void ExternalReferenceTable::AddReferences(Isolate* isolate) {
   // Miscellaneous
   Add(ExternalReference::roots_array_start(isolate).address(),
       "Heap::roots_array_start()");
   Add(ExternalReference::address_of_stack_limit(isolate).address(),
       "StackGuard::address_of_jslimit()");
   Add(ExternalReference::address_of_real_stack_limit(isolate).address(),
       "StackGuard::address_of_real_jslimit()");
   Add(ExternalReference::new_space_allocation_limit_address(isolate).address(),
       "Heap::NewSpaceAllocationLimitAddress()");
@@ skipping 273 matching lines @@
 }
 
 void ExternalReferenceTable::AddAccessors(Isolate* isolate) {
   // Accessors
   struct AccessorRefTable {
     Address address;
     const char* name;
   };
 
   static const AccessorRefTable getters[] = {
-#define ACCESSOR_INFO_DECLARATION(name) \
-  {FUNCTION_ADDR(&Accessors::name##Getter), "Accessors::" #name "Getter"},
+#define ACCESSOR_INFO_DECLARATION(name)     \
+  { FUNCTION_ADDR(&Accessors::name##Getter), \
+    "Redirect to Accessors::" #name "Getter"},
       ACCESSOR_INFO_LIST(ACCESSOR_INFO_DECLARATION)
 #undef ACCESSOR_INFO_DECLARATION
   };
   static const AccessorRefTable setters[] = {
 #define ACCESSOR_SETTER_DECLARATION(name) \
-  {FUNCTION_ADDR(&Accessors::name), "Accessors::" #name},
+  { FUNCTION_ADDR(&Accessors::name), "Accessors::" #name},
       ACCESSOR_SETTER_LIST(ACCESSOR_SETTER_DECLARATION)
 #undef ACCESSOR_INFO_DECLARATION
   };
 
   for (unsigned i = 0; i < arraysize(getters); ++i) {
-    Add(getters[i].address, getters[i].name);
+    const char* name = getters[i].name + 12;  // Skip "Redirect to " prefix.
+    Add(getters[i].address, name);
     Add(AccessorInfo::redirect(isolate, getters[i].address, ACCESSOR_GETTER),
-        "");
+        getters[i].name);
   }
 
   for (unsigned i = 0; i < arraysize(setters); ++i) {
     Add(setters[i].address, setters[i].name);
   }
 }
 
 void ExternalReferenceTable::AddStubCache(Isolate* isolate) {
   StubCache* load_stub_cache = isolate->load_stub_cache();
 
@@ skipping 40 matching lines @@
     Add(address, "lazy_deopt");
   }
 }
 
 void ExternalReferenceTable::AddApiReferences(Isolate* isolate) {
   // Add external references provided by the embedder (a null-terminated
   // array).
   intptr_t* api_external_references = isolate->api_external_references();
   if (api_external_references != nullptr) {
     while (*api_external_references != 0) {
-      Add(reinterpret_cast<Address>(*api_external_references), "<embedder>");
+      Address address = reinterpret_cast<Address>(*api_external_references);
+      Add(address, ResolveSymbol(address));
       api_external_references++;
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8