Merge pull request #4342 from swiftwasm/maxd/main-merge

Resolve build issues with upstream `main`

Author: MaxDesiatov

include/swift/Runtime/Concurrent.h

@@ -520,10 +520,14 @@ template <class ElemTy> struct ConcurrentReadableArray {
     // These are marked as ref-qualified (the &) to make sure they can't be
     // called on temporaries, since the temporary would be destroyed before the
     // return value can be used, making it invalid.
-    const ElemTy *begin() & { return Start; }
-    const ElemTy *end() & { return Start + Count; }
+    const ElemTy *begin() const& { return Start; }
+    const ElemTy *end() const& { return Start + Count; }
+    const ElemTy& operator [](size_t index) const& {
+      assert(index < count() && "out-of-bounds access to snapshot element");
+      return Start[index];
+    }
 
-    size_t count() { return Count; }
+    size_t count() const { return Count; }
   };
 
   // This type cannot be safely copied or moved.

lib/IRGen/GenStruct.cpp

@@ -734,6 +734,52 @@ namespace {
                                                              isOutlined);
     }
 
+    void assignWithCopy(IRGenFunction &IGF, Address destAddr, Address srcAddr,
+                        SILType T, bool isOutlined) const override {
+      if (auto copyConstructor = findCopyConstructor()) {
+        emitCopyWithCopyConstructor(IGF, T, copyConstructor,
+                                    srcAddr.getAddress(),
+                                    destAddr.getAddress());
+        return;
+      }
+      StructTypeInfoBase<AddressOnlyClangRecordTypeInfo, FixedTypeInfo,
+                         ClangFieldInfo>::assignWithCopy(IGF, destAddr,
+                                                         srcAddr, T,
+                                                         isOutlined);
+    }
+
+    void initializeWithTake(IRGenFunction &IGF, Address dest, Address src,
+                            SILType T, bool isOutlined) const override {
+      if (auto copyConstructor = findCopyConstructor()) {
+        emitCopyWithCopyConstructor(IGF, T, copyConstructor,
+                                    src.getAddress(),
+                                    dest.getAddress());
+        destroy(IGF, src, T, isOutlined);
+        return;
+      }
+
+      StructTypeInfoBase<AddressOnlyClangRecordTypeInfo, FixedTypeInfo,
+                         ClangFieldInfo>::initializeWithTake(IGF, dest,
+                                                             src, T,
+                                                             isOutlined);
+    }
+
+    void assignWithTake(IRGenFunction &IGF, Address dest, Address src, SILType T,
+                        bool isOutlined) const override {
+      if (auto copyConstructor = findCopyConstructor()) {
+        emitCopyWithCopyConstructor(IGF, T, copyConstructor,
+                                    src.getAddress(),
+                                    dest.getAddress());
+        destroy(IGF, src, T, isOutlined);
+        return;
+      }
+
+      StructTypeInfoBase<AddressOnlyClangRecordTypeInfo, FixedTypeInfo,
+                         ClangFieldInfo>::assignWithTake(IGF, dest,
+                                                         src, T,
+                                                         isOutlined);
+    }
+
     llvm::NoneType getNonFixedOffsets(IRGenFunction &IGF) const { return None; }
     llvm::NoneType getNonFixedOffsets(IRGenFunction &IGF, SILType T) const {
       return None;

stdlib/public/SwiftShims/MetadataSections.h

@@ -21,6 +21,10 @@
 #ifndef SWIFT_STDLIB_SHIMS_METADATASECTIONS_H
 #define SWIFT_STDLIB_SHIMS_METADATASECTIONS_H
 
+#if defined(__cplusplus) && !defined(__swift__)
+#include <atomic>
+#endif
+
 #include "SwiftStddef.h"
 #include "SwiftStdint.h"
 
@@ -36,7 +40,12 @@ typedef struct MetadataSectionRange {
 } MetadataSectionRange;
 
 
-/// Identifies the address space ranges for the Swift metadata required by the Swift runtime.
+/// Identifies the address space ranges for the Swift metadata required by the
+/// Swift runtime.
+///
+/// \warning If you change the size of this structure by adding fields, it is an
+///   ABI-breaking change on platforms that use it. Make sure to increment
+///   \c CurrentSectionMetadataVersion if you do.
 struct MetadataSections {
   __swift_uintptr_t version;
 
@@ -56,20 +65,23 @@ struct MetadataSections {
   /// loader (i.e. no equivalent of \c __dso_handle or \c __ImageBase), this
   /// field is ignored and should be set to \c nullptr.
   ///
+  /// \bug When imported into Swift, this field is not atomic.
+  ///
   /// \sa swift_addNewDSOImage()
+#if defined(__swift__) || defined(__STDC_NO_ATOMICS__)
   const void *baseAddress;
+#elif defined(__cplusplus)
+  std::atomic<const void *> baseAddress;
+#else
+  _Atomic(const void *) baseAddress;
+#endif
 
-  /// `next` and `prev` are used by the runtime to construct a
-  /// circularly doubly linked list to quickly iterate over the metadata
-  /// from each image loaded into the address space.  These are invasive
-  /// to enable the runtime registration, which occurs at image load time, to
-  /// be allocation-free as it is invoked from an image constructor function
-  /// context where the system may not yet be ready to perform allocations.
-  /// Additionally, avoiding the allocation enables a fast load operation, which
-  /// directly impacts application load time.
-  struct MetadataSections *next;
-  struct MetadataSections *prev;
-
+  /// Unused.
+  ///
+  /// These pointers (or the space they occupy) can be repurposed without
+  /// causing ABI breakage. Set them to \c nullptr.
+  void *unused0;
+  void *unused1;
 
   MetadataSectionRange swift5_protocols;
   MetadataSectionRange swift5_protocol_conformances;

stdlib/public/core/BridgeObjectiveC.swift

@@ -476,33 +476,33 @@ public struct AutoreleasingUnsafeMutablePointer<Pointee /* TODO : class */>
     }
   }
 
-  /// Explicit construction from an UnsafeMutablePointer.		
-  ///		
-  /// This is inherently unsafe; UnsafeMutablePointer assumes the		
-  /// referenced memory has +1 strong ownership semantics, whereas		
-  /// AutoreleasingUnsafeMutablePointer implies +0 semantics.		
-  ///		
-  /// - Warning: Accessing `pointee` as a type that is unrelated to		
-  ///   the underlying memory's bound type is undefined.		
-  @_transparent		
-  public init<U>(@_nonEphemeral _ from: UnsafeMutablePointer<U>) {		
-   self._rawValue = from._rawValue		
-  }		
-
-  /// Explicit construction from an UnsafeMutablePointer.		
-  ///		
-  /// Returns nil if `from` is nil.		
-  ///		
-  /// This is inherently unsafe; UnsafeMutablePointer assumes the		
-  /// referenced memory has +1 strong ownership semantics, whereas		
-  /// AutoreleasingUnsafeMutablePointer implies +0 semantics.		
-  ///		
-  /// - Warning: Accessing `pointee` as a type that is unrelated to		
-  ///   the underlying memory's bound type is undefined.		
-  @_transparent		
+  /// Explicit construction from an UnsafeMutablePointer.
+  ///
+  /// This is inherently unsafe; UnsafeMutablePointer assumes the
+  /// referenced memory has +1 strong ownership semantics, whereas
+  /// AutoreleasingUnsafeMutablePointer implies +0 semantics.
+  ///
+  /// - Warning: Accessing `pointee` as a type that is unrelated to
+  ///   the underlying memory's bound type is undefined.
+  @_transparent
+  public init<U>(@_nonEphemeral _ from: UnsafeMutablePointer<U>) {
+   self._rawValue = from._rawValue
+  }
+
+  /// Explicit construction from an UnsafeMutablePointer.
+  ///
+  /// Returns nil if `from` is nil.
+  ///
+  /// This is inherently unsafe; UnsafeMutablePointer assumes the
+  /// referenced memory has +1 strong ownership semantics, whereas
+  /// AutoreleasingUnsafeMutablePointer implies +0 semantics.
+  ///
+  /// - Warning: Accessing `pointee` as a type that is unrelated to
+  ///   the underlying memory's bound type is undefined.
+  @_transparent
   public init?<U>(@_nonEphemeral _ from: UnsafeMutablePointer<U>?) {
-   guard let unwrapped = from else { return nil }		
-   self.init(unwrapped)		
+   guard let unwrapped = from else { return nil }
+   self.init(unwrapped)
   }
 
   /// Explicit construction from a UnsafePointer.

stdlib/public/core/LazyCollection.swift

@@ -13,20 +13,20 @@
 public protocol LazyCollectionProtocol: Collection, LazySequenceProtocol 
 where Elements: Collection {	}
 
-extension LazyCollectionProtocol {		
-   // Lazy things are already lazy		
-   @inlinable // protocol-only		
-   public var lazy: LazyCollection<Elements> {		
-     return elements.lazy		
-   }		
- }		
-		
- extension LazyCollectionProtocol where Elements: LazyCollectionProtocol {		
-   // Lazy things are already lazy		
-   @inlinable // protocol-only		
-   public var lazy: Elements {		
-     return elements		
-   }		
+extension LazyCollectionProtocol {
+   // Lazy things are already lazy
+   @inlinable // protocol-only
+   public var lazy: LazyCollection<Elements> {
+     return elements.lazy
+   }
+ }
+
+ extension LazyCollectionProtocol where Elements: LazyCollectionProtocol {
+   // Lazy things are already lazy
+   @inlinable // protocol-only
+   public var lazy: Elements {
+     return elements
+   }
  }
 
 /// A collection containing the same elements as a `Base` collection,

stdlib/public/core/UnsafePointer.swift

@@ -600,25 +600,25 @@ public struct UnsafeMutablePointer<Pointee>: _Pointer {
     self.init(mutating: unwrapped)
   }
 
-  /// Creates an immutable typed pointer referencing the same memory as the		
-  /// given mutable pointer.		
-  ///		
-  /// - Parameter other: The pointer to convert.		
-  @_transparent		
+  /// Creates an immutable typed pointer referencing the same memory as the
+  /// given mutable pointer.
+  ///
+  /// - Parameter other: The pointer to convert.
+  @_transparent
   public init(@_nonEphemeral _ other: UnsafeMutablePointer<Pointee>) {
-   self._rawValue = other._rawValue		
-  }		
+   self._rawValue = other._rawValue
+  }
 
-  /// Creates an immutable typed pointer referencing the same memory as the		
-  /// given mutable pointer.		
-  ///		
-  /// - Parameter other: The pointer to convert. If `other` is `nil`, the		
-  ///   result is `nil`.		
-  @_transparent		
+  /// Creates an immutable typed pointer referencing the same memory as the
+  /// given mutable pointer.
+  ///
+  /// - Parameter other: The pointer to convert. If `other` is `nil`, the
+  ///   result is `nil`.
+  @_transparent
   public init?(@_nonEphemeral _ other: UnsafeMutablePointer<Pointee>?) {
-   guard let unwrapped = other else { return nil }		
-   self.init(unwrapped)		
-  }		
+   guard let unwrapped = other else { return nil }
+   self.init(unwrapped)
+  }
 
 
   /// Allocates uninitialized memory for the specified number of instances of

stdlib/public/core/UnsafeRawPointer.swift

@@ -235,31 +235,31 @@ public struct UnsafeRawPointer: _Pointer {
     _rawValue = unwrapped._rawValue
   }
 
-  /// Creates a new raw pointer from the given typed pointer.		
-  ///		
-  /// Use this initializer to explicitly convert `other` to an `UnsafeRawPointer`		
-  /// instance. This initializer creates a new pointer to the same address as		
-  /// `other` and performs no allocation or copying.		
-  ///		
-  /// - Parameter other: The typed pointer to convert.		
-  @_transparent		
+  /// Creates a new raw pointer from the given typed pointer.
+  ///
+  /// Use this initializer to explicitly convert `other` to an `UnsafeRawPointer`
+  /// instance. This initializer creates a new pointer to the same address as
+  /// `other` and performs no allocation or copying.
+  ///
+  /// - Parameter other: The typed pointer to convert.
+  @_transparent
   public init<T>(@_nonEphemeral _ other: UnsafeMutablePointer<T>) {
-   _rawValue = other._rawValue		
-  }		
+   _rawValue = other._rawValue
+  }
 
-  /// Creates a new raw pointer from the given typed pointer.		
-  ///		
-  /// Use this initializer to explicitly convert `other` to an `UnsafeRawPointer`		
-  /// instance. This initializer creates a new pointer to the same address as		
-  /// `other` and performs no allocation or copying.		
-  ///		
-  /// - Parameter other: The typed pointer to convert. If `other` is `nil`, the		
-  ///   result is `nil`.		
-  @_transparent		
+  /// Creates a new raw pointer from the given typed pointer.
+  ///
+  /// Use this initializer to explicitly convert `other` to an `UnsafeRawPointer`
+  /// instance. This initializer creates a new pointer to the same address as
+  /// `other` and performs no allocation or copying.
+  ///
+  /// - Parameter other: The typed pointer to convert. If `other` is `nil`, the
+  ///   result is `nil`.
+  @_transparent
   public init?<T>(@_nonEphemeral _ other: UnsafeMutablePointer<T>?) {
-   guard let unwrapped = other else { return nil }		
-   _rawValue = unwrapped._rawValue		
-  }		
+   guard let unwrapped = other else { return nil }
+   _rawValue = unwrapped._rawValue
+  }
 
   /// Deallocates the previously allocated memory block referenced by this pointer.
   ///