Clang Project

clang_source_code/lib/Driver/ToolChains/Hurd.cpp
1//===--- Hurd.cpp - Hurd ToolChain Implementations --------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "Hurd.h"
10#include "CommonArgs.h"
11#include "clang/Config/config.h"
12#include "clang/Driver/Driver.h"
13#include "clang/Driver/Options.h"
14#include "llvm/Support/Path.h"
15#include "llvm/Support/VirtualFileSystem.h"
16
17using namespace clang::driver;
18using namespace clang::driver::toolchains;
19using namespace clang;
20using namespace llvm::opt;
21
22using tools::addPathIfExists;
23
24/// Get our best guess at the multiarch triple for a target.
25///
26/// Debian-based systems are starting to use a multiarch setup where they use
27/// a target-triple directory in the library and header search paths.
28/// Unfortunately, this triple does not align with the vanilla target triple,
29/// so we provide a rough mapping here.
30static std::string getMultiarchTriple(const Driver &D,
31                                      const llvm::Triple &TargetTriple,
32                                      StringRef SysRoot) {
33  if (TargetTriple.getArch() == llvm::Triple::x86) {
34    // We use the existence of '/lib/<triple>' as a directory to detect some
35    // common hurd triples that don't quite match the Clang triple for both
36    // 32-bit and 64-bit targets. Multiarch fixes its install triples to these
37    // regardless of what the actual target triple is.
38    if (D.getVFS().exists(SysRoot + "/lib/i386-gnu"))
39      return "i386-gnu";
40  }
41
42  // For most architectures, just use whatever we have rather than trying to be
43  // clever.
44  return TargetTriple.str();
45}
46
47static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
48  // It happens that only x86 and PPC use the 'lib32' variant of oslibdir, and
49  // using that variant while targeting other architectures causes problems
50  // because the libraries are laid out in shared system roots that can't cope
51  // with a 'lib32' library search path being considered. So we only enable
52  // them when we know we may need it.
53  //
54  // FIXME: This is a bit of a hack. We should really unify this code for
55  // reasoning about oslibdir spellings with the lib dir spellings in the
56  // GCCInstallationDetector, but that is a more significant refactoring.
57
58  if (Triple.getArch() == llvm::Triple::x86)
59    return "lib32";
60
61  return Triple.isArch32Bit() ? "lib" : "lib64";
62}
63
64Hurd::Hurd(const Driver &D, const llvm::Triple &Triple,
65           const ArgList &Args)
66    : Generic_ELF(D, Triple, Args) {
67  std::string SysRoot = computeSysRoot();
68  path_list &Paths = getFilePaths();
69
70  const std::string OSLibDir = getOSLibDir(Triple, Args);
71  const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot);
72
73  // If we are currently running Clang inside of the requested system root, add
74  // its parent library paths to those searched.
75  // FIXME: It's not clear whether we should use the driver's installed
76  // directory ('Dir' below) or the ResourceDir.
77  if (StringRef(D.Dir).startswith(SysRoot)) {
78    addPathIfExists(D, D.Dir + "/../lib/" + MultiarchTriple, Paths);
79    addPathIfExists(D, D.Dir + "/../" + OSLibDir, Paths);
80  }
81
82  addPathIfExists(D, SysRoot + "/lib/" + MultiarchTriple, Paths);
83  addPathIfExists(D, SysRoot + "/lib/../" + OSLibDir, Paths);
84
85  addPathIfExists(D, SysRoot + "/usr/lib/" + MultiarchTriple, Paths);
86  addPathIfExists(D, SysRoot + "/usr/lib/../" + OSLibDir, Paths);
87
88  // If we are currently running Clang inside of the requested system root, add
89  // its parent library path to those searched.
90  // FIXME: It's not clear whether we should use the driver's installed
91  // directory ('Dir' below) or the ResourceDir.
92  if (StringRef(D.Dir).startswith(SysRoot))
93    addPathIfExists(D, D.Dir + "/../lib", Paths);
94
95  addPathIfExists(D, SysRoot + "/lib", Paths);
96  addPathIfExists(D, SysRoot + "/usr/lib", Paths);
97}
98
99bool Hurd::HasNativeLLVMSupport() const { return true; }
100
101Tool *Hurd::buildLinker() const { return new tools::gnutools::Linker(*this); }
102
103Tool *Hurd::buildAssembler() const {
104  return new tools::gnutools::Assembler(*this);
105}
106
107std::string Hurd::computeSysRoot() const {
108  if (!getDriver().SysRoot.empty())
109    return getDriver().SysRoot;
110
111  return std::string();
112}
113
114std::string Hurd::getDynamicLinker(const ArgList &Args) const {
115  if (getArch() == llvm::Triple::x86)
116    return "/lib/ld.so";
117
118  llvm_unreachable("unsupported architecture");
119}
120
121void Hurd::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
122                                     ArgStringList &CC1Args) const {
123  const Driver &D = getDriver();
124  std::string SysRoot = computeSysRoot();
125
126  if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))
127    return;
128
129  if (!DriverArgs.hasArg(options::OPT_nostdlibinc))
130    addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include");
131
132  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
133    SmallString<128> P(D.ResourceDir);
134    llvm::sys::path::append(P, "include");
135    addSystemInclude(DriverArgs, CC1Args, P);
136  }
137
138  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
139    return;
140
141  // Check for configure-time C include directories.
142  StringRef CIncludeDirs(C_INCLUDE_DIRS);
143  if (CIncludeDirs != "") {
144    SmallVector<StringRef, 5> Dirs;
145    CIncludeDirs.split(Dirs, ":");
146    for (StringRef Dir : Dirs) {
147      StringRef Prefix =
148          llvm::sys::path::is_absolute(Dir) ? StringRef(SysRoot) : "";
149      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + Dir);
150    }
151    return;
152  }
153
154  // Lacking those, try to detect the correct set of system includes for the
155  // target triple.
156  if (getTriple().getArch() == llvm::Triple::x86) {
157    std::string Path = SysRoot + "/usr/include/i386-gnu";
158    if (D.getVFS().exists(Path))
159      addExternCSystemInclude(DriverArgs, CC1Args, Path);
160  }
161
162  // Add an include of '/include' directly. This isn't provided by default by
163  // system GCCs, but is often used with cross-compiling GCCs, and harmless to
164  // add even when Clang is acting as-if it were a system compiler.
165  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
166
167  addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include");
168}
169
CodeThinker, Enjoy your reading code