Allow using sanitizer runtimes on RISC-V

clang/lib/Driver/ToolChain.cpp

@@ -384,8 +384,8 @@ Tool *ToolChain::getTool(Action::ActionClass AC) const {
   llvm_unreachable("Invalid tool kind.");
 }
 
-static StringRef getArchNameForCompilerRTLib(const ToolChain &TC,
-                                             const ArgList &Args) {
+static std::string getArchNameForCompilerRTLib(const ToolChain &TC,
+                                               const ArgList &Args) {
   const llvm::Triple &Triple = TC.getTriple();
   bool IsWindows = Triple.isOSWindows();
 
@@ -398,15 +398,21 @@ static StringRef getArchNameForCompilerRTLib(const ToolChain &TC,
   if (TC.getArch() == llvm::Triple::x86 && Triple.isAndroid())
     return "i686";
 
-  if (Triple.isMIPS() && Triple.getEnvironment() == llvm::Triple::CheriPurecap) {
-    assert(Triple.getSubArch() != llvm::Triple::NoSubArch && "purecap triple should have subarch");
-    return Triple.getArchName();
+  if (Triple.isMIPS() && TC.isCheriPurecap()) {
+    // Purecap MIPS uses mips64c128 as the library name.
+    assert(Triple.getSubArch() != llvm::Triple::NoSubArch &&
+           "purecap triple should have subarch");
+    return Triple.getArchName().str();
   }
 
   if (TC.getArch() == llvm::Triple::x86_64 && Triple.isX32())
     return "x32";
 
-  return llvm::Triple::getArchTypeName(TC.getArch());
+  std::string Result = llvm::Triple::getArchTypeName(TC.getArch()).str();
+  // For other purecap architectures we append a single "c" to the library name.
+  if (TC.isCheriPurecap())
+    Result += "c";
+  return Result;
 }
 
 StringRef ToolChain::getOSLibName() const {
@@ -473,9 +479,9 @@ std::string ToolChain::buildCompilerRTBasename(const llvm::opt::ArgList &Args,
 
   std::string ArchAndEnv;
   if (AddArch) {
-    StringRef Arch = getArchNameForCompilerRTLib(*this, Args);
+    std::string Arch = getArchNameForCompilerRTLib(*this, Args);
     const char *Env = TT.isAndroid() ? "-android" : "";
-    ArchAndEnv = ("-" + Arch + Env).str();
+    ArchAndEnv = "-" + Arch + Env;
   }
   return (Prefix + Twine("clang_rt.") + Component + ArchAndEnv + Suffix).str();
 }

clang/test/Driver/cheri/freebsd-sanitizer-libnames.c

@@ -0,0 +1,63 @@
+// RUN: %riscv64_cheri_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined %s -### 2>&1 | FileCheck --check-prefixes=UBSAN,UBSAN-RISCV64 %s
+// RUN: %riscv64_cheri_purecap_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined %s -### 2>&1 | FileCheck --check-prefixes=UBSAN,UBSAN-PURECAP-RISCV64 %s
+// RUN: %riscv32_cheri_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined %s -### 2>&1 | FileCheck --check-prefixes=UBSAN,UBSAN-RISCV32 %s
+// RUN: %riscv32_cheri_purecap_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined %s -### 2>&1 | FileCheck --check-prefixes=UBSAN,UBSAN-PURECAP-RISCV32 %s
+// RUN: %cheri_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined %s -### 2>&1 | FileCheck --check-prefixes=UBSAN,UBSAN-MIPS64 %s
+// RUN: %cheri_purecap_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined %s -### 2>&1 | FileCheck --check-prefixes=UBSAN,UBSAN-PURECAP-MIPS64 %s
+
+// UBSAN: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]" "-isysroot"
+// UBSAN-SAME: "-fsanitize=alignment,array-bounds,
+// UBSAN-SAME: "-fsanitize-recover=alignment,array-bounds,
+// UBSAN-NEXT: "/usr/bin/ld"
+// UBSAN-RISCV64-SAME:         "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_standalone-riscv64.a"
+// UBSAN-PURECAP-RISCV64-SAME: "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_standalone-riscv64c.a"
+// UBSAN-RISCV32-SAME:         "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_standalone-riscv32.a"
+// UBSAN-PURECAP-RISCV32-SAME: "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_standalone-riscv32c.a"
+// UBSAN-MIPS64-SAME:          "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_standalone-mips64.a"
+// UBSAN-PURECAP-MIPS64-SAME:  "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_standalone-mips64c128.a"
+
+// RUN: %riscv64_cheri_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck --check-prefixes=UBSAN-MINIMAL,UBSAN-MINIMAL-RISCV64 %s
+// RUN: %riscv64_cheri_purecap_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck --check-prefixes=UBSAN-MINIMAL,UBSAN-MINIMAL-PURECAP-RISCV64 %s
+// RUN: %riscv32_cheri_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck --check-prefixes=UBSAN-MINIMAL,UBSAN-MINIMAL-RISCV32 %s
+// RUN: %riscv32_cheri_purecap_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck --check-prefixes=UBSAN-MINIMAL,UBSAN-MINIMAL-PURECAP-RISCV32 %s
+// RUN: %cheri_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck --check-prefixes=UBSAN-MINIMAL,UBSAN-MINIMAL-MIPS64 %s
+// RUN: %cheri_purecap_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=undefined -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck --check-prefixes=UBSAN-MINIMAL,UBSAN-MINIMAL-PURECAP-MIPS64 %s
+
+// UBSAN-MINIMAL: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]" "-isysroot"
+// UBSAN-MINIMAL-SAME: "-fsanitize=alignment,array-bounds,
+// UBSAN-MINIMAL-SAME: "-fsanitize-recover=alignment,array-bounds,
+// UBSAN-MINIMAL-NEXT: "/usr/bin/ld"
+// UBSAN-MINIMAL-RISCV64-SAME:         "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_minimal-riscv64.a"
+// UBSAN-MINIMAL-PURECAP-RISCV64-SAME: "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_minimal-riscv64c.a"
+// UBSAN-MINIMAL-RISCV32-SAME:         "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_minimal-riscv32.a"
+// UBSAN-MINIMAL-PURECAP-RISCV32-SAME: "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_minimal-riscv32c.a"
+// UBSAN-MINIMAL-MIPS64-SAME:          "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_minimal-mips64.a"
+// UBSAN-MINIMAL-PURECAP-MIPS64-SAME:  "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_minimal-mips64c128.a"
+
+// FIXME: fsanitize=fuzzer is not accepted for RISC-V
+// RUN: %cheri_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=fuzzer %s -### 2>&1 | FileCheck --check-prefixes=FUZZER,FUZZER-MIPS64 %s
+// RUN: %cheri_purecap_clang --sysroot=%S/Inputs/basic_cheribsd_libXXc_tree \
+// RUN:   -fsanitize=fuzzer %s -### 2>&1 | FileCheck --check-prefixes=FUZZER,FUZZER-PURECAP-MIPS64 %s
+
+
+// FUZZER: "-resource-dir" "[[RESOURCE_DIR:[^"]+]]" "-isysroot"
+// FUZZER-SAME: "-fsanitize-coverage
+// FUZZER-SAME: "-fsanitize=fuzzer,fuzzer-no-link"
+// FUZZER: "/usr/bin/ld"
+// FUZZER-MIPS64-SAME:          "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.fuzzer-mips64.a"
+// FUZZER-MIPS64-SAME:          "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_standalone-mips64.a"
+// FUZZER-PURECAP-MIPS64-SAME:  "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.fuzzer-mips64c128.a"
+// FUZZER-PURECAP-MIPS64-SAME:  "[[RESOURCE_DIR]]/lib/freebsd/libclang_rt.ubsan_standalone-mips64c128.a"

compiler-rt/cmake/Modules/AddCompilerRT.cmake

@@ -120,6 +120,9 @@ endfunction()
 
 macro(set_output_name output name arch)
   if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR)
+    if (COMPILER_RT_IS_CHERI_PURECAP)
+      message(FATAL_ERROR "LLVM_ENABLE_PER_TARGET_RUNTIME_DIR is incompatible with purecap runtimes")
+    endif()
     set(${output} ${name})
   else()
     if(ANDROID AND ${arch} STREQUAL "i386")

compiler-rt/cmake/Modules/CompilerRTUtils.cmake

@@ -152,6 +152,7 @@ macro(test_target_arch arch def)
 endmacro()
 
 macro(detect_target_arch)
+  check_symbol_exists(__CHERI_PURE_CAPABILITY__ "" __CHERI_PURECAP)
   check_symbol_exists(__arm__ "" __ARM)
   check_symbol_exists(__aarch64__ "" __AARCH64)
   check_symbol_exists(__x86_64__ "" __X86_64)
@@ -183,7 +184,11 @@ macro(detect_target_arch)
   elseif(__I386)
     add_default_target_arch(i386)
   elseif(__MIPS64) # must be checked before __MIPS
-    add_default_target_arch(mips64)
+    if (__CHERI_PURECAP)
+      add_default_target_arch(mips64c128)
+    else()
+      add_default_target_arch(mips64)
+    endif()
   elseif(__MIPS)
     add_default_target_arch(mips)
   elseif(__PPC64) # must be checked before __PPC
@@ -194,9 +199,17 @@ macro(detect_target_arch)
     add_default_target_arch(powerpc)
   elseif(__RISCV)
     if(CMAKE_SIZEOF_VOID_P EQUAL "4")
-      add_default_target_arch(riscv32)
+      if (__CHERI_PURECAP)
+        add_default_target_arch(riscv32c)
+      else()
+        add_default_target_arch(riscv32)
+      endif()
     elseif(CMAKE_SIZEOF_VOID_P EQUAL "8")
-      add_default_target_arch(riscv64)
+      if (__CHERI_PURECAP)
+        add_default_target_arch(riscv64c)
+      else()
+        add_default_target_arch(riscv64)
+      endif()
     else()
       message(FATAL_ERROR "Unsupport XLEN for RISC-V")
     endif()
@@ -425,9 +438,12 @@ macro(construct_compiler_rt_default_triple)
       message(FATAL_ERROR "COMPILER_RT_DEFAULT_TARGET_TRIPLE isn't supported when building for default target only")
     endif()
     set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${CMAKE_C_COMPILER_TARGET})
+    check_symbol_exists(__CHERI_PURE_CAPABILITY__ "" COMPILER_RT_DEFAULT_TARGET_TRIPLE_IS_PURECAP)
   else()
     set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${TARGET_TRIPLE} CACHE STRING
           "Default triple for which compiler-rt runtimes will be built.")
+    set(COMPILER_RT_DEFAULT_TARGET_TRIPLE_IS_PURECAP OFF CACHE BOOL
+          "Whether the default target triple is purecap.")
   endif()
 
   if(DEFINED COMPILER_RT_TEST_TARGET_TRIPLE)
@@ -438,13 +454,24 @@ macro(construct_compiler_rt_default_triple)
 
   string(REPLACE "-" ";" TARGET_TRIPLE_LIST ${COMPILER_RT_DEFAULT_TARGET_TRIPLE})
   list(GET TARGET_TRIPLE_LIST 0 COMPILER_RT_DEFAULT_TARGET_ARCH)
+  message(STATUS "COMPILER_RT_DEFAULT_TARGET_ARCH inferred as ${COMPILER_RT_DEFAULT_TARGET_ARCH}")
 
   # Map various forms of the architecture names to the canonical forms
   # (as they are used by clang, see getArchNameForCompilerRTLib).
   if("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "^i.86$")
     # Android uses i686, but that's remapped at a later stage.
     set(COMPILER_RT_DEFAULT_TARGET_ARCH "i386")
   endif()
+  if (COMPILER_RT_DEFAULT_TARGET_TRIPLE_IS_PURECAP)
+    message(STATUS "Updating default target arch (${COMPILER_RT_DEFAULT_TARGET_ARCH}) for purecap...")
+    if (COMPILER_RT_DEFAULT_TARGET_ARCH MATCHES "^mips")
+      math(EXPR _cap_size "${CMAKE_SIZEOF_VOID_P} * 8" OUTPUT_FORMAT DECIMAL)
+      set(COMPILER_RT_DEFAULT_TARGET_ARCH "${COMPILER_RT_DEFAULT_TARGET_ARCH}c${_cap_size}")
+    else()
+      set(COMPILER_RT_DEFAULT_TARGET_ARCH "${COMPILER_RT_DEFAULT_TARGET_ARCH}c")
+    endif()
+    message(STATUS "Updated default target arch is ${COMPILER_RT_DEFAULT_TARGET_ARCH}")
+  endif()
 
   # Determine if test target triple is specified explicitly, and doesn't match the
   # default.

compiler-rt/cmake/base-config-ix.cmake

@@ -227,6 +227,7 @@ macro(test_targets)
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "mips")
       test_target_arch(mips "" "-mips32r2" "-mabi=32" "-D_LARGEFILE_SOURCE" "-D_FILE_OFFSET_BITS=64")
       test_target_arch(mips64 "" "-mips64r2" "-mabi=64")
+      test_target_arch(mips64c128 "__CHERI_PURE_CAPABILITY__" "-mcpu=beri" "-mabi=purecap" "-cheri=128")
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "arm")
       if(WIN32)
         test_target_arch(arm "" "" "")
@@ -241,8 +242,10 @@ macro(test_targets)
       test_target_arch(aarch64 "" "-march=armv8-a")
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "riscv32")
       test_target_arch(riscv32 "" "")
+      test_target_arch(riscv32c "__CHERI_PURE_CAPABILITY__" "-mabi=il32pc64")
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "riscv64")
       test_target_arch(riscv64 "" "")
+      test_target_arch(riscv64c "__CHERI_PURE_CAPABILITY__" "-mabi=l64pc128")
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "wasm32")
       test_target_arch(wasm32 "" "--target=wasm32-unknown-unknown")
     elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" MATCHES "wasm64")

compiler-rt/cmake/builtin-config-ix.cmake

@@ -47,7 +47,9 @@ set(MIPS_CHERI_PURECAP mips64c128)
 set(PPC32 powerpc)
 set(PPC64 powerpc64 powerpc64le)
 set(RISCV32 riscv32)
+set(RISCV32_PURECAP riscv32c)
 set(RISCV64 riscv64)
+set(RISCV64_PURECAP riscv64c)
 set(SPARC sparc)
 set(SPARCV9 sparcv9)
 set(WASM32 wasm32)
@@ -63,7 +65,7 @@ endif()
 set(ALL_BUILTIN_SUPPORTED_ARCH
   ${X86} ${X86_64} ${ARM32} ${ARM64}
   ${HEXAGON} ${MIPS32} ${MIPS64} ${MIPS_CHERI_PURECAP} ${PPC32} ${PPC64}
-  ${RISCV32} ${RISCV64} ${SPARC} ${SPARCV9}
+  ${RISCV32} ${RISCV32_PURECAP} ${RISCV64} ${RISCV64_PURECAP} ${SPARC} ${SPARCV9}
   ${WASM32} ${WASM64} ${VE})
 
 include(CompilerRTUtils)

compiler-rt/cmake/config-ix.cmake

@@ -120,6 +120,7 @@ check_cxx_compiler_flag(/wd4800 COMPILER_RT_HAS_WD4800_FLAG)
 
 # Symbols.
 check_symbol_exists(__func__ "" COMPILER_RT_HAS_FUNC_SYMBOL)
+check_symbol_exists(__CHERI_PURE_CAPABILITY__ "" COMPILER_RT_IS_CHERI_PURECAP)
 
 # Includes.
 check_cxx_compiler_flag(-nostdinc++ COMPILER_RT_HAS_NOSTDINCXX_FLAG)
@@ -192,8 +193,9 @@ file(WRITE ${SIMPLE_SOURCE} "#include <stdlib.h>\n#include <stdio.h>\nint main()
 # Detect whether the current target platform is 32-bit or 64-bit, and setup
 # the correct commandline flags needed to attempt to target 32-bit and 64-bit.
 if (NOT CMAKE_SIZEOF_VOID_P EQUAL 4 AND
-    NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
-  message(WARNING "Please use architecture with 4 or 8 byte pointers.")
+    NOT CMAKE_SIZEOF_VOID_P EQUAL 8 AND
+    NOT COMPILER_RT_IS_CHERI_PURECAP)
+  message(FATAL_ERROR "Please use architecture with 4 or 8 byte pointers.")
 endif()
 
 test_targets()
@@ -282,7 +284,9 @@ set(MIPS_CHERI_PURECAP mips64c128)
 set(PPC32 powerpc)
 set(PPC64 powerpc64 powerpc64le)
 set(RISCV32 riscv32)
+set(RISCV32_PURECAP riscv32c)
 set(RISCV64 riscv64)
+set(RISCV64_PURECAP riscv64c)
 set(S390X s390x)
 set(SPARC sparc)
 set(SPARCV9 sparcv9)
@@ -296,7 +300,7 @@ if(APPLE)
   set(X86_64 x86_64 x86_64h)
 endif()
 
-set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64} ${RISCV64}
+set(ALL_SANITIZER_COMMON_SUPPORTED_ARCH ${X86} ${X86_64} ${PPC64} ${RISCV64} ${RISCV64_PURECAP}
     ${ARM32} ${ARM64} ${MIPS32} ${MIPS64} ${MIPS_CHERI_PURECAP} ${S390X} ${SPARC} ${SPARCV9})
 set(ALL_ASAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
     ${MIPS32} ${MIPS64} ${PPC64} ${S390X} ${SPARC} ${SPARCV9})
@@ -331,7 +335,7 @@ set(ALL_MEMPROF_SUPPORTED_ARCH ${X86_64})
 set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC32} ${PPC64}
     ${MIPS32} ${MIPS64} ${S390X} ${SPARC} ${SPARCV9})
 set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64} ${S390X})
-set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64}
+set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${RISCV64} ${RISCV64_PURECAP}
     ${MIPS32} ${MIPS64} ${MIPS_CHERI_PURECAP} ${PPC64} ${S390X} ${SPARC} ${SPARCV9})
 set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64} ${MIPS32} ${MIPS64})
 set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${MIPS64})

compiler-rt/lib/builtins/CMakeLists.txt

@@ -606,7 +606,6 @@ set(mips64_SOURCES ${GENERIC_TF_SOURCES}
 set(mips64el_SOURCES ${GENERIC_TF_SOURCES}
                      ${mips_SOURCES})
 set(mips64c128_SOURCES ${GENERIC_TF_SOURCES} ${mips_SOURCES})
-set(mips64c256_SOURCES ${GENERIC_TF_SOURCES} ${mips_SOURCES})
 
 
 set(powerpc_SOURCES ${GENERIC_SOURCES})
@@ -645,10 +644,15 @@ set(riscv32_SOURCES
   riscv/mulsi3.S
   ${riscv_SOURCES}
 )
+set(riscv32c_SOURCES ${riscv64_SOURCES})
 set(riscv64_SOURCES
   riscv/muldi3.S
   ${riscv_SOURCES}
 )
+set(riscv64c_SOURCES ${riscv64_SOURCES})
+# save.S and restore.S need https://github.com/CTSRD-CHERI/llvm-project/pull/533
+list(REMOVE_ITEM riscv32c_SOURCES riscv/save.S riscv/restore.S)
+list(REMOVE_ITEM riscv64c_SOURCES riscv/save.S riscv/restore.S)
 
 set(sparc_SOURCES ${GENERIC_SOURCES} ${GENERIC_TF_SOURCES})
 set(sparcv9_SOURCES ${GENERIC_SOURCES} ${GENERIC_TF_SOURCES})

compiler-rt/lib/builtins/emutls.c

@@ -54,7 +54,11 @@ static pthread_key_t emutls_pthread_key;
 static bool emutls_key_created = false;
 
 typedef unsigned int gcc_word __attribute__((mode(word)));
+#ifdef __CHERI_PURE_CAPABILITY__
+typedef uintptr_t gcc_pointer;
+#else
 typedef unsigned int gcc_pointer __attribute__((mode(pointer)));
+#endif
 
 // Default is not to use posix_memalign, so systems like Android
 // can use thread local data without heavier POSIX memory allocators.

compiler-rt/lib/sanitizer_common/sanitizer_allocator_checks.h

@@ -52,13 +52,13 @@ inline bool CheckAlignedAllocAlignmentAndSize(usize alignment, usize size) {
 
 // Checks posix_memalign() parameters, verifies that alignment is a power of two
 // and a multiple of sizeof(void *).
-inline bool CheckPosixMemalignAlignment(uptr alignment) {
+inline bool CheckPosixMemalignAlignment(usize alignment) {
   return alignment != 0 && IsPowerOfTwo(alignment) &&
          (alignment % sizeof(void *)) == 0;
 }
 
 // Returns true if calloc(size, n) call overflows on size*n calculation.
-inline bool CheckForCallocOverflow(uptr size, uptr n) {
+inline bool CheckForCallocOverflow(usize size, usize n) {
   if (!size)
     return false;
   usize max = (usize)-1L;
@@ -67,7 +67,7 @@ inline bool CheckForCallocOverflow(uptr size, uptr n) {
 
 // Returns true if the size passed to pvalloc overflows when rounded to the next
 // multiple of page_size.
-inline bool CheckForPvallocOverflow(uptr size, uptr page_size) {
+inline bool CheckForPvallocOverflow(usize size, usize page_size) {
   return RoundUpTo(size, page_size) < size;
 }
 

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary64.h

@@ -859,7 +859,7 @@ class SizeClassAllocator64 {
   void MaybeReleaseToOS(MemoryMapperT *memory_mapper, uptr class_id,
                         bool force) {
     RegionInfo *region = GetRegionInfo(class_id);
-    const uptr chunk_size = ClassIdToSize(class_id);
+    const usize chunk_size = ClassIdToSize(class_id);
     const uptr page_size = GetPageSizeCached();
 
     uptr n = region->num_freed_chunks;

compiler-rt/lib/sanitizer_common/sanitizer_allocator_secondary.h

@@ -54,7 +54,7 @@ class LargeMmapAllocatorPtrArrayDynamic {
   static const int kMaxNumChunks = 1 << 20;
   static const int kChunksBlockCount = 1 << 14;
   ReservedAddressRange address_range_;
-  uptr n_reserved_;
+  usize n_reserved_;
 };
 
 #if SANITIZER_WORDSIZE == 32

compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang.h

@@ -58,16 +58,12 @@ inline typename T::Type atomic_fetch_sub(volatile T *a,
   return __sync_fetch_and_add(&a->val_dont_use, -v);
 }
 
-template<typename T>
-inline typename T::Type atomic_exchange(volatile T *a,
-    typename T::Type v, memory_order mo) {
+template <typename T>
+ALWAYS_INLINE typename T::Type atomic_exchange(volatile T *a,
+                                               typename T::Type v,
+                                               memory_order mo) {
   DCHECK(!((vaddr)a % sizeof(*a)));
-  if (mo & (memory_order_release | memory_order_acq_rel | memory_order_seq_cst))
-    __sync_synchronize();
-  v = __sync_lock_test_and_set(&a->val_dont_use, v);
-  if (mo == memory_order_seq_cst)
-    __sync_synchronize();
-  return v;
+  return __atomic_exchange_n(&a->val_dont_use, v, mo);
 }
 
 template <typename T>

compiler-rt/lib/sanitizer_common/sanitizer_common.cpp

@@ -273,7 +273,7 @@ usize ReadBinaryNameCached(/*out*/char *buf, usize buf_len) {
   return name_len;
 }
 
-uptr ReadBinaryDir(/*out*/ char *buf, uptr buf_len) {
+usize ReadBinaryDir(/*out*/ char *buf, usize buf_len) {
   ReadBinaryNameCached(buf, buf_len);
   const char *exec_name_pos = StripModuleName(buf);
   uptr name_len = exec_name_pos - buf;