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"
27 using namespace clang::driver;
28 using namespace clang::driver::tools;
29 using namespace clang::driver::toolchains;
30 using namespace clang;
31 using namespace llvm::opt;
46 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
47 .Cases(
"ppc",
"ppc601",
"ppc603",
"ppc604",
"ppc604e", llvm::Triple::ppc)
48 .Cases(
"ppc750",
"ppc7400",
"ppc7450",
"ppc970", llvm::Triple::ppc)
49 .Case(
"ppc64", llvm::Triple::ppc64)
50 .Cases(
"i386",
"i486",
"i486SX",
"i586",
"i686", llvm::Triple::x86)
51 .Cases(
"pentium",
"pentpro",
"pentIIm3",
"pentIIm5",
"pentium4",
53 .Cases(
"x86_64",
"x86_64h", llvm::Triple::x86_64)
55 .Cases(
"arm",
"armv4t",
"armv5",
"armv6",
"armv6m", llvm::Triple::arm)
56 .Cases(
"armv7",
"armv7em",
"armv7k",
"armv7m", llvm::Triple::arm)
57 .Cases(
"armv7s",
"xscale", llvm::Triple::arm)
58 .Case(
"arm64", llvm::Triple::aarch64)
59 .Case(
"r600", llvm::Triple::r600)
60 .Case(
"amdgcn", llvm::Triple::amdgcn)
61 .Case(
"nvptx", llvm::Triple::nvptx)
62 .Case(
"nvptx64", llvm::Triple::nvptx64)
63 .Case(
"amdil", llvm::Triple::amdil)
64 .Case(
"spir", llvm::Triple::spir)
65 .Default(llvm::Triple::UnknownArch);
70 unsigned ArchKind = llvm::ARM::parseArch(Str);
75 else if (ArchKind == llvm::ARM::AK_ARMV6M ||
76 ArchKind == llvm::ARM::AK_ARMV7M ||
77 ArchKind == llvm::ARM::AK_ARMV7EM) {
78 T.setOS(llvm::Triple::UnknownOS);
79 T.setObjectFormat(llvm::Triple::MachO);
87 const char *LinkingOutput)
const {
88 ArgStringList CmdArgs;
90 assert(Inputs.size() == 1 &&
"Unexpected number of inputs.");
94 const Action *SourceAction = &JA;
96 assert(!SourceAction->
getInputs().empty() &&
"unexpected root action!");
97 SourceAction = SourceAction->
getInputs()[0];
105 if (Args.hasArg(options::OPT_fno_integrated_as)) {
106 const llvm::Triple &T(getToolChain().getTriple());
107 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
108 CmdArgs.push_back(
"-Q");
112 if (SourceAction->
getType() == types::TY_Asm ||
113 SourceAction->
getType() == types::TY_PP_Asm) {
114 if (Args.hasArg(options::OPT_gstabs))
115 CmdArgs.push_back(
"--gstabs");
116 else if (Args.hasArg(options::OPT_g_Group))
117 CmdArgs.push_back(
"-g");
121 AddMachOArch(Args, CmdArgs);
124 if (getToolChain().getArch() == llvm::Triple::x86 ||
125 getToolChain().getArch() == llvm::Triple::x86_64 ||
126 Args.hasArg(options::OPT_force__cpusubtype__ALL))
127 CmdArgs.push_back(
"-force_cpusubtype_ALL");
129 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
130 (((Args.hasArg(options::OPT_mkernel) ||
131 Args.hasArg(options::OPT_fapple_kext)) &&
132 getMachOToolChain().isKernelStatic()) ||
133 Args.hasArg(options::OPT_static)))
134 CmdArgs.push_back(
"-static");
136 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
138 assert(Output.
isFilename() &&
"Unexpected lipo output.");
139 CmdArgs.push_back(
"-o");
142 assert(Input.isFilename() &&
"Invalid input.");
143 CmdArgs.push_back(Input.getFilename());
147 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"as"));
148 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
151 void darwin::MachOTool::anchor() {}
154 ArgStringList &CmdArgs)
const {
155 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
158 CmdArgs.push_back(
"-arch");
159 CmdArgs.push_back(Args.MakeArgString(ArchName));
162 if (ArchName ==
"arm")
163 CmdArgs.push_back(
"-force_cpusubtype_ALL");
166 bool darwin::Linker::NeedsTempPath(
const InputInfoList &Inputs)
const {
170 for (
const auto &
Input : Inputs)
171 if (
Input.getType() != types::TY_Object)
185 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
186 if (A->getOption().matches(options::OPT_O0))
188 if (A->getOption().matches(options::OPT_O))
189 return llvm::StringSwitch<bool>(A->getValue())
195 if (!IsLinkerOnlyAction)
200 void darwin::Linker::AddLinkArgs(
Compilation &C,
const ArgList &Args,
201 ArgStringList &CmdArgs,
203 const Driver &D = getToolChain().getDriver();
206 unsigned Version[5] = {0, 0, 0, 0, 0};
207 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
209 D.
Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
214 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
215 CmdArgs.push_back(
"-demangle");
217 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137)
218 CmdArgs.push_back(
"-export_dynamic");
222 if (Args.hasFlag(options::OPT_fapplication_extension,
223 options::OPT_fno_application_extension,
false))
224 CmdArgs.push_back(
"-application_extension");
230 if (Version[0] >= 116 && NeedsTempPath(Inputs)) {
231 const char *TmpPath = C.
getArgs().MakeArgString(
234 CmdArgs.push_back(
"-object_path_lto");
235 CmdArgs.push_back(TmpPath);
246 if (Version[0] >= 133) {
248 StringRef
P = llvm::sys::path::parent_path(D.
Dir);
250 llvm::sys::path::append(LibLTOPath,
"lib");
251 llvm::sys::path::append(LibLTOPath,
"libLTO.dylib");
252 CmdArgs.push_back(
"-lto_library");
253 CmdArgs.push_back(C.
getArgs().MakeArgString(LibLTOPath));
258 CmdArgs.push_back(
"-no_deduplicate");
261 Args.AddAllArgs(CmdArgs, options::OPT_static);
262 if (!Args.hasArg(options::OPT_static))
263 CmdArgs.push_back(
"-dynamic");
264 if (Args.hasArg(options::OPT_fgnu_runtime)) {
269 if (!Args.hasArg(options::OPT_dynamiclib)) {
270 AddMachOArch(Args, CmdArgs);
272 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
274 Args.AddLastArg(CmdArgs, options::OPT_bundle);
275 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
276 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
279 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
280 (A = Args.getLastArg(options::OPT_current__version)) ||
281 (A = Args.getLastArg(options::OPT_install__name)))
282 D.
Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
285 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
286 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
287 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
289 CmdArgs.push_back(
"-dylib");
292 if ((A = Args.getLastArg(options::OPT_bundle)) ||
293 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
294 (A = Args.getLastArg(options::OPT_client__name)) ||
295 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
296 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
297 (A = Args.getLastArg(options::OPT_private__bundle)))
298 D.
Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
301 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
302 "-dylib_compatibility_version");
303 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
304 "-dylib_current_version");
306 AddMachOArch(Args, CmdArgs);
308 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
309 "-dylib_install_name");
312 Args.AddLastArg(CmdArgs, options::OPT_all__load);
313 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
314 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
316 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
317 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
318 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
319 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
320 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
321 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
322 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
323 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
324 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
325 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
326 Args.AddAllArgs(CmdArgs, options::OPT_init);
331 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
332 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
333 Args.AddLastArg(CmdArgs, options::OPT_single__module);
334 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
335 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
338 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
339 options::OPT_fno_pie, options::OPT_fno_PIE)) {
340 if (A->getOption().matches(options::OPT_fpie) ||
341 A->getOption().matches(options::OPT_fPIE))
342 CmdArgs.push_back(
"-pie");
344 CmdArgs.push_back(
"-no_pie");
351 CmdArgs.push_back(
"-bitcode_bundle");
353 CmdArgs.push_back(
"-bitcode_process_mode");
354 CmdArgs.push_back(
"marker");
357 D.
Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
360 Args.AddLastArg(CmdArgs, options::OPT_prebind);
361 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
362 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
363 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
364 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
365 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
366 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
367 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
368 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
369 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
370 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
371 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
372 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
373 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
374 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
375 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
381 CmdArgs.push_back(
"-syslibroot");
382 CmdArgs.push_back(C.
getArgs().MakeArgString(sysroot));
383 }
else if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
384 CmdArgs.push_back(
"-syslibroot");
385 CmdArgs.push_back(A->getValue());
388 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
389 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
390 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
391 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
392 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
393 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
394 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
395 Args.AddAllArgs(CmdArgs, options::OPT_y);
396 Args.AddLastArg(CmdArgs, options::OPT_w);
397 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
398 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
399 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
400 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
401 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
402 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
403 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
404 Args.AddLastArg(CmdArgs, options::OPT_whyload);
405 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
406 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
407 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
408 Args.AddLastArg(CmdArgs, options::OPT_Mach);
414 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
417 return Args.hasArg(options::OPT_fobjc_link_runtime);
424 const char *LinkingOutput)
const {
425 assert(Output.
getType() == types::TY_Image &&
"Invalid linker output type.");
431 llvm::opt::ArgStringList InputFileList;
436 ArgStringList CmdArgs;
439 if (Args.hasArg(options::OPT_ccc_arcmt_check,
440 options::OPT_ccc_arcmt_migrate)) {
441 for (
const auto &Arg : Args)
444 Args.MakeArgString(getToolChain().GetProgramPath(
"touch"));
446 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs,
None));
452 AddLinkArgs(C, Args, CmdArgs, Inputs);
455 if (Args.hasFlag(options::OPT_fsave_optimization_record,
456 options::OPT_fno_save_optimization_record,
false)) {
457 CmdArgs.push_back(
"-mllvm");
458 CmdArgs.push_back(
"-lto-pass-remarks-output");
459 CmdArgs.push_back(
"-mllvm");
464 CmdArgs.push_back(Args.MakeArgString(F));
467 CmdArgs.push_back(
"-mllvm");
468 CmdArgs.push_back(
"-lto-pass-remarks-with-hotness");
474 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
475 options::OPT_Z_Flag, options::OPT_u_Group,
476 options::OPT_e, options::OPT_r});
481 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
482 CmdArgs.push_back(
"-ObjC");
484 CmdArgs.push_back(
"-o");
487 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
488 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
493 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
494 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
495 "libclang_rt.safestack_osx.a",
499 Args.AddAllArgs(CmdArgs, options::OPT_L);
504 for (
const auto &II : Inputs) {
505 if (!II.isFilename()) {
510 if (InputFileList.size() > 0)
516 InputFileList.push_back(II.getFilename());
519 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
523 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
525 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
527 CmdArgs.push_back(
"-framework");
528 CmdArgs.push_back(
"Foundation");
530 CmdArgs.push_back(
"-lobjc");
534 CmdArgs.push_back(
"-arch_multiple");
535 CmdArgs.push_back(
"-final_output");
536 CmdArgs.push_back(LinkingOutput);
539 if (Args.hasArg(options::OPT_fnested_functions))
540 CmdArgs.push_back(
"-allow_stack_execute");
542 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
544 if (
unsigned Parallelism =
546 CmdArgs.push_back(
"-mllvm");
548 Args.MakeArgString(Twine(
"-threads=") + llvm::to_string(Parallelism)));
551 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
552 if (getToolChain().getDriver().CCCIsCXX())
553 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
558 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
561 Args.ClaimAllArgs(options::OPT_pthread);
562 Args.ClaimAllArgs(options::OPT_pthreads);
565 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
569 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
570 Args.AddAllArgs(CmdArgs, options::OPT_F);
573 for (
const Arg *A : Args.filtered(options::OPT_iframework))
574 CmdArgs.push_back(Args.MakeArgString(std::string(
"-F") + A->getValue()));
576 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
577 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
578 if (A->getValue() == StringRef(
"Accelerate")) {
579 CmdArgs.push_back(
"-framework");
580 CmdArgs.push_back(
"Accelerate");
585 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
586 std::unique_ptr<Command> Cmd =
587 llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs);
588 Cmd->setInputFileList(std::move(InputFileList));
596 const char *LinkingOutput)
const {
597 ArgStringList CmdArgs;
599 CmdArgs.push_back(
"-create");
600 assert(Output.
isFilename() &&
"Unexpected lipo output.");
602 CmdArgs.push_back(
"-output");
605 for (
const auto &II : Inputs) {
606 assert(II.isFilename() &&
"Unexpected lipo input.");
607 CmdArgs.push_back(II.getFilename());
610 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(
"lipo"));
611 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
618 const char *LinkingOutput)
const {
619 ArgStringList CmdArgs;
621 CmdArgs.push_back(
"-o");
624 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
626 assert(Input.isFilename() &&
"Unexpected dsymutil input.");
627 CmdArgs.push_back(Input.getFilename());
630 Args.MakeArgString(getToolChain().GetProgramPath(
"dsymutil"));
631 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
638 const char *LinkingOutput)
const {
639 ArgStringList CmdArgs;
640 CmdArgs.push_back(
"--verify");
641 CmdArgs.push_back(
"--debug-info");
642 CmdArgs.push_back(
"--eh-frame");
643 CmdArgs.push_back(
"--quiet");
645 assert(Inputs.size() == 1 &&
"Unable to handle multiple inputs.");
647 assert(Input.isFilename() &&
"Unexpected verify input");
650 CmdArgs.push_back(Input.getFilename());
653 Args.MakeArgString(getToolChain().GetProgramPath(
"dwarfdump"));
654 C.
addCommand(llvm::make_unique<Command>(JA, *
this, Exec, CmdArgs, Inputs));
657 MachO::MachO(
const Driver &D,
const llvm::Triple &Triple,
const ArgList &Args)
667 :
MachO(D, Triple, Args), TargetInitialized(
false),
668 CudaInstallation(D, Triple, Args) {}
674 if (Ty == types::TY_PP_Asm)
675 return types::TY_Asm;
716 ArgStringList &CC1Args)
const {
725 return llvm::StringSwitch<const char *>(Arch)
726 .Case(
"armv6k",
"armv6")
727 .Case(
"armv6m",
"armv6m")
728 .Case(
"armv5tej",
"armv5")
729 .Case(
"xscale",
"xscale")
730 .Case(
"armv4t",
"armv4t")
731 .Case(
"armv7",
"armv7")
732 .Cases(
"armv7a",
"armv7-a",
"armv7")
733 .Cases(
"armv7r",
"armv7-r",
"armv7")
734 .Cases(
"armv7em",
"armv7e-m",
"armv7em")
735 .Cases(
"armv7k",
"armv7-k",
"armv7k")
736 .Cases(
"armv7m",
"armv7-m",
"armv7m")
737 .Cases(
"armv7s",
"armv7-s",
"armv7s")
742 unsigned ArchKind = llvm::ARM::parseCPUArch(CPU);
743 if (ArchKind == llvm::ARM::AK_INVALID)
745 StringRef Arch = llvm::ARM::getArchName(ArchKind);
749 if (Arch.startswith(
"armv5"))
750 Arch = Arch.substr(0, 5);
752 else if (Arch.startswith(
"armv6") && !Arch.endswith(
"6m"))
753 Arch = Arch.substr(0, 5);
755 else if (Arch.endswith(
"v7a"))
756 Arch = Arch.substr(0, 5);
765 case llvm::Triple::aarch64:
768 case llvm::Triple::thumb:
769 case llvm::Triple::arm:
770 if (
const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
774 if (
const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
793 return Triple.getTriple();
805 Triple.setOSName(Str);
807 return Triple.getTriple();
819 return Dsymutil.get();
823 return VerifyDebug.get();
837 :
Darwin(D, Triple, Args) {}
844 CC1Args.push_back(
"-Wdeprecated-objc-isa-usage");
845 CC1Args.push_back(
"-Werror=deprecated-objc-isa-usage");
850 CC1Args.push_back(
"-Werror=implicit-function-declaration");
855 ArgStringList &CmdArgs)
const {
866 CmdArgs.push_back(
"-force_load");
868 llvm::sys::path::remove_filename(P);
869 llvm::sys::path::remove_filename(P);
870 llvm::sys::path::append(P,
"lib",
"arc",
"libarclite_");
873 P +=
"watchsimulator";
877 P +=
"appletvsimulator";
881 P +=
"iphonesimulator";
888 CmdArgs.push_back(Args.MakeArgString(P));
900 StringRef DarwinLibName,
bool AlwaysLink,
901 bool IsEmbedded,
bool AddRPath)
const {
903 llvm::sys::path::append(Dir,
"lib", IsEmbedded ?
"macho_embedded" :
"darwin");
906 llvm::sys::path::append(P, DarwinLibName);
911 if (AlwaysLink ||
getVFS().exists(P))
912 CmdArgs.push_back(Args.MakeArgString(P));
919 assert(DarwinLibName.endswith(
".dylib") &&
"must be a dynamic library");
923 CmdArgs.push_back(
"-rpath");
924 CmdArgs.push_back(
"@executable_path");
928 CmdArgs.push_back(
"-rpath");
929 CmdArgs.push_back(Args.MakeArgString(Dir));
936 StringRef ParentDir = llvm::sys::path::parent_path(
getDriver().InstalledDir);
938 llvm::sys::path::append(P,
"lib",
"libLLVMFuzzer.a");
939 CmdArgs.push_back(Args.MakeArgString(P));
947 case DarwinPlatformKind::MacOS:
949 case DarwinPlatformKind::IPhoneOS:
950 case DarwinPlatformKind::IPhoneOSSimulator:
952 case DarwinPlatformKind::TvOS:
953 case DarwinPlatformKind::TvOSSimulator:
955 case DarwinPlatformKind::WatchOS:
956 case DarwinPlatformKind::WatchOSSimulator:
959 llvm_unreachable(
"Unsupported platform");
964 llvm::sys::path::const_iterator SDKDir;
965 auto BeginSDK = llvm::sys::path::begin(isysroot);
966 auto EndSDK = llvm::sys::path::end(isysroot);
967 for (
auto IT = BeginSDK; IT != EndSDK; ++IT) {
969 if (SDK.endswith(
".sdk"))
970 return SDK.slice(0, SDK.size() - 4);
977 case DarwinPlatformKind::MacOS:
979 case DarwinPlatformKind::IPhoneOS:
981 case DarwinPlatformKind::IPhoneOSSimulator:
983 case DarwinPlatformKind::TvOS:
985 case DarwinPlatformKind::TvOSSimulator:
987 case DarwinPlatformKind::WatchOS:
989 case DarwinPlatformKind::WatchOSSimulator:
992 llvm_unreachable(
"Unsupported platform");
996 ArgStringList &CmdArgs)
const {
1004 void DarwinClang::AddLinkSanitizerLibArgs(
const ArgList &Args,
1005 ArgStringList &CmdArgs,
1006 StringRef Sanitizer)
const {
1009 (Twine(
"libclang_rt.") + Sanitizer +
"_" +
1016 const ArgList &Args)
const {
1017 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1018 StringRef
Value = A->getValue();
1019 if (Value !=
"compiler-rt")
1020 getDriver().
Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1021 << Value <<
"darwin";
1028 ArgStringList &CmdArgs)
const {
1034 if (Args.hasArg(options::OPT_static) ||
1035 Args.hasArg(options::OPT_fapple_kext) ||
1036 Args.hasArg(options::OPT_mkernel))
1042 if (
const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1043 getDriver().
Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1049 AddLinkSanitizerLibArgs(Args, CmdArgs,
"asan");
1051 AddLinkSanitizerLibArgs(Args, CmdArgs,
"lsan");
1053 AddLinkSanitizerLibArgs(Args, CmdArgs,
"ubsan");
1055 AddLinkSanitizerLibArgs(Args, CmdArgs,
"tsan");
1056 if (Sanitize.
needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib))
1061 (Twine(
"libclang_rt.stats_client_") + OS +
".a").str(),
1063 AddLinkSanitizerLibArgs(Args, CmdArgs,
"stats");
1066 AddLinkSanitizerLibArgs(Args, CmdArgs,
"esan");
1070 CmdArgs.push_back(
"-lSystem");
1085 CmdArgs.push_back(
"-lgcc_s.1");
1094 CmdArgs.push_back(
"-lgcc_s.10.4");
1096 CmdArgs.push_back(
"-lgcc_s.10.5");
1126 unsigned Major, Minor, Micro;
1127 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1128 if (!SystemTriple.isMacOSX())
1129 return MacOSSDKVersion;
1130 SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1135 return MacOSSDKVersion;
1137 if (SDKVersion > SystemVersion)
1139 return MacOSSDKVersion;
1142 void Darwin::AddDeploymentTarget(DerivedArgList &Args)
const {
1148 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1151 getDriver().
Diag(clang::diag::warn_missing_sysroot) << A->getValue();
1153 if (
char *env = ::getenv(
"SDKROOT")) {
1156 if (llvm::sys::path::is_absolute(env) &&
getVFS().exists(env) &&
1157 StringRef(env) !=
"/") {
1158 Args.append(Args.MakeSeparateArg(
1159 nullptr, Opts.getOption(options::OPT_isysroot), env));
1164 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
1165 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ,
1166 options::OPT_mios_simulator_version_min_EQ);
1168 Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1169 options::OPT_mtvos_simulator_version_min_EQ);
1170 Arg *WatchOSVersion =
1171 Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1172 options::OPT_mwatchos_simulator_version_min_EQ);
1174 unsigned Major, Minor, Micro;
1179 std::string ExplicitIOSDeploymentTargetStr;
1182 ExplicitIOSDeploymentTargetStr = iOSVersion->getAsString(Args);
1186 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ) ||
1187 Args.hasArg(options::OPT_mtvos_simulator_version_min_EQ) ||
1188 Args.hasArg(options::OPT_mwatchos_simulator_version_min_EQ))
1189 Args.append(Args.MakeSeparateArg(
nullptr, Opts.getOption(options::OPT_D),
1190 " __APPLE_EMBEDDED_SIMULATOR__=1"));
1192 if (OSXVersion && (iOSVersion || TvOSVersion || WatchOSVersion)) {
1194 << OSXVersion->getAsString(Args)
1195 << (iOSVersion ? iOSVersion :
1196 TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
1197 iOSVersion = TvOSVersion = WatchOSVersion =
nullptr;
1198 }
else if (iOSVersion && (TvOSVersion || WatchOSVersion)) {
1200 << iOSVersion->getAsString(Args)
1201 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
1202 TvOSVersion = WatchOSVersion =
nullptr;
1203 }
else if (TvOSVersion && WatchOSVersion) {
1205 << TvOSVersion->getAsString(Args)
1206 << WatchOSVersion->getAsString(Args);
1207 WatchOSVersion =
nullptr;
1208 }
else if (!OSXVersion && !iOSVersion && !TvOSVersion && !WatchOSVersion) {
1211 std::string OSXTarget;
1212 std::string iOSTarget;
1213 std::string TvOSTarget;
1214 std::string WatchOSTarget;
1216 if (
char *env = ::getenv(
"MACOSX_DEPLOYMENT_TARGET"))
1218 if (
char *env = ::getenv(
"IPHONEOS_DEPLOYMENT_TARGET"))
1220 if (
char *env = ::getenv(
"TVOS_DEPLOYMENT_TARGET"))
1222 if (
char *env = ::getenv(
"WATCHOS_DEPLOYMENT_TARGET"))
1223 WatchOSTarget = env;
1225 if (!iOSTarget.empty())
1226 ExplicitIOSDeploymentTargetStr =
1227 std::string(
"IPHONEOS_DEPLOYMENT_TARGET=") + iOSTarget;
1232 if (OSXTarget.empty() && iOSTarget.empty() && WatchOSTarget.empty() &&
1233 TvOSTarget.empty() && Args.hasArg(options::OPT_isysroot)) {
1234 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1235 StringRef isysroot = A->getValue();
1237 if (SDK.size() > 0) {
1240 size_t StartVer = SDK.find_first_of(
"0123456789");
1241 size_t EndVer = SDK.find_last_of(
"0123456789");
1242 if (StartVer != StringRef::npos && EndVer > StartVer) {
1243 StringRef Version = SDK.slice(StartVer, EndVer + 1);
1244 if (SDK.startswith(
"iPhoneOS") ||
1245 SDK.startswith(
"iPhoneSimulator"))
1246 iOSTarget = Version;
1247 else if (SDK.startswith(
"MacOSX"))
1249 else if (SDK.startswith(
"WatchOS") ||
1250 SDK.startswith(
"WatchSimulator"))
1251 WatchOSTarget = Version;
1252 else if (SDK.startswith(
"AppleTVOS") ||
1253 SDK.startswith(
"AppleTVSimulator"))
1254 TvOSTarget = Version;
1262 if (OSXTarget.empty() && iOSTarget.empty() && TvOSTarget.empty() &&
1263 WatchOSTarget.empty()) {
1264 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
1267 if (Args.hasArg(options::OPT_target) && !Args.hasArg(options::OPT_arch)) {
1271 if (MachOArchName ==
"armv7" || MachOArchName ==
"armv7s" ||
1272 MachOArchName ==
"arm64")
1273 OSTy = llvm::Triple::IOS;
1274 else if (MachOArchName ==
"armv7k")
1275 OSTy = llvm::Triple::WatchOS;
1276 else if (MachOArchName !=
"armv6m" && MachOArchName !=
"armv7m" &&
1277 MachOArchName !=
"armv7em")
1278 OSTy = llvm::Triple::MacOSX;
1282 if (OSTy != llvm::Triple::UnknownOS) {
1283 unsigned Major, Minor, Micro;
1284 std::string *OSTarget;
1287 case llvm::Triple::Darwin:
1288 case llvm::Triple::MacOSX:
1289 if (!
getTriple().getMacOSXVersion(Major, Minor, Micro))
1292 OSTarget = &OSXTarget;
1294 case llvm::Triple::IOS:
1295 getTriple().getiOSVersion(Major, Minor, Micro);
1296 OSTarget = &iOSTarget;
1298 case llvm::Triple::TvOS:
1299 getTriple().getOSVersion(Major, Minor, Micro);
1300 OSTarget = &TvOSTarget;
1302 case llvm::Triple::WatchOS:
1303 getTriple().getWatchOSVersion(Major, Minor, Micro);
1304 OSTarget = &WatchOSTarget;
1307 llvm_unreachable(
"Unexpected OS type");
1311 llvm::raw_string_ostream(*OSTarget) << Major <<
'.' << Minor <<
'.'
1317 if (!WatchOSTarget.empty() && (!iOSTarget.empty() || !TvOSTarget.empty())) {
1318 getDriver().
Diag(diag::err_drv_conflicting_deployment_targets)
1319 <<
"WATCHOS_DEPLOYMENT_TARGET"
1320 << (!iOSTarget.empty() ?
"IPHONEOS_DEPLOYMENT_TARGET" :
1321 "TVOS_DEPLOYMENT_TARGET");
1325 if (!TvOSTarget.empty() && !iOSTarget.empty()) {
1326 getDriver().
Diag(diag::err_drv_conflicting_deployment_targets)
1327 <<
"TVOS_DEPLOYMENT_TARGET"
1328 <<
"IPHONEOS_DEPLOYMENT_TARGET";
1333 if (!OSXTarget.empty() && (!iOSTarget.empty() ||
1334 !WatchOSTarget.empty() ||
1335 !TvOSTarget.empty())) {
1336 if (
getTriple().getArch() == llvm::Triple::arm ||
1337 getTriple().getArch() == llvm::Triple::aarch64 ||
1338 getTriple().getArch() == llvm::Triple::thumb)
1341 iOSTarget = WatchOSTarget = TvOSTarget =
"";
1344 if (!OSXTarget.empty()) {
1345 const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
1346 OSXVersion = Args.MakeJoinedArg(
nullptr, O, OSXTarget);
1347 Args.append(OSXVersion);
1348 }
else if (!iOSTarget.empty()) {
1349 const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
1350 iOSVersion = Args.MakeJoinedArg(
nullptr, O, iOSTarget);
1351 Args.append(iOSVersion);
1352 }
else if (!TvOSTarget.empty()) {
1353 const Option O = Opts.getOption(options::OPT_mtvos_version_min_EQ);
1354 TvOSVersion = Args.MakeJoinedArg(
nullptr, O, TvOSTarget);
1355 Args.append(TvOSVersion);
1356 }
else if (!WatchOSTarget.empty()) {
1357 const Option O = Opts.getOption(options::OPT_mwatchos_version_min_EQ);
1358 WatchOSVersion = Args.MakeJoinedArg(
nullptr, O, WatchOSTarget);
1359 Args.append(WatchOSVersion);
1366 else if (iOSVersion)
1368 else if (TvOSVersion)
1370 else if (WatchOSVersion)
1373 llvm_unreachable(
"Unable to infer Darwin variant");
1376 if (Platform ==
MacOS) {
1377 assert((!iOSVersion && !TvOSVersion && !WatchOSVersion) &&
1378 "Unknown target platform!");
1381 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
1383 << OSXVersion->getAsString(Args);
1385 assert(iOSVersion &&
"Unknown target platform!");
1388 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1390 << iOSVersion->getAsString(Args);
1393 if (
getTriple().isArch32Bit() && Major >= 11) {
1395 if (!ExplicitIOSDeploymentTargetStr.empty()) {
1397 << ExplicitIOSDeploymentTargetStr;
1405 }
else if (Platform ==
TvOS) {
1407 Micro, HadExtra) || HadExtra ||
1408 Major >= 100 || Minor >= 100 || Micro >= 100)
1410 << TvOSVersion->getAsString(Args);
1411 }
else if (Platform ==
WatchOS) {
1413 Micro, HadExtra) || HadExtra ||
1414 Major >= 10 || Minor >= 100 || Micro >= 100)
1416 << WatchOSVersion->getAsString(Args);
1418 llvm_unreachable(
"unknown kind of Darwin platform");
1431 setTarget(Platform, Major, Minor, Micro);
1433 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1435 if (SDK.size() > 0) {
1436 size_t StartVer = SDK.find_first_of(
"0123456789");
1437 StringRef SDKName = SDK.slice(0, StartVer);
1446 ArgStringList &CmdArgs)
const {
1451 CmdArgs.push_back(
"-lc++");
1461 if (
const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1463 llvm::sys::path::append(P,
"usr",
"lib",
"libstdc++.dylib");
1465 if (!
getVFS().exists(P)) {
1466 llvm::sys::path::remove_filename(P);
1467 llvm::sys::path::append(P,
"libstdc++.6.dylib");
1468 if (
getVFS().exists(P)) {
1469 CmdArgs.push_back(Args.MakeArgString(P));
1480 CmdArgs.push_back(
"/usr/lib/libstdc++.6.dylib");
1485 CmdArgs.push_back(
"-lstdc++");
1491 ArgStringList &CmdArgs)
const {
1497 llvm::sys::path::append(P,
"lib",
"darwin");
1501 llvm::sys::path::append(P,
"libclang_rt.cc_kext_watchos.a");
1503 llvm::sys::path::append(P,
"libclang_rt.cc_kext_tvos.a");
1505 llvm::sys::path::append(P,
"libclang_rt.cc_kext_ios.a");
1507 llvm::sys::path::append(P,
"libclang_rt.cc_kext.a");
1513 CmdArgs.push_back(Args.MakeArgString(P));
1517 StringRef BoundArch,
1519 DerivedArgList *DAL =
new DerivedArgList(Args.getBaseArgs());
1529 for (Arg *A : Args) {
1530 if (A->getOption().matches(options::OPT_Xarch__)) {
1533 llvm::Triple::ArchType XarchArch =
1535 if (!(XarchArch ==
getArch() ||
1536 (!BoundArch.empty() &&
1541 Arg *OriginalArg = A;
1542 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1543 unsigned Prev = Index;
1544 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1554 if (!XarchArg || Index > Prev + 1) {
1555 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1556 << A->getAsString(Args);
1559 getDriver().
Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
1560 << A->getAsString(Args);
1564 XarchArg->setBaseArg(A);
1566 A = XarchArg.release();
1567 DAL->AddSynthesizedArg(A);
1574 for (
const char *
Value : A->getValues()) {
1575 DAL->AddSeparateArg(
1576 OriginalArg, Opts.getOption(options::OPT_Zlinker_input),
Value);
1590 case options::OPT_mkernel:
1591 case options::OPT_fapple_kext:
1593 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
1596 case options::OPT_dependency_file:
1597 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
1600 case options::OPT_gfull:
1601 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1603 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
1606 case options::OPT_gused:
1607 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1609 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
1612 case options::OPT_shared:
1613 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
1616 case options::OPT_fconstant_cfstrings:
1617 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
1620 case options::OPT_fno_constant_cfstrings:
1621 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
1624 case options::OPT_Wnonportable_cfstrings:
1626 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
1629 case options::OPT_Wno_nonportable_cfstrings:
1631 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
1634 case options::OPT_fpascal_strings:
1635 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
1638 case options::OPT_fno_pascal_strings:
1639 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
1644 if (
getTriple().getArch() == llvm::Triple::x86 ||
1645 getTriple().getArch() == llvm::Triple::x86_64)
1646 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
1647 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_mtune_EQ),
1652 if (!BoundArch.empty()) {
1653 StringRef
Name = BoundArch;
1654 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
1655 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
1661 else if (Name ==
"ppc601")
1662 DAL->AddJoinedArg(
nullptr, MCpu,
"601");
1663 else if (Name ==
"ppc603")
1664 DAL->AddJoinedArg(
nullptr, MCpu,
"603");
1665 else if (Name ==
"ppc604")
1666 DAL->AddJoinedArg(
nullptr, MCpu,
"604");
1667 else if (Name ==
"ppc604e")
1668 DAL->AddJoinedArg(
nullptr, MCpu,
"604e");
1669 else if (Name ==
"ppc750")
1670 DAL->AddJoinedArg(
nullptr, MCpu,
"750");
1671 else if (Name ==
"ppc7400")
1672 DAL->AddJoinedArg(
nullptr, MCpu,
"7400");
1673 else if (Name ==
"ppc7450")
1674 DAL->AddJoinedArg(
nullptr, MCpu,
"7450");
1675 else if (Name ==
"ppc970")
1676 DAL->AddJoinedArg(
nullptr, MCpu,
"970");
1678 else if (Name ==
"ppc64" || Name ==
"ppc64le")
1679 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
1681 else if (Name ==
"i386")
1683 else if (Name ==
"i486")
1684 DAL->AddJoinedArg(
nullptr, MArch,
"i486");
1685 else if (Name ==
"i586")
1686 DAL->AddJoinedArg(
nullptr, MArch,
"i586");
1687 else if (Name ==
"i686")
1688 DAL->AddJoinedArg(
nullptr, MArch,
"i686");
1689 else if (Name ==
"pentium")
1690 DAL->AddJoinedArg(
nullptr, MArch,
"pentium");
1691 else if (Name ==
"pentium2")
1692 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
1693 else if (Name ==
"pentpro")
1694 DAL->AddJoinedArg(
nullptr, MArch,
"pentiumpro");
1695 else if (Name ==
"pentIIm3")
1696 DAL->AddJoinedArg(
nullptr, MArch,
"pentium2");
1698 else if (Name ==
"x86_64")
1699 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
1700 else if (Name ==
"x86_64h") {
1701 DAL->AddFlagArg(
nullptr, Opts.getOption(options::OPT_m64));
1702 DAL->AddJoinedArg(
nullptr, MArch,
"x86_64h");
1705 else if (Name ==
"arm")
1706 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
1707 else if (Name ==
"armv4t")
1708 DAL->AddJoinedArg(
nullptr, MArch,
"armv4t");
1709 else if (Name ==
"armv5")
1710 DAL->AddJoinedArg(
nullptr, MArch,
"armv5tej");
1711 else if (Name ==
"xscale")
1712 DAL->AddJoinedArg(
nullptr, MArch,
"xscale");
1713 else if (Name ==
"armv6")
1714 DAL->AddJoinedArg(
nullptr, MArch,
"armv6k");
1715 else if (Name ==
"armv6m")
1716 DAL->AddJoinedArg(
nullptr, MArch,
"armv6m");
1717 else if (Name ==
"armv7")
1718 DAL->AddJoinedArg(
nullptr, MArch,
"armv7a");
1719 else if (Name ==
"armv7em")
1720 DAL->AddJoinedArg(
nullptr, MArch,
"armv7em");
1721 else if (Name ==
"armv7k")
1722 DAL->AddJoinedArg(
nullptr, MArch,
"armv7k");
1723 else if (Name ==
"armv7m")
1724 DAL->AddJoinedArg(
nullptr, MArch,
"armv7m");
1725 else if (Name ==
"armv7s")
1726 DAL->AddJoinedArg(
nullptr, MArch,
"armv7s");
1733 ArgStringList &CmdArgs)
const {
1742 CompilerRT += Args.hasArg(options::OPT_fPIC) ?
"_pic.a" :
"_static.a";
1760 llvm_unreachable(
"Unsupported platform");
1764 llvm::opt::ArgStringList &CC1Args,
1767 CC1Args.push_back(
"-faligned-alloc-unavailable");
1774 DerivedArgList *DAL =
1779 if (BoundArch.empty())
1785 AddDeploymentTarget(*DAL);
1793 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
1796 if (A->getOption().getID() != options::OPT_mkernel &&
1797 A->getOption().getID() != options::OPT_fapple_kext)
1799 assert(it != ie &&
"unexpected argument translation");
1801 assert(A->getOption().getID() == options::OPT_static &&
1802 "missing expected -static argument");
1808 if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
1810 DAL->AddJoinedArg(
nullptr, Opts.getOption(options::OPT_stdlib_EQ),
1823 if (where != StringRef()) {
1824 getDriver().
Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
1829 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
1830 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
1831 options::OPT_fno_omit_frame_pointer,
false))
1832 getDriver().
Diag(clang::diag::warn_drv_unsupported_opt_for_target)
1833 <<
"-fomit-frame-pointer" << BoundArch;
1842 return getArch() == llvm::Triple::x86_64 ||
1844 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
1849 if (
const char *
S = ::getenv(
"RC_DEBUG_OPTIONS"))
1850 return S[0] !=
'\0';
1862 return !Triple.isWatchABI();
1877 return (
getArch() == llvm::Triple::x86_64 ||
1878 getArch() == llvm::Triple::aarch64);
1883 return getArch() == llvm::Triple::x86 ||
getArch() == llvm::Triple::x86_64;
1887 ArgStringList &CmdArgs)
const {
1891 CmdArgs.push_back(
"-watchos_version_min");
1893 CmdArgs.push_back(
"-watchos_simulator_version_min");
1895 CmdArgs.push_back(
"-tvos_version_min");
1897 CmdArgs.push_back(
"-tvos_simulator_version_min");
1899 CmdArgs.push_back(
"-ios_simulator_version_min");
1901 CmdArgs.push_back(
"-iphoneos_version_min");
1904 CmdArgs.push_back(
"-macosx_version_min");
1907 CmdArgs.push_back(Args.MakeArgString(TargetVersion.
getAsString()));
1911 ArgStringList &CmdArgs)
const {
1913 if (Args.hasArg(options::OPT_dynamiclib)) {
1921 CmdArgs.push_back(
"-ldylib1.o");
1924 CmdArgs.push_back(
"-ldylib1.o");
1926 CmdArgs.push_back(
"-ldylib1.10.5.o");
1929 if (Args.hasArg(options::OPT_bundle)) {
1930 if (!Args.hasArg(options::OPT_static)) {
1938 CmdArgs.push_back(
"-lbundle1.o");
1941 CmdArgs.push_back(
"-lbundle1.o");
1946 if (Args.hasArg(options::OPT_static) ||
1947 Args.hasArg(options::OPT_object) ||
1948 Args.hasArg(options::OPT_preload)) {
1949 CmdArgs.push_back(
"-lgcrt0.o");
1951 CmdArgs.push_back(
"-lgcrt1.o");
1961 CmdArgs.push_back(
"-no_new_main");
1963 if (Args.hasArg(options::OPT_static) ||
1964 Args.hasArg(options::OPT_object) ||
1965 Args.hasArg(options::OPT_preload)) {
1966 CmdArgs.push_back(
"-lcrt0.o");
1974 if (
getArch() == llvm::Triple::aarch64)
1977 CmdArgs.push_back(
"-lcrt1.o");
1979 CmdArgs.push_back(
"-lcrt1.3.1.o");
1982 CmdArgs.push_back(
"-lcrt1.o");
1984 CmdArgs.push_back(
"-lcrt1.10.5.o");
1986 CmdArgs.push_back(
"-lcrt1.10.6.o");
1998 const char *Str = Args.MakeArgString(
GetFilePath(
"crt3.o"));
1999 CmdArgs.push_back(Str);
2013 const bool IsX86_64 =
getTriple().getArch() == llvm::Triple::x86_64;
2015 Res |= SanitizerKind::Address;
2016 Res |= SanitizerKind::Leak;
2017 Res |= SanitizerKind::Fuzzer;
2020 Res |= SanitizerKind::Vptr;
2021 Res |= SanitizerKind::SafeStack;
2023 Res |= SanitizerKind::Thread;
2026 Res |= SanitizerKind::Thread;
static bool GetReleaseVersion(StringRef Str, unsigned &Major, unsigned &Minor, unsigned &Micro, bool &HadExtra)
GetReleaseVersion - Parse (([0-9]+)(.
const Driver & getDriver() const
Represents a version number in the form major[.minor[.subminor[.build]]].
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.
Defines types useful for describing an Objective-C runtime.
The base class of the type hierarchy.
const llvm::opt::OptTable & getOpts() const
DiagnosticBuilder Diag(unsigned DiagID) const
types::ID getType() 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...
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
std::string Dir
The path the driver executable was in, as invoked from the command line.
ActionClass getKind() const
Action - Represent an abstract compilation step to perform.
std::string getAsString() const
Retrieve a string representation of the version number.
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
const llvm::opt::DerivedArgList & getArgs() const
bool embedBitcodeEnabled() 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.
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
bool needsUbsanRt() const
static const char * ArmMachOArchNameCPU(StringRef CPU)
void addCommand(std::unique_ptr< Command > C)
bool embedBitcodeMarkerOnly() const
static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion)
Returns the most appropriate macOS target version for the current process.
void print(raw_ostream &OS) const
Print information about the detected CUDA installation.
bool hasSubscripting() const
Does this runtime directly support the subscripting methods?
static const char * ArmMachOArchName(StringRef Arch)
The basic abstraction for the target Objective-C runtime.
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.
ID lookupTypeForExtension(llvm::StringRef Ext)
lookupTypeForExtension - Lookup the type to use for the file extension Ext.
StringRef getSysRoot() const
Returns the sysroot path.
bool isUsingLTO() const
Returns true if we are performing any kind of LTO.
bool needsStatsRt() const
const char * addTempFile(const char *Name)
addTempFile - Add a file to remove on exit, and returns its argument.
static bool isObjCRuntimeLinked(const ArgList &Args)
Determine whether we are linking the ObjC runtime.
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const