blob: 6c738aa4a85f7ed4b30536f1b8bb65f50fc91146 [file] [log] [blame]
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +00001//===- lib/MC/MCMachOStreamer.cpp - Mach-O Object Output ------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "llvm/MC/MCStreamer.h"
11
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000012#include "llvm/MC/MCAssembler.h"
13#include "llvm/MC/MCContext.h"
Daniel Dunbar4fac7492009-08-27 08:17:51 +000014#include "llvm/MC/MCCodeEmitter.h"
Daniel Dunbar8c2eebe2009-08-31 08:08:38 +000015#include "llvm/MC/MCExpr.h"
Daniel Dunbar4fac7492009-08-27 08:17:51 +000016#include "llvm/MC/MCInst.h"
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000017#include "llvm/MC/MCSection.h"
18#include "llvm/MC/MCSymbol.h"
Kevin Enderbya6eeb6e2010-05-07 21:44:23 +000019#include "llvm/MC/MCMachOSymbolFlags.h"
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000020#include "llvm/Support/ErrorHandling.h"
Daniel Dunbar4fac7492009-08-27 08:17:51 +000021#include "llvm/Support/raw_ostream.h"
Daniel Dunbard8036fb2010-03-23 05:09:03 +000022#include "llvm/Target/TargetAsmBackend.h"
23
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000024using namespace llvm;
25
26namespace {
27
28class MCMachOStreamer : public MCStreamer {
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +000029
30private:
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000031 MCAssembler Assembler;
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000032 MCSectionData *CurSectionData;
Daniel Dunbarf3d2ef02009-08-22 10:13:24 +000033
Daniel Dunbar071f73d2010-05-10 22:45:09 +000034 /// Track the current atom for each section.
35 DenseMap<const MCSectionData*, MCSymbolData*> CurrentAtomMap;
36
Daniel Dunbarf3d2ef02009-08-22 10:13:24 +000037private:
38 MCFragment *getCurrentFragment() const {
39 assert(CurSectionData && "No current section!");
40
41 if (!CurSectionData->empty())
42 return &CurSectionData->getFragmentList().back();
43
44 return 0;
45 }
46
Daniel Dunbarf70f4772010-03-22 20:35:46 +000047 /// 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());
51 if (!F)
Daniel Dunbar071f73d2010-05-10 22:45:09 +000052 F = createDataFragment();
Daniel Dunbarf70f4772010-03-22 20:35:46 +000053 return F;
54 }
55
Daniel Dunbar071f73d2010-05-10 22:45:09 +000056 /// 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));
60 return DF;
61 }
62
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000063public:
Daniel Dunbar1f3e4452010-03-11 01:34:27 +000064 MCMachOStreamer(MCContext &Context, TargetAsmBackend &TAB,
65 raw_ostream &_OS, MCCodeEmitter *_Emitter)
Daniel Dunbarcf871e52010-03-19 10:43:18 +000066 : MCStreamer(Context), Assembler(Context, TAB, *_Emitter, _OS),
Daniel Dunbar4fac7492009-08-27 08:17:51 +000067 CurSectionData(0) {}
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000068 ~MCMachOStreamer() {}
69
Daniel Dunbarac2884a2010-03-25 22:49:09 +000070 MCAssembler &getAssembler() { return Assembler; }
71
Daniel Dunbar8c2eebe2009-08-31 08:08:38 +000072 const MCExpr *AddValueSymbols(const MCExpr *Value) {
73 switch (Value->getKind()) {
Chris Lattner5d917a82010-02-08 19:41:07 +000074 case MCExpr::Target: assert(0 && "Can't handle target exprs yet!");
Daniel Dunbar8c2eebe2009-08-31 08:08:38 +000075 case MCExpr::Constant:
76 break;
77
78 case MCExpr::Binary: {
79 const MCBinaryExpr *BE = cast<MCBinaryExpr>(Value);
80 AddValueSymbols(BE->getLHS());
81 AddValueSymbols(BE->getRHS());
82 break;
83 }
84
85 case MCExpr::SymbolRef:
Daniel Dunbar46836a72010-03-10 20:58:29 +000086 Assembler.getOrCreateSymbolData(
87 cast<MCSymbolRefExpr>(Value)->getSymbol());
Daniel Dunbar8c2eebe2009-08-31 08:08:38 +000088 break;
89
90 case MCExpr::Unary:
91 AddValueSymbols(cast<MCUnaryExpr>(Value)->getSubExpr());
92 break;
93 }
94
95 return Value;
96 }
97
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +000098 /// @name MCStreamer Interface
99 /// @{
100
101 virtual void SwitchSection(const MCSection *Section);
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000102 virtual void EmitLabel(MCSymbol *Symbol);
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000103 virtual void EmitAssemblerFlag(MCAssemblerFlag Flag);
Daniel Dunbar821e3332009-08-31 08:09:28 +0000104 virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value);
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000105 virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute);
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000106 virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
Chris Lattner9eb158d2010-01-23 07:47:02 +0000107 virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
Daniel Dunbar7092c7e2009-08-30 06:17:16 +0000108 unsigned ByteAlignment);
Chris Lattnerb54b9dd2010-05-08 19:54:22 +0000109 virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol) {
110 assert(0 && "macho doesn't support this directive");
111 }
112 virtual void EmitCOFFSymbolStorageClass(int StorageClass) {
113 assert(0 && "macho doesn't support this directive");
114 }
115 virtual void EmitCOFFSymbolType(int Type) {
116 assert(0 && "macho doesn't support this directive");
117 }
118 virtual void EndCOFFSymbolDef() {
119 assert(0 && "macho doesn't support this directive");
120 }
Chris Lattner99328ad2010-01-25 07:52:13 +0000121 virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
122 assert(0 && "macho doesn't support this directive");
123 }
Chris Lattner9eb158d2010-01-23 07:47:02 +0000124 virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size) {
125 assert(0 && "macho doesn't support this directive");
126 }
Daniel Dunbar8751b942009-08-28 05:48:22 +0000127 virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol = 0,
Daniel Dunbar7092c7e2009-08-30 06:17:16 +0000128 unsigned Size = 0, unsigned ByteAlignment = 0);
Eric Christopher011c3f12010-05-18 21:26:41 +0000129 virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
130 uint64_t Size, unsigned ByteAlignment = 0);
Chris Lattneraaec2052010-01-19 19:46:13 +0000131 virtual void EmitBytes(StringRef Data, unsigned AddrSpace);
Chris Lattneraaec2052010-01-19 19:46:13 +0000132 virtual void EmitValue(const MCExpr *Value, unsigned Size,unsigned AddrSpace);
Chris Lattner718fb592010-01-25 21:28:50 +0000133 virtual void EmitGPRel32Value(const MCExpr *Value) {
134 assert(0 && "macho doesn't support this directive");
135 }
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000136 virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
137 unsigned ValueSize = 1,
138 unsigned MaxBytesToEmit = 0);
Kevin Enderby6e720482010-02-23 18:26:34 +0000139 virtual void EmitCodeAlignment(unsigned ByteAlignment,
140 unsigned MaxBytesToEmit = 0);
Daniel Dunbar821e3332009-08-31 08:09:28 +0000141 virtual void EmitValueToOffset(const MCExpr *Offset,
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000142 unsigned char Value = 0);
Chris Lattnera6594fc2010-01-25 18:58:59 +0000143
144 virtual void EmitFileDirective(StringRef Filename) {
Daniel Dunbarca1212d2010-05-18 17:28:17 +0000145 report_fatal_error("unsupported directive: '.file'");
Chris Lattnera6594fc2010-01-25 18:58:59 +0000146 }
147 virtual void EmitDwarfFileDirective(unsigned FileNo, StringRef Filename) {
Daniel Dunbarca1212d2010-05-18 17:28:17 +0000148 report_fatal_error("unsupported directive: '.file'");
Chris Lattnera6594fc2010-01-25 18:58:59 +0000149 }
150
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000151 virtual void EmitInstruction(const MCInst &Inst);
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000152 virtual void Finish();
153
154 /// @}
155};
156
157} // end anonymous namespace.
158
159void MCMachOStreamer::SwitchSection(const MCSection *Section) {
160 assert(Section && "Cannot switch to a null section!");
Chris Lattnercda7f782009-08-22 19:35:08 +0000161
162 // If already in this section, then this is a noop.
163 if (Section == CurSection) return;
Daniel Dunbar0f5fa692009-08-28 05:48:54 +0000164
Chris Lattnercda7f782009-08-22 19:35:08 +0000165 CurSection = Section;
Daniel Dunbar46836a72010-03-10 20:58:29 +0000166 CurSectionData = &Assembler.getOrCreateSectionData(*Section);
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000167}
168
169void MCMachOStreamer::EmitLabel(MCSymbol *Symbol) {
Daniel Dunbar8906ff12009-08-22 07:22:36 +0000170 assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
Daniel Dunbarc3047182010-05-05 19:01:00 +0000171 assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
172 assert(CurSection && "Cannot emit before setting section!");
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000173
Daniel Dunbar071f73d2010-05-10 22:45:09 +0000174 MCSymbolData &SD = Assembler.getOrCreateSymbolData(*Symbol);
175
176 // Update the current atom map, if necessary.
177 bool MustCreateFragment = false;
178 if (Assembler.isSymbolLinkerVisible(&SD)) {
179 CurrentAtomMap[CurSectionData] = &SD;
180
181 // We have to create a new fragment, fragments cannot span atoms.
182 MustCreateFragment = true;
183 }
184
Daniel Dunbarf70f4772010-03-22 20:35:46 +0000185 // 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.
Daniel Dunbar071f73d2010-05-10 22:45:09 +0000189 MCDataFragment *F =
190 MustCreateFragment ? createDataFragment() : getOrCreateDataFragment();
Daniel Dunbarf3d2ef02009-08-22 10:13:24 +0000191 assert(!SD.getFragment() && "Unexpected fragment on symbol data!");
192 SD.setFragment(F);
193 SD.setOffset(F->getContents().size());
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000194
Daniel Dunbarb18d2dd2010-05-17 20:12:31 +0000195 // 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
198 // diffability.
199 //
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);
Daniel Dunbarf3d2ef02009-08-22 10:13:24 +0000203
Daniel Dunbar8906ff12009-08-22 07:22:36 +0000204 Symbol->setSection(*CurSection);
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000205}
206
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000207void MCMachOStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
Daniel Dunbar6009db42009-08-26 21:22:22 +0000208 switch (Flag) {
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000209 case MCAF_SubsectionsViaSymbols:
Daniel Dunbar6009db42009-08-26 21:22:22 +0000210 Assembler.setSubsectionsViaSymbols(true);
Daniel Dunbar8c3eaf42009-08-28 07:08:47 +0000211 return;
Daniel Dunbar6009db42009-08-26 21:22:22 +0000212 }
Daniel Dunbar8c3eaf42009-08-28 07:08:47 +0000213
214 assert(0 && "invalid assembler flag!");
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000215}
216
Daniel Dunbar821e3332009-08-31 08:09:28 +0000217void MCMachOStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
Daniel Dunbara4d86672009-10-16 01:58:23 +0000218 // FIXME: Lift context changes into super class.
Daniel Dunbar2ae4bfd2010-05-18 17:28:24 +0000219 Assembler.getOrCreateSymbolData(*Symbol);
Daniel Dunbar08a408a2010-05-05 17:41:00 +0000220 Symbol->setVariableValue(AddValueSymbols(Value));
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000221}
222
223void MCMachOStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000224 MCSymbolAttr Attribute) {
Daniel Dunbar0c7761b2009-08-24 11:56:58 +0000225 // Indirect symbols are handled differently, to match how 'as' handles
226 // them. This makes writing matching .o files easier.
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000227 if (Attribute == MCSA_IndirectSymbol) {
Daniel Dunbarad7c3d52009-08-26 00:18:21 +0000228 // Note that we intentionally cannot use the symbol data here; this is
229 // important for matching the string table that 'as' generates.
Daniel Dunbar0c7761b2009-08-24 11:56:58 +0000230 IndirectSymbolData ISD;
231 ISD.Symbol = Symbol;
232 ISD.SectionData = CurSectionData;
233 Assembler.getIndirectSymbols().push_back(ISD);
234 return;
235 }
236
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000237 // Adding a symbol attribute always introduces the symbol, note that an
Daniel Dunbar46836a72010-03-10 20:58:29 +0000238 // important side effect of calling getOrCreateSymbolData here is to register
239 // the symbol with the assembler.
240 MCSymbolData &SD = Assembler.getOrCreateSymbolData(*Symbol);
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000241
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).
245 //
246 // In the future it might be worth trying to make these operations more well
247 // defined.
Daniel Dunbar3edd9bb2009-08-22 11:41:10 +0000248 switch (Attribute) {
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000249 case MCSA_Invalid:
Chris Lattnered0ab152010-01-25 18:30:45 +0000250 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:
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000256 case MCSA_IndirectSymbol:
257 case MCSA_Hidden:
258 case MCSA_Internal:
259 case MCSA_Protected:
260 case MCSA_Weak:
261 case MCSA_Local:
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000262 assert(0 && "Invalid symbol attribute for Mach-O!");
263 break;
Daniel Dunbar3edd9bb2009-08-22 11:41:10 +0000264
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000265 case MCSA_Global:
Daniel Dunbar8f4d1462009-08-28 07:08:35 +0000266 SD.setExternal(true);
Daniel Dunbarb18d2dd2010-05-17 20:12:31 +0000267 // 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
269 // lookup.
270 //
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);
Daniel Dunbar3edd9bb2009-08-22 11:41:10 +0000274 break;
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000275
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000276 case MCSA_LazyReference:
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000277 // FIXME: This requires -dynamic.
278 SD.setFlags(SD.getFlags() | SF_NoDeadStrip);
279 if (Symbol->isUndefined())
280 SD.setFlags(SD.getFlags() | SF_ReferenceTypeUndefinedLazy);
281 break;
282
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000283 // Since .reference sets the no dead strip bit, it is equivalent to
284 // .no_dead_strip in practice.
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000285 case MCSA_Reference:
286 case MCSA_NoDeadStrip:
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000287 SD.setFlags(SD.getFlags() | SF_NoDeadStrip);
288 break;
289
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000290 case MCSA_PrivateExtern:
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000291 SD.setExternal(true);
292 SD.setPrivateExtern(true);
293 break;
294
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000295 case MCSA_WeakReference:
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000296 // FIXME: This requires -dynamic.
297 if (Symbol->isUndefined())
298 SD.setFlags(SD.getFlags() | SF_WeakReference);
299 break;
300
Chris Lattnera5ad93a2010-01-23 06:39:22 +0000301 case MCSA_WeakDefinition:
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000302 // 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);
305 break;
Daniel Dunbar3edd9bb2009-08-22 11:41:10 +0000306 }
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000307}
308
309void MCMachOStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
Daniel Dunbar6aff2fb2009-08-24 08:40:12 +0000310 // Encode the 'desc' value into the lowest implementation defined bits.
311 assert(DescValue == (DescValue & SF_DescFlagsMask) &&
312 "Invalid .desc value!");
Daniel Dunbar46836a72010-03-10 20:58:29 +0000313 Assembler.getOrCreateSymbolData(*Symbol).setFlags(DescValue&SF_DescFlagsMask);
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000314}
315
Chris Lattner9eb158d2010-01-23 07:47:02 +0000316void MCMachOStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
Daniel Dunbar7092c7e2009-08-30 06:17:16 +0000317 unsigned ByteAlignment) {
Daniel Dunbar8f4d1462009-08-28 07:08:35 +0000318 // FIXME: Darwin 'as' does appear to allow redef of a .comm by itself.
319 assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
320
Daniel Dunbar46836a72010-03-10 20:58:29 +0000321 MCSymbolData &SD = Assembler.getOrCreateSymbolData(*Symbol);
Daniel Dunbar8f4d1462009-08-28 07:08:35 +0000322 SD.setExternal(true);
Daniel Dunbar7092c7e2009-08-30 06:17:16 +0000323 SD.setCommon(Size, ByteAlignment);
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000324}
325
Daniel Dunbar8751b942009-08-28 05:48:22 +0000326void MCMachOStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
Daniel Dunbar7092c7e2009-08-30 06:17:16 +0000327 unsigned Size, unsigned ByteAlignment) {
Daniel Dunbar46836a72010-03-10 20:58:29 +0000328 MCSectionData &SectData = Assembler.getOrCreateSectionData(*Section);
Daniel Dunbard5a8e982009-08-28 05:49:21 +0000329
330 // The symbol may not be present, which only creates the section.
331 if (!Symbol)
332 return;
333
334 // FIXME: Assert that this section has the zerofill type.
335
336 assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
337
Daniel Dunbar46836a72010-03-10 20:58:29 +0000338 MCSymbolData &SD = Assembler.getOrCreateSymbolData(*Symbol);
Daniel Dunbard5a8e982009-08-28 05:49:21 +0000339
Daniel Dunbare73d49e2010-05-12 22:51:27 +0000340 // Emit an align fragment if necessary.
341 if (ByteAlignment != 1)
Daniel Dunbar1c154132010-05-12 22:56:23 +0000342 new MCAlignFragment(ByteAlignment, 0, 0, ByteAlignment, &SectData);
Daniel Dunbare73d49e2010-05-12 22:51:27 +0000343
Daniel Dunbar4e544872010-05-12 22:51:38 +0000344 MCFragment *F = new MCFillFragment(0, 0, Size, &SectData);
Daniel Dunbard5a8e982009-08-28 05:49:21 +0000345 SD.setFragment(F);
Daniel Dunbar071f73d2010-05-10 22:45:09 +0000346 if (Assembler.isSymbolLinkerVisible(&SD))
347 F->setAtom(&SD);
Daniel Dunbard5a8e982009-08-28 05:49:21 +0000348
349 Symbol->setSection(*Section);
350
351 // Update the maximum alignment on the zero fill section if necessary.
352 if (ByteAlignment > SectData.getAlignment())
353 SectData.setAlignment(ByteAlignment);
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000354}
355
Eric Christopher070c1ab2010-05-21 23:03:53 +0000356// This should always be called with the thread local bss section. Like the
357// .zerofill directive this doesn't actually switch sections on us.
Eric Christopher011c3f12010-05-18 21:26:41 +0000358void MCMachOStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
359 uint64_t Size, unsigned ByteAlignment) {
360 EmitZerofill(Section, Symbol, Size, ByteAlignment);
361 return;
Eric Christopher482eba02010-05-14 01:50:28 +0000362}
363
Chris Lattneraaec2052010-01-19 19:46:13 +0000364void MCMachOStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) {
Daniel Dunbarf70f4772010-03-22 20:35:46 +0000365 getOrCreateDataFragment()->getContents().append(Data.begin(), Data.end());
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000366}
367
Chris Lattneraaec2052010-01-19 19:46:13 +0000368void MCMachOStreamer::EmitValue(const MCExpr *Value, unsigned Size,
369 unsigned AddrSpace) {
Daniel Dunbarf70f4772010-03-22 20:35:46 +0000370 MCDataFragment *DF = getOrCreateDataFragment();
Daniel Dunbar45f48742010-02-13 09:28:22 +0000371
372 // Avoid fixups when possible.
373 int64_t AbsValue;
Daniel Dunbar40ebe2472010-02-22 22:08:57 +0000374 if (AddValueSymbols(Value)->EvaluateAsAbsolute(AbsValue)) {
Daniel Dunbar45f48742010-02-13 09:28:22 +0000375 // FIXME: Endianness assumption.
376 for (unsigned i = 0; i != Size; ++i)
377 DF->getContents().push_back(uint8_t(AbsValue >> (i * 8)));
378 } else {
Daniel Dunbarc90e30a2010-05-26 15:18:56 +0000379 DF->addFixup(MCFixup::Create(DF->getContents().size(),
380 AddValueSymbols(Value),
381 MCFixup::getKindForSize(Size)));
Daniel Dunbar45f48742010-02-13 09:28:22 +0000382 DF->getContents().resize(DF->getContents().size() + Size, 0);
383 }
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000384}
385
386void MCMachOStreamer::EmitValueToAlignment(unsigned ByteAlignment,
387 int64_t Value, unsigned ValueSize,
388 unsigned MaxBytesToEmit) {
Daniel Dunbard6f761e2009-08-21 23:07:38 +0000389 if (MaxBytesToEmit == 0)
390 MaxBytesToEmit = ByteAlignment;
Daniel Dunbar071f73d2010-05-10 22:45:09 +0000391 MCFragment *F = new MCAlignFragment(ByteAlignment, Value, ValueSize,
Daniel Dunbar1c154132010-05-12 22:56:23 +0000392 MaxBytesToEmit, CurSectionData);
Daniel Dunbar071f73d2010-05-10 22:45:09 +0000393 F->setAtom(CurrentAtomMap.lookup(CurSectionData));
Kevin Enderby6e720482010-02-23 18:26:34 +0000394
395 // Update the maximum alignment on the current section if necessary.
396 if (ByteAlignment > CurSectionData->getAlignment())
397 CurSectionData->setAlignment(ByteAlignment);
398}
399
400void MCMachOStreamer::EmitCodeAlignment(unsigned ByteAlignment,
401 unsigned MaxBytesToEmit) {
402 if (MaxBytesToEmit == 0)
403 MaxBytesToEmit = ByteAlignment;
Daniel Dunbar1c154132010-05-12 22:56:23 +0000404 MCAlignFragment *F = new MCAlignFragment(ByteAlignment, 0, 1, MaxBytesToEmit,
405 CurSectionData);
406 F->setEmitNops(true);
Daniel Dunbar071f73d2010-05-10 22:45:09 +0000407 F->setAtom(CurrentAtomMap.lookup(CurSectionData));
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000408
Daniel Dunbarf3d2ef02009-08-22 10:13:24 +0000409 // Update the maximum alignment on the current section if necessary.
Daniel Dunbar0705fbf2009-08-21 18:29:01 +0000410 if (ByteAlignment > CurSectionData->getAlignment())
411 CurSectionData->setAlignment(ByteAlignment);
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000412}
413
Daniel Dunbar821e3332009-08-31 08:09:28 +0000414void MCMachOStreamer::EmitValueToOffset(const MCExpr *Offset,
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000415 unsigned char Value) {
Daniel Dunbar071f73d2010-05-10 22:45:09 +0000416 MCFragment *F = new MCOrgFragment(*Offset, Value, CurSectionData);
417 F->setAtom(CurrentAtomMap.lookup(CurSectionData));
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000418}
419
420void MCMachOStreamer::EmitInstruction(const MCInst &Inst) {
Daniel Dunbar4fac7492009-08-27 08:17:51 +0000421 // Scan for values.
Daniel Dunbardb9014d2010-05-17 21:19:59 +0000422 for (unsigned i = Inst.getNumOperands(); i--; )
Daniel Dunbar8c2eebe2009-08-31 08:08:38 +0000423 if (Inst.getOperand(i).isExpr())
424 AddValueSymbols(Inst.getOperand(i).getExpr());
Daniel Dunbar4fac7492009-08-27 08:17:51 +0000425
Daniel Dunbare1ec6172010-02-02 21:44:01 +0000426 CurSectionData->setHasInstructions(true);
427
Daniel Dunbar3f4dcd92010-03-22 23:16:48 +0000428 // FIXME-PERF: Common case is that we don't need to relax, encode directly
429 // onto the data fragments buffers.
430
Daniel Dunbar73c55742010-02-09 22:59:55 +0000431 SmallVector<MCFixup, 4> Fixups;
Daniel Dunbar4fac7492009-08-27 08:17:51 +0000432 SmallString<256> Code;
433 raw_svector_ostream VecOS(Code);
Daniel Dunbarcf871e52010-03-19 10:43:18 +0000434 Assembler.getEmitter().EncodeInstruction(Inst, VecOS, Fixups);
Daniel Dunbarf6346762010-02-13 09:29:02 +0000435 VecOS.flush();
436
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000437 // See if we might need to relax this instruction, if so it needs its own
438 // fragment.
439 //
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).
443 //
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.
Daniel Dunbar84882522010-05-26 17:45:29 +0000450 if (Assembler.getBackend().MayNeedRelaxation(Inst)) {
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000451 MCInstFragment *IF = new MCInstFragment(Inst, CurSectionData);
Daniel Dunbar071f73d2010-05-10 22:45:09 +0000452 IF->setAtom(CurrentAtomMap.lookup(CurSectionData));
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000453
454 // Add the fixups and data.
455 //
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;
Daniel Dunbardae5b9f2010-05-26 17:50:16 +0000459 IF->getFixups() = Fixups;
Daniel Dunbard8036fb2010-03-23 05:09:03 +0000460
461 return;
462 }
463
Daniel Dunbar337055e2010-03-23 03:13:05 +0000464 // Add the fixups and data.
465 MCDataFragment *DF = getOrCreateDataFragment();
Daniel Dunbardae5b9f2010-05-26 17:50:16 +0000466 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]);
Daniel Dunbarf6346762010-02-13 09:29:02 +0000469 }
470 DF->getContents().append(Code.begin(), Code.end());
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000471}
472
473void MCMachOStreamer::Finish() {
474 Assembler.Finish();
475}
476
Daniel Dunbar1f3e4452010-03-11 01:34:27 +0000477MCStreamer *llvm::createMachOStreamer(MCContext &Context, TargetAsmBackend &TAB,
Daniel Dunbarac2884a2010-03-25 22:49:09 +0000478 raw_ostream &OS, MCCodeEmitter *CE,
479 bool RelaxAll) {
480 MCMachOStreamer *S = new MCMachOStreamer(Context, TAB, OS, CE);
481 if (RelaxAll)
482 S->getAssembler().setRelaxAll(true);
483 return S;
Daniel Dunbarfb4a6b32009-08-21 09:11:24 +0000484}