Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 1 | //===- DLL.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 | // |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 10 | // This file defines various types of chunks for the DLL import or export |
| 11 | // descriptor tables. They are inherently Windows-specific. |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 12 | // You need to read Microsoft PE/COFF spec to understand details |
| 13 | // about the data structures. |
| 14 | // |
| 15 | // If you are not particularly interested in linking against Windows |
| 16 | // DLL, you can skip this file, and you should still be able to |
| 17 | // understand the rest of the linker. |
| 18 | // |
| 19 | //===----------------------------------------------------------------------===// |
| 20 | |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 21 | #include "DLL.h" |
Sam Clegg | 3141ddc | 2018-02-20 21:53:18 +0000 | [diff] [blame] | 22 | #include "Chunks.h" |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 23 | #include "llvm/Object/COFF.h" |
| 24 | #include "llvm/Support/Endian.h" |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 25 | #include "llvm/Support/Path.h" |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 26 | |
| 27 | using namespace llvm; |
| 28 | using namespace llvm::object; |
| 29 | using namespace llvm::support::endian; |
| 30 | using namespace llvm::COFF; |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 31 | |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 32 | namespace lld { |
| 33 | namespace coff { |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 34 | namespace { |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 35 | |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 36 | // Import table |
| 37 | |
Rui Ueyama | 25522f5 | 2015-07-09 00:45:50 +0000 | [diff] [blame] | 38 | static int ptrSize() { return Config->is64() ? 8 : 4; } |
| 39 | |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 40 | // A chunk for the import descriptor table. |
| 41 | class HintNameChunk : public Chunk { |
| 42 | public: |
| 43 | HintNameChunk(StringRef N, uint16_t H) : Name(N), Hint(H) {} |
| 44 | |
| 45 | size_t getSize() const override { |
| 46 | // Starts with 2 byte Hint field, followed by a null-terminated string, |
| 47 | // ends with 0 or 1 byte padding. |
Rui Ueyama | 489a806 | 2016-01-14 20:53:50 +0000 | [diff] [blame] | 48 | return alignTo(Name.size() + 3, 2); |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 49 | } |
| 50 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 51 | void writeTo(uint8_t *Buf) const override { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 52 | write16le(Buf + OutputSectionOff, Hint); |
| 53 | memcpy(Buf + OutputSectionOff + 2, Name.data(), Name.size()); |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 54 | } |
| 55 | |
| 56 | private: |
| 57 | StringRef Name; |
| 58 | uint16_t Hint; |
| 59 | }; |
| 60 | |
| 61 | // A chunk for the import descriptor table. |
| 62 | class LookupChunk : public Chunk { |
| 63 | public: |
Rui Ueyama | cfc2f80 | 2017-09-13 21:54:55 +0000 | [diff] [blame] | 64 | explicit LookupChunk(Chunk *C) : HintName(C) { Alignment = ptrSize(); } |
Rui Ueyama | 25522f5 | 2015-07-09 00:45:50 +0000 | [diff] [blame] | 65 | size_t getSize() const override { return ptrSize(); } |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 66 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 67 | void writeTo(uint8_t *Buf) const override { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 68 | write32le(Buf + OutputSectionOff, HintName->getRVA()); |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 69 | } |
| 70 | |
| 71 | Chunk *HintName; |
| 72 | }; |
| 73 | |
| 74 | // A chunk for the import descriptor table. |
| 75 | // This chunk represent import-by-ordinal symbols. |
| 76 | // See Microsoft PE/COFF spec 7.1. Import Header for details. |
| 77 | class OrdinalOnlyChunk : public Chunk { |
| 78 | public: |
Rui Ueyama | cfc2f80 | 2017-09-13 21:54:55 +0000 | [diff] [blame] | 79 | explicit OrdinalOnlyChunk(uint16_t V) : Ordinal(V) { Alignment = ptrSize(); } |
Rui Ueyama | 25522f5 | 2015-07-09 00:45:50 +0000 | [diff] [blame] | 80 | size_t getSize() const override { return ptrSize(); } |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 81 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 82 | void writeTo(uint8_t *Buf) const override { |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 83 | // An import-by-ordinal slot has MSB 1 to indicate that |
| 84 | // this is import-by-ordinal (and not import-by-name). |
Rui Ueyama | 25522f5 | 2015-07-09 00:45:50 +0000 | [diff] [blame] | 85 | if (Config->is64()) { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 86 | write64le(Buf + OutputSectionOff, (1ULL << 63) | Ordinal); |
Rui Ueyama | 25522f5 | 2015-07-09 00:45:50 +0000 | [diff] [blame] | 87 | } else { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 88 | write32le(Buf + OutputSectionOff, (1ULL << 31) | Ordinal); |
Rui Ueyama | 25522f5 | 2015-07-09 00:45:50 +0000 | [diff] [blame] | 89 | } |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 90 | } |
| 91 | |
| 92 | uint16_t Ordinal; |
| 93 | }; |
| 94 | |
| 95 | // A chunk for the import descriptor table. |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 96 | class ImportDirectoryChunk : public Chunk { |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 97 | public: |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 98 | explicit ImportDirectoryChunk(Chunk *N) : DLLName(N) {} |
| 99 | size_t getSize() const override { return sizeof(ImportDirectoryTableEntry); } |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 100 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 101 | void writeTo(uint8_t *Buf) const override { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 102 | auto *E = (coff_import_directory_table_entry *)(Buf + OutputSectionOff); |
Reid Kleckner | c2eaccb0 | 2017-06-02 18:49:38 +0000 | [diff] [blame] | 103 | E->ImportLookupTableRVA = LookupTab->getRVA(); |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 104 | E->NameRVA = DLLName->getRVA(); |
| 105 | E->ImportAddressTableRVA = AddressTab->getRVA(); |
| 106 | } |
| 107 | |
| 108 | Chunk *DLLName; |
Reid Kleckner | c2eaccb0 | 2017-06-02 18:49:38 +0000 | [diff] [blame] | 109 | Chunk *LookupTab; |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 110 | Chunk *AddressTab; |
| 111 | }; |
| 112 | |
| 113 | // A chunk representing null terminator in the import table. |
| 114 | // Contents of this chunk is always null bytes. |
| 115 | class NullChunk : public Chunk { |
| 116 | public: |
| 117 | explicit NullChunk(size_t N) : Size(N) {} |
| 118 | bool hasData() const override { return false; } |
| 119 | size_t getSize() const override { return Size; } |
| 120 | |
| 121 | private: |
| 122 | size_t Size; |
| 123 | }; |
| 124 | |
Rui Ueyama | d157088 | 2015-08-17 08:30:31 +0000 | [diff] [blame] | 125 | static std::vector<std::vector<DefinedImportData *>> |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 126 | binImports(const std::vector<DefinedImportData *> &Imports) { |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 127 | // Group DLL-imported symbols by DLL name because that's how |
| 128 | // symbols are layed out in the import descriptor table. |
Rui Ueyama | bfbd277 | 2015-09-02 07:27:31 +0000 | [diff] [blame] | 129 | auto Less = [](const std::string &A, const std::string &B) { |
Rui Ueyama | d157088 | 2015-08-17 08:30:31 +0000 | [diff] [blame] | 130 | return Config->DLLOrder[A] < Config->DLLOrder[B]; |
| 131 | }; |
Rui Ueyama | bfbd277 | 2015-09-02 07:27:31 +0000 | [diff] [blame] | 132 | std::map<std::string, std::vector<DefinedImportData *>, |
| 133 | bool(*)(const std::string &, const std::string &)> M(Less); |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 134 | for (DefinedImportData *Sym : Imports) |
Rui Ueyama | bfbd277 | 2015-09-02 07:27:31 +0000 | [diff] [blame] | 135 | M[Sym->getDLLName().lower()].push_back(Sym); |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 136 | |
Rui Ueyama | d157088 | 2015-08-17 08:30:31 +0000 | [diff] [blame] | 137 | std::vector<std::vector<DefinedImportData *>> V; |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 138 | for (auto &KV : M) { |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 139 | // Sort symbols by name for each group. |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 140 | std::vector<DefinedImportData *> &Syms = KV.second; |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 141 | std::sort(Syms.begin(), Syms.end(), |
| 142 | [](DefinedImportData *A, DefinedImportData *B) { |
| 143 | return A->getName() < B->getName(); |
| 144 | }); |
Rui Ueyama | d157088 | 2015-08-17 08:30:31 +0000 | [diff] [blame] | 145 | V.push_back(std::move(Syms)); |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 146 | } |
Rui Ueyama | d157088 | 2015-08-17 08:30:31 +0000 | [diff] [blame] | 147 | return V; |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 148 | } |
| 149 | |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 150 | // Export table |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 151 | // See Microsoft PE/COFF spec 4.3 for details. |
| 152 | |
| 153 | // A chunk for the delay import descriptor table etnry. |
| 154 | class DelayDirectoryChunk : public Chunk { |
| 155 | public: |
| 156 | explicit DelayDirectoryChunk(Chunk *N) : DLLName(N) {} |
| 157 | |
| 158 | size_t getSize() const override { |
| 159 | return sizeof(delay_import_directory_table_entry); |
| 160 | } |
| 161 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 162 | void writeTo(uint8_t *Buf) const override { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 163 | auto *E = (delay_import_directory_table_entry *)(Buf + OutputSectionOff); |
Rui Ueyama | 382dc96 | 2015-06-26 21:40:15 +0000 | [diff] [blame] | 164 | E->Attributes = 1; |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 165 | E->Name = DLLName->getRVA(); |
| 166 | E->ModuleHandle = ModuleHandle->getRVA(); |
| 167 | E->DelayImportAddressTable = AddressTab->getRVA(); |
| 168 | E->DelayImportNameTable = NameTab->getRVA(); |
| 169 | } |
| 170 | |
| 171 | Chunk *DLLName; |
| 172 | Chunk *ModuleHandle; |
| 173 | Chunk *AddressTab; |
| 174 | Chunk *NameTab; |
| 175 | }; |
| 176 | |
| 177 | // Initial contents for delay-loaded functions. |
Rui Ueyama | 6109620 | 2015-06-22 17:26:27 +0000 | [diff] [blame] | 178 | // This code calls __delayLoadHelper2 function to resolve a symbol |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 179 | // and then overwrites its jump table slot with the result |
| 180 | // for subsequent function calls. |
Rui Ueyama | ef0e647 | 2015-07-15 22:26:57 +0000 | [diff] [blame] | 181 | static const uint8_t ThunkX64[] = { |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 182 | 0x51, // push rcx |
| 183 | 0x52, // push rdx |
| 184 | 0x41, 0x50, // push r8 |
| 185 | 0x41, 0x51, // push r9 |
| 186 | 0x48, 0x83, 0xEC, 0x48, // sub rsp, 48h |
| 187 | 0x66, 0x0F, 0x7F, 0x04, 0x24, // movdqa xmmword ptr [rsp], xmm0 |
| 188 | 0x66, 0x0F, 0x7F, 0x4C, 0x24, 0x10, // movdqa xmmword ptr [rsp+10h], xmm1 |
| 189 | 0x66, 0x0F, 0x7F, 0x54, 0x24, 0x20, // movdqa xmmword ptr [rsp+20h], xmm2 |
| 190 | 0x66, 0x0F, 0x7F, 0x5C, 0x24, 0x30, // movdqa xmmword ptr [rsp+30h], xmm3 |
| 191 | 0x48, 0x8D, 0x15, 0, 0, 0, 0, // lea rdx, [__imp_<FUNCNAME>] |
| 192 | 0x48, 0x8D, 0x0D, 0, 0, 0, 0, // lea rcx, [___DELAY_IMPORT_...] |
| 193 | 0xE8, 0, 0, 0, 0, // call __delayLoadHelper2 |
| 194 | 0x66, 0x0F, 0x6F, 0x04, 0x24, // movdqa xmm0, xmmword ptr [rsp] |
| 195 | 0x66, 0x0F, 0x6F, 0x4C, 0x24, 0x10, // movdqa xmm1, xmmword ptr [rsp+10h] |
| 196 | 0x66, 0x0F, 0x6F, 0x54, 0x24, 0x20, // movdqa xmm2, xmmword ptr [rsp+20h] |
| 197 | 0x66, 0x0F, 0x6F, 0x5C, 0x24, 0x30, // movdqa xmm3, xmmword ptr [rsp+30h] |
| 198 | 0x48, 0x83, 0xC4, 0x48, // add rsp, 48h |
| 199 | 0x41, 0x59, // pop r9 |
| 200 | 0x41, 0x58, // pop r8 |
| 201 | 0x5A, // pop rdx |
| 202 | 0x59, // pop rcx |
| 203 | 0xFF, 0xE0, // jmp rax |
| 204 | }; |
| 205 | |
Rui Ueyama | ef0e647 | 2015-07-15 22:26:57 +0000 | [diff] [blame] | 206 | static const uint8_t ThunkX86[] = { |
| 207 | 0x51, // push ecx |
| 208 | 0x52, // push edx |
| 209 | 0x68, 0, 0, 0, 0, // push offset ___imp__<FUNCNAME> |
| 210 | 0x68, 0, 0, 0, 0, // push offset ___DELAY_IMPORT_DESCRIPTOR_<DLLNAME>_dll |
| 211 | 0xE8, 0, 0, 0, 0, // call ___delayLoadHelper2@8 |
| 212 | 0x5A, // pop edx |
| 213 | 0x59, // pop ecx |
| 214 | 0xFF, 0xE0, // jmp eax |
| 215 | }; |
| 216 | |
Martin Storsjo | 82eaf6c | 2017-07-25 20:00:37 +0000 | [diff] [blame] | 217 | static const uint8_t ThunkARM[] = { |
| 218 | 0x40, 0xf2, 0x00, 0x0c, // mov.w ip, #0 __imp_<FUNCNAME> |
| 219 | 0xc0, 0xf2, 0x00, 0x0c, // mov.t ip, #0 __imp_<FUNCNAME> |
| 220 | 0x2d, 0xe9, 0x0f, 0x48, // push.w {r0, r1, r2, r3, r11, lr} |
| 221 | 0x0d, 0xf2, 0x10, 0x0b, // addw r11, sp, #16 |
| 222 | 0x2d, 0xed, 0x10, 0x0b, // vpush {d0, d1, d2, d3, d4, d5, d6, d7} |
| 223 | 0x61, 0x46, // mov r1, ip |
| 224 | 0x40, 0xf2, 0x00, 0x00, // mov.w r0, #0 DELAY_IMPORT_DESCRIPTOR |
| 225 | 0xc0, 0xf2, 0x00, 0x00, // mov.t r0, #0 DELAY_IMPORT_DESCRIPTOR |
| 226 | 0x00, 0xf0, 0x00, 0xd0, // bl #0 __delayLoadHelper2 |
| 227 | 0x84, 0x46, // mov ip, r0 |
| 228 | 0xbd, 0xec, 0x10, 0x0b, // vpop {d0, d1, d2, d3, d4, d5, d6, d7} |
| 229 | 0xbd, 0xe8, 0x0f, 0x48, // pop.w {r0, r1, r2, r3, r11, lr} |
| 230 | 0x60, 0x47, // bx ip |
| 231 | }; |
| 232 | |
Martin Storsjo | 32d21d6 | 2018-09-18 07:22:01 +0000 | [diff] [blame] | 233 | static const uint8_t ThunkARM64[] = { |
| 234 | 0x11, 0x00, 0x00, 0x90, // adrp x17, #0 __imp_<FUNCNAME> |
| 235 | 0x31, 0x02, 0x00, 0x91, // add x17, x17, #0 :lo12:__imp_<FUNCNAME> |
| 236 | 0xfd, 0x7b, 0xb3, 0xa9, // stp x29, x30, [sp, #-208]! |
| 237 | 0xfd, 0x03, 0x00, 0x91, // mov x29, sp |
| 238 | 0xe0, 0x07, 0x01, 0xa9, // stp x0, x1, [sp, #16] |
| 239 | 0xe2, 0x0f, 0x02, 0xa9, // stp x2, x3, [sp, #32] |
| 240 | 0xe4, 0x17, 0x03, 0xa9, // stp x4, x5, [sp, #48] |
| 241 | 0xe6, 0x1f, 0x04, 0xa9, // stp x6, x7, [sp, #64] |
| 242 | 0xe0, 0x87, 0x02, 0xad, // stp q0, q1, [sp, #80] |
| 243 | 0xe2, 0x8f, 0x03, 0xad, // stp q2, q3, [sp, #112] |
| 244 | 0xe4, 0x97, 0x04, 0xad, // stp q4, q5, [sp, #144] |
| 245 | 0xe6, 0x9f, 0x05, 0xad, // stp q6, q7, [sp, #176] |
| 246 | 0xe1, 0x03, 0x11, 0xaa, // mov x1, x17 |
| 247 | 0x00, 0x00, 0x00, 0x90, // adrp x0, #0 DELAY_IMPORT_DESCRIPTOR |
| 248 | 0x00, 0x00, 0x00, 0x91, // add x0, x0, #0 :lo12:DELAY_IMPORT_DESCRIPTOR |
| 249 | 0x00, 0x00, 0x00, 0x94, // bl #0 __delayLoadHelper2 |
| 250 | 0xf0, 0x03, 0x00, 0xaa, // mov x16, x0 |
| 251 | 0xe6, 0x9f, 0x45, 0xad, // ldp q6, q7, [sp, #176] |
| 252 | 0xe4, 0x97, 0x44, 0xad, // ldp q4, q5, [sp, #144] |
| 253 | 0xe2, 0x8f, 0x43, 0xad, // ldp q2, q3, [sp, #112] |
| 254 | 0xe0, 0x87, 0x42, 0xad, // ldp q0, q1, [sp, #80] |
| 255 | 0xe6, 0x1f, 0x44, 0xa9, // ldp x6, x7, [sp, #64] |
| 256 | 0xe4, 0x17, 0x43, 0xa9, // ldp x4, x5, [sp, #48] |
| 257 | 0xe2, 0x0f, 0x42, 0xa9, // ldp x2, x3, [sp, #32] |
| 258 | 0xe0, 0x07, 0x41, 0xa9, // ldp x0, x1, [sp, #16] |
| 259 | 0xfd, 0x7b, 0xcd, 0xa8, // ldp x29, x30, [sp], #208 |
| 260 | 0x00, 0x02, 0x1f, 0xd6, // br x16 |
| 261 | }; |
| 262 | |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 263 | // A chunk for the delay import thunk. |
Rui Ueyama | ef0e647 | 2015-07-15 22:26:57 +0000 | [diff] [blame] | 264 | class ThunkChunkX64 : public Chunk { |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 265 | public: |
Rui Ueyama | ef0e647 | 2015-07-15 22:26:57 +0000 | [diff] [blame] | 266 | ThunkChunkX64(Defined *I, Chunk *D, Defined *H) |
| 267 | : Imp(I), Desc(D), Helper(H) {} |
| 268 | |
| 269 | size_t getSize() const override { return sizeof(ThunkX64); } |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 270 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 271 | void writeTo(uint8_t *Buf) const override { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 272 | memcpy(Buf + OutputSectionOff, ThunkX64, sizeof(ThunkX64)); |
| 273 | write32le(Buf + OutputSectionOff + 36, Imp->getRVA() - RVA - 40); |
| 274 | write32le(Buf + OutputSectionOff + 43, Desc->getRVA() - RVA - 47); |
| 275 | write32le(Buf + OutputSectionOff + 48, Helper->getRVA() - RVA - 52); |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 276 | } |
| 277 | |
| 278 | Defined *Imp = nullptr; |
| 279 | Chunk *Desc = nullptr; |
| 280 | Defined *Helper = nullptr; |
| 281 | }; |
| 282 | |
Rui Ueyama | ef0e647 | 2015-07-15 22:26:57 +0000 | [diff] [blame] | 283 | class ThunkChunkX86 : public Chunk { |
| 284 | public: |
| 285 | ThunkChunkX86(Defined *I, Chunk *D, Defined *H) |
| 286 | : Imp(I), Desc(D), Helper(H) {} |
| 287 | |
| 288 | size_t getSize() const override { return sizeof(ThunkX86); } |
| 289 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 290 | void writeTo(uint8_t *Buf) const override { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 291 | memcpy(Buf + OutputSectionOff, ThunkX86, sizeof(ThunkX86)); |
| 292 | write32le(Buf + OutputSectionOff + 3, Imp->getRVA() + Config->ImageBase); |
| 293 | write32le(Buf + OutputSectionOff + 8, Desc->getRVA() + Config->ImageBase); |
| 294 | write32le(Buf + OutputSectionOff + 13, Helper->getRVA() - RVA - 17); |
Rui Ueyama | ef0e647 | 2015-07-15 22:26:57 +0000 | [diff] [blame] | 295 | } |
| 296 | |
Rui Ueyama | 3afd5bf | 2015-07-25 01:44:32 +0000 | [diff] [blame] | 297 | void getBaserels(std::vector<Baserel> *Res) override { |
| 298 | Res->emplace_back(RVA + 3); |
| 299 | Res->emplace_back(RVA + 8); |
Rui Ueyama | ef0e647 | 2015-07-15 22:26:57 +0000 | [diff] [blame] | 300 | } |
| 301 | |
| 302 | Defined *Imp = nullptr; |
| 303 | Chunk *Desc = nullptr; |
| 304 | Defined *Helper = nullptr; |
| 305 | }; |
| 306 | |
Martin Storsjo | 82eaf6c | 2017-07-25 20:00:37 +0000 | [diff] [blame] | 307 | class ThunkChunkARM : public Chunk { |
| 308 | public: |
| 309 | ThunkChunkARM(Defined *I, Chunk *D, Defined *H) |
| 310 | : Imp(I), Desc(D), Helper(H) {} |
| 311 | |
| 312 | size_t getSize() const override { return sizeof(ThunkARM); } |
| 313 | |
| 314 | void writeTo(uint8_t *Buf) const override { |
| 315 | memcpy(Buf + OutputSectionOff, ThunkARM, sizeof(ThunkARM)); |
| 316 | applyMOV32T(Buf + OutputSectionOff + 0, Imp->getRVA() + Config->ImageBase); |
| 317 | applyMOV32T(Buf + OutputSectionOff + 22, Desc->getRVA() + Config->ImageBase); |
| 318 | applyBranch24T(Buf + OutputSectionOff + 30, Helper->getRVA() - RVA - 34); |
| 319 | } |
| 320 | |
| 321 | void getBaserels(std::vector<Baserel> *Res) override { |
| 322 | Res->emplace_back(RVA + 0, IMAGE_REL_BASED_ARM_MOV32T); |
| 323 | Res->emplace_back(RVA + 22, IMAGE_REL_BASED_ARM_MOV32T); |
| 324 | } |
| 325 | |
| 326 | Defined *Imp = nullptr; |
| 327 | Chunk *Desc = nullptr; |
| 328 | Defined *Helper = nullptr; |
| 329 | }; |
| 330 | |
Martin Storsjo | 32d21d6 | 2018-09-18 07:22:01 +0000 | [diff] [blame] | 331 | class ThunkChunkARM64 : public Chunk { |
| 332 | public: |
| 333 | ThunkChunkARM64(Defined *I, Chunk *D, Defined *H) |
| 334 | : Imp(I), Desc(D), Helper(H) {} |
| 335 | |
| 336 | size_t getSize() const override { return sizeof(ThunkARM64); } |
| 337 | |
| 338 | void writeTo(uint8_t *Buf) const override { |
| 339 | memcpy(Buf + OutputSectionOff, ThunkARM64, sizeof(ThunkARM64)); |
| 340 | applyArm64Addr(Buf + OutputSectionOff + 0, Imp->getRVA(), RVA + 0, 12); |
| 341 | applyArm64Imm(Buf + OutputSectionOff + 4, Imp->getRVA() & 0xfff, 0); |
| 342 | applyArm64Addr(Buf + OutputSectionOff + 52, Desc->getRVA(), RVA + 52, 12); |
| 343 | applyArm64Imm(Buf + OutputSectionOff + 56, Desc->getRVA() & 0xfff, 0); |
| 344 | applyArm64Branch26(Buf + OutputSectionOff + 60, |
| 345 | Helper->getRVA() - RVA - 60); |
| 346 | } |
| 347 | |
| 348 | Defined *Imp = nullptr; |
| 349 | Chunk *Desc = nullptr; |
| 350 | Defined *Helper = nullptr; |
| 351 | }; |
| 352 | |
Rui Ueyama | 382dc96 | 2015-06-26 21:40:15 +0000 | [diff] [blame] | 353 | // A chunk for the import descriptor table. |
| 354 | class DelayAddressChunk : public Chunk { |
| 355 | public: |
Rui Ueyama | cfc2f80 | 2017-09-13 21:54:55 +0000 | [diff] [blame] | 356 | explicit DelayAddressChunk(Chunk *C) : Thunk(C) { Alignment = ptrSize(); } |
Rui Ueyama | 7e387a6 | 2015-07-28 02:54:18 +0000 | [diff] [blame] | 357 | size_t getSize() const override { return ptrSize(); } |
Rui Ueyama | 382dc96 | 2015-06-26 21:40:15 +0000 | [diff] [blame] | 358 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 359 | void writeTo(uint8_t *Buf) const override { |
Rui Ueyama | 7e387a6 | 2015-07-28 02:54:18 +0000 | [diff] [blame] | 360 | if (Config->is64()) { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 361 | write64le(Buf + OutputSectionOff, Thunk->getRVA() + Config->ImageBase); |
Rui Ueyama | 7e387a6 | 2015-07-28 02:54:18 +0000 | [diff] [blame] | 362 | } else { |
Martin Storsjo | 82eaf6c | 2017-07-25 20:00:37 +0000 | [diff] [blame] | 363 | uint32_t Bit = 0; |
| 364 | // Pointer to thumb code must have the LSB set, so adjust it. |
| 365 | if (Config->Machine == ARMNT) |
| 366 | Bit = 1; |
| 367 | write32le(Buf + OutputSectionOff, (Thunk->getRVA() + Config->ImageBase) | Bit); |
Rui Ueyama | 7e387a6 | 2015-07-28 02:54:18 +0000 | [diff] [blame] | 368 | } |
Rui Ueyama | 382dc96 | 2015-06-26 21:40:15 +0000 | [diff] [blame] | 369 | } |
| 370 | |
Rui Ueyama | 3afd5bf | 2015-07-25 01:44:32 +0000 | [diff] [blame] | 371 | void getBaserels(std::vector<Baserel> *Res) override { |
| 372 | Res->emplace_back(RVA); |
Rui Ueyama | 810551a | 2015-06-26 22:05:32 +0000 | [diff] [blame] | 373 | } |
| 374 | |
Rui Ueyama | 382dc96 | 2015-06-26 21:40:15 +0000 | [diff] [blame] | 375 | Chunk *Thunk; |
| 376 | }; |
| 377 | |
Rui Ueyama | a77336b | 2015-06-21 22:31:52 +0000 | [diff] [blame] | 378 | // Export table |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 379 | // Read Microsoft PE/COFF spec 5.3 for details. |
| 380 | |
| 381 | // A chunk for the export descriptor table. |
| 382 | class ExportDirectoryChunk : public Chunk { |
| 383 | public: |
| 384 | ExportDirectoryChunk(int I, int J, Chunk *D, Chunk *A, Chunk *N, Chunk *O) |
| 385 | : MaxOrdinal(I), NameTabSize(J), DLLName(D), AddressTab(A), NameTab(N), |
| 386 | OrdinalTab(O) {} |
| 387 | |
| 388 | size_t getSize() const override { |
| 389 | return sizeof(export_directory_table_entry); |
| 390 | } |
| 391 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 392 | void writeTo(uint8_t *Buf) const override { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 393 | auto *E = (export_directory_table_entry *)(Buf + OutputSectionOff); |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 394 | E->NameRVA = DLLName->getRVA(); |
| 395 | E->OrdinalBase = 0; |
| 396 | E->AddressTableEntries = MaxOrdinal + 1; |
| 397 | E->NumberOfNamePointers = NameTabSize; |
| 398 | E->ExportAddressTableRVA = AddressTab->getRVA(); |
| 399 | E->NamePointerRVA = NameTab->getRVA(); |
| 400 | E->OrdinalTableRVA = OrdinalTab->getRVA(); |
| 401 | } |
| 402 | |
| 403 | uint16_t MaxOrdinal; |
| 404 | uint16_t NameTabSize; |
| 405 | Chunk *DLLName; |
| 406 | Chunk *AddressTab; |
| 407 | Chunk *NameTab; |
| 408 | Chunk *OrdinalTab; |
| 409 | }; |
| 410 | |
| 411 | class AddressTableChunk : public Chunk { |
| 412 | public: |
| 413 | explicit AddressTableChunk(size_t MaxOrdinal) : Size(MaxOrdinal + 1) {} |
| 414 | size_t getSize() const override { return Size * 4; } |
| 415 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 416 | void writeTo(uint8_t *Buf) const override { |
Martin Storsjo | 6528fb8 | 2017-12-20 06:50:45 +0000 | [diff] [blame] | 417 | for (const Export &E : Config->Exports) { |
Rui Ueyama | 84425d7 | 2016-01-09 01:22:00 +0000 | [diff] [blame] | 418 | uint8_t *P = Buf + OutputSectionOff + E.Ordinal * 4; |
Martin Storsjo | 6528fb8 | 2017-12-20 06:50:45 +0000 | [diff] [blame] | 419 | uint32_t Bit = 0; |
| 420 | // Pointer to thumb code must have the LSB set, so adjust it. |
| 421 | if (Config->Machine == ARMNT && !E.Data) |
| 422 | Bit = 1; |
Rui Ueyama | 84425d7 | 2016-01-09 01:22:00 +0000 | [diff] [blame] | 423 | if (E.ForwardChunk) { |
Martin Storsjo | 405b5bc | 2017-07-25 06:10:44 +0000 | [diff] [blame] | 424 | write32le(P, E.ForwardChunk->getRVA() | Bit); |
Rui Ueyama | 84425d7 | 2016-01-09 01:22:00 +0000 | [diff] [blame] | 425 | } else { |
Martin Storsjo | 405b5bc | 2017-07-25 06:10:44 +0000 | [diff] [blame] | 426 | write32le(P, cast<Defined>(E.Sym)->getRVA() | Bit); |
Rui Ueyama | 84425d7 | 2016-01-09 01:22:00 +0000 | [diff] [blame] | 427 | } |
Rui Ueyama | f5313b3 | 2015-06-28 22:16:41 +0000 | [diff] [blame] | 428 | } |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 429 | } |
| 430 | |
| 431 | private: |
| 432 | size_t Size; |
| 433 | }; |
| 434 | |
| 435 | class NamePointersChunk : public Chunk { |
| 436 | public: |
| 437 | explicit NamePointersChunk(std::vector<Chunk *> &V) : Chunks(V) {} |
| 438 | size_t getSize() const override { return Chunks.size() * 4; } |
| 439 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 440 | void writeTo(uint8_t *Buf) const override { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 441 | uint8_t *P = Buf + OutputSectionOff; |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 442 | for (Chunk *C : Chunks) { |
| 443 | write32le(P, C->getRVA()); |
| 444 | P += 4; |
| 445 | } |
| 446 | } |
| 447 | |
| 448 | private: |
| 449 | std::vector<Chunk *> Chunks; |
| 450 | }; |
| 451 | |
| 452 | class ExportOrdinalChunk : public Chunk { |
| 453 | public: |
| 454 | explicit ExportOrdinalChunk(size_t I) : Size(I) {} |
| 455 | size_t getSize() const override { return Size * 2; } |
| 456 | |
Rui Ueyama | 63bbe84 | 2015-09-19 23:28:57 +0000 | [diff] [blame] | 457 | void writeTo(uint8_t *Buf) const override { |
Rafael Espindola | 5c546a1 | 2015-08-14 03:30:59 +0000 | [diff] [blame] | 458 | uint8_t *P = Buf + OutputSectionOff; |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 459 | for (Export &E : Config->Exports) { |
| 460 | if (E.Noname) |
| 461 | continue; |
| 462 | write16le(P, E.Ordinal); |
| 463 | P += 2; |
| 464 | } |
| 465 | } |
| 466 | |
| 467 | private: |
| 468 | size_t Size; |
| 469 | }; |
| 470 | |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 471 | } // anonymous namespace |
| 472 | |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 473 | void IdataContents::create() { |
Rui Ueyama | d157088 | 2015-08-17 08:30:31 +0000 | [diff] [blame] | 474 | std::vector<std::vector<DefinedImportData *>> V = binImports(Imports); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 475 | |
| 476 | // Create .idata contents for each DLL. |
Rui Ueyama | d157088 | 2015-08-17 08:30:31 +0000 | [diff] [blame] | 477 | for (std::vector<DefinedImportData *> &Syms : V) { |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 478 | // Create lookup and address tables. If they have external names, |
| 479 | // we need to create HintName chunks to store the names. |
| 480 | // If they don't (if they are import-by-ordinals), we store only |
| 481 | // ordinal values to the table. |
Reid Kleckner | c2eaccb0 | 2017-06-02 18:49:38 +0000 | [diff] [blame] | 482 | size_t Base = Lookups.size(); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 483 | for (DefinedImportData *S : Syms) { |
| 484 | uint16_t Ord = S->getOrdinal(); |
| 485 | if (S->getExternalName().empty()) { |
Reid Kleckner | c2eaccb0 | 2017-06-02 18:49:38 +0000 | [diff] [blame] | 486 | Lookups.push_back(make<OrdinalOnlyChunk>(Ord)); |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 487 | Addresses.push_back(make<OrdinalOnlyChunk>(Ord)); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 488 | continue; |
| 489 | } |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 490 | auto *C = make<HintNameChunk>(S->getExternalName(), Ord); |
Reid Kleckner | c2eaccb0 | 2017-06-02 18:49:38 +0000 | [diff] [blame] | 491 | Lookups.push_back(make<LookupChunk>(C)); |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 492 | Addresses.push_back(make<LookupChunk>(C)); |
| 493 | Hints.push_back(C); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 494 | } |
| 495 | // Terminate with null values. |
Reid Kleckner | c2eaccb0 | 2017-06-02 18:49:38 +0000 | [diff] [blame] | 496 | Lookups.push_back(make<NullChunk>(ptrSize())); |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 497 | Addresses.push_back(make<NullChunk>(ptrSize())); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 498 | |
| 499 | for (int I = 0, E = Syms.size(); I < E; ++I) |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 500 | Syms[I]->setLocation(Addresses[Base + I]); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 501 | |
| 502 | // Create the import table header. |
Peter Collingbourne | 03638d0 | 2017-05-18 18:53:39 +0000 | [diff] [blame] | 503 | DLLNames.push_back(make<StringChunk>(Syms[0]->getDLLName())); |
| 504 | auto *Dir = make<ImportDirectoryChunk>(DLLNames.back()); |
Reid Kleckner | c2eaccb0 | 2017-06-02 18:49:38 +0000 | [diff] [blame] | 505 | Dir->LookupTab = Lookups[Base]; |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 506 | Dir->AddressTab = Addresses[Base]; |
| 507 | Dirs.push_back(Dir); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 508 | } |
| 509 | // Add null terminator. |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 510 | Dirs.push_back(make<NullChunk>(sizeof(ImportDirectoryTableEntry))); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 511 | } |
| 512 | |
| 513 | std::vector<Chunk *> DelayLoadContents::getChunks() { |
| 514 | std::vector<Chunk *> V; |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 515 | V.insert(V.end(), Dirs.begin(), Dirs.end()); |
| 516 | V.insert(V.end(), Names.begin(), Names.end()); |
| 517 | V.insert(V.end(), HintNames.begin(), HintNames.end()); |
Peter Collingbourne | 03638d0 | 2017-05-18 18:53:39 +0000 | [diff] [blame] | 518 | V.insert(V.end(), DLLNames.begin(), DLLNames.end()); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 519 | return V; |
| 520 | } |
| 521 | |
| 522 | std::vector<Chunk *> DelayLoadContents::getDataChunks() { |
| 523 | std::vector<Chunk *> V; |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 524 | V.insert(V.end(), ModuleHandles.begin(), ModuleHandles.end()); |
| 525 | V.insert(V.end(), Addresses.begin(), Addresses.end()); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 526 | return V; |
| 527 | } |
| 528 | |
| 529 | uint64_t DelayLoadContents::getDirSize() { |
| 530 | return Dirs.size() * sizeof(delay_import_directory_table_entry); |
| 531 | } |
| 532 | |
| 533 | void DelayLoadContents::create(Defined *H) { |
| 534 | Helper = H; |
Rui Ueyama | d157088 | 2015-08-17 08:30:31 +0000 | [diff] [blame] | 535 | std::vector<std::vector<DefinedImportData *>> V = binImports(Imports); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 536 | |
| 537 | // Create .didat contents for each DLL. |
Rui Ueyama | d157088 | 2015-08-17 08:30:31 +0000 | [diff] [blame] | 538 | for (std::vector<DefinedImportData *> &Syms : V) { |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 539 | // Create the delay import table header. |
Peter Collingbourne | 03638d0 | 2017-05-18 18:53:39 +0000 | [diff] [blame] | 540 | DLLNames.push_back(make<StringChunk>(Syms[0]->getDLLName())); |
| 541 | auto *Dir = make<DelayDirectoryChunk>(DLLNames.back()); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 542 | |
| 543 | size_t Base = Addresses.size(); |
| 544 | for (DefinedImportData *S : Syms) { |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 545 | Chunk *T = newThunkChunk(S, Dir); |
| 546 | auto *A = make<DelayAddressChunk>(T); |
| 547 | Addresses.push_back(A); |
| 548 | Thunks.push_back(T); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 549 | StringRef ExtName = S->getExternalName(); |
| 550 | if (ExtName.empty()) { |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 551 | Names.push_back(make<OrdinalOnlyChunk>(S->getOrdinal())); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 552 | } else { |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 553 | auto *C = make<HintNameChunk>(ExtName, 0); |
| 554 | Names.push_back(make<LookupChunk>(C)); |
| 555 | HintNames.push_back(C); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 556 | } |
| 557 | } |
| 558 | // Terminate with null values. |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 559 | Addresses.push_back(make<NullChunk>(8)); |
| 560 | Names.push_back(make<NullChunk>(8)); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 561 | |
| 562 | for (int I = 0, E = Syms.size(); I < E; ++I) |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 563 | Syms[I]->setLocation(Addresses[Base + I]); |
| 564 | auto *MH = make<NullChunk>(8); |
Rui Ueyama | cfc2f80 | 2017-09-13 21:54:55 +0000 | [diff] [blame] | 565 | MH->Alignment = 8; |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 566 | ModuleHandles.push_back(MH); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 567 | |
| 568 | // Fill the delay import table header fields. |
| 569 | Dir->ModuleHandle = MH; |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 570 | Dir->AddressTab = Addresses[Base]; |
| 571 | Dir->NameTab = Names[Base]; |
| 572 | Dirs.push_back(Dir); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 573 | } |
| 574 | // Add null terminator. |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 575 | Dirs.push_back(make<NullChunk>(sizeof(delay_import_directory_table_entry))); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 576 | } |
| 577 | |
| 578 | Chunk *DelayLoadContents::newThunkChunk(DefinedImportData *S, Chunk *Dir) { |
| 579 | switch (Config->Machine) { |
| 580 | case AMD64: |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 581 | return make<ThunkChunkX64>(S, Dir, Helper); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 582 | case I386: |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 583 | return make<ThunkChunkX86>(S, Dir, Helper); |
Martin Storsjo | 82eaf6c | 2017-07-25 20:00:37 +0000 | [diff] [blame] | 584 | case ARMNT: |
| 585 | return make<ThunkChunkARM>(S, Dir, Helper); |
Martin Storsjo | 32d21d6 | 2018-09-18 07:22:01 +0000 | [diff] [blame] | 586 | case ARM64: |
| 587 | return make<ThunkChunkARM64>(S, Dir, Helper); |
Rui Ueyama | 857b303 | 2015-08-10 23:02:57 +0000 | [diff] [blame] | 588 | default: |
| 589 | llvm_unreachable("unsupported machine type"); |
| 590 | } |
| 591 | } |
| 592 | |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 593 | EdataContents::EdataContents() { |
| 594 | uint16_t MaxOrdinal = 0; |
| 595 | for (Export &E : Config->Exports) |
| 596 | MaxOrdinal = std::max(MaxOrdinal, E.Ordinal); |
| 597 | |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 598 | auto *DLLName = make<StringChunk>(sys::path::filename(Config->OutputFile)); |
| 599 | auto *AddressTab = make<AddressTableChunk>(MaxOrdinal); |
Rui Ueyama | 97dff9e | 2015-06-17 00:16:33 +0000 | [diff] [blame] | 600 | std::vector<Chunk *> Names; |
| 601 | for (Export &E : Config->Exports) |
| 602 | if (!E.Noname) |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 603 | Names.push_back(make<StringChunk>(E.ExportName)); |
Rui Ueyama | 84425d7 | 2016-01-09 01:22:00 +0000 | [diff] [blame] | 604 | |
| 605 | std::vector<Chunk *> Forwards; |
| 606 | for (Export &E : Config->Exports) { |
| 607 | if (E.ForwardTo.empty()) |
| 608 | continue; |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 609 | E.ForwardChunk = make<StringChunk>(E.ForwardTo); |
Rui Ueyama | 84425d7 | 2016-01-09 01:22:00 +0000 | [diff] [blame] | 610 | Forwards.push_back(E.ForwardChunk); |
| 611 | } |
| 612 | |
Rui Ueyama | 01f9333 | 2017-05-18 17:03:49 +0000 | [diff] [blame] | 613 | auto *NameTab = make<NamePointersChunk>(Names); |
| 614 | auto *OrdinalTab = make<ExportOrdinalChunk>(Names.size()); |
| 615 | auto *Dir = make<ExportDirectoryChunk>(MaxOrdinal, Names.size(), DLLName, |
| 616 | AddressTab, NameTab, OrdinalTab); |
| 617 | Chunks.push_back(Dir); |
| 618 | Chunks.push_back(DLLName); |
| 619 | Chunks.push_back(AddressTab); |
| 620 | Chunks.push_back(NameTab); |
| 621 | Chunks.push_back(OrdinalTab); |
| 622 | Chunks.insert(Chunks.end(), Names.begin(), Names.end()); |
| 623 | Chunks.insert(Chunks.end(), Forwards.begin(), Forwards.end()); |
Rui Ueyama | 4b22fa7 | 2015-06-07 01:15:04 +0000 | [diff] [blame] | 624 | } |
| 625 | |
| 626 | } // namespace coff |
| 627 | } // namespace lld |