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 uint32_t getOutputCharacteristics() const { 208 return header->Characteristics & (permMask | typeMask); 209 } 210 StringRef getSectionName() const { 211 return StringRef(sectionNameData, sectionNameSize); 212 } 213 void getBaserels(std::vector<Baserel> *res); 214 bool isCOMDAT() const; 215 void applyRelX64(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s, 216 uint64_t p) const; 217 void applyRelX86(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s, 218 uint64_t p) const; 219 void applyRelARM(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s, 220 uint64_t p) const; 221 void applyRelARM64(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s, 222 uint64_t p) const; 223 224 void getRuntimePseudoRelocs(std::vector<RuntimePseudoReloc> &res); 225 226 // Called if the garbage collector decides to not include this chunk 227 // in a final output. It's supposed to print out a log message to stdout. 228 void printDiscardedMessage() const; 229 230 // Adds COMDAT associative sections to this COMDAT section. A chunk 231 // and its children are treated as a group by the garbage collector. 232 void addAssociative(SectionChunk *child); 233 234 StringRef getDebugName() const; 235 236 // True if this is a codeview debug info chunk. These will not be laid out in 237 // the image. Instead they will end up in the PDB, if one is requested. 238 bool isCodeView() const { 239 return getSectionName() == ".debug" || getSectionName().startswith(".debug$"); 240 } 241 242 // True if this is a DWARF debug info or exception handling chunk. 243 bool isDWARF() const { 244 return getSectionName().startswith(".debug_") || getSectionName() == ".eh_frame"; 245 } 246 247 // Allow iteration over the bodies of this chunk's relocated symbols. 248 llvm::iterator_range<symbol_iterator> symbols() const { 249 return llvm::make_range(symbol_iterator(file, relocsData), 250 symbol_iterator(file, relocsData + relocsSize)); 251 } 252 253 ArrayRef<coff_relocation> getRelocs() const { 254 return llvm::makeArrayRef(relocsData, relocsSize); 255 } 256 257 // Reloc setter used by ARM range extension thunk insertion. 258 void setRelocs(ArrayRef<coff_relocation> newRelocs) { 259 relocsData = newRelocs.data(); 260 relocsSize = newRelocs.size(); 261 assert(relocsSize == newRelocs.size() && "reloc size truncation"); 262 } 263 264 // Single linked list iterator for associated comdat children. 265 class AssociatedIterator 266 : public llvm::iterator_facade_base< 267 AssociatedIterator, std::forward_iterator_tag, SectionChunk> { 268 public: 269 AssociatedIterator() = default; 270 AssociatedIterator(SectionChunk *head) : cur(head) {} 271 bool operator==(const AssociatedIterator &r) const { return cur == r.cur; } 272 const SectionChunk &operator*() const { return *cur; } 273 SectionChunk &operator*() { return *cur; } 274 AssociatedIterator &operator++() { 275 cur = cur->assocChildren; 276 return *this; 277 } 278 279 private: 280 SectionChunk *cur = nullptr; 281 }; 282 283 // Allow iteration over the associated child chunks for this section. 284 llvm::iterator_range<AssociatedIterator> children() const { 285 return llvm::make_range(AssociatedIterator(assocChildren), 286 AssociatedIterator(nullptr)); 287 } 288 289 // The section ID this chunk belongs to in its Obj. 290 uint32_t getSectionNumber() const; 291 292 ArrayRef<uint8_t> consumeDebugMagic(); 293 294 static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> data, 295 StringRef sectionName); 296 297 static SectionChunk *findByName(ArrayRef<SectionChunk *> sections, 298 StringRef name); 299 300 // The file that this chunk was created from. 301 ObjFile *file; 302 303 // Pointer to the COFF section header in the input file. 304 const coff_section *header; 305 306 // The COMDAT leader symbol if this is a COMDAT chunk. 307 DefinedRegular *sym = nullptr; 308 309 // The CRC of the contents as described in the COFF spec 4.5.5. 310 // Auxiliary Format 5: Section Definitions. Used for ICF. 311 uint32_t checksum = 0; 312 313 // Used by the garbage collector. 314 bool live; 315 316 // Whether this section needs to be kept distinct from other sections during 317 // ICF. This is set by the driver using address-significance tables. 318 bool keepUnique = false; 319 320 // The COMDAT selection if this is a COMDAT chunk. 321 llvm::COFF::COMDATType selection = (llvm::COFF::COMDATType)0; 322 323 // A pointer pointing to a replacement for this chunk. 324 // Initially it points to "this" object. If this chunk is merged 325 // with other chunk by ICF, it points to another chunk, 326 // and this chunk is considered as dead. 327 SectionChunk *repl; 328 329 private: 330 SectionChunk *assocChildren = nullptr; 331 332 // Used for ICF (Identical COMDAT Folding) 333 void replace(SectionChunk *other); 334 uint32_t eqClass[2] = {0, 0}; 335 336 // Relocations for this section. Size is stored below. 337 const coff_relocation *relocsData; 338 339 // Section name string. Size is stored below. 340 const char *sectionNameData; 341 342 uint32_t relocsSize = 0; 343 uint32_t sectionNameSize = 0; 344 }; 345 346 // Inline methods to implement faux-virtual dispatch for SectionChunk. 347 348 inline size_t Chunk::getSize() const { 349 if (isa<SectionChunk>(this)) 350 return static_cast<const SectionChunk *>(this)->getSize(); 351 else 352 return static_cast<const NonSectionChunk *>(this)->getSize(); 353 } 354 355 inline uint32_t Chunk::getOutputCharacteristics() const { 356 if (isa<SectionChunk>(this)) 357 return static_cast<const SectionChunk *>(this)->getOutputCharacteristics(); 358 else 359 return static_cast<const NonSectionChunk *>(this) 360 ->getOutputCharacteristics(); 361 } 362 363 inline void Chunk::writeTo(uint8_t *buf) const { 364 if (isa<SectionChunk>(this)) 365 static_cast<const SectionChunk *>(this)->writeTo(buf); 366 else 367 static_cast<const NonSectionChunk *>(this)->writeTo(buf); 368 } 369 370 inline StringRef Chunk::getSectionName() const { 371 if (isa<SectionChunk>(this)) 372 return static_cast<const SectionChunk *>(this)->getSectionName(); 373 else 374 return static_cast<const NonSectionChunk *>(this)->getSectionName(); 375 } 376 377 inline void Chunk::getBaserels(std::vector<Baserel> *res) { 378 if (isa<SectionChunk>(this)) 379 static_cast<SectionChunk *>(this)->getBaserels(res); 380 else 381 static_cast<NonSectionChunk *>(this)->getBaserels(res); 382 } 383 384 inline StringRef Chunk::getDebugName() const { 385 if (isa<SectionChunk>(this)) 386 return static_cast<const SectionChunk *>(this)->getDebugName(); 387 else 388 return static_cast<const NonSectionChunk *>(this)->getDebugName(); 389 } 390 391 // This class is used to implement an lld-specific feature (not implemented in 392 // MSVC) that minimizes the output size by finding string literals sharing tail 393 // parts and merging them. 394 // 395 // If string tail merging is enabled and a section is identified as containing a 396 // string literal, it is added to a MergeChunk with an appropriate alignment. 397 // The MergeChunk then tail merges the strings using the StringTableBuilder 398 // class and assigns RVAs and section offsets to each of the member chunks based 399 // on the offsets assigned by the StringTableBuilder. 400 class MergeChunk : public NonSectionChunk { 401 public: 402 MergeChunk(uint32_t alignment); 403 static void addSection(SectionChunk *c); 404 void finalizeContents(); 405 void assignSubsectionRVAs(); 406 407 uint32_t getOutputCharacteristics() const override; 408 StringRef getSectionName() const override { return ".rdata"; } 409 size_t getSize() const override; 410 void writeTo(uint8_t *buf) const override; 411 412 static MergeChunk *instances[Log2MaxSectionAlignment + 1]; 413 std::vector<SectionChunk *> sections; 414 415 private: 416 llvm::StringTableBuilder builder; 417 bool finalized = false; 418 }; 419 420 // A chunk for common symbols. Common chunks don't have actual data. 421 class CommonChunk : public NonSectionChunk { 422 public: 423 CommonChunk(const COFFSymbolRef sym); 424 size_t getSize() const override { return sym.getValue(); } 425 uint32_t getOutputCharacteristics() const override; 426 StringRef getSectionName() const override { return ".bss"; } 427 428 private: 429 const COFFSymbolRef sym; 430 }; 431 432 // A chunk for linker-created strings. 433 class StringChunk : public NonSectionChunk { 434 public: 435 explicit StringChunk(StringRef s) : str(s) {} 436 size_t getSize() const override { return str.size() + 1; } 437 void writeTo(uint8_t *buf) const override; 438 439 private: 440 StringRef str; 441 }; 442 443 static const uint8_t importThunkX86[] = { 444 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // JMP *0x0 445 }; 446 447 static const uint8_t importThunkARM[] = { 448 0x40, 0xf2, 0x00, 0x0c, // mov.w ip, #0 449 0xc0, 0xf2, 0x00, 0x0c, // mov.t ip, #0 450 0xdc, 0xf8, 0x00, 0xf0, // ldr.w pc, [ip] 451 }; 452 453 static const uint8_t importThunkARM64[] = { 454 0x10, 0x00, 0x00, 0x90, // adrp x16, #0 455 0x10, 0x02, 0x40, 0xf9, // ldr x16, [x16] 456 0x00, 0x02, 0x1f, 0xd6, // br x16 457 }; 458 459 // Windows-specific. 460 // A chunk for DLL import jump table entry. In a final output, its 461 // contents will be a JMP instruction to some __imp_ symbol. 462 class ImportThunkChunk : public NonSectionChunk { 463 public: 464 ImportThunkChunk(Defined *s) 465 : NonSectionChunk(ImportThunkKind), impSymbol(s) {} 466 static bool classof(const Chunk *c) { return c->kind() == ImportThunkKind; } 467 468 protected: 469 Defined *impSymbol; 470 }; 471 472 class ImportThunkChunkX64 : public ImportThunkChunk { 473 public: 474 explicit ImportThunkChunkX64(Defined *s); 475 size_t getSize() const override { return sizeof(importThunkX86); } 476 void writeTo(uint8_t *buf) const override; 477 }; 478 479 class ImportThunkChunkX86 : public ImportThunkChunk { 480 public: 481 explicit ImportThunkChunkX86(Defined *s) : ImportThunkChunk(s) {} 482 size_t getSize() const override { return sizeof(importThunkX86); } 483 void getBaserels(std::vector<Baserel> *res) override; 484 void writeTo(uint8_t *buf) const override; 485 }; 486 487 class ImportThunkChunkARM : public ImportThunkChunk { 488 public: 489 explicit ImportThunkChunkARM(Defined *s) : ImportThunkChunk(s) {} 490 size_t getSize() const override { return sizeof(importThunkARM); } 491 void getBaserels(std::vector<Baserel> *res) override; 492 void writeTo(uint8_t *buf) const override; 493 }; 494 495 class ImportThunkChunkARM64 : public ImportThunkChunk { 496 public: 497 explicit ImportThunkChunkARM64(Defined *s) : ImportThunkChunk(s) {} 498 size_t getSize() const override { return sizeof(importThunkARM64); } 499 void writeTo(uint8_t *buf) const override; 500 }; 501 502 class RangeExtensionThunkARM : public NonSectionChunk { 503 public: 504 explicit RangeExtensionThunkARM(Defined *t) : target(t) {} 505 size_t getSize() const override; 506 void writeTo(uint8_t *buf) const override; 507 508 Defined *target; 509 }; 510 511 class RangeExtensionThunkARM64 : public NonSectionChunk { 512 public: 513 explicit RangeExtensionThunkARM64(Defined *t) : target(t) { setAlignment(4); } 514 size_t getSize() const override; 515 void writeTo(uint8_t *buf) const override; 516 517 Defined *target; 518 }; 519 520 // Windows-specific. 521 // See comments for DefinedLocalImport class. 522 class LocalImportChunk : public NonSectionChunk { 523 public: 524 explicit LocalImportChunk(Defined *s) : sym(s) { 525 setAlignment(config->wordsize); 526 } 527 size_t getSize() const override; 528 void getBaserels(std::vector<Baserel> *res) override; 529 void writeTo(uint8_t *buf) const override; 530 531 private: 532 Defined *sym; 533 }; 534 535 // Duplicate RVAs are not allowed in RVA tables, so unique symbols by chunk and 536 // offset into the chunk. Order does not matter as the RVA table will be sorted 537 // later. 538 struct ChunkAndOffset { 539 Chunk *inputChunk; 540 uint32_t offset; 541 542 struct DenseMapInfo { 543 static ChunkAndOffset getEmptyKey() { 544 return {llvm::DenseMapInfo<Chunk *>::getEmptyKey(), 0}; 545 } 546 static ChunkAndOffset getTombstoneKey() { 547 return {llvm::DenseMapInfo<Chunk *>::getTombstoneKey(), 0}; 548 } 549 static unsigned getHashValue(const ChunkAndOffset &co) { 550 return llvm::DenseMapInfo<std::pair<Chunk *, uint32_t>>::getHashValue( 551 {co.inputChunk, co.offset}); 552 } 553 static bool isEqual(const ChunkAndOffset &lhs, const ChunkAndOffset &rhs) { 554 return lhs.inputChunk == rhs.inputChunk && lhs.offset == rhs.offset; 555 } 556 }; 557 }; 558 559 using SymbolRVASet = llvm::DenseSet<ChunkAndOffset>; 560 561 // Table which contains symbol RVAs. Used for /safeseh and /guard:cf. 562 class RVATableChunk : public NonSectionChunk { 563 public: 564 explicit RVATableChunk(SymbolRVASet s) : syms(std::move(s)) {} 565 size_t getSize() const override { return syms.size() * 4; } 566 void writeTo(uint8_t *buf) const override; 567 568 private: 569 SymbolRVASet syms; 570 }; 571 572 // Windows-specific. 573 // This class represents a block in .reloc section. 574 // See the PE/COFF spec 5.6 for details. 575 class BaserelChunk : public NonSectionChunk { 576 public: 577 BaserelChunk(uint32_t page, Baserel *begin, Baserel *end); 578 size_t getSize() const override { return data.size(); } 579 void writeTo(uint8_t *buf) const override; 580 581 private: 582 std::vector<uint8_t> data; 583 }; 584 585 class Baserel { 586 public: 587 Baserel(uint32_t v, uint8_t ty) : rva(v), type(ty) {} 588 explicit Baserel(uint32_t v) : Baserel(v, getDefaultType()) {} 589 uint8_t getDefaultType(); 590 591 uint32_t rva; 592 uint8_t type; 593 }; 594 595 // This is a placeholder Chunk, to allow attaching a DefinedSynthetic to a 596 // specific place in a section, without any data. This is used for the MinGW 597 // specific symbol __RUNTIME_PSEUDO_RELOC_LIST_END__, even though the concept 598 // of an empty chunk isn't MinGW specific. 599 class EmptyChunk : public NonSectionChunk { 600 public: 601 EmptyChunk() {} 602 size_t getSize() const override { return 0; } 603 void writeTo(uint8_t *buf) const override {} 604 }; 605 606 // MinGW specific, for the "automatic import of variables from DLLs" feature. 607 // This provides the table of runtime pseudo relocations, for variable 608 // references that turned out to need to be imported from a DLL even though 609 // the reference didn't use the dllimport attribute. The MinGW runtime will 610 // process this table after loading, before handling control over to user 611 // code. 612 class PseudoRelocTableChunk : public NonSectionChunk { 613 public: 614 PseudoRelocTableChunk(std::vector<RuntimePseudoReloc> &relocs) 615 : relocs(std::move(relocs)) { 616 setAlignment(4); 617 } 618 size_t getSize() const override; 619 void writeTo(uint8_t *buf) const override; 620 621 private: 622 std::vector<RuntimePseudoReloc> relocs; 623 }; 624 625 // MinGW specific; information about one individual location in the image 626 // that needs to be fixed up at runtime after loading. This represents 627 // one individual element in the PseudoRelocTableChunk table. 628 class RuntimePseudoReloc { 629 public: 630 RuntimePseudoReloc(Defined *sym, SectionChunk *target, uint32_t targetOffset, 631 int flags) 632 : sym(sym), target(target), targetOffset(targetOffset), flags(flags) {} 633 634 Defined *sym; 635 SectionChunk *target; 636 uint32_t targetOffset; 637 // The Flags field contains the size of the relocation, in bits. No other 638 // flags are currently defined. 639 int flags; 640 }; 641 642 // MinGW specific. A Chunk that contains one pointer-sized absolute value. 643 class AbsolutePointerChunk : public NonSectionChunk { 644 public: 645 AbsolutePointerChunk(uint64_t value) : value(value) { 646 setAlignment(getSize()); 647 } 648 size_t getSize() const override; 649 void writeTo(uint8_t *buf) const override; 650 651 private: 652 uint64_t value; 653 }; 654 655 // Return true if this file has the hotpatch flag set to true in the S_COMPILE3 656 // record in codeview debug info. Also returns true for some thunks synthesized 657 // by the linker. 658 inline bool Chunk::isHotPatchable() const { 659 if (auto *sc = dyn_cast<SectionChunk>(this)) 660 return sc->file->hotPatchable; 661 else if (isa<ImportThunkChunk>(this)) 662 return true; 663 return false; 664 } 665 666 void applyMOV32T(uint8_t *off, uint32_t v); 667 void applyBranch24T(uint8_t *off, int32_t v); 668 669 void applyArm64Addr(uint8_t *off, uint64_t s, uint64_t p, int shift); 670 void applyArm64Imm(uint8_t *off, uint64_t imm, uint32_t rangeLimit); 671 void applyArm64Branch26(uint8_t *off, int64_t v); 672 673 } // namespace coff 674 } // namespace lld 675 676 namespace llvm { 677 template <> 678 struct DenseMapInfo<lld::coff::ChunkAndOffset> 679 : lld::coff::ChunkAndOffset::DenseMapInfo {}; 680 } 681 682 #endif 683