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,
223 bool UsePlatformVersion)
const {
224 const Driver &D = getToolChain().getDriver();
229 if ((Version >= VersionTuple(100) || LinkerIsLLD) &&
230 !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
231 CmdArgs.push_back(
"-demangle");
233 if (Args.hasArg(options::OPT_rdynamic) &&
234 (Version >= VersionTuple(137) || LinkerIsLLD))
235 CmdArgs.push_back(
"-export_dynamic");
239 if (Args.hasFlag(options::OPT_fapplication_extension,
240 options::OPT_fno_application_extension,
false))
241 CmdArgs.push_back(
"-application_extension");
243 if (D.
isUsingLTO() && (Version >= VersionTuple(116) || LinkerIsLLD) &&
244 NeedsTempPath(Inputs)) {
245 std::string TmpPathName;
256 if (!TmpPathName.empty()) {
257 auto *TmpPath =
C.getArgs().MakeArgString(TmpPathName);
258 C.addTempFile(TmpPath);
259 CmdArgs.push_back(
"-object_path_lto");
260 CmdArgs.push_back(TmpPath);
273 if (Version >= VersionTuple(133) && !LinkerIsLLD) {
275 StringRef
P = llvm::sys::path::parent_path(D.
Dir);
277 llvm::sys::path::append(LibLTOPath,
"lib");
278 llvm::sys::path::append(LibLTOPath,
"libLTO.dylib");
279 CmdArgs.push_back(
"-lto_library");
280 CmdArgs.push_back(
C.getArgs().MakeArgString(LibLTOPath));
286 if (Version >= VersionTuple(262) &&
288 CmdArgs.push_back(
"-no_deduplicate");
291 Args.AddAllArgs(CmdArgs, options::OPT_static);
292 if (!Args.hasArg(options::OPT_static))
293 CmdArgs.push_back(
"-dynamic");
294 if (Args.hasArg(options::OPT_fgnu_runtime)) {
299 if (!Args.hasArg(options::OPT_dynamiclib)) {
300 AddMachOArch(Args, CmdArgs);
302 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
304 Args.AddLastArg(CmdArgs, options::OPT_bundle);
305 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
306 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
309 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
310 (A = Args.getLastArg(options::OPT_current__version)) ||
311 (A = Args.getLastArg(options::OPT_install__name)))
312 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
315 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
316 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
317 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
319 CmdArgs.push_back(
"-dylib");
322 if ((A = Args.getLastArg(options::OPT_bundle)) ||
323 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
324 (A = Args.getLastArg(options::OPT_client__name)) ||
325 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
326 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
327 (A = Args.getLastArg(options::OPT_private__bundle)))
328 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
331 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
332 "-dylib_compatibility_version");
333 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
334 "-dylib_current_version");
336 AddMachOArch(Args, CmdArgs);
338 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
339 "-dylib_install_name");
342 Args.AddLastArg(CmdArgs, options::OPT_all__load);
343 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
344 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
346 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
347 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
348 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
349 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
350 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
351 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
352 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
353 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
354 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
355 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
356 Args.AddAllArgs(CmdArgs, options::OPT_init);
359 if (Version >= VersionTuple(520) || LinkerIsLLD || UsePlatformVersion)
364 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
365 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
366 Args.AddLastArg(CmdArgs, options::OPT_single__module);
367 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
368 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
371 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
372 options::OPT_fno_pie, options::OPT_fno_PIE)) {
373 if (A->getOption().matches(options::OPT_fpie) ||
374 A->getOption().matches(options::OPT_fPIE))
375 CmdArgs.push_back(
"-pie");
377 CmdArgs.push_back(
"-no_pie");
381 if (
C.getDriver().embedBitcodeEnabled()) {
384 CmdArgs.push_back(
"-bitcode_bundle");
386 if (
C.getDriver().embedBitcodeMarkerOnly() &&
387 Version >= VersionTuple(278)) {
388 CmdArgs.push_back(
"-bitcode_process_mode");
389 CmdArgs.push_back(
"marker");
392 D.
Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
396 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
397 options::OPT_fno_global_isel)) {
398 if (A->getOption().matches(options::OPT_fglobal_isel)) {
399 CmdArgs.push_back(
"-mllvm");
400 CmdArgs.push_back(
"-global-isel");
402 CmdArgs.push_back(
"-mllvm");
403 CmdArgs.push_back(
"-global-isel-abort=0");
407 if (Args.hasArg(options::OPT_mkernel) ||
408 Args.hasArg(options::OPT_fapple_kext) ||
409 Args.hasArg(options::OPT_ffreestanding)) {
410 CmdArgs.push_back(
"-mllvm");
411 CmdArgs.push_back(
"-disable-atexit-based-global-dtor-lowering");
414 Args.AddLastArg(CmdArgs, options::OPT_prebind);
415 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
416 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
417 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
418 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
419 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
420 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
421 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
422 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
423 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
424 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
425 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
426 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
427 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
428 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
429 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
433 StringRef sysroot =
C.getSysRoot();
435 CmdArgs.push_back(
"-syslibroot");
436 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
437 }
else if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
438 CmdArgs.push_back(
"-syslibroot");
439 CmdArgs.push_back(A->getValue());
442 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
443 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
444 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
445 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
446 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
447 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
448 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
449 Args.AddAllArgs(CmdArgs, options::OPT_y);
450 Args.AddLastArg(CmdArgs, options::OPT_w);
451 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
452 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
453 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
454 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
455 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
456 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
457 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
458 Args.AddLastArg(CmdArgs, options::OPT_why_load);
459 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
460 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
461 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
462 Args.AddLastArg(CmdArgs, options::OPT_Mach);
468 : CSPGOGenerateArg->getValue());
469 llvm::sys::path::append(Path,
"default_%m.profraw");
470 CmdArgs.push_back(
"--cs-profile-generate");
471 CmdArgs.push_back(Args.MakeArgString(Twine(
"--cs-profile-path=") + Path));
474 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
475 if (Path.empty() || llvm::sys::fs::is_directory(Path))
476 llvm::sys::path::append(Path,
"default.profdata");
477 CmdArgs.push_back(Args.MakeArgString(Twine(
"--cs-profile-path=") + Path));
485 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
488 return Args.hasArg(options::OPT_fobjc_link_runtime);
492 const llvm::Triple &Triple) {
497 Args.getAllArgValues(options::OPT_arch).size() > 1;
498 bool hasExplicitOutputFile =
499 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
501 D.
Diag(diag::err_drv_invalid_output_with_multiple_archs)
502 <<
"-foptimization-record-file";
509 const llvm::Triple &Triple,
511 StringRef Format =
"yaml";
512 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
513 Format = A->getValue();
515 CmdArgs.push_back(
"-mllvm");
516 CmdArgs.push_back(
"-lto-pass-remarks-output");
517 CmdArgs.push_back(
"-mllvm");
519 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
521 CmdArgs.push_back(A->getValue());
523 assert(Output.
isFilename() &&
"Unexpected ld output.");
529 CmdArgs.push_back(Args.MakeArgString(F));
533 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
534 CmdArgs.push_back(
"-mllvm");
536 std::string(
"-lto-pass-remarks-filter=") + A->getValue();
537 CmdArgs.push_back(Args.MakeArgString(Passes));
540 if (!Format.empty()) {
541 CmdArgs.push_back(
"-mllvm");
542 Twine FormatArg = Twine(
"-lto-pass-remarks-format=") + Format;
543 CmdArgs.push_back(Args.MakeArgString(FormatArg));
547 CmdArgs.push_back(
"-mllvm");
548 CmdArgs.push_back(
"-lto-pass-remarks-with-hotness");
551 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
552 CmdArgs.push_back(
"-mllvm");
554 std::string(
"-lto-pass-remarks-hotness-threshold=") + A->getValue();
555 CmdArgs.push_back(Args.MakeArgString(Opt));
566 const char *LinkingOutput)
const {
567 assert(Output.
getType() == types::TY_Image &&
"Invalid linker output type.");
573 llvm::opt::ArgStringList InputFileList;
578 ArgStringList CmdArgs;
581 if (Args.hasArg(options::OPT_ccc_arcmt_check,
582 options::OPT_ccc_arcmt_migrate)) {
583 for (
const auto &Arg : Args)
586 Args.MakeArgString(getToolChain().GetProgramPath(
"touch"));
588 C.addCommand(std::make_unique<Command>(JA, *
this,
590 CmdArgs, std::nullopt, Output));
594 VersionTuple Version = getMachOToolChain().getLinkerVersion(Args);
598 Args.MakeArgString(getToolChain().GetLinkerPath(&LinkerIsLLD));
601 bool UsePlatformVersion = getToolChain().getTriple().isXROS();
605 AddLinkArgs(
C, Args, CmdArgs, Inputs, Version, LinkerIsLLD,
610 getToolChain().getTriple()))
615 Args.getLastArg(options::OPT_moutline, options::OPT_mno_outline)) {
616 if (A->getOption().matches(options::OPT_moutline)) {
617 if (getMachOToolChain().getMachOArchName(Args) ==
"arm64") {
618 CmdArgs.push_back(
"-mllvm");
619 CmdArgs.push_back(
"-enable-machine-outliner");
625 CmdArgs.push_back(
"-mllvm");
626 CmdArgs.push_back(
"-enable-machine-outliner=never");
633 CmdArgs.push_back(
"-mllvm");
634 CmdArgs.push_back(
"-enable-linkonceodr-outlining");
639 if (!StatsFile.empty()) {
640 CmdArgs.push_back(
"-mllvm");
641 CmdArgs.push_back(Args.MakeArgString(
"-lto-stats-file=" + StatsFile.str()));
646 Args.addAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
647 options::OPT_Z_Flag, options::OPT_u_Group});
652 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
653 CmdArgs.push_back(
"-ObjC");
655 CmdArgs.push_back(
"-o");
658 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
659 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
661 Args.AddAllArgs(CmdArgs, options::OPT_L);
666 for (
const auto &II : Inputs) {
667 if (!II.isFilename()) {
672 if (InputFileList.size() > 0)
678 InputFileList.push_back(II.getFilename());
683 if (getToolChain().getDriver().IsFlangMode()) {
688 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
692 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
694 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
696 CmdArgs.push_back(
"-framework");
697 CmdArgs.push_back(
"Foundation");
699 CmdArgs.push_back(
"-lobjc");
703 CmdArgs.push_back(
"-arch_multiple");
704 CmdArgs.push_back(
"-final_output");
705 CmdArgs.push_back(LinkingOutput);
708 if (Args.hasArg(options::OPT_fnested_functions))
709 CmdArgs.push_back(
"-allow_stack_execute");
711 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
714 if (!Parallelism.empty()) {
715 CmdArgs.push_back(
"-mllvm");
716 unsigned NumThreads =
717 llvm::get_threadpool_strategy(Parallelism)->compute_thread_count();
718 CmdArgs.push_back(Args.MakeArgString(
"-threads=" + Twine(NumThreads)));
721 if (getToolChain().ShouldLinkCXXStdlib(Args))
722 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
724 bool NoStdOrDefaultLibs =
725 Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs);
726 bool ForceLinkBuiltins = Args.hasArg(options::OPT_fapple_link_rtlib);
727 if (!NoStdOrDefaultLibs || ForceLinkBuiltins) {
732 if (NoStdOrDefaultLibs && ForceLinkBuiltins) {
733 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
"builtins");
736 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs,
740 Args.ClaimAllArgs(options::OPT_pthread);
741 Args.ClaimAllArgs(options::OPT_pthreads);
745 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
749 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
750 Args.AddAllArgs(CmdArgs, options::OPT_F);
753 for (
const Arg *A : Args.filtered(options::OPT_iframework))
754 CmdArgs.push_back(Args.MakeArgString(std::string(
"-F") + A->getValue()));
756 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
757 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
758 if (A->getValue() == StringRef(
"Accelerate")) {
759 CmdArgs.push_back(
"-framework");
760 CmdArgs.push_back(
"Accelerate");
769 bool NonStandardSearchPath =
false;
770 const auto &Triple = getToolChain().getTriple();
771 if (Triple.isDriverKit()) {
773 NonStandardSearchPath =
774 Version.getMajor() < 605 ||
775 (Version.getMajor() == 605 && Version.getMinor().value_or(0) < 1);
778 if (NonStandardSearchPath) {
779 if (
auto *Sysroot = Args.getLastArg(options::OPT_isysroot)) {
780 auto AddSearchPath = [&](StringRef Flag, StringRef SearchPath) {
783 llvm::sys::path::append(
P, SearchPath);
784 if (getToolChain().getVFS().exists(
P)) {
785 CmdArgs.push_back(Args.MakeArgString(Flag +
P));
788 AddSearchPath(
"-L",
"/usr/lib");
789 AddSearchPath(
"-F",
"/System/Library/Frameworks");
795 if (Version >= VersionTuple(705) || LinkerIsLLD) {
803 std::unique_ptr<Command>
Cmd = std::make_unique<Command>(
804 JA, *
this, ResponseSupport, Exec, CmdArgs, Inputs, Output);
805 Cmd->setInputFileList(std::move(InputFileList));
806 C.addCommand(std::move(
Cmd));
813 const char *LinkingOutput)
const {
814 const Driver &D = getToolChain().getDriver();
817 Args.ClaimAllArgs(options::OPT_g_Group);
819 Args.ClaimAllArgs(options::OPT_emit_llvm);
822 Args.ClaimAllArgs(options::OPT_w);
824 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
827 ArgStringList CmdArgs;
829 CmdArgs.push_back(
"-static");
830 CmdArgs.push_back(
"-D");
831 CmdArgs.push_back(
"-no_warning_for_no_symbols");
832 CmdArgs.push_back(
"-o");
835 for (
const auto &II : Inputs) {
836 if (II.isFilename()) {
837 CmdArgs.push_back(II.getFilename());
844 if (Output.
isFilename() && llvm::sys::fs::exists(OutputFileName)) {
845 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
846 D.
Diag(diag::err_drv_unable_to_remove_file) << EC.message();
851 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
852 C.addCommand(std::make_unique<Command>(JA, *
this,
854 Exec, CmdArgs, Inputs, Output));
861 const char *LinkingOutput)
const {
862 ArgStringList CmdArgs;
864 CmdArgs.push_back(
"-create");
865 assert(Output.
isFilename() &&
"Unexpected lipo output.");
867 CmdArgs.push_back(
"-output");
870 for (
const auto &II : Inputs) {
871 assert(II.isFilename() &&
"Unexpected lipo input.");
872 CmdArgs.push_back(II.getFilename());
875 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"lipo"));
877 Exec, CmdArgs, Inputs, Output));
884 const char *LinkingOutput)
const {
885 ArgStringList CmdArgs;
887 CmdArgs.push_back(
"-o");
890 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
892 assert(Input.
isFilename() &&
"Unexpected dsymutil input.");
896 Args.MakeArgString(getToolChain().GetProgramPath(
"dsymutil"));
898 Exec, CmdArgs, Inputs, Output));
905 const char *LinkingOutput)
const {
906 ArgStringList CmdArgs;
907 CmdArgs.push_back(
"--verify");
908 CmdArgs.push_back(
"--debug-info");
909 CmdArgs.push_back(
"--eh-frame");
910 CmdArgs.push_back(
"--quiet");
912 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
914 assert(Input.
isFilename() &&
"Unexpected verify input");
920 Args.MakeArgString(getToolChain().GetProgramPath(
"dwarfdump"));
922 Exec, CmdArgs, Inputs, Output));
933 :
MachO(D, Triple, Args), TargetInitialized(
false),
934 CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {}
940 if (Ty == types::TY_PP_Asm)
941 return types::TY_Asm;
961 auto T = llvm::Triple(Twine(
"arm64-apple-") +
962 llvm::Triple::getOSTypeName(llvm::Triple::XROS) +
984 ArgStringList &CC1Args)
const {
989 ArgStringList &CC1Args)
const {
998 return llvm::StringSwitch<const char *>(Arch)
999 .Case(
"armv6k",
"armv6")
1000 .Case(
"armv6m",
"armv6m")
1001 .Case(
"armv5tej",
"armv5")
1002 .Case(
"xscale",
"xscale")
1003 .Case(
"armv4t",
"armv4t")
1004 .Case(
"armv7",
"armv7")
1005 .Cases(
"armv7a",
"armv7-a",
"armv7")
1006 .Cases(
"armv7r",
"armv7-r",
"armv7")
1007 .Cases(
"armv7em",
"armv7e-m",
"armv7em")
1008 .Cases(
"armv7k",
"armv7-k",
"armv7k")
1009 .Cases(
"armv7m",
"armv7-m",
"armv7m")
1010 .Cases(
"armv7s",
"armv7-s",
"armv7s")
1015 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
1016 if (ArchKind == llvm::ARM::ArchKind::INVALID)
1018 StringRef Arch = llvm::ARM::getArchName(ArchKind);
1022 if (Arch.starts_with(
"armv5"))
1023 Arch = Arch.substr(0, 5);
1025 else if (Arch.starts_with(
"armv6") && !Arch.ends_with(
"6m"))
1026 Arch = Arch.substr(0, 5);
1028 else if (Arch.ends_with(
"v7a"))
1029 Arch = Arch.substr(0, 5);
1038 case llvm::Triple::aarch64_32:
1041 case llvm::Triple::aarch64: {
1047 case llvm::Triple::thumb:
1048 case llvm::Triple::arm:
1049 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
1053 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1062 if (LinkerVersion) {
1064 VersionTuple NewLinkerVersion;
1065 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1066 (void)NewLinkerVersion.tryParse(A->getValue());
1067 assert(NewLinkerVersion == LinkerVersion);
1069 return *LinkerVersion;
1072 VersionTuple NewLinkerVersion;
1073 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1074 if (NewLinkerVersion.tryParse(A->getValue()))
1076 << A->getAsString(Args);
1078 LinkerVersion = NewLinkerVersion;
1079 return *LinkerVersion;
1093 return Triple.getTriple();
1105 Str += llvm::Triple::getOSTypeName(llvm::Triple::XROS);
1109 Triple.setOSName(Str);
1111 return Triple.getTriple();
1123 return Dsymutil.get();
1127 return VerifyDebug.get();
1144 const ArgList &Args)
1145 :
Darwin(D, Triple, Args) {}
1149 CC1Args.push_back(
"-Wundef-prefix=TARGET_OS_");
1150 CC1Args.push_back(
"-Werror=undef-prefix");
1156 CC1Args.push_back(
"-Wdeprecated-objc-isa-usage");
1157 CC1Args.push_back(
"-Werror=deprecated-objc-isa-usage");
1162 CC1Args.push_back(
"-Werror=implicit-function-declaration");
1170 static constexpr llvm::StringLiteral XcodeAppSuffix(
1171 ".app/Contents/Developer");
1172 size_t Index = PathIntoXcode.find(XcodeAppSuffix);
1173 if (Index == StringRef::npos)
1175 return PathIntoXcode.take_front(Index + XcodeAppSuffix.size());
1179 ArgStringList &CmdArgs)
const {
1198 llvm::sys::path::remove_filename(
P);
1199 llvm::sys::path::remove_filename(
P);
1200 llvm::sys::path::append(
P,
"lib",
"arc");
1207 auto updatePath = [&](
const Arg *A) {
1211 if (XcodePathForSDK.empty())
1214 P = XcodePathForSDK;
1215 llvm::sys::path::append(
P,
"Toolchains/XcodeDefault.xctoolchain/usr",
1220 bool updated =
false;
1221 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot))
1222 updated = updatePath(A);
1225 if (
const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
1230 CmdArgs.push_back(
"-force_load");
1231 llvm::sys::path::append(
P,
"libarclite_");
1234 P +=
"watchsimulator";
1238 P +=
"appletvsimulator";
1242 P +=
"iphonesimulator";
1250 getDriver().
Diag(clang::diag::err_drv_darwin_sdk_missing_arclite) <<
P;
1252 CmdArgs.push_back(Args.MakeArgString(
P));
1265 bool IsShared)
const {
1268 if (Component !=
"builtins") {
1269 DarwinLibName += Component;
1271 DarwinLibName +=
"_";
1275 DarwinLibName += IsShared ?
"_dynamic.dylib" :
".a";
1277 llvm::sys::path::append(Dir,
"lib",
"darwin");
1279 llvm::sys::path::append(Dir,
"macho_embedded");
1282 llvm::sys::path::append(
P, DarwinLibName);
1288 const char *LibArg = Args.MakeArgString(
P);
1289 CmdArgs.push_back(LibArg);
1297 assert(DarwinLibName.ends_with(
".dylib") &&
"must be a dynamic library");
1301 CmdArgs.push_back(
"-rpath");
1302 CmdArgs.push_back(
"@executable_path");
1306 CmdArgs.push_back(
"-rpath");
1307 CmdArgs.push_back(Args.MakeArgString(Dir));
1328 llvm_unreachable(
"Unsupported platform");
1333 auto BeginSDK = llvm::sys::path::rbegin(isysroot);
1334 auto EndSDK = llvm::sys::path::rend(isysroot);
1335 for (
auto IT = BeginSDK; IT != EndSDK; ++IT) {
1336 StringRef SDK = *IT;
1337 if (SDK.ends_with(
".sdk"))
1338 return SDK.slice(0, SDK.size() - 4);
1364 llvm_unreachable(
"Unsupported platform");
1369 for (Arg *A : Args) {
1370 if (A->getOption().matches(options::OPT_exported__symbols__list))
1372 if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
1373 !A->getOption().matches(options::OPT_Xlinker))
1375 if (A->containsValue(
"-exported_symbols_list") ||
1376 A->containsValue(
"-exported_symbol"))
1384 CmdArgs.push_back(
"-exported_symbol");
1385 CmdArgs.push_back(Symbol);
1395 StringRef Segment, StringRef Section) {
1396 for (
const char *A : {
"-sectalign", Args.MakeArgString(Segment),
1397 Args.MakeArgString(Section),
"0x4000"})
1398 CmdArgs.push_back(A);
1402 ArgStringList &CmdArgs)
const {
1431 for (
auto IPSK : {llvm::IPSK_cnts, llvm::IPSK_bitmap, llvm::IPSK_data}) {
1433 Args, CmdArgs,
"__DATA",
1434 llvm::getInstrProfSectionName(IPSK, llvm::Triple::MachO,
1440void DarwinClang::AddLinkSanitizerLibArgs(
const ArgList &Args,
1441 ArgStringList &CmdArgs,
1442 StringRef Sanitizer,
1443 bool Shared)
const {
1449 const ArgList &Args)
const {
1450 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1451 StringRef
Value = A->getValue();
1452 if (
Value !=
"compiler-rt" &&
Value !=
"platform")
1453 getDriver().
Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1454 <<
Value <<
"darwin";
1461 ArgStringList &CmdArgs,
1462 bool ForceLinkBuiltinRT)
const {
1468 if (Args.hasArg(options::OPT_static) ||
1469 Args.hasArg(options::OPT_fapple_kext) ||
1470 Args.hasArg(options::OPT_mkernel)) {
1471 if (ForceLinkBuiltinRT)
1479 if (
const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1480 getDriver().
Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1487 const char *sanitizer =
nullptr;
1489 sanitizer =
"UndefinedBehaviorSanitizer";
1491 sanitizer =
"AddressSanitizer";
1493 sanitizer =
"ThreadSanitizer";
1496 getDriver().
Diag(diag::err_drv_unsupported_static_sanitizer_darwin)
1505 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan_abi",
false);
1508 "Static sanitizer runtimes not supported");
1509 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan");
1513 AddLinkSanitizerLibArgs(Args, CmdArgs,
"lsan");
1516 "Static sanitizer runtimes not supported");
1517 AddLinkSanitizerLibArgs(
1523 "Static sanitizer runtimes not supported");
1524 AddLinkSanitizerLibArgs(Args, CmdArgs,
"tsan");
1526 if (Sanitize.
needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1527 AddLinkSanitizerLibArgs(Args, CmdArgs,
"fuzzer",
false);
1534 AddLinkSanitizerLibArgs(Args, CmdArgs,
"stats");
1546 CmdArgs.push_back(
"-framework");
1547 CmdArgs.push_back(
"DriverKit");
1553 CmdArgs.push_back(
"-lSystem");
1562 CmdArgs.push_back(
"-lgcc_s.1");
1572 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1573 if (!SystemTriple.isMacOSX())
1574 return std::string(MacOSSDKVersion);
1575 VersionTuple SystemVersion;
1576 SystemTriple.getMacOSXVersion(SystemVersion);
1578 unsigned Major, Minor, Micro;
1582 return std::string(MacOSSDKVersion);
1583 VersionTuple SDKVersion(Major, Minor, Micro);
1585 if (SDKVersion > SystemVersion)
1586 return SystemVersion.getAsString();
1587 return std::string(MacOSSDKVersion);
1593struct DarwinPlatform {
1602 DeploymentTargetEnv,
1612 DarwinPlatformKind getPlatform()
const {
return Platform; }
1614 DarwinEnvironmentKind getEnvironment()
const {
return Environment; }
1616 void setEnvironment(DarwinEnvironmentKind Kind) {
1618 InferSimulatorFromArch =
false;
1621 StringRef getOSVersion()
const {
1622 if (Kind == OSVersionArg)
1623 return Argument->getValue();
1627 void setOSVersion(StringRef S) {
1628 assert(Kind == TargetArg &&
"Unexpected kind!");
1629 OSVersion = std::string(S);
1632 bool hasOSVersion()
const {
return HasOSVersion; }
1634 VersionTuple getNativeTargetVersion()
const {
1635 assert(Environment == DarwinEnvironmentKind::MacCatalyst &&
1636 "native target version is specified only for Mac Catalyst");
1637 return NativeTargetVersion;
1641 bool isExplicitlySpecified()
const {
return Kind <= DeploymentTargetEnv; }
1644 bool canInferSimulatorFromArch()
const {
return InferSimulatorFromArch; }
1646 const std::optional<llvm::Triple> &getTargetVariantTriple()
const {
1647 return TargetVariantTriple;
1651 void addOSVersionMinArgument(DerivedArgList &Args,
const OptTable &Opts) {
1654 assert(Kind != TargetArg && Kind != MTargetOSArg && Kind != OSVersionArg &&
1658 case DarwinPlatformKind::MacOS:
1659 Opt = options::OPT_mmacos_version_min_EQ;
1661 case DarwinPlatformKind::IPhoneOS:
1662 Opt = options::OPT_mios_version_min_EQ;
1664 case DarwinPlatformKind::TvOS:
1665 Opt = options::OPT_mtvos_version_min_EQ;
1667 case DarwinPlatformKind::WatchOS:
1668 Opt = options::OPT_mwatchos_version_min_EQ;
1670 case DarwinPlatformKind::XROS:
1673 case DarwinPlatformKind::DriverKit:
1677 Argument = Args.MakeJoinedArg(
nullptr, Opts.getOption(Opt), OSVersion);
1678 Args.append(Argument);
1683 std::string
getAsString(DerivedArgList &Args,
const OptTable &Opts) {
1688 case InferredFromSDK:
1689 case InferredFromArch:
1690 assert(Argument &&
"OS version argument not yet inferred");
1691 return Argument->getAsString(Args);
1692 case DeploymentTargetEnv:
1693 return (llvm::Twine(EnvVarName) +
"=" + OSVersion).str();
1695 llvm_unreachable(
"Unsupported Darwin Source Kind");
1698 void setEnvironment(llvm::Triple::EnvironmentType EnvType,
1699 const VersionTuple &OSVersion,
1700 const std::optional<DarwinSDKInfo> &SDKInfo) {
1702 case llvm::Triple::Simulator:
1703 Environment = DarwinEnvironmentKind::Simulator;
1705 case llvm::Triple::MacABI: {
1706 Environment = DarwinEnvironmentKind::MacCatalyst;
1708 NativeTargetVersion = VersionTuple(10, 15);
1709 if (HasOSVersion && SDKInfo) {
1710 if (
const auto *MacCatalystToMacOSMapping = SDKInfo->getVersionMapping(
1712 if (
auto MacOSVersion = MacCatalystToMacOSMapping->map(
1713 OSVersion, NativeTargetVersion, std::nullopt)) {
1714 NativeTargetVersion = *MacOSVersion;
1721 if (TargetVariantTriple) {
1722 auto TargetVariantVersion = TargetVariantTriple->getOSVersion();
1723 if (TargetVariantVersion.getMajor()) {
1724 if (TargetVariantVersion < NativeTargetVersion)
1725 NativeTargetVersion = TargetVariantVersion;
1735 static DarwinPlatform
1736 createFromTarget(
const llvm::Triple &TT, StringRef OSVersion, Arg *A,
1737 std::optional<llvm::Triple> TargetVariantTriple,
1738 const std::optional<DarwinSDKInfo> &SDKInfo) {
1739 DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
1741 VersionTuple OsVersion = TT.getOSVersion();
1742 if (OsVersion.getMajor() == 0)
1743 Result.HasOSVersion =
false;
1744 Result.TargetVariantTriple = TargetVariantTriple;
1745 Result.setEnvironment(TT.getEnvironment(), OsVersion, SDKInfo);
1748 static DarwinPlatform
1749 createFromMTargetOS(llvm::Triple::OSType OS, VersionTuple OSVersion,
1750 llvm::Triple::EnvironmentType Environment, Arg *A,
1751 const std::optional<DarwinSDKInfo> &SDKInfo) {
1752 DarwinPlatform Result(MTargetOSArg, getPlatformFromOS(OS),
1753 OSVersion.getAsString(), A);
1754 Result.InferSimulatorFromArch =
false;
1755 Result.setEnvironment(Environment, OSVersion, SDKInfo);
1758 static DarwinPlatform createOSVersionArg(DarwinPlatformKind Platform, Arg *A,
1760 DarwinPlatform Result{OSVersionArg, Platform, A};
1762 Result.Environment = DarwinEnvironmentKind::Simulator;
1765 static DarwinPlatform createDeploymentTargetEnv(DarwinPlatformKind Platform,
1766 StringRef EnvVarName,
1768 DarwinPlatform Result(DeploymentTargetEnv, Platform,
Value);
1769 Result.EnvVarName = EnvVarName;
1772 static DarwinPlatform createFromSDK(DarwinPlatformKind Platform,
1774 bool IsSimulator =
false) {
1775 DarwinPlatform Result(InferredFromSDK, Platform,
Value);
1777 Result.Environment = DarwinEnvironmentKind::Simulator;
1778 Result.InferSimulatorFromArch =
false;
1781 static DarwinPlatform createFromArch(llvm::Triple::OSType OS,
1783 return DarwinPlatform(InferredFromArch, getPlatformFromOS(OS),
Value);
1790 assert(Kind == InferredFromSDK &&
"can infer SDK info only");
1791 llvm::VersionTuple Version;
1792 bool IsValid = !Version.tryParse(OSVersion);
1794 assert(IsValid &&
"invalid SDK version");
1797 VersionTuple(Version.getMajor(), 0, 99));
1801 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, Arg *Argument)
1802 :
Kind(
Kind), Platform(Platform), Argument(Argument) {}
1803 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, StringRef
Value,
1804 Arg *Argument =
nullptr)
1805 :
Kind(
Kind), Platform(Platform), OSVersion(
Value), Argument(Argument) {}
1807 static DarwinPlatformKind getPlatformFromOS(llvm::Triple::OSType OS) {
1809 case llvm::Triple::Darwin:
1810 case llvm::Triple::MacOSX:
1811 return DarwinPlatformKind::MacOS;
1812 case llvm::Triple::IOS:
1813 return DarwinPlatformKind::IPhoneOS;
1814 case llvm::Triple::TvOS:
1815 return DarwinPlatformKind::TvOS;
1816 case llvm::Triple::WatchOS:
1817 return DarwinPlatformKind::WatchOS;
1818 case llvm::Triple::XROS:
1819 return DarwinPlatformKind::XROS;
1820 case llvm::Triple::DriverKit:
1821 return DarwinPlatformKind::DriverKit;
1823 llvm_unreachable(
"Unable to infer Darwin variant");
1828 DarwinPlatformKind Platform;
1829 DarwinEnvironmentKind Environment = DarwinEnvironmentKind::NativeEnvironment;
1830 VersionTuple NativeTargetVersion;
1831 std::string OSVersion;
1832 bool HasOSVersion =
true, InferSimulatorFromArch =
true;
1834 StringRef EnvVarName;
1835 std::optional<llvm::Triple> TargetVariantTriple;
1840std::optional<DarwinPlatform>
1841getDeploymentTargetFromOSVersionArg(DerivedArgList &Args,
1842 const Driver &TheDriver) {
1843 Arg *macOSVersion = Args.getLastArg(options::OPT_mmacos_version_min_EQ);
1844 Arg *iOSVersion = Args.getLastArg(options::OPT_mios_version_min_EQ,
1845 options::OPT_mios_simulator_version_min_EQ);
1847 Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1848 options::OPT_mtvos_simulator_version_min_EQ);
1849 Arg *WatchOSVersion =
1850 Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1851 options::OPT_mwatchos_simulator_version_min_EQ);
1853 if (iOSVersion || TvOSVersion || WatchOSVersion) {
1854 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1855 << macOSVersion->getAsString(Args)
1856 << (iOSVersion ? iOSVersion
1857 : TvOSVersion ? TvOSVersion : WatchOSVersion)
1860 return DarwinPlatform::createOSVersionArg(
Darwin::MacOS, macOSVersion,
1862 }
else if (iOSVersion) {
1863 if (TvOSVersion || WatchOSVersion) {
1864 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1865 << iOSVersion->getAsString(Args)
1866 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->
getAsString(Args);
1868 return DarwinPlatform::createOSVersionArg(
1870 iOSVersion->getOption().getID() ==
1871 options::OPT_mios_simulator_version_min_EQ);
1872 }
else if (TvOSVersion) {
1873 if (WatchOSVersion) {
1874 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1875 << TvOSVersion->getAsString(Args)
1876 << WatchOSVersion->getAsString(Args);
1878 return DarwinPlatform::createOSVersionArg(
1880 TvOSVersion->getOption().getID() ==
1881 options::OPT_mtvos_simulator_version_min_EQ);
1882 }
else if (WatchOSVersion)
1883 return DarwinPlatform::createOSVersionArg(
1885 WatchOSVersion->getOption().getID() ==
1886 options::OPT_mwatchos_simulator_version_min_EQ);
1887 return std::nullopt;
1892std::optional<DarwinPlatform>
1893getDeploymentTargetFromEnvironmentVariables(
const Driver &TheDriver,
1894 const llvm::Triple &Triple) {
1896 const char *EnvVars[] = {
1897 "MACOSX_DEPLOYMENT_TARGET",
1898 "IPHONEOS_DEPLOYMENT_TARGET",
1899 "TVOS_DEPLOYMENT_TARGET",
1900 "WATCHOS_DEPLOYMENT_TARGET",
1901 "DRIVERKIT_DEPLOYMENT_TARGET",
1902 "XROS_DEPLOYMENT_TARGET"
1905 "Missing platform");
1907 if (
char *
Env = ::getenv(I.value()))
1908 Targets[I.index()] =
Env;
1917 if (Triple.getArch() == llvm::Triple::arm ||
1918 Triple.getArch() == llvm::Triple::aarch64 ||
1919 Triple.getArch() == llvm::Triple::thumb)
1926 unsigned FirstTarget = std::size(Targets);
1927 for (
unsigned I = 0; I != std::size(Targets); ++I) {
1928 if (Targets[I].empty())
1930 if (FirstTarget == std::size(Targets))
1933 TheDriver.
Diag(diag::err_drv_conflicting_deployment_targets)
1934 << Targets[FirstTarget] << Targets[I];
1939 if (!
Target.value().empty())
1940 return DarwinPlatform::createDeploymentTargetEnv(
1944 return std::nullopt;
1949static StringRef dropSDKNamePrefix(StringRef SDKName) {
1950 size_t PrefixPos = SDKName.find(
'.');
1951 if (PrefixPos == StringRef::npos)
1953 return SDKName.substr(PrefixPos + 1);
1959std::optional<DarwinPlatform>
1960inferDeploymentTargetFromSDK(DerivedArgList &Args,
1961 const std::optional<DarwinSDKInfo> &SDKInfo) {
1962 const Arg *A = Args.getLastArg(options::OPT_isysroot);
1964 return std::nullopt;
1965 StringRef isysroot = A->getValue();
1968 return std::nullopt;
1970 std::string Version;
1973 Version = SDKInfo->getVersion().getAsString();
1977 size_t StartVer = SDK.find_first_of(
"0123456789");
1978 size_t EndVer = SDK.find_last_of(
"0123456789");
1979 if (StartVer != StringRef::npos && EndVer > StartVer)
1980 Version = std::string(SDK.slice(StartVer, EndVer + 1));
1982 if (Version.empty())
1983 return std::nullopt;
1985 auto CreatePlatformFromSDKName =
1986 [&](StringRef SDK) -> std::optional<DarwinPlatform> {
1987 if (SDK.starts_with(
"iPhoneOS") || SDK.starts_with(
"iPhoneSimulator"))
1988 return DarwinPlatform::createFromSDK(
1990 SDK.starts_with(
"iPhoneSimulator"));
1991 else if (SDK.starts_with(
"MacOSX"))
1994 else if (SDK.starts_with(
"WatchOS") || SDK.starts_with(
"WatchSimulator"))
1995 return DarwinPlatform::createFromSDK(
1997 SDK.starts_with(
"WatchSimulator"));
1998 else if (SDK.starts_with(
"AppleTVOS") ||
1999 SDK.starts_with(
"AppleTVSimulator"))
2000 return DarwinPlatform::createFromSDK(
2002 SDK.starts_with(
"AppleTVSimulator"));
2003 else if (SDK.starts_with(
"XR"))
2004 return DarwinPlatform::createFromSDK(
2006 SDK.contains(
"Simulator"));
2007 else if (SDK.starts_with(
"DriverKit"))
2009 return std::nullopt;
2011 if (
auto Result = CreatePlatformFromSDKName(SDK))
2014 return CreatePlatformFromSDKName(dropSDKNamePrefix(SDK));
2017std::string getOSVersion(llvm::Triple::OSType OS,
const llvm::Triple &Triple,
2018 const Driver &TheDriver) {
2019 VersionTuple OsVersion;
2020 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
2022 case llvm::Triple::Darwin:
2023 case llvm::Triple::MacOSX:
2026 if (Triple.isMacOSX() && SystemTriple.isMacOSX() &&
2027 !Triple.getOSMajorVersion())
2028 SystemTriple.getMacOSXVersion(OsVersion);
2029 else if (!Triple.getMacOSXVersion(OsVersion))
2030 TheDriver.
Diag(diag::err_drv_invalid_darwin_version)
2031 << Triple.getOSName();
2033 case llvm::Triple::IOS:
2034 if (Triple.isMacCatalystEnvironment() && !Triple.getOSMajorVersion()) {
2035 OsVersion = VersionTuple(13, 1);
2037 OsVersion = Triple.getiOSVersion();
2039 case llvm::Triple::TvOS:
2040 OsVersion = Triple.getOSVersion();
2042 case llvm::Triple::WatchOS:
2043 OsVersion = Triple.getWatchOSVersion();
2045 case llvm::Triple::XROS:
2046 OsVersion = Triple.getOSVersion();
2047 if (!OsVersion.getMajor())
2048 OsVersion = OsVersion.withMajorReplaced(1);
2050 case llvm::Triple::DriverKit:
2051 OsVersion = Triple.getDriverKitVersion();
2054 llvm_unreachable(
"Unexpected OS type");
2058 std::string OSVersion;
2059 llvm::raw_string_ostream(OSVersion)
2060 << OsVersion.getMajor() <<
'.' << OsVersion.getMinor().value_or(0) <<
'.'
2061 << OsVersion.getSubminor().value_or(0);
2066std::optional<DarwinPlatform>
2067inferDeploymentTargetFromArch(DerivedArgList &Args,
const Darwin &Toolchain,
2068 const llvm::Triple &Triple,
2069 const Driver &TheDriver) {
2070 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
2073 if (MachOArchName ==
"arm64" || MachOArchName ==
"arm64e")
2074 OSTy = llvm::Triple::MacOSX;
2075 else if (MachOArchName ==
"armv7" || MachOArchName ==
"armv7s")
2076 OSTy = llvm::Triple::IOS;
2077 else if (MachOArchName ==
"armv7k" || MachOArchName ==
"arm64_32")
2078 OSTy = llvm::Triple::WatchOS;
2079 else if (MachOArchName !=
"armv6m" && MachOArchName !=
"armv7m" &&
2080 MachOArchName !=
"armv7em")
2081 OSTy = llvm::Triple::MacOSX;
2082 if (OSTy == llvm::Triple::UnknownOS)
2083 return std::nullopt;
2084 return DarwinPlatform::createFromArch(OSTy,
2085 getOSVersion(OSTy, Triple, TheDriver));
2089std::optional<DarwinPlatform> getDeploymentTargetFromTargetArg(
2090 DerivedArgList &Args,
const llvm::Triple &Triple,
const Driver &TheDriver,
2091 const std::optional<DarwinSDKInfo> &SDKInfo) {
2092 if (!Args.hasArg(options::OPT_target))
2093 return std::nullopt;
2094 if (Triple.getOS() == llvm::Triple::Darwin ||
2095 Triple.getOS() == llvm::Triple::UnknownOS)
2096 return std::nullopt;
2097 std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
2098 std::optional<llvm::Triple> TargetVariantTriple;
2099 for (
const Arg *A : Args.filtered(options::OPT_darwin_target_variant)) {
2100 llvm::Triple TVT(A->getValue());
2102 if ((Triple.getArch() == llvm::Triple::aarch64 ||
2103 TVT.getArchName() == Triple.getArchName()) &&
2104 TVT.getArch() == Triple.getArch() &&
2105 TVT.getSubArch() == Triple.getSubArch() &&
2106 TVT.getVendor() == Triple.getVendor()) {
2107 if (TargetVariantTriple)
2112 if ((Triple.isMacOSX() && TVT.getOS() == llvm::Triple::IOS &&
2113 TVT.isMacCatalystEnvironment()) ||
2114 (TVT.isMacOSX() && Triple.getOS() == llvm::Triple::IOS &&
2115 Triple.isMacCatalystEnvironment())) {
2116 TargetVariantTriple = TVT;
2119 TheDriver.
Diag(diag::err_drv_target_variant_invalid)
2120 << A->getSpelling() << A->getValue();
2123 return DarwinPlatform::createFromTarget(Triple, OSVersion,
2124 Args.getLastArg(options::OPT_target),
2125 TargetVariantTriple, SDKInfo);
2129std::optional<DarwinPlatform> getDeploymentTargetFromMTargetOSArg(
2130 DerivedArgList &Args,
const Driver &TheDriver,
2131 const std::optional<DarwinSDKInfo> &SDKInfo) {
2132 auto *A = Args.getLastArg(options::OPT_mtargetos_EQ);
2134 return std::nullopt;
2135 llvm::Triple TT(llvm::Twine(
"unknown-apple-") + A->getValue());
2136 switch (TT.getOS()) {
2137 case llvm::Triple::MacOSX:
2138 case llvm::Triple::IOS:
2139 case llvm::Triple::TvOS:
2140 case llvm::Triple::WatchOS:
2141 case llvm::Triple::XROS:
2144 TheDriver.
Diag(diag::err_drv_invalid_os_in_arg)
2145 << TT.getOSName() << A->getAsString(Args);
2146 return std::nullopt;
2149 VersionTuple Version = TT.getOSVersion();
2150 if (!Version.getMajor()) {
2151 TheDriver.
Diag(diag::err_drv_invalid_version_number)
2152 << A->getAsString(Args);
2153 return std::nullopt;
2155 return DarwinPlatform::createFromMTargetOS(TT.getOS(), Version,
2156 TT.getEnvironment(), A, SDKInfo);
2159std::optional<DarwinSDKInfo> parseSDKSettings(llvm::vfs::FileSystem &VFS,
2160 const ArgList &Args,
2161 const Driver &TheDriver) {
2162 const Arg *A = Args.getLastArg(options::OPT_isysroot);
2164 return std::nullopt;
2165 StringRef isysroot = A->getValue();
2167 if (!SDKInfoOrErr) {
2168 llvm::consumeError(SDKInfoOrErr.takeError());
2169 TheDriver.
Diag(diag::warn_drv_darwin_sdk_invalid_settings);
2170 return std::nullopt;
2172 return *SDKInfoOrErr;
2177void Darwin::AddDeploymentTarget(DerivedArgList &Args)
const {
2183 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2185 if (!
getVFS().exists(A->getValue()))
2186 getDriver().
Diag(clang::diag::warn_missing_sysroot) << A->getValue();
2188 if (
char *env = ::getenv(
"SDKROOT")) {
2191 if (llvm::sys::path::is_absolute(env) &&
getVFS().exists(env) &&
2192 StringRef(env) !=
"/") {
2193 Args.append(Args.MakeSeparateArg(
2194 nullptr, Opts.getOption(options::OPT_isysroot), env));
2204 std::optional<DarwinPlatform> OSTarget =
2208 if (
const auto *MTargetOSArg = Args.getLastArg(options::OPT_mtargetos_EQ)) {
2209 std::string TargetArgStr = OSTarget->getAsString(Args, Opts);
2210 std::string MTargetOSArgStr = MTargetOSArg->getAsString(Args);
2212 << TargetArgStr << MTargetOSArgStr;
2214 std::optional<DarwinPlatform> OSVersionArgTarget =
2215 getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2216 if (OSVersionArgTarget) {
2217 unsigned TargetMajor, TargetMinor, TargetMicro;
2219 unsigned ArgMajor, ArgMinor, ArgMicro;
2221 if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
2223 TargetMinor, TargetMicro, TargetExtra) &&
2225 ArgMajor, ArgMinor, ArgMicro, ArgExtra) &&
2226 (VersionTuple(TargetMajor, TargetMinor, TargetMicro) !=
2227 VersionTuple(ArgMajor, ArgMinor, ArgMicro) ||
2228 TargetExtra != ArgExtra))) {
2231 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
2232 !OSTarget->hasOSVersion()) {
2233 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
2237 std::string OSVersionArg =
2238 OSVersionArgTarget->getAsString(Args, Opts);
2239 std::string TargetArg = OSTarget->getAsString(Args, Opts);
2241 << OSVersionArg << TargetArg;
2245 }
else if ((OSTarget = getDeploymentTargetFromMTargetOSArg(Args,
getDriver(),
2249 std::optional<DarwinPlatform> OSVersionArgTarget =
2250 getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2251 if (OSVersionArgTarget) {
2252 std::string MTargetOSArgStr = OSTarget->getAsString(Args, Opts);
2253 std::string OSVersionArgStr = OSVersionArgTarget->getAsString(Args, Opts);
2255 << MTargetOSArgStr << OSVersionArgStr;
2259 OSTarget = getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2267 std::optional<DarwinPlatform> SDKTarget =
2268 inferDeploymentTargetFromSDK(Args,
SDKInfo);
2270 OSTarget->setEnvironment(SDKTarget->getEnvironment());
2277 OSTarget = inferDeploymentTargetFromSDK(Args,
SDKInfo);
2281 SDKInfo = OSTarget->inferSDKInfo();
2290 assert(OSTarget &&
"Unable to infer Darwin variant");
2291 OSTarget->addOSVersionMinArgument(Args, Opts);
2294 unsigned Major, Minor, Micro;
2297 const unsigned MajorVersionLimit = 1000;
2299 if (Platform ==
MacOS) {
2302 HadExtra || Major < 10 || Major >= MajorVersionLimit || Minor >= 100 ||
2305 << OSTarget->getAsString(Args, Opts);
2309 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2311 << OSTarget->getAsString(Args, Opts);
2314 (Major < 13 || (Major == 13 && Minor < 1))) {
2316 << OSTarget->getAsString(Args, Opts);
2323 if (
getTriple().isArch32Bit() && Major >= 11) {
2325 if (OSTarget->isExplicitlySpecified()) {
2327 getDriver().
Diag(diag::err_invalid_macos_32bit_deployment_target);
2330 << OSTarget->getAsString(Args, Opts);
2338 }
else if (Platform ==
TvOS) {
2341 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2343 << OSTarget->getAsString(Args, Opts);
2344 }
else if (Platform ==
WatchOS) {
2347 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2349 << OSTarget->getAsString(Args, Opts);
2353 HadExtra || Major < 19 || Major >= MajorVersionLimit || Minor >= 100 ||
2356 << OSTarget->getAsString(Args, Opts);
2357 }
else if (Platform ==
XROS) {
2360 HadExtra || Major < 1 || Major >= MajorVersionLimit || Minor >= 100 ||
2363 << OSTarget->getAsString(Args, Opts);
2365 llvm_unreachable(
"unknown kind of Darwin platform");
2370 Platform !=
DriverKit && OSTarget->canInferSimulatorFromArch() &&
2374 VersionTuple NativeTargetVersion;
2376 NativeTargetVersion = OSTarget->getNativeTargetVersion();
2377 setTarget(Platform, Environment, Major, Minor, Micro, NativeTargetVersion);
2380 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2382 if (SDK.size() > 0) {
2383 size_t StartVer = SDK.find_first_of(
"0123456789");
2384 StringRef SDKName = SDK.slice(0, StartVer);
2397 const llvm::Triple &
T) {
2398 if (
T.isDriverKit()) {
2399 llvm::sys::path::append(Path,
"System",
"DriverKit");
2406DarwinClang::GetEffectiveSysroot(
const llvm::opt::ArgList &DriverArgs)
const {
2408 if (DriverArgs.hasArg(options::OPT_isysroot))
2409 Path = DriverArgs.getLastArgValue(options::OPT_isysroot);
2420 llvm::opt::ArgStringList &CC1Args)
const {
2425 bool NoStdInc = DriverArgs.hasArg(options::OPT_nostdinc);
2426 bool NoStdlibInc = DriverArgs.hasArg(options::OPT_nostdlibinc);
2427 bool NoBuiltinInc = DriverArgs.hasFlag(
2428 options::OPT_nobuiltininc, options::OPT_ibuiltininc,
false);
2429 bool ForceBuiltinInc = DriverArgs.hasFlag(
2430 options::OPT_ibuiltininc, options::OPT_nobuiltininc,
false);
2433 if (!NoStdInc && !NoStdlibInc) {
2435 llvm::sys::path::append(
P,
"usr",
"local",
"include");
2440 if (!(NoStdInc && !ForceBuiltinInc) && !NoBuiltinInc) {
2442 llvm::sys::path::append(
P,
"include");
2446 if (NoStdInc || NoStdlibInc)
2450 llvm::StringRef CIncludeDirs(C_INCLUDE_DIRS);
2451 if (!CIncludeDirs.empty()) {
2453 CIncludeDirs.split(dirs,
":");
2454 for (llvm::StringRef dir : dirs) {
2455 llvm::StringRef Prefix =
2456 llvm::sys::path::is_absolute(dir) ?
"" : llvm::StringRef(Sysroot);
2462 llvm::sys::path::append(
P,
"usr",
"include");
2467bool DarwinClang::AddGnuCPlusPlusIncludePaths(
const llvm::opt::ArgList &DriverArgs,
2468 llvm::opt::ArgStringList &CC1Args,
2470 llvm::StringRef Version,
2471 llvm::StringRef ArchDir,
2472 llvm::StringRef BitDir)
const {
2473 llvm::sys::path::append(
Base, Version);
2481 if (!ArchDir.empty())
2482 llvm::sys::path::append(
P, ArchDir);
2483 if (!BitDir.empty())
2484 llvm::sys::path::append(
P, BitDir);
2491 llvm::sys::path::append(
P,
"backward");
2499 const llvm::opt::ArgList &DriverArgs,
2500 llvm::opt::ArgStringList &CC1Args)
const {
2508 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
2509 options::OPT_nostdincxx))
2530 llvm::sys::path::append(InstallBin,
"..",
"include",
"c++",
"v1");
2531 if (
getVFS().exists(InstallBin)) {
2534 }
else if (DriverArgs.hasArg(options::OPT_v)) {
2535 llvm::errs() <<
"ignoring nonexistent directory \"" << InstallBin
2541 llvm::sys::path::append(SysrootUsr,
"usr",
"include",
"c++",
"v1");
2542 if (
getVFS().exists(SysrootUsr)) {
2545 }
else if (DriverArgs.hasArg(options::OPT_v)) {
2546 llvm::errs() <<
"ignoring nonexistent directory \"" << SysrootUsr
2556 llvm::sys::path::append(UsrIncludeCxx,
"usr",
"include",
"c++");
2559 bool IsBaseFound =
true;
2563 case llvm::Triple::x86:
2564 case llvm::Triple::x86_64:
2565 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2567 "i686-apple-darwin10",
2568 arch == llvm::Triple::x86_64 ?
"x86_64" :
"");
2569 IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2570 "4.0.0",
"i686-apple-darwin8",
2574 case llvm::Triple::arm:
2575 case llvm::Triple::thumb:
2576 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2578 "arm-apple-darwin10",
2580 IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2582 "arm-apple-darwin10",
2586 case llvm::Triple::aarch64:
2587 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2589 "arm64-apple-darwin10",
2603 ArgStringList &CmdArgs)
const {
2608 CmdArgs.push_back(
"-lc++");
2609 if (Args.hasArg(options::OPT_fexperimental_library))
2610 CmdArgs.push_back(
"-lc++experimental");
2620 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2622 llvm::sys::path::append(
P,
"usr",
"lib",
"libstdc++.dylib");
2625 llvm::sys::path::remove_filename(
P);
2626 llvm::sys::path::append(
P,
"libstdc++.6.dylib");
2628 CmdArgs.push_back(Args.MakeArgString(
P));
2637 if (!
getVFS().exists(
"/usr/lib/libstdc++.dylib") &&
2638 getVFS().exists(
"/usr/lib/libstdc++.6.dylib")) {
2639 CmdArgs.push_back(
"/usr/lib/libstdc++.6.dylib");
2644 CmdArgs.push_back(
"-lstdc++");
2650 ArgStringList &CmdArgs)
const {
2656 llvm::sys::path::append(
P,
"lib",
"darwin");
2660 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_watchos.a");
2662 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_tvos.a");
2664 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_ios.a");
2668 llvm::sys::path::append(
2669 P, llvm::Twine(
"libclang_rt.cc_kext_") +
2670 llvm::Triple::getOSTypeName(llvm::Triple::XROS) +
".a");
2672 llvm::sys::path::append(
P,
"libclang_rt.cc_kext.a");
2678 CmdArgs.push_back(Args.MakeArgString(
P));
2682 StringRef BoundArch,
2684 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2694 for (Arg *A : Args) {
2695 if (A->getOption().matches(options::OPT_Xarch__)) {
2698 StringRef XarchArch = A->getValue(0);
2700 (!BoundArch.empty() && XarchArch == BoundArch)))
2703 Arg *OriginalArg = A;
2711 for (
const char *
Value : A->getValues()) {
2712 DAL->AddSeparateArg(
2713 OriginalArg, Opts.getOption(options::OPT_Zlinker_input),
Value);
2727 case options::OPT_mkernel:
2728 case options::OPT_fapple_kext:
2730 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
2733 case options::OPT_dependency_file:
2734 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
2737 case options::OPT_gfull:
2738 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2740 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
2743 case options::OPT_gused:
2744 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2746 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
2749 case options::OPT_shared:
2750 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
2753 case options::OPT_fconstant_cfstrings:
2754 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
2757 case options::OPT_fno_constant_cfstrings:
2758 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
2761 case options::OPT_Wnonportable_cfstrings:
2763 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
2766 case options::OPT_Wno_nonportable_cfstrings:
2768 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
2775 if (!BoundArch.empty()) {
2776 StringRef Name = BoundArch;
2777 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
2778 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
2784 else if (Name ==
"ppc601")
2785 DAL->AddJoinedArg(
nullptr, MCpu,
"601");
2786 else if (Name ==
"ppc603")
2787 DAL->AddJoinedArg(
nullptr, MCpu,
"603");
2788 else if (Name ==
"ppc604")
2789 DAL->AddJoinedArg(
nullptr, MCpu,
"604");
2790 else if (Name ==
"ppc604e")
2791 DAL->AddJoinedArg(
nullptr, MCpu,
"604e");
2792 else if (Name ==
"ppc750")
2793 DAL->AddJoinedArg(
nullptr, MCpu,
"750");
2794 else if (Name ==
"ppc7400")
2795 DAL->AddJoinedArg(
nullptr, MCpu,
"7400");
2796 else if (Name ==
"ppc7450")
2797 DAL->AddJoinedArg(
nullptr, MCpu,
"7450");
2798 else if (Name ==
"ppc970")
2799 DAL->AddJoinedArg(
nullptr, MCpu,
"970");
2801 else if (Name ==
"ppc64" || Name ==
"ppc64le")
2802 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2804 else if (Name ==
"i386")
2806 else if (Name ==
"i486")
2807 DAL->AddJoinedArg(
nullptr, MArch,
"i486");
2808 else if (Name ==
"i586")
2809 DAL->AddJoinedArg(
nullptr, MArch,
"i586");
2810 else if (Name ==
"i686")
2811 DAL->AddJoinedArg(
nullptr, MArch,
"i686");
2812 else if (Name ==
"pentium")
2813 DAL->AddJoinedArg(
nullptr, MArch,
"pentium");
2814 else if (Name ==
"pentium2")
2815 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2816 else if (Name ==
"pentpro")
2817 DAL->AddJoinedArg(
nullptr, MArch,
"pentiumpro");
2818 else if (Name ==
"pentIIm3")
2819 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2821 else if (Name ==
"x86_64" || Name ==
"x86_64h")
2822 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2824 else if (Name ==
"arm")
2825 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2826 else if (Name ==
"armv4t")
2827 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2828 else if (Name ==
"armv5")
2829 DAL->AddJoinedArg(
nullptr, MArch,
"armv5tej");
2830 else if (Name ==
"xscale")
2831 DAL->AddJoinedArg(
nullptr, MArch,
"xscale");
2832 else if (Name ==
"armv6")
2833 DAL->AddJoinedArg(
nullptr, MArch,
"armv6k");
2834 else if (Name ==
"armv6m")
2835 DAL->AddJoinedArg(
nullptr, MArch,
"armv6m");
2836 else if (Name ==
"armv7")
2837 DAL->AddJoinedArg(
nullptr, MArch,
"armv7a");
2838 else if (Name ==
"armv7em")
2839 DAL->AddJoinedArg(
nullptr, MArch,
"armv7em");
2840 else if (Name ==
"armv7k")
2841 DAL->AddJoinedArg(
nullptr, MArch,
"armv7k");
2842 else if (Name ==
"armv7m")
2843 DAL->AddJoinedArg(
nullptr, MArch,
"armv7m");
2844 else if (Name ==
"armv7s")
2845 DAL->AddJoinedArg(
nullptr, MArch,
"armv7s");
2852 ArgStringList &CmdArgs,
2853 bool ForceLinkBuiltinRT)
const {
2862 CompilerRT += Args.hasArg(options::OPT_fPIC) ?
"_pic" :
"_static";
2868 llvm::Triple::OSType OS;
2874 OS = llvm::Triple::MacOSX;
2877 OS = llvm::Triple::IOS;
2880 OS = llvm::Triple::TvOS;
2883 OS = llvm::Triple::WatchOS;
2898 VersionTuple SDKVersion = SDKInfo->getVersion();
2899 switch (TargetPlatform) {
2901 return SDKVersion >= VersionTuple(99U);
2903 return SDKVersion >= VersionTuple(99U);
2905 return SDKVersion >= VersionTuple(99U);
2907 return SDKVersion >= VersionTuple(99U);
2909 return SDKVersion >= VersionTuple(99U);
2916 llvm::opt::ArgStringList &CC1Args,
2920 if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
2921 options::OPT_fno_aligned_allocation) &&
2923 CC1Args.push_back(
"-faligned-alloc-unavailable");
2929 CC1Args.push_back(
"-fcompatibility-qualified-id-block-type-checking");
2933 if (!DriverArgs.getLastArgNoClaim(
2934 options::OPT_fvisibility_inlines_hidden_static_local_var,
2935 options::OPT_fno_visibility_inlines_hidden_static_local_var))
2936 CC1Args.push_back(
"-fvisibility-inlines-hidden-static-local-var");
2950 CC1Args.push_back(
"-fbuiltin-headers-in-system-modules");
2952 if (!DriverArgs.hasArgNoClaim(options::OPT_fdefine_target_os_macros,
2953 options::OPT_fno_define_target_os_macros))
2954 CC1Args.push_back(
"-fdefine-target-os-macros");
2958 const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CC1ASArgs)
const {
2960 CC1ASArgs.push_back(
"-darwin-target-variant-triple");
2967 auto EmitTargetSDKVersionArg = [&](
const VersionTuple &
V) {
2969 llvm::raw_string_ostream OS(Arg);
2970 OS <<
"-target-sdk-version=" <<
V;
2971 CC1ASArgs.push_back(Args.MakeArgString(OS.str()));
2975 if (
const auto *MacOStoMacCatalystMapping =
SDKInfo->getVersionMapping(
2977 std::optional<VersionTuple> SDKVersion = MacOStoMacCatalystMapping->map(
2980 EmitTargetSDKVersionArg(
2984 EmitTargetSDKVersionArg(
SDKInfo->getVersion());
2992 llvm::raw_string_ostream OS(Arg);
2993 OS <<
"-darwin-target-variant-sdk-version=" <<
SDKInfo->getVersion();
2994 CC1ASArgs.push_back(Args.MakeArgString(OS.str()));
2995 }
else if (
const auto *MacOStoMacCatalystMapping =
2998 if (std::optional<VersionTuple> SDKVersion =
2999 MacOStoMacCatalystMapping->map(
3003 llvm::raw_string_ostream OS(Arg);
3004 OS <<
"-darwin-target-variant-sdk-version=" << *SDKVersion;
3005 CC1ASArgs.push_back(Args.MakeArgString(OS.str()));
3016 DerivedArgList *DAL =
3020 if (BoundArch.empty())
3026 AddDeploymentTarget(*DAL);
3034 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
3037 if (A->getOption().getID() != options::OPT_mkernel &&
3038 A->getOption().getID() != options::OPT_fapple_kext)
3040 assert(it != ie &&
"unexpected argument translation");
3042 assert(A->getOption().getID() == options::OPT_static &&
3043 "missing expected -static argument");
3050 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
3051 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
3052 options::OPT_fno_omit_frame_pointer,
false))
3053 getDriver().
Diag(clang::diag::warn_drv_unsupported_opt_for_target)
3054 <<
"-fomit-frame-pointer" << BoundArch;
3063 if (
getArch() == llvm::Triple::x86_64 ||
3065 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
3067 return (
getArch() == llvm::Triple::aarch64 ||
3068 getArch() == llvm::Triple::aarch64_32)
3076 if (
const char *S = ::getenv(
"RC_DEBUG_OPTIONS"))
3077 return S[0] !=
'\0';
3082 if (
const char *S = ::getenv(
"RC_DEBUG_PREFIX_MAP"))
3091 return llvm::ExceptionHandling::None;
3095 if (Triple.isWatchABI())
3096 return llvm::ExceptionHandling::DwarfCFI;
3098 return llvm::ExceptionHandling::SjLj;
3113 return (
getArch() == llvm::Triple::x86_64 ||
3114 getArch() == llvm::Triple::aarch64);
3123 ArgStringList &CmdArgs)
const {
3126 assert(!
isTargetXROS() &&
"xrOS always uses -platform-version");
3129 CmdArgs.push_back(
"-watchos_version_min");
3131 CmdArgs.push_back(
"-watchos_simulator_version_min");
3133 CmdArgs.push_back(
"-tvos_version_min");
3135 CmdArgs.push_back(
"-tvos_simulator_version_min");
3137 CmdArgs.push_back(
"-driverkit_version_min");
3139 CmdArgs.push_back(
"-ios_simulator_version_min");
3141 CmdArgs.push_back(
"-iphoneos_version_min");
3143 CmdArgs.push_back(
"-maccatalyst_version_min");
3146 CmdArgs.push_back(
"-macosx_version_min");
3152 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3155 VersionTuple VariantTargetVersion;
3157 CmdArgs.push_back(
"-macosx_version_min");
3162 "unexpected target variant triple");
3163 CmdArgs.push_back(
"-maccatalyst_version_min");
3166 VersionTuple MinTgtVers =
3168 if (MinTgtVers.getMajor() && MinTgtVers > VariantTargetVersion)
3169 VariantTargetVersion = MinTgtVers;
3170 CmdArgs.push_back(Args.MakeArgString(VariantTargetVersion.getAsString()));
3181 return "mac catalyst";
3192 llvm_unreachable(
"invalid platform");
3196 llvm::opt::ArgStringList &CmdArgs)
const {
3197 auto EmitPlatformVersionArg =
3200 const llvm::Triple &TT) {
3203 CmdArgs.push_back(
"-platform_version");
3204 std::string PlatformName =
3207 PlatformName +=
"-simulator";
3208 CmdArgs.push_back(Args.MakeArgString(PlatformName));
3217 VersionTuple MinTgtVers = TT.getMinimumSupportedOSVersion();
3220 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3225 std::optional<VersionTuple> iOSSDKVersion;
3227 if (
const auto *MacOStoMacCatalystMapping =
3230 iOSSDKVersion = MacOStoMacCatalystMapping->map(
3231 SDKInfo->getVersion().withoutBuild(),
3235 CmdArgs.push_back(Args.MakeArgString(
3236 (iOSSDKVersion ? *iOSSDKVersion
3243 VersionTuple SDKVersion =
SDKInfo->getVersion().withoutBuild();
3244 if (!SDKVersion.getMinor())
3245 SDKVersion = VersionTuple(SDKVersion.getMajor(), 0);
3246 CmdArgs.push_back(Args.MakeArgString(SDKVersion.getAsString()));
3257 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3266 VersionTuple TargetVariantVersion;
3274 "unexpected target variant triple");
3279 EmitPlatformVersionArg(TargetVariantVersion, Platform, Environment,
3285 ArgStringList &CmdArgs) {
3289 CmdArgs.push_back(
"-ldylib1.o");
3296 CmdArgs.push_back(
"-ldylib1.o");
3298 CmdArgs.push_back(
"-ldylib1.10.5.o");
3303 ArgStringList &CmdArgs) {
3304 if (Args.hasArg(options::OPT_static))
3309 CmdArgs.push_back(
"-lbundle1.o");
3314 ArgStringList &CmdArgs) {
3316 if (Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_object) ||
3317 Args.hasArg(options::OPT_preload)) {
3318 CmdArgs.push_back(
"-lgcrt0.o");
3320 CmdArgs.push_back(
"-lgcrt1.o");
3330 CmdArgs.push_back(
"-no_new_main");
3332 D.
getDriver().
Diag(diag::err_drv_clang_unsupported_opt_pg_darwin)
3338 ArgStringList &CmdArgs) {
3341 if (D.
getArch() == llvm::Triple::aarch64)
3344 CmdArgs.push_back(
"-lcrt1.o");
3346 CmdArgs.push_back(
"-lcrt1.3.1.o");
3353 CmdArgs.push_back(
"-lcrt1.o");
3355 CmdArgs.push_back(
"-lcrt1.10.5.o");
3357 CmdArgs.push_back(
"-lcrt1.10.6.o");
3362 ArgStringList &CmdArgs)
const {
3364 if (Args.hasArg(options::OPT_dynamiclib))
3366 else if (Args.hasArg(options::OPT_bundle))
3370 else if (Args.hasArg(options::OPT_static) ||
3371 Args.hasArg(options::OPT_object) ||
3372 Args.hasArg(options::OPT_preload))
3373 CmdArgs.push_back(
"-lcrt0.o");
3377 if (
isTargetMacOS() && Args.hasArg(options::OPT_shared_libgcc) &&
3379 const char *Str = Args.MakeArgString(
GetFilePath(
"crt3.o"));
3380 CmdArgs.push_back(Str);
3392 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
3393 const bool IsAArch64 =
getTriple().getArch() == llvm::Triple::aarch64;
3395 Res |= SanitizerKind::Address;
3396 Res |= SanitizerKind::PointerCompare;
3397 Res |= SanitizerKind::PointerSubtract;
3398 Res |= SanitizerKind::Leak;
3399 Res |= SanitizerKind::Fuzzer;
3400 Res |= SanitizerKind::FuzzerNoLink;
3401 Res |= SanitizerKind::ObjCCast;
3408 Res |= SanitizerKind::Vptr;
3410 if ((IsX86_64 || IsAArch64) &&
3413 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 bool sdkSupportsBuiltinModules(const Darwin::DarwinPlatformKind &TargetPlatform, const std::optional< DarwinSDKInfo > &SDKInfo)
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.
llvm::MachO::Target Target
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.
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.
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)
The JSON file list parser is used to communicate input to InstallAPI.
Expected< std::optional< DarwinSDKInfo > > parseDarwinSDKInfo(llvm::vfs::FileSystem &VFS, StringRef SDKRootPath)
Parse the SDK information from the SDKSettings.json file.
@ Result
The result type of a method or function.
llvm::VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS)
const FunctionProtoType * T
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()