| |
| #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 |
