创建用于工具链的 Conan 包

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

在“使用 Conan 跨平台编译你的应用程序：主机和构建上下文”教程部分，我们讨论了使用 Conan 跨平台编译应用程序的基础知识，重点是“构建”和“主机”上下文。我们学习了如何配置 Conan，为构建机器和目标主机机器使用不同的配置文件，从而能够从 Ubuntu Linux 机器为 Raspberry Pi 等平台进行跨平台编译。

然而，在上一节中，我们假设已经存在一个用于构建环境的跨平台编译工具链或编译器，通过 Conan 配置文件设置。现在，我们将更进一步，演示如何为这样的工具链创建一个 Conan 包。然后，该包可以用作其他 Conan 配方的 tool_require，简化跨平台编译的环境设置过程。

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

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

在这里，你将找到一个 Conan 配方（以及 *test_package*）来打包一个 ARM 工具链，用于交叉编译到 Linux ARM，支持 32 位和 64 位。为了简化一些，我们假设我们可以直接从 Linux x86_64 交叉编译到 Linux ARM，支持 32 位和 64 位。如果你正在寻找另一个示例，可以探索一个额外的 Macos 到 Linux 交叉构建示例，就在 这里 。

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

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

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"
        })

验证工具链包：设置、构建设置和目标设置

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

验证构建平台

...

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 设置被声明。这些设置代表将编译工具链包的机器，因此我们只需要验证它们是否对应于 Linux 和 x86_64，因为这些是工具链二进制文件 intended 的平台。

重要的是要注意，对于此包，它将被用作 tool_requires，这些设置与 host 配置文件无关，而是与 build 配置文件相关的。Conan 在使用 --build-require 参数创建包时会识别这种区别。这将使 settings 和 settings_build 在包创建的上下文中相等。

验证目标平台

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

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 上下文的期望相符。

这里，图表显示了两个配置文件以及为处于 *build* 上下文中的 **arm-toolchain** 配方选择的设置。

digraph context_diagram { subgraph cluster_build_context { label = "build context"; fontname = Helvetica; labeljust = "l"; style=filled; color=lightblue; "arm-toolchain/13.2" [shape=box, style=filled, color=lightblue, fontname=Helvetica] "settings" [shape=box, style=filled, fillcolor=lightblue, fontname=Helvetica] "settings_target" [shape=box, style=filled, fillcolor=pink, fontname=Helvetica] } subgraph cluster_build_profile { label="build profile"; labeljust = "l"; fontname = Helvetica; color=white "build_profile" [shape=record, label="[settings]\larch=x86_64\lbuild_type=Release\lcompiler=gcc\lcompiler.cppstd=gnu14\lcompiler.version=7\los=Linux\l", style=filled, color=lightblue, fontname=Helvetica] } subgraph cluster_host_profile { label = "host profile"; labeljust = "l"; fontname = Helvetica color = white; "host_profile" [shape=record, label="[settings]\larch=armv8\lbuild_type=Release\lcompiler=gcc\lcompiler.cppstd=gnu14\lcompiler.version=13\los=Linux\l", style=filled, color=pink, fontname=Helvetica] } "build_profile" -> "settings" "host_profile" -> "settings_target" }

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

...

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() 方法用于下载配方许可证，因为它在 ARM 工具链的下载页面上找到。然而，这是执行的唯一操作。实际的工具链二进制文件是在 build() 方法中获取的。这种方法是必要的，因为工具链包旨在支持 32 位和 64 位架构，需要我们下载两组不同的工具链二进制文件。包最终使用哪个二进制文件取决于 settings_target 架构。这个有条件下载过程无法在 source() 方法中发生，因为它 缓存下载的内容。

package() 方法没有什么不同寻常的，它只是将下载的文件复制到包文件夹中，包括许可证。

将 settings_target 添加到包 ID 信息

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

在这种情况下，我们扩展了 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 时考虑目标平台的设置。在这种情况下，我们删除了 os、compiler 和 build_type 设置，因为更改它们与选择我们将用于构建的工具链无关，并且只保留了将用于决定是生成 32 位还是 64 位二进制文件的 arch 设置。

为消费者定义信息

在 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* 程序，并且使用它生成的二进制文件正确地针对指定的架构。

使用工具链构建应用程序

详细介绍了工具链配方后，是时候进行包创建了

$ 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-require 参数。

conan create 命令默认为“主机”上下文创建包，使用“主机”配置文件。但是，如果我们要创建的包 intended 用于带有 tool_requires 的工具，那么它需要改为在“构建”上下文中构建。

--build-require 参数指定了这一点。当提供此参数时，当前配方二进制文件将为“构建”上下文构建，在这种情况下使用 default 配置文件，并且它将接收 raspberry-64 “主机”配置文件设置作为 settings_target。 arm-toolchain/13.2 包是一个在当前“构建”机器上运行的可执行文件包，而不是在 RaspberryPI 上运行，但它是一个针对 RaspberryPI 的工具。

--build-require 参数对于将 arm-toolchain 包正确地构建为构建工具是必要的。

准备好工具链包后，我们继续构建实际的应用程序。这将与之前在 使用 Conan 跨平台编译你的应用程序：主机和构建上下文 部分中跨平台编译的相同应用程序。但是，这一次，我们将工具链包作为主机配置文件中的依赖项包含在内。这确保了使用工具链构建应用程序及其所有依赖项

$ 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 位架构一致。

另请参阅