Merge pull request #58499 from apple/jgrynspan/58498-remove-aligned_alloc-template

Revert "runtime: allow over-aligned types in the runtime"

Author: grynspan

include/swift/Runtime/Atomic.h

@@ -18,8 +18,6 @@
 #define SWIFT_RUNTIME_ATOMIC_H
 
 #include "swift/Runtime/Config.h"
-#include "swift/Runtime/Heap.h"
-
 #include <assert.h>
 #include <atomic>
 #if defined(_WIN64)
@@ -45,65 +43,13 @@
 
 namespace swift {
 namespace impl {
-
-// FIXME: why can we not use the definitions from Heap.h? It seems that we
-// would fail to collapse the structure down in that case and end up with size
-// differences.
-template <std::size_t Alignment_>
-struct requires_aligned_alloc {
-#if defined(__cpp_aligned_new)
- // If we have C++17 or newer we can use the alignment aware allocation
- // implicitly.
- static constexpr const bool value = false;
-#else
-#if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
- static constexpr const bool value =
- Alignment_ > std::alignment_of<std::max_align_t>::value &&
- Alignment_ > __STDCPP_DEFAULT_NEW_ALIGNMENT__;
-#else
- static constexpr const bool value =
- Alignment_ > std::alignment_of<std::max_align_t>::value;
-#endif
-#endif
-};
-
-template <std::size_t Alignment_,
- bool = requires_aligned_alloc<Alignment_>::value>
-struct aligned_alloc;
-
-template <std::size_t Alignment_>
-struct aligned_alloc<Alignment_, false> {};
-
-template <std::size_t Alignment_>
-struct aligned_alloc<Alignment_, true> {
- [[nodiscard]] void *operator new(std::size_t size) noexcept {
-#if defined(_WIN32)
- return _aligned_malloc(size, Alignment_);
-#else
- static_assert(Alignment_ >= sizeof(void *),
- "posix_memalign requires minimal alignment of pointer");
- void *ptr = nullptr;
- (void)posix_memalign(&ptr, Alignment_, size);
- return ptr;
-#endif
- }
-
- void operator delete(void *ptr) noexcept {
-#if defined(_WIN32)
- _aligned_free(ptr);
-#else
- free(ptr);
-#endif
- }
-};
-
 /// The default implementation for swift::atomic<T>, which just wraps
 /// std::atomic with minor differences.
 ///
 /// TODO: should we make this use non-atomic operations when the runtime
 /// is single-threaded?
 template <class Value, size_t Size = sizeof(Value)>
-class alignas(Size) atomic_impl : public aligned_alloc<Size> {
+class alignas(Size) atomic_impl {
  std::atomic<Value> value;
 public:
  constexpr atomic_impl(Value value) : value(value) {}

include/swift/Runtime/Heap.h

@@ -18,18 +18,11 @@
 #define SWIFT_RUNTIME_HEAP_H
 
 #include <cstddef>
-#include <cstdint>
-#include <cstdlib>
 #include <new>
-#include <type_traits>
 #include <utility>
 
 #include "swift/Runtime/Config.h"
 
-#if defined(_WIN32)
-#include <malloc.h>
-#endif
-
 namespace swift {
 // Allocate plain old memory. This is the generalized entry point
 // Never returns nil. The returned memory is uninitialized. 
@@ -85,77 +78,6 @@ static inline void swift_cxx_deleteObject(T *ptr) {
  swift_slowDealloc(ptr, sizeof(T), alignof(T) - 1);
  }
 }
-
-namespace {
-// This is C++17 and newer, so we simply re-define it. Since the codebase is
-// C++14, assume that DR1558 is accounted for and that unused parameters in alias
-// templates are guaranteed to ensure SFINAE and are not ignored.
-template <typename ...>
-using void_t = void;
-
-template <typename T, typename = void>
-struct is_aligned_alloc_aware : std::false_type {};
-
-template <typename T>
-struct is_aligned_alloc_aware<T, void_t<decltype(T::operator new(0))>>
- : std::true_type {};
-}
-
-template <std::size_t Alignment_>
-struct requires_aligned_alloc {
-#if defined(__cpp_aligned_new)
- // If we have C++17 or newer we can use the alignment aware allocation
- // implicitly.
- static constexpr const bool value = false;
-#else
-#if defined(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
- static constexpr const bool value =
- Alignment_ > std::alignment_of<std::max_align_t>::value &&
- Alignment_ > __STDCPP_DEFAULT_NEW_ALIGNMENT__;
-#else
- static constexpr const bool value =
- Alignment_ > std::alignment_of<std::max_align_t>::value;
-#endif
-#endif
-};
-
-template <std::size_t Alignment_,
- bool = requires_aligned_alloc<Alignment_>::value>
-struct aligned_alloc;
-
-template <std::size_t Alignment_>
-struct aligned_alloc<Alignment_, false> {};
-
-template <std::size_t Alignment_>
-struct aligned_alloc<Alignment_, true> {
- [[nodiscard]] void *operator new(std::size_t size) noexcept {
-#if defined(_WIN32)
- return _aligned_malloc(size, Alignment_);
-#else
- static_assert(Alignment_ >= sizeof(void *),
- "posix_memalign requires minimal alignment of pointer");
- void *ptr = nullptr;
- (void)posix_memalign(&ptr, Alignment_, size);
- return ptr;
-#endif
- }
-
- void operator delete(void *ptr) noexcept {
-#if defined(_WIN32)
- _aligned_free(ptr);
-#else
- free(ptr);
-#endif
- }
-
-#if defined(_WIN32)
- // FIXME: why is this even needed? This is not permitted as per the C++
- // standard new.delete.placement (§17.6.3.4).
- [[nodiscard]] void *operator new(std::size_t size, void *where) noexcept {
- return ::operator new(size, where);
- }
-#endif
-};
 }
 
 #endif // SWIFT_RUNTIME_HEAP_H

include/swift/Runtime/HeapObject.h

@@ -20,6 +20,7 @@
 #include <cstddef>
 #include <cstdint>
 #include "swift/Runtime/Config.h"
+#include "swift/Runtime/Heap.h"
 
 #if SWIFT_OBJC_INTEROP
 #include <objc/objc.h>

stdlib/public/Concurrency/Actor.cpp

@@ -580,8 +580,7 @@ class JobRef {
 /// achieved through careful arrangement of the storage for this in the
 /// DefaultActorImpl. The additional alignment requirements are
 /// enforced by static asserts below.
-class alignas(2 * sizeof(void *)) ActiveActorStatus
- : public swift::aligned_alloc<2 * sizeof(void *)> {
+class alignas(sizeof(void *) * 2) ActiveActorStatus {
 #if SWIFT_CONCURRENCY_ENABLE_PRIORITY_ESCALATION && SWIFT_POINTER_IS_4_BYTES
  uint32_t Flags;
  dispatch_lock_t DrainLock;

stdlib/public/Concurrency/AsyncLet.cpp

@@ -21,7 +21,6 @@
 #include "swift/ABI/Task.h"
 #include "swift/ABI/TaskOptions.h"
 #include "swift/Runtime/Mutex.h"
-#include "swift/Runtime/Heap.h"
 #include "swift/Runtime/HeapObject.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "TaskPrivate.h"
@@ -36,9 +35,7 @@
 using namespace swift;
 
 namespace {
-class alignas(Alignment_AsyncLet) AsyncLetImpl
- : public swift::aligned_alloc<Alignment_AsyncLet>,
- public ChildTaskStatusRecord {
+class alignas(Alignment_AsyncLet) AsyncLetImpl: public ChildTaskStatusRecord {
 public:
  // This is where we could define a Status or other types important for async-let
 

stdlib/public/Concurrency/TaskPrivate.h

@@ -26,7 +26,6 @@
 #include "swift/Runtime/DispatchShims.h"
 #include "swift/Runtime/Error.h"
 #include "swift/Runtime/Exclusivity.h"
-#include "swift/Runtime/Heap.h"
 #include "swift/Runtime/HeapObject.h"
 #include <atomic>
 #include <new>
@@ -526,12 +525,6 @@ class alignas(2 * sizeof(void*)) ActiveTaskStatus {
 #endif
 static_assert(sizeof(ActiveTaskStatus) == ACTIVE_TASK_STATUS_SIZE,
  "ActiveTaskStatus is of incorrect size");
-#if !defined(_WIN64)
-static_assert(sizeof(swift::atomic<ActiveTaskStatus>) == sizeof(std::atomic<ActiveTaskStatus>),
- "swift::atomic pads std::atomic, memory aliasing invariants violated");
-#endif
-static_assert(sizeof(swift::atomic<ActiveTaskStatus>) == sizeof(ActiveTaskStatus),
- "swift::atomic pads ActiveTaskStatus, memory aliasing invariants violated");
 
 /// The size of an allocator slab. We want the full allocation to fit into a
 /// 1024-byte malloc quantum. We subtract off the slab header size, plus a
@@ -553,7 +546,7 @@ struct AsyncTask::PrivateStorage {
 
  /// Storage for the ActiveTaskStatus. See doc for ActiveTaskStatus for size
  /// and alignment requirements.
- alignas(alignof(ActiveTaskStatus)) char StatusStorage[sizeof(ActiveTaskStatus)];
+ alignas(ActiveTaskStatus) char StatusStorage[sizeof(ActiveTaskStatus)];
 
  /// The allocator for the task stack.
  /// Currently 2 words + 8 bytes.

stdlib/public/SwiftShims/RefCount.h

@@ -626,9 +626,8 @@ class RefCountBitsT {
 
 typedef RefCountBitsT<RefCountIsInline> InlineRefCountBits;
 
-class alignas(2 * sizeof(void*)) SideTableRefCountBits
- : public swift::aligned_alloc<2 * sizeof(void *)>,
- public RefCountBitsT<RefCountNotInline> {
+class alignas(sizeof(void*) * 2) SideTableRefCountBits : public RefCountBitsT<RefCountNotInline>
+{
  uint32_t weakBits;
 
  public:

stdlib/public/runtime/KnownMetadata.cpp

@@ -15,7 +15,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/Runtime/Metadata.h"
-#include "swift/Runtime/Heap.h"
 #include "swift/Runtime/HeapObject.h"
 #include "swift/Runtime/Numeric.h"
 #include "MetadataImpl.h"
@@ -41,19 +40,19 @@ OpaqueValue *swift::swift_copyPOD(OpaqueValue *dest, OpaqueValue *src,
 namespace {
  // A type sized and aligned the way Swift wants Int128 (and Float80/Float128)
  // to be sized and aligned.
- struct alignas(16) int128_like : swift::aligned_alloc<16> {
+ struct alignas(16) int128_like {
  char data[16];
  };
 
  static_assert(MaximumAlignment == 16, "max alignment was hardcoded");
- struct alignas(16) int256_like : swift::aligned_alloc<16> {
+ struct alignas(16) int256_like {
  char data[32];
  };
- struct alignas(16) int512_like : swift::aligned_alloc<16> {
+ struct alignas(16) int512_like {
  char data[64];
  };
 
- struct alignas(16) float80_like : swift::aligned_alloc<16> {
+ struct alignas(16) float80_like {
  char data[10];
  };
 } // end anonymous namespace
@@ -90,8 +89,7 @@ namespace ctypes {
  // Types that are defined in the _Concurrency library
 
  // Default actor storage type.
- struct alignas(2 * alignof(void*)) BD
- : swift::aligned_alloc<2 * alignof(void*)> {
+ struct alignas(2 * alignof(void*)) BD {
  void *storage[NumWords_DefaultActor];
  };
 

stdlib/public/runtime/Metadata.cpp

@@ -24,7 +24,6 @@
 #include "swift/Runtime/Casting.h"
 #include "swift/Runtime/EnvironmentVariables.h"
 #include "swift/Runtime/ExistentialContainer.h"
-#include "swift/Runtime/Heap.h"
 #include "swift/Runtime/HeapObject.h"
 #include "swift/Runtime/Mutex.h"
 #include "swift/Runtime/Once.h"
@@ -6158,16 +6157,10 @@ void swift::blockOnMetadataDependency(MetadataDependency root,
 #if !SWIFT_STDLIB_PASSTHROUGH_METADATA_ALLOCATOR
 
 namespace {
- struct alignas(2 * sizeof(uintptr_t)) PoolRange
- : swift::aligned_alloc<2 * sizeof(uintptr_t)> {
+ struct alignas(sizeof(uintptr_t) * 2) PoolRange {
  static constexpr uintptr_t PageSize = 16 * 1024;
  static constexpr uintptr_t MaxPoolAllocationSize = PageSize / 2;
 
- constexpr PoolRange(char *Begin, size_t Remaining)
- : Begin(Begin), Remaining(Remaining) {}
-
- PoolRange() : Begin(nullptr), Remaining(0) {}
-
  /// The start of the allocation.
  char *Begin;
 

stdlib/public/runtime/MetadataCache.h

@@ -15,7 +15,6 @@
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/STLExtras.h"
 #include "swift/Runtime/Concurrent.h"
-#include "swift/Runtime/Heap.h"
 #include "swift/Runtime/Metadata.h"
 #include "swift/Runtime/Mutex.h"
 #include "swift/Runtime/AtomicWaitQueue.h"
@@ -621,9 +620,8 @@ const size_t PrivateMetadataTrackingAlignment = 16;
 
 /// The wait queue object that we create for metadata that are
 /// being actively initialized right now.
-struct alignas(PrivateMetadataTrackingAlignment) MetadataWaitQueue
- : swift::aligned_alloc<PrivateMetadataTrackingAlignment>,
- public AtomicWaitQueue<MetadataWaitQueue, ConcurrencyControl::LockType> {
+struct alignas(PrivateMetadataTrackingAlignment) MetadataWaitQueue :
+ public AtomicWaitQueue<MetadataWaitQueue, ConcurrencyControl::LockType> {
 
  /// A pointer to the completion context being used to complete this
  /// metadata. This is only actually filled in if:
@@ -682,8 +680,7 @@ struct alignas(PrivateMetadataTrackingAlignment) MetadataWaitQueue
 
 /// A record used to store information about an attempt to
 /// complete a metadata when there's no active worker thread.
-struct alignas(PrivateMetadataTrackingAlignment) SuspendedMetadataCompletion
- : swift::aligned_alloc<PrivateMetadataTrackingAlignment> {
+struct alignas(PrivateMetadataTrackingAlignment) SuspendedMetadataCompletion {
  MetadataDependency BlockingDependency;
  std::unique_ptr<PrivateMetadataCompletionContext> PersistentContext;