ツールチェーン

問題を報告する ソースを表示 ナイトリー · 8.0 7.4 . 7.3 · 7.2 · 7.1 · 7.0 · 6.5

このページでは、ツールチェーン フレームワークについて説明します。これは、ルール作成者がルールロジックをプラットフォームベースのツールの選択から分離する方法です。続行する前に、ルールとプラットフォームのページを読むことをおすすめします。このページでは、ツールチェーンが必要である理由、ツールチェーンの定義と使用方法、Bazel がプラットフォームの制約に基づいて適切なツールチェーンを選択する方法について説明します。

目的

まず、ツールチェーンが解決するように設計されている問題を見てみましょう。「bar」プログラミング言語をサポートするルールを記述しているとします。bar_binary ルールは、barc コンパイラを使用して *.bar ファイルをコンパイルします。このツールは、ワークスペース内の別のターゲットとしてビルドされます。bar_binary ターゲットを記述するユーザーがコンパイラへの依存関係を指定する必要がないため、プライベート属性としてルール定義に追加することで、暗黙的な依存関係にします。

bar_binary = rule(
    implementation = _bar_binary_impl,
    attrs = {
        "srcs": attr.label_list(allow_files = True),
        ...
        "_compiler": attr.label(
            default = "//bar_tools:barc_linux",  # the compiler running on linux
            providers = [BarcInfo],
        ),
    },
)

//bar_tools:barc_linux はすべての bar_binary ターゲットの依存関係になったため、bar_binary ターゲットの前にビルドされます。他の属性と同様に、ルールの実装関数からアクセスできます。

BarcInfo = provider(
    doc = "Information about how to invoke the barc compiler.",
    # In the real world, compiler_path and system_lib might hold File objects,
    # but for simplicity they are strings for this example. arch_flags is a list
    # of strings.
    fields = ["compiler_path", "system_lib", "arch_flags"],
)

def _bar_binary_impl(ctx):
    ...
    info = ctx.attr._compiler[BarcInfo]
    command = "%s -l %s %s" % (
        info.compiler_path,
        info.system_lib,
        " ".join(info.arch_flags),
    )
    ...

ここでの問題は、コンパイラのラベルが bar_binary にハードコードされているにもかかわらず、ビルド対象のプラットフォームとビルド元のプラットフォーム（それぞれターゲット プラットフォームと実行プラットフォーム）に応じて、ターゲットごとに異なるコンパイラが必要になる可能性があることです。さらに、ルール作成者が利用可能なツールやプラットフォームをすべて把握しているわけではありません。そのため、ルールの定義にそれらをハードコードすることは現実的ではありません。

_compiler 属性を非公開にすることで、負担をユーザーに移すという解決策は、あまり理想的ではありません。その後、個々のターゲットをハードコードして、特定のプラットフォーム用にビルドできます。

bar_binary(
    name = "myprog_on_linux",
    srcs = ["mysrc.bar"],
    compiler = "//bar_tools:barc_linux",
)

bar_binary(
    name = "myprog_on_windows",
    srcs = ["mysrc.bar"],
    compiler = "//bar_tools:barc_windows",
)

このソリューションを改善するには、select を使用して、プラットフォームに基づいて compiler を選択します。

config_setting(
    name = "on_linux",
    constraint_values = [
        "@platforms//os:linux",
    ],
)

config_setting(
    name = "on_windows",
    constraint_values = [
        "@platforms//os:windows",
    ],
)

bar_binary(
    name = "myprog",
    srcs = ["mysrc.bar"],
    compiler = select({
        ":on_linux": "//bar_tools:barc_linux",
        ":on_windows": "//bar_tools:barc_windows",
    }),
)

ただし、これは面倒で、すべての bar_binary ユーザーに求めるのは少し過剰です。このスタイルがワークスペース全体で一貫して使用されていない場合、単一のプラットフォームでは正常に動作するビルドが、マルチプラットフォームのシナリオに拡張されると失敗します。また、既存のルールやターゲットを変更せずに新しいプラットフォームとコンパイラのサポートを追加する問題にも対処していません。

ツールチェーン フレームワークは、追加レベルの非直接参照を追加することで、この問題を解決します。基本的に、ルールにターゲット ファミリーの一部のメンバー（ツールチェーン タイプ）に対する抽象的な依存関係があることを宣言します。Bazel は、適用可能なプラットフォームの制約に基づいて、これを特定のターゲット（ツールチェーン）に自動的に解決します。ルールの作成者もターゲットの作成者も、使用可能なプラットフォームとツールチェーンの完全なセットを把握する必要はありません。

ツールチェーンを使用するルールの作成

ツールチェーン フレームワークでは、ルールはツールに直接依存するのではなく、ツールチェーンのタイプに依存します。ツールチェーン タイプは、さまざまなプラットフォームで同じ役割を果たすツールのクラスを表す単純なターゲットです。たとえば、bar コンパイラを表す型を宣言できます。

# By convention, toolchain_type targets are named "toolchain_type" and
# distinguished by their package path. So the full path for this would be
# //bar_tools:toolchain_type.
toolchain_type(name = "toolchain_type")

前のセクションのルール定義を変更して、コンパイラを属性として受け取るのではなく、//bar_tools:toolchain_type ツールチェーンを使用することを宣言します。

bar_binary = rule(
    implementation = _bar_binary_impl,
    attrs = {
        "srcs": attr.label_list(allow_files = True),
        ...
        # No `_compiler` attribute anymore.
    },
    toolchains = ["//bar_tools:toolchain_type"],
)

実装関数は、ツールチェーン タイプをキーとして、ctx.attr ではなく ctx.toolchains の下にあるこの依存関係にアクセスするようになりました。

def _bar_binary_impl(ctx):
    ...
    info = ctx.toolchains["//bar_tools:toolchain_type"].barcinfo
    # The rest is unchanged.
    command = "%s -l %s %s" % (
        info.compiler_path,
        info.system_lib,
        " ".join(info.arch_flags),
    )
    ...

ctx.toolchains["//bar_tools:toolchain_type"] は、Bazel がツールチェーンの依存関係を解決したターゲットの ToolchainInfo プロバイダを返します。ToolchainInfo オブジェクトのフィールドは、基盤となるツールのルールによって設定されます。次のセクションでは、BarcInfo オブジェクトをラップする barcinfo フィールドがあるようにこのルールを定義します。

ツールチェーンをターゲットに解決する Bazel の手順については、こちらをご覧ください。解決されたツールチェーン ターゲットのみ、候補ツールチェーンの空間全体ではなく、bar_binary ターゲットの依存関係になります。

必須およびオプションのツールチェーン

デフォルトでは、ルールが裸のラベルを使用してツールチェーン タイプの依存関係を表現している場合（上記を参照）、ツールチェーン タイプは必須と見なされます。Bazel が必須のツールチェーン タイプに一致するツールチェーン（下記のツールチェーンの解決を参照）を見つけられない場合、エラーとなり、分析が停止します。

代わりに、次のように、省略可の toolchain タイプの依存関係を宣言できます。

bar_binary = rule(
    ...
    toolchains = [
        config_common.toolchain_type("//bar_tools:toolchain_type", mandatory = False),
    ],
)

オプションのツールチェーン タイプを解決できない場合、分析は続行され、ctx.toolchains["//bar_tools:toolchain_type"] の結果は None になります。

config_common.toolchain_type 関数はデフォルトで必須です。

次のフォームを使用できます。

• 必須のツールチェーン タイプ:
  • toolchains = ["//bar_tools:toolchain_type"]
  • toolchains = [config_common.toolchain_type("//bar_tools:toolchain_type")]
  • toolchains = [config_common.toolchain_type("//bar_tools:toolchain_type", mandatory = True)]
• オプションのツールチェーン タイプ:
  • toolchains = [config_common.toolchain_type("//bar_tools:toolchain_type", mandatory = False)]

bar_binary = rule(
    ...
    toolchains = [
        "//foo_tools:toolchain_type",
        config_common.toolchain_type("//bar_tools:toolchain_type", mandatory = False),
    ],
)

同じルール内でフォームを組み合わせることもできます。ただし、同じ toolchain タイプが複数回リストされている場合は、最も厳格なバージョンが使用されます。ここで、必須は省略可よりも厳格です。

ツールチェーンを使用するアスペクトの作成

アスペクトは、ルールと同じ toolchain API にアクセスできます。必要な toolchain タイプを定義し、コンテキストを介して toolchain にアクセスし、toolchain を使用して新しいアクションを生成できます。

bar_aspect = aspect(
    implementation = _bar_aspect_impl,
    attrs = {},
    toolchains = ['//bar_tools:toolchain_type'],
)

def _bar_aspect_impl(target, ctx):
  toolchain = ctx.toolchains['//bar_tools:toolchain_type']
  # Use the toolchain provider like in a rule.
  return []

ツールチェーンの定義

特定のツールチェーン タイプにツールチェーンを定義するには、次の 3 つが必要です。

1. ツールまたはツールスイートの種類を表す言語固有のルール。規則により、このルールの名前には「_toolchain」という接尾辞が付けられます。

   1. 注: \_toolchain ルールではビルドアクションを作成できません。代わりに、他のルールからアーティファクトを収集し、ツールチェーンを使用するルールに転送します。このルールは、すべてのビルドアクションの作成を担当します。

2. このタイプのルールの複数のターゲット。さまざまなプラットフォームのツールまたはツールスイートのバージョンを表します。

3. このようなターゲットごとに、汎用 toolchain ルールの関連ターゲット。ツールチェーン フレームワークで使用されるメタデータを提供します。この toolchain ターゲットは、この toolchain に関連付けられた toolchain_type も参照します。つまり、特定の _toolchain ルールは任意の toolchain_type に関連付けることができ、この _toolchain ルールを使用する toolchain インスタンスでのみ、ルールが toolchain_type に関連付けられます。

実行中の例では、bar_toolchain ルールの定義は次のようになります。この例ではコンパイラのみですが、リンカーなどの他のツールもその下にグループ化できます。

def _bar_toolchain_impl(ctx):
    toolchain_info = platform_common.ToolchainInfo(
        barcinfo = BarcInfo(
            compiler_path = ctx.attr.compiler_path,
            system_lib = ctx.attr.system_lib,
            arch_flags = ctx.attr.arch_flags,
        ),
    )
    return [toolchain_info]

bar_toolchain = rule(
    implementation = _bar_toolchain_impl,
    attrs = {
        "compiler_path": attr.string(),
        "system_lib": attr.string(),
        "arch_flags": attr.string_list(),
    },
)

ルールは ToolchainInfo プロバイダを返す必要があります。このプロバイダは、コンシューマ ルールが ctx.toolchains とツールチェーン タイプのラベルを使用して取得するオブジェクトになります。ToolchainInfo は、struct と同様に、任意のフィールド値ペアを保持できます。ToolchainInfo に追加されるフィールドの詳細は、ツールチェーン タイプで明確に記述する必要があります。この例では、値は BarcInfo オブジェクトにラップされて返され、上記で定義したスキーマが再利用されます。このスタイルは、検証とコードの再利用に役立ちます。

特定の barc コンパイラにターゲットを定義できるようになりました。

bar_toolchain(
    name = "barc_linux",
    arch_flags = [
        "--arch=Linux",
        "--debug_everything",
    ],
    compiler_path = "/path/to/barc/on/linux",
    system_lib = "/usr/lib/libbarc.so",
)

bar_toolchain(
    name = "barc_windows",
    arch_flags = [
        "--arch=Windows",
        # Different flags, no debug support on windows.
    ],
    compiler_path = "C:\\path\\on\\windows\\barc.exe",
    system_lib = "C:\\path\\on\\windows\\barclib.dll",
)

最後に、2 つの bar_toolchain ターゲットの toolchain 定義を作成します。これらの定義は、言語固有のターゲットを toolchain タイプにリンクし、特定のプラットフォームに toolchain が適しているかどうかを Bazel に通知する制約情報を提供します。

toolchain(
    name = "barc_linux_toolchain",
    exec_compatible_with = [
        "@platforms//os:linux",
        "@platforms//cpu:x86_64",
    ],
    target_compatible_with = [
        "@platforms//os:linux",
        "@platforms//cpu:x86_64",
    ],
    toolchain = ":barc_linux",
    toolchain_type = ":toolchain_type",
)

toolchain(
    name = "barc_windows_toolchain",
    exec_compatible_with = [
        "@platforms//os:windows",
        "@platforms//cpu:x86_64",
    ],
    target_compatible_with = [
        "@platforms//os:windows",
        "@platforms//cpu:x86_64",
    ],
    toolchain = ":barc_windows",
    toolchain_type = ":toolchain_type",
)

上記の相対パス構文を使用すると、これらの定義がすべて同じパッケージにあることが示唆されますが、ツールチェーン タイプ、言語固有のツールチェーン ターゲット、toolchain 定義ターゲットをすべて個別のパッケージに配置できない理由はありません。

実際の例については、go_toolchain をご覧ください。

ツールチェーンと構成

ルール作成者にとって重要な質問は、bar_toolchain ターゲットが分析されたときに、どのような構成が検出され、依存関係にどのような遷移を使用すべきかということです。上記の例では文字列属性を使用していますが、Bazel リポジトリ内の他のターゲットに依存するより複雑なツールチェーンの場合はどうなりますか。

bar_toolchain のより複雑なバージョンを見てみましょう。

def _bar_toolchain_impl(ctx):
    # The implementation is mostly the same as above, so skipping.
    pass

bar_toolchain = rule(
    implementation = _bar_toolchain_impl,
    attrs = {
        "compiler": attr.label(
            executable = True,
            mandatory = True,
            cfg = "exec",
        ),
        "system_lib": attr.label(
            mandatory = True,
            cfg = "target",
        ),
        "arch_flags": attr.string_list(),
    },
)

attr.label の使用方法は標準ルールと同じですが、cfg パラメータの意味は少し異なります。

ターゲット（「親」）から toolchain 解決を経由して toolchain への依存関係では、「toolchain 遷移」と呼ばれる特別な構成遷移が使用されます。ツールチェーンの移行では、実行プラットフォームがツールチェーンと親の間で強制的に同じになる点を除き、構成は同じままです（そうしないと、ツールチェーンのツールチェーン解決で任意の実行プラットフォームが選択され、親と同じとは限りません）。これにより、ツールチェーンの exec 依存関係を親のビルドアクションでも実行できるようになります。cfg = "target" を使用する（または「target」がデフォルトであるため cfg を指定しない場合）ツールチェーンの依存関係は、親と同じターゲット プラットフォーム用にビルドされます。これにより、ツールチェーン ルールは、ライブラリ（上記の system_lib 属性）とツール（compiler 属性）の両方を、それらを必要とするビルドルールに提供できます。システム ライブラリは最終的なアーティファクトにリンクされるため、同じプラットフォーム用にビルドする必要があります。一方、コンパイラはビルド中に呼び出されるツールであり、実行プラットフォームで実行できる必要があります。

ツールチェーンを使用した登録とビルド

この時点で、すべての構成要素が組み合わされています。あとは、Bazel の解決手順で使用できるようにツールチェーンを作成するだけです。これは、register_toolchains() を使用して MODULE.bazel ファイルに toolchain を登録するか、--extra_toolchains フラグを使用してコマンドラインで toolchain のラベルを渡すことで行います。

register_toolchains(
    "//bar_tools:barc_linux_toolchain",
    "//bar_tools:barc_windows_toolchain",
    # Target patterns are also permitted, so you could have also written:
    # "//bar_tools:all",
    # or even
    # "//bar_tools/...",
)

ターゲット パターンを使用して toolchain を登録する場合、個々の toolchain が登録される順序は次のルールによって決まります。

• パッケージのサブパッケージで定義された toolchain は、パッケージ自体で定義された toolchain の前に登録されます。
• パッケージ内で、ツールチェーンは名前の辞書順で登録されます。

これで、ツールチェーン タイプに依存するターゲットをビルドするときに、ターゲットと実行プラットフォームに基づいて適切なツールチェーンが選択されます。

# my_pkg/BUILD

platform(
    name = "my_target_platform",
    constraint_values = [
        "@platforms//os:linux",
    ],
)

bar_binary(
    name = "my_bar_binary",
    ...
)

bazel build //my_pkg:my_bar_binary --platforms=//my_pkg:my_target_platform

Bazel は、//my_pkg:my_bar_binary が @platforms//os:linux を含むプラットフォームでビルドされていることを認識し、//bar_tools:toolchain_type 参照を //bar_tools:barc_linux_toolchain に解決します。これにより、//bar_tools:barc_linux はビルドされますが、//bar_tools:barc_windows はビルドされません。

ツールチェーンの解決

注: 一部の Bazel ルールは、まだ toolchain 解決をサポートしていません。

ツールチェーンを使用するターゲットごとに、Bazel のツールチェーン解決プロシージャによって、ターゲットの具体的なツールチェーン依存関係が決定されます。この手順では、必要なツールチェーン タイプ、ターゲット プラットフォーム、使用可能な実行プラットフォームのリスト、使用可能なツールチェーンのリストを入力として受け取ります。出力は、ツールチェーン タイプごとに選択されたツールチェーンと、現在のターゲット用に選択された実行プラットフォームです。

使用可能な実行プラットフォームとツールチェーンは、MODULE.bazelfiles. Additional execution platforms and toolchains may also be specified on the command line via [--extra_execution_platforms](/versions/7.4.0/reference/command-line-reference#flag--extra_execution_platforms) and [--extra_toolchains`](/versions/7.4.0/reference/command-line-reference#flag--extra_toolchains) の register_execution_platforms 呼び出しと register_toolchains 呼び出しを介して外部依存関係グラフから収集されます。ホスト プラットフォームは、使用可能な実行プラットフォームとして自動的に追加されます。使用可能なプラットフォームとツールチェーンは、確定性のために順序付きリストとして追跡され、リスト内の前半のアイテムが優先されます。

使用可能なツールチェーンのセットは、--extra_toolchains と register_toolchains から優先順位の高い順に作成されます。

1. --extra_toolchains を使用して登録されたツールチェーンが最初に追加されます。（これらの中で、最新のツールチェーンが最も優先されます）。
2. 伝播外部依存関係グラフで register_toolchains を使用して登録されたツールチェーン（次の順序で優先度が決まります。これらの中で、最初に記載されているツールチェーンの優先度が最も高くなります）。
   1. ルート モジュールによって登録されたツールチェーン（ワークスペースのルートにある MODULE.bazel など）。
   2. ユーザーの WORKSPACE ファイルに登録されているツールチェーン（そこから呼び出されるマクロを含む）
   3. ルート以外のモジュールによって登録されたツールチェーン（ルート モジュールで指定された依存関係、その依存関係など）。
   4. 「WORKSPACE 接尾辞」に登録されたツールチェーン。これは、Bazel インストールにバンドルされている特定のネイティブ ルールでのみ使用されます。

注: :all、:*、/... などの疑似ターゲットは、辞書順の順序付けを使用する Bazel のパッケージ読み込みメカニズムによって順序付けられます。

解決手順は次のとおりです。

1. target_compatible_with 句または exec_compatible_with 句は、リスト内の constraint_value ごとに、プラットフォームにもその constraint_value が（明示的またはデフォルトとして）含まれている場合、プラットフォームに一致します。

   プラットフォームに、句で参照されていない constraint_setting の constraint_value が含まれている場合、それらはマッチングには影響しません。

2. ビルドされるターゲットで exec_compatible_with 属性が指定されている場合（またはそのルール定義で exec_compatible_with 引数が指定されている場合）、使用可能な実行プラットフォームのリストがフィルタされ、実行制約に一致しないものが削除されます。

3. 使用可能な実行プラットフォームごとに、各ツールチェーン タイプを、この実行プラットフォームとターゲット プラットフォームと互換性のある最初の利用可能なツールチェーン（存在する場合）に関連付けます。

4. いずれかのツールチェーン タイプに互換性のある必須ツールチェーンが見つからなかった実行プラットフォームは除外されます。残りのプラットフォームのうち、最初のプラットフォームが現在のターゲットの実行プラットフォームになり、それに関連付けられたツールチェーン（存在する場合）がターゲットの依存関係になります。

選択した実行プラットフォームは、ターゲットが生成するすべてのアクションの実行に使用されます。

同じターゲットを同じビルド内で複数の構成（異なる CPU など）でビルドできる場合は、解決手順がターゲットの各バージョンに個別に適用されます。

ルールで実行グループを使用する場合、各実行グループは個別にツールチェーンの解決を行い、それぞれに独自の実行プラットフォームとツールチェーンがあります。

ツールチェーンのデバッグ

既存のルールにツールチェーンのサポートを追加する場合は、--toolchain_resolution_debug=regex フラグを使用します。ツールチェーンの解決中に、このフラグは正規表現変数に一致するツールチェーン タイプまたはターゲット名の詳細な出力を生成します。.* を使用すると、すべての情報を出力できます。Bazel は、解決プロセス中にチェックし、スキップするツールチェーンの名前を出力します。

ツールチェーンの解決から取得された cquery 依存関係を確認するには、cquery の --transitions フラグを使用します。

# Find all direct dependencies of //cc:my_cc_lib. This includes explicitly
# declared dependencies, implicit dependencies, and toolchain dependencies.
$ bazel cquery 'deps(//cc:my_cc_lib, 1)'
//cc:my_cc_lib (96d6638)
@bazel_tools//tools/cpp:toolchain (96d6638)
@bazel_tools//tools/def_parser:def_parser (HOST)
//cc:my_cc_dep (96d6638)
@local_config_platform//:host (96d6638)
@bazel_tools//tools/cpp:toolchain_type (96d6638)
//:default_host_platform (96d6638)
@local_config_cc//:cc-compiler-k8 (HOST)
//cc:my_cc_lib.cc (null)
@bazel_tools//tools/cpp:grep-includes (HOST)

# Which of these are from toolchain resolution?
$ bazel cquery 'deps(//cc:my_cc_lib, 1)' --transitions=lite | grep "toolchain dependency"
  [toolchain dependency]#@local_config_cc//:cc-compiler-k8#HostTransition -> b6df211