contrib/llvm/tools/clang/lib/Driver/ToolChains/Gnu.h

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