1 //===- lib/MC/MCELFStreamer.cpp - ELF Object Output ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file assembles .s files and emits ELF .o object files.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/MC/MCStreamer.h"
16 #include "llvm/ADT/SmallPtrSet.h"
17 #include "llvm/MC/MCAssembler.h"
18 #include "llvm/MC/MCContext.h"
19 #include "llvm/MC/MCCodeEmitter.h"
20 #include "llvm/MC/MCELFSymbolFlags.h"
21 #include "llvm/MC/MCExpr.h"
22 #include "llvm/MC/MCInst.h"
23 #include "llvm/MC/MCObjectStreamer.h"
24 #include "llvm/MC/MCSection.h"
25 #include "llvm/MC/MCSectionELF.h"
26 #include "llvm/MC/MCSymbol.h"
27 #include "llvm/MC/MCValue.h"
28 #include "llvm/Support/Debug.h"
29 #include "llvm/Support/ELF.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/raw_ostream.h"
32 #include "llvm/Target/TargetAsmBackend.h"
38 static void SetBinding(MCSymbolData
&SD
, unsigned Binding
) {
39 assert(Binding
== ELF::STB_LOCAL
|| Binding
== ELF::STB_GLOBAL
||
40 Binding
== ELF::STB_WEAK
);
41 uint32_t OtherFlags
= SD
.getFlags() & ~(0xf << ELF_STB_Shift
);
42 SD
.setFlags(OtherFlags
| (Binding
<< ELF_STB_Shift
));
45 static unsigned GetBinding(const MCSymbolData
&SD
) {
46 uint32_t Binding
= (SD
.getFlags() & (0xf << ELF_STB_Shift
)) >> ELF_STB_Shift
;
47 assert(Binding
== ELF::STB_LOCAL
|| Binding
== ELF::STB_GLOBAL
||
48 Binding
== ELF::STB_WEAK
);
52 static void SetType(MCSymbolData
&SD
, unsigned Type
) {
53 assert(Type
== ELF::STT_NOTYPE
|| Type
== ELF::STT_OBJECT
||
54 Type
== ELF::STT_FUNC
|| Type
== ELF::STT_SECTION
||
55 Type
== ELF::STT_FILE
|| Type
== ELF::STT_COMMON
||
56 Type
== ELF::STT_TLS
);
58 uint32_t OtherFlags
= SD
.getFlags() & ~(0xf << ELF_STT_Shift
);
59 SD
.setFlags(OtherFlags
| (Type
<< ELF_STT_Shift
));
62 static void SetVisibility(MCSymbolData
&SD
, unsigned Visibility
) {
63 assert(Visibility
== ELF::STV_DEFAULT
|| Visibility
== ELF::STV_INTERNAL
||
64 Visibility
== ELF::STV_HIDDEN
|| Visibility
== ELF::STV_PROTECTED
);
66 uint32_t OtherFlags
= SD
.getFlags() & ~(0xf << ELF_STV_Shift
);
67 SD
.setFlags(OtherFlags
| (Visibility
<< ELF_STV_Shift
));
70 class MCELFStreamer
: public MCObjectStreamer
{
72 MCELFStreamer(MCContext
&Context
, TargetAsmBackend
&TAB
,
73 raw_ostream
&OS
, MCCodeEmitter
*Emitter
)
74 : MCObjectStreamer(Context
, TAB
, OS
, Emitter
, false) {}
78 /// @name MCStreamer Interface
81 virtual void InitSections();
82 virtual void EmitLabel(MCSymbol
*Symbol
);
83 virtual void EmitAssemblerFlag(MCAssemblerFlag Flag
);
84 virtual void EmitThumbFunc(MCSymbol
*Func
);
85 virtual void EmitAssignment(MCSymbol
*Symbol
, const MCExpr
*Value
);
86 virtual void EmitWeakReference(MCSymbol
*Alias
, const MCSymbol
*Symbol
);
87 virtual void SwitchSection(const MCSection
*Section
);
88 virtual void EmitSymbolAttribute(MCSymbol
*Symbol
, MCSymbolAttr Attribute
);
89 virtual void EmitSymbolDesc(MCSymbol
*Symbol
, unsigned DescValue
) {
90 assert(0 && "ELF doesn't support this directive");
92 virtual void EmitCommonSymbol(MCSymbol
*Symbol
, uint64_t Size
,
93 unsigned ByteAlignment
);
94 virtual void BeginCOFFSymbolDef(const MCSymbol
*Symbol
) {
95 assert(0 && "ELF doesn't support this directive");
98 virtual void EmitCOFFSymbolStorageClass(int StorageClass
) {
99 assert(0 && "ELF doesn't support this directive");
102 virtual void EmitCOFFSymbolType(int Type
) {
103 assert(0 && "ELF doesn't support this directive");
106 virtual void EndCOFFSymbolDef() {
107 assert(0 && "ELF doesn't support this directive");
110 virtual void EmitELFSize(MCSymbol
*Symbol
, const MCExpr
*Value
) {
111 MCSymbolData
&SD
= getAssembler().getOrCreateSymbolData(*Symbol
);
115 virtual void EmitLocalCommonSymbol(MCSymbol
*Symbol
, uint64_t Size
) {
116 assert(0 && "ELF doesn't support this directive");
118 virtual void EmitZerofill(const MCSection
*Section
, MCSymbol
*Symbol
= 0,
119 unsigned Size
= 0, unsigned ByteAlignment
= 0) {
120 assert(0 && "ELF doesn't support this directive");
122 virtual void EmitTBSSSymbol(const MCSection
*Section
, MCSymbol
*Symbol
,
123 uint64_t Size
, unsigned ByteAlignment
= 0) {
124 assert(0 && "ELF doesn't support this directive");
126 virtual void EmitBytes(StringRef Data
, unsigned AddrSpace
);
127 virtual void EmitValue(const MCExpr
*Value
, unsigned Size
,unsigned AddrSpace
);
128 virtual void EmitGPRel32Value(const MCExpr
*Value
) {
129 assert(0 && "ELF doesn't support this directive");
131 virtual void EmitValueToAlignment(unsigned ByteAlignment
, int64_t Value
= 0,
132 unsigned ValueSize
= 1,
133 unsigned MaxBytesToEmit
= 0);
134 virtual void EmitCodeAlignment(unsigned ByteAlignment
,
135 unsigned MaxBytesToEmit
= 0);
136 virtual void EmitValueToOffset(const MCExpr
*Offset
,
137 unsigned char Value
= 0);
139 virtual void EmitFileDirective(StringRef Filename
);
141 virtual void Finish();
144 virtual void EmitInstToFragment(const MCInst
&Inst
);
145 virtual void EmitInstToData(const MCInst
&Inst
);
147 void fixSymbolsInTLSFixups(const MCExpr
*expr
);
152 unsigned ByteAlignment
;
154 std::vector
<LocalCommon
> LocalCommons
;
156 SmallPtrSet
<MCSymbol
*, 16> BindingExplicitlySet
;
158 void SetSection(StringRef Section
, unsigned Type
, unsigned Flags
,
160 SwitchSection(getContext().getELFSection(Section
, Type
, Flags
, Kind
));
163 void SetSectionData() {
164 SetSection(".data", MCSectionELF::SHT_PROGBITS
,
165 MCSectionELF::SHF_WRITE
|MCSectionELF::SHF_ALLOC
,
166 SectionKind::getDataRel());
167 EmitCodeAlignment(4, 0);
169 void SetSectionText() {
170 SetSection(".text", MCSectionELF::SHT_PROGBITS
,
171 MCSectionELF::SHF_EXECINSTR
|
172 MCSectionELF::SHF_ALLOC
, SectionKind::getText());
173 EmitCodeAlignment(4, 0);
175 void SetSectionBss() {
176 SetSection(".bss", MCSectionELF::SHT_NOBITS
,
177 MCSectionELF::SHF_WRITE
|
178 MCSectionELF::SHF_ALLOC
, SectionKind::getBSS());
179 EmitCodeAlignment(4, 0);
183 } // end anonymous namespace.
185 void MCELFStreamer::InitSections() {
186 // This emulates the same behavior of GNU as. This makes it easier
187 // to compare the output as the major sections are in the same order.
194 void MCELFStreamer::EmitLabel(MCSymbol
*Symbol
) {
195 assert(Symbol
->isUndefined() && "Cannot define a symbol twice!");
197 Symbol
->setSection(*CurSection
);
199 MCSymbolData
&SD
= getAssembler().getOrCreateSymbolData(*Symbol
);
201 const MCSectionELF
&Section
=
202 static_cast<const MCSectionELF
&>(Symbol
->getSection());
203 if (Section
.getFlags() & MCSectionELF::SHF_TLS
)
204 SetType(SD
, ELF::STT_TLS
);
206 // FIXME: This is wasteful, we don't necessarily need to create a data
207 // fragment. Instead, we should mark the symbol as pointing into the data
208 // fragment if it exists, otherwise we should just queue the label and set its
209 // fragment pointer when we emit the next fragment.
210 MCDataFragment
*F
= getOrCreateDataFragment();
212 assert(!SD
.getFragment() && "Unexpected fragment on symbol data!");
214 SD
.setOffset(F
->getContents().size());
217 void MCELFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag
) {
219 case MCAF_SyntaxUnified
: return; // no-op here.
220 case MCAF_Code16
: return; // no-op here.
221 case MCAF_Code32
: return; // no-op here.
222 case MCAF_SubsectionsViaSymbols
:
223 getAssembler().setSubsectionsViaSymbols(true);
227 assert(0 && "invalid assembler flag!");
230 void MCELFStreamer::EmitThumbFunc(MCSymbol
*Func
) {
231 // FIXME: Anything needed here to flag the function as thumb?
234 void MCELFStreamer::EmitAssignment(MCSymbol
*Symbol
, const MCExpr
*Value
) {
235 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
237 // FIXME: Lift context changes into super class.
238 getAssembler().getOrCreateSymbolData(*Symbol
);
239 Symbol
->setVariableValue(AddValueSymbols(Value
));
242 void MCELFStreamer::SwitchSection(const MCSection
*Section
) {
243 const MCSymbol
*Grp
= static_cast<const MCSectionELF
*>(Section
)->getGroup();
245 getAssembler().getOrCreateSymbolData(*Grp
);
246 this->MCObjectStreamer::SwitchSection(Section
);
249 void MCELFStreamer::EmitWeakReference(MCSymbol
*Alias
, const MCSymbol
*Symbol
) {
250 getAssembler().getOrCreateSymbolData(*Symbol
);
251 MCSymbolData
&AliasSD
= getAssembler().getOrCreateSymbolData(*Alias
);
252 AliasSD
.setFlags(AliasSD
.getFlags() | ELF_Other_Weakref
);
253 const MCExpr
*Value
= MCSymbolRefExpr::Create(Symbol
, getContext());
254 Alias
->setVariableValue(Value
);
257 void MCELFStreamer::EmitSymbolAttribute(MCSymbol
*Symbol
,
258 MCSymbolAttr Attribute
) {
259 // Indirect symbols are handled differently, to match how 'as' handles
260 // them. This makes writing matching .o files easier.
261 if (Attribute
== MCSA_IndirectSymbol
) {
262 // Note that we intentionally cannot use the symbol data here; this is
263 // important for matching the string table that 'as' generates.
264 IndirectSymbolData ISD
;
266 ISD
.SectionData
= getCurrentSectionData();
267 getAssembler().getIndirectSymbols().push_back(ISD
);
271 // Adding a symbol attribute always introduces the symbol, note that an
272 // important side effect of calling getOrCreateSymbolData here is to register
273 // the symbol with the assembler.
274 MCSymbolData
&SD
= getAssembler().getOrCreateSymbolData(*Symbol
);
276 // The implementation of symbol attributes is designed to match 'as', but it
277 // leaves much to desired. It doesn't really make sense to arbitrarily add and
278 // remove flags, but 'as' allows this (in particular, see .desc).
280 // In the future it might be worth trying to make these operations more well
283 case MCSA_LazyReference
:
285 case MCSA_NoDeadStrip
:
286 case MCSA_SymbolResolver
:
287 case MCSA_PrivateExtern
:
288 case MCSA_WeakDefinition
:
289 case MCSA_WeakDefAutoPrivate
:
291 case MCSA_ELF_TypeIndFunction
:
292 case MCSA_IndirectSymbol
:
293 assert(0 && "Invalid symbol attribute for ELF!");
296 case MCSA_ELF_TypeGnuUniqueObject
:
301 SetBinding(SD
, ELF::STB_GLOBAL
);
302 SD
.setExternal(true);
303 BindingExplicitlySet
.insert(Symbol
);
306 case MCSA_WeakReference
:
308 SetBinding(SD
, ELF::STB_WEAK
);
309 SD
.setExternal(true);
310 BindingExplicitlySet
.insert(Symbol
);
314 SetBinding(SD
, ELF::STB_LOCAL
);
315 SD
.setExternal(false);
316 BindingExplicitlySet
.insert(Symbol
);
319 case MCSA_ELF_TypeFunction
:
320 SetType(SD
, ELF::STT_FUNC
);
323 case MCSA_ELF_TypeObject
:
324 SetType(SD
, ELF::STT_OBJECT
);
327 case MCSA_ELF_TypeTLS
:
328 SetType(SD
, ELF::STT_TLS
);
331 case MCSA_ELF_TypeCommon
:
332 SetType(SD
, ELF::STT_COMMON
);
335 case MCSA_ELF_TypeNoType
:
336 SetType(SD
, ELF::STT_NOTYPE
);
340 SetVisibility(SD
, ELF::STV_PROTECTED
);
344 SetVisibility(SD
, ELF::STV_HIDDEN
);
348 SetVisibility(SD
, ELF::STV_INTERNAL
);
353 void MCELFStreamer::EmitCommonSymbol(MCSymbol
*Symbol
, uint64_t Size
,
354 unsigned ByteAlignment
) {
355 MCSymbolData
&SD
= getAssembler().getOrCreateSymbolData(*Symbol
);
357 if (!BindingExplicitlySet
.count(Symbol
)) {
358 SetBinding(SD
, ELF::STB_GLOBAL
);
359 SD
.setExternal(true);
362 SetType(SD
, ELF::STT_OBJECT
);
364 if (GetBinding(SD
) == ELF_STB_Local
) {
365 const MCSection
*Section
= getAssembler().getContext().getELFSection(".bss",
366 MCSectionELF::SHT_NOBITS
,
367 MCSectionELF::SHF_WRITE
|
368 MCSectionELF::SHF_ALLOC
,
369 SectionKind::getBSS());
370 Symbol
->setSection(*Section
);
372 struct LocalCommon L
= {&SD
, Size
, ByteAlignment
};
373 LocalCommons
.push_back(L
);
375 SD
.setCommon(Size
, ByteAlignment
);
378 SD
.setSize(MCConstantExpr::Create(Size
, getContext()));
381 void MCELFStreamer::EmitBytes(StringRef Data
, unsigned AddrSpace
) {
382 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
384 getOrCreateDataFragment()->getContents().append(Data
.begin(), Data
.end());
387 void MCELFStreamer::EmitValue(const MCExpr
*Value
, unsigned Size
,
388 unsigned AddrSpace
) {
389 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
391 MCDataFragment
*DF
= getOrCreateDataFragment();
393 // Avoid fixups when possible.
395 if (AddValueSymbols(Value
)->EvaluateAsAbsolute(AbsValue
)) {
396 // FIXME: Endianness assumption.
397 for (unsigned i
= 0; i
!= Size
; ++i
)
398 DF
->getContents().push_back(uint8_t(AbsValue
>> (i
* 8)));
400 DF
->addFixup(MCFixup::Create(DF
->getContents().size(), AddValueSymbols(Value
),
401 MCFixup::getKindForSize(Size
)));
402 DF
->getContents().resize(DF
->getContents().size() + Size
, 0);
406 void MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment
,
407 int64_t Value
, unsigned ValueSize
,
408 unsigned MaxBytesToEmit
) {
409 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
411 if (MaxBytesToEmit
== 0)
412 MaxBytesToEmit
= ByteAlignment
;
413 new MCAlignFragment(ByteAlignment
, Value
, ValueSize
, MaxBytesToEmit
,
414 getCurrentSectionData());
416 // Update the maximum alignment on the current section if necessary.
417 if (ByteAlignment
> getCurrentSectionData()->getAlignment())
418 getCurrentSectionData()->setAlignment(ByteAlignment
);
421 void MCELFStreamer::EmitCodeAlignment(unsigned ByteAlignment
,
422 unsigned MaxBytesToEmit
) {
423 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
425 if (MaxBytesToEmit
== 0)
426 MaxBytesToEmit
= ByteAlignment
;
427 MCAlignFragment
*F
= new MCAlignFragment(ByteAlignment
, 0, 1, MaxBytesToEmit
,
428 getCurrentSectionData());
429 F
->setEmitNops(true);
431 // Update the maximum alignment on the current section if necessary.
432 if (ByteAlignment
> getCurrentSectionData()->getAlignment())
433 getCurrentSectionData()->setAlignment(ByteAlignment
);
436 void MCELFStreamer::EmitValueToOffset(const MCExpr
*Offset
,
437 unsigned char Value
) {
438 // TODO: This is exactly the same as MCMachOStreamer. Consider merging into
440 new MCOrgFragment(*Offset
, Value
, getCurrentSectionData());
443 // Add a symbol for the file name of this module. This is the second
444 // entry in the module's symbol table (the first being the null symbol).
445 void MCELFStreamer::EmitFileDirective(StringRef Filename
) {
446 MCSymbol
*Symbol
= getAssembler().getContext().GetOrCreateSymbol(Filename
);
447 Symbol
->setSection(*CurSection
);
448 Symbol
->setAbsolute();
450 MCSymbolData
&SD
= getAssembler().getOrCreateSymbolData(*Symbol
);
452 SD
.setFlags(ELF_STT_File
| ELF_STB_Local
| ELF_STV_Default
);
455 void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr
*expr
) {
456 switch (expr
->getKind()) {
457 case MCExpr::Target
: llvm_unreachable("Can't handle target exprs yet!");
458 case MCExpr::Constant
:
461 case MCExpr::Binary
: {
462 const MCBinaryExpr
*be
= cast
<MCBinaryExpr
>(expr
);
463 fixSymbolsInTLSFixups(be
->getLHS());
464 fixSymbolsInTLSFixups(be
->getRHS());
468 case MCExpr::SymbolRef
: {
469 const MCSymbolRefExpr
&symRef
= *cast
<MCSymbolRefExpr
>(expr
);
470 switch (symRef
.getKind()) {
473 case MCSymbolRefExpr::VK_NTPOFF
:
474 case MCSymbolRefExpr::VK_GOTNTPOFF
:
475 case MCSymbolRefExpr::VK_TLSGD
:
476 case MCSymbolRefExpr::VK_TLSLDM
:
477 case MCSymbolRefExpr::VK_TPOFF
:
478 case MCSymbolRefExpr::VK_DTPOFF
:
479 case MCSymbolRefExpr::VK_GOTTPOFF
:
480 case MCSymbolRefExpr::VK_TLSLD
:
481 case MCSymbolRefExpr::VK_ARM_TLSGD
:
484 MCSymbolData
&SD
= getAssembler().getOrCreateSymbolData(symRef
.getSymbol());
485 SetType(SD
, ELF::STT_TLS
);
490 fixSymbolsInTLSFixups(cast
<MCUnaryExpr
>(expr
)->getSubExpr());
495 void MCELFStreamer::EmitInstToFragment(const MCInst
&Inst
) {
496 MCInstFragment
*IF
= new MCInstFragment(Inst
, getCurrentSectionData());
498 // Add the fixups and data.
500 // FIXME: Revisit this design decision when relaxation is done, we may be
501 // able to get away with not storing any extra data in the MCInst.
502 SmallVector
<MCFixup
, 4> Fixups
;
503 SmallString
<256> Code
;
504 raw_svector_ostream
VecOS(Code
);
505 getAssembler().getEmitter().EncodeInstruction(Inst
, VecOS
, Fixups
);
508 for (unsigned i
= 0, e
= Fixups
.size(); i
!= e
; ++i
)
509 fixSymbolsInTLSFixups(Fixups
[i
].getValue());
511 IF
->getCode() = Code
;
512 IF
->getFixups() = Fixups
;
515 void MCELFStreamer::EmitInstToData(const MCInst
&Inst
) {
516 MCDataFragment
*DF
= getOrCreateDataFragment();
518 SmallVector
<MCFixup
, 4> Fixups
;
519 SmallString
<256> Code
;
520 raw_svector_ostream
VecOS(Code
);
521 getAssembler().getEmitter().EncodeInstruction(Inst
, VecOS
, Fixups
);
524 for (unsigned i
= 0, e
= Fixups
.size(); i
!= e
; ++i
)
525 fixSymbolsInTLSFixups(Fixups
[i
].getValue());
527 // Add the fixups and data.
528 for (unsigned i
= 0, e
= Fixups
.size(); i
!= e
; ++i
) {
529 Fixups
[i
].setOffset(Fixups
[i
].getOffset() + DF
->getContents().size());
530 DF
->addFixup(Fixups
[i
]);
532 DF
->getContents().append(Code
.begin(), Code
.end());
535 void MCELFStreamer::Finish() {
536 // FIXME: duplicated code with the MachO streamer.
537 // Dump out the dwarf file & directory tables and line tables.
538 if (getContext().hasDwarfFiles()) {
539 const MCSection
*DwarfLineSection
=
540 getContext().getELFSection(".debug_line", 0, 0,
541 SectionKind::getDataRelLocal());
543 getAssembler().getOrCreateSectionData(*DwarfLineSection
);
544 int PointerSize
= getAssembler().getBackend().getPointerSize();
545 MCDwarfFileTable::Emit(this, DwarfLineSection
, &DLS
, PointerSize
);
548 for (std::vector
<LocalCommon
>::const_iterator i
= LocalCommons
.begin(),
549 e
= LocalCommons
.end();
551 MCSymbolData
*SD
= i
->SD
;
552 uint64_t Size
= i
->Size
;
553 unsigned ByteAlignment
= i
->ByteAlignment
;
554 const MCSymbol
&Symbol
= SD
->getSymbol();
555 const MCSection
&Section
= Symbol
.getSection();
557 MCSectionData
&SectData
= getAssembler().getOrCreateSectionData(Section
);
558 new MCAlignFragment(ByteAlignment
, 0, 1, ByteAlignment
, &SectData
);
560 MCFragment
*F
= new MCFillFragment(0, 0, Size
, &SectData
);
563 // Update the maximum alignment of the section if necessary.
564 if (ByteAlignment
> SectData
.getAlignment())
565 SectData
.setAlignment(ByteAlignment
);
568 this->MCObjectStreamer::Finish();
571 MCStreamer
*llvm::createELFStreamer(MCContext
&Context
, TargetAsmBackend
&TAB
,
572 raw_ostream
&OS
, MCCodeEmitter
*CE
,
574 MCELFStreamer
*S
= new MCELFStreamer(Context
, TAB
, OS
, CE
);
576 S
->getAssembler().setRelaxAll(true);