Fixed 32-bit build with SWIFT_CONCURRENCY_ENABLE_PRIORITY_ESCALATION

Author: nickolas-pohilets

include/swift/Basic/HeaderFooterLayout.h

@@ -15,22 +15,33 @@
 
 namespace swift {
 
-template <class Header, class Footer, size_t TotalSize>
-struct HeaderFooterLayoutPadding {
-private:
-  enum : ptrdiff_t {
-    maxFooterOffset = TotalSize - (ptrdiff_t)sizeof(Footer),
-    footerAlignment = (ptrdiff_t)alignof(Footer),
-    footerOffset = maxFooterOffset - (maxFooterOffset % footerAlignment),
-    size = footerOffset - (ptrdiff_t)sizeof(Header)
-  };
-  char padding[size];
+namespace detail {
+
+template<ptrdiff_t size>
+struct LayoutPadding {
+    char padding[size];
 };
+template<>
+struct LayoutPadding<0> {};
+
+template<class Header, class Footer, size_t TotalSize>
+struct HeaderFooterLayoutPaddingSize {
+    enum : ptrdiff_t {
+        maxFooterOffset = TotalSize - (ptrdiff_t)sizeof(Footer),
+        footerAlignment = (ptrdiff_t)alignof(Footer),
+        footerOffset = maxFooterOffset - (maxFooterOffset % footerAlignment),
+        value = footerOffset - (ptrdiff_t)sizeof(Header)
+    };
+};
+
+} //namespace detail
 
 template <class Header, class Footer, size_t TotalSize>
 struct HeaderFooterLayout
     : Header,
-      HeaderFooterLayoutPadding<Header, Footer, TotalSize>,
+      detail::LayoutPadding<
+        detail::HeaderFooterLayoutPaddingSize<Header, Footer, TotalSize>::value
+      >,
       Footer {};
 
 } // namespace swift

stdlib/public/Concurrency/Actor.cpp

@@ -1006,13 +1006,13 @@ class DefaultActorImplHeader : public HeapObject {
   // escalation logic
   Mutex drainLock;
 #else
+  // TODO (rokhinip): Make this a flagset
+  bool isDistributedRemoteActor;
   // Note: There is some padding that is added here by the compiler in order to
   // enforce alignment. This is space that is available for us to use in
   // the future
   alignas(sizeof(ActiveActorStatus)) char StatusStorage[sizeof(ActiveActorStatus)];
 #endif
-  // TODO (rokhinip): Make this a flagset
-  bool isDistributedRemoteActor;
 };
 
 // All the fields accessed under the actor's lock should be moved
@@ -1036,6 +1036,12 @@ class DefaultActorImplFooter {
 #endif
 };
 
+// We can't use sizeof(DefaultActor) since the alignment requirement on the
+// default actor means that we have some padding added when calculating
+// sizeof(DefaultActor). However that padding isn't available for us to use
+// in DefaultActorImpl.
+enum { DefaultActorSize = sizeof(void *) * NumWords_DefaultActor + sizeof(HeapObject) };
+
 /// The default actor implementation.
 ///
 /// Ownership of the actor is subtle.  Jobs are assumed to keep the actor
@@ -1087,9 +1093,13 @@ class DefaultActorImplFooter {
 /// exist yet. As a result, the subset of rules that currently apply
 /// are (1), (3), (5), (6).
 class DefaultActorImpl
-    : public HeaderFooterLayout<DefaultActorImplHeader, DefaultActorImplFooter,
-                                sizeof(HeapObject) +
-                                    sizeof(void *) * NumWords_DefaultActor> {
+    : public HeaderFooterLayout<DefaultActorImplHeader, DefaultActorImplFooter, DefaultActorSize> {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+  /// Dummy variable, used to compute sizeWithoutTrailingPadding()
+  /// Must not be accessed
+  char const bytesPastTheEnd[1];
+#pragma clang diagnostic pop
 public:
   /// Properly construct an actor, except for the heap header.
   void initialize(bool isDistributedRemote = false) {
@@ -1159,6 +1169,13 @@ class DefaultActorImpl
   }
 #endif /* !SWIFT_CONCURRENCY_ACTORS_AS_LOCKS */
 
+  static constexpr size_t sizeWithoutTrailingPadding() {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+    return offsetof(DefaultActorImpl, bytesPastTheEnd);
+#pragma clang diagnostic pop
+  }
+
 private:
 #if !SWIFT_CONCURRENCY_ACTORS_AS_LOCKS
 #if SWIFT_CONCURRENCY_ENABLE_PRIORITY_ESCALATION
@@ -1213,11 +1230,7 @@ class NonDefaultDistributedActorImpl : public HeapObject {
 
 } /// end anonymous namespace
 
-// We can't use sizeof(DefaultActor) since the alignment requirement on the
-// default actor means that we have some padding added when calculating
-// sizeof(DefaultActor). However that padding isn't available for us to use
-// in DefaultActorImpl.
-static_assert(sizeof(DefaultActorImpl) <= ((sizeof(void *) * NumWords_DefaultActor) + sizeof(HeapObject)) &&
+static_assert(DefaultActorImpl::sizeWithoutTrailingPadding() == DefaultActorSize &&
               alignof(DefaultActorImpl) <= alignof(DefaultActor),
               "DefaultActorImpl doesn't fit in DefaultActor");
 #if !SWIFT_CONCURRENCY_ACTORS_AS_LOCKS