Resolve external refs without isolate.

Makes ExternalRefEncoder work even if no isolate is available,
by separating V8 builtin external references from isolate dependent ones,
and making the first set available without providing an isolate.

This is used when disassembling external references in wasm functions.

Bug: v8:11373
Change-Id: I9a177618185a6e5612182bcb02be7cc1978e8f34
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2799511Reviewed-by: Clemens Backes <clemensb@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Zhi An Ng <zhin@chromium.org>
Commit-Queue: Daan de Graaf <daagra@google.com>
Cr-Commit-Position: refs/heads/master@{#74025}

src/codegen/external-reference-table.h

@@ -24,8 +24,10 @@ class ExternalReferenceTable {
  public:
   // For the nullptr ref, see the constructor.
   static constexpr int kSpecialReferenceCount = 1;
-  static constexpr int kExternalReferenceCount =
-      ExternalReference::kExternalReferenceCount;
+  static constexpr int kExternalReferenceCountIsolateIndependent =
+      ExternalReference::kExternalReferenceCountIsolateIndependent;
+  static constexpr int kExternalReferenceCountIsolateDependent =
+      ExternalReference::kExternalReferenceCountIsolateDependent;
   static constexpr int kBuiltinsReferenceCount =
 #define COUNT_C_BUILTIN(...) +1
       BUILTIN_LIST_C(COUNT_C_BUILTIN);
@@ -42,11 +44,14 @@ class ExternalReferenceTable {
 #define SC(...) +1
       STATS_COUNTER_NATIVE_CODE_LIST(SC);
 #undef SC
-  static constexpr int kSize =
-      kSpecialReferenceCount + kExternalReferenceCount +
+  static constexpr int kSizeIsolateIndependent =
+      kSpecialReferenceCount + kExternalReferenceCountIsolateIndependent +
       kBuiltinsReferenceCount + kRuntimeReferenceCount +
-      kIsolateAddressReferenceCount + kAccessorReferenceCount +
-      kStubCacheReferenceCount + kStatsCountersReferenceCount;
+      kAccessorReferenceCount;
+  static constexpr int kSize =
+      kSizeIsolateIndependent + kExternalReferenceCountIsolateDependent +
+      kIsolateAddressReferenceCount + kStubCacheReferenceCount +
+      kStatsCountersReferenceCount;
   static constexpr uint32_t kEntrySize =
       static_cast<uint32_t>(kSystemPointerSize);
   static constexpr uint32_t kSizeInBytes = kSize * kEntrySize + 2 * kUInt32Size;
@@ -63,6 +68,9 @@ class ExternalReferenceTable {
     return i * kEntrySize;
   }
 
+  static void InitializeOncePerProcess();
+  static const char* NameOfIsolateIndependentAddress(Address address);
+
   const char* NameFromOffset(uint32_t offset) {
     DCHECK_EQ(offset % kEntrySize, 0);
     DCHECK_LT(offset, kSizeInBytes);
@@ -76,13 +84,18 @@ class ExternalReferenceTable {
   void Init(Isolate* isolate);
 
  private:
+  static void AddIsolateIndependent(Address address, int* index);
+
+  static void AddIsolateIndependentReferences(int* index);
+  static void AddBuiltins(int* index);
+  static void AddRuntimeFunctions(int* index);
+  static void AddAccessors(int* index);
+
   void Add(Address address, int* index);
 
-  void AddReferences(Isolate* isolate, int* index);
-  void AddBuiltins(int* index);
-  void AddRuntimeFunctions(int* index);
+  void CopyIsolateIndependentReferences(int* index);
+  void AddIsolateDependentReferences(Isolate* isolate, int* index);
   void AddIsolateAddresses(Isolate* isolate, int* index);
-  void AddAccessors(int* index);
   void AddStubCache(Isolate* isolate, int* index);
 
   Address GetStatsCounterAddress(StatsCounter* counter);

src/codegen/external-reference.h

@@ -342,10 +342,11 @@ class ExternalReference {
     PROFILING_GETTER_CALL
   };
 
-  static constexpr int kExternalReferenceCount =
 #define COUNT_EXTERNAL_REFERENCE(name, desc) +1
-      EXTERNAL_REFERENCE_LIST(COUNT_EXTERNAL_REFERENCE)
-          EXTERNAL_REFERENCE_LIST_WITH_ISOLATE(COUNT_EXTERNAL_REFERENCE);
+  static constexpr int kExternalReferenceCountIsolateIndependent =
+      EXTERNAL_REFERENCE_LIST(COUNT_EXTERNAL_REFERENCE);
+  static constexpr int kExternalReferenceCountIsolateDependent =
+      EXTERNAL_REFERENCE_LIST_WITH_ISOLATE(COUNT_EXTERNAL_REFERENCE);
 #undef COUNT_EXTERNAL_REFERENCE
 
   ExternalReference() : address_(kNullAddress) {}

src/diagnostics/disassembler.cc

@@ -237,10 +237,11 @@ static void PrintRelocInfo(StringBuilder* out, Isolate* isolate,
     out->AddFormatted("    ;; %sobject: %s",
                       is_compressed ? "(compressed) " : "", obj_name.get());
   } else if (rmode == RelocInfo::EXTERNAL_REFERENCE) {
+    Address address = relocinfo->target_external_reference();
     const char* reference_name =
-        ref_encoder ? ref_encoder->NameOfAddress(
-                          isolate, relocinfo->target_external_reference())
-                    : "unknown";
+        ref_encoder
+            ? ref_encoder->NameOfAddress(isolate, address)
+            : ExternalReferenceTable::NameOfIsolateIndependentAddress(address);
     out->AddFormatted("    ;; external reference (%s)", reference_name);
   } else if (RelocInfo::IsCodeTargetMode(rmode)) {
     out->AddFormatted("    ;; code:");
@@ -441,14 +442,16 @@ int Disassembler::Decode(Isolate* isolate, std::ostream* os, byte* begin,
                   "Builtins disassembly requires a readable .text section");
   V8NameConverter v8NameConverter(isolate, code);
   if (isolate) {
-    // We have an isolate, so support external reference names.
+    // We have an isolate, so support external reference names from V8 and
+    // embedder.
     SealHandleScope shs(isolate);
     DisallowGarbageCollection no_alloc;
     ExternalReferenceEncoder ref_encoder(isolate);
     return DecodeIt(isolate, &ref_encoder, os, code, v8NameConverter, begin,
                     end, current_pc);
   } else {
-    // No isolate => isolate-independent code. No external reference names.
+    // No isolate => isolate-independent code. Only V8 External references
+    // available.
     return DecodeIt(nullptr, nullptr, os, code, v8NameConverter, begin, end,
                     current_pc);
   }

src/init/v8.cc

@@ -164,6 +164,8 @@ void V8::InitializeOncePerProcessImpl() {
 #if V8_ENABLE_WEBASSEMBLY
   wasm::WasmEngine::InitializeOncePerProcess();
 #endif  // V8_ENABLE_WEBASSEMBLY
+
+  ExternalReferenceTable::InitializeOncePerProcess();
 }
 
 void V8::InitializeOncePerProcess() {