Rewrite static section bounds discovery in Swift.

This PR rewrites the static section bounds discovery code in Swift (replacing
the current C++ implementation.) We are making use of `@_silgen_name` here to
name the section bounds symbols that are defined by the linker, so we'll want to
get the core team's approval before merging.

Author: grynspan

Documentation/Porting.md

@@ -136,8 +136,8 @@ emits section information into the resource fork on Classic, you would use the
 to load that information:
 
 ```diff
---- a/Sources/Testing/Discovery+Platform.swift
-+++ b/Sources/Testing/Discovery+Platform.swift
+--- a/Sources/_TestDiscovery/SectionBounds.swift
++++ b/Sources/_TestDiscovery/SectionBounds.swift
 
  // ...
 +#elseif os(Classic)
@@ -211,29 +211,30 @@ start with `"SWT_"`).
 If your platform does not support dynamic linking and loading, you will need to
 use static linkage instead. Define the `"SWT_NO_DYNAMIC_LINKING"` compiler
 conditional for your platform in both `Package.swift` and
-`CompilerSettings.cmake`, then define the symbols `testContentSectionBegin`,
-`testContentSectionEnd`, `typeMetadataSectionBegin`, and
-`typeMetadataSectionEnd` in `Discovery.cpp`.
+`CompilerSettings.cmake`, then define the symbols `_testContentSectionBegin`,
+`_testContentSectionEnd`, `_typeMetadataSectionBegin`, and
+`_typeMetadataSectionEnd` in `SectionBounds.swift`:
 
 ```diff
-diff --git a/Sources/_TestingInternals/Discovery.cpp b/Sources/_TestingInternals/Discovery.cpp
+--- a/Sources/_TestDiscovery/SectionBounds.swift
++++ b/Sources/_TestDiscovery/SectionBounds.swift
  // ...
-+#elif defined(macintosh)
-+extern "C" const char testContentSectionBegin __asm__("...");
-+extern "C" const char testContentSectionEnd __asm__("...");
-+#if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
-+extern "C" const char typeMetadataSectionBegin __asm__("...");
-+extern "C" const char typeMetadataSectionEnd __asm__("...");
++#elseif os(Classic)
++@_silgen_name(raw: "...") private nonisolated(unsafe) var _testContentSectionBegin: CChar
++@_silgen_name(raw: "...") private nonisolated(unsafe) var _testContentSectionEnd: CChar
++#if !SWT_NO_LEGACY_TEST_DISCOVERY
++@_silgen_name(raw: "...") private nonisolated(unsafe) var _typeMetadataSectionBegin: CChar
++@_silgen_name(raw: "...") private nonisolated(unsafe) var _typeMetadataSectionEnd: CChar
 +#endif
  #else
- #warning Platform-specific implementation missing: Runtime test discovery unavailable (static)
- static const char testContentSectionBegin = 0;
- static const char& testContentSectionEnd = testContentSectionBegin;
- #if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
- static const char typeMetadataSectionBegin = 0;
- static const char& typeMetadataSectionEnd = typeMetadataSectionBegin;
- #endif
+ #warning("Platform-specific implementation missing: Runtime test discovery unavailable (static)")
+ private nonisolated(unsafe) var _testContentSectionBegin: Void
+ private nonisolated(unsafe) var _testContentSectionEnd: Void
+ #if !SWT_NO_LEGACY_TEST_DISCOVERY
+ private nonisolated(unsafe) var _typeMetadataSectionBegin: Void
+ private nonisolated(unsafe) var _typeMetadataSectionEnd: Void
  #endif
+ // ...
 ```
 
 These symbols must have unique addresses corresponding to the first byte of the

Sources/_TestDiscovery/SectionBounds.swift

@@ -23,7 +23,7 @@ struct SectionBounds: Sendable {
 
   /// An enumeration describing the different sections discoverable by the
   /// testing library.
-  enum Kind: Int, Equatable, Hashable, CaseIterable {
+  enum Kind: Equatable, Hashable, CaseIterable {
     /// The test content metadata section.
     case testContent
 
@@ -146,7 +146,7 @@ private let _startCollectingSectionBounds: Void = {
 ///
 /// - Returns: An array of structures describing the bounds of all known test
 ///   content sections in the current process.
-private func _sectionBounds(_ kind: SectionBounds.Kind) -> [SectionBounds] {
+private func _sectionBounds(_ kind: SectionBounds.Kind) -> some Sequence<SectionBounds> {
   _startCollectingSectionBounds
   return _sectionBounds.withUnsafeMutablePointers { sectionBounds, lock in
     pthread_mutex_lock(lock)
@@ -169,7 +169,7 @@ private import SwiftShims // For MetadataSections
 ///
 /// - Returns: An array of structures describing the bounds of all known test
 ///   content sections in the current process.
-private func _sectionBounds(_ kind: SectionBounds.Kind) -> [SectionBounds] {
+private func _sectionBounds(_ kind: SectionBounds.Kind) -> some Sequence<SectionBounds> {
   struct Context {
     var kind: SectionBounds.Kind
     var result = [SectionBounds]()
@@ -297,14 +297,63 @@ private func _sectionBounds(_ kind: SectionBounds.Kind) -> some Sequence<Section
 ///   - kind: Ignored.
 ///
 /// - Returns: The empty array.
-private func _sectionBounds(_ kind: SectionBounds.Kind) -> [SectionBounds] {
+private func _sectionBounds(_ kind: SectionBounds.Kind) -> some Sequence<SectionBounds> {
   #warning("Platform-specific implementation missing: Runtime test discovery unavailable (dynamic)")
-  return []
+  return EmptyCollection()
 }
 #endif
 #else
 // MARK: - Statically-linked implementation
 
+/// The bounds of the statically-linked sections of interest to the testing
+/// library.
+///
+/// We use `@_silgen_name(raw:)` to reference these linker-defined symbols.
+/// Then, to get their addresses, we must use `&` (`withPointer(to:)` is not
+/// guaranteed to avoid a copy in this context.) Hence, they must also be
+/// declared `var` rather than `let`, but they should be treated as read-only.
+#if SWT_TARGET_OS_APPLE
+@_silgen_name(raw: "section$start$__DATA_CONST$__swift5_tests") private nonisolated(unsafe) var _testContentSectionBegin: CChar
+@_silgen_name(raw: "section$end$__DATA_CONST$__swift5_tests") private nonisolated(unsafe) var _testContentSectionEnd: CChar
+#if !SWT_NO_LEGACY_TEST_DISCOVERY
+@_silgen_name(raw: "section$start$__TEXT$__swift5_types") private nonisolated(unsafe) var _typeMetadataSectionBegin: CChar
+@_silgen_name(raw: "section$end$__TEXT$__swift5_types") private nonisolated(unsafe) var _typeMetadataSectionEnd: CChar
+#endif
+#elseif os(WASI)
+@_silgen_name(raw: "__start_swift5_tests") private nonisolated(unsafe) var _testContentSectionBegin: CChar
+@_silgen_name(raw: "__stop_swift5_tests") private nonisolated(unsafe) var _testContentSectionEnd: CChar
+#if !SWT_NO_LEGACY_TEST_DISCOVERY
+@_silgen_name(raw: "__start_swift5_type_metadata") private nonisolated(unsafe) var _typeMetadataSectionBegin: CChar
+@_silgen_name(raw: "__stop_swift5_type_metadata") private nonisolated(unsafe) var _typeMetadataSectionEnd: CChar
+#endif
+#else
+#warning("Platform-specific implementation missing: Runtime test discovery unavailable (static)")
+private nonisolated(unsafe) var _testContentSectionBegin: Void
+private nonisolated(unsafe) var _testContentSectionEnd: Void
+#if !SWT_NO_LEGACY_TEST_DISCOVERY
+private nonisolated(unsafe) var _typeMetadataSectionBegin: Void
+private nonisolated(unsafe) var _typeMetadataSectionEnd: Void
+#endif
+
+extension UnsafeRawBufferPointer {
+  /// Construct an empty buffer.
+  fileprivate init(_: Void = (), sectionBegin _: UnsafeRawPointer, sectionEnd _: UnsafeRawPointer) {
+    self.init(start: nil, count: 0)
+  }
+}
+#endif
+
+extension UnsafeRawBufferPointer {
+  /// Construct a buffer representing a section's byte bounds.
+  ///
+  /// - Parameters:
+  ///   - sectionBegin: The address of the first byte of the section.
+  ///   - sectionEnd: The address of the first byte _after_ the section.
+  @_disfavoredOverload fileprivate init(sectionBegin: UnsafeRawPointer, sectionEnd: UnsafeRawPointer) {
+    self.init(start: sectionBegin, count: sectionEnd - sectionBegin)
+  }
+}
+
 /// The common implementation of ``SectionBounds/all(_:)`` for platforms that do
 /// not support dynamic linking.
 ///
@@ -313,10 +362,15 @@ private func _sectionBounds(_ kind: SectionBounds.Kind) -> [SectionBounds] {
 ///
 /// - Returns: A structure describing the bounds of the type metadata section
 ///   contained in the same image as the testing library itself.
-private func _sectionBounds(_ kind: SectionBounds.Kind) -> CollectionOfOne<SectionBounds> {
-  var (baseAddress, count): (UnsafeRawPointer?, Int) = (nil, 0)
-  swt_getStaticallyLinkedSectionBounds(kind.rawValue, &baseAddress, &count)
-  let buffer = UnsafeRawBufferPointer(start: baseAddress, count: count)
+private func _sectionBounds(_ kind: SectionBounds.Kind) -> some Sequence<SectionBounds> {
+  let buffer = switch kind {
+  case .testContent:
+    UnsafeRawBufferPointer(sectionBegin: &_testContentSectionBegin, sectionEnd: &_testContentSectionEnd)
+#if !SWT_NO_LEGACY_TEST_DISCOVERY
+  case .typeMetadata:
+    UnsafeRawBufferPointer(sectionBegin: &_typeMetadataSectionBegin, sectionEnd: &_typeMetadataSectionEnd)
+#endif
+  }
   let sb = SectionBounds(imageAddress: nil, buffer: buffer)
   return CollectionOfOne(sb)
 }

Sources/_TestDiscovery/TestContentRecord.swift

@@ -336,7 +336,8 @@ extension DiscoverableAsTestContent where Self: ~Copyable {
     validateMemoryLayout()
 
     let result = SectionBounds.all(.typeMetadata).lazy.flatMap { sb in
-      stride(from: sb.buffer.baseAddress!, to: sb.buffer.baseAddress! + sb.buffer.count, by: SWTTypeMetadataRecordByteCount).lazy
+      stride(from: 0, to: sb.buffer.count, by: SWTTypeMetadataRecordByteCount).lazy
+        .map { sb.buffer.baseAddress! + $0 }
         .compactMap { swt_getType(fromTypeMetadataRecord: $0, ifNameContains: "__🟡$") }
         .map { unsafeBitCast($0, to: Any.Type.self) }
         .compactMap { $0 as? any TestContentRecordContainer.Type }

Sources/_TestingInternals/Discovery.cpp

@@ -10,55 +10,11 @@
 
 #include "Discovery.h"
 
-#include <algorithm>
 #if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
 #include <cstdint>
 #include <cstring>
 #include <type_traits>
-#endif
-
-#if defined(SWT_NO_DYNAMIC_LINKING)
-#pragma mark - Statically-linked section bounds
 
-#if defined(__APPLE__)
-extern "C" const char testContentSectionBegin __asm("section$start$__DATA_CONST$__swift5_tests");
-extern "C" const char testContentSectionEnd __asm("section$end$__DATA_CONST$__swift5_tests");
-#if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
-extern "C" const char typeMetadataSectionBegin __asm__("section$start$__TEXT$__swift5_types");
-extern "C" const char typeMetadataSectionEnd __asm__("section$end$__TEXT$__swift5_types");
-#endif
-#elif defined(__wasi__)
-extern "C" const char testContentSectionBegin __asm__("__start_swift5_tests");
-extern "C" const char testContentSectionEnd __asm__("__stop_swift5_tests");
-#if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
-extern "C" const char typeMetadataSectionBegin __asm__("__start_swift5_type_metadata");
-extern "C" const char typeMetadataSectionEnd __asm__("__stop_swift5_type_metadata");
-#endif
-#else
-#warning Platform-specific implementation missing: Runtime test discovery unavailable (static)
-static const char testContentSectionBegin = 0;
-static const char& testContentSectionEnd = testContentSectionBegin;
-#if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
-static const char typeMetadataSectionBegin = 0;
-static const char& typeMetadataSectionEnd = typeMetadataSectionBegin;
-#endif
-#endif
-
-static constexpr const char *const staticallyLinkedSectionBounds[][2] = {
-  { &testContentSectionBegin, &testContentSectionEnd },
-#if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
-  { &typeMetadataSectionBegin, &typeMetadataSectionEnd },
-#endif
-};
-
-void swt_getStaticallyLinkedSectionBounds(size_t kind, const void **outSectionBegin, size_t *outByteCount) {
-  auto [sectionBegin, sectionEnd] = staticallyLinkedSectionBounds[kind];
-  *outSectionBegin = sectionBegin;
-  *outByteCount = std::distance(sectionBegin, sectionEnd);
-}
-#endif
-
-#if !defined(SWT_NO_LEGACY_TEST_DISCOVERY)
 #pragma mark - Swift ABI
 
 #if defined(__PTRAUTH_INTRINSICS__)

Sources/_TestingInternals/include/Discovery.h

@@ -30,21 +30,6 @@ SWT_IMPORT_FROM_STDLIB void swift_enumerateAllMetadataSections(
 );
 #endif
 
-#pragma mark - Statically-linked section bounds
-
-/// Get the bounds of a statically linked section in this image.
-///
-/// - Parameters:
-///   - kind: The value of `SectionBounds.Kind.rawValue` for the given section.
-///   - outSectionBegin: On return, a pointer to the first byte of the section.
-///   - outByteCount: On return, the number of bytes in the section.
-///
-/// - Note: This symbol is _declared_, but not _defined_, on platforms with
-///   dynamic linking because the `SWT_NO_DYNAMIC_LINKING` C++ macro (not the
-///   Swift compiler conditional of the same name) is not consistently declared
-///   when Swift files import the `_TestingInternals` C++ module.
-SWT_EXTERN void swt_getStaticallyLinkedSectionBounds(size_t kind, const void *_Nullable *_Nonnull outSectionBegin, size_t *outByteCount);
-
 #pragma mark - Legacy test discovery
 
 /// The size, in bytes, of a Swift type metadata record.