+++ /dev/null
-
-#include "nv50_ir.h"
-#include "nv50_ir_target.h"
-#include "nv50_ir_build_util.h"
-
-#include "nv50_ir_from_sm4.h"
-
-// WTF: pass-through is implicit ??? check ReadWriteMask
-
-namespace tgsi {
-
-static nv50_ir::SVSemantic irSemantic(unsigned sn)
-{
- switch (sn) {
- case TGSI_SEMANTIC_POSITION: return nv50_ir::SV_POSITION;
- case TGSI_SEMANTIC_FACE: return nv50_ir::SV_FACE;
- case NV50_SEMANTIC_LAYER: return nv50_ir::SV_LAYER;
- case NV50_SEMANTIC_VIEWPORTINDEX: return nv50_ir::SV_VIEWPORT_INDEX;
- case TGSI_SEMANTIC_PSIZE: return nv50_ir::SV_POINT_SIZE;
- case NV50_SEMANTIC_CLIPDISTANCE: return nv50_ir::SV_CLIP_DISTANCE;
- case TGSI_SEMANTIC_VERTEXID: return nv50_ir::SV_VERTEX_ID;
- case TGSI_SEMANTIC_INSTANCEID: return nv50_ir::SV_INSTANCE_ID;
- case TGSI_SEMANTIC_PRIMID: return nv50_ir::SV_PRIMITIVE_ID;
- case NV50_SEMANTIC_TESSFACTOR: return nv50_ir::SV_TESS_FACTOR;
- case NV50_SEMANTIC_TESSCOORD: return nv50_ir::SV_TESS_COORD;
- default:
- return nv50_ir::SV_UNDEFINED;
- }
-}
-
-} // namespace tgsi
-
-namespace {
-
-using namespace nv50_ir;
-
-#define NV50_IR_MAX_RESOURCES 64
-
-class Converter : public BuildUtil
-{
-public:
- Converter(Program *, struct nv50_ir_prog_info *);
- ~Converter();
-
-private:
- DataArray tData32;
- DataArray tData64;
- unsigned int nrRegVals;
-
- DataArray *lData;
- unsigned int nrArrays;
- unsigned int arrayVol;
-
- DataArray oData;
-
- uint8_t interpMode[PIPE_MAX_SHADER_INPUTS];
-
- // outputs for each phase
- struct nv50_ir_varying out[3][PIPE_MAX_SHADER_OUTPUTS];
-
- int phase;
- int subPhaseCnt[2];
- int subPhase;
- unsigned int phaseStart;
- unsigned int phaseInstance;
- unsigned int *phaseInstCnt[2];
- bool unrollPhase;
- bool phaseInstanceUsed;
- int phaseEnded; // (phase + 1) if $phase ended
-
- bool finalized;
-
- Value *srcPtr[3][3]; // for indirect addressing, save pointer values
- Value *dstPtr[3];
- Value *vtxBase[3]; // base address of vertex in a primitive (TP/GP)
-
- Value *domainPt[3]; // pre-fetched TessCoord
-
- unsigned int nDstOpnds;
-
- Stack condBBs;
- Stack joinBBs;
- Stack loopBBs;
- Stack breakBBs;
- Stack entryBBs;
- Stack leaveBBs;
- Stack retIPs;
-
- bool shadow[NV50_IR_MAX_RESOURCES];
- TexTarget resourceType[NV50_IR_MAX_RESOURCES][2];
-
- struct nv50_ir_prog_info& info;
-
- Value *fragCoord[4];
-
-public:
- bool run();
-
-private:
- bool handleInstruction(unsigned int pos);
- bool inspectInstruction(unsigned int pos);
- bool handleDeclaration(const sm4_dcl& dcl);
- bool inspectDeclaration(const sm4_dcl& dcl);
- bool parseSignature();
-
- bool haveNextPhase(unsigned int pos) const;
-
- void allocateValues();
- void exportOutputs();
-
- void emitTex(Value *dst0[4], TexInstruction *, const uint8_t swizzle[4]);
- void handleLOAD(Value *dst0[4]);
- void handleSAMPLE(operation, Value *dst0[4]);
- void handleQUERY(Value *dst0[4], enum TexQuery query);
- void handleDP(Value *dst0[4], int dim);
-
- Symbol *iSym(int i, int c);
- Symbol *oSym(int i, int c);
-
- Value *src(int i, int c);
- Value *src(const sm4_op&, int c, int i);
- Value *dst(int i, int c);
- Value *dst(const sm4_op&, int c, int i);
- void saveDst(int i, int c, Value *value);
- void saveDst(const sm4_op&, int c, Value *value, int i);
- void saveFragDepth(operation op, Value *value);
-
- Value *interpolate(const sm4_op&, int c, int i);
-
- Value *getSrcPtr(int s, int dim, int shl);
- Value *getDstPtr(int d, int dim, int shl);
- Value *getVtxPtr(int s);
-
- bool checkDstSrcAliasing() const;
- void insertConvergenceOps(BasicBlock *conv, BasicBlock *fork);
- void finalizeShader();
-
- operation cvtOpcode(enum sm4_opcode op) const;
- unsigned int getDstOpndCount(enum sm4_opcode opcode) const;
-
- DataType inferSrcType(enum sm4_opcode op) const;
- DataType inferDstType(enum sm4_opcode op) const;
-
- unsigned g3dPrim(const unsigned prim, unsigned *patchSize = NULL) const;
- CondCode cvtCondCode(enum sm4_opcode op) const;
- RoundMode cvtRoundingMode(enum sm4_opcode op) const;
- TexTarget cvtTexTarget(enum sm4_target,
- enum sm4_opcode, operation *) const;
- SVSemantic cvtSemantic(enum sm4_sv, uint8_t &index) const;
- uint8_t cvtInterpMode(enum sm4_interpolation) const;
-
- unsigned tgsiSemantic(SVSemantic, int index);
- void recordSV(unsigned sn, unsigned si, unsigned mask, bool input);
-
-private:
- sm4_insn *insn;
- DataType dTy, sTy;
-
- const struct sm4_program& sm4;
- Program *prog;
-};
-
-#define PRIM_CASE(a, b) \
- case D3D_PRIMITIVE_TOPOLOGY_##a: return PIPE_PRIM_##b;
-
-unsigned
-Converter::g3dPrim(const unsigned prim, unsigned *patchSize) const
-{
- switch (prim) {
- PRIM_CASE(UNDEFINED, POINTS);
- PRIM_CASE(POINTLIST, POINTS);
- PRIM_CASE(LINELIST, LINES);
- PRIM_CASE(LINESTRIP, LINE_STRIP);
- PRIM_CASE(TRIANGLELIST, TRIANGLES);
- PRIM_CASE(TRIANGLESTRIP, TRIANGLE_STRIP);
- PRIM_CASE(LINELIST_ADJ, LINES_ADJACENCY);
- PRIM_CASE(LINESTRIP_ADJ, LINE_STRIP_ADJACENCY);
- PRIM_CASE(TRIANGLELIST_ADJ, TRIANGLES_ADJACENCY);
- PRIM_CASE(TRIANGLESTRIP_ADJ, TRIANGLES_ADJACENCY);
- default:
- if (prim < D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST ||
- prim > D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST)
- return PIPE_PRIM_POINTS;
- if (patchSize)
- *patchSize =
- prim - D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST + 1;
- return NV50_PRIM_PATCHES;
- }
-}
-
-#define IPM_CASE(n, a, b) \
- case SM4_INTERPOLATION_##n: return NV50_IR_INTERP_##a | NV50_IR_INTERP_##b
-
-uint8_t
-Converter::cvtInterpMode(enum sm4_interpolation mode) const
-{
- switch (mode) {
- IPM_CASE(CONSTANT, FLAT, FLAT);
- IPM_CASE(LINEAR, PERSPECTIVE, PERSPECTIVE);
- IPM_CASE(LINEAR_CENTROID, PERSPECTIVE, CENTROID);
- IPM_CASE(LINEAR_NOPERSPECTIVE, LINEAR, LINEAR);
- IPM_CASE(LINEAR_NOPERSPECTIVE_CENTROID, LINEAR, CENTROID);
- IPM_CASE(LINEAR_SAMPLE, PERSPECTIVE, OFFSET);
- IPM_CASE(LINEAR_NOPERSPECTIVE_SAMPLE, LINEAR, OFFSET);
- IPM_CASE(UNDEFINED, LINEAR, LINEAR);
- default:
- assert(!"invalid interpolation mode");
- return 0;
- }
-}
-
-static void
-setVaryingInterpMode(struct nv50_ir_varying *var, uint8_t mode)
-{
- switch (mode & NV50_IR_INTERP_MODE_MASK) {
- case NV50_IR_INTERP_LINEAR:
- var->linear = 1;
- break;
- case NV50_IR_INTERP_FLAT:
- var->flat = 1;
- break;
- default:
- break;
- }
- if (mode & NV50_IR_INTERP_CENTROID)
- var->centroid = 1;
-}
-
-RoundMode
-Converter::cvtRoundingMode(enum sm4_opcode op) const
-{
- switch (op) {
- case SM4_OPCODE_ROUND_NE: return ROUND_NI;
- case SM4_OPCODE_ROUND_NI: return ROUND_MI;
- case SM4_OPCODE_ROUND_PI: return ROUND_PI;
- case SM4_OPCODE_ROUND_Z: return ROUND_ZI;
- default:
- return ROUND_N;
- }
-}
-
-CondCode
-Converter::cvtCondCode(enum sm4_opcode op) const
-{
- switch (op) {
- case SM4_OPCODE_EQ:
- case SM4_OPCODE_DEQ:
- case SM4_OPCODE_IEQ: return CC_EQ;
- case SM4_OPCODE_GE:
- case SM4_OPCODE_DGE:
- case SM4_OPCODE_IGE:
- case SM4_OPCODE_UGE: return CC_GE;
- case SM4_OPCODE_LT:
- case SM4_OPCODE_DLT:
- case SM4_OPCODE_ILT:
- case SM4_OPCODE_ULT: return CC_LT;
- case SM4_OPCODE_NE:
- case SM4_OPCODE_INE:
- case SM4_OPCODE_DNE: return CC_NEU;
- default:
- return CC_ALWAYS;
- }
-}
-
-DataType
-Converter::inferSrcType(enum sm4_opcode op) const
-{
- switch (op) {
- case SM4_OPCODE_IADD:
- case SM4_OPCODE_IEQ:
- case SM4_OPCODE_IGE:
- case SM4_OPCODE_ILT:
- case SM4_OPCODE_IMAD:
- case SM4_OPCODE_IMAX:
- case SM4_OPCODE_IMIN:
- case SM4_OPCODE_IMUL:
- case SM4_OPCODE_INE:
- case SM4_OPCODE_INEG:
- case SM4_OPCODE_ISHL:
- case SM4_OPCODE_ISHR:
- case SM4_OPCODE_ITOF:
- case SM4_OPCODE_ATOMIC_IADD:
- case SM4_OPCODE_ATOMIC_IMAX:
- case SM4_OPCODE_ATOMIC_IMIN:
- return TYPE_S32;
- case SM4_OPCODE_AND:
- case SM4_OPCODE_NOT:
- case SM4_OPCODE_OR:
- case SM4_OPCODE_UDIV:
- case SM4_OPCODE_ULT:
- case SM4_OPCODE_UGE:
- case SM4_OPCODE_UMUL:
- case SM4_OPCODE_UMAD:
- case SM4_OPCODE_UMAX:
- case SM4_OPCODE_UMIN:
- case SM4_OPCODE_USHR:
- case SM4_OPCODE_UTOF:
- case SM4_OPCODE_XOR:
- case SM4_OPCODE_UADDC:
- case SM4_OPCODE_USUBB:
- case SM4_OPCODE_ATOMIC_AND:
- case SM4_OPCODE_ATOMIC_OR:
- case SM4_OPCODE_ATOMIC_XOR:
- case SM4_OPCODE_ATOMIC_UMAX:
- case SM4_OPCODE_ATOMIC_UMIN:
- return TYPE_U32;
- case SM4_OPCODE_DADD:
- case SM4_OPCODE_DMAX:
- case SM4_OPCODE_DMIN:
- case SM4_OPCODE_DMUL:
- case SM4_OPCODE_DEQ:
- case SM4_OPCODE_DGE:
- case SM4_OPCODE_DLT:
- case SM4_OPCODE_DNE:
- case SM4_OPCODE_DMOV:
- case SM4_OPCODE_DMOVC:
- case SM4_OPCODE_DTOF:
- return TYPE_F64;
- case SM4_OPCODE_F16TOF32:
- return TYPE_F16;
- default:
- return TYPE_F32;
- }
-}
-
-DataType
-Converter::inferDstType(enum sm4_opcode op) const
-{
- switch (op) {
- case SM4_OPCODE_FTOI:
- return TYPE_S32;
- case SM4_OPCODE_FTOU:
- case SM4_OPCODE_EQ:
- case SM4_OPCODE_GE:
- case SM4_OPCODE_LT:
- case SM4_OPCODE_NE:
- return TYPE_U32;
- case SM4_OPCODE_FTOD:
- return TYPE_F64;
- case SM4_OPCODE_F32TOF16:
- return TYPE_F16;
- case SM4_OPCODE_ITOF:
- case SM4_OPCODE_UTOF:
- case SM4_OPCODE_DTOF:
- return TYPE_F32;
- default:
- return inferSrcType(op);
- }
-}
-
-operation
-Converter::cvtOpcode(enum sm4_opcode op) const
-{
- switch (op) {
- case SM4_OPCODE_ADD: return OP_ADD;
- case SM4_OPCODE_AND: return OP_AND;
- case SM4_OPCODE_BREAK: return OP_BREAK;
- case SM4_OPCODE_BREAKC: return OP_BREAK;
- case SM4_OPCODE_CALL: return OP_CALL;
- case SM4_OPCODE_CALLC: return OP_CALL;
- case SM4_OPCODE_CASE: return OP_NOP;
- case SM4_OPCODE_CONTINUE: return OP_CONT;
- case SM4_OPCODE_CONTINUEC: return OP_CONT;
- case SM4_OPCODE_CUT: return OP_RESTART;
- case SM4_OPCODE_DEFAULT: return OP_NOP;
- case SM4_OPCODE_DERIV_RTX: return OP_DFDX;
- case SM4_OPCODE_DERIV_RTY: return OP_DFDY;
- case SM4_OPCODE_DISCARD: return OP_DISCARD;
- case SM4_OPCODE_DIV: return OP_DIV;
- case SM4_OPCODE_DP2: return OP_MAD;
- case SM4_OPCODE_DP3: return OP_MAD;
- case SM4_OPCODE_DP4: return OP_MAD;
- case SM4_OPCODE_ELSE: return OP_BRA;
- case SM4_OPCODE_EMIT: return OP_EMIT;
- case SM4_OPCODE_EMITTHENCUT: return OP_EMIT;
- case SM4_OPCODE_ENDIF: return OP_BRA;
- case SM4_OPCODE_ENDLOOP: return OP_PREBREAK;
- case SM4_OPCODE_ENDSWITCH: return OP_NOP;
- case SM4_OPCODE_EQ: return OP_SET;
- case SM4_OPCODE_EXP: return OP_EX2;
- case SM4_OPCODE_FRC: return OP_CVT;
- case SM4_OPCODE_FTOI: return OP_CVT;
- case SM4_OPCODE_FTOU: return OP_CVT;
- case SM4_OPCODE_GE: return OP_SET;
- case SM4_OPCODE_IADD: return OP_ADD;
- case SM4_OPCODE_IF: return OP_BRA;
- case SM4_OPCODE_IEQ: return OP_SET;
- case SM4_OPCODE_IGE: return OP_SET;
- case SM4_OPCODE_ILT: return OP_SET;
- case SM4_OPCODE_IMAD: return OP_MAD;
- case SM4_OPCODE_IMAX: return OP_MAX;
- case SM4_OPCODE_IMIN: return OP_MIN;
- case SM4_OPCODE_IMUL: return OP_MUL;
- case SM4_OPCODE_INE: return OP_SET;
- case SM4_OPCODE_INEG: return OP_NEG;
- case SM4_OPCODE_ISHL: return OP_SHL;
- case SM4_OPCODE_ISHR: return OP_SHR;
- case SM4_OPCODE_ITOF: return OP_CVT;
- case SM4_OPCODE_LD: return OP_TXF;
- case SM4_OPCODE_LD_MS: return OP_TXF;
- case SM4_OPCODE_LOG: return OP_LG2;
- case SM4_OPCODE_LOOP: return OP_PRECONT;
- case SM4_OPCODE_LT: return OP_SET;
- case SM4_OPCODE_MAD: return OP_MAD;
- case SM4_OPCODE_MIN: return OP_MIN;
- case SM4_OPCODE_MAX: return OP_MAX;
- case SM4_OPCODE_MOV: return OP_MOV;
- case SM4_OPCODE_MOVC: return OP_MOV;
- case SM4_OPCODE_MUL: return OP_MUL;
- case SM4_OPCODE_NE: return OP_SET;
- case SM4_OPCODE_NOP: return OP_NOP;
- case SM4_OPCODE_NOT: return OP_NOT;
- case SM4_OPCODE_OR: return OP_OR;
- case SM4_OPCODE_RESINFO: return OP_TXQ;
- case SM4_OPCODE_RET: return OP_RET;
- case SM4_OPCODE_RETC: return OP_RET;
- case SM4_OPCODE_ROUND_NE: return OP_CVT;
- case SM4_OPCODE_ROUND_NI: return OP_FLOOR;
- case SM4_OPCODE_ROUND_PI: return OP_CEIL;
- case SM4_OPCODE_ROUND_Z: return OP_TRUNC;
- case SM4_OPCODE_RSQ: return OP_RSQ;
- case SM4_OPCODE_SAMPLE: return OP_TEX;
- case SM4_OPCODE_SAMPLE_C: return OP_TEX;
- case SM4_OPCODE_SAMPLE_C_LZ: return OP_TEX;
- case SM4_OPCODE_SAMPLE_L: return OP_TXL;
- case SM4_OPCODE_SAMPLE_D: return OP_TXD;
- case SM4_OPCODE_SAMPLE_B: return OP_TXB;
- case SM4_OPCODE_SQRT: return OP_SQRT;
- case SM4_OPCODE_SWITCH: return OP_NOP;
- case SM4_OPCODE_SINCOS: return OP_PRESIN;
- case SM4_OPCODE_UDIV: return OP_DIV;
- case SM4_OPCODE_ULT: return OP_SET;
- case SM4_OPCODE_UGE: return OP_SET;
- case SM4_OPCODE_UMUL: return OP_MUL;
- case SM4_OPCODE_UMAD: return OP_MAD;
- case SM4_OPCODE_UMAX: return OP_MAX;
- case SM4_OPCODE_UMIN: return OP_MIN;
- case SM4_OPCODE_USHR: return OP_SHR;
- case SM4_OPCODE_UTOF: return OP_CVT;
- case SM4_OPCODE_XOR: return OP_XOR;
-
- case SM4_OPCODE_GATHER4: return OP_TXG;
- case SM4_OPCODE_SAMPLE_POS: return OP_PIXLD;
- case SM4_OPCODE_SAMPLE_INFO: return OP_PIXLD;
- case SM4_OPCODE_EMIT_STREAM: return OP_EMIT;
- case SM4_OPCODE_CUT_STREAM: return OP_RESTART;
- case SM4_OPCODE_EMITTHENCUT_STREAM: return OP_EMIT;
- case SM4_OPCODE_INTERFACE_CALL: return OP_CALL;
- case SM4_OPCODE_BUFINFO: return OP_TXQ;
- case SM4_OPCODE_DERIV_RTX_COARSE: return OP_DFDX;
- case SM4_OPCODE_DERIV_RTX_FINE: return OP_DFDX;
- case SM4_OPCODE_DERIV_RTY_COARSE: return OP_DFDY;
- case SM4_OPCODE_DERIV_RTY_FINE: return OP_DFDY;
- case SM4_OPCODE_GATHER4_C: return OP_TXG;
- case SM4_OPCODE_GATHER4_PO: return OP_TXG;
- case SM4_OPCODE_GATHER4_PO_C: return OP_TXG;
-
- case SM4_OPCODE_RCP: return OP_RCP;
- case SM4_OPCODE_F32TOF16: return OP_CVT;
- case SM4_OPCODE_F16TOF32: return OP_CVT;
- case SM4_OPCODE_UADDC: return OP_ADD;
- case SM4_OPCODE_USUBB: return OP_SUB;
- case SM4_OPCODE_COUNTBITS: return OP_POPCNT;
-
- case SM4_OPCODE_ATOMIC_AND: return OP_AND;
- case SM4_OPCODE_ATOMIC_OR: return OP_OR;
- case SM4_OPCODE_ATOMIC_XOR: return OP_XOR;
- case SM4_OPCODE_ATOMIC_CMP_STORE: return OP_STORE;
- case SM4_OPCODE_ATOMIC_IADD: return OP_ADD;
- case SM4_OPCODE_ATOMIC_IMAX: return OP_MAX;
- case SM4_OPCODE_ATOMIC_IMIN: return OP_MIN;
- case SM4_OPCODE_ATOMIC_UMAX: return OP_MAX;
- case SM4_OPCODE_ATOMIC_UMIN: return OP_MIN;
-
- case SM4_OPCODE_SYNC: return OP_MEMBAR;
- case SM4_OPCODE_DADD: return OP_ADD;
- case SM4_OPCODE_DMAX: return OP_MAX;
- case SM4_OPCODE_DMIN: return OP_MIN;
- case SM4_OPCODE_DMUL: return OP_MUL;
- case SM4_OPCODE_DEQ: return OP_SET;
- case SM4_OPCODE_DGE: return OP_SET;
- case SM4_OPCODE_DLT: return OP_SET;
- case SM4_OPCODE_DNE: return OP_SET;
- case SM4_OPCODE_DMOV: return OP_MOV;
- case SM4_OPCODE_DMOVC: return OP_MOV;
- case SM4_OPCODE_DTOF: return OP_CVT;
- case SM4_OPCODE_FTOD: return OP_CVT;
-
- default:
- return OP_NOP;
- }
-}
-
-unsigned int
-Converter::getDstOpndCount(enum sm4_opcode opcode) const
-{
- switch (opcode) {
- case SM4_OPCODE_SINCOS:
- case SM4_OPCODE_UDIV:
- case SM4_OPCODE_IMUL:
- case SM4_OPCODE_UMUL:
- return 2;
- case SM4_OPCODE_BREAK:
- case SM4_OPCODE_BREAKC:
- case SM4_OPCODE_CALL:
- case SM4_OPCODE_CALLC:
- case SM4_OPCODE_CONTINUE:
- case SM4_OPCODE_CONTINUEC:
- case SM4_OPCODE_DISCARD:
- case SM4_OPCODE_EMIT:
- case SM4_OPCODE_EMIT_STREAM:
- case SM4_OPCODE_CUT:
- case SM4_OPCODE_CUT_STREAM:
- case SM4_OPCODE_EMITTHENCUT:
- case SM4_OPCODE_EMITTHENCUT_STREAM:
- case SM4_OPCODE_IF:
- case SM4_OPCODE_ELSE:
- case SM4_OPCODE_ENDIF:
- case SM4_OPCODE_LOOP:
- case SM4_OPCODE_ENDLOOP:
- case SM4_OPCODE_RET:
- case SM4_OPCODE_RETC:
- case SM4_OPCODE_SYNC:
- case SM4_OPCODE_SWITCH:
- case SM4_OPCODE_CASE:
- case SM4_OPCODE_HS_DECLS:
- case SM4_OPCODE_HS_CONTROL_POINT_PHASE:
- case SM4_OPCODE_HS_FORK_PHASE:
- case SM4_OPCODE_HS_JOIN_PHASE:
- return 0;
- default:
- return 1;
- }
-}
-
-#define TARG_CASE_1(a, b) case SM4_TARGET_##a: return TEX_TARGET_##b;
-#define TARG_CASE_2(a, b) case SM4_TARGET_##a: \
- return dc ? TEX_TARGET_##b##_SHADOW : TEX_TARGET_##b
-
-TexTarget
-Converter::cvtTexTarget(enum sm4_target targ,
- enum sm4_opcode op, operation *opr) const
-{
- bool dc = (op == SM4_OPCODE_SAMPLE_C ||
- op == SM4_OPCODE_SAMPLE_C_LZ ||
- op == SM4_OPCODE_GATHER4_C ||
- op == SM4_OPCODE_GATHER4_PO_C);
-
- if (opr) {
- switch (targ) {
- case SM4_TARGET_RAW_BUFFER: *opr = OP_LOAD; break;
- case SM4_TARGET_STRUCTURED_BUFFER: *opr = OP_SULD; break;
- default:
- *opr = OP_TEX;
- break;
- }
- }
-
- switch (targ) {
- TARG_CASE_1(UNKNOWN, 2D);
- TARG_CASE_2(TEXTURE1D, 1D);
- TARG_CASE_2(TEXTURE2D, 2D);
- TARG_CASE_1(TEXTURE2DMS, 2D_MS);
- TARG_CASE_1(TEXTURE3D, 3D);
- TARG_CASE_2(TEXTURECUBE, CUBE);
- TARG_CASE_2(TEXTURE1DARRAY, 1D_ARRAY);
- TARG_CASE_2(TEXTURE2DARRAY, 2D_ARRAY);
- TARG_CASE_1(TEXTURE2DMSARRAY, 2D_MS_ARRAY);
- TARG_CASE_2(TEXTURECUBEARRAY, CUBE_ARRAY);
- TARG_CASE_1(BUFFER, BUFFER);
- TARG_CASE_1(RAW_BUFFER, BUFFER);
- TARG_CASE_1(STRUCTURED_BUFFER, BUFFER);
- default:
- assert(!"invalid SM4 texture target");
- return dc ? TEX_TARGET_2D_SHADOW : TEX_TARGET_2D;
- }
-}
-
-static inline uint32_t
-getSVIndex(enum sm4_sv sv)
-{
- switch (sv) {
- case SM4_SV_FINAL_QUAD_U_EQ_0_EDGE_TESSFACTOR: return 0;
- case SM4_SV_FINAL_QUAD_V_EQ_0_EDGE_TESSFACTOR: return 1;
- case SM4_SV_FINAL_QUAD_U_EQ_1_EDGE_TESSFACTOR: return 2;
- case SM4_SV_FINAL_QUAD_V_EQ_1_EDGE_TESSFACTOR: return 3;
-
- case SM4_SV_FINAL_QUAD_U_INSIDE_TESSFACTOR: return 4;
- case SM4_SV_FINAL_QUAD_V_INSIDE_TESSFACTOR: return 5;
-
- case SM4_SV_FINAL_TRI_U_EQ_0_EDGE_TESSFACTOR: return 0;
- case SM4_SV_FINAL_TRI_V_EQ_0_EDGE_TESSFACTOR: return 1;
- case SM4_SV_FINAL_TRI_W_EQ_0_EDGE_TESSFACTOR: return 2;
-
- case SM4_SV_FINAL_TRI_INSIDE_TESSFACTOR: return 4;
-
- case SM4_SV_FINAL_LINE_DETAIL_TESSFACTOR: return 0;
-
- case SM4_SV_FINAL_LINE_DENSITY_TESSFACTOR: return 4;
-
- default:
- return 0;
- }
-}
-
-SVSemantic
-Converter::cvtSemantic(enum sm4_sv sv, uint8_t &idx) const
-{
- idx = 0;
-
- switch (sv) {
- case SM4_SV_UNDEFINED: return SV_UNDEFINED;
- case SM4_SV_POSITION: return SV_POSITION;
- case SM4_SV_CLIP_DISTANCE: return SV_CLIP_DISTANCE;
- case SM4_SV_CULL_DISTANCE: return SV_CLIP_DISTANCE; // XXX: distinction
- case SM4_SV_RENDER_TARGET_ARRAY_INDEX: return SV_LAYER;
- case SM4_SV_VIEWPORT_ARRAY_INDEX: return SV_VIEWPORT_INDEX;
- case SM4_SV_VERTEX_ID: return SV_VERTEX_ID;
- case SM4_SV_PRIMITIVE_ID: return SV_PRIMITIVE_ID;
- case SM4_SV_INSTANCE_ID: return SV_INSTANCE_ID;
- case SM4_SV_IS_FRONT_FACE: return SV_FACE;
- case SM4_SV_SAMPLE_INDEX: return SV_SAMPLE_INDEX;
-
- case SM4_SV_FINAL_QUAD_U_EQ_0_EDGE_TESSFACTOR:
- case SM4_SV_FINAL_QUAD_V_EQ_0_EDGE_TESSFACTOR:
- case SM4_SV_FINAL_QUAD_U_EQ_1_EDGE_TESSFACTOR:
- case SM4_SV_FINAL_QUAD_V_EQ_1_EDGE_TESSFACTOR:
- case SM4_SV_FINAL_QUAD_U_INSIDE_TESSFACTOR:
- case SM4_SV_FINAL_QUAD_V_INSIDE_TESSFACTOR:
- case SM4_SV_FINAL_TRI_U_EQ_0_EDGE_TESSFACTOR:
- case SM4_SV_FINAL_TRI_V_EQ_0_EDGE_TESSFACTOR:
- case SM4_SV_FINAL_TRI_W_EQ_0_EDGE_TESSFACTOR:
- case SM4_SV_FINAL_TRI_INSIDE_TESSFACTOR:
- case SM4_SV_FINAL_LINE_DETAIL_TESSFACTOR:
- case SM4_SV_FINAL_LINE_DENSITY_TESSFACTOR:
- idx = getSVIndex(sv);
- return SV_TESS_FACTOR;
-
- default:
- assert(!"invalid SM4 system value");
- return SV_UNDEFINED;
- }
-}
-
-unsigned
-Converter::tgsiSemantic(SVSemantic sv, int index)
-{
- switch (sv) {
- case SV_POSITION: return TGSI_SEMANTIC_POSITION;
- case SV_FACE: return TGSI_SEMANTIC_FACE;
- case SV_LAYER: return NV50_SEMANTIC_LAYER;
- case SV_VIEWPORT_INDEX: return NV50_SEMANTIC_VIEWPORTINDEX;
- case SV_POINT_SIZE: return TGSI_SEMANTIC_PSIZE;
- case SV_CLIP_DISTANCE: return NV50_SEMANTIC_CLIPDISTANCE;
- case SV_VERTEX_ID: return TGSI_SEMANTIC_VERTEXID;
- case SV_INSTANCE_ID: return TGSI_SEMANTIC_INSTANCEID;
- case SV_PRIMITIVE_ID: return TGSI_SEMANTIC_PRIMID;
- case SV_TESS_FACTOR: return NV50_SEMANTIC_TESSFACTOR;
- case SV_TESS_COORD: return NV50_SEMANTIC_TESSCOORD;
- case SV_INVOCATION_ID: return NV50_SEMANTIC_INVOCATIONID;
- default:
- return TGSI_SEMANTIC_GENERIC;
- }
-}
-
-void
-Converter::recordSV(unsigned sn, unsigned si, unsigned mask, bool input)
-{
- unsigned int i;
- for (i = 0; i < info.numSysVals; ++i)
- if (info.sv[i].sn == sn &&
- info.sv[i].si == si)
- return;
- info.numSysVals = i + 1;
- info.sv[i].sn = sn;
- info.sv[i].si = si;
- info.sv[i].mask = mask;
- info.sv[i].input = input ? 1 : 0;
-}
-
-bool
-Converter::parseSignature()
-{
- struct nv50_ir_varying *patch;
- unsigned int i, r, n;
-
- info.numInputs = 0;
- info.numOutputs = 0;
- info.numPatchConstants = 0;
-
- for (n = 0, i = 0; i < sm4.num_params_in; ++i) {
- r = sm4.params_in[i].Register;
-
- info.in[r].mask |= sm4.params_in[i].ReadWriteMask;
- // mask might be uninitialized ...
- if (!sm4.params_in[i].ReadWriteMask)
- info.in[r].mask = 0xf;
- info.in[r].id = r;
- if (info.in[r].regular) // already assigned semantic name/index
- continue;
- info.in[r].regular = 1;
- info.in[r].patch = 0;
-
- info.numInputs = MAX2(info.numInputs, r + 1);
-
- switch (sm4.params_in[i].SystemValueType) {
- case D3D_NAME_UNDEFINED:
- info.in[r].sn = TGSI_SEMANTIC_GENERIC;
- info.in[r].si = n++;
- break;
- case D3D_NAME_POSITION:
- info.in[r].sn = TGSI_SEMANTIC_POSITION;
- break;
- case D3D_NAME_VERTEX_ID:
- info.in[r].sn = TGSI_SEMANTIC_VERTEXID;
- break;
- case D3D_NAME_PRIMITIVE_ID:
- info.in[r].sn = TGSI_SEMANTIC_PRIMID;
- // no corresponding output
- recordSV(TGSI_SEMANTIC_PRIMID, 0, 1, true);
- break;
- case D3D_NAME_INSTANCE_ID:
- info.in[r].sn = TGSI_SEMANTIC_INSTANCEID;
- break;
- case D3D_NAME_IS_FRONT_FACE:
- info.in[r].sn = TGSI_SEMANTIC_FACE;
- // no corresponding output
- recordSV(TGSI_SEMANTIC_FACE, 0, 1, true);
- break;
- default:
- assert(!"invalid/unsupported input linkage semantic");
- break;
- }
- }
-
- for (n = 0, i = 0; i < sm4.num_params_out; ++i) {
- r = sm4.params_out[i].Register;
-
- info.out[r].mask |= ~sm4.params_out[i].ReadWriteMask;
- info.out[r].id = r;
- if (info.out[r].regular) // already assigned semantic name/index
- continue;
- info.out[r].regular = 1;
- info.out[r].patch = 0;
-
- info.numOutputs = MAX2(info.numOutputs, r + 1);
-
- switch (sm4.params_out[i].SystemValueType) {
- case D3D_NAME_UNDEFINED:
- if (prog->getType() == Program::TYPE_FRAGMENT) {
- info.out[r].sn = TGSI_SEMANTIC_COLOR;
- info.out[r].si = info.prop.fp.numColourResults++;
- } else {
- info.out[r].sn = TGSI_SEMANTIC_GENERIC;
- info.out[r].si = n++;
- }
- break;
- case D3D_NAME_POSITION:
- case D3D_NAME_DEPTH:
- case D3D_NAME_DEPTH_GREATER_EQUAL:
- case D3D_NAME_DEPTH_LESS_EQUAL:
- info.out[r].sn = TGSI_SEMANTIC_POSITION;
- info.io.fragDepth = r;
- break;
- case D3D_NAME_CULL_DISTANCE:
- case D3D_NAME_CLIP_DISTANCE:
- info.out[r].sn = NV50_SEMANTIC_CLIPDISTANCE;
- info.out[r].si = sm4.params_out[i].SemanticIndex;
- break;
- case D3D_NAME_RENDER_TARGET_ARRAY_INDEX:
- info.out[r].sn = NV50_SEMANTIC_LAYER;
- break;
- case D3D_NAME_VIEWPORT_ARRAY_INDEX:
- info.out[r].sn = NV50_SEMANTIC_VIEWPORTINDEX;
- break;
- case D3D_NAME_PRIMITIVE_ID:
- info.out[r].sn = TGSI_SEMANTIC_PRIMID;
- break;
- case D3D_NAME_TARGET:
- info.out[r].sn = TGSI_SEMANTIC_COLOR;
- info.out[r].si = sm4.params_out[i].SemanticIndex;
- break;
- case D3D_NAME_COVERAGE:
- info.out[r].sn = NV50_SEMANTIC_SAMPLEMASK;
- info.io.sampleMask = r;
- break;
- case D3D_NAME_SAMPLE_INDEX:
- default:
- assert(!"invalid/unsupported output linkage semantic");
- break;
- }
- }
-
- if (prog->getType() == Program::TYPE_TESSELLATION_EVAL)
- patch = &info.in[info.numInputs];
- else
- patch = &info.out[info.numOutputs];
-
- for (n = 0, i = 0; i < sm4.num_params_patch; ++i) {
- r = sm4.params_patch[i].Register;
-
- patch[r].mask |= sm4.params_patch[i].Mask;
- patch[r].id = r;
- if (patch[r].regular) // already visited
- continue;
- patch[r].regular = 1;
- patch[r].patch = 1;
-
- info.numPatchConstants = MAX2(info.numPatchConstants, r + 1);
-
- switch (sm4.params_patch[i].SystemValueType) {
- case D3D_NAME_UNDEFINED:
- patch[r].sn = TGSI_SEMANTIC_GENERIC;
- patch[r].si = n++;
- break;
- case D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR:
- case D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR:
- case D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR:
- patch[r].sn = NV50_SEMANTIC_TESSFACTOR;
- patch[r].si = sm4.params_patch[i].SemanticIndex;
- break;
- case D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR:
- case D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR:
- case D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR:
- patch[r].sn = NV50_SEMANTIC_TESSFACTOR;
- patch[r].si = sm4.params_patch[i].SemanticIndex + 4;
- break;
- default:
- assert(!"invalid patch-constant linkage semantic");
- break;
- }
- }
- if (prog->getType() == Program::TYPE_TESSELLATION_EVAL)
- info.numInputs += info.numPatchConstants;
- else
- info.numOutputs += info.numPatchConstants;
-
- return true;
-}
-
-bool
-Converter::inspectDeclaration(const sm4_dcl& dcl)
-{
- int idx = -1;
- enum sm4_interpolation ipa_mode;
-
- if (dcl.op.get() && dcl.op->is_index_simple(0))
- idx = dcl.op->indices[0].disp;
-
- switch (dcl.opcode) {
- case SM4_OPCODE_DCL_SAMPLER:
- assert(idx >= 0);
- shadow[idx] = dcl.dcl_sampler.shadow;
- break;
- case SM4_OPCODE_DCL_RESOURCE:
- {
- enum sm4_target targ = (enum sm4_target)dcl.dcl_resource.target;
-
- assert(idx >= 0 && idx < NV50_IR_MAX_RESOURCES);
- resourceType[idx][0] = cvtTexTarget(targ, SM4_OPCODE_SAMPLE, NULL);
- resourceType[idx][1] = cvtTexTarget(targ, SM4_OPCODE_SAMPLE_C, NULL);
- }
- break;
- case SM4_OPCODE_DCL_CONSTANT_BUFFER:
- // nothing to do
- break;
- case SM4_OPCODE_CUSTOMDATA:
- info.immd.bufSize = dcl.num * 4;
- info.immd.buf = (uint32_t *)MALLOC(info.immd.bufSize);
- memcpy(info.immd.buf, dcl.data, info.immd.bufSize);
- break;
- case SM4_OPCODE_DCL_INDEX_RANGE:
- // XXX: ?
- break;
- case SM4_OPCODE_DCL_INPUT_PS_SGV:
- case SM4_OPCODE_DCL_INPUT_PS_SIV:
- case SM4_OPCODE_DCL_INPUT_PS:
- {
- assert(idx >= 0 && idx < info.numInputs);
- ipa_mode = (enum sm4_interpolation)dcl.dcl_input_ps.interpolation;
- interpMode[idx] = cvtInterpMode(ipa_mode);
- setVaryingInterpMode(&info.in[idx], interpMode[idx]);
- }
- break;
- case SM4_OPCODE_DCL_INPUT_SGV:
- case SM4_OPCODE_DCL_INPUT_SIV:
- case SM4_OPCODE_DCL_INPUT:
- if (dcl.op->file == SM4_FILE_INPUT_DOMAIN_POINT) {
- idx = info.numInputs++;
- info.in[idx].sn = NV50_SEMANTIC_TESSCOORD;
- info.in[idx].mask = dcl.op->mask;
- }
- // rest handled in parseSignature
- break;
- case SM4_OPCODE_DCL_OUTPUT_SGV:
- case SM4_OPCODE_DCL_OUTPUT_SIV:
- switch (dcl.sv) {
- case SM4_SV_POSITION:
- assert(prog->getType() != Program::TYPE_FRAGMENT);
- break;
- case SM4_SV_CULL_DISTANCE: // XXX: order ?
- info.io.cullDistanceMask |= 1 << info.io.clipDistanceMask;
- // fall through
- case SM4_SV_CLIP_DISTANCE:
- info.io.clipDistanceMask++; // abuse as count
- break;
- default:
- break;
- }
- switch (dcl.op->file) {
- case SM4_FILE_OUTPUT_DEPTH_LESS_EQUAL:
- case SM4_FILE_OUTPUT_DEPTH_GREATER_EQUAL:
- case SM4_FILE_OUTPUT_DEPTH:
- if (info.io.fragDepth < 0xff)
- break;
- idx = info.io.fragDepth = info.numOutputs++;
- info.out[idx].sn = TGSI_SEMANTIC_POSITION;
- break;
- case SM4_FILE_OUTPUT_COVERAGE_MASK:
- if (info.io.sampleMask < 0xff)
- break;
- idx = info.io.sampleMask = info.numOutputs++;
- info.out[idx].sn = NV50_SEMANTIC_SAMPLEMASK;
- break;
- default:
- break;
- }
- break;
- case SM4_OPCODE_DCL_OUTPUT:
- // handled in parseSignature
- break;
- case SM4_OPCODE_DCL_TEMPS:
- nrRegVals += dcl.num;
- break;
- case SM4_OPCODE_DCL_INDEXABLE_TEMP:
- nrArrays++;
- break;
- case SM4_OPCODE_DCL_GLOBAL_FLAGS:
- if (prog->getType() == Program::TYPE_FRAGMENT)
- info.prop.fp.earlyFragTests = dcl.dcl_global_flags.early_depth_stencil;
- break;
-
- case SM4_OPCODE_DCL_FUNCTION_BODY:
- break;
- case SM4_OPCODE_DCL_FUNCTION_TABLE:
- break;
- case SM4_OPCODE_DCL_INTERFACE:
- break;
-
- // GP
- case SM4_OPCODE_DCL_GS_OUTPUT_PRIMITIVE_TOPOLOGY:
- info.prop.gp.outputPrim = g3dPrim(
- dcl.dcl_gs_output_primitive_topology.primitive_topology);
- break;
- case SM4_OPCODE_DCL_GS_INPUT_PRIMITIVE:
- info.prop.gp.inputPrim = g3dPrim(dcl.dcl_gs_input_primitive.primitive);
- break;
- case SM4_OPCODE_DCL_MAX_OUTPUT_VERTEX_COUNT:
- info.prop.gp.maxVertices = dcl.num;
- break;
- case SM4_OPCODE_DCL_GS_INSTANCE_COUNT:
- info.prop.gp.instanceCount = dcl.num;
- break;
- case SM4_OPCODE_DCL_STREAM:
- break;
-
- // TCP/TEP
- case SM4_OPCODE_DCL_INPUT_CONTROL_POINT_COUNT:
- info.prop.tp.inputPatchSize =
- dcl.dcl_input_control_point_count.control_points;
- break;
- case SM4_OPCODE_DCL_OUTPUT_CONTROL_POINT_COUNT:
- info.prop.tp.outputPatchSize =
- dcl.dcl_output_control_point_count.control_points;
- break;
- case SM4_OPCODE_DCL_TESS_DOMAIN:
- switch (dcl.dcl_tess_domain.domain) {
- case D3D_TESSELLATOR_DOMAIN_ISOLINE:
- info.prop.tp.domain = PIPE_PRIM_LINES;
- break;
- case D3D_TESSELLATOR_DOMAIN_TRI:
- info.prop.tp.domain = PIPE_PRIM_TRIANGLES;
- break;
- case D3D_TESSELLATOR_DOMAIN_QUAD:
- info.prop.tp.domain = PIPE_PRIM_QUADS;
- break;
- case D3D_TESSELLATOR_DOMAIN_UNDEFINED:
- default:
- info.prop.tp.domain = PIPE_PRIM_MAX;
- break;
- }
- break;
- case SM4_OPCODE_DCL_TESS_PARTITIONING:
- switch (dcl.dcl_tess_partitioning.partitioning) {
- case D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
- info.prop.tp.partitioning = NV50_TESS_PART_FRACT_ODD;
- break;
- case D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
- info.prop.tp.partitioning = NV50_TESS_PART_FRACT_EVEN;
- break;
- case D3D_TESSELLATOR_PARTITIONING_POW2:
- info.prop.tp.partitioning = NV50_TESS_PART_POW2;
- break;
- case D3D_TESSELLATOR_PARTITIONING_INTEGER:
- case D3D_TESSELLATOR_PARTITIONING_UNDEFINED:
- default:
- info.prop.tp.partitioning = NV50_TESS_PART_INTEGER;
- break;
- }
- break;
- case SM4_OPCODE_DCL_TESS_OUTPUT_PRIMITIVE:
- switch (dcl.dcl_tess_output_primitive.primitive) {
- case D3D_TESSELLATOR_OUTPUT_LINE:
- info.prop.tp.outputPrim = PIPE_PRIM_LINES;
- break;
- case D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW:
- info.prop.tp.outputPrim = PIPE_PRIM_TRIANGLES;
- info.prop.tp.winding = +1;
- break;
- case D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW:
- info.prop.tp.outputPrim = PIPE_PRIM_TRIANGLES;
- info.prop.tp.winding = -1;
- break;
- case D3D_TESSELLATOR_OUTPUT_POINT:
- info.prop.tp.outputPrim = PIPE_PRIM_POINTS;
- break;
- case D3D_TESSELLATOR_OUTPUT_UNDEFINED:
- default:
- info.prop.tp.outputPrim = PIPE_PRIM_MAX;
- break;
- }
- break;
-
- case SM4_OPCODE_HS_FORK_PHASE:
- ++subPhaseCnt[0];
- phase = 1;
- break;
- case SM4_OPCODE_HS_JOIN_PHASE:
- phase = 2;
- ++subPhaseCnt[1];
- break;
- case SM4_OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT:
- case SM4_OPCODE_DCL_HS_JOIN_PHASE_INSTANCE_COUNT:
- case SM4_OPCODE_DCL_HS_MAX_TESSFACTOR:
- break;
-
- // weird stuff
- case SM4_OPCODE_DCL_THREAD_GROUP:
- case SM4_OPCODE_DCL_UNORDERED_ACCESS_VIEW_TYPED:
- case SM4_OPCODE_DCL_UNORDERED_ACCESS_VIEW_RAW:
- case SM4_OPCODE_DCL_UNORDERED_ACCESS_VIEW_STRUCTURED:
- case SM4_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_RAW:
- case SM4_OPCODE_DCL_THREAD_GROUP_SHARED_MEMORY_STRUCTURED:
- case SM4_OPCODE_DCL_RESOURCE_RAW:
- case SM4_OPCODE_DCL_RESOURCE_STRUCTURED:
- ERROR("unhandled declaration\n");
- abort();
- return false;
-
- default:
- assert(!"invalid SM4 declaration");
- return false;
- }
- return true;
-}
-
-void
-Converter::allocateValues()
-{
- lData = new DataArray[nrArrays];
-
- for (unsigned int i = 0; i < nrArrays; ++i)
- lData[i].setParent(this);
-
- tData32.setup(0, nrRegVals, 4, 4, FILE_GPR);
- tData64.setup(0, nrRegVals, 2, 8, FILE_GPR);
-
- if (prog->getType() == Program::TYPE_FRAGMENT)
- oData.setup(0, info.numOutputs, 4, 4, FILE_GPR);
-}
-
-bool Converter::handleDeclaration(const sm4_dcl& dcl)
-{
- switch (dcl.opcode) {
- case SM4_OPCODE_DCL_INDEXABLE_TEMP:
- lData[nrArrays++].setup(arrayVol,
- dcl.indexable_temp.num, dcl.indexable_temp.comps,
- 4, FILE_MEMORY_LOCAL);
- arrayVol += dcl.indexable_temp.num * dcl.indexable_temp.comps * 4;
- break;
- case SM4_OPCODE_HS_FORK_PHASE:
- if (subPhaseCnt[0])
- phaseInstCnt[0][subPhaseCnt[0]] = phaseInstCnt[0][subPhaseCnt[0] - 1];
- ++subPhaseCnt[0];
- break;
- case SM4_OPCODE_HS_JOIN_PHASE:
- if (subPhaseCnt[1])
- phaseInstCnt[1][subPhaseCnt[1]] = phaseInstCnt[1][subPhaseCnt[1] - 1];
- ++subPhaseCnt[1];
- break;
- case SM4_OPCODE_DCL_HS_FORK_PHASE_INSTANCE_COUNT:
- phaseInstCnt[0][subPhaseCnt[0] - 1] = dcl.num;
- break;
- case SM4_OPCODE_DCL_HS_JOIN_PHASE_INSTANCE_COUNT:
- phaseInstCnt[1][subPhaseCnt[1] - 1] = dcl.num;
- break;
-
- default:
- break; // already handled in inspection
- }
-
- return true;
-}
-
-Symbol *
-Converter::iSym(int i, int c)
-{
- if (info.in[i].regular) {
- return mkSymbol(FILE_SHADER_INPUT, 0, sTy, info.in[i].slot[c] * 4);
- } else {
- return mkSysVal(tgsi::irSemantic(info.in[i].sn), info.in[i].si);
- }
-}
-
-Symbol *
-Converter::oSym(int i, int c)
-{
- if (info.out[i].regular) {
- return mkSymbol(FILE_SHADER_OUTPUT, 0, dTy, info.out[i].slot[c] * 4);
- } else {
- return mkSysVal(tgsi::irSemantic(info.out[i].sn), info.out[i].si);
- }
-}
-
-Value *
-Converter::getSrcPtr(int s, int dim, int shl)
-{
- if (srcPtr[s][dim])
- return srcPtr[s][dim];
-
- sm4_op *op = insn->ops[s + nDstOpnds]->indices[dim].reg.get();
-
- if (!op)
- return NULL;
-
- Value *index = src(*op, 0, s);
-
- srcPtr[s][dim] = index;
- if (shl)
- srcPtr[s][dim] = mkOp2v(OP_SHL, TYPE_U32, getSSA(), index, mkImm(shl));
- return srcPtr[s][dim];
-}
-
-Value *
-Converter::getDstPtr(int d, int dim, int shl)
-{
- assert(d == 0);
- if (dstPtr[dim])
- return dstPtr[dim];
-
- sm4_op *op = insn->ops[d]->indices[dim].reg.get();
- if (!op)
- return NULL;
-
- Value *index = src(*op, 0, d);
- if (shl)
- index = mkOp2v(OP_SHL, TYPE_U32, getSSA(), index, mkImm(shl));
-
- return (dstPtr[dim] = index);
-}
-
-Value *
-Converter::getVtxPtr(int s)
-{
- assert(s < 3);
- if (vtxBase[s])
- return vtxBase[s];
-
- sm4_op *op = insn->ops[s + nDstOpnds].get();
- if (!op)
- return NULL;
- int idx = op->indices[0].disp;
-
- vtxBase[s] = getSrcPtr(s, 0, 0);
- vtxBase[s] = mkOp2v(OP_PFETCH, TYPE_U32, getSSA(), mkImm(idx), vtxBase[s]);
- return vtxBase[s];
-}
-
-Value *
-Converter::src(int i, int c)
-{
- return src(*insn->ops[i + nDstOpnds], c, i);
-}
-
-Value *
-Converter::dst(int i, int c)
-{
- return dst(*insn->ops[i], c, i);
-}
-
-void
-Converter::saveDst(int i, int c, Value *value)
-{
- if (insn->insn.sat)
- mkOp1(OP_SAT, dTy, value, value);
- return saveDst(*insn->ops[i], c, value, i);
-}
-
-Value *
-Converter::interpolate(const sm4_op& op, int c, int i)
-{
- int idx = op.indices[0].disp;
- int swz = op.swizzle[c];
- operation opr =
- (info.in[idx].linear || info.in[idx].flat) ? OP_LINTERP : OP_PINTERP;
-
- Value *ptr = getSrcPtr(i, 0, 4);
-
- Instruction *insn = new_Instruction(func, opr, TYPE_F32);
-
- insn->setDef(0, getScratch());
- insn->setSrc(0, iSym(idx, swz));
- if (opr == OP_PINTERP)
- insn->setSrc(1, fragCoord[3]);
- if (ptr)
- insn->setIndirect(0, 0, ptr);
-
- insn->setInterpolate(interpMode[idx]);
-
- bb->insertTail(insn);
- return insn->getDef(0);
-}
-
-Value *
-Converter::src(const sm4_op& op, int c, int s)
-{
- const int size = typeSizeof(sTy);
-
- Instruction *ld;
- Value *res, *ptr, *vtx;
- int idx, dim, off;
- const int swz = op.swizzle[c];
-
- switch (op.file) {
- case SM4_FILE_IMMEDIATE32:
- res = loadImm(NULL, (uint32_t)op.imm_values[swz].u32);
- break;
- case SM4_FILE_IMMEDIATE64:
- assert(c < 2);
- res = loadImm(NULL, op.imm_values[swz].u64);
- break;
- case SM4_FILE_TEMP:
- assert(op.is_index_simple(0));
- idx = op.indices[0].disp;
- if (size == 8)
- res = tData64.load(idx, swz, NULL);
- else
- res = tData32.load(idx, swz, NULL);
- break;
- case SM4_FILE_INPUT:
- case SM4_FILE_INPUT_CONTROL_POINT:
- case SM4_FILE_INPUT_PATCH_CONSTANT:
- if (prog->getType() == Program::TYPE_FRAGMENT)
- return interpolate(op, c, s);
-
- idx = 0;
- if (op.file == SM4_FILE_INPUT_PATCH_CONSTANT)
- idx = info.numInputs - info.numPatchConstants;
-
- if (op.num_indices == 2) {
- vtx = getVtxPtr(s);
- ptr = getSrcPtr(s, 1, 4);
- idx += op.indices[1].disp;
- res = getSSA();
- ld = mkOp1(OP_VFETCH, TYPE_U32, res, iSym(idx, swz));
- ld->setIndirect(0, 0, ptr);
- ld->setIndirect(0, 1, vtx);
- } else {
- idx += op.indices[0].disp;
- res = mkLoad(sTy, iSym(idx, swz), getSrcPtr(s, 0, 4));
- }
- if (op.file == SM4_FILE_INPUT_PATCH_CONSTANT)
- res->defs->getInsn()->perPatch = 1;
- break;
- case SM4_FILE_CONSTANT_BUFFER:
- assert(op.num_indices == 2);
- assert(op.is_index_simple(0));
-
- ptr = getSrcPtr(s, 1, 4);
- dim = op.indices[0].disp;
- off = (op.indices[1].disp * 4 + swz) * (sTy == TYPE_F64 ? 8 : 4);
-
- res = mkLoad(sTy, mkSymbol(FILE_MEMORY_CONST, dim, sTy, off), ptr);
- break;
- case SM4_FILE_IMMEDIATE_CONSTANT_BUFFER:
- ptr = getSrcPtr(s, 0, 4);
- off = (op.indices[0].disp * 4 + swz) * 4;
- res = mkLoad(sTy, mkSymbol(FILE_MEMORY_CONST, 14, sTy, off), ptr);
- break;
- case SM4_FILE_INDEXABLE_TEMP:
- {
- assert(op.is_index_simple(0));
- int a = op.indices[0].disp;
- idx = op.indices[1].disp;
- res = lData[a].load(idx, swz, getSrcPtr(s, 1, 4));
- }
- break;
- case SM4_FILE_INPUT_PRIMITIVEID:
- recordSV(TGSI_SEMANTIC_PRIMID, 0, 1, true);
- res = mkOp1v(OP_RDSV, TYPE_U32, getSSA(), mkSysVal(SV_PRIMITIVE_ID, 0));
- break;
- case SM4_FILE_INPUT_GS_INSTANCE_ID:
- case SM4_FILE_OUTPUT_CONTROL_POINT_ID:
- recordSV(NV50_SEMANTIC_INVOCATIONID, 0, 1, true);
- res = mkOp1v(OP_RDSV, TYPE_U32, getSSA(), mkSysVal(SV_INVOCATION_ID, 0));
- break;
- case SM4_FILE_CYCLE_COUNTER:
- res =
- mkOp1v(OP_RDSV, TYPE_U32, getSSA(), mkSysVal(SV_CLOCK, swz ? 1 : 0));
- break;
- case SM4_FILE_INPUT_FORK_INSTANCE_ID:
- case SM4_FILE_INPUT_JOIN_INSTANCE_ID:
- {
- phaseInstanceUsed = true;
- if (unrollPhase)
- return loadImm(NULL, phaseInstance);
- const unsigned int cnt = phaseInstCnt[phase - 1][subPhase];
- res = getScratch();
- res = mkOp1v(OP_RDSV, TYPE_U32, res, mkSysVal(SV_INVOCATION_ID, 0));
- res = mkOp2v(OP_MIN, TYPE_U32, res, res, loadImm(NULL, cnt - 1));
- }
- break;
- case SM4_FILE_INPUT_DOMAIN_POINT:
- assert(swz < 3);
- res = domainPt[swz];
- break;
- case SM4_FILE_THREAD_GROUP_SHARED_MEMORY:
- off = (op.indices[0].disp * 4 + swz) * (sTy == TYPE_F64 ? 8 : 4);
- ptr = getSrcPtr(s, 0, 4);
- res = mkLoad(sTy, mkSymbol(FILE_MEMORY_SHARED, 0, sTy, off), ptr);
- break;
- case SM4_FILE_RESOURCE:
- case SM4_FILE_SAMPLER:
- case SM4_FILE_UNORDERED_ACCESS_VIEW:
- return NULL;
- case SM4_FILE_INPUT_THREAD_ID:
- res = mkOp1v(OP_RDSV, TYPE_U32, getSSA(), mkSysVal(SV_TID, swz));
- break;
- case SM4_FILE_INPUT_THREAD_GROUP_ID:
- res = mkOp1v(OP_RDSV, TYPE_U32, getSSA(), mkSysVal(SV_CTAID, swz));
- break;
- case SM4_FILE_FUNCTION_INPUT:
- case SM4_FILE_INPUT_THREAD_ID_IN_GROUP:
- assert(!"unhandled source file");
- return NULL;
- default:
- assert(!"invalid source file");
- return NULL;
- }
-
- if (op.abs)
- res = mkOp1v(OP_ABS, sTy, getSSA(res->reg.size), res);
- if (op.neg)
- res = mkOp1v(OP_NEG, sTy, getSSA(res->reg.size), res);
- return res;
-}
-
-Value *
-Converter::dst(const sm4_op &op, int c, int i)
-{
- switch (op.file) {
- case SM4_FILE_TEMP:
- return tData32.acquire(op.indices[0].disp, c);
- case SM4_FILE_INDEXABLE_TEMP:
- return getScratch();
- case SM4_FILE_OUTPUT:
- if (prog->getType() == Program::TYPE_FRAGMENT)
- return oData.acquire(op.indices[0].disp, c);
- return getScratch();
- case SM4_FILE_NULL:
- return NULL;
- case SM4_FILE_OUTPUT_DEPTH:
- case SM4_FILE_OUTPUT_DEPTH_GREATER_EQUAL:
- case SM4_FILE_OUTPUT_DEPTH_LESS_EQUAL:
- case SM4_FILE_OUTPUT_COVERAGE_MASK:
- return getScratch();
- case SM4_FILE_IMMEDIATE32:
- case SM4_FILE_IMMEDIATE64:
- case SM4_FILE_CONSTANT_BUFFER:
- case SM4_FILE_RESOURCE:
- case SM4_FILE_SAMPLER:
- case SM4_FILE_UNORDERED_ACCESS_VIEW:
- assert(!"invalid destination file");
- return NULL;
- default:
- assert(!"invalid file");
- return NULL;
- }
-}
-
-void
-Converter::saveFragDepth(operation op, Value *value)
-{
- if (op == OP_MIN || op == OP_MAX) {
- Value *zIn;
- zIn = mkOp1v(OP_RDSV, TYPE_F32, getSSA(), mkSysVal(SV_POSITION, 2));
- value = mkOp2v(op, TYPE_F32, getSSA(), value, zIn);
- }
- oData.store(info.io.fragDepth, 2, NULL, value);
-}
-
-void
-Converter::saveDst(const sm4_op &op, int c, Value *value, int s)
-{
- Symbol *sym;
- Instruction *st;
- int a, idx;
-
- switch (op.file) {
- case SM4_FILE_TEMP:
- idx = op.indices[0].disp;
- tData32.store(idx, c, NULL, value);
- break;
- case SM4_FILE_INDEXABLE_TEMP:
- a = op.indices[0].disp;
- idx = op.indices[1].disp;
- // FIXME: shift is wrong, depends in lData
- lData[a].store(idx, c, getDstPtr(s, 1, 4), value);
- break;
- case SM4_FILE_OUTPUT:
- assert(op.num_indices == 1);
- idx = op.indices[0].disp;
- if (prog->getType() == Program::TYPE_FRAGMENT) {
- oData.store(idx, c, NULL, value);
- } else {
- if (phase)
- idx += info.numOutputs - info.numPatchConstants;
- const int shl = (info.out[idx].sn == NV50_SEMANTIC_TESSFACTOR) ? 2 : 4;
- sym = oSym(idx, c);
- if (sym->reg.file == FILE_SHADER_OUTPUT)
- st = mkStore(OP_EXPORT, dTy, sym, getDstPtr(s, 0, shl), value);
- else
- st = mkStore(OP_WRSV, dTy, sym, getDstPtr(s, 0, 2), value);
- st->perPatch = phase ? 1 : 0;
- }
- break;
- case SM4_FILE_OUTPUT_DEPTH_GREATER_EQUAL:
- saveFragDepth(OP_MAX, value);
- break;
- case SM4_FILE_OUTPUT_DEPTH_LESS_EQUAL:
- saveFragDepth(OP_MIN, value);
- break;
- case SM4_FILE_OUTPUT_DEPTH:
- saveFragDepth(OP_NOP, value);
- break;
- case SM4_FILE_OUTPUT_COVERAGE_MASK:
- oData.store(info.io.sampleMask, 0, NULL, value);
- break;
- case SM4_FILE_IMMEDIATE32:
- case SM4_FILE_IMMEDIATE64:
- case SM4_FILE_INPUT:
- case SM4_FILE_CONSTANT_BUFFER:
- case SM4_FILE_RESOURCE:
- case SM4_FILE_SAMPLER:
- assert(!"invalid destination file");
- return;
- default:
- assert(!"invalid file");
- return;
- }
-}
-
-void
-Converter::emitTex(Value *dst0[4], TexInstruction *tex, const uint8_t swz[4])
-{
- Value *res[4] = { NULL, NULL, NULL, NULL };
- unsigned int c, d;
-
- for (c = 0; c < 4; ++c)
- if (dst0[c])
- tex->tex.mask |= 1 << swz[c];
- for (d = 0, c = 0; c < 4; ++c)
- if (tex->tex.mask & (1 << c))
- tex->setDef(d++, (res[c] = getScratch()));
-
- bb->insertTail(tex);
-
- if (insn->opcode == SM4_OPCODE_RESINFO) {
- if (tex->tex.target.getDim() == 1) {
- res[2] = loadImm(NULL, 0);
- if (!tex->tex.target.isArray())
- res[1] = res[2];
- } else
- if (tex->tex.target.getDim() == 2 && !tex->tex.target.isArray()) {
- res[2] = loadImm(NULL, 0);
- }
- for (c = 0; c < 4; ++c) {
- if (!dst0[c])
- continue;
- Value *src = res[swz[c]];
- assert(src);
- switch (insn->insn.resinfo_return_type) {
- case 0:
- mkCvt(OP_CVT, TYPE_F32, dst0[c], TYPE_U32, src);
- break;
- case 1:
- mkCvt(OP_CVT, TYPE_F32, dst0[c], TYPE_U32, src);
- if (swz[c] < tex->tex.target.getDim())
- mkOp1(OP_RCP, TYPE_F32, dst0[c], dst0[c]);
- break;
- default:
- mkMov(dst0[c], src);
- break;
- }
- }
- } else {
- for (c = 0; c < 4; ++c)
- if (dst0[c])
- mkMov(dst0[c], res[swz[c]]);
- }
-}
-
-void
-Converter::handleQUERY(Value *dst0[4], enum TexQuery query)
-{
- TexInstruction *texi = new_TexInstruction(func, OP_TXQ);
- texi->tex.query = query;
-
- assert(insn->ops[2]->file == SM4_FILE_RESOURCE); // TODO: UAVs
-
- const int rOp = (query == TXQ_DIMS) ? 2 : 1;
- const int sOp = (query == TXQ_DIMS) ? 0 : 1;
-
- const int tR = insn->ops[rOp]->indices[0].disp;
-
- texi->setTexture(resourceType[tR][0], tR, 0);
-
- texi->setSrc(0, src(sOp, 0)); // mip level or sample index
-
- emitTex(dst0, texi, insn->ops[rOp]->swizzle);
-}
-
-void
-Converter::handleLOAD(Value *dst0[4])
-{
- TexInstruction *texi = new_TexInstruction(func, OP_TXF);
- unsigned int c;
-
- const int tR = insn->ops[2]->indices[0].disp;
-
- texi->setTexture(resourceType[tR][0], tR, 0);
-
- for (c = 0; c < texi->tex.target.getArgCount(); ++c)
- texi->setSrc(c, src(0, c));
-
- if (texi->tex.target == TEX_TARGET_BUFFER) {
- texi->tex.levelZero = true;
- } else {
- texi->setSrc(c++, src(0, 3));
- for (c = 0; c < 3; ++c) {
- texi->tex.offset[0][c] = insn->sample_offset[c];
- if (texi->tex.offset[0][c])
- texi->tex.useOffsets = 1;
- }
- }
-
- emitTex(dst0, texi, insn->ops[2]->swizzle);
-}
-
-// order of nv50 ir sources: x y z/layer lod/bias dc
-void
-Converter::handleSAMPLE(operation opr, Value *dst0[4])
-{
- TexInstruction *texi = new_TexInstruction(func, opr);
- unsigned int c, s;
- Value *arg[4], *src0[4];
- Value *val;
- Value *lod = NULL, *dc = NULL;
-
- const int tR = insn->ops[2]->indices[0].disp;
- const int tS = insn->ops[3]->indices[0].disp;
-
- TexInstruction::Target tgt = resourceType[tR][shadow[tS] ? 1 : 0];
-
- for (c = 0; c < tgt.getArgCount(); ++c)
- arg[c] = src0[c] = src(0, c);
-
- if (insn->opcode == SM4_OPCODE_SAMPLE_L ||
- insn->opcode == SM4_OPCODE_SAMPLE_B) {
- lod = src(3, 0);
- } else
- if (insn->opcode == SM4_OPCODE_SAMPLE_C ||
- insn->opcode == SM4_OPCODE_SAMPLE_C_LZ) {
- dc = src(3, 0);
- if (insn->opcode == SM4_OPCODE_SAMPLE_C_LZ)
- texi->tex.levelZero = true;
- } else
- if (insn->opcode == SM4_OPCODE_SAMPLE_D) {
- for (c = 0; c < tgt.getDim(); ++c) {
- texi->dPdx[c] = src(3, c);
- texi->dPdy[c] = src(4, c);
- }
- }
-
- if (tgt.isCube()) {
- for (c = 0; c < 3; ++c)
- src0[c] = mkOp1v(OP_ABS, TYPE_F32, getSSA(), arg[c]);
- val = getScratch();
- mkOp2(OP_MAX, TYPE_F32, val, src0[0], src0[1]);
- mkOp2(OP_MAX, TYPE_F32, val, src0[2], val);
- mkOp1(OP_RCP, TYPE_F32, val, val);
- for (c = 0; c < 3; ++c)
- src0[c] = mkOp2v(OP_MUL, TYPE_F32, getSSA(), arg[c], val);
- }
-
- for (s = 0; s < tgt.getArgCount(); ++s)
- texi->setSrc(s, src0[s]);
- if (lod)
- texi->setSrc(s++, lod);
- if (dc)
- texi->setSrc(s++, dc);
-
- for (c = 0; c < 3; ++c) {
- texi->tex.offset[0][c] = insn->sample_offset[c];
- if (texi->tex.offset[0][c])
- texi->tex.useOffsets = 1;
- }
-
- texi->setTexture(tgt, tR, tS);
-
- emitTex(dst0, texi, insn->ops[2]->swizzle);
-}
-
-void
-Converter::handleDP(Value *dst0[4], int dim)
-{
- Value *src0 = src(0, 0), *src1 = src(1, 0);
- Value *dotp = getScratch();
-
- assert(dim > 0);
-
- mkOp2(OP_MUL, TYPE_F32, dotp, src0, src1);
- for (int c = 1; c < dim; ++c)
- mkOp3(OP_MAD, TYPE_F32, dotp, src(0, c), src(1, c), dotp);
-
- for (int c = 0; c < 4; ++c)
- dst0[c] = dotp;
-}
-
-void
-Converter::insertConvergenceOps(BasicBlock *conv, BasicBlock *fork)
-{
- FlowInstruction *join = new_FlowInstruction(func, OP_JOIN, NULL);
- join->fixed = 1;
- conv->insertHead(join);
-
- fork->joinAt = new_FlowInstruction(func, OP_JOINAT, conv);
- fork->insertBefore(fork->getExit(), fork->joinAt);
-}
-
-void
-Converter::finalizeShader()
-{
- if (finalized)
- return;
- BasicBlock *epilogue = reinterpret_cast<BasicBlock *>(leaveBBs.pop().u.p);
- entryBBs.pop();
-
- finalized = true;
-
- bb->cfg.attach(&epilogue->cfg, Graph::Edge::TREE);
- setPosition(epilogue, true);
-
- if (prog->getType() == Program::TYPE_FRAGMENT)
- exportOutputs();
-
- mkOp(OP_EXIT, TYPE_NONE, NULL)->terminator = 1;
-}
-
-#define FOR_EACH_DST0_ENABLED_CHANNEL32(chan) \
- for ((chan) = 0; (chan) < 4; ++(chan)) \
- if (insn->ops[0].get()->mask & (1 << (chan)))
-
-#define FOR_EACH_DST0_ENABLED_CHANNEL64(chan) \
- for ((chan) = 0; (chan) < 2; ++(chan)) \
- if (insn->ops[0].get()->mask & (1 << (chan)))
-
-bool
-Converter::checkDstSrcAliasing() const
-{
- for (unsigned int d = 0; d < nDstOpnds; ++d) {
- for (unsigned int s = nDstOpnds; s < insn->num_ops; ++s) {
- if (insn->ops[d]->file != insn->ops[s]->file)
- continue;
- int i = insn->ops[s]->num_indices - 1;
- if (i != insn->ops[d]->num_indices - 1)
- continue;
- if (insn->ops[d]->is_index_simple(i) &&
- insn->ops[s]->is_index_simple(i) &&
- insn->ops[d]->indices[i].disp == insn->ops[s]->indices[i].disp)
- return true;
- }
- }
- return false;
-}
-
-bool
-Converter::handleInstruction(unsigned int pos)
-{
- Value *dst0[4], *rDst0[4];
- Value *dst1[4], *rDst1[4];
- int c, nc;
-
- insn = sm4.insns[pos];
- enum sm4_opcode opcode = static_cast<sm4_opcode>(insn->opcode);
-
- operation op = cvtOpcode(opcode);
-
- sTy = inferSrcType(opcode);
- dTy = inferDstType(opcode);
-
- nc = dTy == TYPE_F64 ? 2 : 4;
-
- nDstOpnds = getDstOpndCount(opcode);
-
- bool useScratchDst = checkDstSrcAliasing();
-
- INFO("SM4_OPCODE_##%u, aliasing = %u\n", insn->opcode, useScratchDst);
-
- if (nDstOpnds >= 1) {
- for (c = 0; c < nc; ++c)
- rDst0[c] = dst0[c] =
- insn->ops[0].get()->mask & (1 << c) ? dst(0, c) : NULL;
- if (useScratchDst)
- for (c = 0; c < nc; ++c)
- dst0[c] = rDst0[c] ? getScratch() : NULL;
- }
-
- if (nDstOpnds >= 2) {
- for (c = 0; c < nc; ++c)
- rDst1[c] = dst1[c] =
- insn->ops[1].get()->mask & (1 << c) ? dst(1, c) : NULL;
- if (useScratchDst)
- for (c = 0; c < nc; ++c)
- dst1[c] = rDst1[c] ? getScratch() : NULL;
- }
-
- switch (insn->opcode) {
- case SM4_OPCODE_ADD:
- case SM4_OPCODE_AND:
- case SM4_OPCODE_DIV:
- case SM4_OPCODE_IADD:
- case SM4_OPCODE_IMAX:
- case SM4_OPCODE_IMIN:
- case SM4_OPCODE_MIN:
- case SM4_OPCODE_MAX:
- case SM4_OPCODE_MUL:
- case SM4_OPCODE_OR:
- case SM4_OPCODE_UMAX:
- case SM4_OPCODE_UMIN:
- case SM4_OPCODE_XOR:
- FOR_EACH_DST0_ENABLED_CHANNEL32(c) {
- Instruction *insn = mkOp2(op, dTy, dst0[c], src(0, c), src(1, c));
- if (dTy == TYPE_F32)
- insn->ftz = 1;
- }
- break;
-
- case SM4_OPCODE_ISHL:
- case SM4_OPCODE_ISHR:
- case SM4_OPCODE_USHR:
- FOR_EACH_DST0_ENABLED_CHANNEL32(c) {
- Instruction *insn = mkOp2(op, dTy, dst0[c], src(0, c), src(1, c));
- insn->subOp = NV50_IR_SUBOP_SHIFT_WRAP;
- }
- break;
-
- case SM4_OPCODE_IMAD:
- case SM4_OPCODE_MAD:
- case SM4_OPCODE_UMAD:
- FOR_EACH_DST0_ENABLED_CHANNEL32(c) {
- mkOp3(OP_MAD, dTy, dst0[c], src(0, c), src(1, c), src(2, c));
- }
- break;
-
- case SM4_OPCODE_DADD:
- case SM4_OPCODE_DMAX:
- case SM4_OPCODE_DMIN:
- case SM4_OPCODE_DMUL:
- FOR_EACH_DST0_ENABLED_CHANNEL64(c) {
- mkOp2(op, dTy, dst0[c], src(0, c), src(1, c));
- }
- break;
-
- case SM4_OPCODE_UDIV:
- for (c = 0; c < 4; ++c) {
- Value *dvn, *dvs;
- if (dst0[c] || dst1[c]) {
- dvn = src(0, c);
- dvs = src(1, c);
- }
- if (dst0[c])
- mkOp2(OP_DIV, TYPE_U32, dst0[c], dvn, dvs);
- if (dst1[c])
- mkOp2(OP_MOD, TYPE_U32, dst1[c], dvn, dvs);
- }
- break;
-
- case SM4_OPCODE_IMUL:
- case SM4_OPCODE_UMUL:
- for (c = 0; c < 4; ++c) {
- Value *a, *b;
- if (dst0[c] || dst1[c]) {
- a = src(0, c);
- b = src(1, c);
- }
- if (dst0[c])
- mkOp2(OP_MUL, dTy, dst0[c], a, b)->subOp =
- NV50_IR_SUBOP_MUL_HIGH;
- if (dst1[c])
- mkOp2(OP_MUL, dTy, dst1[c], a, b);
- }
- break;
-
- case SM4_OPCODE_DP2:
- handleDP(dst0, 2);
- break;
- case SM4_OPCODE_DP3:
- handleDP(dst0, 3);
- break;
- case SM4_OPCODE_DP4:
- handleDP(dst0, 4);
- break;
-
- case SM4_OPCODE_DERIV_RTX:
- case SM4_OPCODE_DERIV_RTX_COARSE:
- case SM4_OPCODE_DERIV_RTX_FINE:
- case SM4_OPCODE_DERIV_RTY:
- case SM4_OPCODE_DERIV_RTY_COARSE:
- case SM4_OPCODE_DERIV_RTY_FINE:
- case SM4_OPCODE_MOV:
- case SM4_OPCODE_INEG:
- case SM4_OPCODE_NOT:
- case SM4_OPCODE_SQRT:
- case SM4_OPCODE_COUNTBITS:
- case SM4_OPCODE_EXP:
- case SM4_OPCODE_LOG:
- case SM4_OPCODE_RCP:
- FOR_EACH_DST0_ENABLED_CHANNEL32(c) {
- mkOp1(op, dTy, dst0[c], src(0, c));
- }
- break;
-
- case SM4_OPCODE_FRC:
- FOR_EACH_DST0_ENABLED_CHANNEL32(c) {
- Value *val = getScratch();
- Value *src0 = src(0, c);
- mkOp1(OP_FLOOR, TYPE_F32, val, src0);
- mkOp2(OP_SUB, TYPE_F32, dst0[c], src0, val);
- }
- break;
-
- case SM4_OPCODE_MOVC:
- FOR_EACH_DST0_ENABLED_CHANNEL32(c)
- mkCmp(OP_SLCT, CC_NE, TYPE_U32, dst0[c], src(1, c), src(2, c),
- src(0, c));
- break;
-
- case SM4_OPCODE_ROUND_NE:
- case SM4_OPCODE_ROUND_NI:
- case SM4_OPCODE_ROUND_PI:
- case SM4_OPCODE_ROUND_Z:
- FOR_EACH_DST0_ENABLED_CHANNEL32(c) {
- Instruction *rnd = mkOp1(op, dTy, dst0[c], src(0, c));
- rnd->ftz = 1;
- rnd->rnd = cvtRoundingMode(opcode);
- }
- break;
-
- case SM4_OPCODE_RSQ:
- FOR_EACH_DST0_ENABLED_CHANNEL32(c)
- mkOp1(op, dTy, dst0[c], src(0, c));
- break;
-
- case SM4_OPCODE_SINCOS:
- for (c = 0; c < 4; ++c) {
- if (!dst0[c] && !dst1[c])
- continue;
- Value *val = mkOp1v(OP_PRESIN, TYPE_F32, getScratch(), src(0, c));
- if (dst0[c])
- mkOp1(OP_SIN, TYPE_F32, dst0[c], val);
- if (dst1[c])
- mkOp1(OP_COS, TYPE_F32, dst1[c], val);
- }
- break;
-
- case SM4_OPCODE_EQ:
- case SM4_OPCODE_GE:
- case SM4_OPCODE_IEQ:
- case SM4_OPCODE_IGE:
- case SM4_OPCODE_ILT:
- case SM4_OPCODE_LT:
- case SM4_OPCODE_NE:
- case SM4_OPCODE_INE:
- case SM4_OPCODE_ULT:
- case SM4_OPCODE_UGE:
- case SM4_OPCODE_DEQ:
- case SM4_OPCODE_DGE:
- case SM4_OPCODE_DLT:
- case SM4_OPCODE_DNE:
- {
- CondCode cc = cvtCondCode(opcode);
- FOR_EACH_DST0_ENABLED_CHANNEL32(c) {
- CmpInstruction *set;
- set = mkCmp(op, cc, sTy, dst0[c], src(0, c), src(1, c), NULL);
- set->setType(dTy, sTy);
- if (sTy == TYPE_F32)
- set->ftz = 1;
- }
- }
- break;
-
- case SM4_OPCODE_FTOI:
- case SM4_OPCODE_FTOU:
- FOR_EACH_DST0_ENABLED_CHANNEL32(c)
- mkCvt(op, dTy, dst0[c], sTy, src(0, c))->rnd = ROUND_Z;
- break;
- case SM4_OPCODE_ITOF:
- case SM4_OPCODE_UTOF:
- case SM4_OPCODE_F32TOF16:
- case SM4_OPCODE_F16TOF32:
- case SM4_OPCODE_DTOF:
- case SM4_OPCODE_FTOD:
- FOR_EACH_DST0_ENABLED_CHANNEL32(c)
- mkCvt(op, dTy, dst0[c], sTy, src(0, c));
- break;
-
- case SM4_OPCODE_CUT:
- case SM4_OPCODE_CUT_STREAM:
- mkOp1(OP_RESTART, TYPE_U32, NULL, mkImm(0))->fixed = 1;
- break;
- case SM4_OPCODE_EMIT:
- case SM4_OPCODE_EMIT_STREAM:
- mkOp1(OP_EMIT, TYPE_U32, NULL, mkImm(0))->fixed = 1;
- break;
- case SM4_OPCODE_EMITTHENCUT:
- case SM4_OPCODE_EMITTHENCUT_STREAM:
- {
- Instruction *cut = mkOp1(OP_EMIT, TYPE_U32, NULL, mkImm(0));
- cut->fixed = 1;
- cut->subOp = NV50_IR_SUBOP_EMIT_RESTART;
- }
- break;
-
- case SM4_OPCODE_DISCARD:
- info.prop.fp.usesDiscard = TRUE;
- mkOp(OP_DISCARD, TYPE_NONE, NULL)->setPredicate(
- insn->insn.test_nz ? CC_P : CC_NOT_P, src(0, 0));
- break;
-
- case SM4_OPCODE_CALL:
- case SM4_OPCODE_CALLC:
- assert(!"CALL/CALLC not implemented");
- break;
-
- case SM4_OPCODE_RET:
- // XXX: the following doesn't work with subroutines / early ret
- if (!haveNextPhase(pos))
- finalizeShader();
- else
- phaseEnded = phase + 1;
- break;
-
- case SM4_OPCODE_IF:
- {
- BasicBlock *ifClause = new BasicBlock(func);
-
- bb->cfg.attach(&ifClause->cfg, Graph::Edge::TREE);
- condBBs.push(bb);
- joinBBs.push(bb);
-
- mkFlow(OP_BRA, NULL, insn->insn.test_nz ? CC_NOT_P : CC_P, src(0, 0));
-
- setPosition(ifClause, true);
- }
- break;
- case SM4_OPCODE_ELSE:
- {
- BasicBlock *elseClause = new BasicBlock(func);
- BasicBlock *forkPoint = reinterpret_cast<BasicBlock *>(condBBs.pop().u.p);
-
- forkPoint->cfg.attach(&elseClause->cfg, Graph::Edge::TREE);
- condBBs.push(bb);
-
- forkPoint->getExit()->asFlow()->target.bb = elseClause;
- if (!bb->isTerminated())
- mkFlow(OP_BRA, NULL, CC_ALWAYS, NULL);
-
- setPosition(elseClause, true);
- }
- break;
- case SM4_OPCODE_ENDIF:
- {
- BasicBlock *convPoint = new BasicBlock(func);
- BasicBlock *lastBB = reinterpret_cast<BasicBlock *>(condBBs.pop().u.p);
- BasicBlock *forkPoint = reinterpret_cast<BasicBlock *>(joinBBs.pop().u.p);
-
- if (!bb->isTerminated()) {
- // we only want join if none of the clauses ended with CONT/BREAK/RET
- if (lastBB->getExit()->op == OP_BRA && joinBBs.getSize() < 6)
- insertConvergenceOps(convPoint, forkPoint);
- mkFlow(OP_BRA, convPoint, CC_ALWAYS, NULL);
- bb->cfg.attach(&convPoint->cfg, Graph::Edge::FORWARD);
- }
-
- if (lastBB->getExit()->op == OP_BRA) {
- lastBB->cfg.attach(&convPoint->cfg, Graph::Edge::FORWARD);
- lastBB->getExit()->asFlow()->target.bb = convPoint;
- }
- setPosition(convPoint, true);
- }
- break;
-
- case SM4_OPCODE_SWITCH:
- case SM4_OPCODE_CASE:
- case SM4_OPCODE_ENDSWITCH:
- assert(!"SWITCH/CASE/ENDSWITCH not implemented");
- break;
-
- case SM4_OPCODE_LOOP:
- {
- BasicBlock *loopHeader = new BasicBlock(func);
- BasicBlock *loopBreak = new BasicBlock(func);
-
- loopBBs.push(loopHeader);
- breakBBs.push(loopBreak);
- if (loopBBs.getSize() > func->loopNestingBound)
- func->loopNestingBound++;
-
- mkFlow(OP_PREBREAK, loopBreak, CC_ALWAYS, NULL);
-
- bb->cfg.attach(&loopHeader->cfg, Graph::Edge::TREE);
- setPosition(loopHeader, true);
- mkFlow(OP_PRECONT, loopHeader, CC_ALWAYS, NULL);
- }
- break;
- case SM4_OPCODE_ENDLOOP:
- {
- BasicBlock *loopBB = reinterpret_cast<BasicBlock *>(loopBBs.pop().u.p);
-
- if (!bb->isTerminated()) {
- mkFlow(OP_CONT, loopBB, CC_ALWAYS, NULL);
- bb->cfg.attach(&loopBB->cfg, Graph::Edge::BACK);
- }
- setPosition(reinterpret_cast<BasicBlock *>(breakBBs.pop().u.p), true);
- }
- break;
- case SM4_OPCODE_BREAK:
- {
- if (bb->isTerminated())
- break;
- BasicBlock *breakBB = reinterpret_cast<BasicBlock *>(breakBBs.peek().u.p);
- mkFlow(OP_BREAK, breakBB, CC_ALWAYS, NULL);
- bb->cfg.attach(&breakBB->cfg, Graph::Edge::CROSS);
- }
- break;
- case SM4_OPCODE_BREAKC:
- {
- BasicBlock *nextBB = new BasicBlock(func);
- BasicBlock *breakBB = reinterpret_cast<BasicBlock *>(breakBBs.peek().u.p);
- CondCode cc = insn->insn.test_nz ? CC_P : CC_NOT_P;
- mkFlow(OP_BREAK, breakBB, cc, src(0, 0));
- bb->cfg.attach(&breakBB->cfg, Graph::Edge::CROSS);
- bb->cfg.attach(&nextBB->cfg, Graph::Edge::FORWARD);
- setPosition(nextBB, true);
- }
- break;
- case SM4_OPCODE_CONTINUE:
- {
- if (bb->isTerminated())
- break;
- BasicBlock *contBB = reinterpret_cast<BasicBlock *>(loopBBs.peek().u.p);
- mkFlow(OP_CONT, contBB, CC_ALWAYS, NULL);
- contBB->explicitCont = true;
- bb->cfg.attach(&contBB->cfg, Graph::Edge::BACK);
- }
- break;
- case SM4_OPCODE_CONTINUEC:
- {
- BasicBlock *nextBB = new BasicBlock(func);
- BasicBlock *contBB = reinterpret_cast<BasicBlock *>(loopBBs.peek().u.p);
- mkFlow(OP_CONT, contBB, insn->insn.test_nz ? CC_P : CC_NOT_P, src(0, 0));
- bb->cfg.attach(&contBB->cfg, Graph::Edge::BACK);
- bb->cfg.attach(&nextBB->cfg, Graph::Edge::FORWARD);
- setPosition(nextBB, true);
- }
- break;
-
- case SM4_OPCODE_SAMPLE:
- case SM4_OPCODE_SAMPLE_C:
- case SM4_OPCODE_SAMPLE_C_LZ:
- case SM4_OPCODE_SAMPLE_L:
- case SM4_OPCODE_SAMPLE_D:
- case SM4_OPCODE_SAMPLE_B:
- handleSAMPLE(op, dst0);
- break;
- case SM4_OPCODE_LD:
- case SM4_OPCODE_LD_MS:
- handleLOAD(dst0);
- break;
-
- case SM4_OPCODE_GATHER4:
- assert(!"GATHER4 not implemented\n");
- break;
-
- case SM4_OPCODE_RESINFO:
- handleQUERY(dst0, TXQ_DIMS);
- break;
- case SM4_OPCODE_SAMPLE_POS:
- handleQUERY(dst0, TXQ_SAMPLE_POSITION);
- break;
-
- case SM4_OPCODE_NOP:
- mkOp(OP_NOP, TYPE_NONE, NULL);
- break;
-
- case SM4_OPCODE_HS_DECLS:
- // XXX: any significance ?
- break;
- case SM4_OPCODE_HS_CONTROL_POINT_PHASE:
- phase = 0;
- break;
- case SM4_OPCODE_HS_FORK_PHASE:
- if (phase != 1)
- subPhase = 0;
- phase = 1;
- phaseInstance = (phaseStart == pos) ? (phaseInstance + 1) : 0;
- phaseStart = pos;
- if (info.prop.tp.outputPatchSize < phaseInstCnt[0][subPhase])
- unrollPhase = true;
- break;
- case SM4_OPCODE_HS_JOIN_PHASE:
- if (phase != 2)
- subPhase = 0;
- phase = 2;
- phaseInstance = (phaseStart == pos) ? (phaseInstance + 1) : 0;
- phaseStart = pos;
- if (info.prop.tp.outputPatchSize < phaseInstCnt[1][subPhase])
- unrollPhase = true;
- break;
-
- default:
- ERROR("SM4_OPCODE_#%u illegal / not supported\n", insn->opcode);
- abort();
- return false;
- }
-
- for (c = 0; c < nc; ++c) {
- if (nDstOpnds >= 1 && rDst0[c]) {
- if (dst0[c] != rDst0[c])
- mkMov(rDst0[c], dst0[c]);
- saveDst(0, c, rDst0[c]);
- }
- if (nDstOpnds >= 2 && rDst1[c]) {
- if (dst1[c] != rDst1[c])
- mkMov(rDst1[c], dst1[c]);
- saveDst(1, c, rDst1[c]);
- }
- }
-
- memset(srcPtr, 0, sizeof(srcPtr));
- memset(dstPtr, 0, sizeof(dstPtr));
- memset(vtxBase, 0, sizeof(vtxBase));
- return true;
-}
-
-void
-Converter::exportOutputs()
-{
- for (int i = 0; i < info.numOutputs; ++i) {
- for (int c = 0; c < 4; ++c) {
- if (!oData.exists(i, c))
- continue;
- Symbol *sym = mkSymbol(FILE_SHADER_OUTPUT, 0, TYPE_F32,
- info.out[i].slot[c] * 4);
- Value *val = oData.load(i, c, NULL);
- if (val)
- mkStore(OP_EXPORT, TYPE_F32, sym, NULL, val);
- }
- }
-}
-
-Converter::Converter(Program *p, struct nv50_ir_prog_info *s)
- : tData32(this),
- tData64(this),
- oData(this),
- info(*s),
- sm4(*reinterpret_cast<const sm4_program *>(s->bin.source)),
- prog(p)
-{
- memset(srcPtr, 0, sizeof(srcPtr));
- memset(dstPtr, 0, sizeof(dstPtr));
- memset(vtxBase, 0, sizeof(vtxBase));
-
- memset(interpMode, 0, sizeof(interpMode));
-
- nrRegVals = nrArrays = arrayVol = 0;
-
- for (phase = 3; phase > 0; --phase)
- for (unsigned int i = 0; i < PIPE_MAX_SHADER_OUTPUTS; ++i)
- out[phase - 1][i].sn = TGSI_SEMANTIC_COUNT;
-
- unrollPhase = false;
- phaseStart = 0;
- subPhaseCnt[0] = subPhaseCnt[1] = 0;
-}
-
-Converter::~Converter()
-{
- if (lData)
- delete[] lData;
-
- if (subPhaseCnt[0])
- delete[] phaseInstCnt[0];
- if (subPhaseCnt[1])
- delete[] phaseInstCnt[1];
-}
-
-bool
-Converter::haveNextPhase(unsigned int pos) const
-{
- ++pos;
- return (pos < sm4.insns.size()) &&
- (sm4.insns[pos]->opcode == SM4_OPCODE_HS_FORK_PHASE ||
- sm4.insns[pos]->opcode == SM4_OPCODE_HS_JOIN_PHASE);
-}
-
-bool
-Converter::run()
-{
- parseSignature();
-
- for (unsigned int pos = 0; pos < sm4.dcls.size(); ++pos)
- inspectDeclaration(*sm4.dcls[pos]);
-
- phaseInstCnt[0] = new unsigned int [subPhaseCnt[0]];
- phaseInstCnt[1] = new unsigned int [subPhaseCnt[1]];
- for (int i = 0; i < subPhaseCnt[0]; ++i)
- phaseInstCnt[0][i] = -1;
- for (int i = 0; i < subPhaseCnt[1]; ++i)
- phaseInstCnt[1][i] = -1;
- // re-increased in handleDeclaration:
- subPhaseCnt[0] = subPhaseCnt[1] = 0;
-
- allocateValues();
- nrArrays = 0;
- for (unsigned int pos = 0; pos < sm4.dcls.size(); ++pos)
- handleDeclaration(*sm4.dcls[pos]);
-
- info.io.genUserClip = -1; // no UCPs permitted with SM4 shaders
- info.io.clipDistanceMask = (1 << info.io.clipDistanceMask) - 1;
-
- info.assignSlots(&info);
-
- if (sm4.dcls.size() == 0 && sm4.insns.size() == 0)
- return true;
-
- BasicBlock *entry = new BasicBlock(prog->main);
- BasicBlock *leave = new BasicBlock(prog->main);
-
- prog->main->setEntry(entry);
- prog->main->setExit(leave);
-
- setPosition(entry, true);
-
- entryBBs.push(entry);
- leaveBBs.push(leave);
-
- if (prog->getType() == Program::TYPE_FRAGMENT) {
- Symbol *sv = mkSysVal(SV_POSITION, 3);
- fragCoord[3] = mkOp1v(OP_RDSV, TYPE_F32, getSSA(), sv);
- mkOp1(OP_RCP, TYPE_F32, fragCoord[3], fragCoord[3]);
- } else
- if (prog->getType() == Program::TYPE_TESSELLATION_EVAL) {
- const int n = (info.prop.tp.domain == PIPE_PRIM_TRIANGLES) ? 3 : 2;
- int c;
- for (c = 0; c < n; ++c)
- domainPt[c] =
- mkOp1v(OP_RDSV, TYPE_F32, getSSA(), mkSysVal(SV_TESS_COORD, c));
- if (c == 2)
- domainPt[2] = loadImm(NULL, 0.0f);
- }
-
- finalized = false;
- phaseEnded = 0;
- phase = 0;
- subPhase = 0;
- for (unsigned int pos = 0; pos < sm4.insns.size(); ++pos) {
- handleInstruction(pos);
- if (likely(phase == 0) || (phaseEnded < 2))
- continue;
- phaseEnded = 0;
- if (!unrollPhase || !phaseInstanceUsed) {
- ++subPhase;
- continue;
- }
- phaseInstanceUsed = false;
- if (phaseInstance < (phaseInstCnt[phase - 1][subPhase] - 1))
- pos = phaseStart - 1;
- else
- ++subPhase;
- }
- finalizeShader();
-
- return true;
-}
-
-} // anonymous namespace
-
-namespace nv50_ir {
-
-bool
-Program::makeFromSM4(struct nv50_ir_prog_info *info)
-{
- Converter bld(this, info);
- return bld.run();
-}
-
-} // namespace nv50_ir
projects / mesa.git / commitdiff