← Back to branch summary

~ubuntu-branches/ubuntu/raring/mesa/raring-proposed

« back to all changes in this revision

Viewing changes to src/gallium/drivers/r600/r600_shader.c

  • Committer: Bazaar Package Importer
  • Author(s): Cyril Brulebois
  • Date: 2011-06-19 21:26:00 UTC
  • mfrom: (1.6.1 upstream) (3.3.18 sid)
  • mto: (3.3.20 sid)
  • mto: This revision was merged to the branch mainline in revision 145.
  • Revision ID: james.westby@ubuntu.com-20110619212600-rleaapdmnbtstekb
Tags: 7.11~0-2
Thank you sbuild for giving a green light when that's not actually the
case. Fix missing Pre-Depends for the libegl1-mesa-drivers package
(multiarch-support).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/r600/r600_shader.c
21
21
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
22
22
 */
23
23
#include "pipe/p_shader_tokens.h"
 
24
#include "tgsi/tgsi_info.h"
24
25
#include "tgsi/tgsi_parse.h"
25
26
#include "tgsi/tgsi_scan.h"
26
27
#include "tgsi/tgsi_dump.h"
28
29
#include "r600_pipe.h"
29
30
#include "r600_asm.h"
30
31
#include "r600_sq.h"
 
32
#include "r600_formats.h"
31
33
#include "r600_opcodes.h"
32
34
#include "r600d.h"
33
35
#include <stdio.h>
34
36
#include <errno.h>
35
 
 
36
 
static void r600_pipe_shader_vs(struct pipe_context *ctx, struct r600_pipe_shader *shader)
37
 
{
38
 
        struct r600_pipe_state *rstate = &shader->rstate;
39
 
        struct r600_shader *rshader = &shader->shader;
40
 
        unsigned spi_vs_out_id[10];
41
 
        unsigned i, tmp;
42
 
 
43
 
        /* clear previous register */
44
 
        rstate->nregs = 0;
45
 
 
46
 
        /* so far never got proper semantic id from tgsi */
47
 
        /* FIXME better to move this in config things so they get emited
48
 
         * only one time per cs
49
 
         */
50
 
        for (i = 0; i < 10; i++) {
51
 
                spi_vs_out_id[i] = 0;
52
 
        }
53
 
        for (i = 0; i < 32; i++) {
54
 
                tmp = i << ((i & 3) * 8);
55
 
                spi_vs_out_id[i / 4] |= tmp;
56
 
        }
57
 
        for (i = 0; i < 10; i++) {
58
 
                r600_pipe_state_add_reg(rstate,
59
 
                                        R_028614_SPI_VS_OUT_ID_0 + i * 4,
60
 
                                        spi_vs_out_id[i], 0xFFFFFFFF, NULL);
61
 
        }
62
 
 
63
 
        r600_pipe_state_add_reg(rstate,
64
 
                        R_0286C4_SPI_VS_OUT_CONFIG,
65
 
                        S_0286C4_VS_EXPORT_COUNT(rshader->noutput - 2),
66
 
                        0xFFFFFFFF, NULL);
67
 
        r600_pipe_state_add_reg(rstate,
68
 
                        R_028868_SQ_PGM_RESOURCES_VS,
69
 
                        S_028868_NUM_GPRS(rshader->bc.ngpr) |
70
 
                        S_028868_STACK_SIZE(rshader->bc.nstack),
71
 
                        0xFFFFFFFF, NULL);
72
 
        r600_pipe_state_add_reg(rstate,
73
 
                        R_0288D0_SQ_PGM_CF_OFFSET_VS,
74
 
                        0x00000000, 0xFFFFFFFF, NULL);
75
 
        r600_pipe_state_add_reg(rstate,
76
 
                        R_028858_SQ_PGM_START_VS,
77
 
                        r600_bo_offset(shader->bo) >> 8, 0xFFFFFFFF, shader->bo);
78
 
 
79
 
        r600_pipe_state_add_reg(rstate,
80
 
                                R_03E200_SQ_LOOP_CONST_0 + (32 * 4), 0x01000FFF,
81
 
                                0xFFFFFFFF, NULL);
82
 
 
83
 
}
 
37
#include <byteswap.h>
 
38
 
 
39
/* CAYMAN notes 
 
40
Why CAYMAN got loops for lots of instructions is explained here.
 
41
 
 
42
-These 8xx t-slot only ops are implemented in all vector slots.
 
43
MUL_LIT, FLT_TO_UINT, INT_TO_FLT, UINT_TO_FLT
 
44
These 8xx t-slot only opcodes become vector ops, with all four 
 
45
slots expecting the arguments on sources a and b. Result is 
 
46
broadcast to all channels.
 
47
MULLO_INT, MULHI_INT, MULLO_UINT, MULHI_UINT
 
48
These 8xx t-slot only opcodes become vector ops in the z, y, and 
 
49
x slots.
 
50
EXP_IEEE, LOG_IEEE/CLAMPED, RECIP_IEEE/CLAMPED/FF/INT/UINT/_64/CLAMPED_64
 
51
RECIPSQRT_IEEE/CLAMPED/FF/_64/CLAMPED_64
 
52
SQRT_IEEE/_64
 
53
SIN/COS
 
54
The w slot may have an independent co-issued operation, or if the 
 
55
result is required to be in the w slot, the opcode above may be 
 
56
issued in the w slot as well.
 
57
The compiler must issue the source argument to slots z, y, and x
 
58
*/
 
59
 
84
60
 
85
61
int r600_find_vs_semantic_index(struct r600_shader *vs,
86
62
                                struct r600_shader *ps, int id)
96
72
        return 0;
97
73
}
98
74
 
99
 
static void r600_pipe_shader_ps(struct pipe_context *ctx, struct r600_pipe_shader *shader)
100
 
{
101
 
        struct r600_pipe_state *rstate = &shader->rstate;
102
 
        struct r600_shader *rshader = &shader->shader;
103
 
        unsigned i, exports_ps, num_cout, spi_ps_in_control_0, spi_input_z, spi_ps_in_control_1;
104
 
        int pos_index = -1, face_index = -1;
105
 
 
106
 
        rstate->nregs = 0;
107
 
 
108
 
        for (i = 0; i < rshader->ninput; i++) {
109
 
                if (rshader->input[i].name == TGSI_SEMANTIC_POSITION)
110
 
                        pos_index = i;
111
 
                if (rshader->input[i].name == TGSI_SEMANTIC_FACE)
112
 
                        face_index = i;
113
 
        }
114
 
 
115
 
        for (i = 0; i < rshader->noutput; i++) {
116
 
                if (rshader->output[i].name == TGSI_SEMANTIC_POSITION)
117
 
                        r600_pipe_state_add_reg(rstate,
118
 
                                                R_02880C_DB_SHADER_CONTROL,
119
 
                                                S_02880C_Z_EXPORT_ENABLE(1),
120
 
                                                S_02880C_Z_EXPORT_ENABLE(1), NULL);
121
 
                if (rshader->output[i].name == TGSI_SEMANTIC_STENCIL)
122
 
                        r600_pipe_state_add_reg(rstate,
123
 
                                                R_02880C_DB_SHADER_CONTROL,
124
 
                                                S_02880C_STENCIL_REF_EXPORT_ENABLE(1),
125
 
                                                S_02880C_STENCIL_REF_EXPORT_ENABLE(1), NULL);
126
 
        }
127
 
 
128
 
        exports_ps = 0;
129
 
        num_cout = 0;
130
 
        for (i = 0; i < rshader->noutput; i++) {
131
 
                if (rshader->output[i].name == TGSI_SEMANTIC_POSITION || rshader->output[i].name == TGSI_SEMANTIC_STENCIL)
132
 
                        exports_ps |= 1;
133
 
                else if (rshader->output[i].name == TGSI_SEMANTIC_COLOR) {
134
 
                        num_cout++;
135
 
                }
136
 
        }
137
 
        exports_ps |= S_028854_EXPORT_COLORS(num_cout);
138
 
        if (!exports_ps) {
139
 
                /* always at least export 1 component per pixel */
140
 
                exports_ps = 2;
141
 
        }
142
 
 
143
 
        spi_ps_in_control_0 = S_0286CC_NUM_INTERP(rshader->ninput) |
144
 
                                S_0286CC_PERSP_GRADIENT_ENA(1);
145
 
        spi_input_z = 0;
146
 
        if (pos_index != -1) {
147
 
                spi_ps_in_control_0 |= (S_0286CC_POSITION_ENA(1) |
148
 
                                        S_0286CC_POSITION_CENTROID(rshader->input[pos_index].centroid) |
149
 
                                        S_0286CC_POSITION_ADDR(rshader->input[pos_index].gpr) |
150
 
                                        S_0286CC_BARYC_SAMPLE_CNTL(1));
151
 
                spi_input_z |= 1;
152
 
        }
153
 
 
154
 
        spi_ps_in_control_1 = 0;
155
 
        if (face_index != -1) {
156
 
                spi_ps_in_control_1 |= S_0286D0_FRONT_FACE_ENA(1) |
157
 
                        S_0286D0_FRONT_FACE_ADDR(rshader->input[face_index].gpr);
158
 
        }
159
 
 
160
 
        r600_pipe_state_add_reg(rstate, R_0286CC_SPI_PS_IN_CONTROL_0, spi_ps_in_control_0, 0xFFFFFFFF, NULL);
161
 
        r600_pipe_state_add_reg(rstate, R_0286D0_SPI_PS_IN_CONTROL_1, spi_ps_in_control_1, 0xFFFFFFFF, NULL);
162
 
        r600_pipe_state_add_reg(rstate, R_0286D8_SPI_INPUT_Z, spi_input_z, 0xFFFFFFFF, NULL);
163
 
        r600_pipe_state_add_reg(rstate,
164
 
                                R_028840_SQ_PGM_START_PS,
165
 
                                r600_bo_offset(shader->bo) >> 8, 0xFFFFFFFF, shader->bo);
166
 
        r600_pipe_state_add_reg(rstate,
167
 
                                R_028850_SQ_PGM_RESOURCES_PS,
168
 
                                S_028868_NUM_GPRS(rshader->bc.ngpr) |
169
 
                                S_028868_STACK_SIZE(rshader->bc.nstack),
170
 
                                0xFFFFFFFF, NULL);
171
 
        r600_pipe_state_add_reg(rstate,
172
 
                                R_028854_SQ_PGM_EXPORTS_PS,
173
 
                                exports_ps, 0xFFFFFFFF, NULL);
174
 
        r600_pipe_state_add_reg(rstate,
175
 
                                R_0288CC_SQ_PGM_CF_OFFSET_PS,
176
 
                                0x00000000, 0xFFFFFFFF, NULL);
177
 
 
178
 
        if (rshader->uses_kill) {
179
 
                /* only set some bits here, the other bits are set in the dsa state */
180
 
                r600_pipe_state_add_reg(rstate,
181
 
                                        R_02880C_DB_SHADER_CONTROL,
182
 
                                        S_02880C_KILL_ENABLE(1),
183
 
                                        S_02880C_KILL_ENABLE(1), NULL);
184
 
        }
185
 
        r600_pipe_state_add_reg(rstate,
186
 
                                R_03E200_SQ_LOOP_CONST_0, 0x01000FFF,
187
 
                                0xFFFFFFFF, NULL);
188
 
}
189
 
 
190
 
int r600_pipe_shader(struct pipe_context *ctx, struct r600_pipe_shader *shader)
 
75
static int r600_pipe_shader(struct pipe_context *ctx, struct r600_pipe_shader *shader)
191
76
{
192
77
        struct r600_pipe_context *rctx = (struct r600_pipe_context *)ctx;
193
78
        struct r600_shader *rshader = &shader->shader;
194
 
        void *ptr;
 
79
        uint32_t *ptr;
 
80
        int     i;
195
81
 
196
82
        /* copy new shader */
197
83
        if (shader->bo == NULL) {
198
 
                shader->bo = r600_bo(rctx->radeon, rshader->bc.ndw * 4, 4096, 0, 0);
 
84
                /* use PIPE_BIND_VERTEX_BUFFER so we use the cache buffer manager */
 
85
                shader->bo = r600_bo(rctx->radeon, rshader->bc.ndw * 4, 4096, PIPE_BIND_VERTEX_BUFFER, PIPE_USAGE_IMMUTABLE);
199
86
                if (shader->bo == NULL) {
200
87
                        return -ENOMEM;
201
88
                }
202
 
                ptr = r600_bo_map(rctx->radeon, shader->bo, 0, NULL);
203
 
                memcpy(ptr, rshader->bc.bytecode, rshader->bc.ndw * 4);
 
89
                ptr = (uint32_t*)r600_bo_map(rctx->radeon, shader->bo, 0, NULL);
 
90
                if (R600_BIG_ENDIAN) {
 
91
                        for (i = 0; i < rshader->bc.ndw; ++i) {
 
92
                                ptr[i] = bswap_32(rshader->bc.bytecode[i]);
 
93
                        }
 
94
                } else {
 
95
                        memcpy(ptr, rshader->bc.bytecode, rshader->bc.ndw * sizeof(*ptr));
 
96
                }
204
97
                r600_bo_unmap(rctx->radeon, shader->bo);
205
98
        }
206
99
        /* build state */
225
118
        return 0;
226
119
}
227
120
 
228
 
int r600_shader_from_tgsi(const struct tgsi_token *tokens, struct r600_shader *shader);
 
121
static int r600_shader_from_tgsi(const struct tgsi_token *tokens, struct r600_shader *shader);
 
122
 
229
123
int r600_pipe_shader_create(struct pipe_context *ctx, struct r600_pipe_shader *shader, const struct tgsi_token *tokens)
230
124
{
 
125
        static int dump_shaders = -1;
231
126
        struct r600_pipe_context *rctx = (struct r600_pipe_context *)ctx;
232
127
        int r;
233
128
 
234
 
//fprintf(stderr, "--------------------------------------------------------------\n");
235
 
//tgsi_dump(tokens, 0);
 
129
        /* Would like some magic "get_bool_option_once" routine.
 
130
        */
 
131
        if (dump_shaders == -1)
 
132
                dump_shaders = debug_get_bool_option("R600_DUMP_SHADERS", FALSE);
 
133
 
 
134
        if (dump_shaders) {
 
135
                fprintf(stderr, "--------------------------------------------------------------\n");
 
136
                tgsi_dump(tokens, 0);
 
137
        }
236
138
        shader->shader.family = r600_get_family(rctx->radeon);
237
139
        r = r600_shader_from_tgsi(tokens, &shader->shader);
238
140
        if (r) {
244
146
                R600_ERR("building bytecode failed !\n");
245
147
                return r;
246
148
        }
247
 
//r600_bc_dump(&shader->shader.bc);
248
 
//fprintf(stderr, "______________________________________________________________\n");
 
149
        if (dump_shaders) {
 
150
                r600_bc_dump(&shader->shader.bc);
 
151
                fprintf(stderr, "______________________________________________________________\n");
 
152
        }
249
153
        return r600_pipe_shader(ctx, shader);
250
154
}
251
155
 
262
166
 */
263
167
struct r600_shader_tgsi_instruction;
264
168
 
 
169
struct r600_shader_src {
 
170
        unsigned                                sel;
 
171
        unsigned                                swizzle[4];
 
172
        unsigned                                neg;
 
173
        unsigned                                abs;
 
174
        unsigned                                rel;
 
175
        uint32_t                                value[4];
 
176
};
 
177
 
265
178
struct r600_shader_ctx {
266
179
        struct tgsi_shader_info                 info;
267
180
        struct tgsi_parse_context               parse;
269
182
        unsigned                                type;
270
183
        unsigned                                file_offset[TGSI_FILE_COUNT];
271
184
        unsigned                                temp_reg;
 
185
        unsigned                                ar_reg;
272
186
        struct r600_shader_tgsi_instruction     *inst_info;
273
187
        struct r600_bc                          *bc;
274
188
        struct r600_shader                      *shader;
275
 
        u32                                     value[4];
 
189
        struct r600_shader_src                  src[4];
276
190
        u32                                     *literals;
277
191
        u32                                     nliterals;
278
192
        u32                                     max_driver_temp_used;
290
204
        int (*process)(struct r600_shader_ctx *ctx);
291
205
};
292
206
 
293
 
static struct r600_shader_tgsi_instruction r600_shader_tgsi_instruction[], eg_shader_tgsi_instruction[];
 
207
static struct r600_shader_tgsi_instruction r600_shader_tgsi_instruction[], eg_shader_tgsi_instruction[], cm_shader_tgsi_instruction[];
294
208
static int tgsi_helper_tempx_replicate(struct r600_shader_ctx *ctx);
295
209
 
296
210
static int tgsi_is_supported(struct r600_shader_ctx *ctx)
391
305
{
392
306
        struct tgsi_full_declaration *d = &ctx->parse.FullToken.FullDeclaration;
393
307
        unsigned i;
 
308
        int r;
394
309
 
395
310
        switch (d->Declaration.File) {
396
311
        case TGSI_FILE_INPUT:
400
315
                ctx->shader->input[i].interpolate = d->Declaration.Interpolate;
401
316
                ctx->shader->input[i].centroid = d->Declaration.Centroid;
402
317
                ctx->shader->input[i].gpr = ctx->file_offset[TGSI_FILE_INPUT] + i;
403
 
                if (ctx->type == TGSI_PROCESSOR_FRAGMENT && ctx->bc->chiprev == CHIPREV_EVERGREEN) {
 
318
                if (ctx->type == TGSI_PROCESSOR_FRAGMENT && ctx->bc->chiprev >= CHIPREV_EVERGREEN) {
404
319
                        /* turn input into interpolate on EG */
405
320
                        if (ctx->shader->input[i].name != TGSI_SEMANTIC_POSITION) {
406
321
                                if (ctx->shader->input[i].interpolate > 0) {
422
337
        case TGSI_FILE_SAMPLER:
423
338
        case TGSI_FILE_ADDRESS:
424
339
                break;
 
340
 
 
341
        case TGSI_FILE_SYSTEM_VALUE:
 
342
                if (d->Semantic.Name == TGSI_SEMANTIC_INSTANCEID) {
 
343
                        struct r600_bc_alu alu;
 
344
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
345
 
 
346
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_INT_TO_FLT);
 
347
                        alu.src[0].sel = 0;
 
348
                        alu.src[0].chan = 3;
 
349
 
 
350
                        alu.dst.sel = 0;
 
351
                        alu.dst.chan = 3;
 
352
                        alu.dst.write = 1;
 
353
                        alu.last = 1;
 
354
 
 
355
                        if ((r = r600_bc_add_alu(ctx->bc, &alu)))
 
356
                                return r;
 
357
                        break;
 
358
                }
 
359
 
425
360
        default:
426
361
                R600_ERR("unsupported file %d declaration\n", d->Declaration.File);
427
362
                return -EINVAL;
481
416
        return ctx->num_interp_gpr;
482
417
}
483
418
 
484
 
int r600_shader_from_tgsi(const struct tgsi_token *tokens, struct r600_shader *shader)
 
419
static void tgsi_src(struct r600_shader_ctx *ctx,
 
420
                     const struct tgsi_full_src_register *tgsi_src,
 
421
                     struct r600_shader_src *r600_src)
 
422
{
 
423
        memset(r600_src, 0, sizeof(*r600_src));
 
424
        r600_src->swizzle[0] = tgsi_src->Register.SwizzleX;
 
425
        r600_src->swizzle[1] = tgsi_src->Register.SwizzleY;
 
426
        r600_src->swizzle[2] = tgsi_src->Register.SwizzleZ;
 
427
        r600_src->swizzle[3] = tgsi_src->Register.SwizzleW;
 
428
        r600_src->neg = tgsi_src->Register.Negate;
 
429
        r600_src->abs = tgsi_src->Register.Absolute;
 
430
 
 
431
        if (tgsi_src->Register.File == TGSI_FILE_IMMEDIATE) {
 
432
                int index;
 
433
                if ((tgsi_src->Register.SwizzleX == tgsi_src->Register.SwizzleY) &&
 
434
                        (tgsi_src->Register.SwizzleX == tgsi_src->Register.SwizzleZ) &&
 
435
                        (tgsi_src->Register.SwizzleX == tgsi_src->Register.SwizzleW)) {
 
436
 
 
437
                        index = tgsi_src->Register.Index * 4 + tgsi_src->Register.SwizzleX;
 
438
                        r600_bc_special_constants(ctx->literals[index], &r600_src->sel, &r600_src->neg);
 
439
                        if (r600_src->sel != V_SQ_ALU_SRC_LITERAL)
 
440
                                return;
 
441
                }
 
442
                index = tgsi_src->Register.Index;
 
443
                r600_src->sel = V_SQ_ALU_SRC_LITERAL;
 
444
                memcpy(r600_src->value, ctx->literals + index * 4, sizeof(r600_src->value));
 
445
        } else if (tgsi_src->Register.File == TGSI_FILE_SYSTEM_VALUE) {
 
446
                /* assume we wan't TGSI_SEMANTIC_INSTANCEID here */
 
447
                r600_src->swizzle[0] = 3;
 
448
                r600_src->swizzle[1] = 3;
 
449
                r600_src->swizzle[2] = 3;
 
450
                r600_src->swizzle[3] = 3;
 
451
                r600_src->sel = 0;
 
452
        } else {
 
453
                if (tgsi_src->Register.Indirect)
 
454
                        r600_src->rel = V_SQ_REL_RELATIVE;
 
455
                r600_src->sel = tgsi_src->Register.Index;
 
456
                r600_src->sel += ctx->file_offset[tgsi_src->Register.File];
 
457
        }
 
458
}
 
459
 
 
460
static int tgsi_fetch_rel_const(struct r600_shader_ctx *ctx, unsigned int offset, unsigned int dst_reg)
 
461
{
 
462
        struct r600_bc_vtx vtx;
 
463
        unsigned int ar_reg;
 
464
        int r;
 
465
 
 
466
        if (offset) {
 
467
                struct r600_bc_alu alu;
 
468
 
 
469
                memset(&alu, 0, sizeof(alu));
 
470
 
 
471
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_ADD_INT);
 
472
                alu.src[0].sel = ctx->ar_reg;
 
473
 
 
474
                alu.src[1].sel = V_SQ_ALU_SRC_LITERAL;
 
475
                alu.src[1].value = offset;
 
476
 
 
477
                alu.dst.sel = dst_reg;
 
478
                alu.dst.write = 1;
 
479
                alu.last = 1;
 
480
 
 
481
                if ((r = r600_bc_add_alu(ctx->bc, &alu)))
 
482
                        return r;
 
483
 
 
484
                ar_reg = dst_reg;
 
485
        } else {
 
486
                ar_reg = ctx->ar_reg;
 
487
        }
 
488
 
 
489
        memset(&vtx, 0, sizeof(vtx));
 
490
        vtx.fetch_type = 2;             /* VTX_FETCH_NO_INDEX_OFFSET */
 
491
        vtx.src_gpr = ar_reg;
 
492
        vtx.mega_fetch_count = 16;
 
493
        vtx.dst_gpr = dst_reg;
 
494
        vtx.dst_sel_x = 0;              /* SEL_X */
 
495
        vtx.dst_sel_y = 1;              /* SEL_Y */
 
496
        vtx.dst_sel_z = 2;              /* SEL_Z */
 
497
        vtx.dst_sel_w = 3;              /* SEL_W */
 
498
        vtx.data_format = FMT_32_32_32_32_FLOAT;
 
499
        vtx.num_format_all = 2;         /* NUM_FORMAT_SCALED */
 
500
        vtx.format_comp_all = 1;        /* FORMAT_COMP_SIGNED */
 
501
        vtx.srf_mode_all = 1;           /* SRF_MODE_NO_ZERO */
 
502
        vtx.endian = r600_endian_swap(32);
 
503
 
 
504
        if ((r = r600_bc_add_vtx(ctx->bc, &vtx)))
 
505
                return r;
 
506
 
 
507
        return 0;
 
508
}
 
509
 
 
510
static int tgsi_split_constant(struct r600_shader_ctx *ctx)
 
511
{
 
512
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
 
513
        struct r600_bc_alu alu;
 
514
        int i, j, k, nconst, r;
 
515
 
 
516
        for (i = 0, nconst = 0; i < inst->Instruction.NumSrcRegs; i++) {
 
517
                if (inst->Src[i].Register.File == TGSI_FILE_CONSTANT) {
 
518
                        nconst++;
 
519
                }
 
520
                tgsi_src(ctx, &inst->Src[i], &ctx->src[i]);
 
521
        }
 
522
        for (i = 0, j = nconst - 1; i < inst->Instruction.NumSrcRegs; i++) {
 
523
                if (inst->Src[i].Register.File != TGSI_FILE_CONSTANT) {
 
524
                        continue;
 
525
                }
 
526
 
 
527
                if (ctx->src[i].rel) {
 
528
                        int treg = r600_get_temp(ctx);
 
529
                        if ((r = tgsi_fetch_rel_const(ctx, ctx->src[i].sel - 512, treg)))
 
530
                                return r;
 
531
 
 
532
                        ctx->src[i].sel = treg;
 
533
                        ctx->src[i].rel = 0;
 
534
                        j--;
 
535
                } else if (j > 0) {
 
536
                        int treg = r600_get_temp(ctx);
 
537
                        for (k = 0; k < 4; k++) {
 
538
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
539
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
 
540
                                alu.src[0].sel = ctx->src[i].sel;
 
541
                                alu.src[0].chan = k;
 
542
                                alu.src[0].rel = ctx->src[i].rel;
 
543
                                alu.dst.sel = treg;
 
544
                                alu.dst.chan = k;
 
545
                                alu.dst.write = 1;
 
546
                                if (k == 3)
 
547
                                        alu.last = 1;
 
548
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
549
                                if (r)
 
550
                                        return r;
 
551
                        }
 
552
                        ctx->src[i].sel = treg;
 
553
                        ctx->src[i].rel =0;
 
554
                        j--;
 
555
                }
 
556
        }
 
557
        return 0;
 
558
}
 
559
 
 
560
/* need to move any immediate into a temp - for trig functions which use literal for PI stuff */
 
561
static int tgsi_split_literal_constant(struct r600_shader_ctx *ctx)
 
562
{
 
563
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
 
564
        struct r600_bc_alu alu;
 
565
        int i, j, k, nliteral, r;
 
566
 
 
567
        for (i = 0, nliteral = 0; i < inst->Instruction.NumSrcRegs; i++) {
 
568
                if (ctx->src[i].sel == V_SQ_ALU_SRC_LITERAL) {
 
569
                        nliteral++;
 
570
                }
 
571
        }
 
572
        for (i = 0, j = nliteral - 1; i < inst->Instruction.NumSrcRegs; i++) {
 
573
                if (j > 0 && ctx->src[i].sel == V_SQ_ALU_SRC_LITERAL) {
 
574
                        int treg = r600_get_temp(ctx);
 
575
                        for (k = 0; k < 4; k++) {
 
576
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
577
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
 
578
                                alu.src[0].sel = ctx->src[i].sel;
 
579
                                alu.src[0].chan = k;
 
580
                                alu.src[0].value = ctx->src[i].value[k];
 
581
                                alu.dst.sel = treg;
 
582
                                alu.dst.chan = k;
 
583
                                alu.dst.write = 1;
 
584
                                if (k == 3)
 
585
                                        alu.last = 1;
 
586
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
587
                                if (r)
 
588
                                        return r;
 
589
                        }
 
590
                        ctx->src[i].sel = treg;
 
591
                        j--;
 
592
                }
 
593
        }
 
594
        return 0;
 
595
}
 
596
 
 
597
static int r600_shader_from_tgsi(const struct tgsi_token *tokens, struct r600_shader *shader)
485
598
{
486
599
        struct tgsi_full_immediate *immediate;
 
600
        struct tgsi_full_property *property;
487
601
        struct r600_shader_ctx ctx;
488
602
        struct r600_bc_output output[32];
489
603
        unsigned output_done, noutput;
506
620
        /* Values [0,127] correspond to GPR[0..127].
507
621
         * Values [128,159] correspond to constant buffer bank 0
508
622
         * Values [160,191] correspond to constant buffer bank 1
509
 
         * Values [256,511] correspond to cfile constants c[0..255].
 
623
         * Values [256,511] correspond to cfile constants c[0..255]. (Gone on EG)
 
624
         * Values [256,287] correspond to constant buffer bank 2 (EG)
 
625
         * Values [288,319] correspond to constant buffer bank 3 (EG)
510
626
         * Other special values are shown in the list below.
511
627
         * 244  ALU_SRC_1_DBL_L: special constant 1.0 double-float, LSW. (RV670+)
512
628
         * 245  ALU_SRC_1_DBL_M: special constant 1.0 double-float, MSW. (RV670+)
526
642
        }
527
643
        if (ctx.type == TGSI_PROCESSOR_VERTEX) {
528
644
                ctx.file_offset[TGSI_FILE_INPUT] = 1;
529
 
                if (ctx.bc->chiprev == CHIPREV_EVERGREEN) {
 
645
                if (ctx.bc->chiprev >= CHIPREV_EVERGREEN) {
530
646
                        r600_bc_add_cfinst(ctx.bc, EG_V_SQ_CF_WORD1_SQ_CF_INST_CALL_FS);
531
647
                } else {
532
648
                        r600_bc_add_cfinst(ctx.bc, V_SQ_CF_WORD1_SQ_CF_INST_CALL_FS);
533
649
                }
534
650
        }
535
 
        if (ctx.type == TGSI_PROCESSOR_FRAGMENT && ctx.bc->chiprev == CHIPREV_EVERGREEN) {
 
651
        if (ctx.type == TGSI_PROCESSOR_FRAGMENT && ctx.bc->chiprev >= CHIPREV_EVERGREEN) {
536
652
                ctx.file_offset[TGSI_FILE_INPUT] = evergreen_gpr_count(&ctx);
537
653
        }
538
654
        ctx.file_offset[TGSI_FILE_OUTPUT] = ctx.file_offset[TGSI_FILE_INPUT] +
540
656
        ctx.file_offset[TGSI_FILE_TEMPORARY] = ctx.file_offset[TGSI_FILE_OUTPUT] +
541
657
                                                ctx.info.file_count[TGSI_FILE_OUTPUT];
542
658
 
543
 
        ctx.file_offset[TGSI_FILE_CONSTANT] = 128;
 
659
        /* Outside the GPR range. This will be translated to one of the
 
660
         * kcache banks later. */
 
661
        ctx.file_offset[TGSI_FILE_CONSTANT] = 512;
544
662
 
545
 
        ctx.file_offset[TGSI_FILE_IMMEDIATE] = 253;
546
 
        ctx.temp_reg = ctx.file_offset[TGSI_FILE_TEMPORARY] +
 
663
        ctx.file_offset[TGSI_FILE_IMMEDIATE] = V_SQ_ALU_SRC_LITERAL;
 
664
        ctx.ar_reg = ctx.file_offset[TGSI_FILE_TEMPORARY] +
547
665
                        ctx.info.file_count[TGSI_FILE_TEMPORARY];
 
666
        ctx.temp_reg = ctx.ar_reg + 1;
548
667
 
549
668
        ctx.nliterals = 0;
550
669
        ctx.literals = NULL;
551
 
 
 
670
        shader->fs_write_all = FALSE;
552
671
        while (!tgsi_parse_end_of_tokens(&ctx.parse)) {
553
672
                tgsi_parse_token(&ctx.parse);
554
673
                switch (ctx.parse.FullToken.Token.Type) {
577
696
                        ctx.max_driver_temp_used = 0;
578
697
                        /* reserve first tmp for everyone */
579
698
                        r600_get_temp(&ctx);
 
699
 
580
700
                        opcode = ctx.parse.FullToken.FullInstruction.Instruction.Opcode;
581
 
                        if (ctx.bc->chiprev == CHIPREV_EVERGREEN)
 
701
                        if ((r = tgsi_split_constant(&ctx)))
 
702
                                goto out_err;
 
703
                        if ((r = tgsi_split_literal_constant(&ctx)))
 
704
                                goto out_err;
 
705
                        if (ctx.bc->chiprev == CHIPREV_CAYMAN)
 
706
                                ctx.inst_info = &cm_shader_tgsi_instruction[opcode];
 
707
                        else if (ctx.bc->chiprev >= CHIPREV_EVERGREEN)
582
708
                                ctx.inst_info = &eg_shader_tgsi_instruction[opcode];
583
709
                        else
584
710
                                ctx.inst_info = &r600_shader_tgsi_instruction[opcode];
585
711
                        r = ctx.inst_info->process(&ctx);
586
712
                        if (r)
587
713
                                goto out_err;
588
 
                        r = r600_bc_add_literal(ctx.bc, ctx.value);
589
 
                        if (r)
590
 
                                goto out_err;
591
714
                        break;
592
715
                case TGSI_TOKEN_TYPE_PROPERTY:
 
716
                        property = &ctx.parse.FullToken.FullProperty;
 
717
                        if (property->Property.PropertyName == TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS) {
 
718
                                if (property->u[0].Data == 1)
 
719
                                        shader->fs_write_all = TRUE;
 
720
                        }
593
721
                        break;
594
722
                default:
595
723
                        R600_ERR("unsupported token type %d\n", ctx.parse.FullToken.Token.Type);
607
735
                output[i].swizzle_y = 1;
608
736
                output[i].swizzle_z = 2;
609
737
                output[i].swizzle_w = 3;
 
738
                output[i].burst_count = 1;
610
739
                output[i].barrier = 1;
611
740
                output[i].type = V_SQ_CF_ALLOC_EXPORT_WORD0_SQ_EXPORT_PARAM;
612
741
                output[i].array_base = i - pos0;
670
799
                        output[i].swizzle_y = 1;
671
800
                        output[i].swizzle_z = 2;
672
801
                        output[i].swizzle_w = 3;
 
802
                        output[i].burst_count = 1;
673
803
                        output[i].barrier = 1;
674
804
                        output[i].type = V_SQ_CF_ALLOC_EXPORT_WORD0_SQ_EXPORT_PARAM;
675
805
                        output[i].array_base = 0;
686
816
                output[0].swizzle_y = 7;
687
817
                output[0].swizzle_z = 7;
688
818
                output[0].swizzle_w = 7;
 
819
                output[0].burst_count = 1;
689
820
                output[0].barrier = 1;
690
821
                output[0].type = V_SQ_CF_ALLOC_EXPORT_WORD0_SQ_EXPORT_PIXEL;
691
822
                output[0].array_base = 0;
694
825
        }
695
826
        /* set export done on last export of each type */
696
827
        for (i = noutput - 1, output_done = 0; i >= 0; i--) {
697
 
                if (i == (noutput - 1)) {
698
 
                        output[i].end_of_program = 1;
 
828
                if (ctx.bc->chiprev < CHIPREV_CAYMAN) {
 
829
                        if (i == (noutput - 1)) {
 
830
                                output[i].end_of_program = 1;
 
831
                        }
699
832
                }
700
833
                if (!(output_done & (1 << output[i].type))) {
701
834
                        output_done |= (1 << output[i].type);
708
841
                if (r)
709
842
                        goto out_err;
710
843
        }
 
844
        /* add program end */
 
845
        if (ctx.bc->chiprev == CHIPREV_CAYMAN)
 
846
                cm_bc_add_cf_end(ctx.bc);
 
847
 
711
848
        free(ctx.literals);
712
849
        tgsi_parse_free(&ctx.parse);
713
850
        return 0;
719
856
 
720
857
static int tgsi_unsupported(struct r600_shader_ctx *ctx)
721
858
{
722
 
        R600_ERR("%d tgsi opcode unsupported\n", ctx->inst_info->tgsi_opcode);
 
859
        R600_ERR("%s tgsi opcode unsupported\n",
 
860
                 tgsi_get_opcode_name(ctx->inst_info->tgsi_opcode));
723
861
        return -EINVAL;
724
862
}
725
863
 
728
866
        return 0;
729
867
}
730
868
 
731
 
static int tgsi_src(struct r600_shader_ctx *ctx,
732
 
                        const struct tgsi_full_src_register *tgsi_src,
733
 
                        struct r600_bc_alu_src *r600_src)
 
869
static void r600_bc_src(struct r600_bc_alu_src *bc_src,
 
870
                        const struct r600_shader_src *shader_src,
 
871
                        unsigned chan)
734
872
{
735
 
        int index;
736
 
        memset(r600_src, 0, sizeof(struct r600_bc_alu_src));
737
 
        r600_src->sel = tgsi_src->Register.Index;
738
 
        if (tgsi_src->Register.File == TGSI_FILE_IMMEDIATE) {
739
 
                r600_src->sel = 0;
740
 
                index = tgsi_src->Register.Index;
741
 
                ctx->value[0] = ctx->literals[index * 4 + 0];
742
 
                ctx->value[1] = ctx->literals[index * 4 + 1];
743
 
                ctx->value[2] = ctx->literals[index * 4 + 2];
744
 
                ctx->value[3] = ctx->literals[index * 4 + 3];
745
 
        }
746
 
        if (tgsi_src->Register.Indirect)
747
 
                r600_src->rel = V_SQ_REL_RELATIVE;
748
 
        r600_src->neg = tgsi_src->Register.Negate;
749
 
        r600_src->abs = tgsi_src->Register.Absolute;
750
 
        r600_src->sel += ctx->file_offset[tgsi_src->Register.File];
751
 
        return 0;
 
873
        bc_src->sel = shader_src->sel;
 
874
        bc_src->chan = shader_src->swizzle[chan];
 
875
        bc_src->neg = shader_src->neg;
 
876
        bc_src->abs = shader_src->abs;
 
877
        bc_src->rel = shader_src->rel;
 
878
        bc_src->value = shader_src->value[bc_src->chan];
752
879
}
753
880
 
754
 
static int tgsi_dst(struct r600_shader_ctx *ctx,
755
 
                        const struct tgsi_full_dst_register *tgsi_dst,
756
 
                        unsigned swizzle,
757
 
                        struct r600_bc_alu_dst *r600_dst)
 
881
static void tgsi_dst(struct r600_shader_ctx *ctx,
 
882
                     const struct tgsi_full_dst_register *tgsi_dst,
 
883
                     unsigned swizzle,
 
884
                     struct r600_bc_alu_dst *r600_dst)
758
885
{
759
886
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
760
887
 
767
894
        if (inst->Instruction.Saturate) {
768
895
                r600_dst->clamp = 1;
769
896
        }
770
 
        return 0;
771
 
}
772
 
 
773
 
static unsigned tgsi_chan(const struct tgsi_full_src_register *tgsi_src, unsigned swizzle)
774
 
{
775
 
        switch (swizzle) {
776
 
        case 0:
777
 
                return tgsi_src->Register.SwizzleX;
778
 
        case 1:
779
 
                return tgsi_src->Register.SwizzleY;
780
 
        case 2:
781
 
                return tgsi_src->Register.SwizzleZ;
782
 
        case 3:
783
 
                return tgsi_src->Register.SwizzleW;
784
 
        default:
785
 
                return 0;
786
 
        }
787
 
}
788
 
 
789
 
static int tgsi_split_constant(struct r600_shader_ctx *ctx, struct r600_bc_alu_src r600_src[3])
790
 
{
791
 
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
792
 
        struct r600_bc_alu alu;
793
 
        int i, j, k, nconst, r;
794
 
 
795
 
        for (i = 0, nconst = 0; i < inst->Instruction.NumSrcRegs; i++) {
796
 
                if (inst->Src[i].Register.File == TGSI_FILE_CONSTANT) {
797
 
                        nconst++;
798
 
                }
799
 
                r = tgsi_src(ctx, &inst->Src[i], &r600_src[i]);
800
 
                if (r) {
801
 
                        return r;
802
 
                }
803
 
        }
804
 
        for (i = 0, j = nconst - 1; i < inst->Instruction.NumSrcRegs; i++) {
805
 
                if (j > 0 && inst->Src[i].Register.File == TGSI_FILE_CONSTANT) {
806
 
                        int treg = r600_get_temp(ctx);
807
 
                        for (k = 0; k < 4; k++) {
808
 
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
809
 
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
810
 
                                alu.src[0].sel = r600_src[i].sel;
811
 
                                alu.src[0].chan = k;
812
 
                                alu.src[0].rel = r600_src[i].rel;
813
 
                                alu.dst.sel = treg;
814
 
                                alu.dst.chan = k;
815
 
                                alu.dst.write = 1;
816
 
                                if (k == 3)
817
 
                                        alu.last = 1;
818
 
                                r = r600_bc_add_alu(ctx->bc, &alu);
819
 
                                if (r)
820
 
                                        return r;
821
 
                        }
822
 
                        r600_src[i].sel = treg;
823
 
                        r600_src[i].rel =0;
824
 
                        j--;
825
 
                }
826
 
        }
827
 
        return 0;
828
 
}
829
 
 
830
 
/* need to move any immediate into a temp - for trig functions which use literal for PI stuff */
831
 
static int tgsi_split_literal_constant(struct r600_shader_ctx *ctx, struct r600_bc_alu_src r600_src[3])
832
 
{
833
 
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
834
 
        struct r600_bc_alu alu;
835
 
        int i, j, k, nliteral, r;
836
 
 
837
 
        for (i = 0, nliteral = 0; i < inst->Instruction.NumSrcRegs; i++) {
838
 
                if (inst->Src[i].Register.File == TGSI_FILE_IMMEDIATE) {
839
 
                        nliteral++;
840
 
                }
841
 
        }
842
 
        for (i = 0, j = nliteral - 1; i < inst->Instruction.NumSrcRegs; i++) {
843
 
                if (j > 0 && inst->Src[i].Register.File == TGSI_FILE_IMMEDIATE) {
844
 
                        int treg = r600_get_temp(ctx);
845
 
                        for (k = 0; k < 4; k++) {
846
 
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
847
 
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
848
 
                                alu.src[0].sel = r600_src[i].sel;
849
 
                                alu.src[0].chan = k;
850
 
                                alu.dst.sel = treg;
851
 
                                alu.dst.chan = k;
852
 
                                alu.dst.write = 1;
853
 
                                if (k == 3)
854
 
                                        alu.last = 1;
855
 
                                r = r600_bc_add_alu(ctx->bc, &alu);
856
 
                                if (r)
857
 
                                        return r;
858
 
                        }
859
 
                        r = r600_bc_add_literal(ctx->bc, &ctx->literals[inst->Src[i].Register.Index * 4]);
860
 
                        if (r)
861
 
                                return r;
862
 
                        r600_src[i].sel = treg;
863
 
                        j--;
864
 
                }
865
 
        }
866
 
        return 0;
 
897
}
 
898
 
 
899
static int tgsi_last_instruction(unsigned writemask)
 
900
{
 
901
        int i, lasti = 0;
 
902
 
 
903
        for (i = 0; i < 4; i++) {
 
904
                if (writemask & (1 << i)) {
 
905
                        lasti = i;
 
906
                }
 
907
        }
 
908
        return lasti;
867
909
}
868
910
 
869
911
static int tgsi_op2_s(struct r600_shader_ctx *ctx, int swap)
870
912
{
871
913
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
872
 
        struct r600_bc_alu_src r600_src[3];
873
914
        struct r600_bc_alu alu;
874
915
        int i, j, r;
875
 
        int lasti = 0;
876
 
 
877
 
        for (i = 0; i < 4; i++) {
878
 
                if (inst->Dst[0].Register.WriteMask & (1 << i)) {
879
 
                        lasti = i;
880
 
                }
881
 
        }
882
 
 
883
 
        r = tgsi_split_constant(ctx, r600_src);
884
 
        if (r)
885
 
                return r;
886
 
        r = tgsi_split_literal_constant(ctx, r600_src);
887
 
        if (r)
888
 
                return r;
 
916
        int lasti = tgsi_last_instruction(inst->Dst[0].Register.WriteMask);
 
917
 
889
918
        for (i = 0; i < lasti + 1; i++) {
890
919
                if (!(inst->Dst[0].Register.WriteMask & (1 << i)))
891
920
                        continue;
892
921
 
893
922
                memset(&alu, 0, sizeof(struct r600_bc_alu));
894
 
                r = tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
895
 
                if (r)
896
 
                        return r;
 
923
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
897
924
 
898
925
                alu.inst = ctx->inst_info->r600_opcode;
899
926
                if (!swap) {
900
927
                        for (j = 0; j < inst->Instruction.NumSrcRegs; j++) {
901
 
                                alu.src[j] = r600_src[j];
902
 
                                alu.src[j].chan = tgsi_chan(&inst->Src[j], i);
 
928
                                r600_bc_src(&alu.src[j], &ctx->src[j], i);
903
929
                        }
904
930
                } else {
905
 
                        alu.src[0] = r600_src[1];
906
 
                        alu.src[0].chan = tgsi_chan(&inst->Src[1], i);
907
 
 
908
 
                        alu.src[1] = r600_src[0];
909
 
                        alu.src[1].chan = tgsi_chan(&inst->Src[0], i);
 
931
                        r600_bc_src(&alu.src[0], &ctx->src[1], i);
 
932
                        r600_bc_src(&alu.src[1], &ctx->src[0], i);
910
933
                }
911
934
                /* handle some special cases */
912
935
                switch (ctx->inst_info->tgsi_opcode) {
915
938
                        break;
916
939
                case TGSI_OPCODE_ABS:
917
940
                        alu.src[0].abs = 1;
 
941
                        if (alu.src[0].neg)
 
942
                          alu.src[0].neg = 0;
918
943
                        break;
919
944
                default:
920
945
                        break;
939
964
        return tgsi_op2_s(ctx, 1);
940
965
}
941
966
 
 
967
static int cayman_emit_float_instr(struct r600_shader_ctx *ctx)
 
968
{
 
969
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
 
970
        int i, j, r;
 
971
        struct r600_bc_alu alu;
 
972
        int last_slot = (inst->Dst[0].Register.WriteMask & 0x8) ? 4 : 3;
 
973
        
 
974
        for (i = 0 ; i < last_slot; i++) {
 
975
                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
976
                alu.inst = ctx->inst_info->r600_opcode;
 
977
                for (j = 0; j < inst->Instruction.NumSrcRegs; j++) {
 
978
                        r600_bc_src(&alu.src[j], &ctx->src[j], 0);
 
979
                }
 
980
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
 
981
                alu.dst.write = (inst->Dst[0].Register.WriteMask >> i) & 1;
 
982
 
 
983
                if (i == last_slot - 1)
 
984
                        alu.last = 1;
 
985
                r = r600_bc_add_alu(ctx->bc, &alu);
 
986
                if (r)
 
987
                        return r;
 
988
        }
 
989
        return 0;
 
990
}
 
991
 
942
992
/*
943
993
 * r600 - trunc to -PI..PI range
944
994
 * r700 - normalize by dividing by 2PI
945
995
 * see fdo bug 27901
946
996
 */
947
 
static int tgsi_setup_trig(struct r600_shader_ctx *ctx,
948
 
                           struct r600_bc_alu_src r600_src[3])
 
997
static int tgsi_setup_trig(struct r600_shader_ctx *ctx)
949
998
{
950
 
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
 
999
        static float half_inv_pi = 1.0 /(3.1415926535 * 2);
 
1000
        static float double_pi = 3.1415926535 * 2;
 
1001
        static float neg_pi = -3.1415926535;
 
1002
 
951
1003
        int r;
952
 
        uint32_t lit_vals[4];
953
1004
        struct r600_bc_alu alu;
954
1005
 
955
 
        memset(lit_vals, 0, 4*4);
956
 
        r = tgsi_split_constant(ctx, r600_src);
957
 
        if (r)
958
 
                return r;
959
 
        r = tgsi_split_literal_constant(ctx, r600_src);
960
 
        if (r)
961
 
                return r;
962
 
 
963
 
        lit_vals[0] = fui(1.0 /(3.1415926535 * 2));
964
 
        lit_vals[1] = fui(0.5f);
965
 
 
966
1006
        memset(&alu, 0, sizeof(struct r600_bc_alu));
967
1007
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP3_SQ_OP3_INST_MULADD);
968
1008
        alu.is_op3 = 1;
971
1011
        alu.dst.sel = ctx->temp_reg;
972
1012
        alu.dst.write = 1;
973
1013
 
974
 
        alu.src[0] = r600_src[0];
975
 
        alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
 
1014
        r600_bc_src(&alu.src[0], &ctx->src[0], 0);
976
1015
 
977
1016
        alu.src[1].sel = V_SQ_ALU_SRC_LITERAL;
978
1017
        alu.src[1].chan = 0;
979
 
        alu.src[2].sel = V_SQ_ALU_SRC_LITERAL;
980
 
        alu.src[2].chan = 1;
 
1018
        alu.src[1].value = *(uint32_t *)&half_inv_pi;
 
1019
        alu.src[2].sel = V_SQ_ALU_SRC_0_5;
 
1020
        alu.src[2].chan = 0;
981
1021
        alu.last = 1;
982
1022
        r = r600_bc_add_alu(ctx->bc, &alu);
983
1023
        if (r)
984
1024
                return r;
985
 
        r = r600_bc_add_literal(ctx->bc, lit_vals);
986
 
        if (r)
987
 
                return r;
988
1025
 
989
1026
        memset(&alu, 0, sizeof(struct r600_bc_alu));
990
1027
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_FRACT);
1000
1037
        if (r)
1001
1038
                return r;
1002
1039
 
 
1040
        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1041
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP3_SQ_OP3_INST_MULADD);
 
1042
        alu.is_op3 = 1;
 
1043
 
 
1044
        alu.dst.chan = 0;
 
1045
        alu.dst.sel = ctx->temp_reg;
 
1046
        alu.dst.write = 1;
 
1047
 
 
1048
        alu.src[0].sel = ctx->temp_reg;
 
1049
        alu.src[0].chan = 0;
 
1050
 
 
1051
        alu.src[1].sel = V_SQ_ALU_SRC_LITERAL;
 
1052
        alu.src[1].chan = 0;
 
1053
        alu.src[2].sel = V_SQ_ALU_SRC_LITERAL;
 
1054
        alu.src[2].chan = 0;
 
1055
 
1003
1056
        if (ctx->bc->chiprev == CHIPREV_R600) {
1004
 
                lit_vals[0] = fui(3.1415926535897f * 2.0f);
1005
 
                lit_vals[1] = fui(-3.1415926535897f);
 
1057
                alu.src[1].value = *(uint32_t *)&double_pi;
 
1058
                alu.src[2].value = *(uint32_t *)&neg_pi;
1006
1059
        } else {
1007
 
                lit_vals[0] = fui(1.0f);
1008
 
                lit_vals[1] = fui(-0.5f);
 
1060
                alu.src[1].sel = V_SQ_ALU_SRC_1;
 
1061
                alu.src[2].sel = V_SQ_ALU_SRC_0_5;
 
1062
                alu.src[2].neg = 1;
1009
1063
        }
1010
1064
 
1011
 
        memset(&alu, 0, sizeof(struct r600_bc_alu));
1012
 
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP3_SQ_OP3_INST_MULADD);
1013
 
        alu.is_op3 = 1;
1014
 
 
1015
 
        alu.dst.chan = 0;
1016
 
        alu.dst.sel = ctx->temp_reg;
1017
 
        alu.dst.write = 1;
1018
 
 
1019
 
        alu.src[0].sel = ctx->temp_reg;
1020
 
        alu.src[0].chan = 0;
1021
 
 
1022
 
        alu.src[1].sel = V_SQ_ALU_SRC_LITERAL;
1023
 
        alu.src[1].chan = 0;
1024
 
        alu.src[2].sel = V_SQ_ALU_SRC_LITERAL;
1025
 
        alu.src[2].chan = 1;
1026
1065
        alu.last = 1;
1027
1066
        r = r600_bc_add_alu(ctx->bc, &alu);
1028
1067
        if (r)
1029
1068
                return r;
1030
 
        r = r600_bc_add_literal(ctx->bc, lit_vals);
 
1069
        return 0;
 
1070
}
 
1071
 
 
1072
static int cayman_trig(struct r600_shader_ctx *ctx)
 
1073
{
 
1074
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
 
1075
        struct r600_bc_alu alu;
 
1076
        int last_slot = (inst->Dst[0].Register.WriteMask & 0x8) ? 4 : 3;
 
1077
        int i, r;
 
1078
 
 
1079
        r = tgsi_setup_trig(ctx);
1031
1080
        if (r)
1032
1081
                return r;
 
1082
 
 
1083
 
 
1084
        for (i = 0; i < last_slot; i++) {
 
1085
                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1086
                alu.inst = ctx->inst_info->r600_opcode;
 
1087
                alu.dst.chan = i;
 
1088
 
 
1089
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
 
1090
                alu.dst.write = (inst->Dst[0].Register.WriteMask >> i) & 1;
 
1091
 
 
1092
                alu.src[0].sel = ctx->temp_reg;
 
1093
                alu.src[0].chan = 0;
 
1094
                if (i == last_slot - 1)
 
1095
                        alu.last = 1;
 
1096
                r = r600_bc_add_alu(ctx->bc, &alu);
 
1097
                if (r)
 
1098
                        return r;
 
1099
        }
1033
1100
        return 0;
1034
1101
}
1035
1102
 
1036
1103
static int tgsi_trig(struct r600_shader_ctx *ctx)
1037
1104
{
1038
1105
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
1039
 
        struct r600_bc_alu_src r600_src[3];
1040
1106
        struct r600_bc_alu alu;
1041
1107
        int i, r;
1042
 
        int lasti = 0;
 
1108
        int lasti = tgsi_last_instruction(inst->Dst[0].Register.WriteMask);
1043
1109
 
1044
 
        r = tgsi_setup_trig(ctx, r600_src);
 
1110
        r = tgsi_setup_trig(ctx);
1045
1111
        if (r)
1046
1112
                return r;
1047
1113
 
1059
1125
                return r;
1060
1126
 
1061
1127
        /* replicate result */
1062
 
        for (i = 0; i < 4; i++) {
1063
 
                if (inst->Dst[0].Register.WriteMask & (1 << i))
1064
 
                        lasti = i;
1065
 
        }
1066
1128
        for (i = 0; i < lasti + 1; i++) {
1067
1129
                if (!(inst->Dst[0].Register.WriteMask & (1 << i)))
1068
1130
                        continue;
1071
1133
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
1072
1134
 
1073
1135
                alu.src[0].sel = ctx->temp_reg;
1074
 
                r = tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
1075
 
                if (r)
1076
 
                        return r;
 
1136
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
1077
1137
                if (i == lasti)
1078
1138
                        alu.last = 1;
1079
1139
                r = r600_bc_add_alu(ctx->bc, &alu);
1086
1146
static int tgsi_scs(struct r600_shader_ctx *ctx)
1087
1147
{
1088
1148
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
1089
 
        struct r600_bc_alu_src r600_src[3];
1090
1149
        struct r600_bc_alu alu;
1091
 
        int r;
 
1150
        int i, r;
1092
1151
 
1093
1152
        /* We'll only need the trig stuff if we are going to write to the
1094
1153
         * X or Y components of the destination vector.
1095
1154
         */
1096
1155
        if (likely(inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_XY)) {
1097
 
                r = tgsi_setup_trig(ctx, r600_src);
 
1156
                r = tgsi_setup_trig(ctx);
1098
1157
                if (r)
1099
1158
                        return r;
1100
1159
        }
1101
1160
 
1102
1161
        /* dst.x = COS */
1103
1162
        if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_X) {
1104
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1105
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_COS);
1106
 
                r = tgsi_dst(ctx, &inst->Dst[0], 0, &alu.dst);
1107
 
                if (r)
1108
 
                        return r;
1109
 
 
1110
 
                alu.src[0].sel = ctx->temp_reg;
1111
 
                alu.src[0].chan = 0;
1112
 
                alu.last = 1;
1113
 
                r = r600_bc_add_alu(ctx->bc, &alu);
1114
 
                if (r)
1115
 
                        return r;
 
1163
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
1164
                        for (i = 0 ; i < 3; i++) {
 
1165
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1166
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_COS);
 
1167
                                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
 
1168
 
 
1169
                                if (i == 0)
 
1170
                                        alu.dst.write = 1;
 
1171
                                else
 
1172
                                        alu.dst.write = 0;
 
1173
                                alu.src[0].sel = ctx->temp_reg;
 
1174
                                alu.src[0].chan = 0;
 
1175
                                if (i == 2)
 
1176
                                        alu.last = 1;
 
1177
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
1178
                                if (r)
 
1179
                                        return r;
 
1180
                        }
 
1181
                } else {
 
1182
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1183
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_COS);
 
1184
                        tgsi_dst(ctx, &inst->Dst[0], 0, &alu.dst);
 
1185
 
 
1186
                        alu.src[0].sel = ctx->temp_reg;
 
1187
                        alu.src[0].chan = 0;
 
1188
                        alu.last = 1;
 
1189
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
1190
                        if (r)
 
1191
                                return r;
 
1192
                }
1116
1193
        }
1117
1194
 
1118
1195
        /* dst.y = SIN */
1119
1196
        if (inst->Dst[0].Register.WriteMask & TGSI_WRITEMASK_Y) {
1120
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1121
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SIN);
1122
 
                r = tgsi_dst(ctx, &inst->Dst[0], 1, &alu.dst);
1123
 
                if (r)
1124
 
                        return r;
 
1197
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
1198
                        for (i = 0 ; i < 3; i++) {
 
1199
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1200
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SIN);
 
1201
                                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
 
1202
                                if (i == 1)
 
1203
                                        alu.dst.write = 1;
 
1204
                                else
 
1205
                                        alu.dst.write = 0;
 
1206
                                alu.src[0].sel = ctx->temp_reg;
 
1207
                                alu.src[0].chan = 0;
 
1208
                                if (i == 2)
 
1209
                                        alu.last = 1;
 
1210
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
1211
                                if (r)
 
1212
                                        return r;
 
1213
                        }
 
1214
                } else {
 
1215
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1216
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SIN);
 
1217
                        tgsi_dst(ctx, &inst->Dst[0], 1, &alu.dst);
1125
1218
 
1126
 
                alu.src[0].sel = ctx->temp_reg;
1127
 
                alu.src[0].chan = 0;
1128
 
                alu.last = 1;
1129
 
                r = r600_bc_add_alu(ctx->bc, &alu);
1130
 
                if (r)
1131
 
                        return r;
 
1219
                        alu.src[0].sel = ctx->temp_reg;
 
1220
                        alu.src[0].chan = 0;
 
1221
                        alu.last = 1;
 
1222
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
1223
                        if (r)
 
1224
                                return r;
 
1225
                }
1132
1226
        }
1133
1227
 
1134
1228
        /* dst.z = 0.0; */
1137
1231
 
1138
1232
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
1139
1233
 
1140
 
                r = tgsi_dst(ctx, &inst->Dst[0], 2, &alu.dst);
1141
 
                if (r)
1142
 
                        return r;
 
1234
                tgsi_dst(ctx, &inst->Dst[0], 2, &alu.dst);
1143
1235
 
1144
1236
                alu.src[0].sel = V_SQ_ALU_SRC_0;
1145
1237
                alu.src[0].chan = 0;
1149
1241
                r = r600_bc_add_alu(ctx->bc, &alu);
1150
1242
                if (r)
1151
1243
                        return r;
1152
 
 
1153
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
1154
 
                if (r)
1155
 
                        return r;
1156
1244
        }
1157
1245
 
1158
1246
        /* dst.w = 1.0; */
1161
1249
 
1162
1250
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
1163
1251
 
1164
 
                r = tgsi_dst(ctx, &inst->Dst[0], 3, &alu.dst);
1165
 
                if (r)
1166
 
                        return r;
 
1252
                tgsi_dst(ctx, &inst->Dst[0], 3, &alu.dst);
1167
1253
 
1168
1254
                alu.src[0].sel = V_SQ_ALU_SRC_1;
1169
1255
                alu.src[0].chan = 0;
1173
1259
                r = r600_bc_add_alu(ctx->bc, &alu);
1174
1260
                if (r)
1175
1261
                        return r;
1176
 
 
1177
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
1178
 
                if (r)
1179
 
                        return r;
1180
1262
        }
1181
1263
 
1182
1264
        return 0;
1184
1266
 
1185
1267
static int tgsi_kill(struct r600_shader_ctx *ctx)
1186
1268
{
1187
 
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
1188
1269
        struct r600_bc_alu alu;
1189
1270
        int i, r;
1190
1271
 
1200
1281
                        alu.src[1].sel = V_SQ_ALU_SRC_1;
1201
1282
                        alu.src[1].neg = 1;
1202
1283
                } else {
1203
 
                        r = tgsi_src(ctx, &inst->Src[0], &alu.src[1]);
1204
 
                        if (r)
1205
 
                                return r;
1206
 
                        alu.src[1].chan = tgsi_chan(&inst->Src[0], i);
 
1284
                        r600_bc_src(&alu.src[1], &ctx->src[0], i);
1207
1285
                }
1208
1286
                if (i == 3) {
1209
1287
                        alu.last = 1;
1212
1290
                if (r)
1213
1291
                        return r;
1214
1292
        }
1215
 
        r = r600_bc_add_literal(ctx->bc, ctx->value);
1216
 
        if (r)
1217
 
                return r;
1218
1293
 
1219
1294
        /* kill must be last in ALU */
1220
1295
        ctx->bc->force_add_cf = 1;
1226
1301
{
1227
1302
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
1228
1303
        struct r600_bc_alu alu;
1229
 
        struct r600_bc_alu_src r600_src[3];
1230
1304
        int r;
1231
1305
 
1232
 
        r = tgsi_split_constant(ctx, r600_src);
1233
 
        if (r)
1234
 
                return r;
1235
 
        r = tgsi_split_literal_constant(ctx, r600_src);
1236
 
        if (r)
1237
 
                return r;
1238
 
 
1239
1306
        /* dst.x, <- 1.0  */
1240
1307
        memset(&alu, 0, sizeof(struct r600_bc_alu));
1241
1308
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
1242
1309
        alu.src[0].sel  = V_SQ_ALU_SRC_1; /*1.0*/
1243
1310
        alu.src[0].chan = 0;
1244
 
        r = tgsi_dst(ctx, &inst->Dst[0], 0, &alu.dst);
1245
 
        if (r)
1246
 
                return r;
 
1311
        tgsi_dst(ctx, &inst->Dst[0], 0, &alu.dst);
1247
1312
        alu.dst.write = (inst->Dst[0].Register.WriteMask >> 0) & 1;
1248
1313
        r = r600_bc_add_alu(ctx->bc, &alu);
1249
1314
        if (r)
1252
1317
        /* dst.y = max(src.x, 0.0) */
1253
1318
        memset(&alu, 0, sizeof(struct r600_bc_alu));
1254
1319
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MAX);
1255
 
        alu.src[0] = r600_src[0];
 
1320
        r600_bc_src(&alu.src[0], &ctx->src[0], 0);
1256
1321
        alu.src[1].sel  = V_SQ_ALU_SRC_0; /*0.0*/
1257
1322
        alu.src[1].chan = 0;
1258
 
        r = tgsi_dst(ctx, &inst->Dst[0], 1, &alu.dst);
1259
 
        if (r)
1260
 
                return r;
 
1323
        tgsi_dst(ctx, &inst->Dst[0], 1, &alu.dst);
1261
1324
        alu.dst.write = (inst->Dst[0].Register.WriteMask >> 1) & 1;
1262
1325
        r = r600_bc_add_alu(ctx->bc, &alu);
1263
1326
        if (r)
1268
1331
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
1269
1332
        alu.src[0].sel  = V_SQ_ALU_SRC_1;
1270
1333
        alu.src[0].chan = 0;
1271
 
        r = tgsi_dst(ctx, &inst->Dst[0], 3, &alu.dst);
1272
 
        if (r)
1273
 
                return r;
 
1334
        tgsi_dst(ctx, &inst->Dst[0], 3, &alu.dst);
1274
1335
        alu.dst.write = (inst->Dst[0].Register.WriteMask >> 3) & 1;
1275
1336
        alu.last = 1;
1276
1337
        r = r600_bc_add_alu(ctx->bc, &alu);
1277
1338
        if (r)
1278
1339
                return r;
1279
1340
 
1280
 
        r = r600_bc_add_literal(ctx->bc, ctx->value);
1281
 
        if (r)
1282
 
                return r;
1283
 
 
1284
1341
        if (inst->Dst[0].Register.WriteMask & (1 << 2))
1285
1342
        {
1286
1343
                int chan;
1287
1344
                int sel;
1288
 
 
1289
 
                /* dst.z = log(src.y) */
1290
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1291
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_CLAMPED);
1292
 
                alu.src[0] = r600_src[0];
1293
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], 1);
1294
 
                r = tgsi_dst(ctx, &inst->Dst[0], 2, &alu.dst);
1295
 
                if (r)
1296
 
                        return r;
1297
 
                alu.last = 1;
1298
 
                r = r600_bc_add_alu(ctx->bc, &alu);
1299
 
                if (r)
1300
 
                        return r;
1301
 
 
1302
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
1303
 
                if (r)
1304
 
                        return r;
 
1345
                int i;
 
1346
 
 
1347
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
1348
                        for (i = 0; i < 3; i++) {
 
1349
                                /* dst.z = log(src.y) */
 
1350
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1351
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_CLAMPED);
 
1352
                                r600_bc_src(&alu.src[0], &ctx->src[0], 1);
 
1353
                                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
 
1354
                                if (i == 2) {
 
1355
                                        alu.dst.write = 1;
 
1356
                                        alu.last = 1;
 
1357
                                } else
 
1358
                                        alu.dst.write = 0;
 
1359
                                
 
1360
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
1361
                                if (r)
 
1362
                                        return r;
 
1363
                        }
 
1364
                } else {
 
1365
                        /* dst.z = log(src.y) */
 
1366
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1367
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_CLAMPED);
 
1368
                        r600_bc_src(&alu.src[0], &ctx->src[0], 1);
 
1369
                        alu.dst.sel = ctx->temp_reg;
 
1370
                        alu.dst.chan = 2;
 
1371
                        alu.dst.write = 1;
 
1372
                        alu.last = 1;
 
1373
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
1374
                        if (r)
 
1375
                                return r;
 
1376
                }
1305
1377
 
1306
1378
                chan = alu.dst.chan;
1307
1379
                sel = alu.dst.sel;
1309
1381
                /* tmp.x = amd MUL_LIT(src.w, dst.z, src.x ) */
1310
1382
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1311
1383
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP3_SQ_OP3_INST_MUL_LIT);
1312
 
                alu.src[0] = r600_src[0];
1313
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], 3);
 
1384
                r600_bc_src(&alu.src[0], &ctx->src[0], 3);
1314
1385
                alu.src[1].sel  = sel;
1315
1386
                alu.src[1].chan = chan;
1316
1387
 
1317
 
                alu.src[2] = r600_src[0];
1318
 
                alu.src[2].chan = tgsi_chan(&inst->Src[0], 0);
 
1388
                r600_bc_src(&alu.src[2], &ctx->src[0], 0);
1319
1389
                alu.dst.sel = ctx->temp_reg;
1320
1390
                alu.dst.chan = 0;
1321
1391
                alu.dst.write = 1;
1325
1395
                if (r)
1326
1396
                        return r;
1327
1397
 
1328
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
1329
 
                if (r)
1330
 
                        return r;
1331
 
                /* dst.z = exp(tmp.x) */
1332
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1333
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
1334
 
                alu.src[0].sel = ctx->temp_reg;
1335
 
                alu.src[0].chan = 0;
1336
 
                r = tgsi_dst(ctx, &inst->Dst[0], 2, &alu.dst);
1337
 
                if (r)
1338
 
                        return r;
1339
 
                alu.last = 1;
1340
 
                r = r600_bc_add_alu(ctx->bc, &alu);
1341
 
                if (r)
1342
 
                        return r;
 
1398
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
1399
                        for (i = 0; i < 3; i++) {
 
1400
                                /* dst.z = exp(tmp.x) */
 
1401
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1402
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
 
1403
                                alu.src[0].sel = ctx->temp_reg;
 
1404
                                alu.src[0].chan = 0;
 
1405
                                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
 
1406
                                if (i == 2) {
 
1407
                                        alu.dst.write = 1;
 
1408
                                        alu.last = 1;
 
1409
                                } else
 
1410
                                        alu.dst.write = 0;
 
1411
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
1412
                                if (r)
 
1413
                                        return r;
 
1414
                        }
 
1415
                } else {
 
1416
                        /* dst.z = exp(tmp.x) */
 
1417
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1418
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
 
1419
                        alu.src[0].sel = ctx->temp_reg;
 
1420
                        alu.src[0].chan = 0;
 
1421
                        tgsi_dst(ctx, &inst->Dst[0], 2, &alu.dst);
 
1422
                        alu.last = 1;
 
1423
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
1424
                        if (r)
 
1425
                                return r;
 
1426
                }
1343
1427
        }
1344
1428
        return 0;
1345
1429
}
1359
1443
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIPSQRT_CLAMPED);
1360
1444
 
1361
1445
        for (i = 0; i < inst->Instruction.NumSrcRegs; i++) {
1362
 
                r = tgsi_src(ctx, &inst->Src[i], &alu.src[i]);
1363
 
                if (r)
1364
 
                        return r;
1365
 
                alu.src[i].chan = tgsi_chan(&inst->Src[i], 0);
 
1446
                r600_bc_src(&alu.src[i], &ctx->src[i], 0);
1366
1447
                alu.src[i].abs = 1;
1367
1448
        }
1368
1449
        alu.dst.sel = ctx->temp_reg;
1371
1452
        r = r600_bc_add_alu(ctx->bc, &alu);
1372
1453
        if (r)
1373
1454
                return r;
1374
 
        r = r600_bc_add_literal(ctx->bc, ctx->value);
1375
 
        if (r)
1376
 
                return r;
1377
1455
        /* replicate result */
1378
1456
        return tgsi_helper_tempx_replicate(ctx);
1379
1457
}
1389
1467
                alu.src[0].sel = ctx->temp_reg;
1390
1468
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
1391
1469
                alu.dst.chan = i;
1392
 
                r = tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
1393
 
                if (r)
1394
 
                        return r;
 
1470
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
1395
1471
                alu.dst.write = (inst->Dst[0].Register.WriteMask >> i) & 1;
1396
1472
                if (i == 3)
1397
1473
                        alu.last = 1;
1411
1487
        memset(&alu, 0, sizeof(struct r600_bc_alu));
1412
1488
        alu.inst = ctx->inst_info->r600_opcode;
1413
1489
        for (i = 0; i < inst->Instruction.NumSrcRegs; i++) {
1414
 
                r = tgsi_src(ctx, &inst->Src[i], &alu.src[i]);
1415
 
                if (r)
1416
 
                        return r;
1417
 
                alu.src[i].chan = tgsi_chan(&inst->Src[i], 0);
 
1490
                r600_bc_src(&alu.src[i], &ctx->src[i], 0);
1418
1491
        }
1419
1492
        alu.dst.sel = ctx->temp_reg;
1420
1493
        alu.dst.write = 1;
1422
1495
        r = r600_bc_add_alu(ctx->bc, &alu);
1423
1496
        if (r)
1424
1497
                return r;
1425
 
        r = r600_bc_add_literal(ctx->bc, ctx->value);
1426
 
        if (r)
1427
 
                return r;
1428
1498
        /* replicate result */
1429
1499
        return tgsi_helper_tempx_replicate(ctx);
1430
1500
}
1431
1501
 
 
1502
static int cayman_pow(struct r600_shader_ctx *ctx)
 
1503
{
 
1504
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
 
1505
        int i, r;
 
1506
        struct r600_bc_alu alu;
 
1507
        int last_slot = (inst->Dst[0].Register.WriteMask & 0x8) ? 4 : 3;
 
1508
 
 
1509
        for (i = 0; i < 3; i++) {
 
1510
                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1511
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE);
 
1512
                r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
1513
                alu.dst.sel = ctx->temp_reg;
 
1514
                alu.dst.chan = i;
 
1515
                alu.dst.write = 1;
 
1516
                if (i == 2)
 
1517
                        alu.last = 1;
 
1518
                r = r600_bc_add_alu(ctx->bc, &alu);
 
1519
                if (r)
 
1520
                        return r;
 
1521
        }
 
1522
 
 
1523
        /* b * LOG2(a) */
 
1524
        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1525
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MUL);
 
1526
        r600_bc_src(&alu.src[0], &ctx->src[1], 0);
 
1527
        alu.src[1].sel = ctx->temp_reg;
 
1528
        alu.dst.sel = ctx->temp_reg;
 
1529
        alu.dst.write = 1;
 
1530
        alu.last = 1;
 
1531
        r = r600_bc_add_alu(ctx->bc, &alu);
 
1532
        if (r)
 
1533
                return r;
 
1534
 
 
1535
        for (i = 0; i < last_slot; i++) {
 
1536
                /* POW(a,b) = EXP2(b * LOG2(a))*/
 
1537
                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1538
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
 
1539
                alu.src[0].sel = ctx->temp_reg;
 
1540
 
 
1541
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
 
1542
                alu.dst.write = (inst->Dst[0].Register.WriteMask >> i) & 1;
 
1543
                if (i == last_slot - 1)
 
1544
                        alu.last = 1;
 
1545
                r = r600_bc_add_alu(ctx->bc, &alu);
 
1546
                if (r)
 
1547
                        return r;
 
1548
        }
 
1549
        return 0;
 
1550
}
 
1551
 
1432
1552
static int tgsi_pow(struct r600_shader_ctx *ctx)
1433
1553
{
1434
 
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
1435
1554
        struct r600_bc_alu alu;
1436
1555
        int r;
1437
1556
 
1438
1557
        /* LOG2(a) */
1439
1558
        memset(&alu, 0, sizeof(struct r600_bc_alu));
1440
1559
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE);
1441
 
        r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
1442
 
        if (r)
1443
 
                return r;
1444
 
        alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
 
1560
        r600_bc_src(&alu.src[0], &ctx->src[0], 0);
1445
1561
        alu.dst.sel = ctx->temp_reg;
1446
1562
        alu.dst.write = 1;
1447
1563
        alu.last = 1;
1448
1564
        r = r600_bc_add_alu(ctx->bc, &alu);
1449
1565
        if (r)
1450
1566
                return r;
1451
 
        r = r600_bc_add_literal(ctx->bc,ctx->value);
1452
 
        if (r)
1453
 
                return r;
1454
1567
        /* b * LOG2(a) */
1455
1568
        memset(&alu, 0, sizeof(struct r600_bc_alu));
1456
1569
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MUL);
1457
 
        r = tgsi_src(ctx, &inst->Src[1], &alu.src[0]);
1458
 
        if (r)
1459
 
                return r;
1460
 
        alu.src[0].chan = tgsi_chan(&inst->Src[1], 0);
 
1570
        r600_bc_src(&alu.src[0], &ctx->src[1], 0);
1461
1571
        alu.src[1].sel = ctx->temp_reg;
1462
1572
        alu.dst.sel = ctx->temp_reg;
1463
1573
        alu.dst.write = 1;
1465
1575
        r = r600_bc_add_alu(ctx->bc, &alu);
1466
1576
        if (r)
1467
1577
                return r;
1468
 
        r = r600_bc_add_literal(ctx->bc,ctx->value);
1469
 
        if (r)
1470
 
                return r;
1471
1578
        /* POW(a,b) = EXP2(b * LOG2(a))*/
1472
1579
        memset(&alu, 0, sizeof(struct r600_bc_alu));
1473
1580
        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
1478
1585
        r = r600_bc_add_alu(ctx->bc, &alu);
1479
1586
        if (r)
1480
1587
                return r;
1481
 
        r = r600_bc_add_literal(ctx->bc,ctx->value);
1482
 
        if (r)
1483
 
                return r;
1484
1588
        return tgsi_helper_tempx_replicate(ctx);
1485
1589
}
1486
1590
 
1488
1592
{
1489
1593
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
1490
1594
        struct r600_bc_alu alu;
1491
 
        struct r600_bc_alu_src r600_src[3];
1492
1595
        int i, r;
1493
1596
 
1494
 
        r = tgsi_split_constant(ctx, r600_src);
1495
 
        if (r)
1496
 
                return r;
1497
 
        r = tgsi_split_literal_constant(ctx, r600_src);
1498
 
        if (r)
1499
 
                return r;
1500
 
 
1501
1597
        /* tmp = (src > 0 ? 1 : src) */
1502
1598
        for (i = 0; i < 4; i++) {
1503
1599
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1507
1603
                alu.dst.sel = ctx->temp_reg;
1508
1604
                alu.dst.chan = i;
1509
1605
 
1510
 
                alu.src[0] = r600_src[0];
1511
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], i);
1512
 
 
 
1606
                r600_bc_src(&alu.src[0], &ctx->src[0], i);
1513
1607
                alu.src[1].sel = V_SQ_ALU_SRC_1;
 
1608
                r600_bc_src(&alu.src[2], &ctx->src[0], i);
1514
1609
 
1515
 
                alu.src[2] = r600_src[0];
1516
 
                alu.src[2].chan = tgsi_chan(&inst->Src[0], i);
1517
1610
                if (i == 3)
1518
1611
                        alu.last = 1;
1519
1612
                r = r600_bc_add_alu(ctx->bc, &alu);
1520
1613
                if (r)
1521
1614
                        return r;
1522
1615
        }
1523
 
        r = r600_bc_add_literal(ctx->bc, ctx->value);
1524
 
        if (r)
1525
 
                return r;
1526
1616
 
1527
1617
        /* dst = (-tmp > 0 ? -1 : tmp) */
1528
1618
        for (i = 0; i < 4; i++) {
1529
1619
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1530
1620
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP3_SQ_OP3_INST_CNDGT);
1531
1621
                alu.is_op3 = 1;
1532
 
                r = tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
1533
 
                if (r)
1534
 
                        return r;
 
1622
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
1535
1623
 
1536
1624
                alu.src[0].sel = ctx->temp_reg;
1537
1625
                alu.src[0].chan = i;
1557
1645
        struct r600_bc_alu alu;
1558
1646
        int i, r;
1559
1647
 
1560
 
        r = r600_bc_add_literal(ctx->bc, ctx->value);
1561
 
        if (r)
1562
 
                return r;
1563
1648
        for (i = 0; i < 4; i++) {
1564
1649
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1565
1650
                if (!(inst->Dst[0].Register.WriteMask & (1 << i))) {
1567
1652
                        alu.dst.chan = i;
1568
1653
                } else {
1569
1654
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
1570
 
                        r = tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
1571
 
                        if (r)
1572
 
                                return r;
 
1655
                        tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
1573
1656
                        alu.src[0].sel = ctx->temp_reg;
1574
1657
                        alu.src[0].chan = i;
1575
1658
                }
1586
1669
static int tgsi_op3(struct r600_shader_ctx *ctx)
1587
1670
{
1588
1671
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
1589
 
        struct r600_bc_alu_src r600_src[3];
1590
1672
        struct r600_bc_alu alu;
1591
1673
        int i, j, r;
1592
 
 
1593
 
        r = tgsi_split_constant(ctx, r600_src);
1594
 
        if (r)
1595
 
                return r;
1596
 
        r = tgsi_split_literal_constant(ctx, r600_src);
1597
 
        if (r)
1598
 
                return r;
1599
 
        /* do it in 2 step as op3 doesn't support writemask */
1600
 
        for (i = 0; i < 4; i++) {
 
1674
        int lasti = tgsi_last_instruction(inst->Dst[0].Register.WriteMask);
 
1675
 
 
1676
        for (i = 0; i < lasti + 1; i++) {
 
1677
                if (!(inst->Dst[0].Register.WriteMask & (1 << i)))
 
1678
                        continue;
 
1679
 
1601
1680
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1602
1681
                alu.inst = ctx->inst_info->r600_opcode;
1603
1682
                for (j = 0; j < inst->Instruction.NumSrcRegs; j++) {
1604
 
                        alu.src[j] = r600_src[j];
1605
 
                        alu.src[j].chan = tgsi_chan(&inst->Src[j], i);
 
1683
                        r600_bc_src(&alu.src[j], &ctx->src[j], i);
1606
1684
                }
1607
 
                alu.dst.sel = ctx->temp_reg;
 
1685
 
 
1686
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
1608
1687
                alu.dst.chan = i;
1609
1688
                alu.dst.write = 1;
1610
1689
                alu.is_op3 = 1;
1611
 
                if (i == 3) {
 
1690
                if (i == lasti) {
1612
1691
                        alu.last = 1;
1613
1692
                }
1614
1693
                r = r600_bc_add_alu(ctx->bc, &alu);
1615
1694
                if (r)
1616
1695
                        return r;
1617
1696
        }
1618
 
        return tgsi_helper_copy(ctx, inst);
 
1697
        return 0;
1619
1698
}
1620
1699
 
1621
1700
static int tgsi_dp(struct r600_shader_ctx *ctx)
1622
1701
{
1623
1702
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
1624
 
        struct r600_bc_alu_src r600_src[3];
1625
1703
        struct r600_bc_alu alu;
1626
1704
        int i, j, r;
1627
1705
 
1628
 
        r = tgsi_split_constant(ctx, r600_src);
1629
 
        if (r)
1630
 
                return r;
1631
 
        r = tgsi_split_literal_constant(ctx, r600_src);
1632
 
        if (r)
1633
 
                return r;
1634
1706
        for (i = 0; i < 4; i++) {
1635
1707
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1636
1708
                alu.inst = ctx->inst_info->r600_opcode;
1637
1709
                for (j = 0; j < inst->Instruction.NumSrcRegs; j++) {
1638
 
                        alu.src[j] = r600_src[j];
1639
 
                        alu.src[j].chan = tgsi_chan(&inst->Src[j], i);
 
1710
                        r600_bc_src(&alu.src[j], &ctx->src[j], i);
1640
1711
                }
1641
 
                alu.dst.sel = ctx->temp_reg;
 
1712
 
 
1713
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
1642
1714
                alu.dst.chan = i;
1643
 
                alu.dst.write = 1;
 
1715
                alu.dst.write = (inst->Dst[0].Register.WriteMask >> i) & 1;
1644
1716
                /* handle some special cases */
1645
1717
                switch (ctx->inst_info->tgsi_opcode) {
1646
1718
                case TGSI_OPCODE_DP2:
1672
1744
                if (r)
1673
1745
                        return r;
1674
1746
        }
1675
 
        return tgsi_helper_copy(ctx, inst);
 
1747
        return 0;
 
1748
}
 
1749
 
 
1750
static inline boolean tgsi_tex_src_requires_loading(struct r600_shader_ctx *ctx,
 
1751
                                                    unsigned index)
 
1752
{
 
1753
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
 
1754
        return  (inst->Src[index].Register.File != TGSI_FILE_TEMPORARY &&
 
1755
                inst->Src[index].Register.File != TGSI_FILE_INPUT) ||
 
1756
                ctx->src[index].neg || ctx->src[index].abs;
 
1757
}
 
1758
 
 
1759
static inline unsigned tgsi_tex_get_src_gpr(struct r600_shader_ctx *ctx,
 
1760
                                        unsigned index)
 
1761
{
 
1762
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
 
1763
        return ctx->file_offset[inst->Src[index].Register.File] + inst->Src[index].Register.Index;
1676
1764
}
1677
1765
 
1678
1766
static int tgsi_tex(struct r600_shader_ctx *ctx)
1679
1767
{
 
1768
        static float one_point_five = 1.5f;
1680
1769
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
1681
1770
        struct r600_bc_tex tex;
1682
1771
        struct r600_bc_alu alu;
1683
1772
        unsigned src_gpr;
1684
 
        int r, i;
 
1773
        int r, i, j;
1685
1774
        int opcode;
1686
 
        boolean src_not_temp = inst->Src[0].Register.File != TGSI_FILE_TEMPORARY;
1687
 
        uint32_t lit_vals[4];
1688
 
 
1689
 
        src_gpr = ctx->file_offset[inst->Src[0].Register.File] + inst->Src[0].Register.Index;
1690
 
 
1691
 
        if (inst->Instruction.Opcode == TGSI_OPCODE_TXP) {
 
1775
        /* Texture fetch instructions can only use gprs as source.
 
1776
         * Also they cannot negate the source or take the absolute value */
 
1777
        const boolean src_requires_loading = tgsi_tex_src_requires_loading(ctx, 0);
 
1778
        boolean src_loaded = FALSE;
 
1779
        unsigned sampler_src_reg = 1;
 
1780
 
 
1781
        src_gpr = tgsi_tex_get_src_gpr(ctx, 0);
 
1782
 
 
1783
        if (inst->Instruction.Opcode == TGSI_OPCODE_TXD) {
 
1784
                /* TGSI moves the sampler to src reg 3 for TXD */
 
1785
                sampler_src_reg = 3;
 
1786
 
 
1787
                for (i = 1; i < 3; i++) {
 
1788
                        /* set gradients h/v */
 
1789
                        memset(&tex, 0, sizeof(struct r600_bc_tex));
 
1790
                        tex.inst = (i == 1) ? SQ_TEX_INST_SET_GRADIENTS_H :
 
1791
                                SQ_TEX_INST_SET_GRADIENTS_V;
 
1792
                        tex.sampler_id = tgsi_tex_get_src_gpr(ctx, sampler_src_reg);
 
1793
                        tex.resource_id = tex.sampler_id + R600_MAX_CONST_BUFFERS;
 
1794
 
 
1795
                        if (tgsi_tex_src_requires_loading(ctx, i)) {
 
1796
                                tex.src_gpr = r600_get_temp(ctx);
 
1797
                                tex.src_sel_x = 0;
 
1798
                                tex.src_sel_y = 1;
 
1799
                                tex.src_sel_z = 2;
 
1800
                                tex.src_sel_w = 3;
 
1801
 
 
1802
                                for (j = 0; j < 4; j++) {
 
1803
                                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1804
                                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
 
1805
                                        r600_bc_src(&alu.src[0], &ctx->src[i], j);
 
1806
                                        alu.dst.sel = tex.src_gpr;
 
1807
                                        alu.dst.chan = j;
 
1808
                                        if (j == 3)
 
1809
                                                alu.last = 1;
 
1810
                                        alu.dst.write = 1;
 
1811
                                        r = r600_bc_add_alu(ctx->bc, &alu);
 
1812
                                        if (r)
 
1813
                                                return r;
 
1814
                                }
 
1815
 
 
1816
                        } else {
 
1817
                                tex.src_gpr = tgsi_tex_get_src_gpr(ctx, i);
 
1818
                                tex.src_sel_x = ctx->src[i].swizzle[0];
 
1819
                                tex.src_sel_y = ctx->src[i].swizzle[1];
 
1820
                                tex.src_sel_z = ctx->src[i].swizzle[2];
 
1821
                                tex.src_sel_w = ctx->src[i].swizzle[3];
 
1822
                                tex.src_rel = ctx->src[i].rel;
 
1823
                        }
 
1824
                        tex.dst_gpr = ctx->temp_reg; /* just to avoid confusing the asm scheduler */
 
1825
                        tex.dst_sel_x = tex.dst_sel_y = tex.dst_sel_z = tex.dst_sel_w = 7;
 
1826
                        if (inst->Texture.Texture != TGSI_TEXTURE_RECT) {
 
1827
                                tex.coord_type_x = 1;
 
1828
                                tex.coord_type_y = 1;
 
1829
                                tex.coord_type_z = 1;
 
1830
                                tex.coord_type_w = 1;
 
1831
                        }
 
1832
                        r = r600_bc_add_tex(ctx->bc, &tex);
 
1833
                        if (r)
 
1834
                                return r;
 
1835
                }
 
1836
        } else if (inst->Instruction.Opcode == TGSI_OPCODE_TXP) {
 
1837
                int out_chan;
1692
1838
                /* Add perspective divide */
1693
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1694
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIP_IEEE);
1695
 
                r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
1696
 
                if (r)
1697
 
                        return r;
1698
 
 
1699
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], 3);
1700
 
                alu.dst.sel = ctx->temp_reg;
1701
 
                alu.dst.chan = 3;
1702
 
                alu.last = 1;
1703
 
                alu.dst.write = 1;
1704
 
                r = r600_bc_add_alu(ctx->bc, &alu);
1705
 
                if (r)
1706
 
                        return r;
 
1839
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
1840
                        out_chan = 2;
 
1841
                        for (i = 0; i < 3; i++) {
 
1842
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1843
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIP_IEEE);
 
1844
                                r600_bc_src(&alu.src[0], &ctx->src[0], 3);
 
1845
 
 
1846
                                alu.dst.sel = ctx->temp_reg;
 
1847
                                alu.dst.chan = i;
 
1848
                                if (i == 2)
 
1849
                                        alu.last = 1;
 
1850
                                if (out_chan == i)
 
1851
                                        alu.dst.write = 1;
 
1852
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
1853
                                if (r)
 
1854
                                        return r;
 
1855
                        }
 
1856
 
 
1857
                } else {
 
1858
                        out_chan = 3;
 
1859
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1860
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIP_IEEE);
 
1861
                        r600_bc_src(&alu.src[0], &ctx->src[0], 3);
 
1862
 
 
1863
                        alu.dst.sel = ctx->temp_reg;
 
1864
                        alu.dst.chan = out_chan;
 
1865
                        alu.last = 1;
 
1866
                        alu.dst.write = 1;
 
1867
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
1868
                        if (r)
 
1869
                                return r;
 
1870
                }
1707
1871
 
1708
1872
                for (i = 0; i < 3; i++) {
1709
1873
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
1710
1874
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MUL);
1711
1875
                        alu.src[0].sel = ctx->temp_reg;
1712
 
                        alu.src[0].chan = 3;
1713
 
                        r = tgsi_src(ctx, &inst->Src[0], &alu.src[1]);
1714
 
                        if (r)
1715
 
                                return r;
1716
 
                        alu.src[1].chan = tgsi_chan(&inst->Src[0], i);
 
1876
                        alu.src[0].chan = out_chan;
 
1877
                        r600_bc_src(&alu.src[1], &ctx->src[0], i);
1717
1878
                        alu.dst.sel = ctx->temp_reg;
1718
1879
                        alu.dst.chan = i;
1719
1880
                        alu.dst.write = 1;
1732
1893
                r = r600_bc_add_alu(ctx->bc, &alu);
1733
1894
                if (r)
1734
1895
                        return r;
1735
 
                src_not_temp = FALSE;
 
1896
                src_loaded = TRUE;
1736
1897
                src_gpr = ctx->temp_reg;
1737
1898
        }
1738
1899
 
1739
1900
        if (inst->Texture.Texture == TGSI_TEXTURE_CUBE) {
1740
 
                int src_chan, src2_chan;
 
1901
                static const unsigned src0_swizzle[] = {2, 2, 0, 1};
 
1902
                static const unsigned src1_swizzle[] = {1, 0, 2, 2};
1741
1903
 
1742
1904
                /* tmp1.xyzw = CUBE(R0.zzxy, R0.yxzz) */
1743
1905
                for (i = 0; i < 4; i++) {
1744
1906
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
1745
1907
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_CUBE);
1746
 
                        switch (i) {
1747
 
                        case 0:
1748
 
                                src_chan = 2;
1749
 
                                src2_chan = 1;
1750
 
                                break;
1751
 
                        case 1:
1752
 
                                src_chan = 2;
1753
 
                                src2_chan = 0;
1754
 
                                break;
1755
 
                        case 2:
1756
 
                                src_chan = 0;
1757
 
                                src2_chan = 2;
1758
 
                                break;
1759
 
                        case 3:
1760
 
                                src_chan = 1;
1761
 
                                src2_chan = 2;
1762
 
                                break;
1763
 
                        default:
1764
 
                                assert(0);
1765
 
                                src_chan = 0;
1766
 
                                src2_chan = 0;
1767
 
                                break;
1768
 
                        }
1769
 
                        r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
1770
 
                        if (r)
1771
 
                                return r;
1772
 
                        alu.src[0].chan = tgsi_chan(&inst->Src[0], src_chan);
1773
 
                        r = tgsi_src(ctx, &inst->Src[0], &alu.src[1]);
1774
 
                        if (r)
1775
 
                                return r;
1776
 
                        alu.src[1].chan = tgsi_chan(&inst->Src[0], src2_chan);
 
1908
                        r600_bc_src(&alu.src[0], &ctx->src[0], src0_swizzle[i]);
 
1909
                        r600_bc_src(&alu.src[1], &ctx->src[0], src1_swizzle[i]);
1777
1910
                        alu.dst.sel = ctx->temp_reg;
1778
1911
                        alu.dst.chan = i;
1779
1912
                        if (i == 3)
1785
1918
                }
1786
1919
 
1787
1920
                /* tmp1.z = RCP_e(|tmp1.z|) */
1788
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1789
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIP_IEEE);
1790
 
                alu.src[0].sel = ctx->temp_reg;
1791
 
                alu.src[0].chan = 2;
1792
 
                alu.src[0].abs = 1;
1793
 
                alu.dst.sel = ctx->temp_reg;
1794
 
                alu.dst.chan = 2;
1795
 
                alu.dst.write = 1;
1796
 
                alu.last = 1;
1797
 
                r = r600_bc_add_alu(ctx->bc, &alu);
1798
 
                if (r)
1799
 
                        return r;
 
1921
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
1922
                        for (i = 0; i < 3; i++) {
 
1923
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1924
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIP_IEEE);
 
1925
                                alu.src[0].sel = ctx->temp_reg;
 
1926
                                alu.src[0].chan = 2;
 
1927
                                alu.src[0].abs = 1;
 
1928
                                alu.dst.sel = ctx->temp_reg;
 
1929
                                alu.dst.chan = i;
 
1930
                                if (i == 2)
 
1931
                                        alu.dst.write = 1;
 
1932
                                if (i == 2)
 
1933
                                        alu.last = 1;
 
1934
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
1935
                                if (r)
 
1936
                                        return r;
 
1937
                        }
 
1938
                } else {
 
1939
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
1940
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIP_IEEE);
 
1941
                        alu.src[0].sel = ctx->temp_reg;
 
1942
                        alu.src[0].chan = 2;
 
1943
                        alu.src[0].abs = 1;
 
1944
                        alu.dst.sel = ctx->temp_reg;
 
1945
                        alu.dst.chan = 2;
 
1946
                        alu.dst.write = 1;
 
1947
                        alu.last = 1;
 
1948
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
1949
                        if (r)
 
1950
                                return r;
 
1951
                }
1800
1952
 
1801
1953
                /* MULADD R0.x,  R0.x,  PS1,  (0x3FC00000, 1.5f).x
1802
1954
                 * MULADD R0.y,  R0.y,  PS1,  (0x3FC00000, 1.5f).x
1813
1965
 
1814
1966
                alu.src[2].sel = V_SQ_ALU_SRC_LITERAL;
1815
1967
                alu.src[2].chan = 0;
 
1968
                alu.src[2].value = *(uint32_t *)&one_point_five;
1816
1969
 
1817
1970
                alu.dst.sel = ctx->temp_reg;
1818
1971
                alu.dst.chan = 0;
1833
1986
 
1834
1987
                alu.src[2].sel = V_SQ_ALU_SRC_LITERAL;
1835
1988
                alu.src[2].chan = 0;
 
1989
                alu.src[2].value = *(uint32_t *)&one_point_five;
1836
1990
 
1837
1991
                alu.dst.sel = ctx->temp_reg;
1838
1992
                alu.dst.chan = 1;
1843
1997
                if (r)
1844
1998
                        return r;
1845
1999
 
1846
 
                lit_vals[0] = fui(1.5f);
1847
 
 
1848
 
                r = r600_bc_add_literal(ctx->bc, lit_vals);
1849
 
                if (r)
1850
 
                        return r;
1851
 
                src_not_temp = FALSE;
 
2000
                src_loaded = TRUE;
1852
2001
                src_gpr = ctx->temp_reg;
1853
2002
        }
1854
2003
 
1855
 
        if (src_not_temp) {
 
2004
        if (src_requires_loading && !src_loaded) {
1856
2005
                for (i = 0; i < 4; i++) {
1857
2006
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
1858
2007
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV);
1859
 
                        alu.src[0].sel = src_gpr;
1860
 
                        alu.src[0].chan = tgsi_chan(&inst->Src[0], i);
 
2008
                        r600_bc_src(&alu.src[0], &ctx->src[0], i);
1861
2009
                        alu.dst.sel = ctx->temp_reg;
1862
2010
                        alu.dst.chan = i;
1863
2011
                        if (i == 3)
1867
2015
                        if (r)
1868
2016
                                return r;
1869
2017
                }
 
2018
                src_loaded = TRUE;
1870
2019
                src_gpr = ctx->temp_reg;
1871
2020
        }
1872
2021
 
1873
2022
        opcode = ctx->inst_info->r600_opcode;
1874
 
        if (opcode == SQ_TEX_INST_SAMPLE &&
1875
 
            (inst->Texture.Texture == TGSI_TEXTURE_SHADOW1D || inst->Texture.Texture == TGSI_TEXTURE_SHADOW2D))
1876
 
                opcode = SQ_TEX_INST_SAMPLE_C;
 
2023
        if (inst->Texture.Texture == TGSI_TEXTURE_SHADOW1D || inst->Texture.Texture == TGSI_TEXTURE_SHADOW2D) {
 
2024
                switch (opcode) {
 
2025
                case SQ_TEX_INST_SAMPLE:
 
2026
                        opcode = SQ_TEX_INST_SAMPLE_C;
 
2027
                        break;
 
2028
                case SQ_TEX_INST_SAMPLE_L:
 
2029
                        opcode = SQ_TEX_INST_SAMPLE_C_L;
 
2030
                        break;
 
2031
                case SQ_TEX_INST_SAMPLE_G:
 
2032
                        opcode = SQ_TEX_INST_SAMPLE_C_G;
 
2033
                        break;
 
2034
                }
 
2035
        }
1877
2036
 
1878
2037
        memset(&tex, 0, sizeof(struct r600_bc_tex));
1879
2038
        tex.inst = opcode;
1880
 
        tex.sampler_id = ctx->file_offset[inst->Src[1].Register.File] + inst->Src[1].Register.Index;
1881
 
        tex.resource_id = tex.sampler_id;
 
2039
 
 
2040
        tex.sampler_id = tgsi_tex_get_src_gpr(ctx, sampler_src_reg);
 
2041
        tex.resource_id = tex.sampler_id + R600_MAX_CONST_BUFFERS;
1882
2042
        tex.src_gpr = src_gpr;
1883
2043
        tex.dst_gpr = ctx->file_offset[inst->Dst[0].Register.File] + inst->Dst[0].Register.Index;
1884
2044
        tex.dst_sel_x = (inst->Dst[0].Register.WriteMask & 1) ? 0 : 7;
1885
2045
        tex.dst_sel_y = (inst->Dst[0].Register.WriteMask & 2) ? 1 : 7;
1886
2046
        tex.dst_sel_z = (inst->Dst[0].Register.WriteMask & 4) ? 2 : 7;
1887
2047
        tex.dst_sel_w = (inst->Dst[0].Register.WriteMask & 8) ? 3 : 7;
1888
 
        tex.src_sel_x = 0;
1889
 
        tex.src_sel_y = 1;
1890
 
        tex.src_sel_z = 2;
1891
 
        tex.src_sel_w = 3;
 
2048
        if (src_loaded) {
 
2049
                tex.src_sel_x = 0;
 
2050
                tex.src_sel_y = 1;
 
2051
                tex.src_sel_z = 2;
 
2052
                tex.src_sel_w = 3;
 
2053
        } else {
 
2054
                tex.src_sel_x = ctx->src[0].swizzle[0];
 
2055
                tex.src_sel_y = ctx->src[0].swizzle[1];
 
2056
                tex.src_sel_z = ctx->src[0].swizzle[2];
 
2057
                tex.src_sel_w = ctx->src[0].swizzle[3];
 
2058
                tex.src_rel = ctx->src[0].rel;
 
2059
        }
1892
2060
 
1893
2061
        if (inst->Texture.Texture == TGSI_TEXTURE_CUBE) {
1894
2062
                tex.src_sel_x = 1;
1904
2072
                tex.coord_type_w = 1;
1905
2073
        }
1906
2074
 
 
2075
        if (inst->Texture.Texture == TGSI_TEXTURE_1D_ARRAY) {
 
2076
                tex.coord_type_z = 0;
 
2077
                tex.src_sel_z = tex.src_sel_y;
 
2078
        } else if (inst->Texture.Texture == TGSI_TEXTURE_2D_ARRAY)
 
2079
                tex.coord_type_z = 0;
 
2080
 
1907
2081
        if (inst->Texture.Texture == TGSI_TEXTURE_SHADOW1D || inst->Texture.Texture == TGSI_TEXTURE_SHADOW2D)
1908
 
                tex.src_sel_w = 2;
 
2082
                tex.src_sel_w = tex.src_sel_z;
1909
2083
 
1910
2084
        r = r600_bc_add_tex(ctx->bc, &tex);
1911
2085
        if (r)
1918
2092
static int tgsi_lrp(struct r600_shader_ctx *ctx)
1919
2093
{
1920
2094
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
1921
 
        struct r600_bc_alu_src r600_src[3];
1922
2095
        struct r600_bc_alu alu;
 
2096
        int lasti = tgsi_last_instruction(inst->Dst[0].Register.WriteMask);
1923
2097
        unsigned i;
1924
2098
        int r;
1925
2099
 
1926
 
        r = tgsi_split_constant(ctx, r600_src);
1927
 
        if (r)
1928
 
                return r;
1929
 
        r = tgsi_split_literal_constant(ctx, r600_src);
1930
 
        if (r)
1931
 
                return r;
 
2100
        /* optimize if it's just an equal balance */
 
2101
        if (ctx->src[0].sel == V_SQ_ALU_SRC_0_5) {
 
2102
                for (i = 0; i < lasti + 1; i++) {
 
2103
                        if (!(inst->Dst[0].Register.WriteMask & (1 << i)))
 
2104
                                continue;
 
2105
 
 
2106
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2107
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_ADD);
 
2108
                        r600_bc_src(&alu.src[0], &ctx->src[1], i);
 
2109
                        r600_bc_src(&alu.src[1], &ctx->src[2], i);
 
2110
                        alu.omod = 3;
 
2111
                        tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
 
2112
                        alu.dst.chan = i;
 
2113
                        if (i == lasti) {
 
2114
                                alu.last = 1;
 
2115
                        }
 
2116
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
2117
                        if (r)
 
2118
                                return r;
 
2119
                }
 
2120
                return 0;
 
2121
        }
 
2122
 
1932
2123
        /* 1 - src0 */
1933
 
        for (i = 0; i < 4; i++) {
 
2124
        for (i = 0; i < lasti + 1; i++) {
 
2125
                if (!(inst->Dst[0].Register.WriteMask & (1 << i)))
 
2126
                        continue;
 
2127
 
1934
2128
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1935
2129
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_ADD);
1936
2130
                alu.src[0].sel = V_SQ_ALU_SRC_1;
1937
2131
                alu.src[0].chan = 0;
1938
 
                alu.src[1] = r600_src[0];
1939
 
                alu.src[1].chan = tgsi_chan(&inst->Src[0], i);
 
2132
                r600_bc_src(&alu.src[1], &ctx->src[0], i);
1940
2133
                alu.src[1].neg = 1;
1941
2134
                alu.dst.sel = ctx->temp_reg;
1942
2135
                alu.dst.chan = i;
1943
 
                if (i == 3) {
 
2136
                if (i == lasti) {
1944
2137
                        alu.last = 1;
1945
2138
                }
1946
2139
                alu.dst.write = 1;
1948
2141
                if (r)
1949
2142
                        return r;
1950
2143
        }
1951
 
        r = r600_bc_add_literal(ctx->bc, ctx->value);
1952
 
        if (r)
1953
 
                return r;
1954
2144
 
1955
2145
        /* (1 - src0) * src2 */
1956
 
        for (i = 0; i < 4; i++) {
 
2146
        for (i = 0; i < lasti + 1; i++) {
 
2147
                if (!(inst->Dst[0].Register.WriteMask & (1 << i)))
 
2148
                        continue;
 
2149
 
1957
2150
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1958
2151
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MUL);
1959
2152
                alu.src[0].sel = ctx->temp_reg;
1960
2153
                alu.src[0].chan = i;
1961
 
                alu.src[1] = r600_src[2];
1962
 
                alu.src[1].chan = tgsi_chan(&inst->Src[2], i);
 
2154
                r600_bc_src(&alu.src[1], &ctx->src[2], i);
1963
2155
                alu.dst.sel = ctx->temp_reg;
1964
2156
                alu.dst.chan = i;
1965
 
                if (i == 3) {
 
2157
                if (i == lasti) {
1966
2158
                        alu.last = 1;
1967
2159
                }
1968
2160
                alu.dst.write = 1;
1970
2162
                if (r)
1971
2163
                        return r;
1972
2164
        }
1973
 
        r = r600_bc_add_literal(ctx->bc, ctx->value);
1974
 
        if (r)
1975
 
                return r;
1976
2165
 
1977
2166
        /* src0 * src1 + (1 - src0) * src2 */
1978
 
        for (i = 0; i < 4; i++) {
 
2167
        for (i = 0; i < lasti + 1; i++) {
 
2168
                if (!(inst->Dst[0].Register.WriteMask & (1 << i)))
 
2169
                        continue;
 
2170
 
1979
2171
                memset(&alu, 0, sizeof(struct r600_bc_alu));
1980
2172
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP3_SQ_OP3_INST_MULADD);
1981
2173
                alu.is_op3 = 1;
1982
 
                alu.src[0] = r600_src[0];
1983
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], i);
1984
 
                alu.src[1] = r600_src[1];
1985
 
                alu.src[1].chan = tgsi_chan(&inst->Src[1], i);
 
2174
                r600_bc_src(&alu.src[0], &ctx->src[0], i);
 
2175
                r600_bc_src(&alu.src[1], &ctx->src[1], i);
1986
2176
                alu.src[2].sel = ctx->temp_reg;
1987
2177
                alu.src[2].chan = i;
1988
 
                alu.dst.sel = ctx->temp_reg;
 
2178
 
 
2179
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
1989
2180
                alu.dst.chan = i;
1990
 
                if (i == 3) {
 
2181
                if (i == lasti) {
1991
2182
                        alu.last = 1;
1992
2183
                }
1993
2184
                r = r600_bc_add_alu(ctx->bc, &alu);
1994
2185
                if (r)
1995
2186
                        return r;
1996
2187
        }
1997
 
        return tgsi_helper_copy(ctx, inst);
 
2188
        return 0;
1998
2189
}
1999
2190
 
2000
2191
static int tgsi_cmp(struct r600_shader_ctx *ctx)
2001
2192
{
2002
2193
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
2003
 
        struct r600_bc_alu_src r600_src[3];
2004
2194
        struct r600_bc_alu alu;
2005
 
        int use_temp = 0;
2006
2195
        int i, r;
2007
 
 
2008
 
        r = tgsi_split_constant(ctx, r600_src);
2009
 
        if (r)
2010
 
                return r;
2011
 
        r = tgsi_split_literal_constant(ctx, r600_src);
2012
 
        if (r)
2013
 
                return r;
2014
 
 
2015
 
        if (inst->Dst[0].Register.WriteMask != 0xf)
2016
 
                use_temp = 1;
2017
 
 
2018
 
        for (i = 0; i < 4; i++) {
 
2196
        int lasti = tgsi_last_instruction(inst->Dst[0].Register.WriteMask);
 
2197
 
 
2198
        for (i = 0; i < lasti + 1; i++) {
 
2199
                if (!(inst->Dst[0].Register.WriteMask & (1 << i)))
 
2200
                        continue;
 
2201
 
2019
2202
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2020
2203
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP3_SQ_OP3_INST_CNDGE);
2021
 
                alu.src[0] = r600_src[0];
2022
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], i);
2023
 
 
2024
 
                alu.src[1] = r600_src[2];
2025
 
                alu.src[1].chan = tgsi_chan(&inst->Src[2], i);
2026
 
 
2027
 
                alu.src[2] = r600_src[1];
2028
 
                alu.src[2].chan = tgsi_chan(&inst->Src[1], i);
2029
 
 
2030
 
                if (use_temp)
2031
 
                        alu.dst.sel = ctx->temp_reg;
2032
 
                else {
2033
 
                        r = tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
2034
 
                        if (r)
2035
 
                                return r;
2036
 
                }
 
2204
                r600_bc_src(&alu.src[0], &ctx->src[0], i);
 
2205
                r600_bc_src(&alu.src[1], &ctx->src[2], i);
 
2206
                r600_bc_src(&alu.src[2], &ctx->src[1], i);
 
2207
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
2037
2208
                alu.dst.chan = i;
2038
2209
                alu.dst.write = 1;
2039
2210
                alu.is_op3 = 1;
2040
 
                if (i == 3)
 
2211
                if (i == lasti)
2041
2212
                        alu.last = 1;
2042
2213
                r = r600_bc_add_alu(ctx->bc, &alu);
2043
2214
                if (r)
2044
2215
                        return r;
2045
2216
        }
2046
 
        if (use_temp)
2047
 
                return tgsi_helper_copy(ctx, inst);
2048
2217
        return 0;
2049
2218
}
2050
2219
 
2051
2220
static int tgsi_xpd(struct r600_shader_ctx *ctx)
2052
2221
{
2053
2222
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
2054
 
        struct r600_bc_alu_src r600_src[3];
 
2223
        static const unsigned int src0_swizzle[] = {2, 0, 1};
 
2224
        static const unsigned int src1_swizzle[] = {1, 2, 0};
2055
2225
        struct r600_bc_alu alu;
2056
2226
        uint32_t use_temp = 0;
2057
2227
        int i, r;
2059
2229
        if (inst->Dst[0].Register.WriteMask != 0xf)
2060
2230
                use_temp = 1;
2061
2231
 
2062
 
        r = tgsi_split_constant(ctx, r600_src);
2063
 
        if (r)
2064
 
                return r;
2065
 
        r = tgsi_split_literal_constant(ctx, r600_src);
2066
 
        if (r)
2067
 
                return r;
2068
 
 
2069
2232
        for (i = 0; i < 4; i++) {
2070
2233
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2071
2234
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MUL);
2072
 
 
2073
 
                alu.src[0] = r600_src[0];
2074
 
                switch (i) {
2075
 
                case 0:
2076
 
                        alu.src[0].chan = tgsi_chan(&inst->Src[0], 2);
2077
 
                        break;
2078
 
                case 1:
2079
 
                        alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
2080
 
                        break;
2081
 
                case 2:
2082
 
                        alu.src[0].chan = tgsi_chan(&inst->Src[0], 1);
2083
 
                        break;
2084
 
                case 3:
 
2235
                if (i < 3) {
 
2236
                        r600_bc_src(&alu.src[0], &ctx->src[0], src0_swizzle[i]);
 
2237
                        r600_bc_src(&alu.src[1], &ctx->src[1], src1_swizzle[i]);
 
2238
                } else {
2085
2239
                        alu.src[0].sel = V_SQ_ALU_SRC_0;
2086
2240
                        alu.src[0].chan = i;
2087
 
                }
2088
 
 
2089
 
                alu.src[1] = r600_src[1];
2090
 
                switch (i) {
2091
 
                case 0:
2092
 
                        alu.src[1].chan = tgsi_chan(&inst->Src[1], 1);
2093
 
                        break;
2094
 
                case 1:
2095
 
                        alu.src[1].chan = tgsi_chan(&inst->Src[1], 2);
2096
 
                        break;
2097
 
                case 2:
2098
 
                        alu.src[1].chan = tgsi_chan(&inst->Src[1], 0);
2099
 
                        break;
2100
 
                case 3:
2101
2241
                        alu.src[1].sel = V_SQ_ALU_SRC_0;
2102
2242
                        alu.src[1].chan = i;
2103
2243
                }
2111
2251
                r = r600_bc_add_alu(ctx->bc, &alu);
2112
2252
                if (r)
2113
2253
                        return r;
2114
 
 
2115
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2116
 
                if (r)
2117
 
                        return r;
2118
2254
        }
2119
2255
 
2120
2256
        for (i = 0; i < 4; i++) {
2121
2257
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2122
2258
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP3_SQ_OP3_INST_MULADD);
2123
2259
 
2124
 
                alu.src[0] = r600_src[0];
2125
 
                switch (i) {
2126
 
                case 0:
2127
 
                        alu.src[0].chan = tgsi_chan(&inst->Src[0], 1);
2128
 
                        break;
2129
 
                case 1:
2130
 
                        alu.src[0].chan = tgsi_chan(&inst->Src[0], 2);
2131
 
                        break;
2132
 
                case 2:
2133
 
                        alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
2134
 
                        break;
2135
 
                case 3:
 
2260
                if (i < 3) {
 
2261
                        r600_bc_src(&alu.src[0], &ctx->src[0], src1_swizzle[i]);
 
2262
                        r600_bc_src(&alu.src[1], &ctx->src[1], src0_swizzle[i]);
 
2263
                } else {
2136
2264
                        alu.src[0].sel = V_SQ_ALU_SRC_0;
2137
2265
                        alu.src[0].chan = i;
2138
 
                }
2139
 
 
2140
 
                alu.src[1] = r600_src[1];
2141
 
                switch (i) {
2142
 
                case 0:
2143
 
                        alu.src[1].chan = tgsi_chan(&inst->Src[1], 2);
2144
 
                        break;
2145
 
                case 1:
2146
 
                        alu.src[1].chan = tgsi_chan(&inst->Src[1], 0);
2147
 
                        break;
2148
 
                case 2:
2149
 
                        alu.src[1].chan = tgsi_chan(&inst->Src[1], 1);
2150
 
                        break;
2151
 
                case 3:
2152
2266
                        alu.src[1].sel = V_SQ_ALU_SRC_0;
2153
2267
                        alu.src[1].chan = i;
2154
2268
                }
2159
2273
 
2160
2274
                if (use_temp)
2161
2275
                        alu.dst.sel = ctx->temp_reg;
2162
 
                else {
2163
 
                        r = tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
2164
 
                        if (r)
2165
 
                                return r;
2166
 
                }
 
2276
                else
 
2277
                        tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
2167
2278
                alu.dst.chan = i;
2168
2279
                alu.dst.write = 1;
2169
2280
                alu.is_op3 = 1;
2172
2283
                r = r600_bc_add_alu(ctx->bc, &alu);
2173
2284
                if (r)
2174
2285
                        return r;
2175
 
 
2176
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2177
 
                if (r)
2178
 
                        return r;
2179
2286
        }
2180
2287
        if (use_temp)
2181
2288
                return tgsi_helper_copy(ctx, inst);
2185
2292
static int tgsi_exp(struct r600_shader_ctx *ctx)
2186
2293
{
2187
2294
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
2188
 
        struct r600_bc_alu_src r600_src[3] = { { 0 } };
2189
2295
        struct r600_bc_alu alu;
2190
2296
        int r;
 
2297
        int i;
2191
2298
 
2192
2299
        /* result.x = 2^floor(src); */
2193
2300
        if (inst->Dst[0].Register.WriteMask & 1) {
2194
2301
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2195
2302
 
2196
2303
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_FLOOR);
2197
 
                r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2198
 
                if (r)
2199
 
                        return r;
2200
 
 
2201
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
2202
 
 
2203
 
                alu.dst.sel = ctx->temp_reg;
2204
 
                alu.dst.chan = 0;
2205
 
                alu.dst.write = 1;
2206
 
                alu.last = 1;
2207
 
                r = r600_bc_add_alu(ctx->bc, &alu);
2208
 
                if (r)
2209
 
                        return r;
2210
 
 
2211
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2212
 
                if (r)
2213
 
                        return r;
2214
 
 
2215
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
2216
 
                alu.src[0].sel = ctx->temp_reg;
2217
 
                alu.src[0].chan = 0;
2218
 
 
2219
 
                alu.dst.sel = ctx->temp_reg;
2220
 
                alu.dst.chan = 0;
2221
 
                alu.dst.write = 1;
2222
 
                alu.last = 1;
2223
 
                r = r600_bc_add_alu(ctx->bc, &alu);
2224
 
                if (r)
2225
 
                        return r;
2226
 
 
2227
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2228
 
                if (r)
2229
 
                        return r;
 
2304
                r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
2305
 
 
2306
                alu.dst.sel = ctx->temp_reg;
 
2307
                alu.dst.chan = 0;
 
2308
                alu.dst.write = 1;
 
2309
                alu.last = 1;
 
2310
                r = r600_bc_add_alu(ctx->bc, &alu);
 
2311
                if (r)
 
2312
                        return r;
 
2313
 
 
2314
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
2315
                        for (i = 0; i < 3; i++) {
 
2316
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
 
2317
                                alu.src[0].sel = ctx->temp_reg;
 
2318
                                alu.src[0].chan = 0;
 
2319
 
 
2320
                                alu.dst.sel = ctx->temp_reg;
 
2321
                                alu.dst.chan = i;
 
2322
                                if (i == 0)
 
2323
                                        alu.dst.write = 1;
 
2324
                                if (i == 2)
 
2325
                                        alu.last = 1;
 
2326
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
2327
                                if (r)
 
2328
                                        return r;
 
2329
                        }
 
2330
                } else {
 
2331
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
 
2332
                        alu.src[0].sel = ctx->temp_reg;
 
2333
                        alu.src[0].chan = 0;
 
2334
 
 
2335
                        alu.dst.sel = ctx->temp_reg;
 
2336
                        alu.dst.chan = 0;
 
2337
                        alu.dst.write = 1;
 
2338
                        alu.last = 1;
 
2339
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
2340
                        if (r)
 
2341
                                return r;
 
2342
                }
2230
2343
        }
2231
2344
 
2232
2345
        /* result.y = tmp - floor(tmp); */
2234
2347
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2235
2348
 
2236
2349
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_FRACT);
2237
 
                alu.src[0] = r600_src[0];
2238
 
                r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2239
 
                if (r)
2240
 
                        return r;
2241
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
 
2350
                r600_bc_src(&alu.src[0], &ctx->src[0], 0);
2242
2351
 
2243
2352
                alu.dst.sel = ctx->temp_reg;
2244
 
//              r = tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
2245
 
//              if (r)
2246
 
//                      return r;
 
2353
#if 0
 
2354
                r = tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
 
2355
                if (r)
 
2356
                        return r;
 
2357
#endif
2247
2358
                alu.dst.write = 1;
2248
2359
                alu.dst.chan = 1;
2249
2360
 
2252
2363
                r = r600_bc_add_alu(ctx->bc, &alu);
2253
2364
                if (r)
2254
2365
                        return r;
2255
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2256
 
                if (r)
2257
 
                        return r;
2258
2366
        }
2259
2367
 
2260
2368
        /* result.z = RoughApprox2ToX(tmp);*/
2261
2369
        if ((inst->Dst[0].Register.WriteMask >> 2) & 0x1) {
2262
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2263
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
2264
 
                r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2265
 
                if (r)
2266
 
                        return r;
2267
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
2268
 
 
2269
 
                alu.dst.sel = ctx->temp_reg;
2270
 
                alu.dst.write = 1;
2271
 
                alu.dst.chan = 2;
2272
 
 
2273
 
                alu.last = 1;
2274
 
 
2275
 
                r = r600_bc_add_alu(ctx->bc, &alu);
2276
 
                if (r)
2277
 
                        return r;
2278
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2279
 
                if (r)
2280
 
                        return r;
 
2370
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
2371
                        for (i = 0; i < 3; i++) {
 
2372
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2373
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
 
2374
                                r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
2375
 
 
2376
                                alu.dst.sel = ctx->temp_reg;
 
2377
                                alu.dst.chan = i;
 
2378
                                if (i == 2) {
 
2379
                                        alu.dst.write = 1;
 
2380
                                        alu.last = 1;
 
2381
                                }
 
2382
 
 
2383
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
2384
                                if (r)
 
2385
                                        return r;
 
2386
                        }
 
2387
                } else {
 
2388
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2389
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
 
2390
                        r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
2391
 
 
2392
                        alu.dst.sel = ctx->temp_reg;
 
2393
                        alu.dst.write = 1;
 
2394
                        alu.dst.chan = 2;
 
2395
 
 
2396
                        alu.last = 1;
 
2397
 
 
2398
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
2399
                        if (r)
 
2400
                                return r;
 
2401
                }
2281
2402
        }
2282
2403
 
2283
2404
        /* result.w = 1.0;*/
2295
2416
                r = r600_bc_add_alu(ctx->bc, &alu);
2296
2417
                if (r)
2297
2418
                        return r;
2298
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2299
 
                if (r)
2300
 
                        return r;
2301
2419
        }
2302
2420
        return tgsi_helper_copy(ctx, inst);
2303
2421
}
2307
2425
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
2308
2426
        struct r600_bc_alu alu;
2309
2427
        int r;
 
2428
        int i;
2310
2429
 
2311
2430
        /* result.x = floor(log2(src)); */
2312
2431
        if (inst->Dst[0].Register.WriteMask & 1) {
2313
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2314
 
 
2315
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE);
2316
 
                r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2317
 
                if (r)
2318
 
                        return r;
2319
 
 
2320
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
2321
 
 
2322
 
                alu.dst.sel = ctx->temp_reg;
2323
 
                alu.dst.chan = 0;
2324
 
                alu.dst.write = 1;
2325
 
                alu.last = 1;
2326
 
                r = r600_bc_add_alu(ctx->bc, &alu);
2327
 
                if (r)
2328
 
                        return r;
2329
 
 
2330
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2331
 
                if (r)
2332
 
                        return r;
 
2432
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
2433
                        for (i = 0; i < 3; i++) {
 
2434
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2435
 
 
2436
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE);
 
2437
                                r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
2438
                        
 
2439
                                alu.dst.sel = ctx->temp_reg;
 
2440
                                alu.dst.chan = i;
 
2441
                                if (i == 0) 
 
2442
                                        alu.dst.write = 1;
 
2443
                                if (i == 2)
 
2444
                                        alu.last = 1;
 
2445
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
2446
                                if (r)
 
2447
                                        return r;
 
2448
                        }
 
2449
 
 
2450
                } else {
 
2451
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2452
 
 
2453
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE);
 
2454
                        r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
2455
                        
 
2456
                        alu.dst.sel = ctx->temp_reg;
 
2457
                        alu.dst.chan = 0;
 
2458
                        alu.dst.write = 1;
 
2459
                        alu.last = 1;
 
2460
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
2461
                        if (r)
 
2462
                                return r;
 
2463
                }
2333
2464
 
2334
2465
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_FLOOR);
2335
2466
                alu.src[0].sel = ctx->temp_reg;
2343
2474
                r = r600_bc_add_alu(ctx->bc, &alu);
2344
2475
                if (r)
2345
2476
                        return r;
2346
 
 
2347
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2348
 
                if (r)
2349
 
                        return r;
2350
2477
        }
2351
2478
 
2352
2479
        /* result.y = src.x / (2 ^ floor(log2(src.x))); */
2353
2480
        if ((inst->Dst[0].Register.WriteMask >> 1) & 1) {
2354
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2355
 
 
2356
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE);
2357
 
                r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2358
 
                if (r)
2359
 
                        return r;
2360
 
 
2361
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
2362
 
 
2363
 
                alu.dst.sel = ctx->temp_reg;
2364
 
                alu.dst.chan = 1;
2365
 
                alu.dst.write = 1;
2366
 
                alu.last = 1;
2367
 
 
2368
 
                r = r600_bc_add_alu(ctx->bc, &alu);
2369
 
                if (r)
2370
 
                        return r;
2371
 
 
2372
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2373
 
                if (r)
2374
 
                        return r;
 
2481
 
 
2482
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
2483
                        for (i = 0; i < 3; i++) {
 
2484
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2485
 
 
2486
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE);
 
2487
                                r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
2488
 
 
2489
                                alu.dst.sel = ctx->temp_reg;
 
2490
                                alu.dst.chan = i;
 
2491
                                if (i == 1)
 
2492
                                        alu.dst.write = 1;
 
2493
                                if (i == 2)
 
2494
                                        alu.last = 1;
 
2495
                                
 
2496
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
2497
                                if (r)
 
2498
                                        return r;       
 
2499
                        }
 
2500
                } else {
 
2501
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2502
 
 
2503
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE);
 
2504
                        r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
2505
 
 
2506
                        alu.dst.sel = ctx->temp_reg;
 
2507
                        alu.dst.chan = 1;
 
2508
                        alu.dst.write = 1;
 
2509
                        alu.last = 1;
 
2510
 
 
2511
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
2512
                        if (r)
 
2513
                                return r;
 
2514
                }
2375
2515
 
2376
2516
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2377
2517
 
2388
2528
                if (r)
2389
2529
                        return r;
2390
2530
 
2391
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2392
 
                if (r)
2393
 
                        return r;
2394
 
 
2395
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2396
 
 
2397
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
2398
 
                alu.src[0].sel = ctx->temp_reg;
2399
 
                alu.src[0].chan = 1;
2400
 
 
2401
 
                alu.dst.sel = ctx->temp_reg;
2402
 
                alu.dst.chan = 1;
2403
 
                alu.dst.write = 1;
2404
 
                alu.last = 1;
2405
 
 
2406
 
                r = r600_bc_add_alu(ctx->bc, &alu);
2407
 
                if (r)
2408
 
                        return r;
2409
 
 
2410
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2411
 
                if (r)
2412
 
                        return r;
2413
 
 
2414
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2415
 
 
2416
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIP_IEEE);
2417
 
                alu.src[0].sel = ctx->temp_reg;
2418
 
                alu.src[0].chan = 1;
2419
 
 
2420
 
                alu.dst.sel = ctx->temp_reg;
2421
 
                alu.dst.chan = 1;
2422
 
                alu.dst.write = 1;
2423
 
                alu.last = 1;
2424
 
 
2425
 
                r = r600_bc_add_alu(ctx->bc, &alu);
2426
 
                if (r)
2427
 
                        return r;
2428
 
 
2429
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2430
 
                if (r)
2431
 
                        return r;
 
2531
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
2532
                        for (i = 0; i < 3; i++) {
 
2533
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2534
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
 
2535
                                alu.src[0].sel = ctx->temp_reg;
 
2536
                                alu.src[0].chan = 1;
 
2537
 
 
2538
                                alu.dst.sel = ctx->temp_reg;
 
2539
                                alu.dst.chan = i;
 
2540
                                if (i == 1)
 
2541
                                        alu.dst.write = 1;
 
2542
                                if (i == 2)
 
2543
                                        alu.last = 1;
 
2544
 
 
2545
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
2546
                                if (r)
 
2547
                                        return r;
 
2548
                        }
 
2549
                } else {
 
2550
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2551
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE);
 
2552
                        alu.src[0].sel = ctx->temp_reg;
 
2553
                        alu.src[0].chan = 1;
 
2554
 
 
2555
                        alu.dst.sel = ctx->temp_reg;
 
2556
                        alu.dst.chan = 1;
 
2557
                        alu.dst.write = 1;
 
2558
                        alu.last = 1;
 
2559
 
 
2560
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
2561
                        if (r)
 
2562
                                return r;
 
2563
                }
 
2564
 
 
2565
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
2566
                        for (i = 0; i < 3; i++) {
 
2567
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2568
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIP_IEEE);
 
2569
                                alu.src[0].sel = ctx->temp_reg;
 
2570
                                alu.src[0].chan = 1;
 
2571
 
 
2572
                                alu.dst.sel = ctx->temp_reg;
 
2573
                                alu.dst.chan = i;
 
2574
                                if (i == 1)
 
2575
                                        alu.dst.write = 1;
 
2576
                                if (i == 2)
 
2577
                                        alu.last = 1;
 
2578
                                
 
2579
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
2580
                                if (r)
 
2581
                                        return r;
 
2582
                        }
 
2583
                } else {
 
2584
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2585
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIP_IEEE);
 
2586
                        alu.src[0].sel = ctx->temp_reg;
 
2587
                        alu.src[0].chan = 1;
 
2588
 
 
2589
                        alu.dst.sel = ctx->temp_reg;
 
2590
                        alu.dst.chan = 1;
 
2591
                        alu.dst.write = 1;
 
2592
                        alu.last = 1;
 
2593
 
 
2594
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
2595
                        if (r)
 
2596
                                return r;
 
2597
                }
2432
2598
 
2433
2599
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2434
2600
 
2435
2601
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MUL);
2436
2602
 
2437
 
                r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2438
 
                if (r)
2439
 
                        return r;
2440
 
 
2441
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
 
2603
                r600_bc_src(&alu.src[0], &ctx->src[0], 0);
2442
2604
 
2443
2605
                alu.src[1].sel = ctx->temp_reg;
2444
2606
                alu.src[1].chan = 1;
2451
2613
                r = r600_bc_add_alu(ctx->bc, &alu);
2452
2614
                if (r)
2453
2615
                        return r;
2454
 
 
2455
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2456
 
                if (r)
2457
 
                        return r;
2458
2616
        }
2459
2617
 
2460
2618
        /* result.z = log2(src);*/
2461
2619
        if ((inst->Dst[0].Register.WriteMask >> 2) & 1) {
2462
 
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2463
 
 
2464
 
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE);
2465
 
                r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2466
 
                if (r)
2467
 
                        return r;
2468
 
 
2469
 
                alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
2470
 
 
2471
 
                alu.dst.sel = ctx->temp_reg;
2472
 
                alu.dst.write = 1;
2473
 
                alu.dst.chan = 2;
2474
 
                alu.last = 1;
2475
 
 
2476
 
                r = r600_bc_add_alu(ctx->bc, &alu);
2477
 
                if (r)
2478
 
                        return r;
2479
 
 
2480
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2481
 
                if (r)
2482
 
                        return r;
 
2620
                if (ctx->bc->chiprev == CHIPREV_CAYMAN) {
 
2621
                        for (i = 0; i < 3; i++) {
 
2622
                                memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2623
 
 
2624
                                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE);
 
2625
                                r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
2626
 
 
2627
                                alu.dst.sel = ctx->temp_reg;
 
2628
                                if (i == 2)
 
2629
                                        alu.dst.write = 1;
 
2630
                                alu.dst.chan = i;
 
2631
                                if (i == 2)
 
2632
                                        alu.last = 1;
 
2633
 
 
2634
                                r = r600_bc_add_alu(ctx->bc, &alu);
 
2635
                                if (r)
 
2636
                                        return r;
 
2637
                        }
 
2638
                } else {
 
2639
                        memset(&alu, 0, sizeof(struct r600_bc_alu));
 
2640
 
 
2641
                        alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE);
 
2642
                        r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
2643
 
 
2644
                        alu.dst.sel = ctx->temp_reg;
 
2645
                        alu.dst.write = 1;
 
2646
                        alu.dst.chan = 2;
 
2647
                        alu.last = 1;
 
2648
 
 
2649
                        r = r600_bc_add_alu(ctx->bc, &alu);
 
2650
                        if (r)
 
2651
                                return r;
 
2652
                }
2483
2653
        }
2484
2654
 
2485
2655
        /* result.w = 1.0; */
2498
2668
                r = r600_bc_add_alu(ctx->bc, &alu);
2499
2669
                if (r)
2500
2670
                        return r;
2501
 
 
2502
 
                r = r600_bc_add_literal(ctx->bc, ctx->value);
2503
 
                if (r)
2504
 
                        return r;
2505
2671
        }
2506
2672
 
2507
2673
        return tgsi_helper_copy(ctx, inst);
2512
2678
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
2513
2679
        struct r600_bc_alu alu;
2514
2680
        int r;
 
2681
 
2515
2682
        memset(&alu, 0, sizeof(struct r600_bc_alu));
2516
2683
 
2517
2684
        switch (inst->Instruction.Opcode) {
2526
2693
                return -1;
2527
2694
        }
2528
2695
 
2529
 
        r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2530
 
        if (r)
2531
 
                return r;
2532
 
        alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
 
2696
        r600_bc_src(&alu.src[0], &ctx->src[0], 0);
2533
2697
        alu.last = 1;
2534
 
        alu.dst.chan = 0;
2535
 
        alu.dst.sel = ctx->temp_reg;
 
2698
        alu.dst.sel = ctx->ar_reg;
2536
2699
        alu.dst.write = 1;
2537
 
        r = r600_bc_add_alu_type(ctx->bc, &alu, CTX_INST(V_SQ_CF_ALU_WORD1_SQ_CF_INST_ALU));
 
2700
        r = r600_bc_add_alu(ctx->bc, &alu);
2538
2701
        if (r)
2539
2702
                return r;
 
2703
 
 
2704
        /* TODO: Note that the MOVA can be avoided if we never use AR for
 
2705
         * indexing non-CB registers in the current ALU clause. Similarly, we
 
2706
         * need to load AR from ar_reg again if we started a new clause
 
2707
         * between ARL and AR usage. The easy way to do that is to remove
 
2708
         * the MOVA here, and load it for the first AR access after ar_reg
 
2709
         * has been modified in each clause. */
2540
2710
        memset(&alu, 0, sizeof(struct r600_bc_alu));
2541
2711
        alu.inst = EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOVA_INT;
2542
 
        r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2543
 
        if (r)
2544
 
                return r;
2545
 
        alu.src[0].sel = ctx->temp_reg;
 
2712
        alu.src[0].sel = ctx->ar_reg;
2546
2713
        alu.src[0].chan = 0;
2547
2714
        alu.last = 1;
2548
 
        r = r600_bc_add_alu_type(ctx->bc, &alu, CTX_INST(V_SQ_CF_ALU_WORD1_SQ_CF_INST_ALU));
 
2715
        r = r600_bc_add_alu(ctx->bc, &alu);
2549
2716
        if (r)
2550
2717
                return r;
2551
2718
        return 0;
2556
2723
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
2557
2724
        struct r600_bc_alu alu;
2558
2725
        int r;
2559
 
        memset(&alu, 0, sizeof(struct r600_bc_alu));
2560
2726
 
2561
2727
        switch (inst->Instruction.Opcode) {
2562
2728
        case TGSI_OPCODE_ARL:
2563
 
                alu.inst = V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOVA_FLOOR;
 
2729
                memset(&alu, 0, sizeof(alu));
 
2730
                alu.inst = V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_FLOOR;
 
2731
                r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
2732
                alu.dst.sel = ctx->ar_reg;
 
2733
                alu.dst.write = 1;
 
2734
                alu.last = 1;
 
2735
 
 
2736
                if ((r = r600_bc_add_alu(ctx->bc, &alu)))
 
2737
                        return r;
 
2738
 
 
2739
                memset(&alu, 0, sizeof(alu));
 
2740
                alu.inst = V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_FLT_TO_INT;
 
2741
                alu.src[0].sel = ctx->ar_reg;
 
2742
                alu.dst.sel = ctx->ar_reg;
 
2743
                alu.dst.write = 1;
 
2744
                alu.last = 1;
 
2745
 
 
2746
                if ((r = r600_bc_add_alu(ctx->bc, &alu)))
 
2747
                        return r;
2564
2748
                break;
2565
2749
        case TGSI_OPCODE_ARR:
2566
 
                alu.inst = V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOVA;
 
2750
                memset(&alu, 0, sizeof(alu));
 
2751
                alu.inst = V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_FLT_TO_INT;
 
2752
                r600_bc_src(&alu.src[0], &ctx->src[0], 0);
 
2753
                alu.dst.sel = ctx->ar_reg;
 
2754
                alu.dst.write = 1;
 
2755
                alu.last = 1;
 
2756
 
 
2757
                if ((r = r600_bc_add_alu(ctx->bc, &alu)))
 
2758
                        return r;
2567
2759
                break;
2568
2760
        default:
2569
2761
                assert(0);
2570
2762
                return -1;
2571
2763
        }
2572
2764
 
2573
 
 
2574
 
        r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2575
 
        if (r)
2576
 
                return r;
2577
 
        alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
2578
 
 
 
2765
        memset(&alu, 0, sizeof(alu));
 
2766
        alu.inst = V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOVA_INT;
 
2767
        alu.src[0].sel = ctx->ar_reg;
2579
2768
        alu.last = 1;
2580
2769
 
2581
 
        r = r600_bc_add_alu_type(ctx->bc, &alu, CTX_INST(V_SQ_CF_ALU_WORD1_SQ_CF_INST_ALU));
 
2770
        r = r600_bc_add_alu(ctx->bc, &alu);
2582
2771
        if (r)
2583
2772
                return r;
2584
2773
        ctx->bc->cf_last->r6xx_uses_waterfall = 1;
2595
2784
                memset(&alu, 0, sizeof(struct r600_bc_alu));
2596
2785
 
2597
2786
                alu.inst = CTX_INST(V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MUL);
2598
 
                r = tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
2599
 
                if (r)
2600
 
                        return r;
 
2787
                tgsi_dst(ctx, &inst->Dst[0], i, &alu.dst);
2601
2788
 
2602
2789
                if (i == 0 || i == 3) {
2603
2790
                        alu.src[0].sel = V_SQ_ALU_SRC_1;
2604
2791
                } else {
2605
 
                        r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2606
 
                        if (r)
2607
 
                                return r;
2608
 
                        alu.src[0].chan = tgsi_chan(&inst->Src[0], i);
 
2792
                        r600_bc_src(&alu.src[0], &ctx->src[0], i);
2609
2793
                }
2610
2794
 
2611
 
                if (i == 0 || i == 2) {
 
2795
                if (i == 0 || i == 2) {
2612
2796
                        alu.src[1].sel = V_SQ_ALU_SRC_1;
2613
2797
                } else {
2614
 
                        r = tgsi_src(ctx, &inst->Src[1], &alu.src[1]);
2615
 
                        if (r)
2616
 
                                return r;
2617
 
                        alu.src[1].chan = tgsi_chan(&inst->Src[1], i);
 
2798
                        r600_bc_src(&alu.src[1], &ctx->src[1], i);
2618
2799
                }
2619
2800
                if (i == 3)
2620
2801
                        alu.last = 1;
2627
2808
 
2628
2809
static int emit_logic_pred(struct r600_shader_ctx *ctx, int opcode)
2629
2810
{
2630
 
        struct tgsi_full_instruction *inst = &ctx->parse.FullToken.FullInstruction;
2631
2811
        struct r600_bc_alu alu;
2632
2812
        int r;
2633
2813
 
2639
2819
        alu.dst.write = 1;
2640
2820
        alu.dst.chan = 0;
2641
2821
 
2642
 
        r = tgsi_src(ctx, &inst->Src[0], &alu.src[0]);
2643
 
        if (r)
2644
 
                return r;
2645
 
        alu.src[0].chan = tgsi_chan(&inst->Src[0], 0);
 
2822
        r600_bc_src(&alu.src[0], &ctx->src[0], 0);
2646
2823
        alu.src[1].sel = V_SQ_ALU_SRC_0;
2647
2824
        alu.src[1].chan = 0;
2648
2825
 
2656
2833
 
2657
2834
static int pops(struct r600_shader_ctx *ctx, int pops)
2658
2835
{
2659
 
        r600_bc_add_cfinst(ctx->bc, CTX_INST(V_SQ_CF_WORD1_SQ_CF_INST_POP));
2660
 
        ctx->bc->cf_last->pop_count = pops;
2661
 
        ctx->bc->cf_last->cf_addr = ctx->bc->cf_last->id + 2;
 
2836
        int alu_pop = 3;
 
2837
        if (ctx->bc->cf_last) {
 
2838
                if (ctx->bc->cf_last->inst == CTX_INST(V_SQ_CF_ALU_WORD1_SQ_CF_INST_ALU) << 3)
 
2839
                        alu_pop = 0;
 
2840
                else if (ctx->bc->cf_last->inst == CTX_INST(V_SQ_CF_ALU_WORD1_SQ_CF_INST_ALU_POP_AFTER) << 3)
 
2841
                        alu_pop = 1;
 
2842
        }
 
2843
        alu_pop += pops;
 
2844
        if (alu_pop == 1) {
 
2845
                ctx->bc->cf_last->inst = CTX_INST(V_SQ_CF_ALU_WORD1_SQ_CF_INST_ALU_POP_AFTER) << 3;
 
2846
                ctx->bc->force_add_cf = 1;
 
2847
        } else if (alu_pop == 2) {
 
2848
                ctx->bc->cf_last->inst = CTX_INST(V_SQ_CF_ALU_WORD1_SQ_CF_INST_ALU_POP2_AFTER) << 3;
 
2849
                ctx->bc->force_add_cf = 1;
 
2850
        } else {
 
2851
                r600_bc_add_cfinst(ctx->bc, CTX_INST(V_SQ_CF_WORD1_SQ_CF_INST_POP));
 
2852
                ctx->bc->cf_last->pop_count = pops;
 
2853
                ctx->bc->cf_last->cf_addr = ctx->bc->cf_last->id + 2;
 
2854
        }
2662
2855
        return 0;
2663
2856
}
2664
2857
 
2969
3162
        {TGSI_OPCODE_SNE,       0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SETNE, tgsi_op2},
2970
3163
        {TGSI_OPCODE_STR,       0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
2971
3164
        {TGSI_OPCODE_TEX,       0, SQ_TEX_INST_SAMPLE, tgsi_tex},
2972
 
        {TGSI_OPCODE_TXD,       0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3165
        {TGSI_OPCODE_TXD,       0, SQ_TEX_INST_SAMPLE_G, tgsi_tex},
2973
3166
        {TGSI_OPCODE_TXP,       0, SQ_TEX_INST_SAMPLE, tgsi_tex},
2974
3167
        {TGSI_OPCODE_UP2H,      0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
2975
3168
        {TGSI_OPCODE_UP2US,     0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3004
3197
        {TGSI_OPCODE_CEIL,      0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3005
3198
        {TGSI_OPCODE_I2F,       0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3006
3199
        {TGSI_OPCODE_NOT,       0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3007
 
        {TGSI_OPCODE_TRUNC,     0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_TRUNC, tgsi_trans_srcx_replicate},
 
3200
        {TGSI_OPCODE_TRUNC,     0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_TRUNC, tgsi_op2},
3008
3201
        {TGSI_OPCODE_SHL,       0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3009
3202
        /* gap */
3010
3203
        {88,                    0, V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3075
3268
        {TGSI_OPCODE_MOV,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV, tgsi_op2},
3076
3269
        {TGSI_OPCODE_LIT,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_lit},
3077
3270
        {TGSI_OPCODE_RCP,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIP_IEEE, tgsi_trans_srcx_replicate},
3078
 
        {TGSI_OPCODE_RSQ,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIPSQRT_IEEE, tgsi_trans_srcx_replicate},
 
3271
        {TGSI_OPCODE_RSQ,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIPSQRT_IEEE, tgsi_rsq},
3079
3272
        {TGSI_OPCODE_EXP,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_exp},
3080
 
        {TGSI_OPCODE_LOG,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3273
        {TGSI_OPCODE_LOG,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_log},
3081
3274
        {TGSI_OPCODE_MUL,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MUL, tgsi_op2},
3082
3275
        {TGSI_OPCODE_ADD,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_ADD, tgsi_op2},
3083
3276
        {TGSI_OPCODE_DP3,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_DOT4, tgsi_dp},
3127
3320
        {TGSI_OPCODE_SNE,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SETNE, tgsi_op2},
3128
3321
        {TGSI_OPCODE_STR,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3129
3322
        {TGSI_OPCODE_TEX,       0, SQ_TEX_INST_SAMPLE, tgsi_tex},
3130
 
        {TGSI_OPCODE_TXD,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3131
 
        {TGSI_OPCODE_TXP,       0, SQ_TEX_INST_SAMPLE, tgsi_tex},
3132
 
        {TGSI_OPCODE_UP2H,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3133
 
        {TGSI_OPCODE_UP2US,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3134
 
        {TGSI_OPCODE_UP4B,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3135
 
        {TGSI_OPCODE_UP4UB,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3136
 
        {TGSI_OPCODE_X2D,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3137
 
        {TGSI_OPCODE_ARA,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3138
 
        {TGSI_OPCODE_ARR,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_eg_arl},
3139
 
        {TGSI_OPCODE_BRA,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3140
 
        {TGSI_OPCODE_CAL,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3141
 
        {TGSI_OPCODE_RET,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3142
 
        {TGSI_OPCODE_SSG,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_ssg},
3143
 
        {TGSI_OPCODE_CMP,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_cmp},
3144
 
        {TGSI_OPCODE_SCS,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_scs},
3145
 
        {TGSI_OPCODE_TXB,       0, SQ_TEX_INST_SAMPLE_L, tgsi_tex},
3146
 
        {TGSI_OPCODE_NRM,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3147
 
        {TGSI_OPCODE_DIV,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3148
 
        {TGSI_OPCODE_DP2,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_DOT4, tgsi_dp},
3149
 
        {TGSI_OPCODE_TXL,       0, SQ_TEX_INST_SAMPLE_L, tgsi_tex},
3150
 
        {TGSI_OPCODE_BRK,       0, EG_V_SQ_CF_WORD1_SQ_CF_INST_LOOP_BREAK, tgsi_loop_brk_cont},
3151
 
        {TGSI_OPCODE_IF,        0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_if},
3152
 
        /* gap */
3153
 
        {75,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3154
 
        {76,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3155
 
        {TGSI_OPCODE_ELSE,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_else},
3156
 
        {TGSI_OPCODE_ENDIF,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_endif},
3157
 
        /* gap */
3158
 
        {79,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3159
 
        {80,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3160
 
        {TGSI_OPCODE_PUSHA,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3161
 
        {TGSI_OPCODE_POPA,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3162
 
        {TGSI_OPCODE_CEIL,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3163
 
        {TGSI_OPCODE_I2F,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3164
 
        {TGSI_OPCODE_NOT,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3165
 
        {TGSI_OPCODE_TRUNC,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_TRUNC, tgsi_trans_srcx_replicate},
 
3323
        {TGSI_OPCODE_TXD,       0, SQ_TEX_INST_SAMPLE_G, tgsi_tex},
 
3324
        {TGSI_OPCODE_TXP,       0, SQ_TEX_INST_SAMPLE, tgsi_tex},
 
3325
        {TGSI_OPCODE_UP2H,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3326
        {TGSI_OPCODE_UP2US,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3327
        {TGSI_OPCODE_UP4B,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3328
        {TGSI_OPCODE_UP4UB,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3329
        {TGSI_OPCODE_X2D,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3330
        {TGSI_OPCODE_ARA,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3331
        {TGSI_OPCODE_ARR,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_eg_arl},
 
3332
        {TGSI_OPCODE_BRA,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3333
        {TGSI_OPCODE_CAL,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3334
        {TGSI_OPCODE_RET,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3335
        {TGSI_OPCODE_SSG,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_ssg},
 
3336
        {TGSI_OPCODE_CMP,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_cmp},
 
3337
        {TGSI_OPCODE_SCS,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_scs},
 
3338
        {TGSI_OPCODE_TXB,       0, SQ_TEX_INST_SAMPLE_L, tgsi_tex},
 
3339
        {TGSI_OPCODE_NRM,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3340
        {TGSI_OPCODE_DIV,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3341
        {TGSI_OPCODE_DP2,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_DOT4, tgsi_dp},
 
3342
        {TGSI_OPCODE_TXL,       0, SQ_TEX_INST_SAMPLE_L, tgsi_tex},
 
3343
        {TGSI_OPCODE_BRK,       0, EG_V_SQ_CF_WORD1_SQ_CF_INST_LOOP_BREAK, tgsi_loop_brk_cont},
 
3344
        {TGSI_OPCODE_IF,        0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_if},
 
3345
        /* gap */
 
3346
        {75,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3347
        {76,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3348
        {TGSI_OPCODE_ELSE,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_else},
 
3349
        {TGSI_OPCODE_ENDIF,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_endif},
 
3350
        /* gap */
 
3351
        {79,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3352
        {80,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3353
        {TGSI_OPCODE_PUSHA,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3354
        {TGSI_OPCODE_POPA,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3355
        {TGSI_OPCODE_CEIL,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3356
        {TGSI_OPCODE_I2F,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3357
        {TGSI_OPCODE_NOT,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3358
        {TGSI_OPCODE_TRUNC,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_TRUNC, tgsi_op2},
 
3359
        {TGSI_OPCODE_SHL,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3360
        /* gap */
 
3361
        {88,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3362
        {TGSI_OPCODE_AND,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3363
        {TGSI_OPCODE_OR,        0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3364
        {TGSI_OPCODE_MOD,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3365
        {TGSI_OPCODE_XOR,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3366
        {TGSI_OPCODE_SAD,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3367
        {TGSI_OPCODE_TXF,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3368
        {TGSI_OPCODE_TXQ,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3369
        {TGSI_OPCODE_CONT,      0, EG_V_SQ_CF_WORD1_SQ_CF_INST_LOOP_CONTINUE, tgsi_loop_brk_cont},
 
3370
        {TGSI_OPCODE_EMIT,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3371
        {TGSI_OPCODE_ENDPRIM,   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3372
        {TGSI_OPCODE_BGNLOOP,   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_bgnloop},
 
3373
        {TGSI_OPCODE_BGNSUB,    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3374
        {TGSI_OPCODE_ENDLOOP,   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_endloop},
 
3375
        {TGSI_OPCODE_ENDSUB,    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3376
        /* gap */
 
3377
        {103,                   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3378
        {104,                   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3379
        {105,                   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3380
        {106,                   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3381
        {TGSI_OPCODE_NOP,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3382
        /* gap */
 
3383
        {108,                   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3384
        {109,                   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3385
        {110,                   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3386
        {111,                   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3387
        {TGSI_OPCODE_NRM4,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3388
        {TGSI_OPCODE_CALLNZ,    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3389
        {TGSI_OPCODE_IFC,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3390
        {TGSI_OPCODE_BREAKC,    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3391
        {TGSI_OPCODE_KIL,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_KILLGT, tgsi_kill},  /* conditional kill */
 
3392
        {TGSI_OPCODE_END,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_end},  /* aka HALT */
 
3393
        /* gap */
 
3394
        {118,                   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3395
        {TGSI_OPCODE_F2I,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3396
        {TGSI_OPCODE_IDIV,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3397
        {TGSI_OPCODE_IMAX,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3398
        {TGSI_OPCODE_IMIN,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3399
        {TGSI_OPCODE_INEG,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3400
        {TGSI_OPCODE_ISGE,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3401
        {TGSI_OPCODE_ISHR,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3402
        {TGSI_OPCODE_ISLT,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3403
        {TGSI_OPCODE_F2U,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3404
        {TGSI_OPCODE_U2F,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3405
        {TGSI_OPCODE_UADD,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3406
        {TGSI_OPCODE_UDIV,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3407
        {TGSI_OPCODE_UMAD,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3408
        {TGSI_OPCODE_UMAX,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3409
        {TGSI_OPCODE_UMIN,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3410
        {TGSI_OPCODE_UMOD,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3411
        {TGSI_OPCODE_UMUL,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3412
        {TGSI_OPCODE_USEQ,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3413
        {TGSI_OPCODE_USGE,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3414
        {TGSI_OPCODE_USHR,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3415
        {TGSI_OPCODE_USLT,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3416
        {TGSI_OPCODE_USNE,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3417
        {TGSI_OPCODE_SWITCH,    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3418
        {TGSI_OPCODE_CASE,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3419
        {TGSI_OPCODE_DEFAULT,   0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3420
        {TGSI_OPCODE_ENDSWITCH, 0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3421
        {TGSI_OPCODE_LAST,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3422
};
 
3423
 
 
3424
static struct r600_shader_tgsi_instruction cm_shader_tgsi_instruction[] = {
 
3425
        {TGSI_OPCODE_ARL,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_eg_arl},
 
3426
        {TGSI_OPCODE_MOV,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV, tgsi_op2},
 
3427
        {TGSI_OPCODE_LIT,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_lit},
 
3428
        {TGSI_OPCODE_RCP,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIP_IEEE, cayman_emit_float_instr},
 
3429
        {TGSI_OPCODE_RSQ,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_RECIPSQRT_IEEE, cayman_emit_float_instr},
 
3430
        {TGSI_OPCODE_EXP,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_exp},
 
3431
        {TGSI_OPCODE_LOG,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_log},
 
3432
        {TGSI_OPCODE_MUL,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MUL, tgsi_op2},
 
3433
        {TGSI_OPCODE_ADD,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_ADD, tgsi_op2},
 
3434
        {TGSI_OPCODE_DP3,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_DOT4, tgsi_dp},
 
3435
        {TGSI_OPCODE_DP4,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_DOT4, tgsi_dp},
 
3436
        {TGSI_OPCODE_DST,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_opdst},
 
3437
        {TGSI_OPCODE_MIN,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MIN, tgsi_op2},
 
3438
        {TGSI_OPCODE_MAX,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MAX, tgsi_op2},
 
3439
        {TGSI_OPCODE_SLT,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SETGT, tgsi_op2_swap},
 
3440
        {TGSI_OPCODE_SGE,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SETGE, tgsi_op2},
 
3441
        {TGSI_OPCODE_MAD,       1, EG_V_SQ_ALU_WORD1_OP3_SQ_OP3_INST_MULADD, tgsi_op3},
 
3442
        {TGSI_OPCODE_SUB,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_ADD, tgsi_op2},
 
3443
        {TGSI_OPCODE_LRP,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_lrp},
 
3444
        {TGSI_OPCODE_CND,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3445
        /* gap */
 
3446
        {20,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3447
        {TGSI_OPCODE_DP2A,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3448
        /* gap */
 
3449
        {22,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3450
        {23,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3451
        {TGSI_OPCODE_FRC,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_FRACT, tgsi_op2},
 
3452
        {TGSI_OPCODE_CLAMP,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3453
        {TGSI_OPCODE_FLR,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_FLOOR, tgsi_op2},
 
3454
        {TGSI_OPCODE_ROUND,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3455
        {TGSI_OPCODE_EX2,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_EXP_IEEE, cayman_emit_float_instr},
 
3456
        {TGSI_OPCODE_LG2,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_LOG_IEEE, cayman_emit_float_instr},
 
3457
        {TGSI_OPCODE_POW,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, cayman_pow},
 
3458
        {TGSI_OPCODE_XPD,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_xpd},
 
3459
        /* gap */
 
3460
        {32,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3461
        {TGSI_OPCODE_ABS,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_MOV, tgsi_op2},
 
3462
        {TGSI_OPCODE_RCC,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3463
        {TGSI_OPCODE_DPH,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_DOT4, tgsi_dp},
 
3464
        {TGSI_OPCODE_COS,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_COS, cayman_trig},
 
3465
        {TGSI_OPCODE_DDX,       0, SQ_TEX_INST_GET_GRADIENTS_H, tgsi_tex},
 
3466
        {TGSI_OPCODE_DDY,       0, SQ_TEX_INST_GET_GRADIENTS_V, tgsi_tex},
 
3467
        {TGSI_OPCODE_KILP,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_KILLGT, tgsi_kill},  /* predicated kill */
 
3468
        {TGSI_OPCODE_PK2H,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3469
        {TGSI_OPCODE_PK2US,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3470
        {TGSI_OPCODE_PK4B,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3471
        {TGSI_OPCODE_PK4UB,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3472
        {TGSI_OPCODE_RFL,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3473
        {TGSI_OPCODE_SEQ,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SETE, tgsi_op2},
 
3474
        {TGSI_OPCODE_SFL,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3475
        {TGSI_OPCODE_SGT,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SETGT, tgsi_op2},
 
3476
        {TGSI_OPCODE_SIN,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SIN, cayman_trig},
 
3477
        {TGSI_OPCODE_SLE,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SETGE, tgsi_op2_swap},
 
3478
        {TGSI_OPCODE_SNE,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_SETNE, tgsi_op2},
 
3479
        {TGSI_OPCODE_STR,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3480
        {TGSI_OPCODE_TEX,       0, SQ_TEX_INST_SAMPLE, tgsi_tex},
 
3481
        {TGSI_OPCODE_TXD,       0, SQ_TEX_INST_SAMPLE_G, tgsi_tex},
 
3482
        {TGSI_OPCODE_TXP,       0, SQ_TEX_INST_SAMPLE, tgsi_tex},
 
3483
        {TGSI_OPCODE_UP2H,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3484
        {TGSI_OPCODE_UP2US,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3485
        {TGSI_OPCODE_UP4B,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3486
        {TGSI_OPCODE_UP4UB,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3487
        {TGSI_OPCODE_X2D,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3488
        {TGSI_OPCODE_ARA,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3489
        {TGSI_OPCODE_ARR,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_eg_arl},
 
3490
        {TGSI_OPCODE_BRA,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3491
        {TGSI_OPCODE_CAL,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3492
        {TGSI_OPCODE_RET,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3493
        {TGSI_OPCODE_SSG,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_ssg},
 
3494
        {TGSI_OPCODE_CMP,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_cmp},
 
3495
        {TGSI_OPCODE_SCS,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_scs},
 
3496
        {TGSI_OPCODE_TXB,       0, SQ_TEX_INST_SAMPLE_L, tgsi_tex},
 
3497
        {TGSI_OPCODE_NRM,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3498
        {TGSI_OPCODE_DIV,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3499
        {TGSI_OPCODE_DP2,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_DOT4, tgsi_dp},
 
3500
        {TGSI_OPCODE_TXL,       0, SQ_TEX_INST_SAMPLE_L, tgsi_tex},
 
3501
        {TGSI_OPCODE_BRK,       0, EG_V_SQ_CF_WORD1_SQ_CF_INST_LOOP_BREAK, tgsi_loop_brk_cont},
 
3502
        {TGSI_OPCODE_IF,        0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_if},
 
3503
        /* gap */
 
3504
        {75,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3505
        {76,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3506
        {TGSI_OPCODE_ELSE,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_else},
 
3507
        {TGSI_OPCODE_ENDIF,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_endif},
 
3508
        /* gap */
 
3509
        {79,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3510
        {80,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3511
        {TGSI_OPCODE_PUSHA,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3512
        {TGSI_OPCODE_POPA,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3513
        {TGSI_OPCODE_CEIL,      0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3514
        {TGSI_OPCODE_I2F,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3515
        {TGSI_OPCODE_NOT,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
 
3516
        {TGSI_OPCODE_TRUNC,     0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_TRUNC, tgsi_op2},
3166
3517
        {TGSI_OPCODE_SHL,       0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},
3167
3518
        /* gap */
3168
3519
        {88,                    0, EG_V_SQ_ALU_WORD1_OP2_SQ_OP2_INST_NOP, tgsi_unsupported},