{ lib, stdenv, removeReferencesTo, pkgsBuildBuild, pkgsBuildHost, pkgsBuildTarget, targetPackages, llvmShared, llvmSharedForBuild, llvmSharedForHost, llvmSharedForTarget, llvmPackages, runCommandLocal, fetchurl, file, python3, cargo, cmake, rustc, rustfmt, pkg-config, openssl, xz, zlib, bintools, which, libffi, withBundledLLVM ? false, enableRustcDev ? true, version, sha256, patches ? [ ], fd, ripgrep, wezterm, firefox, thunderbird, # This only builds std for target and reuses the rustc from build. fastCross, lndir, makeWrapper, }: let inherit (lib) optionals optional optionalString concatStringsSep ; useLLVM = stdenv.targetPlatform.useLLVM or false; in stdenv.mkDerivation (finalAttrs: { pname = "${targetPackages.stdenv.cc.targetPrefix}rustc"; inherit version; src = fetchurl { url = "https://static.rust-lang.org/dist/rustc-${version}-src.tar.gz"; inherit sha256; # See https://nixos.org/manual/nixpkgs/stable/#using-git-bisect-on-the-rust-compiler passthru.isReleaseTarball = true; }; hardeningDisable = optionals stdenv.cc.isClang [ # remove once https://github.com/NixOS/nixpkgs/issues/318674 is # addressed properly "zerocallusedregs" ]; __darwinAllowLocalNetworking = true; # rustc complains about modified source files otherwise dontUpdateAutotoolsGnuConfigScripts = true; # Running the default `strip -S` command on Darwin corrupts the # .rlib files in "lib/". # # See https://github.com/NixOS/nixpkgs/pull/34227 # # Running `strip -S` when cross compiling can harm the cross rlibs. # See: https://github.com/NixOS/nixpkgs/pull/56540#issuecomment-471624656 stripDebugList = [ "bin" ]; NIX_LDFLAGS = toString ( # when linking stage1 libstd: cc: undefined reference to `__cxa_begin_catch' # This doesn't apply to cross-building for FreeBSD because the host # uses libstdc++, but the target (used for building std) uses libc++ optional ( stdenv.hostPlatform.isLinux && !withBundledLLVM && !stdenv.targetPlatform.isFreeBSD && !useLLVM ) "--push-state --as-needed -lstdc++ --pop-state" ++ optional (stdenv.hostPlatform.isLinux && !withBundledLLVM && !stdenv.targetPlatform.isFreeBSD && useLLVM) "--push-state --as-needed -L${llvmPackages.libcxx}/lib -lc++ -lc++abi -lLLVM-${lib.versions.major llvmPackages.llvm.version} --pop-state" ++ optional (stdenv.hostPlatform.isDarwin && !withBundledLLVM) "-lc++ -lc++abi" ++ optional stdenv.hostPlatform.isDarwin "-rpath ${llvmSharedForHost.lib}/lib" ); RUSTFLAGS = lib.concatStringsSep " " ( [ # Increase codegen units to introduce parallelism within the compiler. "-Ccodegen-units=10" ] ++ lib.optionals (stdenv.hostPlatform.rust.rustcTargetSpec == "x86_64-unknown-linux-gnu") [ # Upstream defaults to lld on x86_64-unknown-linux-gnu, we want to use our linker "-Clinker-features=-lld" "-Clink-self-contained=-linker" ] ); RUSTDOCFLAGS = "-A rustdoc::broken-intra-doc-links"; # We need rust to build rust. If we don't provide it, configure will try to download it. # Reference: https://github.com/rust-lang/rust/blob/master/src/bootstrap/configure.py configureFlags = let prefixForStdenv = stdenv: "${stdenv.cc}/bin/${stdenv.cc.targetPrefix}"; ccPrefixForStdenv = stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang" else "cc"}"; cxxPrefixForStdenv = stdenv: "${prefixForStdenv stdenv}${if (stdenv.cc.isClang or false) then "clang++" else "c++"}"; setBuild = "--set=target.\"${stdenv.buildPlatform.rust.rustcTargetSpec}\""; setHost = "--set=target.\"${stdenv.hostPlatform.rust.rustcTargetSpec}\""; setTarget = "--set=target.\"${stdenv.targetPlatform.rust.rustcTargetSpec}\""; ccForBuild = ccPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv; cxxForBuild = cxxPrefixForStdenv pkgsBuildBuild.targetPackages.stdenv; ccForHost = ccPrefixForStdenv pkgsBuildHost.targetPackages.stdenv; cxxForHost = cxxPrefixForStdenv pkgsBuildHost.targetPackages.stdenv; ccForTarget = ccPrefixForStdenv pkgsBuildTarget.targetPackages.stdenv; cxxForTarget = cxxPrefixForStdenv pkgsBuildTarget.targetPackages.stdenv; in [ "--sysconfdir=${placeholder "out"}/etc" "--release-channel=stable" "--set=build.rustc=${rustc}/bin/rustc" "--set=build.cargo=${cargo}/bin/cargo" ] ++ lib.optionals (!(finalAttrs.src.passthru.isReleaseTarball or false)) [ # release tarballs vendor the rustfmt source; when # git-bisect'ing from upstream's git repo we must prevent # attempts to download the missing source tarball "--set=build.rustfmt=${rustfmt}/bin/rustfmt" ] ++ [ "--tools=rustc,rustdoc,rust-analyzer-proc-macro-srv" "--enable-rpath" "--enable-vendor" # For Nixpkgs it makes more sense to use stdenv's linker than # letting rustc build its own. "--disable-lld" "--build=${stdenv.buildPlatform.rust.rustcTargetSpec}" "--host=${stdenv.hostPlatform.rust.rustcTargetSpec}" # std is built for all platforms in --target. "--target=${ concatStringsSep "," ( # Other targets that don't need any extra dependencies to build. optionals (!fastCross) [ "wasm32-unknown-unknown" "wasm32v1-none" "bpfel-unknown-none" "bpfeb-unknown-none" ] # (build!=target): When cross-building a compiler we need to add # the build platform as well so rustc can compile build.rs # scripts. ++ optionals (stdenv.buildPlatform != stdenv.targetPlatform && !fastCross) [ stdenv.buildPlatform.rust.rustcTargetSpec ] # (host!=target): When building a cross-targeting compiler we # need to add the host platform as well so rustc can compile # build.rs scripts. ++ optionals (stdenv.hostPlatform != stdenv.targetPlatform && !fastCross) [ stdenv.hostPlatform.rust.rustcTargetSpec ] ++ [ # `make install` only keeps the docs of the last target in the list. # If the `targetPlatform` is not the last entry, we may end up without # `alloc` or `std` docs (if the last target is `no_std`). # More information: https://github.com/rust-lang/rust/issues/140922 stdenv.targetPlatform.rust.rustcTargetSpec ] ) }" "${setBuild}.cc=${ccForBuild}" "${setHost}.cc=${ccForHost}" "${setTarget}.cc=${ccForTarget}" # The Rust compiler build identifies platforms by Rust target # name, and later arguments override previous arguments. This # means that when platforms differ in configuration but overlap # in Rust target name (for instance, `pkgsStatic`), only one # setting will be applied for any given option. # # This is usually mostly harmless, especially as `fastCross` # means that we usually only compile `std` in such cases. # However, the build does still need to link helper tools for the # build platform in that case. This was breaking the Darwin # `pkgsStatic` build, as it was attempting to link build tools # with the target platform’s static linker, and failing to locate # an appropriate static library for `-liconv`. # # Since the static build does not link anything for the target # platform anyway, we put the target linker first so that the # build platform linker overrides it when the Rust target names # overlap, allowing the helper tools to build successfully. # # Note that Rust does not remember these settings in the built # compiler, so this does not compromise any functionality of the # resulting compiler. # # The longer‐term fix would be to get Rust to use a more nuanced # understanding of platforms, such as by explicitly constructing # and passing Rust JSON target definitions that let us # distinguish the platforms in cases like these. That would also # let us supplant various hacks around the wrappers and hooks # that we currently need. "${setTarget}.linker=${ccForTarget}" "${setBuild}.linker=${ccForBuild}" "${setHost}.linker=${ccForHost}" "${setBuild}.cxx=${cxxForBuild}" "${setHost}.cxx=${cxxForHost}" "${setTarget}.cxx=${cxxForTarget}" "${setBuild}.crt-static=${lib.boolToString stdenv.buildPlatform.isStatic}" "${setHost}.crt-static=${lib.boolToString stdenv.hostPlatform.isStatic}" "${setTarget}.crt-static=${lib.boolToString stdenv.targetPlatform.isStatic}" ] ++ optionals (!withBundledLLVM) [ "--enable-llvm-link-shared" "${setBuild}.llvm-config=${llvmSharedForBuild.dev}/bin/llvm-config" "${setHost}.llvm-config=${llvmSharedForHost.dev}/bin/llvm-config" "${setTarget}.llvm-config=${llvmSharedForTarget.dev}/bin/llvm-config" ] ++ optionals fastCross [ # Since fastCross only builds std, it doesn't make sense (and # doesn't work) to build a linker. "--disable-llvm-bitcode-linker" ] ++ optionals (stdenv.targetPlatform.isLinux && !(stdenv.targetPlatform.useLLVM or false)) [ "--enable-profiler" # build libprofiler_builtins ] ++ optionals stdenv.buildPlatform.isMusl [ "${setBuild}.musl-root=${pkgsBuildBuild.targetPackages.stdenv.cc.libc}" ] ++ optionals stdenv.hostPlatform.isMusl [ "${setHost}.musl-root=${pkgsBuildHost.targetPackages.stdenv.cc.libc}" ] ++ optionals stdenv.targetPlatform.isMusl [ "${setTarget}.musl-root=${pkgsBuildTarget.targetPackages.stdenv.cc.libc}" ] ++ optionals stdenv.targetPlatform.rust.isNoStdTarget [ "--disable-docs" ] ++ optionals (stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isx86_64) [ # https://github.com/rust-lang/rust/issues/92173 "--set rust.jemalloc" ] ++ optionals (useLLVM && !stdenv.targetPlatform.isFreeBSD) [ # https://github.com/NixOS/nixpkgs/issues/311930 "--llvm-libunwind=${if withBundledLLVM then "in-tree" else "system"}" "--enable-use-libcxx" ] ++ optionals (!stdenv.hostPlatform.isx86_32) [ # This enables frame pointers for the compiler itself. # # Note that when compiling std, frame pointers (or at least non-leaf # frame pointers, depending on version) are unconditionally enabled and # cannot be overridden, so we do not touch that. (Also note this only # applies to functions that can be immediately compiled when building # std. Generic functions that do codegen when called in user code obey # -Cforce-frame-pointers specified then, if any) "--set rust.frame-pointers" ]; # if we already have a rust compiler for build just compile the target std # library and reuse compiler buildPhase = if fastCross then '' runHook preBuild mkdir -p build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-{std,rustc}/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/ ln -s ${rustc.unwrapped}/lib/rustlib/${stdenv.hostPlatform.rust.rustcTargetSpec}/libstd-*.so build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-std/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/libstd.so ln -s ${rustc.unwrapped}/lib/rustlib/${stdenv.hostPlatform.rust.rustcTargetSpec}/librustc_driver-*.so build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-rustc/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/librustc.so ln -s ${rustc.unwrapped}/bin/rustc build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-rustc/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/rustc-main touch build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-std/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/.libstd-stamp touch build/${stdenv.hostPlatform.rust.rustcTargetSpec}/stage0-rustc/${stdenv.hostPlatform.rust.rustcTargetSpec}/release/.librustc-stamp python ./x.py --keep-stage=0 --stage=1 build library runHook postBuild '' else null; installPhase = if fastCross then '' runHook preInstall python ./x.py --keep-stage=0 --stage=1 install library/std mkdir -v $doc $man ln -s ${rustc.unwrapped}/{bin,libexec} $out rm -rf -v $out/lib/rustlib/{manifest-rust-std-,}${stdenv.hostPlatform.rust.rustcTargetSpec} ln -s ${rustc.unwrapped}/lib/rustlib/{manifest-rust-std-,}${stdenv.hostPlatform.rust.rustcTargetSpec} $out/lib/rustlib/ ln -s ${rustc.unwrapped}/lib/rustlib/etc $out/lib/rustlib/ echo rust-std-${stdenv.hostPlatform.rust.rustcTargetSpec} >> $out/lib/rustlib/components lndir ${rustc.doc} $doc lndir ${rustc.man} $man runHook postInstall '' else null; # the rust build system complains that nix alters the checksums dontFixLibtool = true; inherit patches; postPatch = '' patchShebangs src/etc # rust-lld is the name rustup uses for its bundled lld, so that it # doesn't conflict with any system lld. This is not an # appropriate default for Nixpkgs, where there is no rust-lld. substituteInPlace compiler/rustc_target/src/spec/*/*.rs \ --replace-quiet '"rust-lld"' '"lld"' ${optionalString (!withBundledLLVM) "rm -rf src/llvm"} # Useful debugging parameter # export VERBOSE=1 '' + lib.optionalString (stdenv.hostPlatform.isDarwin || stdenv.targetPlatform.isDarwin) '' # Replace hardcoded path to strip with llvm-strip # https://github.com/NixOS/nixpkgs/issues/299606 substituteInPlace compiler/rustc_codegen_ssa/src/back/link.rs \ --replace-fail "/usr/bin/strip" "${lib.getExe' llvmShared "llvm-strip"}" '' + lib.optionalString (stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isx86_64) '' # See https://github.com/jemalloc/jemalloc/issues/1997 # Using a value of 48 should work on both emulated and native x86_64-darwin. export JEMALLOC_SYS_WITH_LG_VADDR=48 '' + lib.optionalString (!(finalAttrs.src.passthru.isReleaseTarball or false)) '' mkdir .cargo cat > .cargo/config.toml <<\EOF [source.crates-io] replace-with = "vendored-sources" [source.vendored-sources] directory = "vendor" EOF '' + lib.optionalString (stdenv.hostPlatform.isFreeBSD) '' # lzma-sys bundles an old version of xz that doesn't build # on modern FreeBSD, use the system one instead substituteInPlace src/bootstrap/src/core/build_steps/tool.rs \ --replace 'cargo.env("LZMA_API_STATIC", "1");' ' ' ''; # rustc unfortunately needs cmake to compile llvm-rt but doesn't # use it for the normal build. This disables cmake in Nix. dontUseCmakeConfigure = true; depsBuildBuild = [ pkgsBuildHost.stdenv.cc pkg-config ]; depsBuildTarget = lib.optionals stdenv.targetPlatform.isMinGW [ bintools ]; nativeBuildInputs = [ file python3 rustc cmake which libffi removeReferencesTo pkg-config xz ] ++ optionals fastCross [ lndir makeWrapper ]; buildInputs = [ openssl ] ++ optionals stdenv.hostPlatform.isDarwin [ zlib ] ++ optional (!withBundledLLVM) llvmShared.lib ++ optional (useLLVM && !withBundledLLVM) llvmPackages.libunwind; outputs = [ "out" "man" "doc" ]; setOutputFlags = false; postInstall = lib.optionalString (enableRustcDev && !fastCross) '' # install rustc-dev components. Necessary to build rls, clippy... python x.py dist rustc-dev tar xf build/dist/rustc-dev*tar.gz cp -r rustc-dev*/rustc-dev*/lib/* $out/lib/ rm $out/lib/rustlib/install.log for m in $out/lib/rustlib/manifest-rust* do sort --output=$m < $m done '' + '' # remove references to llvm-config in lib/rustlib/x86_64-unknown-linux-gnu/codegen-backends/librustc_codegen_llvm-llvm.so # and thus a transitive dependency on ncurses find $out/lib -name "*.so" -type f -exec remove-references-to -t ${llvmShared} '{}' '+' # remove uninstall script that doesn't really make sense for Nix. rm $out/lib/rustlib/uninstall.sh ''; configurePlatforms = [ ]; enableParallelBuilding = true; setupHooks = ./setup-hook.sh; requiredSystemFeatures = [ "big-parallel" ]; passthru = { llvm = llvmShared; inherit llvmPackages; inherit (rustc) targetPlatforms targetPlatformsWithHostTools badTargetPlatforms; tests = { inherit fd ripgrep wezterm; } // lib.optionalAttrs stdenv.hostPlatform.isLinux { inherit firefox thunderbird; }; }; meta = with lib; { homepage = "https://www.rust-lang.org/"; description = "Safe, concurrent, practical language"; teams = [ teams.rust ]; license = [ licenses.mit licenses.asl20 ]; platforms = rustc.targetPlatformsWithHostTools; # If rustc can't target a platform, we also can't build rustc for # that platform. badPlatforms = rustc.badTargetPlatforms; }; })