[Feature request] Easy way to switch to rust-lld for linking on Linux

[timothyg-stripe]

With the exception of wasm, rules_rust currently always uses the linker specified in the relevant cc_toolchain:

rules_rust/rust/private/rustc.bzl

Lines 1053 to 1063 in 6d532fd

	if toolchain.target_arch not in ("wasm32", "wasm64"):
	if output_dir:
	use_pic = _should_use_pic(cc_toolchain, feature_configuration, crate_info.type, compilation_mode)
	rpaths = _compute_rpaths(toolchain, output_dir, dep_info, use_pic)
	else:
	rpaths = depset()
	ld, link_args, link_env = get_linker_and_args(ctx, crate_info.type, cc_toolchain, feature_configuration, rpaths, add_flags_for_binary = add_flags_for_binary)
	env.update(link_env)
	rustc_flags.add(ld, format = "--codegen=linker=%s")

. However, it would be good to let users configure what linker to use for Rust:

• On Linux, rules_cc defaults to LLD, then gold, then the default ld (ld.bfd). If LLD is not installed globally, then it'll use gold, but gold is deprecated and not appropriate for Rust.
• On several platforms, Rust comes bundled with rust-lld. In fact, Rust 1.90.0 will make it so that it uses rust-lld by default on x86-64 Linux.
• LLD is much faster than both ld.bfd and gold.

It would be nice to be able to use rust-lld for linking, either through a gcc driver, or directly. (I.e., -Clinker-flavor=ld.lld/gnu-lld and gnu-lld-cc.)

---

As breadcrumbs, I was able to get the equivalent of linker-flavor=gnu-lld-cc working locally by applying:

• Add gcc-ld to rustc_lib target #3600

• A patch to expand $(RUST_SYSROOT) in extra_exec_rustc_flags

  diff -ur rules_rust/rust/private/rustc.bzl rules_rust-patched/rust/private/rustc.bzl
  --- rules_rust/rust/private/rustc.bzl 2025-09-09 01:16:47.480776299 +0000
  +++ rules_rust-patched/rust/private/rustc.bzl 2025-09-09 01:20:48.211779196 +0000
  @@ -1099,10 +1099,12 @@
       if crate_info.type in toolchain.extra_rustc_flags_for_crate_types.keys():
           rustc_flags.add_all(toolchain.extra_rustc_flags_for_crate_types[crate_info.type], map_each = map_flag)
  
  -    if is_exec_configuration(ctx):
  -        rustc_flags.add_all(toolchain.extra_exec_rustc_flags, map_each = map_flag)
  -    else:
  -        rustc_flags.add_all(toolchain.extra_rustc_flags, map_each = map_flag)
  +    for flag in (toolchain.extra_exec_rustc_flags if is_exec_configuration(ctx) else toolchain.extra_rustc_flags):
  +        if map_flag:
  +            flag = map_flag(flag)
  +        if flag != None:
  +            flag = flag.replace("$(RUST_SYSROOT)", toolchain.sysroot)
  +        rustc_flags.add(flag)
  
       # extra_rustc_flags apply to the target configuration, not the exec configuration.
       if hasattr(ctx.attr, "_extra_rustc_flags") and not is_exec_configuration(ctx):

• Finally, extra_rustc_flags to tell the GCC driver to use lld

  rust_register_toolchains(
      versions = ["1.89.0"],
      extra_rustc_flags = {
          "x86_64-unknown-linux-gnu": [
              "--codegen=link-arg=-B$(RUST_SYSROOT)/lib/rustlib/x86_64-unknown-linux-gnu/bin/gcc-ld",
              "--codegen=link-arg=-fuse-ld=lld",
          ],
      },
  )

  With rust_repository_set: Allow extra_exec_rustc_flags to be a dict #3601 applied, we would be able to also do the same with extra_exec_rustc_flags

[UebelAndre]

I would be in favor of in incompatibility flag that switched to use rust-lld by default!

The setting could live here:
https://github.com/bazelbuild/rules_rust/blob/6d532fd5e170ca5cfe2ab0acb83d67527bafc4e5/rust/settings/BUILD.bazel

The toolchain might need a new attr to find the file

rules_rust/rust/toolchain.bzl

Line 768 in 6d532fd

rust_toolchain = rule(

Which would probably get set here

rules_rust/rust/private/repository_utils.bzl

Lines 287 to 326 in 6d532fd

	def BUILD_for_rust_toolchain(
	name,
	exec_triple,
	target_triple,
	version,
	allocator_library,
	global_allocator_library,
	default_edition,
	include_rustfmt,
	include_llvm_tools,
	stdlib_linkflags = None,
	extra_rustc_flags = None,
	extra_exec_rustc_flags = None,
	opt_level = None,
	strip_level = None):
	"""Emits a toolchain declaration to match an existing compiler and stdlib.
	Args:
	name (str): The name of the toolchain declaration
	exec_triple (triple): The rust-style target that this compiler runs on
	target_triple (triple): The rust-style target triple of the tool
	version (str): The Rust version for the toolchain.
	allocator_library (str, optional): Target that provides allocator functions when rust_library targets are embedded in a cc_binary.
	global_allocator_library (str, optional): Target that provides allocator functions when a global allocator is used with cc_common_link.
	This target is only used in the target configuration; exec builds still use the symbols provided
	by the `allocator_library` target.
	default_edition (str): Default Rust edition.
	include_rustfmt (bool): Whether rustfmt is present in the toolchain.
	include_llvm_tools (bool): Whether llvm-tools are present in the toolchain.
	stdlib_linkflags (list, optional): Overridden flags needed for linking to rust
	stdlib, akin to BAZEL_LINKLIBS. Defaults to
	None.
	extra_rustc_flags (list, optional): Extra flags to pass to rustc in non-exec configuration.
	extra_exec_rustc_flags (list, optional): Extra flags to pass to rustc in exec configuration.
	opt_level (dict, optional): Optimization level config for this toolchain.
	strip_level (dict, optional): Strip level config for this toolchain.
	Returns:
	str: A rendered template of a `rust_toolchain` declaration
	"""

Then with the new setting and a label to rust-lld, you can update calls in rustc.bzl to add the new flag

rules_rust/rust/private/rustc.bzl

Lines 829 to 900 in 6d532fd

	def construct_arguments(
	*,
	ctx,
	attr,
	file,
	toolchain,
	tool_path,
	cc_toolchain,
	feature_configuration,
	crate_info,
	dep_info,
	linkstamp_outs,
	ambiguous_libs,
	output_hash,
	rust_flags,
	out_dir,
	build_env_files,
	build_flags_files,
	emit = ["dep-info", "link"],
	force_all_deps_direct = False,
	add_flags_for_binary = False,
	include_link_flags = True,
	stamp = False,
	remap_path_prefix = ".",
	use_json_output = False,
	build_metadata = False,
	force_depend_on_objects = False,
	skip_expanding_rustc_env = False,
	error_format = None):
	"""Builds an Args object containing common rustc flags
	Args:
	ctx (ctx): The rule's context object
	attr (struct): The attributes for the target. These may be different from ctx.attr in an aspect context.
	file (struct): A struct containing files defined in label type attributes marked as `allow_single_file`.
	toolchain (rust_toolchain): The current target's `rust_toolchain`
	tool_path (str): Path to rustc
	cc_toolchain (CcToolchain): The CcToolchain for the current target.
	feature_configuration (FeatureConfiguration): Class used to construct command lines from CROSSTOOL features.
	crate_info (CrateInfo): The CrateInfo provider of the target crate
	dep_info (DepInfo): The DepInfo provider of the target crate
	linkstamp_outs (list): Linkstamp outputs of native dependencies
	ambiguous_libs (dict): Ambiguous libs, see `_disambiguate_libs`
	output_hash (str): The hashed path of the crate root
	rust_flags (list): Additional flags to pass to rustc
	out_dir (str): The path to the output directory for the target Crate.
	build_env_files (list): Files containing rustc environment variables, for instance from `cargo_build_script` actions.
	build_flags_files (depset): The output files of a `cargo_build_script` actions containing rustc build flags
	emit (list): Values for the --emit flag to rustc.
	force_all_deps_direct (bool, optional): Whether to pass the transitive rlibs with --extern
	to the commandline as opposed to -L.
	add_flags_for_binary (bool, optional): Whether to add "bin" link flags to the command regardless of `emit` and `crate_type`.
	include_link_flags (bool, optional): Whether to include flags like `-l` that instruct the linker to search for a library.
	stamp (bool, optional): Whether or not workspace status stamping is enabled. For more details see
	https://docs.bazel.build/versions/main/user-manual.html#flag--stamp
	remap_path_prefix (str, optional): A value used to remap `${pwd}` to. If set to None, no prefix will be set.
	use_json_output (bool): Have rustc emit json and process_wrapper parse json messages to output rendered output.
	build_metadata (bool): Generate CLI arguments for building *only* .rmeta files. This requires use_json_output.
	force_depend_on_objects (bool): Force using `.rlib` object files instead of metadata (`.rmeta`) files even if they are available.
	skip_expanding_rustc_env (bool): Whether to skip expanding CrateInfo.rustc_env_attr
	error_format (str, optional): Error format to pass to the `--error-format` command line argument. If set to None, uses the "_error_format" entry in `attr`.
	Returns:
	tuple: A tuple of the following items
	- (struct): A struct of arguments used to run the `Rustc` action
	- process_wrapper_flags (Args): Arguments for the process wrapper
	- rustc_path (Args): Arguments for invoking rustc via the process wrapper
	- rustc_flags (Args): Rust flags for the Rust compiler
	- all (list): A list of all `Args` objects in the order listed above.
	This is to be passed to the `arguments` parameter of actions
	- (dict): Common rustc environment variables
	"""