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