1	//===- Driver.cpp ---------------------------------------------------------===//
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 "Driver.h"
10	#include "Config.h"
11	#include "ICF.h"
12	#include "InputFiles.h"
13	#include "LTO.h"
14	#include "MarkLive.h"
15	#include "ObjC.h"
16	#include "OutputSection.h"
17	#include "OutputSegment.h"
18	#include "SectionPriorities.h"
19	#include "SymbolTable.h"
20	#include "Symbols.h"
21	#include "SyntheticSections.h"
22	#include "Target.h"
23	#include "UnwindInfoSection.h"
24	#include "Writer.h"
25
26	#include "lld/Common/Args.h"
27	#include "lld/Common/CommonLinkerContext.h"
28	#include "lld/Common/Driver.h"
29	#include "lld/Common/ErrorHandler.h"
30	#include "lld/Common/LLVM.h"
31	#include "lld/Common/Memory.h"
32	#include "lld/Common/Reproduce.h"
33	#include "lld/Common/Version.h"
34	#include "llvm/ADT/DenseSet.h"
35	#include "llvm/ADT/StringExtras.h"
36	#include "llvm/ADT/StringRef.h"
37	#include "llvm/BinaryFormat/MachO.h"
38	#include "llvm/BinaryFormat/Magic.h"
39	#include "llvm/Config/llvm-config.h"
40	#include "llvm/LTO/LTO.h"
41	#include "llvm/Object/Archive.h"
42	#include "llvm/Option/ArgList.h"
43	#include "llvm/Support/CommandLine.h"
44	#include "llvm/Support/FileSystem.h"
45	#include "llvm/Support/MemoryBuffer.h"
46	#include "llvm/Support/Parallel.h"
47	#include "llvm/Support/Path.h"
48	#include "llvm/Support/TarWriter.h"
49	#include "llvm/Support/TargetSelect.h"
50	#include "llvm/Support/TimeProfiler.h"
51	#include "llvm/TargetParser/Host.h"
52	#include "llvm/TextAPI/PackedVersion.h"
53
54	#include <algorithm>
55
56	using namespace llvm;
57	using namespace llvm::MachO;
58	using namespace llvm::object;
59	using namespace llvm::opt;
60	using namespace llvm::sys;
61	using namespace lld;
62	using namespace lld::macho;
63
64	std::unique_ptr<Configuration> macho::config;
65	std::unique_ptr<DependencyTracker> macho::depTracker;
66
67	static HeaderFileType getOutputType(const InputArgList &args) {
68	// TODO: -r, -dylinker, -preload...
69	Arg *outputArg = args.getLastArg(OPT_bundle, OPT_dylib, OPT_execute);
70	if (outputArg == nullptr)
71	return MH_EXECUTE;
72
73	switch (outputArg->getOption().getID()) {
74	case OPT_bundle:
75	return MH_BUNDLE;
76	case OPT_dylib:
77	return MH_DYLIB;
78	case OPT_execute:
79	return MH_EXECUTE;
80	default:
81	llvm_unreachable("internal error");
82	}
83	}
84
85	static DenseMap<CachedHashStringRef, StringRef> resolvedLibraries;
86	static std::optional<StringRef> findLibrary(StringRef name) {
87	CachedHashStringRef key(name);
88	auto entry = resolvedLibraries.find(Val: key);
89	if (entry != resolvedLibraries.end())
90	return entry->second;
91
92	auto doFind = [&] {
93	// Special case for Csu support files required for Mac OS X 10.7 and older
94	// (crt1.o)
95	if (name.ends_with(".o"))
96	return findPathCombination(name, config->librarySearchPaths, {""});
97	if (config->searchDylibsFirst) {
98	if (std::optional<StringRef> path =
99	findPathCombination("lib" + name, config->librarySearchPaths,
100	{".tbd", ".dylib", ".so"}))
101	return path;
102	return findPathCombination("lib" + name, config->librarySearchPaths,
103	{".a"});
104	}
105	return findPathCombination("lib" + name, config->librarySearchPaths,
106	{".tbd", ".dylib", ".so", ".a"});
107	};
108
109	std::optional<StringRef> path = doFind();
110	if (path)
111	resolvedLibraries[key] = *path;
112
113	return path;
114	}
115
116	static DenseMap<CachedHashStringRef, StringRef> resolvedFrameworks;
117	static std::optional<StringRef> findFramework(StringRef name) {
118	CachedHashStringRef key(name);
119	auto entry = resolvedFrameworks.find(Val: key);
120	if (entry != resolvedFrameworks.end())
121	return entry->second;
122
123	SmallString<260> symlink;
124	StringRef suffix;
125	std::tie(args&: name, args&: suffix) = name.split(Separator: ",");
126	for (StringRef dir : config->frameworkSearchPaths) {
127	symlink = dir;
128	path::append(path&: symlink, a: name + ".framework", b: name);
129
130	if (!suffix.empty()) {
131	// NOTE: we must resolve the symlink before trying the suffixes, because
132	// there are no symlinks for the suffixed paths.
133	SmallString<260> location;
134	if (!fs::real_path(path: symlink, output&: location)) {
135	// only append suffix if realpath() succeeds
136	Twine suffixed = location + suffix;
137	if (fs::exists(Path: suffixed))
138	return resolvedFrameworks[key] = saver().save(S: suffixed.str());
139	}
140	// Suffix lookup failed, fall through to the no-suffix case.
141	}
142
143	if (std::optional<StringRef> path = resolveDylibPath(path: symlink.str()))
144	return resolvedFrameworks[key] = *path;
145	}
146	return {};
147	}
148
149	static bool warnIfNotDirectory(StringRef option, StringRef path) {
150	if (!fs::exists(Path: path)) {
151	warn(msg: "directory not found for option -" + option + path);
152	return false;
153	} else if (!fs::is_directory(Path: path)) {
154	warn(msg: "option -" + option + path + " references a non-directory path");
155	return false;
156	}
157	return true;
158	}
159
160	static std::vector<StringRef>
161	getSearchPaths(unsigned optionCode, InputArgList &args,
162	const std::vector<StringRef> &roots,
163	const SmallVector<StringRef, 2> &systemPaths) {
164	std::vector<StringRef> paths;
165	StringRef optionLetter{optionCode == OPT_F ? "F" : "L"};
166	for (StringRef path : args::getStrings(args, id: optionCode)) {
167	// NOTE: only absolute paths are re-rooted to syslibroot(s)
168	bool found = false;
169	if (path::is_absolute(path, style: path::Style::posix)) {
170	for (StringRef root : roots) {
171	SmallString<261> buffer(root);
172	path::append(path&: buffer, a: path);
173	// Do not warn about paths that are computed via the syslib roots
174	if (fs::is_directory(Path: buffer)) {
175	paths.push_back(x: saver().save(S: buffer.str()));
176	found = true;
177	}
178	}
179	}
180	if (!found && warnIfNotDirectory(option: optionLetter, path))
181	paths.push_back(x: path);
182	}
183
184	// `-Z` suppresses the standard "system" search paths.
185	if (args.hasArg(OPT_Z))
186	return paths;
187
188	for (const StringRef &path : systemPaths) {
189	for (const StringRef &root : roots) {
190	SmallString<261> buffer(root);
191	path::append(path&: buffer, a: path);
192	if (fs::is_directory(Path: buffer))
193	paths.push_back(x: saver().save(S: buffer.str()));
194	}
195	}
196	return paths;
197	}
198
199	static std::vector<StringRef> getSystemLibraryRoots(InputArgList &args) {
200	std::vector<StringRef> roots;
201	for (const Arg *arg : args.filtered(OPT_syslibroot))
202	roots.push_back(arg->getValue());
203	// NOTE: the final `-syslibroot` being `/` will ignore all roots
204	if (!roots.empty() && roots.back() == "/")
205	roots.clear();
206	// NOTE: roots can never be empty - add an empty root to simplify the library
207	// and framework search path computation.
208	if (roots.empty())
209	roots.emplace_back(args: "");
210	return roots;
211	}
212
213	static std::vector<StringRef>
214	getLibrarySearchPaths(InputArgList &args, const std::vector<StringRef> &roots) {
215	return getSearchPaths(OPT_L, args, roots, {"/usr/lib", "/usr/local/lib"});
216	}
217
218	static std::vector<StringRef>
219	getFrameworkSearchPaths(InputArgList &args,
220	const std::vector<StringRef> &roots) {
221	return getSearchPaths(OPT_F, args, roots,
222	{"/Library/Frameworks", "/System/Library/Frameworks"});
223	}
224
225	static llvm::CachePruningPolicy getLTOCachePolicy(InputArgList &args) {
226	SmallString<128> ltoPolicy;
227	auto add = [&ltoPolicy](Twine val) {
228	if (!ltoPolicy.empty())
229	ltoPolicy += ":";
230	val.toVector(Out&: ltoPolicy);
231	};
232	for (const Arg *arg :
233	args.filtered(OPT_thinlto_cache_policy_eq, OPT_prune_interval_lto,
234	OPT_prune_after_lto, OPT_max_relative_cache_size_lto)) {
235	switch (arg->getOption().getID()) {
236	case OPT_thinlto_cache_policy_eq:
237	add(arg->getValue());
238	break;
239	case OPT_prune_interval_lto:
240	if (!strcmp("-1", arg->getValue()))
241	add("prune_interval=87600h"); // 10 years
242	else
243	add(Twine("prune_interval=") + arg->getValue() + "s");
244	break;
245	case OPT_prune_after_lto:
246	add(Twine("prune_after=") + arg->getValue() + "s");
247	break;
248	case OPT_max_relative_cache_size_lto:
249	add(Twine("cache_size=") + arg->getValue() + "%");
250	break;
251	}
252	}
253	return CHECK(parseCachePruningPolicy(ltoPolicy), "invalid LTO cache policy");
254	}
255
256	// What caused a given library to be loaded. Only relevant for archives.
257	// Note that this does not tell us *how* we should load the library, i.e.
258	// whether we should do it lazily or eagerly (AKA force loading). The "how" is
259	// decided within addFile().
260	enum class LoadType {
261	CommandLine, // Library was passed as a regular CLI argument
262	CommandLineForce, // Library was passed via `-force_load`
263	LCLinkerOption, // Library was passed via LC_LINKER_OPTIONS
264	};
265
266	struct ArchiveFileInfo {
267	ArchiveFile *file;
268	bool isCommandLineLoad;
269	};
270
271	static DenseMap<StringRef, ArchiveFileInfo> loadedArchives;
272
273	static InputFile *addFile(StringRef path, LoadType loadType,
274	bool isLazy = false, bool isExplicit = true,
275	bool isBundleLoader = false,
276	bool isForceHidden = false) {
277	std::optional<MemoryBufferRef> buffer = readFile(path);
278	if (!buffer)
279	return nullptr;
280	MemoryBufferRef mbref = *buffer;
281	InputFile *newFile = nullptr;
282
283	file_magic magic = identify_magic(magic: mbref.getBuffer());
284	switch (magic) {
285	case file_magic::archive: {
286	bool isCommandLineLoad = loadType != LoadType::LCLinkerOption;
287	// Avoid loading archives twice. If the archives are being force-loaded,
288	// loading them twice would create duplicate symbol errors. In the
289	// non-force-loading case, this is just a minor performance optimization.
290	// We don't take a reference to cachedFile here because the
291	// loadArchiveMember() call below may recursively call addFile() and
292	// invalidate this reference.
293	auto entry = loadedArchives.find(Val: path);
294
295	ArchiveFile *file;
296	if (entry == loadedArchives.end()) {
297	// No cached archive, we need to create a new one
298	std::unique_ptr<object::Archive> archive = CHECK(
299	object::Archive::create(mbref), path + ": failed to parse archive");
300
301	if (!archive->isEmpty() && !archive->hasSymbolTable())
302	error(msg: path + ": archive has no index; run ranlib to add one");
303	file = make<ArchiveFile>(args: std::move(archive), args&: isForceHidden);
304	} else {
305	file = entry->second.file;
306	// Command-line loads take precedence. If file is previously loaded via
307	// command line, or is loaded via LC_LINKER_OPTION and being loaded via
308	// LC_LINKER_OPTION again, using the cached archive is enough.
309	if (entry->second.isCommandLineLoad || !isCommandLineLoad)
310	return file;
311	}
312
313	bool isLCLinkerForceLoad = loadType == LoadType::LCLinkerOption &&
314	config->forceLoadSwift &&
315	path::filename(path).starts_with(Prefix: "libswift");
316	if ((isCommandLineLoad && config->allLoad) ||
317	loadType == LoadType::CommandLineForce || isLCLinkerForceLoad) {
318	if (readFile(path)) {
319	Error e = Error::success();
320	for (const object::Archive::Child &c : file->getArchive().children(Err&: e)) {
321	StringRef reason;
322	switch (loadType) {
323	case LoadType::LCLinkerOption:
324	reason = "LC_LINKER_OPTION";
325	break;
326	case LoadType::CommandLineForce:
327	reason = "-force_load";
328	break;
329	case LoadType::CommandLine:
330	reason = "-all_load";
331	break;
332	}
333	if (Error e = file->fetch(c, reason))
334	error(msg: toString(file) + ": " + reason +
335	" failed to load archive member: " + toString(E: std::move(e)));
336	}
337	if (e)
338	error(msg: toString(file) +
339	": Archive::children failed: " + toString(E: std::move(e)));
340	}
341	} else if (isCommandLineLoad && config->forceLoadObjC) {
342	for (const object::Archive::Symbol &sym : file->getArchive().symbols())
343	if (sym.getName().starts_with(Prefix: objc::symbol_names::klass))
344	file->fetch(sym);
345
346	// TODO: no need to look for ObjC sections for a given archive member if
347	// we already found that it contains an ObjC symbol.
348	if (readFile(path)) {
349	Error e = Error::success();
350	for (const object::Archive::Child &c : file->getArchive().children(Err&: e)) {
351	Expected<MemoryBufferRef> mb = c.getMemoryBufferRef();
352	if (!mb || !hasObjCSection(*mb))
353	continue;
354	if (Error e = file->fetch(c, reason: "-ObjC"))
355	error(msg: toString(file) + ": -ObjC failed to load archive member: " +
356	toString(E: std::move(e)));
357	}
358	if (e)
359	error(msg: toString(file) +
360	": Archive::children failed: " + toString(E: std::move(e)));
361	}
362	}
363
364	file->addLazySymbols();
365	loadedArchives[path] = ArchiveFileInfo{.file: file, .isCommandLineLoad: isCommandLineLoad};
366	newFile = file;
367	break;
368	}
369	case file_magic::macho_object:
370	newFile = make<ObjFile>(args&: mbref, args: getModTime(path), args: "", args&: isLazy);
371	break;
372	case file_magic::macho_dynamically_linked_shared_lib:
373	case file_magic::macho_dynamically_linked_shared_lib_stub:
374	case file_magic::tapi_file:
375	if (DylibFile *dylibFile =
376	loadDylib(mbref, umbrella: nullptr, /*isBundleLoader=*/false, explicitlyLinked: isExplicit))
377	newFile = dylibFile;
378	break;
379	case file_magic::bitcode:
380	newFile = make<BitcodeFile>(args&: mbref, args: "", args: 0, args&: isLazy);
381	break;
382	case file_magic::macho_executable:
383	case file_magic::macho_bundle:
384	// We only allow executable and bundle type here if it is used
385	// as a bundle loader.
386	if (!isBundleLoader)
387	error(msg: path + ": unhandled file type");
388	if (DylibFile *dylibFile = loadDylib(mbref, umbrella: nullptr, isBundleLoader))
389	newFile = dylibFile;
390	break;
391	default:
392	error(msg: path + ": unhandled file type");
393	}
394	if (newFile && !isa<DylibFile>(Val: newFile)) {
395	if ((isa<ObjFile>(Val: newFile) || isa<BitcodeFile>(Val: newFile)) && newFile->lazy &&
396	config->forceLoadObjC) {
397	for (Symbol *sym : newFile->symbols)
398	if (sym && sym->getName().starts_with(Prefix: objc::symbol_names::klass)) {
399	extract(file&: *newFile, reason: "-ObjC");
400	break;
401	}
402	if (newFile->lazy && hasObjCSection(mbref))
403	extract(file&: *newFile, reason: "-ObjC");
404	}
405
406	// printArchiveMemberLoad() prints both .a and .o names, so no need to
407	// print the .a name here. Similarly skip lazy files.
408	if (config->printEachFile && magic != file_magic::archive && !isLazy)
409	message(msg: toString(file: newFile));
410	inputFiles.insert(X: newFile);
411	}
412	return newFile;
413	}
414
415	static std::vector<StringRef> missingAutolinkWarnings;
416	static void addLibrary(StringRef name, bool isNeeded, bool isWeak,
417	bool isReexport, bool isHidden, bool isExplicit,
418	LoadType loadType) {
419	if (std::optional<StringRef> path = findLibrary(name)) {
420	if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
421	Val: addFile(path: *path, loadType, /*isLazy=*/false, isExplicit,
422	/*isBundleLoader=*/false, isForceHidden: isHidden))) {
423	if (isNeeded)
424	dylibFile->forceNeeded = true;
425	if (isWeak)
426	dylibFile->forceWeakImport = true;
427	if (isReexport) {
428	config->hasReexports = true;
429	dylibFile->reexport = true;
430	}
431	}
432	return;
433	}
434	if (loadType == LoadType::LCLinkerOption) {
435	missingAutolinkWarnings.push_back(
436	x: saver().save(S: "auto-linked library not found for -l" + name));
437	return;
438	}
439	error(msg: "library not found for -l" + name);
440	}
441
442	static DenseSet<StringRef> loadedObjectFrameworks;
443	static void addFramework(StringRef name, bool isNeeded, bool isWeak,
444	bool isReexport, bool isExplicit, LoadType loadType) {
445	if (std::optional<StringRef> path = findFramework(name)) {
446	if (loadedObjectFrameworks.contains(V: *path))
447	return;
448
449	InputFile *file =
450	addFile(path: *path, loadType, /*isLazy=*/false, isExplicit, isBundleLoader: false);
451	if (auto *dylibFile = dyn_cast_or_null<DylibFile>(Val: file)) {
452	if (isNeeded)
453	dylibFile->forceNeeded = true;
454	if (isWeak)
455	dylibFile->forceWeakImport = true;
456	if (isReexport) {
457	config->hasReexports = true;
458	dylibFile->reexport = true;
459	}
460	} else if (isa_and_nonnull<ObjFile>(Val: file) ||
461	isa_and_nonnull<BitcodeFile>(Val: file)) {
462	// Cache frameworks containing object or bitcode files to avoid duplicate
463	// symbols. Frameworks containing static archives are cached separately
464	// in addFile() to share caching with libraries, and frameworks
465	// containing dylibs should allow overwriting of attributes such as
466	// forceNeeded by subsequent loads
467	loadedObjectFrameworks.insert(V: *path);
468	}
469	return;
470	}
471	if (loadType == LoadType::LCLinkerOption) {
472	missingAutolinkWarnings.push_back(
473	x: saver().save(S: "auto-linked framework not found for -framework " + name));
474	return;
475	}
476	error(msg: "framework not found for -framework " + name);
477	}
478
479	// Parses LC_LINKER_OPTION contents, which can add additional command line
480	// flags. This directly parses the flags instead of using the standard argument
481	// parser to improve performance.
482	void macho::parseLCLinkerOption(
483	llvm::SmallVectorImpl<StringRef> &LCLinkerOptions, InputFile *f,
484	unsigned argc, StringRef data) {
485	if (config->ignoreAutoLink)
486	return;
487
488	SmallVector<StringRef, 4> argv;
489	size_t offset = 0;
490	for (unsigned i = 0; i < argc && offset < data.size(); ++i) {
491	argv.push_back(Elt: data.data() + offset);
492	offset += strlen(s: data.data() + offset) + 1;
493	}
494	if (argv.size() != argc || offset > data.size())
495	fatal(msg: toString(file: f) + ": invalid LC_LINKER_OPTION");
496
497	unsigned i = 0;
498	StringRef arg = argv[i];
499	if (arg.consume_front(Prefix: "-l")) {
500	if (config->ignoreAutoLinkOptions.contains(key: arg))
501	return;
502	} else if (arg == "-framework") {
503	StringRef name = argv[++i];
504	if (config->ignoreAutoLinkOptions.contains(key: name))
505	return;
506	} else {
507	error(msg: arg + " is not allowed in LC_LINKER_OPTION");
508	}
509
510	LCLinkerOptions.append(RHS: argv);
511	}
512
513	void macho::resolveLCLinkerOptions() {
514	while (!unprocessedLCLinkerOptions.empty()) {
515	SmallVector<StringRef> LCLinkerOptions(unprocessedLCLinkerOptions);
516	unprocessedLCLinkerOptions.clear();
517
518	for (unsigned i = 0; i < LCLinkerOptions.size(); ++i) {
519	StringRef arg = LCLinkerOptions[i];
520	if (arg.consume_front(Prefix: "-l")) {
521	assert(!config->ignoreAutoLinkOptions.contains(arg));
522	addLibrary(name: arg, /*isNeeded=*/false, /*isWeak=*/false,
523	/*isReexport=*/false, /*isHidden=*/false,
524	/*isExplicit=*/false, loadType: LoadType::LCLinkerOption);
525	} else if (arg == "-framework") {
526	StringRef name = LCLinkerOptions[++i];
527	assert(!config->ignoreAutoLinkOptions.contains(name));
528	addFramework(name, /*isNeeded=*/false, /*isWeak=*/false,
529	/*isReexport=*/false, /*isExplicit=*/false,
530	loadType: LoadType::LCLinkerOption);
531	} else {
532	error(msg: arg + " is not allowed in LC_LINKER_OPTION");
533	}
534	}
535	}
536	}
537
538	static void addFileList(StringRef path, bool isLazy) {
539	std::optional<MemoryBufferRef> buffer = readFile(path);
540	if (!buffer)
541	return;
542	MemoryBufferRef mbref = *buffer;
543	for (StringRef path : args::getLines(mb: mbref))
544	addFile(path: rerootPath(path), loadType: LoadType::CommandLine, isLazy);
545	}
546
547	// We expect sub-library names of the form "libfoo", which will match a dylib
548	// with a path of .*/libfoo.{dylib, tbd}.
549	// XXX ld64 seems to ignore the extension entirely when matching sub-libraries;
550	// I'm not sure what the use case for that is.
551	static bool markReexport(StringRef searchName, ArrayRef<StringRef> extensions) {
552	for (InputFile *file : inputFiles) {
553	if (auto *dylibFile = dyn_cast<DylibFile>(Val: file)) {
554	StringRef filename = path::filename(path: dylibFile->getName());
555	if (filename.consume_front(Prefix: searchName) &&
556	(filename.empty() || llvm::is_contained(Range&: extensions, Element: filename))) {
557	dylibFile->reexport = true;
558	return true;
559	}
560	}
561	}
562	return false;
563	}
564
565	// This function is called on startup. We need this for LTO since
566	// LTO calls LLVM functions to compile bitcode files to native code.
567	// Technically this can be delayed until we read bitcode files, but
568	// we don't bother to do lazily because the initialization is fast.
569	static void initLLVM() {
570	InitializeAllTargets();
571	InitializeAllTargetMCs();
572	InitializeAllAsmPrinters();
573	InitializeAllAsmParsers();
574	}
575
576	static bool compileBitcodeFiles() {
577	TimeTraceScope timeScope("LTO");
578	auto *lto = make<BitcodeCompiler>();
579	for (InputFile *file : inputFiles)
580	if (auto *bitcodeFile = dyn_cast<BitcodeFile>(Val: file))
581	if (!file->lazy)
582	lto->add(f&: *bitcodeFile);
583
584	std::vector<ObjFile *> compiled = lto->compile();
585	for (ObjFile *file : compiled)
586	inputFiles.insert(X: file);
587
588	return !compiled.empty();
589	}
590
591	// Replaces common symbols with defined symbols residing in __common sections.
592	// This function must be called after all symbol names are resolved (i.e. after
593	// all InputFiles have been loaded.) As a result, later operations won't see
594	// any CommonSymbols.
595	static void replaceCommonSymbols() {
596	TimeTraceScope timeScope("Replace common symbols");
597	ConcatOutputSection *osec = nullptr;
598	for (Symbol *sym : symtab->getSymbols()) {
599	auto *common = dyn_cast<CommonSymbol>(Val: sym);
600	if (common == nullptr)
601	continue;
602
603	// Casting to size_t will truncate large values on 32-bit architectures,
604	// but it's not really worth supporting the linking of 64-bit programs on
605	// 32-bit archs.
606	ArrayRef<uint8_t> data = {nullptr, static_cast<size_t>(common->size)};
607	// FIXME avoid creating one Section per symbol?
608	auto *section =
609	make<Section>(args: common->getFile(), args: segment_names::data,
610	args: section_names::common, args: S_ZEROFILL, /*addr=*/args: 0);
611	auto *isec = make<ConcatInputSection>(args&: *section, args&: data, args: common->align);
612	if (!osec)
613	osec = ConcatOutputSection::getOrCreateForInput(isec);
614	isec->parent = osec;
615	addInputSection(inputSection: isec);
616
617	// FIXME: CommonSymbol should store isReferencedDynamically, noDeadStrip
618	// and pass them on here.
619	replaceSymbol<Defined>(
620	s: sym, arg: sym->getName(), arg: common->getFile(), arg&: isec, /*value=*/arg: 0, arg: common->size,
621	/*isWeakDef=*/arg: false, /*isExternal=*/arg: true, arg: common->privateExtern,
622	/*includeInSymtab=*/arg: true, /*isReferencedDynamically=*/arg: false,
623	/*noDeadStrip=*/arg: false);
624	}
625	}
626
627	static void initializeSectionRenameMap() {
628	if (config->dataConst) {
629	SmallVector<StringRef> v{section_names::got,
630	section_names::authGot,
631	section_names::authPtr,
632	section_names::nonLazySymbolPtr,
633	section_names::const_,
634	section_names::cfString,
635	section_names::moduleInitFunc,
636	section_names::moduleTermFunc,
637	section_names::objcClassList,
638	section_names::objcNonLazyClassList,
639	section_names::objcCatList,
640	section_names::objcNonLazyCatList,
641	section_names::objcProtoList,
642	section_names::objCImageInfo};
643	for (StringRef s : v)
644	config->sectionRenameMap[{segment_names::data, s}] = {
645	segment_names::dataConst, s};
646	}
647	config->sectionRenameMap[{segment_names::text, section_names::staticInit}] = {
648	segment_names::text, section_names::text};
649	config->sectionRenameMap[{segment_names::import, section_names::pointers}] = {
650	config->dataConst ? segment_names::dataConst : segment_names::data,
651	section_names::nonLazySymbolPtr};
652	}
653
654	static inline char toLowerDash(char x) {
655	if (x >= 'A' && x <= 'Z')
656	return x - 'A' + 'a';
657	else if (x == ' ')
658	return '-';
659	return x;
660	}
661
662	static std::string lowerDash(StringRef s) {
663	return std::string(map_iterator(I: s.begin(), F: toLowerDash),
664	map_iterator(I: s.end(), F: toLowerDash));
665	}
666
667	struct PlatformVersion {
668	PlatformType platform = PLATFORM_UNKNOWN;
669	llvm::VersionTuple minimum;
670	llvm::VersionTuple sdk;
671	};
672
673	static PlatformVersion parsePlatformVersion(const Arg *arg) {
674	assert(arg->getOption().getID() == OPT_platform_version);
675	StringRef platformStr = arg->getValue(N: 0);
676	StringRef minVersionStr = arg->getValue(N: 1);
677	StringRef sdkVersionStr = arg->getValue(N: 2);
678
679	PlatformVersion platformVersion;
680
681	// TODO(compnerd) see if we can generate this case list via XMACROS
682	platformVersion.platform =
683	StringSwitch<PlatformType>(lowerDash(s: platformStr))
684	.Cases(S0: "macos", S1: "1", Value: PLATFORM_MACOS)
685	.Cases(S0: "ios", S1: "2", Value: PLATFORM_IOS)
686	.Cases(S0: "tvos", S1: "3", Value: PLATFORM_TVOS)
687	.Cases(S0: "watchos", S1: "4", Value: PLATFORM_WATCHOS)
688	.Cases(S0: "bridgeos", S1: "5", Value: PLATFORM_BRIDGEOS)
689	.Cases(S0: "mac-catalyst", S1: "6", Value: PLATFORM_MACCATALYST)
690	.Cases(S0: "ios-simulator", S1: "7", Value: PLATFORM_IOSSIMULATOR)
691	.Cases(S0: "tvos-simulator", S1: "8", Value: PLATFORM_TVOSSIMULATOR)
692	.Cases(S0: "watchos-simulator", S1: "9", Value: PLATFORM_WATCHOSSIMULATOR)
693	.Cases(S0: "driverkit", S1: "10", Value: PLATFORM_DRIVERKIT)
694	.Cases(S0: "xros", S1: "11", Value: PLATFORM_XROS)
695	.Cases(S0: "xros-simulator", S1: "12", Value: PLATFORM_XROS_SIMULATOR)
696	.Default(Value: PLATFORM_UNKNOWN);
697	if (platformVersion.platform == PLATFORM_UNKNOWN)
698	error(msg: Twine("malformed platform: ") + platformStr);
699	// TODO: check validity of version strings, which varies by platform
700	// NOTE: ld64 accepts version strings with 5 components
701	// llvm::VersionTuple accepts no more than 4 components
702	// Has Apple ever published version strings with 5 components?
703	if (platformVersion.minimum.tryParse(string: minVersionStr))
704	error(msg: Twine("malformed minimum version: ") + minVersionStr);
705	if (platformVersion.sdk.tryParse(string: sdkVersionStr))
706	error(msg: Twine("malformed sdk version: ") + sdkVersionStr);
707	return platformVersion;
708	}
709
710	// Has the side-effect of setting Config::platformInfo and
711	// potentially Config::secondaryPlatformInfo.
712	static void setPlatformVersions(StringRef archName, const ArgList &args) {
713	std::map<PlatformType, PlatformVersion> platformVersions;
714	const PlatformVersion *lastVersionInfo = nullptr;
715	for (const Arg *arg : args.filtered(Ids: OPT_platform_version)) {
716	PlatformVersion version = parsePlatformVersion(arg);
717
718	// For each platform, the last flag wins:
719	// `-platform_version macos 2 3 -platform_version macos 4 5` has the same
720	// effect as just passing `-platform_version macos 4 5`.
721	// FIXME: ld64 warns on multiple flags for one platform. Should we?
722	platformVersions[version.platform] = version;
723	lastVersionInfo = &platformVersions[version.platform];
724	}
725
726	if (platformVersions.empty()) {
727	error(msg: "must specify -platform_version");
728	return;
729	}
730	if (platformVersions.size() > 2) {
731	error(msg: "must specify -platform_version at most twice");
732	return;
733	}
734	if (platformVersions.size() == 2) {
735	bool isZipperedCatalyst = platformVersions.count(x: PLATFORM_MACOS) &&
736	platformVersions.count(x: PLATFORM_MACCATALYST);
737
738	if (!isZipperedCatalyst) {
739	error(msg: "lld supports writing zippered outputs only for "
740	"macos and mac-catalyst");
741	} else if (config->outputType != MH_DYLIB &&
742	config->outputType != MH_BUNDLE) {
743	error(msg: "writing zippered outputs only valid for -dylib and -bundle");
744	}
745
746	config->platformInfo = {
747	.target: MachO::Target(getArchitectureFromName(Name: archName), PLATFORM_MACOS,
748	platformVersions[PLATFORM_MACOS].minimum),
749	.sdk: platformVersions[PLATFORM_MACOS].sdk};
750	config->secondaryPlatformInfo = {
751	.target: MachO::Target(getArchitectureFromName(Name: archName), PLATFORM_MACCATALYST,
752	platformVersions[PLATFORM_MACCATALYST].minimum),
753	.sdk: platformVersions[PLATFORM_MACCATALYST].sdk};
754	return;
755	}
756
757	config->platformInfo = {.target: MachO::Target(getArchitectureFromName(Name: archName),
758	lastVersionInfo->platform,
759	lastVersionInfo->minimum),
760	.sdk: lastVersionInfo->sdk};
761	}
762
763	// Has the side-effect of setting Config::target.
764	static TargetInfo *createTargetInfo(InputArgList &args) {
765	StringRef archName = args.getLastArgValue(Id: OPT_arch);
766	if (archName.empty()) {
767	error(msg: "must specify -arch");
768	return nullptr;
769	}
770
771	setPlatformVersions(archName, args);
772	auto [cpuType, cpuSubtype] = getCPUTypeFromArchitecture(Arch: config->arch());
773	switch (cpuType) {
774	case CPU_TYPE_X86_64:
775	return createX86_64TargetInfo();
776	case CPU_TYPE_ARM64:
777	return createARM64TargetInfo();
778	case CPU_TYPE_ARM64_32:
779	return createARM64_32TargetInfo();
780	default:
781	error(msg: "missing or unsupported -arch " + archName);
782	return nullptr;
783	}
784	}
785
786	static UndefinedSymbolTreatment
787	getUndefinedSymbolTreatment(const ArgList &args) {
788	StringRef treatmentStr = args.getLastArgValue(Id: OPT_undefined);
789	auto treatment =
790	StringSwitch<UndefinedSymbolTreatment>(treatmentStr)
791	.Cases(S0: "error", S1: "", Value: UndefinedSymbolTreatment::error)
792	.Case(S: "warning", Value: UndefinedSymbolTreatment::warning)
793	.Case(S: "suppress", Value: UndefinedSymbolTreatment::suppress)
794	.Case(S: "dynamic_lookup", Value: UndefinedSymbolTreatment::dynamic_lookup)
795	.Default(Value: UndefinedSymbolTreatment::unknown);
796	if (treatment == UndefinedSymbolTreatment::unknown) {
797	warn(msg: Twine("unknown -undefined TREATMENT '") + treatmentStr +
798	"', defaulting to 'error'");
799	treatment = UndefinedSymbolTreatment::error;
800	} else if (config->namespaceKind == NamespaceKind::twolevel &&
801	(treatment == UndefinedSymbolTreatment::warning ||
802	treatment == UndefinedSymbolTreatment::suppress)) {
803	if (treatment == UndefinedSymbolTreatment::warning)
804	fatal(msg: "'-undefined warning' only valid with '-flat_namespace'");
805	else
806	fatal(msg: "'-undefined suppress' only valid with '-flat_namespace'");
807	treatment = UndefinedSymbolTreatment::error;
808	}
809	return treatment;
810	}
811
812	static ICFLevel getICFLevel(const ArgList &args) {
813	StringRef icfLevelStr = args.getLastArgValue(Id: OPT_icf_eq);
814	auto icfLevel = StringSwitch<ICFLevel>(icfLevelStr)
815	.Cases(S0: "none", S1: "", Value: ICFLevel::none)
816	.Case(S: "safe", Value: ICFLevel::safe)
817	.Case(S: "all", Value: ICFLevel::all)
818	.Default(Value: ICFLevel::unknown);
819	if (icfLevel == ICFLevel::unknown) {
820	warn(msg: Twine("unknown --icf=OPTION `") + icfLevelStr +
821	"', defaulting to `none'");
822	icfLevel = ICFLevel::none;
823	}
824	return icfLevel;
825	}
826
827	static ObjCStubsMode getObjCStubsMode(const ArgList &args) {
828	const Arg *arg = args.getLastArg(OPT_objc_stubs_fast, OPT_objc_stubs_small);
829	if (!arg)
830	return ObjCStubsMode::fast;
831
832	if (arg->getOption().getID() == OPT_objc_stubs_small) {
833	if (is_contained(Set: {AK_arm64e, AK_arm64}, Element: config->arch()))
834	return ObjCStubsMode::small;
835	else
836	warn(msg: "-objc_stubs_small is not yet implemented, defaulting to "
837	"-objc_stubs_fast");
838	}
839	return ObjCStubsMode::fast;
840	}
841
842	static void warnIfDeprecatedOption(const Option &opt) {
843	if (!opt.getGroup().isValid())
844	return;
845	if (opt.getGroup().getID() == OPT_grp_deprecated) {
846	warn(msg: "Option `" + opt.getPrefixedName() + "' is deprecated in ld64:");
847	warn(msg: opt.getHelpText());
848	}
849	}
850
851	static void warnIfUnimplementedOption(const Option &opt) {
852	if (!opt.getGroup().isValid() || !opt.hasFlag(Val: DriverFlag::HelpHidden))
853	return;
854	switch (opt.getGroup().getID()) {
855	case OPT_grp_deprecated:
856	// warn about deprecated options elsewhere
857	break;
858	case OPT_grp_undocumented:
859	warn(msg: "Option `" + opt.getPrefixedName() +
860	"' is undocumented. Should lld implement it?");
861	break;
862	case OPT_grp_obsolete:
863	warn(msg: "Option `" + opt.getPrefixedName() +
864	"' is obsolete. Please modernize your usage.");
865	break;
866	case OPT_grp_ignored:
867	warn(msg: "Option `" + opt.getPrefixedName() + "' is ignored.");
868	break;
869	case OPT_grp_ignored_silently:
870	break;
871	default:
872	warn(msg: "Option `" + opt.getPrefixedName() +
873	"' is not yet implemented. Stay tuned...");
874	break;
875	}
876	}
877
878	static const char *getReproduceOption(InputArgList &args) {
879	if (const Arg *arg = args.getLastArg(OPT_reproduce))
880	return arg->getValue();
881	return getenv(name: "LLD_REPRODUCE");
882	}
883
884	// Parse options of the form "old;new".
885	static std::pair<StringRef, StringRef> getOldNewOptions(opt::InputArgList &args,
886	unsigned id) {
887	auto *arg = args.getLastArg(Ids: id);
888	if (!arg)
889	return {"", ""};
890
891	StringRef s = arg->getValue();
892	std::pair<StringRef, StringRef> ret = s.split(Separator: ';');
893	if (ret.second.empty())
894	error(msg: arg->getSpelling() + " expects 'old;new' format, but got " + s);
895	return ret;
896	}
897
898	// Parse options of the form "old;new[;extra]".
899	static std::tuple<StringRef, StringRef, StringRef>
900	getOldNewOptionsExtra(opt::InputArgList &args, unsigned id) {
901	auto [oldDir, second] = getOldNewOptions(args, id);
902	auto [newDir, extraDir] = second.split(Separator: ';');
903	return {oldDir, newDir, extraDir};
904	}
905
906	static void parseClangOption(StringRef opt, const Twine &msg) {
907	std::string err;
908	raw_string_ostream os(err);
909
910	const char *argv[] = {"lld", opt.data()};
911	if (cl::ParseCommandLineOptions(argc: 2, argv, Overview: "", Errs: &os))
912	return;
913	os.flush();
914	error(msg: msg + ": " + StringRef(err).trim());
915	}
916
917	static uint32_t parseDylibVersion(const ArgList &args, unsigned id) {
918	const Arg *arg = args.getLastArg(Ids: id);
919	if (!arg)
920	return 0;
921
922	if (config->outputType != MH_DYLIB) {
923	error(msg: arg->getAsString(Args: args) + ": only valid with -dylib");
924	return 0;
925	}
926
927	PackedVersion version;
928	if (!version.parse32(Str: arg->getValue())) {
929	error(msg: arg->getAsString(Args: args) + ": malformed version");
930	return 0;
931	}
932
933	return version.rawValue();
934	}
935
936	static uint32_t parseProtection(StringRef protStr) {
937	uint32_t prot = 0;
938	for (char c : protStr) {
939	switch (c) {
940	case 'r':
941	prot |= VM_PROT_READ;
942	break;
943	case 'w':
944	prot |= VM_PROT_WRITE;
945	break;
946	case 'x':
947	prot |= VM_PROT_EXECUTE;
948	break;
949	case '-':
950	break;
951	default:
952	error(msg: "unknown -segprot letter '" + Twine(c) + "' in " + protStr);
953	return 0;
954	}
955	}
956	return prot;
957	}
958
959	static std::vector<SectionAlign> parseSectAlign(const opt::InputArgList &args) {
960	std::vector<SectionAlign> sectAligns;
961	for (const Arg *arg : args.filtered(OPT_sectalign)) {
962	StringRef segName = arg->getValue(0);
963	StringRef sectName = arg->getValue(1);
964	StringRef alignStr = arg->getValue(2);
965	alignStr.consume_front_insensitive("0x");
966	uint32_t align;
967	if (alignStr.getAsInteger(16, align)) {
968	error("-sectalign: failed to parse '" + StringRef(arg->getValue(2)) +
969	"' as number");
970	continue;
971	}
972	if (!isPowerOf2_32(align)) {
973	error("-sectalign: '" + StringRef(arg->getValue(2)) +
974	"' (in base 16) not a power of two");
975	continue;
976	}
977	sectAligns.push_back({segName, sectName, align});
978	}
979	return sectAligns;
980	}
981
982	PlatformType macho::removeSimulator(PlatformType platform) {
983	switch (platform) {
984	case PLATFORM_IOSSIMULATOR:
985	return PLATFORM_IOS;
986	case PLATFORM_TVOSSIMULATOR:
987	return PLATFORM_TVOS;
988	case PLATFORM_WATCHOSSIMULATOR:
989	return PLATFORM_WATCHOS;
990	case PLATFORM_XROS_SIMULATOR:
991	return PLATFORM_XROS;
992	default:
993	return platform;
994	}
995	}
996
997	static bool supportsNoPie() {
998	return !(config->arch() == AK_arm64 || config->arch() == AK_arm64e ||
999	config->arch() == AK_arm64_32);
1000	}
1001
1002	static bool shouldAdhocSignByDefault(Architecture arch, PlatformType platform) {
1003	if (arch != AK_arm64 && arch != AK_arm64e)
1004	return false;
1005
1006	return platform == PLATFORM_MACOS || platform == PLATFORM_IOSSIMULATOR ||
1007	platform == PLATFORM_TVOSSIMULATOR ||
1008	platform == PLATFORM_WATCHOSSIMULATOR ||
1009	platform == PLATFORM_XROS_SIMULATOR;
1010	}
1011
1012	static bool dataConstDefault(const InputArgList &args) {
1013	static const std::array<std::pair<PlatformType, VersionTuple>, 6> minVersion =
1014	{._M_elems: {{PLATFORM_MACOS, VersionTuple(10, 15)},
1015	{PLATFORM_IOS, VersionTuple(13, 0)},
1016	{PLATFORM_TVOS, VersionTuple(13, 0)},
1017	{PLATFORM_WATCHOS, VersionTuple(6, 0)},
1018	{PLATFORM_XROS, VersionTuple(1, 0)},
1019	{PLATFORM_BRIDGEOS, VersionTuple(4, 0)}}};
1020	PlatformType platform = removeSimulator(platform: config->platformInfo.target.Platform);
1021	auto it = llvm::find_if(Range: minVersion,
1022	P: [&](const auto &p) { return p.first == platform; });
1023	if (it != minVersion.end())
1024	if (config->platformInfo.target.MinDeployment < it->second)
1025	return false;
1026
1027	switch (config->outputType) {
1028	case MH_EXECUTE:
1029	return !(args.hasArg(OPT_no_pie) && supportsNoPie());
1030	case MH_BUNDLE:
1031	// FIXME: return false when -final_name ...
1032	// has prefix "/System/Library/UserEventPlugins/"
1033	// or matches "/usr/libexec/locationd" "/usr/libexec/terminusd"
1034	return true;
1035	case MH_DYLIB:
1036	return true;
1037	case MH_OBJECT:
1038	return false;
1039	default:
1040	llvm_unreachable(
1041	"unsupported output type for determining data-const default");
1042	}
1043	return false;
1044	}
1045
1046	static bool shouldEmitChainedFixups(const InputArgList &args) {
1047	const Arg *arg = args.getLastArg(OPT_fixup_chains, OPT_no_fixup_chains);
1048	if (arg && arg->getOption().matches(ID: OPT_no_fixup_chains))
1049	return false;
1050
1051	bool isRequested = arg != nullptr;
1052
1053	// Version numbers taken from the Xcode 13.3 release notes.
1054	static const std::array<std::pair<PlatformType, VersionTuple>, 5> minVersion =
1055	{._M_elems: {{PLATFORM_MACOS, VersionTuple(11, 0)},
1056	{PLATFORM_IOS, VersionTuple(13, 4)},
1057	{PLATFORM_TVOS, VersionTuple(14, 0)},
1058	{PLATFORM_WATCHOS, VersionTuple(7, 0)},
1059	{PLATFORM_XROS, VersionTuple(1, 0)}}};
1060	PlatformType platform = removeSimulator(platform: config->platformInfo.target.Platform);
1061	auto it = llvm::find_if(Range: minVersion,
1062	P: [&](const auto &p) { return p.first == platform; });
1063	if (it != minVersion.end() &&
1064	it->second > config->platformInfo.target.MinDeployment) {
1065	if (!isRequested)
1066	return false;
1067
1068	warn(msg: "-fixup_chains requires " + getPlatformName(Platform: config->platform()) + " " +
1069	it->second.getAsString() + ", which is newer than target minimum of " +
1070	config->platformInfo.target.MinDeployment.getAsString());
1071	}
1072
1073	if (!is_contained(Set: {AK_x86_64, AK_x86_64h, AK_arm64}, Element: config->arch())) {
1074	if (isRequested)
1075	error(msg: "-fixup_chains is only supported on x86_64 and arm64 targets");
1076	return false;
1077	}
1078
1079	if (!config->isPic) {
1080	if (isRequested)
1081	error(msg: "-fixup_chains is incompatible with -no_pie");
1082	return false;
1083	}
1084
1085	// TODO: Enable by default once stable.
1086	return isRequested;
1087	}
1088
1089	static bool shouldEmitRelativeMethodLists(const InputArgList &args) {
1090	const Arg *arg = args.getLastArg(OPT_objc_relative_method_lists,
1091	OPT_no_objc_relative_method_lists);
1092	if (arg && arg->getOption().getID() == OPT_objc_relative_method_lists)
1093	return true;
1094	if (arg && arg->getOption().getID() == OPT_no_objc_relative_method_lists)
1095	return false;
1096
1097	// TODO: If no flag is specified, don't default to false, but instead:
1098	// - default false on < ios14
1099	// - default true on >= ios14
1100	// For now, until this feature is confirmed stable, default to false if no
1101	// flag is explicitly specified
1102	return false;
1103	}
1104
1105	void SymbolPatterns::clear() {
1106	literals.clear();
1107	globs.clear();
1108	}
1109
1110	void SymbolPatterns::insert(StringRef symbolName) {
1111	if (symbolName.find_first_of(Chars: "*?[]") == StringRef::npos)
1112	literals.insert(V: CachedHashStringRef(symbolName));
1113	else if (Expected<GlobPattern> pattern = GlobPattern::create(Pat: symbolName))
1114	globs.emplace_back(args&: *pattern);
1115	else
1116	error(msg: "invalid symbol-name pattern: " + symbolName);
1117	}
1118
1119	bool SymbolPatterns::matchLiteral(StringRef symbolName) const {
1120	return literals.contains(V: CachedHashStringRef(symbolName));
1121	}
1122
1123	bool SymbolPatterns::matchGlob(StringRef symbolName) const {
1124	for (const GlobPattern &glob : globs)
1125	if (glob.match(S: symbolName))
1126	return true;
1127	return false;
1128	}
1129
1130	bool SymbolPatterns::match(StringRef symbolName) const {
1131	return matchLiteral(symbolName) || matchGlob(symbolName);
1132	}
1133
1134	static void parseSymbolPatternsFile(const Arg *arg,
1135	SymbolPatterns &symbolPatterns) {
1136	StringRef path = arg->getValue();
1137	std::optional<MemoryBufferRef> buffer = readFile(path);
1138	if (!buffer) {
1139	error(msg: "Could not read symbol file: " + path);
1140	return;
1141	}
1142	MemoryBufferRef mbref = *buffer;
1143	for (StringRef line : args::getLines(mb: mbref)) {
1144	line = line.take_until(F: [](char c) { return c == '#'; }).trim();
1145	if (!line.empty())
1146	symbolPatterns.insert(symbolName: line);
1147	}
1148	}
1149
1150	static void handleSymbolPatterns(InputArgList &args,
1151	SymbolPatterns &symbolPatterns,
1152	unsigned singleOptionCode,
1153	unsigned listFileOptionCode) {
1154	for (const Arg *arg : args.filtered(Ids: singleOptionCode))
1155	symbolPatterns.insert(symbolName: arg->getValue());
1156	for (const Arg *arg : args.filtered(Ids: listFileOptionCode))
1157	parseSymbolPatternsFile(arg, symbolPatterns);
1158	}
1159
1160	static void createFiles(const InputArgList &args) {
1161	TimeTraceScope timeScope("Load input files");
1162	// This loop should be reserved for options whose exact ordering matters.
1163	// Other options should be handled via filtered() and/or getLastArg().
1164	bool isLazy = false;
1165	for (const Arg *arg : args) {
1166	const Option &opt = arg->getOption();
1167	warnIfDeprecatedOption(opt);
1168	warnIfUnimplementedOption(opt);
1169
1170	switch (opt.getID()) {
1171	case OPT_INPUT:
1172	addFile(path: rerootPath(path: arg->getValue()), loadType: LoadType::CommandLine, isLazy);
1173	break;
1174	case OPT_needed_library:
1175	if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
1176	Val: addFile(path: rerootPath(path: arg->getValue()), loadType: LoadType::CommandLine)))
1177	dylibFile->forceNeeded = true;
1178	break;
1179	case OPT_reexport_library:
1180	if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
1181	Val: addFile(path: rerootPath(path: arg->getValue()), loadType: LoadType::CommandLine))) {
1182	config->hasReexports = true;
1183	dylibFile->reexport = true;
1184	}
1185	break;
1186	case OPT_weak_library:
1187	if (auto *dylibFile = dyn_cast_or_null<DylibFile>(
1188	Val: addFile(path: rerootPath(path: arg->getValue()), loadType: LoadType::CommandLine)))
1189	dylibFile->forceWeakImport = true;
1190	break;
1191	case OPT_filelist:
1192	addFileList(path: arg->getValue(), isLazy);
1193	break;
1194	case OPT_force_load:
1195	addFile(path: rerootPath(path: arg->getValue()), loadType: LoadType::CommandLineForce);
1196	break;
1197	case OPT_load_hidden:
1198	addFile(path: rerootPath(path: arg->getValue()), loadType: LoadType::CommandLine,
1199	/*isLazy=*/false, /*isExplicit=*/true, /*isBundleLoader=*/false,
1200	/*isForceHidden=*/true);
1201	break;
1202	case OPT_l:
1203	case OPT_needed_l:
1204	case OPT_reexport_l:
1205	case OPT_weak_l:
1206	case OPT_hidden_l:
1207	addLibrary(arg->getValue(), opt.getID() == OPT_needed_l,
1208	opt.getID() == OPT_weak_l, opt.getID() == OPT_reexport_l,
1209	opt.getID() == OPT_hidden_l,
1210	/*isExplicit=*/true, LoadType::CommandLine);
1211	break;
1212	case OPT_framework:
1213	case OPT_needed_framework:
1214	case OPT_reexport_framework:
1215	case OPT_weak_framework:
1216	addFramework(arg->getValue(), opt.getID() == OPT_needed_framework,
1217	opt.getID() == OPT_weak_framework,
1218	opt.getID() == OPT_reexport_framework, /*isExplicit=*/true,
1219	LoadType::CommandLine);
1220	break;
1221	case OPT_start_lib:
1222	if (isLazy)
1223	error(msg: "nested --start-lib");
1224	isLazy = true;
1225	break;
1226	case OPT_end_lib:
1227	if (!isLazy)
1228	error(msg: "stray --end-lib");
1229	isLazy = false;
1230	break;
1231	default:
1232	break;
1233	}
1234	}
1235	}
1236
1237	static void gatherInputSections() {
1238	TimeTraceScope timeScope("Gathering input sections");
1239	for (const InputFile *file : inputFiles) {
1240	for (const Section *section : file->sections) {
1241	// Compact unwind entries require special handling elsewhere. (In
1242	// contrast, EH frames are handled like regular ConcatInputSections.)
1243	if (section->name == section_names::compactUnwind)
1244	continue;
1245	for (const Subsection &subsection : section->subsections)
1246	addInputSection(inputSection: subsection.isec);
1247	}
1248	if (!file->objCImageInfo.empty())
1249	in.objCImageInfo->addFile(file);
1250	}
1251	}
1252
1253	static void foldIdenticalLiterals() {
1254	TimeTraceScope timeScope("Fold identical literals");
1255	// We always create a cStringSection, regardless of whether dedupLiterals is
1256	// true. If it isn't, we simply create a non-deduplicating CStringSection.
1257	// Either way, we must unconditionally finalize it here.
1258	in.cStringSection->finalizeContents();
1259	in.objcMethnameSection->finalizeContents();
1260	in.wordLiteralSection->finalizeContents();
1261	}
1262
1263	static void addSynthenticMethnames() {
1264	std::string &data = *make<std::string>();
1265	llvm::raw_string_ostream os(data);
1266	for (Symbol *sym : symtab->getSymbols())
1267	if (isa<Undefined>(Val: sym))
1268	if (ObjCStubsSection::isObjCStubSymbol(sym))
1269	os << ObjCStubsSection::getMethname(sym) << '\0';
1270
1271	if (data.empty())
1272	return;
1273
1274	const auto *buf = reinterpret_cast<const uint8_t *>(data.c_str());
1275	Section &section = *make<Section>(/*file=*/args: nullptr, args: segment_names::text,
1276	args: section_names::objcMethname,
1277	args: S_CSTRING_LITERALS, /*addr=*/args: 0);
1278
1279	auto *isec =
1280	make<CStringInputSection>(args&: section, args: ArrayRef<uint8_t>{buf, data.size()},
1281	/*align=*/args: 1, /*dedupLiterals=*/args: true);
1282	isec->splitIntoPieces();
1283	for (auto &piece : isec->pieces)
1284	piece.live = true;
1285	section.subsections.push_back(x: {.offset: 0, .isec: isec});
1286	in.objcMethnameSection->addInput(isec);
1287	in.objcMethnameSection->isec->markLive(off: 0);
1288	}
1289
1290	static void referenceStubBinder() {
1291	bool needsStubHelper = config->outputType == MH_DYLIB ||
1292	config->outputType == MH_EXECUTE ||
1293	config->outputType == MH_BUNDLE;
1294	if (!needsStubHelper || !symtab->find(name: "dyld_stub_binder"))
1295	return;
1296
1297	// dyld_stub_binder is used by dyld to resolve lazy bindings. This code here
1298	// adds a opportunistic reference to dyld_stub_binder if it happens to exist.
1299	// dyld_stub_binder is in libSystem.dylib, which is usually linked in. This
1300	// isn't needed for correctness, but the presence of that symbol suppresses
1301	// "no symbols" diagnostics from `nm`.
1302	// StubHelperSection::setUp() adds a reference and errors out if
1303	// dyld_stub_binder doesn't exist in case it is actually needed.
1304	symtab->addUndefined(name: "dyld_stub_binder", /*file=*/nullptr, /*isWeak=*/isWeakRef: false);
1305	}
1306
1307	static void createAliases() {
1308	for (const auto &pair : config->aliasedSymbols) {
1309	if (const auto &sym = symtab->find(name: pair.first)) {
1310	if (const auto &defined = dyn_cast<Defined>(Val: sym)) {
1311	symtab->aliasDefined(src: defined, target: pair.second, newFile: defined->getFile())
1312	->noDeadStrip = true;
1313	} else {
1314	error(msg: "TODO: support aliasing to symbols of kind " +
1315	Twine(sym->kind()));
1316	}
1317	} else {
1318	warn(msg: "undefined base symbol '" + pair.first + "' for alias '" +
1319	pair.second + "'\n");
1320	}
1321	}
1322
1323	for (const InputFile *file : inputFiles) {
1324	if (auto *objFile = dyn_cast<ObjFile>(Val: file)) {
1325	for (const AliasSymbol *alias : objFile->aliases) {
1326	if (const auto &aliased = symtab->find(name: alias->getAliasedName())) {
1327	if (const auto &defined = dyn_cast<Defined>(Val: aliased)) {
1328	symtab->aliasDefined(src: defined, target: alias->getName(), newFile: alias->getFile(),
1329	makePrivateExtern: alias->privateExtern);
1330	} else {
1331	// Common, dylib, and undefined symbols are all valid alias
1332	// referents (undefineds can become valid Defined symbols later on
1333	// in the link.)
1334	error(msg: "TODO: support aliasing to symbols of kind " +
1335	Twine(aliased->kind()));
1336	}
1337	} else {
1338	// This shouldn't happen since MC generates undefined symbols to
1339	// represent the alias referents. Thus we fatal() instead of just
1340	// warning here.
1341	fatal(msg: "unable to find alias referent " + alias->getAliasedName() +
1342	" for " + alias->getName());
1343	}
1344	}
1345	}
1346	}
1347	}
1348
1349	static void handleExplicitExports() {
1350	static constexpr int kMaxWarnings = 3;
1351	if (config->hasExplicitExports) {
1352	std::atomic<uint64_t> warningsCount{0};
1353	parallelForEach(R: symtab->getSymbols(), Fn: [&warningsCount](Symbol *sym) {
1354	if (auto *defined = dyn_cast<Defined>(Val: sym)) {
1355	if (config->exportedSymbols.match(symbolName: sym->getName())) {
1356	if (defined->privateExtern) {
1357	if (defined->weakDefCanBeHidden) {
1358	// weak_def_can_be_hidden symbols behave similarly to
1359	// private_extern symbols in most cases, except for when
1360	// it is explicitly exported.
1361	// The former can be exported but the latter cannot.
1362	defined->privateExtern = false;
1363	} else {
1364	// Only print the first 3 warnings verbosely, and
1365	// shorten the rest to avoid crowding logs.
1366	if (warningsCount.fetch_add(i: 1, m: std::memory_order_relaxed) <
1367	kMaxWarnings)
1368	warn(msg: "cannot export hidden symbol " + toString(*defined) +
1369	"\n>>> defined in " + toString(file: defined->getFile()));
1370	}
1371	}
1372	} else {
1373	defined->privateExtern = true;
1374	}
1375	} else if (auto *dysym = dyn_cast<DylibSymbol>(Val: sym)) {
1376	dysym->shouldReexport = config->exportedSymbols.match(symbolName: sym->getName());
1377	}
1378	});
1379	if (warningsCount > kMaxWarnings)
1380	warn(msg: "<... " + Twine(warningsCount - kMaxWarnings) +
1381	" more similar warnings...>");
1382	} else if (!config->unexportedSymbols.empty()) {
1383	parallelForEach(R: symtab->getSymbols(), Fn: [](Symbol *sym) {
1384	if (auto *defined = dyn_cast<Defined>(Val: sym))
1385	if (config->unexportedSymbols.match(symbolName: defined->getName()))
1386	defined->privateExtern = true;
1387	});
1388	}
1389	}
1390
1391	namespace lld {
1392	namespace macho {
1393	bool link(ArrayRef<const char *> argsArr, llvm::raw_ostream &stdoutOS,
1394	llvm::raw_ostream &stderrOS, bool exitEarly, bool disableOutput) {
1395	// This driver-specific context will be freed later by lldMain().
1396	auto *ctx = new CommonLinkerContext;
1397
1398	ctx->e.initialize(stdoutOS, stderrOS, exitEarly, disableOutput);
1399	ctx->e.cleanupCallback = []() {
1400	resolvedFrameworks.clear();
1401	resolvedLibraries.clear();
1402	cachedReads.clear();
1403	concatOutputSections.clear();
1404	inputFiles.clear();
1405	inputSections.clear();
1406	inputSectionsOrder = 0;
1407	loadedArchives.clear();
1408	loadedObjectFrameworks.clear();
1409	missingAutolinkWarnings.clear();
1410	syntheticSections.clear();
1411	thunkMap.clear();
1412	unprocessedLCLinkerOptions.clear();
1413	ObjCSelRefsHelper::cleanup();
1414
1415	firstTLVDataSection = nullptr;
1416	tar = nullptr;
1417	memset(s: &in, c: 0, n: sizeof(in));
1418
1419	resetLoadedDylibs();
1420	resetOutputSegments();
1421	resetWriter();
1422	InputFile::resetIdCount();
1423
1424	objc::doCleanup();
1425	};
1426
1427	ctx->e.logName = args::getFilenameWithoutExe(path: argsArr[0]);
1428
1429	MachOOptTable parser;
1430	InputArgList args = parser.parse(argv: argsArr.slice(N: 1));
1431
1432	ctx->e.errorLimitExceededMsg = "too many errors emitted, stopping now "
1433	"(use --error-limit=0 to see all errors)";
1434	ctx->e.errorLimit = args::getInteger(args, OPT_error_limit_eq, 20);
1435	ctx->e.verbose = args.hasArg(OPT_verbose);
1436
1437	if (args.hasArg(OPT_help_hidden)) {
1438	parser.printHelp(argv0: argsArr[0], /*showHidden=*/true);
1439	return true;
1440	}
1441	if (args.hasArg(OPT_help)) {
1442	parser.printHelp(argv0: argsArr[0], /*showHidden=*/false);
1443	return true;
1444	}
1445	if (args.hasArg(OPT_version)) {
1446	message(msg: getLLDVersion());
1447	return true;
1448	}
1449
1450	config = std::make_unique<Configuration>();
1451	symtab = std::make_unique<SymbolTable>();
1452	config->outputType = getOutputType(args);
1453	target = createTargetInfo(args);
1454	depTracker = std::make_unique<DependencyTracker>(
1455	args.getLastArgValue(OPT_dependency_info));
1456
1457	config->ltoo = args::getInteger(args, OPT_lto_O, 2);
1458	if (config->ltoo > 3)
1459	error(msg: "--lto-O: invalid optimization level: " + Twine(config->ltoo));
1460	unsigned ltoCgo =
1461	args::getInteger(args, OPT_lto_CGO, args::getCGOptLevel(config->ltoo));
1462	if (auto level = CodeGenOpt::getLevel(OL: ltoCgo))
1463	config->ltoCgo = *level;
1464	else
1465	error(msg: "--lto-CGO: invalid codegen optimization level: " + Twine(ltoCgo));
1466
1467	if (errorCount())
1468	return false;
1469
1470	if (args.hasArg(OPT_pagezero_size)) {
1471	uint64_t pagezeroSize = args::getHex(args, OPT_pagezero_size, 0);
1472
1473	// ld64 does something really weird. It attempts to realign the value to the
1474	// page size, but assumes the page size is 4K. This doesn't work with most
1475	// of Apple's ARM64 devices, which use a page size of 16K. This means that
1476	// it will first 4K align it by rounding down, then round up to 16K. This
1477	// probably only happened because no one using this arg with anything other
1478	// then 0, so no one checked if it did what is what it says it does.
1479
1480	// So we are not copying this weird behavior and doing the it in a logical
1481	// way, by always rounding down to page size.
1482	if (!isAligned(Lhs: Align(target->getPageSize()), SizeInBytes: pagezeroSize)) {
1483	pagezeroSize -= pagezeroSize % target->getPageSize();
1484	warn(msg: "__PAGEZERO size is not page aligned, rounding down to 0x" +
1485	Twine::utohexstr(Val: pagezeroSize));
1486	}
1487
1488	target->pageZeroSize = pagezeroSize;
1489	}
1490
1491	config->osoPrefix = args.getLastArgValue(OPT_oso_prefix);
1492	if (!config->osoPrefix.empty()) {
1493	// Expand special characters, such as ".", "..", or "~", if present.
1494	// Note: LD64 only expands "." and not other special characters.
1495	// That seems silly to imitate so we will not try to follow it, but rather
1496	// just use real_path() to do it.
1497
1498	// The max path length is 4096, in theory. However that seems quite long
1499	// and seems unlikely that any one would want to strip everything from the
1500	// path. Hence we've picked a reasonably large number here.
1501	SmallString<1024> expanded;
1502	if (!fs::real_path(path: config->osoPrefix, output&: expanded,
1503	/*expand_tilde=*/true)) {
1504	// Note: LD64 expands "." to be `<current_dir>/`
1505	// (ie., it has a slash suffix) whereas real_path() doesn't.
1506	// So we have to append '/' to be consistent.
1507	StringRef sep = sys::path::get_separator();
1508	// real_path removes trailing slashes as part of the normalization, but
1509	// these are meaningful for our text based stripping
1510	if (config->osoPrefix.equals(RHS: ".") || config->osoPrefix.ends_with(Suffix: sep))
1511	expanded += sep;
1512	config->osoPrefix = saver().save(S: expanded.str());
1513	}
1514	}
1515
1516	bool pie = args.hasFlag(OPT_pie, OPT_no_pie, true);
1517	if (!supportsNoPie() && !pie) {
1518	warn(msg: "-no_pie ignored for arm64");
1519	pie = true;
1520	}
1521
1522	config->isPic = config->outputType == MH_DYLIB ||
1523	config->outputType == MH_BUNDLE ||
1524	(config->outputType == MH_EXECUTE && pie);
1525
1526	// Must be set before any InputSections and Symbols are created.
1527	config->deadStrip = args.hasArg(OPT_dead_strip);
1528
1529	config->systemLibraryRoots = getSystemLibraryRoots(args);
1530	if (const char *path = getReproduceOption(args)) {
1531	// Note that --reproduce is a debug option so you can ignore it
1532	// if you are trying to understand the whole picture of the code.
1533	Expected<std::unique_ptr<TarWriter>> errOrWriter =
1534	TarWriter::create(OutputPath: path, BaseDir: path::stem(path));
1535	if (errOrWriter) {
1536	tar = std::move(*errOrWriter);
1537	tar->append(Path: "response.txt", Data: createResponseFile(args));
1538	tar->append(Path: "version.txt", Data: getLLDVersion() + "\n");
1539	} else {
1540	error(msg: "--reproduce: " + toString(E: errOrWriter.takeError()));
1541	}
1542	}
1543
1544	if (auto *arg = args.getLastArg(OPT_threads_eq)) {
1545	StringRef v(arg->getValue());
1546	unsigned threads = 0;
1547	if (!llvm::to_integer(S: v, Num&: threads, Base: 0) || threads == 0)
1548	error(arg->getSpelling() + ": expected a positive integer, but got '" +
1549	arg->getValue() + "'");
1550	parallel::strategy = hardware_concurrency(ThreadCount: threads);
1551	config->thinLTOJobs = v;
1552	}
1553	if (auto *arg = args.getLastArg(OPT_thinlto_jobs_eq))
1554	config->thinLTOJobs = arg->getValue();
1555	if (!get_threadpool_strategy(Num: config->thinLTOJobs))
1556	error(msg: "--thinlto-jobs: invalid job count: " + config->thinLTOJobs);
1557
1558	for (const Arg *arg : args.filtered(OPT_u)) {
1559	config->explicitUndefineds.push_back(symtab->addUndefined(
1560	arg->getValue(), /*file=*/nullptr, /*isWeakRef=*/false));
1561	}
1562
1563	for (const Arg *arg : args.filtered(OPT_U))
1564	config->explicitDynamicLookups.insert(arg->getValue());
1565
1566	config->mapFile = args.getLastArgValue(OPT_map);
1567	config->optimize = args::getInteger(args, OPT_O, 1);
1568	config->outputFile = args.getLastArgValue(OPT_o, "a.out");
1569	config->finalOutput =
1570	args.getLastArgValue(OPT_final_output, config->outputFile);
1571	config->astPaths = args.getAllArgValues(OPT_add_ast_path);
1572	config->headerPad = args::getHex(args, OPT_headerpad, /*Default=*/32);
1573	config->headerPadMaxInstallNames =
1574	args.hasArg(OPT_headerpad_max_install_names);
1575	config->printDylibSearch =
1576	args.hasArg(OPT_print_dylib_search) || getenv("RC_TRACE_DYLIB_SEARCHING");
1577	config->printEachFile = args.hasArg(OPT_t);
1578	config->printWhyLoad = args.hasArg(OPT_why_load);
1579	config->omitDebugInfo = args.hasArg(OPT_S);
1580	config->errorForArchMismatch = args.hasArg(OPT_arch_errors_fatal);
1581	if (const Arg *arg = args.getLastArg(OPT_bundle_loader)) {
1582	if (config->outputType != MH_BUNDLE)
1583	error(msg: "-bundle_loader can only be used with MachO bundle output");
1584	addFile(path: arg->getValue(), loadType: LoadType::CommandLine, /*isLazy=*/false,
1585	/*isExplicit=*/false, /*isBundleLoader=*/true);
1586	}
1587	for (auto *arg : args.filtered(OPT_dyld_env)) {
1588	StringRef envPair(arg->getValue());
1589	if (!envPair.contains('='))
1590	error("-dyld_env's argument is malformed. Expected "
1591	"-dyld_env <ENV_VAR>=<VALUE>, got `" +
1592	envPair + "`");
1593	config->dyldEnvs.push_back(envPair);
1594	}
1595	if (!config->dyldEnvs.empty() && config->outputType != MH_EXECUTE)
1596	error(msg: "-dyld_env can only be used when creating executable output");
1597
1598	if (const Arg *arg = args.getLastArg(OPT_umbrella)) {
1599	if (config->outputType != MH_DYLIB)
1600	warn(msg: "-umbrella used, but not creating dylib");
1601	config->umbrella = arg->getValue();
1602	}
1603	config->ltoObjPath = args.getLastArgValue(OPT_object_path_lto);
1604	config->thinLTOCacheDir = args.getLastArgValue(OPT_cache_path_lto);
1605	config->thinLTOCachePolicy = getLTOCachePolicy(args);
1606	config->thinLTOEmitImportsFiles = args.hasArg(OPT_thinlto_emit_imports_files);
1607	config->thinLTOEmitIndexFiles = args.hasArg(OPT_thinlto_emit_index_files) ||
1608	args.hasArg(OPT_thinlto_index_only) ||
1609	args.hasArg(OPT_thinlto_index_only_eq);
1610	config->thinLTOIndexOnly = args.hasArg(OPT_thinlto_index_only) ||
1611	args.hasArg(OPT_thinlto_index_only_eq);
1612	config->thinLTOIndexOnlyArg = args.getLastArgValue(OPT_thinlto_index_only_eq);
1613	config->thinLTOObjectSuffixReplace =
1614	getOldNewOptions(args, OPT_thinlto_object_suffix_replace_eq);
1615	std::tie(config->thinLTOPrefixReplaceOld, config->thinLTOPrefixReplaceNew,
1616	config->thinLTOPrefixReplaceNativeObject) =
1617	getOldNewOptionsExtra(args, OPT_thinlto_prefix_replace_eq);
1618	if (config->thinLTOEmitIndexFiles && !config->thinLTOIndexOnly) {
1619	if (args.hasArg(OPT_thinlto_object_suffix_replace_eq))
1620	error(msg: "--thinlto-object-suffix-replace is not supported with "
1621	"--thinlto-emit-index-files");
1622	else if (args.hasArg(OPT_thinlto_prefix_replace_eq))
1623	error(msg: "--thinlto-prefix-replace is not supported with "
1624	"--thinlto-emit-index-files");
1625	}
1626	if (!config->thinLTOPrefixReplaceNativeObject.empty() &&
1627	config->thinLTOIndexOnlyArg.empty()) {
1628	error(msg: "--thinlto-prefix-replace=old_dir;new_dir;obj_dir must be used with "
1629	"--thinlto-index-only=");
1630	}
1631	config->runtimePaths = args::getStrings(args, OPT_rpath);
1632	config->allLoad = args.hasFlag(OPT_all_load, OPT_noall_load, false);
1633	config->archMultiple = args.hasArg(OPT_arch_multiple);
1634	config->applicationExtension = args.hasFlag(
1635	OPT_application_extension, OPT_no_application_extension, false);
1636	config->exportDynamic = args.hasArg(OPT_export_dynamic);
1637	config->forceLoadObjC = args.hasArg(OPT_ObjC);
1638	config->forceLoadSwift = args.hasArg(OPT_force_load_swift_libs);
1639	config->deadStripDylibs = args.hasArg(OPT_dead_strip_dylibs);
1640	config->demangle = args.hasArg(OPT_demangle);
1641	config->implicitDylibs = !args.hasArg(OPT_no_implicit_dylibs);
1642	config->emitFunctionStarts =
1643	args.hasFlag(OPT_function_starts, OPT_no_function_starts, true);
1644	config->emitDataInCodeInfo =
1645	args.hasFlag(OPT_data_in_code_info, OPT_no_data_in_code_info, true);
1646	config->emitChainedFixups = shouldEmitChainedFixups(args);
1647	config->emitInitOffsets =
1648	config->emitChainedFixups || args.hasArg(OPT_init_offsets);
1649	config->emitRelativeMethodLists = shouldEmitRelativeMethodLists(args);
1650	config->icfLevel = getICFLevel(args);
1651	config->dedupStrings =
1652	args.hasFlag(OPT_deduplicate_strings, OPT_no_deduplicate_strings, true);
1653	config->deadStripDuplicates = args.hasArg(OPT_dead_strip_duplicates);
1654	config->warnDylibInstallName = args.hasFlag(
1655	OPT_warn_dylib_install_name, OPT_no_warn_dylib_install_name, false);
1656	config->ignoreOptimizationHints = args.hasArg(OPT_ignore_optimization_hints);
1657	config->callGraphProfileSort = args.hasFlag(
1658	OPT_call_graph_profile_sort, OPT_no_call_graph_profile_sort, true);
1659	config->printSymbolOrder = args.getLastArgValue(OPT_print_symbol_order_eq);
1660	config->forceExactCpuSubtypeMatch =
1661	getenv(name: "LD_DYLIB_CPU_SUBTYPES_MUST_MATCH");
1662	config->objcStubsMode = getObjCStubsMode(args);
1663	config->ignoreAutoLink = args.hasArg(OPT_ignore_auto_link);
1664	for (const Arg *arg : args.filtered(OPT_ignore_auto_link_option))
1665	config->ignoreAutoLinkOptions.insert(arg->getValue());
1666	config->strictAutoLink = args.hasArg(OPT_strict_auto_link);
1667	config->ltoDebugPassManager = args.hasArg(OPT_lto_debug_pass_manager);
1668	config->csProfileGenerate = args.hasArg(OPT_cs_profile_generate);
1669	config->csProfilePath = args.getLastArgValue(OPT_cs_profile_path);
1670	config->pgoWarnMismatch =
1671	args.hasFlag(OPT_pgo_warn_mismatch, OPT_no_pgo_warn_mismatch, true);
1672	config->generateUuid = !args.hasArg(OPT_no_uuid);
1673
1674	for (const Arg *arg : args.filtered(OPT_alias)) {
1675	config->aliasedSymbols.push_back(
1676	std::make_pair(arg->getValue(0), arg->getValue(1)));
1677	}
1678
1679	if (const char *zero = getenv(name: "ZERO_AR_DATE"))
1680	config->zeroModTime = strcmp(s1: zero, s2: "0") != 0;
1681	if (args.getLastArg(OPT_reproducible))
1682	config->zeroModTime = true;
1683
1684	std::array<PlatformType, 4> encryptablePlatforms{
1685	PLATFORM_IOS, PLATFORM_WATCHOS, PLATFORM_TVOS, PLATFORM_XROS};
1686	config->emitEncryptionInfo =
1687	args.hasFlag(OPT_encryptable, OPT_no_encryption,
1688	is_contained(encryptablePlatforms, config->platform()));
1689
1690	if (const Arg *arg = args.getLastArg(OPT_install_name)) {
1691	if (config->warnDylibInstallName && config->outputType != MH_DYLIB)
1692	warn(
1693	msg: arg->getAsString(Args: args) +
1694	": ignored, only has effect with -dylib [--warn-dylib-install-name]");
1695	else
1696	config->installName = arg->getValue();
1697	} else if (config->outputType == MH_DYLIB) {
1698	config->installName = config->finalOutput;
1699	}
1700
1701	if (args.hasArg(OPT_mark_dead_strippable_dylib)) {
1702	if (config->outputType != MH_DYLIB)
1703	warn(msg: "-mark_dead_strippable_dylib: ignored, only has effect with -dylib");
1704	else
1705	config->markDeadStrippableDylib = true;
1706	}
1707
1708	if (const Arg *arg = args.getLastArg(OPT_static, OPT_dynamic))
1709	config->staticLink = (arg->getOption().getID() == OPT_static);
1710
1711	if (const Arg *arg =
1712	args.getLastArg(OPT_flat_namespace, OPT_twolevel_namespace))
1713	config->namespaceKind = arg->getOption().getID() == OPT_twolevel_namespace
1714	? NamespaceKind::twolevel
1715	: NamespaceKind::flat;
1716
1717	config->undefinedSymbolTreatment = getUndefinedSymbolTreatment(args);
1718
1719	if (config->outputType == MH_EXECUTE)
1720	config->entry = symtab->addUndefined(args.getLastArgValue(OPT_e, "_main"),
1721	/*file=*/nullptr,
1722	/*isWeakRef=*/false);
1723
1724	config->librarySearchPaths =
1725	getLibrarySearchPaths(args, roots: config->systemLibraryRoots);
1726	config->frameworkSearchPaths =
1727	getFrameworkSearchPaths(args, roots: config->systemLibraryRoots);
1728	if (const Arg *arg =
1729	args.getLastArg(OPT_search_paths_first, OPT_search_dylibs_first))
1730	config->searchDylibsFirst =
1731	arg->getOption().getID() == OPT_search_dylibs_first;
1732
1733	config->dylibCompatibilityVersion =
1734	parseDylibVersion(args, OPT_compatibility_version);
1735	config->dylibCurrentVersion = parseDylibVersion(args, OPT_current_version);
1736
1737	config->dataConst =
1738	args.hasFlag(OPT_data_const, OPT_no_data_const, dataConstDefault(args));
1739	// Populate config->sectionRenameMap with builtin default renames.
1740	// Options -rename_section and -rename_segment are able to override.
1741	initializeSectionRenameMap();
1742	// Reject every special character except '.' and '$'
1743	// TODO(gkm): verify that this is the proper set of invalid chars
1744	StringRef invalidNameChars("!\"#%&'()*+,-/:;<=>?@[\\]^`{|}~");
1745	auto validName = [invalidNameChars](StringRef s) {
1746	if (s.find_first_of(Chars: invalidNameChars) != StringRef::npos)
1747	error(msg: "invalid name for segment or section: " + s);
1748	return s;
1749	};
1750	for (const Arg *arg : args.filtered(OPT_rename_section)) {
1751	config->sectionRenameMap[{validName(arg->getValue(0)),
1752	validName(arg->getValue(1))}] = {
1753	validName(arg->getValue(2)), validName(arg->getValue(3))};
1754	}
1755	for (const Arg *arg : args.filtered(OPT_rename_segment)) {
1756	config->segmentRenameMap[validName(arg->getValue(0))] =
1757	validName(arg->getValue(1));
1758	}
1759
1760	config->sectionAlignments = parseSectAlign(args);
1761
1762	for (const Arg *arg : args.filtered(OPT_segprot)) {
1763	StringRef segName = arg->getValue(0);
1764	uint32_t maxProt = parseProtection(arg->getValue(1));
1765	uint32_t initProt = parseProtection(arg->getValue(2));
1766	if (maxProt != initProt && config->arch() != AK_i386)
1767	error("invalid argument '" + arg->getAsString(args) +
1768	"': max and init must be the same for non-i386 archs");
1769	if (segName == segment_names::linkEdit)
1770	error("-segprot cannot be used to change __LINKEDIT's protections");
1771	config->segmentProtections.push_back({segName, maxProt, initProt});
1772	}
1773
1774	config->hasExplicitExports =
1775	args.hasArg(OPT_no_exported_symbols) ||
1776	args.hasArgNoClaim(OPT_exported_symbol, OPT_exported_symbols_list);
1777	handleSymbolPatterns(args, config->exportedSymbols, OPT_exported_symbol,
1778	OPT_exported_symbols_list);
1779	handleSymbolPatterns(args, config->unexportedSymbols, OPT_unexported_symbol,
1780	OPT_unexported_symbols_list);
1781	if (config->hasExplicitExports && !config->unexportedSymbols.empty())
1782	error(msg: "cannot use both -exported_symbol* and -unexported_symbol* options");
1783
1784	if (args.hasArg(OPT_no_exported_symbols) && !config->exportedSymbols.empty())
1785	error(msg: "cannot use both -exported_symbol* and -no_exported_symbols options");
1786
1787	// Imitating LD64's:
1788	// -non_global_symbols_no_strip_list and -non_global_symbols_strip_list can't
1789	// both be present.
1790	// But -x can be used with either of these two, in which case, the last arg
1791	// takes effect.
1792	// (TODO: This is kind of confusing - considering disallowing using them
1793	// together for a more straightforward behaviour)
1794	{
1795	bool includeLocal = false;
1796	bool excludeLocal = false;
1797	for (const Arg *arg :
1798	args.filtered(OPT_x, OPT_non_global_symbols_no_strip_list,
1799	OPT_non_global_symbols_strip_list)) {
1800	switch (arg->getOption().getID()) {
1801	case OPT_x:
1802	config->localSymbolsPresence = SymtabPresence::None;
1803	break;
1804	case OPT_non_global_symbols_no_strip_list:
1805	if (excludeLocal) {
1806	error("cannot use both -non_global_symbols_no_strip_list and "
1807	"-non_global_symbols_strip_list");
1808	} else {
1809	includeLocal = true;
1810	config->localSymbolsPresence = SymtabPresence::SelectivelyIncluded;
1811	parseSymbolPatternsFile(arg, config->localSymbolPatterns);
1812	}
1813	break;
1814	case OPT_non_global_symbols_strip_list:
1815	if (includeLocal) {
1816	error("cannot use both -non_global_symbols_no_strip_list and "
1817	"-non_global_symbols_strip_list");
1818	} else {
1819	excludeLocal = true;
1820	config->localSymbolsPresence = SymtabPresence::SelectivelyExcluded;
1821	parseSymbolPatternsFile(arg, config->localSymbolPatterns);
1822	}
1823	break;
1824	default:
1825	llvm_unreachable("unexpected option");
1826	}
1827	}
1828	}
1829	// Explicitly-exported literal symbols must be defined, but might
1830	// languish in an archive if unreferenced elsewhere or if they are in the
1831	// non-global strip list. Light a fire under those lazy symbols!
1832	for (const CachedHashStringRef &cachedName : config->exportedSymbols.literals)
1833	symtab->addUndefined(name: cachedName.val(), /*file=*/nullptr,
1834	/*isWeakRef=*/false);
1835
1836	for (const Arg *arg : args.filtered(OPT_why_live))
1837	config->whyLive.insert(arg->getValue());
1838	if (!config->whyLive.empty() && !config->deadStrip)
1839	warn(msg: "-why_live has no effect without -dead_strip, ignoring");
1840
1841	config->saveTemps = args.hasArg(OPT_save_temps);
1842
1843	config->adhocCodesign = args.hasFlag(
1844	OPT_adhoc_codesign, OPT_no_adhoc_codesign,
1845	shouldAdhocSignByDefault(config->arch(), config->platform()));
1846
1847	if (args.hasArg(OPT_v)) {
1848	message(msg: getLLDVersion(), s&: lld::errs());
1849	message(msg: StringRef("Library search paths:") +
1850	(config->librarySearchPaths.empty()
1851	? ""
1852	: "\n\t" + join(R&: config->librarySearchPaths, Separator: "\n\t")),
1853	s&: lld::errs());
1854	message(msg: StringRef("Framework search paths:") +
1855	(config->frameworkSearchPaths.empty()
1856	? ""
1857	: "\n\t" + join(R&: config->frameworkSearchPaths, Separator: "\n\t")),
1858	s&: lld::errs());
1859	}
1860
1861	config->progName = argsArr[0];
1862
1863	config->timeTraceEnabled = args.hasArg(OPT_time_trace_eq);
1864	config->timeTraceGranularity =
1865	args::getInteger(args, OPT_time_trace_granularity_eq, 500);
1866
1867	// Initialize time trace profiler.
1868	if (config->timeTraceEnabled)
1869	timeTraceProfilerInitialize(TimeTraceGranularity: config->timeTraceGranularity, ProcName: config->progName);
1870
1871	{
1872	TimeTraceScope timeScope("ExecuteLinker");
1873
1874	initLLVM(); // must be run before any call to addFile()
1875	createFiles(args);
1876
1877	// Now that all dylibs have been loaded, search for those that should be
1878	// re-exported.
1879	{
1880	auto reexportHandler = [](const Arg *arg,
1881	const std::vector<StringRef> &extensions) {
1882	config->hasReexports = true;
1883	StringRef searchName = arg->getValue();
1884	if (!markReexport(searchName, extensions))
1885	error(msg: arg->getSpelling() + " " + searchName +
1886	" does not match a supplied dylib");
1887	};
1888	std::vector<StringRef> extensions = {".tbd"};
1889	for (const Arg *arg : args.filtered(OPT_sub_umbrella))
1890	reexportHandler(arg, extensions);
1891
1892	extensions.push_back(x: ".dylib");
1893	for (const Arg *arg : args.filtered(OPT_sub_library))
1894	reexportHandler(arg, extensions);
1895	}
1896
1897	cl::ResetAllOptionOccurrences();
1898
1899	// Parse LTO options.
1900	if (const Arg *arg = args.getLastArg(OPT_mcpu))
1901	parseClangOption(opt: saver().save(S: "-mcpu=" + StringRef(arg->getValue())),
1902	msg: arg->getSpelling());
1903
1904	for (const Arg *arg : args.filtered(OPT_mllvm)) {
1905	parseClangOption(arg->getValue(), arg->getSpelling());
1906	config->mllvmOpts.emplace_back(arg->getValue());
1907	}
1908
1909	createSyntheticSections();
1910	createSyntheticSymbols();
1911	addSynthenticMethnames();
1912
1913	createAliases();
1914	// If we are in "explicit exports" mode, hide everything that isn't
1915	// explicitly exported. Do this before running LTO so that LTO can better
1916	// optimize.
1917	handleExplicitExports();
1918
1919	bool didCompileBitcodeFiles = compileBitcodeFiles();
1920
1921	resolveLCLinkerOptions();
1922
1923	// If --thinlto-index-only is given, we should create only "index
1924	// files" and not object files. Index file creation is already done
1925	// in compileBitcodeFiles, so we are done if that's the case.
1926	if (config->thinLTOIndexOnly)
1927	return errorCount() == 0;
1928
1929	// LTO may emit a non-hidden (extern) object file symbol even if the
1930	// corresponding bitcode symbol is hidden. In particular, this happens for
1931	// cross-module references to hidden symbols under ThinLTO. Thus, if we
1932	// compiled any bitcode files, we must redo the symbol hiding.
1933	if (didCompileBitcodeFiles)
1934	handleExplicitExports();
1935	replaceCommonSymbols();
1936
1937	StringRef orderFile = args.getLastArgValue(OPT_order_file);
1938	if (!orderFile.empty())
1939	priorityBuilder.parseOrderFile(path: orderFile);
1940
1941	referenceStubBinder();
1942
1943	// FIXME: should terminate the link early based on errors encountered so
1944	// far?
1945
1946	for (const Arg *arg : args.filtered(OPT_sectcreate)) {
1947	StringRef segName = arg->getValue(0);
1948	StringRef sectName = arg->getValue(1);
1949	StringRef fileName = arg->getValue(2);
1950	std::optional<MemoryBufferRef> buffer = readFile(fileName);
1951	if (buffer)
1952	inputFiles.insert(make<OpaqueFile>(*buffer, segName, sectName));
1953	}
1954
1955	for (const Arg *arg : args.filtered(OPT_add_empty_section)) {
1956	StringRef segName = arg->getValue(0);
1957	StringRef sectName = arg->getValue(1);
1958	inputFiles.insert(make<OpaqueFile>(MemoryBufferRef(), segName, sectName));
1959	}
1960
1961	gatherInputSections();
1962	if (config->callGraphProfileSort)
1963	priorityBuilder.extractCallGraphProfile();
1964
1965	if (config->deadStrip)
1966	markLive();
1967
1968	// Categories are not subject to dead-strip. The __objc_catlist section is
1969	// marked as NO_DEAD_STRIP and that propagates into all category data.
1970	if (args.hasArg(OPT_check_category_conflicts))
1971	objc::checkCategories();
1972
1973	// Category merging uses "->live = false" to erase old category data, so
1974	// it has to run after dead-stripping (markLive).
1975	if (args.hasArg(OPT_objc_category_merging, OPT_no_objc_category_merging))
1976	objc::mergeCategories();
1977
1978	// ICF assumes that all literals have been folded already, so we must run
1979	// foldIdenticalLiterals before foldIdenticalSections.
1980	foldIdenticalLiterals();
1981	if (config->icfLevel != ICFLevel::none) {
1982	if (config->icfLevel == ICFLevel::safe)
1983	markAddrSigSymbols();
1984	foldIdenticalSections(/*onlyCfStrings=*/false);
1985	} else if (config->dedupStrings) {
1986	foldIdenticalSections(/*onlyCfStrings=*/true);
1987	}
1988
1989	// Write to an output file.
1990	if (target->wordSize == 8)
1991	writeResult<LP64>();
1992	else
1993	writeResult<ILP32>();
1994
1995	depTracker->write(getLLDVersion(), inputFiles, config->outputFile);
1996	}
1997
1998	if (config->timeTraceEnabled) {
1999	checkError(timeTraceProfilerWrite(
2000	args.getLastArgValue(OPT_time_trace_eq).str(), config->outputFile));
2001
2002	timeTraceProfilerCleanup();
2003	}
2004
2005	if (errorCount() != 0 || config->strictAutoLink)
2006	for (const auto &warning : missingAutolinkWarnings)
2007	warn(msg: warning);
2008
2009	return errorCount() == 0;
2010	}
2011	} // namespace macho
2012	} // namespace lld
2013