[Distributed] Runtime: Add skeleton support for accessible function sections

Author: xedin

include/swift/ABI/Metadata.h

@@ -5059,6 +5059,8 @@ struct TargetAccessibleFunctionRecord final {
   AccessibleFunctionFlags Flags;
 };
 
+using AccessibleFunctionRecord = TargetAccessibleFunctionRecord<InProcess>;
+
 } // end namespace swift
 
 #pragma clang diagnostic pop

stdlib/public/SwiftShims/MetadataSections.h

@@ -64,6 +64,7 @@ struct MetadataSections {
   MetadataSectionRange swift5_replac2;
   MetadataSectionRange swift5_builtin;
   MetadataSectionRange swift5_capture;
+  MetadataSectionRange swift5_accessible_functions;
 };
 
 #ifdef __cplusplus

stdlib/public/runtime/AccessibleFunction.cpp

@@ -0,0 +1,80 @@
+//===---- AccessibleFunction.cpp - Swift protocol conformance checking ----===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Checking and caching of Swift accessible functions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ImageInspection.h"
+#include "Private.h"
+#include "swift/Basic/Lazy.h"
+#include "swift/Demangling/Demangler.h"
+#include "swift/Runtime/Concurrent.h"
+#include "swift/Runtime/Metadata.h"
+#include "Private.h"
+
+#include <cstdint>
+
+using namespace swift;
+
+#pragma mark Accessible function cache
+namespace {
+
+struct AccessibleFunctionsSection {
+  const AccessibleFunctionRecord *Begin, *End;
+
+  AccessibleFunctionsSection(const AccessibleFunctionRecord *begin,
+                             const AccessibleFunctionRecord *end)
+      : Begin(begin), End(end) {}
+
+  AccessibleFunctionsSection(const void *ptr, uintptr_t size) {
+    auto bytes = reinterpret_cast<const char *>(ptr);
+    Begin = reinterpret_cast<const AccessibleFunctionRecord *>(ptr);
+    End = reinterpret_cast<const AccessibleFunctionRecord *>(bytes + size);
+  }
+
+  const AccessibleFunctionRecord *begin() const { return Begin; }
+  const AccessibleFunctionRecord *end() const { return End; }
+};
+
+struct AccessibleFunctionsState {
+  ConcurrentReadableArray<AccessibleFunctionsSection> SectionsToScan;
+
+  AccessibleFunctionsState() {
+    initializeAccessibleFunctionsLookup();
+  }
+};
+
+static Lazy<AccessibleFunctionsState> Functions;
+
+} // end anonymous namespace
+
+static void _registerAccessibleFunctions(AccessibleFunctionsState &C,
+                                         AccessibleFunctionsSection section) {
+  C.SectionsToScan.push_back(section);
+}
+
+void swift::addImageAccessibleFunctionsBlockCallbackUnsafe(const void *functions,
+                                                           uintptr_t size) {
+  assert(
+      size % sizeof(AccessibleFunctionRecord) == 0 &&
+      "accessible function section not a multiple of AccessibleFunctionRecord");
+
+  auto &C = Functions.unsafeGetAlreadyInitialized();
+  _registerAccessibleFunctions(C, AccessibleFunctionsSection{functions, size});
+}
+
+void swift::addImageAccessibleFunctionsBlockCallback(const void *functions,
+                                                     uintptr_t size) {
+  Functions.get();
+  addImageAccessibleFunctionsBlockCallbackUnsafe(functions, size);
+}

stdlib/public/runtime/CMakeLists.txt

@@ -68,7 +68,8 @@ set(swift_runtime_sources
     ReflectionMirror.cpp
     RuntimeInvocationsTracking.cpp
     SwiftDtoa.cpp
-    SwiftTLSContext.cpp)
+    SwiftTLSContext.cpp
+    AccessibleFunction.cpp)
 
 # Acknowledge that the following sources are known.
 set(LLVM_OPTIONAL_SOURCES

stdlib/public/runtime/ImageInspection.h

@@ -73,6 +73,9 @@ void initializeTypeMetadataRecordLookup();
 /// Load the metadata from the image necessary to perform dynamic replacements.
 void initializeDynamicReplacementLookup();
 
+/// Load the metadata from the image necessary to find functions by name.
+void initializeAccessibleFunctionsLookup();
+
 // Callbacks to register metadata from an image to the runtime.
 void addImageProtocolsBlockCallback(const void *start, uintptr_t size);
 void addImageProtocolsBlockCallbackUnsafe(const void *start, uintptr_t size);
@@ -87,6 +90,10 @@ void addImageTypeMetadataRecordBlockCallbackUnsafe(const void *start,
 void addImageDynamicReplacementBlockCallback(const void *start, uintptr_t size,
                                              const void *start2,
                                              uintptr_t size2);
+void addImageAccessibleFunctionsBlockCallback(const void *start,
+                                              uintptr_t size);
+void addImageAccessibleFunctionsBlockCallbackUnsafe(const void *start,
+                                                    uintptr_t size);
 
 int lookupSymbol(const void *address, SymbolInfo *info);
 

stdlib/public/runtime/ImageInspectionCommon.cpp

@@ -81,6 +81,13 @@ void swift_addNewDSOImage(const void *addr) {
         replacements, dynamic_replacements.length, replacements_some,
         dynamic_replacements_some.length);
   }
+
+  const auto &accessible_funcs_section = sections->swift5_accessible_functions;
+  const void *functions =
+      reinterpret_cast<void *>(accessible_funcs_section.start);
+  if (accessible_funcs_section.length)
+    swift::addImageAccessibleFunctionsBlockCallback(
+        functions, accessible_funcs_section.length);
 }
 
 void swift::initializeProtocolLookup() {
@@ -131,6 +138,21 @@ void swift::initializeTypeMetadataRecordLookup() {
 void swift::initializeDynamicReplacementLookup() {
 }
 
+void swift::initializeAccessibleFunctionsLookup() {
+  const swift::MetadataSections *sections = registered;
+  while (true) {
+    const swift::MetadataSectionRange &functions =
+        sections->swift5_accessible_functions;
+    if (functions.length)
+      addImageAccessibleFunctionsBlockCallbackUnsafe(
+          reinterpret_cast<void *>(functions.start), functions.length);
+
+    if (sections->next == registered)
+      break;
+    sections = sections->next;
+  }
+}
+
 #ifndef NDEBUG
 
 SWIFT_RUNTIME_EXPORT
@@ -177,4 +199,4 @@ size_t swift_getMetadataSectionCount() {
 
 #endif // !defined(__MACH__)
 
-#endif // SWIFT_RUNTIME_IMAGEINSPECTIONCOMMON_H
+#endif // SWIFT_RUNTIME_IMAGEINSPECTIONCOMMON_H

stdlib/public/runtime/ImageInspectionCommon.h

@@ -34,6 +34,9 @@
 /// This lives within SEG_TEXT.
 #define MachODynamicReplacementSection "__swift5_replace"
 #define MachODynamicReplacementSomeSection "__swift5_replac2"
+/// The Mach-O section name for the section containing accessible functions.
+/// This lives within SEG_TEXT.
+#define MachOAccessibleFunctionsSection "__swift5_acfuncs"
 
 #define MachOTextSegment "__TEXT"
 

stdlib/public/runtime/ImageInspectionMachO.cpp

@@ -43,6 +43,8 @@ constexpr const char DynamicReplacementSection[] =
     MachODynamicReplacementSection;
 constexpr const char DynamicReplacementSomeSection[] =
     MachODynamicReplacementSomeSection;
+constexpr const char AccessibleFunctionsSection[] =
+    MachOAccessibleFunctionsSection;
 constexpr const char TextSegment[] = MachOTextSegment;
 
 #if __POINTER_WIDTH__ == 64
@@ -159,6 +161,12 @@ void swift::initializeDynamicReplacementLookup() {
                                 addImageDynamicReplacementBlockCallback>);
 }
 
+void swift::initializeAccessibleFunctionsLookup() {
+  REGISTER_FUNC(
+      addImageCallback<TextSegment, AccessibleFunctionsSection,
+                       addImageAccessibleFunctionsBlockCallbackUnsafe>);
+}
+
 #if SWIFT_STDLIB_HAS_DLADDR
 int swift::lookupSymbol(const void *address, SymbolInfo *info) {
   Dl_info dlinfo;

stdlib/public/runtime/ImageInspectionStatic.cpp

@@ -74,5 +74,14 @@ void swift::initializeDynamicReplacementLookup() {
     return;
   addImageDynamicReplacementBlockCallback(start1, size1, start2, size2);
 }
+void swift::initializeAccessibleFunctionsLookup() {
+  void *start;
+  uintptr_t size;
+  GET_SECTION_START_AND_SIZE(start, size, MachOTextSegment,
+                             MachOAccessibleFunctionsSection);
+  if (start == nullptr || size == 0)
+    return;
+  addImageAccessibleFunctionBlockCallbackUnsafe(start, size);
+}
 
 #endif // defined(__MACH__) && defined(SWIFT_RUNTIME_STATIC_IMAGE_INSPECTION)