为工具链创建 Conan 包¶

在学习了如何为打包应用程序的工具依赖创建 recipe 之后，我们将展示一个示例，说明如何创建一个 recipe，该 recipe 打包一个预编译的工具链或编译器，用于构建其他包。

在“如何使用 Conan 交叉编译应用程序：主机和构建上下文”教程部分中，我们讨论了使用 Conan 交叉编译应用程序的基础知识，重点关注“构建”和“主机”上下文。我们学习了如何配置 Conan 以对构建机器和目标主机使用不同的 profile，从而使我们能够从 Ubuntu Linux 机器交叉编译到 Raspberry Pi 等平台。

但是，在该部分中，我们假设存在一个交叉编译工具链或编译器，作为构建环境的一部分，并通过 Conan profile 进行设置。现在，我们将更进一步，演示如何为此工具链创建 Conan 包。然后，此包可以用作其他 Conan recipe 中的 tool_require，从而简化了为交叉编译设置环境的过程。

请先克隆源代码以重新创建此项目。您可以在 GitHub 上的 examples2 存储库中找到它们

$ git clone https://github.com/conan-io/examples2.git
$ cd examples2/examples/cross_build/toolchain_packages/toolchain

在这里，您将找到一个 Conan recipe（以及 *test_package*），用于打包一个 ARM 工具链，以便交叉编译到 32 位和 64 位 Linux ARM。为了简化一点，我们假设我们可以从 Linux x86_64 交叉编译到 Linux ARM，包括 32 位和 64 位。如果您正在寻找另一个示例，您可以在此处探索一个额外的 MacOs 到 Linux 交叉构建示例。

.
├── conanfile.py
└── test_package
    ├── CMakeLists.txt
    ├── conanfile.py
    └── test_package.cpp

让我们检查一下 recipe 并了解最相关的部分

conanfile.py¶

import os
from conan import ConanFile
from conan.tools.files import get, copy, download
from conan.errors import ConanInvalidConfiguration
from conan.tools.scm import Version

class ArmToolchainPackage(ConanFile):
    name = "arm-toolchain"
    version = "13.2"
    ...
    settings = "os", "arch"
    package_type = "application"

    def _archs32(self):
        return ["armv6", "armv7", "armv7hf"]

    def _archs64(self):
        return ["armv8", "armv8.3"]

    def _get_toolchain(self, target_arch):
        if target_arch in self._archs32():
            return ("arm-none-linux-gnueabihf",
                    "df0f4927a67d1fd366ff81e40bd8c385a9324fbdde60437a512d106215f257b3")
        else:
            return ("aarch64-none-linux-gnu",
                    "12fcdf13a7430655229b20438a49e8566e26551ba08759922cdaf4695b0d4e23")

    def validate(self):
        if self.settings.arch != "x86_64" or self.settings.os != "Linux":
            raise ConanInvalidConfiguration(f"This toolchain is not compatible with {self.settings.os}-{self.settings.arch}. "
                                            "It can only run on Linux-x86_64.")

        valid_archs = self._archs32() + self._archs64()
        if self.settings_target.os != "Linux" or self.settings_target.arch not in valid_archs:
            raise ConanInvalidConfiguration(f"This toolchain only supports building for Linux-{valid_archs.join(',')}. "
                                        f"{self.settings_target.os}-{self.settings_target.arch} is not supported.")

        if self.settings_target.compiler != "gcc":
            raise ConanInvalidConfiguration(f"The compiler is set to '{self.settings_target.compiler}', but this "
                                            "toolchain only supports building with gcc.")

        if Version(self.settings_target.compiler.version) >= Version("14") or Version(self.settings_target.compiler.version) < Version("13"):
            raise ConanInvalidConfiguration(f"Invalid gcc version '{self.settings_target.compiler.version}'. "
                                                "Only 13.X versions are supported for the compiler.")

    def source(self):
        download(self, "https://developer.arm.com/GetEula?Id=37988a7c-c40e-4b78-9fd1-62c20b507aa8", "LICENSE", verify=False)

    def build(self):
        toolchain, sha = self._get_toolchain(self.settings_target.arch)
        get(self, f"https://developer.arm.com/-/media/Files/downloads/gnu/13.2.rel1/binrel/arm-gnu-toolchain-13.2.rel1-x86_64-{toolchain}.tar.xz",
            sha256=sha, strip_root=True)

    def package_id(self):
        self.info.settings_target = self.settings_target
        # We only want the ``arch`` setting
        self.info.settings_target.rm_safe("os")
        self.info.settings_target.rm_safe("compiler")
        self.info.settings_target.rm_safe("build_type")

    def package(self):
        toolchain, _ = self._get_toolchain(self.settings_target.arch)
        dirs_to_copy = [toolchain, "bin", "include", "lib", "libexec"]
        for dir_name in dirs_to_copy:
            copy(self, pattern=f"{dir_name}/*", src=self.build_folder, dst=self.package_folder, keep_path=True)
        copy(self, "LICENSE", src=self.build_folder, dst=os.path.join(self.package_folder, "licenses"), keep_path=False)

    def package_info(self):
        toolchain, _ = self._get_toolchain(self.settings_target.arch)
        self.cpp_info.bindirs.append(os.path.join(self.package_folder, toolchain, "bin"))

        self.conf_info.define("tools.build:compiler_executables", {
            "c":   f"{toolchain}-gcc",
            "cpp": f"{toolchain}-g++",
            "asm": f"{toolchain}-as"
        })

验证工具链包：settings、settings_build 和 settings_target¶

您可能还记得，validate() 方法用于指示包与某些配置不兼容。如前所述，我们限制此包仅在 *Linux x86_64* 平台上使用，以便交叉编译到 *Linux ARM* 目标，同时支持 32 位和 64 位架构。让我们检查一下如何将此信息合并到 validate() 方法中，并讨论涉及的各种类型的 setting

验证构建平台

...

settings = "os", "arch"

...

def validate(self):

    if self.settings.arch != "x86_64" or self.settings.os != "Linux":
        raise ConanInvalidConfiguration(f"This toolchain is not compatible with {self.settings.os}-{self.settings.arch}. "
                                        "It can only run on Linux-x86_64.")
    ...

首先，重要的是要承认只声明了 os 和 arch setting。这些 setting 代表将为工具链编译包的机器，因此我们只需要验证它们是否对应于 Linux 和 x86_64，因为这些是工具链二进制文件的目标平台。

重要的是要注意，对于这个要用作 tool_requires 的包，这些 setting 与 host profile 无关，而是与 build profile 相关。当使用 --build-require 参数创建包时，Conan 会识别出这种区别。这将使 settings 和 settings_build 在包创建的上下文中相等。

验证目标平台

在涉及交叉编译的场景中，关于目标平台的验证（即工具链编译器生成的执行文件将在其上运行的平台）必须参考 settings_target。这些 setting 来自 host profile 中的信息。例如，如果为 Raspberry Pi 编译，则该信息将存储在 settings_target 中。同样，Conan 知道由于在包创建期间使用了 --build-require 标志，因此应该使用 host profile 信息填充 settings_target。

def validate(self):
    ...

    valid_archs = self._archs32() + self._archs64()
    if self.settings_target.os != "Linux" or self.settings_target.arch not in valid_archs:
        raise ConanInvalidConfiguration(f"This toolchain only supports building for Linux-{valid_archs.join(',')}. "
                                       f"{self.settings_target.os}-{self.settings_target.arch} is not supported.")

    if self.settings_target.compiler != "gcc":
        raise ConanInvalidConfiguration(f"The compiler is set to '{self.settings_target.compiler}', but this "
                                        "toolchain only supports building with gcc.")

    if Version(self.settings_target.compiler.version) >= Version("14") or Version(self.settings_target.compiler.version) < Version("13"):
        raise ConanInvalidConfiguration(f"Invalid gcc version '{self.settings_target.compiler.version}'. "
                                        "Only 13.X versions are supported for the compiler.")

如您所见，进行了多项验证，以确保用于生成二进制文件的执行环境的操作系统和架构的有效性。此外，它还会验证编译器的名称和版本是否与 host 上下文的期望相符。

这里，该图显示了两个 profile 以及为处于 *build* 上下文中的 **arm-toolchain** recipe 选择哪些 setting。

下载工具链的二进制文件并打包¶

...

def _archs32(self):
    return ["armv6", "armv7", "armv7hf"]

def _archs64(self):
    return ["armv8", "armv8.3"]

def _get_toolchain(self, target_arch):
    if target_arch in self._archs32():
        return ("arm-none-linux-gnueabihf",
                "df0f4927a67d1fd366ff81e40bd8c385a9324fbdde60437a512d106215f257b3")
    else:
        return ("aarch64-none-linux-gnu",
                "12fcdf13a7430655229b20438a49e8566e26551ba08759922cdaf4695b0d4e23")

def source(self):
    download(self, "https://developer.arm.com/GetEula?Id=37988a7c-c40e-4b78-9fd1-62c20b507aa8", "LICENSE", verify=False)

def build(self):
    toolchain, sha = self._get_toolchain(self.settings_target.arch)
    get(self, f"https://developer.arm.com/-/media/Files/downloads/gnu/13.2.rel1/binrel/arm-gnu-toolchain-13.2.rel1-x86_64-{toolchain}.tar.xz",
        sha256=sha, strip_root=True)

def package(self):
    toolchain, _ = self._get_toolchain(self.settings_target.arch)
    dirs_to_copy = [toolchain, "bin", "include", "lib", "libexec"]
    for dir_name in dirs_to_copy:
        copy(self, pattern=f"{dir_name}/*", src=self.build_folder, dst=self.package_folder, keep_path=True)
    copy(self, "LICENSE", src=self.build_folder, dst=os.path.join(self.package_folder, "licenses"), keep_path=False)

...

source() 方法用于下载 recipe 许可证，因为它可以在 ARM 工具链的下载页面上找到。但是，这是在那里执行的唯一操作。实际的工具链二进制文件是在 build() 方法中获取的。这种方法是必要的，因为工具链包旨在支持 32 位和 64 位架构，因此我们需要下载两组不同的工具链二进制文件。包最终使用的二进制文件取决于 settings_target 架构。这种有条件的下载过程不能在 source() 方法中进行，因为它缓存下载的内容。

package() 方法没有任何特别之处；它只是将下载的文件复制到包文件夹中，包括许可证。

将 `settings_target` 添加到包 ID 信息¶

在为交叉编译场景设计的 recipe 中，特别是那些涉及面向特定架构或操作系统的工具链的 recipe，并且二进制包可能基于目标平台而有所不同，我们可能需要修改 package_id()，以确保 Conan 正确识别并区分基于它们的目标平台设计的二进制文件。

在这种情况下，我们扩展了 package_id() 方法以包含 settings_target，它封装了目标平台的配置（在这种情况下，是 32 位还是 64 位）

def package_id(self):
    # Assign settings_target to the package ID to differentiate binaries by target platform.
    self.info.settings_target = self.settings_target

    # We only want the ``arch`` setting
    self.info.settings_target.rm_safe("os")
    self.info.settings_target.rm_safe("compiler")
    self.info.settings_target.rm_safe("build_type")

通过指定 self.info.settings_target = self.settings_target，我们明确指示 Conan 在生成包 ID 时考虑目标平台的 setting。在这种情况下，我们删除 os、compiler 和 build_type setting，因为更改它们与选择我们将用于构建的工具链无关，而只留下 arch setting，它将用于确定是否要生成 32 位或 64 位二进制文件。

定义消费者的信息¶

在 package_info() 方法中，我们定义了消费者在使用工具链时需要可用的所有信息

def package_info(self):
    toolchain, _ = self._get_toolchain(self.settings_target.arch)
    self.cpp_info.bindirs.append(os.path.join(self.package_folder, toolchain, "bin"))

    self.conf_info.define("tools.build:compiler_executables", {
        "c":   f"{toolchain}-gcc",
        "cpp": f"{toolchain}-g++",
        "asm": f"{toolchain}-as"
    })

在这种情况下，我们需要定义以下信息

添加包含编译期间可能需要的工具链工具的目录。我们下载的工具链会将它的工具存储在 bin 和 <toolchain_triplet>/bin 中。由于 self.cpp_info.bindirs 默认为 bin，我们只需要添加特定于 triplet 的目录。请注意，没有必要定义环境信息以将这些目录添加到 PATH，因为 Conan 将通过 VirtualRunEnv 来管理这一点。
我们定义 tools.build:compiler_executables 配置。诸如 CMakeToolchain、MesonToolchain 或 AutotoolsToolchain 等多个生成器将考虑此配置，以定向到适当的编译器二进制文件。

测试 Conan 工具链包¶

我们还添加了一个简单的 *test_package* 来测试工具链

test_package/conanfile.py¶

import os
from io import StringIO

from conan import ConanFile
from conan.tools.cmake import CMake, cmake_layout


class TestPackageConan(ConanFile):
    settings = "os", "arch", "compiler", "build_type"
    generators = "CMakeToolchain", "VirtualBuildEnv"

    def build_requirements(self):
        self.tool_requires(self.tested_reference_str)

    def layout(self):
        cmake_layout(self)

    def build(self):
        cmake = CMake(self)
        cmake.configure()
        cmake.build()

    def test(self):
        if self.settings.arch in ["armv6", "armv7", "armv7hf"]:
            toolchain = "arm-none-linux-gnueabihf"
        else:
            toolchain = "aarch64-none-linux-gnu"
        self.run(f"{toolchain}-gcc --version")
        test_file = os.path.join(self.cpp.build.bindirs[0], "test_package")
        stdout = StringIO()
        self.run(f"file {test_file}", stdout=stdout)
        if toolchain == "aarch64-none-linux-gnu":
            assert "ELF 64-bit" in stdout.getvalue()
        else:
            assert "ELF 32-bit" in stdout.getvalue()

此测试包确保工具链可以正常运行，构建一个最小的 *hello world* 程序，并且使用它生成的二进制文件正确地定位于指定的架构。

使用工具链交叉构建应用程序¶

在详细介绍了工具链 recipe 之后，就该继续进行包创建了

$ conan create . -pr:b=default -pr:h=../profiles/raspberry-64 --build-require

======== Exporting recipe to the cache ========
...
======== Input profiles ========
Profile host:
[settings]
arch=armv8
build_type=Release
compiler=gcc
compiler.cppstd=gnu14
compiler.libcxx=libstdc++11
compiler.version=13
os=Linux

Profile build:
[settings]
arch=x86_64
build_type=Release
compiler=gcc
compiler.cppstd=gnu14
compiler.libcxx=libstdc++11
compiler.version=7
os=Linux
...
======== Testing the package: Executing test ========
arm-toolchain/13.2 (test package): Running test()
arm-toolchain/13.2 (test package): RUN: aarch64-none-linux-gnu-gcc --version
aarch64-none-linux-gnu-gcc (Arm GNU Toolchain 13.2.rel1 (Build arm-13.7)) 13.2.1 20231009
Copyright (C) 2023 Free Software Foundation, Inc.
...

我们对 *build* 和 *host* 上下文采用两个 profile，但最重要的细节是使用 *–build-require* 参数。这会告知 Conan 该包旨在作为构建需求，并将其置于构建上下文中。因此，*setting* 与构建 profile 中的 setting 匹配，而 *settings_target* 与主机 profile 的 setting 对齐。

准备好工具链包后，我们将继续构建实际的应用程序。这将是在如何使用 Conan 交叉编译应用程序：主机和构建上下文部分中先前交叉编译的同一应用程序。但是，这一次，我们将工具链包作为主机 profile 中的依赖项合并。这确保了工具链用于构建应用程序及其所有依赖项

$ cd .. && cd consumer
$ conan install . -pr:b=default -pr:h=../profiles/raspberry-64 -pr:h=../profiles/arm-toolchain --build missing
$ cmake --preset conan-release
$ cmake --build --preset conan-release
$ file ./build/Release/compressor
compressor: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), dynamically
linked, interpreter /lib/ld-linux-aarch64.so.1, for GNU/Linux 3.7.0, with debug_info,
not stripped

我们将已有的配置和另一个名为 arm-toolchain 的配置组合在一起，后者只添加了 tool_requires

[tool_requires]
arm-toolchain/13.2

在此过程中，如果 zlib 依赖项尚未编译，也会为 ARM 64 位架构编译它。此外，重要的是验证生成的执行文件的架构，确认它与目标 64 位架构对齐。

另请参阅