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;
254 TmpPathName =
D.GetTemporaryDirectory(
"thinlto");
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);
435 if (
const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) {
436 CmdArgs.push_back(
"-syslibroot");
437 CmdArgs.push_back(A->getValue());
438 }
else if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
439 CmdArgs.push_back(
"-syslibroot");
440 CmdArgs.push_back(A->getValue());
441 }
else if (StringRef sysroot =
C.getSysRoot(); sysroot !=
"") {
442 CmdArgs.push_back(
"-syslibroot");
443 CmdArgs.push_back(
C.getArgs().MakeArgString(sysroot));
446 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
447 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
448 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
449 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
450 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
451 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
452 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
453 Args.AddAllArgs(CmdArgs, options::OPT_y);
454 Args.AddLastArg(CmdArgs, options::OPT_w);
455 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
456 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
457 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
458 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
459 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
460 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
461 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
462 Args.AddLastArg(CmdArgs, options::OPT_why_load);
463 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
464 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
465 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
466 Args.AddLastArg(CmdArgs, options::OPT_Mach);
472 : CSPGOGenerateArg->getValue());
473 llvm::sys::path::append(
Path,
"default_%m.profraw");
474 CmdArgs.push_back(
"--cs-profile-generate");
475 CmdArgs.push_back(Args.MakeArgString(Twine(
"--cs-profile-path=") +
Path));
478 ProfileUseArg->getNumValues() == 0 ?
"" : ProfileUseArg->getValue());
479 if (
Path.empty() || llvm::sys::fs::is_directory(
Path))
480 llvm::sys::path::append(
Path,
"default.profdata");
481 CmdArgs.push_back(Args.MakeArgString(Twine(
"--cs-profile-path=") +
Path));
484 auto *CodeGenDataGenArg =
485 Args.getLastArg(options::OPT_fcodegen_data_generate_EQ);
486 if (CodeGenDataGenArg)
488 Args.MakeArgString(Twine(
"--codegen-data-generate-path=") +
489 CodeGenDataGenArg->getValue()));
496 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
499 return Args.hasArg(options::OPT_fobjc_link_runtime);
503 const llvm::Triple &Triple) {
508 Args.getAllArgValues(options::OPT_arch).size() > 1;
509 bool hasExplicitOutputFile =
510 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
512 D.Diag(diag::err_drv_invalid_output_with_multiple_archs)
513 <<
"-foptimization-record-file";
520 const llvm::Triple &Triple,
522 StringRef Format =
"yaml";
523 if (
const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
524 Format = A->getValue();
526 CmdArgs.push_back(
"-mllvm");
527 CmdArgs.push_back(
"-lto-pass-remarks-output");
528 CmdArgs.push_back(
"-mllvm");
530 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
532 CmdArgs.push_back(A->getValue());
534 assert(Output.
isFilename() &&
"Unexpected ld output.");
540 CmdArgs.push_back(Args.MakeArgString(F));
544 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
545 CmdArgs.push_back(
"-mllvm");
547 std::string(
"-lto-pass-remarks-filter=") + A->getValue();
548 CmdArgs.push_back(Args.MakeArgString(Passes));
551 if (!Format.empty()) {
552 CmdArgs.push_back(
"-mllvm");
553 Twine FormatArg = Twine(
"-lto-pass-remarks-format=") + Format;
554 CmdArgs.push_back(Args.MakeArgString(FormatArg));
558 CmdArgs.push_back(
"-mllvm");
559 CmdArgs.push_back(
"-lto-pass-remarks-with-hotness");
562 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
563 CmdArgs.push_back(
"-mllvm");
565 std::string(
"-lto-pass-remarks-hotness-threshold=") + A->getValue();
566 CmdArgs.push_back(Args.MakeArgString(Opt));
577 const char *LinkingOutput)
const {
578 assert(Output.
getType() == types::TY_Image &&
"Invalid linker output type.");
584 llvm::opt::ArgStringList InputFileList;
589 ArgStringList CmdArgs;
592 if (Args.hasArg(options::OPT_ccc_arcmt_check,
593 options::OPT_ccc_arcmt_migrate)) {
594 for (
const auto &Arg : Args)
597 Args.MakeArgString(getToolChain().GetProgramPath(
"touch"));
599 C.addCommand(std::make_unique<Command>(JA, *
this,
601 CmdArgs, std::nullopt, Output));
605 VersionTuple Version = getMachOToolChain().getLinkerVersion(Args);
609 Args.MakeArgString(getToolChain().GetLinkerPath(&LinkerIsLLD));
612 bool UsePlatformVersion = getToolChain().getTriple().isXROS();
616 AddLinkArgs(
C, Args, CmdArgs, Inputs, Version, LinkerIsLLD,
621 getToolChain().getTriple()))
626 Args.getLastArg(options::OPT_moutline, options::OPT_mno_outline)) {
627 if (A->getOption().matches(options::OPT_moutline)) {
628 if (getMachOToolChain().getMachOArchName(Args) ==
"arm64") {
629 CmdArgs.push_back(
"-mllvm");
630 CmdArgs.push_back(
"-enable-machine-outliner");
636 CmdArgs.push_back(
"-mllvm");
637 CmdArgs.push_back(
"-enable-machine-outliner=never");
644 CmdArgs.push_back(
"-mllvm");
645 CmdArgs.push_back(
"-enable-linkonceodr-outlining");
648 auto *CodeGenDataGenArg =
649 Args.getLastArg(options::OPT_fcodegen_data_generate_EQ);
650 auto *CodeGenDataUseArg = Args.getLastArg(options::OPT_fcodegen_data_use_EQ);
653 const Driver &
D = getToolChain().getDriver();
654 if (CodeGenDataGenArg && CodeGenDataUseArg)
655 D.Diag(diag::err_drv_argument_not_allowed_with)
656 << CodeGenDataGenArg->getAsString(Args)
657 << CodeGenDataUseArg->getAsString(Args);
661 if (CodeGenDataGenArg) {
662 CmdArgs.push_back(
"-mllvm");
663 CmdArgs.push_back(
"-codegen-data-generate");
667 if (CodeGenDataUseArg) {
668 CmdArgs.push_back(
"-mllvm");
669 CmdArgs.push_back(Args.MakeArgString(Twine(
"-codegen-data-use-path=") +
670 CodeGenDataUseArg->getValue()));
676 if (!StatsFile.empty()) {
677 CmdArgs.push_back(
"-mllvm");
678 CmdArgs.push_back(Args.MakeArgString(
"-lto-stats-file=" + StatsFile.str()));
683 Args.addAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
684 options::OPT_Z_Flag, options::OPT_u_Group});
689 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
690 CmdArgs.push_back(
"-ObjC");
692 CmdArgs.push_back(
"-o");
695 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
696 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
698 Args.AddAllArgs(CmdArgs, options::OPT_L);
703 for (
const auto &II : Inputs) {
704 if (!II.isFilename()) {
709 if (InputFileList.size() > 0)
715 InputFileList.push_back(II.getFilename());
720 if (getToolChain().getDriver().IsFlangMode() &&
721 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
726 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
730 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
732 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
734 CmdArgs.push_back(
"-framework");
735 CmdArgs.push_back(
"Foundation");
737 CmdArgs.push_back(
"-lobjc");
741 CmdArgs.push_back(
"-arch_multiple");
742 CmdArgs.push_back(
"-final_output");
743 CmdArgs.push_back(LinkingOutput);
746 if (Args.hasArg(options::OPT_fnested_functions))
747 CmdArgs.push_back(
"-allow_stack_execute");
749 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
752 if (!Parallelism.empty()) {
753 CmdArgs.push_back(
"-mllvm");
754 unsigned NumThreads =
755 llvm::get_threadpool_strategy(Parallelism)->compute_thread_count();
756 CmdArgs.push_back(Args.MakeArgString(
"-threads=" + Twine(NumThreads)));
759 if (getToolChain().ShouldLinkCXXStdlib(Args))
760 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
762 bool NoStdOrDefaultLibs =
763 Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs);
764 bool ForceLinkBuiltins = Args.hasArg(options::OPT_fapple_link_rtlib);
765 if (!NoStdOrDefaultLibs || ForceLinkBuiltins) {
770 if (NoStdOrDefaultLibs && ForceLinkBuiltins) {
771 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
"builtins");
774 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs,
778 Args.ClaimAllArgs(options::OPT_pthread);
779 Args.ClaimAllArgs(options::OPT_pthreads);
783 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
787 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
788 Args.AddAllArgs(CmdArgs, options::OPT_F);
791 for (
const Arg *A : Args.filtered(options::OPT_iframework))
792 CmdArgs.push_back(Args.MakeArgString(std::string(
"-F") + A->getValue()));
794 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
795 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
796 if (A->getValue() == StringRef(
"Accelerate")) {
797 CmdArgs.push_back(
"-framework");
798 CmdArgs.push_back(
"Accelerate");
807 bool NonStandardSearchPath =
false;
808 const auto &Triple = getToolChain().getTriple();
809 if (Triple.isDriverKit()) {
811 NonStandardSearchPath =
812 Version.getMajor() < 605 ||
813 (Version.getMajor() == 605 && Version.getMinor().value_or(0) < 1);
816 if (NonStandardSearchPath) {
817 if (
auto *Sysroot = Args.getLastArg(options::OPT_isysroot)) {
818 auto AddSearchPath = [&](StringRef Flag, StringRef SearchPath) {
821 llvm::sys::path::append(
P, SearchPath);
822 if (getToolChain().getVFS().exists(
P)) {
823 CmdArgs.push_back(Args.MakeArgString(Flag +
P));
826 AddSearchPath(
"-L",
"/usr/lib");
827 AddSearchPath(
"-F",
"/System/Library/Frameworks");
833 if (Version >= VersionTuple(705) || LinkerIsLLD) {
841 std::unique_ptr<Command>
Cmd = std::make_unique<Command>(
842 JA, *
this, ResponseSupport, Exec, CmdArgs, Inputs, Output);
843 Cmd->setInputFileList(std::move(InputFileList));
844 C.addCommand(std::move(
Cmd));
851 const char *LinkingOutput)
const {
852 const Driver &
D = getToolChain().getDriver();
855 Args.ClaimAllArgs(options::OPT_g_Group);
857 Args.ClaimAllArgs(options::OPT_emit_llvm);
860 Args.ClaimAllArgs(options::OPT_w);
862 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
865 ArgStringList CmdArgs;
867 CmdArgs.push_back(
"-static");
868 CmdArgs.push_back(
"-D");
869 CmdArgs.push_back(
"-no_warning_for_no_symbols");
870 CmdArgs.push_back(
"-o");
873 for (
const auto &II : Inputs) {
874 if (II.isFilename()) {
875 CmdArgs.push_back(II.getFilename());
882 if (Output.
isFilename() && llvm::sys::fs::exists(OutputFileName)) {
883 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
884 D.Diag(diag::err_drv_unable_to_remove_file) << EC.message();
889 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
890 C.addCommand(std::make_unique<Command>(JA, *
this,
892 Exec, CmdArgs, Inputs, Output));
899 const char *LinkingOutput)
const {
900 ArgStringList CmdArgs;
902 CmdArgs.push_back(
"-create");
903 assert(Output.
isFilename() &&
"Unexpected lipo output.");
905 CmdArgs.push_back(
"-output");
908 for (
const auto &II : Inputs) {
909 assert(II.isFilename() &&
"Unexpected lipo input.");
910 CmdArgs.push_back(II.getFilename());
913 StringRef LipoName = Args.getLastArgValue(options::OPT_fuse_lipo_EQ,
"lipo");
915 Args.MakeArgString(getToolChain().GetProgramPath(LipoName.data()));
917 Exec, CmdArgs, Inputs, Output));
924 const char *LinkingOutput)
const {
925 ArgStringList CmdArgs;
927 CmdArgs.push_back(
"-o");
930 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
932 assert(Input.
isFilename() &&
"Unexpected dsymutil input.");
936 Args.MakeArgString(getToolChain().GetProgramPath(
"dsymutil"));
938 Exec, CmdArgs, Inputs, Output));
945 const char *LinkingOutput)
const {
946 ArgStringList CmdArgs;
947 CmdArgs.push_back(
"--verify");
948 CmdArgs.push_back(
"--debug-info");
949 CmdArgs.push_back(
"--eh-frame");
950 CmdArgs.push_back(
"--quiet");
952 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
954 assert(Input.
isFilename() &&
"Unexpected verify input");
960 Args.MakeArgString(getToolChain().GetProgramPath(
"dwarfdump"));
962 Exec, CmdArgs, Inputs, Output));
973 :
MachO(
D, Triple, Args), CudaInstallation(
D, Triple, Args),
974 RocmInstallation(
D, Triple, Args), SYCLInstallation(
D, Triple, Args) {}
984 if (Ty == types::TY_PP_Asm)
985 return types::TY_Asm;
1005 auto T = llvm::Triple(Twine(
"arm64-apple-") +
1006 llvm::Triple::getOSTypeName(llvm::Triple::XROS) +
1028 ArgStringList &CC1Args)
const {
1033 ArgStringList &CC1Args)
const {
1038 ArgStringList &CC1Args)
const {
1047 return llvm::StringSwitch<const char *>(Arch)
1048 .Case(
"armv6k",
"armv6")
1049 .Case(
"armv6m",
"armv6m")
1050 .Case(
"armv5tej",
"armv5")
1051 .Case(
"xscale",
"xscale")
1052 .Case(
"armv4t",
"armv4t")
1053 .Case(
"armv7",
"armv7")
1054 .Cases(
"armv7a",
"armv7-a",
"armv7")
1055 .Cases(
"armv7r",
"armv7-r",
"armv7")
1056 .Cases(
"armv7em",
"armv7e-m",
"armv7em")
1057 .Cases(
"armv7k",
"armv7-k",
"armv7k")
1058 .Cases(
"armv7m",
"armv7-m",
"armv7m")
1059 .Cases(
"armv7s",
"armv7-s",
"armv7s")
1064 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
1065 if (ArchKind == llvm::ARM::ArchKind::INVALID)
1067 StringRef Arch = llvm::ARM::getArchName(ArchKind);
1071 if (Arch.starts_with(
"armv5"))
1072 Arch = Arch.substr(0, 5);
1074 else if (Arch.starts_with(
"armv6") && !Arch.ends_with(
"6m"))
1075 Arch = Arch.substr(0, 5);
1077 else if (Arch.ends_with(
"v7a"))
1078 Arch = Arch.substr(0, 5);
1087 case llvm::Triple::aarch64_32:
1090 case llvm::Triple::aarch64: {
1096 case llvm::Triple::thumb:
1097 case llvm::Triple::arm:
1098 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
1102 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1111 if (LinkerVersion) {
1113 VersionTuple NewLinkerVersion;
1114 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1115 (void)NewLinkerVersion.tryParse(A->getValue());
1116 assert(NewLinkerVersion == LinkerVersion);
1118 return *LinkerVersion;
1121 VersionTuple NewLinkerVersion;
1122 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1123 if (NewLinkerVersion.tryParse(A->getValue()))
1125 << A->getAsString(Args);
1127 LinkerVersion = NewLinkerVersion;
1128 return *LinkerVersion;
1144 return Triple.getTriple();
1156 Str += llvm::Triple::getOSTypeName(llvm::Triple::XROS);
1160 Triple.setOSName(Str);
1162 return Triple.getTriple();
1174 return Dsymutil.get();
1178 return VerifyDebug.get();
1195 const ArgList &Args)
1200 CC1Args.push_back(
"-Wundef-prefix=TARGET_OS_");
1201 CC1Args.push_back(
"-Werror=undef-prefix");
1207 CC1Args.push_back(
"-Wdeprecated-objc-isa-usage");
1208 CC1Args.push_back(
"-Werror=deprecated-objc-isa-usage");
1213 CC1Args.push_back(
"-Werror=implicit-function-declaration");
1221 static constexpr llvm::StringLiteral XcodeAppSuffix(
1222 ".app/Contents/Developer");
1223 size_t Index = PathIntoXcode.find(XcodeAppSuffix);
1224 if (Index == StringRef::npos)
1226 return PathIntoXcode.take_front(Index + XcodeAppSuffix.size());
1230 ArgStringList &CmdArgs)
const {
1249 llvm::sys::path::remove_filename(
P);
1250 llvm::sys::path::remove_filename(
P);
1251 llvm::sys::path::append(
P,
"lib",
"arc");
1258 auto updatePath = [&](
const Arg *A) {
1262 if (XcodePathForSDK.empty())
1265 P = XcodePathForSDK;
1266 llvm::sys::path::append(
P,
"Toolchains/XcodeDefault.xctoolchain/usr",
1271 bool updated =
false;
1272 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot))
1273 updated = updatePath(A);
1276 if (
const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
1281 CmdArgs.push_back(
"-force_load");
1282 llvm::sys::path::append(
P,
"libarclite_");
1285 P +=
"watchsimulator";
1289 P +=
"appletvsimulator";
1293 P +=
"iphonesimulator";
1301 getDriver().
Diag(clang::diag::err_drv_darwin_sdk_missing_arclite) <<
P;
1303 CmdArgs.push_back(Args.MakeArgString(
P));
1325 bool IsShared)
const {
1333 const char *LibArg = Args.MakeArgString(
P);
1334 CmdArgs.push_back(LibArg);
1342 assert(StringRef(
P).ends_with(
".dylib") &&
"must be a dynamic library");
1346 CmdArgs.push_back(
"-rpath");
1347 CmdArgs.push_back(
"@executable_path");
1351 CmdArgs.push_back(
"-rpath");
1352 CmdArgs.push_back(Args.MakeArgString(llvm::sys::path::parent_path(
P)));
1359 "it doesn't make sense to ask for the compiler-rt library name as an "
1363 if (Component !=
"builtins") {
1364 MachOLibName +=
'.';
1365 MachOLibName += Component;
1370 llvm::sys::path::append(FullPath,
"lib",
"darwin",
"macho_embedded",
1372 return std::string(FullPath);
1378 "it doesn't make sense to ask for the compiler-rt library name as an "
1382 if (Component !=
"builtins") {
1383 DarwinLibName += Component;
1384 DarwinLibName +=
'_';
1390 llvm::sys::path::append(FullPath,
"lib",
"darwin", DarwinLibName);
1391 return std::string(FullPath);
1411 llvm_unreachable(
"Unsupported platform");
1416 auto BeginSDK = llvm::sys::path::rbegin(isysroot);
1417 auto EndSDK = llvm::sys::path::rend(isysroot);
1418 for (
auto IT = BeginSDK; IT != EndSDK; ++IT) {
1419 StringRef SDK = *IT;
1420 if (SDK.ends_with(
".sdk"))
1421 return SDK.slice(0, SDK.size() - 4);
1447 llvm_unreachable(
"Unsupported platform");
1452 for (Arg *A : Args) {
1453 if (A->getOption().matches(options::OPT_exported__symbols__list))
1455 if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
1456 !A->getOption().matches(options::OPT_Xlinker))
1458 if (A->containsValue(
"-exported_symbols_list") ||
1459 A->containsValue(
"-exported_symbol"))
1467 CmdArgs.push_back(
"-exported_symbol");
1468 CmdArgs.push_back(Symbol);
1478 StringRef Segment, StringRef Section) {
1479 for (
const char *A : {
"-sectalign", Args.MakeArgString(Segment),
1480 Args.MakeArgString(Section),
"0x4000"})
1481 CmdArgs.push_back(A);
1485 ArgStringList &CmdArgs)
const {
1514 for (
auto IPSK : {llvm::IPSK_cnts, llvm::IPSK_bitmap, llvm::IPSK_data}) {
1516 Args, CmdArgs,
"__DATA",
1517 llvm::getInstrProfSectionName(IPSK, llvm::Triple::MachO,
1523void DarwinClang::AddLinkSanitizerLibArgs(
const ArgList &Args,
1524 ArgStringList &CmdArgs,
1525 StringRef Sanitizer,
1526 bool Shared)
const {
1532 const ArgList &Args)
const {
1533 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1534 StringRef
Value = A->getValue();
1535 if (
Value !=
"compiler-rt" &&
Value !=
"platform")
1536 getDriver().
Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1537 <<
Value <<
"darwin";
1544 ArgStringList &CmdArgs,
1545 bool ForceLinkBuiltinRT)
const {
1551 if (Args.hasArg(options::OPT_static) ||
1552 Args.hasArg(options::OPT_fapple_kext) ||
1553 Args.hasArg(options::OPT_mkernel)) {
1554 if (ForceLinkBuiltinRT)
1562 if (
const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1563 getDriver().
Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1570 const char *sanitizer =
nullptr;
1572 sanitizer =
"UndefinedBehaviorSanitizer";
1574 sanitizer =
"RealtimeSanitizer";
1576 sanitizer =
"AddressSanitizer";
1578 sanitizer =
"ThreadSanitizer";
1581 getDriver().
Diag(diag::err_drv_unsupported_static_sanitizer_darwin)
1590 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan_abi",
false);
1593 "Static sanitizer runtimes not supported");
1594 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan");
1599 "Static sanitizer runtimes not supported");
1600 AddLinkSanitizerLibArgs(Args, CmdArgs,
"rtsan");
1603 AddLinkSanitizerLibArgs(Args, CmdArgs,
"lsan");
1606 "Static sanitizer runtimes not supported");
1607 AddLinkSanitizerLibArgs(
1613 "Static sanitizer runtimes not supported");
1614 AddLinkSanitizerLibArgs(Args, CmdArgs,
"tsan");
1617 AddLinkSanitizerLibArgs(Args, CmdArgs,
"tysan");
1618 if (Sanitize.
needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1619 AddLinkSanitizerLibArgs(Args, CmdArgs,
"fuzzer",
false);
1626 AddLinkSanitizerLibArgs(Args, CmdArgs,
"stats");
1638 CmdArgs.push_back(
"-framework");
1639 CmdArgs.push_back(
"DriverKit");
1645 CmdArgs.push_back(
"-lSystem");
1654 CmdArgs.push_back(
"-lgcc_s.1");
1664 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1665 if (!SystemTriple.isMacOSX())
1666 return std::string(MacOSSDKVersion);
1667 VersionTuple SystemVersion;
1668 SystemTriple.getMacOSXVersion(SystemVersion);
1670 unsigned Major, Minor, Micro;
1674 return std::string(MacOSSDKVersion);
1675 VersionTuple SDKVersion(Major, Minor, Micro);
1677 if (SDKVersion > SystemVersion)
1678 return SystemVersion.getAsString();
1679 return std::string(MacOSSDKVersion);
1685struct DarwinPlatform {
1694 DeploymentTargetEnv,
1704 DarwinPlatformKind getPlatform()
const {
return Platform; }
1706 DarwinEnvironmentKind getEnvironment()
const {
return Environment; }
1708 void setEnvironment(DarwinEnvironmentKind
Kind) {
1710 InferSimulatorFromArch =
false;
1713 StringRef getOSVersion()
const {
1714 if (
Kind == OSVersionArg)
1715 return Argument->getValue();
1719 void setOSVersion(StringRef S) {
1720 assert(
Kind == TargetArg &&
"Unexpected kind!");
1721 OSVersion = std::string(S);
1724 bool hasOSVersion()
const {
return HasOSVersion; }
1726 VersionTuple getNativeTargetVersion()
const {
1727 assert(Environment == DarwinEnvironmentKind::MacCatalyst &&
1728 "native target version is specified only for Mac Catalyst");
1729 return NativeTargetVersion;
1733 bool isExplicitlySpecified()
const {
return Kind <= DeploymentTargetEnv; }
1736 bool canInferSimulatorFromArch()
const {
return InferSimulatorFromArch; }
1738 const std::optional<llvm::Triple> &getTargetVariantTriple()
const {
1739 return TargetVariantTriple;
1743 void addOSVersionMinArgument(DerivedArgList &Args,
const OptTable &Opts) {
1746 assert(
Kind != TargetArg &&
Kind != MTargetOSArg &&
Kind != OSVersionArg &&
1750 case DarwinPlatformKind::MacOS:
1751 Opt = options::OPT_mmacos_version_min_EQ;
1753 case DarwinPlatformKind::IPhoneOS:
1754 Opt = options::OPT_mios_version_min_EQ;
1756 case DarwinPlatformKind::TvOS:
1757 Opt = options::OPT_mtvos_version_min_EQ;
1759 case DarwinPlatformKind::WatchOS:
1760 Opt = options::OPT_mwatchos_version_min_EQ;
1762 case DarwinPlatformKind::XROS:
1765 case DarwinPlatformKind::DriverKit:
1769 Argument = Args.MakeJoinedArg(
nullptr, Opts.getOption(Opt), OSVersion);
1770 Args.append(Argument);
1775 std::string
getAsString(DerivedArgList &Args,
const OptTable &Opts) {
1780 case InferredFromSDK:
1781 case InferredFromArch:
1782 assert(Argument &&
"OS version argument not yet inferred");
1783 return Argument->getAsString(Args);
1784 case DeploymentTargetEnv:
1785 return (llvm::Twine(EnvVarName) +
"=" + OSVersion).str();
1787 llvm_unreachable(
"Unsupported Darwin Source Kind");
1790 void setEnvironment(llvm::Triple::EnvironmentType EnvType,
1791 const VersionTuple &OSVersion,
1792 const std::optional<DarwinSDKInfo> &SDKInfo) {
1794 case llvm::Triple::Simulator:
1795 Environment = DarwinEnvironmentKind::Simulator;
1797 case llvm::Triple::MacABI: {
1798 Environment = DarwinEnvironmentKind::MacCatalyst;
1800 NativeTargetVersion = VersionTuple(10, 15);
1801 if (HasOSVersion && SDKInfo) {
1802 if (
const auto *MacCatalystToMacOSMapping = SDKInfo->getVersionMapping(
1804 if (
auto MacOSVersion = MacCatalystToMacOSMapping->map(
1805 OSVersion, NativeTargetVersion, std::nullopt)) {
1806 NativeTargetVersion = *MacOSVersion;
1813 if (TargetVariantTriple) {
1814 auto TargetVariantVersion = TargetVariantTriple->getOSVersion();
1815 if (TargetVariantVersion.getMajor()) {
1816 if (TargetVariantVersion < NativeTargetVersion)
1817 NativeTargetVersion = TargetVariantVersion;
1827 static DarwinPlatform
1828 createFromTarget(
const llvm::Triple &TT, StringRef OSVersion, Arg *A,
1829 std::optional<llvm::Triple> TargetVariantTriple,
1830 const std::optional<DarwinSDKInfo> &SDKInfo) {
1831 DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
1833 VersionTuple OsVersion = TT.getOSVersion();
1834 if (OsVersion.getMajor() == 0)
1835 Result.HasOSVersion =
false;
1836 Result.TargetVariantTriple = TargetVariantTriple;
1837 Result.setEnvironment(TT.getEnvironment(), OsVersion, SDKInfo);
1840 static DarwinPlatform
1841 createFromMTargetOS(llvm::Triple::OSType OS, VersionTuple OSVersion,
1842 llvm::Triple::EnvironmentType Environment, Arg *A,
1843 const std::optional<DarwinSDKInfo> &SDKInfo) {
1844 DarwinPlatform Result(MTargetOSArg, getPlatformFromOS(OS),
1845 OSVersion.getAsString(), A);
1846 Result.InferSimulatorFromArch =
false;
1847 Result.setEnvironment(Environment, OSVersion, SDKInfo);
1850 static DarwinPlatform createOSVersionArg(DarwinPlatformKind Platform, Arg *A,
1852 DarwinPlatform Result{OSVersionArg, Platform, A};
1854 Result.Environment = DarwinEnvironmentKind::Simulator;
1857 static DarwinPlatform createDeploymentTargetEnv(DarwinPlatformKind Platform,
1858 StringRef EnvVarName,
1860 DarwinPlatform Result(DeploymentTargetEnv, Platform,
Value);
1861 Result.EnvVarName = EnvVarName;
1864 static DarwinPlatform createFromSDK(DarwinPlatformKind Platform,
1866 bool IsSimulator =
false) {
1867 DarwinPlatform Result(InferredFromSDK, Platform,
Value);
1869 Result.Environment = DarwinEnvironmentKind::Simulator;
1870 Result.InferSimulatorFromArch =
false;
1873 static DarwinPlatform createFromArch(llvm::Triple::OSType OS,
1875 return DarwinPlatform(InferredFromArch, getPlatformFromOS(OS),
Value);
1882 assert(
Kind == InferredFromSDK &&
"can infer SDK info only");
1883 llvm::VersionTuple Version;
1884 bool IsValid = !Version.tryParse(OSVersion);
1886 assert(IsValid &&
"invalid SDK version");
1889 VersionTuple(Version.getMajor(), 0, 99));
1893 DarwinPlatform(SourceKind
Kind, DarwinPlatformKind Platform, Arg *Argument)
1894 :
Kind(
Kind), Platform(Platform), Argument(Argument) {}
1895 DarwinPlatform(SourceKind
Kind, DarwinPlatformKind Platform, StringRef
Value,
1896 Arg *Argument =
nullptr)
1897 :
Kind(
Kind), Platform(Platform), OSVersion(
Value), Argument(Argument) {}
1899 static DarwinPlatformKind getPlatformFromOS(llvm::Triple::OSType OS) {
1901 case llvm::Triple::Darwin:
1902 case llvm::Triple::MacOSX:
1903 return DarwinPlatformKind::MacOS;
1904 case llvm::Triple::IOS:
1905 return DarwinPlatformKind::IPhoneOS;
1906 case llvm::Triple::TvOS:
1907 return DarwinPlatformKind::TvOS;
1908 case llvm::Triple::WatchOS:
1909 return DarwinPlatformKind::WatchOS;
1910 case llvm::Triple::XROS:
1911 return DarwinPlatformKind::XROS;
1912 case llvm::Triple::DriverKit:
1913 return DarwinPlatformKind::DriverKit;
1915 llvm_unreachable(
"Unable to infer Darwin variant");
1920 DarwinPlatformKind Platform;
1921 DarwinEnvironmentKind Environment = DarwinEnvironmentKind::NativeEnvironment;
1922 VersionTuple NativeTargetVersion;
1923 std::string OSVersion;
1924 bool HasOSVersion =
true, InferSimulatorFromArch =
true;
1926 StringRef EnvVarName;
1927 std::optional<llvm::Triple> TargetVariantTriple;
1932std::optional<DarwinPlatform>
1933getDeploymentTargetFromOSVersionArg(DerivedArgList &Args,
1934 const Driver &TheDriver) {
1935 Arg *macOSVersion = Args.getLastArg(options::OPT_mmacos_version_min_EQ);
1936 Arg *iOSVersion = Args.getLastArg(options::OPT_mios_version_min_EQ,
1937 options::OPT_mios_simulator_version_min_EQ);
1939 Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1940 options::OPT_mtvos_simulator_version_min_EQ);
1941 Arg *WatchOSVersion =
1942 Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1943 options::OPT_mwatchos_simulator_version_min_EQ);
1945 if (iOSVersion || TvOSVersion || WatchOSVersion) {
1946 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1947 << macOSVersion->getAsString(Args)
1948 << (iOSVersion ? iOSVersion
1949 : TvOSVersion ? TvOSVersion : WatchOSVersion)
1952 return DarwinPlatform::createOSVersionArg(
Darwin::MacOS, macOSVersion,
1954 }
else if (iOSVersion) {
1955 if (TvOSVersion || WatchOSVersion) {
1956 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1957 << iOSVersion->getAsString(Args)
1958 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->
getAsString(Args);
1960 return DarwinPlatform::createOSVersionArg(
1962 iOSVersion->getOption().getID() ==
1963 options::OPT_mios_simulator_version_min_EQ);
1964 }
else if (TvOSVersion) {
1965 if (WatchOSVersion) {
1966 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1967 << TvOSVersion->getAsString(Args)
1968 << WatchOSVersion->getAsString(Args);
1970 return DarwinPlatform::createOSVersionArg(
1972 TvOSVersion->getOption().getID() ==
1973 options::OPT_mtvos_simulator_version_min_EQ);
1974 }
else if (WatchOSVersion)
1975 return DarwinPlatform::createOSVersionArg(
1977 WatchOSVersion->getOption().getID() ==
1978 options::OPT_mwatchos_simulator_version_min_EQ);
1979 return std::nullopt;
1984std::optional<DarwinPlatform>
1985getDeploymentTargetFromEnvironmentVariables(
const Driver &TheDriver,
1986 const llvm::Triple &Triple) {
1988 const char *EnvVars[] = {
1989 "MACOSX_DEPLOYMENT_TARGET",
1990 "IPHONEOS_DEPLOYMENT_TARGET",
1991 "TVOS_DEPLOYMENT_TARGET",
1992 "WATCHOS_DEPLOYMENT_TARGET",
1993 "DRIVERKIT_DEPLOYMENT_TARGET",
1994 "XROS_DEPLOYMENT_TARGET"
1997 "Missing platform");
1999 if (
char *
Env = ::getenv(I.value()))
2000 Targets[I.index()] =
Env;
2009 if (Triple.getArch() == llvm::Triple::arm ||
2010 Triple.getArch() == llvm::Triple::aarch64 ||
2011 Triple.getArch() == llvm::Triple::thumb)
2018 unsigned FirstTarget = std::size(Targets);
2019 for (
unsigned I = 0; I != std::size(Targets); ++I) {
2020 if (Targets[I].empty())
2022 if (FirstTarget == std::size(Targets))
2025 TheDriver.
Diag(diag::err_drv_conflicting_deployment_targets)
2026 << Targets[FirstTarget] << Targets[I];
2031 if (!
Target.value().empty())
2032 return DarwinPlatform::createDeploymentTargetEnv(
2036 return std::nullopt;
2041static StringRef dropSDKNamePrefix(StringRef SDKName) {
2042 size_t PrefixPos = SDKName.find(
'.');
2043 if (PrefixPos == StringRef::npos)
2045 return SDKName.substr(PrefixPos + 1);
2051std::optional<DarwinPlatform>
2052inferDeploymentTargetFromSDK(DerivedArgList &Args,
2053 const std::optional<DarwinSDKInfo> &SDKInfo) {
2054 const Arg *A = Args.getLastArg(options::OPT_isysroot);
2056 return std::nullopt;
2057 StringRef isysroot = A->getValue();
2060 return std::nullopt;
2062 std::string Version;
2065 Version = SDKInfo->getVersion().getAsString();
2069 size_t StartVer = SDK.find_first_of(
"0123456789");
2070 size_t EndVer = SDK.find_last_of(
"0123456789");
2071 if (StartVer != StringRef::npos && EndVer > StartVer)
2072 Version = std::string(SDK.slice(StartVer, EndVer + 1));
2074 if (Version.empty())
2075 return std::nullopt;
2077 auto CreatePlatformFromSDKName =
2078 [&](StringRef SDK) -> std::optional<DarwinPlatform> {
2079 if (SDK.starts_with(
"iPhoneOS") || SDK.starts_with(
"iPhoneSimulator"))
2080 return DarwinPlatform::createFromSDK(
2082 SDK.starts_with(
"iPhoneSimulator"));
2083 else if (SDK.starts_with(
"MacOSX"))
2086 else if (SDK.starts_with(
"WatchOS") || SDK.starts_with(
"WatchSimulator"))
2087 return DarwinPlatform::createFromSDK(
2089 SDK.starts_with(
"WatchSimulator"));
2090 else if (SDK.starts_with(
"AppleTVOS") ||
2091 SDK.starts_with(
"AppleTVSimulator"))
2092 return DarwinPlatform::createFromSDK(
2094 SDK.starts_with(
"AppleTVSimulator"));
2095 else if (SDK.starts_with(
"XR"))
2096 return DarwinPlatform::createFromSDK(
2098 SDK.contains(
"Simulator"));
2099 else if (SDK.starts_with(
"DriverKit"))
2101 return std::nullopt;
2103 if (
auto Result = CreatePlatformFromSDKName(SDK))
2106 return CreatePlatformFromSDKName(dropSDKNamePrefix(SDK));
2109std::string getOSVersion(llvm::Triple::OSType OS,
const llvm::Triple &Triple,
2110 const Driver &TheDriver) {
2111 VersionTuple OsVersion;
2112 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
2114 case llvm::Triple::Darwin:
2115 case llvm::Triple::MacOSX:
2118 if (Triple.isMacOSX() && SystemTriple.isMacOSX() &&
2119 !Triple.getOSMajorVersion())
2120 SystemTriple.getMacOSXVersion(OsVersion);
2121 else if (!Triple.getMacOSXVersion(OsVersion))
2122 TheDriver.
Diag(diag::err_drv_invalid_darwin_version)
2123 << Triple.getOSName();
2125 case llvm::Triple::IOS:
2126 if (Triple.isMacCatalystEnvironment() && !Triple.getOSMajorVersion()) {
2127 OsVersion = VersionTuple(13, 1);
2129 OsVersion = Triple.getiOSVersion();
2131 case llvm::Triple::TvOS:
2132 OsVersion = Triple.getOSVersion();
2134 case llvm::Triple::WatchOS:
2135 OsVersion = Triple.getWatchOSVersion();
2137 case llvm::Triple::XROS:
2138 OsVersion = Triple.getOSVersion();
2139 if (!OsVersion.getMajor())
2140 OsVersion = OsVersion.withMajorReplaced(1);
2142 case llvm::Triple::DriverKit:
2143 OsVersion = Triple.getDriverKitVersion();
2146 llvm_unreachable(
"Unexpected OS type");
2150 std::string OSVersion;
2151 llvm::raw_string_ostream(OSVersion)
2152 << OsVersion.getMajor() <<
'.' << OsVersion.getMinor().value_or(0) <<
'.'
2153 << OsVersion.getSubminor().value_or(0);
2158std::optional<DarwinPlatform>
2159inferDeploymentTargetFromArch(DerivedArgList &Args,
const Darwin &Toolchain,
2160 const llvm::Triple &Triple,
2161 const Driver &TheDriver) {
2162 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
2165 if (MachOArchName ==
"arm64" || MachOArchName ==
"arm64e")
2166 OSTy = llvm::Triple::MacOSX;
2167 else if (MachOArchName ==
"armv7" || MachOArchName ==
"armv7s")
2168 OSTy = llvm::Triple::IOS;
2169 else if (MachOArchName ==
"armv7k" || MachOArchName ==
"arm64_32")
2170 OSTy = llvm::Triple::WatchOS;
2171 else if (MachOArchName !=
"armv6m" && MachOArchName !=
"armv7m" &&
2172 MachOArchName !=
"armv7em")
2173 OSTy = llvm::Triple::MacOSX;
2174 if (OSTy == llvm::Triple::UnknownOS)
2175 return std::nullopt;
2176 return DarwinPlatform::createFromArch(OSTy,
2177 getOSVersion(OSTy, Triple, TheDriver));
2181std::optional<DarwinPlatform> getDeploymentTargetFromTargetArg(
2182 DerivedArgList &Args,
const llvm::Triple &Triple,
const Driver &TheDriver,
2183 const std::optional<DarwinSDKInfo> &SDKInfo) {
2184 if (!Args.hasArg(options::OPT_target))
2185 return std::nullopt;
2186 if (Triple.getOS() == llvm::Triple::Darwin ||
2187 Triple.getOS() == llvm::Triple::UnknownOS)
2188 return std::nullopt;
2189 std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
2190 std::optional<llvm::Triple> TargetVariantTriple;
2191 for (
const Arg *A : Args.filtered(options::OPT_darwin_target_variant)) {
2192 llvm::Triple TVT(A->getValue());
2194 if ((Triple.getArch() == llvm::Triple::aarch64 ||
2195 TVT.getArchName() == Triple.getArchName()) &&
2196 TVT.getArch() == Triple.getArch() &&
2197 TVT.getSubArch() == Triple.getSubArch() &&
2198 TVT.getVendor() == Triple.getVendor()) {
2199 if (TargetVariantTriple)
2204 if ((Triple.isMacOSX() && TVT.getOS() == llvm::Triple::IOS &&
2205 TVT.isMacCatalystEnvironment()) ||
2206 (TVT.isMacOSX() && Triple.getOS() == llvm::Triple::IOS &&
2207 Triple.isMacCatalystEnvironment())) {
2208 TargetVariantTriple = TVT;
2211 TheDriver.
Diag(diag::err_drv_target_variant_invalid)
2212 << A->getSpelling() << A->getValue();
2215 return DarwinPlatform::createFromTarget(Triple, OSVersion,
2216 Args.getLastArg(options::OPT_target),
2217 TargetVariantTriple, SDKInfo);
2221std::optional<DarwinPlatform> getDeploymentTargetFromMTargetOSArg(
2222 DerivedArgList &Args,
const Driver &TheDriver,
2223 const std::optional<DarwinSDKInfo> &SDKInfo) {
2224 auto *A = Args.getLastArg(options::OPT_mtargetos_EQ);
2226 return std::nullopt;
2227 llvm::Triple TT(llvm::Twine(
"unknown-apple-") + A->getValue());
2228 switch (TT.getOS()) {
2229 case llvm::Triple::MacOSX:
2230 case llvm::Triple::IOS:
2231 case llvm::Triple::TvOS:
2232 case llvm::Triple::WatchOS:
2233 case llvm::Triple::XROS:
2236 TheDriver.
Diag(diag::err_drv_invalid_os_in_arg)
2237 << TT.getOSName() << A->getAsString(Args);
2238 return std::nullopt;
2241 VersionTuple Version = TT.getOSVersion();
2242 if (!Version.getMajor()) {
2243 TheDriver.
Diag(diag::err_drv_invalid_version_number)
2244 << A->getAsString(Args);
2245 return std::nullopt;
2247 return DarwinPlatform::createFromMTargetOS(TT.getOS(), Version,
2248 TT.getEnvironment(), A, SDKInfo);
2251std::optional<DarwinSDKInfo> parseSDKSettings(llvm::vfs::FileSystem &VFS,
2252 const ArgList &Args,
2253 const Driver &TheDriver) {
2254 const Arg *A = Args.getLastArg(options::OPT_isysroot);
2256 return std::nullopt;
2257 StringRef isysroot = A->getValue();
2259 if (!SDKInfoOrErr) {
2260 llvm::consumeError(SDKInfoOrErr.takeError());
2261 TheDriver.
Diag(diag::warn_drv_darwin_sdk_invalid_settings);
2262 return std::nullopt;
2264 return *SDKInfoOrErr;
2269void Darwin::AddDeploymentTarget(DerivedArgList &Args)
const {
2275 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2277 if (!
getVFS().exists(A->getValue()))
2278 getDriver().
Diag(clang::diag::warn_missing_sysroot) << A->getValue();
2280 if (
char *env = ::getenv(
"SDKROOT")) {
2283 if (llvm::sys::path::is_absolute(env) &&
getVFS().exists(env) &&
2284 StringRef(env) !=
"/") {
2285 Args.append(Args.MakeSeparateArg(
2286 nullptr, Opts.getOption(options::OPT_isysroot), env));
2296 std::optional<DarwinPlatform> OSTarget =
2300 if (
const auto *MTargetOSArg = Args.getLastArg(options::OPT_mtargetos_EQ)) {
2301 std::string TargetArgStr = OSTarget->getAsString(Args, Opts);
2302 std::string MTargetOSArgStr = MTargetOSArg->getAsString(Args);
2304 << TargetArgStr << MTargetOSArgStr;
2306 std::optional<DarwinPlatform> OSVersionArgTarget =
2307 getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2308 if (OSVersionArgTarget) {
2309 unsigned TargetMajor, TargetMinor, TargetMicro;
2311 unsigned ArgMajor, ArgMinor, ArgMicro;
2313 if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
2315 TargetMinor, TargetMicro, TargetExtra) &&
2317 ArgMajor, ArgMinor, ArgMicro, ArgExtra) &&
2318 (VersionTuple(TargetMajor, TargetMinor, TargetMicro) !=
2319 VersionTuple(ArgMajor, ArgMinor, ArgMicro) ||
2320 TargetExtra != ArgExtra))) {
2323 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
2324 !OSTarget->hasOSVersion()) {
2325 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
2329 std::string OSVersionArg =
2330 OSVersionArgTarget->getAsString(Args, Opts);
2331 std::string TargetArg = OSTarget->getAsString(Args, Opts);
2333 << OSVersionArg << TargetArg;
2337 }
else if ((OSTarget = getDeploymentTargetFromMTargetOSArg(Args,
getDriver(),
2341 std::optional<DarwinPlatform> OSVersionArgTarget =
2342 getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2343 if (OSVersionArgTarget) {
2344 std::string MTargetOSArgStr = OSTarget->getAsString(Args, Opts);
2345 std::string OSVersionArgStr = OSVersionArgTarget->getAsString(Args, Opts);
2347 << MTargetOSArgStr << OSVersionArgStr;
2351 OSTarget = getDeploymentTargetFromOSVersionArg(Args,
getDriver());
2359 std::optional<DarwinPlatform> SDKTarget =
2360 inferDeploymentTargetFromSDK(Args,
SDKInfo);
2362 OSTarget->setEnvironment(SDKTarget->getEnvironment());
2369 OSTarget = inferDeploymentTargetFromSDK(Args,
SDKInfo);
2373 SDKInfo = OSTarget->inferSDKInfo();
2382 assert(OSTarget &&
"Unable to infer Darwin variant");
2383 OSTarget->addOSVersionMinArgument(Args, Opts);
2386 unsigned Major, Minor, Micro;
2389 const unsigned MajorVersionLimit = 1000;
2391 if (Platform ==
MacOS) {
2394 HadExtra || Major < 10 || Major >= MajorVersionLimit || Minor >= 100 ||
2397 << OSTarget->getAsString(Args, Opts);
2401 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2403 << OSTarget->getAsString(Args, Opts);
2406 (Major < 13 || (Major == 13 && Minor < 1))) {
2408 << OSTarget->getAsString(Args, Opts);
2415 if (
getTriple().isArch32Bit() && Major >= 11) {
2417 if (OSTarget->isExplicitlySpecified()) {
2419 getDriver().
Diag(diag::err_invalid_macos_32bit_deployment_target);
2422 << OSTarget->getAsString(Args, Opts);
2430 }
else if (Platform ==
TvOS) {
2433 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2435 << OSTarget->getAsString(Args, Opts);
2436 }
else if (Platform ==
WatchOS) {
2439 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2441 << OSTarget->getAsString(Args, Opts);
2445 HadExtra || Major < 19 || Major >= MajorVersionLimit || Minor >= 100 ||
2448 << OSTarget->getAsString(Args, Opts);
2449 }
else if (Platform ==
XROS) {
2452 HadExtra || Major < 1 || Major >= MajorVersionLimit || Minor >= 100 ||
2455 << OSTarget->getAsString(Args, Opts);
2457 llvm_unreachable(
"unknown kind of Darwin platform");
2462 Platform !=
DriverKit && OSTarget->canInferSimulatorFromArch() &&
2466 VersionTuple NativeTargetVersion;
2468 NativeTargetVersion = OSTarget->getNativeTargetVersion();
2469 setTarget(Platform, Environment, Major, Minor, Micro, NativeTargetVersion);
2472 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2474 if (SDK.size() > 0) {
2475 size_t StartVer = SDK.find_first_of(
"0123456789");
2476 StringRef SDKName = SDK.slice(0, StartVer);
2489 const llvm::Triple &
T) {
2490 if (
T.isDriverKit()) {
2491 llvm::sys::path::append(
Path,
"System",
"DriverKit");
2500 if (DriverArgs.hasArg(options::OPT_isysroot))
2501 Path = DriverArgs.getLastArgValue(options::OPT_isysroot);
2512 const llvm::opt::ArgList &DriverArgs,
2513 llvm::opt::ArgStringList &CC1Args)
const {
2518 bool NoStdInc = DriverArgs.hasArg(options::OPT_nostdinc);
2519 bool NoStdlibInc = DriverArgs.hasArg(options::OPT_nostdlibinc);
2520 bool NoBuiltinInc = DriverArgs.hasFlag(
2521 options::OPT_nobuiltininc, options::OPT_ibuiltininc,
false);
2522 bool ForceBuiltinInc = DriverArgs.hasFlag(
2523 options::OPT_ibuiltininc, options::OPT_nobuiltininc,
false);
2526 if (!NoStdInc && !NoStdlibInc) {
2528 llvm::sys::path::append(
P,
"usr",
"local",
"include");
2533 if (!(NoStdInc && !ForceBuiltinInc) && !NoBuiltinInc) {
2535 llvm::sys::path::append(
P,
"include");
2539 if (NoStdInc || NoStdlibInc)
2543 llvm::StringRef CIncludeDirs(C_INCLUDE_DIRS);
2544 if (!CIncludeDirs.empty()) {
2546 CIncludeDirs.split(dirs,
":");
2547 for (llvm::StringRef dir : dirs) {
2548 llvm::StringRef Prefix =
2549 llvm::sys::path::is_absolute(dir) ?
"" : llvm::StringRef(Sysroot);
2555 llvm::sys::path::append(
P,
"usr",
"include");
2560bool DarwinClang::AddGnuCPlusPlusIncludePaths(
const llvm::opt::ArgList &DriverArgs,
2561 llvm::opt::ArgStringList &CC1Args,
2563 llvm::StringRef Version,
2564 llvm::StringRef ArchDir,
2565 llvm::StringRef BitDir)
const {
2566 llvm::sys::path::append(
Base, Version);
2574 if (!ArchDir.empty())
2575 llvm::sys::path::append(
P, ArchDir);
2576 if (!BitDir.empty())
2577 llvm::sys::path::append(
P, BitDir);
2584 llvm::sys::path::append(
P,
"backward");
2592 const llvm::opt::ArgList &DriverArgs,
2593 llvm::opt::ArgStringList &CC1Args)
const {
2601 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
2602 options::OPT_nostdincxx))
2623 llvm::sys::path::append(InstallBin,
"..",
"include",
"c++",
"v1");
2624 if (
getVFS().exists(InstallBin)) {
2627 }
else if (DriverArgs.hasArg(options::OPT_v)) {
2628 llvm::errs() <<
"ignoring nonexistent directory \"" << InstallBin
2634 llvm::sys::path::append(SysrootUsr,
"usr",
"include",
"c++",
"v1");
2635 if (
getVFS().exists(SysrootUsr)) {
2638 }
else if (DriverArgs.hasArg(options::OPT_v)) {
2639 llvm::errs() <<
"ignoring nonexistent directory \"" << SysrootUsr
2648 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args);
2653void AppleMachO::AddGnuCPlusPlusIncludePaths(
2654 const llvm::opt::ArgList &DriverArgs,
2655 llvm::opt::ArgStringList &CC1Args)
const {}
2657void DarwinClang::AddGnuCPlusPlusIncludePaths(
2658 const llvm::opt::ArgList &DriverArgs,
2659 llvm::opt::ArgStringList &CC1Args)
const {
2661 llvm::sys::path::append(UsrIncludeCxx,
"usr",
"include",
"c++");
2664 bool IsBaseFound =
true;
2669 case llvm::Triple::x86:
2670 case llvm::Triple::x86_64:
2671 IsBaseFound = AddGnuCPlusPlusIncludePaths(
2672 DriverArgs, CC1Args, UsrIncludeCxx,
"4.2.1",
"i686-apple-darwin10",
2673 arch == llvm::Triple::x86_64 ?
"x86_64" :
"");
2674 IsBaseFound |= AddGnuCPlusPlusIncludePaths(
2675 DriverArgs, CC1Args, UsrIncludeCxx,
"4.0.0",
"i686-apple-darwin8",
"");
2678 case llvm::Triple::arm:
2679 case llvm::Triple::thumb:
2681 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
"4.2.1",
2682 "arm-apple-darwin10",
"v7");
2684 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
"4.2.1",
2685 "arm-apple-darwin10",
"v6");
2688 case llvm::Triple::aarch64:
2690 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
"4.2.1",
2691 "arm64-apple-darwin10",
"");
2701 ArgStringList &CmdArgs)
const {
2706 CmdArgs.push_back(
"-lc++");
2707 if (Args.hasArg(options::OPT_fexperimental_library))
2708 CmdArgs.push_back(
"-lc++experimental");
2718 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2720 llvm::sys::path::append(
P,
"usr",
"lib",
"libstdc++.dylib");
2723 llvm::sys::path::remove_filename(
P);
2724 llvm::sys::path::append(
P,
"libstdc++.6.dylib");
2726 CmdArgs.push_back(Args.MakeArgString(
P));
2735 if (!
getVFS().exists(
"/usr/lib/libstdc++.dylib") &&
2736 getVFS().exists(
"/usr/lib/libstdc++.6.dylib")) {
2737 CmdArgs.push_back(
"/usr/lib/libstdc++.6.dylib");
2742 CmdArgs.push_back(
"-lstdc++");
2748 ArgStringList &CmdArgs)
const {
2754 llvm::sys::path::append(
P,
"lib",
"darwin");
2758 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_watchos.a");
2760 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_tvos.a");
2762 llvm::sys::path::append(
P,
"libclang_rt.cc_kext_ios.a");
2766 llvm::sys::path::append(
2767 P, llvm::Twine(
"libclang_rt.cc_kext_") +
2768 llvm::Triple::getOSTypeName(llvm::Triple::XROS) +
".a");
2770 llvm::sys::path::append(
P,
"libclang_rt.cc_kext.a");
2776 CmdArgs.push_back(Args.MakeArgString(
P));
2780 StringRef BoundArch,
2782 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2792 for (Arg *A : Args) {
2793 if (A->getOption().matches(options::OPT_Xarch__)) {
2796 StringRef XarchArch = A->getValue(0);
2798 (!BoundArch.empty() && XarchArch == BoundArch)))
2801 Arg *OriginalArg = A;
2809 for (
const char *
Value : A->getValues()) {
2810 DAL->AddSeparateArg(
2811 OriginalArg, Opts.getOption(options::OPT_Zlinker_input),
Value);
2825 case options::OPT_mkernel:
2826 case options::OPT_fapple_kext:
2828 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
2831 case options::OPT_dependency_file:
2832 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
2835 case options::OPT_gfull:
2836 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2838 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
2841 case options::OPT_gused:
2842 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2844 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
2847 case options::OPT_shared:
2848 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
2851 case options::OPT_fconstant_cfstrings:
2852 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
2855 case options::OPT_fno_constant_cfstrings:
2856 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
2859 case options::OPT_Wnonportable_cfstrings:
2861 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
2864 case options::OPT_Wno_nonportable_cfstrings:
2866 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
2873 if (!BoundArch.empty()) {
2874 StringRef Name = BoundArch;
2875 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
2876 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
2882 else if (Name ==
"ppc601")
2883 DAL->AddJoinedArg(
nullptr, MCpu,
"601");
2884 else if (Name ==
"ppc603")
2885 DAL->AddJoinedArg(
nullptr, MCpu,
"603");
2886 else if (Name ==
"ppc604")
2887 DAL->AddJoinedArg(
nullptr, MCpu,
"604");
2888 else if (Name ==
"ppc604e")
2889 DAL->AddJoinedArg(
nullptr, MCpu,
"604e");
2890 else if (Name ==
"ppc750")
2891 DAL->AddJoinedArg(
nullptr, MCpu,
"750");
2892 else if (Name ==
"ppc7400")
2893 DAL->AddJoinedArg(
nullptr, MCpu,
"7400");
2894 else if (Name ==
"ppc7450")
2895 DAL->AddJoinedArg(
nullptr, MCpu,
"7450");
2896 else if (Name ==
"ppc970")
2897 DAL->AddJoinedArg(
nullptr, MCpu,
"970");
2899 else if (Name ==
"ppc64" || Name ==
"ppc64le")
2900 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2902 else if (Name ==
"i386")
2904 else if (Name ==
"i486")
2905 DAL->AddJoinedArg(
nullptr, MArch,
"i486");
2906 else if (Name ==
"i586")
2907 DAL->AddJoinedArg(
nullptr, MArch,
"i586");
2908 else if (Name ==
"i686")
2909 DAL->AddJoinedArg(
nullptr, MArch,
"i686");
2910 else if (Name ==
"pentium")
2911 DAL->AddJoinedArg(
nullptr, MArch,
"pentium");
2912 else if (Name ==
"pentium2")
2913 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2914 else if (Name ==
"pentpro")
2915 DAL->AddJoinedArg(
nullptr, MArch,
"pentiumpro");
2916 else if (Name ==
"pentIIm3")
2917 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2919 else if (Name ==
"x86_64" || Name ==
"x86_64h")
2920 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2922 else if (Name ==
"arm")
2923 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2924 else if (Name ==
"armv4t")
2925 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2926 else if (Name ==
"armv5")
2927 DAL->AddJoinedArg(
nullptr, MArch,
"armv5tej");
2928 else if (Name ==
"xscale")
2929 DAL->AddJoinedArg(
nullptr, MArch,
"xscale");
2930 else if (Name ==
"armv6")
2931 DAL->AddJoinedArg(
nullptr, MArch,
"armv6k");
2932 else if (Name ==
"armv6m")
2933 DAL->AddJoinedArg(
nullptr, MArch,
"armv6m");
2934 else if (Name ==
"armv7")
2935 DAL->AddJoinedArg(
nullptr, MArch,
"armv7a");
2936 else if (Name ==
"armv7em")
2937 DAL->AddJoinedArg(
nullptr, MArch,
"armv7em");
2938 else if (Name ==
"armv7k")
2939 DAL->AddJoinedArg(
nullptr, MArch,
"armv7k");
2940 else if (Name ==
"armv7m")
2941 DAL->AddJoinedArg(
nullptr, MArch,
"armv7m");
2942 else if (Name ==
"armv7s")
2943 DAL->AddJoinedArg(
nullptr, MArch,
"armv7s");
2950 ArgStringList &CmdArgs,
2951 bool ForceLinkBuiltinRT)
const {
2960 CompilerRT += Args.hasArg(options::OPT_fPIC) ?
"_pic" :
"_static";
2966 llvm::Triple::OSType OS;
2972 OS = llvm::Triple::MacOSX;
2975 OS = llvm::Triple::IOS;
2978 OS = llvm::Triple::TvOS;
2981 OS = llvm::Triple::WatchOS;
2995 const std::optional<DarwinSDKInfo> &SDKInfo) {
3015 VersionTuple SDKVersion = SDKInfo->getVersion();
3016 switch (TargetPlatform) {
3020 return SDKVersion >= VersionTuple(15U);
3022 switch (TargetEnvironment) {
3027 return SDKVersion >= VersionTuple(15U);
3029 return SDKVersion >= VersionTuple(18U);
3032 return SDKVersion >= VersionTuple(18U);
3034 return SDKVersion >= VersionTuple(11U);
3036 return SDKVersion >= VersionTuple(2U);
3044static inline llvm::VersionTuple
3049 case llvm::Triple::Darwin:
3050 case llvm::Triple::MacOSX:
3051 return llvm::VersionTuple(10U, 12U);
3052 case llvm::Triple::IOS:
3053 case llvm::Triple::TvOS:
3054 return llvm::VersionTuple(10U);
3055 case llvm::Triple::WatchOS:
3056 return llvm::VersionTuple(3U);
3059 llvm_unreachable(
"Unexpected OS");
3063 llvm::Triple::OSType OS;
3069 OS = llvm::Triple::MacOSX;
3072 OS = llvm::Triple::IOS;
3075 OS = llvm::Triple::TvOS;
3078 OS = llvm::Triple::WatchOS;
3090 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
3094 if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
3095 options::OPT_fno_aligned_allocation) &&
3097 CC1Args.push_back(
"-faligned-alloc-unavailable");
3101 if (!DriverArgs.hasArgNoClaim(options::OPT_fsized_deallocation,
3102 options::OPT_fno_sized_deallocation) &&
3104 CC1Args.push_back(
"-fno-sized-deallocation");
3110 CC1Args.push_back(
"-fcompatibility-qualified-id-block-type-checking");
3114 if (!DriverArgs.getLastArgNoClaim(
3115 options::OPT_fvisibility_inlines_hidden_static_local_var,
3116 options::OPT_fno_visibility_inlines_hidden_static_local_var))
3117 CC1Args.push_back(
"-fvisibility-inlines-hidden-static-local-var");
3131 CC1Args.push_back(
"-fbuiltin-headers-in-system-modules");
3133 if (!DriverArgs.hasArgNoClaim(options::OPT_fdefine_target_os_macros,
3134 options::OPT_fno_define_target_os_macros))
3135 CC1Args.push_back(
"-fdefine-target-os-macros");
3139 !DriverArgs.hasFlag(options::OPT_fmodulemap_allow_subdirectory_search,
3140 options::OPT_fno_modulemap_allow_subdirectory_search,
3142 bool RequiresSubdirectorySearch;
3143 VersionTuple SDKVersion =
SDKInfo->getVersion();
3146 RequiresSubdirectorySearch =
true;
3149 RequiresSubdirectorySearch = SDKVersion < VersionTuple(15, 0);
3153 RequiresSubdirectorySearch = SDKVersion < VersionTuple(18, 0);
3156 RequiresSubdirectorySearch = SDKVersion < VersionTuple(11, 0);
3159 RequiresSubdirectorySearch = SDKVersion < VersionTuple(2, 0);
3162 if (!RequiresSubdirectorySearch)
3163 CC1Args.push_back(
"-fno-modulemap-allow-subdirectory-search");
3168 const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CC1ASArgs)
const {
3170 CC1ASArgs.push_back(
"-darwin-target-variant-triple");
3177 auto EmitTargetSDKVersionArg = [&](
const VersionTuple &
V) {
3179 llvm::raw_string_ostream OS(Arg);
3180 OS <<
"-target-sdk-version=" <<
V;
3181 CC1ASArgs.push_back(Args.MakeArgString(Arg));
3185 if (
const auto *MacOStoMacCatalystMapping =
SDKInfo->getVersionMapping(
3187 std::optional<VersionTuple> SDKVersion = MacOStoMacCatalystMapping->map(
3190 EmitTargetSDKVersionArg(
3194 EmitTargetSDKVersionArg(
SDKInfo->getVersion());
3202 llvm::raw_string_ostream OS(Arg);
3203 OS <<
"-darwin-target-variant-sdk-version=" <<
SDKInfo->getVersion();
3204 CC1ASArgs.push_back(Args.MakeArgString(Arg));
3205 }
else if (
const auto *MacOStoMacCatalystMapping =
3208 if (std::optional<VersionTuple> SDKVersion =
3209 MacOStoMacCatalystMapping->map(
3213 llvm::raw_string_ostream OS(Arg);
3214 OS <<
"-darwin-target-variant-sdk-version=" << *SDKVersion;
3215 CC1ASArgs.push_back(Args.MakeArgString(Arg));
3226 DerivedArgList *DAL =
3230 if (BoundArch.empty())
3236 AddDeploymentTarget(*DAL);
3244 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
3247 if (A->getOption().getID() != options::OPT_mkernel &&
3248 A->getOption().getID() != options::OPT_fapple_kext)
3250 assert(it != ie &&
"unexpected argument translation");
3252 assert(A->getOption().getID() == options::OPT_static &&
3253 "missing expected -static argument");
3260 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
3261 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
3262 options::OPT_fno_omit_frame_pointer,
false))
3263 getDriver().
Diag(clang::diag::warn_drv_unsupported_opt_for_target)
3264 <<
"-fomit-frame-pointer" << BoundArch;
3273 if (
getArch() == llvm::Triple::x86_64 ||
3275 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
3277 return (
getArch() == llvm::Triple::aarch64 ||
3278 getArch() == llvm::Triple::aarch64_32)
3286 if (
const char *S = ::getenv(
"RC_DEBUG_OPTIONS"))
3287 return S[0] !=
'\0';
3292 if (
const char *S = ::getenv(
"RC_DEBUG_PREFIX_MAP"))
3301 return llvm::ExceptionHandling::None;
3305 if (Triple.isWatchABI())
3306 return llvm::ExceptionHandling::DwarfCFI;
3308 return llvm::ExceptionHandling::SjLj;
3323 return (
getArch() == llvm::Triple::x86_64 ||
3324 getArch() == llvm::Triple::aarch64);
3333 ArgStringList &CmdArgs)
const {
3336 assert(!
isTargetXROS() &&
"xrOS always uses -platform-version");
3339 CmdArgs.push_back(
"-watchos_version_min");
3341 CmdArgs.push_back(
"-watchos_simulator_version_min");
3343 CmdArgs.push_back(
"-tvos_version_min");
3345 CmdArgs.push_back(
"-tvos_simulator_version_min");
3347 CmdArgs.push_back(
"-driverkit_version_min");
3349 CmdArgs.push_back(
"-ios_simulator_version_min");
3351 CmdArgs.push_back(
"-iphoneos_version_min");
3353 CmdArgs.push_back(
"-maccatalyst_version_min");
3356 CmdArgs.push_back(
"-macosx_version_min");
3362 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3365 VersionTuple VariantTargetVersion;
3367 CmdArgs.push_back(
"-macosx_version_min");
3372 "unexpected target variant triple");
3373 CmdArgs.push_back(
"-maccatalyst_version_min");
3376 VersionTuple MinTgtVers =
3378 if (MinTgtVers.getMajor() && MinTgtVers > VariantTargetVersion)
3379 VariantTargetVersion = MinTgtVers;
3380 CmdArgs.push_back(Args.MakeArgString(VariantTargetVersion.getAsString()));
3391 return "mac catalyst";
3402 llvm_unreachable(
"invalid platform");
3406 llvm::opt::ArgStringList &CmdArgs)
const {
3407 auto EmitPlatformVersionArg =
3410 const llvm::Triple &TT) {
3413 CmdArgs.push_back(
"-platform_version");
3414 std::string PlatformName =
3417 PlatformName +=
"-simulator";
3418 CmdArgs.push_back(Args.MakeArgString(PlatformName));
3427 VersionTuple MinTgtVers = TT.getMinimumSupportedOSVersion();
3430 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3435 std::optional<VersionTuple> iOSSDKVersion;
3437 if (
const auto *MacOStoMacCatalystMapping =
3440 iOSSDKVersion = MacOStoMacCatalystMapping->map(
3441 SDKInfo->getVersion().withoutBuild(),
3445 CmdArgs.push_back(Args.MakeArgString(
3446 (iOSSDKVersion ? *iOSSDKVersion
3453 VersionTuple SDKVersion =
SDKInfo->getVersion().withoutBuild();
3454 if (!SDKVersion.getMinor())
3455 SDKVersion = VersionTuple(SDKVersion.getMajor(), 0);
3456 CmdArgs.push_back(Args.MakeArgString(SDKVersion.getAsString()));
3467 CmdArgs.push_back(Args.MakeArgString(
TargetVersion.getAsString()));
3476 VersionTuple TargetVariantVersion;
3484 "unexpected target variant triple");
3489 EmitPlatformVersionArg(TargetVariantVersion, Platform, Environment,
3495 ArgStringList &CmdArgs) {
3497 if (
D.isTargetIPhoneOS()) {
3498 if (
D.isIPhoneOSVersionLT(3, 1))
3499 CmdArgs.push_back(
"-ldylib1.o");
3503 if (!
D.isTargetMacOS())
3505 if (
D.isMacosxVersionLT(10, 5))
3506 CmdArgs.push_back(
"-ldylib1.o");
3507 else if (
D.isMacosxVersionLT(10, 6))
3508 CmdArgs.push_back(
"-ldylib1.10.5.o");
3513 ArgStringList &CmdArgs) {
3514 if (Args.hasArg(options::OPT_static))
3517 if ((
D.isTargetIPhoneOS() &&
D.isIPhoneOSVersionLT(3, 1)) ||
3518 (
D.isTargetMacOS() &&
D.isMacosxVersionLT(10, 6)))
3519 CmdArgs.push_back(
"-lbundle1.o");
3524 ArgStringList &CmdArgs) {
3525 if (
D.isTargetMacOS() &&
D.isMacosxVersionLT(10, 9)) {
3526 if (Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_object) ||
3527 Args.hasArg(options::OPT_preload)) {
3528 CmdArgs.push_back(
"-lgcrt0.o");
3530 CmdArgs.push_back(
"-lgcrt1.o");
3539 if (!
D.isMacosxVersionLT(10, 8))
3540 CmdArgs.push_back(
"-no_new_main");
3542 D.getDriver().Diag(diag::err_drv_clang_unsupported_opt_pg_darwin)
3543 <<
D.isTargetMacOSBased();
3548 ArgStringList &CmdArgs) {
3550 if (
D.isTargetIPhoneOS()) {
3551 if (
D.getArch() == llvm::Triple::aarch64)
3553 else if (
D.isIPhoneOSVersionLT(3, 1))
3554 CmdArgs.push_back(
"-lcrt1.o");
3555 else if (
D.isIPhoneOSVersionLT(6, 0))
3556 CmdArgs.push_back(
"-lcrt1.3.1.o");
3560 if (!
D.isTargetMacOS())
3562 if (
D.isMacosxVersionLT(10, 5))
3563 CmdArgs.push_back(
"-lcrt1.o");
3564 else if (
D.isMacosxVersionLT(10, 6))
3565 CmdArgs.push_back(
"-lcrt1.10.5.o");
3566 else if (
D.isMacosxVersionLT(10, 8))
3567 CmdArgs.push_back(
"-lcrt1.10.6.o");
3572 ArgStringList &CmdArgs)
const {
3574 if (Args.hasArg(options::OPT_dynamiclib))
3576 else if (Args.hasArg(options::OPT_bundle))
3580 else if (Args.hasArg(options::OPT_static) ||
3581 Args.hasArg(options::OPT_object) ||
3582 Args.hasArg(options::OPT_preload))
3583 CmdArgs.push_back(
"-lcrt0.o");
3587 if (
isTargetMacOS() && Args.hasArg(options::OPT_shared_libgcc) &&
3589 const char *Str = Args.MakeArgString(
GetFilePath(
"crt3.o"));
3590 CmdArgs.push_back(Str);
3602 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
3603 const bool IsAArch64 =
getTriple().getArch() == llvm::Triple::aarch64;
3605 Res |= SanitizerKind::Address;
3606 Res |= SanitizerKind::PointerCompare;
3607 Res |= SanitizerKind::PointerSubtract;
3608 Res |= SanitizerKind::Realtime;
3609 Res |= SanitizerKind::Leak;
3610 Res |= SanitizerKind::Fuzzer;
3611 Res |= SanitizerKind::FuzzerNoLink;
3612 Res |= SanitizerKind::ObjCCast;
3619 Res |= SanitizerKind::Vptr;
3621 if ((IsX86_64 || IsAArch64) &&
3624 Res |= SanitizerKind::Thread;
3628 Res |= SanitizerKind::Type;
3632 Res |= SanitizerKind::NumericalStability;
Defines a function that returns the minimum OS versions supporting C++17's aligned allocation functio...
enum clang::sema::@1724::IndirectLocalPathEntry::EntryKind Kind
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 llvm::VersionTuple sizedDeallocMinVersion(llvm::Triple::OSType OS)
static VersionTuple minimumMacCatalystDeploymentTarget()
static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion)
Returns the most appropriate macOS target version for the current process.
static bool sdkSupportsBuiltinModules(const Darwin::DarwinPlatformKind &TargetPlatform, const Darwin::DarwinEnvironmentKind &TargetEnvironment, const std::optional< DarwinSDKInfo > &SDKInfo)
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.
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
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
bool needsStatsRt() const
bool linkRuntimes() const
bool needsUbsanRt() const
bool needsRtsanRt() const
bool requiresMinimalRuntime() const
bool needsSharedRt() const
bool needsTysanRt() 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()