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