6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-09-30 04:56:49 +00:00
Code Issues Projects Releases Wiki Activity

There is only one Asm streamer, there is no need for targets to register it.

Browse Source 
Instead, have the targets register a TargetStreamer to be use with the
asm streamer (if any).

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@232423 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rafael Espindola 2015-03-16 21:43:42 +00:00
parent 4fefd5cdf4
commit 9130d115d6
11 changed files with 105 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
include/llvm/Support/TargetRegistry.h
View File

@ -130,15 +130,10 @@ namespace llvm {
const Target &T, StringRef TT, MCContext &Ctx, MCAsmBackend &TAB, const Target &T, StringRef TT, MCContext &Ctx, MCAsmBackend &TAB,
raw_ostream &OS, MCCodeEmitter *Emitter, const MCSubtargetInfo &STI, raw_ostream &OS, MCCodeEmitter *Emitter, const MCSubtargetInfo &STI,
bool RelaxAll); bool RelaxAll);
typedef MCStreamer *(*AsmStreamerCtorTy)(MCContext &Ctx,
formatted_raw_ostream &OS,
bool isVerboseAsm,
bool useDwarfDirectory,
MCInstPrinter *InstPrint,
MCCodeEmitter *CE,
MCAsmBackend *TAB,
bool ShowInst);
typedef MCTargetStreamer *(*NullTargetStreamerCtorTy)(MCStreamer &S); typedef MCTargetStreamer *(*NullTargetStreamerCtorTy)(MCStreamer &S);
typedef MCTargetStreamer *(*AsmTargetStreamerCtorTy)(
MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,
bool IsVerboseAsm);
typedef MCRelocationInfo *(*MCRelocationInfoCtorTy)(StringRef TT, typedef MCRelocationInfo *(*MCRelocationInfoCtorTy)(StringRef TT,
MCContext &Ctx); MCContext &Ctx);
typedef MCSymbolizer *(*MCSymbolizerCtorTy)( typedef MCSymbolizer *(*MCSymbolizerCtorTy)(
@ -219,14 +214,14 @@ namespace llvm {
/// MCObjectStreamer, if registered. /// MCObjectStreamer, if registered.
MCObjectStreamerCtorTy MCObjectStreamerCtorFn; MCObjectStreamerCtorTy MCObjectStreamerCtorFn;
/// AsmStreamerCtorFn - Construction function for this target's
/// AsmStreamer, if registered (default = llvm::createAsmStreamer).
AsmStreamerCtorTy AsmStreamerCtorFn;
/// Construction function for this target's null TargetStreamer, if /// Construction function for this target's null TargetStreamer, if
/// registered (default = nullptr). /// registered (default = nullptr).
NullTargetStreamerCtorTy NullTargetStreamerCtorFn; NullTargetStreamerCtorTy NullTargetStreamerCtorFn;
/// Construction function for this target's asm TargetStreamer, if
/// registered (default = nullptr).
AsmTargetStreamerCtorTy AsmTargetStreamerCtorFn;
/// MCRelocationInfoCtorFn - Construction function for this target's /// MCRelocationInfoCtorFn - Construction function for this target's
/// MCRelocationInfo, if registered (default = llvm::createMCRelocationInfo) /// MCRelocationInfo, if registered (default = llvm::createMCRelocationInfo)
MCRelocationInfoCtorTy MCRelocationInfoCtorFn; MCRelocationInfoCtorTy MCRelocationInfoCtorFn;
@ -237,8 +232,8 @@ namespace llvm {
public: public:
Target() Target()
: AsmStreamerCtorFn(nullptr), MCRelocationInfoCtorFn(nullptr), : NullTargetStreamerCtorFn(nullptr), AsmTargetStreamerCtorFn(nullptr),
MCSymbolizerCtorFn(nullptr) {} MCRelocationInfoCtorFn(nullptr), MCSymbolizerCtorFn(nullptr) {}
/// @name Target Information /// @name Target Information
/// @{ /// @{
@ -430,20 +425,24 @@ namespace llvm {
RelaxAll); RelaxAll);
} }
/// createAsmStreamer - Create a target specific MCStreamer. MCStreamer *createAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
MCStreamer *createAsmStreamer(MCContext &Ctx, bool IsVerboseAsm, bool UseDwarfDirectory,
formatted_raw_ostream &OS, MCInstPrinter *InstPrint, MCCodeEmitter *CE,
bool isVerboseAsm, MCAsmBackend *TAB, bool ShowInst) const {
bool useDwarfDirectory, MCStreamer *S =
MCInstPrinter *InstPrint, llvm::createAsmStreamer(Ctx, OS, IsVerboseAsm, UseDwarfDirectory,
MCCodeEmitter *CE, InstPrint, CE, TAB, ShowInst);
MCAsmBackend *TAB, createAsmTargetStreamer(*S, OS, InstPrint, IsVerboseAsm);
bool ShowInst) const { return S;
if (AsmStreamerCtorFn) }
return AsmStreamerCtorFn(Ctx, OS, isVerboseAsm, useDwarfDirectory,
InstPrint, CE, TAB, ShowInst); MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
return llvm::createAsmStreamer(Ctx, OS, isVerboseAsm, useDwarfDirectory, formatted_raw_ostream &OS,
InstPrint, CE, TAB, ShowInst); MCInstPrinter *InstPrint,
bool IsVerboseAsm) const {
if (AsmTargetStreamerCtorFn)
return AsmTargetStreamerCtorFn(S, OS, InstPrint, IsVerboseAsm);
return nullptr;
} }
MCStreamer *createNullStreamer(MCContext &Ctx) const { MCStreamer *createNullStreamer(MCContext &Ctx) const {
@ -771,24 +770,16 @@ namespace llvm {
T.MCObjectStreamerCtorFn = Fn; T.MCObjectStreamerCtorFn = Fn;
} }
/// RegisterAsmStreamer - Register an assembly MCStreamer implementation
/// for the given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct an MCStreamer for the target.
static void RegisterAsmStreamer(Target &T, Target::AsmStreamerCtorTy Fn) {
T.AsmStreamerCtorFn = Fn;
}
static void static void
RegisterNullTargetStreamer(Target &T, Target::NullTargetStreamerCtorTy Fn) { RegisterNullTargetStreamer(Target &T, Target::NullTargetStreamerCtorTy Fn) {
T.NullTargetStreamerCtorFn = Fn; T.NullTargetStreamerCtorFn = Fn;
} }
static void RegisterAsmTargetStreamer(Target &T,
Target::AsmTargetStreamerCtorTy Fn) {
T.AsmTargetStreamerCtorFn = Fn;
}
/// RegisterMCRelocationInfo - Register an MCRelocationInfo /// RegisterMCRelocationInfo - Register an MCRelocationInfo
/// implementation for the given target. /// implementation for the given target.
/// ///

14
lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp
View File

@ -203,15 +203,11 @@ void AArch64TargetELFStreamer::emitInst(uint32_t Inst) {
} }
namespace llvm { namespace llvm {
MCStreamer * MCTargetStreamer *createAArch64AsmTargetStreamer(MCStreamer &S,
createAArch64MCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS, formatted_raw_ostream &OS,
bool isVerboseAsm, bool useDwarfDirectory, MCInstPrinter *InstPrint,
MCInstPrinter *InstPrint, MCCodeEmitter *CE, bool isVerboseAsm) {
MCAsmBackend *TAB, bool ShowInst) { return new AArch64TargetAsmStreamer(S, OS);
MCStreamer *S = llvm::createAsmStreamer(
Ctx, OS, isVerboseAsm, useDwarfDirectory, InstPrint, CE, TAB, ShowInst);
new AArch64TargetAsmStreamer(*S, OS);
return S;
} }
MCELFStreamer *createAArch64ELFStreamer(MCContext &Context, MCAsmBackend &TAB, MCELFStreamer *createAArch64ELFStreamer(MCContext &Context, MCAsmBackend &TAB,

12
lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.cpp
View File

@ -199,12 +199,12 @@ extern "C" void LLVMInitializeAArch64TargetMC() {
TargetRegistry::RegisterMCObjectStreamer(TheARM64Target, createMCStreamer); TargetRegistry::RegisterMCObjectStreamer(TheARM64Target, createMCStreamer);
// Register the asm streamer. // Register the asm streamer.
TargetRegistry::RegisterAsmStreamer(TheAArch64leTarget, TargetRegistry::RegisterAsmTargetStreamer(TheAArch64leTarget,
createAArch64MCAsmStreamer); createAArch64AsmTargetStreamer);
TargetRegistry::RegisterAsmStreamer(TheAArch64beTarget, TargetRegistry::RegisterAsmTargetStreamer(TheAArch64beTarget,
createAArch64MCAsmStreamer); createAArch64AsmTargetStreamer);
TargetRegistry::RegisterAsmStreamer(TheARM64Target, TargetRegistry::RegisterAsmTargetStreamer(TheARM64Target,
createAArch64MCAsmStreamer); createAArch64AsmTargetStreamer);
// Register the MCInstPrinter. // Register the MCInstPrinter.
TargetRegistry::RegisterMCInstPrinter(TheAArch64leTarget, TargetRegistry::RegisterMCInstPrinter(TheAArch64leTarget,

10
lib/Target/AArch64/MCTargetDesc/AArch64MCTargetDesc.h
View File

@ -28,6 +28,7 @@ class MCRegisterInfo;
class MCObjectWriter; class MCObjectWriter;
class MCStreamer; class MCStreamer;
class MCSubtargetInfo; class MCSubtargetInfo;
class MCTargetStreamer;
class StringRef; class StringRef;
class Target; class Target;
class raw_ostream; class raw_ostream;
@ -52,11 +53,10 @@ MCObjectWriter *createAArch64ELFObjectWriter(raw_ostream &OS, uint8_t OSABI,
MCObjectWriter *createAArch64MachObjectWriter(raw_ostream &OS, uint32_t CPUType, MCObjectWriter *createAArch64MachObjectWriter(raw_ostream &OS, uint32_t CPUType,
uint32_t CPUSubtype); uint32_t CPUSubtype);
MCStreamer * MCTargetStreamer *createAArch64AsmTargetStreamer(MCStreamer &S,
createAArch64MCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS, formatted_raw_ostream &OS,
bool isVerboseAsm, bool useDwarfDirectory, MCInstPrinter *InstPrint,
MCInstPrinter *InstPrint, MCCodeEmitter *CE, bool isVerboseAsm);
MCAsmBackend *TAB, bool ShowInst);
} // End llvm namespace } // End llvm namespace
// Defines symbolic names for AArch64 registers. This defines a mapping from // Defines symbolic names for AArch64 registers. This defines a mapping from

13
lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp
View File

@ -1362,14 +1362,11 @@ void ARMELFStreamer::emitUnwindRaw(int64_t Offset,
namespace llvm { namespace llvm {
MCStreamer *createMCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS, MCTargetStreamer *createARMTargetAsmStreamer(MCStreamer &S,
bool isVerboseAsm, bool useDwarfDirectory, formatted_raw_ostream &OS,
MCInstPrinter *InstPrint, MCCodeEmitter *CE, MCInstPrinter *InstPrint,
MCAsmBackend *TAB, bool ShowInst) { bool isVerboseAsm) {
MCStreamer *S = llvm::createAsmStreamer( return new ARMTargetAsmStreamer(S, OS, *InstPrint, isVerboseAsm);
Ctx, OS, isVerboseAsm, useDwarfDirectory, InstPrint, CE, TAB, ShowInst);
new ARMTargetAsmStreamer(*S, OS, *InstPrint, isVerboseAsm);
return S;
} }
MCTargetStreamer *createARMNullTargetStreamer(MCStreamer &S) { MCTargetStreamer *createARMNullTargetStreamer(MCStreamer &S) {

12
lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp
View File

@ -450,10 +450,14 @@ extern "C" void LLVMInitializeARMTargetMC() {
TargetRegistry::RegisterMCObjectStreamer(TheThumbBETarget, createMCStreamer); TargetRegistry::RegisterMCObjectStreamer(TheThumbBETarget, createMCStreamer);
// Register the asm streamer. // Register the asm streamer.
TargetRegistry::RegisterAsmStreamer(TheARMLETarget, createMCAsmStreamer); TargetRegistry::RegisterAsmTargetStreamer(TheARMLETarget,
TargetRegistry::RegisterAsmStreamer(TheARMBETarget, createMCAsmStreamer); createARMTargetAsmStreamer);
TargetRegistry::RegisterAsmStreamer(TheThumbLETarget, createMCAsmStreamer); TargetRegistry::RegisterAsmTargetStreamer(TheARMBETarget,
TargetRegistry::RegisterAsmStreamer(TheThumbBETarget, createMCAsmStreamer); createARMTargetAsmStreamer);
TargetRegistry::RegisterAsmTargetStreamer(TheThumbLETarget,
createARMTargetAsmStreamer);
TargetRegistry::RegisterAsmTargetStreamer(TheThumbBETarget,
createARMTargetAsmStreamer);
// Register the null TargetStreamer. // Register the null TargetStreamer.
TargetRegistry::RegisterNullTargetStreamer(TheARMLETarget, TargetRegistry::RegisterNullTargetStreamer(TheARMLETarget,

9
lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h
View File

@ -47,12 +47,11 @@ namespace ARM_MC {
StringRef FS); StringRef FS);
} }
MCStreamer *createMCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
bool isVerboseAsm, bool useDwarfDirectory,
MCInstPrinter *InstPrint, MCCodeEmitter *CE,
MCAsmBackend *TAB, bool ShowInst);
MCTargetStreamer *createARMNullTargetStreamer(MCStreamer &S); MCTargetStreamer *createARMNullTargetStreamer(MCStreamer &S);
MCTargetStreamer *createARMTargetAsmStreamer(MCStreamer &S,
formatted_raw_ostream &OS,
MCInstPrinter *InstPrint,
bool isVerboseAsm);
MCCodeEmitter *createARMLEMCCodeEmitter(const MCInstrInfo &MCII, MCCodeEmitter *createARMLEMCCodeEmitter(const MCInstrInfo &MCII,
const MCRegisterInfo &MRI, const MCRegisterInfo &MRI,

26
lib/Target/Mips/MCTargetDesc/MipsMCTargetDesc.cpp
View File

@ -119,15 +119,11 @@ static MCStreamer *createMCStreamer(const Target &T, StringRef TT,
return S; return S;
} }
static MCStreamer * static MCTargetStreamer *createMipsAsmTargetStreamer(MCStreamer &S,
createMCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS, formatted_raw_ostream &OS,
bool isVerboseAsm, bool useDwarfDirectory, MCInstPrinter *InstPrint,
MCInstPrinter *InstPrint, MCCodeEmitter *CE, bool isVerboseAsm) {
MCAsmBackend *TAB, bool ShowInst) { return new MipsTargetAsmStreamer(S, OS);
MCStreamer *S = llvm::createAsmStreamer(
Ctx, OS, isVerboseAsm, useDwarfDirectory, InstPrint, CE, TAB, ShowInst);
new MipsTargetAsmStreamer(*S, OS);
return S;
} }
static MCTargetStreamer *createMipsNullTargetStreamer(MCStreamer &S) { static MCTargetStreamer *createMipsNullTargetStreamer(MCStreamer &S) {
@ -183,10 +179,14 @@ extern "C" void LLVMInitializeMipsTargetMC() {
createMCStreamer); createMCStreamer);
// Register the asm streamer. // Register the asm streamer.
TargetRegistry::RegisterAsmStreamer(TheMipsTarget, createMCAsmStreamer); TargetRegistry::RegisterAsmTargetStreamer(TheMipsTarget,
TargetRegistry::RegisterAsmStreamer(TheMipselTarget, createMCAsmStreamer); createMipsAsmTargetStreamer);
TargetRegistry::RegisterAsmStreamer(TheMips64Target, createMCAsmStreamer); TargetRegistry::RegisterAsmTargetStreamer(TheMipselTarget,
TargetRegistry::RegisterAsmStreamer(TheMips64elTarget, createMCAsmStreamer); createMipsAsmTargetStreamer);
TargetRegistry::RegisterAsmTargetStreamer(TheMips64Target,
createMipsAsmTargetStreamer);
TargetRegistry::RegisterAsmTargetStreamer(TheMips64elTarget,
createMipsAsmTargetStreamer);
TargetRegistry::RegisterNullTargetStreamer(TheMipsTarget, TargetRegistry::RegisterNullTargetStreamer(TheMipsTarget,
createMipsNullTargetStreamer); createMipsNullTargetStreamer);

24
lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp
View File

@ -239,16 +239,11 @@ static MCStreamer *createMCStreamer(const Target &T, StringRef TT,
return S; return S;
} }
static MCStreamer * static MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
createMCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS, formatted_raw_ostream &OS,
bool isVerboseAsm, bool useDwarfDirectory, MCInstPrinter *InstPrint,
MCInstPrinter *InstPrint, MCCodeEmitter *CE, bool isVerboseAsm) {
MCAsmBackend *TAB, bool ShowInst) { return new PPCTargetAsmStreamer(S, OS);
MCStreamer *S = llvm::createAsmStreamer(
Ctx, OS, isVerboseAsm, useDwarfDirectory, InstPrint, CE, TAB, ShowInst);
new PPCTargetAsmStreamer(*S, OS);
return S;
} }
static MCInstPrinter *createPPCMCInstPrinter(const Target &T, static MCInstPrinter *createPPCMCInstPrinter(const Target &T,
@ -309,9 +304,12 @@ extern "C" void LLVMInitializePowerPCTargetMC() {
TargetRegistry::RegisterMCObjectStreamer(ThePPC64LETarget, createMCStreamer); TargetRegistry::RegisterMCObjectStreamer(ThePPC64LETarget, createMCStreamer);
// Register the asm streamer. // Register the asm streamer.
TargetRegistry::RegisterAsmStreamer(ThePPC32Target, createMCAsmStreamer); TargetRegistry::RegisterAsmTargetStreamer(ThePPC32Target,
TargetRegistry::RegisterAsmStreamer(ThePPC64Target, createMCAsmStreamer); createAsmTargetStreamer);
TargetRegistry::RegisterAsmStreamer(ThePPC64LETarget, createMCAsmStreamer); TargetRegistry::RegisterAsmTargetStreamer(ThePPC64Target,
createAsmTargetStreamer);
TargetRegistry::RegisterAsmTargetStreamer(ThePPC64LETarget,
createAsmTargetStreamer);
// Register the MCInstPrinter. // Register the MCInstPrinter.
TargetRegistry::RegisterMCInstPrinter(ThePPC32Target, createPPCMCInstPrinter); TargetRegistry::RegisterMCInstPrinter(ThePPC32Target, createPPCMCInstPrinter);

23
lib/Target/Sparc/MCTargetDesc/SparcMCTargetDesc.cpp
View File

@ -131,16 +131,11 @@ static MCStreamer *createMCStreamer(const Target &T, StringRef TT,
return S; return S;
} }
static MCStreamer * static MCTargetStreamer *createTargetAsmStreamer(MCStreamer &S,
createMCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS, formatted_raw_ostream &OS,
bool isVerboseAsm, bool useDwarfDirectory, MCInstPrinter *InstPrint,
MCInstPrinter *InstPrint, MCCodeEmitter *CE, bool isVerboseAsm) {
MCAsmBackend *TAB, bool ShowInst) { return new SparcTargetAsmStreamer(S, OS);
MCStreamer *S = llvm::createAsmStreamer(
Ctx, OS, isVerboseAsm, useDwarfDirectory, InstPrint, CE, TAB, ShowInst);
new SparcTargetAsmStreamer(*S, OS);
return S;
} }
static MCInstPrinter *createSparcMCInstPrinter(const Target &T, static MCInstPrinter *createSparcMCInstPrinter(const Target &T,
@ -197,10 +192,10 @@ extern "C" void LLVMInitializeSparcTargetMC() {
createMCStreamer); createMCStreamer);
// Register the asm streamer. // Register the asm streamer.
TargetRegistry::RegisterAsmStreamer(TheSparcTarget, TargetRegistry::RegisterAsmTargetStreamer(TheSparcTarget,
createMCAsmStreamer); createTargetAsmStreamer);
TargetRegistry::RegisterAsmStreamer(TheSparcV9Target, TargetRegistry::RegisterAsmTargetStreamer(TheSparcV9Target,
createMCAsmStreamer); createTargetAsmStreamer);
// Register the MCInstPrinter // Register the MCInstPrinter
TargetRegistry::RegisterMCInstPrinter(TheSparcTarget, TargetRegistry::RegisterMCInstPrinter(TheSparcTarget,

17
lib/Target/XCore/MCTargetDesc/XCoreMCTargetDesc.cpp
View File

@ -126,15 +126,11 @@ void XCoreTargetAsmStreamer::emitCCBottomFunction(StringRef Name) {
} }
} }
static MCStreamer * static MCTargetStreamer *createTargetAsmStreamer(MCStreamer &S,
createXCoreMCAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS, formatted_raw_ostream &OS,
bool isVerboseAsm, bool useDwarfDirectory, MCInstPrinter *InstPrint,
MCInstPrinter *InstPrint, MCCodeEmitter *CE, bool isVerboseAsm) {
MCAsmBackend *TAB, bool ShowInst) { return new XCoreTargetAsmStreamer(S, OS);
MCStreamer *S = llvm::createAsmStreamer(
Ctx, OS, isVerboseAsm, useDwarfDirectory, InstPrint, CE, TAB, ShowInst);
new XCoreTargetAsmStreamer(*S, OS);
return S;
} }
// Force static initialization. // Force static initialization.
@ -160,5 +156,6 @@ extern "C" void LLVMInitializeXCoreTargetMC() {
TargetRegistry::RegisterMCInstPrinter(TheXCoreTarget, TargetRegistry::RegisterMCInstPrinter(TheXCoreTarget,
createXCoreMCInstPrinter); createXCoreMCInstPrinter);
TargetRegistry::RegisterAsmStreamer(TheXCoreTarget, createXCoreMCAsmStreamer); TargetRegistry::RegisterAsmTargetStreamer(TheXCoreTarget,
createTargetAsmStreamer);
} }