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"
38 return VersionTuple(13, 1);
54 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
55 .Cases(
"ppc",
"ppc601",
"ppc603",
"ppc604",
"ppc604e", llvm::Triple::ppc)
56 .Cases(
"ppc750",
"ppc7400",
"ppc7450",
"ppc970", llvm::Triple::ppc)
57 .Case(
"ppc64", llvm::Triple::ppc64)
58 .Cases(
"i386",
"i486",
"i486SX",
"i586",
"i686", llvm::Triple::x86)
59 .Cases(
"pentium",
"pentpro",
"pentIIm3",
"pentIIm5",
"pentium4",
61 .Cases(
"x86_64",
"x86_64h", llvm::Triple::x86_64)
63 .Cases(
"arm",
"armv4t",
"armv5",
"armv6",
"armv6m", llvm::Triple::arm)
64 .Cases(
"armv7",
"armv7em",
"armv7k",
"armv7m", llvm::Triple::arm)
65 .Cases(
"armv7s",
"xscale", llvm::Triple::arm)
66 .Cases(
"arm64",
"arm64e", llvm::Triple::aarch64)
67 .Case(
"arm64_32", llvm::Triple::aarch64_32)
68 .Case(
"r600", llvm::Triple::r600)
69 .Case(
"amdgcn", llvm::Triple::amdgcn)
70 .Case(
"nvptx", llvm::Triple::nvptx)
71 .Case(
"nvptx64", llvm::Triple::nvptx64)
72 .Case(
"amdil", llvm::Triple::amdil)
73 .Case(
"spir", llvm::Triple::spir)
74 .Default(llvm::Triple::UnknownArch);
79 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseArch(Str);
81 if (Arch != llvm::Triple::UnknownArch)
84 if (ArchKind == llvm::ARM::ArchKind::ARMV6M ||
85 ArchKind == llvm::ARM::ArchKind::ARMV7M ||
86 ArchKind == llvm::ARM::ArchKind::ARMV7EM) {
87 T.setOS(llvm::Triple::UnknownOS);
88 T.setObjectFormat(llvm::Triple::MachO);
96 const char *LinkingOutput)
const {
99 ArgStringList CmdArgs;
101 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
105 const Action *SourceAction = &JA;
107 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
108 SourceAction = SourceAction->
getInputs()[0];
116 if (Args.hasArg(options::OPT_fno_integrated_as)) {
117 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
118 CmdArgs.push_back(
"-Q");
122 if (SourceAction->
getType() == types::TY_Asm ||
123 SourceAction->
getType() == types::TY_PP_Asm) {
124 if (Args.hasArg(options::OPT_gstabs))
125 CmdArgs.push_back(
"--gstabs");
126 else if (Args.hasArg(options::OPT_g_Group))
127 CmdArgs.push_back(
"-g");
134 if (T.isX86() || Args.hasArg(options::OPT_force__cpusubtype__ALL))
135 CmdArgs.push_back(
"-force_cpusubtype_ALL");
138 (((Args.hasArg(options::OPT_mkernel) ||
139 Args.hasArg(options::OPT_fapple_kext)) &&
141 Args.hasArg(options::OPT_static)))
142 CmdArgs.push_back(
"-static");
144 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
146 assert(Output.
isFilename() &&
"Unexpected lipo output.");
147 CmdArgs.push_back(
"-o");
150 assert(Input.
isFilename() &&
"Invalid input.");
155 const char *Exec = Args.MakeArgString(
getToolChain().GetProgramPath(
"as"));
157 Exec, CmdArgs, Inputs, Output));
160void darwin::MachOTool::anchor() {}
163 ArgStringList &CmdArgs)
const {
164 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
167 CmdArgs.push_back(
"-arch");
168 CmdArgs.push_back(Args.MakeArgString(ArchName));
171 if (ArchName ==
"arm")
172 CmdArgs.push_back(
"-force_cpusubtype_ALL");
175bool darwin::Linker::NeedsTempPath(
const InputInfoList &Inputs)
const {
179 for (
const auto &Input : Inputs)
180 if (Input.getType() != types::TY_Object)
194 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
195 if (A->getOption().matches(options::OPT_O0))
197 if (A->getOption().matches(options::OPT_O))
198 return llvm::StringSwitch<bool>(A->getValue())
204 if (!IsLinkerOnlyAction)
209void darwin::Linker::AddLinkArgs(
Compilation &
C,
const ArgList &Args,
210 ArgStringList &CmdArgs,
212 VersionTuple Version,
bool LinkerIsLLD)
const {
213 const Driver &D = getToolChain().getDriver();
218 if ((Version >= VersionTuple(100) || LinkerIsLLD) &&
219 !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
220 CmdArgs.push_back(
"-demangle");
222 if (Args.hasArg(options::OPT_rdynamic) &&
223 (Version >= VersionTuple(137) || LinkerIsLLD))
224 CmdArgs.push_back(
"-export_dynamic");
228 if (Args.hasFlag(options::OPT_fapplication_extension,
229 options::OPT_fno_application_extension,
false))
230 CmdArgs.push_back(
"-application_extension");
232 if (D.
isUsingLTO() && (Version >= VersionTuple(116) || LinkerIsLLD) &&
233 NeedsTempPath(Inputs)) {
234 std::string TmpPathName;
245 if (!TmpPathName.empty()) {
246 auto *TmpPath =
C.getArgs().MakeArgString(TmpPathName);
247 C.addTempFile(TmpPath);
248 CmdArgs.push_back(
"-object_path_lto");
249 CmdArgs.push_back(TmpPath);
262 if (Version >= VersionTuple(133) && !LinkerIsLLD) {
264 StringRef
P = llvm::sys::path::parent_path(D.
Dir);
266 llvm::sys::path::append(LibLTOPath,
"lib");
267 llvm::sys::path::append(LibLTOPath,
"libLTO.dylib");
268 CmdArgs.push_back(
"-lto_library");
269 CmdArgs.push_back(
C.getArgs().MakeArgString(LibLTOPath));
275 if (Version >= VersionTuple(262) &&
277 CmdArgs.push_back(
"-no_deduplicate");
280 Args.AddAllArgs(CmdArgs, options::OPT_static);
281 if (!Args.hasArg(options::OPT_static))
282 CmdArgs.push_back(
"-dynamic");
283 if (Args.hasArg(options::OPT_fgnu_runtime)) {
288 if (!Args.hasArg(options::OPT_dynamiclib)) {
289 AddMachOArch(Args, CmdArgs);
291 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
293 Args.AddLastArg(CmdArgs, options::OPT_bundle);
294 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
295 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
298 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
299 (A = Args.getLastArg(options::OPT_current__version)) ||
300 (A = Args.getLastArg(options::OPT_install__name)))
301 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
304 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
305 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
306 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
308 CmdArgs.push_back(
"-dylib");
311 if ((A = Args.getLastArg(options::OPT_bundle)) ||
312 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
313 (A = Args.getLastArg(options::OPT_client__name)) ||
314 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
315 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
316 (A = Args.getLastArg(options::OPT_private__bundle)))
317 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
320 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
321 "-dylib_compatibility_version");
322 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
323 "-dylib_current_version");
325 AddMachOArch(Args, CmdArgs);
327 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
328 "-dylib_install_name");
331 Args.AddLastArg(CmdArgs, options::OPT_all__load);
332 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
333 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
335 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
336 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
337 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
338 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
339 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
340 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
341 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
342 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
343 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
344 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
345 Args.AddAllArgs(CmdArgs, options::OPT_init);
348 if (Version >= VersionTuple(520) || LinkerIsLLD)
353 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
354 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
355 Args.AddLastArg(CmdArgs, options::OPT_single__module);
356 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
357 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
360 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
361 options::OPT_fno_pie, options::OPT_fno_PIE)) {
362 if (A->getOption().matches(options::OPT_fpie) ||
363 A->getOption().matches(options::OPT_fPIE))
364 CmdArgs.push_back(
"-pie");
366 CmdArgs.push_back(
"-no_pie");
370 if (
C.getDriver().embedBitcodeEnabled()) {
373 CmdArgs.push_back(
"-bitcode_bundle");
375 if (
C.getDriver().embedBitcodeMarkerOnly() &&
376 Version >= VersionTuple(278)) {
377 CmdArgs.push_back(
"-bitcode_process_mode");
378 CmdArgs.push_back(
"marker");
381 D.
Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
385 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
386 options::OPT_fno_global_isel)) {
387 if (A->getOption().matches(options::OPT_fglobal_isel)) {
388 CmdArgs.push_back(
"-mllvm");
389 CmdArgs.push_back(
"-global-isel");
391 CmdArgs.push_back(
"-mllvm");
392 CmdArgs.push_back(
"-global-isel-abort=0");
396 Args.AddLastArg(CmdArgs, options::OPT_prebind);
397 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
398 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
399 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
400 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
401 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
402 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
403 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
404 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
405 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
406 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
407 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
408 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
409 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
410 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
411 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
415 StringRef sysroot =
C.getSysRoot();
417 CmdArgs.push_back(
"-syslibroot");
418 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
419 }
else if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
420 CmdArgs.push_back(
"-syslibroot");
421 CmdArgs.push_back(A->getValue());
424 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
425 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
426 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
427 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
428 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
429 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
430 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
431 Args.AddAllArgs(CmdArgs, options::OPT_y);
432 Args.AddLastArg(CmdArgs, options::OPT_w);
433 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
434 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
435 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
436 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
437 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
438 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
439 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
440 Args.AddLastArg(CmdArgs, options::OPT_why_load);
441 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
442 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
443 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
444 Args.AddLastArg(CmdArgs, options::OPT_Mach);
450 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
453 return Args.hasArg(options::OPT_fobjc_link_runtime);
457 const llvm::Triple &Triple) {
462 Args.getAllArgValues(options::OPT_arch).size() > 1;
463 bool hasExplicitOutputFile =
464 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
466 D.
Diag(diag::err_drv_invalid_output_with_multiple_archs)
467 <<
"-foptimization-record-file";
474 const llvm::Triple &Triple,
476 StringRef Format =
"yaml";
477 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
478 Format = A->getValue();
480 CmdArgs.push_back(
"-mllvm");
481 CmdArgs.push_back(
"-lto-pass-remarks-output");
482 CmdArgs.push_back(
"-mllvm");
484 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
486 CmdArgs.push_back(A->getValue());
488 assert(Output.
isFilename() &&
"Unexpected ld output.");
494 CmdArgs.push_back(Args.MakeArgString(F));
498 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
499 CmdArgs.push_back(
"-mllvm");
501 std::string(
"-lto-pass-remarks-filter=") + A->getValue();
502 CmdArgs.push_back(Args.MakeArgString(Passes));
505 if (!Format.empty()) {
506 CmdArgs.push_back(
"-mllvm");
507 Twine FormatArg = Twine(
"-lto-pass-remarks-format=") + Format;
508 CmdArgs.push_back(Args.MakeArgString(FormatArg));
512 CmdArgs.push_back(
"-mllvm");
513 CmdArgs.push_back(
"-lto-pass-remarks-with-hotness");
516 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
517 CmdArgs.push_back(
"-mllvm");
519 std::string(
"-lto-pass-remarks-hotness-threshold=") + A->getValue();
520 CmdArgs.push_back(Args.MakeArgString(Opt));
531 const char *LinkingOutput)
const {
532 assert(Output.
getType() == types::TY_Image &&
"Invalid linker output type.");
538 llvm::opt::ArgStringList InputFileList;
543 ArgStringList CmdArgs;
546 if (Args.hasArg(options::OPT_ccc_arcmt_check,
547 options::OPT_ccc_arcmt_migrate)) {
548 for (
const auto &Arg : Args)
551 Args.MakeArgString(getToolChain().GetProgramPath(
"touch"));
553 C.addCommand(std::make_unique<Command>(JA, *
this,
555 CmdArgs, std::nullopt, Output));
559 VersionTuple Version = getMachOToolChain().getLinkerVersion(Args);
563 Args.MakeArgString(getToolChain().GetLinkerPath(&LinkerIsLLD));
567 AddLinkArgs(
C, Args, CmdArgs, Inputs, Version, LinkerIsLLD);
571 getToolChain().getTriple()))
576 Args.getLastArg(options::OPT_moutline, options::OPT_mno_outline)) {
577 if (A->getOption().matches(options::OPT_moutline)) {
578 if (getMachOToolChain().getMachOArchName(Args) ==
"arm64") {
579 CmdArgs.push_back(
"-mllvm");
580 CmdArgs.push_back(
"-enable-machine-outliner");
583 CmdArgs.push_back(
"-mllvm");
584 CmdArgs.push_back(
"-enable-linkonceodr-outlining");
590 CmdArgs.push_back(
"-mllvm");
591 CmdArgs.push_back(
"-enable-machine-outliner=never");
598 if (!StatsFile.empty()) {
599 CmdArgs.push_back(
"-mllvm");
600 CmdArgs.push_back(Args.MakeArgString(
"-lto-stats-file=" + StatsFile.str()));
605 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
606 options::OPT_Z_Flag, options::OPT_u_Group,
607 options::OPT_e, options::OPT_r});
612 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
613 CmdArgs.push_back(
"-ObjC");
615 CmdArgs.push_back(
"-o");
618 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
619 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
621 Args.AddAllArgs(CmdArgs, options::OPT_L);
626 for (
const auto &II : Inputs) {
627 if (!II.isFilename()) {
632 if (InputFileList.size() > 0)
638 InputFileList.push_back(II.getFilename());
643 if (getToolChain().getDriver().IsFlangMode()) {
648 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
652 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
654 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
656 CmdArgs.push_back(
"-framework");
657 CmdArgs.push_back(
"Foundation");
659 CmdArgs.push_back(
"-lobjc");
663 CmdArgs.push_back(
"-arch_multiple");
664 CmdArgs.push_back(
"-final_output");
665 CmdArgs.push_back(LinkingOutput);
668 if (Args.hasArg(options::OPT_fnested_functions))
669 CmdArgs.push_back(
"-allow_stack_execute");
671 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
674 if (!Parallelism.empty()) {
675 CmdArgs.push_back(
"-mllvm");
676 unsigned NumThreads =
677 llvm::get_threadpool_strategy(Parallelism)->compute_thread_count();
678 CmdArgs.push_back(Args.MakeArgString(
"-threads=" + Twine(NumThreads)));
681 if (getToolChain().ShouldLinkCXXStdlib(Args))
682 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
684 bool NoStdOrDefaultLibs =
685 Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs);
686 bool ForceLinkBuiltins = Args.hasArg(options::OPT_fapple_link_rtlib);
687 if (!NoStdOrDefaultLibs || ForceLinkBuiltins) {
692 if (NoStdOrDefaultLibs && ForceLinkBuiltins) {
693 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
"builtins");
696 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs,
700 Args.ClaimAllArgs(options::OPT_pthread);
701 Args.ClaimAllArgs(options::OPT_pthreads);
705 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
709 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
710 Args.AddAllArgs(CmdArgs, options::OPT_F);
713 for (
const Arg *A : Args.filtered(options::OPT_iframework))
714 CmdArgs.push_back(Args.MakeArgString(std::string(
"-F") + A->getValue()));
716 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
717 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
718 if (A->getValue() == StringRef(
"Accelerate")) {
719 CmdArgs.push_back(
"-framework");
720 CmdArgs.push_back(
"Accelerate");
729 bool NonStandardSearchPath =
false;
730 const auto &Triple = getToolChain().getTriple();
731 if (Triple.isDriverKit()) {
733 NonStandardSearchPath =
734 Version.getMajor() < 605 ||
735 (Version.getMajor() == 605 && Version.getMinor().value_or(0) < 1);
738 if (NonStandardSearchPath) {
739 if (
auto *Sysroot = Args.getLastArg(options::OPT_isysroot)) {
740 auto AddSearchPath = [&](StringRef Flag, StringRef SearchPath) {
743 llvm::sys::path::append(
P, SearchPath);
744 if (getToolChain().getVFS().exists(
P)) {
745 CmdArgs.push_back(Args.MakeArgString(Flag +
P));
748 AddSearchPath(
"-L",
"/usr/lib");
749 AddSearchPath(
"-F",
"/System/Library/Frameworks");
755 if (Version >= VersionTuple(705) || LinkerIsLLD) {
763 std::unique_ptr<Command>
Cmd = std::make_unique<Command>(
764 JA, *
this, ResponseSupport, Exec, CmdArgs, Inputs, Output);
765 Cmd->setInputFileList(std::move(InputFileList));
766 C.addCommand(std::move(
Cmd));
773 const char *LinkingOutput)
const {
774 const Driver &D = getToolChain().getDriver();
777 Args.ClaimAllArgs(options::OPT_g_Group);
779 Args.ClaimAllArgs(options::OPT_emit_llvm);
782 Args.ClaimAllArgs(options::OPT_w);
784 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
787 ArgStringList CmdArgs;
789 CmdArgs.push_back(
"-static");
790 CmdArgs.push_back(
"-D");
791 CmdArgs.push_back(
"-no_warning_for_no_symbols");
792 CmdArgs.push_back(
"-o");
795 for (
const auto &II : Inputs) {
796 if (II.isFilename()) {
797 CmdArgs.push_back(II.getFilename());
804 if (Output.
isFilename() && llvm::sys::fs::exists(OutputFileName)) {
805 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
806 D.
Diag(diag::err_drv_unable_to_remove_file) << EC.message();
811 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
812 C.addCommand(std::make_unique<Command>(JA, *
this,
814 Exec, CmdArgs, Inputs, Output));
821 const char *LinkingOutput)
const {
822 ArgStringList CmdArgs;
824 CmdArgs.push_back(
"-create");
825 assert(Output.
isFilename() &&
"Unexpected lipo output.");
827 CmdArgs.push_back(
"-output");
830 for (
const auto &II : Inputs) {
831 assert(II.isFilename() &&
"Unexpected lipo input.");
832 CmdArgs.push_back(II.getFilename());
835 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"lipo"));
837 Exec, CmdArgs, Inputs, Output));
844 const char *LinkingOutput)
const {
845 ArgStringList CmdArgs;
847 CmdArgs.push_back(
"-o");
850 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
852 assert(Input.
isFilename() &&
"Unexpected dsymutil input.");
856 Args.MakeArgString(getToolChain().GetProgramPath(
"dsymutil"));
858 Exec, CmdArgs, Inputs, Output));
865 const char *LinkingOutput)
const {
866 ArgStringList CmdArgs;
867 CmdArgs.push_back(
"--verify");
868 CmdArgs.push_back(
"--debug-info");
869 CmdArgs.push_back(
"--eh-frame");
870 CmdArgs.push_back(
"--quiet");
872 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
874 assert(Input.
isFilename() &&
"Unexpected verify input");
880 Args.MakeArgString(getToolChain().GetProgramPath(
"dwarfdump"));
882 Exec, CmdArgs, Inputs, Output));
895 :
MachO(D, Triple, Args), TargetInitialized(
false),
896 CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {}
902 if (Ty == types::TY_PP_Asm)
903 return types::TY_Asm;
939 ArgStringList &CC1Args)
const {
944 ArgStringList &CC1Args)
const {
953 return llvm::StringSwitch<const char *>(Arch)
954 .Case(
"armv6k",
"armv6")
955 .Case(
"armv6m",
"armv6m")
956 .Case(
"armv5tej",
"armv5")
957 .Case(
"xscale",
"xscale")
958 .Case(
"armv4t",
"armv4t")
959 .Case(
"armv7",
"armv7")
960 .Cases(
"armv7a",
"armv7-a",
"armv7")
961 .Cases(
"armv7r",
"armv7-r",
"armv7")
962 .Cases(
"armv7em",
"armv7e-m",
"armv7em")
963 .Cases(
"armv7k",
"armv7-k",
"armv7k")
964 .Cases(
"armv7m",
"armv7-m",
"armv7m")
965 .Cases(
"armv7s",
"armv7-s",
"armv7s")
970 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
971 if (ArchKind == llvm::ARM::ArchKind::INVALID)
973 StringRef Arch = llvm::ARM::getArchName(ArchKind);
977 if (Arch.startswith(
"armv5"))
978 Arch = Arch.substr(0, 5);
980 else if (Arch.startswith(
"armv6") && !Arch.endswith(
"6m"))
981 Arch = Arch.substr(0, 5);
983 else if (Arch.endswith(
"v7a"))
984 Arch = Arch.substr(0, 5);
993 case llvm::Triple::aarch64_32:
996 case llvm::Triple::aarch64: {
1002 case llvm::Triple::thumb:
1003 case llvm::Triple::arm:
1004 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
1008 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1017 if (LinkerVersion) {
1019 VersionTuple NewLinkerVersion;
1020 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1021 (void)NewLinkerVersion.tryParse(A->getValue());
1022 assert(NewLinkerVersion == LinkerVersion);
1024 return *LinkerVersion;
1027 VersionTuple NewLinkerVersion;
1028 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1029 if (NewLinkerVersion.tryParse(A->getValue()))
1031 << A->getAsString(Args);
1033 LinkerVersion = NewLinkerVersion;
1034 return *LinkerVersion;
1048 return Triple.getTriple();
1062 Triple.setOSName(Str);
1064 return Triple.getTriple();
1076 return Dsymutil.get();
1080 return VerifyDebug.get();
1097 const ArgList &Args)
1098 :
Darwin(D, Triple, Args) {}
1102 CC1Args.push_back(
"-Wundef-prefix=TARGET_OS_");
1103 CC1Args.push_back(
"-Werror=undef-prefix");
1109 CC1Args.push_back(
"-Wdeprecated-objc-isa-usage");
1110 CC1Args.push_back(
"-Werror=deprecated-objc-isa-usage");
1115 CC1Args.push_back(
"-Werror=implicit-function-declaration");
1123 static constexpr llvm::StringLiteral XcodeAppSuffix(
1124 ".app/Contents/Developer");
1125 size_t Index = PathIntoXcode.find(XcodeAppSuffix);
1126 if (Index == StringRef::npos)
1128 return PathIntoXcode.take_front(Index + XcodeAppSuffix.size());
1132 ArgStringList &CmdArgs)
const {
1149 llvm::sys::path::remove_filename(
P);
1150 llvm::sys::path::remove_filename(
P);
1151 llvm::sys::path::append(
P,
"lib",
"arc");
1158 auto updatePath = [&](
const Arg *A) {
1162 if (XcodePathForSDK.empty())
1165 P = XcodePathForSDK;
1166 llvm::sys::path::append(
P,
"Toolchains/XcodeDefault.xctoolchain/usr",
1171 bool updated =
false;
1172 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot))
1173 updated = updatePath(A);
1176 if (
const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
1181 CmdArgs.push_back(
"-force_load");
1182 llvm::sys::path::append(
P,
"libarclite_");
1185 P +=
"watchsimulator";
1189 P +=
"appletvsimulator";
1193 P +=
"iphonesimulator";
1200 CmdArgs.push_back(Args.MakeArgString(
P));
1213 bool IsShared)
const {
1216 if (Component !=
"builtins") {
1217 DarwinLibName += Component;
1219 DarwinLibName +=
"_";
1223 DarwinLibName += IsShared ?
"_dynamic.dylib" :
".a";
1225 llvm::sys::path::append(Dir,
"lib",
"darwin");
1227 llvm::sys::path::append(Dir,
"macho_embedded");
1230 llvm::sys::path::append(
P, DarwinLibName);
1236 const char *LibArg = Args.MakeArgString(
P);
1237 CmdArgs.push_back(LibArg);
1245 assert(DarwinLibName.endswith(
".dylib") &&
"must be a dynamic library");
1249 CmdArgs.push_back(
"-rpath");
1250 CmdArgs.push_back(
"@executable_path");
1254 CmdArgs.push_back(
"-rpath");
1255 CmdArgs.push_back(Args.MakeArgString(Dir));
1274 llvm_unreachable(
"Unsupported platform");
1279 auto BeginSDK = llvm::sys::path::rbegin(isysroot);
1280 auto EndSDK = llvm::sys::path::rend(isysroot);
1281 for (
auto IT = BeginSDK; IT != EndSDK; ++IT) {
1282 StringRef SDK = *IT;
1283 if (SDK.endswith(
".sdk"))
1284 return SDK.slice(0, SDK.size() - 4);
1307 llvm_unreachable(
"Unsupported platform");
1312 for (Arg *A : Args) {
1313 if (A->getOption().matches(options::OPT_exported__symbols__list))
1315 if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
1316 !A->getOption().matches(options::OPT_Xlinker))
1318 if (A->containsValue(
"-exported_symbols_list") ||
1319 A->containsValue(
"-exported_symbol"))
1327 CmdArgs.push_back(
"-exported_symbol");
1328 CmdArgs.push_back(Symbol);
1338 StringRef Segment, StringRef Section) {
1339 for (
const char *A : {
"-sectalign", Args.MakeArgString(Segment),
1340 Args.MakeArgString(Section),
"0x4000"})
1341 CmdArgs.push_back(A);
1345 ArgStringList &CmdArgs)
const {
1374 for (
auto IPSK : {llvm::IPSK_cnts, llvm::IPSK_data}) {
1376 Args, CmdArgs,
"__DATA",
1377 llvm::getInstrProfSectionName(IPSK, llvm::Triple::MachO,
1383void DarwinClang::AddLinkSanitizerLibArgs(
const ArgList &Args,
1384 ArgStringList &CmdArgs,
1385 StringRef Sanitizer,
1386 bool Shared)
const {
1392 const ArgList &Args)
const {
1393 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1394 StringRef
Value = A->getValue();
1395 if (
Value !=
"compiler-rt" &&
Value !=
"platform")
1396 getDriver().
Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1397 <<
Value <<
"darwin";
1404 ArgStringList &CmdArgs,
1405 bool ForceLinkBuiltinRT)
const {
1411 if (Args.hasArg(options::OPT_static) ||
1412 Args.hasArg(options::OPT_fapple_kext) ||
1413 Args.hasArg(options::OPT_mkernel)) {
1414 if (ForceLinkBuiltinRT)
1422 if (
const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1423 getDriver().
Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1430 const char *sanitizer =
nullptr;
1432 sanitizer =
"UndefinedBehaviorSanitizer";
1434 sanitizer =
"AddressSanitizer";
1436 sanitizer =
"ThreadSanitizer";
1439 getDriver().
Diag(diag::err_drv_unsupported_static_sanitizer_darwin)
1448 "Static sanitizer runtimes not supported");
1449 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan");
1452 AddLinkSanitizerLibArgs(Args, CmdArgs,
"lsan");
1455 "Static sanitizer runtimes not supported");
1456 AddLinkSanitizerLibArgs(
1462 "Static sanitizer runtimes not supported");
1463 AddLinkSanitizerLibArgs(Args, CmdArgs,
"tsan");
1465 if (Sanitize.
needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1466 AddLinkSanitizerLibArgs(Args, CmdArgs,
"fuzzer",
false);
1473 AddLinkSanitizerLibArgs(Args, CmdArgs,
"stats");
1485 CmdArgs.push_back(
"-framework");
1486 CmdArgs.push_back(
"DriverKit");
1492 CmdArgs.push_back(
"-lSystem");
1501 CmdArgs.push_back(
"-lgcc_s.1");
1511 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1512 if (!SystemTriple.isMacOSX())
1513 return std::string(MacOSSDKVersion);
1514 VersionTuple SystemVersion;
1515 SystemTriple.getMacOSXVersion(SystemVersion);
1517 unsigned Major, Minor, Micro;
1521 return std::string(MacOSSDKVersion);
1522 VersionTuple SDKVersion(Major, Minor, Micro);
1524 if (SDKVersion > SystemVersion)
1525 return SystemVersion.getAsString();
1526 return std::string(MacOSSDKVersion);
1532struct DarwinPlatform {
1541 DeploymentTargetEnv,
1551 DarwinPlatformKind getPlatform()
const {
return Platform; }
1553 DarwinEnvironmentKind getEnvironment()
const {
return Environment; }
1555 void setEnvironment(DarwinEnvironmentKind Kind) {
1557 InferSimulatorFromArch =
false;
1560 StringRef getOSVersion()
const {
1561 if (Kind == OSVersionArg)
1562 return Argument->getValue();
1566 void setOSVersion(StringRef S) {
1567 assert(Kind == TargetArg &&
"Unexpected kind!");
1568 OSVersion = std::string(S);
1571 bool hasOSVersion()
const {
return HasOSVersion; }
1573 VersionTuple getNativeTargetVersion()
const {
1574 assert(Environment == DarwinEnvironmentKind::MacCatalyst &&
1575 "native target version is specified only for Mac Catalyst");
1576 return NativeTargetVersion;
1580 bool isExplicitlySpecified()
const {
return Kind <= DeploymentTargetEnv; }
1583 bool canInferSimulatorFromArch()
const {
return InferSimulatorFromArch; }
1585 const std::optional<llvm::Triple> &getTargetVariantTriple()
const {
1586 return TargetVariantTriple;
1590 void addOSVersionMinArgument(DerivedArgList &Args,
const OptTable &Opts) {
1593 assert(Kind != TargetArg && Kind != MTargetOSArg && Kind != OSVersionArg &&
1597 case DarwinPlatformKind::MacOS:
1598 Opt = options::OPT_mmacos_version_min_EQ;
1600 case DarwinPlatformKind::IPhoneOS:
1601 Opt = options::OPT_mios_version_min_EQ;
1603 case DarwinPlatformKind::TvOS:
1604 Opt = options::OPT_mtvos_version_min_EQ;
1606 case DarwinPlatformKind::WatchOS:
1607 Opt = options::OPT_mwatchos_version_min_EQ;
1609 case DarwinPlatformKind::DriverKit:
1613 Argument = Args.MakeJoinedArg(
nullptr, Opts.getOption(Opt), OSVersion);
1614 Args.append(Argument);
1619 std::string
getAsString(DerivedArgList &Args,
const OptTable &Opts) {
1624 case InferredFromSDK:
1625 case InferredFromArch:
1626 assert(Argument &&
"OS version argument not yet inferred");
1627 return Argument->getAsString(Args);
1628 case DeploymentTargetEnv:
1629 return (llvm::Twine(EnvVarName) +
"=" + OSVersion).str();
1631 llvm_unreachable(
"Unsupported Darwin Source Kind");
1634 void setEnvironment(llvm::Triple::EnvironmentType EnvType,
1635 const VersionTuple &OSVersion,
1636 const std::optional<DarwinSDKInfo> &SDKInfo) {
1638 case llvm::Triple::Simulator:
1639 Environment = DarwinEnvironmentKind::Simulator;
1641 case llvm::Triple::MacABI: {
1642 Environment = DarwinEnvironmentKind::MacCatalyst;
1644 NativeTargetVersion = VersionTuple(10, 15);
1645 if (HasOSVersion && SDKInfo) {
1646 if (
const auto *MacCatalystToMacOSMapping = SDKInfo->getVersionMapping(
1648 if (
auto MacOSVersion = MacCatalystToMacOSMapping->map(
1649 OSVersion, NativeTargetVersion, std::nullopt)) {
1650 NativeTargetVersion = *MacOSVersion;
1657 if (TargetVariantTriple) {
1658 auto TargetVariantVersion = TargetVariantTriple->getOSVersion();
1659 if (TargetVariantVersion.getMajor()) {
1660 if (TargetVariantVersion < NativeTargetVersion)
1661 NativeTargetVersion = TargetVariantVersion;
1671 static DarwinPlatform
1672 createFromTarget(
const llvm::Triple &TT, StringRef OSVersion, Arg *A,
1673 std::optional<llvm::Triple> TargetVariantTriple,
1674 const std::optional<DarwinSDKInfo> &SDKInfo) {
1675 DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
1677 VersionTuple OsVersion = TT.getOSVersion();
1678 if (OsVersion.getMajor() == 0)
1679 Result.HasOSVersion =
false;
1680 Result.TargetVariantTriple = TargetVariantTriple;
1681 Result.setEnvironment(TT.getEnvironment(), OsVersion, SDKInfo);
1684 static DarwinPlatform
1685 createFromMTargetOS(llvm::Triple::OSType
OS, VersionTuple OSVersion,
1686 llvm::Triple::EnvironmentType Environment, Arg *A,
1687 const std::optional<DarwinSDKInfo> &SDKInfo) {
1688 DarwinPlatform Result(MTargetOSArg, getPlatformFromOS(
OS),
1689 OSVersion.getAsString(), A);
1690 Result.InferSimulatorFromArch =
false;
1691 Result.setEnvironment(Environment, OSVersion, SDKInfo);
1694 static DarwinPlatform createOSVersionArg(DarwinPlatformKind Platform, Arg *A,
1696 DarwinPlatform Result{OSVersionArg, Platform, A};
1698 Result.Environment = DarwinEnvironmentKind::Simulator;
1701 static DarwinPlatform createDeploymentTargetEnv(DarwinPlatformKind Platform,
1702 StringRef EnvVarName,
1704 DarwinPlatform Result(DeploymentTargetEnv, Platform,
Value);
1705 Result.EnvVarName = EnvVarName;
1708 static DarwinPlatform createFromSDK(DarwinPlatformKind Platform,
1710 bool IsSimulator =
false) {
1711 DarwinPlatform Result(InferredFromSDK, Platform,
Value);
1713 Result.Environment = DarwinEnvironmentKind::Simulator;
1714 Result.InferSimulatorFromArch =
false;
1717 static DarwinPlatform createFromArch(llvm::Triple::OSType
OS,
1719 return DarwinPlatform(InferredFromArch, getPlatformFromOS(
OS),
Value);
1726 assert(Kind == InferredFromSDK &&
"can infer SDK info only");
1727 llvm::VersionTuple Version;
1728 bool IsValid = !Version.tryParse(OSVersion);
1730 assert(IsValid &&
"invalid SDK version");
1733 VersionTuple(Version.getMajor(), 0, 99));
1737 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, Arg *Argument)
1738 :
Kind(
Kind), Platform(Platform), Argument(Argument) {}
1739 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, StringRef
Value,
1740 Arg *Argument =
nullptr)
1741 :
Kind(
Kind), Platform(Platform), OSVersion(
Value), Argument(Argument) {}
1743 static DarwinPlatformKind getPlatformFromOS(llvm::Triple::OSType
OS) {
1745 case llvm::Triple::Darwin:
1746 case llvm::Triple::MacOSX:
1747 return DarwinPlatformKind::MacOS;
1748 case llvm::Triple::IOS:
1749 return DarwinPlatformKind::IPhoneOS;
1750 case llvm::Triple::TvOS:
1751 return DarwinPlatformKind::TvOS;
1752 case llvm::Triple::WatchOS:
1753 return DarwinPlatformKind::WatchOS;
1754 case llvm::Triple::DriverKit:
1755 return DarwinPlatformKind::DriverKit;
1757 llvm_unreachable(
"Unable to infer Darwin variant");
1762 DarwinPlatformKind Platform;
1763 DarwinEnvironmentKind Environment = DarwinEnvironmentKind::NativeEnvironment;
1764 VersionTuple NativeTargetVersion;
1765 std::string OSVersion;
1766 bool HasOSVersion =
true, InferSimulatorFromArch =
true;
1768 StringRef EnvVarName;
1769 std::optional<llvm::Triple> TargetVariantTriple;
1774std::optional<DarwinPlatform>
1775getDeploymentTargetFromOSVersionArg(DerivedArgList &Args,
1776 const Driver &TheDriver) {
1777 Arg *macOSVersion = Args.getLastArg(options::OPT_mmacos_version_min_EQ);
1778 Arg *iOSVersion = Args.getLastArg(options::OPT_mios_version_min_EQ,
1779 options::OPT_mios_simulator_version_min_EQ);
1781 Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1782 options::OPT_mtvos_simulator_version_min_EQ);
1783 Arg *WatchOSVersion =
1784 Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1785 options::OPT_mwatchos_simulator_version_min_EQ);
1787 if (iOSVersion || TvOSVersion || WatchOSVersion) {
1788 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1789 << macOSVersion->getAsString(Args)
1790 << (iOSVersion ? iOSVersion
1791 : TvOSVersion ? TvOSVersion : WatchOSVersion)
1794 return DarwinPlatform::createOSVersionArg(
Darwin::MacOS, macOSVersion,
1796 }
else if (iOSVersion) {
1797 if (TvOSVersion || WatchOSVersion) {
1798 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1799 << iOSVersion->getAsString(Args)
1800 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->
getAsString(Args);
1802 return DarwinPlatform::createOSVersionArg(
1804 iOSVersion->getOption().getID() ==
1805 options::OPT_mios_simulator_version_min_EQ);
1806 }
else if (TvOSVersion) {
1807 if (WatchOSVersion) {
1808 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1809 << TvOSVersion->getAsString(Args)
1810 << WatchOSVersion->getAsString(Args);
1812 return DarwinPlatform::createOSVersionArg(
1814 TvOSVersion->getOption().getID() ==
1815 options::OPT_mtvos_simulator_version_min_EQ);
1816 }
else if (WatchOSVersion)
1817 return DarwinPlatform::createOSVersionArg(
1819 WatchOSVersion->getOption().getID() ==
1820 options::OPT_mwatchos_simulator_version_min_EQ);
1821 return std::nullopt;
1826std::optional<DarwinPlatform>
1827getDeploymentTargetFromEnvironmentVariables(
const Driver &TheDriver,
1828 const llvm::Triple &Triple) {
1830 const char *EnvVars[] = {
1831 "MACOSX_DEPLOYMENT_TARGET",
1832 "IPHONEOS_DEPLOYMENT_TARGET",
1833 "TVOS_DEPLOYMENT_TARGET",
1834 "WATCHOS_DEPLOYMENT_TARGET",
1835 "DRIVERKIT_DEPLOYMENT_TARGET",
1838 "Missing platform");
1840 if (
char *Env = ::getenv(I.value()))
1841 Targets[I.index()] = Env;
1849 if (Triple.getArch() == llvm::Triple::arm ||
1850 Triple.getArch() == llvm::Triple::aarch64 ||
1851 Triple.getArch() == llvm::Triple::thumb)
1858 unsigned FirstTarget = std::size(Targets);
1859 for (
unsigned I = 0; I != std::size(Targets); ++I) {
1860 if (Targets[I].empty())
1862 if (FirstTarget == std::size(Targets))
1865 TheDriver.
Diag(diag::err_drv_conflicting_deployment_targets)
1866 << Targets[FirstTarget] << Targets[I];
1871 if (!
Target.value().empty())
1872 return DarwinPlatform::createDeploymentTargetEnv(
1876 return std::nullopt;
1881static StringRef dropSDKNamePrefix(StringRef SDKName) {
1882 size_t PrefixPos = SDKName.find(
'.');
1883 if (PrefixPos == StringRef::npos)
1885 return SDKName.substr(PrefixPos + 1);
1891std::optional<DarwinPlatform>
1892inferDeploymentTargetFromSDK(DerivedArgList &Args,
1893 const std::optional<DarwinSDKInfo> &SDKInfo) {
1894 const Arg *A = Args.getLastArg(options::OPT_isysroot);
1896 return std::nullopt;
1897 StringRef isysroot = A->getValue();
1900 return std::nullopt;
1902 std::string Version;
1905 Version = SDKInfo->getVersion().getAsString();
1909 size_t StartVer = SDK.find_first_of(
"0123456789");
1910 size_t EndVer = SDK.find_last_of(
"0123456789");
1911 if (StartVer != StringRef::npos && EndVer > StartVer)
1912 Version = std::string(SDK.slice(StartVer, EndVer + 1));
1914 if (Version.empty())
1915 return std::nullopt;
1917 auto CreatePlatformFromSDKName =
1918 [&](StringRef SDK) -> std::optional<DarwinPlatform> {
1919 if (SDK.startswith(
"iPhoneOS") || SDK.startswith(
"iPhoneSimulator"))
1920 return DarwinPlatform::createFromSDK(
1922 SDK.startswith(
"iPhoneSimulator"));
1923 else if (SDK.startswith(
"MacOSX"))
1926 else if (SDK.startswith(
"WatchOS") || SDK.startswith(
"WatchSimulator"))
1927 return DarwinPlatform::createFromSDK(
1929 SDK.startswith(
"WatchSimulator"));
1930 else if (SDK.startswith(
"AppleTVOS") || SDK.startswith(
"AppleTVSimulator"))
1931 return DarwinPlatform::createFromSDK(
1933 SDK.startswith(
"AppleTVSimulator"));
1934 else if (SDK.startswith(
"DriverKit"))
1936 return std::nullopt;
1938 if (
auto Result = CreatePlatformFromSDKName(SDK))
1941 return CreatePlatformFromSDKName(dropSDKNamePrefix(SDK));
1944std::string getOSVersion(llvm::Triple::OSType
OS,
const llvm::Triple &Triple,
1945 const Driver &TheDriver) {
1946 VersionTuple OsVersion;
1947 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1949 case llvm::Triple::Darwin:
1950 case llvm::Triple::MacOSX:
1953 if (Triple.isMacOSX() && SystemTriple.isMacOSX() &&
1954 !Triple.getOSMajorVersion())
1955 SystemTriple.getMacOSXVersion(OsVersion);
1956 else if (!Triple.getMacOSXVersion(OsVersion))
1957 TheDriver.
Diag(diag::err_drv_invalid_darwin_version)
1958 << Triple.getOSName();
1960 case llvm::Triple::IOS:
1961 if (Triple.isMacCatalystEnvironment() && !Triple.getOSMajorVersion()) {
1962 OsVersion = VersionTuple(13, 1);
1964 OsVersion = Triple.getiOSVersion();
1966 case llvm::Triple::TvOS:
1967 OsVersion = Triple.getOSVersion();
1969 case llvm::Triple::WatchOS:
1970 OsVersion = Triple.getWatchOSVersion();
1972 case llvm::Triple::DriverKit:
1973 OsVersion = Triple.getDriverKitVersion();
1976 llvm_unreachable(
"Unexpected OS type");
1980 std::string OSVersion;
1981 llvm::raw_string_ostream(OSVersion)
1982 << OsVersion.getMajor() <<
'.' << OsVersion.getMinor().value_or(0) <<
'.'
1983 << OsVersion.getSubminor().value_or(0);
1988std::optional<DarwinPlatform>
1989inferDeploymentTargetFromArch(DerivedArgList &Args,
const Darwin &Toolchain,
1990 const llvm::Triple &Triple,
1991 const Driver &TheDriver) {
1992 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
1995 if (MachOArchName ==
"arm64" || MachOArchName ==
"arm64e")
1996 OSTy = llvm::Triple::MacOSX;
1997 else if (MachOArchName ==
"armv7" || MachOArchName ==
"armv7s")
1998 OSTy = llvm::Triple::IOS;
1999 else if (MachOArchName ==
"armv7k" || MachOArchName ==
"arm64_32")
2000 OSTy = llvm::Triple::WatchOS;
2001 else if (MachOArchName !=
"armv6m" && MachOArchName !=
"armv7m" &&
2002 MachOArchName !=
"armv7em")
2003 OSTy = llvm::Triple::MacOSX;
2004 if (OSTy == llvm::Triple::UnknownOS)
2005 return std::nullopt;
2006 return DarwinPlatform::createFromArch(OSTy,
2007 getOSVersion(OSTy, Triple, TheDriver));
2011std::optional<DarwinPlatform> getDeploymentTargetFromTargetArg(
2012 DerivedArgList &Args,
const llvm::Triple &Triple,
const Driver &TheDriver,
2013 const std::optional<DarwinSDKInfo> &SDKInfo) {
2014 if (!Args.hasArg(options::OPT_target))
2015 return std::nullopt;
2016 if (Triple.getOS() == llvm::Triple::Darwin ||
2017 Triple.getOS() == llvm::Triple::UnknownOS)
2018 return std::nullopt;
2019 std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
2020 std::optional<llvm::Triple> TargetVariantTriple;
2021 for (
const Arg *A : Args.filtered(options::OPT_darwin_target_variant)) {
2022 llvm::Triple TVT(A->getValue());
2024 if ((Triple.getArch() == llvm::Triple::aarch64 ||
2025 TVT.getArchName() == Triple.getArchName()) &&
2026 TVT.getArch() == Triple.getArch() &&
2027 TVT.getSubArch() == Triple.getSubArch() &&
2028 TVT.getVendor() == Triple.getVendor()) {
2029 if (TargetVariantTriple)
2034 if ((Triple.isMacOSX() && TVT.getOS() == llvm::Triple::IOS &&
2035 TVT.isMacCatalystEnvironment()) ||
2036 (TVT.isMacOSX() && Triple.getOS() == llvm::Triple::IOS &&
2037 Triple.isMacCatalystEnvironment())) {
2038 TargetVariantTriple = TVT;
2041 TheDriver.
Diag(diag::err_drv_target_variant_invalid)
2042 << A->getSpelling() << A->getValue();
2045 return DarwinPlatform::createFromTarget(Triple, OSVersion,
2046 Args.getLastArg(options::OPT_target),
2047 TargetVariantTriple, SDKInfo);
2051std::optional<DarwinPlatform> getDeploymentTargetFromMTargetOSArg(
2052 DerivedArgList &Args,
const Driver &TheDriver,
2053 const std::optional<DarwinSDKInfo> &SDKInfo) {
2054 auto *A = Args.getLastArg(options::OPT_mtargetos_EQ);
2056 return std::nullopt;
2057 llvm::Triple TT(llvm::Twine(
"unknown-apple-") + A->getValue());
2058 switch (TT.getOS()) {
2059 case llvm::Triple::MacOSX:
2060 case llvm::Triple::IOS:
2061 case llvm::Triple::TvOS:
2062 case llvm::Triple::WatchOS:
2065 TheDriver.
Diag(diag::err_drv_invalid_os_in_arg)
2066 << TT.getOSName() << A->getAsString(Args);
2067 return std::nullopt;
2070 VersionTuple Version = TT.getOSVersion();
2071 if (!Version.getMajor()) {
2072 TheDriver.
Diag(diag::err_drv_invalid_version_number)
2073 << A->getAsString(Args);
2074 return std::nullopt;
2076 return DarwinPlatform::createFromMTargetOS(TT.getOS(), Version,
2077 TT.getEnvironment(), A, SDKInfo);
2080std::optional<DarwinSDKInfo> parseSDKSettings(llvm::vfs::FileSystem &VFS,
2081 const ArgList &Args,
2082 const Driver &TheDriver) {
2083 const Arg *A = Args.getLastArg(options::OPT_isysroot);
2085 return std::nullopt;
2086 StringRef isysroot = A->getValue();
2088 if (!SDKInfoOrErr) {
2089 llvm::consumeError(SDKInfoOrErr.takeError());
2090 TheDriver.
Diag(diag::warn_drv_darwin_sdk_invalid_settings);
2091 return std::nullopt;
2093 return *SDKInfoOrErr;
2098void Darwin::AddDeploymentTarget(DerivedArgList &Args)
const {
2104 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2106 if (!
getVFS().exists(A->getValue()))
2107 getDriver().
Diag(clang::diag::warn_missing_sysroot) << A->getValue();
2109 if (
char *env = ::getenv(
"SDKROOT")) {
2112 if (llvm::sys::path::is_absolute(env) &&
getVFS().exists(env) &&
2113 StringRef(env) !=
"/") {
2114 Args.append(Args.MakeSeparateArg(
2115 nullptr, Opts.getOption(options::OPT_isysroot), env));
2125 std::optional<DarwinPlatform> OSTarget =
2129 if (
const auto *MTargetOSArg = Args.getLastArg(options::OPT_mtargetos_EQ)) {
2130 std::string TargetArgStr = OSTarget->getAsString(Args, Opts);
2131 std::string MTargetOSArgStr = MTargetOSArg->getAsString(Args);
2133 << TargetArgStr << MTargetOSArgStr;
2135 std::optional<DarwinPlatform> OSVersionArgTarget =
2136 getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2137 if (OSVersionArgTarget) {
2138 unsigned TargetMajor, TargetMinor, TargetMicro;
2140 unsigned ArgMajor, ArgMinor, ArgMicro;
2142 if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
2144 TargetMinor, TargetMicro, TargetExtra) &&
2146 ArgMajor, ArgMinor, ArgMicro, ArgExtra) &&
2147 (VersionTuple(TargetMajor, TargetMinor, TargetMicro) !=
2148 VersionTuple(ArgMajor, ArgMinor, ArgMicro) ||
2149 TargetExtra != ArgExtra))) {
2152 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
2153 !OSTarget->hasOSVersion()) {
2154 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
2158 std::string OSVersionArg =
2159 OSVersionArgTarget->getAsString(Args, Opts);
2160 std::string TargetArg = OSTarget->getAsString(Args, Opts);
2161 getDriver().
Diag(clang::diag::warn_drv_overriding_flag_option)
2162 << OSVersionArg << TargetArg;
2166 }
else if ((OSTarget = getDeploymentTargetFromMTargetOSArg(Args,
getDriver(),
2170 std::optional<DarwinPlatform> OSVersionArgTarget =
2171 getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2172 if (OSVersionArgTarget) {
2173 std::string MTargetOSArgStr = OSTarget->getAsString(Args, Opts);
2174 std::string OSVersionArgStr = OSVersionArgTarget->getAsString(Args, Opts);
2176 << MTargetOSArgStr << OSVersionArgStr;
2180 OSTarget = getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2188 std::optional<DarwinPlatform> SDKTarget =
2189 inferDeploymentTargetFromSDK(Args,
SDKInfo);
2191 OSTarget->setEnvironment(SDKTarget->getEnvironment());
2198 OSTarget = inferDeploymentTargetFromSDK(Args,
SDKInfo);
2202 SDKInfo = OSTarget->inferSDKInfo();
2211 assert(OSTarget &&
"Unable to infer Darwin variant");
2212 OSTarget->addOSVersionMinArgument(Args, Opts);
2215 unsigned Major, Minor, Micro;
2218 const unsigned MajorVersionLimit = 1000;
2220 if (Platform ==
MacOS) {
2223 HadExtra || Major < 10 || Major >= MajorVersionLimit || Minor >= 100 ||
2226 << OSTarget->getAsString(Args, Opts);
2230 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2232 << OSTarget->getAsString(Args, Opts);
2235 (Major < 13 || (Major == 13 && Minor < 1))) {
2237 << OSTarget->getAsString(Args, Opts);
2244 if (
getTriple().isArch32Bit() && Major >= 11) {
2246 if (OSTarget->isExplicitlySpecified()) {
2248 getDriver().
Diag(diag::err_invalid_macos_32bit_deployment_target);
2251 << OSTarget->getAsString(Args, Opts);
2259 }
else if (Platform ==
TvOS) {
2262 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2264 << OSTarget->getAsString(Args, Opts);
2265 }
else if (Platform ==
WatchOS) {
2268 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2270 << OSTarget->getAsString(Args, Opts);
2274 HadExtra || Major < 19 || Major >= MajorVersionLimit || Minor >= 100 ||
2277 << OSTarget->getAsString(Args, Opts);
2279 llvm_unreachable(
"unknown kind of Darwin platform");
2284 Platform !=
DriverKit && OSTarget->canInferSimulatorFromArch() &&
2288 VersionTuple NativeTargetVersion;
2290 NativeTargetVersion = OSTarget->getNativeTargetVersion();
2291 setTarget(Platform, Environment, Major, Minor, Micro, NativeTargetVersion);
2294 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2296 if (SDK.size() > 0) {
2297 size_t StartVer = SDK.find_first_of(
"0123456789");
2298 StringRef SDKName = SDK.slice(0, StartVer);
2311 const llvm::Triple &T) {
2312 if (T.isDriverKit()) {
2313 llvm::sys::path::append(Path,
"System",
"DriverKit");
2320DarwinClang::GetEffectiveSysroot(
const llvm::opt::ArgList &DriverArgs)
const {
2322 if (DriverArgs.hasArg(options::OPT_isysroot))
2323 Path = DriverArgs.getLastArgValue(options::OPT_isysroot);
2334 llvm::opt::ArgStringList &CC1Args)
const {
2339 bool NoStdInc = DriverArgs.hasArg(options::OPT_nostdinc);
2340 bool NoStdlibInc = DriverArgs.hasArg(options::OPT_nostdlibinc);
2341 bool NoBuiltinInc = DriverArgs.hasFlag(
2342 options::OPT_nobuiltininc, options::OPT_ibuiltininc,
false);
2343 bool ForceBuiltinInc = DriverArgs.hasFlag(
2344 options::OPT_ibuiltininc, options::OPT_nobuiltininc,
false);
2347 if (!NoStdInc && !NoStdlibInc) {
2349 llvm::sys::path::append(
P,
"usr",
"local",
"include");
2354 if (!(NoStdInc && !ForceBuiltinInc) && !NoBuiltinInc) {
2356 llvm::sys::path::append(
P,
"include");
2360 if (NoStdInc || NoStdlibInc)
2364 llvm::StringRef CIncludeDirs(C_INCLUDE_DIRS);
2365 if (!CIncludeDirs.empty()) {
2367 CIncludeDirs.split(dirs,
":");
2368 for (llvm::StringRef dir : dirs) {
2369 llvm::StringRef Prefix =
2370 llvm::sys::path::is_absolute(dir) ?
"" : llvm::StringRef(Sysroot);
2376 llvm::sys::path::append(
P,
"usr",
"include");
2381bool DarwinClang::AddGnuCPlusPlusIncludePaths(
const llvm::opt::ArgList &DriverArgs,
2382 llvm::opt::ArgStringList &CC1Args,
2384 llvm::StringRef Version,
2385 llvm::StringRef ArchDir,
2386 llvm::StringRef BitDir)
const {
2387 llvm::sys::path::append(
Base, Version);
2395 if (!ArchDir.empty())
2396 llvm::sys::path::append(
P, ArchDir);
2397 if (!BitDir.empty())
2398 llvm::sys::path::append(
P, BitDir);
2405 llvm::sys::path::append(
P,
"backward");
2413 const llvm::opt::ArgList &DriverArgs,
2414 llvm::opt::ArgStringList &CC1Args)
const {
2422 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
2423 options::OPT_nostdincxx))
2444 llvm::StringRef(
getDriver().getInstalledDir());
2445 llvm::sys::path::append(InstallBin,
"..",
"include",
"c++",
"v1");
2446 if (
getVFS().exists(InstallBin)) {
2449 }
else if (DriverArgs.hasArg(options::OPT_v)) {
2450 llvm::errs() <<
"ignoring nonexistent directory \"" << InstallBin
2456 llvm::sys::path::append(SysrootUsr,
"usr",
"include",
"c++",
"v1");
2457 if (
getVFS().exists(SysrootUsr)) {
2460 }
else if (DriverArgs.hasArg(options::OPT_v)) {
2461 llvm::errs() <<
"ignoring nonexistent directory \"" << SysrootUsr
2471 llvm::sys::path::append(UsrIncludeCxx,
"usr",
"include",
"c++");
2474 bool IsBaseFound =
true;
2478 case llvm::Triple::x86:
2479 case llvm::Triple::x86_64:
2480 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2482 "i686-apple-darwin10",
2483 arch == llvm::Triple::x86_64 ?
"x86_64" :
"");
2484 IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2485 "4.0.0",
"i686-apple-darwin8",
2489 case llvm::Triple::arm:
2490 case llvm::Triple::thumb:
2491 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2493 "arm-apple-darwin10",
2495 IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2497 "arm-apple-darwin10",
2501 case llvm::Triple::aarch64:
2502 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2504 "arm64-apple-darwin10",
2518 ArgStringList &CmdArgs)
const {
2523 CmdArgs.push_back(
"-lc++");
2524 if (Args.hasArg(options::OPT_fexperimental_library))
2525 CmdArgs.push_back(
"-lc++experimental");
2535 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2537 llvm::sys::path::append(
P,
"usr",
"lib",
"libstdc++.dylib");
2540 llvm::sys::path::remove_filename(
P);
2541 llvm::sys::path::append(
P,
"libstdc++.6.dylib");
2543 CmdArgs.push_back(Args.MakeArgString(
P));
2552 if (!
getVFS().exists(
"/usr/lib/libstdc++.dylib") &&
2553 getVFS().exists(
"/usr/lib/libstdc++.6.dylib")) {
2554 CmdArgs.push_back(
"/usr/lib/libstdc++.6.dylib");
2559 CmdArgs.push_back(
"-lstdc++");
2565 ArgStringList &CmdArgs)
const {
2571 llvm::sys::path::append(
P,
"lib",
"darwin");
2575 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_watchos.a");
2577 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_tvos.a");
2579 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_ios.a");
2583 llvm::sys::path::append(
P,
"libclang_rt.cc_kext.a");
2589 CmdArgs.push_back(Args.MakeArgString(
P));
2593 StringRef BoundArch,
2595 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2605 for (Arg *A : Args) {
2606 if (A->getOption().matches(options::OPT_Xarch__)) {
2609 StringRef XarchArch = A->getValue(0);
2611 (!BoundArch.empty() && XarchArch == BoundArch)))
2614 Arg *OriginalArg = A;
2622 for (
const char *
Value : A->getValues()) {
2623 DAL->AddSeparateArg(
2624 OriginalArg, Opts.getOption(options::OPT_Zlinker_input),
Value);
2638 case options::OPT_mkernel:
2639 case options::OPT_fapple_kext:
2641 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
2644 case options::OPT_dependency_file:
2645 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
2648 case options::OPT_gfull:
2649 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2651 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
2654 case options::OPT_gused:
2655 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2657 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
2660 case options::OPT_shared:
2661 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
2664 case options::OPT_fconstant_cfstrings:
2665 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
2668 case options::OPT_fno_constant_cfstrings:
2669 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
2672 case options::OPT_Wnonportable_cfstrings:
2674 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
2677 case options::OPT_Wno_nonportable_cfstrings:
2679 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
2686 if (!BoundArch.empty()) {
2687 StringRef Name = BoundArch;
2688 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
2689 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
2695 else if (Name ==
"ppc601")
2696 DAL->AddJoinedArg(
nullptr, MCpu,
"601");
2697 else if (Name ==
"ppc603")
2698 DAL->AddJoinedArg(
nullptr, MCpu,
"603");
2699 else if (Name ==
"ppc604")
2700 DAL->AddJoinedArg(
nullptr, MCpu,
"604");
2701 else if (Name ==
"ppc604e")
2702 DAL->AddJoinedArg(
nullptr, MCpu,
"604e");
2703 else if (Name ==
"ppc750")
2704 DAL->AddJoinedArg(
nullptr, MCpu,
"750");
2705 else if (Name ==
"ppc7400")
2706 DAL->AddJoinedArg(
nullptr, MCpu,
"7400");
2707 else if (Name ==
"ppc7450")
2708 DAL->AddJoinedArg(
nullptr, MCpu,
"7450");
2709 else if (Name ==
"ppc970")
2710 DAL->AddJoinedArg(
nullptr, MCpu,
"970");
2712 else if (Name ==
"ppc64" || Name ==
"ppc64le")
2713 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2715 else if (Name ==
"i386")
2717 else if (Name ==
"i486")
2718 DAL->AddJoinedArg(
nullptr, MArch,
"i486");
2719 else if (Name ==
"i586")
2720 DAL->AddJoinedArg(
nullptr, MArch,
"i586");
2721 else if (Name ==
"i686")
2722 DAL->AddJoinedArg(
nullptr, MArch,
"i686");
2723 else if (Name ==
"pentium")
2724 DAL->AddJoinedArg(
nullptr, MArch,
"pentium");
2725 else if (Name ==
"pentium2")
2726 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2727 else if (Name ==
"pentpro")
2728 DAL->AddJoinedArg(
nullptr, MArch,
"pentiumpro");
2729 else if (Name ==
"pentIIm3")
2730 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2732 else if (Name ==
"x86_64" || Name ==
"x86_64h")
2733 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2735 else if (Name ==
"arm")
2736 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2737 else if (Name ==
"armv4t")
2738 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2739 else if (Name ==
"armv5")
2740 DAL->AddJoinedArg(
nullptr, MArch,
"armv5tej");
2741 else if (Name ==
"xscale")
2742 DAL->AddJoinedArg(
nullptr, MArch,
"xscale");
2743 else if (Name ==
"armv6")
2744 DAL->AddJoinedArg(
nullptr, MArch,
"armv6k");
2745 else if (Name ==
"armv6m")
2746 DAL->AddJoinedArg(
nullptr, MArch,
"armv6m");
2747 else if (Name ==
"armv7")
2748 DAL->AddJoinedArg(
nullptr, MArch,
"armv7a");
2749 else if (Name ==
"armv7em")
2750 DAL->AddJoinedArg(
nullptr, MArch,
"armv7em");
2751 else if (Name ==
"armv7k")
2752 DAL->AddJoinedArg(
nullptr, MArch,
"armv7k");
2753 else if (Name ==
"armv7m")
2754 DAL->AddJoinedArg(
nullptr, MArch,
"armv7m");
2755 else if (Name ==
"armv7s")
2756 DAL->AddJoinedArg(
nullptr, MArch,
"armv7s");
2763 ArgStringList &CmdArgs,
2764 bool ForceLinkBuiltinRT)
const {
2773 CompilerRT += Args.hasArg(options::OPT_fPIC) ?
"_pic" :
"_static";
2779 llvm::Triple::OSType
OS;
2785 OS = llvm::Triple::MacOSX;
2788 OS = llvm::Triple::IOS;
2791 OS = llvm::Triple::TvOS;
2794 OS = llvm::Triple::WatchOS;
2804 llvm::opt::ArgStringList &CC1Args,
2808 if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
2809 options::OPT_fno_aligned_allocation) &&
2811 CC1Args.push_back(
"-faligned-alloc-unavailable");
2817 CC1Args.push_back(
"-fcompatibility-qualified-id-block-type-checking");
2821 if (!DriverArgs.getLastArgNoClaim(
2822 options::OPT_fvisibility_inlines_hidden_static_local_var,
2823 options::OPT_fno_visibility_inlines_hidden_static_local_var))
2824 CC1Args.push_back(
"-fvisibility-inlines-hidden-static-local-var");
2828 const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CC1ASArgs)
const {
2830 CC1ASArgs.push_back(
"-darwin-target-variant-triple");
2837 auto EmitTargetSDKVersionArg = [&](
const VersionTuple &
V) {
2839 llvm::raw_string_ostream
OS(Arg);
2840 OS <<
"-target-sdk-version=" <<
V;
2841 CC1ASArgs.push_back(Args.MakeArgString(
OS.str()));
2845 if (
const auto *MacOStoMacCatalystMapping =
SDKInfo->getVersionMapping(
2847 std::optional<VersionTuple> SDKVersion = MacOStoMacCatalystMapping->map(
2850 EmitTargetSDKVersionArg(
2854 EmitTargetSDKVersionArg(
SDKInfo->getVersion());
2862 llvm::raw_string_ostream
OS(Arg);
2863 OS <<
"-darwin-target-variant-sdk-version=" <<
SDKInfo->getVersion();
2864 CC1ASArgs.push_back(Args.MakeArgString(
OS.str()));
2865 }
else if (
const auto *MacOStoMacCatalystMapping =
2868 if (std::optional<VersionTuple> SDKVersion =
2869 MacOStoMacCatalystMapping->map(
2873 llvm::raw_string_ostream
OS(Arg);
2874 OS <<
"-darwin-target-variant-sdk-version=" << *SDKVersion;
2875 CC1ASArgs.push_back(Args.MakeArgString(
OS.str()));
2886 DerivedArgList *DAL =
2890 if (BoundArch.empty())
2896 AddDeploymentTarget(*DAL);
2904 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
2907 if (A->getOption().getID() != options::OPT_mkernel &&
2908 A->getOption().getID() != options::OPT_fapple_kext)
2910 assert(it != ie &&
"unexpected argument translation");
2912 assert(A->getOption().getID() == options::OPT_static &&
2913 "missing expected -static argument");
2920 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
2921 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
2922 options::OPT_fno_omit_frame_pointer,
false))
2923 getDriver().
Diag(clang::diag::warn_drv_unsupported_opt_for_target)
2924 <<
"-fomit-frame-pointer" << BoundArch;
2933 if (
getArch() == llvm::Triple::x86_64 ||
2935 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2944 if (
const char *S = ::getenv(
"RC_DEBUG_OPTIONS"))
2945 return S[0] !=
'\0';
2950 if (
const char *S = ::getenv(
"RC_DEBUG_PREFIX_MAP"))
2959 return llvm::ExceptionHandling::None;
2963 if (Triple.isWatchABI())
2964 return llvm::ExceptionHandling::DwarfCFI;
2966 return llvm::ExceptionHandling::SjLj;
2981 return (
getArch() == llvm::Triple::x86_64 ||
2982 getArch() == llvm::Triple::aarch64);
2991 ArgStringList &CmdArgs)
const {
2995 CmdArgs.push_back(
"-watchos_version_min");
2997 CmdArgs.push_back(
"-watchos_simulator_version_min");
2999 CmdArgs.push_back(
"-tvos_version_min");
3001 CmdArgs.push_back(
"-tvos_simulator_version_min");
3003 CmdArgs.push_back(
"-driverkit_version_min");
3005 CmdArgs.push_back(
"-ios_simulator_version_min");
3007 CmdArgs.push_back(
"-iphoneos_version_min");
3009 CmdArgs.push_back(
"-maccatalyst_version_min");
3012 CmdArgs.push_back(
"-macosx_version_min");
3018 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3021 VersionTuple VariantTargetVersion;
3023 CmdArgs.push_back(
"-macosx_version_min");
3028 "unexpected target variant triple");
3029 CmdArgs.push_back(
"-maccatalyst_version_min");
3032 VersionTuple MinTgtVers =
3034 if (MinTgtVers.getMajor() && MinTgtVers > VariantTargetVersion)
3035 VariantTargetVersion = MinTgtVers;
3036 CmdArgs.push_back(Args.MakeArgString(VariantTargetVersion.getAsString()));
3047 return "mac catalyst";
3056 llvm_unreachable(
"invalid platform");
3060 llvm::opt::ArgStringList &CmdArgs)
const {
3061 auto EmitPlatformVersionArg =
3064 const llvm::Triple &TT) {
3067 CmdArgs.push_back(
"-platform_version");
3068 std::string PlatformName =
3071 PlatformName +=
"-simulator";
3072 CmdArgs.push_back(Args.MakeArgString(PlatformName));
3081 VersionTuple MinTgtVers = TT.getMinimumSupportedOSVersion();
3084 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3089 std::optional<VersionTuple> iOSSDKVersion;
3091 if (
const auto *MacOStoMacCatalystMapping =
3094 iOSSDKVersion = MacOStoMacCatalystMapping->map(
3095 SDKInfo->getVersion().withoutBuild(),
3099 CmdArgs.push_back(Args.MakeArgString(
3100 (iOSSDKVersion ? *iOSSDKVersion
3107 VersionTuple SDKVersion =
SDKInfo->getVersion().withoutBuild();
3108 if (!SDKVersion.getMinor())
3109 SDKVersion = VersionTuple(SDKVersion.getMajor(), 0);
3110 CmdArgs.push_back(Args.MakeArgString(SDKVersion.getAsString()));
3121 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3130 VersionTuple TargetVariantVersion;
3138 "unexpected target variant triple");
3143 EmitPlatformVersionArg(TargetVariantVersion, Platform, Environment,
3149 ArgStringList &CmdArgs) {
3153 CmdArgs.push_back(
"-ldylib1.o");
3160 CmdArgs.push_back(
"-ldylib1.o");
3162 CmdArgs.push_back(
"-ldylib1.10.5.o");
3167 ArgStringList &CmdArgs) {
3168 if (Args.hasArg(options::OPT_static))
3173 CmdArgs.push_back(
"-lbundle1.o");
3178 ArgStringList &CmdArgs) {
3180 if (Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_object) ||
3181 Args.hasArg(options::OPT_preload)) {
3182 CmdArgs.push_back(
"-lgcrt0.o");
3184 CmdArgs.push_back(
"-lgcrt1.o");
3194 CmdArgs.push_back(
"-no_new_main");
3196 D.
getDriver().
Diag(diag::err_drv_clang_unsupported_opt_pg_darwin)
3202 ArgStringList &CmdArgs) {
3205 if (D.
getArch() == llvm::Triple::aarch64)
3208 CmdArgs.push_back(
"-lcrt1.o");
3210 CmdArgs.push_back(
"-lcrt1.3.1.o");
3217 CmdArgs.push_back(
"-lcrt1.o");
3219 CmdArgs.push_back(
"-lcrt1.10.5.o");
3221 CmdArgs.push_back(
"-lcrt1.10.6.o");
3226 ArgStringList &CmdArgs)
const {
3228 if (Args.hasArg(options::OPT_dynamiclib))
3230 else if (Args.hasArg(options::OPT_bundle))
3234 else if (Args.hasArg(options::OPT_static) ||
3235 Args.hasArg(options::OPT_object) ||
3236 Args.hasArg(options::OPT_preload))
3237 CmdArgs.push_back(
"-lcrt0.o");
3241 if (
isTargetMacOS() && Args.hasArg(options::OPT_shared_libgcc) &&
3243 const char *Str = Args.MakeArgString(
GetFilePath(
"crt3.o"));
3244 CmdArgs.push_back(Str);
3256 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
3257 const bool IsAArch64 =
getTriple().getArch() == llvm::Triple::aarch64;
3259 Res |= SanitizerKind::Address;
3260 Res |= SanitizerKind::PointerCompare;
3261 Res |= SanitizerKind::PointerSubtract;
3262 Res |= SanitizerKind::Leak;
3263 Res |= SanitizerKind::Fuzzer;
3264 Res |= SanitizerKind::FuzzerNoLink;
3265 Res |= SanitizerKind::Function;
3266 Res |= SanitizerKind::ObjCCast;
3273 Res |= SanitizerKind::Vptr;
3275 if ((IsX86_64 || IsAArch64) &&
3278 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
const char * getTypeTempSuffix(ID Id, bool CLMode=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()