Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 1 | //===- lib/ReaderWriter/ELF/ReaderELF.cpp ---------------------------------===// |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 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 | //===----------------------------------------------------------------------===// |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 9 | /// |
| 10 | /// \file |
| 11 | /// \brief Defines the ELF Reader and all helper sub classes to consume an ELF |
| 12 | /// file and produces atoms out of it. |
| 13 | /// |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 14 | //===----------------------------------------------------------------------===// |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 15 | |
Michael J. Spencer | 64afcb4 | 2013-01-23 01:18:43 +0000 | [diff] [blame^] | 16 | #include "lld/ReaderWriter/Reader.h" |
| 17 | |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 18 | #include "lld/Core/File.h" |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 19 | #include "lld/Core/Reference.h" |
Michael J. Spencer | 64afcb4 | 2013-01-23 01:18:43 +0000 | [diff] [blame^] | 20 | #include "lld/ReaderWriter/ELFTargetInfo.h" |
| 21 | #include "lld/ReaderWriter/ReaderArchive.h" |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 22 | |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 23 | #include "llvm/ADT/ArrayRef.h" |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 24 | #include "llvm/ADT/SmallString.h" |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 25 | #include "llvm/ADT/StringRef.h" |
| 26 | #include "llvm/Object/ELF.h" |
| 27 | #include "llvm/Object/ObjectFile.h" |
| 28 | #include "llvm/Support/Allocator.h" |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 29 | #include "llvm/Support/Casting.h" |
Michael J. Spencer | 8af48f3 | 2013-01-20 21:27:05 +0000 | [diff] [blame] | 30 | #include "llvm/Support/ErrorOr.h" |
Shankar Easwaran | bbf9ddd | 2012-12-27 01:40:08 +0000 | [diff] [blame] | 31 | #include "llvm/Support/Path.h" |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 32 | #include "llvm/Support/ELF.h" |
| 33 | #include "llvm/Support/Endian.h" |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 34 | #include "llvm/Support/ErrorHandling.h" |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 35 | #include "llvm/Support/MathExtras.h" |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 36 | #include "llvm/Support/Memory.h" |
| 37 | #include "llvm/Support/MemoryBuffer.h" |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 38 | #include "llvm/Support/Path.h" |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 39 | #include "llvm/Support/raw_ostream.h" |
| 40 | #include "llvm/Support/system_error.h" |
Shankar Easwaran | bbf9ddd | 2012-12-27 01:40:08 +0000 | [diff] [blame] | 41 | #include "AtomsELF.h" |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 42 | |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 43 | #include <map> |
| 44 | #include <vector> |
| 45 | |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 46 | using namespace lld; |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 47 | using llvm::support::endianness; |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 48 | using namespace llvm::object; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 49 | |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 50 | namespace { |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 51 | /// \brief Read a binary, find out based on the symbol table contents what kind |
| 52 | /// of symbol it is and create corresponding atoms for it |
| 53 | template <class ELFT> class FileELF : public File { |
Michael J. Spencer | b03f6c4 | 2013-01-15 07:53:22 +0000 | [diff] [blame] | 54 | typedef Elf_Sym_Impl<ELFT> Elf_Sym; |
| 55 | typedef Elf_Shdr_Impl<ELFT> Elf_Shdr; |
| 56 | typedef Elf_Rel_Impl<ELFT, false> Elf_Rel; |
| 57 | typedef Elf_Rel_Impl<ELFT, true> Elf_Rela; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 58 | |
| 59 | public: |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 60 | FileELF(std::unique_ptr<llvm::MemoryBuffer> MB, llvm::error_code &EC) |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 61 | : File(MB->getBufferIdentifier()) { |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 62 | llvm::OwningPtr<Binary> binaryFile; |
| 63 | EC = createBinary(MB.release(), binaryFile); |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 64 | if (EC) |
| 65 | return; |
| 66 | |
| 67 | // Point Obj to correct class and bitwidth ELF object |
Michael J. Spencer | b03f6c4 | 2013-01-15 07:53:22 +0000 | [diff] [blame] | 68 | _objFile.reset(llvm::dyn_cast<ELFObjectFile<ELFT>>(binaryFile.get())); |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 69 | |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 70 | if (!_objFile) { |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 71 | EC = make_error_code(object_error::invalid_file_type); |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 72 | return; |
| 73 | } |
| 74 | |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 75 | binaryFile.take(); |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 76 | |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 77 | std::map<const Elf_Shdr *, std::vector<const Elf_Sym *>> sectionSymbols; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 78 | |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 79 | // Handle: SHT_REL and SHT_RELA sections: |
| 80 | // Increment over the sections, when REL/RELA section types are found add |
| 81 | // the contents to the RelocationReferences map. |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 82 | section_iterator sit(_objFile->begin_sections()); |
| 83 | section_iterator sie(_objFile->end_sections()); |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 84 | for (; sit != sie; sit.increment(EC)) { |
| 85 | if (EC) |
| 86 | return; |
| 87 | |
| 88 | const Elf_Shdr *section = _objFile->getElfSection(sit); |
| 89 | |
| 90 | if (section->sh_type == llvm::ELF::SHT_RELA) { |
| 91 | llvm::StringRef sectionName; |
| 92 | if ((EC = _objFile->getSectionName(section, sectionName))) |
| 93 | return; |
| 94 | // Get rid of the leading .rela so Atoms can use their own section |
| 95 | // name to find the relocs. |
| 96 | sectionName = sectionName.drop_front(5); |
| 97 | |
| 98 | auto rai(_objFile->beginELFRela(section)); |
| 99 | auto rae(_objFile->endELFRela(section)); |
| 100 | |
| 101 | auto &Ref = _relocationAddendRefences[sectionName]; |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 102 | for (; rai != rae; ++rai) { |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 103 | Ref.push_back(&*rai); |
| 104 | } |
| 105 | } |
| 106 | |
| 107 | if (section->sh_type == llvm::ELF::SHT_REL) { |
| 108 | llvm::StringRef sectionName; |
| 109 | if ((EC = _objFile->getSectionName(section, sectionName))) |
| 110 | return; |
| 111 | // Get rid of the leading .rel so Atoms can use their own section |
| 112 | // name to find the relocs. |
| 113 | sectionName = sectionName.drop_front(4); |
| 114 | |
| 115 | auto ri(_objFile->beginELFRel(section)); |
| 116 | auto re(_objFile->endELFRel(section)); |
| 117 | |
| 118 | auto &Ref = _relocationReferences[sectionName]; |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 119 | for (; ri != re; ++ri) { |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 120 | Ref.push_back(&*ri); |
| 121 | } |
| 122 | } |
| 123 | } |
| 124 | |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 125 | // Increment over all the symbols collecting atoms and symbol names for |
| 126 | // later use. |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 127 | symbol_iterator it(_objFile->begin_symbols()); |
| 128 | symbol_iterator ie(_objFile->end_symbols()); |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 129 | |
Sid Manning | 429a4bc | 2012-07-27 14:52:18 +0000 | [diff] [blame] | 130 | for (; it != ie; it.increment(EC)) { |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 131 | if (EC) |
Sid Manning | 429a4bc | 2012-07-27 14:52:18 +0000 | [diff] [blame] | 132 | return; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 133 | |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 134 | if ((EC = it->getSection(sit))) |
Sid Manning | 429a4bc | 2012-07-27 14:52:18 +0000 | [diff] [blame] | 135 | return; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 136 | |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 137 | const Elf_Shdr *section = _objFile->getElfSection(sit); |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 138 | const Elf_Sym *symbol = _objFile->getElfSymbol(it); |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 139 | |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 140 | llvm::StringRef symbolName; |
| 141 | if ((EC = _objFile->getSymbolName(section, symbol, symbolName))) |
Sid Manning | 429a4bc | 2012-07-27 14:52:18 +0000 | [diff] [blame] | 142 | return; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 143 | |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 144 | if (symbol->st_shndx == llvm::ELF::SHN_ABS) { |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 145 | // Create an absolute atom. |
Michael J. Spencer | 71c00f4 | 2013-01-16 23:34:45 +0000 | [diff] [blame] | 146 | auto *newAtom = new (_readerStorage) |
| 147 | ELFAbsoluteAtom<ELFT>(*this, symbolName, symbol, symbol->st_value); |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 148 | |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 149 | _absoluteAtoms._atoms.push_back(newAtom); |
| 150 | _symbolToAtomMapping.insert(std::make_pair(symbol, newAtom)); |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 151 | } else if (symbol->st_shndx == llvm::ELF::SHN_UNDEF) { |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 152 | // Create an undefined atom. |
Michael J. Spencer | 71c00f4 | 2013-01-16 23:34:45 +0000 | [diff] [blame] | 153 | auto *newAtom = new (_readerStorage) |
| 154 | ELFUndefinedAtom<ELFT>(*this, symbolName, symbol); |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 155 | |
| 156 | _undefinedAtoms._atoms.push_back(newAtom); |
| 157 | _symbolToAtomMapping.insert(std::make_pair(symbol, newAtom)); |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 158 | } else { |
| 159 | // This is actually a defined symbol. Add it to its section's list of |
| 160 | // symbols. |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 161 | if (symbol->getType() == llvm::ELF::STT_NOTYPE || |
| 162 | symbol->getType() == llvm::ELF::STT_OBJECT || |
| 163 | symbol->getType() == llvm::ELF::STT_FUNC || |
| 164 | symbol->getType() == llvm::ELF::STT_GNU_IFUNC || |
| 165 | symbol->getType() == llvm::ELF::STT_SECTION || |
| 166 | symbol->getType() == llvm::ELF::STT_FILE || |
| 167 | symbol->getType() == llvm::ELF::STT_TLS || |
| 168 | symbol->getType() == llvm::ELF::STT_COMMON || |
| 169 | symbol->st_shndx == llvm::ELF::SHN_COMMON) { |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 170 | sectionSymbols[section].push_back(symbol); |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 171 | } else { |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 172 | llvm::errs() << "Unable to create atom for: " << symbolName << "\n"; |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 173 | EC = object_error::parse_failed; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 174 | return; |
| 175 | } |
| 176 | } |
| 177 | } |
| 178 | |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 179 | for (auto &i : sectionSymbols) { |
| 180 | auto &symbols = i.second; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 181 | // Sort symbols by position. |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 182 | std::stable_sort(symbols.begin(), symbols.end(), |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 183 | [](const Elf_Sym *A, const Elf_Sym *B) { |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 184 | return A->st_value < B->st_value; |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 185 | }); |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 186 | |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 187 | StringRef sectionContents; |
| 188 | if ((EC = _objFile->getSectionContents(i.first, sectionContents))) |
| 189 | return; |
| 190 | |
| 191 | llvm::StringRef sectionName; |
| 192 | if ((EC = _objFile->getSectionName(i.first, sectionName))) |
| 193 | return; |
| 194 | |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 195 | // i.first is the section the symbol lives in |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 196 | for (auto si = symbols.begin(), se = symbols.end(); si != se; ++si) { |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 197 | llvm::StringRef symbolName; |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 198 | if ((EC = _objFile->getSymbolName(i.first, *si, symbolName))) |
Sid Manning | 429a4bc | 2012-07-27 14:52:18 +0000 | [diff] [blame] | 199 | return; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 200 | |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 201 | bool isCommon = (*si)->getType() == llvm::ELF::STT_COMMON || |
| 202 | (*si)->st_shndx == llvm::ELF::SHN_COMMON; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 203 | |
| 204 | // Get the symbol's content: |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 205 | uint64_t contentSize; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 206 | if (si + 1 == se) { |
| 207 | // if this is the last symbol, take up the remaining data. |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 208 | contentSize = isCommon ? 0 |
| 209 | : i.first->sh_size - (*si)->st_value; |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 210 | } else { |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 211 | contentSize = isCommon ? 0 |
| 212 | : (*(si + 1))->st_value - (*si)->st_value; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 213 | } |
| 214 | |
Michael J. Spencer | 8b3898a | 2013-01-15 21:13:02 +0000 | [diff] [blame] | 215 | // Don't allocate content to a weak symbol, as they may be merged away. |
| 216 | // Create an anonymous atom to hold the data. |
| 217 | ELFDefinedAtom<ELFT> *anonAtom = nullptr; |
| 218 | if ((*si)->getBinding() == llvm::ELF::STB_WEAK && contentSize != 0) { |
| 219 | // Create a new non-weak ELF symbol. |
Michael J. Spencer | 71c00f4 | 2013-01-16 23:34:45 +0000 | [diff] [blame] | 220 | auto sym = new (_readerStorage) Elf_Sym; |
Michael J. Spencer | 8b3898a | 2013-01-15 21:13:02 +0000 | [diff] [blame] | 221 | *sym = **si; |
| 222 | sym->setBinding(llvm::ELF::STB_GLOBAL); |
| 223 | anonAtom = createDefinedAtomAndAssignRelocations( |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 224 | "", sectionName, sym, i.first, |
| 225 | ArrayRef<uint8_t>((uint8_t *)sectionContents.data() + |
| 226 | (*si)->st_value, contentSize)); |
Michael J. Spencer | 8b3898a | 2013-01-15 21:13:02 +0000 | [diff] [blame] | 227 | contentSize = 0; |
| 228 | } |
| 229 | |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 230 | ArrayRef<uint8_t> symbolData = ArrayRef<uint8_t>( |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 231 | (uint8_t *)sectionContents.data() + |
| 232 | (*si)->st_value, contentSize); |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 233 | |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 234 | auto newAtom = createDefinedAtomAndAssignRelocations( |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 235 | symbolName, sectionName, *si, i.first, symbolData); |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 236 | |
| 237 | _definedAtoms._atoms.push_back(newAtom); |
| 238 | _symbolToAtomMapping.insert(std::make_pair((*si), newAtom)); |
Michael J. Spencer | 8b3898a | 2013-01-15 21:13:02 +0000 | [diff] [blame] | 239 | if (anonAtom) |
| 240 | _definedAtoms._atoms.push_back(anonAtom); |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 241 | } |
| 242 | } |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 243 | |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 244 | // All the Atoms and References are created. Now update each Reference's |
| 245 | // target with the Atom pointer it refers to. |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 246 | for (auto &ri : _references) { |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 247 | const Elf_Sym *Symbol = _objFile->getElfSymbol(ri->targetSymbolIndex()); |
| 248 | ri->setTarget(findAtom(Symbol)); |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 249 | } |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 250 | } |
| 251 | |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 252 | virtual const atom_collection<DefinedAtom> &defined() const { |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 253 | return _definedAtoms; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 254 | } |
| 255 | |
| 256 | virtual const atom_collection<UndefinedAtom> &undefined() const { |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 257 | return _undefinedAtoms; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 258 | } |
| 259 | |
| 260 | virtual const atom_collection<SharedLibraryAtom> &sharedLibrary() const { |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 261 | return _sharedLibraryAtoms; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 262 | } |
| 263 | |
| 264 | virtual const atom_collection<AbsoluteAtom> &absolute() const { |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 265 | return _absoluteAtoms; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 266 | } |
| 267 | |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 268 | Atom *findAtom(const Elf_Sym *symbol) { |
| 269 | return _symbolToAtomMapping.lookup(symbol); |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 270 | } |
| 271 | |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 272 | private: |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 273 | ELFDefinedAtom<ELFT> *createDefinedAtomAndAssignRelocations( |
| 274 | StringRef symbolName, StringRef sectionName, const Elf_Sym *symbol, |
| 275 | const Elf_Shdr *section, ArrayRef<uint8_t> content) { |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 276 | unsigned int referenceStart = _references.size(); |
| 277 | |
| 278 | // Only relocations that are inside the domain of the atom are added. |
| 279 | |
| 280 | // Add Rela (those with r_addend) references: |
| 281 | for (auto &rai : _relocationAddendRefences[sectionName]) { |
| 282 | if (!((rai->r_offset >= symbol->st_value) && |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 283 | (rai->r_offset < symbol->st_value + content.size()))) |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 284 | continue; |
Michael J. Spencer | 71c00f4 | 2013-01-16 23:34:45 +0000 | [diff] [blame] | 285 | auto *ERef = new (_readerStorage) |
| 286 | ELFReference<ELFT>(rai, rai->r_offset - symbol->st_value, nullptr); |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 287 | _references.push_back(ERef); |
| 288 | } |
| 289 | |
| 290 | // Add Rel references. |
| 291 | for (auto &ri : _relocationReferences[sectionName]) { |
| 292 | if ((ri->r_offset >= symbol->st_value) && |
| 293 | (ri->r_offset < symbol->st_value + content.size())) { |
Michael J. Spencer | 71c00f4 | 2013-01-16 23:34:45 +0000 | [diff] [blame] | 294 | auto *ERef = new (_readerStorage) |
| 295 | ELFReference<ELFT>(ri, ri->r_offset - symbol->st_value, nullptr); |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 296 | _references.push_back(ERef); |
| 297 | } |
| 298 | } |
| 299 | |
| 300 | // Create the DefinedAtom and add it to the list of DefinedAtoms. |
Michael J. Spencer | 71c00f4 | 2013-01-16 23:34:45 +0000 | [diff] [blame] | 301 | return new (_readerStorage) |
| 302 | ELFDefinedAtom<ELFT>(*this, symbolName, sectionName, symbol, section, |
| 303 | content, referenceStart, _references.size(), |
| 304 | _references); |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 305 | } |
| 306 | |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 307 | std::unique_ptr<ELFObjectFile<ELFT>> _objFile; |
| 308 | atom_collection_vector<DefinedAtom> _definedAtoms; |
| 309 | atom_collection_vector<UndefinedAtom> _undefinedAtoms; |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 310 | atom_collection_vector<SharedLibraryAtom> _sharedLibraryAtoms; |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 311 | atom_collection_vector<AbsoluteAtom> _absoluteAtoms; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 312 | |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 313 | /// \brief _relocationAddendRefences and _relocationReferences contain the |
| 314 | /// list of relocations references. In ELF, if a section named, ".text" has |
| 315 | /// relocations will also have a section named ".rel.text" or ".rela.text" |
| 316 | /// which will hold the entries. -- .rel or .rela is prepended to create |
| 317 | /// the SHT_REL(A) section name. |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 318 | std::map<llvm::StringRef, |
| 319 | std::vector<const Elf_Rela *>> _relocationAddendRefences; |
| 320 | std::map<llvm::StringRef, |
| 321 | std::vector<const Elf_Rel *>> _relocationReferences; |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 322 | std::vector<ELFReference<ELFT> *> _references; |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 323 | llvm::DenseMap<const Elf_Sym *, Atom *> _symbolToAtomMapping; |
Sid Manning | 8caf4de | 2012-09-17 12:49:38 +0000 | [diff] [blame] | 324 | llvm::BumpPtrAllocator _readerStorage; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 325 | }; |
| 326 | |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 327 | /// \brief A reader object that will instantiate correct FileELF by examining the |
| 328 | /// memory buffer for ELF class and bit width |
| 329 | class ReaderELF : public Reader { |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 330 | public: |
Michael J. Spencer | 64afcb4 | 2013-01-23 01:18:43 +0000 | [diff] [blame^] | 331 | ReaderELF(const TargetInfo & ti, std::function<ReaderFunc> read) |
| 332 | : Reader(ti), |
| 333 | _readerArchive(ti, read) {} |
Shankar Easwaran | 70b4dcf | 2012-11-13 18:39:10 +0000 | [diff] [blame] | 334 | |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 335 | error_code parseFile(std::unique_ptr<MemoryBuffer> mb, |
| 336 | std::vector<std::unique_ptr<File>> &result) { |
Michael J. Spencer | b03f6c4 | 2013-01-15 07:53:22 +0000 | [diff] [blame] | 337 | using llvm::object::ELFType; |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 338 | llvm::sys::LLVMFileType fileType = |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 339 | llvm::sys::IdentifyFileType(mb->getBufferStart(), |
| 340 | static_cast<unsigned>(mb->getBufferSize())); |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 341 | |
| 342 | std::size_t MaxAlignment = |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 343 | 1ULL << llvm::CountTrailingZeros_64(uintptr_t(mb->getBufferStart())); |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 344 | |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 345 | llvm::error_code ec; |
Shankar Easwaran | 70b4dcf | 2012-11-13 18:39:10 +0000 | [diff] [blame] | 346 | switch (fileType) { |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 347 | case llvm::sys::ELF_Relocatable_FileType: { |
| 348 | std::pair<unsigned char, unsigned char> Ident = getElfArchType(&*mb); |
| 349 | std::unique_ptr<File> f; |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 350 | // Instantiate the correct FileELF template instance based on the Ident |
| 351 | // pair. Once the File is created we push the file to the vector of files |
| 352 | // already created during parser's life. |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 353 | if (Ident.first == llvm::ELF::ELFCLASS32 && |
| 354 | Ident.second == llvm::ELF::ELFDATA2LSB) { |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 355 | if (MaxAlignment >= 4) |
Michael J. Spencer | b03f6c4 | 2013-01-15 07:53:22 +0000 | [diff] [blame] | 356 | f.reset(new FileELF<ELFType<llvm::support::little, 4, false>>( |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 357 | std::move(mb), ec)); |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 358 | else if (MaxAlignment >= 2) |
Michael J. Spencer | b03f6c4 | 2013-01-15 07:53:22 +0000 | [diff] [blame] | 359 | f.reset(new FileELF<ELFType<llvm::support::little, 2, false>>( |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 360 | std::move(mb), ec)); |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 361 | else |
| 362 | llvm_unreachable("Invalid alignment for ELF file!"); |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 363 | } else if (Ident.first == llvm::ELF::ELFCLASS32 && |
| 364 | Ident.second == llvm::ELF::ELFDATA2MSB) { |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 365 | if (MaxAlignment >= 4) |
Michael J. Spencer | b03f6c4 | 2013-01-15 07:53:22 +0000 | [diff] [blame] | 366 | f.reset(new FileELF<ELFType<llvm::support::big, 4, false>>( |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 367 | std::move(mb), ec)); |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 368 | else if (MaxAlignment >= 2) |
Michael J. Spencer | b03f6c4 | 2013-01-15 07:53:22 +0000 | [diff] [blame] | 369 | f.reset(new FileELF<ELFType<llvm::support::big, 2, false>>( |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 370 | std::move(mb), ec)); |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 371 | else |
| 372 | llvm_unreachable("Invalid alignment for ELF file!"); |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 373 | } else if (Ident.first == llvm::ELF::ELFCLASS64 && |
| 374 | Ident.second == llvm::ELF::ELFDATA2MSB) { |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 375 | if (MaxAlignment >= 8) |
Michael J. Spencer | b03f6c4 | 2013-01-15 07:53:22 +0000 | [diff] [blame] | 376 | f.reset(new FileELF<ELFType<llvm::support::big, 8, true>>( |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 377 | std::move(mb), ec)); |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 378 | else if (MaxAlignment >= 2) |
Michael J. Spencer | b03f6c4 | 2013-01-15 07:53:22 +0000 | [diff] [blame] | 379 | f.reset(new FileELF<ELFType<llvm::support::big, 2, true>>( |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 380 | std::move(mb), ec)); |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 381 | else |
| 382 | llvm_unreachable("Invalid alignment for ELF file!"); |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 383 | } else if (Ident.first == llvm::ELF::ELFCLASS64 && |
| 384 | Ident.second == llvm::ELF::ELFDATA2LSB) { |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 385 | if (MaxAlignment >= 8) |
Michael J. Spencer | b03f6c4 | 2013-01-15 07:53:22 +0000 | [diff] [blame] | 386 | f.reset(new FileELF<ELFType<llvm::support::little, 8, true>>( |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 387 | std::move(mb), ec)); |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 388 | else if (MaxAlignment >= 2) |
Michael J. Spencer | b03f6c4 | 2013-01-15 07:53:22 +0000 | [diff] [blame] | 389 | f.reset(new FileELF<ELFType<llvm::support::little, 2, true>>( |
Michael J. Spencer | 84d3b01 | 2013-01-16 23:34:32 +0000 | [diff] [blame] | 390 | std::move(mb), ec)); |
Michael J. Spencer | a2c9727 | 2013-01-04 21:09:21 +0000 | [diff] [blame] | 391 | else |
| 392 | llvm_unreachable("Invalid alignment for ELF file!"); |
Michael J. Spencer | a5d2281 | 2012-11-13 19:58:58 +0000 | [diff] [blame] | 393 | } |
| 394 | if (!ec) |
| 395 | result.push_back(std::move(f)); |
| 396 | break; |
Michael J. Spencer | 842885e | 2013-01-15 21:12:45 +0000 | [diff] [blame] | 397 | } |
Michael J. Spencer | a5d2281 | 2012-11-13 19:58:58 +0000 | [diff] [blame] | 398 | case llvm::sys::Archive_FileType: |
| 399 | ec = _readerArchive.parseFile(std::move(mb), result); |
| 400 | break; |
Michael J. Spencer | a5d2281 | 2012-11-13 19:58:58 +0000 | [diff] [blame] | 401 | default: |
| 402 | llvm_unreachable("not supported format"); |
| 403 | break; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 404 | } |
| 405 | |
| 406 | if (ec) |
| 407 | return ec; |
| 408 | |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 409 | return error_code::success(); |
| 410 | } |
Shankar Easwaran | 70b4dcf | 2012-11-13 18:39:10 +0000 | [diff] [blame] | 411 | |
| 412 | private: |
Shankar Easwaran | 70b4dcf | 2012-11-13 18:39:10 +0000 | [diff] [blame] | 413 | ReaderArchive _readerArchive; |
Sid Manning | 1a60141 | 2012-07-25 16:27:21 +0000 | [diff] [blame] | 414 | }; |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 415 | } // end anon namespace. |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 416 | |
| 417 | namespace lld { |
Michael J. Spencer | 64afcb4 | 2013-01-23 01:18:43 +0000 | [diff] [blame^] | 418 | std::unique_ptr<Reader> createReaderELF(const TargetInfo & ti, |
| 419 | std::function<ReaderFunc> read) { |
| 420 | return std::unique_ptr<Reader>(new ReaderELF(ti, std::move(read))); |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 421 | } |
Michael J. Spencer | 6344b32 | 2012-12-20 00:37:10 +0000 | [diff] [blame] | 422 | } // end namespace lld |