stdlib: fix the problem swept under the rug in 58a97f1

The `-Winvalid-offsetof` warning is valid in this case. `offsetof` is
being applied to types with a non-standard layout. The layout of this
type is undefined by the specification. There is no guarantee that the
type layout is uniform across all ABIs. It is not possible to portably
compute the offset statically, especially efficiently.

Author: compnerd

include/swift/Runtime/STLCompatibility.h

@@ -42,4 +42,21 @@ bit_cast(const Source &src) noexcept {
 }
 #endif
 
+namespace {
+// NOTE: this is not possible to mark as `constexpr` as `reinterpret_cast` is
+// not permitted in `constexpr` statements. Additionally, even if we were able
+// to get away from the `reinterpret_cast`, we cannot de-reference the `nullptr`
+// in a `constexpr` statement. Finally, because we are checking the offsets of
+// members in non-standard layouts, we must delay this check until runtime as
+// the static computation is not well defined by the language standard.
+inline namespace __swift {
+template <typename Type, typename PMFType>
+size_t offset_of(PMFType Type::*member) {
+  return reinterpret_cast<uintptr_t>(std::addressof(static_cast<Type *>(nullptr)->*member));
+}
+}
+
+#define offset_of(T,d) __swift::offset_of(&T::d)
+}
+
 #endif

stdlib/public/Concurrency/DispatchGlobalExecutor.cpp

@@ -67,17 +67,6 @@ struct MinimalDispatchObjectHeader {
   void *Linkage;
 };
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wgnu-offsetof-extensions"
-static_assert(
-    offsetof(Job, metadata) == offsetof(MinimalDispatchObjectHeader, VTable),
-    "Job Metadata field must match location of Dispatch VTable field.");
-static_assert(offsetof(Job, SchedulerPrivate[Job::DispatchLinkageIndex]) ==
-                  offsetof(MinimalDispatchObjectHeader, Linkage),
-              "Dispatch Linkage field must match Job "
-              "SchedulerPrivate[DispatchLinkageIndex].");
-#pragma clang diagnostic pop
-
 /// The function passed to dispatch_async_f to execute a job.
 static void __swift_run_job(void *_job) {
   SwiftJob *job = (SwiftJob*) _job;

stdlib/public/Concurrency/ExecutorChecks.cpp

@@ -53,16 +53,6 @@ static_assert((SwiftJobPriority)swift::JobPriority::Unspecified
 
 // Job (has additional fields not exposed via SwiftJob)
 static_assert(sizeof(swift::Job) >= sizeof(SwiftJob));
-static_assert(offsetof(swift::Job, metadata) == offsetof(SwiftJob, metadata));
-#if !SWIFT_CONCURRENCY_EMBEDDED
-static_assert(offsetof(swift::Job, refCounts) == offsetof(SwiftJob, refCounts));
-#else
-static_assert(offsetof(swift::Job, embeddedRefcount) == offsetof(SwiftJob, refCounts));
-#endif
-static_assert(offsetof(swift::Job, SchedulerPrivate) == offsetof(SwiftJob, schedulerPrivate));
-static_assert(offsetof(swift::Job, SchedulerPrivate[0]) == offsetof(SwiftJob, schedulerPrivate[0]));
-static_assert(offsetof(swift::Job, SchedulerPrivate[1]) == offsetof(SwiftJob, schedulerPrivate[1]));
-static_assert(offsetof(swift::Job, Flags) == offsetof(SwiftJob, flags));
 
 // SerialExecutorRef
 static_assert(sizeof(swift::SerialExecutorRef) == sizeof(SwiftExecutorRef));
@@ -74,3 +64,31 @@ static_assert((SwiftClockId)swift::swift_clock_id_suspending
               == SwiftSuspendingClock);
 
 #pragma clang diagnostic pop
+
+#if !defined(NDEBUG)
+namespace swift {
+namespace concurrency {
+struct StaticAssertions {
+  StaticAssertions() {
+    assert(offset_of(swift::Job, metadata) == offset_of(SwiftJob, metadata));
+#if !SWIFT_CONCURRENCY_EMBEDDED
+    assert(offset_of(swift::Job, refCounts) == offset_of(SwiftJob, refCounts));
+#else
+    assert(offset_of(swift::Job, embeddedRefcount) == offset_of(SwiftJob, refCounts));
+#endif
+    assert(offset_of(swift::Job, SchedulerPrivate) == offset_of(SwiftJob, schedulerPrivate));
+    assert(offset_of(swift::Job, SchedulerPrivate[0]) == offset_of(SwiftJob, schedulerPrivate[0]));
+    assert(offset_of(swift::Job, SchedulerPrivate[1]) == offset_of(SwiftJob, schedulerPrivate[1]));
+    assert(offset_of(swift::Job, Flags) == offset_of(SwiftJob, flags));
+
+    assert(offset_of(Job, metadata) == offset_of(MinimalDispatchObjectHeader, VTable) &&
+           "Job Metadata field must match location of Dispatch VTable field.");
+    assert(offset_of(Job, SchedulerPrivate[Job::DispatchLinkageIndex]) == offset_of(MinimalDispatchObjectHeader, Linkage) &&
+                  "Dispatch Linkage field must match Job SchedulerPrivate[DispatchLinkageIndex].");
+  }
+}
+}
+}
+
+static swift::concurrency::StaticAssertions assertions;
+#endif

stdlib/public/runtime/Metadata.cpp

@@ -39,13 +39,15 @@
 #include "swift/Runtime/Metadata.h"
 #include "swift/Runtime/Once.h"
 #include "swift/Runtime/Portability.h"
+#include "swift/Runtime/STLCompatibility.h"
 #include "swift/Strings.h"
 #include "swift/Threading/Mutex.h"
 #include "llvm/ADT/StringExtras.h"
 #include <algorithm>
 #include <cctype>
 #include <cinttypes>
 #include <condition_variable>
+#include <memory>
 #include <new>
 #include <unordered_set>
 #include <vector>
@@ -338,9 +340,9 @@ namespace {
                       MetadataWaitQueue::Worker &worker,
                       MetadataRequest request,
                       const Metadata *candidate)
-      : VariadicMetadataCacheEntryBase(key, worker,
-                                       PrivateMetadataState::Complete,
-                                       const_cast<Metadata*>(candidate)) {}
+        : VariadicMetadataCacheEntryBase(key, worker,
+                                         PrivateMetadataState::Complete,
+                                         const_cast<Metadata*>(candidate)) {}
 
     AllocationResult allocate(const Metadata *candidate) {
       swift_unreachable("always short-circuited");
@@ -362,9 +364,9 @@ namespace {
                       MetadataRequest request,
                       const TypeContextDescriptor *description,
                       const void * const *arguments)
-      : VariadicMetadataCacheEntryBase(key, worker,
-                                       PrivateMetadataState::Allocating,
-                                       /*candidate*/ nullptr) {}
+        : VariadicMetadataCacheEntryBase(key, worker,
+                                         PrivateMetadataState::Allocating,
+                                         /*candidate*/ nullptr) {}
 
     AllocationResult allocate(const TypeContextDescriptor *description,
                               const void * const *arguments) {
@@ -438,19 +440,6 @@ namespace {
   };
 } // end anonymous namespace
 
-namespace swift {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Winvalid-offsetof"
-  struct StaticAssertGenericMetadataCacheEntryValueOffset {
-    static_assert(
-      offsetof(GenericCacheEntry, Value) ==
-      offsetof(swift::GenericMetadataCacheEntry<InProcess::StoredPointer>,
-               Value),
-      "The generic metadata cache entry layout mismatch");
-  };
-#pragma clang diagnostic pop
-}
-
 namespace {
   class GenericMetadataCache :
     public MetadataCache<GenericCacheEntry, GenericMetadataCacheTag> {
@@ -8264,3 +8253,18 @@ const HeapObject *swift_getKeyPathImpl(const void *pattern,
 #if defined(__MACH__)
 asm(".linker_option \"-lc++\"\n");
 #endif // defined(__MACH__)
+
+#if !defined(NDEBUG)
+namespace swift {
+namespace runtime {
+struct StaticAssertions {
+  StaticAssertions() {
+    assert(offset_of(GenericCacheEntry, Value) == offset_of(swift::GenericMetadataCacheEntry<InProcess::StoredPointer>, Value) &&
+           "GenericMetadataCacheEntry layout mismatch");
+  }
+};
+}
+}
+
+static swift::runtime::StaticAssertions assertions;
+#endif

stdlib/public/runtime/MetadataCache.h

@@ -1611,8 +1611,6 @@ class VariadicMetadataCacheEntryBase :
   bool matchesKey(const MetadataCacheKey &key) const {
     return key == getKey();
   }
-
-  friend struct StaticAssertGenericMetadataCacheEntryValueOffset;
 };
 
 template <class EntryType, uint16_t Tag>