input-output-hk · angerman · Feb 1, 2023 · Feb 18, 2023 · Mar 18, 2023 · Oct 7, 2023
diff --git a/builder/comp-builder.nix b/builder/comp-builder.nix
@@ -209,7 +209,15 @@ let
       (enableFeature enableShared "shared")
       (enableFeature enableExecutableDynamic "executable-dynamic")
       (enableFeature doCoverage "coverage")
-      (enableFeature (enableLibraryForGhci && !stdenv.hostPlatform.isGhcjs) "library-for-ghci")
+      # For Android (or really anything that uses lld), -r will silently drop
+      # "lazy" symbols. Those are leaf symbols with no referenes. This however
+      # does not work when loading the objects into the linker, because then we
+      # occationally miss symbols when subsequent libraries depending on the one
+      # that dropped the symbol are loaded.  bfd and lld support --whole-archive
+      # lld -r --whole-archive ... will _not_ drop lazy symbols. However the
+      # --whole-archive flag needs to come _before_ the objects, it's applied in
+      # sequence. The proper fix is thusly to add --while-archive to Cabal.
+      (enableFeature (enableLibraryForGhci && !stdenv.hostPlatform.isGhcjs && !stdenv.hostPlatform.isAndroid) "library-for-ghci")
     ] ++ lib.optionals (stdenv.hostPlatform.isMusl && (haskellLib.isExecutableType componentId)) [
       # These flags will make sure the resulting executable is statically linked.
       # If it uses other libraries it may be necessary for to add more

diff --git a/builder/default.nix b/builder/default.nix
@@ -68,7 +68,7 @@ let
     let
       haskellPackages = {
         # For musl we can use haddock from the buildGHC
-        ghc = if stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && !haskellLib.isNativeMusl
+        ghc = if stdenv.targetPlatform.isMusl
           then ghc.buildGHC
           else ghc;
         inherit packages hoogle;

diff --git a/builder/ghc-for-component-wrapper.nix b/builder/ghc-for-component-wrapper.nix
@@ -23,7 +23,7 @@ let
   libDir         = "$wrappedGhc/${configFiles.libDir}";
   docDir         = "$wrappedGhc/share/doc/ghc/html";
   # For musl we can use haddock from the buildGHC
-  haddock        = if stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && !haskellLib.isNativeMusl
+  haddock        = if stdenv.targetPlatform.isMusl
     then ghc.buildGHC
     else ghc;
 

diff --git a/ci.nix b/ci.nix
@@ -64,6 +64,7 @@
       nixpkgs.lib.optionalAttrs (nixpkgsName == "R2405") {
         ghc96 = false;
         ghc98 = false;
+        ghc910 = true;
       } // nixpkgs.lib.optionalAttrs (nixpkgsName == "unstable") {
         ghc810 = true;
         ghc92 = false;
@@ -101,8 +102,10 @@
   } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948"]) {
     # Musl cross only works on linux
     # aarch64 cross only works on linux
-    inherit (lib.systems.examples) musl64 aarch64-multiplatform;
-  } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && builtins.elem compiler-nix-name ["ghc927" "ghc928"]) {
+    inherit (lib.systems.examples) musl32 musl64 aarch64-multiplatform;
+  } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && !builtins.elem compiler-nix-name ["ghc902" "ghc928" "ghc948"]) {
+    inherit (lib.systems.examples) aarch64-android-prebuilt armv7a-android-prebuilt;
+  } // lib.optionalAttrs (system == "x86_64-linux" && nixpkgsName == "unstable" && !builtins.elem compiler-nix-name ["ghc8107" "ghc902"]) {
     # TODO fix this for the compilers we build with hadrian (ghc >=9.4)
     inherit (lib.systems.examples) aarch64-multiplatform-musl;
   } // lib.optionalAttrs (system == "aarch64-linux" && nixpkgsName == "unstable" && !builtins.elem compiler-nix-name ["ghc8107" "ghc902"]) {

diff --git a/compiler/ghc/default.nix b/compiler/ghc/default.nix
@@ -45,9 +45,9 @@ let self =
 
 , enableDWARF ? false
 
-, enableTerminfo ?
+, enableTerminfo ? !stdenv.targetPlatform.isAndroid &&
     # Terminfo does not work on older ghc cross arm and windows compilers
-     (!haskell-nix.haskellLib.isCrossTarget || !(stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) || builtins.compareVersions ghc-version "8.10" >= 0)
+     (!haskell-nix.haskellLib.isCrossTarget || !(stdenv.targetPlatform.isAarch32 || stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) || builtins.compareVersions ghc-version "8.10" >= 0)
 
 , # Wheter to build in NUMA support
   enableNUMA ? true
@@ -62,7 +62,7 @@ let self =
 
 , # Whether to disable the large address space allocator
   # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
-  disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64
+  disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isAndroid
 
 , useLdGold ?
     # might be better check to see if cc is clang/llvm?
@@ -169,8 +169,9 @@ let
     WITH_TERMINFO=NO
   ''
   # musl doesn't have a system-linker. Only on x86, and on x86 we need it, as
-  # our elf linker for x86_64 is broken.
-  + lib.optionalString (targetPlatform.isAndroid || (targetPlatform.isMusl && !targetPlatform.isx86)) ''
+  # our elf linker for x86_64 is broken. The i686 one seems also to not exist.
+  # So it's really _just_ x86_64.
+  + lib.optionalString (targetPlatform.isAndroid || (targetPlatform.isMusl && !targetPlatform.isx86_64)) ''
     compiler_CONFIGURE_OPTS += --flags=-dynamic-system-linker
   ''
   # While split sections are now enabled by default in ghc 8.8 for windows,
@@ -183,12 +184,14 @@ let
     SplitSections = NO
   '' + lib.optionalString (!enableLibraryProfiling) ''
     BUILD_PROF_LIBS = NO
+  '' + lib.optionalString (disableLargeAddressSpace) ''
+    libraries/base_CONFIGURE_OPTS += --configure-option=--with-libcharset=no
   '';
 
   # `--with` flags for libraries needed for RTS linker
   configureFlags = [
         "--datadir=$doc/share/doc/ghc"
-    ] ++ lib.optionals (!targetPlatform.isGhcjs) ["--with-curses-includes=${targetPackages.ncurses.dev}/include" "--with-curses-libraries=${targetPackages.ncurses.out}/lib"
+    ] ++ lib.optionals (!targetPlatform.isGhcjs && !targetPlatform.isAndroid) ["--with-curses-includes=${targetPackages.ncurses.dev}/include" "--with-curses-libraries=${targetPackages.ncurses.out}/lib"
     ] ++ lib.optionals (targetLibffi != null && !targetPlatform.isGhcjs) ["--with-system-libffi" "--with-ffi-includes=${targetLibffi.dev}/include" "--with-ffi-libraries=${targetLibffi.out}/lib"
     ] ++ lib.optionals (!enableIntegerSimple && !targetPlatform.isGhcjs) [
         "--with-gmp-includes=${targetGmp.dev}/include" "--with-gmp-libraries=${targetGmp.out}/lib"
@@ -216,23 +219,24 @@ let
         # https://gitlab.haskell.org/ghc/ghc/-/issues/23188
         # https://github.com/haskell/cabal/issues/8882
         "fp_cv_prog_ar_supports_dash_l=no"
-    ] ++ lib.optional (targetPlatform.isGhcjs) "--target=javascript-unknown-ghcjs"; # TODO use configurePlatforms once tripple is updated in nixpkgs
+    ] ++ lib.optionals (targetPlatform.isDarwin) [
+        "--without-libcharset"
+    ] ++ lib.optional (targetPlatform.isGhcjs) "--target=javascript-unknown-ghcjs" # TODO use configurePlatforms once tripple is updated in nixpkgs
+    ;
 
   # Splicer will pull out correct variations
-  libDeps = platform: lib.optional (enableTerminfo && !targetPlatform.isGhcjs) [ targetPackages.ncurses targetPackages.ncurses.dev ]
+  libDeps = platform: lib.optional (enableTerminfo && !targetPlatform.isGhcjs && !targetPlatform.isAndroid) [ targetPackages.ncurses targetPackages.ncurses.dev ]
     ++ lib.optional (!targetPlatform.isGhcjs) targetLibffi
     ++ lib.optional (!enableIntegerSimple && !targetPlatform.isGhcjs) gmp
     ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv
     ++ lib.optional (enableNUMA && platform.isLinux && !platform.isAarch32 && !platform.isAndroid) numactl
-    # Even with terminfo disabled some older ghc cross arm and windows compilers do not build unless `ncurses` is found and they seem to want the buildPlatform version
-    ++ lib.optional (!enableTerminfo && haskell-nix.haskellLib.isCrossTarget && (stdenv.targetPlatform.isAarch64 || stdenv.targetPlatform.isWindows) && builtins.compareVersions ghc-version "8.10" < 0) ncurses.dev
     ++ lib.optional enableDWARF (lib.getLib elfutils);
 
   toolsForTarget =
     if targetPlatform.isGhcjs
       then [ buildPackages.emscripten ]
     else if hostPlatform == buildPlatform
-      then [ targetPackages.stdenv.cc ] ++ lib.optionals useLLVM [llvmPackages.llvm llvmPackages.clang]
+      then [ targetPackages.stdenv.cc ] ++ lib.optionals useLLVM ([llvmPackages.llvm] ++ lib.optional (!targetPlatform.useAndroidPrebuilt) llvmPackages.clang)
     else assert targetPlatform == hostPlatform; # build != host == target
       [ stdenv.cc ] ++ lib.optional useLLVM buildLlvmPackages.llvm;
 
@@ -244,7 +248,7 @@ let
   # for musl only; but I'd like to stay far away from the unnecessary
   # bindist logic as we can. It's slow, and buggy, and doesn't provide any
   # value for us.
-  installStage1 = useHadrian && (haskell-nix.haskellLib.isCrossTarget || stdenv.targetPlatform.isMusl);
+  installStage1 = useHadrian && (with haskell-nix.haskellLib; isCrossTarget || isNativeMusl);
 
   hadrian =
     let
@@ -339,7 +343,14 @@ let
         " '*.ghc.cabal.configure.opts += --flags=-dynamic-system-linker'"
       # The following is required if we build on aarch64-darwin for aarch64-iOS. Otherwise older
       # iPhones/iPads/... won't understand the compiled code, as the compiler will emit LDSETALH
-      # + lib.optionalString (targetPlatform.???) "'*.rts.ghc.c.opts += -optc-mcpu=apple-a7 -optc-march=armv8-a+norcpc'"
+      # FIXME: we should have iOS as an argument to this derivation, and then make this, as well as
+      #        disableLargeAddress space conditional on iOS = true.
+      + lib.optionalString (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64)
+        " '*.*.ghc.c.opts += -optc-mcpu=apple-a7 -optc-march=armv8-a+norcpc'"
+      + lib.optionalString (targetPlatform.isAndroid && targetPlatform.isAarch32)
+        " 'stage1.*.ghc.c.opts += -optc-march=armv7-a -optc-mfloat-abi=softfp -optc-mfpu=vfpv3-d16'"
+      + lib.optionalString (targetPlatform.isAndroid && targetPlatform.isAarch64)
+        " 'stage1.*.ghc.c.opts += -optc-march=armv8-a'"
       # For GHC versions in the 9.x range that don't support the +native_bignum flavour transformer yet
       + lib.optionalString ((enableNativeBignum && !hadrianHasNativeBignumFlavour))
         " --bignum=native"
@@ -456,7 +467,10 @@ stdenv.mkDerivation (rec {
         export NIX_LDFLAGS+=" -rpath $out/lib/${targetPrefix}ghc-${ghc-version}"
     '' + lib.optionalString stdenv.isDarwin ''
         export NIX_LDFLAGS+=" -no_dtrace_dof"
-    '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
+    '' +
+    # we really want "+armv7-a,+soft-float,+neon" as features, but llvm will
+    # fail with those :facepalm:
+    lib.optionalString targetPlatform.useAndroidPrebuilt ''
         sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
     '' + lib.optionalString targetPlatform.isMusl ''
         echo "patching llvm-targets for musl targets..."
@@ -531,7 +545,7 @@ stdenv.mkDerivation (rec {
                    ++ lib.optional stdenv.targetPlatform.isMusl "pie"
                    ++ lib.optional enableDWARF "fortify";
 
-  postInstall = lib.optionalString (enableNUMA && targetPlatform.isLinux) ''
+  postInstall = lib.optionalString (enableNUMA && targetPlatform.isLinux && !targetPlatform.isAarch32 && !targetPlatform.isAndroid) ''
     # Patch rts.conf to ensure libnuma can be found
 
     for file in $(find "$out/lib" -name "rts*.conf"); do
@@ -725,7 +739,7 @@ stdenv.mkDerivation (rec {
           --replace 'dynamic-library-dirs:' 'dynamic-library-dirs: ${libcxx}/lib'
         find . -name 'system*.conf*'
         cat mk/system-cxx-std-lib-1.0.conf
-      '' + lib.optionalString (installStage1 && stdenv.targetPlatform.isMusl) ''
+      '' + lib.optionalString (installStage1 && haskell-nix.haskellLib.isNativeMusl) ''
         substituteInPlace hadrian/cfg/system.config \
           --replace 'cross-compiling       = YES' \
                     'cross-compiling       = NO'
@@ -775,7 +789,7 @@ stdenv.mkDerivation (rec {
   dontStrip = true;
   dontPatchELF = true;
   noAuditTmpdir = true;
-} // lib.optionalAttrs (stdenv.buildPlatform.isDarwin || stdenv.targetPlatform.isWindows) {
+} // {
   # ghc install on macOS wants to run `xattr -r -c`
   # The macOS version fails because it wants python 2.
   # The nix version of xattr does not support those args.
@@ -815,12 +829,13 @@ stdenv.mkDerivation (rec {
       --replace 'dynamic-library-dirs:' 'dynamic-library-dirs: ${libcxx}/lib'
     find . -name 'system*.conf*'
     cat mk/system-cxx-std-lib-1.0.conf
-  '' + lib.optionalString (installStage1 && !haskell-nix.haskellLib.isCrossTarget && stdenv.targetPlatform.isMusl) ''
+  '' + lib.optionalString (installStage1 && haskell-nix.haskellLib.isNativeMusl) ''
     substituteInPlace hadrian/cfg/system.config \
       --replace 'cross-compiling       = YES' \
                 'cross-compiling       = NO'
   '';
   buildPhase = ''
+    runHook preBuild
     ${hadrian}/bin/hadrian ${hadrianArgs}
   '' + lib.optionalString (installStage1 && !stdenv.targetPlatform.isGhcjs && builtins.compareVersions ghc-version "9.8" < 0) ''
     ${hadrian}/bin/hadrian ${hadrianArgs} stage1:lib:libiserv
@@ -835,6 +850,8 @@ stdenv.mkDerivation (rec {
       mv $exe ${targetPrefix}$exe
     done
     popd
+  '' + ''
+    runHook postBuild
   '';
 
   # Hadrian's installation only works for native compilers, and is broken for cross compilers.

diff --git a/flake.nix b/flake.nix
@@ -83,7 +83,7 @@
     let
       callFlake = import flake-compat;
 
-      ifdLevel = 3;
+      ifdLevel = 1;
       runningHydraEvalTest = false;
       defaultCompiler = "ghc928";
       config = import ./config.nix;

diff --git a/lib/call-cabal-project-to-nix.nix b/lib/call-cabal-project-to-nix.nix
@@ -334,8 +334,14 @@ let
           echo ',("target arch","${
               if pkgs.stdenv.targetPlatform.isx86_64
                 then "ArchX86_64"
+              else if pkgs.stdenv.targetPlatform.isx86
+                then "ArchX86"
+              else if pkgs.stdenv.targetPlatform.isRiscV64
+                then "ArchRISCV64"
               else if pkgs.stdenv.targetPlatform.isAarch64
                 then "ArchAArch64"
+              else if pkgs.stdenv.targetPlatform.isAarch32
+                then "ArchAArch32"
               else if pkgs.stdenv.targetPlatform.isJavaScript
                 then "ArchJavaScript"
               else throw "Unknown target arch ${pkgs.stdenv.targetPlatform.config}"
@@ -681,8 +687,8 @@ let
         cabal.project.freeze
       chmod +w cabal.project.freeze
     ''}
-    export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt
-    export GIT_SSL_CAINFO=${cacert}/etc/ssl/certs/ca-bundle.crt
+    export SSL_CERT_FILE=${evalPackages.cacert}/etc/ssl/certs/ca-bundle.crt
+    export GIT_SSL_CAINFO=${evalPackages.cacert}/etc/ssl/certs/ca-bundle.crt
 
     export CABAL_DIR=${
       # This creates `.cabal` directory that is as it would have

diff --git a/lib/default.nix b/lib/default.nix
@@ -256,9 +256,9 @@ in {
   isCrossTarget = stdenv.targetPlatform != stdenv.hostPlatform
     && !(stdenv.hostPlatform.isLinux && stdenv.targetPlatform.isMusl && stdenv.hostPlatform.linuxArch == stdenv.targetPlatform.linuxArch);
   # Native musl build-host-target combo
-  isNativeMusl = stdenv.hostPlatform.isMusl
-    && stdenv.buildPlatform == stdenv.hostPlatform
-    && stdenv.hostPlatform == stdenv.targetPlatform;
+  isNativeMusl = stdenv.targetPlatform.isMusl
+    && stdenv.buildPlatform.linuxArch == stdenv.hostPlatform.linuxArch
+    && stdenv.hostPlatform.linuxArch == stdenv.targetPlatform.linuxArch;
 
   # Takes a version number, module or list of modules (for cabalProject)
   # and converts it to an list of project modules.  This allows
@@ -593,6 +593,8 @@ in {
     then "arm"
     else if hostPlatform.isAarch64
     then "aarch64"
+    else if hostPlatform.isi686
+    then "i386"
     else abort "Don't know which QEMU to use for hostPlatform ${hostPlatform.config}. Please provide qemuSuffix";
 
   # How to run ldd when checking for static linking

diff --git a/overlays/android.nix b/overlays/android.nix
@@ -1,4 +1,21 @@
-_final: prev: prev.lib.optionalAttrs prev.stdenv.hostPlatform.isAndroid ({
+final: prev: {
+  # Use android SDK version 26
-final: prev: {
+_final: prev: {
-final: prev: {
+_final: prev: {
+  lib = prev.lib // {
+    systems = prev.lib.systems // {
+      examples = prev.lib.systems.examples // {
+        aarch64-android = prev.lib.systems.examples.aarch64-android // {
+          androidSdkVersion = "269";
+          androidNdkVersion = "24";
+        };
+        armv7a-android-prebuilt = prev.lib.systems.examples.armv7a-android-prebuilt // {
+          androidSdkVersion = "26";
+          androidNdkVersion = "24";
+        };
+      };
+    };
+  };
+} // prev.lib.optionalAttrs prev.stdenv.hostPlatform.isAndroid ({
+
   # we really only want the static one.
   libiconv = (prev.libiconv.override { enableStatic = true; enableShared = false; }).overrideAttrs(_: {
     hardeningDisable = [ "fortify" "stackprotector" "format" ];
@@ -11,18 +28,31 @@ _final: prev: prev.lib.optionalAttrs prev.stdenv.hostPlatform.isAndroid ({
     '';
     # my current thinking is that this is due to the android toolchain using r23, api30.
   });
-  libffi = prev.libffi.overrideAttrs (_: {
+  libffi = prev.libffi.overrideAttrs ( old: {
     dontDisableStatic = true;
+    configureFlags = old.configureFlags ++ [ "--disable-shared" ];
 
     hardeningDisable = [ "fortify" "stackprotector" "format" ];
+  } // prev.lib.optionalAttrs (prev.stdenv.hostPlatform.isAarch32 || prev.stdenv.hostPlatform.isAarch64) {
     # see libiconv. We want to target a lower minsdk
     postConfigure = ''
-      echo "#undef HAVE_MEMFD_CREATE" >> aarch64-unknown-linux-android/fficonfig.h
+      echo "#undef HAVE_MEMFD_CREATE" >> ${prev.stdenv.hostPlatform.config}/fficonfig.h
     '';
   });
-  gmp6 = (prev.gmp6.override { withStatic = true; }).overrideAttrs(_: {
+  gmp6 = (prev.gmp6.override { withStatic = true; }).overrideAttrs(old: {
     hardeningDisable = [ "fortify" "stackprotector" "format" ];
+    configureFlags = old.configureFlags ++ [ "--disable-shared" ];
   });
+  zlib = prev.zlib.override { shared = false; static = true; };
+  # kernel tls (ktls) doesn't work with the android kernel. And will complain
+  # about lots of implicitly declared functions and undeclared identifiers,
+  # because the android (linux) kernel doesn't expose those.
+  openssl = prev.openssl.override { static = true; enableKTLS = false; };
+
 }) // prev.lib.optionalAttrs (prev.stdenv.targetPlatform.isAndroid && (!prev.stdenv.hostPlatform.useAndroidPrebuilt)) ({
-  bionic = prev.bionic.override { enableStatic = true; };
+  # we still need the shared libraries to link against on the platform.  GHC
+  # has been neutered to not even try loading shared libs and will use dynamic ones.
+  # We also link iserv against the static libs, so that we have a fully static
+  # android (bionic/linux) iserv we can execute on glibc/linux.
+  bionic = prev.bionic.override { enableStatic = true; enableShared = true; };
 })