-//===-- EmitBytecodeToAssembly.cpp - Emit bytecode to Sparc .s File --------==//
+//===-- EmitBytecodeToAssembly.cpp - Emit bytecode to SparcV9 .s File --------==//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#include "SparcInternals.h"
+#include "SparcV9Internals.h"
#include "llvm/Pass.h"
#include "llvm/Bytecode/Writer.h"
#include <iostream>
<< "\n";
}
- // SparcBytecodeWriter - Write bytecode out to a stream that is sparc'ified
- class SparcBytecodeWriter : public Pass {
+ // SparcV9BytecodeWriter - Write bytecode out to a stream that is sparc'ified
+ class SparcV9BytecodeWriter : public Pass {
std::ostream &Out;
public:
- SparcBytecodeWriter(std::ostream &out) : Out(out) {}
+ SparcV9BytecodeWriter(std::ostream &out) : Out(out) {}
- const char *getPassName() const { return "Emit Bytecode to Sparc Assembly";}
+ const char *getPassName() const { return "Emit Bytecode to SparcV9 Assembly";}
virtual bool run(Module &M) {
// Write an object containing the bytecode to the SPARC assembly stream
} // end anonymous namespace
Pass *createBytecodeAsmPrinterPass(std::ostream &Out) {
- return new SparcBytecodeWriter(Out);
+ return new SparcV9BytecodeWriter(Out);
}
} // End llvm namespace
#include "llvm/Constants.h"
#include "llvm/BasicBlock.h"
#include "llvm/DerivedTypes.h"
-#include "../SparcInstrSelectionSupport.h"
+#include "../SparcV9InstrSelectionSupport.h"
namespace llvm {
LEVEL = ../../../..
DIRS =
-LIBRARYNAME = select
+LIBRARYNAME = sparcv9select
include $(LEVEL)/Makefile.common
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/Support/CFG.h"
#include "Support/SetOperations.h"
-#include "../SparcInternals.h"
+#include "../SparcV9Internals.h"
namespace llvm {
##===----------------------------------------------------------------------===##
LEVEL = ../../../..
-LIBRARYNAME = livevar
+LIBRARYNAME = sparcv9livevar
include $(LEVEL)/Makefile.common
-##===- lib/Target/Sparc/Makefile ---------------------------*- Makefile -*-===##
+##===- lib/Target/SparcV9/Makefile ---------------------------*- Makefile -*-===##
#
# The LLVM Compiler Infrastructure
#
#
##===----------------------------------------------------------------------===##
LEVEL = ../../..
-LIBRARYNAME = sparc
+LIBRARYNAME = sparcv9
DIRS = InstrSelection RegAlloc LiveVar
-ExtraSource = Sparc.burm.cpp
+ExtraSource = SparcV9.burm.cpp
include $(LEVEL)/Makefile.common
DEBUG_FLAG = -D_DEBUG
endif
-Sparc.burg.in1 : $(SourceDir)/Sparc.burg.in
+SparcV9.burg.in1 : $(SourceDir)/SparcV9.burg.in
$(CXX) -E -I$(LLVM_SRC_ROOT)/include $(DEBUG_FLAG) -x c++ $< | $(SED) '/^#/d' | $(SED) 's/Ydefine/#define/' > $@
-Sparc.burm : Sparc.burg.in1
+SparcV9.burm : SparcV9.burg.in1
$(CXX) -E -I$(LLVM_SRC_ROOT)/include $(DEBUG_FLAG) -x c++ $< | $(SED) '/^#/d' | $(SED) 's/^Xinclude/#include/' | $(SED) 's/^Xdefine/#define/' > $@
-Sparc.burm.cpp: Sparc.burm
+SparcV9.burm.cpp: SparcV9.burm
@echo "Burging `basename $<`"
$(RunBurg) $< -o $@
-$(BUILD_OBJ_DIR)/Debug/Sparc.burm.lo: Sparc.burm.cpp
+$(BUILD_OBJ_DIR)/Debug/SparcV9.burm.lo: SparcV9.burm.cpp
$(CompileG) $< -o $@
-$(BUILD_OBJ_DIR)/Release/Sparc.burm.lo: Sparc.burm.cpp
+$(BUILD_OBJ_DIR)/Release/SparcV9.burm.lo: SparcV9.burm.cpp
$(CompileO) $< -o $@
-$(BUILD_OBJ_DIR)/Profile/Sparc.burm.lo: Sparc.burm.cpp
+$(BUILD_OBJ_DIR)/Profile/SparcV9.burm.lo: SparcV9.burm.cpp
$(CompileP) $< -o $@
-$(BUILD_OBJ_DIR)/Depend/Sparc.burm.d: $(BUILD_OBJ_DIR)/Depend/.dir
+$(BUILD_OBJ_DIR)/Depend/SparcV9.burm.d: $(BUILD_OBJ_DIR)/Depend/.dir
touch $@
TARGET_NAME := SparcV9
$(TBLGEN) -I $(SourceDir) $< -gen-emitter -o $@
clean::
- $(RM) -f $(TARGET_NAME)CodeEmitter.inc Sparc.burg.in1 Sparc.burm Sparc.burm.cpp
+ $(RM) -f $(TARGET_NAME)CodeEmitter.inc SparcV9.burg.in1 SparcV9.burm SparcV9.burm.cpp
-//===- lib/Target/Sparc/MappingInfo.h ---------------------------*- C++ -*-===//
+//===- lib/Target/SparcV9/MappingInfo.h ---------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
DIRS =
-LIBRARYNAME = regalloc
+LIBRARYNAME = sparcv9regalloc
BUILD_ARCHIVE = 1
%term Or=OrOPCODE
%term Xor=XorOPCODE
/* Use the next 4 to distinguish bitwise operators from
- * logical operators. This is no longer used for Sparc,
+ * logical operators. This is no longer used for SparcV9,
* but may be useful for other target machines.
* The last one is the bitwise Not(val) == XOR val, 11..1.
* Note that it is also a binary operator, not unary.
-//===- SparcV9.td - Target Description for Sparc V9 Target ----------------===//
+//===- SparcV9.td - Target Description for SparcV9 V9 Target ----------------===//
//
// The LLVM Compiler Infrastructure
//
// Instructions
//===----------------------------------------------------------------------===//
-class InstV9 : Instruction { // Sparc instruction baseline
+class InstV9 : Instruction { // SparcV9 instruction baseline
field bits<32> Inst;
let Namespace = "V9";
bits<2> op;
let Inst{31-30} = op; // Top two bits are the 'op' field
- // Bit attributes specific to Sparc instructions
+ // Bit attributes specific to SparcV9 instructions
bit isPasi = 0; // Does this instruction affect an alternate addr space?
bit isDeprecated = 0; // Is this instruction deprecated?
bit isPrivileged = 0; // Is this a privileged instruction?
}
// Section A.4: Branch on Floating-Point Condition Codes (FBfcc) p140
-// The following deprecated instructions don't seem to play nice on Sparc
+// The following deprecated instructions don't seem to play nice on SparcV9
/*
let isDeprecated = 1 in {
let op2 = 0b110 in {
}
// Section A.5: Branch on FP condition codes with prediction - p143
-// Not used in the Sparc backend (directly)
+// Not used in the SparcV9 backend (directly)
/*
let op2 = 0b101 in {
def FBPA : F2_3<0b1000, "fba">; // Branch always
}
// Section A.7: Branch on integer condition codes with prediction - p148
-// Not used in the Sparc backend
+// Not used in the SparcV9 backend
/*
let op2 = 0b001 in {
def BPA : F2_3<0b1000, "bpa">; // Branch always
// Section A.10: Divide (64-bit / 32-bit) - p178
-// Not used in the Sparc backend
+// Not used in the SparcV9 backend
/*
let isDeprecated = 1 in {
def UDIVr : F3_1<2, 0b001110, "udiv">; // udiv r, r, r
*/
// Section A.11: DONE and RETRY - p181
-// Not used in the Sparc backend
+// Not used in the SparcV9 backend
/*
let isPrivileged = 1 in {
def DONE : F3_18<0, "done">; // done
def FCMPS : F3_15<2, 0b110101, 0b001010001, "fcmps">; // fcmps %fcc, r1, r2
def FCMPD : F3_15<2, 0b110101, 0b001010010, "fcmpd">; // fcmpd %fcc, r1, r2
def FCMPQ : F3_15<2, 0b110101, 0b001010011, "fcmpq">; // fcmpq %fcc, r1, r2
-// Currently unused in the Sparc backend
+// Currently unused in the SparcV9 backend
/*
def FCMPES : F3_15<2, 0b110101, 0b001010101, "fcmpes">; // fcmpes %fcc, r1, r2
def FCMPED : F3_15<2, 0b110101, 0b001010110, "fcmped">; // fcmped %fcc, r1, r2
// Not currently used
// Section A.24: Jump and Link - p172
-// Mimicking the Sparc's instr def...
+// Mimicking the SparcV9's instr def...
def JMPLCALLr : F3_1<2, 0b111000, "jmpl">; // jmpl [rs1+rs2], rd
def JMPLCALLi : F3_2<2, 0b111000, "jmpl">; // jmpl [rs1+imm], rd
def JMPLRETr : F3_1<2, 0b111000, "jmpl">; // jmpl [rs1+rs2], rd
def XNORcci : F3_2<2, 0b010111, "xnorcc">; // xnorcc rs1, imm, rd
// Section A.32: Memory Barrier - p186
-// Not currently used in the Sparc backend
+// Not currently used in the SparcV9 backend
// Section A.33: Move Floating-Point Register on Condition (FMOVcc)
// ======================= Single Floating Point ======================
def UDIVXi : F3_2<2, 0b001101, "udivx">; // udivx r, i, r
// Section A.38: Multiply (32-bit) - p200
-// Not used in the Sparc backend
+// Not used in the SparcV9 backend
/*
let Inst{13} = 0 in {
def UMULr : F3_1<2, 0b001010, "umul">; // umul r, r, r
*/
// Section A.39: Multiply Step - p202
-// Not currently used in the Sparc backend
+// Not currently used in the SparcV9 backend
// Section A.40: No operation - p204
// NOP is really a pseudo-instruction (special case of SETHI)
}
// Section A.41: Population Count - p205
-// Not currently used in the Sparc backend
+// Not currently used in the SparcV9 backend
// Section A.42: Prefetch Data - p206
-// Not currently used in the Sparc backend
+// Not currently used in the SparcV9 backend
// Section A.43: Read Privileged Register - p211
-// Not currently used in the Sparc backend
+// Not currently used in the SparcV9 backend
// Section A.44: Read State Register
// The only instr from this section currently used is RDCCR
def RESTOREi : F3_2<2, 0b111101, "restore">; // restore r, i, r
// Section A.47: SAVED and RESTORED - p219
-// Not currently used in Sparc backend
+// Not currently used in SparcV9 backend
// Section A.48: SETHI - p220
let op2 = 0b100 in {
}
// Section A.49: Shift - p221
-// Not currently used in the Sparc backend
+// Not currently used in the SparcV9 backend
/*
uses 5 least significant bits of rs2
let x = 0 in {
def SRAXi6 : F3_13<2, 0b100111, "srax">; // srax r, shcnt64, r
// Section A.50: Sofware-Initiated Reset - p223
-// Not currently used in the Sparc backend
+// Not currently used in the SparcV9 backend
// Section A.51: Store Barrier - p224
-// Not currently used in the Sparc backend
+// Not currently used in the SparcV9 backend
// Section A.52: Store Floating-point - p225
// Store instructions all want their rd register first
def STDFr : F3_1rd<3, 0b100111, "std">; // std r, [r+r]
def STDFi : F3_2rd<3, 0b100111, "std">; // std r, [r+i]
-// Not currently used in the Sparc backend
+// Not currently used in the SparcV9 backend
/*
def STQFr : F3_1rd<3, 0b100110, "stq">; // stq r, [r+r]
def STQFi : F3_2rd<3, 0b100110, "stq">; // stq r, [r+i]
// FIXME: An encoding needs to be chosen here, because STFSRx expect rd=0,
// while STXFSRx expect rd=1, but assembly syntax dictates %fsr as first arg.
-// These are being disabled because they aren't used in the Sparc backend.
+// These are being disabled because they aren't used in the SparcV9 backend.
/*
let isDeprecated = 1 in {
def STFSRr : F3_1<3, 0b100101, "st">; // st %fsr, [r+r]
def STXFSRi : F3_2<3, 0b100101, "stx">; // stx %fsr, [r+i]
// Section A.53: Store Floating-Point into Alternate Space - p227
-// Not currently used in the Sparc backend
+// Not currently used in the SparcV9 backend
// Section A.54: Store Integer - p229
// Store instructions all want their rd register first
def STXi : F3_2rd<3, 0b001110, "stx">; // stx r, [r+i]
// Section A.55: Store Integer into Alternate Space - p231
-// Not currently used in the Sparc backend
+// Not currently used in the SparcV9 backend
// Section A.56: Subtract - p233
def SUBr : F3_1<2, 0b000100, "sub">; // sub r, r, r
-//===-- EmitAssembly.cpp - Emit Sparc Specific .s File ---------------------==//
+//===-- EmitAssembly.cpp - Emit SparcV9 Specific .s File ---------------------==//
//
// The LLVM Compiler Infrastructure
//
#include "llvm/Support/Mangler.h"
#include "Support/StringExtras.h"
#include "Support/Statistic.h"
-#include "SparcInternals.h"
+#include "SparcV9Internals.h"
#include <string>
using namespace llvm;
}
// getID Wrappers - Ensure consistent usage
- // Symbol names in Sparc assembly language have these rules:
+ // Symbol names in SparcV9 assembly language have these rules:
// (a) Must match { letter | _ | . | $ } { letter | _ | . | $ | digit }*
// (b) A name beginning in "." is treated as a local name.
std::string getID(const Function *F) {
//===----------------------------------------------------------------------===//
-// SparcAsmPrinter Code
+// SparcV9AsmPrinter Code
//===----------------------------------------------------------------------===//
namespace {
- struct SparcAsmPrinter : public FunctionPass, public AsmPrinter {
- inline SparcAsmPrinter(std::ostream &os, const TargetMachine &t)
+ struct SparcV9AsmPrinter : public FunctionPass, public AsmPrinter {
+ inline SparcV9AsmPrinter(std::ostream &os, const TargetMachine &t)
: AsmPrinter(os, t) {}
const Function *currFunction;
const char *getPassName() const {
- return "Output Sparc Assembly for Functions";
+ return "Output SparcV9 Assembly for Functions";
}
virtual bool doInitialization(Module &M) {
} // End anonymous namespace
inline bool
-SparcAsmPrinter::OpIsBranchTargetLabel(const MachineInstr *MI,
+SparcV9AsmPrinter::OpIsBranchTargetLabel(const MachineInstr *MI,
unsigned int opNum) {
switch (MI->getOpcode()) {
case V9::JMPLCALLr:
}
inline bool
-SparcAsmPrinter::OpIsMemoryAddressBase(const MachineInstr *MI,
+SparcV9AsmPrinter::OpIsMemoryAddressBase(const MachineInstr *MI,
unsigned int opNum) {
if (Target.getInstrInfo().isLoad(MI->getOpcode()))
return (opNum == 0);
printOneOperand(mop2, opCode);
unsigned int
-SparcAsmPrinter::printOperands(const MachineInstr *MI,
+SparcV9AsmPrinter::printOperands(const MachineInstr *MI,
unsigned int opNum)
{
const MachineOperand& mop = MI->getOperand(opNum);
}
void
-SparcAsmPrinter::printOneOperand(const MachineOperand &mop,
+SparcV9AsmPrinter::printOneOperand(const MachineOperand &mop,
MachineOpCode opCode)
{
bool needBitsFlag = true;
case MachineOperand::MO_PCRelativeDisp:
{
const Value *Val = mop.getVRegValue();
- assert(Val && "\tNULL Value in SparcAsmPrinter");
+ assert(Val && "\tNULL Value in SparcV9AsmPrinter");
if (const BasicBlock *BB = dyn_cast<BasicBlock>(Val))
toAsm << getID(BB);
else if (const Constant *CV = dyn_cast<Constant>(Val))
toAsm << getID(CV);
else
- assert(0 && "Unrecognized value in SparcAsmPrinter");
+ assert(0 && "Unrecognized value in SparcV9AsmPrinter");
break;
}
toAsm << ")";
}
-void SparcAsmPrinter::emitMachineInst(const MachineInstr *MI) {
+void SparcV9AsmPrinter::emitMachineInst(const MachineInstr *MI) {
unsigned Opcode = MI->getOpcode();
if (Target.getInstrInfo().isDummyPhiInstr(Opcode))
++EmittedInsts;
}
-void SparcAsmPrinter::emitBasicBlock(const MachineBasicBlock &MBB) {
+void SparcV9AsmPrinter::emitBasicBlock(const MachineBasicBlock &MBB) {
// Emit a label for the basic block
toAsm << getID(MBB.getBasicBlock()) << ":\n";
toAsm << "\n"; // Separate BB's with newlines
}
-void SparcAsmPrinter::emitFunction(const Function &F) {
+void SparcV9AsmPrinter::emitFunction(const Function &F) {
std::string methName = getID(&F);
toAsm << "!****** Outputing Function: " << methName << " ******\n";
toAsm << "\n\n";
}
-void SparcAsmPrinter::printGlobalVariable(const GlobalVariable* GV) {
+void SparcV9AsmPrinter::printGlobalVariable(const GlobalVariable* GV) {
if (GV->hasExternalLinkage())
toAsm << "\t.global\t" << getID(GV) << "\n";
}
}
-void SparcAsmPrinter::emitGlobals(const Module &M) {
+void SparcV9AsmPrinter::emitGlobals(const Module &M) {
// Output global variables...
for (Module::const_giterator GI = M.gbegin(), GE = M.gend(); GI != GE; ++GI)
if (! GI->isExternal()) {
FunctionPass *llvm::createAsmPrinterPass(std::ostream &Out,
const TargetMachine &TM) {
- return new SparcAsmPrinter(Out, TM);
+ return new SparcV9AsmPrinter(Out, TM);
}
#include "Support/Debug.h"
#include "Support/hash_set"
#include "Support/Statistic.h"
-#include "SparcInternals.h"
-#include "SparcTargetMachine.h"
-#include "SparcRegInfo.h"
+#include "SparcV9Internals.h"
+#include "SparcV9TargetMachine.h"
+#include "SparcV9RegInfo.h"
#include "SparcV9CodeEmitter.h"
#include "Config/alloca.h"
Statistic<> CallbackCalls("callback", "Number CompilationCallback() calls");
}
-bool SparcTargetMachine::addPassesToEmitMachineCode(FunctionPassManager &PM,
+bool SparcV9TargetMachine::addPassesToEmitMachineCode(FunctionPassManager &PM,
MachineCodeEmitter &MCE) {
MachineCodeEmitter *M = &MCE;
DEBUG(M = MachineCodeEmitter::createFilePrinterEmitter(MCE));
PM.add(new SparcV9CodeEmitter(*this, *M));
- PM.add(createSparcMachineCodeDestructionPass()); //Free stuff no longer needed
+ PM.add(createSparcV9MachineCodeDestructionPass()); //Free stuff no longer needed
return false;
}
void JITResolver::insertFarJumpAtAddr(int64_t Target, uint64_t Addr) {
static const unsigned
- o6 = SparcIntRegClass::o6, g0 = SparcIntRegClass::g0,
- g1 = SparcIntRegClass::g1, g5 = SparcIntRegClass::g5;
+ o6 = SparcV9IntRegClass::o6, g0 = SparcV9IntRegClass::g0,
+ g1 = SparcV9IntRegClass::g1, g5 = SparcV9IntRegClass::g5;
MachineInstr* BinaryCode[] = {
//
// Rewrite the call target so that we don't fault every time we execute it.
//
- static const unsigned o6 = SparcIntRegClass::o6;
+ static const unsigned o6 = SparcV9IntRegClass::o6;
// Subtract enough to overwrite up to the 'save' instruction
// This depends on whether we made a short call (1 instruction) or the
DEBUG(std::cerr << "Emitting stub at addr: 0x"
<< std::hex << MCE.getCurrentPCValue() << "\n");
- unsigned o6 = SparcIntRegClass::o6, g0 = SparcIntRegClass::g0;
+ unsigned o6 = SparcV9IntRegClass::o6, g0 = SparcV9IntRegClass::g0;
// restore %g0, 0, %g0
MachineInstr *R = BuildMI(V9::RESTOREi, 3).addMReg(g0).addSImm(0)
fakeReg = RI.getClassRegNum(fakeReg, regClass);
switch (regClass) {
- case SparcRegInfo::IntRegClassID: {
- // Sparc manual, p31
+ case SparcV9RegInfo::IntRegClassID: {
+ // SparcV9 manual, p31
static const unsigned IntRegMap[] = {
// "o0", "o1", "o2", "o3", "o4", "o5", "o7",
8, 9, 10, 11, 12, 13, 15,
return IntRegMap[fakeReg];
break;
}
- case SparcRegInfo::FloatRegClassID: {
+ case SparcV9RegInfo::FloatRegClassID: {
DEBUG(std::cerr << "FP reg: " << fakeReg << "\n");
- if (regType == SparcRegInfo::FPSingleRegType) {
+ if (regType == SparcV9RegInfo::FPSingleRegType) {
// only numbered 0-31, hence can already fit into 5 bits (and 6)
DEBUG(std::cerr << "FP single reg, returning: " << fakeReg << "\n");
- } else if (regType == SparcRegInfo::FPDoubleRegType) {
+ } else if (regType == SparcV9RegInfo::FPDoubleRegType) {
// FIXME: This assumes that we only have 5-bit register fields!
- // From Sparc Manual, page 40.
+ // From SparcV9 Manual, page 40.
// The bit layout becomes: b[4], b[3], b[2], b[1], b[5]
fakeReg |= (fakeReg >> 5) & 1;
fakeReg &= 0x1f;
}
return fakeReg;
}
- case SparcRegInfo::IntCCRegClassID: {
+ case SparcV9RegInfo::IntCCRegClassID: {
/* xcc, icc, ccr */
static const unsigned IntCCReg[] = { 6, 4, 2 };
DEBUG(std::cerr << "IntCC reg: " << IntCCReg[fakeReg] << "\n");
return IntCCReg[fakeReg];
}
- case SparcRegInfo::FloatCCRegClassID: {
+ case SparcV9RegInfo::FloatCCRegClassID: {
/* These are laid out %fcc0 - %fcc3 => 0 - 3, so are correct */
DEBUG(std::cerr << "FP CC reg: " << fakeReg << "\n");
return fakeReg;
// WARNING: if the call used the delay slot to do meaningful work, that's not
// being accounted for, and the behavior will be incorrect!!
inline void SparcV9CodeEmitter::emitFarCall(uint64_t Target, Function *F) {
- static const unsigned o6 = SparcIntRegClass::o6,
- o7 = SparcIntRegClass::o7, g0 = SparcIntRegClass::g0,
- g1 = SparcIntRegClass::g1, g5 = SparcIntRegClass::g5;
+ static const unsigned o6 = SparcV9IntRegClass::o6,
+ o7 = SparcV9IntRegClass::o7, g0 = SparcV9IntRegClass::g0,
+ g1 = SparcV9IntRegClass::g1, g5 = SparcV9IntRegClass::g5;
MachineInstr* BinaryCode[] = {
//
}
}
-void SparcJITInfo::replaceMachineCodeForFunction (void *Old, void *New) {
+void SparcV9JITInfo::replaceMachineCodeForFunction (void *Old, void *New) {
assert (TheJITResolver &&
"Can only call replaceMachineCodeForFunction from within JIT");
uint64_t Target = (uint64_t)(intptr_t)New;
}
} else if (MO.isRegister() || MO.getType() == MachineOperand::MO_CCRegister)
{
- // This is necessary because the Sparc backend doesn't actually lay out
+ // This is necessary because the SparcV9 backend doesn't actually lay out
// registers in the real fashion -- it skips those that it chooses not to
// allocate, i.e. those that are the FP, SP, etc.
unsigned fakeReg = MO.getReg();
MI, MO.isPCRelative());
} else if (MO.isMachineBasicBlock()) {
// Duplicate code of the above case for VirtualRegister, BasicBlock...
- // It should really hit this case, but Sparc backend uses VRegs instead
+ // It should really hit this case, but SparcV9 backend uses VRegs instead
DEBUG(std::cerr << "Saving reference to MBB\n");
const BasicBlock *BB = MO.getMachineBasicBlock()->getBasicBlock();
unsigned* CurrPC = (unsigned*)(intptr_t)MCE.getCurrentPCValue();
BBRefs.push_back(std::make_pair(BB, std::make_pair(CurrPC, &MI)));
} else if (MO.isExternalSymbol()) {
- // Sparc backend doesn't generate this (yet...)
+ // SparcV9 backend doesn't generate this (yet...)
std::cerr << "ERROR: External symbol unhandled: " << MO << "\n";
abort();
} else if (MO.isFrameIndex()) {
- // Sparc backend doesn't generate this (yet...)
+ // SparcV9 backend doesn't generate this (yet...)
int FrameIndex = MO.getFrameIndex();
std::cerr << "ERROR: Frame index unhandled.\n";
abort();
// are used in SPARC assembly. (Some of these make no sense in combination
// with some of the above; we'll trust that the instruction selector
// will not produce nonsense, and not check for valid combinations here.)
- if (MO.isLoBits32()) { // %lo(val) == %lo() in Sparc ABI doc
+ if (MO.isLoBits32()) { // %lo(val) == %lo() in SparcV9 ABI doc
return rv & 0x03ff;
- } else if (MO.isHiBits32()) { // %lm(val) == %hi() in Sparc ABI doc
+ } else if (MO.isHiBits32()) { // %lm(val) == %hi() in SparcV9 ABI doc
return (rv >> 10) & 0x03fffff;
- } else if (MO.isLoBits64()) { // %hm(val) == %ulo() in Sparc ABI doc
+ } else if (MO.isLoBits64()) { // %hm(val) == %ulo() in SparcV9 ABI doc
return (rv >> 32) & 0x03ff;
- } else if (MO.isHiBits64()) { // %hh(val) == %uhi() in Sparc ABI doc
+ } else if (MO.isHiBits64()) { // %hh(val) == %uhi() in SparcV9 ABI doc
return rv >> 42;
} else { // (unadorned) val
return rv;
-//===-- Sparc.cpp - General implementation file for the Sparc Target ------===//
+//===-- SparcV9.cpp - General implementation file for the SparcV9 Target ------===//
//
// The LLVM Compiler Infrastructure
//
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineFunctionInfo.h"
#include "llvm/Target/TargetFrameInfo.h"
-#include "SparcFrameInfo.h"
+#include "SparcV9FrameInfo.h"
using namespace llvm;
int
-SparcFrameInfo::getFirstAutomaticVarOffset(MachineFunction&, bool& pos) const {
+SparcV9FrameInfo::getFirstAutomaticVarOffset(MachineFunction&, bool& pos) const {
pos = false; // static stack area grows downwards
return StaticAreaOffsetFromFP;
}
int
-SparcFrameInfo::getRegSpillAreaOffset(MachineFunction& mcInfo, bool& pos) const
+SparcV9FrameInfo::getRegSpillAreaOffset(MachineFunction& mcInfo, bool& pos) const
{
// ensure no more auto vars are added
mcInfo.getInfo()->freezeAutomaticVarsArea();
return StaticAreaOffsetFromFP - autoVarsSize;
}
-int SparcFrameInfo::getTmpAreaOffset(MachineFunction& mcInfo, bool& pos) const {
+int SparcV9FrameInfo::getTmpAreaOffset(MachineFunction& mcInfo, bool& pos) const {
MachineFunctionInfo *MFI = mcInfo.getInfo();
MFI->freezeAutomaticVarsArea(); // ensure no more auto vars are added
MFI->freezeSpillsArea(); // ensure no more spill slots are added
}
int
-SparcFrameInfo::getDynamicAreaOffset(MachineFunction& mcInfo, bool& pos) const {
+SparcV9FrameInfo::getDynamicAreaOffset(MachineFunction& mcInfo, bool& pos) const {
// Dynamic stack area grows downwards starting at top of opt-args area.
// The opt-args, required-args, and register-save areas are empty except
// during calls and traps, so they are shifted downwards on each
-//===-- SparcFrameInfo.h - Define TargetFrameInfo for Sparc -----*- C++ -*-===//
+//===-- SparcV9FrameInfo.h - Define TargetFrameInfo for SparcV9 -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
namespace llvm {
-class SparcFrameInfo: public TargetFrameInfo {
+class SparcV9FrameInfo: public TargetFrameInfo {
const TargetMachine ⌖
public:
- SparcFrameInfo(const TargetMachine &TM)
+ SparcV9FrameInfo(const TargetMachine &TM)
: TargetFrameInfo(StackGrowsDown, StackFrameSizeAlignment, 0), target(TM) {}
public:
private:
/*----------------------------------------------------------------------
- This diagram shows the stack frame layout used by llc on Sparc V9.
+ This diagram shows the stack frame layout used by llc on SparcV9 V9.
Note that only the location of automatic variables, spill area,
temporary storage, and dynamically allocated stack area are chosen
- by us. The rest conform to the Sparc V9 ABI.
+ by us. The rest conform to the SparcV9 V9 ABI.
All stack addresses are offset by OFFSET = 0x7ff (2047).
Alignment assumptions and other invariants:
*----------------------------------------------------------------------*/
- // All stack addresses must be offset by 0x7ff (2047) on Sparc V9.
+ // All stack addresses must be offset by 0x7ff (2047) on SparcV9 V9.
static const int OFFSET = (int) 0x7ff;
static const int StackFrameSizeAlignment = 16;
static const int MinStackFrameSize = 176;
-//===-- SparcInstrInfo.cpp ------------------------------------------------===//
+//===-- SparcV9InstrInfo.cpp ------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
#include "llvm/CodeGen/MachineFunctionInfo.h"
#include "llvm/CodeGen/MachineCodeForInstruction.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
-#include "SparcInternals.h"
-#include "SparcInstrSelectionSupport.h"
-#include "SparcInstrInfo.h"
+#include "SparcV9Internals.h"
+#include "SparcV9InstrSelectionSupport.h"
+#include "SparcV9InstrInfo.h"
namespace llvm {
//---------------------------------------------------------------------------
uint64_t
-SparcInstrInfo::ConvertConstantToIntType(const TargetMachine &target,
+SparcV9InstrInfo::ConvertConstantToIntType(const TargetMachine &target,
const Value *V,
const Type *destType,
bool &isValidConstant) const
default: break;
};
- return (modelOpCode < 0)? 0: SparcMachineInstrDesc[modelOpCode].maxImmedConst;
+ return (modelOpCode < 0)? 0: SparcV9MachineInstrDesc[modelOpCode].maxImmedConst;
}
static void
//---------------------------------------------------------------------------
-// class SparcInstrInfo
+// class SparcV9InstrInfo
//
// Purpose:
// Information about individual instructions.
-// Most information is stored in the SparcMachineInstrDesc array above.
+// Most information is stored in the SparcV9MachineInstrDesc array above.
// Other information is computed on demand, and most such functions
// default to member functions in base class TargetInstrInfo.
//---------------------------------------------------------------------------
/*ctor*/
-SparcInstrInfo::SparcInstrInfo()
- : TargetInstrInfo(SparcMachineInstrDesc,
+SparcV9InstrInfo::SparcV9InstrInfo()
+ : TargetInstrInfo(SparcV9MachineInstrDesc,
/*descSize = */ V9::NUM_TOTAL_OPCODES,
/*numRealOpCodes = */ V9::NUM_REAL_OPCODES)
{
}
bool
-SparcInstrInfo::ConstantMayNotFitInImmedField(const Constant* CV,
+SparcV9InstrInfo::ConstantMayNotFitInImmedField(const Constant* CV,
const Instruction* I) const
{
if (I->getOpcode() >= MaxConstantsTable.size()) // user-defined op (or bug!)
// Any stack space required is allocated via MachineFunction.
//
void
-SparcInstrInfo::CreateCodeToLoadConst(const TargetMachine& target,
+SparcV9InstrInfo::CreateCodeToLoadConst(const TargetMachine& target,
Function* F,
Value* val,
Instruction* dest,
// Any stack space required is allocated via MachineFunction.
//
void
-SparcInstrInfo::CreateCodeToCopyIntToFloat(const TargetMachine& target,
+SparcV9InstrInfo::CreateCodeToCopyIntToFloat(const TargetMachine& target,
Function* F,
Value* val,
Instruction* dest,
// Temporary stack space required is allocated via MachineFunction.
//
void
-SparcInstrInfo::CreateCodeToCopyFloatToInt(const TargetMachine& target,
+SparcV9InstrInfo::CreateCodeToCopyFloatToInt(const TargetMachine& target,
Function* F,
Value* val,
Instruction* dest,
// Any stack space required is allocated via MachineFunction.
//
void
-SparcInstrInfo::CreateCopyInstructionsByType(const TargetMachine& target,
+SparcV9InstrInfo::CreateCopyInstructionsByType(const TargetMachine& target,
Function *F,
Value* src,
Instruction* dest,
// Any stack space required is allocated via MachineFunction.
//
void
-SparcInstrInfo::CreateSignExtensionInstructions(
+SparcV9InstrInfo::CreateSignExtensionInstructions(
const TargetMachine& target,
Function* F,
Value* srcVal,
// Any stack space required is allocated via MachineFunction.
//
void
-SparcInstrInfo::CreateZeroExtensionInstructions(
+SparcV9InstrInfo::CreateZeroExtensionInstructions(
const TargetMachine& target,
Function* F,
Value* srcVal,
-//===-- SparcInstrInfo.h - Define TargetInstrInfo for Sparc -----*- C++ -*-===//
+//===-- SparcV9InstrInfo.h - Define TargetInstrInfo for SparcV9 -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
//
// This class contains information about individual instructions.
-// Most information is stored in the SparcMachineInstrDesc array above.
+// Most information is stored in the SparcV9MachineInstrDesc array above.
// Other information is computed on demand, and most such functions
// default to member functions in base class TargetInstrInfo.
//
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/CodeGen/MachineInstr.h"
-#include "SparcInternals.h"
+#include "SparcV9Internals.h"
namespace llvm {
-struct SparcInstrInfo : public TargetInstrInfo {
- SparcInstrInfo();
+struct SparcV9InstrInfo : public TargetInstrInfo {
+ SparcV9InstrInfo();
// All immediate constants are in position 1 except the
// store instructions and SETxx.
/// another instruction, e.g. X86: xchg ax, ax; SparcV9: sethi 0, g0
///
MachineInstr* createNOPinstr() const {
- return BuildMI(V9::SETHI, 2).addZImm(0).addReg(SparcIntRegClass::g0);
+ return BuildMI(V9::SETHI, 2).addZImm(0).addReg(SparcV9IntRegClass::g0);
}
/// isNOPinstr - not having a special NOP opcode, we need to know if a given
const MachineOperand &op0 = MI.getOperand(0), &op1 = MI.getOperand(1);
if (op0.isImmediate() && op0.getImmedValue() == 0 &&
op1.getType() == MachineOperand::MO_MachineRegister &&
- op1.getMachineRegNum() == SparcIntRegClass::g0)
+ op1.getMachineRegNum() == SparcV9IntRegClass::g0)
{
return true;
}
-//===-- SparcInstrSelection.cpp -------------------------------------------===//
+//===-- SparcV9InstrSelection.cpp -------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
#include "llvm/CodeGen/MachineFunctionInfo.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineInstrAnnot.h"
-#include "SparcInstrSelectionSupport.h"
-#include "SparcInternals.h"
-#include "SparcRegClassInfo.h"
-#include "SparcRegInfo.h"
+#include "SparcV9InstrSelectionSupport.h"
+#include "SparcV9Internals.h"
+#include "SparcV9RegClassInfo.h"
+#include "SparcV9RegInfo.h"
#include "Support/MathExtras.h"
#include <algorithm>
#include <cmath>
}
case Intrinsic::va_end:
- return true; // no-op on Sparc
+ return true; // no-op on SparcV9
case Intrinsic::va_copy:
// Simple copy of current va_list (arg1) to new va_list (result)
// -- For non-FP values, create an add-with-0 instruction
//
if (retVal != NULL) {
- const SparcRegInfo& regInfo =
- (SparcRegInfo&) target.getRegInfo();
+ const SparcV9RegInfo& regInfo =
+ (SparcV9RegInfo&) target.getRegInfo();
const Type* retType = retVal->getType();
unsigned regClassID = regInfo.getRegClassIDOfType(retType);
unsigned retRegNum = (retType->isFloatingPoint()
- ? (unsigned) SparcFloatRegClass::f0
- : (unsigned) SparcIntRegClass::i0);
+ ? (unsigned) SparcV9FloatRegClass::f0
+ : (unsigned) SparcV9IntRegClass::i0);
retRegNum = regInfo.getUnifiedRegNum(regClassID, retRegNum);
// () Insert sign-extension instructions for small signed values.
MachineFunction& MF = MachineFunction::get(currentFunc);
MachineCodeForInstruction& mcfi =
MachineCodeForInstruction::get(callInstr);
- const SparcRegInfo& regInfo =
- (SparcRegInfo&) target.getRegInfo();
+ const SparcV9RegInfo& regInfo =
+ (SparcV9RegInfo&) target.getRegInfo();
const TargetFrameInfo& frameInfo = target.getFrameInfo();
// Create hidden virtual register for return address with type void*
const Type* retType = callInstr->getType();
int regNum = (retType->isFloatingPoint()
- ? (unsigned) SparcFloatRegClass::f0
- : (unsigned) SparcIntRegClass::o0);
+ ? (unsigned) SparcV9FloatRegClass::f0
+ : (unsigned) SparcV9IntRegClass::o0);
unsigned regClassID = regInfo.getRegClassIDOfType(retType);
regNum = regInfo.getUnifiedRegNum(regClassID, regNum);
-//===-- llvm/CodeGen/SparcInstrSelectionSupport.h ---------------*- C++ -*-===//
+//===-- llvm/CodeGen/SparcV9InstrSelectionSupport.h ---------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
#define SPARC_INSTR_SELECTION_SUPPORT_h
#include "llvm/DerivedTypes.h"
-#include "SparcInternals.h"
+#include "SparcV9Internals.h"
namespace llvm {
}
-// Because the Sparc instruction selector likes to re-write operands to
+// Because the SparcV9 instruction selector likes to re-write operands to
// instructions, making them change from a Value* (virtual register) to a
// Constant* (making an immediate field), we need to change the opcode from a
// register-based instruction to an immediate-based instruction, hence this
-//===-- SparcInternals.h ----------------------------------------*- C++ -*-===//
+//===-- SparcV9Internals.h ----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file defines stuff that is to be private to the Sparc backend, but is
+// This file defines stuff that is to be private to the SparcV9 backend, but is
// shared among different portions of the backend.
//
//===----------------------------------------------------------------------===//
#include "llvm/Target/TargetCacheInfo.h"
#include "llvm/Target/TargetRegInfo.h"
#include "llvm/Type.h"
-#include "SparcRegClassInfo.h"
+#include "SparcV9RegClassInfo.h"
#include "Config/sys/types.h"
namespace llvm {
class LiveRange;
-class SparcTargetMachine;
+class SparcV9TargetMachine;
class Pass;
-enum SparcInstrSchedClass {
+enum SparcV9InstrSchedClass {
SPARC_NONE, /* Instructions with no scheduling restrictions */
SPARC_IEUN, /* Integer class that can use IEU0 or IEU1 */
SPARC_IEU0, /* Integer class IEU0 */
//---------------------------------------------------------------------------
-// enum SparcMachineOpCode.
-// const TargetInstrDescriptor SparcMachineInstrDesc[]
+// enum SparcV9MachineOpCode.
+// const TargetInstrDescriptor SparcV9MachineInstrDesc[]
//
// Purpose:
-// Description of UltraSparc machine instructions.
+// Description of UltraSparcV9 machine instructions.
//
//---------------------------------------------------------------------------
namespace V9 {
- enum SparcMachineOpCode {
+ enum SparcV9MachineOpCode {
#define I(ENUM, OPCODESTRING, NUMOPERANDS, RESULTPOS, MAXIMM, IMMSE, \
NUMDELAYSLOTS, LATENCY, SCHEDCLASS, INSTFLAGS) \
ENUM,
-#include "SparcInstr.def"
+#include "SparcV9Instr.def"
// End-of-array marker
INVALID_OPCODE,
}
// Array of machine instruction descriptions...
-extern const TargetInstrDescriptor SparcMachineInstrDesc[];
+extern const TargetInstrDescriptor SparcV9MachineInstrDesc[];
//---------------------------------------------------------------------------
-// class SparcSchedInfo
+// class SparcV9SchedInfo
//
// Purpose:
// Interface to instruction scheduling information for UltraSPARC.
// The parameter values above are based on UltraSPARC IIi.
//---------------------------------------------------------------------------
-class SparcSchedInfo: public TargetSchedInfo {
+class SparcV9SchedInfo: public TargetSchedInfo {
public:
- SparcSchedInfo(const TargetMachine &tgt);
+ SparcV9SchedInfo(const TargetMachine &tgt);
protected:
virtual void initializeResources();
};
//---------------------------------------------------------------------------
-// class SparcCacheInfo
+// class SparcV9CacheInfo
//
// Purpose:
// Interface to cache parameters for the UltraSPARC.
// Just use defaults for now.
//---------------------------------------------------------------------------
-struct SparcCacheInfo: public TargetCacheInfo {
- SparcCacheInfo(const TargetMachine &T) : TargetCacheInfo(T) {}
+struct SparcV9CacheInfo: public TargetCacheInfo {
+ SparcV9CacheInfo(const TargetMachine &T) : TargetCacheInfo(T) {}
};
///
Pass* createBytecodeAsmPrinterPass(std::ostream &Out);
-FunctionPass *createSparcMachineCodeDestructionPass();
+FunctionPass *createSparcV9MachineCodeDestructionPass();
} // End llvm namespace
-//===- SparcJITInfo.h - Sparc implementation of the JIT interface -*-C++-*-===//
+//===- SparcV9JITInfo.h - SparcV9 implementation of the JIT interface -*-C++-*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains the Sparc implementation of the TargetJITInfo class.
+// This file contains the SparcV9 implementation of the TargetJITInfo class.
//
//===----------------------------------------------------------------------===//
namespace llvm {
class TargetMachine;
- class SparcJITInfo : public TargetJITInfo {
+ class SparcV9JITInfo : public TargetJITInfo {
TargetMachine &TM;
public:
- SparcJITInfo(TargetMachine &tm) : TM(tm) {}
+ SparcV9JITInfo(TargetMachine &tm) : TM(tm) {}
/// addPassesToJITCompile - Add passes to the specified pass manager to
/// implement a fast dynamic compiler for this target. Return true if this
//
//===----------------------------------------------------------------------===//
-#include "SparcInternals.h"
+#include "SparcV9Internals.h"
#include "llvm/BasicBlock.h"
#include "llvm/Pass.h"
#include "llvm/CodeGen/MachineFunction.h"
//
//===----------------------------------------------------------------------===//
-#include "SparcInternals.h"
+#include "SparcV9Internals.h"
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/iMemory.h"
//
//===----------------------------------------------------------------------===//
-#include "SparcInternals.h"
-#include "SparcRegClassInfo.h"
+#include "SparcV9Internals.h"
+#include "SparcV9RegClassInfo.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineFunctionInfo.h"
#include "llvm/CodeGen/MachineCodeForInstruction.h"
namespace {
struct InsertPrologEpilogCode : public MachineFunctionPass {
- const char *getPassName() const { return "Sparc Prolog/Epilog Inserter"; }
+ const char *getPassName() const { return "SparcV9 Prolog/Epilog Inserter"; }
bool runOnMachineFunction(MachineFunction &F) {
if (!F.getInfo()->isCompiledAsLeafMethod()) {
// SETSW -(stackSize), %g1
int uregNum = TM.getRegInfo().getUnifiedRegNum(
TM.getRegInfo().getRegClassIDOfType(Type::IntTy),
- SparcIntRegClass::g1);
+ SparcV9IntRegClass::g1);
MachineInstr* M = BuildMI(V9::SETHI, 2).addSImm(C)
.addMReg(uregNum, MachineOperand::Def);
bool ignore;
int firstArgReg = TM.getRegInfo().getUnifiedRegNum(
TM.getRegInfo().getRegClassIDOfType(Type::IntTy),
- SparcIntRegClass::i0);
+ SparcV9IntRegClass::i0);
int fpReg = TM.getFrameInfo().getIncomingArgBaseRegNum();
int argSize = TM.getFrameInfo().getSizeOfEachArgOnStack();
int firstArgOffset=TM.getFrameInfo().getFirstIncomingArgOffset(MF,ignore);
-//===-- SparcRegClassInfo.cpp - Register class def'ns for Sparc -----------===//
+//===-- SparcV9RegClassInfo.cpp - Register class def'ns for SparcV9 -----------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file defines the register classes used by the Sparc target description.
+// This file defines the register classes used by the SparcV9 target description.
//
//===----------------------------------------------------------------------===//
#include "llvm/Type.h"
-#include "SparcRegClassInfo.h"
-#include "SparcInternals.h"
-#include "SparcRegInfo.h"
+#include "SparcV9RegClassInfo.h"
+#include "SparcV9Internals.h"
+#include "SparcV9RegInfo.h"
#include "RegAlloc/RegAllocCommon.h"
#include "RegAlloc/IGNode.h"
// If both above fail, spill.
//
//-----------------------------------------------------------------------------
-void SparcIntRegClass::colorIGNode(IGNode * Node,
+void SparcV9IntRegClass::colorIGNode(IGNode * Node,
const std::vector<bool> &IsColorUsedArr) const
{
LiveRange *LR = Node->getParentLR();
//if this Node is between calls
if (! LR->isCallInterference()) {
// start with volatiles (we can allocate volatiles safely)
- SearchStart = SparcIntRegClass::StartOfAllRegs;
+ SearchStart = SparcV9IntRegClass::StartOfAllRegs;
} else {
// start with non volatiles (no non-volatiles)
- SearchStart = SparcIntRegClass::StartOfNonVolatileRegs;
+ SearchStart = SparcV9IntRegClass::StartOfNonVolatileRegs;
}
unsigned c=0; // color
// find first unused color
- for (c=SearchStart; c < SparcIntRegClass::NumOfAvailRegs; c++) {
+ for (c=SearchStart; c < SparcV9IntRegClass::NumOfAvailRegs; c++) {
if (!IsColorUsedArr[c]) {
ColorFound = true;
break;
//
else if (LR->isCallInterference()) {
// start from 0 - try to find even a volatile this time
- SearchStart = SparcIntRegClass::StartOfAllRegs;
+ SearchStart = SparcV9IntRegClass::StartOfAllRegs;
// find first unused volatile color
- for(c=SearchStart; c < SparcIntRegClass::StartOfNonVolatileRegs; c++) {
+ for(c=SearchStart; c < SparcV9IntRegClass::StartOfNonVolatileRegs; c++) {
if (! IsColorUsedArr[c]) {
ColorFound = true;
break;
// Note: The third name (%ccr) is essentially an assembly mnemonic and
// depends solely on the opcode, so the name can be chosen in EmitAssembly.
//-----------------------------------------------------------------------------
-void SparcIntCCRegClass::colorIGNode(IGNode *Node,
+void SparcV9IntCCRegClass::colorIGNode(IGNode *Node,
const std::vector<bool> &IsColorUsedArr) const
{
if (Node->getNumOfNeighbors() > 0)
}
-void SparcFloatCCRegClass::colorIGNode(IGNode *Node,
+void SparcV9FloatCCRegClass::colorIGNode(IGNode *Node,
const std::vector<bool> &IsColorUsedArr) const {
for(unsigned c = 0; c != 4; ++c)
if (!IsColorUsedArr[c]) { // find unused color
// If a color is still not fond, mark for spilling
//
//----------------------------------------------------------------------------
-void SparcFloatRegClass::colorIGNode(IGNode * Node,
+void SparcV9FloatRegClass::colorIGNode(IGNode * Node,
const std::vector<bool> &IsColorUsedArr) const
{
LiveRange *LR = Node->getParentLR();
//
// FIXME: This is old code that is no longer needed. Temporarily converting
// it into a big assertion just to check that the replacement logic
- // (invoking SparcFloatRegClass::markColorsUsed() directly from
+ // (invoking SparcV9FloatRegClass::markColorsUsed() directly from
// RegClass::colorIGNode) works correctly.
//
// In fact, this entire function should be identical to
- // SparcIntRegClass::colorIGNode(), and perhaps can be
+ // SparcV9IntRegClass::colorIGNode(), and perhaps can be
// made into a general case in CodeGen/RegAlloc/RegClass.cpp.
//
unsigned NumNeighbors = Node->getNumOfNeighbors(); // total # of neighbors
// **NOTE: We don't check for call interferences in allocating suggested
// color in this class since ALL registers are volatile. If this fact
// changes, we should change the following part
- //- see SparcIntRegClass::colorIGNode()
+ //- see SparcV9IntRegClass::colorIGNode()
//
if( LR->hasSuggestedColor() ) {
if( ! IsColorUsedArr[ LR->getSuggestedColor() ] ) {
//if this Node is between calls (i.e., no call interferences )
if (! isCallInterf) {
// start with volatiles (we can allocate volatiles safely)
- SearchStart = SparcFloatRegClass::StartOfAllRegs;
+ SearchStart = SparcV9FloatRegClass::StartOfAllRegs;
} else {
// start with non volatiles (no non-volatiles)
- SearchStart = SparcFloatRegClass::StartOfNonVolatileRegs;
+ SearchStart = SparcV9FloatRegClass::StartOfNonVolatileRegs;
}
ColorFound = findFloatColor(LR, SearchStart, 32, IsColorUsedArr);
// We are here because there is a call interference and no non-volatile
// color could be found.
// Now try to allocate even a volatile color
- ColorFound = findFloatColor(LR, SparcFloatRegClass::StartOfAllRegs,
- SparcFloatRegClass::StartOfNonVolatileRegs,
+ ColorFound = findFloatColor(LR, SparcV9FloatRegClass::StartOfAllRegs,
+ SparcV9FloatRegClass::StartOfNonVolatileRegs,
IsColorUsedArr);
}
// for double-precision registers.
//-----------------------------------------------------------------------------
-void SparcFloatRegClass::markColorsUsed(unsigned RegInClass,
+void SparcV9FloatRegClass::markColorsUsed(unsigned RegInClass,
int UserRegType,
int RegTypeWanted,
std::vector<bool> &IsColorUsedArr) const
{
- if (UserRegType == SparcRegInfo::FPDoubleRegType ||
- RegTypeWanted == SparcRegInfo::FPDoubleRegType) {
+ if (UserRegType == SparcV9RegInfo::FPDoubleRegType ||
+ RegTypeWanted == SparcV9RegInfo::FPDoubleRegType) {
// This register is used as or is needed as a double-precision reg.
// We need to mark the [even,odd] pair corresponding to this reg.
// Get the even numbered register corresponding to this reg.
// for double-precision registers
// It returns -1 if no unused color is found.
//
-int SparcFloatRegClass::findUnusedColor(int RegTypeWanted,
+int SparcV9FloatRegClass::findUnusedColor(int RegTypeWanted,
const std::vector<bool> &IsColorUsedArr) const
{
- if (RegTypeWanted == SparcRegInfo::FPDoubleRegType) {
+ if (RegTypeWanted == SparcV9RegInfo::FPDoubleRegType) {
unsigned NC = 2 * this->getNumOfAvailRegs();
assert(IsColorUsedArr.size() == NC && "Invalid colors-used array");
for (unsigned c = 0; c < NC; c+=2)
// type of the Node (i.e., float/double)
//-----------------------------------------------------------------------------
-int SparcFloatRegClass::findFloatColor(const LiveRange *LR,
+int SparcV9FloatRegClass::findFloatColor(const LiveRange *LR,
unsigned Start,
unsigned End,
const std::vector<bool> &IsColorUsedArr) const
for (unsigned c=Start; c < End ; c+= 2)
if (!IsColorUsedArr[c]) {
assert(!IsColorUsedArr[c+1] &&
- "Incorrect marking of used regs for Sparc FP double!");
+ "Incorrect marking of used regs for SparcV9 FP double!");
return c;
}
} else {
-//===-- SparcRegClassInfo.h - Register class def'ns for Sparc ---*- C++ -*-===//
+//===-- SparcV9RegClassInfo.h - Register class def'ns for SparcV9 ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file defines the register classes used by the Sparc target description.
+// This file defines the register classes used by the SparcV9 target description.
//
//===----------------------------------------------------------------------===//
// Integer Register Class
//-----------------------------------------------------------------------------
-struct SparcIntRegClass : public TargetRegClassInfo {
- SparcIntRegClass(unsigned ID)
+struct SparcV9IntRegClass : public TargetRegClassInfo {
+ SparcV9IntRegClass(unsigned ID)
: TargetRegClassInfo(ID, NumOfAvailRegs, NumOfAllRegs) { }
void colorIGNode(IGNode *Node,
// Float Register Class
//-----------------------------------------------------------------------------
-class SparcFloatRegClass : public TargetRegClassInfo {
+class SparcV9FloatRegClass : public TargetRegClassInfo {
int findFloatColor(const LiveRange *LR, unsigned Start,
unsigned End,
const std::vector<bool> &IsColorUsedArr) const;
public:
- SparcFloatRegClass(unsigned ID)
+ SparcV9FloatRegClass(unsigned ID)
: TargetRegClassInfo(ID, NumOfAvailRegs, NumOfAllRegs) {}
// This method marks the registers used for a given register number.
void colorIGNode(IGNode *Node,
const std::vector<bool> &IsColorUsedArr) const;
- // according to Sparc 64 ABI, all %fp regs are volatile
+ // according to SparcV9 64 ABI, all %fp regs are volatile
inline bool isRegVolatile(int Reg) const { return true; }
enum {
// allocated for the three names.
//-----------------------------------------------------------------------------
-struct SparcIntCCRegClass : public TargetRegClassInfo {
- SparcIntCCRegClass(unsigned ID)
+struct SparcV9IntCCRegClass : public TargetRegClassInfo {
+ SparcV9IntCCRegClass(unsigned ID)
: TargetRegClassInfo(ID, 1, 3) { }
void colorIGNode(IGNode *Node,
const std::vector<bool> &IsColorUsedArr) const;
- // according to Sparc 64 ABI, %ccr is volatile
+ // according to SparcV9 64 ABI, %ccr is volatile
//
inline bool isRegVolatile(int Reg) const { return true; }
// Only 4 Float CC registers are available for allocation.
//-----------------------------------------------------------------------------
-struct SparcFloatCCRegClass : public TargetRegClassInfo {
- SparcFloatCCRegClass(unsigned ID)
+struct SparcV9FloatCCRegClass : public TargetRegClassInfo {
+ SparcV9FloatCCRegClass(unsigned ID)
: TargetRegClassInfo(ID, 4, 5) { }
void colorIGNode(IGNode *Node,
const std::vector<bool> &IsColorUsedArr) const;
- // according to Sparc 64 ABI, all %fp CC regs are volatile
+ // according to SparcV9 64 ABI, all %fp CC regs are volatile
//
inline bool isRegVolatile(int Reg) const { return true; }
};
//-----------------------------------------------------------------------------
-// Sparc special register class. These registers are not used for allocation
+// SparcV9 special register class. These registers are not used for allocation
// but are used as arguments of some instructions.
//-----------------------------------------------------------------------------
-struct SparcSpecialRegClass : public TargetRegClassInfo {
- SparcSpecialRegClass(unsigned ID)
+struct SparcV9SpecialRegClass : public TargetRegClassInfo {
+ SparcV9SpecialRegClass(unsigned ID)
: TargetRegClassInfo(ID, 0, 1) { }
void colorIGNode(IGNode *Node,
const std::vector<bool> &IsColorUsedArr) const {
- assert(0 && "SparcSpecialRegClass should never be used for allocation");
+ assert(0 && "SparcV9SpecialRegClass should never be used for allocation");
}
// all currently included special regs are volatile
-//===-- SparcRegInfo.cpp - Sparc Target Register Information --------------===//
+//===-- SparcV9RegInfo.cpp - SparcV9 Target Register Information --------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file contains implementation of Sparc specific helper methods
+// This file contains implementation of SparcV9 specific helper methods
// used for register allocation.
//
//===----------------------------------------------------------------------===//
#include "llvm/Function.h"
#include "llvm/iTerminators.h"
#include "llvm/iOther.h"
-#include "SparcInternals.h"
-#include "SparcRegClassInfo.h"
-#include "SparcRegInfo.h"
-#include "SparcTargetMachine.h"
+#include "SparcV9Internals.h"
+#include "SparcV9RegClassInfo.h"
+#include "SparcV9RegInfo.h"
+#include "SparcV9TargetMachine.h"
namespace llvm {
BadRegClass = ~0
};
-SparcRegInfo::SparcRegInfo(const SparcTargetMachine &tgt)
+SparcV9RegInfo::SparcV9RegInfo(const SparcV9TargetMachine &tgt)
: TargetRegInfo(tgt), NumOfIntArgRegs(6), NumOfFloatArgRegs(32)
{
- MachineRegClassArr.push_back(new SparcIntRegClass(IntRegClassID));
- MachineRegClassArr.push_back(new SparcFloatRegClass(FloatRegClassID));
- MachineRegClassArr.push_back(new SparcIntCCRegClass(IntCCRegClassID));
- MachineRegClassArr.push_back(new SparcFloatCCRegClass(FloatCCRegClassID));
- MachineRegClassArr.push_back(new SparcSpecialRegClass(SpecialRegClassID));
+ MachineRegClassArr.push_back(new SparcV9IntRegClass(IntRegClassID));
+ MachineRegClassArr.push_back(new SparcV9FloatRegClass(FloatRegClassID));
+ MachineRegClassArr.push_back(new SparcV9IntCCRegClass(IntCCRegClassID));
+ MachineRegClassArr.push_back(new SparcV9FloatCCRegClass(FloatCCRegClassID));
+ MachineRegClassArr.push_back(new SparcV9SpecialRegClass(SpecialRegClassID));
- assert(SparcFloatRegClass::StartOfNonVolatileRegs == 32 &&
+ assert(SparcV9FloatRegClass::StartOfNonVolatileRegs == 32 &&
"32 Float regs are used for float arg passing");
}
// getZeroRegNum - returns the register that contains always zero.
// this is the unified register number
//
-unsigned SparcRegInfo::getZeroRegNum() const {
- return getUnifiedRegNum(SparcRegInfo::IntRegClassID,
- SparcIntRegClass::g0);
+unsigned SparcV9RegInfo::getZeroRegNum() const {
+ return getUnifiedRegNum(SparcV9RegInfo::IntRegClassID,
+ SparcV9IntRegClass::g0);
}
// getCallAddressReg - returns the reg used for pushing the address when a
// method is called. This can be used for other purposes between calls
//
-unsigned SparcRegInfo::getCallAddressReg() const {
- return getUnifiedRegNum(SparcRegInfo::IntRegClassID,
- SparcIntRegClass::o7);
+unsigned SparcV9RegInfo::getCallAddressReg() const {
+ return getUnifiedRegNum(SparcV9RegInfo::IntRegClassID,
+ SparcV9IntRegClass::o7);
}
// Returns the register containing the return address.
// It should be made sure that this register contains the return
// value when a return instruction is reached.
//
-unsigned SparcRegInfo::getReturnAddressReg() const {
- return getUnifiedRegNum(SparcRegInfo::IntRegClassID,
- SparcIntRegClass::i7);
+unsigned SparcV9RegInfo::getReturnAddressReg() const {
+ return getUnifiedRegNum(SparcV9RegInfo::IntRegClassID,
+ SparcV9IntRegClass::i7);
}
// Register get name implementations...
-// Int register names in same order as enum in class SparcIntRegClass
+// Int register names in same order as enum in class SparcV9IntRegClass
static const char * const IntRegNames[] = {
"o0", "o1", "o2", "o3", "o4", "o5", "o7",
"l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7",
"o6"
};
-const char * const SparcIntRegClass::getRegName(unsigned reg) const {
+const char * const SparcV9IntRegClass::getRegName(unsigned reg) const {
assert(reg < NumOfAllRegs);
return IntRegNames[reg];
}
"f60", "f61", "f62", "f63"
};
-const char * const SparcFloatRegClass::getRegName(unsigned reg) const {
+const char * const SparcV9FloatRegClass::getRegName(unsigned reg) const {
assert (reg < NumOfAllRegs);
return FloatRegNames[reg];
}
"xcc", "icc", "ccr"
};
-const char * const SparcIntCCRegClass::getRegName(unsigned reg) const {
+const char * const SparcV9IntCCRegClass::getRegName(unsigned reg) const {
assert(reg < 3);
return IntCCRegNames[reg];
}
"fcc0", "fcc1", "fcc2", "fcc3"
};
-const char * const SparcFloatCCRegClass::getRegName(unsigned reg) const {
+const char * const SparcV9FloatCCRegClass::getRegName(unsigned reg) const {
assert (reg < 5);
return FloatCCRegNames[reg];
}
"fsr"
};
-const char * const SparcSpecialRegClass::getRegName(unsigned reg) const {
+const char * const SparcV9SpecialRegClass::getRegName(unsigned reg) const {
assert (reg < 1);
return SpecialRegNames[reg];
}
// Get unified reg number for frame pointer
-unsigned SparcRegInfo::getFramePointer() const {
- return getUnifiedRegNum(SparcRegInfo::IntRegClassID,
- SparcIntRegClass::i6);
+unsigned SparcV9RegInfo::getFramePointer() const {
+ return getUnifiedRegNum(SparcV9RegInfo::IntRegClassID,
+ SparcV9IntRegClass::i6);
}
// Get unified reg number for stack pointer
-unsigned SparcRegInfo::getStackPointer() const {
- return getUnifiedRegNum(SparcRegInfo::IntRegClassID,
- SparcIntRegClass::o6);
+unsigned SparcV9RegInfo::getStackPointer() const {
+ return getUnifiedRegNum(SparcV9RegInfo::IntRegClassID,
+ SparcV9IntRegClass::o6);
}
// regClassId is set to the register class ID.
//
int
-SparcRegInfo::regNumForIntArg(bool inCallee, bool isVarArgsCall,
+SparcV9RegInfo::regNumForIntArg(bool inCallee, bool isVarArgsCall,
unsigned argNo, unsigned& regClassId) const
{
regClassId = IntRegClassID;
if (argNo >= NumOfIntArgRegs)
return getInvalidRegNum();
else
- return argNo + (inCallee? SparcIntRegClass::i0 : SparcIntRegClass::o0);
+ return argNo + (inCallee? SparcV9IntRegClass::i0 : SparcV9IntRegClass::o0);
}
// Get the register number for the specified FP argument #argNo,
// regClassId is set to the register class ID.
//
int
-SparcRegInfo::regNumForFPArg(unsigned regType,
+SparcV9RegInfo::regNumForFPArg(unsigned regType,
bool inCallee, bool isVarArgsCall,
unsigned argNo, unsigned& regClassId) const
{
regClassId = FloatRegClassID;
if (regType == FPSingleRegType)
return (argNo*2+1 >= NumOfFloatArgRegs)?
- getInvalidRegNum() : SparcFloatRegClass::f0 + (argNo * 2 + 1);
+ getInvalidRegNum() : SparcV9FloatRegClass::f0 + (argNo * 2 + 1);
else if (regType == FPDoubleRegType)
return (argNo*2 >= NumOfFloatArgRegs)?
- getInvalidRegNum() : SparcFloatRegClass::f0 + (argNo * 2);
+ getInvalidRegNum() : SparcV9FloatRegClass::f0 + (argNo * 2);
else
assert(0 && "Illegal FP register type");
return 0;
// Finds the return address of a call sparc specific call instruction
//---------------------------------------------------------------------------
-// The following 4 methods are used to find the RegType (SparcInternals.h)
+// The following 4 methods are used to find the RegType (SparcV9Internals.h)
// of a LiveRange, a Value, and for a given register unified reg number.
//
-int SparcRegInfo::getRegTypeForClassAndType(unsigned regClassID,
+int SparcV9RegInfo::getRegTypeForClassAndType(unsigned regClassID,
const Type* type) const
{
switch (regClassID) {
}
}
-int SparcRegInfo::getRegTypeForDataType(const Type* type) const
+int SparcV9RegInfo::getRegTypeForDataType(const Type* type) const
{
return getRegTypeForClassAndType(getRegClassIDOfType(type), type);
}
-int SparcRegInfo::getRegTypeForLR(const LiveRange *LR) const
+int SparcV9RegInfo::getRegTypeForLR(const LiveRange *LR) const
{
return getRegTypeForClassAndType(LR->getRegClassID(), LR->getType());
}
-int SparcRegInfo::getRegType(int unifiedRegNum) const
+int SparcV9RegInfo::getRegType(int unifiedRegNum) const
{
if (unifiedRegNum < 32)
return IntRegType;
// To find the register class used for a specified Type
//
-unsigned SparcRegInfo::getRegClassIDOfType(const Type *type,
+unsigned SparcV9RegInfo::getRegClassIDOfType(const Type *type,
bool isCCReg) const {
Type::PrimitiveID ty = type->getPrimitiveID();
unsigned res;
return res;
}
-unsigned SparcRegInfo::getRegClassIDOfRegType(int regType) const {
+unsigned SparcV9RegInfo::getRegClassIDOfRegType(int regType) const {
switch(regType) {
case IntRegType: return IntRegClassID;
case FPSingleRegType:
// Suggests a register for the ret address in the RET machine instruction.
// We always suggest %i7 by convention.
//---------------------------------------------------------------------------
-void SparcRegInfo::suggestReg4RetAddr(MachineInstr *RetMI,
+void SparcV9RegInfo::suggestReg4RetAddr(MachineInstr *RetMI,
LiveRangeInfo& LRI) const {
assert(target.getInstrInfo().isReturn(RetMI->getOpcode()));
// return address is always mapped to i7 so set it immediately
RetMI->SetRegForOperand(0, getUnifiedRegNum(IntRegClassID,
- SparcIntRegClass::i7));
+ SparcV9IntRegClass::i7));
// Possible Optimization:
// Instead of setting the color, we can suggest one. In that case,
// assert( RetAddrVal && "LR for ret address must be created at start");
// LiveRange * RetAddrLR = LRI.getLiveRangeForValue( RetAddrVal);
// RetAddrLR->setSuggestedColor(getUnifiedRegNum( IntRegClassID,
- // SparcIntRegOrdr::i7) );
+ // SparcV9IntRegOrdr::i7) );
}
//---------------------------------------------------------------------------
// Suggests a register for the ret address in the JMPL/CALL machine instr.
-// Sparc ABI dictates that %o7 be used for this purpose.
+// SparcV9 ABI dictates that %o7 be used for this purpose.
//---------------------------------------------------------------------------
void
-SparcRegInfo::suggestReg4CallAddr(MachineInstr * CallMI,
+SparcV9RegInfo::suggestReg4CallAddr(MachineInstr * CallMI,
LiveRangeInfo& LRI) const
{
CallArgsDescriptor* argDesc = CallArgsDescriptor::get(CallMI);
assert(RetAddrLR && "INTERNAL ERROR: No LR for return address of call!");
unsigned RegClassID = RetAddrLR->getRegClassID();
- RetAddrLR->setColor(getUnifiedRegNum(IntRegClassID, SparcIntRegClass::o7));
+ RetAddrLR->setColor(getUnifiedRegNum(IntRegClassID, SparcV9IntRegClass::o7));
}
//---------------------------------------------------------------------------
// This method will suggest colors to incoming args to a method.
-// According to the Sparc ABI, the first 6 incoming args are in
+// According to the SparcV9 ABI, the first 6 incoming args are in
// %i0 - %i5 (if they are integer) OR in %f0 - %f31 (if they are float).
// If the arg is passed on stack due to the lack of regs, NOTHING will be
// done - it will be colored (or spilled) as a normal live range.
//---------------------------------------------------------------------------
-void SparcRegInfo::suggestRegs4MethodArgs(const Function *Meth,
+void SparcV9RegInfo::suggestRegs4MethodArgs(const Function *Meth,
LiveRangeInfo& LRI) const
{
// Check if this is a varArgs function. needed for choosing regs.
// the correct hardware registers if they did not receive the correct
// (suggested) color through graph coloring.
//---------------------------------------------------------------------------
-void SparcRegInfo::colorMethodArgs(const Function *Meth,
+void SparcV9RegInfo::colorMethodArgs(const Function *Meth,
LiveRangeInfo &LRI,
std::vector<MachineInstr*>& InstrnsBefore,
std::vector<MachineInstr*>& InstrnsAfter) const {
// This method is called before graph coloring to suggest colors to the
// outgoing call args and the return value of the call.
//---------------------------------------------------------------------------
-void SparcRegInfo::suggestRegs4CallArgs(MachineInstr *CallMI,
+void SparcV9RegInfo::suggestRegs4CallArgs(MachineInstr *CallMI,
LiveRangeInfo& LRI) const {
assert ( (target.getInstrInfo()).isCall(CallMI->getOpcode()) );
// now suggest a register depending on the register class of ret arg
if( RegClassID == IntRegClassID )
- RetValLR->setSuggestedColor(SparcIntRegClass::o0);
+ RetValLR->setSuggestedColor(SparcV9IntRegClass::o0);
else if (RegClassID == FloatRegClassID )
- RetValLR->setSuggestedColor(SparcFloatRegClass::f0 );
+ RetValLR->setSuggestedColor(SparcV9FloatRegClass::f0 );
else assert( 0 && "Unknown reg class for return value of call\n");
}
// this method is called for an LLVM return instruction to identify which
// values will be returned from this method and to suggest colors.
//---------------------------------------------------------------------------
-void SparcRegInfo::suggestReg4RetValue(MachineInstr *RetMI,
+void SparcV9RegInfo::suggestReg4RetValue(MachineInstr *RetMI,
LiveRangeInfo& LRI) const {
assert( (target.getInstrInfo()).isReturn( RetMI->getOpcode() ) );
if (const Value *RetVal = retI->getReturnValue())
if (LiveRange *const LR = LRI.getLiveRangeForValue(RetVal))
LR->setSuggestedColor(LR->getRegClassID() == IntRegClassID
- ? (unsigned) SparcIntRegClass::i0
- : (unsigned) SparcFloatRegClass::f0);
+ ? (unsigned) SparcV9IntRegClass::i0
+ : (unsigned) SparcV9FloatRegClass::f0);
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
bool
-SparcRegInfo::regTypeNeedsScratchReg(int RegType,
+SparcV9RegInfo::regTypeNeedsScratchReg(int RegType,
int& scratchRegType) const
{
if (RegType == IntCCRegType)
//---------------------------------------------------------------------------
void
-SparcRegInfo::cpReg2RegMI(std::vector<MachineInstr*>& mvec,
+SparcV9RegInfo::cpReg2RegMI(std::vector<MachineInstr*>& mvec,
unsigned SrcReg,
unsigned DestReg,
int RegType) const {
if (getRegType(DestReg) == IntRegType) {
// copy intCC reg to int reg
MI = (BuildMI(V9::RDCCR, 2)
- .addMReg(getUnifiedRegNum(SparcRegInfo::IntCCRegClassID,
- SparcIntCCRegClass::ccr))
+ .addMReg(getUnifiedRegNum(SparcV9RegInfo::IntCCRegClassID,
+ SparcV9IntCCRegClass::ccr))
.addMReg(DestReg,MachineOperand::Def));
} else {
// copy int reg to intCC reg
&& "Can only copy CC reg to/from integer reg");
MI = (BuildMI(V9::WRCCRr, 3)
.addMReg(SrcReg)
- .addMReg(SparcIntRegClass::g0)
- .addMReg(getUnifiedRegNum(SparcRegInfo::IntCCRegClassID,
- SparcIntCCRegClass::ccr),
+ .addMReg(SparcV9IntRegClass::g0)
+ .addMReg(getUnifiedRegNum(SparcV9RegInfo::IntCCRegClassID,
+ SparcV9IntCCRegClass::ccr),
MachineOperand::Def));
}
break;
void
-SparcRegInfo::cpReg2MemMI(std::vector<MachineInstr*>& mvec,
+SparcV9RegInfo::cpReg2MemMI(std::vector<MachineInstr*>& mvec,
unsigned SrcReg,
unsigned PtrReg,
int Offset, int RegType,
OffReg = PRA.getUnusedUniRegAtMI(RC, RegType, MInst, LVSetBef);
#else
// Default to using register g4 for holding large offsets
- OffReg = getUnifiedRegNum(SparcRegInfo::IntRegClassID,
- SparcIntRegClass::g4);
+ OffReg = getUnifiedRegNum(SparcV9RegInfo::IntRegClassID,
+ SparcV9IntRegClass::g4);
#endif
assert(OffReg >= 0 && "FIXME: cpReg2MemMI cannot find an unused reg.");
mvec.push_back(BuildMI(V9::SETSW, 2).addZImm(Offset).addReg(OffReg));
assert(scratchReg >= 0 && "Need scratch reg to store %ccr to memory");
assert(getRegType(scratchReg) ==IntRegType && "Invalid scratch reg");
MI = (BuildMI(V9::RDCCR, 2)
- .addMReg(getUnifiedRegNum(SparcRegInfo::IntCCRegClassID,
- SparcIntCCRegClass::ccr))
+ .addMReg(getUnifiedRegNum(SparcV9RegInfo::IntCCRegClassID,
+ SparcV9IntCCRegClass::ccr))
.addMReg(scratchReg, MachineOperand::Def));
mvec.push_back(MI);
return;
case FloatCCRegType: {
- unsigned fsrReg = getUnifiedRegNum(SparcRegInfo::SpecialRegClassID,
- SparcSpecialRegClass::fsr);
+ unsigned fsrReg = getUnifiedRegNum(SparcV9RegInfo::SpecialRegClassID,
+ SparcV9SpecialRegClass::fsr);
if (target.getInstrInfo().constantFitsInImmedField(V9::STXFSRi, Offset))
MI=BuildMI(V9::STXFSRi,3).addMReg(fsrReg).addMReg(PtrReg).addSImm(Offset);
else
void
-SparcRegInfo::cpMem2RegMI(std::vector<MachineInstr*>& mvec,
+SparcV9RegInfo::cpMem2RegMI(std::vector<MachineInstr*>& mvec,
unsigned PtrReg,
int Offset,
unsigned DestReg,
OffReg = PRA.getUnusedUniRegAtMI(RC, RegType, MInst, LVSetBef);
#else
// Default to using register g4 for holding large offsets
- OffReg = getUnifiedRegNum(SparcRegInfo::IntRegClassID,
- SparcIntRegClass::g4);
+ OffReg = getUnifiedRegNum(SparcV9RegInfo::IntRegClassID,
+ SparcV9IntRegClass::g4);
#endif
assert(OffReg >= 0 && "FIXME: cpReg2MemMI cannot find an unused reg.");
mvec.push_back(BuildMI(V9::SETSW, 2).addZImm(Offset).addReg(OffReg));
cpMem2RegMI(mvec, PtrReg, Offset, scratchReg, IntRegType);
MI = (BuildMI(V9::WRCCRr, 3)
.addMReg(scratchReg)
- .addMReg(SparcIntRegClass::g0)
- .addMReg(getUnifiedRegNum(SparcRegInfo::IntCCRegClassID,
- SparcIntCCRegClass::ccr), MachineOperand::Def));
+ .addMReg(SparcV9IntRegClass::g0)
+ .addMReg(getUnifiedRegNum(SparcV9RegInfo::IntCCRegClassID,
+ SparcV9IntCCRegClass::ccr), MachineOperand::Def));
break;
case FloatCCRegType: {
- unsigned fsrRegNum = getUnifiedRegNum(SparcRegInfo::SpecialRegClassID,
- SparcSpecialRegClass::fsr);
+ unsigned fsrRegNum = getUnifiedRegNum(SparcV9RegInfo::SpecialRegClassID,
+ SparcV9SpecialRegClass::fsr);
if (target.getInstrInfo().constantFitsInImmedField(V9::LDXFSRi, Offset))
MI = BuildMI(V9::LDXFSRi, 3).addMReg(PtrReg).addSImm(Offset)
.addMReg(fsrRegNum, MachineOperand::UseAndDef);
void
-SparcRegInfo::cpValue2Value(Value *Src, Value *Dest,
+SparcV9RegInfo::cpValue2Value(Value *Src, Value *Dest,
std::vector<MachineInstr*>& mvec) const {
int RegType = getRegTypeForDataType(Src->getType());
MachineInstr * MI = NULL;
// Print the register assigned to a LR
//---------------------------------------------------------------------------
-void SparcRegInfo::printReg(const LiveRange *LR) const {
+void SparcV9RegInfo::printReg(const LiveRange *LR) const {
unsigned RegClassID = LR->getRegClassID();
std::cerr << " Node ";
-//===-- SparcRegInfo.h - Define TargetRegInfo for Sparc ---------*- C++ -*-===//
+//===-- SparcV9RegInfo.h - Define TargetRegInfo for SparcV9 ---------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This class implements the virtual class TargetRegInfo for Sparc.
+// This class implements the virtual class TargetRegInfo for SparcV9.
//
//----------------------------------------------------------------------------
namespace llvm {
-class SparcTargetMachine;
+class SparcV9TargetMachine;
-class SparcRegInfo : public TargetRegInfo {
+class SparcV9RegInfo : public TargetRegInfo {
private:
// The following methods are used to color special live ranges (e.g.
// function args and return values etc.) with specific hardware registers
- // as required. See SparcRegInfo.cpp for the implementation.
+ // as required. See SparcV9RegInfo.cpp for the implementation.
//
void suggestReg4RetAddr(MachineInstr *RetMI,
LiveRangeInfo &LRI) const;
int getRegTypeForClassAndType(unsigned regClassID, const Type* type) const;
public:
- // Type of registers available in Sparc. There can be several reg types
+ // Type of registers available in SparcV9. There can be several reg types
// in the same class. For instace, the float reg class has Single/Double
// types
//
SpecialRegType
};
- // The actual register classes in the Sparc
+ // The actual register classes in the SparcV9
//
// **** WARNING: If this enum order is changed, also modify
// getRegisterClassOfValue method below since it assumes this particular
SpecialRegClassID // Special (unallocated) registers
};
- SparcRegInfo(const SparcTargetMachine &tgt);
+ SparcV9RegInfo(const SparcV9TargetMachine &tgt);
// To find the register class used for a specified Type
//
// The following methods are used to color special live ranges (e.g.
// function args and return values etc.) with specific hardware registers
- // as required. See SparcRegInfo.cpp for the implementation for Sparc.
+ // as required. See SparcV9RegInfo.cpp for the implementation for SparcV9.
//
void suggestRegs4MethodArgs(const Function *Meth,
LiveRangeInfo& LRI) const;
void printReg(const LiveRange *LR) const;
// returns the # of bytes of stack space allocated for each register
- // type. For Sparc, currently we allocate 8 bytes on stack for all
+ // type. For SparcV9, currently we allocate 8 bytes on stack for all
// register types. We can optimize this later if necessary to save stack
// space (However, should make sure that stack alignment is correct)
//
-//===-- UltraSparcSchedInfo.cpp -------------------------------------------===//
+//===-- UltraSparcV9SchedInfo.cpp -------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// Describe the scheduling characteristics of the UltraSparc
+// Describe the scheduling characteristics of the UltraSparcV9
//
//===----------------------------------------------------------------------===//
-#include "SparcInternals.h"
+#include "SparcV9Internals.h"
using namespace llvm;
//---------------------------------------------------------------------------
-// const InstrClassRUsage SparcRUsageDesc[]
+// const InstrClassRUsage SparcV9RUsageDesc[]
//
// Purpose:
// Resource usage information for instruction in each scheduling class.
};
-static const InstrClassRUsage SparcRUsageDesc[] = {
+static const InstrClassRUsage SparcV9RUsageDesc[] = {
NoneClassRUsage,
IEUNClassRUsage,
IEU0ClassRUsage,
//---------------------------------------------------------------------------
-// const InstrIssueDelta SparcInstrIssueDeltas[]
+// const InstrIssueDelta SparcV9InstrIssueDeltas[]
//
// Purpose:
// Changes to issue restrictions information in InstrClassRUsage for
// instructions that differ from other instructions in their class.
//---------------------------------------------------------------------------
-static const InstrIssueDelta SparcInstrIssueDeltas[] = {
+static const InstrIssueDelta SparcV9InstrIssueDeltas[] = {
// opCode, isSingleIssue, breaksGroup, numBubbles
//---------------------------------------------------------------------------
-// const InstrRUsageDelta SparcInstrUsageDeltas[]
+// const InstrRUsageDelta SparcV9InstrUsageDeltas[]
//
// Purpose:
// Changes to resource usage information in InstrClassRUsage for
// instructions that differ from other instructions in their class.
//---------------------------------------------------------------------------
-static const InstrRUsageDelta SparcInstrUsageDeltas[] = {
+static const InstrRUsageDelta SparcV9InstrUsageDeltas[] = {
// MachineOpCode, Resource, Start cycle, Num cycles
#ifdef EXPLICIT_BUBBLES_NEEDED
//
// MULScc inserts one bubble.
- // This means it breaks the current group (captured in UltraSparcSchedInfo)
+ // This means it breaks the current group (captured in UltraSparcV9SchedInfo)
// *and occupies all issue slots for the next cycle
//
//{ V9::MULScc, AllIssueSlots.rid, 2, 2-1 },
//---------------------------------------------------------------------------
-// class SparcSchedInfo
+// class SparcV9SchedInfo
//
// Purpose:
// Scheduling information for the UltraSPARC.
//---------------------------------------------------------------------------
/*ctor*/
-SparcSchedInfo::SparcSchedInfo(const TargetMachine& tgt)
+SparcV9SchedInfo::SparcV9SchedInfo(const TargetMachine& tgt)
: TargetSchedInfo(tgt,
(unsigned int) SPARC_NUM_SCHED_CLASSES,
- SparcRUsageDesc,
- SparcInstrUsageDeltas,
- SparcInstrIssueDeltas,
- sizeof(SparcInstrUsageDeltas)/sizeof(InstrRUsageDelta),
- sizeof(SparcInstrIssueDeltas)/sizeof(InstrIssueDelta))
+ SparcV9RUsageDesc,
+ SparcV9InstrUsageDeltas,
+ SparcV9InstrIssueDeltas,
+ sizeof(SparcV9InstrUsageDeltas)/sizeof(InstrRUsageDelta),
+ sizeof(SparcV9InstrIssueDeltas)/sizeof(InstrIssueDelta))
{
maxNumIssueTotal = 4;
longestIssueConflict = 0; // computed from issuesGaps[]
}
void
-SparcSchedInfo::initializeResources()
+SparcV9SchedInfo::initializeResources()
{
// Compute TargetSchedInfo::instrRUsages and TargetSchedInfo::issueGaps
TargetSchedInfo::initializeResources();
-//===-- Sparc.cpp - General implementation file for the Sparc Target ------===//
+//===-- SparcV9.cpp - General implementation file for the SparcV9 Target ------===//
//
// The LLVM Compiler Infrastructure
//
#include "llvm/Target/TargetMachineImpls.h"
#include "llvm/Transforms/Scalar.h"
#include "MappingInfo.h"
-#include "SparcInternals.h"
-#include "SparcTargetMachine.h"
+#include "SparcV9Internals.h"
+#include "SparcV9TargetMachine.h"
#include "Support/CommandLine.h"
using namespace llvm;
static const unsigned ImplicitRegUseList[] = { 0 }; /* not used yet */
// Build the MachineInstruction Description Array...
-const TargetInstrDescriptor llvm::SparcMachineInstrDesc[] = {
+const TargetInstrDescriptor llvm::SparcV9MachineInstrDesc[] = {
#define I(ENUM, OPCODESTRING, NUMOPERANDS, RESULTPOS, MAXIMM, IMMSE, \
NUMDELAYSLOTS, LATENCY, SCHEDCLASS, INSTFLAGS) \
{ OPCODESTRING, NUMOPERANDS, RESULTPOS, MAXIMM, IMMSE, \
NUMDELAYSLOTS, LATENCY, SCHEDCLASS, INSTFLAGS, 0, \
ImplicitRegUseList, ImplicitRegUseList },
-#include "SparcInstr.def"
+#include "SparcV9Instr.def"
};
//---------------------------------------------------------------------------
}
}
-FunctionPass *llvm::createSparcMachineCodeDestructionPass() {
+FunctionPass *llvm::createSparcV9MachineCodeDestructionPass() {
return new DestroyMachineFunction();
}
-SparcTargetMachine::SparcTargetMachine(IntrinsicLowering *il)
- : TargetMachine("UltraSparc-Native", il, false),
+SparcV9TargetMachine::SparcV9TargetMachine(IntrinsicLowering *il)
+ : TargetMachine("UltraSparcV9-Native", il, false),
schedInfo(*this),
regInfo(*this),
frameInfo(*this),
/// process for the ultra sparc.
///
bool
-SparcTargetMachine::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out)
+SparcV9TargetMachine::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out)
{
// The following 3 passes used to be inserted specially by llc.
// Replace malloc and free instructions with library calls.
// allowing machine code representations for functions to be free'd after the
// function has been emitted.
PM.add(createAsmPrinterPass(Out, *this));
- PM.add(createSparcMachineCodeDestructionPass()); // Free mem no longer needed
+ PM.add(createSparcV9MachineCodeDestructionPass()); // Free mem no longer needed
// Emit bytecode to the assembly file into its special section next
if (EmitMappingInfo)
}
/// addPassesToJITCompile - This method controls the JIT method of code
-/// generation for the UltraSparc.
+/// generation for the UltraSparcV9.
///
-void SparcJITInfo::addPassesToJITCompile(FunctionPassManager &PM) {
+void SparcV9JITInfo::addPassesToJITCompile(FunctionPassManager &PM) {
const TargetData &TD = TM.getTargetData();
PM.add(new TargetData("lli", TD.isLittleEndian(), TD.getPointerSize(),
PM.add(createPeepholeOptsPass(TM));
}
-/// allocateSparcTargetMachine - Allocate and return a subclass of TargetMachine
-/// that implements the Sparc backend. (the llvm/CodeGen/Sparc.h interface)
+/// allocateSparcV9TargetMachine - Allocate and return a subclass of TargetMachine
+/// that implements the SparcV9 backend. (the llvm/CodeGen/SparcV9.h interface)
///
-TargetMachine *llvm::allocateSparcTargetMachine(const Module &M,
+TargetMachine *llvm::allocateSparcV9TargetMachine(const Module &M,
IntrinsicLowering *IL) {
- return new SparcTargetMachine(IL);
+ return new SparcV9TargetMachine(IL);
}
-//===-- SparcTargetMachine.h - Define TargetMachine for Sparc ---*- C++ -*-===//
+//===-- SparcV9TargetMachine.h - Define TargetMachine for SparcV9 ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
#include "llvm/Target/TargetFrameInfo.h"
#include "llvm/Target/TargetMachine.h"
-#include "SparcInstrInfo.h"
-#include "SparcInternals.h"
-#include "SparcRegInfo.h"
-#include "SparcFrameInfo.h"
-#include "SparcJITInfo.h"
+#include "SparcV9InstrInfo.h"
+#include "SparcV9Internals.h"
+#include "SparcV9RegInfo.h"
+#include "SparcV9FrameInfo.h"
+#include "SparcV9JITInfo.h"
namespace llvm {
class PassManager;
-class SparcTargetMachine : public TargetMachine {
- SparcInstrInfo instrInfo;
- SparcSchedInfo schedInfo;
- SparcRegInfo regInfo;
- SparcFrameInfo frameInfo;
- SparcCacheInfo cacheInfo;
- SparcJITInfo jitInfo;
+class SparcV9TargetMachine : public TargetMachine {
+ SparcV9InstrInfo instrInfo;
+ SparcV9SchedInfo schedInfo;
+ SparcV9RegInfo regInfo;
+ SparcV9FrameInfo frameInfo;
+ SparcV9CacheInfo cacheInfo;
+ SparcV9JITInfo jitInfo;
public:
- SparcTargetMachine(IntrinsicLowering *IL);
+ SparcV9TargetMachine(IntrinsicLowering *IL);
virtual const TargetInstrInfo &getInstrInfo() const { return instrInfo; }
virtual const TargetSchedInfo &getSchedInfo() const { return schedInfo; }
-//===- SparcV9_F2.td - Format 2 instructions: Sparc V9 Target -------------===//
+//===- SparcV9_F2.td - Format 2 instructions: SparcV9 V9 Target -------------===//
//
// The LLVM Compiler Infrastructure
//
class F2_2<bits<4> cond, string name> : F2_br { // Format 2.2 instructions
bits<22> disp;
- bit annul = 0; // currently unused by Sparc backend
+ bit annul = 0; // currently unused by SparcV9 backend
let Name = name;
let Inst{29} = annul;
bits<2> cc;
bits<19> disp;
bit predict = 1;
- bit annul = 0; // currently unused by Sparc backend
+ bit annul = 0; // currently unused by SparcV9 backend
let Name = name;
let Inst{29} = annul;
bits<5> rs1;
bits<16> disp;
bit predict = 1;
- bit annul = 0; // currently unused by Sparc backend
+ bit annul = 0; // currently unused by SparcV9 backend
let Name = name;
let Inst{29} = annul;
-//===- SparcV9_F3.td - Format 3 Instructions: Sparc V9 Target -------------===//
+//===- SparcV9_F3.td - Format 3 Instructions: SparcV9 V9 Target -------------===//
//
// The LLVM Compiler Infrastructure
//
-//===- SparcV9_F4.td - Format 4 instructions: Sparc V9 Target -------------===//
+//===- SparcV9_F4.td - Format 4 instructions: SparcV9 V9 Target -------------===//
//
// The LLVM Compiler Infrastructure
//
-//===- SparcV9_Reg.td - Sparc V9 Register definitions ---------------------===//
+//===- SparcV9_Reg.td - SparcV9 V9 Register definitions ---------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
-// Declarations that describe the Sparc register file
+// Declarations that describe the SparcV9 register file
//===----------------------------------------------------------------------===//
// Ri - One of the 32 64 bit integer registers
projects / oota-llvm.git / commitdiff