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 /// 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 /// 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 and other
456 // opt-remarks flags.
457 if (Args.hasFlag(options::OPT_fsave_optimization_record,
458 options::OPT_fno_save_optimization_record, false)) {
459 CmdArgs.push_back("-mllvm");
460 CmdArgs.push_back("-lto-pass-remarks-output");
461 CmdArgs.push_back("-mllvm");
464 F = Output.getFilename();
466 CmdArgs.push_back(Args.MakeArgString(F));
468 if (getLastProfileUseArg(Args)) {
469 CmdArgs.push_back("-mllvm");
470 CmdArgs.push_back("-lto-pass-remarks-with-hotness");
473 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
474 CmdArgs.push_back("-mllvm");
476 std::string("-lto-pass-remarks-hotness-threshold=") + A->getValue();
477 CmdArgs.push_back(Args.MakeArgString(Opt));
482 // Propagate the -moutline flag to the linker in LTO.
483 if (Args.hasFlag(options::OPT_moutline, options::OPT_mno_outline, false)) {
484 if (getMachOToolChain().getMachOArchName(Args) == "arm64") {
485 CmdArgs.push_back("-mllvm");
486 CmdArgs.push_back("-enable-machine-outliner");
488 // Outline from linkonceodr functions by default in LTO.
489 CmdArgs.push_back("-mllvm");
490 CmdArgs.push_back("-enable-linkonceodr-outlining");
494 // It seems that the 'e' option is completely ignored for dynamic executables
495 // (the default), and with static executables, the last one wins, as expected.
496 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
497 options::OPT_Z_Flag, options::OPT_u_Group,
498 options::OPT_e, options::OPT_r});
500 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
501 // members of static archive libraries which implement Objective-C classes or
503 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
504 CmdArgs.push_back("-ObjC");
506 CmdArgs.push_back("-o");
507 CmdArgs.push_back(Output.getFilename());
509 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
510 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
512 // SafeStack requires its own runtime libraries
513 // These libraries should be linked first, to make sure the
514 // __safestack_init constructor executes before everything else
515 if (getToolChain().getSanitizerArgs().needsSafeStackRt()) {
516 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs,
517 "libclang_rt.safestack_osx.a",
518 toolchains::Darwin::RLO_AlwaysLink);
521 Args.AddAllArgs(CmdArgs, options::OPT_L);
523 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
524 // Build the input file for -filelist (list of linker input files) in case we
526 for (const auto &II : Inputs) {
527 if (!II.isFilename()) {
528 // This is a linker input argument.
529 // We cannot mix input arguments and file names in a -filelist input, thus
530 // we prematurely stop our list (remaining files shall be passed as
532 if (InputFileList.size() > 0)
538 InputFileList.push_back(II.getFilename());
541 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
542 addOpenMPRuntime(CmdArgs, getToolChain(), Args);
544 if (isObjCRuntimeLinked(Args) &&
545 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
546 // We use arclite library for both ARC and subscripting support.
547 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
549 CmdArgs.push_back("-framework");
550 CmdArgs.push_back("Foundation");
552 CmdArgs.push_back("-lobjc");
556 CmdArgs.push_back("-arch_multiple");
557 CmdArgs.push_back("-final_output");
558 CmdArgs.push_back(LinkingOutput);
561 if (Args.hasArg(options::OPT_fnested_functions))
562 CmdArgs.push_back("-allow_stack_execute");
564 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
566 if (unsigned Parallelism =
567 getLTOParallelism(Args, getToolChain().getDriver())) {
568 CmdArgs.push_back("-mllvm");
569 CmdArgs.push_back(Args.MakeArgString("-threads=" + Twine(Parallelism)));
572 if (getToolChain().ShouldLinkCXXStdlib(Args))
573 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
574 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
575 // link_ssp spec is empty.
577 // Let the tool chain choose which runtime library to link.
578 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs);
580 // No need to do anything for pthreads. Claim argument to avoid warning.
581 Args.ClaimAllArgs(options::OPT_pthread);
582 Args.ClaimAllArgs(options::OPT_pthreads);
585 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
586 // endfile_spec is empty.
589 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
590 Args.AddAllArgs(CmdArgs, options::OPT_F);
592 // -iframework should be forwarded as -F.
593 for (const Arg *A : Args.filtered(options::OPT_iframework))
594 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
596 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
597 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
598 if (A->getValue() == StringRef("Accelerate")) {
599 CmdArgs.push_back("-framework");
600 CmdArgs.push_back("Accelerate");
605 const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
606 std::unique_ptr<Command> Cmd =
607 llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs);
608 Cmd->setInputFileList(std::move(InputFileList));
609 C.addCommand(std::move(Cmd));
612 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
613 const InputInfo &Output,
614 const InputInfoList &Inputs,
616 const char *LinkingOutput) const {
617 ArgStringList CmdArgs;
619 CmdArgs.push_back("-create");
620 assert(Output.isFilename() && "Unexpected lipo output.");
622 CmdArgs.push_back("-output");
623 CmdArgs.push_back(Output.getFilename());
625 for (const auto &II : Inputs) {
626 assert(II.isFilename() && "Unexpected lipo input.");
627 CmdArgs.push_back(II.getFilename());
630 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
631 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
634 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
635 const InputInfo &Output,
636 const InputInfoList &Inputs,
638 const char *LinkingOutput) const {
639 ArgStringList CmdArgs;
641 CmdArgs.push_back("-o");
642 CmdArgs.push_back(Output.getFilename());
644 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
645 const InputInfo &Input = Inputs[0];
646 assert(Input.isFilename() && "Unexpected dsymutil input.");
647 CmdArgs.push_back(Input.getFilename());
650 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
651 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
654 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
655 const InputInfo &Output,
656 const InputInfoList &Inputs,
658 const char *LinkingOutput) const {
659 ArgStringList CmdArgs;
660 CmdArgs.push_back("--verify");
661 CmdArgs.push_back("--debug-info");
662 CmdArgs.push_back("--eh-frame");
663 CmdArgs.push_back("--quiet");
665 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
666 const InputInfo &Input = Inputs[0];
667 assert(Input.isFilename() && "Unexpected verify input");
669 // Grabbing the output of the earlier dsymutil run.
670 CmdArgs.push_back(Input.getFilename());
673 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
674 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
677 MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
678 : ToolChain(D, Triple, Args) {
679 // We expect 'as', 'ld', etc. to be adjacent to our install dir.
680 getProgramPaths().push_back(getDriver().getInstalledDir());
681 if (getDriver().getInstalledDir() != getDriver().Dir)
682 getProgramPaths().push_back(getDriver().Dir);
685 /// Darwin - Darwin tool chain for i386 and x86_64.
686 Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
687 : MachO(D, Triple, Args), TargetInitialized(false),
688 CudaInstallation(D, Triple, Args) {}
690 types::ID MachO::LookupTypeForExtension(StringRef Ext) const {
691 types::ID Ty = types::lookupTypeForExtension(Ext);
693 // Darwin always preprocesses assembly files (unless -x is used explicitly).
694 if (Ty == types::TY_PP_Asm)
695 return types::TY_Asm;
700 bool MachO::HasNativeLLVMSupport() const { return true; }
702 ToolChain::CXXStdlibType Darwin::GetDefaultCXXStdlibType() const {
703 // Default to use libc++ on OS X 10.9+ and iOS 7+.
704 if ((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
705 (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
706 isTargetWatchOSBased())
707 return ToolChain::CST_Libcxx;
709 return ToolChain::CST_Libstdcxx;
712 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
713 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
714 if (isTargetWatchOSBased())
715 return ObjCRuntime(ObjCRuntime::WatchOS, TargetVersion);
716 if (isTargetIOSBased())
717 return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
719 return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
720 return ObjCRuntime(ObjCRuntime::FragileMacOSX, TargetVersion);
723 /// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
724 bool Darwin::hasBlocksRuntime() const {
725 if (isTargetWatchOSBased())
727 else if (isTargetIOSBased())
728 return !isIPhoneOSVersionLT(3, 2);
730 assert(isTargetMacOS() && "unexpected darwin target");
731 return !isMacosxVersionLT(10, 6);
735 void Darwin::AddCudaIncludeArgs(const ArgList &DriverArgs,
736 ArgStringList &CC1Args) const {
737 CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
740 // This is just a MachO name translation routine and there's no
741 // way to join this into ARMTargetParser without breaking all
742 // other assumptions. Maybe MachO should consider standardising
743 // their nomenclature.
744 static const char *ArmMachOArchName(StringRef Arch) {
745 return llvm::StringSwitch<const char *>(Arch)
746 .Case("armv6k", "armv6")
747 .Case("armv6m", "armv6m")
748 .Case("armv5tej", "armv5")
749 .Case("xscale", "xscale")
750 .Case("armv4t", "armv4t")
751 .Case("armv7", "armv7")
752 .Cases("armv7a", "armv7-a", "armv7")
753 .Cases("armv7r", "armv7-r", "armv7")
754 .Cases("armv7em", "armv7e-m", "armv7em")
755 .Cases("armv7k", "armv7-k", "armv7k")
756 .Cases("armv7m", "armv7-m", "armv7m")
757 .Cases("armv7s", "armv7-s", "armv7s")
761 static const char *ArmMachOArchNameCPU(StringRef CPU) {
762 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
763 if (ArchKind == llvm::ARM::ArchKind::INVALID)
765 StringRef Arch = llvm::ARM::getArchName(ArchKind);
767 // FIXME: Make sure this MachO triple mangling is really necessary.
768 // ARMv5* normalises to ARMv5.
769 if (Arch.startswith("armv5"))
770 Arch = Arch.substr(0, 5);
771 // ARMv6*, except ARMv6M, normalises to ARMv6.
772 else if (Arch.startswith("armv6") && !Arch.endswith("6m"))
773 Arch = Arch.substr(0, 5);
774 // ARMv7A normalises to ARMv7.
775 else if (Arch.endswith("v7a"))
776 Arch = Arch.substr(0, 5);
780 StringRef MachO::getMachOArchName(const ArgList &Args) const {
781 switch (getTriple().getArch()) {
783 return getDefaultUniversalArchName();
785 case llvm::Triple::aarch64:
788 case llvm::Triple::thumb:
789 case llvm::Triple::arm:
790 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
791 if (const char *Arch = ArmMachOArchName(A->getValue()))
794 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
795 if (const char *Arch = ArmMachOArchNameCPU(A->getValue()))
806 std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
807 types::ID InputType) const {
808 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
810 // If the target isn't initialized (e.g., an unknown Darwin platform, return
811 // the default triple).
812 if (!isTargetInitialized())
813 return Triple.getTriple();
816 if (isTargetWatchOSBased())
818 else if (isTargetTvOSBased())
820 else if (isTargetIOSBased())
824 Str += getTargetVersion().getAsString();
825 Triple.setOSName(Str);
827 return Triple.getTriple();
830 Tool *MachO::getTool(Action::ActionClass AC) const {
832 case Action::LipoJobClass:
834 Lipo.reset(new tools::darwin::Lipo(*this));
836 case Action::DsymutilJobClass:
838 Dsymutil.reset(new tools::darwin::Dsymutil(*this));
839 return Dsymutil.get();
840 case Action::VerifyDebugInfoJobClass:
842 VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
843 return VerifyDebug.get();
845 return ToolChain::getTool(AC);
849 Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); }
851 Tool *MachO::buildAssembler() const {
852 return new tools::darwin::Assembler(*this);
855 DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple,
857 : Darwin(D, Triple, Args) {}
859 void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const {
860 // For modern targets, promote certain warnings to errors.
861 if (isTargetWatchOSBased() || getTriple().isArch64Bit()) {
862 // Always enable -Wdeprecated-objc-isa-usage and promote it
864 CC1Args.push_back("-Wdeprecated-objc-isa-usage");
865 CC1Args.push_back("-Werror=deprecated-objc-isa-usage");
867 // For iOS and watchOS, also error about implicit function declarations,
868 // as that can impact calling conventions.
869 if (!isTargetMacOS())
870 CC1Args.push_back("-Werror=implicit-function-declaration");
874 void DarwinClang::AddLinkARCArgs(const ArgList &Args,
875 ArgStringList &CmdArgs) const {
876 // Avoid linking compatibility stubs on i386 mac.
877 if (isTargetMacOS() && getArch() == llvm::Triple::x86)
880 ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true);
882 if ((runtime.hasNativeARC() || !isObjCAutoRefCount(Args)) &&
883 runtime.hasSubscripting())
886 CmdArgs.push_back("-force_load");
887 SmallString<128> P(getDriver().ClangExecutable);
888 llvm::sys::path::remove_filename(P); // 'clang'
889 llvm::sys::path::remove_filename(P); // 'bin'
890 llvm::sys::path::append(P, "lib", "arc", "libarclite_");
891 // Mash in the platform.
892 if (isTargetWatchOSSimulator())
893 P += "watchsimulator";
894 else if (isTargetWatchOS())
896 else if (isTargetTvOSSimulator())
897 P += "appletvsimulator";
898 else if (isTargetTvOS())
900 else if (isTargetIOSSimulator())
901 P += "iphonesimulator";
902 else if (isTargetIPhoneOS())
908 CmdArgs.push_back(Args.MakeArgString(P));
911 unsigned DarwinClang::GetDefaultDwarfVersion() const {
912 // Default to use DWARF 2 on OS X 10.10 / iOS 8 and lower.
913 if ((isTargetMacOS() && isMacosxVersionLT(10, 11)) ||
914 (isTargetIOSBased() && isIPhoneOSVersionLT(9)))
919 void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
920 StringRef DarwinLibName,
921 RuntimeLinkOptions Opts) const {
922 SmallString<128> Dir(getDriver().ResourceDir);
923 llvm::sys::path::append(
924 Dir, "lib", (Opts & RLO_IsEmbedded) ? "macho_embedded" : "darwin");
926 SmallString<128> P(Dir);
927 llvm::sys::path::append(P, DarwinLibName);
929 // For now, allow missing resource libraries to support developers who may
930 // not have compiler-rt checked out or integrated into their build (unless
931 // we explicitly force linking with this library).
932 if ((Opts & RLO_AlwaysLink) || getVFS().exists(P)) {
933 const char *LibArg = Args.MakeArgString(P);
934 if (Opts & RLO_FirstLink)
935 CmdArgs.insert(CmdArgs.begin(), LibArg);
937 CmdArgs.push_back(LibArg);
940 // Adding the rpaths might negatively interact when other rpaths are involved,
941 // so we should make sure we add the rpaths last, after all user-specified
942 // rpaths. This is currently true from this place, but we need to be
943 // careful if this function is ever called before user's rpaths are emitted.
944 if (Opts & RLO_AddRPath) {
945 assert(DarwinLibName.endswith(".dylib") && "must be a dynamic library");
947 // Add @executable_path to rpath to support having the dylib copied with
949 CmdArgs.push_back("-rpath");
950 CmdArgs.push_back("@executable_path");
952 // Add the path to the resource dir to rpath to support using the dylib
953 // from the default location without copying.
954 CmdArgs.push_back("-rpath");
955 CmdArgs.push_back(Args.MakeArgString(Dir));
959 StringRef Darwin::getPlatformFamily() const {
960 switch (TargetPlatform) {
961 case DarwinPlatformKind::MacOS:
963 case DarwinPlatformKind::IPhoneOS:
965 case DarwinPlatformKind::TvOS:
967 case DarwinPlatformKind::WatchOS:
970 llvm_unreachable("Unsupported platform");
973 StringRef Darwin::getSDKName(StringRef isysroot) {
974 // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk
975 llvm::sys::path::const_iterator SDKDir;
976 auto BeginSDK = llvm::sys::path::begin(isysroot);
977 auto EndSDK = llvm::sys::path::end(isysroot);
978 for (auto IT = BeginSDK; IT != EndSDK; ++IT) {
980 if (SDK.endswith(".sdk"))
981 return SDK.slice(0, SDK.size() - 4);
986 StringRef Darwin::getOSLibraryNameSuffix() const {
987 switch(TargetPlatform) {
988 case DarwinPlatformKind::MacOS:
990 case DarwinPlatformKind::IPhoneOS:
991 return TargetEnvironment == NativeEnvironment ? "ios" : "iossim";
992 case DarwinPlatformKind::TvOS:
993 return TargetEnvironment == NativeEnvironment ? "tvos" : "tvossim";
994 case DarwinPlatformKind::WatchOS:
995 return TargetEnvironment == NativeEnvironment ? "watchos" : "watchossim";
997 llvm_unreachable("Unsupported platform");
1000 /// Check if the link command contains a symbol export directive.
1001 static bool hasExportSymbolDirective(const ArgList &Args) {
1002 for (Arg *A : Args) {
1003 if (A->getOption().matches(options::OPT_exported__symbols__list))
1005 if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
1006 !A->getOption().matches(options::OPT_Xlinker))
1008 if (A->containsValue("-exported_symbols_list") ||
1009 A->containsValue("-exported_symbol"))
1015 /// Add an export directive for \p Symbol to the link command.
1016 static void addExportedSymbol(ArgStringList &CmdArgs, const char *Symbol) {
1017 CmdArgs.push_back("-exported_symbol");
1018 CmdArgs.push_back(Symbol);
1021 void Darwin::addProfileRTLibs(const ArgList &Args,
1022 ArgStringList &CmdArgs) const {
1023 if (!needsProfileRT(Args)) return;
1027 (Twine("libclang_rt.profile_") + getOSLibraryNameSuffix() + ".a").str(),
1028 RuntimeLinkOptions(RLO_AlwaysLink | RLO_FirstLink));
1030 // If we have a symbol export directive and we're linking in the profile
1031 // runtime, automatically export symbols necessary to implement some of the
1032 // runtime's functionality.
1033 if (hasExportSymbolDirective(Args)) {
1034 addExportedSymbol(CmdArgs, "___llvm_profile_filename");
1035 addExportedSymbol(CmdArgs, "___llvm_profile_raw_version");
1036 addExportedSymbol(CmdArgs, "_lprofCurFilename");
1040 void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
1041 ArgStringList &CmdArgs,
1042 StringRef Sanitizer,
1043 bool Shared) const {
1044 auto RLO = RuntimeLinkOptions(RLO_AlwaysLink | (Shared ? RLO_AddRPath : 0U));
1045 AddLinkRuntimeLib(Args, CmdArgs,
1046 (Twine("libclang_rt.") + Sanitizer + "_" +
1047 getOSLibraryNameSuffix() +
1048 (Shared ? "_dynamic.dylib" : ".a"))
1053 ToolChain::RuntimeLibType DarwinClang::GetRuntimeLibType(
1054 const ArgList &Args) const {
1055 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1056 StringRef Value = A->getValue();
1057 if (Value != "compiler-rt")
1058 getDriver().Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1059 << Value << "darwin";
1062 return ToolChain::RLT_CompilerRT;
1065 void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
1066 ArgStringList &CmdArgs) const {
1067 // Call once to ensure diagnostic is printed if wrong value was specified
1068 GetRuntimeLibType(Args);
1070 // Darwin doesn't support real static executables, don't link any runtime
1071 // libraries with -static.
1072 if (Args.hasArg(options::OPT_static) ||
1073 Args.hasArg(options::OPT_fapple_kext) ||
1074 Args.hasArg(options::OPT_mkernel))
1077 // Reject -static-libgcc for now, we can deal with this when and if someone
1078 // cares. This is useful in situations where someone wants to statically link
1079 // something like libstdc++, and needs its runtime support routines.
1080 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1081 getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1085 const SanitizerArgs &Sanitize = getSanitizerArgs();
1086 if (Sanitize.needsAsanRt())
1087 AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
1088 if (Sanitize.needsLsanRt())
1089 AddLinkSanitizerLibArgs(Args, CmdArgs, "lsan");
1090 if (Sanitize.needsUbsanRt())
1091 AddLinkSanitizerLibArgs(Args, CmdArgs,
1092 Sanitize.requiresMinimalRuntime() ? "ubsan_minimal"
1094 Sanitize.needsSharedRt());
1095 if (Sanitize.needsTsanRt())
1096 AddLinkSanitizerLibArgs(Args, CmdArgs, "tsan");
1097 if (Sanitize.needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1098 AddLinkSanitizerLibArgs(Args, CmdArgs, "fuzzer", /*shared=*/false);
1100 // Libfuzzer is written in C++ and requires libcxx.
1101 AddCXXStdlibLibArgs(Args, CmdArgs);
1103 if (Sanitize.needsStatsRt()) {
1104 StringRef OS = isTargetMacOS() ? "osx" : "iossim";
1105 AddLinkRuntimeLib(Args, CmdArgs,
1106 (Twine("libclang_rt.stats_client_") + OS + ".a").str(),
1108 AddLinkSanitizerLibArgs(Args, CmdArgs, "stats");
1110 if (Sanitize.needsEsanRt())
1111 AddLinkSanitizerLibArgs(Args, CmdArgs, "esan");
1113 // Otherwise link libSystem, then the dynamic runtime library, and finally any
1114 // target specific static runtime library.
1115 CmdArgs.push_back("-lSystem");
1117 // Select the dynamic runtime library and the target specific static library.
1118 if (isTargetWatchOSBased()) {
1119 // We currently always need a static runtime library for watchOS.
1120 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.watchos.a");
1121 } else if (isTargetTvOSBased()) {
1122 // We currently always need a static runtime library for tvOS.
1123 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.tvos.a");
1124 } else if (isTargetIOSBased()) {
1125 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
1126 // it never went into the SDK.
1127 // Linking against libgcc_s.1 isn't needed for iOS 5.0+
1128 if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() &&
1129 getTriple().getArch() != llvm::Triple::aarch64)
1130 CmdArgs.push_back("-lgcc_s.1");
1132 // We currently always need a static runtime library for iOS.
1133 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a");
1135 assert(isTargetMacOS() && "unexpected non MacOS platform");
1136 // The dynamic runtime library was merged with libSystem for 10.6 and
1137 // beyond; only 10.4 and 10.5 need an additional runtime library.
1138 if (isMacosxVersionLT(10, 5))
1139 CmdArgs.push_back("-lgcc_s.10.4");
1140 else if (isMacosxVersionLT(10, 6))
1141 CmdArgs.push_back("-lgcc_s.10.5");
1143 // Originally for OS X, we thought we would only need a static runtime
1144 // library when targeting 10.4, to provide versions of the static functions
1145 // which were omitted from 10.4.dylib. This led to the creation of the 10.4
1146 // builtins library.
1148 // Unfortunately, that turned out to not be true, because Darwin system
1149 // headers can still use eprintf on i386, and it is not exported from
1150 // libSystem. Therefore, we still must provide a runtime library just for
1151 // the tiny tiny handful of projects that *might* use that symbol.
1153 // Then over time, we figured out it was useful to add more things to the
1154 // runtime so we created libclang_rt.osx.a to provide new functions when
1155 // deploying to old OS builds, and for a long time we had both eprintf and
1156 // osx builtin libraries. Which just seems excessive. So with PR 28855, we
1157 // are removing the eprintf library and expecting eprintf to be provided by
1158 // the OS X builtins library.
1159 if (isMacosxVersionLT(10, 5))
1160 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a");
1162 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a");
1166 /// Returns the most appropriate macOS target version for the current process.
1168 /// If the macOS SDK version is the same or earlier than the system version,
1169 /// then the SDK version is returned. Otherwise the system version is returned.
1170 static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion) {
1171 unsigned Major, Minor, Micro;
1172 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1173 if (!SystemTriple.isMacOSX())
1174 return MacOSSDKVersion;
1175 SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1176 VersionTuple SystemVersion(Major, Minor, Micro);
1178 if (!Driver::GetReleaseVersion(MacOSSDKVersion, Major, Minor, Micro,
1180 return MacOSSDKVersion;
1181 VersionTuple SDKVersion(Major, Minor, Micro);
1182 if (SDKVersion > SystemVersion)
1183 return SystemVersion.getAsString();
1184 return MacOSSDKVersion;
1189 /// The Darwin OS that was selected or inferred from arguments / environment.
1190 struct DarwinPlatform {
1192 /// The OS was specified using the -target argument.
1194 /// The OS was specified using the -m<os>-version-min argument.
1196 /// The OS was specified using the OS_DEPLOYMENT_TARGET environment.
1197 DeploymentTargetEnv,
1198 /// The OS was inferred from the SDK.
1200 /// The OS was inferred from the -arch.
1204 using DarwinPlatformKind = Darwin::DarwinPlatformKind;
1205 using DarwinEnvironmentKind = Darwin::DarwinEnvironmentKind;
1207 DarwinPlatformKind getPlatform() const { return Platform; }
1209 DarwinEnvironmentKind getEnvironment() const { return Environment; }
1211 void setEnvironment(DarwinEnvironmentKind Kind) {
1213 InferSimulatorFromArch = false;
1216 StringRef getOSVersion() const {
1217 if (Kind == OSVersionArg)
1218 return Argument->getValue();
1222 void setOSVersion(StringRef S) {
1223 assert(Kind == TargetArg && "Unexpected kind!");
1227 bool hasOSVersion() const { return HasOSVersion; }
1229 /// Returns true if the target OS was explicitly specified.
1230 bool isExplicitlySpecified() const { return Kind <= DeploymentTargetEnv; }
1232 /// Returns true if the simulator environment can be inferred from the arch.
1233 bool canInferSimulatorFromArch() const { return InferSimulatorFromArch; }
1235 /// Adds the -m<os>-version-min argument to the compiler invocation.
1236 void addOSVersionMinArgument(DerivedArgList &Args, const OptTable &Opts) {
1239 assert(Kind != TargetArg && Kind != OSVersionArg && "Invalid kind");
1242 case DarwinPlatformKind::MacOS:
1243 Opt = options::OPT_mmacosx_version_min_EQ;
1245 case DarwinPlatformKind::IPhoneOS:
1246 Opt = options::OPT_miphoneos_version_min_EQ;
1248 case DarwinPlatformKind::TvOS:
1249 Opt = options::OPT_mtvos_version_min_EQ;
1251 case DarwinPlatformKind::WatchOS:
1252 Opt = options::OPT_mwatchos_version_min_EQ;
1255 Argument = Args.MakeJoinedArg(nullptr, Opts.getOption(Opt), OSVersion);
1256 Args.append(Argument);
1259 /// Returns the OS version with the argument / environment variable that
1261 std::string getAsString(DerivedArgList &Args, const OptTable &Opts) {
1265 case InferredFromSDK:
1266 case InferredFromArch:
1267 assert(Argument && "OS version argument not yet inferred");
1268 return Argument->getAsString(Args);
1269 case DeploymentTargetEnv:
1270 return (llvm::Twine(EnvVarName) + "=" + OSVersion).str();
1272 llvm_unreachable("Unsupported Darwin Source Kind");
1275 static DarwinPlatform createFromTarget(const llvm::Triple &TT,
1276 StringRef OSVersion, Arg *A) {
1277 DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
1279 switch (TT.getEnvironment()) {
1280 case llvm::Triple::Simulator:
1281 Result.Environment = DarwinEnvironmentKind::Simulator;
1286 unsigned Major, Minor, Micro;
1287 TT.getOSVersion(Major, Minor, Micro);
1289 Result.HasOSVersion = false;
1292 static DarwinPlatform createOSVersionArg(DarwinPlatformKind Platform,
1294 return DarwinPlatform(OSVersionArg, Platform, A);
1296 static DarwinPlatform createDeploymentTargetEnv(DarwinPlatformKind Platform,
1297 StringRef EnvVarName,
1299 DarwinPlatform Result(DeploymentTargetEnv, Platform, Value);
1300 Result.EnvVarName = EnvVarName;
1303 static DarwinPlatform createFromSDK(DarwinPlatformKind Platform,
1305 bool IsSimulator = false) {
1306 DarwinPlatform Result(InferredFromSDK, Platform, Value);
1308 Result.Environment = DarwinEnvironmentKind::Simulator;
1309 Result.InferSimulatorFromArch = false;
1312 static DarwinPlatform createFromArch(llvm::Triple::OSType OS,
1314 return DarwinPlatform(InferredFromArch, getPlatformFromOS(OS), Value);
1318 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, Arg *Argument)
1319 : Kind(Kind), Platform(Platform), Argument(Argument) {}
1320 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, StringRef Value,
1321 Arg *Argument = nullptr)
1322 : Kind(Kind), Platform(Platform), OSVersion(Value), Argument(Argument) {}
1324 static DarwinPlatformKind getPlatformFromOS(llvm::Triple::OSType OS) {
1326 case llvm::Triple::Darwin:
1327 case llvm::Triple::MacOSX:
1328 return DarwinPlatformKind::MacOS;
1329 case llvm::Triple::IOS:
1330 return DarwinPlatformKind::IPhoneOS;
1331 case llvm::Triple::TvOS:
1332 return DarwinPlatformKind::TvOS;
1333 case llvm::Triple::WatchOS:
1334 return DarwinPlatformKind::WatchOS;
1336 llvm_unreachable("Unable to infer Darwin variant");
1341 DarwinPlatformKind Platform;
1342 DarwinEnvironmentKind Environment = DarwinEnvironmentKind::NativeEnvironment;
1343 std::string OSVersion;
1344 bool HasOSVersion = true, InferSimulatorFromArch = true;
1346 StringRef EnvVarName;
1349 /// Returns the deployment target that's specified using the -m<os>-version-min
1351 Optional<DarwinPlatform>
1352 getDeploymentTargetFromOSVersionArg(DerivedArgList &Args,
1353 const Driver &TheDriver) {
1354 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ);
1355 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ,
1356 options::OPT_mios_simulator_version_min_EQ);
1358 Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1359 options::OPT_mtvos_simulator_version_min_EQ);
1360 Arg *WatchOSVersion =
1361 Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1362 options::OPT_mwatchos_simulator_version_min_EQ);
1364 if (iOSVersion || TvOSVersion || WatchOSVersion) {
1365 TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1366 << OSXVersion->getAsString(Args)
1367 << (iOSVersion ? iOSVersion
1368 : TvOSVersion ? TvOSVersion : WatchOSVersion)
1369 ->getAsString(Args);
1371 return DarwinPlatform::createOSVersionArg(Darwin::MacOS, OSXVersion);
1372 } else if (iOSVersion) {
1373 if (TvOSVersion || WatchOSVersion) {
1374 TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1375 << iOSVersion->getAsString(Args)
1376 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
1378 return DarwinPlatform::createOSVersionArg(Darwin::IPhoneOS, iOSVersion);
1379 } else if (TvOSVersion) {
1380 if (WatchOSVersion) {
1381 TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1382 << TvOSVersion->getAsString(Args)
1383 << WatchOSVersion->getAsString(Args);
1385 return DarwinPlatform::createOSVersionArg(Darwin::TvOS, TvOSVersion);
1386 } else if (WatchOSVersion)
1387 return DarwinPlatform::createOSVersionArg(Darwin::WatchOS, WatchOSVersion);
1391 /// Returns the deployment target that's specified using the
1392 /// OS_DEPLOYMENT_TARGET environment variable.
1393 Optional<DarwinPlatform>
1394 getDeploymentTargetFromEnvironmentVariables(const Driver &TheDriver,
1395 const llvm::Triple &Triple) {
1396 std::string Targets[Darwin::LastDarwinPlatform + 1];
1397 const char *EnvVars[] = {
1398 "MACOSX_DEPLOYMENT_TARGET",
1399 "IPHONEOS_DEPLOYMENT_TARGET",
1400 "TVOS_DEPLOYMENT_TARGET",
1401 "WATCHOS_DEPLOYMENT_TARGET",
1403 static_assert(llvm::array_lengthof(EnvVars) == Darwin::LastDarwinPlatform + 1,
1404 "Missing platform");
1405 for (const auto &I : llvm::enumerate(llvm::makeArrayRef(EnvVars))) {
1406 if (char *Env = ::getenv(I.value()))
1407 Targets[I.index()] = Env;
1410 // Do not allow conflicts with the watchOS target.
1411 if (!Targets[Darwin::WatchOS].empty() &&
1412 (!Targets[Darwin::IPhoneOS].empty() || !Targets[Darwin::TvOS].empty())) {
1413 TheDriver.Diag(diag::err_drv_conflicting_deployment_targets)
1414 << "WATCHOS_DEPLOYMENT_TARGET"
1415 << (!Targets[Darwin::IPhoneOS].empty() ? "IPHONEOS_DEPLOYMENT_TARGET"
1416 : "TVOS_DEPLOYMENT_TARGET");
1419 // Do not allow conflicts with the tvOS target.
1420 if (!Targets[Darwin::TvOS].empty() && !Targets[Darwin::IPhoneOS].empty()) {
1421 TheDriver.Diag(diag::err_drv_conflicting_deployment_targets)
1422 << "TVOS_DEPLOYMENT_TARGET"
1423 << "IPHONEOS_DEPLOYMENT_TARGET";
1426 // Allow conflicts among OSX and iOS for historical reasons, but choose the
1427 // default platform.
1428 if (!Targets[Darwin::MacOS].empty() &&
1429 (!Targets[Darwin::IPhoneOS].empty() ||
1430 !Targets[Darwin::WatchOS].empty() || !Targets[Darwin::TvOS].empty())) {
1431 if (Triple.getArch() == llvm::Triple::arm ||
1432 Triple.getArch() == llvm::Triple::aarch64 ||
1433 Triple.getArch() == llvm::Triple::thumb)
1434 Targets[Darwin::MacOS] = "";
1436 Targets[Darwin::IPhoneOS] = Targets[Darwin::WatchOS] =
1437 Targets[Darwin::TvOS] = "";
1440 for (const auto &Target : llvm::enumerate(llvm::makeArrayRef(Targets))) {
1441 if (!Target.value().empty())
1442 return DarwinPlatform::createDeploymentTargetEnv(
1443 (Darwin::DarwinPlatformKind)Target.index(), EnvVars[Target.index()],
1449 /// Tries to infer the deployment target from the SDK specified by -isysroot
1451 Optional<DarwinPlatform> inferDeploymentTargetFromSDK(DerivedArgList &Args) {
1452 const Arg *A = Args.getLastArg(options::OPT_isysroot);
1455 StringRef isysroot = A->getValue();
1456 StringRef SDK = Darwin::getSDKName(isysroot);
1459 // Slice the version number out.
1460 // Version number is between the first and the last number.
1461 size_t StartVer = SDK.find_first_of("0123456789");
1462 size_t EndVer = SDK.find_last_of("0123456789");
1463 if (StartVer != StringRef::npos && EndVer > StartVer) {
1464 StringRef Version = SDK.slice(StartVer, EndVer + 1);
1465 if (SDK.startswith("iPhoneOS") || SDK.startswith("iPhoneSimulator"))
1466 return DarwinPlatform::createFromSDK(
1467 Darwin::IPhoneOS, Version,
1468 /*IsSimulator=*/SDK.startswith("iPhoneSimulator"));
1469 else if (SDK.startswith("MacOSX"))
1470 return DarwinPlatform::createFromSDK(Darwin::MacOS,
1471 getSystemOrSDKMacOSVersion(Version));
1472 else if (SDK.startswith("WatchOS") || SDK.startswith("WatchSimulator"))
1473 return DarwinPlatform::createFromSDK(
1474 Darwin::WatchOS, Version,
1475 /*IsSimulator=*/SDK.startswith("WatchSimulator"));
1476 else if (SDK.startswith("AppleTVOS") || SDK.startswith("AppleTVSimulator"))
1477 return DarwinPlatform::createFromSDK(
1478 Darwin::TvOS, Version,
1479 /*IsSimulator=*/SDK.startswith("AppleTVSimulator"));
1484 std::string getOSVersion(llvm::Triple::OSType OS, const llvm::Triple &Triple,
1485 const Driver &TheDriver) {
1486 unsigned Major, Minor, Micro;
1487 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1489 case llvm::Triple::Darwin:
1490 case llvm::Triple::MacOSX:
1491 // If there is no version specified on triple, and both host and target are
1492 // macos, use the host triple to infer OS version.
1493 if (Triple.isMacOSX() && SystemTriple.isMacOSX() &&
1494 !Triple.getOSMajorVersion())
1495 SystemTriple.getMacOSXVersion(Major, Minor, Micro);
1496 else if (!Triple.getMacOSXVersion(Major, Minor, Micro))
1497 TheDriver.Diag(diag::err_drv_invalid_darwin_version)
1498 << Triple.getOSName();
1500 case llvm::Triple::IOS:
1501 Triple.getiOSVersion(Major, Minor, Micro);
1503 case llvm::Triple::TvOS:
1504 Triple.getOSVersion(Major, Minor, Micro);
1506 case llvm::Triple::WatchOS:
1507 Triple.getWatchOSVersion(Major, Minor, Micro);
1510 llvm_unreachable("Unexpected OS type");
1514 std::string OSVersion;
1515 llvm::raw_string_ostream(OSVersion) << Major << '.' << Minor << '.' << Micro;
1519 /// Tries to infer the target OS from the -arch.
1520 Optional<DarwinPlatform>
1521 inferDeploymentTargetFromArch(DerivedArgList &Args, const Darwin &Toolchain,
1522 const llvm::Triple &Triple,
1523 const Driver &TheDriver) {
1524 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
1526 StringRef MachOArchName = Toolchain.getMachOArchName(Args);
1527 if (MachOArchName == "armv7" || MachOArchName == "armv7s" ||
1528 MachOArchName == "arm64")
1529 OSTy = llvm::Triple::IOS;
1530 else if (MachOArchName == "armv7k")
1531 OSTy = llvm::Triple::WatchOS;
1532 else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" &&
1533 MachOArchName != "armv7em")
1534 OSTy = llvm::Triple::MacOSX;
1536 if (OSTy == llvm::Triple::UnknownOS)
1538 return DarwinPlatform::createFromArch(OSTy,
1539 getOSVersion(OSTy, Triple, TheDriver));
1542 /// Returns the deployment target that's specified using the -target option.
1543 Optional<DarwinPlatform> getDeploymentTargetFromTargetArg(
1544 DerivedArgList &Args, const llvm::Triple &Triple, const Driver &TheDriver) {
1545 if (!Args.hasArg(options::OPT_target))
1547 if (Triple.getOS() == llvm::Triple::Darwin ||
1548 Triple.getOS() == llvm::Triple::UnknownOS)
1550 std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
1551 return DarwinPlatform::createFromTarget(Triple, OSVersion,
1552 Args.getLastArg(options::OPT_target));
1557 void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
1558 const OptTable &Opts = getDriver().getOpts();
1560 // Support allowing the SDKROOT environment variable used by xcrun and other
1561 // Xcode tools to define the default sysroot, by making it the default for
1563 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1564 // Warn if the path does not exist.
1565 if (!getVFS().exists(A->getValue()))
1566 getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
1568 if (char *env = ::getenv("SDKROOT")) {
1569 // We only use this value as the default if it is an absolute path,
1570 // exists, and it is not the root path.
1571 if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) &&
1572 StringRef(env) != "/") {
1573 Args.append(Args.MakeSeparateArg(
1574 nullptr, Opts.getOption(options::OPT_isysroot), env));
1579 // The OS and the version can be specified using the -target argument.
1580 Optional<DarwinPlatform> OSTarget =
1581 getDeploymentTargetFromTargetArg(Args, getTriple(), getDriver());
1583 Optional<DarwinPlatform> OSVersionArgTarget =
1584 getDeploymentTargetFromOSVersionArg(Args, getDriver());
1585 if (OSVersionArgTarget) {
1586 unsigned TargetMajor, TargetMinor, TargetMicro;
1588 unsigned ArgMajor, ArgMinor, ArgMicro;
1590 if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
1591 (Driver::GetReleaseVersion(OSTarget->getOSVersion(), TargetMajor,
1592 TargetMinor, TargetMicro, TargetExtra) &&
1593 Driver::GetReleaseVersion(OSVersionArgTarget->getOSVersion(),
1594 ArgMajor, ArgMinor, ArgMicro, ArgExtra) &&
1595 (VersionTuple(TargetMajor, TargetMinor, TargetMicro) !=
1596 VersionTuple(ArgMajor, ArgMinor, ArgMicro) ||
1597 TargetExtra != ArgExtra))) {
1598 // Select the OS version from the -m<os>-version-min argument when
1599 // the -target does not include an OS version.
1600 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
1601 !OSTarget->hasOSVersion()) {
1602 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
1604 // Warn about -m<os>-version-min that doesn't match the OS version
1605 // that's specified in the target.
1606 std::string OSVersionArg =
1607 OSVersionArgTarget->getAsString(Args, Opts);
1608 std::string TargetArg = OSTarget->getAsString(Args, Opts);
1609 getDriver().Diag(clang::diag::warn_drv_overriding_flag_option)
1610 << OSVersionArg << TargetArg;
1615 // The OS target can be specified using the -m<os>version-min argument.
1616 OSTarget = getDeploymentTargetFromOSVersionArg(Args, getDriver());
1617 // If no deployment target was specified on the command line, check for
1618 // environment defines.
1621 getDeploymentTargetFromEnvironmentVariables(getDriver(), getTriple());
1623 // Don't infer simulator from the arch when the SDK is also specified.
1624 Optional<DarwinPlatform> SDKTarget = inferDeploymentTargetFromSDK(Args);
1626 OSTarget->setEnvironment(SDKTarget->getEnvironment());
1629 // If there is no command-line argument to specify the Target version and
1630 // no environment variable defined, see if we can set the default based
1633 OSTarget = inferDeploymentTargetFromSDK(Args);
1634 // If no OS targets have been specified, try to guess platform from -target
1635 // or arch name and compute the version from the triple.
1638 inferDeploymentTargetFromArch(Args, *this, getTriple(), getDriver());
1641 assert(OSTarget && "Unable to infer Darwin variant");
1642 OSTarget->addOSVersionMinArgument(Args, Opts);
1643 DarwinPlatformKind Platform = OSTarget->getPlatform();
1645 unsigned Major, Minor, Micro;
1647 // Set the tool chain target information.
1648 if (Platform == MacOS) {
1649 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1651 HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
1652 getDriver().Diag(diag::err_drv_invalid_version_number)
1653 << OSTarget->getAsString(Args, Opts);
1654 } else if (Platform == IPhoneOS) {
1655 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1657 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1658 getDriver().Diag(diag::err_drv_invalid_version_number)
1659 << OSTarget->getAsString(Args, Opts);
1661 // For 32-bit targets, the deployment target for iOS has to be earlier than
1663 if (getTriple().isArch32Bit() && Major >= 11) {
1664 // If the deployment target is explicitly specified, print a diagnostic.
1665 if (OSTarget->isExplicitlySpecified()) {
1666 getDriver().Diag(diag::warn_invalid_ios_deployment_target)
1667 << OSTarget->getAsString(Args, Opts);
1668 // Otherwise, set it to 10.99.99.
1675 } else if (Platform == TvOS) {
1676 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1678 HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
1679 getDriver().Diag(diag::err_drv_invalid_version_number)
1680 << OSTarget->getAsString(Args, Opts);
1681 } else if (Platform == WatchOS) {
1682 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
1684 HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
1685 getDriver().Diag(diag::err_drv_invalid_version_number)
1686 << OSTarget->getAsString(Args, Opts);
1688 llvm_unreachable("unknown kind of Darwin platform");
1690 DarwinEnvironmentKind Environment = OSTarget->getEnvironment();
1691 // Recognize iOS targets with an x86 architecture as the iOS simulator.
1692 if (Environment == NativeEnvironment && Platform != MacOS &&
1693 OSTarget->canInferSimulatorFromArch() &&
1694 (getTriple().getArch() == llvm::Triple::x86 ||
1695 getTriple().getArch() == llvm::Triple::x86_64))
1696 Environment = Simulator;
1698 setTarget(Platform, Environment, Major, Minor, Micro);
1700 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1701 StringRef SDK = getSDKName(A->getValue());
1702 if (SDK.size() > 0) {
1703 size_t StartVer = SDK.find_first_of("0123456789");
1704 StringRef SDKName = SDK.slice(0, StartVer);
1705 if (!SDKName.startswith(getPlatformFamily()))
1706 getDriver().Diag(diag::warn_incompatible_sysroot)
1707 << SDKName << getPlatformFamily();
1712 void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
1713 ArgStringList &CmdArgs) const {
1714 CXXStdlibType Type = GetCXXStdlibType(Args);
1717 case ToolChain::CST_Libcxx:
1718 CmdArgs.push_back("-lc++");
1721 case ToolChain::CST_Libstdcxx:
1722 // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
1723 // it was previously found in the gcc lib dir. However, for all the Darwin
1724 // platforms we care about it was -lstdc++.6, so we search for that
1725 // explicitly if we can't see an obvious -lstdc++ candidate.
1727 // Check in the sysroot first.
1728 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
1729 SmallString<128> P(A->getValue());
1730 llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
1732 if (!getVFS().exists(P)) {
1733 llvm::sys::path::remove_filename(P);
1734 llvm::sys::path::append(P, "libstdc++.6.dylib");
1735 if (getVFS().exists(P)) {
1736 CmdArgs.push_back(Args.MakeArgString(P));
1742 // Otherwise, look in the root.
1743 // FIXME: This should be removed someday when we don't have to care about
1744 // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
1745 if (!getVFS().exists("/usr/lib/libstdc++.dylib") &&
1746 getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
1747 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
1751 // Otherwise, let the linker search.
1752 CmdArgs.push_back("-lstdc++");
1757 void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
1758 ArgStringList &CmdArgs) const {
1759 // For Darwin platforms, use the compiler-rt-based support library
1760 // instead of the gcc-provided one (which is also incidentally
1761 // only present in the gcc lib dir, which makes it hard to find).
1763 SmallString<128> P(getDriver().ResourceDir);
1764 llvm::sys::path::append(P, "lib", "darwin");
1766 // Use the newer cc_kext for iOS ARM after 6.0.
1767 if (isTargetWatchOS()) {
1768 llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a");
1769 } else if (isTargetTvOS()) {
1770 llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a");
1771 } else if (isTargetIPhoneOS()) {
1772 llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
1774 llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
1777 // For now, allow missing resource libraries to support developers who may
1778 // not have compiler-rt checked out or integrated into their build.
1779 if (getVFS().exists(P))
1780 CmdArgs.push_back(Args.MakeArgString(P));
1783 DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args,
1784 StringRef BoundArch,
1785 Action::OffloadKind) const {
1786 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
1787 const OptTable &Opts = getDriver().getOpts();
1789 // FIXME: We really want to get out of the tool chain level argument
1790 // translation business, as it makes the driver functionality much
1791 // more opaque. For now, we follow gcc closely solely for the
1792 // purpose of easily achieving feature parity & testability. Once we
1793 // have something that works, we should reevaluate each translation
1794 // and try to push it down into tool specific logic.
1796 for (Arg *A : Args) {
1797 if (A->getOption().matches(options::OPT_Xarch__)) {
1798 // Skip this argument unless the architecture matches either the toolchain
1799 // triple arch, or the arch being bound.
1800 llvm::Triple::ArchType XarchArch =
1801 tools::darwin::getArchTypeForMachOArchName(A->getValue(0));
1802 if (!(XarchArch == getArch() ||
1803 (!BoundArch.empty() &&
1805 tools::darwin::getArchTypeForMachOArchName(BoundArch))))
1808 Arg *OriginalArg = A;
1809 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1));
1810 unsigned Prev = Index;
1811 std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index));
1813 // If the argument parsing failed or more than one argument was
1814 // consumed, the -Xarch_ argument's parameter tried to consume
1815 // extra arguments. Emit an error and ignore.
1817 // We also want to disallow any options which would alter the
1818 // driver behavior; that isn't going to work in our model. We
1819 // use isDriverOption() as an approximation, although things
1820 // like -O4 are going to slip through.
1821 if (!XarchArg || Index > Prev + 1) {
1822 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args)
1823 << A->getAsString(Args);
1825 } else if (XarchArg->getOption().hasFlag(options::DriverOption)) {
1826 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver)
1827 << A->getAsString(Args);
1831 XarchArg->setBaseArg(A);
1833 A = XarchArg.release();
1834 DAL->AddSynthesizedArg(A);
1836 // Linker input arguments require custom handling. The problem is that we
1837 // have already constructed the phase actions, so we can not treat them as
1838 // "input arguments".
1839 if (A->getOption().hasFlag(options::LinkerInput)) {
1840 // Convert the argument into individual Zlinker_input_args.
1841 for (const char *Value : A->getValues()) {
1842 DAL->AddSeparateArg(
1843 OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
1849 // Sob. These is strictly gcc compatible for the time being. Apple
1850 // gcc translates options twice, which means that self-expanding
1851 // options add duplicates.
1852 switch ((options::ID)A->getOption().getID()) {
1857 case options::OPT_mkernel:
1858 case options::OPT_fapple_kext:
1860 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
1863 case options::OPT_dependency_file:
1864 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
1867 case options::OPT_gfull:
1868 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1870 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
1873 case options::OPT_gused:
1874 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
1876 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
1879 case options::OPT_shared:
1880 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
1883 case options::OPT_fconstant_cfstrings:
1884 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
1887 case options::OPT_fno_constant_cfstrings:
1888 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
1891 case options::OPT_Wnonportable_cfstrings:
1893 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
1896 case options::OPT_Wno_nonportable_cfstrings:
1898 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
1901 case options::OPT_fpascal_strings:
1902 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings));
1905 case options::OPT_fno_pascal_strings:
1906 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings));
1911 if (getTriple().getArch() == llvm::Triple::x86 ||
1912 getTriple().getArch() == llvm::Triple::x86_64)
1913 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ))
1914 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_mtune_EQ),
1917 // Add the arch options based on the particular spelling of -arch, to match
1918 // how the driver driver works.
1919 if (!BoundArch.empty()) {
1920 StringRef Name = BoundArch;
1921 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
1922 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
1924 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
1925 // which defines the list of which architectures we accept.
1928 else if (Name == "ppc601")
1929 DAL->AddJoinedArg(nullptr, MCpu, "601");
1930 else if (Name == "ppc603")
1931 DAL->AddJoinedArg(nullptr, MCpu, "603");
1932 else if (Name == "ppc604")
1933 DAL->AddJoinedArg(nullptr, MCpu, "604");
1934 else if (Name == "ppc604e")
1935 DAL->AddJoinedArg(nullptr, MCpu, "604e");
1936 else if (Name == "ppc750")
1937 DAL->AddJoinedArg(nullptr, MCpu, "750");
1938 else if (Name == "ppc7400")
1939 DAL->AddJoinedArg(nullptr, MCpu, "7400");
1940 else if (Name == "ppc7450")
1941 DAL->AddJoinedArg(nullptr, MCpu, "7450");
1942 else if (Name == "ppc970")
1943 DAL->AddJoinedArg(nullptr, MCpu, "970");
1945 else if (Name == "ppc64" || Name == "ppc64le")
1946 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1948 else if (Name == "i386")
1950 else if (Name == "i486")
1951 DAL->AddJoinedArg(nullptr, MArch, "i486");
1952 else if (Name == "i586")
1953 DAL->AddJoinedArg(nullptr, MArch, "i586");
1954 else if (Name == "i686")
1955 DAL->AddJoinedArg(nullptr, MArch, "i686");
1956 else if (Name == "pentium")
1957 DAL->AddJoinedArg(nullptr, MArch, "pentium");
1958 else if (Name == "pentium2")
1959 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
1960 else if (Name == "pentpro")
1961 DAL->AddJoinedArg(nullptr, MArch, "pentiumpro");
1962 else if (Name == "pentIIm3")
1963 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
1965 else if (Name == "x86_64")
1966 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1967 else if (Name == "x86_64h") {
1968 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
1969 DAL->AddJoinedArg(nullptr, MArch, "x86_64h");
1972 else if (Name == "arm")
1973 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
1974 else if (Name == "armv4t")
1975 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
1976 else if (Name == "armv5")
1977 DAL->AddJoinedArg(nullptr, MArch, "armv5tej");
1978 else if (Name == "xscale")
1979 DAL->AddJoinedArg(nullptr, MArch, "xscale");
1980 else if (Name == "armv6")
1981 DAL->AddJoinedArg(nullptr, MArch, "armv6k");
1982 else if (Name == "armv6m")
1983 DAL->AddJoinedArg(nullptr, MArch, "armv6m");
1984 else if (Name == "armv7")
1985 DAL->AddJoinedArg(nullptr, MArch, "armv7a");
1986 else if (Name == "armv7em")
1987 DAL->AddJoinedArg(nullptr, MArch, "armv7em");
1988 else if (Name == "armv7k")
1989 DAL->AddJoinedArg(nullptr, MArch, "armv7k");
1990 else if (Name == "armv7m")
1991 DAL->AddJoinedArg(nullptr, MArch, "armv7m");
1992 else if (Name == "armv7s")
1993 DAL->AddJoinedArg(nullptr, MArch, "armv7s");
1999 void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
2000 ArgStringList &CmdArgs) const {
2001 // Embedded targets are simple at the moment, not supporting sanitizers and
2002 // with different libraries for each member of the product { static, PIC } x
2003 // { hard-float, soft-float }
2004 llvm::SmallString<32> CompilerRT = StringRef("libclang_rt.");
2006 (tools::arm::getARMFloatABI(*this, Args) == tools::arm::FloatABI::Hard)
2009 CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic.a" : "_static.a";
2011 AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, RLO_IsEmbedded);
2014 bool Darwin::isAlignedAllocationUnavailable() const {
2015 llvm::Triple::OSType OS;
2017 switch (TargetPlatform) {
2018 case MacOS: // Earlier than 10.13.
2019 OS = llvm::Triple::MacOSX;
2022 OS = llvm::Triple::IOS;
2024 case TvOS: // Earlier than 11.0.
2025 OS = llvm::Triple::TvOS;
2027 case WatchOS: // Earlier than 4.0.
2028 OS = llvm::Triple::WatchOS;
2032 return TargetVersion < alignedAllocMinVersion(OS);
2035 void Darwin::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
2036 llvm::opt::ArgStringList &CC1Args,
2037 Action::OffloadKind DeviceOffloadKind) const {
2038 if (isAlignedAllocationUnavailable())
2039 CC1Args.push_back("-faligned-alloc-unavailable");
2043 Darwin::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
2044 Action::OffloadKind DeviceOffloadKind) const {
2045 // First get the generic Apple args, before moving onto Darwin-specific ones.
2046 DerivedArgList *DAL =
2047 MachO::TranslateArgs(Args, BoundArch, DeviceOffloadKind);
2048 const OptTable &Opts = getDriver().getOpts();
2050 // If no architecture is bound, none of the translations here are relevant.
2051 if (BoundArch.empty())
2054 // Add an explicit version min argument for the deployment target. We do this
2055 // after argument translation because -Xarch_ arguments may add a version min
2057 AddDeploymentTarget(*DAL);
2059 // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
2060 // FIXME: It would be far better to avoid inserting those -static arguments,
2061 // but we can't check the deployment target in the translation code until
2063 if (isTargetWatchOSBased() ||
2064 (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0))) {
2065 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
2068 if (A->getOption().getID() != options::OPT_mkernel &&
2069 A->getOption().getID() != options::OPT_fapple_kext)
2071 assert(it != ie && "unexpected argument translation");
2073 assert(A->getOption().getID() == options::OPT_static &&
2074 "missing expected -static argument");
2080 if (!Args.getLastArg(options::OPT_stdlib_EQ) &&
2081 GetCXXStdlibType(Args) == ToolChain::CST_Libcxx)
2082 DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_stdlib_EQ),
2085 // Validate the C++ standard library choice.
2086 CXXStdlibType Type = GetCXXStdlibType(*DAL);
2087 if (Type == ToolChain::CST_Libcxx) {
2088 // Check whether the target provides libc++.
2091 // Complain about targeting iOS < 5.0 in any way.
2092 if (isTargetIOSBased() && isIPhoneOSVersionLT(5, 0))
2095 if (where != StringRef()) {
2096 getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) << where;
2100 auto Arch = tools::darwin::getArchTypeForMachOArchName(BoundArch);
2101 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
2102 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
2103 options::OPT_fno_omit_frame_pointer, false))
2104 getDriver().Diag(clang::diag::warn_drv_unsupported_opt_for_target)
2105 << "-fomit-frame-pointer" << BoundArch;
2111 bool MachO::IsUnwindTablesDefault(const ArgList &Args) const {
2112 // Unwind tables are not emitted if -fno-exceptions is supplied (except when
2113 // targeting x86_64).
2114 return getArch() == llvm::Triple::x86_64 ||
2115 (GetExceptionModel(Args) != llvm::ExceptionHandling::SjLj &&
2116 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2120 bool MachO::UseDwarfDebugFlags() const {
2121 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
2122 return S[0] != '\0';
2126 llvm::ExceptionHandling Darwin::GetExceptionModel(const ArgList &Args) const {
2127 // Darwin uses SjLj exceptions on ARM.
2128 if (getTriple().getArch() != llvm::Triple::arm &&
2129 getTriple().getArch() != llvm::Triple::thumb)
2130 return llvm::ExceptionHandling::None;
2132 // Only watchOS uses the new DWARF/Compact unwinding method.
2133 llvm::Triple Triple(ComputeLLVMTriple(Args));
2134 if(Triple.isWatchABI())
2135 return llvm::ExceptionHandling::DwarfCFI;
2137 return llvm::ExceptionHandling::SjLj;
2140 bool Darwin::SupportsEmbeddedBitcode() const {
2141 assert(TargetInitialized && "Target not initialized!");
2142 if (isTargetIPhoneOS() && isIPhoneOSVersionLT(6, 0))
2147 bool MachO::isPICDefault() const { return true; }
2149 bool MachO::isPIEDefault() const { return false; }
2151 bool MachO::isPICDefaultForced() const {
2152 return (getArch() == llvm::Triple::x86_64 ||
2153 getArch() == llvm::Triple::aarch64);
2156 bool MachO::SupportsProfiling() const {
2157 // Profiling instrumentation is only supported on x86.
2158 return getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::x86_64;
2161 void Darwin::addMinVersionArgs(const ArgList &Args,
2162 ArgStringList &CmdArgs) const {
2163 VersionTuple TargetVersion = getTargetVersion();
2165 if (isTargetWatchOS())
2166 CmdArgs.push_back("-watchos_version_min");
2167 else if (isTargetWatchOSSimulator())
2168 CmdArgs.push_back("-watchos_simulator_version_min");
2169 else if (isTargetTvOS())
2170 CmdArgs.push_back("-tvos_version_min");
2171 else if (isTargetTvOSSimulator())
2172 CmdArgs.push_back("-tvos_simulator_version_min");
2173 else if (isTargetIOSSimulator())
2174 CmdArgs.push_back("-ios_simulator_version_min");
2175 else if (isTargetIOSBased())
2176 CmdArgs.push_back("-iphoneos_version_min");
2178 assert(isTargetMacOS() && "unexpected target");
2179 CmdArgs.push_back("-macosx_version_min");
2182 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
2185 void Darwin::addStartObjectFileArgs(const ArgList &Args,
2186 ArgStringList &CmdArgs) const {
2187 // Derived from startfile spec.
2188 if (Args.hasArg(options::OPT_dynamiclib)) {
2189 // Derived from darwin_dylib1 spec.
2190 if (isTargetWatchOSBased()) {
2191 ; // watchOS does not need dylib1.o.
2192 } else if (isTargetIOSSimulator()) {
2193 ; // iOS simulator does not need dylib1.o.
2194 } else if (isTargetIPhoneOS()) {
2195 if (isIPhoneOSVersionLT(3, 1))
2196 CmdArgs.push_back("-ldylib1.o");
2198 if (isMacosxVersionLT(10, 5))
2199 CmdArgs.push_back("-ldylib1.o");
2200 else if (isMacosxVersionLT(10, 6))
2201 CmdArgs.push_back("-ldylib1.10.5.o");
2204 if (Args.hasArg(options::OPT_bundle)) {
2205 if (!Args.hasArg(options::OPT_static)) {
2206 // Derived from darwin_bundle1 spec.
2207 if (isTargetWatchOSBased()) {
2208 ; // watchOS does not need bundle1.o.
2209 } else if (isTargetIOSSimulator()) {
2210 ; // iOS simulator does not need bundle1.o.
2211 } else if (isTargetIPhoneOS()) {
2212 if (isIPhoneOSVersionLT(3, 1))
2213 CmdArgs.push_back("-lbundle1.o");
2215 if (isMacosxVersionLT(10, 6))
2216 CmdArgs.push_back("-lbundle1.o");
2220 if (Args.hasArg(options::OPT_pg) && SupportsProfiling()) {
2221 if (Args.hasArg(options::OPT_static) ||
2222 Args.hasArg(options::OPT_object) ||
2223 Args.hasArg(options::OPT_preload)) {
2224 CmdArgs.push_back("-lgcrt0.o");
2226 CmdArgs.push_back("-lgcrt1.o");
2228 // darwin_crt2 spec is empty.
2230 // By default on OS X 10.8 and later, we don't link with a crt1.o
2231 // file and the linker knows to use _main as the entry point. But,
2232 // when compiling with -pg, we need to link with the gcrt1.o file,
2233 // so pass the -no_new_main option to tell the linker to use the
2234 // "start" symbol as the entry point.
2235 if (isTargetMacOS() && !isMacosxVersionLT(10, 8))
2236 CmdArgs.push_back("-no_new_main");
2238 if (Args.hasArg(options::OPT_static) ||
2239 Args.hasArg(options::OPT_object) ||
2240 Args.hasArg(options::OPT_preload)) {
2241 CmdArgs.push_back("-lcrt0.o");
2243 // Derived from darwin_crt1 spec.
2244 if (isTargetWatchOSBased()) {
2245 ; // watchOS does not need crt1.o.
2246 } else if (isTargetIOSSimulator()) {
2247 ; // iOS simulator does not need crt1.o.
2248 } else if (isTargetIPhoneOS()) {
2249 if (getArch() == llvm::Triple::aarch64)
2250 ; // iOS does not need any crt1 files for arm64
2251 else if (isIPhoneOSVersionLT(3, 1))
2252 CmdArgs.push_back("-lcrt1.o");
2253 else if (isIPhoneOSVersionLT(6, 0))
2254 CmdArgs.push_back("-lcrt1.3.1.o");
2256 if (isMacosxVersionLT(10, 5))
2257 CmdArgs.push_back("-lcrt1.o");
2258 else if (isMacosxVersionLT(10, 6))
2259 CmdArgs.push_back("-lcrt1.10.5.o");
2260 else if (isMacosxVersionLT(10, 8))
2261 CmdArgs.push_back("-lcrt1.10.6.o");
2263 // darwin_crt2 spec is empty.
2270 if (!isTargetIPhoneOS() && Args.hasArg(options::OPT_shared_libgcc) &&
2271 !isTargetWatchOS() &&
2272 isMacosxVersionLT(10, 5)) {
2273 const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
2274 CmdArgs.push_back(Str);
2278 void Darwin::CheckObjCARC() const {
2279 if (isTargetIOSBased() || isTargetWatchOSBased() ||
2280 (isTargetMacOS() && !isMacosxVersionLT(10, 6)))
2282 getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
2285 SanitizerMask Darwin::getSupportedSanitizers() const {
2286 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
2287 SanitizerMask Res = ToolChain::getSupportedSanitizers();
2288 Res |= SanitizerKind::Address;
2289 Res |= SanitizerKind::Leak;
2290 Res |= SanitizerKind::Fuzzer;
2291 Res |= SanitizerKind::FuzzerNoLink;
2292 Res |= SanitizerKind::Function;
2293 if (isTargetMacOS()) {
2294 if (!isMacosxVersionLT(10, 9))
2295 Res |= SanitizerKind::Vptr;
2296 Res |= SanitizerKind::SafeStack;
2298 Res |= SanitizerKind::Thread;
2299 } else if (isTargetIOSSimulator() || isTargetTvOSSimulator()) {
2301 Res |= SanitizerKind::Thread;
2306 void Darwin::printVerboseInfo(raw_ostream &OS) const {
2307 CudaInstallation.print(OS);