1//===- SymbolTable.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 "SymbolTable.h"
10#include "ConcatOutputSection.h"
11#include "Config.h"
12#include "InputFiles.h"
13#include "InputSection.h"
14#include "Symbols.h"
15#include "SyntheticSections.h"
16#include "lld/Common/ErrorHandler.h"
17#include "lld/Common/Memory.h"
18#include "llvm/Demangle/Demangle.h"
19
20using namespace llvm;
21using namespace lld;
22using namespace lld::macho;
23
24Symbol *SymbolTable::find(CachedHashStringRef cachedName) {
25 auto it = symMap.find(Val: cachedName);
26 if (it == symMap.end())
27 return nullptr;
28 return symVector[it->second];
29}
30
31std::pair<Symbol *, bool> SymbolTable::insert(StringRef name,
32 const InputFile *file) {
33 auto p = symMap.insert(KV: {CachedHashStringRef(name), (int)symVector.size()});
34
35 Symbol *sym;
36 if (!p.second) {
37 // Name already present in the symbol table.
38 sym = symVector[p.first->second];
39 } else {
40 // Name is a new symbol.
41 sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
42 symVector.push_back(x: sym);
43 }
44
45 sym->isUsedInRegularObj |= !file || isa<ObjFile>(Val: file);
46 return {sym, p.second};
47}
48
49namespace {
50struct DuplicateSymbolDiag {
51 // Pair containing source location and source file
52 const std::pair<std::string, std::string> src1;
53 const std::pair<std::string, std::string> src2;
54 const Symbol *sym;
55
56 DuplicateSymbolDiag(const std::pair<std::string, std::string> src1,
57 const std::pair<std::string, std::string> src2,
58 const Symbol *sym)
59 : src1(src1), src2(src2), sym(sym) {}
60};
61SmallVector<DuplicateSymbolDiag> dupSymDiags;
62} // namespace
63
64// Move symbols at \p fromOff in \p fromIsec into \p toIsec, unless that symbol
65// is \p skip.
66static void transplantSymbolsAtOffset(InputSection *fromIsec,
67 InputSection *toIsec, Defined *skip,
68 uint64_t fromOff, uint64_t toOff) {
69 // Ensure the symbols will still be in address order after our insertions.
70 auto insertIt = llvm::upper_bound(Range&: toIsec->symbols, Value&: toOff,
71 C: [](uint64_t off, const Symbol *s) {
72 return cast<Defined>(Val: s)->value < off;
73 });
74 llvm::erase_if(C&: fromIsec->symbols, P: [&](Symbol *s) {
75 auto *d = cast<Defined>(Val: s);
76 if (d->value != fromOff)
77 return false;
78 if (d != skip) {
79 // This repeated insertion will be quadratic unless insertIt is the end
80 // iterator. However, that is typically the case for files that have
81 // .subsections_via_symbols set.
82 insertIt = toIsec->symbols.insert(I: insertIt, Elt: d);
83 d->originalIsec = toIsec;
84 d->value = toOff;
85 // We don't want to have more than one unwindEntry at a given address, so
86 // drop the redundant ones. We We can safely drop the unwindEntries of
87 // the symbols in fromIsec since we will be adding another unwindEntry as
88 // we finish parsing toIsec's file. (We can assume that toIsec has its
89 // own unwindEntry because of the ODR.)
90 d->originalUnwindEntry = nullptr;
91 }
92 return true;
93 });
94}
95
96Defined *SymbolTable::addDefined(StringRef name, InputFile *file,
97 InputSection *isec, uint64_t value,
98 uint64_t size, bool isWeakDef,
99 bool isPrivateExtern,
100 bool isReferencedDynamically, bool noDeadStrip,
101 bool isWeakDefCanBeHidden) {
102 bool overridesWeakDef = false;
103 auto [s, wasInserted] = insert(name, file);
104
105 assert(!file || !isa<BitcodeFile>(file) || !isec);
106
107 if (!wasInserted) {
108 if (auto *defined = dyn_cast<Defined>(Val: s)) {
109 if (isWeakDef) {
110 // See further comment in createDefined() in InputFiles.cpp
111 if (defined->isWeakDef()) {
112 defined->privateExtern &= isPrivateExtern;
113 defined->weakDefCanBeHidden &= isWeakDefCanBeHidden;
114 defined->referencedDynamically |= isReferencedDynamically;
115 defined->noDeadStrip |= noDeadStrip;
116 }
117 if (auto concatIsec = dyn_cast_or_null<ConcatInputSection>(Val: isec)) {
118 concatIsec->wasCoalesced = true;
119 // Any local symbols that alias the coalesced symbol should be moved
120 // into the prevailing section. Note that we have sorted the symbols
121 // in ObjFile::parseSymbols() such that extern weak symbols appear
122 // last, so we don't need to worry about subsequent symbols being
123 // added to an already-coalesced section.
124 if (defined->isec())
125 transplantSymbolsAtOffset(fromIsec: concatIsec, toIsec: defined->isec(),
126 /*skip=*/nullptr, fromOff: value, toOff: defined->value);
127 }
128 return defined;
129 }
130
131 if (defined->isWeakDef()) {
132 if (auto concatIsec =
133 dyn_cast_or_null<ConcatInputSection>(Val: defined->isec())) {
134 concatIsec->wasCoalesced = true;
135 if (isec)
136 transplantSymbolsAtOffset(fromIsec: concatIsec, toIsec: isec, skip: defined, fromOff: defined->value,
137 toOff: value);
138 }
139 } else {
140 std::string srcLoc1 = defined->getSourceLocation();
141 std::string srcLoc2 = isec ? isec->getSourceLocation(off: value) : "";
142 std::string srcFile1 = toString(file: defined->getFile());
143 std::string srcFile2 = toString(file);
144
145 dupSymDiags.push_back(Elt: {make_pair(x&: srcLoc1, y&: srcFile1),
146 make_pair(x&: srcLoc2, y&: srcFile2), defined});
147 }
148
149 } else if (auto *dysym = dyn_cast<DylibSymbol>(Val: s)) {
150 overridesWeakDef = !isWeakDef && dysym->isWeakDef();
151 dysym->unreference();
152 } else if (auto *undef = dyn_cast<Undefined>(Val: s)) {
153 if (undef->wasBitcodeSymbol) {
154 auto objFile = dyn_cast<ObjFile>(Val: file);
155 if (!objFile) {
156 // The file must be a native object file, as opposed to potentially
157 // being another bitcode file. A situation arises when some symbols
158 // are defined thru `module asm` and thus they are not present in the
159 // bitcode's symbol table. Consider bitcode modules `A`, `B`, and `C`.
160 // LTO compiles only `A` and `C`, since there's no explicit symbol
161 // reference to `B` other than a symbol from `A` via `module asm`.
162 // After LTO is finished, the missing symbol now appears in the
163 // resulting object file for `A`, which prematurely resolves another
164 // prevailing symbol with `B` that hasn't been compiled, instead of
165 // the resulting object for `C`. Consequently, an incorrect
166 // relocation is generated for the prevailing symbol.
167 assert(isa<BitcodeFile>(file) && "Bitcode file is expected.");
168 std::string message =
169 "The pending prevailing symbol(" + name.str() +
170 ") in the bitcode file(" + toString(file: undef->getFile()) +
171 ") is overridden by a non-native object (from bitcode): " +
172 toString(file);
173 error(msg: message);
174 } else if (!objFile->builtFromBitcode) {
175 // Ideally, this should be an object file compiled from a bitcode
176 // file. However, this might not hold true if a LC linker option is
177 // used. In case LTO internalizes a prevailing hidden weak symbol,
178 // there's a situation where an unresolved prevailing symbol might be
179 // linked with the corresponding one from a native library, which is
180 // loaded later after LTO. Although this could potentially result in
181 // an ODR violation, we choose to permit this scenario as a warning.
182 std::string message = "The pending prevailing symbol(" + name.str() +
183 ") in the bitcode file(" +
184 toString(file: undef->getFile()) +
185 ") is overridden by a post-processed native "
186 "object (from native archive): " +
187 toString(file);
188 warn(msg: message);
189 } else {
190 // Preserve the original bitcode file name (instead of using the
191 // object file name).
192 file = undef->getFile();
193 }
194 }
195 }
196 // Defined symbols take priority over other types of symbols, so in case
197 // of a name conflict, we fall through to the replaceSymbol() call below.
198 }
199
200 // With -flat_namespace, all extern symbols in dylibs are interposable.
201 // FIXME: Add support for `-interposable` (PR53680).
202 bool interposable = config->namespaceKind == NamespaceKind::flat &&
203 config->outputType != MachO::MH_EXECUTE &&
204 !isPrivateExtern;
205 Defined *defined = replaceSymbol<Defined>(
206 s, arg&: name, arg&: file, arg&: isec, arg&: value, arg&: size, arg&: isWeakDef, /*isExternal=*/arg: true,
207 arg&: isPrivateExtern, /*includeInSymtab=*/arg: true, arg&: isReferencedDynamically,
208 arg&: noDeadStrip, arg&: overridesWeakDef, arg&: isWeakDefCanBeHidden, arg&: interposable);
209 return defined;
210}
211
212Defined *SymbolTable::aliasDefined(Defined *src, StringRef target,
213 InputFile *newFile, bool makePrivateExtern) {
214 bool isPrivateExtern = makePrivateExtern || src->privateExtern;
215 return addDefined(name: target, file: newFile, isec: src->isec(), value: src->value, size: src->size,
216 isWeakDef: src->isWeakDef(), isPrivateExtern,
217 isReferencedDynamically: src->referencedDynamically, noDeadStrip: src->noDeadStrip,
218 isWeakDefCanBeHidden: src->weakDefCanBeHidden);
219}
220
221Symbol *SymbolTable::addUndefined(StringRef name, InputFile *file,
222 bool isWeakRef) {
223 auto [s, wasInserted] = insert(name, file);
224
225 RefState refState = isWeakRef ? RefState::Weak : RefState::Strong;
226
227 if (wasInserted)
228 replaceSymbol<Undefined>(s, arg&: name, arg&: file, arg&: refState,
229 /*wasBitcodeSymbol=*/arg: false);
230 else if (auto *lazy = dyn_cast<LazyArchive>(Val: s))
231 lazy->fetchArchiveMember();
232 else if (isa<LazyObject>(Val: s))
233 extract(file&: *s->getFile(), reason: s->getName());
234 else if (auto *dynsym = dyn_cast<DylibSymbol>(Val: s))
235 dynsym->reference(newState: refState);
236 else if (auto *undefined = dyn_cast<Undefined>(Val: s))
237 undefined->refState = std::max(a: undefined->refState, b: refState);
238 return s;
239}
240
241Symbol *SymbolTable::addCommon(StringRef name, InputFile *file, uint64_t size,
242 uint32_t align, bool isPrivateExtern) {
243 auto [s, wasInserted] = insert(name, file);
244
245 if (!wasInserted) {
246 if (auto *common = dyn_cast<CommonSymbol>(Val: s)) {
247 if (size < common->size)
248 return s;
249 } else if (isa<Defined>(Val: s)) {
250 return s;
251 }
252 // Common symbols take priority over all non-Defined symbols, so in case of
253 // a name conflict, we fall through to the replaceSymbol() call below.
254 }
255
256 replaceSymbol<CommonSymbol>(s, arg&: name, arg&: file, arg&: size, arg&: align, arg&: isPrivateExtern);
257 return s;
258}
259
260Symbol *SymbolTable::addDylib(StringRef name, DylibFile *file, bool isWeakDef,
261 bool isTlv) {
262 auto [s, wasInserted] = insert(name, file);
263
264 RefState refState = RefState::Unreferenced;
265 if (!wasInserted) {
266 if (auto *defined = dyn_cast<Defined>(Val: s)) {
267 if (isWeakDef && !defined->isWeakDef())
268 defined->overridesWeakDef = true;
269 } else if (auto *undefined = dyn_cast<Undefined>(Val: s)) {
270 refState = undefined->refState;
271 } else if (auto *dysym = dyn_cast<DylibSymbol>(Val: s)) {
272 refState = dysym->getRefState();
273 }
274 }
275
276 bool isDynamicLookup = file == nullptr;
277 if (wasInserted || isa<Undefined>(Val: s) ||
278 (isa<DylibSymbol>(Val: s) &&
279 ((!isWeakDef && s->isWeakDef()) ||
280 (!isDynamicLookup && cast<DylibSymbol>(Val: s)->isDynamicLookup())))) {
281 if (auto *dynsym = dyn_cast<DylibSymbol>(Val: s))
282 dynsym->unreference();
283 replaceSymbol<DylibSymbol>(s, arg&: file, arg&: name, arg&: isWeakDef, arg&: refState, arg&: isTlv);
284 }
285
286 return s;
287}
288
289Symbol *SymbolTable::addDynamicLookup(StringRef name) {
290 return addDylib(name, /*file=*/nullptr, /*isWeakDef=*/false, /*isTlv=*/false);
291}
292
293Symbol *SymbolTable::addLazyArchive(StringRef name, ArchiveFile *file,
294 const object::Archive::Symbol &sym) {
295 auto [s, wasInserted] = insert(name, file);
296
297 if (wasInserted) {
298 replaceSymbol<LazyArchive>(s, arg&: file, arg: sym);
299 } else if (isa<Undefined>(Val: s)) {
300 file->fetch(sym);
301 } else if (auto *dysym = dyn_cast<DylibSymbol>(Val: s)) {
302 if (dysym->isWeakDef()) {
303 if (dysym->getRefState() != RefState::Unreferenced)
304 file->fetch(sym);
305 else
306 replaceSymbol<LazyArchive>(s, arg&: file, arg: sym);
307 }
308 }
309 return s;
310}
311
312Symbol *SymbolTable::addLazyObject(StringRef name, InputFile &file) {
313 auto [s, wasInserted] = insert(name, file: &file);
314
315 if (wasInserted) {
316 replaceSymbol<LazyObject>(s, arg&: file, arg&: name);
317 } else if (isa<Undefined>(Val: s)) {
318 extract(file, reason: name);
319 } else if (auto *dysym = dyn_cast<DylibSymbol>(Val: s)) {
320 if (dysym->isWeakDef()) {
321 if (dysym->getRefState() != RefState::Unreferenced)
322 extract(file, reason: name);
323 else
324 replaceSymbol<LazyObject>(s, arg&: file, arg&: name);
325 }
326 }
327 return s;
328}
329
330Defined *SymbolTable::addSynthetic(StringRef name, InputSection *isec,
331 uint64_t value, bool isPrivateExtern,
332 bool includeInSymtab,
333 bool referencedDynamically) {
334 assert(!isec || !isec->getFile()); // See makeSyntheticInputSection().
335 Defined *s = addDefined(name, /*file=*/nullptr, isec, value, /*size=*/0,
336 /*isWeakDef=*/false, isPrivateExtern,
337 isReferencedDynamically: referencedDynamically, /*noDeadStrip=*/false,
338 /*isWeakDefCanBeHidden=*/false);
339 s->includeInSymtab = includeInSymtab;
340 return s;
341}
342
343enum class Boundary {
344 Start,
345 End,
346};
347
348static Defined *createBoundarySymbol(const Undefined &sym) {
349 return symtab->addSynthetic(
350 name: sym.getName(), /*isec=*/nullptr, /*value=*/-1, /*isPrivateExtern=*/true,
351 /*includeInSymtab=*/false, /*referencedDynamically=*/false);
352}
353
354static void handleSectionBoundarySymbol(const Undefined &sym, StringRef segSect,
355 Boundary which) {
356 auto [segName, sectName] = segSect.split(Separator: '$');
357
358 // Attach the symbol to any InputSection that will end up in the right
359 // OutputSection -- it doesn't matter which one we pick.
360 // Don't bother looking through inputSections for a matching
361 // ConcatInputSection -- we need to create ConcatInputSection for
362 // non-existing sections anyways, and that codepath works even if we should
363 // already have a ConcatInputSection with the right name.
364
365 OutputSection *osec = nullptr;
366 // This looks for __TEXT,__cstring etc.
367 for (SyntheticSection *ssec : syntheticSections)
368 if (ssec->segname == segName && ssec->name == sectName) {
369 osec = ssec->isec->parent;
370 break;
371 }
372
373 if (!osec) {
374 ConcatInputSection *isec = makeSyntheticInputSection(segName, sectName);
375
376 // This runs after markLive() and is only called for Undefineds that are
377 // live. Marking the isec live ensures an OutputSection is created that the
378 // start/end symbol can refer to.
379 assert(sym.isLive());
380 assert(isec->live);
381
382 // This runs after gatherInputSections(), so need to explicitly set parent
383 // and add to inputSections.
384 osec = isec->parent = ConcatOutputSection::getOrCreateForInput(isec);
385 inputSections.push_back(x: isec);
386 }
387
388 if (which == Boundary::Start)
389 osec->sectionStartSymbols.push_back(NewVal: createBoundarySymbol(sym));
390 else
391 osec->sectionEndSymbols.push_back(NewVal: createBoundarySymbol(sym));
392}
393
394static void handleSegmentBoundarySymbol(const Undefined &sym, StringRef segName,
395 Boundary which) {
396 OutputSegment *seg = getOrCreateOutputSegment(name: segName);
397 if (which == Boundary::Start)
398 seg->segmentStartSymbols.push_back(NewVal: createBoundarySymbol(sym));
399 else
400 seg->segmentEndSymbols.push_back(NewVal: createBoundarySymbol(sym));
401}
402
403// Try to find a definition for an undefined symbol.
404// Returns true if a definition was found and no diagnostics are needed.
405static bool recoverFromUndefinedSymbol(const Undefined &sym) {
406 // Handle start/end symbols.
407 StringRef name = sym.getName();
408 if (name.consume_front(Prefix: "section$start$")) {
409 handleSectionBoundarySymbol(sym, segSect: name, which: Boundary::Start);
410 return true;
411 }
412 if (name.consume_front(Prefix: "section$end$")) {
413 handleSectionBoundarySymbol(sym, segSect: name, which: Boundary::End);
414 return true;
415 }
416 if (name.consume_front(Prefix: "segment$start$")) {
417 handleSegmentBoundarySymbol(sym, segName: name, which: Boundary::Start);
418 return true;
419 }
420 if (name.consume_front(Prefix: "segment$end$")) {
421 handleSegmentBoundarySymbol(sym, segName: name, which: Boundary::End);
422 return true;
423 }
424
425 // Leave dtrace symbols, since we will handle them when we do the relocation
426 if (name.starts_with(Prefix: "___dtrace_"))
427 return true;
428
429 // Handle -U.
430 if (config->explicitDynamicLookups.count(Key: sym.getName())) {
431 symtab->addDynamicLookup(name: sym.getName());
432 return true;
433 }
434
435 // Handle -undefined.
436 if (config->undefinedSymbolTreatment ==
437 UndefinedSymbolTreatment::dynamic_lookup ||
438 config->undefinedSymbolTreatment == UndefinedSymbolTreatment::suppress) {
439 symtab->addDynamicLookup(name: sym.getName());
440 return true;
441 }
442
443 // We do not return true here, as we still need to print diagnostics.
444 if (config->undefinedSymbolTreatment == UndefinedSymbolTreatment::warning)
445 symtab->addDynamicLookup(name: sym.getName());
446
447 return false;
448}
449
450namespace {
451struct UndefinedDiag {
452 struct SectionAndOffset {
453 const InputSection *isec;
454 uint64_t offset;
455 };
456
457 std::vector<SectionAndOffset> codeReferences;
458 std::vector<std::string> otherReferences;
459};
460
461MapVector<const Undefined *, UndefinedDiag> undefs;
462} // namespace
463
464void macho::reportPendingDuplicateSymbols() {
465 for (const auto &duplicate : dupSymDiags) {
466 if (!config->deadStripDuplicates || duplicate.sym->isLive()) {
467 std::string message =
468 "duplicate symbol: " + toString(*duplicate.sym) + "\n>>> defined in ";
469 if (!duplicate.src1.first.empty())
470 message += duplicate.src1.first + "\n>>> ";
471 message += duplicate.src1.second + "\n>>> defined in ";
472 if (!duplicate.src2.first.empty())
473 message += duplicate.src2.first + "\n>>> ";
474 error(msg: message + duplicate.src2.second);
475 }
476 }
477}
478
479// Check whether the definition name def is a mangled function name that matches
480// the reference name ref.
481static bool canSuggestExternCForCXX(StringRef ref, StringRef def) {
482 llvm::ItaniumPartialDemangler d;
483 std::string name = def.str();
484 if (d.partialDemangle(MangledName: name.c_str()))
485 return false;
486 char *buf = d.getFunctionName(Buf: nullptr, N: nullptr);
487 if (!buf)
488 return false;
489 bool ret = ref == buf;
490 free(ptr: buf);
491 return ret;
492}
493
494// Suggest an alternative spelling of an "undefined symbol" diagnostic. Returns
495// the suggested symbol, which is either in the symbol table, or in the same
496// file of sym.
497static const Symbol *getAlternativeSpelling(const Undefined &sym,
498 std::string &preHint,
499 std::string &postHint) {
500 DenseMap<StringRef, const Symbol *> map;
501 if (sym.getFile() && sym.getFile()->kind() == InputFile::ObjKind) {
502 // Build a map of local defined symbols.
503 for (const Symbol *s : sym.getFile()->symbols)
504 if (auto *defined = dyn_cast_or_null<Defined>(Val: s))
505 if (!defined->isExternal())
506 map.try_emplace(Key: s->getName(), Args&: s);
507 }
508
509 auto suggest = [&](StringRef newName) -> const Symbol * {
510 // If defined locally.
511 if (const Symbol *s = map.lookup(Val: newName))
512 return s;
513
514 // If in the symbol table and not undefined.
515 if (const Symbol *s = symtab->find(name: newName))
516 if (dyn_cast<Undefined>(Val: s) == nullptr)
517 return s;
518
519 return nullptr;
520 };
521
522 // This loop enumerates all strings of Levenshtein distance 1 as typo
523 // correction candidates and suggests the one that exists as a non-undefined
524 // symbol.
525 StringRef name = sym.getName();
526 for (size_t i = 0, e = name.size(); i != e + 1; ++i) {
527 // Insert a character before name[i].
528 std::string newName = (name.substr(Start: 0, N: i) + "0" + name.substr(Start: i)).str();
529 for (char c = '0'; c <= 'z'; ++c) {
530 newName[i] = c;
531 if (const Symbol *s = suggest(newName))
532 return s;
533 }
534 if (i == e)
535 break;
536
537 // Substitute name[i].
538 newName = std::string(name);
539 for (char c = '0'; c <= 'z'; ++c) {
540 newName[i] = c;
541 if (const Symbol *s = suggest(newName))
542 return s;
543 }
544
545 // Transpose name[i] and name[i+1]. This is of edit distance 2 but it is
546 // common.
547 if (i + 1 < e) {
548 newName[i] = name[i + 1];
549 newName[i + 1] = name[i];
550 if (const Symbol *s = suggest(newName))
551 return s;
552 }
553
554 // Delete name[i].
555 newName = (name.substr(Start: 0, N: i) + name.substr(Start: i + 1)).str();
556 if (const Symbol *s = suggest(newName))
557 return s;
558 }
559
560 // Case mismatch, e.g. Foo vs FOO.
561 for (auto &it : map)
562 if (name.equals_insensitive(RHS: it.first))
563 return it.second;
564 for (Symbol *sym : symtab->getSymbols())
565 if (dyn_cast<Undefined>(Val: sym) == nullptr &&
566 name.equals_insensitive(RHS: sym->getName()))
567 return sym;
568
569 // The reference may be a mangled name while the definition is not. Suggest a
570 // missing extern "C".
571 if (name.starts_with(Prefix: "__Z")) {
572 std::string buf = name.str();
573 llvm::ItaniumPartialDemangler d;
574 if (!d.partialDemangle(MangledName: buf.c_str()))
575 if (char *buf = d.getFunctionName(Buf: nullptr, N: nullptr)) {
576 const Symbol *s = suggest((Twine("_") + buf).str());
577 free(ptr: buf);
578 if (s) {
579 preHint = ": extern \"C\" ";
580 return s;
581 }
582 }
583 } else {
584 StringRef nameWithoutUnderscore = name;
585 nameWithoutUnderscore.consume_front(Prefix: "_");
586 const Symbol *s = nullptr;
587 for (auto &it : map)
588 if (canSuggestExternCForCXX(ref: nameWithoutUnderscore, def: it.first)) {
589 s = it.second;
590 break;
591 }
592 if (!s)
593 for (Symbol *sym : symtab->getSymbols())
594 if (canSuggestExternCForCXX(ref: nameWithoutUnderscore, def: sym->getName())) {
595 s = sym;
596 break;
597 }
598 if (s) {
599 preHint = " to declare ";
600 postHint = " as extern \"C\"?";
601 return s;
602 }
603 }
604
605 return nullptr;
606}
607
608static void reportUndefinedSymbol(const Undefined &sym,
609 const UndefinedDiag &locations,
610 bool correctSpelling) {
611 std::string message = "undefined symbol";
612 if (config->archMultiple)
613 message += (" for arch " + getArchitectureName(Arch: config->arch())).str();
614 message += ": " + toString(sym);
615
616 const size_t maxUndefinedReferences = 3;
617 size_t i = 0;
618 for (const std::string &loc : locations.otherReferences) {
619 if (i >= maxUndefinedReferences)
620 break;
621 message += "\n>>> referenced by " + loc;
622 ++i;
623 }
624
625 for (const UndefinedDiag::SectionAndOffset &loc : locations.codeReferences) {
626 if (i >= maxUndefinedReferences)
627 break;
628 message += "\n>>> referenced by ";
629 std::string src = loc.isec->getSourceLocation(off: loc.offset);
630 if (!src.empty())
631 message += src + "\n>>> ";
632 message += loc.isec->getLocation(off: loc.offset);
633 ++i;
634 }
635
636 size_t totalReferences =
637 locations.otherReferences.size() + locations.codeReferences.size();
638 if (totalReferences > i)
639 message +=
640 ("\n>>> referenced " + Twine(totalReferences - i) + " more times")
641 .str();
642
643 if (correctSpelling) {
644 std::string preHint = ": ", postHint;
645 if (const Symbol *corrected =
646 getAlternativeSpelling(sym, preHint, postHint)) {
647 message +=
648 "\n>>> did you mean" + preHint + toString(*corrected) + postHint;
649 if (corrected->getFile())
650 message += "\n>>> defined in: " + toString(file: corrected->getFile());
651 }
652 }
653
654 if (config->undefinedSymbolTreatment == UndefinedSymbolTreatment::error)
655 error(msg: message);
656 else if (config->undefinedSymbolTreatment ==
657 UndefinedSymbolTreatment::warning)
658 warn(msg: message);
659 else
660 assert(false && "diagnostics make sense for -undefined error|warning only");
661}
662
663void macho::reportPendingUndefinedSymbols() {
664 // Enable spell corrector for the first 2 diagnostics.
665 for (const auto &[i, undef] : llvm::enumerate(First&: undefs))
666 reportUndefinedSymbol(sym: *undef.first, locations: undef.second, correctSpelling: i < 2);
667
668 // This function is called multiple times during execution. Clear the printed
669 // diagnostics to avoid printing the same things again the next time.
670 undefs.clear();
671}
672
673void macho::treatUndefinedSymbol(const Undefined &sym, StringRef source) {
674 if (recoverFromUndefinedSymbol(sym))
675 return;
676
677 undefs[&sym].otherReferences.push_back(x: source.str());
678}
679
680void macho::treatUndefinedSymbol(const Undefined &sym, const InputSection *isec,
681 uint64_t offset) {
682 if (recoverFromUndefinedSymbol(sym))
683 return;
684
685 undefs[&sym].codeReferences.push_back(x: {.isec: isec, .offset: offset});
686}
687
688std::unique_ptr<SymbolTable> macho::symtab;
689

source code of lld/MachO/SymbolTable.cpp