• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===--- ToolChain.h - Collections of tools for one platform ----*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_CLANG_DRIVER_TOOLCHAIN_H
11 #define LLVM_CLANG_DRIVER_TOOLCHAIN_H
12 
13 #include "clang/Basic/Sanitizers.h"
14 #include "clang/Basic/VersionTuple.h"
15 #include "clang/Driver/Action.h"
16 #include "clang/Driver/Multilib.h"
17 #include "clang/Driver/Types.h"
18 #include "clang/Driver/Util.h"
19 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/ADT/Triple.h"
21 #include "llvm/Support/Path.h"
22 #include "llvm/Target/TargetOptions.h"
23 #include <memory>
24 #include <string>
25 
26 namespace llvm {
27 namespace opt {
28   class ArgList;
29   class DerivedArgList;
30   class InputArgList;
31 }
32 }
33 
34 namespace clang {
35 class ObjCRuntime;
36 namespace vfs {
37 class FileSystem;
38 }
39 
40 namespace driver {
41   class Compilation;
42   class Driver;
43   class JobAction;
44   class SanitizerArgs;
45   class Tool;
46 
47 /// ToolChain - Access to tools for a single platform.
48 class ToolChain {
49 public:
50   typedef SmallVector<std::string, 16> path_list;
51 
52   enum CXXStdlibType {
53     CST_Libcxx,
54     CST_Libstdcxx
55   };
56 
57   enum RuntimeLibType {
58     RLT_CompilerRT,
59     RLT_Libgcc
60   };
61 
62   enum RTTIMode {
63     RM_EnabledExplicitly,
64     RM_EnabledImplicitly,
65     RM_DisabledExplicitly,
66     RM_DisabledImplicitly
67   };
68 
69 private:
70   const Driver &D;
71   const llvm::Triple Triple;
72   const llvm::opt::ArgList &Args;
73   // We need to initialize CachedRTTIArg before CachedRTTIMode
74   const llvm::opt::Arg *const CachedRTTIArg;
75   const RTTIMode CachedRTTIMode;
76 
77   /// The list of toolchain specific path prefixes to search for
78   /// files.
79   path_list FilePaths;
80 
81   /// The list of toolchain specific path prefixes to search for
82   /// programs.
83   path_list ProgramPaths;
84 
85   mutable std::unique_ptr<Tool> Clang;
86   mutable std::unique_ptr<Tool> Assemble;
87   mutable std::unique_ptr<Tool> Link;
88   Tool *getClang() const;
89   Tool *getAssemble() const;
90   Tool *getLink() const;
91   Tool *getClangAs() const;
92 
93   mutable std::unique_ptr<SanitizerArgs> SanitizerArguments;
94 
95 protected:
96   MultilibSet Multilibs;
97   const char *DefaultLinker = "ld";
98 
99   ToolChain(const Driver &D, const llvm::Triple &T,
100             const llvm::opt::ArgList &Args);
101 
102   virtual Tool *buildAssembler() const;
103   virtual Tool *buildLinker() const;
104   virtual Tool *getTool(Action::ActionClass AC) const;
105 
106   /// \name Utilities for implementing subclasses.
107   ///@{
108   static void addSystemInclude(const llvm::opt::ArgList &DriverArgs,
109                                llvm::opt::ArgStringList &CC1Args,
110                                const Twine &Path);
111   static void addExternCSystemInclude(const llvm::opt::ArgList &DriverArgs,
112                                       llvm::opt::ArgStringList &CC1Args,
113                                       const Twine &Path);
114   static void
115       addExternCSystemIncludeIfExists(const llvm::opt::ArgList &DriverArgs,
116                                       llvm::opt::ArgStringList &CC1Args,
117                                       const Twine &Path);
118   static void addSystemIncludes(const llvm::opt::ArgList &DriverArgs,
119                                 llvm::opt::ArgStringList &CC1Args,
120                                 ArrayRef<StringRef> Paths);
121   ///@}
122 
123 public:
124   virtual ~ToolChain();
125 
126   // Accessors
127 
getDriver()128   const Driver &getDriver() const { return D; }
129   vfs::FileSystem &getVFS() const;
getTriple()130   const llvm::Triple &getTriple() const { return Triple; }
131 
getArch()132   llvm::Triple::ArchType getArch() const { return Triple.getArch(); }
getArchName()133   StringRef getArchName() const { return Triple.getArchName(); }
getPlatform()134   StringRef getPlatform() const { return Triple.getVendorName(); }
getOS()135   StringRef getOS() const { return Triple.getOSName(); }
136 
137   /// \brief Provide the default architecture name (as expected by -arch) for
138   /// this toolchain.
139   StringRef getDefaultUniversalArchName() const;
140 
getTripleString()141   std::string getTripleString() const {
142     return Triple.getTriple();
143   }
144 
getFilePaths()145   path_list &getFilePaths() { return FilePaths; }
getFilePaths()146   const path_list &getFilePaths() const { return FilePaths; }
147 
getProgramPaths()148   path_list &getProgramPaths() { return ProgramPaths; }
getProgramPaths()149   const path_list &getProgramPaths() const { return ProgramPaths; }
150 
getMultilibs()151   const MultilibSet &getMultilibs() const { return Multilibs; }
152 
153   const SanitizerArgs& getSanitizerArgs() const;
154 
155   // Returns the Arg * that explicitly turned on/off rtti, or nullptr.
getRTTIArg()156   const llvm::opt::Arg *getRTTIArg() const { return CachedRTTIArg; }
157 
158   // Returns the RTTIMode for the toolchain with the current arguments.
getRTTIMode()159   RTTIMode getRTTIMode() const { return CachedRTTIMode; }
160 
161   /// \brief Return any implicit target and/or mode flag for an invocation of
162   /// the compiler driver as `ProgName`.
163   ///
164   /// For example, when called with i686-linux-android-g++, the first element
165   /// of the return value will be set to `"i686-linux-android"` and the second
166   /// will be set to "--driver-mode=g++"`.
167   ///
168   /// \pre `llvm::InitializeAllTargets()` has been called.
169   /// \param ProgName The name the Clang driver was invoked with (from,
170   /// e.g., argv[0])
171   /// \return A pair of (`target`, `mode-flag`), where one or both may be empty.
172   static std::pair<std::string, std::string>
173   getTargetAndModeFromProgramName(StringRef ProgName);
174 
175   // Tool access.
176 
177   /// TranslateArgs - Create a new derived argument list for any argument
178   /// translations this ToolChain may wish to perform, or 0 if no tool chain
179   /// specific translations are needed.
180   ///
181   /// \param BoundArch - The bound architecture name, or 0.
182   virtual llvm::opt::DerivedArgList *
TranslateArgs(const llvm::opt::DerivedArgList & Args,const char * BoundArch)183   TranslateArgs(const llvm::opt::DerivedArgList &Args,
184                 const char *BoundArch) const {
185     return nullptr;
186   }
187 
188   /// Choose a tool to use to handle the action \p JA.
189   ///
190   /// This can be overridden when a particular ToolChain needs to use
191   /// a compiler other than Clang.
192   virtual Tool *SelectTool(const JobAction &JA) const;
193 
194   // Helper methods
195 
196   std::string GetFilePath(const char *Name) const;
197   std::string GetProgramPath(const char *Name) const;
198 
199   /// Returns the linker path, respecting the -fuse-ld= argument to determine
200   /// the linker suffix or name.
201   std::string GetLinkerPath() const;
202 
203   /// \brief Dispatch to the specific toolchain for verbose printing.
204   ///
205   /// This is used when handling the verbose option to print detailed,
206   /// toolchain-specific information useful for understanding the behavior of
207   /// the driver on a specific platform.
printVerboseInfo(raw_ostream & OS)208   virtual void printVerboseInfo(raw_ostream &OS) const {}
209 
210   // Platform defaults information
211 
212   /// \brief Returns true if the toolchain is targeting a non-native
213   /// architecture.
214   virtual bool isCrossCompiling() const;
215 
216   /// HasNativeLTOLinker - Check whether the linker and related tools have
217   /// native LLVM support.
218   virtual bool HasNativeLLVMSupport() const;
219 
220   /// LookupTypeForExtension - Return the default language type to use for the
221   /// given extension.
222   virtual types::ID LookupTypeForExtension(const char *Ext) const;
223 
224   /// IsBlocksDefault - Does this tool chain enable -fblocks by default.
IsBlocksDefault()225   virtual bool IsBlocksDefault() const { return false; }
226 
227   /// IsIntegratedAssemblerDefault - Does this tool chain enable -integrated-as
228   /// by default.
IsIntegratedAssemblerDefault()229   virtual bool IsIntegratedAssemblerDefault() const { return false; }
230 
231   /// \brief Check if the toolchain should use the integrated assembler.
232   virtual bool useIntegratedAs() const;
233 
234   /// IsMathErrnoDefault - Does this tool chain use -fmath-errno by default.
IsMathErrnoDefault()235   virtual bool IsMathErrnoDefault() const { return true; }
236 
237   /// IsEncodeExtendedBlockSignatureDefault - Does this tool chain enable
238   /// -fencode-extended-block-signature by default.
IsEncodeExtendedBlockSignatureDefault()239   virtual bool IsEncodeExtendedBlockSignatureDefault() const { return false; }
240 
241   /// IsObjCNonFragileABIDefault - Does this tool chain set
242   /// -fobjc-nonfragile-abi by default.
IsObjCNonFragileABIDefault()243   virtual bool IsObjCNonFragileABIDefault() const { return false; }
244 
245   /// UseObjCMixedDispatchDefault - When using non-legacy dispatch, should the
246   /// mixed dispatch method be used?
UseObjCMixedDispatch()247   virtual bool UseObjCMixedDispatch() const { return false; }
248 
249   /// GetDefaultStackProtectorLevel - Get the default stack protector level for
250   /// this tool chain (0=off, 1=on, 2=strong, 3=all).
GetDefaultStackProtectorLevel(bool KernelOrKext)251   virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
252     return 0;
253   }
254 
255   /// GetDefaultRuntimeLibType - Get the default runtime library variant to use.
GetDefaultRuntimeLibType()256   virtual RuntimeLibType GetDefaultRuntimeLibType() const {
257     return ToolChain::RLT_Libgcc;
258   }
259 
GetDefaultCXXStdlibType()260   virtual CXXStdlibType GetDefaultCXXStdlibType() const {
261     return ToolChain::CST_Libstdcxx;
262   }
263 
264   virtual std::string getCompilerRT(const llvm::opt::ArgList &Args,
265                                     StringRef Component,
266                                     bool Shared = false) const;
267 
268   const char *getCompilerRTArgString(const llvm::opt::ArgList &Args,
269                                      StringRef Component,
270                                      bool Shared = false) const;
271   /// needsProfileRT - returns true if instrumentation profile is on.
272   static bool needsProfileRT(const llvm::opt::ArgList &Args);
273 
274   /// IsUnwindTablesDefault - Does this tool chain use -funwind-tables
275   /// by default.
276   virtual bool IsUnwindTablesDefault() const;
277 
278   /// \brief Test whether this toolchain defaults to PIC.
279   virtual bool isPICDefault() const = 0;
280 
281   /// \brief Test whether this toolchain defaults to PIE.
282   virtual bool isPIEDefault() const = 0;
283 
284   /// \brief Tests whether this toolchain forces its default for PIC, PIE or
285   /// non-PIC.  If this returns true, any PIC related flags should be ignored
286   /// and instead the results of \c isPICDefault() and \c isPIEDefault() are
287   /// used exclusively.
288   virtual bool isPICDefaultForced() const = 0;
289 
290   /// SupportsProfiling - Does this tool chain support -pg.
SupportsProfiling()291   virtual bool SupportsProfiling() const { return true; }
292 
293   /// Does this tool chain support Objective-C garbage collection.
SupportsObjCGC()294   virtual bool SupportsObjCGC() const { return true; }
295 
296   /// Complain if this tool chain doesn't support Objective-C ARC.
CheckObjCARC()297   virtual void CheckObjCARC() const {}
298 
299   /// UseDwarfDebugFlags - Embed the compile options to clang into the Dwarf
300   /// compile unit information.
UseDwarfDebugFlags()301   virtual bool UseDwarfDebugFlags() const { return false; }
302 
303   // Return the DWARF version to emit, in the absence of arguments
304   // to the contrary.
GetDefaultDwarfVersion()305   virtual unsigned GetDefaultDwarfVersion() const { return 4; }
306 
307   // True if the driver should assume "-fstandalone-debug"
308   // in the absence of an option specifying otherwise,
309   // provided that debugging was requested in the first place.
310   // i.e. a value of 'true' does not imply that debugging is wanted.
GetDefaultStandaloneDebug()311   virtual bool GetDefaultStandaloneDebug() const { return false; }
312 
313   // Return the default debugger "tuning."
getDefaultDebuggerTuning()314   virtual llvm::DebuggerKind getDefaultDebuggerTuning() const {
315     return llvm::DebuggerKind::GDB;
316   }
317 
318   /// UseSjLjExceptions - Does this tool chain use SjLj exceptions.
UseSjLjExceptions(const llvm::opt::ArgList & Args)319   virtual bool UseSjLjExceptions(const llvm::opt::ArgList &Args) const {
320     return false;
321   }
322 
323   /// SupportsEmbeddedBitcode - Does this tool chain support embedded bitcode.
SupportsEmbeddedBitcode()324   virtual bool SupportsEmbeddedBitcode() const {
325     return false;
326   }
327 
328   /// getThreadModel() - Which thread model does this target use?
getThreadModel()329   virtual std::string getThreadModel() const { return "posix"; }
330 
331   /// isThreadModelSupported() - Does this target support a thread model?
332   virtual bool isThreadModelSupported(const StringRef Model) const;
333 
334   /// ComputeLLVMTriple - Return the LLVM target triple to use, after taking
335   /// command line arguments into account.
336   virtual std::string
337   ComputeLLVMTriple(const llvm::opt::ArgList &Args,
338                     types::ID InputType = types::TY_INVALID) const;
339 
340   /// ComputeEffectiveClangTriple - Return the Clang triple to use for this
341   /// target, which may take into account the command line arguments. For
342   /// example, on Darwin the -mmacosx-version-min= command line argument (which
343   /// sets the deployment target) determines the version in the triple passed to
344   /// Clang.
345   virtual std::string ComputeEffectiveClangTriple(
346       const llvm::opt::ArgList &Args,
347       types::ID InputType = types::TY_INVALID) const;
348 
349   /// getDefaultObjCRuntime - Return the default Objective-C runtime
350   /// for this platform.
351   ///
352   /// FIXME: this really belongs on some sort of DeploymentTarget abstraction
353   virtual ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const;
354 
355   /// hasBlocksRuntime - Given that the user is compiling with
356   /// -fblocks, does this tool chain guarantee the existence of a
357   /// blocks runtime?
358   ///
359   /// FIXME: this really belongs on some sort of DeploymentTarget abstraction
hasBlocksRuntime()360   virtual bool hasBlocksRuntime() const { return true; }
361 
362   /// \brief Add the clang cc1 arguments for system include paths.
363   ///
364   /// This routine is responsible for adding the necessary cc1 arguments to
365   /// include headers from standard system header directories.
366   virtual void
367   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
368                             llvm::opt::ArgStringList &CC1Args) const;
369 
370   /// \brief Add options that need to be passed to cc1 for this target.
371   virtual void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
372                                      llvm::opt::ArgStringList &CC1Args) const;
373 
374   /// \brief Add warning options that need to be passed to cc1 for this target.
375   virtual void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const;
376 
377   // GetRuntimeLibType - Determine the runtime library type to use with the
378   // given compilation arguments.
379   virtual RuntimeLibType
380   GetRuntimeLibType(const llvm::opt::ArgList &Args) const;
381 
382   // GetCXXStdlibType - Determine the C++ standard library type to use with the
383   // given compilation arguments.
384   virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const;
385 
386   /// AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set
387   /// the include paths to use for the given C++ standard library type.
388   virtual void
389   AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
390                                llvm::opt::ArgStringList &CC1Args) const;
391 
392   /// AddCXXStdlibLibArgs - Add the system specific linker arguments to use
393   /// for the given C++ standard library type.
394   virtual void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
395                                    llvm::opt::ArgStringList &CmdArgs) const;
396 
397   /// AddFilePathLibArgs - Add each thing in getFilePaths() as a "-L" option.
398   void AddFilePathLibArgs(const llvm::opt::ArgList &Args,
399                           llvm::opt::ArgStringList &CmdArgs) const;
400 
401   /// AddCCKextLibArgs - Add the system specific linker arguments to use
402   /// for kernel extensions (Darwin-specific).
403   virtual void AddCCKextLibArgs(const llvm::opt::ArgList &Args,
404                                 llvm::opt::ArgStringList &CmdArgs) const;
405 
406   /// AddFastMathRuntimeIfAvailable - If a runtime library exists that sets
407   /// global flags for unsafe floating point math, add it and return true.
408   ///
409   /// This checks for presence of the -Ofast, -ffast-math or -funsafe-math flags.
410   virtual bool AddFastMathRuntimeIfAvailable(
411       const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const;
412   /// addProfileRTLibs - When -fprofile-instr-profile is specified, try to pass
413   /// a suitable profile runtime library to the linker.
414   virtual void addProfileRTLibs(const llvm::opt::ArgList &Args,
415                                 llvm::opt::ArgStringList &CmdArgs) const;
416 
417   /// \brief Add arguments to use system-specific CUDA includes.
418   virtual void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
419                                   llvm::opt::ArgStringList &CC1Args) const;
420 
421   /// \brief Add arguments to use MCU GCC toolchain includes.
422   virtual void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs,
423                                    llvm::opt::ArgStringList &CC1Args) const;
424 
425   /// \brief Return sanitizers which are available in this toolchain.
426   virtual SanitizerMask getSupportedSanitizers() const;
427 
428   /// \brief Return sanitizers which are enabled by default.
getDefaultSanitizers()429   virtual SanitizerMask getDefaultSanitizers() const { return 0; }
430 
431   /// \brief On Windows, returns the version of cl.exe.  On other platforms,
432   /// returns an empty VersionTuple.
getMSVCVersionFromExe()433   virtual VersionTuple getMSVCVersionFromExe() const { return VersionTuple(); }
434 };
435 
436 } // end namespace driver
437 } // end namespace clang
438 
439 #endif
440