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/MCELFStreamer.h" 15 #include "llvm/ADT/SmallPtrSet.h" 16 #include "llvm/ADT/STLExtras.h" 17 #include "llvm/MC/MCAssembler.h" 18 #include "llvm/MC/MCCodeEmitter.h" 19 #include "llvm/MC/MCContext.h" 20 #include "llvm/MC/MCELF.h" 21 #include "llvm/MC/MCELFSymbolFlags.h" 22 #include "llvm/MC/MCExpr.h" 23 #include "llvm/MC/MCInst.h" 24 #include "llvm/MC/MCObjectStreamer.h" 25 #include "llvm/MC/MCSection.h" 26 #include "llvm/MC/MCSectionELF.h" 27 #include "llvm/MC/MCSymbol.h" 28 #include "llvm/MC/MCValue.h" 29 #include "llvm/Support/Debug.h" 30 #include "llvm/Support/ELF.h" 31 #include "llvm/Support/ErrorHandling.h" 32 #include "llvm/Support/raw_ostream.h" 33 34 using namespace llvm; 35 36 37 inline void MCELFStreamer::SetSection(StringRef Section, unsigned Type, 38 unsigned Flags, SectionKind Kind) { 39 SwitchSection(getContext().getELFSection(Section, Type, Flags, Kind)); 40 } 41 42 inline 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 } 49 50 inline 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 } 57 58 inline 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 } 65 66 MCELFStreamer::~MCELFStreamer() { 67 } 68 69 void MCELFStreamer::InitToTextSection() { 70 SetSectionText(); 71 } 72 73 void 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 82 void MCELFStreamer::EmitLabel(MCSymbol *Symbol) { 83 assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); 84 85 MCObjectStreamer::EmitLabel(Symbol); 86 87 const MCSectionELF &Section = 88 static_cast<const MCSectionELF&>(Symbol->getSection()); 89 MCSymbolData &SD = getAssembler().getSymbolData(*Symbol); 90 if (Section.getFlags() & ELF::SHF_TLS) 91 MCELF::SetType(SD, ELF::STT_TLS); 92 } 93 94 void MCELFStreamer::EmitDebugLabel(MCSymbol *Symbol) { 95 EmitLabel(Symbol); 96 } 97 98 void MCELFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) { 99 switch (Flag) { 100 case MCAF_SyntaxUnified: return; // no-op here. 101 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. 104 case MCAF_SubsectionsViaSymbols: 105 getAssembler().setSubsectionsViaSymbols(true); 106 return; 107 } 108 109 llvm_unreachable("invalid assembler flag!"); 110 } 111 112 void MCELFStreamer::ChangeSection(const MCSection *Section, 113 const MCExpr *Subsection) { 114 MCSectionData *CurSection = getCurrentSectionData(); 115 if (CurSection && CurSection->isBundleLocked()) 116 report_fatal_error("Unterminated .bundle_lock when changing a section"); 117 const MCSymbol *Grp = static_cast<const MCSectionELF *>(Section)->getGroup(); 118 if (Grp) 119 getAssembler().getOrCreateSymbolData(*Grp); 120 this->MCObjectStreamer::ChangeSection(Section, Subsection); 121 } 122 123 void 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); 127 const MCExpr *Value = MCSymbolRefExpr::Create(Symbol, getContext()); 128 Alias->setVariableValue(Value); 129 } 130 131 // 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). 138 static 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 151 bool MCELFStreamer::EmitSymbolAttribute(MCSymbol *Symbol, 152 MCSymbolAttr Attribute) { 153 // 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); 162 return true; 163 } 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: 179 case MCSA_SymbolResolver: 180 case MCSA_PrivateExtern: 181 case MCSA_WeakDefinition: 182 case MCSA_WeakDefAutoPrivate: 183 case MCSA_Invalid: 184 case MCSA_IndirectSymbol: 185 return false; 186 187 case MCSA_NoDeadStrip: 188 case MCSA_ELF_TypeGnuUniqueObject: 189 // Ignore for now. 190 break; 191 192 case MCSA_Global: 193 MCELF::SetBinding(SD, ELF::STB_GLOBAL); 194 SD.setExternal(true); 195 BindingExplicitlySet.insert(Symbol); 196 break; 197 198 case MCSA_WeakReference: 199 case MCSA_Weak: 200 MCELF::SetBinding(SD, ELF::STB_WEAK); 201 SD.setExternal(true); 202 BindingExplicitlySet.insert(Symbol); 203 break; 204 205 case MCSA_Local: 206 MCELF::SetBinding(SD, ELF::STB_LOCAL); 207 SD.setExternal(false); 208 BindingExplicitlySet.insert(Symbol); 209 break; 210 211 case MCSA_ELF_TypeFunction: 212 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD), 213 ELF::STT_FUNC)); 214 break; 215 216 case MCSA_ELF_TypeIndFunction: 217 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD), 218 ELF::STT_GNU_IFUNC)); 219 break; 220 221 case MCSA_ELF_TypeObject: 222 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD), 223 ELF::STT_OBJECT)); 224 break; 225 226 case MCSA_ELF_TypeTLS: 227 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD), 228 ELF::STT_TLS)); 229 break; 230 231 case MCSA_ELF_TypeCommon: 232 // TODO: Emit these as a common symbol. 233 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD), 234 ELF::STT_OBJECT)); 235 break; 236 237 case MCSA_ELF_TypeNoType: 238 MCELF::SetType(SD, CombineSymbolTypes(MCELF::GetType(SD), 239 ELF::STT_NOTYPE)); 240 break; 241 242 case MCSA_Protected: 243 MCELF::SetVisibility(SD, ELF::STV_PROTECTED); 244 break; 245 246 case MCSA_Hidden: 247 MCELF::SetVisibility(SD, ELF::STV_HIDDEN); 248 break; 249 250 case MCSA_Internal: 251 MCELF::SetVisibility(SD, ELF::STV_INTERNAL); 252 break; 253 } 254 255 return true; 256 } 257 258 void MCELFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 259 unsigned ByteAlignment) { 260 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 261 262 if (!BindingExplicitlySet.count(Symbol)) { 263 MCELF::SetBinding(SD, ELF::STB_GLOBAL); 264 SD.setExternal(true); 265 } 266 267 MCELF::SetType(SD, ELF::STT_OBJECT); 268 269 if (MCELF::GetBinding(SD) == ELF_STB_Local) { 270 const MCSection *Section = getAssembler().getContext().getELFSection(".bss", 271 ELF::SHT_NOBITS, 272 ELF::SHF_WRITE | 273 ELF::SHF_ALLOC, 274 SectionKind::getBSS()); 275 276 AssignSection(Symbol, Section); 277 278 struct LocalCommon L = {&SD, Size, ByteAlignment}; 279 LocalCommons.push_back(L); 280 } else { 281 SD.setCommon(Size, ByteAlignment); 282 } 283 284 SD.setSize(MCConstantExpr::Create(Size, getContext())); 285 } 286 287 void MCELFStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) { 288 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 289 SD.setSize(Value); 290 } 291 292 void MCELFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, 293 unsigned ByteAlignment) { 294 // FIXME: Should this be caught and done earlier? 295 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 296 MCELF::SetBinding(SD, ELF::STB_LOCAL); 297 SD.setExternal(false); 298 BindingExplicitlySet.insert(Symbol); 299 EmitCommonSymbol(Symbol, Size, ByteAlignment); 300 } 301 302 void MCELFStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size) { 303 if (getCurrentSectionData()->isBundleLocked()) 304 report_fatal_error("Emitting values inside a locked bundle is forbidden"); 305 fixSymbolsInTLSFixups(Value); 306 MCObjectStreamer::EmitValueImpl(Value, Size); 307 } 308 309 void 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 319 // Add a symbol for the file name of this module. They start after the 320 // null symbol and don't count as normal symbol, i.e. a non-STT_FILE symbol 321 // with the same name may appear. 322 void MCELFStreamer::EmitFileDirective(StringRef Filename) { 323 getAssembler().addFileName(Filename); 324 } 325 326 void MCELFStreamer::EmitIdent(StringRef IdentString) { 327 const MCSection *Comment = getAssembler().getContext().getELFSection( 328 ".comment", ELF::SHT_PROGBITS, ELF::SHF_MERGE | ELF::SHF_STRINGS, 329 SectionKind::getReadOnly(), 1, ""); 330 PushSection(); 331 SwitchSection(Comment); 332 if (!SeenIdent) { 333 EmitIntValue(0, 1); 334 SeenIdent = true; 335 } 336 EmitBytes(IdentString); 337 EmitIntValue(0, 1); 338 PopSection(); 339 } 340 341 void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) { 342 switch (expr->getKind()) { 343 case MCExpr::Target: 344 cast<MCTargetExpr>(expr)->fixELFSymbolsInTLSFixups(getAssembler()); 345 break; 346 case MCExpr::Constant: 347 break; 348 349 case MCExpr::Binary: { 350 const MCBinaryExpr *be = cast<MCBinaryExpr>(expr); 351 fixSymbolsInTLSFixups(be->getLHS()); 352 fixSymbolsInTLSFixups(be->getRHS()); 353 break; 354 } 355 356 case MCExpr::SymbolRef: { 357 const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr); 358 switch (symRef.getKind()) { 359 default: 360 return; 361 case MCSymbolRefExpr::VK_GOTTPOFF: 362 case MCSymbolRefExpr::VK_INDNTPOFF: 363 case MCSymbolRefExpr::VK_NTPOFF: 364 case MCSymbolRefExpr::VK_GOTNTPOFF: 365 case MCSymbolRefExpr::VK_TLSGD: 366 case MCSymbolRefExpr::VK_TLSLD: 367 case MCSymbolRefExpr::VK_TLSLDM: 368 case MCSymbolRefExpr::VK_TPOFF: 369 case MCSymbolRefExpr::VK_DTPOFF: 370 case MCSymbolRefExpr::VK_ARM_TLSGD: 371 case MCSymbolRefExpr::VK_ARM_TPOFF: 372 case MCSymbolRefExpr::VK_ARM_GOTTPOFF: 373 case MCSymbolRefExpr::VK_Mips_TLSGD: 374 case MCSymbolRefExpr::VK_Mips_GOTTPREL: 375 case MCSymbolRefExpr::VK_Mips_TPREL_HI: 376 case MCSymbolRefExpr::VK_Mips_TPREL_LO: 377 case MCSymbolRefExpr::VK_PPC_DTPMOD: 378 case MCSymbolRefExpr::VK_PPC_TPREL: 379 case MCSymbolRefExpr::VK_PPC_TPREL_LO: 380 case MCSymbolRefExpr::VK_PPC_TPREL_HI: 381 case MCSymbolRefExpr::VK_PPC_TPREL_HA: 382 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHER: 383 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHERA: 384 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHEST: 385 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHESTA: 386 case MCSymbolRefExpr::VK_PPC_DTPREL: 387 case MCSymbolRefExpr::VK_PPC_DTPREL_LO: 388 case MCSymbolRefExpr::VK_PPC_DTPREL_HI: 389 case MCSymbolRefExpr::VK_PPC_DTPREL_HA: 390 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHER: 391 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHERA: 392 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHEST: 393 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHESTA: 394 case MCSymbolRefExpr::VK_PPC_GOT_TPREL: 395 case MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO: 396 case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HI: 397 case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA: 398 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL: 399 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_LO: 400 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HI: 401 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HA: 402 case MCSymbolRefExpr::VK_PPC_TLS: 403 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD: 404 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO: 405 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HI: 406 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA: 407 case MCSymbolRefExpr::VK_PPC_TLSGD: 408 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD: 409 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO: 410 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HI: 411 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA: 412 case MCSymbolRefExpr::VK_PPC_TLSLD: 413 break; 414 } 415 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(symRef.getSymbol()); 416 MCELF::SetType(SD, ELF::STT_TLS); 417 break; 418 } 419 420 case MCExpr::Unary: 421 fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr()); 422 break; 423 } 424 } 425 426 void MCELFStreamer::EmitInstToFragment(const MCInst &Inst) { 427 this->MCObjectStreamer::EmitInstToFragment(Inst); 428 MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment()); 429 430 for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i) 431 fixSymbolsInTLSFixups(F.getFixups()[i].getValue()); 432 } 433 434 void MCELFStreamer::EmitInstToData(const MCInst &Inst) { 435 MCAssembler &Assembler = getAssembler(); 436 SmallVector<MCFixup, 4> Fixups; 437 SmallString<256> Code; 438 raw_svector_ostream VecOS(Code); 439 Assembler.getEmitter().EncodeInstruction(Inst, VecOS, Fixups); 440 VecOS.flush(); 441 442 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) 443 fixSymbolsInTLSFixups(Fixups[i].getValue()); 444 445 // There are several possibilities here: 446 // 447 // If bundling is disabled, append the encoded instruction to the current data 448 // fragment (or create a new such fragment if the current fragment is not a 449 // data fragment). 450 // 451 // If bundling is enabled: 452 // - If we're not in a bundle-locked group, emit the instruction into a 453 // fragment of its own. If there are no fixups registered for the 454 // instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a 455 // MCDataFragment. 456 // - If we're in a bundle-locked group, append the instruction to the current 457 // data fragment because we want all the instructions in a group to get into 458 // the same fragment. Be careful not to do that for the first instruction in 459 // the group, though. 460 MCDataFragment *DF; 461 462 if (Assembler.isBundlingEnabled()) { 463 MCSectionData *SD = getCurrentSectionData(); 464 if (SD->isBundleLocked() && !SD->isBundleGroupBeforeFirstInst()) 465 // If we are bundle-locked, we re-use the current fragment. 466 // The bundle-locking directive ensures this is a new data fragment. 467 DF = cast<MCDataFragment>(getCurrentFragment()); 468 else if (!SD->isBundleLocked() && Fixups.size() == 0) { 469 // Optimize memory usage by emitting the instruction to a 470 // MCCompactEncodedInstFragment when not in a bundle-locked group and 471 // there are no fixups registered. 472 MCCompactEncodedInstFragment *CEIF = new MCCompactEncodedInstFragment(); 473 insert(CEIF); 474 CEIF->getContents().append(Code.begin(), Code.end()); 475 return; 476 } else { 477 DF = new MCDataFragment(); 478 insert(DF); 479 if (SD->getBundleLockState() == MCSectionData::BundleLockedAlignToEnd) { 480 // If this is a new fragment created for a bundle-locked group, and the 481 // group was marked as "align_to_end", set a flag in the fragment. 482 DF->setAlignToBundleEnd(true); 483 } 484 } 485 486 // We're now emitting an instruction in a bundle group, so this flag has 487 // to be turned off. 488 SD->setBundleGroupBeforeFirstInst(false); 489 } else { 490 DF = getOrCreateDataFragment(); 491 } 492 493 // Add the fixups and data. 494 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) { 495 Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size()); 496 DF->getFixups().push_back(Fixups[i]); 497 } 498 DF->setHasInstructions(true); 499 DF->getContents().append(Code.begin(), Code.end()); 500 } 501 502 void MCELFStreamer::EmitBundleAlignMode(unsigned AlignPow2) { 503 assert(AlignPow2 <= 30 && "Invalid bundle alignment"); 504 MCAssembler &Assembler = getAssembler(); 505 if (Assembler.getBundleAlignSize() == 0 && AlignPow2 > 0) 506 Assembler.setBundleAlignSize(1 << AlignPow2); 507 else 508 report_fatal_error(".bundle_align_mode should be only set once per file"); 509 } 510 511 void MCELFStreamer::EmitBundleLock(bool AlignToEnd) { 512 MCSectionData *SD = getCurrentSectionData(); 513 514 // Sanity checks 515 // 516 if (!getAssembler().isBundlingEnabled()) 517 report_fatal_error(".bundle_lock forbidden when bundling is disabled"); 518 else if (SD->isBundleLocked()) 519 report_fatal_error("Nesting of .bundle_lock is forbidden"); 520 521 SD->setBundleLockState(AlignToEnd ? MCSectionData::BundleLockedAlignToEnd : 522 MCSectionData::BundleLocked); 523 SD->setBundleGroupBeforeFirstInst(true); 524 } 525 526 void MCELFStreamer::EmitBundleUnlock() { 527 MCSectionData *SD = getCurrentSectionData(); 528 529 // Sanity checks 530 if (!getAssembler().isBundlingEnabled()) 531 report_fatal_error(".bundle_unlock forbidden when bundling is disabled"); 532 else if (!SD->isBundleLocked()) 533 report_fatal_error(".bundle_unlock without matching lock"); 534 else if (SD->isBundleGroupBeforeFirstInst()) 535 report_fatal_error("Empty bundle-locked group is forbidden"); 536 537 SD->setBundleLockState(MCSectionData::NotBundleLocked); 538 } 539 540 void MCELFStreamer::Flush() { 541 for (std::vector<LocalCommon>::const_iterator i = LocalCommons.begin(), 542 e = LocalCommons.end(); 543 i != e; ++i) { 544 MCSymbolData *SD = i->SD; 545 uint64_t Size = i->Size; 546 unsigned ByteAlignment = i->ByteAlignment; 547 const MCSymbol &Symbol = SD->getSymbol(); 548 const MCSection &Section = Symbol.getSection(); 549 550 MCSectionData &SectData = getAssembler().getOrCreateSectionData(Section); 551 new MCAlignFragment(ByteAlignment, 0, 1, ByteAlignment, &SectData); 552 553 MCFragment *F = new MCFillFragment(0, 0, Size, &SectData); 554 SD->setFragment(F); 555 556 // Update the maximum alignment of the section if necessary. 557 if (ByteAlignment > SectData.getAlignment()) 558 SectData.setAlignment(ByteAlignment); 559 } 560 561 LocalCommons.clear(); 562 } 563 564 void MCELFStreamer::FinishImpl() { 565 EmitFrames(NULL, true); 566 567 Flush(); 568 569 this->MCObjectStreamer::FinishImpl(); 570 } 571 572 MCStreamer *llvm::createELFStreamer(MCContext &Context, 573 MCTargetStreamer *Streamer, 574 MCAsmBackend &MAB, raw_ostream &OS, 575 MCCodeEmitter *CE, bool RelaxAll, 576 bool NoExecStack) { 577 MCELFStreamer *S = new MCELFStreamer(Context, Streamer, MAB, OS, CE); 578 if (RelaxAll) 579 S->getAssembler().setRelaxAll(true); 580 if (NoExecStack) 581 S->getAssembler().setNoExecStack(true); 582 return S; 583 } 584 585 void MCELFStreamer::EmitThumbFunc(MCSymbol *Func) { 586 llvm_unreachable("Generic ELF doesn't support this directive"); 587 } 588 589 MCSymbolData &MCELFStreamer::getOrCreateSymbolData(MCSymbol *Symbol) { 590 return getAssembler().getOrCreateSymbolData(*Symbol); 591 } 592 593 void MCELFStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) { 594 llvm_unreachable("ELF doesn't support this directive"); 595 } 596 597 void MCELFStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) { 598 llvm_unreachable("ELF doesn't support this directive"); 599 } 600 601 void MCELFStreamer::EmitCOFFSymbolStorageClass(int StorageClass) { 602 llvm_unreachable("ELF doesn't support this directive"); 603 } 604 605 void MCELFStreamer::EmitCOFFSymbolType(int Type) { 606 llvm_unreachable("ELF doesn't support this directive"); 607 } 608 609 void MCELFStreamer::EndCOFFSymbolDef() { 610 llvm_unreachable("ELF doesn't support this directive"); 611 } 612 613 void MCELFStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol, 614 uint64_t Size, unsigned ByteAlignment) { 615 llvm_unreachable("ELF doesn't support this directive"); 616 } 617 618 void MCELFStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol, 619 uint64_t Size, unsigned ByteAlignment) { 620 llvm_unreachable("ELF doesn't support this directive"); 621 } 622