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/ObjCRuntime.h"
14 #include "clang/Basic/VirtualFileSystem.h"
15 #include "clang/Driver/Compilation.h"
16 #include "clang/Driver/Driver.h"
17 #include "clang/Driver/DriverDiagnostic.h"
18 #include "clang/Driver/Options.h"
19 #include "clang/Driver/SanitizerArgs.h"
20 #include "llvm/ADT/StringSwitch.h"
21 #include "llvm/Option/ArgList.h"
22 #include "llvm/Support/Path.h"
23 #include "llvm/Support/ScopedPrinter.h"
24 #include "llvm/Support/TargetParser.h"
25 #include <cstdlib> // ::getenv
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;
33 llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
34 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
35 // archs which Darwin doesn't use.
37 // The matching this routine does is fairly pointless, since it is neither the
38 // complete architecture list, nor a reasonable subset. The problem is that
39 // historically the driver driver accepts this and also ties its -march=
40 // handling to the architecture name, so we need to be careful before removing
43 // This code must be kept in sync with Clang's Darwin specific argument
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)
54 // This is derived from the driver driver.
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);
68 void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
69 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
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);
83 void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
84 const InputInfo &Output,
85 const InputInfoList &Inputs,
87 const char *LinkingOutput) const {
88 ArgStringList CmdArgs;
90 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
91 const InputInfo &Input = Inputs[0];
93 // Determine the original source input.
94 const Action *SourceAction = &JA;
95 while (SourceAction->getKind() != Action::InputClass) {
96 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
97 SourceAction = SourceAction->getInputs()[0];
100 // If -fno-integrated-as is used add -Q to the darwin assember driver to make
101 // sure it runs its system assembler not clang's integrated assembler.
102 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
103 // FIXME: at run-time detect assembler capabilities or rely on version
104 // information forwarded by -target-assembler-version.
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");
111 // Forward -g, assuming we are dealing with an actual assembly file.
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");
120 // Derived from asm spec.
121 AddMachOArch(Args, CmdArgs);
123 // Use -force_cpusubtype_ALL on x86 by default.
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");
140 CmdArgs.push_back(Output.getFilename());
142 assert(Input.isFilename() && "Invalid input.");
143 CmdArgs.push_back(Input.getFilename());
145 // asm_final spec is empty.
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() {}
153 void darwin::MachOTool::AddMachOArch(const ArgList &Args,
154 ArgStringList &CmdArgs) const {
155 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
157 // Derived from darwin_arch spec.
158 CmdArgs.push_back("-arch");
159 CmdArgs.push_back(Args.MakeArgString(ArchName));
161 // FIXME: Is this needed anymore?
162 if (ArchName == "arm")
163 CmdArgs.push_back("-force_cpusubtype_ALL");
166 bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const {
167 // We only need to generate a temp path for LTO if we aren't compiling object
168 // files. When compiling source files, we run 'dsymutil' after linking. We
169 // don't run 'dsymutil' when compiling object files.
170 for (const auto &Input : Inputs)
171 if (Input.getType() != types::TY_Object)
177 /// \brief Pass -no_deduplicate to ld64 under certain conditions:
179 /// - Either -O0 or -O1 is explicitly specified
180 /// - No -O option is specified *and* this is a compile+link (implicit -O0)
182 /// Also do *not* add -no_deduplicate when no -O option is specified and this
183 /// is just a link (we can't imply -O0)
184 static bool shouldLinkerNotDedup(bool IsLinkerOnlyAction, const ArgList &Args) {
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())
192 return false; // OPT_Ofast & OPT_O4
195 if (!IsLinkerOnlyAction) // Implicit -O0 for compile+linker only.
200 void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args,
201 ArgStringList &CmdArgs,
202 const InputInfoList &Inputs) const {
203 const Driver &D = getToolChain().getDriver();
204 const toolchains::MachO &MachOTC = getMachOToolChain();
206 unsigned Version[5] = {0, 0, 0, 0, 0};
207 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
208 if (!Driver::GetReleaseVersion(A->getValue(), Version))
209 D.Diag(diag::err_drv_invalid_version_number) << A->getAsString(Args);
212 // Newer linkers support -demangle. Pass it if supported and not disabled by
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");
220 // If we are using App Extension restrictions, pass a flag to the linker
221 // telling it that the compiled code has been audited.
222 if (Args.hasFlag(options::OPT_fapplication_extension,
223 options::OPT_fno_application_extension, false))
224 CmdArgs.push_back("-application_extension");
226 if (D.isUsingLTO()) {
227 // If we are using LTO, then automatically create a temporary file path for
228 // the linker to use, so that it's lifetime will extend past a possible
230 if (Version[0] >= 116 && NeedsTempPath(Inputs)) {
231 const char *TmpPath = C.getArgs().MakeArgString(
232 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
233 C.addTempFile(TmpPath);
234 CmdArgs.push_back("-object_path_lto");
235 CmdArgs.push_back(TmpPath);
239 // Use -lto_library option to specify the libLTO.dylib path. Try to find
240 // it in clang installed libraries. ld64 will only look at this argument
241 // when it actually uses LTO, so libLTO.dylib only needs to exist at link
242 // time if ld64 decides that it needs to use LTO.
243 // Since this is passed unconditionally, ld64 will never look for libLTO.dylib
244 // next to it. That's ok since ld64 using a libLTO.dylib not matching the
245 // clang version won't work anyways.
246 if (Version[0] >= 133) {
247 // Search for libLTO in <InstalledDir>/../lib/libLTO.dylib
248 StringRef P = llvm::sys::path::parent_path(D.Dir);
249 SmallString<128> LibLTOPath(P);
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));
256 // ld64 version 262 and above run the deduplicate pass by default.
257 if (Version[0] >= 262 && shouldLinkerNotDedup(C.getJobs().empty(), Args))
258 CmdArgs.push_back("-no_deduplicate");
260 // Derived from the "link" spec.
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)) {
265 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
266 // here. How do we wish to handle such things?
269 if (!Args.hasArg(options::OPT_dynamiclib)) {
270 AddMachOArch(Args, CmdArgs);
271 // FIXME: Why do this only on this path?
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);
315 if (MachOTC.isTargetIOSBased())
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);
328 // Add the deployment target.
329 MachOTC.addMinVersionArgs(Args, CmdArgs);
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");
347 // for embed-bitcode, use -bitcode_bundle in linker command
348 if (C.getDriver().embedBitcodeEnabled()) {
349 // Check if the toolchain supports bitcode build flow.
350 if (MachOTC.SupportsEmbeddedBitcode()) {
351 CmdArgs.push_back("-bitcode_bundle");
352 if (C.getDriver().embedBitcodeMarkerOnly() && Version[0] >= 278) {
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);
377 // Give --sysroot= preference, over the Apple specific behavior to also use
378 // --isysroot as the syslibroot.
379 StringRef sysroot = C.getSysRoot();
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);
411 /// \brief Determine whether we are linking the ObjC runtime.
412 static bool isObjCRuntimeLinked(const ArgList &Args) {
413 if (isObjCAutoRefCount(Args)) {
414 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
417 return Args.hasArg(options::OPT_fobjc_link_runtime);
420 void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,
421 const InputInfo &Output,
422 const InputInfoList &Inputs,
424 const char *LinkingOutput) const {
425 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
427 // If the number of arguments surpasses the system limits, we will encode the
428 // input files in a separate file, shortening the command line. To this end,
429 // build a list of input file names that can be passed via a file with the
430 // -filelist linker option.
431 llvm::opt::ArgStringList InputFileList;
433 // The logic here is derived from gcc's behavior; most of which
434 // comes from specs (starting with link_command). Consult gcc for
436 ArgStringList CmdArgs;
438 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
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"));
445 CmdArgs.push_back(Output.getFilename());
446 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, None));
450 // I'm not sure why this particular decomposition exists in gcc, but
451 // we follow suite for ease of comparison.
452 AddLinkArgs(C, Args, CmdArgs, Inputs);
454 // For LTO, pass the name of the optimization record file.
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");
462 F = Output.getFilename();
464 CmdArgs.push_back(Args.MakeArgString(F));
466 if (getLastProfileUseArg(Args)) {
467 CmdArgs.push_back("-mllvm");
468 CmdArgs.push_back("-lto-pass-remarks-with-hotness");
472 // It seems that the 'e' option is completely ignored for dynamic executables
473 // (the default), and with static executables, the last one wins, as expected.
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});
478 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
479 // members of static archive libraries which implement Objective-C classes or
481 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
482 CmdArgs.push_back("-ObjC");
484 CmdArgs.push_back("-o");
485 CmdArgs.push_back(Output.getFilename());
487 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
488 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
490 // SafeStack requires its own runtime libraries
491 // These libraries should be linked first, to make sure the
492 // __safestack_init constructor executes before everything else
493 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
494 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
495 "libclang_rt.safestack_osx.a",
496 /*AlwaysLink=*/true);
499 Args.AddAllArgs(CmdArgs, options::OPT_L);
501 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
502 // Build the input file for -filelist (list of linker input files) in case we
504 for (const auto &II : Inputs) {
505 if (!II.isFilename()) {
506 // This is a linker input argument.
507 // We cannot mix input arguments and file names in a -filelist input, thus
508 // we prematurely stop our list (remaining files shall be passed as
510 if (InputFileList.size() > 0)
516 InputFileList.push_back(II.getFilename());
519 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
520 addOpenMPRuntime(CmdArgs, getToolChain(), Args);
522 if (isObjCRuntimeLinked(Args) &&
523 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
524 // We use arclite library for both ARC and subscripting support.
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 =
545 getLTOParallelism(Args, getToolChain().getDriver())) {
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);
555 // link_ssp spec is empty.
557 // Let the tool chain choose which runtime library to link.
558 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
560 // No need to do anything for pthreads. Claim argument to avoid warning.
561 Args.ClaimAllArgs(options::OPT_pthread);
562 Args.ClaimAllArgs(options::OPT_pthreads);
565 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
566 // endfile_spec is empty.
569 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
570 Args.AddAllArgs(CmdArgs, options::OPT_F);
572 // -iframework should be forwarded as -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));
589 C.addCommand(std::move(Cmd));
592 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
593 const InputInfo &Output,
594 const InputInfoList &Inputs,
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");
603 CmdArgs.push_back(Output.getFilename());
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));
614 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
615 const InputInfo &Output,
616 const InputInfoList &Inputs,
618 const char *LinkingOutput) const {
619 ArgStringList CmdArgs;
621 CmdArgs.push_back("-o");
622 CmdArgs.push_back(Output.getFilename());
624 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
625 const InputInfo &Input = Inputs[0];
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));
634 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
635 const InputInfo &Output,
636 const InputInfoList &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.");
646 const InputInfo &Input = Inputs[0];
647 assert(Input.isFilename() && "Unexpected verify input");
649 // Grabbing the output of the earlier dsymutil run.
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)
658 : ToolChain(D, Triple, Args) {
659 // We expect 'as', 'ld', etc. to be adjacent to our install dir.
660 getProgramPaths().push_back(getDriver().getInstalledDir());
661 if (getDriver().getInstalledDir() != getDriver().Dir)
662 getProgramPaths().push_back(getDriver().Dir);
665 /// Darwin - Darwin tool chain for i386 and x86_64.
666 Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
667 : MachO(D, Triple, Args), TargetInitialized(false),
668 CudaInstallation(D, Triple, Args) {}
670 types::ID MachO::LookupTypeForExtension(StringRef Ext) const {
671 types::ID Ty = types::lookupTypeForExtension(Ext);
673 // Darwin always preprocesses assembly files (unless -x is used explicitly).
674 if (Ty == types::TY_PP_Asm)
675 return types::TY_Asm;
680 bool MachO::HasNativeLLVMSupport() const { return true; }
682 ToolChain::CXXStdlibType Darwin::GetDefaultCXXStdlibType() const {
683 // Default to use libc++ on OS X 10.9+ and iOS 7+.
684 if ((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
685 (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
686 isTargetWatchOSBased())
687 return ToolChain::CST_Libcxx;
689 return ToolChain::CST_Libstdcxx;
692 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
693 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
694 if (isTargetWatchOSBased())
695 return ObjCRuntime(ObjCRuntime::WatchOS, TargetVersion);
696 if (isTargetIOSBased())
697 return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
699 return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
700 return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion);
703 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
704 bool Darwin::hasBlocksRuntime() const {
705 if (isTargetWatchOSBased())
707 else if (isTargetIOSBased())
708 return !isIPhoneOSVersionLT(3, 2);
710 assert(isTargetMacOS() && "unexpected darwin target");
711 return !isMacosxVersionLT(10, 6);
715 void Darwin::AddCudaIncludeArgs(const ArgList &DriverArgs,
716 ArgStringList &CC1Args) const {
717 CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
720 // This is just a MachO name translation routine and there's no
721 // way to join this into ARMTargetParser without breaking all
722 // other assumptions. Maybe MachO should consider standardising
723 // their nomenclature.
724 static const char *ArmMachOArchName(StringRef Arch) {
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")
741 static const char *ArmMachOArchNameCPU(StringRef CPU) {
742 unsigned ArchKind = llvm::ARM::parseCPUArch(CPU);
743 if (ArchKind == llvm::ARM::AK_INVALID)
745 StringRef Arch = llvm::ARM::getArchName(ArchKind);
747 // FIXME: Make sure this MachO triple mangling is really necessary.
748 // ARMv5* normalises to ARMv5.
749 if (Arch.startswith("armv5"))
750 Arch = Arch.substr(0, 5);
751 // ARMv6*, except ARMv6M, normalises to ARMv6.
752 else if (Arch.startswith("armv6") && !Arch.endswith("6m"))
753 Arch = Arch.substr(0, 5);
754 // ARMv7A normalises to ARMv7.
755 else if (Arch.endswith("v7a"))
756 Arch = Arch.substr(0, 5);
760 StringRef MachO::getMachOArchName(const ArgList &Args) const {
761 switch (getTriple().getArch()) {
763 return getDefaultUniversalArchName();
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))
771 if (const char *Arch = ArmMachOArchName(A->getValue()))
774 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
775 if (const char *Arch = ArmMachOArchNameCPU(A->getValue()))
786 std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
787 types::ID InputType) const {
788 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
790 // If the target isn't initialized (e.g., an unknown Darwin platform, return
791 // the default triple).
792 if (!isTargetInitialized())
793 return Triple.getTriple();
796 if (isTargetWatchOSBased())
798 else if (isTargetTvOSBased())
800 else if (isTargetIOSBased())
804 Str += getTargetVersion().getAsString();
805 Triple.setOSName(Str);
807 return Triple.getTriple();
810 Tool *MachO::getTool(Action::ActionClass AC) const {
812 case Action::LipoJobClass:
814 Lipo.reset(new tools::darwin::Lipo(*this));
816 case Action::DsymutilJobClass:
818 Dsymutil.reset(new tools::darwin::Dsymutil(*this));
819 return Dsymutil.get();
820 case Action::VerifyDebugInfoJobClass:
822 VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
823 return VerifyDebug.get();
825 return ToolChain::getTool(AC);
829 Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); }
831 Tool *MachO::buildAssembler() const {
832 return new tools::darwin::Assembler(*this);
835 DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple,
837 : Darwin(D, Triple, Args) {}
839 void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const {
840 // For modern targets, promote certain warnings to errors.
841 if (isTargetWatchOSBased() || getTriple().isArch64Bit()) {
842 // Always enable -Wdeprecated-objc-isa-usage and promote it
844 CC1Args.push_back("-Wdeprecated-objc-isa-usage");
845 CC1Args.push_back("-Werror=deprecated-objc-isa-usage");
847 // For iOS and watchOS, also error about implicit function declarations,
848 // as that can impact calling conventions.
849 if (!isTargetMacOS())
850 CC1Args.push_back("-Werror=implicit-function-declaration");
854 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
855 ArgStringList &CmdArgs) const {
856 // Avoid linking compatibility stubs on i386 mac.
857 if (isTargetMacOS() && getArch() == llvm::Triple::x86)
860 ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true);
862 if ((runtime.hasNativeARC() || !isObjCAutoRefCount(Args)) &&
863 runtime.hasSubscripting())
866 CmdArgs.push_back("-force_load");
867 SmallString<128> P(getDriver().ClangExecutable);
868 llvm::sys::path::remove_filename(P); // 'clang'
869 llvm::sys::path::remove_filename(P); // 'bin'
870 llvm::sys::path::append(P, "lib", "arc", "libarclite_");
871 // Mash in the platform.
872 if (isTargetWatchOSSimulator())
873 P += "watchsimulator";
874 else if (isTargetWatchOS())
876 else if (isTargetTvOSSimulator())
877 P += "appletvsimulator";
878 else if (isTargetTvOS())
880 else if (isTargetIOSSimulator())
881 P += "iphonesimulator";
882 else if (isTargetIPhoneOS())
888 CmdArgs.push_back(Args.MakeArgString(P));
891 unsigned DarwinClang::GetDefaultDwarfVersion() const {
892 // Default to use DWARF 2 on OS X 10.10 / iOS 8 and lower.
893 if ((isTargetMacOS() && isMacosxVersionLT(10, 11)) ||
894 (isTargetIOSBased() && isIPhoneOSVersionLT(9)))
899 void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
900 StringRef DarwinLibName, bool AlwaysLink,
901 bool IsEmbedded, bool AddRPath) const {
902 SmallString<128> Dir(getDriver().ResourceDir);
903 llvm::sys::path::append(Dir, "lib", 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 (AlwaysLink || getVFS().exists(P))
912 CmdArgs.push_back(Args.MakeArgString(P));
914 // Adding the rpaths might negatively interact when other rpaths are involved,
915 // so we should make sure we add the rpaths last, after all user-specified
916 // rpaths. This is currently true from this place, but we need to be
917 // careful if this function is ever called before user's rpaths are emitted.
919 assert(DarwinLibName.endswith(".dylib") && "must be a dynamic library");
921 // Add @executable_path to rpath to support having the dylib copied with
923 CmdArgs.push_back("-rpath");
924 CmdArgs.push_back("@executable_path");
926 // Add the path to the resource dir to rpath to support using the dylib
927 // from the default location without copying.
928 CmdArgs.push_back("-rpath");
929 CmdArgs.push_back(Args.MakeArgString(Dir));
933 void MachO::AddFuzzerLinkArgs(const ArgList &Args, ArgStringList &CmdArgs) const {
935 // Go up one directory from Clang to find the libfuzzer archive file.
936 StringRef ParentDir = llvm::sys::path::parent_path(getDriver().InstalledDir);
937 SmallString<128> P(ParentDir);
938 llvm::sys::path::append(P, "lib", "libLLVMFuzzer.a");
939 CmdArgs.push_back(Args.MakeArgString(P));
941 // Libfuzzer is written in C++ and requires libcxx.
942 AddCXXStdlibLibArgs(Args, CmdArgs);
945 StringRef Darwin::getPlatformFamily() const {
946 switch (TargetPlatform) {
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");
962 StringRef Darwin::getSDKName(StringRef isysroot) {
963 // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk
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);
975 StringRef Darwin::getOSLibraryNameSuffix() const {
976 switch(TargetPlatform) {
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");
995 void Darwin::addProfileRTLibs(const ArgList &Args,
996 ArgStringList &CmdArgs) const {
997 if (!needsProfileRT(Args)) return;
999 AddLinkRuntimeLib(Args, CmdArgs, (Twine("libclang_rt.profile_") +
1000 getOSLibraryNameSuffix() + ".a").str(),
1001 /*AlwaysLink*/ true);
1004 void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
1005 ArgStringList &CmdArgs,
1006 StringRef Sanitizer) const {
1009 (Twine("libclang_rt.") + Sanitizer + "_" +
1010 getOSLibraryNameSuffix() + "_dynamic.dylib").str(),
1011 /*AlwaysLink*/ true, /*IsEmbedded*/ false,
1015 ToolChain::RuntimeLibType DarwinClang::GetRuntimeLibType(
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";
1024 return ToolChain::RLT_CompilerRT;
1027 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
1028 ArgStringList &CmdArgs) const {
1029 // Call once to ensure diagnostic is printed if wrong value was specified
1030 GetRuntimeLibType(Args);
1032 // Darwin doesn't support real static executables, don't link any runtime
1033 // libraries with -static.
1034 if (Args.hasArg(options::OPT_static) ||
1035 Args.hasArg(options::OPT_fapple_kext) ||
1036 Args.hasArg(options::OPT_mkernel))
1039 // Reject -static-libgcc for now, we can deal with this when and if someone
1040 // cares. This is useful in situations where someone wants to statically link
1041 // something like libstdc++, and needs its runtime support routines.
1042 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1043 getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1047 const SanitizerArgs &Sanitize = getSanitizerArgs();
1048 if (Sanitize.needsAsanRt())
1049 AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
1050 if (Sanitize.needsLsanRt())
1051 AddLinkSanitizerLibArgs(Args, CmdArgs, "lsan");
1052 if (Sanitize.needsUbsanRt())
1053 AddLinkSanitizerLibArgs(Args, CmdArgs, "ubsan");
1054 if (Sanitize.needsTsanRt())
1055 AddLinkSanitizerLibArgs(Args, CmdArgs, "tsan");
1056 if (Sanitize.needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib))
1057 AddFuzzerLinkArgs(Args, CmdArgs);
1058 if (Sanitize.needsStatsRt()) {
1059 StringRef OS = isTargetMacOS() ? "osx" : "iossim";
1060 AddLinkRuntimeLib(Args, CmdArgs,
1061 (Twine("libclang_rt.stats_client_") + OS + ".a").str(),
1062 /*AlwaysLink=*/true);
1063 AddLinkSanitizerLibArgs(Args, CmdArgs, "stats");
1065 if (Sanitize.needsEsanRt())
1066 AddLinkSanitizerLibArgs(Args, CmdArgs, "esan");
1068 // Otherwise link libSystem, then the dynamic runtime library, and finally any
1069 // target specific static runtime library.
1070 CmdArgs.push_back("-lSystem");
1072 // Select the dynamic runtime library and the target specific static library.
1073 if (isTargetWatchOSBased()) {
1074 // We currently always need a static runtime library for watchOS.
1075 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.watchos.a");
1076 } else if (isTargetTvOSBased()) {
1077 // We currently always need a static runtime library for tvOS.
1078 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.tvos.a");
1079 } else if (isTargetIOSBased()) {
1080 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
1081 // it never went into the SDK.
1082 // Linking against libgcc_s.1 isn't needed for iOS 5.0+
1083 if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() &&
1084 getTriple().getArch() != llvm::Triple::aarch64)
1085 CmdArgs.push_back("-lgcc_s.1");
1087 // We currently always need a static runtime library for iOS.
1088 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
1090 assert(isTargetMacOS() && "unexpected non MacOS platform");
1091 // The dynamic runtime library was merged with libSystem for 10.6 and
1092 // beyond; only 10.4 and 10.5 need an additional runtime library.
1093 if (isMacosxVersionLT(10, 5))
1094 CmdArgs.push_back("-lgcc_s.10.4");
1095 else if (isMacosxVersionLT(10, 6))
1096 CmdArgs.push_back("-lgcc_s.10.5");
1098 // Originally for OS X, we thought we would only need a static runtime
1099 // library when targeting 10.4, to provide versions of the static functions
1100 // which were omitted from 10.4.dylib. This led to the creation of the 10.4
1101 // builtins library.
1103 // Unfortunately, that turned out to not be true, because Darwin system
1104 // headers can still use eprintf on i386, and it is not exported from
1105 // libSystem. Therefore, we still must provide a runtime library just for
1106 // the tiny tiny handful of projects that *might* use that symbol.
1108 // Then over time, we figured out it was useful to add more things to the
1109 // runtime so we created libclang_rt.osx.a to provide new functions when
1110 // deploying to old OS builds, and for a long time we had both eprintf and
1111 // osx builtin libraries. Which just seems excessive. So with PR 28855, we
1112 // are removing the eprintf library and expecting eprintf to be provided by
1113 // the OS X builtins library.
1114 if (isMacosxVersionLT(10, 5))
1115 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
1117 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
1121 /// Returns the most appropriate macOS target version for the current process.
1123 /// If the macOS SDK version is the same or earlier than the system version,
1124 /// then the SDK version is returned. Otherwise the system version is returned.
1125 static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion) {
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);
1131 VersionTuple SystemVersion(Major, Minor, Micro);
1133 if (!Driver::GetReleaseVersion(MacOSSDKVersion, Major, Minor, Micro,
1135 return MacOSSDKVersion;
1136 VersionTuple SDKVersion(Major, Minor, Micro);
1137 if (SDKVersion > SystemVersion)
1138 return SystemVersion.getAsString();
1139 return MacOSSDKVersion;
1142 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
1143 const OptTable &Opts = getDriver().getOpts();
1145 // Support allowing the SDKROOT environment variable used by xcrun and other
1146 // Xcode tools to define the default sysroot, by making it the default for
1148 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1149 // Warn if the path does not exist.
1150 if (!getVFS().exists(A->getValue()))
1151 getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
1153 if (char *env = ::getenv("SDKROOT")) {
1154 // We only use this value as the default if it is an absolute path,
1155 // exists, and it is not the root path.
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;
1177 // iOS 10 is the maximum deployment target for 32-bit targets.
1178 if (iOSVersion && getTriple().isArch32Bit() &&
1179 Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor, Micro,
1182 getDriver().Diag(diag::err_invalid_ios_deployment_target)
1183 << iOSVersion->getAsString(Args);
1185 // Add a macro to differentiate between m(iphone|tv|watch)os-version-min=X.Y and
1186 // -m(iphone|tv|watch)simulator-version-min=X.Y.
1187 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ) ||
1188 Args.hasArg(options::OPT_mtvos_simulator_version_min_EQ) ||
1189 Args.hasArg(options::OPT_mwatchos_simulator_version_min_EQ))
1190 Args.append(Args.MakeSeparateArg(nullptr, Opts.getOption(options::OPT_D),
1191 " __APPLE_EMBEDDED_SIMULATOR__=1"));
1193 if (OSXVersion && (iOSVersion || TvOSVersion || WatchOSVersion)) {
1194 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
1195 << OSXVersion->getAsString(Args)
1196 << (iOSVersion ? iOSVersion :
1197 TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
1198 iOSVersion = TvOSVersion = WatchOSVersion = nullptr;
1199 } else if (iOSVersion && (TvOSVersion || WatchOSVersion)) {
1200 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
1201 << iOSVersion->getAsString(Args)
1202 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
1203 TvOSVersion = WatchOSVersion = nullptr;
1204 } else if (TvOSVersion && WatchOSVersion) {
1205 getDriver().Diag(diag::err_drv_argument_not_allowed_with)
1206 << TvOSVersion->getAsString(Args)
1207 << WatchOSVersion->getAsString(Args);
1208 WatchOSVersion = nullptr;
1209 } else if (!OSXVersion && !iOSVersion && !TvOSVersion && !WatchOSVersion) {
1210 // If no deployment target was specified on the command line, check for
1211 // environment defines.
1212 std::string OSXTarget;
1213 std::string iOSTarget;
1214 std::string TvOSTarget;
1215 std::string WatchOSTarget;
1217 if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET"))
1219 if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"))
1221 if (char *env = ::getenv("TVOS_DEPLOYMENT_TARGET"))
1223 if (char *env = ::getenv("WATCHOS_DEPLOYMENT_TARGET"))
1224 WatchOSTarget = env;
1226 // iOS 10 is the maximum deployment target for 32-bit targets.
1227 if (!iOSTarget.empty() && getTriple().isArch32Bit() &&
1228 Driver::GetReleaseVersion(iOSTarget.c_str(), Major, Minor, Micro,
1231 getDriver().Diag(diag::err_invalid_ios_deployment_target)
1232 << std::string("IPHONEOS_DEPLOYMENT_TARGET=") + iOSTarget;
1234 // If there is no command-line argument to specify the Target version and
1235 // no environment variable defined, see if we can set the default based
1237 if (OSXTarget.empty() && iOSTarget.empty() && WatchOSTarget.empty() &&
1238 TvOSTarget.empty() && Args.hasArg(options::OPT_isysroot)) {
1239 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1240 StringRef isysroot = A->getValue();
1241 StringRef SDK = getSDKName(isysroot);
1242 if (SDK.size() > 0) {
1243 // Slice the version number out.
1244 // Version number is between the first and the last number.
1245 size_t StartVer = SDK.find_first_of("0123456789");
1246 size_t EndVer = SDK.find_last_of("0123456789");
1247 if (StartVer != StringRef::npos && EndVer > StartVer) {
1248 StringRef Version = SDK.slice(StartVer, EndVer + 1);
1249 if (SDK.startswith("iPhoneOS") ||
1250 SDK.startswith("iPhoneSimulator"))
1251 iOSTarget = Version;
1252 else if (SDK.startswith("MacOSX"))
1253 OSXTarget = getSystemOrSDKMacOSVersion(Version);
1254 else if (SDK.startswith("WatchOS") ||
1255 SDK.startswith("WatchSimulator"))
1256 WatchOSTarget = Version;
1257 else if (SDK.startswith("AppleTVOS") ||
1258 SDK.startswith("AppleTVSimulator"))
1259 TvOSTarget = Version;
1265 // If no OS targets have been specified, try to guess platform from -target
1266 // or arch name and compute the version from the triple.
1267 if (OSXTarget.empty() && iOSTarget.empty() && TvOSTarget.empty() &&
1268 WatchOSTarget.empty()) {
1269 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
1271 // Set the OSTy based on -target if -arch isn't present.
1272 if (Args.hasArg(options::OPT_target) && !Args.hasArg(options::OPT_arch)) {
1273 OSTy = getTriple().getOS();
1275 StringRef MachOArchName = getMachOArchName(Args);
1276 if (MachOArchName == "armv7" || MachOArchName == "armv7s" ||
1277 MachOArchName == "arm64")
1278 OSTy = llvm::Triple::IOS;
1279 else if (MachOArchName == "armv7k")
1280 OSTy = llvm::Triple::WatchOS;
1281 else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" &&
1282 MachOArchName != "armv7em")
1283 OSTy = llvm::Triple::MacOSX;
1287 if (OSTy != llvm::Triple::UnknownOS) {
1288 unsigned Major, Minor, Micro;
1289 std::string *OSTarget;
1292 case llvm::Triple::Darwin:
1293 case llvm::Triple::MacOSX:
1294 if (!getTriple().getMacOSXVersion(Major, Minor, Micro))
1295 getDriver().Diag(diag::err_drv_invalid_darwin_version)
1296 << getTriple().getOSName();
1297 OSTarget = &OSXTarget;
1299 case llvm::Triple::IOS:
1300 getTriple().getiOSVersion(Major, Minor, Micro);
1301 OSTarget = &iOSTarget;
1303 case llvm::Triple::TvOS:
1304 getTriple().getOSVersion(Major, Minor, Micro);
1305 OSTarget = &TvOSTarget;
1307 case llvm::Triple::WatchOS:
1308 getTriple().getWatchOSVersion(Major, Minor, Micro);
1309 OSTarget = &WatchOSTarget;
1312 llvm_unreachable("Unexpected OS type");
1316 llvm::raw_string_ostream(*OSTarget) << Major << '.' << Minor << '.'
1321 // Do not allow conflicts with the watchOS target.
1322 if (!WatchOSTarget.empty() && (!iOSTarget.empty() || !TvOSTarget.empty())) {
1323 getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
1324 << "WATCHOS_DEPLOYMENT_TARGET"
1325 << (!iOSTarget.empty() ? "IPHONEOS_DEPLOYMENT_TARGET" :
1326 "TVOS_DEPLOYMENT_TARGET");
1329 // Do not allow conflicts with the tvOS target.
1330 if (!TvOSTarget.empty() && !iOSTarget.empty()) {
1331 getDriver().Diag(diag::err_drv_conflicting_deployment_targets)
1332 << "TVOS_DEPLOYMENT_TARGET"
1333 << "IPHONEOS_DEPLOYMENT_TARGET";
1336 // Allow conflicts among OSX and iOS for historical reasons, but choose the
1337 // default platform.
1338 if (!OSXTarget.empty() && (!iOSTarget.empty() ||
1339 !WatchOSTarget.empty() ||
1340 !TvOSTarget.empty())) {
1341 if (getTriple().getArch() == llvm::Triple::arm ||
1342 getTriple().getArch() == llvm::Triple::aarch64 ||
1343 getTriple().getArch() == llvm::Triple::thumb)
1346 iOSTarget = WatchOSTarget = TvOSTarget = "";
1349 if (!OSXTarget.empty()) {
1350 const Option O = Opts.getOption(options::OPT_mmacosx_version_min_EQ);
1351 OSXVersion = Args.MakeJoinedArg(nullptr, O, OSXTarget);
1352 Args.append(OSXVersion);
1353 } else if (!iOSTarget.empty()) {
1354 const Option O = Opts.getOption(options::OPT_miphoneos_version_min_EQ);
1355 iOSVersion = Args.MakeJoinedArg(nullptr, O, iOSTarget);
1356 Args.append(iOSVersion);
1357 } else if (!TvOSTarget.empty()) {
1358 const Option O = Opts.getOption(options::OPT_mtvos_version_min_EQ);
1359 TvOSVersion = Args.MakeJoinedArg(nullptr, O, TvOSTarget);
1360 Args.append(TvOSVersion);
1361 } else if (!WatchOSTarget.empty()) {
1362 const Option O = Opts.getOption(options::OPT_mwatchos_version_min_EQ);
1363 WatchOSVersion = Args.MakeJoinedArg(nullptr, O, WatchOSTarget);
1364 Args.append(WatchOSVersion);
1368 DarwinPlatformKind Platform;
1371 else if (iOSVersion)
1372 Platform = IPhoneOS;
1373 else if (TvOSVersion)
1375 else if (WatchOSVersion)
1378 llvm_unreachable("Unable to infer Darwin variant");
1380 // Set the tool chain target information.
1381 if (Platform == MacOS) {
1382 assert((!iOSVersion && !TvOSVersion && !WatchOSVersion) &&
1383 "Unknown target platform!");
1384 if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor, Micro,
1386 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
1387 getDriver().Diag(diag::err_drv_invalid_version_number)
1388 << OSXVersion->getAsString(Args);
1389 } else if (Platform == IPhoneOS) {
1390 assert(iOSVersion && "Unknown target platform!");
1391 if (!Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor, Micro,
1393 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1394 getDriver().Diag(diag::err_drv_invalid_version_number)
1395 << iOSVersion->getAsString(Args);
1396 // iOS 10 is the maximum deployment target for 32-bit targets. If the
1397 // inferred deployment target is iOS 11 or later, set it to 10.99.
1398 if (getTriple().isArch32Bit() && Major >= 11) {
1403 } else if (Platform == TvOS) {
1404 if (!Driver::GetReleaseVersion(TvOSVersion->getValue(), Major, Minor,
1405 Micro, HadExtra) || HadExtra ||
1406 Major >= 100 || Minor >= 100 || Micro >= 100)
1407 getDriver().Diag(diag::err_drv_invalid_version_number)
1408 << TvOSVersion->getAsString(Args);
1409 } else if (Platform == WatchOS) {
1410 if (!Driver::GetReleaseVersion(WatchOSVersion->getValue(), Major, Minor,
1411 Micro, HadExtra) || HadExtra ||
1412 Major >= 10 || Minor >= 100 || Micro >= 100)
1413 getDriver().Diag(diag::err_drv_invalid_version_number)
1414 << WatchOSVersion->getAsString(Args);
1416 llvm_unreachable("unknown kind of Darwin platform");
1418 // Recognize iOS targets with an x86 architecture as the iOS simulator.
1419 if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
1420 getTriple().getArch() == llvm::Triple::x86_64))
1421 Platform = IPhoneOSSimulator;
1422 if (TvOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
1423 getTriple().getArch() == llvm::Triple::x86_64))
1424 Platform = TvOSSimulator;
1425 if (WatchOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
1426 getTriple().getArch() == llvm::Triple::x86_64))
1427 Platform = WatchOSSimulator;
1429 setTarget(Platform, Major, Minor, Micro);
1431 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1432 StringRef SDK = getSDKName(A->getValue());
1433 if (SDK.size() > 0) {
1434 size_t StartVer = SDK.find_first_of("0123456789");
1435 StringRef SDKName = SDK.slice(0, StartVer);
1436 if (!SDKName.startswith(getPlatformFamily()))
1437 getDriver().Diag(diag::warn_incompatible_sysroot)
1438 << SDKName << getPlatformFamily();
1443 void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
1444 ArgStringList &CmdArgs) const {
1445 CXXStdlibType Type = GetCXXStdlibType(Args);
1448 case ToolChain::CST_Libcxx:
1449 CmdArgs.push_back("-lc++");
1452 case ToolChain::CST_Libstdcxx:
1453 // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
1454 // it was previously found in the gcc lib dir. However, for all the Darwin
1455 // platforms we care about it was -lstdc++.6, so we search for that
1456 // explicitly if we can't see an obvious -lstdc++ candidate.
1458 // Check in the sysroot first.
1459 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1460 SmallString<128> P(A->getValue());
1461 llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
1463 if (!getVFS().exists(P)) {
1464 llvm::sys::path::remove_filename(P);
1465 llvm::sys::path::append(P, "libstdc++.6.dylib");
1466 if (getVFS().exists(P)) {
1467 CmdArgs.push_back(Args.MakeArgString(P));
1473 // Otherwise, look in the root.
1474 // FIXME: This should be removed someday when we don't have to care about
1475 // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
1476 if (!getVFS().exists("/usr/lib/libstdc++.dylib") &&
1477 getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
1478 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
1482 // Otherwise, let the linker search.
1483 CmdArgs.push_back("-lstdc++");
1488 void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
1489 ArgStringList &CmdArgs) const {
1490 // For Darwin platforms, use the compiler-rt-based support library
1491 // instead of the gcc-provided one (which is also incidentally
1492 // only present in the gcc lib dir, which makes it hard to find).
1494 SmallString<128> P(getDriver().ResourceDir);
1495 llvm::sys::path::append(P, "lib", "darwin");
1497 // Use the newer cc_kext for iOS ARM after 6.0.
1498 if (isTargetWatchOS()) {
1499 llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a");
1500 } else if (isTargetTvOS()) {
1501 llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a");
1502 } else if (isTargetIPhoneOS()) {
1503 llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
1505 llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
1508 // For now, allow missing resource libraries to support developers who may
1509 // not have compiler-rt checked out or integrated into their build.
1510 if (getVFS().exists(P))
1511 CmdArgs.push_back(Args.MakeArgString(P));
1514 DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args,
1515 StringRef BoundArch,
1516 Action::OffloadKind) const {
1517 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
1518 const OptTable &Opts = getDriver().getOpts();
1520 // FIXME: We really want to get out of the tool chain level argument
1521 // translation business, as it makes the driver functionality much
1522 // more opaque. For now, we follow gcc closely solely for the
1523 // purpose of easily achieving feature parity & testability. Once we
1524 // have something that works, we should reevaluate each translation
1525 // and try to push it down into tool specific logic.
1527 for (Arg *A : Args) {
1528 if (A->getOption().matches(options::OPT_Xarch__)) {
1529 // Skip this argument unless the architecture matches either the toolchain
1530 // triple arch, or the arch being bound.
1531 llvm::Triple::ArchType XarchArch =
1532 tools::darwin::getArchTypeForMachOArchName(A->getValue(0));
1533 if (!(XarchArch == getArch() ||
1534 (!BoundArch.empty() &&
1536 tools::darwin::getArchTypeForMachOArchName(BoundArch))))
1539 Arg *OriginalArg = A;
1540 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1541 unsigned Prev = Index;
1542 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1544 // If the argument parsing failed or more than one argument was
1545 // consumed, the -Xarch_ argument's parameter tried to consume
1546 // extra arguments. Emit an error and ignore.
1548 // We also want to disallow any options which would alter the
1549 // driver behavior; that isn't going to work in our model. We
1550 // use isDriverOption() as an approximation, although things
1551 // like -O4 are going to slip through.
1552 if (!XarchArg || Index > Prev + 1) {
1553 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1554 << A->getAsString(Args);
1556 } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
1557 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
1558 << A->getAsString(Args);
1562 XarchArg->setBaseArg(A);
1564 A = XarchArg.release();
1565 DAL->AddSynthesizedArg(A);
1567 // Linker input arguments require custom handling. The problem is that we
1568 // have already constructed the phase actions, so we can not treat them as
1569 // "input arguments".
1570 if (A->getOption().hasFlag(options::LinkerInput)) {
1571 // Convert the argument into individual Zlinker_input_args.
1572 for (const char *Value : A->getValues()) {
1573 DAL->AddSeparateArg(
1574 OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
1580 // Sob. These is strictly gcc compatible for the time being. Apple
1581 // gcc translates options twice, which means that self-expanding
1582 // options add duplicates.
1583 switch ((options::ID)A->getOption().getID()) {
1588 case options::OPT_mkernel:
1589 case options::OPT_fapple_kext:
1591 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
1594 case options::OPT_dependency_file:
1595 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
1598 case options::OPT_gfull:
1599 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1601 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
1604 case options::OPT_gused:
1605 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1607 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
1610 case options::OPT_shared:
1611 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
1614 case options::OPT_fconstant_cfstrings:
1615 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
1618 case options::OPT_fno_constant_cfstrings:
1619 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
1622 case options::OPT_Wnonportable_cfstrings:
1624 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
1627 case options::OPT_Wno_nonportable_cfstrings:
1629 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
1632 case options::OPT_fpascal_strings:
1633 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
1636 case options::OPT_fno_pascal_strings:
1637 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
1642 if (getTriple().getArch() == llvm::Triple::x86 ||
1643 getTriple().getArch() == llvm::Triple::x86_64)
1644 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
1645 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_mtune_EQ),
1648 // Add the arch options based on the particular spelling of -arch, to match
1649 // how the driver driver works.
1650 if (!BoundArch.empty()) {
1651 StringRef Name = BoundArch;
1652 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
1653 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
1655 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
1656 // which defines the list of which architectures we accept.
1659 else if (Name == "ppc601")
1660 DAL->AddJoinedArg(nullptr, MCpu, "601");
1661 else if (Name == "ppc603")
1662 DAL->AddJoinedArg(nullptr, MCpu, "603");
1663 else if (Name == "ppc604")
1664 DAL->AddJoinedArg(nullptr, MCpu, "604");
1665 else if (Name == "ppc604e")
1666 DAL->AddJoinedArg(nullptr, MCpu, "604e");
1667 else if (Name == "ppc750")
1668 DAL->AddJoinedArg(nullptr, MCpu, "750");
1669 else if (Name == "ppc7400")
1670 DAL->AddJoinedArg(nullptr, MCpu, "7400");
1671 else if (Name == "ppc7450")
1672 DAL->AddJoinedArg(nullptr, MCpu, "7450");
1673 else if (Name == "ppc970")
1674 DAL->AddJoinedArg(nullptr, MCpu, "970");
1676 else if (Name == "ppc64" || Name == "ppc64le")
1677 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1679 else if (Name == "i386")
1681 else if (Name == "i486")
1682 DAL->AddJoinedArg(nullptr, MArch, "i486");
1683 else if (Name == "i586")
1684 DAL->AddJoinedArg(nullptr, MArch, "i586");
1685 else if (Name == "i686")
1686 DAL->AddJoinedArg(nullptr, MArch, "i686");
1687 else if (Name == "pentium")
1688 DAL->AddJoinedArg(nullptr, MArch, "pentium");
1689 else if (Name == "pentium2")
1690 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
1691 else if (Name == "pentpro")
1692 DAL->AddJoinedArg(nullptr, MArch, "pentiumpro");
1693 else if (Name == "pentIIm3")
1694 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
1696 else if (Name == "x86_64")
1697 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1698 else if (Name == "x86_64h") {
1699 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1700 DAL->AddJoinedArg(nullptr, MArch, "x86_64h");
1703 else if (Name == "arm")
1704 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
1705 else if (Name == "armv4t")
1706 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
1707 else if (Name == "armv5")
1708 DAL->AddJoinedArg(nullptr, MArch, "armv5tej");
1709 else if (Name == "xscale")
1710 DAL->AddJoinedArg(nullptr, MArch, "xscale");
1711 else if (Name == "armv6")
1712 DAL->AddJoinedArg(nullptr, MArch, "armv6k");
1713 else if (Name == "armv6m")
1714 DAL->AddJoinedArg(nullptr, MArch, "armv6m");
1715 else if (Name == "armv7")
1716 DAL->AddJoinedArg(nullptr, MArch, "armv7a");
1717 else if (Name == "armv7em")
1718 DAL->AddJoinedArg(nullptr, MArch, "armv7em");
1719 else if (Name == "armv7k")
1720 DAL->AddJoinedArg(nullptr, MArch, "armv7k");
1721 else if (Name == "armv7m")
1722 DAL->AddJoinedArg(nullptr, MArch, "armv7m");
1723 else if (Name == "armv7s")
1724 DAL->AddJoinedArg(nullptr, MArch, "armv7s");
1730 void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
1731 ArgStringList &CmdArgs) const {
1732 // Embedded targets are simple at the moment, not supporting sanitizers and
1733 // with different libraries for each member of the product { static, PIC } x
1734 // { hard-float, soft-float }
1735 llvm::SmallString<32> CompilerRT = StringRef("libclang_rt.");
1737 (tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard)
1740 CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic.a" : "_static.a";
1742 AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, false, true);
1745 bool Darwin::isAlignedAllocationUnavailable() const {
1746 switch (TargetPlatform) {
1747 case MacOS: // Earlier than 10.13.
1748 return TargetVersion < VersionTuple(10U, 13U, 0U);
1750 case IPhoneOSSimulator:
1752 case TvOSSimulator: // Earlier than 11.0.
1753 return TargetVersion < VersionTuple(11U, 0U, 0U);
1755 case WatchOSSimulator: // Earlier than 4.0.
1756 return TargetVersion < VersionTuple(4U, 0U, 0U);
1758 llvm_unreachable("Unsupported platform");
1761 void Darwin::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
1762 llvm::opt::ArgStringList &CC1Args,
1763 Action::OffloadKind DeviceOffloadKind) const {
1764 if (isAlignedAllocationUnavailable())
1765 CC1Args.push_back("-faligned-alloc-unavailable");
1769 Darwin::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
1770 Action::OffloadKind DeviceOffloadKind) const {
1771 // First get the generic Apple args, before moving onto Darwin-specific ones.
1772 DerivedArgList *DAL =
1773 MachO::TranslateArgs(Args, BoundArch, DeviceOffloadKind);
1774 const OptTable &Opts = getDriver().getOpts();
1776 // If no architecture is bound, none of the translations here are relevant.
1777 if (BoundArch.empty())
1780 // Add an explicit version min argument for the deployment target. We do this
1781 // after argument translation because -Xarch_ arguments may add a version min
1783 AddDeploymentTarget(*DAL);
1785 // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
1786 // FIXME: It would be far better to avoid inserting those -static arguments,
1787 // but we can't check the deployment target in the translation code until
1789 if (isTargetWatchOSBased() ||
1790 (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0))) {
1791 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
1794 if (A->getOption().getID() != options::OPT_mkernel &&
1795 A->getOption().getID() != options::OPT_fapple_kext)
1797 assert(it != ie && "unexpected argument translation");
1799 assert(A->getOption().getID() == options::OPT_static &&
1800 "missing expected -static argument");
1806 if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
1807 GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
1808 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_stdlib_EQ),
1811 // Validate the C++ standard library choice.
1812 CXXStdlibType Type = GetCXXStdlibType(*DAL);
1813 if (Type == ToolChain::CST_Libcxx) {
1814 // Check whether the target provides libc++.
1817 // Complain about targeting iOS < 5.0 in any way.
1818 if (isTargetIOSBased() && isIPhoneOSVersionLT(5, 0))
1821 if (where != StringRef()) {
1822 getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
1826 auto Arch = tools::darwin::getArchTypeForMachOArchName(BoundArch);
1827 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
1828 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
1829 options::OPT_fno_omit_frame_pointer, false))
1830 getDriver().Diag(clang::diag::warn_drv_unsupported_opt_for_target)
1831 << "-fomit-frame-pointer" << BoundArch;
1837 bool MachO::IsUnwindTablesDefault() const {
1838 return getArch() == llvm::Triple::x86_64;
1841 bool MachO::UseDwarfDebugFlags() const {
1842 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
1843 return S[0] != '\0';
1847 bool Darwin::UseSjLjExceptions(const ArgList &Args) const {
1848 // Darwin uses SjLj exceptions on ARM.
1849 if (getTriple().getArch() != llvm::Triple::arm &&
1850 getTriple().getArch() != llvm::Triple::thumb)
1853 // Only watchOS uses the new DWARF/Compact unwinding method.
1854 llvm::Triple Triple(ComputeLLVMTriple(Args));
1855 return !Triple.isWatchABI();
1858 bool Darwin::SupportsEmbeddedBitcode() const {
1859 assert(TargetInitialized && "Target not initialized!");
1860 if (isTargetIPhoneOS() && isIPhoneOSVersionLT(6, 0))
1865 bool MachO::isPICDefault() const { return true; }
1867 bool MachO::isPIEDefault() const { return false; }
1869 bool MachO::isPICDefaultForced() const {
1870 return (getArch() == llvm::Triple::x86_64 ||
1871 getArch() == llvm::Triple::aarch64);
1874 bool MachO::SupportsProfiling() const {
1875 // Profiling instrumentation is only supported on x86.
1876 return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64;
1879 void Darwin::addMinVersionArgs(const ArgList &Args,
1880 ArgStringList &CmdArgs) const {
1881 VersionTuple TargetVersion = getTargetVersion();
1883 if (isTargetWatchOS())
1884 CmdArgs.push_back("-watchos_version_min");
1885 else if (isTargetWatchOSSimulator())
1886 CmdArgs.push_back("-watchos_simulator_version_min");
1887 else if (isTargetTvOS())
1888 CmdArgs.push_back("-tvos_version_min");
1889 else if (isTargetTvOSSimulator())
1890 CmdArgs.push_back("-tvos_simulator_version_min");
1891 else if (isTargetIOSSimulator())
1892 CmdArgs.push_back("-ios_simulator_version_min");
1893 else if (isTargetIOSBased())
1894 CmdArgs.push_back("-iphoneos_version_min");
1896 assert(isTargetMacOS() && "unexpected target");
1897 CmdArgs.push_back("-macosx_version_min");
1900 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
1903 void Darwin::addStartObjectFileArgs(const ArgList &Args,
1904 ArgStringList &CmdArgs) const {
1905 // Derived from startfile spec.
1906 if (Args.hasArg(options::OPT_dynamiclib)) {
1907 // Derived from darwin_dylib1 spec.
1908 if (isTargetWatchOSBased()) {
1909 ; // watchOS does not need dylib1.o.
1910 } else if (isTargetIOSSimulator()) {
1911 ; // iOS simulator does not need dylib1.o.
1912 } else if (isTargetIPhoneOS()) {
1913 if (isIPhoneOSVersionLT(3, 1))
1914 CmdArgs.push_back("-ldylib1.o");
1916 if (isMacosxVersionLT(10, 5))
1917 CmdArgs.push_back("-ldylib1.o");
1918 else if (isMacosxVersionLT(10, 6))
1919 CmdArgs.push_back("-ldylib1.10.5.o");
1922 if (Args.hasArg(options::OPT_bundle)) {
1923 if (!Args.hasArg(options::OPT_static)) {
1924 // Derived from darwin_bundle1 spec.
1925 if (isTargetWatchOSBased()) {
1926 ; // watchOS does not need bundle1.o.
1927 } else if (isTargetIOSSimulator()) {
1928 ; // iOS simulator does not need bundle1.o.
1929 } else if (isTargetIPhoneOS()) {
1930 if (isIPhoneOSVersionLT(3, 1))
1931 CmdArgs.push_back("-lbundle1.o");
1933 if (isMacosxVersionLT(10, 6))
1934 CmdArgs.push_back("-lbundle1.o");
1938 if (Args.hasArg(options::OPT_pg) && SupportsProfiling()) {
1939 if (Args.hasArg(options::OPT_static) ||
1940 Args.hasArg(options::OPT_object) ||
1941 Args.hasArg(options::OPT_preload)) {
1942 CmdArgs.push_back("-lgcrt0.o");
1944 CmdArgs.push_back("-lgcrt1.o");
1946 // darwin_crt2 spec is empty.
1948 // By default on OS X 10.8 and later, we don't link with a crt1.o
1949 // file and the linker knows to use _main as the entry point. But,
1950 // when compiling with -pg, we need to link with the gcrt1.o file,
1951 // so pass the -no_new_main option to tell the linker to use the
1952 // "start" symbol as the entry point.
1953 if (isTargetMacOS() && !isMacosxVersionLT(10, 8))
1954 CmdArgs.push_back("-no_new_main");
1956 if (Args.hasArg(options::OPT_static) ||
1957 Args.hasArg(options::OPT_object) ||
1958 Args.hasArg(options::OPT_preload)) {
1959 CmdArgs.push_back("-lcrt0.o");
1961 // Derived from darwin_crt1 spec.
1962 if (isTargetWatchOSBased()) {
1963 ; // watchOS does not need crt1.o.
1964 } else if (isTargetIOSSimulator()) {
1965 ; // iOS simulator does not need crt1.o.
1966 } else if (isTargetIPhoneOS()) {
1967 if (getArch() == llvm::Triple::aarch64)
1968 ; // iOS does not need any crt1 files for arm64
1969 else if (isIPhoneOSVersionLT(3, 1))
1970 CmdArgs.push_back("-lcrt1.o");
1971 else if (isIPhoneOSVersionLT(6, 0))
1972 CmdArgs.push_back("-lcrt1.3.1.o");
1974 if (isMacosxVersionLT(10, 5))
1975 CmdArgs.push_back("-lcrt1.o");
1976 else if (isMacosxVersionLT(10, 6))
1977 CmdArgs.push_back("-lcrt1.10.5.o");
1978 else if (isMacosxVersionLT(10, 8))
1979 CmdArgs.push_back("-lcrt1.10.6.o");
1981 // darwin_crt2 spec is empty.
1988 if (!isTargetIPhoneOS() && Args.hasArg(options::OPT_shared_libgcc) &&
1989 !isTargetWatchOS() &&
1990 isMacosxVersionLT(10, 5)) {
1991 const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
1992 CmdArgs.push_back(Str);
1996 bool Darwin::SupportsObjCGC() const { return isTargetMacOS(); }
1998 void Darwin::CheckObjCARC() const {
1999 if (isTargetIOSBased() || isTargetWatchOSBased() ||
2000 (isTargetMacOS() && !isMacosxVersionLT(10, 6)))
2002 getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
2005 SanitizerMask Darwin::getSupportedSanitizers() const {
2006 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
2007 SanitizerMask Res = ToolChain::getSupportedSanitizers();
2008 Res |= SanitizerKind::Address;
2009 Res |= SanitizerKind::Leak;
2010 Res |= SanitizerKind::Fuzzer;
2011 if (isTargetMacOS()) {
2012 if (!isMacosxVersionLT(10, 9))
2013 Res |= SanitizerKind::Vptr;
2014 Res |= SanitizerKind::SafeStack;
2016 Res |= SanitizerKind::Thread;
2017 } else if (isTargetIOSSimulator() || isTargetTvOSSimulator()) {
2019 Res |= SanitizerKind::Thread;
2024 void Darwin::printVerboseInfo(raw_ostream &OS) const {
2025 CudaInstallation.print(OS);