1 //===- llvm/MC/WinCOFFObjectWriter.cpp ------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains an implementation of a Win32 COFF object file writer.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "llvm/ADT/DenseMap.h"
14 #include "llvm/ADT/DenseSet.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/SmallString.h"
17 #include "llvm/ADT/SmallVector.h"
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/ADT/Twine.h"
20 #include "llvm/BinaryFormat/COFF.h"
21 #include "llvm/MC/MCAsmLayout.h"
22 #include "llvm/MC/MCAssembler.h"
23 #include "llvm/MC/MCContext.h"
24 #include "llvm/MC/MCExpr.h"
25 #include "llvm/MC/MCFixup.h"
26 #include "llvm/MC/MCFragment.h"
27 #include "llvm/MC/MCObjectWriter.h"
28 #include "llvm/MC/MCSection.h"
29 #include "llvm/MC/MCSectionCOFF.h"
30 #include "llvm/MC/MCSymbol.h"
31 #include "llvm/MC/MCSymbolCOFF.h"
32 #include "llvm/MC/MCValue.h"
33 #include "llvm/MC/MCWinCOFFObjectWriter.h"
34 #include "llvm/MC/StringTableBuilder.h"
35 #include "llvm/Support/CRC.h"
36 #include "llvm/Support/Casting.h"
37 #include "llvm/Support/EndianStream.h"
38 #include "llvm/Support/ErrorHandling.h"
39 #include "llvm/Support/LEB128.h"
40 #include "llvm/Support/MathExtras.h"
41 #include "llvm/Support/raw_ostream.h"
42 #include <algorithm>
43 #include <cassert>
44 #include <cstddef>
45 #include <cstdint>
46 #include <cstring>
47 #include <ctime>
48 #include <memory>
49 #include <string>
50 #include <vector>
51
52 using namespace llvm;
53 using llvm::support::endian::write32le;
54
55 #define DEBUG_TYPE "WinCOFFObjectWriter"
56
57 namespace {
58
59 using name = SmallString<COFF::NameSize>;
60
61 enum AuxiliaryType {
62 ATWeakExternal,
63 ATFile,
64 ATSectionDefinition
65 };
66
67 struct AuxSymbol {
68 AuxiliaryType AuxType;
69 COFF::Auxiliary Aux;
70 };
71
72 class COFFSection;
73
74 class COFFSymbol {
75 public:
76 COFF::symbol Data = {};
77
78 using AuxiliarySymbols = SmallVector<AuxSymbol, 1>;
79
80 name Name;
81 int Index;
82 AuxiliarySymbols Aux;
83 COFFSymbol *Other = nullptr;
84 COFFSection *Section = nullptr;
85 int Relocations = 0;
86 const MCSymbol *MC = nullptr;
87
COFFSymbol(StringRef Name)88 COFFSymbol(StringRef Name) : Name(Name) {}
89
90 void set_name_offset(uint32_t Offset);
91
getIndex() const92 int64_t getIndex() const { return Index; }
setIndex(int Value)93 void setIndex(int Value) {
94 Index = Value;
95 if (MC)
96 MC->setIndex(static_cast<uint32_t>(Value));
97 }
98 };
99
100 // This class contains staging data for a COFF relocation entry.
101 struct COFFRelocation {
102 COFF::relocation Data;
103 COFFSymbol *Symb = nullptr;
104
105 COFFRelocation() = default;
106
size__anon99adfaa70111::COFFRelocation107 static size_t size() { return COFF::RelocationSize; }
108 };
109
110 using relocations = std::vector<COFFRelocation>;
111
112 class COFFSection {
113 public:
114 COFF::section Header = {};
115
116 std::string Name;
117 int Number;
118 MCSectionCOFF const *MCSection = nullptr;
119 COFFSymbol *Symbol = nullptr;
120 relocations Relocations;
121
COFFSection(StringRef Name)122 COFFSection(StringRef Name) : Name(std::string(Name)) {}
123 };
124
125 class WinCOFFObjectWriter : public MCObjectWriter {
126 public:
127 support::endian::Writer W;
128
129 using symbols = std::vector<std::unique_ptr<COFFSymbol>>;
130 using sections = std::vector<std::unique_ptr<COFFSection>>;
131
132 using symbol_map = DenseMap<MCSymbol const *, COFFSymbol *>;
133 using section_map = DenseMap<MCSection const *, COFFSection *>;
134
135 using symbol_list = DenseSet<COFFSymbol *>;
136
137 std::unique_ptr<MCWinCOFFObjectTargetWriter> TargetObjectWriter;
138
139 // Root level file contents.
140 COFF::header Header = {};
141 sections Sections;
142 symbols Symbols;
143 StringTableBuilder Strings{StringTableBuilder::WinCOFF};
144
145 // Maps used during object file creation.
146 section_map SectionMap;
147 symbol_map SymbolMap;
148
149 symbol_list WeakDefaults;
150
151 bool UseBigObj;
152
153 bool EmitAddrsigSection = false;
154 MCSectionCOFF *AddrsigSection;
155 std::vector<const MCSymbol *> AddrsigSyms;
156
157 MCSectionCOFF *CGProfileSection = nullptr;
158
159 WinCOFFObjectWriter(std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW,
160 raw_pwrite_stream &OS);
161
reset()162 void reset() override {
163 memset(&Header, 0, sizeof(Header));
164 Header.Machine = TargetObjectWriter->getMachine();
165 Sections.clear();
166 Symbols.clear();
167 Strings.clear();
168 SectionMap.clear();
169 SymbolMap.clear();
170 MCObjectWriter::reset();
171 }
172
173 COFFSymbol *createSymbol(StringRef Name);
174 COFFSymbol *GetOrCreateCOFFSymbol(const MCSymbol *Symbol);
175 COFFSection *createSection(StringRef Name);
176
177 void defineSection(MCSectionCOFF const &Sec);
178
179 COFFSymbol *getLinkedSymbol(const MCSymbol &Symbol);
180 void DefineSymbol(const MCSymbol &Symbol, MCAssembler &Assembler,
181 const MCAsmLayout &Layout);
182
183 void SetSymbolName(COFFSymbol &S);
184 void SetSectionName(COFFSection &S);
185
186 bool IsPhysicalSection(COFFSection *S);
187
188 // Entity writing methods.
189
190 void WriteFileHeader(const COFF::header &Header);
191 void WriteSymbol(const COFFSymbol &S);
192 void WriteAuxiliarySymbols(const COFFSymbol::AuxiliarySymbols &S);
193 void writeSectionHeaders();
194 void WriteRelocation(const COFF::relocation &R);
195 uint32_t writeSectionContents(MCAssembler &Asm, const MCAsmLayout &Layout,
196 const MCSection &MCSec);
197 void writeSection(MCAssembler &Asm, const MCAsmLayout &Layout,
198 const COFFSection &Sec, const MCSection &MCSec);
199
200 // MCObjectWriter interface implementation.
201
202 void executePostLayoutBinding(MCAssembler &Asm,
203 const MCAsmLayout &Layout) override;
204
205 bool isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler &Asm,
206 const MCSymbol &SymA,
207 const MCFragment &FB, bool InSet,
208 bool IsPCRel) const override;
209
210 void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
211 const MCFragment *Fragment, const MCFixup &Fixup,
212 MCValue Target, uint64_t &FixedValue) override;
213
214 void createFileSymbols(MCAssembler &Asm);
215 void setWeakDefaultNames();
216 void assignSectionNumbers();
217 void assignFileOffsets(MCAssembler &Asm, const MCAsmLayout &Layout);
218
emitAddrsigSection()219 void emitAddrsigSection() override { EmitAddrsigSection = true; }
addAddrsigSymbol(const MCSymbol * Sym)220 void addAddrsigSymbol(const MCSymbol *Sym) override {
221 AddrsigSyms.push_back(Sym);
222 }
223
224 uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
225 };
226
227 } // end anonymous namespace
228
229 //------------------------------------------------------------------------------
230 // Symbol class implementation
231
232 // In the case that the name does not fit within 8 bytes, the offset
233 // into the string table is stored in the last 4 bytes instead, leaving
234 // the first 4 bytes as 0.
set_name_offset(uint32_t Offset)235 void COFFSymbol::set_name_offset(uint32_t Offset) {
236 write32le(Data.Name + 0, 0);
237 write32le(Data.Name + 4, Offset);
238 }
239
240 //------------------------------------------------------------------------------
241 // WinCOFFObjectWriter class implementation
242
WinCOFFObjectWriter(std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW,raw_pwrite_stream & OS)243 WinCOFFObjectWriter::WinCOFFObjectWriter(
244 std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS)
245 : W(OS, support::little), TargetObjectWriter(std::move(MOTW)) {
246 Header.Machine = TargetObjectWriter->getMachine();
247 }
248
createSymbol(StringRef Name)249 COFFSymbol *WinCOFFObjectWriter::createSymbol(StringRef Name) {
250 Symbols.push_back(std::make_unique<COFFSymbol>(Name));
251 return Symbols.back().get();
252 }
253
GetOrCreateCOFFSymbol(const MCSymbol * Symbol)254 COFFSymbol *WinCOFFObjectWriter::GetOrCreateCOFFSymbol(const MCSymbol *Symbol) {
255 COFFSymbol *&Ret = SymbolMap[Symbol];
256 if (!Ret)
257 Ret = createSymbol(Symbol->getName());
258 return Ret;
259 }
260
createSection(StringRef Name)261 COFFSection *WinCOFFObjectWriter::createSection(StringRef Name) {
262 Sections.emplace_back(std::make_unique<COFFSection>(Name));
263 return Sections.back().get();
264 }
265
getAlignment(const MCSectionCOFF & Sec)266 static uint32_t getAlignment(const MCSectionCOFF &Sec) {
267 switch (Sec.getAlignment()) {
268 case 1:
269 return COFF::IMAGE_SCN_ALIGN_1BYTES;
270 case 2:
271 return COFF::IMAGE_SCN_ALIGN_2BYTES;
272 case 4:
273 return COFF::IMAGE_SCN_ALIGN_4BYTES;
274 case 8:
275 return COFF::IMAGE_SCN_ALIGN_8BYTES;
276 case 16:
277 return COFF::IMAGE_SCN_ALIGN_16BYTES;
278 case 32:
279 return COFF::IMAGE_SCN_ALIGN_32BYTES;
280 case 64:
281 return COFF::IMAGE_SCN_ALIGN_64BYTES;
282 case 128:
283 return COFF::IMAGE_SCN_ALIGN_128BYTES;
284 case 256:
285 return COFF::IMAGE_SCN_ALIGN_256BYTES;
286 case 512:
287 return COFF::IMAGE_SCN_ALIGN_512BYTES;
288 case 1024:
289 return COFF::IMAGE_SCN_ALIGN_1024BYTES;
290 case 2048:
291 return COFF::IMAGE_SCN_ALIGN_2048BYTES;
292 case 4096:
293 return COFF::IMAGE_SCN_ALIGN_4096BYTES;
294 case 8192:
295 return COFF::IMAGE_SCN_ALIGN_8192BYTES;
296 }
297 llvm_unreachable("unsupported section alignment");
298 }
299
300 /// This function takes a section data object from the assembler
301 /// and creates the associated COFF section staging object.
defineSection(const MCSectionCOFF & MCSec)302 void WinCOFFObjectWriter::defineSection(const MCSectionCOFF &MCSec) {
303 COFFSection *Section = createSection(MCSec.getName());
304 COFFSymbol *Symbol = createSymbol(MCSec.getName());
305 Section->Symbol = Symbol;
306 Symbol->Section = Section;
307 Symbol->Data.StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
308
309 // Create a COMDAT symbol if needed.
310 if (MCSec.getSelection() != COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
311 if (const MCSymbol *S = MCSec.getCOMDATSymbol()) {
312 COFFSymbol *COMDATSymbol = GetOrCreateCOFFSymbol(S);
313 if (COMDATSymbol->Section)
314 report_fatal_error("two sections have the same comdat");
315 COMDATSymbol->Section = Section;
316 }
317 }
318
319 // In this case the auxiliary symbol is a Section Definition.
320 Symbol->Aux.resize(1);
321 Symbol->Aux[0] = {};
322 Symbol->Aux[0].AuxType = ATSectionDefinition;
323 Symbol->Aux[0].Aux.SectionDefinition.Selection = MCSec.getSelection();
324
325 // Set section alignment.
326 Section->Header.Characteristics = MCSec.getCharacteristics();
327 Section->Header.Characteristics |= getAlignment(MCSec);
328
329 // Bind internal COFF section to MC section.
330 Section->MCSection = &MCSec;
331 SectionMap[&MCSec] = Section;
332 }
333
getSymbolValue(const MCSymbol & Symbol,const MCAsmLayout & Layout)334 static uint64_t getSymbolValue(const MCSymbol &Symbol,
335 const MCAsmLayout &Layout) {
336 if (Symbol.isCommon() && Symbol.isExternal())
337 return Symbol.getCommonSize();
338
339 uint64_t Res;
340 if (!Layout.getSymbolOffset(Symbol, Res))
341 return 0;
342
343 return Res;
344 }
345
getLinkedSymbol(const MCSymbol & Symbol)346 COFFSymbol *WinCOFFObjectWriter::getLinkedSymbol(const MCSymbol &Symbol) {
347 if (!Symbol.isVariable())
348 return nullptr;
349
350 const MCSymbolRefExpr *SymRef =
351 dyn_cast<MCSymbolRefExpr>(Symbol.getVariableValue());
352 if (!SymRef)
353 return nullptr;
354
355 const MCSymbol &Aliasee = SymRef->getSymbol();
356 if (Aliasee.isUndefined() || Aliasee.isExternal())
357 return GetOrCreateCOFFSymbol(&Aliasee);
358 else
359 return nullptr;
360 }
361
362 /// This function takes a symbol data object from the assembler
363 /// and creates the associated COFF symbol staging object.
DefineSymbol(const MCSymbol & MCSym,MCAssembler & Assembler,const MCAsmLayout & Layout)364 void WinCOFFObjectWriter::DefineSymbol(const MCSymbol &MCSym,
365 MCAssembler &Assembler,
366 const MCAsmLayout &Layout) {
367 COFFSymbol *Sym = GetOrCreateCOFFSymbol(&MCSym);
368 const MCSymbol *Base = Layout.getBaseSymbol(MCSym);
369 COFFSection *Sec = nullptr;
370 if (Base && Base->getFragment()) {
371 Sec = SectionMap[Base->getFragment()->getParent()];
372 if (Sym->Section && Sym->Section != Sec)
373 report_fatal_error("conflicting sections for symbol");
374 }
375
376 COFFSymbol *Local = nullptr;
377 if (cast<MCSymbolCOFF>(MCSym).isWeakExternal()) {
378 Sym->Data.StorageClass = COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL;
379 Sym->Section = nullptr;
380
381 COFFSymbol *WeakDefault = getLinkedSymbol(MCSym);
382 if (!WeakDefault) {
383 std::string WeakName = (".weak." + MCSym.getName() + ".default").str();
384 WeakDefault = createSymbol(WeakName);
385 if (!Sec)
386 WeakDefault->Data.SectionNumber = COFF::IMAGE_SYM_ABSOLUTE;
387 else
388 WeakDefault->Section = Sec;
389 WeakDefaults.insert(WeakDefault);
390 Local = WeakDefault;
391 }
392
393 Sym->Other = WeakDefault;
394
395 // Setup the Weak External auxiliary symbol.
396 Sym->Aux.resize(1);
397 memset(&Sym->Aux[0], 0, sizeof(Sym->Aux[0]));
398 Sym->Aux[0].AuxType = ATWeakExternal;
399 Sym->Aux[0].Aux.WeakExternal.TagIndex = 0;
400 Sym->Aux[0].Aux.WeakExternal.Characteristics =
401 COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS;
402 } else {
403 if (!Base)
404 Sym->Data.SectionNumber = COFF::IMAGE_SYM_ABSOLUTE;
405 else
406 Sym->Section = Sec;
407 Local = Sym;
408 }
409
410 if (Local) {
411 Local->Data.Value = getSymbolValue(MCSym, Layout);
412
413 const MCSymbolCOFF &SymbolCOFF = cast<MCSymbolCOFF>(MCSym);
414 Local->Data.Type = SymbolCOFF.getType();
415 Local->Data.StorageClass = SymbolCOFF.getClass();
416
417 // If no storage class was specified in the streamer, define it here.
418 if (Local->Data.StorageClass == COFF::IMAGE_SYM_CLASS_NULL) {
419 bool IsExternal = MCSym.isExternal() ||
420 (!MCSym.getFragment() && !MCSym.isVariable());
421
422 Local->Data.StorageClass = IsExternal ? COFF::IMAGE_SYM_CLASS_EXTERNAL
423 : COFF::IMAGE_SYM_CLASS_STATIC;
424 }
425 }
426
427 Sym->MC = &MCSym;
428 }
429
430 // Maximum offsets for different string table entry encodings.
431 enum : unsigned { Max7DecimalOffset = 9999999U };
432 enum : uint64_t { MaxBase64Offset = 0xFFFFFFFFFULL }; // 64^6, including 0
433
434 // Encode a string table entry offset in base 64, padded to 6 chars, and
435 // prefixed with a double slash: '//AAAAAA', '//AAAAAB', ...
436 // Buffer must be at least 8 bytes large. No terminating null appended.
encodeBase64StringEntry(char * Buffer,uint64_t Value)437 static void encodeBase64StringEntry(char *Buffer, uint64_t Value) {
438 assert(Value > Max7DecimalOffset && Value <= MaxBase64Offset &&
439 "Illegal section name encoding for value");
440
441 static const char Alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
442 "abcdefghijklmnopqrstuvwxyz"
443 "0123456789+/";
444
445 Buffer[0] = '/';
446 Buffer[1] = '/';
447
448 char *Ptr = Buffer + 7;
449 for (unsigned i = 0; i < 6; ++i) {
450 unsigned Rem = Value % 64;
451 Value /= 64;
452 *(Ptr--) = Alphabet[Rem];
453 }
454 }
455
SetSectionName(COFFSection & S)456 void WinCOFFObjectWriter::SetSectionName(COFFSection &S) {
457 if (S.Name.size() <= COFF::NameSize) {
458 std::memcpy(S.Header.Name, S.Name.c_str(), S.Name.size());
459 return;
460 }
461
462 uint64_t StringTableEntry = Strings.getOffset(S.Name);
463 if (StringTableEntry <= Max7DecimalOffset) {
464 SmallVector<char, COFF::NameSize> Buffer;
465 Twine('/').concat(Twine(StringTableEntry)).toVector(Buffer);
466 assert(Buffer.size() <= COFF::NameSize && Buffer.size() >= 2);
467 std::memcpy(S.Header.Name, Buffer.data(), Buffer.size());
468 return;
469 }
470 if (StringTableEntry <= MaxBase64Offset) {
471 // Starting with 10,000,000, offsets are encoded as base64.
472 encodeBase64StringEntry(S.Header.Name, StringTableEntry);
473 return;
474 }
475 report_fatal_error("COFF string table is greater than 64 GB.");
476 }
477
SetSymbolName(COFFSymbol & S)478 void WinCOFFObjectWriter::SetSymbolName(COFFSymbol &S) {
479 if (S.Name.size() > COFF::NameSize)
480 S.set_name_offset(Strings.getOffset(S.Name));
481 else
482 std::memcpy(S.Data.Name, S.Name.c_str(), S.Name.size());
483 }
484
IsPhysicalSection(COFFSection * S)485 bool WinCOFFObjectWriter::IsPhysicalSection(COFFSection *S) {
486 return (S->Header.Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) ==
487 0;
488 }
489
490 //------------------------------------------------------------------------------
491 // entity writing methods
492
WriteFileHeader(const COFF::header & Header)493 void WinCOFFObjectWriter::WriteFileHeader(const COFF::header &Header) {
494 if (UseBigObj) {
495 W.write<uint16_t>(COFF::IMAGE_FILE_MACHINE_UNKNOWN);
496 W.write<uint16_t>(0xFFFF);
497 W.write<uint16_t>(COFF::BigObjHeader::MinBigObjectVersion);
498 W.write<uint16_t>(Header.Machine);
499 W.write<uint32_t>(Header.TimeDateStamp);
500 W.OS.write(COFF::BigObjMagic, sizeof(COFF::BigObjMagic));
501 W.write<uint32_t>(0);
502 W.write<uint32_t>(0);
503 W.write<uint32_t>(0);
504 W.write<uint32_t>(0);
505 W.write<uint32_t>(Header.NumberOfSections);
506 W.write<uint32_t>(Header.PointerToSymbolTable);
507 W.write<uint32_t>(Header.NumberOfSymbols);
508 } else {
509 W.write<uint16_t>(Header.Machine);
510 W.write<uint16_t>(static_cast<int16_t>(Header.NumberOfSections));
511 W.write<uint32_t>(Header.TimeDateStamp);
512 W.write<uint32_t>(Header.PointerToSymbolTable);
513 W.write<uint32_t>(Header.NumberOfSymbols);
514 W.write<uint16_t>(Header.SizeOfOptionalHeader);
515 W.write<uint16_t>(Header.Characteristics);
516 }
517 }
518
WriteSymbol(const COFFSymbol & S)519 void WinCOFFObjectWriter::WriteSymbol(const COFFSymbol &S) {
520 W.OS.write(S.Data.Name, COFF::NameSize);
521 W.write<uint32_t>(S.Data.Value);
522 if (UseBigObj)
523 W.write<uint32_t>(S.Data.SectionNumber);
524 else
525 W.write<uint16_t>(static_cast<int16_t>(S.Data.SectionNumber));
526 W.write<uint16_t>(S.Data.Type);
527 W.OS << char(S.Data.StorageClass);
528 W.OS << char(S.Data.NumberOfAuxSymbols);
529 WriteAuxiliarySymbols(S.Aux);
530 }
531
WriteAuxiliarySymbols(const COFFSymbol::AuxiliarySymbols & S)532 void WinCOFFObjectWriter::WriteAuxiliarySymbols(
533 const COFFSymbol::AuxiliarySymbols &S) {
534 for (const AuxSymbol &i : S) {
535 switch (i.AuxType) {
536 case ATWeakExternal:
537 W.write<uint32_t>(i.Aux.WeakExternal.TagIndex);
538 W.write<uint32_t>(i.Aux.WeakExternal.Characteristics);
539 W.OS.write_zeros(sizeof(i.Aux.WeakExternal.unused));
540 if (UseBigObj)
541 W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
542 break;
543 case ATFile:
544 W.OS.write(reinterpret_cast<const char *>(&i.Aux),
545 UseBigObj ? COFF::Symbol32Size : COFF::Symbol16Size);
546 break;
547 case ATSectionDefinition:
548 W.write<uint32_t>(i.Aux.SectionDefinition.Length);
549 W.write<uint16_t>(i.Aux.SectionDefinition.NumberOfRelocations);
550 W.write<uint16_t>(i.Aux.SectionDefinition.NumberOfLinenumbers);
551 W.write<uint32_t>(i.Aux.SectionDefinition.CheckSum);
552 W.write<uint16_t>(static_cast<int16_t>(i.Aux.SectionDefinition.Number));
553 W.OS << char(i.Aux.SectionDefinition.Selection);
554 W.OS.write_zeros(sizeof(i.Aux.SectionDefinition.unused));
555 W.write<uint16_t>(static_cast<int16_t>(i.Aux.SectionDefinition.Number >> 16));
556 if (UseBigObj)
557 W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
558 break;
559 }
560 }
561 }
562
563 // Write the section header.
writeSectionHeaders()564 void WinCOFFObjectWriter::writeSectionHeaders() {
565 // Section numbers must be monotonically increasing in the section
566 // header, but our Sections array is not sorted by section number,
567 // so make a copy of Sections and sort it.
568 std::vector<COFFSection *> Arr;
569 for (auto &Section : Sections)
570 Arr.push_back(Section.get());
571 llvm::sort(Arr, [](const COFFSection *A, const COFFSection *B) {
572 return A->Number < B->Number;
573 });
574
575 for (auto &Section : Arr) {
576 if (Section->Number == -1)
577 continue;
578
579 COFF::section &S = Section->Header;
580 if (Section->Relocations.size() >= 0xffff)
581 S.Characteristics |= COFF::IMAGE_SCN_LNK_NRELOC_OVFL;
582 W.OS.write(S.Name, COFF::NameSize);
583 W.write<uint32_t>(S.VirtualSize);
584 W.write<uint32_t>(S.VirtualAddress);
585 W.write<uint32_t>(S.SizeOfRawData);
586 W.write<uint32_t>(S.PointerToRawData);
587 W.write<uint32_t>(S.PointerToRelocations);
588 W.write<uint32_t>(S.PointerToLineNumbers);
589 W.write<uint16_t>(S.NumberOfRelocations);
590 W.write<uint16_t>(S.NumberOfLineNumbers);
591 W.write<uint32_t>(S.Characteristics);
592 }
593 }
594
WriteRelocation(const COFF::relocation & R)595 void WinCOFFObjectWriter::WriteRelocation(const COFF::relocation &R) {
596 W.write<uint32_t>(R.VirtualAddress);
597 W.write<uint32_t>(R.SymbolTableIndex);
598 W.write<uint16_t>(R.Type);
599 }
600
601 // Write MCSec's contents. What this function does is essentially
602 // "Asm.writeSectionData(&MCSec, Layout)", but it's a bit complicated
603 // because it needs to compute a CRC.
writeSectionContents(MCAssembler & Asm,const MCAsmLayout & Layout,const MCSection & MCSec)604 uint32_t WinCOFFObjectWriter::writeSectionContents(MCAssembler &Asm,
605 const MCAsmLayout &Layout,
606 const MCSection &MCSec) {
607 // Save the contents of the section to a temporary buffer, we need this
608 // to CRC the data before we dump it into the object file.
609 SmallVector<char, 128> Buf;
610 raw_svector_ostream VecOS(Buf);
611 Asm.writeSectionData(VecOS, &MCSec, Layout);
612
613 // Write the section contents to the object file.
614 W.OS << Buf;
615
616 // Calculate our CRC with an initial value of '0', this is not how
617 // JamCRC is specified but it aligns with the expected output.
618 JamCRC JC(/*Init=*/0);
619 JC.update(makeArrayRef(reinterpret_cast<uint8_t*>(Buf.data()), Buf.size()));
620 return JC.getCRC();
621 }
622
writeSection(MCAssembler & Asm,const MCAsmLayout & Layout,const COFFSection & Sec,const MCSection & MCSec)623 void WinCOFFObjectWriter::writeSection(MCAssembler &Asm,
624 const MCAsmLayout &Layout,
625 const COFFSection &Sec,
626 const MCSection &MCSec) {
627 if (Sec.Number == -1)
628 return;
629
630 // Write the section contents.
631 if (Sec.Header.PointerToRawData != 0) {
632 assert(W.OS.tell() == Sec.Header.PointerToRawData &&
633 "Section::PointerToRawData is insane!");
634
635 uint32_t CRC = writeSectionContents(Asm, Layout, MCSec);
636
637 // Update the section definition auxiliary symbol to record the CRC.
638 COFFSection *Sec = SectionMap[&MCSec];
639 COFFSymbol::AuxiliarySymbols &AuxSyms = Sec->Symbol->Aux;
640 assert(AuxSyms.size() == 1 && AuxSyms[0].AuxType == ATSectionDefinition);
641 AuxSymbol &SecDef = AuxSyms[0];
642 SecDef.Aux.SectionDefinition.CheckSum = CRC;
643 }
644
645 // Write relocations for this section.
646 if (Sec.Relocations.empty()) {
647 assert(Sec.Header.PointerToRelocations == 0 &&
648 "Section::PointerToRelocations is insane!");
649 return;
650 }
651
652 assert(W.OS.tell() == Sec.Header.PointerToRelocations &&
653 "Section::PointerToRelocations is insane!");
654
655 if (Sec.Relocations.size() >= 0xffff) {
656 // In case of overflow, write actual relocation count as first
657 // relocation. Including the synthetic reloc itself (+ 1).
658 COFF::relocation R;
659 R.VirtualAddress = Sec.Relocations.size() + 1;
660 R.SymbolTableIndex = 0;
661 R.Type = 0;
662 WriteRelocation(R);
663 }
664
665 for (const auto &Relocation : Sec.Relocations)
666 WriteRelocation(Relocation.Data);
667 }
668
669 ////////////////////////////////////////////////////////////////////////////////
670 // MCObjectWriter interface implementations
671
executePostLayoutBinding(MCAssembler & Asm,const MCAsmLayout & Layout)672 void WinCOFFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
673 const MCAsmLayout &Layout) {
674 if (EmitAddrsigSection) {
675 AddrsigSection = Asm.getContext().getCOFFSection(
676 ".llvm_addrsig", COFF::IMAGE_SCN_LNK_REMOVE,
677 SectionKind::getMetadata());
678 Asm.registerSection(*AddrsigSection);
679 }
680
681 if (!Asm.CGProfile.empty()) {
682 CGProfileSection = Asm.getContext().getCOFFSection(
683 ".llvm.call-graph-profile", COFF::IMAGE_SCN_LNK_REMOVE,
684 SectionKind::getMetadata());
685 Asm.registerSection(*CGProfileSection);
686 }
687
688 // "Define" each section & symbol. This creates section & symbol
689 // entries in the staging area.
690 for (const auto &Section : Asm)
691 defineSection(static_cast<const MCSectionCOFF &>(Section));
692
693 for (const MCSymbol &Symbol : Asm.symbols())
694 if (!Symbol.isTemporary())
695 DefineSymbol(Symbol, Asm, Layout);
696 }
697
isSymbolRefDifferenceFullyResolvedImpl(const MCAssembler & Asm,const MCSymbol & SymA,const MCFragment & FB,bool InSet,bool IsPCRel) const698 bool WinCOFFObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
699 const MCAssembler &Asm, const MCSymbol &SymA, const MCFragment &FB,
700 bool InSet, bool IsPCRel) const {
701 // Don't drop relocations between functions, even if they are in the same text
702 // section. Multiple Visual C++ linker features depend on having the
703 // relocations present. The /INCREMENTAL flag will cause these relocations to
704 // point to thunks, and the /GUARD:CF flag assumes that it can use relocations
705 // to approximate the set of all address taken functions. LLD's implementation
706 // of /GUARD:CF also relies on the existance of these relocations.
707 uint16_t Type = cast<MCSymbolCOFF>(SymA).getType();
708 if ((Type >> COFF::SCT_COMPLEX_TYPE_SHIFT) == COFF::IMAGE_SYM_DTYPE_FUNCTION)
709 return false;
710 return MCObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(Asm, SymA, FB,
711 InSet, IsPCRel);
712 }
713
recordRelocation(MCAssembler & Asm,const MCAsmLayout & Layout,const MCFragment * Fragment,const MCFixup & Fixup,MCValue Target,uint64_t & FixedValue)714 void WinCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
715 const MCAsmLayout &Layout,
716 const MCFragment *Fragment,
717 const MCFixup &Fixup, MCValue Target,
718 uint64_t &FixedValue) {
719 assert(Target.getSymA() && "Relocation must reference a symbol!");
720
721 const MCSymbol &A = Target.getSymA()->getSymbol();
722 if (!A.isRegistered()) {
723 Asm.getContext().reportError(Fixup.getLoc(),
724 Twine("symbol '") + A.getName() +
725 "' can not be undefined");
726 return;
727 }
728 if (A.isTemporary() && A.isUndefined()) {
729 Asm.getContext().reportError(Fixup.getLoc(),
730 Twine("assembler label '") + A.getName() +
731 "' can not be undefined");
732 return;
733 }
734
735 MCSection *MCSec = Fragment->getParent();
736
737 // Mark this symbol as requiring an entry in the symbol table.
738 assert(SectionMap.find(MCSec) != SectionMap.end() &&
739 "Section must already have been defined in executePostLayoutBinding!");
740
741 COFFSection *Sec = SectionMap[MCSec];
742 const MCSymbolRefExpr *SymB = Target.getSymB();
743
744 if (SymB) {
745 const MCSymbol *B = &SymB->getSymbol();
746 if (!B->getFragment()) {
747 Asm.getContext().reportError(
748 Fixup.getLoc(),
749 Twine("symbol '") + B->getName() +
750 "' can not be undefined in a subtraction expression");
751 return;
752 }
753
754 // Offset of the symbol in the section
755 int64_t OffsetOfB = Layout.getSymbolOffset(*B);
756
757 // Offset of the relocation in the section
758 int64_t OffsetOfRelocation =
759 Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
760
761 FixedValue = (OffsetOfRelocation - OffsetOfB) + Target.getConstant();
762 } else {
763 FixedValue = Target.getConstant();
764 }
765
766 COFFRelocation Reloc;
767
768 Reloc.Data.SymbolTableIndex = 0;
769 Reloc.Data.VirtualAddress = Layout.getFragmentOffset(Fragment);
770
771 // Turn relocations for temporary symbols into section relocations.
772 if (A.isTemporary()) {
773 MCSection *TargetSection = &A.getSection();
774 assert(
775 SectionMap.find(TargetSection) != SectionMap.end() &&
776 "Section must already have been defined in executePostLayoutBinding!");
777 Reloc.Symb = SectionMap[TargetSection]->Symbol;
778 FixedValue += Layout.getSymbolOffset(A);
779 } else {
780 assert(
781 SymbolMap.find(&A) != SymbolMap.end() &&
782 "Symbol must already have been defined in executePostLayoutBinding!");
783 Reloc.Symb = SymbolMap[&A];
784 }
785
786 ++Reloc.Symb->Relocations;
787
788 Reloc.Data.VirtualAddress += Fixup.getOffset();
789 Reloc.Data.Type = TargetObjectWriter->getRelocType(
790 Asm.getContext(), Target, Fixup, SymB, Asm.getBackend());
791
792 // FIXME: Can anyone explain what this does other than adjust for the size
793 // of the offset?
794 if ((Header.Machine == COFF::IMAGE_FILE_MACHINE_AMD64 &&
795 Reloc.Data.Type == COFF::IMAGE_REL_AMD64_REL32) ||
796 (Header.Machine == COFF::IMAGE_FILE_MACHINE_I386 &&
797 Reloc.Data.Type == COFF::IMAGE_REL_I386_REL32))
798 FixedValue += 4;
799
800 if (Header.Machine == COFF::IMAGE_FILE_MACHINE_ARMNT) {
801 switch (Reloc.Data.Type) {
802 case COFF::IMAGE_REL_ARM_ABSOLUTE:
803 case COFF::IMAGE_REL_ARM_ADDR32:
804 case COFF::IMAGE_REL_ARM_ADDR32NB:
805 case COFF::IMAGE_REL_ARM_TOKEN:
806 case COFF::IMAGE_REL_ARM_SECTION:
807 case COFF::IMAGE_REL_ARM_SECREL:
808 break;
809 case COFF::IMAGE_REL_ARM_BRANCH11:
810 case COFF::IMAGE_REL_ARM_BLX11:
811 // IMAGE_REL_ARM_BRANCH11 and IMAGE_REL_ARM_BLX11 are only used for
812 // pre-ARMv7, which implicitly rules it out of ARMNT (it would be valid
813 // for Windows CE).
814 case COFF::IMAGE_REL_ARM_BRANCH24:
815 case COFF::IMAGE_REL_ARM_BLX24:
816 case COFF::IMAGE_REL_ARM_MOV32A:
817 // IMAGE_REL_ARM_BRANCH24, IMAGE_REL_ARM_BLX24, IMAGE_REL_ARM_MOV32A are
818 // only used for ARM mode code, which is documented as being unsupported
819 // by Windows on ARM. Empirical proof indicates that masm is able to
820 // generate the relocations however the rest of the MSVC toolchain is
821 // unable to handle it.
822 llvm_unreachable("unsupported relocation");
823 break;
824 case COFF::IMAGE_REL_ARM_MOV32T:
825 break;
826 case COFF::IMAGE_REL_ARM_BRANCH20T:
827 case COFF::IMAGE_REL_ARM_BRANCH24T:
828 case COFF::IMAGE_REL_ARM_BLX23T:
829 // IMAGE_REL_BRANCH20T, IMAGE_REL_ARM_BRANCH24T, IMAGE_REL_ARM_BLX23T all
830 // perform a 4 byte adjustment to the relocation. Relative branches are
831 // offset by 4 on ARM, however, because there is no RELA relocations, all
832 // branches are offset by 4.
833 FixedValue = FixedValue + 4;
834 break;
835 }
836 }
837
838 // The fixed value never makes sense for section indices, ignore it.
839 if (Fixup.getKind() == FK_SecRel_2)
840 FixedValue = 0;
841
842 if (TargetObjectWriter->recordRelocation(Fixup))
843 Sec->Relocations.push_back(Reloc);
844 }
845
getTime()846 static std::time_t getTime() {
847 std::time_t Now = time(nullptr);
848 if (Now < 0 || !isUInt<32>(Now))
849 return UINT32_MAX;
850 return Now;
851 }
852
853 // Create .file symbols.
createFileSymbols(MCAssembler & Asm)854 void WinCOFFObjectWriter::createFileSymbols(MCAssembler &Asm) {
855 for (const std::string &Name : Asm.getFileNames()) {
856 // round up to calculate the number of auxiliary symbols required
857 unsigned SymbolSize = UseBigObj ? COFF::Symbol32Size : COFF::Symbol16Size;
858 unsigned Count = (Name.size() + SymbolSize - 1) / SymbolSize;
859
860 COFFSymbol *File = createSymbol(".file");
861 File->Data.SectionNumber = COFF::IMAGE_SYM_DEBUG;
862 File->Data.StorageClass = COFF::IMAGE_SYM_CLASS_FILE;
863 File->Aux.resize(Count);
864
865 unsigned Offset = 0;
866 unsigned Length = Name.size();
867 for (auto &Aux : File->Aux) {
868 Aux.AuxType = ATFile;
869
870 if (Length > SymbolSize) {
871 memcpy(&Aux.Aux, Name.c_str() + Offset, SymbolSize);
872 Length = Length - SymbolSize;
873 } else {
874 memcpy(&Aux.Aux, Name.c_str() + Offset, Length);
875 memset((char *)&Aux.Aux + Length, 0, SymbolSize - Length);
876 break;
877 }
878
879 Offset += SymbolSize;
880 }
881 }
882 }
883
setWeakDefaultNames()884 void WinCOFFObjectWriter::setWeakDefaultNames() {
885 if (WeakDefaults.empty())
886 return;
887
888 // If multiple object files use a weak symbol (either with a regular
889 // defined default, or an absolute zero symbol as default), the defaults
890 // cause duplicate definitions unless their names are made unique. Look
891 // for a defined extern symbol, that isn't comdat - that should be unique
892 // unless there are other duplicate definitions. And if none is found,
893 // allow picking a comdat symbol, as that's still better than nothing.
894
895 COFFSymbol *Unique = nullptr;
896 for (bool AllowComdat : {false, true}) {
897 for (auto &Sym : Symbols) {
898 // Don't include the names of the defaults themselves
899 if (WeakDefaults.count(Sym.get()))
900 continue;
901 // Only consider external symbols
902 if (Sym->Data.StorageClass != COFF::IMAGE_SYM_CLASS_EXTERNAL)
903 continue;
904 // Only consider symbols defined in a section or that are absolute
905 if (!Sym->Section && Sym->Data.SectionNumber != COFF::IMAGE_SYM_ABSOLUTE)
906 continue;
907 if (!AllowComdat && Sym->Section &&
908 Sym->Section->Header.Characteristics & COFF::IMAGE_SCN_LNK_COMDAT)
909 continue;
910 Unique = Sym.get();
911 break;
912 }
913 if (Unique)
914 break;
915 }
916 // If we didn't find any unique symbol to use for the names, just skip this.
917 if (!Unique)
918 return;
919 for (auto *Sym : WeakDefaults) {
920 Sym->Name.append(".");
921 Sym->Name.append(Unique->Name);
922 }
923 }
924
isAssociative(const COFFSection & Section)925 static bool isAssociative(const COFFSection &Section) {
926 return Section.Symbol->Aux[0].Aux.SectionDefinition.Selection ==
927 COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
928 }
929
assignSectionNumbers()930 void WinCOFFObjectWriter::assignSectionNumbers() {
931 size_t I = 1;
932 auto Assign = [&](COFFSection &Section) {
933 Section.Number = I;
934 Section.Symbol->Data.SectionNumber = I;
935 Section.Symbol->Aux[0].Aux.SectionDefinition.Number = I;
936 ++I;
937 };
938
939 // Although it is not explicitly requested by the Microsoft COFF spec,
940 // we should avoid emitting forward associative section references,
941 // because MSVC link.exe as of 2017 cannot handle that.
942 for (const std::unique_ptr<COFFSection> &Section : Sections)
943 if (!isAssociative(*Section))
944 Assign(*Section);
945 for (const std::unique_ptr<COFFSection> &Section : Sections)
946 if (isAssociative(*Section))
947 Assign(*Section);
948 }
949
950 // Assign file offsets to COFF object file structures.
assignFileOffsets(MCAssembler & Asm,const MCAsmLayout & Layout)951 void WinCOFFObjectWriter::assignFileOffsets(MCAssembler &Asm,
952 const MCAsmLayout &Layout) {
953 unsigned Offset = W.OS.tell();
954
955 Offset += UseBigObj ? COFF::Header32Size : COFF::Header16Size;
956 Offset += COFF::SectionSize * Header.NumberOfSections;
957
958 for (const auto &Section : Asm) {
959 COFFSection *Sec = SectionMap[&Section];
960
961 if (Sec->Number == -1)
962 continue;
963
964 Sec->Header.SizeOfRawData = Layout.getSectionAddressSize(&Section);
965
966 if (IsPhysicalSection(Sec)) {
967 Sec->Header.PointerToRawData = Offset;
968 Offset += Sec->Header.SizeOfRawData;
969 }
970
971 if (!Sec->Relocations.empty()) {
972 bool RelocationsOverflow = Sec->Relocations.size() >= 0xffff;
973
974 if (RelocationsOverflow) {
975 // Signal overflow by setting NumberOfRelocations to max value. Actual
976 // size is found in reloc #0. Microsoft tools understand this.
977 Sec->Header.NumberOfRelocations = 0xffff;
978 } else {
979 Sec->Header.NumberOfRelocations = Sec->Relocations.size();
980 }
981 Sec->Header.PointerToRelocations = Offset;
982
983 if (RelocationsOverflow) {
984 // Reloc #0 will contain actual count, so make room for it.
985 Offset += COFF::RelocationSize;
986 }
987
988 Offset += COFF::RelocationSize * Sec->Relocations.size();
989
990 for (auto &Relocation : Sec->Relocations) {
991 assert(Relocation.Symb->getIndex() != -1);
992 Relocation.Data.SymbolTableIndex = Relocation.Symb->getIndex();
993 }
994 }
995
996 assert(Sec->Symbol->Aux.size() == 1 &&
997 "Section's symbol must have one aux!");
998 AuxSymbol &Aux = Sec->Symbol->Aux[0];
999 assert(Aux.AuxType == ATSectionDefinition &&
1000 "Section's symbol's aux symbol must be a Section Definition!");
1001 Aux.Aux.SectionDefinition.Length = Sec->Header.SizeOfRawData;
1002 Aux.Aux.SectionDefinition.NumberOfRelocations =
1003 Sec->Header.NumberOfRelocations;
1004 Aux.Aux.SectionDefinition.NumberOfLinenumbers =
1005 Sec->Header.NumberOfLineNumbers;
1006 }
1007
1008 Header.PointerToSymbolTable = Offset;
1009 }
1010
writeObject(MCAssembler & Asm,const MCAsmLayout & Layout)1011 uint64_t WinCOFFObjectWriter::writeObject(MCAssembler &Asm,
1012 const MCAsmLayout &Layout) {
1013 uint64_t StartOffset = W.OS.tell();
1014
1015 if (Sections.size() > INT32_MAX)
1016 report_fatal_error(
1017 "PE COFF object files can't have more than 2147483647 sections");
1018
1019 UseBigObj = Sections.size() > COFF::MaxNumberOfSections16;
1020 Header.NumberOfSections = Sections.size();
1021 Header.NumberOfSymbols = 0;
1022
1023 setWeakDefaultNames();
1024 assignSectionNumbers();
1025 createFileSymbols(Asm);
1026
1027 for (auto &Symbol : Symbols) {
1028 // Update section number & offset for symbols that have them.
1029 if (Symbol->Section)
1030 Symbol->Data.SectionNumber = Symbol->Section->Number;
1031 Symbol->setIndex(Header.NumberOfSymbols++);
1032 // Update auxiliary symbol info.
1033 Symbol->Data.NumberOfAuxSymbols = Symbol->Aux.size();
1034 Header.NumberOfSymbols += Symbol->Data.NumberOfAuxSymbols;
1035 }
1036
1037 // Build string table.
1038 for (const auto &S : Sections)
1039 if (S->Name.size() > COFF::NameSize)
1040 Strings.add(S->Name);
1041 for (const auto &S : Symbols)
1042 if (S->Name.size() > COFF::NameSize)
1043 Strings.add(S->Name);
1044 Strings.finalize();
1045
1046 // Set names.
1047 for (const auto &S : Sections)
1048 SetSectionName(*S);
1049 for (auto &S : Symbols)
1050 SetSymbolName(*S);
1051
1052 // Fixup weak external references.
1053 for (auto &Symbol : Symbols) {
1054 if (Symbol->Other) {
1055 assert(Symbol->getIndex() != -1);
1056 assert(Symbol->Aux.size() == 1 && "Symbol must contain one aux symbol!");
1057 assert(Symbol->Aux[0].AuxType == ATWeakExternal &&
1058 "Symbol's aux symbol must be a Weak External!");
1059 Symbol->Aux[0].Aux.WeakExternal.TagIndex = Symbol->Other->getIndex();
1060 }
1061 }
1062
1063 // Fixup associative COMDAT sections.
1064 for (auto &Section : Sections) {
1065 if (Section->Symbol->Aux[0].Aux.SectionDefinition.Selection !=
1066 COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE)
1067 continue;
1068
1069 const MCSectionCOFF &MCSec = *Section->MCSection;
1070 const MCSymbol *AssocMCSym = MCSec.getCOMDATSymbol();
1071 assert(AssocMCSym);
1072
1073 // It's an error to try to associate with an undefined symbol or a symbol
1074 // without a section.
1075 if (!AssocMCSym->isInSection()) {
1076 Asm.getContext().reportError(
1077 SMLoc(), Twine("cannot make section ") + MCSec.getName() +
1078 Twine(" associative with sectionless symbol ") +
1079 AssocMCSym->getName());
1080 continue;
1081 }
1082
1083 const auto *AssocMCSec = cast<MCSectionCOFF>(&AssocMCSym->getSection());
1084 assert(SectionMap.count(AssocMCSec));
1085 COFFSection *AssocSec = SectionMap[AssocMCSec];
1086
1087 // Skip this section if the associated section is unused.
1088 if (AssocSec->Number == -1)
1089 continue;
1090
1091 Section->Symbol->Aux[0].Aux.SectionDefinition.Number = AssocSec->Number;
1092 }
1093
1094 // Create the contents of the .llvm_addrsig section.
1095 if (EmitAddrsigSection) {
1096 auto Frag = new MCDataFragment(AddrsigSection);
1097 Frag->setLayoutOrder(0);
1098 raw_svector_ostream OS(Frag->getContents());
1099 for (const MCSymbol *S : AddrsigSyms) {
1100 if (!S->isTemporary()) {
1101 encodeULEB128(S->getIndex(), OS);
1102 continue;
1103 }
1104
1105 MCSection *TargetSection = &S->getSection();
1106 assert(SectionMap.find(TargetSection) != SectionMap.end() &&
1107 "Section must already have been defined in "
1108 "executePostLayoutBinding!");
1109 encodeULEB128(SectionMap[TargetSection]->Symbol->getIndex(), OS);
1110 }
1111 }
1112
1113 // Create the contents of the .llvm.call-graph-profile section.
1114 if (CGProfileSection) {
1115 auto *Frag = new MCDataFragment(CGProfileSection);
1116 Frag->setLayoutOrder(0);
1117 raw_svector_ostream OS(Frag->getContents());
1118 for (const MCAssembler::CGProfileEntry &CGPE : Asm.CGProfile) {
1119 uint32_t FromIndex = CGPE.From->getSymbol().getIndex();
1120 uint32_t ToIndex = CGPE.To->getSymbol().getIndex();
1121 support::endian::write(OS, FromIndex, W.Endian);
1122 support::endian::write(OS, ToIndex, W.Endian);
1123 support::endian::write(OS, CGPE.Count, W.Endian);
1124 }
1125 }
1126
1127 assignFileOffsets(Asm, Layout);
1128
1129 // MS LINK expects to be able to use this timestamp to implement their
1130 // /INCREMENTAL feature.
1131 if (Asm.isIncrementalLinkerCompatible()) {
1132 Header.TimeDateStamp = getTime();
1133 } else {
1134 // Have deterministic output if /INCREMENTAL isn't needed. Also matches GNU.
1135 Header.TimeDateStamp = 0;
1136 }
1137
1138 // Write it all to disk...
1139 WriteFileHeader(Header);
1140 writeSectionHeaders();
1141
1142 // Write section contents.
1143 sections::iterator I = Sections.begin();
1144 sections::iterator IE = Sections.end();
1145 MCAssembler::iterator J = Asm.begin();
1146 MCAssembler::iterator JE = Asm.end();
1147 for (; I != IE && J != JE; ++I, ++J)
1148 writeSection(Asm, Layout, **I, *J);
1149
1150 assert(W.OS.tell() == Header.PointerToSymbolTable &&
1151 "Header::PointerToSymbolTable is insane!");
1152
1153 // Write a symbol table.
1154 for (auto &Symbol : Symbols)
1155 if (Symbol->getIndex() != -1)
1156 WriteSymbol(*Symbol);
1157
1158 // Write a string table, which completes the entire COFF file.
1159 Strings.write(W.OS);
1160
1161 return W.OS.tell() - StartOffset;
1162 }
1163
MCWinCOFFObjectTargetWriter(unsigned Machine_)1164 MCWinCOFFObjectTargetWriter::MCWinCOFFObjectTargetWriter(unsigned Machine_)
1165 : Machine(Machine_) {}
1166
1167 // Pin the vtable to this file.
anchor()1168 void MCWinCOFFObjectTargetWriter::anchor() {}
1169
1170 //------------------------------------------------------------------------------
1171 // WinCOFFObjectWriter factory function
1172
createWinCOFFObjectWriter(std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW,raw_pwrite_stream & OS)1173 std::unique_ptr<MCObjectWriter> llvm::createWinCOFFObjectWriter(
1174 std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS) {
1175 return std::make_unique<WinCOFFObjectWriter>(std::move(MOTW), OS);
1176 }
1177