← Back to branch summary

~ubuntu-branches/ubuntu/precise/mesa/precise-updates

« back to all changes in this revision

Viewing changes to src/gallium/drivers/r300/compiler/r300_fragprog_emit.c

  • Committer: Package Import Robot
  • Author(s): Robert Hooker
  • Date: 2012-02-02 12:05:48 UTC
  • mfrom: (1.7.1) (3.3.27 sid)
  • Revision ID: package-import@ubuntu.com-20120202120548-nvkma85jq0h4coix
Tags: 8.0~rc2-0ubuntu4
Drop drisearchdir handling, it is no longer needed with multiarch
and dri-alternates being removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/r300/compiler/r300_fragprog_emit.c
 
1
/*
 
2
 * Copyright (C) 2005 Ben Skeggs.
 
3
 *
 
4
 * All Rights Reserved.
 
5
 *
 
6
 * Permission is hereby granted, free of charge, to any person obtaining
 
7
 * a copy of this software and associated documentation files (the
 
8
 * "Software"), to deal in the Software without restriction, including
 
9
 * without limitation the rights to use, copy, modify, merge, publish,
 
10
 * distribute, sublicense, and/or sell copies of the Software, and to
 
11
 * permit persons to whom the Software is furnished to do so, subject to
 
12
 * the following conditions:
 
13
 *
 
14
 * The above copyright notice and this permission notice (including the
 
15
 * next paragraph) shall be included in all copies or substantial
 
16
 * portions of the Software.
 
17
 *
 
18
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
19
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
20
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 
21
 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
 
22
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 
23
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 
24
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
25
 *
 
26
 */
 
27
 
 
28
/**
 
29
 * \file
 
30
 *
 
31
 * Emit the r300_fragment_program_code that can be understood by the hardware.
 
32
 * Input is a pre-transformed radeon_program.
 
33
 *
 
34
 * \author Ben Skeggs <darktama@iinet.net.au>
 
35
 *
 
36
 * \author Jerome Glisse <j.glisse@gmail.com>
 
37
 */
 
38
 
 
39
#include "r300_fragprog.h"
 
40
 
 
41
#include "../r300_reg.h"
 
42
 
 
43
#include "radeon_program_pair.h"
 
44
#include "r300_fragprog_swizzle.h"
 
45
 
 
46
 
 
47
struct r300_emit_state {
 
48
        struct r300_fragment_program_compiler * compiler;
 
49
 
 
50
        unsigned current_node : 2;
 
51
        unsigned node_first_tex : 8;
 
52
        unsigned node_first_alu : 8;
 
53
        uint32_t node_flags;
 
54
};
 
55
 
 
56
#define PROG_CODE \
 
57
        struct r300_fragment_program_compiler *c = emit->compiler; \
 
58
        struct r300_fragment_program_code *code = &c->code->code.r300
 
59
 
 
60
#define error(fmt, args...) do {                        \
 
61
                rc_error(&c->Base, "%s::%s(): " fmt "\n",       \
 
62
                        __FILE__, __FUNCTION__, ##args);        \
 
63
        } while(0)
 
64
 
 
65
static unsigned int get_msbs_alu(unsigned int bits)
 
66
{
 
67
        return (bits >> 6) & 0x7;
 
68
}
 
69
 
 
70
/**
 
71
 * @param lsbs The number of least significant bits
 
72
 */
 
73
static unsigned int get_msbs_tex(unsigned int bits, unsigned int lsbs)
 
74
{
 
75
        return (bits >> lsbs) & 0x15;
 
76
}
 
77
 
 
78
#define R400_EXT_GET_MSBS(x, lsbs, mask) (((x) >> lsbs) & mask)
 
79
 
 
80
/**
 
81
 * Mark a temporary register as used.
 
82
 */
 
83
static void use_temporary(struct r300_fragment_program_code *code, unsigned int index)
 
84
{
 
85
        if (index > code->pixsize)
 
86
                code->pixsize = index;
 
87
}
 
88
 
 
89
static unsigned int use_source(struct r300_fragment_program_code* code, struct rc_pair_instruction_source src)
 
90
{
 
91
        if (!src.Used)
 
92
                return 0;
 
93
 
 
94
        if (src.File == RC_FILE_CONSTANT) {
 
95
                return src.Index | (1 << 5);
 
96
        } else if (src.File == RC_FILE_TEMPORARY || src.File == RC_FILE_INPUT) {
 
97
                use_temporary(code, src.Index);
 
98
                return src.Index & 0x1f;
 
99
        }
 
100
 
 
101
        return 0;
 
102
}
 
103
 
 
104
 
 
105
static unsigned int translate_rgb_opcode(struct r300_fragment_program_compiler * c, rc_opcode opcode)
 
106
{
 
107
        switch(opcode) {
 
108
        case RC_OPCODE_CMP: return R300_ALU_OUTC_CMP;
 
109
        case RC_OPCODE_CND: return R300_ALU_OUTC_CND;
 
110
        case RC_OPCODE_DP3: return R300_ALU_OUTC_DP3;
 
111
        case RC_OPCODE_DP4: return R300_ALU_OUTC_DP4;
 
112
        case RC_OPCODE_FRC: return R300_ALU_OUTC_FRC;
 
113
        default:
 
114
                error("translate_rgb_opcode: Unknown opcode %s", rc_get_opcode_info(opcode)->Name);
 
115
                /* fall through */
 
116
        case RC_OPCODE_NOP:
 
117
                /* fall through */
 
118
        case RC_OPCODE_MAD: return R300_ALU_OUTC_MAD;
 
119
        case RC_OPCODE_MAX: return R300_ALU_OUTC_MAX;
 
120
        case RC_OPCODE_MIN: return R300_ALU_OUTC_MIN;
 
121
        case RC_OPCODE_REPL_ALPHA: return R300_ALU_OUTC_REPL_ALPHA;
 
122
        }
 
123
}
 
124
 
 
125
static unsigned int translate_alpha_opcode(struct r300_fragment_program_compiler * c, rc_opcode opcode)
 
126
{
 
127
        switch(opcode) {
 
128
        case RC_OPCODE_CMP: return R300_ALU_OUTA_CMP;
 
129
        case RC_OPCODE_CND: return R300_ALU_OUTA_CND;
 
130
        case RC_OPCODE_DP3: return R300_ALU_OUTA_DP4;
 
131
        case RC_OPCODE_DP4: return R300_ALU_OUTA_DP4;
 
132
        case RC_OPCODE_EX2: return R300_ALU_OUTA_EX2;
 
133
        case RC_OPCODE_FRC: return R300_ALU_OUTA_FRC;
 
134
        case RC_OPCODE_LG2: return R300_ALU_OUTA_LG2;
 
135
        default:
 
136
                error("translate_rgb_opcode: Unknown opcode %s", rc_get_opcode_info(opcode)->Name);
 
137
                /* fall through */
 
138
        case RC_OPCODE_NOP:
 
139
                /* fall through */
 
140
        case RC_OPCODE_MAD: return R300_ALU_OUTA_MAD;
 
141
        case RC_OPCODE_MAX: return R300_ALU_OUTA_MAX;
 
142
        case RC_OPCODE_MIN: return R300_ALU_OUTA_MIN;
 
143
        case RC_OPCODE_RCP: return R300_ALU_OUTA_RCP;
 
144
        case RC_OPCODE_RSQ: return R300_ALU_OUTA_RSQ;
 
145
        }
 
146
}
 
147
 
 
148
/**
 
149
 * Emit one paired ALU instruction.
 
150
 */
 
151
static int emit_alu(struct r300_emit_state * emit, struct rc_pair_instruction* inst)
 
152
{
 
153
        int ip;
 
154
        int j;
 
155
        PROG_CODE;
 
156
 
 
157
        if (code->alu.length >= c->Base.max_alu_insts) {
 
158
                error("Too many ALU instructions");
 
159
                return 0;
 
160
        }
 
161
 
 
162
        ip = code->alu.length++;
 
163
 
 
164
        code->alu.inst[ip].rgb_inst = translate_rgb_opcode(c, inst->RGB.Opcode);
 
165
        code->alu.inst[ip].alpha_inst = translate_alpha_opcode(c, inst->Alpha.Opcode);
 
166
 
 
167
        for(j = 0; j < 3; ++j) {
 
168
                /* Set the RGB address */
 
169
                unsigned int src = use_source(code, inst->RGB.Src[j]);
 
170
                unsigned int arg;
 
171
                if (inst->RGB.Src[j].Index >= R300_PFS_NUM_TEMP_REGS)
 
172
                        code->alu.inst[ip].r400_ext_addr |= R400_ADDR_EXT_RGB_MSB_BIT(j);
 
173
 
 
174
                code->alu.inst[ip].rgb_addr |= src << (6*j);
 
175
 
 
176
                /* Set the Alpha address */
 
177
                src = use_source(code, inst->Alpha.Src[j]);
 
178
                if (inst->Alpha.Src[j].Index >= R300_PFS_NUM_TEMP_REGS)
 
179
                        code->alu.inst[ip].r400_ext_addr |= R400_ADDR_EXT_A_MSB_BIT(j);
 
180
 
 
181
                code->alu.inst[ip].alpha_addr |= src << (6*j);
 
182
 
 
183
                arg = r300FPTranslateRGBSwizzle(inst->RGB.Arg[j].Source, inst->RGB.Arg[j].Swizzle);
 
184
                arg |= inst->RGB.Arg[j].Abs << 6;
 
185
                arg |= inst->RGB.Arg[j].Negate << 5;
 
186
                code->alu.inst[ip].rgb_inst |= arg << (7*j);
 
187
 
 
188
                arg = r300FPTranslateAlphaSwizzle(inst->Alpha.Arg[j].Source, inst->Alpha.Arg[j].Swizzle);
 
189
                arg |= inst->Alpha.Arg[j].Abs << 6;
 
190
                arg |= inst->Alpha.Arg[j].Negate << 5;
 
191
                code->alu.inst[ip].alpha_inst |= arg << (7*j);
 
192
        }
 
193
 
 
194
        /* Presubtract */
 
195
        if (inst->RGB.Src[RC_PAIR_PRESUB_SRC].Used) {
 
196
                switch(inst->RGB.Src[RC_PAIR_PRESUB_SRC].Index) {
 
197
                case RC_PRESUB_BIAS:
 
198
                        code->alu.inst[ip].rgb_inst |=
 
199
                                                R300_ALU_SRCP_1_MINUS_2_SRC0;
 
200
                        break;
 
201
                case RC_PRESUB_ADD:
 
202
                        code->alu.inst[ip].rgb_inst |=
 
203
                                                R300_ALU_SRCP_SRC1_PLUS_SRC0;
 
204
                        break;
 
205
                case RC_PRESUB_SUB:
 
206
                        code->alu.inst[ip].rgb_inst |=
 
207
                                                R300_ALU_SRCP_SRC1_MINUS_SRC0;
 
208
                        break;
 
209
                case RC_PRESUB_INV:
 
210
                        code->alu.inst[ip].rgb_inst |=
 
211
                                                R300_ALU_SRCP_1_MINUS_SRC0;
 
212
                        break;
 
213
                default:
 
214
                        break;
 
215
                }
 
216
        }
 
217
 
 
218
        if (inst->Alpha.Src[RC_PAIR_PRESUB_SRC].Used) {
 
219
                switch(inst->Alpha.Src[RC_PAIR_PRESUB_SRC].Index) {
 
220
                case RC_PRESUB_BIAS:
 
221
                        code->alu.inst[ip].alpha_inst |=
 
222
                                                R300_ALU_SRCP_1_MINUS_2_SRC0;
 
223
                        break;
 
224
                case RC_PRESUB_ADD:
 
225
                        code->alu.inst[ip].alpha_inst |=
 
226
                                                R300_ALU_SRCP_SRC1_PLUS_SRC0;
 
227
                        break;
 
228
                case RC_PRESUB_SUB:
 
229
                        code->alu.inst[ip].alpha_inst |=
 
230
                                                R300_ALU_SRCP_SRC1_MINUS_SRC0;
 
231
                        break;
 
232
                case RC_PRESUB_INV:
 
233
                        code->alu.inst[ip].alpha_inst |=
 
234
                                                R300_ALU_SRCP_1_MINUS_SRC0;
 
235
                        break;
 
236
                default:
 
237
                        break;
 
238
                }
 
239
        }
 
240
 
 
241
        if (inst->RGB.Saturate)
 
242
                code->alu.inst[ip].rgb_inst |= R300_ALU_OUTC_CLAMP;
 
243
        if (inst->Alpha.Saturate)
 
244
                code->alu.inst[ip].alpha_inst |= R300_ALU_OUTA_CLAMP;
 
245
 
 
246
        if (inst->RGB.WriteMask) {
 
247
                use_temporary(code, inst->RGB.DestIndex);
 
248
                if (inst->RGB.DestIndex >= R300_PFS_NUM_TEMP_REGS)
 
249
                        code->alu.inst[ip].r400_ext_addr |= R400_ADDRD_EXT_RGB_MSB_BIT;
 
250
                code->alu.inst[ip].rgb_addr |=
 
251
                        ((inst->RGB.DestIndex & 0x1f) << R300_ALU_DSTC_SHIFT) |
 
252
                        (inst->RGB.WriteMask << R300_ALU_DSTC_REG_MASK_SHIFT);
 
253
        }
 
254
        if (inst->RGB.OutputWriteMask) {
 
255
                code->alu.inst[ip].rgb_addr |=
 
256
            (inst->RGB.OutputWriteMask << R300_ALU_DSTC_OUTPUT_MASK_SHIFT) |
 
257
            R300_RGB_TARGET(inst->RGB.Target);
 
258
                emit->node_flags |= R300_RGBA_OUT;
 
259
        }
 
260
 
 
261
        if (inst->Alpha.WriteMask) {
 
262
                use_temporary(code, inst->Alpha.DestIndex);
 
263
                if (inst->Alpha.DestIndex >= R300_PFS_NUM_TEMP_REGS)
 
264
                        code->alu.inst[ip].r400_ext_addr |= R400_ADDRD_EXT_A_MSB_BIT;
 
265
                code->alu.inst[ip].alpha_addr |=
 
266
                        ((inst->Alpha.DestIndex & 0x1f) << R300_ALU_DSTA_SHIFT) |
 
267
                        R300_ALU_DSTA_REG;
 
268
        }
 
269
        if (inst->Alpha.OutputWriteMask) {
 
270
                code->alu.inst[ip].alpha_addr |= R300_ALU_DSTA_OUTPUT |
 
271
            R300_ALPHA_TARGET(inst->Alpha.Target);
 
272
                emit->node_flags |= R300_RGBA_OUT;
 
273
        }
 
274
        if (inst->Alpha.DepthWriteMask) {
 
275
                code->alu.inst[ip].alpha_addr |= R300_ALU_DSTA_DEPTH;
 
276
                emit->node_flags |= R300_W_OUT;
 
277
                c->code->writes_depth = 1;
 
278
        }
 
279
        if (inst->Nop)
 
280
                code->alu.inst[ip].rgb_inst |= R300_ALU_INSERT_NOP;
 
281
 
 
282
        /* Handle Output Modifier
 
283
         * According to the r300 docs, there is no RC_OMOD_DISABLE for r300 */
 
284
        if (inst->RGB.Omod) {
 
285
                if (inst->RGB.Omod == RC_OMOD_DISABLE) {
 
286
                        rc_error(&c->Base, "RC_OMOD_DISABLE not supported");
 
287
                }
 
288
                code->alu.inst[ip].rgb_inst |=
 
289
                        (inst->RGB.Omod << R300_ALU_OUTC_MOD_SHIFT);
 
290
        }
 
291
        if (inst->Alpha.Omod) {
 
292
                if (inst->Alpha.Omod == RC_OMOD_DISABLE) {
 
293
                        rc_error(&c->Base, "RC_OMOD_DISABLE not supported");
 
294
                }
 
295
                code->alu.inst[ip].alpha_inst |=
 
296
                        (inst->Alpha.Omod << R300_ALU_OUTC_MOD_SHIFT);
 
297
        }
 
298
        return 1;
 
299
}
 
300
 
 
301
 
 
302
/**
 
303
 * Finish the current node without advancing to the next one.
 
304
 */
 
305
static int finish_node(struct r300_emit_state * emit)
 
306
{
 
307
        struct r300_fragment_program_compiler * c = emit->compiler;
 
308
        struct r300_fragment_program_code *code = &emit->compiler->code->code.r300;
 
309
        unsigned alu_offset;
 
310
        unsigned alu_end;
 
311
        unsigned tex_offset;
 
312
        unsigned tex_end;
 
313
 
 
314
        unsigned int alu_offset_msbs, alu_end_msbs;
 
315
 
 
316
        if (code->alu.length == emit->node_first_alu) {
 
317
                /* Generate a single NOP for this node */
 
318
                struct rc_pair_instruction inst;
 
319
                memset(&inst, 0, sizeof(inst));
 
320
                if (!emit_alu(emit, &inst))
 
321
                        return 0;
 
322
        }
 
323
 
 
324
        alu_offset = emit->node_first_alu;
 
325
        alu_end = code->alu.length - alu_offset - 1;
 
326
        tex_offset = emit->node_first_tex;
 
327
        tex_end = code->tex.length - tex_offset - 1;
 
328
 
 
329
        if (code->tex.length == emit->node_first_tex) {
 
330
                if (emit->current_node > 0) {
 
331
                        error("Node %i has no TEX instructions", emit->current_node);
 
332
                        return 0;
 
333
                }
 
334
 
 
335
                tex_end = 0;
 
336
        } else {
 
337
                if (emit->current_node == 0)
 
338
                        code->config |= R300_PFS_CNTL_FIRST_NODE_HAS_TEX;
 
339
        }
 
340
 
 
341
        /* Write the config register.
 
342
         * Note: The order in which the words for each node are written
 
343
         * is not correct here and needs to be fixed up once we're entirely
 
344
         * done
 
345
         *
 
346
         * Also note that the register specification from AMD is slightly
 
347
         * incorrect in its description of this register. */
 
348
        code->code_addr[emit->current_node]  =
 
349
                        ((alu_offset << R300_ALU_START_SHIFT)
 
350
                                & R300_ALU_START_MASK)
 
351
                        | ((alu_end << R300_ALU_SIZE_SHIFT)
 
352
                                & R300_ALU_SIZE_MASK)
 
353
                        | ((tex_offset << R300_TEX_START_SHIFT)
 
354
                                & R300_TEX_START_MASK)
 
355
                        | ((tex_end << R300_TEX_SIZE_SHIFT)
 
356
                                & R300_TEX_SIZE_MASK)
 
357
                        | emit->node_flags
 
358
                        | (get_msbs_tex(tex_offset, 5)
 
359
                                << R400_TEX_START_MSB_SHIFT)
 
360
                        | (get_msbs_tex(tex_end, 5)
 
361
                                << R400_TEX_SIZE_MSB_SHIFT)
 
362
                        ;
 
363
 
 
364
        /* Write r400 extended instruction fields.  These will be ignored on
 
365
         * r300 cards.  */
 
366
        alu_offset_msbs = get_msbs_alu(alu_offset);
 
367
        alu_end_msbs = get_msbs_alu(alu_end);
 
368
        switch(emit->current_node) {
 
369
        case 0:
 
370
                code->r400_code_offset_ext |=
 
371
                        alu_offset_msbs << R400_ALU_START3_MSB_SHIFT
 
372
                        | alu_end_msbs << R400_ALU_SIZE3_MSB_SHIFT;
 
373
                break;
 
374
        case 1:
 
375
                code->r400_code_offset_ext |=
 
376
                        alu_offset_msbs << R400_ALU_START2_MSB_SHIFT
 
377
                        | alu_end_msbs << R400_ALU_SIZE2_MSB_SHIFT;
 
378
                break;
 
379
        case 2:
 
380
                code->r400_code_offset_ext |=
 
381
                        alu_offset_msbs << R400_ALU_START1_MSB_SHIFT
 
382
                        | alu_end_msbs << R400_ALU_SIZE1_MSB_SHIFT;
 
383
                break;
 
384
        case 3:
 
385
                code->r400_code_offset_ext |=
 
386
                        alu_offset_msbs << R400_ALU_START0_MSB_SHIFT
 
387
                        | alu_end_msbs << R400_ALU_SIZE0_MSB_SHIFT;
 
388
                break;
 
389
        }
 
390
        return 1;
 
391
}
 
392
 
 
393
 
 
394
/**
 
395
 * Begin a block of texture instructions.
 
396
 * Create the necessary indirection.
 
397
 */
 
398
static int begin_tex(struct r300_emit_state * emit)
 
399
{
 
400
        PROG_CODE;
 
401
 
 
402
        if (code->alu.length == emit->node_first_alu &&
 
403
            code->tex.length == emit->node_first_tex) {
 
404
                return 1;
 
405
        }
 
406
 
 
407
        if (emit->current_node == 3) {
 
408
                error("Too many texture indirections");
 
409
                return 0;
 
410
        }
 
411
 
 
412
        if (!finish_node(emit))
 
413
                return 0;
 
414
 
 
415
        emit->current_node++;
 
416
        emit->node_first_tex = code->tex.length;
 
417
        emit->node_first_alu = code->alu.length;
 
418
        emit->node_flags = 0;
 
419
        return 1;
 
420
}
 
421
 
 
422
 
 
423
static int emit_tex(struct r300_emit_state * emit, struct rc_instruction * inst)
 
424
{
 
425
        unsigned int unit;
 
426
        unsigned int dest;
 
427
        unsigned int opcode;
 
428
        PROG_CODE;
 
429
 
 
430
        if (code->tex.length >= emit->compiler->Base.max_tex_insts) {
 
431
                error("Too many TEX instructions");
 
432
                return 0;
 
433
        }
 
434
 
 
435
        unit = inst->U.I.TexSrcUnit;
 
436
        dest = inst->U.I.DstReg.Index;
 
437
 
 
438
        switch(inst->U.I.Opcode) {
 
439
        case RC_OPCODE_KIL: opcode = R300_TEX_OP_KIL; break;
 
440
        case RC_OPCODE_TEX: opcode = R300_TEX_OP_LD; break;
 
441
        case RC_OPCODE_TXB: opcode = R300_TEX_OP_TXB; break;
 
442
        case RC_OPCODE_TXP: opcode = R300_TEX_OP_TXP; break;
 
443
        default:
 
444
                error("Unknown texture opcode %s", rc_get_opcode_info(inst->U.I.Opcode)->Name);
 
445
                return 0;
 
446
        }
 
447
 
 
448
        if (inst->U.I.Opcode == RC_OPCODE_KIL) {
 
449
                unit = 0;
 
450
                dest = 0;
 
451
        } else {
 
452
                use_temporary(code, dest);
 
453
        }
 
454
 
 
455
        use_temporary(code, inst->U.I.SrcReg[0].Index);
 
456
 
 
457
        code->tex.inst[code->tex.length++] =
 
458
                ((inst->U.I.SrcReg[0].Index << R300_SRC_ADDR_SHIFT)
 
459
                        & R300_SRC_ADDR_MASK)
 
460
                | ((dest << R300_DST_ADDR_SHIFT)
 
461
                        & R300_DST_ADDR_MASK)
 
462
                | (unit << R300_TEX_ID_SHIFT)
 
463
                | (opcode << R300_TEX_INST_SHIFT)
 
464
                | (inst->U.I.SrcReg[0].Index >= R300_PFS_NUM_TEMP_REGS ?
 
465
                        R400_SRC_ADDR_EXT_BIT : 0)
 
466
                | (dest >= R300_PFS_NUM_TEMP_REGS ?
 
467
                        R400_DST_ADDR_EXT_BIT : 0)
 
468
                ;
 
469
        return 1;
 
470
}
 
471
 
 
472
 
 
473
/**
 
474
 * Final compilation step: Turn the intermediate radeon_program into
 
475
 * machine-readable instructions.
 
476
 */
 
477
void r300BuildFragmentProgramHwCode(struct radeon_compiler *c, void *user)
 
478
{
 
479
        struct r300_fragment_program_compiler *compiler = (struct r300_fragment_program_compiler*)c;
 
480
        struct r300_emit_state emit;
 
481
        struct r300_fragment_program_code *code = &compiler->code->code.r300;
 
482
        unsigned int tex_end;
 
483
 
 
484
        memset(&emit, 0, sizeof(emit));
 
485
        emit.compiler = compiler;
 
486
 
 
487
        memset(code, 0, sizeof(struct r300_fragment_program_code));
 
488
 
 
489
        for(struct rc_instruction * inst = compiler->Base.Program.Instructions.Next;
 
490
            inst != &compiler->Base.Program.Instructions && !compiler->Base.Error;
 
491
            inst = inst->Next) {
 
492
                if (inst->Type == RC_INSTRUCTION_NORMAL) {
 
493
                        if (inst->U.I.Opcode == RC_OPCODE_BEGIN_TEX) {
 
494
                                begin_tex(&emit);
 
495
                                continue;
 
496
                        }
 
497
 
 
498
                        emit_tex(&emit, inst);
 
499
                } else {
 
500
                        emit_alu(&emit, &inst->U.P);
 
501
                }
 
502
        }
 
503
 
 
504
        if (code->pixsize >= compiler->Base.max_temp_regs)
 
505
                rc_error(&compiler->Base, "Too many hardware temporaries used.\n");
 
506
 
 
507
        if (compiler->Base.Error)
 
508
                return;
 
509
 
 
510
        /* Finish the program */
 
511
        finish_node(&emit);
 
512
 
 
513
        code->config |= emit.current_node; /* FIRST_NODE_HAS_TEX set by finish_node */
 
514
 
 
515
        /* Set r400 extended instruction fields.  These values will be ignored
 
516
         * on r300 cards. */
 
517
        code->r400_code_offset_ext |=
 
518
                (get_msbs_alu(0)
 
519
                                << R400_ALU_OFFSET_MSB_SHIFT)
 
520
                | (get_msbs_alu(code->alu.length - 1)
 
521
                                << R400_ALU_SIZE_MSB_SHIFT);
 
522
 
 
523
        tex_end = code->tex.length ? code->tex.length - 1 : 0;
 
524
        code->code_offset =
 
525
                ((0 << R300_PFS_CNTL_ALU_OFFSET_SHIFT)
 
526
                        & R300_PFS_CNTL_ALU_OFFSET_MASK)
 
527
                | (((code->alu.length - 1) << R300_PFS_CNTL_ALU_END_SHIFT)
 
528
                        & R300_PFS_CNTL_ALU_END_MASK)
 
529
                | ((0 << R300_PFS_CNTL_TEX_OFFSET_SHIFT)
 
530
                        & R300_PFS_CNTL_TEX_OFFSET_MASK)
 
531
                | ((tex_end << R300_PFS_CNTL_TEX_END_SHIFT)
 
532
                        & R300_PFS_CNTL_TEX_END_MASK)
 
533
                | (get_msbs_tex(0, 5) << R400_TEX_START_MSB_SHIFT)
 
534
                | (get_msbs_tex(tex_end, 6) << R400_TEX_SIZE_MSB_SHIFT)
 
535
                ;
 
536
 
 
537
        if (emit.current_node < 3) {
 
538
                int shift = 3 - emit.current_node;
 
539
                int i;
 
540
                for(i = emit.current_node; i >= 0; --i)
 
541
                        code->code_addr[shift + i] = code->code_addr[i];
 
542
                for(i = 0; i < shift; ++i)
 
543
                        code->code_addr[i] = 0;
 
544
        }
 
545
 
 
546
        if (code->pixsize >= R300_PFS_NUM_TEMP_REGS
 
547
            || code->alu.length > R300_PFS_MAX_ALU_INST
 
548
            || code->tex.length > R300_PFS_MAX_TEX_INST) {
 
549
 
 
550
                code->r390_mode = 1;
 
551
        }
 
552
}