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/MCSection.h"
15 #include "llvm/MC/MCSymbol.h"
16 #include "llvm/Support/ErrorHandling.h"
21 class MCMachOStreamer : public MCStreamer {
22 /// SymbolFlags - We store the value for the 'desc' symbol field in the lowest
23 /// 16 bits of the implementation defined flags.
24 enum SymbolFlags { // See <mach-o/nlist.h>.
25 SF_DescFlagsMask = 0xFFFF,
27 // Reference type flags.
28 SF_ReferenceTypeMask = 0x0007,
29 SF_ReferenceTypeUndefinedNonLazy = 0x0000,
30 SF_ReferenceTypeUndefinedLazy = 0x0001,
31 SF_ReferenceTypeDefined = 0x0002,
32 SF_ReferenceTypePrivateDefined = 0x0003,
33 SF_ReferenceTypePrivateUndefinedNonLazy = 0x0004,
34 SF_ReferenceTypePrivateUndefinedLazy = 0x0005,
36 // Other 'desc' flags.
37 SF_NoDeadStrip = 0x0020,
38 SF_WeakReference = 0x0040,
39 SF_WeakDefinition = 0x0080
43 MCAssembler Assembler;
45 MCSectionData *CurSectionData;
47 DenseMap<const MCSection*, MCSectionData*> SectionMap;
49 DenseMap<const MCSymbol*, MCSymbolData*> SymbolMap;
52 MCFragment *getCurrentFragment() const {
53 assert(CurSectionData && "No current section!");
55 if (!CurSectionData->empty())
56 return &CurSectionData->getFragmentList().back();
61 MCSymbolData &getSymbolData(MCSymbol &Symbol) {
62 MCSymbolData *&Entry = SymbolMap[&Symbol];
65 Entry = new MCSymbolData(Symbol, 0, 0, &Assembler);
71 MCMachOStreamer(MCContext &Context, raw_ostream &_OS)
72 : MCStreamer(Context), Assembler(_OS), CurSectionData(0) {}
75 const MCValue &AddValueSymbols(const MCValue &Value) {
77 getSymbolData(*const_cast<MCSymbol*>(Value.getSymA()));
79 getSymbolData(*const_cast<MCSymbol*>(Value.getSymB()));
83 /// @name MCStreamer Interface
86 virtual void SwitchSection(const MCSection *Section);
88 virtual void EmitLabel(MCSymbol *Symbol);
90 virtual void EmitAssemblerFlag(AssemblerFlag Flag);
92 virtual void EmitAssignment(MCSymbol *Symbol, const MCValue &Value,
93 bool MakeAbsolute = false);
95 virtual void EmitSymbolAttribute(MCSymbol *Symbol, SymbolAttr Attribute);
97 virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
99 virtual void EmitLocalSymbol(MCSymbol *Symbol, const MCValue &Value);
101 virtual void EmitCommonSymbol(MCSymbol *Symbol, unsigned Size,
102 unsigned Pow2Alignment, bool IsLocal);
104 virtual void EmitZerofill(MCSection *Section, MCSymbol *Symbol = NULL,
105 unsigned Size = 0, unsigned Pow2Alignment = 0);
107 virtual void EmitBytes(const StringRef &Data);
109 virtual void EmitValue(const MCValue &Value, unsigned Size);
111 virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
112 unsigned ValueSize = 1,
113 unsigned MaxBytesToEmit = 0);
115 virtual void EmitValueToOffset(const MCValue &Offset,
116 unsigned char Value = 0);
118 virtual void EmitInstruction(const MCInst &Inst);
120 virtual void Finish();
125 } // end anonymous namespace.
127 void MCMachOStreamer::SwitchSection(const MCSection *Section) {
128 assert(Section && "Cannot switch to a null section!");
130 // If already in this section, then this is a noop.
131 if (Section == CurSection) return;
133 CurSection = Section;
134 MCSectionData *&Entry = SectionMap[Section];
137 Entry = new MCSectionData(*Section, &Assembler);
139 CurSectionData = Entry;
142 void MCMachOStreamer::EmitLabel(MCSymbol *Symbol) {
143 assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
145 // FIXME: We should also use offsets into Fill fragments.
146 MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
148 F = new MCDataFragment(CurSectionData);
150 MCSymbolData &SD = getSymbolData(*Symbol);
151 assert(!SD.getFragment() && "Unexpected fragment on symbol data!");
153 SD.setOffset(F->getContents().size());
155 // This causes the reference type and weak reference flags to be cleared.
156 SD.setFlags(SD.getFlags() & ~(SF_WeakReference | SF_ReferenceTypeMask));
158 Symbol->setSection(*CurSection);
161 void MCMachOStreamer::EmitAssemblerFlag(AssemblerFlag Flag) {
164 llvm_unreachable("FIXME: Not yet implemented!");
166 case SubsectionsViaSymbols:
167 Assembler.setSubsectionsViaSymbols(true);
172 void MCMachOStreamer::EmitAssignment(MCSymbol *Symbol,
173 const MCValue &Value,
175 // Only absolute symbols can be redefined.
176 assert((Symbol->isUndefined() || Symbol->isAbsolute()) &&
177 "Cannot define a symbol twice!");
179 llvm_unreachable("FIXME: Not yet implemented!");
182 void MCMachOStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
183 SymbolAttr Attribute) {
184 // Indirect symbols are handled differently, to match how 'as' handles
185 // them. This makes writing matching .o files easier.
186 if (Attribute == MCStreamer::IndirectSymbol) {
187 // Note that we intentionally cannot use the symbol data here; this is
188 // important for matching the string table that 'as' generates.
189 IndirectSymbolData ISD;
191 ISD.SectionData = CurSectionData;
192 Assembler.getIndirectSymbols().push_back(ISD);
196 // Adding a symbol attribute always introduces the symbol, note that an
197 // important side effect of calling getSymbolData here is to register the
198 // symbol with the assembler.
199 MCSymbolData &SD = getSymbolData(*Symbol);
201 // The implementation of symbol attributes is designed to match 'as', but it
202 // leaves much to desired. It doesn't really make sense to arbitrarily add and
203 // remove flags, but 'as' allows this (in particular, see .desc).
205 // In the future it might be worth trying to make these operations more well
208 case MCStreamer::IndirectSymbol:
209 case MCStreamer::Hidden:
210 case MCStreamer::Internal:
211 case MCStreamer::Protected:
212 case MCStreamer::Weak:
213 assert(0 && "Invalid symbol attribute for Mach-O!");
216 case MCStreamer::Global:
217 getSymbolData(*Symbol).setExternal(true);
220 case MCStreamer::LazyReference:
221 // FIXME: This requires -dynamic.
222 SD.setFlags(SD.getFlags() | SF_NoDeadStrip);
223 if (Symbol->isUndefined())
224 SD.setFlags(SD.getFlags() | SF_ReferenceTypeUndefinedLazy);
227 // Since .reference sets the no dead strip bit, it is equivalent to
228 // .no_dead_strip in practice.
229 case MCStreamer::Reference:
230 case MCStreamer::NoDeadStrip:
231 SD.setFlags(SD.getFlags() | SF_NoDeadStrip);
234 case MCStreamer::PrivateExtern:
235 SD.setExternal(true);
236 SD.setPrivateExtern(true);
239 case MCStreamer::WeakReference:
240 // FIXME: This requires -dynamic.
241 if (Symbol->isUndefined())
242 SD.setFlags(SD.getFlags() | SF_WeakReference);
245 case MCStreamer::WeakDefinition:
246 // FIXME: 'as' enforces that this is defined and global. The manual claims
247 // it has to be in a coalesced section, but this isn't enforced.
248 SD.setFlags(SD.getFlags() | SF_WeakDefinition);
253 void MCMachOStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
254 // Encode the 'desc' value into the lowest implementation defined bits.
255 assert(DescValue == (DescValue & SF_DescFlagsMask) &&
256 "Invalid .desc value!");
257 getSymbolData(*Symbol).setFlags(DescValue & SF_DescFlagsMask);
260 void MCMachOStreamer::EmitLocalSymbol(MCSymbol *Symbol, const MCValue &Value) {
261 llvm_unreachable("FIXME: Not yet implemented!");
264 void MCMachOStreamer::EmitCommonSymbol(MCSymbol *Symbol, unsigned Size,
265 unsigned Pow2Alignment,
267 llvm_unreachable("FIXME: Not yet implemented!");
270 void MCMachOStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol,
271 unsigned Size, unsigned Pow2Alignment) {
272 llvm_unreachable("FIXME: Not yet implemented!");
275 void MCMachOStreamer::EmitBytes(const StringRef &Data) {
276 MCDataFragment *DF = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
278 DF = new MCDataFragment(CurSectionData);
279 DF->getContents().append(Data.begin(), Data.end());
282 void MCMachOStreamer::EmitValue(const MCValue &Value, unsigned Size) {
283 new MCFillFragment(AddValueSymbols(Value), Size, 1, CurSectionData);
286 void MCMachOStreamer::EmitValueToAlignment(unsigned ByteAlignment,
287 int64_t Value, unsigned ValueSize,
288 unsigned MaxBytesToEmit) {
289 if (MaxBytesToEmit == 0)
290 MaxBytesToEmit = ByteAlignment;
291 new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit,
294 // Update the maximum alignment on the current section if necessary.
295 if (ByteAlignment > CurSectionData->getAlignment())
296 CurSectionData->setAlignment(ByteAlignment);
299 void MCMachOStreamer::EmitValueToOffset(const MCValue &Offset,
300 unsigned char Value) {
301 new MCOrgFragment(AddValueSymbols(Offset), Value, CurSectionData);
304 void MCMachOStreamer::EmitInstruction(const MCInst &Inst) {
305 llvm_unreachable("FIXME: Not yet implemented!");
308 void MCMachOStreamer::Finish() {
312 MCStreamer *llvm::createMachOStreamer(MCContext &Context, raw_ostream &OS) {
313 return new MCMachOStreamer(Context, OS);