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