MCELFStreamer.cpp revision 218893
1212793Sdim//===- lib/MC/MCELFStreamer.cpp - ELF Object Output ------------===// 2212793Sdim// 3212793Sdim// The LLVM Compiler Infrastructure 4212793Sdim// 5212793Sdim// This file is distributed under the University of Illinois Open Source 6212793Sdim// License. See LICENSE.TXT for details. 7212793Sdim// 8212793Sdim//===----------------------------------------------------------------------===// 9212793Sdim// 10212793Sdim// This file assembles .s files and emits ELF .o object files. 11212793Sdim// 12212793Sdim//===----------------------------------------------------------------------===// 13212793Sdim 14212793Sdim#include "llvm/MC/MCStreamer.h" 15212793Sdim 16218893Sdim#include "llvm/ADT/SmallPtrSet.h" 17212793Sdim#include "llvm/MC/MCAssembler.h" 18212793Sdim#include "llvm/MC/MCContext.h" 19212793Sdim#include "llvm/MC/MCCodeEmitter.h" 20212793Sdim#include "llvm/MC/MCELFSymbolFlags.h" 21212793Sdim#include "llvm/MC/MCExpr.h" 22212793Sdim#include "llvm/MC/MCInst.h" 23212793Sdim#include "llvm/MC/MCObjectStreamer.h" 24212793Sdim#include "llvm/MC/MCSection.h" 25212793Sdim#include "llvm/MC/MCSectionELF.h" 26212793Sdim#include "llvm/MC/MCSymbol.h" 27218893Sdim#include "llvm/MC/MCValue.h" 28212793Sdim#include "llvm/Support/Debug.h" 29212793Sdim#include "llvm/Support/ELF.h" 30212793Sdim#include "llvm/Support/ErrorHandling.h" 31212793Sdim#include "llvm/Support/raw_ostream.h" 32212793Sdim#include "llvm/Target/TargetAsmBackend.h" 33218893Sdim#include "llvm/Target/TargetAsmInfo.h" 34212793Sdim 35212793Sdimusing namespace llvm; 36212793Sdim 37212793Sdimnamespace { 38212793Sdim 39218893Sdimstatic void SetBinding(MCSymbolData &SD, unsigned Binding) { 40218893Sdim assert(Binding == ELF::STB_LOCAL || Binding == ELF::STB_GLOBAL || 41218893Sdim Binding == ELF::STB_WEAK); 42218893Sdim uint32_t OtherFlags = SD.getFlags() & ~(0xf << ELF_STB_Shift); 43218893Sdim SD.setFlags(OtherFlags | (Binding << ELF_STB_Shift)); 44218893Sdim} 45218893Sdim 46218893Sdimstatic unsigned GetBinding(const MCSymbolData &SD) { 47218893Sdim uint32_t Binding = (SD.getFlags() & (0xf << ELF_STB_Shift)) >> ELF_STB_Shift; 48218893Sdim assert(Binding == ELF::STB_LOCAL || Binding == ELF::STB_GLOBAL || 49218893Sdim Binding == ELF::STB_WEAK); 50218893Sdim return Binding; 51218893Sdim} 52218893Sdim 53218893Sdimstatic void SetType(MCSymbolData &SD, unsigned Type) { 54218893Sdim assert(Type == ELF::STT_NOTYPE || Type == ELF::STT_OBJECT || 55218893Sdim Type == ELF::STT_FUNC || Type == ELF::STT_SECTION || 56218893Sdim Type == ELF::STT_FILE || Type == ELF::STT_COMMON || 57218893Sdim Type == ELF::STT_TLS); 58218893Sdim 59218893Sdim uint32_t OtherFlags = SD.getFlags() & ~(0xf << ELF_STT_Shift); 60218893Sdim SD.setFlags(OtherFlags | (Type << ELF_STT_Shift)); 61218893Sdim} 62218893Sdim 63218893Sdimstatic void SetVisibility(MCSymbolData &SD, unsigned Visibility) { 64218893Sdim assert(Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_INTERNAL || 65218893Sdim Visibility == ELF::STV_HIDDEN || Visibility == ELF::STV_PROTECTED); 66218893Sdim 67218893Sdim uint32_t OtherFlags = SD.getFlags() & ~(0xf << ELF_STV_Shift); 68218893Sdim SD.setFlags(OtherFlags | (Visibility << ELF_STV_Shift)); 69218893Sdim} 70218893Sdim 71212793Sdimclass MCELFStreamer : public MCObjectStreamer { 72212793Sdimpublic: 73212793Sdim MCELFStreamer(MCContext &Context, TargetAsmBackend &TAB, 74212793Sdim raw_ostream &OS, MCCodeEmitter *Emitter) 75212793Sdim : MCObjectStreamer(Context, TAB, OS, Emitter) {} 76212793Sdim 77212793Sdim ~MCELFStreamer() {} 78212793Sdim 79212793Sdim /// @name MCStreamer Interface 80212793Sdim /// @{ 81212793Sdim 82218893Sdim virtual void InitSections(); 83218893Sdim virtual void ChangeSection(const MCSection *Section); 84212793Sdim virtual void EmitLabel(MCSymbol *Symbol); 85212793Sdim virtual void EmitAssemblerFlag(MCAssemblerFlag Flag); 86218893Sdim virtual void EmitThumbFunc(MCSymbol *Func); 87212793Sdim virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value); 88218893Sdim virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol); 89212793Sdim virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute); 90212793Sdim virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) { 91212793Sdim assert(0 && "ELF doesn't support this directive"); 92212793Sdim } 93212793Sdim virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 94212793Sdim unsigned ByteAlignment); 95212793Sdim virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol) { 96212793Sdim assert(0 && "ELF doesn't support this directive"); 97212793Sdim } 98212793Sdim 99212793Sdim virtual void EmitCOFFSymbolStorageClass(int StorageClass) { 100212793Sdim assert(0 && "ELF doesn't support this directive"); 101212793Sdim } 102212793Sdim 103212793Sdim virtual void EmitCOFFSymbolType(int Type) { 104212793Sdim assert(0 && "ELF doesn't support this directive"); 105212793Sdim } 106212793Sdim 107212793Sdim virtual void EndCOFFSymbolDef() { 108212793Sdim assert(0 && "ELF doesn't support this directive"); 109212793Sdim } 110212793Sdim 111212793Sdim virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) { 112212793Sdim MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 113212793Sdim SD.setSize(Value); 114212793Sdim } 115212793Sdim 116218893Sdim virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size); 117218893Sdim 118212793Sdim virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol = 0, 119212793Sdim unsigned Size = 0, unsigned ByteAlignment = 0) { 120212793Sdim assert(0 && "ELF doesn't support this directive"); 121212793Sdim } 122212793Sdim virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol, 123212793Sdim uint64_t Size, unsigned ByteAlignment = 0) { 124212793Sdim assert(0 && "ELF doesn't support this directive"); 125212793Sdim } 126212793Sdim virtual void EmitBytes(StringRef Data, unsigned AddrSpace); 127212793Sdim virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, 128212793Sdim unsigned ValueSize = 1, 129212793Sdim unsigned MaxBytesToEmit = 0); 130212793Sdim virtual void EmitCodeAlignment(unsigned ByteAlignment, 131212793Sdim unsigned MaxBytesToEmit = 0); 132212793Sdim 133212793Sdim virtual void EmitFileDirective(StringRef Filename); 134212793Sdim 135212793Sdim virtual void Finish(); 136212793Sdim 137218893Sdimprivate: 138218893Sdim virtual void EmitInstToFragment(const MCInst &Inst); 139218893Sdim virtual void EmitInstToData(const MCInst &Inst); 140218893Sdim 141218893Sdim void fixSymbolsInTLSFixups(const MCExpr *expr); 142218893Sdim 143218893Sdim struct LocalCommon { 144218893Sdim MCSymbolData *SD; 145218893Sdim uint64_t Size; 146218893Sdim unsigned ByteAlignment; 147218893Sdim }; 148218893Sdim std::vector<LocalCommon> LocalCommons; 149218893Sdim 150218893Sdim SmallPtrSet<MCSymbol *, 16> BindingExplicitlySet; 151212793Sdim /// @} 152218893Sdim void SetSection(StringRef Section, unsigned Type, unsigned Flags, 153218893Sdim SectionKind Kind) { 154218893Sdim SwitchSection(getContext().getELFSection(Section, Type, Flags, Kind)); 155218893Sdim } 156218893Sdim 157218893Sdim void SetSectionData() { 158218893Sdim SetSection(".data", ELF::SHT_PROGBITS, 159218893Sdim ELF::SHF_WRITE |ELF::SHF_ALLOC, 160218893Sdim SectionKind::getDataRel()); 161218893Sdim EmitCodeAlignment(4, 0); 162218893Sdim } 163218893Sdim void SetSectionText() { 164218893Sdim SetSection(".text", ELF::SHT_PROGBITS, 165218893Sdim ELF::SHF_EXECINSTR | 166218893Sdim ELF::SHF_ALLOC, SectionKind::getText()); 167218893Sdim EmitCodeAlignment(4, 0); 168218893Sdim } 169218893Sdim void SetSectionBss() { 170218893Sdim SetSection(".bss", ELF::SHT_NOBITS, 171218893Sdim ELF::SHF_WRITE | 172218893Sdim ELF::SHF_ALLOC, SectionKind::getBSS()); 173218893Sdim EmitCodeAlignment(4, 0); 174218893Sdim } 175212793Sdim}; 176212793Sdim 177212793Sdim} // end anonymous namespace. 178212793Sdim 179218893Sdimvoid MCELFStreamer::InitSections() { 180218893Sdim // This emulates the same behavior of GNU as. This makes it easier 181218893Sdim // to compare the output as the major sections are in the same order. 182218893Sdim SetSectionText(); 183218893Sdim SetSectionData(); 184218893Sdim SetSectionBss(); 185218893Sdim SetSectionText(); 186218893Sdim} 187218893Sdim 188212793Sdimvoid MCELFStreamer::EmitLabel(MCSymbol *Symbol) { 189212793Sdim assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); 190212793Sdim 191218893Sdim MCObjectStreamer::EmitLabel(Symbol); 192212793Sdim 193218893Sdim const MCSectionELF &Section = 194218893Sdim static_cast<const MCSectionELF&>(Symbol->getSection()); 195218893Sdim MCSymbolData &SD = getAssembler().getSymbolData(*Symbol); 196218893Sdim if (Section.getFlags() & ELF::SHF_TLS) 197218893Sdim SetType(SD, ELF::STT_TLS); 198212793Sdim} 199212793Sdim 200212793Sdimvoid MCELFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) { 201212793Sdim switch (Flag) { 202218893Sdim case MCAF_SyntaxUnified: return; // no-op here. 203218893Sdim case MCAF_Code16: return; // no-op here. 204218893Sdim case MCAF_Code32: return; // no-op here. 205212793Sdim case MCAF_SubsectionsViaSymbols: 206212793Sdim getAssembler().setSubsectionsViaSymbols(true); 207212793Sdim return; 208212793Sdim } 209212793Sdim 210212793Sdim assert(0 && "invalid assembler flag!"); 211212793Sdim} 212212793Sdim 213218893Sdimvoid MCELFStreamer::EmitThumbFunc(MCSymbol *Func) { 214218893Sdim // FIXME: Anything needed here to flag the function as thumb? 215218893Sdim} 216218893Sdim 217212793Sdimvoid MCELFStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) { 218212793Sdim // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into 219212793Sdim // MCObjectStreamer. 220212793Sdim // FIXME: Lift context changes into super class. 221212793Sdim getAssembler().getOrCreateSymbolData(*Symbol); 222212793Sdim Symbol->setVariableValue(AddValueSymbols(Value)); 223212793Sdim} 224212793Sdim 225218893Sdimvoid MCELFStreamer::ChangeSection(const MCSection *Section) { 226218893Sdim const MCSymbol *Grp = static_cast<const MCSectionELF *>(Section)->getGroup(); 227218893Sdim if (Grp) 228218893Sdim getAssembler().getOrCreateSymbolData(*Grp); 229218893Sdim this->MCObjectStreamer::ChangeSection(Section); 230218893Sdim} 231218893Sdim 232218893Sdimvoid MCELFStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) { 233218893Sdim getAssembler().getOrCreateSymbolData(*Symbol); 234218893Sdim MCSymbolData &AliasSD = getAssembler().getOrCreateSymbolData(*Alias); 235218893Sdim AliasSD.setFlags(AliasSD.getFlags() | ELF_Other_Weakref); 236218893Sdim const MCExpr *Value = MCSymbolRefExpr::Create(Symbol, getContext()); 237218893Sdim Alias->setVariableValue(Value); 238218893Sdim} 239218893Sdim 240212793Sdimvoid MCELFStreamer::EmitSymbolAttribute(MCSymbol *Symbol, 241212793Sdim MCSymbolAttr Attribute) { 242212793Sdim // Indirect symbols are handled differently, to match how 'as' handles 243212793Sdim // them. This makes writing matching .o files easier. 244212793Sdim if (Attribute == MCSA_IndirectSymbol) { 245212793Sdim // Note that we intentionally cannot use the symbol data here; this is 246212793Sdim // important for matching the string table that 'as' generates. 247212793Sdim IndirectSymbolData ISD; 248212793Sdim ISD.Symbol = Symbol; 249212793Sdim ISD.SectionData = getCurrentSectionData(); 250212793Sdim getAssembler().getIndirectSymbols().push_back(ISD); 251212793Sdim return; 252212793Sdim } 253212793Sdim 254212793Sdim // Adding a symbol attribute always introduces the symbol, note that an 255212793Sdim // important side effect of calling getOrCreateSymbolData here is to register 256212793Sdim // the symbol with the assembler. 257212793Sdim MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 258212793Sdim 259212793Sdim // The implementation of symbol attributes is designed to match 'as', but it 260212793Sdim // leaves much to desired. It doesn't really make sense to arbitrarily add and 261212793Sdim // remove flags, but 'as' allows this (in particular, see .desc). 262212793Sdim // 263212793Sdim // In the future it might be worth trying to make these operations more well 264212793Sdim // defined. 265212793Sdim switch (Attribute) { 266212793Sdim case MCSA_LazyReference: 267212793Sdim case MCSA_Reference: 268212793Sdim case MCSA_NoDeadStrip: 269218893Sdim case MCSA_SymbolResolver: 270212793Sdim case MCSA_PrivateExtern: 271212793Sdim case MCSA_WeakDefinition: 272212793Sdim case MCSA_WeakDefAutoPrivate: 273212793Sdim case MCSA_Invalid: 274212793Sdim case MCSA_ELF_TypeIndFunction: 275212793Sdim case MCSA_IndirectSymbol: 276212793Sdim assert(0 && "Invalid symbol attribute for ELF!"); 277212793Sdim break; 278212793Sdim 279218893Sdim case MCSA_ELF_TypeGnuUniqueObject: 280218893Sdim // Ignore for now. 281218893Sdim break; 282218893Sdim 283212793Sdim case MCSA_Global: 284218893Sdim SetBinding(SD, ELF::STB_GLOBAL); 285212793Sdim SD.setExternal(true); 286218893Sdim BindingExplicitlySet.insert(Symbol); 287212793Sdim break; 288212793Sdim 289212793Sdim case MCSA_WeakReference: 290212793Sdim case MCSA_Weak: 291218893Sdim SetBinding(SD, ELF::STB_WEAK); 292218893Sdim SD.setExternal(true); 293218893Sdim BindingExplicitlySet.insert(Symbol); 294212793Sdim break; 295212793Sdim 296212793Sdim case MCSA_Local: 297218893Sdim SetBinding(SD, ELF::STB_LOCAL); 298218893Sdim SD.setExternal(false); 299218893Sdim BindingExplicitlySet.insert(Symbol); 300212793Sdim break; 301212793Sdim 302212793Sdim case MCSA_ELF_TypeFunction: 303218893Sdim SetType(SD, ELF::STT_FUNC); 304212793Sdim break; 305212793Sdim 306212793Sdim case MCSA_ELF_TypeObject: 307218893Sdim SetType(SD, ELF::STT_OBJECT); 308212793Sdim break; 309212793Sdim 310212793Sdim case MCSA_ELF_TypeTLS: 311218893Sdim SetType(SD, ELF::STT_TLS); 312212793Sdim break; 313212793Sdim 314212793Sdim case MCSA_ELF_TypeCommon: 315218893Sdim SetType(SD, ELF::STT_COMMON); 316212793Sdim break; 317212793Sdim 318212793Sdim case MCSA_ELF_TypeNoType: 319218893Sdim SetType(SD, ELF::STT_NOTYPE); 320212793Sdim break; 321212793Sdim 322212793Sdim case MCSA_Protected: 323218893Sdim SetVisibility(SD, ELF::STV_PROTECTED); 324212793Sdim break; 325212793Sdim 326212793Sdim case MCSA_Hidden: 327218893Sdim SetVisibility(SD, ELF::STV_HIDDEN); 328212793Sdim break; 329212793Sdim 330212793Sdim case MCSA_Internal: 331218893Sdim SetVisibility(SD, ELF::STV_INTERNAL); 332212793Sdim break; 333212793Sdim } 334212793Sdim} 335212793Sdim 336212793Sdimvoid MCELFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 337212793Sdim unsigned ByteAlignment) { 338212793Sdim MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 339212793Sdim 340218893Sdim if (!BindingExplicitlySet.count(Symbol)) { 341218893Sdim SetBinding(SD, ELF::STB_GLOBAL); 342218893Sdim SD.setExternal(true); 343218893Sdim } 344218893Sdim 345218893Sdim SetType(SD, ELF::STT_OBJECT); 346218893Sdim 347218893Sdim if (GetBinding(SD) == ELF_STB_Local) { 348212793Sdim const MCSection *Section = getAssembler().getContext().getELFSection(".bss", 349218893Sdim ELF::SHT_NOBITS, 350218893Sdim ELF::SHF_WRITE | 351218893Sdim ELF::SHF_ALLOC, 352212793Sdim SectionKind::getBSS()); 353218893Sdim Symbol->setSection(*Section); 354212793Sdim 355218893Sdim struct LocalCommon L = {&SD, Size, ByteAlignment}; 356218893Sdim LocalCommons.push_back(L); 357218893Sdim } else { 358218893Sdim SD.setCommon(Size, ByteAlignment); 359212793Sdim } 360212793Sdim 361218893Sdim SD.setSize(MCConstantExpr::Create(Size, getContext())); 362218893Sdim} 363212793Sdim 364218893Sdimvoid MCELFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size) { 365218893Sdim // FIXME: Should this be caught and done earlier? 366218893Sdim MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 367218893Sdim SetBinding(SD, ELF::STB_LOCAL); 368218893Sdim SD.setExternal(false); 369218893Sdim BindingExplicitlySet.insert(Symbol); 370218893Sdim // FIXME: ByteAlignment is not needed here, but is required. 371218893Sdim EmitCommonSymbol(Symbol, Size, 1); 372212793Sdim} 373212793Sdim 374212793Sdimvoid MCELFStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) { 375212793Sdim // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into 376212793Sdim // MCObjectStreamer. 377212793Sdim getOrCreateDataFragment()->getContents().append(Data.begin(), Data.end()); 378212793Sdim} 379212793Sdim 380212793Sdimvoid MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment, 381212793Sdim int64_t Value, unsigned ValueSize, 382212793Sdim unsigned MaxBytesToEmit) { 383212793Sdim // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into 384212793Sdim // MCObjectStreamer. 385212793Sdim if (MaxBytesToEmit == 0) 386212793Sdim MaxBytesToEmit = ByteAlignment; 387212793Sdim new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit, 388212793Sdim getCurrentSectionData()); 389212793Sdim 390212793Sdim // Update the maximum alignment on the current section if necessary. 391212793Sdim if (ByteAlignment > getCurrentSectionData()->getAlignment()) 392212793Sdim getCurrentSectionData()->setAlignment(ByteAlignment); 393212793Sdim} 394212793Sdim 395212793Sdimvoid MCELFStreamer::EmitCodeAlignment(unsigned ByteAlignment, 396212793Sdim unsigned MaxBytesToEmit) { 397212793Sdim // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into 398212793Sdim // MCObjectStreamer. 399212793Sdim if (MaxBytesToEmit == 0) 400212793Sdim MaxBytesToEmit = ByteAlignment; 401212793Sdim MCAlignFragment *F = new MCAlignFragment(ByteAlignment, 0, 1, MaxBytesToEmit, 402212793Sdim getCurrentSectionData()); 403212793Sdim F->setEmitNops(true); 404212793Sdim 405212793Sdim // Update the maximum alignment on the current section if necessary. 406212793Sdim if (ByteAlignment > getCurrentSectionData()->getAlignment()) 407212793Sdim getCurrentSectionData()->setAlignment(ByteAlignment); 408212793Sdim} 409212793Sdim 410212793Sdim// Add a symbol for the file name of this module. This is the second 411212793Sdim// entry in the module's symbol table (the first being the null symbol). 412212793Sdimvoid MCELFStreamer::EmitFileDirective(StringRef Filename) { 413212793Sdim MCSymbol *Symbol = getAssembler().getContext().GetOrCreateSymbol(Filename); 414218893Sdim Symbol->setSection(*getCurrentSection()); 415212793Sdim Symbol->setAbsolute(); 416212793Sdim 417212793Sdim MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 418212793Sdim 419212793Sdim SD.setFlags(ELF_STT_File | ELF_STB_Local | ELF_STV_Default); 420212793Sdim} 421212793Sdim 422218893Sdimvoid MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) { 423218893Sdim switch (expr->getKind()) { 424218893Sdim case MCExpr::Target: llvm_unreachable("Can't handle target exprs yet!"); 425218893Sdim case MCExpr::Constant: 426218893Sdim break; 427212793Sdim 428218893Sdim case MCExpr::Binary: { 429218893Sdim const MCBinaryExpr *be = cast<MCBinaryExpr>(expr); 430218893Sdim fixSymbolsInTLSFixups(be->getLHS()); 431218893Sdim fixSymbolsInTLSFixups(be->getRHS()); 432218893Sdim break; 433218893Sdim } 434212793Sdim 435218893Sdim case MCExpr::SymbolRef: { 436218893Sdim const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr); 437218893Sdim switch (symRef.getKind()) { 438218893Sdim default: 439218893Sdim return; 440218893Sdim case MCSymbolRefExpr::VK_NTPOFF: 441218893Sdim case MCSymbolRefExpr::VK_GOTNTPOFF: 442218893Sdim case MCSymbolRefExpr::VK_TLSGD: 443218893Sdim case MCSymbolRefExpr::VK_TLSLDM: 444218893Sdim case MCSymbolRefExpr::VK_TPOFF: 445218893Sdim case MCSymbolRefExpr::VK_DTPOFF: 446218893Sdim case MCSymbolRefExpr::VK_GOTTPOFF: 447218893Sdim case MCSymbolRefExpr::VK_TLSLD: 448218893Sdim case MCSymbolRefExpr::VK_ARM_TLSGD: 449218893Sdim break; 450218893Sdim } 451218893Sdim MCSymbolData &SD = getAssembler().getOrCreateSymbolData(symRef.getSymbol()); 452218893Sdim SetType(SD, ELF::STT_TLS); 453218893Sdim break; 454218893Sdim } 455218893Sdim 456218893Sdim case MCExpr::Unary: 457218893Sdim fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr()); 458218893Sdim break; 459218893Sdim } 460212793Sdim} 461212793Sdim 462218893Sdimvoid MCELFStreamer::EmitInstToFragment(const MCInst &Inst) { 463218893Sdim this->MCObjectStreamer::EmitInstToFragment(Inst); 464218893Sdim MCInstFragment &F = *cast<MCInstFragment>(getCurrentFragment()); 465218893Sdim 466218893Sdim for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i) 467218893Sdim fixSymbolsInTLSFixups(F.getFixups()[i].getValue()); 468218893Sdim} 469218893Sdim 470212793Sdimvoid MCELFStreamer::EmitInstToData(const MCInst &Inst) { 471212793Sdim MCDataFragment *DF = getOrCreateDataFragment(); 472212793Sdim 473212793Sdim SmallVector<MCFixup, 4> Fixups; 474212793Sdim SmallString<256> Code; 475212793Sdim raw_svector_ostream VecOS(Code); 476212793Sdim getAssembler().getEmitter().EncodeInstruction(Inst, VecOS, Fixups); 477212793Sdim VecOS.flush(); 478212793Sdim 479218893Sdim for (unsigned i = 0, e = Fixups.size(); i != e; ++i) 480218893Sdim fixSymbolsInTLSFixups(Fixups[i].getValue()); 481218893Sdim 482212793Sdim // Add the fixups and data. 483212793Sdim for (unsigned i = 0, e = Fixups.size(); i != e; ++i) { 484212793Sdim Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size()); 485212793Sdim DF->addFixup(Fixups[i]); 486212793Sdim } 487212793Sdim DF->getContents().append(Code.begin(), Code.end()); 488212793Sdim} 489212793Sdim 490218893Sdimvoid MCELFStreamer::Finish() { 491218893Sdim if (getNumFrameInfos()) 492218893Sdim MCDwarfFrameEmitter::Emit(*this); 493212793Sdim 494218893Sdim for (std::vector<LocalCommon>::const_iterator i = LocalCommons.begin(), 495218893Sdim e = LocalCommons.end(); 496218893Sdim i != e; ++i) { 497218893Sdim MCSymbolData *SD = i->SD; 498218893Sdim uint64_t Size = i->Size; 499218893Sdim unsigned ByteAlignment = i->ByteAlignment; 500218893Sdim const MCSymbol &Symbol = SD->getSymbol(); 501218893Sdim const MCSection &Section = Symbol.getSection(); 502212793Sdim 503218893Sdim MCSectionData &SectData = getAssembler().getOrCreateSectionData(Section); 504218893Sdim new MCAlignFragment(ByteAlignment, 0, 1, ByteAlignment, &SectData); 505212793Sdim 506218893Sdim MCFragment *F = new MCFillFragment(0, 0, Size, &SectData); 507218893Sdim SD->setFragment(F); 508218893Sdim 509218893Sdim // Update the maximum alignment of the section if necessary. 510218893Sdim if (ByteAlignment > SectData.getAlignment()) 511218893Sdim SectData.setAlignment(ByteAlignment); 512212793Sdim } 513212793Sdim 514218893Sdim this->MCObjectStreamer::Finish(); 515212793Sdim} 516212793Sdim 517212793SdimMCStreamer *llvm::createELFStreamer(MCContext &Context, TargetAsmBackend &TAB, 518218893Sdim raw_ostream &OS, MCCodeEmitter *CE, 519218893Sdim bool RelaxAll, bool NoExecStack) { 520212793Sdim MCELFStreamer *S = new MCELFStreamer(Context, TAB, OS, CE); 521212793Sdim if (RelaxAll) 522212793Sdim S->getAssembler().setRelaxAll(true); 523218893Sdim if (NoExecStack) 524218893Sdim S->getAssembler().setNoExecStack(true); 525212793Sdim return S; 526212793Sdim} 527