Michael J. Spencer | 84487f1 | 2015-07-24 21:03:07 +0000 | [diff] [blame] | 1 | //===- Symbols.cpp --------------------------------------------------------===// |
| 2 | // |
| 3 | // The LLVM Linker |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
| 10 | #include "Symbols.h" |
Rafael Espindola | 49a2ca6 | 2015-08-06 15:33:19 +0000 | [diff] [blame] | 11 | #include "Error.h" |
Michael J. Spencer | cdae0a4 | 2015-07-28 22:58:25 +0000 | [diff] [blame] | 12 | #include "InputFiles.h" |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 13 | #include "InputSection.h" |
| 14 | #include "OutputSections.h" |
| 15 | #include "Target.h" |
Michael J. Spencer | 84487f1 | 2015-07-24 21:03:07 +0000 | [diff] [blame] | 16 | |
Michael J. Spencer | 1b348a6 | 2015-09-04 22:28:10 +0000 | [diff] [blame] | 17 | #include "llvm/ADT/STLExtras.h" |
Rui Ueyama | a4a628f | 2016-01-13 18:55:39 +0000 | [diff] [blame] | 18 | #include "llvm/Config/config.h" |
| 19 | |
| 20 | #ifdef HAVE_CXXABI_H |
| 21 | #include <cxxabi.h> |
| 22 | #endif |
Michael J. Spencer | 1b348a6 | 2015-09-04 22:28:10 +0000 | [diff] [blame] | 23 | |
| 24 | using namespace llvm; |
Michael J. Spencer | 84487f1 | 2015-07-24 21:03:07 +0000 | [diff] [blame] | 25 | using namespace llvm::object; |
Rafael Espindola | 78471f0 | 2015-09-01 23:12:52 +0000 | [diff] [blame] | 26 | using namespace llvm::ELF; |
Michael J. Spencer | 84487f1 | 2015-07-24 21:03:07 +0000 | [diff] [blame] | 27 | |
| 28 | using namespace lld; |
Rafael Espindola | e0df00b | 2016-02-28 00:25:54 +0000 | [diff] [blame] | 29 | using namespace lld::elf; |
Michael J. Spencer | 84487f1 | 2015-07-24 21:03:07 +0000 | [diff] [blame] | 30 | |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 31 | template <class ELFT> |
Rui Ueyama | 9328b2c | 2016-03-14 23:16:09 +0000 | [diff] [blame] | 32 | static typename ELFT::uint getSymVA(const SymbolBody &Body, |
| 33 | typename ELFT::uint &Addend) { |
Rui Ueyama | 9328b2c | 2016-03-14 23:16:09 +0000 | [diff] [blame] | 34 | typedef typename ELFT::uint uintX_t; |
Rafael Espindola | 87d9f10 | 2016-03-11 12:19:05 +0000 | [diff] [blame] | 35 | |
| 36 | switch (Body.kind()) { |
| 37 | case SymbolBody::DefinedSyntheticKind: { |
| 38 | auto &D = cast<DefinedSynthetic<ELFT>>(Body); |
Simon Atanasyan | 13f6da1 | 2016-03-31 21:26:23 +0000 | [diff] [blame] | 39 | if (D.Value == DefinedSynthetic<ELFT>::SectionEnd) |
| 40 | return D.Section.getVA() + D.Section.getSize(); |
Rafael Espindola | 87d9f10 | 2016-03-11 12:19:05 +0000 | [diff] [blame] | 41 | return D.Section.getVA() + D.Value; |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 42 | } |
Rafael Espindola | 87d9f10 | 2016-03-11 12:19:05 +0000 | [diff] [blame] | 43 | case SymbolBody::DefinedRegularKind: { |
| 44 | auto &D = cast<DefinedRegular<ELFT>>(Body); |
| 45 | InputSectionBase<ELFT> *SC = D.Section; |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 46 | |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 47 | // According to the ELF spec reference to a local symbol from outside |
| 48 | // the group are not allowed. Unfortunately .eh_frame breaks that rule |
| 49 | // and must be treated specially. For now we just replace the symbol with |
| 50 | // 0. |
| 51 | if (SC == &InputSection<ELFT>::Discarded) |
| 52 | return 0; |
| 53 | |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 54 | // This is an absolute symbol. |
| 55 | if (!SC) |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 56 | return D.Value; |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 57 | |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 58 | uintX_t Offset = D.Value; |
| 59 | if (D.isSection()) { |
Rafael Espindola | 1f5b70f | 2016-03-11 14:21:37 +0000 | [diff] [blame] | 60 | Offset += Addend; |
| 61 | Addend = 0; |
| 62 | } |
| 63 | uintX_t VA = SC->OutSec->getVA() + SC->getOffset(Offset); |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 64 | if (D.isTls()) |
Rafael Espindola | 1f5b70f | 2016-03-11 14:21:37 +0000 | [diff] [blame] | 65 | return VA - Out<ELFT>::TlsPhdr->p_vaddr; |
| 66 | return VA; |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 67 | } |
Rafael Espindola | 87d9f10 | 2016-03-11 12:19:05 +0000 | [diff] [blame] | 68 | case SymbolBody::DefinedCommonKind: |
| 69 | return Out<ELFT>::Bss->getVA() + cast<DefinedCommon>(Body).OffsetInBss; |
| 70 | case SymbolBody::SharedKind: { |
| 71 | auto &SS = cast<SharedSymbol<ELFT>>(Body); |
| 72 | if (!SS.NeedsCopyOrPltAddr) |
Rafael Espindola | a0a65f9 | 2016-02-09 15:11:01 +0000 | [diff] [blame] | 73 | return 0; |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 74 | if (SS.isFunc()) |
Rafael Espindola | 87d9f10 | 2016-03-11 12:19:05 +0000 | [diff] [blame] | 75 | return Body.getPltVA<ELFT>(); |
Rui Ueyama | 2df7289 | 2016-03-13 20:54:38 +0000 | [diff] [blame] | 76 | return Out<ELFT>::Bss->getVA() + SS.OffsetInBss; |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 77 | } |
Rafael Espindola | 87d9f10 | 2016-03-11 12:19:05 +0000 | [diff] [blame] | 78 | case SymbolBody::UndefinedElfKind: |
Rafael Espindola | f476573 | 2016-04-06 13:22:41 +0000 | [diff] [blame] | 79 | case SymbolBody::UndefinedBitcodeKind: |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 80 | return 0; |
Rui Ueyama | f8baa66 | 2016-04-07 19:24:51 +0000 | [diff] [blame] | 81 | case SymbolBody::LazyArchiveKind: |
| 82 | case SymbolBody::LazyObjectKind: |
George Rimar | 777f963 | 2016-03-12 08:31:34 +0000 | [diff] [blame] | 83 | assert(Body.isUsedInRegularObj() && "lazy symbol reached writer"); |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 84 | return 0; |
Rafael Espindola | 87d9f10 | 2016-03-11 12:19:05 +0000 | [diff] [blame] | 85 | case SymbolBody::DefinedBitcodeKind: |
Davide Italiano | f6523ae | 2016-03-29 02:20:10 +0000 | [diff] [blame] | 86 | llvm_unreachable("should have been replaced"); |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 87 | } |
George Rimar | 777f963 | 2016-03-12 08:31:34 +0000 | [diff] [blame] | 88 | llvm_unreachable("invalid symbol kind"); |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 89 | } |
| 90 | |
Rui Ueyama | b5792b2 | 2016-04-04 19:09:08 +0000 | [diff] [blame] | 91 | SymbolBody::SymbolBody(Kind K, uint32_t NameOffset, uint8_t StOther, |
| 92 | uint8_t Type) |
Rafael Espindola | 5e34568 | 2016-04-06 14:31:03 +0000 | [diff] [blame] | 93 | : SymbolKind(K), Type(Type), Binding(STB_LOCAL), StOther(StOther), |
| 94 | NameOffset(NameOffset) { |
Rafael Espindola | f476573 | 2016-04-06 13:22:41 +0000 | [diff] [blame] | 95 | init(); |
| 96 | } |
| 97 | |
| 98 | SymbolBody::SymbolBody(Kind K, StringRef Name, uint8_t Binding, uint8_t StOther, |
| 99 | uint8_t Type) |
Rafael Espindola | 5e34568 | 2016-04-06 14:31:03 +0000 | [diff] [blame] | 100 | : SymbolKind(K), Type(Type), Binding(Binding), StOther(StOther), |
Rafael Espindola | f476573 | 2016-04-06 13:22:41 +0000 | [diff] [blame] | 101 | Name({Name.data(), Name.size()}) { |
| 102 | assert(!isLocal()); |
| 103 | init(); |
| 104 | } |
| 105 | |
| 106 | void SymbolBody::init() { |
| 107 | Kind K = kind(); |
| 108 | IsUsedInRegularObj = K == DefinedRegularKind || K == DefinedCommonKind || |
| 109 | K == DefinedSyntheticKind || K == UndefinedElfKind; |
Rafael Espindola | 5e34568 | 2016-04-06 14:31:03 +0000 | [diff] [blame] | 110 | CanKeepUndefined = false; |
| 111 | MustBeInDynSym = false; |
| 112 | NeedsCopyOrPltAddr = false; |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 113 | } |
| 114 | |
Rui Ueyama | c446660 | 2016-03-13 19:48:18 +0000 | [diff] [blame] | 115 | // Returns true if a symbol can be replaced at load-time by a symbol |
| 116 | // with the same name defined in other ELF executable or DSO. |
| 117 | bool SymbolBody::isPreemptible() const { |
| 118 | if (isLocal()) |
| 119 | return false; |
| 120 | |
| 121 | if (isShared()) |
| 122 | return true; |
| 123 | |
| 124 | if (isUndefined()) { |
| 125 | if (!isWeak()) |
| 126 | return true; |
| 127 | |
| 128 | // Ideally the static linker should see a definition for every symbol, but |
| 129 | // shared object are normally allowed to have undefined references that the |
| 130 | // static linker never sees a definition for. |
| 131 | if (Config->Shared) |
| 132 | return true; |
| 133 | |
| 134 | // Otherwise, just resolve to 0. |
| 135 | return false; |
| 136 | } |
| 137 | |
| 138 | if (!Config->Shared) |
| 139 | return false; |
| 140 | if (getVisibility() != STV_DEFAULT) |
| 141 | return false; |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 142 | if (Config->Bsymbolic || (Config->BsymbolicFunctions && isFunc())) |
Rui Ueyama | c446660 | 2016-03-13 19:48:18 +0000 | [diff] [blame] | 143 | return false; |
| 144 | return true; |
| 145 | } |
| 146 | |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 147 | template <class ELFT> |
Rui Ueyama | 9328b2c | 2016-03-14 23:16:09 +0000 | [diff] [blame] | 148 | typename ELFT::uint SymbolBody::getVA(typename ELFT::uint Addend) const { |
Rafael Espindola | 8381c56 | 2016-03-17 23:36:19 +0000 | [diff] [blame] | 149 | typename ELFT::uint OutVA = getSymVA<ELFT>(*this, Addend); |
| 150 | return OutVA + Addend; |
Rafael Espindola | 87d9f10 | 2016-03-11 12:19:05 +0000 | [diff] [blame] | 151 | } |
| 152 | |
Rui Ueyama | 9328b2c | 2016-03-14 23:16:09 +0000 | [diff] [blame] | 153 | template <class ELFT> typename ELFT::uint SymbolBody::getGotVA() const { |
Rafael Espindola | 74031ba | 2016-04-07 15:20:56 +0000 | [diff] [blame] | 154 | return Out<ELFT>::Got->getVA() + getGotOffset<ELFT>(); |
| 155 | } |
| 156 | |
| 157 | template <class ELFT> typename ELFT::uint SymbolBody::getGotOffset() const { |
| 158 | return (Out<ELFT>::Got->getMipsLocalEntriesNum() + GotIndex) * |
| 159 | sizeof(typename ELFT::uint); |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 160 | } |
| 161 | |
Rui Ueyama | 9328b2c | 2016-03-14 23:16:09 +0000 | [diff] [blame] | 162 | template <class ELFT> typename ELFT::uint SymbolBody::getGotPltVA() const { |
Rafael Espindola | 74031ba | 2016-04-07 15:20:56 +0000 | [diff] [blame] | 163 | return Out<ELFT>::GotPlt->getVA() + getGotPltOffset<ELFT>(); |
| 164 | } |
| 165 | |
| 166 | template <class ELFT> typename ELFT::uint SymbolBody::getGotPltOffset() const { |
| 167 | return GotPltIndex * sizeof(typename ELFT::uint); |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 168 | } |
| 169 | |
Rui Ueyama | 9328b2c | 2016-03-14 23:16:09 +0000 | [diff] [blame] | 170 | template <class ELFT> typename ELFT::uint SymbolBody::getPltVA() const { |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 171 | return Out<ELFT>::Plt->getVA() + Target->PltZeroSize + |
| 172 | PltIndex * Target->PltEntrySize; |
| 173 | } |
| 174 | |
Simon Atanasyan | 13f6da1 | 2016-03-31 21:26:23 +0000 | [diff] [blame] | 175 | template <class ELFT> typename ELFT::uint SymbolBody::getThunkVA() const { |
| 176 | auto *D = cast<DefinedRegular<ELFT>>(this); |
| 177 | auto *S = cast<InputSection<ELFT>>(D->Section); |
| 178 | return S->OutSec->getVA() + S->OutSecOff + S->getThunkOff() + |
| 179 | ThunkIndex * Target->ThunkSize; |
| 180 | } |
| 181 | |
Rui Ueyama | 9328b2c | 2016-03-14 23:16:09 +0000 | [diff] [blame] | 182 | template <class ELFT> typename ELFT::uint SymbolBody::getSize() const { |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 183 | if (const auto *C = dyn_cast<DefinedCommon>(this)) |
| 184 | return C->Size; |
| 185 | if (const auto *DR = dyn_cast<DefinedRegular<ELFT>>(this)) |
| 186 | return DR->Size; |
| 187 | if (const auto *S = dyn_cast<SharedSymbol<ELFT>>(this)) |
| 188 | return S->Sym.st_size; |
| 189 | if (const auto *U = dyn_cast<UndefinedElf<ELFT>>(this)) |
| 190 | return U->Size; |
Rui Ueyama | 512c61d | 2016-02-03 00:12:24 +0000 | [diff] [blame] | 191 | return 0; |
| 192 | } |
| 193 | |
Rafael Espindola | 78471f0 | 2015-09-01 23:12:52 +0000 | [diff] [blame] | 194 | static uint8_t getMinVisibility(uint8_t VA, uint8_t VB) { |
| 195 | if (VA == STV_DEFAULT) |
| 196 | return VB; |
| 197 | if (VB == STV_DEFAULT) |
| 198 | return VA; |
| 199 | return std::min(VA, VB); |
| 200 | } |
| 201 | |
George Rimar | 3498c7f | 2016-03-10 18:49:24 +0000 | [diff] [blame] | 202 | static int compareCommons(DefinedCommon *A, DefinedCommon *B) { |
George Rimar | 3435800 | 2016-03-14 09:19:30 +0000 | [diff] [blame] | 203 | if (Config->WarnCommon) |
| 204 | warning("multiple common of " + A->getName()); |
Rui Ueyama | 17d6983 | 2016-03-10 18:58:53 +0000 | [diff] [blame] | 205 | A->Alignment = B->Alignment = std::max(A->Alignment, B->Alignment); |
Davide Italiano | 901de03 | 2016-03-21 22:44:24 +0000 | [diff] [blame] | 206 | return A->Size < B->Size ? -1 : 1; |
George Rimar | 3498c7f | 2016-03-10 18:49:24 +0000 | [diff] [blame] | 207 | } |
| 208 | |
Michael J. Spencer | 84487f1 | 2015-07-24 21:03:07 +0000 | [diff] [blame] | 209 | // Returns 1, 0 or -1 if this symbol should take precedence |
| 210 | // over the Other, tie or lose, respectively. |
Peter Collingbourne | d0856a6 | 2016-04-05 00:47:58 +0000 | [diff] [blame] | 211 | int SymbolBody::compare(SymbolBody *Other) { |
Michael J. Spencer | 1b348a6 | 2015-09-04 22:28:10 +0000 | [diff] [blame] | 212 | assert(!isLazy() && !Other->isLazy()); |
Rafael Espindola | 0bc0c02 | 2016-01-18 23:54:05 +0000 | [diff] [blame] | 213 | std::tuple<bool, bool, bool> L(isDefined(), !isShared(), !isWeak()); |
| 214 | std::tuple<bool, bool, bool> R(Other->isDefined(), !Other->isShared(), |
| 215 | !Other->isWeak()); |
Rui Ueyama | a7ccb29 | 2015-07-27 20:39:01 +0000 | [diff] [blame] | 216 | |
Rafael Espindola | 3a63f3f | 2015-08-28 20:19:34 +0000 | [diff] [blame] | 217 | // Normalize |
| 218 | if (L > R) |
Peter Collingbourne | d0856a6 | 2016-04-05 00:47:58 +0000 | [diff] [blame] | 219 | return -Other->compare(this); |
Rui Ueyama | a7ccb29 | 2015-07-27 20:39:01 +0000 | [diff] [blame] | 220 | |
Rafael Espindola | f9d3dcf | 2016-04-13 19:03:34 +0000 | [diff] [blame^] | 221 | uint8_t V = getMinVisibility(getVisibility(), Other->getVisibility()); |
Rafael Espindola | 8caf33c | 2016-04-08 18:39:03 +0000 | [diff] [blame] | 222 | if (isShared() != Other->isShared()) { |
| 223 | SymbolBody *Shared = isShared() ? this : Other; |
| 224 | Shared->MustBeInDynSym = true; |
Rafael Espindola | f9d3dcf | 2016-04-13 19:03:34 +0000 | [diff] [blame^] | 225 | if (Shared->getVisibility() == STV_DEFAULT && |
| 226 | (V == STV_DEFAULT || V == STV_PROTECTED)) { |
Rafael Espindola | 8caf33c | 2016-04-08 18:39:03 +0000 | [diff] [blame] | 227 | // We want to export all symbols that exist in the executable and are |
| 228 | // preemptable in DSOs, so that the symbols in the executable can |
| 229 | // preempt symbols in the DSO at runtime. |
| 230 | SymbolBody *NonShared = isShared() ? Other : this; |
| 231 | NonShared->MustBeInDynSym = true; |
| 232 | } |
| 233 | } |
| 234 | |
Rafael Espindola | a15fb15 | 2016-04-08 16:11:42 +0000 | [diff] [blame] | 235 | if (!isShared() && !Other->isShared()) { |
Rafael Espindola | a15fb15 | 2016-04-08 16:11:42 +0000 | [diff] [blame] | 236 | setVisibility(V); |
| 237 | Other->setVisibility(V); |
| 238 | } |
Rafael Espindola | 78471f0 | 2015-09-01 23:12:52 +0000 | [diff] [blame] | 239 | |
Rui Ueyama | 86696f3 | 2015-10-21 19:41:03 +0000 | [diff] [blame] | 240 | if (IsUsedInRegularObj || Other->IsUsedInRegularObj) |
| 241 | IsUsedInRegularObj = Other->IsUsedInRegularObj = true; |
Rafael Espindola | 18173d4 | 2015-09-08 15:50:05 +0000 | [diff] [blame] | 242 | |
Rafael Espindola | 3a63f3f | 2015-08-28 20:19:34 +0000 | [diff] [blame] | 243 | if (L != R) |
| 244 | return -1; |
George Rimar | 3498c7f | 2016-03-10 18:49:24 +0000 | [diff] [blame] | 245 | if (!isDefined() || isShared() || isWeak()) |
Rafael Espindola | 8e5560d | 2015-09-23 14:23:59 +0000 | [diff] [blame] | 246 | return 1; |
George Rimar | 3498c7f | 2016-03-10 18:49:24 +0000 | [diff] [blame] | 247 | if (!isCommon() && !Other->isCommon()) |
| 248 | return 0; |
| 249 | if (isCommon() && Other->isCommon()) |
| 250 | return compareCommons(cast<DefinedCommon>(this), |
| 251 | cast<DefinedCommon>(Other)); |
George Rimar | 3435800 | 2016-03-14 09:19:30 +0000 | [diff] [blame] | 252 | if (Config->WarnCommon) |
| 253 | warning("common " + this->getName() + " is overridden"); |
George Rimar | 3498c7f | 2016-03-10 18:49:24 +0000 | [diff] [blame] | 254 | return isCommon() ? -1 : 1; |
Michael J. Spencer | 84487f1 | 2015-07-24 21:03:07 +0000 | [diff] [blame] | 255 | } |
Rafael Espindola | daa92a6 | 2015-08-31 01:16:19 +0000 | [diff] [blame] | 256 | |
Rafael Espindola | f9b79a4 | 2016-04-06 12:14:31 +0000 | [diff] [blame] | 257 | Defined::Defined(Kind K, StringRef Name, uint8_t Binding, uint8_t StOther, |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 258 | uint8_t Type) |
Rafael Espindola | f9b79a4 | 2016-04-06 12:14:31 +0000 | [diff] [blame] | 259 | : SymbolBody(K, Name, Binding, StOther, Type) {} |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 260 | |
Rafael Espindola | f9b79a4 | 2016-04-06 12:14:31 +0000 | [diff] [blame] | 261 | Defined::Defined(Kind K, uint32_t NameOffset, uint8_t StOther, uint8_t Type) |
| 262 | : SymbolBody(K, NameOffset, StOther, Type) {} |
Rafael Espindola | 4d4b06a | 2015-12-24 00:47:42 +0000 | [diff] [blame] | 263 | |
Rafael Espindola | f9b79a4 | 2016-04-06 12:14:31 +0000 | [diff] [blame] | 264 | DefinedBitcode::DefinedBitcode(StringRef Name, bool IsWeak, uint8_t StOther) |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 265 | : Defined(DefinedBitcodeKind, Name, IsWeak ? STB_WEAK : STB_GLOBAL, |
Rafael Espindola | f9b79a4 | 2016-04-06 12:14:31 +0000 | [diff] [blame] | 266 | StOther, 0 /* Type */) {} |
Rafael Espindola | 9f77ef0 | 2016-02-12 20:54:57 +0000 | [diff] [blame] | 267 | |
| 268 | bool DefinedBitcode::classof(const SymbolBody *S) { |
| 269 | return S->kind() == DefinedBitcodeKind; |
| 270 | } |
| 271 | |
Rafael Espindola | f476573 | 2016-04-06 13:22:41 +0000 | [diff] [blame] | 272 | UndefinedBitcode::UndefinedBitcode(StringRef N, bool IsWeak, uint8_t StOther) |
| 273 | : SymbolBody(SymbolBody::UndefinedBitcodeKind, N, |
| 274 | IsWeak ? STB_WEAK : STB_GLOBAL, StOther, 0 /* Type */) {} |
Rafael Espindola | 5d7593b | 2015-12-22 23:00:50 +0000 | [diff] [blame] | 275 | |
| 276 | template <typename ELFT> |
| 277 | UndefinedElf<ELFT>::UndefinedElf(StringRef N, const Elf_Sym &Sym) |
Rafael Espindola | f476573 | 2016-04-06 13:22:41 +0000 | [diff] [blame] | 278 | : SymbolBody(SymbolBody::UndefinedElfKind, N, Sym.getBinding(), |
| 279 | Sym.st_other, Sym.getType()), |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 280 | Size(Sym.st_size) {} |
| 281 | |
| 282 | template <typename ELFT> |
Rafael Espindola | f476573 | 2016-04-06 13:22:41 +0000 | [diff] [blame] | 283 | UndefinedElf<ELFT>::UndefinedElf(StringRef Name, uint8_t Binding, |
| 284 | uint8_t StOther, uint8_t Type, |
| 285 | bool CanKeepUndefined) |
Rafael Espindola | 5e34568 | 2016-04-06 14:31:03 +0000 | [diff] [blame] | 286 | : SymbolBody(SymbolBody::UndefinedElfKind, Name, Binding, StOther, Type) { |
| 287 | this->CanKeepUndefined = CanKeepUndefined; |
| 288 | } |
Rafael Espindola | f476573 | 2016-04-06 13:22:41 +0000 | [diff] [blame] | 289 | |
| 290 | template <typename ELFT> |
Rafael Espindola | d9a1717 | 2016-04-05 11:47:46 +0000 | [diff] [blame] | 291 | UndefinedElf<ELFT>::UndefinedElf(const Elf_Sym &Sym) |
Rafael Espindola | f476573 | 2016-04-06 13:22:41 +0000 | [diff] [blame] | 292 | : SymbolBody(SymbolBody::UndefinedElfKind, Sym.st_name, Sym.st_other, |
| 293 | Sym.getType()), |
Rafael Espindola | ccfe3cb | 2016-04-04 14:04:16 +0000 | [diff] [blame] | 294 | Size(Sym.st_size) { |
| 295 | assert(Sym.getBinding() == STB_LOCAL); |
| 296 | } |
Rafael Espindola | 5d7593b | 2015-12-22 23:00:50 +0000 | [diff] [blame] | 297 | |
Rafael Espindola | 4d4b06a | 2015-12-24 00:47:42 +0000 | [diff] [blame] | 298 | template <typename ELFT> |
| 299 | DefinedSynthetic<ELFT>::DefinedSynthetic(StringRef N, uintX_t Value, |
Peter Collingbourne | f6e9b4e | 2016-04-13 16:57:28 +0000 | [diff] [blame] | 300 | OutputSectionBase<ELFT> &Section) |
| 301 | : Defined(SymbolBody::DefinedSyntheticKind, N, STB_GLOBAL, STV_HIDDEN, |
Davide Italiano | 255730c | 2016-03-04 01:55:28 +0000 | [diff] [blame] | 302 | 0 /* Type */), |
Rafael Espindola | 4d4b06a | 2015-12-24 00:47:42 +0000 | [diff] [blame] | 303 | Value(Value), Section(Section) {} |
| 304 | |
Rafael Espindola | 1119191 | 2015-12-24 16:23:37 +0000 | [diff] [blame] | 305 | DefinedCommon::DefinedCommon(StringRef N, uint64_t Size, uint64_t Alignment, |
Rafael Espindola | f9b79a4 | 2016-04-06 12:14:31 +0000 | [diff] [blame] | 306 | uint8_t Binding, uint8_t StOther, uint8_t Type) |
| 307 | : Defined(SymbolBody::DefinedCommonKind, N, Binding, StOther, Type), |
Rui Ueyama | 17d6983 | 2016-03-10 18:58:53 +0000 | [diff] [blame] | 308 | Alignment(Alignment), Size(Size) {} |
Rafael Espindola | 1119191 | 2015-12-24 16:23:37 +0000 | [diff] [blame] | 309 | |
Rui Ueyama | f8baa66 | 2016-04-07 19:24:51 +0000 | [diff] [blame] | 310 | std::unique_ptr<InputFile> Lazy::getFile() { |
| 311 | if (auto *S = dyn_cast<LazyArchive>(this)) |
| 312 | return S->getFile(); |
| 313 | return cast<LazyObject>(this)->getFile(); |
| 314 | } |
| 315 | |
| 316 | std::unique_ptr<InputFile> LazyArchive::getFile() { |
Michael J. Spencer | 1b348a6 | 2015-09-04 22:28:10 +0000 | [diff] [blame] | 317 | MemoryBufferRef MBRef = File->getMember(&Sym); |
| 318 | |
| 319 | // getMember returns an empty buffer if the member was already |
| 320 | // read from the library. |
| 321 | if (MBRef.getBuffer().empty()) |
| 322 | return std::unique_ptr<InputFile>(nullptr); |
Rui Ueyama | 71c066d | 2016-02-02 08:22:41 +0000 | [diff] [blame] | 323 | return createObjectFile(MBRef, File->getName()); |
Michael J. Spencer | 1b348a6 | 2015-09-04 22:28:10 +0000 | [diff] [blame] | 324 | } |
| 325 | |
Rui Ueyama | f8baa66 | 2016-04-07 19:24:51 +0000 | [diff] [blame] | 326 | std::unique_ptr<InputFile> LazyObject::getFile() { |
| 327 | return createObjectFile(MBRef); |
| 328 | } |
| 329 | |
Rui Ueyama | a4a628f | 2016-01-13 18:55:39 +0000 | [diff] [blame] | 330 | // Returns the demangled C++ symbol name for Name. |
Rafael Espindola | e0df00b | 2016-02-28 00:25:54 +0000 | [diff] [blame] | 331 | std::string elf::demangle(StringRef Name) { |
Rui Ueyama | a4a628f | 2016-01-13 18:55:39 +0000 | [diff] [blame] | 332 | #if !defined(HAVE_CXXABI_H) |
| 333 | return Name; |
| 334 | #else |
| 335 | if (!Config->Demangle) |
| 336 | return Name; |
Rui Ueyama | 5fa978b | 2016-01-13 19:40:13 +0000 | [diff] [blame] | 337 | |
Rui Ueyama | df15451 | 2016-01-13 22:09:09 +0000 | [diff] [blame] | 338 | // __cxa_demangle can be used to demangle strings other than symbol |
| 339 | // names which do not necessarily start with "_Z". Name can be |
| 340 | // either a C or C++ symbol. Don't call __cxa_demangle if the name |
| 341 | // does not look like a C++ symbol name to avoid getting unexpected |
| 342 | // result for a C symbol that happens to match a mangled type name. |
Rui Ueyama | 5fa978b | 2016-01-13 19:40:13 +0000 | [diff] [blame] | 343 | if (!Name.startswith("_Z")) |
| 344 | return Name; |
| 345 | |
Rui Ueyama | a4a628f | 2016-01-13 18:55:39 +0000 | [diff] [blame] | 346 | char *Buf = |
| 347 | abi::__cxa_demangle(Name.str().c_str(), nullptr, nullptr, nullptr); |
| 348 | if (!Buf) |
| 349 | return Name; |
| 350 | std::string S(Buf); |
| 351 | free(Buf); |
| 352 | return S; |
| 353 | #endif |
| 354 | } |
| 355 | |
Rafael Espindola | 87d9f10 | 2016-03-11 12:19:05 +0000 | [diff] [blame] | 356 | template uint32_t SymbolBody::template getVA<ELF32LE>(uint32_t) const; |
| 357 | template uint32_t SymbolBody::template getVA<ELF32BE>(uint32_t) const; |
| 358 | template uint64_t SymbolBody::template getVA<ELF64LE>(uint64_t) const; |
| 359 | template uint64_t SymbolBody::template getVA<ELF64BE>(uint64_t) const; |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 360 | |
| 361 | template uint32_t SymbolBody::template getGotVA<ELF32LE>() const; |
| 362 | template uint32_t SymbolBody::template getGotVA<ELF32BE>() const; |
| 363 | template uint64_t SymbolBody::template getGotVA<ELF64LE>() const; |
| 364 | template uint64_t SymbolBody::template getGotVA<ELF64BE>() const; |
| 365 | |
Rafael Espindola | 74031ba | 2016-04-07 15:20:56 +0000 | [diff] [blame] | 366 | template uint32_t SymbolBody::template getGotOffset<ELF32LE>() const; |
| 367 | template uint32_t SymbolBody::template getGotOffset<ELF32BE>() const; |
| 368 | template uint64_t SymbolBody::template getGotOffset<ELF64LE>() const; |
| 369 | template uint64_t SymbolBody::template getGotOffset<ELF64BE>() const; |
| 370 | |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 371 | template uint32_t SymbolBody::template getGotPltVA<ELF32LE>() const; |
| 372 | template uint32_t SymbolBody::template getGotPltVA<ELF32BE>() const; |
| 373 | template uint64_t SymbolBody::template getGotPltVA<ELF64LE>() const; |
| 374 | template uint64_t SymbolBody::template getGotPltVA<ELF64BE>() const; |
| 375 | |
Rafael Espindola | 74031ba | 2016-04-07 15:20:56 +0000 | [diff] [blame] | 376 | template uint32_t SymbolBody::template getGotPltOffset<ELF32LE>() const; |
| 377 | template uint32_t SymbolBody::template getGotPltOffset<ELF32BE>() const; |
| 378 | template uint64_t SymbolBody::template getGotPltOffset<ELF64LE>() const; |
| 379 | template uint64_t SymbolBody::template getGotPltOffset<ELF64BE>() const; |
| 380 | |
Rui Ueyama | b5a6970 | 2016-02-01 21:00:35 +0000 | [diff] [blame] | 381 | template uint32_t SymbolBody::template getPltVA<ELF32LE>() const; |
| 382 | template uint32_t SymbolBody::template getPltVA<ELF32BE>() const; |
| 383 | template uint64_t SymbolBody::template getPltVA<ELF64LE>() const; |
| 384 | template uint64_t SymbolBody::template getPltVA<ELF64BE>() const; |
| 385 | |
Rui Ueyama | 512c61d | 2016-02-03 00:12:24 +0000 | [diff] [blame] | 386 | template uint32_t SymbolBody::template getSize<ELF32LE>() const; |
| 387 | template uint32_t SymbolBody::template getSize<ELF32BE>() const; |
| 388 | template uint64_t SymbolBody::template getSize<ELF64LE>() const; |
| 389 | template uint64_t SymbolBody::template getSize<ELF64BE>() const; |
| 390 | |
Simon Atanasyan | 13f6da1 | 2016-03-31 21:26:23 +0000 | [diff] [blame] | 391 | template uint32_t SymbolBody::template getThunkVA<ELF32LE>() const; |
| 392 | template uint32_t SymbolBody::template getThunkVA<ELF32BE>() const; |
| 393 | template uint64_t SymbolBody::template getThunkVA<ELF64LE>() const; |
| 394 | template uint64_t SymbolBody::template getThunkVA<ELF64BE>() const; |
| 395 | |
Rafael Espindola | e0df00b | 2016-02-28 00:25:54 +0000 | [diff] [blame] | 396 | template class elf::UndefinedElf<ELF32LE>; |
| 397 | template class elf::UndefinedElf<ELF32BE>; |
| 398 | template class elf::UndefinedElf<ELF64LE>; |
| 399 | template class elf::UndefinedElf<ELF64BE>; |
Rafael Espindola | 4d4b06a | 2015-12-24 00:47:42 +0000 | [diff] [blame] | 400 | |
Rafael Espindola | e0df00b | 2016-02-28 00:25:54 +0000 | [diff] [blame] | 401 | template class elf::DefinedSynthetic<ELF32LE>; |
| 402 | template class elf::DefinedSynthetic<ELF32BE>; |
| 403 | template class elf::DefinedSynthetic<ELF64LE>; |
| 404 | template class elf::DefinedSynthetic<ELF64BE>; |