[fusilli] Supported ASAN build

Signed-off-by: Alexandra Sidorova <asidorov@amd.com>

Author: a-sidorova

.github/workflows/build-and-test-linux.yml

@@ -30,7 +30,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        name: ["gfx942_clang22_release", "cpu_clang18_debug", "gfx942_clang22_debug", "cpu_gcc13_codecov"]
+        name: ["gfx942_clang22_release", "cpu_clang18_debug", "gfx942_clang22_debug", "cpu_gcc13_codecov", "gfx942_clang22_asan", "cpu_clang18_asan"]
         include:
           - name: gfx942_clang22_release
             runs-on: linux-mi325-1gpu-ossci-iree-org
@@ -67,6 +67,30 @@ jobs:
               -DFUSILLI_CODE_COVERAGE=ON
               -DFUSILLI_SYSTEMS_AMDGPU=OFF
               -DFUSILLI_ENABLE_CLANG_TIDY=ON
+          - name: gfx942_clang22_asan
+            runs-on: linux-mi325-1gpu-ossci-iree-org
+            cmake-options:
+              -DCMAKE_C_COMPILER=clang-22
+              -DCMAKE_CXX_COMPILER=clang++-22
+              -DCMAKE_BUILD_TYPE=Debug
+              -DFUSILLI_SYSTEMS_AMDGPU=ON
+              -DFUSILLI_ENABLE_ASAN=ON
+            asan-env: >-
+              ASAN_SYMBOLIZER_PATH=/workspace/.cache/docker/venv/bin/llvm-symbolizer-22
+              ASAN_OPTIONS=detect_leaks=1:halt_on_error=0
+              LSAN_OPTIONS=suppressions=/workspace/build_tools/sanitizers/lsan_suppressions.txt
+          - name: cpu_clang18_asan
+            runs-on: azure-linux-scale
+            cmake-options:
+              -DCMAKE_C_COMPILER=clang-18
+              -DCMAKE_CXX_COMPILER=clang++-18
+              -DCMAKE_BUILD_TYPE=Debug
+              -DFUSILLI_SYSTEMS_AMDGPU=OFF
+              -DFUSILLI_ENABLE_ASAN=ON
+            asan-env: >-
+              ASAN_SYMBOLIZER_PATH=/usr/bin/llvm-symbolizer-18
+              ASAN_OPTIONS=detect_leaks=1:halt_on_error=0
+              LSAN_OPTIONS=suppressions=/workspace/build_tools/sanitizers/lsan_suppressions.txt
 
     steps:
     - name: Checkout fusilli
@@ -81,14 +105,14 @@ jobs:
                  cmake --build build --target all"
 
     - name: Test fusilli (libIREECompiler CAPI)
-      if: ${{ matrix.name != 'cpu_gcc13_codecov' }}
+      if: ${{ matrix.name != 'cpu_gcc13_codecov' && matrix.name != 'gfx942_clang22_asan' && matrix.name != 'cpu_clang18_asan' }}
       run: |
         build_tools/docker/exec_docker_ci.sh \
         bash -c "ctest --test-dir build --output-on-failure --extra-verbose --timeout 120 -j \$(nproc) && \
                  tests/test_cache_empty.sh"
 
     - name: Test fusilli (iree-compile CLI)
-      if: ${{ matrix.name != 'cpu_gcc13_codecov' }}
+      if: ${{ matrix.name != 'cpu_gcc13_codecov' && matrix.name != 'gfx942_clang22_asan' && matrix.name != 'cpu_clang18_asan' }}
       run: |
         build_tools/docker/exec_docker_ci.sh \
         bash -c "FUSILLI_COMPILE_BACKEND_USE_CLI=1 ctest --test-dir build --output-on-failure --extra-verbose --timeout 120 -j \$(nproc) && \
@@ -109,3 +133,11 @@ jobs:
       with:
         name: coverage-report
         path: ${{ github.workspace }}/coverage_report
+
+    - name: Run AddressSanitizer
+      if: ${{ matrix.name == 'gfx942_clang22_asan' || matrix.name == 'cpu_clang18_asan' }}
+      run: |
+        build_tools/docker/exec_docker_ci.sh \
+        bash -c "${{ matrix.asan-env }} \
+                 ctest --test-dir build --output-on-failure --extra-verbose --timeout 120 -j \$(nproc) && \
+                 tests/test_cache_empty.sh"

CMakeLists.txt

@@ -52,6 +52,7 @@ endif()
 # Includes
 include(CTest)
 include(FetchContent)
+include(CheckCXXCompilerFlag)
 
 # Local Includes
 list(APPEND CMAKE_MODULE_PATH
@@ -67,13 +68,22 @@ option(FUSILLI_CODE_COVERAGE "Enable code coverage for tests" OFF)
 option(FUSILLI_ENABLE_LOGGING "Enable logging for tests and samples" OFF)
 option(FUSILLI_ENABLE_CLANG_TIDY "Enable clang-tidy" OFF)
 option(FUSILLI_SYSTEMS_AMDGPU  "Builds for AMD GPU systems" OFF)
+option(FUSILLI_ENABLE_ASAN "Enable AddressSanitizer" OFF)
 
 message(STATUS "Fusilli supported systems:")
 if(FUSILLI_SYSTEMS_AMDGPU)
   message(STATUS "  - AMD GPU")
 endif()
 message(STATUS "  - Host")
 
+if(FUSILLI_ENABLE_ASAN AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+  message(FATAL_ERROR "AddressSanitizer requires Clang as the C++ compiler, but '${CMAKE_CXX_COMPILER_ID}' was detected.")
+endif()
+
+if(FUSILLI_ENABLE_ASAN AND FUSILLI_CODE_COVERAGE)
+  message(FATAL_ERROR "FUSILLI_ENABLE_ASAN and FUSILLI_CODE_COVERAGE cannot be enabled simultaneously.")
+endif()
+
 ################################################################################
 # IREE Dependency
 #
@@ -121,6 +131,10 @@ if(FUSILLI_SYSTEMS_AMDGPU)
   set(IREE_HAL_DRIVER_HIP ON)
   set(IREE_HIP_TEST_TARGET_CHIP "" CACHE STRING "Enable ROCm testing on specific architecture (e.g. gfx942)")
 endif()
+# Enable ASAN build for IREE if ASAN is used in Fusilli
+if(FUSILLI_ENABLE_ASAN)
+  set(IREE_ENABLE_ASAN ON)
+endif()
 
 if(IREE_SOURCE_DIR)
   message(STATUS "Using existing IREE sources: ${IREE_SOURCE_DIR}")
@@ -184,6 +198,20 @@ if(FUSILLI_CODE_COVERAGE)
   set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Debug build" FORCE)
 endif()
 
+# Configure sanitizer flags
+set(FUSILLI_SANITIZER_COMPILE_FLAGS "")
+set(FUSILLI_SANITIZER_LINK_FLAGS "")
+if(FUSILLI_ENABLE_ASAN)
+  message(STATUS "AddressSanitizer enabled")
+  list(APPEND FUSILLI_SANITIZER_COMPILE_FLAGS -fsanitize=address -fno-omit-frame-pointer -g)
+  list(APPEND FUSILLI_SANITIZER_LINK_FLAGS -fsanitize=address)
+
+  check_cxx_compiler_flag("-fsanitize-recover=address" SANITIZE_RECOVER_ADDRESS_SUPPORTED)
+  if (SANITIZE_RECOVER_ADDRESS_SUPPORTED)
+    list(APPEND FUSILLI_SANITIZER_COMPILE_FLAGS -fsanitize-recover=address)
+  endif()
+endif()
+
 # Enable AMD GPU build if requested
 if(FUSILLI_SYSTEMS_AMDGPU)
   # Check for Linux AMD GPU device node - `/dev/kfd`

README.md

@@ -245,6 +245,39 @@ FUSILLI_COMPILE_BACKEND_USE_CLI=1 \
   -f commands.txt
 ```
 
+### Sanitizers (AddressSanitizer)
+
+Fusilli supports building with AddressSanitizer (ASAN) for detecting memory errors such as use-after-free, buffer overflows, and memory leaks.
+
+To build with AddressSanitizer, specify the cmake flag `-DFUSILLI_ENABLE_ASAN=ON`:
+```shell
+cmake -GNinja -S. -Bbuild \
+    -DCMAKE_C_COMPILER=clang \
+    -DCMAKE_CXX_COMPILER=clang++ \
+    -DCMAKE_BUILD_TYPE=Debug \
+    -DFUSILLI_ENABLE_ASAN=ON \
+    -DIREE_SOURCE_DIR=</path/to/iree/source>
+cmake --build build --target all
+ctest --test-dir build
+```
+
+To customize AddressSanitizer behavior at runtime, use the `ASAN_OPTIONS` environment variable:
+```shell
+ASAN_OPTIONS=detect_leaks=1:halt_on_error=0 LSAN_OPTIONS=suppressions=build_tools/sanitizers/lsan_suppressions.txt ctest --test-dir build
+```
+
+To make AddressSanitizer symbolize its output you need to set the `ASAN_SYMBOLIZER_PATH` environment variable
+to point to the llvm-symbolizer binary (or make sure llvm-symbolizer is in your `$PATH`):
+```shell
+ASAN_SYMBOLIZER_PATH=/usr/bin/llvm-symbolizer ...
+```
+
+> [!NOTE]
+> - Debug builds (`-DCMAKE_BUILD_TYPE=Debug`) provide better stack traces.
+> - Sanitizer builds have runtime overhead and are intended for development/testing, not production.
+> - AddressSanitizer and Code Coverage cannot be used simultaneously, because both add heavy runtime instrumentation
+and combining them often leads to slow/flaky tests and less reliable diagnostics.
+
 ### Code Coverage (using gcov + lcov)
 
 This works with gcc builds (code coverage with clang instrumentation is future
@@ -279,6 +312,10 @@ lcov --remove build/coverage.info '/usr/*' '*/iree/*' --output-file build/covera
 genhtml build/coverage.info --output-directory coverage_report
 ```
 
+> [!NOTE]
+> - AddressSanitizer and Code Coverage cannot be used simultaneously, because both add heavy runtime instrumentation
+and combining them often leads to slow/flaky tests and less reliable diagnostics.
+
 ### Lint
 
 This project is set up to use [pre-commit](https://pre-commit.com/) hooks for

benchmarks/CMakeLists.txt

@@ -19,6 +19,12 @@ set_target_properties(
 # Enable clang-tidy.
 fusilli_enable_clang_tidy(fusilli_benchmark_driver)
 
+# Set compiler options for sanitizers.
+if(FUSILLI_ENABLE_ASAN)
+  target_compile_options(fusilli_benchmark_driver PRIVATE ${FUSILLI_SANITIZER_COMPILE_FLAGS})
+  target_link_options(fusilli_benchmark_driver PRIVATE ${FUSILLI_SANITIZER_LINK_FLAGS})
+endif()
+
 # Test benchmark runner
 if(FUSILLI_SYSTEMS_AMDGPU)
   add_test(

build_tools/cmake/FusilliTestUtils.cmake

@@ -369,6 +369,12 @@ function(_add_fusilli_executable_for_test)
     target_link_options(${_RULE_NAME} PRIVATE -coverage)
   endif()
 
+  # Set compiler options for sanitizers.
+  if(FUSILLI_ENABLE_ASAN)
+    target_compile_options(${_RULE_NAME} PRIVATE ${FUSILLI_SANITIZER_COMPILE_FLAGS})
+    target_link_options(${_RULE_NAME} PRIVATE ${FUSILLI_SANITIZER_LINK_FLAGS})
+  endif()
+
   # Place executable in the build/bin sub-directory.
   set_target_properties(
       ${_RULE_NAME} PROPERTIES

build_tools/sanitizers/lsan_suppressions.txt

@@ -0,0 +1,6 @@
+# LSAN suppressions for leaks in external libraries (IREE, ROCm)
+
+leak:iree_hal_hip_dispatch_completed_create
+leak:libamdhip64.so
+leak:libhsa-runtime64.so
+leak:libamd_comgr.so

include/fusilli/backend/runtime.h

@@ -145,9 +145,14 @@ inline ErrorObject Handle::createAMDGPUDevice(int deviceId, uintptr_t stream) {
 
   // Create device.
   iree_hal_device_t *rawDevice = nullptr;
-  FUSILLI_CHECK_ERROR(iree_hal_driver_create_device_by_id(
+  iree_status_t deviceStatus = iree_hal_driver_create_device_by_id(
       driver, HIP_DEVICE_ID_TO_IREE_DEVICE_ID(deviceId), /*param_count=*/0,
-      /*params=*/nullptr, iree_allocator_system(), &rawDevice));
+      /*params=*/nullptr, iree_allocator_system(), &rawDevice);
+
+  // Release the driver regardless of whether device creation succeeded.
+  iree_hal_driver_release(driver);
+
+  FUSILLI_CHECK_ERROR(deviceStatus);
 
   // Wrap the raw device ptr with a unique_ptr and custom deleter
   // for lifetime management.

include/fusilli/support/logging.h

@@ -102,6 +102,7 @@ struct [[nodiscard]] ErrorObject {
     // Write error message into `errMsg` variable using the runtime's fprint
     // based reporting.
     iree_status_fprint(FprintToString(errMsg), status);
+    iree_status_ignore(status);
   }
 
   ErrorCode getCode() const { return code; }