1 /*
2 * Copyright 2011 Christoph Bumiller
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22
23 #ifndef __NV50_IR_BUILD_UTIL__
24 #define __NV50_IR_BUILD_UTIL__
25
26 namespace nv50_ir {
27
28 class BuildUtil
29 {
30 public:
31 BuildUtil();
32 BuildUtil(Program *);
33
34 inline void setProgram(Program *);
getProgram()35 inline Program *getProgram() const { return prog; }
getFunction()36 inline Function *getFunction() const { return func; }
37
38 // keeps inserting at head/tail of block
39 inline void setPosition(BasicBlock *, bool tail);
40 // position advances only if @after is true
41 inline void setPosition(Instruction *, bool after);
42
getBB()43 inline BasicBlock *getBB() { return bb; }
44
45 inline void insert(Instruction *);
remove(Instruction * i)46 inline void remove(Instruction *i) { assert(i->bb == bb); bb->remove(i); }
47
48 inline LValue *getScratch(int size = 4, DataFile = FILE_GPR);
49 // scratch value for a single assignment:
50 inline LValue *getSSA(int size = 4, DataFile = FILE_GPR);
51
52 inline Instruction *mkOp(operation, DataType, Value *);
53 Instruction *mkOp1(operation, DataType, Value *, Value *);
54 Instruction *mkOp2(operation, DataType, Value *, Value *, Value *);
55 Instruction *mkOp3(operation, DataType, Value *, Value *, Value *, Value *);
56
57 LValue *mkOp1v(operation, DataType, Value *, Value *);
58 LValue *mkOp2v(operation, DataType, Value *, Value *, Value *);
59 LValue *mkOp3v(operation, DataType, Value *, Value *, Value *, Value *);
60
61 Instruction *mkLoad(DataType, Value *dst, Symbol *, Value *ptr);
62 Instruction *mkStore(operation, DataType, Symbol *, Value *ptr, Value *val);
63
64 LValue *mkLoadv(DataType, Symbol *, Value *ptr);
65
66 Instruction *mkMov(Value *, Value *, DataType = TYPE_U32);
67 Instruction *mkMovToReg(int id, Value *);
68 Instruction *mkMovFromReg(Value *, int id);
69
70 Instruction *mkInterp(unsigned mode, Value *, int32_t offset, Value *rel);
71 Instruction *mkFetch(Value *, DataType, DataFile, int32_t offset,
72 Value *attrRel, Value *primRel);
73
74 Instruction *mkCvt(operation, DataType, Value *, DataType, Value *);
75 CmpInstruction *mkCmp(operation, CondCode, DataType,
76 Value *,
77 DataType, Value *, Value *, Value * = NULL);
78 TexInstruction *mkTex(operation, TexTarget,
79 uint16_t tic, uint16_t tsc,
80 const std::vector<Value *> &def,
81 const std::vector<Value *> &src);
82 Instruction *mkQuadop(uint8_t qop, Value *, uint8_t l, Value *, Value *);
83
84 FlowInstruction *mkFlow(operation, void *target, CondCode, Value *pred);
85
86 Instruction *mkSelect(Value *pred, Value *dst, Value *trSrc, Value *flSrc);
87
88 Instruction *mkSplit(Value *half[2], uint8_t halfSize, Value *);
89
90 void mkClobber(DataFile file, uint32_t regMask, int regUnitLog2);
91
92 ImmediateValue *mkImm(float);
93 ImmediateValue *mkImm(double);
94 ImmediateValue *mkImm(uint32_t);
95 ImmediateValue *mkImm(uint64_t);
96
mkImm(int i)97 ImmediateValue *mkImm(int i) { return mkImm((uint32_t)i); }
98
99 Value *loadImm(Value *dst, float);
100 Value *loadImm(Value *dst, double);
101 Value *loadImm(Value *dst, uint32_t);
102 Value *loadImm(Value *dst, uint64_t);
103
loadImm(Value * dst,int i)104 Value *loadImm(Value *dst, int i) { return loadImm(dst, (uint32_t)i); }
105
106 // returns high part of the operation
107 static Instruction *split64BitOpPostRA(Function *, Instruction *,
108 Value *zero, Value *carry);
109
110 struct Location
111 {
LocationLocation112 Location(unsigned array, unsigned arrayIdx, unsigned i, unsigned c)
113 : array(array), arrayIdx(arrayIdx), i(i), c(c) { }
LocationLocation114 Location(const Location &l)
115 : array(l.array), arrayIdx(l.arrayIdx), i(l.i), c(l.c) { }
116
117 bool operator==(const Location &l) const
118 {
119 return
120 array == l.array && arrayIdx == l.arrayIdx && i == l.i && c == l.c;
121 }
122
123 bool operator<(const Location &l) const
124 {
125 return array != l.array ? array < l.array :
126 arrayIdx != l.arrayIdx ? arrayIdx < l.arrayIdx :
127 i != l.i ? i < l.i :
128 c != l.c ? c < l.c :
129 false;
130 }
131
132 unsigned array, arrayIdx, i, c;
133 };
134
135 typedef bimap<Location, Value *> ValueMap;
136
137 class DataArray
138 {
139 public:
DataArray(BuildUtil * bld)140 DataArray(BuildUtil *bld) : up(bld) { }
141
142 void setup(unsigned array, unsigned arrayIdx,
143 uint32_t base, int len, int vecDim, int eltSize,
144 DataFile file, int8_t fileIdx);
145
146 inline bool exists(ValueMap&, unsigned int i, unsigned int c);
147
148 Value *load(ValueMap&, int i, int c, Value *ptr);
149 void store(ValueMap&, int i, int c, Value *ptr, Value *value);
150 Value *acquire(ValueMap&, int i, int c);
151
152 private:
153 inline Value *lookup(ValueMap&, unsigned i, unsigned c);
154 inline Value *insert(ValueMap&, unsigned i, unsigned c, Value *v);
155
156 Symbol *mkSymbol(int i, int c);
157
158 private:
159 BuildUtil *up;
160 unsigned array, arrayIdx;
161
162 uint32_t baseAddr;
163 uint32_t arrayLen;
164 Symbol *baseSym;
165
166 uint8_t vecDim;
167 uint8_t eltSize; // in bytes
168
169 DataFile file;
170 bool regOnly;
171 };
172
173 Symbol *mkSymbol(DataFile file, int8_t fileIndex,
174 DataType ty, uint32_t baseAddress);
175
176 Symbol *mkSysVal(SVSemantic svName, uint32_t svIndex);
177
178 private:
179 void init(Program *);
180 void addImmediate(ImmediateValue *);
181 inline unsigned int u32Hash(uint32_t);
182
183 protected:
184 Program *prog;
185 Function *func;
186 Instruction *pos;
187 BasicBlock *bb;
188 bool tail;
189
190 #define NV50_IR_BUILD_IMM_HT_SIZE 256
191
192 ImmediateValue *imms[NV50_IR_BUILD_IMM_HT_SIZE];
193 unsigned int immCount;
194 };
195
u32Hash(uint32_t u)196 unsigned int BuildUtil::u32Hash(uint32_t u)
197 {
198 return (u % 273) % NV50_IR_BUILD_IMM_HT_SIZE;
199 }
200
setProgram(Program * program)201 void BuildUtil::setProgram(Program *program)
202 {
203 prog = program;
204 }
205
206 void
setPosition(BasicBlock * block,bool atTail)207 BuildUtil::setPosition(BasicBlock *block, bool atTail)
208 {
209 bb = block;
210 prog = bb->getProgram();
211 func = bb->getFunction();
212 pos = NULL;
213 tail = atTail;
214 }
215
216 void
setPosition(Instruction * i,bool after)217 BuildUtil::setPosition(Instruction *i, bool after)
218 {
219 bb = i->bb;
220 prog = bb->getProgram();
221 func = bb->getFunction();
222 pos = i;
223 tail = after;
224 assert(bb);
225 }
226
227 LValue *
getScratch(int size,DataFile f)228 BuildUtil::getScratch(int size, DataFile f)
229 {
230 LValue *lval = new_LValue(func, f);
231 lval->reg.size = size;
232 return lval;
233 }
234
235 LValue *
getSSA(int size,DataFile f)236 BuildUtil::getSSA(int size, DataFile f)
237 {
238 LValue *lval = new_LValue(func, f);
239 lval->ssa = 1;
240 lval->reg.size = size;
241 return lval;
242 }
243
insert(Instruction * i)244 void BuildUtil::insert(Instruction *i)
245 {
246 if (!pos) {
247 tail ? bb->insertTail(i) : bb->insertHead(i);
248 } else {
249 if (tail) {
250 bb->insertAfter(pos, i);
251 pos = i;
252 } else {
253 bb->insertBefore(pos, i);
254 }
255 }
256 }
257
258 Instruction *
mkOp(operation op,DataType ty,Value * dst)259 BuildUtil::mkOp(operation op, DataType ty, Value *dst)
260 {
261 Instruction *insn = new_Instruction(func, op, ty);
262 insn->setDef(0, dst);
263 insert(insn);
264 if (op == OP_DISCARD || op == OP_EXIT ||
265 op == OP_JOIN ||
266 op == OP_QUADON || op == OP_QUADPOP ||
267 op == OP_EMIT || op == OP_RESTART)
268 insn->fixed = 1;
269 return insn;
270 }
271
272 inline LValue *
mkOp1v(operation op,DataType ty,Value * dst,Value * src)273 BuildUtil::mkOp1v(operation op, DataType ty, Value *dst, Value *src)
274 {
275 mkOp1(op, ty, dst, src);
276 return dst->asLValue();
277 }
278
279 inline LValue *
mkOp2v(operation op,DataType ty,Value * dst,Value * src0,Value * src1)280 BuildUtil::mkOp2v(operation op, DataType ty, Value *dst,
281 Value *src0, Value *src1)
282 {
283 mkOp2(op, ty, dst, src0, src1);
284 return dst->asLValue();
285 }
286
287 inline LValue *
mkOp3v(operation op,DataType ty,Value * dst,Value * src0,Value * src1,Value * src2)288 BuildUtil::mkOp3v(operation op, DataType ty, Value *dst,
289 Value *src0, Value *src1, Value *src2)
290 {
291 mkOp3(op, ty, dst, src0, src1, src2);
292 return dst->asLValue();
293 }
294
295 inline LValue *
mkLoadv(DataType ty,Symbol * mem,Value * ptr)296 BuildUtil::mkLoadv(DataType ty, Symbol *mem, Value *ptr)
297 {
298 LValue *dst = getScratch(typeSizeof(ty));
299 mkLoad(ty, dst, mem, ptr);
300 return dst;
301 }
302
303 bool
exists(ValueMap & m,unsigned int i,unsigned int c)304 BuildUtil::DataArray::exists(ValueMap &m, unsigned int i, unsigned int c)
305 {
306 assert(i < arrayLen && c < vecDim);
307 return !regOnly || m.r.count(Location(array, arrayIdx, i, c));
308 }
309
310 Value *
lookup(ValueMap & m,unsigned i,unsigned c)311 BuildUtil::DataArray::lookup(ValueMap &m, unsigned i, unsigned c)
312 {
313 ValueMap::r_iterator it = m.r.find(Location(array, arrayIdx, i, c));
314 return it != m.r.end() ? it->second : NULL;
315 }
316
317 Value *
insert(ValueMap & m,unsigned i,unsigned c,Value * v)318 BuildUtil::DataArray::insert(ValueMap &m, unsigned i, unsigned c, Value *v)
319 {
320 m.insert(Location(array, arrayIdx, i, c), v);
321 return v;
322 }
323
324 } // namespace nv50_ir
325
326 #endif // __NV50_IR_BUILD_UTIL_H__
327