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/MC/MCAssembler.h" 17 #include "llvm/MC/MCCodeEmitter.h" 18 #include "llvm/MC/MCContext.h" 19 #include "llvm/MC/MCELF.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 33 using namespace llvm; 34 35 36 inline void MCELFStreamer::SetSection(StringRef Section, unsigned Type, 37 unsigned Flags, SectionKind Kind) { 38 SwitchSection(getContext().getELFSection(Section, Type, Flags, Kind)); 39 } 40 41 inline void MCELFStreamer::SetSectionData() { 42 SetSection(".data", 43 ELF::SHT_PROGBITS, 44 ELF::SHF_WRITE | ELF::SHF_ALLOC, 45 SectionKind::getDataRel()); 46 EmitCodeAlignment(4, 0); 47 } 48 49 inline void MCELFStreamer::SetSectionText() { 50 SetSection(".text", 51 ELF::SHT_PROGBITS, 52 ELF::SHF_EXECINSTR | ELF::SHF_ALLOC, 53 SectionKind::getText()); 54 EmitCodeAlignment(4, 0); 55 } 56 57 inline void MCELFStreamer::SetSectionBss() { 58 SetSection(".bss", 59 ELF::SHT_NOBITS, 60 ELF::SHF_WRITE | ELF::SHF_ALLOC, 61 SectionKind::getBSS()); 62 EmitCodeAlignment(4, 0); 63 } 64 65 MCELFStreamer::~MCELFStreamer() { 66 } 67 68 void MCELFStreamer::InitToTextSection() { 69 SetSectionText(); 70 } 71 72 void MCELFStreamer::InitSections() { 73 // This emulates the same behavior of GNU as. This makes it easier 74 // to compare the output as the major sections are in the same order. 75 SetSectionText(); 76 SetSectionData(); 77 SetSectionBss(); 78 SetSectionText(); 79 } 80 81 void MCELFStreamer::EmitLabel(MCSymbol *Symbol) { 82 assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); 83 84 MCObjectStreamer::EmitLabel(Symbol); 85 86 const MCSectionELF &Section = 87 static_cast<const MCSectionELF&>(Symbol->getSection()); 88 MCSymbolData &SD = getAssembler().getSymbolData(*Symbol); 89 if (Section.getFlags() & ELF::SHF_TLS) 90 MCELF::SetType(SD, ELF::STT_TLS); 91 } 92 93 void MCELFStreamer::EmitDebugLabel(MCSymbol *Symbol) { 94 EmitLabel(Symbol); 95 } 96 97 void MCELFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) { 98 switch (Flag) { 99 case MCAF_SyntaxUnified: return; // no-op here. 100 case MCAF_Code16: return; // Change parsing mode; no-op here. 101 case MCAF_Code32: return; // Change parsing mode; no-op here. 102 case MCAF_Code64: return; // Change parsing mode; no-op here. 103 case MCAF_SubsectionsViaSymbols: 104 getAssembler().setSubsectionsViaSymbols(true); 105 return; 106 } 107 108 llvm_unreachable("invalid assembler flag!"); 109 } 110 111 void MCELFStreamer::ChangeSection(const MCSection *Section) { 112 MCSectionData *CurSection = getCurrentSectionData(); 113 if (CurSection && CurSection->isBundleLocked()) 114 report_fatal_error("Unterminated .bundle_lock when changing a section"); 115 const MCSymbol *Grp = static_cast<const MCSectionELF *>(Section)->getGroup(); 116 if (Grp) 117 getAssembler().getOrCreateSymbolData(*Grp); 118 this->MCObjectStreamer::ChangeSection(Section); 119 } 120 121 void MCELFStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) { 122 getAssembler().getOrCreateSymbolData(*Symbol); 123 MCSymbolData &AliasSD = getAssembler().getOrCreateSymbolData(*Alias); 124 AliasSD.setFlags(AliasSD.getFlags() | ELF_Other_Weakref); 125 const MCExpr *Value = MCSymbolRefExpr::Create(Symbol, getContext()); 126 Alias->setVariableValue(Value); 127 } 128 129 void MCELFStreamer::EmitSymbolAttribute(MCSymbol *Symbol, 130 MCSymbolAttr Attribute) { 131 // Indirect symbols are handled differently, to match how 'as' handles 132 // them. This makes writing matching .o files easier. 133 if (Attribute == MCSA_IndirectSymbol) { 134 // Note that we intentionally cannot use the symbol data here; this is 135 // important for matching the string table that 'as' generates. 136 IndirectSymbolData ISD; 137 ISD.Symbol = Symbol; 138 ISD.SectionData = getCurrentSectionData(); 139 getAssembler().getIndirectSymbols().push_back(ISD); 140 return; 141 } 142 143 // Adding a symbol attribute always introduces the symbol, note that an 144 // important side effect of calling getOrCreateSymbolData here is to register 145 // the symbol with the assembler. 146 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 147 148 // The implementation of symbol attributes is designed to match 'as', but it 149 // leaves much to desired. It doesn't really make sense to arbitrarily add and 150 // remove flags, but 'as' allows this (in particular, see .desc). 151 // 152 // In the future it might be worth trying to make these operations more well 153 // defined. 154 switch (Attribute) { 155 case MCSA_LazyReference: 156 case MCSA_Reference: 157 case MCSA_SymbolResolver: 158 case MCSA_PrivateExtern: 159 case MCSA_WeakDefinition: 160 case MCSA_WeakDefAutoPrivate: 161 case MCSA_Invalid: 162 case MCSA_IndirectSymbol: 163 llvm_unreachable("Invalid symbol attribute for ELF!"); 164 165 case MCSA_NoDeadStrip: 166 case MCSA_ELF_TypeGnuUniqueObject: 167 // Ignore for now. 168 break; 169 170 case MCSA_Global: 171 MCELF::SetBinding(SD, ELF::STB_GLOBAL); 172 SD.setExternal(true); 173 BindingExplicitlySet.insert(Symbol); 174 break; 175 176 case MCSA_WeakReference: 177 case MCSA_Weak: 178 MCELF::SetBinding(SD, ELF::STB_WEAK); 179 SD.setExternal(true); 180 BindingExplicitlySet.insert(Symbol); 181 break; 182 183 case MCSA_Local: 184 MCELF::SetBinding(SD, ELF::STB_LOCAL); 185 SD.setExternal(false); 186 BindingExplicitlySet.insert(Symbol); 187 break; 188 189 case MCSA_ELF_TypeFunction: 190 MCELF::SetType(SD, ELF::STT_FUNC); 191 break; 192 193 case MCSA_ELF_TypeIndFunction: 194 MCELF::SetType(SD, ELF::STT_GNU_IFUNC); 195 break; 196 197 case MCSA_ELF_TypeObject: 198 MCELF::SetType(SD, ELF::STT_OBJECT); 199 break; 200 201 case MCSA_ELF_TypeTLS: 202 MCELF::SetType(SD, ELF::STT_TLS); 203 break; 204 205 case MCSA_ELF_TypeCommon: 206 MCELF::SetType(SD, ELF::STT_COMMON); 207 break; 208 209 case MCSA_ELF_TypeNoType: 210 MCELF::SetType(SD, ELF::STT_NOTYPE); 211 break; 212 213 case MCSA_Protected: 214 MCELF::SetVisibility(SD, ELF::STV_PROTECTED); 215 break; 216 217 case MCSA_Hidden: 218 MCELF::SetVisibility(SD, ELF::STV_HIDDEN); 219 break; 220 221 case MCSA_Internal: 222 MCELF::SetVisibility(SD, ELF::STV_INTERNAL); 223 break; 224 } 225 } 226 227 void MCELFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, 228 unsigned ByteAlignment) { 229 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 230 231 if (!BindingExplicitlySet.count(Symbol)) { 232 MCELF::SetBinding(SD, ELF::STB_GLOBAL); 233 SD.setExternal(true); 234 } 235 236 MCELF::SetType(SD, ELF::STT_OBJECT); 237 238 if (MCELF::GetBinding(SD) == ELF_STB_Local) { 239 const MCSection *Section = getAssembler().getContext().getELFSection(".bss", 240 ELF::SHT_NOBITS, 241 ELF::SHF_WRITE | 242 ELF::SHF_ALLOC, 243 SectionKind::getBSS()); 244 Symbol->setSection(*Section); 245 246 struct LocalCommon L = {&SD, Size, ByteAlignment}; 247 LocalCommons.push_back(L); 248 } else { 249 SD.setCommon(Size, ByteAlignment); 250 } 251 252 SD.setSize(MCConstantExpr::Create(Size, getContext())); 253 } 254 255 void MCELFStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) { 256 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 257 SD.setSize(Value); 258 } 259 260 void MCELFStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, 261 unsigned ByteAlignment) { 262 // FIXME: Should this be caught and done earlier? 263 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 264 MCELF::SetBinding(SD, ELF::STB_LOCAL); 265 SD.setExternal(false); 266 BindingExplicitlySet.insert(Symbol); 267 EmitCommonSymbol(Symbol, Size, ByteAlignment); 268 } 269 270 void MCELFStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, 271 unsigned AddrSpace) { 272 if (getCurrentSectionData()->isBundleLocked()) 273 report_fatal_error("Emitting values inside a locked bundle is forbidden"); 274 fixSymbolsInTLSFixups(Value); 275 MCObjectStreamer::EmitValueImpl(Value, Size, AddrSpace); 276 } 277 278 void MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment, 279 int64_t Value, 280 unsigned ValueSize, 281 unsigned MaxBytesToEmit) { 282 if (getCurrentSectionData()->isBundleLocked()) 283 report_fatal_error("Emitting values inside a locked bundle is forbidden"); 284 MCObjectStreamer::EmitValueToAlignment(ByteAlignment, Value, 285 ValueSize, MaxBytesToEmit); 286 } 287 288 289 // Add a symbol for the file name of this module. This is the second 290 // entry in the module's symbol table (the first being the null symbol). 291 void MCELFStreamer::EmitFileDirective(StringRef Filename) { 292 MCSymbol *Symbol = getAssembler().getContext().GetOrCreateSymbol(Filename); 293 Symbol->setSection(*getCurrentSection()); 294 Symbol->setAbsolute(); 295 296 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol); 297 298 SD.setFlags(ELF_STT_File | ELF_STB_Local | ELF_STV_Default); 299 } 300 301 void MCELFStreamer::fixSymbolsInTLSFixups(const MCExpr *expr) { 302 switch (expr->getKind()) { 303 case MCExpr::Target: 304 cast<MCTargetExpr>(expr)->fixELFSymbolsInTLSFixups(getAssembler()); 305 break; 306 case MCExpr::Constant: 307 break; 308 309 case MCExpr::Binary: { 310 const MCBinaryExpr *be = cast<MCBinaryExpr>(expr); 311 fixSymbolsInTLSFixups(be->getLHS()); 312 fixSymbolsInTLSFixups(be->getRHS()); 313 break; 314 } 315 316 case MCExpr::SymbolRef: { 317 const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr); 318 switch (symRef.getKind()) { 319 default: 320 return; 321 case MCSymbolRefExpr::VK_GOTTPOFF: 322 case MCSymbolRefExpr::VK_INDNTPOFF: 323 case MCSymbolRefExpr::VK_NTPOFF: 324 case MCSymbolRefExpr::VK_GOTNTPOFF: 325 case MCSymbolRefExpr::VK_TLSGD: 326 case MCSymbolRefExpr::VK_TLSLD: 327 case MCSymbolRefExpr::VK_TLSLDM: 328 case MCSymbolRefExpr::VK_TPOFF: 329 case MCSymbolRefExpr::VK_DTPOFF: 330 case MCSymbolRefExpr::VK_ARM_TLSGD: 331 case MCSymbolRefExpr::VK_ARM_TPOFF: 332 case MCSymbolRefExpr::VK_ARM_GOTTPOFF: 333 case MCSymbolRefExpr::VK_Mips_TLSGD: 334 case MCSymbolRefExpr::VK_Mips_GOTTPREL: 335 case MCSymbolRefExpr::VK_Mips_TPREL_HI: 336 case MCSymbolRefExpr::VK_Mips_TPREL_LO: 337 case MCSymbolRefExpr::VK_PPC_TPREL16_HA: 338 case MCSymbolRefExpr::VK_PPC_TPREL16_LO: 339 case MCSymbolRefExpr::VK_PPC_DTPREL16_HA: 340 case MCSymbolRefExpr::VK_PPC_DTPREL16_LO: 341 case MCSymbolRefExpr::VK_PPC_GOT_TPREL16_HA: 342 case MCSymbolRefExpr::VK_PPC_GOT_TPREL16_LO: 343 case MCSymbolRefExpr::VK_PPC_TLS: 344 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD16_HA: 345 case MCSymbolRefExpr::VK_PPC_GOT_TLSGD16_LO: 346 case MCSymbolRefExpr::VK_PPC_TLSGD: 347 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD16_HA: 348 case MCSymbolRefExpr::VK_PPC_GOT_TLSLD16_LO: 349 case MCSymbolRefExpr::VK_PPC_TLSLD: 350 break; 351 } 352 MCSymbolData &SD = getAssembler().getOrCreateSymbolData(symRef.getSymbol()); 353 MCELF::SetType(SD, ELF::STT_TLS); 354 break; 355 } 356 357 case MCExpr::Unary: 358 fixSymbolsInTLSFixups(cast<MCUnaryExpr>(expr)->getSubExpr()); 359 break; 360 } 361 } 362 363 void MCELFStreamer::EmitInstToFragment(const MCInst &Inst) { 364 this->MCObjectStreamer::EmitInstToFragment(Inst); 365 MCRelaxableFragment &F = *cast<MCRelaxableFragment>(getCurrentFragment()); 366 367 for (unsigned i = 0, e = F.getFixups().size(); i != e; ++i) 368 fixSymbolsInTLSFixups(F.getFixups()[i].getValue()); 369 } 370 371 void MCELFStreamer::EmitInstToData(const MCInst &Inst) { 372 MCAssembler &Assembler = getAssembler(); 373 SmallVector<MCFixup, 4> Fixups; 374 SmallString<256> Code; 375 raw_svector_ostream VecOS(Code); 376 Assembler.getEmitter().EncodeInstruction(Inst, VecOS, Fixups); 377 VecOS.flush(); 378 379 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) 380 fixSymbolsInTLSFixups(Fixups[i].getValue()); 381 382 // There are several possibilities here: 383 // 384 // If bundling is disabled, append the encoded instruction to the current data 385 // fragment (or create a new such fragment if the current fragment is not a 386 // data fragment). 387 // 388 // If bundling is enabled: 389 // - If we're not in a bundle-locked group, emit the instruction into a 390 // fragment of its own. If there are no fixups registered for the 391 // instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a 392 // MCDataFragment. 393 // - If we're in a bundle-locked group, append the instruction to the current 394 // data fragment because we want all the instructions in a group to get into 395 // the same fragment. Be careful not to do that for the first instruction in 396 // the group, though. 397 MCDataFragment *DF; 398 399 if (Assembler.isBundlingEnabled()) { 400 MCSectionData *SD = getCurrentSectionData(); 401 if (SD->isBundleLocked() && !SD->isBundleGroupBeforeFirstInst()) 402 // If we are bundle-locked, we re-use the current fragment. 403 // The bundle-locking directive ensures this is a new data fragment. 404 DF = cast<MCDataFragment>(getCurrentFragment()); 405 else if (!SD->isBundleLocked() && Fixups.size() == 0) { 406 // Optimize memory usage by emitting the instruction to a 407 // MCCompactEncodedInstFragment when not in a bundle-locked group and 408 // there are no fixups registered. 409 MCCompactEncodedInstFragment *CEIF = new MCCompactEncodedInstFragment(SD); 410 CEIF->getContents().append(Code.begin(), Code.end()); 411 return; 412 } else { 413 DF = new MCDataFragment(SD); 414 if (SD->getBundleLockState() == MCSectionData::BundleLockedAlignToEnd) { 415 // If this is a new fragment created for a bundle-locked group, and the 416 // group was marked as "align_to_end", set a flag in the fragment. 417 DF->setAlignToBundleEnd(true); 418 } 419 } 420 421 // We're now emitting an instruction in a bundle group, so this flag has 422 // to be turned off. 423 SD->setBundleGroupBeforeFirstInst(false); 424 } else { 425 DF = getOrCreateDataFragment(); 426 } 427 428 // Add the fixups and data. 429 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) { 430 Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size()); 431 DF->getFixups().push_back(Fixups[i]); 432 } 433 DF->setHasInstructions(true); 434 DF->getContents().append(Code.begin(), Code.end()); 435 } 436 437 void MCELFStreamer::EmitBundleAlignMode(unsigned AlignPow2) { 438 assert(AlignPow2 <= 30 && "Invalid bundle alignment"); 439 MCAssembler &Assembler = getAssembler(); 440 if (Assembler.getBundleAlignSize() == 0 && AlignPow2 > 0) 441 Assembler.setBundleAlignSize(1 << AlignPow2); 442 else 443 report_fatal_error(".bundle_align_mode should be only set once per file"); 444 } 445 446 void MCELFStreamer::EmitBundleLock(bool AlignToEnd) { 447 MCSectionData *SD = getCurrentSectionData(); 448 449 // Sanity checks 450 // 451 if (!getAssembler().isBundlingEnabled()) 452 report_fatal_error(".bundle_lock forbidden when bundling is disabled"); 453 else if (SD->isBundleLocked()) 454 report_fatal_error("Nesting of .bundle_lock is forbidden"); 455 456 SD->setBundleLockState(AlignToEnd ? MCSectionData::BundleLockedAlignToEnd : 457 MCSectionData::BundleLocked); 458 SD->setBundleGroupBeforeFirstInst(true); 459 } 460 461 void MCELFStreamer::EmitBundleUnlock() { 462 MCSectionData *SD = getCurrentSectionData(); 463 464 // Sanity checks 465 if (!getAssembler().isBundlingEnabled()) 466 report_fatal_error(".bundle_unlock forbidden when bundling is disabled"); 467 else if (!SD->isBundleLocked()) 468 report_fatal_error(".bundle_unlock without matching lock"); 469 else if (SD->isBundleGroupBeforeFirstInst()) 470 report_fatal_error("Empty bundle-locked group is forbidden"); 471 472 SD->setBundleLockState(MCSectionData::NotBundleLocked); 473 } 474 475 void MCELFStreamer::FinishImpl() { 476 EmitFrames(true); 477 478 for (std::vector<LocalCommon>::const_iterator i = LocalCommons.begin(), 479 e = LocalCommons.end(); 480 i != e; ++i) { 481 MCSymbolData *SD = i->SD; 482 uint64_t Size = i->Size; 483 unsigned ByteAlignment = i->ByteAlignment; 484 const MCSymbol &Symbol = SD->getSymbol(); 485 const MCSection &Section = Symbol.getSection(); 486 487 MCSectionData &SectData = getAssembler().getOrCreateSectionData(Section); 488 new MCAlignFragment(ByteAlignment, 0, 1, ByteAlignment, &SectData); 489 490 MCFragment *F = new MCFillFragment(0, 0, Size, &SectData); 491 SD->setFragment(F); 492 493 // Update the maximum alignment of the section if necessary. 494 if (ByteAlignment > SectData.getAlignment()) 495 SectData.setAlignment(ByteAlignment); 496 } 497 498 this->MCObjectStreamer::FinishImpl(); 499 } 500 void MCELFStreamer::EmitTCEntry(const MCSymbol &S) { 501 // Creates a R_PPC64_TOC relocation 502 MCObjectStreamer::EmitSymbolValue(&S, 8); 503 } 504 505 MCStreamer *llvm::createELFStreamer(MCContext &Context, MCAsmBackend &MAB, 506 raw_ostream &OS, MCCodeEmitter *CE, 507 bool RelaxAll, bool NoExecStack) { 508 MCELFStreamer *S = new MCELFStreamer(Context, MAB, OS, CE); 509 if (RelaxAll) 510 S->getAssembler().setRelaxAll(true); 511 if (NoExecStack) 512 S->getAssembler().setNoExecStack(true); 513 return S; 514 } 515 516 void MCELFStreamer::EmitThumbFunc(MCSymbol *Func) { 517 llvm_unreachable("Generic ELF doesn't support this directive"); 518 } 519 520 MCSymbolData &MCELFStreamer::getOrCreateSymbolData(MCSymbol *Symbol) { 521 return getAssembler().getOrCreateSymbolData(*Symbol); 522 } 523 524 void MCELFStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) { 525 llvm_unreachable("ELF doesn't support this directive"); 526 } 527 528 void MCELFStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) { 529 llvm_unreachable("ELF doesn't support this directive"); 530 } 531 532 void MCELFStreamer::EmitCOFFSymbolStorageClass(int StorageClass) { 533 llvm_unreachable("ELF doesn't support this directive"); 534 } 535 536 void MCELFStreamer::EmitCOFFSymbolType(int Type) { 537 llvm_unreachable("ELF doesn't support this directive"); 538 } 539 540 void MCELFStreamer::EndCOFFSymbolDef() { 541 llvm_unreachable("ELF doesn't support this directive"); 542 } 543 544 void MCELFStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol, 545 uint64_t Size, unsigned ByteAlignment) { 546 llvm_unreachable("ELF doesn't support this directive"); 547 } 548 549 void MCELFStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol, 550 uint64_t Size, unsigned ByteAlignment) { 551 llvm_unreachable("ELF doesn't support this directive"); 552 } 553