21 #include "llvm/ADT/StringSwitch.h" 22 #include "llvm/Option/ArgList.h" 23 #include "llvm/Support/Path.h" 24 #include "llvm/Support/ScopedPrinter.h" 25 #include "llvm/Support/TargetParser.h" 31 using namespace clang;
47 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
48 .Cases(
"ppc",
"ppc601",
"ppc603",
"ppc604",
"ppc604e", llvm::Triple::ppc)
49 .Cases(
"ppc750",
"ppc7400",
"ppc7450",
"ppc970", llvm::Triple::ppc)
50 .Case(
"ppc64", llvm::Triple::ppc64)
51 .Cases(
"i386",
"i486",
"i486SX",
"i586",
"i686", llvm::Triple::x86)
52 .Cases(
"pentium",
"pentpro",
"pentIIm3",
"pentIIm5",
"pentium4",
54 .Cases(
"x86_64",
"x86_64h", llvm::Triple::x86_64)
56 .Cases(
"arm",
"armv4t",
"armv5",
"armv6",
"armv6m", llvm::Triple::arm)
57 .Cases(
"armv7",
"armv7em",
"armv7k",
"armv7m", llvm::Triple::arm)
58 .Cases(
"armv7s",
"xscale", llvm::Triple::arm)
59 .Case(
"arm64", llvm::Triple::aarch64)
60 .Case(
"r600", llvm::Triple::r600)
61 .Case(
"amdgcn", llvm::Triple::amdgcn)
62 .Case(
"nvptx", llvm::Triple::nvptx)
63 .Case(
"nvptx64", llvm::Triple::nvptx64)
64 .Case(
"amdil", llvm::Triple::amdil)
65 .Case(
"spir", llvm::Triple::spir)
66 .Default(llvm::Triple::UnknownArch);
71 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseArch(Str);
76 else if (ArchKind == llvm::ARM::ArchKind::ARMV6M ||
77 ArchKind == llvm::ARM::ArchKind::ARMV7M ||
78 ArchKind == llvm::ARM::ArchKind::ARMV7EM) {
79 T.setOS(llvm::Triple::UnknownOS);
80 T.setObjectFormat(llvm::Triple::MachO);
88 const char *LinkingOutput)
const {
89 ArgStringList CmdArgs;
91 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
95 const Action *SourceAction = &JA;
97 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
98 SourceAction = SourceAction->
getInputs()[0];
106 if (Args.hasArg(options::OPT_fno_integrated_as)) {
107 const llvm::Triple &T(getToolChain().getTriple());
108 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
109 CmdArgs.push_back(
"-Q");
113 if (SourceAction->
getType() == types::TY_Asm ||
114 SourceAction->
getType() == types::TY_PP_Asm) {
115 if (Args.hasArg(options::OPT_gstabs))
116 CmdArgs.push_back(
"--gstabs");
117 else if (Args.hasArg(options::OPT_g_Group))
118 CmdArgs.push_back(
"-g");
122 AddMachOArch(Args, CmdArgs);
125 if (getToolChain().getArch() == llvm::Triple::x86 ||
126 getToolChain().getArch() == llvm::Triple::x86_64 ||
127 Args.hasArg(options::OPT_force__cpusubtype__ALL))
128 CmdArgs.push_back(
"-force_cpusubtype_ALL");
130 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
131 (((Args.hasArg(options::OPT_mkernel) ||
132 Args.hasArg(options::OPT_fapple_kext)) &&
133 getMachOToolChain().isKernelStatic()) ||
134 Args.hasArg(options::OPT_static)))
135 CmdArgs.push_back(
"-static");
137 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
139 assert(Output.
isFilename() &&
"Unexpected lipo output.");
140 CmdArgs.push_back(
"-o");
143 assert(Input.isFilename() &&
"Invalid input.");
144 CmdArgs.push_back(Input.getFilename());
148 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
149 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
152 void darwin::MachOTool::anchor() {}
155 ArgStringList &CmdArgs)
const {
156 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
159 CmdArgs.push_back(
"-arch");
160 CmdArgs.push_back(Args.MakeArgString(ArchName));
163 if (ArchName ==
"arm")
164 CmdArgs.push_back(
"-force_cpusubtype_ALL");
167 bool darwin::Linker::NeedsTempPath(
const InputInfoList &Inputs)
const {
171 for (
const auto &Input : Inputs)
172 if (Input.getType() != types::TY_Object)
186 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
187 if (A->getOption().matches(options::OPT_O0))
189 if (A->getOption().matches(options::OPT_O))
190 return llvm::StringSwitch<bool>(A->getValue())
196 if (!IsLinkerOnlyAction)
201 void darwin::Linker::AddLinkArgs(
Compilation &C,
const ArgList &Args,
202 ArgStringList &CmdArgs,
204 const Driver &D = getToolChain().getDriver();
207 unsigned Version[5] = {0, 0, 0, 0, 0};
208 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
210 D.
Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
215 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
216 CmdArgs.push_back(
"-demangle");
218 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
219 CmdArgs.push_back(
"-export_dynamic");
223 if (Args.hasFlag(options::OPT_fapplication_extension,
224 options::OPT_fno_application_extension,
false))
225 CmdArgs.push_back(
"-application_extension");
231 if (Version[0] >= 116 && NeedsTempPath(Inputs)) {
232 const char *TmpPath = C.
getArgs().MakeArgString(
235 CmdArgs.push_back(
"-object_path_lto");
236 CmdArgs.push_back(TmpPath);
247 if (Version[0] >= 133) {
249 StringRef
P = llvm::sys::path::parent_path(D.
Dir);
251 llvm::sys::path::append(LibLTOPath,
"lib");
252 llvm::sys::path::append(LibLTOPath,
"libLTO.dylib");
253 CmdArgs.push_back(
"-lto_library");
254 CmdArgs.push_back(C.
getArgs().MakeArgString(LibLTOPath));
259 CmdArgs.push_back(
"-no_deduplicate");
262 Args.AddAllArgs(CmdArgs, options::OPT_static);
263 if (!Args.hasArg(options::OPT_static))
264 CmdArgs.push_back(
"-dynamic");
265 if (Args.hasArg(options::OPT_fgnu_runtime)) {
270 if (!Args.hasArg(options::OPT_dynamiclib)) {
271 AddMachOArch(Args, CmdArgs);
273 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
275 Args.AddLastArg(CmdArgs, options::OPT_bundle);
276 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
277 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
280 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
281 (A = Args.getLastArg(options::OPT_current__version)) ||
282 (A = Args.getLastArg(options::OPT_install__name)))
283 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
286 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
287 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
288 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
290 CmdArgs.push_back(
"-dylib");
293 if ((A = Args.getLastArg(options::OPT_bundle)) ||
294 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
295 (A = Args.getLastArg(options::OPT_client__name)) ||
296 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
297 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
298 (A = Args.getLastArg(options::OPT_private__bundle)))
299 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
302 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
303 "-dylib_compatibility_version");
304 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
305 "-dylib_current_version");
307 AddMachOArch(Args, CmdArgs);
309 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
310 "-dylib_install_name");
313 Args.AddLastArg(CmdArgs, options::OPT_all__load);
314 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
315 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
317 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
318 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
319 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
320 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
321 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
322 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
323 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
324 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
325 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
326 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
327 Args.AddAllArgs(CmdArgs, options::OPT_init);
332 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
333 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
334 Args.AddLastArg(CmdArgs, options::OPT_single__module);
335 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
336 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
339 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
340 options::OPT_fno_pie, options::OPT_fno_PIE)) {
341 if (A->getOption().matches(options::OPT_fpie) ||
342 A->getOption().matches(options::OPT_fPIE))
343 CmdArgs.push_back(
"-pie");
345 CmdArgs.push_back(
"-no_pie");
352 CmdArgs.push_back(
"-bitcode_bundle");
354 CmdArgs.push_back(
"-bitcode_process_mode");
355 CmdArgs.push_back(
"marker");
358 D.
Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
361 Args.AddLastArg(CmdArgs, options::OPT_prebind);
362 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
363 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
364 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
365 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
366 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
367 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
368 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
369 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
370 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
371 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
372 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
373 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
374 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
375 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
376 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
382 CmdArgs.push_back(
"-syslibroot");
383 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
384 }
else if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
385 CmdArgs.push_back(
"-syslibroot");
386 CmdArgs.push_back(A->getValue());
389 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
390 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
391 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
392 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
393 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
394 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
395 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
396 Args.AddAllArgs(CmdArgs, options::OPT_y);
397 Args.AddLastArg(CmdArgs, options::OPT_w);
398 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
399 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
400 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
401 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
402 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
403 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
404 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
405 Args.AddLastArg(CmdArgs, options::OPT_whyload);
406 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
407 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
408 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
409 Args.AddLastArg(CmdArgs, options::OPT_Mach);
415 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
418 return Args.hasArg(options::OPT_fobjc_link_runtime);
425 const char *LinkingOutput)
const {
426 assert(Output.
getType() == types::TY_Image &&
"Invalid linker output type.");
432 llvm::opt::ArgStringList InputFileList;
437 ArgStringList CmdArgs;
440 if (Args.hasArg(options::OPT_ccc_arcmt_check,
441 options::OPT_ccc_arcmt_migrate)) {
442 for (
const auto &Arg : Args)
445 Args.MakeArgString(getToolChain().GetProgramPath(
"touch"));
447 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, None));
453 AddLinkArgs(C, Args, CmdArgs, Inputs);
457 if (Args.hasFlag(options::OPT_fsave_optimization_record,
458 options::OPT_fno_save_optimization_record,
false)) {
459 CmdArgs.push_back(
"-mllvm");
460 CmdArgs.push_back(
"-lto-pass-remarks-output");
461 CmdArgs.push_back(
"-mllvm");
466 CmdArgs.push_back(Args.MakeArgString(F));
469 CmdArgs.push_back(
"-mllvm");
470 CmdArgs.push_back(
"-lto-pass-remarks-with-hotness");
473 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
474 CmdArgs.push_back(
"-mllvm");
476 std::string(
"-lto-pass-remarks-hotness-threshold=") + A->getValue();
477 CmdArgs.push_back(Args.MakeArgString(Opt));
483 if (Args.hasFlag(options::OPT_moutline, options::OPT_mno_outline,
false)) {
484 if (getMachOToolChain().getMachOArchName(Args) ==
"arm64") {
485 CmdArgs.push_back(
"-mllvm");
486 CmdArgs.push_back(
"-enable-machine-outliner");
489 CmdArgs.push_back(
"-mllvm");
490 CmdArgs.push_back(
"-enable-linkonceodr-outlining");
496 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
497 options::OPT_Z_Flag, options::OPT_u_Group,
498 options::OPT_e, options::OPT_r});
503 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
504 CmdArgs.push_back(
"-ObjC");
506 CmdArgs.push_back(
"-o");
509 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
510 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
515 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
516 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
517 "libclang_rt.safestack_osx.a",
521 Args.AddAllArgs(CmdArgs, options::OPT_L);
526 for (
const auto &II : Inputs) {
527 if (!II.isFilename()) {
532 if (InputFileList.size() > 0)
538 InputFileList.push_back(II.getFilename());
541 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
545 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
547 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
549 CmdArgs.push_back(
"-framework");
550 CmdArgs.push_back(
"Foundation");
552 CmdArgs.push_back(
"-lobjc");
556 CmdArgs.push_back(
"-arch_multiple");
557 CmdArgs.push_back(
"-final_output");
558 CmdArgs.push_back(LinkingOutput);
561 if (Args.hasArg(options::OPT_fnested_functions))
562 CmdArgs.push_back(
"-allow_stack_execute");
564 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
566 if (
unsigned Parallelism =
568 CmdArgs.push_back(
"-mllvm");
569 CmdArgs.push_back(Args.MakeArgString(
"-threads=" + Twine(Parallelism)));
572 if (getToolChain().ShouldLinkCXXStdlib(Args))
573 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
574 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
578 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
581 Args.ClaimAllArgs(options::OPT_pthread);
582 Args.ClaimAllArgs(options::OPT_pthreads);
585 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
589 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
590 Args.AddAllArgs(CmdArgs, options::OPT_F);
593 for (
const Arg *A : Args.filtered(options::OPT_iframework))
594 CmdArgs.push_back(Args.MakeArgString(std::string(
"-F") + A->getValue()));
596 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
597 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
598 if (A->getValue() == StringRef(
"Accelerate")) {
599 CmdArgs.push_back(
"-framework");
600 CmdArgs.push_back(
"Accelerate");
605 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
606 std::unique_ptr<Command>
Cmd =
607 llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs);
608 Cmd->setInputFileList(std::move(InputFileList));
616 const char *LinkingOutput)
const {
617 ArgStringList CmdArgs;
619 CmdArgs.push_back(
"-create");
620 assert(Output.
isFilename() &&
"Unexpected lipo output.");
622 CmdArgs.push_back(
"-output");
625 for (
const auto &II : Inputs) {
626 assert(II.isFilename() &&
"Unexpected lipo input.");
627 CmdArgs.push_back(II.getFilename());
630 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"lipo"));
631 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
638 const char *LinkingOutput)
const {
639 ArgStringList CmdArgs;
641 CmdArgs.push_back(
"-o");
644 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
646 assert(Input.isFilename() &&
"Unexpected dsymutil input.");
647 CmdArgs.push_back(Input.getFilename());
650 Args.MakeArgString(getToolChain().GetProgramPath(
"dsymutil"));
651 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
658 const char *LinkingOutput)
const {
659 ArgStringList CmdArgs;
660 CmdArgs.push_back(
"--verify");
661 CmdArgs.push_back(
"--debug-info");
662 CmdArgs.push_back(
"--eh-frame");
663 CmdArgs.push_back(
"--quiet");
665 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
667 assert(Input.isFilename() &&
"Unexpected verify input");
670 CmdArgs.push_back(Input.getFilename());
673 Args.MakeArgString(getToolChain().GetProgramPath(
"dwarfdump"));
674 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
677 MachO::MachO(
const Driver &D,
const llvm::Triple &Triple,
const ArgList &Args)
687 :
MachO(D, Triple, Args), TargetInitialized(
false),
688 CudaInstallation(D, Triple, Args) {}
694 if (Ty == types::TY_PP_Asm)
695 return types::TY_Asm;
736 ArgStringList &CC1Args)
const {
745 return llvm::StringSwitch<const char *>(Arch)
746 .Case(
"armv6k",
"armv6")
747 .Case(
"armv6m",
"armv6m")
748 .Case(
"armv5tej",
"armv5")
749 .Case(
"xscale",
"xscale")
750 .Case(
"armv4t",
"armv4t")
751 .Case(
"armv7",
"armv7")
752 .Cases(
"armv7a",
"armv7-a",
"armv7")
753 .Cases(
"armv7r",
"armv7-r",
"armv7")
754 .Cases(
"armv7em",
"armv7e-m",
"armv7em")
755 .Cases(
"armv7k",
"armv7-k",
"armv7k")
756 .Cases(
"armv7m",
"armv7-m",
"armv7m")
757 .Cases(
"armv7s",
"armv7-s",
"armv7s")
762 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
763 if (ArchKind == llvm::ARM::ArchKind::INVALID)
765 StringRef Arch = llvm::ARM::getArchName(ArchKind);
769 if (Arch.startswith(
"armv5"))
770 Arch = Arch.substr(0, 5);
772 else if (Arch.startswith(
"armv6") && !Arch.endswith(
"6m"))
773 Arch = Arch.substr(0, 5);
775 else if (Arch.endswith(
"v7a"))
776 Arch = Arch.substr(0, 5);
785 case llvm::Triple::aarch64:
788 case llvm::Triple::thumb:
789 case llvm::Triple::arm:
790 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
794 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
813 return Triple.getTriple();
825 Triple.setOSName(Str);
827 return Triple.getTriple();
839 return Dsymutil.get();
843 return VerifyDebug.get();
857 :
Darwin(D, Triple, Args) {}
864 CC1Args.push_back(
"-Wdeprecated-objc-isa-usage");
865 CC1Args.push_back(
"-Werror=deprecated-objc-isa-usage");
870 CC1Args.push_back(
"-Werror=implicit-function-declaration");
875 ArgStringList &CmdArgs)
const {
886 CmdArgs.push_back(
"-force_load");
888 llvm::sys::path::remove_filename(P);
889 llvm::sys::path::remove_filename(P);
890 llvm::sys::path::append(P,
"lib",
"arc",
"libarclite_");
893 P +=
"watchsimulator";
897 P +=
"appletvsimulator";
901 P +=
"iphonesimulator";
908 CmdArgs.push_back(Args.MakeArgString(P));
920 StringRef DarwinLibName,
923 llvm::sys::path::append(
924 Dir,
"lib", (Opts &
RLO_IsEmbedded) ?
"macho_embedded" :
"darwin");
927 llvm::sys::path::append(P, DarwinLibName);
933 const char *LibArg = Args.MakeArgString(P);
935 CmdArgs.insert(CmdArgs.begin(), LibArg);
937 CmdArgs.push_back(LibArg);
945 assert(DarwinLibName.endswith(
".dylib") &&
"must be a dynamic library");
949 CmdArgs.push_back(
"-rpath");
950 CmdArgs.push_back(
"@executable_path");
954 CmdArgs.push_back(
"-rpath");
955 CmdArgs.push_back(Args.MakeArgString(Dir));
961 case DarwinPlatformKind::MacOS:
963 case DarwinPlatformKind::IPhoneOS:
965 case DarwinPlatformKind::TvOS:
967 case DarwinPlatformKind::WatchOS:
970 llvm_unreachable(
"Unsupported platform");
975 llvm::sys::path::const_iterator SDKDir;
976 auto BeginSDK = llvm::sys::path::begin(isysroot);
977 auto EndSDK = llvm::sys::path::end(isysroot);
978 for (
auto IT = BeginSDK; IT != EndSDK; ++IT) {
980 if (SDK.endswith(
".sdk"))
981 return SDK.slice(0, SDK.size() - 4);
988 case DarwinPlatformKind::MacOS:
990 case DarwinPlatformKind::IPhoneOS:
992 case DarwinPlatformKind::TvOS:
994 case DarwinPlatformKind::WatchOS:
997 llvm_unreachable(
"Unsupported platform");
1002 for (Arg *A : Args) {
1003 if (A->getOption().matches(options::OPT_exported__symbols__list))
1005 if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
1006 !A->getOption().matches(options::OPT_Xlinker))
1008 if (A->containsValue(
"-exported_symbols_list") ||
1009 A->containsValue(
"-exported_symbol"))
1017 CmdArgs.push_back(
"-exported_symbol");
1018 CmdArgs.push_back(Symbol);
1022 ArgStringList &CmdArgs)
const {
1040 void DarwinClang::AddLinkSanitizerLibArgs(
const ArgList &Args,
1041 ArgStringList &CmdArgs,
1042 StringRef Sanitizer,
1043 bool Shared)
const {
1046 (Twine(
"libclang_rt.") + Sanitizer +
"_" +
1048 (Shared ?
"_dynamic.dylib" :
".a"))
1054 const ArgList &Args)
const {
1055 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1056 StringRef
Value = A->getValue();
1057 if (Value !=
"compiler-rt")
1058 getDriver().
Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1059 << Value <<
"darwin";
1066 ArgStringList &CmdArgs)
const {
1072 if (Args.hasArg(options::OPT_static) ||
1073 Args.hasArg(options::OPT_fapple_kext) ||
1074 Args.hasArg(options::OPT_mkernel))
1080 if (
const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1081 getDriver().
Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1087 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan");
1089 AddLinkSanitizerLibArgs(Args, CmdArgs,
"lsan");
1091 AddLinkSanitizerLibArgs(Args, CmdArgs,
1096 AddLinkSanitizerLibArgs(Args, CmdArgs,
"tsan");
1097 if (Sanitize.
needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1098 AddLinkSanitizerLibArgs(Args, CmdArgs,
"fuzzer",
false);
1106 (Twine(
"libclang_rt.stats_client_") + OS +
".a").str(),
1108 AddLinkSanitizerLibArgs(Args, CmdArgs,
"stats");
1111 AddLinkSanitizerLibArgs(Args, CmdArgs,
"esan");
1115 CmdArgs.push_back(
"-lSystem");
1130 CmdArgs.push_back(
"-lgcc_s.1");
1139 CmdArgs.push_back(
"-lgcc_s.10.4");
1141 CmdArgs.push_back(
"-lgcc_s.10.5");
1171 unsigned Major, Minor, Micro;
1172 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1173 if (!SystemTriple.isMacOSX())
1174 return MacOSSDKVersion;
1175 SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1176 VersionTuple SystemVersion(Major, Minor, Micro);
1180 return MacOSSDKVersion;
1181 VersionTuple SDKVersion(Major, Minor, Micro);
1182 if (SDKVersion > SystemVersion)
1183 return SystemVersion.getAsString();
1184 return MacOSSDKVersion;
1190 struct DarwinPlatform {
1197 DeploymentTargetEnv,
1213 InferSimulatorFromArch =
false;
1216 StringRef getOSVersion()
const {
1217 if (Kind == OSVersionArg)
1218 return Argument->getValue();
1222 void setOSVersion(StringRef S) {
1223 assert(Kind == TargetArg &&
"Unexpected kind!");
1227 bool hasOSVersion()
const {
return HasOSVersion; }
1230 bool isExplicitlySpecified()
const {
return Kind <= DeploymentTargetEnv; }
1233 bool canInferSimulatorFromArch()
const {
return InferSimulatorFromArch; }
1236 void addOSVersionMinArgument(DerivedArgList &Args,
const OptTable &Opts) {
1239 assert(Kind != TargetArg && Kind != OSVersionArg &&
"Invalid kind");
1242 case DarwinPlatformKind::MacOS:
1243 Opt = options::OPT_mmacosx_version_min_EQ;
1245 case DarwinPlatformKind::IPhoneOS:
1246 Opt = options::OPT_miphoneos_version_min_EQ;
1248 case DarwinPlatformKind::TvOS:
1249 Opt = options::OPT_mtvos_version_min_EQ;
1251 case DarwinPlatformKind::WatchOS:
1252 Opt = options::OPT_mwatchos_version_min_EQ;
1255 Argument = Args.MakeJoinedArg(
nullptr, Opts.getOption(Opt), OSVersion);
1256 Args.append(Argument);
1261 std::string
getAsString(DerivedArgList &Args,
const OptTable &Opts) {
1265 case InferredFromSDK:
1266 case InferredFromArch:
1267 assert(Argument &&
"OS version argument not yet inferred");
1268 return Argument->getAsString(Args);
1269 case DeploymentTargetEnv:
1270 return (llvm::Twine(EnvVarName) +
"=" + OSVersion).str();
1272 llvm_unreachable(
"Unsupported Darwin Source Kind");
1275 static DarwinPlatform createFromTarget(
const llvm::Triple &TT,
1276 StringRef OSVersion, Arg *A) {
1277 DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
1279 switch (TT.getEnvironment()) {
1280 case llvm::Triple::Simulator:
1281 Result.Environment = DarwinEnvironmentKind::Simulator;
1286 unsigned Major, Minor, Micro;
1287 TT.getOSVersion(Major, Minor, Micro);
1289 Result.HasOSVersion =
false;
1294 return DarwinPlatform(OSVersionArg, Platform, A);
1297 StringRef EnvVarName,
1299 DarwinPlatform Result(DeploymentTargetEnv, Platform, Value);
1300 Result.EnvVarName = EnvVarName;
1305 bool IsSimulator =
false) {
1306 DarwinPlatform Result(InferredFromSDK, Platform, Value);
1308 Result.Environment = DarwinEnvironmentKind::Simulator;
1309 Result.InferSimulatorFromArch =
false;
1312 static DarwinPlatform createFromArch(llvm::Triple::OSType OS,
1314 return DarwinPlatform(InferredFromArch, getPlatformFromOS(OS), Value);
1319 :
Kind(Kind), Platform(Platform), Argument(Argument) {}
1321 Arg *Argument =
nullptr)
1322 :
Kind(Kind), Platform(Platform), OSVersion(Value), Argument(Argument) {}
1326 case llvm::Triple::Darwin:
1327 case llvm::Triple::MacOSX:
1328 return DarwinPlatformKind::MacOS;
1329 case llvm::Triple::IOS:
1330 return DarwinPlatformKind::IPhoneOS;
1331 case llvm::Triple::TvOS:
1332 return DarwinPlatformKind::TvOS;
1333 case llvm::Triple::WatchOS:
1334 return DarwinPlatformKind::WatchOS;
1336 llvm_unreachable(
"Unable to infer Darwin variant");
1343 std::string OSVersion;
1344 bool HasOSVersion =
true, InferSimulatorFromArch =
true;
1346 StringRef EnvVarName;
1352 getDeploymentTargetFromOSVersionArg(DerivedArgList &Args,
1353 const Driver &TheDriver) {
1354 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
1355 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ,
1356 options::OPT_mios_simulator_version_min_EQ);
1358 Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1359 options::OPT_mtvos_simulator_version_min_EQ);
1360 Arg *WatchOSVersion =
1361 Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1362 options::OPT_mwatchos_simulator_version_min_EQ);
1364 if (iOSVersion || TvOSVersion || WatchOSVersion) {
1365 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1366 << OSXVersion->getAsString(Args)
1367 << (iOSVersion ? iOSVersion
1368 : TvOSVersion ? TvOSVersion : WatchOSVersion)
1371 return DarwinPlatform::createOSVersionArg(
Darwin::MacOS, OSXVersion);
1372 }
else if (iOSVersion) {
1373 if (TvOSVersion || WatchOSVersion) {
1374 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1375 << iOSVersion->getAsString(Args)
1376 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->
getAsString(Args);
1379 }
else if (TvOSVersion) {
1380 if (WatchOSVersion) {
1381 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1382 << TvOSVersion->getAsString(Args)
1383 << WatchOSVersion->getAsString(Args);
1385 return DarwinPlatform::createOSVersionArg(
Darwin::TvOS, TvOSVersion);
1386 }
else if (WatchOSVersion)
1387 return DarwinPlatform::createOSVersionArg(
Darwin::WatchOS, WatchOSVersion);
1394 getDeploymentTargetFromEnvironmentVariables(
const Driver &TheDriver,
1395 const llvm::Triple &Triple) {
1397 const char *EnvVars[] = {
1398 "MACOSX_DEPLOYMENT_TARGET",
1399 "IPHONEOS_DEPLOYMENT_TARGET",
1400 "TVOS_DEPLOYMENT_TARGET",
1401 "WATCHOS_DEPLOYMENT_TARGET",
1404 "Missing platform");
1405 for (
const auto &I : llvm::enumerate(llvm::makeArrayRef(EnvVars))) {
1406 if (
char *Env = ::getenv(I.value()))
1407 Targets[I.index()] = Env;
1413 TheDriver.
Diag(diag::err_drv_conflicting_deployment_targets)
1414 <<
"WATCHOS_DEPLOYMENT_TARGET" 1416 :
"TVOS_DEPLOYMENT_TARGET");
1421 TheDriver.
Diag(diag::err_drv_conflicting_deployment_targets)
1422 <<
"TVOS_DEPLOYMENT_TARGET" 1423 <<
"IPHONEOS_DEPLOYMENT_TARGET";
1431 if (Triple.getArch() == llvm::Triple::arm ||
1432 Triple.getArch() == llvm::Triple::aarch64 ||
1433 Triple.getArch() == llvm::Triple::thumb)
1440 for (
const auto &
Target : llvm::enumerate(llvm::makeArrayRef(Targets))) {
1441 if (!
Target.value().empty())
1442 return DarwinPlatform::createDeploymentTargetEnv(
1452 const Arg *A = Args.getLastArg(options::OPT_isysroot);
1455 StringRef isysroot = A->getValue();
1461 size_t StartVer = SDK.find_first_of(
"0123456789");
1462 size_t EndVer = SDK.find_last_of(
"0123456789");
1463 if (StartVer != StringRef::npos && EndVer > StartVer) {
1464 StringRef Version = SDK.slice(StartVer, EndVer + 1);
1465 if (SDK.startswith(
"iPhoneOS") || SDK.startswith(
"iPhoneSimulator"))
1466 return DarwinPlatform::createFromSDK(
1468 SDK.startswith(
"iPhoneSimulator"));
1469 else if (SDK.startswith(
"MacOSX"))
1472 else if (SDK.startswith(
"WatchOS") || SDK.startswith(
"WatchSimulator"))
1473 return DarwinPlatform::createFromSDK(
1475 SDK.startswith(
"WatchSimulator"));
1476 else if (SDK.startswith(
"AppleTVOS") || SDK.startswith(
"AppleTVSimulator"))
1477 return DarwinPlatform::createFromSDK(
1479 SDK.startswith(
"AppleTVSimulator"));
1484 std::string getOSVersion(llvm::Triple::OSType OS,
const llvm::Triple &Triple,
1485 const Driver &TheDriver) {
1486 unsigned Major, Minor, Micro;
1487 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1489 case llvm::Triple::Darwin:
1490 case llvm::Triple::MacOSX:
1493 if (Triple.isMacOSX() && SystemTriple.isMacOSX() &&
1494 !Triple.getOSMajorVersion())
1495 SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1496 else if (!Triple.getMacOSXVersion(Major, Minor, Micro))
1497 TheDriver.
Diag(diag::err_drv_invalid_darwin_version)
1498 << Triple.getOSName();
1500 case llvm::Triple::IOS:
1501 Triple.getiOSVersion(Major, Minor, Micro);
1503 case llvm::Triple::TvOS:
1504 Triple.getOSVersion(Major, Minor, Micro);
1506 case llvm::Triple::WatchOS:
1507 Triple.getWatchOSVersion(Major, Minor, Micro);
1510 llvm_unreachable(
"Unexpected OS type");
1514 std::string OSVersion;
1515 llvm::raw_string_ostream(OSVersion) << Major <<
'.' << Minor <<
'.' << Micro;
1521 inferDeploymentTargetFromArch(DerivedArgList &Args,
const Darwin &Toolchain,
1522 const llvm::Triple &Triple,
1523 const Driver &TheDriver) {
1524 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
1527 if (MachOArchName ==
"armv7" || MachOArchName ==
"armv7s" ||
1528 MachOArchName ==
"arm64")
1529 OSTy = llvm::Triple::IOS;
1530 else if (MachOArchName ==
"armv7k")
1531 OSTy = llvm::Triple::WatchOS;
1532 else if (MachOArchName !=
"armv6m" && MachOArchName !=
"armv7m" &&
1533 MachOArchName !=
"armv7em")
1534 OSTy = llvm::Triple::MacOSX;
1536 if (OSTy == llvm::Triple::UnknownOS)
1538 return DarwinPlatform::createFromArch(OSTy,
1539 getOSVersion(OSTy, Triple, TheDriver));
1544 DerivedArgList &Args,
const llvm::Triple &Triple,
const Driver &TheDriver) {
1545 if (!Args.hasArg(options::OPT_target))
1547 if (Triple.getOS() == llvm::Triple::Darwin ||
1548 Triple.getOS() == llvm::Triple::UnknownOS)
1550 std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
1551 return DarwinPlatform::createFromTarget(Triple, OSVersion,
1552 Args.getLastArg(options::OPT_target));
1557 void Darwin::AddDeploymentTarget(DerivedArgList &Args)
const {
1563 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1566 getDriver().
Diag(clang::diag::warn_missing_sysroot) << A->getValue();
1568 if (
char *env = ::getenv(
"SDKROOT")) {
1571 if (llvm::sys::path::is_absolute(env) &&
getVFS().exists(env) &&
1572 StringRef(env) !=
"/") {
1573 Args.append(Args.MakeSeparateArg(
1574 nullptr, Opts.getOption(options::OPT_isysroot), env));
1584 getDeploymentTargetFromOSVersionArg(Args,
getDriver());
1585 if (OSVersionArgTarget) {
1586 unsigned TargetMajor, TargetMinor, TargetMicro;
1588 unsigned ArgMajor, ArgMinor, ArgMicro;
1590 if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
1592 TargetMinor, TargetMicro, TargetExtra) &&
1594 ArgMajor, ArgMinor, ArgMicro, ArgExtra) &&
1595 (VersionTuple(TargetMajor, TargetMinor, TargetMicro) !=
1596 VersionTuple(ArgMajor, ArgMinor, ArgMicro) ||
1597 TargetExtra != ArgExtra))) {
1600 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
1601 !OSTarget->hasOSVersion()) {
1602 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
1606 std::string OSVersionArg =
1607 OSVersionArgTarget->getAsString(Args, Opts);
1608 std::string TargetArg = OSTarget->getAsString(Args, Opts);
1609 getDriver().
Diag(clang::diag::warn_drv_overriding_flag_option)
1610 << OSVersionArg << TargetArg;
1616 OSTarget = getDeploymentTargetFromOSVersionArg(Args,
getDriver());
1626 OSTarget->setEnvironment(SDKTarget->getEnvironment());
1633 OSTarget = inferDeploymentTargetFromSDK(Args);
1641 assert(OSTarget &&
"Unable to infer Darwin variant");
1642 OSTarget->addOSVersionMinArgument(Args, Opts);
1645 unsigned Major, Minor, Micro;
1648 if (Platform ==
MacOS) {
1651 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
1653 << OSTarget->getAsString(Args, Opts);
1657 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1659 << OSTarget->getAsString(Args, Opts);
1663 if (
getTriple().isArch32Bit() && Major >= 11) {
1665 if (OSTarget->isExplicitlySpecified()) {
1667 << OSTarget->getAsString(Args, Opts);
1675 }
else if (Platform ==
TvOS) {
1678 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1680 << OSTarget->getAsString(Args, Opts);
1681 }
else if (Platform ==
WatchOS) {
1684 HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
1686 << OSTarget->getAsString(Args, Opts);
1688 llvm_unreachable(
"unknown kind of Darwin platform");
1693 OSTarget->canInferSimulatorFromArch() &&
1694 (
getTriple().getArch() == llvm::Triple::x86 ||
1695 getTriple().getArch() == llvm::Triple::x86_64))
1698 setTarget(Platform, Environment, Major, Minor, Micro);
1700 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1702 if (SDK.size() > 0) {
1703 size_t StartVer = SDK.find_first_of(
"0123456789");
1704 StringRef SDKName = SDK.slice(0, StartVer);
1713 ArgStringList &CmdArgs)
const {
1718 CmdArgs.push_back(
"-lc++");
1728 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1730 llvm::sys::path::append(
P,
"usr",
"lib",
"libstdc++.dylib");
1733 llvm::sys::path::remove_filename(
P);
1734 llvm::sys::path::append(
P,
"libstdc++.6.dylib");
1736 CmdArgs.push_back(Args.MakeArgString(
P));
1747 CmdArgs.push_back(
"/usr/lib/libstdc++.6.dylib");
1752 CmdArgs.push_back(
"-lstdc++");
1758 ArgStringList &CmdArgs)
const {
1764 llvm::sys::path::append(P,
"lib",
"darwin");
1768 llvm::sys::path::append(P,
"libclang_rt.cc_kext_watchos.a");
1770 llvm::sys::path::append(P,
"libclang_rt.cc_kext_tvos.a");
1772 llvm::sys::path::append(P,
"libclang_rt.cc_kext_ios.a");
1774 llvm::sys::path::append(P,
"libclang_rt.cc_kext.a");
1780 CmdArgs.push_back(Args.MakeArgString(P));
1784 StringRef BoundArch,
1786 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1796 for (Arg *A : Args) {
1797 if (A->getOption().matches(options::OPT_Xarch__)) {
1800 llvm::Triple::ArchType XarchArch =
1802 if (!(XarchArch ==
getArch() ||
1803 (!BoundArch.empty() &&
1808 Arg *OriginalArg = A;
1809 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1810 unsigned Prev = Index;
1811 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1821 if (!XarchArg || Index > Prev + 1) {
1822 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1823 << A->getAsString(Args);
1826 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
1827 << A->getAsString(Args);
1831 XarchArg->setBaseArg(A);
1833 A = XarchArg.release();
1834 DAL->AddSynthesizedArg(A);
1841 for (
const char *
Value : A->getValues()) {
1842 DAL->AddSeparateArg(
1843 OriginalArg, Opts.getOption(options::OPT_Zlinker_input),
Value);
1857 case options::OPT_mkernel:
1858 case options::OPT_fapple_kext:
1860 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
1863 case options::OPT_dependency_file:
1864 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
1867 case options::OPT_gfull:
1868 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1870 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
1873 case options::OPT_gused:
1874 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1876 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
1879 case options::OPT_shared:
1880 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
1883 case options::OPT_fconstant_cfstrings:
1884 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
1887 case options::OPT_fno_constant_cfstrings:
1888 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
1891 case options::OPT_Wnonportable_cfstrings:
1893 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
1896 case options::OPT_Wno_nonportable_cfstrings:
1898 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
1901 case options::OPT_fpascal_strings:
1902 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
1905 case options::OPT_fno_pascal_strings:
1906 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
1911 if (
getTriple().getArch() == llvm::Triple::x86 ||
1912 getTriple().getArch() == llvm::Triple::x86_64)
1913 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
1914 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_mtune_EQ),
1919 if (!BoundArch.empty()) {
1920 StringRef Name = BoundArch;
1921 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
1922 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
1928 else if (Name ==
"ppc601")
1929 DAL->AddJoinedArg(
nullptr, MCpu,
"601");
1930 else if (Name ==
"ppc603")
1931 DAL->AddJoinedArg(
nullptr, MCpu,
"603");
1932 else if (Name ==
"ppc604")
1933 DAL->AddJoinedArg(
nullptr, MCpu,
"604");
1934 else if (Name ==
"ppc604e")
1935 DAL->AddJoinedArg(
nullptr, MCpu,
"604e");
1936 else if (Name ==
"ppc750")
1937 DAL->AddJoinedArg(
nullptr, MCpu,
"750");
1938 else if (Name ==
"ppc7400")
1939 DAL->AddJoinedArg(
nullptr, MCpu,
"7400");
1940 else if (Name ==
"ppc7450")
1941 DAL->AddJoinedArg(
nullptr, MCpu,
"7450");
1942 else if (Name ==
"ppc970")
1943 DAL->AddJoinedArg(
nullptr, MCpu,
"970");
1945 else if (Name ==
"ppc64" || Name ==
"ppc64le")
1946 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
1948 else if (Name ==
"i386")
1950 else if (Name ==
"i486")
1951 DAL->AddJoinedArg(
nullptr, MArch,
"i486");
1952 else if (Name ==
"i586")
1953 DAL->AddJoinedArg(
nullptr, MArch,
"i586");
1954 else if (Name ==
"i686")
1955 DAL->AddJoinedArg(
nullptr, MArch,
"i686");
1956 else if (Name ==
"pentium")
1957 DAL->AddJoinedArg(
nullptr, MArch,
"pentium");
1958 else if (Name ==
"pentium2")
1959 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
1960 else if (Name ==
"pentpro")
1961 DAL->AddJoinedArg(
nullptr, MArch,
"pentiumpro");
1962 else if (Name ==
"pentIIm3")
1963 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
1965 else if (Name ==
"x86_64")
1966 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
1967 else if (Name ==
"x86_64h") {
1968 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
1969 DAL->AddJoinedArg(
nullptr, MArch,
"x86_64h");
1972 else if (Name ==
"arm")
1973 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
1974 else if (Name ==
"armv4t")
1975 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
1976 else if (Name ==
"armv5")
1977 DAL->AddJoinedArg(
nullptr, MArch,
"armv5tej");
1978 else if (Name ==
"xscale")
1979 DAL->AddJoinedArg(
nullptr, MArch,
"xscale");
1980 else if (Name ==
"armv6")
1981 DAL->AddJoinedArg(
nullptr, MArch,
"armv6k");
1982 else if (Name ==
"armv6m")
1983 DAL->AddJoinedArg(
nullptr, MArch,
"armv6m");
1984 else if (Name ==
"armv7")
1985 DAL->AddJoinedArg(
nullptr, MArch,
"armv7a");
1986 else if (Name ==
"armv7em")
1987 DAL->AddJoinedArg(
nullptr, MArch,
"armv7em");
1988 else if (Name ==
"armv7k")
1989 DAL->AddJoinedArg(
nullptr, MArch,
"armv7k");
1990 else if (Name ==
"armv7m")
1991 DAL->AddJoinedArg(
nullptr, MArch,
"armv7m");
1992 else if (Name ==
"armv7s")
1993 DAL->AddJoinedArg(
nullptr, MArch,
"armv7s");
2000 ArgStringList &CmdArgs)
const {
2009 CompilerRT += Args.hasArg(options::OPT_fPIC) ?
"_pic.a" :
"_static.a";
2015 llvm::Triple::OSType OS;
2019 OS = llvm::Triple::MacOSX;
2022 OS = llvm::Triple::IOS;
2025 OS = llvm::Triple::TvOS;
2028 OS = llvm::Triple::WatchOS;
2036 llvm::opt::ArgStringList &CC1Args,
2040 if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
2041 options::OPT_fno_aligned_allocation) &&
2043 CC1Args.push_back(
"-faligned-alloc-unavailable");
2050 DerivedArgList *DAL =
2055 if (BoundArch.empty())
2061 AddDeploymentTarget(*DAL);
2069 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
2072 if (A->getOption().getID() != options::OPT_mkernel &&
2073 A->getOption().getID() != options::OPT_fapple_kext)
2075 assert(it != ie &&
"unexpected argument translation");
2077 assert(A->getOption().getID() == options::OPT_static &&
2078 "missing expected -static argument");
2084 if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
2086 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_stdlib_EQ),
2099 if (where != StringRef()) {
2100 getDriver().
Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
2105 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
2106 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
2107 options::OPT_fno_omit_frame_pointer,
false))
2108 getDriver().
Diag(clang::diag::warn_drv_unsupported_opt_for_target)
2109 <<
"-fomit-frame-pointer" << BoundArch;
2118 return getArch() == llvm::Triple::x86_64 ||
2120 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2125 if (
const char *S = ::getenv(
"RC_DEBUG_OPTIONS"))
2126 return S[0] !=
'\0';
2134 return llvm::ExceptionHandling::None;
2138 if(Triple.isWatchABI())
2139 return llvm::ExceptionHandling::DwarfCFI;
2141 return llvm::ExceptionHandling::SjLj;
2156 return (
getArch() == llvm::Triple::x86_64 ||
2157 getArch() == llvm::Triple::aarch64);
2162 return getArch() == llvm::Triple::x86 ||
getArch() == llvm::Triple::x86_64;
2166 ArgStringList &CmdArgs)
const {
2170 CmdArgs.push_back(
"-watchos_version_min");
2172 CmdArgs.push_back(
"-watchos_simulator_version_min");
2174 CmdArgs.push_back(
"-tvos_version_min");
2176 CmdArgs.push_back(
"-tvos_simulator_version_min");
2178 CmdArgs.push_back(
"-ios_simulator_version_min");
2180 CmdArgs.push_back(
"-iphoneos_version_min");
2183 CmdArgs.push_back(
"-macosx_version_min");
2186 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
2190 ArgStringList &CmdArgs)
const {
2192 if (Args.hasArg(options::OPT_dynamiclib)) {
2200 CmdArgs.push_back(
"-ldylib1.o");
2203 CmdArgs.push_back(
"-ldylib1.o");
2205 CmdArgs.push_back(
"-ldylib1.10.5.o");
2208 if (Args.hasArg(options::OPT_bundle)) {
2209 if (!Args.hasArg(options::OPT_static)) {
2217 CmdArgs.push_back(
"-lbundle1.o");
2220 CmdArgs.push_back(
"-lbundle1.o");
2225 if (Args.hasArg(options::OPT_static) ||
2226 Args.hasArg(options::OPT_object) ||
2227 Args.hasArg(options::OPT_preload)) {
2228 CmdArgs.push_back(
"-lgcrt0.o");
2230 CmdArgs.push_back(
"-lgcrt1.o");
2240 CmdArgs.push_back(
"-no_new_main");
2242 if (Args.hasArg(options::OPT_static) ||
2243 Args.hasArg(options::OPT_object) ||
2244 Args.hasArg(options::OPT_preload)) {
2245 CmdArgs.push_back(
"-lcrt0.o");
2253 if (
getArch() == llvm::Triple::aarch64)
2256 CmdArgs.push_back(
"-lcrt1.o");
2258 CmdArgs.push_back(
"-lcrt1.3.1.o");
2261 CmdArgs.push_back(
"-lcrt1.o");
2263 CmdArgs.push_back(
"-lcrt1.10.5.o");
2265 CmdArgs.push_back(
"-lcrt1.10.6.o");
2277 const char *Str = Args.MakeArgString(
GetFilePath(
"crt3.o"));
2278 CmdArgs.push_back(Str);
2290 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
2292 Res |= SanitizerKind::Address;
2293 Res |= SanitizerKind::Leak;
2294 Res |= SanitizerKind::Fuzzer;
2295 Res |= SanitizerKind::FuzzerNoLink;
2296 Res |= SanitizerKind::Function;
2299 Res |= SanitizerKind::Vptr;
2300 Res |= SanitizerKind::SafeStack;
2302 Res |= SanitizerKind::Thread;
2305 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]+)(.
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
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.
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...
bool requiresMinimalRuntime() const
ActionClass getKind() const
'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.
const llvm::opt::DerivedArgList & getArgs() const
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)
Defines the virtual file system interface vfs::FileSystem.
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
bool exists(const Twine &Path)
Check whether a file exists. Provided for convenience.
Compilation - A set of tasks to perform for a single driver invocation.
const Driver & getDriver() const
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
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?