Bug Summary

File:lld/COFF/Writer.cpp
Warning:line 1025, column 44
Forming reference to null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name Writer.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/build-llvm -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -isystem /usr/include/libxml2 -D LLD_VENDOR="Debian" -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/lld/COFF -I /build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/lld/COFF -I /build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/lld/include -I tools/lld/include -I include -I /build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/build-llvm=build-llvm -fmacro-prefix-map=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/build-llvm=build-llvm -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/build-llvm=build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-01-25-232935-20746-1 -x c++ /build/llvm-toolchain-snapshot-14~++20220125101009+ceec4383681c/lld/COFF/Writer.cpp
1//===- Writer.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#include "Writer.h"
10#include "COFFLinkerContext.h"
11#include "CallGraphSort.h"
12#include "Config.h"
13#include "DLL.h"
14#include "InputFiles.h"
15#include "LLDMapFile.h"
16#include "MapFile.h"
17#include "PDB.h"
18#include "SymbolTable.h"
19#include "Symbols.h"
20#include "lld/Common/ErrorHandler.h"
21#include "lld/Common/Memory.h"
22#include "lld/Common/Timer.h"
23#include "llvm/ADT/DenseMap.h"
24#include "llvm/ADT/STLExtras.h"
25#include "llvm/ADT/StringSet.h"
26#include "llvm/ADT/StringSwitch.h"
27#include "llvm/Support/BinaryStreamReader.h"
28#include "llvm/Support/Debug.h"
29#include "llvm/Support/Endian.h"
30#include "llvm/Support/FileOutputBuffer.h"
31#include "llvm/Support/Parallel.h"
32#include "llvm/Support/Path.h"
33#include "llvm/Support/RandomNumberGenerator.h"
34#include "llvm/Support/xxhash.h"
35#include <algorithm>
36#include <cstdio>
37#include <map>
38#include <memory>
39#include <utility>
40
41using namespace llvm;
42using namespace llvm::COFF;
43using namespace llvm::object;
44using namespace llvm::support;
45using namespace llvm::support::endian;
46using namespace lld;
47using namespace lld::coff;
48
49/* To re-generate DOSProgram:
50$ cat > /tmp/DOSProgram.asm
51org 0
52 ; Copy cs to ds.
53 push cs
54 pop ds
55 ; Point ds:dx at the $-terminated string.
56 mov dx, str
57 ; Int 21/AH=09h: Write string to standard output.
58 mov ah, 0x9
59 int 0x21
60 ; Int 21/AH=4Ch: Exit with return code (in AL).
61 mov ax, 0x4C01
62 int 0x21
63str:
64 db 'This program cannot be run in DOS mode.$'
65align 8, db 0
66$ nasm -fbin /tmp/DOSProgram.asm -o /tmp/DOSProgram.bin
67$ xxd -i /tmp/DOSProgram.bin
68*/
69static unsigned char dosProgram[] = {
70 0x0e, 0x1f, 0xba, 0x0e, 0x00, 0xb4, 0x09, 0xcd, 0x21, 0xb8, 0x01, 0x4c,
71 0xcd, 0x21, 0x54, 0x68, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x67, 0x72,
72 0x61, 0x6d, 0x20, 0x63, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x20, 0x62, 0x65,
73 0x20, 0x72, 0x75, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x44, 0x4f, 0x53, 0x20,
74 0x6d, 0x6f, 0x64, 0x65, 0x2e, 0x24, 0x00, 0x00
75};
76static_assert(sizeof(dosProgram) % 8 == 0,
77 "DOSProgram size must be multiple of 8");
78
79static const int dosStubSize = sizeof(dos_header) + sizeof(dosProgram);
80static_assert(dosStubSize % 8 == 0, "DOSStub size must be multiple of 8");
81
82static const int numberOfDataDirectory = 16;
83
84namespace {
85
86class DebugDirectoryChunk : public NonSectionChunk {
87public:
88 DebugDirectoryChunk(COFFLinkerContext &c,
89 const std::vector<std::pair<COFF::DebugType, Chunk *>> &r,
90 bool writeRepro)
91 : records(r), writeRepro(writeRepro), ctx(c) {}
92
93 size_t getSize() const override {
94 return (records.size() + int(writeRepro)) * sizeof(debug_directory);
95 }
96
97 void writeTo(uint8_t *b) const override {
98 auto *d = reinterpret_cast<debug_directory *>(b);
99
100 for (const std::pair<COFF::DebugType, Chunk *>& record : records) {
101 Chunk *c = record.second;
102 OutputSection *os = ctx.getOutputSection(c);
103 uint64_t offs = os->getFileOff() + (c->getRVA() - os->getRVA());
104 fillEntry(d, record.first, c->getSize(), c->getRVA(), offs);
105 ++d;
106 }
107
108 if (writeRepro) {
109 // FIXME: The COFF spec allows either a 0-sized entry to just say
110 // "the timestamp field is really a hash", or a 4-byte size field
111 // followed by that many bytes containing a longer hash (with the
112 // lowest 4 bytes usually being the timestamp in little-endian order).
113 // Consider storing the full 8 bytes computed by xxHash64 here.
114 fillEntry(d, COFF::IMAGE_DEBUG_TYPE_REPRO, 0, 0, 0);
115 }
116 }
117
118 void setTimeDateStamp(uint32_t timeDateStamp) {
119 for (support::ulittle32_t *tds : timeDateStamps)
120 *tds = timeDateStamp;
121 }
122
123private:
124 void fillEntry(debug_directory *d, COFF::DebugType debugType, size_t size,
125 uint64_t rva, uint64_t offs) const {
126 d->Characteristics = 0;
127 d->TimeDateStamp = 0;
128 d->MajorVersion = 0;
129 d->MinorVersion = 0;
130 d->Type = debugType;
131 d->SizeOfData = size;
132 d->AddressOfRawData = rva;
133 d->PointerToRawData = offs;
134
135 timeDateStamps.push_back(&d->TimeDateStamp);
136 }
137
138 mutable std::vector<support::ulittle32_t *> timeDateStamps;
139 const std::vector<std::pair<COFF::DebugType, Chunk *>> &records;
140 bool writeRepro;
141
142 COFFLinkerContext &ctx;
143};
144
145class CVDebugRecordChunk : public NonSectionChunk {
146public:
147 size_t getSize() const override {
148 return sizeof(codeview::DebugInfo) + config->pdbAltPath.size() + 1;
149 }
150
151 void writeTo(uint8_t *b) const override {
152 // Save off the DebugInfo entry to backfill the file signature (build id)
153 // in Writer::writeBuildId
154 buildId = reinterpret_cast<codeview::DebugInfo *>(b);
155
156 // variable sized field (PDB Path)
157 char *p = reinterpret_cast<char *>(b + sizeof(*buildId));
158 if (!config->pdbAltPath.empty())
159 memcpy(p, config->pdbAltPath.data(), config->pdbAltPath.size());
160 p[config->pdbAltPath.size()] = '\0';
161 }
162
163 mutable codeview::DebugInfo *buildId = nullptr;
164};
165
166class ExtendedDllCharacteristicsChunk : public NonSectionChunk {
167public:
168 ExtendedDllCharacteristicsChunk(uint32_t c) : characteristics(c) {}
169
170 size_t getSize() const override { return 4; }
171
172 void writeTo(uint8_t *buf) const override { write32le(buf, characteristics); }
173
174 uint32_t characteristics = 0;
175};
176
177// PartialSection represents a group of chunks that contribute to an
178// OutputSection. Collating a collection of PartialSections of same name and
179// characteristics constitutes the OutputSection.
180class PartialSectionKey {
181public:
182 StringRef name;
183 unsigned characteristics;
184
185 bool operator<(const PartialSectionKey &other) const {
186 int c = name.compare(other.name);
187 if (c == 1)
188 return false;
189 if (c == 0)
190 return characteristics < other.characteristics;
191 return true;
192 }
193};
194
195// The writer writes a SymbolTable result to a file.
196class Writer {
197public:
198 Writer(COFFLinkerContext &c) : buffer(errorHandler().outputBuffer), ctx(c) {}
199 void run();
200
201private:
202 void createSections();
203 void createMiscChunks();
204 void createImportTables();
205 void appendImportThunks();
206 void locateImportTables();
207 void createExportTable();
208 void mergeSections();
209 void removeUnusedSections();
210 void assignAddresses();
211 void finalizeAddresses();
212 void removeEmptySections();
213 void assignOutputSectionIndices();
214 void createSymbolAndStringTable();
215 void openFile(StringRef outputPath);
216 template <typename PEHeaderTy> void writeHeader();
217 void createSEHTable();
218 void createRuntimePseudoRelocs();
219 void insertCtorDtorSymbols();
220 void createGuardCFTables();
221 void markSymbolsForRVATable(ObjFile *file,
222 ArrayRef<SectionChunk *> symIdxChunks,
223 SymbolRVASet &tableSymbols);
224 void getSymbolsFromSections(ObjFile *file,
225 ArrayRef<SectionChunk *> symIdxChunks,
226 std::vector<Symbol *> &symbols);
227 void maybeAddRVATable(SymbolRVASet tableSymbols, StringRef tableSym,
228 StringRef countSym, bool hasFlag=false);
229 void setSectionPermissions();
230 void writeSections();
231 void writeBuildId();
232 void sortSections();
233 void sortExceptionTable();
234 void sortCRTSectionChunks(std::vector<Chunk *> &chunks);
235 void addSyntheticIdata();
236 void fixPartialSectionChars(StringRef name, uint32_t chars);
237 bool fixGnuImportChunks();
238 void fixTlsAlignment();
239 PartialSection *createPartialSection(StringRef name, uint32_t outChars);
240 PartialSection *findPartialSection(StringRef name, uint32_t outChars);
241
242 llvm::Optional<coff_symbol16> createSymbol(Defined *d);
243 size_t addEntryToStringTable(StringRef str);
244
245 OutputSection *findSection(StringRef name);
246 void addBaserels();
247 void addBaserelBlocks(std::vector<Baserel> &v);
248
249 uint32_t getSizeOfInitializedData();
250
251 std::unique_ptr<FileOutputBuffer> &buffer;
252 std::map<PartialSectionKey, PartialSection *> partialSections;
253 std::vector<char> strtab;
254 std::vector<llvm::object::coff_symbol16> outputSymtab;
255 IdataContents idata;
256 Chunk *importTableStart = nullptr;
257 uint64_t importTableSize = 0;
258 Chunk *edataStart = nullptr;
259 Chunk *edataEnd = nullptr;
260 Chunk *iatStart = nullptr;
261 uint64_t iatSize = 0;
262 DelayLoadContents delayIdata;
263 EdataContents edata;
264 bool setNoSEHCharacteristic = false;
265 uint32_t tlsAlignment = 0;
266
267 DebugDirectoryChunk *debugDirectory = nullptr;
268 std::vector<std::pair<COFF::DebugType, Chunk *>> debugRecords;
269 CVDebugRecordChunk *buildId = nullptr;
270 ArrayRef<uint8_t> sectionTable;
271
272 uint64_t fileSize;
273 uint32_t pointerToSymbolTable = 0;
274 uint64_t sizeOfImage;
275 uint64_t sizeOfHeaders;
276
277 OutputSection *textSec;
278 OutputSection *rdataSec;
279 OutputSection *buildidSec;
280 OutputSection *dataSec;
281 OutputSection *pdataSec;
282 OutputSection *idataSec;
283 OutputSection *edataSec;
284 OutputSection *didatSec;
285 OutputSection *rsrcSec;
286 OutputSection *relocSec;
287 OutputSection *ctorsSec;
288 OutputSection *dtorsSec;
289
290 // The first and last .pdata sections in the output file.
291 //
292 // We need to keep track of the location of .pdata in whichever section it
293 // gets merged into so that we can sort its contents and emit a correct data
294 // directory entry for the exception table. This is also the case for some
295 // other sections (such as .edata) but because the contents of those sections
296 // are entirely linker-generated we can keep track of their locations using
297 // the chunks that the linker creates. All .pdata chunks come from input
298 // files, so we need to keep track of them separately.
299 Chunk *firstPdata = nullptr;
300 Chunk *lastPdata;
301
302 COFFLinkerContext &ctx;
303};
304} // anonymous namespace
305
306void lld::coff::writeResult(COFFLinkerContext &ctx) { Writer(ctx).run(); }
1
Calling 'Writer::run'
307
308void OutputSection::addChunk(Chunk *c) {
309 chunks.push_back(c);
310}
311
312void OutputSection::insertChunkAtStart(Chunk *c) {
313 chunks.insert(chunks.begin(), c);
314}
315
316void OutputSection::setPermissions(uint32_t c) {
317 header.Characteristics &= ~permMask;
318 header.Characteristics |= c;
319}
320
321void OutputSection::merge(OutputSection *other) {
322 chunks.insert(chunks.end(), other->chunks.begin(), other->chunks.end());
323 other->chunks.clear();
324 contribSections.insert(contribSections.end(), other->contribSections.begin(),
325 other->contribSections.end());
326 other->contribSections.clear();
327}
328
329// Write the section header to a given buffer.
330void OutputSection::writeHeaderTo(uint8_t *buf) {
331 auto *hdr = reinterpret_cast<coff_section *>(buf);
332 *hdr = header;
333 if (stringTableOff) {
334 // If name is too long, write offset into the string table as a name.
335 sprintf(hdr->Name, "/%d", stringTableOff);
336 } else {
337 assert(!config->debug || name.size() <= COFF::NameSize ||(static_cast <bool> (!config->debug || name.size() <=
COFF::NameSize || (hdr->Characteristics & IMAGE_SCN_MEM_DISCARDABLE
) == 0) ? void (0) : __assert_fail ("!config->debug || name.size() <= COFF::NameSize || (hdr->Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0"
, "lld/COFF/Writer.cpp", 338, __extension__ __PRETTY_FUNCTION__
))
338 (hdr->Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0)(static_cast <bool> (!config->debug || name.size() <=
COFF::NameSize || (hdr->Characteristics & IMAGE_SCN_MEM_DISCARDABLE
) == 0) ? void (0) : __assert_fail ("!config->debug || name.size() <= COFF::NameSize || (hdr->Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0"
, "lld/COFF/Writer.cpp", 338, __extension__ __PRETTY_FUNCTION__
))
;
339 strncpy(hdr->Name, name.data(),
340 std::min(name.size(), (size_t)COFF::NameSize));
341 }
342}
343
344void OutputSection::addContributingPartialSection(PartialSection *sec) {
345 contribSections.push_back(sec);
346}
347
348// Check whether the target address S is in range from a relocation
349// of type relType at address P.
350static bool isInRange(uint16_t relType, uint64_t s, uint64_t p, int margin) {
351 if (config->machine == ARMNT) {
352 int64_t diff = AbsoluteDifference(s, p + 4) + margin;
353 switch (relType) {
354 case IMAGE_REL_ARM_BRANCH20T:
355 return isInt<21>(diff);
356 case IMAGE_REL_ARM_BRANCH24T:
357 case IMAGE_REL_ARM_BLX23T:
358 return isInt<25>(diff);
359 default:
360 return true;
361 }
362 } else if (config->machine == ARM64) {
363 int64_t diff = AbsoluteDifference(s, p) + margin;
364 switch (relType) {
365 case IMAGE_REL_ARM64_BRANCH26:
366 return isInt<28>(diff);
367 case IMAGE_REL_ARM64_BRANCH19:
368 return isInt<21>(diff);
369 case IMAGE_REL_ARM64_BRANCH14:
370 return isInt<16>(diff);
371 default:
372 return true;
373 }
374 } else {
375 llvm_unreachable("Unexpected architecture")::llvm::llvm_unreachable_internal("Unexpected architecture", "lld/COFF/Writer.cpp"
, 375)
;
376 }
377}
378
379// Return the last thunk for the given target if it is in range,
380// or create a new one.
381static std::pair<Defined *, bool>
382getThunk(DenseMap<uint64_t, Defined *> &lastThunks, Defined *target, uint64_t p,
383 uint16_t type, int margin) {
384 Defined *&lastThunk = lastThunks[target->getRVA()];
385 if (lastThunk && isInRange(type, lastThunk->getRVA(), p, margin))
386 return {lastThunk, false};
387 Chunk *c;
388 switch (config->machine) {
389 case ARMNT:
390 c = make<RangeExtensionThunkARM>(target);
391 break;
392 case ARM64:
393 c = make<RangeExtensionThunkARM64>(target);
394 break;
395 default:
396 llvm_unreachable("Unexpected architecture")::llvm::llvm_unreachable_internal("Unexpected architecture", "lld/COFF/Writer.cpp"
, 396)
;
397 }
398 Defined *d = make<DefinedSynthetic>("", c);
399 lastThunk = d;
400 return {d, true};
401}
402
403// This checks all relocations, and for any relocation which isn't in range
404// it adds a thunk after the section chunk that contains the relocation.
405// If the latest thunk for the specific target is in range, that is used
406// instead of creating a new thunk. All range checks are done with the
407// specified margin, to make sure that relocations that originally are in
408// range, but only barely, also get thunks - in case other added thunks makes
409// the target go out of range.
410//
411// After adding thunks, we verify that all relocations are in range (with
412// no extra margin requirements). If this failed, we restart (throwing away
413// the previously created thunks) and retry with a wider margin.
414static bool createThunks(OutputSection *os, int margin) {
415 bool addressesChanged = false;
416 DenseMap<uint64_t, Defined *> lastThunks;
417 DenseMap<std::pair<ObjFile *, Defined *>, uint32_t> thunkSymtabIndices;
418 size_t thunksSize = 0;
419 // Recheck Chunks.size() each iteration, since we can insert more
420 // elements into it.
421 for (size_t i = 0; i != os->chunks.size(); ++i) {
422 SectionChunk *sc = dyn_cast_or_null<SectionChunk>(os->chunks[i]);
423 if (!sc)
424 continue;
425 size_t thunkInsertionSpot = i + 1;
426
427 // Try to get a good enough estimate of where new thunks will be placed.
428 // Offset this by the size of the new thunks added so far, to make the
429 // estimate slightly better.
430 size_t thunkInsertionRVA = sc->getRVA() + sc->getSize() + thunksSize;
431 ObjFile *file = sc->file;
432 std::vector<std::pair<uint32_t, uint32_t>> relocReplacements;
433 ArrayRef<coff_relocation> originalRelocs =
434 file->getCOFFObj()->getRelocations(sc->header);
435 for (size_t j = 0, e = originalRelocs.size(); j < e; ++j) {
436 const coff_relocation &rel = originalRelocs[j];
437 Symbol *relocTarget = file->getSymbol(rel.SymbolTableIndex);
438
439 // The estimate of the source address P should be pretty accurate,
440 // but we don't know whether the target Symbol address should be
441 // offset by thunksSize or not (or by some of thunksSize but not all of
442 // it), giving us some uncertainty once we have added one thunk.
443 uint64_t p = sc->getRVA() + rel.VirtualAddress + thunksSize;
444
445 Defined *sym = dyn_cast_or_null<Defined>(relocTarget);
446 if (!sym)
447 continue;
448
449 uint64_t s = sym->getRVA();
450
451 if (isInRange(rel.Type, s, p, margin))
452 continue;
453
454 // If the target isn't in range, hook it up to an existing or new
455 // thunk.
456 Defined *thunk;
457 bool wasNew;
458 std::tie(thunk, wasNew) = getThunk(lastThunks, sym, p, rel.Type, margin);
459 if (wasNew) {
460 Chunk *thunkChunk = thunk->getChunk();
461 thunkChunk->setRVA(
462 thunkInsertionRVA); // Estimate of where it will be located.
463 os->chunks.insert(os->chunks.begin() + thunkInsertionSpot, thunkChunk);
464 thunkInsertionSpot++;
465 thunksSize += thunkChunk->getSize();
466 thunkInsertionRVA += thunkChunk->getSize();
467 addressesChanged = true;
468 }
469
470 // To redirect the relocation, add a symbol to the parent object file's
471 // symbol table, and replace the relocation symbol table index with the
472 // new index.
473 auto insertion = thunkSymtabIndices.insert({{file, thunk}, ~0U});
474 uint32_t &thunkSymbolIndex = insertion.first->second;
475 if (insertion.second)
476 thunkSymbolIndex = file->addRangeThunkSymbol(thunk);
477 relocReplacements.push_back({j, thunkSymbolIndex});
478 }
479
480 // Get a writable copy of this section's relocations so they can be
481 // modified. If the relocations point into the object file, allocate new
482 // memory. Otherwise, this must be previously allocated memory that can be
483 // modified in place.
484 ArrayRef<coff_relocation> curRelocs = sc->getRelocs();
485 MutableArrayRef<coff_relocation> newRelocs;
486 if (originalRelocs.data() == curRelocs.data()) {
487 newRelocs = makeMutableArrayRef(
488 bAlloc().Allocate<coff_relocation>(originalRelocs.size()),
489 originalRelocs.size());
490 } else {
491 newRelocs = makeMutableArrayRef(
492 const_cast<coff_relocation *>(curRelocs.data()), curRelocs.size());
493 }
494
495 // Copy each relocation, but replace the symbol table indices which need
496 // thunks.
497 auto nextReplacement = relocReplacements.begin();
498 auto endReplacement = relocReplacements.end();
499 for (size_t i = 0, e = originalRelocs.size(); i != e; ++i) {
500 newRelocs[i] = originalRelocs[i];
501 if (nextReplacement != endReplacement && nextReplacement->first == i) {
502 newRelocs[i].SymbolTableIndex = nextReplacement->second;
503 ++nextReplacement;
504 }
505 }
506
507 sc->setRelocs(newRelocs);
508 }
509 return addressesChanged;
510}
511
512// Verify that all relocations are in range, with no extra margin requirements.
513static bool verifyRanges(const std::vector<Chunk *> chunks) {
514 for (Chunk *c : chunks) {
515 SectionChunk *sc = dyn_cast_or_null<SectionChunk>(c);
516 if (!sc)
517 continue;
518
519 ArrayRef<coff_relocation> relocs = sc->getRelocs();
520 for (size_t j = 0, e = relocs.size(); j < e; ++j) {
521 const coff_relocation &rel = relocs[j];
522 Symbol *relocTarget = sc->file->getSymbol(rel.SymbolTableIndex);
523
524 Defined *sym = dyn_cast_or_null<Defined>(relocTarget);
525 if (!sym)
526 continue;
527
528 uint64_t p = sc->getRVA() + rel.VirtualAddress;
529 uint64_t s = sym->getRVA();
530
531 if (!isInRange(rel.Type, s, p, 0))
532 return false;
533 }
534 }
535 return true;
536}
537
538// Assign addresses and add thunks if necessary.
539void Writer::finalizeAddresses() {
540 assignAddresses();
541 if (config->machine != ARMNT && config->machine != ARM64)
542 return;
543
544 size_t origNumChunks = 0;
545 for (OutputSection *sec : ctx.outputSections) {
546 sec->origChunks = sec->chunks;
547 origNumChunks += sec->chunks.size();
548 }
549
550 int pass = 0;
551 int margin = 1024 * 100;
552 while (true) {
553 // First check whether we need thunks at all, or if the previous pass of
554 // adding them turned out ok.
555 bool rangesOk = true;
556 size_t numChunks = 0;
557 for (OutputSection *sec : ctx.outputSections) {
558 if (!verifyRanges(sec->chunks)) {
559 rangesOk = false;
560 break;
561 }
562 numChunks += sec->chunks.size();
563 }
564 if (rangesOk) {
565 if (pass > 0)
566 log("Added " + Twine(numChunks - origNumChunks) + " thunks with " +
567 "margin " + Twine(margin) + " in " + Twine(pass) + " passes");
568 return;
569 }
570
571 if (pass >= 10)
572 fatal("adding thunks hasn't converged after " + Twine(pass) + " passes");
573
574 if (pass > 0) {
575 // If the previous pass didn't work out, reset everything back to the
576 // original conditions before retrying with a wider margin. This should
577 // ideally never happen under real circumstances.
578 for (OutputSection *sec : ctx.outputSections)
579 sec->chunks = sec->origChunks;
580 margin *= 2;
581 }
582
583 // Try adding thunks everywhere where it is needed, with a margin
584 // to avoid things going out of range due to the added thunks.
585 bool addressesChanged = false;
586 for (OutputSection *sec : ctx.outputSections)
587 addressesChanged |= createThunks(sec, margin);
588 // If the verification above thought we needed thunks, we should have
589 // added some.
590 assert(addressesChanged)(static_cast <bool> (addressesChanged) ? void (0) : __assert_fail
("addressesChanged", "lld/COFF/Writer.cpp", 590, __extension__
__PRETTY_FUNCTION__))
;
591 (void)addressesChanged;
592
593 // Recalculate the layout for the whole image (and verify the ranges at
594 // the start of the next round).
595 assignAddresses();
596
597 pass++;
598 }
599}
600
601// The main function of the writer.
602void Writer::run() {
603 ScopedTimer t1(ctx.codeLayoutTimer);
604
605 createImportTables();
2
Calling 'Writer::createImportTables'
606 createSections();
607 appendImportThunks();
608 // Import thunks must be added before the Control Flow Guard tables are added.
609 createMiscChunks();
610 createExportTable();
611 mergeSections();
612 removeUnusedSections();
613 finalizeAddresses();
614 removeEmptySections();
615 assignOutputSectionIndices();
616 setSectionPermissions();
617 createSymbolAndStringTable();
618
619 if (fileSize > UINT32_MAX(4294967295U))
620 fatal("image size (" + Twine(fileSize) + ") " +
621 "exceeds maximum allowable size (" + Twine(UINT32_MAX(4294967295U)) + ")");
622
623 openFile(config->outputFile);
624 if (config->is64()) {
625 writeHeader<pe32plus_header>();
626 } else {
627 writeHeader<pe32_header>();
628 }
629 writeSections();
630 sortExceptionTable();
631
632 // Fix up the alignment in the TLS Directory's characteristic field,
633 // if a specific alignment value is needed
634 if (tlsAlignment)
635 fixTlsAlignment();
636
637 t1.stop();
638
639 if (!config->pdbPath.empty() && config->debug) {
640 assert(buildId)(static_cast <bool> (buildId) ? void (0) : __assert_fail
("buildId", "lld/COFF/Writer.cpp", 640, __extension__ __PRETTY_FUNCTION__
))
;
641 createPDB(ctx, sectionTable, buildId->buildId);
642 }
643 writeBuildId();
644
645 writeLLDMapFile(ctx);
646 writeMapFile(ctx);
647
648 if (errorCount())
649 return;
650
651 ScopedTimer t2(ctx.outputCommitTimer);
652 if (auto e = buffer->commit())
653 fatal("failed to write the output file: " + toString(std::move(e)));
654}
655
656static StringRef getOutputSectionName(StringRef name) {
657 StringRef s = name.split('$').first;
658
659 // Treat a later period as a separator for MinGW, for sections like
660 // ".ctors.01234".
661 return s.substr(0, s.find('.', 1));
662}
663
664// For /order.
665static void sortBySectionOrder(std::vector<Chunk *> &chunks) {
666 auto getPriority = [](const Chunk *c) {
667 if (auto *sec = dyn_cast<SectionChunk>(c))
668 if (sec->sym)
669 return config->order.lookup(sec->sym->getName());
670 return 0;
671 };
672
673 llvm::stable_sort(chunks, [=](const Chunk *a, const Chunk *b) {
674 return getPriority(a) < getPriority(b);
675 });
676}
677
678// Change the characteristics of existing PartialSections that belong to the
679// section Name to Chars.
680void Writer::fixPartialSectionChars(StringRef name, uint32_t chars) {
681 for (auto it : partialSections) {
682 PartialSection *pSec = it.second;
683 StringRef curName = pSec->name;
684 if (!curName.consume_front(name) ||
685 (!curName.empty() && !curName.startswith("$")))
686 continue;
687 if (pSec->characteristics == chars)
688 continue;
689 PartialSection *destSec = createPartialSection(pSec->name, chars);
690 destSec->chunks.insert(destSec->chunks.end(), pSec->chunks.begin(),
691 pSec->chunks.end());
692 pSec->chunks.clear();
693 }
694}
695
696// Sort concrete section chunks from GNU import libraries.
697//
698// GNU binutils doesn't use short import files, but instead produces import
699// libraries that consist of object files, with section chunks for the .idata$*
700// sections. These are linked just as regular static libraries. Each import
701// library consists of one header object, one object file for every imported
702// symbol, and one trailer object. In order for the .idata tables/lists to
703// be formed correctly, the section chunks within each .idata$* section need
704// to be grouped by library, and sorted alphabetically within each library
705// (which makes sure the header comes first and the trailer last).
706bool Writer::fixGnuImportChunks() {
707 uint32_t rdata = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
708
709 // Make sure all .idata$* section chunks are mapped as RDATA in order to
710 // be sorted into the same sections as our own synthesized .idata chunks.
711 fixPartialSectionChars(".idata", rdata);
712
713 bool hasIdata = false;
714 // Sort all .idata$* chunks, grouping chunks from the same library,
715 // with alphabetical ordering of the object fils within a library.
716 for (auto it : partialSections) {
717 PartialSection *pSec = it.second;
718 if (!pSec->name.startswith(".idata"))
719 continue;
720
721 if (!pSec->chunks.empty())
722 hasIdata = true;
723 llvm::stable_sort(pSec->chunks, [&](Chunk *s, Chunk *t) {
724 SectionChunk *sc1 = dyn_cast_or_null<SectionChunk>(s);
725 SectionChunk *sc2 = dyn_cast_or_null<SectionChunk>(t);
726 if (!sc1 || !sc2) {
727 // if SC1, order them ascending. If SC2 or both null,
728 // S is not less than T.
729 return sc1 != nullptr;
730 }
731 // Make a string with "libraryname/objectfile" for sorting, achieving
732 // both grouping by library and sorting of objects within a library,
733 // at once.
734 std::string key1 =
735 (sc1->file->parentName + "/" + sc1->file->getName()).str();
736 std::string key2 =
737 (sc2->file->parentName + "/" + sc2->file->getName()).str();
738 return key1 < key2;
739 });
740 }
741 return hasIdata;
742}
743
744// Add generated idata chunks, for imported symbols and DLLs, and a
745// terminator in .idata$2.
746void Writer::addSyntheticIdata() {
747 uint32_t rdata = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
748 idata.create();
749
750 // Add the .idata content in the right section groups, to allow
751 // chunks from other linked in object files to be grouped together.
752 // See Microsoft PE/COFF spec 5.4 for details.
753 auto add = [&](StringRef n, std::vector<Chunk *> &v) {
754 PartialSection *pSec = createPartialSection(n, rdata);
755 pSec->chunks.insert(pSec->chunks.end(), v.begin(), v.end());
756 };
757
758 // The loader assumes a specific order of data.
759 // Add each type in the correct order.
760 add(".idata$2", idata.dirs);
761 add(".idata$4", idata.lookups);
762 add(".idata$5", idata.addresses);
763 if (!idata.hints.empty())
764 add(".idata$6", idata.hints);
765 add(".idata$7", idata.dllNames);
766}
767
768// Locate the first Chunk and size of the import directory list and the
769// IAT.
770void Writer::locateImportTables() {
771 uint32_t rdata = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
772
773 if (PartialSection *importDirs = findPartialSection(".idata$2", rdata)) {
774 if (!importDirs->chunks.empty())
775 importTableStart = importDirs->chunks.front();
776 for (Chunk *c : importDirs->chunks)
777 importTableSize += c->getSize();
778 }
779
780 if (PartialSection *importAddresses = findPartialSection(".idata$5", rdata)) {
781 if (!importAddresses->chunks.empty())
782 iatStart = importAddresses->chunks.front();
783 for (Chunk *c : importAddresses->chunks)
784 iatSize += c->getSize();
785 }
786}
787
788// Return whether a SectionChunk's suffix (the dollar and any trailing
789// suffix) should be removed and sorted into the main suffixless
790// PartialSection.
791static bool shouldStripSectionSuffix(SectionChunk *sc, StringRef name) {
792 // On MinGW, comdat groups are formed by putting the comdat group name
793 // after the '$' in the section name. For .eh_frame$<symbol>, that must
794 // still be sorted before the .eh_frame trailer from crtend.o, thus just
795 // strip the section name trailer. For other sections, such as
796 // .tls$$<symbol> (where non-comdat .tls symbols are otherwise stored in
797 // ".tls$"), they must be strictly sorted after .tls. And for the
798 // hypothetical case of comdat .CRT$XCU, we definitely need to keep the
799 // suffix for sorting. Thus, to play it safe, only strip the suffix for
800 // the standard sections.
801 if (!config->mingw)
802 return false;
803 if (!sc || !sc->isCOMDAT())
804 return false;
805 return name.startswith(".text$") || name.startswith(".data$") ||
806 name.startswith(".rdata$") || name.startswith(".pdata$") ||
807 name.startswith(".xdata$") || name.startswith(".eh_frame$");
808}
809
810void Writer::sortSections() {
811 if (!config->callGraphProfile.empty()) {
812 DenseMap<const SectionChunk *, int> order =
813 computeCallGraphProfileOrder(ctx);
814 for (auto it : order) {
815 if (DefinedRegular *sym = it.first->sym)
816 config->order[sym->getName()] = it.second;
817 }
818 }
819 if (!config->order.empty())
820 for (auto it : partialSections)
821 sortBySectionOrder(it.second->chunks);
822}
823
824// Create output section objects and add them to OutputSections.
825void Writer::createSections() {
826 // First, create the builtin sections.
827 const uint32_t data = IMAGE_SCN_CNT_INITIALIZED_DATA;
828 const uint32_t bss = IMAGE_SCN_CNT_UNINITIALIZED_DATA;
829 const uint32_t code = IMAGE_SCN_CNT_CODE;
830 const uint32_t discardable = IMAGE_SCN_MEM_DISCARDABLE;
831 const uint32_t r = IMAGE_SCN_MEM_READ;
832 const uint32_t w = IMAGE_SCN_MEM_WRITE;
833 const uint32_t x = IMAGE_SCN_MEM_EXECUTE;
834
835 SmallDenseMap<std::pair<StringRef, uint32_t>, OutputSection *> sections;
836 auto createSection = [&](StringRef name, uint32_t outChars) {
837 OutputSection *&sec = sections[{name, outChars}];
838 if (!sec) {
839 sec = make<OutputSection>(name, outChars);
840 ctx.outputSections.push_back(sec);
841 }
842 return sec;
843 };
844
845 // Try to match the section order used by link.exe.
846 textSec = createSection(".text", code | r | x);
847 createSection(".bss", bss | r | w);
848 rdataSec = createSection(".rdata", data | r);
849 buildidSec = createSection(".buildid", data | r);
850 dataSec = createSection(".data", data | r | w);
851 pdataSec = createSection(".pdata", data | r);
852 idataSec = createSection(".idata", data | r);
853 edataSec = createSection(".edata", data | r);
854 didatSec = createSection(".didat", data | r);
855 rsrcSec = createSection(".rsrc", data | r);
856 relocSec = createSection(".reloc", data | discardable | r);
857 ctorsSec = createSection(".ctors", data | r | w);
858 dtorsSec = createSection(".dtors", data | r | w);
859
860 // Then bin chunks by name and output characteristics.
861 for (Chunk *c : ctx.symtab.getChunks()) {
862 auto *sc = dyn_cast<SectionChunk>(c);
863 if (sc && !sc->live) {
864 if (config->verbose)
865 sc->printDiscardedMessage();
866 continue;
867 }
868 StringRef name = c->getSectionName();
869 if (shouldStripSectionSuffix(sc, name))
870 name = name.split('$').first;
871
872 if (name.startswith(".tls"))
873 tlsAlignment = std::max(tlsAlignment, c->getAlignment());
874
875 PartialSection *pSec = createPartialSection(name,
876 c->getOutputCharacteristics());
877 pSec->chunks.push_back(c);
878 }
879
880 fixPartialSectionChars(".rsrc", data | r);
881 fixPartialSectionChars(".edata", data | r);
882 // Even in non MinGW cases, we might need to link against GNU import
883 // libraries.
884 bool hasIdata = fixGnuImportChunks();
885 if (!idata.empty())
886 hasIdata = true;
887
888 if (hasIdata)
889 addSyntheticIdata();
890
891 sortSections();
892
893 if (hasIdata)
894 locateImportTables();
895
896 // Then create an OutputSection for each section.
897 // '$' and all following characters in input section names are
898 // discarded when determining output section. So, .text$foo
899 // contributes to .text, for example. See PE/COFF spec 3.2.
900 for (auto it : partialSections) {
901 PartialSection *pSec = it.second;
902 StringRef name = getOutputSectionName(pSec->name);
903 uint32_t outChars = pSec->characteristics;
904
905 if (name == ".CRT") {
906 // In link.exe, there is a special case for the I386 target where .CRT
907 // sections are treated as if they have output characteristics DATA | R if
908 // their characteristics are DATA | R | W. This implements the same
909 // special case for all architectures.
910 outChars = data | r;
911
912 log("Processing section " + pSec->name + " -> " + name);
913
914 sortCRTSectionChunks(pSec->chunks);
915 }
916
917 OutputSection *sec = createSection(name, outChars);
918 for (Chunk *c : pSec->chunks)
919 sec->addChunk(c);
920
921 sec->addContributingPartialSection(pSec);
922 }
923
924 // Finally, move some output sections to the end.
925 auto sectionOrder = [&](const OutputSection *s) {
926 // Move DISCARDABLE (or non-memory-mapped) sections to the end of file
927 // because the loader cannot handle holes. Stripping can remove other
928 // discardable ones than .reloc, which is first of them (created early).
929 if (s->header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE)
930 return 2;
931 // .rsrc should come at the end of the non-discardable sections because its
932 // size may change by the Win32 UpdateResources() function, causing
933 // subsequent sections to move (see https://crbug.com/827082).
934 if (s == rsrcSec)
935 return 1;
936 return 0;
937 };
938 llvm::stable_sort(ctx.outputSections,
939 [&](const OutputSection *s, const OutputSection *t) {
940 return sectionOrder(s) < sectionOrder(t);
941 });
942}
943
944void Writer::createMiscChunks() {
945 for (MergeChunk *p : ctx.mergeChunkInstances) {
946 if (p) {
947 p->finalizeContents();
948 rdataSec->addChunk(p);
949 }
950 }
951
952 // Create thunks for locally-dllimported symbols.
953 if (!ctx.symtab.localImportChunks.empty()) {
954 for (Chunk *c : ctx.symtab.localImportChunks)
955 rdataSec->addChunk(c);
956 }
957
958 // Create Debug Information Chunks
959 OutputSection *debugInfoSec = config->mingw ? buildidSec : rdataSec;
960 if (config->debug || config->repro || config->cetCompat) {
961 debugDirectory =
962 make<DebugDirectoryChunk>(ctx, debugRecords, config->repro);
963 debugDirectory->setAlignment(4);
964 debugInfoSec->addChunk(debugDirectory);
965 }
966
967 if (config->debug) {
968 // Make a CVDebugRecordChunk even when /DEBUG:CV is not specified. We
969 // output a PDB no matter what, and this chunk provides the only means of
970 // allowing a debugger to match a PDB and an executable. So we need it even
971 // if we're ultimately not going to write CodeView data to the PDB.
972 buildId = make<CVDebugRecordChunk>();
973 debugRecords.push_back({COFF::IMAGE_DEBUG_TYPE_CODEVIEW, buildId});
974 }
975
976 if (config->cetCompat) {
977 debugRecords.push_back({COFF::IMAGE_DEBUG_TYPE_EX_DLLCHARACTERISTICS,
978 make<ExtendedDllCharacteristicsChunk>(
979 IMAGE_DLL_CHARACTERISTICS_EX_CET_COMPAT)});
980 }
981
982 // Align and add each chunk referenced by the debug data directory.
983 for (std::pair<COFF::DebugType, Chunk *> r : debugRecords) {
984 r.second->setAlignment(4);
985 debugInfoSec->addChunk(r.second);
986 }
987
988 // Create SEH table. x86-only.
989 if (config->safeSEH)
990 createSEHTable();
991
992 // Create /guard:cf tables if requested.
993 if (config->guardCF != GuardCFLevel::Off)
994 createGuardCFTables();
995
996 if (config->autoImport)
997 createRuntimePseudoRelocs();
998
999 if (config->mingw)
1000 insertCtorDtorSymbols();
1001}
1002
1003// Create .idata section for the DLL-imported symbol table.
1004// The format of this section is inherently Windows-specific.
1005// IdataContents class abstracted away the details for us,
1006// so we just let it create chunks and add them to the section.
1007void Writer::createImportTables() {
1008 // Initialize DLLOrder so that import entries are ordered in
1009 // the same order as in the command line. (That affects DLL
1010 // initialization order, and this ordering is MSVC-compatible.)
1011 for (ImportFile *file : ctx.importFileInstances) {
1012 if (!file->live)
3
Assuming field 'live' is true
4
Taking false branch
1013 continue;
1014
1015 std::string dll = StringRef(file->dllName).lower();
1016 if (config->dllOrder.count(dll) == 0)
5
Assuming the condition is false
1017 config->dllOrder[dll] = config->dllOrder.size();
1018
1019 if (file->impSym && !isa<DefinedImportData>(file->impSym))
6
Assuming field 'impSym' is null
1020 fatal(toString(*file->impSym) + " was replaced");
1021 DefinedImportData *impSym = cast_or_null<DefinedImportData>(file->impSym);
7
Assuming null pointer is passed into cast
8
'impSym' initialized to a null pointer value
1022 if (config->delayLoads.count(StringRef(file->dllName).lower())) {
9
Assuming the condition is true
10
Taking true branch
1023 if (!file->thunkSym)
11
Assuming field 'thunkSym' is null
12
Taking true branch
1024 fatal("cannot delay-load " + toString(file) +
1025 " due to import of data: " + toString(*impSym));
13
Forming reference to null pointer
1026 delayIdata.add(impSym);
1027 } else {
1028 idata.add(impSym);
1029 }
1030 }
1031}
1032
1033void Writer::appendImportThunks() {
1034 if (ctx.importFileInstances.empty())
1035 return;
1036
1037 for (ImportFile *file : ctx.importFileInstances) {
1038 if (!file->live)
1039 continue;
1040
1041 if (!file->thunkSym)
1042 continue;
1043
1044 if (!isa<DefinedImportThunk>(file->thunkSym))
1045 fatal(toString(*file->thunkSym) + " was replaced");
1046 DefinedImportThunk *thunk = cast<DefinedImportThunk>(file->thunkSym);
1047 if (file->thunkLive)
1048 textSec->addChunk(thunk->getChunk());
1049 }
1050
1051 if (!delayIdata.empty()) {
1052 Defined *helper = cast<Defined>(config->delayLoadHelper);
1053 delayIdata.create(ctx, helper);
1054 for (Chunk *c : delayIdata.getChunks())
1055 didatSec->addChunk(c);
1056 for (Chunk *c : delayIdata.getDataChunks())
1057 dataSec->addChunk(c);
1058 for (Chunk *c : delayIdata.getCodeChunks())
1059 textSec->addChunk(c);
1060 }
1061}
1062
1063void Writer::createExportTable() {
1064 if (!edataSec->chunks.empty()) {
1065 // Allow using a custom built export table from input object files, instead
1066 // of having the linker synthesize the tables.
1067 if (config->hadExplicitExports)
1068 warn("literal .edata sections override exports");
1069 } else if (!config->exports.empty()) {
1070 for (Chunk *c : edata.chunks)
1071 edataSec->addChunk(c);
1072 }
1073 if (!edataSec->chunks.empty()) {
1074 edataStart = edataSec->chunks.front();
1075 edataEnd = edataSec->chunks.back();
1076 }
1077 // Warn on exported deleting destructor.
1078 for (auto e : config->exports)
1079 if (e.sym && e.sym->getName().startswith("??_G"))
1080 warn("export of deleting dtor: " + toString(*e.sym));
1081}
1082
1083void Writer::removeUnusedSections() {
1084 // Remove sections that we can be sure won't get content, to avoid
1085 // allocating space for their section headers.
1086 auto isUnused = [this](OutputSection *s) {
1087 if (s == relocSec)
1088 return false; // This section is populated later.
1089 // MergeChunks have zero size at this point, as their size is finalized
1090 // later. Only remove sections that have no Chunks at all.
1091 return s->chunks.empty();
1092 };
1093 llvm::erase_if(ctx.outputSections, isUnused);
1094}
1095
1096// The Windows loader doesn't seem to like empty sections,
1097// so we remove them if any.
1098void Writer::removeEmptySections() {
1099 auto isEmpty = [](OutputSection *s) { return s->getVirtualSize() == 0; };
1100 llvm::erase_if(ctx.outputSections, isEmpty);
1101}
1102
1103void Writer::assignOutputSectionIndices() {
1104 // Assign final output section indices, and assign each chunk to its output
1105 // section.
1106 uint32_t idx = 1;
1107 for (OutputSection *os : ctx.outputSections) {
1108 os->sectionIndex = idx;
1109 for (Chunk *c : os->chunks)
1110 c->setOutputSectionIdx(idx);
1111 ++idx;
1112 }
1113
1114 // Merge chunks are containers of chunks, so assign those an output section
1115 // too.
1116 for (MergeChunk *mc : ctx.mergeChunkInstances)
1117 if (mc)
1118 for (SectionChunk *sc : mc->sections)
1119 if (sc && sc->live)
1120 sc->setOutputSectionIdx(mc->getOutputSectionIdx());
1121}
1122
1123size_t Writer::addEntryToStringTable(StringRef str) {
1124 assert(str.size() > COFF::NameSize)(static_cast <bool> (str.size() > COFF::NameSize) ? void
(0) : __assert_fail ("str.size() > COFF::NameSize", "lld/COFF/Writer.cpp"
, 1124, __extension__ __PRETTY_FUNCTION__))
;
1125 size_t offsetOfEntry = strtab.size() + 4; // +4 for the size field
1126 strtab.insert(strtab.end(), str.begin(), str.end());
1127 strtab.push_back('\0');
1128 return offsetOfEntry;
1129}
1130
1131Optional<coff_symbol16> Writer::createSymbol(Defined *def) {
1132 coff_symbol16 sym;
1133 switch (def->kind()) {
1134 case Symbol::DefinedAbsoluteKind:
1135 sym.Value = def->getRVA();
1136 sym.SectionNumber = IMAGE_SYM_ABSOLUTE;
1137 break;
1138 case Symbol::DefinedSyntheticKind:
1139 // Relative symbols are unrepresentable in a COFF symbol table.
1140 return None;
1141 default: {
1142 // Don't write symbols that won't be written to the output to the symbol
1143 // table.
1144 Chunk *c = def->getChunk();
1145 if (!c)
1146 return None;
1147 OutputSection *os = ctx.getOutputSection(c);
1148 if (!os)
1149 return None;
1150
1151 sym.Value = def->getRVA() - os->getRVA();
1152 sym.SectionNumber = os->sectionIndex;
1153 break;
1154 }
1155 }
1156
1157 // Symbols that are runtime pseudo relocations don't point to the actual
1158 // symbol data itself (as they are imported), but points to the IAT entry
1159 // instead. Avoid emitting them to the symbol table, as they can confuse
1160 // debuggers.
1161 if (def->isRuntimePseudoReloc)
1162 return None;
1163
1164 StringRef name = def->getName();
1165 if (name.size() > COFF::NameSize) {
1166 sym.Name.Offset.Zeroes = 0;
1167 sym.Name.Offset.Offset = addEntryToStringTable(name);
1168 } else {
1169 memset(sym.Name.ShortName, 0, COFF::NameSize);
1170 memcpy(sym.Name.ShortName, name.data(), name.size());
1171 }
1172
1173 if (auto *d = dyn_cast<DefinedCOFF>(def)) {
1174 COFFSymbolRef ref = d->getCOFFSymbol();
1175 sym.Type = ref.getType();
1176 sym.StorageClass = ref.getStorageClass();
1177 } else {
1178 sym.Type = IMAGE_SYM_TYPE_NULL;
1179 sym.StorageClass = IMAGE_SYM_CLASS_EXTERNAL;
1180 }
1181 sym.NumberOfAuxSymbols = 0;
1182 return sym;
1183}
1184
1185void Writer::createSymbolAndStringTable() {
1186 // PE/COFF images are limited to 8 byte section names. Longer names can be
1187 // supported by writing a non-standard string table, but this string table is
1188 // not mapped at runtime and the long names will therefore be inaccessible.
1189 // link.exe always truncates section names to 8 bytes, whereas binutils always
1190 // preserves long section names via the string table. LLD adopts a hybrid
1191 // solution where discardable sections have long names preserved and
1192 // non-discardable sections have their names truncated, to ensure that any
1193 // section which is mapped at runtime also has its name mapped at runtime.
1194 for (OutputSection *sec : ctx.outputSections) {
1195 if (sec->name.size() <= COFF::NameSize)
1196 continue;
1197 if ((sec->header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0)
1198 continue;
1199 if (config->warnLongSectionNames) {
1200 warn("section name " + sec->name +
1201 " is longer than 8 characters and will use a non-standard string "
1202 "table");
1203 }
1204 sec->setStringTableOff(addEntryToStringTable(sec->name));
1205 }
1206
1207 if (config->debugDwarf || config->debugSymtab) {
1208 for (ObjFile *file : ctx.objFileInstances) {
1209 for (Symbol *b : file->getSymbols()) {
1210 auto *d = dyn_cast_or_null<Defined>(b);
1211 if (!d || d->writtenToSymtab)
1212 continue;
1213 d->writtenToSymtab = true;
1214 if (auto *dc = dyn_cast_or_null<DefinedCOFF>(d)) {
1215 COFFSymbolRef symRef = dc->getCOFFSymbol();
1216 if (symRef.isSectionDefinition() ||
1217 symRef.getStorageClass() == COFF::IMAGE_SYM_CLASS_LABEL)
1218 continue;
1219 }
1220
1221 if (Optional<coff_symbol16> sym = createSymbol(d))
1222 outputSymtab.push_back(*sym);
1223 }
1224 }
1225 }
1226
1227 if (outputSymtab.empty() && strtab.empty())
1228 return;
1229
1230 // We position the symbol table to be adjacent to the end of the last section.
1231 uint64_t fileOff = fileSize;
1232 pointerToSymbolTable = fileOff;
1233 fileOff += outputSymtab.size() * sizeof(coff_symbol16);
1234 fileOff += 4 + strtab.size();
1235 fileSize = alignTo(fileOff, config->fileAlign);
1236}
1237
1238void Writer::mergeSections() {
1239 if (!pdataSec->chunks.empty()) {
1240 firstPdata = pdataSec->chunks.front();
1241 lastPdata = pdataSec->chunks.back();
1242 }
1243
1244 for (auto &p : config->merge) {
1245 StringRef toName = p.second;
1246 if (p.first == toName)
1247 continue;
1248 StringSet<> names;
1249 while (true) {
1250 if (!names.insert(toName).second)
1251 fatal("/merge: cycle found for section '" + p.first + "'");
1252 auto i = config->merge.find(toName);
1253 if (i == config->merge.end())
1254 break;
1255 toName = i->second;
1256 }
1257 OutputSection *from = findSection(p.first);
1258 OutputSection *to = findSection(toName);
1259 if (!from)
1260 continue;
1261 if (!to) {
1262 from->name = toName;
1263 continue;
1264 }
1265 to->merge(from);
1266 }
1267}
1268
1269// Visits all sections to assign incremental, non-overlapping RVAs and
1270// file offsets.
1271void Writer::assignAddresses() {
1272 sizeOfHeaders = dosStubSize + sizeof(PEMagic) + sizeof(coff_file_header) +
1273 sizeof(data_directory) * numberOfDataDirectory +
1274 sizeof(coff_section) * ctx.outputSections.size();
1275 sizeOfHeaders +=
1276 config->is64() ? sizeof(pe32plus_header) : sizeof(pe32_header);
1277 sizeOfHeaders = alignTo(sizeOfHeaders, config->fileAlign);
1278 fileSize = sizeOfHeaders;
1279
1280 // The first page is kept unmapped.
1281 uint64_t rva = alignTo(sizeOfHeaders, config->align);
1282
1283 for (OutputSection *sec : ctx.outputSections) {
1284 if (sec == relocSec)
1285 addBaserels();
1286 uint64_t rawSize = 0, virtualSize = 0;
1287 sec->header.VirtualAddress = rva;
1288
1289 // If /FUNCTIONPADMIN is used, functions are padded in order to create a
1290 // hotpatchable image.
1291 const bool isCodeSection =
1292 (sec->header.Characteristics & IMAGE_SCN_CNT_CODE) &&
1293 (sec->header.Characteristics & IMAGE_SCN_MEM_READ) &&
1294 (sec->header.Characteristics & IMAGE_SCN_MEM_EXECUTE);
1295 uint32_t padding = isCodeSection ? config->functionPadMin : 0;
1296
1297 for (Chunk *c : sec->chunks) {
1298 if (padding && c->isHotPatchable())
1299 virtualSize += padding;
1300 virtualSize = alignTo(virtualSize, c->getAlignment());
1301 c->setRVA(rva + virtualSize);
1302 virtualSize += c->getSize();
1303 if (c->hasData)
1304 rawSize = alignTo(virtualSize, config->fileAlign);
1305 }
1306 if (virtualSize > UINT32_MAX(4294967295U))
1307 error("section larger than 4 GiB: " + sec->name);
1308 sec->header.VirtualSize = virtualSize;
1309 sec->header.SizeOfRawData = rawSize;
1310 if (rawSize != 0)
1311 sec->header.PointerToRawData = fileSize;
1312 rva += alignTo(virtualSize, config->align);
1313 fileSize += alignTo(rawSize, config->fileAlign);
1314 }
1315 sizeOfImage = alignTo(rva, config->align);
1316
1317 // Assign addresses to sections in MergeChunks.
1318 for (MergeChunk *mc : ctx.mergeChunkInstances)
1319 if (mc)
1320 mc->assignSubsectionRVAs();
1321}
1322
1323template <typename PEHeaderTy> void Writer::writeHeader() {
1324 // Write DOS header. For backwards compatibility, the first part of a PE/COFF
1325 // executable consists of an MS-DOS MZ executable. If the executable is run
1326 // under DOS, that program gets run (usually to just print an error message).
1327 // When run under Windows, the loader looks at AddressOfNewExeHeader and uses
1328 // the PE header instead.
1329 uint8_t *buf = buffer->getBufferStart();
1330 auto *dos = reinterpret_cast<dos_header *>(buf);
1331 buf += sizeof(dos_header);
1332 dos->Magic[0] = 'M';
1333 dos->Magic[1] = 'Z';
1334 dos->UsedBytesInTheLastPage = dosStubSize % 512;
1335 dos->FileSizeInPages = divideCeil(dosStubSize, 512);
1336 dos->HeaderSizeInParagraphs = sizeof(dos_header) / 16;
1337
1338 dos->AddressOfRelocationTable = sizeof(dos_header);
1339 dos->AddressOfNewExeHeader = dosStubSize;
1340
1341 // Write DOS program.
1342 memcpy(buf, dosProgram, sizeof(dosProgram));
1343 buf += sizeof(dosProgram);
1344
1345 // Write PE magic
1346 memcpy(buf, PEMagic, sizeof(PEMagic));
1347 buf += sizeof(PEMagic);
1348
1349 // Write COFF header
1350 auto *coff = reinterpret_cast<coff_file_header *>(buf);
1351 buf += sizeof(*coff);
1352 coff->Machine = config->machine;
1353 coff->NumberOfSections = ctx.outputSections.size();
1354 coff->Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE;
1355 if (config->largeAddressAware)
1356 coff->Characteristics |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
1357 if (!config->is64())
1358 coff->Characteristics |= IMAGE_FILE_32BIT_MACHINE;
1359 if (config->dll)
1360 coff->Characteristics |= IMAGE_FILE_DLL;
1361 if (config->driverUponly)
1362 coff->Characteristics |= IMAGE_FILE_UP_SYSTEM_ONLY;
1363 if (!config->relocatable)
1364 coff->Characteristics |= IMAGE_FILE_RELOCS_STRIPPED;
1365 if (config->swaprunCD)
1366 coff->Characteristics |= IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP;
1367 if (config->swaprunNet)
1368 coff->Characteristics |= IMAGE_FILE_NET_RUN_FROM_SWAP;
1369 coff->SizeOfOptionalHeader =
1370 sizeof(PEHeaderTy) + sizeof(data_directory) * numberOfDataDirectory;
1371
1372 // Write PE header
1373 auto *pe = reinterpret_cast<PEHeaderTy *>(buf);
1374 buf += sizeof(*pe);
1375 pe->Magic = config->is64() ? PE32Header::PE32_PLUS : PE32Header::PE32;
1376
1377 // If {Major,Minor}LinkerVersion is left at 0.0, then for some
1378 // reason signing the resulting PE file with Authenticode produces a
1379 // signature that fails to validate on Windows 7 (but is OK on 10).
1380 // Set it to 14.0, which is what VS2015 outputs, and which avoids
1381 // that problem.
1382 pe->MajorLinkerVersion = 14;
1383 pe->MinorLinkerVersion = 0;
1384
1385 pe->ImageBase = config->imageBase;
1386 pe->SectionAlignment = config->align;
1387 pe->FileAlignment = config->fileAlign;
1388 pe->MajorImageVersion = config->majorImageVersion;
1389 pe->MinorImageVersion = config->minorImageVersion;
1390 pe->MajorOperatingSystemVersion = config->majorOSVersion;
1391 pe->MinorOperatingSystemVersion = config->minorOSVersion;
1392 pe->MajorSubsystemVersion = config->majorSubsystemVersion;
1393 pe->MinorSubsystemVersion = config->minorSubsystemVersion;
1394 pe->Subsystem = config->subsystem;
1395 pe->SizeOfImage = sizeOfImage;
1396 pe->SizeOfHeaders = sizeOfHeaders;
1397 if (!config->noEntry) {
1398 Defined *entry = cast<Defined>(config->entry);
1399 pe->AddressOfEntryPoint = entry->getRVA();
1400 // Pointer to thumb code must have the LSB set, so adjust it.
1401 if (config->machine == ARMNT)
1402 pe->AddressOfEntryPoint |= 1;
1403 }
1404 pe->SizeOfStackReserve = config->stackReserve;
1405 pe->SizeOfStackCommit = config->stackCommit;
1406 pe->SizeOfHeapReserve = config->heapReserve;
1407 pe->SizeOfHeapCommit = config->heapCommit;
1408 if (config->appContainer)
1409 pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_APPCONTAINER;
1410 if (config->driverWdm)
1411 pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER;
1412 if (config->dynamicBase)
1413 pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
1414 if (config->highEntropyVA)
1415 pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA;
1416 if (!config->allowBind)
1417 pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_BIND;
1418 if (config->nxCompat)
1419 pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
1420 if (!config->allowIsolation)
1421 pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION;
1422 if (config->guardCF != GuardCFLevel::Off)
1423 pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_GUARD_CF;
1424 if (config->integrityCheck)
1425 pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
1426 if (setNoSEHCharacteristic || config->noSEH)
1427 pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_SEH;
1428 if (config->terminalServerAware)
1429 pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE;
1430 pe->NumberOfRvaAndSize = numberOfDataDirectory;
1431 if (textSec->getVirtualSize()) {
1432 pe->BaseOfCode = textSec->getRVA();
1433 pe->SizeOfCode = textSec->getRawSize();
1434 }
1435 pe->SizeOfInitializedData = getSizeOfInitializedData();
1436
1437 // Write data directory
1438 auto *dir = reinterpret_cast<data_directory *>(buf);
1439 buf += sizeof(*dir) * numberOfDataDirectory;
1440 if (edataStart) {
1441 dir[EXPORT_TABLE].RelativeVirtualAddress = edataStart->getRVA();
1442 dir[EXPORT_TABLE].Size =
1443 edataEnd->getRVA() + edataEnd->getSize() - edataStart->getRVA();
1444 }
1445 if (importTableStart) {
1446 dir[IMPORT_TABLE].RelativeVirtualAddress = importTableStart->getRVA();
1447 dir[IMPORT_TABLE].Size = importTableSize;
1448 }
1449 if (iatStart) {
1450 dir[IAT].RelativeVirtualAddress = iatStart->getRVA();
1451 dir[IAT].Size = iatSize;
1452 }
1453 if (rsrcSec->getVirtualSize()) {
1454 dir[RESOURCE_TABLE].RelativeVirtualAddress = rsrcSec->getRVA();
1455 dir[RESOURCE_TABLE].Size = rsrcSec->getVirtualSize();
1456 }
1457 if (firstPdata) {
1458 dir[EXCEPTION_TABLE].RelativeVirtualAddress = firstPdata->getRVA();
1459 dir[EXCEPTION_TABLE].Size =
1460 lastPdata->getRVA() + lastPdata->getSize() - firstPdata->getRVA();
1461 }
1462 if (relocSec->getVirtualSize()) {
1463 dir[BASE_RELOCATION_TABLE].RelativeVirtualAddress = relocSec->getRVA();
1464 dir[BASE_RELOCATION_TABLE].Size = relocSec->getVirtualSize();
1465 }
1466 if (Symbol *sym = ctx.symtab.findUnderscore("_tls_used")) {
1467 if (Defined *b = dyn_cast<Defined>(sym)) {
1468 dir[TLS_TABLE].RelativeVirtualAddress = b->getRVA();
1469 dir[TLS_TABLE].Size = config->is64()
1470 ? sizeof(object::coff_tls_directory64)
1471 : sizeof(object::coff_tls_directory32);
1472 }
1473 }
1474 if (debugDirectory) {
1475 dir[DEBUG_DIRECTORY].RelativeVirtualAddress = debugDirectory->getRVA();
1476 dir[DEBUG_DIRECTORY].Size = debugDirectory->getSize();
1477 }
1478 if (Symbol *sym = ctx.symtab.findUnderscore("_load_config_used")) {
1479 if (auto *b = dyn_cast<DefinedRegular>(sym)) {
1480 SectionChunk *sc = b->getChunk();
1481 assert(b->getRVA() >= sc->getRVA())(static_cast <bool> (b->getRVA() >= sc->getRVA
()) ? void (0) : __assert_fail ("b->getRVA() >= sc->getRVA()"
, "lld/COFF/Writer.cpp", 1481, __extension__ __PRETTY_FUNCTION__
))
;
1482 uint64_t offsetInChunk = b->getRVA() - sc->getRVA();
1483 if (!sc->hasData || offsetInChunk + 4 > sc->getSize())
1484 fatal("_load_config_used is malformed");
1485
1486 ArrayRef<uint8_t> secContents = sc->getContents();
1487 uint32_t loadConfigSize =
1488 *reinterpret_cast<const ulittle32_t *>(&secContents[offsetInChunk]);
1489 if (offsetInChunk + loadConfigSize > sc->getSize())
1490 fatal("_load_config_used is too large");
1491 dir[LOAD_CONFIG_TABLE].RelativeVirtualAddress = b->getRVA();
1492 dir[LOAD_CONFIG_TABLE].Size = loadConfigSize;
1493 }
1494 }
1495 if (!delayIdata.empty()) {
1496 dir[DELAY_IMPORT_DESCRIPTOR].RelativeVirtualAddress =
1497 delayIdata.getDirRVA();
1498 dir[DELAY_IMPORT_DESCRIPTOR].Size = delayIdata.getDirSize();
1499 }
1500
1501 // Write section table
1502 for (OutputSection *sec : ctx.outputSections) {
1503 sec->writeHeaderTo(buf);
1504 buf += sizeof(coff_section);
1505 }
1506 sectionTable = ArrayRef<uint8_t>(
1507 buf - ctx.outputSections.size() * sizeof(coff_section), buf);
1508
1509 if (outputSymtab.empty() && strtab.empty())
1510 return;
1511
1512 coff->PointerToSymbolTable = pointerToSymbolTable;
1513 uint32_t numberOfSymbols = outputSymtab.size();
1514 coff->NumberOfSymbols = numberOfSymbols;
1515 auto *symbolTable = reinterpret_cast<coff_symbol16 *>(
1516 buffer->getBufferStart() + coff->PointerToSymbolTable);
1517 for (size_t i = 0; i != numberOfSymbols; ++i)
1518 symbolTable[i] = outputSymtab[i];
1519 // Create the string table, it follows immediately after the symbol table.
1520 // The first 4 bytes is length including itself.
1521 buf = reinterpret_cast<uint8_t *>(&symbolTable[numberOfSymbols]);
1522 write32le(buf, strtab.size() + 4);
1523 if (!strtab.empty())
1524 memcpy(buf + 4, strtab.data(), strtab.size());
1525}
1526
1527void Writer::openFile(StringRef path) {
1528 buffer = CHECK(check2((FileOutputBuffer::create(path, fileSize, FileOutputBuffer
::F_executable)), [&] { return toString("failed to open "
+ path); })
1529 FileOutputBuffer::create(path, fileSize, FileOutputBuffer::F_executable),check2((FileOutputBuffer::create(path, fileSize, FileOutputBuffer
::F_executable)), [&] { return toString("failed to open "
+ path); })
1530 "failed to open " + path)check2((FileOutputBuffer::create(path, fileSize, FileOutputBuffer
::F_executable)), [&] { return toString("failed to open "
+ path); })
;
1531}
1532
1533void Writer::createSEHTable() {
1534 SymbolRVASet handlers;
1535 for (ObjFile *file : ctx.objFileInstances) {
1536 if (!file->hasSafeSEH())
1537 error("/safeseh: " + file->getName() + " is not compatible with SEH");
1538 markSymbolsForRVATable(file, file->getSXDataChunks(), handlers);
1539 }
1540
1541 // Set the "no SEH" characteristic if there really were no handlers, or if
1542 // there is no load config object to point to the table of handlers.
1543 setNoSEHCharacteristic =
1544 handlers.empty() || !ctx.symtab.findUnderscore("_load_config_used");
1545
1546 maybeAddRVATable(std::move(handlers), "__safe_se_handler_table",
1547 "__safe_se_handler_count");
1548}
1549
1550// Add a symbol to an RVA set. Two symbols may have the same RVA, but an RVA set
1551// cannot contain duplicates. Therefore, the set is uniqued by Chunk and the
1552// symbol's offset into that Chunk.
1553static void addSymbolToRVASet(SymbolRVASet &rvaSet, Defined *s) {
1554 Chunk *c = s->getChunk();
1555 if (auto *sc = dyn_cast<SectionChunk>(c))
1556 c = sc->repl; // Look through ICF replacement.
1557 uint32_t off = s->getRVA() - (c ? c->getRVA() : 0);
1558 rvaSet.insert({c, off});
1559}
1560
1561// Given a symbol, add it to the GFIDs table if it is a live, defined, function
1562// symbol in an executable section.
1563static void maybeAddAddressTakenFunction(SymbolRVASet &addressTakenSyms,
1564 Symbol *s) {
1565 if (!s)
1566 return;
1567
1568 switch (s->kind()) {
1569 case Symbol::DefinedLocalImportKind:
1570 case Symbol::DefinedImportDataKind:
1571 // Defines an __imp_ pointer, so it is data, so it is ignored.
1572 break;
1573 case Symbol::DefinedCommonKind:
1574 // Common is always data, so it is ignored.
1575 break;
1576 case Symbol::DefinedAbsoluteKind:
1577 case Symbol::DefinedSyntheticKind:
1578 // Absolute is never code, synthetic generally isn't and usually isn't
1579 // determinable.
1580 break;
1581 case Symbol::LazyArchiveKind:
1582 case Symbol::LazyObjectKind:
1583 case Symbol::LazyDLLSymbolKind:
1584 case Symbol::UndefinedKind:
1585 // Undefined symbols resolve to zero, so they don't have an RVA. Lazy
1586 // symbols shouldn't have relocations.
1587 break;
1588
1589 case Symbol::DefinedImportThunkKind:
1590 // Thunks are always code, include them.
1591 addSymbolToRVASet(addressTakenSyms, cast<Defined>(s));
1592 break;
1593
1594 case Symbol::DefinedRegularKind: {
1595 // This is a regular, defined, symbol from a COFF file. Mark the symbol as
1596 // address taken if the symbol type is function and it's in an executable
1597 // section.
1598 auto *d = cast<DefinedRegular>(s);
1599 if (d->getCOFFSymbol().getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION) {
1600 SectionChunk *sc = dyn_cast<SectionChunk>(d->getChunk());
1601 if (sc && sc->live &&
1602 sc->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE)
1603 addSymbolToRVASet(addressTakenSyms, d);
1604 }
1605 break;
1606 }
1607 }
1608}
1609
1610// Visit all relocations from all section contributions of this object file and
1611// mark the relocation target as address-taken.
1612static void markSymbolsWithRelocations(ObjFile *file,
1613 SymbolRVASet &usedSymbols) {
1614 for (Chunk *c : file->getChunks()) {
1615 // We only care about live section chunks. Common chunks and other chunks
1616 // don't generally contain relocations.
1617 SectionChunk *sc = dyn_cast<SectionChunk>(c);
1618 if (!sc || !sc->live)
1619 continue;
1620
1621 for (const coff_relocation &reloc : sc->getRelocs()) {
1622 if (config->machine == I386 && reloc.Type == COFF::IMAGE_REL_I386_REL32)
1623 // Ignore relative relocations on x86. On x86_64 they can't be ignored
1624 // since they're also used to compute absolute addresses.
1625 continue;
1626
1627 Symbol *ref = sc->file->getSymbol(reloc.SymbolTableIndex);
1628 maybeAddAddressTakenFunction(usedSymbols, ref);
1629 }
1630 }
1631}
1632
1633// Create the guard function id table. This is a table of RVAs of all
1634// address-taken functions. It is sorted and uniqued, just like the safe SEH
1635// table.
1636void Writer::createGuardCFTables() {
1637 SymbolRVASet addressTakenSyms;
1638 SymbolRVASet giatsRVASet;
1639 std::vector<Symbol *> giatsSymbols;
1640 SymbolRVASet longJmpTargets;
1641 SymbolRVASet ehContTargets;
1642 for (ObjFile *file : ctx.objFileInstances) {
1643 // If the object was compiled with /guard:cf, the address taken symbols
1644 // are in .gfids$y sections, the longjmp targets are in .gljmp$y sections,
1645 // and ehcont targets are in .gehcont$y sections. If the object was not
1646 // compiled with /guard:cf, we assume there were no setjmp and ehcont
1647 // targets, and that all code symbols with relocations are possibly
1648 // address-taken.
1649 if (file->hasGuardCF()) {
1650 markSymbolsForRVATable(file, file->getGuardFidChunks(), addressTakenSyms);
1651 markSymbolsForRVATable(file, file->getGuardIATChunks(), giatsRVASet);
1652 getSymbolsFromSections(file, file->getGuardIATChunks(), giatsSymbols);
1653 markSymbolsForRVATable(file, file->getGuardLJmpChunks(), longJmpTargets);
1654 markSymbolsForRVATable(file, file->getGuardEHContChunks(), ehContTargets);
1655 } else {
1656 markSymbolsWithRelocations(file, addressTakenSyms);
1657 }
1658 }
1659
1660 // Mark the image entry as address-taken.
1661 if (config->entry)
1662 maybeAddAddressTakenFunction(addressTakenSyms, config->entry);
1663
1664 // Mark exported symbols in executable sections as address-taken.
1665 for (Export &e : config->exports)
1666 maybeAddAddressTakenFunction(addressTakenSyms, e.sym);
1667
1668 // For each entry in the .giats table, check if it has a corresponding load
1669 // thunk (e.g. because the DLL that defines it will be delay-loaded) and, if
1670 // so, add the load thunk to the address taken (.gfids) table.
1671 for (Symbol *s : giatsSymbols) {
1672 if (auto *di = dyn_cast<DefinedImportData>(s)) {
1673 if (di->loadThunkSym)
1674 addSymbolToRVASet(addressTakenSyms, di->loadThunkSym);
1675 }
1676 }
1677
1678 // Ensure sections referenced in the gfid table are 16-byte aligned.
1679 for (const ChunkAndOffset &c : addressTakenSyms)
1680 if (c.inputChunk->getAlignment() < 16)
1681 c.inputChunk->setAlignment(16);
1682
1683 maybeAddRVATable(std::move(addressTakenSyms), "__guard_fids_table",
1684 "__guard_fids_count");
1685
1686 // Add the Guard Address Taken IAT Entry Table (.giats).
1687 maybeAddRVATable(std::move(giatsRVASet), "__guard_iat_table",
1688 "__guard_iat_count");
1689
1690 // Add the longjmp target table unless the user told us not to.
1691 if (config->guardCF & GuardCFLevel::LongJmp)
1692 maybeAddRVATable(std::move(longJmpTargets), "__guard_longjmp_table",
1693 "__guard_longjmp_count");
1694
1695 // Add the ehcont target table unless the user told us not to.
1696 if (config->guardCF & GuardCFLevel::EHCont)
1697 maybeAddRVATable(std::move(ehContTargets), "__guard_eh_cont_table",
1698 "__guard_eh_cont_count", true);
1699
1700 // Set __guard_flags, which will be used in the load config to indicate that
1701 // /guard:cf was enabled.
1702 uint32_t guardFlags = uint32_t(coff_guard_flags::CFInstrumented) |
1703 uint32_t(coff_guard_flags::HasFidTable);
1704 if (config->guardCF & GuardCFLevel::LongJmp)
1705 guardFlags |= uint32_t(coff_guard_flags::HasLongJmpTable);
1706 if (config->guardCF & GuardCFLevel::EHCont)
1707 guardFlags |= uint32_t(coff_guard_flags::HasEHContTable);
1708 Symbol *flagSym = ctx.symtab.findUnderscore("__guard_flags");
1709 cast<DefinedAbsolute>(flagSym)->setVA(guardFlags);
1710}
1711
1712// Take a list of input sections containing symbol table indices and add those
1713// symbols to a vector. The challenge is that symbol RVAs are not known and
1714// depend on the table size, so we can't directly build a set of integers.
1715void Writer::getSymbolsFromSections(ObjFile *file,
1716 ArrayRef<SectionChunk *> symIdxChunks,
1717 std::vector<Symbol *> &symbols) {
1718 for (SectionChunk *c : symIdxChunks) {
1719 // Skip sections discarded by linker GC. This comes up when a .gfids section
1720 // is associated with something like a vtable and the vtable is discarded.
1721 // In this case, the associated gfids section is discarded, and we don't
1722 // mark the virtual member functions as address-taken by the vtable.
1723 if (!c->live)
1724 continue;
1725
1726 // Validate that the contents look like symbol table indices.
1727 ArrayRef<uint8_t> data = c->getContents();
1728 if (data.size() % 4 != 0) {
1729 warn("ignoring " + c->getSectionName() +
1730 " symbol table index section in object " + toString(file));
1731 continue;
1732 }
1733
1734 // Read each symbol table index and check if that symbol was included in the
1735 // final link. If so, add it to the vector of symbols.
1736 ArrayRef<ulittle32_t> symIndices(
1737 reinterpret_cast<const ulittle32_t *>(data.data()), data.size() / 4);
1738 ArrayRef<Symbol *> objSymbols = file->getSymbols();
1739 for (uint32_t symIndex : symIndices) {
1740 if (symIndex >= objSymbols.size()) {
1741 warn("ignoring invalid symbol table index in section " +
1742 c->getSectionName() + " in object " + toString(file));
1743 continue;
1744 }
1745 if (Symbol *s = objSymbols[symIndex]) {
1746 if (s->isLive())
1747 symbols.push_back(cast<Symbol>(s));
1748 }
1749 }
1750 }
1751}
1752
1753// Take a list of input sections containing symbol table indices and add those
1754// symbols to an RVA table.
1755void Writer::markSymbolsForRVATable(ObjFile *file,
1756 ArrayRef<SectionChunk *> symIdxChunks,
1757 SymbolRVASet &tableSymbols) {
1758 std::vector<Symbol *> syms;
1759 getSymbolsFromSections(file, symIdxChunks, syms);
1760
1761 for (Symbol *s : syms)
1762 addSymbolToRVASet(tableSymbols, cast<Defined>(s));
1763}
1764
1765// Replace the absolute table symbol with a synthetic symbol pointing to
1766// tableChunk so that we can emit base relocations for it and resolve section
1767// relative relocations.
1768void Writer::maybeAddRVATable(SymbolRVASet tableSymbols, StringRef tableSym,
1769 StringRef countSym, bool hasFlag) {
1770 if (tableSymbols.empty())
1771 return;
1772
1773 NonSectionChunk *tableChunk;
1774 if (hasFlag)
1775 tableChunk = make<RVAFlagTableChunk>(std::move(tableSymbols));
1776 else
1777 tableChunk = make<RVATableChunk>(std::move(tableSymbols));
1778 rdataSec->addChunk(tableChunk);
1779
1780 Symbol *t = ctx.symtab.findUnderscore(tableSym);
1781 Symbol *c = ctx.symtab.findUnderscore(countSym);
1782 replaceSymbol<DefinedSynthetic>(t, t->getName(), tableChunk);
1783 cast<DefinedAbsolute>(c)->setVA(tableChunk->getSize() / (hasFlag ? 5 : 4));
1784}
1785
1786// MinGW specific. Gather all relocations that are imported from a DLL even
1787// though the code didn't expect it to, produce the table that the runtime
1788// uses for fixing them up, and provide the synthetic symbols that the
1789// runtime uses for finding the table.
1790void Writer::createRuntimePseudoRelocs() {
1791 std::vector<RuntimePseudoReloc> rels;
1792
1793 for (Chunk *c : ctx.symtab.getChunks()) {
1794 auto *sc = dyn_cast<SectionChunk>(c);
1795 if (!sc || !sc->live)
1796 continue;
1797 sc->getRuntimePseudoRelocs(rels);
1798 }
1799
1800 if (!config->pseudoRelocs) {
1801 // Not writing any pseudo relocs; if some were needed, error out and
1802 // indicate what required them.
1803 for (const RuntimePseudoReloc &rpr : rels)
1804 error("automatic dllimport of " + rpr.sym->getName() + " in " +
1805 toString(rpr.target->file) + " requires pseudo relocations");
1806 return;
1807 }
1808
1809 if (!rels.empty())
1810 log("Writing " + Twine(rels.size()) + " runtime pseudo relocations");
1811 PseudoRelocTableChunk *table = make<PseudoRelocTableChunk>(rels);
1812 rdataSec->addChunk(table);
1813 EmptyChunk *endOfList = make<EmptyChunk>();
1814 rdataSec->addChunk(endOfList);
1815
1816 Symbol *headSym = ctx.symtab.findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST__");
1817 Symbol *endSym =
1818 ctx.symtab.findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST_END__");
1819 replaceSymbol<DefinedSynthetic>(headSym, headSym->getName(), table);
1820 replaceSymbol<DefinedSynthetic>(endSym, endSym->getName(), endOfList);
1821}
1822
1823// MinGW specific.
1824// The MinGW .ctors and .dtors lists have sentinels at each end;
1825// a (uintptr_t)-1 at the start and a (uintptr_t)0 at the end.
1826// There's a symbol pointing to the start sentinel pointer, __CTOR_LIST__
1827// and __DTOR_LIST__ respectively.
1828void Writer::insertCtorDtorSymbols() {
1829 AbsolutePointerChunk *ctorListHead = make<AbsolutePointerChunk>(-1);
1830 AbsolutePointerChunk *ctorListEnd = make<AbsolutePointerChunk>(0);
1831 AbsolutePointerChunk *dtorListHead = make<AbsolutePointerChunk>(-1);
1832 AbsolutePointerChunk *dtorListEnd = make<AbsolutePointerChunk>(0);
1833 ctorsSec->insertChunkAtStart(ctorListHead);
1834 ctorsSec->addChunk(ctorListEnd);
1835 dtorsSec->insertChunkAtStart(dtorListHead);
1836 dtorsSec->addChunk(dtorListEnd);
1837
1838 Symbol *ctorListSym = ctx.symtab.findUnderscore("__CTOR_LIST__");
1839 Symbol *dtorListSym = ctx.symtab.findUnderscore("__DTOR_LIST__");
1840 replaceSymbol<DefinedSynthetic>(ctorListSym, ctorListSym->getName(),
1841 ctorListHead);
1842 replaceSymbol<DefinedSynthetic>(dtorListSym, dtorListSym->getName(),
1843 dtorListHead);
1844}
1845
1846// Handles /section options to allow users to overwrite
1847// section attributes.
1848void Writer::setSectionPermissions() {
1849 for (auto &p : config->section) {
1850 StringRef name = p.first;
1851 uint32_t perm = p.second;
1852 for (OutputSection *sec : ctx.outputSections)
1853 if (sec->name == name)
1854 sec->setPermissions(perm);
1855 }
1856}
1857
1858// Write section contents to a mmap'ed file.
1859void Writer::writeSections() {
1860 // Record the number of sections to apply section index relocations
1861 // against absolute symbols. See applySecIdx in Chunks.cpp..
1862 DefinedAbsolute::numOutputSections = ctx.outputSections.size();
1863
1864 uint8_t *buf = buffer->getBufferStart();
1865 for (OutputSection *sec : ctx.outputSections) {
1866 uint8_t *secBuf = buf + sec->getFileOff();
1867 // Fill gaps between functions in .text with INT3 instructions
1868 // instead of leaving as NUL bytes (which can be interpreted as
1869 // ADD instructions).
1870 if (sec->header.Characteristics & IMAGE_SCN_CNT_CODE)
1871 memset(secBuf, 0xCC, sec->getRawSize());
1872 parallelForEach(sec->chunks, [&](Chunk *c) {
1873 c->writeTo(secBuf + c->getRVA() - sec->getRVA());
1874 });
1875 }
1876}
1877
1878void Writer::writeBuildId() {
1879 // There are two important parts to the build ID.
1880 // 1) If building with debug info, the COFF debug directory contains a
1881 // timestamp as well as a Guid and Age of the PDB.
1882 // 2) In all cases, the PE COFF file header also contains a timestamp.
1883 // For reproducibility, instead of a timestamp we want to use a hash of the
1884 // PE contents.
1885 if (config->debug) {
1886 assert(buildId && "BuildId is not set!")(static_cast <bool> (buildId && "BuildId is not set!"
) ? void (0) : __assert_fail ("buildId && \"BuildId is not set!\""
, "lld/COFF/Writer.cpp", 1886, __extension__ __PRETTY_FUNCTION__
))
;
1887 // BuildId->BuildId was filled in when the PDB was written.
1888 }
1889
1890 // At this point the only fields in the COFF file which remain unset are the
1891 // "timestamp" in the COFF file header, and the ones in the coff debug
1892 // directory. Now we can hash the file and write that hash to the various
1893 // timestamp fields in the file.
1894 StringRef outputFileData(
1895 reinterpret_cast<const char *>(buffer->getBufferStart()),
1896 buffer->getBufferSize());
1897
1898 uint32_t timestamp = config->timestamp;
1899 uint64_t hash = 0;
1900 bool generateSyntheticBuildId =
1901 config->mingw && config->debug && config->pdbPath.empty();
1902
1903 if (config->repro || generateSyntheticBuildId)
1904 hash = xxHash64(outputFileData);
1905
1906 if (config->repro)
1907 timestamp = static_cast<uint32_t>(hash);
1908
1909 if (generateSyntheticBuildId) {
1910 // For MinGW builds without a PDB file, we still generate a build id
1911 // to allow associating a crash dump to the executable.
1912 buildId->buildId->PDB70.CVSignature = OMF::Signature::PDB70;
1913 buildId->buildId->PDB70.Age = 1;
1914 memcpy(buildId->buildId->PDB70.Signature, &hash, 8);
1915 // xxhash only gives us 8 bytes, so put some fixed data in the other half.
1916 memcpy(&buildId->buildId->PDB70.Signature[8], "LLD PDB.", 8);
1917 }
1918
1919 if (debugDirectory)
1920 debugDirectory->setTimeDateStamp(timestamp);
1921
1922 uint8_t *buf = buffer->getBufferStart();
1923 buf += dosStubSize + sizeof(PEMagic);
1924 object::coff_file_header *coffHeader =
1925 reinterpret_cast<coff_file_header *>(buf);
1926 coffHeader->TimeDateStamp = timestamp;
1927}
1928
1929// Sort .pdata section contents according to PE/COFF spec 5.5.
1930void Writer::sortExceptionTable() {
1931 if (!firstPdata)
1932 return;
1933 // We assume .pdata contains function table entries only.
1934 auto bufAddr = [&](Chunk *c) {
1935 OutputSection *os = ctx.getOutputSection(c);
1936 return buffer->getBufferStart() + os->getFileOff() + c->getRVA() -
1937 os->getRVA();
1938 };
1939 uint8_t *begin = bufAddr(firstPdata);
1940 uint8_t *end = bufAddr(lastPdata) + lastPdata->getSize();
1941 if (config->machine == AMD64) {
1942 struct Entry { ulittle32_t begin, end, unwind; };
1943 if ((end - begin) % sizeof(Entry) != 0) {
1944 fatal("unexpected .pdata size: " + Twine(end - begin) +
1945 " is not a multiple of " + Twine(sizeof(Entry)));
1946 }
1947 parallelSort(
1948 MutableArrayRef<Entry>((Entry *)begin, (Entry *)end),
1949 [](const Entry &a, const Entry &b) { return a.begin < b.begin; });
1950 return;
1951 }
1952 if (config->machine == ARMNT || config->machine == ARM64) {
1953 struct Entry { ulittle32_t begin, unwind; };
1954 if ((end - begin) % sizeof(Entry) != 0) {
1955 fatal("unexpected .pdata size: " + Twine(end - begin) +
1956 " is not a multiple of " + Twine(sizeof(Entry)));
1957 }
1958 parallelSort(
1959 MutableArrayRef<Entry>((Entry *)begin, (Entry *)end),
1960 [](const Entry &a, const Entry &b) { return a.begin < b.begin; });
1961 return;
1962 }
1963 lld::errs() << "warning: don't know how to handle .pdata.\n";
1964}
1965
1966// The CRT section contains, among other things, the array of function
1967// pointers that initialize every global variable that is not trivially
1968// constructed. The CRT calls them one after the other prior to invoking
1969// main().
1970//
1971// As per C++ spec, 3.6.2/2.3,
1972// "Variables with ordered initialization defined within a single
1973// translation unit shall be initialized in the order of their definitions
1974// in the translation unit"
1975//
1976// It is therefore critical to sort the chunks containing the function
1977// pointers in the order that they are listed in the object file (top to
1978// bottom), otherwise global objects might not be initialized in the
1979// correct order.
1980void Writer::sortCRTSectionChunks(std::vector<Chunk *> &chunks) {
1981 auto sectionChunkOrder = [](const Chunk *a, const Chunk *b) {
1982 auto sa = dyn_cast<SectionChunk>(a);
1983 auto sb = dyn_cast<SectionChunk>(b);
1984 assert(sa && sb && "Non-section chunks in CRT section!")(static_cast <bool> (sa && sb && "Non-section chunks in CRT section!"
) ? void (0) : __assert_fail ("sa && sb && \"Non-section chunks in CRT section!\""
, "lld/COFF/Writer.cpp", 1984, __extension__ __PRETTY_FUNCTION__
))
;
1985
1986 StringRef sAObj = sa->file->mb.getBufferIdentifier();
1987 StringRef sBObj = sb->file->mb.getBufferIdentifier();
1988
1989 return sAObj == sBObj && sa->getSectionNumber() < sb->getSectionNumber();
1990 };
1991 llvm::stable_sort(chunks, sectionChunkOrder);
1992
1993 if (config->verbose) {
1994 for (auto &c : chunks) {
1995 auto sc = dyn_cast<SectionChunk>(c);
1996 log(" " + sc->file->mb.getBufferIdentifier().str() +
1997 ", SectionID: " + Twine(sc->getSectionNumber()));
1998 }
1999 }
2000}
2001
2002OutputSection *Writer::findSection(StringRef name) {
2003 for (OutputSection *sec : ctx.outputSections)
2004 if (sec->name == name)
2005 return sec;
2006 return nullptr;
2007}
2008
2009uint32_t Writer::getSizeOfInitializedData() {
2010 uint32_t res = 0;
2011 for (OutputSection *s : ctx.outputSections)
2012 if (s->header.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
2013 res += s->getRawSize();
2014 return res;
2015}
2016
2017// Add base relocations to .reloc section.
2018void Writer::addBaserels() {
2019 if (!config->relocatable)
2020 return;
2021 relocSec->chunks.clear();
2022 std::vector<Baserel> v;
2023 for (OutputSection *sec : ctx.outputSections) {
2024 if (sec->header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE)
2025 continue;
2026 // Collect all locations for base relocations.
2027 for (Chunk *c : sec->chunks)
2028 c->getBaserels(&v);
2029 // Add the addresses to .reloc section.
2030 if (!v.empty())
2031 addBaserelBlocks(v);
2032 v.clear();
2033 }
2034}
2035
2036// Add addresses to .reloc section. Note that addresses are grouped by page.
2037void Writer::addBaserelBlocks(std::vector<Baserel> &v) {
2038 const uint32_t mask = ~uint32_t(pageSize - 1);
2039 uint32_t page = v[0].rva & mask;
2040 size_t i = 0, j = 1;
2041 for (size_t e = v.size(); j < e; ++j) {
2042 uint32_t p = v[j].rva & mask;
2043 if (p == page)
2044 continue;
2045 relocSec->addChunk(make<BaserelChunk>(page, &v[i], &v[0] + j));
2046 i = j;
2047 page = p;
2048 }
2049 if (i == j)
2050 return;
2051 relocSec->addChunk(make<BaserelChunk>(page, &v[i], &v[0] + j));
2052}
2053
2054PartialSection *Writer::createPartialSection(StringRef name,
2055 uint32_t outChars) {
2056 PartialSection *&pSec = partialSections[{name, outChars}];
2057 if (pSec)
2058 return pSec;
2059 pSec = make<PartialSection>(name, outChars);
2060 return pSec;
2061}
2062
2063PartialSection *Writer::findPartialSection(StringRef name, uint32_t outChars) {
2064 auto it = partialSections.find({name, outChars});
2065 if (it != partialSections.end())
2066 return it->second;
2067 return nullptr;
2068}
2069
2070void Writer::fixTlsAlignment() {
2071 Defined *tlsSym =
2072 dyn_cast_or_null<Defined>(ctx.symtab.findUnderscore("_tls_used"));
2073 if (!tlsSym)
2074 return;
2075
2076 OutputSection *sec = ctx.getOutputSection(tlsSym->getChunk());
2077 assert(sec && tlsSym->getRVA() >= sec->getRVA() &&(static_cast <bool> (sec && tlsSym->getRVA()
>= sec->getRVA() && "no output section for _tls_used"
) ? void (0) : __assert_fail ("sec && tlsSym->getRVA() >= sec->getRVA() && \"no output section for _tls_used\""
, "lld/COFF/Writer.cpp", 2078, __extension__ __PRETTY_FUNCTION__
))
2078 "no output section for _tls_used")(static_cast <bool> (sec && tlsSym->getRVA()
>= sec->getRVA() && "no output section for _tls_used"
) ? void (0) : __assert_fail ("sec && tlsSym->getRVA() >= sec->getRVA() && \"no output section for _tls_used\""
, "lld/COFF/Writer.cpp", 2078, __extension__ __PRETTY_FUNCTION__
))
;
2079
2080 uint8_t *secBuf = buffer->getBufferStart() + sec->getFileOff();
2081 uint64_t tlsOffset = tlsSym->getRVA() - sec->getRVA();
2082 uint64_t directorySize = config->is64()
2083 ? sizeof(object::coff_tls_directory64)
2084 : sizeof(object::coff_tls_directory32);
2085
2086 if (tlsOffset + directorySize > sec->getRawSize())
2087 fatal("_tls_used sym is malformed");
2088
2089 if (config->is64()) {
2090 object::coff_tls_directory64 *tlsDir =
2091 reinterpret_cast<object::coff_tls_directory64 *>(&secBuf[tlsOffset]);
2092 tlsDir->setAlignment(tlsAlignment);
2093 } else {
2094 object::coff_tls_directory32 *tlsDir =
2095 reinterpret_cast<object::coff_tls_directory32 *>(&secBuf[tlsOffset]);
2096 tlsDir->setAlignment(tlsAlignment);
2097 }
2098}