[llvm-branch-commits] [clang] [Clang] Add -fsanitize=daddress for Device AddressSanitizer (PR #242444)

Joseph Huber via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Sat Nov 14 11:34:00 PST 2026


https://github.com/jhuber6 updated https://github.com/llvm/llvm-project/pull/242444

>From 1be8b47a54548f913a96ec07ee7f5cb7e0ab84a5 Mon Sep 17 00:00:00 2001
From: Joseph Huber <huberjn at outlook.com>
Date: Thu, 12 Nov 2026 17:38:08 -0600
Subject: [PATCH 1/2] [Clang] Add -fsanitize=daddress for Device
 AddressSanitizer

Wire the sanitizer through the driver, codegen, and preprocessor. Emit
sanitize_device_address, run the dasan pass, and link the dasan runtime
on AMDGPU offload and supported Linux hosts.

RFC: https://discourse.llvm.org/t/rfc-add-a-device-address-sanitizer-for-gpus-dasan/92710
---
 clang/include/clang/Basic/Features.def        |  2 +
 clang/include/clang/Basic/Sanitizers.def      |  3 +
 clang/include/clang/Driver/SanitizerArgs.h    |  3 +
 clang/lib/CodeGen/BackendUtil.cpp             |  8 ++
 clang/lib/CodeGen/CGDeclCXX.cpp               |  4 +
 clang/lib/CodeGen/CodeGenFunction.cpp         |  2 +
 clang/lib/Driver/SanitizerArgs.cpp            |  5 ++
 clang/lib/Driver/ToolChains/AMDGPU.cpp        | 10 ++-
 clang/lib/Driver/ToolChains/Clang.cpp         |  5 ++
 clang/lib/Driver/ToolChains/CommonArgs.cpp    | 13 +++
 clang/lib/Driver/ToolChains/HIPAMD.cpp        |  5 ++
 clang/lib/Driver/ToolChains/Linux.cpp         |  2 +
 clang/lib/Frontend/InitPreprocessor.cpp       |  2 +
 .../lib/Headers/__clang_hip_runtime_wrapper.h |  6 +-
 clang/test/CodeGen/dasan-new-pm.c             | 43 ++++++++++
 .../CodeGen/sanitize-device-address-attr.cpp  | 53 +++++++++++++
 .../lib/amdgpu-amd-amdhsa/libclang_rt.dasan.a |  0
 .../libclang_rt.dasan-preinit.a               |  0
 .../libclang_rt.dasan.a                       |  0
 .../test/Driver/fsanitize-daddress-offload.c  | 79 +++++++++++++++++++
 clang/test/Driver/fsanitize-daddress.c        | 43 ++++++++++
 .../Lexer/has_feature_address_sanitizer.cpp   | 14 ++++
 .../test/Preprocessor/sanitizer-predefines.c  |  3 +
 23 files changed, 301 insertions(+), 4 deletions(-)
 create mode 100644 clang/test/CodeGen/dasan-new-pm.c
 create mode 100644 clang/test/CodeGen/sanitize-device-address-attr.cpp
 create mode 100644 clang/test/Driver/Inputs/resource_dir_with_amdgpu_per_target_subdir/lib/amdgpu-amd-amdhsa/libclang_rt.dasan.a
 create mode 100644 clang/test/Driver/Inputs/resource_dir_with_amdgpu_per_target_subdir/lib/x86_64-unknown-linux-gnu/libclang_rt.dasan-preinit.a
 create mode 100644 clang/test/Driver/Inputs/resource_dir_with_amdgpu_per_target_subdir/lib/x86_64-unknown-linux-gnu/libclang_rt.dasan.a
 create mode 100644 clang/test/Driver/fsanitize-daddress-offload.c
 create mode 100644 clang/test/Driver/fsanitize-daddress.c

diff --git a/clang/include/clang/Basic/Features.def b/clang/include/clang/Basic/Features.def
index cfd5bf69f938cf..16ad573db1cae2 100644
--- a/clang/include/clang/Basic/Features.def
+++ b/clang/include/clang/Basic/Features.def
@@ -40,6 +40,8 @@ FEATURE(speculative_load_hardening, LangOpts.SpeculativeLoadHardening)
 FEATURE(address_sanitizer,
         LangOpts.Sanitize.hasOneOf(SanitizerKind::Address |
                                    SanitizerKind::KernelAddress))
+FEATURE(device_address_sanitizer,
+        LangOpts.Sanitize.has(SanitizerKind::DeviceAddress))
 FEATURE(leak_sanitizer,
         LangOpts.Sanitize.has(SanitizerKind::Leak))
 FEATURE(hwaddress_sanitizer,
diff --git a/clang/include/clang/Basic/Sanitizers.def b/clang/include/clang/Basic/Sanitizers.def
index 8120c5842919b4..e749b2416bce85 100644
--- a/clang/include/clang/Basic/Sanitizers.def
+++ b/clang/include/clang/Basic/Sanitizers.def
@@ -201,6 +201,9 @@ SANITIZER("alloc-token", AllocToken)
 // ConcurrencySanitizer.
 SANITIZER("concurrency", Concurrency)
 
+// Device AddressSanitizer, for memory accessed by offloading devices.
+SANITIZER("daddress", DeviceAddress)
+
 // Magic group, containing all sanitizers. For example, "-fno-sanitize=all"
 // can be used to disable all the sanitizers.
 SANITIZER_GROUP("all", All, ~SanitizerMask())
diff --git a/clang/include/clang/Driver/SanitizerArgs.h b/clang/include/clang/Driver/SanitizerArgs.h
index 145df2d94c61f3..ffbb36a3fdd665 100644
--- a/clang/include/clang/Driver/SanitizerArgs.h
+++ b/clang/include/clang/Driver/SanitizerArgs.h
@@ -133,6 +133,9 @@ class SanitizerArgs {
     return Sanitizers.has(SanitizerKind::NumericalStability);
   }
   bool needsRtsanRt() const { return Sanitizers.has(SanitizerKind::Realtime); }
+  bool needsDasanRt() const {
+    return Sanitizers.has(SanitizerKind::DeviceAddress);
+  }
 
   bool hasMemTag() const {
     return hasMemtagHeap() || hasMemtagStack() || hasMemtagGlobals();
diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
index efe92ed8a83276..10c1c4f7b66f04 100644
--- a/clang/lib/CodeGen/BackendUtil.cpp
+++ b/clang/lib/CodeGen/BackendUtil.cpp
@@ -82,6 +82,7 @@
 #include "llvm/Transforms/Instrumentation/ConcurrencySanitizer.h"
 #include "llvm/Transforms/Instrumentation/CopyProf.h"
 #include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h"
+#include "llvm/Transforms/Instrumentation/DeviceAddressSanitizer.h"
 #include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
 #include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
 #include "llvm/Transforms/Instrumentation/InstrProfiling.h"
@@ -722,6 +723,13 @@ static void addSanitizers(const Triple &TargetTriple,
     if (LangOpts.Sanitize.has(SanitizerKind::Realtime))
       MPM.addPass(RealtimeSanitizerPass());
 
+    if (LangOpts.Sanitize.has(SanitizerKind::DeviceAddress)) {
+      DeviceAddressSanitizerOptions Opts;
+      Opts.Recover =
+          CodeGenOpts.SanitizeRecover.has(SanitizerKind::DeviceAddress);
+      MPM.addPass(DeviceAddressSanitizerPass(Opts));
+    }
+
     auto ASanPass = [&](SanitizerMask Mask, bool CompileKernel) {
       if (LangOpts.Sanitize.has(Mask)) {
         bool UseGlobalGC = asanUseGlobalsGC(TargetTriple, CodeGenOpts);
diff --git a/clang/lib/CodeGen/CGDeclCXX.cpp b/clang/lib/CodeGen/CGDeclCXX.cpp
index 2b6bd17e278b5d..1867c2880c11a6 100644
--- a/clang/lib/CodeGen/CGDeclCXX.cpp
+++ b/clang/lib/CodeGen/CGDeclCXX.cpp
@@ -476,6 +476,10 @@ llvm::Function *CodeGenModule::CreateGlobalInitOrCleanUpFunction(
       !isInNoSanitizeList(SanitizerKind::KernelHWAddress, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
 
+  if (getLangOpts().Sanitize.has(SanitizerKind::DeviceAddress) &&
+      !isInNoSanitizeList(SanitizerKind::DeviceAddress, Fn, Loc))
+    Fn->addFnAttr(llvm::Attribute::SanitizeDeviceAddress);
+
   if (getLangOpts().Sanitize.has(SanitizerKind::MemtagStack) &&
       !isInNoSanitizeList(SanitizerKind::MemtagStack, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
index 33434526d86325..078215bf8e7925 100644
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -824,6 +824,8 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
     if (SanOpts.hasOneOf(SanitizerKind::HWAddress |
                          SanitizerKind::KernelHWAddress))
       Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
+    if (SanOpts.has(SanitizerKind::DeviceAddress))
+      Fn->addFnAttr(llvm::Attribute::SanitizeDeviceAddress);
     if (SanOpts.has(SanitizerKind::MemtagStack))
       Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
     if (SanOpts.has(SanitizerKind::Thread))
diff --git a/clang/lib/Driver/SanitizerArgs.cpp b/clang/lib/Driver/SanitizerArgs.cpp
index 7b46553d035b5b..aafb25e3b2b34c 100644
--- a/clang/lib/Driver/SanitizerArgs.cpp
+++ b/clang/lib/Driver/SanitizerArgs.cpp
@@ -777,6 +777,11 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC,
                      SanitizerKind::Address | SanitizerKind::Thread |
                          SanitizerKind::Undefined | SanitizerKind::Memory |
                          SanitizerKind::Type),
+      // TODO: Need to split the runtime to support this.
+      std::make_pair(SanitizerKind::DeviceAddress,
+                     SanitizerKind::Address | SanitizerKind::Thread |
+                         SanitizerKind::Undefined | SanitizerKind::Memory |
+                         SanitizerKind::Type | SanitizerKind::Realtime),
       std::make_pair(SanitizerKind::AllocToken,
                      SanitizerKind::Address | SanitizerKind::HWAddress |
                          SanitizerKind::KernelAddress |
diff --git a/clang/lib/Driver/ToolChains/AMDGPU.cpp b/clang/lib/Driver/ToolChains/AMDGPU.cpp
index 47c36ee18d2272..4a7e3314797720 100644
--- a/clang/lib/Driver/ToolChains/AMDGPU.cpp
+++ b/clang/lib/Driver/ToolChains/AMDGPU.cpp
@@ -655,6 +655,9 @@ void amdgpu::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   addLinkerCompressDebugSectionsOption(getToolChain(), Args, CmdArgs);
   getToolChain().AddFilePathLibArgs(Args, CmdArgs);
   Args.AddAllArgs(CmdArgs, options::OPT_L);
+  // FIXME: Device ASan is provided by the ROCm device library, not compiler-rt.
+  if (!getToolChain().getSanitizerArgs(Args).needsAsanRt())
+    addSanitizerRuntimes(getToolChain(), Args, CmdArgs, C);
   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
 
   // Always pass the target-id features to the LTO job.
@@ -667,9 +670,6 @@ void amdgpu::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   }
 
   getToolChain().addProfileRTLibs(Args, CmdArgs);
-  // FIXME: Device ASan is provided by the ROCm device library, not compiler-rt.
-  if (!getToolChain().getSanitizerArgs(Args).needsAsanRt())
-    addSanitizerRuntimes(getToolChain(), Args, CmdArgs, C);
 
   if (Args.hasArg(options::OPT_stdlib))
     CmdArgs.append({"-lc", "-lm"});
@@ -1397,6 +1397,10 @@ SanitizerMask AMDGPUToolChain::getSupportedSanitizers(
   if (getTriple().isAMDGCN() && getTriple().getOS() == llvm::Triple::AMDHSA)
     SupportedMask |= SanitizerKind::Concurrency;
 
+  // The device sanitizer is supported on all HSA devices.
+  if (getTriple().isAMDGCN())
+    SupportedMask |= SanitizerKind::DeviceAddress;
+
   return SupportedMask;
 }
 
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index 10d98badf09816..99df046be9678c 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -9916,6 +9916,11 @@ void LinkerWrapper::ConstructJob(Compilation &C, const JobAction &JA,
     // Without this check using it on the host would result in linker errors.
     if (requiresUBSanRT(ID) && !HasSanitizerRT)
       return false;
+    // The device sanitizer has a runtime of its own on this side, which the
+    // device link asks for by the same lookup the host one uses.
+    if (requiresUBSanRT(ID) && TC.getSanitizerArgs(Args).needsDasanRt() &&
+        !ToolChainHasRT(TC, "dasan"))
+      return false;
     // Don't forward -mllvm to toolchains that don't support LLVM.
     return TC.HasNativeLLVMSupport() || ID != OPT_mllvm;
   };
diff --git a/clang/lib/Driver/ToolChains/CommonArgs.cpp b/clang/lib/Driver/ToolChains/CommonArgs.cpp
index 70218bd6f11d7a..7e2b2b37bfba5b 100644
--- a/clang/lib/Driver/ToolChains/CommonArgs.cpp
+++ b/clang/lib/Driver/ToolChains/CommonArgs.cpp
@@ -1695,6 +1695,11 @@ static bool hostNeedsCsanOffloadRt(Compilation &C, const ToolChain &HostTC) {
       C, HostTC, [](const SanitizerArgs &S) { return S.needsCsanRt(); });
 }
 
+static bool hostNeedsDasanRt(Compilation &C, const ToolChain &HostTC) {
+  return hostNeedsOffloadRt(
+      C, HostTC, [](const SanitizerArgs &S) { return S.needsDasanRt(); });
+}
+
 static void
 collectSanitizerRuntimes(Compilation &C, const ToolChain &TC,
                          const ArgList &Args,
@@ -1709,6 +1714,7 @@ collectSanitizerRuntimes(Compilation &C, const ToolChain &TC,
   const bool NeedsCsanOffloadRt = hostNeedsCsanOffloadRt(C, TC);
   const bool NeedsUbsanRt = SanArgs.needsUbsanRt() || NeedsUbsanOffloadRt;
   const bool NeedsCsanRt = SanArgs.needsCsanRt() || NeedsCsanOffloadRt;
+  const bool NeedsDasanRt = SanArgs.needsDasanRt() || hostNeedsDasanRt(C, TC);
   // Collect shared runtimes.
   if (SanArgs.needsSharedRt()) {
     if (SanArgs.needsAsanRt()) {
@@ -1729,6 +1735,8 @@ collectSanitizerRuntimes(Compilation &C, const ToolChain &TC,
       else
         SharedRuntimes.push_back("ubsan_standalone");
     }
+    if (NeedsDasanRt && !TC.getTriple().isGPU())
+      SharedRuntimes.push_back("dasan");
     if (SanArgs.needsScudoRt()) {
       SharedRuntimes.push_back("scudo_standalone");
     }
@@ -1772,6 +1780,9 @@ collectSanitizerRuntimes(Compilation &C, const ToolChain &TC,
   }
   if (NeedsCsanOffloadRt && !Args.hasArg(options::OPT_shared))
     HelperStaticRuntimes.push_back("csan_offload-preinit");
+  if (NeedsDasanRt && !TC.getTriple().isGPU() &&
+      !Args.hasArg(options::OPT_shared))
+    HelperStaticRuntimes.push_back("dasan-preinit");
 
   // Collect static runtimes.
   if (Args.hasArg(options::OPT_shared)) {
@@ -1838,6 +1849,8 @@ collectSanitizerRuntimes(Compilation &C, const ToolChain &TC,
   }
   if (!SanArgs.needsSharedRt() && SanArgs.needsTysanRt())
     StaticRuntimes.push_back("tysan");
+  if (NeedsDasanRt && (!SanArgs.needsSharedRt() || TC.getTriple().isGPU()))
+    StaticRuntimes.push_back("dasan");
   if (!SanArgs.needsSharedRt() && NeedsUbsanRt) {
     if (SanArgs.requiresMinimalRuntime()) {
       StaticRuntimes.push_back("ubsan_minimal");
diff --git a/clang/lib/Driver/ToolChains/HIPAMD.cpp b/clang/lib/Driver/ToolChains/HIPAMD.cpp
index 0f6d7d15a3f31c..4947f48fddb90d 100644
--- a/clang/lib/Driver/ToolChains/HIPAMD.cpp
+++ b/clang/lib/Driver/ToolChains/HIPAMD.cpp
@@ -130,6 +130,11 @@ void AMDGCN::Linker::constructLldCommand(Compilation &C, const JobAction &JA,
     LldArgs.push_back(Input.getFilename());
   TC.addProfileRTLibs(Args, LldArgs);
 
+  // Link the sanitizer runtimes for the standalone LLD invocation.
+  if (TC.getSanitizerArgs(Args).needsDasanRt())
+    LldArgs.push_back(
+        TC.getCompilerRTArgString(Args, "dasan", ToolChain::FT_Static));
+
   LldArgs.push_back("--no-whole-archive");
 
   const char *Lld = Args.MakeArgStringRef(getToolChain().GetProgramPath("lld"));
diff --git a/clang/lib/Driver/ToolChains/Linux.cpp b/clang/lib/Driver/ToolChains/Linux.cpp
index b9d008566e36b6..2812a713860ec5 100644
--- a/clang/lib/Driver/ToolChains/Linux.cpp
+++ b/clang/lib/Driver/ToolChains/Linux.cpp
@@ -1034,6 +1034,8 @@ Linux::getSupportedSanitizers(BoundArch BA,
     Res |= SanitizerKind::Concurrency;
   if (IsX86_64 || IsAArch64 || IsSystemZ || IsHexagon)
     Res |= SanitizerKind::Type;
+  if (IsX86_64 || IsAArch64 || IsPowerPC64)
+    Res |= SanitizerKind::DeviceAddress;
   if (IsX86_64 || IsSystemZ || IsPowerPC64)
     Res |= SanitizerKind::KernelMemory;
   if (IsX86_64 || IsMIPS64 || IsAArch64 || IsX86 || IsMIPS || IsArmArch ||
diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp
index 3e22b6e64676cc..becef32d6a2410 100644
--- a/clang/lib/Frontend/InitPreprocessor.cpp
+++ b/clang/lib/Frontend/InitPreprocessor.cpp
@@ -1538,6 +1538,8 @@ static void InitializePredefinedMacros(const TargetInfo &TI,
   if (LangOpts.Sanitize.hasOneOf(SanitizerKind::HWAddress |
                                  SanitizerKind::KernelHWAddress))
     Builder.defineMacro("__SANITIZE_HWADDRESS__");
+  if (LangOpts.Sanitize.has(SanitizerKind::DeviceAddress))
+    Builder.defineMacro("__SANITIZE_DEVICE_ADDRESS__");
   if (LangOpts.Sanitize.has(SanitizerKind::Thread))
     Builder.defineMacro("__SANITIZE_THREAD__");
   if (LangOpts.Sanitize.has(SanitizerKind::Concurrency))
diff --git a/clang/lib/Headers/__clang_hip_runtime_wrapper.h b/clang/lib/Headers/__clang_hip_runtime_wrapper.h
index 75c61b33190948..fc26874d244d70 100644
--- a/clang/lib/Headers/__clang_hip_runtime_wrapper.h
+++ b/clang/lib/Headers/__clang_hip_runtime_wrapper.h
@@ -44,7 +44,11 @@ typedef __SIZE_TYPE__ __hip_size_t;
 extern "C" {
 #endif //__cplusplus
 
-#if HIP_VERSION_MAJOR * 100 + HIP_VERSION_MINOR >= 405
+#if __has_feature(device_address_sanitizer)
+// Defined by the device sanitizer runtime.
+__device__ void *malloc(__hip_size_t __size);
+__device__ void free(void *__ptr);
+#elif HIP_VERSION_MAJOR * 100 + HIP_VERSION_MINOR >= 405
 __device__ unsigned long long __ockl_dm_alloc(unsigned long long __size);
 __device__ void __ockl_dm_dealloc(unsigned long long __addr);
 #if __has_feature(address_sanitizer)
diff --git a/clang/test/CodeGen/dasan-new-pm.c b/clang/test/CodeGen/dasan-new-pm.c
new file mode 100644
index 00000000000000..62aef690cb72eb
--- /dev/null
+++ b/clang/test/CodeGen/dasan-new-pm.c
@@ -0,0 +1,43 @@
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -emit-llvm -o - -fsanitize=daddress %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -emit-llvm -o - -O1 -fsanitize=daddress %s | FileCheck %s
+
+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -emit-llvm -o - -fsanitize=daddress %s | FileCheck %s
+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -emit-llvm -o - -O1 -fsanitize=daddress %s | FileCheck %s
+
+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -emit-llvm -o - -O1 -fsanitize=daddress %s | FileCheck %s --check-prefix=ABORT
+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -emit-llvm -o - -O1 -fsanitize=daddress -mllvm -dasan-trap-on-error %s | FileCheck %s --check-prefix=TRAP
+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -emit-llvm -o - -O1 -fsanitize=daddress -fsanitize-recover=daddress %s | FileCheck %s --check-prefix=RECOVER
+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -emit-llvm -o - -fsanitize=daddress %s | FileCheck %s --check-prefix=ABORT-SHARED
+
+int foo(int *a, int *b) { return *a + *b; }
+int bar(int __attribute__((address_space(3))) *s) { return *s; }
+
+// CHECK: sanitize_device_address
+// CHECK: !{i32 4, !"nosanitize_device_address", i32 1}
+
+// ABORT-LABEL: define {{.*}} @foo(
+// ABORT:       notail call void @__dasan_report_load(ptr %a, i64 4, i64 {{.*}}, i64 {{.*}}) [[SITE:#[0-9]+]]
+// ABORT-NEXT:  unreachable
+// ABORT:       notail call void @__dasan_report_load(ptr %b, i64 4, i64 {{.*}}, i64 {{.*}}) [[SITE]]
+// ABORT-NEXT:  unreachable
+// ABORT:       declare void @__dasan_report_load(ptr, i64, i64, i64) [[ATTR:#[0-9]+]]
+// ABORT:       attributes [[ATTR]] = { cold noreturn nounwind }
+// ABORT:       attributes [[SITE]] = { noinline nomerge }
+
+// TRAP:       br i1 {{.*}}, label %dasan.trap,
+// TRAP:       br i1 {{.*}}, label %dasan.trap,
+// TRAP:       dasan.trap:
+// TRAP:       call void @llvm.trap()
+// TRAP-NEXT:  unreachable
+
+// RECOVER:     notail call void @__dasan_report_load_noabort(ptr %a, {{.*}}) [[SITE:#[0-9]+]]
+// RECOVER-NOT: unreachable
+// RECOVER:     notail call void @__dasan_report_load_noabort(ptr %b, {{.*}}) [[SITE]]
+// RECOVER:     declare void @__dasan_report_load_noabort(ptr, i64, i64, i64) [[RATTR:#[0-9]+]]
+// RECOVER:     attributes [[RATTR]] = { cold nounwind }
+// RECOVER:     attributes [[SITE]] = { noinline nomerge }
+
+// Unsized LDS needs the dispatch pointer, which -O1 infers away on this TU.
+// ABORT-SHARED:      define {{.*}} @bar(
+// ABORT-SHARED:      notail call void @__dasan_report_shared_load(
+// ABORT-SHARED-NEXT: unreachable
diff --git a/clang/test/CodeGen/sanitize-device-address-attr.cpp b/clang/test/CodeGen/sanitize-device-address-attr.cpp
new file mode 100644
index 00000000000000..b71b6664ec83e2
--- /dev/null
+++ b/clang/test/CodeGen/sanitize-device-address-attr.cpp
@@ -0,0 +1,53 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux -disable-O0-optnone \
+// RUN:   -emit-llvm -o - %s | FileCheck -check-prefix=CHECK-NODASAN %s
+
+// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=daddress \
+// RUN:   -disable-O0-optnone -emit-llvm -o - %s | \
+// RUN:   FileCheck -check-prefix=CHECK-DASAN %s
+
+// RUN: %clang_cc1 -triple amdgcn-amd-amdhsa -fsanitize=daddress \
+// RUN:   -disable-O0-optnone -emit-llvm -o - %s | \
+// RUN:   FileCheck -check-prefix=CHECK-DEVICE %s
+
+// RUN: echo "fun:*NoSanitizeIgnorelisted*" > %t
+// RUN: %clang_cc1 -triple x86_64-unknown-linux -fsanitize=daddress \
+// RUN:   -fsanitize-ignorelist=%t -disable-O0-optnone -emit-llvm -o - %s | \
+// RUN:   FileCheck -check-prefix=CHECK-IGNORELIST %s
+
+int HasSanitizeDeviceAddress(int *a) { return *a; }
+// CHECK-NODASAN: {{Function Attrs: mustprogress noinline nounwind$}}
+// CHECK-DASAN: Function Attrs: mustprogress noinline nounwind sanitize_device_address
+// CHECK-DEVICE: Function Attrs: convergent mustprogress noinline nounwind sanitize_device_address
+// CHECK-IGNORELIST: Function Attrs: mustprogress noinline nounwind sanitize_device_address
+
+__attribute__((no_sanitize("daddress"))) int NoSanitizeDeviceAddress(int *a) {
+  return *a;
+}
+// CHECK-NODASAN: {{Function Attrs: mustprogress noinline nounwind$}}
+// CHECK-DASAN: {{Function Attrs: mustprogress noinline nounwind$}}
+// CHECK-DEVICE: {{Function Attrs: convergent mustprogress noinline nounwind$}}
+// CHECK-IGNORELIST: {{Function Attrs: mustprogress noinline nounwind$}}
+
+int NoSanitizeIgnorelisted(int *a) { return *a; }
+// CHECK-NODASAN: {{Function Attrs: mustprogress noinline nounwind$}}
+// CHECK-DASAN: Function Attrs: mustprogress noinline nounwind sanitize_device_address
+// CHECK-DEVICE: Function Attrs: convergent mustprogress noinline nounwind sanitize_device_address
+// CHECK-IGNORELIST: {{Function Attrs: mustprogress noinline nounwind$}}
+
+__attribute__((disable_sanitizer_instrumentation)) int NoInstrumentation(int *a) {
+  return *a;
+}
+// CHECK-NODASAN: {{Function Attrs: disable_sanitizer_instrumentation mustprogress noinline nounwind$}}
+// CHECK-DASAN: {{Function Attrs: disable_sanitizer_instrumentation mustprogress noinline nounwind$}}
+// CHECK-DEVICE: {{Function Attrs: convergent disable_sanitizer_instrumentation mustprogress noinline nounwind$}}
+// CHECK-IGNORELIST: {{Function Attrs: disable_sanitizer_instrumentation mustprogress noinline nounwind$}}
+
+int global = *(int *)0x1000;
+// CHECK-NODASAN: {{Function Attrs: noinline nounwind$}}
+// CHECK-NODASAN-NEXT: define internal void @__cxx_global_var_init()
+// CHECK-DASAN: Function Attrs: noinline nounwind sanitize_device_address
+// CHECK-DASAN-NEXT: define internal void @__cxx_global_var_init()
+// CHECK-DEVICE: Function Attrs: convergent noinline nounwind sanitize_device_address
+// CHECK-DEVICE-NEXT: define internal void @__cxx_global_var_init()
+// CHECK-IGNORELIST: Function Attrs: noinline nounwind sanitize_device_address
+// CHECK-IGNORELIST-NEXT: define internal void @__cxx_global_var_init()
diff --git a/clang/test/Driver/Inputs/resource_dir_with_amdgpu_per_target_subdir/lib/amdgpu-amd-amdhsa/libclang_rt.dasan.a b/clang/test/Driver/Inputs/resource_dir_with_amdgpu_per_target_subdir/lib/amdgpu-amd-amdhsa/libclang_rt.dasan.a
new file mode 100644
index 00000000000000..e69de29bb2d1d6
diff --git a/clang/test/Driver/Inputs/resource_dir_with_amdgpu_per_target_subdir/lib/x86_64-unknown-linux-gnu/libclang_rt.dasan-preinit.a b/clang/test/Driver/Inputs/resource_dir_with_amdgpu_per_target_subdir/lib/x86_64-unknown-linux-gnu/libclang_rt.dasan-preinit.a
new file mode 100644
index 00000000000000..e69de29bb2d1d6
diff --git a/clang/test/Driver/Inputs/resource_dir_with_amdgpu_per_target_subdir/lib/x86_64-unknown-linux-gnu/libclang_rt.dasan.a b/clang/test/Driver/Inputs/resource_dir_with_amdgpu_per_target_subdir/lib/x86_64-unknown-linux-gnu/libclang_rt.dasan.a
new file mode 100644
index 00000000000000..e69de29bb2d1d6
diff --git a/clang/test/Driver/fsanitize-daddress-offload.c b/clang/test/Driver/fsanitize-daddress-offload.c
new file mode 100644
index 00000000000000..1c98de80f20bfb
--- /dev/null
+++ b/clang/test/Driver/fsanitize-daddress-offload.c
@@ -0,0 +1,79 @@
+// RUN: %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu \
+// RUN:     -fopenmp=libomp --offload-arch=gfx908 -fsanitize=daddress -nogpuinc \
+// RUN:     --rocm-path=%S/Inputs/rocm \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_amdgpu_per_target_subdir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-OPENMP
+// CHECK-OPENMP-DAG: "--device-compiler=amdgpu-amd-amdhsa=-fsanitize=daddress"
+// CHECK-OPENMP-DAG: "--whole-archive" "{{[^"]*}}x86_64-unknown-linux-gnu{{/|\\\\}}libclang_rt.dasan-preinit.a" "--no-whole-archive"
+// CHECK-OPENMP-DAG: "--whole-archive" "{{[^"]*}}x86_64-unknown-linux-gnu{{/|\\\\}}libclang_rt.dasan.a" "--no-whole-archive"
+
+// RUN: %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu \
+// RUN:     -x hip --offload-arch=gfx908 -Xarch_device -fsanitize=daddress \
+// RUN:     -nogpuinc -nogpulib --rocm-path=%S/Inputs/rocm \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_amdgpu_per_target_subdir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-XARCH-DEV
+// CHECK-XARCH-DEV-DAG: "--whole-archive" "{{[^"]*}}x86_64-unknown-linux-gnu{{/|\\\\}}libclang_rt.dasan-preinit.a" "--no-whole-archive"
+// CHECK-XARCH-DEV-DAG: "--whole-archive" "{{[^"]*}}x86_64-unknown-linux-gnu{{/|\\\\}}libclang_rt.dasan.a" "--no-whole-archive"
+
+// RUN: %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu \
+// RUN:     -x hip --offload-arch=gfx908 -fsanitize=daddress \
+// RUN:     -fPIC -shared -nogpuinc -nogpulib --rocm-path=%S/Inputs/rocm \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_amdgpu_per_target_subdir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-SHARED
+// CHECK-SHARED-NOT: x86_64-unknown-linux-gnu{{/|\\\\}}libclang_rt.dasan
+
+// RUN: %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu \
+// RUN:     -x hip --offload-arch=gfx908 -fsanitize=daddress -shared-libsan \
+// RUN:     -nogpuinc -nogpulib --rocm-path=%S/Inputs/rocm \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_amdgpu_per_target_subdir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-SHARED-RT \
+// RUN:       --implicit-check-not=x86_64-unknown-linux-gnu{{.}}libclang_rt.dasan.a
+// RUN: %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu \
+// RUN:     -x hip --offload-arch=gfx908 -Xarch_device -fsanitize=daddress \
+// RUN:     -shared-libsan -nogpuinc -nogpulib --rocm-path=%S/Inputs/rocm \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_amdgpu_per_target_subdir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-SHARED-RT \
+// RUN:       --implicit-check-not=x86_64-unknown-linux-gnu{{.}}libclang_rt.dasan.a
+// CHECK-SHARED-RT: "{{[^"]*}}x86_64-unknown-linux-gnu{{/|\\\\}}libclang_rt.dasan.so"
+// CHECK-SHARED-RT: "--whole-archive" "{{[^"]*}}x86_64-unknown-linux-gnu{{/|\\\\}}libclang_rt.dasan-preinit.a" "--no-whole-archive"
+
+// RUN: %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu \
+// RUN:     -x hip --offload-arch=gfx908 -fsanitize=daddress -shared-libsan \
+// RUN:     -fPIC -shared -nogpuinc -nogpulib --rocm-path=%S/Inputs/rocm \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_amdgpu_per_target_subdir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-SHARED-DSO \
+// RUN:       --implicit-check-not=dasan-preinit \
+// RUN:       --implicit-check-not=x86_64-unknown-linux-gnu{{.}}libclang_rt.dasan.a
+// CHECK-SHARED-DSO: "{{[^"]*}}x86_64-unknown-linux-gnu{{/|\\\\}}libclang_rt.dasan.so"
+
+// RUN: %clang -no-canonical-prefixes -### --target=amdgcn-amd-amdhsa -mcpu=gfx908 \
+// RUN:     -nogpulib -fsanitize=daddress -Xlinker -lc \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_amdgpu_per_target_subdir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-DEVICE
+//      CHECK-DEVICE: ld.lld
+//  CHECK-DEVICE-NOT: dasan-preinit
+// CHECK-DEVICE-SAME: "--whole-archive" "{{[^"]*}}amdgpu-amd-amdhsa{{/|\\\\}}libclang_rt.dasan.a" "--no-whole-archive"
+// CHECK-DEVICE-SAME: "-lc"
+
+// RUN: %clang -no-canonical-prefixes -### --target=amdgcn-amd-amdhsa -mcpu=gfx908 \
+// RUN:     -nogpulib -fsanitize=daddress -shared-libsan -Xlinker -lc \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_amdgpu_per_target_subdir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-DEVICE --implicit-check-not=dasan.so
+
+// RUN: %clang -no-canonical-prefixes -### -x hip --offload-arch=gfx908 \
+// RUN:     --offload-device-only -fsanitize=daddress -nogpuinc -nogpulib \
+// RUN:     --rocm-path=%S/Inputs/rocm \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_amdgpu_per_target_subdir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-HIP
+//      CHECK-HIP: lld
+// CHECK-HIP-SAME: "--whole-archive"
+// CHECK-HIP-SAME: "{{[^"]*}}amdgpu-amd-amdhsa{{/|\\\\}}libclang_rt.dasan.a"
+
+// RUN: %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu \
+// RUN:     -fopenmp=libomp --offload-arch=gfx908 -fsanitize=daddress -nogpuinc \
+// RUN:     --rocm-path=%S/Inputs/rocm \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_per_target_subdir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-MISSING
+// CHECK-MISSING-NOT: "--device-compiler=amdgpu-amd-amdhsa=-fsanitize=daddress"
+
+int main(void) { return 0; }
diff --git a/clang/test/Driver/fsanitize-daddress.c b/clang/test/Driver/fsanitize-daddress.c
new file mode 100644
index 00000000000000..55e70cfc3e7019
--- /dev/null
+++ b/clang/test/Driver/fsanitize-daddress.c
@@ -0,0 +1,43 @@
+// RUN: %clang --target=x86_64-linux-gnu -fsanitize=daddress %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SUPPORTED
+// RUN: %clang --target=aarch64-linux-gnu -fsanitize=daddress %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SUPPORTED
+// RUN: %clang --target=powerpc64le-linux-gnu -fsanitize=daddress %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SUPPORTED
+// CHECK-SUPPORTED-NOT: unsupported option
+
+// RUN: %clang --target=amdgcn-amd-amdhsa -mcpu=gfx1030 -nogpulib -fsanitize=daddress %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEVICE
+// CHECK-DEVICE-NOT: unsupported option
+
+// RUN: not %clang --target=i386-pc-openbsd -fsanitize=daddress %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-OPENBSD
+// CHECK-OPENBSD: unsupported option '-fsanitize=daddress' for target 'i386-pc-openbsd'
+
+// RUN: not %clang --target=x86_64-apple-darwin -fsanitize=daddress %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DARWIN
+// CHECK-DARWIN: unsupported option '-fsanitize=daddress' for target
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=daddress,address %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN
+// CHECK-ASAN: error: invalid argument '-fsanitize=daddress' not allowed with '-fsanitize=address'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=daddress,thread %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN
+// CHECK-TSAN: error: invalid argument '-fsanitize=daddress' not allowed with '-fsanitize=thread'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=daddress,memory %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MSAN
+// CHECK-MSAN: error: invalid argument '-fsanitize=daddress' not allowed with '-fsanitize=memory'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=daddress,undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UBSAN
+// CHECK-UBSAN: error: invalid argument '-fsanitize=daddress' not allowed with '-fsanitize=undefined'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=daddress,realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN
+// CHECK-RTSAN: error: invalid argument '-fsanitize=daddress' not allowed with '-fsanitize=realtime'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=daddress,type %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TYSAN
+// CHECK-TYSAN: error: invalid argument '-fsanitize=daddress' not allowed with '-fsanitize=type'
+
+// The runtime has to be in the executable itself for its definitions to be the
+// ones the offloading runtime binds to.
+// RUN: %clang %s -### -o %t.o --target=x86_64-unknown-linux -fuse-ld=ld \
+// RUN:     -fsanitize=daddress \
+// RUN:     -resource-dir=%S/Inputs/resource_dir \
+// RUN:     --sysroot=%S/Inputs/basic_linux_tree 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-LINK
+// CHECK-LINK: "--whole-archive" "{{.*}}libclang_rt.dasan{{[^.]*}}.a" "--no-whole-archive"
+// CHECK-LINK: "-ldl"
+
+int main(void) { return 0; }
diff --git a/clang/test/Lexer/has_feature_address_sanitizer.cpp b/clang/test/Lexer/has_feature_address_sanitizer.cpp
index f8ae3643279ba7..f1c023af1cb5db 100644
--- a/clang/test/Lexer/has_feature_address_sanitizer.cpp
+++ b/clang/test/Lexer/has_feature_address_sanitizer.cpp
@@ -2,6 +2,7 @@
 // RUN: %clang_cc1 -E -fsanitize=kernel-address %s -o - | FileCheck --check-prefix=CHECK-ASAN %s
 // RUN: %clang_cc1 -E -fsanitize=hwaddress %s -o - | FileCheck --check-prefix=CHECK-HWASAN %s
 // RUN: %clang_cc1 -E -fsanitize=kernel-hwaddress %s -o - | FileCheck --check-prefix=CHECK-HWASAN %s
+// RUN: %clang_cc1 -E -fsanitize=daddress %s -o - | FileCheck --check-prefix=CHECK-DASAN %s
 // RUN: %clang_cc1 -E  %s -o - | FileCheck --check-prefix=CHECK-NO-ASAN %s
 
 #if __has_feature(address_sanitizer)
@@ -16,11 +17,24 @@ int HWAddressSanitizerEnabled();
 int HWAddressSanitizerDisabled();
 #endif
 
+#if __has_feature(device_address_sanitizer)
+int DeviceAddressSanitizerEnabled();
+#else
+int DeviceAddressSanitizerDisabled();
+#endif
+
 // CHECK-ASAN: AddressSanitizerEnabled
 // CHECK-ASAN: HWAddressSanitizerDisabled
+// CHECK-ASAN: DeviceAddressSanitizerDisabled
 
 // CHECK-HWASAN: AddressSanitizerDisabled
 // CHECK-HWASAN: HWAddressSanitizerEnabled
+// CHECK-HWASAN: DeviceAddressSanitizerDisabled
+
+// CHECK-DASAN: AddressSanitizerDisabled
+// CHECK-DASAN: HWAddressSanitizerDisabled
+// CHECK-DASAN: DeviceAddressSanitizerEnabled
 
 // CHECK-NO-ASAN: AddressSanitizerDisabled
 // CHECK-NO-ASAN: HWAddressSanitizerDisabled
+// CHECK-NO-ASAN: DeviceAddressSanitizerDisabled
diff --git a/clang/test/Preprocessor/sanitizer-predefines.c b/clang/test/Preprocessor/sanitizer-predefines.c
index cec6aa4ffee2ec..66ba5a90d871d1 100644
--- a/clang/test/Preprocessor/sanitizer-predefines.c
+++ b/clang/test/Preprocessor/sanitizer-predefines.c
@@ -11,3 +11,6 @@
 
 // RUN: %clang_cc1 -E -dM -triple aarch64-unknown-linux -fsanitize=concurrency %s | FileCheck %s --check-prefix=CSAN
 // CSAN: #define __SANITIZE_CONCURRENCY__ 1
+
+// RUN: %clang_cc1 -E -dM -triple aarch64-unknown-linux -fsanitize=daddress %s | FileCheck %s --check-prefix=DASAN
+// DASAN: #define __SANITIZE_DEVICE_ADDRESS__ 1

>From 7d74fb8a34ac175d19bc08be1421a5768c4f7ea5 Mon Sep 17 00:00:00 2001
From: Joseph Huber <huberjn at outlook.com>
Date: Sat, 14 Nov 2026 13:32:31 -0600
Subject: [PATCH 2/2] always pass dasan even w/o runtime

---
 clang/lib/Driver/SanitizerArgs.cpp            | 12 +++++++----
 clang/lib/Driver/ToolChains/Clang.cpp         | 10 ++++------
 clang/lib/Driver/ToolChains/HIPAMD.cpp        |  3 ++-
 .../test/Driver/fsanitize-daddress-offload.c  | 20 +++++++++++++++----
 clang/test/Driver/fsanitize-daddress.c        |  9 +++++++++
 5 files changed, 39 insertions(+), 15 deletions(-)

diff --git a/clang/lib/Driver/SanitizerArgs.cpp b/clang/lib/Driver/SanitizerArgs.cpp
index aafb25e3b2b34c..6cadcb825bcb3c 100644
--- a/clang/lib/Driver/SanitizerArgs.cpp
+++ b/clang/lib/Driver/SanitizerArgs.cpp
@@ -778,10 +778,14 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC,
                          SanitizerKind::Undefined | SanitizerKind::Memory |
                          SanitizerKind::Type),
       // TODO: Need to split the runtime to support this.
-      std::make_pair(SanitizerKind::DeviceAddress,
-                     SanitizerKind::Address | SanitizerKind::Thread |
-                         SanitizerKind::Undefined | SanitizerKind::Memory |
-                         SanitizerKind::Type | SanitizerKind::Realtime),
+      std::make_pair(
+          SanitizerKind::DeviceAddress,
+          SanitizerKind::Address | SanitizerKind::Thread |
+              SanitizerKind::Memory | SanitizerKind::Type |
+              SanitizerKind::Realtime | SanitizerKind::Undefined |
+              SanitizerKind::Integer | SanitizerKind::ImplicitConversion |
+              SanitizerKind::Nullability | SanitizerKind::LocalBounds |
+              SanitizerKind::FloatDivideByZero),
       std::make_pair(SanitizerKind::AllocToken,
                      SanitizerKind::Address | SanitizerKind::HWAddress |
                          SanitizerKind::KernelAddress |
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index 99df046be9678c..231b129d63de2c 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -9898,8 +9898,11 @@ void LinkerWrapper::ConstructJob(Compilation &C, const JobAction &JA,
   };
   auto ToolChainHasSanitizerRT = [&](const ToolChain &TC, const ArgList &TCArgs,
                                      Action::OffloadKind Kind) {
-    if (TC.getSanitizerArgs(TCArgs, /*BA=*/{}, Kind).needsCsanRt())
+    const SanitizerArgs &SanArgs = TC.getSanitizerArgs(TCArgs, /*BA=*/{}, Kind);
+    if (SanArgs.needsCsanRt())
       return ToolChainHasRT(TC, "csan");
+    if (SanArgs.needsDasanRt())
+      return true;
     return ToolChainHasRT(TC, "ubsan_minimal") ||
            ToolChainHasRT(TC, "ubsan_standalone");
   };
@@ -9916,11 +9919,6 @@ void LinkerWrapper::ConstructJob(Compilation &C, const JobAction &JA,
     // Without this check using it on the host would result in linker errors.
     if (requiresUBSanRT(ID) && !HasSanitizerRT)
       return false;
-    // The device sanitizer has a runtime of its own on this side, which the
-    // device link asks for by the same lookup the host one uses.
-    if (requiresUBSanRT(ID) && TC.getSanitizerArgs(Args).needsDasanRt() &&
-        !ToolChainHasRT(TC, "dasan"))
-      return false;
     // Don't forward -mllvm to toolchains that don't support LLVM.
     return TC.HasNativeLLVMSupport() || ID != OPT_mllvm;
   };
diff --git a/clang/lib/Driver/ToolChains/HIPAMD.cpp b/clang/lib/Driver/ToolChains/HIPAMD.cpp
index 4947f48fddb90d..09ec3a8efef41e 100644
--- a/clang/lib/Driver/ToolChains/HIPAMD.cpp
+++ b/clang/lib/Driver/ToolChains/HIPAMD.cpp
@@ -131,7 +131,8 @@ void AMDGCN::Linker::constructLldCommand(Compilation &C, const JobAction &JA,
   TC.addProfileRTLibs(Args, LldArgs);
 
   // Link the sanitizer runtimes for the standalone LLD invocation.
-  if (TC.getSanitizerArgs(Args).needsDasanRt())
+  const SanitizerArgs &SanArgs = TC.getSanitizerArgs(Args);
+  if (SanArgs.needsDasanRt() && SanArgs.linkRuntimes())
     LldArgs.push_back(
         TC.getCompilerRTArgString(Args, "dasan", ToolChain::FT_Static));
 
diff --git a/clang/test/Driver/fsanitize-daddress-offload.c b/clang/test/Driver/fsanitize-daddress-offload.c
index 1c98de80f20bfb..b2701d926b5c28 100644
--- a/clang/test/Driver/fsanitize-daddress-offload.c
+++ b/clang/test/Driver/fsanitize-daddress-offload.c
@@ -69,11 +69,23 @@
 // CHECK-HIP-SAME: "--whole-archive"
 // CHECK-HIP-SAME: "{{[^"]*}}amdgpu-amd-amdhsa{{/|\\\\}}libclang_rt.dasan.a"
 
+// RUN: %clang -no-canonical-prefixes -### -x hip --offload-arch=gfx908 \
+// RUN:     --offload-device-only -fsanitize=daddress -fno-sanitize-link-runtime \
+// RUN:     -nogpuinc -nogpulib --rocm-path=%S/Inputs/rocm \
+// RUN:     -resource-dir=%S/Inputs/resource_dir_with_amdgpu_per_target_subdir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-HIP-NO-LINK
+//     CHECK-HIP-NO-LINK: lld
+// CHECK-HIP-NO-LINK-NOT: libclang_rt.dasan
+
+// The device flag is forwarded even without any device sanitizer runtime.
 // RUN: %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu \
 // RUN:     -fopenmp=libomp --offload-arch=gfx908 -fsanitize=daddress -nogpuinc \
-// RUN:     --rocm-path=%S/Inputs/rocm \
-// RUN:     -resource-dir=%S/Inputs/resource_dir_with_per_target_subdir %s 2>&1 \
-// RUN:   | FileCheck %s --check-prefix=CHECK-MISSING
-// CHECK-MISSING-NOT: "--device-compiler=amdgpu-amd-amdhsa=-fsanitize=daddress"
+// RUN:     --rocm-path=%S/Inputs/rocm -resource-dir=%S/Inputs/resource_dir %s 2>&1 \
+// RUN:   | FileCheck %s --check-prefix=CHECK-FORWARD
+// RUN: %clang -no-canonical-prefixes -### --target=x86_64-unknown-linux-gnu \
+// RUN:     -fopenmp=libomp --offload-arch=gfx908 -Xarch_device -fsanitize=daddress \
+// RUN:     -nogpuinc --rocm-path=%S/Inputs/rocm -resource-dir=%S/Inputs/resource_dir \
+// RUN:     %s 2>&1 | FileCheck %s --check-prefix=CHECK-FORWARD
+// CHECK-FORWARD: "--device-compiler=amdgpu-amd-amdhsa=-fsanitize=daddress"
 
 int main(void) { return 0; }
diff --git a/clang/test/Driver/fsanitize-daddress.c b/clang/test/Driver/fsanitize-daddress.c
index 55e70cfc3e7019..301e07ff9d3d63 100644
--- a/clang/test/Driver/fsanitize-daddress.c
+++ b/clang/test/Driver/fsanitize-daddress.c
@@ -24,6 +24,15 @@
 // RUN: not %clang --target=x86_64-linux-gnu -fsanitize=daddress,undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UBSAN
 // CHECK-UBSAN: error: invalid argument '-fsanitize=daddress' not allowed with '-fsanitize=undefined'
 
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=daddress,float-divide-by-zero %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-FDBZ
+// CHECK-FDBZ: error: invalid argument '-fsanitize=daddress' not allowed with '-fsanitize=float-divide-by-zero'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=daddress,nullability %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NULLABILITY
+// CHECK-NULLABILITY: error: invalid argument '-fsanitize=daddress' not allowed with '-fsanitize=nullability'
+
+// RUN: not %clang --target=x86_64-linux-gnu -fsanitize=daddress,integer %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-INTEGER
+// CHECK-INTEGER: error: invalid argument '-fsanitize=daddress' not allowed with '-fsanitize=integer'
+
 // RUN: not %clang --target=x86_64-linux-gnu -fsanitize=daddress,realtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-RTSAN
 // CHECK-RTSAN: error: invalid argument '-fsanitize=daddress' not allowed with '-fsanitize=realtime'
 



More information about the llvm-branch-commits mailing list