e076d8e71109a80be1beadca5b489c9e0f7bc6a9
[lldb.git] / lld / COFF / Chunks.h
1 //===- Chunks.h -------------------------------------------------*- C++ -*-===//
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 #ifndef LLD_COFF_CHUNKS_H
10 #define LLD_COFF_CHUNKS_H
11
12 #include "Config.h"
13 #include "InputFiles.h"
14 #include "lld/Common/LLVM.h"
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/PointerIntPair.h"
17 #include "llvm/ADT/iterator.h"
18 #include "llvm/ADT/iterator_range.h"
19 #include "llvm/MC/StringTableBuilder.h"
20 #include "llvm/Object/COFF.h"
21 #include <utility>
22 #include <vector>
23
24 namespace lld {
25 namespace coff {
26
27 using llvm::COFF::ImportDirectoryTableEntry;
28 using llvm::object::COFFSymbolRef;
29 using llvm::object::SectionRef;
30 using llvm::object::coff_relocation;
31 using llvm::object::coff_section;
32
33 class Baserel;
34 class Defined;
35 class DefinedImportData;
36 class DefinedRegular;
37 class ObjFile;
38 class OutputSection;
39 class RuntimePseudoReloc;
40 class Symbol;
41
42 // Mask for permissions (discardable, writable, readable, executable, etc).
43 const uint32_t permMask = 0xFE000000;
44
45 // Mask for section types (code, data, bss).
46 const uint32_t typeMask = 0x000000E0;
47
48 // The log base 2 of the largest section alignment, which is log2(8192), or 13.
49 enum : unsigned { Log2MaxSectionAlignment = 13 };
50
51 // A Chunk represents a chunk of data that will occupy space in the
52 // output (if the resolver chose that). It may or may not be backed by
53 // a section of an input file. It could be linker-created data, or
54 // doesn't even have actual data (if common or bss).
55 class Chunk {
56 public:
57   enum Kind : uint8_t { SectionKind, OtherKind, ImportThunkKind };
58   Kind kind() const { return chunkKind; }
59
60   // Returns the size of this chunk (even if this is a common or BSS.)
61   size_t getSize() const;
62
63   // Returns chunk alignment in power of two form. Value values are powers of
64   // two from 1 to 8192.
65   uint32_t getAlignment() const { return 1U << p2Align; }
66
67   // Update the chunk section alignment measured in bytes. Internally alignment
68   // is stored in log2.
69   void setAlignment(uint32_t align) {
70     // Treat zero byte alignment as 1 byte alignment.
71     align = align ? align : 1;
72     assert(llvm::isPowerOf2_32(align) && "alignment is not a power of 2");
73     p2Align = llvm::Log2_32(align);
74     assert(p2Align <= Log2MaxSectionAlignment &&
75            "impossible requested alignment");
76   }
77
78   // Write this chunk to a mmap'ed file, assuming Buf is pointing to
79   // beginning of the file. Because this function may use RVA values
80   // of other chunks for relocations, you need to set them properly
81   // before calling this function.
82   void writeTo(uint8_t *buf) const;
83
84   // The writer sets and uses the addresses. In practice, PE images cannot be
85   // larger than 2GB. Chunks are always laid as part of the image, so Chunk RVAs
86   // can be stored with 32 bits.
87   uint32_t getRVA() const { return rva; }
88   void setRVA(uint64_t v) {
89     rva = (uint32_t)v;
90     assert(rva == v && "RVA truncated");
91   }
92
93   // Returns readable/writable/executable bits.
94   uint32_t getOutputCharacteristics() const;
95
96   // Returns the section name if this is a section chunk.
97   // It is illegal to call this function on non-section chunks.
98   StringRef getSectionName() const;
99
100   // An output section has pointers to chunks in the section, and each
101   // chunk has a back pointer to an output section.
102   void setOutputSectionIdx(uint16_t o) { osidx = o; }
103   uint16_t getOutputSectionIdx() const { return osidx; }
104   OutputSection *getOutputSection() const;
105
106   // Windows-specific.
107   // Collect all locations that contain absolute addresses for base relocations.
108   void getBaserels(std::vector<Baserel> *res);
109
110   // Returns a human-readable name of this chunk. Chunks are unnamed chunks of
111   // bytes, so this is used only for logging or debugging.
112   StringRef getDebugName() const;
113
114   // Return true if this file has the hotpatch flag set to true in the
115   // S_COMPILE3 record in codeview debug info. Also returns true for some thunks
116   // synthesized by the linker.
117   bool isHotPatchable() const;
118
119 protected:
120   Chunk(Kind k = OtherKind) : chunkKind(k), hasData(true), p2Align(0) {}
121
122   const Kind chunkKind;
123
124 public:
125   // Returns true if this has non-zero data. BSS chunks return
126   // false. If false is returned, the space occupied by this chunk
127   // will be filled with zeros. Corresponds to the
128   // IMAGE_SCN_CNT_UNINITIALIZED_DATA section characteristic bit.
129   uint8_t hasData : 1;
130
131 public:
132   // The alignment of this chunk, stored in log2 form. The writer uses the
133   // value.
134   uint8_t p2Align : 7;
135
136   // The output section index for this chunk. The first valid section number is
137   // one.
138   uint16_t osidx = 0;
139
140   // The RVA of this chunk in the output. The writer sets a value.
141   uint32_t rva = 0;
142 };
143
144 class NonSectionChunk : public Chunk {
145 public:
146   virtual ~NonSectionChunk() = default;
147
148   // Returns the size of this chunk (even if this is a common or BSS.)
149   virtual size_t getSize() const = 0;
150
151   virtual uint32_t getOutputCharacteristics() const { return 0; }
152
153   // Write this chunk to a mmap'ed file, assuming Buf is pointing to
154   // beginning of the file. Because this function may use RVA values
155   // of other chunks for relocations, you need to set them properly
156   // before calling this function.
157   virtual void writeTo(uint8_t *buf) const {}
158
159   // Returns the section name if this is a section chunk.
160   // It is illegal to call this function on non-section chunks.
161   virtual StringRef getSectionName() const {
162     llvm_unreachable("unimplemented getSectionName");
163   }
164
165   // Windows-specific.
166   // Collect all locations that contain absolute addresses for base relocations.
167   virtual void getBaserels(std::vector<Baserel> *res) {}
168
169   // Returns a human-readable name of this chunk. Chunks are unnamed chunks of
170   // bytes, so this is used only for logging or debugging.
171   virtual StringRef getDebugName() const { return ""; }
172
173   static bool classof(const Chunk *c) { return c->kind() != SectionKind; }
174
175 protected:
176   NonSectionChunk(Kind k = OtherKind) : Chunk(k) {}
177 };
178
179 // A chunk corresponding a section of an input file.
180 class SectionChunk final : public Chunk {
181   // Identical COMDAT Folding feature accesses section internal data.
182   friend class ICF;
183
184 public:
185   class symbol_iterator : public llvm::iterator_adaptor_base<
186                               symbol_iterator, const coff_relocation *,
187                               std::random_access_iterator_tag, Symbol *> {
188     friend SectionChunk;
189
190     ObjFile *file;
191
192     symbol_iterator(ObjFile *file, const coff_relocation *i)
193         : symbol_iterator::iterator_adaptor_base(i), file(file) {}
194
195   public:
196     symbol_iterator() = default;
197
198     Symbol *operator*() const { return file->getSymbol(I->SymbolTableIndex); }
199   };
200
201   SectionChunk(ObjFile *file, const coff_section *header);
202   static bool classof(const Chunk *c) { return c->kind() == SectionKind; }
203   size_t getSize() const { return header->SizeOfRawData; }
204   ArrayRef<uint8_t> getContents() const;
205   void writeTo(uint8_t *buf) const;
206
207   // Defend against unsorted relocations. This may be overly conservative.
208   void sortRelocations();
209
210   // Write and relocate a portion of the section. This is intended to be called
211   // in a loop. Relocations must be sorted first.
212   void writeAndRelocateSubsection(ArrayRef<uint8_t> sec,
213                                   ArrayRef<uint8_t> subsec,
214                                   uint32_t &nextRelocIndex, uint8_t *buf) const;
215
216   uint32_t getOutputCharacteristics() const {
217     return header->Characteristics & (permMask | typeMask);
218   }
219   StringRef getSectionName() const {
220     return StringRef(sectionNameData, sectionNameSize);
221   }
222   void getBaserels(std::vector<Baserel> *res);
223   bool isCOMDAT() const;
224   void applyRelocation(uint8_t *off, const coff_relocation &rel) const;
225   void applyRelX64(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
226                    uint64_t p) const;
227   void applyRelX86(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
228                    uint64_t p) const;
229   void applyRelARM(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
230                    uint64_t p) const;
231   void applyRelARM64(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
232                      uint64_t p) const;
233
234   void getRuntimePseudoRelocs(std::vector<RuntimePseudoReloc> &res);
235
236   // Called if the garbage collector decides to not include this chunk
237   // in a final output. It's supposed to print out a log message to stdout.
238   void printDiscardedMessage() const;
239
240   // Adds COMDAT associative sections to this COMDAT section. A chunk
241   // and its children are treated as a group by the garbage collector.
242   void addAssociative(SectionChunk *child);
243
244   StringRef getDebugName() const;
245
246   // True if this is a codeview debug info chunk. These will not be laid out in
247   // the image. Instead they will end up in the PDB, if one is requested.
248   bool isCodeView() const {
249     return getSectionName() == ".debug" || getSectionName().startswith(".debug$");
250   }
251
252   // True if this is a DWARF debug info or exception handling chunk.
253   bool isDWARF() const {
254     return getSectionName().startswith(".debug_") || getSectionName() == ".eh_frame";
255   }
256
257   // Allow iteration over the bodies of this chunk's relocated symbols.
258   llvm::iterator_range<symbol_iterator> symbols() const {
259     return llvm::make_range(symbol_iterator(file, relocsData),
260                             symbol_iterator(file, relocsData + relocsSize));
261   }
262
263   ArrayRef<coff_relocation> getRelocs() const {
264     return llvm::makeArrayRef(relocsData, relocsSize);
265   }
266
267   // Reloc setter used by ARM range extension thunk insertion.
268   void setRelocs(ArrayRef<coff_relocation> newRelocs) {
269     relocsData = newRelocs.data();
270     relocsSize = newRelocs.size();
271     assert(relocsSize == newRelocs.size() && "reloc size truncation");
272   }
273
274   // Single linked list iterator for associated comdat children.
275   class AssociatedIterator
276       : public llvm::iterator_facade_base<
277             AssociatedIterator, std::forward_iterator_tag, SectionChunk> {
278   public:
279     AssociatedIterator() = default;
280     AssociatedIterator(SectionChunk *head) : cur(head) {}
281     bool operator==(const AssociatedIterator &r) const { return cur == r.cur; }
282     // FIXME: Wrong const-ness, but it makes filter ranges work.
283     SectionChunk &operator*() const { return *cur; }
284     SectionChunk &operator*() { return *cur; }
285     AssociatedIterator &operator++() {
286       cur = cur->assocChildren;
287       return *this;
288     }
289
290   private:
291     SectionChunk *cur = nullptr;
292   };
293
294   // Allow iteration over the associated child chunks for this section.
295   llvm::iterator_range<AssociatedIterator> children() const {
296     return llvm::make_range(AssociatedIterator(assocChildren),
297                             AssociatedIterator(nullptr));
298   }
299
300   // The section ID this chunk belongs to in its Obj.
301   uint32_t getSectionNumber() const;
302
303   ArrayRef<uint8_t> consumeDebugMagic();
304
305   static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> data,
306                                              StringRef sectionName);
307
308   static SectionChunk *findByName(ArrayRef<SectionChunk *> sections,
309                                   StringRef name);
310
311   // The file that this chunk was created from.
312   ObjFile *file;
313
314   // Pointer to the COFF section header in the input file.
315   const coff_section *header;
316
317   // The COMDAT leader symbol if this is a COMDAT chunk.
318   DefinedRegular *sym = nullptr;
319
320   // The CRC of the contents as described in the COFF spec 4.5.5.
321   // Auxiliary Format 5: Section Definitions. Used for ICF.
322   uint32_t checksum = 0;
323
324   // Used by the garbage collector.
325   bool live;
326
327   // Whether this section needs to be kept distinct from other sections during
328   // ICF. This is set by the driver using address-significance tables.
329   bool keepUnique = false;
330
331   // The COMDAT selection if this is a COMDAT chunk.
332   llvm::COFF::COMDATType selection = (llvm::COFF::COMDATType)0;
333
334   // A pointer pointing to a replacement for this chunk.
335   // Initially it points to "this" object. If this chunk is merged
336   // with other chunk by ICF, it points to another chunk,
337   // and this chunk is considered as dead.
338   SectionChunk *repl;
339
340 private:
341   SectionChunk *assocChildren = nullptr;
342
343   // Used for ICF (Identical COMDAT Folding)
344   void replace(SectionChunk *other);
345   uint32_t eqClass[2] = {0, 0};
346
347   // Relocations for this section. Size is stored below.
348   const coff_relocation *relocsData;
349
350   // Section name string. Size is stored below.
351   const char *sectionNameData;
352
353   uint32_t relocsSize = 0;
354   uint32_t sectionNameSize = 0;
355 };
356
357 // Inline methods to implement faux-virtual dispatch for SectionChunk.
358
359 inline size_t Chunk::getSize() const {
360   if (isa<SectionChunk>(this))
361     return static_cast<const SectionChunk *>(this)->getSize();
362   else
363     return static_cast<const NonSectionChunk *>(this)->getSize();
364 }
365
366 inline uint32_t Chunk::getOutputCharacteristics() const {
367   if (isa<SectionChunk>(this))
368     return static_cast<const SectionChunk *>(this)->getOutputCharacteristics();
369   else
370     return static_cast<const NonSectionChunk *>(this)
371         ->getOutputCharacteristics();
372 }
373
374 inline void Chunk::writeTo(uint8_t *buf) const {
375   if (isa<SectionChunk>(this))
376     static_cast<const SectionChunk *>(this)->writeTo(buf);
377   else
378     static_cast<const NonSectionChunk *>(this)->writeTo(buf);
379 }
380
381 inline StringRef Chunk::getSectionName() const {
382   if (isa<SectionChunk>(this))
383     return static_cast<const SectionChunk *>(this)->getSectionName();
384   else
385     return static_cast<const NonSectionChunk *>(this)->getSectionName();
386 }
387
388 inline void Chunk::getBaserels(std::vector<Baserel> *res) {
389   if (isa<SectionChunk>(this))
390     static_cast<SectionChunk *>(this)->getBaserels(res);
391   else
392     static_cast<NonSectionChunk *>(this)->getBaserels(res);
393 }
394
395 inline StringRef Chunk::getDebugName() const {
396   if (isa<SectionChunk>(this))
397     return static_cast<const SectionChunk *>(this)->getDebugName();
398   else
399     return static_cast<const NonSectionChunk *>(this)->getDebugName();
400 }
401
402 // This class is used to implement an lld-specific feature (not implemented in
403 // MSVC) that minimizes the output size by finding string literals sharing tail
404 // parts and merging them.
405 //
406 // If string tail merging is enabled and a section is identified as containing a
407 // string literal, it is added to a MergeChunk with an appropriate alignment.
408 // The MergeChunk then tail merges the strings using the StringTableBuilder
409 // class and assigns RVAs and section offsets to each of the member chunks based
410 // on the offsets assigned by the StringTableBuilder.
411 class MergeChunk : public NonSectionChunk {
412 public:
413   MergeChunk(uint32_t alignment);
414   static void addSection(SectionChunk *c);
415   void finalizeContents();
416   void assignSubsectionRVAs();
417
418   uint32_t getOutputCharacteristics() const override;
419   StringRef getSectionName() const override { return ".rdata"; }
420   size_t getSize() const override;
421   void writeTo(uint8_t *buf) const override;
422
423   static MergeChunk *instances[Log2MaxSectionAlignment + 1];
424   std::vector<SectionChunk *> sections;
425
426 private:
427   llvm::StringTableBuilder builder;
428   bool finalized = false;
429 };
430
431 // A chunk for common symbols. Common chunks don't have actual data.
432 class CommonChunk : public NonSectionChunk {
433 public:
434   CommonChunk(const COFFSymbolRef sym);
435   size_t getSize() const override { return sym.getValue(); }
436   uint32_t getOutputCharacteristics() const override;
437   StringRef getSectionName() const override { return ".bss"; }
438
439 private:
440   const COFFSymbolRef sym;
441 };
442
443 // A chunk for linker-created strings.
444 class StringChunk : public NonSectionChunk {
445 public:
446   explicit StringChunk(StringRef s) : str(s) {}
447   size_t getSize() const override { return str.size() + 1; }
448   void writeTo(uint8_t *buf) const override;
449
450 private:
451   StringRef str;
452 };
453
454 static const uint8_t importThunkX86[] = {
455     0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // JMP *0x0
456 };
457
458 static const uint8_t importThunkARM[] = {
459     0x40, 0xf2, 0x00, 0x0c, // mov.w ip, #0
460     0xc0, 0xf2, 0x00, 0x0c, // mov.t ip, #0
461     0xdc, 0xf8, 0x00, 0xf0, // ldr.w pc, [ip]
462 };
463
464 static const uint8_t importThunkARM64[] = {
465     0x10, 0x00, 0x00, 0x90, // adrp x16, #0
466     0x10, 0x02, 0x40, 0xf9, // ldr  x16, [x16]
467     0x00, 0x02, 0x1f, 0xd6, // br   x16
468 };
469
470 // Windows-specific.
471 // A chunk for DLL import jump table entry. In a final output, its
472 // contents will be a JMP instruction to some __imp_ symbol.
473 class ImportThunkChunk : public NonSectionChunk {
474 public:
475   ImportThunkChunk(Defined *s)
476       : NonSectionChunk(ImportThunkKind), impSymbol(s) {}
477   static bool classof(const Chunk *c) { return c->kind() == ImportThunkKind; }
478
479 protected:
480   Defined *impSymbol;
481 };
482
483 class ImportThunkChunkX64 : public ImportThunkChunk {
484 public:
485   explicit ImportThunkChunkX64(Defined *s);
486   size_t getSize() const override { return sizeof(importThunkX86); }
487   void writeTo(uint8_t *buf) const override;
488 };
489
490 class ImportThunkChunkX86 : public ImportThunkChunk {
491 public:
492   explicit ImportThunkChunkX86(Defined *s) : ImportThunkChunk(s) {}
493   size_t getSize() const override { return sizeof(importThunkX86); }
494   void getBaserels(std::vector<Baserel> *res) override;
495   void writeTo(uint8_t *buf) const override;
496 };
497
498 class ImportThunkChunkARM : public ImportThunkChunk {
499 public:
500   explicit ImportThunkChunkARM(Defined *s) : ImportThunkChunk(s) {
501     setAlignment(2);
502   }
503   size_t getSize() const override { return sizeof(importThunkARM); }
504   void getBaserels(std::vector<Baserel> *res) override;
505   void writeTo(uint8_t *buf) const override;
506 };
507
508 class ImportThunkChunkARM64 : public ImportThunkChunk {
509 public:
510   explicit ImportThunkChunkARM64(Defined *s) : ImportThunkChunk(s) {
511     setAlignment(4);
512   }
513   size_t getSize() const override { return sizeof(importThunkARM64); }
514   void writeTo(uint8_t *buf) const override;
515 };
516
517 class RangeExtensionThunkARM : public NonSectionChunk {
518 public:
519   explicit RangeExtensionThunkARM(Defined *t) : target(t) { setAlignment(2); }
520   size_t getSize() const override;
521   void writeTo(uint8_t *buf) const override;
522
523   Defined *target;
524 };
525
526 class RangeExtensionThunkARM64 : public NonSectionChunk {
527 public:
528   explicit RangeExtensionThunkARM64(Defined *t) : target(t) { setAlignment(4); }
529   size_t getSize() const override;
530   void writeTo(uint8_t *buf) const override;
531
532   Defined *target;
533 };
534
535 // Windows-specific.
536 // See comments for DefinedLocalImport class.
537 class LocalImportChunk : public NonSectionChunk {
538 public:
539   explicit LocalImportChunk(Defined *s) : sym(s) {
540     setAlignment(config->wordsize);
541   }
542   size_t getSize() const override;
543   void getBaserels(std::vector<Baserel> *res) override;
544   void writeTo(uint8_t *buf) const override;
545
546 private:
547   Defined *sym;
548 };
549
550 // Duplicate RVAs are not allowed in RVA tables, so unique symbols by chunk and
551 // offset into the chunk. Order does not matter as the RVA table will be sorted
552 // later.
553 struct ChunkAndOffset {
554   Chunk *inputChunk;
555   uint32_t offset;
556
557   struct DenseMapInfo {
558     static ChunkAndOffset getEmptyKey() {
559       return {llvm::DenseMapInfo<Chunk *>::getEmptyKey(), 0};
560     }
561     static ChunkAndOffset getTombstoneKey() {
562       return {llvm::DenseMapInfo<Chunk *>::getTombstoneKey(), 0};
563     }
564     static unsigned getHashValue(const ChunkAndOffset &co) {
565       return llvm::DenseMapInfo<std::pair<Chunk *, uint32_t>>::getHashValue(
566           {co.inputChunk, co.offset});
567     }
568     static bool isEqual(const ChunkAndOffset &lhs, const ChunkAndOffset &rhs) {
569       return lhs.inputChunk == rhs.inputChunk && lhs.offset == rhs.offset;
570     }
571   };
572 };
573
574 using SymbolRVASet = llvm::DenseSet<ChunkAndOffset>;
575
576 // Table which contains symbol RVAs. Used for /safeseh and /guard:cf.
577 class RVATableChunk : public NonSectionChunk {
578 public:
579   explicit RVATableChunk(SymbolRVASet s) : syms(std::move(s)) {}
580   size_t getSize() const override { return syms.size() * 4; }
581   void writeTo(uint8_t *buf) const override;
582
583 private:
584   SymbolRVASet syms;
585 };
586
587 // Windows-specific.
588 // This class represents a block in .reloc section.
589 // See the PE/COFF spec 5.6 for details.
590 class BaserelChunk : public NonSectionChunk {
591 public:
592   BaserelChunk(uint32_t page, Baserel *begin, Baserel *end);
593   size_t getSize() const override { return data.size(); }
594   void writeTo(uint8_t *buf) const override;
595
596 private:
597   std::vector<uint8_t> data;
598 };
599
600 class Baserel {
601 public:
602   Baserel(uint32_t v, uint8_t ty) : rva(v), type(ty) {}
603   explicit Baserel(uint32_t v) : Baserel(v, getDefaultType()) {}
604   uint8_t getDefaultType();
605
606   uint32_t rva;
607   uint8_t type;
608 };
609
610 // This is a placeholder Chunk, to allow attaching a DefinedSynthetic to a
611 // specific place in a section, without any data. This is used for the MinGW
612 // specific symbol __RUNTIME_PSEUDO_RELOC_LIST_END__, even though the concept
613 // of an empty chunk isn't MinGW specific.
614 class EmptyChunk : public NonSectionChunk {
615 public:
616   EmptyChunk() {}
617   size_t getSize() const override { return 0; }
618   void writeTo(uint8_t *buf) const override {}
619 };
620
621 // MinGW specific, for the "automatic import of variables from DLLs" feature.
622 // This provides the table of runtime pseudo relocations, for variable
623 // references that turned out to need to be imported from a DLL even though
624 // the reference didn't use the dllimport attribute. The MinGW runtime will
625 // process this table after loading, before handling control over to user
626 // code.
627 class PseudoRelocTableChunk : public NonSectionChunk {
628 public:
629   PseudoRelocTableChunk(std::vector<RuntimePseudoReloc> &relocs)
630       : relocs(std::move(relocs)) {
631     setAlignment(4);
632   }
633   size_t getSize() const override;
634   void writeTo(uint8_t *buf) const override;
635
636 private:
637   std::vector<RuntimePseudoReloc> relocs;
638 };
639
640 // MinGW specific; information about one individual location in the image
641 // that needs to be fixed up at runtime after loading. This represents
642 // one individual element in the PseudoRelocTableChunk table.
643 class RuntimePseudoReloc {
644 public:
645   RuntimePseudoReloc(Defined *sym, SectionChunk *target, uint32_t targetOffset,
646                      int flags)
647       : sym(sym), target(target), targetOffset(targetOffset), flags(flags) {}
648
649   Defined *sym;
650   SectionChunk *target;
651   uint32_t targetOffset;
652   // The Flags field contains the size of the relocation, in bits. No other
653   // flags are currently defined.
654   int flags;
655 };
656
657 // MinGW specific. A Chunk that contains one pointer-sized absolute value.
658 class AbsolutePointerChunk : public NonSectionChunk {
659 public:
660   AbsolutePointerChunk(uint64_t value) : value(value) {
661     setAlignment(getSize());
662   }
663   size_t getSize() const override;
664   void writeTo(uint8_t *buf) const override;
665
666 private:
667   uint64_t value;
668 };
669
670 // Return true if this file has the hotpatch flag set to true in the S_COMPILE3
671 // record in codeview debug info. Also returns true for some thunks synthesized
672 // by the linker.
673 inline bool Chunk::isHotPatchable() const {
674   if (auto *sc = dyn_cast<SectionChunk>(this))
675     return sc->file->hotPatchable;
676   else if (isa<ImportThunkChunk>(this))
677     return true;
678   return false;
679 }
680
681 void applyMOV32T(uint8_t *off, uint32_t v);
682 void applyBranch24T(uint8_t *off, int32_t v);
683
684 void applyArm64Addr(uint8_t *off, uint64_t s, uint64_t p, int shift);
685 void applyArm64Imm(uint8_t *off, uint64_t imm, uint32_t rangeLimit);
686 void applyArm64Branch26(uint8_t *off, int64_t v);
687
688 } // namespace coff
689 } // namespace lld
690
691 namespace llvm {
692 template <>
693 struct DenseMapInfo<lld::coff::ChunkAndOffset>
694     : lld::coff::ChunkAndOffset::DenseMapInfo {};
695 }
696
697 #endif