clang-tool-chain 1.0.43__py3-none-any.whl → 1.0.45__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.43"
+__version__ = "1.0.45"

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/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
@@ -309,14 +310,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,136 @@
+"""
+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",
+    "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",
 ]

clang_tool_chain/execution/arg_transformers.py

@@ -35,6 +35,8 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from clang_tool_chain.env_utils import is_feature_disabled
+
 if TYPE_CHECKING:
     from clang_tool_chain.directives.parser import ParsedDirectives
 
@@ -111,6 +113,7 @@ class DirectivesTransformer(ArgumentTransformer):
 
     Environment Variables:
         CLANG_TOOL_CHAIN_NO_DIRECTIVES: Set to '1' to disable directive parsing
+        CLANG_TOOL_CHAIN_NO_AUTO: Set to '1' to disable all automatic features
         CLANG_TOOL_CHAIN_DIRECTIVE_VERBOSE: Set to '1' to enable debug logging
     """
 
@@ -119,9 +122,8 @@ class DirectivesTransformer(ArgumentTransformer):
 
     def transform(self, args: list[str], context: ToolContext) -> list[str]:
         """Add arguments from inlined build directives in source files."""
-        # Check if directives are disabled
-        if os.environ.get("CLANG_TOOL_CHAIN_NO_DIRECTIVES") == "1":
-            logger.debug("Directives disabled via CLANG_TOOL_CHAIN_NO_DIRECTIVES=1")
+        # Check if directives are disabled (via NO_DIRECTIVES or NO_AUTO)
+        if is_feature_disabled("DIRECTIVES"):
             return args
 
         # Only apply to clang/clang++ compilation commands
@@ -209,9 +211,10 @@ class LLDLinkerTransformer(ArgumentTransformer):
 
     Priority: 200 (runs after SDK but before ABI)
 
-    This transformer adds platform-specific linker flags:
-    - macOS: -fuse-ld=ld64.lld (explicit Mach-O linker, LLVM 21.x+)
-    - Linux: -fuse-ld=lld (standard ELF linker)
+    This transformer adds -fuse-ld=lld linker flag. The clang driver
+    automatically dispatches to the correct linker binary:
+    - macOS: ld64.lld (Mach-O linker)
+    - Linux: ld.lld (ELF linker)
 
     It also translates GNU ld flags to ld64.lld equivalents on macOS:
     - --no-undefined -> -undefined error
@@ -293,20 +296,28 @@ class ASANRuntimeTransformer(ArgumentTransformer):
     This transformer ensures proper ASAN runtime linking on Linux:
     - Detects -fsanitize=address flag
     - Adds -shared-libasan to use shared runtime library
+    - Adds -Wl,--allow-shlib-undefined when building shared libraries with ASAN
     - Prevents undefined symbol errors during linking
 
     The shared runtime library (libclang_rt.asan.so) contains the full
     ASAN implementation, while the static wrapper library only contains stubs.
 
+    When building shared libraries with sanitizers, the library may have undefined
+    symbols that will be provided by the sanitizer runtime when loaded. LLD by
+    default enforces no undefined symbols, so we need to allow them explicitly.
+
     Environment Variables:
         CLANG_TOOL_CHAIN_NO_SHARED_ASAN: Set to '1' to disable shared ASAN
+        CLANG_TOOL_CHAIN_NO_AUTO: Set to '1' to disable all automatic features
     """
 
     def priority(self) -> int:
         return 250
 
     def transform(self, args: list[str], context: ToolContext) -> list[str]:
-        """Add -shared-libasan when using ASAN on Linux."""
+        """Add -shared-libasan and --allow-shlib-undefined when using ASAN on Linux."""
+        import sys
+
         # Only applies to Linux clang/clang++
         if context.platform_name != "linux" or context.tool_name not in ("clang", "clang++"):
             return args
@@ -316,19 +327,38 @@ class ASANRuntimeTransformer(ArgumentTransformer):
         if not has_asan:
             return args
 
-        # Check if user disabled shared ASAN
-        if os.environ.get("CLANG_TOOL_CHAIN_NO_SHARED_ASAN") == "1":
-            logger.debug("Shared ASAN disabled via CLANG_TOOL_CHAIN_NO_SHARED_ASAN=1")
-            return args
+        result = list(args)
+        injected_flags = []
+
+        # Check if user disabled shared ASAN (via NO_SHARED_ASAN or NO_AUTO)
+        # Also check if -shared-libasan already present
+        if not is_feature_disabled("SHARED_ASAN") and "-shared-libasan" not in args:
+            # Add -shared-libasan to use shared runtime library
+            # This prevents undefined symbol errors during linking
+            logger.info("Adding -shared-libasan for ASAN runtime linking on Linux")
+            result = ["-shared-libasan"] + result
+            injected_flags.append("-shared-libasan")
+
+        # Check if building a shared library with ASAN
+        # Shared libraries need to allow undefined symbols that will be provided
+        # by the sanitizer runtime when the runner loads them
+        is_shared_lib = "-shared" in args
+        if is_shared_lib:
+            # Check if --allow-shlib-undefined already present
+            has_allow_shlib_undefined = any("--allow-shlib-undefined" in arg for arg in args)
+            if not has_allow_shlib_undefined:
+                logger.info("Adding -Wl,--allow-shlib-undefined for shared library with ASAN")
+                result = ["-Wl,--allow-shlib-undefined"] + result
+                injected_flags.append("-Wl,--allow-shlib-undefined")
+
+        # Warn on stderr if we injected flags
+        if injected_flags:
+            print(
+                f"clang-tool-chain: note: automatically injected sanitizer flags: {' '.join(injected_flags)}",
+                file=sys.stderr,
+            )
 
-        # Check if -shared-libasan already present
-        if "-shared-libasan" in args:
-            return args
-
-        # Add -shared-libasan to use shared runtime library
-        # This prevents undefined symbol errors during linking
-        logger.info("Adding -shared-libasan for ASAN runtime linking on Linux")
-        return ["-shared-libasan"] + args
+        return result
 
 
 class RPathTransformer(ArgumentTransformer):
@@ -348,6 +378,7 @@ class RPathTransformer(ArgumentTransformer):
 
     Environment Variables:
         CLANG_TOOL_CHAIN_NO_RPATH: Set to '1' to disable automatic rpath injection
+        CLANG_TOOL_CHAIN_NO_AUTO: Set to '1' to disable all automatic features
     """
 
     def priority(self) -> int:
@@ -371,9 +402,8 @@ class RPathTransformer(ArgumentTransformer):
         if not has_deploy_flag and not deploy_from_env:
             return args
 
-        # Check if user disabled rpath
-        if os.environ.get("CLANG_TOOL_CHAIN_NO_RPATH") == "1":
-            logger.debug("Rpath injection disabled via CLANG_TOOL_CHAIN_NO_RPATH=1")
+        # Check if user disabled rpath (via NO_RPATH or NO_AUTO)
+        if is_feature_disabled("RPATH"):
             return args
 
         # Check if rpath already present

clang_tool_chain/execution/build.py

@@ -26,6 +26,7 @@ from typing import NoReturn
 
 from clang_tool_chain.cli_parsers import parse_build_args, parse_build_run_args
 from clang_tool_chain.directives import DirectiveParser
+from clang_tool_chain.env_utils import is_feature_disabled
 from clang_tool_chain.execution.core import execute_tool
 from clang_tool_chain.interrupt_utils import handle_keyboard_interrupt_properly
 from clang_tool_chain.platform import get_platform_info
@@ -47,9 +48,13 @@ def _get_directive_args(source_path: Path) -> list[str]:
 
     Returns:
         List of compiler/linker arguments derived from directives
+
+    Environment Variables:
+        CLANG_TOOL_CHAIN_NO_DIRECTIVES: Set to '1' to disable directive parsing
+        CLANG_TOOL_CHAIN_NO_AUTO: Set to '1' to disable all automatic features
     """
-    # Check if directives parsing is disabled via environment variable
-    if os.environ.get("CLANG_TOOL_CHAIN_NO_DIRECTIVES", "").lower() in ("1", "true", "yes"):
+    # Check if directives parsing is disabled (via NO_DIRECTIVES or NO_AUTO)
+    if is_feature_disabled("DIRECTIVES"):
         return []
 
     try:
@@ -106,10 +111,11 @@ def get_directive_args_from_compiler_args(args: list[str]) -> list[str]:
 
     Environment Variables:
         CLANG_TOOL_CHAIN_NO_DIRECTIVES: Set to '1' to disable directive parsing
+        CLANG_TOOL_CHAIN_NO_AUTO: Set to '1' to disable all automatic features
         CLANG_TOOL_CHAIN_DIRECTIVE_VERBOSE: Set to '1' to show parsed directives
     """
-    # Check if directives parsing is disabled via environment variable
-    if os.environ.get("CLANG_TOOL_CHAIN_NO_DIRECTIVES", "").lower() in ("1", "true", "yes"):
+    # Check if directives parsing is disabled (via NO_DIRECTIVES or NO_AUTO)
+    if is_feature_disabled("DIRECTIVES"):
         return []
 
     directive_args: list[str] = []

clang_tool_chain/execution/build_pipeline.py

@@ -24,6 +24,7 @@ from pathlib import Path
 from typing import NoReturn
 
 from clang_tool_chain.directives import DirectiveParser
+from clang_tool_chain.env_utils import is_feature_disabled
 from clang_tool_chain.execution.core import run_tool
 from clang_tool_chain.interrupt_utils import handle_keyboard_interrupt_properly
 
@@ -109,9 +110,13 @@ def _get_directive_args(source_path: Path) -> list[str]:
 
     Returns:
         List of compiler/linker arguments derived from directives
+
+    Environment Variables:
+        CLANG_TOOL_CHAIN_NO_DIRECTIVES: Set to '1' to disable directive parsing
+        CLANG_TOOL_CHAIN_NO_AUTO: Set to '1' to disable all automatic features
     """
-    # Check if directives parsing is disabled via environment variable
-    if os.environ.get("CLANG_TOOL_CHAIN_NO_DIRECTIVES", "").lower() in ("1", "true", "yes"):
+    # Check if directives parsing is disabled (via NO_DIRECTIVES or NO_AUTO)
+    if is_feature_disabled("DIRECTIVES"):
         return []
 
     try:

clang_tool_chain/execution/sanitizer_env.py

@@ -1,16 +1,23 @@
 """
 Sanitizer runtime environment configuration.
 
-This module provides automatic injection of ASAN_OPTIONS and LSAN_OPTIONS
-environment variables to improve stack trace quality when running executables
-compiled with Address Sanitizer or Leak Sanitizer.
+This module provides automatic injection of ASAN_OPTIONS, LSAN_OPTIONS, and
+ASAN_SYMBOLIZER_PATH environment variables to improve stack trace quality
+when running executables compiled with Address Sanitizer or Leak Sanitizer.
 
 The default options fix <unknown module> entries in stack traces from
 dlopen()'d shared libraries by enabling slow unwinding and symbolization.
+
+The symbolizer path is automatically detected from the clang-tool-chain
+installation, enabling proper address-to-symbol resolution without manual
+configuration.
 """
 
 import logging
 import os
+import shutil
+
+from clang_tool_chain.env_utils import is_feature_disabled
 
 logger = logging.getLogger(__name__)
 
@@ -22,6 +29,46 @@ DEFAULT_ASAN_OPTIONS = "fast_unwind_on_malloc=0:symbolize=1:detect_leaks=1"
 DEFAULT_LSAN_OPTIONS = "fast_unwind_on_malloc=0:symbolize=1"
 
 
+def get_symbolizer_path() -> str | None:
+    """
+    Get the path to llvm-symbolizer from the clang-tool-chain installation.
+
+    This function finds the llvm-symbolizer binary bundled with clang-tool-chain,
+    which is required by ASAN/LSAN to convert memory addresses into function names
+    and source locations in stack traces.
+
+    Returns:
+        Absolute path to llvm-symbolizer, or None if not found.
+
+    Example:
+        >>> path = get_symbolizer_path()
+        >>> if path:
+        ...     os.environ["ASAN_SYMBOLIZER_PATH"] = path
+
+    Note:
+        Falls back to system PATH if the clang-tool-chain binary is not available.
+        This allows the function to work even when clang-tool-chain is not fully
+        installed (e.g., during development or in CI environments).
+    """
+    # Try to find llvm-symbolizer from clang-tool-chain installation
+    try:
+        from clang_tool_chain.platform.paths import find_tool_binary
+
+        symbolizer = find_tool_binary("llvm-symbolizer")
+        return str(symbolizer)
+    except (ImportError, RuntimeError) as e:
+        logger.debug(f"Could not find llvm-symbolizer in clang-tool-chain: {e}")
+
+    # Fall back to system PATH
+    system_symbolizer = shutil.which("llvm-symbolizer")
+    if system_symbolizer:
+        logger.debug(f"Using system llvm-symbolizer: {system_symbolizer}")
+        return system_symbolizer
+
+    logger.debug("llvm-symbolizer not found in clang-tool-chain or system PATH")
+    return None
+
+
 def detect_sanitizers_from_flags(compiler_flags: list[str]) -> tuple[bool, bool]:
     """
     Detect which sanitizers are enabled from compiler flags.
@@ -64,12 +111,16 @@ def prepare_sanitizer_environment(
     compiler_flags: list[str] | None = None,
 ) -> dict[str, str]:
     """
-    Prepare environment with optimal sanitizer options.
+    Prepare environment with optimal sanitizer options and symbolizer path.
 
-    This function injects ASAN_OPTIONS and/or LSAN_OPTIONS environment variables
-    if they are not already set by the user AND the corresponding sanitizer was
-    enabled during compilation. The injected options improve stack trace quality
-    for executables using dlopen()'d shared libraries.
+    This function injects ASAN_OPTIONS, LSAN_OPTIONS, and ASAN_SYMBOLIZER_PATH
+    environment variables if they are not already set by the user AND the
+    corresponding sanitizer was enabled during compilation. The injected options
+    improve stack trace quality for executables using dlopen()'d shared libraries.
+
+    The ASAN_SYMBOLIZER_PATH is automatically detected from the clang-tool-chain
+    installation, enabling proper address-to-symbol resolution (function names,
+    file paths, line numbers) without manual configuration.
 
     Args:
         base_env: Base environment dictionary to modify. If None, uses os.environ.
@@ -83,20 +134,21 @@ def prepare_sanitizer_environment(
     Environment Variables:
         CLANG_TOOL_CHAIN_NO_SANITIZER_ENV: Set to "1", "true", or "yes" to
             disable automatic injection of sanitizer options.
+        CLANG_TOOL_CHAIN_NO_AUTO: Set to "1" to disable all automatic features.
         ASAN_OPTIONS: If already set, preserved as-is (user config takes priority).
         LSAN_OPTIONS: If already set, preserved as-is (user config takes priority).
+        ASAN_SYMBOLIZER_PATH: If already set, preserved as-is (user config takes priority).
 
     Example:
         >>> env = prepare_sanitizer_environment(compiler_flags=["-fsanitize=address"])
-        >>> # env now contains ASAN_OPTIONS and LSAN_OPTIONS
+        >>> # env now contains ASAN_OPTIONS, LSAN_OPTIONS, and ASAN_SYMBOLIZER_PATH
         >>> env = prepare_sanitizer_environment(compiler_flags=["-O2"])
         >>> # env unchanged - no sanitizers enabled
     """
     env = base_env.copy() if base_env is not None else os.environ.copy()
 
-    # Check if disabled via environment variable
-    if os.environ.get("CLANG_TOOL_CHAIN_NO_SANITIZER_ENV", "").lower() in ("1", "true", "yes"):
-        logger.debug("Sanitizer environment injection disabled via CLANG_TOOL_CHAIN_NO_SANITIZER_ENV")
+    # Check if disabled via environment variable (NO_SANITIZER_ENV or NO_AUTO)
+    if is_feature_disabled("SANITIZER_ENV"):
         return env
 
     # If no compiler flags provided, don't inject anything (safe default)
@@ -117,4 +169,17 @@ def prepare_sanitizer_environment(
         env["LSAN_OPTIONS"] = DEFAULT_LSAN_OPTIONS
         logger.info(f"Injecting LSAN_OPTIONS={DEFAULT_LSAN_OPTIONS}")
 
+    # Inject ASAN_SYMBOLIZER_PATH if any sanitizer is enabled and not already set
+    if (asan_enabled or lsan_enabled) and "ASAN_SYMBOLIZER_PATH" not in env:
+        symbolizer_path = get_symbolizer_path()
+        if symbolizer_path:
+            env["ASAN_SYMBOLIZER_PATH"] = symbolizer_path
+            logger.info(f"Injecting ASAN_SYMBOLIZER_PATH={symbolizer_path}")
+        else:
+            logger.warning(
+                "llvm-symbolizer not found - ASAN/LSAN stack traces may show "
+                "raw addresses instead of function names. Install llvm-symbolizer "
+                "or ensure clang-tool-chain is properly installed."
+            )
+
     return env

clang_tool_chain/linker/lld.py

@@ -35,11 +35,12 @@ def _llvm_supports_ld64_lld_flag() -> bool:
     """
     Check if the current platform's LLVM version supports -fuse-ld=ld64.lld.
 
-    The -fuse-ld=ld64.lld flag is only recognized by LLVM 21.x and later.
-    Earlier versions require -fuse-ld=lld (which auto-detects Mach-O from target).
+    Note: The clang driver does NOT recognize -fuse-ld=ld64.lld as a valid option.
+    This function exists for backward compatibility but always returns False in practice
+    because -fuse-ld=lld should be used instead (clang auto-dispatches to ld64.lld on Darwin).
 
     Returns:
-        True if LLVM >= 21.x, False otherwise.
+        True if LLVM >= 21.x (but we always fall back to -fuse-ld=lld anyway)
     """
     from ..platform.detection import get_platform_info
 
@@ -272,6 +273,39 @@ def _user_specified_lld_on_macos(args: list[str]) -> bool:
     return "-fuse-ld=lld" in args_str or "-fuse-ld=ld64.lld" in args_str
 
 
+def _user_specified_ld64_lld(args: list[str]) -> bool:
+    """
+    Check if the user explicitly specified -fuse-ld=ld64.lld.
+
+    This is used to emit a warning that the flag will be auto-converted
+    to -fuse-ld=lld since clang driver doesn't recognize ld64.lld.
+
+    Args:
+        args: Command-line arguments
+
+    Returns:
+        True if user specified -fuse-ld=ld64.lld
+    """
+    return any("-fuse-ld=ld64.lld" in arg for arg in args)
+
+
+def _convert_ld64_lld_to_lld(args: list[str]) -> list[str]:
+    """
+    Convert -fuse-ld=ld64.lld to -fuse-ld=lld in arguments.
+
+    The clang driver does not recognize -fuse-ld=ld64.lld as a valid option.
+    This function converts it to -fuse-ld=lld which the driver recognizes
+    and automatically dispatches to ld64.lld on Darwin targets.
+
+    Args:
+        args: Original compiler arguments
+
+    Returns:
+        Modified arguments with -fuse-ld=ld64.lld replaced by -fuse-ld=lld
+    """
+    return [arg.replace("-fuse-ld=ld64.lld", "-fuse-ld=lld") for arg in args]
+
+
 # pyright: reportUnusedFunction=false
 def _add_lld_linker_if_needed(platform_name: str, args: list[str]) -> list[str]:
     """
@@ -284,9 +318,10 @@ def _add_lld_linker_if_needed(platform_name: str, args: list[str]) -> list[str]:
     - Faster linking performance
     - Uniform toolchain across all platforms
 
-    Platform-specific linker flags:
-    - macOS: Uses -fuse-ld=ld64.lld (explicit Mach-O variant required by LLVM 21.x+)
-    - Linux: Uses -fuse-ld=lld (standard ELF linker)
+    Platform-specific behavior:
+    - Uses -fuse-ld=lld on all platforms (clang driver auto-dispatches)
+    - macOS: Clang driver finds ld64.lld (Mach-O linker)
+    - Linux: Clang driver finds ld.lld (ELF linker)
 
     The function is skipped when:
     - User sets CLANG_TOOL_CHAIN_USE_SYSTEM_LD=1
@@ -302,14 +337,25 @@ def _add_lld_linker_if_needed(platform_name: str, args: list[str]) -> list[str]:
         args: Original compiler arguments
 
     Returns:
-        Modified arguments with platform-specific -fuse-ld flag prepended if needed
+        Modified arguments with -fuse-ld=lld flag prepended if needed
     """
     # On macOS, if user explicitly specified LLD, we still need to translate flags
     # and ensure ld64.lld symlink exists, even though we don't inject the -fuse-ld flag ourselves
     if platform_name == "darwin" and _user_specified_lld_on_macos(args):
         logger.debug("User specified LLD on macOS, translating GNU ld flags to ld64.lld equivalents")
-        # Ensure ld64.lld symlink exists for user-specified -fuse-ld=ld64.lld
+        # Ensure ld64.lld symlink exists for lld to dispatch to Mach-O mode
         _ensure_ld64_lld_symlink()
+
+        # Check if user specified -fuse-ld=ld64.lld (which is not a valid clang driver option)
+        # and emit a warning about the auto-conversion to -fuse-ld=lld
+        if _user_specified_ld64_lld(args):
+            print(
+                "[clang-tool-chain] Warning: -fuse-ld=ld64.lld is not a valid clang driver option. "
+                "Auto-converting to -fuse-ld=lld (clang driver auto-dispatches to ld64.lld on Darwin).",
+                file=sys.stderr,
+            )
+            args = _convert_ld64_lld_to_lld(args)
+
         return _translate_linker_flags_for_macos_lld(args)
 
     if not _should_force_lld(platform_name, args):
@@ -320,22 +366,13 @@ def _add_lld_linker_if_needed(platform_name: str, args: list[str]) -> list[str]:
     # On macOS, translate GNU ld flags to ld64.lld equivalents
     if platform_name == "darwin":
         args = _translate_linker_flags_for_macos_lld(args)
+        # Ensure ld64.lld symlink exists for lld to dispatch to Mach-O mode
+        _ensure_ld64_lld_symlink()
 
-        # Check LLVM version to determine the correct linker flag
-        if _llvm_supports_ld64_lld_flag():
-            # LLVM 21.x+ supports explicit -fuse-ld=ld64.lld
-            _ensure_ld64_lld_symlink()
-            return ["-fuse-ld=ld64.lld"] + args
-        else:
-            # LLVM < 21.x: rewrite to -fuse-ld=lld with compatibility notice
-            version = _get_llvm_version_for_platform()
-            version_str = f"{version[0]}.{version[1]}.{version[2]}"
-            print(
-                f"[clang-tool-chain] LLVM {version_str} does not support -fuse-ld=ld64.lld, "
-                f"using -fuse-ld=lld instead (lld auto-detects Mach-O from target)",
-                file=sys.stderr,
-            )
-            return ["-fuse-ld=lld"] + args
-    else:
-        # Linux uses standard lld
-        return ["-fuse-ld=lld"] + args
+    # Always use -fuse-ld=lld on all platforms.
+    # Note: -fuse-ld=ld64.lld is NOT a valid clang driver option.
+    # The clang driver only recognizes generic names like "lld", "gold", "bfd".
+    # When -fuse-ld=lld is used, clang automatically dispatches to:
+    # - Darwin: ld64.lld (Mach-O linker)
+    # - Linux: ld.lld (ELF linker)
+    return ["-fuse-ld=lld"] + args

clang_tool_chain/wrapper.py

@@ -151,6 +151,15 @@ from clang_tool_chain.execution.lldb import (
     get_lldb_binary_dir,
 )
 
+# ============================================================================
+# Sanitizer Environment
+# ============================================================================
+from clang_tool_chain.execution.sanitizer_env import (
+    detect_sanitizers_from_flags,
+    get_symbolizer_path,
+    prepare_sanitizer_environment,
+)
+
 # ============================================================================
 # Linker Configuration
 # ============================================================================
@@ -218,6 +227,10 @@ __all__ = [
     "run_tool",
     "sccache_clang_main",
     "sccache_clang_cpp_main",
+    # Sanitizer Environment
+    "prepare_sanitizer_environment",
+    "detect_sanitizers_from_flags",
+    "get_symbolizer_path",
     # Emscripten
     "ensure_nodejs_available",
     "execute_emscripten_tool",

{clang_tool_chain-1.0.43.dist-info → clang_tool_chain-1.0.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clang-tool-chain
-Version: 1.0.43
+Version: 1.0.45
 Summary: Clang Tool Chain - C/C++ compilation toolchain utilities
 Project-URL: Homepage, https://github.com/zackees/clang-tool-chain
 Project-URL: Repository, https://github.com/zackees/clang-tool-chain
@@ -717,11 +717,8 @@ clang-tool-chain-cpp main.cpp -o program --deploy-dependencies -lunwind
 
 **Disable deployment:**
 ```bash
-# Cross-platform (modern)
+# Cross-platform
 export CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS=1
-
-# Windows-specific (legacy)
-export CLANG_TOOL_CHAIN_NO_DEPLOY_DLLS=1
 ```
 
 **Enable verbose logging:**
@@ -791,7 +788,7 @@ jobs:
 **Key Environment Variables:**
 - `CLANG_TOOL_CHAIN_DOWNLOAD_PATH` - Override installation location
 - `CLANG_TOOL_CHAIN_NO_DEPLOY_LIBS` - Disable automatic library deployment (all platforms)
-- `CLANG_TOOL_CHAIN_NO_DEPLOY_DLLS` - Disable Windows DLL deployment (legacy, Windows only)
+- `CLANG_TOOL_CHAIN_NO_DEPLOY_SHARED_LIB` - Disable library deployment for shared library outputs only
 - `CLANG_TOOL_CHAIN_LIB_DEPLOY_VERBOSE` - Enable verbose library deployment logging
 - `CLANG_TOOL_CHAIN_USE_SYSTEM_LD` - Use system linker instead of LLD
 - `CLANG_TOOL_CHAIN_NO_DIRECTIVES` - Disable inlined build directives
@@ -863,16 +860,42 @@ When running executables via `clang-tool-chain-build-run`, optimal sanitizer opt
 
 - `ASAN_OPTIONS=fast_unwind_on_malloc=0:symbolize=1:detect_leaks=1` (when `-fsanitize=address` is used)
 - `LSAN_OPTIONS=fast_unwind_on_malloc=0:symbolize=1` (when `-fsanitize=address` or `-fsanitize=leak` is used)
+- `ASAN_SYMBOLIZER_PATH=/path/to/llvm-symbolizer` (automatically detected from clang-tool-chain)
 
 **What these options fix:**
 - `<unknown module>` entries in stack traces from `dlopen()`'d shared libraries
-- Missing function names in crash reports
+- Missing function names in crash reports (raw addresses like `0x7f5a4f15ac1d` instead of `my_function`)
 - Incomplete leak detection
 
-**Your options are always preserved** - if you set `ASAN_OPTIONS` or `LSAN_OPTIONS` yourself, clang-tool-chain won't override them.
+**Your options are always preserved** - if you set `ASAN_OPTIONS`, `LSAN_OPTIONS`, or `ASAN_SYMBOLIZER_PATH` yourself, clang-tool-chain won't override them.
 
 **Regular builds are unaffected** - sanitizer options are only injected when the compiler flags indicate sanitizers are being used.
 
+### Programmatic API (For Build Systems)
+
+External build systems can use the sanitizer environment API to get properly configured environments:
+
+```python
+from clang_tool_chain import prepare_sanitizer_environment, get_symbolizer_path
+
+# Option A: Complete environment setup (recommended)
+env = prepare_sanitizer_environment(
+    base_env=os.environ.copy(),
+    compiler_flags=["-fsanitize=address", "-O2"]
+)
+# env now contains ASAN_OPTIONS, LSAN_OPTIONS, and ASAN_SYMBOLIZER_PATH
+
+# Option B: Just get the symbolizer path
+symbolizer = get_symbolizer_path()
+if symbolizer:
+    os.environ["ASAN_SYMBOLIZER_PATH"] = symbolizer
+```
+
+**Available functions:**
+- `prepare_sanitizer_environment(base_env, compiler_flags)` - Returns environment dict with all sanitizer variables
+- `get_symbolizer_path()` - Returns path to `llvm-symbolizer` or `None`
+- `detect_sanitizers_from_flags(flags)` - Returns `(asan_enabled, lsan_enabled)` tuple
+
 ### Configuration
 
 ```bash
@@ -888,6 +911,31 @@ export CLANG_TOOL_CHAIN_NO_SHARED_ASAN=1
 - **Windows**: Works with both GNU and MSVC ABIs
 - **macOS**: Uses bundled LLVM ASAN runtime
 
+### Dynamically Loaded Libraries
+
+If you see `<unknown module>` in ASAN/LSAN stack traces for code in dynamically loaded libraries, apply these fixes:
+
+**1. Use `RTLD_NOW | RTLD_GLOBAL` (not `RTLD_LAZY`)**
+
+```cpp
+void* handle = dlopen(path, RTLD_NOW | RTLD_GLOBAL);  // Good
+void* handle = dlopen(path, RTLD_LAZY);               // Bad - causes <unknown module>
+```
+
+**2. Skip `dlclose()` when ASAN is active**
+
+ASAN symbolizes at exit; if the library is unloaded, addresses become `<unknown module>`.
+
+```cpp
+#if !defined(__SANITIZE_ADDRESS__)
+    dlclose(handle);  // Only close when not running under ASAN
+#endif
+```
+
+On Windows, use the same pattern with `FreeLibrary()`.
+
+See: https://github.com/google/sanitizers/issues/899
+
 ---
 
 ## 🔧 How It Works

{clang_tool_chain-1.0.43.dist-info → clang_tool_chain-1.0.45.dist-info}/RECORD

@@ -1,5 +1,5 @@
-clang_tool_chain/__init__.py,sha256=w3f1hdA72SH-WsfwesNTQbTeiXIlhV8ignySXrV3SfU,23
-clang_tool_chain/__version__.py,sha256=6gmxA-SFNIuF2QL2LcQn3fYERY3gD95uxieCn2hdE7o,72
+clang_tool_chain/__init__.py,sha256=u-qgOuQxh5W2g7n8BgUtBnUWsK66rM4N6LJXY9PiEx0,880
+clang_tool_chain/__version__.py,sha256=QaMskYdjKBucedCuNyKFMIEERieKWeom7OJJ_fjGce4,72
 clang_tool_chain/archive.py,sha256=t3reh7cm5XP2rhTqfRIDAQZv5XQq7SsstyiROYg8wFA,27697
 clang_tool_chain/archive_cache.py,sha256=5ZmlwXIJZDcrDFkTbdgBQYN9sulGn0WyI6qwWqC4HEU,6806
 clang_tool_chain/checksums.py,sha256=KFXeAeDz5ZlcZVOxsHDpNDCrm9UDoJ8bMA4PeNhuzdA,9868
@@ -9,6 +9,7 @@ clang_tool_chain/cli_parsers.py,sha256=cHVDyW75N_Kao1VYeAgw_L-1K65DjyvWUigQScTFi
 clang_tool_chain/component_db.py,sha256=ohtlycsrEokui83iZyPsTyxmvXgkD7_OpVwAn1Cq8gI,9096
 clang_tool_chain/downloader.py,sha256=fqErxTaI3oEYbloLZnrWXJ26j2iGOngPnl4i8kqOWNs,6041
 clang_tool_chain/env_breadcrumbs.py,sha256=bvPTz8xABILhzrXTEBzdGrSbpEXLf2YVgcYEe-IdhNY,2335
+clang_tool_chain/env_utils.py,sha256=cNlsZ-BchlKh5BDe6kmGYKU3A8jxFFSn4atv2_pPc1Y,4169
 clang_tool_chain/fetch.py,sha256=DwsNl5DZkNqEYXL-FbCTnp6IA2iCAa9pMl5oPjyuOS4,4696
 clang_tool_chain/installer.py,sha256=GuGeUvVcAw4HMj9jrub-I11ixmksw-vgtSOFrlupmPA,3323
 clang_tool_chain/interrupt_utils.py,sha256=7YvazvGzyItRVDZ_pzUSK6at8PCw-Dgih69HLSz0tT4,1153
@@ -21,7 +22,7 @@ clang_tool_chain/paths.py,sha256=DwgWAAiLmPInpLDFMqyNFUyNYmkowWN626SwrMMx200,280
 clang_tool_chain/permissions.py,sha256=Okt91_fk4I0UmEiUAktqxm3OZfZQ3rUW-0r2X_seuxY,8517
 clang_tool_chain/sccache_runner.py,sha256=xkepFC4Ti8s6wv7GXA24REFj8jli86nSUqcY7TCOQzk,12810
 clang_tool_chain/settings_warnings.py,sha256=mspKHUT0Bod_SnSLyEo6Tix0ANTMn0erVLsn82jWr4I,3523
-clang_tool_chain/wrapper.py,sha256=v_8oLesqYAD3cW5iJLT0z0WOzfP2bwrHJwr0jpXx9dk,8031
+clang_tool_chain/wrapper.py,sha256=mMLydq43AZjUc24QU6TtiMCH8jyVh1BBHY5XMWLSeX0,8493
 clang_tool_chain/abi/__init__.py,sha256=GBiAN5W2TovaZ2MzVFFV5J3udiOn4ME0CN6oGS2FMDM,922
 clang_tool_chain/abi/windows_gnu.py,sha256=ZN7xVWwoBEILi7A_FG8NBBiN5gtrXYscgmixFMEm9zg,10517
 clang_tool_chain/abi/windows_msvc.py,sha256=Z-f6HGjkBcrguDfo62qOP5cI_2EYwjQ9k3Cgnpf42Fo,3617
@@ -29,17 +30,17 @@ clang_tool_chain/commands/__init__.py,sha256=KpJD6wLVa5t3JVSjS5BQ8EUaALc5pc7SqyW
 clang_tool_chain/commands/entry_points.py,sha256=mJ3ZZkYJqoT2JqMi6m8us0w8tf5_b7QnmDR30_yij00,13824
 clang_tool_chain/deployment/__init__.py,sha256=1Bv8kpwyTd3LN9HNHVWFwkznXLbTdbOC5PLvrnDhtR0,356
 clang_tool_chain/deployment/base_deployer.py,sha256=-02O-EJllRTAYnPcBWAilfuvGWTGvpK1EG6TRnBC8_k,11565
-clang_tool_chain/deployment/dll_deployer.py,sha256=YRxO0o_6b7UhqfuT3NQk3pFIkn8tteJpXZJalnzhkuA,25392
+clang_tool_chain/deployment/dll_deployer.py,sha256=x3_hXsPgyQMkp1orzZV4lAZa4NMP27t0B1ajYBBbzmA,24840
 clang_tool_chain/deployment/dll_detector.py,sha256=Zf2NAjAg6bEg6uvb7dFkj0qvk8Mvzj4sjyPIoxNVvJE,8629
-clang_tool_chain/deployment/dylib_deployer.py,sha256=daTPpT9VByHMfIUAE3oHq9pCeinuDDNeq-U2iTvMTz4,19265
+clang_tool_chain/deployment/dylib_deployer.py,sha256=6GLn_CMLYUAdQZgwcTMx0XXo_AxGvUKUFYt04v2Kip0,19315
 clang_tool_chain/deployment/factory.py,sha256=Mq6cMMUctoYBZ81I16_hXUmDLQGSAngCmBzPlu_0iaU,6205
-clang_tool_chain/deployment/so_deployer.py,sha256=9mRKcJUXKV-8vXWJGdsUkB5cTPWjmToFUcHTVTCHdVk,11527
+clang_tool_chain/deployment/so_deployer.py,sha256=i3ezy1gOOHlzH5lHNytPl2FBXu7AX-F3r1uXHFEKfmg,11892
 clang_tool_chain/directives/__init__.py,sha256=MJDNYL_MD2MF0HFsrTsSTX645bYo6vtjq2pOTtfykaU,198
 clang_tool_chain/directives/parser.py,sha256=6J7mO1JtvuHkkKS0Xges5b_jT9b3uTF6ULI0ZiwGAdw,11179
-clang_tool_chain/execution/__init__.py,sha256=wSYnlGmfTlaUPEKwW6PgwlxKTti6Wa5yyVjXVipdpcY,875
-clang_tool_chain/execution/arg_transformers.py,sha256=YkGqz_vbfNE-yFXHnzZREbS1T545AfQcV0DJTkU59YM,18254
-clang_tool_chain/execution/build.py,sha256=PCtHw31WXbjCp2K_qaf1liaCiIjD49036cknqdQyhJM,13040
-clang_tool_chain/execution/build_pipeline.py,sha256=piqh7P2-GR0mVOik3OUGRFqWFIRr8LQM3PU7TcBsujk,17622
+clang_tool_chain/execution/__init__.py,sha256=fFQEW9VejCdbBvt4quNJ2X8udh_PKgewTfzUXHmXzyc,940
+clang_tool_chain/execution/arg_transformers.py,sha256=8RDaUF2r3dgSqQ_2XkGiXnmoLGD3ltaf4YbqkyjG2CI,19772
+clang_tool_chain/execution/build.py,sha256=YHS1BJTZg5pBS9czVko41mBdfswSPad5hxfitMoLvsI,13275
+clang_tool_chain/execution/build_pipeline.py,sha256=ORJEJ8WYp8c7bhWAa-e3w_ySXwenpUczlmXgoGByToY,17823
 clang_tool_chain/execution/core.py,sha256=7CJ0azznC5lq5bw8amk2kwCIN2I_OnDiKytpapkvrdY,25273
 clang_tool_chain/execution/cosmocc.py,sha256=oGlaPK6Jpz3FaohEkWpRz8sRNu2sT-HYCoIf9xBxJHk,13319
 clang_tool_chain/execution/emscripten.py,sha256=lgxPQpeB1_wWxNILgeyyrW5lEn117dHS9dQ3ikHRn1w,44235
@@ -47,7 +48,7 @@ clang_tool_chain/execution/iwyu.py,sha256=bmP0d_PZObA1JfmFYp3qIOKCb7y32AWPm2_ReF
 clang_tool_chain/execution/lldb.py,sha256=VpxkWTPS6PsyskaKTALeziR5Z5NLwarW174Fm1SMX9k,20718
 clang_tool_chain/execution/nodejs_resolver.py,sha256=8QsJWvIfmt5mBDV7n0ypSjsPyXS-eZTizhBli937I-g,11172
 clang_tool_chain/execution/platform_executor.py,sha256=sF4GyW0ujy2EewG8y2Eo1gUWGzss5G5iIkv02w7-2_o,14362
-clang_tool_chain/execution/sanitizer_env.py,sha256=lrGX17BriqYPsHCCrQnwjw0ttnp9mezsq0eYAOLfBag,4853
+clang_tool_chain/execution/sanitizer_env.py,sha256=g07hDdicGI2QqHzahLm8CKm6c-SthLAkR8kANbPxBIU,7583
 clang_tool_chain/installers/__init__.py,sha256=NAV5woPCEDKSbFr1UmfQsrg4Ua5UdghN4q7H3ymvRsg,279
 clang_tool_chain/installers/base.py,sha256=OS78bau9zoYPitmhla7pKsfCPEj-zLY0DkvVzjE31Tw,15437
 clang_tool_chain/installers/clang.py,sha256=rUtheVRF7mq_1YdmQ3XzIybrJqsHbm2Xf0cbhRbH7RQ,16994
@@ -57,7 +58,7 @@ clang_tool_chain/installers/iwyu.py,sha256=9aAhdGtOTY6BrLuPtladY8Y2mz1i7FjgbMxZf
 clang_tool_chain/installers/lldb.py,sha256=FpG8NMNQk8PoNfg6aeU_plmSQrVET7zo-pTvoK8z838,2261
 clang_tool_chain/installers/nodejs.py,sha256=5N07rotgmCfUaDm1uJfBlIAFKC1iTpgZT0HBRuoYwKI,9343
 clang_tool_chain/linker/__init__.py,sha256=ghzDFpZ2-gPmdDO6K05C7yNbY6pZLANPuUks9TaQwVY,537
-clang_tool_chain/linker/lld.py,sha256=J8XXtz0DaabnNFReSJCXgk37NloUvrIkjp5TzIZ7Tg8,12468
+clang_tool_chain/linker/lld.py,sha256=08qkvoK4-8yACm34GfZzp3vM8rZYHCv_M9fjUeSetd0,13826
 clang_tool_chain/platform/__init__.py,sha256=WkV9Y25ua0mtzEGcsIxF-qExtroSTAMKkcElWuQF2BE,342
 clang_tool_chain/platform/detection.py,sha256=PLHyUfmQ5xuohhpz0KSXJWK3d0u0fCsjx1DbM8f1CxQ,5470
 clang_tool_chain/platform/paths.py,sha256=K0IjeVwbmgPlAWQO8mS3r1WS4C2dN6IYrSqPpckeT5c,6088
@@ -67,8 +68,8 @@ clang_tool_chain/sdk/windows.py,sha256=8zMLAoFz2OKMz-w6Kqxr3A-6Cofto2VWZvCvRi7kn
 clang_tool_chain/testing/__init__.py,sha256=-sYqOOCuTV_u-MkmExrD4uKdTHG4RmMwR3D1kIG281Q,208
 clang_tool_chain/testing/diagnostic_runner.py,sha256=mnmFUEOQulY3-Ggu6hKVGZwjrKQNmV6kY80PRTUu2qU,5293
 clang_tool_chain/testing/diagnostic_tests.py,sha256=GmtKWrDcddZTpx9_yIKfhRAy6YOde8dj7SksCWVEME4,6019
-clang_tool_chain-1.0.43.dist-info/METADATA,sha256=BEMrWFJ8AIyAAdlb5v0CfKWkfKr1I-BNYkzoNAv2H6w,50425
-clang_tool_chain-1.0.43.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-clang_tool_chain-1.0.43.dist-info/entry_points.txt,sha256=DBfnqZJzHFoO6rldGY3ESaX-z2ydAvIueUPM9ss9M-w,2728
-clang_tool_chain-1.0.43.dist-info/licenses/LICENSE,sha256=51FO1oc2pZbQNI0v0_THnznnZIF4iFgawG1xnQ58kKo,10997
-clang_tool_chain-1.0.43.dist-info/RECORD,,
+clang_tool_chain-1.0.45.dist-info/METADATA,sha256=ZZZzJS3byKeOW3nToE5HXQjpIiKFNNkY2KI-dvNc2E0,52205
+clang_tool_chain-1.0.45.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+clang_tool_chain-1.0.45.dist-info/entry_points.txt,sha256=DBfnqZJzHFoO6rldGY3ESaX-z2ydAvIueUPM9ss9M-w,2728
+clang_tool_chain-1.0.45.dist-info/licenses/LICENSE,sha256=51FO1oc2pZbQNI0v0_THnznnZIF4iFgawG1xnQ58kKo,10997
+clang_tool_chain-1.0.45.dist-info/RECORD,,