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(MCSymbol
*Symbol
, uint64_t Size
,
130 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 void MCMachOStreamer::EmitTBSSSymbol(MCSymbol
*Symbol
, uint64_t Size
,
357 unsigned ByteAlignment
) {
358 assert(false && "Implement me!");
361 void MCMachOStreamer::EmitBytes(StringRef Data
, unsigned AddrSpace
) {
362 getOrCreateDataFragment()->getContents().append(Data
.begin(), Data
.end());
365 void MCMachOStreamer::EmitValue(const MCExpr
*Value
, unsigned Size
,
366 unsigned AddrSpace
) {
367 MCDataFragment
*DF
= getOrCreateDataFragment();
369 // Avoid fixups when possible.
371 if (AddValueSymbols(Value
)->EvaluateAsAbsolute(AbsValue
)) {
372 // FIXME: Endianness assumption.
373 for (unsigned i
= 0; i
!= Size
; ++i
)
374 DF
->getContents().push_back(uint8_t(AbsValue
>> (i
* 8)));
376 DF
->addFixup(MCAsmFixup(DF
->getContents().size(), *AddValueSymbols(Value
),
377 MCFixup::getKindForSize(Size
)));
378 DF
->getContents().resize(DF
->getContents().size() + Size
, 0);
382 void MCMachOStreamer::EmitValueToAlignment(unsigned ByteAlignment
,
383 int64_t Value
, unsigned ValueSize
,
384 unsigned MaxBytesToEmit
) {
385 if (MaxBytesToEmit
== 0)
386 MaxBytesToEmit
= ByteAlignment
;
387 MCFragment
*F
= new MCAlignFragment(ByteAlignment
, Value
, ValueSize
,
388 MaxBytesToEmit
, CurSectionData
);
389 F
->setAtom(CurrentAtomMap
.lookup(CurSectionData
));
391 // Update the maximum alignment on the current section if necessary.
392 if (ByteAlignment
> CurSectionData
->getAlignment())
393 CurSectionData
->setAlignment(ByteAlignment
);
396 void MCMachOStreamer::EmitCodeAlignment(unsigned ByteAlignment
,
397 unsigned MaxBytesToEmit
) {
398 if (MaxBytesToEmit
== 0)
399 MaxBytesToEmit
= ByteAlignment
;
400 MCAlignFragment
*F
= new MCAlignFragment(ByteAlignment
, 0, 1, MaxBytesToEmit
,
402 F
->setEmitNops(true);
403 F
->setAtom(CurrentAtomMap
.lookup(CurSectionData
));
405 // Update the maximum alignment on the current section if necessary.
406 if (ByteAlignment
> CurSectionData
->getAlignment())
407 CurSectionData
->setAlignment(ByteAlignment
);
410 void MCMachOStreamer::EmitValueToOffset(const MCExpr
*Offset
,
411 unsigned char Value
) {
412 MCFragment
*F
= new MCOrgFragment(*Offset
, Value
, CurSectionData
);
413 F
->setAtom(CurrentAtomMap
.lookup(CurSectionData
));
416 void MCMachOStreamer::EmitInstruction(const MCInst
&Inst
) {
418 for (unsigned i
= Inst
.getNumOperands(); i
--; )
419 if (Inst
.getOperand(i
).isExpr())
420 AddValueSymbols(Inst
.getOperand(i
).getExpr());
422 CurSectionData
->setHasInstructions(true);
424 // FIXME-PERF: Common case is that we don't need to relax, encode directly
425 // onto the data fragments buffers.
427 SmallVector
<MCFixup
, 4> Fixups
;
428 SmallString
<256> Code
;
429 raw_svector_ostream
VecOS(Code
);
430 Assembler
.getEmitter().EncodeInstruction(Inst
, VecOS
, Fixups
);
433 // FIXME: Eliminate this copy.
434 SmallVector
<MCAsmFixup
, 4> AsmFixups
;
435 for (unsigned i
= 0, e
= Fixups
.size(); i
!= e
; ++i
) {
436 MCFixup
&F
= Fixups
[i
];
437 AsmFixups
.push_back(MCAsmFixup(F
.getOffset(), *F
.getValue(),
441 // See if we might need to relax this instruction, if so it needs its own
444 // FIXME-PERF: Support target hook to do a fast path that avoids the encoder,
445 // when we can immediately tell that we will get something which might need
446 // relaxation (and compute its size).
448 // FIXME-PERF: We should also be smart about immediately relaxing instructions
449 // which we can already show will never possibly fit (we can also do a very
450 // good job of this before we do the first relaxation pass, because we have
451 // total knowledge about undefined symbols at that point). Even now, though,
452 // we can do a decent job, especially on Darwin where scattering means that we
453 // are going to often know that we can never fully resolve a fixup.
454 if (Assembler
.getBackend().MayNeedRelaxation(Inst
, AsmFixups
)) {
455 MCInstFragment
*IF
= new MCInstFragment(Inst
, CurSectionData
);
456 IF
->setAtom(CurrentAtomMap
.lookup(CurSectionData
));
458 // Add the fixups and data.
460 // FIXME: Revisit this design decision when relaxation is done, we may be
461 // able to get away with not storing any extra data in the MCInst.
462 IF
->getCode() = Code
;
463 IF
->getFixups() = AsmFixups
;
468 // Add the fixups and data.
469 MCDataFragment
*DF
= getOrCreateDataFragment();
470 for (unsigned i
= 0, e
= AsmFixups
.size(); i
!= e
; ++i
) {
471 AsmFixups
[i
].Offset
+= DF
->getContents().size();
472 DF
->addFixup(AsmFixups
[i
]);
474 DF
->getContents().append(Code
.begin(), Code
.end());
477 void MCMachOStreamer::Finish() {
481 MCStreamer
*llvm::createMachOStreamer(MCContext
&Context
, TargetAsmBackend
&TAB
,
482 raw_ostream
&OS
, MCCodeEmitter
*CE
,
484 MCMachOStreamer
*S
= new MCMachOStreamer(Context
, TAB
, OS
, CE
);
486 S
->getAssembler().setRelaxAll(true);