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 MachOArchName == "armv6")
2169 OSTy = llvm::Triple::IOS;
2170 else if (MachOArchName == "armv7k" || MachOArchName == "arm64_32")
2171 OSTy = llvm::Triple::WatchOS;
2172 else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" &&
2173 MachOArchName != "armv7em")
2174 OSTy = llvm::Triple::MacOSX;
2175 if (OSTy == llvm::Triple::UnknownOS)
2176 return std::nullopt;
2177 return DarwinPlatform::createFromArch(OSTy,
2178 getOSVersion(OSTy, Triple, TheDriver));
2179}
2180
2181
2182std::optional getDeploymentTargetFromTargetArg(
2183 DerivedArgList &Args, const llvm::Triple &Triple, const Driver &TheDriver,
2184 const std::optional &SDKInfo) {
2185 if (!Args.hasArg(options::OPT_target))
2186 return std::nullopt;
2187 if (Triple.getOS() == llvm::Triple::Darwin ||
2188 Triple.getOS() == llvm::Triple::UnknownOS)
2189 return std::nullopt;
2190 std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
2191 std::optionalllvm::Triple TargetVariantTriple;
2192 for (const Arg *A : Args.filtered(options::OPT_darwin_target_variant)) {
2193 llvm::Triple TVT(A->getValue());
2194
2195 if ((Triple.getArch() == llvm::Triple::aarch64 ||
2196 TVT.getArchName() == Triple.getArchName()) &&
2197 TVT.getArch() == Triple.getArch() &&
2198 TVT.getSubArch() == Triple.getSubArch() &&
2199 TVT.getVendor() == Triple.getVendor()) {
2200 if (TargetVariantTriple)
2201 continue;
2202 A->claim();
2203
2204
2205 if ((Triple.isMacOSX() && TVT.getOS() == llvm::Triple::IOS &&
2206 TVT.isMacCatalystEnvironment()) ||
2207 (TVT.isMacOSX() && Triple.getOS() == llvm::Triple::IOS &&
2208 Triple.isMacCatalystEnvironment())) {
2209 TargetVariantTriple = TVT;
2210 continue;
2211 }
2212 TheDriver.Diag(diag::err_drv_target_variant_invalid)
2213 << A->getSpelling() << A->getValue();
2214 }
2215 }
2216 return DarwinPlatform::createFromTarget(Triple, OSVersion,
2217 Args.getLastArg(options::OPT_target),
2218 TargetVariantTriple, SDKInfo);
2219}
2220
2221
2222std::optional getDeploymentTargetFromMTargetOSArg(
2223 DerivedArgList &Args, const Driver &TheDriver,
2224 const std::optional &SDKInfo) {
2225 auto *A = Args.getLastArg(options::OPT_mtargetos_EQ);
2226 if (!A)
2227 return std::nullopt;
2228 llvm::Triple TT(llvm::Twine("unknown-apple-") + A->getValue());
2229 switch (TT.getOS()) {
2230 case llvm::Triple::MacOSX:
2231 case llvm::Triple::IOS:
2232 case llvm::Triple::TvOS:
2233 case llvm::Triple::WatchOS:
2234 case llvm::Triple::XROS:
2235 break;
2236 default:
2237 TheDriver.Diag(diag::err_drv_invalid_os_in_arg)
2238 << TT.getOSName() << A->getAsString(Args);
2239 return std::nullopt;
2240 }
2241
2242 VersionTuple Version = TT.getOSVersion();
2243 if (!Version.getMajor()) {
2244 TheDriver.Diag(diag::err_drv_invalid_version_number)
2245 << A->getAsString(Args);
2246 return std::nullopt;
2247 }
2248 return DarwinPlatform::createFromMTargetOS(TT.getOS(), Version,
2249 TT.getEnvironment(), A, SDKInfo);
2250}
2251
2252std::optional parseSDKSettings(llvm::vfs::FileSystem &VFS,
2253 const ArgList &Args,
2254 const Driver &TheDriver) {
2255 const Arg *A = Args.getLastArg(options::OPT_isysroot);
2256 if (!A)
2257 return std::nullopt;
2258 StringRef isysroot = A->getValue();
2260 if (!SDKInfoOrErr) {
2261 llvm::consumeError(SDKInfoOrErr.takeError());
2262 TheDriver.Diag(diag::warn_drv_darwin_sdk_invalid_settings);
2263 return std::nullopt;
2264 }
2265 return *SDKInfoOrErr;
2266}
2267
2268}
2269
2270void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
2272
2273
2274
2275
2276 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2277
2278 if (().exists(A->getValue()))
2279 getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
2280 } else {
2281 if (char *env = ::getenv("SDKROOT")) {
2282
2283
2284 if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) &&
2285 StringRef(env) != "/") {
2286 Args.append(Args.MakeSeparateArg(
2287 nullptr, Opts.getOption(options::OPT_isysroot), env));
2288 }
2289 }
2290 }
2291
2292
2293
2295
2296
2297 std::optional OSTarget =
2299 if (OSTarget) {
2300
2301 if (const auto *MTargetOSArg = Args.getLastArg(options::OPT_mtargetos_EQ)) {
2302 std::string TargetArgStr = OSTarget->getAsString(Args, Opts);
2303 std::string MTargetOSArgStr = MTargetOSArg->getAsString(Args);
2304 getDriver().Diag(diag::err_drv_cannot_mix_options)
2305 << TargetArgStr << MTargetOSArgStr;
2306 }
2307 std::optional OSVersionArgTarget =
2308 getDeploymentTargetFromOSVersionArg(Args, getDriver());
2309 if (OSVersionArgTarget) {
2310 unsigned TargetMajor, TargetMinor, TargetMicro;
2311 bool TargetExtra;
2312 unsigned ArgMajor, ArgMinor, ArgMicro;
2313 bool ArgExtra;
2314 if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
2316 TargetMinor, TargetMicro, TargetExtra) &&
2318 ArgMajor, ArgMinor, ArgMicro, ArgExtra) &&
2319 (VersionTuple(TargetMajor, TargetMinor, TargetMicro) !=
2320 VersionTuple(ArgMajor, ArgMinor, ArgMicro) ||
2321 TargetExtra != ArgExtra))) {
2322
2323
2324 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
2325 !OSTarget->hasOSVersion()) {
2326 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
2327 } else {
2328
2329
2330 std::string OSVersionArg =
2331 OSVersionArgTarget->getAsString(Args, Opts);
2332 std::string TargetArg = OSTarget->getAsString(Args, Opts);
2333 getDriver().Diag(clang::diag::warn_drv_overriding_option)
2334 << OSVersionArg << TargetArg;
2335 }
2336 }
2337 }
2338 } else if ((OSTarget = getDeploymentTargetFromMTargetOSArg(Args, getDriver(),
2340
2341
2342 std::optional OSVersionArgTarget =
2343 getDeploymentTargetFromOSVersionArg(Args, getDriver());
2344 if (OSVersionArgTarget) {
2345 std::string MTargetOSArgStr = OSTarget->getAsString(Args, Opts);
2346 std::string OSVersionArgStr = OSVersionArgTarget->getAsString(Args, Opts);
2347 getDriver().Diag(diag::err_drv_cannot_mix_options)
2348 << MTargetOSArgStr << OSVersionArgStr;
2349 }
2350 } else {
2351
2352 OSTarget = getDeploymentTargetFromOSVersionArg(Args, getDriver());
2353
2354
2355 if (!OSTarget) {
2356 OSTarget =
2357 getDeploymentTargetFromEnvironmentVariables(getDriver(), getTriple());
2358 if (OSTarget) {
2359
2360 std::optional SDKTarget =
2361 inferDeploymentTargetFromSDK(Args, SDKInfo);
2362 if (SDKTarget)
2363 OSTarget->setEnvironment(SDKTarget->getEnvironment());
2364 }
2365 }
2366
2367
2368
2369 if (!OSTarget) {
2370 OSTarget = inferDeploymentTargetFromSDK(Args, SDKInfo);
2371
2372
2373 if (OSTarget && )
2374 SDKInfo = OSTarget->inferSDKInfo();
2375 }
2376
2377
2378 if (!OSTarget)
2379 OSTarget =
2380 inferDeploymentTargetFromArch(Args, *this, getTriple(), getDriver());
2381 }
2382
2383 assert(OSTarget && "Unable to infer Darwin variant");
2384 OSTarget->addOSVersionMinArgument(Args, Opts);
2386
2387 unsigned Major, Minor, Micro;
2388 bool HadExtra;
2389
2390 const unsigned MajorVersionLimit = 1000;
2391
2392 if (Platform == MacOS) {
2394 Micro, HadExtra) ||
2395 HadExtra || Major < 10 || Major >= MajorVersionLimit || Minor >= 100 ||
2396 Micro >= 100)
2397 getDriver().Diag(diag::err_drv_invalid_version_number)
2398 << OSTarget->getAsString(Args, Opts);
2399 } else if (Platform == IPhoneOS) {
2401 Micro, HadExtra) ||
2402 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2403 getDriver().Diag(diag::err_drv_invalid_version_number)
2404 << OSTarget->getAsString(Args, Opts);
2405 ;
2406 if (OSTarget->getEnvironment() == MacCatalyst &&
2407 (Major < 13 || (Major == 13 && Minor < 1))) {
2408 getDriver().Diag(diag::err_drv_invalid_version_number)
2409 << OSTarget->getAsString(Args, Opts);
2410 Major = 13;
2411 Minor = 1;
2412 Micro = 0;
2413 }
2414
2415
2416 if (getTriple().isArch32Bit() && Major >= 11) {
2417
2418 if (OSTarget->isExplicitlySpecified()) {
2419 if (OSTarget->getEnvironment() == MacCatalyst)
2420 getDriver().Diag(diag::err_invalid_macos_32bit_deployment_target);
2421 else
2422 getDriver().Diag(diag::warn_invalid_ios_deployment_target)
2423 << OSTarget->getAsString(Args, Opts);
2424
2425 } else {
2426 Major = 10;
2427 Minor = 99;
2428 Micro = 99;
2429 }
2430 }
2431 } else if (Platform == TvOS) {
2433 Micro, HadExtra) ||
2434 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2435 getDriver().Diag(diag::err_drv_invalid_version_number)
2436 << OSTarget->getAsString(Args, Opts);
2437 } else if (Platform == WatchOS) {
2439 Micro, HadExtra) ||
2440 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2441 getDriver().Diag(diag::err_drv_invalid_version_number)
2442 << OSTarget->getAsString(Args, Opts);
2443 } else if (Platform == DriverKit) {
2445 Micro, HadExtra) ||
2446 HadExtra || Major < 19 || Major >= MajorVersionLimit || Minor >= 100 ||
2447 Micro >= 100)
2448 getDriver().Diag(diag::err_drv_invalid_version_number)
2449 << OSTarget->getAsString(Args, Opts);
2450 } else if (Platform == XROS) {
2452 Micro, HadExtra) ||
2453 HadExtra || Major < 1 || Major >= MajorVersionLimit || Minor >= 100 ||
2454 Micro >= 100)
2455 getDriver().Diag(diag::err_drv_invalid_version_number)
2456 << OSTarget->getAsString(Args, Opts);
2457 } else
2458 llvm_unreachable("unknown kind of Darwin platform");
2459
2461
2463 Platform != DriverKit && OSTarget->canInferSimulatorFromArch() &&
2466
2467 VersionTuple NativeTargetVersion;
2469 NativeTargetVersion = OSTarget->getNativeTargetVersion();
2470 setTarget(Platform, Environment, Major, Minor, Micro, NativeTargetVersion);
2472
2473 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2474 StringRef SDK = getSDKName(A->getValue());
2475 if (SDK.size() > 0) {
2476 size_t StartVer = SDK.find_first_of("0123456789");
2477 StringRef SDKName = SDK.slice(0, StartVer);
2480 getDriver().Diag(diag::warn_incompatible_sysroot)
2482 }
2483 }
2484}
2485
2486
2487
2488
2490 const llvm::Triple &T) {
2491 if (T.isDriverKit()) {
2492 llvm::sys::path::append(Path, "System", "DriverKit");
2493 }
2494}
2495
2496
2497
2501 if (DriverArgs.hasArg(options::OPT_isysroot))
2502 Path = DriverArgs.getLastArgValue(options::OPT_isysroot);
2503 else if (().SysRoot.empty())
2505
2508 }
2509 return Path;
2510}
2511
2513 const llvm::opt::ArgList &DriverArgs,
2514 llvm::opt::ArgStringList &CC1Args) const {
2516
2518
2519 bool NoStdInc = DriverArgs.hasArg(options::OPT_nostdinc);
2520 bool NoStdlibInc = DriverArgs.hasArg(options::OPT_nostdlibinc);
2521 bool NoBuiltinInc = DriverArgs.hasFlag(
2522 options::OPT_nobuiltininc, options::OPT_ibuiltininc, false);
2523 bool ForceBuiltinInc = DriverArgs.hasFlag(
2524 options::OPT_ibuiltininc, options::OPT_nobuiltininc, false);
2525
2526
2527 if (!NoStdInc && !NoStdlibInc) {
2529 llvm::sys::path::append(P, "usr", "local", "include");
2531 }
2532
2533
2534 if (!(NoStdInc && !ForceBuiltinInc) && !NoBuiltinInc) {
2536 llvm::sys::path::append(P, "include");
2538 }
2539
2540 if (NoStdInc || NoStdlibInc)
2541 return;
2542
2543
2544 llvm::StringRef CIncludeDirs(C_INCLUDE_DIRS);
2545 if (!CIncludeDirs.empty()) {
2547 CIncludeDirs.split(dirs, ":");
2548 for (llvm::StringRef dir : dirs) {
2549 llvm::StringRef Prefix =
2550 llvm::sys::path::is_absolute(dir) ? "" : llvm::StringRef(Sysroot);
2552 }
2553 } else {
2554
2556 llvm::sys::path::append(P, "usr", "include");
2558 }
2559}
2560
2561bool DarwinClang::AddGnuCPlusPlusIncludePaths(const llvm::opt::ArgList &DriverArgs,
2562 llvm::opt::ArgStringList &CC1Args,
2564 llvm::StringRef Version,
2565 llvm::StringRef ArchDir,
2566 llvm::StringRef BitDir) const {
2567 llvm::sys::path::append(Base, Version);
2568
2569
2571
2572
2573 {
2575 if (!ArchDir.empty())
2576 llvm::sys::path::append(P, ArchDir);
2577 if (!BitDir.empty())
2578 llvm::sys::path::append(P, BitDir);
2580 }
2581
2582
2583 {
2585 llvm::sys::path::append(P, "backward");
2587 }
2588
2590}
2591
2593 const llvm::opt::ArgList &DriverArgs,
2594 llvm::opt::ArgStringList &CC1Args) const {
2595
2596
2597
2598
2599
2601
2602 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
2603 options::OPT_nostdincxx))
2604 return;
2605
2607
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2624 llvm::sys::path::append(InstallBin, "..", "include", "c++", "v1");
2625 if (getVFS().exists(InstallBin)) {
2627 return;
2628 } else if (DriverArgs.hasArg(options::OPT_v)) {
2629 llvm::errs() << "ignoring nonexistent directory \"" << InstallBin
2630 << "\"\n";
2631 }
2632
2633
2635 llvm::sys::path::append(SysrootUsr, "usr", "include", "c++", "v1");
2636 if (getVFS().exists(SysrootUsr)) {
2638 return;
2639 } else if (DriverArgs.hasArg(options::OPT_v)) {
2640 llvm::errs() << "ignoring nonexistent directory \"" << SysrootUsr
2641 << "\"\n";
2642 }
2643
2644
2645 break;
2646 }
2647
2649 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args);
2650 break;
2651 }
2652}
2653
2654void AppleMachO::AddGnuCPlusPlusIncludePaths(
2655 const llvm::opt::ArgList &DriverArgs,
2656 llvm::opt::ArgStringList &CC1Args) const {}
2657
2658void DarwinClang::AddGnuCPlusPlusIncludePaths(
2659 const llvm::opt::ArgList &DriverArgs,
2660 llvm::opt::ArgStringList &CC1Args) const {
2662 llvm::sys::path::append(UsrIncludeCxx, "usr", "include", "c++");
2663
2664 llvm::Triple::ArchType arch = getTriple().getArch();
2665 bool IsBaseFound = true;
2666 switch (arch) {
2667 default:
2668 break;
2669
2670 case llvm::Triple::x86:
2671 case llvm::Triple::x86_64:
2672 IsBaseFound = AddGnuCPlusPlusIncludePaths(
2673 DriverArgs, CC1Args, UsrIncludeCxx, "4.2.1", "i686-apple-darwin10",
2674 arch == llvm::Triple::x86_64 ? "x86_64" : "");
2675 IsBaseFound |= AddGnuCPlusPlusIncludePaths(
2676 DriverArgs, CC1Args, UsrIncludeCxx, "4.0.0", "i686-apple-darwin8", "");
2677 break;
2678
2679 case llvm::Triple::arm:
2680 case llvm::Triple::thumb:
2681 IsBaseFound =
2682 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx, "4.2.1",
2683 "arm-apple-darwin10", "v7");
2684 IsBaseFound |=
2685 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx, "4.2.1",
2686 "arm-apple-darwin10", "v6");
2687 break;
2688
2689 case llvm::Triple::aarch64:
2690 IsBaseFound =
2691 AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx, "4.2.1",
2692 "arm64-apple-darwin10", "");
2693 break;
2694 }
2695
2696 if (!IsBaseFound) {
2697 getDriver().Diag(diag::warn_drv_libstdcxx_not_found);
2698 }
2699}
2700
2702 ArgStringList &CmdArgs) const {
2704
2705 switch (Type) {
2707 CmdArgs.push_back("-lc++");
2708 if (Args.hasArg(options::OPT_fexperimental_library))
2709 CmdArgs.push_back("-lc++experimental");
2710 break;
2711
2713
2714
2715
2716
2717
2718
2719 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2721 llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
2722
2723 if (().exists(P)) {
2724 llvm::sys::path::remove_filename(P);
2725 llvm::sys::path::append(P, "libstdc++.6.dylib");
2726 if (getVFS().exists(P)) {
2727 CmdArgs.push_back(Args.MakeArgString(P));
2728 return;
2729 }
2730 }
2731 }
2732
2733
2734
2735
2736 if (().exists("/usr/lib/libstdc++.dylib") &&
2737 getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
2738 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
2739 return;
2740 }
2741
2742
2743 CmdArgs.push_back("-lstdc++");
2744 break;
2745 }
2746}
2747
2749 ArgStringList &CmdArgs) const {
2750
2751
2752
2753
2755 llvm::sys::path::append(P, "lib", "darwin");
2756
2757
2759 llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a");
2761 llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a");
2763 llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
2765
2767 llvm::sys::path::append(
2768 P, llvm::Twine("libclang_rt.cc_kext_") +
2769 llvm::Triple::getOSTypeName(llvm::Triple::XROS) + ".a");
2770 } else {
2771 llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
2772 }
2773
2774
2775
2777 CmdArgs.push_back(Args.MakeArgString(P));
2778}
2779
2781 StringRef BoundArch,
2783 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
2785
2786
2787
2788
2789
2790
2791
2792
2793 for (Arg *A : Args) {
2794 if (A->getOption().matches(options::OPT_Xarch__)) {
2795
2796
2797 StringRef XarchArch = A->getValue(0);
2799 (!BoundArch.empty() && XarchArch == BoundArch)))
2800 continue;
2801
2802 Arg *OriginalArg = A;
2804
2805
2806
2807
2809
2810 for (const char *Value : A->getValues()) {
2811 DAL->AddSeparateArg(
2812 OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
2813 }
2814 continue;
2815 }
2816 }
2817
2818
2819
2820
2821 switch ((options::ID)A->getOption().getID()) {
2822 default:
2823 DAL->append(A);
2824 break;
2825
2826 case options::OPT_mkernel:
2827 case options::OPT_fapple_kext:
2828 DAL->append(A);
2829 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
2830 break;
2831
2832 case options::OPT_dependency_file:
2833 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
2834 break;
2835
2836 case options::OPT_gfull:
2837 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2838 DAL->AddFlagArg(
2839 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
2840 break;
2841
2842 case options::OPT_gused:
2843 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2844 DAL->AddFlagArg(
2845 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
2846 break;
2847
2848 case options::OPT_shared:
2849 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
2850 break;
2851
2852 case options::OPT_fconstant_cfstrings:
2853 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
2854 break;
2855
2856 case options::OPT_fno_constant_cfstrings:
2857 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
2858 break;
2859
2860 case options::OPT_Wnonportable_cfstrings:
2861 DAL->AddFlagArg(A,
2862 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
2863 break;
2864
2865 case options::OPT_Wno_nonportable_cfstrings:
2866 DAL->AddFlagArg(
2867 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
2868 break;
2869 }
2870 }
2871
2872
2873
2874 if (!BoundArch.empty()) {
2875 StringRef Name = BoundArch;
2876 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
2877 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
2878
2879
2880
2881 if (Name == "ppc")
2882 ;
2883 else if (Name == "ppc601")
2884 DAL->AddJoinedArg(nullptr, MCpu, "601");
2885 else if (Name == "ppc603")
2886 DAL->AddJoinedArg(nullptr, MCpu, "603");
2887 else if (Name == "ppc604")
2888 DAL->AddJoinedArg(nullptr, MCpu, "604");
2889 else if (Name == "ppc604e")
2890 DAL->AddJoinedArg(nullptr, MCpu, "604e");
2891 else if (Name == "ppc750")
2892 DAL->AddJoinedArg(nullptr, MCpu, "750");
2893 else if (Name == "ppc7400")
2894 DAL->AddJoinedArg(nullptr, MCpu, "7400");
2895 else if (Name == "ppc7450")
2896 DAL->AddJoinedArg(nullptr, MCpu, "7450");
2897 else if (Name == "ppc970")
2898 DAL->AddJoinedArg(nullptr, MCpu, "970");
2899
2900 else if (Name == "ppc64" || Name == "ppc64le")
2901 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
2902
2903 else if (Name == "i386")
2904 ;
2905 else if (Name == "i486")
2906 DAL->AddJoinedArg(nullptr, MArch, "i486");
2907 else if (Name == "i586")
2908 DAL->AddJoinedArg(nullptr, MArch, "i586");
2909 else if (Name == "i686")
2910 DAL->AddJoinedArg(nullptr, MArch, "i686");
2911 else if (Name == "pentium")
2912 DAL->AddJoinedArg(nullptr, MArch, "pentium");
2913 else if (Name == "pentium2")
2914 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
2915 else if (Name == "pentpro")
2916 DAL->AddJoinedArg(nullptr, MArch, "pentiumpro");
2917 else if (Name == "pentIIm3")
2918 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
2919
2920 else if (Name == "x86_64" || Name == "x86_64h")
2921 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
2922
2923 else if (Name == "arm")
2924 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
2925 else if (Name == "armv4t")
2926 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
2927 else if (Name == "armv5")
2928 DAL->AddJoinedArg(nullptr, MArch, "armv5tej");
2929 else if (Name == "xscale")
2930 DAL->AddJoinedArg(nullptr, MArch, "xscale");
2931 else if (Name == "armv6")
2932 DAL->AddJoinedArg(nullptr, MArch, "armv6k");
2933 else if (Name == "armv6m")
2934 DAL->AddJoinedArg(nullptr, MArch, "armv6m");
2935 else if (Name == "armv7")
2936 DAL->AddJoinedArg(nullptr, MArch, "armv7a");
2937 else if (Name == "armv7em")
2938 DAL->AddJoinedArg(nullptr, MArch, "armv7em");
2939 else if (Name == "armv7k")
2940 DAL->AddJoinedArg(nullptr, MArch, "armv7k");
2941 else if (Name == "armv7m")
2942 DAL->AddJoinedArg(nullptr, MArch, "armv7m");
2943 else if (Name == "armv7s")
2944 DAL->AddJoinedArg(nullptr, MArch, "armv7s");
2945 }
2946
2947 return DAL;
2948}
2949
2951 ArgStringList &CmdArgs,
2952 bool ForceLinkBuiltinRT) const {
2953
2954
2955
2957 CompilerRT +=
2959 ? "hard"
2960 : "soft";
2961 CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic" : "_static";
2962
2964}
2965
2967 llvm::Triple::OSType OS;
2968
2972 case MacOS:
2973 OS = llvm::Triple::MacOSX;
2974 break;
2976 OS = llvm::Triple::IOS;
2977 break;
2978 case TvOS:
2979 OS = llvm::Triple::TvOS;
2980 break;
2981 case WatchOS:
2982 OS = llvm::Triple::WatchOS;
2983 break;
2984 case XROS:
2985 return false;
2986 case DriverKit:
2987 return false;
2988 }
2989
2991}
2992
2996 const std::optional &SDKInfo) {
3000
3001
3002 } else {
3003
3004 return true;
3005 }
3006
3007 if (!SDKInfo)
3008
3009
3010
3011
3012
3013
3014 return false;
3015
3016 VersionTuple SDKVersion = SDKInfo->getVersion();
3017 switch (TargetPlatform) {
3018
3019
3021 return SDKVersion >= VersionTuple(15U);
3023 switch (TargetEnvironment) {
3025
3026
3027
3028 return SDKVersion >= VersionTuple(15U);
3029 default:
3030 return SDKVersion >= VersionTuple(18U);
3031 }
3033 return SDKVersion >= VersionTuple(18U);
3035 return SDKVersion >= VersionTuple(11U);
3037 return SDKVersion >= VersionTuple(2U);
3038
3039
3040 default:
3041 return true;
3042 }
3043}
3044
3045static inline llvm::VersionTuple
3047 switch (OS) {
3048 default:
3049 break;
3050 case llvm::Triple::Darwin:
3051 case llvm::Triple::MacOSX:
3052 return llvm::VersionTuple(10U, 12U);
3053 case llvm::Triple::IOS:
3054 case llvm::Triple::TvOS:
3055 return llvm::VersionTuple(10U);
3056 case llvm::Triple::WatchOS:
3057 return llvm::VersionTuple(3U);
3058 }
3059
3060 llvm_unreachable("Unexpected OS");
3061}
3062
3064 llvm::Triple::OSType OS;
3065
3069 case MacOS:
3070 OS = llvm::Triple::MacOSX;
3071 break;
3073 OS = llvm::Triple::IOS;
3074 break;
3075 case TvOS:
3076 OS = llvm::Triple::TvOS;
3077 break;
3078 case WatchOS:
3079 OS = llvm::Triple::WatchOS;
3080 break;
3083
3084 return false;
3085 }
3086
3088}
3089
3091 const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args,
3093
3094
3095 if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
3096 options::OPT_fno_aligned_allocation) &&
3098 CC1Args.push_back("-faligned-alloc-unavailable");
3099
3100
3101
3102 if (!DriverArgs.hasArgNoClaim(options::OPT_fsized_deallocation,
3103 options::OPT_fno_sized_deallocation) &&
3105 CC1Args.push_back("-fno-sized-deallocation");
3106
3108
3109
3110
3111 CC1Args.push_back("-fcompatibility-qualified-id-block-type-checking");
3112
3113
3114
3115 if (!DriverArgs.getLastArgNoClaim(
3116 options::OPT_fvisibility_inlines_hidden_static_local_var,
3117 options::OPT_fno_visibility_inlines_hidden_static_local_var))
3118 CC1Args.push_back("-fvisibility-inlines-hidden-static-local-var");
3119
3120
3121
3122
3123
3124
3125
3126
3127
3128
3129
3130
3132 CC1Args.push_back("-fbuiltin-headers-in-system-modules");
3133
3134 if (!DriverArgs.hasArgNoClaim(options::OPT_fdefine_target_os_macros,
3135 options::OPT_fno_define_target_os_macros))
3136 CC1Args.push_back("-fdefine-target-os-macros");
3137
3138
3140 !DriverArgs.hasFlag(options::OPT_fmodulemap_allow_subdirectory_search,
3141 options::OPT_fno_modulemap_allow_subdirectory_search,
3142 false)) {
3143 bool RequiresSubdirectorySearch;
3144 VersionTuple SDKVersion = SDKInfo->getVersion();
3146 default:
3147 RequiresSubdirectorySearch = true;
3148 break;
3150 RequiresSubdirectorySearch = SDKVersion < VersionTuple(15, 0);
3151 break;
3154 RequiresSubdirectorySearch = SDKVersion < VersionTuple(18, 0);
3155 break;
3157 RequiresSubdirectorySearch = SDKVersion < VersionTuple(11, 0);
3158 break;
3160 RequiresSubdirectorySearch = SDKVersion < VersionTuple(2, 0);
3161 break;
3162 }
3163 if (!RequiresSubdirectorySearch)
3164 CC1Args.push_back("-fno-modulemap-allow-subdirectory-search");
3165 }
3166}
3167
3169 const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CC1ASArgs) const {
3171 CC1ASArgs.push_back("-darwin-target-variant-triple");
3172 CC1ASArgs.push_back(Args.MakeArgString(TargetVariantTriple->getTriple()));
3173 }
3174
3176
3177
3178 auto EmitTargetSDKVersionArg = [&](const VersionTuple &V) {
3179 std::string Arg;
3180 llvm::raw_string_ostream OS(Arg);
3181 OS << "-target-sdk-version=" << V;
3182 CC1ASArgs.push_back(Args.MakeArgString(Arg));
3183 };
3184
3186 if (const auto *MacOStoMacCatalystMapping = SDKInfo->getVersionMapping(
3188 std::optional SDKVersion = MacOStoMacCatalystMapping->map(
3190 std::nullopt);
3191 EmitTargetSDKVersionArg(
3193 }
3194 } else {
3195 EmitTargetSDKVersionArg(SDKInfo->getVersion());
3196 }
3197
3198
3199
3202 std::string Arg;
3203 llvm::raw_string_ostream OS(Arg);
3204 OS << "-darwin-target-variant-sdk-version=" << SDKInfo->getVersion();
3205 CC1ASArgs.push_back(Args.MakeArgString(Arg));
3206 } else if (const auto *MacOStoMacCatalystMapping =
3207 SDKInfo->getVersionMapping(
3209 if (std::optional SDKVersion =
3210 MacOStoMacCatalystMapping->map(
3212 std::nullopt)) {
3213 std::string Arg;
3214 llvm::raw_string_ostream OS(Arg);
3215 OS << "-darwin-target-variant-sdk-version=" << *SDKVersion;
3216 CC1ASArgs.push_back(Args.MakeArgString(Arg));
3217 }
3218 }
3219 }
3220 }
3221}
3222
3223DerivedArgList *
3226
3227 DerivedArgList *DAL =
3229
3230
3231 if (BoundArch.empty())
3232 return DAL;
3233
3234
3235
3236
3237 AddDeploymentTarget(*DAL);
3238
3239
3240
3241
3242
3245 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
3246 Arg *A = *it;
3247 ++it;
3248 if (A->getOption().getID() != options::OPT_mkernel &&
3249 A->getOption().getID() != options::OPT_fapple_kext)
3250 continue;
3251 assert(it != ie && "unexpected argument translation");
3252 A = *it;
3253 assert(A->getOption().getID() == options::OPT_static &&
3254 "missing expected -static argument");
3255 *it = nullptr;
3256 ++it;
3257 }
3258 }
3259
3261 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
3262 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
3263 options::OPT_fno_omit_frame_pointer, false))
3264 getDriver().Diag(clang::diag::warn_drv_unsupported_opt_for_target)
3265 << "-fomit-frame-pointer" << BoundArch;
3266 }
3267
3268 return DAL;
3269}
3270
3272
3273
3274 if (getArch() == llvm::Triple::x86_64 ||
3276 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
3277 true)))
3278 return (getArch() == llvm::Triple::aarch64 ||
3279 getArch() == llvm::Triple::aarch64_32)
3282
3284}
3285
3287 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
3288 return S[0] != '\0';
3289 return false;
3290}
3291
3293 if (const char *S = ::getenv("RC_DEBUG_PREFIX_MAP"))
3294 return S;
3295 return {};
3296}
3297
3299
3302 return llvm::ExceptionHandling::None;
3303
3304
3306 if (Triple.isWatchABI())
3307 return llvm::ExceptionHandling::DwarfCFI;
3308
3309 return llvm::ExceptionHandling::SjLj;
3310}
3311
3315 return false;
3316 return true;
3317}
3318
3320
3322
3324 return (getArch() == llvm::Triple::x86_64 ||
3325 getArch() == llvm::Triple::aarch64);
3326}
3327
3329
3331}
3332
3334 ArgStringList &CmdArgs) const {
3336
3337 assert(() && "xrOS always uses -platform-version");
3338
3340 CmdArgs.push_back("-watchos_version_min");
3342 CmdArgs.push_back("-watchos_simulator_version_min");
3344 CmdArgs.push_back("-tvos_version_min");
3346 CmdArgs.push_back("-tvos_simulator_version_min");
3348 CmdArgs.push_back("-driverkit_version_min");
3350 CmdArgs.push_back("-ios_simulator_version_min");
3352 CmdArgs.push_back("-iphoneos_version_min");
3354 CmdArgs.push_back("-maccatalyst_version_min");
3355 else {
3357 CmdArgs.push_back("-macosx_version_min");
3358 }
3359
3360 VersionTuple MinTgtVers = getEffectiveTriple().getMinimumSupportedOSVersion();
3361 if (!MinTgtVers.empty() && MinTgtVers > TargetVersion)
3363 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
3366 VersionTuple VariantTargetVersion;
3368 CmdArgs.push_back("-macosx_version_min");
3370 } else {
3373 "unexpected target variant triple");
3374 CmdArgs.push_back("-maccatalyst_version_min");
3376 }
3377 VersionTuple MinTgtVers =
3379 if (MinTgtVers.getMajor() && MinTgtVers > VariantTargetVersion)
3380 VariantTargetVersion = MinTgtVers;
3381 CmdArgs.push_back(Args.MakeArgString(VariantTargetVersion.getAsString()));
3382 }
3383}
3384
3387 switch (Platform) {
3389 return "macos";
3392 return "mac catalyst";
3393 return "ios";
3395 return "tvos";
3397 return "watchos";
3399 return "xros";
3401 return "driverkit";
3402 }
3403 llvm_unreachable("invalid platform");
3404}
3405
3407 llvm::opt::ArgStringList &CmdArgs) const {
3408 auto EmitPlatformVersionArg =
3411 const llvm::Triple &TT) {
3412
3413
3414 CmdArgs.push_back("-platform_version");
3415 std::string PlatformName =
3418 PlatformName += "-simulator";
3419 CmdArgs.push_back(Args.MakeArgString(PlatformName));
3425
3427 }
3428 VersionTuple MinTgtVers = TT.getMinimumSupportedOSVersion();
3429 if (!MinTgtVers.empty() && MinTgtVers > TargetVersion)
3431 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
3432
3434
3435
3436 std::optional iOSSDKVersion;
3438 if (const auto *MacOStoMacCatalystMapping =
3439 SDKInfo->getVersionMapping(
3441 iOSSDKVersion = MacOStoMacCatalystMapping->map(
3442 SDKInfo->getVersion().withoutBuild(),
3444 }
3445 }
3446 CmdArgs.push_back(Args.MakeArgString(
3447 (iOSSDKVersion ? *iOSSDKVersion
3450 return;
3451 }
3452
3454 VersionTuple SDKVersion = SDKInfo->getVersion().withoutBuild();
3455 if (!SDKVersion.getMinor())
3456 SDKVersion = VersionTuple(SDKVersion.getMajor(), 0);
3457 CmdArgs.push_back(Args.MakeArgString(SDKVersion.getAsString()));
3458 } else {
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
3469 }
3470 };
3474 return;
3477 VersionTuple TargetVariantVersion;
3482 } else {
3485 "unexpected target variant triple");
3489 }
3490 EmitPlatformVersionArg(TargetVariantVersion, Platform, Environment,
3492}
3493
3494
3496 ArgStringList &CmdArgs) {
3497
3498 if (D.isTargetIPhoneOS()) {
3499 if (D.isIPhoneOSVersionLT(3, 1))
3500 CmdArgs.push_back("-ldylib1.o");
3501 return;
3502 }
3503
3504 if (.isTargetMacOS())
3505 return;
3506 if (D.isMacosxVersionLT(10, 5))
3507 CmdArgs.push_back("-ldylib1.o");
3508 else if (D.isMacosxVersionLT(10, 6))
3509 CmdArgs.push_back("-ldylib1.10.5.o");
3510}
3511
3512
3514 ArgStringList &CmdArgs) {
3515 if (Args.hasArg(options::OPT_static))
3516 return;
3517
3518 if ((D.isTargetIPhoneOS() && D.isIPhoneOSVersionLT(3, 1)) ||
3519 (D.isTargetMacOS() && D.isMacosxVersionLT(10, 6)))
3520 CmdArgs.push_back("-lbundle1.o");
3521}
3522
3523
3525 ArgStringList &CmdArgs) {
3526 if (D.isTargetMacOS() && D.isMacosxVersionLT(10, 9)) {
3527 if (Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_object) ||
3528 Args.hasArg(options::OPT_preload)) {
3529 CmdArgs.push_back("-lgcrt0.o");
3530 } else {
3531 CmdArgs.push_back("-lgcrt1.o");
3532
3533
3534 }
3535
3536
3537
3538
3539
3540 if (.isMacosxVersionLT(10, 8))
3541 CmdArgs.push_back("-no_new_main");
3542 } else {
3543 D.getDriver().Diag(diag::err_drv_clang_unsupported_opt_pg_darwin)
3544 << D.isTargetMacOSBased();
3545 }
3546}
3547
3549 ArgStringList &CmdArgs) {
3550
3551 if (D.isTargetIPhoneOS()) {
3552 if (D.getArch() == llvm::Triple::aarch64)
3553 ;
3554 else if (D.isIPhoneOSVersionLT(3, 1))
3555 CmdArgs.push_back("-lcrt1.o");
3556 else if (D.isIPhoneOSVersionLT(6, 0))
3557 CmdArgs.push_back("-lcrt1.3.1.o");
3558 return;
3559 }
3560
3561 if (.isTargetMacOS())
3562 return;
3563 if (D.isMacosxVersionLT(10, 5))
3564 CmdArgs.push_back("-lcrt1.o");
3565 else if (D.isMacosxVersionLT(10, 6))
3566 CmdArgs.push_back("-lcrt1.10.5.o");
3567 else if (D.isMacosxVersionLT(10, 8))
3568 CmdArgs.push_back("-lcrt1.10.6.o");
3569
3570}
3571
3573 ArgStringList &CmdArgs) const {
3574
3575 if (Args.hasArg(options::OPT_dynamiclib))
3577 else if (Args.hasArg(options::OPT_bundle))
3581 else if (Args.hasArg(options::OPT_static) ||
3582 Args.hasArg(options::OPT_object) ||
3583 Args.hasArg(options::OPT_preload))
3584 CmdArgs.push_back("-lcrt0.o");
3585 else
3587
3588 if (isTargetMacOS() && Args.hasArg(options::OPT_shared_libgcc) &&
3590 const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
3591 CmdArgs.push_back(Str);
3592 }
3593}
3594
3598 return;
3599 getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
3600}
3601
3603 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
3604 const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64;
3606 Res |= SanitizerKind::Address;
3607 Res |= SanitizerKind::PointerCompare;
3608 Res |= SanitizerKind::PointerSubtract;
3609 Res |= SanitizerKind::Realtime;
3610 Res |= SanitizerKind::Leak;
3611 Res |= SanitizerKind::Fuzzer;
3612 Res |= SanitizerKind::FuzzerNoLink;
3613 Res |= SanitizerKind::ObjCCast;
3614
3615
3616
3617
3620 Res |= SanitizerKind::Vptr;
3621
3622 if ((IsX86_64 || IsAArch64) &&
3625 Res |= SanitizerKind::Thread;
3626 }
3627
3629 Res |= SanitizerKind::Type;
3630 }
3631
3632 if (IsX86_64)
3633 Res |= SanitizerKind::NumericalStability;
3634
3635 return Res;
3636}
3637
3641}
Defines a function that returns the minimum OS versions supporting C++17's aligned allocation functio...
enum clang::sema::@1727::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()