Building packages with llvmPackages.stdenv

[lovesegfault]

What is the right way to modify craneLib (e.g. craneLib = (inputs.crane.mkLib pkgs).overrideToolchain rustToolchain) so that subsequent calls to buildDepsOnly, buildPackage, devShell, etc. use a different stdenv such as llvmPackages.stdenv?

[lovesegfault]

I thought using overrideScope was the way to do it, but my build continues to fail due to CC being gcc and a crate requiring clang.

[eclairevoyant]

I don't know if this can be done at a "higher" level, but

crane/docs/API.md

Lines 1229 to 1232 in 1979a25

	* `stdenv`: a function to select the standard build environment to use for this
	derivation. For backwards compatibility a non-function value (i.e. `stdenv =
	pkgs.stdenv;`) will still be accepted.
	- Default value: `p: p.stdenv`

documents stdenv as an arg to mkCargoDerivation (note that it's a function!), and buildDepsOnly/buildPackage simply pass their args down to mkCargoDerivation:

crane/lib/buildPackage.nix

Lines 38 to 39 in 1979a25

	mkCargoDerivation (
	cleanedArgs

crane/lib/buildDepsOnly.nix

Lines 52 to 53 in 1979a25

	mkCargoDerivation (
	cleanedArgs

For devShell you will have to do a bit more work (replace line 975 accordingly). It's not a function in this case as it's just overriding the mkShell from nixpkgs.

crane/docs/API.md

Lines 971 to 983 in 1979a25

	let
	moldDevShell = craneLib.devShell.override {
	# For example, use the mold linker
	mkShell = pkgs.mkShell.override {
	stdenv = pkgs.stdenvAdapters.useMoldLinker pkgs.stdenv;
	};
	};
	in
	moldDevShell {
	packages = [
	# etc...
	];
	}

[RossSmyth]

The intended way is to do something like:

let 
  commonArgs = { 
    ...
    stdenv = p: p.clangStdenv;
    ....
  };
in
craneLib.buildPackage (commonArgs // {
  ...
})

You can also instance craneLib with pkgsLLVM:

cranelib = crane.mkLin pkgs.pkgsLLVM;

Then everything will be LLVM-based.

[eclairevoyant]

The first solution is basically what I mentioned :) but devShell does need separate handling.

The second solution works in this case, but is tough to use in the general case. How would you create a pkgs instance for say, llvmPackages_18.stdenv?

[lovesegfault]

Using pkgsLLVM is a great idea, but in practice it causes tons of rebuilds, and many builds are broken under it.

[lovesegfault]

I tried the stdenv = p: p.clangStdenv; approach with the MVCE below, and I couldn't get it to work. Even when I used p.pkgsLLVM.stdenv.

[lovesegfault]

Here's an MVCE that shows the issue when trying to use rocksdb's lto feature:

{
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    crane.url = "github:ipetkov/crane";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs =
    {
      self,
      nixpkgs,
      crane,
      flake-utils,
    }:
    flake-utils.lib.eachDefaultSystem (
      system:
      let
        pkgs = import nixpkgs { inherit system; };
        craneLib = crane.mkLib pkgs;

        cargoToml = pkgs.writeText "Cargo.toml" ''
          [package]
          name = "hello-world"
          version = "0.1.0"
          edition = "2024"

          [dependencies]
          rocksdb = { version = "0.24", default-features = false, features = [ "bindgen-runtime", "zstd", "lto" ] }
          tempfile = "3"
        '';

        cargoLock = pkgs.fetchurl {
          url = "https://gist.githubusercontent.com/lovesegfault/6acc6ece622ec63127bc100c76d51d2f/raw/cefaf30fb69c9f83c55313ead96590cf820d6184/Cargo.lock";
          hash = "sha256-Cn9brESnCOgOyt5EK2miJ/LgqAp7rII4d47m63j84fw=";
        };

        mainRs = pkgs.writeText "main.rs" ''
          fn main() -> Result<(), Box<dyn std::error::Error>> {
            let tempdir = tempfile::Builder::new().tempdir()?;
            let db = rocksdb::DB::open_default(tempdir.path())?;
            db.put(b"my key", b"my value")?;
            std::mem::drop(db);
            let _ = rocksdb::DB::destroy(&rocksdb::Options::default(), tempdir.path());
            Ok(())
          }
        '';

        src = pkgs.runCommand "rust-src" { } ''
          echo $out
          mkdir -p $out/src
          cp ${cargoToml} "$out/Cargo.toml"
          cp ${cargoLock} "$out/Cargo.lock"
          cp ${mainRs} "$out/src/main.rs"
        '';
      in
      {
        packages.default = craneLib.buildPackage {
          pname = "hello-world";
          version = "0.0.1";
          src = src;
          strictDeps = true;
          LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
        };
      }
    );
}

This is why I'm trying to use the LLVM stdenv, for context.

[RossSmyth]

Oh, I see. I would recommend reading the rocks-db documentation that talks about the LTO feature:
https://github.com/rust-rocksdb/rust-rocksdb/blob/d6171b7ac13df012c250cebca26294f4f76cd52e/README.md#lto

On the rust side you should use RUSTFLAGS="-Clinker-plugin-lto -Clinker=clang -Clink-arg=-fuse-ld=lld".

So I gave this patch a try and it built fine:

diff --git a/flake.nix b/flake.nix
index 1a56ee079a..d89ca29cc6 100644
--- a/flake.nix
+++ b/flake.nix
@@ -57,9 +57,18 @@
         packages.default = craneLib.buildPackage {
           pname = "hello-world";
           version = "0.0.1";
+
           src = src;
+
+          stdenv = p: p.llvmPackages.stdenv;
           strictDeps = true;
-          LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
+          nativeBuildInputs = [
+            pkgs.llvmPackages.lld            
+          ];
+          env = {
+            LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
+            RUSTFLAGS = "-Clinker-plugin-lto -Clinker=clang -Clink-arg=-fuse-ld=lld";
+          };
         };
       }
     );

[RossSmyth]

Also for posterity, using Nixpkg's zstd and propagating NIX_CFLAGS to bindgen:

diff --git a/flake.nix b/flake.nix
index 1a56ee079a..14937112c1 100644
--- a/flake.nix
+++ b/flake.nix
@@ -57,9 +57,25 @@
         packages.default = craneLib.buildPackage {
           pname = "hello-world";
           version = "0.0.1";
+
           src = src;
+
+          stdenv = p: p.llvmPackages.stdenv;
           strictDeps = true;
-          LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
+          nativeBuildInputs = [
+            pkgs.rustPlatform.bindgenHook
+            pkgs.llvmPackages.lld
+            pkgs.pkg-config
+          ];
+          buildInputs = [
+            pkgs.zstd
+          ];
+
+          env = {
+            RUSTFLAGS = "-Clinker-plugin-lto -Clinker=clang -Clink-arg=-fuse-ld=lld";
+            ZSTD_SYS_USE_PKG_CONFIG = true;
+            NIX_OUTPATH_USED_AS_RANDOM_SEED = "aaaaaaaaaa";
+          };
         };
       }
     );

[RossSmyth]

The issue was that when you use clang it makes objects that ld doesn't know how to use, so you need to use lld and also tell rustc to pass on lto flags to lld

[lovesegfault]

Aha! Thanks @RossSmyth!

[ipetkov]

Happy to include an example on building with clang if someone wants to contribute one! (We do have a "unit test" for building with clang, but I wouldn't expect anyone to stumble upon it!)