CMakeLists: match the hardening-check flag detection that passed CI

Restore the implementation from the earlier passing revision: query
hardening-check --help with ERROR_QUIET and match the advertised option
names including their leading dashes. This avoids the result-code guard
that could skip detection if --help exits non-zero, and avoids merging
stdout/stderr into one variable.

.gitea/workflows/ci.yml

@@ -232,7 +232,8 @@ jobs:
           rm -rf build
           cmake -S . -B build -G Ninja -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
             -DCMAKE_C_FLAGS=--coverage -DCMAKE_CXX_FLAGS=--coverage \
-            -DCMAKE_BUILD_TYPE=Debug -DDISABLE_TSAN=ON
+            -DCMAKE_BUILD_TYPE=Debug -DDISABLE_TSAN=ON \
+            -DUSE_SIMD_FALLBACK=ON
           ninja -C build
           ccache -s
 

CMakeLists.txt

@@ -383,27 +383,26 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR AND BUILD_TESTING)
   if(NOT CMAKE_CROSSCOMPILING)
     find_program(HARDENING_CHECK hardening-check)
     if(HARDENING_CHECK)
-      # Not all versions of hardening-check support the same options, so query
-      # the help output before using architecture-specific skips.
+      # Control flow integrity (CET) is x86-only and branch protection (PAC/BTI)
+      # is arm64-only, so ignore whichever doesn't apply. Newer hardening-check
+      # versions spell some of these flags with hyphens, so pick a supported
+      # form at configure time.
       execute_process(
         COMMAND ${HARDENING_CHECK} --help
-        OUTPUT_VARIABLE hardening_check_help
-        ERROR_VARIABLE hardening_check_help
-        OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_STRIP_TRAILING_WHITESPACE
-        RESULT_VARIABLE hardening_check_help_result)
-      set(hardening_check_arch_flags "")
-      if(hardening_check_help_result EQUAL 0)
-        # Control flow integrity (CET) is x86-only and branch protection
-        # (PAC/BTI) is arm64-only, so ignore whichever doesn't apply.
+        OUTPUT_VARIABLE _hardening_help
+        ERROR_QUIET)
       if(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64 OR CMAKE_SYSTEM_PROCESSOR
                                                     STREQUAL arm64)
-          if(hardening_check_help MATCHES "nocfprotection")
-            list(APPEND hardening_check_arch_flags --nocfprotection)
+        if(_hardening_help MATCHES "--nocfprotection")
+          set(hardening_check_arch_flags --nocfprotection)
+        elseif(_hardening_help MATCHES "--no-cf-protection")
+          set(hardening_check_arch_flags --no-cf-protection)
         endif()
       else()
-          if(hardening_check_help MATCHES "nobranchprotection")
-            list(APPEND hardening_check_arch_flags --nobranchprotection)
-          endif()
+        if(_hardening_help MATCHES "--nobranchprotection")
+          set(hardening_check_arch_flags --nobranchprotection)
+        elseif(_hardening_help MATCHES "--no-branch-protection")
+          set(hardening_check_arch_flags --no-branch-protection)
         endif()
       endif()
       add_test(

ConflictSet.cpp

@@ -3080,7 +3080,7 @@ Node *firstGeqPhysical(Node *n, const TrivialSpan key) {
 #define PRESERVE_NONE
 #endif
 
-#if __has_attribute(musttail) && __has_attribute(preserve_none)
+#if __has_attribute(musttail)
 constexpr bool kEnableInterleaved = true;
 #else
 constexpr bool kEnableInterleaved = false;
@@ -5040,9 +5040,12 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
     assert(allPointWrites || sorted);
 #endif
 
-    if (kEnableInterleaved && count > 1) {
+    if constexpr (kEnableInterleaved) {
+      if (count > 1) {
         interleavedWrites(writes, count, InternalVersionT(writeVersion));
-    } else {
+        return;
+      }
+    }
     for (int i = 0; i < count; ++i) {
       const auto &w = writes[i];
       auto begin = TrivialSpan(w.begin.p, w.begin.len);
@@ -5056,7 +5059,6 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
       }
     }
   }
-  }
 
   void addWrites(const WriteRange *writes, int count, int64_t writeVersion) {
 #if !USE_64_BIT

include/ConflictSet.h

@@ -132,6 +132,13 @@ struct __attribute__((__visibility__("default"))) ConflictSet {
 
 private:
   Impl *impl;
+#if defined(__cplusplus) && __cplusplus <= 199711L
+  /* Declared private and left undefined to prevent copying in C++98/C++03.
+     The compiler would otherwise implicitly generate public copy operations,
+     which share the opaque Impl* and cause a double-free. */
+  ConflictSet(const ConflictSet &);
+  ConflictSet &operator=(const ConflictSet &);
+#endif
 };
 } /* namespace weaselab */