Bazel 튜토리얼: C++ 도구 모음 구성

문제 신고 소스 보기 나이틀리 · 8.3 · 8.2 · 8.1 · 8.0 · 7.6

이 튜토리얼에서는 예시 시나리오를 사용하여 프로젝트의 C++ 도구 모음을 구성하는 방법을 설명합니다.

학습할 내용

이 튜토리얼에서는 다음을 수행하는 방법을 알아봅니다.

  • 빌드 환경 설정
  • --toolchain_resolution_debug을 사용하여 도구 모음 해결 디버그
  • C++ 도구 모음 구성
  • Bazel이 clang로 애플리케이션을 빌드할 수 있도록 cc_toolchain의 추가 구성을 제공하는 Starlark 규칙을 만듭니다.
  • Linux 머신에서 bazel build //main:hello-world를 실행하여 C++ 바이너리 빌드
  • bazel build //main:hello-world --platforms=//:android_x86_64를 실행하여 Android용 바이너리를 크로스 컴파일합니다.

시작하기 전에

이 튜토리얼에서는 Linux를 사용하고 C++ 애플리케이션을 성공적으로 빌드했으며 적절한 도구와 라이브러리를 설치했다고 가정합니다. 이 튜토리얼에서는 시스템에 설치할 수 있는 clang version 19를 사용합니다.

빌드 환경 설정

다음과 같이 빌드 환경을 설정합니다.

  1. 아직 수행하지 않았다면 Bazel 7.0.2 이상을 다운로드하고 설치합니다.

  2. 루트 폴더에 빈 MODULE.bazel 파일을 추가합니다.

  3. main/BUILD 파일에 다음 cc_binary 타겟을 추가합니다.

    cc_binary(
    name = "hello-world",
    srcs = ["hello-world.cc"],
)

    Bazel은 빌드 중에 process-wrapper와 같이 C++로 작성된 많은 내부 도구를 사용하므로 기존 기본 C++ 도구 모음이 호스트 플랫폼에 지정됩니다. 이렇게 하면 이러한 내부 도구가 이 튜토리얼에서 만든 도구 모음을 사용하여 빌드할 수 있습니다. 따라서 cc_binary 타겟도 기본 도구 모음으로 빌드됩니다.

  4. 다음 명령어를 사용하여 빌드를 실행합니다.

    bazel build //main:hello-world

    MODULE.bazel에 등록된 도구 체인이 없어도 빌드가 성공합니다.

    내부 작동 방식을 자세히 알아보려면 다음을 실행하세요.

    bazel build //main:hello-world --toolchain_resolution_debug='@bazel_tools//tools/cpp:toolchain_type'

INFO: ToolchainResolution: Target platform @@platforms//host:host: Selected execution platform @@platforms//host:host, type @@bazel_tools//tools/cpp:toolchain_type -> toolchain @@bazel_tools+cc_configure_extension+local_config_cc//:cc-compiler-k8

    --platforms를 지정하지 않으면 Bazel은 @bazel_tools+cc_configure_extension+local_config_cc//:cc-compiler-k8을 사용하여 @platforms//host의 타겟을 빌드합니다.

C++ 도구 모음 구성

C++ 도구 모음을 구성하려면 다음 설명에 따라 애플리케이션을 반복적으로 빌드하고 각 오류를 하나씩 제거하세요.

또한 clang version 9.0.1를 가정합니다. 하지만 세부사항은 서로 다른 버전의 clang 간에 약간만 변경되어야 합니다.

  1. 다음과 함께 toolchain/BUILD 추가

    filegroup(name = "empty")

cc_toolchain(
    name = "linux_x86_64_toolchain",
    toolchain_identifier = "linux_x86_64-toolchain",
    toolchain_config = ":linux_x86_64_toolchain_config",
    all_files = ":empty",
    compiler_files = ":empty",
    dwp_files = ":empty",
    linker_files = ":empty",
    objcopy_files = ":empty",
    strip_files = ":empty",
    supports_param_files = 0,
)

toolchain(
    name = "cc_toolchain_for_linux_x86_64",
    toolchain = ":linux_x86_64_toolchain",
    toolchain_type = "@bazel_tools//tools/cpp:toolchain_type",
    exec_compatible_with = [
        "@platforms//cpu:x86_64",
        "@platforms//os:linux",
    ],
    target_compatible_with = [
        "@platforms//cpu:x86_64",
        "@platforms//os:linux",
    ],
)

    그런 다음 적절한 종속 항목을 추가하고 다음을 사용하여 MODULE.bazel로 도구 모음을 등록합니다.

    bazel_dep(name = "platforms", version = "0.0.10")
register_toolchains(
    "//toolchain:cc_toolchain_for_linux_x86_64"
)

    이 단계에서는 cc_toolchain를 정의하고 호스트 구성의 toolchain 타겟에 바인딩합니다.

  2. 빌드를 다시 실행합니다. toolchain 패키지에서 아직 linux_x86_64_toolchain_config 타겟을 정의하지 않았으므로 Bazel에서 다음 오류를 발생시킵니다.

    ERROR: toolchain/BUILD:4:13: in toolchain_config attribute of cc_toolchain rule //toolchain:linux_x86_64_toolchain: rule '//toolchain:linux_x86_64_toolchain_config' does not exist.

  3. toolchain/BUILD 파일에서 다음과 같이 빈 filegroup을 정의합니다.

    package(default_visibility = ["//visibility:public"])

filegroup(name = "linux_x86_64_toolchain_config")

  4. 빌드를 다시 실행합니다. Bazel에서 다음 오류가 발생합니다.

    '//toolchain:linux_x86_64_toolchain_config' does not have mandatory providers: 'CcToolchainConfigInfo'.

    CcToolchainConfigInfo는 C++ 도구 모음을 구성하는 데 사용하는 제공자입니다. 이 오류를 수정하려면 다음 콘텐츠로 toolchain/cc_toolchain_config.bzl 파일을 만들어 CcToolchainConfigInfo를 Bazel에 제공하는 Starlark 규칙을 만드세요.

    def _impl(ctx):
    return cc_common.create_cc_toolchain_config_info(
        ctx = ctx,
        toolchain_identifier = "k8-toolchain",
        host_system_name = "local",
        target_system_name = "local",
        target_cpu = "k8",
        target_libc = "unknown",
        compiler = "clang",
        abi_version = "unknown",
        abi_libc_version = "unknown",
    )

cc_toolchain_config = rule(
    implementation = _impl,
    attrs = {},
    provides = [CcToolchainConfigInfo],
)

    cc_common.create_cc_toolchain_config_info()는 필요한 제공자 CcToolchainConfigInfo를 만듭니다. cc_toolchain_config 규칙을 사용하려면 패키지 문 바로 아래에 toolchain/BUILD에 로드 문을 추가합니다.

    load(":cc_toolchain_config.bzl", "cc_toolchain_config")

    'linux_x86_64_toolchain_config' filegroup을 cc_toolchain_config 규칙 선언으로 바꿉니다.

    cc_toolchain_config(name = "linux_x86_64_toolchain_config")

  5. 빌드를 다시 실행합니다. Bazel에서 다음 오류가 발생합니다.

    .../BUILD:1:1: C++ compilation of rule '//:hello-world' failed (Exit 1)
src/main/tools/linux-sandbox-pid1.cc:421:
"execvp(toolchain/DUMMY_GCC_TOOL, 0x11f20e0)": No such file or directory
Target //:hello-world failed to build`

    이 시점에서 Bazel은 코드를 빌드하기에 충분한 정보를 가지고 있지만 필요한 빌드 작업을 완료하는 데 사용할 도구는 아직 알지 못합니다. Starlark 규칙 구현을 수정하여 Bazel에 사용할 도구를 알려줍니다. 이를 위해서는 @bazel_tools//tools/cpp:cc_toolchain_config_lib.bzl의 tool_path() 생성자가 필요합니다.

    # toolchain/cc_toolchain_config.bzl:
# NEW
load("@bazel_tools//tools/cpp:cc_toolchain_config_lib.bzl", "tool_path")

def _impl(ctx):
    tool_paths = [ # NEW
        tool_path(
            name = "gcc",  # Compiler is referenced by the name "gcc" for historic reasons.
            path = "/usr/bin/clang",
        ),
        tool_path(
            name = "ld",
            path = "/usr/bin/ld",
        ),
        tool_path(
            name = "ar",
            path = "/usr/bin/ar",
        ),
        tool_path(
            name = "cpp",
            path = "/bin/false",
        ),
        tool_path(
            name = "gcov",
            path = "/bin/false",
        ),
        tool_path(
            name = "nm",
            path = "/bin/false",
        ),
        tool_path(
            name = "objdump",
            path = "/bin/false",
        ),
        tool_path(
            name = "strip",
            path = "/bin/false",
        ),
    ]

    return cc_common.create_cc_toolchain_config_info(
        ctx = ctx,
        toolchain_identifier = "local",
        host_system_name = "local",
        target_system_name = "local",
        target_cpu = "k8",
        target_libc = "unknown",
        compiler = "clang",
        abi_version = "unknown",
        abi_libc_version = "unknown",
        tool_paths = tool_paths, # NEW
    )

    /usr/bin/clang 및 /usr/bin/ld이 시스템의 올바른 경로인지 확인합니다. 컴파일러는 과거의 이유로 'gcc'라는 이름으로 참조됩니다.

  6. 빌드를 다시 실행합니다. Bazel에서 다음 오류가 발생합니다.

    ERROR: main/BUILD:3:10: Compiling main/hello-world.cc failed: absolute path inclusion(s) found in rule '//main:hello-world':
the source file 'main/hello-world.cc' includes the following non-builtin files with absolute paths (if these are builtin files, make sure these paths are in your toolchain):
  '/usr/include/c++/13/ctime'
  '/usr/include/x86_64-linux-gnu/c++/13/bits/c++config.h'
  '/usr/include/x86_64-linux-gnu/c++/13/bits/os_defines.h'
  ...

    Bazel은 포함된 헤더를 검색할 위치를 알아야 합니다. cc_binary의 includes 속성을 사용하는 등 이 문제를 해결하는 방법은 여러 가지가 있지만 여기서는 cc_common.create_cc_toolchain_config_info의 cxx_builtin_include_directories 매개변수를 사용하여 툴체인 수준에서 해결합니다. 다른 버전의 clang를 사용하는 경우 포함 경로가 달라집니다. 이 경로도 배포에 따라 다를 수 있습니다.

    toolchain/cc_toolchain_config.bzl의 반환 값을 다음과 같이 수정합니다.

    return cc_common.create_cc_toolchain_config_info(
    ctx = ctx,
    cxx_builtin_include_directories = [ # NEW
        "/usr/lib/llvm-19/lib/clang/19/include",
        "/usr/include",
    ],
    toolchain_identifier = "local",
    host_system_name = "local",
    target_system_name = "local",
    target_cpu = "k8",
    target_libc = "unknown",
    compiler = "clang",
    abi_version = "unknown",
    abi_libc_version = "unknown",
    tool_paths = tool_paths,
)

  7. 빌드 명령어를 다시 실행하면 다음과 같은 오류가 표시됩니다.

    /usr/bin/ld: bazel-out/k8-fastbuild/bin/main/_objs/hello-world/hello-world.o: in function `print_localtime()':
hello-world.cc:(.text+0x68): undefined reference to `std::cout'

    링커에 C++ 표준 라이브러리가 누락되어 심볼을 찾을 수 없기 때문입니다. cc_binary의 linkopts 속성을 사용하는 등 이 문제를 해결하는 방법은 여러 가지가 있습니다. 여기서는 도구 모음을 사용하는 타겟이 이 플래그를 지정하지 않아도 되도록 하여 해결합니다.

    다음 코드를 toolchain/cc_toolchain_config.bzl에 복사합니다.

    # NEW
load("@bazel_tools//tools/build_defs/cc:action_names.bzl", "ACTION_NAMES")
# NEW
load(
    "@bazel_tools//tools/cpp:cc_toolchain_config_lib.bzl",
    "feature",    # NEW
    "flag_group", # NEW
    "flag_set",   # NEW
    "tool_path",
)

all_link_actions = [ # NEW
    ACTION_NAMES.cpp_link_executable,
    ACTION_NAMES.cpp_link_dynamic_library,
    ACTION_NAMES.cpp_link_nodeps_dynamic_library,
]

def _impl(ctx):
    tool_paths = [
        tool_path(
            name = "gcc",  # Compiler is referenced by the name "gcc" for historic reasons.
            path = "/usr/bin/clang",
        ),
        tool_path(
            name = "ld",
            path = "/usr/bin/ld",
        ),
        tool_path(
            name = "ar",
            path = "/bin/false",
        ),
        tool_path(
            name = "cpp",
            path = "/bin/false",
        ),
        tool_path(
            name = "gcov",
            path = "/bin/false",
        ),
        tool_path(
            name = "nm",
            path = "/bin/false",
        ),
        tool_path(
            name = "objdump",
            path = "/bin/false",
        ),
        tool_path(
            name = "strip",
            path = "/bin/false",
        ),
    ]

    features = [ # NEW
        feature(
            name = "default_linker_flags",
            enabled = True,
            flag_sets = [
                flag_set(
                    actions = all_link_actions,
                    flag_groups = ([
                        flag_group(
                            flags = [
                                "-lstdc++",
                            ],
                        ),
                    ]),
                ),
            ],
        ),
    ]

    return cc_common.create_cc_toolchain_config_info(
        ctx = ctx,
        features = features, # NEW
        cxx_builtin_include_directories = [
            "/usr/lib/llvm-19/lib/clang/19/include",
            "/usr/include",
        ],
        toolchain_identifier = "local",
        host_system_name = "local",
        target_system_name = "local",
        target_cpu = "k8",
        target_libc = "unknown",
        compiler = "clang",
        abi_version = "unknown",
        abi_libc_version = "unknown",
        tool_paths = tool_paths,
    )

cc_toolchain_config = rule(
    implementation = _impl,
    attrs = {},
    provides = [CcToolchainConfigInfo],
)

    이 코드에서는 GNU C++ 라이브러리 libstdc++를 사용합니다. LLVM C++ 라이브러리를 사용하려면 '-lstdc++' 대신 '-lc++'를 사용하세요.

  8. bazel build //main:hello-world를 실행하면 최종적으로 호스트용 바이너리가 성공적으로 빌드됩니다.

  9. toolchain/BUILD에서 cc_toolchain_config, cc_toolchain, toolchain 타겟을 복사하고 타겟 이름에서 linux_x86_64를 android_x86_64으로 바꿉니다.

    MODULE.bazel에서 Android용 도구 모음을 등록합니다.

    register_toolchains(
    "//toolchain:cc_toolchain_for_linux_x86_64",
    "//toolchain:cc_toolchain_for_android_x86_64"
)

  10. bazel build //main:hello-world --android_platforms=//toolchain:android_x86_64를 실행하여 Android용 바이너리를 빌드합니다.

실제로 Linux와 Android는 C++ 도구 모음 구성이 달라야 합니다. 차이점에 대해 기존 cc_toolchain_config를 수정하거나 별도의 플랫폼에 대해 별도의 규칙 (즉, CcToolchainConfigInfo 제공자)을 만들 수 있습니다.

작업 검토

이 튜토리얼에서는 기본 C++ 도구 모음을 구성하는 방법을 알아봤지만 도구 모음은 이 예보다 훨씬 강력합니다.

핵심 내용은 다음과 같습니다.

  • Bazel이 플랫폼에서 동일한 제약 조건 값의 도구 모음으로 확인되도록 명령줄에 일치하는 platforms 플래그를 지정해야 합니다. 문서에는 언어별 구성 플래그에 관한 자세한 정보가 나와 있습니다.
  • 툴체인에 도구가 있는 위치를 알려야 합니다. 이 튜토리얼에는 시스템에서 도구에 액세스하는 간소화된 버전이 있습니다. 더 독립적인 접근 방식에 관심이 있다면 외부 종속 항목에 대해 알아보세요. 도구가 다른 모듈에서 제공될 수 있으며 compiler_files과 같은 속성에 타겟 종속 항목을 사용하여 cc_toolchain에서 파일을 사용할 수 있도록 해야 합니다. tool_paths도 변경해야 합니다.
  • 연결 또는 기타 유형의 작업 등 다양한 작업에 전달할 플래그를 맞춤설정하는 기능을 만들 수 있습니다.

추가 자료

자세한 내용은 C++ 도구 모음 구성을 참고하세요.