14 #include "clang/Config/config.h" 20 #include "llvm/ADT/StringSwitch.h" 21 #include "llvm/Option/ArgList.h" 22 #include "llvm/ProfileData/InstrProf.h" 23 #include "llvm/Support/Path.h" 24 #include "llvm/Support/ScopedPrinter.h" 25 #include "llvm/Support/TargetParser.h" 26 #include "llvm/Support/VirtualFileSystem.h" 32 using namespace clang;
48 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
49 .Cases(
"ppc",
"ppc601",
"ppc603",
"ppc604",
"ppc604e", llvm::Triple::ppc)
50 .Cases(
"ppc750",
"ppc7400",
"ppc7450",
"ppc970", llvm::Triple::ppc)
51 .Case(
"ppc64", llvm::Triple::ppc64)
52 .Cases(
"i386",
"i486",
"i486SX",
"i586",
"i686", llvm::Triple::x86)
53 .Cases(
"pentium",
"pentpro",
"pentIIm3",
"pentIIm5",
"pentium4",
55 .Cases(
"x86_64",
"x86_64h", llvm::Triple::x86_64)
57 .Cases(
"arm",
"armv4t",
"armv5",
"armv6",
"armv6m", llvm::Triple::arm)
58 .Cases(
"armv7",
"armv7em",
"armv7k",
"armv7m", llvm::Triple::arm)
59 .Cases(
"armv7s",
"xscale", llvm::Triple::arm)
60 .Case(
"arm64", llvm::Triple::aarch64)
61 .Case(
"arm64_32", llvm::Triple::aarch64_32)
62 .Case(
"r600", llvm::Triple::r600)
63 .Case(
"amdgcn", llvm::Triple::amdgcn)
64 .Case(
"nvptx", llvm::Triple::nvptx)
65 .Case(
"nvptx64", llvm::Triple::nvptx64)
66 .Case(
"amdil", llvm::Triple::amdil)
67 .Case(
"spir", llvm::Triple::spir)
68 .Default(llvm::Triple::UnknownArch);
73 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseArch(Str);
78 else if (ArchKind == llvm::ARM::ArchKind::ARMV6M ||
79 ArchKind == llvm::ARM::ArchKind::ARMV7M ||
80 ArchKind == llvm::ARM::ArchKind::ARMV7EM) {
81 T.setOS(llvm::Triple::UnknownOS);
82 T.setObjectFormat(llvm::Triple::MachO);
90 const char *LinkingOutput)
const {
91 ArgStringList CmdArgs;
93 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
97 const Action *SourceAction = &JA;
99 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
100 SourceAction = SourceAction->
getInputs()[0];
108 if (Args.hasArg(options::OPT_fno_integrated_as)) {
109 const llvm::Triple &T(getToolChain().getTriple());
110 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
111 CmdArgs.push_back(
"-Q");
115 if (SourceAction->
getType() == types::TY_Asm ||
116 SourceAction->
getType() == types::TY_PP_Asm) {
117 if (Args.hasArg(options::OPT_gstabs))
118 CmdArgs.push_back(
"--gstabs");
119 else if (Args.hasArg(options::OPT_g_Group))
120 CmdArgs.push_back(
"-g");
124 AddMachOArch(Args, CmdArgs);
127 if (getToolChain().getTriple().isX86() ||
128 Args.hasArg(options::OPT_force__cpusubtype__ALL))
129 CmdArgs.push_back(
"-force_cpusubtype_ALL");
131 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
132 (((Args.hasArg(options::OPT_mkernel) ||
133 Args.hasArg(options::OPT_fapple_kext)) &&
134 getMachOToolChain().isKernelStatic()) ||
135 Args.hasArg(options::OPT_static)))
136 CmdArgs.push_back(
"-static");
138 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
140 assert(Output.
isFilename() &&
"Unexpected lipo output.");
141 CmdArgs.push_back(
"-o");
144 assert(Input.isFilename() &&
"Invalid input.");
145 CmdArgs.push_back(Input.getFilename());
149 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
150 C.
addCommand(std::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
153 void darwin::MachOTool::anchor() {}
156 ArgStringList &CmdArgs)
const {
157 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
160 CmdArgs.push_back(
"-arch");
161 CmdArgs.push_back(Args.MakeArgString(ArchName));
164 if (ArchName ==
"arm")
165 CmdArgs.push_back(
"-force_cpusubtype_ALL");
168 bool darwin::Linker::NeedsTempPath(
const InputInfoList &Inputs)
const {
172 for (
const auto &Input : Inputs)
173 if (Input.getType() != types::TY_Object)
187 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
188 if (A->getOption().matches(options::OPT_O0))
190 if (A->getOption().matches(options::OPT_O))
191 return llvm::StringSwitch<bool>(A->getValue())
197 if (!IsLinkerOnlyAction)
202 void darwin::Linker::AddLinkArgs(
Compilation &C,
const ArgList &Args,
203 ArgStringList &CmdArgs,
205 const Driver &D = getToolChain().getDriver();
208 unsigned Version[5] = {0, 0, 0, 0, 0};
209 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
211 D.
Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
216 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
217 CmdArgs.push_back(
"-demangle");
219 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
220 CmdArgs.push_back(
"-export_dynamic");
224 if (Args.hasFlag(options::OPT_fapplication_extension,
225 options::OPT_fno_application_extension,
false))
226 CmdArgs.push_back(
"-application_extension");
228 if (D.
isUsingLTO() && Version[0] >= 116 && NeedsTempPath(Inputs)) {
229 std::string TmpPathName;
240 if (!TmpPathName.empty()) {
241 auto *TmpPath = C.
getArgs().MakeArgString(TmpPathName);
243 CmdArgs.push_back(
"-object_path_lto");
244 CmdArgs.push_back(TmpPath);
255 if (Version[0] >= 133) {
257 StringRef
P = llvm::sys::path::parent_path(D.
Dir);
259 llvm::sys::path::append(LibLTOPath,
"lib");
260 llvm::sys::path::append(LibLTOPath,
"libLTO.dylib");
261 CmdArgs.push_back(
"-lto_library");
262 CmdArgs.push_back(C.
getArgs().MakeArgString(LibLTOPath));
267 CmdArgs.push_back(
"-no_deduplicate");
270 Args.AddAllArgs(CmdArgs, options::OPT_static);
271 if (!Args.hasArg(options::OPT_static))
272 CmdArgs.push_back(
"-dynamic");
273 if (Args.hasArg(options::OPT_fgnu_runtime)) {
278 if (!Args.hasArg(options::OPT_dynamiclib)) {
279 AddMachOArch(Args, CmdArgs);
281 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
283 Args.AddLastArg(CmdArgs, options::OPT_bundle);
284 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
285 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
288 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
289 (A = Args.getLastArg(options::OPT_current__version)) ||
290 (A = Args.getLastArg(options::OPT_install__name)))
291 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
294 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
295 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
296 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
298 CmdArgs.push_back(
"-dylib");
301 if ((A = Args.getLastArg(options::OPT_bundle)) ||
302 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
303 (A = Args.getLastArg(options::OPT_client__name)) ||
304 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
305 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
306 (A = Args.getLastArg(options::OPT_private__bundle)))
307 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
310 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
311 "-dylib_compatibility_version");
312 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
313 "-dylib_current_version");
315 AddMachOArch(Args, CmdArgs);
317 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
318 "-dylib_install_name");
321 Args.AddLastArg(CmdArgs, options::OPT_all__load);
322 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
323 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
325 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
326 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
327 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
328 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
329 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
330 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
331 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
332 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
333 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
334 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
335 Args.AddAllArgs(CmdArgs, options::OPT_init);
338 if (!Version[0] || Version[0] >= 520)
343 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
344 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
345 Args.AddLastArg(CmdArgs, options::OPT_single__module);
346 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
347 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
350 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
351 options::OPT_fno_pie, options::OPT_fno_PIE)) {
352 if (A->getOption().matches(options::OPT_fpie) ||
353 A->getOption().matches(options::OPT_fPIE))
354 CmdArgs.push_back(
"-pie");
356 CmdArgs.push_back(
"-no_pie");
363 CmdArgs.push_back(
"-bitcode_bundle");
365 CmdArgs.push_back(
"-bitcode_process_mode");
366 CmdArgs.push_back(
"marker");
369 D.
Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
372 Args.AddLastArg(CmdArgs, options::OPT_prebind);
373 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
374 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
375 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
376 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
377 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
378 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
379 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
380 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
381 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
382 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
383 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
384 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
385 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
386 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
387 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
393 CmdArgs.push_back(
"-syslibroot");
394 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
395 }
else if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
396 CmdArgs.push_back(
"-syslibroot");
397 CmdArgs.push_back(A->getValue());
400 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
401 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
402 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
403 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
404 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
405 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
406 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
407 Args.AddAllArgs(CmdArgs, options::OPT_y);
408 Args.AddLastArg(CmdArgs, options::OPT_w);
409 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
410 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
411 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
412 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
413 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
414 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
415 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
416 Args.AddLastArg(CmdArgs, options::OPT_whyload);
417 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
418 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
419 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
420 Args.AddLastArg(CmdArgs, options::OPT_Mach);
426 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
429 return Args.hasArg(options::OPT_fobjc_link_runtime);
436 const char *LinkingOutput)
const {
437 assert(Output.
getType() == types::TY_Image &&
"Invalid linker output type.");
443 llvm::opt::ArgStringList InputFileList;
448 ArgStringList CmdArgs;
451 if (Args.hasArg(options::OPT_ccc_arcmt_check,
452 options::OPT_ccc_arcmt_migrate)) {
453 for (
const auto &Arg : Args)
456 Args.MakeArgString(getToolChain().GetProgramPath(
"touch"));
458 C.
addCommand(std::make_unique<Command>(JA, *
this, Exec, CmdArgs, None));
464 AddLinkArgs(C, Args, CmdArgs, Inputs);
468 if (Args.hasFlag(options::OPT_fsave_optimization_record,
469 options::OPT_fsave_optimization_record_EQ,
470 options::OPT_fno_save_optimization_record,
false)) {
471 CmdArgs.push_back(
"-mllvm");
472 CmdArgs.push_back(
"-lto-pass-remarks-output");
473 CmdArgs.push_back(
"-mllvm");
479 Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
484 CmdArgs.push_back(Args.MakeArgString(F));
487 CmdArgs.push_back(
"-mllvm");
488 CmdArgs.push_back(
"-lto-pass-remarks-with-hotness");
491 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
492 CmdArgs.push_back(
"-mllvm");
494 std::string(
"-lto-pass-remarks-hotness-threshold=") + A->getValue();
495 CmdArgs.push_back(Args.MakeArgString(Opt));
500 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
501 CmdArgs.push_back(
"-mllvm");
503 std::string(
"-lto-pass-remarks-filter=") + A->getValue();
504 CmdArgs.push_back(Args.MakeArgString(Passes));
508 Args.getLastArg(options::OPT_fsave_optimization_record_EQ)) {
509 CmdArgs.push_back(
"-mllvm");
511 std::string(
"-lto-pass-remarks-format=") + A->getValue();
512 CmdArgs.push_back(Args.MakeArgString(Format));
518 Args.getLastArg(options::OPT_moutline, options::OPT_mno_outline)) {
519 if (A->getOption().matches(options::OPT_moutline)) {
520 if (getMachOToolChain().getMachOArchName(Args) ==
"arm64") {
521 CmdArgs.push_back(
"-mllvm");
522 CmdArgs.push_back(
"-enable-machine-outliner");
525 CmdArgs.push_back(
"-mllvm");
526 CmdArgs.push_back(
"-enable-linkonceodr-outlining");
532 CmdArgs.push_back(
"-mllvm");
533 CmdArgs.push_back(
"-enable-machine-outliner=never");
540 if (!StatsFile.empty()) {
541 CmdArgs.push_back(
"-mllvm");
542 CmdArgs.push_back(Args.MakeArgString(
"-lto-stats-file=" + StatsFile.str()));
547 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
548 options::OPT_Z_Flag, options::OPT_u_Group,
549 options::OPT_e, options::OPT_r});
554 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
555 CmdArgs.push_back(
"-ObjC");
557 CmdArgs.push_back(
"-o");
560 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
561 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
563 Args.AddAllArgs(CmdArgs, options::OPT_L);
568 for (
const auto &II : Inputs) {
569 if (!II.isFilename()) {
574 if (InputFileList.size() > 0)
580 InputFileList.push_back(II.getFilename());
583 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
587 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
589 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
591 CmdArgs.push_back(
"-framework");
592 CmdArgs.push_back(
"Foundation");
594 CmdArgs.push_back(
"-lobjc");
598 CmdArgs.push_back(
"-arch_multiple");
599 CmdArgs.push_back(
"-final_output");
600 CmdArgs.push_back(LinkingOutput);
603 if (Args.hasArg(options::OPT_fnested_functions))
604 CmdArgs.push_back(
"-allow_stack_execute");
606 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
608 if (
unsigned Parallelism =
610 CmdArgs.push_back(
"-mllvm");
611 CmdArgs.push_back(Args.MakeArgString(
"-threads=" + Twine(Parallelism)));
614 if (getToolChain().ShouldLinkCXXStdlib(Args))
615 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
617 bool NoStdOrDefaultLibs =
618 Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs);
619 bool ForceLinkBuiltins = Args.hasArg(options::OPT_fapple_link_rtlib);
620 if (!NoStdOrDefaultLibs || ForceLinkBuiltins) {
625 if (NoStdOrDefaultLibs && ForceLinkBuiltins) {
626 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
"builtins");
629 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs,
633 Args.ClaimAllArgs(options::OPT_pthread);
634 Args.ClaimAllArgs(options::OPT_pthreads);
638 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
642 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
643 Args.AddAllArgs(CmdArgs, options::OPT_F);
646 for (
const Arg *A : Args.filtered(options::OPT_iframework))
647 CmdArgs.push_back(Args.MakeArgString(std::string(
"-F") + A->getValue()));
649 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
650 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
651 if (A->getValue() == StringRef(
"Accelerate")) {
652 CmdArgs.push_back(
"-framework");
653 CmdArgs.push_back(
"Accelerate");
658 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
659 std::unique_ptr<Command>
Cmd =
660 std::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs);
661 Cmd->setInputFileList(std::move(InputFileList));
669 const char *LinkingOutput)
const {
670 ArgStringList CmdArgs;
672 CmdArgs.push_back(
"-create");
673 assert(Output.
isFilename() &&
"Unexpected lipo output.");
675 CmdArgs.push_back(
"-output");
678 for (
const auto &II : Inputs) {
679 assert(II.isFilename() &&
"Unexpected lipo input.");
680 CmdArgs.push_back(II.getFilename());
683 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"lipo"));
684 C.
addCommand(std::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
691 const char *LinkingOutput)
const {
692 ArgStringList CmdArgs;
694 CmdArgs.push_back(
"-o");
697 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
699 assert(Input.isFilename() &&
"Unexpected dsymutil input.");
700 CmdArgs.push_back(Input.getFilename());
703 Args.MakeArgString(getToolChain().GetProgramPath(
"dsymutil"));
704 C.
addCommand(std::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
711 const char *LinkingOutput)
const {
712 ArgStringList CmdArgs;
713 CmdArgs.push_back(
"--verify");
714 CmdArgs.push_back(
"--debug-info");
715 CmdArgs.push_back(
"--eh-frame");
716 CmdArgs.push_back(
"--quiet");
718 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
720 assert(Input.isFilename() &&
"Unexpected verify input");
723 CmdArgs.push_back(Input.getFilename());
726 Args.MakeArgString(getToolChain().GetProgramPath(
"dwarfdump"));
727 C.
addCommand(std::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
730 MachO::MachO(
const Driver &D,
const llvm::Triple &Triple,
const ArgList &Args)
740 :
MachO(D, Triple, Args), TargetInitialized(
false),
741 CudaInstallation(D, Triple, Args) {}
747 if (Ty == types::TY_PP_Asm)
748 return types::TY_Asm;
789 ArgStringList &CC1Args)
const {
798 return llvm::StringSwitch<const char *>(Arch)
799 .Case(
"armv6k",
"armv6")
800 .Case(
"armv6m",
"armv6m")
801 .Case(
"armv5tej",
"armv5")
802 .Case(
"xscale",
"xscale")
803 .Case(
"armv4t",
"armv4t")
804 .Case(
"armv7",
"armv7")
805 .Cases(
"armv7a",
"armv7-a",
"armv7")
806 .Cases(
"armv7r",
"armv7-r",
"armv7")
807 .Cases(
"armv7em",
"armv7e-m",
"armv7em")
808 .Cases(
"armv7k",
"armv7-k",
"armv7k")
809 .Cases(
"armv7m",
"armv7-m",
"armv7m")
810 .Cases(
"armv7s",
"armv7-s",
"armv7s")
815 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
816 if (ArchKind == llvm::ARM::ArchKind::INVALID)
818 StringRef Arch = llvm::ARM::getArchName(ArchKind);
822 if (Arch.startswith(
"armv5"))
823 Arch = Arch.substr(0, 5);
825 else if (Arch.startswith(
"armv6") && !Arch.endswith(
"6m"))
826 Arch = Arch.substr(0, 5);
828 else if (Arch.endswith(
"v7a"))
829 Arch = Arch.substr(0, 5);
838 case llvm::Triple::aarch64_32:
841 case llvm::Triple::aarch64:
844 case llvm::Triple::thumb:
845 case llvm::Triple::arm:
846 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
850 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
869 return Triple.getTriple();
881 Triple.setOSName(Str);
883 return Triple.getTriple();
895 return Dsymutil.get();
899 return VerifyDebug.get();
913 :
Darwin(D, Triple, Args) {}
920 CC1Args.push_back(
"-Wdeprecated-objc-isa-usage");
921 CC1Args.push_back(
"-Werror=deprecated-objc-isa-usage");
926 CC1Args.push_back(
"-Werror=implicit-function-declaration");
934 static constexpr llvm::StringLiteral XcodeAppSuffix(
935 ".app/Contents/Developer");
936 size_t Index = PathIntoXcode.find(XcodeAppSuffix);
937 if (Index == StringRef::npos)
939 return PathIntoXcode.take_front(Index + XcodeAppSuffix.size());
943 ArgStringList &CmdArgs)
const {
955 llvm::sys::path::remove_filename(P);
956 llvm::sys::path::remove_filename(P);
963 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
967 if (!XcodePathForSDK.empty()) {
969 llvm::sys::path::append(P,
"Toolchains/XcodeDefault.xctoolchain/usr");
974 CmdArgs.push_back(
"-force_load");
975 llvm::sys::path::append(P,
"lib",
"arc",
"libarclite_");
978 P +=
"watchsimulator";
982 P +=
"appletvsimulator";
986 P +=
"iphonesimulator";
993 CmdArgs.push_back(Args.MakeArgString(P));
1006 bool IsShared)
const {
1009 if (Component !=
"builtins") {
1010 DarwinLibName += Component;
1012 DarwinLibName +=
"_";
1017 DarwinLibName += IsShared ?
"_dynamic.dylib" :
".a";
1019 llvm::sys::path::append(
1020 Dir,
"lib", (Opts &
RLO_IsEmbedded) ?
"macho_embedded" :
"darwin");
1023 llvm::sys::path::append(P, DarwinLibName);
1029 const char *LibArg = Args.MakeArgString(P);
1031 CmdArgs.insert(CmdArgs.begin(), LibArg);
1033 CmdArgs.push_back(LibArg);
1041 assert(DarwinLibName.endswith(
".dylib") &&
"must be a dynamic library");
1045 CmdArgs.push_back(
"-rpath");
1046 CmdArgs.push_back(
"@executable_path");
1050 CmdArgs.push_back(
"-rpath");
1051 CmdArgs.push_back(Args.MakeArgString(Dir));
1057 case DarwinPlatformKind::MacOS:
1059 case DarwinPlatformKind::IPhoneOS:
1061 case DarwinPlatformKind::TvOS:
1063 case DarwinPlatformKind::WatchOS:
1066 llvm_unreachable(
"Unsupported platform");
1071 auto BeginSDK = llvm::sys::path::begin(isysroot);
1072 auto EndSDK = llvm::sys::path::end(isysroot);
1073 for (
auto IT = BeginSDK; IT != EndSDK; ++IT) {
1074 StringRef SDK = *IT;
1075 if (SDK.endswith(
".sdk"))
1076 return SDK.slice(0, SDK.size() - 4);
1083 case DarwinPlatformKind::MacOS:
1085 case DarwinPlatformKind::IPhoneOS:
1088 case DarwinPlatformKind::TvOS:
1091 case DarwinPlatformKind::WatchOS:
1095 llvm_unreachable(
"Unsupported platform");
1100 for (Arg *A : Args) {
1101 if (A->getOption().matches(options::OPT_exported__symbols__list))
1103 if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
1104 !A->getOption().matches(options::OPT_Xlinker))
1106 if (A->containsValue(
"-exported_symbols_list") ||
1107 A->containsValue(
"-exported_symbol"))
1115 CmdArgs.push_back(
"-exported_symbol");
1116 CmdArgs.push_back(Symbol);
1126 StringRef Segment, StringRef Section) {
1127 for (
const char *A : {
"-sectalign", Args.MakeArgString(Segment),
1128 Args.MakeArgString(Section),
"0x4000"})
1129 CmdArgs.push_back(A);
1133 ArgStringList &CmdArgs)
const {
1166 for (
auto IPSK : {llvm::IPSK_cnts, llvm::IPSK_data}) {
1168 Args, CmdArgs,
"__DATA",
1169 llvm::getInstrProfSectionName(IPSK, llvm::Triple::MachO,
1175 void DarwinClang::AddLinkSanitizerLibArgs(
const ArgList &Args,
1176 ArgStringList &CmdArgs,
1177 StringRef Sanitizer,
1178 bool Shared)
const {
1184 const ArgList &Args)
const {
1185 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1186 StringRef
Value = A->getValue();
1187 if (Value !=
"compiler-rt")
1188 getDriver().
Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1189 << Value <<
"darwin";
1196 ArgStringList &CmdArgs,
1197 bool ForceLinkBuiltinRT)
const {
1203 if (Args.hasArg(options::OPT_static) ||
1204 Args.hasArg(options::OPT_fapple_kext) ||
1205 Args.hasArg(options::OPT_mkernel)) {
1206 if (ForceLinkBuiltinRT)
1214 if (
const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1215 getDriver().
Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1221 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan");
1223 AddLinkSanitizerLibArgs(Args, CmdArgs,
"lsan");
1225 AddLinkSanitizerLibArgs(Args, CmdArgs,
1230 AddLinkSanitizerLibArgs(Args, CmdArgs,
"tsan");
1231 if (Sanitize.
needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1232 AddLinkSanitizerLibArgs(Args, CmdArgs,
"fuzzer",
false);
1239 AddLinkSanitizerLibArgs(Args, CmdArgs,
"stats");
1251 CmdArgs.push_back(
"-lSystem");
1260 CmdArgs.push_back(
"-lgcc_s.1");
1270 unsigned Major, Minor, Micro;
1271 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1272 if (!SystemTriple.isMacOSX())
1273 return MacOSSDKVersion;
1274 SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1275 VersionTuple SystemVersion(Major, Minor, Micro);
1279 return MacOSSDKVersion;
1280 VersionTuple SDKVersion(Major, Minor, Micro);
1281 if (SDKVersion > SystemVersion)
1282 return SystemVersion.getAsString();
1283 return MacOSSDKVersion;
1289 struct DarwinPlatform {
1296 DeploymentTargetEnv,
1312 InferSimulatorFromArch =
false;
1315 StringRef getOSVersion()
const {
1316 if (Kind == OSVersionArg)
1317 return Argument->getValue();
1321 void setOSVersion(StringRef S) {
1322 assert(Kind == TargetArg &&
"Unexpected kind!");
1326 bool hasOSVersion()
const {
return HasOSVersion; }
1329 bool isExplicitlySpecified()
const {
return Kind <= DeploymentTargetEnv; }
1332 bool canInferSimulatorFromArch()
const {
return InferSimulatorFromArch; }
1335 void addOSVersionMinArgument(DerivedArgList &Args,
const OptTable &Opts) {
1338 assert(Kind != TargetArg && Kind != OSVersionArg &&
"Invalid kind");
1341 case DarwinPlatformKind::MacOS:
1342 Opt = options::OPT_mmacosx_version_min_EQ;
1344 case DarwinPlatformKind::IPhoneOS:
1345 Opt = options::OPT_miphoneos_version_min_EQ;
1347 case DarwinPlatformKind::TvOS:
1348 Opt = options::OPT_mtvos_version_min_EQ;
1350 case DarwinPlatformKind::WatchOS:
1351 Opt = options::OPT_mwatchos_version_min_EQ;
1354 Argument = Args.MakeJoinedArg(
nullptr, Opts.getOption(Opt), OSVersion);
1355 Args.append(Argument);
1360 std::string
getAsString(DerivedArgList &Args,
const OptTable &Opts) {
1364 case InferredFromSDK:
1365 case InferredFromArch:
1366 assert(Argument &&
"OS version argument not yet inferred");
1367 return Argument->getAsString(Args);
1368 case DeploymentTargetEnv:
1369 return (llvm::Twine(EnvVarName) +
"=" + OSVersion).str();
1371 llvm_unreachable(
"Unsupported Darwin Source Kind");
1374 static DarwinPlatform createFromTarget(
const llvm::Triple &TT,
1375 StringRef OSVersion, Arg *A) {
1376 DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
1378 switch (TT.getEnvironment()) {
1379 case llvm::Triple::Simulator:
1380 Result.Environment = DarwinEnvironmentKind::Simulator;
1385 unsigned Major, Minor, Micro;
1386 TT.getOSVersion(Major, Minor, Micro);
1388 Result.HasOSVersion =
false;
1393 return DarwinPlatform(OSVersionArg, Platform, A);
1396 StringRef EnvVarName,
1398 DarwinPlatform Result(DeploymentTargetEnv, Platform, Value);
1399 Result.EnvVarName = EnvVarName;
1404 bool IsSimulator =
false) {
1405 DarwinPlatform Result(InferredFromSDK, Platform, Value);
1407 Result.Environment = DarwinEnvironmentKind::Simulator;
1408 Result.InferSimulatorFromArch =
false;
1411 static DarwinPlatform createFromArch(llvm::Triple::OSType OS,
1413 return DarwinPlatform(InferredFromArch, getPlatformFromOS(OS), Value);
1420 assert(Kind == InferredFromSDK &&
"can infer SDK info only");
1421 llvm::VersionTuple Version;
1422 bool IsValid = !Version.tryParse(OSVersion);
1424 assert(IsValid &&
"invalid SDK version");
1430 :
Kind(Kind), Platform(Platform), Argument(Argument) {}
1432 Arg *Argument =
nullptr)
1433 :
Kind(Kind), Platform(Platform), OSVersion(Value), Argument(Argument) {}
1437 case llvm::Triple::Darwin:
1438 case llvm::Triple::MacOSX:
1439 return DarwinPlatformKind::MacOS;
1440 case llvm::Triple::IOS:
1441 return DarwinPlatformKind::IPhoneOS;
1442 case llvm::Triple::TvOS:
1443 return DarwinPlatformKind::TvOS;
1444 case llvm::Triple::WatchOS:
1445 return DarwinPlatformKind::WatchOS;
1447 llvm_unreachable(
"Unable to infer Darwin variant");
1454 std::string OSVersion;
1455 bool HasOSVersion =
true, InferSimulatorFromArch =
true;
1457 StringRef EnvVarName;
1463 getDeploymentTargetFromOSVersionArg(DerivedArgList &Args,
1464 const Driver &TheDriver) {
1465 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
1466 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ,
1467 options::OPT_mios_simulator_version_min_EQ);
1469 Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1470 options::OPT_mtvos_simulator_version_min_EQ);
1471 Arg *WatchOSVersion =
1472 Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1473 options::OPT_mwatchos_simulator_version_min_EQ);
1475 if (iOSVersion || TvOSVersion || WatchOSVersion) {
1476 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1477 << OSXVersion->getAsString(Args)
1478 << (iOSVersion ? iOSVersion
1479 : TvOSVersion ? TvOSVersion : WatchOSVersion)
1482 return DarwinPlatform::createOSVersionArg(
Darwin::MacOS, OSXVersion);
1483 }
else if (iOSVersion) {
1484 if (TvOSVersion || WatchOSVersion) {
1485 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1486 << iOSVersion->getAsString(Args)
1487 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->
getAsString(Args);
1490 }
else if (TvOSVersion) {
1491 if (WatchOSVersion) {
1492 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1493 << TvOSVersion->getAsString(Args)
1494 << WatchOSVersion->getAsString(Args);
1496 return DarwinPlatform::createOSVersionArg(
Darwin::TvOS, TvOSVersion);
1497 }
else if (WatchOSVersion)
1498 return DarwinPlatform::createOSVersionArg(
Darwin::WatchOS, WatchOSVersion);
1505 getDeploymentTargetFromEnvironmentVariables(
const Driver &TheDriver,
1506 const llvm::Triple &Triple) {
1508 const char *EnvVars[] = {
1509 "MACOSX_DEPLOYMENT_TARGET",
1510 "IPHONEOS_DEPLOYMENT_TARGET",
1511 "TVOS_DEPLOYMENT_TARGET",
1512 "WATCHOS_DEPLOYMENT_TARGET",
1515 "Missing platform");
1516 for (
const auto &I : llvm::enumerate(llvm::makeArrayRef(EnvVars))) {
1517 if (
char *Env = ::getenv(I.value()))
1518 Targets[I.index()] = Env;
1526 if (Triple.getArch() == llvm::Triple::arm ||
1527 Triple.getArch() == llvm::Triple::aarch64 ||
1528 Triple.getArch() == llvm::Triple::thumb)
1535 unsigned FirstTarget = llvm::array_lengthof(Targets);
1536 for (
unsigned I = 0; I != llvm::array_lengthof(Targets); ++I) {
1537 if (Targets[I].empty())
1539 if (FirstTarget == llvm::array_lengthof(Targets))
1542 TheDriver.
Diag(diag::err_drv_conflicting_deployment_targets)
1543 << Targets[FirstTarget] << Targets[I];
1547 for (
const auto &
Target : llvm::enumerate(llvm::makeArrayRef(Targets))) {
1548 if (!
Target.value().empty())
1549 return DarwinPlatform::createDeploymentTargetEnv(
1560 inferDeploymentTargetFromSDK(DerivedArgList &Args,
1562 const Arg *A = Args.getLastArg(options::OPT_isysroot);
1565 StringRef isysroot = A->getValue();
1570 std::string Version;
1573 Version = SDKInfo->getVersion().getAsString();
1577 size_t StartVer = SDK.find_first_of(
"0123456789");
1578 size_t EndVer = SDK.find_last_of(
"0123456789");
1579 if (StartVer != StringRef::npos && EndVer > StartVer)
1580 Version = SDK.slice(StartVer, EndVer + 1);
1582 if (Version.empty())
1585 if (SDK.startswith(
"iPhoneOS") || SDK.startswith(
"iPhoneSimulator"))
1586 return DarwinPlatform::createFromSDK(
1588 SDK.startswith(
"iPhoneSimulator"));
1589 else if (SDK.startswith(
"MacOSX"))
1592 else if (SDK.startswith(
"WatchOS") || SDK.startswith(
"WatchSimulator"))
1593 return DarwinPlatform::createFromSDK(
1595 SDK.startswith(
"WatchSimulator"));
1596 else if (SDK.startswith(
"AppleTVOS") || SDK.startswith(
"AppleTVSimulator"))
1597 return DarwinPlatform::createFromSDK(
1599 SDK.startswith(
"AppleTVSimulator"));
1603 std::string getOSVersion(llvm::Triple::OSType OS,
const llvm::Triple &Triple,
1604 const Driver &TheDriver) {
1605 unsigned Major, Minor, Micro;
1606 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1608 case llvm::Triple::Darwin:
1609 case llvm::Triple::MacOSX:
1612 if (Triple.isMacOSX() && SystemTriple.isMacOSX() &&
1613 !Triple.getOSMajorVersion())
1614 SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1615 else if (!Triple.getMacOSXVersion(Major, Minor, Micro))
1616 TheDriver.
Diag(diag::err_drv_invalid_darwin_version)
1617 << Triple.getOSName();
1619 case llvm::Triple::IOS:
1620 Triple.getiOSVersion(Major, Minor, Micro);
1622 case llvm::Triple::TvOS:
1623 Triple.getOSVersion(Major, Minor, Micro);
1625 case llvm::Triple::WatchOS:
1626 Triple.getWatchOSVersion(Major, Minor, Micro);
1629 llvm_unreachable(
"Unexpected OS type");
1633 std::string OSVersion;
1634 llvm::raw_string_ostream(OSVersion) << Major <<
'.' << Minor <<
'.' << Micro;
1640 inferDeploymentTargetFromArch(DerivedArgList &Args,
const Darwin &Toolchain,
1641 const llvm::Triple &Triple,
1642 const Driver &TheDriver) {
1643 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
1646 if (MachOArchName ==
"armv7" || MachOArchName ==
"armv7s" ||
1647 MachOArchName ==
"arm64")
1648 OSTy = llvm::Triple::IOS;
1649 else if (MachOArchName ==
"armv7k" || MachOArchName ==
"arm64_32")
1650 OSTy = llvm::Triple::WatchOS;
1651 else if (MachOArchName !=
"armv6m" && MachOArchName !=
"armv7m" &&
1652 MachOArchName !=
"armv7em")
1653 OSTy = llvm::Triple::MacOSX;
1655 if (OSTy == llvm::Triple::UnknownOS)
1657 return DarwinPlatform::createFromArch(OSTy,
1658 getOSVersion(OSTy, Triple, TheDriver));
1663 DerivedArgList &Args,
const llvm::Triple &Triple,
const Driver &TheDriver) {
1664 if (!Args.hasArg(options::OPT_target))
1666 if (Triple.getOS() == llvm::Triple::Darwin ||
1667 Triple.getOS() == llvm::Triple::UnknownOS)
1669 std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
1670 return DarwinPlatform::createFromTarget(Triple, OSVersion,
1671 Args.getLastArg(options::OPT_target));
1675 const ArgList &Args,
1676 const Driver &TheDriver) {
1677 const Arg *A = Args.getLastArg(options::OPT_isysroot);
1680 StringRef isysroot = A->getValue();
1682 if (!SDKInfoOrErr) {
1683 llvm::consumeError(SDKInfoOrErr.takeError());
1684 TheDriver.
Diag(diag::warn_drv_darwin_sdk_invalid_settings);
1687 return *SDKInfoOrErr;
1692 void Darwin::AddDeploymentTarget(DerivedArgList &Args)
const {
1698 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1700 if (!
getVFS().exists(A->getValue()))
1701 getDriver().
Diag(clang::diag::warn_missing_sysroot) << A->getValue();
1703 if (
char *env = ::getenv(
"SDKROOT")) {
1706 if (llvm::sys::path::is_absolute(env) &&
getVFS().exists(env) &&
1707 StringRef(env) !=
"/") {
1708 Args.append(Args.MakeSeparateArg(
1709 nullptr, Opts.getOption(options::OPT_isysroot), env));
1723 getDeploymentTargetFromOSVersionArg(Args,
getDriver());
1724 if (OSVersionArgTarget) {
1725 unsigned TargetMajor, TargetMinor, TargetMicro;
1727 unsigned ArgMajor, ArgMinor, ArgMicro;
1729 if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
1731 TargetMinor, TargetMicro, TargetExtra) &&
1733 ArgMajor, ArgMinor, ArgMicro, ArgExtra) &&
1734 (VersionTuple(TargetMajor, TargetMinor, TargetMicro) !=
1735 VersionTuple(ArgMajor, ArgMinor, ArgMicro) ||
1736 TargetExtra != ArgExtra))) {
1739 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
1740 !OSTarget->hasOSVersion()) {
1741 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
1745 std::string OSVersionArg =
1746 OSVersionArgTarget->getAsString(Args, Opts);
1747 std::string TargetArg = OSTarget->getAsString(Args, Opts);
1748 getDriver().
Diag(clang::diag::warn_drv_overriding_flag_option)
1749 << OSVersionArg << TargetArg;
1755 OSTarget = getDeploymentTargetFromOSVersionArg(Args,
getDriver());
1764 inferDeploymentTargetFromSDK(Args,
SDKInfo);
1766 OSTarget->setEnvironment(SDKTarget->getEnvironment());
1773 OSTarget = inferDeploymentTargetFromSDK(Args,
SDKInfo);
1777 SDKInfo = OSTarget->inferSDKInfo();
1786 assert(OSTarget &&
"Unable to infer Darwin variant");
1787 OSTarget->addOSVersionMinArgument(Args, Opts);
1790 unsigned Major, Minor, Micro;
1793 if (Platform ==
MacOS) {
1796 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
1798 << OSTarget->getAsString(Args, Opts);
1802 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1804 << OSTarget->getAsString(Args, Opts);
1808 if (
getTriple().isArch32Bit() && Major >= 11) {
1810 if (OSTarget->isExplicitlySpecified()) {
1812 << OSTarget->getAsString(Args, Opts);
1820 }
else if (Platform ==
TvOS) {
1823 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1825 << OSTarget->getAsString(Args, Opts);
1826 }
else if (Platform ==
WatchOS) {
1829 HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
1831 << OSTarget->getAsString(Args, Opts);
1833 llvm_unreachable(
"unknown kind of Darwin platform");
1838 OSTarget->canInferSimulatorFromArch() &&
getTriple().isX86())
1841 setTarget(Platform, Environment, Major, Minor, Micro);
1843 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1845 if (SDK.size() > 0) {
1846 size_t StartVer = SDK.find_first_of(
"0123456789");
1847 StringRef SDKName = SDK.slice(0, StartVer);
1857 llvm::StringRef DarwinClang::GetHeaderSysroot(
const llvm::opt::ArgList &DriverArgs)
const {
1858 if(DriverArgs.hasArg(options::OPT_isysroot))
1859 return DriverArgs.getLastArgValue(options::OPT_isysroot);
1866 llvm::opt::ArgStringList &CC1Args)
const {
1869 llvm::StringRef Sysroot = GetHeaderSysroot(DriverArgs);
1871 bool NoStdInc = DriverArgs.hasArg(options::OPT_nostdinc);
1872 bool NoStdlibInc = DriverArgs.hasArg(options::OPT_nostdlibinc);
1873 bool NoBuiltinInc = DriverArgs.hasArg(options::OPT_nobuiltininc);
1876 if (!NoStdInc && !NoStdlibInc) {
1878 llvm::sys::path::append(P,
"usr",
"local",
"include");
1883 if (!NoStdInc && !NoBuiltinInc) {
1885 llvm::sys::path::append(P,
"include");
1889 if (NoStdInc || NoStdlibInc)
1893 llvm::StringRef CIncludeDirs(C_INCLUDE_DIRS);
1894 if (!CIncludeDirs.empty()) {
1896 CIncludeDirs.split(dirs,
":");
1897 for (llvm::StringRef dir : dirs) {
1898 llvm::StringRef Prefix =
1899 llvm::sys::path::is_absolute(dir) ? llvm::StringRef(Sysroot) :
"";
1905 llvm::sys::path::append(P,
"usr",
"include");
1910 bool DarwinClang::AddGnuCPlusPlusIncludePaths(
const llvm::opt::ArgList &DriverArgs,
1911 llvm::opt::ArgStringList &CC1Args,
1913 llvm::StringRef Version,
1914 llvm::StringRef ArchDir,
1915 llvm::StringRef BitDir)
const {
1916 llvm::sys::path::append(Base, Version);
1924 if (!ArchDir.empty())
1925 llvm::sys::path::append(P, ArchDir);
1926 if (!BitDir.empty())
1927 llvm::sys::path::append(P, BitDir);
1934 llvm::sys::path::append(P,
"backward");
1938 return getVFS().exists(Base);
1942 const llvm::opt::ArgList &DriverArgs,
1943 llvm::opt::ArgStringList &CC1Args)
const {
1951 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1952 DriverArgs.hasArg(options::OPT_nostdincxx))
1955 llvm::StringRef Sysroot = GetHeaderSysroot(DriverArgs);
1964 llvm::sys::path::append(P,
"..",
"include",
"c++",
"v1");
1969 if (!DriverArgs.hasArg(options::OPT_nostdinc)) {
1971 llvm::sys::path::append(P,
"usr",
"include",
"c++",
"v1");
1979 llvm::sys::path::append(UsrIncludeCxx,
"usr",
"include",
"c++");
1981 llvm::Triple::ArchType arch =
getTriple().getArch();
1982 bool IsBaseFound =
true;
1986 case llvm::Triple::ppc:
1987 case llvm::Triple::ppc64:
1988 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
1990 "powerpc-apple-darwin10",
1991 arch == llvm::Triple::ppc64 ?
"ppc64" :
"");
1992 IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
1993 "4.0.0",
"powerpc-apple-darwin10",
1994 arch == llvm::Triple::ppc64 ?
"ppc64" :
"");
1997 case llvm::Triple::x86:
1998 case llvm::Triple::x86_64:
1999 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2001 "i686-apple-darwin10",
2002 arch == llvm::Triple::x86_64 ?
"x86_64" :
"");
2003 IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2004 "4.0.0",
"i686-apple-darwin8",
2008 case llvm::Triple::arm:
2009 case llvm::Triple::thumb:
2010 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2012 "arm-apple-darwin10",
2014 IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2016 "arm-apple-darwin10",
2020 case llvm::Triple::aarch64:
2021 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2023 "arm64-apple-darwin10",
2036 ArgStringList &CmdArgs)
const {
2041 CmdArgs.push_back(
"-lc++");
2051 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2053 llvm::sys::path::append(
P,
"usr",
"lib",
"libstdc++.dylib");
2056 llvm::sys::path::remove_filename(
P);
2057 llvm::sys::path::append(
P,
"libstdc++.6.dylib");
2059 CmdArgs.push_back(Args.MakeArgString(
P));
2068 if (!
getVFS().exists(
"/usr/lib/libstdc++.dylib") &&
2069 getVFS().exists(
"/usr/lib/libstdc++.6.dylib")) {
2070 CmdArgs.push_back(
"/usr/lib/libstdc++.6.dylib");
2075 CmdArgs.push_back(
"-lstdc++");
2081 ArgStringList &CmdArgs)
const {
2087 llvm::sys::path::append(P,
"lib",
"darwin");
2091 llvm::sys::path::append(P,
"libclang_rt.cc_kext_watchos.a");
2093 llvm::sys::path::append(P,
"libclang_rt.cc_kext_tvos.a");
2095 llvm::sys::path::append(P,
"libclang_rt.cc_kext_ios.a");
2097 llvm::sys::path::append(P,
"libclang_rt.cc_kext.a");
2103 CmdArgs.push_back(Args.MakeArgString(P));
2107 StringRef BoundArch,
2109 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
2119 for (Arg *A : Args) {
2120 if (A->getOption().matches(options::OPT_Xarch__)) {
2123 llvm::Triple::ArchType XarchArch =
2125 if (!(XarchArch ==
getArch() ||
2126 (!BoundArch.empty() &&
2131 Arg *OriginalArg = A;
2132 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
2133 unsigned Prev = Index;
2134 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
2144 if (!XarchArg || Index > Prev + 1) {
2145 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
2146 << A->getAsString(Args);
2149 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
2150 << A->getAsString(Args);
2154 XarchArg->setBaseArg(A);
2156 A = XarchArg.release();
2157 DAL->AddSynthesizedArg(A);
2164 for (
const char *
Value : A->getValues()) {
2165 DAL->AddSeparateArg(
2166 OriginalArg, Opts.getOption(options::OPT_Zlinker_input),
Value);
2180 case options::OPT_mkernel:
2181 case options::OPT_fapple_kext:
2183 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
2186 case options::OPT_dependency_file:
2187 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
2190 case options::OPT_gfull:
2191 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2193 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
2196 case options::OPT_gused:
2197 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2199 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
2202 case options::OPT_shared:
2203 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
2206 case options::OPT_fconstant_cfstrings:
2207 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
2210 case options::OPT_fno_constant_cfstrings:
2211 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
2214 case options::OPT_Wnonportable_cfstrings:
2216 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
2219 case options::OPT_Wno_nonportable_cfstrings:
2221 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
2224 case options::OPT_fpascal_strings:
2225 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
2228 case options::OPT_fno_pascal_strings:
2229 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
2235 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
2236 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_mtune_EQ),
2241 if (!BoundArch.empty()) {
2242 StringRef Name = BoundArch;
2243 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
2244 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
2250 else if (Name ==
"ppc601")
2251 DAL->AddJoinedArg(
nullptr, MCpu,
"601");
2252 else if (Name ==
"ppc603")
2253 DAL->AddJoinedArg(
nullptr, MCpu,
"603");
2254 else if (Name ==
"ppc604")
2255 DAL->AddJoinedArg(
nullptr, MCpu,
"604");
2256 else if (Name ==
"ppc604e")
2257 DAL->AddJoinedArg(
nullptr, MCpu,
"604e");
2258 else if (Name ==
"ppc750")
2259 DAL->AddJoinedArg(
nullptr, MCpu,
"750");
2260 else if (Name ==
"ppc7400")
2261 DAL->AddJoinedArg(
nullptr, MCpu,
"7400");
2262 else if (Name ==
"ppc7450")
2263 DAL->AddJoinedArg(
nullptr, MCpu,
"7450");
2264 else if (Name ==
"ppc970")
2265 DAL->AddJoinedArg(
nullptr, MCpu,
"970");
2267 else if (Name ==
"ppc64" || Name ==
"ppc64le")
2268 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2270 else if (Name ==
"i386")
2272 else if (Name ==
"i486")
2273 DAL->AddJoinedArg(
nullptr, MArch,
"i486");
2274 else if (Name ==
"i586")
2275 DAL->AddJoinedArg(
nullptr, MArch,
"i586");
2276 else if (Name ==
"i686")
2277 DAL->AddJoinedArg(
nullptr, MArch,
"i686");
2278 else if (Name ==
"pentium")
2279 DAL->AddJoinedArg(
nullptr, MArch,
"pentium");
2280 else if (Name ==
"pentium2")
2281 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2282 else if (Name ==
"pentpro")
2283 DAL->AddJoinedArg(
nullptr, MArch,
"pentiumpro");
2284 else if (Name ==
"pentIIm3")
2285 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2287 else if (Name ==
"x86_64" || Name ==
"x86_64h")
2288 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2290 else if (Name ==
"arm")
2291 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2292 else if (Name ==
"armv4t")
2293 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2294 else if (Name ==
"armv5")
2295 DAL->AddJoinedArg(
nullptr, MArch,
"armv5tej");
2296 else if (Name ==
"xscale")
2297 DAL->AddJoinedArg(
nullptr, MArch,
"xscale");
2298 else if (Name ==
"armv6")
2299 DAL->AddJoinedArg(
nullptr, MArch,
"armv6k");
2300 else if (Name ==
"armv6m")
2301 DAL->AddJoinedArg(
nullptr, MArch,
"armv6m");
2302 else if (Name ==
"armv7")
2303 DAL->AddJoinedArg(
nullptr, MArch,
"armv7a");
2304 else if (Name ==
"armv7em")
2305 DAL->AddJoinedArg(
nullptr, MArch,
"armv7em");
2306 else if (Name ==
"armv7k")
2307 DAL->AddJoinedArg(
nullptr, MArch,
"armv7k");
2308 else if (Name ==
"armv7m")
2309 DAL->AddJoinedArg(
nullptr, MArch,
"armv7m");
2310 else if (Name ==
"armv7s")
2311 DAL->AddJoinedArg(
nullptr, MArch,
"armv7s");
2318 ArgStringList &CmdArgs,
2319 bool ForceLinkBuiltinRT)
const {
2328 CompilerRT += Args.hasArg(options::OPT_fPIC) ?
"_pic" :
"_static";
2334 llvm::Triple::OSType OS;
2338 OS = llvm::Triple::MacOSX;
2341 OS = llvm::Triple::IOS;
2344 OS = llvm::Triple::TvOS;
2347 OS = llvm::Triple::WatchOS;
2355 llvm::opt::ArgStringList &CC1Args,
2359 if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
2360 options::OPT_fno_aligned_allocation) &&
2362 CC1Args.push_back(
"-faligned-alloc-unavailable");
2368 llvm::raw_string_ostream OS(Arg);
2369 OS <<
"-target-sdk-version=" <<
SDKInfo->getVersion();
2370 CC1Args.push_back(DriverArgs.MakeArgString(OS.str()));
2378 DerivedArgList *DAL =
2383 if (BoundArch.empty())
2389 AddDeploymentTarget(*DAL);
2397 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
2400 if (A->getOption().getID() != options::OPT_mkernel &&
2401 A->getOption().getID() != options::OPT_fapple_kext)
2403 assert(it != ie &&
"unexpected argument translation");
2405 assert(A->getOption().getID() == options::OPT_static &&
2406 "missing expected -static argument");
2412 if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
2414 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_stdlib_EQ),
2427 if (where != StringRef()) {
2428 getDriver().
Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
2433 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
2434 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
2435 options::OPT_fno_omit_frame_pointer,
false))
2436 getDriver().
Diag(clang::diag::warn_drv_unsupported_opt_for_target)
2437 <<
"-fomit-frame-pointer" << BoundArch;
2446 return getArch() == llvm::Triple::x86_64 ||
2448 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2453 if (
const char *S = ::getenv(
"RC_DEBUG_OPTIONS"))
2454 return S[0] !=
'\0';
2466 if (Triple.isWatchABI())
2467 return llvm::ExceptionHandling::DwarfCFI;
2469 return llvm::ExceptionHandling::SjLj;
2484 return (
getArch() == llvm::Triple::x86_64 ||
2485 getArch() == llvm::Triple::aarch64);
2494 ArgStringList &CmdArgs)
const {
2498 CmdArgs.push_back(
"-watchos_version_min");
2500 CmdArgs.push_back(
"-watchos_simulator_version_min");
2502 CmdArgs.push_back(
"-tvos_version_min");
2504 CmdArgs.push_back(
"-tvos_simulator_version_min");
2506 CmdArgs.push_back(
"-ios_simulator_version_min");
2508 CmdArgs.push_back(
"-iphoneos_version_min");
2511 CmdArgs.push_back(
"-macosx_version_min");
2514 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
2527 llvm_unreachable(
"macCatalyst isn't yet supported");
2533 llvm_unreachable(
"invalid platform");
2537 llvm::opt::ArgStringList &CmdArgs)
const {
2540 CmdArgs.push_back(
"-platform_version");
2543 PlatformName +=
"-simulator";
2544 CmdArgs.push_back(Args.MakeArgString(PlatformName));
2546 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
2548 VersionTuple SDKVersion =
SDKInfo->getVersion().withoutBuild();
2549 CmdArgs.push_back(Args.MakeArgString(SDKVersion.getAsString()));
2552 CmdArgs.push_back(
"0.0.0");
2557 ArgStringList &CmdArgs)
const {
2559 if (Args.hasArg(options::OPT_dynamiclib)) {
2567 CmdArgs.push_back(
"-ldylib1.o");
2570 CmdArgs.push_back(
"-ldylib1.o");
2572 CmdArgs.push_back(
"-ldylib1.10.5.o");
2575 if (Args.hasArg(options::OPT_bundle)) {
2576 if (!Args.hasArg(options::OPT_static)) {
2584 CmdArgs.push_back(
"-lbundle1.o");
2587 CmdArgs.push_back(
"-lbundle1.o");
2593 if (Args.hasArg(options::OPT_static) ||
2594 Args.hasArg(options::OPT_object) ||
2595 Args.hasArg(options::OPT_preload)) {
2596 CmdArgs.push_back(
"-lgcrt0.o");
2598 CmdArgs.push_back(
"-lgcrt1.o");
2608 CmdArgs.push_back(
"-no_new_main");
2610 getDriver().
Diag(diag::err_drv_clang_unsupported_opt_pg_darwin)
2614 if (Args.hasArg(options::OPT_static) ||
2615 Args.hasArg(options::OPT_object) ||
2616 Args.hasArg(options::OPT_preload)) {
2617 CmdArgs.push_back(
"-lcrt0.o");
2625 if (
getArch() == llvm::Triple::aarch64)
2628 CmdArgs.push_back(
"-lcrt1.o");
2630 CmdArgs.push_back(
"-lcrt1.3.1.o");
2633 CmdArgs.push_back(
"-lcrt1.o");
2635 CmdArgs.push_back(
"-lcrt1.10.5.o");
2637 CmdArgs.push_back(
"-lcrt1.10.6.o");
2648 const char *Str = Args.MakeArgString(
GetFilePath(
"crt3.o"));
2649 CmdArgs.push_back(Str);
2661 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
2663 Res |= SanitizerKind::Address;
2664 Res |= SanitizerKind::PointerCompare;
2665 Res |= SanitizerKind::PointerSubtract;
2666 Res |= SanitizerKind::Leak;
2667 Res |= SanitizerKind::Fuzzer;
2668 Res |= SanitizerKind::FuzzerNoLink;
2676 Res |= SanitizerKind::Vptr;
2680 Res |= SanitizerKind::Thread;
2683 Res |= SanitizerKind::Thread;
StringRef getSysRoot() const
Returns the sysroot path.
static bool GetReleaseVersion(StringRef Str, unsigned &Major, unsigned &Minor, unsigned &Micro, bool &HadExtra)
GetReleaseVersion - Parse (([0-9]+)(.
static const char * getPlatformName(Darwin::DarwinPlatformKind Platform, Darwin::DarwinEnvironmentKind Environment)
bool needsStatsRt() const
std::string GetTemporaryPath(StringRef Prefix, StringRef Suffix) const
GetTemporaryPath - Return the pathname of a temporary file to use as part of compilation; the file wi...
const char * getTypeTempSuffix(ID Id, bool CLMode=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type, or null if unspecified.
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
Defines types useful for describing an Objective-C runtime.
The base class of the type hierarchy.
bool embedBitcodeEnabled() const
constexpr XRayInstrMask Function
LTOKind getLTOMode() const
Get the specific kind of LTO being performed.
DiagnosticBuilder Diag(unsigned DiagID) const
void print(raw_ostream &OS) const
Print information about the detected CUDA installation.
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
bool needsUbsanRt() const
bool embedBitcodeMarkerOnly() const
std::string Dir
The path the driver executable was in, as invoked from the command line.
Action - Represent an abstract compilation step to perform.
The information about the darwin SDK that was used during this compilation.
static bool hasExportSymbolDirective(const ArgList &Args)
Check if the link command contains a symbol export directive.
types::ID getType() const
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
static bool shouldLinkerNotDedup(bool IsLinkerOnlyAction, const ArgList &Args)
Pass -no_deduplicate to ld64 under certain conditions:
'watchos' is a variant of iOS for Apple's watchOS.
Defines a function that returns the minimum OS versions supporting C++17's aligned allocation functio...
Expected< Optional< DarwinSDKInfo > > parseDarwinSDKInfo(llvm::vfs::FileSystem &VFS, StringRef SDKRootPath)
Parse the SDK information from the SDKSettings.json file.
bool requiresMinimalRuntime() const
ActionClass getKind() const
std::string GetTemporaryDirectory(StringRef Prefix) const
GetTemporaryDirectory - Return the pathname of a temporary directory to use as part of compilation; t...
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
llvm::StringRef getAsString(SyncScope S)
static void addExportedSymbol(ArgStringList &CmdArgs, const char *Symbol)
Add an export directive for Symbol to the link command.
static const char * ArmMachOArchNameCPU(StringRef CPU)
void addCommand(std::unique_ptr< Command > C)
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion)
Returns the most appropriate macOS target version for the current process.
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...
const llvm::opt::DerivedArgList & getArgs() const
static StringRef getXcodeDeveloperPath(StringRef PathIntoXcode)
Take a path that speculatively points into Xcode and return the XCODE/Contents/Developer path if it i...
constexpr XRayInstrMask None
static const char * ArmMachOArchName(StringRef Arch)
Dataflow Directional Tag Classes.
The basic abstraction for the target Objective-C runtime.
llvm::VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS)
std::string SysRoot
sysroot, if present
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
Compilation - A set of tasks to perform for a single driver invocation.
const Driver & getDriver() const
const llvm::opt::OptTable & getOpts() const
const char * addTempFile(const char *Name)
addTempFile - Add a file to remove on exit, and returns its argument.
bool needsSharedRt() const
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
static bool isObjCRuntimeLinked(const ArgList &Args)
Determine whether we are linking the ObjC runtime.
bool hasSubscripting() const
Does this runtime directly support the subscripting methods?
std::string ResourceDir
The path to the compiler resource directory.