15#include "clang/Config/config.h"
21#include "llvm/ADT/StringSwitch.h"
22#include "llvm/Option/ArgList.h"
23#include "llvm/ProfileData/InstrProf.h"
24#include "llvm/Support/Path.h"
25#include "llvm/Support/ScopedPrinter.h"
26#include "llvm/Support/Threading.h"
27#include "llvm/Support/VirtualFileSystem.h"
28#include "llvm/TargetParser/TargetParser.h"
29#include "llvm/TargetParser/Triple.h"
39 return VersionTuple(13, 1);
55 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
56 .Cases(
"i386",
"i486",
"i486SX",
"i586",
"i686", llvm::Triple::x86)
57 .Cases(
"pentium",
"pentpro",
"pentIIm3",
"pentIIm5",
"pentium4",
59 .Cases(
"x86_64",
"x86_64h", llvm::Triple::x86_64)
61 .Cases(
"arm",
"armv4t",
"armv5",
"armv6",
"armv6m", llvm::Triple::arm)
62 .Cases(
"armv7",
"armv7em",
"armv7k",
"armv7m", llvm::Triple::arm)
63 .Cases(
"armv7s",
"xscale", llvm::Triple::arm)
64 .Cases(
"arm64",
"arm64e", llvm::Triple::aarch64)
65 .Case(
"arm64_32", llvm::Triple::aarch64_32)
66 .Case(
"r600", llvm::Triple::r600)
67 .Case(
"amdgcn", llvm::Triple::amdgcn)
68 .Case(
"nvptx", llvm::Triple::nvptx)
69 .Case(
"nvptx64", llvm::Triple::nvptx64)
70 .Case(
"amdil", llvm::Triple::amdil)
71 .Case(
"spir", llvm::Triple::spir)
72 .Default(llvm::Triple::UnknownArch);
76 const ArgList &Args) {
77 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
78 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseArch(Str);
80 if (Arch != llvm::Triple::UnknownArch)
83 if (ArchKind == llvm::ARM::ArchKind::ARMV6M ||
84 ArchKind == llvm::ARM::ArchKind::ARMV7M ||
85 ArchKind == llvm::ARM::ArchKind::ARMV7EM) {
87 if (T.getOS() == llvm::Triple::IOS)
88 for (Arg *A : Args.filtered(options::OPT_mios_version_min_EQ))
89 A->ignoreTargetSpecific();
90 if (T.getOS() == llvm::Triple::WatchOS)
91 for (Arg *A : Args.filtered(options::OPT_mwatchos_version_min_EQ))
92 A->ignoreTargetSpecific();
93 if (T.getOS() == llvm::Triple::TvOS)
94 for (Arg *A : Args.filtered(options::OPT_mtvos_version_min_EQ))
95 A->ignoreTargetSpecific();
97 T.setOS(llvm::Triple::UnknownOS);
98 T.setObjectFormat(llvm::Triple::MachO);
106 const char *LinkingOutput)
const {
109 ArgStringList CmdArgs;
111 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
115 const Action *SourceAction = &JA;
117 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
118 SourceAction = SourceAction->
getInputs()[0];
126 if (Args.hasArg(options::OPT_fno_integrated_as)) {
127 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
128 CmdArgs.push_back(
"-Q");
132 if (SourceAction->
getType() == types::TY_Asm ||
133 SourceAction->
getType() == types::TY_PP_Asm) {
134 if (Args.hasArg(options::OPT_gstabs))
135 CmdArgs.push_back(
"--gstabs");
136 else if (Args.hasArg(options::OPT_g_Group))
137 CmdArgs.push_back(
"-g");
144 if (T.isX86() || Args.hasArg(options::OPT_force__cpusubtype__ALL))
145 CmdArgs.push_back(
"-force_cpusubtype_ALL");
148 (((Args.hasArg(options::OPT_mkernel) ||
149 Args.hasArg(options::OPT_fapple_kext)) &&
151 Args.hasArg(options::OPT_static)))
152 CmdArgs.push_back(
"-static");
154 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
156 assert(Output.
isFilename() &&
"Unexpected lipo output.");
157 CmdArgs.push_back(
"-o");
160 assert(Input.
isFilename() &&
"Invalid input.");
165 const char *Exec = Args.MakeArgString(
getToolChain().GetProgramPath(
"as"));
167 Exec, CmdArgs, Inputs, Output));
170void darwin::MachOTool::anchor() {}
173 ArgStringList &CmdArgs)
const {
174 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
177 CmdArgs.push_back(
"-arch");
178 CmdArgs.push_back(Args.MakeArgString(ArchName));
181 if (ArchName ==
"arm")
182 CmdArgs.push_back(
"-force_cpusubtype_ALL");
185bool darwin::Linker::NeedsTempPath(
const InputInfoList &Inputs)
const {
189 for (
const auto &Input : Inputs)
190 if (Input.getType() != types::TY_Object)
204 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
205 if (A->getOption().matches(options::OPT_O0))
207 if (A->getOption().matches(options::OPT_O))
208 return llvm::StringSwitch<bool>(A->getValue())
214 if (!IsLinkerOnlyAction)
219void darwin::Linker::AddLinkArgs(
Compilation &
C,
const ArgList &Args,
220 ArgStringList &CmdArgs,
222 VersionTuple Version,
bool LinkerIsLLD)
const {
223 const Driver &D = getToolChain().getDriver();
228 if ((Version >= VersionTuple(100) || LinkerIsLLD) &&
229 !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
230 CmdArgs.push_back(
"-demangle");
232 if (Args.hasArg(options::OPT_rdynamic) &&
233 (Version >= VersionTuple(137) || LinkerIsLLD))
234 CmdArgs.push_back(
"-export_dynamic");
238 if (Args.hasFlag(options::OPT_fapplication_extension,
239 options::OPT_fno_application_extension,
false))
240 CmdArgs.push_back(
"-application_extension");
242 if (D.
isUsingLTO() && (Version >= VersionTuple(116) || LinkerIsLLD) &&
243 NeedsTempPath(Inputs)) {
244 std::string TmpPathName;
255 if (!TmpPathName.empty()) {
256 auto *TmpPath =
C.getArgs().MakeArgString(TmpPathName);
257 C.addTempFile(TmpPath);
258 CmdArgs.push_back(
"-object_path_lto");
259 CmdArgs.push_back(TmpPath);
272 if (Version >= VersionTuple(133) && !LinkerIsLLD) {
274 StringRef
P = llvm::sys::path::parent_path(D.
Dir);
276 llvm::sys::path::append(LibLTOPath,
"lib");
277 llvm::sys::path::append(LibLTOPath,
"libLTO.dylib");
278 CmdArgs.push_back(
"-lto_library");
279 CmdArgs.push_back(
C.getArgs().MakeArgString(LibLTOPath));
285 if (Version >= VersionTuple(262) &&
287 CmdArgs.push_back(
"-no_deduplicate");
290 Args.AddAllArgs(CmdArgs, options::OPT_static);
291 if (!Args.hasArg(options::OPT_static))
292 CmdArgs.push_back(
"-dynamic");
293 if (Args.hasArg(options::OPT_fgnu_runtime)) {
298 if (!Args.hasArg(options::OPT_dynamiclib)) {
299 AddMachOArch(Args, CmdArgs);
301 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
303 Args.AddLastArg(CmdArgs, options::OPT_bundle);
304 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
305 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
308 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
309 (A = Args.getLastArg(options::OPT_current__version)) ||
310 (A = Args.getLastArg(options::OPT_install__name)))
311 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
314 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
315 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
316 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
318 CmdArgs.push_back(
"-dylib");
321 if ((A = Args.getLastArg(options::OPT_bundle)) ||
322 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
323 (A = Args.getLastArg(options::OPT_client__name)) ||
324 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
325 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
326 (A = Args.getLastArg(options::OPT_private__bundle)))
327 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
330 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
331 "-dylib_compatibility_version");
332 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
333 "-dylib_current_version");
335 AddMachOArch(Args, CmdArgs);
337 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
338 "-dylib_install_name");
341 Args.AddLastArg(CmdArgs, options::OPT_all__load);
342 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
343 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
345 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
346 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
347 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
348 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
349 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
350 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
351 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
352 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
353 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
354 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
355 Args.AddAllArgs(CmdArgs, options::OPT_init);
358 if (Version >= VersionTuple(520) || LinkerIsLLD)
363 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
364 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
365 Args.AddLastArg(CmdArgs, options::OPT_single__module);
366 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
367 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
370 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
371 options::OPT_fno_pie, options::OPT_fno_PIE)) {
372 if (A->getOption().matches(options::OPT_fpie) ||
373 A->getOption().matches(options::OPT_fPIE))
374 CmdArgs.push_back(
"-pie");
376 CmdArgs.push_back(
"-no_pie");
380 if (
C.getDriver().embedBitcodeEnabled()) {
383 CmdArgs.push_back(
"-bitcode_bundle");
385 if (
C.getDriver().embedBitcodeMarkerOnly() &&
386 Version >= VersionTuple(278)) {
387 CmdArgs.push_back(
"-bitcode_process_mode");
388 CmdArgs.push_back(
"marker");
391 D.
Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
395 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
396 options::OPT_fno_global_isel)) {
397 if (A->getOption().matches(options::OPT_fglobal_isel)) {
398 CmdArgs.push_back(
"-mllvm");
399 CmdArgs.push_back(
"-global-isel");
401 CmdArgs.push_back(
"-mllvm");
402 CmdArgs.push_back(
"-global-isel-abort=0");
406 if (Args.hasArg(options::OPT_mkernel) ||
407 Args.hasArg(options::OPT_fapple_kext) ||
408 Args.hasArg(options::OPT_ffreestanding)) {
409 CmdArgs.push_back(
"-mllvm");
410 CmdArgs.push_back(
"-disable-atexit-based-global-dtor-lowering");
413 Args.AddLastArg(CmdArgs, options::OPT_prebind);
414 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
415 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
416 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
417 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
418 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
419 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
420 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
421 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
422 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
423 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
424 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
425 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
426 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
427 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
428 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
432 StringRef sysroot =
C.getSysRoot();
434 CmdArgs.push_back(
"-syslibroot");
435 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
436 }
else if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
437 CmdArgs.push_back(
"-syslibroot");
438 CmdArgs.push_back(A->getValue());
441 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
442 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
443 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
444 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
445 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
446 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
447 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
448 Args.AddAllArgs(CmdArgs, options::OPT_y);
449 Args.AddLastArg(CmdArgs, options::OPT_w);
450 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
451 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
452 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
453 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
454 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
455 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
456 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
457 Args.AddLastArg(CmdArgs, options::OPT_why_load);
458 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
459 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
460 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
461 Args.AddLastArg(CmdArgs, options::OPT_Mach);
467 : CSPGOGenerateArg->getValue());
468 llvm::sys::path::append(Path,
"default_%m.profraw");
469 CmdArgs.push_back(
"--cs-profile-generate");
470 CmdArgs.push_back(Args.MakeArgString(Twine(
"--cs-profile-path=") + Path));
473 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
474 if (Path.empty() || llvm::sys::fs::is_directory(Path))
475 llvm::sys::path::append(Path,
"default.profdata");
476 CmdArgs.push_back(Args.MakeArgString(Twine(
"--cs-profile-path=") + Path));
484 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
487 return Args.hasArg(options::OPT_fobjc_link_runtime);
491 const llvm::Triple &Triple) {
496 Args.getAllArgValues(options::OPT_arch).size() > 1;
497 bool hasExplicitOutputFile =
498 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
500 D.
Diag(diag::err_drv_invalid_output_with_multiple_archs)
501 <<
"-foptimization-record-file";
508 const llvm::Triple &Triple,
510 StringRef Format =
"yaml";
511 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
512 Format = A->getValue();
514 CmdArgs.push_back(
"-mllvm");
515 CmdArgs.push_back(
"-lto-pass-remarks-output");
516 CmdArgs.push_back(
"-mllvm");
518 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
520 CmdArgs.push_back(A->getValue());
522 assert(Output.
isFilename() &&
"Unexpected ld output.");
528 CmdArgs.push_back(Args.MakeArgString(F));
532 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
533 CmdArgs.push_back(
"-mllvm");
535 std::string(
"-lto-pass-remarks-filter=") + A->getValue();
536 CmdArgs.push_back(Args.MakeArgString(Passes));
539 if (!Format.empty()) {
540 CmdArgs.push_back(
"-mllvm");
541 Twine FormatArg = Twine(
"-lto-pass-remarks-format=") + Format;
542 CmdArgs.push_back(Args.MakeArgString(FormatArg));
546 CmdArgs.push_back(
"-mllvm");
547 CmdArgs.push_back(
"-lto-pass-remarks-with-hotness");
550 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
551 CmdArgs.push_back(
"-mllvm");
553 std::string(
"-lto-pass-remarks-hotness-threshold=") + A->getValue();
554 CmdArgs.push_back(Args.MakeArgString(Opt));
565 const char *LinkingOutput)
const {
566 assert(Output.
getType() == types::TY_Image &&
"Invalid linker output type.");
572 llvm::opt::ArgStringList InputFileList;
577 ArgStringList CmdArgs;
580 if (Args.hasArg(options::OPT_ccc_arcmt_check,
581 options::OPT_ccc_arcmt_migrate)) {
582 for (
const auto &Arg : Args)
585 Args.MakeArgString(getToolChain().GetProgramPath(
"touch"));
587 C.addCommand(std::make_unique<Command>(JA, *
this,
589 CmdArgs, std::nullopt, Output));
593 VersionTuple Version = getMachOToolChain().getLinkerVersion(Args);
597 Args.MakeArgString(getToolChain().GetLinkerPath(&LinkerIsLLD));
601 AddLinkArgs(
C, Args, CmdArgs, Inputs, Version, LinkerIsLLD);
605 getToolChain().getTriple()))
610 Args.getLastArg(options::OPT_moutline, options::OPT_mno_outline)) {
611 if (A->getOption().matches(options::OPT_moutline)) {
612 if (getMachOToolChain().getMachOArchName(Args) ==
"arm64") {
613 CmdArgs.push_back(
"-mllvm");
614 CmdArgs.push_back(
"-enable-machine-outliner");
620 CmdArgs.push_back(
"-mllvm");
621 CmdArgs.push_back(
"-enable-machine-outliner=never");
628 CmdArgs.push_back(
"-mllvm");
629 CmdArgs.push_back(
"-enable-linkonceodr-outlining");
634 if (!StatsFile.empty()) {
635 CmdArgs.push_back(
"-mllvm");
636 CmdArgs.push_back(Args.MakeArgString(
"-lto-stats-file=" + StatsFile.str()));
641 Args.AddAllArgs(CmdArgs,
642 {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
643 options::OPT_Z_Flag, options::OPT_u_Group, options::OPT_r});
648 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
649 CmdArgs.push_back(
"-ObjC");
651 CmdArgs.push_back(
"-o");
654 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
655 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
657 Args.AddAllArgs(CmdArgs, options::OPT_L);
662 for (
const auto &II : Inputs) {
663 if (!II.isFilename()) {
668 if (InputFileList.size() > 0)
674 InputFileList.push_back(II.getFilename());
679 if (getToolChain().getDriver().IsFlangMode()) {
684 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
688 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
690 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
692 CmdArgs.push_back(
"-framework");
693 CmdArgs.push_back(
"Foundation");
695 CmdArgs.push_back(
"-lobjc");
699 CmdArgs.push_back(
"-arch_multiple");
700 CmdArgs.push_back(
"-final_output");
701 CmdArgs.push_back(LinkingOutput);
704 if (Args.hasArg(options::OPT_fnested_functions))
705 CmdArgs.push_back(
"-allow_stack_execute");
707 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
710 if (!Parallelism.empty()) {
711 CmdArgs.push_back(
"-mllvm");
712 unsigned NumThreads =
713 llvm::get_threadpool_strategy(Parallelism)->compute_thread_count();
714 CmdArgs.push_back(Args.MakeArgString(
"-threads=" + Twine(NumThreads)));
717 if (getToolChain().ShouldLinkCXXStdlib(Args))
718 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
720 bool NoStdOrDefaultLibs =
721 Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs);
722 bool ForceLinkBuiltins = Args.hasArg(options::OPT_fapple_link_rtlib);
723 if (!NoStdOrDefaultLibs || ForceLinkBuiltins) {
728 if (NoStdOrDefaultLibs && ForceLinkBuiltins) {
729 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
"builtins");
732 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs,
736 Args.ClaimAllArgs(options::OPT_pthread);
737 Args.ClaimAllArgs(options::OPT_pthreads);
741 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
745 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
746 Args.AddAllArgs(CmdArgs, options::OPT_F);
749 for (
const Arg *A : Args.filtered(options::OPT_iframework))
750 CmdArgs.push_back(Args.MakeArgString(std::string(
"-F") + A->getValue()));
752 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
753 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
754 if (A->getValue() == StringRef(
"Accelerate")) {
755 CmdArgs.push_back(
"-framework");
756 CmdArgs.push_back(
"Accelerate");
765 bool NonStandardSearchPath =
false;
766 const auto &Triple = getToolChain().getTriple();
767 if (Triple.isDriverKit()) {
769 NonStandardSearchPath =
770 Version.getMajor() < 605 ||
771 (Version.getMajor() == 605 && Version.getMinor().value_or(0) < 1);
774 if (NonStandardSearchPath) {
775 if (
auto *Sysroot = Args.getLastArg(options::OPT_isysroot)) {
776 auto AddSearchPath = [&](StringRef Flag, StringRef SearchPath) {
779 llvm::sys::path::append(
P, SearchPath);
780 if (getToolChain().getVFS().exists(
P)) {
781 CmdArgs.push_back(Args.MakeArgString(Flag +
P));
784 AddSearchPath(
"-L",
"/usr/lib");
785 AddSearchPath(
"-F",
"/System/Library/Frameworks");
791 if (Version >= VersionTuple(705) || LinkerIsLLD) {
799 std::unique_ptr<Command>
Cmd = std::make_unique<Command>(
800 JA, *
this, ResponseSupport, Exec, CmdArgs, Inputs, Output);
801 Cmd->setInputFileList(std::move(InputFileList));
802 C.addCommand(std::move(
Cmd));
809 const char *LinkingOutput)
const {
810 const Driver &D = getToolChain().getDriver();
813 Args.ClaimAllArgs(options::OPT_g_Group);
815 Args.ClaimAllArgs(options::OPT_emit_llvm);
818 Args.ClaimAllArgs(options::OPT_w);
820 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
823 ArgStringList CmdArgs;
825 CmdArgs.push_back(
"-static");
826 CmdArgs.push_back(
"-D");
827 CmdArgs.push_back(
"-no_warning_for_no_symbols");
828 CmdArgs.push_back(
"-o");
831 for (
const auto &II : Inputs) {
832 if (II.isFilename()) {
833 CmdArgs.push_back(II.getFilename());
840 if (Output.
isFilename() && llvm::sys::fs::exists(OutputFileName)) {
841 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
842 D.
Diag(diag::err_drv_unable_to_remove_file) << EC.message();
847 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
848 C.addCommand(std::make_unique<Command>(JA, *
this,
850 Exec, CmdArgs, Inputs, Output));
857 const char *LinkingOutput)
const {
858 ArgStringList CmdArgs;
860 CmdArgs.push_back(
"-create");
861 assert(Output.
isFilename() &&
"Unexpected lipo output.");
863 CmdArgs.push_back(
"-output");
866 for (
const auto &II : Inputs) {
867 assert(II.isFilename() &&
"Unexpected lipo input.");
868 CmdArgs.push_back(II.getFilename());
871 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"lipo"));
873 Exec, CmdArgs, Inputs, Output));
880 const char *LinkingOutput)
const {
881 ArgStringList CmdArgs;
883 CmdArgs.push_back(
"-o");
886 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
888 assert(Input.
isFilename() &&
"Unexpected dsymutil input.");
892 Args.MakeArgString(getToolChain().GetProgramPath(
"dsymutil"));
894 Exec, CmdArgs, Inputs, Output));
901 const char *LinkingOutput)
const {
902 ArgStringList CmdArgs;
903 CmdArgs.push_back(
"--verify");
904 CmdArgs.push_back(
"--debug-info");
905 CmdArgs.push_back(
"--eh-frame");
906 CmdArgs.push_back(
"--quiet");
908 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
910 assert(Input.
isFilename() &&
"Unexpected verify input");
916 Args.MakeArgString(getToolChain().GetProgramPath(
"dwarfdump"));
918 Exec, CmdArgs, Inputs, Output));
931 :
MachO(D, Triple, Args), TargetInitialized(
false),
932 CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {}
938 if (Ty == types::TY_PP_Asm)
939 return types::TY_Asm;
975 ArgStringList &CC1Args)
const {
980 ArgStringList &CC1Args)
const {
989 return llvm::StringSwitch<const char *>(Arch)
990 .Case(
"armv6k",
"armv6")
991 .Case(
"armv6m",
"armv6m")
992 .Case(
"armv5tej",
"armv5")
993 .Case(
"xscale",
"xscale")
994 .Case(
"armv4t",
"armv4t")
995 .Case(
"armv7",
"armv7")
996 .Cases(
"armv7a",
"armv7-a",
"armv7")
997 .Cases(
"armv7r",
"armv7-r",
"armv7")
998 .Cases(
"armv7em",
"armv7e-m",
"armv7em")
999 .Cases(
"armv7k",
"armv7-k",
"armv7k")
1000 .Cases(
"armv7m",
"armv7-m",
"armv7m")
1001 .Cases(
"armv7s",
"armv7-s",
"armv7s")
1006 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
1007 if (ArchKind == llvm::ARM::ArchKind::INVALID)
1009 StringRef Arch = llvm::ARM::getArchName(ArchKind);
1013 if (Arch.startswith(
"armv5"))
1014 Arch = Arch.substr(0, 5);
1016 else if (Arch.startswith(
"armv6") && !Arch.endswith(
"6m"))
1017 Arch = Arch.substr(0, 5);
1019 else if (Arch.endswith(
"v7a"))
1020 Arch = Arch.substr(0, 5);
1029 case llvm::Triple::aarch64_32:
1032 case llvm::Triple::aarch64: {
1038 case llvm::Triple::thumb:
1039 case llvm::Triple::arm:
1040 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
1044 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1053 if (LinkerVersion) {
1055 VersionTuple NewLinkerVersion;
1056 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1057 (void)NewLinkerVersion.tryParse(A->getValue());
1058 assert(NewLinkerVersion == LinkerVersion);
1060 return *LinkerVersion;
1063 VersionTuple NewLinkerVersion;
1064 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1065 if (NewLinkerVersion.tryParse(A->getValue()))
1067 << A->getAsString(Args);
1069 LinkerVersion = NewLinkerVersion;
1070 return *LinkerVersion;
1084 return Triple.getTriple();
1098 Triple.setOSName(Str);
1100 return Triple.getTriple();
1112 return Dsymutil.get();
1116 return VerifyDebug.get();
1133 const ArgList &Args)
1134 :
Darwin(D, Triple, Args) {}
1138 CC1Args.push_back(
"-Wundef-prefix=TARGET_OS_");
1139 CC1Args.push_back(
"-Werror=undef-prefix");
1145 CC1Args.push_back(
"-Wdeprecated-objc-isa-usage");
1146 CC1Args.push_back(
"-Werror=deprecated-objc-isa-usage");
1151 CC1Args.push_back(
"-Werror=implicit-function-declaration");
1159 static constexpr llvm::StringLiteral XcodeAppSuffix(
1160 ".app/Contents/Developer");
1161 size_t Index = PathIntoXcode.find(XcodeAppSuffix);
1162 if (Index == StringRef::npos)
1164 return PathIntoXcode.take_front(Index + XcodeAppSuffix.size());
1168 ArgStringList &CmdArgs)
const {
1185 llvm::sys::path::remove_filename(
P);
1186 llvm::sys::path::remove_filename(
P);
1187 llvm::sys::path::append(
P,
"lib",
"arc");
1194 auto updatePath = [&](
const Arg *A) {
1198 if (XcodePathForSDK.empty())
1201 P = XcodePathForSDK;
1202 llvm::sys::path::append(
P,
"Toolchains/XcodeDefault.xctoolchain/usr",
1207 bool updated =
false;
1208 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot))
1209 updated = updatePath(A);
1212 if (
const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
1217 CmdArgs.push_back(
"-force_load");
1218 llvm::sys::path::append(
P,
"libarclite_");
1221 P +=
"watchsimulator";
1225 P +=
"appletvsimulator";
1229 P +=
"iphonesimulator";
1237 getDriver().
Diag(clang::diag::err_drv_darwin_sdk_missing_arclite) <<
P;
1239 CmdArgs.push_back(Args.MakeArgString(
P));
1252 bool IsShared)
const {
1255 if (Component !=
"builtins") {
1256 DarwinLibName += Component;
1258 DarwinLibName +=
"_";
1262 DarwinLibName += IsShared ?
"_dynamic.dylib" :
".a";
1264 llvm::sys::path::append(Dir,
"lib",
"darwin");
1266 llvm::sys::path::append(Dir,
"macho_embedded");
1269 llvm::sys::path::append(
P, DarwinLibName);
1275 const char *LibArg = Args.MakeArgString(
P);
1276 CmdArgs.push_back(LibArg);
1284 assert(DarwinLibName.endswith(
".dylib") &&
"must be a dynamic library");
1288 CmdArgs.push_back(
"-rpath");
1289 CmdArgs.push_back(
"@executable_path");
1293 CmdArgs.push_back(
"-rpath");
1294 CmdArgs.push_back(Args.MakeArgString(Dir));
1313 llvm_unreachable(
"Unsupported platform");
1318 auto BeginSDK = llvm::sys::path::rbegin(isysroot);
1319 auto EndSDK = llvm::sys::path::rend(isysroot);
1320 for (
auto IT = BeginSDK; IT != EndSDK; ++IT) {
1321 StringRef SDK = *IT;
1322 if (SDK.endswith(
".sdk"))
1323 return SDK.slice(0, SDK.size() - 4);
1346 llvm_unreachable(
"Unsupported platform");
1351 for (Arg *A : Args) {
1352 if (A->getOption().matches(options::OPT_exported__symbols__list))
1354 if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
1355 !A->getOption().matches(options::OPT_Xlinker))
1357 if (A->containsValue(
"-exported_symbols_list") ||
1358 A->containsValue(
"-exported_symbol"))
1366 CmdArgs.push_back(
"-exported_symbol");
1367 CmdArgs.push_back(Symbol);
1377 StringRef Segment, StringRef Section) {
1378 for (
const char *A : {
"-sectalign", Args.MakeArgString(Segment),
1379 Args.MakeArgString(Section),
"0x4000"})
1380 CmdArgs.push_back(A);
1384 ArgStringList &CmdArgs)
const {
1413 for (
auto IPSK : {llvm::IPSK_cnts, llvm::IPSK_data}) {
1415 Args, CmdArgs,
"__DATA",
1416 llvm::getInstrProfSectionName(IPSK, llvm::Triple::MachO,
1422void DarwinClang::AddLinkSanitizerLibArgs(
const ArgList &Args,
1423 ArgStringList &CmdArgs,
1424 StringRef Sanitizer,
1425 bool Shared)
const {
1431 const ArgList &Args)
const {
1432 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1433 StringRef
Value = A->getValue();
1434 if (
Value !=
"compiler-rt" &&
Value !=
"platform")
1435 getDriver().
Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1436 <<
Value <<
"darwin";
1443 ArgStringList &CmdArgs,
1444 bool ForceLinkBuiltinRT)
const {
1450 if (Args.hasArg(options::OPT_static) ||
1451 Args.hasArg(options::OPT_fapple_kext) ||
1452 Args.hasArg(options::OPT_mkernel)) {
1453 if (ForceLinkBuiltinRT)
1461 if (
const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1462 getDriver().
Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1469 const char *sanitizer =
nullptr;
1471 sanitizer =
"UndefinedBehaviorSanitizer";
1473 sanitizer =
"AddressSanitizer";
1475 sanitizer =
"ThreadSanitizer";
1478 getDriver().
Diag(diag::err_drv_unsupported_static_sanitizer_darwin)
1487 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan_abi",
false);
1490 "Static sanitizer runtimes not supported");
1491 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan");
1495 AddLinkSanitizerLibArgs(Args, CmdArgs,
"lsan");
1498 "Static sanitizer runtimes not supported");
1499 AddLinkSanitizerLibArgs(
1505 "Static sanitizer runtimes not supported");
1506 AddLinkSanitizerLibArgs(Args, CmdArgs,
"tsan");
1508 if (Sanitize.
needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1509 AddLinkSanitizerLibArgs(Args, CmdArgs,
"fuzzer",
false);
1516 AddLinkSanitizerLibArgs(Args, CmdArgs,
"stats");
1528 CmdArgs.push_back(
"-framework");
1529 CmdArgs.push_back(
"DriverKit");
1535 CmdArgs.push_back(
"-lSystem");
1544 CmdArgs.push_back(
"-lgcc_s.1");
1554 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1555 if (!SystemTriple.isMacOSX())
1556 return std::string(MacOSSDKVersion);
1557 VersionTuple SystemVersion;
1558 SystemTriple.getMacOSXVersion(SystemVersion);
1560 unsigned Major, Minor, Micro;
1564 return std::string(MacOSSDKVersion);
1565 VersionTuple SDKVersion(Major, Minor, Micro);
1567 if (SDKVersion > SystemVersion)
1568 return SystemVersion.getAsString();
1569 return std::string(MacOSSDKVersion);
1575struct DarwinPlatform {
1584 DeploymentTargetEnv,
1594 DarwinPlatformKind getPlatform()
const {
return Platform; }
1596 DarwinEnvironmentKind getEnvironment()
const {
return Environment; }
1598 void setEnvironment(DarwinEnvironmentKind Kind) {
1600 InferSimulatorFromArch =
false;
1603 StringRef getOSVersion()
const {
1604 if (Kind == OSVersionArg)
1605 return Argument->getValue();
1609 void setOSVersion(StringRef S) {
1610 assert(Kind == TargetArg &&
"Unexpected kind!");
1611 OSVersion = std::string(S);
1614 bool hasOSVersion()
const {
return HasOSVersion; }
1616 VersionTuple getNativeTargetVersion()
const {
1617 assert(Environment == DarwinEnvironmentKind::MacCatalyst &&
1618 "native target version is specified only for Mac Catalyst");
1619 return NativeTargetVersion;
1623 bool isExplicitlySpecified()
const {
return Kind <= DeploymentTargetEnv; }
1626 bool canInferSimulatorFromArch()
const {
return InferSimulatorFromArch; }
1628 const std::optional<llvm::Triple> &getTargetVariantTriple()
const {
1629 return TargetVariantTriple;
1633 void addOSVersionMinArgument(DerivedArgList &Args,
const OptTable &Opts) {
1636 assert(Kind != TargetArg && Kind != MTargetOSArg && Kind != OSVersionArg &&
1640 case DarwinPlatformKind::MacOS:
1641 Opt = options::OPT_mmacos_version_min_EQ;
1643 case DarwinPlatformKind::IPhoneOS:
1644 Opt = options::OPT_mios_version_min_EQ;
1646 case DarwinPlatformKind::TvOS:
1647 Opt = options::OPT_mtvos_version_min_EQ;
1649 case DarwinPlatformKind::WatchOS:
1650 Opt = options::OPT_mwatchos_version_min_EQ;
1652 case DarwinPlatformKind::DriverKit:
1656 Argument = Args.MakeJoinedArg(
nullptr, Opts.getOption(Opt), OSVersion);
1657 Args.append(Argument);
1662 std::string
getAsString(DerivedArgList &Args,
const OptTable &Opts) {
1667 case InferredFromSDK:
1668 case InferredFromArch:
1669 assert(Argument &&
"OS version argument not yet inferred");
1670 return Argument->getAsString(Args);
1671 case DeploymentTargetEnv:
1672 return (llvm::Twine(EnvVarName) +
"=" + OSVersion).str();
1674 llvm_unreachable(
"Unsupported Darwin Source Kind");
1677 void setEnvironment(llvm::Triple::EnvironmentType EnvType,
1678 const VersionTuple &OSVersion,
1679 const std::optional<DarwinSDKInfo> &SDKInfo) {
1681 case llvm::Triple::Simulator:
1682 Environment = DarwinEnvironmentKind::Simulator;
1684 case llvm::Triple::MacABI: {
1685 Environment = DarwinEnvironmentKind::MacCatalyst;
1687 NativeTargetVersion = VersionTuple(10, 15);
1688 if (HasOSVersion && SDKInfo) {
1689 if (
const auto *MacCatalystToMacOSMapping = SDKInfo->getVersionMapping(
1691 if (
auto MacOSVersion = MacCatalystToMacOSMapping->map(
1692 OSVersion, NativeTargetVersion, std::nullopt)) {
1693 NativeTargetVersion = *MacOSVersion;
1700 if (TargetVariantTriple) {
1701 auto TargetVariantVersion = TargetVariantTriple->getOSVersion();
1702 if (TargetVariantVersion.getMajor()) {
1703 if (TargetVariantVersion < NativeTargetVersion)
1704 NativeTargetVersion = TargetVariantVersion;
1714 static DarwinPlatform
1715 createFromTarget(
const llvm::Triple &TT, StringRef OSVersion, Arg *A,
1716 std::optional<llvm::Triple> TargetVariantTriple,
1717 const std::optional<DarwinSDKInfo> &SDKInfo) {
1718 DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
1720 VersionTuple OsVersion = TT.getOSVersion();
1721 if (OsVersion.getMajor() == 0)
1722 Result.HasOSVersion =
false;
1723 Result.TargetVariantTriple = TargetVariantTriple;
1724 Result.setEnvironment(TT.getEnvironment(), OsVersion, SDKInfo);
1727 static DarwinPlatform
1728 createFromMTargetOS(llvm::Triple::OSType OS, VersionTuple OSVersion,
1729 llvm::Triple::EnvironmentType Environment, Arg *A,
1730 const std::optional<DarwinSDKInfo> &SDKInfo) {
1731 DarwinPlatform Result(MTargetOSArg, getPlatformFromOS(OS),
1732 OSVersion.getAsString(), A);
1733 Result.InferSimulatorFromArch =
false;
1734 Result.setEnvironment(Environment, OSVersion, SDKInfo);
1737 static DarwinPlatform createOSVersionArg(DarwinPlatformKind Platform, Arg *A,
1739 DarwinPlatform Result{OSVersionArg, Platform, A};
1741 Result.Environment = DarwinEnvironmentKind::Simulator;
1744 static DarwinPlatform createDeploymentTargetEnv(DarwinPlatformKind Platform,
1745 StringRef EnvVarName,
1747 DarwinPlatform Result(DeploymentTargetEnv, Platform,
Value);
1748 Result.EnvVarName = EnvVarName;
1751 static DarwinPlatform createFromSDK(DarwinPlatformKind Platform,
1753 bool IsSimulator =
false) {
1754 DarwinPlatform Result(InferredFromSDK, Platform,
Value);
1756 Result.Environment = DarwinEnvironmentKind::Simulator;
1757 Result.InferSimulatorFromArch =
false;
1760 static DarwinPlatform createFromArch(llvm::Triple::OSType OS,
1762 return DarwinPlatform(InferredFromArch, getPlatformFromOS(OS),
Value);
1769 assert(Kind == InferredFromSDK &&
"can infer SDK info only");
1770 llvm::VersionTuple Version;
1771 bool IsValid = !Version.tryParse(OSVersion);
1773 assert(IsValid &&
"invalid SDK version");
1776 VersionTuple(Version.getMajor(), 0, 99));
1780 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, Arg *Argument)
1781 :
Kind(
Kind), Platform(Platform), Argument(Argument) {}
1782 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, StringRef
Value,
1783 Arg *Argument =
nullptr)
1784 :
Kind(
Kind), Platform(Platform), OSVersion(
Value), Argument(Argument) {}
1786 static DarwinPlatformKind getPlatformFromOS(llvm::Triple::OSType OS) {
1788 case llvm::Triple::Darwin:
1789 case llvm::Triple::MacOSX:
1790 return DarwinPlatformKind::MacOS;
1791 case llvm::Triple::IOS:
1792 return DarwinPlatformKind::IPhoneOS;
1793 case llvm::Triple::TvOS:
1794 return DarwinPlatformKind::TvOS;
1795 case llvm::Triple::WatchOS:
1796 return DarwinPlatformKind::WatchOS;
1797 case llvm::Triple::DriverKit:
1798 return DarwinPlatformKind::DriverKit;
1800 llvm_unreachable(
"Unable to infer Darwin variant");
1805 DarwinPlatformKind Platform;
1806 DarwinEnvironmentKind Environment = DarwinEnvironmentKind::NativeEnvironment;
1807 VersionTuple NativeTargetVersion;
1808 std::string OSVersion;
1809 bool HasOSVersion =
true, InferSimulatorFromArch =
true;
1811 StringRef EnvVarName;
1812 std::optional<llvm::Triple> TargetVariantTriple;
1817std::optional<DarwinPlatform>
1818getDeploymentTargetFromOSVersionArg(DerivedArgList &Args,
1819 const Driver &TheDriver) {
1820 Arg *macOSVersion = Args.getLastArg(options::OPT_mmacos_version_min_EQ);
1821 Arg *iOSVersion = Args.getLastArg(options::OPT_mios_version_min_EQ,
1822 options::OPT_mios_simulator_version_min_EQ);
1824 Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1825 options::OPT_mtvos_simulator_version_min_EQ);
1826 Arg *WatchOSVersion =
1827 Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1828 options::OPT_mwatchos_simulator_version_min_EQ);
1830 if (iOSVersion || TvOSVersion || WatchOSVersion) {
1831 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1832 << macOSVersion->getAsString(Args)
1833 << (iOSVersion ? iOSVersion
1834 : TvOSVersion ? TvOSVersion : WatchOSVersion)
1837 return DarwinPlatform::createOSVersionArg(
Darwin::MacOS, macOSVersion,
1839 }
else if (iOSVersion) {
1840 if (TvOSVersion || WatchOSVersion) {
1841 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1842 << iOSVersion->getAsString(Args)
1843 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->
getAsString(Args);
1845 return DarwinPlatform::createOSVersionArg(
1847 iOSVersion->getOption().getID() ==
1848 options::OPT_mios_simulator_version_min_EQ);
1849 }
else if (TvOSVersion) {
1850 if (WatchOSVersion) {
1851 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1852 << TvOSVersion->getAsString(Args)
1853 << WatchOSVersion->getAsString(Args);
1855 return DarwinPlatform::createOSVersionArg(
1857 TvOSVersion->getOption().getID() ==
1858 options::OPT_mtvos_simulator_version_min_EQ);
1859 }
else if (WatchOSVersion)
1860 return DarwinPlatform::createOSVersionArg(
1862 WatchOSVersion->getOption().getID() ==
1863 options::OPT_mwatchos_simulator_version_min_EQ);
1864 return std::nullopt;
1869std::optional<DarwinPlatform>
1870getDeploymentTargetFromEnvironmentVariables(
const Driver &TheDriver,
1871 const llvm::Triple &Triple) {
1873 const char *EnvVars[] = {
1874 "MACOSX_DEPLOYMENT_TARGET",
1875 "IPHONEOS_DEPLOYMENT_TARGET",
1876 "TVOS_DEPLOYMENT_TARGET",
1877 "WATCHOS_DEPLOYMENT_TARGET",
1878 "DRIVERKIT_DEPLOYMENT_TARGET",
1881 "Missing platform");
1883 if (
char *
Env = ::getenv(I.value()))
1884 Targets[I.index()] =
Env;
1892 if (Triple.getArch() == llvm::Triple::arm ||
1893 Triple.getArch() == llvm::Triple::aarch64 ||
1894 Triple.getArch() == llvm::Triple::thumb)
1901 unsigned FirstTarget = std::size(Targets);
1902 for (
unsigned I = 0; I != std::size(Targets); ++I) {
1903 if (Targets[I].empty())
1905 if (FirstTarget == std::size(Targets))
1908 TheDriver.
Diag(diag::err_drv_conflicting_deployment_targets)
1909 << Targets[FirstTarget] << Targets[I];
1914 if (!
Target.value().empty())
1915 return DarwinPlatform::createDeploymentTargetEnv(
1919 return std::nullopt;
1924static StringRef dropSDKNamePrefix(StringRef SDKName) {
1925 size_t PrefixPos = SDKName.find(
'.');
1926 if (PrefixPos == StringRef::npos)
1928 return SDKName.substr(PrefixPos + 1);
1934std::optional<DarwinPlatform>
1935inferDeploymentTargetFromSDK(DerivedArgList &Args,
1936 const std::optional<DarwinSDKInfo> &SDKInfo) {
1937 const Arg *A = Args.getLastArg(options::OPT_isysroot);
1939 return std::nullopt;
1940 StringRef isysroot = A->getValue();
1943 return std::nullopt;
1945 std::string Version;
1948 Version = SDKInfo->getVersion().getAsString();
1952 size_t StartVer = SDK.find_first_of(
"0123456789");
1953 size_t EndVer = SDK.find_last_of(
"0123456789");
1954 if (StartVer != StringRef::npos && EndVer > StartVer)
1955 Version = std::string(SDK.slice(StartVer, EndVer + 1));
1957 if (Version.empty())
1958 return std::nullopt;
1960 auto CreatePlatformFromSDKName =
1961 [&](StringRef SDK) -> std::optional<DarwinPlatform> {
1962 if (SDK.startswith(
"iPhoneOS") || SDK.startswith(
"iPhoneSimulator"))
1963 return DarwinPlatform::createFromSDK(
1965 SDK.startswith(
"iPhoneSimulator"));
1966 else if (SDK.startswith(
"MacOSX"))
1969 else if (SDK.startswith(
"WatchOS") || SDK.startswith(
"WatchSimulator"))
1970 return DarwinPlatform::createFromSDK(
1972 SDK.startswith(
"WatchSimulator"));
1973 else if (SDK.startswith(
"AppleTVOS") || SDK.startswith(
"AppleTVSimulator"))
1974 return DarwinPlatform::createFromSDK(
1976 SDK.startswith(
"AppleTVSimulator"));
1977 else if (SDK.startswith(
"DriverKit"))
1979 return std::nullopt;
1981 if (
auto Result = CreatePlatformFromSDKName(SDK))
1984 return CreatePlatformFromSDKName(dropSDKNamePrefix(SDK));
1987std::string getOSVersion(llvm::Triple::OSType OS,
const llvm::Triple &Triple,
1988 const Driver &TheDriver) {
1989 VersionTuple OsVersion;
1990 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1992 case llvm::Triple::Darwin:
1993 case llvm::Triple::MacOSX:
1996 if (Triple.isMacOSX() && SystemTriple.isMacOSX() &&
1997 !Triple.getOSMajorVersion())
1998 SystemTriple.getMacOSXVersion(OsVersion);
1999 else if (!Triple.getMacOSXVersion(OsVersion))
2000 TheDriver.
Diag(diag::err_drv_invalid_darwin_version)
2001 << Triple.getOSName();
2003 case llvm::Triple::IOS:
2004 if (Triple.isMacCatalystEnvironment() && !Triple.getOSMajorVersion()) {
2005 OsVersion = VersionTuple(13, 1);
2007 OsVersion = Triple.getiOSVersion();
2009 case llvm::Triple::TvOS:
2010 OsVersion = Triple.getOSVersion();
2012 case llvm::Triple::WatchOS:
2013 OsVersion = Triple.getWatchOSVersion();
2015 case llvm::Triple::DriverKit:
2016 OsVersion = Triple.getDriverKitVersion();
2019 llvm_unreachable(
"Unexpected OS type");
2023 std::string OSVersion;
2024 llvm::raw_string_ostream(OSVersion)
2025 << OsVersion.getMajor() <<
'.' << OsVersion.getMinor().value_or(0) <<
'.'
2026 << OsVersion.getSubminor().value_or(0);
2031std::optional<DarwinPlatform>
2032inferDeploymentTargetFromArch(DerivedArgList &Args,
const Darwin &Toolchain,
2033 const llvm::Triple &Triple,
2034 const Driver &TheDriver) {
2035 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
2038 if (MachOArchName ==
"arm64" || MachOArchName ==
"arm64e")
2039 OSTy = llvm::Triple::MacOSX;
2040 else if (MachOArchName ==
"armv7" || MachOArchName ==
"armv7s")
2041 OSTy = llvm::Triple::IOS;
2042 else if (MachOArchName ==
"armv7k" || MachOArchName ==
"arm64_32")
2043 OSTy = llvm::Triple::WatchOS;
2044 else if (MachOArchName !=
"armv6m" && MachOArchName !=
"armv7m" &&
2045 MachOArchName !=
"armv7em")
2046 OSTy = llvm::Triple::MacOSX;
2047 if (OSTy == llvm::Triple::UnknownOS)
2048 return std::nullopt;
2049 return DarwinPlatform::createFromArch(OSTy,
2050 getOSVersion(OSTy, Triple, TheDriver));
2054std::optional<DarwinPlatform> getDeploymentTargetFromTargetArg(
2055 DerivedArgList &Args,
const llvm::Triple &Triple,
const Driver &TheDriver,
2056 const std::optional<DarwinSDKInfo> &SDKInfo) {
2057 if (!Args.hasArg(options::OPT_target))
2058 return std::nullopt;
2059 if (Triple.getOS() == llvm::Triple::Darwin ||
2060 Triple.getOS() == llvm::Triple::UnknownOS)
2061 return std::nullopt;
2062 std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
2063 std::optional<llvm::Triple> TargetVariantTriple;
2064 for (
const Arg *A : Args.filtered(options::OPT_darwin_target_variant)) {
2065 llvm::Triple TVT(A->getValue());
2067 if ((Triple.getArch() == llvm::Triple::aarch64 ||
2068 TVT.getArchName() == Triple.getArchName()) &&
2069 TVT.getArch() == Triple.getArch() &&
2070 TVT.getSubArch() == Triple.getSubArch() &&
2071 TVT.getVendor() == Triple.getVendor()) {
2072 if (TargetVariantTriple)
2077 if ((Triple.isMacOSX() && TVT.getOS() == llvm::Triple::IOS &&
2078 TVT.isMacCatalystEnvironment()) ||
2079 (TVT.isMacOSX() && Triple.getOS() == llvm::Triple::IOS &&
2080 Triple.isMacCatalystEnvironment())) {
2081 TargetVariantTriple = TVT;
2084 TheDriver.
Diag(diag::err_drv_target_variant_invalid)
2085 << A->getSpelling() << A->getValue();
2088 return DarwinPlatform::createFromTarget(Triple, OSVersion,
2089 Args.getLastArg(options::OPT_target),
2090 TargetVariantTriple, SDKInfo);
2094std::optional<DarwinPlatform> getDeploymentTargetFromMTargetOSArg(
2095 DerivedArgList &Args,
const Driver &TheDriver,
2096 const std::optional<DarwinSDKInfo> &SDKInfo) {
2097 auto *A = Args.getLastArg(options::OPT_mtargetos_EQ);
2099 return std::nullopt;
2100 llvm::Triple TT(llvm::Twine(
"unknown-apple-") + A->getValue());
2101 switch (TT.getOS()) {
2102 case llvm::Triple::MacOSX:
2103 case llvm::Triple::IOS:
2104 case llvm::Triple::TvOS:
2105 case llvm::Triple::WatchOS:
2108 TheDriver.
Diag(diag::err_drv_invalid_os_in_arg)
2109 << TT.getOSName() << A->getAsString(Args);
2110 return std::nullopt;
2113 VersionTuple Version = TT.getOSVersion();
2114 if (!Version.getMajor()) {
2115 TheDriver.
Diag(diag::err_drv_invalid_version_number)
2116 << A->getAsString(Args);
2117 return std::nullopt;
2119 return DarwinPlatform::createFromMTargetOS(TT.getOS(), Version,
2120 TT.getEnvironment(), A, SDKInfo);
2123std::optional<DarwinSDKInfo> parseSDKSettings(llvm::vfs::FileSystem &VFS,
2124 const ArgList &Args,
2125 const Driver &TheDriver) {
2126 const Arg *A = Args.getLastArg(options::OPT_isysroot);
2128 return std::nullopt;
2129 StringRef isysroot = A->getValue();
2131 if (!SDKInfoOrErr) {
2132 llvm::consumeError(SDKInfoOrErr.takeError());
2133 TheDriver.
Diag(diag::warn_drv_darwin_sdk_invalid_settings);
2134 return std::nullopt;
2136 return *SDKInfoOrErr;
2141void Darwin::AddDeploymentTarget(DerivedArgList &Args)
const {
2147 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2149 if (!
getVFS().exists(A->getValue()))
2150 getDriver().
Diag(clang::diag::warn_missing_sysroot) << A->getValue();
2152 if (
char *env = ::getenv(
"SDKROOT")) {
2155 if (llvm::sys::path::is_absolute(env) &&
getVFS().exists(env) &&
2156 StringRef(env) !=
"/") {
2157 Args.append(Args.MakeSeparateArg(
2158 nullptr, Opts.getOption(options::OPT_isysroot), env));
2168 std::optional<DarwinPlatform> OSTarget =
2172 if (
const auto *MTargetOSArg = Args.getLastArg(options::OPT_mtargetos_EQ)) {
2173 std::string TargetArgStr = OSTarget->getAsString(Args, Opts);
2174 std::string MTargetOSArgStr = MTargetOSArg->getAsString(Args);
2176 << TargetArgStr << MTargetOSArgStr;
2178 std::optional<DarwinPlatform> OSVersionArgTarget =
2179 getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2180 if (OSVersionArgTarget) {
2181 unsigned TargetMajor, TargetMinor, TargetMicro;
2183 unsigned ArgMajor, ArgMinor, ArgMicro;
2185 if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
2187 TargetMinor, TargetMicro, TargetExtra) &&
2189 ArgMajor, ArgMinor, ArgMicro, ArgExtra) &&
2190 (VersionTuple(TargetMajor, TargetMinor, TargetMicro) !=
2191 VersionTuple(ArgMajor, ArgMinor, ArgMicro) ||
2192 TargetExtra != ArgExtra))) {
2195 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
2196 !OSTarget->hasOSVersion()) {
2197 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
2201 std::string OSVersionArg =
2202 OSVersionArgTarget->getAsString(Args, Opts);
2203 std::string TargetArg = OSTarget->getAsString(Args, Opts);
2205 << OSVersionArg << TargetArg;
2209 }
else if ((OSTarget = getDeploymentTargetFromMTargetOSArg(Args,
getDriver(),
2213 std::optional<DarwinPlatform> OSVersionArgTarget =
2214 getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2215 if (OSVersionArgTarget) {
2216 std::string MTargetOSArgStr = OSTarget->getAsString(Args, Opts);
2217 std::string OSVersionArgStr = OSVersionArgTarget->getAsString(Args, Opts);
2219 << MTargetOSArgStr << OSVersionArgStr;
2223 OSTarget = getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2231 std::optional<DarwinPlatform> SDKTarget =
2232 inferDeploymentTargetFromSDK(Args,
SDKInfo);
2234 OSTarget->setEnvironment(SDKTarget->getEnvironment());
2241 OSTarget = inferDeploymentTargetFromSDK(Args,
SDKInfo);
2245 SDKInfo = OSTarget->inferSDKInfo();
2254 assert(OSTarget &&
"Unable to infer Darwin variant");
2255 OSTarget->addOSVersionMinArgument(Args, Opts);
2258 unsigned Major, Minor, Micro;
2261 const unsigned MajorVersionLimit = 1000;
2263 if (Platform ==
MacOS) {
2266 HadExtra || Major < 10 || Major >= MajorVersionLimit || Minor >= 100 ||
2269 << OSTarget->getAsString(Args, Opts);
2273 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2275 << OSTarget->getAsString(Args, Opts);
2278 (Major < 13 || (Major == 13 && Minor < 1))) {
2280 << OSTarget->getAsString(Args, Opts);
2287 if (
getTriple().isArch32Bit() && Major >= 11) {
2289 if (OSTarget->isExplicitlySpecified()) {
2291 getDriver().
Diag(diag::err_invalid_macos_32bit_deployment_target);
2294 << OSTarget->getAsString(Args, Opts);
2302 }
else if (Platform ==
TvOS) {
2305 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2307 << OSTarget->getAsString(Args, Opts);
2308 }
else if (Platform ==
WatchOS) {
2311 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2313 << OSTarget->getAsString(Args, Opts);
2317 HadExtra || Major < 19 || Major >= MajorVersionLimit || Minor >= 100 ||
2320 << OSTarget->getAsString(Args, Opts);
2322 llvm_unreachable(
"unknown kind of Darwin platform");
2327 Platform !=
DriverKit && OSTarget->canInferSimulatorFromArch() &&
2331 VersionTuple NativeTargetVersion;
2333 NativeTargetVersion = OSTarget->getNativeTargetVersion();
2334 setTarget(Platform, Environment, Major, Minor, Micro, NativeTargetVersion);
2337 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2339 if (SDK.size() > 0) {
2340 size_t StartVer = SDK.find_first_of(
"0123456789");
2341 StringRef SDKName = SDK.slice(0, StartVer);
2354 const llvm::Triple &T) {
2355 if (T.isDriverKit()) {
2356 llvm::sys::path::append(Path,
"System",
"DriverKit");
2363DarwinClang::GetEffectiveSysroot(
const llvm::opt::ArgList &DriverArgs)
const {
2365 if (DriverArgs.hasArg(options::OPT_isysroot))
2366 Path = DriverArgs.getLastArgValue(options::OPT_isysroot);
2377 llvm::opt::ArgStringList &CC1Args)
const {
2382 bool NoStdInc = DriverArgs.hasArg(options::OPT_nostdinc);
2383 bool NoStdlibInc = DriverArgs.hasArg(options::OPT_nostdlibinc);
2384 bool NoBuiltinInc = DriverArgs.hasFlag(
2385 options::OPT_nobuiltininc, options::OPT_ibuiltininc,
false);
2386 bool ForceBuiltinInc = DriverArgs.hasFlag(
2387 options::OPT_ibuiltininc, options::OPT_nobuiltininc,
false);
2390 if (!NoStdInc && !NoStdlibInc) {
2392 llvm::sys::path::append(
P,
"usr",
"local",
"include");
2397 if (!(NoStdInc && !ForceBuiltinInc) && !NoBuiltinInc) {
2399 llvm::sys::path::append(
P,
"include");
2403 if (NoStdInc || NoStdlibInc)
2407 llvm::StringRef CIncludeDirs(C_INCLUDE_DIRS);
2408 if (!CIncludeDirs.empty()) {
2410 CIncludeDirs.split(dirs,
":");
2411 for (llvm::StringRef dir : dirs) {
2412 llvm::StringRef Prefix =
2413 llvm::sys::path::is_absolute(dir) ?
"" : llvm::StringRef(Sysroot);
2419 llvm::sys::path::append(
P,
"usr",
"include");
2424bool DarwinClang::AddGnuCPlusPlusIncludePaths(
const llvm::opt::ArgList &DriverArgs,
2425 llvm::opt::ArgStringList &CC1Args,
2427 llvm::StringRef Version,
2428 llvm::StringRef ArchDir,
2429 llvm::StringRef BitDir)
const {
2430 llvm::sys::path::append(
Base, Version);
2438 if (!ArchDir.empty())
2439 llvm::sys::path::append(
P, ArchDir);
2440 if (!BitDir.empty())
2441 llvm::sys::path::append(
P, BitDir);
2448 llvm::sys::path::append(
P,
"backward");
2456 const llvm::opt::ArgList &DriverArgs,
2457 llvm::opt::ArgStringList &CC1Args)
const {
2465 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
2466 options::OPT_nostdincxx))
2487 llvm::StringRef(
getDriver().getInstalledDir());
2488 llvm::sys::path::append(InstallBin,
"..",
"include",
"c++",
"v1");
2489 if (
getVFS().exists(InstallBin)) {
2492 }
else if (DriverArgs.hasArg(options::OPT_v)) {
2493 llvm::errs() <<
"ignoring nonexistent directory \"" << InstallBin
2499 llvm::sys::path::append(SysrootUsr,
"usr",
"include",
"c++",
"v1");
2500 if (
getVFS().exists(SysrootUsr)) {
2503 }
else if (DriverArgs.hasArg(options::OPT_v)) {
2504 llvm::errs() <<
"ignoring nonexistent directory \"" << SysrootUsr
2514 llvm::sys::path::append(UsrIncludeCxx,
"usr",
"include",
"c++");
2517 bool IsBaseFound =
true;
2521 case llvm::Triple::x86:
2522 case llvm::Triple::x86_64:
2523 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2525 "i686-apple-darwin10",
2526 arch == llvm::Triple::x86_64 ?
"x86_64" :
"");
2527 IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2528 "4.0.0",
"i686-apple-darwin8",
2532 case llvm::Triple::arm:
2533 case llvm::Triple::thumb:
2534 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2536 "arm-apple-darwin10",
2538 IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2540 "arm-apple-darwin10",
2544 case llvm::Triple::aarch64:
2545 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2547 "arm64-apple-darwin10",
2561 ArgStringList &CmdArgs)
const {
2566 CmdArgs.push_back(
"-lc++");
2567 if (Args.hasArg(options::OPT_fexperimental_library))
2568 CmdArgs.push_back(
"-lc++experimental");
2578 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2580 llvm::sys::path::append(
P,
"usr",
"lib",
"libstdc++.dylib");
2583 llvm::sys::path::remove_filename(
P);
2584 llvm::sys::path::append(
P,
"libstdc++.6.dylib");
2586 CmdArgs.push_back(Args.MakeArgString(
P));
2595 if (!
getVFS().exists(
"/usr/lib/libstdc++.dylib") &&
2596 getVFS().exists(
"/usr/lib/libstdc++.6.dylib")) {
2597 CmdArgs.push_back(
"/usr/lib/libstdc++.6.dylib");
2602 CmdArgs.push_back(
"-lstdc++");
2608 ArgStringList &CmdArgs)
const {
2614 llvm::sys::path::append(
P,
"lib",
"darwin");
2618 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_watchos.a");
2620 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_tvos.a");
2622 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_ios.a");
2626 llvm::sys::path::append(
P,
"libclang_rt.cc_kext.a");
2632 CmdArgs.push_back(Args.MakeArgString(
P));
2636 StringRef BoundArch,
2638 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2648 for (Arg *A : Args) {
2649 if (A->getOption().matches(options::OPT_Xarch__)) {
2652 StringRef XarchArch = A->getValue(0);
2654 (!BoundArch.empty() && XarchArch == BoundArch)))
2657 Arg *OriginalArg = A;
2665 for (
const char *
Value : A->getValues()) {
2666 DAL->AddSeparateArg(
2667 OriginalArg, Opts.getOption(options::OPT_Zlinker_input),
Value);
2681 case options::OPT_mkernel:
2682 case options::OPT_fapple_kext:
2684 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
2687 case options::OPT_dependency_file:
2688 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
2691 case options::OPT_gfull:
2692 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2694 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
2697 case options::OPT_gused:
2698 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2700 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
2703 case options::OPT_shared:
2704 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
2707 case options::OPT_fconstant_cfstrings:
2708 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
2711 case options::OPT_fno_constant_cfstrings:
2712 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
2715 case options::OPT_Wnonportable_cfstrings:
2717 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
2720 case options::OPT_Wno_nonportable_cfstrings:
2722 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
2729 if (!BoundArch.empty()) {
2730 StringRef Name = BoundArch;
2731 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
2732 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
2738 else if (Name ==
"ppc601")
2739 DAL->AddJoinedArg(
nullptr, MCpu,
"601");
2740 else if (Name ==
"ppc603")
2741 DAL->AddJoinedArg(
nullptr, MCpu,
"603");
2742 else if (Name ==
"ppc604")
2743 DAL->AddJoinedArg(
nullptr, MCpu,
"604");
2744 else if (Name ==
"ppc604e")
2745 DAL->AddJoinedArg(
nullptr, MCpu,
"604e");
2746 else if (Name ==
"ppc750")
2747 DAL->AddJoinedArg(
nullptr, MCpu,
"750");
2748 else if (Name ==
"ppc7400")
2749 DAL->AddJoinedArg(
nullptr, MCpu,
"7400");
2750 else if (Name ==
"ppc7450")
2751 DAL->AddJoinedArg(
nullptr, MCpu,
"7450");
2752 else if (Name ==
"ppc970")
2753 DAL->AddJoinedArg(
nullptr, MCpu,
"970");
2755 else if (Name ==
"ppc64" || Name ==
"ppc64le")
2756 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2758 else if (Name ==
"i386")
2760 else if (Name ==
"i486")
2761 DAL->AddJoinedArg(
nullptr, MArch,
"i486");
2762 else if (Name ==
"i586")
2763 DAL->AddJoinedArg(
nullptr, MArch,
"i586");
2764 else if (Name ==
"i686")
2765 DAL->AddJoinedArg(
nullptr, MArch,
"i686");
2766 else if (Name ==
"pentium")
2767 DAL->AddJoinedArg(
nullptr, MArch,
"pentium");
2768 else if (Name ==
"pentium2")
2769 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2770 else if (Name ==
"pentpro")
2771 DAL->AddJoinedArg(
nullptr, MArch,
"pentiumpro");
2772 else if (Name ==
"pentIIm3")
2773 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2775 else if (Name ==
"x86_64" || Name ==
"x86_64h")
2776 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2778 else if (Name ==
"arm")
2779 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2780 else if (Name ==
"armv4t")
2781 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2782 else if (Name ==
"armv5")
2783 DAL->AddJoinedArg(
nullptr, MArch,
"armv5tej");
2784 else if (Name ==
"xscale")
2785 DAL->AddJoinedArg(
nullptr, MArch,
"xscale");
2786 else if (Name ==
"armv6")
2787 DAL->AddJoinedArg(
nullptr, MArch,
"armv6k");
2788 else if (Name ==
"armv6m")
2789 DAL->AddJoinedArg(
nullptr, MArch,
"armv6m");
2790 else if (Name ==
"armv7")
2791 DAL->AddJoinedArg(
nullptr, MArch,
"armv7a");
2792 else if (Name ==
"armv7em")
2793 DAL->AddJoinedArg(
nullptr, MArch,
"armv7em");
2794 else if (Name ==
"armv7k")
2795 DAL->AddJoinedArg(
nullptr, MArch,
"armv7k");
2796 else if (Name ==
"armv7m")
2797 DAL->AddJoinedArg(
nullptr, MArch,
"armv7m");
2798 else if (Name ==
"armv7s")
2799 DAL->AddJoinedArg(
nullptr, MArch,
"armv7s");
2806 ArgStringList &CmdArgs,
2807 bool ForceLinkBuiltinRT)
const {
2816 CompilerRT += Args.hasArg(options::OPT_fPIC) ?
"_pic" :
"_static";
2822 llvm::Triple::OSType OS;
2828 OS = llvm::Triple::MacOSX;
2831 OS = llvm::Triple::IOS;
2834 OS = llvm::Triple::TvOS;
2837 OS = llvm::Triple::WatchOS;
2847 llvm::opt::ArgStringList &CC1Args,
2851 if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
2852 options::OPT_fno_aligned_allocation) &&
2854 CC1Args.push_back(
"-faligned-alloc-unavailable");
2860 CC1Args.push_back(
"-fcompatibility-qualified-id-block-type-checking");
2864 if (!DriverArgs.getLastArgNoClaim(
2865 options::OPT_fvisibility_inlines_hidden_static_local_var,
2866 options::OPT_fno_visibility_inlines_hidden_static_local_var))
2867 CC1Args.push_back(
"-fvisibility-inlines-hidden-static-local-var");
2871 const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CC1ASArgs)
const {
2873 CC1ASArgs.push_back(
"-darwin-target-variant-triple");
2880 auto EmitTargetSDKVersionArg = [&](
const VersionTuple &
V) {
2882 llvm::raw_string_ostream OS(Arg);
2883 OS <<
"-target-sdk-version=" <<
V;
2884 CC1ASArgs.push_back(Args.MakeArgString(OS.str()));
2888 if (
const auto *MacOStoMacCatalystMapping =
SDKInfo->getVersionMapping(
2890 std::optional<VersionTuple> SDKVersion = MacOStoMacCatalystMapping->map(
2893 EmitTargetSDKVersionArg(
2897 EmitTargetSDKVersionArg(
SDKInfo->getVersion());
2905 llvm::raw_string_ostream OS(Arg);
2906 OS <<
"-darwin-target-variant-sdk-version=" <<
SDKInfo->getVersion();
2907 CC1ASArgs.push_back(Args.MakeArgString(OS.str()));
2908 }
else if (
const auto *MacOStoMacCatalystMapping =
2911 if (std::optional<VersionTuple> SDKVersion =
2912 MacOStoMacCatalystMapping->map(
2916 llvm::raw_string_ostream OS(Arg);
2917 OS <<
"-darwin-target-variant-sdk-version=" << *SDKVersion;
2918 CC1ASArgs.push_back(Args.MakeArgString(OS.str()));
2929 DerivedArgList *DAL =
2933 if (BoundArch.empty())
2939 AddDeploymentTarget(*DAL);
2947 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
2950 if (A->getOption().getID() != options::OPT_mkernel &&
2951 A->getOption().getID() != options::OPT_fapple_kext)
2953 assert(it != ie &&
"unexpected argument translation");
2955 assert(A->getOption().getID() == options::OPT_static &&
2956 "missing expected -static argument");
2963 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
2964 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
2965 options::OPT_fno_omit_frame_pointer,
false))
2966 getDriver().
Diag(clang::diag::warn_drv_unsupported_opt_for_target)
2967 <<
"-fomit-frame-pointer" << BoundArch;
2976 if (
getArch() == llvm::Triple::x86_64 ||
2978 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2980 return (
getArch() == llvm::Triple::aarch64 ||
2981 getArch() == llvm::Triple::aarch64_32)
2989 if (
const char *S = ::getenv(
"RC_DEBUG_OPTIONS"))
2990 return S[0] !=
'\0';
2995 if (
const char *S = ::getenv(
"RC_DEBUG_PREFIX_MAP"))
3004 return llvm::ExceptionHandling::None;
3008 if (Triple.isWatchABI())
3009 return llvm::ExceptionHandling::DwarfCFI;
3011 return llvm::ExceptionHandling::SjLj;
3026 return (
getArch() == llvm::Triple::x86_64 ||
3027 getArch() == llvm::Triple::aarch64);
3036 ArgStringList &CmdArgs)
const {
3040 CmdArgs.push_back(
"-watchos_version_min");
3042 CmdArgs.push_back(
"-watchos_simulator_version_min");
3044 CmdArgs.push_back(
"-tvos_version_min");
3046 CmdArgs.push_back(
"-tvos_simulator_version_min");
3048 CmdArgs.push_back(
"-driverkit_version_min");
3050 CmdArgs.push_back(
"-ios_simulator_version_min");
3052 CmdArgs.push_back(
"-iphoneos_version_min");
3054 CmdArgs.push_back(
"-maccatalyst_version_min");
3057 CmdArgs.push_back(
"-macosx_version_min");
3063 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3066 VersionTuple VariantTargetVersion;
3068 CmdArgs.push_back(
"-macosx_version_min");
3073 "unexpected target variant triple");
3074 CmdArgs.push_back(
"-maccatalyst_version_min");
3077 VersionTuple MinTgtVers =
3079 if (MinTgtVers.getMajor() && MinTgtVers > VariantTargetVersion)
3080 VariantTargetVersion = MinTgtVers;
3081 CmdArgs.push_back(Args.MakeArgString(VariantTargetVersion.getAsString()));
3092 return "mac catalyst";
3101 llvm_unreachable(
"invalid platform");
3105 llvm::opt::ArgStringList &CmdArgs)
const {
3106 auto EmitPlatformVersionArg =
3109 const llvm::Triple &TT) {
3112 CmdArgs.push_back(
"-platform_version");
3113 std::string PlatformName =
3116 PlatformName +=
"-simulator";
3117 CmdArgs.push_back(Args.MakeArgString(PlatformName));
3126 VersionTuple MinTgtVers = TT.getMinimumSupportedOSVersion();
3129 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3134 std::optional<VersionTuple> iOSSDKVersion;
3136 if (
const auto *MacOStoMacCatalystMapping =
3139 iOSSDKVersion = MacOStoMacCatalystMapping->map(
3140 SDKInfo->getVersion().withoutBuild(),
3144 CmdArgs.push_back(Args.MakeArgString(
3145 (iOSSDKVersion ? *iOSSDKVersion
3152 VersionTuple SDKVersion =
SDKInfo->getVersion().withoutBuild();
3153 if (!SDKVersion.getMinor())
3154 SDKVersion = VersionTuple(SDKVersion.getMajor(), 0);
3155 CmdArgs.push_back(Args.MakeArgString(SDKVersion.getAsString()));
3166 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3175 VersionTuple TargetVariantVersion;
3183 "unexpected target variant triple");
3188 EmitPlatformVersionArg(TargetVariantVersion, Platform, Environment,
3194 ArgStringList &CmdArgs) {
3198 CmdArgs.push_back(
"-ldylib1.o");
3205 CmdArgs.push_back(
"-ldylib1.o");
3207 CmdArgs.push_back(
"-ldylib1.10.5.o");
3212 ArgStringList &CmdArgs) {
3213 if (Args.hasArg(options::OPT_static))
3218 CmdArgs.push_back(
"-lbundle1.o");
3223 ArgStringList &CmdArgs) {
3225 if (Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_object) ||
3226 Args.hasArg(options::OPT_preload)) {
3227 CmdArgs.push_back(
"-lgcrt0.o");
3229 CmdArgs.push_back(
"-lgcrt1.o");
3239 CmdArgs.push_back(
"-no_new_main");
3241 D.
getDriver().
Diag(diag::err_drv_clang_unsupported_opt_pg_darwin)
3247 ArgStringList &CmdArgs) {
3250 if (D.
getArch() == llvm::Triple::aarch64)
3253 CmdArgs.push_back(
"-lcrt1.o");
3255 CmdArgs.push_back(
"-lcrt1.3.1.o");
3262 CmdArgs.push_back(
"-lcrt1.o");
3264 CmdArgs.push_back(
"-lcrt1.10.5.o");
3266 CmdArgs.push_back(
"-lcrt1.10.6.o");
3271 ArgStringList &CmdArgs)
const {
3273 if (Args.hasArg(options::OPT_dynamiclib))
3275 else if (Args.hasArg(options::OPT_bundle))
3279 else if (Args.hasArg(options::OPT_static) ||
3280 Args.hasArg(options::OPT_object) ||
3281 Args.hasArg(options::OPT_preload))
3282 CmdArgs.push_back(
"-lcrt0.o");
3286 if (
isTargetMacOS() && Args.hasArg(options::OPT_shared_libgcc) &&
3288 const char *Str = Args.MakeArgString(
GetFilePath(
"crt3.o"));
3289 CmdArgs.push_back(Str);
3301 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
3302 const bool IsAArch64 =
getTriple().getArch() == llvm::Triple::aarch64;
3304 Res |= SanitizerKind::Address;
3305 Res |= SanitizerKind::PointerCompare;
3306 Res |= SanitizerKind::PointerSubtract;
3307 Res |= SanitizerKind::Leak;
3308 Res |= SanitizerKind::Fuzzer;
3309 Res |= SanitizerKind::FuzzerNoLink;
3310 Res |= SanitizerKind::ObjCCast;
3317 Res |= SanitizerKind::Vptr;
3319 if ((IsX86_64 || IsAArch64) &&
3322 Res |= SanitizerKind::Thread;
Defines a function that returns the minimum OS versions supporting C++17's aligned allocation functio...
static bool hasMultipleInvocations(const llvm::Triple &Triple, const ArgList &Args)
static bool checkRemarksOptions(const Driver &D, const ArgList &Args, const llvm::Triple &Triple)
static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input, const InputInfo &Output, const JobAction &JA)
static void addPgProfilingLinkArgs(const Darwin &D, const ArgList &Args, ArgStringList &CmdArgs)
static const char * ArmMachOArchName(StringRef Arch)
static bool shouldLinkerNotDedup(bool IsLinkerOnlyAction, const ArgList &Args)
Pass -no_deduplicate to ld64 under certain conditions:
static bool hasExportSymbolDirective(const ArgList &Args)
Check if the link command contains a symbol export directive.
static void addDefaultCRTLinkArgs(const Darwin &D, const ArgList &Args, ArgStringList &CmdArgs)
static void addBundleLinkArgs(const Darwin &D, const ArgList &Args, ArgStringList &CmdArgs)
static VersionTuple minimumMacCatalystDeploymentTarget()
static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion)
Returns the most appropriate macOS target version for the current process.
static void addDynamicLibLinkArgs(const Darwin &D, const ArgList &Args, ArgStringList &CmdArgs)
static void AppendPlatformPrefix(SmallString< 128 > &Path, const llvm::Triple &T)
static bool isObjCRuntimeLinked(const ArgList &Args)
Determine whether we are linking the ObjC runtime.
static const char * getPlatformName(Darwin::DarwinPlatformKind Platform, Darwin::DarwinEnvironmentKind Environment)
static const char * ArmMachOArchNameCPU(StringRef CPU)
static void addExportedSymbol(ArgStringList &CmdArgs, const char *Symbol)
Add an export directive for Symbol to the link command.
static StringRef getXcodeDeveloperPath(StringRef PathIntoXcode)
Take a path that speculatively points into Xcode and return the XCODE/Contents/Developer path if it i...
static void addSectalignToPage(const ArgList &Args, ArgStringList &CmdArgs, StringRef Segment, StringRef Section)
Add a sectalign directive for Segment and Section to the maximum expected page size for Darwin.
Defines types useful for describing an Objective-C runtime.
The information about the darwin SDK that was used during this compilation.
The basic abstraction for the target Objective-C runtime.
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
bool hasSubscripting() const
Does this runtime directly support the subscripting methods?
@ MacOSX
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
@ iOS
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
@ WatchOS
'watchos' is a variant of iOS for Apple's watchOS.
The base class of the type hierarchy.
Action - Represent an abstract compilation step to perform.
types::ID getType() const
ActionClass getKind() const
@ VerifyDebugInfoJobClass
Compilation - A set of tasks to perform for a single driver invocation.
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
void print(raw_ostream &OS) const
Print information about the detected CUDA installation.
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
std::string SysRoot
sysroot, if present
std::string GetTemporaryDirectory(StringRef Prefix) const
GetTemporaryDirectory - Return the pathname of a temporary directory to use as part of compilation; t...
DiagnosticBuilder Diag(unsigned DiagID) const
static bool GetReleaseVersion(StringRef Str, unsigned &Major, unsigned &Minor, unsigned &Micro, bool &HadExtra)
GetReleaseVersion - Parse (([0-9]+)(.
const llvm::opt::OptTable & getOpts() const
LTOKind getLTOMode(bool IsOffload=false) const
Get the specific kind of LTO being performed.
std::string ResourceDir
The path to the compiler resource directory.
bool isUsingLTO(bool IsOffload=false) const
Returns true if we are performing any kind of LTO.
std::string GetTemporaryPath(StringRef Prefix, StringRef Suffix) const
GetTemporaryPath - Return the pathname of a temporary file to use as part of compilation; the file wi...
std::string Dir
The path the driver executable was in, as invoked from the command line.
void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
void print(raw_ostream &OS) const
Print information about the detected ROCm installation.
bool needsStatsRt() const
bool linkRuntimes() const
bool needsUbsanRt() const
bool requiresMinimalRuntime() const
bool needsSharedRt() const
bool needsStableAbi() const
const char * getTypeTempSuffix(ID Id, bool CLStyle=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type,...
bool willEmitRemarks(const llvm::opt::ArgList &Args)
Expected< std::optional< DarwinSDKInfo > > parseDarwinSDKInfo(llvm::vfs::FileSystem &VFS, StringRef SDKRootPath)
Parse the SDK information from the SDKSettings.json file.
@ C
Languages that the frontend can parse and compile.
@ Result
The result type of a method or function.
llvm::VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS)
llvm::StringRef getAsString(SyncScope S)
static constexpr OSEnvPair macCatalystToMacOSPair()
Returns the os-environment mapping pair that's used to represent the Mac Catalyst -> macOS version ma...
static constexpr OSEnvPair macOStoMacCatalystPair()
Returns the os-environment mapping pair that's used to represent the macOS -> Mac Catalyst version ma...
static constexpr ResponseFileSupport None()
Returns a ResponseFileSupport indicating that response files are not supported.
static constexpr ResponseFileSupport AtFileUTF8()