[dfsan] Add "DataFlow" option to LLVM_USE_SANITIZER

[zbrid]

Summary

This patch add the dataflow option to LLVM_USE_SANITIZER and documents
it.

I built the libcxx and cxx targets with this option and then ran ninja check-cxx.
Edit: Some failing tests: (see bug: https://bugs.llvm.org/show_bug.cgi?id=45621)

Unexpected failures
libcxx/atomics/atomics.align/align.pass.sh.cpp
std/strings/string.conversions/stoull.pass.cpp
std/utilities/charconv/charconv.to.chars/integral.pass.cpp
std/utilities/tuple/tuple.tuple/tuple.apply/apply_large_arity.pass.cpp

[zbrid]

Oh I found some lit tests that fail by running check-cxx. I'll address that.

[zbrid]

Update config.py to support data flow sanitizer

[morehouse]

clang/docs/DataFlowSanitizer.rst

24

Let's add some explanation here about why we want to build libc++ with dfsan.

26

This sentence doesn't seem too helpful. I think most people reading this doc will know how to build LLVM/Clang.

I suggest either removing this sentence or expanding it to explain that we want to build LLVM/Clang separately from libc++ since we only want dfsan instrumentation on libc++.

libcxx/utils/libcxx/test/config.py

913

I'm not 100% sure what the sanitizer-new-delete feature is used for, but I don't think we want it for dfsan since it doesn't use a custom allocator.

[zbrid]

Update documentation based on Matt's comments.

[broadwaylamb]

libcxx/utils/libcxx/test/config.py

912

I'm not sure we need a new feature if none of the tests actually use the feature.

[morehouse]

clang/docs/DataFlowSanitizer.rst

23

Nit: "How to build libc++"

[zbrid]

libcxx/utils/libcxx/test/config.py

912

What is are these features used for? Will not having this mean some tests fail as a result of dfsan being enabled?

[zbrid]

Update nit from Matt

[zbrid]

• Remove dfsan feature based on review comment

[zbrid]

Gonna land this and file a bug for the failing tests. The tests shouldn't block anyone upstream since I'm only adding a build mode. I'll do some more digging into those failures in the future.

[zbrid]

Rebase

[zbrid]

Bug: https://bugs.llvm.org/show_bug.cgi?id=45621

clang/docs/DataFlowSanitizer.rst

 
 DataFlowSanitizer is a generalised dynamic data flow analysis.
 
 Unlike other Sanitizer tools, this tool is not designed to detect a
 specific class of bugs on its own.  Instead, it provides a generic
 dynamic data flow analysis framework to be used by clients to help
 detect application-specific issues within their own code.
 
+How to build libc++ with DFSan
+==============================
+
+DFSan requires either all of your code to be instrumented or for uninstrumented
+functions to be listed as``uninstrumented`` in the `ABI list`_.
+
+If you'd like to have instrumented libc++ functions, then you need to build it
+with DFSan instrumentation from source. Here is an example of how to build
+libc++ and the libc++ ABI with data flow sanitizer instrumentation.
+
+.. code-block:: console
+  cd libcxx-build
+
+  # An example using ninja
+  cmake -GNinja path/to/llvm-project/llvm \
+    -DCMAKE_C_COMPILER=clang \
+    -DCMAKE_CXX_COMPILER=clang++ \
+    -DLLVM_USE_SANITIZER="DataFlow" \
+    -DLLVM_ENABLE_LIBCXX=ON \
+    -DLLVM_ENABLE_PROJECTS="libcxx;libcxxabi"
+
+  ninja cxx cxxabi
+
+Note: Ensure you are building with a sufficiently new version of Clang.
+
 Usage
 =====
 
 With no program changes, applying DataFlowSanitizer to a program
 will not alter its behavior.  To use DataFlowSanitizer, the program
 uses API functions to apply tags to data to cause it to be tracked, and to
 check the tag of a specific data item.  DataFlowSanitizer manages
 the propagation of tags through the program according to its data flow.
 
 The APIs are defined in the header file ``sanitizer/dfsan_interface.h``.
 For further information about each function, please refer to the header
 file.
 
+.. _ABI list:
+
 ABI List
 --------
 
 DataFlowSanitizer uses a list of functions known as an ABI list to decide
 whether a call to a specific function should use the operating system's native
 ABI or whether it should use a variant of this ABI that also propagates labels
 through function parameters and return values.  The ABI list file also controls
 how labels are propagated in the former case.  DataFlowSanitizer comes with a

libcxx/CMakeLists.txt

elseif (USE_SANITIZER MATCHES "Memory(WithOrigins)?")
       endif()
     elseif (USE_SANITIZER STREQUAL "Undefined")
       append_flags(SANITIZER_FLAGS "-fsanitize=undefined -fno-sanitize=vptr,function -fno-sanitize-recover=all")
     elseif (USE_SANITIZER STREQUAL "Address;Undefined" OR
             USE_SANITIZER STREQUAL "Undefined;Address")
       append_flags(SANITIZER_FLAGS "-fsanitize=address,undefined -fno-sanitize=vptr,function -fno-sanitize-recover=all")
     elseif (USE_SANITIZER STREQUAL "Thread")
       append_flags(SANITIZER_FLAGS -fsanitize=thread)
+    elseif (USE_SANITIZER STREQUAL "DataFlow")
+      append_flags(SANITIZER_FLAGS -fsanitize=dataflow)
     else()
       message(WARNING "Unsupported value of LLVM_USE_SANITIZER: ${USE_SANITIZER}")
     endif()
   elseif(USE_SANITIZER AND MSVC)
     message(WARNING "LLVM_USE_SANITIZER is not supported on this platform.")
   endif()
   set(${OUT_VAR} "${SANITIZER_FLAGS}" PARENT_SCOPE)
 endfunction()

libcxx/utils/libcxx/test/config.py

def configure_sanitizer(self):
                 self.cxx.compile_flags += ['-O1']
             elif san == 'Undefined':
                 add_ubsan()
                 self.cxx.compile_flags += ['-O2']
             elif san == 'Thread':
                 self.cxx.flags += ['-fsanitize=thread']
                 self.config.available_features.add('tsan')
                 self.config.available_features.add('sanitizer-new-delete')
+            elif san == 'DataFlow':
+                self.cxx.flags += ['-fsanitize=dataflow']
             else:
                 self.lit_config.fatal('unsupported value for '
                                       'use_sanitizer: {0}'.format(san))
             san_lib = self.get_lit_conf('sanitizer_library')
             if san_lib:
                 self.cxx.link_flags += [
                     san_lib, '-Wl,-rpath,%s' % os.path.dirname(san_lib)]
 
     def configure_coverage(self):
         self.generate_coverage = self.get_lit_bool('generate_coverage', False)

llvm/cmake/modules/HandleLLVMOptions.cmake

elseif (LLVM_USE_SANITIZER MATCHES "Memory(WithOrigins)?")
       endif()
     elseif (LLVM_USE_SANITIZER STREQUAL "Undefined")
       append_common_sanitizer_flags()
       append("-fsanitize=undefined -fno-sanitize=vptr,function -fno-sanitize-recover=all"
               CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     elseif (LLVM_USE_SANITIZER STREQUAL "Thread")
       append_common_sanitizer_flags()
       append("-fsanitize=thread" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+    elseif (LLVM_USE_SANITIZER STREQUAL "DataFlow")
+      append("-fsanitize=dataflow" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     elseif (LLVM_USE_SANITIZER STREQUAL "Address;Undefined" OR
             LLVM_USE_SANITIZER STREQUAL "Undefined;Address")
       append_common_sanitizer_flags()
       append("-fsanitize=address,undefined -fno-sanitize=vptr,function -fno-sanitize-recover=all"
               CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
     elseif (LLVM_USE_SANITIZER STREQUAL "Leaks")
       append_common_sanitizer_flags()
       append("-fsanitize=leak" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)

llvm/docs/CMake.rst

 
 **LLVM_ENABLE_DIA_SDK**:BOOL
   Enable building with MSVC DIA SDK for PDB debugging support. Available
   only with MSVC. Defaults to ON.
 
 **LLVM_USE_SANITIZER**:STRING
   Define the sanitizer used to build LLVM binaries and tests. Possible values
   are ``Address``, ``Memory``, ``MemoryWithOrigins``, ``Undefined``, ``Thread``,
-  and ``Address;Undefined``. Defaults to empty string.
+  ``DataFlow``, and ``Address;Undefined``. Defaults to empty string.
 
 **LLVM_ENABLE_LTO**:STRING
   Add ``-flto`` or ``-flto=`` flags to the compile and link command
   lines, enabling link-time optimization. Possible values are ``Off``,
   ``On``, ``Thin`` and ``Full``. Defaults to OFF.
 
 **LLVM_USE_LINKER**:STRING
   Add ``-fuse-ld={name}`` to the link invocation. The possible value depend on