From e171407e959278e33097ce5aa85fa3ba1ddb4805 Mon Sep 17 00:00:00 2001 From: Sylvestre Ledru Date: Thu, 7 Feb 2019 22:44:40 +0100 Subject: [PATCH] vfs path --- debian/patches/kfreebsd/vfs.diff | 464 +++++++++++++++++++++++++++++++ debian/patches/series | 1 + 2 files changed, 465 insertions(+) create mode 100644 debian/patches/kfreebsd/vfs.diff diff --git a/debian/patches/kfreebsd/vfs.diff b/debian/patches/kfreebsd/vfs.diff new file mode 100644 index 00000000..c95665fb --- /dev/null +++ b/debian/patches/kfreebsd/vfs.diff @@ -0,0 +1,464 @@ +Index: llvm-toolchain-8-8~+rc2/home/sylvestre/dev/debian/pkg-llvm/llvm-toolchain/branches/llvm-toolchain-8-8~+rc2/tools/clang/lib/Driver/ToolChains/KFreeBSD.cpp +=================================================================== +--- llvm-toolchain-8-8~+rc2.orig/home/sylvestre/dev/debian/pkg-llvm/llvm-toolchain/branches/llvm-toolchain-8-8~+rc2/tools/clang/lib/Driver/ToolChains/KFreeBSD.cpp ++++ /dev/null +@@ -1,459 +0,0 @@ +-//===--- KFreeBSD.cpp - kFreeBSD 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 "KFreeBSD.h" +-#include "CommonArgs.h" +-#include "clang/Basic/VirtualFileSystem.h" +-#include "clang/Config/config.h" +-#include "clang/Driver/Driver.h" +-#include "clang/Driver/Options.h" +-#include "clang/Driver/SanitizerArgs.h" +-#include "llvm/Option/ArgList.h" +-#include "llvm/ProfileData/InstrProf.h" +-#include "llvm/Support/Path.h" +- +-using namespace clang::driver; +-using namespace clang::driver::toolchains; +-using namespace clang; +-using namespace llvm::opt; +- +-using tools::addPathIfExists; +- +-/// Get our best guess at the multiarch triple for a target. +-/// +-/// Debian-based systems are starting to use a multiarch setup where they use +-/// a target-triple directory in the library and header search paths. +-/// Unfortunately, this triple does not align with the vanilla target triple, +-/// so we provide a rough mapping here. +-static std::string getMultiarchTriple(const Driver &D, +- const llvm::Triple &TargetTriple, +- StringRef SysRoot) { +- // For most architectures, just use whatever we have rather than trying to be +- // clever. +- switch (TargetTriple.getArch()) { +- default: +- break; +- +- // We use the existence of '/lib/' as a directory to detect +- // some common kfreebsd triples that don't quite match the Clang +- // triple for both 32-bit and 64-bit targets. Multiarch fixes its +- // install triples to these regardless of what the actual target +- // triple is. +- case llvm::Triple::x86_64: +- if (D.getVFS().exists(SysRoot + "/lib/x86_64-kfreebsd-gnu")) +- return "x86_64-kfreebsd-gnu"; +- break; +- case llvm::Triple::x86: +- if (D.getVFS().exists(SysRoot + "/lib/i386-kfreebsd-gnu")) +- return "i386-kfreebsd-gnu"; +- break; +- } +- +- return TargetTriple.str(); +-} +- +-static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) { +- // It happens that only x86 and PPC use the 'lib32' variant of oslibdir, and +- // using that variant while targeting other architectures causes problems +- // because the libraries are laid out in shared system roots that can't cope +- // with a 'lib32' library search path being considered. So we only enable +- // them when we know we may need it. +- // +- // FIXME: This is a bit of a hack. We should really unify this code for +- // reasoning about oslibdir spellings with the lib dir spellings in the +- // GCCInstallationDetector, but that is a more significant refactoring. +- +- if (Triple.getArch() == llvm::Triple::x86) +- return "lib"; +- +- if (Triple.getArch() == llvm::Triple::x86_64) +- return "lib"; +- +- return Triple.isArch32Bit() ? "lib" : "lib64"; +-} +- +-static void addMultilibsFilePaths(const Driver &D, const MultilibSet &Multilibs, +- const Multilib &Multilib, +- StringRef InstallPath, +- ToolChain::path_list &Paths) { +- if (const auto &PathsCallback = Multilibs.filePathsCallback()) +- for (const auto &Path : PathsCallback(Multilib)) +- addPathIfExists(D, InstallPath + Path, Paths); +-} +- +-kFreeBSD::kFreeBSD(const Driver &D, const llvm::Triple &Triple, +- const ArgList &Args) +- : Generic_ELF(D, Triple, Args) { +- GCCInstallation.init(Triple, Args); +- Multilibs = GCCInstallation.getMultilibs(); +- std::string SysRoot = computeSysRoot(); +- +- // Cross-compiling binutils and GCC installations (vanilla and openSUSE at +- // least) put various tools in a triple-prefixed directory off of the parent +- // of the GCC installation. We use the GCC triple here to ensure that we end +- // up with tools that support the same amount of cross compiling as the +- // detected GCC installation. For example, if we find a GCC installation +- // targeting x86_64, but it is a bi-arch GCC installation, it can also be +- // used to target i386. +- // FIXME: This seems unlikely to be Linux-, kFreeBSD- or Hurd-specific. +- ToolChain::path_list &PPaths = getProgramPaths(); +- PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" + +- GCCInstallation.getTriple().str() + "/bin") +- .str()); +- +-#ifdef ENABLE_LINKER_BUILD_ID +- ExtraOpts.push_back("--build-id"); +-#endif +- +- // The selection of paths to try here is designed to match the patterns which +- // the GCC driver itself uses, as this is part of the GCC-compatible driver. +- // This was determined by running GCC in a fake filesystem, creating all +- // possible permutations of these directories, and seeing which ones it added +- // to the link paths. +- path_list &Paths = getFilePaths(); +- +- const std::string OSLibDir = getOSLibDir(Triple, Args); +- const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot); +- +- // Add the multilib suffixed paths where they are available. +- if (GCCInstallation.isValid()) { +- const llvm::Triple &GCCTriple = GCCInstallation.getTriple(); +- const std::string &LibPath = GCCInstallation.getParentLibPath(); +- const Multilib &Multilib = GCCInstallation.getMultilib(); +- const MultilibSet &Multilibs = GCCInstallation.getMultilibs(); +- +- // Add toolchain / multilib specific file paths. +- addMultilibsFilePaths(D, Multilibs, Multilib, +- GCCInstallation.getInstallPath(), Paths); +- +- // Sourcery CodeBench MIPS toolchain holds some libraries under +- // a biarch-like suffix of the GCC installation. +- addPathIfExists(D, GCCInstallation.getInstallPath() + Multilib.gccSuffix(), +- Paths); +- +- // GCC cross compiling toolchains will install target libraries which ship +- // as part of the toolchain under // rather than as +- // any part of the GCC installation in +- // //gcc//. This decision is somewhat +- // debatable, but is the reality today. We need to search this tree even +- // when we have a sysroot somewhere else. It is the responsibility of +- // whomever is doing the cross build targeting a sysroot using a GCC +- // installation that is *not* within the system root to ensure two things: +- // +- // 1) Any DSOs that are linked in from this tree or from the install path +- // above must be present on the system root and found via an +- // appropriate rpath. +- // 2) There must not be libraries installed into +- // // unless they should be preferred over +- // those within the system root. +- // +- // Note that this matches the GCC behavior. See the below comment for where +- // Clang diverges from GCC's behavior. +- addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib/../" + +- OSLibDir + Multilib.osSuffix(), +- Paths); +- +- // If the GCC installation we found is inside of the sysroot, we want to +- // prefer libraries installed in the parent prefix of the GCC installation. +- // It is important to *not* use these paths when the GCC installation is +- // outside of the system root as that can pick up unintended libraries. +- // This usually happens when there is an external cross compiler on the +- // host system, and a more minimal sysroot available that is the target of +- // the cross. Note that GCC does include some of these directories in some +- // configurations but this seems somewhere between questionable and simply +- // a bug. +- if (StringRef(LibPath).startswith(SysRoot)) { +- addPathIfExists(D, LibPath + "/" + MultiarchTriple, Paths); +- addPathIfExists(D, LibPath + "/../" + OSLibDir, Paths); +- } +- } +- +- // Similar to the logic for GCC above, if we currently running Clang inside +- // of the requested system root, add its parent library paths to +- // those searched. +- // FIXME: It's not clear whether we should use the driver's installed +- // directory ('Dir' below) or the ResourceDir. +- if (StringRef(D.Dir).startswith(SysRoot)) { +- addPathIfExists(D, D.Dir + "/../lib/" + MultiarchTriple, Paths); +- addPathIfExists(D, D.Dir + "/../" + OSLibDir, Paths); +- } +- +- addPathIfExists(D, SysRoot + "/lib/" + MultiarchTriple, Paths); +- addPathIfExists(D, SysRoot + "/lib/../" + OSLibDir, Paths); +- +- addPathIfExists(D, SysRoot + "/usr/lib/" + MultiarchTriple, Paths); +- addPathIfExists(D, SysRoot + "/usr/lib/../" + OSLibDir, Paths); +- +- // Try walking via the GCC triple path in case of biarch or multiarch GCC +- // installations with strange symlinks. +- if (GCCInstallation.isValid()) { +- addPathIfExists(D, +- SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() + +- "/../../" + OSLibDir, +- Paths); +- +- // Add the 'other' biarch variant path +- Multilib BiarchSibling; +- if (GCCInstallation.getBiarchSibling(BiarchSibling)) { +- addPathIfExists(D, GCCInstallation.getInstallPath() + +- BiarchSibling.gccSuffix(), +- Paths); +- } +- +- // See comments above on the multilib variant for details of why this is +- // included even from outside the sysroot. +- const std::string &LibPath = GCCInstallation.getParentLibPath(); +- const llvm::Triple &GCCTriple = GCCInstallation.getTriple(); +- const Multilib &Multilib = GCCInstallation.getMultilib(); +- addPathIfExists(D, LibPath + "/../" + GCCTriple.str() + "/lib" + +- Multilib.osSuffix(), +- Paths); +- +- // See comments above on the multilib variant for details of why this is +- // only included from within the sysroot. +- if (StringRef(LibPath).startswith(SysRoot)) +- addPathIfExists(D, LibPath, Paths); +- } +- +- // Similar to the logic for GCC above, if we are currently running Clang +- // inside of the requested system root, add its parent library path to those +- // searched. +- // FIXME: It's not clear whether we should use the driver's installed +- // directory ('Dir' below) or the ResourceDir. +- if (StringRef(D.Dir).startswith(SysRoot)) +- addPathIfExists(D, D.Dir + "/../lib", Paths); +- +- addPathIfExists(D, SysRoot + "/lib", Paths); +- addPathIfExists(D, SysRoot + "/usr/lib", Paths); +-} +- +-bool kFreeBSD::HasNativeLLVMSupport() const { return true; } +- +-Tool *kFreeBSD::buildLinker() const { return new tools::gnutools::Linker(*this); } +- +-Tool *kFreeBSD::buildAssembler() const { +- return new tools::gnutools::Assembler(*this); +-} +- +-std::string kFreeBSD::computeSysRoot() const { +- if (!getDriver().SysRoot.empty()) +- return getDriver().SysRoot; +- +- return std::string(); +-} +- +-std::string kFreeBSD::getDynamicLinker(const ArgList &Args) const { +- const llvm::Triple::ArchType Arch = getArch(); +- +- if (Arch == llvm::Triple::x86_64) +- return "/lib/ld-kfreebsd-x86-64.so.1"; +- +- if (Arch == llvm::Triple::x86) +- return "/lib/ld.so.1"; +- +- llvm_unreachable("unsupported architecture"); +-} +- +-void kFreeBSD::AddClangSystemIncludeArgs(const ArgList &DriverArgs, +- ArgStringList &CC1Args) const { +- const Driver &D = getDriver(); +- std::string SysRoot = computeSysRoot(); +- +- if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc)) +- return; +- +- if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) +- addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include"); +- +- if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { +- SmallString<128> P(D.ResourceDir); +- llvm::sys::path::append(P, "include"); +- addSystemInclude(DriverArgs, CC1Args, P); +- } +- +- if (DriverArgs.hasArg(options::OPT_nostdlibinc)) +- return; +- +- // Check for configure-time C include directories. +- StringRef CIncludeDirs(C_INCLUDE_DIRS); +- if (CIncludeDirs != "") { +- SmallVector dirs; +- CIncludeDirs.split(dirs, ":"); +- for (StringRef dir : dirs) { +- StringRef Prefix = +- llvm::sys::path::is_absolute(dir) ? StringRef(SysRoot) : ""; +- addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir); +- } +- // addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include"); +- return; +- } +- +- // Lacking those, try to detect the correct set of system includes for the +- // target triple. +- +- // Add include directories specific to the selected multilib set and multilib. +- if (GCCInstallation.isValid()) { +- const auto &Callback = Multilibs.includeDirsCallback(); +- if (Callback) { +- for (const auto &Path : Callback(GCCInstallation.getMultilib())) +- addExternCSystemIncludeIfExists( +- DriverArgs, CC1Args, GCCInstallation.getInstallPath() + Path); +- } +- } +- +- // Implement generic Debian multiarch support. +- const StringRef X86_64MultiarchIncludeDirs[] = { +- "/usr/include/x86_64-kfreebsd-gnu"}; +- +- // CHECK +- const StringRef X86MultiarchIncludeDirs[] = { +- "/usr/include/i386-kfreebsd-gnu"}; +- +- ArrayRef MultiarchIncludeDirs; +- switch (getTriple().getArch()) { +- case llvm::Triple::x86: +- MultiarchIncludeDirs = X86MultiarchIncludeDirs; +- break; +- case llvm::Triple::x86_64: +- MultiarchIncludeDirs = X86_64MultiarchIncludeDirs; +- break; +- default: +- break; +- } +- +- for (StringRef Dir : MultiarchIncludeDirs) { +- if (D.getVFS().exists(SysRoot + Dir)) { +- addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + Dir); +- break; +- } +- } +- +- // Add an include of '/include' directly. This isn't provided by default by +- // system GCCs, but is often used with cross-compiling GCCs, and harmless to +- // add even when Clang is acting as-if it were a system compiler. +- addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include"); +- +- addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include"); +-} +- +-static std::string DetectLibcxxIncludePath(StringRef base) { +- std::error_code EC; +- int MaxVersion = 0; +- std::string MaxVersionString = ""; +- for (llvm::sys::fs::directory_iterator LI(base, EC), LE; !EC && LI != LE; +- LI = LI.increment(EC)) { +- StringRef VersionText = llvm::sys::path::filename(LI->path()); +- int Version; +- if (VersionText[0] == 'v' && +- !VersionText.slice(1, StringRef::npos).getAsInteger(10, Version)) { +- if (Version > MaxVersion) { +- MaxVersion = Version; +- MaxVersionString = VersionText; +- } +- } +- } +- return MaxVersion ? (base + "/" + MaxVersionString).str() : ""; +-} +- +-void kFreeBSD::addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, +- llvm::opt::ArgStringList &CC1Args) const { +- const std::string& SysRoot = computeSysRoot(); +- const std::string LibCXXIncludePathCandidates[] = { +- DetectLibcxxIncludePath(getDriver().ResourceDir + "/include/c++"), +- DetectLibcxxIncludePath(getDriver().Dir + "/../include/c++"), +- // If this is a development, non-installed, clang, libcxx will +- // not be found at ../include/c++ but it likely to be found at +- // one of the following two locations: +- DetectLibcxxIncludePath(SysRoot + "/usr/local/include/c++"), +- DetectLibcxxIncludePath(SysRoot + "/usr/include/c++") }; +- for (const auto &IncludePath : LibCXXIncludePathCandidates) { +- if (IncludePath.empty() || !getVFS().exists(IncludePath)) +- continue; +- // Use the first candidate that exists. +- addSystemInclude(DriverArgs, CC1Args, IncludePath); +- return; +- } +-} +- +-void kFreeBSD::addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, +- llvm::opt::ArgStringList &CC1Args) const { +- // We need a detected GCC installation on kFreeBSD to provide libstdc++'s +- // headers. +- if (!GCCInstallation.isValid()) +- return; +- +- // By default, look for the C++ headers in an include directory adjacent to +- // the lib directory of the GCC installation. Note that this is expect to be +- // equivalent to '/usr/include/c++/X.Y' in almost all cases. +- StringRef LibDir = GCCInstallation.getParentLibPath(); +- StringRef InstallDir = GCCInstallation.getInstallPath(); +- StringRef TripleStr = GCCInstallation.getTriple().str(); +- const Multilib &Multilib = GCCInstallation.getMultilib(); +- const std::string GCCMultiarchTriple = getMultiarchTriple( +- getDriver(), GCCInstallation.getTriple(), getDriver().SysRoot); +- const std::string TargetMultiarchTriple = +- getMultiarchTriple(getDriver(), getTriple(), getDriver().SysRoot); +- const GCCVersion &Version = GCCInstallation.getVersion(); +- +- // The primary search for libstdc++ supports multiarch variants. +- if (addLibStdCXXIncludePaths(LibDir.str() + "/../include", +- "/c++/" + Version.Text, TripleStr, +- GCCMultiarchTriple, TargetMultiarchTriple, +- Multilib.includeSuffix(), DriverArgs, CC1Args)) +- return; +- +- // Otherwise, fall back on a bunch of options which don't use multiarch +- // layouts for simplicity. +- const std::string LibStdCXXIncludePathCandidates[] = { +- // Gentoo is weird and places its headers inside the GCC install, +- // so if the first attempt to find the headers fails, try these patterns. +- InstallDir.str() + "/include/g++-v" + Version.Text, +- InstallDir.str() + "/include/g++-v" + Version.MajorStr + "." + +- Version.MinorStr, +- InstallDir.str() + "/include/g++-v" + Version.MajorStr, +- // Android standalone toolchain has C++ headers in yet another place. +- LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.Text, +- // Freescale SDK C++ headers are directly in /usr/include/c++, +- // without a subdirectory corresponding to the gcc version. +- LibDir.str() + "/../include/c++", +- }; +- +- for (const auto &IncludePath : LibStdCXXIncludePathCandidates) { +- if (addLibStdCXXIncludePaths(IncludePath, /*Suffix*/ "", TripleStr, +- /*GCCMultiarchTriple*/ "", +- /*TargetMultiarchTriple*/ "", +- Multilib.includeSuffix(), DriverArgs, CC1Args)) +- break; +- } +-} +- +-/* FIXME: +-/home/srs/DEBs/llvm-toolchain-7/llvm-toolchain-7-7.0.1~+rc2-7/tools/clang/lib/Driver/ToolChains/KFreeBSD.cpp:431:15: error: no declaration matches ‘clang::SanitizerMask clang::driver::toolchains::kFreeBSD::getSupportedSanitizers() const’ +- SanitizerMask kFreeBSD::getSupportedSanitizers() const { +-*/ +-SanitizerMask kFreeBSD::getSupportedSanitizers() const { +- const bool IsX86 = getTriple().getArch() == llvm::Triple::x86; +- const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64; +- SanitizerMask Res = ToolChain::getSupportedSanitizers(); +- // FIXME: Add here!! +- if (IsX86_64) { +- Res |= SanitizerKind::DataFlow; +- Res |= SanitizerKind::Leak; +- Res |= SanitizerKind::Thread; +- Res |= SanitizerKind::Efficiency; +- Res |= SanitizerKind::Scudo; +- Res |= SanitizerKind::HWAddress; +- Res |= SanitizerKind::KernelHWAddress; +- } +- if (IsX86 || IsX86_64) +- Res |= SanitizerKind::Function; +- +- return Res; +-} +- diff --git a/debian/patches/series b/debian/patches/series index 4ba31d7e..4666801a 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -127,3 +127,4 @@ kfreebsd/lib_Target_X86.diff kfreebsd/lldb_source_Host_freebsd_Host.cpp.diff kfreebsd/lldb_source_Plugins_Process_FreeBSD.diff kfreebsd/tools_llvm-shlib_CMakeLists.txt.diff +kfreebsd/vfs.diff