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