blob: c16a61d2b69541da6fc071dfe8b98739c3164e4a [file] [log] [blame]
Nick Lewycky462bba32013-03-09 09:31:44 +00001//===- lib/MC/MCELFStreamer.cpp - ELF Object Output -----------------------===//
Matt Fleming3565a062010-08-16 18:57:57 +00002//
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// This file assembles .s files and emits ELF .o object files.
11//
12//===----------------------------------------------------------------------===//
13
Logan Chien64501652012-12-07 15:50:40 +000014#include "llvm/MC/MCELFStreamer.h"
Rafael Espindolaf340a292012-01-07 23:18:39 +000015#include "llvm/ADT/SmallPtrSet.h"
Peter Collingbourne01a7b5c2013-04-10 16:52:15 +000016#include "llvm/ADT/STLExtras.h"
Rafael Espindolaf340a292012-01-07 23:18:39 +000017#include "llvm/MC/MCAssembler.h"
Matt Fleming3565a062010-08-16 18:57:57 +000018#include "llvm/MC/MCCodeEmitter.h"
Rafael Espindolaf340a292012-01-07 23:18:39 +000019#include "llvm/MC/MCContext.h"
Tim Northover6eb3e872012-12-07 16:50:23 +000020#include "llvm/MC/MCELF.h"
Matt Fleming3565a062010-08-16 18:57:57 +000021#include "llvm/MC/MCELFSymbolFlags.h"
22#include "llvm/MC/MCExpr.h"
23#include "llvm/MC/MCInst.h"
Rafael Espindolaf340a292012-01-07 23:18:39 +000024#include "llvm/MC/MCObjectStreamer.h"
Matt Fleming3565a062010-08-16 18:57:57 +000025#include "llvm/MC/MCSection.h"
Chandler Carruthd04a8d42012-12-03 16:50:05 +000026#include "llvm/MC/MCSectionELF.h"
Matt Fleming3565a062010-08-16 18:57:57 +000027#include "llvm/MC/MCSymbol.h"
Rafael Espindola484291c2010-11-01 14:28:48 +000028#include "llvm/MC/MCValue.h"
Matt Fleming3565a062010-08-16 18:57:57 +000029#include "llvm/Support/Debug.h"
30#include "llvm/Support/ELF.h"
31#include "llvm/Support/ErrorHandling.h"
32#include "llvm/Support/raw_ostream.h"
Matt Fleming3565a062010-08-16 18:57:57 +000033
34using namespace llvm;
35
Rafael Espindolaf340a292012-01-07 23:18:39 +000036
Logan Chien64501652012-12-07 15:50:40 +000037inline void MCELFStreamer::SetSection(StringRef Section, unsigned Type,
38 unsigned Flags, SectionKind Kind) {
39 SwitchSection(getContext().getELFSection(Section, Type, Flags, Kind));
40}
Rafael Espindolaf340a292012-01-07 23:18:39 +000041
Logan Chien64501652012-12-07 15:50:40 +000042inline void MCELFStreamer::SetSectionData() {
43 SetSection(".data",
44 ELF::SHT_PROGBITS,
45 ELF::SHF_WRITE | ELF::SHF_ALLOC,
46 SectionKind::getDataRel());
47 EmitCodeAlignment(4, 0);
48}
Rafael Espindolaf340a292012-01-07 23:18:39 +000049
Logan Chien64501652012-12-07 15:50:40 +000050inline void MCELFStreamer::SetSectionText() {
51 SetSection(".text",
52 ELF::SHT_PROGBITS,
53 ELF::SHF_EXECINSTR | ELF::SHF_ALLOC,
54 SectionKind::getText());
55 EmitCodeAlignment(4, 0);
56}
Rafael Espindolaf340a292012-01-07 23:18:39 +000057
Logan Chien64501652012-12-07 15:50:40 +000058inline void MCELFStreamer::SetSectionBss() {
59 SetSection(".bss",
60 ELF::SHT_NOBITS,
61 ELF::SHF_WRITE | ELF::SHF_ALLOC,
62 SectionKind::getBSS());
63 EmitCodeAlignment(4, 0);
64}
Rafael Espindolaf340a292012-01-07 23:18:39 +000065
Logan Chien64501652012-12-07 15:50:40 +000066MCELFStreamer::~MCELFStreamer() {
Rafael Espindolaf340a292012-01-07 23:18:39 +000067}
68
Eli Bendersky030f63a2013-01-14 19:04:57 +000069void MCELFStreamer::InitToTextSection() {
70 SetSectionText();
71}
72
Rafael Espindolad80781b2010-09-15 21:48:40 +000073void MCELFStreamer::InitSections() {
74 // This emulates the same behavior of GNU as. This makes it easier
75 // to compare the output as the major sections are in the same order.
76 SetSectionText();
77 SetSectionData();
78 SetSectionBss();
79 SetSectionText();
80}
81
Matt Fleming3565a062010-08-16 18:57:57 +000082void MCELFStreamer::EmitLabel(MCSymbol *Symbol) {
Rafael Espindolaba210242010-11-28 16:22:59 +000083 assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
84
Rafael Espindolaea4afa92010-11-28 17:18:55 +000085 MCObjectStreamer::EmitLabel(Symbol);
Rafael Espindola73ffea42010-09-25 05:42:19 +000086
Rafael Espindolae1a25872010-11-11 19:04:55 +000087 const MCSectionELF &Section =
88 static_cast<const MCSectionELF&>(Symbol->getSection());
Rafael Espindolaea4afa92010-11-28 17:18:55 +000089 MCSymbolData &SD = getAssembler().getSymbolData(*Symbol);
Rafael Espindola1c130262011-01-23 04:43:11 +000090 if (Section.getFlags() & ELF::SHF_TLS)
Jan Sjödin2ddfd952011-02-28 21:45:04 +000091 MCELF::SetType(SD, ELF::STT_TLS);
Matt Fleming3565a062010-08-16 18:57:57 +000092}
93
Reed Kotler2c3a4642012-12-16 04:00:45 +000094void MCELFStreamer::EmitDebugLabel(MCSymbol *Symbol) {
95 EmitLabel(Symbol);
96}
97
Matt Fleming3565a062010-08-16 18:57:57 +000098void MCELFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
99 switch (Flag) {
Jim Grosbachce792992010-11-05 22:08:08 +0000100 case MCAF_SyntaxUnified: return; // no-op here.
Evan Chengbd27f5a2011-07-27 00:38:12 +0000101 case MCAF_Code16: return; // Change parsing mode; no-op here.
102 case MCAF_Code32: return; // Change parsing mode; no-op here.
103 case MCAF_Code64: return; // Change parsing mode; no-op here.
Matt Fleming3565a062010-08-16 18:57:57 +0000104 case MCAF_SubsectionsViaSymbols:
105 getAssembler().setSubsectionsViaSymbols(true);
106 return;
107 }
108
Craig Topper85814382012-02-07 05:05:23 +0000109 llvm_unreachable("invalid assembler flag!");
Matt Fleming3565a062010-08-16 18:57:57 +0000110}
111
Peter Collingbournedf39be62013-04-17 21:18:16 +0000112void MCELFStreamer::ChangeSection(const MCSection *Section,
113 const MCExpr *Subsection) {
Eli Bendersky4766ef42012-12-20 19:05:53 +0000114 MCSectionData *CurSection = getCurrentSectionData();
115 if (CurSection && CurSection->isBundleLocked())
116 report_fatal_error("Unterminated .bundle_lock when changing a section");
Rafael Espindola1f4f9e32010-11-14 04:17:37 +0000117 const MCSymbol *Grp = static_cast<const MCSectionELF *>(Section)->getGroup();
118 if (Grp)
119 getAssembler().getOrCreateSymbolData(*Grp);
Peter Collingbournedf39be62013-04-17 21:18:16 +0000120 this->MCObjectStreamer::ChangeSection(Section, Subsection);
Rafael Espindola1f4f9e32010-11-14 04:17:37 +0000121}
122
Rafael Espindola484291c2010-11-01 14:28:48 +0000123void MCELFStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
124 getAssembler().getOrCreateSymbolData(*Symbol);
125 MCSymbolData &AliasSD = getAssembler().getOrCreateSymbolData(*Alias);
126 AliasSD.setFlags(AliasSD.getFlags() | ELF_Other_Weakref);
Rafael Espindola94ed5fc2010-11-15 16:33:49 +0000127 const MCExpr *Value = MCSymbolRefExpr::Create(Symbol, getContext());
Rafael Espindola484291c2010-11-01 14:28:48 +0000128 Alias->setVariableValue(Value);
129}
130
Peter Collingbourne01a7b5c2013-04-10 16:52:15 +0000131// When GNU as encounters more than one .type declaration for an object it seems
132// to use a mechanism similar to the one below to decide which type is actually
133// used in the object file. The greater of T1 and T2 is selected based on the
134// following ordering:
135// STT_NOTYPE < STT_OBJECT < STT_FUNC < STT_GNU_IFUNC < STT_TLS < anything else
136// If neither T1 < T2 nor T2 < T1 according to this ordering, use T2 (the user
137// provided type).
138static unsigned CombineSymbolTypes(unsigned T1, unsigned T2) {
139 unsigned TypeOrdering[] = {ELF::STT_NOTYPE, ELF::STT_OBJECT, ELF::STT_FUNC,
140 ELF::STT_GNU_IFUNC, ELF::STT_TLS};
141 for (unsigned i = 0; i != array_lengthof(TypeOrdering); ++i) {
142 if (T1 == TypeOrdering[i])
143 return T2;
144 if (T2 == TypeOrdering[i])
145 return T1;
146 }
147
148 return T2;
149}
150
Saleem Abdulrasool1c9cd022013-08-09 01:52:03 +0000151bool MCELFStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
152 MCSymbolAttr Attribute) {
Matt Fleming3565a062010-08-16 18:57:57 +0000153 // Indirect symbols are handled differently, to match how 'as' handles
154 // them. This makes writing matching .o files easier.
155 if (Attribute == MCSA_IndirectSymbol) {
156 // Note that we intentionally cannot use the symbol data here; this is
157 // important for matching the string table that 'as' generates.
158 IndirectSymbolData ISD;
159 ISD.Symbol = Symbol;
160 ISD.SectionData = getCurrentSectionData();
161 getAssembler().getIndirectSymbols().push_back(ISD);
Saleem Abdulrasool1c9cd022013-08-09 01:52:03 +0000162 return true;
Matt Fleming3565a062010-08-16 18:57:57 +0000163 }
164
165 // Adding a symbol attribute always introduces the symbol, note that an
166 // important side effect of calling getOrCreateSymbolData here is to register
167 // the symbol with the assembler.
168 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
169
170 // The implementation of symbol attributes is designed to match 'as', but it
171 // leaves much to desired. It doesn't really make sense to arbitrarily add and
172 // remove flags, but 'as' allows this (in particular, see .desc).
173 //
174 // In the future it might be worth trying to make these operations more well
175 // defined.
176 switch (Attribute) {
177 case MCSA_LazyReference:
178 case MCSA_Reference:
Kevin Enderbye8e98d72010-11-19 18:39:33 +0000179 case MCSA_SymbolResolver:
Matt Fleming3565a062010-08-16 18:57:57 +0000180 case MCSA_PrivateExtern:
Matt Fleming3565a062010-08-16 18:57:57 +0000181 case MCSA_WeakDefinition:
Eli Friedmanf8020a32010-08-16 19:15:06 +0000182 case MCSA_WeakDefAutoPrivate:
Matt Fleming3565a062010-08-16 18:57:57 +0000183 case MCSA_Invalid:
Matt Fleming3565a062010-08-16 18:57:57 +0000184 case MCSA_IndirectSymbol:
Saleem Abdulrasool1c9cd022013-08-09 01:52:03 +0000185 return false;
Matt Fleming3565a062010-08-16 18:57:57 +0000186
Jim Grosbach3f90a4c2012-09-13 23:11:31 +0000187 case MCSA_NoDeadStrip:
Rafael Espindola7e528a12010-11-14 01:34:31 +0000188 case MCSA_ELF_TypeGnuUniqueObject:
189 // Ignore for now.
190 break;
191
Matt Fleming3565a062010-08-16 18:57:57 +0000192 case MCSA_Global:
Jan Sjödin2ddfd952011-02-28 21:45:04 +0000193 MCELF::SetBinding(SD, ELF::STB_GLOBAL);
Matt Fleming3565a062010-08-16 18:57:57 +0000194 SD.setExternal(true);
Rafael Espindolaf7c10a32010-09-21 00:24:38 +0000195 BindingExplicitlySet.insert(Symbol);
Matt Fleming3565a062010-08-16 18:57:57 +0000196 break;
197
Benjamin Kramer230c2742010-09-02 17:18:32 +0000198 case MCSA_WeakReference:
Matt Fleming3565a062010-08-16 18:57:57 +0000199 case MCSA_Weak:
Jan Sjödin2ddfd952011-02-28 21:45:04 +0000200 MCELF::SetBinding(SD, ELF::STB_WEAK);
Rafael Espindola3223f192010-10-06 16:47:31 +0000201 SD.setExternal(true);
Rafael Espindolaf7c10a32010-09-21 00:24:38 +0000202 BindingExplicitlySet.insert(Symbol);
Matt Fleming3565a062010-08-16 18:57:57 +0000203 break;
204
205 case MCSA_Local:
Jan Sjödin2ddfd952011-02-28 21:45:04 +0000206 MCELF::SetBinding(SD, ELF::STB_LOCAL);
Rafael Espindolaf7c10a32010-09-21 00:24:38 +0000207 SD.setExternal(false);
208 BindingExplicitlySet.insert(Symbol);
Matt Fleming3565a062010-08-16 18:57:57 +0000209 break;
210
211 case MCSA_ELF_TypeFunction:
Peter Collingbourne01a7b5c2013-04-10 16:52:15 +0000212 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
213 ELF::STT_FUNC));
Matt Fleming3565a062010-08-16 18:57:57 +0000214 break;
215
Roman Divackya0c17a42011-12-12 17:34:04 +0000216 case MCSA_ELF_TypeIndFunction:
Peter Collingbourne01a7b5c2013-04-10 16:52:15 +0000217 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
218 ELF::STT_GNU_IFUNC));
Roman Divackya0c17a42011-12-12 17:34:04 +0000219 break;
220
Matt Fleming3565a062010-08-16 18:57:57 +0000221 case MCSA_ELF_TypeObject:
Peter Collingbourne01a7b5c2013-04-10 16:52:15 +0000222 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
223 ELF::STT_OBJECT));
Matt Fleming3565a062010-08-16 18:57:57 +0000224 break;
225
226 case MCSA_ELF_TypeTLS:
Peter Collingbourne01a7b5c2013-04-10 16:52:15 +0000227 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
228 ELF::STT_TLS));
Matt Fleming3565a062010-08-16 18:57:57 +0000229 break;
230
231 case MCSA_ELF_TypeCommon:
Peter Collingbourne01a7b5c2013-04-10 16:52:15 +0000232 // TODO: Emit these as a common symbol.
233 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
234 ELF::STT_OBJECT));
Matt Fleming3565a062010-08-16 18:57:57 +0000235 break;
236
237 case MCSA_ELF_TypeNoType:
Peter Collingbourne01a7b5c2013-04-10 16:52:15 +0000238 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD),
239 ELF::STT_NOTYPE));
Matt Fleming3565a062010-08-16 18:57:57 +0000240 break;
241
242 case MCSA_Protected:
Jan Sjödin2ddfd952011-02-28 21:45:04 +0000243 MCELF::SetVisibility(SD, ELF::STV_PROTECTED);
Matt Fleming3565a062010-08-16 18:57:57 +0000244 break;
245
246 case MCSA_Hidden:
Jan Sjödin2ddfd952011-02-28 21:45:04 +0000247 MCELF::SetVisibility(SD, ELF::STV_HIDDEN);
Matt Fleming3565a062010-08-16 18:57:57 +0000248 break;
249
250 case MCSA_Internal:
Jan Sjödin2ddfd952011-02-28 21:45:04 +0000251 MCELF::SetVisibility(SD, ELF::STV_INTERNAL);
Matt Fleming3565a062010-08-16 18:57:57 +0000252 break;
253 }
Saleem Abdulrasool1c9cd022013-08-09 01:52:03 +0000254
255 return true;
Matt Fleming3565a062010-08-16 18:57:57 +0000256}
257
258void MCELFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
259 unsigned ByteAlignment) {
260 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
261
Rafael Espindolaf7c10a32010-09-21 00:24:38 +0000262 if (!BindingExplicitlySet.count(Symbol)) {
Jan Sjödin2ddfd952011-02-28 21:45:04 +0000263 MCELF::SetBinding(SD, ELF::STB_GLOBAL);
Rafael Espindolaf7c10a32010-09-21 00:24:38 +0000264 SD.setExternal(true);
265 }
266
Jan Sjödin2ddfd952011-02-28 21:45:04 +0000267 MCELF::SetType(SD, ELF::STT_OBJECT);
Rafael Espindola55d02f32010-11-14 21:11:16 +0000268
Jan Sjödin2ddfd952011-02-28 21:45:04 +0000269 if (MCELF::GetBinding(SD) == ELF_STB_Local) {
Matt Fleming3565a062010-08-16 18:57:57 +0000270 const MCSection *Section = getAssembler().getContext().getELFSection(".bss",
Jim Grosbach946227d2011-11-15 16:46:22 +0000271 ELF::SHT_NOBITS,
272 ELF::SHF_WRITE |
273 ELF::SHF_ALLOC,
274 SectionKind::getBSS());
Richard Mitton5cc319a2013-09-19 23:21:01 +0000275
276 AssignSection(Symbol, Section);
Rafael Espindola19635722010-09-22 17:43:04 +0000277
Rafael Espindola9e3922e2010-09-29 14:52:01 +0000278 struct LocalCommon L = {&SD, Size, ByteAlignment};
279 LocalCommons.push_back(L);
Rafael Espindolaf7c10a32010-09-21 00:24:38 +0000280 } else {
281 SD.setCommon(Size, ByteAlignment);
Matt Fleming3565a062010-08-16 18:57:57 +0000282 }
283
Rafael Espindolaf7c10a32010-09-21 00:24:38 +0000284 SD.setSize(MCConstantExpr::Create(Size, getContext()));
Matt Fleming3565a062010-08-16 18:57:57 +0000285}
286
Logan Chien64501652012-12-07 15:50:40 +0000287void MCELFStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
288 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
289 SD.setSize(Value);
290}
291
Benjamin Kramer36a16012011-09-01 23:04:27 +0000292void MCELFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
293 unsigned ByteAlignment) {
Jason W Kimf13743b2010-12-16 03:12:17 +0000294 // FIXME: Should this be caught and done earlier?
295 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
Jan Sjödin2ddfd952011-02-28 21:45:04 +0000296 MCELF::SetBinding(SD, ELF::STB_LOCAL);
Jason W Kimf13743b2010-12-16 03:12:17 +0000297 SD.setExternal(false);
298 BindingExplicitlySet.insert(Symbol);
Benjamin Kramer36a16012011-09-01 23:04:27 +0000299 EmitCommonSymbol(Symbol, Size, ByteAlignment);
Jason W Kimf13743b2010-12-16 03:12:17 +0000300}
301
Rafael Espindolaa3863ea2013-07-02 15:49:13 +0000302void MCELFStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size) {
Eli Bendersky4766ef42012-12-20 19:05:53 +0000303 if (getCurrentSectionData()->isBundleLocked())
304 report_fatal_error("Emitting values inside a locked bundle is forbidden");
David Meyer5f769262012-02-15 15:09:06 +0000305 fixSymbolsInTLSFixups(Value);
Rafael Espindolaa3863ea2013-07-02 15:49:13 +0000306 MCObjectStreamer::EmitValueImpl(Value, Size);
David Meyer5f769262012-02-15 15:09:06 +0000307}
308
Eli Bendersky4766ef42012-12-20 19:05:53 +0000309void MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment,
310 int64_t Value,
311 unsigned ValueSize,
312 unsigned MaxBytesToEmit) {
313 if (getCurrentSectionData()->isBundleLocked())
314 report_fatal_error("Emitting values inside a locked bundle is forbidden");
315 MCObjectStreamer::EmitValueToAlignment(ByteAlignment, Value,
316 ValueSize, MaxBytesToEmit);
317}
318
David Meyer5f769262012-02-15 15:09:06 +0000319
Matt Fleming3565a062010-08-16 18:57:57 +0000320// Add a symbol for the file name of this module. This is the second
321// entry in the module's symbol table (the first being the null symbol).
322void MCELFStreamer::EmitFileDirective(StringRef Filename) {
323 MCSymbol *Symbol = getAssembler().getContext().GetOrCreateSymbol(Filename);
Peter Collingbournedf39be62013-04-17 21:18:16 +0000324 Symbol->setSection(*getCurrentSection().first);
Matt Fleming3565a062010-08-16 18:57:57 +0000325 Symbol->setAbsolute();
326
327 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
328
329 SD.setFlags(ELF_STT_File | ELF_STB_Local | ELF_STV_Default);
330}
331
Rafael Espindola97551272010-11-24 02:19:40 +0000332void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) {
333 switch (expr->getKind()) {
Tim Northover72062f52013-01-31 12:12:40 +0000334 case MCExpr::Target:
335 cast<MCTargetExpr>(expr)->fixELFSymbolsInTLSFixups(getAssembler());
336 break;
Rafael Espindola97551272010-11-24 02:19:40 +0000337 case MCExpr::Constant:
338 break;
339
340 case MCExpr::Binary: {
341 const MCBinaryExpr *be = cast<MCBinaryExpr>(expr);
342 fixSymbolsInTLSFixups(be->getLHS());
343 fixSymbolsInTLSFixups(be->getRHS());
344 break;
345 }
346
347 case MCExpr::SymbolRef: {
348 const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
Rafael Espindolabf8209d2010-11-24 18:51:21 +0000349 switch (symRef.getKind()) {
350 default:
Rafael Espindola97551272010-11-24 02:19:40 +0000351 return;
Joerg Sonnenbergerd02c8b62011-03-17 00:35:10 +0000352 case MCSymbolRefExpr::VK_GOTTPOFF:
353 case MCSymbolRefExpr::VK_INDNTPOFF:
Rafael Espindolabf8209d2010-11-24 18:51:21 +0000354 case MCSymbolRefExpr::VK_NTPOFF:
355 case MCSymbolRefExpr::VK_GOTNTPOFF:
356 case MCSymbolRefExpr::VK_TLSGD:
Joerg Sonnenbergerd02c8b62011-03-17 00:35:10 +0000357 case MCSymbolRefExpr::VK_TLSLD:
Rafael Espindolabf8209d2010-11-24 18:51:21 +0000358 case MCSymbolRefExpr::VK_TLSLDM:
359 case MCSymbolRefExpr::VK_TPOFF:
360 case MCSymbolRefExpr::VK_DTPOFF:
Rafael Espindolabf8209d2010-11-24 18:51:21 +0000361 case MCSymbolRefExpr::VK_ARM_TLSGD:
Joerg Sonnenbergerd02c8b62011-03-17 00:35:10 +0000362 case MCSymbolRefExpr::VK_ARM_TPOFF:
363 case MCSymbolRefExpr::VK_ARM_GOTTPOFF:
Bruno Cardoso Lopes3507d242011-10-25 18:13:20 +0000364 case MCSymbolRefExpr::VK_Mips_TLSGD:
365 case MCSymbolRefExpr::VK_Mips_GOTTPREL:
366 case MCSymbolRefExpr::VK_Mips_TPREL_HI:
367 case MCSymbolRefExpr::VK_Mips_TPREL_LO:
Ulrich Weigand228e0af2013-07-01 23:33:29 +0000368 case MCSymbolRefExpr::VK_PPC_DTPMOD:
Ulrich Weigandcab0a192013-06-21 14:44:15 +0000369 case MCSymbolRefExpr::VK_PPC_TPREL:
Ulrich Weigand92cfa612013-06-21 14:42:20 +0000370 case MCSymbolRefExpr::VK_PPC_TPREL_LO:
Ulrich Weigandcab0a192013-06-21 14:44:15 +0000371 case MCSymbolRefExpr::VK_PPC_TPREL_HI:
Ulrich Weigand92cfa612013-06-21 14:42:20 +0000372 case MCSymbolRefExpr::VK_PPC_TPREL_HA:
Ulrich Weigandcab0a192013-06-21 14:44:15 +0000373 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHER:
374 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHERA:
375 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHEST:
376 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHESTA:
377 case MCSymbolRefExpr::VK_PPC_DTPREL:
Ulrich Weigand92cfa612013-06-21 14:42:20 +0000378 case MCSymbolRefExpr::VK_PPC_DTPREL_LO:
Ulrich Weigandcab0a192013-06-21 14:44:15 +0000379 case MCSymbolRefExpr::VK_PPC_DTPREL_HI:
Ulrich Weigand92cfa612013-06-21 14:42:20 +0000380 case MCSymbolRefExpr::VK_PPC_DTPREL_HA:
Ulrich Weigandcab0a192013-06-21 14:44:15 +0000381 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHER:
382 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHERA:
383 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHEST:
384 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHESTA:
385 case MCSymbolRefExpr::VK_PPC_GOT_TPREL:
Ulrich Weigand92cfa612013-06-21 14:42:20 +0000386 case MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO:
Ulrich Weigandcab0a192013-06-21 14:44:15 +0000387 case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HI:
Ulrich Weigand92cfa612013-06-21 14:42:20 +0000388 case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA:
Ulrich Weigandcab0a192013-06-21 14:44:15 +0000389 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL:
390 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_LO:
391 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HI:
392 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HA:
Bill Schmidt3a429892013-02-26 16:41:03 +0000393 case MCSymbolRefExpr::VK_PPC_TLS:
Ulrich Weigandcab0a192013-06-21 14:44:15 +0000394 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD:
Ulrich Weigand92cfa612013-06-21 14:42:20 +0000395 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO:
Ulrich Weigandcab0a192013-06-21 14:44:15 +0000396 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HI:
Ulrich Weigand92cfa612013-06-21 14:42:20 +0000397 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA:
Ulrich Weigand7a345992013-07-09 16:41:09 +0000398 case MCSymbolRefExpr::VK_PPC_TLSGD:
Ulrich Weigandcab0a192013-06-21 14:44:15 +0000399 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD:
Ulrich Weigand92cfa612013-06-21 14:42:20 +0000400 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO:
Ulrich Weigandcab0a192013-06-21 14:44:15 +0000401 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HI:
Ulrich Weigand92cfa612013-06-21 14:42:20 +0000402 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA:
Ulrich Weigand7a345992013-07-09 16:41:09 +0000403 case MCSymbolRefExpr::VK_PPC_TLSLD:
Rafael Espindolabf8209d2010-11-24 18:51:21 +0000404 break;
405 }
Rafael Espindola97551272010-11-24 02:19:40 +0000406 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(symRef.getSymbol());
Jan Sjödin2ddfd952011-02-28 21:45:04 +0000407 MCELF::SetType(SD, ELF::STT_TLS);
Rafael Espindola97551272010-11-24 02:19:40 +0000408 break;
409 }
410
411 case MCExpr::Unary:
412 fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr());
413 break;
414 }
415}
416
Benjamin Kramer93ded732010-08-27 10:40:51 +0000417void MCELFStreamer::EmitInstToFragment(const MCInst &Inst) {
Rafael Espindoladedb0452010-12-02 05:44:06 +0000418 this->MCObjectStreamer::EmitInstToFragment(Inst);
Eli Bendersky251040b2013-01-08 00:22:56 +0000419 MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment());
Benjamin Kramer93ded732010-08-27 10:40:51 +0000420
Rafael Espindoladedb0452010-12-02 05:44:06 +0000421 for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i)
422 fixSymbolsInTLSFixups(F.getFixups()[i].getValue());
Benjamin Kramer93ded732010-08-27 10:40:51 +0000423}
424
425void MCELFStreamer::EmitInstToData(const MCInst &Inst) {
Eli Bendersky4766ef42012-12-20 19:05:53 +0000426 MCAssembler &Assembler = getAssembler();
Benjamin Kramer93ded732010-08-27 10:40:51 +0000427 SmallVector<MCFixup, 4> Fixups;
428 SmallString<256> Code;
429 raw_svector_ostream VecOS(Code);
Eli Bendersky4766ef42012-12-20 19:05:53 +0000430 Assembler.getEmitter().EncodeInstruction(Inst, VecOS, Fixups);
Benjamin Kramer93ded732010-08-27 10:40:51 +0000431 VecOS.flush();
432
Rafael Espindola97551272010-11-24 02:19:40 +0000433 for (unsigned i = 0, e = Fixups.size(); i != e; ++i)
434 fixSymbolsInTLSFixups(Fixups[i].getValue());
435
Eli Bendersky4766ef42012-12-20 19:05:53 +0000436 // There are several possibilities here:
437 //
438 // If bundling is disabled, append the encoded instruction to the current data
439 // fragment (or create a new such fragment if the current fragment is not a
440 // data fragment).
441 //
442 // If bundling is enabled:
Eli Bendersky9ccb7692013-01-15 23:22:09 +0000443 // - If we're not in a bundle-locked group, emit the instruction into a
444 // fragment of its own. If there are no fixups registered for the
445 // instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a
446 // MCDataFragment.
Eli Bendersky4766ef42012-12-20 19:05:53 +0000447 // - If we're in a bundle-locked group, append the instruction to the current
448 // data fragment because we want all the instructions in a group to get into
449 // the same fragment. Be careful not to do that for the first instruction in
450 // the group, though.
451 MCDataFragment *DF;
452
453 if (Assembler.isBundlingEnabled()) {
454 MCSectionData *SD = getCurrentSectionData();
455 if (SD->isBundleLocked() && !SD->isBundleGroupBeforeFirstInst())
Derek Schuff67144e32013-02-15 22:50:52 +0000456 // If we are bundle-locked, we re-use the current fragment.
457 // The bundle-locking directive ensures this is a new data fragment.
458 DF = cast<MCDataFragment>(getCurrentFragment());
Eli Bendersky9ccb7692013-01-15 23:22:09 +0000459 else if (!SD->isBundleLocked() && Fixups.size() == 0) {
460 // Optimize memory usage by emitting the instruction to a
461 // MCCompactEncodedInstFragment when not in a bundle-locked group and
462 // there are no fixups registered.
Peter Collingbournedf39be62013-04-17 21:18:16 +0000463 MCCompactEncodedInstFragment *CEIF = new MCCompactEncodedInstFragment();
464 insert(CEIF);
Eli Bendersky9ccb7692013-01-15 23:22:09 +0000465 CEIF->getContents().append(Code.begin(), Code.end());
466 return;
Derek Schuff67144e32013-02-15 22:50:52 +0000467 } else {
Peter Collingbournedf39be62013-04-17 21:18:16 +0000468 DF = new MCDataFragment();
469 insert(DF);
Eli Bendersky6c1d4972013-01-07 21:51:08 +0000470 if (SD->getBundleLockState() == MCSectionData::BundleLockedAlignToEnd) {
471 // If this is a new fragment created for a bundle-locked group, and the
472 // group was marked as "align_to_end", set a flag in the fragment.
473 DF->setAlignToBundleEnd(true);
474 }
475 }
Eli Bendersky4766ef42012-12-20 19:05:53 +0000476
477 // We're now emitting an instruction in a bundle group, so this flag has
478 // to be turned off.
479 SD->setBundleGroupBeforeFirstInst(false);
480 } else {
481 DF = getOrCreateDataFragment();
482 }
483
Benjamin Kramer93ded732010-08-27 10:40:51 +0000484 // Add the fixups and data.
485 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
486 Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
Eli Bendersky64d9a322012-12-07 19:13:57 +0000487 DF->getFixups().push_back(Fixups[i]);
Benjamin Kramer93ded732010-08-27 10:40:51 +0000488 }
Eli Bendersky4766ef42012-12-20 19:05:53 +0000489 DF->setHasInstructions(true);
Benjamin Kramer93ded732010-08-27 10:40:51 +0000490 DF->getContents().append(Code.begin(), Code.end());
491}
492
Eli Bendersky4766ef42012-12-20 19:05:53 +0000493void MCELFStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
494 assert(AlignPow2 <= 30 && "Invalid bundle alignment");
495 MCAssembler &Assembler = getAssembler();
496 if (Assembler.getBundleAlignSize() == 0 && AlignPow2 > 0)
497 Assembler.setBundleAlignSize(1 << AlignPow2);
498 else
499 report_fatal_error(".bundle_align_mode should be only set once per file");
500}
501
Eli Bendersky6c1d4972013-01-07 21:51:08 +0000502void MCELFStreamer::EmitBundleLock(bool AlignToEnd) {
Eli Bendersky4766ef42012-12-20 19:05:53 +0000503 MCSectionData *SD = getCurrentSectionData();
504
505 // Sanity checks
506 //
507 if (!getAssembler().isBundlingEnabled())
508 report_fatal_error(".bundle_lock forbidden when bundling is disabled");
509 else if (SD->isBundleLocked())
510 report_fatal_error("Nesting of .bundle_lock is forbidden");
511
Eli Bendersky6c1d4972013-01-07 21:51:08 +0000512 SD->setBundleLockState(AlignToEnd ? MCSectionData::BundleLockedAlignToEnd :
513 MCSectionData::BundleLocked);
Eli Bendersky4766ef42012-12-20 19:05:53 +0000514 SD->setBundleGroupBeforeFirstInst(true);
515}
516
517void MCELFStreamer::EmitBundleUnlock() {
518 MCSectionData *SD = getCurrentSectionData();
519
520 // Sanity checks
521 if (!getAssembler().isBundlingEnabled())
522 report_fatal_error(".bundle_unlock forbidden when bundling is disabled");
523 else if (!SD->isBundleLocked())
524 report_fatal_error(".bundle_unlock without matching lock");
525 else if (SD->isBundleGroupBeforeFirstInst())
526 report_fatal_error("Empty bundle-locked group is forbidden");
527
Eli Bendersky6c1d4972013-01-07 21:51:08 +0000528 SD->setBundleLockState(MCSectionData::NotBundleLocked);
Eli Bendersky4766ef42012-12-20 19:05:53 +0000529}
530
Richard Mitton5cc319a2013-09-19 23:21:01 +0000531void MCELFStreamer::Flush() {
Rafael Espindola9e3922e2010-09-29 14:52:01 +0000532 for (std::vector<LocalCommon>::const_iterator i = LocalCommons.begin(),
533 e = LocalCommons.end();
534 i != e; ++i) {
535 MCSymbolData *SD = i->SD;
536 uint64_t Size = i->Size;
537 unsigned ByteAlignment = i->ByteAlignment;
538 const MCSymbol &Symbol = SD->getSymbol();
539 const MCSection &Section = Symbol.getSection();
540
541 MCSectionData &SectData = getAssembler().getOrCreateSectionData(Section);
542 new MCAlignFragment(ByteAlignment, 0, 1, ByteAlignment, &SectData);
543
544 MCFragment *F = new MCFillFragment(0, 0, Size, &SectData);
545 SD->setFragment(F);
546
547 // Update the maximum alignment of the section if necessary.
548 if (ByteAlignment > SectData.getAlignment())
549 SectData.setAlignment(ByteAlignment);
550 }
551
Richard Mitton5cc319a2013-09-19 23:21:01 +0000552 LocalCommons.clear();
553}
554
555void MCELFStreamer::FinishImpl() {
556 EmitFrames(NULL, true);
557
558 Flush();
559
Rafael Espindola99b42372012-01-07 03:13:18 +0000560 this->MCObjectStreamer::FinishImpl();
Matt Fleming3565a062010-08-16 18:57:57 +0000561}
Richard Mitton5cc319a2013-09-19 23:21:01 +0000562
Rafael Espindola320296a2013-10-08 13:08:17 +0000563MCStreamer *llvm::createELFStreamer(MCContext &Context,
564 MCTargetStreamer *Streamer,
565 MCAsmBackend &MAB, raw_ostream &OS,
566 MCCodeEmitter *CE, bool RelaxAll,
567 bool NoExecStack) {
568 MCELFStreamer *S = new MCELFStreamer(Context, Streamer, MAB, OS, CE);
Matt Fleming3565a062010-08-16 18:57:57 +0000569 if (RelaxAll)
570 S->getAssembler().setRelaxAll(true);
Rafael Espindola96aa78c2011-01-23 17:55:27 +0000571 if (NoExecStack)
572 S->getAssembler().setNoExecStack(true);
Matt Fleming3565a062010-08-16 18:57:57 +0000573 return S;
574}
Logan Chien64501652012-12-07 15:50:40 +0000575
Tim Northover6eb3e872012-12-07 16:50:23 +0000576void MCELFStreamer::EmitThumbFunc(MCSymbol *Func) {
577 llvm_unreachable("Generic ELF doesn't support this directive");
578}
579
Jack Carter77afbdc2013-02-19 21:57:35 +0000580MCSymbolData &MCELFStreamer::getOrCreateSymbolData(MCSymbol *Symbol) {
581 return getAssembler().getOrCreateSymbolData(*Symbol);
582}
583
Logan Chien64501652012-12-07 15:50:40 +0000584void MCELFStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
585 llvm_unreachable("ELF doesn't support this directive");
586}
587
588void MCELFStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
589 llvm_unreachable("ELF doesn't support this directive");
590}
591
592void MCELFStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {
593 llvm_unreachable("ELF doesn't support this directive");
594}
595
596void MCELFStreamer::EmitCOFFSymbolType(int Type) {
597 llvm_unreachable("ELF doesn't support this directive");
598}
599
600void MCELFStreamer::EndCOFFSymbolDef() {
601 llvm_unreachable("ELF doesn't support this directive");
602}
603
604void MCELFStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
605 uint64_t Size, unsigned ByteAlignment) {
606 llvm_unreachable("ELF doesn't support this directive");
607}
608
609void MCELFStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
610 uint64_t Size, unsigned ByteAlignment) {
611 llvm_unreachable("ELF doesn't support this directive");
612}