clang-tool-chain 1.0.44__py3-none-any.whl → 1.0.47__py3-none-any.whl

clang_tool_chain/__init__.py

@@ -1 +1,32 @@
 __version__ = "1.0.30"
+
+# Re-export commonly used functions for convenient access
+from clang_tool_chain.env_utils import (
+    CONTROLLABLE_FEATURES,
+    get_disabled_features,
+    is_auto_disabled,
+    is_feature_disabled,
+)
+from clang_tool_chain.execution.sanitizer_env import (
+    detect_sanitizers_from_flags,
+    get_symbolizer_path,
+    prepare_sanitizer_environment,
+)
+from clang_tool_chain.platform import find_tool_binary, get_platform_binary_dir, get_platform_info
+
+__all__ = [
+    "__version__",
+    # Platform utilities
+    "get_platform_info",
+    "get_platform_binary_dir",
+    "find_tool_binary",
+    # Environment utilities
+    "is_feature_disabled",
+    "is_auto_disabled",
+    "get_disabled_features",
+    "CONTROLLABLE_FEATURES",
+    # Sanitizer environment
+    "prepare_sanitizer_environment",
+    "get_symbolizer_path",
+    "detect_sanitizers_from_flags",
+]

clang_tool_chain/__version__.py

@@ -1,3 +1,3 @@
 """Version information for clang-tool-chain."""
 
-__version__ = "1.0.44"
+__version__ = "1.0.47"

clang_tool_chain/deployment/dll_deployer.py

@@ -12,6 +12,7 @@ import re
 import subprocess
 from pathlib import Path
 
+from clang_tool_chain.env_utils import is_feature_disabled
 from clang_tool_chain.interrupt_utils import handle_keyboard_interrupt_properly
 
 from .base_deployer import BaseLibraryDeployer
@@ -510,9 +511,10 @@ def post_link_dll_deployment(output_exe_path: Path, platform_name: str, use_gnu_
         None
 
     Environment Variables:
-        CLANG_TOOL_CHAIN_NO_DEPLOY_DLLS: Set to "1" to disable all DLL deployment
-        CLANG_TOOL_CHAIN_NO_DEPLOY_DLLS_FOR_DLLS: Set to "1" to disable deployment for .dll outputs only
-        CLANG_TOOL_CHAIN_DLL_DEPLOY_VERBOSE: Set to "1" for verbose logging
+        CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS: Set to "1" to disable all library deployment
+        CLANG_TOOL_CHAIN_NO_DEPLOY_SHARED_LIB: Set to "1" to disable deployment for shared library outputs only
+        CLANG_TOOL_CHAIN_NO_AUTO: Set to "1" to disable all automatic features
+        CLANG_TOOL_CHAIN_LIB_DEPLOY_VERBOSE: Set to "1" for verbose logging
 
     Examples:
         >>> post_link_dll_deployment(Path("test.exe"), "win", True)
@@ -520,13 +522,12 @@ def post_link_dll_deployment(output_exe_path: Path, platform_name: str, use_gnu_
         >>> post_link_dll_deployment(Path("mylib.dll"), "win", True)
         # Deploys runtime DLLs alongside the shared library
     """
-    # Check opt-out environment variable
-    if os.environ.get("CLANG_TOOL_CHAIN_NO_DEPLOY_DLLS") == "1":
-        logger.debug("DLL deployment disabled via CLANG_TOOL_CHAIN_NO_DEPLOY_DLLS")
+    # Check opt-out environment variable (via NO_DEPLOY_LIBS or NO_AUTO)
+    if is_feature_disabled("DEPLOY_LIBS"):
         return
 
     # Enable verbose logging if requested
-    if os.environ.get("CLANG_TOOL_CHAIN_DLL_DEPLOY_VERBOSE") == "1":
+    if os.environ.get("CLANG_TOOL_CHAIN_LIB_DEPLOY_VERBOSE") == "1":
         logger.setLevel(logging.DEBUG)
 
     # Guard: only deploy on Windows
@@ -542,9 +543,8 @@ def post_link_dll_deployment(output_exe_path: Path, platform_name: str, use_gnu_
     # Guard: only deploy for .exe and .dll files
     suffix = output_exe_path.suffix.lower()
     if suffix == ".dll":
-        # Check for DLL-specific opt-out
-        if os.environ.get("CLANG_TOOL_CHAIN_NO_DEPLOY_DLLS_FOR_DLLS") == "1":
-            logger.debug("DLL deployment for .dll outputs disabled via CLANG_TOOL_CHAIN_NO_DEPLOY_DLLS_FOR_DLLS")
+        # Check for shared library-specific opt-out (via NO_DEPLOY_SHARED_LIB or NO_AUTO)
+        if is_feature_disabled("DEPLOY_SHARED_LIB"):
             return
     elif suffix != ".exe":
         logger.debug(f"DLL deployment skipped: not .exe or .dll file (suffix={output_exe_path.suffix})")
@@ -596,10 +596,9 @@ def post_link_dependency_deployment(output_path: Path, platform_name: str, use_g
         None
 
     Environment Variables:
-        CLANG_TOOL_CHAIN_NO_DEPLOY_DLLS: Set to "1" to disable deployment (all platforms)
-        CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS: Set to "1" to disable deployment (alias)
-        CLANG_TOOL_CHAIN_DLL_DEPLOY_VERBOSE: Set to "1" for verbose logging (all platforms)
-        CLANG_TOOL_CHAIN_LIB_DEPLOY_VERBOSE: Set to "1" for verbose logging (alias)
+        CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS: Set to "1" to disable all library deployment
+        CLANG_TOOL_CHAIN_NO_AUTO: Set to "1" to disable all automatic features
+        CLANG_TOOL_CHAIN_LIB_DEPLOY_VERBOSE: Set to "1" for verbose logging
 
     Examples:
         >>> post_link_dependency_deployment(Path("mylib.dll"), "win", True)
@@ -609,17 +608,11 @@ def post_link_dependency_deployment(output_path: Path, platform_name: str, use_g
         >>> post_link_dependency_deployment(Path("mylib.dylib"), "darwin", False)
         # Deploys libunwind.1.dylib, libc++.1.dylib, etc. to mylib.dylib directory
     """
-    # Check opt-out environment variables (either DLL-specific or generic)
-    if os.environ.get("CLANG_TOOL_CHAIN_NO_DEPLOY_DLLS") == "1":
-        logger.debug("Dependency deployment disabled via CLANG_TOOL_CHAIN_NO_DEPLOY_DLLS")
-        return
-    if os.environ.get("CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS") == "1":
-        logger.debug("Dependency deployment disabled via CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS")
+    # Check opt-out environment variables (NO_DEPLOY_LIBS or NO_AUTO)
+    if is_feature_disabled("DEPLOY_LIBS"):
         return
 
-    # Enable verbose logging if requested (either DLL-specific or generic)
-    if os.environ.get("CLANG_TOOL_CHAIN_DLL_DEPLOY_VERBOSE") == "1":
-        logger.setLevel(logging.DEBUG)
+    # Enable verbose logging if requested
     if os.environ.get("CLANG_TOOL_CHAIN_LIB_DEPLOY_VERBOSE") == "1":
         logger.setLevel(logging.DEBUG)
 

clang_tool_chain/deployment/dylib_deployer.py

@@ -18,11 +18,12 @@ Example:
 """
 
 import logging
-import os
 import re
 import subprocess
 from pathlib import Path
 
+from clang_tool_chain.env_utils import is_feature_disabled
+
 from .base_deployer import BaseLibraryDeployer
 
 logger = logging.getLogger(__name__)
@@ -499,7 +500,8 @@ def post_link_dylib_deployment(output_path: Path, arch: str = "x86_64") -> int:
 
     Environment variables:
     - CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS=1 - Disable all library deployment
-    - CLANG_TOOL_CHAIN_NO_DEPLOY_DYLIBS=1 - Disable macOS-specific deployment
+    - CLANG_TOOL_CHAIN_NO_DEPLOY_SHARED_LIB=1 - Disable deployment for shared library outputs
+    - CLANG_TOOL_CHAIN_NO_AUTO=1 - Disable all automatic features
 
     Args:
         output_path: Path to executable or shared library
@@ -512,14 +514,12 @@ def post_link_dylib_deployment(output_path: Path, arch: str = "x86_64") -> int:
         >>> # Called automatically after linking
         >>> count = post_link_dylib_deployment(Path("program"), arch="arm64")
     """
-    # Check global disable
-    if os.getenv("CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS") == "1":
-        logger.debug("dylib deployment disabled (CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS=1)")
+    # Check environment variables (NO_DEPLOY_LIBS or NO_AUTO)
+    if is_feature_disabled("DEPLOY_LIBS"):
         return 0
 
-    # Check macOS-specific disable
-    if os.getenv("CLANG_TOOL_CHAIN_NO_DEPLOY_DYLIBS") == "1":
-        logger.debug("dylib deployment disabled (CLANG_TOOL_CHAIN_NO_DEPLOY_DYLIBS=1)")
+    # Check if output is a shared library (.dylib) - if so, check NO_DEPLOY_SHARED_LIB
+    if output_path.suffix == ".dylib" and is_feature_disabled("DEPLOY_SHARED_LIB"):
         return 0
 
     # Check if output is executable or .dylib

clang_tool_chain/deployment/libdeploy.py

@@ -0,0 +1,287 @@
+"""
+Library deployment CLI for deploying runtime dependencies after the fact.
+
+This module provides a command-line interface to deploy library dependencies
+for already-built executables and shared libraries. It supports:
+- Windows: .exe and .dll files (MinGW runtime DLLs)
+- Linux: executables and .so files (libc++, libunwind, etc.)
+- macOS: executables and .dylib files (libc++, libunwind, etc.)
+
+Usage:
+    clang-tool-chain-libdeploy myprogram.exe
+    clang-tool-chain-libdeploy mylib.dll
+    clang-tool-chain-libdeploy myprogram
+    clang-tool-chain-libdeploy mylib.so
+    clang-tool-chain-libdeploy mylib.dylib
+"""
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+from clang_tool_chain.interrupt_utils import handle_keyboard_interrupt_properly
+
+logger = logging.getLogger(__name__)
+
+
+def _setup_logging(verbose: bool) -> None:
+    """Configure logging based on verbosity."""
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(message)s",
+        stream=sys.stderr,
+    )
+    # Also set the deployment module loggers
+    logging.getLogger("clang_tool_chain.deployment").setLevel(level)
+
+
+def _detect_binary_type(binary_path: Path) -> tuple[str, str]:
+    """
+    Detect the binary type and platform from file extension and magic bytes.
+
+    Args:
+        binary_path: Path to the binary file
+
+    Returns:
+        Tuple of (platform, binary_type) where:
+        - platform: "windows", "linux", or "darwin"
+        - binary_type: "executable" or "shared_library"
+
+    Raises:
+        ValueError: If binary type cannot be determined
+    """
+    suffix = binary_path.suffix.lower()
+
+    # Windows binaries
+    if suffix == ".exe":
+        return ("windows", "executable")
+    if suffix == ".dll":
+        return ("windows", "shared_library")
+
+    # macOS binaries
+    if suffix == ".dylib":
+        return ("darwin", "shared_library")
+
+    # Linux shared libraries (including versioned: .so.1, .so.1.2.3)
+    if suffix == ".so" or ".so." in binary_path.name:
+        return ("linux", "shared_library")
+
+    # No extension - could be Linux/macOS executable or a .so with version
+    # Try to detect from magic bytes
+    if binary_path.exists() and binary_path.is_file():
+        try:
+            with open(binary_path, "rb") as f:
+                magic = f.read(4)
+
+            # ELF magic: 0x7f 'E' 'L' 'F'
+            if magic[:4] == b"\x7fELF":
+                return ("linux", "executable")
+
+            # Mach-O magic numbers
+            # MH_MAGIC (32-bit): 0xfeedface
+            # MH_MAGIC_64 (64-bit): 0xfeedfacf
+            # Fat binary: 0xcafebabe
+            if magic[:4] in (b"\xfe\xed\xfa\xce", b"\xfe\xed\xfa\xcf", b"\xcf\xfa\xed\xfe", b"\xce\xfa\xed\xfe"):
+                return ("darwin", "executable")
+            if magic[:4] == b"\xca\xfe\xba\xbe":
+                return ("darwin", "executable")
+
+            # PE magic: 'MZ'
+            if magic[:2] == b"MZ":
+                return ("windows", "executable")
+
+        except (OSError, PermissionError) as e:
+            logger.debug(f"Could not read magic bytes: {e}")
+
+    raise ValueError(
+        f"Cannot determine binary type for: {binary_path}\n"
+        "Supported formats: .exe, .dll (Windows), .so (Linux), .dylib (macOS), "
+        "or ELF/Mach-O executables without extension"
+    )
+
+
+def deploy_dependencies(
+    binary_path: Path,
+    platform_override: str | None = None,
+    arch: str | None = None,
+    verbose: bool = False,
+    dry_run: bool = False,
+) -> int:
+    """
+    Deploy library dependencies for a binary.
+
+    Args:
+        binary_path: Path to executable or shared library
+        platform_override: Override auto-detected platform ("windows", "linux", "darwin")
+        arch: Target architecture (default: auto-detect from current platform)
+        verbose: Enable verbose output
+        dry_run: If True, only show what would be deployed without actually copying
+
+    Returns:
+        Number of libraries deployed, or -1 on error
+    """
+    from clang_tool_chain.deployment.factory import create_deployer
+    from clang_tool_chain.platform.detection import get_platform_info
+
+    # Get architecture if not specified
+    if arch is None:
+        _, arch = get_platform_info()
+
+    # Detect or use override for platform
+    if platform_override:
+        platform = platform_override.lower()
+        if platform not in ("windows", "linux", "darwin", "win", "win32", "macos"):
+            logger.error(f"Invalid platform: {platform_override}")
+            return -1
+        # Normalize platform names
+        if platform in ("win", "win32"):
+            platform = "windows"
+        elif platform == "macos":
+            platform = "darwin"
+    else:
+        try:
+            platform, _ = _detect_binary_type(binary_path)
+        except ValueError as e:
+            logger.error(str(e))
+            return -1
+
+    # Validate binary exists
+    if not binary_path.exists():
+        logger.error(f"Binary not found: {binary_path}")
+        return -1
+
+    if not binary_path.is_file():
+        logger.error(f"Not a file: {binary_path}")
+        return -1
+
+    # Create appropriate deployer
+    deployer = create_deployer(platform, arch)
+    if deployer is None:
+        logger.error(f"No deployer available for platform: {platform}")
+        return -1
+
+    if verbose:
+        logger.info(f"Deploying dependencies for: {binary_path}")
+        logger.info(f"Platform: {platform}, Architecture: {arch}")
+
+    if dry_run:
+        # Dry run - just show what would be deployed
+        dependencies = deployer.detect_all_dependencies(binary_path, recursive=True)
+        if not dependencies:
+            logger.info("No deployable dependencies found")
+            return 0
+
+        logger.info(f"Would deploy {len(dependencies)} libraries:")
+        for dep in sorted(dependencies):
+            src = deployer.find_library_in_toolchain(dep)
+            if src:
+                logger.info(f"  {dep} <- {src}")
+            else:
+                logger.info(f"  {dep} (source not found)")
+        return len(dependencies)
+
+    # Actually deploy
+    try:
+        deployed_count = deployer.deploy_all(binary_path)
+        if deployed_count == 0 and verbose:
+            logger.info("No libraries needed deployment (all up-to-date or none required)")
+        return deployed_count
+    except Exception as e:
+        logger.error(f"Deployment failed: {e}")
+        return -1
+
+
+def main() -> int:
+    """
+    Main entry point for clang-tool-chain-libdeploy.
+
+    Returns:
+        Exit code (0 for success, non-zero for failure)
+    """
+    parser = argparse.ArgumentParser(
+        prog="clang-tool-chain-libdeploy",
+        description="Deploy runtime library dependencies for executables and shared libraries",
+        epilog="""
+Examples:
+  clang-tool-chain-libdeploy myprogram.exe          # Windows executable
+  clang-tool-chain-libdeploy mylib.dll              # Windows DLL
+  clang-tool-chain-libdeploy myprogram              # Linux/macOS executable
+  clang-tool-chain-libdeploy mylib.so               # Linux shared library
+  clang-tool-chain-libdeploy mylib.dylib            # macOS dynamic library
+  clang-tool-chain-libdeploy --dry-run myprogram    # Show what would be deployed
+
+Supported platforms:
+  Windows: Deploys MinGW runtime DLLs (libwinpthread, libgcc_s, libstdc++, etc.)
+  Linux:   Deploys libc++, libunwind, sanitizer runtimes
+  macOS:   Deploys libc++, libunwind, sanitizer runtimes
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "binary",
+        type=Path,
+        help="Path to executable (.exe) or shared library (.dll, .so, .dylib)",
+    )
+
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable verbose output",
+    )
+
+    parser.add_argument(
+        "-n",
+        "--dry-run",
+        action="store_true",
+        help="Show what would be deployed without copying files",
+    )
+
+    parser.add_argument(
+        "-p",
+        "--platform",
+        choices=["windows", "linux", "darwin"],
+        help="Override auto-detected platform",
+    )
+
+    parser.add_argument(
+        "-a",
+        "--arch",
+        help="Target architecture (default: auto-detect)",
+    )
+
+    args = parser.parse_args()
+
+    # Setup logging
+    _setup_logging(args.verbose)
+
+    try:
+        result = deploy_dependencies(
+            binary_path=args.binary.resolve(),
+            platform_override=args.platform,
+            arch=args.arch,
+            verbose=args.verbose,
+            dry_run=args.dry_run,
+        )
+
+        if result < 0:
+            return 1
+
+        if result == 0 and not args.dry_run:
+            # No libraries deployed is not necessarily an error
+            return 0
+
+        return 0
+
+    except KeyboardInterrupt as ke:
+        handle_keyboard_interrupt_properly(ke)  # NoReturn - re-raises
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

clang_tool_chain/deployment/so_deployer.py

@@ -12,6 +12,7 @@ import re
 import subprocess
 from pathlib import Path
 
+from clang_tool_chain.env_utils import is_feature_disabled
 from clang_tool_chain.interrupt_utils import handle_keyboard_interrupt_properly
 
 from .base_deployer import BaseLibraryDeployer
@@ -35,6 +36,8 @@ class SoDeployer(BaseLibraryDeployer):
         r"libc\+\+\.so[.\d]*",
         r"libc\+\+abi\.so[.\d]*",
         r"libunwind\.so[.\d]*",
+        r"libunwind-x86_64\.so[.\d]*",  # Platform-specific libunwind (bundled)
+        r"libunwind-aarch64\.so[.\d]*",  # Platform-specific libunwind (bundled)
         r"libclang_rt\..*\.so",  # Sanitizer runtimes
     ]
 
@@ -309,14 +312,19 @@ def post_link_so_deployment(
 
     Returns:
         Number of .so files deployed
+
+    Environment Variables:
+        CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS: Set to "1" to disable all library deployment
+        CLANG_TOOL_CHAIN_NO_DEPLOY_SHARED_LIB: Set to "1" to disable deployment for shared library outputs
+        CLANG_TOOL_CHAIN_NO_AUTO: Set to "1" to disable all automatic features
     """
-    # Check environment variables
-    if os.getenv("CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS") == "1":
-        logger.debug("Linux .so deployment disabled by CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS")
+    # Check environment variables (NO_DEPLOY_LIBS or NO_AUTO)
+    if is_feature_disabled("DEPLOY_LIBS"):
         return 0
 
-    if os.getenv("CLANG_TOOL_CHAIN_NO_DEPLOY_SO") == "1":
-        logger.debug("Linux .so deployment disabled by CLANG_TOOL_CHAIN_NO_DEPLOY_SO")
+    # Check if output is a shared library (.so) - if so, check NO_DEPLOY_SHARED_LIB
+    is_shared_lib = output_path.suffix == ".so" or ".so." in output_path.name
+    if is_shared_lib and is_feature_disabled("DEPLOY_SHARED_LIB"):
         return 0
 
     # Check if output is a deployable binary

clang_tool_chain/env_utils.py

@@ -0,0 +1,137 @@
+"""
+Environment variable utilities for clang-tool-chain.
+
+This module provides centralized handling of environment variable checks,
+including support for the aggregate CLANG_TOOL_CHAIN_NO_AUTO variable
+that disables all automatic features.
+
+Example:
+    >>> from clang_tool_chain.env_utils import is_feature_disabled
+    >>> if is_feature_disabled("DIRECTIVES"):
+    ...     # Skip directive parsing
+    ...     pass
+"""
+
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+# Truthy values for boolean environment variables
+_TRUTHY_VALUES = ("1", "true", "yes")
+
+# All features that can be disabled via NO_AUTO
+# Maps feature name to the specific environment variable suffix
+CONTROLLABLE_FEATURES = {
+    "DIRECTIVES": "Inlined build directives (@link, @std, @cflags)",
+    "SHARED_ASAN": "Automatic -shared-libasan injection (Linux)",
+    "SANITIZER_ENV": "Automatic ASAN_OPTIONS/LSAN_OPTIONS injection",
+    "SANITIZER_NOTE": "Sanitizer flag injection note to stderr",
+    "RPATH": "Automatic rpath injection for library loading",
+    "SYSROOT": "Automatic macOS SDK detection (-isysroot)",
+    "DEPLOY_LIBS": "Cross-platform library deployment (all outputs)",
+    "DEPLOY_SHARED_LIB": "Library deployment for shared library outputs only (.dll, .so, .dylib)",
+}
+
+
+def _is_truthy(value: str | None) -> bool:
+    """Check if an environment variable value is truthy."""
+    if value is None:
+        return False
+    return value.lower() in _TRUTHY_VALUES
+
+
+def is_auto_disabled() -> bool:
+    """
+    Check if all automatic features are disabled via CLANG_TOOL_CHAIN_NO_AUTO.
+
+    Returns:
+        True if CLANG_TOOL_CHAIN_NO_AUTO is set to a truthy value.
+
+    Example:
+        >>> os.environ["CLANG_TOOL_CHAIN_NO_AUTO"] = "1"
+        >>> is_auto_disabled()
+        True
+    """
+    return _is_truthy(os.environ.get("CLANG_TOOL_CHAIN_NO_AUTO"))
+
+
+def is_feature_disabled(feature: str) -> bool:
+    """
+    Check if a specific feature is disabled.
+
+    A feature is disabled if either:
+    1. The aggregate CLANG_TOOL_CHAIN_NO_AUTO=1 is set, OR
+    2. The specific CLANG_TOOL_CHAIN_NO_{feature}=1 is set
+
+    Args:
+        feature: The feature name (e.g., "DIRECTIVES", "SHARED_ASAN", "DEPLOY_LIBS").
+                 Should match one of the keys in CONTROLLABLE_FEATURES.
+
+    Returns:
+        True if the feature is disabled, False otherwise.
+
+    Example:
+        >>> os.environ["CLANG_TOOL_CHAIN_NO_DIRECTIVES"] = "1"
+        >>> is_feature_disabled("DIRECTIVES")
+        True
+
+        >>> os.environ["CLANG_TOOL_CHAIN_NO_AUTO"] = "1"
+        >>> is_feature_disabled("SHARED_ASAN")  # Disabled by NO_AUTO
+        True
+    """
+    # Check the aggregate NO_AUTO variable first
+    if is_auto_disabled():
+        logger.debug(f"Feature {feature} disabled via CLANG_TOOL_CHAIN_NO_AUTO=1")
+        return True
+
+    # Check the specific feature variable
+    var_name = f"CLANG_TOOL_CHAIN_NO_{feature}"
+    if _is_truthy(os.environ.get(var_name)):
+        logger.debug(f"Feature {feature} disabled via {var_name}=1")
+        return True
+
+    return False
+
+
+def get_disabled_features() -> list[str]:
+    """
+    Get a list of all currently disabled features.
+
+    Returns:
+        List of feature names that are disabled.
+
+    Example:
+        >>> os.environ["CLANG_TOOL_CHAIN_NO_AUTO"] = "1"
+        >>> get_disabled_features()
+        ['DIRECTIVES', 'SHARED_ASAN', 'SANITIZER_ENV', ...]
+    """
+    disabled = []
+
+    # If NO_AUTO is set, all features are disabled
+    if is_auto_disabled():
+        return list(CONTROLLABLE_FEATURES.keys())
+
+    # Check each feature individually
+    for feature in CONTROLLABLE_FEATURES:
+        var_name = f"CLANG_TOOL_CHAIN_NO_{feature}"
+        if _is_truthy(os.environ.get(var_name)):
+            disabled.append(feature)
+
+    return disabled
+
+
+def log_disabled_features_summary() -> None:
+    """
+    Log a summary of disabled features (useful for debugging).
+
+    Only logs if at least one feature is disabled.
+    """
+    disabled = get_disabled_features()
+    if not disabled:
+        return
+
+    if is_auto_disabled():
+        logger.info("All automatic features disabled via CLANG_TOOL_CHAIN_NO_AUTO=1")
+    else:
+        logger.info(f"Disabled features: {', '.join(disabled)}")

clang_tool_chain/execution/__init__.py

@@ -10,7 +10,11 @@ This package provides:
 
 from clang_tool_chain.execution.build import build_main, build_run_main
 from clang_tool_chain.execution.core import execute_tool, run_tool, sccache_clang_cpp_main, sccache_clang_main
-from clang_tool_chain.execution.sanitizer_env import detect_sanitizers_from_flags, prepare_sanitizer_environment
+from clang_tool_chain.execution.sanitizer_env import (
+    detect_sanitizers_from_flags,
+    get_symbolizer_path,
+    prepare_sanitizer_environment,
+)
 
 __all__ = [
     # Core execution
@@ -25,4 +29,5 @@ __all__ = [
     # Sanitizer utilities
     "prepare_sanitizer_environment",
     "detect_sanitizers_from_flags",
+    "get_symbolizer_path",
 ]