lib/MC/WinCOFFStreamer.cpp

   1 //===-- llvm/MC/WinCOFFStreamer.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 streamer.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "WinCOFFStreamer"
  15
  16 #include "llvm/MC/MCStreamer.h"
  17 #include "llvm/MC/MCAsmBackend.h"
  18 #include "llvm/MC/MCAsmLayout.h"
  19 #include "llvm/MC/MCAssembler.h"
  20 #include "llvm/MC/MCCodeEmitter.h"
  21 #include "llvm/MC/MCContext.h"
  22 #include "llvm/MC/MCExpr.h"
  23 #include "llvm/MC/MCObjectFileInfo.h"
  24 #include "llvm/MC/MCObjectStreamer.h"
  25 #include "llvm/MC/MCSection.h"
  26 #include "llvm/MC/MCSectionCOFF.h"
  27 #include "llvm/MC/MCSymbol.h"
  28 #include "llvm/MC/MCValue.h"
  29 #include "llvm/MC/MCWin64EH.h"
  30 #include "llvm/Support/COFF.h"
  31 #include "llvm/Support/Debug.h"
  32 #include "llvm/Support/ErrorHandling.h"
  33 #include "llvm/Support/TargetRegistry.h"
  34 #include "llvm/Support/raw_ostream.h"
  35
  36 using namespace llvm;
  37
  38 namespace {
  39 class WinCOFFStreamer : public MCObjectStreamer {
  40 public:
  41   MCSymbol const *CurSymbol;
  42
  43   WinCOFFStreamer(MCContext &Context,
  44                   MCAsmBackend &MAB,
  45                   MCCodeEmitter &CE,
  46                   raw_ostream &OS);
  47
  48   // MCStreamer interface
  49
  50   void InitSections() override;
  51   void EmitLabel(MCSymbol *Symbol) override;
  52   void EmitDebugLabel(MCSymbol *Symbol) override;
  53   void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
  54   void EmitThumbFunc(MCSymbol *Func) override;
  55   bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
  56   void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
  57   void BeginCOFFSymbolDef(MCSymbol const *Symbol) override;
  58   void EmitCOFFSymbolStorageClass(int StorageClass) override;
  59   void EmitCOFFSymbolType(int Type) override;
  60   void EndCOFFSymbolDef() override;
  61   void EmitCOFFSectionIndex(MCSymbol const *Symbol) override;
  62   void EmitCOFFSecRel32(MCSymbol const *Symbol) override;
  63   void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
  64   void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
  65                         unsigned ByteAlignment) override;
  66   void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
  67                              unsigned ByteAlignment) override;
  68   void EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
  69                     uint64_t Size,unsigned ByteAlignment) override;
  70   void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
  71                       uint64_t Size, unsigned ByteAlignment) override;
  72   void EmitFileDirective(StringRef Filename) override;
  73   void EmitIdent(StringRef IdentString) override;
  74   void EmitWin64EHHandlerData() override;
  75   void FinishImpl() override;
  76
  77 private:
  78   void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &STI) override {
  79     MCDataFragment *DF = getOrCreateDataFragment();
  80
  81     SmallVector<MCFixup, 4> Fixups;
  82     SmallString<256> Code;
  83     raw_svector_ostream VecOS(Code);
  84     getAssembler().getEmitter().EncodeInstruction(Inst, VecOS, Fixups, STI);
  85     VecOS.flush();
  86
  87     // Add the fixups and data.
  88     for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
  89       Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
  90       DF->getFixups().push_back(Fixups[i]);
  91     }
  92     DF->getContents().append(Code.begin(), Code.end());
  93   }
  94 };
  95 } // end anonymous namespace.
  96
  97 WinCOFFStreamer::WinCOFFStreamer(MCContext &Context, MCAsmBackend &MAB,
  98                                  MCCodeEmitter &CE, raw_ostream &OS)
  99     : MCObjectStreamer(Context, MAB, OS, &CE), CurSymbol(NULL) {}
 100
 101 // MCStreamer interface
 102
 103 void WinCOFFStreamer::InitSections() {
 104   // FIXME: this is identical to the ELF one.
 105   // This emulates the same behavior of GNU as. This makes it easier
 106   // to compare the output as the major sections are in the same order.
 107   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
 108   EmitCodeAlignment(4);
 109
 110   SwitchSection(getContext().getObjectFileInfo()->getDataSection());
 111   EmitCodeAlignment(4);
 112
 113   SwitchSection(getContext().getObjectFileInfo()->getBSSSection());
 114   EmitCodeAlignment(4);
 115
 116   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
 117 }
 118
 119 void WinCOFFStreamer::EmitLabel(MCSymbol *Symbol) {
 120   assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
 121   MCObjectStreamer::EmitLabel(Symbol);
 122 }
 123
 124 void WinCOFFStreamer::EmitDebugLabel(MCSymbol *Symbol) {
 125   EmitLabel(Symbol);
 126 }
 127 void WinCOFFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
 128   llvm_unreachable("not implemented");
 129 }
 130
 131 void WinCOFFStreamer::EmitThumbFunc(MCSymbol *Func) {
 132   llvm_unreachable("not implemented");
 133 }
 134
 135 bool WinCOFFStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
 136                                           MCSymbolAttr Attribute) {
 137   assert(Symbol && "Symbol must be non-null!");
 138   assert((Symbol->isInSection()
 139          ? Symbol->getSection().getVariant() == MCSection::SV_COFF
 140          : true) && "Got non-COFF section in the COFF backend!");
 141   switch (Attribute) {
 142   case MCSA_WeakReference:
 143   case MCSA_Weak: {
 144       MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
 145       SD.modifyFlags(COFF::SF_WeakExternal, COFF::SF_WeakExternal);
 146       SD.setExternal(true);
 147     }
 148     break;
 149
 150   case MCSA_Global:
 151     getAssembler().getOrCreateSymbolData(*Symbol).setExternal(true);
 152     break;
 153
 154   default:
 155     return false;
 156   }
 157
 158   return true;
 159 }
 160
 161 void WinCOFFStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
 162   llvm_unreachable("not implemented");
 163 }
 164
 165 void WinCOFFStreamer::BeginCOFFSymbolDef(MCSymbol const *Symbol) {
 166   assert((Symbol->isInSection()
 167          ? Symbol->getSection().getVariant() == MCSection::SV_COFF
 168          : true) && "Got non-COFF section in the COFF backend!");
 169   assert(CurSymbol == NULL && "EndCOFFSymbolDef must be called between calls "
 170                               "to BeginCOFFSymbolDef!");
 171   CurSymbol = Symbol;
 172 }
 173
 174 void WinCOFFStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {
 175   assert(CurSymbol != NULL && "BeginCOFFSymbolDef must be called first!");
 176   assert((StorageClass & ~0xFF) == 0 && "StorageClass must only have data in "
 177                                         "the first byte!");
 178
 179   getAssembler().getOrCreateSymbolData(*CurSymbol).modifyFlags(
 180     StorageClass << COFF::SF_ClassShift,
 181     COFF::SF_ClassMask);
 182 }
 183
 184 void WinCOFFStreamer::EmitCOFFSymbolType(int Type) {
 185   assert(CurSymbol != NULL && "BeginCOFFSymbolDef must be called first!");
 186   assert((Type & ~0xFFFF) == 0 && "Type must only have data in the first 2 "
 187                                   "bytes");
 188
 189   getAssembler().getOrCreateSymbolData(*CurSymbol).modifyFlags(
 190     Type << COFF::SF_TypeShift,
 191     COFF::SF_TypeMask);
 192 }
 193
 194 void WinCOFFStreamer::EndCOFFSymbolDef() {
 195   assert(CurSymbol != NULL && "BeginCOFFSymbolDef must be called first!");
 196   CurSymbol = NULL;
 197 }
 198
 199 void WinCOFFStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
 200   MCDataFragment *DF = getOrCreateDataFragment();
 201   DF->getFixups().push_back(MCFixup::Create(
 202       DF->getContents().size(), MCSymbolRefExpr::Create(Symbol, getContext()),
 203       FK_SecRel_2));
 204   DF->getContents().resize(DF->getContents().size() + 4, 0);
 205 }
 206
 207 void WinCOFFStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
 208   MCDataFragment *DF = getOrCreateDataFragment();
 209   DF->getFixups().push_back(MCFixup::Create(
 210       DF->getContents().size(), MCSymbolRefExpr::Create(Symbol, getContext()),
 211       FK_SecRel_4));
 212   DF->getContents().resize(DF->getContents().size() + 4, 0);
 213 }
 214
 215 void WinCOFFStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
 216   llvm_unreachable("not implemented");
 217 }
 218
 219 void WinCOFFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
 220                                        unsigned ByteAlignment) {
 221   assert((Symbol->isInSection()
 222          ? Symbol->getSection().getVariant() == MCSection::SV_COFF
 223          : true) && "Got non-COFF section in the COFF backend!");
 224
 225   if (ByteAlignment > 32)
 226     report_fatal_error(
 227         "The linker won't align common symbols beyond 32 bytes.");
 228
 229   AssignSection(Symbol, NULL);
 230
 231   MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
 232   SD.setExternal(true);
 233   SD.setCommon(Size, ByteAlignment);
 234 }
 235
 236 void WinCOFFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
 237                                             unsigned ByteAlignment) {
 238   assert(!Symbol->isInSection() && "Symbol must not already have a section!");
 239
 240   const MCSection *Section = getContext().getObjectFileInfo()->getBSSSection();
 241   MCSectionData &SectionData = getAssembler().getOrCreateSectionData(*Section);
 242   if (SectionData.getAlignment() < ByteAlignment)
 243     SectionData.setAlignment(ByteAlignment);
 244
 245   MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
 246   SD.setExternal(false);
 247
 248   AssignSection(Symbol, Section);
 249
 250   if (ByteAlignment != 1)
 251     new MCAlignFragment(ByteAlignment, /*_Value=*/0, /*_ValueSize=*/0,
 252                         ByteAlignment, &SectionData);
 253
 254   SD.setFragment(
 255       new MCFillFragment(/*_Value=*/0, /*_ValueSize=*/0, Size, &SectionData));
 256 }
 257
 258 void WinCOFFStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
 259                                    uint64_t Size,unsigned ByteAlignment) {
 260   llvm_unreachable("not implemented");
 261 }
 262
 263 void WinCOFFStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
 264                                      uint64_t Size, unsigned ByteAlignment) {
 265   llvm_unreachable("not implemented");
 266 }
 267
 268 void WinCOFFStreamer::EmitFileDirective(StringRef Filename) {
 269   // Ignore for now, linkers don't care, and proper debug
 270   // info will be a much large effort.
 271 }
 272
 273 // TODO: Implement this if you want to emit .comment section in COFF obj files.
 274 void WinCOFFStreamer::EmitIdent(StringRef IdentString) {
 275   llvm_unreachable("unsupported directive");
 276 }
 277
 278 void WinCOFFStreamer::EmitWin64EHHandlerData() {
 279   MCStreamer::EmitWin64EHHandlerData();
 280
 281   // We have to emit the unwind info now, because this directive
 282   // actually switches to the .xdata section!
 283   MCWin64EHUnwindEmitter::EmitUnwindInfo(*this, getCurrentW64UnwindInfo());
 284 }
 285
 286 void WinCOFFStreamer::FinishImpl() {
 287   EmitFrames(NULL, true);
 288   EmitW64Tables();
 289   MCObjectStreamer::FinishImpl();
 290 }
 291
 292 namespace llvm
 293 {
 294   MCStreamer *createWinCOFFStreamer(MCContext &Context,
 295                                     MCAsmBackend &MAB,
 296                                     MCCodeEmitter &CE,
 297                                     raw_ostream &OS,
 298                                     bool RelaxAll) {
 299     WinCOFFStreamer *S = new WinCOFFStreamer(Context, MAB, CE, OS);
 300     S->getAssembler().setRelaxAll(RelaxAll);
 301     return S;
 302   }
 303 }