+126
−0
Loading
haskell.compiler.ghc{948,967,984,9102,9103,9121,9122}: backport patches for LLVM support
LLVM 12–17 have been dropped for Nixpkgs 25.11. As discussed recently on Matrix, this backports upstream changes to allow the use of LLVM 20 for all GHC versions from 9.4.8 onward. I looked over GHC commits mentioning LLVM since the release of 9.4.8, and read the discussions and issues around the relevant bumps, and attempted to be quite thorough, but I obviously cannot guarantee that this is wholly comprehensive. It seems like upstream generally bumps the upper bound on the basis of “it builds successfully for me”, with specific adaptations for new versions being fairly uncommon and only coming for obvious build blockers or reactively in response to bug reports. I have backported both kinds of changes here. For some commits, trivial conflict resolutions and adaptations were required. It would be possible to pass the affected files to `fetchpatch` as `excludes` and keep smaller fix‐up patches in tree in some cases, but I opted to keep it simple and vendor complete backport patches instead. I did not attempt to backport every single change to the LLVM backend, only those that seemed directly relevant to support for newer versions; if you’d get the same issue with the older LLVM, that’s just a GHC bug. These changes should actually make it easier to cross‐compile for new architectures, as more recent LLVMs will have better support for newer platforms, and it will be easier to backport GHC changes to enable new platforms with less drift in the backend. These patches do result in two breaking changes. Firstly, the minimum LLVM version is bumped to 13 across the board. This is irrelevant for Nixpkgs as we pin a specific LLVM version anyway, and versions below LLVM 18 will be removed imminently. Secondly, support for the hidden `-fno-llvm-tbaa` flag is dropped. This can be replaced with custom `-optlo` flags to control the passes more directly, but the main use of this undocumented flag appears to have been to [work around] the lack of support for newer LLVM versions, anyway. [work around]: <https://gitlab.haskell.org/ghc/ghc/-/issues/22220> I successfully built the following on `aarch64-linux`: * `pkgsCross.armv7l-hf-multiplatform.buildPackages.haskell.compiler.ghc948` * `pkgsCross.armv7l-hf-multiplatform.buildPackages.haskell.compiler.ghc967` * `pkgsCross.armv7l-hf-multiplatform.buildPackages.haskell.compiler.ghc984` * `pkgsCross.armv7l-hf-multiplatform.buildPackages.haskell.compiler.ghc9102` * `pkgsCross.armv7l-hf-multiplatform.buildPackages.haskell.compiler.ghc9121` * `pkgsCross.armv7l-hf-multiplatform.buildPackages.haskell.compiler.ghc9122` * `pkgsCross.riscv64.haskell.compiler.ghc948` The GHC 9.4.8 with an ARMv7 host platform segfaults when I try to run GHC, though e.g. `ghc-pkg --help` runs successfully. The GHC 9.10.3 build targeting ARMv7 crashed inside `llc(1)`, so I tried RISC‐V, which has some platform mismatch issue relating to `libffi`, so I tried z/Architecture, which failed with an invalid floating point constant in the LLVM IR, so I tried 64‐bit MIPS, which failed with a different `libffi` issue, so I tried 32‐bit MIPS, which failed to compile `compiler-rt`, so I gave up. I confirmed that both of the ARMv7 issues reproduce with 944e8fd4, the revision before they were bumped from their old versions of LLVM, so these are not regressions. I built a test program with the ARMv7 cross‐compilers and confirmed that they run on the AArch64 builder. I also confirmed that the cross‐compiled RISC‐V GHC successfully runs under `qemu-riscv64(1)`. It will only try to build programs via the C backend, though, as that is the only option for unregisterised™ targets, so it’s not clear to me how useful LLVM support in 9.4.8 really is for bootstrapping new platforms; I guess even RISC‐V would require more backporting work to produce a cross‐compiled GHC that will use LLVM to compile its own input. I didn’t bother setting up all the binfmt machinery to get it through compiling and running a test program, but it at least makes the attempt.