1//===- lib/MC/MCContext.cpp - Machine Code Context ------------------------===// 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#include "llvm/MC/MCContext.h" 10#include "llvm/ADT/Optional.h" 11#include "llvm/ADT/SmallString.h" 12#include "llvm/ADT/SmallVector.h" 13#include "llvm/ADT/StringMap.h" 14#include "llvm/ADT/StringRef.h" 15#include "llvm/ADT/Twine.h" 16#include "llvm/BinaryFormat/COFF.h" 17#include "llvm/BinaryFormat/ELF.h" 18#include "llvm/BinaryFormat/XCOFF.h" 19#include "llvm/MC/MCAsmInfo.h" 20#include "llvm/MC/MCCodeView.h" 21#include "llvm/MC/MCDwarf.h" 22#include "llvm/MC/MCExpr.h" 23#include "llvm/MC/MCFragment.h" 24#include "llvm/MC/MCLabel.h" 25#include "llvm/MC/MCObjectFileInfo.h" 26#include "llvm/MC/MCSectionCOFF.h" 27#include "llvm/MC/MCSectionELF.h" 28#include "llvm/MC/MCSectionMachO.h" 29#include "llvm/MC/MCSectionWasm.h" 30#include "llvm/MC/MCSectionXCOFF.h" 31#include "llvm/MC/MCStreamer.h" 32#include "llvm/MC/MCSymbol.h" 33#include "llvm/MC/MCSymbolCOFF.h" 34#include "llvm/MC/MCSymbolELF.h" 35#include "llvm/MC/MCSymbolMachO.h" 36#include "llvm/MC/MCSymbolWasm.h" 37#include "llvm/MC/MCSymbolXCOFF.h" 38#include "llvm/MC/SectionKind.h" 39#include "llvm/Support/Casting.h" 40#include "llvm/Support/CommandLine.h" 41#include "llvm/Support/ErrorHandling.h" 42#include "llvm/Support/MemoryBuffer.h" 43#include "llvm/Support/Path.h" 44#include "llvm/Support/Signals.h" 45#include "llvm/Support/SourceMgr.h" 46#include "llvm/Support/raw_ostream.h" 47#include <cassert> 48#include <cstdlib> 49#include <tuple> 50#include <utility> 51 52using namespace llvm; 53 54static cl::opt<char*> 55AsSecureLogFileName("as-secure-log-file-name", 56 cl::desc("As secure log file name (initialized from " 57 "AS_SECURE_LOG_FILE env variable)"), 58 cl::init(getenv("AS_SECURE_LOG_FILE")), cl::Hidden); 59 60static void defaultDiagHandler(const SMDiagnostic &SMD, bool, const SourceMgr &, 61 std::vector<const MDNode *> &) { 62 SMD.print(nullptr, errs()); 63} 64 65MCContext::MCContext(const Triple &TheTriple, const MCAsmInfo *mai, 66 const MCRegisterInfo *mri, const MCSubtargetInfo *msti, 67 const SourceMgr *mgr, MCTargetOptions const *TargetOpts, 68 bool DoAutoReset) 69 : TT(TheTriple), SrcMgr(mgr), InlineSrcMgr(nullptr), 70 DiagHandler(defaultDiagHandler), MAI(mai), MRI(mri), MSTI(msti), 71 Symbols(Allocator), UsedNames(Allocator), 72 InlineAsmUsedLabelNames(Allocator), 73 CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0), 74 AutoReset(DoAutoReset), TargetOptions(TargetOpts) { 75 SecureLogFile = AsSecureLogFileName; 76 77 if (SrcMgr && SrcMgr->getNumBuffers()) 78 MainFileName = std::string(SrcMgr->getMemoryBuffer(SrcMgr->getMainFileID()) 79 ->getBufferIdentifier()); 80 81 switch (TheTriple.getObjectFormat()) { 82 case Triple::MachO: 83 Env = IsMachO; 84 break; 85 case Triple::COFF: 86 if (!TheTriple.isOSWindows()) 87 report_fatal_error( 88 "Cannot initialize MC for non-Windows COFF object files."); 89 90 Env = IsCOFF; 91 break; 92 case Triple::ELF: 93 Env = IsELF; 94 break; 95 case Triple::Wasm: 96 Env = IsWasm; 97 break; 98 case Triple::XCOFF: 99 Env = IsXCOFF; 100 break; 101 case Triple::GOFF: 102 report_fatal_error("Cannot initialize MC for GOFF object file format"); 103 break; 104 case Triple::UnknownObjectFormat: 105 report_fatal_error("Cannot initialize MC for unknown object file format."); 106 break; 107 } 108} 109 110MCContext::~MCContext() { 111 if (AutoReset) 112 reset(); 113 114 // NOTE: The symbols are all allocated out of a bump pointer allocator, 115 // we don't need to free them here. 116} 117 118void MCContext::initInlineSourceManager() { 119 if (!InlineSrcMgr) 120 InlineSrcMgr.reset(new SourceMgr()); 121} 122 123//===----------------------------------------------------------------------===// 124// Module Lifetime Management 125//===----------------------------------------------------------------------===// 126 127void MCContext::reset() { 128 SrcMgr = nullptr; 129 InlineSrcMgr.reset(); 130 LocInfos.clear(); 131 DiagHandler = defaultDiagHandler; 132 133 // Call the destructors so the fragments are freed 134 COFFAllocator.DestroyAll(); 135 ELFAllocator.DestroyAll(); 136 MachOAllocator.DestroyAll(); 137 XCOFFAllocator.DestroyAll(); 138 MCInstAllocator.DestroyAll(); 139 140 MCSubtargetAllocator.DestroyAll(); 141 InlineAsmUsedLabelNames.clear(); 142 UsedNames.clear(); 143 Symbols.clear(); 144 Allocator.Reset(); 145 Instances.clear(); 146 CompilationDir.clear(); 147 MainFileName.clear(); 148 MCDwarfLineTablesCUMap.clear(); 149 SectionsForRanges.clear(); 150 MCGenDwarfLabelEntries.clear(); 151 DwarfDebugFlags = StringRef(); 152 DwarfCompileUnitID = 0; 153 CurrentDwarfLoc = MCDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0); 154 155 CVContext.reset(); 156 157 MachOUniquingMap.clear(); 158 ELFUniquingMap.clear(); 159 COFFUniquingMap.clear(); 160 WasmUniquingMap.clear(); 161 XCOFFUniquingMap.clear(); 162 163 ELFEntrySizeMap.clear(); 164 ELFSeenGenericMergeableSections.clear(); 165 166 NextID.clear(); 167 AllowTemporaryLabels = true; 168 DwarfLocSeen = false; 169 GenDwarfForAssembly = false; 170 GenDwarfFileNumber = 0; 171 172 HadError = false; 173} 174 175//===----------------------------------------------------------------------===// 176// MCInst Management 177//===----------------------------------------------------------------------===// 178 179MCInst *MCContext::createMCInst() { 180 return new (MCInstAllocator.Allocate()) MCInst; 181} 182 183//===----------------------------------------------------------------------===// 184// Symbol Manipulation 185//===----------------------------------------------------------------------===// 186 187MCSymbol *MCContext::getOrCreateSymbol(const Twine &Name) { 188 SmallString<128> NameSV; 189 StringRef NameRef = Name.toStringRef(NameSV); 190 191 assert(!NameRef.empty() && "Normal symbols cannot be unnamed!"); 192 193 MCSymbol *&Sym = Symbols[NameRef]; 194 if (!Sym) 195 Sym = createSymbol(NameRef, false, false); 196 197 return Sym; 198} 199 200MCSymbol *MCContext::getOrCreateFrameAllocSymbol(StringRef FuncName, 201 unsigned Idx) { 202 return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName + 203 "$frame_escape_" + Twine(Idx)); 204} 205 206MCSymbol *MCContext::getOrCreateParentFrameOffsetSymbol(StringRef FuncName) { 207 return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName + 208 "$parent_frame_offset"); 209} 210 211MCSymbol *MCContext::getOrCreateLSDASymbol(StringRef FuncName) { 212 return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + "__ehtable$" + 213 FuncName); 214} 215 216MCSymbol *MCContext::createSymbolImpl(const StringMapEntry<bool> *Name, 217 bool IsTemporary) { 218 static_assert(std::is_trivially_destructible<MCSymbolCOFF>(), 219 "MCSymbol classes must be trivially destructible"); 220 static_assert(std::is_trivially_destructible<MCSymbolELF>(), 221 "MCSymbol classes must be trivially destructible"); 222 static_assert(std::is_trivially_destructible<MCSymbolMachO>(), 223 "MCSymbol classes must be trivially destructible"); 224 static_assert(std::is_trivially_destructible<MCSymbolWasm>(), 225 "MCSymbol classes must be trivially destructible"); 226 static_assert(std::is_trivially_destructible<MCSymbolXCOFF>(), 227 "MCSymbol classes must be trivially destructible"); 228 229 switch (getObjectFileType()) { 230 case MCContext::IsCOFF: 231 return new (Name, *this) MCSymbolCOFF(Name, IsTemporary); 232 case MCContext::IsELF: 233 return new (Name, *this) MCSymbolELF(Name, IsTemporary); 234 case MCContext::IsMachO: 235 return new (Name, *this) MCSymbolMachO(Name, IsTemporary); 236 case MCContext::IsWasm: 237 return new (Name, *this) MCSymbolWasm(Name, IsTemporary); 238 case MCContext::IsXCOFF: 239 return createXCOFFSymbolImpl(Name, IsTemporary); 240 } 241 return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name, 242 IsTemporary); 243} 244 245MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix, 246 bool CanBeUnnamed) { 247 if (CanBeUnnamed && !UseNamesOnTempLabels) 248 return createSymbolImpl(nullptr, true); 249 250 // Determine whether this is a user written assembler temporary or normal 251 // label, if used. 252 bool IsTemporary = CanBeUnnamed; 253 if (AllowTemporaryLabels && !IsTemporary) 254 IsTemporary = Name.startswith(MAI->getPrivateGlobalPrefix()); 255 256 SmallString<128> NewName = Name; 257 bool AddSuffix = AlwaysAddSuffix; 258 unsigned &NextUniqueID = NextID[Name]; 259 while (true) { 260 if (AddSuffix) { 261 NewName.resize(Name.size()); 262 raw_svector_ostream(NewName) << NextUniqueID++; 263 } 264 auto NameEntry = UsedNames.insert(std::make_pair(NewName, true)); 265 if (NameEntry.second || !NameEntry.first->second) { 266 // Ok, we found a name. 267 // Mark it as used for a non-section symbol. 268 NameEntry.first->second = true; 269 // Have the MCSymbol object itself refer to the copy of the string that is 270 // embedded in the UsedNames entry. 271 return createSymbolImpl(&*NameEntry.first, IsTemporary); 272 } 273 assert(IsTemporary && "Cannot rename non-temporary symbols"); 274 AddSuffix = true; 275 } 276 llvm_unreachable("Infinite loop"); 277} 278 279MCSymbol *MCContext::createTempSymbol(const Twine &Name, bool AlwaysAddSuffix) { 280 SmallString<128> NameSV; 281 raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name; 282 return createSymbol(NameSV, AlwaysAddSuffix, true); 283} 284 285MCSymbol *MCContext::createNamedTempSymbol(const Twine &Name) { 286 SmallString<128> NameSV; 287 raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name; 288 return createSymbol(NameSV, true, false); 289} 290 291MCSymbol *MCContext::createLinkerPrivateTempSymbol() { 292 SmallString<128> NameSV; 293 raw_svector_ostream(NameSV) << MAI->getLinkerPrivateGlobalPrefix() << "tmp"; 294 return createSymbol(NameSV, true, false); 295} 296 297MCSymbol *MCContext::createTempSymbol() { return createTempSymbol("tmp"); } 298 299MCSymbol *MCContext::createNamedTempSymbol() { 300 return createNamedTempSymbol("tmp"); 301} 302 303unsigned MCContext::NextInstance(unsigned LocalLabelVal) { 304 MCLabel *&Label = Instances[LocalLabelVal]; 305 if (!Label) 306 Label = new (*this) MCLabel(0); 307 return Label->incInstance(); 308} 309 310unsigned MCContext::GetInstance(unsigned LocalLabelVal) { 311 MCLabel *&Label = Instances[LocalLabelVal]; 312 if (!Label) 313 Label = new (*this) MCLabel(0); 314 return Label->getInstance(); 315} 316 317MCSymbol *MCContext::getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal, 318 unsigned Instance) { 319 MCSymbol *&Sym = LocalSymbols[std::make_pair(LocalLabelVal, Instance)]; 320 if (!Sym) 321 Sym = createNamedTempSymbol(); 322 return Sym; 323} 324 325MCSymbol *MCContext::createDirectionalLocalSymbol(unsigned LocalLabelVal) { 326 unsigned Instance = NextInstance(LocalLabelVal); 327 return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance); 328} 329 330MCSymbol *MCContext::getDirectionalLocalSymbol(unsigned LocalLabelVal, 331 bool Before) { 332 unsigned Instance = GetInstance(LocalLabelVal); 333 if (!Before) 334 ++Instance; 335 return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance); 336} 337 338MCSymbol *MCContext::lookupSymbol(const Twine &Name) const { 339 SmallString<128> NameSV; 340 StringRef NameRef = Name.toStringRef(NameSV); 341 return Symbols.lookup(NameRef); 342} 343 344void MCContext::setSymbolValue(MCStreamer &Streamer, 345 StringRef Sym, 346 uint64_t Val) { 347 auto Symbol = getOrCreateSymbol(Sym); 348 Streamer.emitAssignment(Symbol, MCConstantExpr::create(Val, *this)); 349} 350 351void MCContext::registerInlineAsmLabel(MCSymbol *Sym) { 352 InlineAsmUsedLabelNames[Sym->getName()] = Sym; 353} 354 355MCSymbolXCOFF * 356MCContext::createXCOFFSymbolImpl(const StringMapEntry<bool> *Name, 357 bool IsTemporary) { 358 if (!Name) 359 return new (nullptr, *this) MCSymbolXCOFF(nullptr, IsTemporary); 360 361 StringRef OriginalName = Name->first(); 362 if (OriginalName.startswith("._Renamed..") || 363 OriginalName.startswith("_Renamed..")) 364 reportError(SMLoc(), "invalid symbol name from source"); 365 366 if (MAI->isValidUnquotedName(OriginalName)) 367 return new (Name, *this) MCSymbolXCOFF(Name, IsTemporary); 368 369 // Now we have a name that contains invalid character(s) for XCOFF symbol. 370 // Let's replace with something valid, but save the original name so that 371 // we could still use the original name in the symbol table. 372 SmallString<128> InvalidName(OriginalName); 373 374 // If it's an entry point symbol, we will keep the '.' 375 // in front for the convention purpose. Otherwise, add "_Renamed.." 376 // as prefix to signal this is an renamed symbol. 377 const bool IsEntryPoint = !InvalidName.empty() && InvalidName[0] == '.'; 378 SmallString<128> ValidName = 379 StringRef(IsEntryPoint ? "._Renamed.." : "_Renamed.."); 380 381 // Append the hex values of '_' and invalid characters with "_Renamed.."; 382 // at the same time replace invalid characters with '_'. 383 for (size_t I = 0; I < InvalidName.size(); ++I) { 384 if (!MAI->isAcceptableChar(InvalidName[I]) || InvalidName[I] == '_') { 385 raw_svector_ostream(ValidName).write_hex(InvalidName[I]); 386 InvalidName[I] = '_'; 387 } 388 } 389 390 // Skip entry point symbol's '.' as we already have a '.' in front of 391 // "_Renamed". 392 if (IsEntryPoint) 393 ValidName.append(InvalidName.substr(1, InvalidName.size() - 1)); 394 else 395 ValidName.append(InvalidName); 396 397 auto NameEntry = UsedNames.insert(std::make_pair(ValidName, true)); 398 assert((NameEntry.second || !NameEntry.first->second) && 399 "This name is used somewhere else."); 400 // Mark the name as used for a non-section symbol. 401 NameEntry.first->second = true; 402 // Have the MCSymbol object itself refer to the copy of the string 403 // that is embedded in the UsedNames entry. 404 MCSymbolXCOFF *XSym = new (&*NameEntry.first, *this) 405 MCSymbolXCOFF(&*NameEntry.first, IsTemporary); 406 XSym->setSymbolTableName(MCSymbolXCOFF::getUnqualifiedName(OriginalName)); 407 return XSym; 408} 409 410//===----------------------------------------------------------------------===// 411// Section Management 412//===----------------------------------------------------------------------===// 413 414MCSectionMachO *MCContext::getMachOSection(StringRef Segment, StringRef Section, 415 unsigned TypeAndAttributes, 416 unsigned Reserved2, SectionKind Kind, 417 const char *BeginSymName) { 418 // We unique sections by their segment/section pair. The returned section 419 // may not have the same flags as the requested section, if so this should be 420 // diagnosed by the client as an error. 421 422 // Form the name to look up. 423 assert(Section.size() <= 16 && "section name is too long"); 424 assert(!memchr(Section.data(), '\0', Section.size()) && 425 "section name cannot contain NUL"); 426 427 // Do the lookup, if we have a hit, return it. 428 auto R = MachOUniquingMap.try_emplace((Segment + Twine(',') + Section).str()); 429 if (!R.second) 430 return R.first->second; 431 432 MCSymbol *Begin = nullptr; 433 if (BeginSymName) 434 Begin = createTempSymbol(BeginSymName, false); 435 436 // Otherwise, return a new section. 437 StringRef Name = R.first->first(); 438 R.first->second = new (MachOAllocator.Allocate()) 439 MCSectionMachO(Segment, Name.substr(Name.size() - Section.size()), 440 TypeAndAttributes, Reserved2, Kind, Begin); 441 return R.first->second; 442} 443 444void MCContext::renameELFSection(MCSectionELF *Section, StringRef Name) { 445 StringRef GroupName; 446 if (const MCSymbol *Group = Section->getGroup()) 447 GroupName = Group->getName(); 448 449 // This function is only used by .debug*, which should not have the 450 // SHF_LINK_ORDER flag. 451 unsigned UniqueID = Section->getUniqueID(); 452 ELFUniquingMap.erase( 453 ELFSectionKey{Section->getName(), GroupName, "", UniqueID}); 454 auto I = ELFUniquingMap 455 .insert(std::make_pair( 456 ELFSectionKey{Name, GroupName, "", UniqueID}, Section)) 457 .first; 458 StringRef CachedName = I->first.SectionName; 459 const_cast<MCSectionELF *>(Section)->setSectionName(CachedName); 460} 461 462MCSectionELF *MCContext::createELFSectionImpl(StringRef Section, unsigned Type, 463 unsigned Flags, SectionKind K, 464 unsigned EntrySize, 465 const MCSymbolELF *Group, 466 bool Comdat, unsigned UniqueID, 467 const MCSymbolELF *LinkedToSym) { 468 MCSymbolELF *R; 469 MCSymbol *&Sym = Symbols[Section]; 470 // A section symbol can not redefine regular symbols. There may be multiple 471 // sections with the same name, in which case the first such section wins. 472 if (Sym && Sym->isDefined() && 473 (!Sym->isInSection() || Sym->getSection().getBeginSymbol() != Sym)) 474 reportError(SMLoc(), "invalid symbol redefinition"); 475 if (Sym && Sym->isUndefined()) { 476 R = cast<MCSymbolELF>(Sym); 477 } else { 478 auto NameIter = UsedNames.insert(std::make_pair(Section, false)).first; 479 R = new (&*NameIter, *this) MCSymbolELF(&*NameIter, /*isTemporary*/ false); 480 if (!Sym) 481 Sym = R; 482 } 483 R->setBinding(ELF::STB_LOCAL); 484 R->setType(ELF::STT_SECTION); 485 486 auto *Ret = new (ELFAllocator.Allocate()) 487 MCSectionELF(Section, Type, Flags, K, EntrySize, Group, Comdat, UniqueID, 488 R, LinkedToSym); 489 490 auto *F = new MCDataFragment(); 491 Ret->getFragmentList().insert(Ret->begin(), F); 492 F->setParent(Ret); 493 R->setFragment(F); 494 495 return Ret; 496} 497 498MCSectionELF *MCContext::createELFRelSection(const Twine &Name, unsigned Type, 499 unsigned Flags, unsigned EntrySize, 500 const MCSymbolELF *Group, 501 const MCSectionELF *RelInfoSection) { 502 StringMap<bool>::iterator I; 503 bool Inserted; 504 std::tie(I, Inserted) = 505 RelSecNames.insert(std::make_pair(Name.str(), true)); 506 507 return createELFSectionImpl( 508 I->getKey(), Type, Flags, SectionKind::getReadOnly(), EntrySize, Group, 509 true, true, cast<MCSymbolELF>(RelInfoSection->getBeginSymbol())); 510} 511 512MCSectionELF *MCContext::getELFNamedSection(const Twine &Prefix, 513 const Twine &Suffix, unsigned Type, 514 unsigned Flags, 515 unsigned EntrySize) { 516 return getELFSection(Prefix + "." + Suffix, Type, Flags, EntrySize, Suffix, 517 /*IsComdat=*/true); 518} 519 520MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type, 521 unsigned Flags, unsigned EntrySize, 522 const Twine &Group, bool IsComdat, 523 unsigned UniqueID, 524 const MCSymbolELF *LinkedToSym) { 525 MCSymbolELF *GroupSym = nullptr; 526 if (!Group.isTriviallyEmpty() && !Group.str().empty()) 527 GroupSym = cast<MCSymbolELF>(getOrCreateSymbol(Group)); 528 529 return getELFSection(Section, Type, Flags, EntrySize, GroupSym, IsComdat, 530 UniqueID, LinkedToSym); 531} 532 533MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type, 534 unsigned Flags, unsigned EntrySize, 535 const MCSymbolELF *GroupSym, 536 bool IsComdat, unsigned UniqueID, 537 const MCSymbolELF *LinkedToSym) { 538 StringRef Group = ""; 539 if (GroupSym) 540 Group = GroupSym->getName(); 541 assert(!(LinkedToSym && LinkedToSym->getName().empty())); 542 // Do the lookup, if we have a hit, return it. 543 auto IterBool = ELFUniquingMap.insert(std::make_pair( 544 ELFSectionKey{Section.str(), Group, 545 LinkedToSym ? LinkedToSym->getName() : "", UniqueID}, 546 nullptr)); 547 auto &Entry = *IterBool.first; 548 if (!IterBool.second) 549 return Entry.second; 550 551 StringRef CachedName = Entry.first.SectionName; 552 553 SectionKind Kind; 554 if (Flags & ELF::SHF_ARM_PURECODE) 555 Kind = SectionKind::getExecuteOnly(); 556 else if (Flags & ELF::SHF_EXECINSTR) 557 Kind = SectionKind::getText(); 558 else 559 Kind = SectionKind::getReadOnly(); 560 561 MCSectionELF *Result = 562 createELFSectionImpl(CachedName, Type, Flags, Kind, EntrySize, GroupSym, 563 IsComdat, UniqueID, LinkedToSym); 564 Entry.second = Result; 565 566 recordELFMergeableSectionInfo(Result->getName(), Result->getFlags(), 567 Result->getUniqueID(), Result->getEntrySize()); 568 569 return Result; 570} 571 572MCSectionELF *MCContext::createELFGroupSection(const MCSymbolELF *Group, 573 bool IsComdat) { 574 return createELFSectionImpl(".group", ELF::SHT_GROUP, 0, 575 SectionKind::getReadOnly(), 4, Group, IsComdat, 576 MCSection::NonUniqueID, nullptr); 577} 578 579void MCContext::recordELFMergeableSectionInfo(StringRef SectionName, 580 unsigned Flags, unsigned UniqueID, 581 unsigned EntrySize) { 582 bool IsMergeable = Flags & ELF::SHF_MERGE; 583 if (IsMergeable && (UniqueID == GenericSectionID)) 584 ELFSeenGenericMergeableSections.insert(SectionName); 585 586 // For mergeable sections or non-mergeable sections with a generic mergeable 587 // section name we enter their Unique ID into the ELFEntrySizeMap so that 588 // compatible globals can be assigned to the same section. 589 if (IsMergeable || isELFGenericMergeableSection(SectionName)) { 590 ELFEntrySizeMap.insert(std::make_pair( 591 ELFEntrySizeKey{SectionName, Flags, EntrySize}, UniqueID)); 592 } 593} 594 595bool MCContext::isELFImplicitMergeableSectionNamePrefix(StringRef SectionName) { 596 return SectionName.startswith(".rodata.str") || 597 SectionName.startswith(".rodata.cst"); 598} 599 600bool MCContext::isELFGenericMergeableSection(StringRef SectionName) { 601 return isELFImplicitMergeableSectionNamePrefix(SectionName) || 602 ELFSeenGenericMergeableSections.count(SectionName); 603} 604 605Optional<unsigned> MCContext::getELFUniqueIDForEntsize(StringRef SectionName, 606 unsigned Flags, 607 unsigned EntrySize) { 608 auto I = ELFEntrySizeMap.find( 609 MCContext::ELFEntrySizeKey{SectionName, Flags, EntrySize}); 610 return (I != ELFEntrySizeMap.end()) ? Optional<unsigned>(I->second) : None; 611} 612 613MCSectionCOFF *MCContext::getCOFFSection(StringRef Section, 614 unsigned Characteristics, 615 SectionKind Kind, 616 StringRef COMDATSymName, int Selection, 617 unsigned UniqueID, 618 const char *BeginSymName) { 619 MCSymbol *COMDATSymbol = nullptr; 620 if (!COMDATSymName.empty()) { 621 COMDATSymbol = getOrCreateSymbol(COMDATSymName); 622 COMDATSymName = COMDATSymbol->getName(); 623 } 624 625 626 // Do the lookup, if we have a hit, return it. 627 COFFSectionKey T{Section, COMDATSymName, Selection, UniqueID}; 628 auto IterBool = COFFUniquingMap.insert(std::make_pair(T, nullptr)); 629 auto Iter = IterBool.first; 630 if (!IterBool.second) 631 return Iter->second; 632 633 MCSymbol *Begin = nullptr; 634 if (BeginSymName) 635 Begin = createTempSymbol(BeginSymName, false); 636 637 StringRef CachedName = Iter->first.SectionName; 638 MCSectionCOFF *Result = new (COFFAllocator.Allocate()) MCSectionCOFF( 639 CachedName, Characteristics, COMDATSymbol, Selection, Kind, Begin); 640 641 Iter->second = Result; 642 return Result; 643} 644 645MCSectionCOFF *MCContext::getCOFFSection(StringRef Section, 646 unsigned Characteristics, 647 SectionKind Kind, 648 const char *BeginSymName) { 649 return getCOFFSection(Section, Characteristics, Kind, "", 0, GenericSectionID, 650 BeginSymName); 651} 652 653MCSectionCOFF *MCContext::getAssociativeCOFFSection(MCSectionCOFF *Sec, 654 const MCSymbol *KeySym, 655 unsigned UniqueID) { 656 // Return the normal section if we don't have to be associative or unique. 657 if (!KeySym && UniqueID == GenericSectionID) 658 return Sec; 659 660 // If we have a key symbol, make an associative section with the same name and 661 // kind as the normal section. 662 unsigned Characteristics = Sec->getCharacteristics(); 663 if (KeySym) { 664 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT; 665 return getCOFFSection(Sec->getName(), Characteristics, Sec->getKind(), 666 KeySym->getName(), 667 COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID); 668 } 669 670 return getCOFFSection(Sec->getName(), Characteristics, Sec->getKind(), "", 0, 671 UniqueID); 672} 673 674MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind K, 675 unsigned Flags, const Twine &Group, 676 unsigned UniqueID, 677 const char *BeginSymName) { 678 MCSymbolWasm *GroupSym = nullptr; 679 if (!Group.isTriviallyEmpty() && !Group.str().empty()) { 680 GroupSym = cast<MCSymbolWasm>(getOrCreateSymbol(Group)); 681 GroupSym->setComdat(true); 682 } 683 684 return getWasmSection(Section, K, Flags, GroupSym, UniqueID, BeginSymName); 685} 686 687MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind, 688 unsigned Flags, 689 const MCSymbolWasm *GroupSym, 690 unsigned UniqueID, 691 const char *BeginSymName) { 692 StringRef Group = ""; 693 if (GroupSym) 694 Group = GroupSym->getName(); 695 // Do the lookup, if we have a hit, return it. 696 auto IterBool = WasmUniquingMap.insert( 697 std::make_pair(WasmSectionKey{Section.str(), Group, UniqueID}, nullptr)); 698 auto &Entry = *IterBool.first; 699 if (!IterBool.second) 700 return Entry.second; 701 702 StringRef CachedName = Entry.first.SectionName; 703 704 MCSymbol *Begin = createSymbol(CachedName, true, false); 705 Symbols[Begin->getName()] = Begin; 706 cast<MCSymbolWasm>(Begin)->setType(wasm::WASM_SYMBOL_TYPE_SECTION); 707 708 MCSectionWasm *Result = new (WasmAllocator.Allocate()) 709 MCSectionWasm(CachedName, Kind, Flags, GroupSym, UniqueID, Begin); 710 Entry.second = Result; 711 712 auto *F = new MCDataFragment(); 713 Result->getFragmentList().insert(Result->begin(), F); 714 F->setParent(Result); 715 Begin->setFragment(F); 716 717 return Result; 718} 719 720MCSectionXCOFF *MCContext::getXCOFFSection( 721 StringRef Section, SectionKind Kind, 722 Optional<XCOFF::CsectProperties> CsectProp, bool MultiSymbolsAllowed, 723 const char *BeginSymName, 724 Optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSectionSubtypeFlags) { 725 bool IsDwarfSec = DwarfSectionSubtypeFlags.hasValue(); 726 assert((IsDwarfSec != CsectProp.hasValue()) && "Invalid XCOFF section!"); 727 728 // Do the lookup. If we have a hit, return it. 729 auto IterBool = XCOFFUniquingMap.insert(std::make_pair( 730 IsDwarfSec 731 ? XCOFFSectionKey(Section.str(), DwarfSectionSubtypeFlags.getValue()) 732 : XCOFFSectionKey(Section.str(), CsectProp->MappingClass), 733 nullptr)); 734 auto &Entry = *IterBool.first; 735 if (!IterBool.second) { 736 MCSectionXCOFF *ExistedEntry = Entry.second; 737 if (ExistedEntry->isMultiSymbolsAllowed() != MultiSymbolsAllowed) 738 report_fatal_error("section's multiply symbols policy does not match"); 739 740 return ExistedEntry; 741 } 742 743 // Otherwise, return a new section. 744 StringRef CachedName = Entry.first.SectionName; 745 MCSymbolXCOFF *QualName = nullptr; 746 // Debug section don't have storage class attribute. 747 if (IsDwarfSec) 748 QualName = cast<MCSymbolXCOFF>(getOrCreateSymbol(CachedName)); 749 else 750 QualName = cast<MCSymbolXCOFF>(getOrCreateSymbol( 751 CachedName + "[" + 752 XCOFF::getMappingClassString(CsectProp->MappingClass) + "]")); 753 754 MCSymbol *Begin = nullptr; 755 if (BeginSymName) 756 Begin = createTempSymbol(BeginSymName, false); 757 758 // QualName->getUnqualifiedName() and CachedName are the same except when 759 // CachedName contains invalid character(s) such as '$' for an XCOFF symbol. 760 MCSectionXCOFF *Result = nullptr; 761 if (IsDwarfSec) 762 Result = new (XCOFFAllocator.Allocate()) 763 MCSectionXCOFF(QualName->getUnqualifiedName(), Kind, QualName, 764 DwarfSectionSubtypeFlags.getValue(), Begin, CachedName, 765 MultiSymbolsAllowed); 766 else 767 Result = new (XCOFFAllocator.Allocate()) 768 MCSectionXCOFF(QualName->getUnqualifiedName(), CsectProp->MappingClass, 769 CsectProp->Type, Kind, QualName, Begin, CachedName, 770 MultiSymbolsAllowed); 771 772 Entry.second = Result; 773 774 auto *F = new MCDataFragment(); 775 Result->getFragmentList().insert(Result->begin(), F); 776 F->setParent(Result); 777 778 if (Begin) 779 Begin->setFragment(F); 780 781 return Result; 782} 783 784MCSubtargetInfo &MCContext::getSubtargetCopy(const MCSubtargetInfo &STI) { 785 return *new (MCSubtargetAllocator.Allocate()) MCSubtargetInfo(STI); 786} 787 788void MCContext::addDebugPrefixMapEntry(const std::string &From, 789 const std::string &To) { 790 DebugPrefixMap.insert(std::make_pair(From, To)); 791} 792 793void MCContext::RemapDebugPaths() { 794 const auto &DebugPrefixMap = this->DebugPrefixMap; 795 if (DebugPrefixMap.empty()) 796 return; 797 798 const auto RemapDebugPath = [&DebugPrefixMap](std::string &Path) { 799 SmallString<256> P(Path); 800 for (const auto &Entry : DebugPrefixMap) { 801 if (llvm::sys::path::replace_path_prefix(P, Entry.first, Entry.second)) { 802 Path = P.str().str(); 803 break; 804 } 805 } 806 }; 807 808 // Remap compilation directory. 809 std::string CompDir = std::string(CompilationDir.str()); 810 RemapDebugPath(CompDir); 811 CompilationDir = CompDir; 812 813 // Remap MCDwarfDirs in all compilation units. 814 for (auto &CUIDTablePair : MCDwarfLineTablesCUMap) 815 for (auto &Dir : CUIDTablePair.second.getMCDwarfDirs()) 816 RemapDebugPath(Dir); 817} 818 819//===----------------------------------------------------------------------===// 820// Dwarf Management 821//===----------------------------------------------------------------------===// 822 823void MCContext::setGenDwarfRootFile(StringRef InputFileName, StringRef Buffer) { 824 // MCDwarf needs the root file as well as the compilation directory. 825 // If we find a '.file 0' directive that will supersede these values. 826 Optional<MD5::MD5Result> Cksum; 827 if (getDwarfVersion() >= 5) { 828 MD5 Hash; 829 MD5::MD5Result Sum; 830 Hash.update(Buffer); 831 Hash.final(Sum); 832 Cksum = Sum; 833 } 834 // Canonicalize the root filename. It cannot be empty, and should not 835 // repeat the compilation dir. 836 // The MCContext ctor initializes MainFileName to the name associated with 837 // the SrcMgr's main file ID, which might be the same as InputFileName (and 838 // possibly include directory components). 839 // Or, MainFileName might have been overridden by a -main-file-name option, 840 // which is supposed to be just a base filename with no directory component. 841 // So, if the InputFileName and MainFileName are not equal, assume 842 // MainFileName is a substitute basename and replace the last component. 843 SmallString<1024> FileNameBuf = InputFileName; 844 if (FileNameBuf.empty() || FileNameBuf == "-") 845 FileNameBuf = "<stdin>"; 846 if (!getMainFileName().empty() && FileNameBuf != getMainFileName()) { 847 llvm::sys::path::remove_filename(FileNameBuf); 848 llvm::sys::path::append(FileNameBuf, getMainFileName()); 849 } 850 StringRef FileName = FileNameBuf; 851 if (FileName.consume_front(getCompilationDir())) 852 if (llvm::sys::path::is_separator(FileName.front())) 853 FileName = FileName.drop_front(); 854 assert(!FileName.empty()); 855 setMCLineTableRootFile( 856 /*CUID=*/0, getCompilationDir(), FileName, Cksum, None); 857} 858 859/// getDwarfFile - takes a file name and number to place in the dwarf file and 860/// directory tables. If the file number has already been allocated it is an 861/// error and zero is returned and the client reports the error, else the 862/// allocated file number is returned. The file numbers may be in any order. 863Expected<unsigned> MCContext::getDwarfFile(StringRef Directory, 864 StringRef FileName, 865 unsigned FileNumber, 866 Optional<MD5::MD5Result> Checksum, 867 Optional<StringRef> Source, 868 unsigned CUID) { 869 MCDwarfLineTable &Table = MCDwarfLineTablesCUMap[CUID]; 870 return Table.tryGetFile(Directory, FileName, Checksum, Source, DwarfVersion, 871 FileNumber); 872} 873 874/// isValidDwarfFileNumber - takes a dwarf file number and returns true if it 875/// currently is assigned and false otherwise. 876bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) { 877 const MCDwarfLineTable &LineTable = getMCDwarfLineTable(CUID); 878 if (FileNumber == 0) 879 return getDwarfVersion() >= 5; 880 if (FileNumber >= LineTable.getMCDwarfFiles().size()) 881 return false; 882 883 return !LineTable.getMCDwarfFiles()[FileNumber].Name.empty(); 884} 885 886/// Remove empty sections from SectionsForRanges, to avoid generating 887/// useless debug info for them. 888void MCContext::finalizeDwarfSections(MCStreamer &MCOS) { 889 SectionsForRanges.remove_if( 890 [&](MCSection *Sec) { return !MCOS.mayHaveInstructions(*Sec); }); 891} 892 893CodeViewContext &MCContext::getCVContext() { 894 if (!CVContext.get()) 895 CVContext.reset(new CodeViewContext); 896 return *CVContext.get(); 897} 898 899//===----------------------------------------------------------------------===// 900// Error Reporting 901//===----------------------------------------------------------------------===// 902 903void MCContext::diagnose(const SMDiagnostic &SMD) { 904 assert(DiagHandler && "MCContext::DiagHandler is not set"); 905 bool UseInlineSrcMgr = false; 906 const SourceMgr *SMP = nullptr; 907 if (SrcMgr) { 908 SMP = SrcMgr; 909 } else if (InlineSrcMgr) { 910 SMP = InlineSrcMgr.get(); 911 UseInlineSrcMgr = true; 912 } else 913 llvm_unreachable("Either SourceMgr should be available"); 914 DiagHandler(SMD, UseInlineSrcMgr, *SMP, LocInfos); 915} 916 917void MCContext::reportCommon( 918 SMLoc Loc, 919 std::function<void(SMDiagnostic &, const SourceMgr *)> GetMessage) { 920 // * MCContext::SrcMgr is null when the MC layer emits machine code for input 921 // other than assembly file, say, for .c/.cpp/.ll/.bc. 922 // * MCContext::InlineSrcMgr is null when the inline asm is not used. 923 // * A default SourceMgr is needed for diagnosing when both MCContext::SrcMgr 924 // and MCContext::InlineSrcMgr are null. 925 SourceMgr SM; 926 const SourceMgr *SMP = &SM; 927 bool UseInlineSrcMgr = false; 928 929 // FIXME: Simplify these by combining InlineSrcMgr & SrcMgr. 930 // For MC-only execution, only SrcMgr is used; 931 // For non MC-only execution, InlineSrcMgr is only ctor'd if there is 932 // inline asm in the IR. 933 if (Loc.isValid()) { 934 if (SrcMgr) { 935 SMP = SrcMgr; 936 } else if (InlineSrcMgr) { 937 SMP = InlineSrcMgr.get(); 938 UseInlineSrcMgr = true; 939 } else 940 llvm_unreachable("Either SourceMgr should be available"); 941 } 942 943 SMDiagnostic D; 944 GetMessage(D, SMP); 945 DiagHandler(D, UseInlineSrcMgr, *SMP, LocInfos); 946} 947 948void MCContext::reportError(SMLoc Loc, const Twine &Msg) { 949 HadError = true; 950 reportCommon(Loc, [&](SMDiagnostic &D, const SourceMgr *SMP) { 951 D = SMP->GetMessage(Loc, SourceMgr::DK_Error, Msg); 952 }); 953} 954 955void MCContext::reportWarning(SMLoc Loc, const Twine &Msg) { 956 if (TargetOptions && TargetOptions->MCNoWarn) 957 return; 958 if (TargetOptions && TargetOptions->MCFatalWarnings) { 959 reportError(Loc, Msg); 960 } else { 961 reportCommon(Loc, [&](SMDiagnostic &D, const SourceMgr *SMP) { 962 D = SMP->GetMessage(Loc, SourceMgr::DK_Warning, Msg); 963 }); 964 } 965} 966 967void MCContext::reportFatalError(SMLoc Loc, const Twine &Msg) { 968 reportError(Loc, Msg); 969 970 // If we reached here, we are failing ungracefully. Run the interrupt handlers 971 // to make sure any special cleanups get done, in particular that we remove 972 // files registered with RemoveFileOnSignal. 973 sys::RunInterruptHandlers(); 974 exit(1); 975} 976