1 //===- lib/MC/MCELFStreamer.cpp - ELF Object Output ------------===//
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 assembles .s files and emits ELF .o object files.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "MCELFStreamer.h"
15 #include "MCELF.h"
16 #include "llvm/MC/MCStreamer.h"
17 #include "llvm/MC/MCCodeEmitter.h"
18 #include "llvm/MC/MCELFSymbolFlags.h"
19 #include "llvm/MC/MCExpr.h"
20 #include "llvm/MC/MCInst.h"
21 #include "llvm/MC/MCSection.h"
22 #include "llvm/MC/MCSymbol.h"
23 #include "llvm/MC/MCValue.h"
24 #include "llvm/Support/Debug.h"
25 #include "llvm/Support/ELF.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include "llvm/Target/TargetAsmBackend.h"
29
30 using namespace llvm;
31
InitSections()32 void MCELFStreamer::InitSections() {
33 // This emulates the same behavior of GNU as. This makes it easier
34 // to compare the output as the major sections are in the same order.
35 SetSectionText();
36 SetSectionData();
37 SetSectionBss();
38 SetSectionText();
39 }
40
EmitLabel(MCSymbol * Symbol)41 void MCELFStreamer::EmitLabel(MCSymbol *Symbol) {
42 assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
43
44 MCObjectStreamer::EmitLabel(Symbol);
45
46 const MCSectionELF &Section =
47 static_cast<const MCSectionELF&>(Symbol->getSection());
48 MCSymbolData &SD = getAssembler().getSymbolData(*Symbol);
49 if (Section.getFlags() & ELF::SHF_TLS)
50 MCELF::SetType(SD, ELF::STT_TLS);
51 }
52
EmitAssemblerFlag(MCAssemblerFlag Flag)53 void MCELFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
54 switch (Flag) {
55 case MCAF_SyntaxUnified: return; // no-op here.
56 case MCAF_Code16: return; // no-op here.
57 case MCAF_Code32: return; // no-op here.
58 case MCAF_SubsectionsViaSymbols:
59 getAssembler().setSubsectionsViaSymbols(true);
60 return;
61 }
62
63 assert(0 && "invalid assembler flag!");
64 }
65
EmitThumbFunc(MCSymbol * Func)66 void MCELFStreamer::EmitThumbFunc(MCSymbol *Func) {
67 // FIXME: Anything needed here to flag the function as thumb?
68
69 getAssembler().setIsThumbFunc(Func);
70
71 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Func);
72 SD.setFlags(SD.getFlags() | ELF_Other_ThumbFunc);
73 }
74
EmitAssignment(MCSymbol * Symbol,const MCExpr * Value)75 void MCELFStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
76 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
77 // MCObjectStreamer.
78 // FIXME: Lift context changes into super class.
79 getAssembler().getOrCreateSymbolData(*Symbol);
80 Symbol->setVariableValue(AddValueSymbols(Value));
81 }
82
ChangeSection(const MCSection * Section)83 void MCELFStreamer::ChangeSection(const MCSection *Section) {
84 const MCSymbol *Grp = static_cast<const MCSectionELF *>(Section)->getGroup();
85 if (Grp)
86 getAssembler().getOrCreateSymbolData(*Grp);
87 this->MCObjectStreamer::ChangeSection(Section);
88 }
89
EmitWeakReference(MCSymbol * Alias,const MCSymbol * Symbol)90 void MCELFStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
91 getAssembler().getOrCreateSymbolData(*Symbol);
92 MCSymbolData &AliasSD = getAssembler().getOrCreateSymbolData(*Alias);
93 AliasSD.setFlags(AliasSD.getFlags() | ELF_Other_Weakref);
94 const MCExpr *Value = MCSymbolRefExpr::Create(Symbol, getContext());
95 Alias->setVariableValue(Value);
96 }
97
EmitSymbolAttribute(MCSymbol * Symbol,MCSymbolAttr Attribute)98 void MCELFStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
99 MCSymbolAttr Attribute) {
100 // Indirect symbols are handled differently, to match how 'as' handles
101 // them. This makes writing matching .o files easier.
102 if (Attribute == MCSA_IndirectSymbol) {
103 // Note that we intentionally cannot use the symbol data here; this is
104 // important for matching the string table that 'as' generates.
105 IndirectSymbolData ISD;
106 ISD.Symbol = Symbol;
107 ISD.SectionData = getCurrentSectionData();
108 getAssembler().getIndirectSymbols().push_back(ISD);
109 return;
110 }
111
112 // Adding a symbol attribute always introduces the symbol, note that an
113 // important side effect of calling getOrCreateSymbolData here is to register
114 // the symbol with the assembler.
115 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
116
117 // The implementation of symbol attributes is designed to match 'as', but it
118 // leaves much to desired. It doesn't really make sense to arbitrarily add and
119 // remove flags, but 'as' allows this (in particular, see .desc).
120 //
121 // In the future it might be worth trying to make these operations more well
122 // defined.
123 switch (Attribute) {
124 case MCSA_LazyReference:
125 case MCSA_Reference:
126 case MCSA_NoDeadStrip:
127 case MCSA_SymbolResolver:
128 case MCSA_PrivateExtern:
129 case MCSA_WeakDefinition:
130 case MCSA_WeakDefAutoPrivate:
131 case MCSA_Invalid:
132 case MCSA_ELF_TypeIndFunction:
133 case MCSA_IndirectSymbol:
134 assert(0 && "Invalid symbol attribute for ELF!");
135 break;
136
137 case MCSA_ELF_TypeGnuUniqueObject:
138 // Ignore for now.
139 break;
140
141 case MCSA_Global:
142 MCELF::SetBinding(SD, ELF::STB_GLOBAL);
143 SD.setExternal(true);
144 BindingExplicitlySet.insert(Symbol);
145 break;
146
147 case MCSA_WeakReference:
148 case MCSA_Weak:
149 MCELF::SetBinding(SD, ELF::STB_WEAK);
150 SD.setExternal(true);
151 BindingExplicitlySet.insert(Symbol);
152 break;
153
154 case MCSA_Local:
155 MCELF::SetBinding(SD, ELF::STB_LOCAL);
156 SD.setExternal(false);
157 BindingExplicitlySet.insert(Symbol);
158 break;
159
160 case MCSA_ELF_TypeFunction:
161 MCELF::SetType(SD, ELF::STT_FUNC);
162 break;
163
164 case MCSA_ELF_TypeObject:
165 MCELF::SetType(SD, ELF::STT_OBJECT);
166 break;
167
168 case MCSA_ELF_TypeTLS:
169 MCELF::SetType(SD, ELF::STT_TLS);
170 break;
171
172 case MCSA_ELF_TypeCommon:
173 MCELF::SetType(SD, ELF::STT_COMMON);
174 break;
175
176 case MCSA_ELF_TypeNoType:
177 MCELF::SetType(SD, ELF::STT_NOTYPE);
178 break;
179
180 case MCSA_Protected:
181 MCELF::SetVisibility(SD, ELF::STV_PROTECTED);
182 break;
183
184 case MCSA_Hidden:
185 MCELF::SetVisibility(SD, ELF::STV_HIDDEN);
186 break;
187
188 case MCSA_Internal:
189 MCELF::SetVisibility(SD, ELF::STV_INTERNAL);
190 break;
191 }
192 }
193
EmitCommonSymbol(MCSymbol * Symbol,uint64_t Size,unsigned ByteAlignment)194 void MCELFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
195 unsigned ByteAlignment) {
196 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
197
198 if (!BindingExplicitlySet.count(Symbol)) {
199 MCELF::SetBinding(SD, ELF::STB_GLOBAL);
200 SD.setExternal(true);
201 }
202
203 MCELF::SetType(SD, ELF::STT_OBJECT);
204
205 if (MCELF::GetBinding(SD) == ELF_STB_Local) {
206 const MCSection *Section = getAssembler().getContext().getELFSection(".bss",
207 ELF::SHT_NOBITS,
208 ELF::SHF_WRITE |
209 ELF::SHF_ALLOC,
210 SectionKind::getBSS());
211 Symbol->setSection(*Section);
212
213 struct LocalCommon L = {&SD, Size, ByteAlignment};
214 LocalCommons.push_back(L);
215 } else {
216 SD.setCommon(Size, ByteAlignment);
217 }
218
219 SD.setSize(MCConstantExpr::Create(Size, getContext()));
220 }
221
EmitLocalCommonSymbol(MCSymbol * Symbol,uint64_t Size)222 void MCELFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size) {
223 // FIXME: Should this be caught and done earlier?
224 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
225 MCELF::SetBinding(SD, ELF::STB_LOCAL);
226 SD.setExternal(false);
227 BindingExplicitlySet.insert(Symbol);
228 // FIXME: ByteAlignment is not needed here, but is required.
229 EmitCommonSymbol(Symbol, Size, 1);
230 }
231
EmitBytes(StringRef Data,unsigned AddrSpace)232 void MCELFStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) {
233 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
234 // MCObjectStreamer.
235 getOrCreateDataFragment()->getContents().append(Data.begin(), Data.end());
236 }
237
EmitValueToAlignment(unsigned ByteAlignment,int64_t Value,unsigned ValueSize,unsigned MaxBytesToEmit)238 void MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment,
239 int64_t Value, unsigned ValueSize,
240 unsigned MaxBytesToEmit) {
241 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
242 // MCObjectStreamer.
243 if (MaxBytesToEmit == 0)
244 MaxBytesToEmit = ByteAlignment;
245 new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit,
246 getCurrentSectionData());
247
248 // Update the maximum alignment on the current section if necessary.
249 if (ByteAlignment > getCurrentSectionData()->getAlignment())
250 getCurrentSectionData()->setAlignment(ByteAlignment);
251 }
252
EmitCodeAlignment(unsigned ByteAlignment,unsigned MaxBytesToEmit)253 void MCELFStreamer::EmitCodeAlignment(unsigned ByteAlignment,
254 unsigned MaxBytesToEmit) {
255 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
256 // MCObjectStreamer.
257 if (MaxBytesToEmit == 0)
258 MaxBytesToEmit = ByteAlignment;
259 MCAlignFragment *F = new MCAlignFragment(ByteAlignment, 0, 1, MaxBytesToEmit,
260 getCurrentSectionData());
261 F->setEmitNops(true);
262
263 // Update the maximum alignment on the current section if necessary.
264 if (ByteAlignment > getCurrentSectionData()->getAlignment())
265 getCurrentSectionData()->setAlignment(ByteAlignment);
266 }
267
268 // Add a symbol for the file name of this module. This is the second
269 // entry in the module's symbol table (the first being the null symbol).
EmitFileDirective(StringRef Filename)270 void MCELFStreamer::EmitFileDirective(StringRef Filename) {
271 MCSymbol *Symbol = getAssembler().getContext().GetOrCreateSymbol(Filename);
272 Symbol->setSection(*getCurrentSection());
273 Symbol->setAbsolute();
274
275 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
276
277 SD.setFlags(ELF_STT_File | ELF_STB_Local | ELF_STV_Default);
278 }
279
fixSymbolsInTLSFixups(const MCExpr * expr)280 void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
281 switch (expr->getKind()) {
282 case MCExpr::Target: llvm_unreachable("Can't handle target exprs yet!");
283 case MCExpr::Constant:
284 break;
285
286 case MCExpr::Binary: {
287 const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
288 fixSymbolsInTLSFixups(be->getLHS());
289 fixSymbolsInTLSFixups(be->getRHS());
290 break;
291 }
292
293 case MCExpr::SymbolRef: {
294 const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
295 switch (symRef.getKind()) {
296 default:
297 return;
298 case MCSymbolRefExpr::VK_GOTTPOFF:
299 case MCSymbolRefExpr::VK_INDNTPOFF:
300 case MCSymbolRefExpr::VK_NTPOFF:
301 case MCSymbolRefExpr::VK_GOTNTPOFF:
302 case MCSymbolRefExpr::VK_TLSGD:
303 case MCSymbolRefExpr::VK_TLSLD:
304 case MCSymbolRefExpr::VK_TLSLDM:
305 case MCSymbolRefExpr::VK_TPOFF:
306 case MCSymbolRefExpr::VK_DTPOFF:
307 case MCSymbolRefExpr::VK_ARM_TLSGD:
308 case MCSymbolRefExpr::VK_ARM_TPOFF:
309 case MCSymbolRefExpr::VK_ARM_GOTTPOFF:
310 break;
311 }
312 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(symRef.getSymbol());
313 MCELF::SetType(SD, ELF::STT_TLS);
314 break;
315 }
316
317 case MCExpr::Unary:
318 fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
319 break;
320 }
321 }
322
EmitInstToFragment(const MCInst & Inst)323 void MCELFStreamer::EmitInstToFragment(const MCInst &Inst) {
324 this->MCObjectStreamer::EmitInstToFragment(Inst);
325 MCInstFragment &F = *cast<MCInstFragment>(getCurrentFragment());
326
327 for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i)
328 fixSymbolsInTLSFixups(F.getFixups()[i].getValue());
329 }
330
EmitInstToData(const MCInst & Inst)331 void MCELFStreamer::EmitInstToData(const MCInst &Inst) {
332 MCDataFragment *DF = getOrCreateDataFragment();
333
334 SmallVector<MCFixup, 4> Fixups;
335 SmallString<256> Code;
336 raw_svector_ostream VecOS(Code);
337 getAssembler().getEmitter().EncodeInstruction(Inst, VecOS, Fixups);
338 VecOS.flush();
339
340 for (unsigned i = 0, e = Fixups.size(); i != e; ++i)
341 fixSymbolsInTLSFixups(Fixups[i].getValue());
342
343 // Add the fixups and data.
344 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
345 Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
346 DF->addFixup(Fixups[i]);
347 }
348 DF->getContents().append(Code.begin(), Code.end());
349 }
350
Finish()351 void MCELFStreamer::Finish() {
352 EmitFrames(true);
353
354 for (std::vector<LocalCommon>::const_iterator i = LocalCommons.begin(),
355 e = LocalCommons.end();
356 i != e; ++i) {
357 MCSymbolData *SD = i->SD;
358 uint64_t Size = i->Size;
359 unsigned ByteAlignment = i->ByteAlignment;
360 const MCSymbol &Symbol = SD->getSymbol();
361 const MCSection &Section = Symbol.getSection();
362
363 MCSectionData &SectData = getAssembler().getOrCreateSectionData(Section);
364 new MCAlignFragment(ByteAlignment, 0, 1, ByteAlignment, &SectData);
365
366 MCFragment *F = new MCFillFragment(0, 0, Size, &SectData);
367 SD->setFragment(F);
368
369 // Update the maximum alignment of the section if necessary.
370 if (ByteAlignment > SectData.getAlignment())
371 SectData.setAlignment(ByteAlignment);
372 }
373
374 this->MCObjectStreamer::Finish();
375 }
376
createELFStreamer(MCContext & Context,TargetAsmBackend & TAB,raw_ostream & OS,MCCodeEmitter * CE,bool RelaxAll,bool NoExecStack)377 MCStreamer *llvm::createELFStreamer(MCContext &Context, TargetAsmBackend &TAB,
378 raw_ostream &OS, MCCodeEmitter *CE,
379 bool RelaxAll, bool NoExecStack) {
380 MCELFStreamer *S = new MCELFStreamer(Context, TAB, OS, CE);
381 if (RelaxAll)
382 S->getAssembler().setRelaxAll(true);
383 if (NoExecStack)
384 S->getAssembler().setNoExecStack(true);
385 return S;
386 }
387