fix(build): use clang's ASan runtime when linking with clang

locateLibasan now returns libclang_rt.asan-<arch>.so when the compiler
is clang, falling back to GCC's libasan only for GCC builds.

configureAsan derives the -l flag from the located library filename:
- clang: -lclang_rt.asan-<arch> satisfies -z defs for both __asan_*
  and __ubsan_* (clang's runtime includes both) and matches the runtime
  that -fsanitize=address links into executables — one runtime, no conflict.
- gcc: -lasan -lubsan as before.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: jbachorik

build-logic/conventions/src/main/kotlin/com/datadoghq/native/config/ConfigurationPresets.kt

@@ -187,18 +187,22 @@ object ConfigurationPresets {
                 config.compilerArgs.set(asanCompilerArgs + commonLinuxCompilerArgs(version))
 
                 val libasan = PlatformUtils.locateLibasan(compiler)
-                // Do not add -lasan/-lubsan explicitly: clang links its own
-                // libclang_rt.asan via -fsanitize=address, and combining that
-                // with an explicit -lasan (GCC's runtime) puts two incompatible
-                // ASan runtimes into the binary's NEEDED entries, causing an
-                // immediate "incompatible ASan runtimes" abort at startup.
-                // -fsanitize=address/-fsanitize=undefined handle the runtime
-                // link correctly for both GCC and clang.
-                val asanLinkerArgs = listOf(
-                    "-fsanitize=address",
-                    "-fsanitize=undefined",
-                    "-fno-omit-frame-pointer"
-                )
+                // Link against the sanitizer runtime that matches the compiler:
+                // - clang: locateLibasan returns libclang_rt.asan-<arch>.so, which
+                //   includes UBSan symbols; -lclang_rt.asan-<arch> satisfies -z defs
+                //   for both __asan_* and __ubsan_* and matches the runtime that
+                //   -fsanitize=address links into executables — one runtime, no conflict.
+                // - gcc: locateLibasan returns libasan.so; -lasan + -lubsan as before.
+                val asanLinkerArgs = if (libasan != null) {
+                    val asanLibName = File(libasan).nameWithoutExtension.removePrefix("lib")
+                    val ubsanLibs = if (asanLibName.startsWith("clang_rt")) emptyList()
+                                    else listOf("-lubsan")
+                    listOf("-L${File(libasan).parent}", "-l$asanLibName") +
+                    ubsanLibs +
+                    listOf("-fsanitize=address", "-fsanitize=undefined", "-fno-omit-frame-pointer")
+                } else {
+                    listOf("-fsanitize=address", "-fsanitize=undefined", "-fno-omit-frame-pointer")
+                }
 
                 config.linkerArgs.set(commonLinuxLinkerArgs() + asanLinkerArgs)
 

build-logic/conventions/src/main/kotlin/com/datadoghq/native/util/PlatformUtils.kt

@@ -125,7 +125,23 @@ object PlatformUtils {
         return null
     }
 
-    fun locateLibasan(compiler: String = "gcc"): String? = locateLibrary("libasan", compiler)
+    fun locateLibasan(compiler: String = "gcc"): String? {
+        if (currentPlatform != Platform.LINUX) return null
+        // For clang, prefer the architecture-specific clang_rt.asan library over
+        // GCC's libasan. Using GCC's runtime alongside clang's libclang_rt.asan
+        // (which -fsanitize=address links for executables) causes "incompatible
+        // ASan runtimes" at startup. The clang runtime also includes UBSan symbols,
+        // so no separate -lubsan is needed.
+        if (compiler.contains("clang")) {
+            val archSuffix = when (currentArchitecture) {
+                Architecture.X64 -> "x86_64"
+                Architecture.ARM64 -> "aarch64"
+            }
+            val clangAsan = locateLibrary("libclang_rt.asan-$archSuffix", compiler)
+            if (clangAsan != null) return clangAsan
+        }
+        return locateLibrary("libasan", compiler)
+    }
 
     fun locateLibtsan(compiler: String = "gcc"): String? = locateLibrary("libtsan", compiler)