#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdint.h>

#define MAXINST 1000

const char *rel[2] = {
	"ABSOLUTE",
	"RELATIVE"
};

const char *im[5] = {
	"SQ_INDEX_AR_X",
	"SQ_INDEX_AR_Y",
	"SQ_INDEX_AR_Z",
	"SQ_INDEX_AR_W",
	"SQ_INDEX_LOOP",
};

const char *ps[4] = {
	"SQ_PRED_SEL_OFF",
	"Reserved",
	"SQ_PRED_SEL_ZERO",
	"SQ_PRED_SEL_ONE"
};

const char *elem[4] = {
	"ELEM_X",
	"ELEM_Y",
	"ELEM_Z",
	"ELEM_W",
};

const char *omod[4] = {
	"SQ_ALU_OMOD_OFF",
	"SQ_ALU_OMOD_M2",
	"SQ_ALU_OMOD_M4",
	"SQ_ALU_OMOD_D2",
};

const char *bs[6] = {
	"SQ_ALU_VEC_012",
	"SQ_ALU_VEC_021",
	"SQ_ALU_VEC_120",
	"SQ_ALU_VEC_102",
	"SQ_ALU_VEC_201",
	"SQ_ALU_VEC_210",
};

const char *op2[122] = {
	"SQ_OP2_INST_ADD", //0
	"SQ_OP2_INST_MUL", //1
	"SQ_OP2_INST_MUL_IEEE", //2
	"SQ_OP2_INST_MAX", //3
	"SQ_OP2_INST_MIN", //4
	"SQ_OP2_INST_MAX_DX10", //5
	"SQ_OP2_INST_MIN_DX10", //6
	"reserved", //7
	"SQ_OP2_INST_SETE", //8
	"SQ_OP2_INST_SETGT", //9
	"SQ_OP2_INST_SETGE", //10
	"SQ_OP2_INST_SETNE", //11
	"SQ_OP2_INST_SETE_DX10", //12
	"SQ_OP2_INST_SETGT_DX10", //13
	"SQ_OP2_INST_SETGE_DX10", //14
	"SQ_OP2_INST_SETNE_DX10", //15
	"SQ_OP2_INST_FRACT", //16
	"SQ_OP2_INST_TRUNC", //17
	"SQ_OP2_INST_CEIL", //18
	"SQ_OP2_INST_RNDNE", //19
	"SQ_OP2_INST_FLOOR", //20
	"SQ_OP2_INST_MOVA", //21
	"SQ_OP2_INST_MOVA_FLOOR", //22
	"reserved", //23
	"SQ_OP2_INST_MOVA_INT", //24
	"SQ_OP2_INST_MOV", //25
	"SQ_OP2_INST_NOP", //26
	"reserved", //27
	"reserved", //28
	"reserved", //29
	"SQ_OP2_INST_PRED_SETGT_UINT", //30
	"SQ_OP2_INST_PRED_SETGE_UINT", //31
	"SQ_OP2_INST_PRED_SETE",  //32
	"SQ_OP2_INST_PRED_SETGT", //33
	"SQ_OP2_INST_PRED_SETGE", //34
	"SQ_OP2_INST_PRED_SETNE", //35
	"SQ_OP2_INST_PRED_SET_INV", //36
	"SQ_OP2_INST_PRED_SET_POP", //37
	"SQ_OP2_INST_PRED_SET_CLR", //38
	"SQ_OP2_INST_PRED_SET_RESTORE", //39
	"SQ_OP2_INST_PRED_SETE_PUSH", //40
	"SQ_OP2_INST_PRED_SETGT_PUSH", //41
	"SQ_OP2_INST_PRED_SETGE_PUSH", //42
	"SQ_OP2_INST_PRED_SETNE_PUSH", //43
	"SQ_OP2_INST_KILLE", //44
	"SQ_OP2_INST_KILLGT", //45
	"SQ_OP2_INST_KILLGE", //46
	"SQ_OP2_INST_KILLNE", //47
	"SQ_OP2_INST_AND_INT", //48
	"SQ_OP2_INST_OR_INT", //49
	"SQ_OP2_INST_XOR_INT", //50
	"SQ_OP2_INST_NOT_INT", //51
	"SQ_OP2_INST_ADD_INT", //52
	"SQ_OP2_INST_SUB_INT", //53
	"SQ_OP2_INST_MAX_INT", //54
	"SQ_OP2_INST_MIN_INT", //55
	"SQ_OP2_INST_MAX_UINT", //56
	"SQ_OP2_INST_MIN_UINT", //57
	"SQ_OP2_INST_SETE_INT", //58
	"SQ_OP2_INST_SETGT_INT", //59
	"SQ_OP2_INST_SETGE_INT", //60
	"SQ_OP2_INST_SETNE_INT", //61
	"SQ_OP2_INST_SETGT_UINT", //62
	"SQ_OP2_INST_SETGE_UINT", //63
	"SQ_OP2_INST_KILLGT_UINT", //64
	"SQ_OP2_INST_KILLGE_UINT", //65
	"SQ_OP2_INST_PRED_SETE_INT", //66
	"SQ_OP2_INST_PRED_SETGT_INT", //67
	"SQ_OP2_INST_PRED_SETGE_INT", //68
	"SQ_OP2_INST_PRED_SETNE_INT", //69
	"SQ_OP2_INST_PRED_SETLT_INT", //70
	"SQ_OP2_INST_PRED_SETLE_INT", //71
	"SQ_OP2_INST_KILLGE_INT", //72
	"SQ_OP2_INST_KILLNE_INT", //73
	"SQ_OP2_INST_PRED_SETE_PUSH_INT", //74
	"SQ_OP2_INST_PRED_SETGT_PUSH_INT", //75
	"SQ_OP2_INST_PRED_SETGE_PUSH_INT", //76
	"SQ_OP2_INST_PRED_SETNE_PUSH_INT", //77
	"SQ_OP2_INST_PRED_SETLT_PUSH_INT", //78
	"SQ_OP2_INST_PRED_SETLE_PUSH_INT", //79
	"SQ_OP2_INST_DOT4", //80
	"SQ_OP2_INST_DOT4_IEEE", //81
	"SQ_OP2_INST_CUBE", //82
	"SQ_OP2_INST_MAX4", //83
	"invalid", //84
	"invalid", //85
	"invalid", //86
	"invalid", //87
	"invalid", //88
	"invalid", //89
	"invalid", //90
	"invalid", //91
	"invalid", //92
	"invalid", //93
	"invalid", //94
	"invalid", //95
	"SQ_OP2_INST_MOVA_GPR_INT", //96
	"SQ_OP2_INST_EXP_IEEE", //97
	"SQ_OP2_INST_LOG_CLAMPED", //98
	"SQ_OP2_INST_LOG_IEEE", //99
	"SQ_OP2_INST_RECIP_CLAMPED", //100
	"SQ_OP2_INST_RECIP_FF", //101
	"SQ_OP2_INST_RECIP_IEEE", //102
	"SQ_OP2_INST_RECIPSQRT_CLAMPED", //103
	"SQ_OP2_INST_RECIPSQRT_FF", //104
	"SQ_OP2_INST_RECIPSQRT_IEEE", //105
	"SQ_OP2_INST_SQRT_IEEE", //106
	"SQ_OP2_INST_FLT_TO_INT", //107
	"SQ_OP2_INST_INT_TO_FLT", //108
	"SQ_OP2_INST_UINT_TO_FLT", //109
	"SQ_OP2_INST_SIN", //110
	"SQ_OP2_INST_COS", //111
	"SQ_OP2_INST_ASHR_INT", //112
	"SQ_OP2_INST_LSHR_INT", //113
	"SQ_OP2_INST_LSHL_INT", //114
	"SQ_OP2_INST_MULLO_INT", //115
	"SQ_OP2_INST_MULHI_INT", //116
	"SQ_OP2_INST_MULLO_UINT", //117
	"SQ_OP2_INST_MULHI_UINT", //118
	"SQ_OP2_INST_RECIP_INT", //119
	"SQ_OP2_INST_RECIP_UINT", //120
	"SQ_OP2_INST_FLT_TO_UINT", //121
};

const char *op3[32] = {
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"reserved",
	"reserved",
	"reserved",
	"reserved",
	"SQ_OP3_INST_MUL_LIT",
	"SQ_OP3_INST_MUL_LIT_M2",
	"SQ_OP3_INST_MUL_LIT_M4",
	"SQ_OP3_INST_MUL_LIT_D2",
	"SQ_OP3_INST_MULADD",
	"SQ_OP3_INST_MULADD_M2",
	"SQ_OP3_INST_MULADD_M4",
	"SQ_OP3_INST_MULADD_D2",
	"SQ_OP3_INST_MULADD_IEEE",
	"SQ_OP3_INST_MULADD_IEEE_M2",
	"SQ_OP3_INST_MULADD_IEEE_M4",
	"SQ_OP3_INST_MULADD_IEEE_D2",
	"SQ_OP3_INST_CNDE",
	"SQ_OP3_INST_CNDGT",
	"SQ_OP3_INST_CNDGE",
	"reserved",
	"SQ_OP3_INST_CNDE_INT",
	"SQ_OP3_INST_CNDGT_INT",
	"SQ_OP3_INST_CNDGE_INT",
	"reserved",
};

const char *cond[4] = {
	"SQ_CF_COND_ACTIVE",
	"SQ_CF_COND_FALSE",
	"SQ_CF_COND_BOOL",
	"SQ_CF_COND_NOT_BOOL",
};

const char *cf_op[25] = {
	"SQ_CF_INST_NOP",
	"SQ_CF_INST_TEX",
	"SQ_CF_INST_VTX",
	"SQ_CF_INST_VTX_TC",
	"SQ_CF_INST_LOOP_START",
	"SQ_CF_INST_LOOP_END",
	"SQ_CF_INST_START_DX10",
	"SQ_CF_INST_START_NO_AL",
	"SQ_CF_INST_LOOP_CONTINUE",
	"SQ_CF_INST_LOOP_BREAK",
	"SQ_CF_INST_JUMP",
	"SQ_CF_INST_PUSH",
	"SQ_CF_INST_PUSH_ELSE",
	"SQ_CF_INST_ELSE",
	"SQ_CF_INST_POP",
	"SQ_CF_INST_POP_JUMP",
	"SQ_CF_INST_POP_PUSH",
	"SQ_CF_INST_POP_PUSH_ELSE",
	"SQ_CF_INST_CALL",
	"SQ_CF_CALL_FS",
	"SQ_CF_INST_RETURN",
	"SQ_CF_INST_EMIT_VERTEX",
	"SQ_CF_INST_EMIT_CUT_VERTEX",
	"SQ_CF_INST_CUT_VERTEX",
	"SQ_CF_INST_KILL",
};


const char *cf_alu_op[16] = {
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"SQ_CF_INST_ALU",
	"SQ_CF_INST_ALU_PUSH_BEFORE",
	"SQ_CF_INST_ALU_POP_AFTER",
	"SQ_CF_INST_ALU_POP2_AFTER",
	"reserved",
	"SQ_CF_INST_ALU_CONTINUE",
	"SQ_CF_INST_ALU_BREAK",
	"SQ_CF_INST_ALU_ELSE_AFTER",
};

const char *cf_exp_op[41] = {
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"SQ_CF_INST_MEM_STREAM0",
	"SQ_CF_INST_MEM_STREAM1",
	"SQ_CF_INST_MEM_STREAM2",
	"SQ_CF_INST_MEM_STREAM3",
	"SQ_CF_INST_MEM_SCRATCH",
	"SQ_CF_INST_MEM_REDUCTION",
	"SQ_CF_INST_MEM_RING",
	"SQ_CF_INST_EXPORT",
	"SQ_CF_INST_EXPORT_DONE",
};

const char *km[4] = {
	"SQ_CF_KCACHE_NOP",
	"SQ_CF_KCACHE_LOCK_1",
	"SQ_CF_KCACHE_LOCK_2",
	"SQ_CF_KCACHE_LOCK_LOOP_INDEX",
};

const char *sel[8] = {
	"SQ_SEL_X",
	"SQ_SEL_Y",
	"SQ_SEL_Z",
	"SQ_SEL_W",
	"SQ_SEL_0",
	"SQ_SEL_1",
	"reserved",
	"SQ_SEL_MASK",
};

const char *cf_exp_type[8] = {
	"SQ_EXPORT_PIXEL",
	"SQ_EXPORT_POS",
	"SQ_EXPORT_PARAM",
	"unused",
};

const char *cf_mem_type[8] = {
	"SQ_EXPORT_WRITE",
	"SQ_EXPORT_WRITE_IND",
	"SQ_IMPORT_READ",
	"SQ_IMPORT_READ_IND",
};

const char *ab_pixel[62] = {
	"CF_PIXEL_MRT0",
	"CF_PIXEL_MRT1",
	"CF_PIXEL_MRT2",
	"CF_PIXEL_MRT3",
	"CF_PIXEL_MRT4",
	"CF_PIXEL_MRT5",
	"CF_PIXEL_MRT6",
	"CF_PIXEL_MRT7",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"CF_PIXEL_MRT0_FOG",
	"CF_PIXEL_MRT1_FOG",
	"CF_PIXEL_MRT2_FOG",
	"CF_PIXEL_MRT3_FOG",
	"CF_PIXEL_MRT4_FOG",
	"CF_PIXEL_MRT5_FOG",
	"CF_PIXEL_MRT6_FOG",
	"CF_PIXEL_MRT7_FOG",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"CF_PIXEL_Z",
};

const char *ab_pos[64] = {
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"invalid",
	"CF_POS0",
	"CF_POS1",
	"CF_POS2",
	"CF_POS3",
};

const char *tex_op[32] = {
	"SQ_TEX_INST_VTX_FETCH",
	"SQ_TEX_INST_VTX_SEMANTIC",
	"reserved",
	"SQ_TEX_INST_LD",
	"SQ_TEX_INST_GET_TEXTURE_RESINFO",
	"SQ_TEX_INST_GET_NUMBER_OF_SAMPLES",
	"SQ_TEX_INST_GET_LOD",
	"SQ_TEX_INST_GET_GRADIENTS_H",
	"SQ_TEX_INST_GET_GRADIENTS_V",
	"SQ_TEX_INST_GET_LERP",
	"reserved",
	"SQ_TEX_INST_SET_GRADIENTS_H",
	"SQ_TEX_INST_SET_GRADIENTS_V",
	"SQ_TEX_INST_PASS",
	"Z set index for array of cubemaps",
	"reserved",
	"SQ_TEX_INST_SAMPLE",
	"SQ_TEX_INST_SAMPLE_L",
	"SQ_TEX_INST_SAMPLE_LB",
	"SQ_TEX_INST_SAMPLE_LZ",
	"SQ_TEX_INST_SAMPLE_G",
	"SQ_TEX_INST_SAMPLE_G_L",
	"SQ_TEX_INST_SAMPLE_G_LB",
	"SQ_TEX_INST_SAMPLE_G_LZ",
	"SQ_TEX_INST_SAMPLE_C",
	"SQ_TEX_INST_SAMPLE_C_L",
	"SQ_TEX_INST_SAMPLE_C_LB",
	"SQ_TEX_INST_SAMPLE_C_LZ",
	"SQ_TEX_INST_SAMPLE_C_G",
	"SQ_TEX_INST_SAMPLE_C_G_L",
	"SQ_TEX_INST_SAMPLE_C_G_LB",
	"SQ_TEX_INST_SAMPLE_C_G_LZ",
};

const char *coord_type[2] = {
	"TEX_UNNORMALIZED",
	"TEX_NORMALIZED",
};

const char *vtx_op[2] = {
	"SQ_VTX_INST_FETCH",
	"SQ_VTX_INST_SEMANTIC",
};

const char *fetch_type[3] = {
	"SQ_VTX_FETCH_VERTEX_DATA",
	"SQ_VTX_FETCH_INSTANCE_DATA",
	"SQ_VTX_FETCH_NO_INDEX_OFFSET",
};

const char *num_format_all[3] = {
	"SQ_NUM_FORMAT_NORM",
	"SQ_NUM_FORMAT_INT",
	"SQ_NUM_FORMAT_SCALED",
};

const char *format_comp_all[2] = {
	"SQ_FORMAT_COMP_UNSIGNED",
	"SQ_FORMAT_COMP_SIGNED",
};

const char *srf_mode_all[2] = {
	"SRF_MODE_ZERO_CLAMP_MINUS_ONE",
	"SRF_MODE_NO_ZERO",
};

const char *endian_swap[3] = {
	"SQ_ENDIAN_NONE",
	"SQ_ENDIAN_8IN16",
	"SQ_ENDIAN_8IN32",
};

void alu_dword1_op3(uint32_t dword1, int is_r700)
{
	int src2_sel, src2_rel;
	int src2_elem, src2_neg;
	int alu_inst;
	int bank_swizzle, dst_gpr, dst_rel;
	int dst_elem, clamp;

	src2_sel = (dword1 >> 0) & 0x1ff;
	src2_rel = (dword1 >> 9) & 0x1;
	src2_elem = (dword1 >> 10) & 0x3;
	src2_neg = (dword1 >> 12) & 0x1;

	printf("ALU_DWORD1_OP3(");
	if (is_r700) {
		if (src2_sel == 248)
			printf("SRC2_SEL(SQ_ALU_SRC_0),\n");
		else if (src2_sel == 249)
			printf("SRC2_SEL(SQ_ALU_SRC_1),\n");
		else if (src2_sel == 250)
			printf("SRC2_SEL(SQ_ALU_SRC_I_INT),\n");
		else if (src2_sel == 251)
			printf("SRC2_SEL(SQ_ALU_SRC_M_1_INT),\n");
		else if (src2_sel == 252)
			printf("SRC2_SEL(SQ_ALU_SRC_0_5),\n");
		else if (src2_sel == 253)
			printf("SRC2_SEL(SQ_ALU_SRC_LITERAL),\n");
		else if (src2_sel == 254)
			printf("SRC2_SEL(SQ_ALU_SRC_PV),\n");
		else if (src2_sel == 255)
			printf("SRC2_SEL(SQ_ALU_SRC_PS),\n");
		else
			printf("SRC2_SEL(%d),\n", src2_sel);
	} else {
		if (src2_sel == 248)
			printf("SRC2_SEL(ALU_SRC_0),\n");
		else if (src2_sel == 249)
			printf("SRC2_SEL(ALU_SRC_1),\n");
		else if (src2_sel == 250)
			printf("SRC2_SEL(ALU_SRC_I_INT),\n");
		else if (src2_sel == 251)
			printf("SRC2_SEL(ALU_SRC_M_1_INT),\n");
		else if (src2_sel == 252)
			printf("SRC2_SEL(ALU_SRC_0_5),\n");
		else if (src2_sel == 253)
			printf("SRC2_SEL(ALU_SRC_LITERAL),\n");
		else if (src2_sel == 254)
			printf("SRC2_SEL(ALU_SRC_PV),\n");
		else if (src2_sel == 255)
			printf("SRC2_SEL(ALU_SRC_PS),\n");
		else
			printf("SRC2_SEL(%d),\n", src2_sel);
	}
	printf("\tSRC2_REL(%s),\n", rel[src2_rel]);
	printf("\tSRC2_ELEM(%s),\n", elem[src2_elem]);
	printf("\tSRC2_NEG(%d),\n", src2_neg);

	alu_inst = (dword1 >> 13) & 0x1f;
	printf("\tALU_INST(%s),\n", op3[alu_inst]);
	bank_swizzle = (dword1 >> 18) & 0x7;
	printf("\tBANK_SWIZZLE(%s),\n", bs[bank_swizzle]);
	dst_gpr = (dword1 >> 21) & 0x7f;
	printf("\tDST_GPR(%d),\n", dst_gpr);
	dst_rel = (dword1 >> 28) & 0x1;
	printf("\tDST_REL(%s),\n", rel[dst_rel]);
	dst_elem = (dword1 >> 29) & 0x3;
	printf("\tDST_ELEM(%s),\n", elem[dst_elem]);
	clamp = (dword1 >> 31) & 0x1;
	printf("\tCLAMP(%d)", clamp);
	printf("),\n");
}

void alu_dword1_op2(uint32_t dword1, int is_r700)
{
	int src0_abs, src1_abs;
	int update_execute_mask, update_pred;
	int write_mask, fog_merge;
	int outmod, alu_inst;
	int bank_swizzle, dst_gpr, dst_rel;
	int dst_elem, clamp;

	printf("ALU_DWORD1_OP2(");
	printf("adapt->chipset,\n");
	src0_abs = (dword1 >> 0) & 0x1;
	printf("\tSRC0_ABS(%d),\n", src0_abs);
	src1_abs = (dword1 >> 1) & 0x1;
	printf("\tSRC1_ABS(%d),\n", src1_abs);
	update_execute_mask = (dword1 >> 2) & 0x1;
	printf("\tUPDATE_EXECUTE_MASK(%d),\n", update_execute_mask);
	update_pred = (dword1 >> 3) & 0x1;
	printf("\tUPDATE_PRED(%d),\n", update_pred);
	write_mask = (dword1 >> 4) & 0x1;
	printf("\tWRITE_MASK(%d),\n", write_mask);
	if (is_r700) {
		printf("\tFOG_MERGE(0),\n");
		outmod = (dword1 >> 5) & 0x3;
		printf("\tOMOD(%s),\n", omod[outmod]);
		alu_inst = (dword1 >> 7) & 0x7ff;
		printf("\tALU_INST(%s),\n", op2[alu_inst]);
	} else {
		fog_merge = (dword1 >> 5) & 0x1;
		printf("\tFOG_MERGE(%d),\n", fog_merge);
		outmod = (dword1 >> 6) & 0x3;
		printf("\tOMOD(%s),\n", omod[outmod]);
		alu_inst = (dword1 >> 8) & 0x3ff;
		printf("\tALU_INST(%s),\n", op2[alu_inst]);
	}
	bank_swizzle = (dword1 >> 18) & 0x7;
	printf("\tBANK_SWIZZLE(%s),\n", bs[bank_swizzle]);
	dst_gpr = (dword1 >> 21) & 0x7f;
	printf("\tDST_GPR(%d),\n", dst_gpr);
	dst_rel = (dword1 >> 28) & 0x1;
	printf("\tDST_REL(%s),\n", rel[dst_rel]);
	dst_elem = (dword1 >> 29) & 0x3;
	printf("\tDST_ELEM(%s),\n", elem[dst_elem]);
	clamp = (dword1 >> 31) & 0x1;
	printf("\tCLAMP(%d)", clamp);
	printf("),\n");
}

void alu_dword0(uint32_t dword0, int is_r700)
{
	int src0_sel, src1_sel;
	int src0_rel, src1_rel;
	int src0_elem, src1_elem;
	int src0_neg, src1_neg;
	int index_mode, pred_sel, last;

	src0_sel = (dword0 >> 0) & 0x1ff;
	src1_sel = (dword0 >> 13) & 0x1ff;

	src0_rel = (dword0 >> 9) & 0x1;
	src1_rel = (dword0 >> 22) & 0x1;

	src0_elem = (dword0 >> 10) & 0x3;
	src1_elem = (dword0 >> 23) & 0x3;

	src0_neg = (dword0 >> 12) & 0x1;
	src1_neg = (dword0 >> 25) & 0x1;

	index_mode = (dword0 >> 26) & 0x7;
	pred_sel = (dword0 >> 29) & 0x3;
	last = (dword0 >> 31) & 0x1;

	printf("ALU_DWORD0(");
	if (is_r700) {
		if (src0_sel == 248)
			printf("SRC0_SEL(SQ_ALU_SRC_0),\n");
		else if (src0_sel == 249)
			printf("SRC0_SEL(SQ_ALU_SRC_1),\n");
		else if (src0_sel == 250)
			printf("SRC0_SEL(SQ_ALU_SRC_I_INT),\n");
		else if (src0_sel == 251)
			printf("SRC0_SEL(SQ_ALU_SRC_M_1_INT),\n");
		else if (src0_sel == 252)
			printf("SRC0_SEL(SQ_ALU_SRC_0_5),\n");
		else if (src0_sel == 253)
			printf("SRC0_SEL(SQ_ALU_SRC_LITERAL),\n");
		else if (src0_sel == 254)
			printf("SRC0_SEL(SQ_ALU_SRC_PV),\n");
		else if (src0_sel == 255)
			printf("SRC0_SEL(SQ_ALU_SRC_PS),\n");
		else
			printf("SRC0_SEL(%d),\n", src0_sel);
	} else {
		if (src0_sel == 248)
			printf("SRC0_SEL(SQ_ALU_SRC_0),\n");
		else if (src0_sel == 249)
			printf("SRC0_SEL(SQ_ALU_SRC_1),\n");
		else if (src0_sel == 250)
			printf("SRC0_SEL(SQ_ALU_SRC_I_INT),\n");
		else if (src0_sel == 251)
			printf("SRC0_SEL(SQ_ALU_SRC_M_1_INT),\n");
		else if (src0_sel == 252)
			printf("SRC0_SEL(SQ_ALU_SRC_0_5),\n");
		else if (src0_sel == 253)
			printf("SRC0_SEL(SQ_ALU_SRC_LITERAL),\n");
		else if (src0_sel == 254)
			printf("SRC0_SEL(SQ_ALU_SRC_PV),\n");
		else if (src0_sel == 255)
			printf("SRC0_SEL(SQ_ALU_SRC_PS),\n");
		else
			printf("SRC0_SEL(%d),\n", src0_sel);
	}
	printf("\tSRC0_REL(%s),\n", rel[src0_rel]);
	printf("\tSRC0_ELEM(%s),\n", elem[src0_elem]);
	printf("\tSRC0_NEG(%d),\n", src0_neg);

	if (is_r700) {
		if (src1_sel == 248)
			printf("\tSRC1_SEL(SQ_ALU_SRC_0),\n");
		else if (src1_sel == 249)
			printf("\tSRC1_SEL(SQ_ALU_SRC_1),\n");
		else if (src1_sel == 250)
			printf("\tSRC1_SEL(SQ_ALU_SRC_I_INT),\n");
		else if (src1_sel == 251)
			printf("\tSRC1_SEL(SQ_ALU_SRC_M_1_INT),\n");
		else if (src1_sel == 252)
			printf("\tSRC0_SEL(SQ_ALU_SRC_0_5),\n");
		else if (src1_sel == 253)
			printf("\tSRC1_SEL(SQ_ALU_SRC_LITERAL),\n");
		else if (src1_sel == 254)
			printf("\tSRC1_SEL(SQ_ALU_SRC_PV),\n");
		else if (src1_sel == 255)
			printf("\tSRC1_SEL(SQ_ALU_SRC_PS),\n");
		else
			printf("\tSRC1_SEL(%d),\n", src1_sel);
	} else {
		if (src1_sel == 248)
			printf("\tSRC1_SEL(SQ_ALU_SRC_0),\n");
		else if (src1_sel == 249)
			printf("\tSRC1_SEL(SQ_ALU_SRC_1),\n");
		else if (src1_sel == 250)
			printf("\tSRC1_SEL(SQ_ALU_SRC_I_INT),\n");
		else if (src1_sel == 251)
			printf("\tSRC1_SEL(SQ_ALU_SRC_M_1_INT),\n");
		else if (src1_sel == 252)
			printf("\tSRC0_SEL(SQ_ALU_SRC_0_5),\n");
		else if (src1_sel == 253)
			printf("\tSRC1_SEL(SQ_ALU_SRC_LITERAL),\n");
		else if (src1_sel == 254)
			printf("\tSRC1_SEL(SQ_ALU_SRC_PV),\n");
		else if (src1_sel == 255)
			printf("\tSRC1_SEL(SQ_ALU_SRC_PS),\n");
		else
			printf("\tSRC1_SEL(%d),\n", src1_sel);
	}

	printf("\tSRC1_REL(%s),\n", rel[src1_rel]);
	printf("\tSRC1_ELEM(%s),\n", elem[src1_elem]);
	printf("\tSRC1_NEG(%d),\n", src1_neg);
	printf("\tINDEX_MODE(%s),\n", im[index_mode]);
	printf("\tPRED_SEL(%s),\n", ps[pred_sel]);
	printf("\tLAST(%d)", last);
	printf("),\n");
}

void tex_dword0(uint32_t dword0, int is_r700)
{
	int inst, bfm, fwq;
	int resource_id, src_gpr;
	int sr, ac;

	printf("TEX_DWORD0(");
	inst = (dword0 >> 0) & 0x1f;
	printf("TEX_INST(%s),\n", tex_op[inst]);
	bfm = (dword0 >> 5) & 0x1;
	printf("\tBC_FRAC_MODE(%d),\n", bfm);
	fwq = (dword0 >> 7) & 0x1;
	printf("\tFETCH_WHOLE_QUAD(%d),\n", fwq);
	resource_id = (dword0 >> 8) & 0xff;
	printf("\tRESOURCE_ID(%d),\n", resource_id);
	src_gpr = (dword0 >> 16) & 0x7f;
	printf("\tSRC_GPR(%d),\n", src_gpr);
	sr = (dword0 >> 23) & 0x1;
	printf("\tSRC_REL(%s),\n", rel[sr]);
	if (is_r700) {
		ac = (dword0 >> 24) & 0x1;
		printf("\tR7xx_ALT_CONST(%d)", ac);
	} else {
		printf("\tR7xx_ALT_CONST(0)");
	}
	printf("),\n");
}

void tex_dword1(uint32_t dword1, int is_r700)
{
	int dst_gpr, dr;
	int dsx, dsy, dsz, dsw;
	int lod_bias;
	int ctx, cty, ctz, ctw;

	printf("TEX_DWORD1(");
	dst_gpr = (dword1 >> 0) & 0x7f;
	printf("DST_GPR(%d),\n", dst_gpr);
	dr = (dword1 >> 7) & 0x1;
	printf("\tDST_REL(%s),\n", rel[dr]);
	dsx = (dword1 >> 9) & 0x7;
	printf("\tDST_SEL_X(%s),\n", sel[dsx]);
	dsy = (dword1 >> 12) & 0x7;
	printf("\tDST_SEL_Y(%s),\n", sel[dsy]);
	dsz = (dword1 >> 15) & 0x7;
	printf("\tDST_SEL_Z(%s),\n", sel[dsz]);
	dsw = (dword1 >> 18) & 0x7;
	printf("\tDST_SEL_W(%s),\n", sel[dsw]);
	lod_bias = (dword1 >> 21) & 0x7f;
	printf("\tLOD_BIAS(%d),\n", lod_bias);
	ctx = (dword1 >> 28) & 0x1;
	printf("\tCOORD_TYPE_X(%s),\n", coord_type[ctx]);
	cty = (dword1 >> 29) & 0x1;
	printf("\tCOORD_TYPE_Y(%s),\n", coord_type[cty]);
	ctz = (dword1 >> 30) & 0x1;
	printf("\tCOORD_TYPE_Z(%s),\n", coord_type[ctz]);
	ctw = (dword1 >> 31) & 0x1;
	printf("\tCOORD_TYPE_W(%s)", coord_type[ctw]);
	printf("),\n");
}

void tex_dword2(uint32_t dword2, int is_r700)
{
	int ox, oy, oz;
	int sampler_id;
	int ssx, ssy, ssz, ssw;

	printf("TEX_DWORD2(");
	ox = (dword2 >> 0) & 0x1f;
	printf("OFFSET_X(%d),\n", ox);
	oy = (dword2 >> 5) & 0x1f;
	printf("\tOFFSET_Y(%d),\n", oy);
	oz = (dword2 >> 10) & 0x1f;
	printf("\tOFFSET_Z(%d),\n", oz);
	sampler_id = (dword2 >> 15) & 0x1f;
	printf("\tSAMPLER_ID(%d),\n", sampler_id);
	ssx = (dword2 >> 20) & 0x7;
	printf("\tSRC_SEL_X(%s),\n", sel[ssx]);
	ssy = (dword2 >> 23) & 0x7;
	printf("\tSRC_SEL_Y(%s),\n", sel[ssy]);
	ssz = (dword2 >> 26) & 0x7;
	printf("\tSRC_SEL_Z(%s),\n", sel[ssz]);
	ssw = (dword2 >> 29) & 0x7;
	printf("\tSRC_SEL_W(%s)", sel[ssw]);
	printf("),\n");
}

void tex_dword_pad()
{
	printf("TEX_DWORD_PAD,\n");
}

void vtx_dword0(uint32_t dword0, int is_r700)
{
	int inst, ft, fwq;
	int buffer_id, src_gpr;
	int sr, ssx, mfc;

	printf("VTX_DWORD0(");
	inst = (dword0 >> 0) & 0x1f;
	printf("VTX_INST(%s),\n", vtx_op[inst]);
	ft = (dword0 >> 5) & 0x3;
	printf("\tFETCH_TYPE(%s),\n", fetch_type[ft]);
	fwq = (dword0 >> 7) & 0x1;
	printf("\tFETCH_WHOLE_QUAD(%d),\n", fwq);
	buffer_id = (dword0 >> 8) & 0xff;
	printf("\tBUFFER_ID(%d),\n", buffer_id);
	src_gpr = (dword0 >> 16) & 0x7f;
	printf("\tSRC_GPR(%d),\n", src_gpr);
	sr = (dword0 >> 23) & 0x1;
	printf("\tSRC_REL(%s),\n", rel[sr]);
	ssx = (dword0 >> 24) & 0x3;
	printf("\tSRC_SEL_X(%s),\n", sel[ssx]);
	mfc = (dword0 >> 26) & 0x3f;
	mfc++;
	printf("\tMEGA_FETCH_COUNT(%d)", mfc);
	printf("),\n");
}

void vtx_dword1_sem(uint32_t dword1, int is_r700)
{
	int semantic_id;
	int dsx, dsy, dsz, dsw;
	int ucf, df, nfa, fca, sma;

	printf("VTX_DWORD1_SEM(");
	semantic_id = (dword1 >> 0) & 0xff;
	printf("SEMANTIC_ID(%d),\n", semantic_id);
	dsx = (dword1 >> 9) & 0x7;
	printf("\tDST_SEL_X(%s),\n", sel[dsx]);
	dsy = (dword1 >> 12) & 0x7;
	printf("\tDST_SEL_Y(%s),\n", sel[dsy]);
	dsz = (dword1 >> 15) & 0x7;
	printf("\tDST_SEL_Z(%s),\n", sel[dsz]);
	dsw = (dword1 >> 18) & 0x7;
	printf("\tDST_SEL_W(%s),\n", sel[dsw]);
	ucf = (dword1 >> 21) & 0x1;
	printf("\tUSE_CONST_FIELDS(%d),\n", ucf);
	df = (dword1 >> 22) & 0x3f;
	printf("\tDATA_FORMAT(%d),\n", df);
	nfa = (dword1 >> 28) & 0x3;
	printf("\tNUM_FORMAT_ALL(%s),\n", num_format_all[nfa]);
	fca = (dword1 >> 30) & 0x1;
	printf("\tFORMAT_COMP_ALL(%s),\n", format_comp_all[fca]);
	sma = (dword1 >> 31) & 0x1;
	printf("\tSRF_MODE_ALL(%s)", srf_mode_all[sma]);
	printf("),\n");
}

void vtx_dword1_gpr(uint32_t dword1, int is_r700)
{
	int dst_gpr, dr;
	int dsx, dsy, dsz, dsw;
	int ucf, df, nfa, fca, sma;

	printf("VTX_DWORD1_GPR(");
	dst_gpr = (dword1 >> 0) & 0x7f;
	printf("DST_GPR(%d),\n", dst_gpr);
	dr = (dword1 >> 7) & 0x1;
	printf("\tDST_REL(%s),\n", rel[dr]);
	dsx = (dword1 >> 9) & 0x7;
	printf("\tDST_SEL_X(%s),\n", sel[dsx]);
	dsy = (dword1 >> 12) & 0x7;
	printf("\tDST_SEL_Y(%s),\n", sel[dsy]);
	dsz = (dword1 >> 15) & 0x7;
	printf("\tDST_SEL_Z(%s),\n", sel[dsz]);
	dsw = (dword1 >> 18) & 0x7;
	printf("\tDST_SEL_W(%s),\n", sel[dsw]);
	ucf = (dword1 >> 21) & 0x1;
	printf("\tUSE_CONST_FIELDS(%d),\n", ucf);
	df = (dword1 >> 22) & 0x3f;
	printf("\tDATA_FORMAT(%d),\n", df);
	nfa = (dword1 >> 28) & 0x3;
	printf("\tNUM_FORMAT_ALL(%s),\n", num_format_all[nfa]);
	fca = (dword1 >> 30) & 0x1;
	printf("\tFORMAT_COMP_ALL(%s),\n", format_comp_all[fca]);
	sma = (dword1 >> 31) & 0x1;
	printf("\tSRF_MODE_ALL(%s)", srf_mode_all[sma]);
	printf("),\n");
}

void vtx_dword2(uint32_t dword2, int is_r700)
{
	int offset, es;
	int cbns, mf;

	printf("VTX_DWORD2(");
	offset = (dword2 >> 0) & 0xffff;
	printf("OFFSET(%d),\n", offset);
	es = (dword2 >> 16) & 0x3;
	printf("\tENDIAN_SWAP(%s),\n", endian_swap[es]);
	cbns = (dword2 >> 18) & 0x1;
	printf("\tCONST_BUF_NO_STRIDE(%d),\n", cbns);
	mf = (dword2 >> 19) & 0x1;
	printf("\tMEGA_FETCH(%d),\n", mf);
	printf("),\n");
}

void vtx_dword_pad()
{
	printf("VTX_DWORD_PAD,\n");
}

void cf_dword0(uint32_t dword0, int is_r700)
{
	printf("CF_DWORD0(");
	printf("ADDR(%d)", dword0);
	printf("),\n");
}

void cf_dword1(uint32_t dword1, int is_r700)
{
	int pop_count, cf_const;
	int cf_cond, count, call_count;
	int eop, vpm, cf_inst, wqm;
	int barrier;

	printf("CF_DWORD1(");
	pop_count = (dword1 >> 0) & 0x7;
	printf("POP_COUNT(%d),\n", pop_count);
	cf_const = (dword1 >> 3) & 0x1f;
	printf("\tCF_CONST(%d),\n", cf_const);
	cf_cond = (dword1 >> 8) & 0x3;
	printf("\tCOND(%s),\n", cond[cf_cond]);
	count = (dword1 >> 10) & 0x7;
	count++;
	printf("\tCOUNT(%d),\n", count);
	call_count = (dword1 >> 13) & 0x3f;
	printf("\tCALL_COUNT(%d),\n", call_count);
	eop = (dword1 >> 21) & 0x1;
	printf("\tEND_OF_PROGRAM(%d),\n", eop);
	vpm = (dword1 >> 22) & 0x1;
	printf("\tVALID_PIXEL_MODE(%d),\n", vpm);
	cf_inst = (dword1 >> 23) & 0x7f;
	printf("\tCF_INST(%s),\n", cf_op[cf_inst]);
	wqm = (dword1 >> 30) & 0x1;
	printf("\tWHOLE_QUAD_MODE(%d),\n", wqm);
	barrier = (dword1 >> 31) & 0x1;
	printf("\tBARRIER(%d)", barrier);
	printf("),\n");
}

void cf_alu_dword0(uint32_t dword0, int is_r700)
{
	int kb0, kb1, km0;

	kb0 = (dword0 >> 22) & 0xf;
	kb1 = (dword0 >> 26) & 0xf;
	km0 = (dword0 >> 30) & 0x3;

	printf("CF_ALU_DWORD0(");
	printf("ADDR(%d),\n", dword0 & 0x3fffff);
	printf("\tKCACHE_BANK0(%d),\n", kb0);
	printf("\tKCACHE_BANK1(%d),\n", kb1);
	printf("\tKCACHE_MODE0(%s)", km[km0]);
	printf("),\n");
}

void cf_alu_dword1(uint32_t dword1, int is_r700)
{
	int km1, ka0, ka1, count, uw;
	int cf_inst, wqm, barrier;

	printf("CF_ALU_DWORD1(");
	km1 = (dword1 >> 0) & 0x3;
	printf("KCACHE_MODE1(%s),\n", km[km1]);
	ka0 = (dword1 >> 2) & 0xff;
	printf("\tKCACHE_ADDR0(%d),\n", ka0);
	ka1 = (dword1 >> 10) & 0xff;
	printf("\tKCACHE_ADDR1(%d),\n", ka1);
	count = (dword1 >> 18) & 0x7f;
	count++;
	printf("\tCOUNT(%d),\n", count);
	uw = (dword1 >> 25) & 0x1;
	printf("\tUSES_WATERFALL(%d),\n", uw);
	cf_inst = (dword1 >> 26) & 0xf;
	printf("\tCF_INST(%s),\n", cf_alu_op[cf_inst]);
	wqm = (dword1 >> 30) & 0x1;
	printf("\tWHOLE_QUAD_MODE(%d),\n", wqm);
	barrier = (dword1 >> 31) & 0x1;
	printf("\tBARRIER(%d)", barrier);
	printf("),\n");
}

void cf_alloc_imp_exp_dword0(uint32_t dword0, int is_mem, int is_r700)
{
	int array_base, type, rw_gpr;
	int rw_rel, index_gpr, elem_size;

	printf("CF_ALLOC_IMP_EXP_DWORD0(");
	array_base = (dword0 >> 0) & 0x1fff;
	type = (dword0 >> 13) & 0x3;
	if (is_mem) {
		printf("ARRAY_BASE(%d),\n", array_base);
		printf("\tTYPE(%s),\n", cf_mem_type[type]);
	} else {
		if (type == 0)
			printf("ARRAY_BASE(%s),\n", ab_pixel[array_base]);
		else if (type == 1)
			printf("ARRAY_BASE(%s),\n", ab_pos[array_base]);
		else
			printf("ARRAY_BASE(%d),\n", array_base);
		printf("\tTYPE(%s),\n", cf_exp_type[type]);
	}
	rw_gpr = (dword0 >> 15) & 0x7f;
	printf("\tRW_GPR(%d),\n", rw_gpr);
	rw_rel = (dword0 >> 22) & 0x1;
	printf("\tRW_REL(%s),\n", rel[rw_rel]);
	index_gpr = (dword0 >> 23) & 0x7f;
	printf("\tINDEX_GPR(%d),\n", index_gpr);
	elem_size = (dword0 >> 30) & 0x3;
	printf("\tELEM_SIZE(%d)", elem_size);
	printf("),\n");
}

void cf_alloc_imp_exp_dword1_buf(uint32_t dword1, int is_r700)
{
	int array_size, comp_mask, elem_loop;
	int bc, eop, vpm, cf_inst, wqm, barrier;

	printf("CF_ALLOC_IMP_EXP_DWORD1_BUF(");
	array_size = (dword1 >> 0) & 0xfff;
	printf("ARRAY_SIZE(%d),\n", array_size);
	comp_mask = (dword1 >> 12) & 0xf;
	printf("\tCOMP_MASK(%d),\n", comp_mask);
	if (is_r700) {
		printf("\tR6xx_ELEM_LOOP(0),\n");
	} else {
		elem_loop = (dword1 >> 16) & 0x1;
		printf("\tR6xx_ELEM_LOOP(%d),\n", elem_loop);
	}
	bc = (dword1 >> 17) & 0xf;
	printf("\tBURST_COUNT(%d),\n", bc);
	eop = (dword1 >> 21) & 0x1;
	printf("\tEND_OF_PROGRAM(%d),\n", eop);
	vpm = (dword1 >> 22) & 0x1;
	printf("\tVALID_PIXEL_MODE(%d),\n", vpm);
	cf_inst = (dword1 >> 23) & 0x7f;
	printf("\tCF_INST(%s),\n", cf_exp_op[cf_inst]);
	wqm = (dword1 >> 30) & 0x1;
	printf("\tWHOLE_QUAD_MODE(%d),\n", wqm);
	barrier = (dword1 >> 31) & 0x1;
	printf("\tBARRIER(%d)", barrier);
	printf("),\n");

}

void cf_alloc_imp_exp_dword1_swiz(uint32_t dword1, int is_r700)
{
	int sel_x, sel_y, sel_z, sel_w, elem_loop;
	int bc, eop, vpm, cf_inst, wqm, barrier;

	printf("CF_ALLOC_IMP_EXP_DWORD1_SWIZ(");
	sel_x = (dword1 >> 0) & 0x7;
	printf("SRC_SEL_X(%s),\n", sel[sel_x]);
	sel_y = (dword1 >> 3) & 0x7;
	printf("\tSRC_SEL_Y(%s),\n", sel[sel_y]);
	sel_z = (dword1 >> 6) & 0x7;
	printf("\tSRC_SEL_Z(%s),\n", sel[sel_z]);
	sel_w = (dword1 >> 9) & 0x7;
	printf("\tSRC_SEL_W(%s),\n", sel[sel_w]);
	elem_loop = (dword1 >> 16) & 0x1;
	printf("\tELEM_LOOP(%d),\n", elem_loop);
	bc = (dword1 >> 17) & 0xf;
	printf("\tBURST_COUNT(%d),\n", bc);
	eop = (dword1 >> 21) & 0x1;
	printf("\tEND_OF_PROGRAM(%d),\n", eop);
	vpm = (dword1 >> 22) & 0x1;
	printf("\tVALID_PIXEL_MODE(%d),\n", vpm);
	cf_inst = (dword1 >> 23) & 0x7f;
	printf("\tCF_INST(%s),\n", cf_exp_op[cf_inst]);
	wqm = (dword1 >> 30) & 0x1;
	printf("\tWHOLE_QUAD_MODE(%d),\n", wqm);
	barrier = (dword1 >> 31) & 0x1;
	printf("\tBARRIER(%d)", barrier);
	printf("),\n");

}

void do_alu_clause(uint32_t *inst, int offset, int count, int is_r700)
{
	uint32_t dword0, dword1;
	int op3;
	int src0, src1, src2;
	int elem0, elem1, elem2;
	int inline_const_count = 0;

	while (count) {
		dword0 = inst[offset];
		dword1 = inst[offset + 1];
		if (inline_const_count) {
			printf("0x%08x,\n",dword0);
			printf("0x%08x,\n",dword1);
			inline_const_count--;
		} else {
			src0 = (dword0 >> 0) & 0x1ff;
			src1 = (dword0 >> 13) & 0x1ff;
			elem0 = (dword0 >> 10) & 0x3;
			elem1 = (dword0 >> 23) & 0x3;
			alu_dword0(dword0, is_r700);
			// if high 3 bits of inst are 000b, OP2, else OP3
			op3 = (dword1 >> 15) & 0x7;
			if (op3) {
				alu_dword1_op3(dword1, is_r700);
				src2 = (dword1 >> 0) & 0x1ff;
				elem2 = (dword1 >> 10) & 0x3;
			} else {
				alu_dword1_op2(dword1, is_r700);
				src2 = 0;
				elem2 = 0;
			}

			// inline constants
			if ((src0 == 253) || (src1 == 253) || (src2 == 253)) {
				if ((elem0 > 1) || (elem1 > 1) || (elem2 > 1))
					inline_const_count = 2; // 3-4 constants
				else
					inline_const_count = 1; // 1-2 constants
			}
		}
		count--;
		offset += 2;
	}
}

void do_tex_clause(uint32_t *inst, int offset, int count, int is_r700)
{
	uint32_t dword0, dword1, dword2;

	while (count) {
		dword0 = inst[offset];
		dword1 = inst[offset + 1];
		dword2 = inst[offset + 2];
		tex_dword0(dword0, is_r700);
		tex_dword1(dword1, is_r700);
		tex_dword2(dword2, is_r700);
		tex_dword_pad();

		count--;
		offset += 4;
	}
}

void do_vtx_clause(uint32_t *inst, int offset, int count, int is_r700)
{
	uint32_t dword0, dword1, dword2;
	int op;

	while (count) {
		dword0 = inst[offset];
		dword1 = inst[offset + 1];
		dword2 = inst[offset + 2];
		vtx_dword0(dword0, is_r700);
		// if op = 1, sem, else gpr
		op = (dword0 >> 0) & 0x1f;
		if (op == 1)
			vtx_dword1_sem(dword1, is_r700);
		else
			vtx_dword1_gpr(dword1, is_r700);
		vtx_dword2(dword2, is_r700);
		vtx_dword_pad();

		count--;
		offset += 4;
	}
}

static int do_cf_inst(uint32_t *inst, uint32_t offset, int is_r700)
{
	uint32_t dword0, dword1;
	int encoding, addr, count, op;
	int eop = 0;

	dword0 = inst[offset];
	dword1 = inst[offset + 1];

	// if high 2 bits of inst are 10b or 11b, ALU,
	// else if 01b, imp/exp
	// else if 00b, cf
	encoding = (dword1 >> 28) & 0x3;
	if (encoding >= 2) {
		cf_alu_dword0(dword0, is_r700);
		cf_alu_dword1(dword1, is_r700);
		addr = (dword0 >> 0) & 0x3fffff;
		addr *= 2;
		count = (dword1 >> 18) & 0x7f;
		count++;
		do_alu_clause(inst, addr, count, is_r700);
	} else if (encoding == 1) {
		op = (dword1 >> 23) & 0x7f;
		if ((op == 39) || (op == 40)) {
			// export inst
			cf_alloc_imp_exp_dword0(dword0, 0, is_r700);
			cf_alloc_imp_exp_dword1_swiz(dword1, is_r700);
		} else {
			// mem inst
			cf_alloc_imp_exp_dword0(dword0, 1, is_r700);
			cf_alloc_imp_exp_dword1_buf(dword1, is_r700);
		}
		eop = (dword1 >> 21) & 0x1;
	} else {
		op = (dword1 >> 23) & 0x7f;
		addr = dword0;
		addr *= 2;
		count = (dword1 >> 10) & 0x7;
		if (is_r700)
			count += (dword1 >> 19) & 0x1;
		count++;
		cf_dword0(dword0, is_r700);
		cf_dword1(dword1, is_r700);
		if (op == 1)
			do_tex_clause(inst, addr, count, is_r700);
		else if ((op == 2) || (op == 3))
			do_vtx_clause(inst, addr, count, is_r700);
		eop = (dword1 >> 21) & 0x1;
	}
	return eop;
}

int main (int argc, char* argv[]) {
	uint32_t sp[MAXINST];
	FILE *fp;
	int is_r700 = 0;
	uint32_t dword0 = sp[0];
	uint32_t dword1 = sp[1];
	uint32_t offset = 0;
	int eop = 0, i = 0, j = 0;

	memset(sp, 0, MAXINST*sizeof(uint32_t));

	if (argc > 1) {
	    for (i = 1; i < argc; i++) {
		if (!strcmp("--r7xx", argv[i])) {
		    is_r700 = 1;
		    continue;
		} else {
		    fp = fopen(argv[i], "r");
		    if (fp == NULL) {
			printf("convert_shader: input file open error\n");
			return -1;
		    } else {
			for (j = 0; j < MAXINST; j++) {
			    fscanf(fp, "%x,", &sp[j]);
			}
		    }
		    fclose(fp);
		}
	    }
	} else {
		printf("convert_shader [--r7xx] shader_file\n");
		return -1;
	}

	while (offset < (sizeof(sp) / 8)) {
		eop = do_cf_inst(sp, offset, is_r700);

		if (eop)
			break;
		offset += 2;
	}

	return 0;
}