pkgs/development/compilers/llvm/11/default.nix

   1 { lowPrio, newScope, pkgs, lib, stdenv, cmake, gccForLibs
   2 , libxml2, python3, isl, fetchurl, overrideCC, wrapCCWith, wrapBintoolsWith
   3 , buildPackages
   4 , buildLlvmTools # tools, but from the previous stage, for cross
   5 , targetLlvmLibraries # libraries, but from the next stage, for cross
   6 }:
   7
   8 let
   9   release_version = "11.1.0";
  10   candidate = ""; # empty or "rcN"
  11   dash-candidate = lib.optionalString (candidate != "") "-${candidate}";
  12   version = "${release_version}${dash-candidate}"; # differentiating these (variables) is important for RCs
  13   targetConfig = stdenv.targetPlatform.config;
  14
  15   fetch = name: sha256: fetchurl {
  16     url = "https://github.com/llvm/llvm-project/releases/download/llvmorg-${version}/${name}-${release_version}${candidate}.src.tar.xz";
  17     inherit sha256;
  18   };
  19
  20   clang-tools-extra_src = fetch "clang-tools-extra" "18n1w1hkv931xzq02b34wglbv6zd6sd0r5kb8piwvag7klj7qw3n";
  21
  22   tools = lib.makeExtensible (tools: let
  23     callPackage = newScope (tools // { inherit stdenv cmake libxml2 python3 isl release_version version fetch; });
  24     mkExtraBuildCommands = cc: ''
  25       rsrc="$out/resource-root"
  26       mkdir "$rsrc"
  27       ln -s "${cc}/lib/clang/${release_version}/include" "$rsrc"
  28       ln -s "${targetLlvmLibraries.compiler-rt.out}/lib" "$rsrc/lib"
  29       ln -s "${targetLlvmLibraries.compiler-rt.out}/share" "$rsrc/share"
  30       echo "-resource-dir=$rsrc" >> $out/nix-support/cc-cflags
  31     '';
  32   in {
  33
  34     llvm = callPackage ./llvm { };
  35
  36     clang-unwrapped = callPackage ./clang {
  37       inherit (tools) lld;
  38       inherit clang-tools-extra_src;
  39     };
  40
  41     # disabled until recommonmark supports sphinx 3
  42     #Llvm-manpages = lowPrio (tools.llvm.override {
  43     #  enableManpages = true;
  44     #  python3 = pkgs.python3;  # don't use python-boot
  45     #});
  46
  47     clang-manpages = lowPrio (tools.clang-unwrapped.override {
  48       enableManpages = true;
  49       python3 = pkgs.python3;  # don't use python-boot
  50     });
  51
  52     # disabled until recommonmark supports sphinx 3
  53     # lldb-manpages = lowPrio (tools.lldb.override {
  54     #   enableManpages = true;
  55     #   python3 = pkgs.python3;  # don't use python-boot
  56     # });
  57
  58     libclang = tools.clang-unwrapped.lib;
  59
  60     clang = if stdenv.cc.isGNU then tools.libstdcxxClang else tools.libcxxClang;
  61
  62     libstdcxxClang = wrapCCWith rec {
  63       cc = tools.clang-unwrapped;
  64       # libstdcxx is taken from gcc in an ad-hoc way in cc-wrapper.
  65       libcxx = null;
  66       extraPackages = [
  67         targetLlvmLibraries.compiler-rt
  68       ];
  69       extraBuildCommands = mkExtraBuildCommands cc;
  70     };
  71
  72     libcxxClang = wrapCCWith rec {
  73       cc = tools.clang-unwrapped;
  74       libcxx = targetLlvmLibraries.libcxx;
  75       extraPackages = [
  76         targetLlvmLibraries.libcxxabi
  77         targetLlvmLibraries.compiler-rt
  78       ];
  79       extraBuildCommands = mkExtraBuildCommands cc;
  80     };
  81
  82     lld = callPackage ./lld {};
  83
  84     lldb = callPackage ./lldb {};
  85
  86     # Below, is the LLVM bootstrapping logic. It handles building a
  87     # fully LLVM toolchain from scratch. No GCC toolchain should be
  88     # pulled in. As a consequence, it is very quick to build different
  89     # targets provided by LLVM and we can also build for what GCC
  90     # doesn’t support like LLVM. Probably we should move to some other
  91     # file.
  92
  93     bintools = callPackage ./bintools.nix {};
  94
  95     lldClang = wrapCCWith rec {
  96       cc = tools.clang-unwrapped;
  97       libcxx = targetLlvmLibraries.libcxx;
  98       bintools = wrapBintoolsWith {
  99         inherit (tools) bintools;
 100       };
 101       extraPackages = [
 102         targetLlvmLibraries.libcxxabi
 103         targetLlvmLibraries.compiler-rt
 104       ] ++ lib.optionals (!stdenv.targetPlatform.isWasm) [
 105         targetLlvmLibraries.libunwind
 106       ];
 107       extraBuildCommands = ''
 108         echo "-rtlib=compiler-rt -Wno-unused-command-line-argument" >> $out/nix-support/cc-cflags
 109         echo "-B${targetLlvmLibraries.compiler-rt}/lib" >> $out/nix-support/cc-cflags
 110       '' + lib.optionalString (!stdenv.targetPlatform.isWasm) ''
 111         echo "--unwindlib=libunwind" >> $out/nix-support/cc-cflags
 112       '' + lib.optionalString stdenv.targetPlatform.isWasm ''
 113         echo "-fno-exceptions" >> $out/nix-support/cc-cflags
 114       '' + mkExtraBuildCommands cc;
 115     };
 116
 117     lldClangNoLibcxx = wrapCCWith rec {
 118       cc = tools.clang-unwrapped;
 119       libcxx = null;
 120       bintools = wrapBintoolsWith {
 121         inherit (tools) bintools;
 122       };
 123       extraPackages = [
 124         targetLlvmLibraries.compiler-rt
 125       ];
 126       extraBuildCommands = ''
 127         echo "-rtlib=compiler-rt" >> $out/nix-support/cc-cflags
 128         echo "-B${targetLlvmLibraries.compiler-rt}/lib" >> $out/nix-support/cc-cflags
 129         echo "-nostdlib++" >> $out/nix-support/cc-cflags
 130       '' + mkExtraBuildCommands cc;
 131     };
 132
 133     lldClangNoLibc = wrapCCWith rec {
 134       cc = tools.clang-unwrapped;
 135       libcxx = null;
 136       bintools = wrapBintoolsWith {
 137         inherit (tools) bintools;
 138         libc = null;
 139       };
 140       extraPackages = [
 141         targetLlvmLibraries.compiler-rt
 142       ];
 143       extraBuildCommands = ''
 144         echo "-rtlib=compiler-rt" >> $out/nix-support/cc-cflags
 145         echo "-B${targetLlvmLibraries.compiler-rt}/lib" >> $out/nix-support/cc-cflags
 146       '' + mkExtraBuildCommands cc;
 147     };
 148
 149     lldClangNoCompilerRt = wrapCCWith {
 150       cc = tools.clang-unwrapped;
 151       libcxx = null;
 152       bintools = wrapBintoolsWith {
 153         inherit (tools) bintools;
 154         libc = null;
 155       };
 156       extraPackages = [ ];
 157       extraBuildCommands = ''
 158         echo "-nostartfiles" >> $out/nix-support/cc-cflags
 159       '';
 160     };
 161
 162   });
 163
 164   libraries = lib.makeExtensible (libraries: let
 165     callPackage = newScope (libraries // buildLlvmTools // { inherit stdenv cmake libxml2 python3 isl release_version version fetch; });
 166   in {
 167
 168     compiler-rt = callPackage ./compiler-rt ({} //
 169       (lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) {
 170         stdenv = overrideCC stdenv buildLlvmTools.lldClangNoCompilerRt;
 171       }));
 172
 173     stdenv = overrideCC stdenv buildLlvmTools.clang;
 174
 175     libcxxStdenv = overrideCC stdenv buildLlvmTools.libcxxClang;
 176
 177     libcxx = callPackage ./libc++ ({} //
 178       (lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) {
 179         stdenv = overrideCC stdenv buildLlvmTools.lldClangNoLibcxx;
 180       }));
 181
 182     libcxxabi = callPackage ./libc++abi ({} //
 183       (lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) {
 184         stdenv = overrideCC stdenv buildLlvmTools.lldClangNoLibcxx;
 185         libunwind = libraries.libunwind;
 186       }));
 187
 188     openmp = callPackage ./openmp.nix {};
 189
 190     libunwind = callPackage ./libunwind ({} //
 191       (lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) {
 192         stdenv = overrideCC stdenv buildLlvmTools.lldClangNoLibcxx;
 193       }));
 194
 195   });
 196
 197 in { inherit tools libraries; } // libraries // tools