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 #define DEBUG_TYPE "WinCOFFObjectWriter" 15 16 #include "llvm/MC/MCObjectWriter.h" 17 #include "llvm/MC/MCSection.h" 18 #include "llvm/MC/MCContext.h" 19 #include "llvm/MC/MCSymbol.h" 20 #include "llvm/MC/MCExpr.h" 21 #include "llvm/MC/MCValue.h" 22 #include "llvm/MC/MCAssembler.h" 23 #include "llvm/MC/MCAsmLayout.h" 24 #include "llvm/MC/MCSectionCOFF.h" 25 #include "llvm/MC/MCWinCOFFObjectWriter.h" 26 27 #include "llvm/ADT/DenseMap.h" 28 #include "llvm/ADT/OwningPtr.h" 29 #include "llvm/ADT/StringMap.h" 30 #include "llvm/ADT/StringRef.h" 31 32 #include "llvm/Support/COFF.h" 33 #include "llvm/Support/Debug.h" 34 #include "llvm/Support/ErrorHandling.h" 35 36 #include "llvm/Support/TimeValue.h" 37 38 #include <cstdio> 39 40 using namespace llvm; 41 42 namespace { 43 typedef llvm::SmallString<COFF::NameSize> name; 44 45 enum AuxiliaryType { 46 ATFunctionDefinition, 47 ATbfAndefSymbol, 48 ATWeakExternal, 49 ATFile, 50 ATSectionDefinition 51 }; 52 53 struct AuxSymbol { 54 AuxiliaryType AuxType; 55 COFF::Auxiliary Aux; 56 }; 57 58 class COFFSymbol; 59 class COFFSection; 60 61 class COFFSymbol { 62 public: 63 COFF::symbol Data; 64 65 typedef llvm::SmallVector<AuxSymbol, 1> AuxiliarySymbols; 66 67 name Name; 68 int Index; 69 AuxiliarySymbols Aux; 70 COFFSymbol *Other; 71 COFFSection *Section; 72 int Relocations; 73 74 MCSymbolData const *MCData; 75 76 COFFSymbol(llvm::StringRef name); 77 size_t size() const; 78 void set_name_offset(uint32_t Offset); 79 80 bool should_keep() const; 81 }; 82 83 // This class contains staging data for a COFF relocation entry. 84 struct COFFRelocation { 85 COFF::relocation Data; 86 COFFSymbol *Symb; 87 88 COFFRelocation() : Symb(NULL) {} 89 static size_t size() { return COFF::RelocationSize; } 90 }; 91 92 typedef std::vector<COFFRelocation> relocations; 93 94 class COFFSection { 95 public: 96 COFF::section Header; 97 98 std::string Name; 99 int Number; 100 MCSectionData const *MCData; 101 COFFSymbol *Symbol; 102 relocations Relocations; 103 104 COFFSection(llvm::StringRef name); 105 static size_t size(); 106 }; 107 108 // This class holds the COFF string table. 109 class StringTable { 110 typedef llvm::StringMap<size_t> map; 111 map Map; 112 113 void update_length(); 114 public: 115 std::vector<char> Data; 116 117 StringTable(); 118 size_t size() const; 119 size_t insert(llvm::StringRef String); 120 }; 121 122 class WinCOFFObjectWriter : public MCObjectWriter { 123 public: 124 125 typedef std::vector<COFFSymbol*> symbols; 126 typedef std::vector<COFFSection*> sections; 127 128 typedef DenseMap<MCSymbol const *, COFFSymbol *> symbol_map; 129 typedef DenseMap<MCSection const *, COFFSection *> section_map; 130 131 llvm::OwningPtr<MCWinCOFFObjectTargetWriter> TargetObjectWriter; 132 133 // Root level file contents. 134 COFF::header Header; 135 sections Sections; 136 symbols Symbols; 137 StringTable Strings; 138 139 // Maps used during object file creation. 140 section_map SectionMap; 141 symbol_map SymbolMap; 142 143 WinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW, raw_ostream &OS); 144 ~WinCOFFObjectWriter(); 145 146 COFFSymbol *createSymbol(StringRef Name); 147 COFFSymbol *GetOrCreateCOFFSymbol(const MCSymbol * Symbol); 148 COFFSection *createSection(StringRef Name); 149 150 template <typename object_t, typename list_t> 151 object_t *createCOFFEntity(llvm::StringRef Name, list_t &List); 152 153 void DefineSection(MCSectionData const &SectionData); 154 void DefineSymbol(MCSymbolData const &SymbolData, MCAssembler &Assembler); 155 156 void MakeSymbolReal(COFFSymbol &S, size_t Index); 157 void MakeSectionReal(COFFSection &S, size_t Number); 158 159 bool ExportSection(COFFSection const *S); 160 bool ExportSymbol(MCSymbolData const &SymbolData, MCAssembler &Asm); 161 162 bool IsPhysicalSection(COFFSection *S); 163 164 // Entity writing methods. 165 166 void WriteFileHeader(const COFF::header &Header); 167 void WriteSymbol(const COFFSymbol *S); 168 void WriteAuxiliarySymbols(const COFFSymbol::AuxiliarySymbols &S); 169 void WriteSectionHeader(const COFF::section &S); 170 void WriteRelocation(const COFF::relocation &R); 171 172 // MCObjectWriter interface implementation. 173 174 void ExecutePostLayoutBinding(MCAssembler &Asm, const MCAsmLayout &Layout); 175 176 void RecordRelocation(const MCAssembler &Asm, 177 const MCAsmLayout &Layout, 178 const MCFragment *Fragment, 179 const MCFixup &Fixup, 180 MCValue Target, 181 uint64_t &FixedValue); 182 183 void WriteObject(MCAssembler &Asm, const MCAsmLayout &Layout); 184 }; 185 } 186 187 static inline void write_uint32_le(void *Data, uint32_t const &Value) { 188 uint8_t *Ptr = reinterpret_cast<uint8_t *>(Data); 189 Ptr[0] = (Value & 0x000000FF) >> 0; 190 Ptr[1] = (Value & 0x0000FF00) >> 8; 191 Ptr[2] = (Value & 0x00FF0000) >> 16; 192 Ptr[3] = (Value & 0xFF000000) >> 24; 193 } 194 195 static inline void write_uint16_le(void *Data, uint16_t const &Value) { 196 uint8_t *Ptr = reinterpret_cast<uint8_t *>(Data); 197 Ptr[0] = (Value & 0x00FF) >> 0; 198 Ptr[1] = (Value & 0xFF00) >> 8; 199 } 200 201 static inline void write_uint8_le(void *Data, uint8_t const &Value) { 202 uint8_t *Ptr = reinterpret_cast<uint8_t *>(Data); 203 Ptr[0] = (Value & 0xFF) >> 0; 204 } 205 206 //------------------------------------------------------------------------------ 207 // Symbol class implementation 208 209 COFFSymbol::COFFSymbol(llvm::StringRef name) 210 : Name(name.begin(), name.end()) 211 , Other(NULL) 212 , Section(NULL) 213 , Relocations(0) 214 , MCData(NULL) { 215 memset(&Data, 0, sizeof(Data)); 216 } 217 218 size_t COFFSymbol::size() const { 219 return COFF::SymbolSize + (Data.NumberOfAuxSymbols * COFF::SymbolSize); 220 } 221 222 // In the case that the name does not fit within 8 bytes, the offset 223 // into the string table is stored in the last 4 bytes instead, leaving 224 // the first 4 bytes as 0. 225 void COFFSymbol::set_name_offset(uint32_t Offset) { 226 write_uint32_le(Data.Name + 0, 0); 227 write_uint32_le(Data.Name + 4, Offset); 228 } 229 230 /// logic to decide if the symbol should be reported in the symbol table 231 bool COFFSymbol::should_keep() const { 232 // no section means its external, keep it 233 if (Section == NULL) 234 return true; 235 236 // if it has relocations pointing at it, keep it 237 if (Relocations > 0) { 238 assert(Section->Number != -1 && "Sections with relocations must be real!"); 239 return true; 240 } 241 242 // if the section its in is being droped, drop it 243 if (Section->Number == -1) 244 return false; 245 246 // if it is the section symbol, keep it 247 if (Section->Symbol == this) 248 return true; 249 250 // if its temporary, drop it 251 if (MCData && MCData->getSymbol().isTemporary()) 252 return false; 253 254 // otherwise, keep it 255 return true; 256 } 257 258 //------------------------------------------------------------------------------ 259 // Section class implementation 260 261 COFFSection::COFFSection(llvm::StringRef name) 262 : Name(name) 263 , MCData(NULL) 264 , Symbol(NULL) { 265 memset(&Header, 0, sizeof(Header)); 266 } 267 268 size_t COFFSection::size() { 269 return COFF::SectionSize; 270 } 271 272 //------------------------------------------------------------------------------ 273 // StringTable class implementation 274 275 /// Write the length of the string table into Data. 276 /// The length of the string table includes uint32 length header. 277 void StringTable::update_length() { 278 write_uint32_le(&Data.front(), Data.size()); 279 } 280 281 StringTable::StringTable() { 282 // The string table data begins with the length of the entire string table 283 // including the length header. Allocate space for this header. 284 Data.resize(4); 285 update_length(); 286 } 287 288 size_t StringTable::size() const { 289 return Data.size(); 290 } 291 292 /// Add String to the table iff it is not already there. 293 /// @returns the index into the string table where the string is now located. 294 size_t StringTable::insert(llvm::StringRef String) { 295 map::iterator i = Map.find(String); 296 297 if (i != Map.end()) 298 return i->second; 299 300 size_t Offset = Data.size(); 301 302 // Insert string data into string table. 303 Data.insert(Data.end(), String.begin(), String.end()); 304 Data.push_back('\0'); 305 306 // Put a reference to it in the map. 307 Map[String] = Offset; 308 309 // Update the internal length field. 310 update_length(); 311 312 return Offset; 313 } 314 315 //------------------------------------------------------------------------------ 316 // WinCOFFObjectWriter class implementation 317 318 WinCOFFObjectWriter::WinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW, 319 raw_ostream &OS) 320 : MCObjectWriter(OS, true) 321 , TargetObjectWriter(MOTW) { 322 memset(&Header, 0, sizeof(Header)); 323 324 Header.Machine = TargetObjectWriter->getMachine(); 325 } 326 327 WinCOFFObjectWriter::~WinCOFFObjectWriter() { 328 for (symbols::iterator I = Symbols.begin(), E = Symbols.end(); I != E; ++I) 329 delete *I; 330 for (sections::iterator I = Sections.begin(), E = Sections.end(); I != E; ++I) 331 delete *I; 332 } 333 334 COFFSymbol *WinCOFFObjectWriter::createSymbol(StringRef Name) { 335 return createCOFFEntity<COFFSymbol>(Name, Symbols); 336 } 337 338 COFFSymbol *WinCOFFObjectWriter::GetOrCreateCOFFSymbol(const MCSymbol * Symbol){ 339 symbol_map::iterator i = SymbolMap.find(Symbol); 340 if (i != SymbolMap.end()) 341 return i->second; 342 COFFSymbol *RetSymbol 343 = createCOFFEntity<COFFSymbol>(Symbol->getName(), Symbols); 344 SymbolMap[Symbol] = RetSymbol; 345 return RetSymbol; 346 } 347 348 COFFSection *WinCOFFObjectWriter::createSection(llvm::StringRef Name) { 349 return createCOFFEntity<COFFSection>(Name, Sections); 350 } 351 352 /// A template used to lookup or create a symbol/section, and initialize it if 353 /// needed. 354 template <typename object_t, typename list_t> 355 object_t *WinCOFFObjectWriter::createCOFFEntity(llvm::StringRef Name, 356 list_t &List) { 357 object_t *Object = new object_t(Name); 358 359 List.push_back(Object); 360 361 return Object; 362 } 363 364 /// This function takes a section data object from the assembler 365 /// and creates the associated COFF section staging object. 366 void WinCOFFObjectWriter::DefineSection(MCSectionData const &SectionData) { 367 assert(SectionData.getSection().getVariant() == MCSection::SV_COFF 368 && "Got non COFF section in the COFF backend!"); 369 // FIXME: Not sure how to verify this (at least in a debug build). 370 MCSectionCOFF const &Sec = 371 static_cast<MCSectionCOFF const &>(SectionData.getSection()); 372 373 COFFSection *coff_section = createSection(Sec.getSectionName()); 374 COFFSymbol *coff_symbol = createSymbol(Sec.getSectionName()); 375 376 coff_section->Symbol = coff_symbol; 377 coff_symbol->Section = coff_section; 378 coff_symbol->Data.StorageClass = COFF::IMAGE_SYM_CLASS_STATIC; 379 380 // In this case the auxiliary symbol is a Section Definition. 381 coff_symbol->Aux.resize(1); 382 memset(&coff_symbol->Aux[0], 0, sizeof(coff_symbol->Aux[0])); 383 coff_symbol->Aux[0].AuxType = ATSectionDefinition; 384 coff_symbol->Aux[0].Aux.SectionDefinition.Selection = Sec.getSelection(); 385 386 coff_section->Header.Characteristics = Sec.getCharacteristics(); 387 388 uint32_t &Characteristics = coff_section->Header.Characteristics; 389 switch (SectionData.getAlignment()) { 390 case 1: Characteristics |= COFF::IMAGE_SCN_ALIGN_1BYTES; break; 391 case 2: Characteristics |= COFF::IMAGE_SCN_ALIGN_2BYTES; break; 392 case 4: Characteristics |= COFF::IMAGE_SCN_ALIGN_4BYTES; break; 393 case 8: Characteristics |= COFF::IMAGE_SCN_ALIGN_8BYTES; break; 394 case 16: Characteristics |= COFF::IMAGE_SCN_ALIGN_16BYTES; break; 395 case 32: Characteristics |= COFF::IMAGE_SCN_ALIGN_32BYTES; break; 396 case 64: Characteristics |= COFF::IMAGE_SCN_ALIGN_64BYTES; break; 397 case 128: Characteristics |= COFF::IMAGE_SCN_ALIGN_128BYTES; break; 398 case 256: Characteristics |= COFF::IMAGE_SCN_ALIGN_256BYTES; break; 399 case 512: Characteristics |= COFF::IMAGE_SCN_ALIGN_512BYTES; break; 400 case 1024: Characteristics |= COFF::IMAGE_SCN_ALIGN_1024BYTES; break; 401 case 2048: Characteristics |= COFF::IMAGE_SCN_ALIGN_2048BYTES; break; 402 case 4096: Characteristics |= COFF::IMAGE_SCN_ALIGN_4096BYTES; break; 403 case 8192: Characteristics |= COFF::IMAGE_SCN_ALIGN_8192BYTES; break; 404 default: 405 llvm_unreachable("unsupported section alignment"); 406 } 407 408 // Bind internal COFF section to MC section. 409 coff_section->MCData = &SectionData; 410 SectionMap[&SectionData.getSection()] = coff_section; 411 } 412 413 /// This function takes a section data object from the assembler 414 /// and creates the associated COFF symbol staging object. 415 void WinCOFFObjectWriter::DefineSymbol(MCSymbolData const &SymbolData, 416 MCAssembler &Assembler) { 417 COFFSymbol *coff_symbol = GetOrCreateCOFFSymbol(&SymbolData.getSymbol()); 418 419 coff_symbol->Data.Type = (SymbolData.getFlags() & 0x0000FFFF) >> 0; 420 coff_symbol->Data.StorageClass = (SymbolData.getFlags() & 0x00FF0000) >> 16; 421 422 if (SymbolData.getFlags() & COFF::SF_WeakExternal) { 423 coff_symbol->Data.StorageClass = COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL; 424 425 if (SymbolData.getSymbol().isVariable()) { 426 coff_symbol->Data.StorageClass = COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL; 427 const MCExpr *Value = SymbolData.getSymbol().getVariableValue(); 428 429 // FIXME: This assert message isn't very good. 430 assert(Value->getKind() == MCExpr::SymbolRef && 431 "Value must be a SymbolRef!"); 432 433 const MCSymbolRefExpr *SymbolRef = 434 static_cast<const MCSymbolRefExpr *>(Value); 435 coff_symbol->Other = GetOrCreateCOFFSymbol(&SymbolRef->getSymbol()); 436 } else { 437 std::string WeakName = std::string(".weak.") 438 + SymbolData.getSymbol().getName().str() 439 + ".default"; 440 COFFSymbol *WeakDefault = createSymbol(WeakName); 441 WeakDefault->Data.SectionNumber = COFF::IMAGE_SYM_ABSOLUTE; 442 WeakDefault->Data.StorageClass = COFF::IMAGE_SYM_CLASS_EXTERNAL; 443 WeakDefault->Data.Type = 0; 444 WeakDefault->Data.Value = 0; 445 coff_symbol->Other = WeakDefault; 446 } 447 448 // Setup the Weak External auxiliary symbol. 449 coff_symbol->Aux.resize(1); 450 memset(&coff_symbol->Aux[0], 0, sizeof(coff_symbol->Aux[0])); 451 coff_symbol->Aux[0].AuxType = ATWeakExternal; 452 coff_symbol->Aux[0].Aux.WeakExternal.TagIndex = 0; 453 coff_symbol->Aux[0].Aux.WeakExternal.Characteristics = 454 COFF::IMAGE_WEAK_EXTERN_SEARCH_LIBRARY; 455 } 456 457 // If no storage class was specified in the streamer, define it here. 458 if (coff_symbol->Data.StorageClass == 0) { 459 bool external = SymbolData.isExternal() || (SymbolData.Fragment == NULL); 460 461 coff_symbol->Data.StorageClass = 462 external ? COFF::IMAGE_SYM_CLASS_EXTERNAL : COFF::IMAGE_SYM_CLASS_STATIC; 463 } 464 465 if (SymbolData.Fragment != NULL) 466 coff_symbol->Section = 467 SectionMap[&SymbolData.Fragment->getParent()->getSection()]; 468 469 // Bind internal COFF symbol to MC symbol. 470 coff_symbol->MCData = &SymbolData; 471 SymbolMap[&SymbolData.getSymbol()] = coff_symbol; 472 } 473 474 /// making a section real involves assigned it a number and putting 475 /// name into the string table if needed 476 void WinCOFFObjectWriter::MakeSectionReal(COFFSection &S, size_t Number) { 477 if (S.Name.size() > COFF::NameSize) { 478 size_t StringTableEntry = Strings.insert(S.Name.c_str()); 479 480 // FIXME: Why is this number 999999? This number is never mentioned in the 481 // spec. I'm assuming this is due to the printed value needing to fit into 482 // the S.Header.Name field. In which case why not 9999999 (7 9's instead of 483 // 6)? The spec does not state if this entry should be null terminated in 484 // this case, and thus this seems to be the best way to do it. I think I 485 // just solved my own FIXME... 486 if (StringTableEntry > 999999) 487 report_fatal_error("COFF string table is greater than 999999 bytes."); 488 489 std::sprintf(S.Header.Name, "/%d", unsigned(StringTableEntry)); 490 } else 491 std::memcpy(S.Header.Name, S.Name.c_str(), S.Name.size()); 492 493 S.Number = Number; 494 S.Symbol->Data.SectionNumber = S.Number; 495 S.Symbol->Aux[0].Aux.SectionDefinition.Number = S.Number; 496 } 497 498 void WinCOFFObjectWriter::MakeSymbolReal(COFFSymbol &S, size_t Index) { 499 if (S.Name.size() > COFF::NameSize) { 500 size_t StringTableEntry = Strings.insert(S.Name.c_str()); 501 502 S.set_name_offset(StringTableEntry); 503 } else 504 std::memcpy(S.Data.Name, S.Name.c_str(), S.Name.size()); 505 S.Index = Index; 506 } 507 508 bool WinCOFFObjectWriter::ExportSection(COFFSection const *S) { 509 return !S->MCData->getFragmentList().empty(); 510 } 511 512 bool WinCOFFObjectWriter::ExportSymbol(MCSymbolData const &SymbolData, 513 MCAssembler &Asm) { 514 // This doesn't seem to be right. Strings referred to from the .data section 515 // need symbols so they can be linked to code in the .text section right? 516 517 // return Asm.isSymbolLinkerVisible (&SymbolData); 518 519 // For now, all non-variable symbols are exported, 520 // the linker will sort the rest out for us. 521 return SymbolData.isExternal() || !SymbolData.getSymbol().isVariable(); 522 } 523 524 bool WinCOFFObjectWriter::IsPhysicalSection(COFFSection *S) { 525 return (S->Header.Characteristics 526 & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) == 0; 527 } 528 529 //------------------------------------------------------------------------------ 530 // entity writing methods 531 532 void WinCOFFObjectWriter::WriteFileHeader(const COFF::header &Header) { 533 WriteLE16(Header.Machine); 534 WriteLE16(Header.NumberOfSections); 535 WriteLE32(Header.TimeDateStamp); 536 WriteLE32(Header.PointerToSymbolTable); 537 WriteLE32(Header.NumberOfSymbols); 538 WriteLE16(Header.SizeOfOptionalHeader); 539 WriteLE16(Header.Characteristics); 540 } 541 542 void WinCOFFObjectWriter::WriteSymbol(const COFFSymbol *S) { 543 WriteBytes(StringRef(S->Data.Name, COFF::NameSize)); 544 WriteLE32(S->Data.Value); 545 WriteLE16(S->Data.SectionNumber); 546 WriteLE16(S->Data.Type); 547 Write8(S->Data.StorageClass); 548 Write8(S->Data.NumberOfAuxSymbols); 549 WriteAuxiliarySymbols(S->Aux); 550 } 551 552 void WinCOFFObjectWriter::WriteAuxiliarySymbols( 553 const COFFSymbol::AuxiliarySymbols &S) { 554 for(COFFSymbol::AuxiliarySymbols::const_iterator i = S.begin(), e = S.end(); 555 i != e; ++i) { 556 switch(i->AuxType) { 557 case ATFunctionDefinition: 558 WriteLE32(i->Aux.FunctionDefinition.TagIndex); 559 WriteLE32(i->Aux.FunctionDefinition.TotalSize); 560 WriteLE32(i->Aux.FunctionDefinition.PointerToLinenumber); 561 WriteLE32(i->Aux.FunctionDefinition.PointerToNextFunction); 562 WriteZeros(sizeof(i->Aux.FunctionDefinition.unused)); 563 break; 564 case ATbfAndefSymbol: 565 WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused1)); 566 WriteLE16(i->Aux.bfAndefSymbol.Linenumber); 567 WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused2)); 568 WriteLE32(i->Aux.bfAndefSymbol.PointerToNextFunction); 569 WriteZeros(sizeof(i->Aux.bfAndefSymbol.unused3)); 570 break; 571 case ATWeakExternal: 572 WriteLE32(i->Aux.WeakExternal.TagIndex); 573 WriteLE32(i->Aux.WeakExternal.Characteristics); 574 WriteZeros(sizeof(i->Aux.WeakExternal.unused)); 575 break; 576 case ATFile: 577 WriteBytes(StringRef(reinterpret_cast<const char *>(i->Aux.File.FileName), 578 sizeof(i->Aux.File.FileName))); 579 break; 580 case ATSectionDefinition: 581 WriteLE32(i->Aux.SectionDefinition.Length); 582 WriteLE16(i->Aux.SectionDefinition.NumberOfRelocations); 583 WriteLE16(i->Aux.SectionDefinition.NumberOfLinenumbers); 584 WriteLE32(i->Aux.SectionDefinition.CheckSum); 585 WriteLE16(i->Aux.SectionDefinition.Number); 586 Write8(i->Aux.SectionDefinition.Selection); 587 WriteZeros(sizeof(i->Aux.SectionDefinition.unused)); 588 break; 589 } 590 } 591 } 592 593 void WinCOFFObjectWriter::WriteSectionHeader(const COFF::section &S) { 594 WriteBytes(StringRef(S.Name, COFF::NameSize)); 595 596 WriteLE32(S.VirtualSize); 597 WriteLE32(S.VirtualAddress); 598 WriteLE32(S.SizeOfRawData); 599 WriteLE32(S.PointerToRawData); 600 WriteLE32(S.PointerToRelocations); 601 WriteLE32(S.PointerToLineNumbers); 602 WriteLE16(S.NumberOfRelocations); 603 WriteLE16(S.NumberOfLineNumbers); 604 WriteLE32(S.Characteristics); 605 } 606 607 void WinCOFFObjectWriter::WriteRelocation(const COFF::relocation &R) { 608 WriteLE32(R.VirtualAddress); 609 WriteLE32(R.SymbolTableIndex); 610 WriteLE16(R.Type); 611 } 612 613 //////////////////////////////////////////////////////////////////////////////// 614 // MCObjectWriter interface implementations 615 616 void WinCOFFObjectWriter::ExecutePostLayoutBinding(MCAssembler &Asm, 617 const MCAsmLayout &Layout) { 618 // "Define" each section & symbol. This creates section & symbol 619 // entries in the staging area. 620 621 for (MCAssembler::const_iterator i = Asm.begin(), e = Asm.end(); i != e; i++) 622 DefineSection(*i); 623 624 for (MCAssembler::const_symbol_iterator i = Asm.symbol_begin(), 625 e = Asm.symbol_end(); i != e; i++) { 626 if (ExportSymbol(*i, Asm)) 627 DefineSymbol(*i, Asm); 628 } 629 } 630 631 void WinCOFFObjectWriter::RecordRelocation(const MCAssembler &Asm, 632 const MCAsmLayout &Layout, 633 const MCFragment *Fragment, 634 const MCFixup &Fixup, 635 MCValue Target, 636 uint64_t &FixedValue) { 637 assert(Target.getSymA() != NULL && "Relocation must reference a symbol!"); 638 639 const MCSymbol *A = &Target.getSymA()->getSymbol(); 640 MCSymbolData &A_SD = Asm.getSymbolData(*A); 641 642 MCSectionData const *SectionData = Fragment->getParent(); 643 644 // Mark this symbol as requiring an entry in the symbol table. 645 assert(SectionMap.find(&SectionData->getSection()) != SectionMap.end() && 646 "Section must already have been defined in ExecutePostLayoutBinding!"); 647 assert(SymbolMap.find(&A_SD.getSymbol()) != SymbolMap.end() && 648 "Symbol must already have been defined in ExecutePostLayoutBinding!"); 649 650 COFFSection *coff_section = SectionMap[&SectionData->getSection()]; 651 COFFSymbol *coff_symbol = SymbolMap[&A_SD.getSymbol()]; 652 const MCSymbolRefExpr *SymA = Target.getSymA(); 653 const MCSymbolRefExpr *SymB = Target.getSymB(); 654 const bool CrossSection = SymB && 655 &SymA->getSymbol().getSection() != &SymB->getSymbol().getSection(); 656 657 if (Target.getSymB()) { 658 const MCSymbol *B = &Target.getSymB()->getSymbol(); 659 MCSymbolData &B_SD = Asm.getSymbolData(*B); 660 661 // Offset of the symbol in the section 662 int64_t a = Layout.getSymbolOffset(&B_SD); 663 664 // Ofeset of the relocation in the section 665 int64_t b = Layout.getFragmentOffset(Fragment) + Fixup.getOffset(); 666 667 FixedValue = b - a; 668 // In the case where we have SymbA and SymB, we just need to store the delta 669 // between the two symbols. Update FixedValue to account for the delta, and 670 // skip recording the relocation. 671 if (!CrossSection) 672 return; 673 } else { 674 FixedValue = Target.getConstant(); 675 } 676 677 COFFRelocation Reloc; 678 679 Reloc.Data.SymbolTableIndex = 0; 680 Reloc.Data.VirtualAddress = Layout.getFragmentOffset(Fragment); 681 682 // Turn relocations for temporary symbols into section relocations. 683 if (coff_symbol->MCData->getSymbol().isTemporary() || CrossSection) { 684 Reloc.Symb = coff_symbol->Section->Symbol; 685 FixedValue += Layout.getFragmentOffset(coff_symbol->MCData->Fragment) 686 + coff_symbol->MCData->getOffset(); 687 } else 688 Reloc.Symb = coff_symbol; 689 690 ++Reloc.Symb->Relocations; 691 692 Reloc.Data.VirtualAddress += Fixup.getOffset(); 693 694 unsigned FixupKind = Fixup.getKind(); 695 696 if (CrossSection) 697 FixupKind = FK_PCRel_4; 698 699 Reloc.Data.Type = TargetObjectWriter->getRelocType(FixupKind); 700 701 // FIXME: Can anyone explain what this does other than adjust for the size 702 // of the offset? 703 if (Reloc.Data.Type == COFF::IMAGE_REL_AMD64_REL32 || 704 Reloc.Data.Type == COFF::IMAGE_REL_I386_REL32) 705 FixedValue += 4; 706 707 coff_section->Relocations.push_back(Reloc); 708 } 709 710 void WinCOFFObjectWriter::WriteObject(MCAssembler &Asm, 711 const MCAsmLayout &Layout) { 712 // Assign symbol and section indexes and offsets. 713 Header.NumberOfSections = 0; 714 715 for (sections::iterator i = Sections.begin(), 716 e = Sections.end(); i != e; i++) { 717 if (Layout.getSectionAddressSize((*i)->MCData) > 0) { 718 MakeSectionReal(**i, ++Header.NumberOfSections); 719 } else { 720 (*i)->Number = -1; 721 } 722 } 723 724 Header.NumberOfSymbols = 0; 725 726 for (symbols::iterator i = Symbols.begin(), e = Symbols.end(); i != e; i++) { 727 COFFSymbol *coff_symbol = *i; 728 MCSymbolData const *SymbolData = coff_symbol->MCData; 729 730 // Update section number & offset for symbols that have them. 731 if ((SymbolData != NULL) && (SymbolData->Fragment != NULL)) { 732 assert(coff_symbol->Section != NULL); 733 734 coff_symbol->Data.SectionNumber = coff_symbol->Section->Number; 735 coff_symbol->Data.Value = Layout.getFragmentOffset(SymbolData->Fragment) 736 + SymbolData->Offset; 737 } 738 739 if (coff_symbol->should_keep()) { 740 MakeSymbolReal(*coff_symbol, Header.NumberOfSymbols++); 741 742 // Update auxiliary symbol info. 743 coff_symbol->Data.NumberOfAuxSymbols = coff_symbol->Aux.size(); 744 Header.NumberOfSymbols += coff_symbol->Data.NumberOfAuxSymbols; 745 } else 746 coff_symbol->Index = -1; 747 } 748 749 // Fixup weak external references. 750 for (symbols::iterator i = Symbols.begin(), e = Symbols.end(); i != e; i++) { 751 COFFSymbol *coff_symbol = *i; 752 if (coff_symbol->Other != NULL) { 753 assert(coff_symbol->Index != -1); 754 assert(coff_symbol->Aux.size() == 1 && 755 "Symbol must contain one aux symbol!"); 756 assert(coff_symbol->Aux[0].AuxType == ATWeakExternal && 757 "Symbol's aux symbol must be a Weak External!"); 758 coff_symbol->Aux[0].Aux.WeakExternal.TagIndex = coff_symbol->Other->Index; 759 } 760 } 761 762 // Assign file offsets to COFF object file structures. 763 764 unsigned offset = 0; 765 766 offset += COFF::HeaderSize; 767 offset += COFF::SectionSize * Header.NumberOfSections; 768 769 for (MCAssembler::const_iterator i = Asm.begin(), 770 e = Asm.end(); 771 i != e; i++) { 772 COFFSection *Sec = SectionMap[&i->getSection()]; 773 774 if (Sec->Number == -1) 775 continue; 776 777 Sec->Header.SizeOfRawData = Layout.getSectionAddressSize(i); 778 779 if (IsPhysicalSection(Sec)) { 780 Sec->Header.PointerToRawData = offset; 781 782 offset += Sec->Header.SizeOfRawData; 783 } 784 785 if (Sec->Relocations.size() > 0) { 786 bool RelocationsOverflow = Sec->Relocations.size() >= 0xffff; 787 788 if (RelocationsOverflow) { 789 // Signal overflow by setting NumberOfSections to max value. Actual 790 // size is found in reloc #0. Microsoft tools understand this. 791 Sec->Header.NumberOfRelocations = 0xffff; 792 } else { 793 Sec->Header.NumberOfRelocations = Sec->Relocations.size(); 794 } 795 Sec->Header.PointerToRelocations = offset; 796 797 if (RelocationsOverflow) { 798 // Reloc #0 will contain actual count, so make room for it. 799 offset += COFF::RelocationSize; 800 } 801 802 offset += COFF::RelocationSize * Sec->Relocations.size(); 803 804 for (relocations::iterator cr = Sec->Relocations.begin(), 805 er = Sec->Relocations.end(); 806 cr != er; ++cr) { 807 assert((*cr).Symb->Index != -1); 808 (*cr).Data.SymbolTableIndex = (*cr).Symb->Index; 809 } 810 } 811 812 assert(Sec->Symbol->Aux.size() == 1 813 && "Section's symbol must have one aux!"); 814 AuxSymbol &Aux = Sec->Symbol->Aux[0]; 815 assert(Aux.AuxType == ATSectionDefinition && 816 "Section's symbol's aux symbol must be a Section Definition!"); 817 Aux.Aux.SectionDefinition.Length = Sec->Header.SizeOfRawData; 818 Aux.Aux.SectionDefinition.NumberOfRelocations = 819 Sec->Header.NumberOfRelocations; 820 Aux.Aux.SectionDefinition.NumberOfLinenumbers = 821 Sec->Header.NumberOfLineNumbers; 822 } 823 824 Header.PointerToSymbolTable = offset; 825 826 Header.TimeDateStamp = sys::TimeValue::now().toEpochTime(); 827 828 // Write it all to disk... 829 WriteFileHeader(Header); 830 831 { 832 sections::iterator i, ie; 833 MCAssembler::const_iterator j, je; 834 835 for (i = Sections.begin(), ie = Sections.end(); i != ie; i++) 836 if ((*i)->Number != -1) { 837 if ((*i)->Relocations.size() >= 0xffff) { 838 (*i)->Header.Characteristics |= COFF::IMAGE_SCN_LNK_NRELOC_OVFL; 839 } 840 WriteSectionHeader((*i)->Header); 841 } 842 843 for (i = Sections.begin(), ie = Sections.end(), 844 j = Asm.begin(), je = Asm.end(); 845 (i != ie) && (j != je); ++i, ++j) { 846 847 if ((*i)->Number == -1) 848 continue; 849 850 if ((*i)->Header.PointerToRawData != 0) { 851 assert(OS.tell() == (*i)->Header.PointerToRawData && 852 "Section::PointerToRawData is insane!"); 853 854 Asm.writeSectionData(j, Layout); 855 } 856 857 if ((*i)->Relocations.size() > 0) { 858 assert(OS.tell() == (*i)->Header.PointerToRelocations && 859 "Section::PointerToRelocations is insane!"); 860 861 if ((*i)->Relocations.size() >= 0xffff) { 862 // In case of overflow, write actual relocation count as first 863 // relocation. Including the synthetic reloc itself (+ 1). 864 COFF::relocation r; 865 r.VirtualAddress = (*i)->Relocations.size() + 1; 866 r.SymbolTableIndex = 0; 867 r.Type = 0; 868 WriteRelocation(r); 869 } 870 871 for (relocations::const_iterator k = (*i)->Relocations.begin(), 872 ke = (*i)->Relocations.end(); 873 k != ke; k++) { 874 WriteRelocation(k->Data); 875 } 876 } else 877 assert((*i)->Header.PointerToRelocations == 0 && 878 "Section::PointerToRelocations is insane!"); 879 } 880 } 881 882 assert(OS.tell() == Header.PointerToSymbolTable && 883 "Header::PointerToSymbolTable is insane!"); 884 885 for (symbols::iterator i = Symbols.begin(), e = Symbols.end(); i != e; i++) 886 if ((*i)->Index != -1) 887 WriteSymbol(*i); 888 889 OS.write((char const *)&Strings.Data.front(), Strings.Data.size()); 890 } 891 892 MCWinCOFFObjectTargetWriter::MCWinCOFFObjectTargetWriter(unsigned Machine_) : 893 Machine(Machine_) { 894 } 895 896 //------------------------------------------------------------------------------ 897 // WinCOFFObjectWriter factory function 898 899 namespace llvm { 900 MCObjectWriter *createWinCOFFObjectWriter(MCWinCOFFObjectTargetWriter *MOTW, 901 raw_ostream &OS) { 902 return new WinCOFFObjectWriter(MOTW, OS); 903 } 904 } 905
