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