mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-07-23 01:30:19 +00:00
ec77d9ad83
What this does is make all symbols that would otherwise start with a .L (or L on MachO) unnamed. Some of these symbols still show up in the symbol table, but we can just make them unnamed. In order to make sure we produce identical results when going thought assembly, all .L (not just the compiler produced ones), are now unnamed. Running llc on llvm-as.opt.bc, the peak memory usage goes from 208.24MB to 205.57MB. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@240130 91177308-0d34-0410-b5e6-96231b3b80d8
487 lines
17 KiB
C++
487 lines
17 KiB
C++
//===- lib/MC/MCContext.cpp - Machine Code Context ------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/MC/MCContext.h"
|
|
#include "llvm/ADT/SmallString.h"
|
|
#include "llvm/ADT/Twine.h"
|
|
#include "llvm/MC/MCAssembler.h"
|
|
#include "llvm/MC/MCAsmInfo.h"
|
|
#include "llvm/MC/MCDwarf.h"
|
|
#include "llvm/MC/MCLabel.h"
|
|
#include "llvm/MC/MCObjectFileInfo.h"
|
|
#include "llvm/MC/MCRegisterInfo.h"
|
|
#include "llvm/MC/MCSectionCOFF.h"
|
|
#include "llvm/MC/MCSectionELF.h"
|
|
#include "llvm/MC/MCSectionMachO.h"
|
|
#include "llvm/MC/MCStreamer.h"
|
|
#include "llvm/MC/MCSymbolCOFF.h"
|
|
#include "llvm/MC/MCSymbolELF.h"
|
|
#include "llvm/MC/MCSymbolMachO.h"
|
|
#include "llvm/Support/ELF.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/Signals.h"
|
|
#include "llvm/Support/SourceMgr.h"
|
|
#include <map>
|
|
|
|
using namespace llvm;
|
|
|
|
MCContext::MCContext(const MCAsmInfo *mai, const MCRegisterInfo *mri,
|
|
const MCObjectFileInfo *mofi, const SourceMgr *mgr,
|
|
bool DoAutoReset)
|
|
: SrcMgr(mgr), MAI(mai), MRI(mri), MOFI(mofi), Allocator(),
|
|
Symbols(Allocator), UsedNames(Allocator),
|
|
CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0), DwarfLocSeen(false),
|
|
GenDwarfForAssembly(false), GenDwarfFileNumber(0), DwarfVersion(4),
|
|
AllowTemporaryLabels(true), DwarfCompileUnitID(0),
|
|
AutoReset(DoAutoReset) {
|
|
|
|
std::error_code EC = llvm::sys::fs::current_path(CompilationDir);
|
|
if (EC)
|
|
CompilationDir.clear();
|
|
|
|
SecureLogFile = getenv("AS_SECURE_LOG_FILE");
|
|
SecureLog = nullptr;
|
|
SecureLogUsed = false;
|
|
|
|
if (SrcMgr && SrcMgr->getNumBuffers())
|
|
MainFileName =
|
|
SrcMgr->getMemoryBuffer(SrcMgr->getMainFileID())->getBufferIdentifier();
|
|
}
|
|
|
|
MCContext::~MCContext() {
|
|
if (AutoReset)
|
|
reset();
|
|
|
|
// NOTE: The symbols are all allocated out of a bump pointer allocator,
|
|
// we don't need to free them here.
|
|
|
|
// If the stream for the .secure_log_unique directive was created free it.
|
|
delete (raw_ostream *)SecureLog;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Module Lifetime Management
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
void MCContext::reset() {
|
|
// Call the destructors so the fragments are freed
|
|
for (auto &I : ELFUniquingMap)
|
|
I.second->~MCSectionELF();
|
|
for (auto &I : COFFUniquingMap)
|
|
I.second->~MCSectionCOFF();
|
|
for (auto &I : MachOUniquingMap)
|
|
I.second->~MCSectionMachO();
|
|
|
|
UsedNames.clear();
|
|
Symbols.clear();
|
|
Allocator.Reset();
|
|
Instances.clear();
|
|
CompilationDir.clear();
|
|
MainFileName.clear();
|
|
MCDwarfLineTablesCUMap.clear();
|
|
SectionsForRanges.clear();
|
|
MCGenDwarfLabelEntries.clear();
|
|
DwarfDebugFlags = StringRef();
|
|
DwarfCompileUnitID = 0;
|
|
CurrentDwarfLoc = MCDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0);
|
|
|
|
MachOUniquingMap.clear();
|
|
ELFUniquingMap.clear();
|
|
COFFUniquingMap.clear();
|
|
|
|
NextID.clear();
|
|
AllowTemporaryLabels = true;
|
|
DwarfLocSeen = false;
|
|
GenDwarfForAssembly = false;
|
|
GenDwarfFileNumber = 0;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Symbol Manipulation
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
MCSymbol *MCContext::getOrCreateSymbol(const Twine &Name) {
|
|
SmallString<128> NameSV;
|
|
StringRef NameRef = Name.toStringRef(NameSV);
|
|
|
|
assert(!NameRef.empty() && "Normal symbols cannot be unnamed!");
|
|
|
|
MCSymbol *&Sym = Symbols[NameRef];
|
|
if (!Sym)
|
|
Sym = createSymbol(NameRef, false);
|
|
|
|
return Sym;
|
|
}
|
|
|
|
MCSymbolELF *MCContext::getOrCreateSectionSymbol(const MCSectionELF &Section) {
|
|
MCSymbolELF *&Sym = SectionSymbols[&Section];
|
|
if (Sym)
|
|
return Sym;
|
|
|
|
StringRef Name = Section.getSectionName();
|
|
|
|
MCSymbol *&OldSym = Symbols[Name];
|
|
if (OldSym && OldSym->isUndefined()) {
|
|
Sym = cast<MCSymbolELF>(OldSym);
|
|
return Sym;
|
|
}
|
|
|
|
auto NameIter = UsedNames.insert(std::make_pair(Name, true)).first;
|
|
Sym = new (&*NameIter, *this) MCSymbolELF(&*NameIter, /*isTemporary*/ false);
|
|
|
|
if (!OldSym)
|
|
OldSym = Sym;
|
|
|
|
return Sym;
|
|
}
|
|
|
|
MCSymbol *MCContext::getOrCreateFrameAllocSymbol(StringRef FuncName,
|
|
unsigned Idx) {
|
|
return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
|
|
"$frame_escape_" + Twine(Idx));
|
|
}
|
|
|
|
MCSymbol *MCContext::getOrCreateParentFrameOffsetSymbol(StringRef FuncName) {
|
|
return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + FuncName +
|
|
"$parent_frame_offset");
|
|
}
|
|
|
|
MCSymbol *MCContext::getOrCreateLSDASymbol(StringRef FuncName) {
|
|
return getOrCreateSymbol(Twine(MAI->getPrivateGlobalPrefix()) + "__ehtable$" +
|
|
FuncName);
|
|
}
|
|
|
|
MCSymbol *MCContext::createSymbolImpl(const StringMapEntry<bool> *Name,
|
|
bool IsTemporary) {
|
|
if (MOFI) {
|
|
switch (MOFI->getObjectFileType()) {
|
|
case MCObjectFileInfo::IsCOFF:
|
|
return new (Name, *this) MCSymbolCOFF(Name, IsTemporary);
|
|
case MCObjectFileInfo::IsELF:
|
|
return new (Name, *this) MCSymbolELF(Name, IsTemporary);
|
|
case MCObjectFileInfo::IsMachO:
|
|
return new (Name, *this) MCSymbolMachO(Name, IsTemporary);
|
|
}
|
|
}
|
|
return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name,
|
|
IsTemporary);
|
|
}
|
|
|
|
MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix) {
|
|
// Determine whether this is an user writter assembler temporary or normal
|
|
// label, if used.
|
|
bool IsTemporary = false;
|
|
if (AllowTemporaryLabels)
|
|
IsTemporary = Name.startswith(MAI->getPrivateGlobalPrefix());
|
|
|
|
if (IsTemporary && !UseNamesOnTempLabels)
|
|
return createSymbolImpl(nullptr, true);
|
|
|
|
SmallString<128> NewName = Name;
|
|
bool AddSuffix = AlwaysAddSuffix;
|
|
unsigned &NextUniqueID = NextID[Name];
|
|
for (;;) {
|
|
if (AddSuffix) {
|
|
NewName.resize(Name.size());
|
|
raw_svector_ostream(NewName) << NextUniqueID++;
|
|
}
|
|
auto NameEntry = UsedNames.insert(std::make_pair(NewName, true));
|
|
if (NameEntry.second) {
|
|
// Ok, we found a name. Have the MCSymbol object itself refer to the copy
|
|
// of the string that is embedded in the UsedNames entry.
|
|
return createSymbolImpl(&*NameEntry.first, IsTemporary);
|
|
}
|
|
assert(IsTemporary && "Cannot rename non-temporary symbols");
|
|
AddSuffix = true;
|
|
}
|
|
llvm_unreachable("Infinite loop");
|
|
}
|
|
|
|
MCSymbol *MCContext::createTempSymbol(const Twine &Name, bool AlwaysAddSuffix) {
|
|
SmallString<128> NameSV;
|
|
raw_svector_ostream(NameSV) << MAI->getPrivateGlobalPrefix() << Name;
|
|
return createSymbol(NameSV, AlwaysAddSuffix);
|
|
}
|
|
|
|
MCSymbol *MCContext::createLinkerPrivateTempSymbol() {
|
|
SmallString<128> NameSV;
|
|
raw_svector_ostream(NameSV) << MAI->getLinkerPrivateGlobalPrefix() << "tmp";
|
|
return createSymbol(NameSV, true);
|
|
}
|
|
|
|
MCSymbol *MCContext::createTempSymbol() {
|
|
return createTempSymbol("tmp", true);
|
|
}
|
|
|
|
unsigned MCContext::NextInstance(unsigned LocalLabelVal) {
|
|
MCLabel *&Label = Instances[LocalLabelVal];
|
|
if (!Label)
|
|
Label = new (*this) MCLabel(0);
|
|
return Label->incInstance();
|
|
}
|
|
|
|
unsigned MCContext::GetInstance(unsigned LocalLabelVal) {
|
|
MCLabel *&Label = Instances[LocalLabelVal];
|
|
if (!Label)
|
|
Label = new (*this) MCLabel(0);
|
|
return Label->getInstance();
|
|
}
|
|
|
|
MCSymbol *MCContext::getOrCreateDirectionalLocalSymbol(unsigned LocalLabelVal,
|
|
unsigned Instance) {
|
|
MCSymbol *&Sym = LocalSymbols[std::make_pair(LocalLabelVal, Instance)];
|
|
if (!Sym)
|
|
Sym = createTempSymbol();
|
|
return Sym;
|
|
}
|
|
|
|
MCSymbol *MCContext::createDirectionalLocalSymbol(unsigned LocalLabelVal) {
|
|
unsigned Instance = NextInstance(LocalLabelVal);
|
|
return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance);
|
|
}
|
|
|
|
MCSymbol *MCContext::getDirectionalLocalSymbol(unsigned LocalLabelVal,
|
|
bool Before) {
|
|
unsigned Instance = GetInstance(LocalLabelVal);
|
|
if (!Before)
|
|
++Instance;
|
|
return getOrCreateDirectionalLocalSymbol(LocalLabelVal, Instance);
|
|
}
|
|
|
|
MCSymbol *MCContext::lookupSymbol(const Twine &Name) const {
|
|
SmallString<128> NameSV;
|
|
StringRef NameRef = Name.toStringRef(NameSV);
|
|
return Symbols.lookup(NameRef);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Section Management
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
MCSectionMachO *MCContext::getMachOSection(StringRef Segment, StringRef Section,
|
|
unsigned TypeAndAttributes,
|
|
unsigned Reserved2, SectionKind Kind,
|
|
const char *BeginSymName) {
|
|
|
|
// We unique sections by their segment/section pair. The returned section
|
|
// may not have the same flags as the requested section, if so this should be
|
|
// diagnosed by the client as an error.
|
|
|
|
// Form the name to look up.
|
|
SmallString<64> Name;
|
|
Name += Segment;
|
|
Name.push_back(',');
|
|
Name += Section;
|
|
|
|
// Do the lookup, if we have a hit, return it.
|
|
MCSectionMachO *&Entry = MachOUniquingMap[Name];
|
|
if (Entry)
|
|
return Entry;
|
|
|
|
MCSymbol *Begin = nullptr;
|
|
if (BeginSymName)
|
|
Begin = createTempSymbol(BeginSymName, false);
|
|
|
|
// Otherwise, return a new section.
|
|
return Entry = new (*this) MCSectionMachO(Segment, Section, TypeAndAttributes,
|
|
Reserved2, Kind, Begin);
|
|
}
|
|
|
|
void MCContext::renameELFSection(MCSectionELF *Section, StringRef Name) {
|
|
StringRef GroupName;
|
|
if (const MCSymbol *Group = Section->getGroup())
|
|
GroupName = Group->getName();
|
|
|
|
unsigned UniqueID = Section->getUniqueID();
|
|
ELFUniquingMap.erase(
|
|
ELFSectionKey{Section->getSectionName(), GroupName, UniqueID});
|
|
auto I = ELFUniquingMap.insert(std::make_pair(
|
|
ELFSectionKey{Name, GroupName, UniqueID},
|
|
Section))
|
|
.first;
|
|
StringRef CachedName = I->first.SectionName;
|
|
const_cast<MCSectionELF *>(Section)->setSectionName(CachedName);
|
|
}
|
|
|
|
MCSectionELF *MCContext::createELFRelSection(StringRef Name, unsigned Type,
|
|
unsigned Flags, unsigned EntrySize,
|
|
const MCSymbolELF *Group,
|
|
const MCSectionELF *Associated) {
|
|
StringMap<bool>::iterator I;
|
|
bool Inserted;
|
|
std::tie(I, Inserted) = ELFRelSecNames.insert(std::make_pair(Name, true));
|
|
|
|
return new (*this)
|
|
MCSectionELF(I->getKey(), Type, Flags, SectionKind::getReadOnly(),
|
|
EntrySize, Group, true, nullptr, Associated);
|
|
}
|
|
|
|
MCSectionELF *MCContext::getELFSection(StringRef Section, unsigned Type,
|
|
unsigned Flags, unsigned EntrySize,
|
|
StringRef Group, unsigned UniqueID,
|
|
const char *BeginSymName) {
|
|
MCSymbolELF *GroupSym = nullptr;
|
|
if (!Group.empty())
|
|
GroupSym = cast<MCSymbolELF>(getOrCreateSymbol(Group));
|
|
|
|
return getELFSection(Section, Type, Flags, EntrySize, GroupSym, UniqueID,
|
|
BeginSymName, nullptr);
|
|
}
|
|
|
|
MCSectionELF *MCContext::getELFSection(StringRef Section, unsigned Type,
|
|
unsigned Flags, unsigned EntrySize,
|
|
const MCSymbolELF *GroupSym,
|
|
unsigned UniqueID,
|
|
const char *BeginSymName,
|
|
const MCSectionELF *Associated) {
|
|
StringRef Group = "";
|
|
if (GroupSym)
|
|
Group = GroupSym->getName();
|
|
// Do the lookup, if we have a hit, return it.
|
|
auto IterBool = ELFUniquingMap.insert(
|
|
std::make_pair(ELFSectionKey{Section, Group, UniqueID}, nullptr));
|
|
auto &Entry = *IterBool.first;
|
|
if (!IterBool.second)
|
|
return Entry.second;
|
|
|
|
StringRef CachedName = Entry.first.SectionName;
|
|
|
|
SectionKind Kind;
|
|
if (Flags & ELF::SHF_EXECINSTR)
|
|
Kind = SectionKind::getText();
|
|
else
|
|
Kind = SectionKind::getReadOnly();
|
|
|
|
MCSymbol *Begin = nullptr;
|
|
if (BeginSymName)
|
|
Begin = createTempSymbol(BeginSymName, false);
|
|
|
|
MCSectionELF *Result =
|
|
new (*this) MCSectionELF(CachedName, Type, Flags, Kind, EntrySize,
|
|
GroupSym, UniqueID, Begin, Associated);
|
|
Entry.second = Result;
|
|
return Result;
|
|
}
|
|
|
|
MCSectionELF *MCContext::createELFGroupSection(const MCSymbolELF *Group) {
|
|
MCSectionELF *Result = new (*this)
|
|
MCSectionELF(".group", ELF::SHT_GROUP, 0, SectionKind::getReadOnly(), 4,
|
|
Group, ~0, nullptr, nullptr);
|
|
return Result;
|
|
}
|
|
|
|
MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
|
|
unsigned Characteristics,
|
|
SectionKind Kind,
|
|
StringRef COMDATSymName, int Selection,
|
|
const char *BeginSymName) {
|
|
MCSymbol *COMDATSymbol = nullptr;
|
|
if (!COMDATSymName.empty()) {
|
|
COMDATSymbol = getOrCreateSymbol(COMDATSymName);
|
|
COMDATSymName = COMDATSymbol->getName();
|
|
}
|
|
|
|
// Do the lookup, if we have a hit, return it.
|
|
COFFSectionKey T{Section, COMDATSymName, Selection};
|
|
auto IterBool = COFFUniquingMap.insert(std::make_pair(T, nullptr));
|
|
auto Iter = IterBool.first;
|
|
if (!IterBool.second)
|
|
return Iter->second;
|
|
|
|
MCSymbol *Begin = nullptr;
|
|
if (BeginSymName)
|
|
Begin = createTempSymbol(BeginSymName, false);
|
|
|
|
StringRef CachedName = Iter->first.SectionName;
|
|
MCSectionCOFF *Result = new (*this) MCSectionCOFF(
|
|
CachedName, Characteristics, COMDATSymbol, Selection, Kind, Begin);
|
|
|
|
Iter->second = Result;
|
|
return Result;
|
|
}
|
|
|
|
MCSectionCOFF *MCContext::getCOFFSection(StringRef Section,
|
|
unsigned Characteristics,
|
|
SectionKind Kind,
|
|
const char *BeginSymName) {
|
|
return getCOFFSection(Section, Characteristics, Kind, "", 0, BeginSymName);
|
|
}
|
|
|
|
MCSectionCOFF *MCContext::getCOFFSection(StringRef Section) {
|
|
COFFSectionKey T{Section, "", 0};
|
|
auto Iter = COFFUniquingMap.find(T);
|
|
if (Iter == COFFUniquingMap.end())
|
|
return nullptr;
|
|
return Iter->second;
|
|
}
|
|
|
|
MCSectionCOFF *MCContext::getAssociativeCOFFSection(MCSectionCOFF *Sec,
|
|
const MCSymbol *KeySym) {
|
|
// Return the normal section if we don't have to be associative.
|
|
if (!KeySym)
|
|
return Sec;
|
|
|
|
// Make an associative section with the same name and kind as the normal
|
|
// section.
|
|
unsigned Characteristics =
|
|
Sec->getCharacteristics() | COFF::IMAGE_SCN_LNK_COMDAT;
|
|
return getCOFFSection(Sec->getSectionName(), Characteristics, Sec->getKind(),
|
|
KeySym->getName(),
|
|
COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Dwarf Management
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// getDwarfFile - takes a file name an number to place in the dwarf file and
|
|
/// directory tables. If the file number has already been allocated it is an
|
|
/// error and zero is returned and the client reports the error, else the
|
|
/// allocated file number is returned. The file numbers may be in any order.
|
|
unsigned MCContext::getDwarfFile(StringRef Directory, StringRef FileName,
|
|
unsigned FileNumber, unsigned CUID) {
|
|
MCDwarfLineTable &Table = MCDwarfLineTablesCUMap[CUID];
|
|
return Table.getFile(Directory, FileName, FileNumber);
|
|
}
|
|
|
|
/// isValidDwarfFileNumber - takes a dwarf file number and returns true if it
|
|
/// currently is assigned and false otherwise.
|
|
bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) {
|
|
const SmallVectorImpl<MCDwarfFile> &MCDwarfFiles = getMCDwarfFiles(CUID);
|
|
if (FileNumber == 0 || FileNumber >= MCDwarfFiles.size())
|
|
return false;
|
|
|
|
return !MCDwarfFiles[FileNumber].Name.empty();
|
|
}
|
|
|
|
/// Remove empty sections from SectionStartEndSyms, to avoid generating
|
|
/// useless debug info for them.
|
|
void MCContext::finalizeDwarfSections(MCStreamer &MCOS) {
|
|
SectionsForRanges.remove_if(
|
|
[&](MCSection *Sec) { return !MCOS.mayHaveInstructions(*Sec); });
|
|
}
|
|
|
|
void MCContext::reportFatalError(SMLoc Loc, const Twine &Msg) const {
|
|
// If we have a source manager and a location, use it. Otherwise just
|
|
// use the generic report_fatal_error().
|
|
if (!SrcMgr || Loc == SMLoc())
|
|
report_fatal_error(Msg, false);
|
|
|
|
// Use the source manager to print the message.
|
|
SrcMgr->PrintMessage(Loc, SourceMgr::DK_Error, Msg);
|
|
|
|
// If we reached here, we are failing ungracefully. Run the interrupt handlers
|
|
// to make sure any special cleanups get done, in particular that we remove
|
|
// files registered with RemoveFileOnSignal.
|
|
sys::RunInterruptHandlers();
|
|
exit(1);
|
|
}
|