[clang] [compiler-rt] [compiler-rt] Realtime Sanitizer: Introduce Realtime Sanitizer (RTSan) backend (PR #92460)

[Chris Apple via cfe-commits]

https://github.com/cjappl updated https://github.com/llvm/llvm-project/pull/92460

>From be6fbe347ed52bec5528cdaaa1d1b184b52f9803 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Tue, 7 May 2024 12:24:53 -0700
Subject: [PATCH 01/44] First try

---
 clang/include/clang/Basic/Sanitizers.def      |   3 +
 clang/include/clang/Driver/SanitizerArgs.h    |   1 +
 clang/lib/Driver/ToolChains/CommonArgs.cpp    |   6 +
 clang/lib/Driver/ToolChains/Darwin.cpp        |   8 +
 clang/lib/Driver/ToolChains/Linux.cpp         |   1 +
 clang/runtime/CMakeLists.txt                  |   1 +
 .../cmake/Modules/AllSupportedArchDefs.cmake  |   3 +
 compiler-rt/cmake/config-ix.cmake             |  12 +-
 compiler-rt/lib/radsan/CMakeLists.txt         |  92 ++++
 compiler-rt/lib/radsan/radsan.cpp             |  34 ++
 compiler-rt/lib/radsan/radsan.h               |  75 +++
 compiler-rt/lib/radsan/radsan_context.cpp     |  82 ++++
 compiler-rt/lib/radsan/radsan_context.h       |  38 ++
 .../lib/radsan/radsan_interceptors.cpp        | 412 ++++++++++++++++
 compiler-rt/lib/radsan/radsan_interceptors.h  |  15 +
 compiler-rt/lib/radsan/radsan_preinit.cpp     |  23 +
 compiler-rt/lib/radsan/radsan_stack.cpp       |  52 ++
 compiler-rt/lib/radsan/radsan_stack.h         |  15 +
 compiler-rt/lib/radsan/tests/CMakeLists.txt   | 103 ++++
 compiler-rt/lib/radsan/tests/radsan_test.cpp  | 203 ++++++++
 .../lib/radsan/tests/radsan_test_context.cpp  |  69 +++
 .../radsan/tests/radsan_test_interceptors.cpp | 454 ++++++++++++++++++
 .../lib/radsan/tests/radsan_test_main.cpp     |  17 +
 .../lib/radsan/tests/radsan_test_utilities.h  |  49 ++
 compiler-rt/test/radsan/CMakeLists.txt        |  47 ++
 .../test/radsan/Unit/lit.site.cfg.py.in       |  25 +
 compiler-rt/test/radsan/lit.cfg.py            |  69 +++
 compiler-rt/test/radsan/lit.site.cfg.py.in    |  17 +
 .../test/sanitizer_common/CMakeLists.txt      |   2 +-
 .../test/sanitizer_common/lit.common.cfg.py   |   3 +
 30 files changed, 1929 insertions(+), 2 deletions(-)
 create mode 100644 compiler-rt/lib/radsan/CMakeLists.txt
 create mode 100644 compiler-rt/lib/radsan/radsan.cpp
 create mode 100644 compiler-rt/lib/radsan/radsan.h
 create mode 100644 compiler-rt/lib/radsan/radsan_context.cpp
 create mode 100644 compiler-rt/lib/radsan/radsan_context.h
 create mode 100644 compiler-rt/lib/radsan/radsan_interceptors.cpp
 create mode 100644 compiler-rt/lib/radsan/radsan_interceptors.h
 create mode 100644 compiler-rt/lib/radsan/radsan_preinit.cpp
 create mode 100644 compiler-rt/lib/radsan/radsan_stack.cpp
 create mode 100644 compiler-rt/lib/radsan/radsan_stack.h
 create mode 100644 compiler-rt/lib/radsan/tests/CMakeLists.txt
 create mode 100644 compiler-rt/lib/radsan/tests/radsan_test.cpp
 create mode 100644 compiler-rt/lib/radsan/tests/radsan_test_context.cpp
 create mode 100644 compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
 create mode 100644 compiler-rt/lib/radsan/tests/radsan_test_main.cpp
 create mode 100644 compiler-rt/lib/radsan/tests/radsan_test_utilities.h
 create mode 100644 compiler-rt/test/radsan/CMakeLists.txt
 create mode 100644 compiler-rt/test/radsan/Unit/lit.site.cfg.py.in
 create mode 100644 compiler-rt/test/radsan/lit.cfg.py
 create mode 100644 compiler-rt/test/radsan/lit.site.cfg.py.in

diff --git a/clang/include/clang/Basic/Sanitizers.def b/clang/include/clang/Basic/Sanitizers.def
index bee35e9dca7c3..8a5df643ffa0c 100644
--- a/clang/include/clang/Basic/Sanitizers.def
+++ b/clang/include/clang/Basic/Sanitizers.def
@@ -37,6 +37,9 @@
 #endif
 
 
+// RealtimeSanitizer
+SANITIZER("realtime", Realtime)
+
 // AddressSanitizer
 SANITIZER("address", Address)
 
diff --git a/clang/include/clang/Driver/SanitizerArgs.h b/clang/include/clang/Driver/SanitizerArgs.h
index 47ef175302679..f059c8715e26d 100644
--- a/clang/include/clang/Driver/SanitizerArgs.h
+++ b/clang/include/clang/Driver/SanitizerArgs.h
@@ -79,6 +79,7 @@ class SanitizerArgs {
   bool needsStableAbi() const { return StableABI; }
 
   bool needsMemProfRt() const { return NeedsMemProfRt; }
+  bool needsRadsanRt() const { return Sanitizers.has(SanitizerKind::Realtime); }
   bool needsAsanRt() const { return Sanitizers.has(SanitizerKind::Address); }
   bool needsHwasanRt() const {
     return Sanitizers.has(SanitizerKind::HWAddress);
diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp
index 2a4c1369f5a73..459b7d59d0ee8 100644
--- a/clang/lib/Driver/ToolChains/CommonArgs.cpp
+++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp
@@ -1418,6 +1418,8 @@ collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
       if (!Args.hasArg(options::OPT_shared))
         HelperStaticRuntimes.push_back("hwasan-preinit");
     }
+    if (SanArgs.needsRadsanRt() && SanArgs.linkRuntimes())
+      SharedRuntimes.push_back("radsan");
   }
 
   // The stats_client library is also statically linked into DSOs.
@@ -1443,6 +1445,10 @@ collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
       StaticRuntimes.push_back("asan_cxx");
   }
 
+  if (!SanArgs.needsSharedRt() && SanArgs.needsRadsanRt() && SanArgs.linkRuntimes()) {
+    StaticRuntimes.push_back("radsan");
+  }
+
   if (!SanArgs.needsSharedRt() && SanArgs.needsMemProfRt()) {
     StaticRuntimes.push_back("memprof");
     if (SanArgs.linkCXXRuntimes())
diff --git a/clang/lib/Driver/ToolChains/Darwin.cpp b/clang/lib/Driver/ToolChains/Darwin.cpp
index 64ab328a6d25f..b75e6580890c1 100644
--- a/clang/lib/Driver/ToolChains/Darwin.cpp
+++ b/clang/lib/Driver/ToolChains/Darwin.cpp
@@ -1496,6 +1496,8 @@ void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
     const char *sanitizer = nullptr;
     if (Sanitize.needsUbsanRt()) {
       sanitizer = "UndefinedBehaviorSanitizer";
+    } else if (Sanitize.needsRadsanRt()) {
+      sanitizer = "RealtimeSanitizer";
     } else if (Sanitize.needsAsanRt()) {
       sanitizer = "AddressSanitizer";
     } else if (Sanitize.needsTsanRt()) {
@@ -1518,6 +1520,11 @@ void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
         AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
       }
     }
+    if(Sanitize.needsRadsanRt())
+    {
+      assert(Sanitize.needsSharedRt() && "Static sanitizer runtimes not supported");
+      AddLinkSanitizerLibArgs(Args, CmdArgs, "radsan");
+    }
     if (Sanitize.needsLsanRt())
       AddLinkSanitizerLibArgs(Args, CmdArgs, "lsan");
     if (Sanitize.needsUbsanRt()) {
@@ -3454,6 +3461,7 @@ SanitizerMask Darwin::getSupportedSanitizers() const {
   const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64;
   SanitizerMask Res = ToolChain::getSupportedSanitizers();
   Res |= SanitizerKind::Address;
+  Res |= SanitizerKind::Realtime;
   Res |= SanitizerKind::PointerCompare;
   Res |= SanitizerKind::PointerSubtract;
   Res |= SanitizerKind::Leak;
diff --git a/clang/lib/Driver/ToolChains/Linux.cpp b/clang/lib/Driver/ToolChains/Linux.cpp
index 49e029e7c9ab7..4922583e9fc67 100644
--- a/clang/lib/Driver/ToolChains/Linux.cpp
+++ b/clang/lib/Driver/ToolChains/Linux.cpp
@@ -799,6 +799,7 @@ SanitizerMask Linux::getSupportedSanitizers() const {
   const bool IsHexagon = getTriple().getArch() == llvm::Triple::hexagon;
   SanitizerMask Res = ToolChain::getSupportedSanitizers();
   Res |= SanitizerKind::Address;
+  Res |= SanitizerKind::Realtime;
   Res |= SanitizerKind::PointerCompare;
   Res |= SanitizerKind::PointerSubtract;
   Res |= SanitizerKind::Fuzzer;
diff --git a/clang/runtime/CMakeLists.txt b/clang/runtime/CMakeLists.txt
index 65fcdc2868f03..c56bff11d476b 100644
--- a/clang/runtime/CMakeLists.txt
+++ b/clang/runtime/CMakeLists.txt
@@ -150,6 +150,7 @@ if(LLVM_BUILD_EXTERNAL_COMPILER_RT AND EXISTS ${COMPILER_RT_SRC_ROOT}/)
         check-lsan
         check-msan
         check-profile
+        check-radsan
         check-safestack
         check-sanitizer
         check-tsan
diff --git a/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake b/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake
index ac4a71202384d..56a3a2590b999 100644
--- a/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake
+++ b/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake
@@ -32,6 +32,9 @@ set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
     ${LOONGARCH64})
 set(ALL_ASAN_ABI_SUPPORTED_ARCH ${X86_64} ${ARM64} ${ARM64_32})
 set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${LOONGARCH64})
+set(ALL_RADSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
+    ${MIPS32} ${MIPS64} ${PPC64} ${S390X} ${SPARC} ${SPARCV9} ${HEXAGON}
+    ${LOONGARCH64})
 
 if(ANDROID)
   set(OS_NAME "Android")
diff --git a/compiler-rt/cmake/config-ix.cmake b/compiler-rt/cmake/config-ix.cmake
index 75e4d3677703a..ceddf7fbdea94 100644
--- a/compiler-rt/cmake/config-ix.cmake
+++ b/compiler-rt/cmake/config-ix.cmake
@@ -597,6 +597,9 @@ if(APPLE)
   list_intersect(ASAN_SUPPORTED_ARCH
     ALL_ASAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
+  list_intersect(RADSAN_SUPPORTED_ARCH
+    ALL_RADSAN_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(DFSAN_SUPPORTED_ARCH
     ALL_DFSAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
@@ -663,6 +666,7 @@ else()
   filter_available_targets(UBSAN_COMMON_SUPPORTED_ARCH
     ${SANITIZER_COMMON_SUPPORTED_ARCH})
   filter_available_targets(ASAN_SUPPORTED_ARCH ${ALL_ASAN_SUPPORTED_ARCH})
+  filter_available_targets(RADSAN_SUPPORTED_ARCH ${ALL_RADSAN_SUPPORTED_ARCH})
   filter_available_targets(FUZZER_SUPPORTED_ARCH ${ALL_FUZZER_SUPPORTED_ARCH})
   filter_available_targets(DFSAN_SUPPORTED_ARCH ${ALL_DFSAN_SUPPORTED_ARCH})
   filter_available_targets(LSAN_SUPPORTED_ARCH ${ALL_LSAN_SUPPORTED_ARCH})
@@ -716,7 +720,7 @@ if(COMPILER_RT_SUPPORTED_ARCH)
 endif()
 message(STATUS "Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}")
 
-set(ALL_SANITIZERS asan;dfsan;msan;hwasan;tsan;safestack;cfi;scudo_standalone;ubsan_minimal;gwp_asan;nsan;asan_abi)
+set(ALL_SANITIZERS asan;radsan;dfsan;msan;hwasan;tsan;safestack;cfi;scudo_standalone;ubsan_minimal;gwp_asan;nsan;asan_abi)
 set(COMPILER_RT_SANITIZERS_TO_BUILD all CACHE STRING
     "sanitizers to build if supported on the target (all;${ALL_SANITIZERS})")
 list_replace(COMPILER_RT_SANITIZERS_TO_BUILD all "${ALL_SANITIZERS}")
@@ -747,6 +751,12 @@ else()
   set(COMPILER_RT_HAS_ASAN FALSE)
 endif()
 
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND RADSAN_SUPPORTED_ARCH)
+  set(COMPILER_RT_HAS_RADSAN TRUE)
+else()
+  set(COMPILER_RT_HAS_RADSAN FALSE)
+endif()
+
 if (OS_NAME MATCHES "Linux|FreeBSD|Windows|NetBSD|SunOS")
   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME TRUE)
 else()
diff --git a/compiler-rt/lib/radsan/CMakeLists.txt b/compiler-rt/lib/radsan/CMakeLists.txt
new file mode 100644
index 0000000000000..c7d1dacf3dbc7
--- /dev/null
+++ b/compiler-rt/lib/radsan/CMakeLists.txt
@@ -0,0 +1,92 @@
+include_directories(..)
+
+set(RADSAN_CXX_SOURCES
+  radsan.cpp
+  radsan_context.cpp
+  radsan_stack.cpp
+  radsan_interceptors.cpp)
+
+set(RADSAN_PREINIT_SOURCES
+  radsan_preinit.cpp)
+
+set(RADSAN_HEADERS
+  radsan.h
+  radsan_context.h
+  radsan_stack.h)
+
+set(RADSAN_DEPS)
+
+set(RADSAN_CFLAGS
+  ${COMPILER_RT_COMMON_CFLAGS}
+  ${COMPILER_RT_CXX_CFLAGS}
+  -DSANITIZER_COMMON_NO_REDEFINE_BUILTINS)
+set(RADSAN_LINK_FLAGS ${COMPILER_RT_COMMON_LINK_FLAGS})
+set(RADSAN_LINK_LIBS
+  ${COMPILER_RT_UNWINDER_LINK_LIBS}
+  ${COMPILER_RT_CXX_LINK_LIBS})
+
+if(APPLE)
+  add_compiler_rt_object_libraries(RTRadsan
+    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    ARCHS ${RADSAN_SUPPORTED_ARCH}
+    SOURCES ${RADSAN_CXX_SOURCES}
+    ADDITIONAL_HEADERS ${RADSAN_HEADERS}
+    CFLAGS ${RADSAN_CFLAGS}
+    DEPS ${RADSAN_DEPS})
+else()
+  add_compiler_rt_object_libraries(RTRadsan
+    ARCHS ${RADSAN_SUPPORTED_ARCH}
+    SOURCES ${RADSAN_CXX_SOURCES}
+    ADDITIONAL_HEADERS ${RADSAN_HEADERS}
+    CFLAGS ${RADSAN_CFLAGS}
+    DEPS ${RADSAN_DEPS})
+  add_compiler_rt_object_libraries(RTRadsan_preinit
+    ARCHS ${RADSAN_SUPPORTED_ARCH}
+    SOURCES ${RADSAN_PREINIT_SOURCES}
+    ADDITIONAL_HEADERS ${RADSAN_HEADERS}
+    CFLAGS ${RADSAN_CFLAGS})
+endif()
+
+set(RADSAN_COMMON_RUNTIME_OBJECT_LIBS
+  RTInterception
+  RTSanitizerCommon
+  RTSanitizerCommonLibc
+  RTSanitizerCommonCoverage
+  RTSanitizerCommonSymbolizer)
+
+append_list_if(COMPILER_RT_HAS_LIBDL dl RADSAN_LINK_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBRT rt RADSAN_LINK_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBM m RADSAN_LINK_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBPTHREAD pthread RADSAN_LINK_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBLOG log RADSAN_LINK_LIBS)
+
+add_compiler_rt_component(radsan)
+
+if (APPLE)
+  add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
+  set(RADSAN_LINK_FLAGS ${RADSAN_LINK_FLAGS} ${WEAK_SYMBOL_LINK_FLAGS})
+
+  add_compiler_rt_runtime(clang_rt.radsan
+    SHARED
+    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    ARCHS ${RADSAN_SUPPORTED_ARCH}
+    OBJECT_LIBS RTRadsan
+                ${RADSAN_COMMON_RUNTIME_OBJECT_LIBS}
+    LINK_FLAGS ${RADSAN_LINK_FLAGS}
+    LINK_LIBS ${RADSAN_LINK_LIBS}
+    PARENT_TARGET radsan)
+else()
+  add_compiler_rt_runtime(clang_rt.radsan
+    STATIC
+    ARCHS ${RADSAN_SUPPORTED_ARCH}
+    OBJECT_LIBS RTRadsan_preinit
+                RTRadsan
+                ${RADSAN_COMMON_RUNTIME_OBJECT_LIBS}
+    LINK_FLAGS ${RADSAN_LINK_FLAGS}
+    CFLAGS ${RADSAN_CFLAGS}
+    PARENT_TARGET radsan)
+endif()
+
+if(COMPILER_RT_INCLUDE_TESTS)
+  add_subdirectory(tests)
+endif()
diff --git a/compiler-rt/lib/radsan/radsan.cpp b/compiler-rt/lib/radsan/radsan.cpp
new file mode 100644
index 0000000000000..32a1f8223e55d
--- /dev/null
+++ b/compiler-rt/lib/radsan/radsan.cpp
@@ -0,0 +1,34 @@
+//===--- radsan.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#include <radsan/radsan.h>
+#include <radsan/radsan_context.h>
+#include <radsan/radsan_interceptors.h>
+#include <unistd.h>
+
+extern "C" {
+RADSAN_EXPORT void radsan_init() { radsan::initialiseInterceptors(); }
+
+RADSAN_EXPORT void radsan_realtime_enter() {
+  radsan::getContextForThisThread().realtimePush();
+}
+
+RADSAN_EXPORT void radsan_realtime_exit() {
+  radsan::getContextForThisThread().realtimePop();
+}
+
+RADSAN_EXPORT void radsan_off() {
+  radsan::getContextForThisThread().bypassPush();
+}
+
+RADSAN_EXPORT void radsan_on() {
+  radsan::getContextForThisThread().bypassPop();
+}
+}
diff --git a/compiler-rt/lib/radsan/radsan.h b/compiler-rt/lib/radsan/radsan.h
new file mode 100644
index 0000000000000..684cedd499ae7
--- /dev/null
+++ b/compiler-rt/lib/radsan/radsan.h
@@ -0,0 +1,75 @@
+//===--- radsan.h - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#define RADSAN_EXPORT __attribute__((visibility("default")))
+
+extern "C" {
+
+/**
+    Initialise radsan interceptors. A call to this method is added to the
+    preinit array on Linux systems.
+
+    @warning Do not call this method as a user.
+*/
+RADSAN_EXPORT void radsan_init();
+
+/** Enter real-time context.
+
+    When in a real-time context, RADSan interceptors will error if realtime
+    violations are detected. Calls to this method are injected at the code
+    generation stage when RADSan is enabled.
+
+    @warning Do not call this method as a user
+*/
+RADSAN_EXPORT void radsan_realtime_enter();
+
+/** Exit the real-time context.
+
+    When not in a real-time context, RADSan interceptors will simply forward
+    intercepted method calls to the real methods.
+
+    @warning Do not call this method as a user
+*/
+RADSAN_EXPORT void radsan_realtime_exit();
+
+/** Disable all RADSan error reporting.
+
+    This method might be useful to you if RADSan is presenting you with an error
+    for some code you are confident is realtime safe. For example, you might
+    know that a mutex is never contested, and that locking it will never block
+    on your particular system. Be careful!
+
+    A call to `radsan_off()` MUST be paired with a corresponding `radsan_on()`
+    to reactivate interception after the code in question. If you don't, radsan
+    will cease to work.
+
+    Example:
+
+        float process (float x) [[clang::nonblocking]] 
+        {
+            auto const y = 2.0f * x;
+
+            radsan_off();
+            i_know_this_method_is_realtime_safe_but_radsan_complains_about_it();
+            radsan_on();
+        }
+
+*/
+RADSAN_EXPORT void radsan_off();
+
+/** Re-enable all RADSan error reporting.
+
+    The counterpart to `radsan_off`. See the description for `radsan_off` for
+    details about how to use this method.
+*/
+RADSAN_EXPORT void radsan_on();
+}
diff --git a/compiler-rt/lib/radsan/radsan_context.cpp b/compiler-rt/lib/radsan/radsan_context.cpp
new file mode 100644
index 0000000000000..5ca70d3fd9dc5
--- /dev/null
+++ b/compiler-rt/lib/radsan/radsan_context.cpp
@@ -0,0 +1,82 @@
+//===--- radsan_context.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#include <radsan/radsan_context.h>
+
+#include <radsan/radsan_stack.h>
+
+#include <sanitizer_common/sanitizer_allocator_internal.h>
+#include <sanitizer_common/sanitizer_stacktrace.h>
+
+#include <new>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace __sanitizer;
+
+namespace detail {
+
+static pthread_key_t key;
+static pthread_once_t key_once = PTHREAD_ONCE_INIT;
+void internalFree(void *ptr) { InternalFree(ptr); }
+
+} // namespace detail
+
+namespace radsan {
+
+Context::Context() = default;
+
+void Context::realtimePush() { realtime_depth_++; }
+
+void Context::realtimePop() { realtime_depth_--; }
+
+void Context::bypassPush() { bypass_depth_++; }
+
+void Context::bypassPop() { bypass_depth_--; }
+
+void Context::expectNotRealtime(const char *intercepted_function_name) {
+  if (inRealtimeContext() && !isBypassed()) {
+    bypassPush();
+    printDiagnostics(intercepted_function_name);
+    exit(EXIT_FAILURE);
+    bypassPop();
+  }
+}
+
+bool Context::inRealtimeContext() const { return realtime_depth_ > 0; }
+
+bool Context::isBypassed() const { return bypass_depth_ > 0; }
+
+void Context::printDiagnostics(const char *intercepted_function_name) {
+  fprintf(stderr,
+          "Real-time violation: intercepted call to real-time unsafe function "
+          "`%s` in real-time context! Stack trace:\n",
+          intercepted_function_name);
+  radsan::printStackTrace();
+}
+
+Context &getContextForThisThread() {
+  auto make_tls_key = []() {
+    CHECK_EQ(pthread_key_create(&detail::key, detail::internalFree), 0);
+  };
+
+  pthread_once(&detail::key_once, make_tls_key);
+  auto *ptr = static_cast<Context *>(pthread_getspecific(detail::key));
+  if (ptr == nullptr) {
+    ptr = static_cast<Context *>(InternalAlloc(sizeof(Context)));
+    new(ptr) Context();
+    pthread_setspecific(detail::key, ptr);
+  }
+
+  return *ptr;
+}
+
+} // namespace radsan
diff --git a/compiler-rt/lib/radsan/radsan_context.h b/compiler-rt/lib/radsan/radsan_context.h
new file mode 100644
index 0000000000000..efd3677107469
--- /dev/null
+++ b/compiler-rt/lib/radsan/radsan_context.h
@@ -0,0 +1,38 @@
+//===--- radsan_context.h - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+namespace radsan {
+
+class Context {
+public:
+  Context();
+
+  void realtimePush();
+  void realtimePop();
+
+  void bypassPush();
+  void bypassPop();
+
+  void expectNotRealtime(const char *interpreted_function_name);
+
+private:
+  bool inRealtimeContext() const;
+  bool isBypassed() const;
+  void printDiagnostics(const char *intercepted_function_name);
+
+  int realtime_depth_{0};
+  int bypass_depth_{0};
+};
+
+Context &getContextForThisThread();
+
+} // namespace radsan
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
new file mode 100644
index 0000000000000..d50ece6099b14
--- /dev/null
+++ b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -0,0 +1,412 @@
+//===--- radsan_interceptors.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#include "radsan/radsan_interceptors.h"
+
+#include "sanitizer_common/sanitizer_platform.h"
+#include "sanitizer_common/sanitizer_platform_interceptors.h"
+
+#include "interception/interception.h"
+#include "radsan/radsan_context.h"
+
+#if !SANITIZER_LINUX && !SANITIZER_APPLE
+#error Sorry, radsan does not yet support this platform
+#endif
+
+#if SANITIZER_APPLE
+#include <libkern/OSAtomic.h>
+#include <os/lock.h>
+#endif
+
+#if SANITIZER_INTERCEPT_MEMALIGN || SANITIZER_INTERCEPT_PVALLOC
+#include <malloc.h>
+#endif
+
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <sys/socket.h>
+#include <time.h>
+#include <unistd.h>
+
+using namespace __sanitizer;
+
+namespace radsan {
+void expectNotRealtime(const char *intercepted_function_name) {
+  getContextForThisThread().expectNotRealtime(intercepted_function_name);
+}
+} // namespace radsan
+
+/*
+    Filesystem
+*/
+
+INTERCEPTOR(int, open, const char *path, int oflag, ...) {
+  // TODO Establish whether we should intercept here if the flag contains
+  // O_NONBLOCK
+  radsan::expectNotRealtime("open");
+  va_list args;
+  va_start(args, oflag);
+  auto result = REAL(open)(path, oflag, args);
+  va_end(args);
+  return result;
+}
+
+INTERCEPTOR(int, openat, int fd, const char *path, int oflag, ...) {
+  // TODO Establish whether we should intercept here if the flag contains
+  // O_NONBLOCK
+  radsan::expectNotRealtime("openat");
+  va_list args;
+  va_start(args, oflag);
+  auto result = REAL(openat)(fd, path, oflag, args);
+  va_end(args);
+  return result;
+}
+
+INTERCEPTOR(int, creat, const char *path, mode_t mode) {
+  // TODO Establish whether we should intercept here if the flag contains
+  // O_NONBLOCK
+  radsan::expectNotRealtime("creat");
+  auto result = REAL(creat)(path, mode);
+  return result;
+}
+
+INTERCEPTOR(int, fcntl, int filedes, int cmd, ...) {
+  radsan::expectNotRealtime("fcntl");
+  va_list args;
+  va_start(args, cmd);
+  auto result = REAL(fcntl)(filedes, cmd, args);
+  va_end(args);
+  return result;
+}
+
+INTERCEPTOR(int, close, int filedes) {
+  radsan::expectNotRealtime("close");
+  return REAL(close)(filedes);
+}
+
+INTERCEPTOR(FILE *, fopen, const char *path, const char *mode) {
+  radsan::expectNotRealtime("fopen");
+  return REAL(fopen)(path, mode);
+}
+
+INTERCEPTOR(size_t, fread, void *ptr, size_t size, size_t nitems,
+            FILE *stream) {
+  radsan::expectNotRealtime("fread");
+  return REAL(fread)(ptr, size, nitems, stream);
+}
+
+INTERCEPTOR(size_t, fwrite, const void *ptr, size_t size, size_t nitems,
+            FILE *stream) {
+  radsan::expectNotRealtime("fwrite");
+  return REAL(fwrite)(ptr, size, nitems, stream);
+}
+
+INTERCEPTOR(int, fclose, FILE *stream) {
+  radsan::expectNotRealtime("fclose");
+  return REAL(fclose)(stream);
+}
+
+INTERCEPTOR(int, fputs, const char *s, FILE *stream) {
+  radsan::expectNotRealtime("fputs");
+  return REAL(fputs)(s, stream);
+}
+
+/*
+    Streams
+*/
+
+INTERCEPTOR(int, puts, const char *s) {
+  radsan::expectNotRealtime("puts");
+  return REAL(puts)(s);
+}
+
+/*
+    Concurrency
+*/
+
+#if SANITIZER_APPLE
+#pragma clang diagnostic push
+// OSSpinLockLock is deprecated, but still in use in libc++
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+INTERCEPTOR(void, OSSpinLockLock, volatile OSSpinLock *lock) {
+  radsan::expectNotRealtime("OSSpinLockLock");
+  return REAL(OSSpinLockLock)(lock);
+}
+#pragma clang diagnostic pop
+
+INTERCEPTOR(void, os_unfair_lock_lock, os_unfair_lock_t lock) {
+  radsan::expectNotRealtime("os_unfair_lock_lock");
+  return REAL(os_unfair_lock_lock)(lock);
+}
+#elif SANITIZER_LINUX
+INTERCEPTOR(int, pthread_spin_lock, pthread_spinlock_t *spinlock) {
+  radsan::expectNotRealtime("pthread_spin_lock");
+  return REAL(pthread_spin_lock)(spinlock);
+}
+#endif
+
+INTERCEPTOR(int, pthread_create, pthread_t *thread, const pthread_attr_t *attr,
+            void *(*start_routine)(void *), void *arg) {
+  radsan::expectNotRealtime("pthread_create");
+  return REAL(pthread_create)(thread, attr, start_routine, arg);
+}
+
+INTERCEPTOR(int, pthread_mutex_lock, pthread_mutex_t *mutex) {
+  radsan::expectNotRealtime("pthread_mutex_lock");
+  return REAL(pthread_mutex_lock)(mutex);
+}
+
+INTERCEPTOR(int, pthread_mutex_unlock, pthread_mutex_t *mutex) {
+  radsan::expectNotRealtime("pthread_mutex_unlock");
+  return REAL(pthread_mutex_unlock)(mutex);
+}
+
+INTERCEPTOR(int, pthread_join, pthread_t thread, void **value_ptr) {
+  radsan::expectNotRealtime("pthread_join");
+  return REAL(pthread_join)(thread, value_ptr);
+}
+
+INTERCEPTOR(int, pthread_cond_signal, pthread_cond_t *cond) {
+  radsan::expectNotRealtime("pthread_cond_signal");
+  return REAL(pthread_cond_signal)(cond);
+}
+
+INTERCEPTOR(int, pthread_cond_broadcast, pthread_cond_t *cond) {
+  radsan::expectNotRealtime("pthread_cond_broadcast");
+  return REAL(pthread_cond_broadcast)(cond);
+}
+
+INTERCEPTOR(int, pthread_cond_wait, pthread_cond_t *cond,
+            pthread_mutex_t *mutex) {
+  radsan::expectNotRealtime("pthread_cond_wait");
+  return REAL(pthread_cond_wait)(cond, mutex);
+}
+
+INTERCEPTOR(int, pthread_cond_timedwait, pthread_cond_t *cond,
+            pthread_mutex_t *mutex, const timespec *ts) {
+  radsan::expectNotRealtime("pthread_cond_timedwait");
+  return REAL(pthread_cond_timedwait)(cond, mutex, ts);
+}
+
+INTERCEPTOR(int, pthread_rwlock_rdlock, pthread_rwlock_t *lock) {
+  radsan::expectNotRealtime("pthread_rwlock_rdlock");
+  return REAL(pthread_rwlock_rdlock)(lock);
+}
+
+INTERCEPTOR(int, pthread_rwlock_unlock, pthread_rwlock_t *lock) {
+  radsan::expectNotRealtime("pthread_rwlock_unlock");
+  return REAL(pthread_rwlock_unlock)(lock);
+}
+
+INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *lock) {
+  radsan::expectNotRealtime("pthread_rwlock_wrlock");
+  return REAL(pthread_rwlock_wrlock)(lock);
+}
+
+/*
+    Sleeping
+*/
+
+INTERCEPTOR(unsigned int, sleep, unsigned int s) {
+  radsan::expectNotRealtime("sleep");
+  return REAL(sleep)(s);
+}
+
+INTERCEPTOR(int, usleep, useconds_t u) {
+  radsan::expectNotRealtime("usleep");
+  return REAL(usleep)(u);
+}
+
+INTERCEPTOR(int, nanosleep, const struct timespec *rqtp,
+            struct timespec *rmtp) {
+  radsan::expectNotRealtime("nanosleep");
+  return REAL(nanosleep)(rqtp, rmtp);
+}
+
+/*
+    Memory
+*/
+
+INTERCEPTOR(void *, calloc, SIZE_T num, SIZE_T size) {
+  radsan::expectNotRealtime("calloc");
+  return REAL(calloc)(num, size);
+}
+
+INTERCEPTOR(void, free, void *ptr) {
+  if (ptr != NULL) {
+    radsan::expectNotRealtime("free");
+  }
+  return REAL(free)(ptr);
+}
+
+INTERCEPTOR(void *, malloc, SIZE_T size) {
+  radsan::expectNotRealtime("malloc");
+  return REAL(malloc)(size);
+}
+
+INTERCEPTOR(void *, realloc, void *ptr, SIZE_T size) {
+  radsan::expectNotRealtime("realloc");
+  return REAL(realloc)(ptr, size);
+}
+
+INTERCEPTOR(void *, reallocf, void *ptr, SIZE_T size) {
+  radsan::expectNotRealtime("reallocf");
+  return REAL(reallocf)(ptr, size);
+}
+
+INTERCEPTOR(void *, valloc, SIZE_T size) {
+  radsan::expectNotRealtime("valloc");
+  return REAL(valloc)(size);
+}
+
+#if SANITIZER_INTERCEPT_ALIGNED_ALLOC
+INTERCEPTOR(void *, aligned_alloc, SIZE_T alignment, SIZE_T size) {
+  radsan::expectNotRealtime("aligned_alloc");
+  return REAL(aligned_alloc)(alignment, size);
+}
+#define RADSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC INTERCEPT_FUNCTION(aligned_alloc)
+#else
+#define RADSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC
+#endif
+
+INTERCEPTOR(int, posix_memalign, void **memptr, size_t alignment, size_t size) {
+  radsan::expectNotRealtime("posix_memalign");
+  return REAL(posix_memalign)(memptr, alignment, size);
+}
+
+#if SANITIZER_INTERCEPT_MEMALIGN
+INTERCEPTOR(void *, memalign, size_t alignment, size_t size) {
+  radsan::expectNotRealtime("memalign");
+  return REAL(memalign)(alignment, size);
+}
+#endif
+
+#if SANITIZER_INTERCEPT_PVALLOC
+INTERCEPTOR(void *, pvalloc, size_t size) {
+  radsan::expectNotRealtime("pvalloc");
+  return REAL(pvalloc)(size);
+}
+#endif
+
+/*
+    Sockets
+*/
+
+INTERCEPTOR(int, socket, int domain, int type, int protocol) {
+  radsan::expectNotRealtime("socket");
+  return REAL(socket)(domain, type, protocol);
+}
+
+INTERCEPTOR(ssize_t, send, int sockfd, const void *buf, size_t len, int flags) {
+  radsan::expectNotRealtime("send");
+  return REAL(send)(sockfd, buf, len, flags);
+}
+
+INTERCEPTOR(ssize_t, sendmsg, int socket, const struct msghdr *message,
+            int flags) {
+  radsan::expectNotRealtime("sendmsg");
+  return REAL(sendmsg)(socket, message, flags);
+}
+
+INTERCEPTOR(ssize_t, sendto, int socket, const void *buffer, size_t length,
+            int flags, const struct sockaddr *dest_addr, socklen_t dest_len) {
+  radsan::expectNotRealtime("sendto");
+  return REAL(sendto)(socket, buffer, length, flags, dest_addr, dest_len);
+}
+
+INTERCEPTOR(ssize_t, recv, int socket, void *buffer, size_t length, int flags) {
+  radsan::expectNotRealtime("recv");
+  return REAL(recv)(socket, buffer, length, flags);
+}
+
+INTERCEPTOR(ssize_t, recvfrom, int socket, void *buffer, size_t length,
+            int flags, struct sockaddr *address, socklen_t *address_len) {
+  radsan::expectNotRealtime("recvfrom");
+  return REAL(recvfrom)(socket, buffer, length, flags, address, address_len);
+}
+
+INTERCEPTOR(ssize_t, recvmsg, int socket, struct msghdr *message, int flags) {
+  radsan::expectNotRealtime("recvmsg");
+  return REAL(recvmsg)(socket, message, flags);
+}
+
+INTERCEPTOR(int, shutdown, int socket, int how) {
+  radsan::expectNotRealtime("shutdown");
+  return REAL(shutdown)(socket, how);
+}
+
+/*
+    Preinit
+*/
+
+namespace radsan {
+void initialiseInterceptors() {
+  INTERCEPT_FUNCTION(calloc);
+  INTERCEPT_FUNCTION(free);
+  INTERCEPT_FUNCTION(malloc);
+  INTERCEPT_FUNCTION(realloc);
+  INTERCEPT_FUNCTION(reallocf);
+  INTERCEPT_FUNCTION(valloc);
+  RADSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC;
+  INTERCEPT_FUNCTION(posix_memalign);
+#if SANITIZER_INTERCEPT_MEMALIGN
+  INTERCEPT_FUNCTION(memalign);
+#endif
+#if SANITIZER_INTERCEPT_PVALLOC
+  INTERCEPT_FUNCTION(pvalloc);
+#endif
+
+  INTERCEPT_FUNCTION(open);
+  INTERCEPT_FUNCTION(openat);
+  INTERCEPT_FUNCTION(close);
+  INTERCEPT_FUNCTION(fopen);
+  INTERCEPT_FUNCTION(fread);
+  INTERCEPT_FUNCTION(fwrite);
+  INTERCEPT_FUNCTION(fclose);
+  INTERCEPT_FUNCTION(fcntl);
+  INTERCEPT_FUNCTION(creat);
+  INTERCEPT_FUNCTION(puts);
+  INTERCEPT_FUNCTION(fputs);
+
+#if SANITIZER_APPLE
+  INTERCEPT_FUNCTION(OSSpinLockLock);
+  INTERCEPT_FUNCTION(os_unfair_lock_lock);
+#elif SANITIZER_LINUX
+  INTERCEPT_FUNCTION(pthread_spin_lock);
+#endif
+
+  INTERCEPT_FUNCTION(pthread_create);
+  INTERCEPT_FUNCTION(pthread_mutex_lock);
+  INTERCEPT_FUNCTION(pthread_mutex_unlock);
+  INTERCEPT_FUNCTION(pthread_join);
+  INTERCEPT_FUNCTION(pthread_cond_signal);
+  INTERCEPT_FUNCTION(pthread_cond_broadcast);
+  INTERCEPT_FUNCTION(pthread_cond_wait);
+  INTERCEPT_FUNCTION(pthread_cond_timedwait);
+  INTERCEPT_FUNCTION(pthread_rwlock_rdlock);
+  INTERCEPT_FUNCTION(pthread_rwlock_unlock);
+  INTERCEPT_FUNCTION(pthread_rwlock_wrlock);
+
+  INTERCEPT_FUNCTION(sleep);
+  INTERCEPT_FUNCTION(usleep);
+  INTERCEPT_FUNCTION(nanosleep);
+
+  INTERCEPT_FUNCTION(socket);
+  INTERCEPT_FUNCTION(send);
+  INTERCEPT_FUNCTION(sendmsg);
+  INTERCEPT_FUNCTION(sendto);
+  INTERCEPT_FUNCTION(recv);
+  INTERCEPT_FUNCTION(recvmsg);
+  INTERCEPT_FUNCTION(recvfrom);
+  INTERCEPT_FUNCTION(shutdown);
+}
+} // namespace radsan
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.h b/compiler-rt/lib/radsan/radsan_interceptors.h
new file mode 100644
index 0000000000000..d10f4a01d8c80
--- /dev/null
+++ b/compiler-rt/lib/radsan/radsan_interceptors.h
@@ -0,0 +1,15 @@
+//===--- radsan_interceptors.h - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+namespace radsan {
+void initialiseInterceptors();
+}
diff --git a/compiler-rt/lib/radsan/radsan_preinit.cpp b/compiler-rt/lib/radsan/radsan_preinit.cpp
new file mode 100644
index 0000000000000..e5e92becb1eac
--- /dev/null
+++ b/compiler-rt/lib/radsan/radsan_preinit.cpp
@@ -0,0 +1,23 @@
+//===--- radsan_preinit.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_internal_defs.h"
+#include <radsan/radsan.h>
+
+#if SANITIZER_CAN_USE_PREINIT_ARRAY
+
+// The symbol is called __local_radsan_preinit, because it's not intended to be
+// exported.
+// This code is linked into the main executable when -fsanitize=realtime is in
+// the link flags. It can only use exported interface functions.
+__attribute__((section(".preinit_array"), used))
+void (*__local_radsan_preinit)(void) = radsan_init;
+
+#endif
diff --git a/compiler-rt/lib/radsan/radsan_stack.cpp b/compiler-rt/lib/radsan/radsan_stack.cpp
new file mode 100644
index 0000000000000..b3cffa98b3ab9
--- /dev/null
+++ b/compiler-rt/lib/radsan/radsan_stack.cpp
@@ -0,0 +1,52 @@
+//===--- radsan_stack.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#include <sanitizer_common/sanitizer_flags.h>
+#include <sanitizer_common/sanitizer_stacktrace.h>
+
+using namespace __sanitizer;
+
+// We must define our own implementation of this method for our runtime.
+// This one is just copied from UBSan.
+
+namespace __sanitizer {
+void BufferedStackTrace::UnwindImpl(uptr pc, uptr bp, void *context,
+                                    bool request_fast, u32 max_depth) {
+  uptr top = 0;
+  uptr bottom = 0;
+  GetThreadStackTopAndBottom(false, &top, &bottom);
+  bool fast = StackTrace::WillUseFastUnwind(request_fast);
+  Unwind(max_depth, pc, bp, context, top, bottom, fast);
+}
+} // namespace __sanitizer
+
+namespace {
+void setGlobalStackTraceFormat() {
+  SetCommonFlagsDefaults();
+  CommonFlags cf;
+  cf.CopyFrom(*common_flags());
+  cf.stack_trace_format = "DEFAULT";
+  cf.external_symbolizer_path = GetEnv("RADSAN_SYMBOLIZER_PATH");
+  OverrideCommonFlags(cf);
+}
+} // namespace
+
+namespace radsan {
+void printStackTrace() {
+
+  auto stack = BufferedStackTrace{};
+
+  GET_CURRENT_PC_BP;
+  stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal);
+
+  setGlobalStackTraceFormat();
+  stack.Print();
+}
+} // namespace radsan
diff --git a/compiler-rt/lib/radsan/radsan_stack.h b/compiler-rt/lib/radsan/radsan_stack.h
new file mode 100644
index 0000000000000..ee65a959431aa
--- /dev/null
+++ b/compiler-rt/lib/radsan/radsan_stack.h
@@ -0,0 +1,15 @@
+//===--- radsan_stack.h - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+namespace radsan {
+void printStackTrace();
+}
diff --git a/compiler-rt/lib/radsan/tests/CMakeLists.txt b/compiler-rt/lib/radsan/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..73cedac2765d6
--- /dev/null
+++ b/compiler-rt/lib/radsan/tests/CMakeLists.txt
@@ -0,0 +1,103 @@
+include(CompilerRTCompile)
+
+include_directories(..)
+
+set(RADSAN_UNITTEST_CFLAGS
+  ${COMPILER_RT_UNITTEST_CFLAGS}
+  ${COMPILER_RT_GTEST_CFLAGS}
+  ${COMPILER_RT_GMOCK_CFLAGS}
+  ${SANITIZER_TEST_CXX_CFLAGS}
+  -I${COMPILER_RT_SOURCE_DIR}/lib/
+  -I${COMPILER_RT_SOURCE_DIR}/include/
+  -I${COMPILER_RT_SOURCE_DIR}/lib/radsan
+  -I${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common/tests
+  -DSANITIZER_COMMON_NO_REDEFINE_BUILTINS
+  -O2)
+
+set(RADSAN_INST_TEST_SOURCES
+    radsan_test.cpp
+    radsan_test_interceptors.cpp
+    radsan_test_main.cpp)
+
+set(RADSAN_NOINST_TEST_SOURCES
+    ../radsan_preinit.cpp
+    radsan_test_context.cpp
+    radsan_test_main.cpp)
+
+set(RADSAN_UNITTEST_HEADERS
+    radsan_test_utilities.h)
+
+add_custom_target(RadsanUnitTests)
+set_target_properties(RadsanUnitTests PROPERTIES FOLDER "Compiler-RT Tests")
+
+set(RADSAN_UNITTEST_LINK_FLAGS
+  ${COMPILER_RT_UNITTEST_LINK_FLAGS}
+  ${COMPILER_RT_UNWINDER_LINK_LIBS}
+  ${SANITIZER_TEST_CXX_LIBRARIES}
+  -no-pie)
+
+if (APPLE)
+  add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
+  list(APPEND RADSAN_UNITTEST_LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS})
+  list(APPEND RADSAN_UNITTEST_LINK_FLAGS ${DARWIN_osx_LINK_FLAGS})
+  list(APPEND RADSAN_UNITTEST_CFLAGS ${DARWIN_osx_CFLAGS})
+else()
+  list(APPEND RADSAN_UNITTEST_LINK_FLAGS -latomic)
+endif()
+
+set(COMPILER_RT_GOOGLETEST_SOURCES ${COMPILER_RT_GTEST_SOURCE} ${COMPILER_RT_GMOCK_SOURCE})
+
+set(RADSAN_TEST_ARCH ${RADSAN_SUPPORTED_ARCH})
+if(APPLE)
+  darwin_filter_host_archs(RADSAN_SUPPORTED_ARCH RADSAN_TEST_ARCH)
+endif()
+
+foreach(arch ${RADSAN_TEST_ARCH})
+  set(RadsanTestObjects)
+  generate_compiler_rt_tests(RadsanTestObjects
+    RadsanUnitTests "Radsan-${arch}-Test" ${arch}
+    COMPILE_DEPS ${RADSAN_UNITTEST_HEADERS}
+    SOURCES ${RADSAN_INST_TEST_SOURCES} ${COMPILER_RT_GOOGLETEST_SOURCES}
+    DEPS llvm_gtest radsan
+    CFLAGS ${RADSAN_UNITTEST_CFLAGS} -fsanitize=realtime
+    LINK_FLAGS ${RADSAN_UNITTEST_LINK_FLAGS} -fsanitize=realtime)
+  set_target_properties(RadsanUnitTests PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+  set(RADSAN_TEST_RUNTIME RTRadsanTest.${arch})
+  if(APPLE)
+    set(RADSAN_TEST_RUNTIME_OBJECTS
+      $<TARGET_OBJECTS:RTRadsan.osx>
+      $<TARGET_OBJECTS:RTInterception.osx>
+      $<TARGET_OBJECTS:RTSanitizerCommon.osx>
+      $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
+      $<TARGET_OBJECTS:RTSanitizerCommonCoverage.osx>
+      $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.osx>)
+  else()
+    set(RADSAN_TEST_RUNTIME_OBJECTS
+      $<TARGET_OBJECTS:RTRadsan.${arch}>
+      $<TARGET_OBJECTS:RTInterception.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonCoverage.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonSymbolizerInternal.${arch}>)
+  endif()
+  add_library(${RADSAN_TEST_RUNTIME} STATIC ${RADSAN_TEST_RUNTIME_OBJECTS})
+  set_target_properties(${RADSAN_TEST_RUNTIME} PROPERTIES
+      ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+      FOLDER "Compiler-RT Runtime tests")
+
+  set(RadsanNoInstTestObjects)
+  generate_compiler_rt_tests(RadsanNoInstTestObjects
+    RadsanUnitTests "Radsan-${arch}-NoInstTest" ${arch}
+    COMPILE_DEPS ${RADSAN_UNITTEST_HEADERS}
+    SOURCES ${RADSAN_NOINST_TEST_SOURCES}
+            ${COMPILER_RT_GOOGLETEST_SOURCES}
+    DEPS llvm_gtest
+    CFLAGS ${RADSAN_UNITTEST_CFLAGS}
+    LINK_FLAGS ${RADSAN_UNITTEST_LINK_FLAGS}
+    RUNTIME ${RADSAN_TEST_RUNTIME})
+  set_target_properties(RadsanUnitTests PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+endforeach()
diff --git a/compiler-rt/lib/radsan/tests/radsan_test.cpp b/compiler-rt/lib/radsan/tests/radsan_test.cpp
new file mode 100644
index 0000000000000..65c4380dfc602
--- /dev/null
+++ b/compiler-rt/lib/radsan/tests/radsan_test.cpp
@@ -0,0 +1,203 @@
+//===--- radsan_test.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "radsan_test_utilities.h"
+#include <radsan.h>
+#include <sanitizer_common/sanitizer_platform.h>
+#include <sanitizer_common/sanitizer_platform_interceptors.h>
+
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <fstream>
+#include <mutex>
+#include <shared_mutex>
+#include <thread>
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) &&                  \
+    __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101200
+#define SI_MAC_DEPLOYMENT_AT_LEAST_10_12 1
+#else
+#define SI_MAC_DEPLOYMENT_AT_LEAST_10_12 0
+#endif
+
+#define RADSAN_TEST_SHARED_MUTEX (!(SI_MAC) || SI_MAC_DEPLOYMENT_AT_LEAST_10_12)
+
+using namespace testing;
+using namespace radsan_testing;
+using namespace std::chrono_literals;
+
+namespace {
+void invokeStdFunction(std::function<void()> &&function) { function(); }
+} // namespace
+
+TEST(TestRadsan, vectorPushBackAllocationDiesWhenRealtime) {
+  auto vec = std::vector<float>{};
+  auto func = [&vec]() { vec.push_back(0.4f); };
+  expectRealtimeDeath(func);
+  ASSERT_EQ(0u, vec.size());
+  expectNonrealtimeSurvival(func);
+  ASSERT_EQ(1u, vec.size());
+}
+
+TEST(TestRadsan, destructionOfObjectOnHeapDiesWhenRealtime) {
+  auto obj = std::make_unique<std::array<float, 256>>();
+  auto func = [&obj]() { obj.reset(); };
+  expectRealtimeDeath(func);
+  ASSERT_NE(nullptr, obj.get());
+  expectNonrealtimeSurvival(func);
+  ASSERT_EQ(nullptr, obj.get());
+}
+
+TEST(TestRadsan, sleepingAThreadDiesWhenRealtime) {
+  auto func = []() { std::this_thread::sleep_for(1us); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, ifstreamCreationDiesWhenRealtime) {
+  auto func = []() { auto ifs = std::ifstream("./file.txt"); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+  std::remove("./file.txt");
+}
+
+TEST(TestRadsan, ofstreamCreationDiesWhenRealtime) {
+  auto func = []() { auto ofs = std::ofstream("./file.txt"); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+  std::remove("./file.txt");
+}
+
+TEST(TestRadsan, lockingAMutexDiesWhenRealtime) {
+  auto mutex = std::mutex{};
+  auto func = [&]() { mutex.lock(); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, unlockingAMutexDiesWhenRealtime) {
+  auto mutex = std::mutex{};
+  mutex.lock();
+  auto func = [&]() { mutex.unlock(); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+#if RADSAN_TEST_SHARED_MUTEX
+
+TEST(TestRadsan, lockingASharedMutexDiesWhenRealtime) {
+  auto mutex = std::shared_mutex();
+  auto func = [&]() { mutex.lock(); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, unlockingASharedMutexDiesWhenRealtime) {
+  auto mutex = std::shared_mutex();
+  mutex.lock();
+  auto func = [&]() { mutex.unlock(); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, sharedLockingASharedMutexDiesWhenRealtime) {
+  auto mutex = std::shared_mutex();
+  auto func = [&]() { mutex.lock_shared(); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, sharedUnlockingASharedMutexDiesWhenRealtime) {
+  auto mutex = std::shared_mutex();
+  mutex.lock_shared();
+  auto func = [&]() { mutex.unlock_shared(); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+#endif // RADSAN_TEST_SHARED_MUTEX
+
+TEST(TestRadsan, launchingAThreadDiesWhenRealtime) {
+  auto func = [&]() {
+    auto t = std::thread([]() {});
+    t.join();
+  };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, copyingALambdaWithLargeCaptureDiesWhenRealtime) {
+  auto lots_of_data = std::array<float, 16>{};
+  auto lambda = [lots_of_data]() mutable {
+    // Stop everything getting optimised out
+    lots_of_data[3] = 0.25f;
+    EXPECT_EQ(16, lots_of_data.size());
+    EXPECT_EQ(0.25f, lots_of_data[3]);
+  };
+  auto func = [&]() { invokeStdFunction(lambda); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, accessingALargeAtomicVariableDiesWhenRealtime) {
+  auto small_atomic = std::atomic<float>{0.0f};
+  ASSERT_TRUE(small_atomic.is_lock_free());
+  realtimeInvoke([&small_atomic]() { auto x = small_atomic.load(); });
+
+  auto large_atomic = std::atomic<std::array<float, 2048>>{{}};
+  ASSERT_FALSE(large_atomic.is_lock_free());
+  auto func = [&]() { auto x = large_atomic.load(); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, firstCoutDiesWhenRealtime) {
+  auto func = []() { std::cout << "Hello, world!" << std::endl; };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, secondCoutDiesWhenRealtime) {
+  std::cout << "Hello, world";
+  auto func = []() { std::cout << "Hello, again!" << std::endl; };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, printfDiesWhenRealtime) {
+  auto func = []() { printf("Hello, world!\n"); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, throwingAnExceptionDiesWhenRealtime) {
+  auto func = [&]() {
+    try {
+      throw std::exception();
+    } catch (std::exception &) {
+    }
+  };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsan, doesNotDieIfTurnedOff) {
+  auto mutex = std::mutex{};
+  auto realtime_unsafe_func = [&]() {
+    radsan_off();
+    mutex.lock();
+    mutex.unlock();
+    radsan_on();
+  };
+  realtimeInvoke(realtime_unsafe_func);
+}
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
new file mode 100644
index 0000000000000..c52a0fff3b7ef
--- /dev/null
+++ b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
@@ -0,0 +1,69 @@
+//===--- radsan_test_context.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#include "radsan_test_utilities.h"
+
+#include "radsan_context.h"
+
+TEST(TestRadsanContext, canCreateContext) { auto context = radsan::Context{}; }
+
+TEST(TestRadsanContext, expectNotRealtimeDoesNotDieBeforeRealtimePush) {
+  auto context = radsan::Context{};
+  context.expectNotRealtime("do_some_stuff");
+}
+
+TEST(TestRadsanContext, expectNotRealtimeDoesNotDieAfterPushAndPop) {
+  auto context = radsan::Context{};
+  context.realtimePush();
+  context.realtimePop();
+  context.expectNotRealtime("do_some_stuff");
+}
+
+TEST(TestRadsanContext, expectNotRealtimeDiesAfterRealtimePush) {
+  auto context = radsan::Context{};
+
+  context.realtimePush();
+  EXPECT_DEATH(context.expectNotRealtime("do_some_stuff"), "");
+}
+
+TEST(TestRadsanContext,
+     expectNotRealtimeDiesAfterRealtimeAfterMorePushesThanPops) {
+  auto context = radsan::Context{};
+
+  context.realtimePush();
+  context.realtimePush();
+  context.realtimePush();
+  context.realtimePop();
+  context.realtimePop();
+  EXPECT_DEATH(context.expectNotRealtime("do_some_stuff"), "");
+}
+
+TEST(TestRadsanContext, expectNotRealtimeDoesNotDieAfterBypassPush) {
+  auto context = radsan::Context{};
+
+  context.realtimePush();
+  context.bypassPush();
+  context.expectNotRealtime("do_some_stuff");
+}
+
+TEST(TestRadsanContext,
+     expectNotRealtimeDoesNotDieIfBypassDepthIsGreaterThanZero) {
+  auto context = radsan::Context{};
+
+  context.realtimePush();
+  context.bypassPush();
+  context.bypassPush();
+  context.bypassPush();
+  context.bypassPop();
+  context.bypassPop();
+  context.expectNotRealtime("do_some_stuff");
+  context.bypassPop();
+  EXPECT_DEATH(context.expectNotRealtime("do_some_stuff"), "");
+}
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
new file mode 100644
index 0000000000000..6b6bb6b76d7ff
--- /dev/null
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -0,0 +1,454 @@
+//===--- radsan_test_interceptors.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include <sanitizer_common/sanitizer_platform.h>
+#include <sanitizer_common/sanitizer_platform_interceptors.h>
+
+#include "radsan_test_utilities.h"
+
+#if SANITIZER_APPLE
+#include <libkern/OSAtomic.h>
+#include <os/lock.h>
+#endif
+
+#if SANITIZER_INTERCEPT_MEMALIGN || SANITIZER_INTERCEPT_PVALLOC
+#include <malloc.h>
+#endif
+
+#include <atomic>
+#include <chrono>
+#include <thread>
+
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <sys/socket.h>
+
+using namespace testing;
+using namespace radsan_testing;
+using namespace std::chrono_literals;
+
+namespace {
+void *fake_thread_entry_point(void *) { return nullptr; }
+
+/*
+  The creat function doesn't seem to work on an ubuntu Docker image when the
+  path is in a shared volume of the host. For now, to keep testing convenient
+  with a local Docker container, we just put it somewhere that's not in the
+  shared volume (/tmp). This is volatile and will be cleaned up as soon as the
+  container is stopped.
+*/
+constexpr const char *temporary_file_path() {
+#if SANITIZER_LINUX
+  return "/tmp/radsan_temporary_test_file.txt";
+#elif SANITIZER_APPLE
+  return "./radsan_temporary_test_file.txt";
+#endif
+}
+} // namespace
+
+/*
+    Allocation and deallocation
+*/
+
+TEST(TestRadsanInterceptors, mallocDiesWhenRealtime) {
+  auto func = []() { EXPECT_NE(nullptr, malloc(1)); };
+  expectRealtimeDeath(func, "malloc");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, reallocDiesWhenRealtime) {
+  auto *ptr_1 = malloc(1);
+  auto func = [ptr_1]() { EXPECT_NE(nullptr, realloc(ptr_1, 8)); };
+  expectRealtimeDeath(func, "realloc");
+  expectNonrealtimeSurvival(func);
+}
+
+#if SANITIZER_APPLE
+TEST(TestRadsanInterceptors, reallocfDiesWhenRealtime) {
+  auto *ptr_1 = malloc(1);
+  auto func = [ptr_1]() { EXPECT_NE(nullptr, reallocf(ptr_1, 8)); };
+  expectRealtimeDeath(func, "reallocf");
+  expectNonrealtimeSurvival(func);
+}
+#endif
+
+TEST(TestRadsanInterceptors, vallocDiesWhenRealtime) {
+  auto func = []() { EXPECT_NE(nullptr, valloc(4)); };
+  expectRealtimeDeath(func, "valloc");
+  expectNonrealtimeSurvival(func);
+}
+
+#if SANITIZER_INTERCEPT_ALIGNED_ALLOC
+TEST(TestRadsanInterceptors, alignedAllocDiesWhenRealtime) {
+  auto func = []() { EXPECT_NE(nullptr, aligned_alloc(16, 32)); };
+  expectRealtimeDeath(func, "aligned_alloc");
+  expectNonrealtimeSurvival(func);
+}
+#endif
+
+// free_sized and free_aligned_sized (both C23) are not yet supported
+TEST(TestRadsanInterceptors, freeDiesWhenRealtime) {
+  auto *ptr_1 = malloc(1);
+  auto *ptr_2 = malloc(1);
+  expectRealtimeDeath([ptr_1]() { free(ptr_1); }, "free");
+  expectNonrealtimeSurvival([ptr_2]() { free(ptr_2); });
+
+  // Prevent malloc/free pair being optimised out
+  ASSERT_NE(nullptr, ptr_1);
+  ASSERT_NE(nullptr, ptr_2);
+}
+
+TEST(TestRadsanInterceptors, freeSurvivesWhenRealtimeIfArgumentIsNull) {
+  realtimeInvoke([]() { free(NULL); });
+  expectNonrealtimeSurvival([]() { free(NULL); });
+}
+
+TEST(TestRadsanInterceptors, posixMemalignDiesWhenRealtime) {
+  auto func = []() {
+    void *mem;
+    posix_memalign(&mem, 4, 4);
+  };
+  expectRealtimeDeath(func, "posix_memalign");
+  expectNonrealtimeSurvival(func);
+}
+
+#if SANITIZER_INTERCEPT_MEMALIGN
+TEST(TestRadsanInterceptors, memalignDiesWhenRealtime) {
+  auto func = []() { EXPECT_NE(memalign(2, 2048), nullptr); };
+  expectRealtimeDeath(func, "memalign");
+  expectNonrealtimeSurvival(func);
+}
+#endif
+
+#if SANITIZER_INTERCEPT_PVALLOC
+TEST(TestRadsanInterceptors, pvallocDiesWhenRealtime) {
+  auto func = []() { EXPECT_NE(pvalloc(2048), nullptr); };
+  expectRealtimeDeath(func, "pvalloc");
+  expectNonrealtimeSurvival(func);
+}
+#endif
+
+/*
+    Sleeping
+*/
+
+TEST(TestRadsanInterceptors, sleepDiesWhenRealtime) {
+  auto func = []() { sleep(0u); };
+  expectRealtimeDeath(func, "sleep");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, usleepDiesWhenRealtime) {
+  auto func = []() { usleep(1u); };
+  expectRealtimeDeath(func, "usleep");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, nanosleepDiesWhenRealtime) {
+  auto func = []() {
+    auto t = timespec{};
+    nanosleep(&t, &t);
+  };
+  expectRealtimeDeath(func, "nanosleep");
+  expectNonrealtimeSurvival(func);
+}
+
+/*
+    Filesystem
+*/
+
+TEST(TestRadsanInterceptors, openDiesWhenRealtime) {
+  auto func = []() { open(temporary_file_path(), O_RDONLY); };
+  expectRealtimeDeath(func, "open");
+  expectNonrealtimeSurvival(func);
+  std::remove(temporary_file_path());
+}
+
+TEST(TestRadsanInterceptors, openatDiesWhenRealtime) {
+  auto func = []() { openat(0, temporary_file_path(), O_RDONLY); };
+  expectRealtimeDeath(func, "openat");
+  expectNonrealtimeSurvival(func);
+  std::remove(temporary_file_path());
+}
+
+TEST(TestRadsanInterceptors, creatDiesWhenRealtime) {
+  auto func = []() { creat(temporary_file_path(), S_IWOTH | S_IROTH); };
+  expectRealtimeDeath(func, "creat");
+  expectNonrealtimeSurvival(func);
+  std::remove(temporary_file_path());
+}
+
+TEST(TestRadsanInterceptors, fcntlDiesWhenRealtime) {
+  auto func = []() { fcntl(0, F_GETFL); };
+  expectRealtimeDeath(func, "fcntl");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, closeDiesWhenRealtime) {
+  auto func = []() { close(0); };
+  expectRealtimeDeath(func, "close");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, fopenDiesWhenRealtime) {
+  auto func = []() {
+    auto fd = fopen(temporary_file_path(), "w");
+    EXPECT_THAT(fd, Ne(nullptr));
+  };
+  expectRealtimeDeath(func, "fopen");
+  expectNonrealtimeSurvival(func);
+  std::remove(temporary_file_path());
+}
+
+TEST(TestRadsanInterceptors, freadDiesWhenRealtime) {
+  auto fd = fopen(temporary_file_path(), "w");
+  auto func = [fd]() {
+    char c{};
+    fread(&c, 1, 1, fd);
+  };
+  expectRealtimeDeath(func, "fread");
+  expectNonrealtimeSurvival(func);
+  if (fd != nullptr)
+    fclose(fd);
+  std::remove(temporary_file_path());
+}
+
+TEST(TestRadsanInterceptors, fwriteDiesWhenRealtime) {
+  auto fd = fopen(temporary_file_path(), "w");
+  ASSERT_NE(nullptr, fd);
+  auto message = "Hello, world!";
+  auto func = [&]() { fwrite(&message, 1, 4, fd); };
+  expectRealtimeDeath(func, "fwrite");
+  expectNonrealtimeSurvival(func);
+  std::remove(temporary_file_path());
+}
+
+TEST(TestRadsanInterceptors, fcloseDiesWhenRealtime) {
+  auto fd = fopen(temporary_file_path(), "w");
+  EXPECT_THAT(fd, Ne(nullptr));
+  auto func = [fd]() { fclose(fd); };
+  expectRealtimeDeath(func, "fclose");
+  expectNonrealtimeSurvival(func);
+  std::remove(temporary_file_path());
+}
+
+TEST(TestRadsanInterceptors, putsDiesWhenRealtime) {
+  auto func = []() { puts("Hello, world!\n"); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, fputsDiesWhenRealtime) {
+  auto fd = fopen(temporary_file_path(), "w");
+  ASSERT_THAT(fd, Ne(nullptr)) << errno;
+  auto func = [fd]() { fputs("Hello, world!\n", fd); };
+  expectRealtimeDeath(func);
+  expectNonrealtimeSurvival(func);
+  if (fd != nullptr)
+    fclose(fd);
+  std::remove(temporary_file_path());
+}
+
+/*
+    Concurrency
+*/
+
+TEST(TestRadsanInterceptors, pthreadCreateDiesWhenRealtime) {
+  auto func = []() {
+    auto thread = pthread_t{};
+    auto const attr = pthread_attr_t{};
+    struct thread_info *tinfo;
+    pthread_create(&thread, &attr, &fake_thread_entry_point, tinfo);
+  };
+  expectRealtimeDeath(func, "pthread_create");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, pthreadMutexLockDiesWhenRealtime) {
+  auto func = []() {
+    auto mutex = pthread_mutex_t{};
+    pthread_mutex_lock(&mutex);
+  };
+
+  expectRealtimeDeath(func, "pthread_mutex_lock");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, pthreadMutexUnlockDiesWhenRealtime) {
+  auto func = []() {
+    auto mutex = pthread_mutex_t{};
+    pthread_mutex_unlock(&mutex);
+  };
+
+  expectRealtimeDeath(func, "pthread_mutex_unlock");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, pthreadMutexJoinDiesWhenRealtime) {
+  auto func = []() {
+    auto thread = pthread_t{};
+    pthread_join(thread, nullptr);
+  };
+
+  expectRealtimeDeath(func, "pthread_join");
+  expectNonrealtimeSurvival(func);
+}
+
+#if SANITIZER_APPLE
+
+#pragma clang diagnostic push
+// OSSpinLockLock is deprecated, but still in use in libc++
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+TEST(TestRadsanInterceptors, osSpinLockLockDiesWhenRealtime) {
+  auto func = []() {
+    auto spin_lock = OSSpinLock{};
+    OSSpinLockLock(&spin_lock);
+  };
+  expectRealtimeDeath(func, "OSSpinLockLock");
+  expectNonrealtimeSurvival(func);
+}
+#pragma clang diagnostic pop
+
+TEST(TestRadsanInterceptors, osUnfairLockLockDiesWhenRealtime) {
+  auto func = []() {
+    auto unfair_lock = os_unfair_lock_s{};
+    os_unfair_lock_lock(&unfair_lock);
+  };
+  expectRealtimeDeath(func, "os_unfair_lock_lock");
+  expectNonrealtimeSurvival(func);
+}
+#endif
+
+#if SANITIZER_LINUX
+TEST(TestRadsanInterceptors, spinLockLockDiesWhenRealtime) {
+  auto spinlock = pthread_spinlock_t{};
+  pthread_spin_init(&spinlock, PTHREAD_PROCESS_SHARED);
+  auto func = [&]() { pthread_spin_lock(&spinlock); };
+  expectRealtimeDeath(func, "pthread_spin_lock");
+  expectNonrealtimeSurvival(func);
+}
+#endif
+
+TEST(TestRadsanInterceptors, pthreadCondSignalDiesWhenRealtime) {
+  auto func = []() {
+    auto cond = pthread_cond_t{};
+    pthread_cond_signal(&cond);
+  };
+  expectRealtimeDeath(func, "pthread_cond_signal");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, pthreadCondBroadcastDiesWhenRealtime) {
+  auto func = []() {
+    auto cond = pthread_cond_t{};
+    pthread_cond_broadcast(&cond);
+  };
+  expectRealtimeDeath(func, "pthread_cond_broadcast");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, pthreadCondWaitDiesWhenRealtime) {
+  auto cond = pthread_cond_t{};
+  auto mutex = pthread_mutex_t{};
+  ASSERT_EQ(0, pthread_cond_init(&cond, nullptr));
+  ASSERT_EQ(0, pthread_mutex_init(&mutex, nullptr));
+  auto func = [&]() { pthread_cond_wait(&cond, &mutex); };
+  expectRealtimeDeath(func, "pthread_cond_wait");
+  // It's very difficult to test the success case here without doing some
+  // sleeping, which is at the mercy of the scheduler. What's really important
+  // here is the interception - so we're only testing that for now.
+}
+
+TEST(TestRadsanInterceptors, pthreadRwlockRdlockDiesWhenRealtime) {
+  auto func = []() {
+    auto rwlock = pthread_rwlock_t{};
+    pthread_rwlock_rdlock(&rwlock);
+  };
+  expectRealtimeDeath(func, "pthread_rwlock_rdlock");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, pthreadRwlockUnlockDiesWhenRealtime) {
+  auto func = []() {
+    auto rwlock = pthread_rwlock_t{};
+    pthread_rwlock_unlock(&rwlock);
+  };
+  expectRealtimeDeath(func, "pthread_rwlock_unlock");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, pthreadRwlockWrlockDiesWhenRealtime) {
+  auto func = []() {
+    auto rwlock = pthread_rwlock_t{};
+    pthread_rwlock_wrlock(&rwlock);
+  };
+  expectRealtimeDeath(func, "pthread_rwlock_wrlock");
+  expectNonrealtimeSurvival(func);
+}
+
+/*
+    Sockets
+*/
+TEST(TestRadsanInterceptors, openingASocketDiesWhenRealtime) {
+  auto func = []() { socket(PF_INET, SOCK_STREAM, 0); };
+  expectRealtimeDeath(func, "socket");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, sendToASocketDiesWhenRealtime) {
+  auto func = []() { send(0, nullptr, 0, 0); };
+  expectRealtimeDeath(func, "send");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, sendmsgToASocketDiesWhenRealtime) {
+  auto const msg = msghdr{};
+  auto func = [&]() { sendmsg(0, &msg, 0); };
+  expectRealtimeDeath(func, "sendmsg");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, sendtoToASocketDiesWhenRealtime) {
+  auto const addr = sockaddr{};
+  auto const len = socklen_t{};
+  auto func = [&]() { sendto(0, nullptr, 0, 0, &addr, len); };
+  expectRealtimeDeath(func, "sendto");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, recvFromASocketDiesWhenRealtime) {
+  auto func = []() { recv(0, nullptr, 0, 0); };
+  expectRealtimeDeath(func, "recv");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, recvfromOnASocketDiesWhenRealtime) {
+  auto addr = sockaddr{};
+  auto len = socklen_t{};
+  auto func = [&]() { recvfrom(0, nullptr, 0, 0, &addr, &len); };
+  expectRealtimeDeath(func, "recvfrom");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, recvmsgOnASocketDiesWhenRealtime) {
+  auto msg = msghdr{};
+  auto func = [&]() { recvmsg(0, &msg, 0); };
+  expectRealtimeDeath(func, "recvmsg");
+  expectNonrealtimeSurvival(func);
+}
+
+TEST(TestRadsanInterceptors, shutdownOnASocketDiesWhenRealtime) {
+  auto func = [&]() { shutdown(0, 0); };
+  expectRealtimeDeath(func, "shutdown");
+  expectNonrealtimeSurvival(func);
+}
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_main.cpp b/compiler-rt/lib/radsan/tests/radsan_test_main.cpp
new file mode 100644
index 0000000000000..5777a0b69a93f
--- /dev/null
+++ b/compiler-rt/lib/radsan/tests/radsan_test_main.cpp
@@ -0,0 +1,17 @@
+//===--- radsan_test_main.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_test_utils.h"
+
+int main(int argc, char **argv) {
+  testing::GTEST_FLAG(death_test_style) = "threadsafe";
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
new file mode 100644
index 0000000000000..fb3681aa97b06
--- /dev/null
+++ b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
@@ -0,0 +1,49 @@
+//===--- radsan_test_utilities.h - Realtime Sanitizer --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "gmock/gmock.h"
+#include "radsan.h"
+#include <string>
+
+namespace radsan_testing {
+
+template <typename Function>
+void realtimeInvoke(Function &&func) 
+{
+  radsan_realtime_enter();
+  std::forward<Function>(func)();
+  radsan_realtime_exit();
+}
+
+template <typename Function>
+void expectRealtimeDeath(Function &&func,
+                         const char *intercepted_method_name = nullptr) {
+
+  using namespace testing;
+
+  auto expected_error_substr = [&]() -> std::string {
+    return intercepted_method_name != nullptr
+               ? "Real-time violation: intercepted call to real-time unsafe "
+                 "function `" +
+                     std::string(intercepted_method_name) + "`"
+               : "";
+  };
+
+  EXPECT_EXIT(realtimeInvoke(std::forward<Function>(func)),
+              ExitedWithCode(EXIT_FAILURE), expected_error_substr());
+}
+
+template <typename Function> void expectNonrealtimeSurvival(Function &&func) {
+  std::forward<Function>(func)();
+}
+
+} // namespace radsan_testing
diff --git a/compiler-rt/test/radsan/CMakeLists.txt b/compiler-rt/test/radsan/CMakeLists.txt
new file mode 100644
index 0000000000000..51a3ff72859b6
--- /dev/null
+++ b/compiler-rt/test/radsan/CMakeLists.txt
@@ -0,0 +1,47 @@
+set(RADSAN_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(RADSAN_TESTSUITES)
+set(RADSAN_FDR_TESTSUITES)
+
+set(RADSAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+set(RADSAN_FDR_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+set(RADSAN_TEST_ARCH ${RADSAN_SUPPORTED_ARCH})
+if(APPLE)
+  darwin_filter_host_archs(RADSAN_SUPPORTED_ARCH RADSAN_TEST_ARCH)
+endif()
+
+if (COMPILER_RT_HAS_RADSAN)
+  foreach(arch ${RADSAN_TEST_ARCH})
+    set(RADSAN_TEST_TARGET_ARCH ${arch})
+    string(TOLOWER "-${arch}-${OS_NAME}" RADSAN_TEST_CONFIG_SUFFIX)
+    get_test_cc_for_arch(${arch} RADSAN_TEST_TARGET_CC RADSAN_TEST_TARGET_CFLAGS)
+    string(TOUPPER ${arch} ARCH_UPPER_CASE)
+    set(CONFIG_NAME ${ARCH_UPPER_CASE}${OS_NAME}Config)
+
+    configure_lit_site_cfg(
+      ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
+      ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg.py)
+    list(APPEND RADSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
+  endforeach()
+endif()
+
+if(COMPILER_RT_INCLUDE_TESTS)
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.py.in
+    ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg.py)
+  if(COMPILER_RT_RADSAN_HAS_STATIC_RUNTIME)
+    configure_lit_site_cfg(
+      ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.py.in
+      ${CMAKE_CURRENT_BINARY_DIR}/Unit/dynamic/lit.site.cfg.py)
+  endif()
+  list(APPEND RADSAN_TEST_DEPS RadsanUnitTests)
+  list(APPEND RADSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit)
+  if(COMPILER_RT_RADSAN_HAS_STATIC_RUNTIME)
+    list(APPEND RADSAN_DYNAMIC_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit/dynamic)
+  endif()
+endif()
+
+add_lit_testsuite(check-radsan "Running the Radsan tests"
+  ${RADSAN_TESTSUITES}
+  DEPENDS ${RADSAN_TEST_DEPS})
+set_target_properties(check-radsan PROPERTIES FOLDER "Compiler-RT Misc")
diff --git a/compiler-rt/test/radsan/Unit/lit.site.cfg.py.in b/compiler-rt/test/radsan/Unit/lit.site.cfg.py.in
new file mode 100644
index 0000000000000..432e0ed5e1907
--- /dev/null
+++ b/compiler-rt/test/radsan/Unit/lit.site.cfg.py.in
@@ -0,0 +1,25 @@
+ at LIT_SITE_CFG_IN_HEADER@
+
+# Load common config for all compiler-rt unit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/unittests/lit.common.unit.configured")
+
+# Setup config name.
+config.name = 'RealtimeSanitizer-Unit'
+
+# Setup test source and exec root. For unit tests, we define
+# it as build directory with ASan unit tests.
+# FIXME: De-hardcode this path.
+config.test_exec_root = "@COMPILER_RT_BINARY_DIR@/lib/radsan/tests"
+config.test_source_root = config.test_exec_root
+
+if not config.parallelism_group:
+  config.parallelism_group = 'shadow-memory'
+
+if config.host_os == 'Darwin':
+  # On Darwin, we default to ignore_noninstrumented_modules=1, which also
+  # suppresses some races the tests are supposed to find.  See radsan/lit.cfg.py.
+  if 'RADSAN_OPTIONS' in config.environment:
+    config.environment['RADSAN_OPTIONS'] += ':ignore_noninstrumented_modules=0'
+  else:
+    config.environment['RADSAN_OPTIONS'] = 'ignore_noninstrumented_modules=0'
+  config.environment['RADSAN_OPTIONS'] += ':ignore_interceptors_accesses=0'
diff --git a/compiler-rt/test/radsan/lit.cfg.py b/compiler-rt/test/radsan/lit.cfg.py
new file mode 100644
index 0000000000000..773b624900fa6
--- /dev/null
+++ b/compiler-rt/test/radsan/lit.cfg.py
@@ -0,0 +1,69 @@
+# -*- Python -*-
+
+import os
+
+# Setup config name.
+config.name = "RADSAN" + config.name_suffix
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+# Setup default compiler flags use with -fradsan-instrument option.
+clang_radsan_cflags = ["-fradsan-instrument", config.target_cflags]
+
+# If libc++ was used to build radsan libraries, libc++ is needed. Fix applied
+# to Linux only since -rpath may not be portable. This can be extended to
+# other platforms.
+if config.libcxx_used == "1" and config.host_os == "Linux":
+    clang_radsan_cflags = clang_radsan_cflags + (
+        ["-L%s -lc++ -Wl,-rpath=%s" % (config.llvm_shlib_dir, config.llvm_shlib_dir)]
+    )
+
+clang_radsan_cxxflags = config.cxx_mode_flags + clang_radsan_cflags
+
+
+def build_invocation(compile_flags):
+    return " " + " ".join([config.clang] + compile_flags) + " "
+
+
+# Assume that llvm-radsan is in the config.llvm_tools_dir.
+llvm_radsan = os.path.join(config.llvm_tools_dir, "llvm-radsan")
+
+# Setup substitutions.
+if config.host_os == "Linux":
+    libdl_flag = "-ldl"
+else:
+    libdl_flag = ""
+
+config.substitutions.append(("%clang ", build_invocation([config.target_cflags])))
+config.substitutions.append(
+    ("%clangxx ", build_invocation(config.cxx_mode_flags + [config.target_cflags]))
+)
+config.substitutions.append(("%clang_radsan ", build_invocation(clang_radsan_cflags)))
+config.substitutions.append(("%clangxx_radsan", build_invocation(clang_radsan_cxxflags)))
+config.substitutions.append(("%llvm_radsan", llvm_radsan))
+config.substitutions.append(
+    (
+        "%radsanlib",
+        (
+            "-lm -lpthread %s -lrt -L%s "
+            "-Wl,-whole-archive -lclang_rt.radsan%s -Wl,-no-whole-archive"
+        )
+        % (libdl_flag, config.compiler_rt_libdir, config.target_suffix),
+    )
+)
+
+# Default test suffixes.
+config.suffixes = [".c", ".cpp"]
+
+if config.host_os not in ["Darwin", "FreeBSD", "Linux", "NetBSD", "OpenBSD"]:
+    config.unsupported = True
+elif "64" not in config.host_arch:
+    if "arm" in config.host_arch:
+        if "-mthumb" in config.target_cflags:
+            config.unsupported = True
+    else:
+        config.unsupported = True
+
+if config.host_os == "NetBSD":
+    config.substitutions.insert(0, ("%run", config.netbsd_nomprotect_prefix))
diff --git a/compiler-rt/test/radsan/lit.site.cfg.py.in b/compiler-rt/test/radsan/lit.site.cfg.py.in
new file mode 100644
index 0000000000000..7d509c9f2eb91
--- /dev/null
+++ b/compiler-rt/test/radsan/lit.site.cfg.py.in
@@ -0,0 +1,17 @@
+ at LIT_SITE_CFG_IN_HEADER@
+
+# Tool-specific config options.
+config.name_suffix = "@RADSAN_TEST_CONFIG_SUFFIX@"
+config.radsan_lit_source_dir = "@RADSAN_LIT_SOURCE_DIR@"
+config.target_cflags = "@RADSAN_TEST_TARGET_CFLAGS@"
+config.target_arch = "@RADSAN_TEST_TARGET_ARCH@"
+config.built_with_llvm = ("@COMPILER_RT_STANDALONE_BUILD@" != "TRUE")
+
+if config.built_with_llvm:
+  config.available_features.add('built-in-llvm-tree')
+
+# Load common config for all compiler-rt lit tests
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@CMAKE_CURRENT_SOURCE_DIR@/lit.cfg.py")
diff --git a/compiler-rt/test/sanitizer_common/CMakeLists.txt b/compiler-rt/test/sanitizer_common/CMakeLists.txt
index edecc04d48c75..1c37cf2a0c721 100644
--- a/compiler-rt/test/sanitizer_common/CMakeLists.txt
+++ b/compiler-rt/test/sanitizer_common/CMakeLists.txt
@@ -7,7 +7,7 @@ set(SANITIZER_COMMON_TESTSUITES)
 # FIXME(dliew): We should switch to COMPILER_RT_SANITIZERS_TO_BUILD instead of
 # the hard coded `SUPPORTED_TOOLS_INIT` list once we know that the other
 # sanitizers work.
-set(SUPPORTED_TOOLS_INIT asan lsan hwasan msan tsan ubsan)
+set(SUPPORTED_TOOLS_INIT asan lsan hwasan msan radsan tsan ubsan)
 set(SUPPORTED_TOOLS)
   foreach(SANITIZER_TOOL ${SUPPORTED_TOOLS_INIT})
     string(TOUPPER ${SANITIZER_TOOL} SANITIZER_TOOL_UPPER)
diff --git a/compiler-rt/test/sanitizer_common/lit.common.cfg.py b/compiler-rt/test/sanitizer_common/lit.common.cfg.py
index 04af4816eb6e7..80c7372372f44 100644
--- a/compiler-rt/test/sanitizer_common/lit.common.cfg.py
+++ b/compiler-rt/test/sanitizer_common/lit.common.cfg.py
@@ -18,6 +18,9 @@
     tool_options = "HWASAN_OPTIONS"
     if not config.has_lld:
         config.unsupported = True
+elif config.tool_name == "radsan":
+    tool_cflags = ["-fsanitize=realtime"]
+    tool_options = "RADSAN_OPTIONS"
 elif config.tool_name == "tsan":
     tool_cflags = ["-fsanitize=thread"]
     tool_options = "TSAN_OPTIONS"

>From a4ac25f9d4f4b3a230c5407b13f7d0b4266b2b67 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Tue, 7 May 2024 15:28:48 -0700
Subject: [PATCH 02/44] Fixing some clang tidy foo

---
 .../lib/radsan/radsan_interceptors.cpp        |   8 +-
 compiler-rt/lib/radsan/tests/radsan_test.cpp  | 226 +++++++++---------
 .../radsan/tests/radsan_test_interceptors.cpp | 176 +++++++-------
 .../lib/radsan/tests/radsan_test_utilities.h  |   4 +-
 4 files changed, 207 insertions(+), 207 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
index d50ece6099b14..6d0bc52893b35 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.cpp
+++ b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -55,7 +55,7 @@ INTERCEPTOR(int, open, const char *path, int oflag, ...) {
   radsan::expectNotRealtime("open");
   va_list args;
   va_start(args, oflag);
-  auto result = REAL(open)(path, oflag, args);
+  const int result = REAL(open)(path, oflag, args);
   va_end(args);
   return result;
 }
@@ -66,7 +66,7 @@ INTERCEPTOR(int, openat, int fd, const char *path, int oflag, ...) {
   radsan::expectNotRealtime("openat");
   va_list args;
   va_start(args, oflag);
-  auto result = REAL(openat)(fd, path, oflag, args);
+  const int result = REAL(openat)(fd, path, oflag, args);
   va_end(args);
   return result;
 }
@@ -75,7 +75,7 @@ INTERCEPTOR(int, creat, const char *path, mode_t mode) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
   radsan::expectNotRealtime("creat");
-  auto result = REAL(creat)(path, mode);
+  const int result = REAL(creat)(path, mode);
   return result;
 }
 
@@ -83,7 +83,7 @@ INTERCEPTOR(int, fcntl, int filedes, int cmd, ...) {
   radsan::expectNotRealtime("fcntl");
   va_list args;
   va_start(args, cmd);
-  auto result = REAL(fcntl)(filedes, cmd, args);
+  const int result = REAL(fcntl)(filedes, cmd, args);
   va_end(args);
   return result;
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test.cpp b/compiler-rt/lib/radsan/tests/radsan_test.cpp
index 65c4380dfc602..9769e7a72779e 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test.cpp
@@ -36,168 +36,168 @@ using namespace testing;
 using namespace radsan_testing;
 using namespace std::chrono_literals;
 
-namespace {
-void invokeStdFunction(std::function<void()> &&function) { function(); }
-} // namespace
-
-TEST(TestRadsan, vectorPushBackAllocationDiesWhenRealtime) {
-  auto vec = std::vector<float>{};
-  auto func = [&vec]() { vec.push_back(0.4f); };
-  expectRealtimeDeath(func);
-  ASSERT_EQ(0u, vec.size());
-  expectNonrealtimeSurvival(func);
-  ASSERT_EQ(1u, vec.size());
-}
-
-TEST(TestRadsan, destructionOfObjectOnHeapDiesWhenRealtime) {
-  auto obj = std::make_unique<std::array<float, 256>>();
-  auto func = [&obj]() { obj.reset(); };
-  expectRealtimeDeath(func);
-  ASSERT_NE(nullptr, obj.get());
-  expectNonrealtimeSurvival(func);
-  ASSERT_EQ(nullptr, obj.get());
-}
-
-TEST(TestRadsan, sleepingAThreadDiesWhenRealtime) {
-  auto func = []() { std::this_thread::sleep_for(1us); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
-}
-
-TEST(TestRadsan, ifstreamCreationDiesWhenRealtime) {
-  auto func = []() { auto ifs = std::ifstream("./file.txt"); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+TEST(TestRadsan, VectorPushBackAllocationDiesWhenRealtime) {
+  std::vector<float> Vec{};
+  auto Func = [&Vec]() { Vec.push_back(0.4f); };
+  ExpectRealtimeDeath(Func);
+  ASSERT_EQ(0u, Vec.size());
+  ExpectNonRealtimeSurvival(Func);
+  ASSERT_EQ(1u, Vec.size());
+}
+
+TEST(TestRadsan, DestructionOfObjectOnHeapDiesWhenRealtime) {
+  auto AllocatedPtr = std::make_unique<std::array<float, 256>>();
+  auto Func = [&AllocatedPtr]() { AllocatedPtr.reset(); };
+  ExpectRealtimeDeath(Func);
+  ASSERT_NE(nullptr, AllocatedPtr.get());
+  ExpectNonRealtimeSurvival(Func);
+  ASSERT_EQ(nullptr, AllocatedPtr.get());
+}
+
+TEST(TestRadsan, SleepingAThreadDiesWhenRealtime) {
+  auto Func = []() { std::this_thread::sleep_for(1us); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
+}
+
+TEST(TestRadsan, IfstreamCreationDiesWhenRealtime) {
+  auto Func = []() { auto ifs = std::ifstream("./file.txt"); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
   std::remove("./file.txt");
 }
 
-TEST(TestRadsan, ofstreamCreationDiesWhenRealtime) {
-  auto func = []() { auto ofs = std::ofstream("./file.txt"); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+TEST(TestRadsan, OfstreamCreationDiesWhenRealtime) {
+  auto Func = []() { auto ofs = std::ofstream("./file.txt"); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
   std::remove("./file.txt");
 }
 
-TEST(TestRadsan, lockingAMutexDiesWhenRealtime) {
-  auto mutex = std::mutex{};
-  auto func = [&]() { mutex.lock(); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+TEST(TestRadsan, LockingAMutexDiesWhenRealtime) {
+  std::mutex Mutex{};
+  auto Func = [&]() { Mutex.lock(); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, unlockingAMutexDiesWhenRealtime) {
-  auto mutex = std::mutex{};
-  mutex.lock();
-  auto func = [&]() { mutex.unlock(); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+TEST(TestRadsan, UnlockingAMutexDiesWhenRealtime) {
+  std::mutex Mutex{};
+  Mutex.lock();
+  auto Func = [&]() { Mutex.unlock(); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
 #if RADSAN_TEST_SHARED_MUTEX
 
-TEST(TestRadsan, lockingASharedMutexDiesWhenRealtime) {
-  auto mutex = std::shared_mutex();
-  auto func = [&]() { mutex.lock(); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+TEST(TestRadsan, LockingASharedMutexDiesWhenRealtime) {
+  std::shared_mutex Mutex{};
+  auto Func = [&]() { Mutex.lock(); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, unlockingASharedMutexDiesWhenRealtime) {
-  auto mutex = std::shared_mutex();
-  mutex.lock();
-  auto func = [&]() { mutex.unlock(); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+TEST(TestRadsan, UnlockingASharedMutexDiesWhenRealtime) {
+  std::shared_mutex Mutex{};
+  Mutex.lock();
+  auto Func = [&]() { Mutex.unlock(); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, sharedLockingASharedMutexDiesWhenRealtime) {
-  auto mutex = std::shared_mutex();
-  auto func = [&]() { mutex.lock_shared(); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+TEST(TestRadsan, SharedLockingASharedMutexDiesWhenRealtime) {
+  std::shared_mutex Mutex{};
+  auto Func = [&]() { Mutex.lock_shared(); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, sharedUnlockingASharedMutexDiesWhenRealtime) {
-  auto mutex = std::shared_mutex();
-  mutex.lock_shared();
-  auto func = [&]() { mutex.unlock_shared(); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+TEST(TestRadsan, SharedUnlockingASharedMutexDiesWhenRealtime) {
+  std::shared_mutex Mutex{};
+  Mutex.lock_shared();
+  auto Func = [&]() { Mutex.unlock_shared(); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
 #endif // RADSAN_TEST_SHARED_MUTEX
 
-TEST(TestRadsan, launchingAThreadDiesWhenRealtime) {
-  auto func = [&]() {
+TEST(TestRadsan, LaunchingAThreadDiesWhenRealtime) {
+  auto Func = [&]() {
     auto t = std::thread([]() {});
     t.join();
   };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, copyingALambdaWithLargeCaptureDiesWhenRealtime) {
-  auto lots_of_data = std::array<float, 16>{};
-  auto lambda = [lots_of_data]() mutable {
+namespace {
+void InvokeStdFunction(std::function<void()> &&function) { function(); }
+} // namespace
+
+TEST(TestRadsan, CopyingALambdaWithLargeCaptureDiesWhenRealtime) {
+  std::array<float, 16> LotsOfData{};
+  auto lambda = [LotsOfData]() mutable {
     // Stop everything getting optimised out
-    lots_of_data[3] = 0.25f;
-    EXPECT_EQ(16, lots_of_data.size());
-    EXPECT_EQ(0.25f, lots_of_data[3]);
+    LotsOfData[3] = 0.25f;
+    EXPECT_EQ(16, LotsOfData.size());
+    EXPECT_EQ(0.25f, LotsOfData[3]);
   };
-  auto func = [&]() { invokeStdFunction(lambda); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+  auto Func = [&]() { InvokeStdFunction(lambda); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, accessingALargeAtomicVariableDiesWhenRealtime) {
-  auto small_atomic = std::atomic<float>{0.0f};
-  ASSERT_TRUE(small_atomic.is_lock_free());
-  realtimeInvoke([&small_atomic]() { auto x = small_atomic.load(); });
+TEST(TestRadsan, AccessingALargeAtomicVariableDiesWhenRealtime) {
+  std::atomic<float> SmallAtomic{0.0f};
+  ASSERT_TRUE(SmallAtomic.is_lock_free());
+  realtimeInvoke([&SmallAtomic]() { float x = SmallAtomic.load(); });
 
-  auto large_atomic = std::atomic<std::array<float, 2048>>{{}};
-  ASSERT_FALSE(large_atomic.is_lock_free());
-  auto func = [&]() { auto x = large_atomic.load(); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+  std::atomic<std::array<float, 2048>> LargeAtomic{};
+  ASSERT_FALSE(LargeAtomic.is_lock_free());
+  auto Func = [&]() { auto x = LargeAtomic.load(); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, firstCoutDiesWhenRealtime) {
-  auto func = []() { std::cout << "Hello, world!" << std::endl; };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+TEST(TestRadsan, FirstCoutDiesWhenRealtime) {
+  auto Func = []() { std::cout << "Hello, world!" << std::endl; };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, secondCoutDiesWhenRealtime) {
+TEST(TestRadsan, SecondCoutDiesWhenRealtime) {
   std::cout << "Hello, world";
-  auto func = []() { std::cout << "Hello, again!" << std::endl; };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+  auto Func = []() { std::cout << "Hello, again!" << std::endl; };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, printfDiesWhenRealtime) {
-  auto func = []() { printf("Hello, world!\n"); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+TEST(TestRadsan, PrintfDiesWhenRealtime) {
+  auto Func = []() { printf("Hello, world!\n"); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, throwingAnExceptionDiesWhenRealtime) {
-  auto func = [&]() {
+TEST(TestRadsan, ThrowingAnExceptionDiesWhenRealtime) {
+  auto Func = [&]() {
     try {
       throw std::exception();
     } catch (std::exception &) {
     }
   };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, doesNotDieIfTurnedOff) {
-  auto mutex = std::mutex{};
-  auto realtime_unsafe_func = [&]() {
+TEST(TestRadsan, DoesNotDieIfTurnedOff) {
+  std::mutex Mutex{};
+  auto RealtimeUnsafeFunc = [&]() {
     radsan_off();
-    mutex.lock();
-    mutex.unlock();
+    Mutex.lock();
+    Mutex.unlock();
     radsan_on();
   };
-  realtimeInvoke(realtime_unsafe_func);
+  realtimeInvoke(RealtimeUnsafeFunc);
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index 6b6bb6b76d7ff..95735d2059de3 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -62,37 +62,37 @@ constexpr const char *temporary_file_path() {
 
 TEST(TestRadsanInterceptors, mallocDiesWhenRealtime) {
   auto func = []() { EXPECT_NE(nullptr, malloc(1)); };
-  expectRealtimeDeath(func, "malloc");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "malloc");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, reallocDiesWhenRealtime) {
   auto *ptr_1 = malloc(1);
   auto func = [ptr_1]() { EXPECT_NE(nullptr, realloc(ptr_1, 8)); };
-  expectRealtimeDeath(func, "realloc");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "realloc");
+  ExpectNonRealtimeSurvival(func);
 }
 
 #if SANITIZER_APPLE
 TEST(TestRadsanInterceptors, reallocfDiesWhenRealtime) {
   auto *ptr_1 = malloc(1);
   auto func = [ptr_1]() { EXPECT_NE(nullptr, reallocf(ptr_1, 8)); };
-  expectRealtimeDeath(func, "reallocf");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "reallocf");
+  ExpectNonRealtimeSurvival(func);
 }
 #endif
 
 TEST(TestRadsanInterceptors, vallocDiesWhenRealtime) {
   auto func = []() { EXPECT_NE(nullptr, valloc(4)); };
-  expectRealtimeDeath(func, "valloc");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "valloc");
+  ExpectNonRealtimeSurvival(func);
 }
 
 #if SANITIZER_INTERCEPT_ALIGNED_ALLOC
 TEST(TestRadsanInterceptors, alignedAllocDiesWhenRealtime) {
   auto func = []() { EXPECT_NE(nullptr, aligned_alloc(16, 32)); };
-  expectRealtimeDeath(func, "aligned_alloc");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "aligned_alloc");
+  ExpectNonRealtimeSurvival(func);
 }
 #endif
 
@@ -100,8 +100,8 @@ TEST(TestRadsanInterceptors, alignedAllocDiesWhenRealtime) {
 TEST(TestRadsanInterceptors, freeDiesWhenRealtime) {
   auto *ptr_1 = malloc(1);
   auto *ptr_2 = malloc(1);
-  expectRealtimeDeath([ptr_1]() { free(ptr_1); }, "free");
-  expectNonrealtimeSurvival([ptr_2]() { free(ptr_2); });
+  ExpectRealtimeDeath([ptr_1]() { free(ptr_1); }, "free");
+  ExpectNonRealtimeSurvival([ptr_2]() { free(ptr_2); });
 
   // Prevent malloc/free pair being optimised out
   ASSERT_NE(nullptr, ptr_1);
@@ -110,7 +110,7 @@ TEST(TestRadsanInterceptors, freeDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, freeSurvivesWhenRealtimeIfArgumentIsNull) {
   realtimeInvoke([]() { free(NULL); });
-  expectNonrealtimeSurvival([]() { free(NULL); });
+  ExpectNonRealtimeSurvival([]() { free(NULL); });
 }
 
 TEST(TestRadsanInterceptors, posixMemalignDiesWhenRealtime) {
@@ -118,23 +118,23 @@ TEST(TestRadsanInterceptors, posixMemalignDiesWhenRealtime) {
     void *mem;
     posix_memalign(&mem, 4, 4);
   };
-  expectRealtimeDeath(func, "posix_memalign");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "posix_memalign");
+  ExpectNonRealtimeSurvival(func);
 }
 
 #if SANITIZER_INTERCEPT_MEMALIGN
 TEST(TestRadsanInterceptors, memalignDiesWhenRealtime) {
   auto func = []() { EXPECT_NE(memalign(2, 2048), nullptr); };
-  expectRealtimeDeath(func, "memalign");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "memalign");
+  ExpectNonRealtimeSurvival(func);
 }
 #endif
 
 #if SANITIZER_INTERCEPT_PVALLOC
 TEST(TestRadsanInterceptors, pvallocDiesWhenRealtime) {
   auto func = []() { EXPECT_NE(pvalloc(2048), nullptr); };
-  expectRealtimeDeath(func, "pvalloc");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "pvalloc");
+  ExpectNonRealtimeSurvival(func);
 }
 #endif
 
@@ -144,14 +144,14 @@ TEST(TestRadsanInterceptors, pvallocDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, sleepDiesWhenRealtime) {
   auto func = []() { sleep(0u); };
-  expectRealtimeDeath(func, "sleep");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "sleep");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, usleepDiesWhenRealtime) {
   auto func = []() { usleep(1u); };
-  expectRealtimeDeath(func, "usleep");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "usleep");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, nanosleepDiesWhenRealtime) {
@@ -159,8 +159,8 @@ TEST(TestRadsanInterceptors, nanosleepDiesWhenRealtime) {
     auto t = timespec{};
     nanosleep(&t, &t);
   };
-  expectRealtimeDeath(func, "nanosleep");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "nanosleep");
+  ExpectNonRealtimeSurvival(func);
 }
 
 /*
@@ -169,35 +169,35 @@ TEST(TestRadsanInterceptors, nanosleepDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, openDiesWhenRealtime) {
   auto func = []() { open(temporary_file_path(), O_RDONLY); };
-  expectRealtimeDeath(func, "open");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "open");
+  ExpectNonRealtimeSurvival(func);
   std::remove(temporary_file_path());
 }
 
 TEST(TestRadsanInterceptors, openatDiesWhenRealtime) {
   auto func = []() { openat(0, temporary_file_path(), O_RDONLY); };
-  expectRealtimeDeath(func, "openat");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "openat");
+  ExpectNonRealtimeSurvival(func);
   std::remove(temporary_file_path());
 }
 
 TEST(TestRadsanInterceptors, creatDiesWhenRealtime) {
   auto func = []() { creat(temporary_file_path(), S_IWOTH | S_IROTH); };
-  expectRealtimeDeath(func, "creat");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "creat");
+  ExpectNonRealtimeSurvival(func);
   std::remove(temporary_file_path());
 }
 
 TEST(TestRadsanInterceptors, fcntlDiesWhenRealtime) {
   auto func = []() { fcntl(0, F_GETFL); };
-  expectRealtimeDeath(func, "fcntl");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "fcntl");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, closeDiesWhenRealtime) {
   auto func = []() { close(0); };
-  expectRealtimeDeath(func, "close");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "close");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, fopenDiesWhenRealtime) {
@@ -205,8 +205,8 @@ TEST(TestRadsanInterceptors, fopenDiesWhenRealtime) {
     auto fd = fopen(temporary_file_path(), "w");
     EXPECT_THAT(fd, Ne(nullptr));
   };
-  expectRealtimeDeath(func, "fopen");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "fopen");
+  ExpectNonRealtimeSurvival(func);
   std::remove(temporary_file_path());
 }
 
@@ -216,8 +216,8 @@ TEST(TestRadsanInterceptors, freadDiesWhenRealtime) {
     char c{};
     fread(&c, 1, 1, fd);
   };
-  expectRealtimeDeath(func, "fread");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "fread");
+  ExpectNonRealtimeSurvival(func);
   if (fd != nullptr)
     fclose(fd);
   std::remove(temporary_file_path());
@@ -228,8 +228,8 @@ TEST(TestRadsanInterceptors, fwriteDiesWhenRealtime) {
   ASSERT_NE(nullptr, fd);
   auto message = "Hello, world!";
   auto func = [&]() { fwrite(&message, 1, 4, fd); };
-  expectRealtimeDeath(func, "fwrite");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "fwrite");
+  ExpectNonRealtimeSurvival(func);
   std::remove(temporary_file_path());
 }
 
@@ -237,23 +237,23 @@ TEST(TestRadsanInterceptors, fcloseDiesWhenRealtime) {
   auto fd = fopen(temporary_file_path(), "w");
   EXPECT_THAT(fd, Ne(nullptr));
   auto func = [fd]() { fclose(fd); };
-  expectRealtimeDeath(func, "fclose");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "fclose");
+  ExpectNonRealtimeSurvival(func);
   std::remove(temporary_file_path());
 }
 
 TEST(TestRadsanInterceptors, putsDiesWhenRealtime) {
   auto func = []() { puts("Hello, world!\n"); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func);
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, fputsDiesWhenRealtime) {
   auto fd = fopen(temporary_file_path(), "w");
   ASSERT_THAT(fd, Ne(nullptr)) << errno;
   auto func = [fd]() { fputs("Hello, world!\n", fd); };
-  expectRealtimeDeath(func);
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func);
+  ExpectNonRealtimeSurvival(func);
   if (fd != nullptr)
     fclose(fd);
   std::remove(temporary_file_path());
@@ -270,8 +270,8 @@ TEST(TestRadsanInterceptors, pthreadCreateDiesWhenRealtime) {
     struct thread_info *tinfo;
     pthread_create(&thread, &attr, &fake_thread_entry_point, tinfo);
   };
-  expectRealtimeDeath(func, "pthread_create");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "pthread_create");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, pthreadMutexLockDiesWhenRealtime) {
@@ -280,8 +280,8 @@ TEST(TestRadsanInterceptors, pthreadMutexLockDiesWhenRealtime) {
     pthread_mutex_lock(&mutex);
   };
 
-  expectRealtimeDeath(func, "pthread_mutex_lock");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "pthread_mutex_lock");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, pthreadMutexUnlockDiesWhenRealtime) {
@@ -290,8 +290,8 @@ TEST(TestRadsanInterceptors, pthreadMutexUnlockDiesWhenRealtime) {
     pthread_mutex_unlock(&mutex);
   };
 
-  expectRealtimeDeath(func, "pthread_mutex_unlock");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "pthread_mutex_unlock");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, pthreadMutexJoinDiesWhenRealtime) {
@@ -300,8 +300,8 @@ TEST(TestRadsanInterceptors, pthreadMutexJoinDiesWhenRealtime) {
     pthread_join(thread, nullptr);
   };
 
-  expectRealtimeDeath(func, "pthread_join");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "pthread_join");
+  ExpectNonRealtimeSurvival(func);
 }
 
 #if SANITIZER_APPLE
@@ -314,8 +314,8 @@ TEST(TestRadsanInterceptors, osSpinLockLockDiesWhenRealtime) {
     auto spin_lock = OSSpinLock{};
     OSSpinLockLock(&spin_lock);
   };
-  expectRealtimeDeath(func, "OSSpinLockLock");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "OSSpinLockLock");
+  ExpectNonRealtimeSurvival(func);
 }
 #pragma clang diagnostic pop
 
@@ -324,8 +324,8 @@ TEST(TestRadsanInterceptors, osUnfairLockLockDiesWhenRealtime) {
     auto unfair_lock = os_unfair_lock_s{};
     os_unfair_lock_lock(&unfair_lock);
   };
-  expectRealtimeDeath(func, "os_unfair_lock_lock");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "os_unfair_lock_lock");
+  ExpectNonRealtimeSurvival(func);
 }
 #endif
 
@@ -334,8 +334,8 @@ TEST(TestRadsanInterceptors, spinLockLockDiesWhenRealtime) {
   auto spinlock = pthread_spinlock_t{};
   pthread_spin_init(&spinlock, PTHREAD_PROCESS_SHARED);
   auto func = [&]() { pthread_spin_lock(&spinlock); };
-  expectRealtimeDeath(func, "pthread_spin_lock");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "pthread_spin_lock");
+  ExpectNonRealtimeSurvival(func);
 }
 #endif
 
@@ -344,8 +344,8 @@ TEST(TestRadsanInterceptors, pthreadCondSignalDiesWhenRealtime) {
     auto cond = pthread_cond_t{};
     pthread_cond_signal(&cond);
   };
-  expectRealtimeDeath(func, "pthread_cond_signal");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "pthread_cond_signal");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, pthreadCondBroadcastDiesWhenRealtime) {
@@ -353,8 +353,8 @@ TEST(TestRadsanInterceptors, pthreadCondBroadcastDiesWhenRealtime) {
     auto cond = pthread_cond_t{};
     pthread_cond_broadcast(&cond);
   };
-  expectRealtimeDeath(func, "pthread_cond_broadcast");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "pthread_cond_broadcast");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, pthreadCondWaitDiesWhenRealtime) {
@@ -363,7 +363,7 @@ TEST(TestRadsanInterceptors, pthreadCondWaitDiesWhenRealtime) {
   ASSERT_EQ(0, pthread_cond_init(&cond, nullptr));
   ASSERT_EQ(0, pthread_mutex_init(&mutex, nullptr));
   auto func = [&]() { pthread_cond_wait(&cond, &mutex); };
-  expectRealtimeDeath(func, "pthread_cond_wait");
+  ExpectRealtimeDeath(func, "pthread_cond_wait");
   // It's very difficult to test the success case here without doing some
   // sleeping, which is at the mercy of the scheduler. What's really important
   // here is the interception - so we're only testing that for now.
@@ -374,8 +374,8 @@ TEST(TestRadsanInterceptors, pthreadRwlockRdlockDiesWhenRealtime) {
     auto rwlock = pthread_rwlock_t{};
     pthread_rwlock_rdlock(&rwlock);
   };
-  expectRealtimeDeath(func, "pthread_rwlock_rdlock");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "pthread_rwlock_rdlock");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, pthreadRwlockUnlockDiesWhenRealtime) {
@@ -383,8 +383,8 @@ TEST(TestRadsanInterceptors, pthreadRwlockUnlockDiesWhenRealtime) {
     auto rwlock = pthread_rwlock_t{};
     pthread_rwlock_unlock(&rwlock);
   };
-  expectRealtimeDeath(func, "pthread_rwlock_unlock");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "pthread_rwlock_unlock");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, pthreadRwlockWrlockDiesWhenRealtime) {
@@ -392,8 +392,8 @@ TEST(TestRadsanInterceptors, pthreadRwlockWrlockDiesWhenRealtime) {
     auto rwlock = pthread_rwlock_t{};
     pthread_rwlock_wrlock(&rwlock);
   };
-  expectRealtimeDeath(func, "pthread_rwlock_wrlock");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "pthread_rwlock_wrlock");
+  ExpectNonRealtimeSurvival(func);
 }
 
 /*
@@ -401,54 +401,54 @@ TEST(TestRadsanInterceptors, pthreadRwlockWrlockDiesWhenRealtime) {
 */
 TEST(TestRadsanInterceptors, openingASocketDiesWhenRealtime) {
   auto func = []() { socket(PF_INET, SOCK_STREAM, 0); };
-  expectRealtimeDeath(func, "socket");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "socket");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, sendToASocketDiesWhenRealtime) {
   auto func = []() { send(0, nullptr, 0, 0); };
-  expectRealtimeDeath(func, "send");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "send");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, sendmsgToASocketDiesWhenRealtime) {
   auto const msg = msghdr{};
   auto func = [&]() { sendmsg(0, &msg, 0); };
-  expectRealtimeDeath(func, "sendmsg");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "sendmsg");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, sendtoToASocketDiesWhenRealtime) {
   auto const addr = sockaddr{};
   auto const len = socklen_t{};
   auto func = [&]() { sendto(0, nullptr, 0, 0, &addr, len); };
-  expectRealtimeDeath(func, "sendto");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "sendto");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, recvFromASocketDiesWhenRealtime) {
   auto func = []() { recv(0, nullptr, 0, 0); };
-  expectRealtimeDeath(func, "recv");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "recv");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, recvfromOnASocketDiesWhenRealtime) {
   auto addr = sockaddr{};
   auto len = socklen_t{};
   auto func = [&]() { recvfrom(0, nullptr, 0, 0, &addr, &len); };
-  expectRealtimeDeath(func, "recvfrom");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "recvfrom");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, recvmsgOnASocketDiesWhenRealtime) {
   auto msg = msghdr{};
   auto func = [&]() { recvmsg(0, &msg, 0); };
-  expectRealtimeDeath(func, "recvmsg");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "recvmsg");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, shutdownOnASocketDiesWhenRealtime) {
   auto func = [&]() { shutdown(0, 0); };
-  expectRealtimeDeath(func, "shutdown");
-  expectNonrealtimeSurvival(func);
+  ExpectRealtimeDeath(func, "shutdown");
+  ExpectNonRealtimeSurvival(func);
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
index fb3681aa97b06..dac88e4dd1c46 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
+++ b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
@@ -25,7 +25,7 @@ void realtimeInvoke(Function &&func)
 }
 
 template <typename Function>
-void expectRealtimeDeath(Function &&func,
+void ExpectRealtimeDeath(Function &&func,
                          const char *intercepted_method_name = nullptr) {
 
   using namespace testing;
@@ -42,7 +42,7 @@ void expectRealtimeDeath(Function &&func,
               ExitedWithCode(EXIT_FAILURE), expected_error_substr());
 }
 
-template <typename Function> void expectNonrealtimeSurvival(Function &&func) {
+template <typename Function> void ExpectNonRealtimeSurvival(Function &&func) {
   std::forward<Function>(func)();
 }
 

>From 05207011fe990de79055598345e41e6ed10a1124 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Tue, 7 May 2024 15:36:27 -0700
Subject: [PATCH 03/44] One round of renaming

---
 compiler-rt/lib/radsan/radsan.cpp             |  8 +-
 compiler-rt/lib/radsan/radsan_context.cpp     | 50 +++++-----
 compiler-rt/lib/radsan/radsan_context.h       | 20 ++--
 .../lib/radsan/radsan_interceptors.cpp        | 96 +++++++++----------
 .../lib/radsan/tests/radsan_test_context.cpp  | 60 ++++++------
 5 files changed, 117 insertions(+), 117 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan.cpp b/compiler-rt/lib/radsan/radsan.cpp
index 32a1f8223e55d..b4e56479b944a 100644
--- a/compiler-rt/lib/radsan/radsan.cpp
+++ b/compiler-rt/lib/radsan/radsan.cpp
@@ -17,18 +17,18 @@ extern "C" {
 RADSAN_EXPORT void radsan_init() { radsan::initialiseInterceptors(); }
 
 RADSAN_EXPORT void radsan_realtime_enter() {
-  radsan::getContextForThisThread().realtimePush();
+  radsan::getContextForThisThread().RealtimePush();
 }
 
 RADSAN_EXPORT void radsan_realtime_exit() {
-  radsan::getContextForThisThread().realtimePop();
+  radsan::getContextForThisThread().RealtimePop();
 }
 
 RADSAN_EXPORT void radsan_off() {
-  radsan::getContextForThisThread().bypassPush();
+  radsan::getContextForThisThread().BypassPush();
 }
 
 RADSAN_EXPORT void radsan_on() {
-  radsan::getContextForThisThread().bypassPop();
+  radsan::getContextForThisThread().BypassPop();
 }
 }
diff --git a/compiler-rt/lib/radsan/radsan_context.cpp b/compiler-rt/lib/radsan/radsan_context.cpp
index 5ca70d3fd9dc5..03e0a01d7cd97 100644
--- a/compiler-rt/lib/radsan/radsan_context.cpp
+++ b/compiler-rt/lib/radsan/radsan_context.cpp
@@ -24,9 +24,9 @@ using namespace __sanitizer;
 
 namespace detail {
 
-static pthread_key_t key;
-static pthread_once_t key_once = PTHREAD_ONCE_INIT;
-void internalFree(void *ptr) { InternalFree(ptr); }
+static pthread_key_t Key;
+static pthread_once_t KeyOnce = PTHREAD_ONCE_INIT;
+void internalFree(void *Ptr) { __sanitizer::InternalFree(Ptr); }
 
 } // namespace detail
 
@@ -34,49 +34,49 @@ namespace radsan {
 
 Context::Context() = default;
 
-void Context::realtimePush() { realtime_depth_++; }
+void Context::RealtimePush() { RealtimeDepth++; }
 
-void Context::realtimePop() { realtime_depth_--; }
+void Context::RealtimePop() { RealtimeDepth--; }
 
-void Context::bypassPush() { bypass_depth_++; }
+void Context::BypassPush() { BypassDepth++; }
 
-void Context::bypassPop() { bypass_depth_--; }
+void Context::BypassPop() { BypassDepth--; }
 
-void Context::expectNotRealtime(const char *intercepted_function_name) {
-  if (inRealtimeContext() && !isBypassed()) {
-    bypassPush();
-    printDiagnostics(intercepted_function_name);
+void Context::ExpectNotRealtime(const char *InterceptedFunctionName) {
+  if (InRealtimeContext() && !IsBypassed()) {
+    BypassPush();
+    PrintDiagnostics(InterceptedFunctionName);
     exit(EXIT_FAILURE);
-    bypassPop();
+    BypassPop();
   }
 }
 
-bool Context::inRealtimeContext() const { return realtime_depth_ > 0; }
+bool Context::InRealtimeContext() const { return RealtimeDepth > 0; }
 
-bool Context::isBypassed() const { return bypass_depth_ > 0; }
+bool Context::IsBypassed() const { return BypassDepth > 0; }
 
-void Context::printDiagnostics(const char *intercepted_function_name) {
+void Context::PrintDiagnostics(const char *InterceptedFunctionName) {
   fprintf(stderr,
           "Real-time violation: intercepted call to real-time unsafe function "
           "`%s` in real-time context! Stack trace:\n",
-          intercepted_function_name);
+          InterceptedFunctionName);
   radsan::printStackTrace();
 }
 
 Context &getContextForThisThread() {
-  auto make_tls_key = []() {
-    CHECK_EQ(pthread_key_create(&detail::key, detail::internalFree), 0);
+  auto MakeTlsKey = []() {
+    CHECK_EQ(pthread_key_create(&detail::Key, detail::internalFree), 0);
   };
 
-  pthread_once(&detail::key_once, make_tls_key);
-  auto *ptr = static_cast<Context *>(pthread_getspecific(detail::key));
-  if (ptr == nullptr) {
-    ptr = static_cast<Context *>(InternalAlloc(sizeof(Context)));
-    new(ptr) Context();
-    pthread_setspecific(detail::key, ptr);
+  pthread_once(&detail::KeyOnce, MakeTlsKey);
+  Context *CurrentThreadContext = static_cast<Context *>(pthread_getspecific(detail::Key));
+  if (CurrentThreadContext == nullptr) {
+    CurrentThreadContext = static_cast<Context *>(InternalAlloc(sizeof(Context)));
+    new(CurrentThreadContext) Context();
+    pthread_setspecific(detail::Key, CurrentThreadContext);
   }
 
-  return *ptr;
+  return *CurrentThreadContext;
 }
 
 } // namespace radsan
diff --git a/compiler-rt/lib/radsan/radsan_context.h b/compiler-rt/lib/radsan/radsan_context.h
index efd3677107469..1b841446b7c1f 100644
--- a/compiler-rt/lib/radsan/radsan_context.h
+++ b/compiler-rt/lib/radsan/radsan_context.h
@@ -16,21 +16,21 @@ class Context {
 public:
   Context();
 
-  void realtimePush();
-  void realtimePop();
+  void RealtimePush();
+  void RealtimePop();
 
-  void bypassPush();
-  void bypassPop();
+  void BypassPush();
+  void BypassPop();
 
-  void expectNotRealtime(const char *interpreted_function_name);
+  void ExpectNotRealtime(const char *interpreted_function_name);
 
 private:
-  bool inRealtimeContext() const;
-  bool isBypassed() const;
-  void printDiagnostics(const char *intercepted_function_name);
+  bool InRealtimeContext() const;
+  bool IsBypassed() const;
+  void PrintDiagnostics(const char *InterceptedFunctionName);
 
-  int realtime_depth_{0};
-  int bypass_depth_{0};
+  int RealtimeDepth{0};
+  int BypassDepth{0};
 };
 
 Context &getContextForThisThread();
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
index 6d0bc52893b35..4318f4382257d 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.cpp
+++ b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -40,8 +40,8 @@
 using namespace __sanitizer;
 
 namespace radsan {
-void expectNotRealtime(const char *intercepted_function_name) {
-  getContextForThisThread().expectNotRealtime(intercepted_function_name);
+void ExpectNotRealtime(const char *InterceptedFunctionName) {
+  getContextForThisThread().ExpectNotRealtime(InterceptedFunctionName);
 }
 } // namespace radsan
 
@@ -52,7 +52,7 @@ void expectNotRealtime(const char *intercepted_function_name) {
 INTERCEPTOR(int, open, const char *path, int oflag, ...) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
-  radsan::expectNotRealtime("open");
+  radsan::ExpectNotRealtime("open");
   va_list args;
   va_start(args, oflag);
   const int result = REAL(open)(path, oflag, args);
@@ -63,7 +63,7 @@ INTERCEPTOR(int, open, const char *path, int oflag, ...) {
 INTERCEPTOR(int, openat, int fd, const char *path, int oflag, ...) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
-  radsan::expectNotRealtime("openat");
+  radsan::ExpectNotRealtime("openat");
   va_list args;
   va_start(args, oflag);
   const int result = REAL(openat)(fd, path, oflag, args);
@@ -74,13 +74,13 @@ INTERCEPTOR(int, openat, int fd, const char *path, int oflag, ...) {
 INTERCEPTOR(int, creat, const char *path, mode_t mode) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
-  radsan::expectNotRealtime("creat");
+  radsan::ExpectNotRealtime("creat");
   const int result = REAL(creat)(path, mode);
   return result;
 }
 
 INTERCEPTOR(int, fcntl, int filedes, int cmd, ...) {
-  radsan::expectNotRealtime("fcntl");
+  radsan::ExpectNotRealtime("fcntl");
   va_list args;
   va_start(args, cmd);
   const int result = REAL(fcntl)(filedes, cmd, args);
@@ -89,34 +89,34 @@ INTERCEPTOR(int, fcntl, int filedes, int cmd, ...) {
 }
 
 INTERCEPTOR(int, close, int filedes) {
-  radsan::expectNotRealtime("close");
+  radsan::ExpectNotRealtime("close");
   return REAL(close)(filedes);
 }
 
 INTERCEPTOR(FILE *, fopen, const char *path, const char *mode) {
-  radsan::expectNotRealtime("fopen");
+  radsan::ExpectNotRealtime("fopen");
   return REAL(fopen)(path, mode);
 }
 
 INTERCEPTOR(size_t, fread, void *ptr, size_t size, size_t nitems,
             FILE *stream) {
-  radsan::expectNotRealtime("fread");
+  radsan::ExpectNotRealtime("fread");
   return REAL(fread)(ptr, size, nitems, stream);
 }
 
 INTERCEPTOR(size_t, fwrite, const void *ptr, size_t size, size_t nitems,
             FILE *stream) {
-  radsan::expectNotRealtime("fwrite");
+  radsan::ExpectNotRealtime("fwrite");
   return REAL(fwrite)(ptr, size, nitems, stream);
 }
 
 INTERCEPTOR(int, fclose, FILE *stream) {
-  radsan::expectNotRealtime("fclose");
+  radsan::ExpectNotRealtime("fclose");
   return REAL(fclose)(stream);
 }
 
 INTERCEPTOR(int, fputs, const char *s, FILE *stream) {
-  radsan::expectNotRealtime("fputs");
+  radsan::ExpectNotRealtime("fputs");
   return REAL(fputs)(s, stream);
 }
 
@@ -125,7 +125,7 @@ INTERCEPTOR(int, fputs, const char *s, FILE *stream) {
 */
 
 INTERCEPTOR(int, puts, const char *s) {
-  radsan::expectNotRealtime("puts");
+  radsan::ExpectNotRealtime("puts");
   return REAL(puts)(s);
 }
 
@@ -138,77 +138,77 @@ INTERCEPTOR(int, puts, const char *s) {
 // OSSpinLockLock is deprecated, but still in use in libc++
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 INTERCEPTOR(void, OSSpinLockLock, volatile OSSpinLock *lock) {
-  radsan::expectNotRealtime("OSSpinLockLock");
+  radsan::ExpectNotRealtime("OSSpinLockLock");
   return REAL(OSSpinLockLock)(lock);
 }
 #pragma clang diagnostic pop
 
 INTERCEPTOR(void, os_unfair_lock_lock, os_unfair_lock_t lock) {
-  radsan::expectNotRealtime("os_unfair_lock_lock");
+  radsan::ExpectNotRealtime("os_unfair_lock_lock");
   return REAL(os_unfair_lock_lock)(lock);
 }
 #elif SANITIZER_LINUX
 INTERCEPTOR(int, pthread_spin_lock, pthread_spinlock_t *spinlock) {
-  radsan::expectNotRealtime("pthread_spin_lock");
+  radsan::ExpectNotRealtime("pthread_spin_lock");
   return REAL(pthread_spin_lock)(spinlock);
 }
 #endif
 
 INTERCEPTOR(int, pthread_create, pthread_t *thread, const pthread_attr_t *attr,
             void *(*start_routine)(void *), void *arg) {
-  radsan::expectNotRealtime("pthread_create");
+  radsan::ExpectNotRealtime("pthread_create");
   return REAL(pthread_create)(thread, attr, start_routine, arg);
 }
 
 INTERCEPTOR(int, pthread_mutex_lock, pthread_mutex_t *mutex) {
-  radsan::expectNotRealtime("pthread_mutex_lock");
+  radsan::ExpectNotRealtime("pthread_mutex_lock");
   return REAL(pthread_mutex_lock)(mutex);
 }
 
 INTERCEPTOR(int, pthread_mutex_unlock, pthread_mutex_t *mutex) {
-  radsan::expectNotRealtime("pthread_mutex_unlock");
+  radsan::ExpectNotRealtime("pthread_mutex_unlock");
   return REAL(pthread_mutex_unlock)(mutex);
 }
 
 INTERCEPTOR(int, pthread_join, pthread_t thread, void **value_ptr) {
-  radsan::expectNotRealtime("pthread_join");
+  radsan::ExpectNotRealtime("pthread_join");
   return REAL(pthread_join)(thread, value_ptr);
 }
 
 INTERCEPTOR(int, pthread_cond_signal, pthread_cond_t *cond) {
-  radsan::expectNotRealtime("pthread_cond_signal");
+  radsan::ExpectNotRealtime("pthread_cond_signal");
   return REAL(pthread_cond_signal)(cond);
 }
 
 INTERCEPTOR(int, pthread_cond_broadcast, pthread_cond_t *cond) {
-  radsan::expectNotRealtime("pthread_cond_broadcast");
+  radsan::ExpectNotRealtime("pthread_cond_broadcast");
   return REAL(pthread_cond_broadcast)(cond);
 }
 
 INTERCEPTOR(int, pthread_cond_wait, pthread_cond_t *cond,
             pthread_mutex_t *mutex) {
-  radsan::expectNotRealtime("pthread_cond_wait");
+  radsan::ExpectNotRealtime("pthread_cond_wait");
   return REAL(pthread_cond_wait)(cond, mutex);
 }
 
 INTERCEPTOR(int, pthread_cond_timedwait, pthread_cond_t *cond,
             pthread_mutex_t *mutex, const timespec *ts) {
-  radsan::expectNotRealtime("pthread_cond_timedwait");
+  radsan::ExpectNotRealtime("pthread_cond_timedwait");
   return REAL(pthread_cond_timedwait)(cond, mutex, ts);
 }
 
 INTERCEPTOR(int, pthread_rwlock_rdlock, pthread_rwlock_t *lock) {
-  radsan::expectNotRealtime("pthread_rwlock_rdlock");
+  radsan::ExpectNotRealtime("pthread_rwlock_rdlock");
   return REAL(pthread_rwlock_rdlock)(lock);
 }
 
 INTERCEPTOR(int, pthread_rwlock_unlock, pthread_rwlock_t *lock) {
-  radsan::expectNotRealtime("pthread_rwlock_unlock");
+  radsan::ExpectNotRealtime("pthread_rwlock_unlock");
   return REAL(pthread_rwlock_unlock)(lock);
 }
 
 INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *lock) {
-  radsan::expectNotRealtime("pthread_rwlock_wrlock");
+  radsan::ExpectNotRealtime("pthread_rwlock_wrlock");
   return REAL(pthread_rwlock_wrlock)(lock);
 }
 
@@ -217,18 +217,18 @@ INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *lock) {
 */
 
 INTERCEPTOR(unsigned int, sleep, unsigned int s) {
-  radsan::expectNotRealtime("sleep");
+  radsan::ExpectNotRealtime("sleep");
   return REAL(sleep)(s);
 }
 
 INTERCEPTOR(int, usleep, useconds_t u) {
-  radsan::expectNotRealtime("usleep");
+  radsan::ExpectNotRealtime("usleep");
   return REAL(usleep)(u);
 }
 
 INTERCEPTOR(int, nanosleep, const struct timespec *rqtp,
             struct timespec *rmtp) {
-  radsan::expectNotRealtime("nanosleep");
+  radsan::ExpectNotRealtime("nanosleep");
   return REAL(nanosleep)(rqtp, rmtp);
 }
 
@@ -237,40 +237,40 @@ INTERCEPTOR(int, nanosleep, const struct timespec *rqtp,
 */
 
 INTERCEPTOR(void *, calloc, SIZE_T num, SIZE_T size) {
-  radsan::expectNotRealtime("calloc");
+  radsan::ExpectNotRealtime("calloc");
   return REAL(calloc)(num, size);
 }
 
 INTERCEPTOR(void, free, void *ptr) {
   if (ptr != NULL) {
-    radsan::expectNotRealtime("free");
+    radsan::ExpectNotRealtime("free");
   }
   return REAL(free)(ptr);
 }
 
 INTERCEPTOR(void *, malloc, SIZE_T size) {
-  radsan::expectNotRealtime("malloc");
+  radsan::ExpectNotRealtime("malloc");
   return REAL(malloc)(size);
 }
 
 INTERCEPTOR(void *, realloc, void *ptr, SIZE_T size) {
-  radsan::expectNotRealtime("realloc");
+  radsan::ExpectNotRealtime("realloc");
   return REAL(realloc)(ptr, size);
 }
 
 INTERCEPTOR(void *, reallocf, void *ptr, SIZE_T size) {
-  radsan::expectNotRealtime("reallocf");
+  radsan::ExpectNotRealtime("reallocf");
   return REAL(reallocf)(ptr, size);
 }
 
 INTERCEPTOR(void *, valloc, SIZE_T size) {
-  radsan::expectNotRealtime("valloc");
+  radsan::ExpectNotRealtime("valloc");
   return REAL(valloc)(size);
 }
 
 #if SANITIZER_INTERCEPT_ALIGNED_ALLOC
 INTERCEPTOR(void *, aligned_alloc, SIZE_T alignment, SIZE_T size) {
-  radsan::expectNotRealtime("aligned_alloc");
+  radsan::ExpectNotRealtime("aligned_alloc");
   return REAL(aligned_alloc)(alignment, size);
 }
 #define RADSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC INTERCEPT_FUNCTION(aligned_alloc)
@@ -279,20 +279,20 @@ INTERCEPTOR(void *, aligned_alloc, SIZE_T alignment, SIZE_T size) {
 #endif
 
 INTERCEPTOR(int, posix_memalign, void **memptr, size_t alignment, size_t size) {
-  radsan::expectNotRealtime("posix_memalign");
+  radsan::ExpectNotRealtime("posix_memalign");
   return REAL(posix_memalign)(memptr, alignment, size);
 }
 
 #if SANITIZER_INTERCEPT_MEMALIGN
 INTERCEPTOR(void *, memalign, size_t alignment, size_t size) {
-  radsan::expectNotRealtime("memalign");
+  radsan::ExpectNotRealtime("memalign");
   return REAL(memalign)(alignment, size);
 }
 #endif
 
 #if SANITIZER_INTERCEPT_PVALLOC
 INTERCEPTOR(void *, pvalloc, size_t size) {
-  radsan::expectNotRealtime("pvalloc");
+  radsan::ExpectNotRealtime("pvalloc");
   return REAL(pvalloc)(size);
 }
 #endif
@@ -302,45 +302,45 @@ INTERCEPTOR(void *, pvalloc, size_t size) {
 */
 
 INTERCEPTOR(int, socket, int domain, int type, int protocol) {
-  radsan::expectNotRealtime("socket");
+  radsan::ExpectNotRealtime("socket");
   return REAL(socket)(domain, type, protocol);
 }
 
 INTERCEPTOR(ssize_t, send, int sockfd, const void *buf, size_t len, int flags) {
-  radsan::expectNotRealtime("send");
+  radsan::ExpectNotRealtime("send");
   return REAL(send)(sockfd, buf, len, flags);
 }
 
 INTERCEPTOR(ssize_t, sendmsg, int socket, const struct msghdr *message,
             int flags) {
-  radsan::expectNotRealtime("sendmsg");
+  radsan::ExpectNotRealtime("sendmsg");
   return REAL(sendmsg)(socket, message, flags);
 }
 
 INTERCEPTOR(ssize_t, sendto, int socket, const void *buffer, size_t length,
             int flags, const struct sockaddr *dest_addr, socklen_t dest_len) {
-  radsan::expectNotRealtime("sendto");
+  radsan::ExpectNotRealtime("sendto");
   return REAL(sendto)(socket, buffer, length, flags, dest_addr, dest_len);
 }
 
 INTERCEPTOR(ssize_t, recv, int socket, void *buffer, size_t length, int flags) {
-  radsan::expectNotRealtime("recv");
+  radsan::ExpectNotRealtime("recv");
   return REAL(recv)(socket, buffer, length, flags);
 }
 
 INTERCEPTOR(ssize_t, recvfrom, int socket, void *buffer, size_t length,
             int flags, struct sockaddr *address, socklen_t *address_len) {
-  radsan::expectNotRealtime("recvfrom");
+  radsan::ExpectNotRealtime("recvfrom");
   return REAL(recvfrom)(socket, buffer, length, flags, address, address_len);
 }
 
 INTERCEPTOR(ssize_t, recvmsg, int socket, struct msghdr *message, int flags) {
-  radsan::expectNotRealtime("recvmsg");
+  radsan::ExpectNotRealtime("recvmsg");
   return REAL(recvmsg)(socket, message, flags);
 }
 
 INTERCEPTOR(int, shutdown, int socket, int how) {
-  radsan::expectNotRealtime("shutdown");
+  radsan::ExpectNotRealtime("shutdown");
   return REAL(shutdown)(socket, how);
 }
 
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
index c52a0fff3b7ef..b654ac958be4b 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
@@ -14,56 +14,56 @@
 
 TEST(TestRadsanContext, canCreateContext) { auto context = radsan::Context{}; }
 
-TEST(TestRadsanContext, expectNotRealtimeDoesNotDieBeforeRealtimePush) {
+TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieBeforeRealtimePush) {
   auto context = radsan::Context{};
-  context.expectNotRealtime("do_some_stuff");
+  context.ExpectNotRealtime("do_some_stuff");
 }
 
-TEST(TestRadsanContext, expectNotRealtimeDoesNotDieAfterPushAndPop) {
+TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterPushAndPop) {
   auto context = radsan::Context{};
-  context.realtimePush();
-  context.realtimePop();
-  context.expectNotRealtime("do_some_stuff");
+  context.RealtimePush();
+  context.RealtimePop();
+  context.ExpectNotRealtime("do_some_stuff");
 }
 
-TEST(TestRadsanContext, expectNotRealtimeDiesAfterRealtimePush) {
+TEST(TestRadsanContext, ExpectNotRealtimeDiesAfterRealtimePush) {
   auto context = radsan::Context{};
 
-  context.realtimePush();
-  EXPECT_DEATH(context.expectNotRealtime("do_some_stuff"), "");
+  context.RealtimePush();
+  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
 }
 
 TEST(TestRadsanContext,
-     expectNotRealtimeDiesAfterRealtimeAfterMorePushesThanPops) {
+     ExpectNotRealtimeDiesAfterRealtimeAfterMorePushesThanPops) {
   auto context = radsan::Context{};
 
-  context.realtimePush();
-  context.realtimePush();
-  context.realtimePush();
-  context.realtimePop();
-  context.realtimePop();
-  EXPECT_DEATH(context.expectNotRealtime("do_some_stuff"), "");
+  context.RealtimePush();
+  context.RealtimePush();
+  context.RealtimePush();
+  context.RealtimePop();
+  context.RealtimePop();
+  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
 }
 
-TEST(TestRadsanContext, expectNotRealtimeDoesNotDieAfterBypassPush) {
+TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterBypassPush) {
   auto context = radsan::Context{};
 
-  context.realtimePush();
-  context.bypassPush();
-  context.expectNotRealtime("do_some_stuff");
+  context.RealtimePush();
+  context.BypassPush();
+  context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext,
-     expectNotRealtimeDoesNotDieIfBypassDepthIsGreaterThanZero) {
+     ExpectNotRealtimeDoesNotDieIfBypassDepthIsGreaterThanZero) {
   auto context = radsan::Context{};
 
-  context.realtimePush();
-  context.bypassPush();
-  context.bypassPush();
-  context.bypassPush();
-  context.bypassPop();
-  context.bypassPop();
-  context.expectNotRealtime("do_some_stuff");
-  context.bypassPop();
-  EXPECT_DEATH(context.expectNotRealtime("do_some_stuff"), "");
+  context.RealtimePush();
+  context.BypassPush();
+  context.BypassPush();
+  context.BypassPush();
+  context.BypassPop();
+  context.BypassPop();
+  context.ExpectNotRealtime("do_some_stuff");
+  context.BypassPop();
+  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
 }

>From 59ae42015d429b0935e6c4123a8a72696b20f2e2 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Tue, 7 May 2024 15:54:08 -0700
Subject: [PATCH 04/44] Another round of style cleanups

---
 compiler-rt/lib/radsan/radsan.cpp             | 18 +++---
 compiler-rt/lib/radsan/radsan.h               | 12 ++--
 compiler-rt/lib/radsan/radsan_context.cpp     |  4 +-
 compiler-rt/lib/radsan/radsan_context.h       |  2 +-
 .../lib/radsan/radsan_interceptors.cpp        |  4 +-
 compiler-rt/lib/radsan/radsan_interceptors.h  |  2 +-
 compiler-rt/lib/radsan/radsan_stack.cpp       | 12 ++--
 compiler-rt/lib/radsan/radsan_stack.h         |  2 +-
 compiler-rt/lib/radsan/tests/radsan_test.cpp  |  4 +-
 .../lib/radsan/tests/radsan_test_context.cpp  | 62 +++++++++----------
 .../radsan/tests/radsan_test_interceptors.cpp |  2 +-
 .../lib/radsan/tests/radsan_test_utilities.h  | 16 ++---
 12 files changed, 70 insertions(+), 70 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan.cpp b/compiler-rt/lib/radsan/radsan.cpp
index b4e56479b944a..a859e8f4ce112 100644
--- a/compiler-rt/lib/radsan/radsan.cpp
+++ b/compiler-rt/lib/radsan/radsan.cpp
@@ -14,21 +14,21 @@
 #include <unistd.h>
 
 extern "C" {
-RADSAN_EXPORT void radsan_init() { radsan::initialiseInterceptors(); }
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_init() { radsan::InitializeInterceptors(); }
 
-RADSAN_EXPORT void radsan_realtime_enter() {
-  radsan::getContextForThisThread().RealtimePush();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_enter() {
+  radsan::GetContextForThisThread().RealtimePush();
 }
 
-RADSAN_EXPORT void radsan_realtime_exit() {
-  radsan::getContextForThisThread().RealtimePop();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_exit() {
+  radsan::GetContextForThisThread().RealtimePop();
 }
 
-RADSAN_EXPORT void radsan_off() {
-  radsan::getContextForThisThread().BypassPush();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_off() {
+  radsan::GetContextForThisThread().BypassPush();
 }
 
-RADSAN_EXPORT void radsan_on() {
-  radsan::getContextForThisThread().BypassPop();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_on() {
+  radsan::GetContextForThisThread().BypassPop();
 }
 }
diff --git a/compiler-rt/lib/radsan/radsan.h b/compiler-rt/lib/radsan/radsan.h
index 684cedd499ae7..ac644a80a0347 100644
--- a/compiler-rt/lib/radsan/radsan.h
+++ b/compiler-rt/lib/radsan/radsan.h
@@ -10,7 +10,7 @@
 
 #pragma once
 
-#define RADSAN_EXPORT __attribute__((visibility("default")))
+#include "sanitizer_common/sanitizer_internal_defs.h"
 
 extern "C" {
 
@@ -20,7 +20,7 @@ extern "C" {
 
     @warning Do not call this method as a user.
 */
-RADSAN_EXPORT void radsan_init();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_init();
 
 /** Enter real-time context.
 
@@ -30,7 +30,7 @@ RADSAN_EXPORT void radsan_init();
 
     @warning Do not call this method as a user
 */
-RADSAN_EXPORT void radsan_realtime_enter();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_enter();
 
 /** Exit the real-time context.
 
@@ -39,7 +39,7 @@ RADSAN_EXPORT void radsan_realtime_enter();
 
     @warning Do not call this method as a user
 */
-RADSAN_EXPORT void radsan_realtime_exit();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_exit();
 
 /** Disable all RADSan error reporting.
 
@@ -64,12 +64,12 @@ RADSAN_EXPORT void radsan_realtime_exit();
         }
 
 */
-RADSAN_EXPORT void radsan_off();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_off();
 
 /** Re-enable all RADSan error reporting.
 
     The counterpart to `radsan_off`. See the description for `radsan_off` for
     details about how to use this method.
 */
-RADSAN_EXPORT void radsan_on();
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_on();
 }
diff --git a/compiler-rt/lib/radsan/radsan_context.cpp b/compiler-rt/lib/radsan/radsan_context.cpp
index 03e0a01d7cd97..16fdf967ff4d8 100644
--- a/compiler-rt/lib/radsan/radsan_context.cpp
+++ b/compiler-rt/lib/radsan/radsan_context.cpp
@@ -60,10 +60,10 @@ void Context::PrintDiagnostics(const char *InterceptedFunctionName) {
           "Real-time violation: intercepted call to real-time unsafe function "
           "`%s` in real-time context! Stack trace:\n",
           InterceptedFunctionName);
-  radsan::printStackTrace();
+  radsan::PrintStackTrace();
 }
 
-Context &getContextForThisThread() {
+Context &GetContextForThisThread() {
   auto MakeTlsKey = []() {
     CHECK_EQ(pthread_key_create(&detail::Key, detail::internalFree), 0);
   };
diff --git a/compiler-rt/lib/radsan/radsan_context.h b/compiler-rt/lib/radsan/radsan_context.h
index 1b841446b7c1f..0cf8a61cbdde2 100644
--- a/compiler-rt/lib/radsan/radsan_context.h
+++ b/compiler-rt/lib/radsan/radsan_context.h
@@ -33,6 +33,6 @@ class Context {
   int BypassDepth{0};
 };
 
-Context &getContextForThisThread();
+Context &GetContextForThisThread();
 
 } // namespace radsan
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
index 4318f4382257d..f7fd005aa004d 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.cpp
+++ b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -41,7 +41,7 @@ using namespace __sanitizer;
 
 namespace radsan {
 void ExpectNotRealtime(const char *InterceptedFunctionName) {
-  getContextForThisThread().ExpectNotRealtime(InterceptedFunctionName);
+  GetContextForThisThread().ExpectNotRealtime(InterceptedFunctionName);
 }
 } // namespace radsan
 
@@ -349,7 +349,7 @@ INTERCEPTOR(int, shutdown, int socket, int how) {
 */
 
 namespace radsan {
-void initialiseInterceptors() {
+void InitializeInterceptors() {
   INTERCEPT_FUNCTION(calloc);
   INTERCEPT_FUNCTION(free);
   INTERCEPT_FUNCTION(malloc);
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.h b/compiler-rt/lib/radsan/radsan_interceptors.h
index d10f4a01d8c80..30b37fb24a70f 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.h
+++ b/compiler-rt/lib/radsan/radsan_interceptors.h
@@ -11,5 +11,5 @@
 #pragma once
 
 namespace radsan {
-void initialiseInterceptors();
+void InitializeInterceptors();
 }
diff --git a/compiler-rt/lib/radsan/radsan_stack.cpp b/compiler-rt/lib/radsan/radsan_stack.cpp
index b3cffa98b3ab9..e8cb4ae19ce88 100644
--- a/compiler-rt/lib/radsan/radsan_stack.cpp
+++ b/compiler-rt/lib/radsan/radsan_stack.cpp
@@ -28,7 +28,7 @@ void BufferedStackTrace::UnwindImpl(uptr pc, uptr bp, void *context,
 } // namespace __sanitizer
 
 namespace {
-void setGlobalStackTraceFormat() {
+void SetGlobalStackTraceFormat() {
   SetCommonFlagsDefaults();
   CommonFlags cf;
   cf.CopyFrom(*common_flags());
@@ -39,14 +39,14 @@ void setGlobalStackTraceFormat() {
 } // namespace
 
 namespace radsan {
-void printStackTrace() {
+void PrintStackTrace() {
 
-  auto stack = BufferedStackTrace{};
+  BufferedStackTrace Stack{};
 
   GET_CURRENT_PC_BP;
-  stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal);
+  Stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal);
 
-  setGlobalStackTraceFormat();
-  stack.Print();
+  SetGlobalStackTraceFormat();
+  Stack.Print();
 }
 } // namespace radsan
diff --git a/compiler-rt/lib/radsan/radsan_stack.h b/compiler-rt/lib/radsan/radsan_stack.h
index ee65a959431aa..29ef7d016f1ef 100644
--- a/compiler-rt/lib/radsan/radsan_stack.h
+++ b/compiler-rt/lib/radsan/radsan_stack.h
@@ -11,5 +11,5 @@
 #pragma once
 
 namespace radsan {
-void printStackTrace();
+void PrintStackTrace();
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test.cpp b/compiler-rt/lib/radsan/tests/radsan_test.cpp
index 9769e7a72779e..e049ee928c58c 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test.cpp
@@ -152,7 +152,7 @@ TEST(TestRadsan, CopyingALambdaWithLargeCaptureDiesWhenRealtime) {
 TEST(TestRadsan, AccessingALargeAtomicVariableDiesWhenRealtime) {
   std::atomic<float> SmallAtomic{0.0f};
   ASSERT_TRUE(SmallAtomic.is_lock_free());
-  realtimeInvoke([&SmallAtomic]() { float x = SmallAtomic.load(); });
+  RealtimeInvoke([&SmallAtomic]() { float x = SmallAtomic.load(); });
 
   std::atomic<std::array<float, 2048>> LargeAtomic{};
   ASSERT_FALSE(LargeAtomic.is_lock_free());
@@ -199,5 +199,5 @@ TEST(TestRadsan, DoesNotDieIfTurnedOff) {
     Mutex.unlock();
     radsan_on();
   };
-  realtimeInvoke(RealtimeUnsafeFunc);
+  RealtimeInvoke(RealtimeUnsafeFunc);
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
index b654ac958be4b..91822df5a841d 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
@@ -12,58 +12,58 @@
 
 #include "radsan_context.h"
 
-TEST(TestRadsanContext, canCreateContext) { auto context = radsan::Context{}; }
+TEST(TestRadsanContext, CanCreateContext) { radsan::Context Context{}; }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieBeforeRealtimePush) {
-  auto context = radsan::Context{};
-  context.ExpectNotRealtime("do_some_stuff");
+  radsan::Context Context{};
+  Context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterPushAndPop) {
-  auto context = radsan::Context{};
-  context.RealtimePush();
-  context.RealtimePop();
-  context.ExpectNotRealtime("do_some_stuff");
+  radsan::Context Context{};
+  Context.RealtimePush();
+  Context.RealtimePop();
+  Context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDiesAfterRealtimePush) {
-  auto context = radsan::Context{};
+  radsan::Context Context{};
 
-  context.RealtimePush();
-  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
+  Context.RealtimePush();
+  EXPECT_DEATH(Context.ExpectNotRealtime("do_some_stuff"), "");
 }
 
 TEST(TestRadsanContext,
      ExpectNotRealtimeDiesAfterRealtimeAfterMorePushesThanPops) {
-  auto context = radsan::Context{};
+  radsan::Context Context{};
 
-  context.RealtimePush();
-  context.RealtimePush();
-  context.RealtimePush();
-  context.RealtimePop();
-  context.RealtimePop();
-  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
+  Context.RealtimePush();
+  Context.RealtimePush();
+  Context.RealtimePush();
+  Context.RealtimePop();
+  Context.RealtimePop();
+  EXPECT_DEATH(Context.ExpectNotRealtime("do_some_stuff"), "");
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterBypassPush) {
-  auto context = radsan::Context{};
+  radsan::Context Context{};
 
-  context.RealtimePush();
-  context.BypassPush();
-  context.ExpectNotRealtime("do_some_stuff");
+  Context.RealtimePush();
+  Context.BypassPush();
+  Context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext,
      ExpectNotRealtimeDoesNotDieIfBypassDepthIsGreaterThanZero) {
-  auto context = radsan::Context{};
+  radsan::Context Context{};
 
-  context.RealtimePush();
-  context.BypassPush();
-  context.BypassPush();
-  context.BypassPush();
-  context.BypassPop();
-  context.BypassPop();
-  context.ExpectNotRealtime("do_some_stuff");
-  context.BypassPop();
-  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
+  Context.RealtimePush();
+  Context.BypassPush();
+  Context.BypassPush();
+  Context.BypassPush();
+  Context.BypassPop();
+  Context.BypassPop();
+  Context.ExpectNotRealtime("do_some_stuff");
+  Context.BypassPop();
+  EXPECT_DEATH(Context.ExpectNotRealtime("do_some_stuff"), "");
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index 95735d2059de3..a94fb5c7012df 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -109,7 +109,7 @@ TEST(TestRadsanInterceptors, freeDiesWhenRealtime) {
 }
 
 TEST(TestRadsanInterceptors, freeSurvivesWhenRealtimeIfArgumentIsNull) {
-  realtimeInvoke([]() { free(NULL); });
+  RealtimeInvoke([]() { free(NULL); });
   ExpectNonRealtimeSurvival([]() { free(NULL); });
 }
 
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
index dac88e4dd1c46..4a2510d5f87d4 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
+++ b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
@@ -17,20 +17,20 @@
 namespace radsan_testing {
 
 template <typename Function>
-void realtimeInvoke(Function &&func) 
+void RealtimeInvoke(Function &&Func) 
 {
   radsan_realtime_enter();
-  std::forward<Function>(func)();
+  std::forward<Function>(Func)();
   radsan_realtime_exit();
 }
 
 template <typename Function>
-void ExpectRealtimeDeath(Function &&func,
+void ExpectRealtimeDeath(Function &&Func,
                          const char *intercepted_method_name = nullptr) {
 
   using namespace testing;
 
-  auto expected_error_substr = [&]() -> std::string {
+  auto ExpectedErrorSubstring = [&]() -> std::string {
     return intercepted_method_name != nullptr
                ? "Real-time violation: intercepted call to real-time unsafe "
                  "function `" +
@@ -38,12 +38,12 @@ void ExpectRealtimeDeath(Function &&func,
                : "";
   };
 
-  EXPECT_EXIT(realtimeInvoke(std::forward<Function>(func)),
-              ExitedWithCode(EXIT_FAILURE), expected_error_substr());
+  EXPECT_EXIT(RealtimeInvoke(std::forward<Function>(Func)),
+              ExitedWithCode(EXIT_FAILURE), ExpectedErrorSubstring());
 }
 
-template <typename Function> void ExpectNonRealtimeSurvival(Function &&func) {
-  std::forward<Function>(func)();
+template <typename Function> void ExpectNonRealtimeSurvival(Function &&Func) {
+  std::forward<Function>(Func)();
 }
 
 } // namespace radsan_testing

>From a97f4be1722c8a286a7661a2c200428e5dc286e0 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Tue, 7 May 2024 16:10:47 -0700
Subject: [PATCH 05/44] more auto removal, more case fixing

---
 compiler-rt/lib/radsan/tests/radsan_test.cpp  |   8 +-
 .../radsan/tests/radsan_test_interceptors.cpp | 484 +++++++++---------
 2 files changed, 246 insertions(+), 246 deletions(-)

diff --git a/compiler-rt/lib/radsan/tests/radsan_test.cpp b/compiler-rt/lib/radsan/tests/radsan_test.cpp
index e049ee928c58c..521545ca8a9e2 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test.cpp
@@ -61,14 +61,14 @@ TEST(TestRadsan, SleepingAThreadDiesWhenRealtime) {
 }
 
 TEST(TestRadsan, IfstreamCreationDiesWhenRealtime) {
-  auto Func = []() { auto ifs = std::ifstream("./file.txt"); };
+  auto Func = []() { std::ifstream ifs{"./file.txt"}; };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
   std::remove("./file.txt");
 }
 
 TEST(TestRadsan, OfstreamCreationDiesWhenRealtime) {
-  auto Func = []() { auto ofs = std::ofstream("./file.txt"); };
+  auto Func = []() { std::ofstream ofs{"./file.txt"}; };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
   std::remove("./file.txt");
@@ -125,8 +125,8 @@ TEST(TestRadsan, SharedUnlockingASharedMutexDiesWhenRealtime) {
 
 TEST(TestRadsan, LaunchingAThreadDiesWhenRealtime) {
   auto Func = [&]() {
-    auto t = std::thread([]() {});
-    t.join();
+    std::thread Thread{[]() {}};
+    Thread.join();
   };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index a94fb5c7012df..20ed7c7542d03 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -38,7 +38,7 @@ using namespace radsan_testing;
 using namespace std::chrono_literals;
 
 namespace {
-void *fake_thread_entry_point(void *) { return nullptr; }
+void *FakeThreadEntryPoint(void *) { return nullptr; }
 
 /*
   The creat function doesn't seem to work on an ubuntu Docker image when the
@@ -47,7 +47,7 @@ void *fake_thread_entry_point(void *) { return nullptr; }
   shared volume (/tmp). This is volatile and will be cleaned up as soon as the
   container is stopped.
 */
-constexpr const char *temporary_file_path() {
+constexpr const char *TemporaryFilePath() {
 #if SANITIZER_LINUX
   return "/tmp/radsan_temporary_test_file.txt";
 #elif SANITIZER_APPLE
@@ -60,46 +60,46 @@ constexpr const char *temporary_file_path() {
     Allocation and deallocation
 */
 
-TEST(TestRadsanInterceptors, mallocDiesWhenRealtime) {
-  auto func = []() { EXPECT_NE(nullptr, malloc(1)); };
-  ExpectRealtimeDeath(func, "malloc");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, MallocDiesWhenRealtime) {
+  auto Func = []() { EXPECT_NE(nullptr, malloc(1)); };
+  ExpectRealtimeDeath(Func, "malloc");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, reallocDiesWhenRealtime) {
-  auto *ptr_1 = malloc(1);
-  auto func = [ptr_1]() { EXPECT_NE(nullptr, realloc(ptr_1, 8)); };
-  ExpectRealtimeDeath(func, "realloc");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, ReallocDiesWhenRealtime) {
+  void *ptr_1 = malloc(1);
+  auto Func = [ptr_1]() { EXPECT_NE(nullptr, realloc(ptr_1, 8)); };
+  ExpectRealtimeDeath(Func, "realloc");
+  ExpectNonRealtimeSurvival(Func);
 }
 
 #if SANITIZER_APPLE
-TEST(TestRadsanInterceptors, reallocfDiesWhenRealtime) {
-  auto *ptr_1 = malloc(1);
-  auto func = [ptr_1]() { EXPECT_NE(nullptr, reallocf(ptr_1, 8)); };
-  ExpectRealtimeDeath(func, "reallocf");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, ReallocfDiesWhenRealtime) {
+  void *ptr_1 = malloc(1);
+  auto Func = [ptr_1]() { EXPECT_NE(nullptr, reallocf(ptr_1, 8)); };
+  ExpectRealtimeDeath(Func, "reallocf");
+  ExpectNonRealtimeSurvival(Func);
 }
 #endif
 
-TEST(TestRadsanInterceptors, vallocDiesWhenRealtime) {
-  auto func = []() { EXPECT_NE(nullptr, valloc(4)); };
-  ExpectRealtimeDeath(func, "valloc");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, VallocDiesWhenRealtime) {
+  auto Func = []() { EXPECT_NE(nullptr, valloc(4)); };
+  ExpectRealtimeDeath(Func, "valloc");
+  ExpectNonRealtimeSurvival(Func);
 }
 
 #if SANITIZER_INTERCEPT_ALIGNED_ALLOC
-TEST(TestRadsanInterceptors, alignedAllocDiesWhenRealtime) {
-  auto func = []() { EXPECT_NE(nullptr, aligned_alloc(16, 32)); };
-  ExpectRealtimeDeath(func, "aligned_alloc");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, AlignedAllocDiesWhenRealtime) {
+  auto Func = []() { EXPECT_NE(nullptr, aligned_alloc(16, 32)); };
+  ExpectRealtimeDeath(Func, "aligned_alloc");
+  ExpectNonRealtimeSurvival(Func);
 }
 #endif
 
 // free_sized and free_aligned_sized (both C23) are not yet supported
-TEST(TestRadsanInterceptors, freeDiesWhenRealtime) {
-  auto *ptr_1 = malloc(1);
-  auto *ptr_2 = malloc(1);
+TEST(TestRadsanInterceptors, FreeDiesWhenRealtime) {
+  void *ptr_1 = malloc(1);
+  void *ptr_2 = malloc(1);
   ExpectRealtimeDeath([ptr_1]() { free(ptr_1); }, "free");
   ExpectNonRealtimeSurvival([ptr_2]() { free(ptr_2); });
 
@@ -108,33 +108,33 @@ TEST(TestRadsanInterceptors, freeDiesWhenRealtime) {
   ASSERT_NE(nullptr, ptr_2);
 }
 
-TEST(TestRadsanInterceptors, freeSurvivesWhenRealtimeIfArgumentIsNull) {
+TEST(TestRadsanInterceptors, FreeSurvivesWhenRealtimeIfArgumentIsNull) {
   RealtimeInvoke([]() { free(NULL); });
   ExpectNonRealtimeSurvival([]() { free(NULL); });
 }
 
-TEST(TestRadsanInterceptors, posixMemalignDiesWhenRealtime) {
-  auto func = []() {
-    void *mem;
-    posix_memalign(&mem, 4, 4);
+TEST(TestRadsanInterceptors, PosixMemalignDiesWhenRealtime) {
+  auto Func = []() {
+    void *Mem;
+    posix_memalign(&Mem, 4, 4);
   };
-  ExpectRealtimeDeath(func, "posix_memalign");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "posix_memalign");
+  ExpectNonRealtimeSurvival(Func);
 }
 
 #if SANITIZER_INTERCEPT_MEMALIGN
-TEST(TestRadsanInterceptors, memalignDiesWhenRealtime) {
-  auto func = []() { EXPECT_NE(memalign(2, 2048), nullptr); };
-  ExpectRealtimeDeath(func, "memalign");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, MemalignDiesWhenRealtime) {
+  auto Func = []() { EXPECT_NE(memalign(2, 2048), nullptr); };
+  ExpectRealtimeDeath(Func, "memalign");
+  ExpectNonRealtimeSurvival(Func);
 }
 #endif
 
 #if SANITIZER_INTERCEPT_PVALLOC
-TEST(TestRadsanInterceptors, pvallocDiesWhenRealtime) {
-  auto func = []() { EXPECT_NE(pvalloc(2048), nullptr); };
-  ExpectRealtimeDeath(func, "pvalloc");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, PvallocDiesWhenRealtime) {
+  auto Func = []() { EXPECT_NE(pvalloc(2048), nullptr); };
+  ExpectRealtimeDeath(Func, "pvalloc");
+  ExpectNonRealtimeSurvival(Func);
 }
 #endif
 
@@ -142,166 +142,166 @@ TEST(TestRadsanInterceptors, pvallocDiesWhenRealtime) {
     Sleeping
 */
 
-TEST(TestRadsanInterceptors, sleepDiesWhenRealtime) {
-  auto func = []() { sleep(0u); };
-  ExpectRealtimeDeath(func, "sleep");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, SleepDiesWhenRealtime) {
+  auto Func = []() { sleep(0u); };
+  ExpectRealtimeDeath(Func, "sleep");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, usleepDiesWhenRealtime) {
-  auto func = []() { usleep(1u); };
-  ExpectRealtimeDeath(func, "usleep");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, UsleepDiesWhenRealtime) {
+  auto Func = []() { usleep(1u); };
+  ExpectRealtimeDeath(Func, "usleep");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, nanosleepDiesWhenRealtime) {
-  auto func = []() {
-    auto t = timespec{};
-    nanosleep(&t, &t);
+TEST(TestRadsanInterceptors, NanosleepDiesWhenRealtime) {
+  auto Func = []() {
+    timespec T{};
+    nanosleep(&T, &T);
   };
-  ExpectRealtimeDeath(func, "nanosleep");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "nanosleep");
+  ExpectNonRealtimeSurvival(Func);
 }
 
 /*
     Filesystem
 */
 
-TEST(TestRadsanInterceptors, openDiesWhenRealtime) {
-  auto func = []() { open(temporary_file_path(), O_RDONLY); };
-  ExpectRealtimeDeath(func, "open");
-  ExpectNonRealtimeSurvival(func);
-  std::remove(temporary_file_path());
+TEST(TestRadsanInterceptors, OpenDiesWhenRealtime) {
+  auto Func = []() { open(TemporaryFilePath(), O_RDONLY); };
+  ExpectRealtimeDeath(Func, "open");
+  ExpectNonRealtimeSurvival(Func);
+  std::remove(TemporaryFilePath());
 }
 
-TEST(TestRadsanInterceptors, openatDiesWhenRealtime) {
-  auto func = []() { openat(0, temporary_file_path(), O_RDONLY); };
-  ExpectRealtimeDeath(func, "openat");
-  ExpectNonRealtimeSurvival(func);
-  std::remove(temporary_file_path());
+TEST(TestRadsanInterceptors, OpenatDiesWhenRealtime) {
+  auto Func = []() { openat(0, TemporaryFilePath(), O_RDONLY); };
+  ExpectRealtimeDeath(Func, "openat");
+  ExpectNonRealtimeSurvival(Func);
+  std::remove(TemporaryFilePath());
 }
 
-TEST(TestRadsanInterceptors, creatDiesWhenRealtime) {
-  auto func = []() { creat(temporary_file_path(), S_IWOTH | S_IROTH); };
-  ExpectRealtimeDeath(func, "creat");
-  ExpectNonRealtimeSurvival(func);
-  std::remove(temporary_file_path());
+TEST(TestRadsanInterceptors, CreatDiesWhenRealtime) {
+  auto Func = []() { creat(TemporaryFilePath(), S_IWOTH | S_IROTH); };
+  ExpectRealtimeDeath(Func, "creat");
+  ExpectNonRealtimeSurvival(Func);
+  std::remove(TemporaryFilePath());
 }
 
-TEST(TestRadsanInterceptors, fcntlDiesWhenRealtime) {
-  auto func = []() { fcntl(0, F_GETFL); };
-  ExpectRealtimeDeath(func, "fcntl");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, FcntlDiesWhenRealtime) {
+  auto Func = []() { fcntl(0, F_GETFL); };
+  ExpectRealtimeDeath(Func, "fcntl");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, closeDiesWhenRealtime) {
-  auto func = []() { close(0); };
-  ExpectRealtimeDeath(func, "close");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, CloseDiesWhenRealtime) {
+  auto Func = []() { close(0); };
+  ExpectRealtimeDeath(Func, "close");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, fopenDiesWhenRealtime) {
-  auto func = []() {
-    auto fd = fopen(temporary_file_path(), "w");
-    EXPECT_THAT(fd, Ne(nullptr));
+TEST(TestRadsanInterceptors, FopenDiesWhenRealtime) {
+  auto Func = []() {
+    FILE* Fd = fopen(TemporaryFilePath(), "w");
+    EXPECT_THAT(Fd, Ne(nullptr));
   };
-  ExpectRealtimeDeath(func, "fopen");
-  ExpectNonRealtimeSurvival(func);
-  std::remove(temporary_file_path());
+  ExpectRealtimeDeath(Func, "fopen");
+  ExpectNonRealtimeSurvival(Func);
+  std::remove(TemporaryFilePath());
 }
 
-TEST(TestRadsanInterceptors, freadDiesWhenRealtime) {
-  auto fd = fopen(temporary_file_path(), "w");
-  auto func = [fd]() {
+TEST(TestRadsanInterceptors, FreadDiesWhenRealtime) {
+  FILE* Fd = fopen(TemporaryFilePath(), "w");
+  auto Func = [Fd]() {
     char c{};
-    fread(&c, 1, 1, fd);
+    fread(&c, 1, 1, Fd);
   };
-  ExpectRealtimeDeath(func, "fread");
-  ExpectNonRealtimeSurvival(func);
-  if (fd != nullptr)
-    fclose(fd);
-  std::remove(temporary_file_path());
+  ExpectRealtimeDeath(Func, "fread");
+  ExpectNonRealtimeSurvival(Func);
+  if (Fd != nullptr)
+    fclose(Fd);
+  std::remove(TemporaryFilePath());
 }
 
-TEST(TestRadsanInterceptors, fwriteDiesWhenRealtime) {
-  auto fd = fopen(temporary_file_path(), "w");
-  ASSERT_NE(nullptr, fd);
-  auto message = "Hello, world!";
-  auto func = [&]() { fwrite(&message, 1, 4, fd); };
-  ExpectRealtimeDeath(func, "fwrite");
-  ExpectNonRealtimeSurvival(func);
-  std::remove(temporary_file_path());
+TEST(TestRadsanInterceptors, FwriteDiesWhenRealtime) {
+  FILE* Fd = fopen(TemporaryFilePath(), "w");
+  ASSERT_NE(nullptr, Fd);
+  const char* Message = "Hello, world!";
+  auto Func = [&]() { fwrite(&Message, 1, 4, Fd); };
+  ExpectRealtimeDeath(Func, "fwrite");
+  ExpectNonRealtimeSurvival(Func);
+  std::remove(TemporaryFilePath());
 }
 
-TEST(TestRadsanInterceptors, fcloseDiesWhenRealtime) {
-  auto fd = fopen(temporary_file_path(), "w");
-  EXPECT_THAT(fd, Ne(nullptr));
-  auto func = [fd]() { fclose(fd); };
-  ExpectRealtimeDeath(func, "fclose");
-  ExpectNonRealtimeSurvival(func);
-  std::remove(temporary_file_path());
+TEST(TestRadsanInterceptors, FcloseDiesWhenRealtime) {
+  FILE* Fd = fopen(TemporaryFilePath(), "w");
+  EXPECT_THAT(Fd, Ne(nullptr));
+  auto Func = [Fd]() { fclose(Fd); };
+  ExpectRealtimeDeath(Func, "fclose");
+  ExpectNonRealtimeSurvival(Func);
+  std::remove(TemporaryFilePath());
 }
 
-TEST(TestRadsanInterceptors, putsDiesWhenRealtime) {
-  auto func = []() { puts("Hello, world!\n"); };
-  ExpectRealtimeDeath(func);
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, PutsDiesWhenRealtime) {
+  auto Func = []() { puts("Hello, world!\n"); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, fputsDiesWhenRealtime) {
-  auto fd = fopen(temporary_file_path(), "w");
-  ASSERT_THAT(fd, Ne(nullptr)) << errno;
-  auto func = [fd]() { fputs("Hello, world!\n", fd); };
-  ExpectRealtimeDeath(func);
-  ExpectNonRealtimeSurvival(func);
-  if (fd != nullptr)
-    fclose(fd);
-  std::remove(temporary_file_path());
+TEST(TestRadsanInterceptors, FputsDiesWhenRealtime) {
+  FILE* Fd = fopen(TemporaryFilePath(), "w");
+  ASSERT_THAT(Fd, Ne(nullptr)) << errno;
+  auto Func = [Fd]() { fputs("Hello, world!\n", Fd); };
+  ExpectRealtimeDeath(Func);
+  ExpectNonRealtimeSurvival(Func);
+  if (Fd != nullptr)
+    fclose(Fd);
+  std::remove(TemporaryFilePath());
 }
 
 /*
     Concurrency
 */
 
-TEST(TestRadsanInterceptors, pthreadCreateDiesWhenRealtime) {
-  auto func = []() {
-    auto thread = pthread_t{};
-    auto const attr = pthread_attr_t{};
-    struct thread_info *tinfo;
-    pthread_create(&thread, &attr, &fake_thread_entry_point, tinfo);
+TEST(TestRadsanInterceptors, PthreadCreateDiesWhenRealtime) {
+  auto Func = []() {
+    pthread_t Thread{};
+    const pthread_attr_t Attr{};
+    struct thread_info *ThreadInfo;
+    pthread_create(&Thread, &Attr, &FakeThreadEntryPoint, ThreadInfo);
   };
-  ExpectRealtimeDeath(func, "pthread_create");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "pthread_create");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, pthreadMutexLockDiesWhenRealtime) {
-  auto func = []() {
-    auto mutex = pthread_mutex_t{};
-    pthread_mutex_lock(&mutex);
+TEST(TestRadsanInterceptors, PthreadMutexLockDiesWhenRealtime) {
+  auto Func = []() {
+    pthread_mutex_t Mutex{};
+    pthread_mutex_lock(&Mutex);
   };
 
-  ExpectRealtimeDeath(func, "pthread_mutex_lock");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "pthread_mutex_lock");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, pthreadMutexUnlockDiesWhenRealtime) {
-  auto func = []() {
-    auto mutex = pthread_mutex_t{};
-    pthread_mutex_unlock(&mutex);
+TEST(TestRadsanInterceptors, PthreadMutexUnlockDiesWhenRealtime) {
+  auto Func = []() {
+    pthread_mutex_t Mutex{};
+    pthread_mutex_unlock(&Mutex);
   };
 
-  ExpectRealtimeDeath(func, "pthread_mutex_unlock");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "pthread_mutex_unlock");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, pthreadMutexJoinDiesWhenRealtime) {
-  auto func = []() {
-    auto thread = pthread_t{};
-    pthread_join(thread, nullptr);
+TEST(TestRadsanInterceptors, PthreadMutexJoinDiesWhenRealtime) {
+  auto Func = []() {
+    pthread_t Thread{};
+    pthread_join(Thread, nullptr);
   };
 
-  ExpectRealtimeDeath(func, "pthread_join");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "pthread_join");
+  ExpectNonRealtimeSurvival(Func);
 }
 
 #if SANITIZER_APPLE
@@ -309,146 +309,146 @@ TEST(TestRadsanInterceptors, pthreadMutexJoinDiesWhenRealtime) {
 #pragma clang diagnostic push
 // OSSpinLockLock is deprecated, but still in use in libc++
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
-TEST(TestRadsanInterceptors, osSpinLockLockDiesWhenRealtime) {
-  auto func = []() {
-    auto spin_lock = OSSpinLock{};
-    OSSpinLockLock(&spin_lock);
+TEST(TestRadsanInterceptors, OsSpinLockLockDiesWhenRealtime) {
+  auto Func = []() {
+    OSSpinLock SpinLock{};
+    OSSpinLockLock(&SpinLock);
   };
-  ExpectRealtimeDeath(func, "OSSpinLockLock");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "OSSpinLockLock");
+  ExpectNonRealtimeSurvival(Func);
 }
 #pragma clang diagnostic pop
 
-TEST(TestRadsanInterceptors, osUnfairLockLockDiesWhenRealtime) {
-  auto func = []() {
-    auto unfair_lock = os_unfair_lock_s{};
-    os_unfair_lock_lock(&unfair_lock);
+TEST(TestRadsanInterceptors, OsUnfairLockLockDiesWhenRealtime) {
+  auto Func = []() {
+    os_unfair_lock_s UnfairLock{};
+    os_unfair_lock_lock(&UnfairLock);
   };
-  ExpectRealtimeDeath(func, "os_unfair_lock_lock");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "os_unfair_lock_lock");
+  ExpectNonRealtimeSurvival(Func);
 }
 #endif
 
 #if SANITIZER_LINUX
-TEST(TestRadsanInterceptors, spinLockLockDiesWhenRealtime) {
-  auto spinlock = pthread_spinlock_t{};
-  pthread_spin_init(&spinlock, PTHREAD_PROCESS_SHARED);
-  auto func = [&]() { pthread_spin_lock(&spinlock); };
-  ExpectRealtimeDeath(func, "pthread_spin_lock");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, SpinLockLockDiesWhenRealtime) {
+  pthread_spinlock_t SpinLock;
+  pthread_spin_init(&SpinLock, PTHREAD_PROCESS_SHARED);
+  auto Func = [&]() { pthread_spin_lock(&SpinLock); };
+  ExpectRealtimeDeath(Func, "pthread_spin_lock");
+  ExpectNonRealtimeSurvival(Func);
 }
 #endif
 
-TEST(TestRadsanInterceptors, pthreadCondSignalDiesWhenRealtime) {
-  auto func = []() {
-    auto cond = pthread_cond_t{};
-    pthread_cond_signal(&cond);
+TEST(TestRadsanInterceptors, PthreadCondSignalDiesWhenRealtime) {
+  auto Func = []() {
+    pthread_cond_t Cond{};
+    pthread_cond_signal(&Cond);
   };
-  ExpectRealtimeDeath(func, "pthread_cond_signal");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "pthread_cond_signal");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, pthreadCondBroadcastDiesWhenRealtime) {
-  auto func = []() {
-    auto cond = pthread_cond_t{};
-    pthread_cond_broadcast(&cond);
+TEST(TestRadsanInterceptors, PthreadCondBroadcastDiesWhenRealtime) {
+  auto Func = []() {
+    pthread_cond_t Cond;
+    pthread_cond_broadcast(&Cond);
   };
-  ExpectRealtimeDeath(func, "pthread_cond_broadcast");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "pthread_cond_broadcast");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, pthreadCondWaitDiesWhenRealtime) {
-  auto cond = pthread_cond_t{};
-  auto mutex = pthread_mutex_t{};
-  ASSERT_EQ(0, pthread_cond_init(&cond, nullptr));
-  ASSERT_EQ(0, pthread_mutex_init(&mutex, nullptr));
-  auto func = [&]() { pthread_cond_wait(&cond, &mutex); };
-  ExpectRealtimeDeath(func, "pthread_cond_wait");
+TEST(TestRadsanInterceptors, PthreadCondWaitDiesWhenRealtime) {
+  pthread_cond_t Cond;
+  pthread_mutex_t Mutex;
+  ASSERT_EQ(0, pthread_cond_init(&Cond, nullptr));
+  ASSERT_EQ(0, pthread_mutex_init(&Mutex, nullptr));
+  auto Func = [&]() { pthread_cond_wait(&Cond, &Mutex); };
+  ExpectRealtimeDeath(Func, "pthread_cond_wait");
   // It's very difficult to test the success case here without doing some
   // sleeping, which is at the mercy of the scheduler. What's really important
   // here is the interception - so we're only testing that for now.
 }
 
-TEST(TestRadsanInterceptors, pthreadRwlockRdlockDiesWhenRealtime) {
-  auto func = []() {
-    auto rwlock = pthread_rwlock_t{};
-    pthread_rwlock_rdlock(&rwlock);
+TEST(TestRadsanInterceptors, PthreadRwlockRdlockDiesWhenRealtime) {
+  auto Func = []() {
+    pthread_rwlock_t RwLock;
+    pthread_rwlock_rdlock(&RwLock);
   };
-  ExpectRealtimeDeath(func, "pthread_rwlock_rdlock");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "pthread_rwlock_rdlock");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, pthreadRwlockUnlockDiesWhenRealtime) {
-  auto func = []() {
-    auto rwlock = pthread_rwlock_t{};
-    pthread_rwlock_unlock(&rwlock);
+TEST(TestRadsanInterceptors, PthreadRwlockUnlockDiesWhenRealtime) {
+  auto Func = []() {
+    pthread_rwlock_t RwLock;
+    pthread_rwlock_unlock(&RwLock);
   };
-  ExpectRealtimeDeath(func, "pthread_rwlock_unlock");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "pthread_rwlock_unlock");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, pthreadRwlockWrlockDiesWhenRealtime) {
-  auto func = []() {
-    auto rwlock = pthread_rwlock_t{};
-    pthread_rwlock_wrlock(&rwlock);
+TEST(TestRadsanInterceptors, PthreadRwlockWrlockDiesWhenRealtime) {
+  auto Func = []() {
+    pthread_rwlock_t RwLock;
+    pthread_rwlock_wrlock(&RwLock);
   };
-  ExpectRealtimeDeath(func, "pthread_rwlock_wrlock");
-  ExpectNonRealtimeSurvival(func);
+  ExpectRealtimeDeath(Func, "pthread_rwlock_wrlock");
+  ExpectNonRealtimeSurvival(Func);
 }
 
 /*
     Sockets
 */
-TEST(TestRadsanInterceptors, openingASocketDiesWhenRealtime) {
-  auto func = []() { socket(PF_INET, SOCK_STREAM, 0); };
-  ExpectRealtimeDeath(func, "socket");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, OpeningASocketDiesWhenRealtime) {
+  auto Func = []() { socket(PF_INET, SOCK_STREAM, 0); };
+  ExpectRealtimeDeath(Func, "socket");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, sendToASocketDiesWhenRealtime) {
-  auto func = []() { send(0, nullptr, 0, 0); };
-  ExpectRealtimeDeath(func, "send");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, SendToASocketDiesWhenRealtime) {
+  auto Func = []() { send(0, nullptr, 0, 0); };
+  ExpectRealtimeDeath(Func, "send");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, sendmsgToASocketDiesWhenRealtime) {
-  auto const msg = msghdr{};
-  auto func = [&]() { sendmsg(0, &msg, 0); };
-  ExpectRealtimeDeath(func, "sendmsg");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, SendmsgToASocketDiesWhenRealtime) {
+  msghdr Msg{};
+  auto Func = [&]() { sendmsg(0, &Msg, 0); };
+  ExpectRealtimeDeath(Func, "sendmsg");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, sendtoToASocketDiesWhenRealtime) {
-  auto const addr = sockaddr{};
-  auto const len = socklen_t{};
-  auto func = [&]() { sendto(0, nullptr, 0, 0, &addr, len); };
-  ExpectRealtimeDeath(func, "sendto");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, SendtoToASocketDiesWhenRealtime) {
+  sockaddr Addr{};
+  socklen_t Len{};
+  auto Func = [&]() { sendto(0, nullptr, 0, 0, &Addr, Len); };
+  ExpectRealtimeDeath(Func, "sendto");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, recvFromASocketDiesWhenRealtime) {
-  auto func = []() { recv(0, nullptr, 0, 0); };
-  ExpectRealtimeDeath(func, "recv");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, RecvFromASocketDiesWhenRealtime) {
+  auto Func = []() { recv(0, nullptr, 0, 0); };
+  ExpectRealtimeDeath(Func, "recv");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, recvfromOnASocketDiesWhenRealtime) {
-  auto addr = sockaddr{};
-  auto len = socklen_t{};
-  auto func = [&]() { recvfrom(0, nullptr, 0, 0, &addr, &len); };
-  ExpectRealtimeDeath(func, "recvfrom");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, RecvfromOnASocketDiesWhenRealtime) {
+  sockaddr Addr{};
+  socklen_t Len{};
+  auto Func = [&]() { recvfrom(0, nullptr, 0, 0, &Addr, &Len); };
+  ExpectRealtimeDeath(Func, "recvfrom");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, recvmsgOnASocketDiesWhenRealtime) {
-  auto msg = msghdr{};
-  auto func = [&]() { recvmsg(0, &msg, 0); };
-  ExpectRealtimeDeath(func, "recvmsg");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, RecvmsgOnASocketDiesWhenRealtime) {
+  msghdr Msg{};
+  auto Func = [&]() { recvmsg(0, &Msg, 0); };
+  ExpectRealtimeDeath(Func, "recvmsg");
+  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, shutdownOnASocketDiesWhenRealtime) {
-  auto func = [&]() { shutdown(0, 0); };
-  ExpectRealtimeDeath(func, "shutdown");
-  ExpectNonRealtimeSurvival(func);
+TEST(TestRadsanInterceptors, ShutdownOnASocketDiesWhenRealtime) {
+  auto Func = [&]() { shutdown(0, 0); };
+  ExpectRealtimeDeath(Func, "shutdown");
+  ExpectNonRealtimeSurvival(Func);
 }

>From 8d9ea529f47a8902984d10639a484b417b624514 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Tue, 7 May 2024 16:15:32 -0700
Subject: [PATCH 06/44] Missing end of namespace comment

---
 compiler-rt/lib/radsan/radsan.cpp | 8 ++++++--
 compiler-rt/lib/radsan/radsan.h   | 3 ++-
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan.cpp b/compiler-rt/lib/radsan/radsan.cpp
index a859e8f4ce112..dbe787ea6f6e4 100644
--- a/compiler-rt/lib/radsan/radsan.cpp
+++ b/compiler-rt/lib/radsan/radsan.cpp
@@ -14,7 +14,10 @@
 #include <unistd.h>
 
 extern "C" {
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_init() { radsan::InitializeInterceptors(); }
+
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_init() { 
+  radsan::InitializeInterceptors(); 
+}
 
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_enter() {
   radsan::GetContextForThisThread().RealtimePush();
@@ -31,4 +34,5 @@ SANITIZER_INTERFACE_ATTRIBUTE void radsan_off() {
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_on() {
   radsan::GetContextForThisThread().BypassPop();
 }
-}
+
+} // extern "C"
diff --git a/compiler-rt/lib/radsan/radsan.h b/compiler-rt/lib/radsan/radsan.h
index ac644a80a0347..61205e93e29ed 100644
--- a/compiler-rt/lib/radsan/radsan.h
+++ b/compiler-rt/lib/radsan/radsan.h
@@ -72,4 +72,5 @@ SANITIZER_INTERFACE_ATTRIBUTE void radsan_off();
     details about how to use this method.
 */
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_on();
-}
+
+} // extern "C"

>From cd34f7279f172d8d84992a16bb297e6108da2cd1 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Wed, 8 May 2024 12:16:29 -0700
Subject: [PATCH 07/44] Fix one naming issue

---
 compiler-rt/lib/radsan/radsan_context.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler-rt/lib/radsan/radsan_context.h b/compiler-rt/lib/radsan/radsan_context.h
index 0cf8a61cbdde2..6f8f937ca0739 100644
--- a/compiler-rt/lib/radsan/radsan_context.h
+++ b/compiler-rt/lib/radsan/radsan_context.h
@@ -22,7 +22,7 @@ class Context {
   void BypassPush();
   void BypassPop();
 
-  void ExpectNotRealtime(const char *interpreted_function_name);
+  void ExpectNotRealtime(const char *InterceptedFunctionName);
 
 private:
   bool InRealtimeContext() const;

>From df1233dcfc8b6319945e6cec90fc1a7e4b765252 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Mon, 13 May 2024 13:43:00 -0700
Subject: [PATCH 08/44] No more unistd

---
 compiler-rt/lib/radsan/radsan.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/compiler-rt/lib/radsan/radsan.cpp b/compiler-rt/lib/radsan/radsan.cpp
index dbe787ea6f6e4..e5117ac0d5f78 100644
--- a/compiler-rt/lib/radsan/radsan.cpp
+++ b/compiler-rt/lib/radsan/radsan.cpp
@@ -11,7 +11,6 @@
 #include <radsan/radsan.h>
 #include <radsan/radsan_context.h>
 #include <radsan/radsan_interceptors.h>
-#include <unistd.h>
 
 extern "C" {
 

>From 860f8eb03aba8ef8c13ea3836330793240eac6fe Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Mon, 13 May 2024 13:43:18 -0700
Subject: [PATCH 09/44] Radsan context moved to impl

---
 compiler-rt/lib/radsan/radsan_context.cpp | 31 +++++++++++++----------
 1 file changed, 18 insertions(+), 13 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan_context.cpp b/compiler-rt/lib/radsan/radsan_context.cpp
index 16fdf967ff4d8..37f4faaff61a8 100644
--- a/compiler-rt/lib/radsan/radsan_context.cpp
+++ b/compiler-rt/lib/radsan/radsan_context.cpp
@@ -28,6 +28,23 @@ static pthread_key_t Key;
 static pthread_once_t KeyOnce = PTHREAD_ONCE_INIT;
 void internalFree(void *Ptr) { __sanitizer::InternalFree(Ptr); }
 
+using radsan::Context;
+
+Context &GetContextForThisThreadImpl() {
+  auto MakeTlsKey = []() {
+    CHECK_EQ(pthread_key_create(&detail::Key, detail::internalFree), 0);
+  };
+
+  pthread_once(&detail::KeyOnce, MakeTlsKey);
+  Context *CurrentThreadContext = static_cast<Context *>(pthread_getspecific(detail::Key));
+  if (CurrentThreadContext == nullptr) {
+    CurrentThreadContext = static_cast<Context *>(InternalAlloc(sizeof(Context)));
+    new(CurrentThreadContext) Context();
+    pthread_setspecific(detail::Key, CurrentThreadContext);
+  }
+
+  return *CurrentThreadContext;
+}
 } // namespace detail
 
 namespace radsan {
@@ -64,19 +81,7 @@ void Context::PrintDiagnostics(const char *InterceptedFunctionName) {
 }
 
 Context &GetContextForThisThread() {
-  auto MakeTlsKey = []() {
-    CHECK_EQ(pthread_key_create(&detail::Key, detail::internalFree), 0);
-  };
-
-  pthread_once(&detail::KeyOnce, MakeTlsKey);
-  Context *CurrentThreadContext = static_cast<Context *>(pthread_getspecific(detail::Key));
-  if (CurrentThreadContext == nullptr) {
-    CurrentThreadContext = static_cast<Context *>(InternalAlloc(sizeof(Context)));
-    new(CurrentThreadContext) Context();
-    pthread_setspecific(detail::Key, CurrentThreadContext);
-  }
-
-  return *CurrentThreadContext;
+  return detail::GetContextForThisThreadImpl();
 }
 
 } // namespace radsan

>From b5329191f5a4946aaee40aaafb41b7661a58fa95 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Mon, 13 May 2024 14:02:36 -0700
Subject: [PATCH 10/44] Promise lit tests later

---
 compiler-rt/test/radsan/CMakeLists.txt | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/compiler-rt/test/radsan/CMakeLists.txt b/compiler-rt/test/radsan/CMakeLists.txt
index 51a3ff72859b6..d6b8dc9652879 100644
--- a/compiler-rt/test/radsan/CMakeLists.txt
+++ b/compiler-rt/test/radsan/CMakeLists.txt
@@ -1,3 +1,14 @@
+
+
+
+
+######
+# TODO: Full lit tests coming in a future review when we introduce the codegen
+######
+
+
+
+
 set(RADSAN_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 set(RADSAN_TESTSUITES)

>From 5fd7063385d4f52712d912731556c93db83ae730 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Mon, 13 May 2024 14:05:57 -0700
Subject: [PATCH 11/44] Move radsan_test and add helper comment to top of file

---
 compiler-rt/lib/radsan/tests/CMakeLists.txt                   | 2 +-
 .../tests/{radsan_test.cpp => radsan_test_functional.cpp}     | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)
 rename compiler-rt/lib/radsan/tests/{radsan_test.cpp => radsan_test_functional.cpp} (96%)

diff --git a/compiler-rt/lib/radsan/tests/CMakeLists.txt b/compiler-rt/lib/radsan/tests/CMakeLists.txt
index 73cedac2765d6..79a3d2d3d6c23 100644
--- a/compiler-rt/lib/radsan/tests/CMakeLists.txt
+++ b/compiler-rt/lib/radsan/tests/CMakeLists.txt
@@ -15,7 +15,7 @@ set(RADSAN_UNITTEST_CFLAGS
   -O2)
 
 set(RADSAN_INST_TEST_SOURCES
-    radsan_test.cpp
+    radsan_test_functional.cpp
     radsan_test_interceptors.cpp
     radsan_test_main.cpp)
 
diff --git a/compiler-rt/lib/radsan/tests/radsan_test.cpp b/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
similarity index 96%
rename from compiler-rt/lib/radsan/tests/radsan_test.cpp
rename to compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
index 521545ca8a9e2..8adb3b94c5406 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
@@ -6,6 +6,10 @@
 //
 //===----------------------------------------------------------------------===//
 //
+// Introduces basic functional tests for the realtime sanitizer.
+// Not meant to be exhaustive, testing all interceptors, please see
+// test_radsan_interceptors.cpp for those tests.
+//
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"

>From 99f0f43f2ca0dacd8690114baffb4a57d924e545 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Mon, 13 May 2024 14:06:13 -0700
Subject: [PATCH 12/44] Only link radsan statically

---
 clang/lib/Driver/ToolChains/CommonArgs.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp
index 459b7d59d0ee8..05bf9d97b8405 100644
--- a/clang/lib/Driver/ToolChains/CommonArgs.cpp
+++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp
@@ -1418,8 +1418,6 @@ collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
       if (!Args.hasArg(options::OPT_shared))
         HelperStaticRuntimes.push_back("hwasan-preinit");
     }
-    if (SanArgs.needsRadsanRt() && SanArgs.linkRuntimes())
-      SharedRuntimes.push_back("radsan");
   }
 
   // The stats_client library is also statically linked into DSOs.
@@ -1445,7 +1443,7 @@ collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
       StaticRuntimes.push_back("asan_cxx");
   }
 
-  if (!SanArgs.needsSharedRt() && SanArgs.needsRadsanRt() && SanArgs.linkRuntimes()) {
+  if (!SanArgs.needsSharedRt() && SanArgs.needsRadsanRt()) {
     StaticRuntimes.push_back("radsan");
   }
 

>From 4f18dd0ef69d7d70b0626cf2b0271b4a31e00b4b Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Wed, 15 May 2024 13:54:13 -0700
Subject: [PATCH 13/44] Fix comments in radsan.h

---
 compiler-rt/lib/radsan/radsan.h | 44 +++++++--------------------------
 1 file changed, 9 insertions(+), 35 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan.h b/compiler-rt/lib/radsan/radsan.h
index 61205e93e29ed..b79933fde5171 100644
--- a/compiler-rt/lib/radsan/radsan.h
+++ b/compiler-rt/lib/radsan/radsan.h
@@ -14,62 +14,36 @@
 
 extern "C" {
 
-/**
-    Initialise radsan interceptors. A call to this method is added to the
-    preinit array on Linux systems.
+/**  Initialise radsan interceptors. 
 
-    @warning Do not call this method as a user.
+  A call to this method is added to the preinit array on Linux systems.
 */
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_init();
 
 /** Enter real-time context.
 
-    When in a real-time context, RADSan interceptors will error if realtime
-    violations are detected. Calls to this method are injected at the code
-    generation stage when RADSan is enabled.
-
-    @warning Do not call this method as a user
+  When in a real-time context, RADSan interceptors will error if realtime
+  violations are detected. Calls to this method are injected at the code
+  generation stage when RADSan is enabled.
 */
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_enter();
 
 /** Exit the real-time context.
 
-    When not in a real-time context, RADSan interceptors will simply forward
-    intercepted method calls to the real methods.
-
-    @warning Do not call this method as a user
+  When not in a real-time context, RADSan interceptors will simply forward
+  intercepted method calls to the real methods.
 */
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_exit();
 
 /** Disable all RADSan error reporting.
 
-    This method might be useful to you if RADSan is presenting you with an error
-    for some code you are confident is realtime safe. For example, you might
-    know that a mutex is never contested, and that locking it will never block
-    on your particular system. Be careful!
-
-    A call to `radsan_off()` MUST be paired with a corresponding `radsan_on()`
-    to reactivate interception after the code in question. If you don't, radsan
-    will cease to work.
-
-    Example:
-
-        float process (float x) [[clang::nonblocking]] 
-        {
-            auto const y = 2.0f * x;
-
-            radsan_off();
-            i_know_this_method_is_realtime_safe_but_radsan_complains_about_it();
-            radsan_on();
-        }
-
+  Injected into the code if "nosanitize(realtime)" is on a function.
 */
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_off();
 
 /** Re-enable all RADSan error reporting.
 
-    The counterpart to `radsan_off`. See the description for `radsan_off` for
-    details about how to use this method.
+  The counterpart to `radsan_off`. 
 */
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_on();
 

>From b564d8d5d6712e178e390d9b02719b79f875df76 Mon Sep 17 00:00:00 2001
From: David Trevelyan <david.trevelyan at gmail.com>
Date: Thu, 16 May 2024 22:18:07 +0100
Subject: [PATCH 14/44] Replace inlined exit with selected action stub

---
 compiler-rt/lib/radsan/radsan_context.cpp | 27 +++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan_context.cpp b/compiler-rt/lib/radsan/radsan_context.cpp
index 37f4faaff61a8..97bee5e57c016 100644
--- a/compiler-rt/lib/radsan/radsan_context.cpp
+++ b/compiler-rt/lib/radsan/radsan_context.cpp
@@ -36,15 +36,34 @@ Context &GetContextForThisThreadImpl() {
   };
 
   pthread_once(&detail::KeyOnce, MakeTlsKey);
-  Context *CurrentThreadContext = static_cast<Context *>(pthread_getspecific(detail::Key));
+  Context *CurrentThreadContext =
+      static_cast<Context *>(pthread_getspecific(detail::Key));
   if (CurrentThreadContext == nullptr) {
-    CurrentThreadContext = static_cast<Context *>(InternalAlloc(sizeof(Context)));
-    new(CurrentThreadContext) Context();
+    CurrentThreadContext =
+        static_cast<Context *>(InternalAlloc(sizeof(Context)));
+    new (CurrentThreadContext) Context();
     pthread_setspecific(detail::Key, CurrentThreadContext);
   }
 
   return *CurrentThreadContext;
 }
+
+/*
+    This is a placeholder stub for a future feature that will allow
+    a user to configure RADSan's behaviour when a real-time safety
+    violation is detected. The RADSan developers intend for the
+    following choices to be made available, via a RADSAN_OPTIONS
+    environment variable, in a future PR:
+
+        i) exit,
+       ii) continue, or
+      iii) wait for user input from stdin.
+
+    Until then, and to keep the first PRs small, only the exit mode
+    is available.
+*/
+void InvokeViolationDetectedAction() { exit(EXIT_FAILURE); }
+
 } // namespace detail
 
 namespace radsan {
@@ -63,7 +82,7 @@ void Context::ExpectNotRealtime(const char *InterceptedFunctionName) {
   if (InRealtimeContext() && !IsBypassed()) {
     BypassPush();
     PrintDiagnostics(InterceptedFunctionName);
-    exit(EXIT_FAILURE);
+    detail::InvokeViolationDetectedAction();
     BypassPop();
   }
 }

>From 11183c8194a1e732e09290e7bd1ed24c97c3322a Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Thu, 16 May 2024 13:54:01 -0700
Subject: [PATCH 15/44] Codeowners

---
 compiler-rt/CODE_OWNERS.TXT | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/compiler-rt/CODE_OWNERS.TXT b/compiler-rt/CODE_OWNERS.TXT
index ad136edf96781..2db0357fc1a7f 100644
--- a/compiler-rt/CODE_OWNERS.TXT
+++ b/compiler-rt/CODE_OWNERS.TXT
@@ -67,3 +67,7 @@ D: ThreadSanitizer
 N: Bill Wendling
 E: isanbard at gmail.com
 D: Profile runtime library
+
+N: Christopher Apple, David Trevelyan
+E: cja-private at pm.me, realtime.sanitizer at gmail.com
+D: Realtime Sanitizer (RADSan)

>From 6640c486ee2fe1b2e87840d5e62c4d9eb009bdaf Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Thu, 16 May 2024 14:40:46 -0700
Subject: [PATCH 16/44] Fix python formatting errors

---
 compiler-rt/test/radsan/lit.cfg.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/compiler-rt/test/radsan/lit.cfg.py b/compiler-rt/test/radsan/lit.cfg.py
index 773b624900fa6..32af62dfb8e04 100644
--- a/compiler-rt/test/radsan/lit.cfg.py
+++ b/compiler-rt/test/radsan/lit.cfg.py
@@ -40,7 +40,9 @@ def build_invocation(compile_flags):
     ("%clangxx ", build_invocation(config.cxx_mode_flags + [config.target_cflags]))
 )
 config.substitutions.append(("%clang_radsan ", build_invocation(clang_radsan_cflags)))
-config.substitutions.append(("%clangxx_radsan", build_invocation(clang_radsan_cxxflags)))
+config.substitutions.append(
+    ("%clangxx_radsan", build_invocation(clang_radsan_cxxflags))
+)
 config.substitutions.append(("%llvm_radsan", llvm_radsan))
 config.substitutions.append(
     (

>From 79d4dc68d6e16ffe00f7aefb2560ad6d88d25add Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Thu, 16 May 2024 14:43:43 -0700
Subject: [PATCH 17/44] Fix cpp style issues

---
 clang/lib/Driver/ToolChains/Darwin.cpp            |  6 +++---
 compiler-rt/lib/radsan/radsan.cpp                 |  4 ++--
 compiler-rt/lib/radsan/radsan.h                   |  4 ++--
 compiler-rt/lib/radsan/radsan_interceptors.cpp    |  3 ++-
 compiler-rt/lib/radsan/radsan_interceptors.h      |  3 ++-
 compiler-rt/lib/radsan/radsan_preinit.cpp         |  4 ++--
 .../lib/radsan/tests/radsan_test_context.cpp      |  3 ++-
 .../lib/radsan/tests/radsan_test_interceptors.cpp | 15 ++++++++-------
 .../lib/radsan/tests/radsan_test_utilities.h      |  9 ++++-----
 9 files changed, 27 insertions(+), 24 deletions(-)

diff --git a/clang/lib/Driver/ToolChains/Darwin.cpp b/clang/lib/Driver/ToolChains/Darwin.cpp
index b75e6580890c1..b3e9d14021cda 100644
--- a/clang/lib/Driver/ToolChains/Darwin.cpp
+++ b/clang/lib/Driver/ToolChains/Darwin.cpp
@@ -1520,9 +1520,9 @@ void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
         AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
       }
     }
-    if(Sanitize.needsRadsanRt())
-    {
-      assert(Sanitize.needsSharedRt() && "Static sanitizer runtimes not supported");
+    if (Sanitize.needsRadsanRt()) {
+      assert(Sanitize.needsSharedRt() &&
+             "Static sanitizer runtimes not supported");
       AddLinkSanitizerLibArgs(Args, CmdArgs, "radsan");
     }
     if (Sanitize.needsLsanRt())
diff --git a/compiler-rt/lib/radsan/radsan.cpp b/compiler-rt/lib/radsan/radsan.cpp
index e5117ac0d5f78..97069a0ac1299 100644
--- a/compiler-rt/lib/radsan/radsan.cpp
+++ b/compiler-rt/lib/radsan/radsan.cpp
@@ -14,8 +14,8 @@
 
 extern "C" {
 
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_init() { 
-  radsan::InitializeInterceptors(); 
+SANITIZER_INTERFACE_ATTRIBUTE void radsan_init() {
+  radsan::InitializeInterceptors();
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_enter() {
diff --git a/compiler-rt/lib/radsan/radsan.h b/compiler-rt/lib/radsan/radsan.h
index b79933fde5171..28682cb9c1b24 100644
--- a/compiler-rt/lib/radsan/radsan.h
+++ b/compiler-rt/lib/radsan/radsan.h
@@ -14,7 +14,7 @@
 
 extern "C" {
 
-/**  Initialise radsan interceptors. 
+/**  Initialise radsan interceptors.
 
   A call to this method is added to the preinit array on Linux systems.
 */
@@ -43,7 +43,7 @@ SANITIZER_INTERFACE_ATTRIBUTE void radsan_off();
 
 /** Re-enable all RADSan error reporting.
 
-  The counterpart to `radsan_off`. 
+  The counterpart to `radsan_off`.
 */
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_on();
 
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
index f7fd005aa004d..0719d327585ff 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.cpp
+++ b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -1,4 +1,5 @@
-//===--- radsan_interceptors.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- radsan_interceptors.cpp - Realtime Sanitizer --------------*- C++
+//-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.h b/compiler-rt/lib/radsan/radsan_interceptors.h
index 30b37fb24a70f..9f020fa9d4df5 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.h
+++ b/compiler-rt/lib/radsan/radsan_interceptors.h
@@ -1,4 +1,5 @@
-//===--- radsan_interceptors.h - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- radsan_interceptors.h - Realtime Sanitizer --------------*- C++
+//-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/compiler-rt/lib/radsan/radsan_preinit.cpp b/compiler-rt/lib/radsan/radsan_preinit.cpp
index e5e92becb1eac..d3ee60f939861 100644
--- a/compiler-rt/lib/radsan/radsan_preinit.cpp
+++ b/compiler-rt/lib/radsan/radsan_preinit.cpp
@@ -17,7 +17,7 @@
 // exported.
 // This code is linked into the main executable when -fsanitize=realtime is in
 // the link flags. It can only use exported interface functions.
-__attribute__((section(".preinit_array"), used))
-void (*__local_radsan_preinit)(void) = radsan_init;
+__attribute__((section(".preinit_array"),
+               used)) void (*__local_radsan_preinit)(void) = radsan_init;
 
 #endif
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
index 91822df5a841d..d389b60e8cd90 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
@@ -1,4 +1,5 @@
-//===--- radsan_test_context.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- radsan_test_context.cpp - Realtime Sanitizer --------------*- C++
+//-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index 20ed7c7542d03..e3b2e34fbe48a 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -1,4 +1,5 @@
-//===--- radsan_test_interceptors.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- radsan_test_interceptors.cpp - Realtime Sanitizer --------------*- C++
+//-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -202,7 +203,7 @@ TEST(TestRadsanInterceptors, CloseDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, FopenDiesWhenRealtime) {
   auto Func = []() {
-    FILE* Fd = fopen(TemporaryFilePath(), "w");
+    FILE *Fd = fopen(TemporaryFilePath(), "w");
     EXPECT_THAT(Fd, Ne(nullptr));
   };
   ExpectRealtimeDeath(Func, "fopen");
@@ -211,7 +212,7 @@ TEST(TestRadsanInterceptors, FopenDiesWhenRealtime) {
 }
 
 TEST(TestRadsanInterceptors, FreadDiesWhenRealtime) {
-  FILE* Fd = fopen(TemporaryFilePath(), "w");
+  FILE *Fd = fopen(TemporaryFilePath(), "w");
   auto Func = [Fd]() {
     char c{};
     fread(&c, 1, 1, Fd);
@@ -224,9 +225,9 @@ TEST(TestRadsanInterceptors, FreadDiesWhenRealtime) {
 }
 
 TEST(TestRadsanInterceptors, FwriteDiesWhenRealtime) {
-  FILE* Fd = fopen(TemporaryFilePath(), "w");
+  FILE *Fd = fopen(TemporaryFilePath(), "w");
   ASSERT_NE(nullptr, Fd);
-  const char* Message = "Hello, world!";
+  const char *Message = "Hello, world!";
   auto Func = [&]() { fwrite(&Message, 1, 4, Fd); };
   ExpectRealtimeDeath(Func, "fwrite");
   ExpectNonRealtimeSurvival(Func);
@@ -234,7 +235,7 @@ TEST(TestRadsanInterceptors, FwriteDiesWhenRealtime) {
 }
 
 TEST(TestRadsanInterceptors, FcloseDiesWhenRealtime) {
-  FILE* Fd = fopen(TemporaryFilePath(), "w");
+  FILE *Fd = fopen(TemporaryFilePath(), "w");
   EXPECT_THAT(Fd, Ne(nullptr));
   auto Func = [Fd]() { fclose(Fd); };
   ExpectRealtimeDeath(Func, "fclose");
@@ -249,7 +250,7 @@ TEST(TestRadsanInterceptors, PutsDiesWhenRealtime) {
 }
 
 TEST(TestRadsanInterceptors, FputsDiesWhenRealtime) {
-  FILE* Fd = fopen(TemporaryFilePath(), "w");
+  FILE *Fd = fopen(TemporaryFilePath(), "w");
   ASSERT_THAT(Fd, Ne(nullptr)) << errno;
   auto Func = [Fd]() { fputs("Hello, world!\n", Fd); };
   ExpectRealtimeDeath(Func);
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
index 4a2510d5f87d4..8c2821e9825ea 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
+++ b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
@@ -1,4 +1,5 @@
-//===--- radsan_test_utilities.h - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- radsan_test_utilities.h - Realtime Sanitizer --------------*- C++
+//-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -10,15 +11,13 @@
 
 #pragma once
 
-#include "gmock/gmock.h"
 #include "radsan.h"
+#include "gmock/gmock.h"
 #include <string>
 
 namespace radsan_testing {
 
-template <typename Function>
-void RealtimeInvoke(Function &&Func) 
-{
+template <typename Function> void RealtimeInvoke(Function &&Func) {
   radsan_realtime_enter();
   std::forward<Function>(Func)();
   radsan_realtime_exit();

>From 0358f526ae8d43b7dfc813cdabc8bbf8a521271e Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Sun, 19 May 2024 22:12:18 -0700
Subject: [PATCH 18/44] PR: Delete python header comment

---
 compiler-rt/test/radsan/lit.cfg.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/compiler-rt/test/radsan/lit.cfg.py b/compiler-rt/test/radsan/lit.cfg.py
index 32af62dfb8e04..b9e4dbc03abb6 100644
--- a/compiler-rt/test/radsan/lit.cfg.py
+++ b/compiler-rt/test/radsan/lit.cfg.py
@@ -1,5 +1,3 @@
-# -*- Python -*-
-
 import os
 
 # Setup config name.

>From 80eec4d75b44faadf8db1675e1078645f3467f08 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Sun, 19 May 2024 22:28:39 -0700
Subject: [PATCH 19/44] PR: Change main namespace name to __radsan

---
 compiler-rt/lib/radsan/radsan.cpp             |  10 +-
 compiler-rt/lib/radsan/radsan_context.cpp     |   8 +-
 compiler-rt/lib/radsan/radsan_context.h       |   4 +-
 .../lib/radsan/radsan_interceptors.cpp        | 100 +++++++++---------
 compiler-rt/lib/radsan/radsan_interceptors.h  |   2 +-
 compiler-rt/lib/radsan/radsan_stack.cpp       |   7 +-
 compiler-rt/lib/radsan/radsan_stack.h         |   2 +-
 .../lib/radsan/tests/radsan_test_context.cpp  |  14 +--
 8 files changed, 73 insertions(+), 74 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan.cpp b/compiler-rt/lib/radsan/radsan.cpp
index 97069a0ac1299..52b228dd93195 100644
--- a/compiler-rt/lib/radsan/radsan.cpp
+++ b/compiler-rt/lib/radsan/radsan.cpp
@@ -15,23 +15,23 @@
 extern "C" {
 
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_init() {
-  radsan::InitializeInterceptors();
+  __radsan::InitializeInterceptors();
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_enter() {
-  radsan::GetContextForThisThread().RealtimePush();
+  __radsan::GetContextForThisThread().RealtimePush();
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_exit() {
-  radsan::GetContextForThisThread().RealtimePop();
+  __radsan::GetContextForThisThread().RealtimePop();
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_off() {
-  radsan::GetContextForThisThread().BypassPush();
+  __radsan::GetContextForThisThread().BypassPush();
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE void radsan_on() {
-  radsan::GetContextForThisThread().BypassPop();
+  __radsan::GetContextForThisThread().BypassPop();
 }
 
 } // extern "C"
diff --git a/compiler-rt/lib/radsan/radsan_context.cpp b/compiler-rt/lib/radsan/radsan_context.cpp
index 97bee5e57c016..bb83b1e9f16c8 100644
--- a/compiler-rt/lib/radsan/radsan_context.cpp
+++ b/compiler-rt/lib/radsan/radsan_context.cpp
@@ -28,7 +28,7 @@ static pthread_key_t Key;
 static pthread_once_t KeyOnce = PTHREAD_ONCE_INIT;
 void internalFree(void *Ptr) { __sanitizer::InternalFree(Ptr); }
 
-using radsan::Context;
+using __radsan::Context;
 
 Context &GetContextForThisThreadImpl() {
   auto MakeTlsKey = []() {
@@ -66,7 +66,7 @@ void InvokeViolationDetectedAction() { exit(EXIT_FAILURE); }
 
 } // namespace detail
 
-namespace radsan {
+namespace __radsan {
 
 Context::Context() = default;
 
@@ -96,11 +96,11 @@ void Context::PrintDiagnostics(const char *InterceptedFunctionName) {
           "Real-time violation: intercepted call to real-time unsafe function "
           "`%s` in real-time context! Stack trace:\n",
           InterceptedFunctionName);
-  radsan::PrintStackTrace();
+  __radsan::PrintStackTrace();
 }
 
 Context &GetContextForThisThread() {
   return detail::GetContextForThisThreadImpl();
 }
 
-} // namespace radsan
+} // namespace __radsan
diff --git a/compiler-rt/lib/radsan/radsan_context.h b/compiler-rt/lib/radsan/radsan_context.h
index 6f8f937ca0739..103f055508d47 100644
--- a/compiler-rt/lib/radsan/radsan_context.h
+++ b/compiler-rt/lib/radsan/radsan_context.h
@@ -10,7 +10,7 @@
 
 #pragma once
 
-namespace radsan {
+namespace __radsan {
 
 class Context {
 public:
@@ -35,4 +35,4 @@ class Context {
 
 Context &GetContextForThisThread();
 
-} // namespace radsan
+} // namespace __radsan
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
index 0719d327585ff..61b56269ac3ea 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.cpp
+++ b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -40,11 +40,11 @@
 
 using namespace __sanitizer;
 
-namespace radsan {
+namespace __radsan {
 void ExpectNotRealtime(const char *InterceptedFunctionName) {
   GetContextForThisThread().ExpectNotRealtime(InterceptedFunctionName);
 }
-} // namespace radsan
+} // namespace __radsan
 
 /*
     Filesystem
@@ -53,7 +53,7 @@ void ExpectNotRealtime(const char *InterceptedFunctionName) {
 INTERCEPTOR(int, open, const char *path, int oflag, ...) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
-  radsan::ExpectNotRealtime("open");
+  __radsan::ExpectNotRealtime("open");
   va_list args;
   va_start(args, oflag);
   const int result = REAL(open)(path, oflag, args);
@@ -64,7 +64,7 @@ INTERCEPTOR(int, open, const char *path, int oflag, ...) {
 INTERCEPTOR(int, openat, int fd, const char *path, int oflag, ...) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
-  radsan::ExpectNotRealtime("openat");
+  __radsan::ExpectNotRealtime("openat");
   va_list args;
   va_start(args, oflag);
   const int result = REAL(openat)(fd, path, oflag, args);
@@ -75,13 +75,13 @@ INTERCEPTOR(int, openat, int fd, const char *path, int oflag, ...) {
 INTERCEPTOR(int, creat, const char *path, mode_t mode) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
-  radsan::ExpectNotRealtime("creat");
+  __radsan::ExpectNotRealtime("creat");
   const int result = REAL(creat)(path, mode);
   return result;
 }
 
 INTERCEPTOR(int, fcntl, int filedes, int cmd, ...) {
-  radsan::ExpectNotRealtime("fcntl");
+  __radsan::ExpectNotRealtime("fcntl");
   va_list args;
   va_start(args, cmd);
   const int result = REAL(fcntl)(filedes, cmd, args);
@@ -90,34 +90,34 @@ INTERCEPTOR(int, fcntl, int filedes, int cmd, ...) {
 }
 
 INTERCEPTOR(int, close, int filedes) {
-  radsan::ExpectNotRealtime("close");
+  __radsan::ExpectNotRealtime("close");
   return REAL(close)(filedes);
 }
 
 INTERCEPTOR(FILE *, fopen, const char *path, const char *mode) {
-  radsan::ExpectNotRealtime("fopen");
+  __radsan::ExpectNotRealtime("fopen");
   return REAL(fopen)(path, mode);
 }
 
 INTERCEPTOR(size_t, fread, void *ptr, size_t size, size_t nitems,
             FILE *stream) {
-  radsan::ExpectNotRealtime("fread");
+  __radsan::ExpectNotRealtime("fread");
   return REAL(fread)(ptr, size, nitems, stream);
 }
 
 INTERCEPTOR(size_t, fwrite, const void *ptr, size_t size, size_t nitems,
             FILE *stream) {
-  radsan::ExpectNotRealtime("fwrite");
+  __radsan::ExpectNotRealtime("fwrite");
   return REAL(fwrite)(ptr, size, nitems, stream);
 }
 
 INTERCEPTOR(int, fclose, FILE *stream) {
-  radsan::ExpectNotRealtime("fclose");
+  __radsan::ExpectNotRealtime("fclose");
   return REAL(fclose)(stream);
 }
 
 INTERCEPTOR(int, fputs, const char *s, FILE *stream) {
-  radsan::ExpectNotRealtime("fputs");
+  __radsan::ExpectNotRealtime("fputs");
   return REAL(fputs)(s, stream);
 }
 
@@ -126,7 +126,7 @@ INTERCEPTOR(int, fputs, const char *s, FILE *stream) {
 */
 
 INTERCEPTOR(int, puts, const char *s) {
-  radsan::ExpectNotRealtime("puts");
+  __radsan::ExpectNotRealtime("puts");
   return REAL(puts)(s);
 }
 
@@ -139,77 +139,77 @@ INTERCEPTOR(int, puts, const char *s) {
 // OSSpinLockLock is deprecated, but still in use in libc++
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 INTERCEPTOR(void, OSSpinLockLock, volatile OSSpinLock *lock) {
-  radsan::ExpectNotRealtime("OSSpinLockLock");
+  __radsan::ExpectNotRealtime("OSSpinLockLock");
   return REAL(OSSpinLockLock)(lock);
 }
 #pragma clang diagnostic pop
 
 INTERCEPTOR(void, os_unfair_lock_lock, os_unfair_lock_t lock) {
-  radsan::ExpectNotRealtime("os_unfair_lock_lock");
+  __radsan::ExpectNotRealtime("os_unfair_lock_lock");
   return REAL(os_unfair_lock_lock)(lock);
 }
 #elif SANITIZER_LINUX
 INTERCEPTOR(int, pthread_spin_lock, pthread_spinlock_t *spinlock) {
-  radsan::ExpectNotRealtime("pthread_spin_lock");
+  __radsan::ExpectNotRealtime("pthread_spin_lock");
   return REAL(pthread_spin_lock)(spinlock);
 }
 #endif
 
 INTERCEPTOR(int, pthread_create, pthread_t *thread, const pthread_attr_t *attr,
             void *(*start_routine)(void *), void *arg) {
-  radsan::ExpectNotRealtime("pthread_create");
+  __radsan::ExpectNotRealtime("pthread_create");
   return REAL(pthread_create)(thread, attr, start_routine, arg);
 }
 
 INTERCEPTOR(int, pthread_mutex_lock, pthread_mutex_t *mutex) {
-  radsan::ExpectNotRealtime("pthread_mutex_lock");
+  __radsan::ExpectNotRealtime("pthread_mutex_lock");
   return REAL(pthread_mutex_lock)(mutex);
 }
 
 INTERCEPTOR(int, pthread_mutex_unlock, pthread_mutex_t *mutex) {
-  radsan::ExpectNotRealtime("pthread_mutex_unlock");
+  __radsan::ExpectNotRealtime("pthread_mutex_unlock");
   return REAL(pthread_mutex_unlock)(mutex);
 }
 
 INTERCEPTOR(int, pthread_join, pthread_t thread, void **value_ptr) {
-  radsan::ExpectNotRealtime("pthread_join");
+  __radsan::ExpectNotRealtime("pthread_join");
   return REAL(pthread_join)(thread, value_ptr);
 }
 
 INTERCEPTOR(int, pthread_cond_signal, pthread_cond_t *cond) {
-  radsan::ExpectNotRealtime("pthread_cond_signal");
+  __radsan::ExpectNotRealtime("pthread_cond_signal");
   return REAL(pthread_cond_signal)(cond);
 }
 
 INTERCEPTOR(int, pthread_cond_broadcast, pthread_cond_t *cond) {
-  radsan::ExpectNotRealtime("pthread_cond_broadcast");
+  __radsan::ExpectNotRealtime("pthread_cond_broadcast");
   return REAL(pthread_cond_broadcast)(cond);
 }
 
 INTERCEPTOR(int, pthread_cond_wait, pthread_cond_t *cond,
             pthread_mutex_t *mutex) {
-  radsan::ExpectNotRealtime("pthread_cond_wait");
+  __radsan::ExpectNotRealtime("pthread_cond_wait");
   return REAL(pthread_cond_wait)(cond, mutex);
 }
 
 INTERCEPTOR(int, pthread_cond_timedwait, pthread_cond_t *cond,
             pthread_mutex_t *mutex, const timespec *ts) {
-  radsan::ExpectNotRealtime("pthread_cond_timedwait");
+  __radsan::ExpectNotRealtime("pthread_cond_timedwait");
   return REAL(pthread_cond_timedwait)(cond, mutex, ts);
 }
 
 INTERCEPTOR(int, pthread_rwlock_rdlock, pthread_rwlock_t *lock) {
-  radsan::ExpectNotRealtime("pthread_rwlock_rdlock");
+  __radsan::ExpectNotRealtime("pthread_rwlock_rdlock");
   return REAL(pthread_rwlock_rdlock)(lock);
 }
 
 INTERCEPTOR(int, pthread_rwlock_unlock, pthread_rwlock_t *lock) {
-  radsan::ExpectNotRealtime("pthread_rwlock_unlock");
+  __radsan::ExpectNotRealtime("pthread_rwlock_unlock");
   return REAL(pthread_rwlock_unlock)(lock);
 }
 
 INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *lock) {
-  radsan::ExpectNotRealtime("pthread_rwlock_wrlock");
+  __radsan::ExpectNotRealtime("pthread_rwlock_wrlock");
   return REAL(pthread_rwlock_wrlock)(lock);
 }
 
@@ -218,18 +218,18 @@ INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *lock) {
 */
 
 INTERCEPTOR(unsigned int, sleep, unsigned int s) {
-  radsan::ExpectNotRealtime("sleep");
+  __radsan::ExpectNotRealtime("sleep");
   return REAL(sleep)(s);
 }
 
 INTERCEPTOR(int, usleep, useconds_t u) {
-  radsan::ExpectNotRealtime("usleep");
+  __radsan::ExpectNotRealtime("usleep");
   return REAL(usleep)(u);
 }
 
 INTERCEPTOR(int, nanosleep, const struct timespec *rqtp,
             struct timespec *rmtp) {
-  radsan::ExpectNotRealtime("nanosleep");
+  __radsan::ExpectNotRealtime("nanosleep");
   return REAL(nanosleep)(rqtp, rmtp);
 }
 
@@ -238,40 +238,40 @@ INTERCEPTOR(int, nanosleep, const struct timespec *rqtp,
 */
 
 INTERCEPTOR(void *, calloc, SIZE_T num, SIZE_T size) {
-  radsan::ExpectNotRealtime("calloc");
+  __radsan::ExpectNotRealtime("calloc");
   return REAL(calloc)(num, size);
 }
 
 INTERCEPTOR(void, free, void *ptr) {
   if (ptr != NULL) {
-    radsan::ExpectNotRealtime("free");
+    __radsan::ExpectNotRealtime("free");
   }
   return REAL(free)(ptr);
 }
 
 INTERCEPTOR(void *, malloc, SIZE_T size) {
-  radsan::ExpectNotRealtime("malloc");
+  __radsan::ExpectNotRealtime("malloc");
   return REAL(malloc)(size);
 }
 
 INTERCEPTOR(void *, realloc, void *ptr, SIZE_T size) {
-  radsan::ExpectNotRealtime("realloc");
+  __radsan::ExpectNotRealtime("realloc");
   return REAL(realloc)(ptr, size);
 }
 
 INTERCEPTOR(void *, reallocf, void *ptr, SIZE_T size) {
-  radsan::ExpectNotRealtime("reallocf");
+  __radsan::ExpectNotRealtime("reallocf");
   return REAL(reallocf)(ptr, size);
 }
 
 INTERCEPTOR(void *, valloc, SIZE_T size) {
-  radsan::ExpectNotRealtime("valloc");
+  __radsan::ExpectNotRealtime("valloc");
   return REAL(valloc)(size);
 }
 
 #if SANITIZER_INTERCEPT_ALIGNED_ALLOC
 INTERCEPTOR(void *, aligned_alloc, SIZE_T alignment, SIZE_T size) {
-  radsan::ExpectNotRealtime("aligned_alloc");
+  __radsan::ExpectNotRealtime("aligned_alloc");
   return REAL(aligned_alloc)(alignment, size);
 }
 #define RADSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC INTERCEPT_FUNCTION(aligned_alloc)
@@ -280,20 +280,20 @@ INTERCEPTOR(void *, aligned_alloc, SIZE_T alignment, SIZE_T size) {
 #endif
 
 INTERCEPTOR(int, posix_memalign, void **memptr, size_t alignment, size_t size) {
-  radsan::ExpectNotRealtime("posix_memalign");
+  __radsan::ExpectNotRealtime("posix_memalign");
   return REAL(posix_memalign)(memptr, alignment, size);
 }
 
 #if SANITIZER_INTERCEPT_MEMALIGN
 INTERCEPTOR(void *, memalign, size_t alignment, size_t size) {
-  radsan::ExpectNotRealtime("memalign");
+  __radsan::ExpectNotRealtime("memalign");
   return REAL(memalign)(alignment, size);
 }
 #endif
 
 #if SANITIZER_INTERCEPT_PVALLOC
 INTERCEPTOR(void *, pvalloc, size_t size) {
-  radsan::ExpectNotRealtime("pvalloc");
+  __radsan::ExpectNotRealtime("pvalloc");
   return REAL(pvalloc)(size);
 }
 #endif
@@ -303,45 +303,45 @@ INTERCEPTOR(void *, pvalloc, size_t size) {
 */
 
 INTERCEPTOR(int, socket, int domain, int type, int protocol) {
-  radsan::ExpectNotRealtime("socket");
+  __radsan::ExpectNotRealtime("socket");
   return REAL(socket)(domain, type, protocol);
 }
 
 INTERCEPTOR(ssize_t, send, int sockfd, const void *buf, size_t len, int flags) {
-  radsan::ExpectNotRealtime("send");
+  __radsan::ExpectNotRealtime("send");
   return REAL(send)(sockfd, buf, len, flags);
 }
 
 INTERCEPTOR(ssize_t, sendmsg, int socket, const struct msghdr *message,
             int flags) {
-  radsan::ExpectNotRealtime("sendmsg");
+  __radsan::ExpectNotRealtime("sendmsg");
   return REAL(sendmsg)(socket, message, flags);
 }
 
 INTERCEPTOR(ssize_t, sendto, int socket, const void *buffer, size_t length,
             int flags, const struct sockaddr *dest_addr, socklen_t dest_len) {
-  radsan::ExpectNotRealtime("sendto");
+  __radsan::ExpectNotRealtime("sendto");
   return REAL(sendto)(socket, buffer, length, flags, dest_addr, dest_len);
 }
 
 INTERCEPTOR(ssize_t, recv, int socket, void *buffer, size_t length, int flags) {
-  radsan::ExpectNotRealtime("recv");
+  __radsan::ExpectNotRealtime("recv");
   return REAL(recv)(socket, buffer, length, flags);
 }
 
 INTERCEPTOR(ssize_t, recvfrom, int socket, void *buffer, size_t length,
             int flags, struct sockaddr *address, socklen_t *address_len) {
-  radsan::ExpectNotRealtime("recvfrom");
+  __radsan::ExpectNotRealtime("recvfrom");
   return REAL(recvfrom)(socket, buffer, length, flags, address, address_len);
 }
 
 INTERCEPTOR(ssize_t, recvmsg, int socket, struct msghdr *message, int flags) {
-  radsan::ExpectNotRealtime("recvmsg");
+  __radsan::ExpectNotRealtime("recvmsg");
   return REAL(recvmsg)(socket, message, flags);
 }
 
 INTERCEPTOR(int, shutdown, int socket, int how) {
-  radsan::ExpectNotRealtime("shutdown");
+  __radsan::ExpectNotRealtime("shutdown");
   return REAL(shutdown)(socket, how);
 }
 
@@ -349,7 +349,7 @@ INTERCEPTOR(int, shutdown, int socket, int how) {
     Preinit
 */
 
-namespace radsan {
+namespace __radsan {
 void InitializeInterceptors() {
   INTERCEPT_FUNCTION(calloc);
   INTERCEPT_FUNCTION(free);
@@ -410,4 +410,4 @@ void InitializeInterceptors() {
   INTERCEPT_FUNCTION(recvfrom);
   INTERCEPT_FUNCTION(shutdown);
 }
-} // namespace radsan
+} // namespace __radsan
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.h b/compiler-rt/lib/radsan/radsan_interceptors.h
index 9f020fa9d4df5..223d2afb93b10 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.h
+++ b/compiler-rt/lib/radsan/radsan_interceptors.h
@@ -11,6 +11,6 @@
 
 #pragma once
 
-namespace radsan {
+namespace __radsan {
 void InitializeInterceptors();
 }
diff --git a/compiler-rt/lib/radsan/radsan_stack.cpp b/compiler-rt/lib/radsan/radsan_stack.cpp
index e8cb4ae19ce88..72236185e003c 100644
--- a/compiler-rt/lib/radsan/radsan_stack.cpp
+++ b/compiler-rt/lib/radsan/radsan_stack.cpp
@@ -27,7 +27,8 @@ void BufferedStackTrace::UnwindImpl(uptr pc, uptr bp, void *context,
 }
 } // namespace __sanitizer
 
-namespace {
+namespace __radsan {
+
 void SetGlobalStackTraceFormat() {
   SetCommonFlagsDefaults();
   CommonFlags cf;
@@ -36,9 +37,7 @@ void SetGlobalStackTraceFormat() {
   cf.external_symbolizer_path = GetEnv("RADSAN_SYMBOLIZER_PATH");
   OverrideCommonFlags(cf);
 }
-} // namespace
 
-namespace radsan {
 void PrintStackTrace() {
 
   BufferedStackTrace Stack{};
@@ -49,4 +48,4 @@ void PrintStackTrace() {
   SetGlobalStackTraceFormat();
   Stack.Print();
 }
-} // namespace radsan
+} // namespace __radsan
diff --git a/compiler-rt/lib/radsan/radsan_stack.h b/compiler-rt/lib/radsan/radsan_stack.h
index 29ef7d016f1ef..356209d625c1e 100644
--- a/compiler-rt/lib/radsan/radsan_stack.h
+++ b/compiler-rt/lib/radsan/radsan_stack.h
@@ -10,6 +10,6 @@
 
 #pragma once
 
-namespace radsan {
+namespace __radsan {
 void PrintStackTrace();
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
index d389b60e8cd90..69d788b37ba01 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
@@ -13,22 +13,22 @@
 
 #include "radsan_context.h"
 
-TEST(TestRadsanContext, CanCreateContext) { radsan::Context Context{}; }
+TEST(TestRadsanContext, CanCreateContext) { __radsan::Context Context{}; }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieBeforeRealtimePush) {
-  radsan::Context Context{};
+  __radsan::Context Context{};
   Context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterPushAndPop) {
-  radsan::Context Context{};
+  __radsan::Context Context{};
   Context.RealtimePush();
   Context.RealtimePop();
   Context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDiesAfterRealtimePush) {
-  radsan::Context Context{};
+  __radsan::Context Context{};
 
   Context.RealtimePush();
   EXPECT_DEATH(Context.ExpectNotRealtime("do_some_stuff"), "");
@@ -36,7 +36,7 @@ TEST(TestRadsanContext, ExpectNotRealtimeDiesAfterRealtimePush) {
 
 TEST(TestRadsanContext,
      ExpectNotRealtimeDiesAfterRealtimeAfterMorePushesThanPops) {
-  radsan::Context Context{};
+  __radsan::Context Context{};
 
   Context.RealtimePush();
   Context.RealtimePush();
@@ -47,7 +47,7 @@ TEST(TestRadsanContext,
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterBypassPush) {
-  radsan::Context Context{};
+  __radsan::Context Context{};
 
   Context.RealtimePush();
   Context.BypassPush();
@@ -56,7 +56,7 @@ TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterBypassPush) {
 
 TEST(TestRadsanContext,
      ExpectNotRealtimeDoesNotDieIfBypassDepthIsGreaterThanZero) {
-  radsan::Context Context{};
+  __radsan::Context Context{};
 
   Context.RealtimePush();
   Context.BypassPush();

>From f2cf9a3ffba10a0bc5f6d069588edde9f33a269a Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Sun, 19 May 2024 22:31:49 -0700
Subject: [PATCH 20/44] PR: Fix stack trace namespace

---
 compiler-rt/lib/radsan/radsan_stack.cpp | 8 +++++---
 compiler-rt/lib/radsan/radsan_stack.h   | 2 +-
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan_stack.cpp b/compiler-rt/lib/radsan/radsan_stack.cpp
index 72236185e003c..6563893231b50 100644
--- a/compiler-rt/lib/radsan/radsan_stack.cpp
+++ b/compiler-rt/lib/radsan/radsan_stack.cpp
@@ -8,6 +8,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "radsan_stack.h"
+
 #include <sanitizer_common/sanitizer_flags.h>
 #include <sanitizer_common/sanitizer_stacktrace.h>
 
@@ -28,7 +30,6 @@ void BufferedStackTrace::UnwindImpl(uptr pc, uptr bp, void *context,
 } // namespace __sanitizer
 
 namespace __radsan {
-
 void SetGlobalStackTraceFormat() {
   SetCommonFlagsDefaults();
   CommonFlags cf;
@@ -37,8 +38,10 @@ void SetGlobalStackTraceFormat() {
   cf.external_symbolizer_path = GetEnv("RADSAN_SYMBOLIZER_PATH");
   OverrideCommonFlags(cf);
 }
+} // namespace __radsan
 
-void PrintStackTrace() {
+using namespace __radsan;
+void __radsan::PrintStackTrace() {
 
   BufferedStackTrace Stack{};
 
@@ -48,4 +51,3 @@ void PrintStackTrace() {
   SetGlobalStackTraceFormat();
   Stack.Print();
 }
-} // namespace __radsan
diff --git a/compiler-rt/lib/radsan/radsan_stack.h b/compiler-rt/lib/radsan/radsan_stack.h
index 356209d625c1e..73958f98d221d 100644
--- a/compiler-rt/lib/radsan/radsan_stack.h
+++ b/compiler-rt/lib/radsan/radsan_stack.h
@@ -12,4 +12,4 @@
 
 namespace __radsan {
 void PrintStackTrace();
-}
+} // namespace __radsan

>From 52f932c38d49e5fcbf4bf0f1474f21f0ef798a44 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Sun, 19 May 2024 22:35:21 -0700
Subject: [PATCH 21/44] PR: Fix incorrect C++ style comments

---
 .../lib/radsan/radsan_interceptors.cpp        | 32 ++++---------------
 1 file changed, 7 insertions(+), 25 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
index 61b56269ac3ea..23077dbb32f31 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.cpp
+++ b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -46,9 +46,7 @@ void ExpectNotRealtime(const char *InterceptedFunctionName) {
 }
 } // namespace __radsan
 
-/*
-    Filesystem
-*/
+// Filesystem
 
 INTERCEPTOR(int, open, const char *path, int oflag, ...) {
   // TODO Establish whether we should intercept here if the flag contains
@@ -121,19 +119,13 @@ INTERCEPTOR(int, fputs, const char *s, FILE *stream) {
   return REAL(fputs)(s, stream);
 }
 
-/*
-    Streams
-*/
-
+// Streams
 INTERCEPTOR(int, puts, const char *s) {
   __radsan::ExpectNotRealtime("puts");
   return REAL(puts)(s);
 }
 
-/*
-    Concurrency
-*/
-
+ // Concurrency
 #if SANITIZER_APPLE
 #pragma clang diagnostic push
 // OSSpinLockLock is deprecated, but still in use in libc++
@@ -213,9 +205,7 @@ INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *lock) {
   return REAL(pthread_rwlock_wrlock)(lock);
 }
 
-/*
-    Sleeping
-*/
+// Sleeping
 
 INTERCEPTOR(unsigned int, sleep, unsigned int s) {
   __radsan::ExpectNotRealtime("sleep");
@@ -233,9 +223,7 @@ INTERCEPTOR(int, nanosleep, const struct timespec *rqtp,
   return REAL(nanosleep)(rqtp, rmtp);
 }
 
-/*
-    Memory
-*/
+// Memory
 
 INTERCEPTOR(void *, calloc, SIZE_T num, SIZE_T size) {
   __radsan::ExpectNotRealtime("calloc");
@@ -298,10 +286,7 @@ INTERCEPTOR(void *, pvalloc, size_t size) {
 }
 #endif
 
-/*
-    Sockets
-*/
-
+// Sockets
 INTERCEPTOR(int, socket, int domain, int type, int protocol) {
   __radsan::ExpectNotRealtime("socket");
   return REAL(socket)(domain, type, protocol);
@@ -345,10 +330,7 @@ INTERCEPTOR(int, shutdown, int socket, int how) {
   return REAL(shutdown)(socket, how);
 }
 
-/*
-    Preinit
-*/
-
+// Preinit
 namespace __radsan {
 void InitializeInterceptors() {
   INTERCEPT_FUNCTION(calloc);

>From b3885f3ff0b8543512b0d523048bbcce2541cbf2 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Sun, 19 May 2024 22:37:52 -0700
Subject: [PATCH 22/44] PR: Prefix external API with dunderscores

---
 compiler-rt/lib/radsan/radsan.cpp                    | 10 +++++-----
 compiler-rt/lib/radsan/radsan.h                      | 12 ++++++------
 compiler-rt/lib/radsan/radsan_preinit.cpp            |  2 +-
 .../lib/radsan/tests/radsan_test_functional.cpp      |  4 ++--
 compiler-rt/lib/radsan/tests/radsan_test_utilities.h |  4 ++--
 5 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan.cpp b/compiler-rt/lib/radsan/radsan.cpp
index 52b228dd93195..5fc7d1ab8beea 100644
--- a/compiler-rt/lib/radsan/radsan.cpp
+++ b/compiler-rt/lib/radsan/radsan.cpp
@@ -14,23 +14,23 @@
 
 extern "C" {
 
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_init() {
+SANITIZER_INTERFACE_ATTRIBUTE void __radsan_init() {
   __radsan::InitializeInterceptors();
 }
 
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_enter() {
+SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_enter() {
   __radsan::GetContextForThisThread().RealtimePush();
 }
 
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_exit() {
+SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_exit() {
   __radsan::GetContextForThisThread().RealtimePop();
 }
 
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_off() {
+SANITIZER_INTERFACE_ATTRIBUTE void __radsan_off() {
   __radsan::GetContextForThisThread().BypassPush();
 }
 
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_on() {
+SANITIZER_INTERFACE_ATTRIBUTE void __radsan_on() {
   __radsan::GetContextForThisThread().BypassPop();
 }
 
diff --git a/compiler-rt/lib/radsan/radsan.h b/compiler-rt/lib/radsan/radsan.h
index 28682cb9c1b24..3f2df5ef05dff 100644
--- a/compiler-rt/lib/radsan/radsan.h
+++ b/compiler-rt/lib/radsan/radsan.h
@@ -18,7 +18,7 @@ extern "C" {
 
   A call to this method is added to the preinit array on Linux systems.
 */
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_init();
+SANITIZER_INTERFACE_ATTRIBUTE void __radsan_init();
 
 /** Enter real-time context.
 
@@ -26,25 +26,25 @@ SANITIZER_INTERFACE_ATTRIBUTE void radsan_init();
   violations are detected. Calls to this method are injected at the code
   generation stage when RADSan is enabled.
 */
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_enter();
+SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_enter();
 
 /** Exit the real-time context.
 
   When not in a real-time context, RADSan interceptors will simply forward
   intercepted method calls to the real methods.
 */
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_realtime_exit();
+SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_exit();
 
 /** Disable all RADSan error reporting.
 
   Injected into the code if "nosanitize(realtime)" is on a function.
 */
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_off();
+SANITIZER_INTERFACE_ATTRIBUTE void __radsan_off();
 
 /** Re-enable all RADSan error reporting.
 
-  The counterpart to `radsan_off`.
+  The counterpart to `__radsan_off`.
 */
-SANITIZER_INTERFACE_ATTRIBUTE void radsan_on();
+SANITIZER_INTERFACE_ATTRIBUTE void __radsan_on();
 
 } // extern "C"
diff --git a/compiler-rt/lib/radsan/radsan_preinit.cpp b/compiler-rt/lib/radsan/radsan_preinit.cpp
index d3ee60f939861..43bf1d6714a40 100644
--- a/compiler-rt/lib/radsan/radsan_preinit.cpp
+++ b/compiler-rt/lib/radsan/radsan_preinit.cpp
@@ -18,6 +18,6 @@
 // This code is linked into the main executable when -fsanitize=realtime is in
 // the link flags. It can only use exported interface functions.
 __attribute__((section(".preinit_array"),
-               used)) void (*__local_radsan_preinit)(void) = radsan_init;
+               used)) void (*__local_radsan_preinit)(void) = __radsan_init;
 
 #endif
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp b/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
index 8adb3b94c5406..c4bcb9952df2a 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
@@ -198,10 +198,10 @@ TEST(TestRadsan, ThrowingAnExceptionDiesWhenRealtime) {
 TEST(TestRadsan, DoesNotDieIfTurnedOff) {
   std::mutex Mutex{};
   auto RealtimeUnsafeFunc = [&]() {
-    radsan_off();
+    __radsan_off();
     Mutex.lock();
     Mutex.unlock();
-    radsan_on();
+    __radsan_on();
   };
   RealtimeInvoke(RealtimeUnsafeFunc);
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
index 8c2821e9825ea..950c018aff304 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
+++ b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
@@ -18,9 +18,9 @@
 namespace radsan_testing {
 
 template <typename Function> void RealtimeInvoke(Function &&Func) {
-  radsan_realtime_enter();
+  __radsan_realtime_enter();
   std::forward<Function>(Func)();
-  radsan_realtime_exit();
+  __radsan_realtime_exit();
 }
 
 template <typename Function>

>From c8734686311fa03faec41c2f659dfb16fa1e4bf3 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Mon, 20 May 2024 08:39:46 -0700
Subject: [PATCH 23/44] PR: Fix variable naming cases for variables, leave
 lambdas for now

---
 compiler-rt/lib/radsan/radsan_context.cpp     |  46 +++----
 compiler-rt/lib/radsan/radsan_context.h       |   8 +-
 .../lib/radsan/radsan_interceptors.cpp        |   4 +-
 compiler-rt/lib/radsan/radsan_interceptors.h  |   2 +-
 compiler-rt/lib/radsan/radsan_stack.cpp       |   6 +-
 .../lib/radsan/tests/radsan_test_context.cpp  |  62 ++++-----
 .../radsan/tests/radsan_test_functional.cpp   |  74 +++++-----
 .../radsan/tests/radsan_test_interceptors.cpp | 126 +++++++++---------
 .../lib/radsan/tests/radsan_test_utilities.h  |   4 +-
 9 files changed, 166 insertions(+), 166 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan_context.cpp b/compiler-rt/lib/radsan/radsan_context.cpp
index bb83b1e9f16c8..344dfb6bdcdd1 100644
--- a/compiler-rt/lib/radsan/radsan_context.cpp
+++ b/compiler-rt/lib/radsan/radsan_context.cpp
@@ -24,28 +24,28 @@ using namespace __sanitizer;
 
 namespace detail {
 
-static pthread_key_t Key;
-static pthread_once_t KeyOnce = PTHREAD_ONCE_INIT;
-void internalFree(void *Ptr) { __sanitizer::InternalFree(Ptr); }
+static pthread_key_t key;
+static pthread_once_t key_once = PTHREAD_ONCE_INIT;
+void internalFree(void *ptr) { __sanitizer::InternalFree(ptr); }
 
 using __radsan::Context;
 
 Context &GetContextForThisThreadImpl() {
-  auto MakeTlsKey = []() {
-    CHECK_EQ(pthread_key_create(&detail::Key, detail::internalFree), 0);
+  auto make_tls_key = []() {
+    CHECK_EQ(pthread_key_create(&detail::key, detail::internalFree), 0);
   };
 
-  pthread_once(&detail::KeyOnce, MakeTlsKey);
-  Context *CurrentThreadContext =
-      static_cast<Context *>(pthread_getspecific(detail::Key));
-  if (CurrentThreadContext == nullptr) {
-    CurrentThreadContext =
+  pthread_once(&detail::key_once, make_tls_key);
+  Context *current_thread_context =
+      static_cast<Context *>(pthread_getspecific(detail::key));
+  if (current_thread_context == nullptr) {
+    current_thread_context =
         static_cast<Context *>(InternalAlloc(sizeof(Context)));
-    new (CurrentThreadContext) Context();
-    pthread_setspecific(detail::Key, CurrentThreadContext);
+    new (current_thread_context) Context();
+    pthread_setspecific(detail::key, current_thread_context);
   }
 
-  return *CurrentThreadContext;
+  return *current_thread_context;
 }
 
 /*
@@ -70,32 +70,32 @@ namespace __radsan {
 
 Context::Context() = default;
 
-void Context::RealtimePush() { RealtimeDepth++; }
+void Context::RealtimePush() { realtime_depth++; }
 
-void Context::RealtimePop() { RealtimeDepth--; }
+void Context::RealtimePop() { realtime_depth--; }
 
-void Context::BypassPush() { BypassDepth++; }
+void Context::BypassPush() { bypass_depth++; }
 
-void Context::BypassPop() { BypassDepth--; }
+void Context::BypassPop() { bypass_depth--; }
 
-void Context::ExpectNotRealtime(const char *InterceptedFunctionName) {
+void Context::ExpectNotRealtime(const char *intercepted_function_name) {
   if (InRealtimeContext() && !IsBypassed()) {
     BypassPush();
-    PrintDiagnostics(InterceptedFunctionName);
+    PrintDiagnostics(intercepted_function_name);
     detail::InvokeViolationDetectedAction();
     BypassPop();
   }
 }
 
-bool Context::InRealtimeContext() const { return RealtimeDepth > 0; }
+bool Context::InRealtimeContext() const { return realtime_depth > 0; }
 
-bool Context::IsBypassed() const { return BypassDepth > 0; }
+bool Context::IsBypassed() const { return bypass_depth > 0; }
 
-void Context::PrintDiagnostics(const char *InterceptedFunctionName) {
+void Context::PrintDiagnostics(const char *intercepted_function_name) {
   fprintf(stderr,
           "Real-time violation: intercepted call to real-time unsafe function "
           "`%s` in real-time context! Stack trace:\n",
-          InterceptedFunctionName);
+          intercepted_function_name);
   __radsan::PrintStackTrace();
 }
 
diff --git a/compiler-rt/lib/radsan/radsan_context.h b/compiler-rt/lib/radsan/radsan_context.h
index 103f055508d47..8fddae0291e45 100644
--- a/compiler-rt/lib/radsan/radsan_context.h
+++ b/compiler-rt/lib/radsan/radsan_context.h
@@ -22,15 +22,15 @@ class Context {
   void BypassPush();
   void BypassPop();
 
-  void ExpectNotRealtime(const char *InterceptedFunctionName);
+  void ExpectNotRealtime(const char *intercepted_function_name);
 
 private:
   bool InRealtimeContext() const;
   bool IsBypassed() const;
-  void PrintDiagnostics(const char *InterceptedFunctionName);
+  void PrintDiagnostics(const char *intercepted_function_name);
 
-  int RealtimeDepth{0};
-  int BypassDepth{0};
+  int realtime_depth{0};
+  int bypass_depth{0};
 };
 
 Context &GetContextForThisThread();
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
index 23077dbb32f31..b157b9d25bdb1 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.cpp
+++ b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -41,8 +41,8 @@
 using namespace __sanitizer;
 
 namespace __radsan {
-void ExpectNotRealtime(const char *InterceptedFunctionName) {
-  GetContextForThisThread().ExpectNotRealtime(InterceptedFunctionName);
+void ExpectNotRealtime(const char *intercepted_function_name) {
+  GetContextForThisThread().ExpectNotRealtime(intercepted_function_name);
 }
 } // namespace __radsan
 
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.h b/compiler-rt/lib/radsan/radsan_interceptors.h
index 223d2afb93b10..95dd44ca5bc80 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.h
+++ b/compiler-rt/lib/radsan/radsan_interceptors.h
@@ -13,4 +13,4 @@
 
 namespace __radsan {
 void InitializeInterceptors();
-}
+} // namespace __radsan
diff --git a/compiler-rt/lib/radsan/radsan_stack.cpp b/compiler-rt/lib/radsan/radsan_stack.cpp
index 6563893231b50..1ba56a7068343 100644
--- a/compiler-rt/lib/radsan/radsan_stack.cpp
+++ b/compiler-rt/lib/radsan/radsan_stack.cpp
@@ -43,11 +43,11 @@ void SetGlobalStackTraceFormat() {
 using namespace __radsan;
 void __radsan::PrintStackTrace() {
 
-  BufferedStackTrace Stack{};
+  BufferedStackTrace stack{};
 
   GET_CURRENT_PC_BP;
-  Stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal);
+  stack.Unwind(pc, bp, nullptr, common_flags()->fast_unwind_on_fatal);
 
   SetGlobalStackTraceFormat();
-  Stack.Print();
+  stack.Print();
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
index 69d788b37ba01..1c098fcabd2ad 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
@@ -13,58 +13,58 @@
 
 #include "radsan_context.h"
 
-TEST(TestRadsanContext, CanCreateContext) { __radsan::Context Context{}; }
+TEST(TestRadsanContext, CanCreateContext) { __radsan::Context context{}; }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieBeforeRealtimePush) {
-  __radsan::Context Context{};
-  Context.ExpectNotRealtime("do_some_stuff");
+  __radsan::Context context{};
+  context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterPushAndPop) {
-  __radsan::Context Context{};
-  Context.RealtimePush();
-  Context.RealtimePop();
-  Context.ExpectNotRealtime("do_some_stuff");
+  __radsan::Context context{};
+  context.RealtimePush();
+  context.RealtimePop();
+  context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDiesAfterRealtimePush) {
-  __radsan::Context Context{};
+  __radsan::Context context{};
 
-  Context.RealtimePush();
-  EXPECT_DEATH(Context.ExpectNotRealtime("do_some_stuff"), "");
+  context.RealtimePush();
+  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
 }
 
 TEST(TestRadsanContext,
      ExpectNotRealtimeDiesAfterRealtimeAfterMorePushesThanPops) {
-  __radsan::Context Context{};
+  __radsan::Context context{};
 
-  Context.RealtimePush();
-  Context.RealtimePush();
-  Context.RealtimePush();
-  Context.RealtimePop();
-  Context.RealtimePop();
-  EXPECT_DEATH(Context.ExpectNotRealtime("do_some_stuff"), "");
+  context.RealtimePush();
+  context.RealtimePush();
+  context.RealtimePush();
+  context.RealtimePop();
+  context.RealtimePop();
+  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
 }
 
 TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterBypassPush) {
-  __radsan::Context Context{};
+  __radsan::Context context{};
 
-  Context.RealtimePush();
-  Context.BypassPush();
-  Context.ExpectNotRealtime("do_some_stuff");
+  context.RealtimePush();
+  context.BypassPush();
+  context.ExpectNotRealtime("do_some_stuff");
 }
 
 TEST(TestRadsanContext,
      ExpectNotRealtimeDoesNotDieIfBypassDepthIsGreaterThanZero) {
-  __radsan::Context Context{};
+  __radsan::Context context{};
 
-  Context.RealtimePush();
-  Context.BypassPush();
-  Context.BypassPush();
-  Context.BypassPush();
-  Context.BypassPop();
-  Context.BypassPop();
-  Context.ExpectNotRealtime("do_some_stuff");
-  Context.BypassPop();
-  EXPECT_DEATH(Context.ExpectNotRealtime("do_some_stuff"), "");
+  context.RealtimePush();
+  context.BypassPush();
+  context.BypassPush();
+  context.BypassPush();
+  context.BypassPop();
+  context.BypassPop();
+  context.ExpectNotRealtime("do_some_stuff");
+  context.BypassPop();
+  EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp b/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
index c4bcb9952df2a..2b314043c320a 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
@@ -41,21 +41,21 @@ using namespace radsan_testing;
 using namespace std::chrono_literals;
 
 TEST(TestRadsan, VectorPushBackAllocationDiesWhenRealtime) {
-  std::vector<float> Vec{};
-  auto Func = [&Vec]() { Vec.push_back(0.4f); };
+  std::vector<float> vec{};
+  auto Func = [&vec]() { vec.push_back(0.4f); };
   ExpectRealtimeDeath(Func);
-  ASSERT_EQ(0u, Vec.size());
+  ASSERT_EQ(0u, vec.size());
   ExpectNonRealtimeSurvival(Func);
-  ASSERT_EQ(1u, Vec.size());
+  ASSERT_EQ(1u, vec.size());
 }
 
 TEST(TestRadsan, DestructionOfObjectOnHeapDiesWhenRealtime) {
-  auto AllocatedPtr = std::make_unique<std::array<float, 256>>();
-  auto Func = [&AllocatedPtr]() { AllocatedPtr.reset(); };
+  auto allocated_ptr = std::make_unique<std::array<float, 256>>();
+  auto Func = [&allocated_ptr]() { allocated_ptr.reset(); };
   ExpectRealtimeDeath(Func);
-  ASSERT_NE(nullptr, AllocatedPtr.get());
+  ASSERT_NE(nullptr, allocated_ptr.get());
   ExpectNonRealtimeSurvival(Func);
-  ASSERT_EQ(nullptr, AllocatedPtr.get());
+  ASSERT_EQ(nullptr, allocated_ptr.get());
 }
 
 TEST(TestRadsan, SleepingAThreadDiesWhenRealtime) {
@@ -79,16 +79,16 @@ TEST(TestRadsan, OfstreamCreationDiesWhenRealtime) {
 }
 
 TEST(TestRadsan, LockingAMutexDiesWhenRealtime) {
-  std::mutex Mutex{};
-  auto Func = [&]() { Mutex.lock(); };
+  std::mutex mutex{};
+  auto Func = [&]() { mutex.lock(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsan, UnlockingAMutexDiesWhenRealtime) {
-  std::mutex Mutex{};
-  Mutex.lock();
-  auto Func = [&]() { Mutex.unlock(); };
+  std::mutex mutex{};
+  mutex.lock();
+  auto Func = [&]() { mutex.unlock(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
@@ -96,31 +96,31 @@ TEST(TestRadsan, UnlockingAMutexDiesWhenRealtime) {
 #if RADSAN_TEST_SHARED_MUTEX
 
 TEST(TestRadsan, LockingASharedMutexDiesWhenRealtime) {
-  std::shared_mutex Mutex{};
-  auto Func = [&]() { Mutex.lock(); };
+  std::shared_mutex mutex{};
+  auto Func = [&]() { mutex.lock(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsan, UnlockingASharedMutexDiesWhenRealtime) {
-  std::shared_mutex Mutex{};
-  Mutex.lock();
-  auto Func = [&]() { Mutex.unlock(); };
+  std::shared_mutex mutex{};
+  mutex.lock();
+  auto Func = [&]() { mutex.unlock(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsan, SharedLockingASharedMutexDiesWhenRealtime) {
-  std::shared_mutex Mutex{};
-  auto Func = [&]() { Mutex.lock_shared(); };
+  std::shared_mutex mutex{};
+  auto Func = [&]() { mutex.lock_shared(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsan, SharedUnlockingASharedMutexDiesWhenRealtime) {
-  std::shared_mutex Mutex{};
-  Mutex.lock_shared();
-  auto Func = [&]() { Mutex.unlock_shared(); };
+  std::shared_mutex mutex{};
+  mutex.lock_shared();
+  auto Func = [&]() { mutex.unlock_shared(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
@@ -141,12 +141,12 @@ void InvokeStdFunction(std::function<void()> &&function) { function(); }
 } // namespace
 
 TEST(TestRadsan, CopyingALambdaWithLargeCaptureDiesWhenRealtime) {
-  std::array<float, 16> LotsOfData{};
-  auto lambda = [LotsOfData]() mutable {
+  std::array<float, 16> lots_of_data{};
+  auto lambda = [lots_of_data]() mutable {
     // Stop everything getting optimised out
-    LotsOfData[3] = 0.25f;
-    EXPECT_EQ(16, LotsOfData.size());
-    EXPECT_EQ(0.25f, LotsOfData[3]);
+    lots_of_data[3] = 0.25f;
+    EXPECT_EQ(16, lots_of_data.size());
+    EXPECT_EQ(0.25f, lots_of_data[3]);
   };
   auto Func = [&]() { InvokeStdFunction(lambda); };
   ExpectRealtimeDeath(Func);
@@ -154,13 +154,13 @@ TEST(TestRadsan, CopyingALambdaWithLargeCaptureDiesWhenRealtime) {
 }
 
 TEST(TestRadsan, AccessingALargeAtomicVariableDiesWhenRealtime) {
-  std::atomic<float> SmallAtomic{0.0f};
-  ASSERT_TRUE(SmallAtomic.is_lock_free());
-  RealtimeInvoke([&SmallAtomic]() { float x = SmallAtomic.load(); });
+  std::atomic<float> small_atomic{0.0f};
+  ASSERT_TRUE(small_atomic.is_lock_free());
+  RealtimeInvoke([&small_atomic]() { float x = small_atomic.load(); });
 
-  std::atomic<std::array<float, 2048>> LargeAtomic{};
-  ASSERT_FALSE(LargeAtomic.is_lock_free());
-  auto Func = [&]() { auto x = LargeAtomic.load(); };
+  std::atomic<std::array<float, 2048>> large_atomic{};
+  ASSERT_FALSE(large_atomic.is_lock_free());
+  auto Func = [&]() { auto x = large_atomic.load(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
@@ -196,11 +196,11 @@ TEST(TestRadsan, ThrowingAnExceptionDiesWhenRealtime) {
 }
 
 TEST(TestRadsan, DoesNotDieIfTurnedOff) {
-  std::mutex Mutex{};
+  std::mutex mutex{};
   auto RealtimeUnsafeFunc = [&]() {
     __radsan_off();
-    Mutex.lock();
-    Mutex.unlock();
+    mutex.lock();
+    mutex.unlock();
     __radsan_on();
   };
   RealtimeInvoke(RealtimeUnsafeFunc);
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index e3b2e34fbe48a..182cdef071a30 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -116,8 +116,8 @@ TEST(TestRadsanInterceptors, FreeSurvivesWhenRealtimeIfArgumentIsNull) {
 
 TEST(TestRadsanInterceptors, PosixMemalignDiesWhenRealtime) {
   auto Func = []() {
-    void *Mem;
-    posix_memalign(&Mem, 4, 4);
+    void *ptr;
+    posix_memalign(&ptr, 4, 4);
   };
   ExpectRealtimeDeath(Func, "posix_memalign");
   ExpectNonRealtimeSurvival(Func);
@@ -203,8 +203,8 @@ TEST(TestRadsanInterceptors, CloseDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, FopenDiesWhenRealtime) {
   auto Func = []() {
-    FILE *Fd = fopen(TemporaryFilePath(), "w");
-    EXPECT_THAT(Fd, Ne(nullptr));
+    FILE *fd = fopen(TemporaryFilePath(), "w");
+    EXPECT_THAT(fd, Ne(nullptr));
   };
   ExpectRealtimeDeath(Func, "fopen");
   ExpectNonRealtimeSurvival(Func);
@@ -212,32 +212,32 @@ TEST(TestRadsanInterceptors, FopenDiesWhenRealtime) {
 }
 
 TEST(TestRadsanInterceptors, FreadDiesWhenRealtime) {
-  FILE *Fd = fopen(TemporaryFilePath(), "w");
-  auto Func = [Fd]() {
+  FILE *fd = fopen(TemporaryFilePath(), "w");
+  auto Func = [fd]() {
     char c{};
-    fread(&c, 1, 1, Fd);
+    fread(&c, 1, 1, fd);
   };
   ExpectRealtimeDeath(Func, "fread");
   ExpectNonRealtimeSurvival(Func);
-  if (Fd != nullptr)
-    fclose(Fd);
+  if (fd != nullptr)
+    fclose(fd);
   std::remove(TemporaryFilePath());
 }
 
 TEST(TestRadsanInterceptors, FwriteDiesWhenRealtime) {
-  FILE *Fd = fopen(TemporaryFilePath(), "w");
-  ASSERT_NE(nullptr, Fd);
-  const char *Message = "Hello, world!";
-  auto Func = [&]() { fwrite(&Message, 1, 4, Fd); };
+  FILE *fd = fopen(TemporaryFilePath(), "w");
+  ASSERT_NE(nullptr, fd);
+  const char *message = "Hello, world!";
+  auto Func = [&]() { fwrite(&message, 1, 4, fd); };
   ExpectRealtimeDeath(Func, "fwrite");
   ExpectNonRealtimeSurvival(Func);
   std::remove(TemporaryFilePath());
 }
 
 TEST(TestRadsanInterceptors, FcloseDiesWhenRealtime) {
-  FILE *Fd = fopen(TemporaryFilePath(), "w");
-  EXPECT_THAT(Fd, Ne(nullptr));
-  auto Func = [Fd]() { fclose(Fd); };
+  FILE *fd = fopen(TemporaryFilePath(), "w");
+  EXPECT_THAT(fd, Ne(nullptr));
+  auto Func = [fd]() { fclose(fd); };
   ExpectRealtimeDeath(Func, "fclose");
   ExpectNonRealtimeSurvival(Func);
   std::remove(TemporaryFilePath());
@@ -250,13 +250,13 @@ TEST(TestRadsanInterceptors, PutsDiesWhenRealtime) {
 }
 
 TEST(TestRadsanInterceptors, FputsDiesWhenRealtime) {
-  FILE *Fd = fopen(TemporaryFilePath(), "w");
-  ASSERT_THAT(Fd, Ne(nullptr)) << errno;
-  auto Func = [Fd]() { fputs("Hello, world!\n", Fd); };
+  FILE *fd = fopen(TemporaryFilePath(), "w");
+  ASSERT_THAT(fd, Ne(nullptr)) << errno;
+  auto Func = [fd]() { fputs("Hello, world!\n", fd); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
-  if (Fd != nullptr)
-    fclose(Fd);
+  if (fd != nullptr)
+    fclose(fd);
   std::remove(TemporaryFilePath());
 }
 
@@ -266,10 +266,10 @@ TEST(TestRadsanInterceptors, FputsDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, PthreadCreateDiesWhenRealtime) {
   auto Func = []() {
-    pthread_t Thread{};
-    const pthread_attr_t Attr{};
-    struct thread_info *ThreadInfo;
-    pthread_create(&Thread, &Attr, &FakeThreadEntryPoint, ThreadInfo);
+    pthread_t thread{};
+    const pthread_attr_t attr{};
+    struct thread_info *thread_info;
+    pthread_create(&thread, &attr, &FakeThreadEntryPoint, thread_info);
   };
   ExpectRealtimeDeath(Func, "pthread_create");
   ExpectNonRealtimeSurvival(Func);
@@ -277,8 +277,8 @@ TEST(TestRadsanInterceptors, PthreadCreateDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, PthreadMutexLockDiesWhenRealtime) {
   auto Func = []() {
-    pthread_mutex_t Mutex{};
-    pthread_mutex_lock(&Mutex);
+    pthread_mutex_t mutex{};
+    pthread_mutex_lock(&mutex);
   };
 
   ExpectRealtimeDeath(Func, "pthread_mutex_lock");
@@ -287,8 +287,8 @@ TEST(TestRadsanInterceptors, PthreadMutexLockDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, PthreadMutexUnlockDiesWhenRealtime) {
   auto Func = []() {
-    pthread_mutex_t Mutex{};
-    pthread_mutex_unlock(&Mutex);
+    pthread_mutex_t mutex{};
+    pthread_mutex_unlock(&mutex);
   };
 
   ExpectRealtimeDeath(Func, "pthread_mutex_unlock");
@@ -297,8 +297,8 @@ TEST(TestRadsanInterceptors, PthreadMutexUnlockDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, PthreadMutexJoinDiesWhenRealtime) {
   auto Func = []() {
-    pthread_t Thread{};
-    pthread_join(Thread, nullptr);
+    pthread_t thread{};
+    pthread_join(thread, nullptr);
   };
 
   ExpectRealtimeDeath(Func, "pthread_join");
@@ -312,8 +312,8 @@ TEST(TestRadsanInterceptors, PthreadMutexJoinDiesWhenRealtime) {
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 TEST(TestRadsanInterceptors, OsSpinLockLockDiesWhenRealtime) {
   auto Func = []() {
-    OSSpinLock SpinLock{};
-    OSSpinLockLock(&SpinLock);
+    OSSpinLock spin_lock{};
+    OSSpinLockLock(&spin_lock);
   };
   ExpectRealtimeDeath(Func, "OSSpinLockLock");
   ExpectNonRealtimeSurvival(Func);
@@ -322,8 +322,8 @@ TEST(TestRadsanInterceptors, OsSpinLockLockDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, OsUnfairLockLockDiesWhenRealtime) {
   auto Func = []() {
-    os_unfair_lock_s UnfairLock{};
-    os_unfair_lock_lock(&UnfairLock);
+    os_unfair_lock_s unfair_lock{};
+    os_unfair_lock_lock(&unfair_lock);
   };
   ExpectRealtimeDeath(Func, "os_unfair_lock_lock");
   ExpectNonRealtimeSurvival(Func);
@@ -332,9 +332,9 @@ TEST(TestRadsanInterceptors, OsUnfairLockLockDiesWhenRealtime) {
 
 #if SANITIZER_LINUX
 TEST(TestRadsanInterceptors, SpinLockLockDiesWhenRealtime) {
-  pthread_spinlock_t SpinLock;
-  pthread_spin_init(&SpinLock, PTHREAD_PROCESS_SHARED);
-  auto Func = [&]() { pthread_spin_lock(&SpinLock); };
+  pthread_spinlock_t spin_lock;
+  pthread_spin_init(&spin_lock, PTHREAD_PROCESS_SHARED);
+  auto Func = [&]() { pthread_spin_lock(&spin_lock); };
   ExpectRealtimeDeath(Func, "pthread_spin_lock");
   ExpectNonRealtimeSurvival(Func);
 }
@@ -342,8 +342,8 @@ TEST(TestRadsanInterceptors, SpinLockLockDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, PthreadCondSignalDiesWhenRealtime) {
   auto Func = []() {
-    pthread_cond_t Cond{};
-    pthread_cond_signal(&Cond);
+    pthread_cond_t cond{};
+    pthread_cond_signal(&cond);
   };
   ExpectRealtimeDeath(Func, "pthread_cond_signal");
   ExpectNonRealtimeSurvival(Func);
@@ -351,19 +351,19 @@ TEST(TestRadsanInterceptors, PthreadCondSignalDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, PthreadCondBroadcastDiesWhenRealtime) {
   auto Func = []() {
-    pthread_cond_t Cond;
-    pthread_cond_broadcast(&Cond);
+    pthread_cond_t cond;
+    pthread_cond_broadcast(&cond);
   };
   ExpectRealtimeDeath(Func, "pthread_cond_broadcast");
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsanInterceptors, PthreadCondWaitDiesWhenRealtime) {
-  pthread_cond_t Cond;
-  pthread_mutex_t Mutex;
-  ASSERT_EQ(0, pthread_cond_init(&Cond, nullptr));
-  ASSERT_EQ(0, pthread_mutex_init(&Mutex, nullptr));
-  auto Func = [&]() { pthread_cond_wait(&Cond, &Mutex); };
+  pthread_cond_t cond;
+  pthread_mutex_t mutex;
+  ASSERT_EQ(0, pthread_cond_init(&cond, nullptr));
+  ASSERT_EQ(0, pthread_mutex_init(&mutex, nullptr));
+  auto Func = [&]() { pthread_cond_wait(&cond, &mutex); };
   ExpectRealtimeDeath(Func, "pthread_cond_wait");
   // It's very difficult to test the success case here without doing some
   // sleeping, which is at the mercy of the scheduler. What's really important
@@ -372,8 +372,8 @@ TEST(TestRadsanInterceptors, PthreadCondWaitDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, PthreadRwlockRdlockDiesWhenRealtime) {
   auto Func = []() {
-    pthread_rwlock_t RwLock;
-    pthread_rwlock_rdlock(&RwLock);
+    pthread_rwlock_t rw_lock;
+    pthread_rwlock_rdlock(&rw_lock);
   };
   ExpectRealtimeDeath(Func, "pthread_rwlock_rdlock");
   ExpectNonRealtimeSurvival(Func);
@@ -381,8 +381,8 @@ TEST(TestRadsanInterceptors, PthreadRwlockRdlockDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, PthreadRwlockUnlockDiesWhenRealtime) {
   auto Func = []() {
-    pthread_rwlock_t RwLock;
-    pthread_rwlock_unlock(&RwLock);
+    pthread_rwlock_t rw_lock;
+    pthread_rwlock_unlock(&rw_lock);
   };
   ExpectRealtimeDeath(Func, "pthread_rwlock_unlock");
   ExpectNonRealtimeSurvival(Func);
@@ -390,8 +390,8 @@ TEST(TestRadsanInterceptors, PthreadRwlockUnlockDiesWhenRealtime) {
 
 TEST(TestRadsanInterceptors, PthreadRwlockWrlockDiesWhenRealtime) {
   auto Func = []() {
-    pthread_rwlock_t RwLock;
-    pthread_rwlock_wrlock(&RwLock);
+    pthread_rwlock_t rw_lock;
+    pthread_rwlock_wrlock(&rw_lock);
   };
   ExpectRealtimeDeath(Func, "pthread_rwlock_wrlock");
   ExpectNonRealtimeSurvival(Func);
@@ -413,16 +413,16 @@ TEST(TestRadsanInterceptors, SendToASocketDiesWhenRealtime) {
 }
 
 TEST(TestRadsanInterceptors, SendmsgToASocketDiesWhenRealtime) {
-  msghdr Msg{};
-  auto Func = [&]() { sendmsg(0, &Msg, 0); };
+  msghdr msg{};
+  auto Func = [&]() { sendmsg(0, &msg, 0); };
   ExpectRealtimeDeath(Func, "sendmsg");
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsanInterceptors, SendtoToASocketDiesWhenRealtime) {
-  sockaddr Addr{};
-  socklen_t Len{};
-  auto Func = [&]() { sendto(0, nullptr, 0, 0, &Addr, Len); };
+  sockaddr addr{};
+  socklen_t len{};
+  auto Func = [&]() { sendto(0, nullptr, 0, 0, &addr, len); };
   ExpectRealtimeDeath(Func, "sendto");
   ExpectNonRealtimeSurvival(Func);
 }
@@ -434,16 +434,16 @@ TEST(TestRadsanInterceptors, RecvFromASocketDiesWhenRealtime) {
 }
 
 TEST(TestRadsanInterceptors, RecvfromOnASocketDiesWhenRealtime) {
-  sockaddr Addr{};
-  socklen_t Len{};
-  auto Func = [&]() { recvfrom(0, nullptr, 0, 0, &Addr, &Len); };
+  sockaddr addr{};
+  socklen_t len{};
+  auto Func = [&]() { recvfrom(0, nullptr, 0, 0, &addr, &len); };
   ExpectRealtimeDeath(Func, "recvfrom");
   ExpectNonRealtimeSurvival(Func);
 }
 
 TEST(TestRadsanInterceptors, RecvmsgOnASocketDiesWhenRealtime) {
-  msghdr Msg{};
-  auto Func = [&]() { recvmsg(0, &Msg, 0); };
+  msghdr msg{};
+  auto Func = [&]() { recvmsg(0, &msg, 0); };
   ExpectRealtimeDeath(Func, "recvmsg");
   ExpectNonRealtimeSurvival(Func);
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
index 950c018aff304..1d1c404a1373b 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
+++ b/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
@@ -29,7 +29,7 @@ void ExpectRealtimeDeath(Function &&Func,
 
   using namespace testing;
 
-  auto ExpectedErrorSubstring = [&]() -> std::string {
+  auto GetExpectedErrorSubstring = [&]() -> std::string {
     return intercepted_method_name != nullptr
                ? "Real-time violation: intercepted call to real-time unsafe "
                  "function `" +
@@ -38,7 +38,7 @@ void ExpectRealtimeDeath(Function &&Func,
   };
 
   EXPECT_EXIT(RealtimeInvoke(std::forward<Function>(Func)),
-              ExitedWithCode(EXIT_FAILURE), ExpectedErrorSubstring());
+              ExitedWithCode(EXIT_FAILURE), GetExpectedErrorSubstring());
 }
 
 template <typename Function> void ExpectNonRealtimeSurvival(Function &&Func) {

>From 319759357b2ac76a60d9f7bf57a9610f415bfe82 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Mon, 20 May 2024 09:08:50 -0700
Subject: [PATCH 24/44] PR: Fix style nit

---
 clang/lib/Driver/ToolChains/CommonArgs.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp
index 05bf9d97b8405..7ea6d842c9d3a 100644
--- a/clang/lib/Driver/ToolChains/CommonArgs.cpp
+++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp
@@ -1443,9 +1443,8 @@ collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
       StaticRuntimes.push_back("asan_cxx");
   }
 
-  if (!SanArgs.needsSharedRt() && SanArgs.needsRadsanRt()) {
+  if (!SanArgs.needsSharedRt() && SanArgs.needsRadsanRt()) 
     StaticRuntimes.push_back("radsan");
-  }
 
   if (!SanArgs.needsSharedRt() && SanArgs.needsMemProfRt()) {
     StaticRuntimes.push_back("memprof");

>From b4db15c12967c0a08c20b2191498c98e1ecd110b Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Mon, 20 May 2024 09:10:17 -0700
Subject: [PATCH 25/44] PR: Fix small style fallout

---
 clang/lib/Driver/ToolChains/CommonArgs.cpp     | 2 +-
 compiler-rt/lib/radsan/radsan_interceptors.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp
index 7ea6d842c9d3a..5a92faa8a2898 100644
--- a/clang/lib/Driver/ToolChains/CommonArgs.cpp
+++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp
@@ -1443,7 +1443,7 @@ collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
       StaticRuntimes.push_back("asan_cxx");
   }
 
-  if (!SanArgs.needsSharedRt() && SanArgs.needsRadsanRt()) 
+  if (!SanArgs.needsSharedRt() && SanArgs.needsRadsanRt())
     StaticRuntimes.push_back("radsan");
 
   if (!SanArgs.needsSharedRt() && SanArgs.needsMemProfRt()) {
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
index b157b9d25bdb1..87b16aa47bd3d 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.cpp
+++ b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -125,7 +125,7 @@ INTERCEPTOR(int, puts, const char *s) {
   return REAL(puts)(s);
 }
 
- // Concurrency
+// Concurrency
 #if SANITIZER_APPLE
 #pragma clang diagnostic push
 // OSSpinLockLock is deprecated, but still in use in libc++

>From e2b4a98bf8f0f586024e2067ebd1249d86a592ea Mon Sep 17 00:00:00 2001
From: David Trevelyan <david.trevelyan at gmail.com>
Date: Tue, 21 May 2024 09:22:04 +0100
Subject: [PATCH 26/44] Update comment and TU-local function style

---
 compiler-rt/lib/radsan/radsan.h           | 36 ++++++++-------------
 compiler-rt/lib/radsan/radsan_context.cpp | 39 +++++++++--------------
 compiler-rt/lib/radsan/radsan_stack.cpp   |  5 +--
 3 files changed, 29 insertions(+), 51 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan.h b/compiler-rt/lib/radsan/radsan.h
index 3f2df5ef05dff..e4a897e831d76 100644
--- a/compiler-rt/lib/radsan/radsan.h
+++ b/compiler-rt/lib/radsan/radsan.h
@@ -14,37 +14,27 @@
 
 extern "C" {
 
-/**  Initialise radsan interceptors.
-
-  A call to this method is added to the preinit array on Linux systems.
-*/
+// Initialise radsan interceptors.
+// A call to this method is added to the preinit array on Linux systems.
 SANITIZER_INTERFACE_ATTRIBUTE void __radsan_init();
 
-/** Enter real-time context.
-
-  When in a real-time context, RADSan interceptors will error if realtime
-  violations are detected. Calls to this method are injected at the code
-  generation stage when RADSan is enabled.
-*/
+// Enter real-time context.
+// When in a real-time context, RADSan interceptors will error if realtime
+// violations are detected. Calls to this method are injected at the code
+// generation stage when RADSan is enabled.
 SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_enter();
 
-/** Exit the real-time context.
-
-  When not in a real-time context, RADSan interceptors will simply forward
-  intercepted method calls to the real methods.
-*/
+// Exit the real-time context.
+// When not in a real-time context, RADSan interceptors will simply forward
+// intercepted method calls to the real methods.
 SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_exit();
 
-/** Disable all RADSan error reporting.
-
-  Injected into the code if "nosanitize(realtime)" is on a function.
-*/
+// Disable all RADSan error reporting.
+// Injected into the code if "nosanitize(realtime)" is on a function.
 SANITIZER_INTERFACE_ATTRIBUTE void __radsan_off();
 
-/** Re-enable all RADSan error reporting.
-
-  The counterpart to `__radsan_off`.
-*/
+// Re-enable all RADSan error reporting.
+// The counterpart to `__radsan_off`.
 SANITIZER_INTERFACE_ATTRIBUTE void __radsan_on();
 
 } // extern "C"
diff --git a/compiler-rt/lib/radsan/radsan_context.cpp b/compiler-rt/lib/radsan/radsan_context.cpp
index 344dfb6bdcdd1..2d43061c15bfe 100644
--- a/compiler-rt/lib/radsan/radsan_context.cpp
+++ b/compiler-rt/lib/radsan/radsan_context.cpp
@@ -20,29 +20,24 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-using namespace __sanitizer;
-
-namespace detail {
-
-static pthread_key_t key;
+static pthread_key_t context_key;
 static pthread_once_t key_once = PTHREAD_ONCE_INIT;
-void internalFree(void *ptr) { __sanitizer::InternalFree(ptr); }
 
-using __radsan::Context;
+static void internalFree(void *ptr) { __sanitizer::InternalFree(ptr); }
 
-Context &GetContextForThisThreadImpl() {
-  auto make_tls_key = []() {
-    CHECK_EQ(pthread_key_create(&detail::key, detail::internalFree), 0);
+static __radsan::Context &GetContextForThisThreadImpl() {
+  auto make_thread_local_context_key = []() {
+    CHECK_EQ(pthread_key_create(&context_key, internalFree), 0);
   };
 
-  pthread_once(&detail::key_once, make_tls_key);
-  Context *current_thread_context =
-      static_cast<Context *>(pthread_getspecific(detail::key));
+  pthread_once(&key_once, make_thread_local_context_key);
+  __radsan::Context *current_thread_context =
+      static_cast<__radsan::Context *>(pthread_getspecific(context_key));
   if (current_thread_context == nullptr) {
-    current_thread_context =
-        static_cast<Context *>(InternalAlloc(sizeof(Context)));
-    new (current_thread_context) Context();
-    pthread_setspecific(detail::key, current_thread_context);
+    current_thread_context = static_cast<__radsan::Context *>(
+        __sanitizer::InternalAlloc(sizeof(__radsan::Context)));
+    new (current_thread_context) __radsan::Context();
+    pthread_setspecific(context_key, current_thread_context);
   }
 
   return *current_thread_context;
@@ -62,9 +57,7 @@ Context &GetContextForThisThreadImpl() {
     Until then, and to keep the first PRs small, only the exit mode
     is available.
 */
-void InvokeViolationDetectedAction() { exit(EXIT_FAILURE); }
-
-} // namespace detail
+static void InvokeViolationDetectedAction() { exit(EXIT_FAILURE); }
 
 namespace __radsan {
 
@@ -82,7 +75,7 @@ void Context::ExpectNotRealtime(const char *intercepted_function_name) {
   if (InRealtimeContext() && !IsBypassed()) {
     BypassPush();
     PrintDiagnostics(intercepted_function_name);
-    detail::InvokeViolationDetectedAction();
+    InvokeViolationDetectedAction();
     BypassPop();
   }
 }
@@ -99,8 +92,6 @@ void Context::PrintDiagnostics(const char *intercepted_function_name) {
   __radsan::PrintStackTrace();
 }
 
-Context &GetContextForThisThread() {
-  return detail::GetContextForThisThreadImpl();
-}
+Context &GetContextForThisThread() { return GetContextForThisThreadImpl(); }
 
 } // namespace __radsan
diff --git a/compiler-rt/lib/radsan/radsan_stack.cpp b/compiler-rt/lib/radsan/radsan_stack.cpp
index 1ba56a7068343..d00db6068132f 100644
--- a/compiler-rt/lib/radsan/radsan_stack.cpp
+++ b/compiler-rt/lib/radsan/radsan_stack.cpp
@@ -17,7 +17,6 @@ using namespace __sanitizer;
 
 // We must define our own implementation of this method for our runtime.
 // This one is just copied from UBSan.
-
 namespace __sanitizer {
 void BufferedStackTrace::UnwindImpl(uptr pc, uptr bp, void *context,
                                     bool request_fast, u32 max_depth) {
@@ -29,8 +28,7 @@ void BufferedStackTrace::UnwindImpl(uptr pc, uptr bp, void *context,
 }
 } // namespace __sanitizer
 
-namespace __radsan {
-void SetGlobalStackTraceFormat() {
+static void SetGlobalStackTraceFormat() {
   SetCommonFlagsDefaults();
   CommonFlags cf;
   cf.CopyFrom(*common_flags());
@@ -38,7 +36,6 @@ void SetGlobalStackTraceFormat() {
   cf.external_symbolizer_path = GetEnv("RADSAN_SYMBOLIZER_PATH");
   OverrideCommonFlags(cf);
 }
-} // namespace __radsan
 
 using namespace __radsan;
 void __radsan::PrintStackTrace() {

>From dca1d5a222ea24b61aa079de43b995601d14d8a5 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Tue, 21 May 2024 13:46:02 -0700
Subject: [PATCH 27/44] PR: Remove too early inclusion of sanitizer common lit
 tests

---
 compiler-rt/test/sanitizer_common/CMakeLists.txt    | 2 +-
 compiler-rt/test/sanitizer_common/lit.common.cfg.py | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/compiler-rt/test/sanitizer_common/CMakeLists.txt b/compiler-rt/test/sanitizer_common/CMakeLists.txt
index 1c37cf2a0c721..edecc04d48c75 100644
--- a/compiler-rt/test/sanitizer_common/CMakeLists.txt
+++ b/compiler-rt/test/sanitizer_common/CMakeLists.txt
@@ -7,7 +7,7 @@ set(SANITIZER_COMMON_TESTSUITES)
 # FIXME(dliew): We should switch to COMPILER_RT_SANITIZERS_TO_BUILD instead of
 # the hard coded `SUPPORTED_TOOLS_INIT` list once we know that the other
 # sanitizers work.
-set(SUPPORTED_TOOLS_INIT asan lsan hwasan msan radsan tsan ubsan)
+set(SUPPORTED_TOOLS_INIT asan lsan hwasan msan tsan ubsan)
 set(SUPPORTED_TOOLS)
   foreach(SANITIZER_TOOL ${SUPPORTED_TOOLS_INIT})
     string(TOUPPER ${SANITIZER_TOOL} SANITIZER_TOOL_UPPER)
diff --git a/compiler-rt/test/sanitizer_common/lit.common.cfg.py b/compiler-rt/test/sanitizer_common/lit.common.cfg.py
index 80c7372372f44..04af4816eb6e7 100644
--- a/compiler-rt/test/sanitizer_common/lit.common.cfg.py
+++ b/compiler-rt/test/sanitizer_common/lit.common.cfg.py
@@ -18,9 +18,6 @@
     tool_options = "HWASAN_OPTIONS"
     if not config.has_lld:
         config.unsupported = True
-elif config.tool_name == "radsan":
-    tool_cflags = ["-fsanitize=realtime"]
-    tool_options = "RADSAN_OPTIONS"
 elif config.tool_name == "tsan":
     tool_cflags = ["-fsanitize=thread"]
     tool_options = "TSAN_OPTIONS"

>From 302c5761de7bff3fd29773d68b847dc6c5ba7b39 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Thu, 30 May 2024 09:46:19 -0700
Subject: [PATCH 28/44] Test failure: fix initialization of pthread_cond_t

---
 compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index 182cdef071a30..52f3381be226b 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -350,12 +350,16 @@ TEST(TestRadsanInterceptors, PthreadCondSignalDiesWhenRealtime) {
 }
 
 TEST(TestRadsanInterceptors, PthreadCondBroadcastDiesWhenRealtime) {
+  pthread_cond_t cond;
+  pthread_cond_init(&cond, NULL);
   auto Func = []() {
     pthread_cond_t cond;
     pthread_cond_broadcast(&cond);
   };
   ExpectRealtimeDeath(Func, "pthread_cond_broadcast");
   ExpectNonRealtimeSurvival(Func);
+
+  pthread_cond_destroy(&cond);
 }
 
 TEST(TestRadsanInterceptors, PthreadCondWaitDiesWhenRealtime) {

>From 061f44a8dcca41dd2b26bbde545d02dc4c2b3ef4 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Thu, 30 May 2024 12:01:58 -0700
Subject: [PATCH 29/44] Test failure: Try again with initialization of
 pthread_cond_t

---
 compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index 52f3381be226b..5d88c3a99f2bd 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -350,10 +350,9 @@ TEST(TestRadsanInterceptors, PthreadCondSignalDiesWhenRealtime) {
 }
 
 TEST(TestRadsanInterceptors, PthreadCondBroadcastDiesWhenRealtime) {
-  pthread_cond_t cond;
+  pthread_cond_t cond{};
   pthread_cond_init(&cond, NULL);
-  auto Func = []() {
-    pthread_cond_t cond;
+  auto Func = [&cond]() {
     pthread_cond_broadcast(&cond);
   };
   ExpectRealtimeDeath(Func, "pthread_cond_broadcast");

>From cdff1b8eca978722eb2476d809b9b8e203bfa26a Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Thu, 30 May 2024 15:26:16 -0700
Subject: [PATCH 30/44] Fix code formatting on unit test

---
 compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index 5d88c3a99f2bd..7c11a66adb680 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -352,9 +352,7 @@ TEST(TestRadsanInterceptors, PthreadCondSignalDiesWhenRealtime) {
 TEST(TestRadsanInterceptors, PthreadCondBroadcastDiesWhenRealtime) {
   pthread_cond_t cond{};
   pthread_cond_init(&cond, NULL);
-  auto Func = [&cond]() {
-    pthread_cond_broadcast(&cond);
-  };
+  auto Func = [&cond]() { pthread_cond_broadcast(&cond); };
   ExpectRealtimeDeath(Func, "pthread_cond_broadcast");
   ExpectNonRealtimeSurvival(Func);
 

>From 5a86ede7dcb2d4fc4e55f1302ebcadef7e3e043c Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Thu, 30 May 2024 16:36:50 -0700
Subject: [PATCH 31/44] Ensure all pthread_cond_t are initialized in unit tests

---
 .../lib/radsan/tests/radsan_test_interceptors.cpp | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index 7c11a66adb680..0841cf95e6540 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -341,17 +341,20 @@ TEST(TestRadsanInterceptors, SpinLockLockDiesWhenRealtime) {
 #endif
 
 TEST(TestRadsanInterceptors, PthreadCondSignalDiesWhenRealtime) {
-  auto Func = []() {
-    pthread_cond_t cond{};
-    pthread_cond_signal(&cond);
-  };
+  pthread_cond_t cond{};
+  pthread_cond_init(&cond, NULL);
+
+  auto Func = [&cond]() { pthread_cond_signal(&cond); };
   ExpectRealtimeDeath(Func, "pthread_cond_signal");
   ExpectNonRealtimeSurvival(Func);
+
+  pthread_cond_destroy(&cond);
 }
 
 TEST(TestRadsanInterceptors, PthreadCondBroadcastDiesWhenRealtime) {
   pthread_cond_t cond{};
   pthread_cond_init(&cond, NULL);
+
   auto Func = [&cond]() { pthread_cond_broadcast(&cond); };
   ExpectRealtimeDeath(Func, "pthread_cond_broadcast");
   ExpectNonRealtimeSurvival(Func);
@@ -364,11 +367,15 @@ TEST(TestRadsanInterceptors, PthreadCondWaitDiesWhenRealtime) {
   pthread_mutex_t mutex;
   ASSERT_EQ(0, pthread_cond_init(&cond, nullptr));
   ASSERT_EQ(0, pthread_mutex_init(&mutex, nullptr));
+
   auto Func = [&]() { pthread_cond_wait(&cond, &mutex); };
   ExpectRealtimeDeath(Func, "pthread_cond_wait");
   // It's very difficult to test the success case here without doing some
   // sleeping, which is at the mercy of the scheduler. What's really important
   // here is the interception - so we're only testing that for now.
+
+  pthread_cond_destroy(&cond);
+  pthread_mutex_destroy(&mutex);
 }
 
 TEST(TestRadsanInterceptors, PthreadRwlockRdlockDiesWhenRealtime) {

>From b5871f7ad185255ee4910c594efe98c65fef5d66 Mon Sep 17 00:00:00 2001
From: Chris Apple <cja-private at pm.me>
Date: Fri, 31 May 2024 06:34:56 -0700
Subject: [PATCH 32/44] Fix issue where CREAT flag was not properly passing
 mode (#23)

* Pass on CREAT mode propertly in open interceptors

* Add unit tests

* Remove two unneccessary bits

* Fix fcntl
---
 .../lib/radsan/radsan_interceptors.cpp        | 16 ++++++--
 .../radsan/tests/radsan_test_interceptors.cpp | 38 +++++++++++++++++++
 2 files changed, 50 insertions(+), 4 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
index 87b16aa47bd3d..53305c0393f0a 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.cpp
+++ b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -52,10 +52,13 @@ INTERCEPTOR(int, open, const char *path, int oflag, ...) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
   __radsan::ExpectNotRealtime("open");
+
   va_list args;
   va_start(args, oflag);
-  const int result = REAL(open)(path, oflag, args);
+  const mode_t mode = va_arg(args, int);
   va_end(args);
+
+  const int result = REAL(open)(path, oflag, mode);
   return result;
 }
 
@@ -63,10 +66,13 @@ INTERCEPTOR(int, openat, int fd, const char *path, int oflag, ...) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
   __radsan::ExpectNotRealtime("openat");
+
   va_list args;
   va_start(args, oflag);
-  const int result = REAL(openat)(fd, path, oflag, args);
+  mode_t mode = va_arg(args, int);
   va_end(args);
+
+  const int result = REAL(openat)(fd, path, oflag, mode);
   return result;
 }
 
@@ -80,11 +86,13 @@ INTERCEPTOR(int, creat, const char *path, mode_t mode) {
 
 INTERCEPTOR(int, fcntl, int filedes, int cmd, ...) {
   __radsan::ExpectNotRealtime("fcntl");
+
   va_list args;
   va_start(args, cmd);
-  const int result = REAL(fcntl)(filedes, cmd, args);
+  void *arg = va_arg(args, void *);
   va_end(args);
-  return result;
+
+  return fcntl(filedes, cmd, arg);
 }
 
 INTERCEPTOR(int, close, int filedes) {
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index 0841cf95e6540..fa74e85ad95bc 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -182,6 +182,22 @@ TEST(TestRadsanInterceptors, OpenatDiesWhenRealtime) {
   std::remove(TemporaryFilePath());
 }
 
+TEST(TestRadsanInterceptors, openCreatesFileWithProperMode) {
+  const int mode = S_IRGRP | S_IROTH | S_IRUSR | S_IWUSR;
+
+  const int fd = open(TemporaryFilePath(), O_CREAT | O_WRONLY, mode);
+  ASSERT_THAT(fd, Ne(-1));
+  close(fd);
+
+  struct stat st;
+  ASSERT_THAT(stat(TemporaryFilePath(), &st), Eq(0));
+
+  // Mask st_mode to get permission bits only
+  ASSERT_THAT(st.st_mode & 0777, Eq(mode));
+
+  std::remove(TemporaryFilePath());
+}
+
 TEST(TestRadsanInterceptors, CreatDiesWhenRealtime) {
   auto Func = []() { creat(TemporaryFilePath(), S_IWOTH | S_IROTH); };
   ExpectRealtimeDeath(Func, "creat");
@@ -195,6 +211,28 @@ TEST(TestRadsanInterceptors, FcntlDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
+TEST(TestRadsanInterceptors, FcntlFlockDiesWhenRealtime) {
+  int fd = creat(TemporaryFilePath(), S_IRUSR | S_IWUSR);
+  ASSERT_THAT(fd, Ne(-1));
+
+  auto func = [fd]() {
+    struct flock lock {};
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0;
+    lock.l_pid = ::getpid();
+
+    ASSERT_THAT(fcntl(fd, F_GETLK, &lock), Eq(0));
+    ASSERT_THAT(lock.l_type, F_UNLCK);
+  };
+  ExpectRealtimeDeath(func, "fcntl");
+  ExpectNonRealtimeSurvival(func);
+
+  close(fd);
+  std::remove(TemporaryFilePath());
+}
+
 TEST(TestRadsanInterceptors, CloseDiesWhenRealtime) {
   auto Func = []() { close(0); };
   ExpectRealtimeDeath(Func, "close");

>From fe51ef8ce8dd65a8067ea05b2f47ddebb4c7c9d2 Mon Sep 17 00:00:00 2001
From: Chris Apple <cja-private at pm.me>
Date: Fri, 31 May 2024 14:15:51 -0700
Subject: [PATCH 33/44] Fix issue where fcntl was not using last arg correctly
 (#24)

* Fix issue where fcntl was not using last arg correctly

* Comment update
---
 .../lib/radsan/radsan_interceptors.cpp        | 14 ++++++++++--
 .../radsan/tests/radsan_test_interceptors.cpp | 22 +++++++++++++++++++
 2 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/radsan/radsan_interceptors.cpp
index 53305c0393f0a..dfde4d5d175f8 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.cpp
+++ b/compiler-rt/lib/radsan/radsan_interceptors.cpp
@@ -89,10 +89,20 @@ INTERCEPTOR(int, fcntl, int filedes, int cmd, ...) {
 
   va_list args;
   va_start(args, cmd);
-  void *arg = va_arg(args, void *);
+
+  // Following precedent here. The linux source (fcntl.c, do_fcntl) accepts the
+  // final argument in a variable that will hold the largest of the possible
+  // argument types (pointers and ints are typical in fcntl) It is then assumed
+  // that the implementation of fcntl will cast it properly depending on cmd.
+  //
+  // This is also similar to what is done in
+  // sanitizer_common/sanitizer_common_syscalls.inc
+  const unsigned long arg = va_arg(args, unsigned long);
+  int result = REAL(fcntl)(filedes, cmd, arg);
+
   va_end(args);
 
-  return fcntl(filedes, cmd, arg);
+  return result;
 }
 
 INTERCEPTOR(int, close, int filedes) {
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index fa74e85ad95bc..c8819405494f3 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -239,6 +239,28 @@ TEST(TestRadsanInterceptors, CloseDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
+TEST(TestRadsanInterceptors, fcntlSetFdDiesWhenRealtime) {
+  int fd = creat(TemporaryFilePath(), S_IRUSR | S_IWUSR);
+  ASSERT_THAT(fd, Ne(-1));
+
+  auto func = [fd]() {
+    int old_flags = fcntl(fd, F_GETFD);
+    ASSERT_THAT(fcntl(fd, F_SETFD, FD_CLOEXEC), Eq(0));
+
+    int flags = fcntl(fd, F_GETFD);
+    ASSERT_THAT(flags, Ne(-1));
+    ASSERT_THAT(flags & FD_CLOEXEC, Eq(FD_CLOEXEC));
+
+    ASSERT_THAT(fcntl(fd, F_SETFD, old_flags), Eq(0));
+    ASSERT_THAT(fcntl(fd, F_GETFD), Eq(old_flags));
+  };
+
+  ExpectRealtimeDeath(func, "fcntl");
+  ExpectNonRealtimeSurvival(func);
+
+  close(fd);
+}
+
 TEST(TestRadsanInterceptors, FopenDiesWhenRealtime) {
   auto Func = []() {
     FILE *fd = fopen(TemporaryFilePath(), "w");

>From 0fe45910c10991acebe0ff7c747f7f30aec8ddf8 Mon Sep 17 00:00:00 2001
From: Chris Apple <cja-private at pm.me>
Date: Sat, 1 Jun 2024 08:55:50 -0700
Subject: [PATCH 34/44] Introduce test fixture for temporary files (#25)

* Introduce test fixture for temporary files

* Style fixup for method name
---
 .../radsan/tests/radsan_test_interceptors.cpp | 160 +++++++++---------
 1 file changed, 76 insertions(+), 84 deletions(-)

diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index c8819405494f3..8b7650323346b 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -27,6 +27,7 @@
 
 #include <atomic>
 #include <chrono>
+#include <string>
 #include <thread>
 
 #include <fcntl.h>
@@ -38,24 +39,26 @@ using namespace testing;
 using namespace radsan_testing;
 using namespace std::chrono_literals;
 
-namespace {
 void *FakeThreadEntryPoint(void *) { return nullptr; }
 
-/*
-  The creat function doesn't seem to work on an ubuntu Docker image when the
-  path is in a shared volume of the host. For now, to keep testing convenient
-  with a local Docker container, we just put it somewhere that's not in the
-  shared volume (/tmp). This is volatile and will be cleaned up as soon as the
-  container is stopped.
-*/
-constexpr const char *TemporaryFilePath() {
-#if SANITIZER_LINUX
-  return "/tmp/radsan_temporary_test_file.txt";
-#elif SANITIZER_APPLE
-  return "./radsan_temporary_test_file.txt";
-#endif
-}
-} // namespace
+class RadsanFileTest : public ::testing::Test {
+protected:
+  void SetUp() override {
+    const ::testing::TestInfo *const test_info =
+        ::testing::UnitTest::GetInstance()->current_test_info();
+    file_path = std::string("/tmp/radsan_temporary_test_file_") +
+                test_info->name() + ".txt";
+  }
+
+  // Gets a file path with the test's name in in
+  // This file will be removed if it exists at the end of the test
+  const char *GetTemporaryFilePath() const { return file_path.c_str(); }
+
+  void TearDown() override { std::remove(GetTemporaryFilePath()); }
+
+private:
+  std::string file_path;
+};
 
 /*
     Allocation and deallocation
@@ -168,51 +171,46 @@ TEST(TestRadsanInterceptors, NanosleepDiesWhenRealtime) {
     Filesystem
 */
 
-TEST(TestRadsanInterceptors, OpenDiesWhenRealtime) {
-  auto Func = []() { open(TemporaryFilePath(), O_RDONLY); };
-  ExpectRealtimeDeath(Func, "open");
-  ExpectNonRealtimeSurvival(Func);
-  std::remove(TemporaryFilePath());
+TEST_F(RadsanFileTest, OpenDiesWhenRealtime) {
+  auto func = [this]() { open(GetTemporaryFilePath(), O_RDONLY); };
+  ExpectRealtimeDeath(func, "open");
+  ExpectNonRealtimeSurvival(func);
 }
 
-TEST(TestRadsanInterceptors, OpenatDiesWhenRealtime) {
-  auto Func = []() { openat(0, TemporaryFilePath(), O_RDONLY); };
-  ExpectRealtimeDeath(Func, "openat");
-  ExpectNonRealtimeSurvival(Func);
-  std::remove(TemporaryFilePath());
+TEST_F(RadsanFileTest, OpenatDiesWhenRealtime) {
+  auto func = [this]() { openat(0, GetTemporaryFilePath(), O_RDONLY); };
+  ExpectRealtimeDeath(func, "openat");
+  ExpectNonRealtimeSurvival(func);
 }
 
-TEST(TestRadsanInterceptors, openCreatesFileWithProperMode) {
+TEST_F(RadsanFileTest, OpenCreatesFileWithProperMode) {
   const int mode = S_IRGRP | S_IROTH | S_IRUSR | S_IWUSR;
 
-  const int fd = open(TemporaryFilePath(), O_CREAT | O_WRONLY, mode);
+  const int fd = open(GetTemporaryFilePath(), O_CREAT | O_WRONLY, mode);
   ASSERT_THAT(fd, Ne(-1));
   close(fd);
 
   struct stat st;
-  ASSERT_THAT(stat(TemporaryFilePath(), &st), Eq(0));
+  ASSERT_THAT(stat(GetTemporaryFilePath(), &st), Eq(0));
 
   // Mask st_mode to get permission bits only
   ASSERT_THAT(st.st_mode & 0777, Eq(mode));
-
-  std::remove(TemporaryFilePath());
 }
 
-TEST(TestRadsanInterceptors, CreatDiesWhenRealtime) {
-  auto Func = []() { creat(TemporaryFilePath(), S_IWOTH | S_IROTH); };
-  ExpectRealtimeDeath(Func, "creat");
-  ExpectNonRealtimeSurvival(Func);
-  std::remove(TemporaryFilePath());
+TEST_F(RadsanFileTest, CreatDiesWhenRealtime) {
+  auto func = [this]() { creat(GetTemporaryFilePath(), S_IWOTH | S_IROTH); };
+  ExpectRealtimeDeath(func, "creat");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, FcntlDiesWhenRealtime) {
-  auto Func = []() { fcntl(0, F_GETFL); };
-  ExpectRealtimeDeath(Func, "fcntl");
-  ExpectNonRealtimeSurvival(Func);
+  auto func = []() { fcntl(0, F_GETFL); };
+  ExpectRealtimeDeath(func, "fcntl");
+  ExpectNonRealtimeSurvival(func);
 }
 
-TEST(TestRadsanInterceptors, FcntlFlockDiesWhenRealtime) {
-  int fd = creat(TemporaryFilePath(), S_IRUSR | S_IWUSR);
+TEST_F(RadsanFileTest, FcntlFlockDiesWhenRealtime) {
+  int fd = creat(GetTemporaryFilePath(), S_IRUSR | S_IWUSR);
   ASSERT_THAT(fd, Ne(-1));
 
   auto func = [fd]() {
@@ -230,17 +228,10 @@ TEST(TestRadsanInterceptors, FcntlFlockDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(func);
 
   close(fd);
-  std::remove(TemporaryFilePath());
-}
-
-TEST(TestRadsanInterceptors, CloseDiesWhenRealtime) {
-  auto Func = []() { close(0); };
-  ExpectRealtimeDeath(Func, "close");
-  ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, fcntlSetFdDiesWhenRealtime) {
-  int fd = creat(TemporaryFilePath(), S_IRUSR | S_IWUSR);
+TEST_F(RadsanFileTest, FcntlSetFdDiesWhenRealtime) {
+  int fd = creat(GetTemporaryFilePath(), S_IRUSR | S_IWUSR);
   ASSERT_THAT(fd, Ne(-1));
 
   auto func = [fd]() {
@@ -261,63 +252,64 @@ TEST(TestRadsanInterceptors, fcntlSetFdDiesWhenRealtime) {
   close(fd);
 }
 
-TEST(TestRadsanInterceptors, FopenDiesWhenRealtime) {
-  auto Func = []() {
-    FILE *fd = fopen(TemporaryFilePath(), "w");
+TEST(TestRadsanInterceptors, CloseDiesWhenRealtime) {
+  auto func = []() { close(0); };
+  ExpectRealtimeDeath(func, "close");
+  ExpectNonRealtimeSurvival(func);
+}
+
+TEST_F(RadsanFileTest, FopenDiesWhenRealtime) {
+  auto func = [this]() {
+    auto fd = fopen(GetTemporaryFilePath(), "w");
     EXPECT_THAT(fd, Ne(nullptr));
   };
-  ExpectRealtimeDeath(Func, "fopen");
-  ExpectNonRealtimeSurvival(Func);
-  std::remove(TemporaryFilePath());
+  ExpectRealtimeDeath(func, "fopen");
+  ExpectNonRealtimeSurvival(func);
 }
 
-TEST(TestRadsanInterceptors, FreadDiesWhenRealtime) {
-  FILE *fd = fopen(TemporaryFilePath(), "w");
-  auto Func = [fd]() {
+TEST_F(RadsanFileTest, FreadDiesWhenRealtime) {
+  auto fd = fopen(GetTemporaryFilePath(), "w");
+  auto func = [fd]() {
     char c{};
     fread(&c, 1, 1, fd);
   };
-  ExpectRealtimeDeath(Func, "fread");
-  ExpectNonRealtimeSurvival(Func);
+  ExpectRealtimeDeath(func, "fread");
+  ExpectNonRealtimeSurvival(func);
   if (fd != nullptr)
     fclose(fd);
-  std::remove(TemporaryFilePath());
 }
 
-TEST(TestRadsanInterceptors, FwriteDiesWhenRealtime) {
-  FILE *fd = fopen(TemporaryFilePath(), "w");
+TEST_F(RadsanFileTest, FwriteDiesWhenRealtime) {
+  auto fd = fopen(GetTemporaryFilePath(), "w");
   ASSERT_NE(nullptr, fd);
-  const char *message = "Hello, world!";
-  auto Func = [&]() { fwrite(&message, 1, 4, fd); };
-  ExpectRealtimeDeath(Func, "fwrite");
-  ExpectNonRealtimeSurvival(Func);
-  std::remove(TemporaryFilePath());
+  auto message = "Hello, world!";
+  auto func = [&]() { fwrite(&message, 1, 4, fd); };
+  ExpectRealtimeDeath(func, "fwrite");
+  ExpectNonRealtimeSurvival(func);
 }
 
-TEST(TestRadsanInterceptors, FcloseDiesWhenRealtime) {
-  FILE *fd = fopen(TemporaryFilePath(), "w");
+TEST_F(RadsanFileTest, FcloseDiesWhenRealtime) {
+  auto fd = fopen(GetTemporaryFilePath(), "w");
   EXPECT_THAT(fd, Ne(nullptr));
-  auto Func = [fd]() { fclose(fd); };
-  ExpectRealtimeDeath(Func, "fclose");
-  ExpectNonRealtimeSurvival(Func);
-  std::remove(TemporaryFilePath());
+  auto func = [fd]() { fclose(fd); };
+  ExpectRealtimeDeath(func, "fclose");
+  ExpectNonRealtimeSurvival(func);
 }
 
 TEST(TestRadsanInterceptors, PutsDiesWhenRealtime) {
-  auto Func = []() { puts("Hello, world!\n"); };
-  ExpectRealtimeDeath(Func);
-  ExpectNonRealtimeSurvival(Func);
+  auto func = []() { puts("Hello, world!\n"); };
+  ExpectRealtimeDeath(func);
+  ExpectNonRealtimeSurvival(func);
 }
 
-TEST(TestRadsanInterceptors, FputsDiesWhenRealtime) {
-  FILE *fd = fopen(TemporaryFilePath(), "w");
+TEST_F(RadsanFileTest, FputsDiesWhenRealtime) {
+  auto fd = fopen(GetTemporaryFilePath(), "w");
   ASSERT_THAT(fd, Ne(nullptr)) << errno;
-  auto Func = [fd]() { fputs("Hello, world!\n", fd); };
-  ExpectRealtimeDeath(Func);
-  ExpectNonRealtimeSurvival(Func);
+  auto func = [fd]() { fputs("Hello, world!\n", fd); };
+  ExpectRealtimeDeath(func);
+  ExpectNonRealtimeSurvival(func);
   if (fd != nullptr)
     fclose(fd);
-  std::remove(TemporaryFilePath());
 }
 
 /*

>From dbb03112a299c677e5b375b48299181e4f8004f7 Mon Sep 17 00:00:00 2001
From: David Trevelyan <david.trevelyan at gmail.com>
Date: Sat, 1 Jun 2024 17:20:20 +0100
Subject: [PATCH 35/44] Clean out temp files in test fixture SetUp too

---
 .../lib/radsan/tests/radsan_test_interceptors.cpp  | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
index 8b7650323346b..9874f0e4c3e6b 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
@@ -46,18 +46,20 @@ class RadsanFileTest : public ::testing::Test {
   void SetUp() override {
     const ::testing::TestInfo *const test_info =
         ::testing::UnitTest::GetInstance()->current_test_info();
-    file_path = std::string("/tmp/radsan_temporary_test_file_") +
-                test_info->name() + ".txt";
+    file_path_ = std::string("/tmp/radsan_temporary_test_file_") +
+                 test_info->name() + ".txt";
+    RemoveTemporaryFile();
   }
 
-  // Gets a file path with the test's name in in
+  // Gets a file path with the test's name in it
   // This file will be removed if it exists at the end of the test
-  const char *GetTemporaryFilePath() const { return file_path.c_str(); }
+  const char *GetTemporaryFilePath() const { return file_path_.c_str(); }
 
-  void TearDown() override { std::remove(GetTemporaryFilePath()); }
+  void TearDown() override { RemoveTemporaryFile(); }
 
 private:
-  std::string file_path;
+  void RemoveTemporaryFile() const { std::remove(GetTemporaryFilePath()); }
+  std::string file_path_;
 };
 
 /*

>From 852a55e61d827a075010455e7e1cc30c030fb130 Mon Sep 17 00:00:00 2001
From: David Trevelyan <david.trevelyan at gmail.com>
Date: Mon, 3 Jun 2024 21:57:36 +0100
Subject: [PATCH 36/44] Rename RADSan to RTSan

---
 clang/include/clang/Driver/SanitizerArgs.h    |   2 +-
 clang/lib/Driver/ToolChains/CommonArgs.cpp    |   4 +-
 clang/lib/Driver/ToolChains/Darwin.cpp        |   6 +-
 clang/runtime/CMakeLists.txt                  |   2 +-
 compiler-rt/CODE_OWNERS.TXT                   |   2 +-
 .../cmake/Modules/AllSupportedArchDefs.cmake  |   2 +-
 compiler-rt/cmake/config-ix.cmake             |  14 +--
 compiler-rt/lib/radsan/CMakeLists.txt         |  92 --------------
 compiler-rt/lib/radsan/radsan.cpp             |  37 ------
 compiler-rt/lib/radsan/tests/CMakeLists.txt   | 103 ----------------
 compiler-rt/lib/rtsan/CMakeLists.txt          |  92 ++++++++++++++
 compiler-rt/lib/rtsan/rtsan.cpp               |  37 ++++++
 .../lib/{radsan/radsan.h => rtsan/rtsan.h}    |  26 ++--
 .../rtsan_context.cpp}                        |  30 ++---
 .../rtsan_context.h}                          |   6 +-
 .../rtsan_interceptors.cpp}                   | 115 +++++++++---------
 .../rtsan_interceptors.h}                     |   7 +-
 .../rtsan_preinit.cpp}                        |   8 +-
 .../rtsan_stack.cpp}                          |  10 +-
 .../radsan_stack.h => rtsan/rtsan_stack.h}    |   6 +-
 compiler-rt/lib/rtsan/tests/CMakeLists.txt    | 103 ++++++++++++++++
 .../tests/rtsan_test_context.cpp}             |  33 +++--
 .../tests/rtsan_test_functional.cpp}          |  58 ++++-----
 .../tests/rtsan_test_interceptors.cpp}        | 107 ++++++++--------
 .../tests/rtsan_test_main.cpp}                |   2 +-
 .../tests/rtsan_test_utilities.h}             |  13 +-
 compiler-rt/test/radsan/CMakeLists.txt        |  58 ---------
 compiler-rt/test/rtsan/CMakeLists.txt         |  58 +++++++++
 .../{radsan => rtsan}/Unit/lit.site.cfg.py.in |  12 +-
 compiler-rt/test/{radsan => rtsan}/lit.cfg.py |  26 ++--
 .../test/{radsan => rtsan}/lit.site.cfg.py.in |   8 +-
 31 files changed, 537 insertions(+), 542 deletions(-)
 delete mode 100644 compiler-rt/lib/radsan/CMakeLists.txt
 delete mode 100644 compiler-rt/lib/radsan/radsan.cpp
 delete mode 100644 compiler-rt/lib/radsan/tests/CMakeLists.txt
 create mode 100644 compiler-rt/lib/rtsan/CMakeLists.txt
 create mode 100644 compiler-rt/lib/rtsan/rtsan.cpp
 rename compiler-rt/lib/{radsan/radsan.h => rtsan/rtsan.h} (53%)
 rename compiler-rt/lib/{radsan/radsan_context.cpp => rtsan/rtsan_context.cpp} (75%)
 rename compiler-rt/lib/{radsan/radsan_context.h => rtsan/rtsan_context.h} (86%)
 rename compiler-rt/lib/{radsan/radsan_interceptors.cpp => rtsan/rtsan_interceptors.cpp} (79%)
 rename compiler-rt/lib/{radsan/radsan_interceptors.h => rtsan/rtsan_interceptors.h} (76%)
 rename compiler-rt/lib/{radsan/radsan_preinit.cpp => rtsan/rtsan_preinit.cpp} (71%)
 rename compiler-rt/lib/{radsan/radsan_stack.cpp => rtsan/rtsan_stack.cpp} (85%)
 rename compiler-rt/lib/{radsan/radsan_stack.h => rtsan/rtsan_stack.h} (76%)
 create mode 100644 compiler-rt/lib/rtsan/tests/CMakeLists.txt
 rename compiler-rt/lib/{radsan/tests/radsan_test_context.cpp => rtsan/tests/rtsan_test_context.cpp} (64%)
 rename compiler-rt/lib/{radsan/tests/radsan_test_functional.cpp => rtsan/tests/rtsan_test_functional.cpp} (76%)
 rename compiler-rt/lib/{radsan/tests/radsan_test_interceptors.cpp => rtsan/tests/rtsan_test_interceptors.cpp} (78%)
 rename compiler-rt/lib/{radsan/tests/radsan_test_main.cpp => rtsan/tests/rtsan_test_main.cpp} (90%)
 rename compiler-rt/lib/{radsan/tests/radsan_test_utilities.h => rtsan/tests/rtsan_test_utilities.h} (85%)
 delete mode 100644 compiler-rt/test/radsan/CMakeLists.txt
 create mode 100644 compiler-rt/test/rtsan/CMakeLists.txt
 rename compiler-rt/test/{radsan => rtsan}/Unit/lit.site.cfg.py.in (65%)
 rename compiler-rt/test/{radsan => rtsan}/lit.cfg.py (64%)
 rename compiler-rt/test/{radsan => rtsan}/lit.site.cfg.py.in (69%)

diff --git a/clang/include/clang/Driver/SanitizerArgs.h b/clang/include/clang/Driver/SanitizerArgs.h
index f059c8715e26d..6c0df926aec5b 100644
--- a/clang/include/clang/Driver/SanitizerArgs.h
+++ b/clang/include/clang/Driver/SanitizerArgs.h
@@ -79,7 +79,7 @@ class SanitizerArgs {
   bool needsStableAbi() const { return StableABI; }
 
   bool needsMemProfRt() const { return NeedsMemProfRt; }
-  bool needsRadsanRt() const { return Sanitizers.has(SanitizerKind::Realtime); }
+  bool needsRtsanRt() const { return Sanitizers.has(SanitizerKind::Realtime); }
   bool needsAsanRt() const { return Sanitizers.has(SanitizerKind::Address); }
   bool needsHwasanRt() const {
     return Sanitizers.has(SanitizerKind::HWAddress);
diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp
index 5a92faa8a2898..7c6c4b2a056a4 100644
--- a/clang/lib/Driver/ToolChains/CommonArgs.cpp
+++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp
@@ -1443,8 +1443,8 @@ collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
       StaticRuntimes.push_back("asan_cxx");
   }
 
-  if (!SanArgs.needsSharedRt() && SanArgs.needsRadsanRt())
-    StaticRuntimes.push_back("radsan");
+  if (!SanArgs.needsSharedRt() && SanArgs.needsRtsanRt())
+    StaticRuntimes.push_back("rtsan");
 
   if (!SanArgs.needsSharedRt() && SanArgs.needsMemProfRt()) {
     StaticRuntimes.push_back("memprof");
diff --git a/clang/lib/Driver/ToolChains/Darwin.cpp b/clang/lib/Driver/ToolChains/Darwin.cpp
index b3e9d14021cda..0c1c13edfdd45 100644
--- a/clang/lib/Driver/ToolChains/Darwin.cpp
+++ b/clang/lib/Driver/ToolChains/Darwin.cpp
@@ -1496,7 +1496,7 @@ void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
     const char *sanitizer = nullptr;
     if (Sanitize.needsUbsanRt()) {
       sanitizer = "UndefinedBehaviorSanitizer";
-    } else if (Sanitize.needsRadsanRt()) {
+    } else if (Sanitize.needsRtsanRt()) {
       sanitizer = "RealtimeSanitizer";
     } else if (Sanitize.needsAsanRt()) {
       sanitizer = "AddressSanitizer";
@@ -1520,10 +1520,10 @@ void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
         AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
       }
     }
-    if (Sanitize.needsRadsanRt()) {
+    if (Sanitize.needsRtsanRt()) {
       assert(Sanitize.needsSharedRt() &&
              "Static sanitizer runtimes not supported");
-      AddLinkSanitizerLibArgs(Args, CmdArgs, "radsan");
+      AddLinkSanitizerLibArgs(Args, CmdArgs, "rtsan");
     }
     if (Sanitize.needsLsanRt())
       AddLinkSanitizerLibArgs(Args, CmdArgs, "lsan");
diff --git a/clang/runtime/CMakeLists.txt b/clang/runtime/CMakeLists.txt
index c56bff11d476b..109de3d737548 100644
--- a/clang/runtime/CMakeLists.txt
+++ b/clang/runtime/CMakeLists.txt
@@ -150,7 +150,7 @@ if(LLVM_BUILD_EXTERNAL_COMPILER_RT AND EXISTS ${COMPILER_RT_SRC_ROOT}/)
         check-lsan
         check-msan
         check-profile
-        check-radsan
+        check-rtsan
         check-safestack
         check-sanitizer
         check-tsan
diff --git a/compiler-rt/CODE_OWNERS.TXT b/compiler-rt/CODE_OWNERS.TXT
index 2db0357fc1a7f..570ab86508060 100644
--- a/compiler-rt/CODE_OWNERS.TXT
+++ b/compiler-rt/CODE_OWNERS.TXT
@@ -70,4 +70,4 @@ D: Profile runtime library
 
 N: Christopher Apple, David Trevelyan
 E: cja-private at pm.me, realtime.sanitizer at gmail.com
-D: Realtime Sanitizer (RADSan)
+D: Realtime Sanitizer (RTSan)
diff --git a/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake b/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake
index 56a3a2590b999..bc152e304aaaf 100644
--- a/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake
+++ b/compiler-rt/cmake/Modules/AllSupportedArchDefs.cmake
@@ -32,7 +32,7 @@ set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
     ${LOONGARCH64})
 set(ALL_ASAN_ABI_SUPPORTED_ARCH ${X86_64} ${ARM64} ${ARM64_32})
 set(ALL_DFSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${LOONGARCH64})
-set(ALL_RADSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
+set(ALL_RTSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X} ${SPARC} ${SPARCV9} ${HEXAGON}
     ${LOONGARCH64})
 
diff --git a/compiler-rt/cmake/config-ix.cmake b/compiler-rt/cmake/config-ix.cmake
index ceddf7fbdea94..9c8eb92d1d084 100644
--- a/compiler-rt/cmake/config-ix.cmake
+++ b/compiler-rt/cmake/config-ix.cmake
@@ -597,8 +597,8 @@ if(APPLE)
   list_intersect(ASAN_SUPPORTED_ARCH
     ALL_ASAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
-  list_intersect(RADSAN_SUPPORTED_ARCH
-    ALL_RADSAN_SUPPORTED_ARCH
+  list_intersect(RTSAN_SUPPORTED_ARCH
+    ALL_RTSAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(DFSAN_SUPPORTED_ARCH
     ALL_DFSAN_SUPPORTED_ARCH
@@ -666,7 +666,7 @@ else()
   filter_available_targets(UBSAN_COMMON_SUPPORTED_ARCH
     ${SANITIZER_COMMON_SUPPORTED_ARCH})
   filter_available_targets(ASAN_SUPPORTED_ARCH ${ALL_ASAN_SUPPORTED_ARCH})
-  filter_available_targets(RADSAN_SUPPORTED_ARCH ${ALL_RADSAN_SUPPORTED_ARCH})
+  filter_available_targets(RTSAN_SUPPORTED_ARCH ${ALL_RTSAN_SUPPORTED_ARCH})
   filter_available_targets(FUZZER_SUPPORTED_ARCH ${ALL_FUZZER_SUPPORTED_ARCH})
   filter_available_targets(DFSAN_SUPPORTED_ARCH ${ALL_DFSAN_SUPPORTED_ARCH})
   filter_available_targets(LSAN_SUPPORTED_ARCH ${ALL_LSAN_SUPPORTED_ARCH})
@@ -720,7 +720,7 @@ if(COMPILER_RT_SUPPORTED_ARCH)
 endif()
 message(STATUS "Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}")
 
-set(ALL_SANITIZERS asan;radsan;dfsan;msan;hwasan;tsan;safestack;cfi;scudo_standalone;ubsan_minimal;gwp_asan;nsan;asan_abi)
+set(ALL_SANITIZERS asan;rtsan;dfsan;msan;hwasan;tsan;safestack;cfi;scudo_standalone;ubsan_minimal;gwp_asan;nsan;asan_abi)
 set(COMPILER_RT_SANITIZERS_TO_BUILD all CACHE STRING
     "sanitizers to build if supported on the target (all;${ALL_SANITIZERS})")
 list_replace(COMPILER_RT_SANITIZERS_TO_BUILD all "${ALL_SANITIZERS}")
@@ -751,10 +751,10 @@ else()
   set(COMPILER_RT_HAS_ASAN FALSE)
 endif()
 
-if (COMPILER_RT_HAS_SANITIZER_COMMON AND RADSAN_SUPPORTED_ARCH)
-  set(COMPILER_RT_HAS_RADSAN TRUE)
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND RTSAN_SUPPORTED_ARCH)
+  set(COMPILER_RT_HAS_RTSAN TRUE)
 else()
-  set(COMPILER_RT_HAS_RADSAN FALSE)
+  set(COMPILER_RT_HAS_RTSAN FALSE)
 endif()
 
 if (OS_NAME MATCHES "Linux|FreeBSD|Windows|NetBSD|SunOS")
diff --git a/compiler-rt/lib/radsan/CMakeLists.txt b/compiler-rt/lib/radsan/CMakeLists.txt
deleted file mode 100644
index c7d1dacf3dbc7..0000000000000
--- a/compiler-rt/lib/radsan/CMakeLists.txt
+++ /dev/null
@@ -1,92 +0,0 @@
-include_directories(..)
-
-set(RADSAN_CXX_SOURCES
-  radsan.cpp
-  radsan_context.cpp
-  radsan_stack.cpp
-  radsan_interceptors.cpp)
-
-set(RADSAN_PREINIT_SOURCES
-  radsan_preinit.cpp)
-
-set(RADSAN_HEADERS
-  radsan.h
-  radsan_context.h
-  radsan_stack.h)
-
-set(RADSAN_DEPS)
-
-set(RADSAN_CFLAGS
-  ${COMPILER_RT_COMMON_CFLAGS}
-  ${COMPILER_RT_CXX_CFLAGS}
-  -DSANITIZER_COMMON_NO_REDEFINE_BUILTINS)
-set(RADSAN_LINK_FLAGS ${COMPILER_RT_COMMON_LINK_FLAGS})
-set(RADSAN_LINK_LIBS
-  ${COMPILER_RT_UNWINDER_LINK_LIBS}
-  ${COMPILER_RT_CXX_LINK_LIBS})
-
-if(APPLE)
-  add_compiler_rt_object_libraries(RTRadsan
-    OS ${SANITIZER_COMMON_SUPPORTED_OS}
-    ARCHS ${RADSAN_SUPPORTED_ARCH}
-    SOURCES ${RADSAN_CXX_SOURCES}
-    ADDITIONAL_HEADERS ${RADSAN_HEADERS}
-    CFLAGS ${RADSAN_CFLAGS}
-    DEPS ${RADSAN_DEPS})
-else()
-  add_compiler_rt_object_libraries(RTRadsan
-    ARCHS ${RADSAN_SUPPORTED_ARCH}
-    SOURCES ${RADSAN_CXX_SOURCES}
-    ADDITIONAL_HEADERS ${RADSAN_HEADERS}
-    CFLAGS ${RADSAN_CFLAGS}
-    DEPS ${RADSAN_DEPS})
-  add_compiler_rt_object_libraries(RTRadsan_preinit
-    ARCHS ${RADSAN_SUPPORTED_ARCH}
-    SOURCES ${RADSAN_PREINIT_SOURCES}
-    ADDITIONAL_HEADERS ${RADSAN_HEADERS}
-    CFLAGS ${RADSAN_CFLAGS})
-endif()
-
-set(RADSAN_COMMON_RUNTIME_OBJECT_LIBS
-  RTInterception
-  RTSanitizerCommon
-  RTSanitizerCommonLibc
-  RTSanitizerCommonCoverage
-  RTSanitizerCommonSymbolizer)
-
-append_list_if(COMPILER_RT_HAS_LIBDL dl RADSAN_LINK_LIBS)
-append_list_if(COMPILER_RT_HAS_LIBRT rt RADSAN_LINK_LIBS)
-append_list_if(COMPILER_RT_HAS_LIBM m RADSAN_LINK_LIBS)
-append_list_if(COMPILER_RT_HAS_LIBPTHREAD pthread RADSAN_LINK_LIBS)
-append_list_if(COMPILER_RT_HAS_LIBLOG log RADSAN_LINK_LIBS)
-
-add_compiler_rt_component(radsan)
-
-if (APPLE)
-  add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
-  set(RADSAN_LINK_FLAGS ${RADSAN_LINK_FLAGS} ${WEAK_SYMBOL_LINK_FLAGS})
-
-  add_compiler_rt_runtime(clang_rt.radsan
-    SHARED
-    OS ${SANITIZER_COMMON_SUPPORTED_OS}
-    ARCHS ${RADSAN_SUPPORTED_ARCH}
-    OBJECT_LIBS RTRadsan
-                ${RADSAN_COMMON_RUNTIME_OBJECT_LIBS}
-    LINK_FLAGS ${RADSAN_LINK_FLAGS}
-    LINK_LIBS ${RADSAN_LINK_LIBS}
-    PARENT_TARGET radsan)
-else()
-  add_compiler_rt_runtime(clang_rt.radsan
-    STATIC
-    ARCHS ${RADSAN_SUPPORTED_ARCH}
-    OBJECT_LIBS RTRadsan_preinit
-                RTRadsan
-                ${RADSAN_COMMON_RUNTIME_OBJECT_LIBS}
-    LINK_FLAGS ${RADSAN_LINK_FLAGS}
-    CFLAGS ${RADSAN_CFLAGS}
-    PARENT_TARGET radsan)
-endif()
-
-if(COMPILER_RT_INCLUDE_TESTS)
-  add_subdirectory(tests)
-endif()
diff --git a/compiler-rt/lib/radsan/radsan.cpp b/compiler-rt/lib/radsan/radsan.cpp
deleted file mode 100644
index 5fc7d1ab8beea..0000000000000
--- a/compiler-rt/lib/radsan/radsan.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//===--- radsan.cpp - Realtime Sanitizer --------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-//===----------------------------------------------------------------------===//
-
-#include <radsan/radsan.h>
-#include <radsan/radsan_context.h>
-#include <radsan/radsan_interceptors.h>
-
-extern "C" {
-
-SANITIZER_INTERFACE_ATTRIBUTE void __radsan_init() {
-  __radsan::InitializeInterceptors();
-}
-
-SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_enter() {
-  __radsan::GetContextForThisThread().RealtimePush();
-}
-
-SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_exit() {
-  __radsan::GetContextForThisThread().RealtimePop();
-}
-
-SANITIZER_INTERFACE_ATTRIBUTE void __radsan_off() {
-  __radsan::GetContextForThisThread().BypassPush();
-}
-
-SANITIZER_INTERFACE_ATTRIBUTE void __radsan_on() {
-  __radsan::GetContextForThisThread().BypassPop();
-}
-
-} // extern "C"
diff --git a/compiler-rt/lib/radsan/tests/CMakeLists.txt b/compiler-rt/lib/radsan/tests/CMakeLists.txt
deleted file mode 100644
index 79a3d2d3d6c23..0000000000000
--- a/compiler-rt/lib/radsan/tests/CMakeLists.txt
+++ /dev/null
@@ -1,103 +0,0 @@
-include(CompilerRTCompile)
-
-include_directories(..)
-
-set(RADSAN_UNITTEST_CFLAGS
-  ${COMPILER_RT_UNITTEST_CFLAGS}
-  ${COMPILER_RT_GTEST_CFLAGS}
-  ${COMPILER_RT_GMOCK_CFLAGS}
-  ${SANITIZER_TEST_CXX_CFLAGS}
-  -I${COMPILER_RT_SOURCE_DIR}/lib/
-  -I${COMPILER_RT_SOURCE_DIR}/include/
-  -I${COMPILER_RT_SOURCE_DIR}/lib/radsan
-  -I${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common/tests
-  -DSANITIZER_COMMON_NO_REDEFINE_BUILTINS
-  -O2)
-
-set(RADSAN_INST_TEST_SOURCES
-    radsan_test_functional.cpp
-    radsan_test_interceptors.cpp
-    radsan_test_main.cpp)
-
-set(RADSAN_NOINST_TEST_SOURCES
-    ../radsan_preinit.cpp
-    radsan_test_context.cpp
-    radsan_test_main.cpp)
-
-set(RADSAN_UNITTEST_HEADERS
-    radsan_test_utilities.h)
-
-add_custom_target(RadsanUnitTests)
-set_target_properties(RadsanUnitTests PROPERTIES FOLDER "Compiler-RT Tests")
-
-set(RADSAN_UNITTEST_LINK_FLAGS
-  ${COMPILER_RT_UNITTEST_LINK_FLAGS}
-  ${COMPILER_RT_UNWINDER_LINK_LIBS}
-  ${SANITIZER_TEST_CXX_LIBRARIES}
-  -no-pie)
-
-if (APPLE)
-  add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
-  list(APPEND RADSAN_UNITTEST_LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS})
-  list(APPEND RADSAN_UNITTEST_LINK_FLAGS ${DARWIN_osx_LINK_FLAGS})
-  list(APPEND RADSAN_UNITTEST_CFLAGS ${DARWIN_osx_CFLAGS})
-else()
-  list(APPEND RADSAN_UNITTEST_LINK_FLAGS -latomic)
-endif()
-
-set(COMPILER_RT_GOOGLETEST_SOURCES ${COMPILER_RT_GTEST_SOURCE} ${COMPILER_RT_GMOCK_SOURCE})
-
-set(RADSAN_TEST_ARCH ${RADSAN_SUPPORTED_ARCH})
-if(APPLE)
-  darwin_filter_host_archs(RADSAN_SUPPORTED_ARCH RADSAN_TEST_ARCH)
-endif()
-
-foreach(arch ${RADSAN_TEST_ARCH})
-  set(RadsanTestObjects)
-  generate_compiler_rt_tests(RadsanTestObjects
-    RadsanUnitTests "Radsan-${arch}-Test" ${arch}
-    COMPILE_DEPS ${RADSAN_UNITTEST_HEADERS}
-    SOURCES ${RADSAN_INST_TEST_SOURCES} ${COMPILER_RT_GOOGLETEST_SOURCES}
-    DEPS llvm_gtest radsan
-    CFLAGS ${RADSAN_UNITTEST_CFLAGS} -fsanitize=realtime
-    LINK_FLAGS ${RADSAN_UNITTEST_LINK_FLAGS} -fsanitize=realtime)
-  set_target_properties(RadsanUnitTests PROPERTIES
-    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-
-  set(RADSAN_TEST_RUNTIME RTRadsanTest.${arch})
-  if(APPLE)
-    set(RADSAN_TEST_RUNTIME_OBJECTS
-      $<TARGET_OBJECTS:RTRadsan.osx>
-      $<TARGET_OBJECTS:RTInterception.osx>
-      $<TARGET_OBJECTS:RTSanitizerCommon.osx>
-      $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
-      $<TARGET_OBJECTS:RTSanitizerCommonCoverage.osx>
-      $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.osx>)
-  else()
-    set(RADSAN_TEST_RUNTIME_OBJECTS
-      $<TARGET_OBJECTS:RTRadsan.${arch}>
-      $<TARGET_OBJECTS:RTInterception.${arch}>
-      $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
-      $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
-      $<TARGET_OBJECTS:RTSanitizerCommonCoverage.${arch}>
-      $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.${arch}>
-      $<TARGET_OBJECTS:RTSanitizerCommonSymbolizerInternal.${arch}>)
-  endif()
-  add_library(${RADSAN_TEST_RUNTIME} STATIC ${RADSAN_TEST_RUNTIME_OBJECTS})
-  set_target_properties(${RADSAN_TEST_RUNTIME} PROPERTIES
-      ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-      FOLDER "Compiler-RT Runtime tests")
-
-  set(RadsanNoInstTestObjects)
-  generate_compiler_rt_tests(RadsanNoInstTestObjects
-    RadsanUnitTests "Radsan-${arch}-NoInstTest" ${arch}
-    COMPILE_DEPS ${RADSAN_UNITTEST_HEADERS}
-    SOURCES ${RADSAN_NOINST_TEST_SOURCES}
-            ${COMPILER_RT_GOOGLETEST_SOURCES}
-    DEPS llvm_gtest
-    CFLAGS ${RADSAN_UNITTEST_CFLAGS}
-    LINK_FLAGS ${RADSAN_UNITTEST_LINK_FLAGS}
-    RUNTIME ${RADSAN_TEST_RUNTIME})
-  set_target_properties(RadsanUnitTests PROPERTIES
-    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
-endforeach()
diff --git a/compiler-rt/lib/rtsan/CMakeLists.txt b/compiler-rt/lib/rtsan/CMakeLists.txt
new file mode 100644
index 0000000000000..bd7358e86e59b
--- /dev/null
+++ b/compiler-rt/lib/rtsan/CMakeLists.txt
@@ -0,0 +1,92 @@
+include_directories(..)
+
+set(RTSAN_CXX_SOURCES
+  rtsan.cpp
+  rtsan_context.cpp
+  rtsan_stack.cpp
+  rtsan_interceptors.cpp)
+
+set(RTSAN_PREINIT_SOURCES
+  rtsan_preinit.cpp)
+
+set(RTSAN_HEADERS
+  rtsan.h
+  rtsan_context.h
+  rtsan_stack.h)
+
+set(RTSAN_DEPS)
+
+set(RTSAN_CFLAGS
+  ${COMPILER_RT_COMMON_CFLAGS}
+  ${COMPILER_RT_CXX_CFLAGS}
+  -DSANITIZER_COMMON_NO_REDEFINE_BUILTINS)
+set(RTSAN_LINK_FLAGS ${COMPILER_RT_COMMON_LINK_FLAGS})
+set(RTSAN_LINK_LIBS
+  ${COMPILER_RT_UNWINDER_LINK_LIBS}
+  ${COMPILER_RT_CXX_LINK_LIBS})
+
+if(APPLE)
+  add_compiler_rt_object_libraries(RTRtsan
+    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    ARCHS ${RTSAN_SUPPORTED_ARCH}
+    SOURCES ${RTSAN_CXX_SOURCES}
+    ADDITIONAL_HEADERS ${RTSAN_HEADERS}
+    CFLAGS ${RTSAN_CFLAGS}
+    DEPS ${RTSAN_DEPS})
+else()
+  add_compiler_rt_object_libraries(RTRtsan
+    ARCHS ${RTSAN_SUPPORTED_ARCH}
+    SOURCES ${RTSAN_CXX_SOURCES}
+    ADDITIONAL_HEADERS ${RTSAN_HEADERS}
+    CFLAGS ${RTSAN_CFLAGS}
+    DEPS ${RTSAN_DEPS})
+  add_compiler_rt_object_libraries(RTRtsan_preinit
+    ARCHS ${RTSAN_SUPPORTED_ARCH}
+    SOURCES ${RTSAN_PREINIT_SOURCES}
+    ADDITIONAL_HEADERS ${RTSAN_HEADERS}
+    CFLAGS ${RTSAN_CFLAGS})
+endif()
+
+set(RTSAN_COMMON_RUNTIME_OBJECT_LIBS
+  RTInterception
+  RTSanitizerCommon
+  RTSanitizerCommonLibc
+  RTSanitizerCommonCoverage
+  RTSanitizerCommonSymbolizer)
+
+append_list_if(COMPILER_RT_HAS_LIBDL dl RTSAN_LINK_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBRT rt RTSAN_LINK_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBM m RTSAN_LINK_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBPTHREAD pthread RTSAN_LINK_LIBS)
+append_list_if(COMPILER_RT_HAS_LIBLOG log RTSAN_LINK_LIBS)
+
+add_compiler_rt_component(rtsan)
+
+if (APPLE)
+  add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
+  set(RTSAN_LINK_FLAGS ${RTSAN_LINK_FLAGS} ${WEAK_SYMBOL_LINK_FLAGS})
+
+  add_compiler_rt_runtime(clang_rt.rtsan
+    SHARED
+    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    ARCHS ${RTSAN_SUPPORTED_ARCH}
+    OBJECT_LIBS RTRtsan
+                ${RTSAN_COMMON_RUNTIME_OBJECT_LIBS}
+    LINK_FLAGS ${RTSAN_LINK_FLAGS}
+    LINK_LIBS ${RTSAN_LINK_LIBS}
+    PARENT_TARGET rtsan)
+else()
+  add_compiler_rt_runtime(clang_rt.rtsan
+    STATIC
+    ARCHS ${RTSAN_SUPPORTED_ARCH}
+    OBJECT_LIBS RTRtsan_preinit
+                RTRtsan
+                ${RTSAN_COMMON_RUNTIME_OBJECT_LIBS}
+    LINK_FLAGS ${RTSAN_LINK_FLAGS}
+    CFLAGS ${RTSAN_CFLAGS}
+    PARENT_TARGET rtsan)
+endif()
+
+if(COMPILER_RT_INCLUDE_TESTS)
+  add_subdirectory(tests)
+endif()
diff --git a/compiler-rt/lib/rtsan/rtsan.cpp b/compiler-rt/lib/rtsan/rtsan.cpp
new file mode 100644
index 0000000000000..43a63b4636f1e
--- /dev/null
+++ b/compiler-rt/lib/rtsan/rtsan.cpp
@@ -0,0 +1,37 @@
+//===--- rtsan.cpp - Realtime Sanitizer -------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+//===----------------------------------------------------------------------===//
+
+#include <rtsan/rtsan.h>
+#include <rtsan/rtsan_context.h>
+#include <rtsan/rtsan_interceptors.h>
+
+extern "C" {
+
+SANITIZER_INTERFACE_ATTRIBUTE void __rtsan_init() {
+  __rtsan::InitializeInterceptors();
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE void __rtsan_realtime_enter() {
+  __rtsan::GetContextForThisThread().RealtimePush();
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE void __rtsan_realtime_exit() {
+  __rtsan::GetContextForThisThread().RealtimePop();
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE void __rtsan_off() {
+  __rtsan::GetContextForThisThread().BypassPush();
+}
+
+SANITIZER_INTERFACE_ATTRIBUTE void __rtsan_on() {
+  __rtsan::GetContextForThisThread().BypassPop();
+}
+
+} // extern "C"
diff --git a/compiler-rt/lib/radsan/radsan.h b/compiler-rt/lib/rtsan/rtsan.h
similarity index 53%
rename from compiler-rt/lib/radsan/radsan.h
rename to compiler-rt/lib/rtsan/rtsan.h
index e4a897e831d76..8b1219c13cbd3 100644
--- a/compiler-rt/lib/radsan/radsan.h
+++ b/compiler-rt/lib/rtsan/rtsan.h
@@ -1,4 +1,4 @@
-//===--- radsan.h - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- rtsan.h - Realtime Sanitizer ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -14,27 +14,27 @@
 
 extern "C" {
 
-// Initialise radsan interceptors.
+// Initialise rtsan interceptors.
 // A call to this method is added to the preinit array on Linux systems.
-SANITIZER_INTERFACE_ATTRIBUTE void __radsan_init();
+SANITIZER_INTERFACE_ATTRIBUTE void __rtsan_init();
 
 // Enter real-time context.
-// When in a real-time context, RADSan interceptors will error if realtime
+// When in a real-time context, RTSan interceptors will error if realtime
 // violations are detected. Calls to this method are injected at the code
-// generation stage when RADSan is enabled.
-SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_enter();
+// generation stage when RTSan is enabled.
+SANITIZER_INTERFACE_ATTRIBUTE void __rtsan_realtime_enter();
 
 // Exit the real-time context.
-// When not in a real-time context, RADSan interceptors will simply forward
+// When not in a real-time context, RTSan interceptors will simply forward
 // intercepted method calls to the real methods.
-SANITIZER_INTERFACE_ATTRIBUTE void __radsan_realtime_exit();
+SANITIZER_INTERFACE_ATTRIBUTE void __rtsan_realtime_exit();
 
-// Disable all RADSan error reporting.
+// Disable all RTSan error reporting.
 // Injected into the code if "nosanitize(realtime)" is on a function.
-SANITIZER_INTERFACE_ATTRIBUTE void __radsan_off();
+SANITIZER_INTERFACE_ATTRIBUTE void __rtsan_off();
 
-// Re-enable all RADSan error reporting.
-// The counterpart to `__radsan_off`.
-SANITIZER_INTERFACE_ATTRIBUTE void __radsan_on();
+// Re-enable all RTSan error reporting.
+// The counterpart to `__rtsan_off`.
+SANITIZER_INTERFACE_ATTRIBUTE void __rtsan_on();
 
 } // extern "C"
diff --git a/compiler-rt/lib/radsan/radsan_context.cpp b/compiler-rt/lib/rtsan/rtsan_context.cpp
similarity index 75%
rename from compiler-rt/lib/radsan/radsan_context.cpp
rename to compiler-rt/lib/rtsan/rtsan_context.cpp
index 2d43061c15bfe..9eba3fb0ec25a 100644
--- a/compiler-rt/lib/radsan/radsan_context.cpp
+++ b/compiler-rt/lib/rtsan/rtsan_context.cpp
@@ -1,4 +1,4 @@
-//===--- radsan_context.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- rtsan_context.cpp - Realtime Sanitizer -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,9 +8,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <radsan/radsan_context.h>
+#include <rtsan/rtsan_context.h>
 
-#include <radsan/radsan_stack.h>
+#include <rtsan/rtsan_stack.h>
 
 #include <sanitizer_common/sanitizer_allocator_internal.h>
 #include <sanitizer_common/sanitizer_stacktrace.h>
@@ -25,18 +25,18 @@ static pthread_once_t key_once = PTHREAD_ONCE_INIT;
 
 static void internalFree(void *ptr) { __sanitizer::InternalFree(ptr); }
 
-static __radsan::Context &GetContextForThisThreadImpl() {
+static __rtsan::Context &GetContextForThisThreadImpl() {
   auto make_thread_local_context_key = []() {
     CHECK_EQ(pthread_key_create(&context_key, internalFree), 0);
   };
 
   pthread_once(&key_once, make_thread_local_context_key);
-  __radsan::Context *current_thread_context =
-      static_cast<__radsan::Context *>(pthread_getspecific(context_key));
+  __rtsan::Context *current_thread_context =
+      static_cast<__rtsan::Context *>(pthread_getspecific(context_key));
   if (current_thread_context == nullptr) {
-    current_thread_context = static_cast<__radsan::Context *>(
-        __sanitizer::InternalAlloc(sizeof(__radsan::Context)));
-    new (current_thread_context) __radsan::Context();
+    current_thread_context = static_cast<__rtsan::Context *>(
+        __sanitizer::InternalAlloc(sizeof(__rtsan::Context)));
+    new (current_thread_context) __rtsan::Context();
     pthread_setspecific(context_key, current_thread_context);
   }
 
@@ -45,9 +45,9 @@ static __radsan::Context &GetContextForThisThreadImpl() {
 
 /*
     This is a placeholder stub for a future feature that will allow
-    a user to configure RADSan's behaviour when a real-time safety
-    violation is detected. The RADSan developers intend for the
-    following choices to be made available, via a RADSAN_OPTIONS
+    a user to configure RTSan's behaviour when a real-time safety
+    violation is detected. The RTSan developers intend for the
+    following choices to be made available, via a RTSAN_OPTIONS
     environment variable, in a future PR:
 
         i) exit,
@@ -59,7 +59,7 @@ static __radsan::Context &GetContextForThisThreadImpl() {
 */
 static void InvokeViolationDetectedAction() { exit(EXIT_FAILURE); }
 
-namespace __radsan {
+namespace __rtsan {
 
 Context::Context() = default;
 
@@ -89,9 +89,9 @@ void Context::PrintDiagnostics(const char *intercepted_function_name) {
           "Real-time violation: intercepted call to real-time unsafe function "
           "`%s` in real-time context! Stack trace:\n",
           intercepted_function_name);
-  __radsan::PrintStackTrace();
+  __rtsan::PrintStackTrace();
 }
 
 Context &GetContextForThisThread() { return GetContextForThisThreadImpl(); }
 
-} // namespace __radsan
+} // namespace __rtsan
diff --git a/compiler-rt/lib/radsan/radsan_context.h b/compiler-rt/lib/rtsan/rtsan_context.h
similarity index 86%
rename from compiler-rt/lib/radsan/radsan_context.h
rename to compiler-rt/lib/rtsan/rtsan_context.h
index 8fddae0291e45..515bb8ade1eb9 100644
--- a/compiler-rt/lib/radsan/radsan_context.h
+++ b/compiler-rt/lib/rtsan/rtsan_context.h
@@ -1,4 +1,4 @@
-//===--- radsan_context.h - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- rtsan_context.h - Realtime Sanitizer -------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -10,7 +10,7 @@
 
 #pragma once
 
-namespace __radsan {
+namespace __rtsan {
 
 class Context {
 public:
@@ -35,4 +35,4 @@ class Context {
 
 Context &GetContextForThisThread();
 
-} // namespace __radsan
+} // namespace __rtsan
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.cpp b/compiler-rt/lib/rtsan/rtsan_interceptors.cpp
similarity index 79%
rename from compiler-rt/lib/radsan/radsan_interceptors.cpp
rename to compiler-rt/lib/rtsan/rtsan_interceptors.cpp
index dfde4d5d175f8..adcad6c5de412 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.cpp
+++ b/compiler-rt/lib/rtsan/rtsan_interceptors.cpp
@@ -1,5 +1,4 @@
-//===--- radsan_interceptors.cpp - Realtime Sanitizer --------------*- C++
-//-*-===//
+//===--- rtsan_interceptors.cpp - Realtime Sanitizer ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,16 +8,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "radsan/radsan_interceptors.h"
+#include "rtsan/rtsan_interceptors.h"
 
 #include "sanitizer_common/sanitizer_platform.h"
 #include "sanitizer_common/sanitizer_platform_interceptors.h"
 
 #include "interception/interception.h"
-#include "radsan/radsan_context.h"
+#include "rtsan/rtsan_context.h"
 
 #if !SANITIZER_LINUX && !SANITIZER_APPLE
-#error Sorry, radsan does not yet support this platform
+#error Sorry, rtsan does not yet support this platform
 #endif
 
 #if SANITIZER_APPLE
@@ -40,18 +39,18 @@
 
 using namespace __sanitizer;
 
-namespace __radsan {
+namespace __rtsan {
 void ExpectNotRealtime(const char *intercepted_function_name) {
   GetContextForThisThread().ExpectNotRealtime(intercepted_function_name);
 }
-} // namespace __radsan
+} // namespace __rtsan
 
 // Filesystem
 
 INTERCEPTOR(int, open, const char *path, int oflag, ...) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
-  __radsan::ExpectNotRealtime("open");
+  __rtsan::ExpectNotRealtime("open");
 
   va_list args;
   va_start(args, oflag);
@@ -65,7 +64,7 @@ INTERCEPTOR(int, open, const char *path, int oflag, ...) {
 INTERCEPTOR(int, openat, int fd, const char *path, int oflag, ...) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
-  __radsan::ExpectNotRealtime("openat");
+  __rtsan::ExpectNotRealtime("openat");
 
   va_list args;
   va_start(args, oflag);
@@ -79,13 +78,13 @@ INTERCEPTOR(int, openat, int fd, const char *path, int oflag, ...) {
 INTERCEPTOR(int, creat, const char *path, mode_t mode) {
   // TODO Establish whether we should intercept here if the flag contains
   // O_NONBLOCK
-  __radsan::ExpectNotRealtime("creat");
+  __rtsan::ExpectNotRealtime("creat");
   const int result = REAL(creat)(path, mode);
   return result;
 }
 
 INTERCEPTOR(int, fcntl, int filedes, int cmd, ...) {
-  __radsan::ExpectNotRealtime("fcntl");
+  __rtsan::ExpectNotRealtime("fcntl");
 
   va_list args;
   va_start(args, cmd);
@@ -106,40 +105,40 @@ INTERCEPTOR(int, fcntl, int filedes, int cmd, ...) {
 }
 
 INTERCEPTOR(int, close, int filedes) {
-  __radsan::ExpectNotRealtime("close");
+  __rtsan::ExpectNotRealtime("close");
   return REAL(close)(filedes);
 }
 
 INTERCEPTOR(FILE *, fopen, const char *path, const char *mode) {
-  __radsan::ExpectNotRealtime("fopen");
+  __rtsan::ExpectNotRealtime("fopen");
   return REAL(fopen)(path, mode);
 }
 
 INTERCEPTOR(size_t, fread, void *ptr, size_t size, size_t nitems,
             FILE *stream) {
-  __radsan::ExpectNotRealtime("fread");
+  __rtsan::ExpectNotRealtime("fread");
   return REAL(fread)(ptr, size, nitems, stream);
 }
 
 INTERCEPTOR(size_t, fwrite, const void *ptr, size_t size, size_t nitems,
             FILE *stream) {
-  __radsan::ExpectNotRealtime("fwrite");
+  __rtsan::ExpectNotRealtime("fwrite");
   return REAL(fwrite)(ptr, size, nitems, stream);
 }
 
 INTERCEPTOR(int, fclose, FILE *stream) {
-  __radsan::ExpectNotRealtime("fclose");
+  __rtsan::ExpectNotRealtime("fclose");
   return REAL(fclose)(stream);
 }
 
 INTERCEPTOR(int, fputs, const char *s, FILE *stream) {
-  __radsan::ExpectNotRealtime("fputs");
+  __rtsan::ExpectNotRealtime("fputs");
   return REAL(fputs)(s, stream);
 }
 
 // Streams
 INTERCEPTOR(int, puts, const char *s) {
-  __radsan::ExpectNotRealtime("puts");
+  __rtsan::ExpectNotRealtime("puts");
   return REAL(puts)(s);
 }
 
@@ -149,207 +148,207 @@ INTERCEPTOR(int, puts, const char *s) {
 // OSSpinLockLock is deprecated, but still in use in libc++
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 INTERCEPTOR(void, OSSpinLockLock, volatile OSSpinLock *lock) {
-  __radsan::ExpectNotRealtime("OSSpinLockLock");
+  __rtsan::ExpectNotRealtime("OSSpinLockLock");
   return REAL(OSSpinLockLock)(lock);
 }
 #pragma clang diagnostic pop
 
 INTERCEPTOR(void, os_unfair_lock_lock, os_unfair_lock_t lock) {
-  __radsan::ExpectNotRealtime("os_unfair_lock_lock");
+  __rtsan::ExpectNotRealtime("os_unfair_lock_lock");
   return REAL(os_unfair_lock_lock)(lock);
 }
 #elif SANITIZER_LINUX
 INTERCEPTOR(int, pthread_spin_lock, pthread_spinlock_t *spinlock) {
-  __radsan::ExpectNotRealtime("pthread_spin_lock");
+  __rtsan::ExpectNotRealtime("pthread_spin_lock");
   return REAL(pthread_spin_lock)(spinlock);
 }
 #endif
 
 INTERCEPTOR(int, pthread_create, pthread_t *thread, const pthread_attr_t *attr,
             void *(*start_routine)(void *), void *arg) {
-  __radsan::ExpectNotRealtime("pthread_create");
+  __rtsan::ExpectNotRealtime("pthread_create");
   return REAL(pthread_create)(thread, attr, start_routine, arg);
 }
 
 INTERCEPTOR(int, pthread_mutex_lock, pthread_mutex_t *mutex) {
-  __radsan::ExpectNotRealtime("pthread_mutex_lock");
+  __rtsan::ExpectNotRealtime("pthread_mutex_lock");
   return REAL(pthread_mutex_lock)(mutex);
 }
 
 INTERCEPTOR(int, pthread_mutex_unlock, pthread_mutex_t *mutex) {
-  __radsan::ExpectNotRealtime("pthread_mutex_unlock");
+  __rtsan::ExpectNotRealtime("pthread_mutex_unlock");
   return REAL(pthread_mutex_unlock)(mutex);
 }
 
 INTERCEPTOR(int, pthread_join, pthread_t thread, void **value_ptr) {
-  __radsan::ExpectNotRealtime("pthread_join");
+  __rtsan::ExpectNotRealtime("pthread_join");
   return REAL(pthread_join)(thread, value_ptr);
 }
 
 INTERCEPTOR(int, pthread_cond_signal, pthread_cond_t *cond) {
-  __radsan::ExpectNotRealtime("pthread_cond_signal");
+  __rtsan::ExpectNotRealtime("pthread_cond_signal");
   return REAL(pthread_cond_signal)(cond);
 }
 
 INTERCEPTOR(int, pthread_cond_broadcast, pthread_cond_t *cond) {
-  __radsan::ExpectNotRealtime("pthread_cond_broadcast");
+  __rtsan::ExpectNotRealtime("pthread_cond_broadcast");
   return REAL(pthread_cond_broadcast)(cond);
 }
 
 INTERCEPTOR(int, pthread_cond_wait, pthread_cond_t *cond,
             pthread_mutex_t *mutex) {
-  __radsan::ExpectNotRealtime("pthread_cond_wait");
+  __rtsan::ExpectNotRealtime("pthread_cond_wait");
   return REAL(pthread_cond_wait)(cond, mutex);
 }
 
 INTERCEPTOR(int, pthread_cond_timedwait, pthread_cond_t *cond,
             pthread_mutex_t *mutex, const timespec *ts) {
-  __radsan::ExpectNotRealtime("pthread_cond_timedwait");
+  __rtsan::ExpectNotRealtime("pthread_cond_timedwait");
   return REAL(pthread_cond_timedwait)(cond, mutex, ts);
 }
 
 INTERCEPTOR(int, pthread_rwlock_rdlock, pthread_rwlock_t *lock) {
-  __radsan::ExpectNotRealtime("pthread_rwlock_rdlock");
+  __rtsan::ExpectNotRealtime("pthread_rwlock_rdlock");
   return REAL(pthread_rwlock_rdlock)(lock);
 }
 
 INTERCEPTOR(int, pthread_rwlock_unlock, pthread_rwlock_t *lock) {
-  __radsan::ExpectNotRealtime("pthread_rwlock_unlock");
+  __rtsan::ExpectNotRealtime("pthread_rwlock_unlock");
   return REAL(pthread_rwlock_unlock)(lock);
 }
 
 INTERCEPTOR(int, pthread_rwlock_wrlock, pthread_rwlock_t *lock) {
-  __radsan::ExpectNotRealtime("pthread_rwlock_wrlock");
+  __rtsan::ExpectNotRealtime("pthread_rwlock_wrlock");
   return REAL(pthread_rwlock_wrlock)(lock);
 }
 
 // Sleeping
 
 INTERCEPTOR(unsigned int, sleep, unsigned int s) {
-  __radsan::ExpectNotRealtime("sleep");
+  __rtsan::ExpectNotRealtime("sleep");
   return REAL(sleep)(s);
 }
 
 INTERCEPTOR(int, usleep, useconds_t u) {
-  __radsan::ExpectNotRealtime("usleep");
+  __rtsan::ExpectNotRealtime("usleep");
   return REAL(usleep)(u);
 }
 
 INTERCEPTOR(int, nanosleep, const struct timespec *rqtp,
             struct timespec *rmtp) {
-  __radsan::ExpectNotRealtime("nanosleep");
+  __rtsan::ExpectNotRealtime("nanosleep");
   return REAL(nanosleep)(rqtp, rmtp);
 }
 
 // Memory
 
 INTERCEPTOR(void *, calloc, SIZE_T num, SIZE_T size) {
-  __radsan::ExpectNotRealtime("calloc");
+  __rtsan::ExpectNotRealtime("calloc");
   return REAL(calloc)(num, size);
 }
 
 INTERCEPTOR(void, free, void *ptr) {
   if (ptr != NULL) {
-    __radsan::ExpectNotRealtime("free");
+    __rtsan::ExpectNotRealtime("free");
   }
   return REAL(free)(ptr);
 }
 
 INTERCEPTOR(void *, malloc, SIZE_T size) {
-  __radsan::ExpectNotRealtime("malloc");
+  __rtsan::ExpectNotRealtime("malloc");
   return REAL(malloc)(size);
 }
 
 INTERCEPTOR(void *, realloc, void *ptr, SIZE_T size) {
-  __radsan::ExpectNotRealtime("realloc");
+  __rtsan::ExpectNotRealtime("realloc");
   return REAL(realloc)(ptr, size);
 }
 
 INTERCEPTOR(void *, reallocf, void *ptr, SIZE_T size) {
-  __radsan::ExpectNotRealtime("reallocf");
+  __rtsan::ExpectNotRealtime("reallocf");
   return REAL(reallocf)(ptr, size);
 }
 
 INTERCEPTOR(void *, valloc, SIZE_T size) {
-  __radsan::ExpectNotRealtime("valloc");
+  __rtsan::ExpectNotRealtime("valloc");
   return REAL(valloc)(size);
 }
 
 #if SANITIZER_INTERCEPT_ALIGNED_ALLOC
 INTERCEPTOR(void *, aligned_alloc, SIZE_T alignment, SIZE_T size) {
-  __radsan::ExpectNotRealtime("aligned_alloc");
+  __rtsan::ExpectNotRealtime("aligned_alloc");
   return REAL(aligned_alloc)(alignment, size);
 }
-#define RADSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC INTERCEPT_FUNCTION(aligned_alloc)
+#define RTSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC INTERCEPT_FUNCTION(aligned_alloc)
 #else
-#define RADSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC
+#define RTSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC
 #endif
 
 INTERCEPTOR(int, posix_memalign, void **memptr, size_t alignment, size_t size) {
-  __radsan::ExpectNotRealtime("posix_memalign");
+  __rtsan::ExpectNotRealtime("posix_memalign");
   return REAL(posix_memalign)(memptr, alignment, size);
 }
 
 #if SANITIZER_INTERCEPT_MEMALIGN
 INTERCEPTOR(void *, memalign, size_t alignment, size_t size) {
-  __radsan::ExpectNotRealtime("memalign");
+  __rtsan::ExpectNotRealtime("memalign");
   return REAL(memalign)(alignment, size);
 }
 #endif
 
 #if SANITIZER_INTERCEPT_PVALLOC
 INTERCEPTOR(void *, pvalloc, size_t size) {
-  __radsan::ExpectNotRealtime("pvalloc");
+  __rtsan::ExpectNotRealtime("pvalloc");
   return REAL(pvalloc)(size);
 }
 #endif
 
 // Sockets
 INTERCEPTOR(int, socket, int domain, int type, int protocol) {
-  __radsan::ExpectNotRealtime("socket");
+  __rtsan::ExpectNotRealtime("socket");
   return REAL(socket)(domain, type, protocol);
 }
 
 INTERCEPTOR(ssize_t, send, int sockfd, const void *buf, size_t len, int flags) {
-  __radsan::ExpectNotRealtime("send");
+  __rtsan::ExpectNotRealtime("send");
   return REAL(send)(sockfd, buf, len, flags);
 }
 
 INTERCEPTOR(ssize_t, sendmsg, int socket, const struct msghdr *message,
             int flags) {
-  __radsan::ExpectNotRealtime("sendmsg");
+  __rtsan::ExpectNotRealtime("sendmsg");
   return REAL(sendmsg)(socket, message, flags);
 }
 
 INTERCEPTOR(ssize_t, sendto, int socket, const void *buffer, size_t length,
             int flags, const struct sockaddr *dest_addr, socklen_t dest_len) {
-  __radsan::ExpectNotRealtime("sendto");
+  __rtsan::ExpectNotRealtime("sendto");
   return REAL(sendto)(socket, buffer, length, flags, dest_addr, dest_len);
 }
 
 INTERCEPTOR(ssize_t, recv, int socket, void *buffer, size_t length, int flags) {
-  __radsan::ExpectNotRealtime("recv");
+  __rtsan::ExpectNotRealtime("recv");
   return REAL(recv)(socket, buffer, length, flags);
 }
 
 INTERCEPTOR(ssize_t, recvfrom, int socket, void *buffer, size_t length,
             int flags, struct sockaddr *address, socklen_t *address_len) {
-  __radsan::ExpectNotRealtime("recvfrom");
+  __rtsan::ExpectNotRealtime("recvfrom");
   return REAL(recvfrom)(socket, buffer, length, flags, address, address_len);
 }
 
 INTERCEPTOR(ssize_t, recvmsg, int socket, struct msghdr *message, int flags) {
-  __radsan::ExpectNotRealtime("recvmsg");
+  __rtsan::ExpectNotRealtime("recvmsg");
   return REAL(recvmsg)(socket, message, flags);
 }
 
 INTERCEPTOR(int, shutdown, int socket, int how) {
-  __radsan::ExpectNotRealtime("shutdown");
+  __rtsan::ExpectNotRealtime("shutdown");
   return REAL(shutdown)(socket, how);
 }
 
 // Preinit
-namespace __radsan {
+namespace __rtsan {
 void InitializeInterceptors() {
   INTERCEPT_FUNCTION(calloc);
   INTERCEPT_FUNCTION(free);
@@ -357,7 +356,7 @@ void InitializeInterceptors() {
   INTERCEPT_FUNCTION(realloc);
   INTERCEPT_FUNCTION(reallocf);
   INTERCEPT_FUNCTION(valloc);
-  RADSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC;
+  RTSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC;
   INTERCEPT_FUNCTION(posix_memalign);
 #if SANITIZER_INTERCEPT_MEMALIGN
   INTERCEPT_FUNCTION(memalign);
@@ -410,4 +409,4 @@ void InitializeInterceptors() {
   INTERCEPT_FUNCTION(recvfrom);
   INTERCEPT_FUNCTION(shutdown);
 }
-} // namespace __radsan
+} // namespace __rtsan
diff --git a/compiler-rt/lib/radsan/radsan_interceptors.h b/compiler-rt/lib/rtsan/rtsan_interceptors.h
similarity index 76%
rename from compiler-rt/lib/radsan/radsan_interceptors.h
rename to compiler-rt/lib/rtsan/rtsan_interceptors.h
index 95dd44ca5bc80..a3dac27544c66 100644
--- a/compiler-rt/lib/radsan/radsan_interceptors.h
+++ b/compiler-rt/lib/rtsan/rtsan_interceptors.h
@@ -1,5 +1,4 @@
-//===--- radsan_interceptors.h - Realtime Sanitizer --------------*- C++
-//-*-===//
+//===--- rtsan_interceptors.h - Realtime Sanitizer --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -11,6 +10,6 @@
 
 #pragma once
 
-namespace __radsan {
+namespace __rtsan {
 void InitializeInterceptors();
-} // namespace __radsan
+} // namespace __rtsan
diff --git a/compiler-rt/lib/radsan/radsan_preinit.cpp b/compiler-rt/lib/rtsan/rtsan_preinit.cpp
similarity index 71%
rename from compiler-rt/lib/radsan/radsan_preinit.cpp
rename to compiler-rt/lib/rtsan/rtsan_preinit.cpp
index 43bf1d6714a40..8cea61c3ea8b7 100644
--- a/compiler-rt/lib/radsan/radsan_preinit.cpp
+++ b/compiler-rt/lib/rtsan/rtsan_preinit.cpp
@@ -1,4 +1,4 @@
-//===--- radsan_preinit.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- rtsan_preinit.cpp - Realtime Sanitizer -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,15 +9,15 @@
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_internal_defs.h"
-#include <radsan/radsan.h>
+#include <rtsan/rtsan.h>
 
 #if SANITIZER_CAN_USE_PREINIT_ARRAY
 
-// The symbol is called __local_radsan_preinit, because it's not intended to be
+// The symbol is called __local_rtsan_preinit, because it's not intended to be
 // exported.
 // This code is linked into the main executable when -fsanitize=realtime is in
 // the link flags. It can only use exported interface functions.
 __attribute__((section(".preinit_array"),
-               used)) void (*__local_radsan_preinit)(void) = __radsan_init;
+               used)) void (*__local_rtsan_preinit)(void) = __rtsan_init;
 
 #endif
diff --git a/compiler-rt/lib/radsan/radsan_stack.cpp b/compiler-rt/lib/rtsan/rtsan_stack.cpp
similarity index 85%
rename from compiler-rt/lib/radsan/radsan_stack.cpp
rename to compiler-rt/lib/rtsan/rtsan_stack.cpp
index d00db6068132f..ff0af8fe675f3 100644
--- a/compiler-rt/lib/radsan/radsan_stack.cpp
+++ b/compiler-rt/lib/rtsan/rtsan_stack.cpp
@@ -1,4 +1,4 @@
-//===--- radsan_stack.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- rtsan_stack.cpp - Realtime Sanitizer -------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,7 +8,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "radsan_stack.h"
+#include "rtsan_stack.h"
 
 #include <sanitizer_common/sanitizer_flags.h>
 #include <sanitizer_common/sanitizer_stacktrace.h>
@@ -33,12 +33,12 @@ static void SetGlobalStackTraceFormat() {
   CommonFlags cf;
   cf.CopyFrom(*common_flags());
   cf.stack_trace_format = "DEFAULT";
-  cf.external_symbolizer_path = GetEnv("RADSAN_SYMBOLIZER_PATH");
+  cf.external_symbolizer_path = GetEnv("RTSAN_SYMBOLIZER_PATH");
   OverrideCommonFlags(cf);
 }
 
-using namespace __radsan;
-void __radsan::PrintStackTrace() {
+using namespace __rtsan;
+void __rtsan::PrintStackTrace() {
 
   BufferedStackTrace stack{};
 
diff --git a/compiler-rt/lib/radsan/radsan_stack.h b/compiler-rt/lib/rtsan/rtsan_stack.h
similarity index 76%
rename from compiler-rt/lib/radsan/radsan_stack.h
rename to compiler-rt/lib/rtsan/rtsan_stack.h
index 73958f98d221d..cecdd43045db5 100644
--- a/compiler-rt/lib/radsan/radsan_stack.h
+++ b/compiler-rt/lib/rtsan/rtsan_stack.h
@@ -1,4 +1,4 @@
-//===--- radsan_stack.h - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- rtsan_stack.h - Realtime Sanitizer ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -10,6 +10,6 @@
 
 #pragma once
 
-namespace __radsan {
+namespace __rtsan {
 void PrintStackTrace();
-} // namespace __radsan
+} // namespace __rtsan
diff --git a/compiler-rt/lib/rtsan/tests/CMakeLists.txt b/compiler-rt/lib/rtsan/tests/CMakeLists.txt
new file mode 100644
index 0000000000000..87a5730685376
--- /dev/null
+++ b/compiler-rt/lib/rtsan/tests/CMakeLists.txt
@@ -0,0 +1,103 @@
+include(CompilerRTCompile)
+
+include_directories(..)
+
+set(RTSAN_UNITTEST_CFLAGS
+  ${COMPILER_RT_UNITTEST_CFLAGS}
+  ${COMPILER_RT_GTEST_CFLAGS}
+  ${COMPILER_RT_GMOCK_CFLAGS}
+  ${SANITIZER_TEST_CXX_CFLAGS}
+  -I${COMPILER_RT_SOURCE_DIR}/lib/
+  -I${COMPILER_RT_SOURCE_DIR}/include/
+  -I${COMPILER_RT_SOURCE_DIR}/lib/rtsan
+  -I${COMPILER_RT_SOURCE_DIR}/lib/sanitizer_common/tests
+  -DSANITIZER_COMMON_NO_REDEFINE_BUILTINS
+  -O2)
+
+set(RTSAN_INST_TEST_SOURCES
+    rtsan_test_functional.cpp
+    rtsan_test_interceptors.cpp
+    rtsan_test_main.cpp)
+
+set(RTSAN_NOINST_TEST_SOURCES
+    ../rtsan_preinit.cpp
+    rtsan_test_context.cpp
+    rtsan_test_main.cpp)
+
+set(RTSAN_UNITTEST_HEADERS
+    rtsan_test_utilities.h)
+
+add_custom_target(RtsanUnitTests)
+set_target_properties(RtsanUnitTests PROPERTIES FOLDER "Compiler-RT Tests")
+
+set(RTSAN_UNITTEST_LINK_FLAGS
+  ${COMPILER_RT_UNITTEST_LINK_FLAGS}
+  ${COMPILER_RT_UNWINDER_LINK_LIBS}
+  ${SANITIZER_TEST_CXX_LIBRARIES}
+  -no-pie)
+
+if (APPLE)
+  add_weak_symbols("sanitizer_common" WEAK_SYMBOL_LINK_FLAGS)
+  list(APPEND RTSAN_UNITTEST_LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS})
+  list(APPEND RTSAN_UNITTEST_LINK_FLAGS ${DARWIN_osx_LINK_FLAGS})
+  list(APPEND RTSAN_UNITTEST_CFLAGS ${DARWIN_osx_CFLAGS})
+else()
+  list(APPEND RTSAN_UNITTEST_LINK_FLAGS -latomic)
+endif()
+
+set(COMPILER_RT_GOOGLETEST_SOURCES ${COMPILER_RT_GTEST_SOURCE} ${COMPILER_RT_GMOCK_SOURCE})
+
+set(RTSAN_TEST_ARCH ${RTSAN_SUPPORTED_ARCH})
+if(APPLE)
+  darwin_filter_host_archs(RTSAN_SUPPORTED_ARCH RTSAN_TEST_ARCH)
+endif()
+
+foreach(arch ${RTSAN_TEST_ARCH})
+  set(RtsanTestObjects)
+  generate_compiler_rt_tests(RtsanTestObjects
+    RtsanUnitTests "Rtsan-${arch}-Test" ${arch}
+    COMPILE_DEPS ${RTSAN_UNITTEST_HEADERS}
+    SOURCES ${RTSAN_INST_TEST_SOURCES} ${COMPILER_RT_GOOGLETEST_SOURCES}
+    DEPS llvm_gtest rtsan
+    CFLAGS ${RTSAN_UNITTEST_CFLAGS} -fsanitize=realtime
+    LINK_FLAGS ${RTSAN_UNITTEST_LINK_FLAGS} -fsanitize=realtime)
+  set_target_properties(RtsanUnitTests PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+  set(RTSAN_TEST_RUNTIME RTRtsanTest.${arch})
+  if(APPLE)
+    set(RTSAN_TEST_RUNTIME_OBJECTS
+      $<TARGET_OBJECTS:RTRtsan.osx>
+      $<TARGET_OBJECTS:RTInterception.osx>
+      $<TARGET_OBJECTS:RTSanitizerCommon.osx>
+      $<TARGET_OBJECTS:RTSanitizerCommonLibc.osx>
+      $<TARGET_OBJECTS:RTSanitizerCommonCoverage.osx>
+      $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.osx>)
+  else()
+    set(RTSAN_TEST_RUNTIME_OBJECTS
+      $<TARGET_OBJECTS:RTRtsan.${arch}>
+      $<TARGET_OBJECTS:RTInterception.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonCoverage.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonSymbolizer.${arch}>
+      $<TARGET_OBJECTS:RTSanitizerCommonSymbolizerInternal.${arch}>)
+  endif()
+  add_library(${RTSAN_TEST_RUNTIME} STATIC ${RTSAN_TEST_RUNTIME_OBJECTS})
+  set_target_properties(${RTSAN_TEST_RUNTIME} PROPERTIES
+      ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+      FOLDER "Compiler-RT Runtime tests")
+
+  set(RtsanNoInstTestObjects)
+  generate_compiler_rt_tests(RtsanNoInstTestObjects
+    RtsanUnitTests "Rtsan-${arch}-NoInstTest" ${arch}
+    COMPILE_DEPS ${RTSAN_UNITTEST_HEADERS}
+    SOURCES ${RTSAN_NOINST_TEST_SOURCES}
+            ${COMPILER_RT_GOOGLETEST_SOURCES}
+    DEPS llvm_gtest
+    CFLAGS ${RTSAN_UNITTEST_CFLAGS}
+    LINK_FLAGS ${RTSAN_UNITTEST_LINK_FLAGS}
+    RUNTIME ${RTSAN_TEST_RUNTIME})
+  set_target_properties(RtsanUnitTests PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+endforeach()
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp b/compiler-rt/lib/rtsan/tests/rtsan_test_context.cpp
similarity index 64%
rename from compiler-rt/lib/radsan/tests/radsan_test_context.cpp
rename to compiler-rt/lib/rtsan/tests/rtsan_test_context.cpp
index 1c098fcabd2ad..b7e73236a14cc 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_context.cpp
+++ b/compiler-rt/lib/rtsan/tests/rtsan_test_context.cpp
@@ -1,5 +1,4 @@
-//===--- radsan_test_context.cpp - Realtime Sanitizer --------------*- C++
-//-*-===//
+//===--- rtsan_test_context.cpp - Realtime Sanitizer ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -9,34 +8,34 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "radsan_test_utilities.h"
+#include "rtsan_test_utilities.h"
 
-#include "radsan_context.h"
+#include "rtsan_context.h"
 
-TEST(TestRadsanContext, CanCreateContext) { __radsan::Context context{}; }
+TEST(TestRtsanContext, CanCreateContext) { __rtsan::Context context{}; }
 
-TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieBeforeRealtimePush) {
-  __radsan::Context context{};
+TEST(TestRtsanContext, ExpectNotRealtimeDoesNotDieBeforeRealtimePush) {
+  __rtsan::Context context{};
   context.ExpectNotRealtime("do_some_stuff");
 }
 
-TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterPushAndPop) {
-  __radsan::Context context{};
+TEST(TestRtsanContext, ExpectNotRealtimeDoesNotDieAfterPushAndPop) {
+  __rtsan::Context context{};
   context.RealtimePush();
   context.RealtimePop();
   context.ExpectNotRealtime("do_some_stuff");
 }
 
-TEST(TestRadsanContext, ExpectNotRealtimeDiesAfterRealtimePush) {
-  __radsan::Context context{};
+TEST(TestRtsanContext, ExpectNotRealtimeDiesAfterRealtimePush) {
+  __rtsan::Context context{};
 
   context.RealtimePush();
   EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
 }
 
-TEST(TestRadsanContext,
+TEST(TestRtsanContext,
      ExpectNotRealtimeDiesAfterRealtimeAfterMorePushesThanPops) {
-  __radsan::Context context{};
+  __rtsan::Context context{};
 
   context.RealtimePush();
   context.RealtimePush();
@@ -46,17 +45,17 @@ TEST(TestRadsanContext,
   EXPECT_DEATH(context.ExpectNotRealtime("do_some_stuff"), "");
 }
 
-TEST(TestRadsanContext, ExpectNotRealtimeDoesNotDieAfterBypassPush) {
-  __radsan::Context context{};
+TEST(TestRtsanContext, ExpectNotRealtimeDoesNotDieAfterBypassPush) {
+  __rtsan::Context context{};
 
   context.RealtimePush();
   context.BypassPush();
   context.ExpectNotRealtime("do_some_stuff");
 }
 
-TEST(TestRadsanContext,
+TEST(TestRtsanContext,
      ExpectNotRealtimeDoesNotDieIfBypassDepthIsGreaterThanZero) {
-  __radsan::Context context{};
+  __rtsan::Context context{};
 
   context.RealtimePush();
   context.BypassPush();
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp b/compiler-rt/lib/rtsan/tests/rtsan_test_functional.cpp
similarity index 76%
rename from compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
rename to compiler-rt/lib/rtsan/tests/rtsan_test_functional.cpp
index 2b314043c320a..2f3cd3a8bd287 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_functional.cpp
+++ b/compiler-rt/lib/rtsan/tests/rtsan_test_functional.cpp
@@ -1,4 +1,4 @@
-//===--- radsan_test.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- rtsan_test.cpp - Realtime Sanitizer --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -8,14 +8,14 @@
 //
 // Introduces basic functional tests for the realtime sanitizer.
 // Not meant to be exhaustive, testing all interceptors, please see
-// test_radsan_interceptors.cpp for those tests.
+// test_rtsan_interceptors.cpp for those tests.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 
-#include "radsan_test_utilities.h"
-#include <radsan.h>
+#include "rtsan_test_utilities.h"
+#include <rtsan.h>
 #include <sanitizer_common/sanitizer_platform.h>
 #include <sanitizer_common/sanitizer_platform_interceptors.h>
 
@@ -34,13 +34,13 @@
 #define SI_MAC_DEPLOYMENT_AT_LEAST_10_12 0
 #endif
 
-#define RADSAN_TEST_SHARED_MUTEX (!(SI_MAC) || SI_MAC_DEPLOYMENT_AT_LEAST_10_12)
+#define RTSAN_TEST_SHARED_MUTEX (!(SI_MAC) || SI_MAC_DEPLOYMENT_AT_LEAST_10_12)
 
 using namespace testing;
-using namespace radsan_testing;
+using namespace rtsan_testing;
 using namespace std::chrono_literals;
 
-TEST(TestRadsan, VectorPushBackAllocationDiesWhenRealtime) {
+TEST(TestRtsan, VectorPushBackAllocationDiesWhenRealtime) {
   std::vector<float> vec{};
   auto Func = [&vec]() { vec.push_back(0.4f); };
   ExpectRealtimeDeath(Func);
@@ -49,7 +49,7 @@ TEST(TestRadsan, VectorPushBackAllocationDiesWhenRealtime) {
   ASSERT_EQ(1u, vec.size());
 }
 
-TEST(TestRadsan, DestructionOfObjectOnHeapDiesWhenRealtime) {
+TEST(TestRtsan, DestructionOfObjectOnHeapDiesWhenRealtime) {
   auto allocated_ptr = std::make_unique<std::array<float, 256>>();
   auto Func = [&allocated_ptr]() { allocated_ptr.reset(); };
   ExpectRealtimeDeath(Func);
@@ -58,34 +58,34 @@ TEST(TestRadsan, DestructionOfObjectOnHeapDiesWhenRealtime) {
   ASSERT_EQ(nullptr, allocated_ptr.get());
 }
 
-TEST(TestRadsan, SleepingAThreadDiesWhenRealtime) {
+TEST(TestRtsan, SleepingAThreadDiesWhenRealtime) {
   auto Func = []() { std::this_thread::sleep_for(1us); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, IfstreamCreationDiesWhenRealtime) {
+TEST(TestRtsan, IfstreamCreationDiesWhenRealtime) {
   auto Func = []() { std::ifstream ifs{"./file.txt"}; };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
   std::remove("./file.txt");
 }
 
-TEST(TestRadsan, OfstreamCreationDiesWhenRealtime) {
+TEST(TestRtsan, OfstreamCreationDiesWhenRealtime) {
   auto Func = []() { std::ofstream ofs{"./file.txt"}; };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
   std::remove("./file.txt");
 }
 
-TEST(TestRadsan, LockingAMutexDiesWhenRealtime) {
+TEST(TestRtsan, LockingAMutexDiesWhenRealtime) {
   std::mutex mutex{};
   auto Func = [&]() { mutex.lock(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, UnlockingAMutexDiesWhenRealtime) {
+TEST(TestRtsan, UnlockingAMutexDiesWhenRealtime) {
   std::mutex mutex{};
   mutex.lock();
   auto Func = [&]() { mutex.unlock(); };
@@ -93,16 +93,16 @@ TEST(TestRadsan, UnlockingAMutexDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-#if RADSAN_TEST_SHARED_MUTEX
+#if RTSAN_TEST_SHARED_MUTEX
 
-TEST(TestRadsan, LockingASharedMutexDiesWhenRealtime) {
+TEST(TestRtsan, LockingASharedMutexDiesWhenRealtime) {
   std::shared_mutex mutex{};
   auto Func = [&]() { mutex.lock(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, UnlockingASharedMutexDiesWhenRealtime) {
+TEST(TestRtsan, UnlockingASharedMutexDiesWhenRealtime) {
   std::shared_mutex mutex{};
   mutex.lock();
   auto Func = [&]() { mutex.unlock(); };
@@ -110,14 +110,14 @@ TEST(TestRadsan, UnlockingASharedMutexDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, SharedLockingASharedMutexDiesWhenRealtime) {
+TEST(TestRtsan, SharedLockingASharedMutexDiesWhenRealtime) {
   std::shared_mutex mutex{};
   auto Func = [&]() { mutex.lock_shared(); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, SharedUnlockingASharedMutexDiesWhenRealtime) {
+TEST(TestRtsan, SharedUnlockingASharedMutexDiesWhenRealtime) {
   std::shared_mutex mutex{};
   mutex.lock_shared();
   auto Func = [&]() { mutex.unlock_shared(); };
@@ -125,9 +125,9 @@ TEST(TestRadsan, SharedUnlockingASharedMutexDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-#endif // RADSAN_TEST_SHARED_MUTEX
+#endif // RTSAN_TEST_SHARED_MUTEX
 
-TEST(TestRadsan, LaunchingAThreadDiesWhenRealtime) {
+TEST(TestRtsan, LaunchingAThreadDiesWhenRealtime) {
   auto Func = [&]() {
     std::thread Thread{[]() {}};
     Thread.join();
@@ -140,7 +140,7 @@ namespace {
 void InvokeStdFunction(std::function<void()> &&function) { function(); }
 } // namespace
 
-TEST(TestRadsan, CopyingALambdaWithLargeCaptureDiesWhenRealtime) {
+TEST(TestRtsan, CopyingALambdaWithLargeCaptureDiesWhenRealtime) {
   std::array<float, 16> lots_of_data{};
   auto lambda = [lots_of_data]() mutable {
     // Stop everything getting optimised out
@@ -153,7 +153,7 @@ TEST(TestRadsan, CopyingALambdaWithLargeCaptureDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, AccessingALargeAtomicVariableDiesWhenRealtime) {
+TEST(TestRtsan, AccessingALargeAtomicVariableDiesWhenRealtime) {
   std::atomic<float> small_atomic{0.0f};
   ASSERT_TRUE(small_atomic.is_lock_free());
   RealtimeInvoke([&small_atomic]() { float x = small_atomic.load(); });
@@ -165,26 +165,26 @@ TEST(TestRadsan, AccessingALargeAtomicVariableDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, FirstCoutDiesWhenRealtime) {
+TEST(TestRtsan, FirstCoutDiesWhenRealtime) {
   auto Func = []() { std::cout << "Hello, world!" << std::endl; };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, SecondCoutDiesWhenRealtime) {
+TEST(TestRtsan, SecondCoutDiesWhenRealtime) {
   std::cout << "Hello, world";
   auto Func = []() { std::cout << "Hello, again!" << std::endl; };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, PrintfDiesWhenRealtime) {
+TEST(TestRtsan, PrintfDiesWhenRealtime) {
   auto Func = []() { printf("Hello, world!\n"); };
   ExpectRealtimeDeath(Func);
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, ThrowingAnExceptionDiesWhenRealtime) {
+TEST(TestRtsan, ThrowingAnExceptionDiesWhenRealtime) {
   auto Func = [&]() {
     try {
       throw std::exception();
@@ -195,13 +195,13 @@ TEST(TestRadsan, ThrowingAnExceptionDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsan, DoesNotDieIfTurnedOff) {
+TEST(TestRtsan, DoesNotDieIfTurnedOff) {
   std::mutex mutex{};
   auto RealtimeUnsafeFunc = [&]() {
-    __radsan_off();
+    __rtsan_off();
     mutex.lock();
     mutex.unlock();
-    __radsan_on();
+    __rtsan_on();
   };
   RealtimeInvoke(RealtimeUnsafeFunc);
 }
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp b/compiler-rt/lib/rtsan/tests/rtsan_test_interceptors.cpp
similarity index 78%
rename from compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
rename to compiler-rt/lib/rtsan/tests/rtsan_test_interceptors.cpp
index 9874f0e4c3e6b..f5b016089087d 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_interceptors.cpp
+++ b/compiler-rt/lib/rtsan/tests/rtsan_test_interceptors.cpp
@@ -1,5 +1,4 @@
-//===--- radsan_test_interceptors.cpp - Realtime Sanitizer --------------*- C++
-//-*-===//
+//===--- rtsan_test_interceptors.cpp - Realtime Sanitizer -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -14,7 +13,7 @@
 #include <sanitizer_common/sanitizer_platform.h>
 #include <sanitizer_common/sanitizer_platform_interceptors.h>
 
-#include "radsan_test_utilities.h"
+#include "rtsan_test_utilities.h"
 
 #if SANITIZER_APPLE
 #include <libkern/OSAtomic.h>
@@ -36,17 +35,17 @@
 #include <sys/socket.h>
 
 using namespace testing;
-using namespace radsan_testing;
+using namespace rtsan_testing;
 using namespace std::chrono_literals;
 
 void *FakeThreadEntryPoint(void *) { return nullptr; }
 
-class RadsanFileTest : public ::testing::Test {
+class RtsanFileTest : public ::testing::Test {
 protected:
   void SetUp() override {
     const ::testing::TestInfo *const test_info =
         ::testing::UnitTest::GetInstance()->current_test_info();
-    file_path_ = std::string("/tmp/radsan_temporary_test_file_") +
+    file_path_ = std::string("/tmp/rtsan_temporary_test_file_") +
                  test_info->name() + ".txt";
     RemoveTemporaryFile();
   }
@@ -66,13 +65,13 @@ class RadsanFileTest : public ::testing::Test {
     Allocation and deallocation
 */
 
-TEST(TestRadsanInterceptors, MallocDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, MallocDiesWhenRealtime) {
   auto Func = []() { EXPECT_NE(nullptr, malloc(1)); };
   ExpectRealtimeDeath(Func, "malloc");
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, ReallocDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, ReallocDiesWhenRealtime) {
   void *ptr_1 = malloc(1);
   auto Func = [ptr_1]() { EXPECT_NE(nullptr, realloc(ptr_1, 8)); };
   ExpectRealtimeDeath(Func, "realloc");
@@ -80,7 +79,7 @@ TEST(TestRadsanInterceptors, ReallocDiesWhenRealtime) {
 }
 
 #if SANITIZER_APPLE
-TEST(TestRadsanInterceptors, ReallocfDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, ReallocfDiesWhenRealtime) {
   void *ptr_1 = malloc(1);
   auto Func = [ptr_1]() { EXPECT_NE(nullptr, reallocf(ptr_1, 8)); };
   ExpectRealtimeDeath(Func, "reallocf");
@@ -88,14 +87,14 @@ TEST(TestRadsanInterceptors, ReallocfDiesWhenRealtime) {
 }
 #endif
 
-TEST(TestRadsanInterceptors, VallocDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, VallocDiesWhenRealtime) {
   auto Func = []() { EXPECT_NE(nullptr, valloc(4)); };
   ExpectRealtimeDeath(Func, "valloc");
   ExpectNonRealtimeSurvival(Func);
 }
 
 #if SANITIZER_INTERCEPT_ALIGNED_ALLOC
-TEST(TestRadsanInterceptors, AlignedAllocDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, AlignedAllocDiesWhenRealtime) {
   auto Func = []() { EXPECT_NE(nullptr, aligned_alloc(16, 32)); };
   ExpectRealtimeDeath(Func, "aligned_alloc");
   ExpectNonRealtimeSurvival(Func);
@@ -103,7 +102,7 @@ TEST(TestRadsanInterceptors, AlignedAllocDiesWhenRealtime) {
 #endif
 
 // free_sized and free_aligned_sized (both C23) are not yet supported
-TEST(TestRadsanInterceptors, FreeDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, FreeDiesWhenRealtime) {
   void *ptr_1 = malloc(1);
   void *ptr_2 = malloc(1);
   ExpectRealtimeDeath([ptr_1]() { free(ptr_1); }, "free");
@@ -114,12 +113,12 @@ TEST(TestRadsanInterceptors, FreeDiesWhenRealtime) {
   ASSERT_NE(nullptr, ptr_2);
 }
 
-TEST(TestRadsanInterceptors, FreeSurvivesWhenRealtimeIfArgumentIsNull) {
+TEST(TestRtsanInterceptors, FreeSurvivesWhenRealtimeIfArgumentIsNull) {
   RealtimeInvoke([]() { free(NULL); });
   ExpectNonRealtimeSurvival([]() { free(NULL); });
 }
 
-TEST(TestRadsanInterceptors, PosixMemalignDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PosixMemalignDiesWhenRealtime) {
   auto Func = []() {
     void *ptr;
     posix_memalign(&ptr, 4, 4);
@@ -129,7 +128,7 @@ TEST(TestRadsanInterceptors, PosixMemalignDiesWhenRealtime) {
 }
 
 #if SANITIZER_INTERCEPT_MEMALIGN
-TEST(TestRadsanInterceptors, MemalignDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, MemalignDiesWhenRealtime) {
   auto Func = []() { EXPECT_NE(memalign(2, 2048), nullptr); };
   ExpectRealtimeDeath(Func, "memalign");
   ExpectNonRealtimeSurvival(Func);
@@ -137,7 +136,7 @@ TEST(TestRadsanInterceptors, MemalignDiesWhenRealtime) {
 #endif
 
 #if SANITIZER_INTERCEPT_PVALLOC
-TEST(TestRadsanInterceptors, PvallocDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PvallocDiesWhenRealtime) {
   auto Func = []() { EXPECT_NE(pvalloc(2048), nullptr); };
   ExpectRealtimeDeath(Func, "pvalloc");
   ExpectNonRealtimeSurvival(Func);
@@ -148,19 +147,19 @@ TEST(TestRadsanInterceptors, PvallocDiesWhenRealtime) {
     Sleeping
 */
 
-TEST(TestRadsanInterceptors, SleepDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, SleepDiesWhenRealtime) {
   auto Func = []() { sleep(0u); };
   ExpectRealtimeDeath(Func, "sleep");
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, UsleepDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, UsleepDiesWhenRealtime) {
   auto Func = []() { usleep(1u); };
   ExpectRealtimeDeath(Func, "usleep");
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, NanosleepDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, NanosleepDiesWhenRealtime) {
   auto Func = []() {
     timespec T{};
     nanosleep(&T, &T);
@@ -173,19 +172,19 @@ TEST(TestRadsanInterceptors, NanosleepDiesWhenRealtime) {
     Filesystem
 */
 
-TEST_F(RadsanFileTest, OpenDiesWhenRealtime) {
+TEST_F(RtsanFileTest, OpenDiesWhenRealtime) {
   auto func = [this]() { open(GetTemporaryFilePath(), O_RDONLY); };
   ExpectRealtimeDeath(func, "open");
   ExpectNonRealtimeSurvival(func);
 }
 
-TEST_F(RadsanFileTest, OpenatDiesWhenRealtime) {
+TEST_F(RtsanFileTest, OpenatDiesWhenRealtime) {
   auto func = [this]() { openat(0, GetTemporaryFilePath(), O_RDONLY); };
   ExpectRealtimeDeath(func, "openat");
   ExpectNonRealtimeSurvival(func);
 }
 
-TEST_F(RadsanFileTest, OpenCreatesFileWithProperMode) {
+TEST_F(RtsanFileTest, OpenCreatesFileWithProperMode) {
   const int mode = S_IRGRP | S_IROTH | S_IRUSR | S_IWUSR;
 
   const int fd = open(GetTemporaryFilePath(), O_CREAT | O_WRONLY, mode);
@@ -199,19 +198,19 @@ TEST_F(RadsanFileTest, OpenCreatesFileWithProperMode) {
   ASSERT_THAT(st.st_mode & 0777, Eq(mode));
 }
 
-TEST_F(RadsanFileTest, CreatDiesWhenRealtime) {
+TEST_F(RtsanFileTest, CreatDiesWhenRealtime) {
   auto func = [this]() { creat(GetTemporaryFilePath(), S_IWOTH | S_IROTH); };
   ExpectRealtimeDeath(func, "creat");
   ExpectNonRealtimeSurvival(func);
 }
 
-TEST(TestRadsanInterceptors, FcntlDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, FcntlDiesWhenRealtime) {
   auto func = []() { fcntl(0, F_GETFL); };
   ExpectRealtimeDeath(func, "fcntl");
   ExpectNonRealtimeSurvival(func);
 }
 
-TEST_F(RadsanFileTest, FcntlFlockDiesWhenRealtime) {
+TEST_F(RtsanFileTest, FcntlFlockDiesWhenRealtime) {
   int fd = creat(GetTemporaryFilePath(), S_IRUSR | S_IWUSR);
   ASSERT_THAT(fd, Ne(-1));
 
@@ -232,7 +231,7 @@ TEST_F(RadsanFileTest, FcntlFlockDiesWhenRealtime) {
   close(fd);
 }
 
-TEST_F(RadsanFileTest, FcntlSetFdDiesWhenRealtime) {
+TEST_F(RtsanFileTest, FcntlSetFdDiesWhenRealtime) {
   int fd = creat(GetTemporaryFilePath(), S_IRUSR | S_IWUSR);
   ASSERT_THAT(fd, Ne(-1));
 
@@ -254,13 +253,13 @@ TEST_F(RadsanFileTest, FcntlSetFdDiesWhenRealtime) {
   close(fd);
 }
 
-TEST(TestRadsanInterceptors, CloseDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, CloseDiesWhenRealtime) {
   auto func = []() { close(0); };
   ExpectRealtimeDeath(func, "close");
   ExpectNonRealtimeSurvival(func);
 }
 
-TEST_F(RadsanFileTest, FopenDiesWhenRealtime) {
+TEST_F(RtsanFileTest, FopenDiesWhenRealtime) {
   auto func = [this]() {
     auto fd = fopen(GetTemporaryFilePath(), "w");
     EXPECT_THAT(fd, Ne(nullptr));
@@ -269,7 +268,7 @@ TEST_F(RadsanFileTest, FopenDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(func);
 }
 
-TEST_F(RadsanFileTest, FreadDiesWhenRealtime) {
+TEST_F(RtsanFileTest, FreadDiesWhenRealtime) {
   auto fd = fopen(GetTemporaryFilePath(), "w");
   auto func = [fd]() {
     char c{};
@@ -281,7 +280,7 @@ TEST_F(RadsanFileTest, FreadDiesWhenRealtime) {
     fclose(fd);
 }
 
-TEST_F(RadsanFileTest, FwriteDiesWhenRealtime) {
+TEST_F(RtsanFileTest, FwriteDiesWhenRealtime) {
   auto fd = fopen(GetTemporaryFilePath(), "w");
   ASSERT_NE(nullptr, fd);
   auto message = "Hello, world!";
@@ -290,7 +289,7 @@ TEST_F(RadsanFileTest, FwriteDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(func);
 }
 
-TEST_F(RadsanFileTest, FcloseDiesWhenRealtime) {
+TEST_F(RtsanFileTest, FcloseDiesWhenRealtime) {
   auto fd = fopen(GetTemporaryFilePath(), "w");
   EXPECT_THAT(fd, Ne(nullptr));
   auto func = [fd]() { fclose(fd); };
@@ -298,13 +297,13 @@ TEST_F(RadsanFileTest, FcloseDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(func);
 }
 
-TEST(TestRadsanInterceptors, PutsDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PutsDiesWhenRealtime) {
   auto func = []() { puts("Hello, world!\n"); };
   ExpectRealtimeDeath(func);
   ExpectNonRealtimeSurvival(func);
 }
 
-TEST_F(RadsanFileTest, FputsDiesWhenRealtime) {
+TEST_F(RtsanFileTest, FputsDiesWhenRealtime) {
   auto fd = fopen(GetTemporaryFilePath(), "w");
   ASSERT_THAT(fd, Ne(nullptr)) << errno;
   auto func = [fd]() { fputs("Hello, world!\n", fd); };
@@ -318,7 +317,7 @@ TEST_F(RadsanFileTest, FputsDiesWhenRealtime) {
     Concurrency
 */
 
-TEST(TestRadsanInterceptors, PthreadCreateDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PthreadCreateDiesWhenRealtime) {
   auto Func = []() {
     pthread_t thread{};
     const pthread_attr_t attr{};
@@ -329,7 +328,7 @@ TEST(TestRadsanInterceptors, PthreadCreateDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, PthreadMutexLockDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PthreadMutexLockDiesWhenRealtime) {
   auto Func = []() {
     pthread_mutex_t mutex{};
     pthread_mutex_lock(&mutex);
@@ -339,7 +338,7 @@ TEST(TestRadsanInterceptors, PthreadMutexLockDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, PthreadMutexUnlockDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PthreadMutexUnlockDiesWhenRealtime) {
   auto Func = []() {
     pthread_mutex_t mutex{};
     pthread_mutex_unlock(&mutex);
@@ -349,7 +348,7 @@ TEST(TestRadsanInterceptors, PthreadMutexUnlockDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, PthreadMutexJoinDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PthreadMutexJoinDiesWhenRealtime) {
   auto Func = []() {
     pthread_t thread{};
     pthread_join(thread, nullptr);
@@ -364,7 +363,7 @@ TEST(TestRadsanInterceptors, PthreadMutexJoinDiesWhenRealtime) {
 #pragma clang diagnostic push
 // OSSpinLockLock is deprecated, but still in use in libc++
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
-TEST(TestRadsanInterceptors, OsSpinLockLockDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, OsSpinLockLockDiesWhenRealtime) {
   auto Func = []() {
     OSSpinLock spin_lock{};
     OSSpinLockLock(&spin_lock);
@@ -374,7 +373,7 @@ TEST(TestRadsanInterceptors, OsSpinLockLockDiesWhenRealtime) {
 }
 #pragma clang diagnostic pop
 
-TEST(TestRadsanInterceptors, OsUnfairLockLockDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, OsUnfairLockLockDiesWhenRealtime) {
   auto Func = []() {
     os_unfair_lock_s unfair_lock{};
     os_unfair_lock_lock(&unfair_lock);
@@ -385,7 +384,7 @@ TEST(TestRadsanInterceptors, OsUnfairLockLockDiesWhenRealtime) {
 #endif
 
 #if SANITIZER_LINUX
-TEST(TestRadsanInterceptors, SpinLockLockDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, SpinLockLockDiesWhenRealtime) {
   pthread_spinlock_t spin_lock;
   pthread_spin_init(&spin_lock, PTHREAD_PROCESS_SHARED);
   auto Func = [&]() { pthread_spin_lock(&spin_lock); };
@@ -394,7 +393,7 @@ TEST(TestRadsanInterceptors, SpinLockLockDiesWhenRealtime) {
 }
 #endif
 
-TEST(TestRadsanInterceptors, PthreadCondSignalDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PthreadCondSignalDiesWhenRealtime) {
   pthread_cond_t cond{};
   pthread_cond_init(&cond, NULL);
 
@@ -405,7 +404,7 @@ TEST(TestRadsanInterceptors, PthreadCondSignalDiesWhenRealtime) {
   pthread_cond_destroy(&cond);
 }
 
-TEST(TestRadsanInterceptors, PthreadCondBroadcastDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PthreadCondBroadcastDiesWhenRealtime) {
   pthread_cond_t cond{};
   pthread_cond_init(&cond, NULL);
 
@@ -416,7 +415,7 @@ TEST(TestRadsanInterceptors, PthreadCondBroadcastDiesWhenRealtime) {
   pthread_cond_destroy(&cond);
 }
 
-TEST(TestRadsanInterceptors, PthreadCondWaitDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PthreadCondWaitDiesWhenRealtime) {
   pthread_cond_t cond;
   pthread_mutex_t mutex;
   ASSERT_EQ(0, pthread_cond_init(&cond, nullptr));
@@ -432,7 +431,7 @@ TEST(TestRadsanInterceptors, PthreadCondWaitDiesWhenRealtime) {
   pthread_mutex_destroy(&mutex);
 }
 
-TEST(TestRadsanInterceptors, PthreadRwlockRdlockDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PthreadRwlockRdlockDiesWhenRealtime) {
   auto Func = []() {
     pthread_rwlock_t rw_lock;
     pthread_rwlock_rdlock(&rw_lock);
@@ -441,7 +440,7 @@ TEST(TestRadsanInterceptors, PthreadRwlockRdlockDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, PthreadRwlockUnlockDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PthreadRwlockUnlockDiesWhenRealtime) {
   auto Func = []() {
     pthread_rwlock_t rw_lock;
     pthread_rwlock_unlock(&rw_lock);
@@ -450,7 +449,7 @@ TEST(TestRadsanInterceptors, PthreadRwlockUnlockDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, PthreadRwlockWrlockDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, PthreadRwlockWrlockDiesWhenRealtime) {
   auto Func = []() {
     pthread_rwlock_t rw_lock;
     pthread_rwlock_wrlock(&rw_lock);
@@ -462,26 +461,26 @@ TEST(TestRadsanInterceptors, PthreadRwlockWrlockDiesWhenRealtime) {
 /*
     Sockets
 */
-TEST(TestRadsanInterceptors, OpeningASocketDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, OpeningASocketDiesWhenRealtime) {
   auto Func = []() { socket(PF_INET, SOCK_STREAM, 0); };
   ExpectRealtimeDeath(Func, "socket");
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, SendToASocketDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, SendToASocketDiesWhenRealtime) {
   auto Func = []() { send(0, nullptr, 0, 0); };
   ExpectRealtimeDeath(Func, "send");
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, SendmsgToASocketDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, SendmsgToASocketDiesWhenRealtime) {
   msghdr msg{};
   auto Func = [&]() { sendmsg(0, &msg, 0); };
   ExpectRealtimeDeath(Func, "sendmsg");
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, SendtoToASocketDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, SendtoToASocketDiesWhenRealtime) {
   sockaddr addr{};
   socklen_t len{};
   auto Func = [&]() { sendto(0, nullptr, 0, 0, &addr, len); };
@@ -489,13 +488,13 @@ TEST(TestRadsanInterceptors, SendtoToASocketDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, RecvFromASocketDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, RecvFromASocketDiesWhenRealtime) {
   auto Func = []() { recv(0, nullptr, 0, 0); };
   ExpectRealtimeDeath(Func, "recv");
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, RecvfromOnASocketDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, RecvfromOnASocketDiesWhenRealtime) {
   sockaddr addr{};
   socklen_t len{};
   auto Func = [&]() { recvfrom(0, nullptr, 0, 0, &addr, &len); };
@@ -503,14 +502,14 @@ TEST(TestRadsanInterceptors, RecvfromOnASocketDiesWhenRealtime) {
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, RecvmsgOnASocketDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, RecvmsgOnASocketDiesWhenRealtime) {
   msghdr msg{};
   auto Func = [&]() { recvmsg(0, &msg, 0); };
   ExpectRealtimeDeath(Func, "recvmsg");
   ExpectNonRealtimeSurvival(Func);
 }
 
-TEST(TestRadsanInterceptors, ShutdownOnASocketDiesWhenRealtime) {
+TEST(TestRtsanInterceptors, ShutdownOnASocketDiesWhenRealtime) {
   auto Func = [&]() { shutdown(0, 0); };
   ExpectRealtimeDeath(Func, "shutdown");
   ExpectNonRealtimeSurvival(Func);
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_main.cpp b/compiler-rt/lib/rtsan/tests/rtsan_test_main.cpp
similarity index 90%
rename from compiler-rt/lib/radsan/tests/radsan_test_main.cpp
rename to compiler-rt/lib/rtsan/tests/rtsan_test_main.cpp
index 5777a0b69a93f..255ac9497103e 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_main.cpp
+++ b/compiler-rt/lib/rtsan/tests/rtsan_test_main.cpp
@@ -1,4 +1,4 @@
-//===--- radsan_test_main.cpp - Realtime Sanitizer --------------*- C++ -*-===//
+//===--- rtsan_test_main.cpp - Realtime Sanitizer ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
diff --git a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h b/compiler-rt/lib/rtsan/tests/rtsan_test_utilities.h
similarity index 85%
rename from compiler-rt/lib/radsan/tests/radsan_test_utilities.h
rename to compiler-rt/lib/rtsan/tests/rtsan_test_utilities.h
index 1d1c404a1373b..6ca09cf657094 100644
--- a/compiler-rt/lib/radsan/tests/radsan_test_utilities.h
+++ b/compiler-rt/lib/rtsan/tests/rtsan_test_utilities.h
@@ -1,5 +1,4 @@
-//===--- radsan_test_utilities.h - Realtime Sanitizer --------------*- C++
-//-*-===//
+//===--- rtsan_test_utilities.h - Realtime Sanitizer ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -11,16 +10,16 @@
 
 #pragma once
 
-#include "radsan.h"
+#include "rtsan.h"
 #include "gmock/gmock.h"
 #include <string>
 
-namespace radsan_testing {
+namespace rtsan_testing {
 
 template <typename Function> void RealtimeInvoke(Function &&Func) {
-  __radsan_realtime_enter();
+  __rtsan_realtime_enter();
   std::forward<Function>(Func)();
-  __radsan_realtime_exit();
+  __rtsan_realtime_exit();
 }
 
 template <typename Function>
@@ -45,4 +44,4 @@ template <typename Function> void ExpectNonRealtimeSurvival(Function &&Func) {
   std::forward<Function>(Func)();
 }
 
-} // namespace radsan_testing
+} // namespace rtsan_testing
diff --git a/compiler-rt/test/radsan/CMakeLists.txt b/compiler-rt/test/radsan/CMakeLists.txt
deleted file mode 100644
index d6b8dc9652879..0000000000000
--- a/compiler-rt/test/radsan/CMakeLists.txt
+++ /dev/null
@@ -1,58 +0,0 @@
-
-
-
-
-######
-# TODO: Full lit tests coming in a future review when we introduce the codegen
-######
-
-
-
-
-set(RADSAN_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
-
-set(RADSAN_TESTSUITES)
-set(RADSAN_FDR_TESTSUITES)
-
-set(RADSAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
-set(RADSAN_FDR_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
-set(RADSAN_TEST_ARCH ${RADSAN_SUPPORTED_ARCH})
-if(APPLE)
-  darwin_filter_host_archs(RADSAN_SUPPORTED_ARCH RADSAN_TEST_ARCH)
-endif()
-
-if (COMPILER_RT_HAS_RADSAN)
-  foreach(arch ${RADSAN_TEST_ARCH})
-    set(RADSAN_TEST_TARGET_ARCH ${arch})
-    string(TOLOWER "-${arch}-${OS_NAME}" RADSAN_TEST_CONFIG_SUFFIX)
-    get_test_cc_for_arch(${arch} RADSAN_TEST_TARGET_CC RADSAN_TEST_TARGET_CFLAGS)
-    string(TOUPPER ${arch} ARCH_UPPER_CASE)
-    set(CONFIG_NAME ${ARCH_UPPER_CASE}${OS_NAME}Config)
-
-    configure_lit_site_cfg(
-      ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
-      ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg.py)
-    list(APPEND RADSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
-  endforeach()
-endif()
-
-if(COMPILER_RT_INCLUDE_TESTS)
-  configure_lit_site_cfg(
-    ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.py.in
-    ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg.py)
-  if(COMPILER_RT_RADSAN_HAS_STATIC_RUNTIME)
-    configure_lit_site_cfg(
-      ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.py.in
-      ${CMAKE_CURRENT_BINARY_DIR}/Unit/dynamic/lit.site.cfg.py)
-  endif()
-  list(APPEND RADSAN_TEST_DEPS RadsanUnitTests)
-  list(APPEND RADSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit)
-  if(COMPILER_RT_RADSAN_HAS_STATIC_RUNTIME)
-    list(APPEND RADSAN_DYNAMIC_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit/dynamic)
-  endif()
-endif()
-
-add_lit_testsuite(check-radsan "Running the Radsan tests"
-  ${RADSAN_TESTSUITES}
-  DEPENDS ${RADSAN_TEST_DEPS})
-set_target_properties(check-radsan PROPERTIES FOLDER "Compiler-RT Misc")
diff --git a/compiler-rt/test/rtsan/CMakeLists.txt b/compiler-rt/test/rtsan/CMakeLists.txt
new file mode 100644
index 0000000000000..ba1070467f1a3
--- /dev/null
+++ b/compiler-rt/test/rtsan/CMakeLists.txt
@@ -0,0 +1,58 @@
+
+
+
+
+######
+# TODO: Full lit tests coming in a future review when we introduce the codegen
+######
+
+
+
+
+set(RTSAN_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(RTSAN_TESTSUITES)
+set(RTSAN_FDR_TESTSUITES)
+
+set(RTSAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+set(RTSAN_FDR_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+set(RTSAN_TEST_ARCH ${RTSAN_SUPPORTED_ARCH})
+if(APPLE)
+  darwin_filter_host_archs(RTSAN_SUPPORTED_ARCH RTSAN_TEST_ARCH)
+endif()
+
+if (COMPILER_RT_HAS_RTSAN)
+  foreach(arch ${RTSAN_TEST_ARCH})
+    set(RTSAN_TEST_TARGET_ARCH ${arch})
+    string(TOLOWER "-${arch}-${OS_NAME}" RTSAN_TEST_CONFIG_SUFFIX)
+    get_test_cc_for_arch(${arch} RTSAN_TEST_TARGET_CC RTSAN_TEST_TARGET_CFLAGS)
+    string(TOUPPER ${arch} ARCH_UPPER_CASE)
+    set(CONFIG_NAME ${ARCH_UPPER_CASE}${OS_NAME}Config)
+
+    configure_lit_site_cfg(
+      ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
+      ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg.py)
+    list(APPEND RTSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
+  endforeach()
+endif()
+
+if(COMPILER_RT_INCLUDE_TESTS)
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.py.in
+    ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg.py)
+  if(COMPILER_RT_RTSAN_HAS_STATIC_RUNTIME)
+    configure_lit_site_cfg(
+      ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.py.in
+      ${CMAKE_CURRENT_BINARY_DIR}/Unit/dynamic/lit.site.cfg.py)
+  endif()
+  list(APPEND RTSAN_TEST_DEPS RtsanUnitTests)
+  list(APPEND RTSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit)
+  if(COMPILER_RT_RTSAN_HAS_STATIC_RUNTIME)
+    list(APPEND RTSAN_DYNAMIC_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/Unit/dynamic)
+  endif()
+endif()
+
+add_lit_testsuite(check-rtsan "Running the Rtsan tests"
+  ${RTSAN_TESTSUITES}
+  DEPENDS ${RTSAN_TEST_DEPS})
+set_target_properties(check-rtsan PROPERTIES FOLDER "Compiler-RT Misc")
diff --git a/compiler-rt/test/radsan/Unit/lit.site.cfg.py.in b/compiler-rt/test/rtsan/Unit/lit.site.cfg.py.in
similarity index 65%
rename from compiler-rt/test/radsan/Unit/lit.site.cfg.py.in
rename to compiler-rt/test/rtsan/Unit/lit.site.cfg.py.in
index 432e0ed5e1907..59e1e10360b52 100644
--- a/compiler-rt/test/radsan/Unit/lit.site.cfg.py.in
+++ b/compiler-rt/test/rtsan/Unit/lit.site.cfg.py.in
@@ -9,7 +9,7 @@ config.name = 'RealtimeSanitizer-Unit'
 # Setup test source and exec root. For unit tests, we define
 # it as build directory with ASan unit tests.
 # FIXME: De-hardcode this path.
-config.test_exec_root = "@COMPILER_RT_BINARY_DIR@/lib/radsan/tests"
+config.test_exec_root = "@COMPILER_RT_BINARY_DIR@/lib/rtsan/tests"
 config.test_source_root = config.test_exec_root
 
 if not config.parallelism_group:
@@ -17,9 +17,9 @@ if not config.parallelism_group:
 
 if config.host_os == 'Darwin':
   # On Darwin, we default to ignore_noninstrumented_modules=1, which also
-  # suppresses some races the tests are supposed to find.  See radsan/lit.cfg.py.
-  if 'RADSAN_OPTIONS' in config.environment:
-    config.environment['RADSAN_OPTIONS'] += ':ignore_noninstrumented_modules=0'
+  # suppresses some races the tests are supposed to find.  See rtsan/lit.cfg.py.
+  if 'RTSAN_OPTIONS' in config.environment:
+    config.environment['RTSAN_OPTIONS'] += ':ignore_noninstrumented_modules=0'
   else:
-    config.environment['RADSAN_OPTIONS'] = 'ignore_noninstrumented_modules=0'
-  config.environment['RADSAN_OPTIONS'] += ':ignore_interceptors_accesses=0'
+    config.environment['RTSAN_OPTIONS'] = 'ignore_noninstrumented_modules=0'
+  config.environment['RTSAN_OPTIONS'] += ':ignore_interceptors_accesses=0'
diff --git a/compiler-rt/test/radsan/lit.cfg.py b/compiler-rt/test/rtsan/lit.cfg.py
similarity index 64%
rename from compiler-rt/test/radsan/lit.cfg.py
rename to compiler-rt/test/rtsan/lit.cfg.py
index b9e4dbc03abb6..137a7d99495ec 100644
--- a/compiler-rt/test/radsan/lit.cfg.py
+++ b/compiler-rt/test/rtsan/lit.cfg.py
@@ -1,31 +1,31 @@
 import os
 
 # Setup config name.
-config.name = "RADSAN" + config.name_suffix
+config.name = "RTSAN" + config.name_suffix
 
 # Setup source root.
 config.test_source_root = os.path.dirname(__file__)
 
-# Setup default compiler flags use with -fradsan-instrument option.
-clang_radsan_cflags = ["-fradsan-instrument", config.target_cflags]
+# Setup default compiler flags use with -frtsan-instrument option.
+clang_rtsan_cflags = ["-frtsan-instrument", config.target_cflags]
 
-# If libc++ was used to build radsan libraries, libc++ is needed. Fix applied
+# If libc++ was used to build rtsan libraries, libc++ is needed. Fix applied
 # to Linux only since -rpath may not be portable. This can be extended to
 # other platforms.
 if config.libcxx_used == "1" and config.host_os == "Linux":
-    clang_radsan_cflags = clang_radsan_cflags + (
+    clang_rtsan_cflags = clang_rtsan_cflags + (
         ["-L%s -lc++ -Wl,-rpath=%s" % (config.llvm_shlib_dir, config.llvm_shlib_dir)]
     )
 
-clang_radsan_cxxflags = config.cxx_mode_flags + clang_radsan_cflags
+clang_rtsan_cxxflags = config.cxx_mode_flags + clang_rtsan_cflags
 
 
 def build_invocation(compile_flags):
     return " " + " ".join([config.clang] + compile_flags) + " "
 
 
-# Assume that llvm-radsan is in the config.llvm_tools_dir.
-llvm_radsan = os.path.join(config.llvm_tools_dir, "llvm-radsan")
+# Assume that llvm-rtsan is in the config.llvm_tools_dir.
+llvm_rtsan = os.path.join(config.llvm_tools_dir, "llvm-rtsan")
 
 # Setup substitutions.
 if config.host_os == "Linux":
@@ -37,17 +37,17 @@ def build_invocation(compile_flags):
 config.substitutions.append(
     ("%clangxx ", build_invocation(config.cxx_mode_flags + [config.target_cflags]))
 )
-config.substitutions.append(("%clang_radsan ", build_invocation(clang_radsan_cflags)))
+config.substitutions.append(("%clang_rtsan ", build_invocation(clang_rtsan_cflags)))
 config.substitutions.append(
-    ("%clangxx_radsan", build_invocation(clang_radsan_cxxflags))
+    ("%clangxx_rtsan", build_invocation(clang_rtsan_cxxflags))
 )
-config.substitutions.append(("%llvm_radsan", llvm_radsan))
+config.substitutions.append(("%llvm_rtsan", llvm_rtsan))
 config.substitutions.append(
     (
-        "%radsanlib",
+        "%rtsanlib",
         (
             "-lm -lpthread %s -lrt -L%s "
-            "-Wl,-whole-archive -lclang_rt.radsan%s -Wl,-no-whole-archive"
+            "-Wl,-whole-archive -lclang_rt.rtsan%s -Wl,-no-whole-archive"
         )
         % (libdl_flag, config.compiler_rt_libdir, config.target_suffix),
     )
diff --git a/compiler-rt/test/radsan/lit.site.cfg.py.in b/compiler-rt/test/rtsan/lit.site.cfg.py.in
similarity index 69%
rename from compiler-rt/test/radsan/lit.site.cfg.py.in
rename to compiler-rt/test/rtsan/lit.site.cfg.py.in
index 7d509c9f2eb91..5b458645e94dc 100644
--- a/compiler-rt/test/radsan/lit.site.cfg.py.in
+++ b/compiler-rt/test/rtsan/lit.site.cfg.py.in
@@ -1,10 +1,10 @@
 @LIT_SITE_CFG_IN_HEADER@
 
 # Tool-specific config options.
-config.name_suffix = "@RADSAN_TEST_CONFIG_SUFFIX@"
-config.radsan_lit_source_dir = "@RADSAN_LIT_SOURCE_DIR@"
-config.target_cflags = "@RADSAN_TEST_TARGET_CFLAGS@"
-config.target_arch = "@RADSAN_TEST_TARGET_ARCH@"
+config.name_suffix = "@RTSAN_TEST_CONFIG_SUFFIX@"
+config.rtsan_lit_source_dir = "@RTSAN_LIT_SOURCE_DIR@"
+config.target_cflags = "@RTSAN_TEST_TARGET_CFLAGS@"
+config.target_arch = "@RTSAN_TEST_TARGET_ARCH@"
 config.built_with_llvm = ("@COMPILER_RT_STANDALONE_BUILD@" != "TRUE")
 
 if config.built_with_llvm:

>From 07e9f9d683d31745667a6d28f547189fa1cb5c29 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Wed, 5 Jun 2024 08:14:52 -0700
Subject: [PATCH 37/44] First working rtsan driver tests

---
 clang/test/Driver/rtsan.c | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 clang/test/Driver/rtsan.c

diff --git a/clang/test/Driver/rtsan.c b/clang/test/Driver/rtsan.c
new file mode 100644
index 0000000000000..efb1970d13f76
--- /dev/null
+++ b/clang/test/Driver/rtsan.c
@@ -0,0 +1,27 @@
+// RUN: %clang --target=x86_64-apple-darwin -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-DARWIN
+// CHECK-RTSAN-X86-64-DARWIN-NOT: unsupported option
+
+// RUN: %clang --target=x86_64-apple-darwin -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-DARWIN
+// CHECK-RTSAN-X86-64-DARWIN-NOT: unsupported option
+// RUN: %clang --target=x86_64-apple-macos -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-MACOS
+// CHECK-RTSAN-X86-64-MACOS-NOT: unsupported option
+// RUN: %clang --target=arm64-apple-macos -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-MACOS
+// CHECK-RTSAN-ARM64-MACOS-NOT: unsupported option
+
+// RUN: %clang --target=arm64-apple-ios-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-IOSSIMULATOR
+// CHECK-RTSAN-ARM64-IOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=arm64-apple-watchos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-WATCHOSSIMULATOR
+// CHECK-RTSAN-ARM64-WATCHOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=arm64-apple-tvos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-TVOSSIMULATOR
+// CHECK-RTSAN-ARM64-TVOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=x86_64-apple-ios-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-IOSSIMULATOR
+// CHECK-RTSAN-X86-64-IOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=x86_64-apple-watchos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-WATCHOSSIMULATOR
+// CHECK-RTSAN-X86-64-WATCHOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=x86_64-apple-tvos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-TVOSSIMULATOR
+// CHECK-RTSAN-X86-64-TVOSSIMULATOR-NOT: unsupported option

>From 8fa91f2a7fe3911948672c4798d614e48526e190 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Wed, 5 Jun 2024 08:28:21 -0700
Subject: [PATCH 38/44] Add linux working test

---
 clang/test/Driver/rtsan.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/clang/test/Driver/rtsan.c b/clang/test/Driver/rtsan.c
index efb1970d13f76..374712183f850 100644
--- a/clang/test/Driver/rtsan.c
+++ b/clang/test/Driver/rtsan.c
@@ -25,3 +25,6 @@
 
 // RUN: %clang --target=x86_64-apple-tvos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-TVOSSIMULATOR
 // CHECK-RTSAN-X86-64-TVOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=x86_64-linux-gnu -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-LINUX
+// CHECK-RTSAN-X86-64-LINUX-NOT: unsupported option

>From 2da8e98d453a71f9c8d7fd74b29554c36336780c Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Wed, 5 Jun 2024 08:31:00 -0700
Subject: [PATCH 39/44] Another test for openBSD

---
 clang/test/Driver/rtsan.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/clang/test/Driver/rtsan.c b/clang/test/Driver/rtsan.c
index 374712183f850..a335eff8845f5 100644
--- a/clang/test/Driver/rtsan.c
+++ b/clang/test/Driver/rtsan.c
@@ -28,3 +28,6 @@
 
 // RUN: %clang --target=x86_64-linux-gnu -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-LINUX
 // CHECK-RTSAN-X86-64-LINUX-NOT: unsupported option
+
+// RUN: not %clang --target=i386-pc-openbsd -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-OPENBSD
+// CHECK-RTSAN-OPENBSD: unsupported option '-fsanitize=realtime' for target 'i386-pc-openbsd'

>From 6ef90df5813738102d298b368cc6bc041ec6f5d1 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Wed, 5 Jun 2024 08:44:21 -0700
Subject: [PATCH 40/44] Add feature for realtime sanitizer, add incompatible
 sanitizers

---
 clang/include/clang/Basic/Features.def | 1 +
 clang/lib/Driver/SanitizerArgs.cpp     | 5 ++++-
 clang/test/Driver/rtsan.c              | 3 +++
 3 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/clang/include/clang/Basic/Features.def b/clang/include/clang/Basic/Features.def
index 53f410d3cb4bd..95064eeccf091 100644
--- a/clang/include/clang/Basic/Features.def
+++ b/clang/include/clang/Basic/Features.def
@@ -103,6 +103,7 @@ FEATURE(memory_sanitizer,
 FEATURE(thread_sanitizer, LangOpts.Sanitize.has(SanitizerKind::Thread))
 FEATURE(dataflow_sanitizer, LangOpts.Sanitize.has(SanitizerKind::DataFlow))
 FEATURE(scudo, LangOpts.Sanitize.hasOneOf(SanitizerKind::Scudo))
+FEATURE(realtime_sanitizer, LangOpts.Sanitize.hasOneOf(SanitizerKind::Realtime))
 FEATURE(ptrauth_intrinsics, LangOpts.PointerAuthIntrinsics)
 FEATURE(ptrauth_calls, LangOpts.PointerAuthCalls)
 FEATURE(ptrauth_returns, LangOpts.PointerAuthReturns)
diff --git a/clang/lib/Driver/SanitizerArgs.cpp b/clang/lib/Driver/SanitizerArgs.cpp
index 86825a6ccf7a1..44ea55bc971ae 100644
--- a/clang/lib/Driver/SanitizerArgs.cpp
+++ b/clang/lib/Driver/SanitizerArgs.cpp
@@ -556,7 +556,10 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC,
                      SanitizerKind::Address | SanitizerKind::KernelAddress |
                          SanitizerKind::HWAddress |
                          SanitizerKind::KernelHWAddress),
-      std::make_pair(SanitizerKind::KCFI, SanitizerKind::Function)};
+      std::make_pair(SanitizerKind::KCFI, SanitizerKind::Function),
+      std::make_pair(SanitizerKind::Realtime,
+                    SanitizerKind::Address | SanitizerKind::Thread ),
+      };
   // Enable toolchain specific default sanitizers if not explicitly disabled.
   SanitizerMask Default = TC.getDefaultSanitizers() & ~AllRemove;
 
diff --git a/clang/test/Driver/rtsan.c b/clang/test/Driver/rtsan.c
index a335eff8845f5..6a5002ed9c284 100644
--- a/clang/test/Driver/rtsan.c
+++ b/clang/test/Driver/rtsan.c
@@ -31,3 +31,6 @@
 
 // RUN: not %clang --target=i386-pc-openbsd -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-OPENBSD
 // CHECK-RTSAN-OPENBSD: unsupported option '-fsanitize=realtime' for target 'i386-pc-openbsd'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,thread  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-TSAN
+// CHECK-REALTIME-TSAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=thread'

>From 6cc96d728c8974af8ee05885083c48321c99bf1a Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Wed, 5 Jun 2024 08:49:01 -0700
Subject: [PATCH 41/44] More incompatabilities added

---
 clang/lib/Driver/SanitizerArgs.cpp |  3 ++-
 clang/test/Driver/rtsan.c          | 10 ++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/clang/lib/Driver/SanitizerArgs.cpp b/clang/lib/Driver/SanitizerArgs.cpp
index 44ea55bc971ae..3a742fde356aa 100644
--- a/clang/lib/Driver/SanitizerArgs.cpp
+++ b/clang/lib/Driver/SanitizerArgs.cpp
@@ -558,7 +558,8 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC,
                          SanitizerKind::KernelHWAddress),
       std::make_pair(SanitizerKind::KCFI, SanitizerKind::Function),
       std::make_pair(SanitizerKind::Realtime,
-                    SanitizerKind::Address | SanitizerKind::Thread ),
+                    SanitizerKind::Address | SanitizerKind::Thread |
+                    SanitizerKind::Undefined | SanitizerKind::Memory)
       };
   // Enable toolchain specific default sanitizers if not explicitly disabled.
   SanitizerMask Default = TC.getDefaultSanitizers() & ~AllRemove;
diff --git a/clang/test/Driver/rtsan.c b/clang/test/Driver/rtsan.c
index 6a5002ed9c284..4be691b2943c7 100644
--- a/clang/test/Driver/rtsan.c
+++ b/clang/test/Driver/rtsan.c
@@ -34,3 +34,13 @@
 
 // RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,thread  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-TSAN
 // CHECK-REALTIME-TSAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=thread'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,address  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-ASAN
+// CHECK-REALTIME-ASAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=address'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,memory  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-MSAN
+// CHECK-REALTIME-MSAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=memory'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,undefined  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-UBSAN
+// CHECK-REALTIME-UBSAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=undefined'
+

>From 618b9256c20b8a0b653c2b1654208f7c5ba0ac45 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Wed, 5 Jun 2024 08:51:48 -0700
Subject: [PATCH 42/44] rtsan tests to fsanitize

---
 clang/test/Driver/fsanitize.c | 47 +++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/clang/test/Driver/fsanitize.c b/clang/test/Driver/fsanitize.c
index db14f6e195c64..d1a3ea9a37066 100644
--- a/clang/test/Driver/fsanitize.c
+++ b/clang/test/Driver/fsanitize.c
@@ -1038,3 +1038,50 @@
 // RUN: not %clang --target=aarch64-none-elf -fsanitize=dataflow %s -### 2>&1 | FileCheck %s -check-prefix=UNSUPPORTED-BAREMETAL
 // RUN: not %clang --target=arm-arm-none-eabi -fsanitize=shadow-call-stack %s -### 2>&1 | FileCheck %s -check-prefix=UNSUPPORTED-BAREMETAL
 // UNSUPPORTED-BAREMETAL: unsupported option '-fsanitize={{.*}}' for target
+
+// RUN: %clang --target=x86_64-apple-darwin -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-DARWIN
+// CHECK-RTSAN-X86-64-DARWIN-NOT: unsupported option
+
+// RUN: %clang --target=x86_64-apple-darwin -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-DARWIN
+// CHECK-RTSAN-X86-64-DARWIN-NOT: unsupported option
+// RUN: %clang --target=x86_64-apple-macos -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-MACOS
+// CHECK-RTSAN-X86-64-MACOS-NOT: unsupported option
+// RUN: %clang --target=arm64-apple-macos -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-MACOS
+// CHECK-RTSAN-ARM64-MACOS-NOT: unsupported option
+
+// RUN: %clang --target=arm64-apple-ios-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-IOSSIMULATOR
+// CHECK-RTSAN-ARM64-IOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=arm64-apple-watchos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-WATCHOSSIMULATOR
+// CHECK-RTSAN-ARM64-WATCHOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=arm64-apple-tvos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-TVOSSIMULATOR
+// CHECK-RTSAN-ARM64-TVOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=x86_64-apple-ios-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-IOSSIMULATOR
+// CHECK-RTSAN-X86-64-IOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=x86_64-apple-watchos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-WATCHOSSIMULATOR
+// CHECK-RTSAN-X86-64-WATCHOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=x86_64-apple-tvos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-TVOSSIMULATOR
+// CHECK-RTSAN-X86-64-TVOSSIMULATOR-NOT: unsupported option
+
+// RUN: %clang --target=x86_64-linux-gnu -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-LINUX
+// CHECK-RTSAN-X86-64-LINUX-NOT: unsupported option
+
+// RUN: not %clang --target=i386-pc-openbsd -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-OPENBSD
+// CHECK-RTSAN-OPENBSD: unsupported option '-fsanitize=realtime' for target 'i386-pc-openbsd'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,thread  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-TSAN
+// CHECK-REALTIME-TSAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=thread'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,address  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-ASAN
+// CHECK-REALTIME-ASAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=address'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,memory  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-MSAN
+// CHECK-REALTIME-MSAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=memory'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,undefined  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-UBSAN
+// CHECK-REALTIME-UBSAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=undefined'
+

>From 14a58bed40aa4f6fe669cdb3a1ec3caa280eaff0 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Wed, 5 Jun 2024 08:52:51 -0700
Subject: [PATCH 43/44] Deleted rtsan.c

---
 clang/test/Driver/rtsan.c | 46 ---------------------------------------
 1 file changed, 46 deletions(-)
 delete mode 100644 clang/test/Driver/rtsan.c

diff --git a/clang/test/Driver/rtsan.c b/clang/test/Driver/rtsan.c
deleted file mode 100644
index 4be691b2943c7..0000000000000
--- a/clang/test/Driver/rtsan.c
+++ /dev/null
@@ -1,46 +0,0 @@
-// RUN: %clang --target=x86_64-apple-darwin -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-DARWIN
-// CHECK-RTSAN-X86-64-DARWIN-NOT: unsupported option
-
-// RUN: %clang --target=x86_64-apple-darwin -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-DARWIN
-// CHECK-RTSAN-X86-64-DARWIN-NOT: unsupported option
-// RUN: %clang --target=x86_64-apple-macos -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-MACOS
-// CHECK-RTSAN-X86-64-MACOS-NOT: unsupported option
-// RUN: %clang --target=arm64-apple-macos -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-MACOS
-// CHECK-RTSAN-ARM64-MACOS-NOT: unsupported option
-
-// RUN: %clang --target=arm64-apple-ios-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-IOSSIMULATOR
-// CHECK-RTSAN-ARM64-IOSSIMULATOR-NOT: unsupported option
-
-// RUN: %clang --target=arm64-apple-watchos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-WATCHOSSIMULATOR
-// CHECK-RTSAN-ARM64-WATCHOSSIMULATOR-NOT: unsupported option
-
-// RUN: %clang --target=arm64-apple-tvos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-ARM64-TVOSSIMULATOR
-// CHECK-RTSAN-ARM64-TVOSSIMULATOR-NOT: unsupported option
-
-// RUN: %clang --target=x86_64-apple-ios-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-IOSSIMULATOR
-// CHECK-RTSAN-X86-64-IOSSIMULATOR-NOT: unsupported option
-
-// RUN: %clang --target=x86_64-apple-watchos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-WATCHOSSIMULATOR
-// CHECK-RTSAN-X86-64-WATCHOSSIMULATOR-NOT: unsupported option
-
-// RUN: %clang --target=x86_64-apple-tvos-simulator -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-TVOSSIMULATOR
-// CHECK-RTSAN-X86-64-TVOSSIMULATOR-NOT: unsupported option
-
-// RUN: %clang --target=x86_64-linux-gnu -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-X86-64-LINUX
-// CHECK-RTSAN-X86-64-LINUX-NOT: unsupported option
-
-// RUN: not %clang --target=i386-pc-openbsd -fsanitize=realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN-OPENBSD
-// CHECK-RTSAN-OPENBSD: unsupported option '-fsanitize=realtime' for target 'i386-pc-openbsd'
-
-// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,thread  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-TSAN
-// CHECK-REALTIME-TSAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=thread'
-
-// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,address  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-ASAN
-// CHECK-REALTIME-ASAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=address'
-
-// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,memory  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-MSAN
-// CHECK-REALTIME-MSAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=memory'
-
-// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=realtime,undefined  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-REALTIME-UBSAN
-// CHECK-REALTIME-UBSAN: error: invalid argument '-fsanitize=realtime' not allowed with '-fsanitize=undefined'
-

>From 181fac7d0b16ec68fddd89fffa9b731f984e1d42 Mon Sep 17 00:00:00 2001
From: Chris Apple <14171107+cjappl at users.noreply.github.com>
Date: Wed, 5 Jun 2024 08:54:27 -0700
Subject: [PATCH 44/44] Code formatting

---
 clang/lib/Driver/SanitizerArgs.cpp | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/clang/lib/Driver/SanitizerArgs.cpp b/clang/lib/Driver/SanitizerArgs.cpp
index 3a742fde356aa..543b7b315423e 100644
--- a/clang/lib/Driver/SanitizerArgs.cpp
+++ b/clang/lib/Driver/SanitizerArgs.cpp
@@ -552,15 +552,14 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC,
                          SanitizerKind::Leak | SanitizerKind::Thread |
                          SanitizerKind::Memory | SanitizerKind::KernelAddress |
                          SanitizerKind::Scudo | SanitizerKind::SafeStack),
-      std::make_pair(SanitizerKind::MemTag,
-                     SanitizerKind::Address | SanitizerKind::KernelAddress |
-                         SanitizerKind::HWAddress |
-                         SanitizerKind::KernelHWAddress),
+      std::make_pair(SanitizerKind::MemTag, SanitizerKind::Address |
+                                                SanitizerKind::KernelAddress |
+                                                SanitizerKind::HWAddress |
+                                                SanitizerKind::KernelHWAddress),
       std::make_pair(SanitizerKind::KCFI, SanitizerKind::Function),
       std::make_pair(SanitizerKind::Realtime,
-                    SanitizerKind::Address | SanitizerKind::Thread |
-                    SanitizerKind::Undefined | SanitizerKind::Memory)
-      };
+                     SanitizerKind::Address | SanitizerKind::Thread |
+                         SanitizerKind::Undefined | SanitizerKind::Memory)};
   // Enable toolchain specific default sanitizers if not explicitly disabled.
   SanitizerMask Default = TC.getDefaultSanitizers() & ~AllRemove;