6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-21 18:29:46 +00:00
Code Issues Projects Releases Wiki Activity

We need to pass the TargetMachine object to the InstPrinter if we are printing

Browse Source 
the alias of an InstAlias instead of the thing being aliased. Because we need to
know the features that are valid for an InstAlias.

This is part of a work-in-progress.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@127986 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling 2011-03-21 04:13:46 +00:00
parent 262a862787
commit a5c177e70a
18 changed files with 90 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -78,6 +78,7 @@ namespace llvm {
TargetMachine &TM);
typedef MCDisassembler *(*MCDisassemblerCtorTy)(const Target &T);
typedef MCInstPrinter *(*MCInstPrinterCtorTy)(const Target &T,
TargetMachine &TM,
unsigned SyntaxVariant,
const MCAsmInfo &MAI);
typedef MCCodeEmitter *(*CodeEmitterCtorTy)(const Target &T,
@ -286,11 +287,12 @@ namespace llvm {
return MCDisassemblerCtorFn(*this);
}
MCInstPrinter *createMCInstPrinter(unsigned SyntaxVariant,
MCInstPrinter *createMCInstPrinter(TargetMachine &TM,
unsigned SyntaxVariant,
const MCAsmInfo &MAI) const {
if (!MCInstPrinterCtorFn)
return 0;
return MCInstPrinterCtorFn(*this, SyntaxVariant, MAI);
return MCInstPrinterCtorFn(*this, TM, SyntaxVariant, MAI);
}

2
lib/CodeGen/LLVMTargetMachine.cpp
View File

@ -133,7 +133,7 @@ bool LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM,
default: return true;
case CGFT_AssemblyFile: {
MCInstPrinter *InstPrinter =
getTarget().createMCInstPrinter(MAI.getAssemblerDialect(), MAI);
getTarget().createMCInstPrinter(*this, MAI.getAssemblerDialect(), MAI);
// Create a code emitter if asked to show the encoding.
MCCodeEmitter *MCE = 0;

3
lib/MC/MCDisassembler/EDDisassembler.cpp
View File

@ -193,7 +193,8 @@ EDDisassembler::EDDisassembler(CPUKey &key) :
InstString.reset(new std::string);
InstStream.reset(new raw_string_ostream(*InstString));
InstPrinter.reset(Tgt->createMCInstPrinter(LLVMSyntaxVariant, *AsmInfo));
InstPrinter.reset(Tgt->createMCInstPrinter(*TargetMachine, LLVMSyntaxVariant,
*AsmInfo));
if (!InstPrinter)
return;

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

@ -1791,10 +1791,11 @@ void ARMAsmPrinter::EmitInstruction(const MachineInstr *MI) {
//===----------------------------------------------------------------------===//
static MCInstPrinter *createARMMCInstPrinter(const Target &T,
TargetMachine &TM,
unsigned SyntaxVariant,
const MCAsmInfo &MAI) {
if (SyntaxVariant == 0)
return new ARMInstPrinter(MAI);
return new ARMInstPrinter(TM, MAI);
return 0;
}

7
lib/Target/ARM/InstPrinter/ARMInstPrinter.h
View File

@ -17,11 +17,14 @@
#include "llvm/MC/MCInstPrinter.h"
namespace llvm {
class MCOperand;
class MCOperand;
class TargetMachine;
class ARMInstPrinter : public MCInstPrinter {
public:
ARMInstPrinter(const MCAsmInfo &MAI) : MCInstPrinter(MAI) {}
ARMInstPrinter(TargetMachine &TM, const MCAsmInfo &MAI)
: MCInstPrinter(MAI) {}
virtual void printInst(const MCInst *MI, raw_ostream &O);
virtual StringRef getOpcodeName(unsigned Opcode) const;

5
lib/Target/MBlaze/InstPrinter/MBlazeInstPrinter.h
View File

@ -18,11 +18,12 @@
namespace llvm {
class MCOperand;
class TargetMachine;
class MBlazeInstPrinter : public MCInstPrinter {
public:
MBlazeInstPrinter(const MCAsmInfo &MAI) : MCInstPrinter(MAI) {
}
MBlazeInstPrinter(TargetMachine &TM, const MCAsmInfo &MAI)
: MCInstPrinter(MAI) {}
virtual void printInst(const MCInst *MI, raw_ostream &O);

3
lib/Target/MBlaze/MBlazeAsmPrinter.cpp
View File

@ -319,10 +319,11 @@ isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const {
}
static MCInstPrinter *createMBlazeMCInstPrinter(const Target &T,
TargetMachine &TM,
unsigned SyntaxVariant,
const MCAsmInfo &MAI) {
if (SyntaxVariant == 0)
return new MBlazeInstPrinter(MAI);
return new MBlazeInstPrinter(TM, MAI);
return 0;
}

5
lib/Target/MSP430/InstPrinter/MSP430InstPrinter.h
View File

@ -18,11 +18,12 @@
namespace llvm {
class MCOperand;
class TargetMachine;
class MSP430InstPrinter : public MCInstPrinter {
public:
MSP430InstPrinter(const MCAsmInfo &MAI) : MCInstPrinter(MAI) {
}
MSP430InstPrinter(TargetMachine &TM, const MCAsmInfo &MAI)
: MCInstPrinter(MAI) {}
virtual void printInst(const MCInst *MI, raw_ostream &O);

3
lib/Target/MSP430/MSP430AsmPrinter.cpp
View File

@ -164,10 +164,11 @@ void MSP430AsmPrinter::EmitInstruction(const MachineInstr *MI) {
}
static MCInstPrinter *createMSP430MCInstPrinter(const Target &T,
TargetMachine &TM,
unsigned SyntaxVariant,
const MCAsmInfo &MAI) {
if (SyntaxVariant == 0)
return new MSP430InstPrinter(MAI);
return new MSP430InstPrinter(TM, MAI);
return 0;
}

7
lib/Target/PowerPC/InstPrinter/PPCInstPrinter.h
View File

@ -17,13 +17,16 @@
#include "llvm/MC/MCInstPrinter.h"
namespace llvm {
class MCOperand;
class MCOperand;
class TargetMachine;
class PPCInstPrinter : public MCInstPrinter {
// 0 -> AIX, 1 -> Darwin.
unsigned SyntaxVariant;
public:
PPCInstPrinter(const MCAsmInfo &MAI, unsigned syntaxVariant)
PPCInstPrinter(TargetMachine &TM, const MCAsmInfo &MAI,
unsigned syntaxVariant)
: MCInstPrinter(MAI), SyntaxVariant(syntaxVariant) {}
bool isDarwinSyntax() const {

3
lib/Target/PowerPC/PPCAsmPrinter.cpp
View File

@ -680,9 +680,10 @@ static AsmPrinter *createPPCAsmPrinterPass(TargetMachine &tm,
}
static MCInstPrinter *createPPCMCInstPrinter(const Target &T,
TargetMachine &TM,
unsigned SyntaxVariant,
const MCAsmInfo &MAI) {
return new PPCInstPrinter(MAI, SyntaxVariant);
return new PPCInstPrinter(TM, MAI, SyntaxVariant);
}

8
lib/Target/X86/InstPrinter/X86ATTInstPrinter.h
View File

@ -17,12 +17,14 @@
#include "llvm/MC/MCInstPrinter.h"
namespace llvm {
class MCOperand;
class MCOperand;
class TargetMachine;
class X86ATTInstPrinter : public MCInstPrinter {
public:
X86ATTInstPrinter(const MCAsmInfo &MAI) : MCInstPrinter(MAI) {}
X86ATTInstPrinter(TargetMachine &TM, const MCAsmInfo &MAI)
: MCInstPrinter(MAI) {}
virtual void printInst(const MCInst *MI, raw_ostream &OS);
virtual StringRef getOpcodeName(unsigned Opcode) const;

6
lib/Target/X86/InstPrinter/X86IntelInstPrinter.h
View File

@ -18,11 +18,13 @@
#include "llvm/Support/raw_ostream.h"
namespace llvm {
class MCOperand;
class MCOperand;
class TargetMachine;
class X86IntelInstPrinter : public MCInstPrinter {
public:
X86IntelInstPrinter(const MCAsmInfo &MAI)
X86IntelInstPrinter(TargetMachine &TM, const MCAsmInfo &MAI)
: MCInstPrinter(MAI) {}
virtual void printInst(const MCInst *MI, raw_ostream &OS);

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

@ -709,12 +709,13 @@ void X86AsmPrinter::PrintDebugValueComment(const MachineInstr *MI,
//===----------------------------------------------------------------------===//
static MCInstPrinter *createX86MCInstPrinter(const Target &T,
TargetMachine &TM,
unsigned SyntaxVariant,
const MCAsmInfo &MAI) {
if (SyntaxVariant == 0)
return new X86ATTInstPrinter(MAI);
return new X86ATTInstPrinter(TM, MAI);
if (SyntaxVariant == 1)
return new X86IntelInstPrinter(MAI);
return new X86IntelInstPrinter(TM, MAI);
return 0;
}

5
tools/llvm-mc/Disassembler.cpp
View File

@ -127,7 +127,8 @@ static bool ByteArrayFromString(ByteArrayTy &ByteArray,
return false;
}
int Disassembler::disassemble(const Target &T, const std::string &Triple,
int Disassembler::disassemble(const Target &T, TargetMachine &TM,
const std::string &Triple,
MemoryBuffer &Buffer,
raw_ostream &Out) {
// Set up disassembler.
@ -145,7 +146,7 @@ int Disassembler::disassemble(const Target &T, const std::string &Triple,
}
int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
OwningPtr<MCInstPrinter> IP(T.createMCInstPrinter(AsmPrinterVariant,
OwningPtr<MCInstPrinter> IP(T.createMCInstPrinter(TM, AsmPrinterVariant,
*AsmInfo));
if (!IP) {
errs() << "error: no instruction printer for target " << Triple << '\n';

6
tools/llvm-mc/Disassembler.h
View File

@ -19,13 +19,15 @@
namespace llvm {
class Target;
class MemoryBuffer;
class Target;
class TargetMachine;
class raw_ostream;
class Disassembler {
public:
static int disassemble(const Target &target,
static int disassemble(const Target &target,
TargetMachine &TM,
const std::string &tripleString,
MemoryBuffer &buffer,
raw_ostream &Out);

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

@ -342,7 +342,7 @@ static int AssembleInput(const char *ProgName) {
// FIXME: There is a bit of code duplication with addPassesToEmitFile.
if (FileType == OFT_AssemblyFile) {
MCInstPrinter *IP =
TheTarget->createMCInstPrinter(OutputAsmVariant, *MAI);
TheTarget->createMCInstPrinter(*TM, OutputAsmVariant, *MAI);
MCCodeEmitter *CE = 0;
TargetAsmBackend *TAB = 0;
if (ShowEncoding) {
@ -403,12 +403,34 @@ static int DisassembleInput(const char *ProgName, bool Enhanced) {
return 1;
int Res;
if (Enhanced)
if (Enhanced) {
Res =
Disassembler::disassembleEnhanced(TripleName, *Buffer.take(), Out->os());
else
Res = Disassembler::disassemble(*TheTarget, TripleName,
} else {
// Package up features to be passed to target/subtarget
std::string FeaturesStr;
if (MCPU.size()) {
SubtargetFeatures Features;
Features.setCPU(MCPU);
FeaturesStr = Features.getString();
}
// FIXME: We shouldn't need to do this (and link in codegen).
// When we split this out, we should do it in a way that makes
// it straightforward to switch subtargets on the fly (.e.g,
// the .cpu and .code16 directives).
OwningPtr<TargetMachine> TM(TheTarget->createTargetMachine(TripleName,
FeaturesStr));
if (!TM) {
errs() << ProgName << ": error: could not create target for triple '"
<< TripleName << "'.\n";
return 1;
}
Res = Disassembler::disassemble(*TheTarget, *TM, TripleName,
*Buffer.take(), Out->os());
}
// Keep output if no errors.
if (Res == 0) Out->keep();

15
tools/llvm-objdump/llvm-objdump.cpp
View File

@ -38,6 +38,7 @@
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/system_error.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetRegistry.h"
#include "llvm/Target/TargetSelect.h"
#include <algorithm>
@ -182,9 +183,21 @@ static void DisassembleInput(const StringRef &Filename) {
return;
}
// FIXME: We shouldn't need to do this (and link in codegen).
// When we split this out, we should do it in a way that makes
// it straightforward to switch subtargets on the fly (.e.g,
// the .cpu and .code16 directives).
std::string FeaturesStr;
OwningPtr<TargetMachine> TM(TheTarget->createTargetMachine(TripleName,
FeaturesStr));
if (!TM) {
errs() << "error: could not create target for triple " << TripleName << "\n";
return;
}
int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
OwningPtr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
AsmPrinterVariant, *AsmInfo));
*TM, AsmPrinterVariant, *AsmInfo));
if (!IP) {
errs() << "error: no instruction printer for target " << TripleName << '\n';
return;