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