Revert D61236418

Summary:
This diff reverts D61236418
unicorn continuous tests are down after this and asan canaries are crashlooping

Differential Revision: D61514775

fbshipit-source-id: 96c61ccc8fd1af1fdc27c28271bb3f2e2e06d6b5

Author: generatedunixname89002005232357

folly/container/detail/F14Table.cpp

@@ -30,6 +30,10 @@ namespace detail {
 // everywhere or disabled everywhere.
 void F14LinkCheck<getF14IntrinsicsMode()>::check() noexcept {}
 
+#if FOLLY_F14_VECTOR_INTRINSICS_AVAILABLE
+EmptyTagVectorType kEmptyTagVector = {};
+#endif
+
 //// Debug and ASAN stuff
 
 bool tlsPendingSafeInserts(std::ptrdiff_t delta) {

folly/container/detail/F14Table.h

@@ -474,25 +474,11 @@ using TagVector = __uint128_t;
 constexpr std::size_t kRequiredVectorAlignment =
     constexpr_max(std::size_t{16}, alignof(max_align_t));
 
-struct alignas(kRequiredVectorAlignment) F14EmptyTagVector {
-  std::array<uint8_t, sizeof(void*)> tags_{};
-  FOLLY_CONSTEVAL F14EmptyTagVector() noexcept {
-    for (auto& t : tags_) {
-      t = 1;
-    }
-  }
-};
+using EmptyTagVectorType = std::aligned_storage_t<
+    sizeof(TagVector) + kRequiredVectorAlignment,
+    alignof(max_align_t)>;
 
-FOLLY_EXPORT inline F14EmptyTagVector& getF14EmptyTagVector() noexcept {
-  static constexpr F14EmptyTagVector instance;
-  auto const raw = reinterpret_cast<uintptr_t>(&instance);
-  FOLLY_SAFE_DCHECK(
-      (raw % kRequiredVectorAlignment) == 0,
-      raw,
-      " not aligned to ",
-      kRequiredVectorAlignment);
-  return const_cast<F14EmptyTagVector&>(instance);
-}
+FOLLY_EXPORT extern EmptyTagVectorType kEmptyTagVector;
 
 template <typename ItemType>
 struct alignas(kRequiredVectorAlignment) F14Chunk {
@@ -538,14 +524,20 @@ struct alignas(kRequiredVectorAlignment) F14Chunk {
 
   std::array<aligned_storage_for_t<Item>, kAllocatedCapacity> rawItems_;
 
-  FOLLY_EXPORT static F14Chunk* getSomeEmptyInstance() noexcept {
-    return &reinterpret_cast<F14Chunk&>(getF14EmptyTagVector());
-  }
-
-  bool isEmptyInstance() const noexcept {
-    F14EmptyTagVector self;
-    std::memcpy(&self, this, sizeof(self));
-    return self.tags_ == F14EmptyTagVector{}.tags_;
+  static F14Chunk* emptyInstance() {
+    auto raw = reinterpret_cast<char*>(&kEmptyTagVector);
+    if constexpr (kRequiredVectorAlignment > alignof(max_align_t)) {
+      auto delta = kRequiredVectorAlignment -
+          (reinterpret_cast<uintptr_t>(raw) % kRequiredVectorAlignment);
+      raw += delta;
+    }
+    auto rv = reinterpret_cast<F14Chunk*>(raw);
+    FOLLY_SAFE_DCHECK(
+        (reinterpret_cast<uintptr_t>(rv) % kRequiredVectorAlignment) == 0,
+        reinterpret_cast<uintptr_t>(rv),
+        " not aligned to ",
+        kRequiredVectorAlignment);
+    return rv;
   }
 
   void clear() {
@@ -585,7 +577,7 @@ struct alignas(kRequiredVectorAlignment) F14Chunk {
 
   void setCapacityScale(std::size_t scale) {
     FOLLY_SAFE_DCHECK(
-        !isEmptyInstance() && scale > 0 &&
+        this != emptyInstance() && scale > 0 &&
             scale < (std::size_t{1} << kCapacityScaleBits),
         "");
     if constexpr (kCapacityScaleBits == 4) {
@@ -618,7 +610,8 @@ struct alignas(kRequiredVectorAlignment) F14Chunk {
   std::size_t tag(std::size_t index) const { return tags_[index]; }
 
   void setTag(std::size_t index, std::size_t tag) {
-    FOLLY_SAFE_DCHECK(!isEmptyInstance() && tag >= 0x80 && tag <= 0xff, "");
+    FOLLY_SAFE_DCHECK(
+        this != emptyInstance() && tag >= 0x80 && tag <= 0xff, "");
     FOLLY_SAFE_CHECK(tags_[index] == 0, "");
     tags_[index] = static_cast<uint8_t>(tag);
   }
@@ -741,9 +734,8 @@ struct alignas(kRequiredVectorAlignment) F14Chunk {
   }
 
   bool occupied(std::size_t index) const {
-    auto const tag = tags_[index];
-    FOLLY_SAFE_DCHECK((tag & ~1) == 0 || (tag & 0x80) != 0, "");
-    return to_signed(tag) < 0;
+    FOLLY_SAFE_DCHECK(tags_[index] == 0 || (tags_[index] & 0x80) != 0, "");
+    return tags_[index] != 0;
   }
 
   Item* itemAddr(std::size_t i) const {
@@ -1243,7 +1235,7 @@ class F14Table : public Policy {
  private:
   //////// begin fields
 
-  ChunkPtr chunks_{Chunk::getSomeEmptyInstance()};
+  ChunkPtr chunks_{Chunk::emptyInstance()};
   SizeAndChunkShiftAndPackedBegin<ItemIter, kEnableItemIteration>
       sizeAndChunkShiftAndPackedBegin_;
 
@@ -2060,8 +2052,7 @@ class F14Table : public Policy {
   void initialReserve(std::size_t desiredCapacity) {
     FOLLY_SAFE_DCHECK(size() == 0, "");
     FOLLY_SAFE_DCHECK(chunkShift() == 0, "");
-    FOLLY_SAFE_DCHECK(!!chunks_);
-    FOLLY_SAFE_DCHECK(chunks_->isEmptyInstance(), "");
+    FOLLY_SAFE_DCHECK(chunks_ == Chunk::emptyInstance(), "");
     if (desiredCapacity == 0) {
       return;
     }
@@ -2279,8 +2270,7 @@ class F14Table : public Policy {
     // We want to support the pattern
     //   map.reserve(map.size() + 2); auto& r1 = map[k1]; auto& r2 = map[k2];
     debugModeOnReserve(capacity);
-    FOLLY_SAFE_DCHECK(!!chunks_);
-    if (chunks_->isEmptyInstance()) {
+    if (chunks_ == Chunk::emptyInstance()) {
       initialReserve(capacity);
     } else {
       reserveImpl(capacity);
@@ -2364,8 +2354,7 @@ class F14Table : public Policy {
  private:
   template <bool Reset>
   void clearImpl() noexcept {
-    FOLLY_SAFE_DCHECK(!!chunks_);
-    if (chunks_->isEmptyInstance()) {
+    if (chunks_ == Chunk::emptyInstance()) {
       FOLLY_SAFE_DCHECK(empty() && bucket_count() == 0, "");
       return;
     }
@@ -2419,7 +2408,7 @@ class F14Table : public Policy {
       std::size_t rawSize =
           chunkAllocSize(chunkCount(), chunks_->capacityScale());
 
-      chunks_ = Chunk::getSomeEmptyInstance();
+      chunks_ = Chunk::emptyInstance();
       sizeAndChunkShiftAndPackedBegin_.setChunkCount(1);
 
       this->afterReset(origSize, origCapacity, rawAllocation, rawSize);
@@ -2577,7 +2566,7 @@ class F14Table : public Policy {
     }
 
     FOLLY_SAFE_DCHECK(
-        (chunks_->isEmptyInstance()) == (bucket_count() == 0), "");
+        (chunks_ == Chunk::emptyInstance()) == (bucket_count() == 0), "");
 
     std::size_t n1 = 0;
     std::size_t n2 = 0;