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