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 Windows COFF object file streamer.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/MC/MCAsmBackend.h"
15 #include "llvm/MC/MCAsmLayout.h"
16 #include "llvm/MC/MCAssembler.h"
17 #include "llvm/MC/MCCodeEmitter.h"
18 #include "llvm/MC/MCContext.h"
19 #include "llvm/MC/MCExpr.h"
20 #include "llvm/MC/MCObjectFileInfo.h"
21 #include "llvm/MC/MCObjectStreamer.h"
22 #include "llvm/MC/MCSection.h"
23 #include "llvm/MC/MCSectionCOFF.h"
24 #include "llvm/MC/MCStreamer.h"
25 #include "llvm/MC/MCSymbolCOFF.h"
26 #include "llvm/MC/MCValue.h"
27 #include "llvm/MC/MCWinCOFFStreamer.h"
28 #include "llvm/Support/COFF.h"
29 #include "llvm/Support/Debug.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/MathExtras.h"
32 #include "llvm/Support/TargetRegistry.h"
33 #include "llvm/Support/raw_ostream.h"
34 
35 using namespace llvm;
36 
37 #define DEBUG_TYPE "WinCOFFStreamer"
38 
39 namespace llvm {
MCWinCOFFStreamer(MCContext & Context,MCAsmBackend & MAB,MCCodeEmitter & CE,raw_pwrite_stream & OS)40 MCWinCOFFStreamer::MCWinCOFFStreamer(MCContext &Context, MCAsmBackend &MAB,
41                                      MCCodeEmitter &CE, raw_pwrite_stream &OS)
42     : MCObjectStreamer(Context, MAB, OS, &CE), CurSymbol(nullptr) {}
43 
EmitInstToData(const MCInst & Inst,const MCSubtargetInfo & STI)44 void MCWinCOFFStreamer::EmitInstToData(const MCInst &Inst,
45                                        const MCSubtargetInfo &STI) {
46   MCDataFragment *DF = getOrCreateDataFragment();
47 
48   SmallVector<MCFixup, 4> Fixups;
49   SmallString<256> Code;
50   raw_svector_ostream VecOS(Code);
51   getAssembler().getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
52 
53   // Add the fixups and data.
54   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
55     Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
56     DF->getFixups().push_back(Fixups[i]);
57   }
58 
59   DF->getContents().append(Code.begin(), Code.end());
60 }
61 
InitSections(bool NoExecStack)62 void MCWinCOFFStreamer::InitSections(bool NoExecStack) {
63   // FIXME: this is identical to the ELF one.
64   // This emulates the same behavior of GNU as. This makes it easier
65   // to compare the output as the major sections are in the same order.
66   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
67   EmitCodeAlignment(4);
68 
69   SwitchSection(getContext().getObjectFileInfo()->getDataSection());
70   EmitCodeAlignment(4);
71 
72   SwitchSection(getContext().getObjectFileInfo()->getBSSSection());
73   EmitCodeAlignment(4);
74 
75   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
76 }
77 
EmitLabel(MCSymbol * S)78 void MCWinCOFFStreamer::EmitLabel(MCSymbol *S) {
79   auto *Symbol = cast<MCSymbolCOFF>(S);
80   assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
81   MCObjectStreamer::EmitLabel(Symbol);
82 }
83 
EmitAssemblerFlag(MCAssemblerFlag Flag)84 void MCWinCOFFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
85   llvm_unreachable("not implemented");
86 }
87 
EmitThumbFunc(MCSymbol * Func)88 void MCWinCOFFStreamer::EmitThumbFunc(MCSymbol *Func) {
89   llvm_unreachable("not implemented");
90 }
91 
EmitSymbolAttribute(MCSymbol * S,MCSymbolAttr Attribute)92 bool MCWinCOFFStreamer::EmitSymbolAttribute(MCSymbol *S,
93                                             MCSymbolAttr Attribute) {
94   auto *Symbol = cast<MCSymbolCOFF>(S);
95   getAssembler().registerSymbol(*Symbol);
96 
97   switch (Attribute) {
98   default: return false;
99   case MCSA_WeakReference:
100   case MCSA_Weak:
101     Symbol->setIsWeakExternal();
102     Symbol->setExternal(true);
103     break;
104   case MCSA_Global:
105     Symbol->setExternal(true);
106     break;
107   case MCSA_AltEntry:
108     llvm_unreachable("COFF doesn't support the .alt_entry attribute");
109   }
110 
111   return true;
112 }
113 
EmitSymbolDesc(MCSymbol * Symbol,unsigned DescValue)114 void MCWinCOFFStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
115   llvm_unreachable("not implemented");
116 }
117 
BeginCOFFSymbolDef(MCSymbol const * S)118 void MCWinCOFFStreamer::BeginCOFFSymbolDef(MCSymbol const *S) {
119   auto *Symbol = cast<MCSymbolCOFF>(S);
120   if (CurSymbol)
121     Error("starting a new symbol definition without completing the "
122           "previous one");
123   CurSymbol = Symbol;
124 }
125 
EmitCOFFSymbolStorageClass(int StorageClass)126 void MCWinCOFFStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {
127   if (!CurSymbol) {
128     Error("storage class specified outside of symbol definition");
129     return;
130   }
131 
132   if (StorageClass & ~COFF::SSC_Invalid) {
133     Error("storage class value '" + Twine(StorageClass) +
134                "' out of range");
135     return;
136   }
137 
138   getAssembler().registerSymbol(*CurSymbol);
139   cast<MCSymbolCOFF>(CurSymbol)->setClass((uint16_t)StorageClass);
140 }
141 
EmitCOFFSymbolType(int Type)142 void MCWinCOFFStreamer::EmitCOFFSymbolType(int Type) {
143   if (!CurSymbol) {
144     Error("symbol type specified outside of a symbol definition");
145     return;
146   }
147 
148   if (Type & ~0xffff) {
149     Error("type value '" + Twine(Type) + "' out of range");
150     return;
151   }
152 
153   getAssembler().registerSymbol(*CurSymbol);
154   cast<MCSymbolCOFF>(CurSymbol)->setType((uint16_t)Type);
155 }
156 
EndCOFFSymbolDef()157 void MCWinCOFFStreamer::EndCOFFSymbolDef() {
158   if (!CurSymbol)
159     Error("ending symbol definition without starting one");
160   CurSymbol = nullptr;
161 }
162 
EmitCOFFSafeSEH(MCSymbol const * Symbol)163 void MCWinCOFFStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {
164   // SafeSEH is a feature specific to 32-bit x86.  It does not exist (and is
165   // unnecessary) on all platforms which use table-based exception dispatch.
166   if (getContext().getObjectFileInfo()->getTargetTriple().getArch() !=
167       Triple::x86)
168     return;
169 
170   const MCSymbolCOFF *CSymbol = cast<MCSymbolCOFF>(Symbol);
171   if (CSymbol->isSafeSEH())
172     return;
173 
174   MCSection *SXData = getContext().getObjectFileInfo()->getSXDataSection();
175   getAssembler().registerSection(*SXData);
176   if (SXData->getAlignment() < 4)
177     SXData->setAlignment(4);
178 
179   new MCSafeSEHFragment(Symbol, SXData);
180 
181   getAssembler().registerSymbol(*Symbol);
182   CSymbol->setIsSafeSEH();
183 
184   // The Microsoft linker requires that the symbol type of a handler be
185   // function. Go ahead and oblige it here.
186   CSymbol->setType(COFF::IMAGE_SYM_DTYPE_FUNCTION
187                    << COFF::SCT_COMPLEX_TYPE_SHIFT);
188 }
189 
EmitCOFFSectionIndex(MCSymbol const * Symbol)190 void MCWinCOFFStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
191   MCDataFragment *DF = getOrCreateDataFragment();
192   const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(Symbol, getContext());
193   MCFixup Fixup = MCFixup::create(DF->getContents().size(), SRE, FK_SecRel_2);
194   DF->getFixups().push_back(Fixup);
195   DF->getContents().resize(DF->getContents().size() + 2, 0);
196 }
197 
EmitCOFFSecRel32(MCSymbol const * Symbol)198 void MCWinCOFFStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
199   MCDataFragment *DF = getOrCreateDataFragment();
200   const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(Symbol, getContext());
201   MCFixup Fixup = MCFixup::create(DF->getContents().size(), SRE, FK_SecRel_4);
202   DF->getFixups().push_back(Fixup);
203   DF->getContents().resize(DF->getContents().size() + 4, 0);
204 }
205 
EmitCommonSymbol(MCSymbol * S,uint64_t Size,unsigned ByteAlignment)206 void MCWinCOFFStreamer::EmitCommonSymbol(MCSymbol *S, uint64_t Size,
207                                          unsigned ByteAlignment) {
208   auto *Symbol = cast<MCSymbolCOFF>(S);
209 
210   const Triple &T = getContext().getObjectFileInfo()->getTargetTriple();
211   if (T.isKnownWindowsMSVCEnvironment()) {
212     if (ByteAlignment > 32)
213       report_fatal_error("alignment is limited to 32-bytes");
214 
215     // Round size up to alignment so that we will honor the alignment request.
216     Size = std::max(Size, static_cast<uint64_t>(ByteAlignment));
217   }
218 
219   getAssembler().registerSymbol(*Symbol);
220   Symbol->setExternal(true);
221   Symbol->setCommon(Size, ByteAlignment);
222 
223   if (!T.isKnownWindowsMSVCEnvironment() && ByteAlignment > 1) {
224     SmallString<128> Directive;
225     raw_svector_ostream OS(Directive);
226     const MCObjectFileInfo *MFI = getContext().getObjectFileInfo();
227 
228     OS << " -aligncomm:\"" << Symbol->getName() << "\","
229        << Log2_32_Ceil(ByteAlignment);
230 
231     PushSection();
232     SwitchSection(MFI->getDrectveSection());
233     EmitBytes(Directive);
234     PopSection();
235   }
236 }
237 
EmitLocalCommonSymbol(MCSymbol * S,uint64_t Size,unsigned ByteAlignment)238 void MCWinCOFFStreamer::EmitLocalCommonSymbol(MCSymbol *S, uint64_t Size,
239                                               unsigned ByteAlignment) {
240   auto *Symbol = cast<MCSymbolCOFF>(S);
241 
242   MCSection *Section = getContext().getObjectFileInfo()->getBSSSection();
243   getAssembler().registerSection(*Section);
244   if (Section->getAlignment() < ByteAlignment)
245     Section->setAlignment(ByteAlignment);
246 
247   getAssembler().registerSymbol(*Symbol);
248   Symbol->setExternal(false);
249 
250   if (ByteAlignment != 1)
251     new MCAlignFragment(ByteAlignment, /*Value=*/0, /*ValueSize=*/0,
252                         ByteAlignment, Section);
253 
254   MCFillFragment *Fragment = new MCFillFragment(
255       /*Value=*/0, Size, Section);
256   Symbol->setFragment(Fragment);
257 }
258 
EmitZerofill(MCSection * Section,MCSymbol * Symbol,uint64_t Size,unsigned ByteAlignment)259 void MCWinCOFFStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol,
260                                      uint64_t Size, unsigned ByteAlignment) {
261   llvm_unreachable("not implemented");
262 }
263 
EmitTBSSSymbol(MCSection * Section,MCSymbol * Symbol,uint64_t Size,unsigned ByteAlignment)264 void MCWinCOFFStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
265                                        uint64_t Size, unsigned ByteAlignment) {
266   llvm_unreachable("not implemented");
267 }
268 
EmitFileDirective(StringRef Filename)269 void MCWinCOFFStreamer::EmitFileDirective(StringRef Filename) {
270   getAssembler().addFileName(Filename);
271 }
272 
273 // TODO: Implement this if you want to emit .comment section in COFF obj files.
EmitIdent(StringRef IdentString)274 void MCWinCOFFStreamer::EmitIdent(StringRef IdentString) {
275   llvm_unreachable("not implemented");
276 }
277 
EmitWinEHHandlerData()278 void MCWinCOFFStreamer::EmitWinEHHandlerData() {
279   llvm_unreachable("not implemented");
280 }
281 
FinishImpl()282 void MCWinCOFFStreamer::FinishImpl() {
283   MCObjectStreamer::FinishImpl();
284 }
285 
Error(const Twine & Msg) const286 void MCWinCOFFStreamer::Error(const Twine &Msg) const {
287   getContext().reportError(SMLoc(), Msg);
288 }
289 }
290 
291