diff --git a/overlay/default.nix b/overlay/default.nix index c84b6f5..67015da 100644 --- a/overlay/default.nix +++ b/overlay/default.nix @@ -8,6 +8,8 @@ with prev; { [ ./binutils/support-genode.patch ]; }); + clang = final.llvmPackages_10.clang; + cmake = prev.cmake.overrideAttrs (attrs: { postInstall = with stdenv; if targetPlatform.isGenode then '' @@ -37,10 +39,14 @@ with prev; { else prev.libcCrossChooser name; - llvmPackages_8 = callPackage ./llvm-8 ({ + llvmPackages = recurseIntoAttrs llvmPackages_10; + llvmPackages_latest = llvmPackages_10; + + llvmPackages_8 = llvmPackages_10; + llvmPackages_10 = callPackage ./llvm-10 ({ inherit (stdenvAdapters) overrideCC; - buildLlvmTools = buildPackages.llvmPackages_8.tools; - targetLlvmLibraries = targetPackages.llvmPackages_8.libraries; + buildLlvmTools = buildPackages.llvmPackages_10.tools; + targetLlvmLibraries = targetPackages.llvmPackages_10.libraries; }); solo5-tools = callPackage ./solo5-tools { }; diff --git a/overlay/llvm-10/bintools.nix b/overlay/llvm-10/bintools.nix new file mode 100644 index 0000000..72a2a73 --- /dev/null +++ b/overlay/llvm-10/bintools.nix @@ -0,0 +1,19 @@ +{ runCommand, stdenv, llvm, lld, version }: + +let + prefix = + if stdenv.hostPlatform != stdenv.targetPlatform + then "${stdenv.targetPlatform.config}-" + else ""; +in runCommand "llvm-binutils-${version}" { preferLocalBuild = true; } '' + mkdir -p $out/bin + for prog in ${lld}/bin/*; do + ln -s $prog $out/bin/${prefix}$(basename $prog) + done + for prog in ${llvm}/bin/*; do + ln -s $prog $out/bin/${prefix}$(echo $(basename $prog) | sed -e "s|llvm-||") + ln -sf $prog $out/bin/${prefix}$(basename $prog) + done + rm -f $out/bin/${prefix}cat + ln -s ${lld}/bin/lld $out/bin/${prefix}ld +'' diff --git a/overlay/llvm-10/clang/clang-extension-handling.patch b/overlay/llvm-10/clang/clang-extension-handling.patch new file mode 100644 index 0000000..a74d109 --- /dev/null +++ b/overlay/llvm-10/clang/clang-extension-handling.patch @@ -0,0 +1,18 @@ +Compressed diff from +``` +git show d21664cce1db8debe2528f36b1fbd2b8af9c9401 87dac7da68ea1e0adac78c59ef1891dcf9632b67 3a0f6e699bb6d96dc62dce6faef20ac26cf103fd +``` +with the purpose of avoiding linker errors arising in the polly-flavoured clang. + +diff --git a/clang/CMakeLists.txt b/clang/CMakeLists.txt +index 781c3eb7f2f..dc1413f4b59 100644 +--- clang/CMakeLists.txt ++++ clang/CMakeLists.txt +@@ -864,6 +864,7 @@ add_subdirectory(utils/hmaptool) + + if(CLANG_BUILT_STANDALONE) + llvm_distribution_add_targets() ++ process_llvm_pass_plugins() + endif() + + configure_file( diff --git a/overlay/llvm-10/clang/compiler-rt-baremetal.patch b/overlay/llvm-10/clang/compiler-rt-baremetal.patch new file mode 100644 index 0000000..a4a0f21 --- /dev/null +++ b/overlay/llvm-10/clang/compiler-rt-baremetal.patch @@ -0,0 +1,53 @@ +Index: lib/Driver/ToolChains/BareMetal.cpp +=================================================================== +--- a/lib/Driver/ToolChains/BareMetal.cpp ++++ b/lib/Driver/ToolChains/BareMetal.cpp +@@ -157,7 +157,7 @@ + void BareMetal::AddLinkRuntimeLib(const ArgList &Args, + ArgStringList &CmdArgs) const { + CmdArgs.push_back(Args.MakeArgString("-lclang_rt.builtins-" + +- getTriple().getArchName() + ".a")); ++ getTriple().getArchName())); + } + + void baremetal::Linker::ConstructJob(Compilation &C, const JobAction &JA, +Index: test/Driver/baremetal.cpp +=================================================================== +--- a/test/Driver/baremetal.cpp ++++ b/test/Driver/baremetal.cpp +@@ -13,7 +13,7 @@ + // CHECK-V6M-C-NEXT: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic" + // CHECK-V6M-C-SAME: "-L[[RESOURCE_DIR:[^"]+]]{{[/\\]+}}lib{{[/\\]+}}baremetal" + // CHECK-V6M-C-SAME: "-T" "semihosted.lds" "-Lsome{{[/\\]+}}directory{{[/\\]+}}user{{[/\\]+}}asked{{[/\\]+}}for" +-// CHECK-V6M-C-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m.a" ++// CHECK-V6M-C-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m" + // CHECK-V6M-C-SAME: "-o" "{{.*}}.o" + + // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +@@ -35,7 +35,7 @@ + // CHECK-V6M-DEFAULTCXX: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic" + // CHECK-V6M-DEFAULTCXX-SAME: "-L{{[^"]*}}{{[/\\]+}}lib{{(64)?}}{{[/\\]+}}clang{{[/\\]+}}{{.*}}{{[/\\]+}}lib{{[/\\]+}}baremetal" + // CHECK-V6M-DEFAULTCXX-SAME: "-lc++" "-lc++abi" "-lunwind" +-// CHECK-V6M-DEFAULTCXX-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m.a" ++// CHECK-V6M-DEFAULTCXX-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m" + // CHECK-V6M-DEFAULTCXX-SAME: "-o" "{{.*}}.o" + + // RUN: %clangxx -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +@@ -48,7 +48,7 @@ + // CHECK-V6M-LIBCXX: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic" + // CHECK-V6M-LIBCXX-SAME: "-L{{[^"]*}}{{[/\\]+}}lib{{(64)?}}{{[/\\]+}}clang{{[/\\]+}}{{.*}}{{[/\\]+}}lib{{[/\\]+}}baremetal" + // CHECK-V6M-LIBCXX-SAME: "-lc++" "-lc++abi" "-lunwind" +-// CHECK-V6M-LIBCXX-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m.a" ++// CHECK-V6M-LIBCXX-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m" + // CHECK-V6M-LIBCXX-SAME: "-o" "{{.*}}.o" + + // RUN: %clangxx -no-canonical-prefixes %s -### -o %t.o 2>&1 \ +@@ -61,7 +61,7 @@ + // CHECK-V6M-LIBSTDCXX: "{{[^"]*}}ld{{(\.(lld|bfd|gold))?}}{{(\.exe)?}}" "{{.*}}.o" "-Bstatic" + // CHECK-V6M-LIBSTDCXX-SAME: "-L{{[^"]*}}{{[/\\]+}}lib{{(64)?}}{{[/\\]+}}clang{{[/\\]+}}{{.*}}{{[/\\]+}}lib{{[/\\]+}}baremetal" + // CHECK-V6M-LIBSTDCXX-SAME: "-lstdc++" "-lsupc++" "-lunwind" +-// CHECK-V6M-LIBSTDCXX-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m.a" ++// CHECK-V6M-LIBSTDCXX-SAME: "-lc" "-lm" "-lclang_rt.builtins-armv6m" + // CHECK-V6M-LIBSTDCXX-SAME: "-o" "{{.*}}.o" + + // RUN: %clangxx -no-canonical-prefixes %s -### -o %t.o 2>&1 \ diff --git a/overlay/llvm-10/clang/default.nix b/overlay/llvm-10/clang/default.nix new file mode 100644 index 0000000..0727880 --- /dev/null +++ b/overlay/llvm-10/clang/default.nix @@ -0,0 +1,121 @@ +{ stdenv, fetch, cmake, libxml2, llvm, version, clang-tools-extra_src, python3, lld +, fixDarwinDylibNames +, enableManpages ? false +}: + +let + self = stdenv.mkDerivation ({ + pname = "clang"; + inherit version; + + src = fetch "clang" "08fbxa2a0kr3ni35ckppj0kyvlcyaywrhpqwcdrdy0z900mhcnw8"; + + unpackPhase = '' + unpackFile $src + mv clang-${version}* clang + sourceRoot=$PWD/clang + unpackFile ${clang-tools-extra_src} + mv clang-tools-extra-* $sourceRoot/tools/extra + ''; + + nativeBuildInputs = [ cmake python3 lld ] + ++ stdenv.lib.optional enableManpages python3.pkgs.sphinx; + + buildInputs = [ libxml2 llvm ] + ++ stdenv.lib.optional stdenv.isDarwin fixDarwinDylibNames; + + cmakeFlags = [ + "-DCMAKE_CXX_FLAGS=-std=c++14" + "-DCLANGD_BUILD_XPC=OFF" + ] ++ stdenv.lib.optionals enableManpages [ + "-DCLANG_INCLUDE_DOCS=ON" + "-DLLVM_ENABLE_SPHINX=ON" + "-DSPHINX_OUTPUT_MAN=ON" + "-DSPHINX_OUTPUT_HTML=OFF" + "-DSPHINX_WARNINGS_AS_ERRORS=OFF" + ]; + + patches = [ + # 10.0.0 only, this should be present in 10.0.1 + ./clang-extension-handling.patch + + ./purity.patch + # https://reviews.llvm.org/D51899 + ./compiler-rt-baremetal.patch + ] ++ stdenv.lib.optional stdenv.targetPlatform.isGenode ./genode.patch; + + postPatch = '' + sed -i -e 's/DriverArgs.hasArg(options::OPT_nostdlibinc)/true/' \ + -e 's/Args.hasArg(options::OPT_nostdlibinc)/true/' \ + lib/Driver/ToolChains/*.cpp + + # Patch for standalone doc building + sed -i '1s,^,find_package(Sphinx REQUIRED)\n,' docs/CMakeLists.txt + '' + stdenv.lib.optionalString stdenv.hostPlatform.isMusl '' + sed -i -e 's/lgcc_s/lgcc_eh/' lib/Driver/ToolChains/*.cpp + '' + stdenv.lib.optionalString stdenv.hostPlatform.isDarwin '' + substituteInPlace tools/extra/clangd/CMakeLists.txt \ + --replace "NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB" FALSE + ''; + + outputs = [ "out" "lib" "python" ]; + + # Clang expects to find LLVMgold in its own prefix + postInstall = '' + if [ -e ${llvm}/lib/LLVMgold.so ]; then + ln -sv ${llvm}/lib/LLVMgold.so $out/lib + fi + + ln -sv $out/bin/clang $out/bin/cpp + + # Move libclang to 'lib' output + moveToOutput "lib/libclang.*" "$lib" + moveToOutput "lib/libclang-cpp.*" "$lib" + substituteInPlace $out/lib/cmake/clang/ClangTargets-release.cmake \ + --replace "\''${_IMPORT_PREFIX}/lib/libclang." "$lib/lib/libclang." \ + --replace "\''${_IMPORT_PREFIX}/lib/libclang-cpp." "$lib/lib/libclang-cpp." + + mkdir -p $python/bin $python/share/clang/ + mv $out/bin/{git-clang-format,scan-view} $python/bin + if [ -e $out/bin/set-xcode-analyzer ]; then + mv $out/bin/set-xcode-analyzer $python/bin + fi + mv $out/share/clang/*.py $python/share/clang + rm $out/bin/c-index-test + ''; + + enableParallelBuilding = true; + + passthru = { + isClang = true; + inherit llvm; + } // stdenv.lib.optionalAttrs (stdenv.targetPlatform.isLinux || (stdenv.cc.isGNU && stdenv.cc.cc ? gcc)) { + gcc = if stdenv.cc.isGNU then stdenv.cc.cc else stdenv.cc.cc.gcc; + }; + + meta = { + description = "A c, c++, objective-c, and objective-c++ frontend for the llvm compiler"; + homepage = http://llvm.org/; + license = stdenv.lib.licenses.ncsa; + platforms = stdenv.lib.platforms.all; + }; + } // stdenv.lib.optionalAttrs enableManpages { + pname = "clang-manpages"; + + buildPhase = '' + make docs-clang-man + ''; + + installPhase = '' + mkdir -p $out/share/man/man1 + # Manually install clang manpage + cp docs/man/*.1 $out/share/man/man1/ + ''; + + outputs = [ "out" ]; + + doCheck = false; + + meta.description = "man page for Clang ${version}"; + }); +in self diff --git a/overlay/llvm-10/clang/genode.patch b/overlay/llvm-10/clang/genode.patch new file mode 100644 index 0000000..9640a0c --- /dev/null +++ b/overlay/llvm-10/clang/genode.patch @@ -0,0 +1,349 @@ +diff --git a/lib/Basic/Targets.cpp b/lib/Basic/Targets.cpp +index c063f8ca447..d0ad6fea966 100644 +--- a/lib/Basic/Targets.cpp ++++ b/lib/Basic/Targets.cpp +@@ -138,6 +138,8 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple, + return new FreeBSDTargetInfo(Triple, Opts); + case llvm::Triple::Fuchsia: + return new FuchsiaTargetInfo(Triple, Opts); ++ case llvm::Triple::Genode: ++ return new GenodeTargetInfo(Triple, Opts); + case llvm::Triple::Linux: + return new LinuxTargetInfo(Triple, Opts); + case llvm::Triple::NetBSD: +@@ -162,6 +164,8 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple, + return new FreeBSDTargetInfo(Triple, Opts); + case llvm::Triple::Fuchsia: + return new FuchsiaTargetInfo(Triple, Opts); ++ case llvm::Triple::Genode: ++ return new GenodeTargetInfo(Triple, Opts); + case llvm::Triple::Linux: + return new LinuxTargetInfo(Triple, Opts); + case llvm::Triple::NetBSD: +@@ -536,6 +540,8 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple, + return new FreeBSDTargetInfo(Triple, Opts); + case llvm::Triple::Fuchsia: + return new FuchsiaTargetInfo(Triple, Opts); ++ case llvm::Triple::Genode: ++ return new GenodeTargetInfo(Triple, Opts); + case llvm::Triple::KFreeBSD: + return new KFreeBSDTargetInfo(Triple, Opts); + case llvm::Triple::Solaris: +diff --git a/lib/Basic/Targets/OSTargets.h b/lib/Basic/Targets/OSTargets.h +index 70fac030bc5..08b6d1fc997 100644 +--- a/lib/Basic/Targets/OSTargets.h ++++ b/lib/Basic/Targets/OSTargets.h +@@ -813,6 +813,26 @@ public: + } + }; + ++// Genode Target ++template ++class LLVM_LIBRARY_VISIBILITY GenodeTargetInfo : public OSTargetInfo { ++protected: ++ void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple, ++ MacroBuilder &Builder) const override { ++ Builder.defineMacro("__GENODE__"); ++ Builder.defineMacro("__ELF__"); ++ // Required by the libc++ locale support. ++ if (Opts.CPlusPlus) ++ Builder.defineMacro("_GNU_SOURCE"); ++ } ++ ++public: ++ GenodeTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts) ++ : OSTargetInfo(Triple, Opts) { ++ this->MCountName = "__mcount"; ++ } ++}; ++ + // WebAssembly target + template + class LLVM_LIBRARY_VISIBILITY WebAssemblyOSTargetInfo +diff --git a/lib/Driver/CMakeLists.txt b/lib/Driver/CMakeLists.txt +index 6f25d3588eb..35df9d56600 100644 +--- a/lib/Driver/CMakeLists.txt ++++ b/lib/Driver/CMakeLists.txt +@@ -48,6 +48,7 @@ add_clang_library(clangDriver + ToolChains/Flang.cpp + ToolChains/FreeBSD.cpp + ToolChains/Fuchsia.cpp ++ ToolChains/Genode.cpp + ToolChains/Gnu.cpp + ToolChains/Haiku.cpp + ToolChains/HIP.cpp +diff --git a/lib/Driver/Driver.cpp b/lib/Driver/Driver.cpp +index fb8335a3695..267ebb57fd7 100644 +--- a/lib/Driver/Driver.cpp ++++ b/lib/Driver/Driver.cpp +@@ -22,6 +22,7 @@ + #include "ToolChains/DragonFly.h" + #include "ToolChains/FreeBSD.h" + #include "ToolChains/Fuchsia.h" ++#include "ToolChains/Genode.h" + #include "ToolChains/Gnu.h" + #include "ToolChains/HIP.h" + #include "ToolChains/Haiku.h" +@@ -4856,6 +4857,9 @@ const ToolChain &Driver::getToolChain(const ArgList &Args, + case llvm::Triple::Solaris: + TC = std::make_unique(*this, Target, Args); + break; ++ case llvm::Triple::Genode: ++ TC = std::make_unique(*this, Target, Args); ++ break; + case llvm::Triple::AMDHSA: + case llvm::Triple::AMDPAL: + case llvm::Triple::Mesa3D: +diff --git a/lib/Driver/SanitizerArgs.cpp b/lib/Driver/SanitizerArgs.cpp +index ac9a294ee3f..c0914ac4559 100644 +--- a/lib/Driver/SanitizerArgs.cpp ++++ b/lib/Driver/SanitizerArgs.cpp +@@ -748,7 +748,7 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, + ImplicitCfiRuntime = TC.getTriple().isAndroid(); + + if (AllAddedKinds & SanitizerKind::Address) { +- NeedPIE |= TC.getTriple().isOSFuchsia(); ++ NeedPIE |= TC.getTriple().isOSFuchsia() | TC.getTriple().isOSGenode(); + if (Arg *A = + Args.getLastArg(options::OPT_fsanitize_address_field_padding)) { + StringRef S = A->getValue(); +diff --git a/lib/Driver/ToolChains/Genode.cpp b/lib/Driver/ToolChains/Genode.cpp +new file mode 100644 +index 00000000000..ce2a494e61c +--- /dev/null ++++ b/lib/Driver/ToolChains/Genode.cpp +@@ -0,0 +1,133 @@ ++//===--- Genode.cpp - Genode ToolChain Implementations ----------*- C++ -*-===// ++// ++// The LLVM Compiler Infrastructure ++// ++// This file is distributed under the University of Illinois Open Source ++// License. See LICENSE.TXT for details. ++// ++//===----------------------------------------------------------------------===// ++ ++ ++#include "Genode.h" ++#include "InputInfo.h" ++#include "CommonArgs.h" ++#include "clang/Driver/Compilation.h" ++#include "clang/Driver/Driver.h" ++#include "clang/Driver/Options.h" ++#include "llvm/ADT/SmallString.h" ++#include "llvm/Option/ArgList.h" ++#include "llvm/Support/Path.h" ++ ++using namespace clang::driver; ++using namespace clang::driver::tools; ++using namespace clang::driver::toolchains; ++using namespace clang; ++using namespace llvm::opt; ++ ++void genode::Linker::ConstructJob(Compilation &C, const JobAction &JA, ++ const InputInfo &Output, ++ const InputInfoList &Inputs, ++ const llvm::opt::ArgList &Args, ++ const char *LinkingOutput) const { ++ const toolchains::Genode &ToolChain = ++ static_cast(getToolChain()); ++ const Driver &D = ToolChain.getDriver(); ++ const llvm::Triple::ArchType Arch = ToolChain.getArch(); ++ ArgStringList CmdArgs; ++ ++ if (!D.SysRoot.empty()) ++ CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); ++ ++ // Explicitly set the linker emulation for platforms that might not ++ // be the default emulation for the linker. ++ switch (Arch) { ++ case llvm::Triple::x86: ++ CmdArgs.push_back("-melf_i386"); ++ break; ++ case llvm::Triple::x86_64: ++ CmdArgs.push_back("-melf_x86_64"); ++ break; ++ case llvm::Triple::riscv32: ++ CmdArgs.push_back("-melf32lriscv"); ++ break; ++ case llvm::Triple::riscv64: ++ CmdArgs.push_back("-melf64lriscv"); ++ break; ++ default: ++ break; ++ } ++ ++ CmdArgs.push_back("--eh-frame-hdr"); ++ CmdArgs.push_back("--gc-sections"); ++ CmdArgs.push_back("-zmax-page-size=0x1000"); ++ ++ CmdArgs.push_back("-Ttext=0x01000000"); ++ ++ Args.AddAllArgs(CmdArgs, options::OPT_L); ++ ToolChain.AddFilePathLibArgs(Args, CmdArgs); ++ Args.AddAllArgs(CmdArgs, options::OPT_T_Group); ++ Args.AddAllArgs(CmdArgs, options::OPT_e); ++ Args.AddAllArgs(CmdArgs, options::OPT_s); ++ Args.AddAllArgs(CmdArgs, options::OPT_t); ++ Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); ++ ++ if (Args.hasArg(options::OPT_static)) { ++ CmdArgs.push_back("-Bstatic"); ++ } else { ++ CmdArgs.push_back(Args.MakeArgString("-T" + D.SysRoot + "/ld/genode_dyn.ld")); ++ CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + D.SysRoot + "/ld/genode_dyn.dl")); ++ CmdArgs.push_back("--dynamic-linker=ld.lib.so"); ++ if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { ++ CmdArgs.push_back("-l:ld.lib.so"); ++ } ++ } ++ ++ if (Output.isFilename()) { ++ CmdArgs.push_back("-o"); ++ CmdArgs.push_back(Output.getFilename()); ++ } else { ++ assert(Output.isNothing() && "Invalid output."); ++ } ++ ++ AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA); ++ ++ const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath()); ++ C.addCommand(std::make_unique(JA, *this, Exec, CmdArgs, Inputs)); ++} ++ ++Genode::Genode(const Driver &D, const llvm::Triple &Triple, ++ const llvm::opt::ArgList &Args) ++ : Generic_ELF(D, Triple, Args) { ++ SmallString<128> P(getDriver().Dir); ++ llvm::sys::path::append(P, "..", getTriple().str(), "lib"); ++ getFilePaths().push_back(P.str()); ++} ++ ++void Genode::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, ++ llvm::opt::ArgStringList &CC1Args) const { ++ SmallString<128> P(getDriver().Dir); ++ llvm::sys::path::append(P, "..", getTriple().str(), "include/c++/v1"); ++ addSystemInclude(DriverArgs, CC1Args, P.str()); ++} ++ ++bool Genode::isPIEDefault() const { ++ switch (getTriple().getArch()) { ++ case llvm::Triple::aarch64: ++ case llvm::Triple::x86_64: ++ return true; ++ default: ++ return false; ++ } ++} ++ ++SanitizerMask Genode::getSupportedSanitizers() const { ++ return Generic_ELF::getSupportedSanitizers(); ++} ++ ++SanitizerMask Genode::getDefaultSanitizers() const { ++ return Generic_ELF::getDefaultSanitizers(); ++} ++ ++Tool *Genode::buildLinker() const { ++ return new tools::genode::Linker(*this); ++} +diff --git a/lib/Driver/ToolChains/Genode.h b/lib/Driver/ToolChains/Genode.h +new file mode 100644 +index 00000000000..144f4f99abe +--- /dev/null ++++ b/lib/Driver/ToolChains/Genode.h +@@ -0,0 +1,69 @@ ++//===----- Genode.h - Genode ToolChain Implementations ----------*- C++ -*-===// ++// ++// The LLVM Compiler Infrastructure ++// ++// This file is distributed under the University of Illinois Open Source ++// License. See LICENSE.TXT for details. ++// ++//===----------------------------------------------------------------------===// ++ ++ ++#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GENODE_H ++#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GENODE_H ++ ++#include "Gnu.h" ++#include "clang/Driver/Tool.h" ++#include "clang/Driver/ToolChain.h" ++ ++namespace clang { ++namespace driver { ++namespace tools { ++ ++//// genode -- Directly call GNU Binutils linker ++namespace genode { ++class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { ++public: ++ Linker(const ToolChain &TC) : GnuTool("genode::Linker", "linker", TC) {} ++ ++ bool hasIntegratedCPP() const override { return false; } ++ bool isLinkJob() const override { return true; } ++ ++ void ConstructJob(Compilation &C, const JobAction &JA, ++ const InputInfo &Output, const InputInfoList &Inputss, ++ const llvm::opt::ArgList &Args, ++ const char *LinkingOutput) const override; ++}; ++} // end namespace genode ++} // end namespace tools ++ ++namespace toolchains { ++ ++class LLVM_LIBRARY_VISIBILITY Genode : public Generic_ELF { ++public: ++ Genode(const Driver &D, const llvm::Triple &Triple, ++ const llvm::opt::ArgList &Args); ++ bool HasNativeLLVMSupport() const override { return true; } ++ ++ bool IsMathErrnoDefault() const override { return true; } ++ ++ CXXStdlibType ++ GetCXXStdlibType(const llvm::opt::ArgList &Args) const override { ++ return ToolChain::CST_Libcxx; ++ } ++ void addLibCxxIncludePaths( ++ const llvm::opt::ArgList &DriverArgs, ++ llvm::opt::ArgStringList &CC1Args) const override; ++ ++ bool isPIEDefault() const override; ++ SanitizerMask getSupportedSanitizers() const override; ++ SanitizerMask getDefaultSanitizers() const override; ++ ++protected: ++ Tool *buildLinker() const override; ++}; ++ ++} // end namespace toolchains ++} // end namespace driver ++} // end namespace clang ++ ++#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GENODE_H +diff --git a/lib/Frontend/InitHeaderSearch.cpp b/lib/Frontend/InitHeaderSearch.cpp +index 5d877ee9c0d..01a33c1fa0d 100644 +--- a/lib/Frontend/InitHeaderSearch.cpp ++++ b/lib/Frontend/InitHeaderSearch.cpp +@@ -231,6 +231,7 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple, + case llvm::Triple::PS4: + case llvm::Triple::ELFIAMCU: + case llvm::Triple::Fuchsia: ++ case llvm::Triple::Genode: + break; + case llvm::Triple::Win32: + if (triple.getEnvironment() != llvm::Triple::Cygnus) +@@ -339,6 +340,7 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple, + case llvm::Triple::NaCl: + case llvm::Triple::ELFIAMCU: + case llvm::Triple::Fuchsia: ++ case llvm::Triple::Genode: + break; + case llvm::Triple::PS4: { + // gets prepended later in AddPath(). +diff --git a/test/Driver/genode.c b/test/Driver/genode.c +new file mode 100644 +index 00000000000..e69de29bb2d +diff --git a/test/Driver/genode.cpp b/test/Driver/genode.cpp +new file mode 100644 +index 00000000000..e69de29bb2d diff --git a/overlay/llvm-10/clang/purity.patch b/overlay/llvm-10/clang/purity.patch new file mode 100644 index 0000000..a6729a9 --- /dev/null +++ b/overlay/llvm-10/clang/purity.patch @@ -0,0 +1,30 @@ +From 4add81bba40dcec62c4ea4481be8e35ac53e89d8 Mon Sep 17 00:00:00 2001 +From: Will Dietz +Date: Thu, 18 May 2017 11:56:12 -0500 +Subject: [PATCH] "purity" patch for 5.0 + +--- + lib/Driver/ToolChains/Gnu.cpp | 7 ------- + 1 file changed, 7 deletions(-) + +diff --git a/lib/Driver/ToolChains/Gnu.cpp b/lib/Driver/ToolChains/Gnu.cpp +index fe3c0191bb..c6a482bece 100644 +--- a/lib/Driver/ToolChains/Gnu.cpp ++++ b/lib/Driver/ToolChains/Gnu.cpp +@@ -494,13 +494,6 @@ void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA, + if (!IsStatic) { + if (Args.hasArg(options::OPT_rdynamic)) + CmdArgs.push_back("-export-dynamic"); +- +- if (!Args.hasArg(options::OPT_shared) && !IsStaticPIE) { +- const std::string Loader = +- D.DyldPrefix + ToolChain.getDynamicLinker(Args); +- CmdArgs.push_back("-dynamic-linker"); +- CmdArgs.push_back(Args.MakeArgString(Loader)); +- } + } + + CmdArgs.push_back("-o"); +-- +2.11.0 + diff --git a/overlay/llvm-10/compiler-rt-codesign.patch b/overlay/llvm-10/compiler-rt-codesign.patch new file mode 100644 index 0000000..3cc12b9 --- /dev/null +++ b/overlay/llvm-10/compiler-rt-codesign.patch @@ -0,0 +1,33 @@ +From 3dec5f3475a26aeb4678627795c4b67c6b7b4785 Mon Sep 17 00:00:00 2001 +From: Will Dietz +Date: Tue, 19 Sep 2017 13:13:06 -0500 +Subject: [PATCH] remove codesign use on Apple, disable ios sim testing that + needs it + +--- + cmake/Modules/AddCompilerRT.cmake | 8 ------ + test/asan/CMakeLists.txt | 52 --------------------------------------- + test/tsan/CMakeLists.txt | 47 ----------------------------------- + 3 files changed, 107 deletions(-) + +diff --git a/cmake/Modules/AddCompilerRT.cmake b/cmake/Modules/AddCompilerRT.cmake +index bc5fb9ff7..b64eb4246 100644 +--- a/cmake/Modules/AddCompilerRT.cmake ++++ b/cmake/Modules/AddCompilerRT.cmake +@@ -210,14 +210,6 @@ function(add_compiler_rt_runtime name type) + set_target_properties(${libname} PROPERTIES IMPORT_PREFIX "") + set_target_properties(${libname} PROPERTIES IMPORT_SUFFIX ".lib") + endif() +- if(APPLE) +- # Ad-hoc sign the dylibs +- add_custom_command(TARGET ${libname} +- POST_BUILD +- COMMAND codesign --sign - $ +- WORKING_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR} +- ) +- endif() + endif() + install(TARGETS ${libname} + ARCHIVE DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR} +2.14.1 + diff --git a/overlay/llvm-10/compiler-rt-genode.patch b/overlay/llvm-10/compiler-rt-genode.patch new file mode 100644 index 0000000..51c0b68 --- /dev/null +++ b/overlay/llvm-10/compiler-rt-genode.patch @@ -0,0 +1,13 @@ +diff --git a/lib/builtins/assembly.h b/lib/builtins/assembly.h +index f437cb87f60..6406320aa69 100644 +--- a/lib/builtins/assembly.h ++++ b/lib/builtins/assembly.h +@@ -43,7 +43,7 @@ + #define CONST_SECTION .section .rodata + + #if defined(__GNU__) || defined(__FreeBSD__) || defined(__Fuchsia__) || \ +- defined(__linux__) ++ defined(__linux__) || defined(__GENODE__) + #define NO_EXEC_STACK_DIRECTIVE .section .note.GNU-stack,"",%progbits + #else + #define NO_EXEC_STACK_DIRECTIVE diff --git a/overlay/llvm-10/compiler-rt.nix b/overlay/llvm-10/compiler-rt.nix new file mode 100644 index 0000000..1a4403f --- /dev/null +++ b/overlay/llvm-10/compiler-rt.nix @@ -0,0 +1,74 @@ +{ stdenv, version, fetch, cmake, python3, llvm, libcxxabi }: +stdenv.mkDerivation rec { + pname = "compiler-rt"; + inherit version; + src = fetch pname "0x9c531k6ww21s2mkdwqx1vbdjmx6d4wmfb8gdbj0wqa796sczba"; + + nativeBuildInputs = [ cmake python3 llvm ]; + buildInputs = stdenv.lib.optional stdenv.hostPlatform.isDarwin libcxxabi; + + NIX_CFLAGS_COMPILE = [ + "-DSCUDO_DEFAULT_OPTIONS=DeleteSizeMismatch=0:DeallocationTypeMismatch=0" + ]; + + cmakeFlags = stdenv.lib.optionals (stdenv.hostPlatform.useLLVM or false) [ + "-DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON" + "-DCMAKE_C_COMPILER_TARGET=${stdenv.hostPlatform.config}" + "-DCMAKE_ASM_COMPILER_TARGET=${stdenv.hostPlatform.config}" + "-DCMAKE_C_FLAGS=-nodefaultlibs" + "-DCMAKE_CXX_COMPILER_WORKS=ON" + "-DCOMPILER_RT_BUILD_SANITIZERS=OFF" + "-DCOMPILER_RT_BUILD_XRAY=OFF" + "-DCOMPILER_RT_BUILD_LIBFUZZER=OFF" + "-DCOMPILER_RT_BUILD_PROFILE=OFF" + "-DCOMPILER_RT_BAREMETAL_BUILD=ON" + #https://stackoverflow.com/questions/53633705/cmake-the-c-compiler-is-not-able-to-compile-a-simple-test-program + "-DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY" + "-DCMAKE_SIZEOF_VOID_P=${toString (stdenv.hostPlatform.parsed.cpu.bits / 8)}" + ] ++ stdenv.lib.optionals stdenv.hostPlatform.isMusl [ + "-DCOMPILER_RT_BUILD_SANITIZERS=OFF" + "-DCOMPILER_RT_BUILD_XRAY=OFF" + "-DCOMPILER_RT_BUILD_LIBFUZZER=OFF" + "-DCOMPILER_RT_BUILD_PROFILE=OFF" + ] ++ stdenv.lib.optionals (stdenv.hostPlatform.parsed.kernel.name == "none") [ + "-DCOMPILER_RT_BAREMETAL_BUILD=ON" + "-DCOMPILER_RT_OS_DIR=baremetal" + ]; + + outputs = [ "out" "dev" ]; + + patches = [ + ./compiler-rt-codesign.patch # Revert compiler-rt commit that makes codesign mandatory + ./find-darwin-sdk-version.patch # don't test for macOS being >= 10.15 + ] ++ stdenv.lib.optional stdenv.targetPlatform.isGenode ./compiler-rt-genode.patch; + # ++ stdenv.lib.optional stdenv.hostPlatform.isMusl ./sanitizers-nongnu.patch; + + # TSAN requires XPC on Darwin, which we have no public/free source files for. We can depend on the Apple frameworks + # to get it, but they're unfree. Since LLVM is rather central to the stdenv, we patch out TSAN support so that Hydra + # can build this. If we didn't do it, basically the entire nixpkgs on Darwin would have an unfree dependency and we'd + # get no binary cache for the entire platform. If you really find yourself wanting the TSAN, make this controllable by + # a flag and turn the flag off during the stdenv build. + postPatch = stdenv.lib.optionalString stdenv.isDarwin '' + substituteInPlace cmake/config-ix.cmake \ + --replace 'set(COMPILER_RT_HAS_TSAN TRUE)' 'set(COMPILER_RT_HAS_TSAN FALSE)' + '' + stdenv.lib.optionalString (stdenv.hostPlatform.useLLVM or false) '' + substituteInPlace lib/builtins/int_util.c \ + --replace "#include " "" + substituteInPlace lib/builtins/clear_cache.c \ + --replace "#include " "" + substituteInPlace lib/builtins/cpu_model.c \ + --replace "#include " "" + ''; + + # Hack around weird upsream RPATH bug + postInstall = stdenv.lib.optionalString (stdenv.hostPlatform.isDarwin || stdenv.hostPlatform.isWasm) '' + ln -s "$out/lib"/*/* "$out/lib" + '' + stdenv.lib.optionalString (stdenv.hostPlatform.useLLVM or false) '' + ln -s $out/lib/*/clang_rt.crtbegin-*.o $out/lib/crtbegin.o + ln -s $out/lib/*/clang_rt.crtend-*.o $out/lib/crtend.o + ln -s $out/lib/*/clang_rt.crtbegin_shared-*.o $out/lib/crtbeginS.o + ln -s $out/lib/*/clang_rt.crtend_shared-*.o $out/lib/crtendS.o + ''; + + enableParallelBuilding = true; +} diff --git a/overlay/llvm-10/default.nix b/overlay/llvm-10/default.nix new file mode 100644 index 0000000..8011718 --- /dev/null +++ b/overlay/llvm-10/default.nix @@ -0,0 +1,209 @@ +{ lowPrio, newScope, pkgs, stdenv, cmake, libstdcxxHook +, libxml2, python3, isl, fetchurl, overrideCC, wrapCCWith, wrapBintoolsWith +, buildLlvmTools # tools, but from the previous stage, for cross +, targetLlvmLibraries # libraries, but from the next stage, for cross +, genodeBase +}: + +let + release_version = "10.0.0"; + version = release_version; # differentiating these (variables) is important for rc's + + fetch = name: sha256: fetchurl { + url = "https://github.com/llvm/llvm-project/releases/download/llvmorg-${release_version}/${name}-${version}.src.tar.xz"; + inherit sha256; + }; + + clang-tools-extra_src = fetch "clang-tools-extra" "074ija5s2jsdn0k035r2dzmryjmqxdnyg4xwvaqych2bazv8rpxc"; + + tools = stdenv.lib.makeExtensible (tools: let + callPackage = newScope (tools // { inherit stdenv cmake libxml2 python3 isl release_version version fetch; }); + mkExtraBuildCommands = cc: '' + rsrc="$out/resource-root" + mkdir "$rsrc" + ln -s "${cc}/lib/clang/${release_version}/include" "$rsrc" + ln -s "${targetLlvmLibraries.compiler-rt.out}/lib" "$rsrc/lib" + echo "-resource-dir=$rsrc" >> $out/nix-support/cc-cflags + '' + stdenv.lib.optionalString (stdenv.targetPlatform.isLinux && tools.clang-unwrapped ? gcc && !(stdenv.targetPlatform.useLLVM or false)) '' + echo "--gcc-toolchain=${tools.clang-unwrapped.gcc}" >> $out/nix-support/cc-cflags + ''; + in { + + llvm = callPackage ./llvm.nix { }; + + clang-unwrapped = callPackage ./clang { + inherit (tools) lld; + inherit clang-tools-extra_src; + }; + + llvm-manpages = lowPrio (tools.llvm.override { + enableManpages = true; + python3 = pkgs.python3; # don't use python-boot + }); + + clang-manpages = lowPrio (tools.clang-unwrapped.override { + enableManpages = true; + python3 = pkgs.python3; # don't use python-boot + }); + + lldb-manpages = lowPrio (tools.lldb.override { + enableManpages = true; + python3 = pkgs.python3; # don't use python-boot + }); + + libclang = tools.clang-unwrapped.lib; + + clang = if stdenv.cc.isGNU then tools.libstdcxxClang else tools.libcxxClang; + + libstdcxxClang = wrapCCWith rec { + cc = tools.clang-unwrapped; + extraPackages = [ + libstdcxxHook + targetLlvmLibraries.compiler-rt + ]; + extraBuildCommands = mkExtraBuildCommands cc; + }; + + libcxxClang = wrapCCWith rec { + cc = tools.clang-unwrapped; + libcxx = targetLlvmLibraries.libcxx; + extraPackages = [ + targetLlvmLibraries.libcxx + targetLlvmLibraries.libcxxabi + targetLlvmLibraries.compiler-rt + ]; + extraBuildCommands = mkExtraBuildCommands cc; + }; + + lld = callPackage ./lld.nix {}; + + lldb = callPackage ./lldb.nix {}; + + # Below, is the LLVM bootstrapping logic. It handles building a + # fully LLVM toolchain from scratch. No GCC toolchain should be + # pulled in. As a consequence, it is very quick to build different + # targets provided by LLVM and we can also build for what GCC + # doesn’t support like LLVM. Probably we should move to some other + # file. + + bintools = callPackage ./bintools.nix {}; + + lldClang = wrapCCWith rec { + cc = tools.clang-unwrapped; + libcxx = targetLlvmLibraries.libcxx; + bintools = wrapBintoolsWith { + inherit (tools) bintools; + }; + extraPackages = [ + targetLlvmLibraries.libcxx + targetLlvmLibraries.libcxxabi + targetLlvmLibraries.compiler-rt + ] ++ stdenv.lib.optionals (!stdenv.targetPlatform.isWasm) [ + targetLlvmLibraries.libunwind + ]; + extraBuildCommands = '' + echo "-target ${stdenv.targetPlatform.config}" >> $out/nix-support/cc-cflags + echo "-rtlib=compiler-rt -Wno-unused-command-line-argument" >> $out/nix-support/cc-cflags + echo "-B${targetLlvmLibraries.compiler-rt}/lib" >> $out/nix-support/cc-cflags + '' + stdenv.lib.optionalString (!stdenv.targetPlatform.isWasm) '' + echo "--unwindlib=libunwind" >> $out/nix-support/cc-cflags + '' + stdenv.lib.optionalString stdenv.targetPlatform.isWasm '' + echo "-fno-exceptions" >> $out/nix-support/cc-cflags + '' + mkExtraBuildCommands cc + + stdenv.lib.optionalString stdenv.targetPlatform.isGenode '' + echo "-I${genodeBase}/include" >> $out/nix-support/cc-cflags + echo "--sysroot=${genodeBase}" >> $out/nix-support/cc-cflags + echo "-L ${genodeBase}" >> $out/nix-support/cc-cflags + ''; + }; + + lldClangNoLibcxx = wrapCCWith rec { + cc = tools.clang-unwrapped; + libcxx = null; + bintools = wrapBintoolsWith { + inherit (tools) bintools; + }; + extraPackages = [ + targetLlvmLibraries.compiler-rt + ]; + extraBuildCommands = '' + echo "-target ${stdenv.targetPlatform.config}" >> $out/nix-support/cc-cflags + echo "-rtlib=compiler-rt" >> $out/nix-support/cc-cflags + echo "-B${targetLlvmLibraries.compiler-rt}/lib" >> $out/nix-support/cc-cflags + echo "-nostdlib++" >> $out/nix-support/cc-cflags + '' + mkExtraBuildCommands cc + + stdenv.lib.optionalString stdenv.targetPlatform.isGenode '' + echo "--sysroot=${genodeBase}" >> $out/nix-support/cc-cflags + echo "-L ${genodeBase}" >> $out/nix-support/cc-cflags + ''; + }; + + lldClangNoLibc = wrapCCWith rec { + cc = tools.clang-unwrapped; + libcxx = null; + bintools = wrapBintoolsWith { + inherit (tools) bintools; + libc = null; + }; + extraPackages = [ + targetLlvmLibraries.compiler-rt + ]; + extraBuildCommands = '' + echo "-target ${stdenv.targetPlatform.config}" >> $out/nix-support/cc-cflags + echo "-rtlib=compiler-rt" >> $out/nix-support/cc-cflags + echo "-B${targetLlvmLibraries.compiler-rt}/lib" >> $out/nix-support/cc-cflags + '' + mkExtraBuildCommands cc + stdenv.lib.optionalString stdenv.targetPlatform.isGenode '' + echo "--sysroot=${genodeBase}" >> $out/nix-support/cc-cflags + ''; + }; + + lldClangNoCompilerRt = wrapCCWith { + cc = tools.clang-unwrapped; + libcxx = null; + bintools = wrapBintoolsWith { + inherit (tools) bintools; + libc = null; + }; + extraPackages = [ ]; + extraBuildCommands = '' + echo "-nostartfiles" >> $out/nix-support/cc-cflags + echo "-target ${stdenv.targetPlatform.config}" >> $out/nix-support/cc-cflags + ''; + }; + + }); + + libraries = stdenv.lib.makeExtensible (libraries: let + callPackage = newScope (libraries // buildLlvmTools // { inherit stdenv cmake libxml2 python3 isl release_version version fetch; }); + in { + + compiler-rt = callPackage ./compiler-rt.nix ({} // + (stdenv.lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) { + stdenv = overrideCC stdenv buildLlvmTools.lldClangNoCompilerRt; + })); + + stdenv = overrideCC stdenv buildLlvmTools.clang; + + libcxxStdenv = overrideCC stdenv buildLlvmTools.libcxxClang; + + libcxx = callPackage ./libc++ ({} // + (stdenv.lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) { + stdenv = overrideCC stdenv buildLlvmTools.lldClangNoLibcxx; + })); + + libcxxabi = callPackage ./libc++abi.nix ({} // + (stdenv.lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) { + stdenv = overrideCC stdenv buildLlvmTools.lldClangNoLibcxx; + libunwind = libraries.libunwind; + })); + + openmp = callPackage ./openmp.nix {}; + + libunwind = callPackage ./libunwind.nix ({} // + (stdenv.lib.optionalAttrs (stdenv.hostPlatform.useLLVM or false) { + stdenv = overrideCC stdenv buildLlvmTools.lldClangNoLibcxx; + })); + + }); + +in { inherit tools libraries; } // libraries // tools diff --git a/overlay/llvm-10/find-darwin-sdk-version.patch b/overlay/llvm-10/find-darwin-sdk-version.patch new file mode 100644 index 0000000..fc16ddd --- /dev/null +++ b/overlay/llvm-10/find-darwin-sdk-version.patch @@ -0,0 +1,62 @@ +--- a/cmake/Modules/CompilerRTDarwinUtils.cmake 2020-01-25 23:13:55.000000000 +0100 ++++ b/cmake/Modules/CompilerRTDarwinUtils.cmake 2020-01-25 23:19:37.000000000 +0100 +@@ -43,41 +43,6 @@ + set(DARWIN_${sdk_name}_CACHED_SYSROOT ${var_internal} CACHE STRING "Darwin SDK path for SDK ${sdk_name}." FORCE) + endfunction() + +-function(find_darwin_sdk_version var sdk_name) +- # We deliberately don't cache the result here because +- # CMake's caching causes too many problems. +- set(result_process 1) +- if(NOT DARWIN_PREFER_PUBLIC_SDK) +- # Let's first try the internal SDK, otherwise use the public SDK. +- execute_process( +- COMMAND xcrun --sdk ${sdk_name}.internal --show-sdk-version +- RESULT_VARIABLE result_process +- OUTPUT_VARIABLE var_internal +- OUTPUT_STRIP_TRAILING_WHITESPACE +- ERROR_FILE /dev/null +- ) +- endif() +- if((NOT ${result_process} EQUAL 0) OR "" STREQUAL "${var_internal}") +- execute_process( +- COMMAND xcrun --sdk ${sdk_name} --show-sdk-version +- RESULT_VARIABLE result_process +- OUTPUT_VARIABLE var_internal +- OUTPUT_STRIP_TRAILING_WHITESPACE +- ERROR_FILE /dev/null +- ) +- endif() +- if(NOT result_process EQUAL 0) +- message(FATAL_ERROR +- "Failed to determine SDK version for \"${sdk_name}\" SDK") +- endif() +- # Check reported version looks sane. +- if (NOT "${var_internal}" MATCHES "^[0-9]+\\.[0-9]+(\\.[0-9]+)?$") +- message(FATAL_ERROR +- "Reported SDK version \"${var_internal}\" does not look like a version") +- endif() +- set(${var} ${var_internal} PARENT_SCOPE) +-endfunction() +- + # There isn't a clear mapping of what architectures are supported with a given + # target platform, but ld's version output does list the architectures it can + # link for. +@@ -119,17 +84,6 @@ + foreach(flag ${DARWIN_${os}_LINK_FLAGS}) + set(os_linker_flags "${os_linker_flags} ${flag}") + endforeach() +- +- # Disable building for i386 for macOS SDK >= 10.15. The SDK doesn't support +- # linking for i386 and the corresponding OS doesn't allow running macOS i386 +- # binaries. +- if ("${os}" STREQUAL "osx") +- find_darwin_sdk_version(macosx_sdk_version "macosx") +- if ("${macosx_sdk_version}" VERSION_GREATER 10.15 OR "${macosx_sdk_version}" VERSION_EQUAL 10.15) +- message(STATUS "Disabling i386 slice for ${valid_archs}") +- list(REMOVE_ITEM archs "i386") +- endif() +- endif() + endif() + + # The simple program will build for x86_64h on the simulator because it is diff --git a/overlay/llvm-10/libc++/default.nix b/overlay/llvm-10/libc++/default.nix new file mode 100644 index 0000000..f0c4475 --- /dev/null +++ b/overlay/llvm-10/libc++/default.nix @@ -0,0 +1,58 @@ +{ lib, stdenv, fetch, cmake, python3, libcxxabi, fixDarwinDylibNames, version +, enableShared ? true }: + +stdenv.mkDerivation { + pname = "libc++"; + inherit version; + + src = fetch "libcxx" "1isnj78diknh0nvd73mlq8p8g209f9bab2mbysq826bg2wzql3r7"; + + postUnpack = '' + unpackFile ${libcxxabi.src} + export LIBCXXABI_INCLUDE_DIR="$PWD/$(ls -d libcxxabi-${version}*)/include" + ''; + + patches = stdenv.lib.optional stdenv.hostPlatform.isMusl + ../../libcxx-0001-musl-hacks.patch + ++ stdenv.lib.optional stdenv.targetPlatform.isGenode + ../libcxx-genode.patch; + + preConfigure = '' + # Get headers from the cxxabi source so we can see private headers not installed by the cxxabi package + cmakeFlagsArray=($cmakeFlagsArray -DLIBCXX_CXX_ABI_INCLUDE_PATHS="$LIBCXXABI_INCLUDE_DIR") + '' + lib.optionalString stdenv.hostPlatform.isMusl '' + patchShebangs utils/cat_files.py + ''; + nativeBuildInputs = [ cmake ] + ++ stdenv.lib.optional (stdenv.hostPlatform.isMusl || stdenv.hostPlatform.isWasi) python3; + + buildInputs = [ libcxxabi ] ++ lib.optional stdenv.isDarwin fixDarwinDylibNames; + + cmakeFlags = [ + "-DLIBCXX_LIBCXXABI_LIB_PATH=${libcxxabi}/lib" + "-DLIBCXX_LIBCPPABI_VERSION=2" + "-DLIBCXX_CXX_ABI=libcxxabi" + ] ++ stdenv.lib.optional (stdenv.hostPlatform.isMusl || stdenv.hostPlatform.isWasi) "-DLIBCXX_HAS_MUSL_LIBC=1" + ++ stdenv.lib.optional (stdenv.hostPlatform.useLLVM or false) "-DLIBCXX_USE_COMPILER_RT=ON" + ++ stdenv.lib.optional stdenv.hostPlatform.isWasm [ + "-DLIBCXX_ENABLE_THREADS=OFF" + "-DLIBCXX_ENABLE_FILESYSTEM=OFF" + "-DLIBCXX_ENABLE_EXCEPTIONS=OFF" + ] ++ stdenv.lib.optional (!enableShared) "-DLIBCXX_ENABLE_SHARED=OFF"; + + enableParallelBuilding = true; + + linkCxxAbi = stdenv.isLinux; + + setupHooks = [ + ./role.bash + ./setup-hook.sh + ]; + + meta = { + homepage = http://libcxx.llvm.org/; + description = "A new implementation of the C++ standard library, targeting C++11"; + license = with stdenv.lib.licenses; [ ncsa mit ]; + platforms = stdenv.lib.platforms.all; + }; +} diff --git a/overlay/llvm-10/libc++/role.bash b/overlay/llvm-10/libc++/role.bash new file mode 100644 index 0000000..6f1c36f --- /dev/null +++ b/overlay/llvm-10/libc++/role.bash @@ -0,0 +1,75 @@ +# Since the same derivation can be depend on in multiple ways, we need to +# accumulate *each* role (i.e. host and target platforms relative the depending +# derivation) in which the derivation is used. +# +# The role is intened to be use as part of other variables names like +# - $NIX_${role_pre}_SOMETHING +# - $NIX_SOMETHING_${role_post} + +function getRole() { + case $1 in + -1) + role_pre='BUILD_' + role_post='_FOR_BUILD' + ;; + 0) + role_pre='' + role_post='' + ;; + 1) + role_pre='TARGET_' + role_post='_FOR_TARGET' + ;; + *) + echo "@name@: used as improper sort of dependency" >2 + return 1 + ;; + esac +} + +# `hostOffset` describes how the host platform of the package is slid relative +# to the depending package. `targetOffset` likewise describes the target +# platform of the package. Both are brought into scope of the setup hook defined +# for dependency whose setup hook is being processed relative to the package +# being built. + +function getHostRole() { + getRole "$hostOffset" +} +function getTargetRole() { + getRole "$targetOffset" +} + +# `depHostOffset` describes how the host platform of the dependencies are slid +# relative to the depending package. `depTargetOffset` likewise describes the +# target platform of dependenices. Both are brought into scope of the +# environment hook defined for the dependency being applied relative to the +# package being built. + +function getHostRoleEnvHook() { + getRole "$depHostOffset" +} +function getTargetRoleEnvHook() { + getRole "$depTargetOffset" +} + +# This variant is inteneded specifically for code-prodocing tool wrapper scripts +# `NIX_@wrapperName@_@infixSalt@_TARGET_*` tracks this (needs to be an exported +# env var so can't use fancier data structures). +function getTargetRoleWrapper() { + case $targetOffset in + -1) + export NIX_@wrapperName@_@infixSalt@_TARGET_BUILD=1 + ;; + 0) + export NIX_@wrapperName@_@infixSalt@_TARGET_HOST=1 + ;; + 1) + export NIX_@wrapperName@_@infixSalt@_TARGET_TARGET=1 + ;; + *) + echo "@name@: used as improper sort of dependency" >2 + return 1 + ;; + esac +} diff --git a/overlay/llvm-10/libc++/setup-hook.sh b/overlay/llvm-10/libc++/setup-hook.sh new file mode 100644 index 0000000..6611259 --- /dev/null +++ b/overlay/llvm-10/libc++/setup-hook.sh @@ -0,0 +1,6 @@ +# See pkgs/build-support/setup-hooks/role.bash +getHostRole + +linkCxxAbi="@linkCxxAbi@" +export NIX_${role_pre}CXXSTDLIB_COMPILE+=" -isystem @out@/include/c++/v1" +export NIX_${role_pre}CXXSTDLIB_LINK=" -stdlib=libc++${linkCxxAbi:+" -lc++abi"}" diff --git a/overlay/llvm-10/libc++abi.nix b/overlay/llvm-10/libc++abi.nix new file mode 100644 index 0000000..b58c12b --- /dev/null +++ b/overlay/llvm-10/libc++abi.nix @@ -0,0 +1,67 @@ +{ stdenv, cmake, fetch, libcxx, libunwind, llvm, version +, enableShared ? true }: + +stdenv.mkDerivation { + pname = "libc++abi"; + inherit version; + + src = fetch "libcxxabi" "1q8lrbh68a9v4lr88b8xsjpmwx5z96sa5wnkb92xx7ccm1ssq6z7"; + + nativeBuildInputs = [ cmake ]; + buildInputs = stdenv.lib.optional (!stdenv.isDarwin && !stdenv.isFreeBSD && !stdenv.hostPlatform.isWasm) libunwind; + + cmakeFlags = stdenv.lib.optionals (stdenv.hostPlatform.useLLVM or false) [ + "-DLLVM_ENABLE_LIBCXX=ON" + "-DLIBCXXABI_USE_LLVM_UNWINDER=ON" + ] ++ stdenv.lib.optionals stdenv.hostPlatform.isWasm [ + "-DLIBCXXABI_ENABLE_THREADS=OFF" + "-DLIBCXXABI_ENABLE_EXCEPTIONS=OFF" + ] ++ stdenv.lib.optionals (!enableShared) [ + "-DLIBCXXABI_ENABLE_SHARED=OFF" + ]; + + patches = [ ./libcxxabi-no-threads.patch ]; + + postUnpack = '' + unpackFile ${libcxx.src} + unpackFile ${llvm.src} + cmakeFlags+=" -DLLVM_PATH=$PWD/$(ls -d llvm-*) -DLIBCXXABI_LIBCXX_PATH=$PWD/$(ls -d libcxx-*)" + '' + stdenv.lib.optionalString stdenv.isDarwin '' + export TRIPLE=x86_64-apple-darwin + '' + stdenv.lib.optionalString stdenv.hostPlatform.isMusl '' + patch -p1 -d $(ls -d libcxx-*) -i ${../libcxx-0001-musl-hacks.patch} + '' + stdenv.lib.optionalString stdenv.hostPlatform.isWasm '' + patch -p1 -d $(ls -d llvm-*) -i ${./libcxxabi-wasm.patch} + ''; + + installPhase = if stdenv.isDarwin + then '' + for file in lib/*.dylib; do + # this should be done in CMake, but having trouble figuring out + # the magic combination of necessary CMake variables + # if you fancy a try, take a look at + # http://www.cmake.org/Wiki/CMake_RPATH_handling + install_name_tool -id $out/$file $file + done + make install + install -d 755 $out/include + install -m 644 ../include/*.h $out/include + '' + else '' + install -d -m 755 $out/include $out/lib + install -m 644 lib/libc++abi.a $out/lib + install -m 644 ../include/cxxabi.h $out/include + '' + stdenv.lib.optionalString enableShared '' + install -m 644 lib/libc++abi.so.1.0 $out/lib + ln -s libc++abi.so.1.0 $out/lib/libc++abi.so + ln -s libc++abi.so.1.0 $out/lib/libc++abi.so.1 + ''; + + meta = { + homepage = http://libcxxabi.llvm.org/; + description = "A new implementation of low level support for a standard C++ library"; + license = with stdenv.lib.licenses; [ ncsa mit ]; + maintainers = with stdenv.lib.maintainers; [ vlstill ]; + platforms = stdenv.lib.platforms.all; + }; +} diff --git a/overlay/llvm-10/libcxx-genode.patch b/overlay/llvm-10/libcxx-genode.patch new file mode 100644 index 0000000..2309f79 --- /dev/null +++ b/overlay/llvm-10/libcxx-genode.patch @@ -0,0 +1,26 @@ +diff --git a/include/__config b/include/__config +index ccce227f4d6..b3fda04b53d 100644 +--- a/include/__config ++++ b/include/__config +@@ -1126,6 +1126,8 @@ _LIBCPP_FUNC_VIS extern "C" void __sanitizer_annotate_contiguous_container( + # define _LIBCPP_HAS_THREAD_API_PTHREAD + # elif defined(__Fuchsia__) + # define _LIBCPP_HAS_THREAD_API_C11 ++# elif defined(__Genode__) ++# define _LIBCPP_HAS_NO_THREADS + # elif defined(_LIBCPP_WIN32API) + # define _LIBCPP_HAS_THREAD_API_WIN32 + # else +diff --git a/utils/google-benchmark/src/internal_macros.h b/utils/google-benchmark/src/internal_macros.h +index 5dbf4fd2752..4699c5ed913 100644 +--- a/utils/google-benchmark/src/internal_macros.h ++++ b/utils/google-benchmark/src/internal_macros.h +@@ -70,6 +70,8 @@ + #define BENCHMARK_OS_FUCHSIA 1 + #elif defined (__SVR4) && defined (__sun) + #define BENCHMARK_OS_SOLARIS 1 ++#elif defined(__GENODE__) ++ #define BENCHMARK_OS_GENODE 1 + #endif + + #if defined(__ANDROID__) && defined(__GLIBCXX__) diff --git a/overlay/llvm-10/libcxxabi-no-threads.patch b/overlay/llvm-10/libcxxabi-no-threads.patch new file mode 100644 index 0000000..787f3e1 --- /dev/null +++ b/overlay/llvm-10/libcxxabi-no-threads.patch @@ -0,0 +1,12 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 4138acf..41b4763 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -362,6 +362,7 @@ if (NOT LIBCXXABI_ENABLE_THREADS) + " is also set to ON.") + endif() + add_definitions(-D_LIBCXXABI_HAS_NO_THREADS) ++ add_definitions(-D_LIBCPP_HAS_NO_THREADS) + endif() + + if (LIBCXXABI_HAS_EXTERNAL_THREAD_API) diff --git a/overlay/llvm-10/libcxxabi-wasm.patch b/overlay/llvm-10/libcxxabi-wasm.patch new file mode 100644 index 0000000..4ebfe46 --- /dev/null +++ b/overlay/llvm-10/libcxxabi-wasm.patch @@ -0,0 +1,16 @@ +diff --git a/cmake/modules/HandleLLVMOptions.cmake b/cmake/modules/HandleLLVMOptions.cmake +index 15497d405e0..33f7f18193a 100644 +--- a/cmake/modules/HandleLLVMOptions.cmake ++++ b/cmake/modules/HandleLLVMOptions.cmake +@@ -127,7 +127,10 @@ else(WIN32) + set(LLVM_HAVE_LINK_VERSION_SCRIPT 1) + endif() + else(FUCHSIA OR UNIX) +- MESSAGE(SEND_ERROR "Unable to determine platform") ++ if(${CMAKE_SYSTEM_NAME} MATCHES "Wasi") ++ else() ++ MESSAGE(SEND_ERROR "Unable to determine platform") ++ endif() + endif(FUCHSIA OR UNIX) + endif(WIN32) + diff --git a/overlay/llvm-10/libunwind-genode.patch b/overlay/llvm-10/libunwind-genode.patch new file mode 100644 index 0000000..95b1291 --- /dev/null +++ b/overlay/llvm-10/libunwind-genode.patch @@ -0,0 +1,13 @@ +diff --git a/src/assembly.h b/src/assembly.h +index 7132b6c561b..764addcc0f8 100644 +--- a/src/assembly.h ++++ b/src/assembly.h +@@ -80,7 +80,7 @@ + SYMBOL_NAME(aliasname) = SYMBOL_NAME(name) + + #if defined(__GNU__) || defined(__FreeBSD__) || defined(__Fuchsia__) || \ +- defined(__linux__) ++ defined(__linux__) || defined(__GENODE__) + #define NO_EXEC_STACK_DIRECTIVE .section .note.GNU-stack,"",%progbits + #else + #define NO_EXEC_STACK_DIRECTIVE diff --git a/overlay/llvm-10/libunwind.nix b/overlay/llvm-10/libunwind.nix new file mode 100644 index 0000000..4e55b28 --- /dev/null +++ b/overlay/llvm-10/libunwind.nix @@ -0,0 +1,14 @@ +{ stdenv, version, fetch, cmake, fetchpatch, enableShared ? true }: + +stdenv.mkDerivation rec { + pname = "libunwind"; + inherit version; + + src = fetch pname "09n66dl9cc17d81qflj5h1l4garmhvzfi2lhcb7rx00l8z65xp09"; + + nativeBuildInputs = [ cmake ]; + + enableParallelBuilding = true; + + cmakeFlags = stdenv.lib.optional (!enableShared) "-DLIBUNWIND_ENABLE_SHARED=OFF"; +} diff --git a/overlay/llvm-10/lld.nix b/overlay/llvm-10/lld.nix new file mode 100644 index 0000000..4bde3d7 --- /dev/null +++ b/overlay/llvm-10/lld.nix @@ -0,0 +1,33 @@ +{ stdenv +, fetch +, cmake +, libxml2 +, llvm +, version +}: + +stdenv.mkDerivation rec { + pname = "lld"; + inherit version; + + src = fetch pname "026pwcbczcg0j5c9h7hxxrn3ki81ia9m9sfn0sy0bvzffv2xg85r"; + + nativeBuildInputs = [ cmake ]; + buildInputs = [ llvm libxml2 ]; + + outputs = [ "out" "dev" ]; + + enableParallelBuilding = true; + + postInstall = '' + moveToOutput include "$dev" + moveToOutput lib "$dev" + ''; + + meta = { + description = "The LLVM Linker"; + homepage = http://lld.llvm.org/; + license = stdenv.lib.licenses.ncsa; + platforms = stdenv.lib.platforms.all; + }; +} diff --git a/overlay/llvm-10/lldb-procfs.patch b/overlay/llvm-10/lldb-procfs.patch new file mode 100644 index 0000000..b075dba --- /dev/null +++ b/overlay/llvm-10/lldb-procfs.patch @@ -0,0 +1,31 @@ +--- a/source/Plugins/Process/Linux/Procfs.h ++++ b/source/Plugins/Process/Linux/Procfs.h +@@ -11,21 +11,12 @@ + // sys/procfs.h on Android/Linux for all supported architectures. + + #include ++#include + +-#ifdef __ANDROID__ +-#if defined(__arm64__) || defined(__aarch64__) +-typedef unsigned long elf_greg_t; +-typedef elf_greg_t +- elf_gregset_t[(sizeof(struct user_pt_regs) / sizeof(elf_greg_t))]; +-typedef struct user_fpsimd_state elf_fpregset_t; +-#ifndef NT_FPREGSET +-#define NT_FPREGSET NT_PRFPREG +-#endif // NT_FPREGSET +-#elif defined(__mips__) +-#ifndef NT_FPREGSET +-#define NT_FPREGSET NT_PRFPREG +-#endif // NT_FPREGSET +-#endif +-#else // __ANDROID__ ++#if !defined(__GLIBC__) && defined(__powerpc__) ++#define pt_regs musl_pt_regs ++#include ++#undef pt_regs ++#else + #include +-#endif // __ANDROID__ ++#endif diff --git a/overlay/llvm-10/lldb.nix b/overlay/llvm-10/lldb.nix new file mode 100644 index 0000000..46c991d --- /dev/null +++ b/overlay/llvm-10/lldb.nix @@ -0,0 +1,101 @@ +{ stdenv +, fetch +, cmake +, zlib +, ncurses +, swig +, which +, libedit +, libxml2 +, llvm +, clang-unwrapped +, python3 +, version +, darwin +, lit +, enableManpages ? false +}: + +stdenv.mkDerivation (rec { + pname = "lldb"; + inherit version; + + src = fetch pname "0ddikvc0kbqlqvsypsm9nhfwmyw4prp4rv49f0bgacyh5ssgq7yx"; + + patches = [ ./lldb-procfs.patch ]; + + nativeBuildInputs = [ cmake python3 which swig lit ] + ++ stdenv.lib.optionals enableManpages [ python3.pkgs.sphinx python3.pkgs.recommonmark ]; + + buildInputs = [ + ncurses + zlib + libedit + libxml2 + llvm + ] + ++ stdenv.lib.optionals stdenv.isDarwin [ + darwin.libobjc + darwin.apple_sdk.libs.xpc + darwin.apple_sdk.frameworks.Foundation + darwin.bootstrap_cmds + darwin.apple_sdk.frameworks.Carbon + darwin.apple_sdk.frameworks.Cocoa + ]; + + CXXFLAGS = "-fno-rtti"; + hardeningDisable = [ "format" ]; + + cmakeFlags = [ + "-DLLDB_CODESIGN_IDENTITY=" # codesigning makes nondeterministic + "-DClang_DIR=${clang-unwrapped}/lib/cmake" + "-DLLVM_EXTERNAL_LIT=${lit}/bin/lit" + ] ++ stdenv.lib.optionals stdenv.isDarwin [ + "-DLLDB_USE_SYSTEM_DEBUGSERVER=ON" + ] ++ stdenv.lib.optionals enableManpages [ + "-DLLVM_ENABLE_SPHINX=ON" + "-DSPHINX_OUTPUT_MAN=ON" + "-DSPHINX_OUTPUT_HTML=OFF" + ] +; + + enableParallelBuilding = true; + + postInstall = '' + # Editor support + # vscode: + install -D ../tools/lldb-vscode/package.json $out/share/vscode/extensions/llvm-org.lldb-vscode-0.1.0/package.json + mkdir -p $out/share/vscode/extensions/llvm-org.lldb-vscode-0.1.0/bin + ln -s $out/bin/lldb-vscode $out/share/vscode/extensions/llvm-org.lldb-vscode-0.1.0/bin + ''; + + meta = with stdenv.lib; { + description = "A next-generation high-performance debugger"; + homepage = http://lldb.llvm.org; + license = licenses.ncsa; + platforms = platforms.all; + }; +} // stdenv.lib.optionalAttrs enableManpages { + pname = "lldb-manpages"; + + buildPhase = '' + make docs-lldb-man + ''; + + propagatedBuildInputs = []; + + installPhase = '' + # manually install lldb man page + mkdir -p $out/share/man/man1 + install docs/man/lldb.1 -t $out/share/man/man1/ + ''; + + postPatch = null; + postInstall = null; + + outputs = [ "out" ]; + + doCheck = false; + + meta.description = "man pages for LLDB ${version}"; +}) diff --git a/overlay/llvm-10/llvm-extension-handling.patch b/overlay/llvm-10/llvm-extension-handling.patch new file mode 100644 index 0000000..cf4b1ea --- /dev/null +++ b/overlay/llvm-10/llvm-extension-handling.patch @@ -0,0 +1,146 @@ +Compressed diff from +``` +git show d21664cce1db8debe2528f36b1fbd2b8af9c9401 87dac7da68ea1e0adac78c59ef1891dcf9632b67 3a0f6e699bb6d96dc62dce6faef20ac26cf103fd +``` +with the purpose of avoiding linker errors arising in the polly-flavoured clang. + +diff --git a/llvm/CMakeLists.txt b/llvm/CMakeLists.txt +index a02c2a5a23f..faf8f561faa 100644 +--- llvm/CMakeLists.txt ++++ llvm/CMakeLists.txt +@@ -1069,6 +1069,7 @@ endif() + # after all targets are created. + include(LLVMDistributionSupport) + llvm_distribution_add_targets() ++process_llvm_pass_plugins(GEN_CONFIG) + + # This allows us to deploy the Universal CRT DLLs by passing -DCMAKE_INSTALL_UCRT_LIBRARIES=ON to CMake + if (MSVC AND CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows" AND CMAKE_INSTALL_UCRT_LIBRARIES) +@@ -1093,5 +1094,3 @@ endif() + if (LLVM_INCLUDE_UTILS AND LLVM_INCLUDE_TOOLS) + add_subdirectory(utils/llvm-locstats) + endif() +- +-process_llvm_pass_plugins() +diff --git a/llvm/cmake/modules/AddLLVM.cmake b/llvm/cmake/modules/AddLLVM.cmake +index fd69786544a..8fbb33a22fd 100644 +--- llvm/cmake/modules/AddLLVM.cmake ++++ llvm/cmake/modules/AddLLVM.cmake +@@ -884,53 +884,71 @@ function(add_llvm_pass_plugin name) + if (TARGET intrinsics_gen) + add_dependencies(obj.${name} intrinsics_gen) + endif() +- message(STATUS "Registering ${name} as a pass plugin (static build: ${LLVM_${name_upper}_LINK_INTO_TOOLS})") +- set_property(GLOBAL APPEND PROPERTY LLVM_COMPILE_EXTENSIONS ${name}) ++ set_property(GLOBAL APPEND PROPERTY LLVM_STATIC_EXTENSIONS ${name}) + elseif(NOT ARG_NO_MODULE) + add_llvm_library(${name} MODULE ${ARG_UNPARSED_ARGUMENTS}) + else() + add_llvm_library(${name} OBJECT ${ARG_UNPARSED_ARGUMENTS}) + endif() ++ message(STATUS "Registering ${name} as a pass plugin (static build: ${LLVM_${name_upper}_LINK_INTO_TOOLS})") + + endfunction(add_llvm_pass_plugin) + +-# Generate X Macro file for extension handling. It provides a +-# HANDLE_EXTENSION(extension_namespace, ExtensionProject) call for each extension +-# allowing client code to define HANDLE_EXTENSION to have a specific code be run for +-# each extension. ++# process_llvm_pass_plugins([GEN_CONFIG]) ++# ++# Correctly set lib dependencies between plugins and tools, based on tools ++# registered with the ENABLE_PLUGINS option. ++# ++# if GEN_CONFIG option is set, also generate X Macro file for extension ++# handling. It provides a HANDLE_EXTENSION(extension_namespace, ExtensionProject) ++# call for each extension allowing client code to define ++# HANDLE_EXTENSION to have a specific code be run for each extension. + # +-# Also correctly set lib dependencies between plugins and tools. + function(process_llvm_pass_plugins) +- get_property(LLVM_EXTENSIONS GLOBAL PROPERTY LLVM_COMPILE_EXTENSIONS) +- file(WRITE "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def.tmp" "//extension handlers\n") +- foreach(llvm_extension ${LLVM_EXTENSIONS}) +- string(TOLOWER ${llvm_extension} llvm_extension_lower) +- +- string(TOUPPER ${llvm_extension} llvm_extension_upper) +- string(SUBSTRING ${llvm_extension_upper} 0 1 llvm_extension_upper_first) +- string(SUBSTRING ${llvm_extension_lower} 1 -1 llvm_extension_lower_tail) +- string(CONCAT llvm_extension_project ${llvm_extension_upper_first} ${llvm_extension_lower_tail}) +- +- if(LLVM_${llvm_extension_upper}_LINK_INTO_TOOLS) +- file(APPEND "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def.tmp" "HANDLE_EXTENSION(${llvm_extension_project})\n") +- +- get_property(llvm_plugin_targets GLOBAL PROPERTY LLVM_PLUGIN_TARGETS) +- foreach(llvm_plugin_target ${llvm_plugin_targets}) +- set_property(TARGET ${llvm_plugin_target} APPEND PROPERTY LINK_LIBRARIES ${llvm_extension}) +- set_property(TARGET ${llvm_plugin_target} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${llvm_extension}) +- endforeach() +- else() +- add_llvm_library(${llvm_extension_lower} MODULE obj.${llvm_extension_lower}) +- endif() ++ cmake_parse_arguments(ARG ++ "GEN_CONFIG" "" "" ++ ${ARGN}) + ++ if(ARG_GEN_CONFIG) ++ get_property(LLVM_STATIC_EXTENSIONS GLOBAL PROPERTY LLVM_STATIC_EXTENSIONS) ++ else() ++ include(LLVMConfigExtensions) ++ endif() ++ ++ # Add static plugins to each plugin target. ++ foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS}) ++ get_property(llvm_plugin_targets GLOBAL PROPERTY LLVM_PLUGIN_TARGETS) ++ foreach(llvm_plugin_target ${llvm_plugin_targets}) ++ set_property(TARGET ${llvm_plugin_target} APPEND PROPERTY LINK_LIBRARIES ${llvm_extension}) ++ set_property(TARGET ${llvm_plugin_target} APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${llvm_extension}) ++ endforeach() + endforeach() +- file(APPEND "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def.tmp" "#undef HANDLE_EXTENSION\n") + +- # only replace if there's an actual change +- execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different +- "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def.tmp" +- "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def") +- file(REMOVE "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def.tmp") ++ # Eventually generate the extension header, and store config to a cmake file ++ # for usage in third-party configuration. ++ if(ARG_GEN_CONFIG) ++ set(LLVM_INSTALL_PACKAGE_DIR lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm) ++ set(llvm_cmake_builddir "${LLVM_BINARY_DIR}/${LLVM_INSTALL_PACKAGE_DIR}") ++ file(WRITE ++ "${llvm_cmake_builddir}/LLVMConfigExtensions.cmake" ++ "set(LLVM_STATIC_EXTENSIONS ${LLVM_STATIC_EXTENSIONS})") ++ install(FILES ++ ${llvm_cmake_builddir}/LLVMConfigExtensions.cmake ++ DESTINATION ${LLVM_INSTALL_PACKAGE_DIR} ++ COMPONENT cmake-exports) ++ ++ file(WRITE "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def.tmp" "//extension handlers\n") ++ foreach(llvm_extension ${LLVM_STATIC_EXTENSIONS}) ++ file(APPEND "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def.tmp" "HANDLE_EXTENSION(${llvm_extension})\n") ++ endforeach() ++ file(APPEND "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def.tmp" "#undef HANDLE_EXTENSION\n") ++ ++ # only replace if there's an actual change ++ execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different ++ "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def.tmp" ++ "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def") ++ file(REMOVE "${LLVM_BINARY_DIR}/include/llvm/Support/Extension.def.tmp") ++ endif() + endfunction() + + function(export_executable_symbols target) +diff --git a/llvm/cmake/modules/CMakeLists.txt b/llvm/cmake/modules/CMakeLists.txt +index 9cf22b436fa..af757d6199a 100644 +--- llvm/cmake/modules/CMakeLists.txt ++++ llvm/cmake/modules/CMakeLists.txt +@@ -136,6 +136,7 @@ if (NOT LLVM_INSTALL_TOOLCHAIN_ONLY) + FILES_MATCHING PATTERN *.cmake + PATTERN .svn EXCLUDE + PATTERN LLVMConfig.cmake EXCLUDE ++ PATTERN LLVMConfigExtensions.cmake EXCLUDE + PATTERN LLVMConfigVersion.cmake EXCLUDE + PATTERN LLVM-Config.cmake EXCLUDE + PATTERN GetHostTriple.cmake EXCLUDE) diff --git a/overlay/llvm-10/llvm-genode.patch b/overlay/llvm-10/llvm-genode.patch new file mode 100644 index 0000000..d547f70 --- /dev/null +++ b/overlay/llvm-10/llvm-genode.patch @@ -0,0 +1,157 @@ +diff --git a/cmake/modules/HandleLLVMOptions.cmake b/cmake/modules/HandleLLVMOptions.cmake +index 30f04ca34c2..eb388c82a48 100644 +--- a/cmake/modules/HandleLLVMOptions.cmake ++++ b/cmake/modules/HandleLLVMOptions.cmake +@@ -108,7 +108,7 @@ if(WIN32) + set(LLVM_ON_UNIX 0) + endif(CYGWIN) + else(WIN32) +- if(FUCHSIA OR UNIX) ++ if(FUCHSIA OR GENODE OR UNIX) + set(LLVM_ON_WIN32 0) + set(LLVM_ON_UNIX 1) + if(APPLE OR ${CMAKE_SYSTEM_NAME} MATCHES "AIX") +@@ -116,9 +116,9 @@ else(WIN32) + else() + set(LLVM_HAVE_LINK_VERSION_SCRIPT 1) + endif() +- else(FUCHSIA OR UNIX) ++ else(FUCHSIA OR GENODE OR UNIX) + MESSAGE(SEND_ERROR "Unable to determine platform") +- endif(FUCHSIA OR UNIX) ++ endif(FUCHSIA OR GENODE OR UNIX) + endif(WIN32) + + set(EXEEXT ${CMAKE_EXECUTABLE_SUFFIX}) +diff --git a/include/llvm/ADT/Triple.h b/include/llvm/ADT/Triple.h +index 76a754d671f..f687da0a42b 100644 +--- a/include/llvm/ADT/Triple.h ++++ b/include/llvm/ADT/Triple.h +@@ -163,6 +163,7 @@ public: + DragonFly, + FreeBSD, + Fuchsia, ++ Genode, + IOS, + KFreeBSD, + Linux, +@@ -509,6 +510,8 @@ public: + + bool isOSDragonFly() const { return getOS() == Triple::DragonFly; } + ++ bool isOSGenode() const { return getOS() == Triple::Genode; } ++ + bool isOSSolaris() const { + return getOS() == Triple::Solaris; + } +diff --git a/include/llvm/BinaryFormat/ELF.h b/include/llvm/BinaryFormat/ELF.h +index caab91da9c8..2c3d7a2f518 100644 +--- a/include/llvm/BinaryFormat/ELF.h ++++ b/include/llvm/BinaryFormat/ELF.h +@@ -347,6 +347,7 @@ enum { + ELFOSABI_AROS = 15, // AROS + ELFOSABI_FENIXOS = 16, // FenixOS + ELFOSABI_CLOUDABI = 17, // Nuxi CloudABI ++ ELFOSABI_GENODE = 18, // Genode + ELFOSABI_FIRST_ARCH = 64, // First architecture-specific OS ABI + ELFOSABI_AMDGPU_HSA = 64, // AMD HSA runtime + ELFOSABI_AMDGPU_PAL = 65, // AMD PAL runtime +diff --git a/include/llvm/MC/MCELFObjectWriter.h b/include/llvm/MC/MCELFObjectWriter.h +index 2d441fdeee2..438497401b5 100644 +--- a/include/llvm/MC/MCELFObjectWriter.h ++++ b/include/llvm/MC/MCELFObjectWriter.h +@@ -74,6 +74,8 @@ public: + switch (OSType) { + case Triple::CloudABI: + return ELF::ELFOSABI_CLOUDABI; ++ case Triple::Genode: ++ return ELF::ELFOSABI_GENODE; + case Triple::HermitCore: + return ELF::ELFOSABI_STANDALONE; + case Triple::PS4: +diff --git a/lib/ObjectYAML/ELFYAML.cpp b/lib/ObjectYAML/ELFYAML.cpp +index efa7ecb4728..99881cef3ed 100644 +--- a/lib/ObjectYAML/ELFYAML.cpp ++++ b/lib/ObjectYAML/ELFYAML.cpp +@@ -267,6 +267,7 @@ void ScalarEnumerationTraits::enumeration( + ECase(ELFOSABI_AROS); + ECase(ELFOSABI_FENIXOS); + ECase(ELFOSABI_CLOUDABI); ++ ECase(ELFOSABI_GENODE); + ECase(ELFOSABI_AMDGPU_HSA); + ECase(ELFOSABI_AMDGPU_PAL); + ECase(ELFOSABI_AMDGPU_MESA3D); +diff --git a/lib/Support/Triple.cpp b/lib/Support/Triple.cpp +index 2c480c1094a..9bdd99c9496 100644 +--- a/lib/Support/Triple.cpp ++++ b/lib/Support/Triple.cpp +@@ -193,6 +193,7 @@ StringRef Triple::getOSTypeName(OSType Kind) { + case Emscripten: return "emscripten"; + case FreeBSD: return "freebsd"; + case Fuchsia: return "fuchsia"; ++ case Genode: return "genode"; + case Haiku: return "haiku"; + case HermitCore: return "hermit"; + case Hurd: return "hurd"; +@@ -490,6 +491,7 @@ static Triple::OSType parseOS(StringRef OSName) { + .StartsWith("dragonfly", Triple::DragonFly) + .StartsWith("freebsd", Triple::FreeBSD) + .StartsWith("fuchsia", Triple::Fuchsia) ++ .StartsWith("genode", Triple::Genode) + .StartsWith("ios", Triple::IOS) + .StartsWith("kfreebsd", Triple::KFreeBSD) + .StartsWith("linux", Triple::Linux) +diff --git a/tools/llvm-readobj/ELFDumper.cpp b/tools/llvm-readobj/ELFDumper.cpp +index 8ffb6828340..1eac59600a9 100644 +--- a/tools/llvm-readobj/ELFDumper.cpp ++++ b/tools/llvm-readobj/ELFDumper.cpp +@@ -1223,6 +1223,7 @@ static const EnumEntry ElfOSABI[] = { + {"AROS", "AROS", ELF::ELFOSABI_AROS}, + {"FenixOS", "FenixOS", ELF::ELFOSABI_FENIXOS}, + {"CloudABI", "CloudABI", ELF::ELFOSABI_CLOUDABI}, ++ {"Genode", "Genode", ELF::ELFOSABI_GENODE}, + {"Standalone", "Standalone App", ELF::ELFOSABI_STANDALONE} + }; + +diff --git a/unittests/ADT/TripleTest.cpp b/unittests/ADT/TripleTest.cpp +index ef7f82d268e..248679d803c 100644 +--- a/unittests/ADT/TripleTest.cpp ++++ b/unittests/ADT/TripleTest.cpp +@@ -247,6 +247,12 @@ TEST(TripleTest, ParsedIDs) { + EXPECT_EQ(Triple::Fuchsia, T.getOS()); + EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); + ++ T = Triple("x86_64-unknown-genode"); ++ EXPECT_EQ(Triple::x86_64, T.getArch()); ++ EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); ++ EXPECT_EQ(Triple::Genode, T.getOS()); ++ EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment()); ++ + T = Triple("x86_64-unknown-hermit"); + EXPECT_EQ(Triple::x86_64, T.getArch()); + EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); +diff --git a/utils/benchmark/src/internal_macros.h b/utils/benchmark/src/internal_macros.h +index f2d54bfcbd9..e20f891d435 100644 +--- a/utils/benchmark/src/internal_macros.h ++++ b/utils/benchmark/src/internal_macros.h +@@ -65,6 +65,8 @@ + #define BENCHMARK_OS_FUCHSIA 1 + #elif defined (__SVR4) && defined (__sun) + #define BENCHMARK_OS_SOLARIS 1 ++#elif defined(__GENODE__) ++ #define BENCHMARK_OS_GENODE 1 + #endif + + #if !__has_feature(cxx_exceptions) && !defined(__cpp_exceptions) \ +diff --git a/utils/gn/secondary/clang/lib/Driver/BUILD.gn b/utils/gn/secondary/clang/lib/Driver/BUILD.gn +index 9dd07a463dc..2ed62d1adbc 100644 +--- a/utils/gn/secondary/clang/lib/Driver/BUILD.gn ++++ b/utils/gn/secondary/clang/lib/Driver/BUILD.gn +@@ -65,6 +65,7 @@ static_library("Driver") { + "ToolChains/Flang.cpp", + "ToolChains/FreeBSD.cpp", + "ToolChains/Fuchsia.cpp", ++ "ToolChains/Genode.cpp", + "ToolChains/Gnu.cpp", + "ToolChains/HIP.cpp", + "ToolChains/Haiku.cpp", diff --git a/overlay/llvm-10/llvm-outputs.patch b/overlay/llvm-10/llvm-outputs.patch new file mode 100644 index 0000000..40096fa --- /dev/null +++ b/overlay/llvm-10/llvm-outputs.patch @@ -0,0 +1,26 @@ +diff --git a/tools/llvm-config/llvm-config.cpp b/tools/llvm-config/llvm-config.cpp +index 94d426b..37f7794 100644 +--- a/tools/llvm-config/llvm-config.cpp ++++ b/tools/llvm-config/llvm-config.cpp +@@ -333,6 +333,21 @@ int main(int argc, char **argv) { + ActiveIncludeOption = "-I" + ActiveIncludeDir; + } + ++ /// Nix-specific multiple-output handling: override ActiveLibDir if --link-shared ++ if (!IsInDevelopmentTree) { ++ bool WantShared = true; ++ for (int i = 1; i < argc; ++i) { ++ StringRef Arg = argv[i]; ++ if (Arg == "--link-shared") ++ WantShared = true; ++ else if (Arg == "--link-static") ++ WantShared = false; // the last one wins ++ } ++ ++ if (WantShared) ++ ActiveLibDir = std::string("@lib@") + "/lib" + LLVM_LIBDIR_SUFFIX; ++ } ++ + /// We only use `shared library` mode in cases where the static library form + /// of the components provided are not available; note however that this is + /// skipped if we're run from within the build dir. However, once installed, diff --git a/overlay/llvm-10/llvm.nix b/overlay/llvm-10/llvm.nix new file mode 100644 index 0000000..2325f85 --- /dev/null +++ b/overlay/llvm-10/llvm.nix @@ -0,0 +1,190 @@ +{ stdenv +, fetch +, cmake +, python3 +, libffi +, libbfd +, libpfm +, libxml2 +, ncurses +, version +, release_version +, zlib +, buildPackages +, debugVersion ? false +, enableManpages ? false +, enableSharedLibraries ? true +, enablePFM ? !(stdenv.isDarwin + || stdenv.isAarch64 # broken for Ampere eMAG 8180 (c2.large.arm on Packet) #56245 +) +, enablePolly ? true +}: + +let + inherit (stdenv.lib) optional optionals optionalString; + + # Used when creating a version-suffixed symlink of libLLVM.dylib + shortVersion = with stdenv.lib; + concatStringsSep "." (take 1 (splitString "." release_version)); + +in stdenv.mkDerivation (rec { + pname = "llvm"; + inherit version; + + src = fetch pname "1pwgm6cr0xr5a0hrbqs1zvsvvjvy0yq1y47c96804wcs795s90yz"; + polly_src = fetch "polly" "15sd3dq0w60jsb76pis09lkagj5iy43h9hg4kd9gx5l8cbnsdyrm"; + + unpackPhase = '' + unpackFile $src + mv llvm-${version}* llvm + sourceRoot=$PWD/llvm + '' + optionalString enablePolly '' + unpackFile $polly_src + mv polly-* $sourceRoot/tools/polly + ''; + + outputs = [ "out" "python" ] + ++ optional enableSharedLibraries "lib"; + + nativeBuildInputs = [ cmake python3 ] + ++ optionals enableManpages [ python3.pkgs.sphinx python3.pkgs.recommonmark ]; + + buildInputs = [ libxml2 libffi ] + ++ optional enablePFM libpfm; # exegesis + + propagatedBuildInputs = [ ncurses zlib ]; + + patches = [ + # 10.0.0rc3-only + ./llvm-extension-handling.patch + ] ++ stdenv.lib.optional stdenv.targetPlatform.isGenode ./llvm-genode.patch; + + postPatch = optionalString stdenv.isDarwin '' + substituteInPlace cmake/modules/AddLLVM.cmake \ + --replace 'set(_install_name_dir INSTALL_NAME_DIR "@rpath")' "set(_install_name_dir)" \ + --replace 'set(_install_rpath "@loader_path/../lib''${LLVM_LIBDIR_SUFFIX}" ''${extra_libdir})' "" + '' + # Patch llvm-config to return correct library path based on --link-{shared,static}. + + optionalString (enableSharedLibraries) '' + substitute '${./llvm-outputs.patch}' ./llvm-outputs.patch --subst-var lib + patch -p1 < ./llvm-outputs.patch + '' + '' + # FileSystem permissions tests fail with various special bits + substituteInPlace unittests/Support/CMakeLists.txt \ + --replace "Path.cpp" "" + rm unittests/Support/Path.cpp + '' + optionalString stdenv.hostPlatform.isMusl '' + patch -p1 -i ${../TLI-musl.patch} + substituteInPlace unittests/Support/CMakeLists.txt \ + --replace "add_subdirectory(DynamicLibrary)" "" + rm unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp + # valgrind unhappy with musl or glibc, but fails w/musl only + rm test/CodeGen/AArch64/wineh4.mir + '' + optionalString stdenv.hostPlatform.isAarch32 '' + # skip failing X86 test cases on 32-bit ARM + rm test/DebugInfo/X86/convert-debugloc.ll + rm test/DebugInfo/X86/convert-inlined.ll + rm test/DebugInfo/X86/convert-linked.ll + rm test/tools/dsymutil/X86/op-convert.test + '' + optionalString (stdenv.hostPlatform.system == "armv6l-linux") '' + # Seems to require certain floating point hardware (NEON?) + rm test/ExecutionEngine/frem.ll + '' + '' + patchShebangs test/BugPoint/compile-custom.ll.py + ''; + + # hacky fix: created binaries need to be run before installation + preBuild = '' + mkdir -p $out/ + ln -sv $PWD/lib $out + ''; + + cmakeFlags = with stdenv; [ + "-DCMAKE_BUILD_TYPE=${if debugVersion then "Debug" else "Release"}" + "-DLLVM_INSTALL_UTILS=ON" # Needed by rustc + "-DLLVM_BUILD_TESTS=ON" + "-DLLVM_ENABLE_FFI=ON" + "-DLLVM_ENABLE_RTTI=ON" + "-DLLVM_HOST_TRIPLE=${stdenv.hostPlatform.config}" + "-DLLVM_DEFAULT_TARGET_TRIPLE=${stdenv.hostPlatform.config}" + "-DLLVM_ENABLE_DUMP=ON" + ] ++ optionals enableSharedLibraries [ + "-DLLVM_LINK_LLVM_DYLIB=ON" + ] ++ optionals enableManpages [ + "-DLLVM_BUILD_DOCS=ON" + "-DLLVM_ENABLE_SPHINX=ON" + "-DSPHINX_OUTPUT_MAN=ON" + "-DSPHINX_OUTPUT_HTML=OFF" + "-DSPHINX_WARNINGS_AS_ERRORS=OFF" + ] ++ optionals (!isDarwin) [ + "-DLLVM_BINUTILS_INCDIR=${libbfd.dev}/include" + ] ++ optionals isDarwin [ + "-DLLVM_ENABLE_LIBCXX=ON" + "-DCAN_TARGET_i386=false" + ] ++ optionals (stdenv.hostPlatform != stdenv.buildPlatform) [ + "-DCMAKE_CROSSCOMPILING=True" + "-DLLVM_TABLEGEN=${buildPackages.llvm_10}/bin/llvm-tblgen" + ]; + + postBuild = '' + rm -fR $out + ''; + + preCheck = '' + export LD_LIBRARY_PATH=$LD_LIBRARY_PATH''${LD_LIBRARY_PATH:+:}$PWD/lib + ''; + + postInstall = '' + mkdir -p $python/share + mv $out/share/opt-viewer $python/share/opt-viewer + '' + + optionalString enableSharedLibraries '' + moveToOutput "lib/libLLVM-*" "$lib" + moveToOutput "lib/libLLVM${stdenv.hostPlatform.extensions.sharedLibrary}" "$lib" + '' + + optionalString (enableSharedLibraries && (!stdenv.isDarwin)) '' + substituteInPlace "$out/lib/cmake/llvm/LLVMExports-${if debugVersion then "debug" else "release"}.cmake" \ + --replace "\''${_IMPORT_PREFIX}/lib/libLLVM-" "$lib/lib/libLLVM-" + '' + + optionalString (stdenv.isDarwin && enableSharedLibraries) '' + substituteInPlace "$out/lib/cmake/llvm/LLVMExports-${if debugVersion then "debug" else "release"}.cmake" \ + --replace "\''${_IMPORT_PREFIX}/lib/libLLVM.dylib" "$lib/lib/libLLVM.dylib" + ln -s $lib/lib/libLLVM.dylib $lib/lib/libLLVM-${shortVersion}.dylib + ln -s $lib/lib/libLLVM.dylib $lib/lib/libLLVM-${release_version}.dylib + ''; + + doCheck = stdenv.isLinux && (!stdenv.isx86_32); + + checkTarget = "check-all"; + + enableParallelBuilding = true; + + meta = { + description = "Collection of modular and reusable compiler and toolchain technologies"; + homepage = http://llvm.org/; + license = stdenv.lib.licenses.ncsa; + maintainers = with stdenv.lib.maintainers; [ lovek323 raskin dtzWill ]; + platforms = stdenv.lib.platforms.all; + }; +} // stdenv.lib.optionalAttrs enableManpages { + pname = "llvm-manpages"; + + buildPhase = '' + make docs-llvm-man + ''; + + propagatedBuildInputs = []; + + installPhase = '' + make -C docs install + ''; + + postPatch = null; + postInstall = null; + + outputs = [ "out" ]; + + doCheck = false; + + meta.description = "man pages for LLVM ${version}"; +}) diff --git a/overlay/llvm-10/openmp.nix b/overlay/llvm-10/openmp.nix new file mode 100644 index 0000000..4dd45ba --- /dev/null +++ b/overlay/llvm-10/openmp.nix @@ -0,0 +1,26 @@ +{ stdenv +, fetch +, cmake +, llvm +, perl +, version +}: + +stdenv.mkDerivation rec { + pname = "openmp"; + inherit version; + + src = fetch pname "1ymd13gj07x0b0vxziygm0p41vrq6nsgx837jqg9ll6h8ndg57rv"; + + nativeBuildInputs = [ cmake perl ]; + buildInputs = [ llvm ]; + + enableParallelBuilding = true; + + meta = { + description = "Components required to build an executable OpenMP program"; + homepage = http://openmp.llvm.org/; + license = stdenv.lib.licenses.mit; + platforms = stdenv.lib.platforms.all; + }; +} diff --git a/overlay/llvm-10/sanitizers-nongnu.patch b/overlay/llvm-10/sanitizers-nongnu.patch new file mode 100644 index 0000000..1f2ac97 --- /dev/null +++ b/overlay/llvm-10/sanitizers-nongnu.patch @@ -0,0 +1,412 @@ +From f7a253f8f85d0f49df6b73996737a3e84ac64236 Mon Sep 17 00:00:00 2001 +From: Will Dietz +Date: Mon, 24 Sep 2018 11:17:25 -0500 +Subject: [PATCH] Ported to 7.0, taken from gentoo-musl project. + +------ +Ported to compiler-rt-sanitizers-5.0.0. Taken from + +https://gist.githubusercontent.com/pwaller/2337f3290f12634cad3e3730cff0a6c1/raw/83c87a8585e2f9662494db5662e5361beb093c26/nongnu.patch +Signed-off-by: Jory A. Pratt + +Taken from gentoo-musl project, with a few additional minor fixes. +--- + lib/asan/asan_linux.cc | 4 +- + lib/interception/interception_linux.cc | 2 +- + lib/interception/interception_linux.h | 2 +- + lib/msan/msan_linux.cc | 2 +- + lib/sanitizer_common/sanitizer_allocator.cc | 2 +- + .../sanitizer_common_interceptors_ioctl.inc | 4 +- + .../sanitizer_common_syscalls.inc | 2 +- + lib/sanitizer_common/sanitizer_linux.cc | 8 +++- + .../sanitizer_linux_libcdep.cc | 10 ++--- + lib/sanitizer_common/sanitizer_platform.h | 6 +++ + .../sanitizer_platform_interceptors.h | 4 +- + .../sanitizer_platform_limits_posix.cc | 37 +++++++++++-------- + lib/tsan/rtl/tsan_platform_linux.cc | 2 +- + 13 files changed, 51 insertions(+), 34 deletions(-) + +diff --git a/lib/asan/asan_linux.cc b/lib/asan/asan_linux.cc +index 625f32d40..73cf77aca 100644 +--- a/lib/asan/asan_linux.cc ++++ b/lib/asan/asan_linux.cc +@@ -46,7 +46,7 @@ + #include + #endif + +-#if SANITIZER_ANDROID || SANITIZER_FREEBSD || SANITIZER_SOLARIS ++#if SANITIZER_ANDROID || SANITIZER_FREEBSD || SANITIZER_SOLARIS || SANITIZER_NONGNU + #include + extern "C" void* _DYNAMIC; + #elif SANITIZER_NETBSD +@@ -139,7 +139,7 @@ void AsanApplyToGlobals(globals_op_fptr op, const void *needle) { + UNIMPLEMENTED(); + } + +-#if SANITIZER_ANDROID ++#if SANITIZER_ANDROID || SANITIZER_NONGNU + // FIXME: should we do anything for Android? + void AsanCheckDynamicRTPrereqs() {} + void AsanCheckIncompatibleRT() {} +diff --git a/lib/interception/interception_linux.cc b/lib/interception/interception_linux.cc +index 26bfcd8f6..529b234f7 100644 +--- a/lib/interception/interception_linux.cc ++++ b/lib/interception/interception_linux.cc +@@ -43,7 +43,7 @@ bool GetRealFunctionAddress(const char *func_name, uptr *func_addr, + } + + // Android and Solaris do not have dlvsym +-#if !SANITIZER_ANDROID && !SANITIZER_SOLARIS && !SANITIZER_OPENBSD ++#if !SANITIZER_ANDROID && !SANITIZER_SOLARIS && !SANITIZER_OPENBSD && !SANITIZER_NONGNU + void *GetFuncAddrVer(const char *func_name, const char *ver) { + return dlvsym(RTLD_NEXT, func_name, ver); + } +diff --git a/lib/interception/interception_linux.h b/lib/interception/interception_linux.h +index 942c25609..24a4d5080 100644 +--- a/lib/interception/interception_linux.h ++++ b/lib/interception/interception_linux.h +@@ -36,7 +36,7 @@ void *GetFuncAddrVer(const char *func_name, const char *ver); + (::__interception::uptr) & WRAP(func)) + + // Android, Solaris and OpenBSD do not have dlvsym +-#if !SANITIZER_ANDROID && !SANITIZER_SOLARIS && !SANITIZER_OPENBSD ++#if !SANITIZER_ANDROID && !SANITIZER_SOLARIS && !SANITIZER_OPENBSD && !SANITIZER_NONGNU + #define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \ + (::__interception::real_##func = (func##_f)( \ + unsigned long)::__interception::GetFuncAddrVer(#func, symver)) +diff --git a/lib/msan/msan_linux.cc b/lib/msan/msan_linux.cc +index 385a650c4..6e30a8ce9 100644 +--- a/lib/msan/msan_linux.cc ++++ b/lib/msan/msan_linux.cc +@@ -13,7 +13,7 @@ + //===----------------------------------------------------------------------===// + + #include "sanitizer_common/sanitizer_platform.h" +-#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD ++#if SANITIZER_FREEBSD || (SANITIZER_LINUX && !SANITIZER_NONGNU) || SANITIZER_NETBSD + + #include "msan.h" + #include "msan_report.h" +diff --git a/lib/sanitizer_common/sanitizer_allocator.cc b/lib/sanitizer_common/sanitizer_allocator.cc +index 6bfd5e5ee..048f6154f 100644 +--- a/lib/sanitizer_common/sanitizer_allocator.cc ++++ b/lib/sanitizer_common/sanitizer_allocator.cc +@@ -27,7 +27,7 @@ const char *SecondaryAllocatorName = "LargeMmapAllocator"; + + // ThreadSanitizer for Go uses libc malloc/free. + #if SANITIZER_GO || defined(SANITIZER_USE_MALLOC) +-# if SANITIZER_LINUX && !SANITIZER_ANDROID ++# if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_NONGNU + extern "C" void *__libc_malloc(uptr size); + # if !SANITIZER_GO + extern "C" void *__libc_memalign(uptr alignment, uptr size); +diff --git a/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc b/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc +index 2d633c173..b6eb23116 100644 +--- a/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc ++++ b/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc +@@ -104,7 +104,7 @@ static void ioctl_table_fill() { + _(SIOCGETVIFCNT, WRITE, struct_sioc_vif_req_sz); + #endif + +-#if SANITIZER_LINUX ++#if SANITIZER_LINUX && !SANITIZER_NONGNU + // Conflicting request ids. + // _(CDROMAUDIOBUFSIZ, NONE, 0); + // _(SNDCTL_TMR_CONTINUE, NONE, 0); +@@ -365,7 +365,7 @@ static void ioctl_table_fill() { + _(VT_WAITACTIVE, NONE, 0); + #endif + +-#if SANITIZER_LINUX && !SANITIZER_ANDROID ++#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_NONGNU + // _(SIOCDEVPLIP, WRITE, struct_ifreq_sz); // the same as EQL_ENSLAVE + _(CYGETDEFTHRESH, WRITE, sizeof(int)); + _(CYGETDEFTIMEOUT, WRITE, sizeof(int)); +diff --git a/lib/sanitizer_common/sanitizer_common_syscalls.inc b/lib/sanitizer_common/sanitizer_common_syscalls.inc +index 469c8eb7e..24f87867d 100644 +--- a/lib/sanitizer_common/sanitizer_common_syscalls.inc ++++ b/lib/sanitizer_common/sanitizer_common_syscalls.inc +@@ -2038,7 +2038,7 @@ POST_SYSCALL(setrlimit)(long res, long resource, void *rlim) { + } + } + +-#if !SANITIZER_ANDROID ++#if !SANITIZER_ANDROID && !SANITIZER_NONGNU + PRE_SYSCALL(prlimit64)(long pid, long resource, const void *new_rlim, + void *old_rlim) { + if (new_rlim) PRE_READ(new_rlim, struct_rlimit64_sz); +diff --git a/lib/sanitizer_common/sanitizer_linux.cc b/lib/sanitizer_common/sanitizer_linux.cc +index 96d6c1eff..9e2b7fb9d 100644 +--- a/lib/sanitizer_common/sanitizer_linux.cc ++++ b/lib/sanitizer_common/sanitizer_linux.cc +@@ -541,13 +541,13 @@ const char *GetEnv(const char *name) { + #endif + } + +-#if !SANITIZER_FREEBSD && !SANITIZER_NETBSD && !SANITIZER_OPENBSD ++#if !SANITIZER_FREEBSD && !SANITIZER_NETBSD && !SANITIZER_OPENBSD && !SANITIZER_NONGNU + extern "C" { + SANITIZER_WEAK_ATTRIBUTE extern void *__libc_stack_end; + } + #endif + +-#if !SANITIZER_GO && !SANITIZER_FREEBSD && !SANITIZER_NETBSD && \ ++#if (!SANITIZER_GO || SANITIZER_NONGNU) && !SANITIZER_FREEBSD && !SANITIZER_NETBSD && \ + !SANITIZER_OPENBSD + static void ReadNullSepFileToArray(const char *path, char ***arr, + int arr_size) { +@@ -590,6 +590,10 @@ static void GetArgsAndEnv(char ***argv, char ***envp) { + #elif SANITIZER_NETBSD + *argv = __ps_strings->ps_argvstr; + *envp = __ps_strings->ps_envstr; ++#elif SANITIZER_NONGNU ++ static const int kMaxArgv = 2000, kMaxEnvp = 2000; ++ ReadNullSepFileToArray("/proc/self/cmdline", argv, kMaxArgv); ++ ReadNullSepFileToArray("/proc/self/environ", envp, kMaxEnvp); + #else // SANITIZER_FREEBSD + #if !SANITIZER_GO + if (&__libc_stack_end) { +diff --git a/lib/sanitizer_common/sanitizer_linux_libcdep.cc b/lib/sanitizer_common/sanitizer_linux_libcdep.cc +index 4962ff832..438f94dbe 100644 +--- a/lib/sanitizer_common/sanitizer_linux_libcdep.cc ++++ b/lib/sanitizer_common/sanitizer_linux_libcdep.cc +@@ -179,7 +179,7 @@ __attribute__((unused)) static bool GetLibcVersion(int *major, int *minor, + } + + #if !SANITIZER_FREEBSD && !SANITIZER_ANDROID && !SANITIZER_GO && \ +- !SANITIZER_NETBSD && !SANITIZER_OPENBSD && !SANITIZER_SOLARIS ++ !SANITIZER_NETBSD && !SANITIZER_OPENBSD && !SANITIZER_SOLARIS && !SANITIZER_NONGNU + static uptr g_tls_size; + + #ifdef __i386__ +@@ -261,7 +261,7 @@ void InitTlsSize() { } + #if (defined(__x86_64__) || defined(__i386__) || defined(__mips__) || \ + defined(__aarch64__) || defined(__powerpc64__) || defined(__s390__) || \ + defined(__arm__)) && \ +- SANITIZER_LINUX && !SANITIZER_ANDROID ++ SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_NONGNU + // sizeof(struct pthread) from glibc. + static atomic_uintptr_t thread_descriptor_size; + +@@ -426,7 +426,7 @@ int GetSizeFromHdr(struct dl_phdr_info *info, size_t size, void *data) { + + #if !SANITIZER_GO + static void GetTls(uptr *addr, uptr *size) { +-#if SANITIZER_LINUX && !SANITIZER_ANDROID ++#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_NONGNU + # if defined(__x86_64__) || defined(__i386__) || defined(__s390__) + *addr = ThreadSelf(); + *size = GetTlsSize(); +@@ -470,7 +470,7 @@ static void GetTls(uptr *addr, uptr *size) { + #elif SANITIZER_OPENBSD + *addr = 0; + *size = 0; +-#elif SANITIZER_ANDROID ++#elif SANITIZER_ANDROID || SANITIZER_NONGNU + *addr = 0; + *size = 0; + #elif SANITIZER_SOLARIS +@@ -486,7 +486,7 @@ static void GetTls(uptr *addr, uptr *size) { + #if !SANITIZER_GO + uptr GetTlsSize() { + #if SANITIZER_FREEBSD || SANITIZER_ANDROID || SANITIZER_NETBSD || \ +- SANITIZER_OPENBSD || SANITIZER_SOLARIS ++ SANITIZER_OPENBSD || SANITIZER_SOLARIS || SANITIZER_NONGNU + uptr addr, size; + GetTls(&addr, &size); + return size; +diff --git a/lib/sanitizer_common/sanitizer_platform.h b/lib/sanitizer_common/sanitizer_platform.h +index d81e25580..e10680ac8 100644 +--- a/lib/sanitizer_common/sanitizer_platform.h ++++ b/lib/sanitizer_common/sanitizer_platform.h +@@ -208,6 +208,12 @@ + # define SANITIZER_SOLARIS32 0 + #endif + ++#if defined(__linux__) && !defined(__GLIBC__) ++# define SANITIZER_NONGNU 1 ++#else ++# define SANITIZER_NONGNU 0 ++#endif ++ + #if defined(__myriad2__) + # define SANITIZER_MYRIAD2 1 + #else +diff --git a/lib/sanitizer_common/sanitizer_platform_interceptors.h b/lib/sanitizer_common/sanitizer_platform_interceptors.h +index f95539a73..6c53b3415 100644 +--- a/lib/sanitizer_common/sanitizer_platform_interceptors.h ++++ b/lib/sanitizer_common/sanitizer_platform_interceptors.h +@@ -39,7 +39,7 @@ + # include "sanitizer_platform_limits_solaris.h" + #endif + +-#if SANITIZER_LINUX && !SANITIZER_ANDROID ++#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_NONGNU + # define SI_LINUX_NOT_ANDROID 1 + #else + # define SI_LINUX_NOT_ANDROID 0 +@@ -322,7 +322,7 @@ + #define SANITIZER_INTERCEPT_ETHER_R (SI_FREEBSD || SI_LINUX_NOT_ANDROID) + #define SANITIZER_INTERCEPT_SHMCTL \ + (SI_NETBSD || SI_OPENBSD || SI_SOLARIS || \ +- ((SI_FREEBSD || SI_LINUX_NOT_ANDROID) && \ ++ ((SI_FREEBSD || SI_LINUX_NOT_ANDROID || SANITIZER_NONGNU) && \ + SANITIZER_WORDSIZE == 64)) // NOLINT + #define SANITIZER_INTERCEPT_RANDOM_R SI_LINUX_NOT_ANDROID + #define SANITIZER_INTERCEPT_PTHREAD_ATTR_GET SI_POSIX +diff --git a/lib/sanitizer_common/sanitizer_platform_limits_posix.cc b/lib/sanitizer_common/sanitizer_platform_limits_posix.cc +index 54da635d7..2f6ff69c3 100644 +--- a/lib/sanitizer_common/sanitizer_platform_limits_posix.cc ++++ b/lib/sanitizer_common/sanitizer_platform_limits_posix.cc +@@ -14,6 +14,9 @@ + + #include "sanitizer_platform.h" + ++// Workaround musl <--> linux conflicting definition of 'struct sysinfo' ++#define _LINUX_SYSINFO_H ++ + #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_MAC + // Tests in this file assume that off_t-dependent data structures match the + // libc ABI. For example, struct dirent here is what readdir() function (as +@@ -138,12 +141,14 @@ typedef struct user_fpregs elf_fpregset_t; + + #if SANITIZER_LINUX && !SANITIZER_ANDROID + #include +-#include ++# if !SANITIZER_NONGNU ++# include ++# endif + #include +-#include +-#include +-#include +-#include ++#include ++#include ++#include ++#include + #if HAVE_RPC_XDR_H + # include + #elif HAVE_TIRPC_RPC_XDR_H +@@ -251,7 +256,7 @@ namespace __sanitizer { + unsigned struct_itimerspec_sz = sizeof(struct itimerspec); + #endif // SANITIZER_LINUX || SANITIZER_FREEBSD + +-#if SANITIZER_LINUX && !SANITIZER_ANDROID ++#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_NONGNU + // Use pre-computed size of struct ustat to avoid which + // has been removed from glibc 2.28. + #if defined(__aarch64__) || defined(__s390x__) || defined (__mips64) \ +@@ -322,7 +327,7 @@ unsigned struct_ElfW_Phdr_sz = sizeof(ElfW(Phdr)); + unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); + #endif + +-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID ++#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID && !SANITIZER_NONGNU + int glob_nomatch = GLOB_NOMATCH; + int glob_altdirfunc = GLOB_ALTDIRFUNC; + #endif +@@ -416,7 +421,7 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); + unsigned struct_termios_sz = sizeof(struct termios); + unsigned struct_winsize_sz = sizeof(struct winsize); + +-#if SANITIZER_LINUX ++#if SANITIZER_LINUX && !SANITIZER_NONGNU + unsigned struct_arpreq_sz = sizeof(struct arpreq); + unsigned struct_cdrom_msf_sz = sizeof(struct cdrom_msf); + unsigned struct_cdrom_multisession_sz = sizeof(struct cdrom_multisession); +@@ -466,7 +471,7 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); + unsigned struct_vt_mode_sz = sizeof(struct vt_mode); + #endif // SANITIZER_LINUX || SANITIZER_FREEBSD + +-#if SANITIZER_LINUX && !SANITIZER_ANDROID ++#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_NONGNU + unsigned struct_ax25_parms_struct_sz = sizeof(struct ax25_parms_struct); + unsigned struct_cyclades_monitor_sz = sizeof(struct cyclades_monitor); + #if EV_VERSION > (0x010000) +@@ -834,7 +839,7 @@ unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); + unsigned IOCTL_VT_WAITACTIVE = VT_WAITACTIVE; + #endif // SANITIZER_LINUX || SANITIZER_FREEBSD + +-#if SANITIZER_LINUX && !SANITIZER_ANDROID ++#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_NONGNU + unsigned IOCTL_CYGETDEFTHRESH = CYGETDEFTHRESH; + unsigned IOCTL_CYGETDEFTIMEOUT = CYGETDEFTIMEOUT; + unsigned IOCTL_CYGETMON = CYGETMON; +@@ -989,7 +994,7 @@ CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phdr); + CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phnum); + #endif // SANITIZER_LINUX || SANITIZER_FREEBSD + +-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID ++#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID && !SANITIZER_NONGNU + CHECK_TYPE_SIZE(glob_t); + CHECK_SIZE_AND_OFFSET(glob_t, gl_pathc); + CHECK_SIZE_AND_OFFSET(glob_t, gl_pathv); +@@ -1023,6 +1028,7 @@ CHECK_TYPE_SIZE(iovec); + CHECK_SIZE_AND_OFFSET(iovec, iov_base); + CHECK_SIZE_AND_OFFSET(iovec, iov_len); + ++#if !SANITIZER_NONGNU + CHECK_TYPE_SIZE(msghdr); + CHECK_SIZE_AND_OFFSET(msghdr, msg_name); + CHECK_SIZE_AND_OFFSET(msghdr, msg_namelen); +@@ -1036,6 +1042,7 @@ CHECK_TYPE_SIZE(cmsghdr); + CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_len); + CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_level); + CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_type); ++#endif + + #ifndef __GLIBC_PREREQ + #define __GLIBC_PREREQ(x, y) 0 +@@ -1145,7 +1152,7 @@ CHECK_SIZE_AND_OFFSET(mntent, mnt_passno); + + CHECK_TYPE_SIZE(ether_addr); + +-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID ++#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID && !SANITIZER_NONGNU + CHECK_TYPE_SIZE(ipc_perm); + # if SANITIZER_FREEBSD + CHECK_SIZE_AND_OFFSET(ipc_perm, key); +@@ -1206,7 +1213,7 @@ CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr); + CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_data); + #endif + +-#if SANITIZER_LINUX ++#if SANITIZER_LINUX && !SANITIZER_NONGNU + COMPILER_CHECK(sizeof(__sanitizer_mallinfo) == sizeof(struct mallinfo)); + #endif + +@@ -1256,7 +1263,7 @@ COMPILER_CHECK(__sanitizer_XDR_DECODE == XDR_DECODE); + COMPILER_CHECK(__sanitizer_XDR_FREE == XDR_FREE); + #endif + +-#if SANITIZER_LINUX && !SANITIZER_ANDROID ++#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_NONGNU + COMPILER_CHECK(sizeof(__sanitizer_FILE) <= sizeof(FILE)); + CHECK_SIZE_AND_OFFSET(FILE, _flags); + CHECK_SIZE_AND_OFFSET(FILE, _IO_read_ptr); +@@ -1275,7 +1282,7 @@ CHECK_SIZE_AND_OFFSET(FILE, _chain); + CHECK_SIZE_AND_OFFSET(FILE, _fileno); + #endif + +-#if SANITIZER_LINUX && !SANITIZER_ANDROID ++#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_NONGNU + COMPILER_CHECK(sizeof(__sanitizer__obstack_chunk) <= sizeof(_obstack_chunk)); + CHECK_SIZE_AND_OFFSET(_obstack_chunk, limit); + CHECK_SIZE_AND_OFFSET(_obstack_chunk, prev); +diff --git a/lib/tsan/rtl/tsan_platform_linux.cc b/lib/tsan/rtl/tsan_platform_linux.cc +index de989b780..51a97b554 100644 +--- a/lib/tsan/rtl/tsan_platform_linux.cc ++++ b/lib/tsan/rtl/tsan_platform_linux.cc +@@ -294,7 +294,7 @@ void InitializePlatform() { + // This is required to properly "close" the fds, because we do not see internal + // closes within glibc. The code is a pure hack. + int ExtractResolvFDs(void *state, int *fds, int nfd) { +-#if SANITIZER_LINUX && !SANITIZER_ANDROID ++#if SANITIZER_LINUX && !SANITIZER_ANDROID && !SANITIZER_NONGNU + int cnt = 0; + struct __res_state *statp = (struct __res_state*)state; + for (int i = 0; i < MAXNS && cnt < nfd; i++) { +-- +2.19.0 +