[llvm-commits] [llvm] r140390 - in /llvm/trunk/lib/Target/PTX: PTXAsmPrinter.cpp PTXISelLowering.cpp PTXMachineFunctionInfo.h
Justin Holewinski
justin.holewinski at gmail.com
Fri Sep 23 10:15:53 PDT 2011
Author: jholewinski
Date: Fri Sep 23 12:15:53 2011
New Revision: 140390
URL: http://llvm.org/viewvc/llvm-project?rev=140390&view=rev
Log:
PTX: Cleanup unused code in PTXMachineFunctionInfo
Modified:
llvm/trunk/lib/Target/PTX/PTXAsmPrinter.cpp
llvm/trunk/lib/Target/PTX/PTXISelLowering.cpp
llvm/trunk/lib/Target/PTX/PTXMachineFunctionInfo.h
Modified: llvm/trunk/lib/Target/PTX/PTXAsmPrinter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/PTX/PTXAsmPrinter.cpp?rev=140390&r1=140389&r2=140390&view=diff
==============================================================================
--- llvm/trunk/lib/Target/PTX/PTXAsmPrinter.cpp (original)
+++ llvm/trunk/lib/Target/PTX/PTXAsmPrinter.cpp Fri Sep 23 12:15:53 2011
@@ -600,8 +600,8 @@
decl += PM.getParamName(*i);
}
} else {
- for (PTXMachineFunctionInfo::ret_iterator
- i = MFI->retRegBegin(), e = MFI->retRegEnd(), b = i;
+ for (PTXMachineFunctionInfo::reg_iterator
+ i = MFI->retreg_begin(), e = MFI->retreg_end(), b = i;
i != e; ++i) {
if (i != b) {
decl += ", ";
@@ -638,7 +638,7 @@
}
} else {
for (PTXMachineFunctionInfo::reg_iterator
- i = MFI->argRegBegin(), e = MFI->argRegEnd(), b = i;
+ i = MFI->argreg_begin(), e = MFI->argreg_end(), b = i;
i != e; ++i) {
if (i != b) {
decl += ", ";
Modified: llvm/trunk/lib/Target/PTX/PTXISelLowering.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/PTX/PTXISelLowering.cpp?rev=140390&r1=140389&r2=140390&view=diff
==============================================================================
--- llvm/trunk/lib/Target/PTX/PTXISelLowering.cpp (original)
+++ llvm/trunk/lib/Target/PTX/PTXISelLowering.cpp Fri Sep 23 12:15:53 2011
@@ -228,32 +228,14 @@
SDValue ArgValue = DAG.getNode(PTXISD::LOAD_PARAM, dl, Ins[i].VT, Chain,
DAG.getTargetConstant(Param, MVT::i32));
InVals.push_back(ArgValue);
-
- // Instead of storing a physical register in our argument list, we just
- // store the total size of the parameter, in bits. The ASM printer
- // knows how to process this.
- MFI->addArgParam(Ins[i].VT.getStoreSizeInBits());
}
}
else {
- // For device functions, we use the PTX calling convention to do register
- // assignments then create CopyFromReg ISDs for the allocated registers
-
- //SmallVector<CCValAssign, 16> ArgLocs;
- //CCState CCInfo(CallConv, isVarArg, MF, getTargetMachine(), ArgLocs,
- // *DAG.getContext());
-
- //CCInfo.AnalyzeFormalArguments(Ins, CC_PTX);
-
- //for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {
for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
-
EVT RegVT = Ins[i].VT;
TargetRegisterClass* TRC = 0;
int OpCode;
- //assert(VA.isRegLoc() && "CCValAssign must be RegLoc");
-
// Determine which register class we need
if (RegVT == MVT::i1) {
TRC = PTX::RegPredRegisterClass;
@@ -329,12 +311,6 @@
PTXParamManager &PM = MFI->getParamManager();
SDValue Flag;
-
- // Even though we could use the .param space for return arguments for
- // device functions if SM >= 2.0 and the number of return arguments is
- // only 1, we just always use registers since this makes the codegen
- // easier.
-
const PTXSubtarget& ST = getTargetMachine().getSubtarget<PTXSubtarget>();
if (ST.useParamSpaceForDeviceArgs()) {
@@ -346,27 +322,9 @@
SDValue ParamIndex = DAG.getTargetConstant(Param, MVT::i32);
Chain = DAG.getNode(PTXISD::STORE_PARAM, dl, MVT::Other, Chain,
ParamIndex, OutVals[0]);
-
-
- //Flag = Chain.getValue(1);
- //MFI->setRetParamSize(Outs[0].VT.getStoreSizeInBits());
}
} else {
- //SmallVector<CCValAssign, 16> RVLocs;
- //CCState CCInfo(CallConv, isVarArg, DAG.getMachineFunction(),
- //getTargetMachine(), RVLocs, *DAG.getContext());
-
- //CCInfo.AnalyzeReturn(Outs, RetCC_PTX);
-
- //for (unsigned i = 0, e = RVLocs.size(); i != e; ++i) {
- //CCValAssign& VA = RVLocs[i];
-
for (unsigned i = 0, e = Outs.size(); i != e; ++i) {
-
- //assert(VA.isRegLoc() && "CCValAssign must be RegLoc");
-
- //unsigned Reg = VA.getLocReg();
-
EVT RegVT = Outs[i].VT;
TargetRegisterClass* TRC = 0;
@@ -395,24 +353,12 @@
unsigned Reg = MF.getRegInfo().createVirtualRegister(TRC);
- //DAG.getMachineFunction().getRegInfo().addLiveOut(Reg);
-
- //Chain = DAG.getCopyToReg(Chain, dl, Reg, OutVals[i], Flag);
- //SDValue Copy = DAG.getCopyToReg(Chain, dl, Reg, OutVals[i]/*, Flag*/);
-
- // Guarantee that all emitted copies are stuck together,
- // avoiding something bad
- //Flag = Chain.getValue(1);
-
SDValue Copy = DAG.getCopyToReg(Chain, dl, Reg, OutVals[i]/*, Flag*/);
SDValue OutReg = DAG.getRegister(Reg, RegVT);
Chain = DAG.getNode(PTXISD::WRITE_PARAM, dl, MVT::Other, Copy, OutReg);
- //Flag = Chain.getValue(1);
MFI->addRetReg(Reg);
-
- //MFI->addRetReg(Reg);
}
}
@@ -447,6 +393,7 @@
Ops[0] = Chain;
+ // Identify the callee function
if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
const GlobalValue *GV = G->getGlobal();
if (const Function *F = dyn_cast<Function>(GV)) {
@@ -461,6 +408,9 @@
assert(false && "Function must be a GlobalAddressSDNode");
}
+ // Generate STORE_PARAM nodes for each function argument. In PTX, function
+ // arguments are explicitly stored into .param variables and passed as
+ // arguments. There is no register/stack-based calling convention in PTX.
for (unsigned i = 0; i != OutVals.size(); ++i) {
unsigned Size = OutVals[i].getValueType().getSizeInBits();
unsigned Param = PM.addLocalParam(Size);
@@ -472,6 +422,7 @@
std::vector<unsigned> InParams;
+ // Generate list of .param variables to hold the return value(s).
for (unsigned i = 0; i < Ins.size(); ++i) {
unsigned Size = Ins[i].VT.getStoreSizeInBits();
unsigned Param = PM.addLocalParam(Size);
@@ -482,8 +433,10 @@
Ops[0] = Chain;
+ // Create the CALL node.
Chain = DAG.getNode(PTXISD::CALL, dl, MVT::Other, &Ops[0], Ops.size());
+ // Create the LOAD_PARAM nodes that retrieve the function return value(s).
for (unsigned i = 0; i < Ins.size(); ++i) {
SDValue Index = DAG.getTargetConstant(InParams[i], MVT::i32);
SDValue Load = DAG.getNode(PTXISD::LOAD_PARAM, dl, Ins[i].VT, Chain, Index);
Modified: llvm/trunk/lib/Target/PTX/PTXMachineFunctionInfo.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/PTX/PTXMachineFunctionInfo.h?rev=140390&r1=140389&r2=140390&view=diff
==============================================================================
--- llvm/trunk/lib/Target/PTX/PTXMachineFunctionInfo.h (original)
+++ llvm/trunk/lib/Target/PTX/PTXMachineFunctionInfo.h Fri Sep 23 12:15:53 2011
@@ -31,134 +31,79 @@
///
class PTXMachineFunctionInfo : public MachineFunctionInfo {
private:
- bool is_kernel;
- DenseSet<unsigned> reg_local_var;
- DenseSet<unsigned> reg_arg;
- DenseSet<unsigned> reg_ret;
- std::vector<unsigned> call_params;
- bool _isDoneAddArg;
+ bool IsKernel;
+ DenseSet<unsigned> RegArgs;
+ DenseSet<unsigned> RegRets;
typedef std::vector<unsigned> RegisterList;
typedef DenseMap<const TargetRegisterClass*, RegisterList> RegisterMap;
typedef DenseMap<unsigned, std::string> RegisterNameMap;
- RegisterMap usedRegs;
- RegisterNameMap regNames;
-
- SmallVector<unsigned, 8> argParams;
-
- unsigned retParamSize;
+ RegisterMap UsedRegs;
+ RegisterNameMap RegNames;
PTXParamManager ParamManager;
public:
- PTXMachineFunctionInfo(MachineFunction &MF)
- : is_kernel(false), reg_ret(PTX::NoRegister), _isDoneAddArg(false) {
- usedRegs[PTX::RegPredRegisterClass] = RegisterList();
- usedRegs[PTX::RegI16RegisterClass] = RegisterList();
- usedRegs[PTX::RegI32RegisterClass] = RegisterList();
- usedRegs[PTX::RegI64RegisterClass] = RegisterList();
- usedRegs[PTX::RegF32RegisterClass] = RegisterList();
- usedRegs[PTX::RegF64RegisterClass] = RegisterList();
+ typedef DenseSet<unsigned>::const_iterator reg_iterator;
- retParamSize = 0;
+ PTXMachineFunctionInfo(MachineFunction &MF)
+ : IsKernel(false) {
+ UsedRegs[PTX::RegPredRegisterClass] = RegisterList();
+ UsedRegs[PTX::RegI16RegisterClass] = RegisterList();
+ UsedRegs[PTX::RegI32RegisterClass] = RegisterList();
+ UsedRegs[PTX::RegI64RegisterClass] = RegisterList();
+ UsedRegs[PTX::RegF32RegisterClass] = RegisterList();
+ UsedRegs[PTX::RegF64RegisterClass] = RegisterList();
}
+ /// getParamManager - Returns the PTXParamManager instance for this function.
PTXParamManager& getParamManager() { return ParamManager; }
const PTXParamManager& getParamManager() const { return ParamManager; }
- void setKernel(bool _is_kernel=true) { is_kernel = _is_kernel; }
-
-
- void addLocalVarReg(unsigned reg) { reg_local_var.insert(reg); }
-
-
- void doneAddArg(void) {
- _isDoneAddArg = true;
- }
- void doneAddLocalVar(void) {}
-
- bool isKernel() const { return is_kernel; }
-
- typedef DenseSet<unsigned>::const_iterator reg_iterator;
- //typedef DenseSet<unsigned>::const_reverse_iterator reg_reverse_iterator;
- typedef DenseSet<unsigned>::const_iterator ret_iterator;
- typedef std::vector<unsigned>::const_iterator param_iterator;
- typedef SmallVector<unsigned, 8>::const_iterator argparam_iterator;
-
- bool argRegEmpty() const { return reg_arg.empty(); }
- int getNumArg() const { return reg_arg.size(); }
- reg_iterator argRegBegin() const { return reg_arg.begin(); }
- reg_iterator argRegEnd() const { return reg_arg.end(); }
- argparam_iterator argParamBegin() const { return argParams.begin(); }
- argparam_iterator argParamEnd() const { return argParams.end(); }
- //reg_reverse_iterator argRegReverseBegin() const { return reg_arg.rbegin(); }
- //reg_reverse_iterator argRegReverseEnd() const { return reg_arg.rend(); }
-
- bool localVarRegEmpty() const { return reg_local_var.empty(); }
- reg_iterator localVarRegBegin() const { return reg_local_var.begin(); }
- reg_iterator localVarRegEnd() const { return reg_local_var.end(); }
-
- bool retRegEmpty() const { return reg_ret.empty(); }
- int getNumRet() const { return reg_ret.size(); }
- ret_iterator retRegBegin() const { return reg_ret.begin(); }
- ret_iterator retRegEnd() const { return reg_ret.end(); }
-
- param_iterator paramBegin() const { return call_params.begin(); }
- param_iterator paramEnd() const { return call_params.end(); }
- unsigned getNextParam(unsigned size) {
- call_params.push_back(size);
- return call_params.size()-1;
- }
-
- bool isArgReg(unsigned reg) const {
- return std::find(reg_arg.begin(), reg_arg.end(), reg) != reg_arg.end();
- }
-
- /*bool isRetReg(unsigned reg) const {
- return std::find(reg_ret.begin(), reg_ret.end(), reg) != reg_ret.end();
- }*/
-
- bool isLocalVarReg(unsigned reg) const {
- return std::find(reg_local_var.begin(), reg_local_var.end(), reg)
- != reg_local_var.end();
- }
+ /// setKernel/isKernel - Gets/sets a flag that indicates if this function is
+ /// a PTX kernel function.
+ void setKernel(bool _IsKernel=true) { IsKernel = _IsKernel; }
+ bool isKernel() const { return IsKernel; }
+
+ /// argreg_begin/argreg_end - Returns iterators to the set of registers
+ /// containing function arguments.
+ reg_iterator argreg_begin() const { return RegArgs.begin(); }
+ reg_iterator argreg_end() const { return RegArgs.end(); }
+
+ /// retreg_begin/retreg_end - Returns iterators to the set of registers
+ /// containing the function return values.
+ reg_iterator retreg_begin() const { return RegRets.begin(); }
+ reg_iterator retreg_end() const { return RegRets.end(); }
+ /// addRetReg - Adds a register to the set of return-value registers.
void addRetReg(unsigned Reg) {
- if (!reg_ret.count(Reg)) {
- reg_ret.insert(Reg);
+ if (!RegRets.count(Reg)) {
+ RegRets.insert(Reg);
std::string name;
name = "%ret";
- name += utostr(reg_ret.size() - 1);
- regNames[Reg] = name;
+ name += utostr(RegRets.size() - 1);
+ RegNames[Reg] = name;
}
}
- void setRetParamSize(unsigned SizeInBits) {
- retParamSize = SizeInBits;
- }
-
- unsigned getRetParamSize() const {
- return retParamSize;
- }
-
+ /// addArgReg - Adds a register to the set of function argument registers.
void addArgReg(unsigned Reg) {
- reg_arg.insert(Reg);
+ RegArgs.insert(Reg);
std::string name;
name = "%param";
- name += utostr(reg_arg.size() - 1);
- regNames[Reg] = name;
- }
-
- void addArgParam(unsigned SizeInBits) {
- argParams.push_back(SizeInBits);
+ name += utostr(RegArgs.size() - 1);
+ RegNames[Reg] = name;
}
+ /// addVirtualRegister - Adds a virtual register to the set of all used
+ /// registers in the function.
void addVirtualRegister(const TargetRegisterClass *TRC, unsigned Reg) {
std::string name;
- if (!reg_ret.count(Reg) && !reg_arg.count(Reg)) {
- usedRegs[TRC].push_back(Reg);
+ // Do not count registers that are argument/return registers.
+ if (!RegRets.count(Reg) && !RegArgs.count(Reg)) {
+ UsedRegs[TRC].push_back(Reg);
if (TRC == PTX::RegPredRegisterClass)
name = "%p";
else if (TRC == PTX::RegI16RegisterClass)
@@ -174,22 +119,26 @@
else
llvm_unreachable("Invalid register class");
- name += utostr(usedRegs[TRC].size() - 1);
- regNames[Reg] = name;
+ name += utostr(UsedRegs[TRC].size() - 1);
+ RegNames[Reg] = name;
}
}
+ /// getRegisterName - Returns the name of the specified virtual register. This
+ /// name is used during PTX emission.
std::string getRegisterName(unsigned Reg) const {
- if (regNames.count(Reg))
- return regNames.lookup(Reg);
+ if (RegNames.count(Reg))
+ return RegNames.lookup(Reg);
else if (Reg == PTX::NoRegister)
return "%noreg";
else
llvm_unreachable("Register not in register name map");
}
+ /// getNumRegistersForClass - Returns the number of virtual registers that are
+ /// used for the specified register class.
unsigned getNumRegistersForClass(const TargetRegisterClass *TRC) const {
- return usedRegs.lookup(TRC).size();
+ return UsedRegs.lookup(TRC).size();
}
}; // class PTXMachineFunctionInfo
More information about the llvm-commits
mailing list