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 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 LazyDetector<CudaInstallationDetector> CudaInstallation; 290 LazyDetector<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 UnwindTableLevel 300 getDefaultUnwindTableLevel(const llvm::opt::ArgList &Args) const override; 301 bool isPICDefault() const override; 302 bool isPIEDefault(const llvm::opt::ArgList &Args) const override; 303 bool isPICDefaultForced() const override; 304 bool IsIntegratedAssemblerDefault() const override; 305 llvm::opt::DerivedArgList * 306 TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch, 307 Action::OffloadKind DeviceOffloadKind) const override; 308 309 protected: 310 Tool *getTool(Action::ActionClass AC) const override; 311 Tool *buildAssembler() const override; 312 Tool *buildLinker() const override; 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 addGCCLibStdCxxIncludePaths(const llvm::opt::ArgList &DriverArgs, 347 llvm::opt::ArgStringList &CC1Args, 348 StringRef DebianMultiarch) const; 349 350 bool addLibStdCXXIncludePaths(Twine IncludeDir, StringRef Triple, 351 Twine IncludeSuffix, 352 const llvm::opt::ArgList &DriverArgs, 353 llvm::opt::ArgStringList &CC1Args, 354 bool DetectDebian = false) const; 355 356 /// @} 357 358 private: 359 mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocess; 360 mutable std::unique_ptr<tools::gcc::Compiler> Compile; 361 }; 362 363 class LLVM_LIBRARY_VISIBILITY Generic_ELF : public Generic_GCC { 364 virtual void anchor(); 365 366 public: 367 Generic_ELF(const Driver &D, const llvm::Triple &Triple, 368 const llvm::opt::ArgList &Args) 369 : Generic_GCC(D, Triple, Args) {} 370 371 void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, 372 llvm::opt::ArgStringList &CC1Args, 373 Action::OffloadKind DeviceOffloadKind) const override; 374 375 virtual std::string getDynamicLinker(const llvm::opt::ArgList &Args) const { 376 return {}; 377 } 378 379 virtual void addExtraOpts(llvm::opt::ArgStringList &CmdArgs) const {} 380 }; 381 382 } // end namespace toolchains 383 } // end namespace driver 384 } // end namespace clang 385 386 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_GNU_H 387