1 //===- lib/MC/MCMachOStreamer.cpp - Mach-O 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 #include "llvm/MC/MCStreamer.h"
12 #include "llvm/MC/MCAssembler.h"
13 #include "llvm/MC/MCContext.h"
14 #include "llvm/MC/MCCodeEmitter.h"
15 #include "llvm/MC/MCExpr.h"
16 #include "llvm/MC/MCInst.h"
17 #include "llvm/MC/MCSection.h"
18 #include "llvm/MC/MCSymbol.h"
19 #include "llvm/MC/MCMachOSymbolFlags.h"
20 #include "llvm/Support/ErrorHandling.h"
21 #include "llvm/Support/raw_ostream.h"
22 #include "llvm/Target/TargetAsmBackend.h"
28 class MCMachOStreamer
: public MCStreamer
{
31 MCAssembler Assembler
;
32 MCSectionData
*CurSectionData
;
34 /// Track the current atom for each section.
35 DenseMap
<const MCSectionData
*, MCSymbolData
*> CurrentAtomMap
;
38 MCFragment
*getCurrentFragment() const {
39 assert(CurSectionData
&& "No current section!");
41 if (!CurSectionData
->empty())
42 return &CurSectionData
->getFragmentList().back();
47 /// Get a data fragment to write into, creating a new one if the current
48 /// fragment is not a data fragment.
49 MCDataFragment
*getOrCreateDataFragment() const {
50 MCDataFragment
*F
= dyn_cast_or_null
<MCDataFragment
>(getCurrentFragment());
52 F
= createDataFragment();
56 /// Create a new data fragment in the current section.
57 MCDataFragment
*createDataFragment() const {
58 MCDataFragment
*DF
= new MCDataFragment(CurSectionData
);
59 DF
->setAtom(CurrentAtomMap
.lookup(CurSectionData
));
64 MCMachOStreamer(MCContext
&Context
, TargetAsmBackend
&TAB
,
65 raw_ostream
&_OS
, MCCodeEmitter
*_Emitter
)
66 : MCStreamer(Context
), Assembler(Context
, TAB
, *_Emitter
, _OS
),
70 MCAssembler
&getAssembler() { return Assembler
; }
72 const MCExpr
*AddValueSymbols(const MCExpr
*Value
) {
73 switch (Value
->getKind()) {
74 case MCExpr::Target
: assert(0 && "Can't handle target exprs yet!");
75 case MCExpr::Constant
:
78 case MCExpr::Binary
: {
79 const MCBinaryExpr
*BE
= cast
<MCBinaryExpr
>(Value
);
80 AddValueSymbols(BE
->getLHS());
81 AddValueSymbols(BE
->getRHS());
85 case MCExpr::SymbolRef
:
86 Assembler
.getOrCreateSymbolData(
87 cast
<MCSymbolRefExpr
>(Value
)->getSymbol());
91 AddValueSymbols(cast
<MCUnaryExpr
>(Value
)->getSubExpr());
98 /// @name MCStreamer Interface
101 virtual void SwitchSection(const MCSection
*Section
);
102 virtual void EmitLabel(MCSymbol
*Symbol
);
103 virtual void EmitAssemblerFlag(MCAssemblerFlag Flag
);
104 virtual void EmitAssignment(MCSymbol
*Symbol
, const MCExpr
*Value
);
105 virtual void EmitSymbolAttribute(MCSymbol
*Symbol
, MCSymbolAttr Attribute
);
106 virtual void EmitSymbolDesc(MCSymbol
*Symbol
, unsigned DescValue
);
107 virtual void EmitCommonSymbol(MCSymbol
*Symbol
, uint64_t Size
,
108 unsigned ByteAlignment
);
109 virtual void BeginCOFFSymbolDef(const MCSymbol
*Symbol
) {
110 assert(0 && "macho doesn't support this directive");
112 virtual void EmitCOFFSymbolStorageClass(int StorageClass
) {
113 assert(0 && "macho doesn't support this directive");
115 virtual void EmitCOFFSymbolType(int Type
) {
116 assert(0 && "macho doesn't support this directive");
118 virtual void EndCOFFSymbolDef() {
119 assert(0 && "macho doesn't support this directive");
121 virtual void EmitELFSize(MCSymbol
*Symbol
, const MCExpr
*Value
) {
122 assert(0 && "macho doesn't support this directive");
124 virtual void EmitLocalCommonSymbol(MCSymbol
*Symbol
, uint64_t Size
) {
125 assert(0 && "macho doesn't support this directive");
127 virtual void EmitZerofill(const MCSection
*Section
, MCSymbol
*Symbol
= 0,
128 unsigned Size
= 0, unsigned ByteAlignment
= 0);
129 virtual void EmitTBSSSymbol(const MCSection
*Section
, MCSymbol
*Symbol
,
130 uint64_t Size
, unsigned ByteAlignment
= 0);
131 virtual void EmitBytes(StringRef Data
, unsigned AddrSpace
);
132 virtual void EmitValue(const MCExpr
*Value
, unsigned Size
,unsigned AddrSpace
);
133 virtual void EmitGPRel32Value(const MCExpr
*Value
) {
134 assert(0 && "macho doesn't support this directive");
136 virtual void EmitValueToAlignment(unsigned ByteAlignment
, int64_t Value
= 0,
137 unsigned ValueSize
= 1,
138 unsigned MaxBytesToEmit
= 0);
139 virtual void EmitCodeAlignment(unsigned ByteAlignment
,
140 unsigned MaxBytesToEmit
= 0);
141 virtual void EmitValueToOffset(const MCExpr
*Offset
,
142 unsigned char Value
= 0);
144 virtual void EmitFileDirective(StringRef Filename
) {
145 report_fatal_error("unsupported directive: '.file'");
147 virtual void EmitDwarfFileDirective(unsigned FileNo
, StringRef Filename
) {
148 report_fatal_error("unsupported directive: '.file'");
151 virtual void EmitInstruction(const MCInst
&Inst
);
152 virtual void Finish();
157 } // end anonymous namespace.
159 void MCMachOStreamer::SwitchSection(const MCSection
*Section
) {
160 assert(Section
&& "Cannot switch to a null section!");
162 // If already in this section, then this is a noop.
163 if (Section
== CurSection
) return;
165 CurSection
= Section
;
166 CurSectionData
= &Assembler
.getOrCreateSectionData(*Section
);
169 void MCMachOStreamer::EmitLabel(MCSymbol
*Symbol
) {
170 assert(Symbol
->isUndefined() && "Cannot define a symbol twice!");
171 assert(!Symbol
->isVariable() && "Cannot emit a variable symbol!");
172 assert(CurSection
&& "Cannot emit before setting section!");
174 MCSymbolData
&SD
= Assembler
.getOrCreateSymbolData(*Symbol
);
176 // Update the current atom map, if necessary.
177 bool MustCreateFragment
= false;
178 if (Assembler
.isSymbolLinkerVisible(&SD
)) {
179 CurrentAtomMap
[CurSectionData
] = &SD
;
181 // We have to create a new fragment, fragments cannot span atoms.
182 MustCreateFragment
= true;
185 // FIXME: This is wasteful, we don't necessarily need to create a data
186 // fragment. Instead, we should mark the symbol as pointing into the data
187 // fragment if it exists, otherwise we should just queue the label and set its
188 // fragment pointer when we emit the next fragment.
190 MustCreateFragment
? createDataFragment() : getOrCreateDataFragment();
191 assert(!SD
.getFragment() && "Unexpected fragment on symbol data!");
193 SD
.setOffset(F
->getContents().size());
195 // This causes the reference type flag to be cleared. Darwin 'as' was "trying"
196 // to clear the weak reference and weak definition bits too, but the
197 // implementation was buggy. For now we just try to match 'as', for
200 // FIXME: Cleanup this code, these bits should be emitted based on semantic
201 // properties, not on the order of definition, etc.
202 SD
.setFlags(SD
.getFlags() & ~SF_ReferenceTypeMask
);
204 Symbol
->setSection(*CurSection
);
207 void MCMachOStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag
) {
209 case MCAF_SubsectionsViaSymbols
:
210 Assembler
.setSubsectionsViaSymbols(true);
214 assert(0 && "invalid assembler flag!");
217 void MCMachOStreamer::EmitAssignment(MCSymbol
*Symbol
, const MCExpr
*Value
) {
218 // FIXME: Lift context changes into super class.
219 Assembler
.getOrCreateSymbolData(*Symbol
);
220 Symbol
->setVariableValue(AddValueSymbols(Value
));
223 void MCMachOStreamer::EmitSymbolAttribute(MCSymbol
*Symbol
,
224 MCSymbolAttr Attribute
) {
225 // Indirect symbols are handled differently, to match how 'as' handles
226 // them. This makes writing matching .o files easier.
227 if (Attribute
== MCSA_IndirectSymbol
) {
228 // Note that we intentionally cannot use the symbol data here; this is
229 // important for matching the string table that 'as' generates.
230 IndirectSymbolData ISD
;
232 ISD
.SectionData
= CurSectionData
;
233 Assembler
.getIndirectSymbols().push_back(ISD
);
237 // Adding a symbol attribute always introduces the symbol, note that an
238 // important side effect of calling getOrCreateSymbolData here is to register
239 // the symbol with the assembler.
240 MCSymbolData
&SD
= Assembler
.getOrCreateSymbolData(*Symbol
);
242 // The implementation of symbol attributes is designed to match 'as', but it
243 // leaves much to desired. It doesn't really make sense to arbitrarily add and
244 // remove flags, but 'as' allows this (in particular, see .desc).
246 // In the future it might be worth trying to make these operations more well
250 case MCSA_ELF_TypeFunction
:
251 case MCSA_ELF_TypeIndFunction
:
252 case MCSA_ELF_TypeObject
:
253 case MCSA_ELF_TypeTLS
:
254 case MCSA_ELF_TypeCommon
:
255 case MCSA_ELF_TypeNoType
:
256 case MCSA_IndirectSymbol
:
262 assert(0 && "Invalid symbol attribute for Mach-O!");
266 SD
.setExternal(true);
267 // This effectively clears the undefined lazy bit, in Darwin 'as', although
268 // it isn't very consistent because it implements this as part of symbol
271 // FIXME: Cleanup this code, these bits should be emitted based on semantic
272 // properties, not on the order of definition, etc.
273 SD
.setFlags(SD
.getFlags() & ~SF_ReferenceTypeUndefinedLazy
);
276 case MCSA_LazyReference
:
277 // FIXME: This requires -dynamic.
278 SD
.setFlags(SD
.getFlags() | SF_NoDeadStrip
);
279 if (Symbol
->isUndefined())
280 SD
.setFlags(SD
.getFlags() | SF_ReferenceTypeUndefinedLazy
);
283 // Since .reference sets the no dead strip bit, it is equivalent to
284 // .no_dead_strip in practice.
286 case MCSA_NoDeadStrip
:
287 SD
.setFlags(SD
.getFlags() | SF_NoDeadStrip
);
290 case MCSA_PrivateExtern
:
291 SD
.setExternal(true);
292 SD
.setPrivateExtern(true);
295 case MCSA_WeakReference
:
296 // FIXME: This requires -dynamic.
297 if (Symbol
->isUndefined())
298 SD
.setFlags(SD
.getFlags() | SF_WeakReference
);
301 case MCSA_WeakDefinition
:
302 // FIXME: 'as' enforces that this is defined and global. The manual claims
303 // it has to be in a coalesced section, but this isn't enforced.
304 SD
.setFlags(SD
.getFlags() | SF_WeakDefinition
);
309 void MCMachOStreamer::EmitSymbolDesc(MCSymbol
*Symbol
, unsigned DescValue
) {
310 // Encode the 'desc' value into the lowest implementation defined bits.
311 assert(DescValue
== (DescValue
& SF_DescFlagsMask
) &&
312 "Invalid .desc value!");
313 Assembler
.getOrCreateSymbolData(*Symbol
).setFlags(DescValue
&SF_DescFlagsMask
);
316 void MCMachOStreamer::EmitCommonSymbol(MCSymbol
*Symbol
, uint64_t Size
,
317 unsigned ByteAlignment
) {
318 // FIXME: Darwin 'as' does appear to allow redef of a .comm by itself.
319 assert(Symbol
->isUndefined() && "Cannot define a symbol twice!");
321 MCSymbolData
&SD
= Assembler
.getOrCreateSymbolData(*Symbol
);
322 SD
.setExternal(true);
323 SD
.setCommon(Size
, ByteAlignment
);
326 void MCMachOStreamer::EmitZerofill(const MCSection
*Section
, MCSymbol
*Symbol
,
327 unsigned Size
, unsigned ByteAlignment
) {
328 MCSectionData
&SectData
= Assembler
.getOrCreateSectionData(*Section
);
330 // The symbol may not be present, which only creates the section.
334 // FIXME: Assert that this section has the zerofill type.
336 assert(Symbol
->isUndefined() && "Cannot define a symbol twice!");
338 MCSymbolData
&SD
= Assembler
.getOrCreateSymbolData(*Symbol
);
340 // Emit an align fragment if necessary.
341 if (ByteAlignment
!= 1)
342 new MCAlignFragment(ByteAlignment
, 0, 0, ByteAlignment
, &SectData
);
344 MCFragment
*F
= new MCFillFragment(0, 0, Size
, &SectData
);
346 if (Assembler
.isSymbolLinkerVisible(&SD
))
349 Symbol
->setSection(*Section
);
351 // Update the maximum alignment on the zero fill section if necessary.
352 if (ByteAlignment
> SectData
.getAlignment())
353 SectData
.setAlignment(ByteAlignment
);
356 // This should always be called with the thread local bss section. Like the
357 // .zerofill directive this doesn't actually switch sections on us.
358 void MCMachOStreamer::EmitTBSSSymbol(const MCSection
*Section
, MCSymbol
*Symbol
,
359 uint64_t Size
, unsigned ByteAlignment
) {
360 EmitZerofill(Section
, Symbol
, Size
, ByteAlignment
);
364 void MCMachOStreamer::EmitBytes(StringRef Data
, unsigned AddrSpace
) {
365 getOrCreateDataFragment()->getContents().append(Data
.begin(), Data
.end());
368 void MCMachOStreamer::EmitValue(const MCExpr
*Value
, unsigned Size
,
369 unsigned AddrSpace
) {
370 MCDataFragment
*DF
= getOrCreateDataFragment();
372 // Avoid fixups when possible.
374 if (AddValueSymbols(Value
)->EvaluateAsAbsolute(AbsValue
)) {
375 // FIXME: Endianness assumption.
376 for (unsigned i
= 0; i
!= Size
; ++i
)
377 DF
->getContents().push_back(uint8_t(AbsValue
>> (i
* 8)));
379 DF
->addFixup(MCFixup::Create(DF
->getContents().size(),
380 AddValueSymbols(Value
),
381 MCFixup::getKindForSize(Size
)));
382 DF
->getContents().resize(DF
->getContents().size() + Size
, 0);
386 void MCMachOStreamer::EmitValueToAlignment(unsigned ByteAlignment
,
387 int64_t Value
, unsigned ValueSize
,
388 unsigned MaxBytesToEmit
) {
389 if (MaxBytesToEmit
== 0)
390 MaxBytesToEmit
= ByteAlignment
;
391 MCFragment
*F
= new MCAlignFragment(ByteAlignment
, Value
, ValueSize
,
392 MaxBytesToEmit
, CurSectionData
);
393 F
->setAtom(CurrentAtomMap
.lookup(CurSectionData
));
395 // Update the maximum alignment on the current section if necessary.
396 if (ByteAlignment
> CurSectionData
->getAlignment())
397 CurSectionData
->setAlignment(ByteAlignment
);
400 void MCMachOStreamer::EmitCodeAlignment(unsigned ByteAlignment
,
401 unsigned MaxBytesToEmit
) {
402 if (MaxBytesToEmit
== 0)
403 MaxBytesToEmit
= ByteAlignment
;
404 MCAlignFragment
*F
= new MCAlignFragment(ByteAlignment
, 0, 1, MaxBytesToEmit
,
406 F
->setEmitNops(true);
407 F
->setAtom(CurrentAtomMap
.lookup(CurSectionData
));
409 // Update the maximum alignment on the current section if necessary.
410 if (ByteAlignment
> CurSectionData
->getAlignment())
411 CurSectionData
->setAlignment(ByteAlignment
);
414 void MCMachOStreamer::EmitValueToOffset(const MCExpr
*Offset
,
415 unsigned char Value
) {
416 MCFragment
*F
= new MCOrgFragment(*Offset
, Value
, CurSectionData
);
417 F
->setAtom(CurrentAtomMap
.lookup(CurSectionData
));
420 void MCMachOStreamer::EmitInstruction(const MCInst
&Inst
) {
422 for (unsigned i
= Inst
.getNumOperands(); i
--; )
423 if (Inst
.getOperand(i
).isExpr())
424 AddValueSymbols(Inst
.getOperand(i
).getExpr());
426 CurSectionData
->setHasInstructions(true);
428 // FIXME-PERF: Common case is that we don't need to relax, encode directly
429 // onto the data fragments buffers.
431 SmallVector
<MCFixup
, 4> Fixups
;
432 SmallString
<256> Code
;
433 raw_svector_ostream
VecOS(Code
);
434 Assembler
.getEmitter().EncodeInstruction(Inst
, VecOS
, Fixups
);
437 // See if we might need to relax this instruction, if so it needs its own
440 // FIXME-PERF: Support target hook to do a fast path that avoids the encoder,
441 // when we can immediately tell that we will get something which might need
442 // relaxation (and compute its size).
444 // FIXME-PERF: We should also be smart about immediately relaxing instructions
445 // which we can already show will never possibly fit (we can also do a very
446 // good job of this before we do the first relaxation pass, because we have
447 // total knowledge about undefined symbols at that point). Even now, though,
448 // we can do a decent job, especially on Darwin where scattering means that we
449 // are going to often know that we can never fully resolve a fixup.
450 if (Assembler
.getBackend().MayNeedRelaxation(Inst
)) {
451 MCInstFragment
*IF
= new MCInstFragment(Inst
, CurSectionData
);
452 IF
->setAtom(CurrentAtomMap
.lookup(CurSectionData
));
454 // Add the fixups and data.
456 // FIXME: Revisit this design decision when relaxation is done, we may be
457 // able to get away with not storing any extra data in the MCInst.
458 IF
->getCode() = Code
;
459 IF
->getFixups() = Fixups
;
464 // Add the fixups and data.
465 MCDataFragment
*DF
= getOrCreateDataFragment();
466 for (unsigned i
= 0, e
= Fixups
.size(); i
!= e
; ++i
) {
467 Fixups
[i
].setOffset(Fixups
[i
].getOffset() + DF
->getContents().size());
468 DF
->addFixup(Fixups
[i
]);
470 DF
->getContents().append(Code
.begin(), Code
.end());
473 void MCMachOStreamer::Finish() {
477 MCStreamer
*llvm::createMachOStreamer(MCContext
&Context
, TargetAsmBackend
&TAB
,
478 raw_ostream
&OS
, MCCodeEmitter
*CE
,
480 MCMachOStreamer
*S
= new MCMachOStreamer(Context
, TAB
, OS
, CE
);
482 S
->getAssembler().setRelaxAll(true);