[CMake] Enable building with UBSAN + clang-cl on windows

[dwang]

Summary

Currently both ASAN and UBSAN are supported on Windows but only ASAN is enabled in LLVM build system. This patch enables the option to build LLVM with UBSAN on windows.

Tested with clang-cl released in LLVM16.

[dwang]

• Update ubsan_ignorelist to exempt false-positives for 0-sized objects. Build crashes if those files are not exempted.
• Refine HandleLLVMOptions.cmake

[andrewng]

Apart from the two nits, the CMake changes LGTM, although I haven't tested the patch myself. I'm not particularly familiar with UBSAN, so can't really comment on the other changes to ubsan_ignorelist.txt.

llvm/cmake/modules/HandleLLVMOptions.cmake

969

Perhaps supported by clang-cl?

llvm/utils/sanitizers/ubsan_ignorelist.txt

24 ↗

(On Diff #526109)

Should add newline to the end of the file for "UNIX" consumers.

[dwang]

fix error message & newline at end of file

[dwang]

rebase

[dwang]

For the ubsan ignore list, the newly added files reported ubsan crashes similiar to the one reported in: https://github.com/llvm/llvm-project/issues/61775

[pgousseau]

llvm/cmake/modules/HandleLLVMOptions.cmake

971

Could we add a succint comment to explain -D_ITERATOR_DEBUG_LEVEL=0 ? Is it for performance or to workaround a bug?

[dwang]

llvm/cmake/modules/HandleLLVMOptions.cmake

971

This was a workaround for debug level mismatch between UBSAN runtime and another module. Somehow the bug does not reproduce on latest master branch anymore. I will remove this.

[dwang]

Workaround UBSAN false-positive on 0-sized objects with __declspec(empty_bases)

[dwang]

For the UBSAN crashes, I found an alternative workaround here: https://github.com/llvm/llvm-project/issues/31914. Since the errors only reproduce on windows, this seems like a cleaner fix.
I have pushed an update to outline the necessary changes.

[pgousseau]

LGTM!

[dwang]

@pgousseau Thanks for the review!
Can you maybe commit this patch for me? I do not have push permission.

[dwang]

• format code

[dwang]

rebase against main

llvm/cmake/modules/HandleLLVMOptions.cmake

if (LLVM_ENABLE_WARNINGS AND (LLVM_COMPILER_IS_GCC_COMPATIBLE OR CLANG_CL))
   add_flag_if_supported("-Wctad-maybe-unsupported" CTAD_MAYBE_UNSPPORTED_FLAG)
 endif (LLVM_ENABLE_WARNINGS AND (LLVM_COMPILER_IS_GCC_COMPATIBLE OR CLANG_CL))
 
 if (LLVM_COMPILER_IS_GCC_COMPATIBLE AND NOT LLVM_ENABLE_WARNINGS)
   append("-w" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
 endif()
 
 macro(append_common_sanitizer_flags)
-  if (NOT MSVC)
+  if (NOT MSVC OR CLANG_CL)
     # Append -fno-omit-frame-pointer and turn on debug info to get better
     # stack traces.
     add_flag_if_supported("-fno-omit-frame-pointer" FNO_OMIT_FRAME_POINTER)
     if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" AND
         NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELWITHDEBINFO")
       add_flag_if_supported("-gline-tables-only" GLINE_TABLES_ONLY)
     endif()
     # Use -O1 even in debug mode, otherwise sanitizers slowdown is too large.
elseif (LLVM_USE_SANITIZER STREQUAL "Address;Undefined" OR
             LLVM_USE_SANITIZER STREQUAL "Undefined;Address")
       append_common_sanitizer_flags()
       append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
       append("${LLVM_UBSAN_FLAGS}" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     else()
       message(FATAL_ERROR "This sanitizer not yet supported in a MinGW environment: ${LLVM_USE_SANITIZER}")
     endif()
   elseif(MSVC)
-    if (LLVM_USE_SANITIZER STREQUAL "Address")
-      append_common_sanitizer_flags()
-      append("/fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
-      if (NOT CLANG_CL)
-        # Not compatible with /RTC flags.
-        foreach (flags_opt_to_scrub
-            CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} CMAKE_C_FLAGS_${uppercase_CMAKE_BUILD_TYPE})
-          string (REGEX REPLACE "(^| )/RTC[1csu]*($| )" " "
-            "${flags_opt_to_scrub}" "${${flags_opt_to_scrub}}")
-        endforeach()
-      endif()
-      if (LINKER_IS_LLD_LINK)
-        if (LLVM_HOST_TRIPLE MATCHES "i[2-6]86-.*")
-          set(arch "i386")
-        else()
-          set(arch "x86_64")
-        endif()
+    if (NOT LLVM_USE_SANITIZER MATCHES "^(Address|Undefined|Address;Undefined|Undefined;Address)$")
+      message(FATAL_ERROR "This sanitizer not yet supported in the MSVC environment: ${LLVM_USE_SANITIZER}")
+    append_common_sanitizer_flags()
+      # Prepare ASAN runtime if needed
+      if (LLVM_USE_SANITIZER MATCHES ".*Address.*")
         if (${LLVM_USE_CRT_${uppercase_CMAKE_BUILD_TYPE}} MATCHES "^(MT|MTd)$")
           append("/wholearchive:clang_rt.asan-${arch}.lib /wholearchive:clang_rt.asan_cxx-${arch}.lib"
             CMAKE_EXE_LINKER_FLAGS)
           append("/wholearchive:clang_rt.asan_dll_thunk-${arch}.lib"
             CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
         else()
           append("clang_rt.asan_dynamic-${arch}.lib /wholearchive:clang_rt.asan_dynamic_runtime_thunk-${arch}.lib"
             CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
         endif()
       endif()
+    endif()
+    if (LLVM_USE_SANITIZER MATCHES ".*Address.*")
+      if (NOT CLANG_CL)
+        append("/fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+        # Not compatible with /RTC flags.
+        foreach (flags_opt_to_scrub
+            CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} CMAKE_C_FLAGS_${uppercase_CMAKE_BUILD_TYPE})
+          string (REGEX REPLACE "(^| )/RTC[1csu]*($| )" " "
+            "${flags_opt_to_scrub}" "${${flags_opt_to_scrub}}")
+        endforeach()
       else()
-      message(FATAL_ERROR "This sanitizer not yet supported in the MSVC environment: ${LLVM_USE_SANITIZER}")
+        append("-fsanitize=address" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+      endif()
+    endif()
+    if (LLVM_USE_SANITIZER MATCHES ".*Undefined.*")
+      if (NOT CLANG_CL)
+        message(FATAL_ERROR "This sanitizer is only supported by clang-cl: Undefined")
+      endif()
+      append(${LLVM_UBSAN_FLAGS} CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     endif()
   else()
     message(FATAL_ERROR "LLVM_USE_SANITIZER is not supported on this platform.")
   endif()
   if (LLVM_USE_SANITIZE_COVERAGE)
     append("-fsanitize=fuzzer-no-link" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
   endif()
   if (LLVM_USE_SANITIZER MATCHES ".*Undefined.*")

llvm/include/llvm/ADT/EpochTracker.h

 
 #include "llvm/Config/abi-breaking.h"
 
 #include <cstdint>
 
 namespace llvm {
 
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
+#define LLVM_DEBUGEPOCHBASE_HANDLEBASE_EMPTYBASE
 
 /// A base class for data structure classes wishing to make iterators
 /// ("handles") pointing into themselves fail-fast.  When building without
 /// asserts, this class is empty and does nothing.
 ///
 /// DebugEpochBase does not by itself track handles pointing into itself.  The
 /// expectation is that routines touching the handles will poll on
 /// isHandleInSync at appropriate points to assert that the handle they're using
public:
     /// Returns a pointer to the epoch word stored in the data structure
     /// this handle points into.  Can be used to check if two iterators point
     /// into the same data structure.
     const void *getEpochAddress() const { return EpochAddress; }
   };
 };
 
 #else
+#ifdef _MSC_VER
+#define LLVM_DEBUGEPOCHBASE_HANDLEBASE_EMPTYBASE __declspec(empty_bases)
+#else
+#define LLVM_DEBUGEPOCHBASE_HANDLEBASE_EMPTYBASE
+#endif // _MSC_VER
 
 class DebugEpochBase {
 public:
   void incrementEpoch() {}
 
   class HandleBase {
   public:
     HandleBase() = default;

llvm/include/llvm/ADT/SmallPtrSet.h

while (Bucket != End &&
             Bucket[-1] == SmallPtrSetImplBase::getTombstoneMarker())) {
       --Bucket;
     }
   }
 };
 
 /// SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet.
 template <typename PtrTy>
-class SmallPtrSetIterator : public SmallPtrSetIteratorImpl,
-                            DebugEpochBase::HandleBase {
+class LLVM_DEBUGEPOCHBASE_HANDLEBASE_EMPTYBASE SmallPtrSetIterator
+    : public SmallPtrSetIteratorImpl,
   using PtrTraits = PointerLikeTypeTraits<PtrTy>;
 
 public:
   using value_type = PtrTy;
   using reference = PtrTy;
   using pointer = PtrTy;
   using difference_type = std::ptrdiff_t;
   using iterator_category = std::forward_iterator_tag;

llvm/include/llvm/ADT/StringMap.h

public:
   }
 };
 
 /// StringMap - This is an unconventional map that is specialized for handling
 /// keys that are "strings", which are basically ranges of bytes. This does some
 /// funky memory allocation and hashing things to make it extremely efficient,
 /// storing the string data *after* the value in the map.
 template <typename ValueTy, typename AllocatorTy = MallocAllocator>
-class StringMap : public StringMapImpl,
-                  private detail::AllocatorHolder<AllocatorTy> {
+class LLVM_ALLOCATORHOLDER_EMPTYBASE StringMap
+    : public StringMapImpl,
   using AllocTy = detail::AllocatorHolder<AllocatorTy>;
 
 public:
   using MapEntryTy = StringMapEntry<ValueTy>;
 
   StringMap() : StringMapImpl(static_cast<unsigned>(sizeof(MapEntryTy))) {}
 
   explicit StringMap(unsigned InitialSize)

llvm/include/llvm/Support/AllocatorBase.h

 /// setting size and alignment based on the final type. These overloads are
 /// typically provided by a base class template \c AllocatorBase.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ALLOCATORBASE_H
 #define LLVM_SUPPORT_ALLOCATORBASE_H
 
+#ifdef _MSC_VER
+#define LLVM_ALLOCATORHOLDER_EMPTYBASE __declspec(empty_bases)
+#else
+#define LLVM_ALLOCATORHOLDER_EMPTYBASE
+#endif // _MSC_VER
+
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/MemAlloc.h"
 #include <type_traits>
 
 namespace llvm {
 
 /// CRTP base class providing obvious overloads for the core \c
 /// Allocate() methods of LLVM-style allocators.