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 /// @name MCStreamer Interface
78 virtual void SwitchSection(const MCSection *Section);
80 virtual void EmitLabel(MCSymbol *Symbol);
82 virtual void EmitAssemblerFlag(AssemblerFlag Flag);
84 virtual void EmitAssignment(MCSymbol *Symbol, const MCValue &Value,
85 bool MakeAbsolute = false);
87 virtual void EmitSymbolAttribute(MCSymbol *Symbol, SymbolAttr Attribute);
89 virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
91 virtual void EmitLocalSymbol(MCSymbol *Symbol, const MCValue &Value);
93 virtual void EmitCommonSymbol(MCSymbol *Symbol, unsigned Size,
94 unsigned Pow2Alignment, bool IsLocal);
96 virtual void EmitZerofill(MCSection *Section, MCSymbol *Symbol = NULL,
97 unsigned Size = 0, unsigned Pow2Alignment = 0);
99 virtual void EmitBytes(const StringRef &Data);
101 virtual void EmitValue(const MCValue &Value, unsigned Size);
103 virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
104 unsigned ValueSize = 1,
105 unsigned MaxBytesToEmit = 0);
107 virtual void EmitValueToOffset(const MCValue &Offset,
108 unsigned char Value = 0);
110 virtual void EmitInstruction(const MCInst &Inst);
112 virtual void Finish();
117 } // end anonymous namespace.
119 void MCMachOStreamer::SwitchSection(const MCSection *Section) {
120 assert(Section && "Cannot switch to a null section!");
122 // If already in this section, then this is a noop.
123 if (Section == CurSection) return;
125 CurSection = Section;
126 MCSectionData *&Entry = SectionMap[Section];
129 Entry = new MCSectionData(*Section, &Assembler);
131 CurSectionData = Entry;
134 void MCMachOStreamer::EmitLabel(MCSymbol *Symbol) {
135 assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
137 MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
139 F = new MCDataFragment(CurSectionData);
141 MCSymbolData &SD = getSymbolData(*Symbol);
142 assert(!SD.getFragment() && "Unexpected fragment on symbol data!");
144 SD.setOffset(F->getContents().size());
146 // This causes the reference type and weak reference flags to be cleared.
147 SD.setFlags(SD.getFlags() & ~(SF_WeakReference | SF_ReferenceTypeMask));
149 Symbol->setSection(*CurSection);
152 void MCMachOStreamer::EmitAssemblerFlag(AssemblerFlag Flag) {
153 llvm_unreachable("FIXME: Not yet implemented!");
156 void MCMachOStreamer::EmitAssignment(MCSymbol *Symbol,
157 const MCValue &Value,
159 // Only absolute symbols can be redefined.
160 assert((Symbol->isUndefined() || Symbol->isAbsolute()) &&
161 "Cannot define a symbol twice!");
163 llvm_unreachable("FIXME: Not yet implemented!");
166 void MCMachOStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
167 SymbolAttr Attribute) {
168 // Adding a symbol attribute always introduces the symbol, note that an
169 // important side effect of calling getSymbolData here is to register the
170 // symbol with the assembler.
171 MCSymbolData &SD = getSymbolData(*Symbol);
173 // The implementation of symbol attributes is designed to match 'as', but it
174 // leaves much to desired. It doesn't really make sense to arbitrarily add and
175 // remove flags, but 'as' allows this (in particular, see .desc).
177 // In the future it might be worth trying to make these operations more well
180 case MCStreamer::Hidden:
181 case MCStreamer::Internal:
182 case MCStreamer::Protected:
183 case MCStreamer::Weak:
184 assert(0 && "Invalid symbol attribute for Mach-O!");
187 case MCStreamer::Global:
188 getSymbolData(*Symbol).setExternal(true);
191 case MCStreamer::LazyReference:
192 // FIXME: This requires -dynamic.
193 SD.setFlags(SD.getFlags() | SF_NoDeadStrip);
194 if (Symbol->isUndefined())
195 SD.setFlags(SD.getFlags() | SF_ReferenceTypeUndefinedLazy);
198 case MCStreamer::IndirectSymbol:
199 llvm_unreachable("FIXME: Not yet implemented!");
202 // Since .reference sets the no dead strip bit, it is equivalent to
203 // .no_dead_strip in practice.
204 case MCStreamer::Reference:
205 case MCStreamer::NoDeadStrip:
206 SD.setFlags(SD.getFlags() | SF_NoDeadStrip);
209 case MCStreamer::PrivateExtern:
210 SD.setExternal(true);
211 SD.setPrivateExtern(true);
214 case MCStreamer::WeakReference:
215 // FIXME: This requires -dynamic.
216 if (Symbol->isUndefined())
217 SD.setFlags(SD.getFlags() | SF_WeakReference);
220 case MCStreamer::WeakDefinition:
221 // FIXME: 'as' enforces that this is defined and global. The manual claims
222 // it has to be in a coalesced section, but this isn't enforced.
223 SD.setFlags(SD.getFlags() | SF_WeakDefinition);
228 void MCMachOStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
229 // Encode the 'desc' value into the lowest implementation defined bits.
230 assert(DescValue == (DescValue & SF_DescFlagsMask) &&
231 "Invalid .desc value!");
232 getSymbolData(*Symbol).setFlags(DescValue & SF_DescFlagsMask);
235 void MCMachOStreamer::EmitLocalSymbol(MCSymbol *Symbol, const MCValue &Value) {
236 llvm_unreachable("FIXME: Not yet implemented!");
239 void MCMachOStreamer::EmitCommonSymbol(MCSymbol *Symbol, unsigned Size,
240 unsigned Pow2Alignment,
242 llvm_unreachable("FIXME: Not yet implemented!");
245 void MCMachOStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol,
246 unsigned Size, unsigned Pow2Alignment) {
247 llvm_unreachable("FIXME: Not yet implemented!");
250 void MCMachOStreamer::EmitBytes(const StringRef &Data) {
251 MCDataFragment *DF = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
253 DF = new MCDataFragment(CurSectionData);
254 DF->getContents().append(Data.begin(), Data.end());
257 void MCMachOStreamer::EmitValue(const MCValue &Value, unsigned Size) {
258 new MCFillFragment(Value, Size, 1, CurSectionData);
261 void MCMachOStreamer::EmitValueToAlignment(unsigned ByteAlignment,
262 int64_t Value, unsigned ValueSize,
263 unsigned MaxBytesToEmit) {
264 if (MaxBytesToEmit == 0)
265 MaxBytesToEmit = ByteAlignment;
266 new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit,
269 // Update the maximum alignment on the current section if necessary.
270 if (ByteAlignment > CurSectionData->getAlignment())
271 CurSectionData->setAlignment(ByteAlignment);
274 void MCMachOStreamer::EmitValueToOffset(const MCValue &Offset,
275 unsigned char Value) {
276 new MCOrgFragment(Offset, Value, CurSectionData);
279 void MCMachOStreamer::EmitInstruction(const MCInst &Inst) {
280 llvm_unreachable("FIXME: Not yet implemented!");
283 void MCMachOStreamer::Finish() {
287 MCStreamer *llvm::createMachOStreamer(MCContext &Context, raw_ostream &OS) {
288 return new MCMachOStreamer(Context, OS);