mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-12-14 23:29:51 +00:00
s/ISel/PPC64ISel/ to have unique class names for debugging via gdb because the
C++ front-end in gcc does not mangle classes in anonymous namespaces correctly. llvm-svn: 16471
This commit is contained in:
Misha Brukman
parent
6ad6dd2ab9
commit
bd9f406b0b
@ -73,7 +73,7 @@ static inline TypeClass getClassB(const Type *Ty) {
|
||||
}
|
||||
|
||||
namespace {
|
||||
struct ISel : public FunctionPass, InstVisitor<ISel> {
|
||||
struct PPC64ISel : public FunctionPass, InstVisitor<PPC64ISel> {
|
||||
PPC64TargetMachine &TM;
|
||||
MachineFunction *F; // The function we are compiling into
|
||||
MachineBasicBlock *BB; // The current MBB we are compiling
|
||||
@ -95,7 +95,7 @@ namespace {
|
||||
// Target configuration data
|
||||
const unsigned ParameterSaveAreaOffset, MaxArgumentStackSpace;
|
||||
|
||||
ISel(TargetMachine &tm) : TM(reinterpret_cast<PPC64TargetMachine&>(tm)),
|
||||
PPC64ISel(TargetMachine &tm):TM(reinterpret_cast<PPC64TargetMachine&>(tm)),
|
||||
F(0), BB(0), ParameterSaveAreaOffset(24), MaxArgumentStackSpace(32) {}
|
||||
|
||||
bool doInitialization(Module &M) {
|
||||
@ -397,8 +397,8 @@ static AllocaInst *dyn_castFixedAlloca(Value *V) {
|
||||
|
||||
/// getReg - This method turns an LLVM value into a register number.
|
||||
///
|
||||
unsigned ISel::getReg(Value *V, MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IPt) {
|
||||
unsigned PPC64ISel::getReg(Value *V, MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IPt) {
|
||||
if (Constant *C = dyn_cast<Constant>(V)) {
|
||||
unsigned Reg = makeAnotherReg(V->getType());
|
||||
copyConstantToRegister(MBB, IPt, C, Reg);
|
||||
@ -423,7 +423,7 @@ unsigned ISel::getReg(Value *V, MachineBasicBlock *MBB,
|
||||
/// is okay to use as an immediate argument to a certain binary operator.
|
||||
///
|
||||
/// Operator is one of: 0 for Add, 1 for Sub, 2 for And, 3 for Or, 4 for Xor.
|
||||
bool ISel::canUseAsImmediateForOpcode(ConstantInt *CI, unsigned Operator) {
|
||||
bool PPC64ISel::canUseAsImmediateForOpcode(ConstantInt *CI, unsigned Operator) {
|
||||
ConstantSInt *Op1Cs;
|
||||
ConstantUInt *Op1Cu;
|
||||
|
||||
@ -464,7 +464,7 @@ bool ISel::canUseAsImmediateForOpcode(ConstantInt *CI, unsigned Operator) {
|
||||
/// getFixedSizedAllocaFI - Return the frame index for a fixed sized alloca
|
||||
/// that is to be statically allocated with the initial stack frame
|
||||
/// adjustment.
|
||||
unsigned ISel::getFixedSizedAllocaFI(AllocaInst *AI) {
|
||||
unsigned PPC64ISel::getFixedSizedAllocaFI(AllocaInst *AI) {
|
||||
// Already computed this?
|
||||
std::map<AllocaInst*, unsigned>::iterator I = AllocaMap.lower_bound(AI);
|
||||
if (I != AllocaMap.end() && I->first == AI) return I->second;
|
||||
@ -485,9 +485,9 @@ unsigned ISel::getFixedSizedAllocaFI(AllocaInst *AI) {
|
||||
/// copyConstantToRegister - Output the instructions required to put the
|
||||
/// specified constant into the specified register.
|
||||
///
|
||||
void ISel::copyConstantToRegister(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Constant *C, unsigned R) {
|
||||
void PPC64ISel::copyConstantToRegister(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Constant *C, unsigned R) {
|
||||
if (C->getType()->isIntegral()) {
|
||||
unsigned Class = getClassB(C->getType());
|
||||
|
||||
@ -574,7 +574,7 @@ void ISel::copyConstantToRegister(MachineBasicBlock *MBB,
|
||||
|
||||
/// LoadArgumentsToVirtualRegs - Load all of the arguments to this function from
|
||||
/// the stack into virtual registers.
|
||||
void ISel::LoadArgumentsToVirtualRegs(Function &Fn) {
|
||||
void PPC64ISel::LoadArgumentsToVirtualRegs(Function &Fn) {
|
||||
unsigned ArgOffset = ParameterSaveAreaOffset;
|
||||
unsigned GPR_remaining = 8;
|
||||
unsigned FPR_remaining = 13;
|
||||
@ -703,7 +703,7 @@ void ISel::LoadArgumentsToVirtualRegs(Function &Fn) {
|
||||
/// because we have to generate our sources into the source basic blocks, not
|
||||
/// the current one.
|
||||
///
|
||||
void ISel::SelectPHINodes() {
|
||||
void PPC64ISel::SelectPHINodes() {
|
||||
const TargetInstrInfo &TII = *TM.getInstrInfo();
|
||||
const Function &LF = *F->getFunction(); // The LLVM function...
|
||||
for (Function::const_iterator I = LF.begin(), E = LF.end(); I != E; ++I) {
|
||||
@ -861,17 +861,17 @@ static unsigned getPPCOpcodeForSetCCNumber(unsigned Opcode) {
|
||||
}
|
||||
|
||||
/// emitUCOM - emits an unordered FP compare.
|
||||
void ISel::emitUCOM(MachineBasicBlock *MBB, MachineBasicBlock::iterator IP,
|
||||
unsigned LHS, unsigned RHS) {
|
||||
void PPC64ISel::emitUCOM(MachineBasicBlock *MBB, MachineBasicBlock::iterator IP,
|
||||
unsigned LHS, unsigned RHS) {
|
||||
BuildMI(*MBB, IP, PPC::FCMPU, 2, PPC::CR0).addReg(LHS).addReg(RHS);
|
||||
}
|
||||
|
||||
/// EmitComparison - emits a comparison of the two operands, returning the
|
||||
/// extended setcc code to use. The result is in CR0.
|
||||
///
|
||||
unsigned ISel::EmitComparison(unsigned OpNum, Value *Op0, Value *Op1,
|
||||
MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP) {
|
||||
unsigned PPC64ISel::EmitComparison(unsigned OpNum, Value *Op0, Value *Op1,
|
||||
MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP) {
|
||||
// The arguments are already supposed to be of the same type.
|
||||
const Type *CompTy = Op0->getType();
|
||||
unsigned Class = getClassB(CompTy);
|
||||
@ -943,7 +943,7 @@ unsigned ISel::EmitComparison(unsigned OpNum, Value *Op0, Value *Op1,
|
||||
/// visitSetCondInst - emit code to calculate the condition via
|
||||
/// EmitComparison(), and possibly store a 0 or 1 to a register as a result
|
||||
///
|
||||
void ISel::visitSetCondInst(SetCondInst &I) {
|
||||
void PPC64ISel::visitSetCondInst(SetCondInst &I) {
|
||||
if (canFoldSetCCIntoBranchOrSelect(&I))
|
||||
return;
|
||||
|
||||
@ -1007,7 +1007,7 @@ void ISel::visitSetCondInst(SetCondInst &I) {
|
||||
.addMBB(copy0MBB).addReg(TrueValue).addMBB(copy1MBB);
|
||||
}
|
||||
|
||||
void ISel::visitSelectInst(SelectInst &SI) {
|
||||
void PPC64ISel::visitSelectInst(SelectInst &SI) {
|
||||
unsigned DestReg = getReg(SI);
|
||||
MachineBasicBlock::iterator MII = BB->end();
|
||||
emitSelectOperation(BB, MII, SI.getCondition(), SI.getTrueValue(),
|
||||
@ -1018,10 +1018,10 @@ void ISel::visitSelectInst(SelectInst &SI) {
|
||||
/// expression support.
|
||||
/// FIXME: this is most likely broken in one or more ways. Namely, PowerPC has
|
||||
/// no select instruction. FSEL only works for comparisons against zero.
|
||||
void ISel::emitSelectOperation(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Cond, Value *TrueVal, Value *FalseVal,
|
||||
unsigned DestReg) {
|
||||
void PPC64ISel::emitSelectOperation(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Cond, Value *TrueVal,
|
||||
Value *FalseVal, unsigned DestReg) {
|
||||
unsigned SelectClass = getClassB(TrueVal->getType());
|
||||
unsigned Opcode;
|
||||
|
||||
@ -1095,7 +1095,7 @@ void ISel::emitSelectOperation(MachineBasicBlock *MBB,
|
||||
/// promote32 - Emit instructions to turn a narrow operand into a 32-bit-wide
|
||||
/// operand, in the specified target register.
|
||||
///
|
||||
void ISel::promote32(unsigned targetReg, const ValueRecord &VR) {
|
||||
void PPC64ISel::promote32(unsigned targetReg, const ValueRecord &VR) {
|
||||
bool isUnsigned = VR.Ty->isUnsigned() || VR.Ty == Type::BoolTy;
|
||||
|
||||
Value *Val = VR.Val;
|
||||
@ -1156,7 +1156,7 @@ void ISel::promote32(unsigned targetReg, const ValueRecord &VR) {
|
||||
|
||||
/// visitReturnInst - implemented with BLR
|
||||
///
|
||||
void ISel::visitReturnInst(ReturnInst &I) {
|
||||
void PPC64ISel::visitReturnInst(ReturnInst &I) {
|
||||
// Only do the processing if this is a non-void return
|
||||
if (I.getNumOperands() > 0) {
|
||||
Value *RetVal = I.getOperand(0);
|
||||
@ -1192,7 +1192,7 @@ static inline BasicBlock *getBlockAfter(BasicBlock *BB) {
|
||||
/// jump to a block that is the immediate successor of the current block, we can
|
||||
/// just make a fall-through (but we don't currently).
|
||||
///
|
||||
void ISel::visitBranchInst(BranchInst &BI) {
|
||||
void PPC64ISel::visitBranchInst(BranchInst &BI) {
|
||||
// Update machine-CFG edges
|
||||
BB->addSuccessor(MBBMap[BI.getSuccessor(0)]);
|
||||
if (BI.isConditional())
|
||||
@ -1255,8 +1255,8 @@ void ISel::visitBranchInst(BranchInst &BI) {
|
||||
/// and the return value as appropriate. For the actual function call itself,
|
||||
/// it inserts the specified CallMI instruction into the stream.
|
||||
///
|
||||
void ISel::doCall(const ValueRecord &Ret, MachineInstr *CallMI,
|
||||
const std::vector<ValueRecord> &Args, bool isVarArg) {
|
||||
void PPC64ISel::doCall(const ValueRecord &Ret, MachineInstr *CallMI,
|
||||
const std::vector<ValueRecord> &Args, bool isVarArg) {
|
||||
// Count how many bytes are to be pushed on the stack, including the linkage
|
||||
// area, and parameter passing area.
|
||||
unsigned NumBytes = ParameterSaveAreaOffset;
|
||||
@ -1441,7 +1441,7 @@ void ISel::doCall(const ValueRecord &Ret, MachineInstr *CallMI,
|
||||
|
||||
|
||||
/// visitCallInst - Push args on stack and do a procedure call instruction.
|
||||
void ISel::visitCallInst(CallInst &CI) {
|
||||
void PPC64ISel::visitCallInst(CallInst &CI) {
|
||||
MachineInstr *TheCall;
|
||||
Function *F = CI.getCalledFunction();
|
||||
if (F) {
|
||||
@ -1498,7 +1498,7 @@ static bool isOnlyUsedByUnorderedComparisons(Value *V) {
|
||||
/// function, lowering any calls to unknown intrinsic functions into the
|
||||
/// equivalent LLVM code.
|
||||
///
|
||||
void ISel::LowerUnknownIntrinsicFunctionCalls(Function &F) {
|
||||
void PPC64ISel::LowerUnknownIntrinsicFunctionCalls(Function &F) {
|
||||
for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
|
||||
for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; )
|
||||
if (CallInst *CI = dyn_cast<CallInst>(I++))
|
||||
@ -1547,7 +1547,7 @@ void ISel::LowerUnknownIntrinsicFunctionCalls(Function &F) {
|
||||
}
|
||||
}
|
||||
|
||||
void ISel::visitIntrinsicCall(Intrinsic::ID ID, CallInst &CI) {
|
||||
void PPC64ISel::visitIntrinsicCall(Intrinsic::ID ID, CallInst &CI) {
|
||||
unsigned TmpReg1, TmpReg2, TmpReg3;
|
||||
switch (ID) {
|
||||
case Intrinsic::vastart:
|
||||
@ -1610,7 +1610,7 @@ void ISel::visitIntrinsicCall(Intrinsic::ID ID, CallInst &CI) {
|
||||
/// OperatorClass is one of: 0 for Add, 1 for Sub, 2 for And, 3 for Or, 4 for
|
||||
/// Xor.
|
||||
///
|
||||
void ISel::visitSimpleBinary(BinaryOperator &B, unsigned OperatorClass) {
|
||||
void PPC64ISel::visitSimpleBinary(BinaryOperator &B, unsigned OperatorClass) {
|
||||
unsigned DestReg = getReg(B);
|
||||
MachineBasicBlock::iterator MI = BB->end();
|
||||
Value *Op0 = B.getOperand(0), *Op1 = B.getOperand(1);
|
||||
@ -1621,10 +1621,10 @@ void ISel::visitSimpleBinary(BinaryOperator &B, unsigned OperatorClass) {
|
||||
|
||||
/// emitBinaryFPOperation - This method handles emission of floating point
|
||||
/// Add (0), Sub (1), Mul (2), and Div (3) operations.
|
||||
void ISel::emitBinaryFPOperation(MachineBasicBlock *BB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Op0, Value *Op1,
|
||||
unsigned OperatorClass, unsigned DestReg) {
|
||||
void PPC64ISel::emitBinaryFPOperation(MachineBasicBlock *BB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Op0, Value *Op1,
|
||||
unsigned OperatorClass, unsigned DestReg){
|
||||
|
||||
static const unsigned OpcodeTab[][4] = {
|
||||
{ PPC::FADDS, PPC::FSUBS, PPC::FMULS, PPC::FDIVS }, // Float
|
||||
@ -1653,10 +1653,11 @@ void ISel::emitBinaryFPOperation(MachineBasicBlock *BB,
|
||||
/// emitSimpleBinaryOperation - Common code shared between visitSimpleBinary
|
||||
/// and constant expression support.
|
||||
///
|
||||
void ISel::emitSimpleBinaryOperation(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Op0, Value *Op1,
|
||||
unsigned OperatorClass, unsigned DestReg) {
|
||||
void PPC64ISel::emitSimpleBinaryOperation(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Op0, Value *Op1,
|
||||
unsigned OperatorClass,
|
||||
unsigned DestReg) {
|
||||
unsigned Class = getClassB(Op0->getType());
|
||||
|
||||
// Arithmetic and Bitwise operators
|
||||
@ -1768,9 +1769,9 @@ static unsigned ExactLog2(unsigned Val) {
|
||||
/// doMultiply - Emit appropriate instructions to multiply together the
|
||||
/// Values Op0 and Op1, and put the result in DestReg.
|
||||
///
|
||||
void ISel::doMultiply(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
unsigned DestReg, Value *Op0, Value *Op1) {
|
||||
void PPC64ISel::doMultiply(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
unsigned DestReg, Value *Op0, Value *Op1) {
|
||||
unsigned Class0 = getClass(Op0->getType());
|
||||
unsigned Class1 = getClass(Op1->getType());
|
||||
|
||||
@ -1801,9 +1802,9 @@ void ISel::doMultiply(MachineBasicBlock *MBB,
|
||||
|
||||
/// doMultiplyConst - This method will multiply the value in Op0 by the
|
||||
/// value of the ContantInt *CI
|
||||
void ISel::doMultiplyConst(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
unsigned DestReg, Value *Op0, ConstantInt *CI) {
|
||||
void PPC64ISel::doMultiplyConst(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
unsigned DestReg, Value *Op0, ConstantInt *CI) {
|
||||
unsigned Class = getClass(Op0->getType());
|
||||
|
||||
// Mul op0, 0 ==> 0
|
||||
@ -1839,7 +1840,7 @@ void ISel::doMultiplyConst(MachineBasicBlock *MBB,
|
||||
doMultiply(MBB, IP, DestReg, Op0, CI);
|
||||
}
|
||||
|
||||
void ISel::visitMul(BinaryOperator &I) {
|
||||
void PPC64ISel::visitMul(BinaryOperator &I) {
|
||||
unsigned ResultReg = getReg(I);
|
||||
|
||||
Value *Op0 = I.getOperand(0);
|
||||
@ -1849,8 +1850,9 @@ void ISel::visitMul(BinaryOperator &I) {
|
||||
emitMultiply(BB, IP, Op0, Op1, ResultReg);
|
||||
}
|
||||
|
||||
void ISel::emitMultiply(MachineBasicBlock *MBB, MachineBasicBlock::iterator IP,
|
||||
Value *Op0, Value *Op1, unsigned DestReg) {
|
||||
void PPC64ISel::emitMultiply(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Op0, Value *Op1, unsigned DestReg) {
|
||||
TypeClass Class = getClass(Op0->getType());
|
||||
|
||||
switch (Class) {
|
||||
@ -1878,7 +1880,7 @@ void ISel::emitMultiply(MachineBasicBlock *MBB, MachineBasicBlock::iterator IP,
|
||||
/// select the result from a different register. Note that both of these
|
||||
/// instructions work differently for signed and unsigned operands.
|
||||
///
|
||||
void ISel::visitDivRem(BinaryOperator &I) {
|
||||
void PPC64ISel::visitDivRem(BinaryOperator &I) {
|
||||
unsigned ResultReg = getReg(I);
|
||||
Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
|
||||
|
||||
@ -1887,10 +1889,10 @@ void ISel::visitDivRem(BinaryOperator &I) {
|
||||
ResultReg);
|
||||
}
|
||||
|
||||
void ISel::emitDivRemOperation(MachineBasicBlock *BB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Op0, Value *Op1, bool isDiv,
|
||||
unsigned ResultReg) {
|
||||
void PPC64ISel::emitDivRemOperation(MachineBasicBlock *BB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Op0, Value *Op1, bool isDiv,
|
||||
unsigned ResultReg) {
|
||||
const Type *Ty = Op0->getType();
|
||||
unsigned Class = getClass(Ty);
|
||||
switch (Class) {
|
||||
@ -1989,7 +1991,7 @@ void ISel::emitDivRemOperation(MachineBasicBlock *BB,
|
||||
/// shift values equal to 1. Even the general case is sort of special,
|
||||
/// because the shift amount has to be in CL, not just any old register.
|
||||
///
|
||||
void ISel::visitShiftInst(ShiftInst &I) {
|
||||
void PPC64ISel::visitShiftInst(ShiftInst &I) {
|
||||
MachineBasicBlock::iterator IP = BB->end();
|
||||
emitShiftOperation(BB, IP, I.getOperand(0), I.getOperand(1),
|
||||
I.getOpcode() == Instruction::Shl, I.getType(),
|
||||
@ -1999,10 +2001,11 @@ void ISel::visitShiftInst(ShiftInst &I) {
|
||||
/// emitShiftOperation - Common code shared between visitShiftInst and
|
||||
/// constant expression support.
|
||||
///
|
||||
void ISel::emitShiftOperation(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Op, Value *ShiftAmount, bool isLeftShift,
|
||||
const Type *ResultTy, unsigned DestReg) {
|
||||
void PPC64ISel::emitShiftOperation(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Op, Value *ShiftAmount,
|
||||
bool isLeftShift, const Type *ResultTy,
|
||||
unsigned DestReg) {
|
||||
unsigned SrcReg = getReg (Op, MBB, IP);
|
||||
bool isSigned = ResultTy->isSigned ();
|
||||
unsigned Class = getClass (ResultTy);
|
||||
@ -2074,7 +2077,7 @@ void ISel::emitShiftOperation(MachineBasicBlock *MBB,
|
||||
/// mapping of LLVM classes to PPC load instructions, with the exception of
|
||||
/// signed byte loads, which need a sign extension following them.
|
||||
///
|
||||
void ISel::visitLoadInst(LoadInst &I) {
|
||||
void PPC64ISel::visitLoadInst(LoadInst &I) {
|
||||
// Immediate opcodes, for reg+imm addressing
|
||||
static const unsigned ImmOpcodes[] = {
|
||||
PPC::LBZ, PPC::LHZ, PPC::LWZ,
|
||||
@ -2162,7 +2165,7 @@ void ISel::visitLoadInst(LoadInst &I) {
|
||||
|
||||
/// visitStoreInst - Implement LLVM store instructions
|
||||
///
|
||||
void ISel::visitStoreInst(StoreInst &I) {
|
||||
void PPC64ISel::visitStoreInst(StoreInst &I) {
|
||||
// Immediate opcodes, for reg+imm addressing
|
||||
static const unsigned ImmOpcodes[] = {
|
||||
PPC::STB, PPC::STH, PPC::STW,
|
||||
@ -2217,7 +2220,7 @@ void ISel::visitStoreInst(StoreInst &I) {
|
||||
/// visitCastInst - Here we have various kinds of copying with or without sign
|
||||
/// extension going on.
|
||||
///
|
||||
void ISel::visitCastInst(CastInst &CI) {
|
||||
void PPC64ISel::visitCastInst(CastInst &CI) {
|
||||
Value *Op = CI.getOperand(0);
|
||||
|
||||
unsigned SrcClass = getClassB(Op->getType());
|
||||
@ -2246,10 +2249,10 @@ void ISel::visitCastInst(CastInst &CI) {
|
||||
/// emitCastOperation - Common code shared between visitCastInst and constant
|
||||
/// expression cast support.
|
||||
///
|
||||
void ISel::emitCastOperation(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Src, const Type *DestTy,
|
||||
unsigned DestReg) {
|
||||
void PPC64ISel::emitCastOperation(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Src, const Type *DestTy,
|
||||
unsigned DestReg) {
|
||||
const Type *SrcTy = Src->getType();
|
||||
unsigned SrcClass = getClassB(SrcTy);
|
||||
unsigned DestClass = getClassB(DestTy);
|
||||
@ -2623,7 +2626,7 @@ void ISel::emitCastOperation(MachineBasicBlock *MBB,
|
||||
|
||||
/// visitVANextInst - Implement the va_next instruction...
|
||||
///
|
||||
void ISel::visitVANextInst(VANextInst &I) {
|
||||
void PPC64ISel::visitVANextInst(VANextInst &I) {
|
||||
unsigned VAList = getReg(I.getOperand(0));
|
||||
unsigned DestReg = getReg(I);
|
||||
|
||||
@ -2649,7 +2652,7 @@ void ISel::visitVANextInst(VANextInst &I) {
|
||||
BuildMI(BB, PPC::ADDI, 2, DestReg).addReg(VAList).addSImm(Size);
|
||||
}
|
||||
|
||||
void ISel::visitVAArgInst(VAArgInst &I) {
|
||||
void PPC64ISel::visitVAArgInst(VAArgInst &I) {
|
||||
unsigned VAList = getReg(I.getOperand(0));
|
||||
unsigned DestReg = getReg(I);
|
||||
|
||||
@ -2678,7 +2681,7 @@ void ISel::visitVAArgInst(VAArgInst &I) {
|
||||
|
||||
/// visitGetElementPtrInst - instruction-select GEP instructions
|
||||
///
|
||||
void ISel::visitGetElementPtrInst(GetElementPtrInst &I) {
|
||||
void PPC64ISel::visitGetElementPtrInst(GetElementPtrInst &I) {
|
||||
if (canFoldGEPIntoLoadOrStore(&I))
|
||||
return;
|
||||
|
||||
@ -2690,12 +2693,12 @@ void ISel::visitGetElementPtrInst(GetElementPtrInst &I) {
|
||||
/// emitGEPOperation - Common code shared between visitGetElementPtrInst and
|
||||
/// constant expression GEP support.
|
||||
///
|
||||
void ISel::emitGEPOperation(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Src, User::op_iterator IdxBegin,
|
||||
User::op_iterator IdxEnd, unsigned TargetReg,
|
||||
bool GEPIsFolded, ConstantSInt **RemainderPtr,
|
||||
unsigned *PendingAddReg) {
|
||||
void PPC64ISel::emitGEPOperation(MachineBasicBlock *MBB,
|
||||
MachineBasicBlock::iterator IP,
|
||||
Value *Src, User::op_iterator IdxBegin,
|
||||
User::op_iterator IdxEnd, unsigned TargetReg,
|
||||
bool GEPIsFolded, ConstantSInt **RemainderPtr,
|
||||
unsigned *PendingAddReg) {
|
||||
const TargetData &TD = TM.getTargetData();
|
||||
const Type *Ty = Src->getType();
|
||||
unsigned basePtrReg = getReg(Src, MBB, IP);
|
||||
@ -2861,7 +2864,7 @@ void ISel::emitGEPOperation(MachineBasicBlock *MBB,
|
||||
/// visitAllocaInst - If this is a fixed size alloca, allocate space from the
|
||||
/// frame manager, otherwise do it the hard way.
|
||||
///
|
||||
void ISel::visitAllocaInst(AllocaInst &I) {
|
||||
void PPC64ISel::visitAllocaInst(AllocaInst &I) {
|
||||
// If this is a fixed size alloca in the entry block for the function, we
|
||||
// statically stack allocate the space, so we don't need to do anything here.
|
||||
//
|
||||
@ -2904,7 +2907,7 @@ void ISel::visitAllocaInst(AllocaInst &I) {
|
||||
/// visitMallocInst - Malloc instructions are code generated into direct calls
|
||||
/// to the library malloc.
|
||||
///
|
||||
void ISel::visitMallocInst(MallocInst &I) {
|
||||
void PPC64ISel::visitMallocInst(MallocInst &I) {
|
||||
unsigned AllocSize = TM.getTargetData().getTypeSize(I.getAllocatedType());
|
||||
unsigned Arg;
|
||||
|
||||
@ -2928,7 +2931,7 @@ void ISel::visitMallocInst(MallocInst &I) {
|
||||
/// visitFreeInst - Free instructions are code gen'd to call the free libc
|
||||
/// function.
|
||||
///
|
||||
void ISel::visitFreeInst(FreeInst &I) {
|
||||
void PPC64ISel::visitFreeInst(FreeInst &I) {
|
||||
std::vector<ValueRecord> Args;
|
||||
Args.push_back(ValueRecord(I.getOperand(0)));
|
||||
MachineInstr *TheCall =
|
||||
@ -2940,5 +2943,5 @@ void ISel::visitFreeInst(FreeInst &I) {
|
||||
/// code representation is a very simple peep-hole fashion.
|
||||
///
|
||||
FunctionPass *llvm::createPPC64ISelSimple(TargetMachine &TM) {
|
||||
return new ISel(TM);
|
||||
return new PPC64ISel(TM);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user