build/rust/std/BUILD.gn - cobalt - Git at Google

 # Copyright 2021 The Chromium Authors
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.

 # This file provides the ability for our C++ toolchain to successfully
 # link binaries containing arbitrary Rust code.
 #
 # By "arbitrary Rust code" I mean .rlib archives full of Rust code, which
 # is actually a static archive.
 #
 # Those static libraries don't link as-is into a final executable because
 # they're designed for downstream processing by further invocations of rustc
 # which link into a final binary. That final invocation of rustc knows how
 # to do two things:
 # * Find the Rust standard library.
 # * Remap some generic allocator symbols to the specific allocator symbols
 #   in use.
 # This file takes care of equivalent tasks for our C++ toolchains.
 # C++ targets should depend upon either link_local_std or
 # link_prebuilt_std to ensure that Rust code can be linked into their
 # C++ executables.
 #
 # This is obviously a bit fragile - rustc might do other magic in future.
 # But, linking with a final C++ toolchain is something often needed, and
 # https://github.com/rust-lang/rust/issues/64191 aims to make this
 # officially possible.

 import("//build/config/compiler/compiler.gni")
 import("//build/config/rust.gni")

 if (toolchain_has_rust) {
   # Equivalent of allocator symbols injected by rustc.
   source_set("remap_alloc") {
     sources = [
       "immediate_crash.h",
       "remap_alloc.cc",
     ]
   }

   # List of Rust stdlib rlibs which are present in the official Rust toolchain
   # we are using from the Android team. This is usually a version or two behind
   # nightly. Generally this matches the toolchain we build ourselves, but if
   # they differ, append or remove libraries based on the
   # `use_chromium_rust_toolchain` GN variable.
   #
   # If the build fails due to missing symbols, it would be because of a missing
   # library that needs to be added here in a newer stdlib.
   stdlib_files = [
     "std",  # List first because it makes depfiles more debuggable (see below)
     "addr2line",
     "adler",
     "alloc",
     "cfg_if",
     "compiler_builtins",
     "core",
     "getopts",
     "gimli",
     "hashbrown",
     "libc",
     "memchr",
     "miniz_oxide",
     "object",
     "panic_abort",
     "panic_unwind",
     "rustc_demangle",
     "std_detect",
     "test",
     "unicode_width",
     "unwind",
   ]

   if (is_win) {
     # Our C++ builds already link against a wide variety of Windows API import libraries,
     # but the Rust stdlib requires a few extra.
     _windows_lib_deps = [
       "bcrypt.lib",
       "ntdll.lib",
       "userenv.lib",
     ]
   }

   # rlibs explicitly ignored when copying prebuilt sysroot libraries.
   # find_std_rlibs.py rightfully errors out if an unexpected prebuilt lib is
   # encountered, since it usually indicates we missed something. This ignore
   # list is also passed to it. This has no effect on the local std build.
   ignore_stdlib_files = []

   # proc_macro is special: we only run proc macros on the host, so we only want
   # it for our host toolchain.
   if (current_toolchain == host_toolchain_no_sanitizers) {
     # Directs the local_std_for_rustc target to depend on proc_macro, and
     # includes proc_macro in the prebuilts copied in find_stdlib. Otherwise it
     # is not built or copied.
     stdlib_files += [ "proc_macro" ]
   } else {
     # Explicitly ignore it from the prebuilts. Nothing needs to be done for the
     # local std build.
     ignore_stdlib_files += [ "proc_macro" ]
   }

   # Different Rust toolchains may add or remove files relative to the above
   # list. That can be specified in gn args for anyone using (for instance)
   # nightly or some other experimental toolchain, prior to it becoming official.
   stdlib_files -= removed_rust_stdlib_libs
   stdlib_files += added_rust_stdlib_libs

   # rlib files which are distributed alongside Rust's prebuilt stdlib, but we
   # don't need to pass to the C++ linker because they're used for specialized
   # purposes.
   skip_stdlib_files = [
     "profiler_builtins",
     "rustc_std_workspace_alloc",
     "rustc_std_workspace_core",
     "rustc_std_workspace_std",
   ]
   if (prebuilt_libstd_supported) {
     action("find_stdlib") {
       # Collect prebuilt Rust libraries from toolchain package and copy to a known
       # location.
       #
       # The Rust toolchain contains prebuilt rlibs for the standard library and
       # its dependencies. However, they have unstable names: an unpredictable
       # metadata hash is appended to the known crate name.
       #
       # We must depend on these rlibs explicitly when rustc is not in charge of
       # linking. However, it is difficult to construct GN rules to do so when the
       # names can't be known statically.
       #
       # This action copies the prebuilt rlibs to a known location, removing the
       # metadata part of the name. In the process it verifies we have all the
       # libraries we expect and none that we don't. A depfile is generated so this
       # step is re-run when any libraries change. The action script additionally
       # verifies rustc matches the expected version, which is unrelated but this
       # is a convenient place to do so.
       #
       # The action refers to `stdlib_files`, `skip_stdlib_files`, and the
       # associated //build/config/rust.gni vars `removed_rust_stdlib_libs` and
       # `added_rust_stdlib_libs` for which rlib files to expect.
       # `extra_sysroot_libs` is also used to copy non-std libs, if any.
       script = "find_std_rlibs.py"
       depfile = "$target_out_dir/stdlib.d"
       out_libdir = rebase_path(target_out_dir, root_build_dir)
       out_depfile = rebase_path(depfile, root_build_dir)

       # For the rustc sysroot we must include even the rlibs we don't pass to the
       # C++ linker.
       all_stdlibs_to_copy = stdlib_files + skip_stdlib_files
       args = [
         "--rust-bin-dir",
         rebase_path("${rust_sysroot}/bin", root_build_dir),
         "--output",
         out_libdir,
         "--depfile",
         out_depfile,

         # Due to limitations in Ninja's handling of .d files, we have to pick
         # *the first* of our outputs. To make diagnostics more obviously
         # related to the Rust standard library, we ensure libstd.rlib is first.
         "--depfile-target",
         stdlib_files[0],

         # Create a dependency on the rustc version so this action is re-run when
         # it changes. This argument is not actually read by the script.
         "--rustc-revision",
         rustc_revision,
       ]

       if (!use_unverified_rust_toolchain) {
         args += [
           "--stdlibs",
           string_join(",", all_stdlibs_to_copy),
         ]

         if (ignore_stdlib_files != []) {
           args += [
             "--ignore-stdlibs",
             string_join(",", ignore_stdlib_files),
           ]
         }
       }

       if (extra_sysroot_libs != []) {
         args += [
           "--extra-libs",
           string_join(",", extra_sysroot_libs),
         ]
       }

       args += [
         "--target",
         rust_abi_target,
       ]

       outputs = []
       foreach(lib, all_stdlibs_to_copy) {
         outputs += [ "$target_out_dir/lib$lib.rlib" ]
       }
       foreach(lib, extra_sysroot_libs) {
         outputs += [ "$target_out_dir/$lib" ]
       }
     }
   } else {
     not_needed([ "ignore_stdlib_files" ])
   }

   # Construct sysroots for rustc invocations to better control what libraries
   # are linked. We have two: one with copied prebuilt libraries, and one with
   # our locally-built std. Both reside in root_out_dir: we must only have one of
   # each per GN toolchain anyway.

   sysroot_lib_subdir = "lib/rustlib/$rust_abi_target/lib"

   if (prebuilt_libstd_supported) {
     prebuilt_rustc_sysroot = "$root_out_dir/prebuilt_rustc_sysroot"
     copy("prebuilt_rustc_sysroot") {
       deps = [ ":find_stdlib" ]
       sources = get_target_outputs(":find_stdlib")
       outputs =
           [ "$prebuilt_rustc_sysroot/$sysroot_lib_subdir/{{source_file_part}}" ]
     }

     config("prebuilt_stdlib_for_rustc") {
       # Match the output directory of :prebuilt_rustc_sysroot
       sysroot = rebase_path(prebuilt_rustc_sysroot, root_build_dir)
       rustflags = [ "--sysroot=$sysroot" ]
     }

     # Use the sysroot generated by :prebuilt_rustc_sysroot. Almost all Rust targets should depend
     # on this.
     group("prebuilt_std_for_rustc") {
       assert(
           enable_rust,
           "Some C++ target is including Rust code even though enable_rust=false")
       all_dependent_configs = [ ":prebuilt_stdlib_for_rustc" ]
       deps = [ ":prebuilt_rustc_sysroot" ]
     }

     config("prebuilt_rust_stdlib_config") {
       ldflags = []
       lib_dir = rebase_path("$prebuilt_rustc_sysroot/$sysroot_lib_subdir",
                             root_build_dir)

       # We're unable to make these files regular gn dependencies because
       # they're prebuilt. Instead, we'll pass them in the ldflags. This doesn't
       # work for all types of build because ldflags propagate differently from
       # actual dependencies and therefore can end up in different targets from
       # the remap_alloc.cc above. For example, in a component build, we might
       # apply the remap_alloc.cc file and these ldlags to shared object A,
       # while shared object B (that depends upon A) might get only the ldflags
       # but not remap_alloc.cc, and thus the build will fail. There is
       # currently no known solution to this for the prebuilt stdlib - this
       # problem does not apply with configurations where we build the stdlib
       # ourselves, which is what we'll use in production.
       foreach(lib, stdlib_files) {
         this_file = "$lib_dir/lib$lib.rlib"
         ldflags += [ this_file ]
       }
       if (is_win) {
         # TODO(crbug.com/1434092): This should really be `libs`, however that
         # breaks. Normally, we specify lib files with the `.lib` suffix but
         # then when rustc links an EXE, it invokes lld-link with `.lib.lib`
         # instead.
         #
         # Omitting the `.lib` suffix breaks linking as well, when clang drives
         # the linking step of a C++ EXE that depends on Rust.
         ldflags += _windows_lib_deps
       }
     }

     # Provides std libs to non-rustc linkers.
     group("link_prebuilt_std") {
       assert(
           enable_rust,
           "Some C++ target is including Rust code even though enable_rust=false")
       all_dependent_configs = [ ":prebuilt_rust_stdlib_config" ]
       deps = [
         ":prebuilt_rustc_sysroot",
         ":remap_alloc",
       ]
     }
   }

   if (local_libstd_supported) {
     local_rustc_sysroot = "$root_out_dir/local_rustc_sysroot"

     # All std targets starting with core build with our sysroot. It starts empty
     # and is incrementally built. The directory must exist at the start.
     generated_file("empty_sysroot_for_std_build") {
       outputs = [ "$local_rustc_sysroot/$sysroot_lib_subdir/.empty" ]
       contents = ""
     }

     config("local_stdlib_for_rustc") {
       sysroot = rebase_path(local_rustc_sysroot, root_build_dir)
       rustflags = [ "--sysroot=$sysroot" ]
     }

     # Target to be depended on by std build targets. Creates the initially empty
     # sysroot.
     group("std_build_deps") {
       deps = [ ":empty_sysroot_for_std_build" ]
       public_configs = [ ":local_stdlib_for_rustc" ]
     }

     # Use the sysroot generated by :local_rustc_sysroot, which transitively builds
     # std. Only for use in specific tests for now.
     group("local_std_for_rustc") {
       assert(
           enable_rust,
           "Some C++ target is including Rust code even though enable_rust=false")
       all_dependent_configs = [ ":local_stdlib_for_rustc" ]

       deps = []
       foreach(libname, stdlib_files + skip_stdlib_files) {
         deps += [ "rules:$libname" ]
       }
     }

     config("local_rust_stdlib_config") {
       if (is_win) {
         # TODO(crbug.com/1434092): This should really be `libs`, however that
         # breaks. Normally, we specify lib files with the `.lib` suffix but
         # then when rustc links an EXE, it invokes lld-link with `.lib.lib`
         # instead.
         #
         # Omitting the `.lib` suffix breaks linking as well, when clang drives
         # the linking step of a C++ EXE that depends on Rust.
         ldflags = _windows_lib_deps
       }
     }

     # TODO(crbug.com/1368806): rework this so when using locally-built std, we
     # don't link the prebuilt std as well.

     group("link_local_std") {
       assert(
           enable_rust,
           "Some C++ target is including Rust code even though enable_rust=false")
       all_dependent_configs = [ ":local_rust_stdlib_config" ]
       deps = [
         ":local_std_for_rustc",
         ":remap_alloc",
       ]
     }
   }
 }
	# Copyright 2021 The Chromium Authors
	# Use of this source code is governed by a BSD-style license that can be
	# found in the LICENSE file.

	# This file provides the ability for our C++ toolchain to successfully
	# link binaries containing arbitrary Rust code.
	#
	# By "arbitrary Rust code" I mean .rlib archives full of Rust code, which
	# is actually a static archive.
	#
	# Those static libraries don't link as-is into a final executable because
	# they're designed for downstream processing by further invocations of rustc
	# which link into a final binary. That final invocation of rustc knows how
	# to do two things:
	# * Find the Rust standard library.
	# * Remap some generic allocator symbols to the specific allocator symbols
	# in use.
	# This file takes care of equivalent tasks for our C++ toolchains.
	# C++ targets should depend upon either link_local_std or
	# link_prebuilt_std to ensure that Rust code can be linked into their
	# C++ executables.
	#
	# This is obviously a bit fragile - rustc might do other magic in future.
	# But, linking with a final C++ toolchain is something often needed, and
	# https://github.com/rust-lang/rust/issues/64191 aims to make this
	# officially possible.

	import("//build/config/compiler/compiler.gni")
	import("//build/config/rust.gni")

	if (toolchain_has_rust) {
	# Equivalent of allocator symbols injected by rustc.
	source_set("remap_alloc") {
	sources = [
	"immediate_crash.h",
	"remap_alloc.cc",
	]
	}

	# List of Rust stdlib rlibs which are present in the official Rust toolchain
	# we are using from the Android team. This is usually a version or two behind
	# nightly. Generally this matches the toolchain we build ourselves, but if
	# they differ, append or remove libraries based on the
	# `use_chromium_rust_toolchain` GN variable.
	#
	# If the build fails due to missing symbols, it would be because of a missing
	# library that needs to be added here in a newer stdlib.
	stdlib_files = [
	"std", # List first because it makes depfiles more debuggable (see below)
	"addr2line",
	"adler",
	"alloc",
	"cfg_if",
	"compiler_builtins",
	"core",
	"getopts",
	"gimli",
	"hashbrown",
	"libc",
	"memchr",
	"miniz_oxide",
	"object",
	"panic_abort",
	"panic_unwind",
	"rustc_demangle",
	"std_detect",
	"test",
	"unicode_width",
	"unwind",
	]

	if (is_win) {
	# Our C++ builds already link against a wide variety of Windows API import libraries,
	# but the Rust stdlib requires a few extra.
	_windows_lib_deps = [
	"bcrypt.lib",
	"ntdll.lib",
	"userenv.lib",
	]
	}

	# rlibs explicitly ignored when copying prebuilt sysroot libraries.
	# find_std_rlibs.py rightfully errors out if an unexpected prebuilt lib is
	# encountered, since it usually indicates we missed something. This ignore
	# list is also passed to it. This has no effect on the local std build.
	ignore_stdlib_files = []

	# proc_macro is special: we only run proc macros on the host, so we only want
	# it for our host toolchain.
	if (current_toolchain == host_toolchain_no_sanitizers) {
	# Directs the local_std_for_rustc target to depend on proc_macro, and
	# includes proc_macro in the prebuilts copied in find_stdlib. Otherwise it
	# is not built or copied.
	stdlib_files += [ "proc_macro" ]
	} else {
	# Explicitly ignore it from the prebuilts. Nothing needs to be done for the
	# local std build.
	ignore_stdlib_files += [ "proc_macro" ]
	}

	# Different Rust toolchains may add or remove files relative to the above
	# list. That can be specified in gn args for anyone using (for instance)
	# nightly or some other experimental toolchain, prior to it becoming official.
	stdlib_files -= removed_rust_stdlib_libs
	stdlib_files += added_rust_stdlib_libs

	# rlib files which are distributed alongside Rust's prebuilt stdlib, but we
	# don't need to pass to the C++ linker because they're used for specialized
	# purposes.
	skip_stdlib_files = [
	"profiler_builtins",
	"rustc_std_workspace_alloc",
	"rustc_std_workspace_core",
	"rustc_std_workspace_std",
	]
	if (prebuilt_libstd_supported) {
	action("find_stdlib") {
	# Collect prebuilt Rust libraries from toolchain package and copy to a known
	# location.
	#
	# The Rust toolchain contains prebuilt rlibs for the standard library and
	# its dependencies. However, they have unstable names: an unpredictable
	# metadata hash is appended to the known crate name.
	#
	# We must depend on these rlibs explicitly when rustc is not in charge of
	# linking. However, it is difficult to construct GN rules to do so when the
	# names can't be known statically.
	#
	# This action copies the prebuilt rlibs to a known location, removing the
	# metadata part of the name. In the process it verifies we have all the
	# libraries we expect and none that we don't. A depfile is generated so this
	# step is re-run when any libraries change. The action script additionally
	# verifies rustc matches the expected version, which is unrelated but this
	# is a convenient place to do so.
	#
	# The action refers to `stdlib_files`, `skip_stdlib_files`, and the
	# associated //build/config/rust.gni vars `removed_rust_stdlib_libs` and
	# `added_rust_stdlib_libs` for which rlib files to expect.
	# `extra_sysroot_libs` is also used to copy non-std libs, if any.
	script = "find_std_rlibs.py"
	depfile = "$target_out_dir/stdlib.d"
	out_libdir = rebase_path(target_out_dir, root_build_dir)
	out_depfile = rebase_path(depfile, root_build_dir)

	# For the rustc sysroot we must include even the rlibs we don't pass to the
	# C++ linker.
	all_stdlibs_to_copy = stdlib_files + skip_stdlib_files
	args = [
	"--rust-bin-dir",
	rebase_path("${rust_sysroot}/bin", root_build_dir),
	"--output",
	out_libdir,
	"--depfile",
	out_depfile,

	# Due to limitations in Ninja's handling of .d files, we have to pick
	# the first of our outputs. To make diagnostics more obviously
	# related to the Rust standard library, we ensure libstd.rlib is first.
	"--depfile-target",
	stdlib_files[0],

	# Create a dependency on the rustc version so this action is re-run when
	# it changes. This argument is not actually read by the script.
	"--rustc-revision",
	rustc_revision,
	]

	if (!use_unverified_rust_toolchain) {
	args += [
	"--stdlibs",
	string_join(",", all_stdlibs_to_copy),
	]

	if (ignore_stdlib_files != []) {
	args += [
	"--ignore-stdlibs",
	string_join(",", ignore_stdlib_files),
	]
	}
	}

	if (extra_sysroot_libs != []) {
	args += [
	"--extra-libs",
	string_join(",", extra_sysroot_libs),
	]
	}

	args += [
	"--target",
	rust_abi_target,
	]

	outputs = []
	foreach(lib, all_stdlibs_to_copy) {
	outputs += [ "$target_out_dir/lib$lib.rlib" ]
	}
	foreach(lib, extra_sysroot_libs) {
	outputs += [ "$target_out_dir/$lib" ]
	}
	}
	} else {
	not_needed([ "ignore_stdlib_files" ])
	}

	# Construct sysroots for rustc invocations to better control what libraries
	# are linked. We have two: one with copied prebuilt libraries, and one with
	# our locally-built std. Both reside in root_out_dir: we must only have one of
	# each per GN toolchain anyway.

	sysroot_lib_subdir = "lib/rustlib/$rust_abi_target/lib"

	if (prebuilt_libstd_supported) {
	prebuilt_rustc_sysroot = "$root_out_dir/prebuilt_rustc_sysroot"
	copy("prebuilt_rustc_sysroot") {
	deps = [ ":find_stdlib" ]
	sources = get_target_outputs(":find_stdlib")
	outputs =
	[ "$prebuilt_rustc_sysroot/$sysroot_lib_subdir/{{source_file_part}}" ]
	}

	config("prebuilt_stdlib_for_rustc") {
	# Match the output directory of :prebuilt_rustc_sysroot
	sysroot = rebase_path(prebuilt_rustc_sysroot, root_build_dir)
	rustflags = [ "--sysroot=$sysroot" ]
	}

	# Use the sysroot generated by :prebuilt_rustc_sysroot. Almost all Rust targets should depend
	# on this.
	group("prebuilt_std_for_rustc") {
	assert(
	enable_rust,
	"Some C++ target is including Rust code even though enable_rust=false")
	all_dependent_configs = [ ":prebuilt_stdlib_for_rustc" ]
	deps = [ ":prebuilt_rustc_sysroot" ]
	}

	config("prebuilt_rust_stdlib_config") {
	ldflags = []
	lib_dir = rebase_path("$prebuilt_rustc_sysroot/$sysroot_lib_subdir",
	root_build_dir)

	# We're unable to make these files regular gn dependencies because
	# they're prebuilt. Instead, we'll pass them in the ldflags. This doesn't
	# work for all types of build because ldflags propagate differently from
	# actual dependencies and therefore can end up in different targets from
	# the remap_alloc.cc above. For example, in a component build, we might
	# apply the remap_alloc.cc file and these ldlags to shared object A,
	# while shared object B (that depends upon A) might get only the ldflags
	# but not remap_alloc.cc, and thus the build will fail. There is
	# currently no known solution to this for the prebuilt stdlib - this
	# problem does not apply with configurations where we build the stdlib
	# ourselves, which is what we'll use in production.
	foreach(lib, stdlib_files) {
	this_file = "$lib_dir/lib$lib.rlib"
	ldflags += [ this_file ]
	}
	if (is_win) {
	# TODO(crbug.com/1434092): This should really be `libs`, however that
	# breaks. Normally, we specify lib files with the `.lib` suffix but
	# then when rustc links an EXE, it invokes lld-link with `.lib.lib`
	# instead.
	#
	# Omitting the `.lib` suffix breaks linking as well, when clang drives
	# the linking step of a C++ EXE that depends on Rust.
	ldflags += _windows_lib_deps
	}
	}

	# Provides std libs to non-rustc linkers.
	group("link_prebuilt_std") {
	assert(
	enable_rust,
	"Some C++ target is including Rust code even though enable_rust=false")
	all_dependent_configs = [ ":prebuilt_rust_stdlib_config" ]
	deps = [
	":prebuilt_rustc_sysroot",
	":remap_alloc",
	]
	}
	}

	if (local_libstd_supported) {
	local_rustc_sysroot = "$root_out_dir/local_rustc_sysroot"

	# All std targets starting with core build with our sysroot. It starts empty
	# and is incrementally built. The directory must exist at the start.
	generated_file("empty_sysroot_for_std_build") {
	outputs = [ "$local_rustc_sysroot/$sysroot_lib_subdir/.empty" ]
	contents = ""
	}

	config("local_stdlib_for_rustc") {
	sysroot = rebase_path(local_rustc_sysroot, root_build_dir)
	rustflags = [ "--sysroot=$sysroot" ]
	}

	# Target to be depended on by std build targets. Creates the initially empty
	# sysroot.
	group("std_build_deps") {
	deps = [ ":empty_sysroot_for_std_build" ]
	public_configs = [ ":local_stdlib_for_rustc" ]
	}

	# Use the sysroot generated by :local_rustc_sysroot, which transitively builds
	# std. Only for use in specific tests for now.
	group("local_std_for_rustc") {
	assert(
	enable_rust,
	"Some C++ target is including Rust code even though enable_rust=false")
	all_dependent_configs = [ ":local_stdlib_for_rustc" ]

	deps = []
	foreach(libname, stdlib_files + skip_stdlib_files) {
	deps += [ "rules:$libname" ]
	}
	}

	config("local_rust_stdlib_config") {
	if (is_win) {
	# TODO(crbug.com/1434092): This should really be `libs`, however that
	# breaks. Normally, we specify lib files with the `.lib` suffix but
	# then when rustc links an EXE, it invokes lld-link with `.lib.lib`
	# instead.
	#
	# Omitting the `.lib` suffix breaks linking as well, when clang drives
	# the linking step of a C++ EXE that depends on Rust.
	ldflags = _windows_lib_deps
	}
	}

	# TODO(crbug.com/1368806): rework this so when using locally-built std, we
	# don't link the prebuilt std as well.

	group("link_local_std") {
	assert(
	enable_rust,
	"Some C++ target is including Rust code even though enable_rust=false")
	all_dependent_configs = [ ":local_rust_stdlib_config" ]
	deps = [
	":local_std_for_rustc",
	":remap_alloc",
	]
	}
	}
	}