1 //===--- Tools.h - Tool 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_TOOLS_H 11 #define LLVM_CLANG_LIB_DRIVER_TOOLS_H 12 13 #include "clang/Basic/DebugInfoOptions.h" 14 #include "clang/Basic/VersionTuple.h" 15 #include "clang/Driver/Tool.h" 16 #include "clang/Driver/Types.h" 17 #include "clang/Driver/Util.h" 18 #include "llvm/ADT/Triple.h" 19 #include "llvm/Option/Option.h" 20 #include "llvm/Support/Compiler.h" 21 22 namespace clang { 23 class ObjCRuntime; 24 25 namespace driver { 26 class Command; 27 class Driver; 28 29 namespace toolchains { 30 class MachO; 31 } 32 33 namespace tools { 34 35 namespace visualstudio { 36 class Compiler; 37 } 38 39 using llvm::opt::ArgStringList; 40 41 SmallString<128> getCompilerRT(const ToolChain &TC, 42 const llvm::opt::ArgList &Args, 43 StringRef Component, bool Shared = false); 44 45 /// \brief Clang compiler tool. 46 class LLVM_LIBRARY_VISIBILITY Clang : public Tool { 47 public: 48 static const char *getBaseInputName(const llvm::opt::ArgList &Args, 49 const InputInfo &Input); 50 static const char *getBaseInputStem(const llvm::opt::ArgList &Args, 51 const InputInfoList &Inputs); 52 static const char *getDependencyFileName(const llvm::opt::ArgList &Args, 53 const InputInfoList &Inputs); 54 55 private: 56 void AddPreprocessingOptions(Compilation &C, const JobAction &JA, 57 const Driver &D, const llvm::opt::ArgList &Args, 58 llvm::opt::ArgStringList &CmdArgs, 59 const InputInfo &Output, 60 const InputInfoList &Inputs, 61 const ToolChain *AuxToolChain) const; 62 63 void AddAArch64TargetArgs(const llvm::opt::ArgList &Args, 64 llvm::opt::ArgStringList &CmdArgs) const; 65 void AddARMTargetArgs(const llvm::Triple &Triple, 66 const llvm::opt::ArgList &Args, 67 llvm::opt::ArgStringList &CmdArgs, 68 bool KernelOrKext) const; 69 void AddARM64TargetArgs(const llvm::opt::ArgList &Args, 70 llvm::opt::ArgStringList &CmdArgs) const; 71 void AddMIPSTargetArgs(const llvm::opt::ArgList &Args, 72 llvm::opt::ArgStringList &CmdArgs) const; 73 void AddPPCTargetArgs(const llvm::opt::ArgList &Args, 74 llvm::opt::ArgStringList &CmdArgs) const; 75 void AddR600TargetArgs(const llvm::opt::ArgList &Args, 76 llvm::opt::ArgStringList &CmdArgs) const; 77 void AddSparcTargetArgs(const llvm::opt::ArgList &Args, 78 llvm::opt::ArgStringList &CmdArgs) const; 79 void AddSystemZTargetArgs(const llvm::opt::ArgList &Args, 80 llvm::opt::ArgStringList &CmdArgs) const; 81 void AddX86TargetArgs(const llvm::opt::ArgList &Args, 82 llvm::opt::ArgStringList &CmdArgs) const; 83 void AddHexagonTargetArgs(const llvm::opt::ArgList &Args, 84 llvm::opt::ArgStringList &CmdArgs) const; 85 void AddLanaiTargetArgs(const llvm::opt::ArgList &Args, 86 llvm::opt::ArgStringList &CmdArgs) const; 87 void AddWebAssemblyTargetArgs(const llvm::opt::ArgList &Args, 88 llvm::opt::ArgStringList &CmdArgs) const; 89 90 enum RewriteKind { RK_None, RK_Fragile, RK_NonFragile }; 91 92 ObjCRuntime AddObjCRuntimeArgs(const llvm::opt::ArgList &args, 93 llvm::opt::ArgStringList &cmdArgs, 94 RewriteKind rewrite) const; 95 96 void AddClangCLArgs(const llvm::opt::ArgList &Args, types::ID InputType, 97 llvm::opt::ArgStringList &CmdArgs, 98 codegenoptions::DebugInfoKind *DebugInfoKind, 99 bool *EmitCodeView) const; 100 101 visualstudio::Compiler *getCLFallback() const; 102 103 mutable std::unique_ptr<visualstudio::Compiler> CLFallback; 104 105 public: 106 // CAUTION! The first constructor argument ("clang") is not arbitrary, 107 // as it is for other tools. Some operations on a Tool actually test 108 // whether that tool is Clang based on the Tool's Name as a string. 109 Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC, RF_Full) {} 110 111 bool hasGoodDiagnostics() const override { return true; } 112 bool hasIntegratedAssembler() const override { return true; } 113 bool hasIntegratedCPP() const override { return true; } 114 bool canEmitIR() const override { return true; } 115 116 void ConstructJob(Compilation &C, const JobAction &JA, 117 const InputInfo &Output, const InputInfoList &Inputs, 118 const llvm::opt::ArgList &TCArgs, 119 const char *LinkingOutput) const override; 120 }; 121 122 /// \brief Clang integrated assembler tool. 123 class LLVM_LIBRARY_VISIBILITY ClangAs : public Tool { 124 public: 125 ClangAs(const ToolChain &TC) 126 : Tool("clang::as", "clang integrated assembler", TC, RF_Full) {} 127 void AddMIPSTargetArgs(const llvm::opt::ArgList &Args, 128 llvm::opt::ArgStringList &CmdArgs) const; 129 bool hasGoodDiagnostics() const override { return true; } 130 bool hasIntegratedAssembler() const override { return false; } 131 bool hasIntegratedCPP() const override { return false; } 132 133 void ConstructJob(Compilation &C, const JobAction &JA, 134 const InputInfo &Output, const InputInfoList &Inputs, 135 const llvm::opt::ArgList &TCArgs, 136 const char *LinkingOutput) const override; 137 }; 138 139 /// \brief Base class for all GNU tools that provide the same behavior when 140 /// it comes to response files support 141 class LLVM_LIBRARY_VISIBILITY GnuTool : public Tool { 142 virtual void anchor(); 143 144 public: 145 GnuTool(const char *Name, const char *ShortName, const ToolChain &TC) 146 : Tool(Name, ShortName, TC, RF_Full, llvm::sys::WEM_CurrentCodePage) {} 147 }; 148 149 /// gcc - Generic GCC tool implementations. 150 namespace gcc { 151 class LLVM_LIBRARY_VISIBILITY Common : public GnuTool { 152 public: 153 Common(const char *Name, const char *ShortName, const ToolChain &TC) 154 : GnuTool(Name, ShortName, TC) {} 155 156 // A gcc tool has an "integrated" assembler that it will call to produce an 157 // object. Let it use that assembler so that we don't have to deal with 158 // assembly syntax incompatibilities. 159 bool hasIntegratedAssembler() const override { return true; } 160 void ConstructJob(Compilation &C, const JobAction &JA, 161 const InputInfo &Output, const InputInfoList &Inputs, 162 const llvm::opt::ArgList &TCArgs, 163 const char *LinkingOutput) const override; 164 165 /// RenderExtraToolArgs - Render any arguments necessary to force 166 /// the particular tool mode. 167 virtual void RenderExtraToolArgs(const JobAction &JA, 168 llvm::opt::ArgStringList &CmdArgs) const = 0; 169 }; 170 171 class LLVM_LIBRARY_VISIBILITY Preprocessor : public Common { 172 public: 173 Preprocessor(const ToolChain &TC) 174 : Common("gcc::Preprocessor", "gcc preprocessor", TC) {} 175 176 bool hasGoodDiagnostics() const override { return true; } 177 bool hasIntegratedCPP() const override { return false; } 178 179 void RenderExtraToolArgs(const JobAction &JA, 180 llvm::opt::ArgStringList &CmdArgs) const override; 181 }; 182 183 class LLVM_LIBRARY_VISIBILITY Compiler : public Common { 184 public: 185 Compiler(const ToolChain &TC) : Common("gcc::Compiler", "gcc frontend", TC) {} 186 187 bool hasGoodDiagnostics() const override { return true; } 188 bool hasIntegratedCPP() const override { return true; } 189 190 void RenderExtraToolArgs(const JobAction &JA, 191 llvm::opt::ArgStringList &CmdArgs) const override; 192 }; 193 194 class LLVM_LIBRARY_VISIBILITY Linker : public Common { 195 public: 196 Linker(const ToolChain &TC) : Common("gcc::Linker", "linker (via gcc)", TC) {} 197 198 bool hasIntegratedCPP() const override { return false; } 199 bool isLinkJob() const override { return true; } 200 201 void RenderExtraToolArgs(const JobAction &JA, 202 llvm::opt::ArgStringList &CmdArgs) const override; 203 }; 204 } // end namespace gcc 205 206 namespace hexagon { 207 // For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile 208 // and Compile. 209 // We simply use "clang -cc1" for those actions. 210 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { 211 public: 212 Assembler(const ToolChain &TC) 213 : GnuTool("hexagon::Assembler", "hexagon-as", TC) {} 214 215 bool hasIntegratedCPP() const override { return false; } 216 217 void RenderExtraToolArgs(const JobAction &JA, 218 llvm::opt::ArgStringList &CmdArgs) const; 219 void ConstructJob(Compilation &C, const JobAction &JA, 220 const InputInfo &Output, const InputInfoList &Inputs, 221 const llvm::opt::ArgList &TCArgs, 222 const char *LinkingOutput) const override; 223 }; 224 225 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 226 public: 227 Linker(const ToolChain &TC) : GnuTool("hexagon::Linker", "hexagon-ld", TC) {} 228 229 bool hasIntegratedCPP() const override { return false; } 230 bool isLinkJob() const override { return true; } 231 232 virtual void RenderExtraToolArgs(const JobAction &JA, 233 llvm::opt::ArgStringList &CmdArgs) const; 234 void ConstructJob(Compilation &C, const JobAction &JA, 235 const InputInfo &Output, const InputInfoList &Inputs, 236 const llvm::opt::ArgList &TCArgs, 237 const char *LinkingOutput) const override; 238 }; 239 } // end namespace hexagon. 240 241 namespace amdgpu { 242 243 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 244 public: 245 Linker(const ToolChain &TC) : GnuTool("amdgpu::Linker", "ld.lld", TC) {} 246 bool isLinkJob() const override { return true; } 247 bool hasIntegratedCPP() const override { return false; } 248 void ConstructJob(Compilation &C, const JobAction &JA, 249 const InputInfo &Output, const InputInfoList &Inputs, 250 const llvm::opt::ArgList &TCArgs, 251 const char *LinkingOutput) const override; 252 }; 253 254 } // end namespace amdgpu 255 256 namespace wasm { 257 258 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 259 public: 260 explicit Linker(const ToolChain &TC); 261 bool isLinkJob() const override; 262 bool hasIntegratedCPP() const override; 263 void ConstructJob(Compilation &C, const JobAction &JA, 264 const InputInfo &Output, const InputInfoList &Inputs, 265 const llvm::opt::ArgList &TCArgs, 266 const char *LinkingOutput) const override; 267 }; 268 269 } // end namespace wasm 270 271 namespace arm { 272 std::string getARMTargetCPU(StringRef CPU, StringRef Arch, 273 const llvm::Triple &Triple); 274 const std::string getARMArch(StringRef Arch, 275 const llvm::Triple &Triple); 276 StringRef getARMCPUForMArch(StringRef Arch, const llvm::Triple &Triple); 277 StringRef getLLVMArchSuffixForARM(StringRef CPU, StringRef Arch, 278 const llvm::Triple &Triple); 279 280 void appendEBLinkFlags(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs, 281 const llvm::Triple &Triple); 282 } // end namespace arm 283 284 namespace mips { 285 typedef enum { NanLegacy = 1, Nan2008 = 2 } NanEncoding; 286 287 enum class FloatABI { 288 Invalid, 289 Soft, 290 Hard, 291 }; 292 293 NanEncoding getSupportedNanEncoding(StringRef &CPU); 294 bool hasCompactBranches(StringRef &CPU); 295 void getMipsCPUAndABI(const llvm::opt::ArgList &Args, 296 const llvm::Triple &Triple, StringRef &CPUName, 297 StringRef &ABIName); 298 std::string getMipsABILibSuffix(const llvm::opt::ArgList &Args, 299 const llvm::Triple &Triple); 300 bool hasMipsAbiArg(const llvm::opt::ArgList &Args, const char *Value); 301 bool isUCLibc(const llvm::opt::ArgList &Args); 302 bool isNaN2008(const llvm::opt::ArgList &Args, const llvm::Triple &Triple); 303 bool isFP64ADefault(const llvm::Triple &Triple, StringRef CPUName); 304 bool isFPXXDefault(const llvm::Triple &Triple, StringRef CPUName, 305 StringRef ABIName, mips::FloatABI FloatABI); 306 bool shouldUseFPXX(const llvm::opt::ArgList &Args, const llvm::Triple &Triple, 307 StringRef CPUName, StringRef ABIName, 308 mips::FloatABI FloatABI); 309 } // end namespace mips 310 311 namespace ppc { 312 bool hasPPCAbiArg(const llvm::opt::ArgList &Args, const char *Value); 313 } // end namespace ppc 314 315 /// cloudabi -- Directly call GNU Binutils linker 316 namespace cloudabi { 317 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 318 public: 319 Linker(const ToolChain &TC) : GnuTool("cloudabi::Linker", "linker", TC) {} 320 321 bool hasIntegratedCPP() const override { return false; } 322 bool isLinkJob() const override { return true; } 323 324 void ConstructJob(Compilation &C, const JobAction &JA, 325 const InputInfo &Output, const InputInfoList &Inputs, 326 const llvm::opt::ArgList &TCArgs, 327 const char *LinkingOutput) const override; 328 }; 329 } // end namespace cloudabi 330 331 namespace darwin { 332 llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str); 333 void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str); 334 335 class LLVM_LIBRARY_VISIBILITY MachOTool : public Tool { 336 virtual void anchor(); 337 338 protected: 339 void AddMachOArch(const llvm::opt::ArgList &Args, 340 llvm::opt::ArgStringList &CmdArgs) const; 341 342 const toolchains::MachO &getMachOToolChain() const { 343 return reinterpret_cast<const toolchains::MachO &>(getToolChain()); 344 } 345 346 public: 347 MachOTool( 348 const char *Name, const char *ShortName, const ToolChain &TC, 349 ResponseFileSupport ResponseSupport = RF_None, 350 llvm::sys::WindowsEncodingMethod ResponseEncoding = llvm::sys::WEM_UTF8, 351 const char *ResponseFlag = "@") 352 : Tool(Name, ShortName, TC, ResponseSupport, ResponseEncoding, 353 ResponseFlag) {} 354 }; 355 356 class LLVM_LIBRARY_VISIBILITY Assembler : public MachOTool { 357 public: 358 Assembler(const ToolChain &TC) 359 : MachOTool("darwin::Assembler", "assembler", TC) {} 360 361 bool hasIntegratedCPP() const override { return false; } 362 363 void ConstructJob(Compilation &C, const JobAction &JA, 364 const InputInfo &Output, const InputInfoList &Inputs, 365 const llvm::opt::ArgList &TCArgs, 366 const char *LinkingOutput) const override; 367 }; 368 369 class LLVM_LIBRARY_VISIBILITY Linker : public MachOTool { 370 bool NeedsTempPath(const InputInfoList &Inputs) const; 371 void AddLinkArgs(Compilation &C, const llvm::opt::ArgList &Args, 372 llvm::opt::ArgStringList &CmdArgs, 373 const InputInfoList &Inputs) const; 374 375 public: 376 Linker(const ToolChain &TC) 377 : MachOTool("darwin::Linker", "linker", TC, RF_FileList, 378 llvm::sys::WEM_UTF8, "-filelist") {} 379 380 bool hasIntegratedCPP() const override { return false; } 381 bool isLinkJob() const override { return true; } 382 383 void ConstructJob(Compilation &C, const JobAction &JA, 384 const InputInfo &Output, const InputInfoList &Inputs, 385 const llvm::opt::ArgList &TCArgs, 386 const char *LinkingOutput) const override; 387 }; 388 389 class LLVM_LIBRARY_VISIBILITY Lipo : public MachOTool { 390 public: 391 Lipo(const ToolChain &TC) : MachOTool("darwin::Lipo", "lipo", TC) {} 392 393 bool hasIntegratedCPP() const override { return false; } 394 395 void ConstructJob(Compilation &C, const JobAction &JA, 396 const InputInfo &Output, const InputInfoList &Inputs, 397 const llvm::opt::ArgList &TCArgs, 398 const char *LinkingOutput) const override; 399 }; 400 401 class LLVM_LIBRARY_VISIBILITY Dsymutil : public MachOTool { 402 public: 403 Dsymutil(const ToolChain &TC) 404 : MachOTool("darwin::Dsymutil", "dsymutil", TC) {} 405 406 bool hasIntegratedCPP() const override { return false; } 407 bool isDsymutilJob() const override { return true; } 408 409 void ConstructJob(Compilation &C, const JobAction &JA, 410 const InputInfo &Output, const InputInfoList &Inputs, 411 const llvm::opt::ArgList &TCArgs, 412 const char *LinkingOutput) const override; 413 }; 414 415 class LLVM_LIBRARY_VISIBILITY VerifyDebug : public MachOTool { 416 public: 417 VerifyDebug(const ToolChain &TC) 418 : MachOTool("darwin::VerifyDebug", "dwarfdump", TC) {} 419 420 bool hasIntegratedCPP() const override { return false; } 421 422 void ConstructJob(Compilation &C, const JobAction &JA, 423 const InputInfo &Output, const InputInfoList &Inputs, 424 const llvm::opt::ArgList &TCArgs, 425 const char *LinkingOutput) const override; 426 }; 427 } // end namespace darwin 428 429 /// openbsd -- Directly call GNU Binutils assembler and linker 430 namespace openbsd { 431 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { 432 public: 433 Assembler(const ToolChain &TC) 434 : GnuTool("openbsd::Assembler", "assembler", TC) {} 435 436 bool hasIntegratedCPP() const override { return false; } 437 438 void ConstructJob(Compilation &C, const JobAction &JA, 439 const InputInfo &Output, const InputInfoList &Inputs, 440 const llvm::opt::ArgList &TCArgs, 441 const char *LinkingOutput) const override; 442 }; 443 444 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 445 public: 446 Linker(const ToolChain &TC) : GnuTool("openbsd::Linker", "linker", TC) {} 447 448 bool hasIntegratedCPP() const override { return false; } 449 bool isLinkJob() const override { return true; } 450 451 void ConstructJob(Compilation &C, const JobAction &JA, 452 const InputInfo &Output, const InputInfoList &Inputs, 453 const llvm::opt::ArgList &TCArgs, 454 const char *LinkingOutput) const override; 455 }; 456 } // end namespace openbsd 457 458 /// bitrig -- Directly call GNU Binutils assembler and linker 459 namespace bitrig { 460 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { 461 public: 462 Assembler(const ToolChain &TC) 463 : GnuTool("bitrig::Assembler", "assembler", TC) {} 464 465 bool hasIntegratedCPP() const override { return false; } 466 467 void ConstructJob(Compilation &C, const JobAction &JA, 468 const InputInfo &Output, const InputInfoList &Inputs, 469 const llvm::opt::ArgList &TCArgs, 470 const char *LinkingOutput) const override; 471 }; 472 473 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 474 public: 475 Linker(const ToolChain &TC) : GnuTool("bitrig::Linker", "linker", TC) {} 476 477 bool hasIntegratedCPP() const override { return false; } 478 bool isLinkJob() const override { return true; } 479 480 void ConstructJob(Compilation &C, const JobAction &JA, 481 const InputInfo &Output, const InputInfoList &Inputs, 482 const llvm::opt::ArgList &TCArgs, 483 const char *LinkingOutput) const override; 484 }; 485 } // end namespace bitrig 486 487 /// freebsd -- Directly call GNU Binutils assembler and linker 488 namespace freebsd { 489 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { 490 public: 491 Assembler(const ToolChain &TC) 492 : GnuTool("freebsd::Assembler", "assembler", TC) {} 493 494 bool hasIntegratedCPP() const override { return false; } 495 496 void ConstructJob(Compilation &C, const JobAction &JA, 497 const InputInfo &Output, const InputInfoList &Inputs, 498 const llvm::opt::ArgList &TCArgs, 499 const char *LinkingOutput) const override; 500 }; 501 502 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 503 public: 504 Linker(const ToolChain &TC) : GnuTool("freebsd::Linker", "linker", TC) {} 505 506 bool hasIntegratedCPP() const override { return false; } 507 bool isLinkJob() const override { return true; } 508 509 void ConstructJob(Compilation &C, const JobAction &JA, 510 const InputInfo &Output, const InputInfoList &Inputs, 511 const llvm::opt::ArgList &TCArgs, 512 const char *LinkingOutput) const override; 513 }; 514 } // end namespace freebsd 515 516 /// netbsd -- Directly call GNU Binutils assembler and linker 517 namespace netbsd { 518 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { 519 public: 520 Assembler(const ToolChain &TC) 521 : GnuTool("netbsd::Assembler", "assembler", TC) {} 522 523 bool hasIntegratedCPP() const override { return false; } 524 525 void ConstructJob(Compilation &C, const JobAction &JA, 526 const InputInfo &Output, const InputInfoList &Inputs, 527 const llvm::opt::ArgList &TCArgs, 528 const char *LinkingOutput) const override; 529 }; 530 531 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 532 public: 533 Linker(const ToolChain &TC) : GnuTool("netbsd::Linker", "linker", TC) {} 534 535 bool hasIntegratedCPP() const override { return false; } 536 bool isLinkJob() const override { return true; } 537 538 void ConstructJob(Compilation &C, const JobAction &JA, 539 const InputInfo &Output, const InputInfoList &Inputs, 540 const llvm::opt::ArgList &TCArgs, 541 const char *LinkingOutput) const override; 542 }; 543 } // end namespace netbsd 544 545 /// Directly call GNU Binutils' assembler and linker. 546 namespace gnutools { 547 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { 548 public: 549 Assembler(const ToolChain &TC) : GnuTool("GNU::Assembler", "assembler", TC) {} 550 551 bool hasIntegratedCPP() const override { return false; } 552 553 void ConstructJob(Compilation &C, const JobAction &JA, 554 const InputInfo &Output, const InputInfoList &Inputs, 555 const llvm::opt::ArgList &TCArgs, 556 const char *LinkingOutput) const override; 557 }; 558 559 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 560 public: 561 Linker(const ToolChain &TC) : GnuTool("GNU::Linker", "linker", TC) {} 562 563 bool hasIntegratedCPP() const override { return false; } 564 bool isLinkJob() const override { return true; } 565 566 void ConstructJob(Compilation &C, const JobAction &JA, 567 const InputInfo &Output, const InputInfoList &Inputs, 568 const llvm::opt::ArgList &TCArgs, 569 const char *LinkingOutput) const override; 570 }; 571 } // end namespace gnutools 572 573 namespace nacltools { 574 class LLVM_LIBRARY_VISIBILITY AssemblerARM : public gnutools::Assembler { 575 public: 576 AssemblerARM(const ToolChain &TC) : gnutools::Assembler(TC) {} 577 578 void ConstructJob(Compilation &C, const JobAction &JA, 579 const InputInfo &Output, const InputInfoList &Inputs, 580 const llvm::opt::ArgList &TCArgs, 581 const char *LinkingOutput) const override; 582 }; 583 584 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 585 public: 586 Linker(const ToolChain &TC) : GnuTool("NaCl::Linker", "linker", TC) {} 587 588 bool hasIntegratedCPP() const override { return false; } 589 bool isLinkJob() const override { return true; } 590 591 void ConstructJob(Compilation &C, const JobAction &JA, 592 const InputInfo &Output, const InputInfoList &Inputs, 593 const llvm::opt::ArgList &TCArgs, 594 const char *LinkingOutput) const override; 595 }; 596 } // end namespace nacltools 597 598 /// minix -- Directly call GNU Binutils assembler and linker 599 namespace minix { 600 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { 601 public: 602 Assembler(const ToolChain &TC) 603 : GnuTool("minix::Assembler", "assembler", TC) {} 604 605 bool hasIntegratedCPP() const override { return false; } 606 607 void ConstructJob(Compilation &C, const JobAction &JA, 608 const InputInfo &Output, const InputInfoList &Inputs, 609 const llvm::opt::ArgList &TCArgs, 610 const char *LinkingOutput) const override; 611 }; 612 613 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 614 public: 615 Linker(const ToolChain &TC) : GnuTool("minix::Linker", "linker", TC) {} 616 617 bool hasIntegratedCPP() const override { return false; } 618 bool isLinkJob() const override { return true; } 619 620 void ConstructJob(Compilation &C, const JobAction &JA, 621 const InputInfo &Output, const InputInfoList &Inputs, 622 const llvm::opt::ArgList &TCArgs, 623 const char *LinkingOutput) const override; 624 }; 625 } // end namespace minix 626 627 /// solaris -- Directly call Solaris assembler and linker 628 namespace solaris { 629 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool { 630 public: 631 Assembler(const ToolChain &TC) 632 : Tool("solaris::Assembler", "assembler", TC) {} 633 634 bool hasIntegratedCPP() const override { return false; } 635 636 void ConstructJob(Compilation &C, const JobAction &JA, 637 const InputInfo &Output, const InputInfoList &Inputs, 638 const llvm::opt::ArgList &TCArgs, 639 const char *LinkingOutput) const override; 640 }; 641 642 class LLVM_LIBRARY_VISIBILITY Linker : public Tool { 643 public: 644 Linker(const ToolChain &TC) : Tool("solaris::Linker", "linker", TC) {} 645 646 bool hasIntegratedCPP() const override { return false; } 647 bool isLinkJob() const override { return true; } 648 649 void ConstructJob(Compilation &C, const JobAction &JA, 650 const InputInfo &Output, const InputInfoList &Inputs, 651 const llvm::opt::ArgList &TCArgs, 652 const char *LinkingOutput) const override; 653 }; 654 } // end namespace solaris 655 656 /// dragonfly -- Directly call GNU Binutils assembler and linker 657 namespace dragonfly { 658 class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool { 659 public: 660 Assembler(const ToolChain &TC) 661 : GnuTool("dragonfly::Assembler", "assembler", TC) {} 662 663 bool hasIntegratedCPP() const override { return false; } 664 665 void ConstructJob(Compilation &C, const JobAction &JA, 666 const InputInfo &Output, const InputInfoList &Inputs, 667 const llvm::opt::ArgList &TCArgs, 668 const char *LinkingOutput) const override; 669 }; 670 671 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 672 public: 673 Linker(const ToolChain &TC) : GnuTool("dragonfly::Linker", "linker", TC) {} 674 675 bool hasIntegratedCPP() const override { return false; } 676 bool isLinkJob() const override { return true; } 677 678 void ConstructJob(Compilation &C, const JobAction &JA, 679 const InputInfo &Output, const InputInfoList &Inputs, 680 const llvm::opt::ArgList &TCArgs, 681 const char *LinkingOutput) const override; 682 }; 683 } // end namespace dragonfly 684 685 /// Visual studio tools. 686 namespace visualstudio { 687 VersionTuple getMSVCVersion(const Driver *D, const ToolChain &TC, 688 const llvm::Triple &Triple, 689 const llvm::opt::ArgList &Args, bool IsWindowsMSVC); 690 691 class LLVM_LIBRARY_VISIBILITY Linker : public Tool { 692 public: 693 Linker(const ToolChain &TC) 694 : Tool("visualstudio::Linker", "linker", TC, RF_Full, 695 llvm::sys::WEM_UTF16) {} 696 697 bool hasIntegratedCPP() const override { return false; } 698 bool isLinkJob() const override { return true; } 699 700 void ConstructJob(Compilation &C, const JobAction &JA, 701 const InputInfo &Output, const InputInfoList &Inputs, 702 const llvm::opt::ArgList &TCArgs, 703 const char *LinkingOutput) const override; 704 }; 705 706 class LLVM_LIBRARY_VISIBILITY Compiler : public Tool { 707 public: 708 Compiler(const ToolChain &TC) 709 : Tool("visualstudio::Compiler", "compiler", TC, RF_Full, 710 llvm::sys::WEM_UTF16) {} 711 712 bool hasIntegratedAssembler() const override { return true; } 713 bool hasIntegratedCPP() const override { return true; } 714 bool isLinkJob() const override { return false; } 715 716 void ConstructJob(Compilation &C, const JobAction &JA, 717 const InputInfo &Output, const InputInfoList &Inputs, 718 const llvm::opt::ArgList &TCArgs, 719 const char *LinkingOutput) const override; 720 721 std::unique_ptr<Command> GetCommand(Compilation &C, const JobAction &JA, 722 const InputInfo &Output, 723 const InputInfoList &Inputs, 724 const llvm::opt::ArgList &TCArgs, 725 const char *LinkingOutput) const; 726 }; 727 } // end namespace visualstudio 728 729 /// MinGW -- Directly call GNU Binutils assembler and linker 730 namespace MinGW { 731 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool { 732 public: 733 Assembler(const ToolChain &TC) : Tool("MinGW::Assemble", "assembler", TC) {} 734 735 bool hasIntegratedCPP() const override { return false; } 736 737 void ConstructJob(Compilation &C, const JobAction &JA, 738 const InputInfo &Output, const InputInfoList &Inputs, 739 const llvm::opt::ArgList &TCArgs, 740 const char *LinkingOutput) const override; 741 }; 742 743 class LLVM_LIBRARY_VISIBILITY Linker : public Tool { 744 public: 745 Linker(const ToolChain &TC) : Tool("MinGW::Linker", "linker", TC) {} 746 747 bool hasIntegratedCPP() const override { return false; } 748 bool isLinkJob() const override { return true; } 749 750 void ConstructJob(Compilation &C, const JobAction &JA, 751 const InputInfo &Output, const InputInfoList &Inputs, 752 const llvm::opt::ArgList &TCArgs, 753 const char *LinkingOutput) const override; 754 755 private: 756 void AddLibGCC(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) const; 757 }; 758 } // end namespace MinGW 759 760 namespace arm { 761 enum class FloatABI { 762 Invalid, 763 Soft, 764 SoftFP, 765 Hard, 766 }; 767 768 FloatABI getARMFloatABI(const ToolChain &TC, const llvm::opt::ArgList &Args); 769 } // end namespace arm 770 771 namespace ppc { 772 enum class FloatABI { 773 Invalid, 774 Soft, 775 Hard, 776 }; 777 778 FloatABI getPPCFloatABI(const Driver &D, const llvm::opt::ArgList &Args); 779 } // end namespace ppc 780 781 namespace sparc { 782 enum class FloatABI { 783 Invalid, 784 Soft, 785 Hard, 786 }; 787 788 FloatABI getSparcFloatABI(const Driver &D, const llvm::opt::ArgList &Args); 789 } // end namespace sparc 790 791 namespace XCore { 792 // For XCore, we do not need to instantiate tools for PreProcess, PreCompile and 793 // Compile. 794 // We simply use "clang -cc1" for those actions. 795 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool { 796 public: 797 Assembler(const ToolChain &TC) : Tool("XCore::Assembler", "XCore-as", TC) {} 798 799 bool hasIntegratedCPP() const override { return false; } 800 void ConstructJob(Compilation &C, const JobAction &JA, 801 const InputInfo &Output, const InputInfoList &Inputs, 802 const llvm::opt::ArgList &TCArgs, 803 const char *LinkingOutput) const override; 804 }; 805 806 class LLVM_LIBRARY_VISIBILITY Linker : public Tool { 807 public: 808 Linker(const ToolChain &TC) : Tool("XCore::Linker", "XCore-ld", TC) {} 809 810 bool hasIntegratedCPP() const override { return false; } 811 bool isLinkJob() const override { return true; } 812 void ConstructJob(Compilation &C, const JobAction &JA, 813 const InputInfo &Output, const InputInfoList &Inputs, 814 const llvm::opt::ArgList &TCArgs, 815 const char *LinkingOutput) const override; 816 }; 817 } // end namespace XCore. 818 819 namespace CrossWindows { 820 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool { 821 public: 822 Assembler(const ToolChain &TC) : Tool("CrossWindows::Assembler", "as", TC) {} 823 824 bool hasIntegratedCPP() const override { return false; } 825 826 void ConstructJob(Compilation &C, const JobAction &JA, 827 const InputInfo &Output, const InputInfoList &Inputs, 828 const llvm::opt::ArgList &TCArgs, 829 const char *LinkingOutput) const override; 830 }; 831 832 class LLVM_LIBRARY_VISIBILITY Linker : public Tool { 833 public: 834 Linker(const ToolChain &TC) 835 : Tool("CrossWindows::Linker", "ld", TC, RF_Full) {} 836 837 bool hasIntegratedCPP() const override { return false; } 838 bool isLinkJob() const override { return true; } 839 840 void ConstructJob(Compilation &C, const JobAction &JA, 841 const InputInfo &Output, const InputInfoList &Inputs, 842 const llvm::opt::ArgList &TCArgs, 843 const char *LinkingOutput) const override; 844 }; 845 } // end namespace CrossWindows 846 847 /// SHAVE tools -- Directly call moviCompile and moviAsm 848 namespace SHAVE { 849 class LLVM_LIBRARY_VISIBILITY Compiler : public Tool { 850 public: 851 Compiler(const ToolChain &TC) : Tool("moviCompile", "movicompile", TC) {} 852 853 bool hasIntegratedCPP() const override { return true; } 854 855 void ConstructJob(Compilation &C, const JobAction &JA, 856 const InputInfo &Output, const InputInfoList &Inputs, 857 const llvm::opt::ArgList &TCArgs, 858 const char *LinkingOutput) const override; 859 }; 860 861 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool { 862 public: 863 Assembler(const ToolChain &TC) : Tool("moviAsm", "moviAsm", TC) {} 864 865 bool hasIntegratedCPP() const override { return false; } // not sure. 866 867 void ConstructJob(Compilation &C, const JobAction &JA, 868 const InputInfo &Output, const InputInfoList &Inputs, 869 const llvm::opt::ArgList &TCArgs, 870 const char *LinkingOutput) const override; 871 }; 872 } // end namespace SHAVE 873 874 /// The Myriad toolchain uses tools that are in two different namespaces. 875 /// The Compiler and Assembler as defined above are in the SHAVE namespace, 876 /// whereas the linker, which accepts code for a mixture of Sparc and SHAVE, 877 /// is in the Myriad namespace. 878 namespace Myriad { 879 class LLVM_LIBRARY_VISIBILITY Linker : public GnuTool { 880 public: 881 Linker(const ToolChain &TC) : GnuTool("shave::Linker", "ld", TC) {} 882 bool hasIntegratedCPP() const override { return false; } 883 bool isLinkJob() const override { return true; } 884 void ConstructJob(Compilation &C, const JobAction &JA, 885 const InputInfo &Output, const InputInfoList &Inputs, 886 const llvm::opt::ArgList &TCArgs, 887 const char *LinkingOutput) const override; 888 }; 889 } // end namespace Myriad 890 891 namespace PS4cpu { 892 class LLVM_LIBRARY_VISIBILITY Assemble : public Tool { 893 public: 894 Assemble(const ToolChain &TC) 895 : Tool("PS4cpu::Assemble", "assembler", TC, RF_Full) {} 896 897 bool hasIntegratedCPP() const override { return false; } 898 899 void ConstructJob(Compilation &C, const JobAction &JA, 900 const InputInfo &Output, 901 const InputInfoList &Inputs, 902 const llvm::opt::ArgList &TCArgs, 903 const char *LinkingOutput) const override; 904 }; 905 906 class LLVM_LIBRARY_VISIBILITY Link : public Tool { 907 public: 908 Link(const ToolChain &TC) : Tool("PS4cpu::Link", "linker", TC, RF_Full) {} 909 910 bool hasIntegratedCPP() const override { return false; } 911 bool isLinkJob() const override { return true; } 912 913 void ConstructJob(Compilation &C, const JobAction &JA, 914 const InputInfo &Output, 915 const InputInfoList &Inputs, 916 const llvm::opt::ArgList &TCArgs, 917 const char *LinkingOutput) const override; 918 }; 919 } // end namespace PS4cpu 920 921 namespace NVPTX { 922 923 // Run ptxas, the NVPTX assembler. 924 class LLVM_LIBRARY_VISIBILITY Assembler : public Tool { 925 public: 926 Assembler(const ToolChain &TC) 927 : Tool("NVPTX::Assembler", "ptxas", TC, RF_Full, llvm::sys::WEM_UTF8, 928 "--options-file") {} 929 930 bool hasIntegratedCPP() const override { return false; } 931 932 void ConstructJob(Compilation &C, const JobAction &JA, 933 const InputInfo &Output, const InputInfoList &Inputs, 934 const llvm::opt::ArgList &TCArgs, 935 const char *LinkingOutput) const override; 936 }; 937 938 // Runs fatbinary, which combines GPU object files ("cubin" files) and/or PTX 939 // assembly into a single output file. 940 class LLVM_LIBRARY_VISIBILITY Linker : public Tool { 941 public: 942 Linker(const ToolChain &TC) 943 : Tool("NVPTX::Linker", "fatbinary", TC, RF_Full, llvm::sys::WEM_UTF8, 944 "--options-file") {} 945 946 bool hasIntegratedCPP() const override { return false; } 947 948 void ConstructJob(Compilation &C, const JobAction &JA, 949 const InputInfo &Output, const InputInfoList &Inputs, 950 const llvm::opt::ArgList &TCArgs, 951 const char *LinkingOutput) const override; 952 }; 953 954 } // end namespace NVPTX 955 956 } // end namespace tools 957 } // end namespace driver 958 } // end namespace clang 959 960 #endif // LLVM_CLANG_LIB_DRIVER_TOOLS_H 961
