MCELFStreamer.cpp revision 218893
1//===- lib/MC/MCELFStreamer.cpp - ELF 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// This file assembles .s files and emits ELF .o object files. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/MC/MCStreamer.h" 15 16#include "llvm/ADT/SmallPtrSet.h" 17#include "llvm/MC/MCAssembler.h" 18#include "llvm/MC/MCContext.h" 19#include "llvm/MC/MCCodeEmitter.h" 20#include "llvm/MC/MCELFSymbolFlags.h" 21#include "llvm/MC/MCExpr.h" 22#include "llvm/MC/MCInst.h" 23#include "llvm/MC/MCObjectStreamer.h" 24#include "llvm/MC/MCSection.h" 25#include "llvm/MC/MCSectionELF.h" 26#include "llvm/MC/MCSymbol.h" 27#include "llvm/MC/MCValue.h" 28#include "llvm/Support/Debug.h" 29#include "llvm/Support/ELF.h" 30#include "llvm/Support/ErrorHandling.h" 31#include "llvm/Support/raw_ostream.h" 32#include "llvm/Target/TargetAsmBackend.h" 33#include "llvm/Target/TargetAsmInfo.h" 34 35using namespace llvm; 36 37namespace { 38 39static void SetBinding(MCSymbolData &SD, unsigned Binding) { 40 assert(Binding == ELF::STB_LOCAL || Binding == ELF::STB_GLOBAL || 41 Binding == ELF::STB_WEAK); 42 uint32_t OtherFlags = SD.getFlags() & ~(0xf << ELF_STB_Shift); 43 SD.setFlags(OtherFlags | (Binding << ELF_STB_Shift)); 44} 45 46static unsigned GetBinding(const MCSymbolData &SD) { 47 uint32_t Binding = (SD.getFlags() & (0xf << ELF_STB_Shift)) >> ELF_STB_Shift; 48 assert(Binding == ELF::STB_LOCAL || Binding == ELF::STB_GLOBAL || 49 Binding == ELF::STB_WEAK); 50 return Binding; 51} 52 53static void SetType(MCSymbolData &SD, unsigned Type) { 54 assert(Type == ELF::STT_NOTYPE || Type == ELF::STT_OBJECT || 55 Type == ELF::STT_FUNC || Type == ELF::STT_SECTION || 56 Type == ELF::STT_FILE || Type == ELF::STT_COMMON || 57 Type == ELF::STT_TLS); 58 59 uint32_t OtherFlags = SD.getFlags() & ~(0xf << ELF_STT_Shift); 60 SD.setFlags(OtherFlags | (Type << ELF_STT_Shift)); 61} 62 63static void SetVisibility(MCSymbolData &SD, unsigned Visibility) { 64 assert(Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_INTERNAL || 65 Visibility == ELF::STV_HIDDEN || Visibility == ELF::STV_PROTECTED); 66 67 uint32_t OtherFlags = SD.getFlags() & ~(0xf << ELF_STV_Shift); 68 SD.setFlags(OtherFlags | (Visibility << ELF_STV_Shift)); 69} 70 71class MCELFStreamer : public MCObjectStreamer { 72public: 73 MCELFStreamer(MCContext &Context, TargetAsmBackend &TAB, 74 raw_ostream &OS, MCCodeEmitter *Emitter) 75 : MCObjectStreamer(Context, TAB, OS, Emitter) {} 76 77 ~MCELFStreamer() {} 78 79 /// @name MCStreamer Interface 80 /// @{ 81 82 virtual void InitSections(); 83 virtual void ChangeSection(const MCSection *Section); 84 virtual void EmitLabel(MCSymbol *Symbol); 85 virtual void EmitAssemblerFlag(MCAssemblerFlag Flag); 86 virtual void EmitThumbFunc(MCSymbol *Func); 87 virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value); 88 virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol); 89 virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute); 90 virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) { 91 assert(0 && "ELF doesn't support this directive"); 92 } 93 virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 94 unsigned ByteAlignment); 95 virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol) { 96 assert(0 && "ELF doesn't support this directive"); 97 } 98 99 virtual void EmitCOFFSymbolStorageClass(int StorageClass) { 100 assert(0 && "ELF doesn't support this directive"); 101 } 102 103 virtual void EmitCOFFSymbolType(int Type) { 104 assert(0 && "ELF doesn't support this directive"); 105 } 106 107 virtual void EndCOFFSymbolDef() { 108 assert(0 && "ELF doesn't support this directive"); 109 } 110 111 virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) { 112 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 113 SD.setSize(Value); 114 } 115 116 virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size); 117 118 virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol = 0, 119 unsigned Size = 0, unsigned ByteAlignment = 0) { 120 assert(0 && "ELF doesn't support this directive"); 121 } 122 virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol, 123 uint64_t Size, unsigned ByteAlignment = 0) { 124 assert(0 && "ELF doesn't support this directive"); 125 } 126 virtual void EmitBytes(StringRef Data, unsigned AddrSpace); 127 virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, 128 unsigned ValueSize = 1, 129 unsigned MaxBytesToEmit = 0); 130 virtual void EmitCodeAlignment(unsigned ByteAlignment, 131 unsigned MaxBytesToEmit = 0); 132 133 virtual void EmitFileDirective(StringRef Filename); 134 135 virtual void Finish(); 136 137private: 138 virtual void EmitInstToFragment(const MCInst &Inst); 139 virtual void EmitInstToData(const MCInst &Inst); 140 141 void fixSymbolsInTLSFixups(const MCExpr *expr); 142 143 struct LocalCommon { 144 MCSymbolData *SD; 145 uint64_t Size; 146 unsigned ByteAlignment; 147 }; 148 std::vector<LocalCommon> LocalCommons; 149 150 SmallPtrSet<MCSymbol *, 16> BindingExplicitlySet; 151 /// @} 152 void SetSection(StringRef Section, unsigned Type, unsigned Flags, 153 SectionKind Kind) { 154 SwitchSection(getContext().getELFSection(Section, Type, Flags, Kind)); 155 } 156 157 void SetSectionData() { 158 SetSection(".data", ELF::SHT_PROGBITS, 159 ELF::SHF_WRITE |ELF::SHF_ALLOC, 160 SectionKind::getDataRel()); 161 EmitCodeAlignment(4, 0); 162 } 163 void SetSectionText() { 164 SetSection(".text", ELF::SHT_PROGBITS, 165 ELF::SHF_EXECINSTR | 166 ELF::SHF_ALLOC, SectionKind::getText()); 167 EmitCodeAlignment(4, 0); 168 } 169 void SetSectionBss() { 170 SetSection(".bss", ELF::SHT_NOBITS, 171 ELF::SHF_WRITE | 172 ELF::SHF_ALLOC, SectionKind::getBSS()); 173 EmitCodeAlignment(4, 0); 174 } 175}; 176 177} // end anonymous namespace. 178 179void MCELFStreamer::InitSections() { 180 // This emulates the same behavior of GNU as. This makes it easier 181 // to compare the output as the major sections are in the same order. 182 SetSectionText(); 183 SetSectionData(); 184 SetSectionBss(); 185 SetSectionText(); 186} 187 188void MCELFStreamer::EmitLabel(MCSymbol *Symbol) { 189 assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); 190 191 MCObjectStreamer::EmitLabel(Symbol); 192 193 const MCSectionELF &Section = 194 static_cast<const MCSectionELF&>(Symbol->getSection()); 195 MCSymbolData &SD = getAssembler().getSymbolData(*Symbol); 196 if (Section.getFlags() & ELF::SHF_TLS) 197 SetType(SD, ELF::STT_TLS); 198} 199 200void MCELFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) { 201 switch (Flag) { 202 case MCAF_SyntaxUnified: return; // no-op here. 203 case MCAF_Code16: return; // no-op here. 204 case MCAF_Code32: return; // no-op here. 205 case MCAF_SubsectionsViaSymbols: 206 getAssembler().setSubsectionsViaSymbols(true); 207 return; 208 } 209 210 assert(0 && "invalid assembler flag!"); 211} 212 213void MCELFStreamer::EmitThumbFunc(MCSymbol *Func) { 214 // FIXME: Anything needed here to flag the function as thumb? 215} 216 217void MCELFStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) { 218 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into 219 // MCObjectStreamer. 220 // FIXME: Lift context changes into super class. 221 getAssembler().getOrCreateSymbolData(*Symbol); 222 Symbol->setVariableValue(AddValueSymbols(Value)); 223} 224 225void MCELFStreamer::ChangeSection(const MCSection *Section) { 226 const MCSymbol *Grp = static_cast<const MCSectionELF *>(Section)->getGroup(); 227 if (Grp) 228 getAssembler().getOrCreateSymbolData(*Grp); 229 this->MCObjectStreamer::ChangeSection(Section); 230} 231 232void MCELFStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) { 233 getAssembler().getOrCreateSymbolData(*Symbol); 234 MCSymbolData &AliasSD = getAssembler().getOrCreateSymbolData(*Alias); 235 AliasSD.setFlags(AliasSD.getFlags() | ELF_Other_Weakref); 236 const MCExpr *Value = MCSymbolRefExpr::Create(Symbol, getContext()); 237 Alias->setVariableValue(Value); 238} 239 240void MCELFStreamer::EmitSymbolAttribute(MCSymbol *Symbol, 241 MCSymbolAttr Attribute) { 242 // Indirect symbols are handled differently, to match how 'as' handles 243 // them. This makes writing matching .o files easier. 244 if (Attribute == MCSA_IndirectSymbol) { 245 // Note that we intentionally cannot use the symbol data here; this is 246 // important for matching the string table that 'as' generates. 247 IndirectSymbolData ISD; 248 ISD.Symbol = Symbol; 249 ISD.SectionData = getCurrentSectionData(); 250 getAssembler().getIndirectSymbols().push_back(ISD); 251 return; 252 } 253 254 // Adding a symbol attribute always introduces the symbol, note that an 255 // important side effect of calling getOrCreateSymbolData here is to register 256 // the symbol with the assembler. 257 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 258 259 // The implementation of symbol attributes is designed to match 'as', but it 260 // leaves much to desired. It doesn't really make sense to arbitrarily add and 261 // remove flags, but 'as' allows this (in particular, see .desc). 262 // 263 // In the future it might be worth trying to make these operations more well 264 // defined. 265 switch (Attribute) { 266 case MCSA_LazyReference: 267 case MCSA_Reference: 268 case MCSA_NoDeadStrip: 269 case MCSA_SymbolResolver: 270 case MCSA_PrivateExtern: 271 case MCSA_WeakDefinition: 272 case MCSA_WeakDefAutoPrivate: 273 case MCSA_Invalid: 274 case MCSA_ELF_TypeIndFunction: 275 case MCSA_IndirectSymbol: 276 assert(0 && "Invalid symbol attribute for ELF!"); 277 break; 278 279 case MCSA_ELF_TypeGnuUniqueObject: 280 // Ignore for now. 281 break; 282 283 case MCSA_Global: 284 SetBinding(SD, ELF::STB_GLOBAL); 285 SD.setExternal(true); 286 BindingExplicitlySet.insert(Symbol); 287 break; 288 289 case MCSA_WeakReference: 290 case MCSA_Weak: 291 SetBinding(SD, ELF::STB_WEAK); 292 SD.setExternal(true); 293 BindingExplicitlySet.insert(Symbol); 294 break; 295 296 case MCSA_Local: 297 SetBinding(SD, ELF::STB_LOCAL); 298 SD.setExternal(false); 299 BindingExplicitlySet.insert(Symbol); 300 break; 301 302 case MCSA_ELF_TypeFunction: 303 SetType(SD, ELF::STT_FUNC); 304 break; 305 306 case MCSA_ELF_TypeObject: 307 SetType(SD, ELF::STT_OBJECT); 308 break; 309 310 case MCSA_ELF_TypeTLS: 311 SetType(SD, ELF::STT_TLS); 312 break; 313 314 case MCSA_ELF_TypeCommon: 315 SetType(SD, ELF::STT_COMMON); 316 break; 317 318 case MCSA_ELF_TypeNoType: 319 SetType(SD, ELF::STT_NOTYPE); 320 break; 321 322 case MCSA_Protected: 323 SetVisibility(SD, ELF::STV_PROTECTED); 324 break; 325 326 case MCSA_Hidden: 327 SetVisibility(SD, ELF::STV_HIDDEN); 328 break; 329 330 case MCSA_Internal: 331 SetVisibility(SD, ELF::STV_INTERNAL); 332 break; 333 } 334} 335 336void MCELFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 337 unsigned ByteAlignment) { 338 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 339 340 if (!BindingExplicitlySet.count(Symbol)) { 341 SetBinding(SD, ELF::STB_GLOBAL); 342 SD.setExternal(true); 343 } 344 345 SetType(SD, ELF::STT_OBJECT); 346 347 if (GetBinding(SD) == ELF_STB_Local) { 348 const MCSection *Section = getAssembler().getContext().getELFSection(".bss", 349 ELF::SHT_NOBITS, 350 ELF::SHF_WRITE | 351 ELF::SHF_ALLOC, 352 SectionKind::getBSS()); 353 Symbol->setSection(*Section); 354 355 struct LocalCommon L = {&SD, Size, ByteAlignment}; 356 LocalCommons.push_back(L); 357 } else { 358 SD.setCommon(Size, ByteAlignment); 359 } 360 361 SD.setSize(MCConstantExpr::Create(Size, getContext())); 362} 363 364void MCELFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size) { 365 // FIXME: Should this be caught and done earlier? 366 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 367 SetBinding(SD, ELF::STB_LOCAL); 368 SD.setExternal(false); 369 BindingExplicitlySet.insert(Symbol); 370 // FIXME: ByteAlignment is not needed here, but is required. 371 EmitCommonSymbol(Symbol, Size, 1); 372} 373 374void MCELFStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) { 375 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into 376 // MCObjectStreamer. 377 getOrCreateDataFragment()->getContents().append(Data.begin(), Data.end()); 378} 379 380void MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment, 381 int64_t Value, unsigned ValueSize, 382 unsigned MaxBytesToEmit) { 383 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into 384 // MCObjectStreamer. 385 if (MaxBytesToEmit == 0) 386 MaxBytesToEmit = ByteAlignment; 387 new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit, 388 getCurrentSectionData()); 389 390 // Update the maximum alignment on the current section if necessary. 391 if (ByteAlignment > getCurrentSectionData()->getAlignment()) 392 getCurrentSectionData()->setAlignment(ByteAlignment); 393} 394 395void MCELFStreamer::EmitCodeAlignment(unsigned ByteAlignment, 396 unsigned MaxBytesToEmit) { 397 // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into 398 // MCObjectStreamer. 399 if (MaxBytesToEmit == 0) 400 MaxBytesToEmit = ByteAlignment; 401 MCAlignFragment *F = new MCAlignFragment(ByteAlignment, 0, 1, MaxBytesToEmit, 402 getCurrentSectionData()); 403 F->setEmitNops(true); 404 405 // Update the maximum alignment on the current section if necessary. 406 if (ByteAlignment > getCurrentSectionData()->getAlignment()) 407 getCurrentSectionData()->setAlignment(ByteAlignment); 408} 409 410// Add a symbol for the file name of this module. This is the second 411// entry in the module's symbol table (the first being the null symbol). 412void MCELFStreamer::EmitFileDirective(StringRef Filename) { 413 MCSymbol *Symbol = getAssembler().getContext().GetOrCreateSymbol(Filename); 414 Symbol->setSection(*getCurrentSection()); 415 Symbol->setAbsolute(); 416 417 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 418 419 SD.setFlags(ELF_STT_File | ELF_STB_Local | ELF_STV_Default); 420} 421 422void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) { 423 switch (expr->getKind()) { 424 case MCExpr::Target: llvm_unreachable("Can't handle target exprs yet!"); 425 case MCExpr::Constant: 426 break; 427 428 case MCExpr::Binary: { 429 const MCBinaryExpr *be = cast<MCBinaryExpr>(expr); 430 fixSymbolsInTLSFixups(be->getLHS()); 431 fixSymbolsInTLSFixups(be->getRHS()); 432 break; 433 } 434 435 case MCExpr::SymbolRef: { 436 const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr); 437 switch (symRef.getKind()) { 438 default: 439 return; 440 case MCSymbolRefExpr::VK_NTPOFF: 441 case MCSymbolRefExpr::VK_GOTNTPOFF: 442 case MCSymbolRefExpr::VK_TLSGD: 443 case MCSymbolRefExpr::VK_TLSLDM: 444 case MCSymbolRefExpr::VK_TPOFF: 445 case MCSymbolRefExpr::VK_DTPOFF: 446 case MCSymbolRefExpr::VK_GOTTPOFF: 447 case MCSymbolRefExpr::VK_TLSLD: 448 case MCSymbolRefExpr::VK_ARM_TLSGD: 449 break; 450 } 451 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(symRef.getSymbol()); 452 SetType(SD, ELF::STT_TLS); 453 break; 454 } 455 456 case MCExpr::Unary: 457 fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr()); 458 break; 459 } 460} 461 462void MCELFStreamer::EmitInstToFragment(const MCInst &Inst) { 463 this->MCObjectStreamer::EmitInstToFragment(Inst); 464 MCInstFragment &F = *cast<MCInstFragment>(getCurrentFragment()); 465 466 for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i) 467 fixSymbolsInTLSFixups(F.getFixups()[i].getValue()); 468} 469 470void MCELFStreamer::EmitInstToData(const MCInst &Inst) { 471 MCDataFragment *DF = getOrCreateDataFragment(); 472 473 SmallVector<MCFixup, 4> Fixups; 474 SmallString<256> Code; 475 raw_svector_ostream VecOS(Code); 476 getAssembler().getEmitter().EncodeInstruction(Inst, VecOS, Fixups); 477 VecOS.flush(); 478 479 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) 480 fixSymbolsInTLSFixups(Fixups[i].getValue()); 481 482 // Add the fixups and data. 483 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) { 484 Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size()); 485 DF->addFixup(Fixups[i]); 486 } 487 DF->getContents().append(Code.begin(), Code.end()); 488} 489 490void MCELFStreamer::Finish() { 491 if (getNumFrameInfos()) 492 MCDwarfFrameEmitter::Emit(*this); 493 494 for (std::vector<LocalCommon>::const_iterator i = LocalCommons.begin(), 495 e = LocalCommons.end(); 496 i != e; ++i) { 497 MCSymbolData *SD = i->SD; 498 uint64_t Size = i->Size; 499 unsigned ByteAlignment = i->ByteAlignment; 500 const MCSymbol &Symbol = SD->getSymbol(); 501 const MCSection &Section = Symbol.getSection(); 502 503 MCSectionData &SectData = getAssembler().getOrCreateSectionData(Section); 504 new MCAlignFragment(ByteAlignment, 0, 1, ByteAlignment, &SectData); 505 506 MCFragment *F = new MCFillFragment(0, 0, Size, &SectData); 507 SD->setFragment(F); 508 509 // Update the maximum alignment of the section if necessary. 510 if (ByteAlignment > SectData.getAlignment()) 511 SectData.setAlignment(ByteAlignment); 512 } 513 514 this->MCObjectStreamer::Finish(); 515} 516 517MCStreamer *llvm::createELFStreamer(MCContext &Context, TargetAsmBackend &TAB, 518 raw_ostream &OS, MCCodeEmitter *CE, 519 bool RelaxAll, bool NoExecStack) { 520 MCELFStreamer *S = new MCELFStreamer(Context, TAB, OS, CE); 521 if (RelaxAll) 522 S->getAssembler().setRelaxAll(true); 523 if (NoExecStack) 524 S->getAssembler().setNoExecStack(true); 525 return S; 526} 527