clang  11.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.
163  std::string Text;
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.
169  std::string MajorStr, MinorStr;
170 
171  /// Any textual suffix on the patch number.
172  std::string PatchSuffix;
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.
202  /// On Biarch systems, this corresponds to the default multilib when
203  /// targeting the non-default multilib. Otherwise, it is empty.
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.
214 
215  public:
216  explicit GCCInstallationDetector(const Driver &D) : IsValid(false), D(D) {}
217  void init(const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args,
218  ArrayRef<std::string> ExtraTripleAliases = None);
219 
220  /// Check whether we detected a valid GCC install.
221  bool isValid() const { return IsValid; }
222 
223  /// Get the GCC triple for the detected install.
224  const llvm::Triple &getTriple() const { return GCCTriple; }
225 
226  /// Get the detected GCC installation path.
227  StringRef getInstallPath() const { return GCCInstallPath; }
228 
229  /// Get the detected GCC parent lib path.
230  StringRef getParentLibPath() const { return GCCParentLibPath; }
231 
232  /// Get the detected Multilib
233  const Multilib &getMultilib() const { return SelectedMultilib; }
234 
235  /// Get the whole MultilibSet
236  const MultilibSet &getMultilibs() const { return Multilibs; }
237 
238  /// Get the biarch sibling multilib (if it exists).
239  /// \return true iff such a sibling exists
240  bool getBiarchSibling(Multilib &M) const;
241 
242  /// Get the detected GCC version string.
243  const GCCVersion &getVersion() const { return Version; }
244 
245  /// Print information about the detected GCC installation.
246  void print(raw_ostream &OS) const;
247 
248  private:
249  static void
250  CollectLibDirsAndTriples(const llvm::Triple &TargetTriple,
251  const llvm::Triple &BiarchTriple,
253  SmallVectorImpl<StringRef> &TripleAliases,
254  SmallVectorImpl<StringRef> &BiarchLibDirs,
255  SmallVectorImpl<StringRef> &BiarchTripleAliases);
256 
257  void AddDefaultGCCPrefixes(const llvm::Triple &TargetTriple,
259  StringRef SysRoot);
260 
261  bool ScanGCCForMultilibs(const llvm::Triple &TargetTriple,
262  const llvm::opt::ArgList &Args,
263  StringRef Path,
264  bool NeedsBiarchSuffix = false);
265 
266  void ScanLibDirForGCCTriple(const llvm::Triple &TargetArch,
267  const llvm::opt::ArgList &Args,
268  const std::string &LibDir,
269  StringRef CandidateTriple,
270  bool NeedsBiarchSuffix = false);
271 
272  bool ScanGentooConfigs(const llvm::Triple &TargetTriple,
273  const llvm::opt::ArgList &Args,
274  const SmallVectorImpl<StringRef> &CandidateTriples,
275  const SmallVectorImpl<StringRef> &BiarchTriples);
276 
277  bool ScanGentooGccConfig(const llvm::Triple &TargetTriple,
278  const llvm::opt::ArgList &Args,
279  StringRef CandidateTriple,
280  bool NeedsBiarchSuffix = false);
281  };
282 
283 protected:
287 
288 public:
289  Generic_GCC(const Driver &D, const llvm::Triple &Triple,
290  const llvm::opt::ArgList &Args);
291  ~Generic_GCC() override;
292 
293  void printVerboseInfo(raw_ostream &OS) const override;
294 
295  bool IsUnwindTablesDefault(const llvm::opt::ArgList &Args) const override;
296  bool isPICDefault() const override;
297  bool isPIEDefault() const override;
298  bool isPICDefaultForced() const override;
299  bool IsIntegratedAssemblerDefault() const override;
300  llvm::opt::DerivedArgList *
301  TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
302  Action::OffloadKind DeviceOffloadKind) const override;
303 
304 protected:
305  Tool *getTool(Action::ActionClass AC) const override;
306  Tool *buildAssembler() const override;
307  Tool *buildLinker() const override;
308 
309  virtual std::string getMultiarchTriple(const Driver &D,
310  const llvm::Triple &TargetTriple,
311  StringRef SysRoot) const
312  { return TargetTriple.str(); }
313 
314  /// \name ToolChain Implementation Helper Functions
315  /// @{
316 
317  /// Check whether the target triple's architecture is 64-bits.
318  bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
319 
320  /// Check whether the target triple's architecture is 32-bits.
321  bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
322 
323  void PushPPaths(ToolChain::path_list &PPaths);
324  void AddMultilibPaths(const Driver &D, const std::string &SysRoot,
325  const std::string &OSLibDir,
326  const std::string &MultiarchTriple,
327  path_list &Paths);
328  void AddMultiarchPaths(const Driver &D, const std::string &SysRoot,
329  const std::string &OSLibDir, path_list &Paths);
330  void AddMultilibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
331  llvm::opt::ArgStringList &CC1Args) const;
332 
333  // FIXME: This should be final, but the CrossWindows toolchain does weird
334  // things that can't be easily generalized.
335  void AddClangCXXStdlibIncludeArgs(
336  const llvm::opt::ArgList &DriverArgs,
337  llvm::opt::ArgStringList &CC1Args) const override;
338 
339  virtual void
340  addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
341  llvm::opt::ArgStringList &CC1Args) const;
342  virtual void
343  addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
344  llvm::opt::ArgStringList &CC1Args) const;
345 
346  bool
347  addGCCLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
348  llvm::opt::ArgStringList &CC1Args) const;
349 
350  bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix, StringRef GCCTriple,
351  StringRef GCCMultiarchTriple,
352  StringRef TargetMultiarchTriple,
353  Twine IncludeSuffix,
354  const llvm::opt::ArgList &DriverArgs,
355  llvm::opt::ArgStringList &CC1Args) const;
356 
357  /// @}
358 
359 private:
360  mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocess;
361  mutable std::unique_ptr<tools::gcc::Compiler> Compile;
362 };
363 
364 class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC {
365  virtual void anchor();
366 
367 public:
368  Generic_ELF(const Driver &D, const llvm::Triple &Triple,
369  const llvm::opt::ArgList &Args)
370  : Generic_GCC(D, Triple, Args) {}
371 
372  void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
373  llvm::opt::ArgStringList &CC1Args,
374  Action::OffloadKind DeviceOffloadKind) const override;
375 
376  virtual std::string getDynamicLinker(const llvm::opt::ArgList &Args) const {
377  return {};
378  }
379 
380  virtual void addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {}
381 };
382 
383 } // end namespace toolchains
384 } // end namespace driver
385 } // end namespace clang
386 
387 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GNU_H
Generic_GCC - A tool chain using the &#39;gcc&#39; command to perform all subcommands; this relies on gcc tra...
Definition: Gnu.h:144
llvm::Optional< Multilib > BiarchSibling
On Biarch systems, this corresponds to the default multilib when targeting the non-default multilib...
Definition: Gnu.h:30
bool isLinkJob() const override
Definition: Gnu.h:72
const llvm::Triple & getTriple() const
Get the GCC triple for the detected install.
Definition: Gnu.h:224
bool hasIntegratedCPP() const override
Definition: Gnu.h:57
Struct to store and manipulate GCC versions.
Definition: Gnu.h:161
bool operator<=(const GCCVersion &RHS) const
Definition: Gnu.h:181
void print(llvm::raw_ostream &OS, const Pointer &P, ASTContext &Ctx, QualType Ty)
Definition: InterpFrame.cpp:62
std::string PatchSuffix
Any textual suffix on the patch number.
Definition: Gnu.h:172
A class to find a viable CUDA installation.
Definition: Cuda.h:28
GCCInstallationDetector GCCInstallation
Definition: Gnu.h:284
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Gnu.h:108
Compiler(const ToolChain &TC)
Definition: Gnu.h:117
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:59
const GCCVersion & getVersion() const
Get the detected GCC version string.
Definition: Gnu.h:243
CudaInstallationDetector CudaInstallation
Definition: Gnu.h:285
bool hasIntegratedAssembler() const override
Definition: Gnu.h:91
Linker(const ToolChain &TC)
Definition: Gnu.h:55
bool operator>(const GCCVersion &RHS) const
Definition: Gnu.h:180
Preprocessor(const ToolChain &TC)
Definition: Gnu.h:105
bool operator>=(const GCCVersion &RHS) const
Definition: Gnu.h:182
This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag...
Definition: Multilib.h:28
Assembler(const ToolChain &TC)
Definition: Gnu.h:43
Common(const char *Name, const char *ShortName, const ToolChain &TC)
Definition: Gnu.h:85
bool hasIntegratedCPP() const override
Definition: Gnu.h:130
virtual void addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const
Definition: Gnu.h:380
#define false
Definition: stdbool.h:17
RocmInstallationDetector RocmInstallation
Definition: Gnu.h:286
bool isTarget32Bit() const
Check whether the target triple&#39;s architecture is 32-bits.
Definition: Gnu.h:321
StaticLibTool(const ToolChain &TC)
Definition: Gnu.h:68
This is a class to find a viable GCC installation for Clang to use.
Definition: Gnu.h:191
bool hasIntegratedCPP() const override
Definition: Gnu.h:71
StringRef getParentLibPath() const
Get the detected GCC parent lib path.
Definition: Gnu.h:230
bool operator<(const GCCVersion &RHS) const
Definition: Gnu.h:177
bool hasIntegratedCPP() const override
Definition: Gnu.h:109
Dataflow Directional Tag Classes.
virtual std::string getMultiarchTriple(const Driver &D, const llvm::Triple &TargetTriple, StringRef SysRoot) const
Definition: Gnu.h:309
bool hasIntegratedCPP() const override
Definition: Gnu.h:120
bool isLinkJob() const override
Definition: Gnu.h:58
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
A class to find a viable ROCM installation TODO: Generalize to handle libclc.
Definition: ROCm.h:27
std::string Text
The unparsed text of the version.
Definition: Gnu.h:163
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
bool findMIPSMultilibs(const Driver &D, const llvm::Triple &TargetTriple, StringRef Path, const llvm::opt::ArgList &Args, DetectedMultilibs &Result)
bool hasIntegratedCPP() const override
Definition: Gnu.h:45
Generic_ELF(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: Gnu.h:368
const MultilibSet & getMultilibs() const
Get the whole MultilibSet.
Definition: Gnu.h:236
virtual std::string getDynamicLinker(const llvm::opt::ArgList &Args) const
Definition: Gnu.h:376
Linker(const ToolChain &TC)
Definition: Gnu.h:128
MultilibSet Multilibs
The set of multilibs that the detected installation supports.
Definition: Gnu.h:23
bool isTarget64Bit() const
Check whether the target triple&#39;s architecture is 64-bits.
Definition: Gnu.h:318
int Major
The parsed major, minor, and patch numbers.
Definition: Gnu.h:166
bool isLinkJob() const override
Definition: Gnu.h:131
StringRef getInstallPath() const
Get the detected GCC installation path.
Definition: Gnu.h:227
bool hasGoodDiagnostics() const override
Does this tool have "good" standardized diagnostics, or should the driver add an additional "command ...
Definition: Gnu.h:119
const Multilib & getMultilib() const
Get the detected Multilib.
Definition: Gnu.h:233
Multilib SelectedMultilib
The primary multilib appropriate for the given flags.
Definition: Gnu.h:26
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:90
bool isValid() const
Check whether we detected a valid GCC install.
Definition: Gnu.h:221