Michael J. Spencer | 84487f1 | 2015-07-24 21:03:07 | [diff] [blame] | 1 | //===- Symbols.cpp --------------------------------------------------------===// |
| 2 | // |
Chandler Carruth | 2946cd7 | 2019-01-19 08:50:56 | [diff] [blame] | 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 |
Michael J. Spencer | 84487f1 | 2015-07-24 21:03:07 | [diff] [blame] | 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | |
| 9 | #include "Symbols.h" |
Michael J. Spencer | cdae0a4 | 2015-07-28 22:58:25 | [diff] [blame] | 10 | #include "InputFiles.h" |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 | [diff] [blame] | 11 | #include "InputSection.h" |
| 12 | #include "OutputSections.h" |
Rui Ueyama | e8a6102 | 2016-11-05 23:05:47 | [diff] [blame] | 13 | #include "SyntheticSections.h" |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 | [diff] [blame] | 14 | #include "Target.h" |
Rafael Espindola | 17cb7c0 | 2016-12-19 17:01:01 | [diff] [blame] | 15 | #include "Writer.h" |
Bob Haarman | b8a59c8 | 2017-10-25 22:28:38 | [diff] [blame] | 16 | #include "lld/Common/ErrorHandler.h" |
Rui Ueyama | 53fe469 | 2017-11-28 02:15:26 | [diff] [blame] | 17 | #include "lld/Common/Strings.h" |
Rui Ueyama | c72ba3a | 2016-11-23 04:57:25 | [diff] [blame] | 18 | #include <cstring> |
Michael J. Spencer | 1b348a6 | 2015-09-04 22:28:10 | [diff] [blame] | 19 | |
| 20 | using namespace llvm; |
Michael J. Spencer | 84487f1 | 2015-07-24 21:03:07 | [diff] [blame] | 21 | using namespace llvm::object; |
Rafael Espindola | 78471f0 | 2015-09-01 23:12:52 | [diff] [blame] | 22 | using namespace llvm::ELF; |
Fangrui Song | 07837b8 | 2020-05-15 05:18:58 | [diff] [blame] | 23 | using namespace lld; |
| 24 | using namespace lld::elf; |
Michael J. Spencer | 84487f1 | 2015-07-24 21:03:07 | [diff] [blame] | 25 | |
Fangrui Song | 07837b8 | 2020-05-15 05:18:58 | [diff] [blame] | 26 | std::string lld::toString(const elf::Symbol &sym) { |
Fangrui Song | f2036a1 | 2020-03-28 22:48:38 | [diff] [blame] | 27 | StringRef name = sym.getName(); |
Luís Ferreira | 10e40a4 | 2022-01-05 03:05:10 | [diff] [blame] | 28 | std::string ret = demangle(name, config->demangle); |
Fangrui Song | f2036a1 | 2020-03-28 22:48:38 | [diff] [blame] | 29 | |
Fangrui Song | 941e933 | 2020-12-01 16:54:01 | [diff] [blame] | 30 | const char *suffix = sym.getVersionSuffix(); |
| 31 | if (*suffix == '@') |
| 32 | ret += suffix; |
Fangrui Song | f2036a1 | 2020-03-28 22:48:38 | [diff] [blame] | 33 | return ret; |
| 34 | } |
| 35 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 36 | Defined *ElfSym::bss; |
| 37 | Defined *ElfSym::etext1; |
| 38 | Defined *ElfSym::etext2; |
| 39 | Defined *ElfSym::edata1; |
| 40 | Defined *ElfSym::edata2; |
| 41 | Defined *ElfSym::end1; |
| 42 | Defined *ElfSym::end2; |
| 43 | Defined *ElfSym::globalOffsetTable; |
| 44 | Defined *ElfSym::mipsGp; |
| 45 | Defined *ElfSym::mipsGpDisp; |
| 46 | Defined *ElfSym::mipsLocalGp; |
| 47 | Defined *ElfSym::relaIpltStart; |
| 48 | Defined *ElfSym::relaIpltEnd; |
| 49 | Defined *ElfSym::riscvGlobalPointer; |
| 50 | Defined *ElfSym::tlsModuleBase; |
Fangrui Song | ce3c5da | 2020-10-22 22:26:52 | [diff] [blame] | 51 | DenseMap<const Symbol *, std::pair<const InputFile *, const InputFile *>> |
| 52 | elf::backwardReferences; |
Fangrui Song | a954bb1 | 2021-09-20 16:52:30 | [diff] [blame] | 53 | SmallVector<std::tuple<std::string, const InputFile *, const Symbol &>, 0> |
| 54 | elf::whyExtract; |
Fangrui Song | 5d3bd7f | 2022-01-09 21:43:26 | [diff] [blame] | 55 | SmallVector<SymbolAux, 0> elf::symAux; |
Rui Ueyama | 80474a2 | 2017-02-28 19:29:55 | [diff] [blame] | 56 | |
Fangrui Song | a8024df | 2021-12-13 03:12:01 | [diff] [blame] | 57 | static uint64_t getSymVA(const Symbol &sym, int64_t addend) { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 58 | switch (sym.kind()) { |
Peter Collingbourne | e9a9e0a | 2017-11-06 04:35:31 | [diff] [blame] | 59 | case Symbol::DefinedKind: { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 60 | auto &d = cast<Defined>(sym); |
| 61 | SectionBase *isec = d.section; |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 | [diff] [blame] | 62 | |
| 63 | // This is an absolute symbol. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 64 | if (!isec) |
| 65 | return d.value; |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 | [diff] [blame] | 66 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 67 | assert(isec != &InputSection::discarded); |
Rafael Espindola | f4d6e8c | 2018-04-19 17:26:50 | [diff] [blame] | 68 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 69 | uint64_t offset = d.value; |
Sean Silva | a9ba450 | 2017-02-28 08:32:56 | [diff] [blame] | 70 | |
| 71 | // An object in an SHF_MERGE section might be referenced via a |
| 72 | // section symbol (as a hack for reducing the number of local |
| 73 | // symbols). |
Sean Silva | d4e6062 | 2017-03-01 04:44:04 | [diff] [blame] | 74 | // Depending on the addend, the reference via a section symbol |
| 75 | // refers to a different object in the merge section. |
| 76 | // Since the objects in the merge section are not necessarily |
| 77 | // contiguous in the output, the addend can thus affect the final |
| 78 | // VA in a non-linear way. |
| 79 | // To make this work, we incorporate the addend into the section |
| 80 | // offset (and zero out the addend for later processing) so that |
| 81 | // we find the right object in the section. |
Fangrui Song | a8024df | 2021-12-13 03:12:01 | [diff] [blame] | 82 | if (d.isSection()) |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 83 | offset += addend; |
Sean Silva | a9ba450 | 2017-02-28 08:32:56 | [diff] [blame] | 84 | |
Sean Silva | 6ab3926 | 2017-02-28 09:01:58 | [diff] [blame] | 85 | // In the typical case, this is actually very simple and boils |
| 86 | // down to adding together 3 numbers: |
| 87 | // 1. The address of the output section. |
| 88 | // 2. The offset of the input section within the output section. |
| 89 | // 3. The offset within the input section (this addition happens |
| 90 | // inside InputSection::getOffset). |
| 91 | // |
| 92 | // If you understand the data structures involved with this next |
| 93 | // line (and how they get built), then you have a pretty good |
| 94 | // understanding of the linker. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 95 | uint64_t va = isec->getVA(offset); |
Fangrui Song | a8024df | 2021-12-13 03:12:01 | [diff] [blame] | 96 | if (d.isSection()) |
| 97 | va -= addend; |
Sean Silva | 6ab3926 | 2017-02-28 09:01:58 | [diff] [blame] | 98 | |
Simon Atanasyan | fae2a509 | 2019-02-19 10:36:58 | [diff] [blame] | 99 | // MIPS relocatable files can mix regular and microMIPS code. |
| 100 | // Linker needs to distinguish such code. To do so microMIPS |
| 101 | // symbols has the `STO_MIPS_MICROMIPS` flag in the `st_other` |
Fangrui Song | deb5819 | 2020-01-23 05:39:16 | [diff] [blame] | 102 | // field. Unfortunately, the `MIPS::relocate()` method has |
Simon Atanasyan | fae2a509 | 2019-02-19 10:36:58 | [diff] [blame] | 103 | // a symbol value only. To pass type of the symbol (regular/microMIPS) |
| 104 | // to that routine as well as other places where we write |
| 105 | // a symbol value as-is (.dynamic section, `Elf_Ehdr::e_entry` |
| 106 | // field etc) do the same trick as compiler uses to mark microMIPS |
| 107 | // for CPU - set the less-significant bit. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 108 | if (config->emachine == EM_MIPS && isMicroMips() && |
Fangrui Song | cf783be | 2021-12-15 00:28:41 | [diff] [blame] | 109 | ((sym.stOther & STO_MIPS_MICROMIPS) || sym.needsCopy)) |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 110 | va |= 1; |
Simon Atanasyan | fae2a509 | 2019-02-19 10:36:58 | [diff] [blame] | 111 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 112 | if (d.isTls() && !config->relocatable) { |
Ryan Prichard | 1c33d14 | 2018-09-18 00:24:48 | [diff] [blame] | 113 | // Use the address of the TLS segment's first section rather than the |
| 114 | // segment's address, because segment addresses aren't initialized until |
| 115 | // after sections are finalized. (e.g. Measuring the size of .rela.dyn |
| 116 | // for Android relocation packing requires knowing TLS symbol addresses |
| 117 | // during section finalization.) |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 118 | if (!Out::tlsPhdr || !Out::tlsPhdr->firstSec) |
| 119 | fatal(toString(d.file) + |
Peter Collingbourne | 3e2abde | 2017-07-14 00:22:46 | [diff] [blame] | 120 | " has an STT_TLS symbol but doesn't have an SHF_TLS section"); |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 121 | return va - Out::tlsPhdr->firstSec->addr; |
George Rimar | 6a3b154 | 2016-10-04 08:52:51 | [diff] [blame] | 122 | } |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 123 | return va; |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 | [diff] [blame] | 124 | } |
Rafael Espindola | ab0cce5 | 2018-04-26 17:58:58 | [diff] [blame] | 125 | case Symbol::SharedKind: |
Rui Ueyama | f52496e | 2017-11-03 21:21:47 | [diff] [blame] | 126 | case Symbol::UndefinedKind: |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 | [diff] [blame] | 127 | return 0; |
Rui Ueyama | f52496e | 2017-11-03 21:21:47 | [diff] [blame] | 128 | case Symbol::LazyObjectKind: |
Fangrui Song | 935229f | 2022-01-05 08:46:48 | [diff] [blame] | 129 | llvm_unreachable("lazy symbol reached writer"); |
Rui Ueyama | 5c073a9 | 2019-05-16 03:29:03 | [diff] [blame] | 130 | case Symbol::CommonKind: |
| 131 | llvm_unreachable("common symbol reached writer"); |
Rui Ueyama | f3fad55 | 2018-10-12 18:29:18 | [diff] [blame] | 132 | case Symbol::PlaceholderKind: |
| 133 | llvm_unreachable("placeholder symbol reached writer"); |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 | [diff] [blame] | 134 | } |
George Rimar | 777f963 | 2016-03-12 08:31:34 | [diff] [blame] | 135 | llvm_unreachable("invalid symbol kind"); |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 | [diff] [blame] | 136 | } |
| 137 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 138 | uint64_t Symbol::getVA(int64_t addend) const { |
Fangrui Song | a8024df | 2021-12-13 03:12:01 | [diff] [blame] | 139 | return getSymVA(*this, addend) + addend; |
Rafael Espindola | 87d9f10 | 2016-03-11 12:19:05 | [diff] [blame] | 140 | } |
| 141 | |
Peter Collingbourne | 8331f61 | 2019-02-13 21:49:55 | [diff] [blame] | 142 | uint64_t Symbol::getGotVA() const { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 143 | if (gotInIgot) |
| 144 | return in.igotPlt->getVA() + getGotPltOffset(); |
| 145 | return in.got->getVA() + getGotOffset(); |
Peter Collingbourne | 8331f61 | 2019-02-13 21:49:55 | [diff] [blame] | 146 | } |
Rafael Espindola | 74031ba | 2016-04-07 15:20:56 | [diff] [blame] | 147 | |
Harald van Dijk | d624134 | 2021-05-16 23:13:00 | [diff] [blame] | 148 | uint64_t Symbol::getGotOffset() const { |
Fangrui Song | 5d3bd7f | 2022-01-09 21:43:26 | [diff] [blame] | 149 | return getGotIdx() * target->gotEntrySize; |
Harald van Dijk | d624134 | 2021-05-16 23:13:00 | [diff] [blame] | 150 | } |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 | [diff] [blame] | 151 | |
Rui Ueyama | f52496e | 2017-11-03 21:21:47 | [diff] [blame] | 152 | uint64_t Symbol::getGotPltVA() const { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 153 | if (isInIplt) |
| 154 | return in.igotPlt->getVA() + getGotPltOffset(); |
| 155 | return in.gotPlt->getVA() + getGotPltOffset(); |
Rafael Espindola | 74031ba | 2016-04-07 15:20:56 | [diff] [blame] | 156 | } |
| 157 | |
Rui Ueyama | f52496e | 2017-11-03 21:21:47 | [diff] [blame] | 158 | uint64_t Symbol::getGotPltOffset() const { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 159 | if (isInIplt) |
Fangrui Song | 5d3bd7f | 2022-01-09 21:43:26 | [diff] [blame] | 160 | return getPltIdx() * target->gotEntrySize; |
| 161 | return (getPltIdx() + target->gotPltHeaderEntriesNum) * target->gotEntrySize; |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 | [diff] [blame] | 162 | } |
| 163 | |
Rui Ueyama | f52496e | 2017-11-03 21:21:47 | [diff] [blame] | 164 | uint64_t Symbol::getPltVA() const { |
Fangrui Song | 891a865 | 2019-12-14 22:17:35 | [diff] [blame] | 165 | uint64_t outVA = isInIplt |
Fangrui Song | 5d3bd7f | 2022-01-09 21:43:26 | [diff] [blame] | 166 | ? in.iplt->getVA() + getPltIdx() * target->ipltEntrySize |
Fangrui Song | 891a865 | 2019-12-14 22:17:35 | [diff] [blame] | 167 | : in.plt->getVA() + in.plt->headerSize + |
Fangrui Song | 5d3bd7f | 2022-01-09 21:43:26 | [diff] [blame] | 168 | getPltIdx() * target->pltEntrySize; |
Fangrui Song | 891a865 | 2019-12-14 22:17:35 | [diff] [blame] | 169 | |
Simon Atanasyan | fae2a509 | 2019-02-19 10:36:58 | [diff] [blame] | 170 | // While linking microMIPS code PLT code are always microMIPS |
| 171 | // code. Set the less-significant bit to track that fact. |
| 172 | // See detailed comment in the `getSymVA` function. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 173 | if (config->emachine == EM_MIPS && isMicroMips()) |
| 174 | outVA |= 1; |
| 175 | return outVA; |
Rafael Espindola | ab0cce5 | 2018-04-26 17:58:58 | [diff] [blame] | 176 | } |
| 177 | |
Rui Ueyama | f52496e | 2017-11-03 21:21:47 | [diff] [blame] | 178 | uint64_t Symbol::getSize() const { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 179 | if (const auto *dr = dyn_cast<Defined>(this)) |
| 180 | return dr->size; |
| 181 | return cast<SharedSymbol>(this)->size; |
Rui Ueyama | 512c61d | 2016-02-03 00:12:24 | [diff] [blame] | 182 | } |
| 183 | |
Rui Ueyama | f52496e | 2017-11-03 21:21:47 | [diff] [blame] | 184 | OutputSection *Symbol::getOutputSection() const { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 185 | if (auto *s = dyn_cast<Defined>(this)) { |
| 186 | if (auto *sec = s->section) |
Fangrui Song | c2f2bb0 | 2021-12-21 08:39:16 | [diff] [blame] | 187 | return sec->getOutputSection(); |
Rui Ueyama | 968db48 | 2017-02-28 04:02:42 | [diff] [blame] | 188 | return nullptr; |
| 189 | } |
Rui Ueyama | 968db48 | 2017-02-28 04:02:42 | [diff] [blame] | 190 | return nullptr; |
| 191 | } |
| 192 | |
Rui Ueyama | 35fa6c5 | 2016-11-23 05:48:40 | [diff] [blame] | 193 | // If a symbol name contains '@', the characters after that is |
| 194 | // a symbol version name. This function parses that. |
Rui Ueyama | f52496e | 2017-11-03 21:21:47 | [diff] [blame] | 195 | void Symbol::parseSymbolVersion() { |
Fangrui Song | 00809c8 | 2021-08-05 06:52:55 | [diff] [blame] | 196 | // Return if localized by a local: pattern in a version script. |
| 197 | if (versionId == VER_NDX_LOCAL) |
| 198 | return; |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 199 | StringRef s = getName(); |
| 200 | size_t pos = s.find('@'); |
Fangrui Song | 101407b | 2021-12-16 07:59:55 | [diff] [blame] | 201 | if (pos == StringRef::npos) |
Rui Ueyama | 35fa6c5 | 2016-11-23 05:48:40 | [diff] [blame] | 202 | return; |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 203 | StringRef verstr = s.substr(pos + 1); |
Rui Ueyama | 35fa6c5 | 2016-11-23 05:48:40 | [diff] [blame] | 204 | |
| 205 | // Truncate the symbol name so that it doesn't include the version string. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 206 | nameSize = pos; |
Rui Ueyama | 35fa6c5 | 2016-11-23 05:48:40 | [diff] [blame] | 207 | |
Fangrui Song | 7924b38 | 2021-12-27 01:25:54 | [diff] [blame] | 208 | if (verstr.empty()) |
| 209 | return; |
| 210 | |
Rafael Espindola | 1d6d1b4 | 2017-01-17 16:08:06 | [diff] [blame] | 211 | // If this is not in this DSO, it is not a definition. |
Peter Collingbourne | b472aa0 | 2017-11-06 04:39:07 | [diff] [blame] | 212 | if (!isDefined()) |
Rafael Espindola | 2756e04 | 2017-01-06 22:30:35 | [diff] [blame] | 213 | return; |
| 214 | |
Rui Ueyama | 35fa6c5 | 2016-11-23 05:48:40 | [diff] [blame] | 215 | // '@@' in a symbol name means the default version. |
| 216 | // It is usually the most recent one. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 217 | bool isDefault = (verstr[0] == '@'); |
| 218 | if (isDefault) |
| 219 | verstr = verstr.substr(1); |
Rui Ueyama | 35fa6c5 | 2016-11-23 05:48:40 | [diff] [blame] | 220 | |
Fangrui Song | e28a70d | 2019-08-05 14:31:39 | [diff] [blame] | 221 | for (const VersionDefinition &ver : namedVersionDefs()) { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 222 | if (ver.name != verstr) |
Rui Ueyama | 35fa6c5 | 2016-11-23 05:48:40 | [diff] [blame] | 223 | continue; |
| 224 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 225 | if (isDefault) |
| 226 | versionId = ver.id; |
Rui Ueyama | 35fa6c5 | 2016-11-23 05:48:40 | [diff] [blame] | 227 | else |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 228 | versionId = ver.id | VERSYM_HIDDEN; |
Rui Ueyama | 35fa6c5 | 2016-11-23 05:48:40 | [diff] [blame] | 229 | return; |
| 230 | } |
| 231 | |
| 232 | // It is an error if the specified version is not defined. |
George Rimar | 4d2f9762 | 2017-07-04 13:19:13 | [diff] [blame] | 233 | // Usually version script is not provided when linking executable, |
| 234 | // but we may still want to override a versioned symbol from DSO, |
Peter Smith | 796fb99 | 2018-05-14 10:13:56 | [diff] [blame] | 235 | // so we do not report error in this case. We also do not error |
| 236 | // if the symbol has a local version as it won't be in the dynamic |
| 237 | // symbol table. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 238 | if (config->shared && versionId != VER_NDX_LOCAL) |
| 239 | error(toString(file) + ": symbol " + s + " has undefined version " + |
| 240 | verstr); |
Rui Ueyama | 35fa6c5 | 2016-11-23 05:48:40 | [diff] [blame] | 241 | } |
| 242 | |
Fangrui Song | 09401df | 2021-11-26 18:58:50 | [diff] [blame] | 243 | void Symbol::extract() const { |
Fangrui Song | 3d85424 | 2022-02-15 17:38:00 | [diff] [blame] | 244 | if (file->lazy) { |
Fangrui Song | 3a5fb57 | 2021-12-23 01:41:50 | [diff] [blame] | 245 | file->lazy = false; |
| 246 | parseFile(file); |
| 247 | } |
Rui Ueyama | 7d47619 | 2019-05-16 02:14:00 | [diff] [blame] | 248 | } |
Rui Ueyama | f8baa66 | 2016-04-07 19:24:51 | [diff] [blame] | 249 | |
Rui Ueyama | f52496e | 2017-11-03 21:21:47 | [diff] [blame] | 250 | uint8_t Symbol::computeBinding() const { |
Fangrui Song | cfdd458 | 2019-08-11 17:03:00 | [diff] [blame] | 251 | if ((visibility != STV_DEFAULT && visibility != STV_PROTECTED) || |
Fangrui Song | 9e885ea | 2022-01-16 07:58:15 | [diff] [blame] | 252 | versionId == VER_NDX_LOCAL) |
Rafael Espindola | b7e2ee2 | 2017-01-10 17:08:13 | [diff] [blame] | 253 | return STB_LOCAL; |
Fangrui Song | b3cc470 | 2022-01-16 07:40:43 | [diff] [blame] | 254 | if (binding == STB_GNU_UNIQUE && !config->gnuUnique) |
Rafael Espindola | b7e2ee2 | 2017-01-10 17:08:13 | [diff] [blame] | 255 | return STB_GLOBAL; |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 256 | return binding; |
Rafael Espindola | b7e2ee2 | 2017-01-10 17:08:13 | [diff] [blame] | 257 | } |
| 258 | |
Rui Ueyama | f52496e | 2017-11-03 21:21:47 | [diff] [blame] | 259 | bool Symbol::includeInDynsym() const { |
Rafael Espindola | b7e2ee2 | 2017-01-10 17:08:13 | [diff] [blame] | 260 | if (computeBinding() == STB_LOCAL) |
Rafael Espindola | ae605c1 | 2016-04-21 20:35:25 | [diff] [blame] | 261 | return false; |
Fangrui Song | 375371c | 2020-01-09 23:53:52 | [diff] [blame] | 262 | if (!isDefined() && !isCommon()) |
Fangrui Song | 0fbf28f | 2020-01-23 19:52:03 | [diff] [blame] | 263 | // This should unconditionally return true, unfortunately glibc -static-pie |
| 264 | // expects undefined weak symbols not to exist in .dynsym, e.g. |
| 265 | // __pthread_mutex_lock reference in _dl_add_to_namespace_list, |
| 266 | // __pthread_initialize_minimal reference in csu/libc-start.c. |
Fangrui Song | 01a5162 | 2022-01-16 07:32:48 | [diff] [blame] | 267 | return !(isUndefWeak() && config->noDynamicLinker); |
Rui Ueyama | e63ae7f | 2019-06-25 06:58:07 | [diff] [blame] | 268 | |
Fangrui Song | 375371c | 2020-01-09 23:53:52 | [diff] [blame] | 269 | return exportDynamic || inDynamicList; |
Rafael Espindola | ae605c1 | 2016-04-21 20:35:25 | [diff] [blame] | 270 | } |
Rui Ueyama | 69c778c | 2016-07-17 17:50:09 | [diff] [blame] | 271 | |
| 272 | // Print out a log message for --trace-symbol. |
Fangrui Song | 977a1a5 | 2022-02-06 00:34:02 | [diff] [blame] | 273 | void elf::printTraceSymbol(const Symbol &sym, StringRef name) { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 274 | std::string s; |
Fangrui Song | 977a1a5 | 2022-02-06 00:34:02 | [diff] [blame] | 275 | if (sym.isUndefined()) |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 276 | s = ": reference to "; |
Fangrui Song | 977a1a5 | 2022-02-06 00:34:02 | [diff] [blame] | 277 | else if (sym.isLazy()) |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 278 | s = ": lazy definition of "; |
Fangrui Song | 977a1a5 | 2022-02-06 00:34:02 | [diff] [blame] | 279 | else if (sym.isShared()) |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 280 | s = ": shared definition of "; |
Fangrui Song | 977a1a5 | 2022-02-06 00:34:02 | [diff] [blame] | 281 | else if (sym.isCommon()) |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 282 | s = ": common definition of "; |
Rui Ueyama | 69c778c | 2016-07-17 17:50:09 | [diff] [blame] | 283 | else |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 284 | s = ": definition of "; |
Rui Ueyama | e6e206d | 2017-02-21 23:22:56 | [diff] [blame] | 285 | |
Fangrui Song | 977a1a5 | 2022-02-06 00:34:02 | [diff] [blame] | 286 | message(toString(sym.file) + s + name); |
Rui Ueyama | 69c778c | 2016-07-17 17:50:09 | [diff] [blame] | 287 | } |
| 288 | |
Fangrui Song | a954bb1 | 2021-09-20 16:52:30 | [diff] [blame] | 289 | static void recordWhyExtract(const InputFile *reference, |
| 290 | const InputFile &extracted, const Symbol &sym) { |
| 291 | whyExtract.emplace_back(toString(reference), &extracted, sym); |
| 292 | } |
| 293 | |
Fangrui Song | 07837b8 | 2020-05-15 05:18:58 | [diff] [blame] | 294 | void elf::maybeWarnUnorderableSymbol(const Symbol *sym) { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 295 | if (!config->warnSymbolOrdering) |
Michael J. Spencer | b842725 | 2018-04-17 23:30:05 | [diff] [blame] | 296 | return; |
Rui Ueyama | b774c3c | 2018-04-26 01:38:29 | [diff] [blame] | 297 | |
Fangrui Song | 11ca54f | 2018-10-10 22:48:57 | [diff] [blame] | 298 | // If UnresolvedPolicy::Ignore is used, no "undefined symbol" error/warning |
| 299 | // is emitted. It makes sense to not warn on undefined symbols. |
| 300 | // |
| 301 | // Note, ld.bfd --symbol-ordering-file= does not warn on undefined symbols, |
| 302 | // but we don't have to be compatible here. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 303 | if (sym->isUndefined() && |
| 304 | config->unresolvedSymbols == UnresolvedPolicy::Ignore) |
Fangrui Song | 11ca54f | 2018-10-10 22:48:57 | [diff] [blame] | 305 | return; |
| 306 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 307 | const InputFile *file = sym->file; |
| 308 | auto *d = dyn_cast<Defined>(sym); |
Rui Ueyama | b774c3c | 2018-04-26 01:38:29 | [diff] [blame] | 309 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 310 | auto report = [&](StringRef s) { warn(toString(file) + s + sym->getName()); }; |
Rui Ueyama | b774c3c | 2018-04-26 01:38:29 | [diff] [blame] | 311 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 312 | if (sym->isUndefined()) |
| 313 | report(": unable to order undefined symbol: "); |
| 314 | else if (sym->isShared()) |
| 315 | report(": unable to order shared symbol: "); |
| 316 | else if (d && !d->section) |
| 317 | report(": unable to order absolute symbol: "); |
| 318 | else if (d && isa<OutputSection>(d->section)) |
| 319 | report(": unable to order synthetic symbol: "); |
Fangrui Song | e1b6b5b | 2021-12-24 20:09:48 | [diff] [blame] | 320 | else if (d && !d->section->isLive()) |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 321 | report(": unable to order discarded symbol: "); |
Michael J. Spencer | b842725 | 2018-04-17 23:30:05 | [diff] [blame] | 322 | } |
| 323 | |
Fangrui Song | cd0ab24 | 2019-11-30 05:58:36 | [diff] [blame] | 324 | // Returns true if a symbol can be replaced at load-time by a symbol |
| 325 | // with the same name defined in other ELF executable or DSO. |
Fangrui Song | 07837b8 | 2020-05-15 05:18:58 | [diff] [blame] | 326 | bool elf::computeIsPreemptible(const Symbol &sym) { |
Fangrui Song | e9262ed | 2021-12-27 02:11:45 | [diff] [blame] | 327 | assert(!sym.isLocal() || sym.isPlaceholder()); |
Fangrui Song | cd0ab24 | 2019-11-30 05:58:36 | [diff] [blame] | 328 | |
| 329 | // Only symbols with default visibility that appear in dynsym can be |
| 330 | // preempted. Symbols with protected visibility cannot be preempted. |
| 331 | if (!sym.includeInDynsym() || sym.visibility != STV_DEFAULT) |
| 332 | return false; |
| 333 | |
| 334 | // At this point copy relocations have not been created yet, so any |
| 335 | // symbol that is not defined locally is preemptible. |
| 336 | if (!sym.isDefined()) |
| 337 | return true; |
| 338 | |
| 339 | if (!config->shared) |
| 340 | return false; |
| 341 | |
Fangrui Song | 751f18e | 2020-06-01 18:27:53 | [diff] [blame] | 342 | // If -Bsymbolic or --dynamic-list is specified, or -Bsymbolic-functions is |
| 343 | // specified and the symbol is STT_FUNC, the symbol is preemptible iff it is |
Fangrui Song | b06426d | 2021-07-29 21:46:53 | [diff] [blame] | 344 | // in the dynamic list. -Bsymbolic-non-weak-functions is a non-weak subset of |
| 345 | // -Bsymbolic-functions. |
| 346 | if (config->symbolic || |
| 347 | (config->bsymbolic == BsymbolicKind::Functions && sym.isFunc()) || |
| 348 | (config->bsymbolic == BsymbolicKind::NonWeakFunctions && sym.isFunc() && |
| 349 | sym.binding != STB_WEAK)) |
Fangrui Song | cd0ab24 | 2019-11-30 05:58:36 | [diff] [blame] | 350 | return sym.inDynamicList; |
Fangrui Song | cd0ab24 | 2019-11-30 05:58:36 | [diff] [blame] | 351 | return true; |
| 352 | } |
| 353 | |
Fangrui Song | 07837b8 | 2020-05-15 05:18:58 | [diff] [blame] | 354 | void elf::reportBackrefs() { |
Fangrui Song | 03c825c | 2020-04-06 05:27:46 | [diff] [blame] | 355 | for (auto &it : backwardReferences) { |
| 356 | const Symbol &sym = *it.first; |
Fangrui Song | 3ba33422 | 2020-11-08 04:17:41 | [diff] [blame] | 357 | std::string to = toString(it.second.second); |
| 358 | // Some libraries have known problems and can cause noise. Filter them out |
| 359 | // with --warn-backrefs-exclude=. to may look like *.o or *.a(*.o). |
| 360 | bool exclude = false; |
| 361 | for (const llvm::GlobPattern &pat : config->warnBackrefsExclude) |
| 362 | if (pat.match(to)) { |
| 363 | exclude = true; |
| 364 | break; |
| 365 | } |
| 366 | if (!exclude) |
| 367 | warn("backward reference detected: " + sym.getName() + " in " + |
| 368 | toString(it.second.first) + " refers to " + to); |
Fangrui Song | 03c825c | 2020-04-06 05:27:46 | [diff] [blame] | 369 | } |
| 370 | } |
| 371 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 372 | static uint8_t getMinVisibility(uint8_t va, uint8_t vb) { |
| 373 | if (va == STV_DEFAULT) |
| 374 | return vb; |
| 375 | if (vb == STV_DEFAULT) |
| 376 | return va; |
| 377 | return std::min(va, vb); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 378 | } |
| 379 | |
| 380 | // Merge symbol properties. |
| 381 | // |
| 382 | // When we have many symbols of the same name, we choose one of them, |
| 383 | // and that's the result of symbol resolution. However, symbols that |
| 384 | // were not chosen still affect some symbol properties. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 385 | void Symbol::mergeProperties(const Symbol &other) { |
| 386 | if (other.exportDynamic) |
| 387 | exportDynamic = true; |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 388 | |
| 389 | // DSO symbols do not affect visibility in the output. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 390 | if (!other.isShared()) |
| 391 | visibility = getMinVisibility(visibility, other.visibility); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 392 | } |
| 393 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 394 | void Symbol::resolve(const Symbol &other) { |
| 395 | mergeProperties(other); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 396 | |
| 397 | if (isPlaceholder()) { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 398 | replace(other); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 399 | return; |
| 400 | } |
| 401 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 402 | switch (other.kind()) { |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 403 | case Symbol::UndefinedKind: |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 404 | resolveUndefined(cast<Undefined>(other)); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 405 | break; |
| 406 | case Symbol::CommonKind: |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 407 | resolveCommon(cast<CommonSymbol>(other)); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 408 | break; |
| 409 | case Symbol::DefinedKind: |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 410 | resolveDefined(cast<Defined>(other)); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 411 | break; |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 412 | case Symbol::LazyObjectKind: |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 413 | resolveLazy(cast<LazyObject>(other)); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 414 | break; |
| 415 | case Symbol::SharedKind: |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 416 | resolveShared(cast<SharedSymbol>(other)); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 417 | break; |
| 418 | case Symbol::PlaceholderKind: |
| 419 | llvm_unreachable("bad symbol kind"); |
| 420 | } |
| 421 | } |
| 422 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 423 | void Symbol::resolveUndefined(const Undefined &other) { |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 424 | // An undefined symbol with non default visibility must be satisfied |
| 425 | // in the same DSO. |
| 426 | // |
| 427 | // If this is a non-weak defined symbol in a discarded section, override the |
| 428 | // existing undefined symbol for better error message later. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 429 | if ((isShared() && other.visibility != STV_DEFAULT) || |
| 430 | (isUndefined() && other.binding != STB_WEAK && other.discardedSecIdx)) { |
| 431 | replace(other); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 432 | return; |
| 433 | } |
| 434 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 435 | if (traced) |
Fangrui Song | 977a1a5 | 2022-02-06 00:34:02 | [diff] [blame] | 436 | printTraceSymbol(other, getName()); |
Sam Clegg | 7991b68 | 2019-05-24 13:29:17 | [diff] [blame] | 437 | |
Fangrui Song | f347541 | 2019-07-04 10:38:04 | [diff] [blame] | 438 | if (isLazy()) { |
Fangrui Song | 09401df | 2021-11-26 18:58:50 | [diff] [blame] | 439 | // An undefined weak will not extract archive members. See comment on Lazy |
| 440 | // in Symbols.h for the details. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 441 | if (other.binding == STB_WEAK) { |
| 442 | binding = STB_WEAK; |
| 443 | type = other.type; |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 444 | return; |
| 445 | } |
| 446 | |
| 447 | // Do extra check for --warn-backrefs. |
| 448 | // |
| 449 | // --warn-backrefs is an option to prevent an undefined reference from |
Fangrui Song | 09401df | 2021-11-26 18:58:50 | [diff] [blame] | 450 | // extracting an archive member written earlier in the command line. It can |
| 451 | // be used to keep compatibility with GNU linkers to some degree. I'll |
| 452 | // explain the feature and why you may find it useful in this comment. |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 453 | // |
| 454 | // lld's symbol resolution semantics is more relaxed than traditional Unix |
| 455 | // linkers. For example, |
| 456 | // |
| 457 | // ld.lld foo.a bar.o |
| 458 | // |
| 459 | // succeeds even if bar.o contains an undefined symbol that has to be |
| 460 | // resolved by some object file in foo.a. Traditional Unix linkers don't |
| 461 | // allow this kind of backward reference, as they visit each file only once |
| 462 | // from left to right in the command line while resolving all undefined |
| 463 | // symbols at the moment of visiting. |
| 464 | // |
| 465 | // In the above case, since there's no undefined symbol when a linker visits |
| 466 | // foo.a, no files are pulled out from foo.a, and because the linker forgets |
| 467 | // about foo.a after visiting, it can't resolve undefined symbols in bar.o |
| 468 | // that could have been resolved otherwise. |
| 469 | // |
| 470 | // That lld accepts more relaxed form means that (besides it'd make more |
| 471 | // sense) you can accidentally write a command line or a build file that |
| 472 | // works only with lld, even if you have a plan to distribute it to wider |
| 473 | // users who may be using GNU linkers. With --warn-backrefs, you can detect |
| 474 | // a library order that doesn't work with other Unix linkers. |
| 475 | // |
| 476 | // The option is also useful to detect cyclic dependencies between static |
| 477 | // archives. Again, lld accepts |
| 478 | // |
| 479 | // ld.lld foo.a bar.a |
| 480 | // |
| 481 | // even if foo.a and bar.a depend on each other. With --warn-backrefs, it is |
| 482 | // handled as an error. |
| 483 | // |
| 484 | // Here is how the option works. We assign a group ID to each file. A file |
| 485 | // with a smaller group ID can pull out object files from an archive file |
| 486 | // with an equal or greater group ID. Otherwise, it is a reverse dependency |
| 487 | // and an error. |
| 488 | // |
| 489 | // A file outside --{start,end}-group gets a fresh ID when instantiated. All |
| 490 | // files within the same --{start,end}-group get the same group ID. E.g. |
| 491 | // |
| 492 | // ld.lld A B --start-group C D --end-group E |
| 493 | // |
| 494 | // A forms group 0. B form group 1. C and D (including their member object |
| 495 | // files) form group 2. E forms group 3. I think that you can see how this |
| 496 | // group assignment rule simulates the traditional linker's semantics. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 497 | bool backref = config->warnBackrefs && other.file && |
| 498 | file->groupId < other.file->groupId; |
Fangrui Song | 09401df | 2021-11-26 18:58:50 | [diff] [blame] | 499 | extract(); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 500 | |
Fangrui Song | a954bb1 | 2021-09-20 16:52:30 | [diff] [blame] | 501 | if (!config->whyExtract.empty()) |
| 502 | recordWhyExtract(other.file, *file, *this); |
| 503 | |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 504 | // We don't report backward references to weak symbols as they can be |
| 505 | // overridden later. |
Fangrui Song | 03c825c | 2020-04-06 05:27:46 | [diff] [blame] | 506 | // |
| 507 | // A traditional linker does not error for -ldef1 -lref -ldef2 (linking |
| 508 | // sandwich), where def2 may or may not be the same as def1. We don't want |
| 509 | // to warn for this case, so dismiss the warning if we see a subsequent lazy |
Fangrui Song | ce3c5da | 2020-10-22 22:26:52 | [diff] [blame] | 510 | // definition. this->file needs to be saved because in the case of LTO it |
| 511 | // may be reset to nullptr or be replaced with a file named lto.tmp. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 512 | if (backref && !isWeak()) |
Fangrui Song | ce3c5da | 2020-10-22 22:26:52 | [diff] [blame] | 513 | backwardReferences.try_emplace(this, std::make_pair(other.file, file)); |
Fangrui Song | f347541 | 2019-07-04 10:38:04 | [diff] [blame] | 514 | return; |
| 515 | } |
| 516 | |
| 517 | // Undefined symbols in a SharedFile do not change the binding. |
Kazu Hirata | 62e48ed | 2021-12-25 05:22:27 | [diff] [blame] | 518 | if (isa_and_nonnull<SharedFile>(other.file)) |
Fangrui Song | f347541 | 2019-07-04 10:38:04 | [diff] [blame] | 519 | return; |
| 520 | |
Fangrui Song | e49c417 | 2019-08-06 14:03:45 | [diff] [blame] | 521 | if (isUndefined() || isShared()) { |
| 522 | // The binding will be weak if there is at least one reference and all are |
| 523 | // weak. The binding has one opportunity to change to weak: if the first |
| 524 | // reference is weak. |
| 525 | if (other.binding != STB_WEAK || !referenced) |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 526 | binding = other.binding; |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 527 | } |
| 528 | } |
| 529 | |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 530 | // Compare two symbols. Return 1 if the new symbol should win, -1 if |
| 531 | // the new symbol should lose, or 0 if there is a conflict. |
Fangrui Song | 6d94340 | 2022-02-24 22:08:06 | [diff] [blame^] | 532 | bool Symbol::compare(const Defined &other) const { |
| 533 | if (LLVM_UNLIKELY(isCommon())) { |
| 534 | if (config->warnCommon) |
| 535 | warn("common " + getName() + " is overridden"); |
| 536 | return !other.isWeak(); |
| 537 | } |
| 538 | if (!isDefined()) |
| 539 | return true; |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 540 | |
Fangrui Song | 2bdad16 | 2021-12-15 23:19:35 | [diff] [blame] | 541 | // .symver foo,foo@@VER unfortunately creates two defined symbols: foo and |
| 542 | // foo@@VER. In GNU ld, if foo and foo@@VER are in the same file, foo is |
| 543 | // ignored. In our implementation, when this is foo, this->getName() may still |
Fangrui Song | 6d94340 | 2022-02-24 22:08:06 | [diff] [blame^] | 544 | // contain @@, return true in this case as well. |
| 545 | if (LLVM_UNLIKELY(file == other.file)) { |
| 546 | if (other.getName().contains("@@")) |
| 547 | return true; |
Fangrui Song | 2bdad16 | 2021-12-15 23:19:35 | [diff] [blame] | 548 | if (getName().contains("@@")) |
Fangrui Song | 6d94340 | 2022-02-24 22:08:06 | [diff] [blame^] | 549 | return false; |
Fangrui Song | 2bdad16 | 2021-12-15 23:19:35 | [diff] [blame] | 550 | } |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 551 | |
Fangrui Song | 6d94340 | 2022-02-24 22:08:06 | [diff] [blame^] | 552 | return isWeak() && !other.isWeak(); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 553 | } |
| 554 | |
Fangrui Song | 88d66f6 | 2022-02-22 18:07:58 | [diff] [blame] | 555 | void elf::reportDuplicate(const Symbol &sym, InputFile *newFile, |
| 556 | InputSectionBase *errSec, uint64_t errOffset) { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 557 | if (config->allowMultipleDefinition) |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 558 | return; |
Fangrui Song | 467e1b3 | 2022-02-15 19:18:31 | [diff] [blame] | 559 | const Defined *d = cast<Defined>(&sym); |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 560 | if (!d->section || !errSec) { |
Fangrui Song | 467e1b3 | 2022-02-15 19:18:31 | [diff] [blame] | 561 | error("duplicate symbol: " + toString(sym) + "\n>>> defined in " + |
| 562 | toString(sym.file) + "\n>>> defined in " + toString(newFile)); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 563 | return; |
| 564 | } |
| 565 | |
| 566 | // Construct and print an error message in the form of: |
| 567 | // |
| 568 | // ld.lld: error: duplicate symbol: foo |
| 569 | // >>> defined at bar.c:30 |
| 570 | // >>> bar.o (/home/alice/src/bar.o) |
| 571 | // >>> defined at baz.c:563 |
| 572 | // >>> baz.o in archive libbaz.a |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 573 | auto *sec1 = cast<InputSectionBase>(d->section); |
Fangrui Song | 467e1b3 | 2022-02-15 19:18:31 | [diff] [blame] | 574 | std::string src1 = sec1->getSrcMsg(sym, d->value); |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 575 | std::string obj1 = sec1->getObjMsg(d->value); |
Fangrui Song | 467e1b3 | 2022-02-15 19:18:31 | [diff] [blame] | 576 | std::string src2 = errSec->getSrcMsg(sym, errOffset); |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 577 | std::string obj2 = errSec->getObjMsg(errOffset); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 578 | |
Fangrui Song | 467e1b3 | 2022-02-15 19:18:31 | [diff] [blame] | 579 | std::string msg = "duplicate symbol: " + toString(sym) + "\n>>> defined at "; |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 580 | if (!src1.empty()) |
| 581 | msg += src1 + "\n>>> "; |
| 582 | msg += obj1 + "\n>>> defined at "; |
| 583 | if (!src2.empty()) |
| 584 | msg += src2 + "\n>>> "; |
| 585 | msg += obj2; |
| 586 | error(msg); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 587 | } |
| 588 | |
Fangrui Song | 88d66f6 | 2022-02-22 18:07:58 | [diff] [blame] | 589 | void Symbol::checkDuplicate(const Defined &other) const { |
Fangrui Song | 6d94340 | 2022-02-24 22:08:06 | [diff] [blame^] | 590 | if (isDefined() && !isWeak() && !other.isWeak()) |
Fangrui Song | 88d66f6 | 2022-02-22 18:07:58 | [diff] [blame] | 591 | reportDuplicate(*this, other.file, |
| 592 | dyn_cast_or_null<InputSectionBase>(other.section), |
| 593 | other.value); |
| 594 | } |
| 595 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 596 | void Symbol::resolveCommon(const CommonSymbol &other) { |
Fangrui Song | 6d94340 | 2022-02-24 22:08:06 | [diff] [blame^] | 597 | if (isDefined() && !isWeak()) { |
| 598 | if (config->warnCommon) |
| 599 | warn("common " + getName() + " is overridden"); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 600 | return; |
Fangrui Song | 6d94340 | 2022-02-24 22:08:06 | [diff] [blame^] | 601 | } |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 602 | |
Fangrui Song | 6d94340 | 2022-02-24 22:08:06 | [diff] [blame^] | 603 | if (CommonSymbol *oldSym = dyn_cast<CommonSymbol>(this)) { |
| 604 | if (config->warnCommon) |
| 605 | warn("multiple common of " + getName()); |
| 606 | oldSym->alignment = std::max(oldSym->alignment, other.alignment); |
| 607 | if (oldSym->size < other.size) { |
| 608 | oldSym->file = other.file; |
| 609 | oldSym->size = other.size; |
Fangrui Song | 69d10d2 | 2019-12-07 05:18:31 | [diff] [blame] | 610 | } |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 611 | return; |
| 612 | } |
| 613 | |
Fangrui Song | 6d94340 | 2022-02-24 22:08:06 | [diff] [blame^] | 614 | if (auto *s = dyn_cast<SharedSymbol>(this)) { |
| 615 | // Increase st_size if the shared symbol has a larger st_size. The shared |
| 616 | // symbol may be created from common symbols. The fact that some object |
| 617 | // files were linked into a shared object first should not change the |
| 618 | // regular rule that picks the largest st_size. |
| 619 | uint64_t size = s->size; |
| 620 | replace(other); |
| 621 | if (size > cast<CommonSymbol>(this)->size) |
| 622 | cast<CommonSymbol>(this)->size = size; |
| 623 | } else { |
| 624 | replace(other); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 625 | } |
| 626 | } |
| 627 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 628 | void Symbol::resolveDefined(const Defined &other) { |
Fangrui Song | 6d94340 | 2022-02-24 22:08:06 | [diff] [blame^] | 629 | if (compare(other)) |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 630 | replace(other); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 631 | } |
| 632 | |
Fangrui Song | 4129890 | 2022-02-24 20:20:05 | [diff] [blame] | 633 | void Symbol::resolveLazy(const LazyObject &other) { |
Sean Fertile | 8f91f38 | 2020-12-07 14:28:17 | [diff] [blame] | 634 | // For common objects, we want to look for global or weak definitions that |
Fangrui Song | 09401df | 2021-11-26 18:58:50 | [diff] [blame] | 635 | // should be extracted as the canonical definition instead. |
Fangrui Song | 15617cd | 2022-02-24 20:21:40 | [diff] [blame] | 636 | if (LLVM_UNLIKELY(isCommon()) && elf::config->fortranCommon && |
| 637 | other.file->shouldExtractForCommon(getName())) { |
| 638 | backwardReferences.erase(this); |
| 639 | replace(other); |
| 640 | other.extract(); |
| 641 | return; |
Sean Fertile | 8f91f38 | 2020-12-07 14:28:17 | [diff] [blame] | 642 | } |
| 643 | |
Fangrui Song | 03c825c | 2020-04-06 05:27:46 | [diff] [blame] | 644 | if (!isUndefined()) { |
| 645 | // See the comment in resolveUndefined(). |
| 646 | if (isDefined()) |
| 647 | backwardReferences.erase(this); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 648 | return; |
Fangrui Song | 03c825c | 2020-04-06 05:27:46 | [diff] [blame] | 649 | } |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 650 | |
Fangrui Song | 09401df | 2021-11-26 18:58:50 | [diff] [blame] | 651 | // An undefined weak will not extract archive members. See comment on Lazy in |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 652 | // Symbols.h for the details. |
| 653 | if (isWeak()) { |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 654 | uint8_t ty = type; |
| 655 | replace(other); |
| 656 | type = ty; |
| 657 | binding = STB_WEAK; |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 658 | return; |
| 659 | } |
| 660 | |
Fangrui Song | a954bb1 | 2021-09-20 16:52:30 | [diff] [blame] | 661 | const InputFile *oldFile = file; |
Fangrui Song | 09401df | 2021-11-26 18:58:50 | [diff] [blame] | 662 | other.extract(); |
Fangrui Song | a954bb1 | 2021-09-20 16:52:30 | [diff] [blame] | 663 | if (!config->whyExtract.empty()) |
| 664 | recordWhyExtract(oldFile, *file, *this); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 665 | } |
| 666 | |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 667 | void Symbol::resolveShared(const SharedSymbol &other) { |
Fangrui Song | 69d10d2 | 2019-12-07 05:18:31 | [diff] [blame] | 668 | if (isCommon()) { |
| 669 | // See the comment in resolveCommon() above. |
| 670 | if (other.size > cast<CommonSymbol>(this)->size) |
| 671 | cast<CommonSymbol>(this)->size = other.size; |
| 672 | return; |
| 673 | } |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 674 | if (visibility == STV_DEFAULT && (isUndefined() || isLazy())) { |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 675 | // An undefined symbol with non default visibility must be satisfied |
| 676 | // in the same DSO. |
Rui Ueyama | 3837f42 | 2019-07-10 05:00:37 | [diff] [blame] | 677 | uint8_t bind = binding; |
| 678 | replace(other); |
| 679 | binding = bind; |
Fangrui Song | 6467649 | 2020-05-18 17:15:59 | [diff] [blame] | 680 | } else if (traced) |
Fangrui Song | 977a1a5 | 2022-02-06 00:34:02 | [diff] [blame] | 681 | printTraceSymbol(other, getName()); |
Rui Ueyama | 7f7d2b2 | 2019-05-23 09:58:08 | [diff] [blame] | 682 | } |