1 //===- Chunks.h -------------------------------------------------*- C++ -*-===//
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef LLD_COFF_CHUNKS_H
11 #define LLD_COFF_CHUNKS_H
14 #include "InputFiles.h"
15 #include "lld/Core/LLVM.h"
16 #include "llvm/ADT/ArrayRef.h"
17 #include "llvm/ADT/iterator.h"
18 #include "llvm/ADT/iterator_range.h"
19 #include "llvm/Object/COFF.h"
26 using llvm::COFF::ImportDirectoryTableEntry;
27 using llvm::object::COFFSymbolRef;
28 using llvm::object::SectionRef;
29 using llvm::object::coff_relocation;
30 using llvm::object::coff_section;
34 class DefinedImportData;
40 // Mask for section types (code, data, bss, disacardable, etc.)
41 // and permissions (writable, readable or executable).
42 const uint32_t PermMask = 0xFF0000F0;
44 // A Chunk represents a chunk of data that will occupy space in the
45 // output (if the resolver chose that). It may or may not be backed by
46 // a section of an input file. It could be linker-created data, or
47 // doesn't even have actual data (if common or bss).
50 enum Kind { SectionKind, OtherKind };
51 Kind kind() const { return ChunkKind; }
52 virtual ~Chunk() = default;
54 // Returns the size of this chunk (even if this is a common or BSS.)
55 virtual size_t getSize() const = 0;
57 // Write this chunk to a mmap'ed file, assuming Buf is pointing to
58 // beginning of the file. Because this function may use RVA values
59 // of other chunks for relocations, you need to set them properly
60 // before calling this function.
61 virtual void writeTo(uint8_t *Buf) const {}
63 // The writer sets and uses the addresses.
64 uint64_t getRVA() const { return RVA; }
65 uint32_t getAlign() const { return Align; }
66 void setRVA(uint64_t V) { RVA = V; }
67 void setOutputSectionOff(uint64_t V) { OutputSectionOff = V; }
69 // Returns true if this has non-zero data. BSS chunks return
70 // false. If false is returned, the space occupied by this chunk
71 // will be filled with zeros.
72 virtual bool hasData() const { return true; }
74 // Returns readable/writable/executable bits.
75 virtual uint32_t getPermissions() const { return 0; }
77 // Returns the section name if this is a section chunk.
78 // It is illegal to call this function on non-section chunks.
79 virtual StringRef getSectionName() const {
80 llvm_unreachable("unimplemented getSectionName");
83 // An output section has pointers to chunks in the section, and each
84 // chunk has a back pointer to an output section.
85 void setOutputSection(OutputSection *O) { Out = O; }
86 OutputSection *getOutputSection() { return Out; }
89 // Collect all locations that contain absolute addresses for base relocations.
90 virtual void getBaserels(std::vector<Baserel> *Res) {}
92 // Returns a human-readable name of this chunk. Chunks are unnamed chunks of
93 // bytes, so this is used only for logging or debugging.
94 virtual StringRef getDebugName() { return ""; }
97 Chunk(Kind K = OtherKind) : ChunkKind(K) {}
100 // The RVA of this chunk in the output. The writer sets a value.
103 // The offset from beginning of the output section. The writer sets a value.
104 uint64_t OutputSectionOff = 0;
106 // The output section for this chunk.
107 OutputSection *Out = nullptr;
109 // The alignment of this chunk. The writer uses the value.
113 // A chunk corresponding a section of an input file.
114 class SectionChunk : public Chunk {
115 // Identical COMDAT Folding feature accesses section internal data.
119 class symbol_iterator : public llvm::iterator_adaptor_base<
120 symbol_iterator, const coff_relocation *,
121 std::random_access_iterator_tag, SymbolBody *> {
126 symbol_iterator(ObjectFile *File, const coff_relocation *I)
127 : symbol_iterator::iterator_adaptor_base(I), File(File) {}
130 symbol_iterator() = default;
132 SymbolBody *operator*() const {
133 return File->getSymbolBody(I->SymbolTableIndex);
137 SectionChunk(ObjectFile *File, const coff_section *Header);
138 static bool classof(const Chunk *C) { return C->kind() == SectionKind; }
139 size_t getSize() const override { return Header->SizeOfRawData; }
140 ArrayRef<uint8_t> getContents() const;
141 void writeTo(uint8_t *Buf) const override;
142 bool hasData() const override;
143 uint32_t getPermissions() const override;
144 StringRef getSectionName() const override { return SectionName; }
145 void getBaserels(std::vector<Baserel> *Res) override;
146 bool isCOMDAT() const;
147 void applyRelX64(uint8_t *Off, uint16_t Type, Defined *Sym, uint64_t P) const;
148 void applyRelX86(uint8_t *Off, uint16_t Type, Defined *Sym, uint64_t P) const;
149 void applyRelARM(uint8_t *Off, uint16_t Type, Defined *Sym, uint64_t P) const;
151 // Called if the garbage collector decides to not include this chunk
152 // in a final output. It's supposed to print out a log message to stdout.
153 void printDiscardedMessage() const;
155 // Adds COMDAT associative sections to this COMDAT section. A chunk
156 // and its children are treated as a group by the garbage collector.
157 void addAssociative(SectionChunk *Child);
159 StringRef getDebugName() override;
160 void setSymbol(DefinedRegular *S) { if (!Sym) Sym = S; }
162 // Used by the garbage collector.
163 bool isLive() { return !Config->DoGC || Live; }
165 assert(!isLive() && "Cannot mark an already live section!");
169 // Allow iteration over the bodies of this chunk's relocated symbols.
170 llvm::iterator_range<symbol_iterator> symbols() const {
171 return llvm::make_range(symbol_iterator(File, Relocs.begin()),
172 symbol_iterator(File, Relocs.end()));
175 // Allow iteration over the associated child chunks for this section.
176 ArrayRef<SectionChunk *> children() const { return AssocChildren; }
178 // A pointer pointing to a replacement for this chunk.
179 // Initially it points to "this" object. If this chunk is merged
180 // with other chunk by ICF, it points to another chunk,
181 // and this chunk is considrered as dead.
184 // The CRC of the contents as described in the COFF spec 4.5.5.
185 // Auxiliary Format 5: Section Definitions. Used for ICF.
186 uint32_t Checksum = 0;
188 const coff_section *Header;
190 // The file that this chunk was created from.
194 StringRef SectionName;
195 std::vector<SectionChunk *> AssocChildren;
196 llvm::iterator_range<const coff_relocation *> Relocs;
199 // Used by the garbage collector.
202 // Used for ICF (Identical COMDAT Folding)
203 void replace(SectionChunk *Other);
204 uint32_t Class[2] = {0, 0};
206 // Sym points to a section symbol if this is a COMDAT chunk.
207 DefinedRegular *Sym = nullptr;
210 // A chunk for common symbols. Common chunks don't have actual data.
211 class CommonChunk : public Chunk {
213 CommonChunk(const COFFSymbolRef Sym);
214 size_t getSize() const override { return Sym.getValue(); }
215 bool hasData() const override { return false; }
216 uint32_t getPermissions() const override;
217 StringRef getSectionName() const override { return ".bss"; }
220 const COFFSymbolRef Sym;
223 // A chunk for linker-created strings.
224 class StringChunk : public Chunk {
226 explicit StringChunk(StringRef S) : Str(S) {}
227 size_t getSize() const override { return Str.size() + 1; }
228 void writeTo(uint8_t *Buf) const override;
234 static const uint8_t ImportThunkX86[] = {
235 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // JMP *0x0
238 static const uint8_t ImportThunkARM[] = {
239 0x40, 0xf2, 0x00, 0x0c, // mov.w ip, #0
240 0xc0, 0xf2, 0x00, 0x0c, // mov.t ip, #0
241 0xdc, 0xf8, 0x00, 0xf0, // ldr.w pc, [ip]
245 // A chunk for DLL import jump table entry. In a final output, it's
246 // contents will be a JMP instruction to some __imp_ symbol.
247 class ImportThunkChunkX64 : public Chunk {
249 explicit ImportThunkChunkX64(Defined *S);
250 size_t getSize() const override { return sizeof(ImportThunkX86); }
251 void writeTo(uint8_t *Buf) const override;
257 class ImportThunkChunkX86 : public Chunk {
259 explicit ImportThunkChunkX86(Defined *S) : ImpSymbol(S) {}
260 size_t getSize() const override { return sizeof(ImportThunkX86); }
261 void getBaserels(std::vector<Baserel> *Res) override;
262 void writeTo(uint8_t *Buf) const override;
268 class ImportThunkChunkARM : public Chunk {
270 explicit ImportThunkChunkARM(Defined *S) : ImpSymbol(S) {}
271 size_t getSize() const override { return sizeof(ImportThunkARM); }
272 void getBaserels(std::vector<Baserel> *Res) override;
273 void writeTo(uint8_t *Buf) const override;
280 // See comments for DefinedLocalImport class.
281 class LocalImportChunk : public Chunk {
283 explicit LocalImportChunk(Defined *S) : Sym(S) {}
284 size_t getSize() const override;
285 void getBaserels(std::vector<Baserel> *Res) override;
286 void writeTo(uint8_t *Buf) const override;
293 // A chunk for SEH table which contains RVAs of safe exception handler
294 // functions. x86-only.
295 class SEHTableChunk : public Chunk {
297 explicit SEHTableChunk(std::set<Defined *> S) : Syms(std::move(S)) {}
298 size_t getSize() const override { return Syms.size() * 4; }
299 void writeTo(uint8_t *Buf) const override;
302 std::set<Defined *> Syms;
306 // This class represents a block in .reloc section.
307 // See the PE/COFF spec 5.6 for details.
308 class BaserelChunk : public Chunk {
310 BaserelChunk(uint32_t Page, Baserel *Begin, Baserel *End);
311 size_t getSize() const override { return Data.size(); }
312 void writeTo(uint8_t *Buf) const override;
315 std::vector<uint8_t> Data;
320 Baserel(uint32_t V, uint8_t Ty) : RVA(V), Type(Ty) {}
321 explicit Baserel(uint32_t V) : Baserel(V, getDefaultType()) {}
322 uint8_t getDefaultType();