1 //===- lib/MC/MCELFStreamer.cpp - ELF Object Output -----------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file assembles .s files and emits ELF .o object files. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/MC/MCELFStreamer.h" 14 #include "llvm/ADT/SmallString.h" 15 #include "llvm/ADT/SmallVector.h" 16 #include "llvm/BinaryFormat/ELF.h" 17 #include "llvm/MC/MCAsmBackend.h" 18 #include "llvm/MC/MCAsmInfo.h" 19 #include "llvm/MC/MCAssembler.h" 20 #include "llvm/MC/MCCodeEmitter.h" 21 #include "llvm/MC/MCContext.h" 22 #include "llvm/MC/MCExpr.h" 23 #include "llvm/MC/MCFixup.h" 24 #include "llvm/MC/MCFragment.h" 25 #include "llvm/MC/MCObjectFileInfo.h" 26 #include "llvm/MC/MCObjectWriter.h" 27 #include "llvm/MC/MCSection.h" 28 #include "llvm/MC/MCSectionELF.h" 29 #include "llvm/MC/MCStreamer.h" 30 #include "llvm/MC/MCSymbol.h" 31 #include "llvm/MC/MCSymbolELF.h" 32 #include "llvm/Support/Casting.h" 33 #include "llvm/Support/ErrorHandling.h" 34 #include "llvm/Support/TargetRegistry.h" 35 #include "llvm/Support/raw_ostream.h" 36 #include <cassert> 37 #include <cstdint> 38 39 using namespace llvm; 40 41 MCELFStreamer::MCELFStreamer(MCContext &Context, 42 std::unique_ptr<MCAsmBackend> TAB, 43 std::unique_ptr<MCObjectWriter> OW, 44 std::unique_ptr<MCCodeEmitter> Emitter) 45 : MCObjectStreamer(Context, std::move(TAB), std::move(OW), 46 std::move(Emitter)) {} 47 48 bool MCELFStreamer::isBundleLocked() const { 49 return getCurrentSectionOnly()->isBundleLocked(); 50 } 51 52 void MCELFStreamer::mergeFragment(MCDataFragment *DF, 53 MCDataFragment *EF) { 54 MCAssembler &Assembler = getAssembler(); 55 56 if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) { 57 uint64_t FSize = EF->getContents().size(); 58 59 if (FSize > Assembler.getBundleAlignSize()) 60 report_fatal_error("Fragment can't be larger than a bundle size"); 61 62 uint64_t RequiredBundlePadding = computeBundlePadding( 63 Assembler, EF, DF->getContents().size(), FSize); 64 65 if (RequiredBundlePadding > UINT8_MAX) 66 report_fatal_error("Padding cannot exceed 255 bytes"); 67 68 if (RequiredBundlePadding > 0) { 69 SmallString<256> Code; 70 raw_svector_ostream VecOS(Code); 71 EF->setBundlePadding(static_cast<uint8_t>(RequiredBundlePadding)); 72 Assembler.writeFragmentPadding(VecOS, *EF, FSize); 73 74 DF->getContents().append(Code.begin(), Code.end()); 75 } 76 } 77 78 flushPendingLabels(DF, DF->getContents().size()); 79 80 for (unsigned i = 0, e = EF->getFixups().size(); i != e; ++i) { 81 EF->getFixups()[i].setOffset(EF->getFixups()[i].getOffset() + 82 DF->getContents().size()); 83 DF->getFixups().push_back(EF->getFixups()[i]); 84 } 85 if (DF->getSubtargetInfo() == nullptr && EF->getSubtargetInfo()) 86 DF->setHasInstructions(*EF->getSubtargetInfo()); 87 DF->getContents().append(EF->getContents().begin(), EF->getContents().end()); 88 } 89 90 void MCELFStreamer::InitSections(bool NoExecStack) { 91 MCContext &Ctx = getContext(); 92 SwitchSection(Ctx.getObjectFileInfo()->getTextSection()); 93 emitCodeAlignment(4); 94 95 if (NoExecStack) 96 SwitchSection(Ctx.getAsmInfo()->getNonexecutableStackSection(Ctx)); 97 } 98 99 void MCELFStreamer::emitLabel(MCSymbol *S, SMLoc Loc) { 100 auto *Symbol = cast<MCSymbolELF>(S); 101 MCObjectStreamer::emitLabel(Symbol, Loc); 102 103 const MCSectionELF &Section = 104 static_cast<const MCSectionELF &>(*getCurrentSectionOnly()); 105 if (Section.getFlags() & ELF::SHF_TLS) 106 Symbol->setType(ELF::STT_TLS); 107 } 108 109 void MCELFStreamer::emitLabelAtPos(MCSymbol *S, SMLoc Loc, MCFragment *F, 110 uint64_t Offset) { 111 auto *Symbol = cast<MCSymbolELF>(S); 112 MCObjectStreamer::emitLabelAtPos(Symbol, Loc, F, Offset); 113 114 const MCSectionELF &Section = 115 static_cast<const MCSectionELF &>(*getCurrentSectionOnly()); 116 if (Section.getFlags() & ELF::SHF_TLS) 117 Symbol->setType(ELF::STT_TLS); 118 } 119 120 void MCELFStreamer::emitAssemblerFlag(MCAssemblerFlag Flag) { 121 // Let the target do whatever target specific stuff it needs to do. 122 getAssembler().getBackend().handleAssemblerFlag(Flag); 123 // Do any generic stuff we need to do. 124 switch (Flag) { 125 case MCAF_SyntaxUnified: return; // no-op here. 126 case MCAF_Code16: return; // Change parsing mode; no-op here. 127 case MCAF_Code32: return; // Change parsing mode; no-op here. 128 case MCAF_Code64: return; // Change parsing mode; no-op here. 129 case MCAF_SubsectionsViaSymbols: 130 getAssembler().setSubsectionsViaSymbols(true); 131 return; 132 } 133 134 llvm_unreachable("invalid assembler flag!"); 135 } 136 137 // If bundle alignment is used and there are any instructions in the section, it 138 // needs to be aligned to at least the bundle size. 139 static void setSectionAlignmentForBundling(const MCAssembler &Assembler, 140 MCSection *Section) { 141 if (Section && Assembler.isBundlingEnabled() && Section->hasInstructions() && 142 Section->getAlignment() < Assembler.getBundleAlignSize()) 143 Section->setAlignment(Align(Assembler.getBundleAlignSize())); 144 } 145 146 void MCELFStreamer::changeSection(MCSection *Section, 147 const MCExpr *Subsection) { 148 MCSection *CurSection = getCurrentSectionOnly(); 149 if (CurSection && isBundleLocked()) 150 report_fatal_error("Unterminated .bundle_lock when changing a section"); 151 152 MCAssembler &Asm = getAssembler(); 153 // Ensure the previous section gets aligned if necessary. 154 setSectionAlignmentForBundling(Asm, CurSection); 155 auto *SectionELF = static_cast<const MCSectionELF *>(Section); 156 const MCSymbol *Grp = SectionELF->getGroup(); 157 if (Grp) 158 Asm.registerSymbol(*Grp); 159 160 changeSectionImpl(Section, Subsection); 161 Asm.registerSymbol(*Section->getBeginSymbol()); 162 } 163 164 void MCELFStreamer::emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) { 165 getAssembler().registerSymbol(*Symbol); 166 const MCExpr *Value = MCSymbolRefExpr::create( 167 Symbol, MCSymbolRefExpr::VK_WEAKREF, getContext()); 168 Alias->setVariableValue(Value); 169 } 170 171 // When GNU as encounters more than one .type declaration for an object it seems 172 // to use a mechanism similar to the one below to decide which type is actually 173 // used in the object file. The greater of T1 and T2 is selected based on the 174 // following ordering: 175 // STT_NOTYPE < STT_OBJECT < STT_FUNC < STT_GNU_IFUNC < STT_TLS < anything else 176 // If neither T1 < T2 nor T2 < T1 according to this ordering, use T2 (the user 177 // provided type). 178 static unsigned CombineSymbolTypes(unsigned T1, unsigned T2) { 179 for (unsigned Type : {ELF::STT_NOTYPE, ELF::STT_OBJECT, ELF::STT_FUNC, 180 ELF::STT_GNU_IFUNC, ELF::STT_TLS}) { 181 if (T1 == Type) 182 return T2; 183 if (T2 == Type) 184 return T1; 185 } 186 187 return T2; 188 } 189 190 bool MCELFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) { 191 auto *Symbol = cast<MCSymbolELF>(S); 192 193 // Adding a symbol attribute always introduces the symbol, note that an 194 // important side effect of calling registerSymbol here is to register 195 // the symbol with the assembler. 196 getAssembler().registerSymbol(*Symbol); 197 198 // The implementation of symbol attributes is designed to match 'as', but it 199 // leaves much to desired. It doesn't really make sense to arbitrarily add and 200 // remove flags, but 'as' allows this (in particular, see .desc). 201 // 202 // In the future it might be worth trying to make these operations more well 203 // defined. 204 switch (Attribute) { 205 case MCSA_Cold: 206 case MCSA_Extern: 207 case MCSA_LazyReference: 208 case MCSA_Reference: 209 case MCSA_SymbolResolver: 210 case MCSA_PrivateExtern: 211 case MCSA_WeakDefinition: 212 case MCSA_WeakDefAutoPrivate: 213 case MCSA_Invalid: 214 case MCSA_IndirectSymbol: 215 return false; 216 217 case MCSA_NoDeadStrip: 218 // Ignore for now. 219 break; 220 221 case MCSA_ELF_TypeGnuUniqueObject: 222 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT)); 223 Symbol->setBinding(ELF::STB_GNU_UNIQUE); 224 break; 225 226 case MCSA_Global: 227 // For `.weak x; .global x`, GNU as sets the binding to STB_WEAK while we 228 // traditionally set the binding to STB_GLOBAL. This is error-prone, so we 229 // error on such cases. Note, we also disallow changed binding from .local. 230 if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_GLOBAL) 231 getContext().reportError(getStartTokLoc(), 232 Symbol->getName() + 233 " changed binding to STB_GLOBAL"); 234 Symbol->setBinding(ELF::STB_GLOBAL); 235 break; 236 237 case MCSA_WeakReference: 238 case MCSA_Weak: 239 // For `.global x; .weak x`, both MC and GNU as set the binding to STB_WEAK. 240 // We emit a warning for now but may switch to an error in the future. 241 if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_WEAK) 242 getContext().reportWarning( 243 getStartTokLoc(), Symbol->getName() + " changed binding to STB_WEAK"); 244 Symbol->setBinding(ELF::STB_WEAK); 245 break; 246 247 case MCSA_Local: 248 if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_LOCAL) 249 getContext().reportError(getStartTokLoc(), 250 Symbol->getName() + 251 " changed binding to STB_LOCAL"); 252 Symbol->setBinding(ELF::STB_LOCAL); 253 break; 254 255 case MCSA_ELF_TypeFunction: 256 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_FUNC)); 257 break; 258 259 case MCSA_ELF_TypeIndFunction: 260 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_GNU_IFUNC)); 261 break; 262 263 case MCSA_ELF_TypeObject: 264 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT)); 265 break; 266 267 case MCSA_ELF_TypeTLS: 268 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_TLS)); 269 break; 270 271 case MCSA_ELF_TypeCommon: 272 // TODO: Emit these as a common symbol. 273 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_OBJECT)); 274 break; 275 276 case MCSA_ELF_TypeNoType: 277 Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_NOTYPE)); 278 break; 279 280 case MCSA_Protected: 281 Symbol->setVisibility(ELF::STV_PROTECTED); 282 break; 283 284 case MCSA_Hidden: 285 Symbol->setVisibility(ELF::STV_HIDDEN); 286 break; 287 288 case MCSA_Internal: 289 Symbol->setVisibility(ELF::STV_INTERNAL); 290 break; 291 292 case MCSA_AltEntry: 293 llvm_unreachable("ELF doesn't support the .alt_entry attribute"); 294 295 case MCSA_LGlobal: 296 llvm_unreachable("ELF doesn't support the .lglobl attribute"); 297 } 298 299 return true; 300 } 301 302 void MCELFStreamer::emitCommonSymbol(MCSymbol *S, uint64_t Size, 303 unsigned ByteAlignment) { 304 auto *Symbol = cast<MCSymbolELF>(S); 305 getAssembler().registerSymbol(*Symbol); 306 307 if (!Symbol->isBindingSet()) 308 Symbol->setBinding(ELF::STB_GLOBAL); 309 310 Symbol->setType(ELF::STT_OBJECT); 311 312 if (Symbol->getBinding() == ELF::STB_LOCAL) { 313 MCSection &Section = *getAssembler().getContext().getELFSection( 314 ".bss", ELF::SHT_NOBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC); 315 MCSectionSubPair P = getCurrentSection(); 316 SwitchSection(&Section); 317 318 emitValueToAlignment(ByteAlignment, 0, 1, 0); 319 emitLabel(Symbol); 320 emitZeros(Size); 321 322 SwitchSection(P.first, P.second); 323 } else { 324 if(Symbol->declareCommon(Size, ByteAlignment)) 325 report_fatal_error("Symbol: " + Symbol->getName() + 326 " redeclared as different type"); 327 } 328 329 cast<MCSymbolELF>(Symbol) 330 ->setSize(MCConstantExpr::create(Size, getContext())); 331 } 332 333 void MCELFStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) { 334 cast<MCSymbolELF>(Symbol)->setSize(Value); 335 } 336 337 void MCELFStreamer::emitELFSymverDirective(StringRef AliasName, 338 const MCSymbol *Aliasee) { 339 getAssembler().Symvers.push_back( 340 MCAssembler::Symver{AliasName, Aliasee, getStartTokLoc()}); 341 } 342 343 void MCELFStreamer::emitLocalCommonSymbol(MCSymbol *S, uint64_t Size, 344 unsigned ByteAlignment) { 345 auto *Symbol = cast<MCSymbolELF>(S); 346 // FIXME: Should this be caught and done earlier? 347 getAssembler().registerSymbol(*Symbol); 348 Symbol->setBinding(ELF::STB_LOCAL); 349 emitCommonSymbol(Symbol, Size, ByteAlignment); 350 } 351 352 void MCELFStreamer::emitValueImpl(const MCExpr *Value, unsigned Size, 353 SMLoc Loc) { 354 if (isBundleLocked()) 355 report_fatal_error("Emitting values inside a locked bundle is forbidden"); 356 fixSymbolsInTLSFixups(Value); 357 MCObjectStreamer::emitValueImpl(Value, Size, Loc); 358 } 359 360 void MCELFStreamer::emitValueToAlignment(unsigned ByteAlignment, 361 int64_t Value, 362 unsigned ValueSize, 363 unsigned MaxBytesToEmit) { 364 if (isBundleLocked()) 365 report_fatal_error("Emitting values inside a locked bundle is forbidden"); 366 MCObjectStreamer::emitValueToAlignment(ByteAlignment, Value, 367 ValueSize, MaxBytesToEmit); 368 } 369 370 void MCELFStreamer::emitCGProfileEntry(const MCSymbolRefExpr *From, 371 const MCSymbolRefExpr *To, 372 uint64_t Count) { 373 getAssembler().CGProfile.push_back({From, To, Count}); 374 } 375 376 void MCELFStreamer::emitIdent(StringRef IdentString) { 377 MCSection *Comment = getAssembler().getContext().getELFSection( 378 ".comment", ELF::SHT_PROGBITS, ELF::SHF_MERGE | ELF::SHF_STRINGS, 1, ""); 379 PushSection(); 380 SwitchSection(Comment); 381 if (!SeenIdent) { 382 emitInt8(0); 383 SeenIdent = true; 384 } 385 emitBytes(IdentString); 386 emitInt8(0); 387 PopSection(); 388 } 389 390 void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) { 391 switch (expr->getKind()) { 392 case MCExpr::Target: 393 cast<MCTargetExpr>(expr)->fixELFSymbolsInTLSFixups(getAssembler()); 394 break; 395 case MCExpr::Constant: 396 break; 397 398 case MCExpr::Binary: { 399 const MCBinaryExpr *be = cast<MCBinaryExpr>(expr); 400 fixSymbolsInTLSFixups(be->getLHS()); 401 fixSymbolsInTLSFixups(be->getRHS()); 402 break; 403 } 404 405 case MCExpr::SymbolRef: { 406 const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr); 407 switch (symRef.getKind()) { 408 default: 409 return; 410 case MCSymbolRefExpr::VK_GOTTPOFF: 411 case MCSymbolRefExpr::VK_INDNTPOFF: 412 case MCSymbolRefExpr::VK_NTPOFF: 413 case MCSymbolRefExpr::VK_GOTNTPOFF: 414 case MCSymbolRefExpr::VK_TLSCALL: 415 case MCSymbolRefExpr::VK_TLSDESC: 416 case MCSymbolRefExpr::VK_TLSGD: 417 case MCSymbolRefExpr::VK_TLSLD: 418 case MCSymbolRefExpr::VK_TLSLDM: 419 case MCSymbolRefExpr::VK_TPOFF: 420 case MCSymbolRefExpr::VK_TPREL: 421 case MCSymbolRefExpr::VK_DTPOFF: 422 case MCSymbolRefExpr::VK_DTPREL: 423 case MCSymbolRefExpr::VK_PPC_DTPMOD: 424 case MCSymbolRefExpr::VK_PPC_TPREL_LO: 425 case MCSymbolRefExpr::VK_PPC_TPREL_HI: 426 case MCSymbolRefExpr::VK_PPC_TPREL_HA: 427 case MCSymbolRefExpr::VK_PPC_TPREL_HIGH: 428 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHA: 429 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHER: 430 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHERA: 431 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHEST: 432 case MCSymbolRefExpr::VK_PPC_TPREL_HIGHESTA: 433 case MCSymbolRefExpr::VK_PPC_DTPREL_LO: 434 case MCSymbolRefExpr::VK_PPC_DTPREL_HI: 435 case MCSymbolRefExpr::VK_PPC_DTPREL_HA: 436 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGH: 437 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHA: 438 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHER: 439 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHERA: 440 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHEST: 441 case MCSymbolRefExpr::VK_PPC_DTPREL_HIGHESTA: 442 case MCSymbolRefExpr::VK_PPC_GOT_TPREL: 443 case MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO: 444 case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HI: 445 case MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA: 446 case MCSymbolRefExpr::VK_PPC_GOT_TPREL_PCREL: 447 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL: 448 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_LO: 449 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HI: 450 case MCSymbolRefExpr::VK_PPC_GOT_DTPREL_HA: 451 case MCSymbolRefExpr::VK_PPC_TLS: 452 case MCSymbolRefExpr::VK_PPC_TLS_PCREL: 453 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD: 454 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO: 455 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HI: 456 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA: 457 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD_PCREL: 458 case MCSymbolRefExpr::VK_PPC_TLSGD: 459 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD: 460 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO: 461 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HI: 462 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA: 463 case MCSymbolRefExpr::VK_PPC_TLSLD: 464 break; 465 } 466 getAssembler().registerSymbol(symRef.getSymbol()); 467 cast<MCSymbolELF>(symRef.getSymbol()).setType(ELF::STT_TLS); 468 break; 469 } 470 471 case MCExpr::Unary: 472 fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr()); 473 break; 474 } 475 } 476 477 void MCELFStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE) { 478 const MCSymbol *S = &SRE->getSymbol(); 479 if (S->isTemporary()) { 480 if (!S->isInSection()) { 481 getContext().reportError( 482 SRE->getLoc(), Twine("Reference to undefined temporary symbol ") + 483 "`" + S->getName() + "`"); 484 return; 485 } 486 S = S->getSection().getBeginSymbol(); 487 S->setUsedInReloc(); 488 SRE = 489 MCSymbolRefExpr::create(S, SRE->getKind(), getContext(), SRE->getLoc()); 490 return; 491 } 492 // Not a temporary, referece it as a weak undefined. 493 bool Created; 494 getAssembler().registerSymbol(*S, &Created); 495 if (Created) 496 cast<MCSymbolELF>(S)->setBinding(ELF::STB_WEAK); 497 } 498 499 void MCELFStreamer::finalizeCGProfile() { 500 for (MCAssembler::CGProfileEntry &E : getAssembler().CGProfile) { 501 finalizeCGProfileEntry(E.From); 502 finalizeCGProfileEntry(E.To); 503 } 504 } 505 506 void MCELFStreamer::emitInstToFragment(const MCInst &Inst, 507 const MCSubtargetInfo &STI) { 508 this->MCObjectStreamer::emitInstToFragment(Inst, STI); 509 MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment()); 510 511 for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i) 512 fixSymbolsInTLSFixups(F.getFixups()[i].getValue()); 513 } 514 515 // A fragment can only have one Subtarget, and when bundling is enabled we 516 // sometimes need to use the same fragment. We give an error if there 517 // are conflicting Subtargets. 518 static void CheckBundleSubtargets(const MCSubtargetInfo *OldSTI, 519 const MCSubtargetInfo *NewSTI) { 520 if (OldSTI && NewSTI && OldSTI != NewSTI) 521 report_fatal_error("A Bundle can only have one Subtarget."); 522 } 523 524 void MCELFStreamer::emitInstToData(const MCInst &Inst, 525 const MCSubtargetInfo &STI) { 526 MCAssembler &Assembler = getAssembler(); 527 SmallVector<MCFixup, 4> Fixups; 528 SmallString<256> Code; 529 raw_svector_ostream VecOS(Code); 530 Assembler.getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI); 531 532 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) 533 fixSymbolsInTLSFixups(Fixups[i].getValue()); 534 535 // There are several possibilities here: 536 // 537 // If bundling is disabled, append the encoded instruction to the current data 538 // fragment (or create a new such fragment if the current fragment is not a 539 // data fragment, or the Subtarget has changed). 540 // 541 // If bundling is enabled: 542 // - If we're not in a bundle-locked group, emit the instruction into a 543 // fragment of its own. If there are no fixups registered for the 544 // instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a 545 // MCDataFragment. 546 // - If we're in a bundle-locked group, append the instruction to the current 547 // data fragment because we want all the instructions in a group to get into 548 // the same fragment. Be careful not to do that for the first instruction in 549 // the group, though. 550 MCDataFragment *DF; 551 552 if (Assembler.isBundlingEnabled()) { 553 MCSection &Sec = *getCurrentSectionOnly(); 554 if (Assembler.getRelaxAll() && isBundleLocked()) { 555 // If the -mc-relax-all flag is used and we are bundle-locked, we re-use 556 // the current bundle group. 557 DF = BundleGroups.back(); 558 CheckBundleSubtargets(DF->getSubtargetInfo(), &STI); 559 } 560 else if (Assembler.getRelaxAll() && !isBundleLocked()) 561 // When not in a bundle-locked group and the -mc-relax-all flag is used, 562 // we create a new temporary fragment which will be later merged into 563 // the current fragment. 564 DF = new MCDataFragment(); 565 else if (isBundleLocked() && !Sec.isBundleGroupBeforeFirstInst()) { 566 // If we are bundle-locked, we re-use the current fragment. 567 // The bundle-locking directive ensures this is a new data fragment. 568 DF = cast<MCDataFragment>(getCurrentFragment()); 569 CheckBundleSubtargets(DF->getSubtargetInfo(), &STI); 570 } 571 else if (!isBundleLocked() && Fixups.size() == 0) { 572 // Optimize memory usage by emitting the instruction to a 573 // MCCompactEncodedInstFragment when not in a bundle-locked group and 574 // there are no fixups registered. 575 MCCompactEncodedInstFragment *CEIF = new MCCompactEncodedInstFragment(); 576 insert(CEIF); 577 CEIF->getContents().append(Code.begin(), Code.end()); 578 CEIF->setHasInstructions(STI); 579 return; 580 } else { 581 DF = new MCDataFragment(); 582 insert(DF); 583 } 584 if (Sec.getBundleLockState() == MCSection::BundleLockedAlignToEnd) { 585 // If this fragment is for a group marked "align_to_end", set a flag 586 // in the fragment. This can happen after the fragment has already been 587 // created if there are nested bundle_align groups and an inner one 588 // is the one marked align_to_end. 589 DF->setAlignToBundleEnd(true); 590 } 591 592 // We're now emitting an instruction in a bundle group, so this flag has 593 // to be turned off. 594 Sec.setBundleGroupBeforeFirstInst(false); 595 } else { 596 DF = getOrCreateDataFragment(&STI); 597 } 598 599 // Add the fixups and data. 600 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) { 601 Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size()); 602 DF->getFixups().push_back(Fixups[i]); 603 } 604 DF->setHasInstructions(STI); 605 DF->getContents().append(Code.begin(), Code.end()); 606 607 if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) { 608 if (!isBundleLocked()) { 609 mergeFragment(getOrCreateDataFragment(&STI), DF); 610 delete DF; 611 } 612 } 613 } 614 615 void MCELFStreamer::emitBundleAlignMode(unsigned AlignPow2) { 616 assert(AlignPow2 <= 30 && "Invalid bundle alignment"); 617 MCAssembler &Assembler = getAssembler(); 618 if (AlignPow2 > 0 && (Assembler.getBundleAlignSize() == 0 || 619 Assembler.getBundleAlignSize() == 1U << AlignPow2)) 620 Assembler.setBundleAlignSize(1U << AlignPow2); 621 else 622 report_fatal_error(".bundle_align_mode cannot be changed once set"); 623 } 624 625 void MCELFStreamer::emitBundleLock(bool AlignToEnd) { 626 MCSection &Sec = *getCurrentSectionOnly(); 627 628 // Sanity checks 629 // 630 if (!getAssembler().isBundlingEnabled()) 631 report_fatal_error(".bundle_lock forbidden when bundling is disabled"); 632 633 if (!isBundleLocked()) 634 Sec.setBundleGroupBeforeFirstInst(true); 635 636 if (getAssembler().getRelaxAll() && !isBundleLocked()) { 637 // TODO: drop the lock state and set directly in the fragment 638 MCDataFragment *DF = new MCDataFragment(); 639 BundleGroups.push_back(DF); 640 } 641 642 Sec.setBundleLockState(AlignToEnd ? MCSection::BundleLockedAlignToEnd 643 : MCSection::BundleLocked); 644 } 645 646 void MCELFStreamer::emitBundleUnlock() { 647 MCSection &Sec = *getCurrentSectionOnly(); 648 649 // Sanity checks 650 if (!getAssembler().isBundlingEnabled()) 651 report_fatal_error(".bundle_unlock forbidden when bundling is disabled"); 652 else if (!isBundleLocked()) 653 report_fatal_error(".bundle_unlock without matching lock"); 654 else if (Sec.isBundleGroupBeforeFirstInst()) 655 report_fatal_error("Empty bundle-locked group is forbidden"); 656 657 // When the -mc-relax-all flag is used, we emit instructions to fragments 658 // stored on a stack. When the bundle unlock is emitted, we pop a fragment 659 // from the stack a merge it to the one below. 660 if (getAssembler().getRelaxAll()) { 661 assert(!BundleGroups.empty() && "There are no bundle groups"); 662 MCDataFragment *DF = BundleGroups.back(); 663 664 // FIXME: Use BundleGroups to track the lock state instead. 665 Sec.setBundleLockState(MCSection::NotBundleLocked); 666 667 // FIXME: Use more separate fragments for nested groups. 668 if (!isBundleLocked()) { 669 mergeFragment(getOrCreateDataFragment(DF->getSubtargetInfo()), DF); 670 BundleGroups.pop_back(); 671 delete DF; 672 } 673 674 if (Sec.getBundleLockState() != MCSection::BundleLockedAlignToEnd) 675 getOrCreateDataFragment()->setAlignToBundleEnd(false); 676 } else 677 Sec.setBundleLockState(MCSection::NotBundleLocked); 678 } 679 680 void MCELFStreamer::finishImpl() { 681 // Ensure the last section gets aligned if necessary. 682 MCSection *CurSection = getCurrentSectionOnly(); 683 setSectionAlignmentForBundling(getAssembler(), CurSection); 684 685 finalizeCGProfile(); 686 emitFrames(nullptr); 687 688 this->MCObjectStreamer::finishImpl(); 689 } 690 691 void MCELFStreamer::emitThumbFunc(MCSymbol *Func) { 692 llvm_unreachable("Generic ELF doesn't support this directive"); 693 } 694 695 void MCELFStreamer::emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) { 696 llvm_unreachable("ELF doesn't support this directive"); 697 } 698 699 void MCELFStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol, 700 uint64_t Size, unsigned ByteAlignment, 701 SMLoc Loc) { 702 llvm_unreachable("ELF doesn't support this directive"); 703 } 704 705 void MCELFStreamer::emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, 706 uint64_t Size, unsigned ByteAlignment) { 707 llvm_unreachable("ELF doesn't support this directive"); 708 } 709 710 MCStreamer *llvm::createELFStreamer(MCContext &Context, 711 std::unique_ptr<MCAsmBackend> &&MAB, 712 std::unique_ptr<MCObjectWriter> &&OW, 713 std::unique_ptr<MCCodeEmitter> &&CE, 714 bool RelaxAll) { 715 MCELFStreamer *S = 716 new MCELFStreamer(Context, std::move(MAB), std::move(OW), std::move(CE)); 717 if (RelaxAll) 718 S->getAssembler().setRelaxAll(true); 719 return S; 720 } 721