6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-21 18:24:23 +00:00
Code Issues Projects Releases Wiki Activity

Rename createCodeEmitter to createMCCodeEmitter; createObjectStreamer to createMCObjectStreamer.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@136031 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Evan Cheng
2011-07-26 00:42:34 +00:00
parent 0682597817
commit 28c85a81a1
7 changed files with 97 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
include/llvm/Target/TargetRegistry.h
View File

@ -96,17 +96,17 @@ namespace llvm {
typedef MCInstPrinter *(*MCInstPrinterCtorTy)(const Target &T, typedef MCInstPrinter *(*MCInstPrinterCtorTy)(const Target &T,
unsigned SyntaxVariant, unsigned SyntaxVariant,
const MCAsmInfo &MAI); const MCAsmInfo &MAI);
typedef MCCodeEmitter *(*CodeEmitterCtorTy)(const MCInstrInfo &II, typedef MCCodeEmitter *(*MCCodeEmitterCtorTy)(const MCInstrInfo &II,
const MCSubtargetInfo &STI, const MCSubtargetInfo &STI,
MCContext &Ctx); MCContext &Ctx);
typedef MCStreamer *(*ObjectStreamerCtorTy)(const Target &T, typedef MCStreamer *(*MCObjectStreamerCtorTy)(const Target &T,
const std::string &TT, StringRef TT,
MCContext &Ctx, MCContext &Ctx,
MCAsmBackend &TAB, MCAsmBackend &TAB,
raw_ostream &_OS, raw_ostream &_OS,
MCCodeEmitter *_Emitter, MCCodeEmitter *_Emitter,
bool RelaxAll, bool RelaxAll,
bool NoExecStack); bool NoExecStack);
typedef MCStreamer *(*AsmStreamerCtorTy)(MCContext &Ctx, typedef MCStreamer *(*AsmStreamerCtorTy)(MCContext &Ctx,
formatted_raw_ostream &OS, formatted_raw_ostream &OS,
bool isVerboseAsm, bool isVerboseAsm,
@ -183,13 +183,13 @@ namespace llvm {
/// MCInstPrinter, if registered. /// MCInstPrinter, if registered.
MCInstPrinterCtorTy MCInstPrinterCtorFn; MCInstPrinterCtorTy MCInstPrinterCtorFn;
/// CodeEmitterCtorFn - Construction function for this target's CodeEmitter, /// MCCodeEmitterCtorFn - Construction function for this target's
/// if registered. /// CodeEmitter, if registered.
CodeEmitterCtorTy CodeEmitterCtorFn; MCCodeEmitterCtorTy MCCodeEmitterCtorFn;
/// ObjectStreamerCtorFn - Construction function for this target's /// MCObjectStreamerCtorFn - Construction function for this target's
/// ObjectStreamer, if registered. /// MCObjectStreamer, if registered.
ObjectStreamerCtorTy ObjectStreamerCtorFn; MCObjectStreamerCtorTy MCObjectStreamerCtorFn;
/// AsmStreamerCtorFn - Construction function for this target's /// AsmStreamerCtorFn - Construction function for this target's
/// AsmStreamer, if registered (default = llvm::createAsmStreamer). /// AsmStreamer, if registered (default = llvm::createAsmStreamer).
@ -238,11 +238,11 @@ namespace llvm {
/// hasMCInstPrinter - Check if this target has an instruction printer. /// hasMCInstPrinter - Check if this target has an instruction printer.
bool hasMCInstPrinter() const { return MCInstPrinterCtorFn != 0; } bool hasMCInstPrinter() const { return MCInstPrinterCtorFn != 0; }
/// hasCodeEmitter - Check if this target supports instruction encoding. /// hasMCCodeEmitter - Check if this target supports instruction encoding.
bool hasCodeEmitter() const { return CodeEmitterCtorFn != 0; } bool hasMCCodeEmitter() const { return MCCodeEmitterCtorFn != 0; }
/// hasObjectStreamer - Check if this target supports streaming to files. /// hasMCObjectStreamer - Check if this target supports streaming to files.
bool hasObjectStreamer() const { return ObjectStreamerCtorFn != 0; } bool hasMCObjectStreamer() const { return MCObjectStreamerCtorFn != 0; }
/// hasAsmStreamer - Check if this target supports streaming to files. /// hasAsmStreamer - Check if this target supports streaming to files.
bool hasAsmStreamer() const { return AsmStreamerCtorFn != 0; } bool hasAsmStreamer() const { return AsmStreamerCtorFn != 0; }
@ -373,16 +373,16 @@ namespace llvm {
} }
/// createCodeEmitter - Create a target specific code emitter. /// createMCCodeEmitter - Create a target specific code emitter.
MCCodeEmitter *createCodeEmitter(const MCInstrInfo &II, MCCodeEmitter *createMCCodeEmitter(const MCInstrInfo &II,
const MCSubtargetInfo &STI, const MCSubtargetInfo &STI,
MCContext &Ctx) const { MCContext &Ctx) const {
if (!CodeEmitterCtorFn) if (!MCCodeEmitterCtorFn)
return 0; return 0;
return CodeEmitterCtorFn(II, STI, Ctx); return MCCodeEmitterCtorFn(II, STI, Ctx);
} }
/// createObjectStreamer - Create a target specific MCStreamer. /// createMCObjectStreamer - Create a target specific MCStreamer.
/// ///
/// \arg TT - The target triple. /// \arg TT - The target triple.
/// \arg Ctx - The target context. /// \arg Ctx - The target context.
@ -391,16 +391,16 @@ namespace llvm {
/// \arg _Emitter - The target independent assembler object.Takes ownership. /// \arg _Emitter - The target independent assembler object.Takes ownership.
/// \arg RelaxAll - Relax all fixups? /// \arg RelaxAll - Relax all fixups?
/// \arg NoExecStack - Mark file as not needing a executable stack. /// \arg NoExecStack - Mark file as not needing a executable stack.
MCStreamer *createObjectStreamer(const std::string &TT, MCContext &Ctx, MCStreamer *createMCObjectStreamer(StringRef TT, MCContext &Ctx,
MCAsmBackend &TAB, MCAsmBackend &TAB,
raw_ostream &_OS, raw_ostream &_OS,
MCCodeEmitter *_Emitter, MCCodeEmitter *_Emitter,
bool RelaxAll, bool RelaxAll,
bool NoExecStack) const { bool NoExecStack) const {
if (!ObjectStreamerCtorFn) if (!MCObjectStreamerCtorFn)
return 0; return 0;
return ObjectStreamerCtorFn(*this, TT, Ctx, TAB, _OS, _Emitter, RelaxAll, return MCObjectStreamerCtorFn(*this, TT, Ctx, TAB, _OS, _Emitter,
NoExecStack); RelaxAll, NoExecStack);
} }
/// createAsmStreamer - Create a target specific MCStreamer. /// createAsmStreamer - Create a target specific MCStreamer.
@ -691,7 +691,7 @@ namespace llvm {
T.MCInstPrinterCtorFn = Fn; T.MCInstPrinterCtorFn = Fn;
} }
/// RegisterCodeEmitter - Register a MCCodeEmitter implementation for the /// RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the
/// given target. /// given target.
/// ///
/// Clients are responsible for ensuring that registration doesn't occur /// Clients are responsible for ensuring that registration doesn't occur
@ -700,13 +700,14 @@ namespace llvm {
/// ///
/// @param T - The target being registered. /// @param T - The target being registered.
/// @param Fn - A function to construct an MCCodeEmitter for the target. /// @param Fn - A function to construct an MCCodeEmitter for the target.
static void RegisterCodeEmitter(Target &T, Target::CodeEmitterCtorTy Fn) { static void RegisterMCCodeEmitter(Target &T,
if (!T.CodeEmitterCtorFn) Target::MCCodeEmitterCtorTy Fn) {
T.CodeEmitterCtorFn = Fn; if (!T.MCCodeEmitterCtorFn)
T.MCCodeEmitterCtorFn = Fn;
} }
/// RegisterObjectStreamer - Register a object code MCStreamer implementation /// RegisterMCObjectStreamer - Register a object code MCStreamer
/// for the given target. /// implementation for the given target.
/// ///
/// Clients are responsible for ensuring that registration doesn't occur /// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically /// while another thread is attempting to access the registry. Typically
@ -714,9 +715,10 @@ namespace llvm {
/// ///
/// @param T - The target being registered. /// @param T - The target being registered.
/// @param Fn - A function to construct an MCStreamer for the target. /// @param Fn - A function to construct an MCStreamer for the target.
static void RegisterObjectStreamer(Target &T, Target::ObjectStreamerCtorTy Fn) { static void RegisterMCObjectStreamer(Target &T,
if (!T.ObjectStreamerCtorFn) Target::MCObjectStreamerCtorTy Fn) {
T.ObjectStreamerCtorFn = Fn; if (!T.MCObjectStreamerCtorFn)
T.MCObjectStreamerCtorFn = Fn;
} }
/// RegisterAsmStreamer - Register an assembly MCStreamer implementation /// RegisterAsmStreamer - Register an assembly MCStreamer implementation
@ -1036,25 +1038,25 @@ namespace llvm {
} }
}; };
/// RegisterCodeEmitter - Helper template for registering a target specific /// RegisterMCCodeEmitter - Helper template for registering a target specific
/// machine code emitter, for use in the target initialization /// machine code emitter, for use in the target initialization
/// function. Usage: /// function. Usage:
/// ///
/// extern "C" void LLVMInitializeFooCodeEmitter() { /// extern "C" void LLVMInitializeFooMCCodeEmitter() {
/// extern Target TheFooTarget; /// extern Target TheFooTarget;
/// RegisterCodeEmitter<FooCodeEmitter> X(TheFooTarget); /// RegisterMCCodeEmitter<FooCodeEmitter> X(TheFooTarget);
/// } /// }
template<class CodeEmitterImpl> template<class MCCodeEmitterImpl>
struct RegisterCodeEmitter { struct RegisterMCCodeEmitter {
RegisterCodeEmitter(Target &T) { RegisterMCCodeEmitter(Target &T) {
TargetRegistry::RegisterCodeEmitter(T, &Allocator); TargetRegistry::RegisterMCCodeEmitter(T, &Allocator);
} }
private: private:
static MCCodeEmitter *Allocator(const MCInstrInfo &II, static MCCodeEmitter *Allocator(const MCInstrInfo &II,
const MCSubtargetInfo &STI, const MCSubtargetInfo &STI,
MCContext &Ctx) { MCContext &Ctx) {
return new CodeEmitterImpl(); return new MCCodeEmitterImpl();
} }
}; };

24
lib/CodeGen/LLVMTargetMachine.cpp
View File

@ -140,7 +140,7 @@ bool LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM,
MCAsmBackend *MAB = 0; MCAsmBackend *MAB = 0;
if (ShowMCEncoding) { if (ShowMCEncoding) {
const MCSubtargetInfo &STI = getSubtarget<MCSubtargetInfo>(); const MCSubtargetInfo &STI = getSubtarget<MCSubtargetInfo>();
MCE = getTarget().createCodeEmitter(*getInstrInfo(), STI, *Context); MCE = getTarget().createMCCodeEmitter(*getInstrInfo(), STI, *Context);
MAB = getTarget().createMCAsmBackend(getTargetTriple()); MAB = getTarget().createMCAsmBackend(getTargetTriple());
} }
@ -158,16 +158,16 @@ bool LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM,
// Create the code emitter for the target if it exists. If not, .o file // Create the code emitter for the target if it exists. If not, .o file
// emission fails. // emission fails.
const MCSubtargetInfo &STI = getSubtarget<MCSubtargetInfo>(); const MCSubtargetInfo &STI = getSubtarget<MCSubtargetInfo>();
MCCodeEmitter *MCE = getTarget().createCodeEmitter(*getInstrInfo(), STI, MCCodeEmitter *MCE = getTarget().createMCCodeEmitter(*getInstrInfo(), STI,
*Context); *Context);
MCAsmBackend *MAB = getTarget().createMCAsmBackend(getTargetTriple()); MCAsmBackend *MAB = getTarget().createMCAsmBackend(getTargetTriple());
if (MCE == 0 || MAB == 0) if (MCE == 0 || MAB == 0)
return true; return true;
AsmStreamer.reset(getTarget().createObjectStreamer(getTargetTriple(), AsmStreamer.reset(getTarget().createMCObjectStreamer(getTargetTriple(),
*Context, *MAB, Out, MCE, *Context, *MAB, Out,
hasMCRelaxAll(), MCE, hasMCRelaxAll(),
hasMCNoExecStack())); hasMCNoExecStack()));
AsmStreamer.get()->InitSections(); AsmStreamer.get()->InitSections();
break; break;
} }
@ -236,16 +236,16 @@ bool LLVMTargetMachine::addPassesToEmitMC(PassManagerBase &PM,
// Create the code emitter for the target if it exists. If not, .o file // Create the code emitter for the target if it exists. If not, .o file
// emission fails. // emission fails.
const MCSubtargetInfo &STI = getSubtarget<MCSubtargetInfo>(); const MCSubtargetInfo &STI = getSubtarget<MCSubtargetInfo>();
MCCodeEmitter *MCE = getTarget().createCodeEmitter(*getInstrInfo(),STI, *Ctx); MCCodeEmitter *MCE = getTarget().createMCCodeEmitter(*getInstrInfo(),STI, *Ctx);
MCAsmBackend *MAB = getTarget().createMCAsmBackend(getTargetTriple()); MCAsmBackend *MAB = getTarget().createMCAsmBackend(getTargetTriple());
if (MCE == 0 || MAB == 0) if (MCE == 0 || MAB == 0)
return true; return true;
OwningPtr<MCStreamer> AsmStreamer; OwningPtr<MCStreamer> AsmStreamer;
AsmStreamer.reset(getTarget().createObjectStreamer(getTargetTriple(), *Ctx, AsmStreamer.reset(getTarget().createMCObjectStreamer(getTargetTriple(), *Ctx,
*MAB, Out, MCE, *MAB, Out, MCE,
hasMCRelaxAll(), hasMCRelaxAll(),
hasMCNoExecStack())); hasMCNoExecStack()));
AsmStreamer.get()->InitSections(); AsmStreamer.get()->InitSections();
// Create the AsmPrinter, which takes ownership of AsmStreamer if successful. // Create the AsmPrinter, which takes ownership of AsmStreamer if successful.

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

@ -132,7 +132,7 @@ static MCCodeGenInfo *createARMMCCodeGenInfo(StringRef TT, Reloc::Model RM,
} }
// This is duplicated code. Refactor this. // This is duplicated code. Refactor this.
static MCStreamer *createMCStreamer(const Target &T, const std::string &TT, static MCStreamer *createMCStreamer(const Target &T, StringRef TT,
MCContext &Ctx, MCAsmBackend &MAB, MCContext &Ctx, MCAsmBackend &MAB,
raw_ostream &OS, raw_ostream &OS,
MCCodeEmitter *Emitter, MCCodeEmitter *Emitter,
@ -185,16 +185,16 @@ extern "C" void LLVMInitializeARMTargetMC() {
ARM_MC::createARMMCSubtargetInfo); ARM_MC::createARMMCSubtargetInfo);
// Register the MC Code Emitter // Register the MC Code Emitter
TargetRegistry::RegisterCodeEmitter(TheARMTarget, createARMMCCodeEmitter); TargetRegistry::RegisterMCCodeEmitter(TheARMTarget, createARMMCCodeEmitter);
TargetRegistry::RegisterCodeEmitter(TheThumbTarget, createARMMCCodeEmitter); TargetRegistry::RegisterMCCodeEmitter(TheThumbTarget, createARMMCCodeEmitter);
// Register the asm backend. // Register the asm backend.
TargetRegistry::RegisterMCAsmBackend(TheARMTarget, createARMAsmBackend); TargetRegistry::RegisterMCAsmBackend(TheARMTarget, createARMAsmBackend);
TargetRegistry::RegisterMCAsmBackend(TheThumbTarget, createARMAsmBackend); TargetRegistry::RegisterMCAsmBackend(TheThumbTarget, createARMAsmBackend);
// Register the object streamer. // Register the object streamer.
TargetRegistry::RegisterObjectStreamer(TheARMTarget, createMCStreamer); TargetRegistry::RegisterMCObjectStreamer(TheARMTarget, createMCStreamer);
TargetRegistry::RegisterObjectStreamer(TheThumbTarget, createMCStreamer); TargetRegistry::RegisterMCObjectStreamer(TheThumbTarget, createMCStreamer);
// Register the MCInstPrinter. // Register the MCInstPrinter.
TargetRegistry::RegisterMCInstPrinter(TheARMTarget, createARMMCInstPrinter); TargetRegistry::RegisterMCInstPrinter(TheARMTarget, createARMMCInstPrinter);

10
lib/Target/MBlaze/MCTargetDesc/MBlazeMCTargetDesc.cpp
View File

@ -71,7 +71,7 @@ static MCCodeGenInfo *createMBlazeMCCodeGenInfo(StringRef TT, Reloc::Model RM,
return X; return X;
} }
static MCStreamer *createMCStreamer(const Target &T, const std::string &TT, static MCStreamer *createMCStreamer(const Target &T, StringRef TT,
MCContext &Ctx, MCAsmBackend &MAB, MCContext &Ctx, MCAsmBackend &MAB,
raw_ostream &_OS, raw_ostream &_OS,
MCCodeEmitter *_Emitter, MCCodeEmitter *_Emitter,
@ -121,16 +121,16 @@ extern "C" void LLVMInitializeMBlazeTargetMC() {
createMBlazeMCSubtargetInfo); createMBlazeMCSubtargetInfo);
// Register the MC code emitter // Register the MC code emitter
TargetRegistry::RegisterCodeEmitter(TheMBlazeTarget, TargetRegistry::RegisterMCCodeEmitter(TheMBlazeTarget,
llvm::createMBlazeMCCodeEmitter); llvm::createMBlazeMCCodeEmitter);
// Register the asm backend // Register the asm backend
TargetRegistry::RegisterMCAsmBackend(TheMBlazeTarget, TargetRegistry::RegisterMCAsmBackend(TheMBlazeTarget,
createMBlazeAsmBackend); createMBlazeAsmBackend);
// Register the object streamer // Register the object streamer
TargetRegistry::RegisterObjectStreamer(TheMBlazeTarget, TargetRegistry::RegisterMCObjectStreamer(TheMBlazeTarget,
createMCStreamer); createMCStreamer);
// Register the MCInstPrinter. // Register the MCInstPrinter.
TargetRegistry::RegisterMCInstPrinter(TheMBlazeTarget, TargetRegistry::RegisterMCInstPrinter(TheMBlazeTarget,

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

@ -90,7 +90,7 @@ static MCCodeGenInfo *createPPCMCCodeGenInfo(StringRef TT, Reloc::Model RM,
} }
// This is duplicated code. Refactor this. // This is duplicated code. Refactor this.
static MCStreamer *createMCStreamer(const Target &T, const std::string &TT, static MCStreamer *createMCStreamer(const Target &T, StringRef TT,
MCContext &Ctx, MCAsmBackend &MAB, MCContext &Ctx, MCAsmBackend &MAB,
raw_ostream &OS, raw_ostream &OS,
MCCodeEmitter *Emitter, MCCodeEmitter *Emitter,
@ -132,16 +132,16 @@ extern "C" void LLVMInitializePowerPCTargetMC() {
createPPCMCSubtargetInfo); createPPCMCSubtargetInfo);
// Register the MC Code Emitter // Register the MC Code Emitter
TargetRegistry::RegisterCodeEmitter(ThePPC32Target, createPPCMCCodeEmitter); TargetRegistry::RegisterMCCodeEmitter(ThePPC32Target, createPPCMCCodeEmitter);
TargetRegistry::RegisterCodeEmitter(ThePPC64Target, createPPCMCCodeEmitter); TargetRegistry::RegisterMCCodeEmitter(ThePPC64Target, createPPCMCCodeEmitter);
// Register the asm backend. // Register the asm backend.
TargetRegistry::RegisterMCAsmBackend(ThePPC32Target, createPPCAsmBackend); TargetRegistry::RegisterMCAsmBackend(ThePPC32Target, createPPCAsmBackend);
TargetRegistry::RegisterMCAsmBackend(ThePPC64Target, createPPCAsmBackend); TargetRegistry::RegisterMCAsmBackend(ThePPC64Target, createPPCAsmBackend);
// Register the object streamer. // Register the object streamer.
TargetRegistry::RegisterObjectStreamer(ThePPC32Target, createMCStreamer); TargetRegistry::RegisterMCObjectStreamer(ThePPC32Target, createMCStreamer);
TargetRegistry::RegisterObjectStreamer(ThePPC64Target, createMCStreamer); TargetRegistry::RegisterMCObjectStreamer(ThePPC64Target, createMCStreamer);
// Register the MCInstPrinter. // Register the MCInstPrinter.
TargetRegistry::RegisterMCInstPrinter(ThePPC32Target, createPPCMCInstPrinter); TargetRegistry::RegisterMCInstPrinter(ThePPC32Target, createPPCMCInstPrinter);

18
lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp
View File

@ -366,7 +366,7 @@ static MCCodeGenInfo *createX86MCCodeGenInfo(StringRef TT, Reloc::Model RM,
return X; return X;
} }
static MCStreamer *createMCStreamer(const Target &T, const std::string &TT, static MCStreamer *createMCStreamer(const Target &T, StringRef TT,
MCContext &Ctx, MCAsmBackend &MAB, MCContext &Ctx, MCAsmBackend &MAB,
raw_ostream &_OS, raw_ostream &_OS,
MCCodeEmitter *_Emitter, MCCodeEmitter *_Emitter,
@ -418,10 +418,10 @@ extern "C" void LLVMInitializeX86TargetMC() {
X86_MC::createX86MCSubtargetInfo); X86_MC::createX86MCSubtargetInfo);
// Register the code emitter. // Register the code emitter.
TargetRegistry::RegisterCodeEmitter(TheX86_32Target, TargetRegistry::RegisterMCCodeEmitter(TheX86_32Target,
createX86MCCodeEmitter); createX86MCCodeEmitter);
TargetRegistry::RegisterCodeEmitter(TheX86_64Target, TargetRegistry::RegisterMCCodeEmitter(TheX86_64Target,
createX86MCCodeEmitter); createX86MCCodeEmitter);
// Register the asm backend. // Register the asm backend.
TargetRegistry::RegisterMCAsmBackend(TheX86_32Target, TargetRegistry::RegisterMCAsmBackend(TheX86_32Target,
@ -430,10 +430,10 @@ extern "C" void LLVMInitializeX86TargetMC() {
createX86_64AsmBackend); createX86_64AsmBackend);
// Register the object streamer. // Register the object streamer.
TargetRegistry::RegisterObjectStreamer(TheX86_32Target, TargetRegistry::RegisterMCObjectStreamer(TheX86_32Target,
createMCStreamer); createMCStreamer);
TargetRegistry::RegisterObjectStreamer(TheX86_64Target, TargetRegistry::RegisterMCObjectStreamer(TheX86_64Target,
createMCStreamer); createMCStreamer);
// Register the MCInstPrinter. // Register the MCInstPrinter.
TargetRegistry::RegisterMCInstPrinter(TheX86_32Target, TargetRegistry::RegisterMCInstPrinter(TheX86_32Target,

10
tools/llvm-mc/llvm-mc.cpp
View File

@ -370,7 +370,7 @@ static int AssembleInput(const char *ProgName) {
MCCodeEmitter *CE = 0; MCCodeEmitter *CE = 0;
MCAsmBackend *MAB = 0; MCAsmBackend *MAB = 0;
if (ShowEncoding) { if (ShowEncoding) {
CE = TheTarget->createCodeEmitter(*MCII, *STI, Ctx); CE = TheTarget->createMCCodeEmitter(*MCII, *STI, Ctx);
MAB = TheTarget->createMCAsmBackend(TripleName); MAB = TheTarget->createMCAsmBackend(TripleName);
} }
Str.reset(TheTarget->createAsmStreamer(Ctx, FOS, /*asmverbose*/true, Str.reset(TheTarget->createAsmStreamer(Ctx, FOS, /*asmverbose*/true,
@ -381,11 +381,11 @@ static int AssembleInput(const char *ProgName) {
Str.reset(createNullStreamer(Ctx)); Str.reset(createNullStreamer(Ctx));
} else { } else {
assert(FileType == OFT_ObjectFile && "Invalid file type!"); assert(FileType == OFT_ObjectFile && "Invalid file type!");
MCCodeEmitter *CE = TheTarget->createCodeEmitter(*MCII, *STI, Ctx); MCCodeEmitter *CE = TheTarget->createMCCodeEmitter(*MCII, *STI, Ctx);
MCAsmBackend *MAB = TheTarget->createMCAsmBackend(TripleName); MCAsmBackend *MAB = TheTarget->createMCAsmBackend(TripleName);
Str.reset(TheTarget->createObjectStreamer(TripleName, Ctx, *MAB, Str.reset(TheTarget->createMCObjectStreamer(TripleName, Ctx, *MAB,
FOS, CE, RelaxAll, FOS, CE, RelaxAll,
NoExecStack)); NoExecStack));
} }
if (EnableLogging) { if (EnableLogging) {