Revert "Rewrite static section bounds discovery in Swift."

This reverts commit e107fa4.

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/_TestDiscovery/SectionBounds.swift
-+++ b/Sources/_TestDiscovery/SectionBounds.swift
+--- a/Sources/Testing/Discovery+Platform.swift
++++ b/Sources/Testing/Discovery+Platform.swift
 
  // ...
 +#elseif os(Classic)
@@ -211,30 +211,29 @@ 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 `SectionBounds.swift`:
+`CompilerSettings.cmake`, then define the symbols `testContentSectionBegin`,
+`testContentSectionEnd`, `typeMetadataSectionBegin`, and
+`typeMetadataSectionEnd` in `Discovery.cpp`.
 
 ```diff
---- a/Sources/_TestDiscovery/SectionBounds.swift
-+++ b/Sources/_TestDiscovery/SectionBounds.swift
+diff --git a/Sources/_TestingInternals/Discovery.cpp b/Sources/_TestingInternals/Discovery.cpp
  // ...
-+#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
++#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__("...");
 +#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
+ #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
- // ...
 ```
 
 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: Equatable, Hashable, CaseIterable {
+  enum Kind: Int, 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) -> some Sequence<SectionBounds> {
+private func _sectionBounds(_ kind: SectionBounds.Kind) -> [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) -> some Sequence<SectionBounds> {
+private func _sectionBounds(_ kind: SectionBounds.Kind) -> [SectionBounds] {
   struct Context {
     var kind: SectionBounds.Kind
     var result = [SectionBounds]()
@@ -297,63 +297,14 @@ private func _sectionBounds(_ kind: SectionBounds.Kind) -> some Sequence<Section
 ///   - kind: Ignored.
 ///
 /// - Returns: The empty array.
-private func _sectionBounds(_ kind: SectionBounds.Kind) -> some Sequence<SectionBounds> {
+private func _sectionBounds(_ kind: SectionBounds.Kind) -> [SectionBounds] {
   #warning("Platform-specific implementation missing: Runtime test discovery unavailable (dynamic)")
-  return EmptyCollection()
+  return []
 }
 #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.
 ///
@@ -362,15 +313,10 @@ extension UnsafeRawBufferPointer {
 ///
 /// - 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) -> 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
-  }
+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)
   let sb = SectionBounds(imageAddress: nil, buffer: buffer)
   return CollectionOfOne(sb)
 }

Sources/_TestDiscovery/TestContentRecord.swift

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

Sources/_TestingInternals/Discovery.cpp

@@ -10,11 +10,55 @@
 
 #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,6 +30,21 @@ 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.