xref: /freebsd/contrib/llvm-project/lld/COFF/DLL.cpp (revision c66ec88fed842fbaad62c30d510644ceb7bd2d71)
1 //===- DLL.cpp ------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines various types of chunks for the DLL import or export
10 // descriptor tables. They are inherently Windows-specific.
11 // You need to read Microsoft PE/COFF spec to understand details
12 // about the data structures.
13 //
14 // If you are not particularly interested in linking against Windows
15 // DLL, you can skip this file, and you should still be able to
16 // understand the rest of the linker.
17 //
18 //===----------------------------------------------------------------------===//
19 
20 #include "DLL.h"
21 #include "Chunks.h"
22 #include "llvm/Object/COFF.h"
23 #include "llvm/Support/Endian.h"
24 #include "llvm/Support/Path.h"
25 
26 using namespace llvm;
27 using namespace llvm::object;
28 using namespace llvm::support::endian;
29 using namespace llvm::COFF;
30 
31 namespace lld {
32 namespace coff {
33 namespace {
34 
35 // Import table
36 
37 // A chunk for the import descriptor table.
38 class HintNameChunk : public NonSectionChunk {
39 public:
40   HintNameChunk(StringRef n, uint16_t h) : name(n), hint(h) {}
41 
42   size_t getSize() const override {
43     // Starts with 2 byte Hint field, followed by a null-terminated string,
44     // ends with 0 or 1 byte padding.
45     return alignTo(name.size() + 3, 2);
46   }
47 
48   void writeTo(uint8_t *buf) const override {
49     memset(buf, 0, getSize());
50     write16le(buf, hint);
51     memcpy(buf + 2, name.data(), name.size());
52   }
53 
54 private:
55   StringRef name;
56   uint16_t hint;
57 };
58 
59 // A chunk for the import descriptor table.
60 class LookupChunk : public NonSectionChunk {
61 public:
62   explicit LookupChunk(Chunk *c) : hintName(c) {
63     setAlignment(config->wordsize);
64   }
65   size_t getSize() const override { return config->wordsize; }
66 
67   void writeTo(uint8_t *buf) const override {
68     if (config->is64())
69       write64le(buf, hintName->getRVA());
70     else
71       write32le(buf, hintName->getRVA());
72   }
73 
74   Chunk *hintName;
75 };
76 
77 // A chunk for the import descriptor table.
78 // This chunk represent import-by-ordinal symbols.
79 // See Microsoft PE/COFF spec 7.1. Import Header for details.
80 class OrdinalOnlyChunk : public NonSectionChunk {
81 public:
82   explicit OrdinalOnlyChunk(uint16_t v) : ordinal(v) {
83     setAlignment(config->wordsize);
84   }
85   size_t getSize() const override { return config->wordsize; }
86 
87   void writeTo(uint8_t *buf) const override {
88     // An import-by-ordinal slot has MSB 1 to indicate that
89     // this is import-by-ordinal (and not import-by-name).
90     if (config->is64()) {
91       write64le(buf, (1ULL << 63) | ordinal);
92     } else {
93       write32le(buf, (1ULL << 31) | ordinal);
94     }
95   }
96 
97   uint16_t ordinal;
98 };
99 
100 // A chunk for the import descriptor table.
101 class ImportDirectoryChunk : public NonSectionChunk {
102 public:
103   explicit ImportDirectoryChunk(Chunk *n) : dllName(n) {}
104   size_t getSize() const override { return sizeof(ImportDirectoryTableEntry); }
105 
106   void writeTo(uint8_t *buf) const override {
107     memset(buf, 0, getSize());
108 
109     auto *e = (coff_import_directory_table_entry *)(buf);
110     e->ImportLookupTableRVA = lookupTab->getRVA();
111     e->NameRVA = dllName->getRVA();
112     e->ImportAddressTableRVA = addressTab->getRVA();
113   }
114 
115   Chunk *dllName;
116   Chunk *lookupTab;
117   Chunk *addressTab;
118 };
119 
120 // A chunk representing null terminator in the import table.
121 // Contents of this chunk is always null bytes.
122 class NullChunk : public NonSectionChunk {
123 public:
124   explicit NullChunk(size_t n) : size(n) { hasData = false; }
125   size_t getSize() const override { return size; }
126 
127   void writeTo(uint8_t *buf) const override {
128     memset(buf, 0, size);
129   }
130 
131 private:
132   size_t size;
133 };
134 
135 static std::vector<std::vector<DefinedImportData *>>
136 binImports(const std::vector<DefinedImportData *> &imports) {
137   // Group DLL-imported symbols by DLL name because that's how
138   // symbols are laid out in the import descriptor table.
139   auto less = [](const std::string &a, const std::string &b) {
140     return config->dllOrder[a] < config->dllOrder[b];
141   };
142   std::map<std::string, std::vector<DefinedImportData *>,
143            bool(*)(const std::string &, const std::string &)> m(less);
144   for (DefinedImportData *sym : imports)
145     m[sym->getDLLName().lower()].push_back(sym);
146 
147   std::vector<std::vector<DefinedImportData *>> v;
148   for (auto &kv : m) {
149     // Sort symbols by name for each group.
150     std::vector<DefinedImportData *> &syms = kv.second;
151     std::sort(syms.begin(), syms.end(),
152               [](DefinedImportData *a, DefinedImportData *b) {
153                 return a->getName() < b->getName();
154               });
155     v.push_back(std::move(syms));
156   }
157   return v;
158 }
159 
160 // Export table
161 // See Microsoft PE/COFF spec 4.3 for details.
162 
163 // A chunk for the delay import descriptor table etnry.
164 class DelayDirectoryChunk : public NonSectionChunk {
165 public:
166   explicit DelayDirectoryChunk(Chunk *n) : dllName(n) {}
167 
168   size_t getSize() const override {
169     return sizeof(delay_import_directory_table_entry);
170   }
171 
172   void writeTo(uint8_t *buf) const override {
173     memset(buf, 0, getSize());
174 
175     auto *e = (delay_import_directory_table_entry *)(buf);
176     e->Attributes = 1;
177     e->Name = dllName->getRVA();
178     e->ModuleHandle = moduleHandle->getRVA();
179     e->DelayImportAddressTable = addressTab->getRVA();
180     e->DelayImportNameTable = nameTab->getRVA();
181   }
182 
183   Chunk *dllName;
184   Chunk *moduleHandle;
185   Chunk *addressTab;
186   Chunk *nameTab;
187 };
188 
189 // Initial contents for delay-loaded functions.
190 // This code calls __delayLoadHelper2 function to resolve a symbol
191 // which then overwrites its jump table slot with the result
192 // for subsequent function calls.
193 static const uint8_t thunkX64[] = {
194     0x48, 0x8D, 0x05, 0, 0, 0, 0,       // lea     rax, [__imp_<FUNCNAME>]
195     0xE9, 0, 0, 0, 0,                   // jmp     __tailMerge_<lib>
196 };
197 
198 static const uint8_t tailMergeX64[] = {
199     0x51,                               // push    rcx
200     0x52,                               // push    rdx
201     0x41, 0x50,                         // push    r8
202     0x41, 0x51,                         // push    r9
203     0x48, 0x83, 0xEC, 0x48,             // sub     rsp, 48h
204     0x66, 0x0F, 0x7F, 0x04, 0x24,       // movdqa  xmmword ptr [rsp], xmm0
205     0x66, 0x0F, 0x7F, 0x4C, 0x24, 0x10, // movdqa  xmmword ptr [rsp+10h], xmm1
206     0x66, 0x0F, 0x7F, 0x54, 0x24, 0x20, // movdqa  xmmword ptr [rsp+20h], xmm2
207     0x66, 0x0F, 0x7F, 0x5C, 0x24, 0x30, // movdqa  xmmword ptr [rsp+30h], xmm3
208     0x48, 0x8B, 0xD0,                   // mov     rdx, rax
209     0x48, 0x8D, 0x0D, 0, 0, 0, 0,       // lea     rcx, [___DELAY_IMPORT_...]
210     0xE8, 0, 0, 0, 0,                   // call    __delayLoadHelper2
211     0x66, 0x0F, 0x6F, 0x04, 0x24,       // movdqa  xmm0, xmmword ptr [rsp]
212     0x66, 0x0F, 0x6F, 0x4C, 0x24, 0x10, // movdqa  xmm1, xmmword ptr [rsp+10h]
213     0x66, 0x0F, 0x6F, 0x54, 0x24, 0x20, // movdqa  xmm2, xmmword ptr [rsp+20h]
214     0x66, 0x0F, 0x6F, 0x5C, 0x24, 0x30, // movdqa  xmm3, xmmword ptr [rsp+30h]
215     0x48, 0x83, 0xC4, 0x48,             // add     rsp, 48h
216     0x41, 0x59,                         // pop     r9
217     0x41, 0x58,                         // pop     r8
218     0x5A,                               // pop     rdx
219     0x59,                               // pop     rcx
220     0xFF, 0xE0,                         // jmp     rax
221 };
222 
223 static const uint8_t thunkX86[] = {
224     0xB8, 0, 0, 0, 0,  // mov   eax, offset ___imp__<FUNCNAME>
225     0xE9, 0, 0, 0, 0,  // jmp   __tailMerge_<lib>
226 };
227 
228 static const uint8_t tailMergeX86[] = {
229     0x51,              // push  ecx
230     0x52,              // push  edx
231     0x50,              // push  eax
232     0x68, 0, 0, 0, 0,  // push  offset ___DELAY_IMPORT_DESCRIPTOR_<DLLNAME>_dll
233     0xE8, 0, 0, 0, 0,  // call  ___delayLoadHelper2@8
234     0x5A,              // pop   edx
235     0x59,              // pop   ecx
236     0xFF, 0xE0,        // jmp   eax
237 };
238 
239 static const uint8_t thunkARM[] = {
240     0x40, 0xf2, 0x00, 0x0c, // mov.w   ip, #0 __imp_<FUNCNAME>
241     0xc0, 0xf2, 0x00, 0x0c, // mov.t   ip, #0 __imp_<FUNCNAME>
242     0x00, 0xf0, 0x00, 0xb8, // b.w     __tailMerge_<lib>
243 };
244 
245 static const uint8_t tailMergeARM[] = {
246     0x2d, 0xe9, 0x0f, 0x48, // push.w  {r0, r1, r2, r3, r11, lr}
247     0x0d, 0xf2, 0x10, 0x0b, // addw    r11, sp, #16
248     0x2d, 0xed, 0x10, 0x0b, // vpush   {d0, d1, d2, d3, d4, d5, d6, d7}
249     0x61, 0x46,             // mov     r1, ip
250     0x40, 0xf2, 0x00, 0x00, // mov.w   r0, #0 DELAY_IMPORT_DESCRIPTOR
251     0xc0, 0xf2, 0x00, 0x00, // mov.t   r0, #0 DELAY_IMPORT_DESCRIPTOR
252     0x00, 0xf0, 0x00, 0xd0, // bl      #0 __delayLoadHelper2
253     0x84, 0x46,             // mov     ip, r0
254     0xbd, 0xec, 0x10, 0x0b, // vpop    {d0, d1, d2, d3, d4, d5, d6, d7}
255     0xbd, 0xe8, 0x0f, 0x48, // pop.w   {r0, r1, r2, r3, r11, lr}
256     0x60, 0x47,             // bx      ip
257 };
258 
259 static const uint8_t thunkARM64[] = {
260     0x11, 0x00, 0x00, 0x90, // adrp    x17, #0      __imp_<FUNCNAME>
261     0x31, 0x02, 0x00, 0x91, // add     x17, x17, #0 :lo12:__imp_<FUNCNAME>
262     0x00, 0x00, 0x00, 0x14, // b       __tailMerge_<lib>
263 };
264 
265 static const uint8_t tailMergeARM64[] = {
266     0xfd, 0x7b, 0xb3, 0xa9, // stp     x29, x30, [sp, #-208]!
267     0xfd, 0x03, 0x00, 0x91, // mov     x29, sp
268     0xe0, 0x07, 0x01, 0xa9, // stp     x0, x1, [sp, #16]
269     0xe2, 0x0f, 0x02, 0xa9, // stp     x2, x3, [sp, #32]
270     0xe4, 0x17, 0x03, 0xa9, // stp     x4, x5, [sp, #48]
271     0xe6, 0x1f, 0x04, 0xa9, // stp     x6, x7, [sp, #64]
272     0xe0, 0x87, 0x02, 0xad, // stp     q0, q1, [sp, #80]
273     0xe2, 0x8f, 0x03, 0xad, // stp     q2, q3, [sp, #112]
274     0xe4, 0x97, 0x04, 0xad, // stp     q4, q5, [sp, #144]
275     0xe6, 0x9f, 0x05, 0xad, // stp     q6, q7, [sp, #176]
276     0xe1, 0x03, 0x11, 0xaa, // mov     x1, x17
277     0x00, 0x00, 0x00, 0x90, // adrp    x0, #0     DELAY_IMPORT_DESCRIPTOR
278     0x00, 0x00, 0x00, 0x91, // add     x0, x0, #0 :lo12:DELAY_IMPORT_DESCRIPTOR
279     0x00, 0x00, 0x00, 0x94, // bl      #0 __delayLoadHelper2
280     0xf0, 0x03, 0x00, 0xaa, // mov     x16, x0
281     0xe6, 0x9f, 0x45, 0xad, // ldp     q6, q7, [sp, #176]
282     0xe4, 0x97, 0x44, 0xad, // ldp     q4, q5, [sp, #144]
283     0xe2, 0x8f, 0x43, 0xad, // ldp     q2, q3, [sp, #112]
284     0xe0, 0x87, 0x42, 0xad, // ldp     q0, q1, [sp, #80]
285     0xe6, 0x1f, 0x44, 0xa9, // ldp     x6, x7, [sp, #64]
286     0xe4, 0x17, 0x43, 0xa9, // ldp     x4, x5, [sp, #48]
287     0xe2, 0x0f, 0x42, 0xa9, // ldp     x2, x3, [sp, #32]
288     0xe0, 0x07, 0x41, 0xa9, // ldp     x0, x1, [sp, #16]
289     0xfd, 0x7b, 0xcd, 0xa8, // ldp     x29, x30, [sp], #208
290     0x00, 0x02, 0x1f, 0xd6, // br      x16
291 };
292 
293 // A chunk for the delay import thunk.
294 class ThunkChunkX64 : public NonSectionChunk {
295 public:
296   ThunkChunkX64(Defined *i, Chunk *tm) : imp(i), tailMerge(tm) {}
297 
298   size_t getSize() const override { return sizeof(thunkX64); }
299 
300   void writeTo(uint8_t *buf) const override {
301     memcpy(buf, thunkX64, sizeof(thunkX64));
302     write32le(buf + 3, imp->getRVA() - rva - 7);
303     write32le(buf + 8, tailMerge->getRVA() - rva - 12);
304   }
305 
306   Defined *imp = nullptr;
307   Chunk *tailMerge = nullptr;
308 };
309 
310 class TailMergeChunkX64 : public NonSectionChunk {
311 public:
312   TailMergeChunkX64(Chunk *d, Defined *h) : desc(d), helper(h) {}
313 
314   size_t getSize() const override { return sizeof(tailMergeX64); }
315 
316   void writeTo(uint8_t *buf) const override {
317     memcpy(buf, tailMergeX64, sizeof(tailMergeX64));
318     write32le(buf + 39, desc->getRVA() - rva - 43);
319     write32le(buf + 44, helper->getRVA() - rva - 48);
320   }
321 
322   Chunk *desc = nullptr;
323   Defined *helper = nullptr;
324 };
325 
326 class ThunkChunkX86 : public NonSectionChunk {
327 public:
328   ThunkChunkX86(Defined *i, Chunk *tm) : imp(i), tailMerge(tm) {}
329 
330   size_t getSize() const override { return sizeof(thunkX86); }
331 
332   void writeTo(uint8_t *buf) const override {
333     memcpy(buf, thunkX86, sizeof(thunkX86));
334     write32le(buf + 1, imp->getRVA() + config->imageBase);
335     write32le(buf + 6, tailMerge->getRVA() - rva - 10);
336   }
337 
338   void getBaserels(std::vector<Baserel> *res) override {
339     res->emplace_back(rva + 1);
340   }
341 
342   Defined *imp = nullptr;
343   Chunk *tailMerge = nullptr;
344 };
345 
346 class TailMergeChunkX86 : public NonSectionChunk {
347 public:
348   TailMergeChunkX86(Chunk *d, Defined *h) : desc(d), helper(h) {}
349 
350   size_t getSize() const override { return sizeof(tailMergeX86); }
351 
352   void writeTo(uint8_t *buf) const override {
353     memcpy(buf, tailMergeX86, sizeof(tailMergeX86));
354     write32le(buf + 4, desc->getRVA() + config->imageBase);
355     write32le(buf + 9, helper->getRVA() - rva - 13);
356   }
357 
358   void getBaserels(std::vector<Baserel> *res) override {
359     res->emplace_back(rva + 4);
360   }
361 
362   Chunk *desc = nullptr;
363   Defined *helper = nullptr;
364 };
365 
366 class ThunkChunkARM : public NonSectionChunk {
367 public:
368   ThunkChunkARM(Defined *i, Chunk *tm) : imp(i), tailMerge(tm) {
369     setAlignment(2);
370   }
371 
372   size_t getSize() const override { return sizeof(thunkARM); }
373 
374   void writeTo(uint8_t *buf) const override {
375     memcpy(buf, thunkARM, sizeof(thunkARM));
376     applyMOV32T(buf + 0, imp->getRVA() + config->imageBase);
377     applyBranch24T(buf + 8, tailMerge->getRVA() - rva - 12);
378   }
379 
380   void getBaserels(std::vector<Baserel> *res) override {
381     res->emplace_back(rva + 0, IMAGE_REL_BASED_ARM_MOV32T);
382   }
383 
384   Defined *imp = nullptr;
385   Chunk *tailMerge = nullptr;
386 };
387 
388 class TailMergeChunkARM : public NonSectionChunk {
389 public:
390   TailMergeChunkARM(Chunk *d, Defined *h) : desc(d), helper(h) {
391     setAlignment(2);
392   }
393 
394   size_t getSize() const override { return sizeof(tailMergeARM); }
395 
396   void writeTo(uint8_t *buf) const override {
397     memcpy(buf, tailMergeARM, sizeof(tailMergeARM));
398     applyMOV32T(buf + 14, desc->getRVA() + config->imageBase);
399     applyBranch24T(buf + 22, helper->getRVA() - rva - 26);
400   }
401 
402   void getBaserels(std::vector<Baserel> *res) override {
403     res->emplace_back(rva + 14, IMAGE_REL_BASED_ARM_MOV32T);
404   }
405 
406   Chunk *desc = nullptr;
407   Defined *helper = nullptr;
408 };
409 
410 class ThunkChunkARM64 : public NonSectionChunk {
411 public:
412   ThunkChunkARM64(Defined *i, Chunk *tm) : imp(i), tailMerge(tm) {
413     setAlignment(4);
414   }
415 
416   size_t getSize() const override { return sizeof(thunkARM64); }
417 
418   void writeTo(uint8_t *buf) const override {
419     memcpy(buf, thunkARM64, sizeof(thunkARM64));
420     applyArm64Addr(buf + 0, imp->getRVA(), rva + 0, 12);
421     applyArm64Imm(buf + 4, imp->getRVA() & 0xfff, 0);
422     applyArm64Branch26(buf + 8, tailMerge->getRVA() - rva - 8);
423   }
424 
425   Defined *imp = nullptr;
426   Chunk *tailMerge = nullptr;
427 };
428 
429 class TailMergeChunkARM64 : public NonSectionChunk {
430 public:
431   TailMergeChunkARM64(Chunk *d, Defined *h) : desc(d), helper(h) {
432     setAlignment(4);
433   }
434 
435   size_t getSize() const override { return sizeof(tailMergeARM64); }
436 
437   void writeTo(uint8_t *buf) const override {
438     memcpy(buf, tailMergeARM64, sizeof(tailMergeARM64));
439     applyArm64Addr(buf + 44, desc->getRVA(), rva + 44, 12);
440     applyArm64Imm(buf + 48, desc->getRVA() & 0xfff, 0);
441     applyArm64Branch26(buf + 52, helper->getRVA() - rva - 52);
442   }
443 
444   Chunk *desc = nullptr;
445   Defined *helper = nullptr;
446 };
447 
448 // A chunk for the import descriptor table.
449 class DelayAddressChunk : public NonSectionChunk {
450 public:
451   explicit DelayAddressChunk(Chunk *c) : thunk(c) {
452     setAlignment(config->wordsize);
453   }
454   size_t getSize() const override { return config->wordsize; }
455 
456   void writeTo(uint8_t *buf) const override {
457     if (config->is64()) {
458       write64le(buf, thunk->getRVA() + config->imageBase);
459     } else {
460       uint32_t bit = 0;
461       // Pointer to thumb code must have the LSB set, so adjust it.
462       if (config->machine == ARMNT)
463         bit = 1;
464       write32le(buf, (thunk->getRVA() + config->imageBase) | bit);
465     }
466   }
467 
468   void getBaserels(std::vector<Baserel> *res) override {
469     res->emplace_back(rva);
470   }
471 
472   Chunk *thunk;
473 };
474 
475 // Export table
476 // Read Microsoft PE/COFF spec 5.3 for details.
477 
478 // A chunk for the export descriptor table.
479 class ExportDirectoryChunk : public NonSectionChunk {
480 public:
481   ExportDirectoryChunk(int i, int j, Chunk *d, Chunk *a, Chunk *n, Chunk *o)
482       : maxOrdinal(i), nameTabSize(j), dllName(d), addressTab(a), nameTab(n),
483         ordinalTab(o) {}
484 
485   size_t getSize() const override {
486     return sizeof(export_directory_table_entry);
487   }
488 
489   void writeTo(uint8_t *buf) const override {
490     memset(buf, 0, getSize());
491 
492     auto *e = (export_directory_table_entry *)(buf);
493     e->NameRVA = dllName->getRVA();
494     e->OrdinalBase = 0;
495     e->AddressTableEntries = maxOrdinal + 1;
496     e->NumberOfNamePointers = nameTabSize;
497     e->ExportAddressTableRVA = addressTab->getRVA();
498     e->NamePointerRVA = nameTab->getRVA();
499     e->OrdinalTableRVA = ordinalTab->getRVA();
500   }
501 
502   uint16_t maxOrdinal;
503   uint16_t nameTabSize;
504   Chunk *dllName;
505   Chunk *addressTab;
506   Chunk *nameTab;
507   Chunk *ordinalTab;
508 };
509 
510 class AddressTableChunk : public NonSectionChunk {
511 public:
512   explicit AddressTableChunk(size_t maxOrdinal) : size(maxOrdinal + 1) {}
513   size_t getSize() const override { return size * 4; }
514 
515   void writeTo(uint8_t *buf) const override {
516     memset(buf, 0, getSize());
517 
518     for (const Export &e : config->exports) {
519       uint8_t *p = buf + e.ordinal * 4;
520       uint32_t bit = 0;
521       // Pointer to thumb code must have the LSB set, so adjust it.
522       if (config->machine == ARMNT && !e.data)
523         bit = 1;
524       if (e.forwardChunk) {
525         write32le(p, e.forwardChunk->getRVA() | bit);
526       } else {
527         write32le(p, cast<Defined>(e.sym)->getRVA() | bit);
528       }
529     }
530   }
531 
532 private:
533   size_t size;
534 };
535 
536 class NamePointersChunk : public NonSectionChunk {
537 public:
538   explicit NamePointersChunk(std::vector<Chunk *> &v) : chunks(v) {}
539   size_t getSize() const override { return chunks.size() * 4; }
540 
541   void writeTo(uint8_t *buf) const override {
542     for (Chunk *c : chunks) {
543       write32le(buf, c->getRVA());
544       buf += 4;
545     }
546   }
547 
548 private:
549   std::vector<Chunk *> chunks;
550 };
551 
552 class ExportOrdinalChunk : public NonSectionChunk {
553 public:
554   explicit ExportOrdinalChunk(size_t i) : size(i) {}
555   size_t getSize() const override { return size * 2; }
556 
557   void writeTo(uint8_t *buf) const override {
558     for (Export &e : config->exports) {
559       if (e.noname)
560         continue;
561       write16le(buf, e.ordinal);
562       buf += 2;
563     }
564   }
565 
566 private:
567   size_t size;
568 };
569 
570 } // anonymous namespace
571 
572 void IdataContents::create() {
573   std::vector<std::vector<DefinedImportData *>> v = binImports(imports);
574 
575   // Create .idata contents for each DLL.
576   for (std::vector<DefinedImportData *> &syms : v) {
577     // Create lookup and address tables. If they have external names,
578     // we need to create hintName chunks to store the names.
579     // If they don't (if they are import-by-ordinals), we store only
580     // ordinal values to the table.
581     size_t base = lookups.size();
582     for (DefinedImportData *s : syms) {
583       uint16_t ord = s->getOrdinal();
584       if (s->getExternalName().empty()) {
585         lookups.push_back(make<OrdinalOnlyChunk>(ord));
586         addresses.push_back(make<OrdinalOnlyChunk>(ord));
587         continue;
588       }
589       auto *c = make<HintNameChunk>(s->getExternalName(), ord);
590       lookups.push_back(make<LookupChunk>(c));
591       addresses.push_back(make<LookupChunk>(c));
592       hints.push_back(c);
593     }
594     // Terminate with null values.
595     lookups.push_back(make<NullChunk>(config->wordsize));
596     addresses.push_back(make<NullChunk>(config->wordsize));
597 
598     for (int i = 0, e = syms.size(); i < e; ++i)
599       syms[i]->setLocation(addresses[base + i]);
600 
601     // Create the import table header.
602     dllNames.push_back(make<StringChunk>(syms[0]->getDLLName()));
603     auto *dir = make<ImportDirectoryChunk>(dllNames.back());
604     dir->lookupTab = lookups[base];
605     dir->addressTab = addresses[base];
606     dirs.push_back(dir);
607   }
608   // Add null terminator.
609   dirs.push_back(make<NullChunk>(sizeof(ImportDirectoryTableEntry)));
610 }
611 
612 std::vector<Chunk *> DelayLoadContents::getChunks() {
613   std::vector<Chunk *> v;
614   v.insert(v.end(), dirs.begin(), dirs.end());
615   v.insert(v.end(), names.begin(), names.end());
616   v.insert(v.end(), hintNames.begin(), hintNames.end());
617   v.insert(v.end(), dllNames.begin(), dllNames.end());
618   return v;
619 }
620 
621 std::vector<Chunk *> DelayLoadContents::getDataChunks() {
622   std::vector<Chunk *> v;
623   v.insert(v.end(), moduleHandles.begin(), moduleHandles.end());
624   v.insert(v.end(), addresses.begin(), addresses.end());
625   return v;
626 }
627 
628 uint64_t DelayLoadContents::getDirSize() {
629   return dirs.size() * sizeof(delay_import_directory_table_entry);
630 }
631 
632 void DelayLoadContents::create(Defined *h) {
633   helper = h;
634   std::vector<std::vector<DefinedImportData *>> v = binImports(imports);
635 
636   // Create .didat contents for each DLL.
637   for (std::vector<DefinedImportData *> &syms : v) {
638     // Create the delay import table header.
639     dllNames.push_back(make<StringChunk>(syms[0]->getDLLName()));
640     auto *dir = make<DelayDirectoryChunk>(dllNames.back());
641 
642     size_t base = addresses.size();
643     Chunk *tm = newTailMergeChunk(dir);
644     for (DefinedImportData *s : syms) {
645       Chunk *t = newThunkChunk(s, tm);
646       auto *a = make<DelayAddressChunk>(t);
647       addresses.push_back(a);
648       thunks.push_back(t);
649       StringRef extName = s->getExternalName();
650       if (extName.empty()) {
651         names.push_back(make<OrdinalOnlyChunk>(s->getOrdinal()));
652       } else {
653         auto *c = make<HintNameChunk>(extName, 0);
654         names.push_back(make<LookupChunk>(c));
655         hintNames.push_back(c);
656       }
657     }
658     thunks.push_back(tm);
659     // Terminate with null values.
660     addresses.push_back(make<NullChunk>(8));
661     names.push_back(make<NullChunk>(8));
662 
663     for (int i = 0, e = syms.size(); i < e; ++i)
664       syms[i]->setLocation(addresses[base + i]);
665     auto *mh = make<NullChunk>(8);
666     mh->setAlignment(8);
667     moduleHandles.push_back(mh);
668 
669     // Fill the delay import table header fields.
670     dir->moduleHandle = mh;
671     dir->addressTab = addresses[base];
672     dir->nameTab = names[base];
673     dirs.push_back(dir);
674   }
675   // Add null terminator.
676   dirs.push_back(make<NullChunk>(sizeof(delay_import_directory_table_entry)));
677 }
678 
679 Chunk *DelayLoadContents::newTailMergeChunk(Chunk *dir) {
680   switch (config->machine) {
681   case AMD64:
682     return make<TailMergeChunkX64>(dir, helper);
683   case I386:
684     return make<TailMergeChunkX86>(dir, helper);
685   case ARMNT:
686     return make<TailMergeChunkARM>(dir, helper);
687   case ARM64:
688     return make<TailMergeChunkARM64>(dir, helper);
689   default:
690     llvm_unreachable("unsupported machine type");
691   }
692 }
693 
694 Chunk *DelayLoadContents::newThunkChunk(DefinedImportData *s,
695                                         Chunk *tailMerge) {
696   switch (config->machine) {
697   case AMD64:
698     return make<ThunkChunkX64>(s, tailMerge);
699   case I386:
700     return make<ThunkChunkX86>(s, tailMerge);
701   case ARMNT:
702     return make<ThunkChunkARM>(s, tailMerge);
703   case ARM64:
704     return make<ThunkChunkARM64>(s, tailMerge);
705   default:
706     llvm_unreachable("unsupported machine type");
707   }
708 }
709 
710 EdataContents::EdataContents() {
711   uint16_t maxOrdinal = 0;
712   for (Export &e : config->exports)
713     maxOrdinal = std::max(maxOrdinal, e.ordinal);
714 
715   auto *dllName = make<StringChunk>(sys::path::filename(config->outputFile));
716   auto *addressTab = make<AddressTableChunk>(maxOrdinal);
717   std::vector<Chunk *> names;
718   for (Export &e : config->exports)
719     if (!e.noname)
720       names.push_back(make<StringChunk>(e.exportName));
721 
722   std::vector<Chunk *> forwards;
723   for (Export &e : config->exports) {
724     if (e.forwardTo.empty())
725       continue;
726     e.forwardChunk = make<StringChunk>(e.forwardTo);
727     forwards.push_back(e.forwardChunk);
728   }
729 
730   auto *nameTab = make<NamePointersChunk>(names);
731   auto *ordinalTab = make<ExportOrdinalChunk>(names.size());
732   auto *dir = make<ExportDirectoryChunk>(maxOrdinal, names.size(), dllName,
733                                          addressTab, nameTab, ordinalTab);
734   chunks.push_back(dir);
735   chunks.push_back(dllName);
736   chunks.push_back(addressTab);
737   chunks.push_back(nameTab);
738   chunks.push_back(ordinalTab);
739   chunks.insert(chunks.end(), names.begin(), names.end());
740   chunks.insert(chunks.end(), forwards.begin(), forwards.end());
741 }
742 
743 } // namespace coff
744 } // namespace lld
745