clang  13.0.0git
Gnu.h
Go to the documentation of this file.
1 //===--- Gnu.h - Gnu Tool and 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 #ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GNU_H
10 #define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GNU_H
11 
12 #include "Cuda.h"
13 #include "ROCm.h"
14 #include "clang/Driver/Tool.h"
15 #include "clang/Driver/ToolChain.h"
16 #include <set>
17 
18 namespace clang {
19 namespace driver {
20 
22  /// The set of multilibs that the detected installation supports.
24 
25  /// The primary multilib appropriate for the given flags.
27 
28  /// On Biarch systems, this corresponds to the default multilib when
29  /// targeting the non-default multilib. Otherwise, it is empty.
31 };
32 
33 bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple,
34  StringRef Path, const llvm::opt::ArgList &Args,
35  DetectedMultilibs &Result);
36 
37 namespace tools {
38 
39 /// Directly call GNU Binutils' assembler and linker.
40 namespace gnutools {
41 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
42 public:
43  Assembler(const ToolChain &TC) : Tool("GNU::Assembler", "assembler", TC) {}
44 
45  bool hasIntegratedCPP() const override { return false; }
46 
47  void ConstructJob(Compilation &C, const JobAction &JA,
48  const InputInfo &Output, const InputInfoList &Inputs,
49  const llvm::opt::ArgList &TCArgs,
50  const char *LinkingOutput) const override;
51 };
52 
53 class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
54 public:
55  Linker(const ToolChain &TC) : Tool("GNU::Linker", "linker", TC) {}
56 
57  bool hasIntegratedCPP() const override { return false; }
58  bool isLinkJob() const override { return true; }
59 
60  void ConstructJob(Compilation &C, const JobAction &JA,
61  const InputInfo &Output, const InputInfoList &Inputs,
62  const llvm::opt::ArgList &TCArgs,
63  const char *LinkingOutput) const override;
64 };
65 
66 class LLVM_LIBRARY_VISIBILITY StaticLibTool : public Tool {
67 public:
69  : Tool("GNU::StaticLibTool", "static-lib-linker", TC) {}
70 
71  bool hasIntegratedCPP() const override { return false; }
72  bool isLinkJob() const override { return true; }
73 
74  void ConstructJob(Compilation &C, const JobAction &JA,
75  const InputInfo &Output, const InputInfoList &Inputs,
76  const llvm::opt::ArgList &TCArgs,
77  const char *LinkingOutput) const override;
78 };
79 } // end namespace gnutools
80 
81 /// gcc - Generic GCC tool implementations.
82 namespace gcc {
83 class LLVM_LIBRARY_VISIBILITY Common : public Tool {
84 public:
85  Common(const char *Name, const char *ShortName, const ToolChain &TC)
86  : Tool(Name, ShortName, TC) {}
87 
88  // A gcc tool has an "integrated" assembler that it will call to produce an
89  // object. Let it use that assembler so that we don't have to deal with
90  // assembly syntax incompatibilities.
91  bool hasIntegratedAssembler() const override { return true; }
92  void ConstructJob(Compilation &C, const JobAction &JA,
93  const InputInfo &Output, const InputInfoList &Inputs,
94  const llvm::opt::ArgList &TCArgs,
95  const char *LinkingOutput) const override;
96 
97  /// RenderExtraToolArgs - Render any arguments necessary to force
98  /// the particular tool mode.
99  virtual void RenderExtraToolArgs(const JobAction &JA,
100  llvm::opt::ArgStringList &CmdArgs) const = 0;
101 };
102 
103 class LLVM_LIBRARY_VISIBILITY Preprocessor : public Common {
104 public:
106  : Common("gcc::Preprocessor", "gcc preprocessor", TC) {}
107 
108  bool hasGoodDiagnostics() const override { return true; }
109  bool hasIntegratedCPP() const override { return false; }
110 
111  void RenderExtraToolArgs(const JobAction &JA,
112  llvm::opt::ArgStringList &CmdArgs) const override;
113 };
114 
115 class LLVM_LIBRARY_VISIBILITY Compiler : public Common {
116 public:
117  Compiler(const ToolChain &TC) : Common("gcc::Compiler", "gcc frontend", TC) {}
118 
119  bool hasGoodDiagnostics() const override { return true; }
120  bool hasIntegratedCPP() const override { return true; }
121 
122  void RenderExtraToolArgs(const JobAction &JA,
123  llvm::opt::ArgStringList &CmdArgs) const override;
124 };
125 
126 class LLVM_LIBRARY_VISIBILITY Linker : public Common {
127 public:
128  Linker(const ToolChain &TC) : Common("gcc::Linker", "linker (via gcc)", TC) {}
129 
130  bool hasIntegratedCPP() const override { return false; }
131  bool isLinkJob() const override { return true; }
132 
133  void RenderExtraToolArgs(const JobAction &JA,
134  llvm::opt::ArgStringList &CmdArgs) const override;
135 };
136 } // end namespace gcc
137 } // end namespace tools
138 
139 namespace toolchains {
140 
141 /// Generic_GCC - A tool chain using the 'gcc' command to perform
142 /// all subcommands; this relies on gcc translating the majority of
143 /// command line options.
144 class LLVM_LIBRARY_VISIBILITY Generic_GCC : public ToolChain {
145 public:
146  /// Struct to store and manipulate GCC versions.
147  ///
148  /// We rely on assumptions about the form and structure of GCC version
149  /// numbers: they consist of at most three '.'-separated components, and each
150  /// component is a non-negative integer except for the last component. For
151  /// the last component we are very flexible in order to tolerate release
152  /// candidates or 'x' wildcards.
153  ///
154  /// Note that the ordering established among GCCVersions is based on the
155  /// preferred version string to use. For example we prefer versions without
156  /// a hard-coded patch number to those with a hard coded patch number.
157  ///
158  /// Currently this doesn't provide any logic for textual suffixes to patches
159  /// in the way that (for example) Debian's version format does. If that ever
160  /// becomes necessary, it can be added.
161  struct GCCVersion {
162  /// The unparsed text of the version.
164 
165  /// The parsed major, minor, and patch numbers.
166  int Major, Minor, Patch;
167 
168  /// The text of the parsed major, and major+minor versions.
170 
171  /// Any textual suffix on the patch number.
173 
174  static GCCVersion Parse(StringRef VersionText);
175  bool isOlderThan(int RHSMajor, int RHSMinor, int RHSPatch,
176  StringRef RHSPatchSuffix = StringRef()) const;
177  bool operator<(const GCCVersion &RHS) const {
178  return isOlderThan(RHS.Major, RHS.Minor, RHS.Patch, RHS.PatchSuffix);
179  }
180  bool operator>(const GCCVersion &RHS) const { return RHS < *this; }
181  bool operator<=(const GCCVersion &RHS) const { return !(*this > RHS); }
182  bool operator>=(const GCCVersion &RHS) const { return !(*this < RHS); }
183  };
184 
185  /// This is a class to find a viable GCC installation for Clang to
186  /// use.
187  ///
188  /// This class tries to find a GCC installation on the system, and report
189  /// information about it. It starts from the host information provided to the
190  /// Driver, and has logic for fuzzing that where appropriate.
192  bool IsValid;
193  llvm::Triple GCCTriple;
194  const Driver &D;
195 
196  // FIXME: These might be better as path objects.
197  std::string GCCInstallPath;
198  std::string GCCParentLibPath;
199 
200  /// The primary multilib appropriate for the given flags.
201  Multilib SelectedMultilib;
202  /// On Biarch systems, this corresponds to the default multilib when
203  /// targeting the non-default multilib. Otherwise, it is empty.
204  llvm::Optional<Multilib> BiarchSibling;
205 
206  GCCVersion Version;
207 
208  // We retain the list of install paths that were considered and rejected in
209  // order to print out detailed information in verbose mode.
210  std::set<std::string> CandidateGCCInstallPaths;
211 
212  /// The set of multilibs that the detected installation supports.
213  MultilibSet Multilibs;
214 
215  // Gentoo-specific toolchain configurations are stored here.
216  const std::string GentooConfigDir = "/etc/env.d/gcc";
217 
218  public:
219  explicit GCCInstallationDetector(const Driver &D) : IsValid(false), D(D) {}
220  void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args,
221  ArrayRef<std::string> ExtraTripleAliases = None);
222 
223  /// Check whether we detected a valid GCC install.
224  bool isValid() const { return IsValid; }
225 
226  /// Get the GCC triple for the detected install.
227  const llvm::Triple &getTriple() const { return GCCTriple; }
228 
229  /// Get the detected GCC installation path.
230  StringRef getInstallPath() const { return GCCInstallPath; }
231 
232  /// Get the detected GCC parent lib path.
233  StringRef getParentLibPath() const { return GCCParentLibPath; }
234 
235  /// Get the detected Multilib
236  const Multilib &getMultilib() const { return SelectedMultilib; }
237 
238  /// Get the whole MultilibSet
239  const MultilibSet &getMultilibs() const { return Multilibs; }
240 
241  /// Get the biarch sibling multilib (if it exists).
242  /// \return true iff such a sibling exists
243  bool getBiarchSibling(Multilib &M) const;
244 
245  /// Get the detected GCC version string.
246  const GCCVersion &getVersion() const { return Version; }
247 
248  /// Print information about the detected GCC installation.
249  void print(raw_ostream &OS) const;
250 
251  private:
252  static void
253  CollectLibDirsAndTriples(const llvm::Triple &TargetTriple,
254  const llvm::Triple &BiarchTriple,
256  SmallVectorImpl<StringRef> &TripleAliases,
257  SmallVectorImpl<StringRef> &BiarchLibDirs,
258  SmallVectorImpl<StringRef> &BiarchTripleAliases);
259 
260  void AddDefaultGCCPrefixes(const llvm::Triple &TargetTriple,
262  StringRef SysRoot);
263 
264  bool ScanGCCForMultilibs(const llvm::Triple &TargetTriple,
265  const llvm::opt::ArgList &Args,
266  StringRef Path,
267  bool NeedsBiarchSuffix = false);
268 
269  void ScanLibDirForGCCTriple(const llvm::Triple &TargetArch,
270  const llvm::opt::ArgList &Args,
271  const std::string &LibDir,
272  StringRef CandidateTriple,
273  bool NeedsBiarchSuffix, bool GCCDirExists,
274  bool GCCCrossDirExists);
275 
276  bool ScanGentooConfigs(const llvm::Triple &TargetTriple,
277  const llvm::opt::ArgList &Args,
278  const SmallVectorImpl<StringRef> &CandidateTriples,
279  const SmallVectorImpl<StringRef> &BiarchTriples);
280 
281  bool ScanGentooGccConfig(const llvm::Triple &TargetTriple,
282  const llvm::opt::ArgList &Args,
283  StringRef CandidateTriple,
284  bool NeedsBiarchSuffix = false);
285  };
286 
287 protected:
291 
292 public:
293  Generic_GCC(const Driver &D, const llvm::Triple &Triple,
294  const llvm::opt::ArgList &Args);
295  ~Generic_GCC() override;
296 
297  void printVerboseInfo(raw_ostream &OS) const override;
298 
299  bool IsUnwindTablesDefault(const llvm::opt::ArgList &Args) const override;
300  bool isPICDefault() const override;
301  bool isPIEDefault() const override;
302  bool isPICDefaultForced() const override;
303  bool IsIntegratedAssemblerDefault() const override;
304  llvm::opt::DerivedArgList *
305  TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
306  Action::OffloadKind DeviceOffloadKind) const override;
307 
308 protected:
309  Tool *getTool(Action::ActionClass AC) const override;
310  Tool *buildAssembler() const override;
311  Tool *buildLinker() const override;
312 
313  /// \name ToolChain Implementation Helper Functions
314  /// @{
315 
316  /// Check whether the target triple's architecture is 64-bits.
317  bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
318 
319  /// Check whether the target triple's architecture is 32-bits.
320  bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
321 
322  void PushPPaths(ToolChain::path_list &PPaths);
323  void AddMultilibPaths(const Driver &D, const std::string &SysRoot,
324  const std::string &OSLibDir,
325  const std::string &MultiarchTriple,
326  path_list &Paths);
327  void AddMultiarchPaths(const Driver &D, const std::string &SysRoot,
328  const std::string &OSLibDir, path_list &Paths);
329  void AddMultilibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
330  llvm::opt::ArgStringList &CC1Args) const;
331 
332  // FIXME: This should be final, but the CrossWindows toolchain does weird
333  // things that can't be easily generalized.
334  void AddClangCXXStdlibIncludeArgs(
335  const llvm::opt::ArgList &DriverArgs,
336  llvm::opt::ArgStringList &CC1Args) const override;
337 
338  virtual void
339  addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
340  llvm::opt::ArgStringList &CC1Args) const;
341  virtual void
342  addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
343  llvm::opt::ArgStringList &CC1Args) const;
344 
345  bool addGCCLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
346  llvm::opt::ArgStringList &CC1Args,
347  StringRef DebianMultiarch) const;
348 
349  bool addLibStdCXXIncludePaths(Twine IncludeDir, StringRef Triple,
350  Twine IncludeSuffix,
351  const llvm::opt::ArgList &DriverArgs,
352  llvm::opt::ArgStringList &CC1Args,
353  bool DetectDebian = false) const;
354 
355  /// @}
356 
357 private:
358  mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocess;
359  mutable std::unique_ptr<tools::gcc::Compiler> Compile;
360 };
361 
362 class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC {
363  virtual void anchor();
364 
365 public:
366  Generic_ELF(const Driver &D, const llvm::Triple &Triple,
367  const llvm::opt::ArgList &Args)
368  : Generic_GCC(D, Triple, Args) {}
369 
370  void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
371  llvm::opt::ArgStringList &CC1Args,
372  Action::OffloadKind DeviceOffloadKind) const override;
373 
374  virtual std::string getDynamicLinker(const llvm::opt::ArgList &Args) const {
375  return {};
376  }
377 
378  virtual void addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {}
379 };
380 
381 } // end namespace toolchains
382 } // end namespace driver
383 } // end namespace clang
384 
385 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GNU_H
clang::driver::tools::gnutools::StaticLibTool
Definition: Gnu.h:66
clang::driver::tools::gnutools::Assembler::Assembler
Assembler(const ToolChain &TC)
Definition: Gnu.h:43
clang::driver::toolchains::Generic_ELF::addExtraOpts
virtual void addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const
Definition: Gnu.h:378
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::driver::MultilibSet
Definition: Multilib.h:114
clang::driver::findMIPSMultilibs
bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const llvm::opt::ArgList &Args, DetectedMultilibs &Result)
clang::driver::toolchains::Generic_GCC::isTarget32Bit
bool isTarget32Bit() const
Check whether the target triple's architecture is 32-bits.
Definition: Gnu.h:320
llvm::SmallVector
Definition: LLVM.h:38
clang::driver::toolchains::Generic_GCC::GCCInstallation
GCCInstallationDetector GCCInstallation
Definition: Gnu.h:288
clang::driver::Action::ActionClass
ActionClass
Definition: Action.h:55
clang::driver::tools::gcc::Preprocessor::hasGoodDiagnostics
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Gnu.h:108
clang::driver::tools::gcc::Common::hasIntegratedAssembler
bool hasIntegratedAssembler() const override
Definition: Gnu.h:91
clang::driver::phases::Preprocess
@ Preprocess
Definition: Phases.h:18
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::GCCInstallationDetector
GCCInstallationDetector(const Driver &D)
Definition: Gnu.h:219
clang::driver::toolchains::Generic_ELF::getDynamicLinker
virtual std::string getDynamicLinker(const llvm::opt::ArgList &Args) const
Definition: Gnu.h:374
clang::driver::toolchains::Generic_GCC::CudaInstallation
CudaInstallationDetector CudaInstallation
Definition: Gnu.h:289
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::isValid
bool isValid() const
Check whether we detected a valid GCC install.
Definition: Gnu.h:224
llvm::Optional
Definition: LLVM.h:40
clang::driver::toolchains::Generic_GCC::GCCVersion::Minor
int Minor
Definition: Gnu.h:166
print
void print(llvm::raw_ostream &OS, const Pointer &P, ASTContext &Ctx, QualType Ty)
Definition: InterpFrame.cpp:62
clang::driver::tools::gnutools::Assembler::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Gnu.h:45
clang::driver::InputInfo
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
clang::driver::tools::gcc::Linker::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Gnu.h:130
clang::driver::tools::gnutools::Linker::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Gnu.h:57
clang::driver::toolchains::Generic_GCC::GCCVersion
Struct to store and manipulate GCC versions.
Definition: Gnu.h:161
clang::driver::tools::gcc::Compiler::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Gnu.h:120
clang::driver::Tool
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
clang::driver::toolchains::Generic_ELF
Definition: Gnu.h:362
clang::driver::toolchains::Generic_GCC::GCCVersion::Text
std::string Text
The unparsed text of the version.
Definition: Gnu.h:163
clang::driver::tools::gnutools::Linker
Definition: Gnu.h:53
clang::driver::tools::gnutools::Linker::Linker
Linker(const ToolChain &TC)
Definition: Gnu.h:55
clang::driver::DetectedMultilibs::SelectedMultilib
Multilib SelectedMultilib
The primary multilib appropriate for the given flags.
Definition: Gnu.h:26
clang::driver::tools::gcc::Compiler::hasGoodDiagnostics
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Gnu.h:119
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getTriple
const llvm::Triple & getTriple() const
Get the GCC triple for the detected install.
Definition: Gnu.h:227
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getParentLibPath
StringRef getParentLibPath() const
Get the detected GCC parent lib path.
Definition: Gnu.h:233
Tool.h
clang::driver::tools::gcc::Common::Common
Common(const char *Name, const char *ShortName, const ToolChain &TC)
Definition: Gnu.h:85
clang::driver::Multilib
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag.
Definition: Multilib.h:28
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector
This is a class to find a viable GCC installation for Clang to use.
Definition: Gnu.h:191
clang::driver::toolchains::Generic_GCC::GCCVersion::PatchSuffix
std::string PatchSuffix
Any textual suffix on the patch number.
Definition: Gnu.h:172
clang::driver::toolchains::Generic_ELF::Generic_ELF
Generic_ELF(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: Gnu.h:366
clang::driver::tools::gcc::Common
Definition: Gnu.h:83
clang::driver::tools::gcc::Linker
Definition: Gnu.h:126
clang::driver::toolchains::Generic_GCC::GCCVersion::operator<
bool operator<(const GCCVersion &RHS) const
Definition: Gnu.h:177
clang::driver::toolchains::Generic_GCC::RocmInstallation
RocmInstallationDetector RocmInstallation
Definition: Gnu.h:290
ToolChain.h
clang::driver::tools::gnutools::Linker::isLinkJob
bool isLinkJob() const override
Definition: Gnu.h:58
clang::driver::tools::gcc::Preprocessor::Preprocessor
Preprocessor(const ToolChain &TC)
Definition: Gnu.h:105
clang::driver::toolchains::Generic_GCC::GCCVersion::operator>
bool operator>(const GCCVersion &RHS) const
Definition: Gnu.h:180
false
#define false
Definition: stdbool.h:17
ROCm.h
clang::driver::toolchains::Generic_GCC::GCCVersion::operator<=
bool operator<=(const GCCVersion &RHS) const
Definition: Gnu.h:181
clang::driver::ToolChain
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:91
llvm::ArrayRef< std::string >
clang::driver::toolchains::Generic_GCC::isTarget64Bit
bool isTarget64Bit() const
Check whether the target triple's architecture is 64-bits.
Definition: Gnu.h:317
clang::driver::tools::gcc::Linker::isLinkJob
bool isLinkJob() const override
Definition: Gnu.h:131
clang::driver::tools::gnutools::Assembler
Definition: Gnu.h:41
clang::driver::tools::gcc::Preprocessor
Definition: Gnu.h:103
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getInstallPath
StringRef getInstallPath() const
Get the detected GCC installation path.
Definition: Gnu.h:230
clang::driver::CudaInstallationDetector
A class to find a viable CUDA installation.
Definition: Cuda.h:28
clang::driver::Compilation
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getVersion
const GCCVersion & getVersion() const
Get the detected GCC version string.
Definition: Gnu.h:246
clang::driver::RocmInstallationDetector
A class to find a viable ROCM installation TODO: Generalize to handle libclc.
Definition: ROCm.h:27
clang::driver::toolchains::Generic_GCC::GCCVersion::Major
int Major
The parsed major, minor, and patch numbers.
Definition: Gnu.h:166
clang::driver::toolchains::Generic_GCC::GCCVersion::MinorStr
std::string MinorStr
Definition: Gnu.h:169
clang::driver::tools::gcc::Linker::Linker
Linker(const ToolChain &TC)
Definition: Gnu.h:128
clang
Definition: CalledOnceCheck.h:17
clang::driver::Driver
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
clang::driver::tools::gnutools::StaticLibTool::StaticLibTool
StaticLibTool(const ToolChain &TC)
Definition: Gnu.h:68
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getMultilib
const Multilib & getMultilib() const
Get the detected Multilib.
Definition: Gnu.h:236
clang::driver::toolchains::Generic_GCC::GCCVersion::operator>=
bool operator>=(const GCCVersion &RHS) const
Definition: Gnu.h:182
clang::driver::tools::gcc::Compiler
Definition: Gnu.h:115
clang::driver::toolchains::Generic_GCC::GCCInstallationDetector::getMultilibs
const MultilibSet & getMultilibs() const
Get the whole MultilibSet.
Definition: Gnu.h:239
clang::driver::tools::gnutools::StaticLibTool::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Gnu.h:71
clang::driver::DetectedMultilibs
Definition: Gnu.h:21
clang::driver::toolchains::Generic_GCC::GCCVersion::Patch
int Patch
Definition: Gnu.h:166
clang::driver::tools::gcc::Compiler::Compiler
Compiler(const ToolChain &TC)
Definition: Gnu.h:117
clang::driver::phases::Compile
@ Compile
Definition: Phases.h:20
clang::driver::DetectedMultilibs::BiarchSibling
llvm::Optional< Multilib > BiarchSibling
On Biarch systems, this corresponds to the default multilib when targeting the non-default multilib.
Definition: Gnu.h:30
clang::driver::Action::OffloadKind
OffloadKind
Definition: Action.h:85
llvm::SmallVectorImpl
Definition: LLVM.h:39
clang::driver::tools::gnutools::StaticLibTool::isLinkJob
bool isLinkJob() const override
Definition: Gnu.h:72
clang::driver::JobAction
Definition: Action.h:380
clang::driver::DetectedMultilibs::Multilibs
MultilibSet Multilibs
The set of multilibs that the detected installation supports.
Definition: Gnu.h:23
clang::driver::tools::gcc::Preprocessor::hasIntegratedCPP
bool hasIntegratedCPP() const override
Definition: Gnu.h:109
clang::driver::toolchains::Generic_GCC
Generic_GCC - A tool chain using the 'gcc' command to perform all subcommands; this relies on gcc tra...
Definition: Gnu.h:144
Cuda.h