src/gallium/drivers/nouveau/codegen/nv50_ir_build_util.h

   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 *);
  35    inline Program *getProgram() const { return prog; }
  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
  43    inline BasicBlock *getBB() { return bb; }
  44
  45    inline void insert(Instruction *);
  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
  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
 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    {
 112       Location(unsigned array, unsigned arrayIdx, unsigned i, unsigned c)
 113          : array(array), arrayIdx(arrayIdx), i(i), c(c) { }
 114       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:
 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
 196 unsigned int BuildUtil::u32Hash(uint32_t u)
 197 {
 198    return (u % 273) % NV50_IR_BUILD_IMM_HT_SIZE;
 199 }
 200
 201 void BuildUtil::setProgram(Program *program)
 202 {
 203    prog = program;
 204 }
 205
 206 void
 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
 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 *
 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 *
 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
 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 *
 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 *
 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 *
 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 *
 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 *
 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
 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 *
 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 *
 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__