clang: lib/Driver/ToolChains/Darwin.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
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"
30#include
31
35using namespace clang;
37
39 return VersionTuple(13, 1);
40}
41
43
44
45
46
47
48
49
50
51
52
53
54
55 return llvm::StringSwitchllvm::Triple::ArchType(Str)
56 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
57 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
58 llvm::Triple::x86)
59 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
60
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);
73}
74
76 const ArgList &Args) {
77 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
78 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseArch(Str);
79 T.setArch(Arch);
80 if (Arch != llvm::Triple::UnknownArch)
81 T.setArchName(Str);
82
83 if (ArchKind == llvm::ARM::ArchKind::ARMV6M ||
84 ArchKind == llvm::ARM::ArchKind::ARMV7M ||
85 ArchKind == llvm::ARM::ArchKind::ARMV7EM) {
86
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();
96
97 T.setOS(llvm::Triple::UnknownOS);
98 T.setObjectFormat(llvm::Triple::MachO);
99 }
100}
101
105 const ArgList &Args,
106 const char *LinkingOutput) const {
107 const llvm::Triple &T(getToolChain().getTriple());
108
109 ArgStringList CmdArgs;
110
111 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
112 const InputInfo &Input = Inputs[0];
113
114
115 const Action *SourceAction = &JA;
117 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
118 SourceAction = SourceAction->getInputs()[0];
119 }
120
121
122
123
124
125
126 if (Args.hasArg(options::OPT_fno_integrated_as)) {
127 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
128 CmdArgs.push_back("-Q");
129 }
130
131
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");
138 }
139
140
142
143
144 if (T.isX86() || Args.hasArg(options::OPT_force__cpusubtype__ALL))
145 CmdArgs.push_back("-force_cpusubtype_ALL");
146
147 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
148 (((Args.hasArg(options::OPT_mkernel) ||
149 Args.hasArg(options::OPT_fapple_kext)) &&
151 Args.hasArg(options::OPT_static)))
152 CmdArgs.push_back("-static");
153
154 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
155
156 assert(Output.isFilename() && "Unexpected lipo output.");
157 CmdArgs.push_back("-o");
159
160 assert(Input.isFilename() && "Invalid input.");
162
163
164
165 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
167 Exec, CmdArgs, Inputs, Output));
168}
169
170void darwin::MachOTool::anchor() {}
171
173 ArgStringList &CmdArgs) const {
174 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
175
176
177 CmdArgs.push_back("-arch");
178 CmdArgs.push_back(Args.MakeArgString(ArchName));
179
180
181 if (ArchName == "arm")
182 CmdArgs.push_back("-force_cpusubtype_ALL");
183}
184
185bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const {
186
187
188
189 for (const auto &Input : Inputs)
190 if (Input.getType() != types::TY_Object)
191 return true;
192
193 return false;
194}
195
196
197
198
199
200
201
202
204 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
205 if (A->getOption().matches(options::OPT_O0))
206 return true;
207 if (A->getOption().matches(options::OPT_O))
208 return llvm::StringSwitch(A->getValue())
209 .Case("1", true)
210 .Default(false);
211 return false;
212 }
213
214 if (!IsLinkerOnlyAction)
215 return true;
216 return false;
217}
218
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();
226
227
228
229 if ((Version >= VersionTuple(100) || LinkerIsLLD) &&
230 !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
231 CmdArgs.push_back("-demangle");
232
233 if (Args.hasArg(options::OPT_rdynamic) &&
234 (Version >= VersionTuple(137) || LinkerIsLLD))
235 CmdArgs.push_back("-export_dynamic");
236
237
238
239 if (Args.hasFlag(options::OPT_fapplication_extension,
240 options::OPT_fno_application_extension, false))
241 CmdArgs.push_back("-application_extension");
242
243 if (D.isUsingLTO() && (Version >= VersionTuple(116) || LinkerIsLLD) &&
244 NeedsTempPath(Inputs)) {
245 std::string TmpPathName;
247
248
249
250 TmpPathName =
252 } else if (D.getLTOMode() == LTOK_Thin)
253
254 TmpPathName = D.GetTemporaryDirectory("thinlto");
255
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);
261 }
262 }
263
264
265
266
267
268
269
270
271
272
273 if (Version >= VersionTuple(133) && !LinkerIsLLD) {
274
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));
281 }
282
283
284
285
286 if (Version >= VersionTuple(262) &&
288 CmdArgs.push_back("-no_deduplicate");
289
290
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)) {
295
296
297 }
298
299 if (!Args.hasArg(options::OPT_dynamiclib)) {
300 AddMachOArch(Args, CmdArgs);
301
302 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
303
304 Args.AddLastArg(CmdArgs, options::OPT_bundle);
305 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
306 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
307
308 Arg *A;
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)
313 << "-dynamiclib";
314
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);
318 } else {
319 CmdArgs.push_back("-dylib");
320
321 Arg *A;
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)
329 << "-dynamiclib";
330
331 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
332 "-dylib_compatibility_version");
333 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
334 "-dylib_current_version");
335
336 AddMachOArch(Args, CmdArgs);
337
338 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
339 "-dylib_install_name");
340 }
341
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);
357
358
359 if (Version >= VersionTuple(520) || LinkerIsLLD || UsePlatformVersion)
361 else
363
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);
369
370 if (const Arg *A =
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");
376 else
377 CmdArgs.push_back("-no_pie");
378 }
379
380
381 if (C.getDriver().embedBitcodeEnabled()) {
382
384 CmdArgs.push_back("-bitcode_bundle");
385
386 if (C.getDriver().embedBitcodeMarkerOnly() &&
387 Version >= VersionTuple(278)) {
388 CmdArgs.push_back("-bitcode_process_mode");
389 CmdArgs.push_back("marker");
390 }
391 } else
392 D.Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
393 }
394
395
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");
401
402 CmdArgs.push_back("-mllvm");
403 CmdArgs.push_back("-global-isel-abort=0");
404 }
405 }
406
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");
412 }
413
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);
430
431
432
433
434
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));
444 }
445
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);
467
468 if (LinkerIsLLD) {
471 ? ""
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));
482 }
483
484 auto *CodeGenDataGenArg =
485 Args.getLastArg(options::OPT_fcodegen_data_generate_EQ);
486 if (CodeGenDataGenArg)
487 CmdArgs.push_back(
488 Args.MakeArgString(Twine("--codegen-data-generate-path=") +
489 CodeGenDataGenArg->getValue()));
490 }
491}
492
493
496 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
497 return true;
498 }
499 return Args.hasArg(options::OPT_fobjc_link_runtime);
500}
501
503 const llvm::Triple &Triple) {
504
505
506
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";
514 return false;
515 }
516 return true;
517}
518
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();
525
526 CmdArgs.push_back("-mllvm");
527 CmdArgs.push_back("-lto-pass-remarks-output");
528 CmdArgs.push_back("-mllvm");
529
530 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
531 if (A) {
532 CmdArgs.push_back(A->getValue());
533 } else {
534 assert(Output.isFilename() && "Unexpected ld output.");
537 F += ".opt.";
538 F += Format;
539
540 CmdArgs.push_back(Args.MakeArgString(F));
541 }
542
543 if (const Arg *A =
544 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
545 CmdArgs.push_back("-mllvm");
546 std::string Passes =
547 std::string("-lto-pass-remarks-filter=") + A->getValue();
548 CmdArgs.push_back(Args.MakeArgString(Passes));
549 }
550
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));
555 }
556
558 CmdArgs.push_back("-mllvm");
559 CmdArgs.push_back("-lto-pass-remarks-with-hotness");
560
561 if (const Arg *A =
562 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
563 CmdArgs.push_back("-mllvm");
564 std::string Opt =
565 std::string("-lto-pass-remarks-hotness-threshold=") + A->getValue();
566 CmdArgs.push_back(Args.MakeArgString(Opt));
567 }
568 }
569}
570
572
576 const ArgList &Args,
577 const char *LinkingOutput) const {
578 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
579
580
581
582
583
584 llvm::opt::ArgStringList InputFileList;
585
586
587
588
589 ArgStringList CmdArgs;
590
591
592 if (Args.hasArg(options::OPT_ccc_arcmt_check,
593 options::OPT_ccc_arcmt_migrate)) {
594 for (const auto &Arg : Args)
595 Arg->claim();
596 const char *Exec =
597 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
599 C.addCommand(std::make_unique(JA, *this,
601 CmdArgs, std::nullopt, Output));
602 return;
603 }
604
605 VersionTuple Version = getMachOToolChain().getLinkerVersion(Args);
606
607 bool LinkerIsLLD;
608 const char *Exec =
609 Args.MakeArgString(getToolChain().GetLinkerPath(&LinkerIsLLD));
610
611
612 bool UsePlatformVersion = getToolChain().getTriple().isXROS();
613
614
615
616 AddLinkArgs(C, Args, CmdArgs, Inputs, Version, LinkerIsLLD,
617 UsePlatformVersion);
618
621 getToolChain().getTriple()))
623
624
625 if (Arg *A =
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");
631 }
632 } else {
633
634
635
636 CmdArgs.push_back("-mllvm");
637 CmdArgs.push_back("-enable-machine-outliner=never");
638 }
639 }
640
641
642
643
644 CmdArgs.push_back("-mllvm");
645 CmdArgs.push_back("-enable-linkonceodr-outlining");
646
647
648 auto *CodeGenDataGenArg =
649 Args.getLastArg(options::OPT_fcodegen_data_generate_EQ);
650 auto *CodeGenDataUseArg = Args.getLastArg(options::OPT_fcodegen_data_use_EQ);
651
652
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);
658
659
660
661 if (CodeGenDataGenArg) {
662 CmdArgs.push_back("-mllvm");
663 CmdArgs.push_back("-codegen-data-generate");
664 }
665
666
667 if (CodeGenDataUseArg) {
668 CmdArgs.push_back("-mllvm");
669 CmdArgs.push_back(Args.MakeArgString(Twine("-codegen-data-use-path=") +
670 CodeGenDataUseArg->getValue()));
671 }
672
673
675 getStatsFileName(Args, Output, Inputs[0], getToolChain().getDriver());
676 if (!StatsFile.empty()) {
677 CmdArgs.push_back("-mllvm");
678 CmdArgs.push_back(Args.MakeArgString("-lto-stats-file=" + StatsFile.str()));
679 }
680
681
682
683 Args.addAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
684 options::OPT_Z_Flag, options::OPT_u_Group});
685
686
687
688
689 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
690 CmdArgs.push_back("-ObjC");
691
692 CmdArgs.push_back("-o");
694
695 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
696 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
697
698 Args.AddAllArgs(CmdArgs, options::OPT_L);
699
700 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
701
702
703 for (const auto &II : Inputs) {
704 if (!II.isFilename()) {
705
706
707
708
709 if (InputFileList.size() > 0)
710 break;
711
712 continue;
713 }
714
715 InputFileList.push_back(II.getFilename());
716 }
717
718
719
720 if (getToolChain().getDriver().IsFlangMode() &&
721 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
724 }
725
726 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
728
730 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
731
732 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
733
734 CmdArgs.push_back("-framework");
735 CmdArgs.push_back("Foundation");
736
737 CmdArgs.push_back("-lobjc");
738 }
739
740 if (LinkingOutput) {
741 CmdArgs.push_back("-arch_multiple");
742 CmdArgs.push_back("-final_output");
743 CmdArgs.push_back(LinkingOutput);
744 }
745
746 if (Args.hasArg(options::OPT_fnested_functions))
747 CmdArgs.push_back("-allow_stack_execute");
748
749 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
750
751 StringRef Parallelism = getLTOParallelism(Args, getToolChain().getDriver());
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)));
757 }
758
759 if (getToolChain().ShouldLinkCXXStdlib(Args))
760 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
761
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) {
766
767
768
769
770 if (NoStdOrDefaultLibs && ForceLinkBuiltins) {
771 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs, "builtins");
772 } else {
773
774 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs,
775 ForceLinkBuiltins);
776
777
778 Args.ClaimAllArgs(options::OPT_pthread);
779 Args.ClaimAllArgs(options::OPT_pthreads);
780 }
781 }
782
783 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
784
785 }
786
787 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
788 Args.AddAllArgs(CmdArgs, options::OPT_F);
789
790
791 for (const Arg *A : Args.filtered(options::OPT_iframework))
792 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
793
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");
799 }
800 }
801 }
802
803
804
805
806 {
807 bool NonStandardSearchPath = false;
808 const auto &Triple = getToolChain().getTriple();
809 if (Triple.isDriverKit()) {
810
811 NonStandardSearchPath =
812 Version.getMajor() < 605 ||
813 (Version.getMajor() == 605 && Version.getMinor().value_or(0) < 1);
814 }
815
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));
824 }
825 };
826 AddSearchPath("-L", "/usr/lib");
827 AddSearchPath("-F", "/System/Library/Frameworks");
828 }
829 }
830 }
831
833 if (Version >= VersionTuple(705) || LinkerIsLLD) {
835 } else {
836
838 "-filelist"};
839 }
840
841 std::unique_ptr Cmd = std::make_unique(
842 JA, *this, ResponseSupport, Exec, CmdArgs, Inputs, Output);
843 Cmd->setInputFileList(std::move(InputFileList));
844 C.addCommand(std::move(Cmd));
845}
846
850 const ArgList &Args,
851 const char *LinkingOutput) const {
852 const Driver &D = getToolChain().getDriver();
853
854
855 Args.ClaimAllArgs(options::OPT_g_Group);
856
857 Args.ClaimAllArgs(options::OPT_emit_llvm);
858
859
860 Args.ClaimAllArgs(options::OPT_w);
861
862 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
863
864
865 ArgStringList CmdArgs;
866
867 CmdArgs.push_back("-static");
868 CmdArgs.push_back("-D");
869 CmdArgs.push_back("-no_warning_for_no_symbols");
870 CmdArgs.push_back("-o");
872
873 for (const auto &II : Inputs) {
874 if (II.isFilename()) {
875 CmdArgs.push_back(II.getFilename());
876 }
877 }
878
879
880
881 const auto *OutputFileName = Output.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();
885 return;
886 }
887 }
888
889 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
890 C.addCommand(std::make_unique(JA, *this,
892 Exec, CmdArgs, Inputs, Output));
893}
894
898 const ArgList &Args,
899 const char *LinkingOutput) const {
900 ArgStringList CmdArgs;
901
902 CmdArgs.push_back("-create");
903 assert(Output.isFilename() && "Unexpected lipo output.");
904
905 CmdArgs.push_back("-output");
907
908 for (const auto &II : Inputs) {
909 assert(II.isFilename() && "Unexpected lipo input.");
910 CmdArgs.push_back(II.getFilename());
911 }
912
913 StringRef LipoName = Args.getLastArgValue(options::OPT_fuse_lipo_EQ, "lipo");
914 const char *Exec =
915 Args.MakeArgString(getToolChain().GetProgramPath(LipoName.data()));
917 Exec, CmdArgs, Inputs, Output));
918}
919
923 const ArgList &Args,
924 const char *LinkingOutput) const {
925 ArgStringList CmdArgs;
926
927 CmdArgs.push_back("-o");
929
930 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
931 const InputInfo &Input = Inputs[0];
932 assert(Input.isFilename() && "Unexpected dsymutil input.");
934
935 const char *Exec =
936 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
938 Exec, CmdArgs, Inputs, Output));
939}
940
944 const ArgList &Args,
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");
951
952 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
953 const InputInfo &Input = Inputs[0];
954 assert(Input.isFilename() && "Unexpected verify input");
955
956
958
959 const char *Exec =
960 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
962 Exec, CmdArgs, Inputs, Output));
963}
964
967
969}
970
972 const ArgList &Args)
973 : MachO(D, Triple, Args), CudaInstallation(D, Triple, Args),
974 RocmInstallation(D, Triple, Args), SYCLInstallation(D, Triple, Args) {}
975
976
979
982
983
984 if (Ty == types::TY_PP_Asm)
985 return types::TY_Asm;
986
987 return Ty;
988}
989
991
993
995}
996
997
1004
1005 auto T = llvm::Triple(Twine("arm64-apple-") +
1006 llvm::Triple::getOSTypeName(llvm::Triple::XROS) +
1009 }
1010 if (isNonFragile)
1013}
1014
1015
1018 return true;
1021 else {
1024 }
1025}
1026
1028 ArgStringList &CC1Args) const {
1030}
1031
1033 ArgStringList &CC1Args) const {
1035}
1036
1038 ArgStringList &CC1Args) const {
1040}
1041
1042
1043
1044
1045
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")
1060 .Default(nullptr);
1061}
1062
1064 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
1065 if (ArchKind == llvm::ARM::ArchKind::INVALID)
1066 return nullptr;
1067 StringRef Arch = llvm::ARM::getArchName(ArchKind);
1068
1069
1070
1071 if (Arch.starts_with("armv5"))
1072 Arch = Arch.substr(0, 5);
1073
1074 else if (Arch.starts_with("armv6") && !Arch.ends_with("6m"))
1075 Arch = Arch.substr(0, 5);
1076
1077 else if (Arch.ends_with("v7a"))
1078 Arch = Arch.substr(0, 5);
1079 return Arch.data();
1080}
1081
1084 default:
1086
1087 case llvm::Triple::aarch64_32:
1088 return "arm64_32";
1089
1090 case llvm::Triple::aarch64: {
1092 return "arm64e";
1093 return "arm64";
1094 }
1095
1096 case llvm::Triple::thumb:
1097 case llvm::Triple::arm:
1098 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
1100 return Arch;
1101
1102 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1104 return Arch;
1105
1106 return "arm";
1107 }
1108}
1109
1111 if (LinkerVersion) {
1112#ifndef NDEBUG
1113 VersionTuple NewLinkerVersion;
1114 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1115 (void)NewLinkerVersion.tryParse(A->getValue());
1116 assert(NewLinkerVersion == LinkerVersion);
1117#endif
1118 return *LinkerVersion;
1119 }
1120
1121 VersionTuple NewLinkerVersion;
1122 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1123 if (NewLinkerVersion.tryParse(A->getValue()))
1124 getDriver().Diag(diag::err_drv_invalid_version_number)
1125 << A->getAsString(Args);
1126
1127 LinkerVersion = NewLinkerVersion;
1128 return *LinkerVersion;
1129}
1130
1132
1134
1136
1140
1141
1142
1144 return Triple.getTriple();
1145
1148 Str += "watchos";
1150 Str += "tvos";
1152 Str += "driverkit";
1154 Str += "ios";
1156 Str += llvm::Triple::getOSTypeName(llvm::Triple::XROS);
1157 else
1158 Str += "macosx";
1160 Triple.setOSName(Str);
1161
1162 return Triple.getTriple();
1163}
1164
1166 switch (AC) {
1168 if (!Lipo)
1170 return Lipo.get();
1172 if (!Dsymutil)
1174 return Dsymutil.get();
1176 if (!VerifyDebug)
1178 return VerifyDebug.get();
1179 default:
1181 }
1182}
1183
1185
1188}
1189
1192}
1193
1195 const ArgList &Args)
1196 : Darwin(D, Triple, Args) {}
1197
1199
1200 CC1Args.push_back("-Wundef-prefix=TARGET_OS_");
1201 CC1Args.push_back("-Werror=undef-prefix");
1202
1203
1205
1206
1207 CC1Args.push_back("-Wdeprecated-objc-isa-usage");
1208 CC1Args.push_back("-Werror=deprecated-objc-isa-usage");
1209
1210
1211
1213 CC1Args.push_back("-Werror=implicit-function-declaration");
1214 }
1215}
1216
1217
1218
1219
1221 static constexpr llvm::StringLiteral XcodeAppSuffix(
1222 ".app/Contents/Developer");
1223 size_t Index = PathIntoXcode.find(XcodeAppSuffix);
1224 if (Index == StringRef::npos)
1225 return "";
1226 return PathIntoXcode.take_front(Index + XcodeAppSuffix.size());
1227}
1228
1230 ArgStringList &CmdArgs) const {
1231
1233 return;
1235 return;
1236
1238 return;
1240 return;
1241
1243
1246 return;
1247
1249 llvm::sys::path::remove_filename(P);
1250 llvm::sys::path::remove_filename(P);
1251 llvm::sys::path::append(P, "lib", "arc");
1252
1253
1254
1255
1256
1257 if (().exists(P)) {
1258 auto updatePath = [&](const Arg *A) {
1259
1260
1262 if (XcodePathForSDK.empty())
1263 return false;
1264
1265 P = XcodePathForSDK;
1266 llvm::sys::path::append(P, "Toolchains/XcodeDefault.xctoolchain/usr",
1267 "lib", "arc");
1268 return getVFS().exists(P);
1269 };
1270
1271 bool updated = false;
1272 if (const Arg *A = Args.getLastArg(options::OPT_isysroot))
1273 updated = updatePath(A);
1274
1275 if (!updated) {
1276 if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
1277 updatePath(A);
1278 }
1279 }
1280
1281 CmdArgs.push_back("-force_load");
1282 llvm::sys::path::append(P, "libarclite_");
1283
1285 P += "watchsimulator";
1287 P += "watchos";
1289 P += "appletvsimulator";
1291 P += "appletvos";
1293 P += "iphonesimulator";
1295 P += "iphoneos";
1296 else
1297 P += "macosx";
1298 P += ".a";
1299
1300 if (().exists(P))
1301 getDriver().Diag(clang::diag::err_drv_darwin_sdk_missing_arclite) << P;
1302
1303 CmdArgs.push_back(Args.MakeArgString(P));
1304}
1305
1307
1310 return 2;
1311
1318 TargetVersion.empty()))
1319 return 4;
1320 return 5;
1321}
1322
1325 bool IsShared) const {
1328
1329
1330
1331
1333 const char *LibArg = Args.MakeArgString(P);
1334 CmdArgs.push_back(LibArg);
1335 }
1336
1337
1338
1339
1340
1342 assert(StringRef(P).ends_with(".dylib") && "must be a dynamic library");
1343
1344
1345
1346 CmdArgs.push_back("-rpath");
1347 CmdArgs.push_back("@executable_path");
1348
1349
1350
1351 CmdArgs.push_back("-rpath");
1352 CmdArgs.push_back(Args.MakeArgString(llvm::sys::path::parent_path(P)));
1353 }
1354}
1355
1359 "it doesn't make sense to ask for the compiler-rt library name as an "
1360 "object file");
1361 SmallString<64> MachOLibName = StringRef("libclang_rt");
1362
1363 if (Component != "builtins") {
1364 MachOLibName += '.';
1365 MachOLibName += Component;
1366 }
1368
1370 llvm::sys::path::append(FullPath, "lib", "darwin", "macho_embedded",
1371 MachOLibName);
1372 return std::string(FullPath);
1373}
1374
1378 "it doesn't make sense to ask for the compiler-rt library name as an "
1379 "object file");
1380 SmallString<64> DarwinLibName = StringRef("libclang_rt.");
1381
1382 if (Component != "builtins") {
1383 DarwinLibName += Component;
1384 DarwinLibName += '_';
1385 }
1388
1390 llvm::sys::path::append(FullPath, "lib", "darwin", DarwinLibName);
1391 return std::string(FullPath);
1392}
1393
1397 return "MacOSX";
1400 return "MacOSX";
1401 return "iPhone";
1403 return "AppleTV";
1405 return "Watch";
1407 return "DriverKit";
1409 return "XR";
1410 }
1411 llvm_unreachable("Unsupported platform");
1412}
1413
1415
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);
1422 }
1423 return "";
1424}
1425
1429 return "osx";
1432 return "osx";
1434 : "iossim";
1437 : "tvossim";
1440 : "watchossim";
1443 : "xrossim";
1445 return "driverkit";
1446 }
1447 llvm_unreachable("Unsupported platform");
1448}
1449
1450
1452 for (Arg *A : Args) {
1453 if (A->getOption().matches(options::OPT_exported__symbols__list))
1454 return true;
1455 if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
1456 !A->getOption().matches(options::OPT_Xlinker))
1457 continue;
1458 if (A->containsValue("-exported_symbols_list") ||
1459 A->containsValue("-exported_symbol"))
1460 return true;
1461 }
1462 return false;
1463}
1464
1465
1467 CmdArgs.push_back("-exported_symbol");
1468 CmdArgs.push_back(Symbol);
1469}
1470
1471
1472
1473
1474
1475
1476
1478 StringRef Segment, StringRef Section) {
1479 for (const char *A : {"-sectalign", Args.MakeArgString(Segment),
1480 Args.MakeArgString(Section), "0x4000"})
1481 CmdArgs.push_back(A);
1482}
1483
1485 ArgStringList &CmdArgs) const {
1487 return;
1488
1491
1493
1494
1495
1496
1502 }
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513 if (!ForGCOV) {
1514 for (auto IPSK : {llvm::IPSK_cnts, llvm::IPSK_bitmap, llvm::IPSK_data}) {
1516 Args, CmdArgs, "__DATA",
1517 llvm::getInstrProfSectionName(IPSK, llvm::Triple::MachO,
1518 false));
1519 }
1520 }
1521}
1522
1523void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
1524 ArgStringList &CmdArgs,
1525 StringRef Sanitizer,
1526 bool Shared) const {
1529}
1530
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";
1538 }
1539
1541}
1542
1544 ArgStringList &CmdArgs,
1545 bool ForceLinkBuiltinRT) const {
1546
1548
1549
1550
1551 if (Args.hasArg(options::OPT_static) ||
1552 Args.hasArg(options::OPT_fapple_kext) ||
1553 Args.hasArg(options::OPT_mkernel)) {
1554 if (ForceLinkBuiltinRT)
1556 return;
1557 }
1558
1559
1560
1561
1562 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1563 getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1564 return;
1565 }
1566
1568
1570 const char *sanitizer = nullptr;
1572 sanitizer = "UndefinedBehaviorSanitizer";
1574 sanitizer = "RealtimeSanitizer";
1576 sanitizer = "AddressSanitizer";
1578 sanitizer = "ThreadSanitizer";
1579 }
1580 if (sanitizer) {
1581 getDriver().Diag(diag::err_drv_unsupported_static_sanitizer_darwin)
1582 << sanitizer;
1583 return;
1584 }
1585 }
1586
1590 AddLinkSanitizerLibArgs(Args, CmdArgs, "asan_abi", false);
1591 } else {
1593 "Static sanitizer runtimes not supported");
1594 AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
1595 }
1596 }
1599 "Static sanitizer runtimes not supported");
1600 AddLinkSanitizerLibArgs(Args, CmdArgs, "rtsan");
1601 }
1603 AddLinkSanitizerLibArgs(Args, CmdArgs, "lsan");
1606 "Static sanitizer runtimes not supported");
1607 AddLinkSanitizerLibArgs(
1608 Args, CmdArgs,
1610 }
1613 "Static sanitizer runtimes not supported");
1614 AddLinkSanitizerLibArgs(Args, CmdArgs, "tsan");
1615 }
1617 AddLinkSanitizerLibArgs(Args, CmdArgs, "tysan");
1618 if (Sanitize.needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1619 AddLinkSanitizerLibArgs(Args, CmdArgs, "fuzzer", false);
1620
1621
1623 }
1626 AddLinkSanitizerLibArgs(Args, CmdArgs, "stats");
1627 }
1628 }
1629
1635 }
1636
1637 if (isTargetDriverKit() && !Args.hasArg(options::OPT_nodriverkitlib)) {
1638 CmdArgs.push_back("-framework");
1639 CmdArgs.push_back("DriverKit");
1640 }
1641
1642
1643
1645 CmdArgs.push_back("-lSystem");
1646
1647
1649
1650
1651
1654 CmdArgs.push_back("-lgcc_s.1");
1655 }
1657}
1658
1659
1660
1661
1662
1664 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1665 if (!SystemTriple.isMacOSX())
1666 return std::string(MacOSSDKVersion);
1667 VersionTuple SystemVersion;
1668 SystemTriple.getMacOSXVersion(SystemVersion);
1669
1670 unsigned Major, Minor, Micro;
1671 bool HadExtra;
1673 HadExtra))
1674 return std::string(MacOSSDKVersion);
1675 VersionTuple SDKVersion(Major, Minor, Micro);
1676
1677 if (SDKVersion > SystemVersion)
1678 return SystemVersion.getAsString();
1679 return std::string(MacOSSDKVersion);
1680}
1681
1682namespace {
1683
1684
1685struct DarwinPlatform {
1686 enum SourceKind {
1687
1688 TargetArg,
1689
1690 MTargetOSArg,
1691
1692 OSVersionArg,
1693
1694 DeploymentTargetEnv,
1695
1696 InferredFromSDK,
1697
1698 InferredFromArch
1699 };
1700
1703
1704 DarwinPlatformKind getPlatform() const { return Platform; }
1705
1706 DarwinEnvironmentKind getEnvironment() const { return Environment; }
1707
1708 void setEnvironment(DarwinEnvironmentKind Kind) {
1709 Environment = Kind;
1710 InferSimulatorFromArch = false;
1711 }
1712
1713 StringRef getOSVersion() const {
1714 if (Kind == OSVersionArg)
1715 return Argument->getValue();
1716 return OSVersion;
1717 }
1718
1719 void setOSVersion(StringRef S) {
1720 assert(Kind == TargetArg && "Unexpected kind!");
1721 OSVersion = std::string(S);
1722 }
1723
1724 bool hasOSVersion() const { return HasOSVersion; }
1725
1726 VersionTuple getNativeTargetVersion() const {
1727 assert(Environment == DarwinEnvironmentKind::MacCatalyst &&
1728 "native target version is specified only for Mac Catalyst");
1729 return NativeTargetVersion;
1730 }
1731
1732
1733 bool isExplicitlySpecified() const { return Kind <= DeploymentTargetEnv; }
1734
1735
1736 bool canInferSimulatorFromArch() const { return InferSimulatorFromArch; }
1737
1738 const std::optionalllvm::Triple &getTargetVariantTriple() const {
1739 return TargetVariantTriple;
1740 }
1741
1742
1743 void addOSVersionMinArgument(DerivedArgList &Args, const OptTable &Opts) {
1744 if (Argument)
1745 return;
1746 assert(Kind != TargetArg && Kind != MTargetOSArg && Kind != OSVersionArg &&
1747 "Invalid kind");
1749 switch (Platform) {
1750 case DarwinPlatformKind::MacOS:
1751 Opt = options::OPT_mmacos_version_min_EQ;
1752 break;
1753 case DarwinPlatformKind::IPhoneOS:
1754 Opt = options::OPT_mios_version_min_EQ;
1755 break;
1756 case DarwinPlatformKind::TvOS:
1757 Opt = options::OPT_mtvos_version_min_EQ;
1758 break;
1759 case DarwinPlatformKind::WatchOS:
1760 Opt = options::OPT_mwatchos_version_min_EQ;
1761 break;
1762 case DarwinPlatformKind::XROS:
1763
1764 return;
1765 case DarwinPlatformKind::DriverKit:
1766
1767 return;
1768 }
1769 Argument = Args.MakeJoinedArg(nullptr, Opts.getOption(Opt), OSVersion);
1770 Args.append(Argument);
1771 }
1772
1773
1774
1775 std::string getAsString(DerivedArgList &Args, const OptTable &Opts) {
1776 switch (Kind) {
1777 case TargetArg:
1778 case MTargetOSArg:
1779 case OSVersionArg:
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();
1786 }
1787 llvm_unreachable("Unsupported Darwin Source Kind");
1788 }
1789
1790 void setEnvironment(llvm::Triple::EnvironmentType EnvType,
1791 const VersionTuple &OSVersion,
1792 const std::optional &SDKInfo) {
1793 switch (EnvType) {
1794 case llvm::Triple::Simulator:
1795 Environment = DarwinEnvironmentKind::Simulator;
1796 break;
1797 case llvm::Triple::MacABI: {
1798 Environment = DarwinEnvironmentKind::MacCatalyst;
1799
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;
1807 }
1808 }
1809 }
1810
1811
1812
1813 if (TargetVariantTriple) {
1814 auto TargetVariantVersion = TargetVariantTriple->getOSVersion();
1815 if (TargetVariantVersion.getMajor()) {
1816 if (TargetVariantVersion < NativeTargetVersion)
1817 NativeTargetVersion = TargetVariantVersion;
1818 }
1819 }
1820 break;
1821 }
1822 default:
1823 break;
1824 }
1825 }
1826
1827 static DarwinPlatform
1828 createFromTarget(const llvm::Triple &TT, StringRef OSVersion, Arg *A,
1829 std::optionalllvm::Triple TargetVariantTriple,
1830 const std::optional &SDKInfo) {
1831 DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
1832 A);
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);
1838 return Result;
1839 }
1840 static DarwinPlatform
1841 createFromMTargetOS(llvm::Triple::OSType OS, VersionTuple OSVersion,
1842 llvm::Triple::EnvironmentType Environment, Arg *A,
1843 const std::optional &SDKInfo) {
1844 DarwinPlatform Result(MTargetOSArg, getPlatformFromOS(OS),
1845 OSVersion.getAsString(), A);
1846 Result.InferSimulatorFromArch = false;
1847 Result.setEnvironment(Environment, OSVersion, SDKInfo);
1848 return Result;
1849 }
1850 static DarwinPlatform createOSVersionArg(DarwinPlatformKind Platform, Arg *A,
1851 bool IsSimulator) {
1852 DarwinPlatform Result{OSVersionArg, Platform, A};
1853 if (IsSimulator)
1854 Result.Environment = DarwinEnvironmentKind::Simulator;
1855 return Result;
1856 }
1857 static DarwinPlatform createDeploymentTargetEnv(DarwinPlatformKind Platform,
1858 StringRef EnvVarName,
1859 StringRef Value) {
1860 DarwinPlatform Result(DeploymentTargetEnv, Platform, Value);
1861 Result.EnvVarName = EnvVarName;
1862 return Result;
1863 }
1864 static DarwinPlatform createFromSDK(DarwinPlatformKind Platform,
1865 StringRef Value,
1866 bool IsSimulator = false) {
1867 DarwinPlatform Result(InferredFromSDK, Platform, Value);
1868 if (IsSimulator)
1869 Result.Environment = DarwinEnvironmentKind::Simulator;
1870 Result.InferSimulatorFromArch = false;
1871 return Result;
1872 }
1873 static DarwinPlatform createFromArch(llvm::Triple::OSType OS,
1874 StringRef Value) {
1875 return DarwinPlatform(InferredFromArch, getPlatformFromOS(OS), Value);
1876 }
1877
1878
1879
1880
1882 assert(Kind == InferredFromSDK && "can infer SDK info only");
1883 llvm::VersionTuple Version;
1884 bool IsValid = !Version.tryParse(OSVersion);
1885 (void)IsValid;
1886 assert(IsValid && "invalid SDK version");
1888 Version,
1889 VersionTuple(Version.getMajor(), 0, 99));
1890 }
1891
1892private:
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) {}
1898
1899 static DarwinPlatformKind getPlatformFromOS(llvm::Triple::OSType OS) {
1900 switch (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;
1914 default:
1915 llvm_unreachable("Unable to infer Darwin variant");
1916 }
1917 }
1918
1919 SourceKind Kind;
1920 DarwinPlatformKind Platform;
1921 DarwinEnvironmentKind Environment = DarwinEnvironmentKind::NativeEnvironment;
1922 VersionTuple NativeTargetVersion;
1923 std::string OSVersion;
1924 bool HasOSVersion = true, InferSimulatorFromArch = true;
1925 Arg *Argument;
1926 StringRef EnvVarName;
1927 std::optionalllvm::Triple TargetVariantTriple;
1928};
1929
1930
1931
1932std::optional
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);
1938 Arg *TvOSVersion =
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);
1944 if (macOSVersion) {
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)
1951 }
1952 return DarwinPlatform::createOSVersionArg(Darwin::MacOS, macOSVersion,
1953 false);
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);
1959 }
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);
1969 }
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;
1980}
1981
1982
1983
1984std::optional
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"
1995 };
1997 "Missing platform");
1998 for (const auto &I : llvm::enumerate(llvm::ArrayRef(EnvVars))) {
1999 if (char *Env = ::getenv(I.value()))
2000 Targets[I.index()] = Env;
2001 }
2002
2003
2004
2009 if (Triple.getArch() == llvm::Triple::arm ||
2010 Triple.getArch() == llvm::Triple::aarch64 ||
2011 Triple.getArch() == llvm::Triple::thumb)
2013 else
2016 } else {
2017
2018 unsigned FirstTarget = std::size(Targets);
2019 for (unsigned I = 0; I != std::size(Targets); ++I) {
2020 if (Targets[I].empty())
2021 continue;
2022 if (FirstTarget == std::size(Targets))
2023 FirstTarget = I;
2024 else
2025 TheDriver.Diag(diag::err_drv_conflicting_deployment_targets)
2026 << Targets[FirstTarget] << Targets[I];
2027 }
2028 }
2029
2031 if (.value().empty())
2032 return DarwinPlatform::createDeploymentTargetEnv(
2035 }
2036 return std::nullopt;
2037}
2038
2039
2040
2041static StringRef dropSDKNamePrefix(StringRef SDKName) {
2042 size_t PrefixPos = SDKName.find('.');
2043 if (PrefixPos == StringRef::npos)
2044 return "";
2045 return SDKName.substr(PrefixPos + 1);
2046}
2047
2048
2049
2050
2051std::optional
2052inferDeploymentTargetFromSDK(DerivedArgList &Args,
2053 const std::optional &SDKInfo) {
2054 const Arg *A = Args.getLastArg(options::OPT_isysroot);
2055 if (!A)
2056 return std::nullopt;
2057 StringRef isysroot = A->getValue();
2059 if (!SDK.size())
2060 return std::nullopt;
2061
2062 std::string Version;
2063 if (SDKInfo) {
2064
2065 Version = SDKInfo->getVersion().getAsString();
2066 } else {
2067
2068
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));
2073 }
2074 if (Version.empty())
2075 return std::nullopt;
2076
2077 auto CreatePlatformFromSDKName =
2078 [&](StringRef SDK) -> std::optional {
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"))
2084 return DarwinPlatform::createFromSDK(Darwin::MacOS,
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"))
2100 return DarwinPlatform::createFromSDK(Darwin::DriverKit, Version);
2101 return std::nullopt;
2102 };
2103 if (auto Result = CreatePlatformFromSDKName(SDK))
2105
2106 return CreatePlatformFromSDKName(dropSDKNamePrefix(SDK));
2107}
2108
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());
2113 switch (OS) {
2114 case llvm::Triple::Darwin:
2115 case llvm::Triple::MacOSX:
2116
2117
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();
2124 break;
2125 case llvm::Triple::IOS:
2126 if (Triple.isMacCatalystEnvironment() && !Triple.getOSMajorVersion()) {
2127 OsVersion = VersionTuple(13, 1);
2128 } else
2129 OsVersion = Triple.getiOSVersion();
2130 break;
2131 case llvm::Triple::TvOS:
2132 OsVersion = Triple.getOSVersion();
2133 break;
2134 case llvm::Triple::WatchOS:
2135 OsVersion = Triple.getWatchOSVersion();
2136 break;
2137 case llvm::Triple::XROS:
2138 OsVersion = Triple.getOSVersion();
2139 if (!OsVersion.getMajor())
2140 OsVersion = OsVersion.withMajorReplaced(1);
2141 break;
2142 case llvm::Triple::DriverKit:
2143 OsVersion = Triple.getDriverKitVersion();
2144 break;
2145 default:
2146 llvm_unreachable("Unexpected OS type");
2147 break;
2148 }
2149
2150 std::string OSVersion;
2151 llvm::raw_string_ostream(OSVersion)
2152 << OsVersion.getMajor() << '.' << OsVersion.getMinor().value_or(0) << '.'
2153 << OsVersion.getSubminor().value_or(0);
2154 return OSVersion;
2155}
2156
2157
2158std::optional
2159inferDeploymentTargetFromArch(DerivedArgList &Args, const Darwin &Toolchain,
2160 const llvm::Triple &Triple,
2161 const Driver &TheDriver) {
2162 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
2163
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));
2178}
2179
2180
2181std::optional getDeploymentTargetFromTargetArg(
2182 DerivedArgList &Args, const llvm::Triple &Triple, const Driver &TheDriver,
2183 const std::optional &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::optionalllvm::Triple TargetVariantTriple;
2191 for (const Arg *A : Args.filtered(options::OPT_darwin_target_variant)) {
2192 llvm::Triple TVT(A->getValue());
2193
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)
2200 continue;
2201 A->claim();
2202
2203
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;
2209 continue;
2210 }
2211 TheDriver.Diag(diag::err_drv_target_variant_invalid)
2212 << A->getSpelling() << A->getValue();
2213 }
2214 }
2215 return DarwinPlatform::createFromTarget(Triple, OSVersion,
2216 Args.getLastArg(options::OPT_target),
2217 TargetVariantTriple, SDKInfo);
2218}
2219
2220
2221std::optional getDeploymentTargetFromMTargetOSArg(
2222 DerivedArgList &Args, const Driver &TheDriver,
2223 const std::optional &SDKInfo) {
2224 auto *A = Args.getLastArg(options::OPT_mtargetos_EQ);
2225 if (!A)
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:
2234 break;
2235 default:
2236 TheDriver.Diag(diag::err_drv_invalid_os_in_arg)
2237 << TT.getOSName() << A->getAsString(Args);
2238 return std::nullopt;
2239 }
2240
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;
2246 }
2247 return DarwinPlatform::createFromMTargetOS(TT.getOS(), Version,
2248 TT.getEnvironment(), A, SDKInfo);
2249}
2250
2251std::optional parseSDKSettings(llvm::vfs::FileSystem &VFS,
2252 const ArgList &Args,
2253 const Driver &TheDriver) {
2254 const Arg *A = Args.getLastArg(options::OPT_isysroot);
2255 if (!A)
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;
2263 }
2264 return *SDKInfoOrErr;
2265}
2266
2267}
2268
2269void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
2271
2272
2273
2274
2275 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2276
2277 if (().exists(A->getValue()))
2278 getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
2279 } else {
2280 if (char *env = ::getenv("SDKROOT")) {
2281
2282
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));
2287 }
2288 }
2289 }
2290
2291
2292
2294
2295
2296 std::optional OSTarget =
2298 if (OSTarget) {
2299
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);
2303 getDriver().Diag(diag::err_drv_cannot_mix_options)
2304 << TargetArgStr << MTargetOSArgStr;
2305 }
2306 std::optional OSVersionArgTarget =
2307 getDeploymentTargetFromOSVersionArg(Args, getDriver());
2308 if (OSVersionArgTarget) {
2309 unsigned TargetMajor, TargetMinor, TargetMicro;
2310 bool TargetExtra;
2311 unsigned ArgMajor, ArgMinor, ArgMicro;
2312 bool ArgExtra;
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))) {
2321
2322
2323 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
2324 !OSTarget->hasOSVersion()) {
2325 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
2326 } else {
2327
2328
2329 std::string OSVersionArg =
2330 OSVersionArgTarget->getAsString(Args, Opts);
2331 std::string TargetArg = OSTarget->getAsString(Args, Opts);
2332 getDriver().Diag(clang::diag::warn_drv_overriding_option)
2333 << OSVersionArg << TargetArg;
2334 }
2335 }
2336 }
2337 } else if ((OSTarget = getDeploymentTargetFromMTargetOSArg(Args, getDriver(),
2339
2340
2341 std::optional OSVersionArgTarget =
2342 getDeploymentTargetFromOSVersionArg(Args, getDriver());
2343 if (OSVersionArgTarget) {
2344 std::string MTargetOSArgStr = OSTarget->getAsString(Args, Opts);
2345 std::string OSVersionArgStr = OSVersionArgTarget->getAsString(Args, Opts);
2346 getDriver().Diag(diag::err_drv_cannot_mix_options)
2347 << MTargetOSArgStr << OSVersionArgStr;
2348 }
2349 } else {
2350
2351 OSTarget = getDeploymentTargetFromOSVersionArg(Args, getDriver());
2352
2353
2354 if (!OSTarget) {
2355 OSTarget =
2356 getDeploymentTargetFromEnvironmentVariables(getDriver(), getTriple());
2357 if (OSTarget) {
2358
2359 std::optional SDKTarget =
2360 inferDeploymentTargetFromSDK(Args, SDKInfo);
2361 if (SDKTarget)
2362 OSTarget->setEnvironment(SDKTarget->getEnvironment());
2363 }
2364 }
2365
2366
2367
2368 if (!OSTarget) {
2369 OSTarget = inferDeploymentTargetFromSDK(Args, SDKInfo);
2370
2371
2372 if (OSTarget && )
2373 SDKInfo = OSTarget->inferSDKInfo();
2374 }
2375
2376
2377 if (!OSTarget)
2378 OSTarget =
2379 inferDeploymentTargetFromArch(Args, *this, getTriple(), getDriver());
2380 }
2381
2382 assert(OSTarget && "Unable to infer Darwin variant");
2383 OSTarget->addOSVersionMinArgument(Args, Opts);
2385
2386 unsigned Major, Minor, Micro;
2387 bool HadExtra;
2388
2389 const unsigned MajorVersionLimit = 1000;
2390
2391 if (Platform == MacOS) {
2393 Micro, HadExtra) ||
2394 HadExtra || Major < 10 || Major >= MajorVersionLimit || Minor >= 100 ||
2395 Micro >= 100)
2396 getDriver().Diag(diag::err_drv_invalid_version_number)
2397 << OSTarget->getAsString(Args, Opts);
2398 } else if (Platform == IPhoneOS) {
2400 Micro, HadExtra) ||
2401 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2402 getDriver().Diag(diag::err_drv_invalid_version_number)
2403 << OSTarget->getAsString(Args, Opts);
2404 ;
2405 if (OSTarget->getEnvironment() == MacCatalyst &&
2406 (Major < 13 || (Major == 13 && Minor < 1))) {
2407 getDriver().Diag(diag::err_drv_invalid_version_number)
2408 << OSTarget->getAsString(Args, Opts);
2409 Major = 13;
2410 Minor = 1;
2411 Micro = 0;
2412 }
2413
2414
2415 if (getTriple().isArch32Bit() && Major >= 11) {
2416
2417 if (OSTarget->isExplicitlySpecified()) {
2418 if (OSTarget->getEnvironment() == MacCatalyst)
2419 getDriver().Diag(diag::err_invalid_macos_32bit_deployment_target);
2420 else
2421 getDriver().Diag(diag::warn_invalid_ios_deployment_target)
2422 << OSTarget->getAsString(Args, Opts);
2423
2424 } else {
2425 Major = 10;
2426 Minor = 99;
2427 Micro = 99;
2428 }
2429 }
2430 } else if (Platform == TvOS) {
2432 Micro, HadExtra) ||
2433 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2434 getDriver().Diag(diag::err_drv_invalid_version_number)
2435 << OSTarget->getAsString(Args, Opts);
2436 } else if (Platform == WatchOS) {
2438 Micro, HadExtra) ||
2439 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2440 getDriver().Diag(diag::err_drv_invalid_version_number)
2441 << OSTarget->getAsString(Args, Opts);
2442 } else if (Platform == DriverKit) {
2444 Micro, HadExtra) ||
2445 HadExtra || Major < 19 || Major >= MajorVersionLimit || Minor >= 100 ||
2446 Micro >= 100)
2447 getDriver().Diag(diag::err_drv_invalid_version_number)
2448 << OSTarget->getAsString(Args, Opts);
2449 } else if (Platform == XROS) {
2451 Micro, HadExtra) ||
2452 HadExtra || Major < 1 || Major >= MajorVersionLimit || Minor >= 100 ||
2453 Micro >= 100)
2454 getDriver().Diag(diag::err_drv_invalid_version_number)
2455 << OSTarget->getAsString(Args, Opts);
2456 } else
2457 llvm_unreachable("unknown kind of Darwin platform");
2458
2460
2462 Platform != DriverKit && OSTarget->canInferSimulatorFromArch() &&
2465
2466 VersionTuple NativeTargetVersion;
2468 NativeTargetVersion = OSTarget->getNativeTargetVersion();
2469 setTarget(Platform, Environment, Major, Minor, Micro, NativeTargetVersion);
2471
2472 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2473 StringRef SDK = getSDKName(A->getValue());
2474 if (SDK.size() > 0) {
2475 size_t StartVer = SDK.find_first_of("0123456789");
2476 StringRef SDKName = SDK.slice(0, StartVer);
2479 getDriver().Diag(diag::warn_incompatible_sysroot)
2481 }
2482 }
2483}
2484
2485
2486
2487
2489 const llvm::Triple &T) {
2490 if (T.isDriverKit()) {
2491 llvm::sys::path::append(Path, "System", "DriverKit");
2492 }
2493}
2494
2495
2496
2500 if (DriverArgs.hasArg(options::OPT_isysroot))
2501 Path = DriverArgs.getLastArgValue(options::OPT_isysroot);
2502 else if (().SysRoot.empty())
2504
2507 }
2508 return Path;
2509}
2510
2512 const llvm::opt::ArgList &DriverArgs,
2513 llvm::opt::ArgStringList &CC1Args) const {
2515
2517
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);
2524
2525
2526 if (!NoStdInc && !NoStdlibInc) {
2528 llvm::sys::path::append(P, "usr", "local", "include");
2530 }
2531
2532
2533 if (!(NoStdInc && !ForceBuiltinInc) && !NoBuiltinInc) {
2535 llvm::sys::path::append(P, "include");
2537 }
2538
2539 if (NoStdInc || NoStdlibInc)
2540 return;
2541
2542
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);
2551 }
2552 } else {
2553
2555 llvm::sys::path::append(P, "usr", "include");
2557 }
2558}
2559
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);
2567
2568
2570
2571
2572 {
2574 if (!ArchDir.empty())
2575 llvm::sys::path::append(P, ArchDir);
2576 if (!BitDir.empty())
2577 llvm::sys::path::append(P, BitDir);
2579 }
2580
2581
2582 {
2584 llvm::sys::path::append(P, "backward");
2586 }
2587
2589}
2590
2592 const llvm::opt::ArgList &DriverArgs,
2593 llvm::opt::ArgStringList &CC1Args) const {
2594
2595
2596
2597
2598
2600
2601 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
2602 options::OPT_nostdincxx))
2603 return;
2604
2606
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2623 llvm::sys::path::append(InstallBin, "..", "include", "c++", "v1");
2624 if (getVFS().exists(InstallBin)) {
2626 return;
2627 } else if (DriverArgs.hasArg(options::OPT_v)) {
2628 llvm::errs() << "ignoring nonexistent directory \"" << InstallBin
2629 << "\"\n";
2630 }
2631
2632
2634 llvm::sys::path::append(SysrootUsr, "usr", "include", "c++", "v1");
2635 if (getVFS().exists(SysrootUsr)) {
2637 return;
2638 } else if (DriverArgs.hasArg(options::OPT_v)) {
2639 llvm::errs() << "ignoring nonexistent directory \"" << SysrootUsr
2640 << "\"\n";
2641 }
2642
2643
2644 break;
2645 }
2646
2648 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args);
2649 break;
2650 }
2651}
2652
2653void AppleMachO::AddGnuCPlusPlusIncludePaths(
2654 const llvm::opt::ArgList &DriverArgs,
2655 llvm::opt::ArgStringList &CC1Args) const {}
2656
2657void DarwinClang::AddGnuCPlusPlusIncludePaths(
2658 const llvm::opt::ArgList &DriverArgs,
2659 llvm::opt::ArgStringList &CC1Args) const {
2661 llvm::sys::path::append(UsrIncludeCxx, "usr", "include", "c++");
2662
2663 llvm::Triple::ArchType arch = getTriple().getArch();
2664 bool IsBaseFound = true;
2665 switch (arch) {
2666 default:
2667 break;
2668
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", "");
2676 break;
2677
2678 case llvm::Triple::arm:
2679 case llvm::Triple::thumb:
2680 IsBaseFound =
2681 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx, "4.2.1",
2682 "arm-apple-darwin10", "v7");
2683 IsBaseFound |=
2684 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx, "4.2.1",
2685 "arm-apple-darwin10", "v6");
2686 break;
2687
2688 case llvm::Triple::aarch64:
2689 IsBaseFound =
2690 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx, "4.2.1",
2691 "arm64-apple-darwin10", "");
2692 break;
2693 }
2694
2695 if (!IsBaseFound) {
2696 getDriver().Diag(diag::warn_drv_libstdcxx_not_found);
2697 }
2698}
2699
2701 ArgStringList &CmdArgs) const {
2703
2704 switch (Type) {
2706 CmdArgs.push_back("-lc++");
2707 if (Args.hasArg(options::OPT_fexperimental_library))
2708 CmdArgs.push_back("-lc++experimental");
2709 break;
2710
2712
2713
2714
2715
2716
2717
2718 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2720 llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
2721
2722 if (().exists(P)) {
2723 llvm::sys::path::remove_filename(P);
2724 llvm::sys::path::append(P, "libstdc++.6.dylib");
2725 if (getVFS().exists(P)) {
2726 CmdArgs.push_back(Args.MakeArgString(P));
2727 return;
2728 }
2729 }
2730 }
2731
2732
2733
2734
2735 if (().exists("/usr/lib/libstdc++.dylib") &&
2736 getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
2737 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
2738 return;
2739 }
2740
2741
2742 CmdArgs.push_back("-lstdc++");
2743 break;
2744 }
2745}
2746
2748 ArgStringList &CmdArgs) const {
2749
2750
2751
2752
2754 llvm::sys::path::append(P, "lib", "darwin");
2755
2756
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");
2764
2766 llvm::sys::path::append(
2767 P, llvm::Twine("libclang_rt.cc_kext_") +
2768 llvm::Triple::getOSTypeName(llvm::Triple::XROS) + ".a");
2769 } else {
2770 llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
2771 }
2772
2773
2774
2776 CmdArgs.push_back(Args.MakeArgString(P));
2777}
2778
2780 StringRef BoundArch,
2782 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
2784
2785
2786
2787
2788
2789
2790
2791
2792 for (Arg *A : Args) {
2793 if (A->getOption().matches(options::OPT_Xarch__)) {
2794
2795
2796 StringRef XarchArch = A->getValue(0);
2798 (!BoundArch.empty() && XarchArch == BoundArch)))
2799 continue;
2800
2801 Arg *OriginalArg = A;
2803
2804
2805
2806
2808
2809 for (const char *Value : A->getValues()) {
2810 DAL->AddSeparateArg(
2811 OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
2812 }
2813 continue;
2814 }
2815 }
2816
2817
2818
2819
2820 switch ((options::ID)A->getOption().getID()) {
2821 default:
2822 DAL->append(A);
2823 break;
2824
2825 case options::OPT_mkernel:
2826 case options::OPT_fapple_kext:
2827 DAL->append(A);
2828 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
2829 break;
2830
2831 case options::OPT_dependency_file:
2832 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
2833 break;
2834
2835 case options::OPT_gfull:
2836 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2837 DAL->AddFlagArg(
2838 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
2839 break;
2840
2841 case options::OPT_gused:
2842 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2843 DAL->AddFlagArg(
2844 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
2845 break;
2846
2847 case options::OPT_shared:
2848 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
2849 break;
2850
2851 case options::OPT_fconstant_cfstrings:
2852 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
2853 break;
2854
2855 case options::OPT_fno_constant_cfstrings:
2856 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
2857 break;
2858
2859 case options::OPT_Wnonportable_cfstrings:
2860 DAL->AddFlagArg(A,
2861 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
2862 break;
2863
2864 case options::OPT_Wno_nonportable_cfstrings:
2865 DAL->AddFlagArg(
2866 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
2867 break;
2868 }
2869 }
2870
2871
2872
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);
2877
2878
2879
2880 if (Name == "ppc")
2881 ;
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");
2898
2899 else if (Name == "ppc64" || Name == "ppc64le")
2900 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
2901
2902 else if (Name == "i386")
2903 ;
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");
2918
2919 else if (Name == "x86_64" || Name == "x86_64h")
2920 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
2921
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");
2944 }
2945
2946 return DAL;
2947}
2948
2950 ArgStringList &CmdArgs,
2951 bool ForceLinkBuiltinRT) const {
2952
2953
2954
2956 CompilerRT +=
2958 ? "hard"
2959 : "soft";
2960 CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic" : "_static";
2961
2963}
2964
2966 llvm::Triple::OSType OS;
2967
2971 case MacOS:
2972 OS = llvm::Triple::MacOSX;
2973 break;
2975 OS = llvm::Triple::IOS;
2976 break;
2977 case TvOS:
2978 OS = llvm::Triple::TvOS;
2979 break;
2980 case WatchOS:
2981 OS = llvm::Triple::WatchOS;
2982 break;
2983 case XROS:
2984 return false;
2985 case DriverKit:
2986 return false;
2987 }
2988
2990}
2991
2995 const std::optional &SDKInfo) {
2999
3000
3001 } else {
3002
3003 return true;
3004 }
3005
3006 if (!SDKInfo)
3007
3008
3009
3010
3011
3012
3013 return false;
3014
3015 VersionTuple SDKVersion = SDKInfo->getVersion();
3016 switch (TargetPlatform) {
3017
3018
3020 return SDKVersion >= VersionTuple(15U);
3022 switch (TargetEnvironment) {
3024
3025
3026
3027 return SDKVersion >= VersionTuple(15U);
3028 default:
3029 return SDKVersion >= VersionTuple(18U);
3030 }
3032 return SDKVersion >= VersionTuple(18U);
3034 return SDKVersion >= VersionTuple(11U);
3036 return SDKVersion >= VersionTuple(2U);
3037
3038
3039 default:
3040 return true;
3041 }
3042}
3043
3044static inline llvm::VersionTuple
3046 switch (OS) {
3047 default:
3048 break;
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);
3057 }
3058
3059 llvm_unreachable("Unexpected OS");
3060}
3061
3063 llvm::Triple::OSType OS;
3064
3068 case MacOS:
3069 OS = llvm::Triple::MacOSX;
3070 break;
3072 OS = llvm::Triple::IOS;
3073 break;
3074 case TvOS:
3075 OS = llvm::Triple::TvOS;
3076 break;
3077 case WatchOS:
3078 OS = llvm::Triple::WatchOS;
3079 break;
3082
3083 return false;
3084 }
3085
3087}
3088
3090 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
3092
3093
3094 if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
3095 options::OPT_fno_aligned_allocation) &&
3097 CC1Args.push_back("-faligned-alloc-unavailable");
3098
3099
3100
3101 if (!DriverArgs.hasArgNoClaim(options::OPT_fsized_deallocation,
3102 options::OPT_fno_sized_deallocation) &&
3104 CC1Args.push_back("-fno-sized-deallocation");
3105
3107
3108
3109
3110 CC1Args.push_back("-fcompatibility-qualified-id-block-type-checking");
3111
3112
3113
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");
3118
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3131 CC1Args.push_back("-fbuiltin-headers-in-system-modules");
3132
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");
3136
3137
3139 !DriverArgs.hasFlag(options::OPT_fmodulemap_allow_subdirectory_search,
3140 options::OPT_fno_modulemap_allow_subdirectory_search,
3141 false)) {
3142 bool RequiresSubdirectorySearch;
3143 VersionTuple SDKVersion = SDKInfo->getVersion();
3145 default:
3146 RequiresSubdirectorySearch = true;
3147 break;
3149 RequiresSubdirectorySearch = SDKVersion < VersionTuple(15, 0);
3150 break;
3153 RequiresSubdirectorySearch = SDKVersion < VersionTuple(18, 0);
3154 break;
3156 RequiresSubdirectorySearch = SDKVersion < VersionTuple(11, 0);
3157 break;
3159 RequiresSubdirectorySearch = SDKVersion < VersionTuple(2, 0);
3160 break;
3161 }
3162 if (!RequiresSubdirectorySearch)
3163 CC1Args.push_back("-fno-modulemap-allow-subdirectory-search");
3164 }
3165}
3166
3168 const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CC1ASArgs) const {
3170 CC1ASArgs.push_back("-darwin-target-variant-triple");
3171 CC1ASArgs.push_back(Args.MakeArgString(TargetVariantTriple->getTriple()));
3172 }
3173
3175
3176
3177 auto EmitTargetSDKVersionArg = [&](const VersionTuple &V) {
3178 std::string Arg;
3179 llvm::raw_string_ostream OS(Arg);
3180 OS << "-target-sdk-version=" << V;
3181 CC1ASArgs.push_back(Args.MakeArgString(Arg));
3182 };
3183
3185 if (const auto *MacOStoMacCatalystMapping = SDKInfo->getVersionMapping(
3187 std::optional SDKVersion = MacOStoMacCatalystMapping->map(
3189 std::nullopt);
3190 EmitTargetSDKVersionArg(
3192 }
3193 } else {
3194 EmitTargetSDKVersionArg(SDKInfo->getVersion());
3195 }
3196
3197
3198
3201 std::string Arg;
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 =
3206 SDKInfo->getVersionMapping(
3208 if (std::optional SDKVersion =
3209 MacOStoMacCatalystMapping->map(
3211 std::nullopt)) {
3212 std::string Arg;
3213 llvm::raw_string_ostream OS(Arg);
3214 OS << "-darwin-target-variant-sdk-version=" << *SDKVersion;
3215 CC1ASArgs.push_back(Args.MakeArgString(Arg));
3216 }
3217 }
3218 }
3219 }
3220}
3221
3222DerivedArgList *
3225
3226 DerivedArgList *DAL =
3228
3229
3230 if (BoundArch.empty())
3231 return DAL;
3232
3233
3234
3235
3236 AddDeploymentTarget(*DAL);
3237
3238
3239
3240
3241
3244 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
3245 Arg *A = *it;
3246 ++it;
3247 if (A->getOption().getID() != options::OPT_mkernel &&
3248 A->getOption().getID() != options::OPT_fapple_kext)
3249 continue;
3250 assert(it != ie && "unexpected argument translation");
3251 A = *it;
3252 assert(A->getOption().getID() == options::OPT_static &&
3253 "missing expected -static argument");
3254 *it = nullptr;
3255 ++it;
3256 }
3257 }
3258
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;
3265 }
3266
3267 return DAL;
3268}
3269
3271
3272
3273 if (getArch() == llvm::Triple::x86_64 ||
3275 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
3276 true)))
3277 return (getArch() == llvm::Triple::aarch64 ||
3278 getArch() == llvm::Triple::aarch64_32)
3281
3283}
3284
3286 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
3287 return S[0] != '\0';
3288 return false;
3289}
3290
3292 if (const char *S = ::getenv("RC_DEBUG_PREFIX_MAP"))
3293 return S;
3294 return {};
3295}
3296
3298
3301 return llvm::ExceptionHandling::None;
3302
3303
3305 if (Triple.isWatchABI())
3306 return llvm::ExceptionHandling::DwarfCFI;
3307
3308 return llvm::ExceptionHandling::SjLj;
3309}
3310
3314 return false;
3315 return true;
3316}
3317
3319
3321
3323 return (getArch() == llvm::Triple::x86_64 ||
3324 getArch() == llvm::Triple::aarch64);
3325}
3326
3328
3330}
3331
3333 ArgStringList &CmdArgs) const {
3335
3336 assert(() && "xrOS always uses -platform-version");
3337
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");
3354 else {
3356 CmdArgs.push_back("-macosx_version_min");
3357 }
3358
3359 VersionTuple MinTgtVers = getEffectiveTriple().getMinimumSupportedOSVersion();
3360 if (!MinTgtVers.empty() && MinTgtVers > TargetVersion)
3362 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
3365 VersionTuple VariantTargetVersion;
3367 CmdArgs.push_back("-macosx_version_min");
3369 } else {
3372 "unexpected target variant triple");
3373 CmdArgs.push_back("-maccatalyst_version_min");
3375 }
3376 VersionTuple MinTgtVers =
3378 if (MinTgtVers.getMajor() && MinTgtVers > VariantTargetVersion)
3379 VariantTargetVersion = MinTgtVers;
3380 CmdArgs.push_back(Args.MakeArgString(VariantTargetVersion.getAsString()));
3381 }
3382}
3383
3386 switch (Platform) {
3388 return "macos";
3391 return "mac catalyst";
3392 return "ios";
3394 return "tvos";
3396 return "watchos";
3398 return "xros";
3400 return "driverkit";
3401 }
3402 llvm_unreachable("invalid platform");
3403}
3404
3406 llvm::opt::ArgStringList &CmdArgs) const {
3407 auto EmitPlatformVersionArg =
3410 const llvm::Triple &TT) {
3411
3412
3413 CmdArgs.push_back("-platform_version");
3414 std::string PlatformName =
3417 PlatformName += "-simulator";
3418 CmdArgs.push_back(Args.MakeArgString(PlatformName));
3424
3426 }
3427 VersionTuple MinTgtVers = TT.getMinimumSupportedOSVersion();
3428 if (!MinTgtVers.empty() && MinTgtVers > TargetVersion)
3430 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
3431
3433
3434
3435 std::optional iOSSDKVersion;
3437 if (const auto *MacOStoMacCatalystMapping =
3438 SDKInfo->getVersionMapping(
3440 iOSSDKVersion = MacOStoMacCatalystMapping->map(
3441 SDKInfo->getVersion().withoutBuild(),
3443 }
3444 }
3445 CmdArgs.push_back(Args.MakeArgString(
3446 (iOSSDKVersion ? *iOSSDKVersion
3449 return;
3450 }
3451
3453 VersionTuple SDKVersion = SDKInfo->getVersion().withoutBuild();
3454 if (!SDKVersion.getMinor())
3455 SDKVersion = VersionTuple(SDKVersion.getMajor(), 0);
3456 CmdArgs.push_back(Args.MakeArgString(SDKVersion.getAsString()));
3457 } else {
3458
3459
3460
3461
3462
3463
3464
3465
3466
3467 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
3468 }
3469 };
3473 return;
3476 VersionTuple TargetVariantVersion;
3481 } else {
3484 "unexpected target variant triple");
3488 }
3489 EmitPlatformVersionArg(TargetVariantVersion, Platform, Environment,
3491}
3492
3493
3495 ArgStringList &CmdArgs) {
3496
3497 if (D.isTargetIPhoneOS()) {
3498 if (D.isIPhoneOSVersionLT(3, 1))
3499 CmdArgs.push_back("-ldylib1.o");
3500 return;
3501 }
3502
3503 if (.isTargetMacOS())
3504 return;
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");
3509}
3510
3511
3513 ArgStringList &CmdArgs) {
3514 if (Args.hasArg(options::OPT_static))
3515 return;
3516
3517 if ((D.isTargetIPhoneOS() && D.isIPhoneOSVersionLT(3, 1)) ||
3518 (D.isTargetMacOS() && D.isMacosxVersionLT(10, 6)))
3519 CmdArgs.push_back("-lbundle1.o");
3520}
3521
3522
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");
3529 } else {
3530 CmdArgs.push_back("-lgcrt1.o");
3531
3532
3533 }
3534
3535
3536
3537
3538
3539 if (.isMacosxVersionLT(10, 8))
3540 CmdArgs.push_back("-no_new_main");
3541 } else {
3542 D.getDriver().Diag(diag::err_drv_clang_unsupported_opt_pg_darwin)
3543 << D.isTargetMacOSBased();
3544 }
3545}
3546
3548 ArgStringList &CmdArgs) {
3549
3550 if (D.isTargetIPhoneOS()) {
3551 if (D.getArch() == llvm::Triple::aarch64)
3552 ;
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");
3557 return;
3558 }
3559
3560 if (.isTargetMacOS())
3561 return;
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");
3568
3569}
3570
3572 ArgStringList &CmdArgs) const {
3573
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");
3584 else
3586
3587 if (isTargetMacOS() && Args.hasArg(options::OPT_shared_libgcc) &&
3589 const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
3590 CmdArgs.push_back(Str);
3591 }
3592}
3593
3597 return;
3598 getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
3599}
3600
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;
3613
3614
3615
3616
3619 Res |= SanitizerKind::Vptr;
3620
3621 if ((IsX86_64 || IsAArch64) &&
3624 Res |= SanitizerKind::Thread;
3625 }
3626
3628 Res |= SanitizerKind::Type;
3629 }
3630
3631 if (IsX86_64)
3632 Res |= SanitizerKind::NumericalStability;
3633
3634 return Res;
3635}
3636
3640}
Defines a function that returns the minimum OS versions supporting C++17's aligned allocation functio...
enum clang::sema::@1726::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
InputInfo - Wrapper for information about an input source.
const char * getFilename() const
types::ID getType() 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()