1 //===-- PTXISelLowering.cpp - PTX DAG Lowering Implementation -------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the PTXTargetLowering class.
12 //===----------------------------------------------------------------------===//
15 #include "PTXISelLowering.h"
16 #include "PTXRegisterInfo.h"
17 #include "llvm/Support/ErrorHandling.h"
18 #include "llvm/CodeGen/MachineFunction.h"
19 #include "llvm/CodeGen/MachineRegisterInfo.h"
20 #include "llvm/CodeGen/SelectionDAG.h"
21 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
25 PTXTargetLowering::PTXTargetLowering(TargetMachine &TM)
26 : TargetLowering(TM, new TargetLoweringObjectFileELF()) {
27 // Set up the register classes.
28 addRegisterClass(MVT::i1, PTX::PredsRegisterClass);
29 addRegisterClass(MVT::i32, PTX::RRegs32RegisterClass);
31 // Compute derived properties from the register classes
32 computeRegisterProperties();
35 const char *PTXTargetLowering::getTargetNodeName(unsigned Opcode) const {
37 default: llvm_unreachable("Unknown opcode");
38 case PTXISD::EXIT: return "PTXISD::EXIT";
39 case PTXISD::RET: return "PTXISD::RET";
43 //===----------------------------------------------------------------------===//
44 // Calling Convention Implementation
45 //===----------------------------------------------------------------------===//
47 static struct argmap_entry {
48 MVT::SimpleValueType VT;
49 TargetRegisterClass *RC;
50 TargetRegisterClass::iterator loc;
52 argmap_entry(MVT::SimpleValueType _VT, TargetRegisterClass *_RC)
53 : VT(_VT), RC(_RC), loc(_RC->begin()) {}
55 void reset(void) { loc = RC->begin(); }
56 bool operator==(MVT::SimpleValueType _VT) { return VT == _VT; }
58 argmap_entry(MVT::i1, PTX::PredsRegisterClass),
59 argmap_entry(MVT::i32, PTX::RRegs32RegisterClass)
62 static SDValue lower_kernel_argument(int i,
65 MVT::SimpleValueType VT,
70 llvm_unreachable("Not implemented yet");
73 static SDValue lower_device_argument(int i,
76 MVT::SimpleValueType VT,
80 MachineRegisterInfo &RegInfo = DAG.getMachineFunction().getRegInfo();
82 unsigned preg = *++(entry->loc); // allocate start from register 1
83 unsigned vreg = RegInfo.createVirtualRegister(entry->RC);
84 RegInfo.addLiveIn(preg, vreg);
87 return DAG.getCopyFromReg(Chain, dl, vreg, VT);
90 typedef SDValue (*lower_argument_func)(int i,
93 MVT::SimpleValueType VT,
98 SDValue PTXTargetLowering::
99 LowerFormalArguments(SDValue Chain,
100 CallingConv::ID CallConv,
102 const SmallVectorImpl<ISD::InputArg> &Ins,
105 SmallVectorImpl<SDValue> &InVals) const {
106 if (isVarArg) llvm_unreachable("PTX does not support varargs");
108 lower_argument_func lower_argument;
112 llvm_unreachable("Unsupported calling convention");
114 case CallingConv::PTX_Kernel:
115 lower_argument = lower_kernel_argument;
117 case CallingConv::PTX_Device:
118 lower_argument = lower_device_argument;
122 // Reset argmap before allocation
123 for (struct argmap_entry *i = argmap, *e = argmap + array_lengthof(argmap);
127 for (int i = 0, e = Ins.size(); i != e; ++ i) {
128 MVT::SimpleValueType VT = Ins[i].VT.getSimpleVT().SimpleTy;
130 struct argmap_entry *entry = std::find(argmap,
131 argmap + array_lengthof(argmap), VT);
132 if (entry == argmap + array_lengthof(argmap))
133 llvm_unreachable("Type of argument is not supported");
136 SDValue arg = lower_argument(i, Chain, dl, VT, entry, DAG, ®);
137 InVals.push_back(arg);
143 SDValue PTXTargetLowering::
144 LowerReturn(SDValue Chain,
145 CallingConv::ID CallConv,
147 const SmallVectorImpl<ISD::OutputArg> &Outs,
148 const SmallVectorImpl<SDValue> &OutVals,
150 SelectionDAG &DAG) const {
151 if (isVarArg) llvm_unreachable("PTX does not support varargs");
155 llvm_unreachable("Unsupported calling convention.");
156 case CallingConv::PTX_Kernel:
157 assert(Outs.size() == 0 && "Kernel must return void.");
158 return DAG.getNode(PTXISD::EXIT, dl, MVT::Other, Chain);
159 case CallingConv::PTX_Device:
160 assert(Outs.size() <= 1 && "Can at most return one value.");
167 if (Outs.size() == 0)
168 return DAG.getNode(PTXISD::RET, dl, MVT::Other, Chain);
170 assert(Outs[0].VT == MVT::i32 && "Can return only basic types");
173 unsigned reg = PTX::R0;
175 // If this is the first return lowered for this function, add the regs to the
176 // liveout set for the function
177 if (DAG.getMachineFunction().getRegInfo().liveout_empty())
178 DAG.getMachineFunction().getRegInfo().addLiveOut(reg);
180 // Copy the result values into the output registers
181 Chain = DAG.getCopyToReg(Chain, dl, reg, OutVals[0], Flag);
183 // Guarantee that all emitted copies are stuck together,
184 // avoiding something bad
185 Flag = Chain.getValue(1);
187 return DAG.getNode(PTXISD::RET, dl, MVT::Other, Chain, Flag);