1 //===--- Darwin.cpp - Darwin Tool and ToolChain Implementations -*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
12 #include "CommonArgs.h"
13 #include "clang/Basic/AlignedAllocation.h"
14 #include "clang/Basic/ObjCRuntime.h"
15 #include "clang/Basic/VirtualFileSystem.h"
16 #include "clang/Driver/Compilation.h"
17 #include "clang/Driver/Driver.h"
18 #include "clang/Driver/DriverDiagnostic.h"
19 #include "clang/Driver/Options.h"
20 #include "clang/Driver/SanitizerArgs.h"
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"
26 #include <cstdlib> // ::getenv
28 using namespace clang::driver;
29 using namespace clang::driver::tools;
30 using namespace clang::driver::toolchains;
31 using namespace clang;
32 using namespace llvm::opt;
34 llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
35 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
36 // archs which Darwin doesn't use.
38 // The matching this routine does is fairly pointless, since it is neither the
39 // complete architecture list, nor a reasonable subset. The problem is that
40 // historically the driver driver accepts this and also ties its -march=
41 // handling to the architecture name, so we need to be careful before removing
44 // This code must be kept in sync with Clang's Darwin specific argument
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)
55 // This is derived from the driver driver.
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);
69 void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
70 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
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);
84 void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
85 const InputInfo &Output,
86 const InputInfoList &Inputs,
88 const char *LinkingOutput) const {
89 ArgStringList CmdArgs;
91 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
92 const InputInfo &Input = Inputs[0];
94 // Determine the original source input.
95 const Action *SourceAction = &JA;
96 while (SourceAction->getKind() != Action::InputClass) {
97 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
98 SourceAction = SourceAction->getInputs()[0];
101 // If -fno-integrated-as is used add -Q to the darwin assember driver to make
102 // sure it runs its system assembler not clang's integrated assembler.
103 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
104 // FIXME: at run-time detect assembler capabilities or rely on version
105 // information forwarded by -target-assembler-version.
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");
112 // Forward -g, assuming we are dealing with an actual assembly file.
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");
121 // Derived from asm spec.
122 AddMachOArch(Args, CmdArgs);
124 // Use -force_cpusubtype_ALL on x86 by default.
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");
141 CmdArgs.push_back(Output.getFilename());
143 assert(Input.isFilename() && "Invalid input.");
144 CmdArgs.push_back(Input.getFilename());
146 // asm_final spec is empty.
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() {}
154 void darwin::MachOTool::AddMachOArch(const ArgList &Args,
155 ArgStringList &CmdArgs) const {
156 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
158 // Derived from darwin_arch spec.
159 CmdArgs.push_back("-arch");
160 CmdArgs.push_back(Args.MakeArgString(ArchName));
162 // FIXME: Is this needed anymore?
163 if (ArchName == "arm")
164 CmdArgs.push_back("-force_cpusubtype_ALL");
167 bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const {
168 // We only need to generate a temp path for LTO if we aren't compiling object
169 // files. When compiling source files, we run 'dsymutil' after linking. We
170 // don't run 'dsymutil' when compiling object files.
171 for (const auto &Input : Inputs)
172 if (Input.getType() != types::TY_Object)
178 /// \brief Pass -no_deduplicate to ld64 under certain conditions:
180 /// - Either -O0 or -O1 is explicitly specified
181 /// - No -O option is specified *and* this is a compile+link (implicit -O0)
183 /// Also do *not* add -no_deduplicate when no -O option is specified and this
184 /// is just a link (we can't imply -O0)
185 static bool shouldLinkerNotDedup(bool IsLinkerOnlyAction, const ArgList &Args) {
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())
193 return false; // OPT_Ofast & OPT_O4
196 if (!IsLinkerOnlyAction) // Implicit -O0 for compile+linker only.
201 void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args,
202 ArgStringList &CmdArgs,
203 const InputInfoList &Inputs) const {
204 const Driver &D = getToolChain().getDriver();
205 const toolchains::MachO &MachOTC = getMachOToolChain();
207 unsigned Version[5] = {0, 0, 0, 0, 0};
208 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
209 if (!Driver::GetReleaseVersion(A->getValue(), Version))
210 D.Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
213 // Newer linkers support -demangle. Pass it if supported and not disabled by
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");
221 // If we are using App Extension restrictions, pass a flag to the linker
222 // telling it that the compiled code has been audited.
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()) {
228 // If we are using LTO, then automatically create a temporary file path for
229 // the linker to use, so that it's lifetime will extend past a possible
231 if (Version[0] >= 116 && NeedsTempPath(Inputs)) {
232 const char *TmpPath = C.getArgs().MakeArgString(
233 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
234 C.addTempFile(TmpPath);
235 CmdArgs.push_back("-object_path_lto");
236 CmdArgs.push_back(TmpPath);
240 // Use -lto_library option to specify the libLTO.dylib path. Try to find
241 // it in clang installed libraries. ld64 will only look at this argument
242 // when it actually uses LTO, so libLTO.dylib only needs to exist at link
243 // time if ld64 decides that it needs to use LTO.
244 // Since this is passed unconditionally, ld64 will never look for libLTO.dylib
245 // next to it. That's ok since ld64 using a libLTO.dylib not matching the
246 // clang version won't work anyways.
247 if (Version[0] >= 133) {
248 // Search for libLTO in <InstalledDir>/../lib/libLTO.dylib
249 StringRef P = llvm::sys::path::parent_path(D.Dir);
250 SmallString<128> LibLTOPath(P);
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));
257 // ld64 version 262 and above run the deduplicate pass by default.
258 if (Version[0] >= 262 && shouldLinkerNotDedup(C.getJobs().empty(), Args))
259 CmdArgs.push_back("-no_deduplicate");
261 // Derived from the "link" spec.
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)) {
266 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
267 // here. How do we wish to handle such things?
270 if (!Args.hasArg(options::OPT_dynamiclib)) {
271 AddMachOArch(Args, CmdArgs);
272 // FIXME: Why do this only on this path?
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);
316 if (MachOTC.isTargetIOSBased())
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);
329 // Add the deployment target.
330 MachOTC.addMinVersionArgs(Args, CmdArgs);
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");
348 // for embed-bitcode, use -bitcode_bundle in linker command
349 if (C.getDriver().embedBitcodeEnabled()) {
350 // Check if the toolchain supports bitcode build flow.
351 if (MachOTC.SupportsEmbeddedBitcode()) {
352 CmdArgs.push_back("-bitcode_bundle");
353 if (C.getDriver().embedBitcodeMarkerOnly() && Version[0] >= 278) {
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);
378 // Give --sysroot= preference, over the Apple specific behavior to also use
379 // --isysroot as the syslibroot.
380 StringRef sysroot = C.getSysRoot();
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);
412 /// \brief Determine whether we are linking the ObjC runtime.
413 static bool isObjCRuntimeLinked(const ArgList &Args) {
414 if (isObjCAutoRefCount(Args)) {
415 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
418 return Args.hasArg(options::OPT_fobjc_link_runtime);
421 void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,
422 const InputInfo &Output,
423 const InputInfoList &Inputs,
425 const char *LinkingOutput) const {
426 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
428 // If the number of arguments surpasses the system limits, we will encode the
429 // input files in a separate file, shortening the command line. To this end,
430 // build a list of input file names that can be passed via a file with the
431 // -filelist linker option.
432 llvm::opt::ArgStringList InputFileList;
434 // The logic here is derived from gcc's behavior; most of which
435 // comes from specs (starting with link_command). Consult gcc for
437 ArgStringList CmdArgs;
439 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
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"));
446 CmdArgs.push_back(Output.getFilename());
447 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, None));
451 // I'm not sure why this particular decomposition exists in gcc, but
452 // we follow suite for ease of comparison.
453 AddLinkArgs(C, Args, CmdArgs, Inputs);
455 // For LTO, pass the name of the optimization record file.
456 if (Args.hasFlag(options::OPT_fsave_optimization_record,
457 options::OPT_fno_save_optimization_record, false)) {
458 CmdArgs.push_back("-mllvm");
459 CmdArgs.push_back("-lto-pass-remarks-output");
460 CmdArgs.push_back("-mllvm");
463 F = Output.getFilename();
465 CmdArgs.push_back(Args.MakeArgString(F));
467 if (getLastProfileUseArg(Args)) {
468 CmdArgs.push_back("-mllvm");
469 CmdArgs.push_back("-lto-pass-remarks-with-hotness");
473 // It seems that the 'e' option is completely ignored for dynamic executables
474 // (the default), and with static executables, the last one wins, as expected.
475 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
476 options::OPT_Z_Flag, options::OPT_u_Group,
477 options::OPT_e, options::OPT_r});
479 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
480 // members of static archive libraries which implement Objective-C classes or
482 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
483 CmdArgs.push_back("-ObjC");
485 CmdArgs.push_back("-o");
486 CmdArgs.push_back(Output.getFilename());
488 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
489 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
491 // SafeStack requires its own runtime libraries
492 // These libraries should be linked first, to make sure the
493 // __safestack_init constructor executes before everything else
494 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
495 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
496 "libclang_rt.safestack_osx.a",
497 toolchains::Darwin::RLO_AlwaysLink);
500 Args.AddAllArgs(CmdArgs, options::OPT_L);
502 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
503 // Build the input file for -filelist (list of linker input files) in case we
505 for (const auto &II : Inputs) {
506 if (!II.isFilename()) {
507 // This is a linker input argument.
508 // We cannot mix input arguments and file names in a -filelist input, thus
509 // we prematurely stop our list (remaining files shall be passed as
511 if (InputFileList.size() > 0)
517 InputFileList.push_back(II.getFilename());
520 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
521 addOpenMPRuntime(CmdArgs, getToolChain(), Args);
523 if (isObjCRuntimeLinked(Args) &&
524 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
525 // We use arclite library for both ARC and subscripting support.
526 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
528 CmdArgs.push_back("-framework");
529 CmdArgs.push_back("Foundation");
531 CmdArgs.push_back("-lobjc");
535 CmdArgs.push_back("-arch_multiple");
536 CmdArgs.push_back("-final_output");
537 CmdArgs.push_back(LinkingOutput);
540 if (Args.hasArg(options::OPT_fnested_functions))
541 CmdArgs.push_back("-allow_stack_execute");
543 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
545 if (unsigned Parallelism =
546 getLTOParallelism(Args, getToolChain().getDriver())) {
547 CmdArgs.push_back("-mllvm");
548 CmdArgs.push_back(Args.MakeArgString("-threads=" + Twine(Parallelism)));
551 if (getToolChain().ShouldLinkCXXStdlib(Args))
552 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
553 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
554 // link_ssp spec is empty.
556 // Let the tool chain choose which runtime library to link.
557 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
559 // No need to do anything for pthreads. Claim argument to avoid warning.
560 Args.ClaimAllArgs(options::OPT_pthread);
561 Args.ClaimAllArgs(options::OPT_pthreads);
564 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
565 // endfile_spec is empty.
568 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
569 Args.AddAllArgs(CmdArgs, options::OPT_F);
571 // -iframework should be forwarded as -F.
572 for (const Arg *A : Args.filtered(options::OPT_iframework))
573 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
575 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
576 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
577 if (A->getValue() == StringRef("Accelerate")) {
578 CmdArgs.push_back("-framework");
579 CmdArgs.push_back("Accelerate");
584 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
585 std::unique_ptr<Command> Cmd =
586 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs);
587 Cmd->setInputFileList(std::move(InputFileList));
588 C.addCommand(std::move(Cmd));
591 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
592 const InputInfo &Output,
593 const InputInfoList &Inputs,
595 const char *LinkingOutput) const {
596 ArgStringList CmdArgs;
598 CmdArgs.push_back("-create");
599 assert(Output.isFilename() && "Unexpected lipo output.");
601 CmdArgs.push_back("-output");
602 CmdArgs.push_back(Output.getFilename());
604 for (const auto &II : Inputs) {
605 assert(II.isFilename() && "Unexpected lipo input.");
606 CmdArgs.push_back(II.getFilename());
609 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
610 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
613 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
614 const InputInfo &Output,
615 const InputInfoList &Inputs,
617 const char *LinkingOutput) const {
618 ArgStringList CmdArgs;
620 CmdArgs.push_back("-o");
621 CmdArgs.push_back(Output.getFilename());
623 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
624 const InputInfo &Input = Inputs[0];
625 assert(Input.isFilename() && "Unexpected dsymutil input.");
626 CmdArgs.push_back(Input.getFilename());
629 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
630 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
633 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
634 const InputInfo &Output,
635 const InputInfoList &Inputs,
637 const char *LinkingOutput) const {
638 ArgStringList CmdArgs;
639 CmdArgs.push_back("--verify");
640 CmdArgs.push_back("--debug-info");
641 CmdArgs.push_back("--eh-frame");
642 CmdArgs.push_back("--quiet");
644 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
645 const InputInfo &Input = Inputs[0];
646 assert(Input.isFilename() && "Unexpected verify input");
648 // Grabbing the output of the earlier dsymutil run.
649 CmdArgs.push_back(Input.getFilename());
652 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
653 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
656 MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
657 : ToolChain(D, Triple, Args) {
658 // We expect 'as', 'ld', etc. to be adjacent to our install dir.
659 getProgramPaths().push_back(getDriver().getInstalledDir());
660 if (getDriver().getInstalledDir() != getDriver().Dir)
661 getProgramPaths().push_back(getDriver().Dir);
664 /// Darwin - Darwin tool chain for i386 and x86_64.
665 Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
666 : MachO(D, Triple, Args), TargetInitialized(false),
667 CudaInstallation(D, Triple, Args) {}
669 types::ID MachO::LookupTypeForExtension(StringRef Ext) const {
670 types::ID Ty = types::lookupTypeForExtension(Ext);
672 // Darwin always preprocesses assembly files (unless -x is used explicitly).
673 if (Ty == types::TY_PP_Asm)
674 return types::TY_Asm;
679 bool MachO::HasNativeLLVMSupport() const { return true; }
681 ToolChain::CXXStdlibType Darwin::GetDefaultCXXStdlibType() const {
682 // Default to use libc++ on OS X 10.9+ and iOS 7+.
683 if ((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
684 (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
685 isTargetWatchOSBased())
686 return ToolChain::CST_Libcxx;
688 return ToolChain::CST_Libstdcxx;
691 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
692 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
693 if (isTargetWatchOSBased())
694 return ObjCRuntime(ObjCRuntime::WatchOS, TargetVersion);
695 if (isTargetIOSBased())
696 return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
698 return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
699 return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion);
702 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
703 bool Darwin::hasBlocksRuntime() const {
704 if (isTargetWatchOSBased())
706 else if (isTargetIOSBased())
707 return !isIPhoneOSVersionLT(3, 2);
709 assert(isTargetMacOS() && "unexpected darwin target");
710 return !isMacosxVersionLT(10, 6);
714 void Darwin::AddCudaIncludeArgs(const ArgList &DriverArgs,
715 ArgStringList &CC1Args) const {
716 CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
719 // This is just a MachO name translation routine and there's no
720 // way to join this into ARMTargetParser without breaking all
721 // other assumptions. Maybe MachO should consider standardising
722 // their nomenclature.
723 static const char *ArmMachOArchName(StringRef Arch) {
724 return llvm::StringSwitch<const char *>(Arch)
725 .Case("armv6k", "armv6")
726 .Case("armv6m", "armv6m")
727 .Case("armv5tej", "armv5")
728 .Case("xscale", "xscale")
729 .Case("armv4t", "armv4t")
730 .Case("armv7", "armv7")
731 .Cases("armv7a", "armv7-a", "armv7")
732 .Cases("armv7r", "armv7-r", "armv7")
733 .Cases("armv7em", "armv7e-m", "armv7em")
734 .Cases("armv7k", "armv7-k", "armv7k")
735 .Cases("armv7m", "armv7-m", "armv7m")
736 .Cases("armv7s", "armv7-s", "armv7s")
740 static const char *ArmMachOArchNameCPU(StringRef CPU) {
741 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
742 if (ArchKind == llvm::ARM::ArchKind::INVALID)
744 StringRef Arch = llvm::ARM::getArchName(ArchKind);
746 // FIXME: Make sure this MachO triple mangling is really necessary.
747 // ARMv5* normalises to ARMv5.
748 if (Arch.startswith("armv5"))
749 Arch = Arch.substr(0, 5);
750 // ARMv6*, except ARMv6M, normalises to ARMv6.
751 else if (Arch.startswith("armv6") && !Arch.endswith("6m"))
752 Arch = Arch.substr(0, 5);
753 // ARMv7A normalises to ARMv7.
754 else if (Arch.endswith("v7a"))
755 Arch = Arch.substr(0, 5);
759 StringRef MachO::getMachOArchName(const ArgList &Args) const {
760 switch (getTriple().getArch()) {
762 return getDefaultUniversalArchName();
764 case llvm::Triple::aarch64:
767 case llvm::Triple::thumb:
768 case llvm::Triple::arm:
769 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
770 if (const char *Arch = ArmMachOArchName(A->getValue()))
773 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
774 if (const char *Arch = ArmMachOArchNameCPU(A->getValue()))
785 std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
786 types::ID InputType) const {
787 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
789 // If the target isn't initialized (e.g., an unknown Darwin platform, return
790 // the default triple).
791 if (!isTargetInitialized())
792 return Triple.getTriple();
795 if (isTargetWatchOSBased())
797 else if (isTargetTvOSBased())
799 else if (isTargetIOSBased())
803 Str += getTargetVersion().getAsString();
804 Triple.setOSName(Str);
806 return Triple.getTriple();
809 Tool *MachO::getTool(Action::ActionClass AC) const {
811 case Action::LipoJobClass:
813 Lipo.reset(new tools::darwin::Lipo(*this));
815 case Action::DsymutilJobClass:
817 Dsymutil.reset(new tools::darwin::Dsymutil(*this));
818 return Dsymutil.get();
819 case Action::VerifyDebugInfoJobClass:
821 VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
822 return VerifyDebug.get();
824 return ToolChain::getTool(AC);
828 Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); }
830 Tool *MachO::buildAssembler() const {
831 return new tools::darwin::Assembler(*this);
834 DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple,
836 : Darwin(D, Triple, Args) {}
838 void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const {
839 // For modern targets, promote certain warnings to errors.
840 if (isTargetWatchOSBased() || getTriple().isArch64Bit()) {
841 // Always enable -Wdeprecated-objc-isa-usage and promote it
843 CC1Args.push_back("-Wdeprecated-objc-isa-usage");
844 CC1Args.push_back("-Werror=deprecated-objc-isa-usage");
846 // For iOS and watchOS, also error about implicit function declarations,
847 // as that can impact calling conventions.
848 if (!isTargetMacOS())
849 CC1Args.push_back("-Werror=implicit-function-declaration");
853 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
854 ArgStringList &CmdArgs) const {
855 // Avoid linking compatibility stubs on i386 mac.
856 if (isTargetMacOS() && getArch() == llvm::Triple::x86)
859 ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true);
861 if ((runtime.hasNativeARC() || !isObjCAutoRefCount(Args)) &&
862 runtime.hasSubscripting())
865 CmdArgs.push_back("-force_load");
866 SmallString<128> P(getDriver().ClangExecutable);
867 llvm::sys::path::remove_filename(P); // 'clang'
868 llvm::sys::path::remove_filename(P); // 'bin'
869 llvm::sys::path::append(P, "lib", "arc", "libarclite_");
870 // Mash in the platform.
871 if (isTargetWatchOSSimulator())
872 P += "watchsimulator";
873 else if (isTargetWatchOS())
875 else if (isTargetTvOSSimulator())
876 P += "appletvsimulator";
877 else if (isTargetTvOS())
879 else if (isTargetIOSSimulator())
880 P += "iphonesimulator";
881 else if (isTargetIPhoneOS())
887 CmdArgs.push_back(Args.MakeArgString(P));
890 unsigned DarwinClang::GetDefaultDwarfVersion() const {
891 // Default to use DWARF 2 on OS X 10.10 / iOS 8 and lower.
892 if ((isTargetMacOS() && isMacosxVersionLT(10, 11)) ||
893 (isTargetIOSBased() && isIPhoneOSVersionLT(9)))
898 void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
899 StringRef DarwinLibName,
900 RuntimeLinkOptions Opts) const {
901 SmallString<128> Dir(getDriver().ResourceDir);
902 llvm::sys::path::append(
903 Dir, "lib", (Opts & RLO_IsEmbedded) ? "macho_embedded" : "darwin");
905 SmallString<128> P(Dir);
906 llvm::sys::path::append(P, DarwinLibName);
908 // For now, allow missing resource libraries to support developers who may
909 // not have compiler-rt checked out or integrated into their build (unless
910 // we explicitly force linking with this library).
911 if ((Opts & RLO_AlwaysLink) || getVFS().exists(P)) {
912 const char *LibArg = Args.MakeArgString(P);
913 if (Opts & RLO_FirstLink)
914 CmdArgs.insert(CmdArgs.begin(), LibArg);
916 CmdArgs.push_back(LibArg);
919 // Adding the rpaths might negatively interact when other rpaths are involved,
920 // so we should make sure we add the rpaths last, after all user-specified
921 // rpaths. This is currently true from this place, but we need to be
922 // careful if this function is ever called before user's rpaths are emitted.
923 if (Opts & RLO_AddRPath) {
924 assert(DarwinLibName.endswith(".dylib") && "must be a dynamic library");
926 // Add @executable_path to rpath to support having the dylib copied with
928 CmdArgs.push_back("-rpath");
929 CmdArgs.push_back("@executable_path");
931 // Add the path to the resource dir to rpath to support using the dylib
932 // from the default location without copying.
933 CmdArgs.push_back("-rpath");
934 CmdArgs.push_back(Args.MakeArgString(Dir));
938 StringRef Darwin::getPlatformFamily() const {
939 switch (TargetPlatform) {
940 case DarwinPlatformKind::MacOS:
942 case DarwinPlatformKind::IPhoneOS:
944 case DarwinPlatformKind::TvOS:
946 case DarwinPlatformKind::WatchOS:
949 llvm_unreachable("Unsupported platform");
952 StringRef Darwin::getSDKName(StringRef isysroot) {
953 // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk
954 llvm::sys::path::const_iterator SDKDir;
955 auto BeginSDK = llvm::sys::path::begin(isysroot);
956 auto EndSDK = llvm::sys::path::end(isysroot);
957 for (auto IT = BeginSDK; IT != EndSDK; ++IT) {
959 if (SDK.endswith(".sdk"))
960 return SDK.slice(0, SDK.size() - 4);
965 StringRef Darwin::getOSLibraryNameSuffix() const {
966 switch(TargetPlatform) {
967 case DarwinPlatformKind::MacOS:
969 case DarwinPlatformKind::IPhoneOS:
970 return TargetEnvironment == NativeEnvironment ? "ios" : "iossim";
971 case DarwinPlatformKind::TvOS:
972 return TargetEnvironment == NativeEnvironment ? "tvos" : "tvossim";
973 case DarwinPlatformKind::WatchOS:
974 return TargetEnvironment == NativeEnvironment ? "watchos" : "watchossim";
976 llvm_unreachable("Unsupported platform");
979 /// Check if the link command contains a symbol export directive.
980 static bool hasExportSymbolDirective(const ArgList &Args) {
981 for (Arg *A : Args) {
982 if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
983 !A->getOption().matches(options::OPT_Xlinker))
985 if (A->containsValue("-exported_symbols_list") ||
986 A->containsValue("-exported_symbol"))
992 /// Add an export directive for \p Symbol to the link command.
993 static void addExportedSymbol(ArgStringList &CmdArgs, const char *Symbol) {
994 CmdArgs.push_back("-exported_symbol");
995 CmdArgs.push_back(Symbol);
998 void Darwin::addProfileRTLibs(const ArgList &Args,
999 ArgStringList &CmdArgs) const {
1000 if (!needsProfileRT(Args)) return;
1004 (Twine("libclang_rt.profile_") + getOSLibraryNameSuffix() + ".a").str(),
1005 RuntimeLinkOptions(RLO_AlwaysLink | RLO_FirstLink));
1007 // If we have a symbol export directive and we're linking in the profile
1008 // runtime, automatically export symbols necessary to implement some of the
1009 // runtime's functionality.
1010 if (hasExportSymbolDirective(Args)) {
1011 addExportedSymbol(CmdArgs, "_VPMergeHook");
1012 addExportedSymbol(CmdArgs, "___llvm_profile_filename");
1013 addExportedSymbol(CmdArgs, "___llvm_profile_raw_version");
1014 addExportedSymbol(CmdArgs, "_lprofCurFilename");
1018 void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
1019 ArgStringList &CmdArgs,
1020 StringRef Sanitizer,
1021 bool Shared) const {
1022 auto RLO = RuntimeLinkOptions(RLO_AlwaysLink | (Shared ? RLO_AddRPath : 0U));
1023 AddLinkRuntimeLib(Args, CmdArgs,
1024 (Twine("libclang_rt.") + Sanitizer + "_" +
1025 getOSLibraryNameSuffix() +
1026 (Shared ? "_dynamic.dylib" : ".a"))
1031 ToolChain::RuntimeLibType DarwinClang::GetRuntimeLibType(
1032 const ArgList &Args) const {
1033 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1034 StringRef Value = A->getValue();
1035 if (Value != "compiler-rt")
1036 getDriver().Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1037 << Value << "darwin";
1040 return ToolChain::RLT_CompilerRT;
1043 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
1044 ArgStringList &CmdArgs) const {
1045 // Call once to ensure diagnostic is printed if wrong value was specified
1046 GetRuntimeLibType(Args);
1048 // Darwin doesn't support real static executables, don't link any runtime
1049 // libraries with -static.
1050 if (Args.hasArg(options::OPT_static) ||
1051 Args.hasArg(options::OPT_fapple_kext) ||
1052 Args.hasArg(options::OPT_mkernel))
1055 // Reject -static-libgcc for now, we can deal with this when and if someone
1056 // cares. This is useful in situations where someone wants to statically link
1057 // something like libstdc++, and needs its runtime support routines.
1058 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1059 getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1063 const SanitizerArgs &Sanitize = getSanitizerArgs();
1064 if (Sanitize.needsAsanRt())
1065 AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
1066 if (Sanitize.needsLsanRt())
1067 AddLinkSanitizerLibArgs(Args, CmdArgs, "lsan");
1068 if (Sanitize.needsUbsanRt())
1069 AddLinkSanitizerLibArgs(Args, CmdArgs,
1070 Sanitize.requiresMinimalRuntime() ? "ubsan_minimal"
1072 Sanitize.needsSharedRt());
1073 if (Sanitize.needsTsanRt())
1074 AddLinkSanitizerLibArgs(Args, CmdArgs, "tsan");
1075 if (Sanitize.needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1076 AddLinkSanitizerLibArgs(Args, CmdArgs, "fuzzer", /*shared=*/false);
1078 // Libfuzzer is written in C++ and requires libcxx.
1079 AddCXXStdlibLibArgs(Args, CmdArgs);
1081 if (Sanitize.needsStatsRt()) {
1082 StringRef OS = isTargetMacOS() ? "osx" : "iossim";
1083 AddLinkRuntimeLib(Args, CmdArgs,
1084 (Twine("libclang_rt.stats_client_") + OS + ".a").str(),
1086 AddLinkSanitizerLibArgs(Args, CmdArgs, "stats");
1088 if (Sanitize.needsEsanRt())
1089 AddLinkSanitizerLibArgs(Args, CmdArgs, "esan");
1091 // Otherwise link libSystem, then the dynamic runtime library, and finally any
1092 // target specific static runtime library.
1093 CmdArgs.push_back("-lSystem");
1095 // Select the dynamic runtime library and the target specific static library.
1096 if (isTargetWatchOSBased()) {
1097 // We currently always need a static runtime library for watchOS.
1098 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.watchos.a");
1099 } else if (isTargetTvOSBased()) {
1100 // We currently always need a static runtime library for tvOS.
1101 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.tvos.a");
1102 } else if (isTargetIOSBased()) {
1103 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
1104 // it never went into the SDK.
1105 // Linking against libgcc_s.1 isn't needed for iOS 5.0+
1106 if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() &&
1107 getTriple().getArch() != llvm::Triple::aarch64)
1108 CmdArgs.push_back("-lgcc_s.1");
1110 // We currently always need a static runtime library for iOS.
1111 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
1113 assert(isTargetMacOS() && "unexpected non MacOS platform");
1114 // The dynamic runtime library was merged with libSystem for 10.6 and
1115 // beyond; only 10.4 and 10.5 need an additional runtime library.
1116 if (isMacosxVersionLT(10, 5))
1117 CmdArgs.push_back("-lgcc_s.10.4");
1118 else if (isMacosxVersionLT(10, 6))
1119 CmdArgs.push_back("-lgcc_s.10.5");
1121 // Originally for OS X, we thought we would only need a static runtime
1122 // library when targeting 10.4, to provide versions of the static functions
1123 // which were omitted from 10.4.dylib. This led to the creation of the 10.4
1124 // builtins library.
1126 // Unfortunately, that turned out to not be true, because Darwin system
1127 // headers can still use eprintf on i386, and it is not exported from
1128 // libSystem. Therefore, we still must provide a runtime library just for
1129 // the tiny tiny handful of projects that *might* use that symbol.
1131 // Then over time, we figured out it was useful to add more things to the
1132 // runtime so we created libclang_rt.osx.a to provide new functions when
1133 // deploying to old OS builds, and for a long time we had both eprintf and
1134 // osx builtin libraries. Which just seems excessive. So with PR 28855, we
1135 // are removing the eprintf library and expecting eprintf to be provided by
1136 // the OS X builtins library.
1137 if (isMacosxVersionLT(10, 5))
1138 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
1140 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
1144 /// Returns the most appropriate macOS target version for the current process.
1146 /// If the macOS SDK version is the same or earlier than the system version,
1147 /// then the SDK version is returned. Otherwise the system version is returned.
1148 static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion) {
1149 unsigned Major, Minor, Micro;
1150 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1151 if (!SystemTriple.isMacOSX())
1152 return MacOSSDKVersion;
1153 SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1154 VersionTuple SystemVersion(Major, Minor, Micro);
1156 if (!Driver::GetReleaseVersion(MacOSSDKVersion, Major, Minor, Micro,
1158 return MacOSSDKVersion;
1159 VersionTuple SDKVersion(Major, Minor, Micro);
1160 if (SDKVersion > SystemVersion)
1161 return SystemVersion.getAsString();
1162 return MacOSSDKVersion;
1167 /// The Darwin OS that was selected or inferred from arguments / environment.
1168 struct DarwinPlatform {
1170 /// The OS was specified using the -target argument.
1172 /// The OS was specified using the -m<os>-version-min argument.
1174 /// The OS was specified using the OS_DEPLOYMENT_TARGET environment.
1175 DeploymentTargetEnv,
1176 /// The OS was inferred from the SDK.
1178 /// The OS was inferred from the -arch.
1182 using DarwinPlatformKind = Darwin::DarwinPlatformKind;
1183 using DarwinEnvironmentKind = Darwin::DarwinEnvironmentKind;
1185 DarwinPlatformKind getPlatform() const { return Platform; }
1187 DarwinEnvironmentKind getEnvironment() const { return Environment; }
1189 StringRef getOSVersion() const {
1190 if (Kind == OSVersionArg)
1191 return Argument->getValue();
1195 void setOSVersion(StringRef S) {
1196 assert(Kind == TargetArg && "Unexpected kind!");
1200 bool hasOSVersion() const { return HasOSVersion; }
1202 /// Returns true if the target OS was explicitly specified.
1203 bool isExplicitlySpecified() const { return Kind <= DeploymentTargetEnv; }
1205 /// Adds the -m<os>-version-min argument to the compiler invocation.
1206 void addOSVersionMinArgument(DerivedArgList &Args, const OptTable &Opts) {
1209 assert(Kind != TargetArg && Kind != OSVersionArg && "Invalid kind");
1212 case DarwinPlatformKind::MacOS:
1213 Opt = options::OPT_mmacosx_version_min_EQ;
1215 case DarwinPlatformKind::IPhoneOS:
1216 Opt = options::OPT_miphoneos_version_min_EQ;
1218 case DarwinPlatformKind::TvOS:
1219 Opt = options::OPT_mtvos_version_min_EQ;
1221 case DarwinPlatformKind::WatchOS:
1222 Opt = options::OPT_mwatchos_version_min_EQ;
1225 Argument = Args.MakeJoinedArg(nullptr, Opts.getOption(Opt), OSVersion);
1226 Args.append(Argument);
1229 /// Returns the OS version with the argument / environment variable that
1231 std::string getAsString(DerivedArgList &Args, const OptTable &Opts) {
1235 case InferredFromSDK:
1236 case InferredFromArch:
1237 assert(Argument && "OS version argument not yet inferred");
1238 return Argument->getAsString(Args);
1239 case DeploymentTargetEnv:
1240 return (llvm::Twine(EnvVarName) + "=" + OSVersion).str();
1242 llvm_unreachable("Unsupported Darwin Source Kind");
1245 static DarwinPlatform createFromTarget(const llvm::Triple &TT,
1246 StringRef OSVersion, Arg *A) {
1247 DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
1249 switch (TT.getEnvironment()) {
1250 case llvm::Triple::Simulator:
1251 Result.Environment = DarwinEnvironmentKind::Simulator;
1256 unsigned Major, Minor, Micro;
1257 TT.getOSVersion(Major, Minor, Micro);
1259 Result.HasOSVersion = false;
1262 static DarwinPlatform createOSVersionArg(DarwinPlatformKind Platform,
1264 return DarwinPlatform(OSVersionArg, Platform, A);
1266 static DarwinPlatform createDeploymentTargetEnv(DarwinPlatformKind Platform,
1267 StringRef EnvVarName,
1269 DarwinPlatform Result(DeploymentTargetEnv, Platform, Value);
1270 Result.EnvVarName = EnvVarName;
1273 static DarwinPlatform createFromSDK(DarwinPlatformKind Platform,
1275 return DarwinPlatform(InferredFromSDK, Platform, Value);
1277 static DarwinPlatform createFromArch(llvm::Triple::OSType OS,
1279 return DarwinPlatform(InferredFromArch, getPlatformFromOS(OS), Value);
1283 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, Arg *Argument)
1284 : Kind(Kind), Platform(Platform), Argument(Argument) {}
1285 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, StringRef Value,
1286 Arg *Argument = nullptr)
1287 : Kind(Kind), Platform(Platform), OSVersion(Value), Argument(Argument) {}
1289 static DarwinPlatformKind getPlatformFromOS(llvm::Triple::OSType OS) {
1291 case llvm::Triple::Darwin:
1292 case llvm::Triple::MacOSX:
1293 return DarwinPlatformKind::MacOS;
1294 case llvm::Triple::IOS:
1295 return DarwinPlatformKind::IPhoneOS;
1296 case llvm::Triple::TvOS:
1297 return DarwinPlatformKind::TvOS;
1298 case llvm::Triple::WatchOS:
1299 return DarwinPlatformKind::WatchOS;
1301 llvm_unreachable("Unable to infer Darwin variant");
1306 DarwinPlatformKind Platform;
1307 DarwinEnvironmentKind Environment = DarwinEnvironmentKind::NativeEnvironment;
1308 std::string OSVersion;
1309 bool HasOSVersion = true;
1311 StringRef EnvVarName;
1314 /// Returns the deployment target that's specified using the -m<os>-version-min
1316 Optional<DarwinPlatform>
1317 getDeploymentTargetFromOSVersionArg(DerivedArgList &Args,
1318 const Driver &TheDriver) {
1319 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
1320 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ,
1321 options::OPT_mios_simulator_version_min_EQ);
1323 Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1324 options::OPT_mtvos_simulator_version_min_EQ);
1325 Arg *WatchOSVersion =
1326 Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1327 options::OPT_mwatchos_simulator_version_min_EQ);
1329 if (iOSVersion || TvOSVersion || WatchOSVersion) {
1330 TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1331 << OSXVersion->getAsString(Args)
1332 << (iOSVersion ? iOSVersion
1333 : TvOSVersion ? TvOSVersion : WatchOSVersion)
1334 ->getAsString(Args);
1336 return DarwinPlatform::createOSVersionArg(Darwin::MacOS, OSXVersion);
1337 } else if (iOSVersion) {
1338 if (TvOSVersion || WatchOSVersion) {
1339 TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1340 << iOSVersion->getAsString(Args)
1341 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
1343 return DarwinPlatform::createOSVersionArg(Darwin::IPhoneOS, iOSVersion);
1344 } else if (TvOSVersion) {
1345 if (WatchOSVersion) {
1346 TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1347 << TvOSVersion->getAsString(Args)
1348 << WatchOSVersion->getAsString(Args);
1350 return DarwinPlatform::createOSVersionArg(Darwin::TvOS, TvOSVersion);
1351 } else if (WatchOSVersion)
1352 return DarwinPlatform::createOSVersionArg(Darwin::WatchOS, WatchOSVersion);
1356 /// Returns the deployment target that's specified using the
1357 /// OS_DEPLOYMENT_TARGET environment variable.
1358 Optional<DarwinPlatform>
1359 getDeploymentTargetFromEnvironmentVariables(const Driver &TheDriver,
1360 const llvm::Triple &Triple) {
1361 std::string Targets[Darwin::LastDarwinPlatform + 1];
1362 const char *EnvVars[] = {
1363 "MACOSX_DEPLOYMENT_TARGET",
1364 "IPHONEOS_DEPLOYMENT_TARGET",
1365 "TVOS_DEPLOYMENT_TARGET",
1366 "WATCHOS_DEPLOYMENT_TARGET",
1368 static_assert(llvm::array_lengthof(EnvVars) == Darwin::LastDarwinPlatform + 1,
1369 "Missing platform");
1370 for (const auto &I : llvm::enumerate(llvm::makeArrayRef(EnvVars))) {
1371 if (char *Env = ::getenv(I.value()))
1372 Targets[I.index()] = Env;
1375 // Do not allow conflicts with the watchOS target.
1376 if (!Targets[Darwin::WatchOS].empty() &&
1377 (!Targets[Darwin::IPhoneOS].empty() || !Targets[Darwin::TvOS].empty())) {
1378 TheDriver.Diag(diag::err_drv_conflicting_deployment_targets)
1379 << "WATCHOS_DEPLOYMENT_TARGET"
1380 << (!Targets[Darwin::IPhoneOS].empty() ? "IPHONEOS_DEPLOYMENT_TARGET"
1381 : "TVOS_DEPLOYMENT_TARGET");
1384 // Do not allow conflicts with the tvOS target.
1385 if (!Targets[Darwin::TvOS].empty() && !Targets[Darwin::IPhoneOS].empty()) {
1386 TheDriver.Diag(diag::err_drv_conflicting_deployment_targets)
1387 << "TVOS_DEPLOYMENT_TARGET"
1388 << "IPHONEOS_DEPLOYMENT_TARGET";
1391 // Allow conflicts among OSX and iOS for historical reasons, but choose the
1392 // default platform.
1393 if (!Targets[Darwin::MacOS].empty() &&
1394 (!Targets[Darwin::IPhoneOS].empty() ||
1395 !Targets[Darwin::WatchOS].empty() || !Targets[Darwin::TvOS].empty())) {
1396 if (Triple.getArch() == llvm::Triple::arm ||
1397 Triple.getArch() == llvm::Triple::aarch64 ||
1398 Triple.getArch() == llvm::Triple::thumb)
1399 Targets[Darwin::MacOS] = "";
1401 Targets[Darwin::IPhoneOS] = Targets[Darwin::WatchOS] =
1402 Targets[Darwin::TvOS] = "";
1405 for (const auto &Target : llvm::enumerate(llvm::makeArrayRef(Targets))) {
1406 if (!Target.value().empty())
1407 return DarwinPlatform::createDeploymentTargetEnv(
1408 (Darwin::DarwinPlatformKind)Target.index(), EnvVars[Target.index()],
1414 /// Tries to infer the deployment target from the SDK specified by -isysroot
1416 Optional<DarwinPlatform> inferDeploymentTargetFromSDK(DerivedArgList &Args) {
1417 const Arg *A = Args.getLastArg(options::OPT_isysroot);
1420 StringRef isysroot = A->getValue();
1421 StringRef SDK = Darwin::getSDKName(isysroot);
1424 // Slice the version number out.
1425 // Version number is between the first and the last number.
1426 size_t StartVer = SDK.find_first_of("0123456789");
1427 size_t EndVer = SDK.find_last_of("0123456789");
1428 if (StartVer != StringRef::npos && EndVer > StartVer) {
1429 StringRef Version = SDK.slice(StartVer, EndVer + 1);
1430 if (SDK.startswith("iPhoneOS") || SDK.startswith("iPhoneSimulator"))
1431 return DarwinPlatform::createFromSDK(Darwin::IPhoneOS, Version);
1432 else if (SDK.startswith("MacOSX"))
1433 return DarwinPlatform::createFromSDK(Darwin::MacOS,
1434 getSystemOrSDKMacOSVersion(Version));
1435 else if (SDK.startswith("WatchOS") || SDK.startswith("WatchSimulator"))
1436 return DarwinPlatform::createFromSDK(Darwin::WatchOS, Version);
1437 else if (SDK.startswith("AppleTVOS") || SDK.startswith("AppleTVSimulator"))
1438 return DarwinPlatform::createFromSDK(Darwin::TvOS, Version);
1443 std::string getOSVersion(llvm::Triple::OSType OS, const llvm::Triple &Triple,
1444 const Driver &TheDriver) {
1445 unsigned Major, Minor, Micro;
1447 case llvm::Triple::Darwin:
1448 case llvm::Triple::MacOSX:
1449 if (!Triple.getMacOSXVersion(Major, Minor, Micro))
1450 TheDriver.Diag(diag::err_drv_invalid_darwin_version)
1451 << Triple.getOSName();
1453 case llvm::Triple::IOS:
1454 Triple.getiOSVersion(Major, Minor, Micro);
1456 case llvm::Triple::TvOS:
1457 Triple.getOSVersion(Major, Minor, Micro);
1459 case llvm::Triple::WatchOS:
1460 Triple.getWatchOSVersion(Major, Minor, Micro);
1463 llvm_unreachable("Unexpected OS type");
1467 std::string OSVersion;
1468 llvm::raw_string_ostream(OSVersion) << Major << '.' << Minor << '.' << Micro;
1472 /// Tries to infer the target OS from the -arch.
1473 Optional<DarwinPlatform>
1474 inferDeploymentTargetFromArch(DerivedArgList &Args, const Darwin &Toolchain,
1475 const llvm::Triple &Triple,
1476 const Driver &TheDriver) {
1477 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
1479 StringRef MachOArchName = Toolchain.getMachOArchName(Args);
1480 if (MachOArchName == "armv7" || MachOArchName == "armv7s" ||
1481 MachOArchName == "arm64")
1482 OSTy = llvm::Triple::IOS;
1483 else if (MachOArchName == "armv7k")
1484 OSTy = llvm::Triple::WatchOS;
1485 else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" &&
1486 MachOArchName != "armv7em")
1487 OSTy = llvm::Triple::MacOSX;
1489 if (OSTy == llvm::Triple::UnknownOS)
1491 return DarwinPlatform::createFromArch(OSTy,
1492 getOSVersion(OSTy, Triple, TheDriver));
1495 /// Returns the deployment target that's specified using the -target option.
1496 Optional<DarwinPlatform> getDeploymentTargetFromTargetArg(
1497 DerivedArgList &Args, const llvm::Triple &Triple, const Driver &TheDriver) {
1498 if (!Args.hasArg(options::OPT_target))
1500 if (Triple.getOS() == llvm::Triple::Darwin ||
1501 Triple.getOS() == llvm::Triple::UnknownOS)
1503 std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
1504 return DarwinPlatform::createFromTarget(Triple, OSVersion,
1505 Args.getLastArg(options::OPT_target));
1510 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
1511 const OptTable &Opts = getDriver().getOpts();
1513 // Support allowing the SDKROOT environment variable used by xcrun and other
1514 // Xcode tools to define the default sysroot, by making it the default for
1516 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1517 // Warn if the path does not exist.
1518 if (!getVFS().exists(A->getValue()))
1519 getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
1521 if (char *env = ::getenv("SDKROOT")) {
1522 // We only use this value as the default if it is an absolute path,
1523 // exists, and it is not the root path.
1524 if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) &&
1525 StringRef(env) != "/") {
1526 Args.append(Args.MakeSeparateArg(
1527 nullptr, Opts.getOption(options::OPT_isysroot), env));
1532 // The OS and the version can be specified using the -target argument.
1533 Optional<DarwinPlatform> OSTarget =
1534 getDeploymentTargetFromTargetArg(Args, getTriple(), getDriver());
1536 Optional<DarwinPlatform> OSVersionArgTarget =
1537 getDeploymentTargetFromOSVersionArg(Args, getDriver());
1538 if (OSVersionArgTarget) {
1539 unsigned TargetMajor, TargetMinor, TargetMicro;
1541 unsigned ArgMajor, ArgMinor, ArgMicro;
1543 if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
1544 (Driver::GetReleaseVersion(OSTarget->getOSVersion(), TargetMajor,
1545 TargetMinor, TargetMicro, TargetExtra) &&
1546 Driver::GetReleaseVersion(OSVersionArgTarget->getOSVersion(),
1547 ArgMajor, ArgMinor, ArgMicro, ArgExtra) &&
1548 (VersionTuple(TargetMajor, TargetMinor, TargetMicro) !=
1549 VersionTuple(ArgMajor, ArgMinor, ArgMicro) ||
1550 TargetExtra != ArgExtra))) {
1551 // Select the OS version from the -m<os>-version-min argument when
1552 // the -target does not include an OS version.
1553 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
1554 !OSTarget->hasOSVersion()) {
1555 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
1557 // Warn about -m<os>-version-min that doesn't match the OS version
1558 // that's specified in the target.
1559 std::string OSVersionArg =
1560 OSVersionArgTarget->getAsString(Args, Opts);
1561 std::string TargetArg = OSTarget->getAsString(Args, Opts);
1562 getDriver().Diag(clang::diag::warn_drv_overriding_flag_option)
1563 << OSVersionArg << TargetArg;
1568 // The OS target can be specified using the -m<os>version-min argument.
1569 OSTarget = getDeploymentTargetFromOSVersionArg(Args, getDriver());
1570 // If no deployment target was specified on the command line, check for
1571 // environment defines.
1574 getDeploymentTargetFromEnvironmentVariables(getDriver(), getTriple());
1575 // If there is no command-line argument to specify the Target version and
1576 // no environment variable defined, see if we can set the default based
1579 OSTarget = inferDeploymentTargetFromSDK(Args);
1580 // If no OS targets have been specified, try to guess platform from -target
1581 // or arch name and compute the version from the triple.
1584 inferDeploymentTargetFromArch(Args, *this, getTriple(), getDriver());
1587 assert(OSTarget && "Unable to infer Darwin variant");
1588 OSTarget->addOSVersionMinArgument(Args, Opts);
1589 DarwinPlatformKind Platform = OSTarget->getPlatform();
1591 unsigned Major, Minor, Micro;
1593 // Set the tool chain target information.
1594 if (Platform == MacOS) {
1595 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1597 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
1598 getDriver().Diag(diag::err_drv_invalid_version_number)
1599 << OSTarget->getAsString(Args, Opts);
1600 } else if (Platform == IPhoneOS) {
1601 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1603 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1604 getDriver().Diag(diag::err_drv_invalid_version_number)
1605 << OSTarget->getAsString(Args, Opts);
1607 // For 32-bit targets, the deployment target for iOS has to be earlier than
1609 if (getTriple().isArch32Bit() && Major >= 11) {
1610 // If the deployment target is explicitly specified, print a diagnostic.
1611 if (OSTarget->isExplicitlySpecified()) {
1612 getDriver().Diag(diag::warn_invalid_ios_deployment_target)
1613 << OSTarget->getAsString(Args, Opts);
1614 // Otherwise, set it to 10.99.99.
1621 } else if (Platform == TvOS) {
1622 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1624 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1625 getDriver().Diag(diag::err_drv_invalid_version_number)
1626 << OSTarget->getAsString(Args, Opts);
1627 } else if (Platform == WatchOS) {
1628 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1630 HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
1631 getDriver().Diag(diag::err_drv_invalid_version_number)
1632 << OSTarget->getAsString(Args, Opts);
1634 llvm_unreachable("unknown kind of Darwin platform");
1636 DarwinEnvironmentKind Environment = OSTarget->getEnvironment();
1637 // Recognize iOS targets with an x86 architecture as the iOS simulator.
1638 if (Environment == NativeEnvironment && Platform != MacOS &&
1639 (getTriple().getArch() == llvm::Triple::x86 ||
1640 getTriple().getArch() == llvm::Triple::x86_64))
1641 Environment = Simulator;
1643 setTarget(Platform, Environment, Major, Minor, Micro);
1645 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1646 StringRef SDK = getSDKName(A->getValue());
1647 if (SDK.size() > 0) {
1648 size_t StartVer = SDK.find_first_of("0123456789");
1649 StringRef SDKName = SDK.slice(0, StartVer);
1650 if (!SDKName.startswith(getPlatformFamily()))
1651 getDriver().Diag(diag::warn_incompatible_sysroot)
1652 << SDKName << getPlatformFamily();
1657 void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
1658 ArgStringList &CmdArgs) const {
1659 CXXStdlibType Type = GetCXXStdlibType(Args);
1662 case ToolChain::CST_Libcxx:
1663 CmdArgs.push_back("-lc++");
1666 case ToolChain::CST_Libstdcxx:
1667 // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
1668 // it was previously found in the gcc lib dir. However, for all the Darwin
1669 // platforms we care about it was -lstdc++.6, so we search for that
1670 // explicitly if we can't see an obvious -lstdc++ candidate.
1672 // Check in the sysroot first.
1673 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1674 SmallString<128> P(A->getValue());
1675 llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
1677 if (!getVFS().exists(P)) {
1678 llvm::sys::path::remove_filename(P);
1679 llvm::sys::path::append(P, "libstdc++.6.dylib");
1680 if (getVFS().exists(P)) {
1681 CmdArgs.push_back(Args.MakeArgString(P));
1687 // Otherwise, look in the root.
1688 // FIXME: This should be removed someday when we don't have to care about
1689 // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
1690 if (!getVFS().exists("/usr/lib/libstdc++.dylib") &&
1691 getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
1692 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
1696 // Otherwise, let the linker search.
1697 CmdArgs.push_back("-lstdc++");
1702 void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
1703 ArgStringList &CmdArgs) const {
1704 // For Darwin platforms, use the compiler-rt-based support library
1705 // instead of the gcc-provided one (which is also incidentally
1706 // only present in the gcc lib dir, which makes it hard to find).
1708 SmallString<128> P(getDriver().ResourceDir);
1709 llvm::sys::path::append(P, "lib", "darwin");
1711 // Use the newer cc_kext for iOS ARM after 6.0.
1712 if (isTargetWatchOS()) {
1713 llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a");
1714 } else if (isTargetTvOS()) {
1715 llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a");
1716 } else if (isTargetIPhoneOS()) {
1717 llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
1719 llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
1722 // For now, allow missing resource libraries to support developers who may
1723 // not have compiler-rt checked out or integrated into their build.
1724 if (getVFS().exists(P))
1725 CmdArgs.push_back(Args.MakeArgString(P));
1728 DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args,
1729 StringRef BoundArch,
1730 Action::OffloadKind) const {
1731 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
1732 const OptTable &Opts = getDriver().getOpts();
1734 // FIXME: We really want to get out of the tool chain level argument
1735 // translation business, as it makes the driver functionality much
1736 // more opaque. For now, we follow gcc closely solely for the
1737 // purpose of easily achieving feature parity & testability. Once we
1738 // have something that works, we should reevaluate each translation
1739 // and try to push it down into tool specific logic.
1741 for (Arg *A : Args) {
1742 if (A->getOption().matches(options::OPT_Xarch__)) {
1743 // Skip this argument unless the architecture matches either the toolchain
1744 // triple arch, or the arch being bound.
1745 llvm::Triple::ArchType XarchArch =
1746 tools::darwin::getArchTypeForMachOArchName(A->getValue(0));
1747 if (!(XarchArch == getArch() ||
1748 (!BoundArch.empty() &&
1750 tools::darwin::getArchTypeForMachOArchName(BoundArch))))
1753 Arg *OriginalArg = A;
1754 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1755 unsigned Prev = Index;
1756 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1758 // If the argument parsing failed or more than one argument was
1759 // consumed, the -Xarch_ argument's parameter tried to consume
1760 // extra arguments. Emit an error and ignore.
1762 // We also want to disallow any options which would alter the
1763 // driver behavior; that isn't going to work in our model. We
1764 // use isDriverOption() as an approximation, although things
1765 // like -O4 are going to slip through.
1766 if (!XarchArg || Index > Prev + 1) {
1767 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1768 << A->getAsString(Args);
1770 } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
1771 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
1772 << A->getAsString(Args);
1776 XarchArg->setBaseArg(A);
1778 A = XarchArg.release();
1779 DAL->AddSynthesizedArg(A);
1781 // Linker input arguments require custom handling. The problem is that we
1782 // have already constructed the phase actions, so we can not treat them as
1783 // "input arguments".
1784 if (A->getOption().hasFlag(options::LinkerInput)) {
1785 // Convert the argument into individual Zlinker_input_args.
1786 for (const char *Value : A->getValues()) {
1787 DAL->AddSeparateArg(
1788 OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
1794 // Sob. These is strictly gcc compatible for the time being. Apple
1795 // gcc translates options twice, which means that self-expanding
1796 // options add duplicates.
1797 switch ((options::ID)A->getOption().getID()) {
1802 case options::OPT_mkernel:
1803 case options::OPT_fapple_kext:
1805 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
1808 case options::OPT_dependency_file:
1809 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
1812 case options::OPT_gfull:
1813 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1815 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
1818 case options::OPT_gused:
1819 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1821 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
1824 case options::OPT_shared:
1825 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
1828 case options::OPT_fconstant_cfstrings:
1829 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
1832 case options::OPT_fno_constant_cfstrings:
1833 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
1836 case options::OPT_Wnonportable_cfstrings:
1838 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
1841 case options::OPT_Wno_nonportable_cfstrings:
1843 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
1846 case options::OPT_fpascal_strings:
1847 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
1850 case options::OPT_fno_pascal_strings:
1851 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
1856 if (getTriple().getArch() == llvm::Triple::x86 ||
1857 getTriple().getArch() == llvm::Triple::x86_64)
1858 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
1859 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_mtune_EQ),
1862 // Add the arch options based on the particular spelling of -arch, to match
1863 // how the driver driver works.
1864 if (!BoundArch.empty()) {
1865 StringRef Name = BoundArch;
1866 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
1867 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
1869 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
1870 // which defines the list of which architectures we accept.
1873 else if (Name == "ppc601")
1874 DAL->AddJoinedArg(nullptr, MCpu, "601");
1875 else if (Name == "ppc603")
1876 DAL->AddJoinedArg(nullptr, MCpu, "603");
1877 else if (Name == "ppc604")
1878 DAL->AddJoinedArg(nullptr, MCpu, "604");
1879 else if (Name == "ppc604e")
1880 DAL->AddJoinedArg(nullptr, MCpu, "604e");
1881 else if (Name == "ppc750")
1882 DAL->AddJoinedArg(nullptr, MCpu, "750");
1883 else if (Name == "ppc7400")
1884 DAL->AddJoinedArg(nullptr, MCpu, "7400");
1885 else if (Name == "ppc7450")
1886 DAL->AddJoinedArg(nullptr, MCpu, "7450");
1887 else if (Name == "ppc970")
1888 DAL->AddJoinedArg(nullptr, MCpu, "970");
1890 else if (Name == "ppc64" || Name == "ppc64le")
1891 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1893 else if (Name == "i386")
1895 else if (Name == "i486")
1896 DAL->AddJoinedArg(nullptr, MArch, "i486");
1897 else if (Name == "i586")
1898 DAL->AddJoinedArg(nullptr, MArch, "i586");
1899 else if (Name == "i686")
1900 DAL->AddJoinedArg(nullptr, MArch, "i686");
1901 else if (Name == "pentium")
1902 DAL->AddJoinedArg(nullptr, MArch, "pentium");
1903 else if (Name == "pentium2")
1904 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
1905 else if (Name == "pentpro")
1906 DAL->AddJoinedArg(nullptr, MArch, "pentiumpro");
1907 else if (Name == "pentIIm3")
1908 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
1910 else if (Name == "x86_64")
1911 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1912 else if (Name == "x86_64h") {
1913 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1914 DAL->AddJoinedArg(nullptr, MArch, "x86_64h");
1917 else if (Name == "arm")
1918 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
1919 else if (Name == "armv4t")
1920 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
1921 else if (Name == "armv5")
1922 DAL->AddJoinedArg(nullptr, MArch, "armv5tej");
1923 else if (Name == "xscale")
1924 DAL->AddJoinedArg(nullptr, MArch, "xscale");
1925 else if (Name == "armv6")
1926 DAL->AddJoinedArg(nullptr, MArch, "armv6k");
1927 else if (Name == "armv6m")
1928 DAL->AddJoinedArg(nullptr, MArch, "armv6m");
1929 else if (Name == "armv7")
1930 DAL->AddJoinedArg(nullptr, MArch, "armv7a");
1931 else if (Name == "armv7em")
1932 DAL->AddJoinedArg(nullptr, MArch, "armv7em");
1933 else if (Name == "armv7k")
1934 DAL->AddJoinedArg(nullptr, MArch, "armv7k");
1935 else if (Name == "armv7m")
1936 DAL->AddJoinedArg(nullptr, MArch, "armv7m");
1937 else if (Name == "armv7s")
1938 DAL->AddJoinedArg(nullptr, MArch, "armv7s");
1944 void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
1945 ArgStringList &CmdArgs) const {
1946 // Embedded targets are simple at the moment, not supporting sanitizers and
1947 // with different libraries for each member of the product { static, PIC } x
1948 // { hard-float, soft-float }
1949 llvm::SmallString<32> CompilerRT = StringRef("libclang_rt.");
1951 (tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard)
1954 CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic.a" : "_static.a";
1956 AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, RLO_IsEmbedded);
1959 bool Darwin::isAlignedAllocationUnavailable() const {
1960 llvm::Triple::OSType OS;
1962 switch (TargetPlatform) {
1963 case MacOS: // Earlier than 10.13.
1964 OS = llvm::Triple::MacOSX;
1967 OS = llvm::Triple::IOS;
1969 case TvOS: // Earlier than 11.0.
1970 OS = llvm::Triple::TvOS;
1972 case WatchOS: // Earlier than 4.0.
1973 OS = llvm::Triple::WatchOS;
1977 return TargetVersion < alignedAllocMinVersion(OS);
1980 void Darwin::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
1981 llvm::opt::ArgStringList &CC1Args,
1982 Action::OffloadKind DeviceOffloadKind) const {
1983 if (isAlignedAllocationUnavailable())
1984 CC1Args.push_back("-faligned-alloc-unavailable");
1988 Darwin::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
1989 Action::OffloadKind DeviceOffloadKind) const {
1990 // First get the generic Apple args, before moving onto Darwin-specific ones.
1991 DerivedArgList *DAL =
1992 MachO::TranslateArgs(Args, BoundArch, DeviceOffloadKind);
1993 const OptTable &Opts = getDriver().getOpts();
1995 // If no architecture is bound, none of the translations here are relevant.
1996 if (BoundArch.empty())
1999 // Add an explicit version min argument for the deployment target. We do this
2000 // after argument translation because -Xarch_ arguments may add a version min
2002 AddDeploymentTarget(*DAL);
2004 // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
2005 // FIXME: It would be far better to avoid inserting those -static arguments,
2006 // but we can't check the deployment target in the translation code until
2008 if (isTargetWatchOSBased() ||
2009 (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0))) {
2010 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
2013 if (A->getOption().getID() != options::OPT_mkernel &&
2014 A->getOption().getID() != options::OPT_fapple_kext)
2016 assert(it != ie && "unexpected argument translation");
2018 assert(A->getOption().getID() == options::OPT_static &&
2019 "missing expected -static argument");
2025 if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
2026 GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
2027 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_stdlib_EQ),
2030 // Validate the C++ standard library choice.
2031 CXXStdlibType Type = GetCXXStdlibType(*DAL);
2032 if (Type == ToolChain::CST_Libcxx) {
2033 // Check whether the target provides libc++.
2036 // Complain about targeting iOS < 5.0 in any way.
2037 if (isTargetIOSBased() && isIPhoneOSVersionLT(5, 0))
2040 if (where != StringRef()) {
2041 getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
2045 auto Arch = tools::darwin::getArchTypeForMachOArchName(BoundArch);
2046 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
2047 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
2048 options::OPT_fno_omit_frame_pointer, false))
2049 getDriver().Diag(clang::diag::warn_drv_unsupported_opt_for_target)
2050 << "-fomit-frame-pointer" << BoundArch;
2056 bool MachO::IsUnwindTablesDefault(const ArgList &Args) const {
2057 // Unwind tables are not emitted if -fno-exceptions is supplied (except when
2058 // targeting x86_64).
2059 return getArch() == llvm::Triple::x86_64 ||
2060 (GetExceptionModel(Args) != llvm::ExceptionHandling::SjLj &&
2061 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2065 bool MachO::UseDwarfDebugFlags() const {
2066 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
2067 return S[0] != '\0';
2071 llvm::ExceptionHandling Darwin::GetExceptionModel(const ArgList &Args) const {
2072 // Darwin uses SjLj exceptions on ARM.
2073 if (getTriple().getArch() != llvm::Triple::arm &&
2074 getTriple().getArch() != llvm::Triple::thumb)
2075 return llvm::ExceptionHandling::None;
2077 // Only watchOS uses the new DWARF/Compact unwinding method.
2078 llvm::Triple Triple(ComputeLLVMTriple(Args));
2079 if(Triple.isWatchABI())
2080 return llvm::ExceptionHandling::DwarfCFI;
2082 return llvm::ExceptionHandling::SjLj;
2085 bool Darwin::SupportsEmbeddedBitcode() const {
2086 assert(TargetInitialized && "Target not initialized!");
2087 if (isTargetIPhoneOS() && isIPhoneOSVersionLT(6, 0))
2092 bool MachO::isPICDefault() const { return true; }
2094 bool MachO::isPIEDefault() const { return false; }
2096 bool MachO::isPICDefaultForced() const {
2097 return (getArch() == llvm::Triple::x86_64 ||
2098 getArch() == llvm::Triple::aarch64);
2101 bool MachO::SupportsProfiling() const {
2102 // Profiling instrumentation is only supported on x86.
2103 return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64;
2106 void Darwin::addMinVersionArgs(const ArgList &Args,
2107 ArgStringList &CmdArgs) const {
2108 VersionTuple TargetVersion = getTargetVersion();
2110 if (isTargetWatchOS())
2111 CmdArgs.push_back("-watchos_version_min");
2112 else if (isTargetWatchOSSimulator())
2113 CmdArgs.push_back("-watchos_simulator_version_min");
2114 else if (isTargetTvOS())
2115 CmdArgs.push_back("-tvos_version_min");
2116 else if (isTargetTvOSSimulator())
2117 CmdArgs.push_back("-tvos_simulator_version_min");
2118 else if (isTargetIOSSimulator())
2119 CmdArgs.push_back("-ios_simulator_version_min");
2120 else if (isTargetIOSBased())
2121 CmdArgs.push_back("-iphoneos_version_min");
2123 assert(isTargetMacOS() && "unexpected target");
2124 CmdArgs.push_back("-macosx_version_min");
2127 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
2130 void Darwin::addStartObjectFileArgs(const ArgList &Args,
2131 ArgStringList &CmdArgs) const {
2132 // Derived from startfile spec.
2133 if (Args.hasArg(options::OPT_dynamiclib)) {
2134 // Derived from darwin_dylib1 spec.
2135 if (isTargetWatchOSBased()) {
2136 ; // watchOS does not need dylib1.o.
2137 } else if (isTargetIOSSimulator()) {
2138 ; // iOS simulator does not need dylib1.o.
2139 } else if (isTargetIPhoneOS()) {
2140 if (isIPhoneOSVersionLT(3, 1))
2141 CmdArgs.push_back("-ldylib1.o");
2143 if (isMacosxVersionLT(10, 5))
2144 CmdArgs.push_back("-ldylib1.o");
2145 else if (isMacosxVersionLT(10, 6))
2146 CmdArgs.push_back("-ldylib1.10.5.o");
2149 if (Args.hasArg(options::OPT_bundle)) {
2150 if (!Args.hasArg(options::OPT_static)) {
2151 // Derived from darwin_bundle1 spec.
2152 if (isTargetWatchOSBased()) {
2153 ; // watchOS does not need bundle1.o.
2154 } else if (isTargetIOSSimulator()) {
2155 ; // iOS simulator does not need bundle1.o.
2156 } else if (isTargetIPhoneOS()) {
2157 if (isIPhoneOSVersionLT(3, 1))
2158 CmdArgs.push_back("-lbundle1.o");
2160 if (isMacosxVersionLT(10, 6))
2161 CmdArgs.push_back("-lbundle1.o");
2165 if (Args.hasArg(options::OPT_pg) && SupportsProfiling()) {
2166 if (Args.hasArg(options::OPT_static) ||
2167 Args.hasArg(options::OPT_object) ||
2168 Args.hasArg(options::OPT_preload)) {
2169 CmdArgs.push_back("-lgcrt0.o");
2171 CmdArgs.push_back("-lgcrt1.o");
2173 // darwin_crt2 spec is empty.
2175 // By default on OS X 10.8 and later, we don't link with a crt1.o
2176 // file and the linker knows to use _main as the entry point. But,
2177 // when compiling with -pg, we need to link with the gcrt1.o file,
2178 // so pass the -no_new_main option to tell the linker to use the
2179 // "start" symbol as the entry point.
2180 if (isTargetMacOS() && !isMacosxVersionLT(10, 8))
2181 CmdArgs.push_back("-no_new_main");
2183 if (Args.hasArg(options::OPT_static) ||
2184 Args.hasArg(options::OPT_object) ||
2185 Args.hasArg(options::OPT_preload)) {
2186 CmdArgs.push_back("-lcrt0.o");
2188 // Derived from darwin_crt1 spec.
2189 if (isTargetWatchOSBased()) {
2190 ; // watchOS does not need crt1.o.
2191 } else if (isTargetIOSSimulator()) {
2192 ; // iOS simulator does not need crt1.o.
2193 } else if (isTargetIPhoneOS()) {
2194 if (getArch() == llvm::Triple::aarch64)
2195 ; // iOS does not need any crt1 files for arm64
2196 else if (isIPhoneOSVersionLT(3, 1))
2197 CmdArgs.push_back("-lcrt1.o");
2198 else if (isIPhoneOSVersionLT(6, 0))
2199 CmdArgs.push_back("-lcrt1.3.1.o");
2201 if (isMacosxVersionLT(10, 5))
2202 CmdArgs.push_back("-lcrt1.o");
2203 else if (isMacosxVersionLT(10, 6))
2204 CmdArgs.push_back("-lcrt1.10.5.o");
2205 else if (isMacosxVersionLT(10, 8))
2206 CmdArgs.push_back("-lcrt1.10.6.o");
2208 // darwin_crt2 spec is empty.
2215 if (!isTargetIPhoneOS() && Args.hasArg(options::OPT_shared_libgcc) &&
2216 !isTargetWatchOS() &&
2217 isMacosxVersionLT(10, 5)) {
2218 const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
2219 CmdArgs.push_back(Str);
2223 void Darwin::CheckObjCARC() const {
2224 if (isTargetIOSBased() || isTargetWatchOSBased() ||
2225 (isTargetMacOS() && !isMacosxVersionLT(10, 6)))
2227 getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
2230 SanitizerMask Darwin::getSupportedSanitizers() const {
2231 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
2232 SanitizerMask Res = ToolChain::getSupportedSanitizers();
2233 Res |= SanitizerKind::Address;
2234 Res |= SanitizerKind::Leak;
2235 Res |= SanitizerKind::Fuzzer;
2236 Res |= SanitizerKind::FuzzerNoLink;
2237 Res |= SanitizerKind::Function;
2238 if (isTargetMacOS()) {
2239 if (!isMacosxVersionLT(10, 9))
2240 Res |= SanitizerKind::Vptr;
2241 Res |= SanitizerKind::SafeStack;
2243 Res |= SanitizerKind::Thread;
2244 } else if (isTargetIOSSimulator() || isTargetTvOSSimulator()) {
2246 Res |= SanitizerKind::Thread;
2251 void Darwin::printVerboseInfo(raw_ostream &OS) const {
2252 CudaInstallation.print(OS);