1 //===- lib/MC/MCContext.cpp - Machine Code Context ------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/MC/MCContext.h"
11 #include "llvm/ADT/Optional.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/SmallVector.h"
14 #include "llvm/ADT/StringMap.h"
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/ADT/Twine.h"
17 #include "llvm/BinaryFormat/COFF.h"
18 #include "llvm/BinaryFormat/ELF.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/MCStreamer.h"
31 #include "llvm/MC/MCSymbol.h"
32 #include "llvm/MC/MCSymbolCOFF.h"
33 #include "llvm/MC/MCSymbolELF.h"
34 #include "llvm/MC/MCSymbolMachO.h"
35 #include "llvm/MC/MCSymbolWasm.h"
36 #include "llvm/MC/SectionKind.h"
37 #include "llvm/Support/Casting.h"
38 #include "llvm/Support/CommandLine.h"
39 #include "llvm/Support/ErrorHandling.h"
40 #include "llvm/Support/MemoryBuffer.h"
41 #include "llvm/Support/Signals.h"
42 #include "llvm/Support/SourceMgr.h"
43 #include "llvm/Support/raw_ostream.h"
52 AsSecureLogFileName("as-secure-log-file-name",
53 cl::desc("As secure log file name (initialized from "
54 "AS_SECURE_LOG_FILE env variable)"),
55 cl::init(getenv("AS_SECURE_LOG_FILE")), cl::Hidden);
57 MCContext::MCContext(const MCAsmInfo *mai, const MCRegisterInfo *mri,
58 const MCObjectFileInfo *mofi, const SourceMgr *mgr,
60 : SrcMgr(mgr), InlineSrcMgr(nullptr), MAI(mai), MRI(mri), MOFI(mofi),
61 Symbols(Allocator), UsedNames(Allocator),
62 CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0),
63 AutoReset(DoAutoReset) {
64 SecureLogFile = AsSecureLogFileName;
66 if (SrcMgr && SrcMgr->getNumBuffers())
68 SrcMgr->getMemoryBuffer(SrcMgr->getMainFileID())->getBufferIdentifier();
71 MCContext::~MCContext() {
75 // NOTE: The symbols are all allocated out of a bump pointer allocator,
76 // we don't need to free them here.
79 //===----------------------------------------------------------------------===//
80 // Module Lifetime Management
81 //===----------------------------------------------------------------------===//
83 void MCContext::reset() {
84 // Call the destructors so the fragments are freed
85 COFFAllocator.DestroyAll();
86 ELFAllocator.DestroyAll();
87 MachOAllocator.DestroyAll();
89 MCSubtargetAllocator.DestroyAll();
94 CompilationDir.clear();
96 MCDwarfLineTablesCUMap.clear();
97 SectionsForRanges.clear();
98 MCGenDwarfLabelEntries.clear();
99 DwarfDebugFlags = StringRef();
100 DwarfCompileUnitID = 0;
101 CurrentDwarfLoc = MCDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0);
105 MachOUniquingMap.clear();
106 ELFUniquingMap.clear();
107 COFFUniquingMap.clear();
108 WasmUniquingMap.clear();
111 AllowTemporaryLabels = true;
112 DwarfLocSeen = false;
113 GenDwarfForAssembly = false;
114 GenDwarfFileNumber = 0;
119 //===----------------------------------------------------------------------===//
120 // Symbol Manipulation
121 //===----------------------------------------------------------------------===//
123 MCSymbol *MCContext::getOrCreateSymbol(const Twine &Name) {
124 SmallString<128> NameSV;
125 StringRef NameRef = Name.toStringRef(NameSV);
127 assert(!NameRef.empty() && "Normal symbols cannot be unnamed!");
129 MCSymbol *&Sym = Symbols[NameRef];
131 Sym = createSymbol(NameRef, false, false);
136 MCSymbol *MCContext::getOrCreateFrameAllocSymbol(StringRef FuncName,
138 return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
139 "$frame_escape_" + Twine(Idx));
142 MCSymbol *MCContext::getOrCreateParentFrameOffsetSymbol(StringRef FuncName) {
143 return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
144 "$parent_frame_offset");
147 MCSymbol *MCContext::getOrCreateLSDASymbol(StringRef FuncName) {
148 return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + "__ehtable$" +
152 MCSymbol *MCContext::createSymbolImpl(const StringMapEntry<bool> *Name,
155 switch (MOFI->getObjectFileType()) {
156 case MCObjectFileInfo::IsCOFF:
157 return new (Name, *this) MCSymbolCOFF(Name, IsTemporary);
158 case MCObjectFileInfo::IsELF:
159 return new (Name, *this) MCSymbolELF(Name, IsTemporary);
160 case MCObjectFileInfo::IsMachO:
161 return new (Name, *this) MCSymbolMachO(Name, IsTemporary);
162 case MCObjectFileInfo::IsWasm:
163 return new (Name, *this) MCSymbolWasm(Name, IsTemporary);
166 return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name,
170 MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix,
172 if (CanBeUnnamed && !UseNamesOnTempLabels)
173 return createSymbolImpl(nullptr, true);
175 // Determine whether this is a user written assembler temporary or normal
177 bool IsTemporary = CanBeUnnamed;
178 if (AllowTemporaryLabels && !IsTemporary)
179 IsTemporary = Name.startswith(MAI->getPrivateGlobalPrefix());
181 SmallString<128> NewName = Name;
182 bool AddSuffix = AlwaysAddSuffix;
183 unsigned &NextUniqueID = NextID[Name];
186 NewName.resize(Name.size());
187 raw_svector_ostream(NewName) << NextUniqueID++;
189 auto NameEntry = UsedNames.insert(std::make_pair(NewName, true));
190 if (NameEntry.second || !NameEntry.first->second) {
191 // Ok, we found a name.
192 // Mark it as used for a non-section symbol.
193 NameEntry.first->second = true;
194 // Have the MCSymbol object itself refer to the copy of the string that is
195 // embedded in the UsedNames entry.
196 return createSymbolImpl(&*NameEntry.first, IsTemporary);
198 assert(IsTemporary && "Cannot rename non-temporary symbols");
201 llvm_unreachable("Infinite loop");
204 MCSymbol *MCContext::createTempSymbol(const Twine &Name, bool AlwaysAddSuffix,
206 SmallString<128> NameSV;
207 raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name;
208 return createSymbol(NameSV, AlwaysAddSuffix, CanBeUnnamed);
211 MCSymbol *MCContext::createLinkerPrivateTempSymbol() {
212 SmallString<128> NameSV;
213 raw_svector_ostream(NameSV) << MAI->getLinkerPrivateGlobalPrefix() << "tmp";
214 return createSymbol(NameSV, true, false);
217 MCSymbol *MCContext::createTempSymbol(bool CanBeUnnamed) {
218 return createTempSymbol("tmp", true, CanBeUnnamed);
221 unsigned MCContext::NextInstance(unsigned LocalLabelVal) {
222 MCLabel *&Label = Instances[LocalLabelVal];
224 Label = new (*this) MCLabel(0);
225 return Label->incInstance();
228 unsigned MCContext::GetInstance(unsigned LocalLabelVal) {
229 MCLabel *&Label = Instances[LocalLabelVal];
231 Label = new (*this) MCLabel(0);
232 return Label->getInstance();
235 MCSymbol *MCContext::getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal,
237 MCSymbol *&Sym = LocalSymbols[std::make_pair(LocalLabelVal, Instance)];
239 Sym = createTempSymbol(false);
243 MCSymbol *MCContext::createDirectionalLocalSymbol(unsigned LocalLabelVal) {
244 unsigned Instance = NextInstance(LocalLabelVal);
245 return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance);
248 MCSymbol *MCContext::getDirectionalLocalSymbol(unsigned LocalLabelVal,
250 unsigned Instance = GetInstance(LocalLabelVal);
253 return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance);
256 MCSymbol *MCContext::lookupSymbol(const Twine &Name) const {
257 SmallString<128> NameSV;
258 StringRef NameRef = Name.toStringRef(NameSV);
259 return Symbols.lookup(NameRef);
262 void MCContext::setSymbolValue(MCStreamer &Streamer,
265 auto Symbol = getOrCreateSymbol(Sym);
266 Streamer.EmitAssignment(Symbol, MCConstantExpr::create(Val, *this));
269 //===----------------------------------------------------------------------===//
270 // Section Management
271 //===----------------------------------------------------------------------===//
273 MCSectionMachO *MCContext::getMachOSection(StringRef Segment, StringRef Section,
274 unsigned TypeAndAttributes,
275 unsigned Reserved2, SectionKind Kind,
276 const char *BeginSymName) {
277 // We unique sections by their segment/section pair. The returned section
278 // may not have the same flags as the requested section, if so this should be
279 // diagnosed by the client as an error.
281 // Form the name to look up.
282 SmallString<64> Name;
287 // Do the lookup, if we have a hit, return it.
288 MCSectionMachO *&Entry = MachOUniquingMap[Name];
292 MCSymbol *Begin = nullptr;
294 Begin = createTempSymbol(BeginSymName, false);
296 // Otherwise, return a new section.
297 return Entry = new (MachOAllocator.Allocate()) MCSectionMachO(
298 Segment, Section, TypeAndAttributes, Reserved2, Kind, Begin);
301 void MCContext::renameELFSection(MCSectionELF *Section, StringRef Name) {
303 if (const MCSymbol *Group = Section->getGroup())
304 GroupName = Group->getName();
306 unsigned UniqueID = Section->getUniqueID();
307 ELFUniquingMap.erase(
308 ELFSectionKey{Section->getSectionName(), GroupName, UniqueID});
309 auto I = ELFUniquingMap.insert(std::make_pair(
310 ELFSectionKey{Name, GroupName, UniqueID},
313 StringRef CachedName = I->first.SectionName;
314 const_cast<MCSectionELF *>(Section)->setSectionName(CachedName);
317 MCSectionELF *MCContext::createELFSectionImpl(StringRef Section, unsigned Type,
318 unsigned Flags, SectionKind K,
320 const MCSymbolELF *Group,
322 const MCSymbolELF *Associated) {
324 MCSymbol *&Sym = Symbols[Section];
325 // A section symbol can not redefine regular symbols. There may be multiple
326 // sections with the same name, in which case the first such section wins.
327 if (Sym && Sym->isDefined() &&
328 (!Sym->isInSection() || Sym->getSection().getBeginSymbol() != Sym))
329 reportError(SMLoc(), "invalid symbol redefinition");
330 if (Sym && Sym->isUndefined()) {
331 R = cast<MCSymbolELF>(Sym);
333 auto NameIter = UsedNames.insert(std::make_pair(Section, false)).first;
334 R = new (&*NameIter, *this) MCSymbolELF(&*NameIter, /*isTemporary*/ false);
338 R->setBinding(ELF::STB_LOCAL);
339 R->setType(ELF::STT_SECTION);
341 auto *Ret = new (ELFAllocator.Allocate()) MCSectionELF(
342 Section, Type, Flags, K, EntrySize, Group, UniqueID, R, Associated);
344 auto *F = new MCDataFragment();
345 Ret->getFragmentList().insert(Ret->begin(), F);
352 MCSectionELF *MCContext::createELFRelSection(const Twine &Name, unsigned Type,
353 unsigned Flags, unsigned EntrySize,
354 const MCSymbolELF *Group,
355 const MCSectionELF *RelInfoSection) {
356 StringMap<bool>::iterator I;
358 std::tie(I, Inserted) =
359 RelSecNames.insert(std::make_pair(Name.str(), true));
361 return createELFSectionImpl(
362 I->getKey(), Type, Flags, SectionKind::getReadOnly(), EntrySize, Group,
363 true, cast<MCSymbolELF>(RelInfoSection->getBeginSymbol()));
366 MCSectionELF *MCContext::getELFNamedSection(const Twine &Prefix,
367 const Twine &Suffix, unsigned Type,
369 unsigned EntrySize) {
370 return getELFSection(Prefix + "." + Suffix, Type, Flags, EntrySize, Suffix);
373 MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
374 unsigned Flags, unsigned EntrySize,
375 const Twine &Group, unsigned UniqueID,
376 const MCSymbolELF *Associated) {
377 MCSymbolELF *GroupSym = nullptr;
378 if (!Group.isTriviallyEmpty() && !Group.str().empty())
379 GroupSym = cast<MCSymbolELF>(getOrCreateSymbol(Group));
381 return getELFSection(Section, Type, Flags, EntrySize, GroupSym, UniqueID,
385 MCSectionELF *MCContext::getELFSection(const Twine &Section, unsigned Type,
386 unsigned Flags, unsigned EntrySize,
387 const MCSymbolELF *GroupSym,
389 const MCSymbolELF *Associated) {
390 StringRef Group = "";
392 Group = GroupSym->getName();
393 // Do the lookup, if we have a hit, return it.
394 auto IterBool = ELFUniquingMap.insert(
395 std::make_pair(ELFSectionKey{Section.str(), Group, UniqueID}, nullptr));
396 auto &Entry = *IterBool.first;
397 if (!IterBool.second)
400 StringRef CachedName = Entry.first.SectionName;
403 if (Flags & ELF::SHF_ARM_PURECODE)
404 Kind = SectionKind::getExecuteOnly();
405 else if (Flags & ELF::SHF_EXECINSTR)
406 Kind = SectionKind::getText();
408 Kind = SectionKind::getReadOnly();
410 MCSectionELF *Result = createELFSectionImpl(
411 CachedName, Type, Flags, Kind, EntrySize, GroupSym, UniqueID, Associated);
412 Entry.second = Result;
416 MCSectionELF *MCContext::createELFGroupSection(const MCSymbolELF *Group) {
417 return createELFSectionImpl(".group", ELF::SHT_GROUP, 0,
418 SectionKind::getReadOnly(), 4, Group, ~0,
422 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
423 unsigned Characteristics,
425 StringRef COMDATSymName, int Selection,
427 const char *BeginSymName) {
428 MCSymbol *COMDATSymbol = nullptr;
429 if (!COMDATSymName.empty()) {
430 COMDATSymbol = getOrCreateSymbol(COMDATSymName);
431 COMDATSymName = COMDATSymbol->getName();
435 // Do the lookup, if we have a hit, return it.
436 COFFSectionKey T{Section, COMDATSymName, Selection, UniqueID};
437 auto IterBool = COFFUniquingMap.insert(std::make_pair(T, nullptr));
438 auto Iter = IterBool.first;
439 if (!IterBool.second)
442 MCSymbol *Begin = nullptr;
444 Begin = createTempSymbol(BeginSymName, false);
446 StringRef CachedName = Iter->first.SectionName;
447 MCSectionCOFF *Result = new (COFFAllocator.Allocate()) MCSectionCOFF(
448 CachedName, Characteristics, COMDATSymbol, Selection, Kind, Begin);
450 Iter->second = Result;
454 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
455 unsigned Characteristics,
457 const char *BeginSymName) {
458 return getCOFFSection(Section, Characteristics, Kind, "", 0, GenericSectionID,
462 MCSectionCOFF *MCContext::getCOFFSection(StringRef Section) {
463 COFFSectionKey T{Section, "", 0, GenericSectionID};
464 auto Iter = COFFUniquingMap.find(T);
465 if (Iter == COFFUniquingMap.end())
470 MCSectionCOFF *MCContext::getAssociativeCOFFSection(MCSectionCOFF *Sec,
471 const MCSymbol *KeySym,
473 // Return the normal section if we don't have to be associative or unique.
474 if (!KeySym && UniqueID == GenericSectionID)
477 // If we have a key symbol, make an associative section with the same name and
478 // kind as the normal section.
479 unsigned Characteristics = Sec->getCharacteristics();
481 Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
482 return getCOFFSection(Sec->getSectionName(), Characteristics,
483 Sec->getKind(), KeySym->getName(),
484 COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
487 return getCOFFSection(Sec->getSectionName(), Characteristics, Sec->getKind(),
491 MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind K,
492 const Twine &Group, unsigned UniqueID,
493 const char *BeginSymName) {
494 MCSymbolWasm *GroupSym = nullptr;
495 if (!Group.isTriviallyEmpty() && !Group.str().empty()) {
496 GroupSym = cast<MCSymbolWasm>(getOrCreateSymbol(Group));
497 GroupSym->setComdat(true);
500 return getWasmSection(Section, K, GroupSym, UniqueID, BeginSymName);
503 MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind,
504 const MCSymbolWasm *GroupSym,
506 const char *BeginSymName) {
507 StringRef Group = "";
509 Group = GroupSym->getName();
510 // Do the lookup, if we have a hit, return it.
511 auto IterBool = WasmUniquingMap.insert(
512 std::make_pair(WasmSectionKey{Section.str(), Group, UniqueID}, nullptr));
513 auto &Entry = *IterBool.first;
514 if (!IterBool.second)
517 StringRef CachedName = Entry.first.SectionName;
519 MCSymbol *Begin = createSymbol(CachedName, false, false);
520 cast<MCSymbolWasm>(Begin)->setType(wasm::WASM_SYMBOL_TYPE_SECTION);
522 MCSectionWasm *Result = new (WasmAllocator.Allocate())
523 MCSectionWasm(CachedName, Kind, GroupSym, UniqueID, Begin);
524 Entry.second = Result;
526 auto *F = new MCDataFragment();
527 Result->getFragmentList().insert(Result->begin(), F);
528 F->setParent(Result);
529 Begin->setFragment(F);
534 MCSubtargetInfo &MCContext::getSubtargetCopy(const MCSubtargetInfo &STI) {
535 return *new (MCSubtargetAllocator.Allocate()) MCSubtargetInfo(STI);
538 void MCContext::addDebugPrefixMapEntry(const std::string &From,
539 const std::string &To) {
540 DebugPrefixMap.insert(std::make_pair(From, To));
543 void MCContext::RemapDebugPaths() {
544 const auto &DebugPrefixMap = this->DebugPrefixMap;
545 const auto RemapDebugPath = [&DebugPrefixMap](std::string &Path) {
546 for (const auto &Entry : DebugPrefixMap)
547 if (StringRef(Path).startswith(Entry.first)) {
548 std::string RemappedPath =
549 (Twine(Entry.second) + Path.substr(Entry.first.size())).str();
550 Path.swap(RemappedPath);
554 // Remap compilation directory.
555 std::string CompDir = CompilationDir.str();
556 RemapDebugPath(CompDir);
557 CompilationDir = CompDir;
559 // Remap MCDwarfDirs in all compilation units.
560 for (auto &CUIDTablePair : MCDwarfLineTablesCUMap)
561 for (auto &Dir : CUIDTablePair.second.getMCDwarfDirs())
565 //===----------------------------------------------------------------------===//
567 //===----------------------------------------------------------------------===//
569 /// getDwarfFile - takes a file name and number to place in the dwarf file and
570 /// directory tables. If the file number has already been allocated it is an
571 /// error and zero is returned and the client reports the error, else the
572 /// allocated file number is returned. The file numbers may be in any order.
573 Expected<unsigned> MCContext::getDwarfFile(StringRef Directory,
576 MD5::MD5Result *Checksum,
577 Optional<StringRef> Source,
579 MCDwarfLineTable &Table = MCDwarfLineTablesCUMap[CUID];
580 return Table.tryGetFile(Directory, FileName, Checksum, Source, FileNumber);
583 /// isValidDwarfFileNumber - takes a dwarf file number and returns true if it
584 /// currently is assigned and false otherwise.
585 bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) {
586 const MCDwarfLineTable &LineTable = getMCDwarfLineTable(CUID);
588 return getDwarfVersion() >= 5 && LineTable.hasRootFile();
589 if (FileNumber >= LineTable.getMCDwarfFiles().size())
592 return !LineTable.getMCDwarfFiles()[FileNumber].Name.empty();
595 /// Remove empty sections from SectionsForRanges, to avoid generating
596 /// useless debug info for them.
597 void MCContext::finalizeDwarfSections(MCStreamer &MCOS) {
598 SectionsForRanges.remove_if(
599 [&](MCSection *Sec) { return !MCOS.mayHaveInstructions(*Sec); });
602 CodeViewContext &MCContext::getCVContext() {
603 if (!CVContext.get())
604 CVContext.reset(new CodeViewContext);
605 return *CVContext.get();
608 //===----------------------------------------------------------------------===//
610 //===----------------------------------------------------------------------===//
612 void MCContext::reportError(SMLoc Loc, const Twine &Msg) {
615 // If we have a source manager use it. Otherwise, try using the inline source
617 // If that fails, use the generic report_fatal_error().
619 SrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
620 else if (InlineSrcMgr)
621 InlineSrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
623 report_fatal_error(Msg, false);
626 void MCContext::reportFatalError(SMLoc Loc, const Twine &Msg) {
627 reportError(Loc, Msg);
629 // If we reached here, we are failing ungracefully. Run the interrupt handlers
630 // to make sure any special cleanups get done, in particular that we remove
631 // files registered with RemoveFileOnSignal.
632 sys::RunInterruptHandlers();