xref: /freebsd/contrib/llvm-project/clang/lib/Driver/ToolChains/Gnu.h (revision 6ba2210ee039f2f12878c217bcf058e9c8b26b29)
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 
21 struct DetectedMultilibs {
22   /// The set of multilibs that the detected installation supports.
23   MultilibSet Multilibs;
24 
25   /// The primary multilib appropriate for the given flags.
26   Multilib SelectedMultilib;
27 
28   /// On Biarch systems, this corresponds to the default multilib when
29   /// targeting the non-default multilib. Otherwise, it is empty.
30   llvm::Optional<Multilib> BiarchSibling;
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:
68   StaticLibTool(const ToolChain &TC)
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:
105   Preprocessor(const ToolChain &TC)
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.
191   class GCCInstallationDetector {
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,
255                              SmallVectorImpl<StringRef> &LibDirs,
256                              SmallVectorImpl<StringRef> &TripleAliases,
257                              SmallVectorImpl<StringRef> &BiarchLibDirs,
258                              SmallVectorImpl<StringRef> &BiarchTripleAliases);
259 
260     void AddDefaultGCCPrefixes(const llvm::Triple &TargetTriple,
261                                SmallVectorImpl<std::string> &Prefixes,
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:
288   GCCInstallationDetector GCCInstallation;
289   CudaInstallationDetector CudaInstallation;
290   RocmInstallationDetector RocmInstallation;
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   virtual std::string getMultiarchTriple(const Driver &D,
314                                          const llvm::Triple &TargetTriple,
315                                          StringRef SysRoot) const
316   { return TargetTriple.str(); }
317 
318   /// \name ToolChain Implementation Helper Functions
319   /// @{
320 
321   /// Check whether the target triple's architecture is 64-bits.
322   bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
323 
324   /// Check whether the target triple's architecture is 32-bits.
325   bool isTarget32Bit() const { return getTriple().isArch32Bit(); }
326 
327   void PushPPaths(ToolChain::path_list &PPaths);
328   void AddMultilibPaths(const Driver &D, const std::string &SysRoot,
329                         const std::string &OSLibDir,
330                         const std::string &MultiarchTriple,
331                         path_list &Paths);
332   void AddMultiarchPaths(const Driver &D, const std::string &SysRoot,
333                          const std::string &OSLibDir, path_list &Paths);
334   void AddMultilibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
335                               llvm::opt::ArgStringList &CC1Args) const;
336 
337   // FIXME: This should be final, but the CrossWindows toolchain does weird
338   // things that can't be easily generalized.
339   void AddClangCXXStdlibIncludeArgs(
340       const llvm::opt::ArgList &DriverArgs,
341       llvm::opt::ArgStringList &CC1Args) const override;
342 
343   virtual void
344   addLibCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
345                         llvm::opt::ArgStringList &CC1Args) const;
346   virtual void
347   addLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
348                            llvm::opt::ArgStringList &CC1Args) const;
349 
350   bool
351   addGCCLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs,
352                            llvm::opt::ArgStringList &CC1Args) const;
353 
354   bool addLibStdCXXIncludePaths(Twine Base, Twine Suffix, StringRef GCCTriple,
355                                 StringRef GCCMultiarchTriple,
356                                 StringRef TargetMultiarchTriple,
357                                 Twine IncludeSuffix,
358                                 const llvm::opt::ArgList &DriverArgs,
359                                 llvm::opt::ArgStringList &CC1Args) const;
360 
361   /// @}
362 
363 private:
364   mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocess;
365   mutable std::unique_ptr<tools::gcc::Compiler> Compile;
366 };
367 
368 class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC {
369   virtual void anchor();
370 
371 public:
372   Generic_ELF(const Driver &D, const llvm::Triple &Triple,
373               const llvm::opt::ArgList &Args)
374       : Generic_GCC(D, Triple, Args) {}
375 
376   void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
377                              llvm::opt::ArgStringList &CC1Args,
378                              Action::OffloadKind DeviceOffloadKind) const override;
379 
380   virtual std::string getDynamicLinker(const llvm::opt::ArgList &Args) const {
381     return {};
382   }
383 
384   virtual void addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {}
385 };
386 
387 } // end namespace toolchains
388 } // end namespace driver
389 } // end namespace clang
390 
391 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GNU_H
392