20 #include "llvm/ADT/StringSwitch.h" 21 #include "llvm/Option/ArgList.h" 22 #include "llvm/Support/Path.h" 23 #include "llvm/Support/ScopedPrinter.h" 24 #include "llvm/Support/TargetParser.h" 25 #include "llvm/Support/VirtualFileSystem.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");
227 if (D.
isUsingLTO() && Version[0] >= 116 && NeedsTempPath(Inputs)) {
228 std::string TmpPathName;
239 if (!TmpPathName.empty()) {
240 auto *TmpPath = C.
getArgs().MakeArgString(TmpPathName);
242 CmdArgs.push_back(
"-object_path_lto");
243 CmdArgs.push_back(TmpPath);
254 if (Version[0] >= 133) {
256 StringRef
P = llvm::sys::path::parent_path(D.
Dir);
258 llvm::sys::path::append(LibLTOPath,
"lib");
259 llvm::sys::path::append(LibLTOPath,
"libLTO.dylib");
260 CmdArgs.push_back(
"-lto_library");
261 CmdArgs.push_back(C.
getArgs().MakeArgString(LibLTOPath));
266 CmdArgs.push_back(
"-no_deduplicate");
269 Args.AddAllArgs(CmdArgs, options::OPT_static);
270 if (!Args.hasArg(options::OPT_static))
271 CmdArgs.push_back(
"-dynamic");
272 if (Args.hasArg(options::OPT_fgnu_runtime)) {
277 if (!Args.hasArg(options::OPT_dynamiclib)) {
278 AddMachOArch(Args, CmdArgs);
280 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
282 Args.AddLastArg(CmdArgs, options::OPT_bundle);
283 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
284 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
287 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
288 (A = Args.getLastArg(options::OPT_current__version)) ||
289 (A = Args.getLastArg(options::OPT_install__name)))
290 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
293 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
294 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
295 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
297 CmdArgs.push_back(
"-dylib");
300 if ((A = Args.getLastArg(options::OPT_bundle)) ||
301 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
302 (A = Args.getLastArg(options::OPT_client__name)) ||
303 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
304 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
305 (A = Args.getLastArg(options::OPT_private__bundle)))
306 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
309 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
310 "-dylib_compatibility_version");
311 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
312 "-dylib_current_version");
314 AddMachOArch(Args, CmdArgs);
316 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
317 "-dylib_install_name");
320 Args.AddLastArg(CmdArgs, options::OPT_all__load);
321 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
322 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
324 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
325 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
326 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
327 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
328 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
329 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
330 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
331 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
332 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
333 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
334 Args.AddAllArgs(CmdArgs, options::OPT_init);
339 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
340 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
341 Args.AddLastArg(CmdArgs, options::OPT_single__module);
342 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
343 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
346 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
347 options::OPT_fno_pie, options::OPT_fno_PIE)) {
348 if (A->getOption().matches(options::OPT_fpie) ||
349 A->getOption().matches(options::OPT_fPIE))
350 CmdArgs.push_back(
"-pie");
352 CmdArgs.push_back(
"-no_pie");
359 CmdArgs.push_back(
"-bitcode_bundle");
361 CmdArgs.push_back(
"-bitcode_process_mode");
362 CmdArgs.push_back(
"marker");
365 D.
Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
368 Args.AddLastArg(CmdArgs, options::OPT_prebind);
369 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
370 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
371 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
372 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
373 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
374 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
375 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
376 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
377 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
378 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
379 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
380 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
381 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
382 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
383 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
389 CmdArgs.push_back(
"-syslibroot");
390 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
391 }
else if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
392 CmdArgs.push_back(
"-syslibroot");
393 CmdArgs.push_back(A->getValue());
396 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
397 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
398 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
399 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
400 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
401 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
402 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
403 Args.AddAllArgs(CmdArgs, options::OPT_y);
404 Args.AddLastArg(CmdArgs, options::OPT_w);
405 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
406 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
407 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
408 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
409 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
410 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
411 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
412 Args.AddLastArg(CmdArgs, options::OPT_whyload);
413 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
414 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
415 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
416 Args.AddLastArg(CmdArgs, options::OPT_Mach);
422 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
425 return Args.hasArg(options::OPT_fobjc_link_runtime);
432 const char *LinkingOutput)
const {
433 assert(Output.
getType() == types::TY_Image &&
"Invalid linker output type.");
439 llvm::opt::ArgStringList InputFileList;
444 ArgStringList CmdArgs;
447 if (Args.hasArg(options::OPT_ccc_arcmt_check,
448 options::OPT_ccc_arcmt_migrate)) {
449 for (
const auto &Arg : Args)
452 Args.MakeArgString(getToolChain().GetProgramPath(
"touch"));
454 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, None));
460 AddLinkArgs(C, Args, CmdArgs, Inputs);
464 if (Args.hasFlag(options::OPT_fsave_optimization_record,
465 options::OPT_fno_save_optimization_record,
false)) {
466 CmdArgs.push_back(
"-mllvm");
467 CmdArgs.push_back(
"-lto-pass-remarks-output");
468 CmdArgs.push_back(
"-mllvm");
473 CmdArgs.push_back(Args.MakeArgString(F));
476 CmdArgs.push_back(
"-mllvm");
477 CmdArgs.push_back(
"-lto-pass-remarks-with-hotness");
480 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
481 CmdArgs.push_back(
"-mllvm");
483 std::string(
"-lto-pass-remarks-hotness-threshold=") + A->getValue();
484 CmdArgs.push_back(Args.MakeArgString(Opt));
490 if (Args.hasFlag(options::OPT_moutline, options::OPT_mno_outline,
false)) {
491 if (getMachOToolChain().getMachOArchName(Args) ==
"arm64") {
492 CmdArgs.push_back(
"-mllvm");
493 CmdArgs.push_back(
"-enable-machine-outliner");
496 CmdArgs.push_back(
"-mllvm");
497 CmdArgs.push_back(
"-enable-linkonceodr-outlining");
503 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
504 options::OPT_Z_Flag, options::OPT_u_Group,
505 options::OPT_e, options::OPT_r});
510 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
511 CmdArgs.push_back(
"-ObjC");
513 CmdArgs.push_back(
"-o");
516 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
517 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
519 Args.AddAllArgs(CmdArgs, options::OPT_L);
524 for (
const auto &II : Inputs) {
525 if (!II.isFilename()) {
530 if (InputFileList.size() > 0)
536 InputFileList.push_back(II.getFilename());
539 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
543 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
545 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
547 CmdArgs.push_back(
"-framework");
548 CmdArgs.push_back(
"Foundation");
550 CmdArgs.push_back(
"-lobjc");
554 CmdArgs.push_back(
"-arch_multiple");
555 CmdArgs.push_back(
"-final_output");
556 CmdArgs.push_back(LinkingOutput);
559 if (Args.hasArg(options::OPT_fnested_functions))
560 CmdArgs.push_back(
"-allow_stack_execute");
562 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
564 if (
unsigned Parallelism =
566 CmdArgs.push_back(
"-mllvm");
567 CmdArgs.push_back(Args.MakeArgString(
"-threads=" + Twine(Parallelism)));
570 if (getToolChain().ShouldLinkCXXStdlib(Args))
571 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
572 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
576 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
579 Args.ClaimAllArgs(options::OPT_pthread);
580 Args.ClaimAllArgs(options::OPT_pthreads);
583 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
587 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
588 Args.AddAllArgs(CmdArgs, options::OPT_F);
591 for (
const Arg *A : Args.filtered(options::OPT_iframework))
592 CmdArgs.push_back(Args.MakeArgString(std::string(
"-F") + A->getValue()));
594 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
595 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
596 if (A->getValue() == StringRef(
"Accelerate")) {
597 CmdArgs.push_back(
"-framework");
598 CmdArgs.push_back(
"Accelerate");
603 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
604 std::unique_ptr<Command>
Cmd =
605 llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs);
606 Cmd->setInputFileList(std::move(InputFileList));
614 const char *LinkingOutput)
const {
615 ArgStringList CmdArgs;
617 CmdArgs.push_back(
"-create");
618 assert(Output.
isFilename() &&
"Unexpected lipo output.");
620 CmdArgs.push_back(
"-output");
623 for (
const auto &II : Inputs) {
624 assert(II.isFilename() &&
"Unexpected lipo input.");
625 CmdArgs.push_back(II.getFilename());
628 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"lipo"));
629 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
636 const char *LinkingOutput)
const {
637 ArgStringList CmdArgs;
639 CmdArgs.push_back(
"-o");
642 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
644 assert(Input.isFilename() &&
"Unexpected dsymutil input.");
645 CmdArgs.push_back(Input.getFilename());
648 Args.MakeArgString(getToolChain().GetProgramPath(
"dsymutil"));
649 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
656 const char *LinkingOutput)
const {
657 ArgStringList CmdArgs;
658 CmdArgs.push_back(
"--verify");
659 CmdArgs.push_back(
"--debug-info");
660 CmdArgs.push_back(
"--eh-frame");
661 CmdArgs.push_back(
"--quiet");
663 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
665 assert(Input.isFilename() &&
"Unexpected verify input");
668 CmdArgs.push_back(Input.getFilename());
671 Args.MakeArgString(getToolChain().GetProgramPath(
"dwarfdump"));
672 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
675 MachO::MachO(
const Driver &D,
const llvm::Triple &Triple,
const ArgList &Args)
685 :
MachO(D, Triple, Args), TargetInitialized(
false),
686 CudaInstallation(D, Triple, Args) {}
692 if (Ty == types::TY_PP_Asm)
693 return types::TY_Asm;
734 ArgStringList &CC1Args)
const {
743 return llvm::StringSwitch<const char *>(Arch)
744 .Case(
"armv6k",
"armv6")
745 .Case(
"armv6m",
"armv6m")
746 .Case(
"armv5tej",
"armv5")
747 .Case(
"xscale",
"xscale")
748 .Case(
"armv4t",
"armv4t")
749 .Case(
"armv7",
"armv7")
750 .Cases(
"armv7a",
"armv7-a",
"armv7")
751 .Cases(
"armv7r",
"armv7-r",
"armv7")
752 .Cases(
"armv7em",
"armv7e-m",
"armv7em")
753 .Cases(
"armv7k",
"armv7-k",
"armv7k")
754 .Cases(
"armv7m",
"armv7-m",
"armv7m")
755 .Cases(
"armv7s",
"armv7-s",
"armv7s")
760 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
761 if (ArchKind == llvm::ARM::ArchKind::INVALID)
763 StringRef Arch = llvm::ARM::getArchName(ArchKind);
767 if (Arch.startswith(
"armv5"))
768 Arch = Arch.substr(0, 5);
770 else if (Arch.startswith(
"armv6") && !Arch.endswith(
"6m"))
771 Arch = Arch.substr(0, 5);
773 else if (Arch.endswith(
"v7a"))
774 Arch = Arch.substr(0, 5);
783 case llvm::Triple::aarch64:
786 case llvm::Triple::thumb:
787 case llvm::Triple::arm:
788 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
792 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
811 return Triple.getTriple();
823 Triple.setOSName(Str);
825 return Triple.getTriple();
837 return Dsymutil.get();
841 return VerifyDebug.get();
855 :
Darwin(D, Triple, Args) {}
862 CC1Args.push_back(
"-Wdeprecated-objc-isa-usage");
863 CC1Args.push_back(
"-Werror=deprecated-objc-isa-usage");
868 CC1Args.push_back(
"-Werror=implicit-function-declaration");
873 ArgStringList &CmdArgs)
const {
884 CmdArgs.push_back(
"-force_load");
886 llvm::sys::path::remove_filename(P);
887 llvm::sys::path::remove_filename(P);
888 llvm::sys::path::append(P,
"lib",
"arc",
"libarclite_");
891 P +=
"watchsimulator";
895 P +=
"appletvsimulator";
899 P +=
"iphonesimulator";
906 CmdArgs.push_back(Args.MakeArgString(P));
919 bool IsShared)
const {
922 if (Component !=
"builtins") {
923 DarwinLibName += Component;
925 DarwinLibName +=
"_";
930 DarwinLibName += IsShared ?
"_dynamic.dylib" :
".a";
932 llvm::sys::path::append(
933 Dir,
"lib", (Opts &
RLO_IsEmbedded) ?
"macho_embedded" :
"darwin");
936 llvm::sys::path::append(P, DarwinLibName);
942 const char *LibArg = Args.MakeArgString(P);
944 CmdArgs.insert(CmdArgs.begin(), LibArg);
946 CmdArgs.push_back(LibArg);
954 assert(DarwinLibName.endswith(
".dylib") &&
"must be a dynamic library");
958 CmdArgs.push_back(
"-rpath");
959 CmdArgs.push_back(
"@executable_path");
963 CmdArgs.push_back(
"-rpath");
964 CmdArgs.push_back(Args.MakeArgString(Dir));
970 case DarwinPlatformKind::MacOS:
972 case DarwinPlatformKind::IPhoneOS:
974 case DarwinPlatformKind::TvOS:
976 case DarwinPlatformKind::WatchOS:
979 llvm_unreachable(
"Unsupported platform");
984 llvm::sys::path::const_iterator SDKDir;
985 auto BeginSDK = llvm::sys::path::begin(isysroot);
986 auto EndSDK = llvm::sys::path::end(isysroot);
987 for (
auto IT = BeginSDK; IT != EndSDK; ++IT) {
989 if (SDK.endswith(
".sdk"))
990 return SDK.slice(0, SDK.size() - 4);
997 case DarwinPlatformKind::MacOS:
999 case DarwinPlatformKind::IPhoneOS:
1002 case DarwinPlatformKind::TvOS:
1005 case DarwinPlatformKind::WatchOS:
1009 llvm_unreachable(
"Unsupported platform");
1014 for (Arg *A : Args) {
1015 if (A->getOption().matches(options::OPT_exported__symbols__list))
1017 if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
1018 !A->getOption().matches(options::OPT_Xlinker))
1020 if (A->containsValue(
"-exported_symbols_list") ||
1021 A->containsValue(
"-exported_symbol"))
1029 CmdArgs.push_back(
"-exported_symbol");
1030 CmdArgs.push_back(Symbol);
1034 ArgStringList &CmdArgs)
const {
1058 void DarwinClang::AddLinkSanitizerLibArgs(
const ArgList &Args,
1059 ArgStringList &CmdArgs,
1060 StringRef Sanitizer,
1061 bool Shared)
const {
1067 const ArgList &Args)
const {
1068 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1069 StringRef
Value = A->getValue();
1070 if (Value !=
"compiler-rt")
1071 getDriver().
Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1072 << Value <<
"darwin";
1079 ArgStringList &CmdArgs)
const {
1085 if (Args.hasArg(options::OPT_static) ||
1086 Args.hasArg(options::OPT_fapple_kext) ||
1087 Args.hasArg(options::OPT_mkernel))
1093 if (
const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1094 getDriver().
Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1100 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan");
1102 AddLinkSanitizerLibArgs(Args, CmdArgs,
"lsan");
1104 AddLinkSanitizerLibArgs(Args, CmdArgs,
1109 AddLinkSanitizerLibArgs(Args, CmdArgs,
"tsan");
1110 if (Sanitize.
needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1111 AddLinkSanitizerLibArgs(Args, CmdArgs,
"fuzzer",
false);
1118 AddLinkSanitizerLibArgs(Args, CmdArgs,
"stats");
1121 AddLinkSanitizerLibArgs(Args, CmdArgs,
"esan");
1132 CmdArgs.push_back(
"-lSystem");
1141 CmdArgs.push_back(
"-lgcc_s.1");
1151 unsigned Major, Minor, Micro;
1152 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1153 if (!SystemTriple.isMacOSX())
1154 return MacOSSDKVersion;
1155 SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1156 VersionTuple SystemVersion(Major, Minor, Micro);
1160 return MacOSSDKVersion;
1161 VersionTuple SDKVersion(Major, Minor, Micro);
1162 if (SDKVersion > SystemVersion)
1163 return SystemVersion.getAsString();
1164 return MacOSSDKVersion;
1170 struct DarwinPlatform {
1177 DeploymentTargetEnv,
1193 InferSimulatorFromArch =
false;
1196 StringRef getOSVersion()
const {
1197 if (Kind == OSVersionArg)
1198 return Argument->getValue();
1202 void setOSVersion(StringRef S) {
1203 assert(Kind == TargetArg &&
"Unexpected kind!");
1207 bool hasOSVersion()
const {
return HasOSVersion; }
1210 bool isExplicitlySpecified()
const {
return Kind <= DeploymentTargetEnv; }
1213 bool canInferSimulatorFromArch()
const {
return InferSimulatorFromArch; }
1216 void addOSVersionMinArgument(DerivedArgList &Args,
const OptTable &Opts) {
1219 assert(Kind != TargetArg && Kind != OSVersionArg &&
"Invalid kind");
1222 case DarwinPlatformKind::MacOS:
1223 Opt = options::OPT_mmacosx_version_min_EQ;
1225 case DarwinPlatformKind::IPhoneOS:
1226 Opt = options::OPT_miphoneos_version_min_EQ;
1228 case DarwinPlatformKind::TvOS:
1229 Opt = options::OPT_mtvos_version_min_EQ;
1231 case DarwinPlatformKind::WatchOS:
1232 Opt = options::OPT_mwatchos_version_min_EQ;
1235 Argument = Args.MakeJoinedArg(
nullptr, Opts.getOption(Opt), OSVersion);
1236 Args.append(Argument);
1241 std::string
getAsString(DerivedArgList &Args,
const OptTable &Opts) {
1245 case InferredFromSDK:
1246 case InferredFromArch:
1247 assert(Argument &&
"OS version argument not yet inferred");
1248 return Argument->getAsString(Args);
1249 case DeploymentTargetEnv:
1250 return (llvm::Twine(EnvVarName) +
"=" + OSVersion).str();
1252 llvm_unreachable(
"Unsupported Darwin Source Kind");
1255 static DarwinPlatform createFromTarget(
const llvm::Triple &TT,
1256 StringRef OSVersion, Arg *A) {
1257 DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
1259 switch (TT.getEnvironment()) {
1260 case llvm::Triple::Simulator:
1261 Result.Environment = DarwinEnvironmentKind::Simulator;
1266 unsigned Major, Minor, Micro;
1267 TT.getOSVersion(Major, Minor, Micro);
1269 Result.HasOSVersion =
false;
1274 return DarwinPlatform(OSVersionArg, Platform, A);
1277 StringRef EnvVarName,
1279 DarwinPlatform Result(DeploymentTargetEnv, Platform, Value);
1280 Result.EnvVarName = EnvVarName;
1285 bool IsSimulator =
false) {
1286 DarwinPlatform Result(InferredFromSDK, Platform, Value);
1288 Result.Environment = DarwinEnvironmentKind::Simulator;
1289 Result.InferSimulatorFromArch =
false;
1292 static DarwinPlatform createFromArch(llvm::Triple::OSType OS,
1294 return DarwinPlatform(InferredFromArch, getPlatformFromOS(OS), Value);
1301 assert(Kind == InferredFromSDK &&
"can infer SDK info only");
1302 llvm::VersionTuple Version;
1303 bool IsValid = !Version.tryParse(OSVersion);
1305 assert(IsValid &&
"invalid SDK version");
1311 :
Kind(Kind), Platform(Platform), Argument(Argument) {}
1313 Arg *Argument =
nullptr)
1314 :
Kind(Kind), Platform(Platform), OSVersion(Value), Argument(Argument) {}
1318 case llvm::Triple::Darwin:
1319 case llvm::Triple::MacOSX:
1320 return DarwinPlatformKind::MacOS;
1321 case llvm::Triple::IOS:
1322 return DarwinPlatformKind::IPhoneOS;
1323 case llvm::Triple::TvOS:
1324 return DarwinPlatformKind::TvOS;
1325 case llvm::Triple::WatchOS:
1326 return DarwinPlatformKind::WatchOS;
1328 llvm_unreachable(
"Unable to infer Darwin variant");
1335 std::string OSVersion;
1336 bool HasOSVersion =
true, InferSimulatorFromArch =
true;
1338 StringRef EnvVarName;
1344 getDeploymentTargetFromOSVersionArg(DerivedArgList &Args,
1345 const Driver &TheDriver) {
1346 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
1347 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ,
1348 options::OPT_mios_simulator_version_min_EQ);
1350 Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1351 options::OPT_mtvos_simulator_version_min_EQ);
1352 Arg *WatchOSVersion =
1353 Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1354 options::OPT_mwatchos_simulator_version_min_EQ);
1356 if (iOSVersion || TvOSVersion || WatchOSVersion) {
1357 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1358 << OSXVersion->getAsString(Args)
1359 << (iOSVersion ? iOSVersion
1360 : TvOSVersion ? TvOSVersion : WatchOSVersion)
1363 return DarwinPlatform::createOSVersionArg(
Darwin::MacOS, OSXVersion);
1364 }
else if (iOSVersion) {
1365 if (TvOSVersion || WatchOSVersion) {
1366 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1367 << iOSVersion->getAsString(Args)
1368 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->
getAsString(Args);
1371 }
else if (TvOSVersion) {
1372 if (WatchOSVersion) {
1373 TheDriver.
Diag(diag::err_drv_argument_not_allowed_with)
1374 << TvOSVersion->getAsString(Args)
1375 << WatchOSVersion->getAsString(Args);
1377 return DarwinPlatform::createOSVersionArg(
Darwin::TvOS, TvOSVersion);
1378 }
else if (WatchOSVersion)
1379 return DarwinPlatform::createOSVersionArg(
Darwin::WatchOS, WatchOSVersion);
1386 getDeploymentTargetFromEnvironmentVariables(
const Driver &TheDriver,
1387 const llvm::Triple &Triple) {
1389 const char *EnvVars[] = {
1390 "MACOSX_DEPLOYMENT_TARGET",
1391 "IPHONEOS_DEPLOYMENT_TARGET",
1392 "TVOS_DEPLOYMENT_TARGET",
1393 "WATCHOS_DEPLOYMENT_TARGET",
1396 "Missing platform");
1397 for (
const auto &I : llvm::enumerate(llvm::makeArrayRef(EnvVars))) {
1398 if (
char *Env = ::getenv(I.value()))
1399 Targets[I.index()] = Env;
1405 TheDriver.
Diag(diag::err_drv_conflicting_deployment_targets)
1406 <<
"WATCHOS_DEPLOYMENT_TARGET" 1408 :
"TVOS_DEPLOYMENT_TARGET");
1413 TheDriver.
Diag(diag::err_drv_conflicting_deployment_targets)
1414 <<
"TVOS_DEPLOYMENT_TARGET" 1415 <<
"IPHONEOS_DEPLOYMENT_TARGET";
1423 if (Triple.getArch() == llvm::Triple::arm ||
1424 Triple.getArch() == llvm::Triple::aarch64 ||
1425 Triple.getArch() == llvm::Triple::thumb)
1432 for (
const auto &
Target : llvm::enumerate(llvm::makeArrayRef(Targets))) {
1433 if (!
Target.value().empty())
1434 return DarwinPlatform::createDeploymentTargetEnv(
1445 inferDeploymentTargetFromSDK(DerivedArgList &Args,
1447 const Arg *A = Args.getLastArg(options::OPT_isysroot);
1450 StringRef isysroot = A->getValue();
1455 std::string Version;
1458 Version = SDKInfo->getVersion().getAsString();
1462 size_t StartVer = SDK.find_first_of(
"0123456789");
1463 size_t EndVer = SDK.find_last_of(
"0123456789");
1464 if (StartVer != StringRef::npos && EndVer > StartVer)
1465 Version = SDK.slice(StartVer, EndVer + 1);
1467 if (Version.empty())
1470 if (SDK.startswith(
"iPhoneOS") || SDK.startswith(
"iPhoneSimulator"))
1471 return DarwinPlatform::createFromSDK(
1473 SDK.startswith(
"iPhoneSimulator"));
1474 else if (SDK.startswith(
"MacOSX"))
1477 else if (SDK.startswith(
"WatchOS") || SDK.startswith(
"WatchSimulator"))
1478 return DarwinPlatform::createFromSDK(
1480 SDK.startswith(
"WatchSimulator"));
1481 else if (SDK.startswith(
"AppleTVOS") || SDK.startswith(
"AppleTVSimulator"))
1482 return DarwinPlatform::createFromSDK(
1484 SDK.startswith(
"AppleTVSimulator"));
1488 std::string getOSVersion(llvm::Triple::OSType OS,
const llvm::Triple &Triple,
1489 const Driver &TheDriver) {
1490 unsigned Major, Minor, Micro;
1491 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1493 case llvm::Triple::Darwin:
1494 case llvm::Triple::MacOSX:
1497 if (Triple.isMacOSX() && SystemTriple.isMacOSX() &&
1498 !Triple.getOSMajorVersion())
1499 SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1500 else if (!Triple.getMacOSXVersion(Major, Minor, Micro))
1501 TheDriver.
Diag(diag::err_drv_invalid_darwin_version)
1502 << Triple.getOSName();
1504 case llvm::Triple::IOS:
1505 Triple.getiOSVersion(Major, Minor, Micro);
1507 case llvm::Triple::TvOS:
1508 Triple.getOSVersion(Major, Minor, Micro);
1510 case llvm::Triple::WatchOS:
1511 Triple.getWatchOSVersion(Major, Minor, Micro);
1514 llvm_unreachable(
"Unexpected OS type");
1518 std::string OSVersion;
1519 llvm::raw_string_ostream(OSVersion) << Major <<
'.' << Minor <<
'.' << Micro;
1525 inferDeploymentTargetFromArch(DerivedArgList &Args,
const Darwin &Toolchain,
1526 const llvm::Triple &Triple,
1527 const Driver &TheDriver) {
1528 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
1531 if (MachOArchName ==
"armv7" || MachOArchName ==
"armv7s" ||
1532 MachOArchName ==
"arm64")
1533 OSTy = llvm::Triple::IOS;
1534 else if (MachOArchName ==
"armv7k")
1535 OSTy = llvm::Triple::WatchOS;
1536 else if (MachOArchName !=
"armv6m" && MachOArchName !=
"armv7m" &&
1537 MachOArchName !=
"armv7em")
1538 OSTy = llvm::Triple::MacOSX;
1540 if (OSTy == llvm::Triple::UnknownOS)
1542 return DarwinPlatform::createFromArch(OSTy,
1543 getOSVersion(OSTy, Triple, TheDriver));
1548 DerivedArgList &Args,
const llvm::Triple &Triple,
const Driver &TheDriver) {
1549 if (!Args.hasArg(options::OPT_target))
1551 if (Triple.getOS() == llvm::Triple::Darwin ||
1552 Triple.getOS() == llvm::Triple::UnknownOS)
1554 std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
1555 return DarwinPlatform::createFromTarget(Triple, OSVersion,
1556 Args.getLastArg(options::OPT_target));
1560 const ArgList &Args,
1561 const Driver &TheDriver) {
1562 const Arg *A = Args.getLastArg(options::OPT_isysroot);
1565 StringRef isysroot = A->getValue();
1567 if (!SDKInfoOrErr) {
1568 llvm::consumeError(SDKInfoOrErr.takeError());
1569 TheDriver.
Diag(diag::warn_drv_darwin_sdk_invalid_settings);
1572 return *SDKInfoOrErr;
1577 void Darwin::AddDeploymentTarget(DerivedArgList &Args)
const {
1583 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1585 if (!
getVFS().exists(A->getValue()))
1586 getDriver().
Diag(clang::diag::warn_missing_sysroot) << A->getValue();
1588 if (
char *env = ::getenv(
"SDKROOT")) {
1591 if (llvm::sys::path::is_absolute(env) &&
getVFS().exists(env) &&
1592 StringRef(env) !=
"/") {
1593 Args.append(Args.MakeSeparateArg(
1594 nullptr, Opts.getOption(options::OPT_isysroot), env));
1608 getDeploymentTargetFromOSVersionArg(Args,
getDriver());
1609 if (OSVersionArgTarget) {
1610 unsigned TargetMajor, TargetMinor, TargetMicro;
1612 unsigned ArgMajor, ArgMinor, ArgMicro;
1614 if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
1616 TargetMinor, TargetMicro, TargetExtra) &&
1618 ArgMajor, ArgMinor, ArgMicro, ArgExtra) &&
1619 (VersionTuple(TargetMajor, TargetMinor, TargetMicro) !=
1620 VersionTuple(ArgMajor, ArgMinor, ArgMicro) ||
1621 TargetExtra != ArgExtra))) {
1624 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
1625 !OSTarget->hasOSVersion()) {
1626 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
1630 std::string OSVersionArg =
1631 OSVersionArgTarget->getAsString(Args, Opts);
1632 std::string TargetArg = OSTarget->getAsString(Args, Opts);
1633 getDriver().
Diag(clang::diag::warn_drv_overriding_flag_option)
1634 << OSVersionArg << TargetArg;
1640 OSTarget = getDeploymentTargetFromOSVersionArg(Args,
getDriver());
1649 inferDeploymentTargetFromSDK(Args,
SDKInfo);
1651 OSTarget->setEnvironment(SDKTarget->getEnvironment());
1658 OSTarget = inferDeploymentTargetFromSDK(Args,
SDKInfo);
1662 SDKInfo = OSTarget->inferSDKInfo();
1671 assert(OSTarget &&
"Unable to infer Darwin variant");
1672 OSTarget->addOSVersionMinArgument(Args, Opts);
1675 unsigned Major, Minor, Micro;
1678 if (Platform ==
MacOS) {
1681 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
1683 << OSTarget->getAsString(Args, Opts);
1687 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1689 << OSTarget->getAsString(Args, Opts);
1693 if (
getTriple().isArch32Bit() && Major >= 11) {
1695 if (OSTarget->isExplicitlySpecified()) {
1697 << OSTarget->getAsString(Args, Opts);
1705 }
else if (Platform ==
TvOS) {
1708 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1710 << OSTarget->getAsString(Args, Opts);
1711 }
else if (Platform ==
WatchOS) {
1714 HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
1716 << OSTarget->getAsString(Args, Opts);
1718 llvm_unreachable(
"unknown kind of Darwin platform");
1723 OSTarget->canInferSimulatorFromArch() &&
1724 (
getTriple().getArch() == llvm::Triple::x86 ||
1725 getTriple().getArch() == llvm::Triple::x86_64))
1728 setTarget(Platform, Environment, Major, Minor, Micro);
1730 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1732 if (SDK.size() > 0) {
1733 size_t StartVer = SDK.find_first_of(
"0123456789");
1734 StringRef SDKName = SDK.slice(0, StartVer);
1743 const llvm::opt::ArgList &DriverArgs,
1744 llvm::opt::ArgStringList &CC1Args)
const {
1751 if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
1752 DriverArgs.hasArg(options::OPT_nostdincxx))
1758 if (InstallDir.empty())
1766 llvm::sys::path::append(P,
"..",
"include",
"c++",
"v1");
1776 ArgStringList &CmdArgs)
const {
1781 CmdArgs.push_back(
"-lc++");
1791 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1793 llvm::sys::path::append(
P,
"usr",
"lib",
"libstdc++.dylib");
1796 llvm::sys::path::remove_filename(
P);
1797 llvm::sys::path::append(
P,
"libstdc++.6.dylib");
1799 CmdArgs.push_back(Args.MakeArgString(
P));
1808 if (!
getVFS().exists(
"/usr/lib/libstdc++.dylib") &&
1809 getVFS().exists(
"/usr/lib/libstdc++.6.dylib")) {
1810 CmdArgs.push_back(
"/usr/lib/libstdc++.6.dylib");
1815 CmdArgs.push_back(
"-lstdc++");
1821 ArgStringList &CmdArgs)
const {
1827 llvm::sys::path::append(P,
"lib",
"darwin");
1831 llvm::sys::path::append(P,
"libclang_rt.cc_kext_watchos.a");
1833 llvm::sys::path::append(P,
"libclang_rt.cc_kext_tvos.a");
1835 llvm::sys::path::append(P,
"libclang_rt.cc_kext_ios.a");
1837 llvm::sys::path::append(P,
"libclang_rt.cc_kext.a");
1843 CmdArgs.push_back(Args.MakeArgString(P));
1847 StringRef BoundArch,
1849 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1859 for (Arg *A : Args) {
1860 if (A->getOption().matches(options::OPT_Xarch__)) {
1863 llvm::Triple::ArchType XarchArch =
1865 if (!(XarchArch ==
getArch() ||
1866 (!BoundArch.empty() &&
1871 Arg *OriginalArg = A;
1872 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1873 unsigned Prev = Index;
1874 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1884 if (!XarchArg || Index > Prev + 1) {
1885 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1886 << A->getAsString(Args);
1889 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
1890 << A->getAsString(Args);
1894 XarchArg->setBaseArg(A);
1896 A = XarchArg.release();
1897 DAL->AddSynthesizedArg(A);
1904 for (
const char *
Value : A->getValues()) {
1905 DAL->AddSeparateArg(
1906 OriginalArg, Opts.getOption(options::OPT_Zlinker_input),
Value);
1920 case options::OPT_mkernel:
1921 case options::OPT_fapple_kext:
1923 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
1926 case options::OPT_dependency_file:
1927 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
1930 case options::OPT_gfull:
1931 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1933 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
1936 case options::OPT_gused:
1937 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1939 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
1942 case options::OPT_shared:
1943 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
1946 case options::OPT_fconstant_cfstrings:
1947 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
1950 case options::OPT_fno_constant_cfstrings:
1951 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
1954 case options::OPT_Wnonportable_cfstrings:
1956 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
1959 case options::OPT_Wno_nonportable_cfstrings:
1961 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
1964 case options::OPT_fpascal_strings:
1965 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
1968 case options::OPT_fno_pascal_strings:
1969 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
1974 if (
getTriple().getArch() == llvm::Triple::x86 ||
1975 getTriple().getArch() == llvm::Triple::x86_64)
1976 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
1977 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_mtune_EQ),
1982 if (!BoundArch.empty()) {
1983 StringRef Name = BoundArch;
1984 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
1985 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
1991 else if (Name ==
"ppc601")
1992 DAL->AddJoinedArg(
nullptr, MCpu,
"601");
1993 else if (Name ==
"ppc603")
1994 DAL->AddJoinedArg(
nullptr, MCpu,
"603");
1995 else if (Name ==
"ppc604")
1996 DAL->AddJoinedArg(
nullptr, MCpu,
"604");
1997 else if (Name ==
"ppc604e")
1998 DAL->AddJoinedArg(
nullptr, MCpu,
"604e");
1999 else if (Name ==
"ppc750")
2000 DAL->AddJoinedArg(
nullptr, MCpu,
"750");
2001 else if (Name ==
"ppc7400")
2002 DAL->AddJoinedArg(
nullptr, MCpu,
"7400");
2003 else if (Name ==
"ppc7450")
2004 DAL->AddJoinedArg(
nullptr, MCpu,
"7450");
2005 else if (Name ==
"ppc970")
2006 DAL->AddJoinedArg(
nullptr, MCpu,
"970");
2008 else if (Name ==
"ppc64" || Name ==
"ppc64le")
2009 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2011 else if (Name ==
"i386")
2013 else if (Name ==
"i486")
2014 DAL->AddJoinedArg(
nullptr, MArch,
"i486");
2015 else if (Name ==
"i586")
2016 DAL->AddJoinedArg(
nullptr, MArch,
"i586");
2017 else if (Name ==
"i686")
2018 DAL->AddJoinedArg(
nullptr, MArch,
"i686");
2019 else if (Name ==
"pentium")
2020 DAL->AddJoinedArg(
nullptr, MArch,
"pentium");
2021 else if (Name ==
"pentium2")
2022 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2023 else if (Name ==
"pentpro")
2024 DAL->AddJoinedArg(
nullptr, MArch,
"pentiumpro");
2025 else if (Name ==
"pentIIm3")
2026 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
2028 else if (Name ==
"x86_64" || Name ==
"x86_64h")
2029 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
2031 else if (Name ==
"arm")
2032 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2033 else if (Name ==
"armv4t")
2034 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
2035 else if (Name ==
"armv5")
2036 DAL->AddJoinedArg(
nullptr, MArch,
"armv5tej");
2037 else if (Name ==
"xscale")
2038 DAL->AddJoinedArg(
nullptr, MArch,
"xscale");
2039 else if (Name ==
"armv6")
2040 DAL->AddJoinedArg(
nullptr, MArch,
"armv6k");
2041 else if (Name ==
"armv6m")
2042 DAL->AddJoinedArg(
nullptr, MArch,
"armv6m");
2043 else if (Name ==
"armv7")
2044 DAL->AddJoinedArg(
nullptr, MArch,
"armv7a");
2045 else if (Name ==
"armv7em")
2046 DAL->AddJoinedArg(
nullptr, MArch,
"armv7em");
2047 else if (Name ==
"armv7k")
2048 DAL->AddJoinedArg(
nullptr, MArch,
"armv7k");
2049 else if (Name ==
"armv7m")
2050 DAL->AddJoinedArg(
nullptr, MArch,
"armv7m");
2051 else if (Name ==
"armv7s")
2052 DAL->AddJoinedArg(
nullptr, MArch,
"armv7s");
2059 ArgStringList &CmdArgs)
const {
2068 CompilerRT += Args.hasArg(options::OPT_fPIC) ?
"_pic" :
"_static";
2074 llvm::Triple::OSType OS;
2078 OS = llvm::Triple::MacOSX;
2081 OS = llvm::Triple::IOS;
2084 OS = llvm::Triple::TvOS;
2087 OS = llvm::Triple::WatchOS;
2095 llvm::opt::ArgStringList &CC1Args,
2099 if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
2100 options::OPT_fno_aligned_allocation) &&
2102 CC1Args.push_back(
"-faligned-alloc-unavailable");
2108 llvm::raw_string_ostream OS(Arg);
2109 OS <<
"-target-sdk-version=" <<
SDKInfo->getVersion();
2110 CC1Args.push_back(DriverArgs.MakeArgString(OS.str()));
2118 DerivedArgList *DAL =
2123 if (BoundArch.empty())
2129 AddDeploymentTarget(*DAL);
2137 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
2140 if (A->getOption().getID() != options::OPT_mkernel &&
2141 A->getOption().getID() != options::OPT_fapple_kext)
2143 assert(it != ie &&
"unexpected argument translation");
2145 assert(A->getOption().getID() == options::OPT_static &&
2146 "missing expected -static argument");
2152 if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
2154 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_stdlib_EQ),
2167 if (where != StringRef()) {
2168 getDriver().
Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
2173 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
2174 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
2175 options::OPT_fno_omit_frame_pointer,
false))
2176 getDriver().
Diag(clang::diag::warn_drv_unsupported_opt_for_target)
2177 <<
"-fomit-frame-pointer" << BoundArch;
2186 return getArch() == llvm::Triple::x86_64 ||
2188 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2193 if (
const char *S = ::getenv(
"RC_DEBUG_OPTIONS"))
2194 return S[0] !=
'\0';
2206 if (Triple.isWatchABI())
2207 return llvm::ExceptionHandling::DwarfCFI;
2209 return llvm::ExceptionHandling::SjLj;
2224 return (
getArch() == llvm::Triple::x86_64 ||
2225 getArch() == llvm::Triple::aarch64);
2230 return getArch() == llvm::Triple::x86 ||
getArch() == llvm::Triple::x86_64;
2234 ArgStringList &CmdArgs)
const {
2238 CmdArgs.push_back(
"-watchos_version_min");
2240 CmdArgs.push_back(
"-watchos_simulator_version_min");
2242 CmdArgs.push_back(
"-tvos_version_min");
2244 CmdArgs.push_back(
"-tvos_simulator_version_min");
2246 CmdArgs.push_back(
"-ios_simulator_version_min");
2248 CmdArgs.push_back(
"-iphoneos_version_min");
2251 CmdArgs.push_back(
"-macosx_version_min");
2254 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
2258 ArgStringList &CmdArgs)
const {
2260 if (Args.hasArg(options::OPT_dynamiclib)) {
2268 CmdArgs.push_back(
"-ldylib1.o");
2271 CmdArgs.push_back(
"-ldylib1.o");
2273 CmdArgs.push_back(
"-ldylib1.10.5.o");
2276 if (Args.hasArg(options::OPT_bundle)) {
2277 if (!Args.hasArg(options::OPT_static)) {
2285 CmdArgs.push_back(
"-lbundle1.o");
2288 CmdArgs.push_back(
"-lbundle1.o");
2293 if (Args.hasArg(options::OPT_static) ||
2294 Args.hasArg(options::OPT_object) ||
2295 Args.hasArg(options::OPT_preload)) {
2296 CmdArgs.push_back(
"-lgcrt0.o");
2298 CmdArgs.push_back(
"-lgcrt1.o");
2308 CmdArgs.push_back(
"-no_new_main");
2310 if (Args.hasArg(options::OPT_static) ||
2311 Args.hasArg(options::OPT_object) ||
2312 Args.hasArg(options::OPT_preload)) {
2313 CmdArgs.push_back(
"-lcrt0.o");
2321 if (
getArch() == llvm::Triple::aarch64)
2324 CmdArgs.push_back(
"-lcrt1.o");
2326 CmdArgs.push_back(
"-lcrt1.3.1.o");
2329 CmdArgs.push_back(
"-lcrt1.o");
2331 CmdArgs.push_back(
"-lcrt1.10.5.o");
2333 CmdArgs.push_back(
"-lcrt1.10.6.o");
2344 const char *Str = Args.MakeArgString(
GetFilePath(
"crt3.o"));
2345 CmdArgs.push_back(Str);
2357 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
2359 Res |= SanitizerKind::Address;
2360 Res |= SanitizerKind::Leak;
2361 Res |= SanitizerKind::Fuzzer;
2362 Res |= SanitizerKind::FuzzerNoLink;
2363 Res |= SanitizerKind::Function;
2370 Res |= SanitizerKind::Vptr;
2374 Res |= SanitizerKind::Thread;
2377 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
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.
const llvm::opt::DerivedArgList & getArgs() const
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)
const char * getInstalledDir() const
Get the path to where the clang executable was installed.
'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
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?