clang 17.0.0git
Darwin.cpp
Go to the documentation of this file.
1//===--- Darwin.cpp - Darwin Tool and ToolChain Implementations -*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "Darwin.h"
10#include "Arch/AArch64.h"
11#include "Arch/ARM.h"
12#include "CommonArgs.h"
15#include "clang/Config/config.h"
17#include "clang/Driver/Driver.h"
21#include "llvm/ADT/StringSwitch.h"
22#include "llvm/Option/ArgList.h"
23#include "llvm/ProfileData/InstrProf.h"
24#include "llvm/Support/Path.h"
25#include "llvm/Support/ScopedPrinter.h"
26#include "llvm/Support/Threading.h"
27#include "llvm/Support/VirtualFileSystem.h"
28#include "llvm/TargetParser/TargetParser.h"
29#include <cstdlib> // ::getenv
30
31using namespace clang::driver;
32using namespace clang::driver::tools;
33using namespace clang::driver::toolchains;
34using namespace clang;
35using namespace llvm::opt;
36
38 return VersionTuple(13, 1);
39}
40
41llvm::Triple::ArchType darwin::getArchTypeForMachOArchName(StringRef Str) {
42 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for
43 // archs which Darwin doesn't use.
44
45 // The matching this routine does is fairly pointless, since it is neither the
46 // complete architecture list, nor a reasonable subset. The problem is that
47 // historically the driver accepts this and also ties its -march=
48 // handling to the architecture name, so we need to be careful before removing
49 // support for it.
50
51 // This code must be kept in sync with Clang's Darwin specific argument
52 // translation.
53
54 return llvm::StringSwitch<llvm::Triple::ArchType>(Str)
55 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc)
56 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc)
57 .Case("ppc64", llvm::Triple::ppc64)
58 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86)
59 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4",
60 llvm::Triple::x86)
61 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64)
62 // This is derived from the driver.
63 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm)
64 .Cases("armv7", "armv7em", "armv7k", "armv7m", llvm::Triple::arm)
65 .Cases("armv7s", "xscale", llvm::Triple::arm)
66 .Cases("arm64", "arm64e", llvm::Triple::aarch64)
67 .Case("arm64_32", llvm::Triple::aarch64_32)
68 .Case("r600", llvm::Triple::r600)
69 .Case("amdgcn", llvm::Triple::amdgcn)
70 .Case("nvptx", llvm::Triple::nvptx)
71 .Case("nvptx64", llvm::Triple::nvptx64)
72 .Case("amdil", llvm::Triple::amdil)
73 .Case("spir", llvm::Triple::spir)
74 .Default(llvm::Triple::UnknownArch);
75}
76
77void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
78 const llvm::Triple::ArchType Arch = getArchTypeForMachOArchName(Str);
79 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseArch(Str);
80 T.setArch(Arch);
81 if (Arch != llvm::Triple::UnknownArch)
82 T.setArchName(Str);
83
84 if (ArchKind == llvm::ARM::ArchKind::ARMV6M ||
85 ArchKind == llvm::ARM::ArchKind::ARMV7M ||
86 ArchKind == llvm::ARM::ArchKind::ARMV7EM) {
87 T.setOS(llvm::Triple::UnknownOS);
88 T.setObjectFormat(llvm::Triple::MachO);
89 }
90}
91
93 const InputInfo &Output,
94 const InputInfoList &Inputs,
95 const ArgList &Args,
96 const char *LinkingOutput) const {
97 const llvm::Triple &T(getToolChain().getTriple());
98
99 ArgStringList CmdArgs;
100
101 assert(Inputs.size() == 1 && "Unexpected number of inputs.");
102 const InputInfo &Input = Inputs[0];
103
104 // Determine the original source input.
105 const Action *SourceAction = &JA;
106 while (SourceAction->getKind() != Action::InputClass) {
107 assert(!SourceAction->getInputs().empty() && "unexpected root action!");
108 SourceAction = SourceAction->getInputs()[0];
109 }
110
111 // If -fno-integrated-as is used add -Q to the darwin assembler driver to make
112 // sure it runs its system assembler not clang's integrated assembler.
113 // Applicable to darwin11+ and Xcode 4+. darwin<10 lacked integrated-as.
114 // FIXME: at run-time detect assembler capabilities or rely on version
115 // information forwarded by -target-assembler-version.
116 if (Args.hasArg(options::OPT_fno_integrated_as)) {
117 if (!(T.isMacOSX() && T.isMacOSXVersionLT(10, 7)))
118 CmdArgs.push_back("-Q");
119 }
120
121 // Forward -g, assuming we are dealing with an actual assembly file.
122 if (SourceAction->getType() == types::TY_Asm ||
123 SourceAction->getType() == types::TY_PP_Asm) {
124 if (Args.hasArg(options::OPT_gstabs))
125 CmdArgs.push_back("--gstabs");
126 else if (Args.hasArg(options::OPT_g_Group))
127 CmdArgs.push_back("-g");
128 }
129
130 // Derived from asm spec.
131 AddMachOArch(Args, CmdArgs);
132
133 // Use -force_cpusubtype_ALL on x86 by default.
134 if (T.isX86() || Args.hasArg(options::OPT_force__cpusubtype__ALL))
135 CmdArgs.push_back("-force_cpusubtype_ALL");
136
137 if (getToolChain().getArch() != llvm::Triple::x86_64 &&
138 (((Args.hasArg(options::OPT_mkernel) ||
139 Args.hasArg(options::OPT_fapple_kext)) &&
140 getMachOToolChain().isKernelStatic()) ||
141 Args.hasArg(options::OPT_static)))
142 CmdArgs.push_back("-static");
143
144 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
145
146 assert(Output.isFilename() && "Unexpected lipo output.");
147 CmdArgs.push_back("-o");
148 CmdArgs.push_back(Output.getFilename());
149
150 assert(Input.isFilename() && "Invalid input.");
151 CmdArgs.push_back(Input.getFilename());
152
153 // asm_final spec is empty.
154
155 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
156 C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
157 Exec, CmdArgs, Inputs, Output));
158}
159
160void darwin::MachOTool::anchor() {}
161
162void darwin::MachOTool::AddMachOArch(const ArgList &Args,
163 ArgStringList &CmdArgs) const {
164 StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
165
166 // Derived from darwin_arch spec.
167 CmdArgs.push_back("-arch");
168 CmdArgs.push_back(Args.MakeArgString(ArchName));
169
170 // FIXME: Is this needed anymore?
171 if (ArchName == "arm")
172 CmdArgs.push_back("-force_cpusubtype_ALL");
173}
174
175bool darwin::Linker::NeedsTempPath(const InputInfoList &Inputs) const {
176 // We only need to generate a temp path for LTO if we aren't compiling object
177 // files. When compiling source files, we run 'dsymutil' after linking. We
178 // don't run 'dsymutil' when compiling object files.
179 for (const auto &Input : Inputs)
180 if (Input.getType() != types::TY_Object)
181 return true;
182
183 return false;
184}
185
186/// Pass -no_deduplicate to ld64 under certain conditions:
187///
188/// - Either -O0 or -O1 is explicitly specified
189/// - No -O option is specified *and* this is a compile+link (implicit -O0)
190///
191/// Also do *not* add -no_deduplicate when no -O option is specified and this
192/// is just a link (we can't imply -O0)
193static bool shouldLinkerNotDedup(bool IsLinkerOnlyAction, const ArgList &Args) {
194 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
195 if (A->getOption().matches(options::OPT_O0))
196 return true;
197 if (A->getOption().matches(options::OPT_O))
198 return llvm::StringSwitch<bool>(A->getValue())
199 .Case("1", true)
200 .Default(false);
201 return false; // OPT_Ofast & OPT_O4
202 }
203
204 if (!IsLinkerOnlyAction) // Implicit -O0 for compile+linker only.
205 return true;
206 return false;
207}
208
209void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args,
210 ArgStringList &CmdArgs,
211 const InputInfoList &Inputs,
212 VersionTuple Version, bool LinkerIsLLD) const {
213 const Driver &D = getToolChain().getDriver();
214 const toolchains::MachO &MachOTC = getMachOToolChain();
215
216 // Newer linkers support -demangle. Pass it if supported and not disabled by
217 // the user.
218 if ((Version >= VersionTuple(100) || LinkerIsLLD) &&
219 !Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
220 CmdArgs.push_back("-demangle");
221
222 if (Args.hasArg(options::OPT_rdynamic) &&
223 (Version >= VersionTuple(137) || LinkerIsLLD))
224 CmdArgs.push_back("-export_dynamic");
225
226 // If we are using App Extension restrictions, pass a flag to the linker
227 // telling it that the compiled code has been audited.
228 if (Args.hasFlag(options::OPT_fapplication_extension,
229 options::OPT_fno_application_extension, false))
230 CmdArgs.push_back("-application_extension");
231
232 if (D.isUsingLTO() && (Version >= VersionTuple(116) || LinkerIsLLD) &&
233 NeedsTempPath(Inputs)) {
234 std::string TmpPathName;
235 if (D.getLTOMode() == LTOK_Full) {
236 // If we are using full LTO, then automatically create a temporary file
237 // path for the linker to use, so that it's lifetime will extend past a
238 // possible dsymutil step.
239 TmpPathName =
240 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object));
241 } else if (D.getLTOMode() == LTOK_Thin)
242 // If we are using thin LTO, then create a directory instead.
243 TmpPathName = D.GetTemporaryDirectory("thinlto");
244
245 if (!TmpPathName.empty()) {
246 auto *TmpPath = C.getArgs().MakeArgString(TmpPathName);
247 C.addTempFile(TmpPath);
248 CmdArgs.push_back("-object_path_lto");
249 CmdArgs.push_back(TmpPath);
250 }
251 }
252
253 // Use -lto_library option to specify the libLTO.dylib path. Try to find
254 // it in clang installed libraries. ld64 will only look at this argument
255 // when it actually uses LTO, so libLTO.dylib only needs to exist at link
256 // time if ld64 decides that it needs to use LTO.
257 // Since this is passed unconditionally, ld64 will never look for libLTO.dylib
258 // next to it. That's ok since ld64 using a libLTO.dylib not matching the
259 // clang version won't work anyways.
260 // lld is built at the same revision as clang and statically links in
261 // LLVM libraries, so it doesn't need libLTO.dylib.
262 if (Version >= VersionTuple(133) && !LinkerIsLLD) {
263 // Search for libLTO in <InstalledDir>/../lib/libLTO.dylib
264 StringRef P = llvm::sys::path::parent_path(D.Dir);
265 SmallString<128> LibLTOPath(P);
266 llvm::sys::path::append(LibLTOPath, "lib");
267 llvm::sys::path::append(LibLTOPath, "libLTO.dylib");
268 CmdArgs.push_back("-lto_library");
269 CmdArgs.push_back(C.getArgs().MakeArgString(LibLTOPath));
270 }
271
272 // ld64 version 262 and above runs the deduplicate pass by default.
273 // FIXME: lld doesn't dedup by default. Should we pass `--icf=safe`
274 // if `!shouldLinkerNotDedup()` if LinkerIsLLD here?
275 if (Version >= VersionTuple(262) &&
276 shouldLinkerNotDedup(C.getJobs().empty(), Args))
277 CmdArgs.push_back("-no_deduplicate");
278
279 // Derived from the "link" spec.
280 Args.AddAllArgs(CmdArgs, options::OPT_static);
281 if (!Args.hasArg(options::OPT_static))
282 CmdArgs.push_back("-dynamic");
283 if (Args.hasArg(options::OPT_fgnu_runtime)) {
284 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu
285 // here. How do we wish to handle such things?
286 }
287
288 if (!Args.hasArg(options::OPT_dynamiclib)) {
289 AddMachOArch(Args, CmdArgs);
290 // FIXME: Why do this only on this path?
291 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL);
292
293 Args.AddLastArg(CmdArgs, options::OPT_bundle);
294 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader);
295 Args.AddAllArgs(CmdArgs, options::OPT_client__name);
296
297 Arg *A;
298 if ((A = Args.getLastArg(options::OPT_compatibility__version)) ||
299 (A = Args.getLastArg(options::OPT_current__version)) ||
300 (A = Args.getLastArg(options::OPT_install__name)))
301 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args)
302 << "-dynamiclib";
303
304 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace);
305 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs);
306 Args.AddLastArg(CmdArgs, options::OPT_private__bundle);
307 } else {
308 CmdArgs.push_back("-dylib");
309
310 Arg *A;
311 if ((A = Args.getLastArg(options::OPT_bundle)) ||
312 (A = Args.getLastArg(options::OPT_bundle__loader)) ||
313 (A = Args.getLastArg(options::OPT_client__name)) ||
314 (A = Args.getLastArg(options::OPT_force__flat__namespace)) ||
315 (A = Args.getLastArg(options::OPT_keep__private__externs)) ||
316 (A = Args.getLastArg(options::OPT_private__bundle)))
317 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
318 << "-dynamiclib";
319
320 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version,
321 "-dylib_compatibility_version");
322 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version,
323 "-dylib_current_version");
324
325 AddMachOArch(Args, CmdArgs);
326
327 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name,
328 "-dylib_install_name");
329 }
330
331 Args.AddLastArg(CmdArgs, options::OPT_all__load);
332 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client);
333 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load);
334 if (MachOTC.isTargetIOSBased())
335 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal);
336 Args.AddLastArg(CmdArgs, options::OPT_dead__strip);
337 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms);
338 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file);
339 Args.AddLastArg(CmdArgs, options::OPT_dynamic);
340 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list);
341 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace);
342 Args.AddAllArgs(CmdArgs, options::OPT_force__load);
343 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names);
344 Args.AddAllArgs(CmdArgs, options::OPT_image__base);
345 Args.AddAllArgs(CmdArgs, options::OPT_init);
346
347 // Add the deployment target.
348 if (Version >= VersionTuple(520) || LinkerIsLLD)
349 MachOTC.addPlatformVersionArgs(Args, CmdArgs);
350 else
351 MachOTC.addMinVersionArgs(Args, CmdArgs);
352
353 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs);
354 Args.AddLastArg(CmdArgs, options::OPT_multi__module);
355 Args.AddLastArg(CmdArgs, options::OPT_single__module);
356 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined);
357 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused);
358
359 if (const Arg *A =
360 Args.getLastArg(options::OPT_fpie, options::OPT_fPIE,
361 options::OPT_fno_pie, options::OPT_fno_PIE)) {
362 if (A->getOption().matches(options::OPT_fpie) ||
363 A->getOption().matches(options::OPT_fPIE))
364 CmdArgs.push_back("-pie");
365 else
366 CmdArgs.push_back("-no_pie");
367 }
368
369 // for embed-bitcode, use -bitcode_bundle in linker command
370 if (C.getDriver().embedBitcodeEnabled()) {
371 // Check if the toolchain supports bitcode build flow.
372 if (MachOTC.SupportsEmbeddedBitcode()) {
373 CmdArgs.push_back("-bitcode_bundle");
374 // FIXME: Pass this if LinkerIsLLD too, once it implements this flag.
375 if (C.getDriver().embedBitcodeMarkerOnly() &&
376 Version >= VersionTuple(278)) {
377 CmdArgs.push_back("-bitcode_process_mode");
378 CmdArgs.push_back("marker");
379 }
380 } else
381 D.Diag(diag::err_drv_bitcode_unsupported_on_toolchain);
382 }
383
384 // If GlobalISel is enabled, pass it through to LLVM.
385 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel,
386 options::OPT_fno_global_isel)) {
387 if (A->getOption().matches(options::OPT_fglobal_isel)) {
388 CmdArgs.push_back("-mllvm");
389 CmdArgs.push_back("-global-isel");
390 // Disable abort and fall back to SDAG silently.
391 CmdArgs.push_back("-mllvm");
392 CmdArgs.push_back("-global-isel-abort=0");
393 }
394 }
395
396 Args.AddLastArg(CmdArgs, options::OPT_prebind);
397 Args.AddLastArg(CmdArgs, options::OPT_noprebind);
398 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding);
399 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules);
400 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs);
401 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate);
402 Args.AddAllArgs(CmdArgs, options::OPT_sectorder);
403 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr);
404 Args.AddAllArgs(CmdArgs, options::OPT_segprot);
405 Args.AddAllArgs(CmdArgs, options::OPT_segaddr);
406 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr);
407 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr);
408 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
409 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
410 Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
411 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
412
413 // Give --sysroot= preference, over the Apple specific behavior to also use
414 // --isysroot as the syslibroot.
415 StringRef sysroot = C.getSysRoot();
416 if (sysroot != "") {
417 CmdArgs.push_back("-syslibroot");
418 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
419 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
420 CmdArgs.push_back("-syslibroot");
421 CmdArgs.push_back(A->getValue());
422 }
423
424 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
425 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints);
426 Args.AddAllArgs(CmdArgs, options::OPT_umbrella);
427 Args.AddAllArgs(CmdArgs, options::OPT_undefined);
428 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list);
429 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches);
430 Args.AddLastArg(CmdArgs, options::OPT_X_Flag);
431 Args.AddAllArgs(CmdArgs, options::OPT_y);
432 Args.AddLastArg(CmdArgs, options::OPT_w);
433 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size);
434 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__);
435 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit);
436 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit);
437 Args.AddAllArgs(CmdArgs, options::OPT_sectalign);
438 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols);
439 Args.AddAllArgs(CmdArgs, options::OPT_segcreate);
440 Args.AddLastArg(CmdArgs, options::OPT_why_load);
441 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded);
442 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name);
443 Args.AddLastArg(CmdArgs, options::OPT_dylinker);
444 Args.AddLastArg(CmdArgs, options::OPT_Mach);
445}
446
447/// Determine whether we are linking the ObjC runtime.
448static bool isObjCRuntimeLinked(const ArgList &Args) {
449 if (isObjCAutoRefCount(Args)) {
450 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime);
451 return true;
452 }
453 return Args.hasArg(options::OPT_fobjc_link_runtime);
454}
455
456static bool checkRemarksOptions(const Driver &D, const ArgList &Args,
457 const llvm::Triple &Triple) {
458 // When enabling remarks, we need to error if:
459 // * The remark file is specified but we're targeting multiple architectures,
460 // which means more than one remark file is being generated.
462 Args.getAllArgValues(options::OPT_arch).size() > 1;
463 bool hasExplicitOutputFile =
464 Args.getLastArg(options::OPT_foptimization_record_file_EQ);
465 if (hasMultipleInvocations && hasExplicitOutputFile) {
466 D.Diag(diag::err_drv_invalid_output_with_multiple_archs)
467 << "-foptimization-record-file";
468 return false;
469 }
470 return true;
471}
472
473static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs,
474 const llvm::Triple &Triple,
475 const InputInfo &Output, const JobAction &JA) {
476 StringRef Format = "yaml";
477 if (const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ))
478 Format = A->getValue();
479
480 CmdArgs.push_back("-mllvm");
481 CmdArgs.push_back("-lto-pass-remarks-output");
482 CmdArgs.push_back("-mllvm");
483
484 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ);
485 if (A) {
486 CmdArgs.push_back(A->getValue());
487 } else {
488 assert(Output.isFilename() && "Unexpected ld output.");
490 F = Output.getFilename();
491 F += ".opt.";
492 F += Format;
493
494 CmdArgs.push_back(Args.MakeArgString(F));
495 }
496
497 if (const Arg *A =
498 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) {
499 CmdArgs.push_back("-mllvm");
500 std::string Passes =
501 std::string("-lto-pass-remarks-filter=") + A->getValue();
502 CmdArgs.push_back(Args.MakeArgString(Passes));
503 }
504
505 if (!Format.empty()) {
506 CmdArgs.push_back("-mllvm");
507 Twine FormatArg = Twine("-lto-pass-remarks-format=") + Format;
508 CmdArgs.push_back(Args.MakeArgString(FormatArg));
509 }
510
511 if (getLastProfileUseArg(Args)) {
512 CmdArgs.push_back("-mllvm");
513 CmdArgs.push_back("-lto-pass-remarks-with-hotness");
514
515 if (const Arg *A =
516 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
517 CmdArgs.push_back("-mllvm");
518 std::string Opt =
519 std::string("-lto-pass-remarks-hotness-threshold=") + A->getValue();
520 CmdArgs.push_back(Args.MakeArgString(Opt));
521 }
522 }
523}
524
525static void AppendPlatformPrefix(SmallString<128> &Path, const llvm::Triple &T);
526
528 const InputInfo &Output,
529 const InputInfoList &Inputs,
530 const ArgList &Args,
531 const char *LinkingOutput) const {
532 assert(Output.getType() == types::TY_Image && "Invalid linker output type.");
533
534 // If the number of arguments surpasses the system limits, we will encode the
535 // input files in a separate file, shortening the command line. To this end,
536 // build a list of input file names that can be passed via a file with the
537 // -filelist linker option.
538 llvm::opt::ArgStringList InputFileList;
539
540 // The logic here is derived from gcc's behavior; most of which
541 // comes from specs (starting with link_command). Consult gcc for
542 // more information.
543 ArgStringList CmdArgs;
544
545 /// Hack(tm) to ignore linking errors when we are doing ARC migration.
546 if (Args.hasArg(options::OPT_ccc_arcmt_check,
547 options::OPT_ccc_arcmt_migrate)) {
548 for (const auto &Arg : Args)
549 Arg->claim();
550 const char *Exec =
551 Args.MakeArgString(getToolChain().GetProgramPath("touch"));
552 CmdArgs.push_back(Output.getFilename());
553 C.addCommand(std::make_unique<Command>(JA, *this,
555 CmdArgs, std::nullopt, Output));
556 return;
557 }
558
559 VersionTuple Version = getMachOToolChain().getLinkerVersion(Args);
560
561 bool LinkerIsLLD;
562 const char *Exec =
563 Args.MakeArgString(getToolChain().GetLinkerPath(&LinkerIsLLD));
564
565 // I'm not sure why this particular decomposition exists in gcc, but
566 // we follow suite for ease of comparison.
567 AddLinkArgs(C, Args, CmdArgs, Inputs, Version, LinkerIsLLD);
568
569 if (willEmitRemarks(Args) &&
570 checkRemarksOptions(getToolChain().getDriver(), Args,
571 getToolChain().getTriple()))
572 renderRemarksOptions(Args, CmdArgs, getToolChain().getTriple(), Output, JA);
573
574 // Propagate the -moutline flag to the linker in LTO.
575 if (Arg *A =
576 Args.getLastArg(options::OPT_moutline, options::OPT_mno_outline)) {
577 if (A->getOption().matches(options::OPT_moutline)) {
578 if (getMachOToolChain().getMachOArchName(Args) == "arm64") {
579 CmdArgs.push_back("-mllvm");
580 CmdArgs.push_back("-enable-machine-outliner");
581
582 // Outline from linkonceodr functions by default in LTO.
583 CmdArgs.push_back("-mllvm");
584 CmdArgs.push_back("-enable-linkonceodr-outlining");
585 }
586 } else {
587 // Disable all outlining behaviour if we have mno-outline. We need to do
588 // this explicitly, because targets which support default outlining will
589 // try to do work if we don't.
590 CmdArgs.push_back("-mllvm");
591 CmdArgs.push_back("-enable-machine-outliner=never");
592 }
593 }
594
595 // Setup statistics file output.
596 SmallString<128> StatsFile =
597 getStatsFileName(Args, Output, Inputs[0], getToolChain().getDriver());
598 if (!StatsFile.empty()) {
599 CmdArgs.push_back("-mllvm");
600 CmdArgs.push_back(Args.MakeArgString("-lto-stats-file=" + StatsFile.str()));
601 }
602
603 // It seems that the 'e' option is completely ignored for dynamic executables
604 // (the default), and with static executables, the last one wins, as expected.
605 Args.AddAllArgs(CmdArgs, {options::OPT_d_Flag, options::OPT_s, options::OPT_t,
606 options::OPT_Z_Flag, options::OPT_u_Group,
607 options::OPT_e, options::OPT_r});
608
609 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading
610 // members of static archive libraries which implement Objective-C classes or
611 // categories.
612 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX))
613 CmdArgs.push_back("-ObjC");
614
615 CmdArgs.push_back("-o");
616 CmdArgs.push_back(Output.getFilename());
617
618 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
619 getMachOToolChain().addStartObjectFileArgs(Args, CmdArgs);
620
621 Args.AddAllArgs(CmdArgs, options::OPT_L);
622
623 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs, JA);
624 // Build the input file for -filelist (list of linker input files) in case we
625 // need it later
626 for (const auto &II : Inputs) {
627 if (!II.isFilename()) {
628 // This is a linker input argument.
629 // We cannot mix input arguments and file names in a -filelist input, thus
630 // we prematurely stop our list (remaining files shall be passed as
631 // arguments).
632 if (InputFileList.size() > 0)
633 break;
634
635 continue;
636 }
637
638 InputFileList.push_back(II.getFilename());
639 }
640
641 // Additional linker set-up and flags for Fortran. This is required in order
642 // to generate executables.
643 if (getToolChain().getDriver().IsFlangMode()) {
644 addFortranRuntimeLibraryPath(getToolChain(), Args, CmdArgs);
645 addFortranRuntimeLibs(getToolChain(), CmdArgs);
646 }
647
648 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs))
649 addOpenMPRuntime(CmdArgs, getToolChain(), Args);
650
651 if (isObjCRuntimeLinked(Args) &&
652 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
653 // We use arclite library for both ARC and subscripting support.
654 getMachOToolChain().AddLinkARCArgs(Args, CmdArgs);
655
656 CmdArgs.push_back("-framework");
657 CmdArgs.push_back("Foundation");
658 // Link libobj.
659 CmdArgs.push_back("-lobjc");
660 }
661
662 if (LinkingOutput) {
663 CmdArgs.push_back("-arch_multiple");
664 CmdArgs.push_back("-final_output");
665 CmdArgs.push_back(LinkingOutput);
666 }
667
668 if (Args.hasArg(options::OPT_fnested_functions))
669 CmdArgs.push_back("-allow_stack_execute");
670
671 getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
672
673 StringRef Parallelism = getLTOParallelism(Args, getToolChain().getDriver());
674 if (!Parallelism.empty()) {
675 CmdArgs.push_back("-mllvm");
676 unsigned NumThreads =
677 llvm::get_threadpool_strategy(Parallelism)->compute_thread_count();
678 CmdArgs.push_back(Args.MakeArgString("-threads=" + Twine(NumThreads)));
679 }
680
681 if (getToolChain().ShouldLinkCXXStdlib(Args))
682 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs);
683
684 bool NoStdOrDefaultLibs =
685 Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs);
686 bool ForceLinkBuiltins = Args.hasArg(options::OPT_fapple_link_rtlib);
687 if (!NoStdOrDefaultLibs || ForceLinkBuiltins) {
688 // link_ssp spec is empty.
689
690 // If we have both -nostdlib/nodefaultlibs and -fapple-link-rtlib then
691 // we just want to link the builtins, not the other libs like libSystem.
692 if (NoStdOrDefaultLibs && ForceLinkBuiltins) {
693 getMachOToolChain().AddLinkRuntimeLib(Args, CmdArgs, "builtins");
694 } else {
695 // Let the tool chain choose which runtime library to link.
696 getMachOToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs,
697 ForceLinkBuiltins);
698
699 // No need to do anything for pthreads. Claim argument to avoid warning.
700 Args.ClaimAllArgs(options::OPT_pthread);
701 Args.ClaimAllArgs(options::OPT_pthreads);
702 }
703 }
704
705 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
706 // endfile_spec is empty.
707 }
708
709 Args.AddAllArgs(CmdArgs, options::OPT_T_Group);
710 Args.AddAllArgs(CmdArgs, options::OPT_F);
711
712 // -iframework should be forwarded as -F.
713 for (const Arg *A : Args.filtered(options::OPT_iframework))
714 CmdArgs.push_back(Args.MakeArgString(std::string("-F") + A->getValue()));
715
716 if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
717 if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
718 if (A->getValue() == StringRef("Accelerate")) {
719 CmdArgs.push_back("-framework");
720 CmdArgs.push_back("Accelerate");
721 }
722 }
723 }
724
725 // Add non-standard, platform-specific search paths, e.g., for DriverKit:
726 // -L<sysroot>/System/DriverKit/usr/lib
727 // -F<sysroot>/System/DriverKit/System/Library/Framework
728 {
729 bool NonStandardSearchPath = false;
730 const auto &Triple = getToolChain().getTriple();
731 if (Triple.isDriverKit()) {
732 // ld64 fixed the implicit -F and -L paths in ld64-605.1+.
733 NonStandardSearchPath =
734 Version.getMajor() < 605 ||
735 (Version.getMajor() == 605 && Version.getMinor().value_or(0) < 1);
736 }
737
738 if (NonStandardSearchPath) {
739 if (auto *Sysroot = Args.getLastArg(options::OPT_isysroot)) {
740 auto AddSearchPath = [&](StringRef Flag, StringRef SearchPath) {
741 SmallString<128> P(Sysroot->getValue());
742 AppendPlatformPrefix(P, Triple);
743 llvm::sys::path::append(P, SearchPath);
744 if (getToolChain().getVFS().exists(P)) {
745 CmdArgs.push_back(Args.MakeArgString(Flag + P));
746 }
747 };
748 AddSearchPath("-L", "/usr/lib");
749 AddSearchPath("-F", "/System/Library/Frameworks");
750 }
751 }
752 }
753
754 ResponseFileSupport ResponseSupport;
755 if (Version >= VersionTuple(705) || LinkerIsLLD) {
756 ResponseSupport = ResponseFileSupport::AtFileUTF8();
757 } else {
758 // For older versions of the linker, use the legacy filelist method instead.
759 ResponseSupport = {ResponseFileSupport::RF_FileList, llvm::sys::WEM_UTF8,
760 "-filelist"};
761 }
762
763 std::unique_ptr<Command> Cmd = std::make_unique<Command>(
764 JA, *this, ResponseSupport, Exec, CmdArgs, Inputs, Output);
765 Cmd->setInputFileList(std::move(InputFileList));
766 C.addCommand(std::move(Cmd));
767}
768
770 const InputInfo &Output,
771 const InputInfoList &Inputs,
772 const ArgList &Args,
773 const char *LinkingOutput) const {
774 const Driver &D = getToolChain().getDriver();
775
776 // Silence warning for "clang -g foo.o -o foo"
777 Args.ClaimAllArgs(options::OPT_g_Group);
778 // and "clang -emit-llvm foo.o -o foo"
779 Args.ClaimAllArgs(options::OPT_emit_llvm);
780 // and for "clang -w foo.o -o foo". Other warning options are already
781 // handled somewhere else.
782 Args.ClaimAllArgs(options::OPT_w);
783 // Silence warnings when linking C code with a C++ '-stdlib' argument.
784 Args.ClaimAllArgs(options::OPT_stdlib_EQ);
785
786 // libtool <options> <output_file> <input_files>
787 ArgStringList CmdArgs;
788 // Create and insert file members with a deterministic index.
789 CmdArgs.push_back("-static");
790 CmdArgs.push_back("-D");
791 CmdArgs.push_back("-no_warning_for_no_symbols");
792 CmdArgs.push_back("-o");
793 CmdArgs.push_back(Output.getFilename());
794
795 for (const auto &II : Inputs) {
796 if (II.isFilename()) {
797 CmdArgs.push_back(II.getFilename());
798 }
799 }
800
801 // Delete old output archive file if it already exists before generating a new
802 // archive file.
803 const auto *OutputFileName = Output.getFilename();
804 if (Output.isFilename() && llvm::sys::fs::exists(OutputFileName)) {
805 if (std::error_code EC = llvm::sys::fs::remove(OutputFileName)) {
806 D.Diag(diag::err_drv_unable_to_remove_file) << EC.message();
807 return;
808 }
809 }
810
811 const char *Exec = Args.MakeArgString(getToolChain().GetStaticLibToolPath());
812 C.addCommand(std::make_unique<Command>(JA, *this,
814 Exec, CmdArgs, Inputs, Output));
815}
816
818 const InputInfo &Output,
819 const InputInfoList &Inputs,
820 const ArgList &Args,
821 const char *LinkingOutput) const {
822 ArgStringList CmdArgs;
823
824 CmdArgs.push_back("-create");
825 assert(Output.isFilename() && "Unexpected lipo output.");
826
827 CmdArgs.push_back("-output");
828 CmdArgs.push_back(Output.getFilename());
829
830 for (const auto &II : Inputs) {
831 assert(II.isFilename() && "Unexpected lipo input.");
832 CmdArgs.push_back(II.getFilename());
833 }
834
835 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
836 C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
837 Exec, CmdArgs, Inputs, Output));
838}
839
841 const InputInfo &Output,
842 const InputInfoList &Inputs,
843 const ArgList &Args,
844 const char *LinkingOutput) const {
845 ArgStringList CmdArgs;
846
847 CmdArgs.push_back("-o");
848 CmdArgs.push_back(Output.getFilename());
849
850 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
851 const InputInfo &Input = Inputs[0];
852 assert(Input.isFilename() && "Unexpected dsymutil input.");
853 CmdArgs.push_back(Input.getFilename());
854
855 const char *Exec =
856 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
857 C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
858 Exec, CmdArgs, Inputs, Output));
859}
860
862 const InputInfo &Output,
863 const InputInfoList &Inputs,
864 const ArgList &Args,
865 const char *LinkingOutput) const {
866 ArgStringList CmdArgs;
867 CmdArgs.push_back("--verify");
868 CmdArgs.push_back("--debug-info");
869 CmdArgs.push_back("--eh-frame");
870 CmdArgs.push_back("--quiet");
871
872 assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
873 const InputInfo &Input = Inputs[0];
874 assert(Input.isFilename() && "Unexpected verify input");
875
876 // Grabbing the output of the earlier dsymutil run.
877 CmdArgs.push_back(Input.getFilename());
878
879 const char *Exec =
880 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
881 C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(),
882 Exec, CmdArgs, Inputs, Output));
883}
884
885MachO::MachO(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
886 : ToolChain(D, Triple, Args) {
887 // We expect 'as', 'ld', etc. to be adjacent to our install dir.
888 getProgramPaths().push_back(getDriver().getInstalledDir());
889 if (getDriver().getInstalledDir() != getDriver().Dir)
890 getProgramPaths().push_back(getDriver().Dir);
891}
892
893/// Darwin - Darwin tool chain for i386 and x86_64.
894Darwin::Darwin(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
895 : MachO(D, Triple, Args), TargetInitialized(false),
896 CudaInstallation(D, Triple, Args), RocmInstallation(D, Triple, Args) {}
897
900
901 // Darwin always preprocesses assembly files (unless -x is used explicitly).
902 if (Ty == types::TY_PP_Asm)
903 return types::TY_Asm;
904
905 return Ty;
906}
907
908bool MachO::HasNativeLLVMSupport() const { return true; }
909
911 // Always use libc++ by default
913}
914
915/// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
919 if (isTargetIOSBased())
921 if (isNonFragile)
924}
925
926/// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
929 return true;
930 else if (isTargetIOSBased())
931 return !isIPhoneOSVersionLT(3, 2);
932 else {
933 assert(isTargetMacOSBased() && "unexpected darwin target");
934 return !isMacosxVersionLT(10, 6);
935 }
936}
937
938void Darwin::AddCudaIncludeArgs(const ArgList &DriverArgs,
939 ArgStringList &CC1Args) const {
940 CudaInstallation.AddCudaIncludeArgs(DriverArgs, CC1Args);
941}
942
943void Darwin::AddHIPIncludeArgs(const ArgList &DriverArgs,
944 ArgStringList &CC1Args) const {
945 RocmInstallation.AddHIPIncludeArgs(DriverArgs, CC1Args);
946}
947
948// This is just a MachO name translation routine and there's no
949// way to join this into ARMTargetParser without breaking all
950// other assumptions. Maybe MachO should consider standardising
951// their nomenclature.
952static const char *ArmMachOArchName(StringRef Arch) {
953 return llvm::StringSwitch<const char *>(Arch)
954 .Case("armv6k", "armv6")
955 .Case("armv6m", "armv6m")
956 .Case("armv5tej", "armv5")
957 .Case("xscale", "xscale")
958 .Case("armv4t", "armv4t")
959 .Case("armv7", "armv7")
960 .Cases("armv7a", "armv7-a", "armv7")
961 .Cases("armv7r", "armv7-r", "armv7")
962 .Cases("armv7em", "armv7e-m", "armv7em")
963 .Cases("armv7k", "armv7-k", "armv7k")
964 .Cases("armv7m", "armv7-m", "armv7m")
965 .Cases("armv7s", "armv7-s", "armv7s")
966 .Default(nullptr);
967}
968
969static const char *ArmMachOArchNameCPU(StringRef CPU) {
970 llvm::ARM::ArchKind ArchKind = llvm::ARM::parseCPUArch(CPU);
971 if (ArchKind == llvm::ARM::ArchKind::INVALID)
972 return nullptr;
973 StringRef Arch = llvm::ARM::getArchName(ArchKind);
974
975 // FIXME: Make sure this MachO triple mangling is really necessary.
976 // ARMv5* normalises to ARMv5.
977 if (Arch.startswith("armv5"))
978 Arch = Arch.substr(0, 5);
979 // ARMv6*, except ARMv6M, normalises to ARMv6.
980 else if (Arch.startswith("armv6") && !Arch.endswith("6m"))
981 Arch = Arch.substr(0, 5);
982 // ARMv7A normalises to ARMv7.
983 else if (Arch.endswith("v7a"))
984 Arch = Arch.substr(0, 5);
985 return Arch.data();
986}
987
988StringRef MachO::getMachOArchName(const ArgList &Args) const {
989 switch (getTriple().getArch()) {
990 default:
992
993 case llvm::Triple::aarch64_32:
994 return "arm64_32";
995
996 case llvm::Triple::aarch64: {
997 if (getTriple().isArm64e())
998 return "arm64e";
999 return "arm64";
1000 }
1001
1002 case llvm::Triple::thumb:
1003 case llvm::Triple::arm:
1004 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_march_EQ))
1005 if (const char *Arch = ArmMachOArchName(A->getValue()))
1006 return Arch;
1007
1008 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
1009 if (const char *Arch = ArmMachOArchNameCPU(A->getValue()))
1010 return Arch;
1011
1012 return "arm";
1013 }
1014}
1015
1016VersionTuple MachO::getLinkerVersion(const llvm::opt::ArgList &Args) const {
1017 if (LinkerVersion) {
1018#ifndef NDEBUG
1019 VersionTuple NewLinkerVersion;
1020 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1021 (void)NewLinkerVersion.tryParse(A->getValue());
1022 assert(NewLinkerVersion == LinkerVersion);
1023#endif
1024 return *LinkerVersion;
1025 }
1026
1027 VersionTuple NewLinkerVersion;
1028 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ))
1029 if (NewLinkerVersion.tryParse(A->getValue()))
1030 getDriver().Diag(diag::err_drv_invalid_version_number)
1031 << A->getAsString(Args);
1032
1033 LinkerVersion = NewLinkerVersion;
1034 return *LinkerVersion;
1035}
1036
1038
1040
1041std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args,
1042 types::ID InputType) const {
1043 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
1044
1045 // If the target isn't initialized (e.g., an unknown Darwin platform, return
1046 // the default triple).
1047 if (!isTargetInitialized())
1048 return Triple.getTriple();
1049
1050 SmallString<16> Str;
1052 Str += "watchos";
1053 else if (isTargetTvOSBased())
1054 Str += "tvos";
1055 else if (isTargetDriverKit())
1056 Str += "driverkit";
1057 else if (isTargetIOSBased() || isTargetMacCatalyst())
1058 Str += "ios";
1059 else
1060 Str += "macosx";
1061 Str += getTripleTargetVersion().getAsString();
1062 Triple.setOSName(Str);
1063
1064 return Triple.getTriple();
1065}
1066
1068 switch (AC) {
1070 if (!Lipo)
1071 Lipo.reset(new tools::darwin::Lipo(*this));
1072 return Lipo.get();
1074 if (!Dsymutil)
1075 Dsymutil.reset(new tools::darwin::Dsymutil(*this));
1076 return Dsymutil.get();
1078 if (!VerifyDebug)
1079 VerifyDebug.reset(new tools::darwin::VerifyDebug(*this));
1080 return VerifyDebug.get();
1081 default:
1082 return ToolChain::getTool(AC);
1083 }
1084}
1085
1086Tool *MachO::buildLinker() const { return new tools::darwin::Linker(*this); }
1087
1089 return new tools::darwin::StaticLibTool(*this);
1090}
1091
1093 return new tools::darwin::Assembler(*this);
1094}
1095
1096DarwinClang::DarwinClang(const Driver &D, const llvm::Triple &Triple,
1097 const ArgList &Args)
1098 : Darwin(D, Triple, Args) {}
1099
1100void DarwinClang::addClangWarningOptions(ArgStringList &CC1Args) const {
1101 // Always error about undefined 'TARGET_OS_*' macros.
1102 CC1Args.push_back("-Wundef-prefix=TARGET_OS_");
1103 CC1Args.push_back("-Werror=undef-prefix");
1104
1105 // For modern targets, promote certain warnings to errors.
1106 if (isTargetWatchOSBased() || getTriple().isArch64Bit()) {
1107 // Always enable -Wdeprecated-objc-isa-usage and promote it
1108 // to an error.
1109 CC1Args.push_back("-Wdeprecated-objc-isa-usage");
1110 CC1Args.push_back("-Werror=deprecated-objc-isa-usage");
1111
1112 // For iOS and watchOS, also error about implicit function declarations,
1113 // as that can impact calling conventions.
1114 if (!isTargetMacOS())
1115 CC1Args.push_back("-Werror=implicit-function-declaration");
1116 }
1117}
1118
1119/// Take a path that speculatively points into Xcode and return the
1120/// `XCODE/Contents/Developer` path if it is an Xcode path, or an empty path
1121/// otherwise.
1122static StringRef getXcodeDeveloperPath(StringRef PathIntoXcode) {
1123 static constexpr llvm::StringLiteral XcodeAppSuffix(
1124 ".app/Contents/Developer");
1125 size_t Index = PathIntoXcode.find(XcodeAppSuffix);
1126 if (Index == StringRef::npos)
1127 return "";
1128 return PathIntoXcode.take_front(Index + XcodeAppSuffix.size());
1129}
1130
1131void DarwinClang::AddLinkARCArgs(const ArgList &Args,
1132 ArgStringList &CmdArgs) const {
1133 // Avoid linking compatibility stubs on i386 mac.
1134 if (isTargetMacOSBased() && getArch() == llvm::Triple::x86)
1135 return;
1137 return;
1138 // ARC runtime is supported everywhere on arm64e.
1139 if (getTriple().isArm64e())
1140 return;
1141
1142 ObjCRuntime runtime = getDefaultObjCRuntime(/*nonfragile*/ true);
1143
1144 if ((runtime.hasNativeARC() || !isObjCAutoRefCount(Args)) &&
1145 runtime.hasSubscripting())
1146 return;
1147
1148 SmallString<128> P(getDriver().ClangExecutable);
1149 llvm::sys::path::remove_filename(P); // 'clang'
1150 llvm::sys::path::remove_filename(P); // 'bin'
1151 llvm::sys::path::append(P, "lib", "arc");
1152
1153 // 'libarclite' usually lives in the same toolchain as 'clang'. However, the
1154 // Swift open source toolchains for macOS distribute Clang without libarclite.
1155 // In that case, to allow the linker to find 'libarclite', we point to the
1156 // 'libarclite' in the XcodeDefault toolchain instead.
1157 if (!getVFS().exists(P)) {
1158 auto updatePath = [&](const Arg *A) {
1159 // Try to infer the path to 'libarclite' in the toolchain from the
1160 // specified SDK path.
1161 StringRef XcodePathForSDK = getXcodeDeveloperPath(A->getValue());
1162 if (XcodePathForSDK.empty())
1163 return false;
1164
1165 P = XcodePathForSDK;
1166 llvm::sys::path::append(P, "Toolchains/XcodeDefault.xctoolchain/usr",
1167 "lib", "arc");
1168 return getVFS().exists(P);
1169 };
1170
1171 bool updated = false;
1172 if (const Arg *A = Args.getLastArg(options::OPT_isysroot))
1173 updated = updatePath(A);
1174
1175 if (!updated) {
1176 if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
1177 updatePath(A);
1178 }
1179 }
1180
1181 CmdArgs.push_back("-force_load");
1182 llvm::sys::path::append(P, "libarclite_");
1183 // Mash in the platform.
1185 P += "watchsimulator";
1186 else if (isTargetWatchOS())
1187 P += "watchos";
1188 else if (isTargetTvOSSimulator())
1189 P += "appletvsimulator";
1190 else if (isTargetTvOS())
1191 P += "appletvos";
1192 else if (isTargetIOSSimulator())
1193 P += "iphonesimulator";
1194 else if (isTargetIPhoneOS())
1195 P += "iphoneos";
1196 else
1197 P += "macosx";
1198 P += ".a";
1199
1200 CmdArgs.push_back(Args.MakeArgString(P));
1201}
1202
1204 // Default to use DWARF 2 on OS X 10.10 / iOS 8 and lower.
1205 if ((isTargetMacOSBased() && isMacosxVersionLT(10, 11)) ||
1207 return 2;
1208 return 4;
1209}
1210
1211void MachO::AddLinkRuntimeLib(const ArgList &Args, ArgStringList &CmdArgs,
1212 StringRef Component, RuntimeLinkOptions Opts,
1213 bool IsShared) const {
1214 SmallString<64> DarwinLibName = StringRef("libclang_rt.");
1215 // an Darwin the builtins compomnent is not in the library name
1216 if (Component != "builtins") {
1217 DarwinLibName += Component;
1218 if (!(Opts & RLO_IsEmbedded))
1219 DarwinLibName += "_";
1220 }
1221
1222 DarwinLibName += getOSLibraryNameSuffix();
1223 DarwinLibName += IsShared ? "_dynamic.dylib" : ".a";
1224 SmallString<128> Dir(getDriver().ResourceDir);
1225 llvm::sys::path::append(Dir, "lib", "darwin");
1226 if (Opts & RLO_IsEmbedded)
1227 llvm::sys::path::append(Dir, "macho_embedded");
1228
1229 SmallString<128> P(Dir);
1230 llvm::sys::path::append(P, DarwinLibName);
1231
1232 // For now, allow missing resource libraries to support developers who may
1233 // not have compiler-rt checked out or integrated into their build (unless
1234 // we explicitly force linking with this library).
1235 if ((Opts & RLO_AlwaysLink) || getVFS().exists(P)) {
1236 const char *LibArg = Args.MakeArgString(P);
1237 CmdArgs.push_back(LibArg);
1238 }
1239
1240 // Adding the rpaths might negatively interact when other rpaths are involved,
1241 // so we should make sure we add the rpaths last, after all user-specified
1242 // rpaths. This is currently true from this place, but we need to be
1243 // careful if this function is ever called before user's rpaths are emitted.
1244 if (Opts & RLO_AddRPath) {
1245 assert(DarwinLibName.endswith(".dylib") && "must be a dynamic library");
1246
1247 // Add @executable_path to rpath to support having the dylib copied with
1248 // the executable.
1249 CmdArgs.push_back("-rpath");
1250 CmdArgs.push_back("@executable_path");
1251
1252 // Add the path to the resource dir to rpath to support using the dylib
1253 // from the default location without copying.
1254 CmdArgs.push_back("-rpath");
1255 CmdArgs.push_back(Args.MakeArgString(Dir));
1256 }
1257}
1258
1259StringRef Darwin::getPlatformFamily() const {
1260 switch (TargetPlatform) {
1262 return "MacOSX";
1265 return "MacOSX";
1266 return "iPhone";
1268 return "AppleTV";
1270 return "Watch";
1272 return "DriverKit";
1273 }
1274 llvm_unreachable("Unsupported platform");
1275}
1276
1277StringRef Darwin::getSDKName(StringRef isysroot) {
1278 // Assume SDK has path: SOME_PATH/SDKs/PlatformXX.YY.sdk
1279 auto BeginSDK = llvm::sys::path::rbegin(isysroot);
1280 auto EndSDK = llvm::sys::path::rend(isysroot);
1281 for (auto IT = BeginSDK; IT != EndSDK; ++IT) {
1282 StringRef SDK = *IT;
1283 if (SDK.endswith(".sdk"))
1284 return SDK.slice(0, SDK.size() - 4);
1285 }
1286 return "";
1287}
1288
1289StringRef Darwin::getOSLibraryNameSuffix(bool IgnoreSim) const {
1290 switch (TargetPlatform) {
1292 return "osx";
1295 return "osx";
1296 return TargetEnvironment == NativeEnvironment || IgnoreSim ? "ios"
1297 : "iossim";
1299 return TargetEnvironment == NativeEnvironment || IgnoreSim ? "tvos"
1300 : "tvossim";
1302 return TargetEnvironment == NativeEnvironment || IgnoreSim ? "watchos"
1303 : "watchossim";
1305 return "driverkit";
1306 }
1307 llvm_unreachable("Unsupported platform");
1308}
1309
1310/// Check if the link command contains a symbol export directive.
1311static bool hasExportSymbolDirective(const ArgList &Args) {
1312 for (Arg *A : Args) {
1313 if (A->getOption().matches(options::OPT_exported__symbols__list))
1314 return true;
1315 if (!A->getOption().matches(options::OPT_Wl_COMMA) &&
1316 !A->getOption().matches(options::OPT_Xlinker))
1317 continue;
1318 if (A->containsValue("-exported_symbols_list") ||
1319 A->containsValue("-exported_symbol"))
1320 return true;
1321 }
1322 return false;
1323}
1324
1325/// Add an export directive for \p Symbol to the link command.
1326static void addExportedSymbol(ArgStringList &CmdArgs, const char *Symbol) {
1327 CmdArgs.push_back("-exported_symbol");
1328 CmdArgs.push_back(Symbol);
1329}
1330
1331/// Add a sectalign directive for \p Segment and \p Section to the maximum
1332/// expected page size for Darwin.
1333///
1334/// On iPhone 6+ the max supported page size is 16K. On macOS, the max is 4K.
1335/// Use a common alignment constant (16K) for now, and reduce the alignment on
1336/// macOS if it proves important.
1337static void addSectalignToPage(const ArgList &Args, ArgStringList &CmdArgs,
1338 StringRef Segment, StringRef Section) {
1339 for (const char *A : {"-sectalign", Args.MakeArgString(Segment),
1340 Args.MakeArgString(Section), "0x4000"})
1341 CmdArgs.push_back(A);
1342}
1343
1344void Darwin::addProfileRTLibs(const ArgList &Args,
1345 ArgStringList &CmdArgs) const {
1346 if (!needsProfileRT(Args) && !needsGCovInstrumentation(Args))
1347 return;
1348
1349 AddLinkRuntimeLib(Args, CmdArgs, "profile",
1351
1352 bool ForGCOV = needsGCovInstrumentation(Args);
1353
1354 // If we have a symbol export directive and we're linking in the profile
1355 // runtime, automatically export symbols necessary to implement some of the
1356 // runtime's functionality.
1357 if (hasExportSymbolDirective(Args) && ForGCOV) {
1358 addExportedSymbol(CmdArgs, "___gcov_dump");
1359 addExportedSymbol(CmdArgs, "___gcov_reset");
1360 addExportedSymbol(CmdArgs, "_writeout_fn_list");
1361 addExportedSymbol(CmdArgs, "_reset_fn_list");
1362 }
1363
1364 // Align __llvm_prf_{cnts,data} sections to the maximum expected page
1365 // alignment. This allows profile counters to be mmap()'d to disk. Note that
1366 // it's not enough to just page-align __llvm_prf_cnts: the following section
1367 // must also be page-aligned so that its data is not clobbered by mmap().
1368 //
1369 // The section alignment is only needed when continuous profile sync is
1370 // enabled, but this is expected to be the default in Xcode. Specifying the
1371 // extra alignment also allows the same binary to be used with/without sync
1372 // enabled.
1373 if (!ForGCOV) {
1374 for (auto IPSK : {llvm::IPSK_cnts, llvm::IPSK_data}) {
1376 Args, CmdArgs, "__DATA",
1377 llvm::getInstrProfSectionName(IPSK, llvm::Triple::MachO,
1378 /*AddSegmentInfo=*/false));
1379 }
1380 }
1381}
1382
1383void DarwinClang::AddLinkSanitizerLibArgs(const ArgList &Args,
1384 ArgStringList &CmdArgs,
1385 StringRef Sanitizer,
1386 bool Shared) const {
1387 auto RLO = RuntimeLinkOptions(RLO_AlwaysLink | (Shared ? RLO_AddRPath : 0U));
1388 AddLinkRuntimeLib(Args, CmdArgs, Sanitizer, RLO, Shared);
1389}
1390
1392 const ArgList &Args) const {
1393 if (Arg* A = Args.getLastArg(options::OPT_rtlib_EQ)) {
1394 StringRef Value = A->getValue();
1395 if (Value != "compiler-rt" && Value != "platform")
1396 getDriver().Diag(clang::diag::err_drv_unsupported_rtlib_for_platform)
1397 << Value << "darwin";
1398 }
1399
1401}
1402
1403void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args,
1404 ArgStringList &CmdArgs,
1405 bool ForceLinkBuiltinRT) const {
1406 // Call once to ensure diagnostic is printed if wrong value was specified
1407 GetRuntimeLibType(Args);
1408
1409 // Darwin doesn't support real static executables, don't link any runtime
1410 // libraries with -static.
1411 if (Args.hasArg(options::OPT_static) ||
1412 Args.hasArg(options::OPT_fapple_kext) ||
1413 Args.hasArg(options::OPT_mkernel)) {
1414 if (ForceLinkBuiltinRT)
1415 AddLinkRuntimeLib(Args, CmdArgs, "builtins");
1416 return;
1417 }
1418
1419 // Reject -static-libgcc for now, we can deal with this when and if someone
1420 // cares. This is useful in situations where someone wants to statically link
1421 // something like libstdc++, and needs its runtime support routines.
1422 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) {
1423 getDriver().Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
1424 return;
1425 }
1426
1427 const SanitizerArgs &Sanitize = getSanitizerArgs(Args);
1428
1429 if (!Sanitize.needsSharedRt()) {
1430 const char *sanitizer = nullptr;
1431 if (Sanitize.needsUbsanRt()) {
1432 sanitizer = "UndefinedBehaviorSanitizer";
1433 } else if (Sanitize.needsAsanRt()) {
1434 sanitizer = "AddressSanitizer";
1435 } else if (Sanitize.needsTsanRt()) {
1436 sanitizer = "ThreadSanitizer";
1437 }
1438 if (sanitizer) {
1439 getDriver().Diag(diag::err_drv_unsupported_static_sanitizer_darwin)
1440 << sanitizer;
1441 return;
1442 }
1443 }
1444
1445 if (Sanitize.linkRuntimes()) {
1446 if (Sanitize.needsAsanRt()) {
1447 assert(Sanitize.needsSharedRt() &&
1448 "Static sanitizer runtimes not supported");
1449 AddLinkSanitizerLibArgs(Args, CmdArgs, "asan");
1450 }
1451 if (Sanitize.needsLsanRt())
1452 AddLinkSanitizerLibArgs(Args, CmdArgs, "lsan");
1453 if (Sanitize.needsUbsanRt()) {
1454 assert(Sanitize.needsSharedRt() &&
1455 "Static sanitizer runtimes not supported");
1456 AddLinkSanitizerLibArgs(
1457 Args, CmdArgs,
1458 Sanitize.requiresMinimalRuntime() ? "ubsan_minimal" : "ubsan");
1459 }
1460 if (Sanitize.needsTsanRt()) {
1461 assert(Sanitize.needsSharedRt() &&
1462 "Static sanitizer runtimes not supported");
1463 AddLinkSanitizerLibArgs(Args, CmdArgs, "tsan");
1464 }
1465 if (Sanitize.needsFuzzer() && !Args.hasArg(options::OPT_dynamiclib)) {
1466 AddLinkSanitizerLibArgs(Args, CmdArgs, "fuzzer", /*shared=*/false);
1467
1468 // Libfuzzer is written in C++ and requires libcxx.
1469 AddCXXStdlibLibArgs(Args, CmdArgs);
1470 }
1471 if (Sanitize.needsStatsRt()) {
1472 AddLinkRuntimeLib(Args, CmdArgs, "stats_client", RLO_AlwaysLink);
1473 AddLinkSanitizerLibArgs(Args, CmdArgs, "stats");
1474 }
1475 }
1476
1477 const XRayArgs &XRay = getXRayArgs();
1478 if (XRay.needsXRayRt()) {
1479 AddLinkRuntimeLib(Args, CmdArgs, "xray");
1480 AddLinkRuntimeLib(Args, CmdArgs, "xray-basic");
1481 AddLinkRuntimeLib(Args, CmdArgs, "xray-fdr");
1482 }
1483
1484 if (isTargetDriverKit() && !Args.hasArg(options::OPT_nodriverkitlib)) {
1485 CmdArgs.push_back("-framework");
1486 CmdArgs.push_back("DriverKit");
1487 }
1488
1489 // Otherwise link libSystem, then the dynamic runtime library, and finally any
1490 // target specific static runtime library.
1491 if (!isTargetDriverKit())
1492 CmdArgs.push_back("-lSystem");
1493
1494 // Select the dynamic runtime library and the target specific static library.
1495 if (isTargetIOSBased()) {
1496 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1,
1497 // it never went into the SDK.
1498 // Linking against libgcc_s.1 isn't needed for iOS 5.0+
1499 if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator() &&
1500 getTriple().getArch() != llvm::Triple::aarch64)
1501 CmdArgs.push_back("-lgcc_s.1");
1502 }
1503 AddLinkRuntimeLib(Args, CmdArgs, "builtins");
1504}
1505
1506/// Returns the most appropriate macOS target version for the current process.
1507///
1508/// If the macOS SDK version is the same or earlier than the system version,
1509/// then the SDK version is returned. Otherwise the system version is returned.
1510static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion) {
1511 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1512 if (!SystemTriple.isMacOSX())
1513 return std::string(MacOSSDKVersion);
1514 VersionTuple SystemVersion;
1515 SystemTriple.getMacOSXVersion(SystemVersion);
1516
1517 unsigned Major, Minor, Micro;
1518 bool HadExtra;
1519 if (!Driver::GetReleaseVersion(MacOSSDKVersion, Major, Minor, Micro,
1520 HadExtra))
1521 return std::string(MacOSSDKVersion);
1522 VersionTuple SDKVersion(Major, Minor, Micro);
1523
1524 if (SDKVersion > SystemVersion)
1525 return SystemVersion.getAsString();
1526 return std::string(MacOSSDKVersion);
1527}
1528
1529namespace {
1530
1531/// The Darwin OS that was selected or inferred from arguments / environment.
1532struct DarwinPlatform {
1533 enum SourceKind {
1534 /// The OS was specified using the -target argument.
1535 TargetArg,
1536 /// The OS was specified using the -mtargetos= argument.
1537 MTargetOSArg,
1538 /// The OS was specified using the -m<os>-version-min argument.
1539 OSVersionArg,
1540 /// The OS was specified using the OS_DEPLOYMENT_TARGET environment.
1541 DeploymentTargetEnv,
1542 /// The OS was inferred from the SDK.
1543 InferredFromSDK,
1544 /// The OS was inferred from the -arch.
1545 InferredFromArch
1546 };
1547
1548 using DarwinPlatformKind = Darwin::DarwinPlatformKind;
1549 using DarwinEnvironmentKind = Darwin::DarwinEnvironmentKind;
1550
1551 DarwinPlatformKind getPlatform() const { return Platform; }
1552
1553 DarwinEnvironmentKind getEnvironment() const { return Environment; }
1554
1555 void setEnvironment(DarwinEnvironmentKind Kind) {
1556 Environment = Kind;
1557 InferSimulatorFromArch = false;
1558 }
1559
1560 StringRef getOSVersion() const {
1561 if (Kind == OSVersionArg)
1562 return Argument->getValue();
1563 return OSVersion;
1564 }
1565
1566 void setOSVersion(StringRef S) {
1567 assert(Kind == TargetArg && "Unexpected kind!");
1568 OSVersion = std::string(S);
1569 }
1570
1571 bool hasOSVersion() const { return HasOSVersion; }
1572
1573 VersionTuple getNativeTargetVersion() const {
1574 assert(Environment == DarwinEnvironmentKind::MacCatalyst &&
1575 "native target version is specified only for Mac Catalyst");
1576 return NativeTargetVersion;
1577 }
1578
1579 /// Returns true if the target OS was explicitly specified.
1580 bool isExplicitlySpecified() const { return Kind <= DeploymentTargetEnv; }
1581
1582 /// Returns true if the simulator environment can be inferred from the arch.
1583 bool canInferSimulatorFromArch() const { return InferSimulatorFromArch; }
1584
1585 const std::optional<llvm::Triple> &getTargetVariantTriple() const {
1586 return TargetVariantTriple;
1587 }
1588
1589 /// Adds the -m<os>-version-min argument to the compiler invocation.
1590 void addOSVersionMinArgument(DerivedArgList &Args, const OptTable &Opts) {
1591 if (Argument)
1592 return;
1593 assert(Kind != TargetArg && Kind != MTargetOSArg && Kind != OSVersionArg &&
1594 "Invalid kind");
1595 options::ID Opt;
1596 switch (Platform) {
1597 case DarwinPlatformKind::MacOS:
1598 Opt = options::OPT_mmacos_version_min_EQ;
1599 break;
1600 case DarwinPlatformKind::IPhoneOS:
1601 Opt = options::OPT_mios_version_min_EQ;
1602 break;
1603 case DarwinPlatformKind::TvOS:
1604 Opt = options::OPT_mtvos_version_min_EQ;
1605 break;
1606 case DarwinPlatformKind::WatchOS:
1607 Opt = options::OPT_mwatchos_version_min_EQ;
1608 break;
1609 case DarwinPlatformKind::DriverKit:
1610 // DriverKit always explicitly provides a version in the triple.
1611 return;
1612 }
1613 Argument = Args.MakeJoinedArg(nullptr, Opts.getOption(Opt), OSVersion);
1614 Args.append(Argument);
1615 }
1616
1617 /// Returns the OS version with the argument / environment variable that
1618 /// specified it.
1619 std::string getAsString(DerivedArgList &Args, const OptTable &Opts) {
1620 switch (Kind) {
1621 case TargetArg:
1622 case MTargetOSArg:
1623 case OSVersionArg:
1624 case InferredFromSDK:
1625 case InferredFromArch:
1626 assert(Argument && "OS version argument not yet inferred");
1627 return Argument->getAsString(Args);
1628 case DeploymentTargetEnv:
1629 return (llvm::Twine(EnvVarName) + "=" + OSVersion).str();
1630 }
1631 llvm_unreachable("Unsupported Darwin Source Kind");
1632 }
1633
1634 void setEnvironment(llvm::Triple::EnvironmentType EnvType,
1635 const VersionTuple &OSVersion,
1636 const std::optional<DarwinSDKInfo> &SDKInfo) {
1637 switch (EnvType) {
1638 case llvm::Triple::Simulator:
1639 Environment = DarwinEnvironmentKind::Simulator;
1640 break;
1641 case llvm::Triple::MacABI: {
1642 Environment = DarwinEnvironmentKind::MacCatalyst;
1643 // The minimum native macOS target for MacCatalyst is macOS 10.15.
1644 NativeTargetVersion = VersionTuple(10, 15);
1645 if (HasOSVersion && SDKInfo) {
1646 if (const auto *MacCatalystToMacOSMapping = SDKInfo->getVersionMapping(
1648 if (auto MacOSVersion = MacCatalystToMacOSMapping->map(
1649 OSVersion, NativeTargetVersion, std::nullopt)) {
1650 NativeTargetVersion = *MacOSVersion;
1651 }
1652 }
1653 }
1654 // In a zippered build, we could be building for a macOS target that's
1655 // lower than the version that's implied by the OS version. In that case
1656 // we need to use the minimum version as the native target version.
1657 if (TargetVariantTriple) {
1658 auto TargetVariantVersion = TargetVariantTriple->getOSVersion();
1659 if (TargetVariantVersion.getMajor()) {
1660 if (TargetVariantVersion < NativeTargetVersion)
1661 NativeTargetVersion = TargetVariantVersion;
1662 }
1663 }
1664 break;
1665 }
1666 default:
1667 break;
1668 }
1669 }
1670
1671 static DarwinPlatform
1672 createFromTarget(const llvm::Triple &TT, StringRef OSVersion, Arg *A,
1673 std::optional<llvm::Triple> TargetVariantTriple,
1674 const std::optional<DarwinSDKInfo> &SDKInfo) {
1675 DarwinPlatform Result(TargetArg, getPlatformFromOS(TT.getOS()), OSVersion,
1676 A);
1677 VersionTuple OsVersion = TT.getOSVersion();
1678 if (OsVersion.getMajor() == 0)
1679 Result.HasOSVersion = false;
1680 Result.TargetVariantTriple = TargetVariantTriple;
1681 Result.setEnvironment(TT.getEnvironment(), OsVersion, SDKInfo);
1682 return Result;
1683 }
1684 static DarwinPlatform
1685 createFromMTargetOS(llvm::Triple::OSType OS, VersionTuple OSVersion,
1686 llvm::Triple::EnvironmentType Environment, Arg *A,
1687 const std::optional<DarwinSDKInfo> &SDKInfo) {
1688 DarwinPlatform Result(MTargetOSArg, getPlatformFromOS(OS),
1689 OSVersion.getAsString(), A);
1690 Result.InferSimulatorFromArch = false;
1691 Result.setEnvironment(Environment, OSVersion, SDKInfo);
1692 return Result;
1693 }
1694 static DarwinPlatform createOSVersionArg(DarwinPlatformKind Platform, Arg *A,
1695 bool IsSimulator) {
1696 DarwinPlatform Result{OSVersionArg, Platform, A};
1697 if (IsSimulator)
1698 Result.Environment = DarwinEnvironmentKind::Simulator;
1699 return Result;
1700 }
1701 static DarwinPlatform createDeploymentTargetEnv(DarwinPlatformKind Platform,
1702 StringRef EnvVarName,
1703 StringRef Value) {
1704 DarwinPlatform Result(DeploymentTargetEnv, Platform, Value);
1705 Result.EnvVarName = EnvVarName;
1706 return Result;
1707 }
1708 static DarwinPlatform createFromSDK(DarwinPlatformKind Platform,
1709 StringRef Value,
1710 bool IsSimulator = false) {
1711 DarwinPlatform Result(InferredFromSDK, Platform, Value);
1712 if (IsSimulator)
1713 Result.Environment = DarwinEnvironmentKind::Simulator;
1714 Result.InferSimulatorFromArch = false;
1715 return Result;
1716 }
1717 static DarwinPlatform createFromArch(llvm::Triple::OSType OS,
1718 StringRef Value) {
1719 return DarwinPlatform(InferredFromArch, getPlatformFromOS(OS), Value);
1720 }
1721
1722 /// Constructs an inferred SDKInfo value based on the version inferred from
1723 /// the SDK path itself. Only works for values that were created by inferring
1724 /// the platform from the SDKPath.
1725 DarwinSDKInfo inferSDKInfo() {
1726 assert(Kind == InferredFromSDK && "can infer SDK info only");
1727 llvm::VersionTuple Version;
1728 bool IsValid = !Version.tryParse(OSVersion);
1729 (void)IsValid;
1730 assert(IsValid && "invalid SDK version");
1731 return DarwinSDKInfo(
1732 Version,
1733 /*MaximumDeploymentTarget=*/VersionTuple(Version.getMajor(), 0, 99));
1734 }
1735
1736private:
1737 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, Arg *Argument)
1738 : Kind(Kind), Platform(Platform), Argument(Argument) {}
1739 DarwinPlatform(SourceKind Kind, DarwinPlatformKind Platform, StringRef Value,
1740 Arg *Argument = nullptr)
1741 : Kind(Kind), Platform(Platform), OSVersion(Value), Argument(Argument) {}
1742
1743 static DarwinPlatformKind getPlatformFromOS(llvm::Triple::OSType OS) {
1744 switch (OS) {
1745 case llvm::Triple::Darwin:
1746 case llvm::Triple::MacOSX:
1747 return DarwinPlatformKind::MacOS;
1748 case llvm::Triple::IOS:
1749 return DarwinPlatformKind::IPhoneOS;
1750 case llvm::Triple::TvOS:
1751 return DarwinPlatformKind::TvOS;
1752 case llvm::Triple::WatchOS:
1753 return DarwinPlatformKind::WatchOS;
1754 case llvm::Triple::DriverKit:
1755 return DarwinPlatformKind::DriverKit;
1756 default:
1757 llvm_unreachable("Unable to infer Darwin variant");
1758 }
1759 }
1760
1761 SourceKind Kind;
1762 DarwinPlatformKind Platform;
1763 DarwinEnvironmentKind Environment = DarwinEnvironmentKind::NativeEnvironment;
1764 VersionTuple NativeTargetVersion;
1765 std::string OSVersion;
1766 bool HasOSVersion = true, InferSimulatorFromArch = true;
1767 Arg *Argument;
1768 StringRef EnvVarName;
1769 std::optional<llvm::Triple> TargetVariantTriple;
1770};
1771
1772/// Returns the deployment target that's specified using the -m<os>-version-min
1773/// argument.
1774std::optional<DarwinPlatform>
1775getDeploymentTargetFromOSVersionArg(DerivedArgList &Args,
1776 const Driver &TheDriver) {
1777 Arg *macOSVersion = Args.getLastArg(options::OPT_mmacos_version_min_EQ);
1778 Arg *iOSVersion = Args.getLastArg(options::OPT_mios_version_min_EQ,
1779 options::OPT_mios_simulator_version_min_EQ);
1780 Arg *TvOSVersion =
1781 Args.getLastArg(options::OPT_mtvos_version_min_EQ,
1782 options::OPT_mtvos_simulator_version_min_EQ);
1783 Arg *WatchOSVersion =
1784 Args.getLastArg(options::OPT_mwatchos_version_min_EQ,
1785 options::OPT_mwatchos_simulator_version_min_EQ);
1786 if (macOSVersion) {
1787 if (iOSVersion || TvOSVersion || WatchOSVersion) {
1788 TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1789 << macOSVersion->getAsString(Args)
1790 << (iOSVersion ? iOSVersion
1791 : TvOSVersion ? TvOSVersion : WatchOSVersion)
1792 ->getAsString(Args);
1793 }
1794 return DarwinPlatform::createOSVersionArg(Darwin::MacOS, macOSVersion,
1795 /*IsSimulator=*/false);
1796 } else if (iOSVersion) {
1797 if (TvOSVersion || WatchOSVersion) {
1798 TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1799 << iOSVersion->getAsString(Args)
1800 << (TvOSVersion ? TvOSVersion : WatchOSVersion)->getAsString(Args);
1801 }
1802 return DarwinPlatform::createOSVersionArg(
1803 Darwin::IPhoneOS, iOSVersion,
1804 iOSVersion->getOption().getID() ==
1805 options::OPT_mios_simulator_version_min_EQ);
1806 } else if (TvOSVersion) {
1807 if (WatchOSVersion) {
1808 TheDriver.Diag(diag::err_drv_argument_not_allowed_with)
1809 << TvOSVersion->getAsString(Args)
1810 << WatchOSVersion->getAsString(Args);
1811 }
1812 return DarwinPlatform::createOSVersionArg(
1813 Darwin::TvOS, TvOSVersion,
1814 TvOSVersion->getOption().getID() ==
1815 options::OPT_mtvos_simulator_version_min_EQ);
1816 } else if (WatchOSVersion)
1817 return DarwinPlatform::createOSVersionArg(
1818 Darwin::WatchOS, WatchOSVersion,
1819 WatchOSVersion->getOption().getID() ==
1820 options::OPT_mwatchos_simulator_version_min_EQ);
1821 return std::nullopt;
1822}
1823
1824/// Returns the deployment target that's specified using the
1825/// OS_DEPLOYMENT_TARGET environment variable.
1826std::optional<DarwinPlatform>
1827getDeploymentTargetFromEnvironmentVariables(const Driver &TheDriver,
1828 const llvm::Triple &Triple) {
1829 std::string Targets[Darwin::LastDarwinPlatform + 1];
1830 const char *EnvVars[] = {
1831 "MACOSX_DEPLOYMENT_TARGET",
1832 "IPHONEOS_DEPLOYMENT_TARGET",
1833 "TVOS_DEPLOYMENT_TARGET",
1834 "WATCHOS_DEPLOYMENT_TARGET",
1835 "DRIVERKIT_DEPLOYMENT_TARGET",
1836 };
1837 static_assert(std::size(EnvVars) == Darwin::LastDarwinPlatform + 1,
1838 "Missing platform");
1839 for (const auto &I : llvm::enumerate(llvm::ArrayRef(EnvVars))) {
1840 if (char *Env = ::getenv(I.value()))
1841 Targets[I.index()] = Env;
1842 }
1843
1844 // Allow conflicts among OSX and iOS for historical reasons, but choose the
1845 // default platform.
1846 if (!Targets[Darwin::MacOS].empty() &&
1847 (!Targets[Darwin::IPhoneOS].empty() ||
1848 !Targets[Darwin::WatchOS].empty() || !Targets[Darwin::TvOS].empty())) {
1849 if (Triple.getArch() == llvm::Triple::arm ||
1850 Triple.getArch() == llvm::Triple::aarch64 ||
1851 Triple.getArch() == llvm::Triple::thumb)
1852 Targets[Darwin::MacOS] = "";
1853 else
1854 Targets[Darwin::IPhoneOS] = Targets[Darwin::WatchOS] =
1855 Targets[Darwin::TvOS] = "";
1856 } else {
1857 // Don't allow conflicts in any other platform.
1858 unsigned FirstTarget = std::size(Targets);
1859 for (unsigned I = 0; I != std::size(Targets); ++I) {
1860 if (Targets[I].empty())
1861 continue;
1862 if (FirstTarget == std::size(Targets))
1863 FirstTarget = I;
1864 else
1865 TheDriver.Diag(diag::err_drv_conflicting_deployment_targets)
1866 << Targets[FirstTarget] << Targets[I];
1867 }
1868 }
1869
1870 for (const auto &Target : llvm::enumerate(llvm::ArrayRef(Targets))) {
1871 if (!Target.value().empty())
1872 return DarwinPlatform::createDeploymentTargetEnv(
1873 (Darwin::DarwinPlatformKind)Target.index(), EnvVars[Target.index()],
1874 Target.value());
1875 }
1876 return std::nullopt;
1877}
1878
1879/// Returns the SDK name without the optional prefix that ends with a '.' or an
1880/// empty string otherwise.
1881static StringRef dropSDKNamePrefix(StringRef SDKName) {
1882 size_t PrefixPos = SDKName.find('.');
1883 if (PrefixPos == StringRef::npos)
1884 return "";
1885 return SDKName.substr(PrefixPos + 1);
1886}
1887
1888/// Tries to infer the deployment target from the SDK specified by -isysroot
1889/// (or SDKROOT). Uses the version specified in the SDKSettings.json file if
1890/// it's available.
1891std::optional<DarwinPlatform>
1892inferDeploymentTargetFromSDK(DerivedArgList &Args,
1893 const std::optional<DarwinSDKInfo> &SDKInfo) {
1894 const Arg *A = Args.getLastArg(options::OPT_isysroot);
1895 if (!A)
1896 return std::nullopt;
1897 StringRef isysroot = A->getValue();
1898 StringRef SDK = Darwin::getSDKName(isysroot);
1899 if (!SDK.size())
1900 return std::nullopt;
1901
1902 std::string Version;
1903 if (SDKInfo) {
1904 // Get the version from the SDKSettings.json if it's available.
1905 Version = SDKInfo->getVersion().getAsString();
1906 } else {
1907 // Slice the version number out.
1908 // Version number is between the first and the last number.
1909 size_t StartVer = SDK.find_first_of("0123456789");
1910 size_t EndVer = SDK.find_last_of("0123456789");
1911 if (StartVer != StringRef::npos && EndVer > StartVer)
1912 Version = std::string(SDK.slice(StartVer, EndVer + 1));
1913 }
1914 if (Version.empty())
1915 return std::nullopt;
1916
1917 auto CreatePlatformFromSDKName =
1918 [&](StringRef SDK) -> std::optional<DarwinPlatform> {
1919 if (SDK.startswith("iPhoneOS") || SDK.startswith("iPhoneSimulator"))
1920 return DarwinPlatform::createFromSDK(
1921 Darwin::IPhoneOS, Version,
1922 /*IsSimulator=*/SDK.startswith("iPhoneSimulator"));
1923 else if (SDK.startswith("MacOSX"))
1924 return DarwinPlatform::createFromSDK(Darwin::MacOS,
1926 else if (SDK.startswith("WatchOS") || SDK.startswith("WatchSimulator"))
1927 return DarwinPlatform::createFromSDK(
1928 Darwin::WatchOS, Version,
1929 /*IsSimulator=*/SDK.startswith("WatchSimulator"));
1930 else if (SDK.startswith("AppleTVOS") || SDK.startswith("AppleTVSimulator"))
1931 return DarwinPlatform::createFromSDK(
1932 Darwin::TvOS, Version,
1933 /*IsSimulator=*/SDK.startswith("AppleTVSimulator"));
1934 else if (SDK.startswith("DriverKit"))
1935 return DarwinPlatform::createFromSDK(Darwin::DriverKit, Version);
1936 return std::nullopt;
1937 };
1938 if (auto Result = CreatePlatformFromSDKName(SDK))
1939 return Result;
1940 // The SDK can be an SDK variant with a name like `<prefix>.<platform>`.
1941 return CreatePlatformFromSDKName(dropSDKNamePrefix(SDK));
1942}
1943
1944std::string getOSVersion(llvm::Triple::OSType OS, const llvm::Triple &Triple,
1945 const Driver &TheDriver) {
1946 VersionTuple OsVersion;
1947 llvm::Triple SystemTriple(llvm::sys::getProcessTriple());
1948 switch (OS) {
1949 case llvm::Triple::Darwin:
1950 case llvm::Triple::MacOSX:
1951 // If there is no version specified on triple, and both host and target are
1952 // macos, use the host triple to infer OS version.
1953 if (Triple.isMacOSX() && SystemTriple.isMacOSX() &&
1954 !Triple.getOSMajorVersion())
1955 SystemTriple.getMacOSXVersion(OsVersion);
1956 else if (!Triple.getMacOSXVersion(OsVersion))
1957 TheDriver.Diag(diag::err_drv_invalid_darwin_version)
1958 << Triple.getOSName();
1959 break;
1960 case llvm::Triple::IOS:
1961 if (Triple.isMacCatalystEnvironment() && !Triple.getOSMajorVersion()) {
1962 OsVersion = VersionTuple(13, 1);
1963 } else
1964 OsVersion = Triple.getiOSVersion();
1965 break;
1966 case llvm::Triple::TvOS:
1967 OsVersion = Triple.getOSVersion();
1968 break;
1969 case llvm::Triple::WatchOS:
1970 OsVersion = Triple.getWatchOSVersion();
1971 break;
1972 case llvm::Triple::DriverKit:
1973 OsVersion = Triple.getDriverKitVersion();
1974 break;
1975 default:
1976 llvm_unreachable("Unexpected OS type");
1977 break;
1978 }
1979
1980 std::string OSVersion;
1981 llvm::raw_string_ostream(OSVersion)
1982 << OsVersion.getMajor() << '.' << OsVersion.getMinor().value_or(0) << '.'
1983 << OsVersion.getSubminor().value_or(0);
1984 return OSVersion;
1985}
1986
1987/// Tries to infer the target OS from the -arch.
1988std::optional<DarwinPlatform>
1989inferDeploymentTargetFromArch(DerivedArgList &Args, const Darwin &Toolchain,
1990 const llvm::Triple &Triple,
1991 const Driver &TheDriver) {
1992 llvm::Triple::OSType OSTy = llvm::Triple::UnknownOS;
1993
1994 StringRef MachOArchName = Toolchain.getMachOArchName(Args);
1995 if (MachOArchName == "arm64" || MachOArchName == "arm64e")
1996 OSTy = llvm::Triple::MacOSX;
1997 else if (MachOArchName == "armv7" || MachOArchName == "armv7s")
1998 OSTy = llvm::Triple::IOS;
1999 else if (MachOArchName == "armv7k" || MachOArchName == "arm64_32")
2000 OSTy = llvm::Triple::WatchOS;
2001 else if (MachOArchName != "armv6m" && MachOArchName != "armv7m" &&
2002 MachOArchName != "armv7em")
2003 OSTy = llvm::Triple::MacOSX;
2004 if (OSTy == llvm::Triple::UnknownOS)
2005 return std::nullopt;
2006 return DarwinPlatform::createFromArch(OSTy,
2007 getOSVersion(OSTy, Triple, TheDriver));
2008}
2009
2010/// Returns the deployment target that's specified using the -target option.
2011std::optional<DarwinPlatform> getDeploymentTargetFromTargetArg(
2012 DerivedArgList &Args, const llvm::Triple &Triple, const Driver &TheDriver,
2013 const std::optional<DarwinSDKInfo> &SDKInfo) {
2014 if (!Args.hasArg(options::OPT_target))
2015 return std::nullopt;
2016 if (Triple.getOS() == llvm::Triple::Darwin ||
2017 Triple.getOS() == llvm::Triple::UnknownOS)
2018 return std::nullopt;
2019 std::string OSVersion = getOSVersion(Triple.getOS(), Triple, TheDriver);
2020 std::optional<llvm::Triple> TargetVariantTriple;
2021 for (const Arg *A : Args.filtered(options::OPT_darwin_target_variant)) {
2022 llvm::Triple TVT(A->getValue());
2023 // Find a matching <arch>-<vendor> target variant triple that can be used.
2024 if ((Triple.getArch() == llvm::Triple::aarch64 ||
2025 TVT.getArchName() == Triple.getArchName()) &&
2026 TVT.getArch() == Triple.getArch() &&
2027 TVT.getSubArch() == Triple.getSubArch() &&
2028 TVT.getVendor() == Triple.getVendor()) {
2029 if (TargetVariantTriple)
2030 continue;
2031 A->claim();
2032 // Accept a -target-variant triple when compiling code that may run on
2033 // macOS or Mac Catalust.
2034 if ((Triple.isMacOSX() && TVT.getOS() == llvm::Triple::IOS &&
2035 TVT.isMacCatalystEnvironment()) ||
2036 (TVT.isMacOSX() && Triple.getOS() == llvm::Triple::IOS &&
2037 Triple.isMacCatalystEnvironment())) {
2038 TargetVariantTriple = TVT;
2039 continue;
2040 }
2041 TheDriver.Diag(diag::err_drv_target_variant_invalid)
2042 << A->getSpelling() << A->getValue();
2043 }
2044 }
2045 return DarwinPlatform::createFromTarget(Triple, OSVersion,
2046 Args.getLastArg(options::OPT_target),
2047 TargetVariantTriple, SDKInfo);
2048}
2049
2050/// Returns the deployment target that's specified using the -mtargetos option.
2051std::optional<DarwinPlatform> getDeploymentTargetFromMTargetOSArg(
2052 DerivedArgList &Args, const Driver &TheDriver,
2053 const std::optional<DarwinSDKInfo> &SDKInfo) {
2054 auto *A = Args.getLastArg(options::OPT_mtargetos_EQ);
2055 if (!A)
2056 return std::nullopt;
2057 llvm::Triple TT(llvm::Twine("unknown-apple-") + A->getValue());
2058 switch (TT.getOS()) {
2059 case llvm::Triple::MacOSX:
2060 case llvm::Triple::IOS:
2061 case llvm::Triple::TvOS:
2062 case llvm::Triple::WatchOS:
2063 break;
2064 default:
2065 TheDriver.Diag(diag::err_drv_invalid_os_in_arg)
2066 << TT.getOSName() << A->getAsString(Args);
2067 return std::nullopt;
2068 }
2069
2070 VersionTuple Version = TT.getOSVersion();
2071 if (!Version.getMajor()) {
2072 TheDriver.Diag(diag::err_drv_invalid_version_number)
2073 << A->getAsString(Args);
2074 return std::nullopt;
2075 }
2076 return DarwinPlatform::createFromMTargetOS(TT.getOS(), Version,
2077 TT.getEnvironment(), A, SDKInfo);
2078}
2079
2080std::optional<DarwinSDKInfo> parseSDKSettings(llvm::vfs::FileSystem &VFS,
2081 const ArgList &Args,
2082 const Driver &TheDriver) {
2083 const Arg *A = Args.getLastArg(options::OPT_isysroot);
2084 if (!A)
2085 return std::nullopt;
2086 StringRef isysroot = A->getValue();
2087 auto SDKInfoOrErr = parseDarwinSDKInfo(VFS, isysroot);
2088 if (!SDKInfoOrErr) {
2089 llvm::consumeError(SDKInfoOrErr.takeError());
2090 TheDriver.Diag(diag::warn_drv_darwin_sdk_invalid_settings);
2091 return std::nullopt;
2092 }
2093 return *SDKInfoOrErr;
2094}
2095
2096} // namespace
2097
2098void Darwin::AddDeploymentTarget(DerivedArgList &Args) const {
2099 const OptTable &Opts = getDriver().getOpts();
2100
2101 // Support allowing the SDKROOT environment variable used by xcrun and other
2102 // Xcode tools to define the default sysroot, by making it the default for
2103 // isysroot.
2104 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2105 // Warn if the path does not exist.
2106 if (!getVFS().exists(A->getValue()))
2107 getDriver().Diag(clang::diag::warn_missing_sysroot) << A->getValue();
2108 } else {
2109 if (char *env = ::getenv("SDKROOT")) {
2110 // We only use this value as the default if it is an absolute path,
2111 // exists, and it is not the root path.
2112 if (llvm::sys::path::is_absolute(env) && getVFS().exists(env) &&
2113 StringRef(env) != "/") {
2114 Args.append(Args.MakeSeparateArg(
2115 nullptr, Opts.getOption(options::OPT_isysroot), env));
2116 }
2117 }
2118 }
2119
2120 // Read the SDKSettings.json file for more information, like the SDK version
2121 // that we can pass down to the compiler.
2122 SDKInfo = parseSDKSettings(getVFS(), Args, getDriver());
2123
2124 // The OS and the version can be specified using the -target argument.
2125 std::optional<DarwinPlatform> OSTarget =
2126 getDeploymentTargetFromTargetArg(Args, getTriple(), getDriver(), SDKInfo);
2127 if (OSTarget) {
2128 // Disallow mixing -target and -mtargetos=.
2129 if (const auto *MTargetOSArg = Args.getLastArg(options::OPT_mtargetos_EQ)) {
2130 std::string TargetArgStr = OSTarget->getAsString(Args, Opts);
2131 std::string MTargetOSArgStr = MTargetOSArg->getAsString(Args);
2132 getDriver().Diag(diag::err_drv_cannot_mix_options)
2133 << TargetArgStr << MTargetOSArgStr;
2134 }
2135 std::optional<DarwinPlatform> OSVersionArgTarget =
2136 getDeploymentTargetFromOSVersionArg(Args, getDriver());
2137 if (OSVersionArgTarget) {
2138 unsigned TargetMajor, TargetMinor, TargetMicro;
2139 bool TargetExtra;
2140 unsigned ArgMajor, ArgMinor, ArgMicro;
2141 bool ArgExtra;
2142 if (OSTarget->getPlatform() != OSVersionArgTarget->getPlatform() ||
2143 (Driver::GetReleaseVersion(OSTarget->getOSVersion(), TargetMajor,
2144 TargetMinor, TargetMicro, TargetExtra) &&
2145 Driver::GetReleaseVersion(OSVersionArgTarget->getOSVersion(),
2146 ArgMajor, ArgMinor, ArgMicro, ArgExtra) &&
2147 (VersionTuple(TargetMajor, TargetMinor, TargetMicro) !=
2148 VersionTuple(ArgMajor, ArgMinor, ArgMicro) ||
2149 TargetExtra != ArgExtra))) {
2150 // Select the OS version from the -m<os>-version-min argument when
2151 // the -target does not include an OS version.
2152 if (OSTarget->getPlatform() == OSVersionArgTarget->getPlatform() &&
2153 !OSTarget->hasOSVersion()) {
2154 OSTarget->setOSVersion(OSVersionArgTarget->getOSVersion());
2155 } else {
2156 // Warn about -m<os>-version-min that doesn't match the OS version
2157 // that's specified in the target.
2158 std::string OSVersionArg =
2159 OSVersionArgTarget->getAsString(Args, Opts);
2160 std::string TargetArg = OSTarget->getAsString(Args, Opts);
2161 getDriver().Diag(clang::diag::warn_drv_overriding_flag_option)
2162 << OSVersionArg << TargetArg;
2163 }
2164 }
2165 }
2166 } else if ((OSTarget = getDeploymentTargetFromMTargetOSArg(Args, getDriver(),
2167 SDKInfo))) {
2168 // The OS target can be specified using the -mtargetos= argument.
2169 // Disallow mixing -mtargetos= and -m<os>version-min=.
2170 std::optional<DarwinPlatform> OSVersionArgTarget =
2171 getDeploymentTargetFromOSVersionArg(Args, getDriver());
2172 if (OSVersionArgTarget) {
2173 std::string MTargetOSArgStr = OSTarget->getAsString(Args, Opts);
2174 std::string OSVersionArgStr = OSVersionArgTarget->getAsString(Args, Opts);
2175 getDriver().Diag(diag::err_drv_cannot_mix_options)
2176 << MTargetOSArgStr << OSVersionArgStr;
2177 }
2178 } else {
2179 // The OS target can be specified using the -m<os>version-min argument.
2180 OSTarget = getDeploymentTargetFromOSVersionArg(Args, getDriver());
2181 // If no deployment target was specified on the command line, check for
2182 // environment defines.
2183 if (!OSTarget) {
2184 OSTarget =
2185 getDeploymentTargetFromEnvironmentVariables(getDriver(), getTriple());
2186 if (OSTarget) {
2187 // Don't infer simulator from the arch when the SDK is also specified.
2188 std::optional<DarwinPlatform> SDKTarget =
2189 inferDeploymentTargetFromSDK(Args, SDKInfo);
2190 if (SDKTarget)
2191 OSTarget->setEnvironment(SDKTarget->getEnvironment());
2192 }
2193 }
2194 // If there is no command-line argument to specify the Target version and
2195 // no environment variable defined, see if we can set the default based
2196 // on -isysroot using SDKSettings.json if it exists.
2197 if (!OSTarget) {
2198 OSTarget = inferDeploymentTargetFromSDK(Args, SDKInfo);
2199 /// If the target was successfully constructed from the SDK path, try to
2200 /// infer the SDK info if the SDK doesn't have it.
2201 if (OSTarget && !SDKInfo)
2202 SDKInfo = OSTarget->inferSDKInfo();
2203 }
2204 // If no OS targets have been specified, try to guess platform from -target
2205 // or arch name and compute the version from the triple.
2206 if (!OSTarget)
2207 OSTarget =
2208 inferDeploymentTargetFromArch(Args, *this, getTriple(), getDriver());
2209 }
2210
2211 assert(OSTarget && "Unable to infer Darwin variant");
2212 OSTarget->addOSVersionMinArgument(Args, Opts);
2213 DarwinPlatformKind Platform = OSTarget->getPlatform();
2214
2215 unsigned Major, Minor, Micro;
2216 bool HadExtra;
2217 // The major version should not be over this number.
2218 const unsigned MajorVersionLimit = 1000;
2219 // Set the tool chain target information.
2220 if (Platform == MacOS) {
2221 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
2222 Micro, HadExtra) ||
2223 HadExtra || Major < 10 || Major >= MajorVersionLimit || Minor >= 100 ||
2224 Micro >= 100)
2225 getDriver().Diag(diag::err_drv_invalid_version_number)
2226 << OSTarget->getAsString(Args, Opts);
2227 } else if (Platform == IPhoneOS) {
2228 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
2229 Micro, HadExtra) ||
2230 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2231 getDriver().Diag(diag::err_drv_invalid_version_number)
2232 << OSTarget->getAsString(Args, Opts);
2233 ;
2234 if (OSTarget->getEnvironment() == MacCatalyst &&
2235 (Major < 13 || (Major == 13 && Minor < 1))) {
2236 getDriver().Diag(diag::err_drv_invalid_version_number)
2237 << OSTarget->getAsString(Args, Opts);
2238 Major = 13;
2239 Minor = 1;
2240 Micro = 0;
2241 }
2242 // For 32-bit targets, the deployment target for iOS has to be earlier than
2243 // iOS 11.
2244 if (getTriple().isArch32Bit() && Major >= 11) {
2245 // If the deployment target is explicitly specified, print a diagnostic.
2246 if (OSTarget->isExplicitlySpecified()) {
2247 if (OSTarget->getEnvironment() == MacCatalyst)
2248 getDriver().Diag(diag::err_invalid_macos_32bit_deployment_target);
2249 else
2250 getDriver().Diag(diag::warn_invalid_ios_deployment_target)
2251 << OSTarget->getAsString(Args, Opts);
2252 // Otherwise, set it to 10.99.99.
2253 } else {
2254 Major = 10;
2255 Minor = 99;
2256 Micro = 99;
2257 }
2258 }
2259 } else if (Platform == TvOS) {
2260 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
2261 Micro, HadExtra) ||
2262 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2263 getDriver().Diag(diag::err_drv_invalid_version_number)
2264 << OSTarget->getAsString(Args, Opts);
2265 } else if (Platform == WatchOS) {
2266 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
2267 Micro, HadExtra) ||
2268 HadExtra || Major >= MajorVersionLimit || Minor >= 100 || Micro >= 100)
2269 getDriver().Diag(diag::err_drv_invalid_version_number)
2270 << OSTarget->getAsString(Args, Opts);
2271 } else if (Platform == DriverKit) {
2272 if (!Driver::GetReleaseVersion(OSTarget->getOSVersion(), Major, Minor,
2273 Micro, HadExtra) ||
2274 HadExtra || Major < 19 || Major >= MajorVersionLimit || Minor >= 100 ||
2275 Micro >= 100)
2276 getDriver().Diag(diag::err_drv_invalid_version_number)
2277 << OSTarget->getAsString(Args, Opts);
2278 } else
2279 llvm_unreachable("unknown kind of Darwin platform");
2280
2281 DarwinEnvironmentKind Environment = OSTarget->getEnvironment();
2282 // Recognize iOS targets with an x86 architecture as the iOS simulator.
2283 if (Environment == NativeEnvironment && Platform != MacOS &&
2284 Platform != DriverKit && OSTarget->canInferSimulatorFromArch() &&
2285 getTriple().isX86())
2286 Environment = Simulator;
2287
2288 VersionTuple NativeTargetVersion;
2289 if (Environment == MacCatalyst)
2290 NativeTargetVersion = OSTarget->getNativeTargetVersion();
2291 setTarget(Platform, Environment, Major, Minor, Micro, NativeTargetVersion);
2292 TargetVariantTriple = OSTarget->getTargetVariantTriple();
2293
2294 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2295 StringRef SDK = getSDKName(A->getValue());
2296 if (SDK.size() > 0) {
2297 size_t StartVer = SDK.find_first_of("0123456789");
2298 StringRef SDKName = SDK.slice(0, StartVer);
2299 if (!SDKName.startswith(getPlatformFamily()) &&
2300 !dropSDKNamePrefix(SDKName).startswith(getPlatformFamily()))
2301 getDriver().Diag(diag::warn_incompatible_sysroot)
2302 << SDKName << getPlatformFamily();
2303 }
2304 }
2305}
2306
2307// For certain platforms/environments almost all resources (e.g., headers) are
2308// located in sub-directories, e.g., for DriverKit they live in
2309// <SYSROOT>/System/DriverKit/usr/include (instead of <SYSROOT>/usr/include).
2311 const llvm::Triple &T) {
2312 if (T.isDriverKit()) {
2313 llvm::sys::path::append(Path, "System", "DriverKit");
2314 }
2315}
2316
2317// Returns the effective sysroot from either -isysroot or --sysroot, plus the
2318// platform prefix (if any).
2320DarwinClang::GetEffectiveSysroot(const llvm::opt::ArgList &DriverArgs) const {
2321 llvm::SmallString<128> Path("/");
2322 if (DriverArgs.hasArg(options::OPT_isysroot))
2323 Path = DriverArgs.getLastArgValue(options::OPT_isysroot);
2324 else if (!getDriver().SysRoot.empty())
2325 Path = getDriver().SysRoot;
2326
2327 if (hasEffectiveTriple()) {
2329 }
2330 return Path;
2331}
2332
2333void DarwinClang::AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
2334 llvm::opt::ArgStringList &CC1Args) const {
2335 const Driver &D = getDriver();
2336
2337 llvm::SmallString<128> Sysroot = GetEffectiveSysroot(DriverArgs);
2338
2339 bool NoStdInc = DriverArgs.hasArg(options::OPT_nostdinc);
2340 bool NoStdlibInc = DriverArgs.hasArg(options::OPT_nostdlibinc);
2341 bool NoBuiltinInc = DriverArgs.hasFlag(
2342 options::OPT_nobuiltininc, options::OPT_ibuiltininc, /*Default=*/false);
2343 bool ForceBuiltinInc = DriverArgs.hasFlag(
2344 options::OPT_ibuiltininc, options::OPT_nobuiltininc, /*Default=*/false);
2345
2346 // Add <sysroot>/usr/local/include
2347 if (!NoStdInc && !NoStdlibInc) {
2348 SmallString<128> P(Sysroot);
2349 llvm::sys::path::append(P, "usr", "local", "include");
2350 addSystemInclude(DriverArgs, CC1Args, P);
2351 }
2352
2353 // Add the Clang builtin headers (<resource>/include)
2354 if (!(NoStdInc && !ForceBuiltinInc) && !NoBuiltinInc) {
2356 llvm::sys::path::append(P, "include");
2357 addSystemInclude(DriverArgs, CC1Args, P);
2358 }
2359
2360 if (NoStdInc || NoStdlibInc)
2361 return;
2362
2363 // Check for configure-time C include directories.
2364 llvm::StringRef CIncludeDirs(C_INCLUDE_DIRS);
2365 if (!CIncludeDirs.empty()) {
2367 CIncludeDirs.split(dirs, ":");
2368 for (llvm::StringRef dir : dirs) {
2369 llvm::StringRef Prefix =
2370 llvm::sys::path::is_absolute(dir) ? "" : llvm::StringRef(Sysroot);
2371 addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
2372 }
2373 } else {
2374 // Otherwise, add <sysroot>/usr/include.
2375 SmallString<128> P(Sysroot);
2376 llvm::sys::path::append(P, "usr", "include");
2377 addExternCSystemInclude(DriverArgs, CC1Args, P.str());
2378 }
2379}
2380
2381bool DarwinClang::AddGnuCPlusPlusIncludePaths(const llvm::opt::ArgList &DriverArgs,
2382 llvm::opt::ArgStringList &CC1Args,
2384 llvm::StringRef Version,
2385 llvm::StringRef ArchDir,
2386 llvm::StringRef BitDir) const {
2387 llvm::sys::path::append(Base, Version);
2388
2389 // Add the base dir
2390 addSystemInclude(DriverArgs, CC1Args, Base);
2391
2392 // Add the multilib dirs
2393 {
2395 if (!ArchDir.empty())
2396 llvm::sys::path::append(P, ArchDir);
2397 if (!BitDir.empty())
2398 llvm::sys::path::append(P, BitDir);
2399 addSystemInclude(DriverArgs, CC1Args, P);
2400 }
2401
2402 // Add the backward dir
2403 {
2405 llvm::sys::path::append(P, "backward");
2406 addSystemInclude(DriverArgs, CC1Args, P);
2407 }
2408
2409 return getVFS().exists(Base);
2410}
2411
2413 const llvm::opt::ArgList &DriverArgs,
2414 llvm::opt::ArgStringList &CC1Args) const {
2415 // The implementation from a base class will pass through the -stdlib to
2416 // CC1Args.
2417 // FIXME: this should not be necessary, remove usages in the frontend
2418 // (e.g. HeaderSearchOptions::UseLibcxx) and don't pipe -stdlib.
2419 // Also check whether this is used for setting library search paths.
2420 ToolChain::AddClangCXXStdlibIncludeArgs(DriverArgs, CC1Args);
2421
2422 if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
2423 options::OPT_nostdincxx))
2424 return;
2425
2426 llvm::SmallString<128> Sysroot = GetEffectiveSysroot(DriverArgs);
2427
2428 switch (GetCXXStdlibType(DriverArgs)) {
2429 case ToolChain::CST_Libcxx: {
2430 // On Darwin, libc++ can be installed in one of the following two places:
2431 // 1. Alongside the compiler in <install>/include/c++/v1
2432 // 2. In a SDK (or a custom sysroot) in <sysroot>/usr/include/c++/v1
2433 //
2434 // The precendence of paths is as listed above, i.e. we take the first path
2435 // that exists. Also note that we never include libc++ twice -- we take the
2436 // first path that exists and don't send the other paths to CC1 (otherwise
2437 // include_next could break).
2438
2439 // Check for (1)
2440 // Get from '<install>/bin' to '<install>/include/c++/v1'.
2441 // Note that InstallBin can be relative, so we use '..' instead of
2442 // parent_path.
2443 llvm::SmallString<128> InstallBin =
2444 llvm::StringRef(getDriver().getInstalledDir()); // <install>/bin
2445 llvm::sys::path::append(InstallBin, "..", "include", "c++", "v1");
2446 if (getVFS().exists(InstallBin)) {
2447 addSystemInclude(DriverArgs, CC1Args, InstallBin);
2448 return;
2449 } else if (DriverArgs.hasArg(options::OPT_v)) {
2450 llvm::errs() << "ignoring nonexistent directory \"" << InstallBin
2451 << "\"\n";
2452 }
2453
2454 // Otherwise, check for (2)
2455 llvm::SmallString<128> SysrootUsr = Sysroot;
2456 llvm::sys::path::append(SysrootUsr, "usr", "include", "c++", "v1");
2457 if (getVFS().exists(SysrootUsr)) {
2458 addSystemInclude(DriverArgs, CC1Args, SysrootUsr);
2459 return;
2460 } else if (DriverArgs.hasArg(options::OPT_v)) {
2461 llvm::errs() << "ignoring nonexistent directory \"" << SysrootUsr
2462 << "\"\n";
2463 }
2464
2465 // Otherwise, don't add any path.
2466 break;
2467 }
2468
2470 llvm::SmallString<128> UsrIncludeCxx = Sysroot;
2471 llvm::sys::path::append(UsrIncludeCxx, "usr", "include", "c++");
2472
2473 llvm::Triple::ArchType arch = getTriple().getArch();
2474 bool IsBaseFound = true;
2475 switch (arch) {
2476 default: break;
2477
2478 case llvm::Triple::x86:
2479 case llvm::Triple::x86_64:
2480 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2481 "4.2.1",
2482 "i686-apple-darwin10",
2483 arch == llvm::Triple::x86_64 ? "x86_64" : "");
2484 IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2485 "4.0.0", "i686-apple-darwin8",
2486 "");
2487 break;
2488
2489 case llvm::Triple::arm:
2490 case llvm::Triple::thumb:
2491 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2492 "4.2.1",
2493 "arm-apple-darwin10",
2494 "v7");
2495 IsBaseFound |= AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2496 "4.2.1",
2497 "arm-apple-darwin10",
2498 "v6");
2499 break;
2500
2501 case llvm::Triple::aarch64:
2502 IsBaseFound = AddGnuCPlusPlusIncludePaths(DriverArgs, CC1Args, UsrIncludeCxx,
2503 "4.2.1",
2504 "arm64-apple-darwin10",
2505 "");
2506 break;
2507 }
2508
2509 if (!IsBaseFound) {
2510 getDriver().Diag(diag::warn_drv_libstdcxx_not_found);
2511 }
2512
2513 break;
2514 }
2515}
2516
2517void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args,
2518 ArgStringList &CmdArgs) const {
2520
2521 switch (Type) {
2523 CmdArgs.push_back("-lc++");
2524 if (Args.hasArg(options::OPT_fexperimental_library))
2525 CmdArgs.push_back("-lc++experimental");
2526 break;
2527
2529 // Unfortunately, -lstdc++ doesn't always exist in the standard search path;
2530 // it was previously found in the gcc lib dir. However, for all the Darwin
2531 // platforms we care about it was -lstdc++.6, so we search for that
2532 // explicitly if we can't see an obvious -lstdc++ candidate.
2533
2534 // Check in the sysroot first.
2535 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
2536 SmallString<128> P(A->getValue());
2537 llvm::sys::path::append(P, "usr", "lib", "libstdc++.dylib");
2538
2539 if (!getVFS().exists(P)) {
2540 llvm::sys::path::remove_filename(P);
2541 llvm::sys::path::append(P, "libstdc++.6.dylib");
2542 if (getVFS().exists(P)) {
2543 CmdArgs.push_back(Args.MakeArgString(P));
2544 return;
2545 }
2546 }
2547 }
2548
2549 // Otherwise, look in the root.
2550 // FIXME: This should be removed someday when we don't have to care about
2551 // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist.
2552 if (!getVFS().exists("/usr/lib/libstdc++.dylib") &&
2553 getVFS().exists("/usr/lib/libstdc++.6.dylib")) {
2554 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib");
2555 return;
2556 }
2557
2558 // Otherwise, let the linker search.
2559 CmdArgs.push_back("-lstdc++");
2560 break;
2561 }
2562}
2563
2564void DarwinClang::AddCCKextLibArgs(const ArgList &Args,
2565 ArgStringList &CmdArgs) const {
2566 // For Darwin platforms, use the compiler-rt-based support library
2567 // instead of the gcc-provided one (which is also incidentally
2568 // only present in the gcc lib dir, which makes it hard to find).
2569
2570 SmallString<128> P(getDriver().ResourceDir);
2571 llvm::sys::path::append(P, "lib", "darwin");
2572
2573 // Use the newer cc_kext for iOS ARM after 6.0.
2574 if (isTargetWatchOS()) {
2575 llvm::sys::path::append(P, "libclang_rt.cc_kext_watchos.a");
2576 } else if (isTargetTvOS()) {
2577 llvm::sys::path::append(P, "libclang_rt.cc_kext_tvos.a");
2578 } else if (isTargetIPhoneOS()) {
2579 llvm::sys::path::append(P, "libclang_rt.cc_kext_ios.a");
2580 } else if (isTargetDriverKit()) {
2581 // DriverKit doesn't want extra runtime support.
2582 } else {
2583 llvm::sys::path::append(P, "libclang_rt.cc_kext.a");
2584 }
2585
2586 // For now, allow missing resource libraries to support developers who may
2587 // not have compiler-rt checked out or integrated into their build.
2588 if (getVFS().exists(P))
2589 CmdArgs.push_back(Args.MakeArgString(P));
2590}
2591
2592DerivedArgList *MachO::TranslateArgs(const DerivedArgList &Args,
2593 StringRef BoundArch,
2594 Action::OffloadKind) const {
2595 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs());
2596 const OptTable &Opts = getDriver().getOpts();
2597
2598 // FIXME: We really want to get out of the tool chain level argument
2599 // translation business, as it makes the driver functionality much
2600 // more opaque. For now, we follow gcc closely solely for the
2601 // purpose of easily achieving feature parity & testability. Once we
2602 // have something that works, we should reevaluate each translation
2603 // and try to push it down into tool specific logic.
2604
2605 for (Arg *A : Args) {
2606 if (A->getOption().matches(options::OPT_Xarch__)) {
2607 // Skip this argument unless the architecture matches either the toolchain
2608 // triple arch, or the arch being bound.
2609 StringRef XarchArch = A->getValue(0);
2610 if (!(XarchArch == getArchName() ||
2611 (!BoundArch.empty() && XarchArch == BoundArch)))
2612 continue;
2613
2614 Arg *OriginalArg = A;
2615 TranslateXarchArgs(Args, A, DAL);
2616
2617 // Linker input arguments require custom handling. The problem is that we
2618 // have already constructed the phase actions, so we can not treat them as
2619 // "input arguments".
2620 if (A->getOption().hasFlag(options::LinkerInput)) {
2621 // Convert the argument into individual Zlinker_input_args.
2622 for (const char *Value : A->getValues()) {
2623 DAL->AddSeparateArg(
2624 OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
2625 }
2626 continue;
2627 }
2628 }
2629
2630 // Sob. These is strictly gcc compatible for the time being. Apple
2631 // gcc translates options twice, which means that self-expanding
2632 // options add duplicates.
2633 switch ((options::ID)A->getOption().getID()) {
2634 default:
2635 DAL->append(A);
2636 break;
2637
2638 case options::OPT_mkernel:
2639 case options::OPT_fapple_kext:
2640 DAL->append(A);
2641 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static));
2642 break;
2643
2644 case options::OPT_dependency_file:
2645 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue());
2646 break;
2647
2648 case options::OPT_gfull:
2649 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2650 DAL->AddFlagArg(
2651 A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols));
2652 break;
2653
2654 case options::OPT_gused:
2655 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag));
2656 DAL->AddFlagArg(
2657 A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols));
2658 break;
2659
2660 case options::OPT_shared:
2661 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib));
2662 break;
2663
2664 case options::OPT_fconstant_cfstrings:
2665 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings));
2666 break;
2667
2668 case options::OPT_fno_constant_cfstrings:
2669 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings));
2670 break;
2671
2672 case options::OPT_Wnonportable_cfstrings:
2673 DAL->AddFlagArg(A,
2674 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings));
2675 break;
2676
2677 case options::OPT_Wno_nonportable_cfstrings:
2678 DAL->AddFlagArg(
2679 A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings));
2680 break;
2681 }
2682 }
2683
2684 // Add the arch options based on the particular spelling of -arch, to match
2685 // how the driver works.
2686 if (!BoundArch.empty()) {
2687 StringRef Name = BoundArch;
2688 const Option MCpu = Opts.getOption(options::OPT_mcpu_EQ);
2689 const Option MArch = Opts.getOption(clang::driver::options::OPT_march_EQ);
2690
2691 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch,
2692 // which defines the list of which architectures we accept.
2693 if (Name == "ppc")
2694 ;
2695 else if (Name == "ppc601")
2696 DAL->AddJoinedArg(nullptr, MCpu, "601");
2697 else if (Name == "ppc603")
2698 DAL->AddJoinedArg(nullptr, MCpu, "603");
2699 else if (Name == "ppc604")
2700 DAL->AddJoinedArg(nullptr, MCpu, "604");
2701 else if (Name == "ppc604e")
2702 DAL->AddJoinedArg(nullptr, MCpu, "604e");
2703 else if (Name == "ppc750")
2704 DAL->AddJoinedArg(nullptr, MCpu, "750");
2705 else if (Name == "ppc7400")
2706 DAL->AddJoinedArg(nullptr, MCpu, "7400");
2707 else if (Name == "ppc7450")
2708 DAL->AddJoinedArg(nullptr, MCpu, "7450");
2709 else if (Name == "ppc970")
2710 DAL->AddJoinedArg(nullptr, MCpu, "970");
2711
2712 else if (Name == "ppc64" || Name == "ppc64le")
2713 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
2714
2715 else if (Name == "i386")
2716 ;
2717 else if (Name == "i486")
2718 DAL->AddJoinedArg(nullptr, MArch, "i486");
2719 else if (Name == "i586")
2720 DAL->AddJoinedArg(nullptr, MArch, "i586");
2721 else if (Name == "i686")
2722 DAL->AddJoinedArg(nullptr, MArch, "i686");
2723 else if (Name == "pentium")
2724 DAL->AddJoinedArg(nullptr, MArch, "pentium");
2725 else if (Name == "pentium2")
2726 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
2727 else if (Name == "pentpro")
2728 DAL->AddJoinedArg(nullptr, MArch, "pentiumpro");
2729 else if (Name == "pentIIm3")
2730 DAL->AddJoinedArg(nullptr, MArch, "pentium2");
2731
2732 else if (Name == "x86_64" || Name == "x86_64h")
2733 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_m64));
2734
2735 else if (Name == "arm")
2736 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
2737 else if (Name == "armv4t")
2738 DAL->AddJoinedArg(nullptr, MArch, "armv4t");
2739 else if (Name == "armv5")
2740 DAL->AddJoinedArg(nullptr, MArch, "armv5tej");
2741 else if (Name == "xscale")
2742 DAL->AddJoinedArg(nullptr, MArch, "xscale");
2743 else if (Name == "armv6")
2744 DAL->AddJoinedArg(nullptr, MArch, "armv6k");
2745 else if (Name == "armv6m")
2746 DAL->AddJoinedArg(nullptr, MArch, "armv6m");
2747 else if (Name == "armv7")
2748 DAL->AddJoinedArg(nullptr, MArch, "armv7a");
2749 else if (Name == "armv7em")
2750 DAL->AddJoinedArg(nullptr, MArch, "armv7em");
2751 else if (Name == "armv7k")
2752 DAL->AddJoinedArg(nullptr, MArch, "armv7k");
2753 else if (Name == "armv7m")
2754 DAL->AddJoinedArg(nullptr, MArch, "armv7m");
2755 else if (Name == "armv7s")
2756 DAL->AddJoinedArg(nullptr, MArch, "armv7s");
2757 }
2758
2759 return DAL;
2760}
2761
2762void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
2763 ArgStringList &CmdArgs,
2764 bool ForceLinkBuiltinRT) const {
2765 // Embedded targets are simple at the moment, not supporting sanitizers and
2766 // with different libraries for each member of the product { static, PIC } x
2767 // { hard-float, soft-float }
2768 llvm::SmallString<32> CompilerRT = StringRef("");
2769 CompilerRT +=
2771 ? "hard"
2772 : "soft";
2773 CompilerRT += Args.hasArg(options::OPT_fPIC) ? "_pic" : "_static";
2774
2775 AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, RLO_IsEmbedded);
2776}
2777
2779 llvm::Triple::OSType OS;
2780
2781 if (isTargetMacCatalyst())
2782 return TargetVersion < alignedAllocMinVersion(llvm::Triple::MacOSX);
2783 switch (TargetPlatform) {
2784 case MacOS: // Earlier than 10.13.
2785 OS = llvm::Triple::MacOSX;
2786 break;
2787 case IPhoneOS:
2788 OS = llvm::Triple::IOS;
2789 break;
2790 case TvOS: // Earlier than 11.0.
2791 OS = llvm::Triple::TvOS;
2792 break;
2793 case WatchOS: // Earlier than 4.0.
2794 OS = llvm::Triple::WatchOS;
2795 break;
2796 case DriverKit: // Always available.
2797 return false;
2798 }
2799
2801}
2802
2803void Darwin::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
2804 llvm::opt::ArgStringList &CC1Args,
2805 Action::OffloadKind DeviceOffloadKind) const {
2806 // Pass "-faligned-alloc-unavailable" only when the user hasn't manually
2807 // enabled or disabled aligned allocations.
2808 if (!DriverArgs.hasArgNoClaim(options::OPT_faligned_allocation,
2809 options::OPT_fno_aligned_allocation) &&
2811 CC1Args.push_back("-faligned-alloc-unavailable");
2812
2813 addClangCC1ASTargetOptions(DriverArgs, CC1Args);
2814
2815 // Enable compatibility mode for NSItemProviderCompletionHandler in
2816 // Foundation/NSItemProvider.h.
2817 CC1Args.push_back("-fcompatibility-qualified-id-block-type-checking");
2818
2819 // Give static local variables in inline functions hidden visibility when
2820 // -fvisibility-inlines-hidden is enabled.
2821 if (!DriverArgs.getLastArgNoClaim(
2822 options::OPT_fvisibility_inlines_hidden_static_local_var,
2823 options::OPT_fno_visibility_inlines_hidden_static_local_var))
2824 CC1Args.push_back("-fvisibility-inlines-hidden-static-local-var");
2825}
2826
2828 const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CC1ASArgs) const {
2829 if (TargetVariantTriple) {
2830 CC1ASArgs.push_back("-darwin-target-variant-triple");
2831 CC1ASArgs.push_back(Args.MakeArgString(TargetVariantTriple->getTriple()));
2832 }
2833
2834 if (SDKInfo) {
2835 /// Pass the SDK version to the compiler when the SDK information is
2836 /// available.
2837 auto EmitTargetSDKVersionArg = [&](const VersionTuple &V) {
2838 std::string Arg;
2839 llvm::raw_string_ostream OS(Arg);
2840 OS << "-target-sdk-version=" << V;
2841 CC1ASArgs.push_back(Args.MakeArgString(OS.str()));
2842 };
2843
2844 if (isTargetMacCatalyst()) {
2845 if (const auto *MacOStoMacCatalystMapping = SDKInfo->getVersionMapping(
2847 std::optional<VersionTuple> SDKVersion = MacOStoMacCatalystMapping->map(
2849 std::nullopt);
2850 EmitTargetSDKVersionArg(
2851 SDKVersion ? *SDKVersion : minimumMacCatalystDeploymentTarget());
2852 }
2853 } else {
2854 EmitTargetSDKVersionArg(SDKInfo->getVersion());
2855 }
2856
2857 /// Pass the target variant SDK version to the compiler when the SDK
2858 /// information is available and is required for target variant.
2859 if (TargetVariantTriple) {
2860 if (isTargetMacCatalyst()) {
2861 std::string Arg;
2862 llvm::raw_string_ostream OS(Arg);
2863 OS << "-darwin-target-variant-sdk-version=" << SDKInfo->getVersion();
2864 CC1ASArgs.push_back(Args.MakeArgString(OS.str()));
2865 } else if (const auto *MacOStoMacCatalystMapping =
2866 SDKInfo->getVersionMapping(
2868 if (std::optional<VersionTuple> SDKVersion =
2869 MacOStoMacCatalystMapping->map(
2871 std::nullopt)) {
2872 std::string Arg;
2873 llvm::raw_string_ostream OS(Arg);
2874 OS << "-darwin-target-variant-sdk-version=" << *SDKVersion;
2875 CC1ASArgs.push_back(Args.MakeArgString(OS.str()));
2876 }
2877 }
2878 }
2879 }
2880}
2881
2882DerivedArgList *
2883Darwin::TranslateArgs(const DerivedArgList &Args, StringRef BoundArch,
2884 Action::OffloadKind DeviceOffloadKind) const {
2885 // First get the generic Apple args, before moving onto Darwin-specific ones.
2886 DerivedArgList *DAL =
2887 MachO::TranslateArgs(Args, BoundArch, DeviceOffloadKind);
2888
2889 // If no architecture is bound, none of the translations here are relevant.
2890 if (BoundArch.empty())
2891 return DAL;
2892
2893 // Add an explicit version min argument for the deployment target. We do this
2894 // after argument translation because -Xarch_ arguments may add a version min
2895 // argument.
2896 AddDeploymentTarget(*DAL);
2897
2898 // For iOS 6, undo the translation to add -static for -mkernel/-fapple-kext.
2899 // FIXME: It would be far better to avoid inserting those -static arguments,
2900 // but we can't check the deployment target in the translation code until
2901 // it is set here.
2903 (isTargetIOSBased() && !isIPhoneOSVersionLT(6, 0))) {
2904 for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
2905 Arg *A = *it;
2906 ++it;
2907 if (A->getOption().getID() != options::OPT_mkernel &&
2908 A->getOption().getID() != options::OPT_fapple_kext)
2909 continue;
2910 assert(it != ie && "unexpected argument translation");
2911 A = *it;
2912 assert(A->getOption().getID() == options::OPT_static &&
2913 "missing expected -static argument");
2914 *it = nullptr;
2915 ++it;
2916 }
2917 }
2918
2919 auto Arch = tools::darwin::getArchTypeForMachOArchName(BoundArch);
2920 if ((Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb)) {
2921 if (Args.hasFlag(options::OPT_fomit_frame_pointer,
2922 options::OPT_fno_omit_frame_pointer, false))
2923 getDriver().Diag(clang::diag::warn_drv_unsupported_opt_for_target)
2924 << "-fomit-frame-pointer" << BoundArch;
2925 }
2926
2927 return DAL;
2928}
2929
2931 // Unwind tables are not emitted if -fno-exceptions is supplied (except when
2932 // targeting x86_64).
2933 if (getArch() == llvm::Triple::x86_64 ||
2934 (GetExceptionModel(Args) != llvm::ExceptionHandling::SjLj &&
2935 Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
2936 true)))
2937 return getArch() == llvm::Triple::aarch64 ? UnwindTableLevel::Synchronous
2939
2941}
2942
2944 if (const char *S = ::getenv("RC_DEBUG_OPTIONS"))
2945 return S[0] != '\0';
2946 return false;
2947}
2948
2950 if (const char *S = ::getenv("RC_DEBUG_PREFIX_MAP"))
2951 return S;
2952 return {};
2953}
2954
2955llvm::ExceptionHandling Darwin::GetExceptionModel(const ArgList &Args) const {
2956 // Darwin uses SjLj exceptions on ARM.
2957 if (getTriple().getArch() != llvm::Triple::arm &&
2958 getTriple().getArch() != llvm::Triple::thumb)
2959 return llvm::ExceptionHandling::None;
2960
2961 // Only watchOS uses the new DWARF/Compact unwinding method.
2962 llvm::Triple Triple(ComputeLLVMTriple(Args));
2963 if (Triple.isWatchABI())
2964 return llvm::ExceptionHandling::DwarfCFI;
2965
2966 return llvm::ExceptionHandling::SjLj;
2967}
2968
2970 assert(TargetInitialized && "Target not initialized!");
2972 return false;
2973 return true;
2974}
2975
2976bool MachO::isPICDefault() const { return true; }
2977
2978bool MachO::isPIEDefault(const llvm::opt::ArgList &Args) const { return false; }
2979
2981 return (getArch() == llvm::Triple::x86_64 ||
2982 getArch() == llvm::Triple::aarch64);
2983}
2984
2986 // Profiling instrumentation is only supported on x86.
2987 return getTriple().isX86();
2988}
2989
2990void Darwin::addMinVersionArgs(const ArgList &Args,
2991 ArgStringList &CmdArgs) const {
2992 VersionTuple TargetVersion = getTripleTargetVersion();
2993
2994 if (isTargetWatchOS())
2995 CmdArgs.push_back("-watchos_version_min");
2996 else if (isTargetWatchOSSimulator())
2997 CmdArgs.push_back("-watchos_simulator_version_min");
2998 else if (isTargetTvOS())
2999 CmdArgs.push_back("-tvos_version_min");
3000 else if (isTargetTvOSSimulator())
3001 CmdArgs.push_back("-tvos_simulator_version_min");
3002 else if (isTargetDriverKit())
3003 CmdArgs.push_back("-driverkit_version_min");
3004 else if (isTargetIOSSimulator())
3005 CmdArgs.push_back("-ios_simulator_version_min");
3006 else if (isTargetIOSBased())
3007 CmdArgs.push_back("-iphoneos_version_min");
3008 else if (isTargetMacCatalyst())
3009 CmdArgs.push_back("-maccatalyst_version_min");
3010 else {
3011 assert(isTargetMacOS() && "unexpected target");
3012 CmdArgs.push_back("-macosx_version_min");
3013 }
3014
3015 VersionTuple MinTgtVers = getEffectiveTriple().getMinimumSupportedOSVersion();
3016 if (!MinTgtVers.empty() && MinTgtVers > TargetVersion)
3017 TargetVersion = MinTgtVers;
3018 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
3019 if (TargetVariantTriple) {
3020 assert(isTargetMacOSBased() && "unexpected target");
3021 VersionTuple VariantTargetVersion;
3022 if (TargetVariantTriple->isMacOSX()) {
3023 CmdArgs.push_back("-macosx_version_min");
3024 TargetVariantTriple->getMacOSXVersion(VariantTargetVersion);
3025 } else {
3026 assert(TargetVariantTriple->isiOS() &&
3027 TargetVariantTriple->isMacCatalystEnvironment() &&
3028 "unexpected target variant triple");
3029 CmdArgs.push_back("-maccatalyst_version_min");
3030 VariantTargetVersion = TargetVariantTriple->getiOSVersion();
3031 }
3032 VersionTuple MinTgtVers =
3033 TargetVariantTriple->getMinimumSupportedOSVersion();
3034 if (MinTgtVers.getMajor() && MinTgtVers > VariantTargetVersion)
3035 VariantTargetVersion = MinTgtVers;
3036 CmdArgs.push_back(Args.MakeArgString(VariantTargetVersion.getAsString()));
3037 }
3038}
3039
3041 Darwin::DarwinEnvironmentKind Environment) {
3042 switch (Platform) {
3043 case Darwin::MacOS:
3044 return "macos";
3045 case Darwin::IPhoneOS:
3046 if (Environment == Darwin::MacCatalyst)
3047 return "mac catalyst";
3048 return "ios";
3049 case Darwin::TvOS:
3050 return "tvos";
3051 case Darwin::WatchOS:
3052 return "watchos";
3053 case Darwin::DriverKit:
3054 return "driverkit";
3055 }
3056 llvm_unreachable("invalid platform");
3057}
3058
3059void Darwin::addPlatformVersionArgs(const llvm::opt::ArgList &Args,
3060 llvm::opt::ArgStringList &CmdArgs) const {
3061 auto EmitPlatformVersionArg =
3062 [&](const VersionTuple &TV, Darwin::DarwinPlatformKind TargetPlatform,
3064 const llvm::Triple &TT) {
3065 // -platform_version <platform> <target_version> <sdk_version>
3066 // Both the target and SDK version support only up to 3 components.
3067 CmdArgs.push_back("-platform_version");
3068 std::string PlatformName =
3071 PlatformName += "-simulator";
3072 CmdArgs.push_back(Args.MakeArgString(PlatformName));
3073 VersionTuple TargetVersion = TV.withoutBuild();
3076 getTriple().getArchName() == "arm64e" &&
3077 TargetVersion.getMajor() < 14) {
3078 // arm64e slice is supported on iOS/tvOS 14+ only.
3079 TargetVersion = VersionTuple(14, 0);
3080 }
3081 VersionTuple MinTgtVers = TT.getMinimumSupportedOSVersion();
3082 if (!MinTgtVers.empty() && MinTgtVers > TargetVersion)
3083 TargetVersion = MinTgtVers;
3084 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
3085
3087 // Mac Catalyst programs must use the appropriate iOS SDK version
3088 // that corresponds to the macOS SDK version used for the compilation.
3089 std::optional<VersionTuple> iOSSDKVersion;
3090 if (SDKInfo) {
3091 if (const auto *MacOStoMacCatalystMapping =
3092 SDKInfo->getVersionMapping(
3094 iOSSDKVersion = MacOStoMacCatalystMapping->map(
3095 SDKInfo->getVersion().withoutBuild(),
3096 minimumMacCatalystDeploymentTarget(), std::nullopt);
3097 }
3098 }
3099 CmdArgs.push_back(Args.MakeArgString(
3100 (iOSSDKVersion ? *iOSSDKVersion
3102 .getAsString()));
3103 return;
3104 }
3105
3106 if (SDKInfo) {
3107 VersionTuple SDKVersion = SDKInfo->getVersion().withoutBuild();
3108 if (!SDKVersion.getMinor())
3109 SDKVersion = VersionTuple(SDKVersion.getMajor(), 0);
3110 CmdArgs.push_back(Args.MakeArgString(SDKVersion.getAsString()));
3111 } else {
3112 // Use an SDK version that's matching the deployment target if the SDK
3113 // version is missing. This is preferred over an empty SDK version
3114 // (0.0.0) as the system's runtime might expect the linked binary to
3115 // contain a valid SDK version in order for the binary to work
3116 // correctly. It's reasonable to use the deployment target version as
3117 // a proxy for the SDK version because older SDKs don't guarantee
3118 // support for deployment targets newer than the SDK versions, so that
3119 // rules out using some predetermined older SDK version, which leaves
3120 // the deployment target version as the only reasonable choice.
3121 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString()));
3122 }
3123 };
3124 EmitPlatformVersionArg(getTripleTargetVersion(), TargetPlatform,
3127 return;
3130 VersionTuple TargetVariantVersion;
3131 if (TargetVariantTriple->isMacOSX()) {
3132 TargetVariantTriple->getMacOSXVersion(TargetVariantVersion);
3133 Platform = Darwin::MacOS;
3134 Environment = Darwin::NativeEnvironment;
3135 } else {
3136 assert(TargetVariantTriple->isiOS() &&
3137 TargetVariantTriple->isMacCatalystEnvironment() &&
3138 "unexpected target variant triple");
3139 TargetVariantVersion = TargetVariantTriple->getiOSVersion();
3140 Platform = Darwin::IPhoneOS;
3141 Environment = Darwin::MacCatalyst;
3142 }
3143 EmitPlatformVersionArg(TargetVariantVersion, Platform, Environment,
3145}
3146
3147// Add additional link args for the -dynamiclib option.
3148static void addDynamicLibLinkArgs(const Darwin &D, const ArgList &Args,
3149 ArgStringList &CmdArgs) {
3150 // Derived from darwin_dylib1 spec.
3151 if (D.isTargetIPhoneOS()) {
3152 if (D.isIPhoneOSVersionLT(3, 1))
3153 CmdArgs.push_back("-ldylib1.o");
3154 return;
3155 }
3156
3157 if (!D.isTargetMacOS())
3158 return;
3159 if (D.isMacosxVersionLT(10, 5))
3160 CmdArgs.push_back("-ldylib1.o");
3161 else if (D.isMacosxVersionLT(10, 6))
3162 CmdArgs.push_back("-ldylib1.10.5.o");
3163}
3164
3165// Add additional link args for the -bundle option.
3166static void addBundleLinkArgs(const Darwin &D, const ArgList &Args,
3167 ArgStringList &CmdArgs) {
3168 if (Args.hasArg(options::OPT_static))
3169 return;
3170 // Derived from darwin_bundle1 spec.
3171 if ((D.isTargetIPhoneOS() && D.isIPhoneOSVersionLT(3, 1)) ||
3172 (D.isTargetMacOS() && D.isMacosxVersionLT(10, 6)))
3173 CmdArgs.push_back("-lbundle1.o");
3174}
3175
3176// Add additional link args for the -pg option.
3177static void addPgProfilingLinkArgs(const Darwin &D, const ArgList &Args,
3178 ArgStringList &CmdArgs) {
3179 if (D.isTargetMacOS() && D.isMacosxVersionLT(10, 9)) {
3180 if (Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_object) ||
3181 Args.hasArg(options::OPT_preload)) {
3182 CmdArgs.push_back("-lgcrt0.o");
3183 } else {
3184 CmdArgs.push_back("-lgcrt1.o");
3185
3186 // darwin_crt2 spec is empty.
3187 }
3188 // By default on OS X 10.8 and later, we don't link with a crt1.o
3189 // file and the linker knows to use _main as the entry point. But,
3190 // when compiling with -pg, we need to link with the gcrt1.o file,
3191 // so pass the -no_new_main option to tell the linker to use the
3192 // "start" symbol as the entry point.
3193 if (!D.isMacosxVersionLT(10, 8))
3194 CmdArgs.push_back("-no_new_main");
3195 } else {
3196 D.getDriver().Diag(diag::err_drv_clang_unsupported_opt_pg_darwin)
3197 << D.isTargetMacOSBased();
3198 }
3199}
3200
3201static void addDefaultCRTLinkArgs(const Darwin &D, const ArgList &Args,
3202 ArgStringList &CmdArgs) {
3203 // Derived from darwin_crt1 spec.
3204 if (D.isTargetIPhoneOS()) {
3205 if (D.getArch() == llvm::Triple::aarch64)
3206 ; // iOS does not need any crt1 files for arm64
3207 else if (D.isIPhoneOSVersionLT(3, 1))
3208 CmdArgs.push_back("-lcrt1.o");
3209 else if (D.isIPhoneOSVersionLT(6, 0))
3210 CmdArgs.push_back("-lcrt1.3.1.o");
3211 return;
3212 }
3213
3214 if (!D.isTargetMacOS())
3215 return;
3216 if (D.isMacosxVersionLT(10, 5))
3217 CmdArgs.push_back("-lcrt1.o");
3218 else if (D.isMacosxVersionLT(10, 6))
3219 CmdArgs.push_back("-lcrt1.10.5.o");
3220 else if (D.isMacosxVersionLT(10, 8))
3221 CmdArgs.push_back("-lcrt1.10.6.o");
3222 // darwin_crt2 spec is empty.
3223}
3224
3225void Darwin::addStartObjectFileArgs(const ArgList &Args,
3226 ArgStringList &CmdArgs) const {
3227 // Derived from startfile spec.
3228 if (Args.hasArg(options::OPT_dynamiclib))
3229 addDynamicLibLinkArgs(*this, Args, CmdArgs);
3230 else if (Args.hasArg(options::OPT_bundle))
3231 addBundleLinkArgs(*this, Args, CmdArgs);
3232 else if (Args.hasArg(options::OPT_pg) && SupportsProfiling())
3233 addPgProfilingLinkArgs(*this, Args, CmdArgs);
3234 else if (Args.hasArg(options::OPT_static) ||
3235 Args.hasArg(options::OPT_object) ||
3236 Args.hasArg(options::OPT_preload))
3237 CmdArgs.push_back("-lcrt0.o");
3238 else
3239 addDefaultCRTLinkArgs(*this, Args, CmdArgs);
3240
3241 if (isTargetMacOS() && Args.hasArg(options::OPT_shared_libgcc) &&
3242 isMacosxVersionLT(10, 5)) {
3243 const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
3244 CmdArgs.push_back(Str);
3245 }
3246}
3247
3251 return;
3252 getDriver().Diag(diag::err_arc_unsupported_on_toolchain);
3253}
3254
3256 const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
3257 const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64;
3259 Res |= SanitizerKind::Address;
3260 Res |= SanitizerKind::PointerCompare;
3261 Res |= SanitizerKind::PointerSubtract;
3262 Res |= SanitizerKind::Leak;
3263 Res |= SanitizerKind::Fuzzer;
3264 Res |= SanitizerKind::FuzzerNoLink;
3265 Res |= SanitizerKind::Function;
3266 Res |= SanitizerKind::ObjCCast;
3267
3268 // Prior to 10.9, macOS shipped a version of the C++ standard library without
3269 // C++11 support. The same is true of iOS prior to version 5. These OS'es are
3270 // incompatible with -fsanitize=vptr.
3271 if (!(isTargetMacOSBased() && isMacosxVersionLT(10, 9)) &&
3273 Res |= SanitizerKind::Vptr;
3274
3275 if ((IsX86_64 || IsAArch64) &&
3278 Res |= SanitizerKind::Thread;
3279 }
3280 return Res;
3281}
3282
3283void Darwin::printVerboseInfo(raw_ostream &OS) const {
3286}
#define V(N, I)
Definition: ASTContext.h:3217
StringRef P
Defines a function that returns the minimum OS versions supporting C++17's aligned allocation functio...
CudaArch arch
Definition: Cuda.cpp:70
static bool hasMultipleInvocations(const llvm::Triple &Triple, const ArgList &Args)
Definition: Clang.cpp:1386
static bool checkRemarksOptions(const Driver &D, const ArgList &Args, const llvm::Triple &Triple)
Definition: Clang.cpp:1397
static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, const llvm::Triple &Triple, const InputInfo &Input, const InputInfo &Output, const JobAction &JA)
Definition: Clang.cpp:1413
static void addPgProfilingLinkArgs(const Darwin &D, const ArgList &Args, ArgStringList &CmdArgs)
Definition: Darwin.cpp:3177
static const char * ArmMachOArchName(StringRef Arch)
Definition: Darwin.cpp:952
static bool shouldLinkerNotDedup(bool IsLinkerOnlyAction, const ArgList &Args)
Pass -no_deduplicate to ld64 under certain conditions:
Definition: Darwin.cpp:193
static bool hasExportSymbolDirective(const ArgList &Args)
Check if the link command contains a symbol export directive.
Definition: Darwin.cpp:1311
static void addDefaultCRTLinkArgs(const Darwin &D, const ArgList &Args, ArgStringList &CmdArgs)
Definition: Darwin.cpp:3201
static void addBundleLinkArgs(const Darwin &D, const ArgList &Args, ArgStringList &CmdArgs)
Definition: Darwin.cpp:3166
static VersionTuple minimumMacCatalystDeploymentTarget()
Definition: Darwin.cpp:37
static std::string getSystemOrSDKMacOSVersion(StringRef MacOSSDKVersion)
Returns the most appropriate macOS target version for the current process.
Definition: Darwin.cpp:1510
static void addDynamicLibLinkArgs(const Darwin &D, const ArgList &Args, ArgStringList &CmdArgs)
Definition: Darwin.cpp:3148
static void AppendPlatformPrefix(SmallString< 128 > &Path, const llvm::Triple &T)
Definition: Darwin.cpp:2310
static bool isObjCRuntimeLinked(const ArgList &Args)
Determine whether we are linking the ObjC runtime.
Definition: Darwin.cpp:448
static const char * getPlatformName(Darwin::DarwinPlatformKind Platform, Darwin::DarwinEnvironmentKind Environment)
Definition: Darwin.cpp:3040
static const char * ArmMachOArchNameCPU(StringRef CPU)
Definition: Darwin.cpp:969
static void addExportedSymbol(ArgStringList &CmdArgs, const char *Symbol)
Add an export directive for Symbol to the link command.
Definition: Darwin.cpp:1326
static StringRef getXcodeDeveloperPath(StringRef PathIntoXcode)
Take a path that speculatively points into Xcode and return the XCODE/Contents/Developer path if it i...
Definition: Darwin.cpp:1122
static void addSectalignToPage(const ArgList &Args, ArgStringList &CmdArgs, StringRef Segment, StringRef Section)
Add a sectalign directive for Segment and Section to the maximum expected page size for Darwin.
Definition: Darwin.cpp:1337
CompileCommand Cmd
llvm::raw_ostream & OS
Definition: Logger.cpp:24
Defines types useful for describing an Objective-C runtime.
The information about the darwin SDK that was used during this compilation.
Definition: DarwinSDKInfo.h:29
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:28
bool hasNativeARC() const
Does this runtime natively provide the ARC entrypoints?
Definition: ObjCRuntime.h:162
bool hasSubscripting() const
Does this runtime directly support the subscripting methods?
Definition: ObjCRuntime.h:298
@ MacOSX
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
Definition: ObjCRuntime.h:35
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Definition: ObjCRuntime.h:40
@ iOS
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
Definition: ObjCRuntime.h:45
@ WatchOS
'watchos' is a variant of iOS for Apple's watchOS.
Definition: ObjCRuntime.h:49
The base class of the type hierarchy.
Definition: Type.h:1566
Action - Represent an abstract compilation step to perform.
Definition: Action.h:47
types::ID getType() const
Definition: Action.h:148
ActionClass getKind() const
Definition: Action.h:147
ActionList & getInputs()
Definition: Action.h:150
Compilation - A set of tasks to perform for a single driver invocation.
Definition: Compilation.h:45
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Definition: Cuda.cpp:278
void print(raw_ostream &OS) const
Print information about the detected CUDA installation.
Definition: Cuda.cpp:319
Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like comma...
Definition: Driver.h:77
std::string SysRoot
sysroot, if present
Definition: Driver.h:183
std::string GetTemporaryDirectory(StringRef Prefix) const
GetTemporaryDirectory - Return the pathname of a temporary directory to use as part of compilation; t...
Definition: Driver.cpp:5986
DiagnosticBuilder Diag(unsigned DiagID) const
Definition: Driver.h:144
static bool GetReleaseVersion(StringRef Str, unsigned &Major, unsigned &Minor, unsigned &Micro, bool &HadExtra)
GetReleaseVersion - Parse (([0-9]+)(.
Definition: Driver.cpp:6293
const llvm::opt::OptTable & getOpts() const
Definition: Driver.h:388
LTOKind getLTOMode(bool IsOffload=false) const
Get the specific kind of LTO being performed.
Definition: Driver.h:704
std::string ResourceDir
The path to the compiler resource directory.
Definition: Driver.h:167
bool isUsingLTO(bool IsOffload=false) const
Returns true if we are performing any kind of LTO.
Definition: Driver.h:699
std::string GetTemporaryPath(StringRef Prefix, StringRef Suffix) const
GetTemporaryPath - Return the pathname of a temporary file to use as part of compilation; the file wi...
Definition: Driver.cpp:5975
std::string Dir
The path the driver executable was in, as invoked from the command line.
Definition: Driver.h:155
InputInfo - Wrapper for information about an input source.
Definition: InputInfo.h:22
const char * getFilename() const
Definition: InputInfo.h:83
bool isFilename() const
Definition: InputInfo.h:75
types::ID getType() const
Definition: InputInfo.h:77
void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
Definition: AMDGPU.cpp:493
void print(raw_ostream &OS) const
Print information about the detected ROCm installation.
Definition: AMDGPU.cpp:487
bool requiresMinimalRuntime() const
Definition: SanitizerArgs.h:97
ToolChain - Access to tools for a single platform.
Definition: ToolChain.h:91
static void addSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory to CC1 arguments.
Definition: ToolChain.cpp:969
static void addExternCSystemInclude(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, const Twine &Path)
Utility function to add a system include directory with extern "C" semantics to CC1 arguments.
Definition: ToolChain.cpp:984
std::string GetFilePath(const char *Name) const
Definition: ToolChain.cpp:660
static bool needsProfileRT(const llvm::opt::ArgList &Args)
needsProfileRT - returns true if instrumentation profile is on.
Definition: ToolChain.cpp:631
llvm::Triple::ArchType getArch() const
Definition: ToolChain.h:252
const Driver & getDriver() const
Definition: ToolChain.h:236
llvm::vfs::FileSystem & getVFS() const
Definition: ToolChain.cpp:127
static bool needsGCovInstrumentation(const llvm::opt::ArgList &Args)
Returns true if gcov instrumentation (-fprofile-arcs or –coverage) is on.
Definition: ToolChain.cpp:645
virtual std::string ComputeLLVMTriple(const llvm::opt::ArgList &Args, types::ID InputType=types::TY_INVALID) const
ComputeLLVMTriple - Return the LLVM target triple to use, after taking command line arguments into ac...
Definition: ToolChain.cpp:802
const XRayArgs & getXRayArgs() const
Definition: ToolChain.cpp:180
virtual bool SupportsEmbeddedBitcode() const
SupportsEmbeddedBitcode - Does this tool chain support embedded bitcode.
Definition: ToolChain.h:583
path_list & getProgramPaths()
Definition: ToolChain.h:281
bool hasEffectiveTriple() const
Definition: ToolChain.h:271
const llvm::Triple & getEffectiveTriple() const
Get the toolchain's effective clang triple.
Definition: ToolChain.h:266
const llvm::Triple & getTriple() const
Definition: ToolChain.h:238
virtual types::ID LookupTypeForExtension(StringRef Ext) const
LookupTypeForExtension - Return the default language type to use for the given extension.
Definition: ToolChain.cpp:747
virtual void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
Definition: ToolChain.cpp:1039
StringRef getDefaultUniversalArchName() const
Provide the default architecture name (as expected by -arch) for this toolchain.
Definition: ToolChain.cpp:296
SanitizerArgs getSanitizerArgs(const llvm::opt::ArgList &JobArgs) const
Definition: ToolChain.cpp:174
virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const
Definition: ToolChain.cpp:943
virtual Tool * getTool(Action::ActionClass AC) const
Definition: ToolChain.cpp:402
virtual SanitizerMask getSupportedSanitizers() const
Return sanitizers which are available in this toolchain.
Definition: ToolChain.cpp:1144
virtual void TranslateXarchArgs(const llvm::opt::DerivedArgList &Args, llvm::opt::Arg *&A, llvm::opt::DerivedArgList *DAL, SmallVectorImpl< llvm::opt::Arg * > *AllocatedArgs=nullptr) const
Append the argument following A to DAL assuming A is an Xarch argument.
Definition: ToolChain.cpp:1309
StringRef getArchName() const
Definition: ToolChain.h:253
Tool - Information on a specific compilation tool.
Definition: Tool.h:32
const ToolChain & getToolChain() const
Definition: Tool.h:52
bool needsXRayRt() const
Definition: XRayArgs.h:44
void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override
Add warning options that need to be passed to cc1 for this target.
Definition: Darwin.cpp:1100
void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add the clang cc1 arguments for system include paths.
Definition: Darwin.cpp:2333
void AddCCKextLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCCKextLibArgs - Add the system specific linker arguments to use for kernel extensions (Darwin-spec...
Definition: Darwin.cpp:2564
void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
AddCXXStdlibLibArgs - Add the system specific linker arguments to use for the given C++ standard libr...
Definition: Darwin.cpp:2517
void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, bool ForceLinkBuiltinRT=false) const override
Add the linker arguments to link the compiler runtime library.
Definition: Darwin.cpp:1403
RuntimeLibType GetRuntimeLibType(const llvm::opt::ArgList &Args) const override
Definition: Darwin.cpp:1391
DarwinClang(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: Darwin.cpp:1096
void AddLinkARCArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
Add the linker arguments to link the ARC runtime library.
Definition: Darwin.cpp:1131
void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set the include paths to use for...
Definition: Darwin.cpp:2412
unsigned GetDefaultDwarfVersion() const override
Definition: Darwin.cpp:1203
Darwin - The base Darwin tool chain.
Definition: Darwin.h:289
VersionTuple TargetVersion
The native OS version we are targeting.
Definition: Darwin.h:316
void printVerboseInfo(raw_ostream &OS) const override
Dispatch to the specific toolchain for verbose printing.
Definition: Darwin.cpp:3283
void addPlatformVersionArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
Definition: Darwin.cpp:3059
bool TargetInitialized
Whether the information on the target has been initialized.
Definition: Darwin.h:296
bool isIPhoneOSVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const
Definition: Darwin.h:475
bool SupportsEmbeddedBitcode() const override
SupportsEmbeddedBitcode - Does this tool chain support embedded bitcode.
Definition: Darwin.cpp:2969
void addProfileRTLibs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
Add any profiling runtime libraries that are needed.
Definition: Darwin.cpp:1344
Darwin(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Darwin - Darwin tool chain for i386 and x86_64.
Definition: Darwin.cpp:894
SanitizerMask getSupportedSanitizers() const override
Return sanitizers which are available in this toolchain.
Definition: Darwin.cpp:3255
void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args, Action::OffloadKind DeviceOffloadKind) const override
Add options that need to be passed to cc1 for this target.
Definition: Darwin.cpp:2803
std::string ComputeEffectiveClangTriple(const llvm::opt::ArgList &Args, types::ID InputType) const override
ComputeEffectiveClangTriple - Return the Clang triple to use for this target, which may take into acc...
Definition: Darwin.cpp:1041
void CheckObjCARC() const override
Complain if this tool chain doesn't support Objective-C ARC.
Definition: Darwin.cpp:3248
llvm::ExceptionHandling GetExceptionModel(const llvm::opt::ArgList &Args) const override
GetExceptionModel - Return the tool chain exception model.
Definition: Darwin.cpp:2955
std::optional< DarwinSDKInfo > SDKInfo
The information about the darwin SDK that was used.
Definition: Darwin.h:321
StringRef getPlatformFamily() const
Definition: Darwin.cpp:1259
void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add arguments to use system-specific CUDA includes.
Definition: Darwin.cpp:938
void AddHIPIncludeArgs(const llvm::opt::ArgList &DriverArgs, llvm::opt::ArgStringList &CC1Args) const override
Add arguments to use system-specific HIP includes.
Definition: Darwin.cpp:943
ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const override
Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
Definition: Darwin.cpp:916
bool hasBlocksRuntime() const override
Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2.
Definition: Darwin.cpp:927
bool isMacosxVersionLT(unsigned V0, unsigned V1=0, unsigned V2=0) const
Returns true if the minimum supported macOS version for the slice that's being built is less than the...
Definition: Darwin.h:485
RocmInstallationDetector RocmInstallation
Definition: Darwin.h:327
bool isTargetInitialized() const
Definition: Darwin.h:464
bool isTargetAppleSiliconMac() const
Definition: Darwin.h:459
static StringRef getSDKName(StringRef isysroot)
Definition: Darwin.cpp:1277
llvm::opt::DerivedArgList * TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch, Action::OffloadKind DeviceOffloadKind) const override
TranslateArgs - Create a new derived argument list for any argument translations this ToolChain may w...
Definition: Darwin.cpp:2883
bool isTargetTvOSSimulator() const
Definition: Darwin.h:415
void addClangCC1ASTargetOptions(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CC1ASArgs) const override
Add options that need to be passed to cc1as for this target.
Definition: Darwin.cpp:2827
void setTarget(DarwinPlatformKind Platform, DarwinEnvironmentKind Environment, unsigned Major, unsigned Minor, unsigned Micro, VersionTuple NativeTargetVersion) const
Definition: Darwin.h:367
bool isTargetMacCatalyst() const
Definition: Darwin.h:445
CXXStdlibType GetDefaultCXXStdlibType() const override
Definition: Darwin.cpp:910
bool isTargetWatchOSSimulator() const
Definition: Darwin.h:430
DarwinPlatformKind TargetPlatform
Definition: Darwin.h:312
StringRef getOSLibraryNameSuffix(bool IgnoreSim=false) const override
Definition: Darwin.cpp:1289
void addMinVersionArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
Definition: Darwin.cpp:2990
void addStartObjectFileArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const override
Definition: Darwin.cpp:3225
bool isTargetWatchOSBased() const
Definition: Darwin.h:435
std::optional< llvm::Triple > TargetVariantTriple
The target variant triple that was specified (if any).
Definition: Darwin.h:324
VersionTuple getTripleTargetVersion() const
The version of the OS that's used by the OS specified in the target triple.
Definition: Darwin.h:470
CudaInstallationDetector CudaInstallation
Definition: Darwin.h:326
bool isAlignedAllocationUnavailable() const
Return true if c++17 aligned allocation/deallocation functions are not implemented in the c++ standar...
Definition: Darwin.cpp:2778
bool isTargetIOSSimulator() const
Definition: Darwin.h:399
DarwinEnvironmentKind TargetEnvironment
Definition: Darwin.h:313
VersionTuple getLinkerVersion(const llvm::opt::ArgList &Args) const
Get the version of the linker known to be available for a particular compiler invocation (via the -ml...
Definition: Darwin.cpp:1016
Tool * buildLinker() const override
Definition: Darwin.cpp:1086
Tool * buildStaticLibTool() const override
Definition: Darwin.cpp:1088
bool isTargetIOSBased() const
Is the target either iOS or an iOS simulator?
Definition: Darwin.h:197
bool isPICDefault() const override
Test whether this toolchain defaults to PIC.
Definition: Darwin.cpp:2976
bool isPICDefaultForced() const override
Tests whether this toolchain forces its default for PIC, PIE or non-PIC.
Definition: Darwin.cpp:2980
llvm::ExceptionHandling GetExceptionModel(const llvm::opt::ArgList &Args) const override
GetExceptionModel - Return the tool chain exception model.
Definition: Darwin.h:274
Tool * getTool(Action::ActionClass AC) const override
Definition: Darwin.cpp:1067
types::ID LookupTypeForExtension(StringRef Ext) const override
LookupTypeForExtension - Return the default language type to use for the given extension.
Definition: Darwin.cpp:898
void AddLinkRuntimeLib(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, StringRef Component, RuntimeLinkOptions Opts=RuntimeLinkOptions(), bool IsShared=false) const
Add a runtime library to the list of items to link.
Definition: Darwin.cpp:1211
virtual void addMinVersionArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: Darwin.h:185
virtual void addPlatformVersionArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: Darwin.h:188
virtual StringRef getOSLibraryNameSuffix(bool IgnoreSim=false) const
Definition: Darwin.h:278
UnwindTableLevel getDefaultUnwindTableLevel(const llvm::opt::ArgList &Args) const override
How detailed should the unwind tables be by default.
Definition: Darwin.cpp:2930
bool HasNativeLLVMSupport() const override
HasNativeLTOLinker - Check whether the linker and related tools have native LLVM support.
Definition: Darwin.cpp:908
std::string GetGlobalDebugPathRemapping() const override
Add an additional -fdebug-prefix-map entry.
Definition: Darwin.cpp:2949
bool SupportsProfiling() const override
SupportsProfiling - Does this tool chain support -pg.
Definition: Darwin.cpp:2985
RuntimeLinkOptions
Options to control how a runtime library is linked.
Definition: Darwin.h:200
@ RLO_IsEmbedded
Use the embedded runtime from the macho_embedded directory.
Definition: Darwin.h:205
@ RLO_AddRPath
Emit rpaths for @executable_path as well as the resource directory.
Definition: Darwin.h:208
@ RLO_AlwaysLink
Link the library in even if it can't be found in the VFS.
Definition: Darwin.h:202
MachO(const Driver &D, const llvm::Triple &Triple, const llvm::opt::ArgList &Args)
Definition: Darwin.cpp:885
virtual void AddLinkRuntimeLibArgs(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, bool ForceLinkBuiltinRT=false) const
Add the linker arguments to link the compiler runtime library.
Definition: Darwin.cpp:2762
StringRef getMachOArchName(const llvm::opt::ArgList &Args) const
Get the "MachO" arch name for a particular compiler invocation.
Definition: Darwin.cpp:988
Tool * buildAssembler() const override
Definition: Darwin.cpp:1092
bool isPIEDefault(const llvm::opt::ArgList &Args) const override
Test whether this toolchain defaults to PIE.
Definition: Darwin.cpp:2978
llvm::opt::DerivedArgList * TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch, Action::OffloadKind DeviceOffloadKind) const override
TranslateArgs - Create a new derived argument list for any argument translations this ToolChain may w...
Definition: Darwin.cpp:2592
bool UseDwarfDebugFlags() const override
UseDwarfDebugFlags - Embed the compile options to clang into the Dwarf compile unit information.
Definition: Darwin.cpp:2943
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Darwin.cpp:92
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Darwin.cpp:840
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Darwin.cpp:527
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Darwin.cpp:817
const toolchains::MachO & getMachOToolChain() const
Definition: Darwin.h:40
void AddMachOArch(const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs) const
Definition: Darwin.cpp:162
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Darwin.cpp:769
void ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, const char *LinkingOutput) const override
ConstructJob - Construct jobs to perform the action JA, writing to Output and with Inputs,...
Definition: Darwin.cpp:861
FloatABI getARMFloatABI(const ToolChain &TC, const llvm::opt::ArgList &Args)
llvm::Triple::ArchType getArchTypeForMachOArchName(StringRef Str)
Definition: Darwin.cpp:41
void setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str)
Definition: Darwin.cpp:77
void addFortranRuntimeLibs(const ToolChain &TC, llvm::opt::ArgStringList &CmdArgs)
Adds Fortran runtime libraries to CmdArgs.
Definition: CommonArgs.cpp:876
llvm::opt::Arg * getLastProfileUseArg(const llvm::opt::ArgList &Args)
void addFortranRuntimeLibraryPath(const ToolChain &TC, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs)
Adds the path for the Fortran runtime libraries to CmdArgs.
llvm::StringRef getLTOParallelism(const llvm::opt::ArgList &Args, const Driver &D)
bool addOpenMPRuntime(llvm::opt::ArgStringList &CmdArgs, const ToolChain &TC, const llvm::opt::ArgList &Args, bool ForceStaticHostRuntime=false, bool IsOffloadingHost=false, bool GompNeedsRT=false)
Returns true, if an OpenMP runtime has been added.
void AddLinkerInputs(const ToolChain &TC, const InputInfoList &Inputs, const llvm::opt::ArgList &Args, llvm::opt::ArgStringList &CmdArgs, const JobAction &JA)
SmallString< 128 > getStatsFileName(const llvm::opt::ArgList &Args, const InputInfo &Output, const InputInfo &Input, const Driver &D)
Handles the -save-stats option and returns the filename to save statistics to.
bool isObjCAutoRefCount(const llvm::opt::ArgList &Args)
const char * getTypeTempSuffix(ID Id, bool CLMode=false)
getTypeTempSuffix - Return the suffix to use when creating a temp file of this type,...
Definition: Types.cpp:83
bool willEmitRemarks(const llvm::opt::ArgList &Args)
Expected< std::optional< DarwinSDKInfo > > parseDarwinSDKInfo(llvm::vfs::FileSystem &VFS, StringRef SDKRootPath)
Parse the SDK information from the SDKSettings.json file.
@ C
Languages that the frontend can parse and compile.
@ Result
The result type of a method or function.
llvm::VersionTuple alignedAllocMinVersion(llvm::Triple::OSType OS)
llvm::StringRef getAsString(SyncScope S)
Definition: SyncScope.h:55
#define false
Definition: stdbool.h:22
static constexpr OSEnvPair macCatalystToMacOSPair()
Returns the os-environment mapping pair that's used to represent the Mac Catalyst -> macOS version ma...
Definition: DarwinSDKInfo.h:56
static constexpr OSEnvPair macOStoMacCatalystPair()
Returns the os-environment mapping pair that's used to represent the macOS -> Mac Catalyst version ma...
Definition: DarwinSDKInfo.h:49
static constexpr ResponseFileSupport None()
Returns a ResponseFileSupport indicating that response files are not supported.
Definition: Job.h:78
static constexpr ResponseFileSupport AtFileUTF8()
Definition: Job.h:85