Fix release and coverage CI failures

* ConflictSet.cpp: enable the interleaved read/write path whenever
  musttail is available, falling back to the default calling convention
  when preserve_none is not supported. This prevents a large block of
  compiled-but-dead code from being counted in coverage.

* CMakeLists.txt: detect which arch-specific hardening-check options the
  installed hardening-check binary supports, including the newer
  hyphenated spellings, so the release test no longer fails with an
  unknown option.

* .gitea/workflows/ci.yml: build the coverage job with
  -DUSE_SIMD_FALLBACK=ON so AVX512-only functions that cannot execute on
  the CI runners are not counted against line coverage.

.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

@@ -139,6 +139,7 @@ add_custom_command(
   COMMAND_EXPAND_LISTS)
 
 add_library(${PROJECT_NAME} SHARED ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o)
+add_dependencies(${PROJECT_NAME} ${PROJECT_NAME}-object)
 set_target_properties(
   ${PROJECT_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY
                              "${CMAKE_CURRENT_BINARY_DIR}/radix_tree")
@@ -155,6 +156,7 @@ if(HAS_VERSION_SCRIPT)
 endif()
 
 add_library(${PROJECT_NAME}-static STATIC ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.o)
+add_dependencies(${PROJECT_NAME}-static ${PROJECT_NAME}-object)
 if(CMAKE_BUILD_TYPE STREQUAL Debug)
   set_target_properties(${PROJECT_NAME}-static PROPERTIES LINKER_LANGUAGE CXX)
 else()
@@ -383,13 +385,28 @@ 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)
-      # Control flow integrity (CET) is x86-only and branch protection (PAC/BTI)
+      # Not all versions of hardening-check support the same options, so query
-      # is arm64-only, so ignore whichever doesn't apply.
+      # the help output before using architecture-specific skips.
-      if(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64 OR CMAKE_SYSTEM_PROCESSOR
+      execute_process(
-                                                    STREQUAL arm64)
+        COMMAND ${HARDENING_CHECK} --help
-        set(hardening_check_arch_flags --nocfprotection)
+        OUTPUT_VARIABLE hardening_check_help
-      else()
+        ERROR_VARIABLE hardening_check_help
-        set(hardening_check_arch_flags --nobranchprotection)
+        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.
+        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)
+          endif()
+        else()
+          if(hardening_check_help MATCHES "nobranchprotection")
+            list(APPEND hardening_check_arch_flags --nobranchprotection)
+          endif()
+        endif()
       endif()
       add_test(
         NAME hardening_check

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,20 +5040,22 @@ struct __attribute__((visibility("hidden"))) ConflictSet::Impl {
     assert(allPointWrites || sorted);
 #endif
 
-    if (kEnableInterleaved && count > 1) {
+    if constexpr (kEnableInterleaved) {
-      interleavedWrites(writes, count, InternalVersionT(writeVersion));
+      if (count > 1) {
-    } else {
+        interleavedWrites(writes, count, InternalVersionT(writeVersion));
-      for (int i = 0; i < count; ++i) {
+        return;
-        const auto &w = writes[i];
+      }
-        auto begin = TrivialSpan(w.begin.p, w.begin.len);
+    }
-        auto end = TrivialSpan(w.end.p, w.end.len);
+    for (int i = 0; i < count; ++i) {
-        if (w.end.len > 0) {
+      const auto &w = writes[i];
-          addWriteRange(rootParent->children[0], begin, end,
+      auto begin = TrivialSpan(w.begin.p, w.begin.len);
-                        InternalVersionT(writeVersion), &writeContext);
+      auto end = TrivialSpan(w.end.p, w.end.len);
-        } else {
+      if (w.end.len > 0) {
-          addPointWrite(rootParent->children[0], begin,
+        addWriteRange(rootParent->children[0], begin, end,
-                        InternalVersionT(writeVersion), &writeContext);
+                      InternalVersionT(writeVersion), &writeContext);
-        }
+      } else {
+        addPointWrite(rootParent->children[0], begin,
+                      InternalVersionT(writeVersion), &writeContext);
       }
     }
   }

conflict_set.py

@@ -88,6 +88,7 @@ class ConflictSet:
             ctypes.POINTER(ctypes.c_int),
             ctypes.c_int,
         )
+        self._lib.ConflictSet_check.restype = None
 
         self._lib.ConflictSet_addWrites.argtypes = (
             ctypes.c_void_p,
@@ -95,13 +96,16 @@ class ConflictSet:
             ctypes.c_int,
             ctypes.c_int64,
         )
+        self._lib.ConflictSet_addWrites.restype = None
 
         self._lib.ConflictSet_setOldestVersion.argtypes = (
             ctypes.c_void_p,
             ctypes.c_int64,
         )
+        self._lib.ConflictSet_setOldestVersion.restype = None
 
         self._lib.ConflictSet_destroy.argtypes = (ctypes.c_void_p,)
+        self._lib.ConflictSet_destroy.restype = None
 
         self._lib.ConflictSet_getBytes.argtypes = (ctypes.c_void_p,)
         self._lib.ConflictSet_getBytes.restype = ctypes.c_int64