nv50: Remove nv0_ir_from_sm4.*

Unused, depends on d3d1x.

Reviewed-by: Christoph Bumiller <[email protected]>

2 files changed, 0 insertions, 2512 deletions

diff --git a/src/gallium/drivers/nv50/codegen/nv50_ir_from_sm4.cpp b/src/gallium/drivers/nv50/codegen/nv50_ir_from_sm4.cpp
deleted file mode 100644
index 4f3189eade0..00000000000
--- a/src/gallium/drivers/nv50/codegen/nv50_ir_from_sm4.cpp
+++ /dev/null
@@ -1,2329 +0,0 @@
-
-#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
diff --git a/src/gallium/drivers/nv50/codegen/nv50_ir_from_sm4.h b/src/gallium/drivers/nv50/codegen/nv50_ir_from_sm4.h
deleted file mode 100644
index 3c7b55aa1d4..00000000000
--- a/src/gallium/drivers/nv50/codegen/nv50_ir_from_sm4.h
+++ /dev/null
@@ -1,183 +0,0 @@
-
-#ifndef __NV50_IR_FROM_SM4_H__
-#define __NV50_IR_FROM_SM4_H__
-
-typedef enum D3D_PRIMITIVE_TOPOLOGY {
-    D3D_PRIMITIVE_TOPOLOGY_UNDEFINED = 0,
-    D3D_PRIMITIVE_TOPOLOGY_POINTLIST = 1,
-    D3D_PRIMITIVE_TOPOLOGY_LINELIST = 2,
-    D3D_PRIMITIVE_TOPOLOGY_LINESTRIP = 3,
-    D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST = 4,
-    D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = 5,
-    D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10,
-    D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = 11,
-    D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = 12,
-    D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = 13,
-    D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = 33,
-    D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST = 34,
-    D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST = 35,
-    D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST = 36,
-    D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST = 37,
-    D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST = 38,
-    D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST = 39,
-    D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST = 40,
-    D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST = 41,
-    D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST = 42,
-    D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST = 43,
-    D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST = 44,
-    D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST = 45,
-    D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST = 46,
-    D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST = 47,
-    D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST = 48,
-    D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST = 49,
-    D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST = 50,
-    D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST = 51,
-    D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST = 52,
-    D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST = 53,
-    D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST = 54,
-    D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST = 55,
-    D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST = 56,
-    D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST = 57,
-    D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST = 58,
-    D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST = 59,
-    D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST = 60,
-    D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST = 61,
-    D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST = 62,
-    D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST = 63,
-    D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST = 64,
-} D3D_PRIMITIVE_TOPOLOGY;
-
-typedef enum D3D_RESOURCE_RETURN_TYPE {
-    D3D_RETURN_TYPE_UNORM = 1,
-    D3D_RETURN_TYPE_SNORM = 2,
-    D3D_RETURN_TYPE_SINT = 3,
-    D3D_RETURN_TYPE_UINT = 4,
-    D3D_RETURN_TYPE_FLOAT = 5,
-    D3D_RETURN_TYPE_MIXED = 6,
-    D3D_RETURN_TYPE_DOUBLE = 7,
-    D3D_RETURN_TYPE_CONTINUED = 8,
-    D3D10_RETURN_TYPE_UNORM = 1,
-    D3D10_RETURN_TYPE_SNORM = 2,
-    D3D10_RETURN_TYPE_SINT = 3,
-    D3D10_RETURN_TYPE_UINT = 4,
-    D3D10_RETURN_TYPE_FLOAT = 5,
-    D3D10_RETURN_TYPE_MIXED = 6,
-    D3D11_RETURN_TYPE_UNORM = 1,
-    D3D11_RETURN_TYPE_SNORM = 2,
-    D3D11_RETURN_TYPE_SINT = 3,
-    D3D11_RETURN_TYPE_UINT = 4,
-    D3D11_RETURN_TYPE_FLOAT = 5,
-    D3D11_RETURN_TYPE_MIXED = 6,
-    D3D11_RETURN_TYPE_DOUBLE = 7,
-    D3D11_RETURN_TYPE_CONTINUED = 8
-} D3D_RESOURCE_RETURN_TYPE;
-
-typedef enum D3D_REGISTER_COMPONENT_TYPE {
-    D3D_REGISTER_COMPONENT_UNKNOWN = 0,
-    D3D_REGISTER_COMPONENT_UINT32 = 1,
-    D3D_REGISTER_COMPONENT_SINT32 = 2,
-    D3D_REGISTER_COMPONENT_FLOAT32 = 3,
-    D3D10_REGISTER_COMPONENT_UNKNOWN = 0,
-    D3D10_REGISTER_COMPONENT_UINT32 = 1,
-    D3D10_REGISTER_COMPONENT_SINT32 = 2,
-    D3D10_REGISTER_COMPONENT_FLOAT32 = 3
-} D3D_REGISTER_COMPONENT_TYPE;
-
-typedef enum D3D_TESSELLATOR_DOMAIN {
-    D3D_TESSELLATOR_DOMAIN_UNDEFINED = 0,
-    D3D_TESSELLATOR_DOMAIN_ISOLINE = 1,
-    D3D_TESSELLATOR_DOMAIN_TRI = 2,
-    D3D_TESSELLATOR_DOMAIN_QUAD = 3,
-    D3D11_TESSELLATOR_DOMAIN_UNDEFINED = 0,
-    D3D11_TESSELLATOR_DOMAIN_ISOLINE = 1,
-    D3D11_TESSELLATOR_DOMAIN_TRI = 2,
-    D3D11_TESSELLATOR_DOMAIN_QUAD = 3
-} D3D_TESSELLATOR_DOMAIN;
-
-typedef enum D3D_TESSELLATOR_PARTITIONING {
-    D3D_TESSELLATOR_PARTITIONING_UNDEFINED = 0,
-    D3D_TESSELLATOR_PARTITIONING_INTEGER = 1,
-    D3D_TESSELLATOR_PARTITIONING_POW2 = 2,
-    D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD = 3,
-    D3D_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = 4,
-    D3D11_TESSELLATOR_PARTITIONING_UNDEFINED = 0,
-    D3D11_TESSELLATOR_PARTITIONING_INTEGER = 1,
-    D3D11_TESSELLATOR_PARTITIONING_POW2 = 2,
-    D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD = 3,
-    D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN = 4
-} D3D_TESSELLATOR_PARTITIONING;
-
-typedef enum D3D_TESSELLATOR_OUTPUT_PRIMITIVE {
-    D3D_TESSELLATOR_OUTPUT_UNDEFINED = 0,
-    D3D_TESSELLATOR_OUTPUT_POINT = 1,
-    D3D_TESSELLATOR_OUTPUT_LINE = 2,
-    D3D_TESSELLATOR_OUTPUT_TRIANGLE_CW = 3,
-    D3D_TESSELLATOR_OUTPUT_TRIANGLE_CCW = 4,
-    D3D11_TESSELLATOR_OUTPUT_UNDEFINED = 0,
-    D3D11_TESSELLATOR_OUTPUT_POINT = 1,
-    D3D11_TESSELLATOR_OUTPUT_LINE = 2,
-    D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CW = 3,
-    D3D11_TESSELLATOR_OUTPUT_TRIANGLE_CCW = 4
-} D3D_TESSELLATOR_OUTPUT_PRIMITIVE;
-
-typedef enum D3D_NAME {
-    D3D_NAME_UNDEFINED = 0,
-    D3D_NAME_POSITION = 1,
-    D3D_NAME_CLIP_DISTANCE = 2,
-    D3D_NAME_CULL_DISTANCE = 3,
-    D3D_NAME_RENDER_TARGET_ARRAY_INDEX = 4,
-    D3D_NAME_VIEWPORT_ARRAY_INDEX = 5,
-    D3D_NAME_VERTEX_ID = 6,
-    D3D_NAME_PRIMITIVE_ID = 7,
-    D3D_NAME_INSTANCE_ID = 8,
-    D3D_NAME_IS_FRONT_FACE = 9,
-    D3D_NAME_SAMPLE_INDEX = 10,
-    D3D_NAME_FINAL_QUAD_EDGE_TESSFACTOR = 11,
-    D3D_NAME_FINAL_QUAD_INSIDE_TESSFACTOR = 12,
-    D3D_NAME_FINAL_TRI_EDGE_TESSFACTOR = 13,
-    D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR = 14,
-    D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR = 15,
-    D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR = 16,
-    D3D_NAME_TARGET = 64,
-    D3D_NAME_DEPTH = 65,
-    D3D_NAME_COVERAGE = 66,
-    D3D_NAME_DEPTH_GREATER_EQUAL = 67,
-    D3D_NAME_DEPTH_LESS_EQUAL = 68,
-    D3D10_NAME_UNDEFINED = 0,
-    D3D10_NAME_POSITION = 1,
-    D3D10_NAME_CLIP_DISTANCE = 2,
-    D3D10_NAME_CULL_DISTANCE = 3,
-    D3D10_NAME_RENDER_TARGET_ARRAY_INDEX = 4,
-    D3D10_NAME_VIEWPORT_ARRAY_INDEX = 5,
-    D3D10_NAME_VERTEX_ID = 6,
-    D3D10_NAME_PRIMITIVE_ID = 7,
-    D3D10_NAME_INSTANCE_ID = 8,
-    D3D10_NAME_IS_FRONT_FACE = 9,
-    D3D10_NAME_SAMPLE_INDEX = 10,
-    D3D11_NAME_FINAL_QUAD_EDGE_TESSFACTOR = 11,
-    D3D11_NAME_FINAL_QUAD_INSIDE_TESSFACTOR = 12,
-    D3D11_NAME_FINAL_TRI_EDGE_TESSFACTOR = 13,
-    D3D11_NAME_FINAL_TRI_INSIDE_TESSFACTOR = 14,
-    D3D11_NAME_FINAL_LINE_DETAIL_TESSFACTOR = 15,
-    D3D11_NAME_FINAL_LINE_DENSITY_TESSFACTOR = 16,
-    D3D10_NAME_TARGET = 64,
-    D3D10_NAME_DEPTH = 65,
-    D3D10_NAME_COVERAGE = 66,
-    D3D11_NAME_DEPTH_GREATER_EQUAL = 67,
-    D3D11_NAME_DEPTH_LESS_EQUAL = 68
-} D3D_NAME;
-
-typedef struct _D3D11_SIGNATURE_PARAMETER_DESC {
-    const char* SemanticName;
-    unsigned int SemanticIndex;
-    unsigned int Register;
-    D3D_NAME SystemValueType;
-    D3D_REGISTER_COMPONENT_TYPE ComponentType;
-    unsigned char Mask;
-    unsigned char ReadWriteMask;
-    unsigned int Stream;
-} D3D11_SIGNATURE_PARAMETER_DESC;
-
-#include "../../../state_trackers/d3d1x/d3d1xshader/include/sm4.h"
-
-#endif // __NV50_IR_FROM_SM4_H__