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