clang: lib/Driver/ToolChains/CommonArgs.cpp Source File (original) (raw)

1

2

3

4

5

6

7

8

32#include "clang/Config/config.h"

44#include "llvm/ADT/STLExtras.h"

45#include "llvm/ADT/SmallSet.h"

46#include "llvm/ADT/SmallString.h"

47#include "llvm/ADT/StringExtras.h"

48#include "llvm/ADT/StringSwitch.h"

49#include "llvm/ADT/Twine.h"

50#include "llvm/BinaryFormat/Magic.h"

51#include "llvm/Config/llvm-config.h"

52#include "llvm/Option/Arg.h"

53#include "llvm/Option/ArgList.h"

54#include "llvm/Option/Option.h"

55#include "llvm/Support/CodeGen.h"

56#include "llvm/Support/Compression.h"

57#include "llvm/Support/Debug.h"

58#include "llvm/Support/ErrorHandling.h"

59#include "llvm/Support/FileSystem.h"

60#include "llvm/Support/Path.h"

61#include "llvm/Support/Process.h"

62#include "llvm/Support/Program.h"

63#include "llvm/Support/ScopedPrinter.h"

64#include "llvm/Support/Threading.h"

65#include "llvm/Support/VirtualFileSystem.h"

66#include "llvm/Support/YAMLParser.h"

67#include "llvm/TargetParser/Host.h"

68#include "llvm/TargetParser/PPCTargetParser.h"

69#include "llvm/TargetParser/TargetParser.h"

70#include

71

74using namespace clang;

76

78 const llvm::Triple &Triple) {

79 if (Args.hasArg(clang::driver::options::OPT_pg) &&

80 !Args.hasArg(clang::driver::options::OPT_mfentry))

81 return true;

82

83 if (Triple.isAndroid())

84 return true;

85

86 switch (Triple.getArch()) {

87 case llvm::Triple::xcore:

88 case llvm::Triple::wasm32:

89 case llvm::Triple::wasm64:

90 case llvm::Triple::msp430:

91

92

93 return false;

94 case llvm::Triple::ppc:

95 case llvm::Triple::ppcle:

96 case llvm::Triple::ppc64:

97 case llvm::Triple::ppc64le:

98 case llvm::Triple::riscv32:

99 case llvm::Triple::riscv64:

100 case llvm::Triple::sparc:

101 case llvm::Triple::sparcel:

102 case llvm::Triple::sparcv9:

103 case llvm::Triple::amdgcn:

104 case llvm::Triple::r600:

105 case llvm::Triple::csky:

106 case llvm::Triple::loongarch32:

107 case llvm::Triple::loongarch64:

108 case llvm::Triple::m68k:

110 default:

111 break;

112 }

113

114 if (Triple.isOSFuchsia() || Triple.isOSNetBSD()) {

116 }

117

118 if (Triple.isOSLinux() || Triple.isOSHurd()) {

119 switch (Triple.getArch()) {

120

121 case llvm::Triple::arm:

122 case llvm::Triple::armeb:

123 case llvm::Triple::thumb:

124 case llvm::Triple::thumbeb:

125 case llvm::Triple::mips64:

126 case llvm::Triple::mips64el:

127 case llvm::Triple::mips:

128 case llvm::Triple::mipsel:

129 case llvm::Triple::systemz:

130 case llvm::Triple::x86:

131 case llvm::Triple::x86_64:

133 default:

134 return true;

135 }

136 }

137

138 if (Triple.isOSWindows()) {

139 switch (Triple.getArch()) {

140 case llvm::Triple::x86:

142 case llvm::Triple::x86_64:

143 return Triple.isOSBinFormatMachO();

144 case llvm::Triple::arm:

145 case llvm::Triple::thumb:

146

147 return true;

148 default:

149

150

151 return false;

152 }

153 }

154

156 return false;

157

158 return true;

159}

160

162 if (Triple.isAArch64() || Triple.isPS() || Triple.isVE() ||

163 (Triple.isAndroid() && !Triple.isARM()))

164 return false;

165

166 return true;

167}

168

170 switch (Triple.getArch()) {

171 default:

172 return false;

173 case llvm::Triple::arm:

174 case llvm::Triple::thumb:

175

176

177 return Triple.isOSDarwin();

178 }

179}

180

181

182

184 const llvm::Triple &Triple) {

185 if (Triple.isARM() || Triple.isThumb()) {

186

187

188

189 if (Arg *A = Args.getLastArg(options::OPT_mframe_chain)) {

190 StringRef V = A->getValue();

191 return V != "none";

192 }

193 return false;

194 }

195 return false;

196}

197

198

199

201 const llvm::Triple &Triple) {

202 if (Triple.isARM() || Triple.isThumb()) {

203

204

205

206 if (Arg *A = Args.getLastArg(options::OPT_mframe_chain)) {

207 StringRef V = A->getValue();

208 return V == "aapcs+leaf";

209 }

210 return false;

211 }

212 return false;

213}

214

217 const llvm::Triple &Triple) {

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

245 bool EnableFP =

247 Args.hasFlag(clang::driver::options::OPT_fno_omit_frame_pointer,

248 clang::driver::options::OPT_fomit_frame_pointer, DefaultFP);

249

250 bool DefaultLeafFP =

253 bool EnableLeafFP = Args.hasFlag(

254 clang::driver::options::OPT_mno_omit_leaf_frame_pointer,

255 clang::driver::options::OPT_momit_leaf_frame_pointer, DefaultLeafFP);

256

258

259 if (EnableFP) {

260 if (EnableLeafFP)

263 }

264 if (FPRegReserved)

267}

268

270 const StringRef PluginOptPrefix) {

271 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ))

272 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +

273 "-pass-remarks=" + A->getValue()));

274

275 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ))

276 CmdArgs.push_back(Args.MakeArgString(

277 Twine(PluginOptPrefix) + "-pass-remarks-missed=" + A->getValue()));

278

279 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ))

280 CmdArgs.push_back(Args.MakeArgString(

281 Twine(PluginOptPrefix) + "-pass-remarks-analysis=" + A->getValue()));

282}

283

285 const llvm::Triple &Triple,

288 const StringRef PluginOptPrefix) {

289 StringRef Format = "yaml";

290 if (const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))

291 Format = A->getValue();

292

294 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);

295 if (A)

296 F = A->getValue();

299

300 assert(!F.empty() && "Cannot determine remarks output name.");

301

302 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +

303 "opt-remarks-filename=" + F +

304 ".opt.ld." + Format));

305

306 if (const Arg *A =

307 Args.getLastArg(options::OPT_foptimization_record_passes_EQ))

308 CmdArgs.push_back(Args.MakeArgString(

309 Twine(PluginOptPrefix) + "opt-remarks-passes=" + A->getValue()));

310

311 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +

312 "opt-remarks-format=" + Format.data()));

313}

314

316 ArgStringList &CmdArgs,

317 const StringRef PluginOptPrefix) {

318 if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness,

319 options::OPT_fno_diagnostics_show_hotness, false))

320 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +

321 "opt-remarks-with-hotness"));

322

323 if (const Arg *A =

324 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ))

325 CmdArgs.push_back(

326 Args.MakeArgString(Twine(PluginOptPrefix) +

327 "opt-remarks-hotness-threshold=" + A->getValue()));

328}

329

331 llvm::Triple T,

332 StringRef Processor) {

333

334 if (T.isAMDGPU())

335 return false;

336 auto GPUKind = T.isAMDGCN() ? llvm::AMDGPU::parseArchAMDGCN(Processor)

337 : llvm::AMDGPU::parseArchR600(Processor);

338 auto GPUFeatures = T.isAMDGCN() ? llvm::AMDGPU::getArchAttrAMDGCN(GPUKind)

339 : llvm::AMDGPU::getArchAttrR600(GPUKind);

340 if (GPUFeatures & llvm::AMDGPU::FEATURE_WGP)

341 return false;

342 return TargetFeatureArg.getOption().matches(options::OPT_mno_cumode);

343}

344

347 if (D.getVFS().exists(Path))

348 Paths.push_back(Path.str());

349}

350

352 const llvm::Triple &Triple,

353 const ArgList &Args,

354 std::vector &Features,

355 OptSpecifier Group) {

356 std::set Warned;

357 for (const Arg *A : Args.filtered(Group)) {

358 StringRef Name = A->getOption().getName();

359 A->claim();

360

361

362 assert(Name.starts_with("m") && "Invalid feature name.");

363 Name = Name.substr(1);

364

367 if (Warned.count(Name) == 0) {

368 D.getDiags().Report(

369 clang::diag::warn_drv_unsupported_option_for_processor)

370 << A->getAsString(Args) << Proc;

371 Warned.insert(Name);

372 }

373 continue;

374 }

375

376 bool IsNegative = Name.consume_front("no-");

377

378 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name));

379 }

380}

381

384

386 llvm::DenseSet UsedFeatures;

387 for (StringRef Feature : llvm::reverse(Features)) {

388 if (UsedFeatures.insert(Feature.drop_front()).second)

389 UnifiedFeatures.insert(UnifiedFeatures.begin(), Feature);

390 }

391

392 return UnifiedFeatures;

393}

394

396 const char *ArgName, const char *EnvVar) {

397 const char *DirList = ::getenv(EnvVar);

398 bool CombinedArg = false;

399

400 if (!DirList)

401 return;

402

403 StringRef Name(ArgName);

404 if (Name == "-I" || Name == "-L" || Name.empty())

405 CombinedArg = true;

406

407 StringRef Dirs(DirList);

408 if (Dirs.empty())

409 return;

410

411 StringRef::size_type Delim;

412 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) {

413 if (Delim == 0) {

414 if (CombinedArg) {

415 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));

416 } else {

417 CmdArgs.push_back(ArgName);

418 CmdArgs.push_back(".");

419 }

420 } else {

421 if (CombinedArg) {

422 CmdArgs.push_back(

423 Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim)));

424 } else {

425 CmdArgs.push_back(ArgName);

426 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim)));

427 }

428 }

429 Dirs = Dirs.substr(Delim + 1);

430 }

431

432 if (Dirs.empty()) {

433 if (CombinedArg) {

434 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + "."));

435 } else {

436 CmdArgs.push_back(ArgName);

437 CmdArgs.push_back(".");

438 }

439 } else {

440 if (CombinedArg) {

441 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));

442 } else {

443 CmdArgs.push_back(ArgName);

444 CmdArgs.push_back(Args.MakeArgString(Dirs));

445 }

446 }

447}

448

450 const ArgList &Args, ArgStringList &CmdArgs,

453

454

455

456 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);

457

458

459

462

463 for (const auto &II : Inputs) {

464

465

466

467 if (auto *IA = II.getAction())

470 continue;

471

473

474 D.Diag(diag::err_drv_no_linker_llvm_support) << TC.getTripleString();

475

476

477 if (II.isFilename()) {

478 CmdArgs.push_back(II.getFilename());

479 continue;

480 }

481

482

483 if (II.isNothing())

484 continue;

485

486

487 const Arg &A = II.getInputArg();

488

489

490 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))

492 else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext))

494 else

495 A.renderAsInput(Args, CmdArgs);

496 }

497 if (const Arg *A = Args.getLastArg(options::OPT_fveclib)) {

498 const llvm::Triple &Triple = TC.getTriple();

499 StringRef V = A->getValue();

500 if (V == "ArmPL" && (Triple.isOSLinux() || Triple.isOSDarwin())) {

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518 if (Triple.isOSLinux()) {

519 CmdArgs.push_back(Args.MakeArgString("--push-state"));

520 CmdArgs.push_back(Args.MakeArgString("--as-needed"));

521 }

522 CmdArgs.push_back(Args.MakeArgString("-lm"));

523 CmdArgs.push_back(Args.MakeArgString("-lamath"));

524 CmdArgs.push_back(Args.MakeArgString("-lm"));

525 if (Triple.isOSLinux())

526 CmdArgs.push_back(Args.MakeArgString("--pop-state"));

528 }

529 }

530}

531

533 const ToolChain &TC, const llvm::opt::ArgList &Args,

534 llvm::opt::ArgStringList &CmdArgs) {

535

536

537

538

539

540 if (const Arg *A = Args.getLastArg(options::OPT_gz_EQ)) {

541 StringRef V = A->getValue();

542 if (V == "none" || V == "zlib" || V == "zstd")

543 CmdArgs.push_back(Args.MakeArgString("--compress-debug-sections=" + V));

544 else

545 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument)

546 << A->getSpelling() << V;

547 }

548}

549

551 std::vector &Features,

552 OptSpecifier OnOpt, OptSpecifier OffOpt,

553 StringRef FeatureName) {

554 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) {

555 if (A->getOption().matches(OnOpt))

556 Features.push_back(Args.MakeArgString("+" + FeatureName));

557 else

558 Features.push_back(Args.MakeArgString("-" + FeatureName));

559 }

560}

561

562

564 const ArgList &Args) {

565 Arg *MArch = Args.getLastArg(options::OPT_march_EQ);

566 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {

568 return llvm::StringSwitchstd::string(GPUName)

569 .Cases("rv630", "rv635", "r600")

570 .Cases("rv610", "rv620", "rs780", "rs880")

571 .Case("rv740", "rv770")

572 .Case("palm", "cedar")

573 .Cases("sumo", "sumo2", "sumo")

574 .Case("hemlock", "cypress")

575 .Case("aruba", "cayman")

576 .Default(GPUName.str());

577 }

578 if (MArch)

580 return "";

581}

582

584 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {

585 return A->getValue();

586 }

587 return "";

588}

589

590

592

593 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {

594 StringRef CPU = A->getValue();

595

596#ifdef __wasm__

597

598

599 if (CPU == "native")

600 return llvm::sys::getHostCPUName();

601#endif

602

603 return CPU;

604 }

605

606 return "generic";

607}

608

610 const llvm::Triple &T, bool FromAs) {

611 Arg *A;

612

613 switch (T.getArch()) {

614 default:

615 return "";

616

617 case llvm::Triple::aarch64:

618 case llvm::Triple::aarch64_32:

619 case llvm::Triple::aarch64_be:

621

622 case llvm::Triple::arm:

623 case llvm::Triple::armeb:

624 case llvm::Triple::thumb:

625 case llvm::Triple::thumbeb: {

626 StringRef MArch, MCPU;

629 }

630

631 case llvm::Triple::avr:

632 if (const Arg *A = Args.getLastArg(options::OPT_mmcu_EQ))

633 return A->getValue();

634 return "";

635

636 case llvm::Triple::m68k:

638

639 case llvm::Triple::mips:

640 case llvm::Triple::mipsel:

641 case llvm::Triple::mips64:

642 case llvm::Triple::mips64el: {

643 StringRef CPUName;

644 StringRef ABIName;

646 return std::string(CPUName);

647 }

648

649 case llvm::Triple::nvptx:

650 case llvm::Triple::nvptx64:

651 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))

652 return A->getValue();

653 return "";

654

655 case llvm::Triple::ppc:

656 case llvm::Triple::ppcle:

657 case llvm::Triple::ppc64:

658 case llvm::Triple::ppc64le:

659 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_mcpu_EQ))

660 return std::string(

661 llvm::PPC::getNormalizedPPCTargetCPU(T, A->getValue()));

662 return std::string(llvm::PPC::getNormalizedPPCTargetCPU(T));

663

664 case llvm::Triple::csky:

665 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))

666 return A->getValue();

667 else if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))

668 return A->getValue();

669 else

670 return "ck810";

671 case llvm::Triple::riscv32:

672 case llvm::Triple::riscv64:

674

675 case llvm::Triple::bpfel:

676 case llvm::Triple::bpfeb:

677 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))

678 return A->getValue();

679 return "";

680

681 case llvm::Triple::sparc:

682 case llvm::Triple::sparcel:

683 case llvm::Triple::sparcv9:

685

686 case llvm::Triple::x86:

687 case llvm::Triple::x86_64:

689

690 case llvm::Triple::hexagon:

691 return "hexagon" +

693

694 case llvm::Triple::lanai:

696

697 case llvm::Triple::systemz:

699

700 case llvm::Triple::r600:

701 case llvm::Triple::amdgcn:

703

704 case llvm::Triple::wasm32:

705 case llvm::Triple::wasm64:

707

708 case llvm::Triple::loongarch32:

709 case llvm::Triple::loongarch64:

711

712 case llvm::Triple::xtensa:

713 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))

714 return A->getValue();

715 return "";

716 }

717}

718

720 const llvm::Triple &Triple,

721 const ArgList &Args,

722 std::vector &Features) {

724 options::OPT_m_wasm_Features_Group);

725}

726

728 const ArgList &Args, ArgStringList &CmdArgs,

729 bool ForAS, bool IsAux) {

730 std::vector Features;

731 switch (Triple.getArch()) {

732 default:

733 break;

734 case llvm::Triple::mips:

735 case llvm::Triple::mipsel:

736 case llvm::Triple::mips64:

737 case llvm::Triple::mips64el:

739 break;

740 case llvm::Triple::arm:

741 case llvm::Triple::armeb:

742 case llvm::Triple::thumb:

743 case llvm::Triple::thumbeb:

745 break;

746 case llvm::Triple::ppc:

747 case llvm::Triple::ppcle:

748 case llvm::Triple::ppc64:

749 case llvm::Triple::ppc64le:

751 break;

752 case llvm::Triple::riscv32:

753 case llvm::Triple::riscv64:

755 break;

756 case llvm::Triple::systemz:

758 break;

759 case llvm::Triple::aarch64:

760 case llvm::Triple::aarch64_32:

761 case llvm::Triple::aarch64_be:

763 break;

764 case llvm::Triple::x86:

765 case llvm::Triple::x86_64:

767 break;

768 case llvm::Triple::hexagon:

770 break;

771 case llvm::Triple::wasm32:

772 case llvm::Triple::wasm64:

774 break;

775 case llvm::Triple::sparc:

776 case llvm::Triple::sparcel:

777 case llvm::Triple::sparcv9:

779 break;

780 case llvm::Triple::r600:

781 case llvm::Triple::amdgcn:

783 break;

784 case llvm::Triple::nvptx:

785 case llvm::Triple::nvptx64:

787 break;

788 case llvm::Triple::m68k:

790 break;

791 case llvm::Triple::msp430:

793 break;

794 case llvm::Triple::ve:

796 break;

797 case llvm::Triple::csky:

799 break;

800 case llvm::Triple::loongarch32:

801 case llvm::Triple::loongarch64:

803 break;

804 }

805

807 CmdArgs.push_back(IsAux ? "-aux-target-feature" : "-target-feature");

808 CmdArgs.push_back(Feature.data());

809 }

810}

811

813 Arg *LtoJobsArg = Args.getLastArg(options::OPT_flto_jobs_EQ);

814 if (!LtoJobsArg)

815 return {};

816 if (!llvm::get_threadpool_strategy(LtoJobsArg->getValue()))

817 D.Diag(diag::err_drv_invalid_int_value)

818 << LtoJobsArg->getAsString(Args) << LtoJobsArg->getValue();

819 return LtoJobsArg->getValue();

820}

821

822

824 return Triple.isPS();

825}

826

828 const llvm::opt::ArgList &Args) {

830 Arg *A = Args.getLastArg(options::OPT_mtls_dialect_EQ);

831 if (!A)

832 return Triple.hasDefaultTLSDESC();

833 StringRef V = A->getValue();

834 bool SupportedArgument = false, EnableTLSDESC = false;

835 bool Unsupported = !Triple.isOSBinFormatELF();

836 if (Triple.isLoongArch() || Triple.isRISCV()) {

837 SupportedArgument = V == "desc" || V == "trad";

838 EnableTLSDESC = V == "desc";

839 } else if (Triple.isX86()) {

840 SupportedArgument = V == "gnu" || V == "gnu2";

841 EnableTLSDESC = V == "gnu2";

842 } else {

843 Unsupported = true;

844 }

845 if (Unsupported) {

846 TC.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)

847 << A->getSpelling() << Triple.getTriple();

848 } else if (!SupportedArgument) {

849 TC.getDriver().Diag(diag::err_drv_unsupported_option_argument_for_target)

850 << A->getSpelling() << V << Triple.getTriple();

851 }

852 return EnableTLSDESC;

853}

854

856 ArgStringList &CmdArgs, const InputInfo &Output,

857 const InputInfo &Input, bool IsThinLTO) {

859 const bool IsOSAIX = Triple.isOSAIX();

860 const bool IsAMDGCN = Triple.isAMDGCN();

863 const bool IsFatLTO = Args.hasArg(options::OPT_ffat_lto_objects);

864 const bool IsUnifiedLTO = Args.hasArg(options::OPT_funified_lto);

865 if (llvm::sys::path::filename(Linker) != "ld.lld" &&

866 llvm::sys::path::stem(Linker) != "ld.lld" && !Triple.isOSOpenBSD()) {

867

868

869

870 const char *PluginPrefix = IsOSAIX ? "-bplugin:" : "";

871 const char *PluginName = IsOSAIX ? "/libLTO" : "/LLVMgold";

872

873 if (!IsOSAIX)

874 CmdArgs.push_back("-plugin");

875

876#if defined(_WIN32)

877 const char *Suffix = ".dll";

878#elif defined(__APPLE__)

879 const char *Suffix = ".dylib";

880#else

881 const char *Suffix = ".so";

882#endif

883

885 llvm::sys::path::native(Twine(D.Dir) +

886 "/../" CLANG_INSTALL_LIBDIR_BASENAME +

887 PluginName + Suffix,

888 Plugin);

889 CmdArgs.push_back(Args.MakeArgString(Twine(PluginPrefix) + Plugin));

890 } else {

891

892

893 if (IsFatLTO)

894 CmdArgs.push_back("--fat-lto-objects");

895 }

896

897 const char *PluginOptPrefix = IsOSAIX ? "-bplugin_opt:" : "-plugin-opt=";

898 const char *ExtraDash = IsOSAIX ? "-" : "";

899 const char *ParallelismOpt = IsOSAIX ? "-threads=" : "jobs=";

900

901

902

903

904 if (Args.hasArg(options::OPT_gdwarf_aranges)) {

905 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +

906 "-generate-arange-section"));

907 }

908

909

910 Arg *ArgVecLib = Args.getLastArg(options::OPT_fveclib);

911 if (ArgVecLib && ArgVecLib->getNumValues() == 1) {

912

913

914 std::optional OptVal =

915 llvm::StringSwitch<std::optional>(ArgVecLib->getValue())

916 .Case("Accelerate", "Accelerate")

917 .Case("LIBMVEC", "LIBMVEC-X86")

918 .Case("MASSV", "MASSV")

919 .Case("SVML", "SVML")

920 .Case("SLEEF", "sleefgnuabi")

921 .Case("Darwin_libsystem_m", "Darwin_libsystem_m")

922 .Case("ArmPL", "ArmPL")

923 .Case("none", "none")

924 .Default(std::nullopt);

925

926 if (OptVal)

927 CmdArgs.push_back(Args.MakeArgString(

928 Twine(PluginOptPrefix) + "-vector-library=" + OptVal.value()));

929 }

930

931

932

933

934

935 std::string CPU = getCPUName(D, Args, Triple);

936 if (!CPU.empty())

937 CmdArgs.push_back(

938 Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash + "mcpu=" + CPU));

939

940 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {

941

942

943 StringRef OOpt;

944 if (A->getOption().matches(options::OPT_O4) ||

945 A->getOption().matches(options::OPT_Ofast))

946 OOpt = "3";

947 else if (A->getOption().matches(options::OPT_O)) {

948 OOpt = A->getValue();

949 if (OOpt == "g")

950 OOpt = "1";

951 else if (OOpt == "s" || OOpt == "z")

952 OOpt = "2";

953 } else if (A->getOption().matches(options::OPT_O0))

954 OOpt = "0";

955 if (!OOpt.empty()) {

956 CmdArgs.push_back(

957 Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash + "O" + OOpt));

958 if (IsAMDGCN)

959 CmdArgs.push_back(Args.MakeArgString(Twine("--lto-CGO") + OOpt));

960 }

961 }

962

963 if (Args.hasArg(options::OPT_gsplit_dwarf))

964 CmdArgs.push_back(Args.MakeArgString(

965 Twine(PluginOptPrefix) + "dwo_dir=" + Output.getFilename() + "_dwo"));

966

967 if (IsThinLTO && !IsOSAIX)

968 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + "thinlto"));

969 else if (IsThinLTO && IsOSAIX)

970 CmdArgs.push_back(Args.MakeArgString(Twine("-bdbg:thinlto")));

971

972

973

974

975 if ((IsThinLTO || IsFatLTO || IsUnifiedLTO) &&

976 Args.hasArg(options::OPT_fenable_matrix))

977 CmdArgs.push_back(

978 Args.MakeArgString(Twine(PluginOptPrefix) + "-enable-matrix"));

979

981 if (!Parallelism.empty())

982 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +

983 ParallelismOpt + Parallelism));

984

985

986 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,

987 options::OPT_fno_global_isel)) {

988

989

990 CmdArgs.push_back(Args.MakeArgString(

991 Twine(PluginOptPrefix) + "-global-isel=" +

992 (A->getOption().matches(options::OPT_fglobal_isel) ? "1" : "0")));

993 }

994

995

996 if (Arg *A =

997 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) {

998 if (A->getOption().matches(options::OPT_glldb))

999 CmdArgs.push_back(

1000 Args.MakeArgString(Twine(PluginOptPrefix) + "-debugger-tune=lldb"));

1001 else if (A->getOption().matches(options::OPT_gsce))

1002 CmdArgs.push_back(

1003 Args.MakeArgString(Twine(PluginOptPrefix) + "-debugger-tune=sce"));

1004 else if (A->getOption().matches(options::OPT_gdbx))

1005 CmdArgs.push_back(

1006 Args.MakeArgString(Twine(PluginOptPrefix) + "-debugger-tune=dbx"));

1007 else

1008 CmdArgs.push_back(

1009 Args.MakeArgString(Twine(PluginOptPrefix) + "-debugger-tune=gdb"));

1010 }

1011

1012 if (IsOSAIX) {

1014 CmdArgs.push_back(

1015 Args.MakeArgString(Twine(PluginOptPrefix) + "-no-integrated-as=1"));

1016

1017

1018

1019 Arg *A = Args.getLastArg(options::OPT_g_Group);

1020 bool EnableDebugInfo = A && !A->getOption().matches(options::OPT_g0) &&

1021 !A->getOption().matches(options::OPT_ggdb0);

1022 if (EnableDebugInfo && Args.hasFlag(options::OPT_gstrict_dwarf,

1023 options::OPT_gno_strict_dwarf, true))

1024 CmdArgs.push_back(

1025 Args.MakeArgString(Twine(PluginOptPrefix) + "-strict-dwarf=true"));

1026

1027 for (const Arg *A : Args.filtered_reverse(options::OPT_mabi_EQ)) {

1028 StringRef V = A->getValue();

1029 if (V == "vec-default")

1030 break;

1031 if (V == "vec-extabi") {

1032 CmdArgs.push_back(

1033 Args.MakeArgString(Twine(PluginOptPrefix) + "-vec-extabi"));

1034 break;

1035 }

1036 }

1037 }

1038

1039 bool UseSeparateSections =

1041

1042 if (Args.hasFlag(options::OPT_ffunction_sections,

1043 options::OPT_fno_function_sections, UseSeparateSections))

1044 CmdArgs.push_back(

1045 Args.MakeArgString(Twine(PluginOptPrefix) + "-function-sections=1"));

1046 else if (Args.hasArg(options::OPT_fno_function_sections))

1047 CmdArgs.push_back(

1048 Args.MakeArgString(Twine(PluginOptPrefix) + "-function-sections=0"));

1049

1050 bool DataSectionsTurnedOff = false;

1051 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,

1052 UseSeparateSections)) {

1053 CmdArgs.push_back(

1054 Args.MakeArgString(Twine(PluginOptPrefix) + "-data-sections=1"));

1055 } else if (Args.hasArg(options::OPT_fno_data_sections)) {

1056 DataSectionsTurnedOff = true;

1057 CmdArgs.push_back(

1058 Args.MakeArgString(Twine(PluginOptPrefix) + "-data-sections=0"));

1059 }

1060

1061 if (Args.hasArg(options::OPT_mxcoff_roptr) ||

1062 Args.hasArg(options::OPT_mno_xcoff_roptr)) {

1063 bool HasRoptr = Args.hasFlag(options::OPT_mxcoff_roptr,

1064 options::OPT_mno_xcoff_roptr, false);

1065 StringRef OptStr = HasRoptr ? "-mxcoff-roptr" : "-mno-xcoff-roptr";

1066 if (!IsOSAIX)

1067 D.Diag(diag::err_drv_unsupported_opt_for_target)

1068 << OptStr << Triple.str();

1069

1070 if (HasRoptr) {

1071

1072

1073

1074 if (DataSectionsTurnedOff)

1075 D.Diag(diag::err_roptr_requires_data_sections);

1076

1077 CmdArgs.push_back(

1078 Args.MakeArgString(Twine(PluginOptPrefix) + "-mxcoff-roptr"));

1079 }

1080 }

1081

1082

1083 if (auto *A = Args.getLastArg(options::OPT_fsplit_machine_functions,

1084 options::OPT_fno_split_machine_functions)) {

1085 if (A->getOption().matches(options::OPT_fsplit_machine_functions))

1086 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +

1087 "-split-machine-functions"));

1088 }

1089

1091 StringRef FName = A->getValue();

1092 if (!llvm::sys::fs::exists(FName))

1093 D.Diag(diag::err_drv_no_such_file) << FName;

1094 else

1095 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +

1096 "sample-profile=" + FName));

1097 }

1098

1100 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +

1101 "cs-profile-generate"));

1102 if (CSPGOGenerateArg->getOption().matches(

1103 options::OPT_fcs_profile_generate_EQ)) {

1105 llvm::sys::path::append(Path, "default_%m.profraw");

1106 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +

1107 "cs-profile-path=" + Path));

1108 } else

1109 CmdArgs.push_back(

1110 Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +

1111 "cs-profile-path=default_%m.profraw"));

1114 ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());

1115 if (Path.empty() || llvm::sys::fs::is_directory(Path))

1116 llvm::sys::path::append(Path, "default.profdata");

1117 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + ExtraDash +

1118 "cs-profile-path=" + Path));

1119 }

1120

1121

1122 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false)) {

1124 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) +

1125 "-enable-jmc-instrument"));

1126 else

1127 D.Diag(clang::diag::warn_drv_fjmc_for_elf_only);

1128 }

1129

1130 if (Args.hasFlag(options::OPT_femulated_tls, options::OPT_fno_emulated_tls,

1131 Triple.hasDefaultEmulatedTLS())) {

1132 CmdArgs.push_back(

1133 Args.MakeArgString(Twine(PluginOptPrefix) + "-emulated-tls"));

1134 }

1136 CmdArgs.push_back(

1137 Args.MakeArgString(Twine(PluginOptPrefix) + "-enable-tlsdesc"));

1138

1139 if (Args.hasFlag(options::OPT_fstack_size_section,

1140 options::OPT_fno_stack_size_section, false))

1141 CmdArgs.push_back(

1142 Args.MakeArgString(Twine(PluginOptPrefix) + "-stack-size-section"));

1143

1144

1146 if (!StatsFile.empty())

1147 CmdArgs.push_back(

1148 Args.MakeArgString(Twine(PluginOptPrefix) + "stats-file=" + StatsFile));

1149

1150

1151 if (Arg *A = Args.getLastArg(options::OPT_fcrash_diagnostics_dir))

1152 CmdArgs.push_back(Args.MakeArgString(

1153 Twine(PluginOptPrefix) + "-crash-diagnostics-dir=" + A->getValue()));

1154

1156

1157

1159

1160

1161

1164 Output, PluginOptPrefix);

1165

1166

1168

1170 true, PluginOptPrefix);

1171

1172 bool IsELF = Triple.isOSBinFormatELF();

1173 bool Crel = false;

1174 bool ImplicitMapSyms = false;

1175 for (const Arg *A : Args.filtered(options::OPT_Wa_COMMA)) {

1176 for (StringRef V : A->getValues()) {

1177 auto Equal = V.split('=');

1178 auto checkArg = [&](bool ValidTarget,

1179 std::initializer_list<const char *> Set) {

1180 if (!ValidTarget) {

1181 D.Diag(diag::err_drv_unsupported_opt_for_target)

1182 << (Twine("-Wa,") + Equal.first + "=").str()

1183 << Triple.getTriple();

1184 } else if (!llvm::is_contained(Set, Equal.second)) {

1185 D.Diag(diag::err_drv_unsupported_option_argument)

1186 << (Twine("-Wa,") + Equal.first + "=").str() << Equal.second;

1187 }

1188 };

1189 if (Equal.first == "-mmapsyms") {

1190 ImplicitMapSyms = Equal.second == "implicit";

1191 checkArg(IsELF && Triple.isAArch64(), {"default", "implicit"});

1192 } else if (V == "--crel")

1193 Crel = true;

1194 else if (V == "--no-crel")

1195 Crel = false;

1196 else

1197 continue;

1198 A->claim();

1199 }

1200 }

1201 if (Crel) {

1202 if (IsELF && !Triple.isMIPS()) {

1203 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + "-crel"));

1204 } else {

1205 D.Diag(diag::err_drv_unsupported_opt_for_target)

1206 << "-Wa,--crel" << D.getTargetTriple();

1207 }

1208 }

1209 if (ImplicitMapSyms)

1210 CmdArgs.push_back(

1211 Args.MakeArgString(Twine(PluginOptPrefix) + "-implicit-mapsyms"));

1212

1213 if (Args.hasArg(options::OPT_ftime_report))

1214 CmdArgs.push_back(

1215 Args.MakeArgString(Twine(PluginOptPrefix) + "-time-passes"));

1216}

1217

1219 const ArgList &Args,

1220 ArgStringList &CmdArgs) {

1221

1222

1224 llvm::sys::path::parent_path(TC.getDriver().Dir);

1225 llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);

1226 CmdArgs.push_back(Args.MakeArgString("-L" + DefaultLibPath));

1227}

1228

1230 ArgStringList &CmdArgs) {

1231 if (!Args.hasFlag(options::OPT_frtlib_add_rpath,

1232 options::OPT_fno_rtlib_add_rpath, false))

1233 return;

1234

1236 if (const auto CandidateRPath = TC.getStdlibPath())

1237 CandidateRPaths.emplace_back(*CandidateRPath);

1238

1239 for (const auto &CandidateRPath : CandidateRPaths) {

1240 if (TC.getVFS().exists(CandidateRPath)) {

1241 CmdArgs.push_back("-rpath");

1242 CmdArgs.push_back(Args.MakeArgString(CandidateRPath));

1243 }

1244 }

1245}

1246

1248 const ToolChain &TC, const ArgList &Args,

1249 bool ForceStaticHostRuntime, bool IsOffloadingHost,

1250 bool GompNeedsRT) {

1251 if (!Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,

1252 options::OPT_fno_openmp, false)) {

1253

1254 if (Args.hasFlag(options::OPT_foffload_via_llvm,

1255 options::OPT_fno_offload_via_llvm, false))

1256 CmdArgs.push_back("-lomptarget");

1257 return false;

1258 }

1259

1261

1263

1264 return false;

1265

1266 if (ForceStaticHostRuntime)

1267 CmdArgs.push_back("-Bstatic");

1268

1269 switch (RTKind) {

1271 CmdArgs.push_back("-lomp");

1272 break;

1274 CmdArgs.push_back("-lgomp");

1275 break;

1277 CmdArgs.push_back("-liomp5");

1278 break;

1280 break;

1281 }

1282

1283 if (ForceStaticHostRuntime)

1284 CmdArgs.push_back("-Bdynamic");

1285

1287 CmdArgs.push_back("-lrt");

1288

1289 if (IsOffloadingHost)

1290 CmdArgs.push_back("-lomptarget");

1291

1292 if (IsOffloadingHost && !Args.hasArg(options::OPT_nogpulib))

1293 CmdArgs.push_back("-lomptarget.devicertl");

1294

1296

1298

1299 return true;

1300}

1301

1304 const llvm::opt::ArgList &Args,

1305 llvm::opt::ArgStringList &CmdArgs) {

1307 return;

1308

1309

1310

1311 constexpr llvm::StringLiteral Targets("-fopenmp-targets=");

1312

1315 std::transform(TCRange.first, TCRange.second, std::back_inserter(Triples),

1316 [](auto TC) { return TC.second->getTripleString(); });

1317 CmdArgs.push_back(

1318 Args.MakeArgString(Twine(Targets) + llvm::join(Triples, ",")));

1319}

1320

1321

1323 llvm::opt::ArgStringList &CmdArgs) {

1324

1325

1326

1327

1328 if (!TC.getTriple().isKnownWindowsMSVCEnvironment()) {

1330 F128LibName.consume_front_insensitive("lib");

1331 if (!F128LibName.empty()) {

1332 bool AsNeeded = !TC.getTriple().isOSAIX();

1333 CmdArgs.push_back("-lFortranFloat128Math");

1334 if (AsNeeded)

1336 CmdArgs.push_back(Args.MakeArgString("-l" + F128LibName));

1337 if (AsNeeded)

1339 }

1340 CmdArgs.push_back("-lFortranRuntime");

1341 CmdArgs.push_back("-lFortranDecimal");

1343 }

1344

1345

1346 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ,

1347 options::OPT_fno_openmp, false)) {

1352 CmdArgs.push_back("-latomic");

1353 }

1354}

1355

1357 const llvm::opt::ArgList &Args,

1358 ArgStringList &CmdArgs) {

1359

1360

1361

1362

1364 llvm::sys::path::parent_path(TC.getDriver().Dir);

1365 llvm::sys::path::append(DefaultLibPath, "lib");

1366 if (TC.getTriple().isKnownWindowsMSVCEnvironment())

1367 CmdArgs.push_back(Args.MakeArgString("-libpath:" + DefaultLibPath));

1368 else

1369 CmdArgs.push_back(Args.MakeArgString("-L" + DefaultLibPath));

1370}

1371

1373 ArgStringList &CmdArgs, StringRef Sanitizer,

1374 bool IsShared, bool IsWhole) {

1375

1376

1377 if (IsWhole) CmdArgs.push_back("--whole-archive");

1380 if (IsWhole) CmdArgs.push_back("--no-whole-archive");

1381

1382 if (IsShared) {

1384 }

1385}

1386

1387

1388

1390 ArgStringList &CmdArgs,

1391 StringRef Sanitizer) {

1393

1394

1395

1396 if (TC.getTriple().isOSSolaris() && !LinkerIsGnuLd)

1397 return true;

1399 if (llvm::sys::fs::exists(SanRT + ".syms")) {

1400 CmdArgs.push_back(Args.MakeArgString("--dynamic-list=" + SanRT + ".syms"));

1401 return true;

1402 }

1403 return false;

1404}

1405

1407 const llvm::opt::ArgList &Args,

1408 llvm::opt::ArgStringList &CmdArgs,

1409 bool as_needed) {

1410 assert(!TC.getTriple().isOSAIX() &&

1411 "AIX linker does not support any form of --as-needed option yet.");

1413

1414

1415

1416

1417

1418

1419 if (TC.getTriple().isOSSolaris() && !LinkerIsGnuLd) {

1420 CmdArgs.push_back("-z");

1421 CmdArgs.push_back(as_needed ? "ignore" : "record");

1422 } else {

1423 CmdArgs.push_back(as_needed ? "--as-needed" : "--no-as-needed");

1424 }

1425}

1426

1428 const llvm::opt::ArgList &Args,

1429 ArgStringList &CmdArgs) {

1430

1431

1433

1434 if (TC.getTriple().getOS() != llvm::Triple::RTEMS &&

1436 CmdArgs.push_back("-lpthread");

1437 if (!TC.getTriple().isOSOpenBSD())

1438 CmdArgs.push_back("-lrt");

1439 }

1440 CmdArgs.push_back("-lm");

1441

1442 if (!TC.getTriple().isOSFreeBSD() && !TC.getTriple().isOSNetBSD() &&

1443 !TC.getTriple().isOSOpenBSD() &&

1444 TC.getTriple().getOS() != llvm::Triple::RTEMS)

1445 CmdArgs.push_back("-ldl");

1446

1447 if (TC.getTriple().isOSFreeBSD() ||

1450 CmdArgs.push_back("-lexecinfo");

1451

1452

1453

1456 CmdArgs.push_back("-lresolv");

1457}

1458

1459static void

1466 assert(!TC.getTriple().isOSDarwin() && "it's not used by Darwin");

1468

1471 SharedRuntimes.push_back("asan");

1472 if (!Args.hasArg(options::OPT_shared) && !TC.getTriple().isAndroid())

1473 HelperStaticRuntimes.push_back("asan-preinit");

1474 }

1476 SharedRuntimes.push_back("memprof");

1477 if (!Args.hasArg(options::OPT_shared) && !TC.getTriple().isAndroid())

1478 HelperStaticRuntimes.push_back("memprof-preinit");

1479 }

1481 SharedRuntimes.push_back("nsan");

1484 SharedRuntimes.push_back("ubsan_minimal");

1485 else

1486 SharedRuntimes.push_back("ubsan_standalone");

1487 }

1489 SharedRuntimes.push_back("scudo_standalone");

1490 }

1492 SharedRuntimes.push_back("tsan");

1494 SharedRuntimes.push_back("tysan");

1497 SharedRuntimes.push_back("hwasan_aliases");

1498 else

1499 SharedRuntimes.push_back("hwasan");

1500 if (!Args.hasArg(options::OPT_shared))

1501 HelperStaticRuntimes.push_back("hwasan-preinit");

1502 }

1504 SharedRuntimes.push_back("rtsan");

1505 }

1506

1507

1509 StaticRuntimes.push_back("stats_client");

1510

1511

1513 HelperStaticRuntimes.push_back("asan_static");

1514

1515

1516 if (Args.hasArg(options::OPT_shared)) {

1517

1518 return;

1519 }

1520

1521

1522

1523

1525 StaticRuntimes.push_back("asan");

1527 StaticRuntimes.push_back("asan_cxx");

1528 }

1529

1532 StaticRuntimes.push_back("rtsan");

1533

1535 StaticRuntimes.push_back("memprof");

1537 StaticRuntimes.push_back("memprof_cxx");

1538 }

1539

1542 StaticRuntimes.push_back("hwasan_aliases");

1544 StaticRuntimes.push_back("hwasan_aliases_cxx");

1545 } else {

1546 StaticRuntimes.push_back("hwasan");

1548 StaticRuntimes.push_back("hwasan_cxx");

1549 }

1550 }

1552 StaticRuntimes.push_back("dfsan");

1554 StaticRuntimes.push_back("lsan");

1556 StaticRuntimes.push_back("msan");

1558 StaticRuntimes.push_back("msan_cxx");

1559 }

1561 StaticRuntimes.push_back("nsan");

1563 StaticRuntimes.push_back("tsan");

1565 StaticRuntimes.push_back("tsan_cxx");

1566 }

1568 StaticRuntimes.push_back("tysan");

1571 StaticRuntimes.push_back("ubsan_minimal");

1572 } else {

1573 StaticRuntimes.push_back("ubsan_standalone");

1574 }

1575 }

1577 NonWholeStaticRuntimes.push_back("safestack");

1578 RequiredSymbols.push_back("__safestack_init");

1579 }

1582 StaticRuntimes.push_back("cfi");

1584 StaticRuntimes.push_back("cfi_diag");

1585 }

1589 StaticRuntimes.push_back("ubsan_standalone_cxx");

1590 }

1592 NonWholeStaticRuntimes.push_back("stats");

1593 RequiredSymbols.push_back("__sanitizer_stats_register");

1594 }

1596 StaticRuntimes.push_back("scudo_standalone");

1598 StaticRuntimes.push_back("scudo_standalone_cxx");

1599 }

1600}

1601

1602

1603

1605 ArgStringList &CmdArgs) {

1608 NonWholeStaticRuntimes, HelperStaticRuntimes, RequiredSymbols;

1611 NonWholeStaticRuntimes, HelperStaticRuntimes,

1612 RequiredSymbols);

1613 }

1614

1615

1616 for (auto S : RequiredSymbols) {

1617 CmdArgs.push_back("-u");

1618 CmdArgs.push_back(Args.MakeArgString(S));

1619 }

1620

1621

1623 !Args.hasArg(options::OPT_shared)) {

1624

1628 true);

1629 if (!Args.hasArg(clang::driver::options::OPT_nostdlibxx)) {

1630 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&

1631 !Args.hasArg(options::OPT_static);

1632 if (OnlyLibstdcxxStatic)

1633 CmdArgs.push_back("-Bstatic");

1635 if (OnlyLibstdcxxStatic)

1636 CmdArgs.push_back("-Bdynamic");

1637 }

1638 }

1639

1640 for (auto RT : SharedRuntimes)

1642 for (auto RT : HelperStaticRuntimes)

1644 bool AddExportDynamic = false;

1645 for (auto RT : StaticRuntimes) {

1648 }

1649 for (auto RT : NonWholeStaticRuntimes) {

1652 }

1653

1654

1655 if (AddExportDynamic)

1656 CmdArgs.push_back("--export-dynamic");

1657

1659 CmdArgs.push_back("--export-dynamic-symbol=__cfi_check");

1660

1662 if (!TC.getTriple().isAndroid()) {

1663 TC.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)

1664 << "-fsanitize=memtag*" << TC.getTriple().str();

1665 }

1666 CmdArgs.push_back(

1667 Args.MakeArgString("--android-memtag-mode=" + SanArgs.getMemtagMode()));

1669 CmdArgs.push_back("--android-memtag-heap");

1671 CmdArgs.push_back("--android-memtag-stack");

1672 }

1673

1674 return !StaticRuntimes.empty() || !NonWholeStaticRuntimes.empty();

1675}

1676

1678 if (Args.hasArg(options::OPT_shared)) {

1680 CmdArgs.push_back("--whole-archive");

1682 CmdArgs.push_back("--no-whole-archive");

1683 return true;

1684 }

1686 CmdArgs.push_back("--whole-archive");

1690 CmdArgs.push_back("--no-whole-archive");

1691 return true;

1692 }

1693

1694 return false;

1695}

1696

1698 const llvm::opt::ArgList &Args,

1699 ArgStringList &CmdArgs) {

1701 CmdArgs.push_back("-lpthread");

1702 if (!TC.getTriple().isOSOpenBSD())

1703 CmdArgs.push_back("-lrt");

1704 CmdArgs.push_back("-lm");

1705

1706 if (!TC.getTriple().isOSFreeBSD() &&

1709 CmdArgs.push_back("-ldl");

1710}

1711

1713

1714 if (Arg *A = Args.getLastArg(options::OPT_O_Group))

1715 return !A->getOption().matches(options::OPT_O0);

1716

1717 return false;

1718}

1719

1723 auto AddPostfix = [JA](auto &F) {

1726 F += ".dwo";

1727 };

1728 if (Arg *A = Args.getLastArg(options::OPT_gsplit_dwarf_EQ))

1729 if (StringRef(A->getValue()) == "single" && Output.isFilename())

1730 return Args.MakeArgString(Output.getFilename());

1731

1733 if (const Arg *A = Args.getLastArg(options::OPT_dumpdir)) {

1734 T = A->getValue();

1735 } else {

1736 Arg *FinalOutput = Args.getLastArg(options::OPT_o, options::OPT__SLASH_o);

1737 if (FinalOutput && Args.hasArg(options::OPT_c)) {

1738 T = FinalOutput->getValue();

1739 llvm::sys::path::remove_filename(T);

1740 llvm::sys::path::append(T,

1741 llvm::sys::path::stem(FinalOutput->getValue()));

1742 AddPostfix(T);

1743 return Args.MakeArgString(T);

1744 }

1745 }

1746

1747 T += llvm::sys::path::stem(Input.getBaseInput());

1748 AddPostfix(T);

1749 return Args.MakeArgString(T);

1750}

1751

1753 const JobAction &JA, const ArgList &Args,

1754 const InputInfo &Output, const char *OutFile) {

1755 ArgStringList ExtractArgs;

1756 ExtractArgs.push_back("--extract-dwo");

1757

1758 ArgStringList StripArgs;

1759 StripArgs.push_back("--strip-dwo");

1760

1761

1762 StripArgs.push_back(Output.getFilename());

1763 ExtractArgs.push_back(Output.getFilename());

1764 ExtractArgs.push_back(OutFile);

1765

1766 const char *Exec =

1767 Args.MakeArgString(TC.GetProgramPath(CLANG_DEFAULT_OBJCOPY));

1769

1770

1771 C.addCommand(std::make_unique(JA, T,

1773 Exec, ExtractArgs, II, Output));

1774

1775

1776 C.addCommand(std::make_unique(

1778}

1779

1780

1781

1782

1784

1785

1786 Args.ClaimAllArgs(options::OPT_flto_EQ);

1787 Args.ClaimAllArgs(options::OPT_flto);

1788 Args.ClaimAllArgs(options::OPT_fno_lto);

1789}

1790

1792 auto *CSPGOGenerateArg = Args.getLastArg(options::OPT_fcs_profile_generate,

1793 options::OPT_fcs_profile_generate_EQ,

1794 options::OPT_fno_profile_generate);

1795 if (CSPGOGenerateArg &&

1796 CSPGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))

1797 CSPGOGenerateArg = nullptr;

1798

1799 return CSPGOGenerateArg;

1800}

1801

1803 auto *ProfileUseArg = Args.getLastArg(

1804 options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,

1805 options::OPT_fprofile_use, options::OPT_fprofile_use_EQ,

1806 options::OPT_fno_profile_instr_use);

1807

1808 if (ProfileUseArg &&

1809 ProfileUseArg->getOption().matches(options::OPT_fno_profile_instr_use))

1810 ProfileUseArg = nullptr;

1811

1812 return ProfileUseArg;

1813}

1814

1816 auto *ProfileSampleUseArg = Args.getLastArg(

1817 options::OPT_fprofile_sample_use_EQ, options::OPT_fno_profile_sample_use);

1818

1819 if (ProfileSampleUseArg && (ProfileSampleUseArg->getOption().matches(

1820 options::OPT_fno_profile_sample_use)))

1821 return nullptr;

1822

1823 return Args.getLastArg(options::OPT_fprofile_sample_use_EQ);

1824}

1825

1827 switch (Model) {

1828 case llvm::Reloc::Static:

1829 return "static";

1830 case llvm::Reloc::PIC_:

1831 return "pic";

1832 case llvm::Reloc::DynamicNoPIC:

1833 return "dynamic-no-pic";

1834 case llvm::Reloc::ROPI:

1835 return "ropi";

1836 case llvm::Reloc::RWPI:

1837 return "rwpi";

1838 case llvm::Reloc::ROPI_RWPI:

1839 return "ropi-rwpi";

1840 }

1841 llvm_unreachable("Unknown Reloc::Model kind");

1842}

1843

1844

1845

1846

1847

1848std::tuple<llvm::Reloc::Model, unsigned, bool>

1852

1855

1856 if (Triple.isOSBinFormatMachO() && Args.hasArg(options::OPT_static))

1857 PIE = PIC = false;

1858 bool IsPICLevelTwo = PIC;

1859

1860 bool KernelOrKext =

1861 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext);

1862

1863

1864 if (Triple.isAndroid()) {

1865 switch (Triple.getArch()) {

1866 case llvm::Triple::x86:

1867 case llvm::Triple::x86_64:

1868 PIC = true;

1869 IsPICLevelTwo = true;

1870 break;

1871

1872 default:

1873 PIC = true;

1874 break;

1875 }

1876 }

1877

1878

1879 if (Triple.isOHOSFamily() && Triple.getArch() == llvm::Triple::aarch64)

1880 PIC = true;

1881

1882

1883 if (Triple.isOSOpenBSD()) {

1885 case llvm::Triple::arm:

1886 case llvm::Triple::aarch64:

1887 case llvm::Triple::mips64:

1888 case llvm::Triple::mips64el:

1889 case llvm::Triple::x86:

1890 case llvm::Triple::x86_64:

1891 IsPICLevelTwo = false;

1892 break;

1893

1894 case llvm::Triple::ppc:

1895 case llvm::Triple::sparcv9:

1896 IsPICLevelTwo = true;

1897 break;

1898

1899 default:

1900 break;

1901 }

1902 }

1903

1904

1905

1906

1907

1908 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC,

1909 options::OPT_fpic, options::OPT_fno_pic,

1910 options::OPT_fPIE, options::OPT_fno_PIE,

1911 options::OPT_fpie, options::OPT_fno_pie);

1912 if (Triple.isOSWindows() && !Triple.isOSCygMing() && LastPICArg &&

1913 LastPICArg == Args.getLastArg(options::OPT_fPIC, options::OPT_fpic,

1914 options::OPT_fPIE, options::OPT_fpie)) {

1916 << LastPICArg->getSpelling() << Triple.str();

1917 if (Triple.getArch() == llvm::Triple::x86_64)

1918 return std::make_tuple(llvm::Reloc::PIC_, 2U, false);

1919 return std::make_tuple(llvm::Reloc::Static, 0U, false);

1920 }

1921

1922

1923

1925 if (LastPICArg) {

1926 Option O = LastPICArg->getOption();

1927 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) ||

1928 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) {

1929 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie);

1930 PIC =

1931 PIE || O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic);

1932 IsPICLevelTwo =

1933 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fPIC);

1934 } else {

1935 PIE = PIC = false;

1936 if (EffectiveTriple.isPS()) {

1937 Arg *ModelArg = Args.getLastArg(options::OPT_mcmodel_EQ);

1938 StringRef Model = ModelArg ? ModelArg->getValue() : "";

1939 if (Model != "kernel") {

1940 PIC = true;

1942 << LastPICArg->getSpelling()

1943 << (EffectiveTriple.isPS4() ? "PS4" : "PS5");

1944 }

1945 }

1946 }

1947 }

1948 }

1949

1950

1951

1952

1953 if (PIC && (Triple.isOSDarwin() || EffectiveTriple.isPS()))

1955

1956

1957

1958 if (KernelOrKext &&

1959 ((!EffectiveTriple.isiOS() || EffectiveTriple.isOSVersionLT(6)) &&

1960 !EffectiveTriple.isWatchOS() && !EffectiveTriple.isDriverKit()))

1961 PIC = PIE = false;

1962

1963 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) {

1964

1965

1966 if (!Triple.isOSDarwin())

1968 << A->getSpelling() << Triple.str();

1969

1970

1971

1972

1973

1974

1976

1977 return std::make_tuple(llvm::Reloc::DynamicNoPIC, PIC ? 2U : 0U, false);

1978 }

1979

1980 bool EmbeddedPISupported;

1981 switch (Triple.getArch()) {

1982 case llvm::Triple::arm:

1983 case llvm::Triple::armeb:

1984 case llvm::Triple::thumb:

1985 case llvm::Triple::thumbeb:

1986 EmbeddedPISupported = true;

1987 break;

1988 default:

1989 EmbeddedPISupported = false;

1990 break;

1991 }

1992

1993 bool ROPI = false, RWPI = false;

1994 Arg* LastROPIArg = Args.getLastArg(options::OPT_fropi, options::OPT_fno_ropi);

1995 if (LastROPIArg && LastROPIArg->getOption().matches(options::OPT_fropi)) {

1996 if (!EmbeddedPISupported)

1998 << LastROPIArg->getSpelling() << Triple.str();

1999 ROPI = true;

2000 }

2001 Arg *LastRWPIArg = Args.getLastArg(options::OPT_frwpi, options::OPT_fno_rwpi);

2002 if (LastRWPIArg && LastRWPIArg->getOption().matches(options::OPT_frwpi)) {

2003 if (!EmbeddedPISupported)

2005 << LastRWPIArg->getSpelling() << Triple.str();

2006 RWPI = true;

2007 }

2008

2009

2010 if ((ROPI || RWPI) && (PIC || PIE))

2012

2013 if (Triple.isMIPS()) {

2014 StringRef CPUName;

2015 StringRef ABIName;

2017

2018

2019

2020 if (ABIName == "n64")

2021 PIC = true;

2022

2023 if(Args.hasArg(options::OPT_mno_abicalls))

2024 return std::make_tuple(llvm::Reloc::Static, 0U, false);

2025

2026

2027 IsPICLevelTwo = false;

2028 }

2029

2030 if (PIC)

2031 return std::make_tuple(llvm::Reloc::PIC_, IsPICLevelTwo ? 2U : 1U, PIE);

2032

2033 llvm::Reloc::Model RelocM = llvm::Reloc::Static;

2034 if (ROPI && RWPI)

2035 RelocM = llvm::Reloc::ROPI_RWPI;

2036 else if (ROPI)

2037 RelocM = llvm::Reloc::ROPI;

2038 else if (RWPI)

2039 RelocM = llvm::Reloc::RWPI;

2040

2041 return std::make_tuple(RelocM, 0U, false);

2042}

2043

2044

2045

2046

2047

2048

2049

2050

2051

2052

2053

2054

2055

2056

2057

2058

2059

2061 const ArgList &Args) {

2062 const Arg *A = Args.getLastArg(options::OPT_falign_functions,

2063 options::OPT_falign_functions_EQ,

2064 options::OPT_fno_align_functions);

2065 if (!A || A->getOption().matches(options::OPT_fno_align_functions))

2066 return 0;

2067

2068 if (A->getOption().matches(options::OPT_falign_functions))

2069 return 0;

2070

2071 unsigned Value = 0;

2072 if (StringRef(A->getValue()).getAsInteger(10, Value) || Value > 65536)

2073 TC.getDriver().Diag(diag::err_drv_invalid_int_value)

2074 << A->getAsString(Args) << A->getValue();

2075 return Value ? llvm::Log2_32_Ceil(std::min(Value, 65536u)) : Value;

2076}

2077

2079 ArgStringList &CmdArgs, llvm::codegenoptions::DebugInfoKind DebugInfoKind) {

2080 switch (DebugInfoKind) {

2081 case llvm::codegenoptions::DebugDirectivesOnly:

2082 CmdArgs.push_back("-debug-info-kind=line-directives-only");

2083 break;

2084 case llvm::codegenoptions::DebugLineTablesOnly:

2085 CmdArgs.push_back("-debug-info-kind=line-tables-only");

2086 break;

2087 case llvm::codegenoptions::DebugInfoConstructor:

2088 CmdArgs.push_back("-debug-info-kind=constructor");

2089 break;

2090 case llvm::codegenoptions::LimitedDebugInfo:

2091 CmdArgs.push_back("-debug-info-kind=limited");

2092 break;

2093 case llvm::codegenoptions::FullDebugInfo:

2094 CmdArgs.push_back("-debug-info-kind=standalone");

2095 break;

2096 case llvm::codegenoptions::UnusedTypeInfo:

2097 CmdArgs.push_back("-debug-info-kind=unused-types");

2098 break;

2099 default:

2100 break;

2101 }

2102}

2103

2104

2105

2107 assert(A.getOption().matches(options::OPT_gN_Group) &&

2108 "Not a -g option that specifies a debug-info level");

2109 if (A.getOption().matches(options::OPT_g0) ||

2110 A.getOption().matches(options::OPT_ggdb0))

2111 return llvm::codegenoptions::NoDebugInfo;

2112 if (A.getOption().matches(options::OPT_gline_tables_only) ||

2113 A.getOption().matches(options::OPT_ggdb1))

2114 return llvm::codegenoptions::DebugLineTablesOnly;

2115 if (A.getOption().matches(options::OPT_gline_directives_only))

2116 return llvm::codegenoptions::DebugDirectivesOnly;

2117 return llvm::codegenoptions::DebugInfoConstructor;

2118}

2119

2121 const ArgList &Args) {

2122 const Arg *A = Args.getLastArg(options::OPT_fdebug_default_version);

2123

2124 if (!A)

2125 return 0;

2126

2127 unsigned Value = 0;

2128 if (StringRef(A->getValue()).getAsInteger(10, Value) || Value > 5 ||

2130 TC.getDriver().Diag(diag::err_drv_invalid_int_value)

2131 << A->getAsString(Args) << A->getValue();

2133}

2134

2136 return llvm::StringSwitch(ArgValue)

2137 .Case("-gdwarf-2", 2)

2138 .Case("-gdwarf-3", 3)

2139 .Case("-gdwarf-4", 4)

2140 .Case("-gdwarf-5", 5)

2141 .Default(0);

2142}

2143

2145 return Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3,

2146 options::OPT_gdwarf_4, options::OPT_gdwarf_5,

2147 options::OPT_gdwarf);

2148}

2149

2151 const llvm::opt::ArgList &Args) {

2153 if (const Arg *GDwarfN = getDwarfNArg(Args))

2155 DwarfVersion = N;

2156 if (DwarfVersion == 5 && TC.getTriple().isOSAIX())

2157 TC.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)

2158 << GDwarfN->getSpelling() << TC.getTriple().str();

2159 }

2160 if (DwarfVersion == 0) {

2162 assert(DwarfVersion && "toolchain default DWARF version must be nonzero");

2163 }

2164 return DwarfVersion;

2165}

2166

2168 ArgStringList &CmdArgs) {

2169 llvm::Reloc::Model RelocationModel;

2170 unsigned PICLevel;

2171 bool IsPIE;

2173

2174 if (RelocationModel != llvm::Reloc::Static)

2175 CmdArgs.push_back("-KPIC");

2176}

2177

2178

2179

2181 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);

2182}

2183

2185

2187 const ArgList &Args) {

2188 if (Args.hasArg(options::OPT_static_libgcc) ||

2189 Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_static_pie) ||

2190

2193 if (Args.hasArg(options::OPT_shared_libgcc))

2196}

2197

2198

2199

2200

2201

2202

2203

2204

2205

2206

2207

2208

2209

2210

2212 ArgStringList &CmdArgs, const ArgList &Args) {

2214

2216 CmdArgs.push_back("-l:libunwind.a");

2217 return;

2218 }

2219

2220

2224 return;

2225

2231 if (AsNeeded)

2233

2234 switch (UNW) {

2236 return;

2239 CmdArgs.push_back("-lgcc_eh");

2240 else

2241 CmdArgs.push_back("-lgcc_s");

2242 break;

2243 }

2246

2247

2249 CmdArgs.push_back("-lunwind");

2251 CmdArgs.push_back("-l:libunwind.a");

2253 if (TC.getTriple().isOSCygMing())

2254 CmdArgs.push_back("-l:libunwind.dll.a");

2255 else

2256 CmdArgs.push_back("-l:libunwind.so");

2257 } else {

2258

2259

2260 CmdArgs.push_back("-lunwind");

2261 }

2262 break;

2263 }

2264

2265 if (AsNeeded)

2267}

2268

2270 ArgStringList &CmdArgs, const ArgList &Args) {

2274 CmdArgs.push_back("-lgcc");

2278 CmdArgs.push_back("-lgcc");

2279}

2280

2282 ArgStringList &CmdArgs, const ArgList &Args) {

2283

2285

2286 switch (RLT) {

2290 break;

2292

2293 if (TC.getTriple().isKnownWindowsMSVCEnvironment()) {

2294

2295

2296 Arg *A = Args.getLastArg(options::OPT_rtlib_EQ);

2297 if (A && A->getValue() != StringRef("platform")) {

2298 TC.getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)

2299 << A->getValue() << "MSVC";

2300 }

2301 } else

2303 break;

2304 }

2305

2306

2307

2308

2309 if (TC.getTriple().isAndroid() && !Args.hasArg(options::OPT_static) &&

2310 !Args.hasArg(options::OPT_static_pie))

2311 CmdArgs.push_back("-ldl");

2312}

2313

2318 const Arg *A = Args.getLastArg(options::OPT_save_stats_EQ);

2319 if (!A && D.CCPrintInternalStats)

2320 return {};

2321

2323 if (A) {

2324 StringRef SaveStats = A->getValue();

2325 if (SaveStats == "obj" && Output.isFilename()) {

2327 llvm::sys::path::remove_filename(StatsFile);

2328 } else if (SaveStats != "cwd") {

2329 D.Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << SaveStats;

2330 return {};

2331 }

2332

2333 StringRef BaseName = llvm::sys::path::filename(Input.getBaseInput());

2334 llvm::sys::path::append(StatsFile, BaseName);

2335 llvm::sys::path::replace_extension(StatsFile, "stats");

2336 } else {

2337 assert(D.CCPrintInternalStats);

2338 StatsFile.assign(D.CCPrintInternalStatReportFilename.empty()

2339 ? "-"

2340 : D.CCPrintInternalStatReportFilename);

2341 }

2342 return StatsFile;

2343}

2344

2347 assert(Flag.front() == '-');

2348 if (Enabled) {

2349 Flags.push_back(Flag.str());

2350 } else {

2351 Flags.push_back(("!" + Flag.substr(1)).str());

2352 }

2353}

2354

2356 ArgStringList &CmdArgs, bool IsLTO,

2357 const StringRef PluginOptPrefix) {

2358 auto addArg = [&, IsLTO](const Twine &Arg) {

2359 if (IsLTO) {

2360 assert(!PluginOptPrefix.empty() && "Cannot have empty PluginOptPrefix!");

2361 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + Arg));

2362 } else {

2363 CmdArgs.push_back("-mllvm");

2364 CmdArgs.push_back(Args.MakeArgString(Arg));

2365 }

2366 };

2367

2368 if (Args.hasArg(options::OPT_mbranches_within_32B_boundaries)) {

2369 addArg(Twine("-x86-branches-within-32B-boundaries"));

2370 }

2371 if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_boundary_EQ)) {

2372 StringRef Value = A->getValue();

2373 unsigned Boundary;

2374 if (Value.getAsInteger(10, Boundary) || Boundary < 16 ||

2375 !llvm::isPowerOf2_64(Boundary)) {

2376 D.Diag(diag::err_drv_invalid_argument_to_option)

2377 << Value << A->getOption().getName();

2378 } else {

2379 addArg("-x86-align-branch-boundary=" + Twine(Boundary));

2380 }

2381 }

2382 if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_EQ)) {

2383 std::string AlignBranch;

2384 for (StringRef T : A->getValues()) {

2385 if (T != "fused" && T != "jcc" && T != "jmp" && T != "call" &&

2386 T != "ret" && T != "indirect")

2387 D.Diag(diag::err_drv_invalid_malign_branch_EQ)

2388 << T << "fused, jcc, jmp, call, ret, indirect";

2389 if (!AlignBranch.empty())

2390 AlignBranch += '+';

2391 AlignBranch += T;

2392 }

2393 addArg("-x86-align-branch=" + Twine(AlignBranch));

2394 }

2395 if (const Arg *A = Args.getLastArg(options::OPT_mpad_max_prefix_size_EQ)) {

2396 StringRef Value = A->getValue();

2397 unsigned PrefixSize;

2398 if (Value.getAsInteger(10, PrefixSize)) {

2399 D.Diag(diag::err_drv_invalid_argument_to_option)

2400 << Value << A->getOption().getName();

2401 } else {

2402 addArg("-x86-pad-max-prefix-size=" + Twine(PrefixSize));

2403 }

2404 }

2405}

2406

2407

2408

2409

2410

2411

2412

2413

2414

2415

2416

2417

2418

2419

2420

2421

2422

2423

2424

2425

2426

2428 llvm::opt::ArgStringList &CC1Args,

2430 StringRef Lib, StringRef Arch, StringRef Target,

2431 bool isBitCodeSDL) {

2433

2434 std::string LibDeviceLoc = "/libdevice";

2435 std::string LibBcPrefix = "/libbc-";

2436 std::string LibPrefix = "/lib";

2437

2438 if (isBitCodeSDL) {

2439

2440

2441

2442

2443

2444

2445

2446

2447

2448

2449

2450

2451

2452

2453 for (StringRef Base : {LibBcPrefix, LibPrefix}) {

2454 const auto *Ext = Base.contains(LibBcPrefix) ? ".a" : ".bc";

2455

2456 for (auto Suffix : {Twine(Lib + "-" + Arch + "-" + Target).str(),

2457 Twine(Lib + "-" + Arch).str(), Twine(Lib).str()}) {

2458 SDLs.push_back(Twine(LibDeviceLoc + Base + Suffix + Ext).str());

2459 SDLs.push_back(Twine(Base + Suffix + Ext).str());

2460 }

2461 }

2462 } else {

2463

2464

2465

2466

2467

2468

2469 const auto *Ext = ".a";

2470

2471 for (auto Suffix : {Twine(Lib + "-" + Arch + "-" + Target).str(),

2472 Twine(Lib + "-" + Arch).str()}) {

2473 SDLs.push_back(Twine(LibDeviceLoc + LibPrefix + Suffix + Ext).str());

2474 SDLs.push_back(Twine(LibPrefix + Suffix + Ext).str());

2475 }

2476 }

2477

2478

2479

2480

2481

2482

2483

2484

2485 bool FoundSDL = false;

2486 for (auto LPath : LibraryPaths) {

2487 for (auto SDL : SDLs) {

2488 auto FullName = Twine(LPath + SDL).str();

2489 if (llvm::sys::fs::exists(FullName)) {

2490 CC1Args.push_back(DriverArgs.MakeArgString(FullName));

2491 FoundSDL = true;

2492 break;

2493 }

2494 }

2495 if (FoundSDL)

2496 break;

2497 }

2498 return FoundSDL;

2499}

2500

2501

2502

2503

2504

2507 const InputInfoList &Inputs, const llvm::opt::ArgList &DriverArgs,

2508 llvm::opt::ArgStringList &CC1Args,

2510 StringRef Arch, StringRef Target, bool isBitCodeSDL) {

2511

2512

2513 if (isBitCodeSDL && Arch.contains("nvptx"))

2514 return;

2515

2516 bool FoundAOB = false;

2517 std::string ArchiveOfBundles;

2518

2519 llvm::Triple Triple(D.getTargetTriple());

2520 bool IsMSVC = Triple.isWindowsMSVCEnvironment();

2521 auto Ext = IsMSVC ? ".lib" : ".a";

2522 if (!Lib.starts_with(":") && !Lib.starts_with("-l")) {

2523 if (llvm::sys::fs::exists(Lib)) {

2524 ArchiveOfBundles = Lib;

2525 FoundAOB = true;

2526 }

2527 } else {

2528 Lib.consume_front("-l");

2529 for (auto LPath : LibraryPaths) {

2530 ArchiveOfBundles.clear();

2531 auto LibFile = (Lib.starts_with(":") ? Lib.drop_front()

2532 : IsMSVC ? Lib + Ext

2533 : "lib" + Lib + Ext)

2534 .str();

2535 for (auto Prefix : {"/libdevice/", "/"}) {

2536 auto AOB = Twine(LPath + Prefix + LibFile).str();

2537 if (llvm::sys::fs::exists(AOB)) {

2538 ArchiveOfBundles = AOB;

2539 FoundAOB = true;

2540 break;

2541 }

2542 }

2543 if (FoundAOB)

2544 break;

2545 }

2546 }

2547

2548 if (!FoundAOB)

2549 return;

2550

2551 llvm::file_magic Magic;

2552 auto EC = llvm::identify_magic(ArchiveOfBundles, Magic);

2553 if (EC || Magic != llvm::file_magic::archive)

2554 return;

2555

2556 StringRef Prefix = isBitCodeSDL ? "libbc-" : "lib";

2557 std::string OutputLib =

2558 D.GetTemporaryPath(Twine(Prefix + llvm::sys::path::filename(Lib) + "-" +

2559 Arch + "-" + Target)

2560 .str(),

2561 "a");

2562

2563 C.addTempFile(C.getArgs().MakeArgString(OutputLib));

2564

2565 ArgStringList CmdArgs;

2568 DeviceTriple += '-';

2569 std::string NormalizedTriple = T.getToolChain().getTriple().normalize();

2570 DeviceTriple += NormalizedTriple;

2571 if (Target.empty()) {

2572 DeviceTriple += '-';

2573 DeviceTriple += Target;

2574 }

2575

2576 std::string UnbundleArg("-unbundle");

2577 std::string TypeArg("-type=a");

2578 std::string InputArg("-input=" + ArchiveOfBundles);

2579 std::string OffloadArg("-targets=" + std::string(DeviceTriple));

2580 std::string OutputArg("-output=" + OutputLib);

2581

2582 const char *UBProgram = DriverArgs.MakeArgString(

2583 T.getToolChain().GetProgramPath("clang-offload-bundler"));

2584

2585 ArgStringList UBArgs;

2586 UBArgs.push_back(C.getArgs().MakeArgString(UnbundleArg));

2587 UBArgs.push_back(C.getArgs().MakeArgString(TypeArg));

2588 UBArgs.push_back(C.getArgs().MakeArgString(InputArg));

2589 UBArgs.push_back(C.getArgs().MakeArgString(OffloadArg));

2590 UBArgs.push_back(C.getArgs().MakeArgString(OutputArg));

2591

2592

2593

2594 std::string AdditionalArgs("-allow-missing-bundles");

2595 UBArgs.push_back(C.getArgs().MakeArgString(AdditionalArgs));

2596

2597

2598

2599

2600 std::string HipCompatibleArgs("-hip-openmp-compatible");

2601 UBArgs.push_back(C.getArgs().MakeArgString(HipCompatibleArgs));

2602

2603 C.addCommand(std::make_unique(

2605 InputInfo(&JA, C.getArgs().MakeArgString(OutputLib))));

2606

2607 CC1Args.push_back(DriverArgs.MakeArgString(OutputLib));

2608

2609 return;

2610}

2611

2612

2616 const llvm::opt::ArgList &DriverArgs,

2617 llvm::opt::ArgStringList &CC1Args,

2618 StringRef Arch, StringRef Target,

2619 bool isBitCodeSDL) {

2621 Arch, Target, isBitCodeSDL);

2622}

2623

2624

2625

2626

2627

2628

2629

2630

2631

2632

2633

2634

2635

2636

2637

2638

2639

2640

2641

2642

2643

2644

2645

2646

2650 const llvm::opt::ArgList &DriverArgs,

2651 llvm::opt::ArgStringList &CC1Args,

2652 StringRef Arch, StringRef Target,

2653 bool isBitCodeSDL) {

2654

2656

2657 std::optionalstd::string LibPath =

2658 llvm::sys::Process::GetEnv("LIBRARY_PATH");

2659 if (LibPath) {

2661 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};

2662 llvm::SplitString(*LibPath, Frags, EnvPathSeparatorStr);

2663 for (StringRef Path : Frags)

2664 LibraryPaths.emplace_back(Path.trim());

2665 }

2666

2667

2668 for (std::string Search_Dir : DriverArgs.getAllArgValues(options::OPT_L))

2669 LibraryPaths.emplace_back(Search_Dir);

2670

2671

2672 SmallString<256> DefaultLibPath = llvm::sys::path::parent_path(D.Dir);

2673 llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);

2674 LibraryPaths.emplace_back(DefaultLibPath.c_str());

2675

2676

2677 llvm::SmallSet<std::string, 16> SDLNames;

2678 static const StringRef HostOnlyArchives[] = {

2679 "omp", "cudart", "m", "gcc", "gcc_s", "pthread", "hip_hcc"};

2680 for (auto SDLName : DriverArgs.getAllArgValues(options::OPT_l)) {

2681 if (!llvm::is_contained(HostOnlyArchives, SDLName)) {

2682 SDLNames.insert(std::string("-l") + SDLName);

2683 }

2684 }

2685

2686 for (auto Input : DriverArgs.getAllArgValues(options::OPT_INPUT)) {

2687 auto FileName = StringRef(Input);

2688

2689

2690

2691

2692

2693 const StringRef LibFileExt = ".lib";

2694 if (!llvm::sys::path::has_extension(FileName) ||

2696 llvm::sys::path::extension(FileName).drop_front()) ==

2698 llvm::sys::path::extension(FileName) == LibFileExt)

2699 SDLNames.insert(Input);

2700 }

2701

2702

2703

2704

2705

2706 for (auto SDLName : SDLNames) {

2707

2708 if (SDLSearch(D, DriverArgs, CC1Args, LibraryPaths, SDLName, Arch, Target,

2709 isBitCodeSDL)) {

2711 LibraryPaths, SDLName, Arch, Target,

2712 isBitCodeSDL);

2713 }

2714 }

2715}

2716

2717static llvm::opt::Arg *

2719 return Args.getLastArg(options::OPT_mcode_object_version_EQ);

2720}

2721

2723 const llvm::opt::ArgList &Args) {

2724 const unsigned MinCodeObjVer = 4;

2725 const unsigned MaxCodeObjVer = 6;

2726

2728 if (CodeObjArg->getOption().getID() ==

2729 options::OPT_mcode_object_version_EQ) {

2730 unsigned CodeObjVer = MaxCodeObjVer;

2731 auto Remnant =

2732 StringRef(CodeObjArg->getValue()).getAsInteger(0, CodeObjVer);

2733 if (Remnant || CodeObjVer < MinCodeObjVer || CodeObjVer > MaxCodeObjVer)

2734 D.Diag(diag::err_drv_invalid_int_value)

2735 << CodeObjArg->getAsString(Args) << CodeObjArg->getValue();

2736

2737

2738

2739

2740 if (CodeObjVer == 6)

2741 D.Diag(diag::warn_drv_amdgpu_cov6);

2742 }

2743 }

2744}

2745

2747 const llvm::opt::ArgList &Args) {

2748 unsigned CodeObjVer = 5;

2750 StringRef(CodeObjArg->getValue()).getAsInteger(0, CodeObjVer);

2751 return CodeObjVer;

2752}

2753

2755 const Driver &D, const llvm::opt::ArgList &Args) {

2757}

2758

2760 const llvm::opt::ArgList &Args,

2761 llvm::opt::ArgStringList &CmdArgs,

2762 const llvm::Triple &Triple, bool IsLTO,

2763 const StringRef PluginOptPrefix) {

2764 auto addArg = [&, IsLTO](const Twine &Arg) {

2765 if (IsLTO) {

2766 assert(!PluginOptPrefix.empty() && "Cannot have empty PluginOptPrefix!");

2767 CmdArgs.push_back(Args.MakeArgString(Twine(PluginOptPrefix) + Arg));

2768 } else {

2769 CmdArgs.push_back("-mllvm");

2770 CmdArgs.push_back(Args.MakeArgString(Arg));

2771 }

2772 };

2773

2774 if (Arg *A = Args.getLastArg(options::OPT_moutline,

2775 options::OPT_mno_outline)) {

2776 if (A->getOption().matches(options::OPT_moutline)) {

2777

2778

2779

2780 if (!(Triple.isARM() || Triple.isThumb() || Triple.isAArch64())) {

2781 D.Diag(diag::warn_drv_moutline_unsupported_opt) << Triple.getArchName();

2782 } else {

2783 addArg(Twine("-enable-machine-outliner"));

2784 }

2785 } else {

2786

2787 addArg(Twine("-enable-machine-outliner=never"));

2788 }

2789 }

2790

2791 auto *CodeGenDataGenArg =

2792 Args.getLastArg(options::OPT_fcodegen_data_generate_EQ);

2793 auto *CodeGenDataUseArg = Args.getLastArg(options::OPT_fcodegen_data_use_EQ);

2794

2795

2796 if (CodeGenDataGenArg && CodeGenDataUseArg)

2797 D.Diag(diag::err_drv_argument_not_allowed_with)

2798 << CodeGenDataGenArg->getAsString(Args)

2799 << CodeGenDataUseArg->getAsString(Args);

2800

2801

2802

2803 if (CodeGenDataGenArg)

2804 addArg(Twine("-codegen-data-generate"));

2805

2806

2807 if (CodeGenDataUseArg)

2808 addArg(Twine("-codegen-data-use-path=") + CodeGenDataUseArg->getValue());

2809}

2810

2812 const llvm::opt::ArgList &DriverArgs,

2813 llvm::opt::ArgStringList &CC1Args,

2814 StringRef BitcodeSuffix,

2815 const llvm::Triple &Triple,

2818

2819

2820 std::optionalstd::string LibPath =

2821 llvm::sys::Process::GetEnv("LIBRARY_PATH");

2822 if (LibPath) {

2824 const char EnvPathSeparatorStr[] = {llvm::sys::EnvPathSeparator, '\0'};

2825 llvm::SplitString(*LibPath, Frags, EnvPathSeparatorStr);

2826 for (StringRef Path : Frags)

2827 LibraryPaths.emplace_back(Path.trim());

2828 }

2829

2830

2831 for (const auto &LibPath : HostTC.getFilePaths())

2832 LibraryPaths.emplace_back(LibPath);

2833

2834 OptSpecifier LibomptargetBCPathOpt =

2835 Triple.isAMDGCN() ? options::OPT_libomptarget_amdgpu_bc_path_EQ

2836 : Triple.isNVPTX() ? options::OPT_libomptarget_nvptx_bc_path_EQ

2837 : options::OPT_libomptarget_spirv_bc_path_EQ;

2838

2839 StringRef ArchPrefix = Triple.isAMDGCN() ? "amdgpu"

2840 : Triple.isNVPTX() ? "nvptx"

2841 : "spirv64";

2842 std::string LibOmpTargetName = ("libomptarget-" + ArchPrefix + ".bc").str();

2843

2844

2845 if (const Arg *A = DriverArgs.getLastArg(LibomptargetBCPathOpt)) {

2847 if (llvm::sys::fs::exists(LibOmpTargetFile) &&

2848 llvm::sys::fs::is_directory(LibOmpTargetFile)) {

2849 llvm::sys::path::append(LibOmpTargetFile, LibOmpTargetName);

2850 }

2851

2852 if (llvm::sys::fs::exists(LibOmpTargetFile)) {

2853 CC1Args.push_back("-mlink-builtin-bitcode");

2854 CC1Args.push_back(DriverArgs.MakeArgString(LibOmpTargetFile));

2855 } else {

2856 D.Diag(diag::err_drv_omp_offload_target_bcruntime_not_found)

2857 << LibOmpTargetFile;

2858 }

2859 } else {

2860 bool FoundBCLibrary = false;

2861

2862 for (StringRef LibraryPath : LibraryPaths) {

2864 llvm::sys::path::append(LibOmpTargetFile, LibOmpTargetName);

2865 if (llvm::sys::fs::exists(LibOmpTargetFile)) {

2866 CC1Args.push_back("-mlink-builtin-bitcode");

2867 CC1Args.push_back(DriverArgs.MakeArgString(LibOmpTargetFile));

2868 FoundBCLibrary = true;

2869 break;

2870 }

2871 }

2872

2873 if (!FoundBCLibrary)

2874 D.Diag(diag::err_drv_omp_offload_target_missingbcruntime)

2875 << LibOmpTargetName << ArchPrefix;

2876 }

2877}

2879 const llvm::opt::ArgList &Args,

2880 llvm::opt::ArgStringList &CmdArgs) {

2882 !Args.hasArg(options::OPT_nostdlib) &&

2883 !Args.hasArg(options::OPT_no_hip_rt) && !Args.hasArg(options::OPT_r)) {

2885 } else {

2886

2887 for (auto *Arg : Args.filtered(options::OPT_no_hip_rt)) {

2888 Arg->claim();

2889 }

2890 }

2891}

2892

2894 const llvm::opt::ArgList &Args,

2895 llvm::opt::ArgStringList &CmdArgs,

2896 const llvm::Triple &Triple) {

2897 if (Arg *A = Args.getLastArg(options::OPT_moutline_atomics,

2898 options::OPT_mno_outline_atomics)) {

2899

2900 if (!Triple.isAArch64()) {

2901 D.Diag(diag::warn_drv_moutline_atomics_unsupported_opt)

2902 << Triple.getArchName() << A->getOption().getName();

2903 } else {

2904 if (A->getOption().matches(options::OPT_moutline_atomics)) {

2905 CmdArgs.push_back("-target-feature");

2906 CmdArgs.push_back("+outline-atomics");

2907 } else {

2908 CmdArgs.push_back("-target-feature");

2909 CmdArgs.push_back("-outline-atomics");

2910 }

2911 }

2913 CmdArgs.push_back("-target-feature");

2914 CmdArgs.push_back("+outline-atomics");

2915 }

2916}

2917

2919 llvm::opt::ArgStringList &CmdArgs) {

2920 if (TCArgs.hasFlag(options::OPT_offload_compress,

2921 options::OPT_no_offload_compress, false))

2922 CmdArgs.push_back("-compress");

2923 if (TCArgs.hasArg(options::OPT_v))

2924 CmdArgs.push_back("-verbose");

2925 if (auto *Arg = TCArgs.getLastArg(options::OPT_offload_compression_level_EQ))

2926 CmdArgs.push_back(

2927 TCArgs.MakeArgString(Twine("-compression-level=") + Arg->getValue()));

2928}

2929

2931 const llvm::Triple &Triple,

2932 const llvm::Reloc::Model &RelocationModel,

2933 llvm::opt::ArgStringList &CmdArgs) {

2934 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {

2935 StringRef CM = A->getValue();

2936 bool Ok = false;

2937 if (Triple.isOSAIX() && CM == "medium")

2938 CM = "large";

2939 if (Triple.isAArch64(64)) {

2940 Ok = CM == "tiny" || CM == "small" || CM == "large";

2941 if (CM == "large" && !Triple.isOSBinFormatMachO() &&

2942 RelocationModel != llvm::Reloc::Static)

2943 D.Diag(diag::err_drv_argument_only_allowed_with)

2944 << A->getAsString(Args) << "-fno-pic";

2945 } else if (Triple.isLoongArch()) {

2946 if (CM == "extreme" &&

2947 Args.hasFlagNoClaim(options::OPT_fplt, options::OPT_fno_plt, false))

2948 D.Diag(diag::err_drv_argument_not_allowed_with)

2949 << A->getAsString(Args) << "-fplt";

2950 Ok = CM == "normal" || CM == "medium" || CM == "extreme";

2951

2952 if (Ok)

2953 CM = llvm::StringSwitch(CM)

2954 .Case("normal", "small")

2955 .Case("extreme", "large")

2956 .Default(CM);

2957 } else if (Triple.isPPC64() || Triple.isOSAIX()) {

2958 Ok = CM == "small" || CM == "medium" || CM == "large";

2959 } else if (Triple.isRISCV()) {

2960

2961 if (CM == "large" && RelocationModel != llvm::Reloc::Static)

2962 D.Diag(diag::err_drv_argument_not_allowed_with)

2963 << A->getAsString(Args) << "-fpic";

2964 if (CM == "medlow")

2965 CM = "small";

2966 else if (CM == "medany")

2967 CM = "medium";

2968 Ok = CM == "small" || CM == "medium" ||

2969 (CM == "large" && Triple.isRISCV64());

2970 } else if (Triple.getArch() == llvm::Triple::x86_64) {

2971 Ok = llvm::is_contained({"small", "kernel", "medium", "large", "tiny"},

2972 CM);

2973 } else if (Triple.isNVPTX() || Triple.isAMDGPU() || Triple.isSPIRV()) {

2974

2975

2976 Ok = true;

2977 } else if (Triple.isSPARC64()) {

2978 if (CM == "medlow")

2979 CM = "small";

2980 else if (CM == "medmid")

2981 CM = "medium";

2982 else if (CM == "medany")

2983 CM = "large";

2984 Ok = CM == "small" || CM == "medium" || CM == "large";

2985 }

2986 if (Ok) {

2987 CmdArgs.push_back(Args.MakeArgString("-mcmodel=" + CM));

2988 } else {

2989 D.Diag(diag::err_drv_unsupported_option_argument_for_target)

2990 << A->getSpelling() << CM << Triple.getTriple();

2991 }

2992 }

2993

2994 if (Triple.getArch() == llvm::Triple::x86_64) {

2995 bool IsMediumCM = false;

2996 bool IsLargeCM = false;

2997 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) {

2998 IsMediumCM = StringRef(A->getValue()) == "medium";

2999 IsLargeCM = StringRef(A->getValue()) == "large";

3000 }

3001 if (Arg *A = Args.getLastArg(options::OPT_mlarge_data_threshold_EQ)) {

3002 if (!IsMediumCM && !IsLargeCM) {

3003 D.Diag(diag::warn_drv_large_data_threshold_invalid_code_model)

3004 << A->getOption().getRenderName();

3005 } else {

3006 A->render(Args, CmdArgs);

3007 }

3008 } else if (IsMediumCM) {

3009 CmdArgs.push_back("-mlarge-data-threshold=65536");

3010 } else if (IsLargeCM) {

3011 CmdArgs.push_back("-mlarge-data-threshold=0");

3012 }

3013 }

3014}

3015

3017 ArgStringList &CmdArgs) {

3018

3019

3020

3021

3022 Args.getLastArg(options::OPT_fcolor_diagnostics,

3023 options::OPT_fno_color_diagnostics);

3024 if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_color_EQ)) {

3025 StringRef Value(A->getValue());

3026 if (Value != "always" && Value != "never" && Value != "auto")

3027 D.Diag(diag::err_drv_invalid_argument_to_option)

3028 << Value << A->getOption().getName();

3029 }

3030

3031 if (D.getDiags().getDiagnosticOptions().ShowColors)

3032 CmdArgs.push_back("-fcolor-diagnostics");

3033}

3034

3037 for (; *Arg; ++Arg) {

3038 switch (*Arg) {

3039 default:

3040 break;

3041 case ' ':

3042 case '\\':

3043 Res.push_back('\\');

3044 break;

3045 }

3046 Res.push_back(*Arg);

3047 }

3048}

3049

3051 const llvm::opt::ArgList &Args) {

3053 const char *Exec = D.getClangProgramPath();

3054

3055 llvm::opt::ArgStringList OriginalArgs;

3056 for (const auto &Arg : Args)

3057 Arg->render(Args, OriginalArgs);

3058

3061 for (const char *OriginalArg : OriginalArgs) {

3064 Flags += " ";

3065 Flags += EscapedArg;

3066 }

3067

3068 return Args.MakeArgString(Flags);

3069}

3070

3072 const llvm::opt::ArgList &Args,

3073 bool &FRecordCommandLine,

3074 bool &GRecordCommandLine) {

3077 const std::string &TripleStr = Triple.getTriple();

3078

3079 FRecordCommandLine =

3080 Args.hasFlag(options::OPT_frecord_command_line,

3081 options::OPT_fno_record_command_line, false);

3082 GRecordCommandLine =

3083 Args.hasFlag(options::OPT_grecord_command_line,

3084 options::OPT_gno_record_command_line, false);

3085 if (FRecordCommandLine && !Triple.isOSBinFormatELF() &&

3086 !Triple.isOSBinFormatXCOFF() && !Triple.isOSBinFormatMachO())

3087 D.Diag(diag::err_drv_unsupported_opt_for_target)

3088 << Args.getLastArg(options::OPT_frecord_command_line)->getAsString(Args)

3089 << TripleStr;

3090

3091 return FRecordCommandLine || TC.UseDwarfDebugFlags() || GRecordCommandLine;

3092}

3093

3095 ArgStringList &CmdArgs) {

3096

3097

3098 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) {

3099 if (A->getOption().matches(options::OPT_fwrapv))

3100 CmdArgs.push_back("-fwrapv");

3101 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow,

3102 options::OPT_fno_strict_overflow)) {

3103 if (A->getOption().matches(options::OPT_fno_strict_overflow))

3104 CmdArgs.push_back("-fwrapv");

3105 }

3106}

static bool useLeafFramePointerForTargetByDefault(const llvm::Triple &Triple)

static unsigned ParseDebugDefaultVersion(const ToolChain &TC, const ArgList &Args)

static void getWebAssemblyTargetFeatures(const Driver &D, const llvm::Triple &Triple, const ArgList &Args, std::vector< StringRef > &Features)

static bool addSanitizerDynamicList(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, StringRef Sanitizer)

static bool mustMaintainValidFrameChain(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)

static llvm::opt::Arg * getAMDGPUCodeObjectArgument(const Driver &D, const llvm::opt::ArgList &Args)

static void collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args, SmallVectorImpl< StringRef > &SharedRuntimes, SmallVectorImpl< StringRef > &StaticRuntimes, SmallVectorImpl< StringRef > &NonWholeStaticRuntimes, SmallVectorImpl< StringRef > &HelperStaticRuntimes, SmallVectorImpl< StringRef > &RequiredSymbols)

static void addSanitizerRuntime(const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, StringRef Sanitizer, bool IsShared, bool IsWhole)

static void AddUnwindLibrary(const ToolChain &TC, const Driver &D, ArgStringList &CmdArgs, const ArgList &Args)

static bool SDLSearch(const Driver &D, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const SmallVectorImpl< std::string > &LibraryPaths, StringRef Lib, StringRef Arch, StringRef Target, bool isBitCodeSDL)

SDLSearch: Search for Static Device Library The search for SDL bitcode files is consistent with how s...

static void renderRpassOptions(const ArgList &Args, ArgStringList &CmdArgs, const StringRef PluginOptPrefix)

static StringRef getWebAssemblyTargetCPU(const ArgList &Args)

Get the (LLVM) name of the WebAssembly cpu we are targeting.

static bool framePointerImpliesLeafFramePointer(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)

static void renderRemarksHotnessOptions(const ArgList &Args, ArgStringList &CmdArgs, const StringRef PluginOptPrefix)

static void GetSDLFromOffloadArchive(Compilation &C, const Driver &D, const Tool &T, const JobAction &JA, const InputInfoList &Inputs, const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const SmallVectorImpl< std::string > &LibraryPaths, StringRef Lib, StringRef Arch, StringRef Target, bool isBitCodeSDL)

Search if a user provided archive file lib.a exists in any of the library paths.

static std::string getLanaiTargetCPU(const ArgList &Args)

static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input, const InputInfo &Output, const StringRef PluginOptPrefix)

static bool useFramePointerForTargetByDefault(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)

static void AddLibgcc(const ToolChain &TC, const Driver &D, ArgStringList &CmdArgs, const ArgList &Args)

static LibGccType getLibGccType(const ToolChain &TC, const Driver &D, const ArgList &Args)

clang::CodeGenOptions::FramePointerKind getFramePointerKind(const llvm::opt::ArgList &Args, const llvm::Triple &Triple)

static std::string getAMDGPUTargetGPU(const llvm::Triple &T, const ArgList &Args)

Get the (LLVM) name of the AMDGPU gpu we are targeting.

static bool mustUseNonLeafFramePointerForTarget(const llvm::Triple &Triple)

static bool shouldIgnoreUnsupportedTargetFeature(const Arg &TargetFeatureArg, llvm::Triple T, StringRef Processor)

Defines the clang::LangOptions interface.

llvm::MachO::Target Target

Defines types useful for describing an Objective-C runtime.

Defines version macros and version-related utility functions for Clang.

const char * getOffloadingArch() const

static StringRef GetOffloadKindName(OffloadKind Kind)

Return a string containing a offload kind name.

OffloadKind getOffloadingDeviceKind() const

bool isHostOffloading(unsigned int OKind) const

Check if this action have any offload kinds.

Compilation - A set of tasks to perform for a single driver invocation.

Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...

OpenMPRuntimeKind getOpenMPRuntime(const llvm::opt::ArgList &Args) const

Compute the desired OpenMP runtime from the flags provided.

DiagnosticBuilder Diag(unsigned DiagID) const

StringRef getFlangF128MathLibrary() const

std::string Dir

The path the driver executable was in, as invoked from the command line.

@ OMPRT_IOMP5

The legacy name for the LLVM OpenMP runtime from when it was the Intel OpenMP runtime.

@ OMPRT_OMP

The LLVM OpenMP runtime.

@ OMPRT_Unknown

An unknown OpenMP runtime.

@ OMPRT_GOMP

The GNU OpenMP runtime.

InputInfo - Wrapper for information about an input source.

const char * getBaseInput() const

const char * getFilename() const

std::vector< std::string > flags_list

bool needsFuzzerInterceptors() const

bool needsHwasanAliasesRt() const

bool needsStatsRt() const

bool needsMemProfRt() const

bool needsCfiDiagRt() const

bool linkRuntimes() const

bool needsUbsanRt() const

bool needsHwasanRt() const

bool hasCrossDsoCfi() const

bool hasMemtagHeap() const

bool needsSafeStackRt() const

bool needsRtsanRt() const

bool requiresMinimalRuntime() const

bool hasMemtagStack() const

bool needsDfsanRt() const

bool needsScudoRt() const

bool needsUbsanCXXRt() const

const std::string & getMemtagMode() const

bool needsSharedRt() const

bool needsTysanRt() const

bool linkCXXRuntimes() const

bool needsXRayDSORt() const

llvm::ArrayRef< std::string > modeList() const

bool isLLVMIR(ID Id)

Is this LLVM IR.

ID lookupTypeForExtension(llvm::StringRef Ext)

lookupTypeForExtension - Lookup the type to use for the file extension Ext.

bool willEmitRemarks(const llvm::opt::ArgList &Args)

The JSON file list parser is used to communicate input to InstallAPI.

llvm::StringRef getProcessorFromTargetID(const llvm::Triple &T, llvm::StringRef OffloadArch)

Get processor name from target ID.

const FunctionProtoType * T

static constexpr ResponseFileSupport AtFileCurCP()