clang-tool-chain 1.0.45__py3-none-any.whl → 1.1.0__py3-none-any.whl

clang_tool_chain/__version__.py

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

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

@@ -36,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
     ]
 
@@ -206,6 +208,19 @@ class SoDeployer(BaseLibraryDeployer):
                     if resolved.exists():
                         return resolved
 
+                # For sanitizer runtimes, try architecture-suffixed variants
+                # e.g., libclang_rt.asan.so -> libclang_rt.asan-x86_64.so
+                if lib_name.startswith("libclang_rt.") and lib_name.endswith(".so"):
+                    base_name = lib_name[:-3]  # Remove .so
+                    arch_suffixes = ["-x86_64", "-aarch64", "-arm64"]
+                    for suffix in arch_suffixes:
+                        arch_lib_path = search_dir / f"{base_name}{suffix}.so"
+                        if arch_lib_path.exists():
+                            resolved = arch_lib_path.resolve()
+                            if resolved.exists():
+                                self.logger.debug(f"Found architecture-suffixed variant: {arch_lib_path}")
+                                return resolved
+
             return None
 
         except KeyboardInterrupt as ke:

clang_tool_chain/env_utils.py

@@ -26,6 +26,7 @@ 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)",

clang_tool_chain/execution/arg_transformers.py

@@ -14,9 +14,12 @@ The Chain of Responsibility pattern allows:
 
 Architecture:
     ArgumentTransformer (ABC)
-        ├── MacOSSDKTransformer (priority=100)
         ├── DirectivesTransformer (priority=50)
+        ├── MacOSSDKTransformer (priority=100)
+        ├── LinuxUnwindTransformer (priority=150)
         ├── LLDLinkerTransformer (priority=200)
+        ├── ASANRuntimeTransformer (priority=250)
+        ├── RPathTransformer (priority=275)
         ├── GNUABITransformer (priority=300)
         └── MSVCABITransformer (priority=300)
 
@@ -205,6 +208,86 @@ class MacOSSDKTransformer(ArgumentTransformer):
         return _add_macos_sysroot_if_needed(args)
 
 
+class LinuxUnwindTransformer(ArgumentTransformer):
+    """
+    Transformer for adding bundled libunwind include/library paths on Linux.
+
+    Priority: 150 (runs after SDK but before linker)
+
+    This transformer adds include and library paths for the bundled libunwind
+    headers and libraries on Linux. This allows compilation of code that uses
+    libunwind without requiring system libunwind-dev to be installed.
+
+    When libunwind.h exists in the clang toolchain's include directory:
+    - Adds -I<clang_root>/include for header discovery
+    - Adds -L<clang_root>/lib for library discovery
+    - Adds -Wl,-rpath,<clang_root>/lib for runtime library discovery
+
+    Environment Variables:
+        CLANG_TOOL_CHAIN_NO_BUNDLED_UNWIND: Set to '1' to disable bundled libunwind
+        CLANG_TOOL_CHAIN_NO_AUTO: Set to '1' to disable all automatic features
+    """
+
+    def priority(self) -> int:
+        return 150
+
+    def transform(self, args: list[str], context: ToolContext) -> list[str]:
+        """Add bundled libunwind paths if available on Linux."""
+        # Only applies to Linux clang/clang++
+        if context.platform_name != "linux" or context.tool_name not in ("clang", "clang++"):
+            return args
+
+        # Check if disabled (via NO_BUNDLED_UNWIND or NO_AUTO)
+        if is_feature_disabled("BUNDLED_UNWIND"):
+            return args
+
+        # Check if compile-only (no linking)
+        is_compile_only = "-c" in args
+
+        try:
+            from clang_tool_chain.platform.detection import get_platform_binary_dir
+
+            clang_bin = get_platform_binary_dir()
+            clang_root = clang_bin.parent
+
+            # Check if bundled libunwind.h exists
+            libunwind_header = clang_root / "include" / "libunwind.h"
+            if not libunwind_header.exists():
+                logger.debug("Bundled libunwind.h not found, skipping LinuxUnwindTransformer")
+                return args
+
+            result = list(args)
+            include_dir = clang_root / "include"
+            lib_dir = clang_root / "lib"
+
+            # Add include path (always needed for compilation)
+            include_flag = f"-I{include_dir}"
+            if include_flag not in args:
+                result = [include_flag] + result
+                logger.debug(f"Adding bundled libunwind include path: {include_flag}")
+
+            # Add library path and rpath (only for linking)
+            if not is_compile_only:
+                lib_flag = f"-L{lib_dir}"
+                if lib_flag not in args:
+                    result = [lib_flag] + result
+                    logger.debug(f"Adding bundled libunwind library path: {lib_flag}")
+
+                # Add rpath so runtime can find libunwind.so
+                rpath_flag = f"-Wl,-rpath,{lib_dir}"
+                # Check if any rpath to our lib dir already exists
+                has_our_rpath = any(str(lib_dir) in arg and "-rpath" in arg for arg in args)
+                if not has_our_rpath:
+                    result = [rpath_flag] + result
+                    logger.debug(f"Adding bundled libunwind rpath: {rpath_flag}")
+
+            return result
+
+        except Exception as e:
+            logger.debug(f"LinuxUnwindTransformer error: {e}")
+            return args
+
+
 class LLDLinkerTransformer(ArgumentTransformer):
     """
     Transformer for forcing LLVM's lld linker on macOS and Linux.
@@ -293,21 +376,25 @@ class ASANRuntimeTransformer(ArgumentTransformer):
 
     Priority: 250 (runs after linker but before ABI)
 
-    This transformer ensures proper ASAN runtime linking on Linux:
+    This transformer ensures proper ASAN runtime linking on Linux and Windows:
     - Detects -fsanitize=address flag
     - Adds -shared-libasan to use shared runtime library
-    - Adds -Wl,--allow-shlib-undefined when building shared libraries with ASAN
+    - Adds -Wl,--allow-shlib-undefined when building shared libraries with ASAN (Linux only)
     - 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.
+    The shared runtime library (libclang_rt.asan.so on Linux, libclang_rt.asan_dynamic.dll
+    on Windows) 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.
 
+    Note: macOS uses a different ASAN runtime mechanism and is not affected.
+
     Environment Variables:
         CLANG_TOOL_CHAIN_NO_SHARED_ASAN: Set to '1' to disable shared ASAN
+        CLANG_TOOL_CHAIN_NO_SANITIZER_NOTE: Set to '1' to suppress the injection note
         CLANG_TOOL_CHAIN_NO_AUTO: Set to '1' to disable all automatic features
     """
 
@@ -315,11 +402,12 @@ class ASANRuntimeTransformer(ArgumentTransformer):
         return 250
 
     def transform(self, args: list[str], context: ToolContext) -> list[str]:
-        """Add -shared-libasan and --allow-shlib-undefined when using ASAN on Linux."""
+        """Add -shared-libasan and --allow-shlib-undefined when using ASAN on Linux/Windows."""
         import sys
 
-        # Only applies to Linux clang/clang++
-        if context.platform_name != "linux" or context.tool_name not in ("clang", "clang++"):
+        # Only applies to Linux and Windows (GNU ABI) clang/clang++
+        # macOS uses a different ASAN runtime mechanism
+        if context.platform_name not in ("linux", "win") or context.tool_name not in ("clang", "clang++"):
             return args
 
         # Check if ASAN is enabled
@@ -339,11 +427,12 @@ class ASANRuntimeTransformer(ArgumentTransformer):
             result = ["-shared-libasan"] + result
             injected_flags.append("-shared-libasan")
 
-        # Check if building a shared library with ASAN
+        # Check if building a shared library with ASAN on Linux
         # Shared libraries need to allow undefined symbols that will be provided
         # by the sanitizer runtime when the runner loads them
+        # Note: --allow-shlib-undefined is a Linux ELF linker flag, not supported on Windows
         is_shared_lib = "-shared" in args
-        if is_shared_lib:
+        if is_shared_lib and context.platform_name == "linux":
             # 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:
@@ -351,10 +440,11 @@ class ASANRuntimeTransformer(ArgumentTransformer):
                 result = ["-Wl,--allow-shlib-undefined"] + result
                 injected_flags.append("-Wl,--allow-shlib-undefined")
 
-        # Warn on stderr if we injected flags
-        if injected_flags:
+        # Warn on stderr if we injected flags (unless disabled)
+        if injected_flags and not is_feature_disabled("SANITIZER_NOTE"):
             print(
-                f"clang-tool-chain: note: automatically injected sanitizer flags: {' '.join(injected_flags)}",
+                f"clang-tool-chain: note: automatically injected sanitizer flags: {' '.join(injected_flags)} "
+                "(disable with CLANG_TOOL_CHAIN_NO_SANITIZER_NOTE=1)",
                 file=sys.stderr,
             )
 
@@ -406,9 +496,9 @@ class RPathTransformer(ArgumentTransformer):
         if is_feature_disabled("RPATH"):
             return args
 
-        # Check if rpath already present
+        # Check if $ORIGIN rpath already present (don't skip for other rpaths)
         for arg in args:
-            if "-rpath" in arg or "$ORIGIN" in arg:
+            if "$ORIGIN" in arg:
                 return args
 
         # Add rpath to look in executable's directory first
@@ -528,11 +618,12 @@ def create_default_pipeline() -> ArgumentPipeline:
     This includes all standard transformers in their default priority order:
     1. DirectivesTransformer (priority=50)
     2. MacOSSDKTransformer (priority=100)
-    3. LLDLinkerTransformer (priority=200)
-    4. ASANRuntimeTransformer (priority=250)
-    5. RPathTransformer (priority=275)
-    6. GNUABITransformer (priority=300)
-    7. MSVCABITransformer (priority=300)
+    3. LinuxUnwindTransformer (priority=150)
+    4. LLDLinkerTransformer (priority=200)
+    5. ASANRuntimeTransformer (priority=250)
+    6. RPathTransformer (priority=275)
+    7. GNUABITransformer (priority=300)
+    8. MSVCABITransformer (priority=300)
 
     Returns:
         Configured ArgumentPipeline ready for use
@@ -541,6 +632,7 @@ def create_default_pipeline() -> ArgumentPipeline:
         [
             DirectivesTransformer(),
             MacOSSDKTransformer(),
+            LinuxUnwindTransformer(),
             LLDLinkerTransformer(),
             ASANRuntimeTransformer(),
             RPathTransformer(),

clang_tool_chain/linker/lld.py

@@ -12,6 +12,7 @@ import logging
 import os
 import sys
 
+from clang_tool_chain.env_utils import is_feature_disabled
 from clang_tool_chain.interrupt_utils import handle_keyboard_interrupt_properly
 from clang_tool_chain.llvm_versions import get_llvm_version_tuple, supports_ld64_lld_flag
 
@@ -187,13 +188,16 @@ def _translate_linker_flags_for_macos_lld(args: list[str]) -> list[str]:
     Translate GNU ld linker flags to ld64.lld equivalents for macOS.
 
     When using lld on macOS (ld64.lld), certain GNU ld flags need to be
-    translated to their Mach-O equivalents:
+    translated to their Mach-O equivalents or removed:
     - --no-undefined -> -undefined error
     - --fatal-warnings -> -fatal_warnings
-    - More translations can be added as needed
+    - --allow-shlib-undefined -> (removed, ld64 allows undefined symbols by default)
 
     This function processes both direct linker flags and flags passed via -Wl,
 
+    A warning is printed to stderr when flags are removed, unless silenced via
+    CLANG_TOOL_CHAIN_NO_LINKER_COMPAT_NOTE=1.
+
     Args:
         args: Original compiler arguments
 
@@ -201,12 +205,19 @@ def _translate_linker_flags_for_macos_lld(args: list[str]) -> list[str]:
         Modified arguments with translated linker flags
     """
     # Map of GNU ld flags to ld64.lld equivalents
-    flag_translations = {
+    # None means the flag should be removed (no equivalent needed)
+    flag_translations: dict[str, str | None] = {
         "--no-undefined": "-undefined error",
         "--fatal-warnings": "-fatal_warnings",
+        # --allow-shlib-undefined: ld64 allows undefined symbols in dylibs by default,
+        # so this flag is a no-op on macOS. We remove it entirely.
+        "--allow-shlib-undefined": None,
         # Add more translations as needed
     }
 
+    # Track removed flags for warning
+    removed_flags: list[str] = []
+
     result = []
     i = 0
     while i < len(args):
@@ -221,14 +232,18 @@ def _translate_linker_flags_for_macos_lld(args: list[str]) -> list[str]:
             for flag in linker_flags:
                 # Check if this flag needs translation
                 if flag in flag_translations:
-                    # Translate the flag (may result in multiple flags)
                     translated = flag_translations[flag]
-                    if " " in translated:
+                    if translated is None:
+                        # Flag should be removed entirely (no equivalent on macOS)
+                        removed_flags.append(flag)
+                        logger.debug(f"Removed linker flag (no macOS equivalent): {flag}")
+                    elif " " in translated:
                         # Multiple flags (e.g., "-undefined error")
                         translated_flags.extend(translated.split())
+                        logger.debug(f"Translated linker flag: {flag} -> {translated}")
                     else:
                         translated_flags.append(translated)
-                    logger.debug(f"Translated linker flag: {flag} -> {translated}")
+                        logger.debug(f"Translated linker flag: {flag} -> {translated}")
                 else:
                     translated_flags.append(flag)
 
@@ -239,19 +254,34 @@ def _translate_linker_flags_for_macos_lld(args: list[str]) -> list[str]:
         # Handle standalone linker flags passed directly
         elif arg in flag_translations:
             translated = flag_translations[arg]
-            logger.debug(f"Translated linker flag: {arg} -> {translated}")
-            # Add via -Wl, to pass to linker
-            if " " in translated:
-                # Multiple flags
-                result.append("-Wl," + ",".join(translated.split()))
+            if translated is None:
+                # Flag should be removed entirely (no equivalent on macOS)
+                removed_flags.append(arg)
+                logger.debug(f"Removed linker flag (no macOS equivalent): {arg}")
             else:
-                result.append("-Wl," + translated)
+                logger.debug(f"Translated linker flag: {arg} -> {translated}")
+                # Add via -Wl, to pass to linker
+                if " " in translated:
+                    # Multiple flags
+                    result.append("-Wl," + ",".join(translated.split()))
+                else:
+                    result.append("-Wl," + translated)
 
         else:
             result.append(arg)
 
         i += 1
 
+    # Emit warning for removed flags (unless silenced)
+    if removed_flags and not is_feature_disabled("LINKER_COMPAT_NOTE"):
+        import sys
+
+        print(
+            f"clang-tool-chain: note: removed GNU linker flags not supported by ld64.lld: "
+            f"{', '.join(removed_flags)} (disable with CLANG_TOOL_CHAIN_NO_LINKER_COMPAT_NOTE=1)",
+            file=sys.stderr,
+        )
+
     return result
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clang-tool-chain
-Version: 1.0.45
+Version: 1.1.0
 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
@@ -117,12 +117,13 @@ Comprehensive test coverage across all platforms and tool categories ensures rel
 | **lldb** | [![lldb-win](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lldb-win.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lldb-win.yml) | [![lldb-linux-x86](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lldb-linux-x86.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lldb-linux-x86.yml) | [![lldb-linux-arm](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lldb-linux-arm.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lldb-linux-arm.yml) | [![lldb-macos-x86](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lldb-macos-x86.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lldb-macos-x86.yml) | [![lldb-macos-arm](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lldb-macos-arm.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lldb-macos-arm.yml) |
 | **cosmocc** | [![cosmocc-win](https://github.com/zackees/clang-tool-chain/actions/workflows/test-cosmocc-win.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-cosmocc-win.yml) | [![cosmocc-linux-x86](https://github.com/zackees/clang-tool-chain/actions/workflows/test-cosmocc-linux-x86.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-cosmocc-linux-x86.yml) | [![cosmocc-linux-arm](https://github.com/zackees/clang-tool-chain/actions/workflows/test-cosmocc-linux-arm.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-cosmocc-linux-arm.yml) | [![cosmocc-macos-x86](https://github.com/zackees/clang-tool-chain/actions/workflows/test-cosmocc-macos-x86.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-cosmocc-macos-x86.yml) | [![cosmocc-macos-arm](https://github.com/zackees/clang-tool-chain/actions/workflows/test-cosmocc-macos-arm.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-cosmocc-macos-arm.yml) |
 | **lib-deploy** | [![lib-deploy-win](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lib-deploy-win.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lib-deploy-win.yml) | [![lib-deploy-linux-x86](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lib-deploy-linux-x86.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lib-deploy-linux-x86.yml) | [![lib-deploy-linux-arm](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lib-deploy-linux-arm.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lib-deploy-linux-arm.yml) | [![lib-deploy-macos-x86](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lib-deploy-macos-x86.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lib-deploy-macos-x86.yml) | [![lib-deploy-macos-arm](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lib-deploy-macos-arm.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-lib-deploy-macos-arm.yml) |
+| **libunwind** | N/A | [![libunwind-linux-x86](https://github.com/zackees/clang-tool-chain/actions/workflows/test-libunwind-linux-x86.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-libunwind-linux-x86.yml) | [![libunwind-linux-arm](https://github.com/zackees/clang-tool-chain/actions/workflows/test-libunwind-linux-arm.yml/badge.svg)](https://github.com/zackees/clang-tool-chain/actions/workflows/test-libunwind-linux-arm.yml) | N/A | N/A |
 
 **📖 [Complete Test Matrix Documentation](docs/TEST_MATRIX.md)** - Tool category descriptions, test organization, running tests locally.
 
 ---
 
-## 📋 All Commands (41 Total)
+## 📋 All Commands (42 Total)
 
 Comprehensive reference of all available commands organized by category.
 
@@ -203,7 +204,7 @@ Comprehensive reference of all available commands organized by category.
 | `clang-tool-chain-sccache-emcc` | Cached Emscripten C compiler |
 | `clang-tool-chain-sccache-empp` | Cached Emscripten C++ compiler |
 
-### Management & Diagnostics (4)
+### Management & Diagnostics (5)
 
 | Command | Description |
 |---------|-------------|
@@ -211,8 +212,9 @@ Comprehensive reference of all available commands organized by category.
 | `clang-tool-chain-test` | Run diagnostic tests (7 checks) |
 | `clang-tool-chain-fetch` | Download toolchain components |
 | `clang-tool-chain-paths` | Display installation paths |
+| `clang-tool-chain-libdeploy` | Deploy runtime library dependencies after the fact |
 
-**Total: 41 commands** providing complete C/C++/WebAssembly toolchain capabilities.
+**Total: 42 commands** providing complete C/C++/WebAssembly toolchain capabilities.
 
 ---
 
@@ -241,6 +243,7 @@ Comprehensive reference of all available commands organized by category.
 - [Executable C++ Scripts](#-executable-c-scripts-shebang-support)
 - [Windows DLL Deployment](#-windows-dll-deployment)
 - [Address Sanitizer (ASAN)](#️-address-sanitizer-asan-support)
+- [Bundled libunwind (Linux)](#-bundled-libunwind-linux)
 - [sccache Integration](#-sccache-integration)
 
 ### Platform & Configuration
@@ -275,13 +278,13 @@ Comprehensive reference of all available commands organized by category.
 
 ### Platform & Version Matrix
 
-| Platform | Architecture | LLVM Version | Archive Size | Linker | Status |
-|----------|--------------|--------------|--------------|--------|--------|
-| Windows  | x86_64       | 21.1.5       | ~71-90 MB    | lld    | ✅ Stable |
-| Linux    | x86_64       | 21.1.5       | ~87 MB       | lld    | ✅ Stable |
-| Linux    | ARM64        | 21.1.5       | ~91 MB       | lld    | ✅ Stable |
-| macOS    | x86_64       | 21.1.6       | ~77 MB       | ld64.lld | ✅ Stable |
-| macOS    | ARM64        | 21.1.6       | ~71 MB       | ld64.lld | ✅ Stable |
+| Platform | Architecture | LLVM Version | Archive Size | Linker | Extras | Status |
+|----------|--------------|--------------|--------------|--------|--------|--------|
+| Windows  | x86_64       | 21.1.5       | ~71-90 MB    | lld    | MinGW sysroot | ✅ Stable |
+| Linux    | x86_64       | 21.1.5       | ~87 MB       | lld    | libunwind (bundled) | ✅ Stable |
+| Linux    | ARM64        | 21.1.5       | ~91 MB       | lld    | libunwind (bundled) | ✅ Stable |
+| macOS    | x86_64       | 21.1.6       | ~77 MB       | ld64.lld | - | ✅ Stable |
+| macOS    | ARM64        | 21.1.6       | ~71 MB       | ld64.lld | - | ✅ Stable |
 
 ### Windows ABI Selection
 
@@ -743,6 +746,70 @@ clang-tool-chain-cpp main.cpp -o program --deploy-dependencies
 
 ---
 
+## 📦 Post-Build Library Deployment (clang-tool-chain-libdeploy)
+
+**Deploy runtime dependencies after compilation** - useful when you've compiled without `--deploy-dependencies` or when using external build systems.
+
+### Quick Examples
+
+```bash
+# Deploy dependencies for a Windows executable
+clang-tool-chain-libdeploy myprogram.exe
+# Output: Deployed 3 MinGW DLL(s) for myprogram.exe
+
+# Deploy dependencies for a Linux shared library
+clang-tool-chain-libdeploy mylib.so
+
+# Deploy dependencies for a macOS executable
+clang-tool-chain-libdeploy myprogram
+
+# Dry run - see what would be deployed without copying
+clang-tool-chain-libdeploy --dry-run myprogram.exe
+# Output:
+# Would deploy 3 libraries:
+#   libwinpthread-1.dll <- /path/to/toolchain/lib/libwinpthread-1.dll
+#   libgcc_s_seh-1.dll <- /path/to/toolchain/lib/libgcc_s_seh-1.dll
+#   libstdc++-6.dll <- /path/to/toolchain/lib/libstdc++-6.dll
+```
+
+### Command Line Options
+
+```bash
+clang-tool-chain-libdeploy [options] <binary>
+
+Options:
+  -h, --help            Show help message
+  -v, --verbose         Enable verbose output
+  -n, --dry-run         Show what would be deployed without copying
+  -p, --platform        Override auto-detected platform (windows, linux, darwin)
+  -a, --arch            Target architecture (default: auto-detect)
+```
+
+### Use Cases
+
+1. **External build systems**: When using CMake, Make, or other build systems that don't use clang-tool-chain wrappers directly
+2. **Third-party binaries**: Deploy dependencies for pre-built executables compiled with clang-tool-chain
+3. **CI/CD pipelines**: Add deployment as a separate step after compilation
+4. **Debugging**: Use `--dry-run` to inspect dependencies without modifying files
+
+### Supported Formats
+
+| Platform | File Types | Dependencies Deployed |
+|----------|------------|----------------------|
+| Windows  | `.exe`, `.dll` | MinGW runtime DLLs (libwinpthread, libgcc_s, libstdc++, etc.) |
+| Linux    | executables, `.so` | libc++, libunwind, sanitizer runtimes |
+| macOS    | executables, `.dylib` | libc++, libunwind, sanitizer runtimes |
+
+### Binary Type Detection
+
+The tool automatically detects binary type from:
+1. **File extension**: `.exe`, `.dll`, `.so`, `.dylib`
+2. **Magic bytes**: ELF (Linux), Mach-O (macOS), PE (Windows)
+
+For executables without extensions (common on Linux/macOS), magic bytes are used for detection.
+
+---
+
 ## 🚀 CI/CD Integration
 
 ```yaml
@@ -769,13 +836,13 @@ jobs:
 
 ## 🌍 Platform Support Matrix
 
-| Platform | Architecture | LLVM Version | Archive Size | Status |
-|----------|--------------|--------------|--------------|--------|
-| Windows  | x86_64       | 21.1.5       | ~71-90 MB    | ✅ Stable |
-| Linux    | x86_64       | 21.1.5       | ~87 MB       | ✅ Stable |
-| Linux    | ARM64        | 21.1.5       | ~91 MB       | ✅ Stable |
-| macOS    | x86_64       | 19.1.7       | ~77 MB       | ✅ Stable |
-| macOS    | ARM64        | 21.1.6       | ~71 MB       | ✅ Stable |
+| Platform | Architecture | LLVM Version | Archive Size | Bundled Extras | Status |
+|----------|--------------|--------------|--------------|----------------|--------|
+| Windows  | x86_64       | 21.1.5       | ~71-90 MB    | MinGW sysroot | ✅ Stable |
+| Linux    | x86_64       | 21.1.5       | ~87 MB       | libunwind | ✅ Stable |
+| Linux    | ARM64        | 21.1.5       | ~91 MB       | libunwind | ✅ Stable |
+| macOS    | x86_64       | 19.1.7       | ~77 MB       | - | ✅ Stable |
+| macOS    | ARM64        | 21.1.6       | ~71 MB       | - | ✅ Stable |
 
 **Requirements:** Python 3.10+, ~100-400 MB disk space
 
@@ -792,6 +859,7 @@ jobs:
 - `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
+- `CLANG_TOOL_CHAIN_NO_BUNDLED_UNWIND` - Disable bundled libunwind on Linux (use system version)
 - `CLANG_TOOL_CHAIN_NO_SANITIZER_ENV` - Disable automatic ASAN/LSAN options injection at runtime
 - `SDKROOT` - Custom macOS SDK path (auto-detected by default)
 
@@ -904,6 +972,9 @@ export CLANG_TOOL_CHAIN_NO_SANITIZER_ENV=1
 
 # Disable automatic -shared-libasan on Linux (use static ASAN)
 export CLANG_TOOL_CHAIN_NO_SHARED_ASAN=1
+
+# Suppress the "automatically injected sanitizer flags" note
+export CLANG_TOOL_CHAIN_NO_SANITIZER_NOTE=1
 ```
 
 **Platform Notes:**
@@ -938,6 +1009,83 @@ See: https://github.com/google/sanitizers/issues/899
 
 ---
 
+## 📚 Bundled libunwind (Linux)
+
+**Self-contained stack unwinding - no system packages required**
+
+On Linux, clang-tool-chain bundles libunwind headers and shared libraries, providing a complete solution for stack unwinding without requiring system packages like `libunwind-dev`.
+
+### What's Bundled
+
+| Component | Files | Size |
+|-----------|-------|------|
+| Headers | `libunwind.h`, `libunwind-common.h`, `libunwind-x86_64.h`/`libunwind-aarch64.h`, `unwind.h` | ~20 KB |
+| Libraries | `libunwind.so.*`, `libunwind-x86_64.so.*` (or `aarch64`) | ~300 KB |
+
+### How It Works
+
+When compiling on Linux, clang-tool-chain **automatically**:
+1. Adds `-I<clang_root>/include` for bundled libunwind headers
+2. Adds `-L<clang_root>/lib` for bundled libunwind libraries
+3. Adds `-Wl,-rpath,<clang_root>/lib` so executables find libunwind at runtime
+
+This means `#include <libunwind.h>` and `-lunwind` work out of the box.
+
+### Usage Example
+
+```c
+// backtrace.c - Print a stack trace using libunwind
+#include <stdio.h>
+#include <libunwind.h>
+
+void print_backtrace() {
+    unw_cursor_t cursor;
+    unw_context_t context;
+    unw_getcontext(&context);
+    unw_init_local(&cursor, &context);
+
+    while (unw_step(&cursor) > 0) {
+        char name[256];
+        unw_word_t offset;
+        unw_get_proc_name(&cursor, name, sizeof(name), &offset);
+        printf("  %s+0x%lx\n", name, (unsigned long)offset);
+    }
+}
+
+int main() {
+    print_backtrace();
+    return 0;
+}
+```
+
+```bash
+# Compile and link with bundled libunwind - no apt-get install needed!
+clang-tool-chain-c backtrace.c -lunwind -o backtrace
+
+# Run without LD_LIBRARY_PATH - works due to embedded rpath
+./backtrace
+```
+
+### Configuration
+
+**Disable bundled libunwind** (use system version instead):
+```bash
+export CLANG_TOOL_CHAIN_NO_BUNDLED_UNWIND=1
+```
+
+### Platform Support
+
+| Platform | Headers | Libraries | Status |
+|----------|---------|-----------|--------|
+| Linux x86_64 | ✅ Bundled | ✅ Bundled | ✅ Full |
+| Linux ARM64 | ✅ Bundled | ✅ Bundled | ✅ Full |
+| Windows | MinGW sysroot | MinGW sysroot | N/A (different API) |
+| macOS | System | System | N/A (uses system) |
+
+**📖 [Complete Documentation](docs/LIBUNWIND.md)** - Detailed usage, API reference, integration with ASAN, advanced examples.
+
+---
+
 ## 🔧 How It Works
 
 Auto-downloads on first use (~71-91 MB, 10-60 seconds). Subsequent uses are instant.
@@ -1047,6 +1195,7 @@ For in-depth information on specific topics, see the documentation in the `docs/
 | **[Cosmopolitan Libc](docs/COSMOCC.md)** | Actually Portable Executables (APE) |
 | **[sccache Integration](docs/SCCACHE.md)** | Compilation caching (2-10x speedup) |
 | **[Inlined Build Directives](docs/DIRECTIVES.md)** | Self-contained source files |
+| **[Bundled libunwind](docs/LIBUNWIND.md)** | Linux stack unwinding (headers + libraries) |
 
 ### Setup & Configuration
 | Document | Description |

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

@@ -1,5 +1,5 @@
 clang_tool_chain/__init__.py,sha256=u-qgOuQxh5W2g7n8BgUtBnUWsK66rM4N6LJXY9PiEx0,880
-clang_tool_chain/__version__.py,sha256=QaMskYdjKBucedCuNyKFMIEERieKWeom7OJJ_fjGce4,72
+clang_tool_chain/__version__.py,sha256=6CB4WX5utk2VKYGwXj_5nRzglWK1ken81ARqHoarPF4,71
 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,7 +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/env_utils.py,sha256=5ovnV9cQ_-g5yBlvG8OyaH0fJ-gYasCwvEn_nKYiw_4,4234
 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
@@ -34,11 +34,12 @@ clang_tool_chain/deployment/dll_deployer.py,sha256=x3_hXsPgyQMkp1orzZV4lAZa4NMP2
 clang_tool_chain/deployment/dll_detector.py,sha256=Zf2NAjAg6bEg6uvb7dFkj0qvk8Mvzj4sjyPIoxNVvJE,8629
 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=i3ezy1gOOHlzH5lHNytPl2FBXu7AX-F3r1uXHFEKfmg,11892
+clang_tool_chain/deployment/libdeploy.py,sha256=cfyDFmbuUmimss5fv7exO7NOulDnw7agrKGFgbSK7BM,9050
+clang_tool_chain/deployment/so_deployer.py,sha256=eAygmGojioi1iz5cHeqmKjJ5fI-5XooG9Ro-5TIA0gw,12867
 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=fFQEW9VejCdbBvt4quNJ2X8udh_PKgewTfzUXHmXzyc,940
-clang_tool_chain/execution/arg_transformers.py,sha256=8RDaUF2r3dgSqQ_2XkGiXnmoLGD3ltaf4YbqkyjG2CI,19772
+clang_tool_chain/execution/arg_transformers.py,sha256=j73CZg8jen7bSymAoiNgqvAQka-e-RMyKkYbh28qy0o,23899
 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
@@ -58,7 +59,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=08qkvoK4-8yACm34GfZzp3vM8rZYHCv_M9fjUeSetd0,13826
+clang_tool_chain/linker/lld.py,sha256=OQLmCLNbj2BU0l5HxtHegHvXvblPITg8Gkm_EvJorKw,15381
 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
@@ -68,8 +69,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.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,,
+clang_tool_chain-1.1.0.dist-info/METADATA,sha256=FU9mvPYq7qfmEGqYBb6ucjrrX3jCDIbJoKb1c9BSIic,57944
+clang_tool_chain-1.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+clang_tool_chain-1.1.0.dist-info/entry_points.txt,sha256=N0a0OVPkCFbf6BisRkHj-m2TcZ-f1mqxfXxAHQxfrQg,2800
+clang_tool_chain-1.1.0.dist-info/licenses/LICENSE,sha256=51FO1oc2pZbQNI0v0_THnznnZIF4iFgawG1xnQ58kKo,10997
+clang_tool_chain-1.1.0.dist-info/RECORD,,

{clang_tool_chain-1.0.45.dist-info → clang_tool_chain-1.1.0.dist-info}/entry_points.txt

@@ -20,6 +20,7 @@ clang-tool-chain-format = clang_tool_chain.wrapper:clang_format_main
 clang-tool-chain-iwyu = clang_tool_chain.wrapper:iwyu_main
 clang-tool-chain-iwyu-tool = clang_tool_chain.wrapper:iwyu_tool_main
 clang-tool-chain-ld = clang_tool_chain.wrapper:lld_main
+clang-tool-chain-libdeploy = clang_tool_chain.deployment.libdeploy:main
 clang-tool-chain-lldb = clang_tool_chain.wrapper:lldb_main
 clang-tool-chain-lldb-check-python = clang_tool_chain.wrapper:lldb_check_python_main
 clang-tool-chain-meson = clang_tool_chain.wrapper:meson_main