WIP: cross compile gcc

tidepool/src/export.nix

@@ -33,7 +33,13 @@ in
         #   platform.host = lib.modules.overrides.force "x86_64-linux";
         # };
         cross-aux-a-x86_64-linux = config.packages.cross.x86_64-linux.aux.a;
-        cross-foundation-gcc-x86_64-linux = config.packages.cross.x86_64-linux.foundation.gcc;
+        cross-foundation-gcc-newlib-x86_64-linux = config.packages.cross-tools.x86_64-linux.foundation.gcc-newlib;
+
+        cross-foundation-binutils-x86_64-linux = config.packages.cross-tools.x86_64-linux.foundation.binutils;
+
+        cross-foundation-glibc-x86_64-linux = config.packages.cross.x86_64-linux.foundation.glibc;
+        cross-foundation-gcc-x86_64-linux = config.packages.cross-tools.x86_64-linux.foundation.gcc;
+
 
         example-a = config.packages.foundation.gcc.versions.latest.extend {
           platform = {

tidepool/src/packages/default.nix

@@ -4,7 +4,7 @@ let
 
   doubles = lib.systems.doubles.all;
 
-  packages = builtins.removeAttrs config.packages [ "cross" ];
+  packages = builtins.removeAttrs config.packages [ "cross" "cross-tools" ];
 in
 {
   includes = [
@@ -21,6 +21,14 @@ in
         freeform = lib.types.packages;
 
         options = {
+          cross-tools = lib.attrs.generate doubles (
+            system:
+            lib.options.create {
+              description = "The cross-compilation tools for the ${system} target.";
+              type = lib.types.packages;
+              default.value = { };
+            }
+          );
           cross = lib.attrs.generate doubles (
             system:
             lib.options.create {
@@ -54,6 +62,36 @@ in
   };
 
   config = {
+    packages.cross-tools = lib.attrs.generate doubles (
+      system:
+      builtins.mapAttrs
+        (
+          namespace:
+          builtins.mapAttrs (
+            name: alias:
+              let
+                setTarget =
+                  package:
+                  package
+                  // {
+                    __modules__ = package.__modules__ ++ [
+                      {
+                        config.platform = {
+                          target = lib.modules.override 5 system;
+                        };
+                      }
+                    ];
+                  };
+
+                updated = alias // {
+                  versions = builtins.mapAttrs (version: package: setTarget package) alias.versions;
+                };
+              in
+              updated
+          )
+        )
+        packages
+    );
     packages.cross = lib.attrs.generate doubles (
       system:
       builtins.mapAttrs
@@ -62,7 +100,7 @@ in
           builtins.mapAttrs (
             name: alias:
               let
-                setHost =
+                setPlatform =
                   package:
                   package
                   // {
@@ -77,7 +115,7 @@ in
                   };
 
                 updated = alias // {
-                  versions = builtins.mapAttrs (version: package: setHost package) alias.versions;
+                  versions = builtins.mapAttrs (version: package: setPlatform package) alias.versions;
                 };
               in
               updated

tidepool/src/packages/foundation/binutils/default.nix

@@ -33,10 +33,11 @@ in
               isHostBootstrapped = config.platform.host.double == "i686-linux";
 
               isBootstrapped = isBuildBootstrapped && isHostBootstrapped;
+
             in
             {
               meta = {
-                platforms = [ "i686-linux" ];
+                platforms = [ "i686-linux" "x86_64-linux" ];
               };
 
               pname = "binutils";
@@ -48,13 +49,19 @@ in
                 build = {
                   only = {
 										gcc = lib.modules.when (!isBootstrapped) packages.foundation.gcc;
+										# gcc = lib.modules.when (isCross) (packages.foundation.gcc.versions.latest.extend {
+                    #     platform = lib.modules.override 0 {
+                    #       inherit (config.platform) host target;
+                    #       build = config.platform.target;
+                    #     };
+                    # });
                   };
                 };
               };
 
               env = {
                 PATH = lib.paths.bin (
-									lib.lists.when isBootstrapped
+									lib.lists.when (isBootstrapped)
 									[ foundation.stage2-gcc ]
 									++ [
 										foundation.stage2-gcc
@@ -116,6 +123,9 @@ in
                   '';
 
                   configure = ''
+                    echo "BUILD: ${config.platform.build.triple}"
+                    echo "HOST: ${config.platform.host.triple}"
+                    echo "TARGET: ${config.platform.target.triple}"
                     bash ./configure ${builtins.concatStringsSep " " configureFlags}
                   '';
 

tidepool/src/packages/foundation/gcc/default.nix

@@ -11,6 +11,10 @@ let
     ;
 in
 {
+  includes = [
+    ./newlib.nix
+  ];
+
   config.packages.context.options = {
     "foundation:cflags" = lib.options.create {
       type = lib.types.list.of lib.types.string;
@@ -101,66 +105,38 @@ in
 
               builder = builders.basic;
 
-              # hooks = ctx: let
+              deps = {
-              #
-              # in {
-              # 	"aux:gcc:env" = lib.dag.entry.before [ "unpack" ] ''
-              #
-              # 	'';
-              # };
-
-              deps =
-                let
-                  platform =
-                    if !isBuildBootstrapped then
-                      {
-                        build = "i686-linux";
-                        host = lib.modules.override 0 config.platform.build.triple;
-                        target = lib.modules.override 0 config.platform.build.triple;
-                      }
-                    else
-                      {
-                        build = "i686-linux";
-                        host = "i686-linux";
-                        target = lib.modules.override 0 config.platform.host.triple;
-                      };
-                in
-                {
                   build = {
-                    only = {
-                      gcc =
-                        lib.modules.when
-                          (!isBootstrapped)
-                          (packages.foundation.gcc.versions.latest.extend {
-                            inherit platform;
-                          });
-                    };
                     build = {
-                      binutils = packages.foundation.binutils;
+                      binutils = (packages.foundation.binutils.versions.latest.extend {
-											linux-headers = packages.foundation.linux-headers;
+                        platform = lib.modules.override 0 config.platform;
-											glibc = packages.foundation.glibc;
+                      });
+                      glibc = (packages.foundation.glibc.versions.latest.extend {
+                        platform = lib.modules.override 0 {
+                          inherit (config.platform) build target;
+                          host = config.platform.target;
+                        };
+                      });
+                      linux-headers = (packages.foundation.linux-headers.versions.latest.extend {
+                        platform.target = lib.modules.override 0 config.platform.target;
+                      });
                     };
                   };
                 };
 
-							hooks = ctx: {
-								"aux:compiler:setup" = lib.dag.entry.before [ "unpack" ] ''
-									: ''${AUX_COMPILER_LIBRARY_PATH:=}
-								'';
-							};
-
               env = {
                 PATH = lib.paths.bin (
                   lib.lists.when
                     (isBootstrapped)
                     [
                       foundation.stage2-gcc
-                      # foundation.stage2-binutils
+                      foundation.stage2-binutils
                     ]
                   ++ [
                     foundation.stage2-gnumake
                     foundation.stage2-gnused
                     foundation.stage2-gnugrep
+										foundation.stage2-gnupatch
                     foundation.stage2-gawk
                     foundation.stage2-diffutils
                     foundation.stage2-findutils
@@ -172,74 +148,78 @@ in
                 );
               };
 
-              phases =
+              phases = let
-                let
+                  patches = [
-                  host = lib.systems.withBuildInfo config.platform.host;
+                    # Make binutils output deterministic by default.
+                    ./patches/libstdc++-target.patch
+                  ];
+              in {
+                unpack = ''
+                  # Unpack
+                  tar xf ${config.src}
+                  tar xf ${config.gmp.src}
+                  tar xf ${config.mpfr.src}
+                  tar xf ${config.mpc.src}
+                  tar xf ${config.isl.src}
+                  cd gcc-${config.version}
 
-									compiler = if isBootstrapped then "gcc" else "${config.platform.build.triple}-gcc";
+                  ln -s ../gmp-${config.gmp.version} gmp
+                  ln -s ../mpfr-${config.mpfr.version} mpfr
+                  ln -s ../mpc-${config.mpc.version} mpc
+                  ln -s ../isl-${config.isl.version} isl
+                '';
 
-                  mbits = if host.system.cpu.family == "x86" then if host.is64bit then "-m64" else "-m32" else "";
+                patch = ''
-                in
+                  ${lib.strings.concatMapSep "\n" (file: "patch -Np1 -i ${file}") patches}
-                {
+                '';
-									"aux:compiler:setup" = ''
-										: ''${AUX_COMPILER_LIBRARY_PATH:=}
-									'';
 
-                  unpack = ''
+                configure = ''
-                    # Unpack
+                  # Configure
-                    tar xf ${config.src}
+                  export CC="gcc -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
-                    tar xf ${config.gmp.src}
+                  export CXX="g++ -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
-                    tar xf ${config.mpfr.src}
+                  export CFLAGS_FOR_TARGET=""
-                    tar xf ${config.mpc.src}
+                  export LIBRARY_PATH="${foundation.stage1-musl}/lib"
-                    tar xf ${config.isl.src}
+                  export LDFLAGS_FOR_TARGET="-L${config.deps.build.build.glibc.package}/lib"
-                    cd gcc-${config.version}
+                  export LDFLAGS_FOR_TARGET="$LDFLAGS_FOR_TARGET -B${config.deps.build.build.glibc.package}/lib"
+                  export LDFLAGS_FOR_TARGET="$LDFLAGS_FOR_TARGET -I${config.deps.build.build.linux-headers.package}/lib"
 
-                    ln -s ../gmp-${config.gmp.version} gmp
+                  mkdir build
-                    ln -s ../mpfr-${config.mpfr.version} mpfr
+                  cd build
-                    ln -s ../mpc-${config.mpc.version} mpc
-                    ln -s ../isl-${config.isl.version} isl
-                  '';
 
-                  patch = ''
+                  # TODO(vlinkz) Hack to fix missing crti.o and crtn.o. Figure out how to properly find their paths.
-                    # Patch
+                  mkdir gcc
-                    # force musl even if host triple is gnu
+                  ln -sv ${config.deps.build.build.glibc.package}/lib/{crti.o,crtn.o} gcc
-                    sed -i 's|"os/gnu-linux"|"os/generic"|' libstdc++-v3/configure.host
+                  mkdir -p x86_64-unknown-linux-gnu/libstdc++-v3/src
-                  '';
+                  ln -sv ${config.deps.build.build.glibc.package}/lib/{crti.o,crtn.o} x86_64-unknown-linux-gnu/libstdc++-v3/src
 
-                  configure = ''
+                  bash ../configure \
-                    # Configure
+                    --prefix=$out \
-                    export CC="gcc -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
+                    --build=${config.platform.build.triple} \
-                    export CXX="g++ -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
+                    --host=${config.platform.host.triple} \
-                    export CFLAGS_FOR_TARGET="-Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
+                    --target=${config.platform.target.triple} \
-                    export LIBRARY_PATH="${foundation.stage1-musl}/lib"
+                    --with-as=${config.deps.build.build.binutils.package}/bin/${config.platform.target.triple}-as \
+                    --with-ld=${config.deps.build.build.binutils.package}/bin/${config.platform.target.triple}-ld \
+                    --enable-languages=c,c++ \
+                    --disable-bootstrap \
+                    --disable-libsanitizer \
+                    --disable-lto \
+                    --disable-multilib \
+                    --disable-plugin \
+                    --with-headers=${config.deps.build.build.glibc.package}/include \
+                    --with-build-sysroot=/ \
+                    LDFLAGS_FOR_TARGET="-L$(pwd)/${config.platform.target.triple}/libgcc $LDFLAGS_FOR_TARGET"
+                '';
 
-                    bash ./configure \
+                build = ''
-                      --prefix=$out \
+                  # Build
-                      --build=${config.platform.build.triple} \
+                  make -j $NIX_BUILD_CORES
-                      --host=${config.platform.host.triple} \
+                '';
-                      --target=${config.platform.target.triple} \
-											--with-sysroot=${foundation.stage1-musl} \
-											--with-native-system-header-dir=/include \
-                      --enable-languages=c,c++ \
-                      --disable-bootstrap \
-                      --disable-libsanitizer \
-                      --disable-lto \
-                      --disable-multilib \
-                      --disable-plugin \
-                      CFLAGS=-static \
-                      CXXFLAGS=-static
-                  '';
 
-                  build = ''
+                install = ''
-                    # Build
+                  # Install
-                    make -j $NIX_BUILD_CORES
+                  make -j $NIX_BUILD_CORES install
-                  '';
+                '';
-
+              };
-                  install = ''
-                    # Install
-                    make -j $NIX_BUILD_CORES install
-                  '';
-                };
 
               src = builtins.fetchurl {
                 url = "${mirrors.gnu}/gcc/gcc-${config.version}/gcc-${config.version}.tar.xz";

tidepool/src/packages/foundation/gcc/newlib.nix

@@ -0,0 +1,240 @@
+{ config, options }:
+let
+  inherit (config)
+    lib
+    mirrors
+    builders
+    # These are the upstream foundational packages exported from the Aux Foundation project.
+
+    foundation
+    packages
+    ;
+in
+{
+  config.packages.foundation.gcc-newlib = {
+    versions = {
+      "latest" =
+        { config, meta }:
+        {
+          options = {
+            src = lib.options.create {
+              type = lib.types.derivation;
+              description = "Source for the package.";
+            };
+
+            cc = {
+              src = lib.options.create {
+                type = lib.types.derivation;
+                description = "The cc source for the package.";
+              };
+            };
+
+            gmp = {
+              src = lib.options.create {
+                type = lib.types.derivation;
+                description = "The gmp source for the package.";
+              };
+
+              version = lib.options.create {
+                type = lib.types.string;
+                description = "Version of gmp.";
+              };
+            };
+
+            mpfr = {
+              src = lib.options.create {
+                type = lib.types.derivation;
+                description = "The mpfr source for the package.";
+              };
+
+              version = lib.options.create {
+                type = lib.types.string;
+                description = "Version of mpfr.";
+              };
+            };
+
+            mpc = {
+              src = lib.options.create {
+                type = lib.types.derivation;
+                description = "The mpc source for the package.";
+              };
+
+              version = lib.options.create {
+                type = lib.types.string;
+                description = "Version of mpc.";
+              };
+            };
+
+            isl = {
+              src = lib.options.create {
+                type = lib.types.derivation;
+                description = "The isl source for the package.";
+              };
+              version = lib.options.create {
+                type = lib.types.string;
+                description = "Version of isl.";
+              };
+            };
+          };
+
+          config =
+            let
+              isBuildBootstrapped = config.platform.build.double == "i686-linux";
+              isHostBootstrapped = config.platform.host.double == "i686-linux";
+
+              isBootstrapped = isBuildBootstrapped && isHostBootstrapped;
+            in
+            {
+              meta = {
+                platforms = [ "i686-linux" ];
+              };
+
+              pname = "gcc-${config.platform.build.double}--${config.platform.host.double}--${config.platform.target.double}";
+              version = "13.2.0";
+
+              builder = builders.basic;
+
+              deps = {
+                  build = {
+                    build = {
+                      binutils = (packages.foundation.binutils.versions.latest.extend {
+                        platform = lib.modules.override 0 config.platform;
+                      });
+                    };
+                  };
+                };
+
+              env = {
+                PATH = lib.paths.bin (
+                  lib.lists.when
+                    (isBootstrapped)
+                    [
+                      foundation.stage2-gcc
+                      foundation.stage2-binutils
+                    ]
+                  ++ [
+                    foundation.stage2-gnumake
+                    foundation.stage2-gnused
+                    foundation.stage2-gnugrep
+                    foundation.stage2-gawk
+                    foundation.stage2-diffutils
+                    foundation.stage2-findutils
+                    foundation.stage2-gnutar
+                    foundation.stage2-gzip
+                    foundation.stage2-bzip2
+                    foundation.stage1-xz
+                  ]
+                );
+              };
+
+              phases = {
+                  unpack = ''
+                    # Unpack
+                    tar xf ${config.src}
+                    tar xf ${config.gmp.src}
+                    tar xf ${config.mpfr.src}
+                    tar xf ${config.mpc.src}
+                    tar xf ${config.isl.src}
+                    cd gcc-${config.version}
+
+                    ln -s ../gmp-${config.gmp.version} gmp
+                    ln -s ../mpfr-${config.mpfr.version} mpfr
+                    ln -s ../mpc-${config.mpc.version} mpc
+                    ln -s ../isl-${config.isl.version} isl
+                  '';
+
+                  patch = ''
+                    # Patch
+                    # force musl even if host triple is gnu
+                    sed -i 's|"os/gnu-linux"|"os/generic"|' libstdc++-v3/configure.host
+                  '';
+
+                  configure = ''
+                    # Configure
+                    export CC="gcc -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
+                    export CXX="g++ -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
+                    export CFLAGS_FOR_TARGET="-Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
+                    export LIBRARY_PATH="${foundation.stage1-musl}/lib"
+
+                    mkdir build
+                    cd build
+
+                    bash ../configure \
+                      --prefix=$out \
+                      --build=${config.platform.build.triple} \
+                      --host=${config.platform.host.triple} \
+                      --target=${config.platform.target.triple} \
+                      --with-as=${config.deps.build.build.binutils.package}/bin/${config.platform.target.triple}-as \
+                      --with-ld=${config.deps.build.build.binutils.package}/bin/${config.platform.target.triple}-ld \
+                      --enable-languages=c,c++ \
+                      --disable-bootstrap \
+                      --disable-libsanitizer \
+                      --disable-lto \
+                      --disable-multilib \
+                      --disable-plugin \
+                      --disable-libssp \
+                      --disable-libvtv \
+                      --disable-libstdcxx \
+                      --disable-libquadmath \
+                      --disable-threads \
+                      --disable-decimal-float \
+                      --disable-shared \
+                      --disable-libmudflap \
+                      --disable-libgomp \
+                      --disable-libatomic \
+                      --without-headers \
+                      --with-newlib
+                  '';
+
+                  build = ''
+                    # Build
+                    make -j $NIX_BUILD_CORES
+                  '';
+
+                  install = ''
+                    # Install
+                    make -j $NIX_BUILD_CORES install
+                  '';
+                };
+
+              src = builtins.fetchurl {
+                url = "${mirrors.gnu}/gcc/gcc-${config.version}/gcc-${config.version}.tar.xz";
+                sha256 = "4nXnZEKmBnNBon8Exca4PYYTFEAEwEE1KIY9xrXHQ9o=";
+              };
+
+              gmp = {
+                version = "6.3.0";
+                src = builtins.fetchurl {
+                  url = "${mirrors.gnu}/gmp/gmp-${config.gmp.version}.tar.xz";
+                  sha256 = "o8K4AgG4nmhhb0rTC8Zq7kknw85Q4zkpyoGdXENTiJg=";
+                };
+              };
+
+              mpfr = {
+                version = "4.2.1";
+                src = builtins.fetchurl {
+                  url = "${mirrors.gnu}/mpfr/mpfr-${config.mpfr.version}.tar.xz";
+                  sha256 = "J3gHNTpnJpeJlpRa8T5Sgp46vXqaW3+yeTiU4Y8fy7I=";
+                };
+              };
+
+              mpc = {
+                version = "1.3.1";
+                src = builtins.fetchurl {
+                  url = "${mirrors.gnu}/mpc/mpc-${config.mpc.version}.tar.gz";
+                  sha256 = "q2QkkvXPiCt0qgy3MM1BCoHtzb7IlRg86TDnBsHHWbg=";
+                };
+              };
+
+              isl = {
+                version = "0.24";
+                src = builtins.fetchurl {
+                  url = "https://gcc.gnu.org/pub/gcc/infrastructure/isl-${config.isl.version}.tar.bz2";
+                  sha256 = "/PeN2WVsEOuM+fvV9ZoLawE4YgX+GTSzsoegoYmBRcA=";
+                };
+              };
+            };
+        };
+    };
+  };
+}

tidepool/src/packages/foundation/gcc/patches/libstdc++-target.patch

@@ -0,0 +1,33 @@
+# From https://github.com/NixOS/nixpkgs/blob/nixos-24.05/pkgs/development/compilers/gcc/patches/libstdc%2B%2B-target.patch
+Patch to make the target libraries 'configure' scripts find the proper CPP.
+I noticed that building the mingw32 cross compiler.
+Looking at the build script for mingw in archlinux, I think that only nixos
+needs this patch. I don't know why.
+diff --git a/Makefile.in b/Makefile.in
+index 93f66b6..d691917 100644
+--- a/Makefile.in
++++ b/Makefile.in
+@@ -266,6 +266,7 @@ BASE_TARGET_EXPORTS = \
+ 	AR="$(AR_FOR_TARGET)"; export AR; \
+ 	AS="$(COMPILER_AS_FOR_TARGET)"; export AS; \
+ 	CC="$(CC_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CC; \
++	CPP="$(CC_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS -E"; export CC; \
+ 	CFLAGS="$(CFLAGS_FOR_TARGET)"; export CFLAGS; \
+ 	CONFIG_SHELL="$(SHELL)"; export CONFIG_SHELL; \
+ 	CPPFLAGS="$(CPPFLAGS_FOR_TARGET)"; export CPPFLAGS; \
+@@ -291,11 +292,13 @@ BASE_TARGET_EXPORTS = \
+ RAW_CXX_TARGET_EXPORTS = \
+ 	$(BASE_TARGET_EXPORTS) \
+ 	CXX_FOR_TARGET="$(RAW_CXX_FOR_TARGET)"; export CXX_FOR_TARGET; \
+-	CXX="$(RAW_CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CXX;
++	CXX="$(RAW_CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CXX; \
++	CXXCPP="$(RAW_CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS -E"; export CXX;
+ 
+ NORMAL_TARGET_EXPORTS = \
+ 	$(BASE_TARGET_EXPORTS) \
+-	CXX="$(CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CXX;
++	CXX="$(CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS"; export CXX; \
++	CXXCPP="$(CXX_FOR_TARGET) $(XGCC_FLAGS_FOR_TARGET) $$TFLAGS -E"; export CXX;
+ 
+ # Where to find GMP
+ HOST_GMPLIBS = @gmplibs@

tidepool/src/packages/foundation/glibc/default.nix

@@ -1,8 +1,9 @@
-{
+{ lib
-  lib,
+, lib'
-  lib',
+, config
-  config,
+, options
-  options,
+, packages
+,
 }:
 let
   inherit (config)
@@ -10,6 +11,7 @@ let
     builders
     # These are the upstream foundational packages exported from the Aux Foundation project.
 
+    packages
     foundation
     ;
 in
@@ -26,95 +28,116 @@ in
             };
           };
 
-          config = {
+          config =
-            meta = {
+            let
-              platforms = [ "i686-linux" ];
+              isCross = (config.platform.build.triple != config.platform.host.triple) && (config.platform.host.triple == config.platform.target.triple);
-            };
+            in
+            {
 
-            pname = "gcc";
+              meta = {
-            version = "2.38";
+                platforms = [ "i686-linux" "x86_64-linux" ];
+              };
 
-            src = builtins.fetchurl {
+              pname = "glibc";
-              url = "${mirrors.gnu}/libc/glibc-${config.version}.tar.xz";
+              version = "2.38";
-              sha256 = "+4KZiZiyspllRnvBtp0VLpwwfSzzAcnq+0VVt3DvP9I=";
-            };
 
-            builder = builders.basic;
+              src = builtins.fetchurl {
+                url = "${mirrors.gnu}/libc/glibc-${config.version}.tar.xz";
+                sha256 = "+4KZiZiyspllRnvBtp0VLpwwfSzzAcnq+0VVt3DvP9I=";
+              };
 
-						hooks = ctx: {
+              builder = builders.basic;
-							"aux:glibc:env" = lib.dag.entry.between ["aux:compiler:setup"] ["configure"] ''
-								AUX_COMPILER_LIBRARY_PATH="${config.package}/lib:$AUX_COMPILER_LIBRARY_PATH"
-							'';
-						};
 
-            env = {
+              deps = {
-              PATH =
+                build ={
-                let
+                  host = {
-                  gcc =
+                      linux-headers = (packages.foundation.linux-headers.versions.latest.extend {
-                    if
+                        platform.target = lib.modules.override 0 config.platform.target;
-                      config.platform.build.triple == config.platform.host.triple
+                      });
-                    # If we're on the same system then we can use the existing GCC instance.
+                  };
-                    then
+                };
-                      foundation.stage2-gcc
+              };
-                    # Otherwise we are going to need a cross-compiler.
+
-                    else
+              env = {
-                      (meta.extend (args: {
+                PATH =
-                        config = {
+                  let
-                          platform = {
+                    gcc =
-                            build = config.platform.build.triple;
+                      if
-                            host = config.platform.build.triple;
+                        isCross
-                            target = lib.modules.override.force config.platform.host.triple;
+                      # Otherwise we are going to need a cross-compiler.
+                      then
+                        (packages.foundation.gcc-newlib.versions.latest.extend {
+                          platform = lib.modules.override 0 {
+                            inherit (config.platform) build target;
+                            host = config.platform.build;
                           };
+                        }).package
+                      # If we're on the same system then we can use the existing GCC instance.
+                      else
+                        foundation.stage2-gcc;
+                  in
+                  lib.paths.bin [
+                    gcc
+                    foundation.stage2-gnumake
+                    foundation.stage2-gnused
+                    foundation.stage2-gnugrep
+                    foundation.stage2-gawk
+                    foundation.stage2-diffutils
+                    foundation.stage2-findutils
+                    foundation.stage2-gnutar
+                    foundation.stage2-gzip
+                    foundation.stage2-bzip2
+                    foundation.stage1-python
+                    foundation.stage1-bison
+                    foundation.stage1-xz
+                  ];
+              };
+
+              phases =
+                let
+                  binutils =
+                    if
+                      isCross
+                    then
+                      "${(packages.foundation.binutils.versions.latest.extend {
+                        platform = lib.modules.override 0 {
+                          inherit (config.platform) build target;
+                          host = config.platform.build;
                         };
-                      })).config.package;
+                      }).package}/${config.platform.target.triple}"
+                    else
+                      foundation.stage2-binutils;
                 in
-                lib.paths.bin [
+                {
-                  foundation.stage2-gcc
+                  unpack = ''
-                  foundation.stage2-binutils
+                    tar xf ${config.src}
-                  foundation.stage2-gnumake
+                    cd glibc-${config.version}
-                  foundation.stage2-gnused
+                  '';
-                  foundation.stage2-gnugrep
+
-                  foundation.stage2-gawk
+                  configure = ''
-                  foundation.stage2-diffutils
+                    mkdir build
-                  foundation.stage2-findutils
+                    cd build
-                  foundation.stage2-gnutar
+
-                  foundation.stage2-gzip
+                    bash ../configure \
-                  foundation.stage2-bzip2
+                      --prefix=$out \
-									foundation.stage1-python
+                      --build=${config.platform.build.triple} \
-									foundation.stage1-bison
+                      --host=${config.platform.host.triple} \
-                  foundation.stage1-xz
+                      --with-headers=${config.deps.build.host.linux-headers.package}/include \
-                ];
+                      --with-binutils=${binutils}/bin
+                  '';
+
+                  build = ''
+                    # Build
+                    make -j $NIX_BUILD_CORES
+                  '';
+
+                  install = ''
+                    # Install
+                    make -j $NIX_BUILD_CORES install
+                    ln -sv $(ls -d ${config.deps.build.host.linux-headers.package}/include/* | grep -v scsi\$) $out/include/
+                  '';
+                };
             };
-
-            phases = {
-              unpack = ''
-                tar xf ${config.src}
-                cd glibc-${config.version}
-              '';
-
-              configure = ''
-                mkdir build
-                cd build
-                # libstdc++.so is built against musl and fails to link
-                export CXX=false
-                bash ../configure \
-                  --prefix=$out \
-                  --build=${config.platform.build.triple} \
-                  --host=${config.platform.host.triple} \
-                  --with-headers=${foundation.stage1-linux-headers}/include
-              '';
-
-              build = ''
-                # Build
-                make -j $NIX_BUILD_CORES
-              '';
-
-              install = ''
-                # Install
-                make -j $NIX_BUILD_CORES INSTALL_UNCOMPRESSED=yes install
-              '';
-            };
-          };
         };
     };
   };

tidepool/src/packages/foundation/linux-headers/default.nix

@@ -1,8 +1,8 @@
-{
+{ lib
-  lib,
+, lib'
-  lib',
+, config
-  config,
+, options
-  options,
+,
 }:
 let
   inherit (config)
@@ -28,7 +28,7 @@ in
 
           config = {
             meta = {
-              platforms = [ "i686-linux" ];
+              platforms = [ "x86_64-linux" "i686-linux" ];
             };
 
             pname = "linux-headers";
@@ -60,7 +60,7 @@ in
               '';
 
               build = ''
-                make -j $NIX_BUILD_CORES CC=musl-gcc HOSTCC=musl-gcc ARCH=${config.platform.host.linux.arch} headers
+                make -j $NIX_BUILD_CORES CC=musl-gcc HOSTCC=musl-gcc ARCH=${config.platform.target.linux.arch} headers
               '';
 
               install = ''