r600: double multiply can handle only one multiply at a time
[mesa.git] / src / gallium / drivers / r600 / r600_shader.c
index 64b049a1ced1308af6f21c38fbb432b341bbf229..7d1452add343bb88d473c9ebe0b5ba7c891eaa54 100644 (file)
@@ -33,6 +33,7 @@
 #include "tgsi/tgsi_parse.h"
 #include "tgsi/tgsi_scan.h"
 #include "tgsi/tgsi_dump.h"
+#include "util/u_bitcast.h"
 #include "util/u_memory.h"
 #include "util/u_math.h"
 #include <stdio.h>
@@ -136,7 +137,7 @@ static int store_shader(struct pipe_context *ctx,
 
        if (shader->bo == NULL) {
                shader->bo = (struct r600_resource*)
-                       pipe_buffer_create(ctx->screen, PIPE_BIND_CUSTOM, PIPE_USAGE_IMMUTABLE, shader->shader.bc.ndw * 4);
+                       pipe_buffer_create(ctx->screen, 0, PIPE_USAGE_IMMUTABLE, shader->shader.bc.ndw * 4);
                if (shader->bo == NULL) {
                        return -ENOMEM;
                }
@@ -288,7 +289,7 @@ error:
 
 void r600_pipe_shader_destroy(struct pipe_context *ctx, struct r600_pipe_shader *shader)
 {
-       pipe_resource_reference((struct pipe_resource**)&shader->bo, NULL);
+       r600_resource_reference(&shader->bo, NULL);
        r600_bytecode_clear(&shader->shader.bc);
        r600_release_command_buffer(&shader->command_buffer);
 }
@@ -858,7 +859,7 @@ static int tgsi_declaration(struct r600_shader_ctx *ctx)
        case TGSI_FILE_INPUT:
                for (j = 0; j < count; j++) {
                        i = ctx->shader->ninput + j;
-                       assert(i < Elements(ctx->shader->input));
+                       assert(i < ARRAY_SIZE(ctx->shader->input));
                        ctx->shader->input[i].name = d->Semantic.Name;
                        ctx->shader->input[i].sid = d->Semantic.Index + j;
                        ctx->shader->input[i].interpolate = d->Interp.Interpolate;
@@ -902,7 +903,7 @@ static int tgsi_declaration(struct r600_shader_ctx *ctx)
        case TGSI_FILE_OUTPUT:
                for (j = 0; j < count; j++) {
                        i = ctx->shader->noutput + j;
-                       assert(i < Elements(ctx->shader->output));
+                       assert(i < ARRAY_SIZE(ctx->shader->output));
                        ctx->shader->output[i].name = d->Semantic.Name;
                        ctx->shader->output[i].sid = d->Semantic.Index + j;
                        ctx->shader->output[i].gpr = ctx->file_offset[TGSI_FILE_OUTPUT] + d->Range.First + j;
@@ -1117,7 +1118,7 @@ static int allocate_system_value_inputs(struct r600_shader_ctx *ctx, int gpr_off
                } else if (parse.FullToken.Token.Type == TGSI_TOKEN_TYPE_DECLARATION) {
                        struct tgsi_full_declaration *d = &parse.FullToken.FullDeclaration;
                        if (d->Declaration.File == TGSI_FILE_SYSTEM_VALUE) {
-                               for (k = 0; k < Elements(inputs); k++) {
+                               for (k = 0; k < ARRAY_SIZE(inputs); k++) {
                                        if (d->Semantic.Name == inputs[k].name ||
                                                d->Semantic.Name == inputs[k].alternate_name) {
                                                inputs[k].enabled = true;
@@ -1129,7 +1130,7 @@ static int allocate_system_value_inputs(struct r600_shader_ctx *ctx, int gpr_off
 
        tgsi_parse_free(&parse);
 
-       for (i = 0; i < Elements(inputs); i++) {
+       for (i = 0; i < ARRAY_SIZE(inputs); i++) {
                boolean enabled = inputs[i].enabled;
                int *reg = inputs[i].reg;
                unsigned name = inputs[i].name;
@@ -1217,7 +1218,7 @@ static int evergreen_gpr_count(struct r600_shader_ctx *ctx)
 
        /* assign gpr to each interpolator according to priority */
        num_baryc = 0;
-       for (i = 0; i < Elements(ctx->eg_interpolators); i++) {
+       for (i = 0; i < ARRAY_SIZE(ctx->eg_interpolators); i++) {
                if (ctx->eg_interpolators[i].enabled) {
                        ctx->eg_interpolators[i].ij_index = num_baryc;
                        num_baryc ++;
@@ -3803,9 +3804,6 @@ static int tgsi_op2_64_params(struct r600_shader_ctx *ctx, bool singledest, bool
                /* handle some special cases */
                if (i == 1 || i == 3) {
                        switch (ctx->parse.FullToken.FullInstruction.Instruction.Opcode) {
-                       case TGSI_OPCODE_SUB:
-                               r600_bytecode_src_toggle_neg(&alu.src[1]);
-                               break;
                        case TGSI_OPCODE_DABS:
                                r600_bytecode_src_set_abs(&alu.src[0]);
                                break;
@@ -3930,17 +3928,6 @@ static int tgsi_op2_s(struct r600_shader_ctx *ctx, int swap, int trans_only)
                        r600_bytecode_src(&alu.src[0], &ctx->src[1], i);
                        r600_bytecode_src(&alu.src[1], &ctx->src[0], i);
                }
-               /* handle some special cases */
-               switch (inst->Instruction.Opcode) {
-               case TGSI_OPCODE_SUB:
-                       r600_bytecode_src_toggle_neg(&alu.src[1]);
-                       break;
-               case TGSI_OPCODE_ABS:
-                       r600_bytecode_src_set_abs(&alu.src[0]);
-                       break;
-               default:
-                       break;
-               }
                if (i == lasti || trans_only) {
                        alu.last = 1;
                }
@@ -4339,25 +4326,27 @@ static int cayman_mul_double_instr(struct r600_shader_ctx *ctx)
        int lasti = tgsi_last_instruction(inst->Dst[0].Register.WriteMask);
        int t1 = ctx->temp_reg;
 
-       for (k = 0; k < 2; k++) {
-               if (!(inst->Dst[0].Register.WriteMask & (0x3 << (k * 2))))
-                       continue;
+       /* t1 would get overwritten below if we actually tried to
+        * multiply two pairs of doubles at a time. */
+       assert(inst->Dst[0].Register.WriteMask == TGSI_WRITEMASK_XY ||
+              inst->Dst[0].Register.WriteMask == TGSI_WRITEMASK_ZW);
 
-               for (i = 0; i < 4; i++) {
-                       memset(&alu, 0, sizeof(struct r600_bytecode_alu));
-                       alu.op = ctx->inst_info->op;
-                       for (j = 0; j < inst->Instruction.NumSrcRegs; j++) {
-                               r600_bytecode_src(&alu.src[j], &ctx->src[j], k * 2 + ((i == 3) ? 0 : 1));
-                       }
-                       alu.dst.sel = t1;
-                       alu.dst.chan = i;
-                       alu.dst.write = 1;
-                       if (i == 3)
-                               alu.last = 1;
-                       r = r600_bytecode_add_alu(ctx->bc, &alu);
-                       if (r)
-                               return r;
+       k = inst->Dst[0].Register.WriteMask == TGSI_WRITEMASK_XY ? 0 : 1;
+
+       for (i = 0; i < 4; i++) {
+               memset(&alu, 0, sizeof(struct r600_bytecode_alu));
+               alu.op = ctx->inst_info->op;
+               for (j = 0; j < inst->Instruction.NumSrcRegs; j++) {
+                       r600_bytecode_src(&alu.src[j], &ctx->src[j], k * 2 + ((i == 3) ? 0 : 1));
                }
+               alu.dst.sel = t1;
+               alu.dst.chan = i;
+               alu.dst.write = 1;
+               if (i == 3)
+                       alu.last = 1;
+               r = r600_bytecode_add_alu(ctx->bc, &alu);
+               if (r)
+                       return r;
        }
 
        for (i = 0; i <= lasti; i++) {
@@ -4386,10 +4375,6 @@ static int cayman_mul_double_instr(struct r600_shader_ctx *ctx)
  */
 static int tgsi_setup_trig(struct r600_shader_ctx *ctx)
 {
-       static float half_inv_pi = 1.0 /(3.1415926535 * 2);
-       static float double_pi = 3.1415926535 * 2;
-       static float neg_pi = -3.1415926535;
-
        int r;
        struct r600_bytecode_alu alu;
 
@@ -4405,7 +4390,7 @@ static int tgsi_setup_trig(struct r600_shader_ctx *ctx)
 
        alu.src[1].sel = V_SQ_ALU_SRC_LITERAL;
        alu.src[1].chan = 0;
-       alu.src[1].value = *(uint32_t *)&half_inv_pi;
+       alu.src[1].value = u_bitcast_f2u(0.5f * M_1_PI);
        alu.src[2].sel = V_SQ_ALU_SRC_0_5;
        alu.src[2].chan = 0;
        alu.last = 1;
@@ -4444,8 +4429,8 @@ static int tgsi_setup_trig(struct r600_shader_ctx *ctx)
        alu.src[2].chan = 0;
 
        if (ctx->bc->chip_class == R600) {
-               alu.src[1].value = *(uint32_t *)&double_pi;
-               alu.src[2].value = *(uint32_t *)&neg_pi;
+               alu.src[1].value = u_bitcast_f2u(2.0f * M_PI);
+               alu.src[2].value = u_bitcast_f2u(-M_PI);
        } else {
                alu.src[1].sel = V_SQ_ALU_SRC_1;
                alu.src[2].sel = V_SQ_ALU_SRC_0_5;
@@ -6704,7 +6689,6 @@ static int r600_do_buffer_txq(struct r600_shader_ctx *ctx)
 
 static int tgsi_tex(struct r600_shader_ctx *ctx)
 {
-       static float one_point_five = 1.5f;
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
        struct r600_bytecode_tex tex;
        struct r600_bytecode_alu alu;
@@ -6906,7 +6890,7 @@ static int tgsi_tex(struct r600_shader_ctx *ctx)
 
                alu.src[2].sel = V_SQ_ALU_SRC_LITERAL;
                alu.src[2].chan = 0;
-               alu.src[2].value = *(uint32_t *)&one_point_five;
+               alu.src[2].value = u_bitcast_f2u(1.5f);
 
                alu.dst.sel = ctx->temp_reg;
                alu.dst.chan = 0;
@@ -6927,7 +6911,7 @@ static int tgsi_tex(struct r600_shader_ctx *ctx)
 
                alu.src[2].sel = V_SQ_ALU_SRC_LITERAL;
                alu.src[2].chan = 0;
-               alu.src[2].value = *(uint32_t *)&one_point_five;
+               alu.src[2].value = u_bitcast_f2u(1.5f);
 
                alu.dst.sel = ctx->temp_reg;
                alu.dst.chan = 1;
@@ -6961,7 +6945,6 @@ static int tgsi_tex(struct r600_shader_ctx *ctx)
                    inst->Texture.Texture == TGSI_TEXTURE_SHADOWCUBE_ARRAY) {
                        if (ctx->bc->chip_class >= EVERGREEN) {
                                int mytmp = r600_get_temp(ctx);
-                               static const float eight = 8.0f;
                                memset(&alu, 0, sizeof(struct r600_bytecode_alu));
                                alu.op = ALU_OP1_MOV;
                                alu.src[0].sel = ctx->temp_reg;
@@ -6981,7 +6964,7 @@ static int tgsi_tex(struct r600_shader_ctx *ctx)
                                r600_bytecode_src(&alu.src[0], &ctx->src[0], 3);
                                alu.src[1].sel = V_SQ_ALU_SRC_LITERAL;
                                alu.src[1].chan = 0;
-                               alu.src[1].value = *(uint32_t *)&eight;
+                               alu.src[1].value = u_bitcast_f2u(8.0f);
                                alu.src[2].sel = mytmp;
                                alu.src[2].chan = 0;
                                alu.dst.sel = ctx->temp_reg;
@@ -7707,6 +7690,15 @@ static int tgsi_cmp(struct r600_shader_ctx *ctx)
        int i, r, j;
        int lasti = tgsi_last_instruction(inst->Dst[0].Register.WriteMask);
        int temp_regs[3];
+       unsigned op;
+
+       if (ctx->src[0].abs && ctx->src[0].neg) {
+               op = ALU_OP3_CNDE;
+               ctx->src[0].abs = 0;
+               ctx->src[0].neg = 0;
+       } else {
+               op = ALU_OP3_CNDGE;
+       }
 
        for (j = 0; j < inst->Instruction.NumSrcRegs; j++) {
                temp_regs[j] = 0;
@@ -7719,7 +7711,7 @@ static int tgsi_cmp(struct r600_shader_ctx *ctx)
                        continue;
 
                memset(&alu, 0, sizeof(struct r600_bytecode_alu));
-               alu.op = ALU_OP3_CNDGE;
+               alu.op = op;
                r = tgsi_make_src_for_op3(ctx, temp_regs[0], i, &alu.src[0], &ctx->src[0]);
                if (r)
                        return r;
@@ -8882,6 +8874,105 @@ static int tgsi_umad(struct r600_shader_ctx *ctx)
        return 0;
 }
 
+static int tgsi_pk2h(struct r600_shader_ctx *ctx)
+{
+       struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
+       struct r600_bytecode_alu alu;
+       int r, i;
+       int lasti = tgsi_last_instruction(inst->Dst[0].Register.WriteMask);
+
+       /* temp.xy = f32_to_f16(src) */
+       memset(&alu, 0, sizeof(struct r600_bytecode_alu));
+       alu.op = ALU_OP1_FLT32_TO_FLT16;
+       alu.dst.chan = 0;
+       alu.dst.sel = ctx->temp_reg;
+       alu.dst.write = 1;
+       r600_bytecode_src(&alu.src[0], &ctx->src[0], 0);
+       r = r600_bytecode_add_alu(ctx->bc, &alu);
+       if (r)
+               return r;
+       alu.dst.chan = 1;
+       r600_bytecode_src(&alu.src[0], &ctx->src[0], 1);
+       alu.last = 1;
+       r = r600_bytecode_add_alu(ctx->bc, &alu);
+       if (r)
+               return r;
+
+       /* dst.x = temp.y * 0x10000 + temp.x */
+       for (i = 0; i < lasti + 1; i++) {
+               if (!(inst->Dst[0].Register.WriteMask & (1 << i)))
+                       continue;
+
+               memset(&alu, 0, sizeof(struct r600_bytecode_alu));
+               alu.op = ALU_OP3_MULADD_UINT24;
+               alu.is_op3 = 1;
+               tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
+               alu.last = i == lasti;
+               alu.src[0].sel = ctx->temp_reg;
+               alu.src[0].chan = 1;
+               alu.src[1].sel = V_SQ_ALU_SRC_LITERAL;
+               alu.src[1].value = 0x10000;
+               alu.src[2].sel = ctx->temp_reg;
+               alu.src[2].chan = 0;
+               r = r600_bytecode_add_alu(ctx->bc, &alu);
+               if (r)
+                       return r;
+       }
+
+       return 0;
+}
+
+static int tgsi_up2h(struct r600_shader_ctx *ctx)
+{
+       struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
+       struct r600_bytecode_alu alu;
+       int r, i;
+       int lasti = tgsi_last_instruction(inst->Dst[0].Register.WriteMask);
+
+       /* temp.x = src.x */
+       /* note: no need to mask out the high bits */
+       memset(&alu, 0, sizeof(struct r600_bytecode_alu));
+       alu.op = ALU_OP1_MOV;
+       alu.dst.chan = 0;
+       alu.dst.sel = ctx->temp_reg;
+       alu.dst.write = 1;
+       r600_bytecode_src(&alu.src[0], &ctx->src[0], 0);
+       r = r600_bytecode_add_alu(ctx->bc, &alu);
+       if (r)
+               return r;
+
+       /* temp.y = src.x >> 16 */
+       memset(&alu, 0, sizeof(struct r600_bytecode_alu));
+       alu.op = ALU_OP2_LSHR_INT;
+       alu.dst.chan = 1;
+       alu.dst.sel = ctx->temp_reg;
+       alu.dst.write = 1;
+       r600_bytecode_src(&alu.src[0], &ctx->src[0], 0);
+       alu.src[1].sel = V_SQ_ALU_SRC_LITERAL;
+       alu.src[1].value = 16;
+       alu.last = 1;
+       r = r600_bytecode_add_alu(ctx->bc, &alu);
+       if (r)
+               return r;
+
+       /* dst.wz = dst.xy = f16_to_f32(temp.xy) */
+       for (i = 0; i < lasti + 1; i++) {
+               if (!(inst->Dst[0].Register.WriteMask & (1 << i)))
+                       continue;
+               memset(&alu, 0, sizeof(struct r600_bytecode_alu));
+               tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
+               alu.op = ALU_OP1_FLT16_TO_FLT32;
+               alu.src[0].sel = ctx->temp_reg;
+               alu.src[0].chan = i % 2;
+               alu.last = i == lasti;
+               r = r600_bytecode_add_alu(ctx->bc, &alu);
+               if (r)
+                       return r;
+       }
+
+       return 0;
+}
+
 static const struct r600_shader_tgsi_instruction r600_shader_tgsi_instruction[] = {
        [TGSI_OPCODE_ARL]       = { ALU_OP0_NOP, tgsi_r600_arl},
        [TGSI_OPCODE_MOV]       = { ALU_OP1_MOV, tgsi_op2},
@@ -8906,7 +8997,6 @@ static const struct r600_shader_tgsi_instruction r600_shader_tgsi_instruction[]
        [TGSI_OPCODE_SLT]       = { ALU_OP2_SETGT, tgsi_op2_swap},
        [TGSI_OPCODE_SGE]       = { ALU_OP2_SETGE, tgsi_op2},
        [TGSI_OPCODE_MAD]       = { ALU_OP3_MULADD, tgsi_op3},
-       [TGSI_OPCODE_SUB]       = { ALU_OP2_ADD, tgsi_op2},
        [TGSI_OPCODE_LRP]       = { ALU_OP0_NOP, tgsi_lrp},
        [TGSI_OPCODE_FMA]       = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_SQRT]      = { ALU_OP1_SQRT_IEEE, tgsi_trans_srcx_replicate},
@@ -8922,7 +9012,7 @@ static const struct r600_shader_tgsi_instruction r600_shader_tgsi_instruction[]
        [TGSI_OPCODE_POW]       = { ALU_OP0_NOP, tgsi_pow},
        [TGSI_OPCODE_XPD]       = { ALU_OP0_NOP, tgsi_xpd},
        [32]                    = { ALU_OP0_NOP, tgsi_unsupported},
-       [TGSI_OPCODE_ABS]       = { ALU_OP1_MOV, tgsi_op2},
+       [33]                    = { ALU_OP0_NOP, tgsi_unsupported},
        [34]                    = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_DPH]       = { ALU_OP2_DOT4, tgsi_dp},
        [TGSI_OPCODE_COS]       = { ALU_OP1_COS, tgsi_trig},
@@ -8994,20 +9084,20 @@ static const struct r600_shader_tgsi_instruction r600_shader_tgsi_instruction[]
        [TGSI_OPCODE_ENDSUB]    = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_TXQ_LZ]    = { FETCH_OP_GET_TEXTURE_RESINFO, tgsi_tex},
        [TGSI_OPCODE_TXQS]      = { FETCH_OP_GET_NUMBER_OF_SAMPLES, tgsi_tex},
-       [105]                   = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_RESQ]      = { ALU_OP0_NOP, tgsi_unsupported},
        [106]                   = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_NOP]       = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_FSEQ]      = { ALU_OP2_SETE_DX10, tgsi_op2},
        [TGSI_OPCODE_FSGE]      = { ALU_OP2_SETGE_DX10, tgsi_op2},
        [TGSI_OPCODE_FSLT]      = { ALU_OP2_SETGT_DX10, tgsi_op2_swap},
        [TGSI_OPCODE_FSNE]      = { ALU_OP2_SETNE_DX10, tgsi_op2_swap},
-       [112]                   = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_MEMBAR]    = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_CALLNZ]    = { ALU_OP0_NOP, tgsi_unsupported},
        [114]                   = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_BREAKC]    = { ALU_OP0_NOP, tgsi_loop_breakc},
        [TGSI_OPCODE_KILL_IF]   = { ALU_OP2_KILLGT, tgsi_kill},  /* conditional kill */
        [TGSI_OPCODE_END]       = { ALU_OP0_NOP, tgsi_end},  /* aka HALT */
-       [118]                   = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_DFMA]      = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_F2I]       = { ALU_OP1_FLT_TO_INT, tgsi_op2_trans},
        [TGSI_OPCODE_IDIV]      = { ALU_OP0_NOP, tgsi_idiv},
        [TGSI_OPCODE_IMAX]      = { ALU_OP2_MAX_INT, tgsi_op2},
@@ -9105,9 +9195,8 @@ static const struct r600_shader_tgsi_instruction eg_shader_tgsi_instruction[] =
        [TGSI_OPCODE_SLT]       = { ALU_OP2_SETGT, tgsi_op2_swap},
        [TGSI_OPCODE_SGE]       = { ALU_OP2_SETGE, tgsi_op2},
        [TGSI_OPCODE_MAD]       = { ALU_OP3_MULADD, tgsi_op3},
-       [TGSI_OPCODE_SUB]       = { ALU_OP2_ADD, tgsi_op2},
        [TGSI_OPCODE_LRP]       = { ALU_OP0_NOP, tgsi_lrp},
-       [TGSI_OPCODE_FMA]       = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_FMA]       = { ALU_OP3_FMA, tgsi_op3},
        [TGSI_OPCODE_SQRT]      = { ALU_OP1_SQRT_IEEE, tgsi_trans_srcx_replicate},
        [TGSI_OPCODE_DP2A]      = { ALU_OP0_NOP, tgsi_unsupported},
        [22]                    = { ALU_OP0_NOP, tgsi_unsupported},
@@ -9121,14 +9210,14 @@ static const struct r600_shader_tgsi_instruction eg_shader_tgsi_instruction[] =
        [TGSI_OPCODE_POW]       = { ALU_OP0_NOP, tgsi_pow},
        [TGSI_OPCODE_XPD]       = { ALU_OP0_NOP, tgsi_xpd},
        [32]                    = { ALU_OP0_NOP, tgsi_unsupported},
-       [TGSI_OPCODE_ABS]       = { ALU_OP1_MOV, tgsi_op2},
+       [33]                    = { ALU_OP0_NOP, tgsi_unsupported},
        [34]                    = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_DPH]       = { ALU_OP2_DOT4, tgsi_dp},
        [TGSI_OPCODE_COS]       = { ALU_OP1_COS, tgsi_trig},
        [TGSI_OPCODE_DDX]       = { FETCH_OP_GET_GRADIENTS_H, tgsi_tex},
        [TGSI_OPCODE_DDY]       = { FETCH_OP_GET_GRADIENTS_V, tgsi_tex},
        [TGSI_OPCODE_KILL]      = { ALU_OP2_KILLGT, tgsi_kill},  /* unconditional kill */
-       [TGSI_OPCODE_PK2H]      = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_PK2H]      = { ALU_OP0_NOP, tgsi_pk2h},
        [TGSI_OPCODE_PK2US]     = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_PK4B]      = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_PK4UB]     = { ALU_OP0_NOP, tgsi_unsupported},
@@ -9143,7 +9232,7 @@ static const struct r600_shader_tgsi_instruction eg_shader_tgsi_instruction[] =
        [TGSI_OPCODE_TEX]       = { FETCH_OP_SAMPLE, tgsi_tex},
        [TGSI_OPCODE_TXD]       = { FETCH_OP_SAMPLE_G, tgsi_tex},
        [TGSI_OPCODE_TXP]       = { FETCH_OP_SAMPLE, tgsi_tex},
-       [TGSI_OPCODE_UP2H]      = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_UP2H]      = { ALU_OP0_NOP, tgsi_up2h},
        [TGSI_OPCODE_UP2US]     = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_UP4B]      = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_UP4UB]     = { ALU_OP0_NOP, tgsi_unsupported},
@@ -9193,20 +9282,20 @@ static const struct r600_shader_tgsi_instruction eg_shader_tgsi_instruction[] =
        [TGSI_OPCODE_ENDSUB]    = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_TXQ_LZ]    = { FETCH_OP_GET_TEXTURE_RESINFO, tgsi_tex},
        [TGSI_OPCODE_TXQS]      = { FETCH_OP_GET_NUMBER_OF_SAMPLES, tgsi_tex},
-       [105]                   = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_RESQ]      = { ALU_OP0_NOP, tgsi_unsupported},
        [106]                   = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_NOP]       = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_FSEQ]      = { ALU_OP2_SETE_DX10, tgsi_op2},
        [TGSI_OPCODE_FSGE]      = { ALU_OP2_SETGE_DX10, tgsi_op2},
        [TGSI_OPCODE_FSLT]      = { ALU_OP2_SETGT_DX10, tgsi_op2_swap},
        [TGSI_OPCODE_FSNE]      = { ALU_OP2_SETNE_DX10, tgsi_op2_swap},
-       [112]                   = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_MEMBAR]    = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_CALLNZ]    = { ALU_OP0_NOP, tgsi_unsupported},
        [114]                   = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_BREAKC]    = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_KILL_IF]   = { ALU_OP2_KILLGT, tgsi_kill},  /* conditional kill */
        [TGSI_OPCODE_END]       = { ALU_OP0_NOP, tgsi_end},  /* aka HALT */
-       [118]                   = { ALU_OP0_NOP, tgsi_unsupported},
+       /* Refer below for TGSI_OPCODE_DFMA */
        [TGSI_OPCODE_F2I]       = { ALU_OP1_FLT_TO_INT, tgsi_f2i},
        [TGSI_OPCODE_IDIV]      = { ALU_OP0_NOP, tgsi_idiv},
        [TGSI_OPCODE_IMAX]      = { ALU_OP2_MAX_INT, tgsi_op2},
@@ -9298,6 +9387,7 @@ static const struct r600_shader_tgsi_instruction eg_shader_tgsi_instruction[] =
        [TGSI_OPCODE_DRCP]      = { ALU_OP2_RECIP_64, cayman_emit_double_instr},
        [TGSI_OPCODE_DSQRT]     = { ALU_OP2_SQRT_64, cayman_emit_double_instr},
        [TGSI_OPCODE_DMAD]      = { ALU_OP3_FMA_64, tgsi_op3_64},
+       [TGSI_OPCODE_DFMA]      = { ALU_OP3_FMA_64, tgsi_op3_64},
        [TGSI_OPCODE_DFRAC]     = { ALU_OP1_FRACT_64, tgsi_op2_64},
        [TGSI_OPCODE_DLDEXP]    = { ALU_OP2_LDEXP_64, tgsi_op2_64},
        [TGSI_OPCODE_DFRACEXP]  = { ALU_OP1_FREXP_64, tgsi_dfracexp},
@@ -9327,9 +9417,8 @@ static const struct r600_shader_tgsi_instruction cm_shader_tgsi_instruction[] =
        [TGSI_OPCODE_SLT]       = { ALU_OP2_SETGT, tgsi_op2_swap},
        [TGSI_OPCODE_SGE]       = { ALU_OP2_SETGE, tgsi_op2},
        [TGSI_OPCODE_MAD]       = { ALU_OP3_MULADD, tgsi_op3},
-       [TGSI_OPCODE_SUB]       = { ALU_OP2_ADD, tgsi_op2},
        [TGSI_OPCODE_LRP]       = { ALU_OP0_NOP, tgsi_lrp},
-       [TGSI_OPCODE_FMA]       = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_FMA]       = { ALU_OP3_FMA, tgsi_op3},
        [TGSI_OPCODE_SQRT]      = { ALU_OP1_SQRT_IEEE, cayman_emit_float_instr},
        [TGSI_OPCODE_DP2A]      = { ALU_OP0_NOP, tgsi_unsupported},
        [22]                    = { ALU_OP0_NOP, tgsi_unsupported},
@@ -9343,14 +9432,14 @@ static const struct r600_shader_tgsi_instruction cm_shader_tgsi_instruction[] =
        [TGSI_OPCODE_POW]       = { ALU_OP0_NOP, cayman_pow},
        [TGSI_OPCODE_XPD]       = { ALU_OP0_NOP, tgsi_xpd},
        [32]                    = { ALU_OP0_NOP, tgsi_unsupported},
-       [TGSI_OPCODE_ABS]       = { ALU_OP1_MOV, tgsi_op2},
+       [33]                    = { ALU_OP0_NOP, tgsi_unsupported},
        [34]                    = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_DPH]       = { ALU_OP2_DOT4, tgsi_dp},
        [TGSI_OPCODE_COS]       = { ALU_OP1_COS, cayman_trig},
        [TGSI_OPCODE_DDX]       = { FETCH_OP_GET_GRADIENTS_H, tgsi_tex},
        [TGSI_OPCODE_DDY]       = { FETCH_OP_GET_GRADIENTS_V, tgsi_tex},
        [TGSI_OPCODE_KILL]      = { ALU_OP2_KILLGT, tgsi_kill},  /* unconditional kill */
-       [TGSI_OPCODE_PK2H]      = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_PK2H]      = { ALU_OP0_NOP, tgsi_pk2h},
        [TGSI_OPCODE_PK2US]     = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_PK4B]      = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_PK4UB]     = { ALU_OP0_NOP, tgsi_unsupported},
@@ -9365,7 +9454,7 @@ static const struct r600_shader_tgsi_instruction cm_shader_tgsi_instruction[] =
        [TGSI_OPCODE_TEX]       = { FETCH_OP_SAMPLE, tgsi_tex},
        [TGSI_OPCODE_TXD]       = { FETCH_OP_SAMPLE_G, tgsi_tex},
        [TGSI_OPCODE_TXP]       = { FETCH_OP_SAMPLE, tgsi_tex},
-       [TGSI_OPCODE_UP2H]      = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_UP2H]      = { ALU_OP0_NOP, tgsi_up2h},
        [TGSI_OPCODE_UP2US]     = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_UP4B]      = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_UP4UB]     = { ALU_OP0_NOP, tgsi_unsupported},
@@ -9415,20 +9504,20 @@ static const struct r600_shader_tgsi_instruction cm_shader_tgsi_instruction[] =
        [TGSI_OPCODE_ENDSUB]    = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_TXQ_LZ]    = { FETCH_OP_GET_TEXTURE_RESINFO, tgsi_tex},
        [TGSI_OPCODE_TXQS]      = { FETCH_OP_GET_NUMBER_OF_SAMPLES, tgsi_tex},
-       [105]                   = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_RESQ]      = { ALU_OP0_NOP, tgsi_unsupported},
        [106]                   = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_NOP]       = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_FSEQ]      = { ALU_OP2_SETE_DX10, tgsi_op2},
        [TGSI_OPCODE_FSGE]      = { ALU_OP2_SETGE_DX10, tgsi_op2},
        [TGSI_OPCODE_FSLT]      = { ALU_OP2_SETGT_DX10, tgsi_op2_swap},
        [TGSI_OPCODE_FSNE]      = { ALU_OP2_SETNE_DX10, tgsi_op2_swap},
-       [112]                   = { ALU_OP0_NOP, tgsi_unsupported},
+       [TGSI_OPCODE_MEMBAR]    = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_CALLNZ]    = { ALU_OP0_NOP, tgsi_unsupported},
        [114]                   = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_BREAKC]    = { ALU_OP0_NOP, tgsi_unsupported},
        [TGSI_OPCODE_KILL_IF]   = { ALU_OP2_KILLGT, tgsi_kill},  /* conditional kill */
        [TGSI_OPCODE_END]       = { ALU_OP0_NOP, tgsi_end},  /* aka HALT */
-       [118]                   = { ALU_OP0_NOP, tgsi_unsupported},
+       /* Refer below for TGSI_OPCODE_DFMA */
        [TGSI_OPCODE_F2I]       = { ALU_OP1_FLT_TO_INT, tgsi_op2},
        [TGSI_OPCODE_IDIV]      = { ALU_OP0_NOP, tgsi_idiv},
        [TGSI_OPCODE_IMAX]      = { ALU_OP2_MAX_INT, tgsi_op2},
@@ -9520,6 +9609,7 @@ static const struct r600_shader_tgsi_instruction cm_shader_tgsi_instruction[] =
        [TGSI_OPCODE_DRCP]      = { ALU_OP2_RECIP_64, cayman_emit_double_instr},
        [TGSI_OPCODE_DSQRT]     = { ALU_OP2_SQRT_64, cayman_emit_double_instr},
        [TGSI_OPCODE_DMAD]      = { ALU_OP3_FMA_64, tgsi_op3_64},
+       [TGSI_OPCODE_DFMA]      = { ALU_OP3_FMA_64, tgsi_op3_64},
        [TGSI_OPCODE_DFRAC]     = { ALU_OP1_FRACT_64, tgsi_op2_64},
        [TGSI_OPCODE_DLDEXP]    = { ALU_OP2_LDEXP_64, tgsi_op2_64},
        [TGSI_OPCODE_DFRACEXP]  = { ALU_OP1_FREXP_64, tgsi_dfracexp},