|
150
|
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 "lld/Common/Driver.h"
|
|
|
10 #include "Config.h"
|
|
|
11 #include "InputChunks.h"
|
|
207
|
12 #include "InputElement.h"
|
|
150
|
13 #include "MarkLive.h"
|
|
|
14 #include "SymbolTable.h"
|
|
|
15 #include "Writer.h"
|
|
|
16 #include "lld/Common/Args.h"
|
|
|
17 #include "lld/Common/ErrorHandler.h"
|
|
173
|
18 #include "lld/Common/Filesystem.h"
|
|
150
|
19 #include "lld/Common/Memory.h"
|
|
|
20 #include "lld/Common/Reproduce.h"
|
|
|
21 #include "lld/Common/Strings.h"
|
|
|
22 #include "lld/Common/Version.h"
|
|
|
23 #include "llvm/ADT/Twine.h"
|
|
207
|
24 #include "llvm/Config/llvm-config.h"
|
|
150
|
25 #include "llvm/Object/Wasm.h"
|
|
|
26 #include "llvm/Option/Arg.h"
|
|
|
27 #include "llvm/Option/ArgList.h"
|
|
|
28 #include "llvm/Support/CommandLine.h"
|
|
173
|
29 #include "llvm/Support/Host.h"
|
|
|
30 #include "llvm/Support/Parallel.h"
|
|
150
|
31 #include "llvm/Support/Path.h"
|
|
|
32 #include "llvm/Support/Process.h"
|
|
|
33 #include "llvm/Support/TarWriter.h"
|
|
|
34 #include "llvm/Support/TargetSelect.h"
|
|
|
35
|
|
|
36 #define DEBUG_TYPE "lld"
|
|
|
37
|
|
|
38 using namespace llvm;
|
|
|
39 using namespace llvm::object;
|
|
|
40 using namespace llvm::sys;
|
|
|
41 using namespace llvm::wasm;
|
|
|
42
|
|
|
43 namespace lld {
|
|
|
44 namespace wasm {
|
|
|
45 Configuration *config;
|
|
|
46
|
|
|
47 namespace {
|
|
|
48
|
|
|
49 // Create enum with OPT_xxx values for each option in Options.td
|
|
|
50 enum {
|
|
|
51 OPT_INVALID = 0,
|
|
|
52 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
|
|
|
53 #include "Options.inc"
|
|
|
54 #undef OPTION
|
|
|
55 };
|
|
|
56
|
|
|
57 // This function is called on startup. We need this for LTO since
|
|
|
58 // LTO calls LLVM functions to compile bitcode files to native code.
|
|
|
59 // Technically this can be delayed until we read bitcode files, but
|
|
|
60 // we don't bother to do lazily because the initialization is fast.
|
|
|
61 static void initLLVM() {
|
|
|
62 InitializeAllTargets();
|
|
|
63 InitializeAllTargetMCs();
|
|
|
64 InitializeAllAsmPrinters();
|
|
|
65 InitializeAllAsmParsers();
|
|
|
66 }
|
|
|
67
|
|
|
68 class LinkerDriver {
|
|
|
69 public:
|
|
207
|
70 void linkerMain(ArrayRef<const char *> argsArr);
|
|
150
|
71
|
|
|
72 private:
|
|
|
73 void createFiles(opt::InputArgList &args);
|
|
|
74 void addFile(StringRef path);
|
|
|
75 void addLibrary(StringRef name);
|
|
|
76
|
|
|
77 // True if we are in --whole-archive and --no-whole-archive.
|
|
|
78 bool inWholeArchive = false;
|
|
|
79
|
|
|
80 std::vector<InputFile *> files;
|
|
|
81 };
|
|
|
82 } // anonymous namespace
|
|
|
83
|
|
|
84 bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &stdoutOS,
|
|
|
85 raw_ostream &stderrOS) {
|
|
|
86 lld::stdoutOS = &stdoutOS;
|
|
|
87 lld::stderrOS = &stderrOS;
|
|
|
88
|
|
207
|
89 errorHandler().cleanupCallback = []() { freeArena(); };
|
|
|
90
|
|
150
|
91 errorHandler().logName = args::getFilenameWithoutExe(args[0]);
|
|
|
92 errorHandler().errorLimitExceededMsg =
|
|
|
93 "too many errors emitted, stopping now (use "
|
|
|
94 "-error-limit=0 to see all errors)";
|
|
|
95 stderrOS.enable_colors(stderrOS.has_colors());
|
|
|
96
|
|
|
97 config = make<Configuration>();
|
|
|
98 symtab = make<SymbolTable>();
|
|
|
99
|
|
|
100 initLLVM();
|
|
207
|
101 LinkerDriver().linkerMain(args);
|
|
150
|
102
|
|
|
103 // Exit immediately if we don't need to return to the caller.
|
|
|
104 // This saves time because the overhead of calling destructors
|
|
|
105 // for all globally-allocated objects is not negligible.
|
|
|
106 if (canExitEarly)
|
|
|
107 exitLld(errorCount() ? 1 : 0);
|
|
|
108
|
|
|
109 return !errorCount();
|
|
|
110 }
|
|
|
111
|
|
|
112 // Create prefix string literals used in Options.td
|
|
|
113 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
|
|
|
114 #include "Options.inc"
|
|
|
115 #undef PREFIX
|
|
|
116
|
|
|
117 // Create table mapping all options defined in Options.td
|
|
|
118 static const opt::OptTable::Info optInfo[] = {
|
|
|
119 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \
|
|
|
120 {X1, X2, X10, X11, OPT_##ID, opt::Option::KIND##Class, \
|
|
|
121 X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12},
|
|
|
122 #include "Options.inc"
|
|
|
123 #undef OPTION
|
|
|
124 };
|
|
|
125
|
|
|
126 namespace {
|
|
|
127 class WasmOptTable : public llvm::opt::OptTable {
|
|
|
128 public:
|
|
|
129 WasmOptTable() : OptTable(optInfo) {}
|
|
|
130 opt::InputArgList parse(ArrayRef<const char *> argv);
|
|
|
131 };
|
|
|
132 } // namespace
|
|
|
133
|
|
|
134 // Set color diagnostics according to -color-diagnostics={auto,always,never}
|
|
|
135 // or -no-color-diagnostics flags.
|
|
|
136 static void handleColorDiagnostics(opt::InputArgList &args) {
|
|
|
137 auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
|
|
|
138 OPT_no_color_diagnostics);
|
|
|
139 if (!arg)
|
|
|
140 return;
|
|
|
141 if (arg->getOption().getID() == OPT_color_diagnostics) {
|
|
|
142 lld::errs().enable_colors(true);
|
|
|
143 } else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
|
|
|
144 lld::errs().enable_colors(false);
|
|
|
145 } else {
|
|
|
146 StringRef s = arg->getValue();
|
|
|
147 if (s == "always")
|
|
|
148 lld::errs().enable_colors(true);
|
|
|
149 else if (s == "never")
|
|
|
150 lld::errs().enable_colors(false);
|
|
|
151 else if (s != "auto")
|
|
|
152 error("unknown option: --color-diagnostics=" + s);
|
|
|
153 }
|
|
|
154 }
|
|
|
155
|
|
173
|
156 static cl::TokenizerCallback getQuotingStyle(opt::InputArgList &args) {
|
|
|
157 if (auto *arg = args.getLastArg(OPT_rsp_quoting)) {
|
|
|
158 StringRef s = arg->getValue();
|
|
|
159 if (s != "windows" && s != "posix")
|
|
|
160 error("invalid response file quoting: " + s);
|
|
|
161 if (s == "windows")
|
|
|
162 return cl::TokenizeWindowsCommandLine;
|
|
|
163 return cl::TokenizeGNUCommandLine;
|
|
|
164 }
|
|
|
165 if (Triple(sys::getProcessTriple()).isOSWindows())
|
|
|
166 return cl::TokenizeWindowsCommandLine;
|
|
|
167 return cl::TokenizeGNUCommandLine;
|
|
|
168 }
|
|
|
169
|
|
150
|
170 // Find a file by concatenating given paths.
|
|
|
171 static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
|
|
|
172 SmallString<128> s;
|
|
|
173 path::append(s, path1, path2);
|
|
|
174 if (fs::exists(s))
|
|
|
175 return std::string(s);
|
|
|
176 return None;
|
|
|
177 }
|
|
|
178
|
|
|
179 opt::InputArgList WasmOptTable::parse(ArrayRef<const char *> argv) {
|
|
|
180 SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size());
|
|
|
181
|
|
|
182 unsigned missingIndex;
|
|
|
183 unsigned missingCount;
|
|
|
184
|
|
173
|
185 // We need to get the quoting style for response files before parsing all
|
|
|
186 // options so we parse here before and ignore all the options but
|
|
|
187 // --rsp-quoting.
|
|
|
188 opt::InputArgList args = this->ParseArgs(vec, missingIndex, missingCount);
|
|
|
189
|
|
150
|
190 // Expand response files (arguments in the form of @<filename>)
|
|
173
|
191 // and then parse the argument again.
|
|
|
192 cl::ExpandResponseFiles(saver, getQuotingStyle(args), vec);
|
|
|
193 args = this->ParseArgs(vec, missingIndex, missingCount);
|
|
150
|
194
|
|
|
195 handleColorDiagnostics(args);
|
|
|
196 for (auto *arg : args.filtered(OPT_UNKNOWN))
|
|
|
197 error("unknown argument: " + arg->getAsString(args));
|
|
|
198 return args;
|
|
|
199 }
|
|
|
200
|
|
|
201 // Currently we allow a ".imports" to live alongside a library. This can
|
|
|
202 // be used to specify a list of symbols which can be undefined at link
|
|
|
203 // time (imported from the environment. For example libc.a include an
|
|
|
204 // import file that lists the syscall functions it relies on at runtime.
|
|
|
205 // In the long run this information would be better stored as a symbol
|
|
|
206 // attribute/flag in the object file itself.
|
|
|
207 // See: https://github.com/WebAssembly/tool-conventions/issues/35
|
|
|
208 static void readImportFile(StringRef filename) {
|
|
|
209 if (Optional<MemoryBufferRef> buf = readFile(filename))
|
|
|
210 for (StringRef sym : args::getLines(*buf))
|
|
|
211 config->allowUndefinedSymbols.insert(sym);
|
|
|
212 }
|
|
|
213
|
|
|
214 // Returns slices of MB by parsing MB as an archive file.
|
|
|
215 // Each slice consists of a member file in the archive.
|
|
|
216 std::vector<MemoryBufferRef> static getArchiveMembers(MemoryBufferRef mb) {
|
|
|
217 std::unique_ptr<Archive> file =
|
|
|
218 CHECK(Archive::create(mb),
|
|
|
219 mb.getBufferIdentifier() + ": failed to parse archive");
|
|
|
220
|
|
|
221 std::vector<MemoryBufferRef> v;
|
|
|
222 Error err = Error::success();
|
|
|
223 for (const Archive::Child &c : file->children(err)) {
|
|
|
224 MemoryBufferRef mbref =
|
|
|
225 CHECK(c.getMemoryBufferRef(),
|
|
|
226 mb.getBufferIdentifier() +
|
|
|
227 ": could not get the buffer for a child of the archive");
|
|
|
228 v.push_back(mbref);
|
|
|
229 }
|
|
|
230 if (err)
|
|
|
231 fatal(mb.getBufferIdentifier() +
|
|
|
232 ": Archive::children failed: " + toString(std::move(err)));
|
|
|
233
|
|
|
234 // Take ownership of memory buffers created for members of thin archives.
|
|
|
235 for (std::unique_ptr<MemoryBuffer> &mb : file->takeThinBuffers())
|
|
|
236 make<std::unique_ptr<MemoryBuffer>>(std::move(mb));
|
|
|
237
|
|
|
238 return v;
|
|
|
239 }
|
|
|
240
|
|
|
241 void LinkerDriver::addFile(StringRef path) {
|
|
|
242 Optional<MemoryBufferRef> buffer = readFile(path);
|
|
|
243 if (!buffer.hasValue())
|
|
|
244 return;
|
|
|
245 MemoryBufferRef mbref = *buffer;
|
|
|
246
|
|
|
247 switch (identify_magic(mbref.getBuffer())) {
|
|
|
248 case file_magic::archive: {
|
|
|
249 SmallString<128> importFile = path;
|
|
|
250 path::replace_extension(importFile, ".imports");
|
|
|
251 if (fs::exists(importFile))
|
|
|
252 readImportFile(importFile.str());
|
|
|
253
|
|
|
254 // Handle -whole-archive.
|
|
|
255 if (inWholeArchive) {
|
|
207
|
256 for (MemoryBufferRef &m : getArchiveMembers(mbref)) {
|
|
|
257 auto *object = createObjectFile(m, path);
|
|
|
258 // Mark object as live; object members are normally not
|
|
|
259 // live by default but -whole-archive is designed to treat
|
|
|
260 // them as such.
|
|
|
261 object->markLive();
|
|
|
262 files.push_back(object);
|
|
|
263 }
|
|
|
264
|
|
150
|
265 return;
|
|
|
266 }
|
|
|
267
|
|
|
268 std::unique_ptr<Archive> file =
|
|
|
269 CHECK(Archive::create(mbref), path + ": failed to parse archive");
|
|
|
270
|
|
|
271 if (!file->isEmpty() && !file->hasSymbolTable()) {
|
|
|
272 error(mbref.getBufferIdentifier() +
|
|
|
273 ": archive has no index; run ranlib to add one");
|
|
|
274 }
|
|
|
275
|
|
|
276 files.push_back(make<ArchiveFile>(mbref));
|
|
|
277 return;
|
|
|
278 }
|
|
|
279 case file_magic::bitcode:
|
|
|
280 case file_magic::wasm_object:
|
|
|
281 files.push_back(createObjectFile(mbref));
|
|
|
282 break;
|
|
|
283 default:
|
|
|
284 error("unknown file type: " + mbref.getBufferIdentifier());
|
|
|
285 }
|
|
|
286 }
|
|
|
287
|
|
|
288 // Add a given library by searching it from input search paths.
|
|
|
289 void LinkerDriver::addLibrary(StringRef name) {
|
|
|
290 for (StringRef dir : config->searchPaths) {
|
|
|
291 if (Optional<std::string> s = findFile(dir, "lib" + name + ".a")) {
|
|
|
292 addFile(*s);
|
|
|
293 return;
|
|
|
294 }
|
|
|
295 }
|
|
|
296
|
|
|
297 error("unable to find library -l" + name);
|
|
|
298 }
|
|
|
299
|
|
|
300 void LinkerDriver::createFiles(opt::InputArgList &args) {
|
|
|
301 for (auto *arg : args) {
|
|
|
302 switch (arg->getOption().getID()) {
|
|
|
303 case OPT_l:
|
|
|
304 addLibrary(arg->getValue());
|
|
|
305 break;
|
|
|
306 case OPT_INPUT:
|
|
|
307 addFile(arg->getValue());
|
|
|
308 break;
|
|
|
309 case OPT_whole_archive:
|
|
|
310 inWholeArchive = true;
|
|
|
311 break;
|
|
|
312 case OPT_no_whole_archive:
|
|
|
313 inWholeArchive = false;
|
|
|
314 break;
|
|
|
315 }
|
|
|
316 }
|
|
173
|
317 if (files.empty() && errorCount() == 0)
|
|
|
318 error("no input files");
|
|
150
|
319 }
|
|
|
320
|
|
|
321 static StringRef getEntry(opt::InputArgList &args) {
|
|
|
322 auto *arg = args.getLastArg(OPT_entry, OPT_no_entry);
|
|
|
323 if (!arg) {
|
|
|
324 if (args.hasArg(OPT_relocatable))
|
|
|
325 return "";
|
|
|
326 if (args.hasArg(OPT_shared))
|
|
|
327 return "__wasm_call_ctors";
|
|
|
328 return "_start";
|
|
|
329 }
|
|
|
330 if (arg->getOption().getID() == OPT_no_entry)
|
|
|
331 return "";
|
|
|
332 return arg->getValue();
|
|
|
333 }
|
|
|
334
|
|
207
|
335 // Determines what we should do if there are remaining unresolved
|
|
|
336 // symbols after the name resolution.
|
|
|
337 static UnresolvedPolicy getUnresolvedSymbolPolicy(opt::InputArgList &args) {
|
|
|
338 UnresolvedPolicy errorOrWarn = args.hasFlag(OPT_error_unresolved_symbols,
|
|
|
339 OPT_warn_unresolved_symbols, true)
|
|
|
340 ? UnresolvedPolicy::ReportError
|
|
|
341 : UnresolvedPolicy::Warn;
|
|
|
342
|
|
|
343 if (auto *arg = args.getLastArg(OPT_unresolved_symbols)) {
|
|
|
344 StringRef s = arg->getValue();
|
|
|
345 if (s == "ignore-all")
|
|
|
346 return UnresolvedPolicy::Ignore;
|
|
|
347 if (s == "import-functions")
|
|
|
348 return UnresolvedPolicy::ImportFuncs;
|
|
|
349 if (s == "report-all")
|
|
|
350 return errorOrWarn;
|
|
|
351 error("unknown --unresolved-symbols value: " + s);
|
|
|
352 }
|
|
|
353
|
|
|
354 // Legacy --allow-undefined flag which is equivalent to
|
|
|
355 // --unresolve-symbols=ignore-all
|
|
|
356 if (args.hasArg(OPT_allow_undefined))
|
|
|
357 return UnresolvedPolicy::ImportFuncs;
|
|
|
358
|
|
|
359 return errorOrWarn;
|
|
|
360 }
|
|
|
361
|
|
150
|
362 // Initializes Config members by the command line options.
|
|
|
363 static void readConfigs(opt::InputArgList &args) {
|
|
207
|
364 config->bsymbolic = args.hasArg(OPT_Bsymbolic);
|
|
150
|
365 config->checkFeatures =
|
|
|
366 args.hasFlag(OPT_check_features, OPT_no_check_features, true);
|
|
|
367 config->compressRelocations = args.hasArg(OPT_compress_relocations);
|
|
|
368 config->demangle = args.hasFlag(OPT_demangle, OPT_no_demangle, true);
|
|
|
369 config->disableVerify = args.hasArg(OPT_disable_verify);
|
|
|
370 config->emitRelocs = args.hasArg(OPT_emit_relocs);
|
|
207
|
371 config->experimentalPic = args.hasArg(OPT_experimental_pic);
|
|
150
|
372 config->entry = getEntry(args);
|
|
|
373 config->exportAll = args.hasArg(OPT_export_all);
|
|
|
374 config->exportTable = args.hasArg(OPT_export_table);
|
|
|
375 config->growableTable = args.hasArg(OPT_growable_table);
|
|
|
376 errorHandler().fatalWarnings =
|
|
|
377 args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
|
|
|
378 config->importMemory = args.hasArg(OPT_import_memory);
|
|
|
379 config->sharedMemory = args.hasArg(OPT_shared_memory);
|
|
|
380 config->importTable = args.hasArg(OPT_import_table);
|
|
|
381 config->ltoo = args::getInteger(args, OPT_lto_O, 2);
|
|
|
382 config->ltoPartitions = args::getInteger(args, OPT_lto_partitions, 1);
|
|
207
|
383 config->ltoNewPassManager =
|
|
|
384 args.hasFlag(OPT_no_lto_legacy_pass_manager, OPT_lto_legacy_pass_manager,
|
|
|
385 LLVM_ENABLE_NEW_PASS_MANAGER);
|
|
|
386 config->ltoDebugPassManager = args.hasArg(OPT_lto_debug_pass_manager);
|
|
|
387 config->mapFile = args.getLastArgValue(OPT_Map);
|
|
|
388 config->optimize = args::getInteger(args, OPT_O, 1);
|
|
150
|
389 config->outputFile = args.getLastArgValue(OPT_o);
|
|
|
390 config->relocatable = args.hasArg(OPT_relocatable);
|
|
|
391 config->gcSections =
|
|
|
392 args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, !config->relocatable);
|
|
|
393 config->mergeDataSegments =
|
|
|
394 args.hasFlag(OPT_merge_data_segments, OPT_no_merge_data_segments,
|
|
|
395 !config->relocatable);
|
|
|
396 config->pie = args.hasFlag(OPT_pie, OPT_no_pie, false);
|
|
|
397 config->printGcSections =
|
|
|
398 args.hasFlag(OPT_print_gc_sections, OPT_no_print_gc_sections, false);
|
|
|
399 config->saveTemps = args.hasArg(OPT_save_temps);
|
|
|
400 config->searchPaths = args::getStrings(args, OPT_L);
|
|
|
401 config->shared = args.hasArg(OPT_shared);
|
|
|
402 config->stripAll = args.hasArg(OPT_strip_all);
|
|
|
403 config->stripDebug = args.hasArg(OPT_strip_debug);
|
|
|
404 config->stackFirst = args.hasArg(OPT_stack_first);
|
|
|
405 config->trace = args.hasArg(OPT_trace);
|
|
|
406 config->thinLTOCacheDir = args.getLastArgValue(OPT_thinlto_cache_dir);
|
|
|
407 config->thinLTOCachePolicy = CHECK(
|
|
|
408 parseCachePruningPolicy(args.getLastArgValue(OPT_thinlto_cache_policy)),
|
|
|
409 "--thinlto-cache-policy: invalid cache policy");
|
|
207
|
410 config->unresolvedSymbols = getUnresolvedSymbolPolicy(args);
|
|
150
|
411 errorHandler().verbose = args.hasArg(OPT_verbose);
|
|
|
412 LLVM_DEBUG(errorHandler().verbose = true);
|
|
|
413
|
|
|
414 config->initialMemory = args::getInteger(args, OPT_initial_memory, 0);
|
|
|
415 config->globalBase = args::getInteger(args, OPT_global_base, 1024);
|
|
|
416 config->maxMemory = args::getInteger(args, OPT_max_memory, 0);
|
|
|
417 config->zStackSize =
|
|
|
418 args::getZOptionValue(args, OPT_z, "stack-size", WasmPageSize);
|
|
|
419
|
|
|
420 // Default value of exportDynamic depends on `-shared`
|
|
|
421 config->exportDynamic =
|
|
|
422 args.hasFlag(OPT_export_dynamic, OPT_no_export_dynamic, config->shared);
|
|
|
423
|
|
207
|
424 // Parse wasm32/64.
|
|
|
425 if (auto *arg = args.getLastArg(OPT_m)) {
|
|
|
426 StringRef s = arg->getValue();
|
|
|
427 if (s == "wasm32")
|
|
|
428 config->is64 = false;
|
|
|
429 else if (s == "wasm64")
|
|
|
430 config->is64 = true;
|
|
|
431 else
|
|
|
432 error("invalid target architecture: " + s);
|
|
|
433 }
|
|
|
434
|
|
173
|
435 // --threads= takes a positive integer and provides the default value for
|
|
|
436 // --thinlto-jobs=.
|
|
|
437 if (auto *arg = args.getLastArg(OPT_threads)) {
|
|
|
438 StringRef v(arg->getValue());
|
|
|
439 unsigned threads = 0;
|
|
|
440 if (!llvm::to_integer(v, threads, 0) || threads == 0)
|
|
|
441 error(arg->getSpelling() + ": expected a positive integer, but got '" +
|
|
|
442 arg->getValue() + "'");
|
|
|
443 parallel::strategy = hardware_concurrency(threads);
|
|
|
444 config->thinLTOJobs = v;
|
|
|
445 }
|
|
|
446 if (auto *arg = args.getLastArg(OPT_thinlto_jobs))
|
|
|
447 config->thinLTOJobs = arg->getValue();
|
|
|
448
|
|
150
|
449 if (auto *arg = args.getLastArg(OPT_features)) {
|
|
|
450 config->features =
|
|
|
451 llvm::Optional<std::vector<std::string>>(std::vector<std::string>());
|
|
|
452 for (StringRef s : arg->getValues())
|
|
|
453 config->features->push_back(std::string(s));
|
|
|
454 }
|
|
207
|
455
|
|
|
456 if (args.hasArg(OPT_print_map))
|
|
|
457 config->mapFile = "-";
|
|
150
|
458 }
|
|
|
459
|
|
|
460 // Some Config members do not directly correspond to any particular
|
|
|
461 // command line options, but computed based on other Config values.
|
|
|
462 // This function initialize such members. See Config.h for the details
|
|
|
463 // of these values.
|
|
|
464 static void setConfigs() {
|
|
|
465 config->isPic = config->pie || config->shared;
|
|
|
466
|
|
|
467 if (config->isPic) {
|
|
|
468 if (config->exportTable)
|
|
|
469 error("-shared/-pie is incompatible with --export-table");
|
|
|
470 config->importTable = true;
|
|
|
471 }
|
|
|
472
|
|
207
|
473 if (config->relocatable) {
|
|
|
474 if (config->exportTable)
|
|
|
475 error("--relocatable is incompatible with --export-table");
|
|
|
476 if (config->growableTable)
|
|
|
477 error("--relocatable is incompatible with --growable-table");
|
|
|
478 // Ignore any --import-table, as it's redundant.
|
|
|
479 config->importTable = true;
|
|
|
480 }
|
|
|
481
|
|
150
|
482 if (config->shared) {
|
|
|
483 config->importMemory = true;
|
|
207
|
484 config->unresolvedSymbols = UnresolvedPolicy::ImportFuncs;
|
|
150
|
485 }
|
|
|
486 }
|
|
|
487
|
|
|
488 // Some command line options or some combinations of them are not allowed.
|
|
|
489 // This function checks for such errors.
|
|
|
490 static void checkOptions(opt::InputArgList &args) {
|
|
|
491 if (!config->stripDebug && !config->stripAll && config->compressRelocations)
|
|
|
492 error("--compress-relocations is incompatible with output debug"
|
|
|
493 " information. Please pass --strip-debug or --strip-all");
|
|
|
494
|
|
|
495 if (config->ltoo > 3)
|
|
|
496 error("invalid optimization level for LTO: " + Twine(config->ltoo));
|
|
|
497 if (config->ltoPartitions == 0)
|
|
|
498 error("--lto-partitions: number of threads must be > 0");
|
|
173
|
499 if (!get_threadpool_strategy(config->thinLTOJobs))
|
|
|
500 error("--thinlto-jobs: invalid job count: " + config->thinLTOJobs);
|
|
150
|
501
|
|
|
502 if (config->pie && config->shared)
|
|
|
503 error("-shared and -pie may not be used together");
|
|
|
504
|
|
|
505 if (config->outputFile.empty())
|
|
|
506 error("no output file specified");
|
|
|
507
|
|
|
508 if (config->importTable && config->exportTable)
|
|
|
509 error("--import-table and --export-table may not be used together");
|
|
|
510
|
|
|
511 if (config->relocatable) {
|
|
|
512 if (!config->entry.empty())
|
|
|
513 error("entry point specified for relocatable output file");
|
|
|
514 if (config->gcSections)
|
|
|
515 error("-r and --gc-sections may not be used together");
|
|
|
516 if (config->compressRelocations)
|
|
|
517 error("-r -and --compress-relocations may not be used together");
|
|
|
518 if (args.hasArg(OPT_undefined))
|
|
|
519 error("-r -and --undefined may not be used together");
|
|
|
520 if (config->pie)
|
|
|
521 error("-r and -pie may not be used together");
|
|
173
|
522 if (config->sharedMemory)
|
|
|
523 error("-r and --shared-memory may not be used together");
|
|
150
|
524 }
|
|
207
|
525
|
|
|
526 // To begin to prepare for Module Linking-style shared libraries, start
|
|
|
527 // warning about uses of `-shared` and related flags outside of Experimental
|
|
|
528 // mode, to give anyone using them a heads-up that they will be changing.
|
|
|
529 //
|
|
|
530 // Also, warn about flags which request explicit exports.
|
|
|
531 if (!config->experimentalPic) {
|
|
|
532 // -shared will change meaning when Module Linking is implemented.
|
|
|
533 if (config->shared) {
|
|
|
534 warn("creating shared libraries, with -shared, is not yet stable");
|
|
|
535 }
|
|
|
536
|
|
|
537 // -pie will change meaning when Module Linking is implemented.
|
|
|
538 if (config->pie) {
|
|
|
539 warn("creating PIEs, with -pie, is not yet stable");
|
|
|
540 }
|
|
|
541 }
|
|
|
542
|
|
|
543 if (config->bsymbolic && !config->shared) {
|
|
|
544 warn("-Bsymbolic is only meaningful when combined with -shared");
|
|
|
545 }
|
|
150
|
546 }
|
|
|
547
|
|
|
548 // Force Sym to be entered in the output. Used for -u or equivalent.
|
|
|
549 static Symbol *handleUndefined(StringRef name) {
|
|
|
550 Symbol *sym = symtab->find(name);
|
|
|
551 if (!sym)
|
|
|
552 return nullptr;
|
|
|
553
|
|
|
554 // Since symbol S may not be used inside the program, LTO may
|
|
|
555 // eliminate it. Mark the symbol as "used" to prevent it.
|
|
|
556 sym->isUsedInRegularObj = true;
|
|
|
557
|
|
|
558 if (auto *lazySym = dyn_cast<LazySymbol>(sym))
|
|
|
559 lazySym->fetch();
|
|
|
560
|
|
|
561 return sym;
|
|
|
562 }
|
|
|
563
|
|
|
564 static void handleLibcall(StringRef name) {
|
|
|
565 Symbol *sym = symtab->find(name);
|
|
|
566 if (!sym)
|
|
|
567 return;
|
|
|
568
|
|
|
569 if (auto *lazySym = dyn_cast<LazySymbol>(sym)) {
|
|
|
570 MemoryBufferRef mb = lazySym->getMemberBuffer();
|
|
|
571 if (isBitcode(mb))
|
|
|
572 lazySym->fetch();
|
|
|
573 }
|
|
|
574 }
|
|
|
575
|
|
|
576 static UndefinedGlobal *
|
|
|
577 createUndefinedGlobal(StringRef name, llvm::wasm::WasmGlobalType *type) {
|
|
|
578 auto *sym = cast<UndefinedGlobal>(symtab->addUndefinedGlobal(
|
|
173
|
579 name, None, None, WASM_SYMBOL_UNDEFINED, nullptr, type));
|
|
150
|
580 config->allowUndefinedSymbols.insert(sym->getName());
|
|
|
581 sym->isUsedInRegularObj = true;
|
|
|
582 return sym;
|
|
|
583 }
|
|
|
584
|
|
207
|
585 static InputGlobal *createGlobal(StringRef name, bool isMutable) {
|
|
150
|
586 llvm::wasm::WasmGlobal wasmGlobal;
|
|
207
|
587 bool is64 = config->is64.getValueOr(false);
|
|
|
588 wasmGlobal.Type = {uint8_t(is64 ? WASM_TYPE_I64 : WASM_TYPE_I32), isMutable};
|
|
|
589 wasmGlobal.InitExpr = intConst(0, is64);
|
|
150
|
590 wasmGlobal.SymbolName = name;
|
|
207
|
591 return make<InputGlobal>(wasmGlobal, nullptr);
|
|
|
592 }
|
|
|
593
|
|
|
594 static GlobalSymbol *createGlobalVariable(StringRef name, bool isMutable) {
|
|
|
595 InputGlobal *g = createGlobal(name, isMutable);
|
|
|
596 return symtab->addSyntheticGlobal(name, WASM_SYMBOL_VISIBILITY_HIDDEN, g);
|
|
|
597 }
|
|
|
598
|
|
|
599 static GlobalSymbol *createOptionalGlobal(StringRef name, bool isMutable) {
|
|
|
600 InputGlobal *g = createGlobal(name, isMutable);
|
|
|
601 return symtab->addOptionalGlobalSymbol(name, g);
|
|
150
|
602 }
|
|
|
603
|
|
|
604 // Create ABI-defined synthetic symbols
|
|
|
605 static void createSyntheticSymbols() {
|
|
|
606 if (config->relocatable)
|
|
|
607 return;
|
|
|
608
|
|
|
609 static WasmSignature nullSignature = {{}, {}};
|
|
|
610 static WasmSignature i32ArgSignature = {{}, {ValType::I32}};
|
|
207
|
611 static WasmSignature i64ArgSignature = {{}, {ValType::I64}};
|
|
150
|
612 static llvm::wasm::WasmGlobalType globalTypeI32 = {WASM_TYPE_I32, false};
|
|
207
|
613 static llvm::wasm::WasmGlobalType globalTypeI64 = {WASM_TYPE_I64, false};
|
|
150
|
614 static llvm::wasm::WasmGlobalType mutableGlobalTypeI32 = {WASM_TYPE_I32,
|
|
|
615 true};
|
|
207
|
616 static llvm::wasm::WasmGlobalType mutableGlobalTypeI64 = {WASM_TYPE_I64,
|
|
|
617 true};
|
|
150
|
618 WasmSym::callCtors = symtab->addSyntheticFunction(
|
|
|
619 "__wasm_call_ctors", WASM_SYMBOL_VISIBILITY_HIDDEN,
|
|
|
620 make<SyntheticFunction>(nullSignature, "__wasm_call_ctors"));
|
|
|
621
|
|
|
622 if (config->isPic) {
|
|
|
623 WasmSym::stackPointer =
|
|
207
|
624 createUndefinedGlobal("__stack_pointer", config->is64.getValueOr(false)
|
|
|
625 ? &mutableGlobalTypeI64
|
|
|
626 : &mutableGlobalTypeI32);
|
|
150
|
627 // For PIC code, we import two global variables (__memory_base and
|
|
|
628 // __table_base) from the environment and use these as the offset at
|
|
|
629 // which to load our static data and function table.
|
|
|
630 // See:
|
|
|
631 // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
|
|
207
|
632 bool is64 = config->is64.getValueOr(false);
|
|
|
633 auto *globalType = is64 ? &globalTypeI64 : &globalTypeI32;
|
|
|
634 WasmSym::memoryBase = createUndefinedGlobal("__memory_base", globalType);
|
|
|
635 WasmSym::tableBase = createUndefinedGlobal("__table_base", globalType);
|
|
150
|
636 WasmSym::memoryBase->markLive();
|
|
|
637 WasmSym::tableBase->markLive();
|
|
207
|
638 if (is64) {
|
|
|
639 WasmSym::tableBase32 =
|
|
|
640 createUndefinedGlobal("__table_base32", &globalTypeI32);
|
|
|
641 WasmSym::tableBase32->markLive();
|
|
|
642 } else {
|
|
|
643 WasmSym::tableBase32 = nullptr;
|
|
|
644 }
|
|
150
|
645 } else {
|
|
|
646 // For non-PIC code
|
|
207
|
647 WasmSym::stackPointer = createGlobalVariable("__stack_pointer", true);
|
|
150
|
648 WasmSym::stackPointer->markLive();
|
|
|
649 }
|
|
|
650
|
|
207
|
651 if (config->sharedMemory && !config->relocatable) {
|
|
|
652 WasmSym::tlsBase = createGlobalVariable("__tls_base", true);
|
|
|
653 WasmSym::tlsSize = createGlobalVariable("__tls_size", false);
|
|
|
654 WasmSym::tlsAlign = createGlobalVariable("__tls_align", false);
|
|
150
|
655 WasmSym::initTLS = symtab->addSyntheticFunction(
|
|
|
656 "__wasm_init_tls", WASM_SYMBOL_VISIBILITY_HIDDEN,
|
|
207
|
657 make<SyntheticFunction>(
|
|
|
658 config->is64.getValueOr(false) ? i64ArgSignature : i32ArgSignature,
|
|
|
659 "__wasm_init_tls"));
|
|
150
|
660 }
|
|
|
661 }
|
|
|
662
|
|
|
663 static void createOptionalSymbols() {
|
|
|
664 if (config->relocatable)
|
|
|
665 return;
|
|
|
666
|
|
|
667 WasmSym::dsoHandle = symtab->addOptionalDataSymbol("__dso_handle");
|
|
|
668
|
|
|
669 if (!config->shared)
|
|
|
670 WasmSym::dataEnd = symtab->addOptionalDataSymbol("__data_end");
|
|
|
671
|
|
|
672 if (!config->isPic) {
|
|
|
673 WasmSym::globalBase = symtab->addOptionalDataSymbol("__global_base");
|
|
|
674 WasmSym::heapBase = symtab->addOptionalDataSymbol("__heap_base");
|
|
|
675 WasmSym::definedMemoryBase = symtab->addOptionalDataSymbol("__memory_base");
|
|
|
676 WasmSym::definedTableBase = symtab->addOptionalDataSymbol("__table_base");
|
|
207
|
677 if (config->is64.getValueOr(false))
|
|
|
678 WasmSym::definedTableBase32 =
|
|
|
679 symtab->addOptionalDataSymbol("__table_base32");
|
|
150
|
680 }
|
|
207
|
681
|
|
|
682 // For non-shared memory programs we still need to define __tls_base since we
|
|
|
683 // allow object files built with TLS to be linked into single threaded
|
|
|
684 // programs, and such object files can contains refernced to this symbol.
|
|
|
685 //
|
|
|
686 // However, in this case __tls_base is immutable and points directly to the
|
|
|
687 // start of the `.tdata` static segment.
|
|
|
688 //
|
|
|
689 // __tls_size and __tls_align are not needed in this case since they are only
|
|
|
690 // needed for __wasm_init_tls (which we do not create in this case).
|
|
|
691 if (!config->sharedMemory)
|
|
|
692 WasmSym::tlsBase = createOptionalGlobal("__tls_base", false);
|
|
150
|
693 }
|
|
|
694
|
|
|
695 // Reconstructs command line arguments so that so that you can re-run
|
|
|
696 // the same command with the same inputs. This is for --reproduce.
|
|
|
697 static std::string createResponseFile(const opt::InputArgList &args) {
|
|
|
698 SmallString<0> data;
|
|
|
699 raw_svector_ostream os(data);
|
|
|
700
|
|
|
701 // Copy the command line to the output while rewriting paths.
|
|
|
702 for (auto *arg : args) {
|
|
|
703 switch (arg->getOption().getID()) {
|
|
|
704 case OPT_reproduce:
|
|
|
705 break;
|
|
|
706 case OPT_INPUT:
|
|
|
707 os << quote(relativeToRoot(arg->getValue())) << "\n";
|
|
|
708 break;
|
|
|
709 case OPT_o:
|
|
|
710 // If -o path contains directories, "lld @response.txt" will likely
|
|
|
711 // fail because the archive we are creating doesn't contain empty
|
|
|
712 // directories for the output path (-o doesn't create directories).
|
|
|
713 // Strip directories to prevent the issue.
|
|
|
714 os << "-o " << quote(sys::path::filename(arg->getValue())) << "\n";
|
|
|
715 break;
|
|
|
716 default:
|
|
|
717 os << toString(*arg) << "\n";
|
|
|
718 }
|
|
|
719 }
|
|
|
720 return std::string(data.str());
|
|
|
721 }
|
|
|
722
|
|
|
723 // The --wrap option is a feature to rename symbols so that you can write
|
|
|
724 // wrappers for existing functions. If you pass `-wrap=foo`, all
|
|
|
725 // occurrences of symbol `foo` are resolved to `wrap_foo` (so, you are
|
|
|
726 // expected to write `wrap_foo` function as a wrapper). The original
|
|
|
727 // symbol becomes accessible as `real_foo`, so you can call that from your
|
|
|
728 // wrapper.
|
|
|
729 //
|
|
|
730 // This data structure is instantiated for each -wrap option.
|
|
|
731 struct WrappedSymbol {
|
|
|
732 Symbol *sym;
|
|
|
733 Symbol *real;
|
|
|
734 Symbol *wrap;
|
|
|
735 };
|
|
|
736
|
|
|
737 static Symbol *addUndefined(StringRef name) {
|
|
173
|
738 return symtab->addUndefinedFunction(name, None, None, WASM_SYMBOL_UNDEFINED,
|
|
150
|
739 nullptr, nullptr, false);
|
|
|
740 }
|
|
|
741
|
|
|
742 // Handles -wrap option.
|
|
|
743 //
|
|
|
744 // This function instantiates wrapper symbols. At this point, they seem
|
|
|
745 // like they are not being used at all, so we explicitly set some flags so
|
|
|
746 // that LTO won't eliminate them.
|
|
|
747 static std::vector<WrappedSymbol> addWrappedSymbols(opt::InputArgList &args) {
|
|
|
748 std::vector<WrappedSymbol> v;
|
|
|
749 DenseSet<StringRef> seen;
|
|
|
750
|
|
|
751 for (auto *arg : args.filtered(OPT_wrap)) {
|
|
|
752 StringRef name = arg->getValue();
|
|
|
753 if (!seen.insert(name).second)
|
|
|
754 continue;
|
|
|
755
|
|
|
756 Symbol *sym = symtab->find(name);
|
|
|
757 if (!sym)
|
|
|
758 continue;
|
|
|
759
|
|
|
760 Symbol *real = addUndefined(saver.save("__real_" + name));
|
|
|
761 Symbol *wrap = addUndefined(saver.save("__wrap_" + name));
|
|
|
762 v.push_back({sym, real, wrap});
|
|
|
763
|
|
|
764 // We want to tell LTO not to inline symbols to be overwritten
|
|
|
765 // because LTO doesn't know the final symbol contents after renaming.
|
|
|
766 real->canInline = false;
|
|
|
767 sym->canInline = false;
|
|
|
768
|
|
|
769 // Tell LTO not to eliminate these symbols.
|
|
|
770 sym->isUsedInRegularObj = true;
|
|
|
771 wrap->isUsedInRegularObj = true;
|
|
|
772 real->isUsedInRegularObj = false;
|
|
|
773 }
|
|
|
774 return v;
|
|
|
775 }
|
|
|
776
|
|
|
777 // Do renaming for -wrap by updating pointers to symbols.
|
|
|
778 //
|
|
|
779 // When this function is executed, only InputFiles and symbol table
|
|
|
780 // contain pointers to symbol objects. We visit them to replace pointers,
|
|
|
781 // so that wrapped symbols are swapped as instructed by the command line.
|
|
|
782 static void wrapSymbols(ArrayRef<WrappedSymbol> wrapped) {
|
|
|
783 DenseMap<Symbol *, Symbol *> map;
|
|
|
784 for (const WrappedSymbol &w : wrapped) {
|
|
|
785 map[w.sym] = w.wrap;
|
|
|
786 map[w.real] = w.sym;
|
|
|
787 }
|
|
|
788
|
|
|
789 // Update pointers in input files.
|
|
|
790 parallelForEach(symtab->objectFiles, [&](InputFile *file) {
|
|
|
791 MutableArrayRef<Symbol *> syms = file->getMutableSymbols();
|
|
|
792 for (size_t i = 0, e = syms.size(); i != e; ++i)
|
|
|
793 if (Symbol *s = map.lookup(syms[i]))
|
|
|
794 syms[i] = s;
|
|
|
795 });
|
|
|
796
|
|
|
797 // Update pointers in the symbol table.
|
|
|
798 for (const WrappedSymbol &w : wrapped)
|
|
|
799 symtab->wrap(w.sym, w.real, w.wrap);
|
|
|
800 }
|
|
|
801
|
|
207
|
802 static void splitSections() {
|
|
|
803 // splitIntoPieces needs to be called on each MergeInputChunk
|
|
|
804 // before calling finalizeContents().
|
|
|
805 LLVM_DEBUG(llvm::dbgs() << "splitSections\n");
|
|
|
806 parallelForEach(symtab->objectFiles, [](ObjFile *file) {
|
|
|
807 for (InputChunk *seg : file->segments) {
|
|
|
808 if (auto *s = dyn_cast<MergeInputChunk>(seg))
|
|
|
809 s->splitIntoPieces();
|
|
|
810 }
|
|
|
811 for (InputChunk *sec : file->customSections) {
|
|
|
812 if (auto *s = dyn_cast<MergeInputChunk>(sec))
|
|
|
813 s->splitIntoPieces();
|
|
|
814 }
|
|
|
815 });
|
|
|
816 }
|
|
|
817
|
|
|
818 void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
|
|
150
|
819 WasmOptTable parser;
|
|
|
820 opt::InputArgList args = parser.parse(argsArr.slice(1));
|
|
|
821
|
|
|
822 // Handle --help
|
|
|
823 if (args.hasArg(OPT_help)) {
|
|
|
824 parser.PrintHelp(lld::outs(),
|
|
|
825 (std::string(argsArr[0]) + " [options] file...").c_str(),
|
|
|
826 "LLVM Linker", false);
|
|
|
827 return;
|
|
|
828 }
|
|
|
829
|
|
|
830 // Handle --version
|
|
|
831 if (args.hasArg(OPT_version) || args.hasArg(OPT_v)) {
|
|
|
832 lld::outs() << getLLDVersion() << "\n";
|
|
|
833 return;
|
|
|
834 }
|
|
|
835
|
|
|
836 // Handle --reproduce
|
|
|
837 if (auto *arg = args.getLastArg(OPT_reproduce)) {
|
|
|
838 StringRef path = arg->getValue();
|
|
|
839 Expected<std::unique_ptr<TarWriter>> errOrWriter =
|
|
|
840 TarWriter::create(path, path::stem(path));
|
|
|
841 if (errOrWriter) {
|
|
|
842 tar = std::move(*errOrWriter);
|
|
|
843 tar->append("response.txt", createResponseFile(args));
|
|
|
844 tar->append("version.txt", getLLDVersion() + "\n");
|
|
|
845 } else {
|
|
|
846 error("--reproduce: " + toString(errOrWriter.takeError()));
|
|
|
847 }
|
|
|
848 }
|
|
|
849
|
|
|
850 // Parse and evaluate -mllvm options.
|
|
|
851 std::vector<const char *> v;
|
|
|
852 v.push_back("wasm-ld (LLVM option parsing)");
|
|
|
853 for (auto *arg : args.filtered(OPT_mllvm))
|
|
|
854 v.push_back(arg->getValue());
|
|
207
|
855 cl::ResetAllOptionOccurrences();
|
|
150
|
856 cl::ParseCommandLineOptions(v.size(), v.data());
|
|
|
857
|
|
|
858 errorHandler().errorLimit = args::getInteger(args, OPT_error_limit, 20);
|
|
|
859
|
|
|
860 readConfigs(args);
|
|
173
|
861
|
|
|
862 createFiles(args);
|
|
|
863 if (errorCount())
|
|
|
864 return;
|
|
|
865
|
|
150
|
866 setConfigs();
|
|
|
867 checkOptions(args);
|
|
173
|
868 if (errorCount())
|
|
|
869 return;
|
|
150
|
870
|
|
|
871 if (auto *arg = args.getLastArg(OPT_allow_undefined_file))
|
|
|
872 readImportFile(arg->getValue());
|
|
|
873
|
|
173
|
874 // Fail early if the output file or map file is not writable. If a user has a
|
|
|
875 // long link, e.g. due to a large LTO link, they do not wish to run it and
|
|
|
876 // find that it failed because there was a mistake in their command-line.
|
|
|
877 if (auto e = tryCreateFile(config->outputFile))
|
|
|
878 error("cannot open output file " + config->outputFile + ": " + e.message());
|
|
207
|
879 if (auto e = tryCreateFile(config->mapFile))
|
|
|
880 error("cannot open map file " + config->mapFile + ": " + e.message());
|
|
173
|
881 if (errorCount())
|
|
150
|
882 return;
|
|
|
883
|
|
|
884 // Handle --trace-symbol.
|
|
|
885 for (auto *arg : args.filtered(OPT_trace_symbol))
|
|
|
886 symtab->trace(arg->getValue());
|
|
|
887
|
|
207
|
888 for (auto *arg : args.filtered(OPT_export_if_defined))
|
|
150
|
889 config->exportedSymbols.insert(arg->getValue());
|
|
|
890
|
|
207
|
891 for (auto *arg : args.filtered(OPT_export)) {
|
|
|
892 config->exportedSymbols.insert(arg->getValue());
|
|
|
893 config->requiredExports.push_back(arg->getValue());
|
|
|
894 }
|
|
|
895
|
|
150
|
896 createSyntheticSymbols();
|
|
|
897
|
|
|
898 // Add all files to the symbol table. This will add almost all
|
|
|
899 // symbols that we need to the symbol table.
|
|
|
900 for (InputFile *f : files)
|
|
|
901 symtab->addFile(f);
|
|
|
902 if (errorCount())
|
|
|
903 return;
|
|
|
904
|
|
|
905 // Handle the `--undefined <sym>` options.
|
|
|
906 for (auto *arg : args.filtered(OPT_undefined))
|
|
|
907 handleUndefined(arg->getValue());
|
|
|
908
|
|
|
909 // Handle the `--export <sym>` options
|
|
|
910 // This works like --undefined but also exports the symbol if its found
|
|
207
|
911 for (auto &iter : config->exportedSymbols)
|
|
|
912 handleUndefined(iter.first());
|
|
150
|
913
|
|
|
914 Symbol *entrySym = nullptr;
|
|
|
915 if (!config->relocatable && !config->entry.empty()) {
|
|
|
916 entrySym = handleUndefined(config->entry);
|
|
|
917 if (entrySym && entrySym->isDefined())
|
|
|
918 entrySym->forceExport = true;
|
|
|
919 else
|
|
173
|
920 error("entry symbol not defined (pass --no-entry to suppress): " +
|
|
150
|
921 config->entry);
|
|
|
922 }
|
|
|
923
|
|
207
|
924 // If the user code defines a `__wasm_call_dtors` function, remember it so
|
|
|
925 // that we can call it from the command export wrappers. Unlike
|
|
|
926 // `__wasm_call_ctors` which we synthesize, `__wasm_call_dtors` is defined
|
|
|
927 // by libc/etc., because destructors are registered dynamically with
|
|
|
928 // `__cxa_atexit` and friends.
|
|
|
929 if (!config->relocatable && !config->shared &&
|
|
|
930 !WasmSym::callCtors->isUsedInRegularObj &&
|
|
|
931 WasmSym::callCtors->getName() != config->entry &&
|
|
|
932 !config->exportedSymbols.count(WasmSym::callCtors->getName())) {
|
|
|
933 if (Symbol *callDtors = handleUndefined("__wasm_call_dtors")) {
|
|
|
934 if (auto *callDtorsFunc = dyn_cast<DefinedFunction>(callDtors)) {
|
|
|
935 if (callDtorsFunc->signature &&
|
|
|
936 (!callDtorsFunc->signature->Params.empty() ||
|
|
|
937 !callDtorsFunc->signature->Returns.empty())) {
|
|
|
938 error("__wasm_call_dtors must have no argument or return values");
|
|
|
939 }
|
|
|
940 WasmSym::callDtors = callDtorsFunc;
|
|
|
941 } else {
|
|
|
942 error("__wasm_call_dtors must be a function");
|
|
|
943 }
|
|
|
944 }
|
|
|
945 }
|
|
|
946
|
|
150
|
947 createOptionalSymbols();
|
|
|
948
|
|
|
949 if (errorCount())
|
|
|
950 return;
|
|
|
951
|
|
|
952 // Create wrapped symbols for -wrap option.
|
|
|
953 std::vector<WrappedSymbol> wrapped = addWrappedSymbols(args);
|
|
|
954
|
|
|
955 // If any of our inputs are bitcode files, the LTO code generator may create
|
|
|
956 // references to certain library functions that might not be explicit in the
|
|
|
957 // bitcode file's symbol table. If any of those library functions are defined
|
|
|
958 // in a bitcode file in an archive member, we need to arrange to use LTO to
|
|
|
959 // compile those archive members by adding them to the link beforehand.
|
|
|
960 //
|
|
|
961 // We only need to add libcall symbols to the link before LTO if the symbol's
|
|
|
962 // definition is in bitcode. Any other required libcall symbols will be added
|
|
|
963 // to the link after LTO when we add the LTO object file to the link.
|
|
|
964 if (!symtab->bitcodeFiles.empty())
|
|
|
965 for (auto *s : lto::LTO::getRuntimeLibcallSymbols())
|
|
|
966 handleLibcall(s);
|
|
|
967 if (errorCount())
|
|
|
968 return;
|
|
|
969
|
|
|
970 // Do link-time optimization if given files are LLVM bitcode files.
|
|
|
971 // This compiles bitcode files into real object files.
|
|
|
972 symtab->addCombinedLTOObject();
|
|
|
973 if (errorCount())
|
|
|
974 return;
|
|
|
975
|
|
|
976 // Resolve any variant symbols that were created due to signature
|
|
|
977 // mismatchs.
|
|
|
978 symtab->handleSymbolVariants();
|
|
|
979 if (errorCount())
|
|
|
980 return;
|
|
|
981
|
|
|
982 // Apply symbol renames for -wrap.
|
|
|
983 if (!wrapped.empty())
|
|
|
984 wrapSymbols(wrapped);
|
|
|
985
|
|
207
|
986 for (auto &iter : config->exportedSymbols) {
|
|
|
987 Symbol *sym = symtab->find(iter.first());
|
|
150
|
988 if (sym && sym->isDefined())
|
|
|
989 sym->forceExport = true;
|
|
|
990 }
|
|
|
991
|
|
207
|
992 if (!config->relocatable && !config->isPic) {
|
|
150
|
993 // Add synthetic dummies for weak undefined functions. Must happen
|
|
|
994 // after LTO otherwise functions may not yet have signatures.
|
|
|
995 symtab->handleWeakUndefines();
|
|
|
996 }
|
|
|
997
|
|
|
998 if (entrySym)
|
|
|
999 entrySym->setHidden(false);
|
|
|
1000
|
|
|
1001 if (errorCount())
|
|
|
1002 return;
|
|
|
1003
|
|
207
|
1004 // Split WASM_SEG_FLAG_STRINGS sections into pieces in preparation for garbage
|
|
|
1005 // collection.
|
|
|
1006 splitSections();
|
|
|
1007
|
|
150
|
1008 // Do size optimizations: garbage collection
|
|
|
1009 markLive();
|
|
|
1010
|
|
207
|
1011 // Provide the indirect function table if needed.
|
|
|
1012 WasmSym::indirectFunctionTable =
|
|
|
1013 symtab->resolveIndirectFunctionTable(/*required =*/false);
|
|
|
1014
|
|
|
1015 if (errorCount())
|
|
|
1016 return;
|
|
|
1017
|
|
150
|
1018 // Write the result to the file.
|
|
|
1019 writeResult();
|
|
|
1020 }
|
|
|
1021
|
|
|
1022 } // namespace wasm
|
|
|
1023 } // namespace lld
|
