RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-01-26 20:57:15 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Move the Mangler from the AsmPrinter down to TLOF and clean up the

Browse Source 
TLOF API accordingly.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@281708 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Christopher 2016-09-16 07:33:15 +00:00
parent 2ce67fb75a
commit 88a23b6016
35 changed files with 210 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
include/llvm/CodeGen/TargetLoweringObjectFileImpl.h
View File

@ -54,14 +54,12 @@ public:
unsigned &Align) const override;
MCSection *getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
MCSection *getSectionForJumpTable(const Function &F, Mangler &Mang,
MCSection *getSectionForJumpTable(const Function &F,
const TargetMachine &TM) const override;
bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,
@ -69,14 +67,14 @@ public:
/// Return an MCExpr to use for a reference to the specified type info global
/// variable from exception handling information.
const MCExpr *
getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding,
Mangler &Mang, const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const override;
const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
unsigned Encoding,
const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const override;
// The symbol that gets passed to .cfi_personality.
MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV, Mangler &Mang,
MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV,
const TargetMachine &TM,
MachineModuleInfo *MMI) const override;
@ -87,7 +85,7 @@ public:
const MCSymbol *KeySym) const override;
const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
const GlobalValue *RHS, Mangler &Mang,
const GlobalValue *RHS,
const TargetMachine &TM) const override;
};
@ -103,14 +101,12 @@ public:
/// Emit the module flags that specify the garbage collection information.
void emitModuleFlags(MCStreamer &Streamer,
ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
Mangler &Mang, const TargetMachine &TM) const override;
const TargetMachine &TM) const override;
MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
MCSection *getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
@ -118,14 +114,14 @@ public:
unsigned &Align) const override;
/// The mach-o version of this method defaults to returning a stub reference.
const MCExpr *
getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding,
Mangler &Mang, const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const override;
const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
unsigned Encoding,
const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const override;
// The symbol that gets passed to .cfi_personality.
MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV, Mangler &Mang,
MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV,
const TargetMachine &TM,
MachineModuleInfo *MMI) const override;
@ -136,7 +132,7 @@ public:
MCStreamer &Streamer) const override;
void getNameWithPrefix(SmallVectorImpl<char> &OutName, const GlobalValue *GV,
Mangler &Mang, const TargetMachine &TM) const override;
const TargetMachine &TM) const override;
};
@ -149,32 +145,30 @@ public:
void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
MCSection *getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
void getNameWithPrefix(SmallVectorImpl<char> &OutName, const GlobalValue *GV,
Mangler &Mang, const TargetMachine &TM) const override;
const TargetMachine &TM) const override;
MCSection *getSectionForJumpTable(const Function &F, Mangler &Mang,
MCSection *getSectionForJumpTable(const Function &F,
const TargetMachine &TM) const override;
/// Emit Obj-C garbage collection and linker options. Only linker option
/// emission is implemented for COFF.
void emitModuleFlags(MCStreamer &Streamer,
ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
Mangler &Mang, const TargetMachine &TM) const override;
const TargetMachine &TM) const override;
MCSection *getStaticCtorSection(unsigned Priority,
const MCSymbol *KeySym) const override;
MCSection *getStaticDtorSection(unsigned Priority,
const MCSymbol *KeySym) const override;
void emitLinkerFlagsForGlobal(raw_ostream &OS, const GlobalValue *GV,
const Mangler &Mang) const override;
void emitLinkerFlagsForGlobal(raw_ostream &OS,
const GlobalValue *GV) const override;
};
} // end namespace llvm

56
include/llvm/Target/TargetLoweringObjectFile.h
View File

@ -37,6 +37,9 @@ namespace llvm {
class TargetLoweringObjectFile : public MCObjectFileInfo {
MCContext *Ctx;
/// Name-mangler for global names.
Mangler *Mang;
TargetLoweringObjectFile(
const TargetLoweringObjectFile&) = delete;
void operator=(const TargetLoweringObjectFile&) = delete;
@ -53,10 +56,11 @@ protected:
public:
MCContext &getContext() const { return *Ctx; }
Mangler &getMangler() const { return *Mang; }
TargetLoweringObjectFile()
: MCObjectFileInfo(), Ctx(nullptr), SupportIndirectSymViaGOTPCRel(false),
SupportGOTPCRelWithOffset(true) {}
: MCObjectFileInfo(), Ctx(nullptr), Mang(nullptr),
SupportIndirectSymViaGOTPCRel(false), SupportGOTPCRelWithOffset(true) {}
virtual ~TargetLoweringObjectFile();
@ -71,7 +75,7 @@ public:
/// Emit the module flags that the platform cares about.
virtual void emitModuleFlags(MCStreamer &Streamer,
ArrayRef<Module::ModuleFlagEntry> Flags,
Mangler &Mang, const TargetMachine &TM) const {}
const TargetMachine &TM) const {}
/// Given a constant with the SectionKind, return a section that it should be
/// placed in.
@ -89,21 +93,21 @@ public:
/// variable or function definition. This should not be passed external (or
/// available externally) globals.
MCSection *SectionForGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang, const TargetMachine &TM) const;
const TargetMachine &TM) const;
/// This method computes the appropriate section to emit the specified global
/// variable or function definition. This should not be passed external (or
/// available externally) globals.
MCSection *SectionForGlobal(const GlobalValue *GV, Mangler &Mang,
MCSection *SectionForGlobal(const GlobalValue *GV,
const TargetMachine &TM) const {
return SectionForGlobal(GV, getKindForGlobal(GV, TM), Mang, TM);
return SectionForGlobal(GV, getKindForGlobal(GV, TM), TM);
}
virtual void getNameWithPrefix(SmallVectorImpl<char> &OutName,
const GlobalValue *GV, Mangler &Mang,
const GlobalValue *GV,
const TargetMachine &TM) const;
virtual MCSection *getSectionForJumpTable(const Function &F, Mangler &Mang,
virtual MCSection *getSectionForJumpTable(const Function &F,
const TargetMachine &TM) const;
virtual bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,
@ -114,37 +118,35 @@ public:
/// assume that GV->hasSection() is true.
virtual MCSection *
getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang, const TargetMachine &TM) const = 0;
const TargetMachine &TM) const = 0;
/// Allow the target to completely override section assignment of a global.
virtual const MCSection *getSpecialCasedSectionGlobals(const GlobalValue *GV,
SectionKind Kind,
Mangler &Mang) const {
virtual const MCSection *
getSpecialCasedSectionGlobals(const GlobalValue *GV, SectionKind Kind) const {
return nullptr;
}
/// Return an MCExpr to use for a reference to the specified global variable
/// from exception handling information.
virtual const MCExpr *
getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding,
Mangler &Mang, const TargetMachine &TM,
MachineModuleInfo *MMI, MCStreamer &Streamer) const;
virtual const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
unsigned Encoding,
const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const;
/// Return the MCSymbol for a private symbol with global value name as its
/// base, with the specified suffix.
MCSymbol *getSymbolWithGlobalValueBase(const GlobalValue *GV,
StringRef Suffix, Mangler &Mang,
StringRef Suffix,
const TargetMachine &TM) const;
// The symbol that gets passed to .cfi_personality.
virtual MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV,
Mangler &Mang,
const TargetMachine &TM,
MachineModuleInfo *MMI) const;
const MCExpr *
getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding,
MCStreamer &Streamer) const;
const MCExpr *getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding,
MCStreamer &Streamer) const;
virtual MCSection *getStaticCtorSection(unsigned Priority,
const MCSymbol *KeySym) const {
@ -160,9 +162,9 @@ public:
/// emitting the address in debug info.
virtual const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const;
virtual const MCExpr *
lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS,
Mangler &Mang, const TargetMachine &TM) const {
virtual const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
const GlobalValue *RHS,
const TargetMachine &TM) const {
return nullptr;
}
@ -187,12 +189,12 @@ public:
return nullptr;
}
virtual void emitLinkerFlagsForGlobal(raw_ostream &OS, const GlobalValue *GV,
const Mangler &Mang) const {}
virtual void emitLinkerFlagsForGlobal(raw_ostream &OS,
const GlobalValue *GV) const {}
protected:
virtual MCSection *SelectSectionForGlobal(const GlobalValue *GV,
SectionKind Kind, Mangler &Mang,
SectionKind Kind,
const TargetMachine &TM) const = 0;
};

26
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
View File

@ -184,8 +184,6 @@ bool AsmPrinter::doInitialization(Module &M) {
OutStreamer->InitSections(false);
Mang = new Mangler();
// Emit the version-min deplyment target directive if needed.
//
// FIXME: If we end up with a collection of these sorts of Darwin-specific
@ -340,11 +338,11 @@ void AsmPrinter::EmitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const {
void AsmPrinter::getNameWithPrefix(SmallVectorImpl<char> &Name,
const GlobalValue *GV) const {
TM.getNameWithPrefix(Name, GV, *Mang);
TM.getNameWithPrefix(Name, GV, getObjFileLowering().getMangler());
}
MCSymbol *AsmPrinter::getSymbol(const GlobalValue *GV) const {
return TM.getSymbol(GV, *Mang);
return TM.getSymbol(GV, getObjFileLowering().getMangler());
}
/// EmitGlobalVariable - Emit the specified global variable to the .s file.
@ -424,8 +422,7 @@ void AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
}
// Determine to which section this global should be emitted.
MCSection *TheSection =
getObjFileLowering().SectionForGlobal(GV, GVKind, *Mang, TM);
MCSection *TheSection = getObjFileLowering().SectionForGlobal(GV, GVKind, TM);
// If we have a bss global going to a section that supports the
// zerofill directive, do so here.
@ -483,7 +480,7 @@ void AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
if (GVKind.isThreadLocal() && MAI->hasMachoTBSSDirective()) {
// Emit the .tbss symbol
MCSymbol *MangSym =
OutContext.getOrCreateSymbol(GVSym->getName() + Twine("$tlv$init"));
OutContext.getOrCreateSymbol(GVSym->getName() + Twine("$tlv$init"));
if (GVKind.isThreadBSS()) {
TheSection = getObjFileLowering().getTLSBSSSection();
@ -550,8 +547,7 @@ void AsmPrinter::EmitFunctionHeader() {
// Print the 'header' of function.
const Function *F = MF->getFunction();
OutStreamer->SwitchSection(
getObjFileLowering().SectionForGlobal(F, *Mang, TM));
OutStreamer->SwitchSection(getObjFileLowering().SectionForGlobal(F, TM));
EmitVisibility(CurrentFnSym, F->getVisibility());
EmitLinkage(F, CurrentFnSym);
@ -1143,7 +1139,7 @@ bool AsmPrinter::doFinalization(Module &M) {
SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
M.getModuleFlagsMetadata(ModuleFlags);
if (!ModuleFlags.empty())
TLOF.emitModuleFlags(*OutStreamer, ModuleFlags, *Mang, TM);
TLOF.emitModuleFlags(*OutStreamer, ModuleFlags, TM);
if (TM.getTargetTriple().isOSBinFormatELF()) {
MachineModuleInfoELF &MMIELF = MMI->getObjFileInfo<MachineModuleInfoELF>();
@ -1246,7 +1242,6 @@ bool AsmPrinter::doFinalization(Module &M) {
// after everything else has gone out.
EmitEndOfAsmFile(M);
delete Mang; Mang = nullptr;
MMI = nullptr;
OutStreamer->Finish();
@ -1392,7 +1387,7 @@ void AsmPrinter::EmitJumpTableInfo() {
*F);
if (JTInDiffSection) {
// Drop it in the readonly section.
MCSection *ReadOnlySection = TLOF.getSectionForJumpTable(*F, *Mang, TM);
MCSection *ReadOnlySection = TLOF.getSectionForJumpTable(*F, TM);
OutStreamer->SwitchSection(ReadOnlySection);
}
@ -1831,8 +1826,8 @@ const MCExpr *AsmPrinter::lowerConstant(const Constant *CV) {
APInt RHSOffset;
if (IsConstantOffsetFromGlobal(CE->getOperand(1), RHSGV, RHSOffset,
getDataLayout())) {
const MCExpr *RelocExpr = getObjFileLowering().lowerRelativeReference(
LHSGV, RHSGV, *Mang, TM);
const MCExpr *RelocExpr =
getObjFileLowering().lowerRelativeReference(LHSGV, RHSGV, TM);
if (!RelocExpr)
RelocExpr = MCBinaryExpr::createSub(
MCSymbolRefExpr::create(getSymbol(LHSGV), Ctx),
@ -2373,8 +2368,7 @@ MCSymbol *AsmPrinter::GetJTSetSymbol(unsigned UID, unsigned MBBID) const {
MCSymbol *AsmPrinter::getSymbolWithGlobalValueBase(const GlobalValue *GV,
StringRef Suffix) const {
return getObjFileLowering().getSymbolWithGlobalValueBase(GV, Suffix, *Mang,
TM);
return getObjFileLowering().getSymbolWithGlobalValueBase(GV, Suffix, TM);
}
/// Return the MCSymbol for the specified ExternalSymbol.

3
lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
View File

@ -138,8 +138,7 @@ void AsmPrinter::EmitTTypeReference(const GlobalValue *GV,
const TargetLoweringObjectFile &TLOF = getObjFileLowering();
const MCExpr *Exp =
TLOF.getTTypeGlobalReference(GV, Encoding, *Mang, TM, MMI,
*OutStreamer);
TLOF.getTTypeGlobalReference(GV, Encoding, TM, MMI, *OutStreamer);
OutStreamer->EmitValue(Exp, GetSizeOfEncodedValue(Encoding));
} else
OutStreamer->EmitIntValue(0, GetSizeOfEncodedValue(Encoding));

3
lib/CodeGen/AsmPrinter/DwarfCFIException.cpp
View File

@ -160,8 +160,7 @@ void DwarfCFIException::beginFragment(const MachineBasicBlock *MBB,
const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
unsigned PerEncoding = TLOF.getPersonalityEncoding();
const MCSymbol *Sym =
TLOF.getCFIPersonalitySymbol(P, *Asm->Mang, Asm->TM, MMI);
const MCSymbol *Sym = TLOF.getCFIPersonalitySymbol(P, Asm->TM, MMI);
Asm->OutStreamer->EmitCFIPersonality(Sym, PerEncoding);
// Provide LSDA information.

2
lib/CodeGen/AsmPrinter/WinException.cpp
View File

@ -204,7 +204,7 @@ void WinException::beginFunclet(const MachineBasicBlock &MBB,
if (F->hasPersonalityFn())
PerFn = dyn_cast<Function>(F->getPersonalityFn()->stripPointerCasts());
const MCSymbol *PersHandlerSym =
TLOF.getCFIPersonalitySymbol(PerFn, *Asm->Mang, Asm->TM, MMI);
TLOF.getCFIPersonalitySymbol(PerFn, Asm->TM, MMI);
// Classify the personality routine so that we may reason about it.
EHPersonality Per = EHPersonality::Unknown;

109
lib/CodeGen/TargetLoweringObjectFileImpl.cpp
View File

@ -50,14 +50,14 @@ using namespace dwarf;
//===----------------------------------------------------------------------===//
MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol(
const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
const GlobalValue *GV, const TargetMachine &TM,
MachineModuleInfo *MMI) const {
unsigned Encoding = getPersonalityEncoding();
if ((Encoding & 0x80) == dwarf::DW_EH_PE_indirect)
return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
TM.getSymbol(GV, Mang)->getName());
TM.getSymbol(GV, getMangler())->getName());
if ((Encoding & 0x70) == dwarf::DW_EH_PE_absptr)
return TM.getSymbol(GV, Mang);
return TM.getSymbol(GV, getMangler());
report_fatal_error("We do not support this DWARF encoding yet!");
}
@ -84,20 +84,19 @@ void TargetLoweringObjectFileELF::emitPersonalityValue(
}
const MCExpr *TargetLoweringObjectFileELF::getTTypeGlobalReference(
const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
const TargetMachine &TM, MachineModuleInfo *MMI,
MCStreamer &Streamer) const {
const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
if (Encoding & dwarf::DW_EH_PE_indirect) {
MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", Mang, TM);
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM);
// Add information about the stub reference to ELFMMI so that the stub
// gets emitted by the asmprinter.
MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
if (!StubSym.getPointer()) {
MCSymbol *Sym = TM.getSymbol(GV, Mang);
MCSymbol *Sym = TM.getSymbol(GV, getMangler());
StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
}
@ -106,8 +105,8 @@ const MCExpr *TargetLoweringObjectFileELF::getTTypeGlobalReference(
Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
}
return TargetLoweringObjectFile::
getTTypeGlobalReference(GV, Encoding, Mang, TM, MMI, Streamer);
return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
MMI, Streamer);
}
static SectionKind
@ -205,8 +204,7 @@ static const Comdat *getELFComdat(const GlobalValue *GV) {
}
MCSection *TargetLoweringObjectFileELF::getExplicitSectionGlobal(
const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
StringRef SectionName = GV->getSection();
// Infer section flags from the section name if we can.
@ -310,8 +308,7 @@ selectELFSectionForGlobal(MCContext &Ctx, const GlobalValue *GV,
}
MCSection *TargetLoweringObjectFileELF::SelectSectionForGlobal(
const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
unsigned Flags = getELFSectionFlags(Kind);
// If we have -ffunction-section or -fdata-section then we should emit the
@ -325,12 +322,12 @@ MCSection *TargetLoweringObjectFileELF::SelectSectionForGlobal(
}
EmitUniqueSection |= GV->hasComdat();
return selectELFSectionForGlobal(getContext(), GV, Kind, Mang, TM,
return selectELFSectionForGlobal(getContext(), GV, Kind, getMangler(), TM,
EmitUniqueSection, Flags, &NextUniqueID);
}
MCSection *TargetLoweringObjectFileELF::getSectionForJumpTable(
const Function &F, Mangler &Mang, const TargetMachine &TM) const {
const Function &F, const TargetMachine &TM) const {
// If the function can be removed, produce a unique section so that
// the table doesn't prevent the removal.
const Comdat *C = F.getComdat();
@ -339,7 +336,7 @@ MCSection *TargetLoweringObjectFileELF::getSectionForJumpTable(
return ReadOnlySection;
return selectELFSectionForGlobal(getContext(), &F, SectionKind::getReadOnly(),
Mang, TM, EmitUniqueSection, ELF::SHF_ALLOC,
getMangler(), TM, EmitUniqueSection, ELF::SHF_ALLOC,
&NextUniqueID);
}
@ -423,7 +420,7 @@ MCSection *TargetLoweringObjectFileELF::getStaticDtorSection(
}
const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference(
const GlobalValue *LHS, const GlobalValue *RHS, Mangler &Mang,
const GlobalValue *LHS, const GlobalValue *RHS,
const TargetMachine &TM) const {
// We may only use a PLT-relative relocation to refer to unnamed_addr
// functions.
@ -437,9 +434,9 @@ const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference(
return nullptr;
return MCBinaryExpr::createSub(
MCSymbolRefExpr::create(TM.getSymbol(LHS, Mang), PLTRelativeVariantKind,
MCSymbolRefExpr::create(TM.getSymbol(LHS, getMangler()), PLTRelativeVariantKind,
getContext()),
MCSymbolRefExpr::create(TM.getSymbol(RHS, Mang), getContext()),
MCSymbolRefExpr::create(TM.getSymbol(RHS, getMangler()), getContext()),
getContext());
}
@ -490,10 +487,9 @@ void TargetLoweringObjectFileMachO::Initialize(MCContext &Ctx,
}
/// emitModuleFlags - Perform code emission for module flags.
void TargetLoweringObjectFileMachO::
emitModuleFlags(MCStreamer &Streamer,
ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
Mangler &Mang, const TargetMachine &TM) const {
void TargetLoweringObjectFileMachO::emitModuleFlags(
MCStreamer &Streamer, ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
const TargetMachine &TM) const {
unsigned VersionVal = 0;
unsigned ImageInfoFlags = 0;
MDNode *LinkerOptions = nullptr;
@ -567,8 +563,7 @@ static void checkMachOComdat(const GlobalValue *GV) {
}
MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal(
const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
// Parse the section specifier and create it if valid.
StringRef Segment, Section;
unsigned TAA = 0, StubSize = 0;
@ -609,8 +604,7 @@ MCSection *TargetLoweringObjectFileMachO::getExplicitSectionGlobal(
}
MCSection *TargetLoweringObjectFileMachO::SelectSectionForGlobal(
const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
checkMachOComdat(GV);
// Handle thread local data.
@ -695,23 +689,21 @@ MCSection *TargetLoweringObjectFileMachO::getSectionForConstant(
}
const MCExpr *TargetLoweringObjectFileMachO::getTTypeGlobalReference(
const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
const TargetMachine &TM, MachineModuleInfo *MMI,
MCStreamer &Streamer) const {
const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
// The mach-o version of this method defaults to returning a stub reference.
if (Encoding & DW_EH_PE_indirect) {
MachineModuleInfoMachO &MachOMMI =
MMI->getObjFileInfo<MachineModuleInfoMachO>();
MCSymbol *SSym =
getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", Mang, TM);
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
// Add information about the stub reference to MachOMMI so that the stub
// gets emitted by the asmprinter.
MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
if (!StubSym.getPointer()) {
MCSymbol *Sym = TM.getSymbol(GV, Mang);
MCSymbol *Sym = TM.getSymbol(GV, getMangler());
StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
}
@ -720,24 +712,24 @@ const MCExpr *TargetLoweringObjectFileMachO::getTTypeGlobalReference(
Encoding & ~dwarf::DW_EH_PE_indirect, Streamer);
}
return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, Mang,
TM, MMI, Streamer);
return TargetLoweringObjectFile::getTTypeGlobalReference(GV, Encoding, TM,
MMI, Streamer);
}
MCSymbol *TargetLoweringObjectFileMachO::getCFIPersonalitySymbol(
const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
const GlobalValue *GV, const TargetMachine &TM,
MachineModuleInfo *MMI) const {
// The mach-o version of this method defaults to returning a stub reference.
MachineModuleInfoMachO &MachOMMI =
MMI->getObjFileInfo<MachineModuleInfoMachO>();
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", Mang, TM);
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr", TM);
// Add information about the stub reference to MachOMMI so that the stub
// gets emitted by the asmprinter.
MachineModuleInfoImpl::StubValueTy &StubSym = MachOMMI.getGVStubEntry(SSym);
if (!StubSym.getPointer()) {
MCSymbol *Sym = TM.getSymbol(GV, Mang);
MCSymbol *Sym = TM.getSymbol(GV, getMangler());
StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
}
@ -818,13 +810,13 @@ static bool canUsePrivateLabel(const MCAsmInfo &AsmInfo,
}
void TargetLoweringObjectFileMachO::getNameWithPrefix(
SmallVectorImpl<char> &OutName, const GlobalValue *GV, Mangler &Mang,
SmallVectorImpl<char> &OutName, const GlobalValue *GV,
const TargetMachine &TM) const {
SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM);
const MCSection *TheSection = SectionForGlobal(GV, GVKind, Mang, TM);
const MCSection *TheSection = SectionForGlobal(GV, GVKind, TM);
bool CannotUsePrivateLabel =
!canUsePrivateLabel(*TM.getMCAsmInfo(), *TheSection);
Mang.getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
}
//===----------------------------------------------------------------------===//
@ -911,8 +903,7 @@ static int getSelectionForCOFF(const GlobalValue *GV) {
}
MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal(
const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
int Selection = 0;
unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
StringRef Name = GV->getSection();
@ -926,7 +917,7 @@ MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal(
ComdatGV = GV;
if (!ComdatGV->hasPrivateLinkage()) {
MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang);
MCSymbol *Sym = TM.getSymbol(ComdatGV, getMangler());
COMDATSymName = Sym->getName();
Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
} else {
@ -951,8 +942,7 @@ static const char *getCOFFSectionNameForUniqueGlobal(SectionKind Kind) {
}
MCSection *TargetLoweringObjectFileCOFF::SelectSectionForGlobal(
const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
// If we have -ffunction-sections then we should emit the global value to a
// uniqued section specifically for it.
bool EmitUniquedSection;
@ -980,13 +970,13 @@ MCSection *TargetLoweringObjectFileCOFF::SelectSectionForGlobal(
UniqueID = NextUniqueID++;
if (!ComdatGV->hasPrivateLinkage()) {
MCSymbol *Sym = TM.getSymbol(ComdatGV, Mang);
MCSymbol *Sym = TM.getSymbol(ComdatGV, getMangler());
StringRef COMDATSymName = Sym->getName();
return getContext().getCOFFSection(Name, Characteristics, Kind,
COMDATSymName, Selection, UniqueID);
} else {
SmallString<256> TmpData;
Mang.getNameWithPrefix(TmpData, GV, /*CannotUsePrivateLabel=*/true);
getMangler().getNameWithPrefix(TmpData, GV, /*CannotUsePrivateLabel=*/true);
return getContext().getCOFFSection(Name, Characteristics, Kind, TmpData,
Selection, UniqueID);
}
@ -1011,7 +1001,7 @@ MCSection *TargetLoweringObjectFileCOFF::SelectSectionForGlobal(
}
void TargetLoweringObjectFileCOFF::getNameWithPrefix(
SmallVectorImpl<char> &OutName, const GlobalValue *GV, Mangler &Mang,
SmallVectorImpl<char> &OutName, const GlobalValue *GV,
const TargetMachine &TM) const {
bool CannotUsePrivateLabel = false;
if (GV->hasPrivateLinkage() &&
@ -1019,11 +1009,11 @@ void TargetLoweringObjectFileCOFF::getNameWithPrefix(
(isa<GlobalVariable>(GV) && TM.getDataSections())))
CannotUsePrivateLabel = true;
Mang.getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
getMangler().getNameWithPrefix(OutName, GV, CannotUsePrivateLabel);
}
MCSection *TargetLoweringObjectFileCOFF::getSectionForJumpTable(
const Function &F, Mangler &Mang, const TargetMachine &TM) const {
const Function &F, const TargetMachine &TM) const {
// If the function can be removed, produce a unique section so that
// the table doesn't prevent the removal.
const Comdat *C = F.getComdat();
@ -1035,7 +1025,7 @@ MCSection *TargetLoweringObjectFileCOFF::getSectionForJumpTable(
if (F.hasPrivateLinkage())
return ReadOnlySection;
MCSymbol *Sym = TM.getSymbol(&F, Mang);
MCSymbol *Sym = TM.getSymbol(&F, getMangler());
StringRef COMDATSymName = Sym->getName();
SectionKind Kind = SectionKind::getReadOnly();
@ -1048,10 +1038,9 @@ MCSection *TargetLoweringObjectFileCOFF::getSectionForJumpTable(
COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
}
void TargetLoweringObjectFileCOFF::
emitModuleFlags(MCStreamer &Streamer,
ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
Mangler &Mang, const TargetMachine &TM) const {
void TargetLoweringObjectFileCOFF::emitModuleFlags(
MCStreamer &Streamer, ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
const TargetMachine &TM) const {
MDNode *LinkerOptions = nullptr;
for (const auto &MFE : ModuleFlags) {
@ -1115,7 +1104,7 @@ MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection(
}
void TargetLoweringObjectFileCOFF::emitLinkerFlagsForGlobal(
raw_ostream &OS, const GlobalValue *GV, const Mangler &Mang) const {
raw_ostream &OS, const GlobalValue *GV) const {
if (!GV->hasDLLExportStorageClass() || GV->isDeclaration())
return;
@ -1129,14 +1118,14 @@ void TargetLoweringObjectFileCOFF::emitLinkerFlagsForGlobal(
if (TT.isWindowsGNUEnvironment() || TT.isWindowsCygwinEnvironment()) {
std::string Flag;
raw_string_ostream FlagOS(Flag);
Mang.getNameWithPrefix(FlagOS, GV, false);
getMangler().getNameWithPrefix(FlagOS, GV, false);
FlagOS.flush();
if (Flag[0] == GV->getParent()->getDataLayout().getGlobalPrefix())
OS << Flag.substr(1);
else
OS << Flag;
} else {
Mang.getNameWithPrefix(OS, GV, false);
getMangler().getNameWithPrefix(OS, GV, false);
}
if (!GV->getValueType()->isFunctionTy()) {

5
lib/LTO/LTOModule.cpp
View File

@ -19,7 +19,6 @@
#include "llvm/IR/Constants.h"
#include "llvm/IR/DiagnosticPrinter.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Mangler.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h"
#include "llvm/MC/MCExpr.h"
@ -648,12 +647,10 @@ void LTOModule::parseMetadata() {
}
// Globals
Mangler Mang;
for (const NameAndAttributes &Sym : _symbols) {
if (!Sym.symbol)
continue;
_target->getObjFileLowering()->emitLinkerFlagsForGlobal(OS, Sym.symbol,
Mang);
_target->getObjFileLowering()->emitLinkerFlagsForGlobal(OS, Sym.symbol);
}
// Add other interesting metadata here.

13
lib/Target/AArch64/AArch64TargetObjectFile.cpp
View File

@ -30,15 +30,14 @@ AArch64_MachoTargetObjectFile::AArch64_MachoTargetObjectFile()
}
const MCExpr *AArch64_MachoTargetObjectFile::getTTypeGlobalReference(
const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
const TargetMachine &TM, MachineModuleInfo *MMI,
MCStreamer &Streamer) const {
const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
// On Darwin, we can reference dwarf symbols with foo@GOT-., which
// is an indirect pc-relative reference. The default implementation
// won't reference using the GOT, so we need this target-specific
// version.
if (Encoding & (DW_EH_PE_indirect | DW_EH_PE_pcrel)) {
const MCSymbol *Sym = TM.getSymbol(GV, Mang);
const MCSymbol *Sym = TM.getSymbol(GV, getMangler());
const MCExpr *Res =
MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_GOT, getContext());
MCSymbol *PCSym = getContext().createTempSymbol();
@ -48,13 +47,13 @@ const MCExpr *AArch64_MachoTargetObjectFile::getTTypeGlobalReference(
}
return TargetLoweringObjectFileMachO::getTTypeGlobalReference(
GV, Encoding, Mang, TM, MMI, Streamer);
GV, Encoding, TM, MMI, Streamer);
}
MCSymbol *AArch64_MachoTargetObjectFile::getCFIPersonalitySymbol(
const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
const GlobalValue *GV, const TargetMachine &TM,
MachineModuleInfo *MMI) const {
return TM.getSymbol(GV, Mang);
return TM.getSymbol(GV, getMangler());
}
const MCExpr *AArch64_MachoTargetObjectFile::getIndirectSymViaGOTPCRel(

4
lib/Target/AArch64/AArch64TargetObjectFile.h
View File

@ -27,12 +27,12 @@ public:
AArch64_MachoTargetObjectFile();
const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
unsigned Encoding, Mangler &Mang,
unsigned Encoding,
const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const override;
MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV, Mangler &Mang,
MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV,
const TargetMachine &TM,
MachineModuleInfo *MMI) const override;

8
lib/Target/AMDGPU/AMDGPUTargetObjectFile.cpp
View File

@ -20,12 +20,10 @@ using namespace llvm;
// Generic Object File
//===----------------------------------------------------------------------===//
MCSection *AMDGPUTargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const {
MCSection *AMDGPUTargetObjectFile::SelectSectionForGlobal(
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
if (Kind.isReadOnly() && AMDGPU::isReadOnlySegment(GV))
return TextSection;
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, Mang, TM);
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, TM);
}

1
lib/Target/AMDGPU/AMDGPUTargetObjectFile.h
View File

@ -24,7 +24,6 @@ namespace llvm {
class AMDGPUTargetObjectFile : public TargetLoweringObjectFileELF {
public:
MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
};

6
lib/Target/ARM/ARMAsmPrinter.cpp
View File

@ -543,11 +543,11 @@ void ARMAsmPrinter::EmitEndOfAsmFile(Module &M) {
raw_string_ostream OS(Flags);
for (const auto &Function : M)
TLOF.emitLinkerFlagsForGlobal(OS, &Function, *Mang);
TLOF.emitLinkerFlagsForGlobal(OS, &Function);
for (const auto &Global : M.globals())
TLOF.emitLinkerFlagsForGlobal(OS, &Global, *Mang);
TLOF.emitLinkerFlagsForGlobal(OS, &Global);
for (const auto &Alias : M.aliases())
TLOF.emitLinkerFlagsForGlobal(OS, &Alias, *Mang);
TLOF.emitLinkerFlagsForGlobal(OS, &Alias);
OS.flush();

9
lib/Target/ARM/ARMTargetObjectFile.cpp
View File

@ -41,16 +41,15 @@ void ARMElfTargetObjectFile::Initialize(MCContext &Ctx,
}
const MCExpr *ARMElfTargetObjectFile::getTTypeGlobalReference(
const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
const TargetMachine &TM, MachineModuleInfo *MMI,
MCStreamer &Streamer) const {
const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
if (TM.getMCAsmInfo()->getExceptionHandlingType() != ExceptionHandling::ARM)
return TargetLoweringObjectFileELF::getTTypeGlobalReference(
GV, Encoding, Mang, TM, MMI, Streamer);
GV, Encoding, TM, MMI, Streamer);
assert(Encoding == DW_EH_PE_absptr && "Can handle absptr encoding only");
return MCSymbolRefExpr::create(TM.getSymbol(GV, Mang),
return MCSymbolRefExpr::create(TM.getSymbol(GV, getMangler()),
MCSymbolRefExpr::VK_ARM_TARGET2, getContext());
}

10
lib/Target/ARM/ARMTargetObjectFile.h
View File

@ -28,11 +28,11 @@ public:
void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
const MCExpr *
getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding,
Mangler &Mang, const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const override;
const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
unsigned Encoding,
const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const override;
/// \brief Describe a TLS variable address within debug info.
const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const override;

25
lib/Target/Hexagon/HexagonTargetObjectFile.cpp
View File

@ -100,10 +100,8 @@ void HexagonTargetObjectFile::Initialize(MCContext &Ctx,
ELF::SHF_HEX_GPREL);
}
MCSection *HexagonTargetObjectFile::SelectSectionForGlobal(
const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
TRACE("[SelectSectionForGlobal] GV(" << GV->getName() << ") ");
TRACE("input section(" << GV->getSection() << ") ");
@ -118,7 +116,7 @@ MCSection *HexagonTargetObjectFile::SelectSectionForGlobal(
<< (Kind.isBSSLocal() ? "kind_bss_local " : "" ));
if (isGlobalInSmallSection(GV, TM))
return selectSmallSectionForGlobal(GV, Kind, Mang, TM);
return selectSmallSectionForGlobal(GV, Kind, TM);
if (Kind.isCommon()) {
// This is purely for LTO+Linker Script because commons don't really have a
@ -130,14 +128,11 @@ MCSection *HexagonTargetObjectFile::SelectSectionForGlobal(
TRACE("default_ELF_section\n");
// Otherwise, we work the same as ELF.
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind,
Mang, TM);
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, TM);
}
MCSection *HexagonTargetObjectFile::getExplicitSectionGlobal(
const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
TRACE("[getExplicitSectionGlobal] GV(" << GV->getName() << ") from("
<< GV->getSection() << ") ");
TRACE((GV->hasPrivateLinkage() ? "private_linkage " : "")
@ -161,12 +156,11 @@ MCSection *HexagonTargetObjectFile::getExplicitSectionGlobal(
}
if (isGlobalInSmallSection(GV, TM))
return selectSmallSectionForGlobal(GV, Kind, Mang, TM);
return selectSmallSectionForGlobal(GV, Kind, TM);
// Otherwise, we work the same as ELF.
TRACE("default_ELF_section\n");
return TargetLoweringObjectFileELF::getExplicitSectionGlobal(GV, Kind,
Mang, TM);
return TargetLoweringObjectFileELF::getExplicitSectionGlobal(GV, Kind, TM);
}
@ -302,10 +296,8 @@ unsigned HexagonTargetObjectFile::getSmallestAddressableSize(const Type *Ty,
return 0;
}
MCSection *HexagonTargetObjectFile::selectSmallSectionForGlobal(
const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
const Type *GTy = GV->getType()->getElementType();
unsigned Size = getSmallestAddressableSize(GTy, GV, TM);
@ -386,6 +378,5 @@ MCSection *HexagonTargetObjectFile::selectSmallSectionForGlobal(
TRACE("default ELF section\n");
// Otherwise, we work the same as ELF.
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind,
Mang, TM);
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, TM);
}

7
lib/Target/Hexagon/HexagonTargetObjectFile.h
View File

@ -20,10 +20,10 @@ namespace llvm {
void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang, const TargetMachine &TM) const override;
const TargetMachine &TM) const override;
MCSection *getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang, const TargetMachine &TM) const override;
const TargetMachine &TM) const override;
bool isGlobalInSmallSection(const GlobalValue *GV, const TargetMachine &TM)
const;
@ -40,7 +40,8 @@ namespace llvm {
const TargetMachine &TM) const;
MCSection *selectSmallSectionForGlobal(const GlobalValue *GV,
SectionKind Kind, Mangler &Mang, const TargetMachine &TM) const;
SectionKind Kind,
const TargetMachine &TM) const;
};
} // namespace llvm

9
lib/Target/Lanai/LanaiTargetObjectFile.cpp
View File

@ -90,10 +90,8 @@ bool LanaiTargetObjectFile::isGlobalInSmallSectionImpl(
GV->getParent()->getDataLayout().getTypeAllocSize(Ty));
}
MCSection *
LanaiTargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
MCSection *LanaiTargetObjectFile::SelectSectionForGlobal(
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
// Handle Small Section classification here.
if (Kind.isBSS() && isGlobalInSmallSection(GV, TM, Kind))
return SmallBSSSection;
@ -101,8 +99,7 @@ LanaiTargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
return SmallDataSection;
// Otherwise, we work the same as ELF.
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, Mang,
TM);
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, TM);
}
/// Return true if this constant should be placed into small data section.

1
lib/Target/Lanai/LanaiTargetObjectFile.h
View File

@ -31,7 +31,6 @@ public:
const TargetMachine &TM) const;
MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
/// Return true if this constant should be placed into small data section.

8
lib/Target/Mips/MipsTargetObjectFile.cpp
View File

@ -113,10 +113,8 @@ IsGlobalInSmallSectionImpl(const GlobalValue *GV,
GV->getParent()->getDataLayout().getTypeAllocSize(Ty));
}
MCSection *
MipsTargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
MCSection *MipsTargetObjectFile::SelectSectionForGlobal(
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
// TODO: Could also support "weak" symbols as well with ".gnu.linkonce.s.*"
// sections?
@ -127,7 +125,7 @@ MipsTargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
return SmallDataSection;
// Otherwise, we work the same as ELF.
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, Mang,TM);
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, TM);
}
/// Return true if this constant should be placed into small data section.

1
lib/Target/Mips/MipsTargetObjectFile.h
View File

@ -32,7 +32,6 @@ class MipsTargetMachine;
const TargetMachine &TM) const;
MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
/// Return true if this constant should be placed into small data section.

6
lib/Target/NVPTX/NVPTXISelLowering.cpp
View File

@ -4576,9 +4576,7 @@ NVPTXTargetObjectFile::~NVPTXTargetObjectFile() {
delete static_cast<NVPTXSection *>(DwarfMacinfoSection);
}
MCSection *
NVPTXTargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
MCSection *NVPTXTargetObjectFile::SelectSectionForGlobal(
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
return getDataSection();
}

2
lib/Target/NVPTX/NVPTXTargetObjectFile.h
View File

@ -92,13 +92,11 @@ public:
}
MCSection *getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override {
return DataSection;
}
MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
};

6
lib/Target/PowerPC/PPCTargetObjectFile.cpp
View File

@ -23,8 +23,7 @@ Initialize(MCContext &Ctx, const TargetMachine &TM) {
}
MCSection *PPC64LinuxTargetObjectFile::SelectSectionForGlobal(
const GlobalValue *GV, SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
// Here override ReadOnlySection to DataRelROSection for PPC64 SVR4 ABI
// when we have a constant that contains global relocations. This is
// necessary because of this ABI's handling of pointers to functions in
@ -46,8 +45,7 @@ MCSection *PPC64LinuxTargetObjectFile::SelectSectionForGlobal(
Kind = SectionKind::getReadOnlyWithRel();
}
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind,
Mang, TM);
return TargetLoweringObjectFileELF::SelectSectionForGlobal(GV, Kind, TM);
}
const MCExpr *PPC64LinuxTargetObjectFile::

1
lib/Target/PowerPC/PPCTargetObjectFile.h
View File

@ -23,7 +23,6 @@ namespace llvm {
void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
/// \brief Describe a TLS variable address within debug info.

13
lib/Target/Sparc/SparcTargetObjectFile.cpp
View File

@ -16,20 +16,19 @@
using namespace llvm;
const MCExpr *SparcELFTargetObjectFile::getTTypeGlobalReference(
const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
const TargetMachine &TM, MachineModuleInfo *MMI,
MCStreamer &Streamer) const {
const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
if (Encoding & dwarf::DW_EH_PE_pcrel) {
MachineModuleInfoELF &ELFMMI = MMI->getObjFileInfo<MachineModuleInfoELF>();
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", Mang, TM);
MCSymbol *SSym = getSymbolWithGlobalValueBase(GV, ".DW.stub", TM);
// Add information about the stub reference to ELFMMI so that the stub
// gets emitted by the asmprinter.
MachineModuleInfoImpl::StubValueTy &StubSym = ELFMMI.getGVStubEntry(SSym);
if (!StubSym.getPointer()) {
MCSymbol *Sym = TM.getSymbol(GV, Mang);
MCSymbol *Sym = TM.getSymbol(GV, getMangler());
StubSym = MachineModuleInfoImpl::StubValueTy(Sym, !GV->hasLocalLinkage());
}
@ -38,6 +37,6 @@ const MCExpr *SparcELFTargetObjectFile::getTTypeGlobalReference(
MCSymbolRefExpr::create(SSym, Ctx), Ctx);
}
return TargetLoweringObjectFileELF::getTTypeGlobalReference(
GV, Encoding, Mang, TM, MMI, Streamer);
return TargetLoweringObjectFileELF::getTTypeGlobalReference(GV, Encoding, TM,
MMI, Streamer);
}

10
lib/Target/Sparc/SparcTargetObjectFile.h
View File

@ -23,11 +23,11 @@ public:
TargetLoweringObjectFileELF()
{}
const MCExpr *
getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding,
Mangler &Mang, const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const override;
const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
unsigned Encoding,
const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const override;
};
} // end namespace llvm

35
lib/Target/TargetLoweringObjectFile.cpp
View File

@ -43,11 +43,13 @@ using namespace llvm;
void TargetLoweringObjectFile::Initialize(MCContext &ctx,
const TargetMachine &TM) {
Ctx = &ctx;
Mang = new Mangler();
InitMCObjectFileInfo(TM.getTargetTriple(), TM.isPositionIndependent(),
TM.getCodeModel(), *Ctx);
}
TargetLoweringObjectFile::~TargetLoweringObjectFile() {
delete Mang;
}
static bool isSuitableForBSS(const GlobalVariable *GV, bool NoZerosInBSS) {
@ -101,21 +103,20 @@ static bool IsNullTerminatedString(const Constant *C) {
}
MCSymbol *TargetLoweringObjectFile::getSymbolWithGlobalValueBase(
const GlobalValue *GV, StringRef Suffix, Mangler &Mang,
const TargetMachine &TM) const {
const GlobalValue *GV, StringRef Suffix, const TargetMachine &TM) const {
assert(!Suffix.empty());
SmallString<60> NameStr;
NameStr += GV->getParent()->getDataLayout().getPrivateGlobalPrefix();
TM.getNameWithPrefix(NameStr, GV, Mang);
TM.getNameWithPrefix(NameStr, GV, *Mang);
NameStr.append(Suffix.begin(), Suffix.end());
return Ctx->getOrCreateSymbol(NameStr);
}
MCSymbol *TargetLoweringObjectFile::getCFIPersonalitySymbol(
const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
const GlobalValue *GV, const TargetMachine &TM,
MachineModuleInfo *MMI) const {
return TM.getSymbol(GV, Mang);
return TM.getSymbol(GV, *Mang);
}
void TargetLoweringObjectFile::emitPersonalityValue(MCStreamer &Streamer,
@ -230,21 +231,18 @@ SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalValue *GV,
/// This method computes the appropriate section to emit the specified global
/// variable or function definition. This should not be passed external (or
/// available externally) globals.
MCSection *
TargetLoweringObjectFile::SectionForGlobal(const GlobalValue *GV,
SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
MCSection *TargetLoweringObjectFile::SectionForGlobal(
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
// Select section name.
if (GV->hasSection())
return getExplicitSectionGlobal(GV, Kind, Mang, TM);
return getExplicitSectionGlobal(GV, Kind, TM);
// Use default section depending on the 'type' of global
return SelectSectionForGlobal(GV, Kind, Mang, TM);
return SelectSectionForGlobal(GV, Kind, TM);
}
MCSection *TargetLoweringObjectFile::getSectionForJumpTable(
const Function &F, Mangler &Mang, const TargetMachine &TM) const {
const Function &F, const TargetMachine &TM) const {
unsigned Align = 0;
return getSectionForConstant(F.getParent()->getDataLayout(),
SectionKind::getReadOnly(), /*C=*/nullptr,
@ -284,11 +282,10 @@ MCSection *TargetLoweringObjectFile::getSectionForConstant(
/// reference to the specified global variable from exception
/// handling information.
const MCExpr *TargetLoweringObjectFile::getTTypeGlobalReference(
const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
const TargetMachine &TM, MachineModuleInfo *MMI,
MCStreamer &Streamer) const {
const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
const MCSymbolRefExpr *Ref =
MCSymbolRefExpr::create(TM.getSymbol(GV, Mang), getContext());
MCSymbolRefExpr::create(TM.getSymbol(GV, *Mang), getContext());
return getTTypeReference(Ref, Encoding, Streamer);
}
@ -320,7 +317,7 @@ const MCExpr *TargetLoweringObjectFile::getDebugThreadLocalSymbol(const MCSymbol
}
void TargetLoweringObjectFile::getNameWithPrefix(
SmallVectorImpl<char> &OutName, const GlobalValue *GV, Mangler &Mang,
SmallVectorImpl<char> &OutName, const GlobalValue *GV,
const TargetMachine &TM) const {
Mang.getNameWithPrefix(OutName, GV, /*CannotUsePrivateLabel=*/false);
Mang->getNameWithPrefix(OutName, GV, /*CannotUsePrivateLabel=*/false);
}

2
lib/Target/TargetMachine.cpp
View File

@ -208,7 +208,7 @@ void TargetMachine::getNameWithPrefix(SmallVectorImpl<char> &Name,
return;
}
const TargetLoweringObjectFile *TLOF = getObjFileLowering();
TLOF->getNameWithPrefix(Name, GV, Mang, *this);
TLOF->getNameWithPrefix(Name, GV, *this);
}
MCSymbol *TargetMachine::getSymbol(const GlobalValue *GV, Mangler &Mang) const {

6
lib/Target/X86/X86AsmPrinter.cpp
View File

@ -627,11 +627,11 @@ void X86AsmPrinter::EmitEndOfAsmFile(Module &M) {
raw_string_ostream FlagsOS(Flags);
for (const auto &Function : M)
TLOFCOFF.emitLinkerFlagsForGlobal(FlagsOS, &Function, *Mang);
TLOFCOFF.emitLinkerFlagsForGlobal(FlagsOS, &Function);
for (const auto &Global : M.globals())
TLOFCOFF.emitLinkerFlagsForGlobal(FlagsOS, &Global, *Mang);
TLOFCOFF.emitLinkerFlagsForGlobal(FlagsOS, &Global);
for (const auto &Alias : M.aliases())
TLOFCOFF.emitLinkerFlagsForGlobal(FlagsOS, &Alias, *Mang);
TLOFCOFF.emitLinkerFlagsForGlobal(FlagsOS, &Alias);
FlagsOS.flush();

20
lib/Target/X86/X86TargetObjectFile.cpp
View File

@ -24,14 +24,13 @@ using namespace llvm;
using namespace dwarf;
const MCExpr *X86_64MachoTargetObjectFile::getTTypeGlobalReference(
const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
const TargetMachine &TM, MachineModuleInfo *MMI,
MCStreamer &Streamer) const {
const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
MachineModuleInfo *MMI, MCStreamer &Streamer) const {
// On Darwin/X86-64, we can reference dwarf symbols with foo@GOTPCREL+4, which
// is an indirect pc-relative reference.
if ((Encoding & DW_EH_PE_indirect) && (Encoding & DW_EH_PE_pcrel)) {
const MCSymbol *Sym = TM.getSymbol(GV, Mang);
const MCSymbol *Sym = TM.getSymbol(GV, getMangler());
const MCExpr *Res =
MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_GOTPCREL, getContext());
const MCExpr *Four = MCConstantExpr::create(4, getContext());
@ -39,13 +38,13 @@ const MCExpr *X86_64MachoTargetObjectFile::getTTypeGlobalReference(
}
return TargetLoweringObjectFileMachO::getTTypeGlobalReference(
GV, Encoding, Mang, TM, MMI, Streamer);
GV, Encoding, TM, MMI, Streamer);
}
MCSymbol *X86_64MachoTargetObjectFile::getCFIPersonalitySymbol(
const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
const GlobalValue *GV, const TargetMachine &TM,
MachineModuleInfo *MMI) const {
return TM.getSymbol(GV, Mang);
return TM.getSymbol(GV, getMangler());
}
const MCExpr *X86_64MachoTargetObjectFile::getIndirectSymViaGOTPCRel(
@ -74,7 +73,7 @@ X86LinuxNaClTargetObjectFile::Initialize(MCContext &Ctx,
}
const MCExpr *X86WindowsTargetObjectFile::lowerRelativeReference(
const GlobalValue *LHS, const GlobalValue *RHS, Mangler &Mang,
const GlobalValue *LHS, const GlobalValue *RHS,
const TargetMachine &TM) const {
// Our symbols should exist in address space zero, cowardly no-op if
// otherwise.
@ -95,8 +94,9 @@ const MCExpr *X86WindowsTargetObjectFile::lowerRelativeReference(
cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection())
return nullptr;
return MCSymbolRefExpr::create(
TM.getSymbol(LHS, Mang), MCSymbolRefExpr::VK_COFF_IMGREL32, getContext());
return MCSymbolRefExpr::create(TM.getSymbol(LHS, getMangler()),
MCSymbolRefExpr::VK_COFF_IMGREL32,
getContext());
}
static std::string APIntToHexString(const APInt &AI) {

13
lib/Target/X86/X86TargetObjectFile.h
View File

@ -19,15 +19,15 @@ namespace llvm {
/// x86-64.
class X86_64MachoTargetObjectFile : public TargetLoweringObjectFileMachO {
public:
const MCExpr *
getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding,
Mangler &Mang, const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const override;
const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
unsigned Encoding,
const TargetMachine &TM,
MachineModuleInfo *MMI,
MCStreamer &Streamer) const override;
// getCFIPersonalitySymbol - The symbol that gets passed to
// .cfi_personality.
MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV, Mangler &Mang,
MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV,
const TargetMachine &TM,
MachineModuleInfo *MMI) const override;
@ -59,7 +59,6 @@ namespace llvm {
class X86WindowsTargetObjectFile : public TargetLoweringObjectFileCOFF {
const MCExpr *
lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS,
Mangler &Mang,
const TargetMachine &TM) const override;
/// \brief Given a mergeable constant with the specified size and relocation

3
lib/Target/XCore/XCoreAsmPrinter.cpp
View File

@ -115,8 +115,7 @@ void XCoreAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
return;
const DataLayout &DL = getDataLayout();
OutStreamer->SwitchSection(
getObjFileLowering().SectionForGlobal(GV, *Mang, TM));
OutStreamer->SwitchSection(getObjFileLowering().SectionForGlobal(GV, TM));
MCSymbol *GVSym = getSymbol(GV);
const Constant *C = GV->getInitializer();

12
lib/Target/XCore/XCoreTargetObjectFile.cpp
View File

@ -95,10 +95,8 @@ static unsigned getXCoreSectionFlags(SectionKind K, bool IsCPRel) {
return Flags;
}
MCSection *
XCoreTargetObjectFile::getExplicitSectionGlobal(const GlobalValue *GV,
SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
MCSection *XCoreTargetObjectFile::getExplicitSectionGlobal(
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
StringRef SectionName = GV->getSection();
// Infer section flags from the section name if we can.
bool IsCPRel = SectionName.startswith(".cp.");
@ -108,10 +106,8 @@ XCoreTargetObjectFile::getExplicitSectionGlobal(const GlobalValue *GV,
getXCoreSectionFlags(Kind, IsCPRel));
}
MCSection *
XCoreTargetObjectFile::SelectSectionForGlobal(const GlobalValue *GV,
SectionKind Kind, Mangler &Mang,
const TargetMachine &TM) const {
MCSection *XCoreTargetObjectFile::SelectSectionForGlobal(
const GlobalValue *GV, SectionKind Kind, const TargetMachine &TM) const {
bool UseCPRel = GV->isLocalLinkage(GV->getLinkage());

2
lib/Target/XCore/XCoreTargetObjectFile.h
View File

@ -26,11 +26,9 @@ static const unsigned CodeModelLargeSize = 256;
void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
MCSection *getExplicitSectionGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
MCSection *SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
Mangler &Mang,
const TargetMachine &TM) const override;
MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,