[PATCH] D54379: Add Hurd support
sthibaul updated this revision to Diff 173604. sthibaul added a comment. Herald added a subscriber: srhines. This includes version finding the gcc Hurd triplet (i[3456]-gnu) in the Gcc detector. Repository: rC Clang https://reviews.llvm.org/D54379 Files: lib/Basic/Targets.cpp lib/Basic/Targets/OSTargets.h lib/Driver/CMakeLists.txt lib/Driver/Driver.cpp lib/Driver/ToolChains/Clang.cpp lib/Driver/ToolChains/Gnu.cpp lib/Driver/ToolChains/Hurd.cpp lib/Driver/ToolChains/Hurd.h lib/Frontend/InitHeaderSearch.cpp Index: lib/Frontend/InitHeaderSearch.cpp === --- lib/Frontend/InitHeaderSearch.cpp +++ lib/Frontend/InitHeaderSearch.cpp @@ -260,6 +260,7 @@ switch (os) { case llvm::Triple::Linux: + case llvm::Triple::Hurd: case llvm::Triple::Solaris: llvm_unreachable("Include management is handled in the driver."); Index: lib/Driver/ToolChains/Hurd.h === --- lib/Driver/ToolChains/Hurd.h +++ lib/Driver/ToolChains/Hurd.h @@ -0,0 +1,36 @@ +//===--- Hurd.h - Hurd 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_Hurd_H +#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_Hurd_H + +#include "Gnu.h" +#include "clang/Driver/ToolChain.h" + +namespace clang { +namespace driver { +namespace toolchains { + +class LLVM_LIBRARY_VISIBILITY Hurd : public Generic_ELF { +public: + Hurd(const Driver , const llvm::Triple , + const llvm::opt::ArgList ); + + void + AddClangSystemIncludeArgs(const llvm::opt::ArgList , +llvm::opt::ArgStringList ) const override; + + virtual std::string computeSysRoot() const; +}; + +} // end namespace toolchains +} // end namespace driver +} // end namespace clang + +#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_Hurd_H Index: lib/Driver/ToolChains/Hurd.cpp === --- lib/Driver/ToolChains/Hurd.cpp +++ lib/Driver/ToolChains/Hurd.cpp @@ -0,0 +1,142 @@ +//===--- Hurd.cpp - Hurd 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 "Hurd.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 "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 , + const llvm::Triple , + 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 hurd 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: +if (D.getVFS().exists(SysRoot + "/lib/i386-gnu")) + return "i386-gnu"; +break; + } + + return TargetTriple.str(); +} + +static StringRef getOSLibDir(const llvm::Triple , const ArgList ) { + // 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 "lib32"; + + return Triple.isArch32Bit() ? "lib" : "lib64"; +} + +Hurd::Hurd(const Driver ,
[PATCH] D54379: Add Hurd support
sthibaul updated this revision to Diff 173601. Repository: rC Clang https://reviews.llvm.org/D54379 Files: lib/Basic/Targets.cpp lib/Basic/Targets/OSTargets.h lib/Driver/CMakeLists.txt lib/Driver/Driver.cpp lib/Driver/ToolChains/Clang.cpp lib/Driver/ToolChains/Gnu.cpp lib/Driver/ToolChains/Hurd.cpp lib/Driver/ToolChains/Hurd.h lib/Frontend/InitHeaderSearch.cpp Index: lib/Frontend/InitHeaderSearch.cpp === --- lib/Frontend/InitHeaderSearch.cpp +++ lib/Frontend/InitHeaderSearch.cpp @@ -260,6 +260,7 @@ switch (os) { case llvm::Triple::Linux: + case llvm::Triple::Hurd: case llvm::Triple::Solaris: llvm_unreachable("Include management is handled in the driver."); Index: lib/Driver/ToolChains/Hurd.h === --- lib/Driver/ToolChains/Hurd.h +++ lib/Driver/ToolChains/Hurd.h @@ -0,0 +1,36 @@ +//===--- Hurd.h - Hurd 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_Hurd_H +#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_Hurd_H + +#include "Gnu.h" +#include "clang/Driver/ToolChain.h" + +namespace clang { +namespace driver { +namespace toolchains { + +class LLVM_LIBRARY_VISIBILITY Hurd : public Generic_ELF { +public: + Hurd(const Driver , const llvm::Triple , + const llvm::opt::ArgList ); + + void + AddClangSystemIncludeArgs(const llvm::opt::ArgList , +llvm::opt::ArgStringList ) const override; + + virtual std::string computeSysRoot() const; +}; + +} // end namespace toolchains +} // end namespace driver +} // end namespace clang + +#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_Hurd_H Index: lib/Driver/ToolChains/Hurd.cpp === --- lib/Driver/ToolChains/Hurd.cpp +++ lib/Driver/ToolChains/Hurd.cpp @@ -0,0 +1,142 @@ +//===--- Hurd.cpp - Hurd 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 "Hurd.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 "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 , + const llvm::Triple , + 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 hurd 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: +if (D.getVFS().exists(SysRoot + "/lib/i386-gnu")) + return "i386-gnu"; +break; + } + + return TargetTriple.str(); +} + +static StringRef getOSLibDir(const llvm::Triple , const ArgList ) { + // 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 "lib32"; + + return Triple.isArch32Bit() ? "lib" : "lib64"; +} + +Hurd::Hurd(const Driver , const llvm::Triple , + const ArgList ) +: Generic_ELF(D, Triple, Args) { } + +std::string Hurd::computeSysRoot() const { + if
[PATCH] D54379: Add Hurd support
sthibaul updated this revision to Diff 173599. sthibaul added a comment. In this version, the Driver introduces the "-hurd-" part Repository: rC Clang https://reviews.llvm.org/D54379 Files: lib/Basic/Targets.cpp lib/Basic/Targets/OSTargets.h lib/Driver/CMakeLists.txt lib/Driver/Driver.cpp lib/Driver/ToolChains/Clang.cpp lib/Driver/ToolChains/Gnu.cpp lib/Driver/ToolChains/Hurd.cpp lib/Driver/ToolChains/Hurd.h lib/Frontend/InitHeaderSearch.cpp Index: lib/Frontend/InitHeaderSearch.cpp === --- lib/Frontend/InitHeaderSearch.cpp +++ lib/Frontend/InitHeaderSearch.cpp @@ -260,6 +260,7 @@ switch (os) { case llvm::Triple::Linux: + case llvm::Triple::Hurd: case llvm::Triple::Solaris: llvm_unreachable("Include management is handled in the driver."); Index: lib/Driver/ToolChains/Hurd.h === --- lib/Driver/ToolChains/Hurd.h +++ lib/Driver/ToolChains/Hurd.h @@ -0,0 +1,36 @@ +//===--- Hurd.h - Hurd 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_Hurd_H +#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_Hurd_H + +#include "Gnu.h" +#include "clang/Driver/ToolChain.h" + +namespace clang { +namespace driver { +namespace toolchains { + +class LLVM_LIBRARY_VISIBILITY Hurd : public Generic_ELF { +public: + Hurd(const Driver , const llvm::Triple , + const llvm::opt::ArgList ); + + void + AddClangSystemIncludeArgs(const llvm::opt::ArgList , +llvm::opt::ArgStringList ) const override; + + virtual std::string computeSysRoot() const; +}; + +} // end namespace toolchains +} // end namespace driver +} // end namespace clang + +#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_Hurd_H Index: lib/Driver/ToolChains/Hurd.cpp === --- lib/Driver/ToolChains/Hurd.cpp +++ lib/Driver/ToolChains/Hurd.cpp @@ -0,0 +1,142 @@ +//===--- Hurd.cpp - Hurd 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 "Hurd.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 "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 , + const llvm::Triple , + 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 hurd 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: +if (D.getVFS().exists(SysRoot + "/lib/i386-gnu")) + return "i386-gnu"; +break; + } + + return TargetTriple.str(); +} + +static StringRef getOSLibDir(const llvm::Triple , const ArgList ) { + // 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 "lib32"; + + return Triple.isArch32Bit() ? "lib" : "lib64"; +} + +Hurd::Hurd(const Driver , const llvm::Triple , + const ArgList ) +:
[PATCH] D54379: Add Hurd support
sthibaul added inline comments. Comment at: lib/Driver/ToolChains/Hurd.cpp:136 + + // 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 krytarowski wrote: > Is this some hurd standard or personal taste? I copied this from the Linux.cpp file. Actually it happens to be a standard in the pure GNU system which does not define a /usr. Debian GNU/Hurd eventually migrated to having a real /usr just like other Debian ports to keep things coherent, but the GNU system is supposed to have prefix=/ https://reviews.llvm.org/D54379 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D54379: Add Hurd support
krytarowski added inline comments. Comment at: lib/Driver/ToolChains/Hurd.cpp:136 + + // 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 Is this some hurd standard or personal taste? https://reviews.llvm.org/D54379 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D54379: Add Hurd support
sthibaul updated this revision to Diff 173515. https://reviews.llvm.org/D54379 Files: lib/Basic/Targets.cpp lib/Basic/Targets/OSTargets.h lib/Driver/CMakeLists.txt lib/Driver/Driver.cpp lib/Driver/ToolChains/Clang.cpp lib/Driver/ToolChains/Gnu.cpp lib/Driver/ToolChains/Hurd.cpp lib/Driver/ToolChains/Hurd.h lib/Frontend/InitHeaderSearch.cpp Index: lib/Frontend/InitHeaderSearch.cpp === --- lib/Frontend/InitHeaderSearch.cpp +++ lib/Frontend/InitHeaderSearch.cpp @@ -260,6 +260,7 @@ switch (os) { case llvm::Triple::Linux: + case llvm::Triple::Hurd: case llvm::Triple::Solaris: llvm_unreachable("Include management is handled in the driver."); Index: lib/Driver/ToolChains/Hurd.h === --- lib/Driver/ToolChains/Hurd.h +++ lib/Driver/ToolChains/Hurd.h @@ -0,0 +1,36 @@ +//===--- Hurd.h - Hurd 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_Hurd_H +#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_Hurd_H + +#include "Gnu.h" +#include "clang/Driver/ToolChain.h" + +namespace clang { +namespace driver { +namespace toolchains { + +class LLVM_LIBRARY_VISIBILITY Hurd : public Generic_ELF { +public: + Hurd(const Driver , const llvm::Triple , + const llvm::opt::ArgList ); + + void + AddClangSystemIncludeArgs(const llvm::opt::ArgList , +llvm::opt::ArgStringList ) const override; + + virtual std::string computeSysRoot() const; +}; + +} // end namespace toolchains +} // end namespace driver +} // end namespace clang + +#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_Hurd_H Index: lib/Driver/ToolChains/Hurd.cpp === --- lib/Driver/ToolChains/Hurd.cpp +++ lib/Driver/ToolChains/Hurd.cpp @@ -0,0 +1,142 @@ +//===--- Hurd.cpp - Hurd 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 "Hurd.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 "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 , + const llvm::Triple , + 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 hurd 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: +if (D.getVFS().exists(SysRoot + "/lib/i386-gnu")) + return "i386-gnu"; +break; + } + + return TargetTriple.str(); +} + +static StringRef getOSLibDir(const llvm::Triple , const ArgList ) { + // 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 "lib32"; + + return Triple.isArch32Bit() ? "lib" : "lib64"; +} + +Hurd::Hurd(const Driver , const llvm::Triple , + const ArgList ) +: Generic_ELF(D, Triple, Args) { } + +std::string Hurd::computeSysRoot() const { + if
[PATCH] D54379: Add Hurd support
sthibaul marked 3 inline comments as done. sthibaul added a comment. I commented one of them, and will fix the rest. Comment at: lib/Driver/ToolChains/Hurd.cpp:36 + // clever. + switch (TargetTriple.getArch()) { + default: kristina wrote: > Does this need a switch? Wouldn't an `if` be sufficient? An if would work, yes, it's just to make it easily extensible for future cases, just like the getMultiarchTriple function in Linux.cpp Repository: rC Clang https://reviews.llvm.org/D54379 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D54379: Add Hurd support
kristina added reviewers: kristina, clang. kristina added a comment. A few style naming/comments. Comment at: lib/Driver/ToolChains/Hurd.cpp:36 + // clever. + switch (TargetTriple.getArch()) { + default: Does this need a switch? Wouldn't an `if` be sufficient? Comment at: lib/Driver/ToolChains/Hurd.cpp:106 +CIncludeDirs.split(dirs, ":"); +for (StringRef dir : dirs) { + StringRef Prefix = Variable names should be capitalized. Comment at: lib/Driver/ToolChains/Hurd.cpp:125 +break; + default: +break; Default should generally be the first case, if present. Repository: rC Clang https://reviews.llvm.org/D54379 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D54379: Add Hurd support
kristina added inline comments. Comment at: lib/Driver/ToolChains/Clang.cpp:533 - if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI) { + if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI || Triple.isOSHurd()) { switch (Triple.getArch()) { Please keep line lengths to 80 columns at most, it's one of the few hard rules outlined in the developer policy. Repository: rC Clang https://reviews.llvm.org/D54379 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D54379: Add Hurd support
sthibaul added a comment. The Hurd::Hurd constructor would actually need to do the same gcc inclusion path detection as on Linux, but let's leave this aside for now, this commit is enough for a build without libc++. Repository: rC Clang https://reviews.llvm.org/D54379 ___ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
[PATCH] D54379: Add Hurd support
sthibaul created this revision. sthibaul added a reviewer: rengolin. Herald added subscribers: cfe-commits, fedor.sergeev, krytarowski, mgorny. Repository: rC Clang https://reviews.llvm.org/D54379 Files: lib/Basic/Targets.cpp lib/Basic/Targets/OSTargets.h lib/Driver/CMakeLists.txt lib/Driver/Driver.cpp lib/Driver/ToolChains/Clang.cpp lib/Driver/ToolChains/Gnu.cpp lib/Driver/ToolChains/Hurd.cpp lib/Driver/ToolChains/Hurd.h lib/Frontend/InitHeaderSearch.cpp Index: lib/Frontend/InitHeaderSearch.cpp === --- lib/Frontend/InitHeaderSearch.cpp +++ lib/Frontend/InitHeaderSearch.cpp @@ -260,6 +260,7 @@ switch (os) { case llvm::Triple::Linux: + case llvm::Triple::Hurd: case llvm::Triple::Solaris: llvm_unreachable("Include management is handled in the driver."); Index: lib/Driver/ToolChains/Hurd.h === --- lib/Driver/ToolChains/Hurd.h +++ lib/Driver/ToolChains/Hurd.h @@ -0,0 +1,36 @@ +//===--- Hurd.h - Hurd 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_Hurd_H +#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_Hurd_H + +#include "Gnu.h" +#include "clang/Driver/ToolChain.h" + +namespace clang { +namespace driver { +namespace toolchains { + +class LLVM_LIBRARY_VISIBILITY Hurd : public Generic_ELF { +public: + Hurd(const Driver , const llvm::Triple , + const llvm::opt::ArgList ); + + void + AddClangSystemIncludeArgs(const llvm::opt::ArgList , +llvm::opt::ArgStringList ) const override; + + virtual std::string computeSysRoot() const; +}; + +} // end namespace toolchains +} // end namespace driver +} // end namespace clang + +#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_Hurd_H Index: lib/Driver/ToolChains/Hurd.cpp === --- lib/Driver/ToolChains/Hurd.cpp +++ lib/Driver/ToolChains/Hurd.cpp @@ -0,0 +1,142 @@ +//===--- Hurd.cpp - Hurd 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 "Hurd.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 "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 , + const llvm::Triple , + 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 hurd 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: +if (D.getVFS().exists(SysRoot + "/lib/i386-gnu")) + return "i386-gnu"; +break; + } + + return TargetTriple.str(); +} + +static StringRef getOSLibDir(const llvm::Triple , const ArgList ) { + // 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 "lib32"; + + return Triple.isArch32Bit() ? "lib" : "lib64"; +} + +Hurd::Hurd(const Driver , const llvm::Triple , + const ArgList )