6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-27 14:34:58 +00:00
Code Issues Projects Releases Wiki Activity

Refactor MBlaze target to separate MC routines from Target routines.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@135953 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Evan Cheng 2011-07-25 20:18:18 +00:00
parent d7808d23ad
commit 8cb2d61bce
15 changed files with 216 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lib/Target/MBlaze/AsmParser/MBlazeAsmParser.cpp
View File

@ -286,19 +286,19 @@ void MBlazeOperand::print(raw_ostream &OS) const {
break; break;
case Register: case Register:
OS << "<register R"; OS << "<register R";
OS << MBlazeRegisterInfo::getRegisterNumbering(getReg()) << ">"; OS << getMBlazeRegisterNumbering(getReg()) << ">";
break; break;
case Token: case Token:
OS << "'" << getToken() << "'"; OS << "'" << getToken() << "'";
break; break;
case Memory: { case Memory: {
OS << "<memory R"; OS << "<memory R";
OS << MBlazeRegisterInfo::getRegisterNumbering(getMemBase()); OS << getMBlazeRegisterNumbering(getMemBase());
OS << ", "; OS << ", ";
unsigned RegOff = getMemOffReg(); unsigned RegOff = getMemOffReg();
if (RegOff) if (RegOff)
OS << "R" << MBlazeRegisterInfo::getRegisterNumbering(RegOff); OS << "R" << getMBlazeRegisterNumbering(RegOff);
else else
OS << getMemOff(); OS << getMemOff();
OS << ">"; OS << ">";

2
lib/Target/MBlaze/CMakeLists.txt
View File

@ -24,10 +24,8 @@ add_llvm_target(MBlazeCodeGen
MBlazeIntrinsicInfo.cpp MBlazeIntrinsicInfo.cpp
MBlazeSelectionDAGInfo.cpp MBlazeSelectionDAGInfo.cpp
MBlazeAsmPrinter.cpp MBlazeAsmPrinter.cpp
MBlazeAsmBackend.cpp
MBlazeMCInstLower.cpp MBlazeMCInstLower.cpp
MBlazeELFWriterInfo.cpp MBlazeELFWriterInfo.cpp
MBlazeMCCodeEmitter.cpp
) )
add_subdirectory(AsmParser) add_subdirectory(AsmParser)

12
lib/Target/MBlaze/MBlaze.h
View File

@ -15,6 +15,7 @@
#ifndef TARGET_MBLAZE_H #ifndef TARGET_MBLAZE_H
#define TARGET_MBLAZE_H #define TARGET_MBLAZE_H
#include "MCTargetDesc/MBlazeBaseInfo.h"
#include "MCTargetDesc/MBlazeMCTargetDesc.h" #include "MCTargetDesc/MBlazeMCTargetDesc.h"
#include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetMachine.h"
@ -22,17 +23,6 @@ namespace llvm {
class MBlazeTargetMachine; class MBlazeTargetMachine;
class FunctionPass; class FunctionPass;
class MachineCodeEmitter; class MachineCodeEmitter;
class MCCodeEmitter;
class MCInstrInfo;
class MCSubtargetInfo;
class TargetAsmBackend;
class formatted_raw_ostream;
MCCodeEmitter *createMBlazeMCCodeEmitter(const MCInstrInfo &MCII,
const MCSubtargetInfo &STI,
MCContext &Ctx);
TargetAsmBackend *createMBlazeAsmBackend(const Target &, const std::string &);
FunctionPass *createMBlazeISelDag(MBlazeTargetMachine &TM); FunctionPass *createMBlazeISelDag(MBlazeTargetMachine &TM);
FunctionPass *createMBlazeDelaySlotFillerPass(MBlazeTargetMachine &TM); FunctionPass *createMBlazeDelaySlotFillerPass(MBlazeTargetMachine &TM);

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

@ -136,19 +136,17 @@ void MBlazeAsmPrinter::printSavedRegsBitmask() {
const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo(); const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo();
for (unsigned i = 0, e = CSI.size(); i != e; ++i) { for (unsigned i = 0, e = CSI.size(); i != e; ++i) {
unsigned Reg = CSI[i].getReg(); unsigned Reg = CSI[i].getReg();
unsigned RegNum = MBlazeRegisterInfo::getRegisterNumbering(Reg); unsigned RegNum = getMBlazeRegisterNumbering(Reg);
if (MBlaze::GPRRegisterClass->contains(Reg)) if (MBlaze::GPRRegisterClass->contains(Reg))
CPUBitmask |= (1 << RegNum); CPUBitmask |= (1 << RegNum);
} }
// Return Address and Frame registers must also be set in CPUBitmask. // Return Address and Frame registers must also be set in CPUBitmask.
if (TFI->hasFP(*MF)) if (TFI->hasFP(*MF))
CPUBitmask |= (1 << MBlazeRegisterInfo:: CPUBitmask |= (1 << getMBlazeRegisterNumbering(RI.getFrameRegister(*MF)));
getRegisterNumbering(RI.getFrameRegister(*MF)));
if (MFI->adjustsStack()) if (MFI->adjustsStack())
CPUBitmask |= (1 << MBlazeRegisterInfo:: CPUBitmask |= (1 << getMBlazeRegisterNumbering(RI.getRARegister()));
getRegisterNumbering(RI.getRARegister()));
// Print CPUBitmask // Print CPUBitmask
OutStreamer.EmitRawText("\t.mask\t0x" + Twine::utohexstr(CPUBitmask)); OutStreamer.EmitRawText("\t.mask\t0x" + Twine::utohexstr(CPUBitmask));

6
lib/Target/MBlaze/MBlazeISelLowering.cpp
View File

@ -964,9 +964,9 @@ LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg,
// The last register argument that must be saved is MBlaze::R10 // The last register argument that must be saved is MBlaze::R10
TargetRegisterClass *RC = MBlaze::GPRRegisterClass; TargetRegisterClass *RC = MBlaze::GPRRegisterClass;
unsigned Begin = MBlazeRegisterInfo::getRegisterNumbering(MBlaze::R5); unsigned Begin = getMBlazeRegisterNumbering(MBlaze::R5);
unsigned Start = MBlazeRegisterInfo::getRegisterNumbering(ArgRegEnd+1); unsigned Start = getMBlazeRegisterNumbering(ArgRegEnd+1);
unsigned End = MBlazeRegisterInfo::getRegisterNumbering(MBlaze::R10); unsigned End = getMBlazeRegisterNumbering(MBlaze::R10);
unsigned StackLoc = Start - Begin + 1; unsigned StackLoc = Start - Begin + 1;
for (; Start <= End; ++Start, ++StackLoc) { for (; Start <= End; ++Start, ++StackLoc) {

56
lib/Target/MBlaze/MBlazeInstrInfo.h
View File

@ -166,62 +166,6 @@ namespace MBlaze {
} }
} }
/// MBlazeII - This namespace holds all of the target specific flags that
/// instruction info tracks.
///
namespace MBlazeII {
enum {
// PseudoFrm - This represents an instruction that is a pseudo instruction
// or one that has not been implemented yet. It is illegal to code generate
// it, but tolerated for intermediate implementation stages.
FPseudo = 0,
FRRR,
FRRI,
FCRR,
FCRI,
FRCR,
FRCI,
FCCR,
FCCI,
FRRCI,
FRRC,
FRCX,
FRCS,
FCRCS,
FCRCX,
FCX,
FCR,
FRIR,
FRRRR,
FRI,
FC,
FormMask = 63
//===------------------------------------------------------------------===//
// MBlaze Specific MachineOperand flags.
// MO_NO_FLAG,
/// MO_GOT - Represents the offset into the global offset table at which
/// the address the relocation entry symbol resides during execution.
// MO_GOT,
/// MO_GOT_CALL - Represents the offset into the global offset table at
/// which the address of a call site relocation entry symbol resides
/// during execution. This is different from the above since this flag
/// can only be present in call instructions.
// MO_GOT_CALL,
/// MO_GPREL - Represents the offset from the current gp value to be used
/// for the relocatable object file being produced.
// MO_GPREL,
/// MO_ABS_HILO - Represents the hi or low part of an absolute symbol
/// address.
// MO_ABS_HILO
};
}
class MBlazeInstrInfo : public MBlazeGenInstrInfo { class MBlazeInstrInfo : public MBlazeGenInstrInfo {
MBlazeTargetMachine &TM; MBlazeTargetMachine &TM;
const MBlazeRegisterInfo RI; const MBlazeRegisterInfo RI;

65
lib/Target/MBlaze/MBlazeRegisterInfo.cpp
View File

@ -45,71 +45,6 @@ MBlazeRegisterInfo::
MBlazeRegisterInfo(const MBlazeSubtarget &ST, const TargetInstrInfo &tii) MBlazeRegisterInfo(const MBlazeSubtarget &ST, const TargetInstrInfo &tii)
: MBlazeGenRegisterInfo(MBlaze::R15), Subtarget(ST), TII(tii) {} : MBlazeGenRegisterInfo(MBlaze::R15), Subtarget(ST), TII(tii) {}
/// getRegisterNumbering - Given the enum value for some register, e.g.
/// MBlaze::R0, return the number that it corresponds to (e.g. 0).
unsigned MBlazeRegisterInfo::getRegisterNumbering(unsigned RegEnum) {
switch (RegEnum) {
case MBlaze::R0 : return 0;
case MBlaze::R1 : return 1;
case MBlaze::R2 : return 2;
case MBlaze::R3 : return 3;
case MBlaze::R4 : return 4;
case MBlaze::R5 : return 5;
case MBlaze::R6 : return 6;
case MBlaze::R7 : return 7;
case MBlaze::R8 : return 8;
case MBlaze::R9 : return 9;
case MBlaze::R10 : return 10;
case MBlaze::R11 : return 11;
case MBlaze::R12 : return 12;
case MBlaze::R13 : return 13;
case MBlaze::R14 : return 14;
case MBlaze::R15 : return 15;
case MBlaze::R16 : return 16;
case MBlaze::R17 : return 17;
case MBlaze::R18 : return 18;
case MBlaze::R19 : return 19;
case MBlaze::R20 : return 20;
case MBlaze::R21 : return 21;
case MBlaze::R22 : return 22;
case MBlaze::R23 : return 23;
case MBlaze::R24 : return 24;
case MBlaze::R25 : return 25;
case MBlaze::R26 : return 26;
case MBlaze::R27 : return 27;
case MBlaze::R28 : return 28;
case MBlaze::R29 : return 29;
case MBlaze::R30 : return 30;
case MBlaze::R31 : return 31;
case MBlaze::RPC : return 0x0000;
case MBlaze::RMSR : return 0x0001;
case MBlaze::REAR : return 0x0003;
case MBlaze::RESR : return 0x0005;
case MBlaze::RFSR : return 0x0007;
case MBlaze::RBTR : return 0x000B;
case MBlaze::REDR : return 0x000D;
case MBlaze::RPID : return 0x1000;
case MBlaze::RZPR : return 0x1001;
case MBlaze::RTLBX : return 0x1002;
case MBlaze::RTLBLO : return 0x1003;
case MBlaze::RTLBHI : return 0x1004;
case MBlaze::RPVR0 : return 0x2000;
case MBlaze::RPVR1 : return 0x2001;
case MBlaze::RPVR2 : return 0x2002;
case MBlaze::RPVR3 : return 0x2003;
case MBlaze::RPVR4 : return 0x2004;
case MBlaze::RPVR5 : return 0x2005;
case MBlaze::RPVR6 : return 0x2006;
case MBlaze::RPVR7 : return 0x2007;
case MBlaze::RPVR8 : return 0x2008;
case MBlaze::RPVR9 : return 0x2009;
case MBlaze::RPVR10 : return 0x200A;
case MBlaze::RPVR11 : return 0x200B;
default: llvm_unreachable("Unknown register number!");
}
return 0; // Not reached
}
/// getRegisterFromNumbering - Given the enum value for some register, e.g. /// getRegisterFromNumbering - Given the enum value for some register, e.g.
/// MBlaze::R0, return the number that it corresponds to (e.g. 0). /// MBlaze::R0, return the number that it corresponds to (e.g. 0).
unsigned MBlazeRegisterInfo::getRegisterFromNumbering(unsigned Reg) { unsigned MBlazeRegisterInfo::getRegisterFromNumbering(unsigned Reg) {

3
lib/Target/MBlaze/MBlazeRegisterInfo.h
View File

@ -42,9 +42,6 @@ struct MBlazeRegisterInfo : public MBlazeGenRegisterInfo {
MBlazeRegisterInfo(const MBlazeSubtarget &Subtarget, MBlazeRegisterInfo(const MBlazeSubtarget &Subtarget,
const TargetInstrInfo &tii); const TargetInstrInfo &tii);
/// getRegisterNumbering - Given the enum value for some register, e.g.
/// MBlaze::RA, return the number that it corresponds to (e.g. 31).
static unsigned getRegisterNumbering(unsigned RegEnum);
static unsigned getRegisterFromNumbering(unsigned RegEnum); static unsigned getRegisterFromNumbering(unsigned RegEnum);
static unsigned getSpecialRegisterFromNumbering(unsigned RegEnum); static unsigned getSpecialRegisterFromNumbering(unsigned RegEnum);
static bool isRegister(unsigned RegEnum); static bool isRegister(unsigned RegEnum);

35
lib/Target/MBlaze/MBlazeTargetMachine.cpp
View File

@ -20,44 +20,9 @@
#include "llvm/Target/TargetRegistry.h" #include "llvm/Target/TargetRegistry.h"
using namespace llvm; using namespace llvm;
static MCStreamer *createMCStreamer(const Target &T, const std::string &TT,
MCContext &Ctx, TargetAsmBackend &TAB,
raw_ostream &_OS,
MCCodeEmitter *_Emitter,
bool RelaxAll,
bool NoExecStack) {
Triple TheTriple(TT);
if (TheTriple.isOSDarwin()) {
llvm_unreachable("MBlaze does not support Darwin MACH-O format");
return NULL;
}
if (TheTriple.isOSWindows()) {
llvm_unreachable("MBlaze does not support Windows COFF format");
return NULL;
}
return createELFStreamer(Ctx, TAB, _OS, _Emitter, RelaxAll, NoExecStack);
}
extern "C" void LLVMInitializeMBlazeTarget() { extern "C" void LLVMInitializeMBlazeTarget() {
// Register the target. // Register the target.
RegisterTargetMachine<MBlazeTargetMachine> X(TheMBlazeTarget); RegisterTargetMachine<MBlazeTargetMachine> X(TheMBlazeTarget);
// Register the MC code emitter
TargetRegistry::RegisterCodeEmitter(TheMBlazeTarget,
llvm::createMBlazeMCCodeEmitter);
// Register the asm backend
TargetRegistry::RegisterAsmBackend(TheMBlazeTarget,
createMBlazeAsmBackend);
// Register the object streamer
TargetRegistry::RegisterObjectStreamer(TheMBlazeTarget,
createMCStreamer);
} }
// DataLayout --> Big-endian, 32-bit pointer/ABI/alignment // DataLayout --> Big-endian, 32-bit pointer/ABI/alignment

4
lib/Target/MBlaze/MCTargetDesc/CMakeLists.txt
View File

@ -1,4 +1,6 @@
add_llvm_library(LLVMMBlazeDesc add_llvm_library(LLVMMBlazeDesc
MBlazeMCTargetDesc.cpp MBlazeAsmBackend.cpp
MBlazeMCAsmInfo.cpp MBlazeMCAsmInfo.cpp
MBlazeMCCodeEmitter.cpp
MBlazeMCTargetDesc.cpp
) )

5
lib/Target/MBlaze/MBlazeAsmBackend.cpp → lib/Target/MBlaze/MCTargetDesc/MBlazeAsmBackend.cpp
View File

@ -7,10 +7,8 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MCTargetDesc/MBlazeMCTargetDesc.h"
#include "llvm/MC/TargetAsmBackend.h" #include "llvm/MC/TargetAsmBackend.h"
#include "MBlaze.h"
#include "MBlazeELFWriterInfo.h"
#include "llvm/ADT/Twine.h"
#include "llvm/MC/MCAssembler.h" #include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCAsmLayout.h" #include "llvm/MC/MCAsmLayout.h"
#include "llvm/MC/MCELFObjectWriter.h" #include "llvm/MC/MCELFObjectWriter.h"
@ -20,6 +18,7 @@
#include "llvm/MC/MCSectionELF.h" #include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCSectionMachO.h" #include "llvm/MC/MCSectionMachO.h"
#include "llvm/MC/MCValue.h" #include "llvm/MC/MCValue.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/ELF.h" #include "llvm/Support/ELF.h"
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"

148
lib/Target/MBlaze/MCTargetDesc/MBlazeBaseInfo.h Normal file
View File

@ -0,0 +1,148 @@
//===-- MBlazeBaseInfo.h - Top level definitions for MBlaze -- --*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains small standalone helper functions and enum definitions for
// the MBlaze target useful for the compiler back-end and the MC libraries.
// As such, it deliberately does not include references to LLVM core
// code gen types, passes, etc..
//
//===----------------------------------------------------------------------===//
#ifndef MBlazeBASEINFO_H
#define MBlazeBASEINFO_H
#include "MBlazeMCTargetDesc.h"
#include "llvm/Support/ErrorHandling.h"
namespace llvm {
/// MBlazeII - This namespace holds all of the target specific flags that
/// instruction info tracks.
///
namespace MBlazeII {
enum {
// PseudoFrm - This represents an instruction that is a pseudo instruction
// or one that has not been implemented yet. It is illegal to code generate
// it, but tolerated for intermediate implementation stages.
FPseudo = 0,
FRRR,
FRRI,
FCRR,
FCRI,
FRCR,
FRCI,
FCCR,
FCCI,
FRRCI,
FRRC,
FRCX,
FRCS,
FCRCS,
FCRCX,
FCX,
FCR,
FRIR,
FRRRR,
FRI,
FC,
FormMask = 63
//===------------------------------------------------------------------===//
// MBlaze Specific MachineOperand flags.
// MO_NO_FLAG,
/// MO_GOT - Represents the offset into the global offset table at which
/// the address the relocation entry symbol resides during execution.
// MO_GOT,
/// MO_GOT_CALL - Represents the offset into the global offset table at
/// which the address of a call site relocation entry symbol resides
/// during execution. This is different from the above since this flag
/// can only be present in call instructions.
// MO_GOT_CALL,
/// MO_GPREL - Represents the offset from the current gp value to be used
/// for the relocatable object file being produced.
// MO_GPREL,
/// MO_ABS_HILO - Represents the hi or low part of an absolute symbol
/// address.
// MO_ABS_HILO
};
}
/// getMBlazeRegisterNumbering - Given the enum value for some register, e.g.
/// MBlaze::R0, return the number that it corresponds to (e.g. 0).
static inline unsigned getMBlazeRegisterNumbering(unsigned RegEnum) {
switch (RegEnum) {
case MBlaze::R0 : return 0;
case MBlaze::R1 : return 1;
case MBlaze::R2 : return 2;
case MBlaze::R3 : return 3;
case MBlaze::R4 : return 4;
case MBlaze::R5 : return 5;
case MBlaze::R6 : return 6;
case MBlaze::R7 : return 7;
case MBlaze::R8 : return 8;
case MBlaze::R9 : return 9;
case MBlaze::R10 : return 10;
case MBlaze::R11 : return 11;
case MBlaze::R12 : return 12;
case MBlaze::R13 : return 13;
case MBlaze::R14 : return 14;
case MBlaze::R15 : return 15;
case MBlaze::R16 : return 16;
case MBlaze::R17 : return 17;
case MBlaze::R18 : return 18;
case MBlaze::R19 : return 19;
case MBlaze::R20 : return 20;
case MBlaze::R21 : return 21;
case MBlaze::R22 : return 22;
case MBlaze::R23 : return 23;
case MBlaze::R24 : return 24;
case MBlaze::R25 : return 25;
case MBlaze::R26 : return 26;
case MBlaze::R27 : return 27;
case MBlaze::R28 : return 28;
case MBlaze::R29 : return 29;
case MBlaze::R30 : return 30;
case MBlaze::R31 : return 31;
case MBlaze::RPC : return 0x0000;
case MBlaze::RMSR : return 0x0001;
case MBlaze::REAR : return 0x0003;
case MBlaze::RESR : return 0x0005;
case MBlaze::RFSR : return 0x0007;
case MBlaze::RBTR : return 0x000B;
case MBlaze::REDR : return 0x000D;
case MBlaze::RPID : return 0x1000;
case MBlaze::RZPR : return 0x1001;
case MBlaze::RTLBX : return 0x1002;
case MBlaze::RTLBLO : return 0x1003;
case MBlaze::RTLBHI : return 0x1004;
case MBlaze::RPVR0 : return 0x2000;
case MBlaze::RPVR1 : return 0x2001;
case MBlaze::RPVR2 : return 0x2002;
case MBlaze::RPVR3 : return 0x2003;
case MBlaze::RPVR4 : return 0x2004;
case MBlaze::RPVR5 : return 0x2005;
case MBlaze::RPVR6 : return 0x2006;
case MBlaze::RPVR7 : return 0x2007;
case MBlaze::RPVR8 : return 0x2008;
case MBlaze::RPVR9 : return 0x2009;
case MBlaze::RPVR10 : return 0x200A;
case MBlaze::RPVR11 : return 0x200B;
default: llvm_unreachable("Unknown register number!");
}
return 0; // Not reached
}
} // end namespace llvm;
#endif

8
lib/Target/MBlaze/MBlazeMCCodeEmitter.cpp → lib/Target/MBlaze/MCTargetDesc/MBlazeMCCodeEmitter.cpp
View File

@ -12,11 +12,13 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#define DEBUG_TYPE "mccodeemitter" #define DEBUG_TYPE "mccodeemitter"
#include "MBlaze.h" #include "MCTargetDesc/MBlazeBaseInfo.h"
#include "MBlazeInstrInfo.h" #include "MCTargetDesc/MBlazeMCTargetDesc.h"
#include "llvm/MC/MCCodeEmitter.h" #include "llvm/MC/MCCodeEmitter.h"
#include "llvm/MC/MCExpr.h" #include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCInst.h" #include "llvm/MC/MCInst.h"
#include "llvm/MC/MCInstrInfo.h"
#include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/MC/MCSymbol.h" #include "llvm/MC/MCSymbol.h"
#include "llvm/MC/MCFixup.h" #include "llvm/MC/MCFixup.h"
#include "llvm/ADT/Statistic.h" #include "llvm/ADT/Statistic.h"
@ -106,7 +108,7 @@ MCCodeEmitter *llvm::createMBlazeMCCodeEmitter(const MCInstrInfo &MCII,
unsigned MBlazeMCCodeEmitter::getMachineOpValue(const MCInst &MI, unsigned MBlazeMCCodeEmitter::getMachineOpValue(const MCInst &MI,
const MCOperand &MO) const { const MCOperand &MO) const {
if (MO.isReg()) if (MO.isReg())
return MBlazeRegisterInfo::getRegisterNumbering(MO.getReg()); return getMBlazeRegisterNumbering(MO.getReg());
else if (MO.isImm()) else if (MO.isImm())
return static_cast<unsigned>(MO.getImm()); return static_cast<unsigned>(MO.getImm());
else if (MO.isExpr()) else if (MO.isExpr())

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

@ -15,8 +15,10 @@
#include "MBlazeMCAsmInfo.h" #include "MBlazeMCAsmInfo.h"
#include "llvm/MC/MCInstrInfo.h" #include "llvm/MC/MCInstrInfo.h"
#include "llvm/MC/MCRegisterInfo.h" #include "llvm/MC/MCRegisterInfo.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSubtargetInfo.h" #include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/Target/TargetRegistry.h" #include "llvm/Target/TargetRegistry.h"
#include "llvm/Support/ErrorHandling.h"
#define GET_INSTRINFO_MC_DESC #define GET_INSTRINFO_MC_DESC
#include "MBlazeGenInstrInfo.inc" #include "MBlazeGenInstrInfo.inc"
@ -68,6 +70,27 @@ static MCCodeGenInfo *createMBlazeMCCodeGenInfo(StringRef TT, Reloc::Model RM,
return X; return X;
} }
static MCStreamer *createMCStreamer(const Target &T, const std::string &TT,
MCContext &Ctx, TargetAsmBackend &TAB,
raw_ostream &_OS,
MCCodeEmitter *_Emitter,
bool RelaxAll,
bool NoExecStack) {
Triple TheTriple(TT);
if (TheTriple.isOSDarwin()) {
llvm_unreachable("MBlaze does not support Darwin MACH-O format");
return NULL;
}
if (TheTriple.isOSWindows()) {
llvm_unreachable("MBlaze does not support Windows COFF format");
return NULL;
}
return createELFStreamer(Ctx, TAB, _OS, _Emitter, RelaxAll, NoExecStack);
}
// Force static initialization. // Force static initialization.
extern "C" void LLVMInitializeMBlazeTargetMC() { extern "C" void LLVMInitializeMBlazeTargetMC() {
// Register the MC asm info. // Register the MC asm info.
@ -87,4 +110,16 @@ extern "C" void LLVMInitializeMBlazeTargetMC() {
// Register the MC subtarget info. // Register the MC subtarget info.
TargetRegistry::RegisterMCSubtargetInfo(TheMBlazeTarget, TargetRegistry::RegisterMCSubtargetInfo(TheMBlazeTarget,
createMBlazeMCSubtargetInfo); createMBlazeMCSubtargetInfo);
// Register the MC code emitter
TargetRegistry::RegisterCodeEmitter(TheMBlazeTarget,
llvm::createMBlazeMCCodeEmitter);
// Register the asm backend
TargetRegistry::RegisterAsmBackend(TheMBlazeTarget,
createMBlazeAsmBackend);
// Register the object streamer
TargetRegistry::RegisterObjectStreamer(TheMBlazeTarget,
createMCStreamer);
} }

13
lib/Target/MBlaze/MCTargetDesc/MBlazeMCTargetDesc.h
View File

@ -14,13 +14,26 @@
#ifndef MBLAZEMCTARGETDESC_H #ifndef MBLAZEMCTARGETDESC_H
#define MBLAZEMCTARGETDESC_H #define MBLAZEMCTARGETDESC_H
#include <string>
namespace llvm { namespace llvm {
class MCContext;
class MCCodeEmitter;
class MCInstrInfo;
class MCSubtargetInfo; class MCSubtargetInfo;
class Target; class Target;
class TargetAsmBackend;
class StringRef; class StringRef;
class formatted_raw_ostream;
extern Target TheMBlazeTarget; extern Target TheMBlazeTarget;
MCCodeEmitter *createMBlazeMCCodeEmitter(const MCInstrInfo &MCII,
const MCSubtargetInfo &STI,
MCContext &Ctx);
TargetAsmBackend *createMBlazeAsmBackend(const Target &, const std::string &);
} // End llvm namespace } // End llvm namespace
// Defines symbolic names for MBlaze registers. This defines a mapping from // Defines symbolic names for MBlaze registers. This defines a mapping from