gallivm: Add a lp_build_const_func_pointer() helper.
[mesa.git] / src / mesa / state_tracker / st_glsl_to_tgsi.cpp
1 /*
2 * Copyright (C) 2005-2007 Brian Paul All Rights Reserved.
3 * Copyright (C) 2008 VMware, Inc. All Rights Reserved.
4 * Copyright © 2010 Intel Corporation
5 * Copyright © 2011 Bryan Cain
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
16 * Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
24 * DEALINGS IN THE SOFTWARE.
25 */
26
27 /**
28 * \file glsl_to_tgsi.cpp
29 *
30 * Translate GLSL IR to TGSI.
31 */
32
33 #include <stdio.h>
34 #include "main/compiler.h"
35 #include "ir.h"
36 #include "ir_visitor.h"
37 #include "ir_print_visitor.h"
38 #include "ir_expression_flattening.h"
39 #include "glsl_types.h"
40 #include "glsl_parser_extras.h"
41 #include "../glsl/program.h"
42 #include "ir_optimization.h"
43 #include "ast.h"
44
45 #include "main/mtypes.h"
46 #include "main/shaderobj.h"
47 #include "program/hash_table.h"
48
49 extern "C" {
50 #include "main/shaderapi.h"
51 #include "main/uniforms.h"
52 #include "program/prog_instruction.h"
53 #include "program/prog_optimize.h"
54 #include "program/prog_print.h"
55 #include "program/program.h"
56 #include "program/prog_parameter.h"
57 #include "program/sampler.h"
58
59 #include "pipe/p_compiler.h"
60 #include "pipe/p_context.h"
61 #include "pipe/p_screen.h"
62 #include "pipe/p_shader_tokens.h"
63 #include "pipe/p_state.h"
64 #include "util/u_math.h"
65 #include "tgsi/tgsi_ureg.h"
66 #include "tgsi/tgsi_info.h"
67 #include "st_context.h"
68 #include "st_program.h"
69 #include "st_glsl_to_tgsi.h"
70 #include "st_mesa_to_tgsi.h"
71 }
72
73 #define PROGRAM_IMMEDIATE PROGRAM_FILE_MAX
74 #define PROGRAM_ANY_CONST ((1 << PROGRAM_LOCAL_PARAM) | \
75 (1 << PROGRAM_ENV_PARAM) | \
76 (1 << PROGRAM_STATE_VAR) | \
77 (1 << PROGRAM_NAMED_PARAM) | \
78 (1 << PROGRAM_CONSTANT) | \
79 (1 << PROGRAM_UNIFORM))
80
81 /**
82 * Maximum number of temporary registers.
83 *
84 * It is too big for stack allocated arrays -- it will cause stack overflow on
85 * Windows and likely Mac OS X.
86 */
87 #define MAX_TEMPS 4096
88
89 /* will be 4 for GLSL 4.00 */
90 #define MAX_GLSL_TEXTURE_OFFSET 1
91
92 class st_src_reg;
93 class st_dst_reg;
94
95 static int swizzle_for_size(int size);
96
97 /**
98 * This struct is a corresponding struct to TGSI ureg_src.
99 */
100 class st_src_reg {
101 public:
102 st_src_reg(gl_register_file file, int index, const glsl_type *type)
103 {
104 this->file = file;
105 this->index = index;
106 if (type && (type->is_scalar() || type->is_vector() || type->is_matrix()))
107 this->swizzle = swizzle_for_size(type->vector_elements);
108 else
109 this->swizzle = SWIZZLE_XYZW;
110 this->negate = 0;
111 this->type = type ? type->base_type : GLSL_TYPE_ERROR;
112 this->reladdr = NULL;
113 }
114
115 st_src_reg(gl_register_file file, int index, int type)
116 {
117 this->type = type;
118 this->file = file;
119 this->index = index;
120 this->swizzle = SWIZZLE_XYZW;
121 this->negate = 0;
122 this->reladdr = NULL;
123 }
124
125 st_src_reg()
126 {
127 this->type = GLSL_TYPE_ERROR;
128 this->file = PROGRAM_UNDEFINED;
129 this->index = 0;
130 this->swizzle = 0;
131 this->negate = 0;
132 this->reladdr = NULL;
133 }
134
135 explicit st_src_reg(st_dst_reg reg);
136
137 gl_register_file file; /**< PROGRAM_* from Mesa */
138 int index; /**< temporary index, VERT_ATTRIB_*, FRAG_ATTRIB_*, etc. */
139 GLuint swizzle; /**< SWIZZLE_XYZWONEZERO swizzles from Mesa. */
140 int negate; /**< NEGATE_XYZW mask from mesa */
141 int type; /** GLSL_TYPE_* from GLSL IR (enum glsl_base_type) */
142 /** Register index should be offset by the integer in this reg. */
143 st_src_reg *reladdr;
144 };
145
146 class st_dst_reg {
147 public:
148 st_dst_reg(gl_register_file file, int writemask, int type)
149 {
150 this->file = file;
151 this->index = 0;
152 this->writemask = writemask;
153 this->cond_mask = COND_TR;
154 this->reladdr = NULL;
155 this->type = type;
156 }
157
158 st_dst_reg()
159 {
160 this->type = GLSL_TYPE_ERROR;
161 this->file = PROGRAM_UNDEFINED;
162 this->index = 0;
163 this->writemask = 0;
164 this->cond_mask = COND_TR;
165 this->reladdr = NULL;
166 }
167
168 explicit st_dst_reg(st_src_reg reg);
169
170 gl_register_file file; /**< PROGRAM_* from Mesa */
171 int index; /**< temporary index, VERT_ATTRIB_*, FRAG_ATTRIB_*, etc. */
172 int writemask; /**< Bitfield of WRITEMASK_[XYZW] */
173 GLuint cond_mask:4;
174 int type; /** GLSL_TYPE_* from GLSL IR (enum glsl_base_type) */
175 /** Register index should be offset by the integer in this reg. */
176 st_src_reg *reladdr;
177 };
178
179 st_src_reg::st_src_reg(st_dst_reg reg)
180 {
181 this->type = reg.type;
182 this->file = reg.file;
183 this->index = reg.index;
184 this->swizzle = SWIZZLE_XYZW;
185 this->negate = 0;
186 this->reladdr = reg.reladdr;
187 }
188
189 st_dst_reg::st_dst_reg(st_src_reg reg)
190 {
191 this->type = reg.type;
192 this->file = reg.file;
193 this->index = reg.index;
194 this->writemask = WRITEMASK_XYZW;
195 this->cond_mask = COND_TR;
196 this->reladdr = reg.reladdr;
197 }
198
199 class glsl_to_tgsi_instruction : public exec_node {
200 public:
201 /* Callers of this ralloc-based new need not call delete. It's
202 * easier to just ralloc_free 'ctx' (or any of its ancestors). */
203 static void* operator new(size_t size, void *ctx)
204 {
205 void *node;
206
207 node = rzalloc_size(ctx, size);
208 assert(node != NULL);
209
210 return node;
211 }
212
213 unsigned op;
214 st_dst_reg dst;
215 st_src_reg src[3];
216 /** Pointer to the ir source this tree came from for debugging */
217 ir_instruction *ir;
218 GLboolean cond_update;
219 bool saturate;
220 int sampler; /**< sampler index */
221 int tex_target; /**< One of TEXTURE_*_INDEX */
222 GLboolean tex_shadow;
223 struct tgsi_texture_offset tex_offsets[MAX_GLSL_TEXTURE_OFFSET];
224 unsigned tex_offset_num_offset;
225 int dead_mask; /**< Used in dead code elimination */
226
227 class function_entry *function; /* Set on TGSI_OPCODE_CAL or TGSI_OPCODE_BGNSUB */
228 };
229
230 class variable_storage : public exec_node {
231 public:
232 variable_storage(ir_variable *var, gl_register_file file, int index)
233 : file(file), index(index), var(var)
234 {
235 /* empty */
236 }
237
238 gl_register_file file;
239 int index;
240 ir_variable *var; /* variable that maps to this, if any */
241 };
242
243 class immediate_storage : public exec_node {
244 public:
245 immediate_storage(gl_constant_value *values, int size, int type)
246 {
247 memcpy(this->values, values, size * sizeof(gl_constant_value));
248 this->size = size;
249 this->type = type;
250 }
251
252 gl_constant_value values[4];
253 int size; /**< Number of components (1-4) */
254 int type; /**< GL_FLOAT, GL_INT, GL_BOOL, or GL_UNSIGNED_INT */
255 };
256
257 class function_entry : public exec_node {
258 public:
259 ir_function_signature *sig;
260
261 /**
262 * identifier of this function signature used by the program.
263 *
264 * At the point that TGSI instructions for function calls are
265 * generated, we don't know the address of the first instruction of
266 * the function body. So we make the BranchTarget that is called a
267 * small integer and rewrite them during set_branchtargets().
268 */
269 int sig_id;
270
271 /**
272 * Pointer to first instruction of the function body.
273 *
274 * Set during function body emits after main() is processed.
275 */
276 glsl_to_tgsi_instruction *bgn_inst;
277
278 /**
279 * Index of the first instruction of the function body in actual TGSI.
280 *
281 * Set after conversion from glsl_to_tgsi_instruction to TGSI.
282 */
283 int inst;
284
285 /** Storage for the return value. */
286 st_src_reg return_reg;
287 };
288
289 class glsl_to_tgsi_visitor : public ir_visitor {
290 public:
291 glsl_to_tgsi_visitor();
292 ~glsl_to_tgsi_visitor();
293
294 function_entry *current_function;
295
296 struct gl_context *ctx;
297 struct gl_program *prog;
298 struct gl_shader_program *shader_program;
299 struct gl_shader_compiler_options *options;
300
301 int next_temp;
302
303 int num_address_regs;
304 int samplers_used;
305 bool indirect_addr_temps;
306 bool indirect_addr_consts;
307 int num_clip_distances;
308
309 int glsl_version;
310 bool native_integers;
311
312 variable_storage *find_variable_storage(ir_variable *var);
313
314 int add_constant(gl_register_file file, gl_constant_value values[4],
315 int size, int datatype, GLuint *swizzle_out);
316
317 function_entry *get_function_signature(ir_function_signature *sig);
318
319 st_src_reg get_temp(const glsl_type *type);
320 void reladdr_to_temp(ir_instruction *ir, st_src_reg *reg, int *num_reladdr);
321
322 st_src_reg st_src_reg_for_float(float val);
323 st_src_reg st_src_reg_for_int(int val);
324 st_src_reg st_src_reg_for_type(int type, int val);
325
326 /**
327 * \name Visit methods
328 *
329 * As typical for the visitor pattern, there must be one \c visit method for
330 * each concrete subclass of \c ir_instruction. Virtual base classes within
331 * the hierarchy should not have \c visit methods.
332 */
333 /*@{*/
334 virtual void visit(ir_variable *);
335 virtual void visit(ir_loop *);
336 virtual void visit(ir_loop_jump *);
337 virtual void visit(ir_function_signature *);
338 virtual void visit(ir_function *);
339 virtual void visit(ir_expression *);
340 virtual void visit(ir_swizzle *);
341 virtual void visit(ir_dereference_variable *);
342 virtual void visit(ir_dereference_array *);
343 virtual void visit(ir_dereference_record *);
344 virtual void visit(ir_assignment *);
345 virtual void visit(ir_constant *);
346 virtual void visit(ir_call *);
347 virtual void visit(ir_return *);
348 virtual void visit(ir_discard *);
349 virtual void visit(ir_texture *);
350 virtual void visit(ir_if *);
351 /*@}*/
352
353 st_src_reg result;
354
355 /** List of variable_storage */
356 exec_list variables;
357
358 /** List of immediate_storage */
359 exec_list immediates;
360 unsigned num_immediates;
361
362 /** List of function_entry */
363 exec_list function_signatures;
364 int next_signature_id;
365
366 /** List of glsl_to_tgsi_instruction */
367 exec_list instructions;
368
369 glsl_to_tgsi_instruction *emit(ir_instruction *ir, unsigned op);
370
371 glsl_to_tgsi_instruction *emit(ir_instruction *ir, unsigned op,
372 st_dst_reg dst, st_src_reg src0);
373
374 glsl_to_tgsi_instruction *emit(ir_instruction *ir, unsigned op,
375 st_dst_reg dst, st_src_reg src0, st_src_reg src1);
376
377 glsl_to_tgsi_instruction *emit(ir_instruction *ir, unsigned op,
378 st_dst_reg dst,
379 st_src_reg src0, st_src_reg src1, st_src_reg src2);
380
381 unsigned get_opcode(ir_instruction *ir, unsigned op,
382 st_dst_reg dst,
383 st_src_reg src0, st_src_reg src1);
384
385 /**
386 * Emit the correct dot-product instruction for the type of arguments
387 */
388 glsl_to_tgsi_instruction *emit_dp(ir_instruction *ir,
389 st_dst_reg dst,
390 st_src_reg src0,
391 st_src_reg src1,
392 unsigned elements);
393
394 void emit_scalar(ir_instruction *ir, unsigned op,
395 st_dst_reg dst, st_src_reg src0);
396
397 void emit_scalar(ir_instruction *ir, unsigned op,
398 st_dst_reg dst, st_src_reg src0, st_src_reg src1);
399
400 void try_emit_float_set(ir_instruction *ir, unsigned op, st_dst_reg dst);
401
402 void emit_arl(ir_instruction *ir, st_dst_reg dst, st_src_reg src0);
403
404 void emit_scs(ir_instruction *ir, unsigned op,
405 st_dst_reg dst, const st_src_reg &src);
406
407 bool try_emit_mad(ir_expression *ir,
408 int mul_operand);
409 bool try_emit_mad_for_and_not(ir_expression *ir,
410 int mul_operand);
411 bool try_emit_sat(ir_expression *ir);
412
413 void emit_swz(ir_expression *ir);
414
415 bool process_move_condition(ir_rvalue *ir);
416
417 void simplify_cmp(void);
418
419 void rename_temp_register(int index, int new_index);
420 int get_first_temp_read(int index);
421 int get_first_temp_write(int index);
422 int get_last_temp_read(int index);
423 int get_last_temp_write(int index);
424
425 void copy_propagate(void);
426 void eliminate_dead_code(void);
427 int eliminate_dead_code_advanced(void);
428 void merge_registers(void);
429 void renumber_registers(void);
430
431 void *mem_ctx;
432 };
433
434 static st_src_reg undef_src = st_src_reg(PROGRAM_UNDEFINED, 0, GLSL_TYPE_ERROR);
435
436 static st_dst_reg undef_dst = st_dst_reg(PROGRAM_UNDEFINED, SWIZZLE_NOOP, GLSL_TYPE_ERROR);
437
438 static st_dst_reg address_reg = st_dst_reg(PROGRAM_ADDRESS, WRITEMASK_X, GLSL_TYPE_FLOAT);
439
440 static void
441 fail_link(struct gl_shader_program *prog, const char *fmt, ...) PRINTFLIKE(2, 3);
442
443 static void
444 fail_link(struct gl_shader_program *prog, const char *fmt, ...)
445 {
446 va_list args;
447 va_start(args, fmt);
448 ralloc_vasprintf_append(&prog->InfoLog, fmt, args);
449 va_end(args);
450
451 prog->LinkStatus = GL_FALSE;
452 }
453
454 static int
455 swizzle_for_size(int size)
456 {
457 int size_swizzles[4] = {
458 MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_X, SWIZZLE_X, SWIZZLE_X),
459 MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Y, SWIZZLE_Y),
460 MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z),
461 MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_W),
462 };
463
464 assert((size >= 1) && (size <= 4));
465 return size_swizzles[size - 1];
466 }
467
468 static bool
469 is_tex_instruction(unsigned opcode)
470 {
471 const tgsi_opcode_info* info = tgsi_get_opcode_info(opcode);
472 return info->is_tex;
473 }
474
475 static unsigned
476 num_inst_dst_regs(unsigned opcode)
477 {
478 const tgsi_opcode_info* info = tgsi_get_opcode_info(opcode);
479 return info->num_dst;
480 }
481
482 static unsigned
483 num_inst_src_regs(unsigned opcode)
484 {
485 const tgsi_opcode_info* info = tgsi_get_opcode_info(opcode);
486 return info->is_tex ? info->num_src - 1 : info->num_src;
487 }
488
489 glsl_to_tgsi_instruction *
490 glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op,
491 st_dst_reg dst,
492 st_src_reg src0, st_src_reg src1, st_src_reg src2)
493 {
494 glsl_to_tgsi_instruction *inst = new(mem_ctx) glsl_to_tgsi_instruction();
495 int num_reladdr = 0, i;
496
497 op = get_opcode(ir, op, dst, src0, src1);
498
499 /* If we have to do relative addressing, we want to load the ARL
500 * reg directly for one of the regs, and preload the other reladdr
501 * sources into temps.
502 */
503 num_reladdr += dst.reladdr != NULL;
504 num_reladdr += src0.reladdr != NULL;
505 num_reladdr += src1.reladdr != NULL;
506 num_reladdr += src2.reladdr != NULL;
507
508 reladdr_to_temp(ir, &src2, &num_reladdr);
509 reladdr_to_temp(ir, &src1, &num_reladdr);
510 reladdr_to_temp(ir, &src0, &num_reladdr);
511
512 if (dst.reladdr) {
513 emit_arl(ir, address_reg, *dst.reladdr);
514 num_reladdr--;
515 }
516 assert(num_reladdr == 0);
517
518 inst->op = op;
519 inst->dst = dst;
520 inst->src[0] = src0;
521 inst->src[1] = src1;
522 inst->src[2] = src2;
523 inst->ir = ir;
524 inst->dead_mask = 0;
525
526 inst->function = NULL;
527
528 if (op == TGSI_OPCODE_ARL || op == TGSI_OPCODE_UARL)
529 this->num_address_regs = 1;
530
531 /* Update indirect addressing status used by TGSI */
532 if (dst.reladdr) {
533 switch(dst.file) {
534 case PROGRAM_TEMPORARY:
535 this->indirect_addr_temps = true;
536 break;
537 case PROGRAM_LOCAL_PARAM:
538 case PROGRAM_ENV_PARAM:
539 case PROGRAM_STATE_VAR:
540 case PROGRAM_NAMED_PARAM:
541 case PROGRAM_CONSTANT:
542 case PROGRAM_UNIFORM:
543 this->indirect_addr_consts = true;
544 break;
545 case PROGRAM_IMMEDIATE:
546 assert(!"immediates should not have indirect addressing");
547 break;
548 default:
549 break;
550 }
551 }
552 else {
553 for (i=0; i<3; i++) {
554 if(inst->src[i].reladdr) {
555 switch(inst->src[i].file) {
556 case PROGRAM_TEMPORARY:
557 this->indirect_addr_temps = true;
558 break;
559 case PROGRAM_LOCAL_PARAM:
560 case PROGRAM_ENV_PARAM:
561 case PROGRAM_STATE_VAR:
562 case PROGRAM_NAMED_PARAM:
563 case PROGRAM_CONSTANT:
564 case PROGRAM_UNIFORM:
565 this->indirect_addr_consts = true;
566 break;
567 case PROGRAM_IMMEDIATE:
568 assert(!"immediates should not have indirect addressing");
569 break;
570 default:
571 break;
572 }
573 }
574 }
575 }
576
577 this->instructions.push_tail(inst);
578
579 if (native_integers)
580 try_emit_float_set(ir, op, dst);
581
582 return inst;
583 }
584
585
586 glsl_to_tgsi_instruction *
587 glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op,
588 st_dst_reg dst, st_src_reg src0, st_src_reg src1)
589 {
590 return emit(ir, op, dst, src0, src1, undef_src);
591 }
592
593 glsl_to_tgsi_instruction *
594 glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op,
595 st_dst_reg dst, st_src_reg src0)
596 {
597 assert(dst.writemask != 0);
598 return emit(ir, op, dst, src0, undef_src, undef_src);
599 }
600
601 glsl_to_tgsi_instruction *
602 glsl_to_tgsi_visitor::emit(ir_instruction *ir, unsigned op)
603 {
604 return emit(ir, op, undef_dst, undef_src, undef_src, undef_src);
605 }
606
607 /**
608 * Emits the code to convert the result of float SET instructions to integers.
609 */
610 void
611 glsl_to_tgsi_visitor::try_emit_float_set(ir_instruction *ir, unsigned op,
612 st_dst_reg dst)
613 {
614 if ((op == TGSI_OPCODE_SEQ ||
615 op == TGSI_OPCODE_SNE ||
616 op == TGSI_OPCODE_SGE ||
617 op == TGSI_OPCODE_SLT))
618 {
619 st_src_reg src = st_src_reg(dst);
620 src.negate = ~src.negate;
621 dst.type = GLSL_TYPE_FLOAT;
622 emit(ir, TGSI_OPCODE_F2I, dst, src);
623 }
624 }
625
626 /**
627 * Determines whether to use an integer, unsigned integer, or float opcode
628 * based on the operands and input opcode, then emits the result.
629 */
630 unsigned
631 glsl_to_tgsi_visitor::get_opcode(ir_instruction *ir, unsigned op,
632 st_dst_reg dst,
633 st_src_reg src0, st_src_reg src1)
634 {
635 int type = GLSL_TYPE_FLOAT;
636
637 if (src0.type == GLSL_TYPE_FLOAT || src1.type == GLSL_TYPE_FLOAT)
638 type = GLSL_TYPE_FLOAT;
639 else if (native_integers)
640 type = src0.type == GLSL_TYPE_BOOL ? GLSL_TYPE_INT : src0.type;
641
642 #define case4(c, f, i, u) \
643 case TGSI_OPCODE_##c: \
644 if (type == GLSL_TYPE_INT) op = TGSI_OPCODE_##i; \
645 else if (type == GLSL_TYPE_UINT) op = TGSI_OPCODE_##u; \
646 else op = TGSI_OPCODE_##f; \
647 break;
648 #define case3(f, i, u) case4(f, f, i, u)
649 #define case2fi(f, i) case4(f, f, i, i)
650 #define case2iu(i, u) case4(i, LAST, i, u)
651
652 switch(op) {
653 case2fi(ADD, UADD);
654 case2fi(MUL, UMUL);
655 case2fi(MAD, UMAD);
656 case3(DIV, IDIV, UDIV);
657 case3(MAX, IMAX, UMAX);
658 case3(MIN, IMIN, UMIN);
659 case2iu(MOD, UMOD);
660
661 case2fi(SEQ, USEQ);
662 case2fi(SNE, USNE);
663 case3(SGE, ISGE, USGE);
664 case3(SLT, ISLT, USLT);
665
666 case2iu(ISHR, USHR);
667
668 case2fi(SSG, ISSG);
669 case3(ABS, IABS, IABS);
670
671 default: break;
672 }
673
674 assert(op != TGSI_OPCODE_LAST);
675 return op;
676 }
677
678 glsl_to_tgsi_instruction *
679 glsl_to_tgsi_visitor::emit_dp(ir_instruction *ir,
680 st_dst_reg dst, st_src_reg src0, st_src_reg src1,
681 unsigned elements)
682 {
683 static const unsigned dot_opcodes[] = {
684 TGSI_OPCODE_DP2, TGSI_OPCODE_DP3, TGSI_OPCODE_DP4
685 };
686
687 return emit(ir, dot_opcodes[elements - 2], dst, src0, src1);
688 }
689
690 /**
691 * Emits TGSI scalar opcodes to produce unique answers across channels.
692 *
693 * Some TGSI opcodes are scalar-only, like ARB_fp/vp. The src X
694 * channel determines the result across all channels. So to do a vec4
695 * of this operation, we want to emit a scalar per source channel used
696 * to produce dest channels.
697 */
698 void
699 glsl_to_tgsi_visitor::emit_scalar(ir_instruction *ir, unsigned op,
700 st_dst_reg dst,
701 st_src_reg orig_src0, st_src_reg orig_src1)
702 {
703 int i, j;
704 int done_mask = ~dst.writemask;
705
706 /* TGSI RCP is a scalar operation splatting results to all channels,
707 * like ARB_fp/vp. So emit as many RCPs as necessary to cover our
708 * dst channels.
709 */
710 for (i = 0; i < 4; i++) {
711 GLuint this_mask = (1 << i);
712 glsl_to_tgsi_instruction *inst;
713 st_src_reg src0 = orig_src0;
714 st_src_reg src1 = orig_src1;
715
716 if (done_mask & this_mask)
717 continue;
718
719 GLuint src0_swiz = GET_SWZ(src0.swizzle, i);
720 GLuint src1_swiz = GET_SWZ(src1.swizzle, i);
721 for (j = i + 1; j < 4; j++) {
722 /* If there is another enabled component in the destination that is
723 * derived from the same inputs, generate its value on this pass as
724 * well.
725 */
726 if (!(done_mask & (1 << j)) &&
727 GET_SWZ(src0.swizzle, j) == src0_swiz &&
728 GET_SWZ(src1.swizzle, j) == src1_swiz) {
729 this_mask |= (1 << j);
730 }
731 }
732 src0.swizzle = MAKE_SWIZZLE4(src0_swiz, src0_swiz,
733 src0_swiz, src0_swiz);
734 src1.swizzle = MAKE_SWIZZLE4(src1_swiz, src1_swiz,
735 src1_swiz, src1_swiz);
736
737 inst = emit(ir, op, dst, src0, src1);
738 inst->dst.writemask = this_mask;
739 done_mask |= this_mask;
740 }
741 }
742
743 void
744 glsl_to_tgsi_visitor::emit_scalar(ir_instruction *ir, unsigned op,
745 st_dst_reg dst, st_src_reg src0)
746 {
747 st_src_reg undef = undef_src;
748
749 undef.swizzle = SWIZZLE_XXXX;
750
751 emit_scalar(ir, op, dst, src0, undef);
752 }
753
754 void
755 glsl_to_tgsi_visitor::emit_arl(ir_instruction *ir,
756 st_dst_reg dst, st_src_reg src0)
757 {
758 int op = TGSI_OPCODE_ARL;
759
760 if (src0.type == GLSL_TYPE_INT || src0.type == GLSL_TYPE_UINT)
761 op = TGSI_OPCODE_UARL;
762
763 emit(NULL, op, dst, src0);
764 }
765
766 /**
767 * Emit an TGSI_OPCODE_SCS instruction
768 *
769 * The \c SCS opcode functions a bit differently than the other TGSI opcodes.
770 * Instead of splatting its result across all four components of the
771 * destination, it writes one value to the \c x component and another value to
772 * the \c y component.
773 *
774 * \param ir IR instruction being processed
775 * \param op Either \c TGSI_OPCODE_SIN or \c TGSI_OPCODE_COS depending
776 * on which value is desired.
777 * \param dst Destination register
778 * \param src Source register
779 */
780 void
781 glsl_to_tgsi_visitor::emit_scs(ir_instruction *ir, unsigned op,
782 st_dst_reg dst,
783 const st_src_reg &src)
784 {
785 /* Vertex programs cannot use the SCS opcode.
786 */
787 if (this->prog->Target == GL_VERTEX_PROGRAM_ARB) {
788 emit_scalar(ir, op, dst, src);
789 return;
790 }
791
792 const unsigned component = (op == TGSI_OPCODE_SIN) ? 0 : 1;
793 const unsigned scs_mask = (1U << component);
794 int done_mask = ~dst.writemask;
795 st_src_reg tmp;
796
797 assert(op == TGSI_OPCODE_SIN || op == TGSI_OPCODE_COS);
798
799 /* If there are compnents in the destination that differ from the component
800 * that will be written by the SCS instrution, we'll need a temporary.
801 */
802 if (scs_mask != unsigned(dst.writemask)) {
803 tmp = get_temp(glsl_type::vec4_type);
804 }
805
806 for (unsigned i = 0; i < 4; i++) {
807 unsigned this_mask = (1U << i);
808 st_src_reg src0 = src;
809
810 if ((done_mask & this_mask) != 0)
811 continue;
812
813 /* The source swizzle specified which component of the source generates
814 * sine / cosine for the current component in the destination. The SCS
815 * instruction requires that this value be swizzle to the X component.
816 * Replace the current swizzle with a swizzle that puts the source in
817 * the X component.
818 */
819 unsigned src0_swiz = GET_SWZ(src.swizzle, i);
820
821 src0.swizzle = MAKE_SWIZZLE4(src0_swiz, src0_swiz,
822 src0_swiz, src0_swiz);
823 for (unsigned j = i + 1; j < 4; j++) {
824 /* If there is another enabled component in the destination that is
825 * derived from the same inputs, generate its value on this pass as
826 * well.
827 */
828 if (!(done_mask & (1 << j)) &&
829 GET_SWZ(src0.swizzle, j) == src0_swiz) {
830 this_mask |= (1 << j);
831 }
832 }
833
834 if (this_mask != scs_mask) {
835 glsl_to_tgsi_instruction *inst;
836 st_dst_reg tmp_dst = st_dst_reg(tmp);
837
838 /* Emit the SCS instruction.
839 */
840 inst = emit(ir, TGSI_OPCODE_SCS, tmp_dst, src0);
841 inst->dst.writemask = scs_mask;
842
843 /* Move the result of the SCS instruction to the desired location in
844 * the destination.
845 */
846 tmp.swizzle = MAKE_SWIZZLE4(component, component,
847 component, component);
848 inst = emit(ir, TGSI_OPCODE_SCS, dst, tmp);
849 inst->dst.writemask = this_mask;
850 } else {
851 /* Emit the SCS instruction to write directly to the destination.
852 */
853 glsl_to_tgsi_instruction *inst = emit(ir, TGSI_OPCODE_SCS, dst, src0);
854 inst->dst.writemask = scs_mask;
855 }
856
857 done_mask |= this_mask;
858 }
859 }
860
861 int
862 glsl_to_tgsi_visitor::add_constant(gl_register_file file,
863 gl_constant_value values[4], int size, int datatype,
864 GLuint *swizzle_out)
865 {
866 if (file == PROGRAM_CONSTANT) {
867 return _mesa_add_typed_unnamed_constant(this->prog->Parameters, values,
868 size, datatype, swizzle_out);
869 } else {
870 int index = 0;
871 immediate_storage *entry;
872 assert(file == PROGRAM_IMMEDIATE);
873
874 /* Search immediate storage to see if we already have an identical
875 * immediate that we can use instead of adding a duplicate entry.
876 */
877 foreach_iter(exec_list_iterator, iter, this->immediates) {
878 entry = (immediate_storage *)iter.get();
879
880 if (entry->size == size &&
881 entry->type == datatype &&
882 !memcmp(entry->values, values, size * sizeof(gl_constant_value))) {
883 return index;
884 }
885 index++;
886 }
887
888 /* Add this immediate to the list. */
889 entry = new(mem_ctx) immediate_storage(values, size, datatype);
890 this->immediates.push_tail(entry);
891 this->num_immediates++;
892 return index;
893 }
894 }
895
896 st_src_reg
897 glsl_to_tgsi_visitor::st_src_reg_for_float(float val)
898 {
899 st_src_reg src(PROGRAM_IMMEDIATE, -1, GLSL_TYPE_FLOAT);
900 union gl_constant_value uval;
901
902 uval.f = val;
903 src.index = add_constant(src.file, &uval, 1, GL_FLOAT, &src.swizzle);
904
905 return src;
906 }
907
908 st_src_reg
909 glsl_to_tgsi_visitor::st_src_reg_for_int(int val)
910 {
911 st_src_reg src(PROGRAM_IMMEDIATE, -1, GLSL_TYPE_INT);
912 union gl_constant_value uval;
913
914 assert(native_integers);
915
916 uval.i = val;
917 src.index = add_constant(src.file, &uval, 1, GL_INT, &src.swizzle);
918
919 return src;
920 }
921
922 st_src_reg
923 glsl_to_tgsi_visitor::st_src_reg_for_type(int type, int val)
924 {
925 if (native_integers)
926 return type == GLSL_TYPE_FLOAT ? st_src_reg_for_float(val) :
927 st_src_reg_for_int(val);
928 else
929 return st_src_reg_for_float(val);
930 }
931
932 static int
933 type_size(const struct glsl_type *type)
934 {
935 unsigned int i;
936 int size;
937
938 switch (type->base_type) {
939 case GLSL_TYPE_UINT:
940 case GLSL_TYPE_INT:
941 case GLSL_TYPE_FLOAT:
942 case GLSL_TYPE_BOOL:
943 if (type->is_matrix()) {
944 return type->matrix_columns;
945 } else {
946 /* Regardless of size of vector, it gets a vec4. This is bad
947 * packing for things like floats, but otherwise arrays become a
948 * mess. Hopefully a later pass over the code can pack scalars
949 * down if appropriate.
950 */
951 return 1;
952 }
953 case GLSL_TYPE_ARRAY:
954 assert(type->length > 0);
955 return type_size(type->fields.array) * type->length;
956 case GLSL_TYPE_STRUCT:
957 size = 0;
958 for (i = 0; i < type->length; i++) {
959 size += type_size(type->fields.structure[i].type);
960 }
961 return size;
962 case GLSL_TYPE_SAMPLER:
963 /* Samplers take up one slot in UNIFORMS[], but they're baked in
964 * at link time.
965 */
966 return 1;
967 default:
968 assert(0);
969 return 0;
970 }
971 }
972
973 /**
974 * In the initial pass of codegen, we assign temporary numbers to
975 * intermediate results. (not SSA -- variable assignments will reuse
976 * storage).
977 */
978 st_src_reg
979 glsl_to_tgsi_visitor::get_temp(const glsl_type *type)
980 {
981 st_src_reg src;
982
983 src.type = native_integers ? type->base_type : GLSL_TYPE_FLOAT;
984 src.file = PROGRAM_TEMPORARY;
985 src.index = next_temp;
986 src.reladdr = NULL;
987 next_temp += type_size(type);
988
989 if (type->is_array() || type->is_record()) {
990 src.swizzle = SWIZZLE_NOOP;
991 } else {
992 src.swizzle = swizzle_for_size(type->vector_elements);
993 }
994 src.negate = 0;
995
996 return src;
997 }
998
999 variable_storage *
1000 glsl_to_tgsi_visitor::find_variable_storage(ir_variable *var)
1001 {
1002
1003 variable_storage *entry;
1004
1005 foreach_iter(exec_list_iterator, iter, this->variables) {
1006 entry = (variable_storage *)iter.get();
1007
1008 if (entry->var == var)
1009 return entry;
1010 }
1011
1012 return NULL;
1013 }
1014
1015 void
1016 glsl_to_tgsi_visitor::visit(ir_variable *ir)
1017 {
1018 if (strcmp(ir->name, "gl_FragCoord") == 0) {
1019 struct gl_fragment_program *fp = (struct gl_fragment_program *)this->prog;
1020
1021 fp->OriginUpperLeft = ir->origin_upper_left;
1022 fp->PixelCenterInteger = ir->pixel_center_integer;
1023 }
1024
1025 if (ir->mode == ir_var_uniform && strncmp(ir->name, "gl_", 3) == 0) {
1026 unsigned int i;
1027 const ir_state_slot *const slots = ir->state_slots;
1028 assert(ir->state_slots != NULL);
1029
1030 /* Check if this statevar's setup in the STATE file exactly
1031 * matches how we'll want to reference it as a
1032 * struct/array/whatever. If not, then we need to move it into
1033 * temporary storage and hope that it'll get copy-propagated
1034 * out.
1035 */
1036 for (i = 0; i < ir->num_state_slots; i++) {
1037 if (slots[i].swizzle != SWIZZLE_XYZW) {
1038 break;
1039 }
1040 }
1041
1042 variable_storage *storage;
1043 st_dst_reg dst;
1044 if (i == ir->num_state_slots) {
1045 /* We'll set the index later. */
1046 storage = new(mem_ctx) variable_storage(ir, PROGRAM_STATE_VAR, -1);
1047 this->variables.push_tail(storage);
1048
1049 dst = undef_dst;
1050 } else {
1051 /* The variable_storage constructor allocates slots based on the size
1052 * of the type. However, this had better match the number of state
1053 * elements that we're going to copy into the new temporary.
1054 */
1055 assert((int) ir->num_state_slots == type_size(ir->type));
1056
1057 storage = new(mem_ctx) variable_storage(ir, PROGRAM_TEMPORARY,
1058 this->next_temp);
1059 this->variables.push_tail(storage);
1060 this->next_temp += type_size(ir->type);
1061
1062 dst = st_dst_reg(st_src_reg(PROGRAM_TEMPORARY, storage->index,
1063 native_integers ? ir->type->base_type : GLSL_TYPE_FLOAT));
1064 }
1065
1066
1067 for (unsigned int i = 0; i < ir->num_state_slots; i++) {
1068 int index = _mesa_add_state_reference(this->prog->Parameters,
1069 (gl_state_index *)slots[i].tokens);
1070
1071 if (storage->file == PROGRAM_STATE_VAR) {
1072 if (storage->index == -1) {
1073 storage->index = index;
1074 } else {
1075 assert(index == storage->index + (int)i);
1076 }
1077 } else {
1078 st_src_reg src(PROGRAM_STATE_VAR, index,
1079 native_integers ? ir->type->base_type : GLSL_TYPE_FLOAT);
1080 src.swizzle = slots[i].swizzle;
1081 emit(ir, TGSI_OPCODE_MOV, dst, src);
1082 /* even a float takes up a whole vec4 reg in a struct/array. */
1083 dst.index++;
1084 }
1085 }
1086
1087 if (storage->file == PROGRAM_TEMPORARY &&
1088 dst.index != storage->index + (int) ir->num_state_slots) {
1089 fail_link(this->shader_program,
1090 "failed to load builtin uniform `%s' (%d/%d regs loaded)\n",
1091 ir->name, dst.index - storage->index,
1092 type_size(ir->type));
1093 }
1094 }
1095 }
1096
1097 void
1098 glsl_to_tgsi_visitor::visit(ir_loop *ir)
1099 {
1100 ir_dereference_variable *counter = NULL;
1101
1102 if (ir->counter != NULL)
1103 counter = new(ir) ir_dereference_variable(ir->counter);
1104
1105 if (ir->from != NULL) {
1106 assert(ir->counter != NULL);
1107
1108 ir_assignment *a = new(ir) ir_assignment(counter, ir->from, NULL);
1109
1110 a->accept(this);
1111 delete a;
1112 }
1113
1114 emit(NULL, TGSI_OPCODE_BGNLOOP);
1115
1116 if (ir->to) {
1117 ir_expression *e =
1118 new(ir) ir_expression(ir->cmp, glsl_type::bool_type,
1119 counter, ir->to);
1120 ir_if *if_stmt = new(ir) ir_if(e);
1121
1122 ir_loop_jump *brk = new(ir) ir_loop_jump(ir_loop_jump::jump_break);
1123
1124 if_stmt->then_instructions.push_tail(brk);
1125
1126 if_stmt->accept(this);
1127
1128 delete if_stmt;
1129 delete e;
1130 delete brk;
1131 }
1132
1133 visit_exec_list(&ir->body_instructions, this);
1134
1135 if (ir->increment) {
1136 ir_expression *e =
1137 new(ir) ir_expression(ir_binop_add, counter->type,
1138 counter, ir->increment);
1139
1140 ir_assignment *a = new(ir) ir_assignment(counter, e, NULL);
1141
1142 a->accept(this);
1143 delete a;
1144 delete e;
1145 }
1146
1147 emit(NULL, TGSI_OPCODE_ENDLOOP);
1148 }
1149
1150 void
1151 glsl_to_tgsi_visitor::visit(ir_loop_jump *ir)
1152 {
1153 switch (ir->mode) {
1154 case ir_loop_jump::jump_break:
1155 emit(NULL, TGSI_OPCODE_BRK);
1156 break;
1157 case ir_loop_jump::jump_continue:
1158 emit(NULL, TGSI_OPCODE_CONT);
1159 break;
1160 }
1161 }
1162
1163
1164 void
1165 glsl_to_tgsi_visitor::visit(ir_function_signature *ir)
1166 {
1167 assert(0);
1168 (void)ir;
1169 }
1170
1171 void
1172 glsl_to_tgsi_visitor::visit(ir_function *ir)
1173 {
1174 /* Ignore function bodies other than main() -- we shouldn't see calls to
1175 * them since they should all be inlined before we get to glsl_to_tgsi.
1176 */
1177 if (strcmp(ir->name, "main") == 0) {
1178 const ir_function_signature *sig;
1179 exec_list empty;
1180
1181 sig = ir->matching_signature(&empty);
1182
1183 assert(sig);
1184
1185 foreach_iter(exec_list_iterator, iter, sig->body) {
1186 ir_instruction *ir = (ir_instruction *)iter.get();
1187
1188 ir->accept(this);
1189 }
1190 }
1191 }
1192
1193 bool
1194 glsl_to_tgsi_visitor::try_emit_mad(ir_expression *ir, int mul_operand)
1195 {
1196 int nonmul_operand = 1 - mul_operand;
1197 st_src_reg a, b, c;
1198 st_dst_reg result_dst;
1199
1200 ir_expression *expr = ir->operands[mul_operand]->as_expression();
1201 if (!expr || expr->operation != ir_binop_mul)
1202 return false;
1203
1204 expr->operands[0]->accept(this);
1205 a = this->result;
1206 expr->operands[1]->accept(this);
1207 b = this->result;
1208 ir->operands[nonmul_operand]->accept(this);
1209 c = this->result;
1210
1211 this->result = get_temp(ir->type);
1212 result_dst = st_dst_reg(this->result);
1213 result_dst.writemask = (1 << ir->type->vector_elements) - 1;
1214 emit(ir, TGSI_OPCODE_MAD, result_dst, a, b, c);
1215
1216 return true;
1217 }
1218
1219 /**
1220 * Emit MAD(a, -b, a) instead of AND(a, NOT(b))
1221 *
1222 * The logic values are 1.0 for true and 0.0 for false. Logical-and is
1223 * implemented using multiplication, and logical-or is implemented using
1224 * addition. Logical-not can be implemented as (true - x), or (1.0 - x).
1225 * As result, the logical expression (a & !b) can be rewritten as:
1226 *
1227 * - a * !b
1228 * - a * (1 - b)
1229 * - (a * 1) - (a * b)
1230 * - a + -(a * b)
1231 * - a + (a * -b)
1232 *
1233 * This final expression can be implemented as a single MAD(a, -b, a)
1234 * instruction.
1235 */
1236 bool
1237 glsl_to_tgsi_visitor::try_emit_mad_for_and_not(ir_expression *ir, int try_operand)
1238 {
1239 const int other_operand = 1 - try_operand;
1240 st_src_reg a, b;
1241
1242 ir_expression *expr = ir->operands[try_operand]->as_expression();
1243 if (!expr || expr->operation != ir_unop_logic_not)
1244 return false;
1245
1246 ir->operands[other_operand]->accept(this);
1247 a = this->result;
1248 expr->operands[0]->accept(this);
1249 b = this->result;
1250
1251 b.negate = ~b.negate;
1252
1253 this->result = get_temp(ir->type);
1254 emit(ir, TGSI_OPCODE_MAD, st_dst_reg(this->result), a, b, a);
1255
1256 return true;
1257 }
1258
1259 bool
1260 glsl_to_tgsi_visitor::try_emit_sat(ir_expression *ir)
1261 {
1262 /* Saturates were only introduced to vertex programs in
1263 * NV_vertex_program3, so don't give them to drivers in the VP.
1264 */
1265 if (this->prog->Target == GL_VERTEX_PROGRAM_ARB)
1266 return false;
1267
1268 ir_rvalue *sat_src = ir->as_rvalue_to_saturate();
1269 if (!sat_src)
1270 return false;
1271
1272 sat_src->accept(this);
1273 st_src_reg src = this->result;
1274
1275 /* If we generated an expression instruction into a temporary in
1276 * processing the saturate's operand, apply the saturate to that
1277 * instruction. Otherwise, generate a MOV to do the saturate.
1278 *
1279 * Note that we have to be careful to only do this optimization if
1280 * the instruction in question was what generated src->result. For
1281 * example, ir_dereference_array might generate a MUL instruction
1282 * to create the reladdr, and return us a src reg using that
1283 * reladdr. That MUL result is not the value we're trying to
1284 * saturate.
1285 */
1286 ir_expression *sat_src_expr = sat_src->as_expression();
1287 if (sat_src_expr && (sat_src_expr->operation == ir_binop_mul ||
1288 sat_src_expr->operation == ir_binop_add ||
1289 sat_src_expr->operation == ir_binop_dot)) {
1290 glsl_to_tgsi_instruction *new_inst;
1291 new_inst = (glsl_to_tgsi_instruction *)this->instructions.get_tail();
1292 new_inst->saturate = true;
1293 } else {
1294 this->result = get_temp(ir->type);
1295 st_dst_reg result_dst = st_dst_reg(this->result);
1296 result_dst.writemask = (1 << ir->type->vector_elements) - 1;
1297 glsl_to_tgsi_instruction *inst;
1298 inst = emit(ir, TGSI_OPCODE_MOV, result_dst, src);
1299 inst->saturate = true;
1300 }
1301
1302 return true;
1303 }
1304
1305 void
1306 glsl_to_tgsi_visitor::reladdr_to_temp(ir_instruction *ir,
1307 st_src_reg *reg, int *num_reladdr)
1308 {
1309 if (!reg->reladdr)
1310 return;
1311
1312 emit_arl(ir, address_reg, *reg->reladdr);
1313
1314 if (*num_reladdr != 1) {
1315 st_src_reg temp = get_temp(glsl_type::vec4_type);
1316
1317 emit(ir, TGSI_OPCODE_MOV, st_dst_reg(temp), *reg);
1318 *reg = temp;
1319 }
1320
1321 (*num_reladdr)--;
1322 }
1323
1324 void
1325 glsl_to_tgsi_visitor::visit(ir_expression *ir)
1326 {
1327 unsigned int operand;
1328 st_src_reg op[Elements(ir->operands)];
1329 st_src_reg result_src;
1330 st_dst_reg result_dst;
1331
1332 /* Quick peephole: Emit MAD(a, b, c) instead of ADD(MUL(a, b), c)
1333 */
1334 if (ir->operation == ir_binop_add) {
1335 if (try_emit_mad(ir, 1))
1336 return;
1337 if (try_emit_mad(ir, 0))
1338 return;
1339 }
1340
1341 /* Quick peephole: Emit OPCODE_MAD(-a, -b, a) instead of AND(a, NOT(b))
1342 */
1343 if (ir->operation == ir_binop_logic_and) {
1344 if (try_emit_mad_for_and_not(ir, 1))
1345 return;
1346 if (try_emit_mad_for_and_not(ir, 0))
1347 return;
1348 }
1349
1350 if (try_emit_sat(ir))
1351 return;
1352
1353 if (ir->operation == ir_quadop_vector)
1354 assert(!"ir_quadop_vector should have been lowered");
1355
1356 for (operand = 0; operand < ir->get_num_operands(); operand++) {
1357 this->result.file = PROGRAM_UNDEFINED;
1358 ir->operands[operand]->accept(this);
1359 if (this->result.file == PROGRAM_UNDEFINED) {
1360 ir_print_visitor v;
1361 printf("Failed to get tree for expression operand:\n");
1362 ir->operands[operand]->accept(&v);
1363 exit(1);
1364 }
1365 op[operand] = this->result;
1366
1367 /* Matrix expression operands should have been broken down to vector
1368 * operations already.
1369 */
1370 assert(!ir->operands[operand]->type->is_matrix());
1371 }
1372
1373 int vector_elements = ir->operands[0]->type->vector_elements;
1374 if (ir->operands[1]) {
1375 vector_elements = MAX2(vector_elements,
1376 ir->operands[1]->type->vector_elements);
1377 }
1378
1379 this->result.file = PROGRAM_UNDEFINED;
1380
1381 /* Storage for our result. Ideally for an assignment we'd be using
1382 * the actual storage for the result here, instead.
1383 */
1384 result_src = get_temp(ir->type);
1385 /* convenience for the emit functions below. */
1386 result_dst = st_dst_reg(result_src);
1387 /* Limit writes to the channels that will be used by result_src later.
1388 * This does limit this temp's use as a temporary for multi-instruction
1389 * sequences.
1390 */
1391 result_dst.writemask = (1 << ir->type->vector_elements) - 1;
1392
1393 switch (ir->operation) {
1394 case ir_unop_logic_not:
1395 if (result_dst.type != GLSL_TYPE_FLOAT)
1396 emit(ir, TGSI_OPCODE_NOT, result_dst, op[0]);
1397 else {
1398 /* Previously 'SEQ dst, src, 0.0' was used for this. However, many
1399 * older GPUs implement SEQ using multiple instructions (i915 uses two
1400 * SGE instructions and a MUL instruction). Since our logic values are
1401 * 0.0 and 1.0, 1-x also implements !x.
1402 */
1403 op[0].negate = ~op[0].negate;
1404 emit(ir, TGSI_OPCODE_ADD, result_dst, op[0], st_src_reg_for_float(1.0));
1405 }
1406 break;
1407 case ir_unop_neg:
1408 if (result_dst.type == GLSL_TYPE_INT || result_dst.type == GLSL_TYPE_UINT)
1409 emit(ir, TGSI_OPCODE_INEG, result_dst, op[0]);
1410 else {
1411 op[0].negate = ~op[0].negate;
1412 result_src = op[0];
1413 }
1414 break;
1415 case ir_unop_abs:
1416 emit(ir, TGSI_OPCODE_ABS, result_dst, op[0]);
1417 break;
1418 case ir_unop_sign:
1419 emit(ir, TGSI_OPCODE_SSG, result_dst, op[0]);
1420 break;
1421 case ir_unop_rcp:
1422 emit_scalar(ir, TGSI_OPCODE_RCP, result_dst, op[0]);
1423 break;
1424
1425 case ir_unop_exp2:
1426 emit_scalar(ir, TGSI_OPCODE_EX2, result_dst, op[0]);
1427 break;
1428 case ir_unop_exp:
1429 case ir_unop_log:
1430 assert(!"not reached: should be handled by ir_explog_to_explog2");
1431 break;
1432 case ir_unop_log2:
1433 emit_scalar(ir, TGSI_OPCODE_LG2, result_dst, op[0]);
1434 break;
1435 case ir_unop_sin:
1436 emit_scalar(ir, TGSI_OPCODE_SIN, result_dst, op[0]);
1437 break;
1438 case ir_unop_cos:
1439 emit_scalar(ir, TGSI_OPCODE_COS, result_dst, op[0]);
1440 break;
1441 case ir_unop_sin_reduced:
1442 emit_scs(ir, TGSI_OPCODE_SIN, result_dst, op[0]);
1443 break;
1444 case ir_unop_cos_reduced:
1445 emit_scs(ir, TGSI_OPCODE_COS, result_dst, op[0]);
1446 break;
1447
1448 case ir_unop_dFdx:
1449 emit(ir, TGSI_OPCODE_DDX, result_dst, op[0]);
1450 break;
1451 case ir_unop_dFdy:
1452 op[0].negate = ~op[0].negate;
1453 emit(ir, TGSI_OPCODE_DDY, result_dst, op[0]);
1454 break;
1455
1456 case ir_unop_noise: {
1457 /* At some point, a motivated person could add a better
1458 * implementation of noise. Currently not even the nvidia
1459 * binary drivers do anything more than this. In any case, the
1460 * place to do this is in the GL state tracker, not the poor
1461 * driver.
1462 */
1463 emit(ir, TGSI_OPCODE_MOV, result_dst, st_src_reg_for_float(0.5));
1464 break;
1465 }
1466
1467 case ir_binop_add:
1468 emit(ir, TGSI_OPCODE_ADD, result_dst, op[0], op[1]);
1469 break;
1470 case ir_binop_sub:
1471 emit(ir, TGSI_OPCODE_SUB, result_dst, op[0], op[1]);
1472 break;
1473
1474 case ir_binop_mul:
1475 emit(ir, TGSI_OPCODE_MUL, result_dst, op[0], op[1]);
1476 break;
1477 case ir_binop_div:
1478 if (result_dst.type == GLSL_TYPE_FLOAT)
1479 assert(!"not reached: should be handled by ir_div_to_mul_rcp");
1480 else
1481 emit(ir, TGSI_OPCODE_DIV, result_dst, op[0], op[1]);
1482 break;
1483 case ir_binop_mod:
1484 if (result_dst.type == GLSL_TYPE_FLOAT)
1485 assert(!"ir_binop_mod should have been converted to b * fract(a/b)");
1486 else
1487 emit(ir, TGSI_OPCODE_MOD, result_dst, op[0], op[1]);
1488 break;
1489
1490 case ir_binop_less:
1491 emit(ir, TGSI_OPCODE_SLT, result_dst, op[0], op[1]);
1492 break;
1493 case ir_binop_greater:
1494 emit(ir, TGSI_OPCODE_SLT, result_dst, op[1], op[0]);
1495 break;
1496 case ir_binop_lequal:
1497 emit(ir, TGSI_OPCODE_SGE, result_dst, op[1], op[0]);
1498 break;
1499 case ir_binop_gequal:
1500 emit(ir, TGSI_OPCODE_SGE, result_dst, op[0], op[1]);
1501 break;
1502 case ir_binop_equal:
1503 emit(ir, TGSI_OPCODE_SEQ, result_dst, op[0], op[1]);
1504 break;
1505 case ir_binop_nequal:
1506 emit(ir, TGSI_OPCODE_SNE, result_dst, op[0], op[1]);
1507 break;
1508 case ir_binop_all_equal:
1509 /* "==" operator producing a scalar boolean. */
1510 if (ir->operands[0]->type->is_vector() ||
1511 ir->operands[1]->type->is_vector()) {
1512 st_src_reg temp = get_temp(native_integers ?
1513 glsl_type::get_instance(ir->operands[0]->type->base_type, 4, 1) :
1514 glsl_type::vec4_type);
1515
1516 if (native_integers) {
1517 st_dst_reg temp_dst = st_dst_reg(temp);
1518 st_src_reg temp1 = st_src_reg(temp), temp2 = st_src_reg(temp);
1519
1520 emit(ir, TGSI_OPCODE_SEQ, st_dst_reg(temp), op[0], op[1]);
1521
1522 /* Emit 1-3 AND operations to combine the SEQ results. */
1523 switch (ir->operands[0]->type->vector_elements) {
1524 case 2:
1525 break;
1526 case 3:
1527 temp_dst.writemask = WRITEMASK_Y;
1528 temp1.swizzle = SWIZZLE_YYYY;
1529 temp2.swizzle = SWIZZLE_ZZZZ;
1530 emit(ir, TGSI_OPCODE_AND, temp_dst, temp1, temp2);
1531 break;
1532 case 4:
1533 temp_dst.writemask = WRITEMASK_X;
1534 temp1.swizzle = SWIZZLE_XXXX;
1535 temp2.swizzle = SWIZZLE_YYYY;
1536 emit(ir, TGSI_OPCODE_AND, temp_dst, temp1, temp2);
1537 temp_dst.writemask = WRITEMASK_Y;
1538 temp1.swizzle = SWIZZLE_ZZZZ;
1539 temp2.swizzle = SWIZZLE_WWWW;
1540 emit(ir, TGSI_OPCODE_AND, temp_dst, temp1, temp2);
1541 }
1542
1543 temp1.swizzle = SWIZZLE_XXXX;
1544 temp2.swizzle = SWIZZLE_YYYY;
1545 emit(ir, TGSI_OPCODE_AND, result_dst, temp1, temp2);
1546 } else {
1547 emit(ir, TGSI_OPCODE_SNE, st_dst_reg(temp), op[0], op[1]);
1548
1549 /* After the dot-product, the value will be an integer on the
1550 * range [0,4]. Zero becomes 1.0, and positive values become zero.
1551 */
1552 emit_dp(ir, result_dst, temp, temp, vector_elements);
1553
1554 /* Negating the result of the dot-product gives values on the range
1555 * [-4, 0]. Zero becomes 1.0, and negative values become zero.
1556 * This is achieved using SGE.
1557 */
1558 st_src_reg sge_src = result_src;
1559 sge_src.negate = ~sge_src.negate;
1560 emit(ir, TGSI_OPCODE_SGE, result_dst, sge_src, st_src_reg_for_float(0.0));
1561 }
1562 } else {
1563 emit(ir, TGSI_OPCODE_SEQ, result_dst, op[0], op[1]);
1564 }
1565 break;
1566 case ir_binop_any_nequal:
1567 /* "!=" operator producing a scalar boolean. */
1568 if (ir->operands[0]->type->is_vector() ||
1569 ir->operands[1]->type->is_vector()) {
1570 st_src_reg temp = get_temp(native_integers ?
1571 glsl_type::get_instance(ir->operands[0]->type->base_type, 4, 1) :
1572 glsl_type::vec4_type);
1573 emit(ir, TGSI_OPCODE_SNE, st_dst_reg(temp), op[0], op[1]);
1574
1575 if (native_integers) {
1576 st_dst_reg temp_dst = st_dst_reg(temp);
1577 st_src_reg temp1 = st_src_reg(temp), temp2 = st_src_reg(temp);
1578
1579 /* Emit 1-3 OR operations to combine the SNE results. */
1580 switch (ir->operands[0]->type->vector_elements) {
1581 case 2:
1582 break;
1583 case 3:
1584 temp_dst.writemask = WRITEMASK_Y;
1585 temp1.swizzle = SWIZZLE_YYYY;
1586 temp2.swizzle = SWIZZLE_ZZZZ;
1587 emit(ir, TGSI_OPCODE_OR, temp_dst, temp1, temp2);
1588 break;
1589 case 4:
1590 temp_dst.writemask = WRITEMASK_X;
1591 temp1.swizzle = SWIZZLE_XXXX;
1592 temp2.swizzle = SWIZZLE_YYYY;
1593 emit(ir, TGSI_OPCODE_OR, temp_dst, temp1, temp2);
1594 temp_dst.writemask = WRITEMASK_Y;
1595 temp1.swizzle = SWIZZLE_ZZZZ;
1596 temp2.swizzle = SWIZZLE_WWWW;
1597 emit(ir, TGSI_OPCODE_OR, temp_dst, temp1, temp2);
1598 }
1599
1600 temp1.swizzle = SWIZZLE_XXXX;
1601 temp2.swizzle = SWIZZLE_YYYY;
1602 emit(ir, TGSI_OPCODE_OR, result_dst, temp1, temp2);
1603 } else {
1604 /* After the dot-product, the value will be an integer on the
1605 * range [0,4]. Zero stays zero, and positive values become 1.0.
1606 */
1607 glsl_to_tgsi_instruction *const dp =
1608 emit_dp(ir, result_dst, temp, temp, vector_elements);
1609 if (this->prog->Target == GL_FRAGMENT_PROGRAM_ARB) {
1610 /* The clamping to [0,1] can be done for free in the fragment
1611 * shader with a saturate.
1612 */
1613 dp->saturate = true;
1614 } else {
1615 /* Negating the result of the dot-product gives values on the range
1616 * [-4, 0]. Zero stays zero, and negative values become 1.0. This
1617 * achieved using SLT.
1618 */
1619 st_src_reg slt_src = result_src;
1620 slt_src.negate = ~slt_src.negate;
1621 emit(ir, TGSI_OPCODE_SLT, result_dst, slt_src, st_src_reg_for_float(0.0));
1622 }
1623 }
1624 } else {
1625 emit(ir, TGSI_OPCODE_SNE, result_dst, op[0], op[1]);
1626 }
1627 break;
1628
1629 case ir_unop_any: {
1630 assert(ir->operands[0]->type->is_vector());
1631
1632 /* After the dot-product, the value will be an integer on the
1633 * range [0,4]. Zero stays zero, and positive values become 1.0.
1634 */
1635 glsl_to_tgsi_instruction *const dp =
1636 emit_dp(ir, result_dst, op[0], op[0],
1637 ir->operands[0]->type->vector_elements);
1638 if (this->prog->Target == GL_FRAGMENT_PROGRAM_ARB &&
1639 result_dst.type == GLSL_TYPE_FLOAT) {
1640 /* The clamping to [0,1] can be done for free in the fragment
1641 * shader with a saturate.
1642 */
1643 dp->saturate = true;
1644 } else if (result_dst.type == GLSL_TYPE_FLOAT) {
1645 /* Negating the result of the dot-product gives values on the range
1646 * [-4, 0]. Zero stays zero, and negative values become 1.0. This
1647 * is achieved using SLT.
1648 */
1649 st_src_reg slt_src = result_src;
1650 slt_src.negate = ~slt_src.negate;
1651 emit(ir, TGSI_OPCODE_SLT, result_dst, slt_src, st_src_reg_for_float(0.0));
1652 }
1653 else {
1654 /* Use SNE 0 if integers are being used as boolean values. */
1655 emit(ir, TGSI_OPCODE_SNE, result_dst, result_src, st_src_reg_for_int(0));
1656 }
1657 break;
1658 }
1659
1660 case ir_binop_logic_xor:
1661 if (native_integers)
1662 emit(ir, TGSI_OPCODE_XOR, result_dst, op[0], op[1]);
1663 else
1664 emit(ir, TGSI_OPCODE_SNE, result_dst, op[0], op[1]);
1665 break;
1666
1667 case ir_binop_logic_or: {
1668 if (native_integers) {
1669 /* If integers are used as booleans, we can use an actual "or"
1670 * instruction.
1671 */
1672 assert(native_integers);
1673 emit(ir, TGSI_OPCODE_OR, result_dst, op[0], op[1]);
1674 } else {
1675 /* After the addition, the value will be an integer on the
1676 * range [0,2]. Zero stays zero, and positive values become 1.0.
1677 */
1678 glsl_to_tgsi_instruction *add =
1679 emit(ir, TGSI_OPCODE_ADD, result_dst, op[0], op[1]);
1680 if (this->prog->Target == GL_FRAGMENT_PROGRAM_ARB) {
1681 /* The clamping to [0,1] can be done for free in the fragment
1682 * shader with a saturate if floats are being used as boolean values.
1683 */
1684 add->saturate = true;
1685 } else {
1686 /* Negating the result of the addition gives values on the range
1687 * [-2, 0]. Zero stays zero, and negative values become 1.0. This
1688 * is achieved using SLT.
1689 */
1690 st_src_reg slt_src = result_src;
1691 slt_src.negate = ~slt_src.negate;
1692 emit(ir, TGSI_OPCODE_SLT, result_dst, slt_src, st_src_reg_for_float(0.0));
1693 }
1694 }
1695 break;
1696 }
1697
1698 case ir_binop_logic_and:
1699 /* If native integers are disabled, the bool args are stored as float 0.0
1700 * or 1.0, so "mul" gives us "and". If they're enabled, just use the
1701 * actual AND opcode.
1702 */
1703 if (native_integers)
1704 emit(ir, TGSI_OPCODE_AND, result_dst, op[0], op[1]);
1705 else
1706 emit(ir, TGSI_OPCODE_MUL, result_dst, op[0], op[1]);
1707 break;
1708
1709 case ir_binop_dot:
1710 assert(ir->operands[0]->type->is_vector());
1711 assert(ir->operands[0]->type == ir->operands[1]->type);
1712 emit_dp(ir, result_dst, op[0], op[1],
1713 ir->operands[0]->type->vector_elements);
1714 break;
1715
1716 case ir_unop_sqrt:
1717 /* sqrt(x) = x * rsq(x). */
1718 emit_scalar(ir, TGSI_OPCODE_RSQ, result_dst, op[0]);
1719 emit(ir, TGSI_OPCODE_MUL, result_dst, result_src, op[0]);
1720 /* For incoming channels <= 0, set the result to 0. */
1721 op[0].negate = ~op[0].negate;
1722 emit(ir, TGSI_OPCODE_CMP, result_dst,
1723 op[0], result_src, st_src_reg_for_float(0.0));
1724 break;
1725 case ir_unop_rsq:
1726 emit_scalar(ir, TGSI_OPCODE_RSQ, result_dst, op[0]);
1727 break;
1728 case ir_unop_i2f:
1729 if (native_integers) {
1730 emit(ir, TGSI_OPCODE_I2F, result_dst, op[0]);
1731 break;
1732 }
1733 /* fallthrough to next case otherwise */
1734 case ir_unop_b2f:
1735 if (native_integers) {
1736 emit(ir, TGSI_OPCODE_AND, result_dst, op[0], st_src_reg_for_float(1.0));
1737 break;
1738 }
1739 /* fallthrough to next case otherwise */
1740 case ir_unop_i2u:
1741 case ir_unop_u2i:
1742 /* Converting between signed and unsigned integers is a no-op. */
1743 result_src = op[0];
1744 break;
1745 case ir_unop_b2i:
1746 if (native_integers) {
1747 /* Booleans are stored as integers using ~0 for true and 0 for false.
1748 * GLSL requires that int(bool) return 1 for true and 0 for false.
1749 * This conversion is done with AND, but it could be done with NEG.
1750 */
1751 emit(ir, TGSI_OPCODE_AND, result_dst, op[0], st_src_reg_for_int(1));
1752 } else {
1753 /* Booleans and integers are both stored as floats when native
1754 * integers are disabled.
1755 */
1756 result_src = op[0];
1757 }
1758 break;
1759 case ir_unop_f2i:
1760 if (native_integers)
1761 emit(ir, TGSI_OPCODE_F2I, result_dst, op[0]);
1762 else
1763 emit(ir, TGSI_OPCODE_TRUNC, result_dst, op[0]);
1764 break;
1765 case ir_unop_f2b:
1766 emit(ir, TGSI_OPCODE_SNE, result_dst, op[0], st_src_reg_for_float(0.0));
1767 break;
1768 case ir_unop_i2b:
1769 if (native_integers)
1770 emit(ir, TGSI_OPCODE_INEG, result_dst, op[0]);
1771 else
1772 emit(ir, TGSI_OPCODE_SNE, result_dst, op[0], st_src_reg_for_float(0.0));
1773 break;
1774 case ir_unop_trunc:
1775 emit(ir, TGSI_OPCODE_TRUNC, result_dst, op[0]);
1776 break;
1777 case ir_unop_ceil:
1778 op[0].negate = ~op[0].negate;
1779 emit(ir, TGSI_OPCODE_FLR, result_dst, op[0]);
1780 result_src.negate = ~result_src.negate;
1781 break;
1782 case ir_unop_floor:
1783 emit(ir, TGSI_OPCODE_FLR, result_dst, op[0]);
1784 break;
1785 case ir_unop_round_even:
1786 emit(ir, TGSI_OPCODE_ROUND, result_dst, op[0]);
1787 break;
1788 case ir_unop_fract:
1789 emit(ir, TGSI_OPCODE_FRC, result_dst, op[0]);
1790 break;
1791
1792 case ir_binop_min:
1793 emit(ir, TGSI_OPCODE_MIN, result_dst, op[0], op[1]);
1794 break;
1795 case ir_binop_max:
1796 emit(ir, TGSI_OPCODE_MAX, result_dst, op[0], op[1]);
1797 break;
1798 case ir_binop_pow:
1799 emit_scalar(ir, TGSI_OPCODE_POW, result_dst, op[0], op[1]);
1800 break;
1801
1802 case ir_unop_bit_not:
1803 if (native_integers) {
1804 emit(ir, TGSI_OPCODE_NOT, result_dst, op[0]);
1805 break;
1806 }
1807 case ir_unop_u2f:
1808 if (native_integers) {
1809 emit(ir, TGSI_OPCODE_U2F, result_dst, op[0]);
1810 break;
1811 }
1812 case ir_binop_lshift:
1813 if (native_integers) {
1814 emit(ir, TGSI_OPCODE_SHL, result_dst, op[0], op[1]);
1815 break;
1816 }
1817 case ir_binop_rshift:
1818 if (native_integers) {
1819 emit(ir, TGSI_OPCODE_ISHR, result_dst, op[0], op[1]);
1820 break;
1821 }
1822 case ir_binop_bit_and:
1823 if (native_integers) {
1824 emit(ir, TGSI_OPCODE_AND, result_dst, op[0], op[1]);
1825 break;
1826 }
1827 case ir_binop_bit_xor:
1828 if (native_integers) {
1829 emit(ir, TGSI_OPCODE_XOR, result_dst, op[0], op[1]);
1830 break;
1831 }
1832 case ir_binop_bit_or:
1833 if (native_integers) {
1834 emit(ir, TGSI_OPCODE_OR, result_dst, op[0], op[1]);
1835 break;
1836 }
1837
1838 assert(!"GLSL 1.30 features unsupported");
1839 break;
1840
1841 case ir_quadop_vector:
1842 /* This operation should have already been handled.
1843 */
1844 assert(!"Should not get here.");
1845 break;
1846 }
1847
1848 this->result = result_src;
1849 }
1850
1851
1852 void
1853 glsl_to_tgsi_visitor::visit(ir_swizzle *ir)
1854 {
1855 st_src_reg src;
1856 int i;
1857 int swizzle[4];
1858
1859 /* Note that this is only swizzles in expressions, not those on the left
1860 * hand side of an assignment, which do write masking. See ir_assignment
1861 * for that.
1862 */
1863
1864 ir->val->accept(this);
1865 src = this->result;
1866 assert(src.file != PROGRAM_UNDEFINED);
1867
1868 for (i = 0; i < 4; i++) {
1869 if (i < ir->type->vector_elements) {
1870 switch (i) {
1871 case 0:
1872 swizzle[i] = GET_SWZ(src.swizzle, ir->mask.x);
1873 break;
1874 case 1:
1875 swizzle[i] = GET_SWZ(src.swizzle, ir->mask.y);
1876 break;
1877 case 2:
1878 swizzle[i] = GET_SWZ(src.swizzle, ir->mask.z);
1879 break;
1880 case 3:
1881 swizzle[i] = GET_SWZ(src.swizzle, ir->mask.w);
1882 break;
1883 }
1884 } else {
1885 /* If the type is smaller than a vec4, replicate the last
1886 * channel out.
1887 */
1888 swizzle[i] = swizzle[ir->type->vector_elements - 1];
1889 }
1890 }
1891
1892 src.swizzle = MAKE_SWIZZLE4(swizzle[0], swizzle[1], swizzle[2], swizzle[3]);
1893
1894 this->result = src;
1895 }
1896
1897 void
1898 glsl_to_tgsi_visitor::visit(ir_dereference_variable *ir)
1899 {
1900 variable_storage *entry = find_variable_storage(ir->var);
1901 ir_variable *var = ir->var;
1902
1903 if (!entry) {
1904 switch (var->mode) {
1905 case ir_var_uniform:
1906 entry = new(mem_ctx) variable_storage(var, PROGRAM_UNIFORM,
1907 var->location);
1908 this->variables.push_tail(entry);
1909 break;
1910 case ir_var_in:
1911 case ir_var_inout:
1912 /* The linker assigns locations for varyings and attributes,
1913 * including deprecated builtins (like gl_Color), user-assign
1914 * generic attributes (glBindVertexLocation), and
1915 * user-defined varyings.
1916 *
1917 * FINISHME: We would hit this path for function arguments. Fix!
1918 */
1919 assert(var->location != -1);
1920 entry = new(mem_ctx) variable_storage(var,
1921 PROGRAM_INPUT,
1922 var->location);
1923 break;
1924 case ir_var_out:
1925 assert(var->location != -1);
1926 entry = new(mem_ctx) variable_storage(var,
1927 PROGRAM_OUTPUT,
1928 var->location + var->index);
1929 break;
1930 case ir_var_system_value:
1931 entry = new(mem_ctx) variable_storage(var,
1932 PROGRAM_SYSTEM_VALUE,
1933 var->location);
1934 break;
1935 case ir_var_auto:
1936 case ir_var_temporary:
1937 entry = new(mem_ctx) variable_storage(var, PROGRAM_TEMPORARY,
1938 this->next_temp);
1939 this->variables.push_tail(entry);
1940
1941 next_temp += type_size(var->type);
1942 break;
1943 }
1944
1945 if (!entry) {
1946 printf("Failed to make storage for %s\n", var->name);
1947 exit(1);
1948 }
1949 }
1950
1951 this->result = st_src_reg(entry->file, entry->index, var->type);
1952 if (!native_integers)
1953 this->result.type = GLSL_TYPE_FLOAT;
1954 }
1955
1956 void
1957 glsl_to_tgsi_visitor::visit(ir_dereference_array *ir)
1958 {
1959 ir_constant *index;
1960 st_src_reg src;
1961 int element_size = type_size(ir->type);
1962
1963 index = ir->array_index->constant_expression_value();
1964
1965 ir->array->accept(this);
1966 src = this->result;
1967
1968 if (index) {
1969 src.index += index->value.i[0] * element_size;
1970 } else {
1971 /* Variable index array dereference. It eats the "vec4" of the
1972 * base of the array and an index that offsets the TGSI register
1973 * index.
1974 */
1975 ir->array_index->accept(this);
1976
1977 st_src_reg index_reg;
1978
1979 if (element_size == 1) {
1980 index_reg = this->result;
1981 } else {
1982 index_reg = get_temp(native_integers ?
1983 glsl_type::int_type : glsl_type::float_type);
1984
1985 emit(ir, TGSI_OPCODE_MUL, st_dst_reg(index_reg),
1986 this->result, st_src_reg_for_type(index_reg.type, element_size));
1987 }
1988
1989 /* If there was already a relative address register involved, add the
1990 * new and the old together to get the new offset.
1991 */
1992 if (src.reladdr != NULL) {
1993 st_src_reg accum_reg = get_temp(native_integers ?
1994 glsl_type::int_type : glsl_type::float_type);
1995
1996 emit(ir, TGSI_OPCODE_ADD, st_dst_reg(accum_reg),
1997 index_reg, *src.reladdr);
1998
1999 index_reg = accum_reg;
2000 }
2001
2002 src.reladdr = ralloc(mem_ctx, st_src_reg);
2003 memcpy(src.reladdr, &index_reg, sizeof(index_reg));
2004 }
2005
2006 /* If the type is smaller than a vec4, replicate the last channel out. */
2007 if (ir->type->is_scalar() || ir->type->is_vector())
2008 src.swizzle = swizzle_for_size(ir->type->vector_elements);
2009 else
2010 src.swizzle = SWIZZLE_NOOP;
2011
2012 this->result = src;
2013 }
2014
2015 void
2016 glsl_to_tgsi_visitor::visit(ir_dereference_record *ir)
2017 {
2018 unsigned int i;
2019 const glsl_type *struct_type = ir->record->type;
2020 int offset = 0;
2021
2022 ir->record->accept(this);
2023
2024 for (i = 0; i < struct_type->length; i++) {
2025 if (strcmp(struct_type->fields.structure[i].name, ir->field) == 0)
2026 break;
2027 offset += type_size(struct_type->fields.structure[i].type);
2028 }
2029
2030 /* If the type is smaller than a vec4, replicate the last channel out. */
2031 if (ir->type->is_scalar() || ir->type->is_vector())
2032 this->result.swizzle = swizzle_for_size(ir->type->vector_elements);
2033 else
2034 this->result.swizzle = SWIZZLE_NOOP;
2035
2036 this->result.index += offset;
2037 }
2038
2039 /**
2040 * We want to be careful in assignment setup to hit the actual storage
2041 * instead of potentially using a temporary like we might with the
2042 * ir_dereference handler.
2043 */
2044 static st_dst_reg
2045 get_assignment_lhs(ir_dereference *ir, glsl_to_tgsi_visitor *v)
2046 {
2047 /* The LHS must be a dereference. If the LHS is a variable indexed array
2048 * access of a vector, it must be separated into a series conditional moves
2049 * before reaching this point (see ir_vec_index_to_cond_assign).
2050 */
2051 assert(ir->as_dereference());
2052 ir_dereference_array *deref_array = ir->as_dereference_array();
2053 if (deref_array) {
2054 assert(!deref_array->array->type->is_vector());
2055 }
2056
2057 /* Use the rvalue deref handler for the most part. We'll ignore
2058 * swizzles in it and write swizzles using writemask, though.
2059 */
2060 ir->accept(v);
2061 return st_dst_reg(v->result);
2062 }
2063
2064 /**
2065 * Process the condition of a conditional assignment
2066 *
2067 * Examines the condition of a conditional assignment to generate the optimal
2068 * first operand of a \c CMP instruction. If the condition is a relational
2069 * operator with 0 (e.g., \c ir_binop_less), the value being compared will be
2070 * used as the source for the \c CMP instruction. Otherwise the comparison
2071 * is processed to a boolean result, and the boolean result is used as the
2072 * operand to the CMP instruction.
2073 */
2074 bool
2075 glsl_to_tgsi_visitor::process_move_condition(ir_rvalue *ir)
2076 {
2077 ir_rvalue *src_ir = ir;
2078 bool negate = true;
2079 bool switch_order = false;
2080
2081 ir_expression *const expr = ir->as_expression();
2082 if ((expr != NULL) && (expr->get_num_operands() == 2)) {
2083 bool zero_on_left = false;
2084
2085 if (expr->operands[0]->is_zero()) {
2086 src_ir = expr->operands[1];
2087 zero_on_left = true;
2088 } else if (expr->operands[1]->is_zero()) {
2089 src_ir = expr->operands[0];
2090 zero_on_left = false;
2091 }
2092
2093 /* a is - 0 + - 0 +
2094 * (a < 0) T F F ( a < 0) T F F
2095 * (0 < a) F F T (-a < 0) F F T
2096 * (a <= 0) T T F (-a < 0) F F T (swap order of other operands)
2097 * (0 <= a) F T T ( a < 0) T F F (swap order of other operands)
2098 * (a > 0) F F T (-a < 0) F F T
2099 * (0 > a) T F F ( a < 0) T F F
2100 * (a >= 0) F T T ( a < 0) T F F (swap order of other operands)
2101 * (0 >= a) T T F (-a < 0) F F T (swap order of other operands)
2102 *
2103 * Note that exchanging the order of 0 and 'a' in the comparison simply
2104 * means that the value of 'a' should be negated.
2105 */
2106 if (src_ir != ir) {
2107 switch (expr->operation) {
2108 case ir_binop_less:
2109 switch_order = false;
2110 negate = zero_on_left;
2111 break;
2112
2113 case ir_binop_greater:
2114 switch_order = false;
2115 negate = !zero_on_left;
2116 break;
2117
2118 case ir_binop_lequal:
2119 switch_order = true;
2120 negate = !zero_on_left;
2121 break;
2122
2123 case ir_binop_gequal:
2124 switch_order = true;
2125 negate = zero_on_left;
2126 break;
2127
2128 default:
2129 /* This isn't the right kind of comparison afterall, so make sure
2130 * the whole condition is visited.
2131 */
2132 src_ir = ir;
2133 break;
2134 }
2135 }
2136 }
2137
2138 src_ir->accept(this);
2139
2140 /* We use the TGSI_OPCODE_CMP (a < 0 ? b : c) for conditional moves, and the
2141 * condition we produced is 0.0 or 1.0. By flipping the sign, we can
2142 * choose which value TGSI_OPCODE_CMP produces without an extra instruction
2143 * computing the condition.
2144 */
2145 if (negate)
2146 this->result.negate = ~this->result.negate;
2147
2148 return switch_order;
2149 }
2150
2151 void
2152 glsl_to_tgsi_visitor::visit(ir_assignment *ir)
2153 {
2154 st_dst_reg l;
2155 st_src_reg r;
2156 int i;
2157
2158 ir->rhs->accept(this);
2159 r = this->result;
2160
2161 l = get_assignment_lhs(ir->lhs, this);
2162
2163 /* FINISHME: This should really set to the correct maximal writemask for each
2164 * FINISHME: component written (in the loops below). This case can only
2165 * FINISHME: occur for matrices, arrays, and structures.
2166 */
2167 if (ir->write_mask == 0) {
2168 assert(!ir->lhs->type->is_scalar() && !ir->lhs->type->is_vector());
2169 l.writemask = WRITEMASK_XYZW;
2170 } else if (ir->lhs->type->is_scalar() &&
2171 ir->lhs->variable_referenced()->mode == ir_var_out) {
2172 /* FINISHME: This hack makes writing to gl_FragDepth, which lives in the
2173 * FINISHME: W component of fragment shader output zero, work correctly.
2174 */
2175 l.writemask = WRITEMASK_XYZW;
2176 } else {
2177 int swizzles[4];
2178 int first_enabled_chan = 0;
2179 int rhs_chan = 0;
2180
2181 l.writemask = ir->write_mask;
2182
2183 for (int i = 0; i < 4; i++) {
2184 if (l.writemask & (1 << i)) {
2185 first_enabled_chan = GET_SWZ(r.swizzle, i);
2186 break;
2187 }
2188 }
2189
2190 /* Swizzle a small RHS vector into the channels being written.
2191 *
2192 * glsl ir treats write_mask as dictating how many channels are
2193 * present on the RHS while TGSI treats write_mask as just
2194 * showing which channels of the vec4 RHS get written.
2195 */
2196 for (int i = 0; i < 4; i++) {
2197 if (l.writemask & (1 << i))
2198 swizzles[i] = GET_SWZ(r.swizzle, rhs_chan++);
2199 else
2200 swizzles[i] = first_enabled_chan;
2201 }
2202 r.swizzle = MAKE_SWIZZLE4(swizzles[0], swizzles[1],
2203 swizzles[2], swizzles[3]);
2204 }
2205
2206 assert(l.file != PROGRAM_UNDEFINED);
2207 assert(r.file != PROGRAM_UNDEFINED);
2208
2209 if (ir->condition) {
2210 const bool switch_order = this->process_move_condition(ir->condition);
2211 st_src_reg condition = this->result;
2212
2213 for (i = 0; i < type_size(ir->lhs->type); i++) {
2214 st_src_reg l_src = st_src_reg(l);
2215 st_src_reg condition_temp = condition;
2216 l_src.swizzle = swizzle_for_size(ir->lhs->type->vector_elements);
2217
2218 if (native_integers) {
2219 /* This is necessary because TGSI's CMP instruction expects the
2220 * condition to be a float, and we store booleans as integers.
2221 * If TGSI had a UCMP instruction or similar, this extra
2222 * instruction would not be necessary.
2223 */
2224 condition_temp = get_temp(glsl_type::vec4_type);
2225 condition.negate = 0;
2226 emit(ir, TGSI_OPCODE_I2F, st_dst_reg(condition_temp), condition);
2227 condition_temp.swizzle = condition.swizzle;
2228 }
2229
2230 if (switch_order) {
2231 emit(ir, TGSI_OPCODE_CMP, l, condition_temp, l_src, r);
2232 } else {
2233 emit(ir, TGSI_OPCODE_CMP, l, condition_temp, r, l_src);
2234 }
2235
2236 l.index++;
2237 r.index++;
2238 }
2239 } else if (ir->rhs->as_expression() &&
2240 this->instructions.get_tail() &&
2241 ir->rhs == ((glsl_to_tgsi_instruction *)this->instructions.get_tail())->ir &&
2242 type_size(ir->lhs->type) == 1 &&
2243 l.writemask == ((glsl_to_tgsi_instruction *)this->instructions.get_tail())->dst.writemask) {
2244 /* To avoid emitting an extra MOV when assigning an expression to a
2245 * variable, emit the last instruction of the expression again, but
2246 * replace the destination register with the target of the assignment.
2247 * Dead code elimination will remove the original instruction.
2248 */
2249 glsl_to_tgsi_instruction *inst, *new_inst;
2250 inst = (glsl_to_tgsi_instruction *)this->instructions.get_tail();
2251 new_inst = emit(ir, inst->op, l, inst->src[0], inst->src[1], inst->src[2]);
2252 new_inst->saturate = inst->saturate;
2253 inst->dead_mask = inst->dst.writemask;
2254 } else {
2255 for (i = 0; i < type_size(ir->lhs->type); i++) {
2256 emit(ir, TGSI_OPCODE_MOV, l, r);
2257 l.index++;
2258 r.index++;
2259 }
2260 }
2261 }
2262
2263
2264 void
2265 glsl_to_tgsi_visitor::visit(ir_constant *ir)
2266 {
2267 st_src_reg src;
2268 GLfloat stack_vals[4] = { 0 };
2269 gl_constant_value *values = (gl_constant_value *) stack_vals;
2270 GLenum gl_type = GL_NONE;
2271 unsigned int i;
2272 static int in_array = 0;
2273 gl_register_file file = in_array ? PROGRAM_CONSTANT : PROGRAM_IMMEDIATE;
2274
2275 /* Unfortunately, 4 floats is all we can get into
2276 * _mesa_add_typed_unnamed_constant. So, make a temp to store an
2277 * aggregate constant and move each constant value into it. If we
2278 * get lucky, copy propagation will eliminate the extra moves.
2279 */
2280 if (ir->type->base_type == GLSL_TYPE_STRUCT) {
2281 st_src_reg temp_base = get_temp(ir->type);
2282 st_dst_reg temp = st_dst_reg(temp_base);
2283
2284 foreach_iter(exec_list_iterator, iter, ir->components) {
2285 ir_constant *field_value = (ir_constant *)iter.get();
2286 int size = type_size(field_value->type);
2287
2288 assert(size > 0);
2289
2290 field_value->accept(this);
2291 src = this->result;
2292
2293 for (i = 0; i < (unsigned int)size; i++) {
2294 emit(ir, TGSI_OPCODE_MOV, temp, src);
2295
2296 src.index++;
2297 temp.index++;
2298 }
2299 }
2300 this->result = temp_base;
2301 return;
2302 }
2303
2304 if (ir->type->is_array()) {
2305 st_src_reg temp_base = get_temp(ir->type);
2306 st_dst_reg temp = st_dst_reg(temp_base);
2307 int size = type_size(ir->type->fields.array);
2308
2309 assert(size > 0);
2310 in_array++;
2311
2312 for (i = 0; i < ir->type->length; i++) {
2313 ir->array_elements[i]->accept(this);
2314 src = this->result;
2315 for (int j = 0; j < size; j++) {
2316 emit(ir, TGSI_OPCODE_MOV, temp, src);
2317
2318 src.index++;
2319 temp.index++;
2320 }
2321 }
2322 this->result = temp_base;
2323 in_array--;
2324 return;
2325 }
2326
2327 if (ir->type->is_matrix()) {
2328 st_src_reg mat = get_temp(ir->type);
2329 st_dst_reg mat_column = st_dst_reg(mat);
2330
2331 for (i = 0; i < ir->type->matrix_columns; i++) {
2332 assert(ir->type->base_type == GLSL_TYPE_FLOAT);
2333 values = (gl_constant_value *) &ir->value.f[i * ir->type->vector_elements];
2334
2335 src = st_src_reg(file, -1, ir->type->base_type);
2336 src.index = add_constant(file,
2337 values,
2338 ir->type->vector_elements,
2339 GL_FLOAT,
2340 &src.swizzle);
2341 emit(ir, TGSI_OPCODE_MOV, mat_column, src);
2342
2343 mat_column.index++;
2344 }
2345
2346 this->result = mat;
2347 return;
2348 }
2349
2350 switch (ir->type->base_type) {
2351 case GLSL_TYPE_FLOAT:
2352 gl_type = GL_FLOAT;
2353 for (i = 0; i < ir->type->vector_elements; i++) {
2354 values[i].f = ir->value.f[i];
2355 }
2356 break;
2357 case GLSL_TYPE_UINT:
2358 gl_type = native_integers ? GL_UNSIGNED_INT : GL_FLOAT;
2359 for (i = 0; i < ir->type->vector_elements; i++) {
2360 if (native_integers)
2361 values[i].u = ir->value.u[i];
2362 else
2363 values[i].f = ir->value.u[i];
2364 }
2365 break;
2366 case GLSL_TYPE_INT:
2367 gl_type = native_integers ? GL_INT : GL_FLOAT;
2368 for (i = 0; i < ir->type->vector_elements; i++) {
2369 if (native_integers)
2370 values[i].i = ir->value.i[i];
2371 else
2372 values[i].f = ir->value.i[i];
2373 }
2374 break;
2375 case GLSL_TYPE_BOOL:
2376 gl_type = native_integers ? GL_BOOL : GL_FLOAT;
2377 for (i = 0; i < ir->type->vector_elements; i++) {
2378 if (native_integers)
2379 values[i].u = ir->value.b[i] ? ~0 : 0;
2380 else
2381 values[i].f = ir->value.b[i];
2382 }
2383 break;
2384 default:
2385 assert(!"Non-float/uint/int/bool constant");
2386 }
2387
2388 this->result = st_src_reg(file, -1, ir->type);
2389 this->result.index = add_constant(file,
2390 values,
2391 ir->type->vector_elements,
2392 gl_type,
2393 &this->result.swizzle);
2394 }
2395
2396 function_entry *
2397 glsl_to_tgsi_visitor::get_function_signature(ir_function_signature *sig)
2398 {
2399 function_entry *entry;
2400
2401 foreach_iter(exec_list_iterator, iter, this->function_signatures) {
2402 entry = (function_entry *)iter.get();
2403
2404 if (entry->sig == sig)
2405 return entry;
2406 }
2407
2408 entry = ralloc(mem_ctx, function_entry);
2409 entry->sig = sig;
2410 entry->sig_id = this->next_signature_id++;
2411 entry->bgn_inst = NULL;
2412
2413 /* Allocate storage for all the parameters. */
2414 foreach_iter(exec_list_iterator, iter, sig->parameters) {
2415 ir_variable *param = (ir_variable *)iter.get();
2416 variable_storage *storage;
2417
2418 storage = find_variable_storage(param);
2419 assert(!storage);
2420
2421 storage = new(mem_ctx) variable_storage(param, PROGRAM_TEMPORARY,
2422 this->next_temp);
2423 this->variables.push_tail(storage);
2424
2425 this->next_temp += type_size(param->type);
2426 }
2427
2428 if (!sig->return_type->is_void()) {
2429 entry->return_reg = get_temp(sig->return_type);
2430 } else {
2431 entry->return_reg = undef_src;
2432 }
2433
2434 this->function_signatures.push_tail(entry);
2435 return entry;
2436 }
2437
2438 void
2439 glsl_to_tgsi_visitor::visit(ir_call *ir)
2440 {
2441 glsl_to_tgsi_instruction *call_inst;
2442 ir_function_signature *sig = ir->callee;
2443 function_entry *entry = get_function_signature(sig);
2444 int i;
2445
2446 /* Process in parameters. */
2447 exec_list_iterator sig_iter = sig->parameters.iterator();
2448 foreach_iter(exec_list_iterator, iter, *ir) {
2449 ir_rvalue *param_rval = (ir_rvalue *)iter.get();
2450 ir_variable *param = (ir_variable *)sig_iter.get();
2451
2452 if (param->mode == ir_var_in ||
2453 param->mode == ir_var_inout) {
2454 variable_storage *storage = find_variable_storage(param);
2455 assert(storage);
2456
2457 param_rval->accept(this);
2458 st_src_reg r = this->result;
2459
2460 st_dst_reg l;
2461 l.file = storage->file;
2462 l.index = storage->index;
2463 l.reladdr = NULL;
2464 l.writemask = WRITEMASK_XYZW;
2465 l.cond_mask = COND_TR;
2466
2467 for (i = 0; i < type_size(param->type); i++) {
2468 emit(ir, TGSI_OPCODE_MOV, l, r);
2469 l.index++;
2470 r.index++;
2471 }
2472 }
2473
2474 sig_iter.next();
2475 }
2476 assert(!sig_iter.has_next());
2477
2478 /* Emit call instruction */
2479 call_inst = emit(ir, TGSI_OPCODE_CAL);
2480 call_inst->function = entry;
2481
2482 /* Process out parameters. */
2483 sig_iter = sig->parameters.iterator();
2484 foreach_iter(exec_list_iterator, iter, *ir) {
2485 ir_rvalue *param_rval = (ir_rvalue *)iter.get();
2486 ir_variable *param = (ir_variable *)sig_iter.get();
2487
2488 if (param->mode == ir_var_out ||
2489 param->mode == ir_var_inout) {
2490 variable_storage *storage = find_variable_storage(param);
2491 assert(storage);
2492
2493 st_src_reg r;
2494 r.file = storage->file;
2495 r.index = storage->index;
2496 r.reladdr = NULL;
2497 r.swizzle = SWIZZLE_NOOP;
2498 r.negate = 0;
2499
2500 param_rval->accept(this);
2501 st_dst_reg l = st_dst_reg(this->result);
2502
2503 for (i = 0; i < type_size(param->type); i++) {
2504 emit(ir, TGSI_OPCODE_MOV, l, r);
2505 l.index++;
2506 r.index++;
2507 }
2508 }
2509
2510 sig_iter.next();
2511 }
2512 assert(!sig_iter.has_next());
2513
2514 /* Process return value. */
2515 this->result = entry->return_reg;
2516 }
2517
2518 void
2519 glsl_to_tgsi_visitor::visit(ir_texture *ir)
2520 {
2521 st_src_reg result_src, coord, lod_info, projector, dx, dy, offset;
2522 st_dst_reg result_dst, coord_dst;
2523 glsl_to_tgsi_instruction *inst = NULL;
2524 unsigned opcode = TGSI_OPCODE_NOP;
2525
2526 if (ir->coordinate) {
2527 ir->coordinate->accept(this);
2528
2529 /* Put our coords in a temp. We'll need to modify them for shadow,
2530 * projection, or LOD, so the only case we'd use it as is is if
2531 * we're doing plain old texturing. The optimization passes on
2532 * glsl_to_tgsi_visitor should handle cleaning up our mess in that case.
2533 */
2534 coord = get_temp(glsl_type::vec4_type);
2535 coord_dst = st_dst_reg(coord);
2536 emit(ir, TGSI_OPCODE_MOV, coord_dst, this->result);
2537 }
2538
2539 if (ir->projector) {
2540 ir->projector->accept(this);
2541 projector = this->result;
2542 }
2543
2544 /* Storage for our result. Ideally for an assignment we'd be using
2545 * the actual storage for the result here, instead.
2546 */
2547 result_src = get_temp(glsl_type::vec4_type);
2548 result_dst = st_dst_reg(result_src);
2549
2550 switch (ir->op) {
2551 case ir_tex:
2552 opcode = TGSI_OPCODE_TEX;
2553 break;
2554 case ir_txb:
2555 opcode = TGSI_OPCODE_TXB;
2556 ir->lod_info.bias->accept(this);
2557 lod_info = this->result;
2558 break;
2559 case ir_txl:
2560 opcode = TGSI_OPCODE_TXL;
2561 ir->lod_info.lod->accept(this);
2562 lod_info = this->result;
2563 break;
2564 case ir_txd:
2565 opcode = TGSI_OPCODE_TXD;
2566 ir->lod_info.grad.dPdx->accept(this);
2567 dx = this->result;
2568 ir->lod_info.grad.dPdy->accept(this);
2569 dy = this->result;
2570 break;
2571 case ir_txs:
2572 opcode = TGSI_OPCODE_TXQ;
2573 ir->lod_info.lod->accept(this);
2574 lod_info = this->result;
2575 break;
2576 case ir_txf:
2577 opcode = TGSI_OPCODE_TXF;
2578 ir->lod_info.lod->accept(this);
2579 lod_info = this->result;
2580 if (ir->offset) {
2581 ir->offset->accept(this);
2582 offset = this->result;
2583 }
2584 break;
2585 }
2586
2587 const glsl_type *sampler_type = ir->sampler->type;
2588
2589 if (ir->projector) {
2590 if (opcode == TGSI_OPCODE_TEX) {
2591 /* Slot the projector in as the last component of the coord. */
2592 coord_dst.writemask = WRITEMASK_W;
2593 emit(ir, TGSI_OPCODE_MOV, coord_dst, projector);
2594 coord_dst.writemask = WRITEMASK_XYZW;
2595 opcode = TGSI_OPCODE_TXP;
2596 } else {
2597 st_src_reg coord_w = coord;
2598 coord_w.swizzle = SWIZZLE_WWWW;
2599
2600 /* For the other TEX opcodes there's no projective version
2601 * since the last slot is taken up by LOD info. Do the
2602 * projective divide now.
2603 */
2604 coord_dst.writemask = WRITEMASK_W;
2605 emit(ir, TGSI_OPCODE_RCP, coord_dst, projector);
2606
2607 /* In the case where we have to project the coordinates "by hand,"
2608 * the shadow comparator value must also be projected.
2609 */
2610 st_src_reg tmp_src = coord;
2611 if (ir->shadow_comparitor) {
2612 /* Slot the shadow value in as the second to last component of the
2613 * coord.
2614 */
2615 ir->shadow_comparitor->accept(this);
2616
2617 tmp_src = get_temp(glsl_type::vec4_type);
2618 st_dst_reg tmp_dst = st_dst_reg(tmp_src);
2619
2620 /* Projective division not allowed for array samplers. */
2621 assert(!sampler_type->sampler_array);
2622
2623 tmp_dst.writemask = WRITEMASK_Z;
2624 emit(ir, TGSI_OPCODE_MOV, tmp_dst, this->result);
2625
2626 tmp_dst.writemask = WRITEMASK_XY;
2627 emit(ir, TGSI_OPCODE_MOV, tmp_dst, coord);
2628 }
2629
2630 coord_dst.writemask = WRITEMASK_XYZ;
2631 emit(ir, TGSI_OPCODE_MUL, coord_dst, tmp_src, coord_w);
2632
2633 coord_dst.writemask = WRITEMASK_XYZW;
2634 coord.swizzle = SWIZZLE_XYZW;
2635 }
2636 }
2637
2638 /* If projection is done and the opcode is not TGSI_OPCODE_TXP, then the shadow
2639 * comparator was put in the correct place (and projected) by the code,
2640 * above, that handles by-hand projection.
2641 */
2642 if (ir->shadow_comparitor && (!ir->projector || opcode == TGSI_OPCODE_TXP)) {
2643 /* Slot the shadow value in as the second to last component of the
2644 * coord.
2645 */
2646 ir->shadow_comparitor->accept(this);
2647
2648 /* XXX This will need to be updated for cubemap array samplers. */
2649 if ((sampler_type->sampler_dimensionality == GLSL_SAMPLER_DIM_2D &&
2650 sampler_type->sampler_array) ||
2651 sampler_type->sampler_dimensionality == GLSL_SAMPLER_DIM_CUBE) {
2652 coord_dst.writemask = WRITEMASK_W;
2653 } else {
2654 coord_dst.writemask = WRITEMASK_Z;
2655 }
2656
2657 emit(ir, TGSI_OPCODE_MOV, coord_dst, this->result);
2658 coord_dst.writemask = WRITEMASK_XYZW;
2659 }
2660
2661 if (opcode == TGSI_OPCODE_TXL || opcode == TGSI_OPCODE_TXB ||
2662 opcode == TGSI_OPCODE_TXF) {
2663 /* TGSI stores LOD or LOD bias in the last channel of the coords. */
2664 coord_dst.writemask = WRITEMASK_W;
2665 emit(ir, TGSI_OPCODE_MOV, coord_dst, lod_info);
2666 coord_dst.writemask = WRITEMASK_XYZW;
2667 }
2668
2669 if (opcode == TGSI_OPCODE_TXD)
2670 inst = emit(ir, opcode, result_dst, coord, dx, dy);
2671 else if (opcode == TGSI_OPCODE_TXQ)
2672 inst = emit(ir, opcode, result_dst, lod_info);
2673 else if (opcode == TGSI_OPCODE_TXF) {
2674 inst = emit(ir, opcode, result_dst, coord);
2675 } else
2676 inst = emit(ir, opcode, result_dst, coord);
2677
2678 if (ir->shadow_comparitor)
2679 inst->tex_shadow = GL_TRUE;
2680
2681 inst->sampler = _mesa_get_sampler_uniform_value(ir->sampler,
2682 this->shader_program,
2683 this->prog);
2684
2685 if (ir->offset) {
2686 inst->tex_offset_num_offset = 1;
2687 inst->tex_offsets[0].Index = offset.index;
2688 inst->tex_offsets[0].File = offset.file;
2689 inst->tex_offsets[0].SwizzleX = GET_SWZ(offset.swizzle, 0);
2690 inst->tex_offsets[0].SwizzleY = GET_SWZ(offset.swizzle, 1);
2691 inst->tex_offsets[0].SwizzleZ = GET_SWZ(offset.swizzle, 2);
2692 }
2693
2694 switch (sampler_type->sampler_dimensionality) {
2695 case GLSL_SAMPLER_DIM_1D:
2696 inst->tex_target = (sampler_type->sampler_array)
2697 ? TEXTURE_1D_ARRAY_INDEX : TEXTURE_1D_INDEX;
2698 break;
2699 case GLSL_SAMPLER_DIM_2D:
2700 inst->tex_target = (sampler_type->sampler_array)
2701 ? TEXTURE_2D_ARRAY_INDEX : TEXTURE_2D_INDEX;
2702 break;
2703 case GLSL_SAMPLER_DIM_3D:
2704 inst->tex_target = TEXTURE_3D_INDEX;
2705 break;
2706 case GLSL_SAMPLER_DIM_CUBE:
2707 inst->tex_target = TEXTURE_CUBE_INDEX;
2708 break;
2709 case GLSL_SAMPLER_DIM_RECT:
2710 inst->tex_target = TEXTURE_RECT_INDEX;
2711 break;
2712 case GLSL_SAMPLER_DIM_BUF:
2713 assert(!"FINISHME: Implement ARB_texture_buffer_object");
2714 break;
2715 case GLSL_SAMPLER_DIM_EXTERNAL:
2716 inst->tex_target = TEXTURE_EXTERNAL_INDEX;
2717 break;
2718 default:
2719 assert(!"Should not get here.");
2720 }
2721
2722 this->result = result_src;
2723 }
2724
2725 void
2726 glsl_to_tgsi_visitor::visit(ir_return *ir)
2727 {
2728 if (ir->get_value()) {
2729 st_dst_reg l;
2730 int i;
2731
2732 assert(current_function);
2733
2734 ir->get_value()->accept(this);
2735 st_src_reg r = this->result;
2736
2737 l = st_dst_reg(current_function->return_reg);
2738
2739 for (i = 0; i < type_size(current_function->sig->return_type); i++) {
2740 emit(ir, TGSI_OPCODE_MOV, l, r);
2741 l.index++;
2742 r.index++;
2743 }
2744 }
2745
2746 emit(ir, TGSI_OPCODE_RET);
2747 }
2748
2749 void
2750 glsl_to_tgsi_visitor::visit(ir_discard *ir)
2751 {
2752 struct gl_fragment_program *fp = (struct gl_fragment_program *)this->prog;
2753
2754 if (ir->condition) {
2755 ir->condition->accept(this);
2756 this->result.negate = ~this->result.negate;
2757 emit(ir, TGSI_OPCODE_KIL, undef_dst, this->result);
2758 } else {
2759 emit(ir, TGSI_OPCODE_KILP);
2760 }
2761
2762 fp->UsesKill = GL_TRUE;
2763 }
2764
2765 void
2766 glsl_to_tgsi_visitor::visit(ir_if *ir)
2767 {
2768 glsl_to_tgsi_instruction *cond_inst, *if_inst;
2769 glsl_to_tgsi_instruction *prev_inst;
2770
2771 prev_inst = (glsl_to_tgsi_instruction *)this->instructions.get_tail();
2772
2773 ir->condition->accept(this);
2774 assert(this->result.file != PROGRAM_UNDEFINED);
2775
2776 if (this->options->EmitCondCodes) {
2777 cond_inst = (glsl_to_tgsi_instruction *)this->instructions.get_tail();
2778
2779 /* See if we actually generated any instruction for generating
2780 * the condition. If not, then cook up a move to a temp so we
2781 * have something to set cond_update on.
2782 */
2783 if (cond_inst == prev_inst) {
2784 st_src_reg temp = get_temp(glsl_type::bool_type);
2785 cond_inst = emit(ir->condition, TGSI_OPCODE_MOV, st_dst_reg(temp), result);
2786 }
2787 cond_inst->cond_update = GL_TRUE;
2788
2789 if_inst = emit(ir->condition, TGSI_OPCODE_IF);
2790 if_inst->dst.cond_mask = COND_NE;
2791 } else {
2792 if_inst = emit(ir->condition, TGSI_OPCODE_IF, undef_dst, this->result);
2793 }
2794
2795 this->instructions.push_tail(if_inst);
2796
2797 visit_exec_list(&ir->then_instructions, this);
2798
2799 if (!ir->else_instructions.is_empty()) {
2800 emit(ir->condition, TGSI_OPCODE_ELSE);
2801 visit_exec_list(&ir->else_instructions, this);
2802 }
2803
2804 if_inst = emit(ir->condition, TGSI_OPCODE_ENDIF);
2805 }
2806
2807 glsl_to_tgsi_visitor::glsl_to_tgsi_visitor()
2808 {
2809 result.file = PROGRAM_UNDEFINED;
2810 next_temp = 1;
2811 next_signature_id = 1;
2812 num_immediates = 0;
2813 current_function = NULL;
2814 num_address_regs = 0;
2815 indirect_addr_temps = false;
2816 indirect_addr_consts = false;
2817 mem_ctx = ralloc_context(NULL);
2818 ctx = NULL;
2819 prog = NULL;
2820 shader_program = NULL;
2821 options = NULL;
2822 }
2823
2824 glsl_to_tgsi_visitor::~glsl_to_tgsi_visitor()
2825 {
2826 ralloc_free(mem_ctx);
2827 }
2828
2829 extern "C" void free_glsl_to_tgsi_visitor(glsl_to_tgsi_visitor *v)
2830 {
2831 delete v;
2832 }
2833
2834
2835 /**
2836 * Count resources used by the given gpu program (number of texture
2837 * samplers, etc).
2838 */
2839 static void
2840 count_resources(glsl_to_tgsi_visitor *v, gl_program *prog)
2841 {
2842 v->samplers_used = 0;
2843
2844 foreach_iter(exec_list_iterator, iter, v->instructions) {
2845 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
2846
2847 if (is_tex_instruction(inst->op)) {
2848 v->samplers_used |= 1 << inst->sampler;
2849
2850 if (inst->tex_shadow) {
2851 prog->ShadowSamplers |= 1 << inst->sampler;
2852 }
2853 }
2854 }
2855
2856 prog->SamplersUsed = v->samplers_used;
2857
2858 if (v->shader_program != NULL)
2859 _mesa_update_shader_textures_used(v->shader_program, prog);
2860 }
2861
2862 static void
2863 set_uniform_initializer(struct gl_context *ctx, void *mem_ctx,
2864 struct gl_shader_program *shader_program,
2865 const char *name, const glsl_type *type,
2866 ir_constant *val)
2867 {
2868 if (type->is_record()) {
2869 ir_constant *field_constant;
2870
2871 field_constant = (ir_constant *)val->components.get_head();
2872
2873 for (unsigned int i = 0; i < type->length; i++) {
2874 const glsl_type *field_type = type->fields.structure[i].type;
2875 const char *field_name = ralloc_asprintf(mem_ctx, "%s.%s", name,
2876 type->fields.structure[i].name);
2877 set_uniform_initializer(ctx, mem_ctx, shader_program, field_name,
2878 field_type, field_constant);
2879 field_constant = (ir_constant *)field_constant->next;
2880 }
2881 return;
2882 }
2883
2884 int loc = _mesa_get_uniform_location(ctx, shader_program, name);
2885
2886 if (loc == -1) {
2887 fail_link(shader_program,
2888 "Couldn't find uniform for initializer %s\n", name);
2889 return;
2890 }
2891
2892 for (unsigned int i = 0; i < (type->is_array() ? type->length : 1); i++) {
2893 ir_constant *element;
2894 const glsl_type *element_type;
2895 if (type->is_array()) {
2896 element = val->array_elements[i];
2897 element_type = type->fields.array;
2898 } else {
2899 element = val;
2900 element_type = type;
2901 }
2902
2903 void *values;
2904
2905 if (element_type->base_type == GLSL_TYPE_BOOL) {
2906 int *conv = ralloc_array(mem_ctx, int, element_type->components());
2907 for (unsigned int j = 0; j < element_type->components(); j++) {
2908 conv[j] = element->value.b[j];
2909 }
2910 values = (void *)conv;
2911 element_type = glsl_type::get_instance(GLSL_TYPE_INT,
2912 element_type->vector_elements,
2913 1);
2914 } else {
2915 values = &element->value;
2916 }
2917
2918 if (element_type->is_matrix()) {
2919 _mesa_uniform_matrix(ctx, shader_program,
2920 element_type->matrix_columns,
2921 element_type->vector_elements,
2922 loc, 1, GL_FALSE, (GLfloat *)values);
2923 } else {
2924 _mesa_uniform(ctx, shader_program, loc, element_type->matrix_columns,
2925 values, element_type->gl_type);
2926 }
2927
2928 loc++;
2929 }
2930 }
2931
2932 /**
2933 * Returns the mask of channels (bitmask of WRITEMASK_X,Y,Z,W) which
2934 * are read from the given src in this instruction
2935 */
2936 static int
2937 get_src_arg_mask(st_dst_reg dst, st_src_reg src)
2938 {
2939 int read_mask = 0, comp;
2940
2941 /* Now, given the src swizzle and the written channels, find which
2942 * components are actually read
2943 */
2944 for (comp = 0; comp < 4; ++comp) {
2945 const unsigned coord = GET_SWZ(src.swizzle, comp);
2946 ASSERT(coord < 4);
2947 if (dst.writemask & (1 << comp) && coord <= SWIZZLE_W)
2948 read_mask |= 1 << coord;
2949 }
2950
2951 return read_mask;
2952 }
2953
2954 /**
2955 * This pass replaces CMP T0, T1 T2 T0 with MOV T0, T2 when the CMP
2956 * instruction is the first instruction to write to register T0. There are
2957 * several lowering passes done in GLSL IR (e.g. branches and
2958 * relative addressing) that create a large number of conditional assignments
2959 * that ir_to_mesa converts to CMP instructions like the one mentioned above.
2960 *
2961 * Here is why this conversion is safe:
2962 * CMP T0, T1 T2 T0 can be expanded to:
2963 * if (T1 < 0.0)
2964 * MOV T0, T2;
2965 * else
2966 * MOV T0, T0;
2967 *
2968 * If (T1 < 0.0) evaluates to true then our replacement MOV T0, T2 is the same
2969 * as the original program. If (T1 < 0.0) evaluates to false, executing
2970 * MOV T0, T0 will store a garbage value in T0 since T0 is uninitialized.
2971 * Therefore, it doesn't matter that we are replacing MOV T0, T0 with MOV T0, T2
2972 * because any instruction that was going to read from T0 after this was going
2973 * to read a garbage value anyway.
2974 */
2975 void
2976 glsl_to_tgsi_visitor::simplify_cmp(void)
2977 {
2978 unsigned *tempWrites;
2979 unsigned outputWrites[MAX_PROGRAM_OUTPUTS];
2980
2981 tempWrites = new unsigned[MAX_TEMPS];
2982 if (!tempWrites) {
2983 return;
2984 }
2985 memset(tempWrites, 0, sizeof(unsigned) * MAX_TEMPS);
2986 memset(outputWrites, 0, sizeof(outputWrites));
2987
2988 foreach_iter(exec_list_iterator, iter, this->instructions) {
2989 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
2990 unsigned prevWriteMask = 0;
2991
2992 /* Give up if we encounter relative addressing or flow control. */
2993 if (inst->dst.reladdr ||
2994 tgsi_get_opcode_info(inst->op)->is_branch ||
2995 inst->op == TGSI_OPCODE_BGNSUB ||
2996 inst->op == TGSI_OPCODE_CONT ||
2997 inst->op == TGSI_OPCODE_END ||
2998 inst->op == TGSI_OPCODE_ENDSUB ||
2999 inst->op == TGSI_OPCODE_RET) {
3000 break;
3001 }
3002
3003 if (inst->dst.file == PROGRAM_OUTPUT) {
3004 assert(inst->dst.index < MAX_PROGRAM_OUTPUTS);
3005 prevWriteMask = outputWrites[inst->dst.index];
3006 outputWrites[inst->dst.index] |= inst->dst.writemask;
3007 } else if (inst->dst.file == PROGRAM_TEMPORARY) {
3008 assert(inst->dst.index < MAX_TEMPS);
3009 prevWriteMask = tempWrites[inst->dst.index];
3010 tempWrites[inst->dst.index] |= inst->dst.writemask;
3011 }
3012
3013 /* For a CMP to be considered a conditional write, the destination
3014 * register and source register two must be the same. */
3015 if (inst->op == TGSI_OPCODE_CMP
3016 && !(inst->dst.writemask & prevWriteMask)
3017 && inst->src[2].file == inst->dst.file
3018 && inst->src[2].index == inst->dst.index
3019 && inst->dst.writemask == get_src_arg_mask(inst->dst, inst->src[2])) {
3020
3021 inst->op = TGSI_OPCODE_MOV;
3022 inst->src[0] = inst->src[1];
3023 }
3024 }
3025
3026 delete [] tempWrites;
3027 }
3028
3029 /* Replaces all references to a temporary register index with another index. */
3030 void
3031 glsl_to_tgsi_visitor::rename_temp_register(int index, int new_index)
3032 {
3033 foreach_iter(exec_list_iterator, iter, this->instructions) {
3034 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
3035 unsigned j;
3036
3037 for (j=0; j < num_inst_src_regs(inst->op); j++) {
3038 if (inst->src[j].file == PROGRAM_TEMPORARY &&
3039 inst->src[j].index == index) {
3040 inst->src[j].index = new_index;
3041 }
3042 }
3043
3044 if (inst->dst.file == PROGRAM_TEMPORARY && inst->dst.index == index) {
3045 inst->dst.index = new_index;
3046 }
3047 }
3048 }
3049
3050 int
3051 glsl_to_tgsi_visitor::get_first_temp_read(int index)
3052 {
3053 int depth = 0; /* loop depth */
3054 int loop_start = -1; /* index of the first active BGNLOOP (if any) */
3055 unsigned i = 0, j;
3056
3057 foreach_iter(exec_list_iterator, iter, this->instructions) {
3058 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
3059
3060 for (j=0; j < num_inst_src_regs(inst->op); j++) {
3061 if (inst->src[j].file == PROGRAM_TEMPORARY &&
3062 inst->src[j].index == index) {
3063 return (depth == 0) ? i : loop_start;
3064 }
3065 }
3066
3067 if (inst->op == TGSI_OPCODE_BGNLOOP) {
3068 if(depth++ == 0)
3069 loop_start = i;
3070 } else if (inst->op == TGSI_OPCODE_ENDLOOP) {
3071 if (--depth == 0)
3072 loop_start = -1;
3073 }
3074 assert(depth >= 0);
3075
3076 i++;
3077 }
3078
3079 return -1;
3080 }
3081
3082 int
3083 glsl_to_tgsi_visitor::get_first_temp_write(int index)
3084 {
3085 int depth = 0; /* loop depth */
3086 int loop_start = -1; /* index of the first active BGNLOOP (if any) */
3087 int i = 0;
3088
3089 foreach_iter(exec_list_iterator, iter, this->instructions) {
3090 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
3091
3092 if (inst->dst.file == PROGRAM_TEMPORARY && inst->dst.index == index) {
3093 return (depth == 0) ? i : loop_start;
3094 }
3095
3096 if (inst->op == TGSI_OPCODE_BGNLOOP) {
3097 if(depth++ == 0)
3098 loop_start = i;
3099 } else if (inst->op == TGSI_OPCODE_ENDLOOP) {
3100 if (--depth == 0)
3101 loop_start = -1;
3102 }
3103 assert(depth >= 0);
3104
3105 i++;
3106 }
3107
3108 return -1;
3109 }
3110
3111 int
3112 glsl_to_tgsi_visitor::get_last_temp_read(int index)
3113 {
3114 int depth = 0; /* loop depth */
3115 int last = -1; /* index of last instruction that reads the temporary */
3116 unsigned i = 0, j;
3117
3118 foreach_iter(exec_list_iterator, iter, this->instructions) {
3119 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
3120
3121 for (j=0; j < num_inst_src_regs(inst->op); j++) {
3122 if (inst->src[j].file == PROGRAM_TEMPORARY &&
3123 inst->src[j].index == index) {
3124 last = (depth == 0) ? i : -2;
3125 }
3126 }
3127
3128 if (inst->op == TGSI_OPCODE_BGNLOOP)
3129 depth++;
3130 else if (inst->op == TGSI_OPCODE_ENDLOOP)
3131 if (--depth == 0 && last == -2)
3132 last = i;
3133 assert(depth >= 0);
3134
3135 i++;
3136 }
3137
3138 assert(last >= -1);
3139 return last;
3140 }
3141
3142 int
3143 glsl_to_tgsi_visitor::get_last_temp_write(int index)
3144 {
3145 int depth = 0; /* loop depth */
3146 int last = -1; /* index of last instruction that writes to the temporary */
3147 int i = 0;
3148
3149 foreach_iter(exec_list_iterator, iter, this->instructions) {
3150 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
3151
3152 if (inst->dst.file == PROGRAM_TEMPORARY && inst->dst.index == index)
3153 last = (depth == 0) ? i : -2;
3154
3155 if (inst->op == TGSI_OPCODE_BGNLOOP)
3156 depth++;
3157 else if (inst->op == TGSI_OPCODE_ENDLOOP)
3158 if (--depth == 0 && last == -2)
3159 last = i;
3160 assert(depth >= 0);
3161
3162 i++;
3163 }
3164
3165 assert(last >= -1);
3166 return last;
3167 }
3168
3169 /*
3170 * On a basic block basis, tracks available PROGRAM_TEMPORARY register
3171 * channels for copy propagation and updates following instructions to
3172 * use the original versions.
3173 *
3174 * The glsl_to_tgsi_visitor lazily produces code assuming that this pass
3175 * will occur. As an example, a TXP production before this pass:
3176 *
3177 * 0: MOV TEMP[1], INPUT[4].xyyy;
3178 * 1: MOV TEMP[1].w, INPUT[4].wwww;
3179 * 2: TXP TEMP[2], TEMP[1], texture[0], 2D;
3180 *
3181 * and after:
3182 *
3183 * 0: MOV TEMP[1], INPUT[4].xyyy;
3184 * 1: MOV TEMP[1].w, INPUT[4].wwww;
3185 * 2: TXP TEMP[2], INPUT[4].xyyw, texture[0], 2D;
3186 *
3187 * which allows for dead code elimination on TEMP[1]'s writes.
3188 */
3189 void
3190 glsl_to_tgsi_visitor::copy_propagate(void)
3191 {
3192 glsl_to_tgsi_instruction **acp = rzalloc_array(mem_ctx,
3193 glsl_to_tgsi_instruction *,
3194 this->next_temp * 4);
3195 int *acp_level = rzalloc_array(mem_ctx, int, this->next_temp * 4);
3196 int level = 0;
3197
3198 foreach_iter(exec_list_iterator, iter, this->instructions) {
3199 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
3200
3201 assert(inst->dst.file != PROGRAM_TEMPORARY
3202 || inst->dst.index < this->next_temp);
3203
3204 /* First, do any copy propagation possible into the src regs. */
3205 for (int r = 0; r < 3; r++) {
3206 glsl_to_tgsi_instruction *first = NULL;
3207 bool good = true;
3208 int acp_base = inst->src[r].index * 4;
3209
3210 if (inst->src[r].file != PROGRAM_TEMPORARY ||
3211 inst->src[r].reladdr)
3212 continue;
3213
3214 /* See if we can find entries in the ACP consisting of MOVs
3215 * from the same src register for all the swizzled channels
3216 * of this src register reference.
3217 */
3218 for (int i = 0; i < 4; i++) {
3219 int src_chan = GET_SWZ(inst->src[r].swizzle, i);
3220 glsl_to_tgsi_instruction *copy_chan = acp[acp_base + src_chan];
3221
3222 if (!copy_chan) {
3223 good = false;
3224 break;
3225 }
3226
3227 assert(acp_level[acp_base + src_chan] <= level);
3228
3229 if (!first) {
3230 first = copy_chan;
3231 } else {
3232 if (first->src[0].file != copy_chan->src[0].file ||
3233 first->src[0].index != copy_chan->src[0].index) {
3234 good = false;
3235 break;
3236 }
3237 }
3238 }
3239
3240 if (good) {
3241 /* We've now validated that we can copy-propagate to
3242 * replace this src register reference. Do it.
3243 */
3244 inst->src[r].file = first->src[0].file;
3245 inst->src[r].index = first->src[0].index;
3246
3247 int swizzle = 0;
3248 for (int i = 0; i < 4; i++) {
3249 int src_chan = GET_SWZ(inst->src[r].swizzle, i);
3250 glsl_to_tgsi_instruction *copy_inst = acp[acp_base + src_chan];
3251 swizzle |= (GET_SWZ(copy_inst->src[0].swizzle, src_chan) <<
3252 (3 * i));
3253 }
3254 inst->src[r].swizzle = swizzle;
3255 }
3256 }
3257
3258 switch (inst->op) {
3259 case TGSI_OPCODE_BGNLOOP:
3260 case TGSI_OPCODE_ENDLOOP:
3261 /* End of a basic block, clear the ACP entirely. */
3262 memset(acp, 0, sizeof(*acp) * this->next_temp * 4);
3263 break;
3264
3265 case TGSI_OPCODE_IF:
3266 ++level;
3267 break;
3268
3269 case TGSI_OPCODE_ENDIF:
3270 case TGSI_OPCODE_ELSE:
3271 /* Clear all channels written inside the block from the ACP, but
3272 * leaving those that were not touched.
3273 */
3274 for (int r = 0; r < this->next_temp; r++) {
3275 for (int c = 0; c < 4; c++) {
3276 if (!acp[4 * r + c])
3277 continue;
3278
3279 if (acp_level[4 * r + c] >= level)
3280 acp[4 * r + c] = NULL;
3281 }
3282 }
3283 if (inst->op == TGSI_OPCODE_ENDIF)
3284 --level;
3285 break;
3286
3287 default:
3288 /* Continuing the block, clear any written channels from
3289 * the ACP.
3290 */
3291 if (inst->dst.file == PROGRAM_TEMPORARY && inst->dst.reladdr) {
3292 /* Any temporary might be written, so no copy propagation
3293 * across this instruction.
3294 */
3295 memset(acp, 0, sizeof(*acp) * this->next_temp * 4);
3296 } else if (inst->dst.file == PROGRAM_OUTPUT &&
3297 inst->dst.reladdr) {
3298 /* Any output might be written, so no copy propagation
3299 * from outputs across this instruction.
3300 */
3301 for (int r = 0; r < this->next_temp; r++) {
3302 for (int c = 0; c < 4; c++) {
3303 if (!acp[4 * r + c])
3304 continue;
3305
3306 if (acp[4 * r + c]->src[0].file == PROGRAM_OUTPUT)
3307 acp[4 * r + c] = NULL;
3308 }
3309 }
3310 } else if (inst->dst.file == PROGRAM_TEMPORARY ||
3311 inst->dst.file == PROGRAM_OUTPUT) {
3312 /* Clear where it's used as dst. */
3313 if (inst->dst.file == PROGRAM_TEMPORARY) {
3314 for (int c = 0; c < 4; c++) {
3315 if (inst->dst.writemask & (1 << c)) {
3316 acp[4 * inst->dst.index + c] = NULL;
3317 }
3318 }
3319 }
3320
3321 /* Clear where it's used as src. */
3322 for (int r = 0; r < this->next_temp; r++) {
3323 for (int c = 0; c < 4; c++) {
3324 if (!acp[4 * r + c])
3325 continue;
3326
3327 int src_chan = GET_SWZ(acp[4 * r + c]->src[0].swizzle, c);
3328
3329 if (acp[4 * r + c]->src[0].file == inst->dst.file &&
3330 acp[4 * r + c]->src[0].index == inst->dst.index &&
3331 inst->dst.writemask & (1 << src_chan))
3332 {
3333 acp[4 * r + c] = NULL;
3334 }
3335 }
3336 }
3337 }
3338 break;
3339 }
3340
3341 /* If this is a copy, add it to the ACP. */
3342 if (inst->op == TGSI_OPCODE_MOV &&
3343 inst->dst.file == PROGRAM_TEMPORARY &&
3344 !inst->dst.reladdr &&
3345 !inst->saturate &&
3346 !inst->src[0].reladdr &&
3347 !inst->src[0].negate) {
3348 for (int i = 0; i < 4; i++) {
3349 if (inst->dst.writemask & (1 << i)) {
3350 acp[4 * inst->dst.index + i] = inst;
3351 acp_level[4 * inst->dst.index + i] = level;
3352 }
3353 }
3354 }
3355 }
3356
3357 ralloc_free(acp_level);
3358 ralloc_free(acp);
3359 }
3360
3361 /*
3362 * Tracks available PROGRAM_TEMPORARY registers for dead code elimination.
3363 *
3364 * The glsl_to_tgsi_visitor lazily produces code assuming that this pass
3365 * will occur. As an example, a TXP production after copy propagation but
3366 * before this pass:
3367 *
3368 * 0: MOV TEMP[1], INPUT[4].xyyy;
3369 * 1: MOV TEMP[1].w, INPUT[4].wwww;
3370 * 2: TXP TEMP[2], INPUT[4].xyyw, texture[0], 2D;
3371 *
3372 * and after this pass:
3373 *
3374 * 0: TXP TEMP[2], INPUT[4].xyyw, texture[0], 2D;
3375 *
3376 * FIXME: assumes that all functions are inlined (no support for BGNSUB/ENDSUB)
3377 * FIXME: doesn't eliminate all dead code inside of loops; it steps around them
3378 */
3379 void
3380 glsl_to_tgsi_visitor::eliminate_dead_code(void)
3381 {
3382 int i;
3383
3384 for (i=0; i < this->next_temp; i++) {
3385 int last_read = get_last_temp_read(i);
3386 int j = 0;
3387
3388 foreach_iter(exec_list_iterator, iter, this->instructions) {
3389 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
3390
3391 if (inst->dst.file == PROGRAM_TEMPORARY && inst->dst.index == i &&
3392 j > last_read)
3393 {
3394 iter.remove();
3395 delete inst;
3396 }
3397
3398 j++;
3399 }
3400 }
3401 }
3402
3403 /*
3404 * On a basic block basis, tracks available PROGRAM_TEMPORARY registers for dead
3405 * code elimination. This is less primitive than eliminate_dead_code(), as it
3406 * is per-channel and can detect consecutive writes without a read between them
3407 * as dead code. However, there is some dead code that can be eliminated by
3408 * eliminate_dead_code() but not this function - for example, this function
3409 * cannot eliminate an instruction writing to a register that is never read and
3410 * is the only instruction writing to that register.
3411 *
3412 * The glsl_to_tgsi_visitor lazily produces code assuming that this pass
3413 * will occur.
3414 */
3415 int
3416 glsl_to_tgsi_visitor::eliminate_dead_code_advanced(void)
3417 {
3418 glsl_to_tgsi_instruction **writes = rzalloc_array(mem_ctx,
3419 glsl_to_tgsi_instruction *,
3420 this->next_temp * 4);
3421 int *write_level = rzalloc_array(mem_ctx, int, this->next_temp * 4);
3422 int level = 0;
3423 int removed = 0;
3424
3425 foreach_iter(exec_list_iterator, iter, this->instructions) {
3426 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
3427
3428 assert(inst->dst.file != PROGRAM_TEMPORARY
3429 || inst->dst.index < this->next_temp);
3430
3431 switch (inst->op) {
3432 case TGSI_OPCODE_BGNLOOP:
3433 case TGSI_OPCODE_ENDLOOP:
3434 case TGSI_OPCODE_CONT:
3435 case TGSI_OPCODE_BRK:
3436 /* End of a basic block, clear the write array entirely.
3437 *
3438 * This keeps us from killing dead code when the writes are
3439 * on either side of a loop, even when the register isn't touched
3440 * inside the loop. However, glsl_to_tgsi_visitor doesn't seem to emit
3441 * dead code of this type, so it shouldn't make a difference as long as
3442 * the dead code elimination pass in the GLSL compiler does its job.
3443 */
3444 memset(writes, 0, sizeof(*writes) * this->next_temp * 4);
3445 break;
3446
3447 case TGSI_OPCODE_ENDIF:
3448 case TGSI_OPCODE_ELSE:
3449 /* Promote the recorded level of all channels written inside the
3450 * preceding if or else block to the level above the if/else block.
3451 */
3452 for (int r = 0; r < this->next_temp; r++) {
3453 for (int c = 0; c < 4; c++) {
3454 if (!writes[4 * r + c])
3455 continue;
3456
3457 if (write_level[4 * r + c] == level)
3458 write_level[4 * r + c] = level-1;
3459 }
3460 }
3461
3462 if(inst->op == TGSI_OPCODE_ENDIF)
3463 --level;
3464
3465 break;
3466
3467 case TGSI_OPCODE_IF:
3468 ++level;
3469 /* fallthrough to default case to mark the condition as read */
3470
3471 default:
3472 /* Continuing the block, clear any channels from the write array that
3473 * are read by this instruction.
3474 */
3475 for (unsigned i = 0; i < Elements(inst->src); i++) {
3476 if (inst->src[i].file == PROGRAM_TEMPORARY && inst->src[i].reladdr){
3477 /* Any temporary might be read, so no dead code elimination
3478 * across this instruction.
3479 */
3480 memset(writes, 0, sizeof(*writes) * this->next_temp * 4);
3481 } else if (inst->src[i].file == PROGRAM_TEMPORARY) {
3482 /* Clear where it's used as src. */
3483 int src_chans = 1 << GET_SWZ(inst->src[i].swizzle, 0);
3484 src_chans |= 1 << GET_SWZ(inst->src[i].swizzle, 1);
3485 src_chans |= 1 << GET_SWZ(inst->src[i].swizzle, 2);
3486 src_chans |= 1 << GET_SWZ(inst->src[i].swizzle, 3);
3487
3488 for (int c = 0; c < 4; c++) {
3489 if (src_chans & (1 << c)) {
3490 writes[4 * inst->src[i].index + c] = NULL;
3491 }
3492 }
3493 }
3494 }
3495 break;
3496 }
3497
3498 /* If this instruction writes to a temporary, add it to the write array.
3499 * If there is already an instruction in the write array for one or more
3500 * of the channels, flag that channel write as dead.
3501 */
3502 if (inst->dst.file == PROGRAM_TEMPORARY &&
3503 !inst->dst.reladdr &&
3504 !inst->saturate) {
3505 for (int c = 0; c < 4; c++) {
3506 if (inst->dst.writemask & (1 << c)) {
3507 if (writes[4 * inst->dst.index + c]) {
3508 if (write_level[4 * inst->dst.index + c] < level)
3509 continue;
3510 else
3511 writes[4 * inst->dst.index + c]->dead_mask |= (1 << c);
3512 }
3513 writes[4 * inst->dst.index + c] = inst;
3514 write_level[4 * inst->dst.index + c] = level;
3515 }
3516 }
3517 }
3518 }
3519
3520 /* Anything still in the write array at this point is dead code. */
3521 for (int r = 0; r < this->next_temp; r++) {
3522 for (int c = 0; c < 4; c++) {
3523 glsl_to_tgsi_instruction *inst = writes[4 * r + c];
3524 if (inst)
3525 inst->dead_mask |= (1 << c);
3526 }
3527 }
3528
3529 /* Now actually remove the instructions that are completely dead and update
3530 * the writemask of other instructions with dead channels.
3531 */
3532 foreach_iter(exec_list_iterator, iter, this->instructions) {
3533 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
3534
3535 if (!inst->dead_mask || !inst->dst.writemask)
3536 continue;
3537 else if ((inst->dst.writemask & ~inst->dead_mask) == 0) {
3538 iter.remove();
3539 delete inst;
3540 removed++;
3541 } else
3542 inst->dst.writemask &= ~(inst->dead_mask);
3543 }
3544
3545 ralloc_free(write_level);
3546 ralloc_free(writes);
3547
3548 return removed;
3549 }
3550
3551 /* Merges temporary registers together where possible to reduce the number of
3552 * registers needed to run a program.
3553 *
3554 * Produces optimal code only after copy propagation and dead code elimination
3555 * have been run. */
3556 void
3557 glsl_to_tgsi_visitor::merge_registers(void)
3558 {
3559 int *last_reads = rzalloc_array(mem_ctx, int, this->next_temp);
3560 int *first_writes = rzalloc_array(mem_ctx, int, this->next_temp);
3561 int i, j;
3562
3563 /* Read the indices of the last read and first write to each temp register
3564 * into an array so that we don't have to traverse the instruction list as
3565 * much. */
3566 for (i=0; i < this->next_temp; i++) {
3567 last_reads[i] = get_last_temp_read(i);
3568 first_writes[i] = get_first_temp_write(i);
3569 }
3570
3571 /* Start looking for registers with non-overlapping usages that can be
3572 * merged together. */
3573 for (i=0; i < this->next_temp; i++) {
3574 /* Don't touch unused registers. */
3575 if (last_reads[i] < 0 || first_writes[i] < 0) continue;
3576
3577 for (j=0; j < this->next_temp; j++) {
3578 /* Don't touch unused registers. */
3579 if (last_reads[j] < 0 || first_writes[j] < 0) continue;
3580
3581 /* We can merge the two registers if the first write to j is after or
3582 * in the same instruction as the last read from i. Note that the
3583 * register at index i will always be used earlier or at the same time
3584 * as the register at index j. */
3585 if (first_writes[i] <= first_writes[j] &&
3586 last_reads[i] <= first_writes[j])
3587 {
3588 rename_temp_register(j, i); /* Replace all references to j with i.*/
3589
3590 /* Update the first_writes and last_reads arrays with the new
3591 * values for the merged register index, and mark the newly unused
3592 * register index as such. */
3593 last_reads[i] = last_reads[j];
3594 first_writes[j] = -1;
3595 last_reads[j] = -1;
3596 }
3597 }
3598 }
3599
3600 ralloc_free(last_reads);
3601 ralloc_free(first_writes);
3602 }
3603
3604 /* Reassign indices to temporary registers by reusing unused indices created
3605 * by optimization passes. */
3606 void
3607 glsl_to_tgsi_visitor::renumber_registers(void)
3608 {
3609 int i = 0;
3610 int new_index = 0;
3611
3612 for (i=0; i < this->next_temp; i++) {
3613 if (get_first_temp_read(i) < 0) continue;
3614 if (i != new_index)
3615 rename_temp_register(i, new_index);
3616 new_index++;
3617 }
3618
3619 this->next_temp = new_index;
3620 }
3621
3622 /**
3623 * Returns a fragment program which implements the current pixel transfer ops.
3624 * Based on get_pixel_transfer_program in st_atom_pixeltransfer.c.
3625 */
3626 extern "C" void
3627 get_pixel_transfer_visitor(struct st_fragment_program *fp,
3628 glsl_to_tgsi_visitor *original,
3629 int scale_and_bias, int pixel_maps)
3630 {
3631 glsl_to_tgsi_visitor *v = new glsl_to_tgsi_visitor();
3632 struct st_context *st = st_context(original->ctx);
3633 struct gl_program *prog = &fp->Base.Base;
3634 struct gl_program_parameter_list *params = _mesa_new_parameter_list();
3635 st_src_reg coord, src0;
3636 st_dst_reg dst0;
3637 glsl_to_tgsi_instruction *inst;
3638
3639 /* Copy attributes of the glsl_to_tgsi_visitor in the original shader. */
3640 v->ctx = original->ctx;
3641 v->prog = prog;
3642 v->shader_program = NULL;
3643 v->glsl_version = original->glsl_version;
3644 v->native_integers = original->native_integers;
3645 v->options = original->options;
3646 v->next_temp = original->next_temp;
3647 v->num_address_regs = original->num_address_regs;
3648 v->samplers_used = prog->SamplersUsed = original->samplers_used;
3649 v->indirect_addr_temps = original->indirect_addr_temps;
3650 v->indirect_addr_consts = original->indirect_addr_consts;
3651 memcpy(&v->immediates, &original->immediates, sizeof(v->immediates));
3652 v->num_immediates = original->num_immediates;
3653
3654 /*
3655 * Get initial pixel color from the texture.
3656 * TEX colorTemp, fragment.texcoord[0], texture[0], 2D;
3657 */
3658 coord = st_src_reg(PROGRAM_INPUT, FRAG_ATTRIB_TEX0, glsl_type::vec2_type);
3659 src0 = v->get_temp(glsl_type::vec4_type);
3660 dst0 = st_dst_reg(src0);
3661 inst = v->emit(NULL, TGSI_OPCODE_TEX, dst0, coord);
3662 inst->sampler = 0;
3663 inst->tex_target = TEXTURE_2D_INDEX;
3664
3665 prog->InputsRead |= FRAG_BIT_TEX0;
3666 prog->SamplersUsed |= (1 << 0); /* mark sampler 0 as used */
3667 v->samplers_used |= (1 << 0);
3668
3669 if (scale_and_bias) {
3670 static const gl_state_index scale_state[STATE_LENGTH] =
3671 { STATE_INTERNAL, STATE_PT_SCALE,
3672 (gl_state_index) 0, (gl_state_index) 0, (gl_state_index) 0 };
3673 static const gl_state_index bias_state[STATE_LENGTH] =
3674 { STATE_INTERNAL, STATE_PT_BIAS,
3675 (gl_state_index) 0, (gl_state_index) 0, (gl_state_index) 0 };
3676 GLint scale_p, bias_p;
3677 st_src_reg scale, bias;
3678
3679 scale_p = _mesa_add_state_reference(params, scale_state);
3680 bias_p = _mesa_add_state_reference(params, bias_state);
3681
3682 /* MAD colorTemp, colorTemp, scale, bias; */
3683 scale = st_src_reg(PROGRAM_STATE_VAR, scale_p, GLSL_TYPE_FLOAT);
3684 bias = st_src_reg(PROGRAM_STATE_VAR, bias_p, GLSL_TYPE_FLOAT);
3685 inst = v->emit(NULL, TGSI_OPCODE_MAD, dst0, src0, scale, bias);
3686 }
3687
3688 if (pixel_maps) {
3689 st_src_reg temp = v->get_temp(glsl_type::vec4_type);
3690 st_dst_reg temp_dst = st_dst_reg(temp);
3691
3692 assert(st->pixel_xfer.pixelmap_texture);
3693
3694 /* With a little effort, we can do four pixel map look-ups with
3695 * two TEX instructions:
3696 */
3697
3698 /* TEX temp.rg, colorTemp.rgba, texture[1], 2D; */
3699 temp_dst.writemask = WRITEMASK_XY; /* write R,G */
3700 inst = v->emit(NULL, TGSI_OPCODE_TEX, temp_dst, src0);
3701 inst->sampler = 1;
3702 inst->tex_target = TEXTURE_2D_INDEX;
3703
3704 /* TEX temp.ba, colorTemp.baba, texture[1], 2D; */
3705 src0.swizzle = MAKE_SWIZZLE4(SWIZZLE_Z, SWIZZLE_W, SWIZZLE_Z, SWIZZLE_W);
3706 temp_dst.writemask = WRITEMASK_ZW; /* write B,A */
3707 inst = v->emit(NULL, TGSI_OPCODE_TEX, temp_dst, src0);
3708 inst->sampler = 1;
3709 inst->tex_target = TEXTURE_2D_INDEX;
3710
3711 prog->SamplersUsed |= (1 << 1); /* mark sampler 1 as used */
3712 v->samplers_used |= (1 << 1);
3713
3714 /* MOV colorTemp, temp; */
3715 inst = v->emit(NULL, TGSI_OPCODE_MOV, dst0, temp);
3716 }
3717
3718 /* Now copy the instructions from the original glsl_to_tgsi_visitor into the
3719 * new visitor. */
3720 foreach_iter(exec_list_iterator, iter, original->instructions) {
3721 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
3722 glsl_to_tgsi_instruction *newinst;
3723 st_src_reg src_regs[3];
3724
3725 if (inst->dst.file == PROGRAM_OUTPUT)
3726 prog->OutputsWritten |= BITFIELD64_BIT(inst->dst.index);
3727
3728 for (int i=0; i<3; i++) {
3729 src_regs[i] = inst->src[i];
3730 if (src_regs[i].file == PROGRAM_INPUT &&
3731 src_regs[i].index == FRAG_ATTRIB_COL0)
3732 {
3733 src_regs[i].file = PROGRAM_TEMPORARY;
3734 src_regs[i].index = src0.index;
3735 }
3736 else if (src_regs[i].file == PROGRAM_INPUT)
3737 prog->InputsRead |= BITFIELD64_BIT(src_regs[i].index);
3738 }
3739
3740 newinst = v->emit(NULL, inst->op, inst->dst, src_regs[0], src_regs[1], src_regs[2]);
3741 newinst->tex_target = inst->tex_target;
3742 }
3743
3744 /* Make modifications to fragment program info. */
3745 prog->Parameters = _mesa_combine_parameter_lists(params,
3746 original->prog->Parameters);
3747 _mesa_free_parameter_list(params);
3748 count_resources(v, prog);
3749 fp->glsl_to_tgsi = v;
3750 }
3751
3752 /**
3753 * Make fragment program for glBitmap:
3754 * Sample the texture and kill the fragment if the bit is 0.
3755 * This program will be combined with the user's fragment program.
3756 *
3757 * Based on make_bitmap_fragment_program in st_cb_bitmap.c.
3758 */
3759 extern "C" void
3760 get_bitmap_visitor(struct st_fragment_program *fp,
3761 glsl_to_tgsi_visitor *original, int samplerIndex)
3762 {
3763 glsl_to_tgsi_visitor *v = new glsl_to_tgsi_visitor();
3764 struct st_context *st = st_context(original->ctx);
3765 struct gl_program *prog = &fp->Base.Base;
3766 st_src_reg coord, src0;
3767 st_dst_reg dst0;
3768 glsl_to_tgsi_instruction *inst;
3769
3770 /* Copy attributes of the glsl_to_tgsi_visitor in the original shader. */
3771 v->ctx = original->ctx;
3772 v->prog = prog;
3773 v->shader_program = NULL;
3774 v->glsl_version = original->glsl_version;
3775 v->native_integers = original->native_integers;
3776 v->options = original->options;
3777 v->next_temp = original->next_temp;
3778 v->num_address_regs = original->num_address_regs;
3779 v->samplers_used = prog->SamplersUsed = original->samplers_used;
3780 v->indirect_addr_temps = original->indirect_addr_temps;
3781 v->indirect_addr_consts = original->indirect_addr_consts;
3782 memcpy(&v->immediates, &original->immediates, sizeof(v->immediates));
3783 v->num_immediates = original->num_immediates;
3784
3785 /* TEX tmp0, fragment.texcoord[0], texture[0], 2D; */
3786 coord = st_src_reg(PROGRAM_INPUT, FRAG_ATTRIB_TEX0, glsl_type::vec2_type);
3787 src0 = v->get_temp(glsl_type::vec4_type);
3788 dst0 = st_dst_reg(src0);
3789 inst = v->emit(NULL, TGSI_OPCODE_TEX, dst0, coord);
3790 inst->sampler = samplerIndex;
3791 inst->tex_target = TEXTURE_2D_INDEX;
3792
3793 prog->InputsRead |= FRAG_BIT_TEX0;
3794 prog->SamplersUsed |= (1 << samplerIndex); /* mark sampler as used */
3795 v->samplers_used |= (1 << samplerIndex);
3796
3797 /* KIL if -tmp0 < 0 # texel=0 -> keep / texel=0 -> discard */
3798 src0.negate = NEGATE_XYZW;
3799 if (st->bitmap.tex_format == PIPE_FORMAT_L8_UNORM)
3800 src0.swizzle = SWIZZLE_XXXX;
3801 inst = v->emit(NULL, TGSI_OPCODE_KIL, undef_dst, src0);
3802
3803 /* Now copy the instructions from the original glsl_to_tgsi_visitor into the
3804 * new visitor. */
3805 foreach_iter(exec_list_iterator, iter, original->instructions) {
3806 glsl_to_tgsi_instruction *inst = (glsl_to_tgsi_instruction *)iter.get();
3807 glsl_to_tgsi_instruction *newinst;
3808 st_src_reg src_regs[3];
3809
3810 if (inst->dst.file == PROGRAM_OUTPUT)
3811 prog->OutputsWritten |= BITFIELD64_BIT(inst->dst.index);
3812
3813 for (int i=0; i<3; i++) {
3814 src_regs[i] = inst->src[i];
3815 if (src_regs[i].file == PROGRAM_INPUT)
3816 prog->InputsRead |= BITFIELD64_BIT(src_regs[i].index);
3817 }
3818
3819 newinst = v->emit(NULL, inst->op, inst->dst, src_regs[0], src_regs[1], src_regs[2]);
3820 newinst->tex_target = inst->tex_target;
3821 }
3822
3823 /* Make modifications to fragment program info. */
3824 prog->Parameters = _mesa_clone_parameter_list(original->prog->Parameters);
3825 count_resources(v, prog);
3826 fp->glsl_to_tgsi = v;
3827 }
3828
3829 /* ------------------------- TGSI conversion stuff -------------------------- */
3830 struct label {
3831 unsigned branch_target;
3832 unsigned token;
3833 };
3834
3835 /**
3836 * Intermediate state used during shader translation.
3837 */
3838 struct st_translate {
3839 struct ureg_program *ureg;
3840
3841 struct ureg_dst temps[MAX_TEMPS];
3842 struct ureg_src *constants;
3843 struct ureg_src *immediates;
3844 struct ureg_dst outputs[PIPE_MAX_SHADER_OUTPUTS];
3845 struct ureg_src inputs[PIPE_MAX_SHADER_INPUTS];
3846 struct ureg_dst address[1];
3847 struct ureg_src samplers[PIPE_MAX_SAMPLERS];
3848 struct ureg_src systemValues[SYSTEM_VALUE_MAX];
3849
3850 const GLuint *inputMapping;
3851 const GLuint *outputMapping;
3852
3853 /* For every instruction that contains a label (eg CALL), keep
3854 * details so that we can go back afterwards and emit the correct
3855 * tgsi instruction number for each label.
3856 */
3857 struct label *labels;
3858 unsigned labels_size;
3859 unsigned labels_count;
3860
3861 /* Keep a record of the tgsi instruction number that each mesa
3862 * instruction starts at, will be used to fix up labels after
3863 * translation.
3864 */
3865 unsigned *insn;
3866 unsigned insn_size;
3867 unsigned insn_count;
3868
3869 unsigned procType; /**< TGSI_PROCESSOR_VERTEX/FRAGMENT */
3870
3871 boolean error;
3872 };
3873
3874 /** Map Mesa's SYSTEM_VALUE_x to TGSI_SEMANTIC_x */
3875 static unsigned mesa_sysval_to_semantic[SYSTEM_VALUE_MAX] = {
3876 TGSI_SEMANTIC_FACE,
3877 TGSI_SEMANTIC_VERTEXID,
3878 TGSI_SEMANTIC_INSTANCEID
3879 };
3880
3881 /**
3882 * Make note of a branch to a label in the TGSI code.
3883 * After we've emitted all instructions, we'll go over the list
3884 * of labels built here and patch the TGSI code with the actual
3885 * location of each label.
3886 */
3887 static unsigned *get_label(struct st_translate *t, unsigned branch_target)
3888 {
3889 unsigned i;
3890
3891 if (t->labels_count + 1 >= t->labels_size) {
3892 t->labels_size = 1 << (util_logbase2(t->labels_size) + 1);
3893 t->labels = (struct label *)realloc(t->labels,
3894 t->labels_size * sizeof(struct label));
3895 if (t->labels == NULL) {
3896 static unsigned dummy;
3897 t->error = TRUE;
3898 return &dummy;
3899 }
3900 }
3901
3902 i = t->labels_count++;
3903 t->labels[i].branch_target = branch_target;
3904 return &t->labels[i].token;
3905 }
3906
3907 /**
3908 * Called prior to emitting the TGSI code for each instruction.
3909 * Allocate additional space for instructions if needed.
3910 * Update the insn[] array so the next glsl_to_tgsi_instruction points to
3911 * the next TGSI instruction.
3912 */
3913 static void set_insn_start(struct st_translate *t, unsigned start)
3914 {
3915 if (t->insn_count + 1 >= t->insn_size) {
3916 t->insn_size = 1 << (util_logbase2(t->insn_size) + 1);
3917 t->insn = (unsigned *)realloc(t->insn, t->insn_size * sizeof(t->insn[0]));
3918 if (t->insn == NULL) {
3919 t->error = TRUE;
3920 return;
3921 }
3922 }
3923
3924 t->insn[t->insn_count++] = start;
3925 }
3926
3927 /**
3928 * Map a glsl_to_tgsi constant/immediate to a TGSI immediate.
3929 */
3930 static struct ureg_src
3931 emit_immediate(struct st_translate *t,
3932 gl_constant_value values[4],
3933 int type, int size)
3934 {
3935 struct ureg_program *ureg = t->ureg;
3936
3937 switch(type)
3938 {
3939 case GL_FLOAT:
3940 return ureg_DECL_immediate(ureg, &values[0].f, size);
3941 case GL_INT:
3942 return ureg_DECL_immediate_int(ureg, &values[0].i, size);
3943 case GL_UNSIGNED_INT:
3944 case GL_BOOL:
3945 return ureg_DECL_immediate_uint(ureg, &values[0].u, size);
3946 default:
3947 assert(!"should not get here - type must be float, int, uint, or bool");
3948 return ureg_src_undef();
3949 }
3950 }
3951
3952 /**
3953 * Map a glsl_to_tgsi dst register to a TGSI ureg_dst register.
3954 */
3955 static struct ureg_dst
3956 dst_register(struct st_translate *t,
3957 gl_register_file file,
3958 GLuint index)
3959 {
3960 switch(file) {
3961 case PROGRAM_UNDEFINED:
3962 return ureg_dst_undef();
3963
3964 case PROGRAM_TEMPORARY:
3965 if (ureg_dst_is_undef(t->temps[index]))
3966 t->temps[index] = ureg_DECL_temporary(t->ureg);
3967
3968 return t->temps[index];
3969
3970 case PROGRAM_OUTPUT:
3971 if (t->procType == TGSI_PROCESSOR_VERTEX)
3972 assert(index < VERT_RESULT_MAX);
3973 else if (t->procType == TGSI_PROCESSOR_FRAGMENT)
3974 assert(index < FRAG_RESULT_MAX);
3975 else
3976 assert(index < GEOM_RESULT_MAX);
3977
3978 assert(t->outputMapping[index] < Elements(t->outputs));
3979
3980 return t->outputs[t->outputMapping[index]];
3981
3982 case PROGRAM_ADDRESS:
3983 return t->address[index];
3984
3985 default:
3986 assert(!"unknown dst register file");
3987 return ureg_dst_undef();
3988 }
3989 }
3990
3991 /**
3992 * Map a glsl_to_tgsi src register to a TGSI ureg_src register.
3993 */
3994 static struct ureg_src
3995 src_register(struct st_translate *t,
3996 gl_register_file file,
3997 GLuint index)
3998 {
3999 switch(file) {
4000 case PROGRAM_UNDEFINED:
4001 return ureg_src_undef();
4002
4003 case PROGRAM_TEMPORARY:
4004 assert(index >= 0);
4005 assert(index < Elements(t->temps));
4006 if (ureg_dst_is_undef(t->temps[index]))
4007 t->temps[index] = ureg_DECL_temporary(t->ureg);
4008 return ureg_src(t->temps[index]);
4009
4010 case PROGRAM_NAMED_PARAM:
4011 case PROGRAM_ENV_PARAM:
4012 case PROGRAM_LOCAL_PARAM:
4013 case PROGRAM_UNIFORM:
4014 assert(index >= 0);
4015 return t->constants[index];
4016 case PROGRAM_STATE_VAR:
4017 case PROGRAM_CONSTANT: /* ie, immediate */
4018 if (index < 0)
4019 return ureg_DECL_constant(t->ureg, 0);
4020 else
4021 return t->constants[index];
4022
4023 case PROGRAM_IMMEDIATE:
4024 return t->immediates[index];
4025
4026 case PROGRAM_INPUT:
4027 assert(t->inputMapping[index] < Elements(t->inputs));
4028 return t->inputs[t->inputMapping[index]];
4029
4030 case PROGRAM_OUTPUT:
4031 assert(t->outputMapping[index] < Elements(t->outputs));
4032 return ureg_src(t->outputs[t->outputMapping[index]]); /* not needed? */
4033
4034 case PROGRAM_ADDRESS:
4035 return ureg_src(t->address[index]);
4036
4037 case PROGRAM_SYSTEM_VALUE:
4038 assert(index < Elements(t->systemValues));
4039 return t->systemValues[index];
4040
4041 default:
4042 assert(!"unknown src register file");
4043 return ureg_src_undef();
4044 }
4045 }
4046
4047 /**
4048 * Create a TGSI ureg_dst register from an st_dst_reg.
4049 */
4050 static struct ureg_dst
4051 translate_dst(struct st_translate *t,
4052 const st_dst_reg *dst_reg,
4053 bool saturate, bool clamp_color)
4054 {
4055 struct ureg_dst dst = dst_register(t,
4056 dst_reg->file,
4057 dst_reg->index);
4058
4059 dst = ureg_writemask(dst, dst_reg->writemask);
4060
4061 if (saturate)
4062 dst = ureg_saturate(dst);
4063 else if (clamp_color && dst_reg->file == PROGRAM_OUTPUT) {
4064 /* Clamp colors for ARB_color_buffer_float. */
4065 switch (t->procType) {
4066 case TGSI_PROCESSOR_VERTEX:
4067 /* XXX if the geometry shader is present, this must be done there
4068 * instead of here. */
4069 if (dst_reg->index == VERT_RESULT_COL0 ||
4070 dst_reg->index == VERT_RESULT_COL1 ||
4071 dst_reg->index == VERT_RESULT_BFC0 ||
4072 dst_reg->index == VERT_RESULT_BFC1) {
4073 dst = ureg_saturate(dst);
4074 }
4075 break;
4076
4077 case TGSI_PROCESSOR_FRAGMENT:
4078 if (dst_reg->index >= FRAG_RESULT_COLOR) {
4079 dst = ureg_saturate(dst);
4080 }
4081 break;
4082 }
4083 }
4084
4085 if (dst_reg->reladdr != NULL)
4086 dst = ureg_dst_indirect(dst, ureg_src(t->address[0]));
4087
4088 return dst;
4089 }
4090
4091 /**
4092 * Create a TGSI ureg_src register from an st_src_reg.
4093 */
4094 static struct ureg_src
4095 translate_src(struct st_translate *t, const st_src_reg *src_reg)
4096 {
4097 struct ureg_src src = src_register(t, src_reg->file, src_reg->index);
4098
4099 src = ureg_swizzle(src,
4100 GET_SWZ(src_reg->swizzle, 0) & 0x3,
4101 GET_SWZ(src_reg->swizzle, 1) & 0x3,
4102 GET_SWZ(src_reg->swizzle, 2) & 0x3,
4103 GET_SWZ(src_reg->swizzle, 3) & 0x3);
4104
4105 if ((src_reg->negate & 0xf) == NEGATE_XYZW)
4106 src = ureg_negate(src);
4107
4108 if (src_reg->reladdr != NULL) {
4109 /* Normally ureg_src_indirect() would be used here, but a stupid compiler
4110 * bug in g++ makes ureg_src_indirect (an inline C function) erroneously
4111 * set the bit for src.Negate. So we have to do the operation manually
4112 * here to work around the compiler's problems. */
4113 /*src = ureg_src_indirect(src, ureg_src(t->address[0]));*/
4114 struct ureg_src addr = ureg_src(t->address[0]);
4115 src.Indirect = 1;
4116 src.IndirectFile = addr.File;
4117 src.IndirectIndex = addr.Index;
4118 src.IndirectSwizzle = addr.SwizzleX;
4119
4120 if (src_reg->file != PROGRAM_INPUT &&
4121 src_reg->file != PROGRAM_OUTPUT) {
4122 /* If src_reg->index was negative, it was set to zero in
4123 * src_register(). Reassign it now. But don't do this
4124 * for input/output regs since they get remapped while
4125 * const buffers don't.
4126 */
4127 src.Index = src_reg->index;
4128 }
4129 }
4130
4131 return src;
4132 }
4133
4134 static struct tgsi_texture_offset
4135 translate_tex_offset(struct st_translate *t,
4136 const struct tgsi_texture_offset *in_offset)
4137 {
4138 struct tgsi_texture_offset offset;
4139
4140 assert(in_offset->File == PROGRAM_IMMEDIATE);
4141
4142 offset.File = TGSI_FILE_IMMEDIATE;
4143 offset.Index = in_offset->Index;
4144 offset.SwizzleX = in_offset->SwizzleX;
4145 offset.SwizzleY = in_offset->SwizzleY;
4146 offset.SwizzleZ = in_offset->SwizzleZ;
4147
4148 return offset;
4149 }
4150
4151 static void
4152 compile_tgsi_instruction(struct st_translate *t,
4153 const glsl_to_tgsi_instruction *inst,
4154 bool clamp_dst_color_output)
4155 {
4156 struct ureg_program *ureg = t->ureg;
4157 GLuint i;
4158 struct ureg_dst dst[1];
4159 struct ureg_src src[4];
4160 struct tgsi_texture_offset texoffsets[MAX_GLSL_TEXTURE_OFFSET];
4161
4162 unsigned num_dst;
4163 unsigned num_src;
4164
4165 num_dst = num_inst_dst_regs(inst->op);
4166 num_src = num_inst_src_regs(inst->op);
4167
4168 if (num_dst)
4169 dst[0] = translate_dst(t,
4170 &inst->dst,
4171 inst->saturate,
4172 clamp_dst_color_output);
4173
4174 for (i = 0; i < num_src; i++)
4175 src[i] = translate_src(t, &inst->src[i]);
4176
4177 switch(inst->op) {
4178 case TGSI_OPCODE_BGNLOOP:
4179 case TGSI_OPCODE_CAL:
4180 case TGSI_OPCODE_ELSE:
4181 case TGSI_OPCODE_ENDLOOP:
4182 case TGSI_OPCODE_IF:
4183 assert(num_dst == 0);
4184 ureg_label_insn(ureg,
4185 inst->op,
4186 src, num_src,
4187 get_label(t,
4188 inst->op == TGSI_OPCODE_CAL ? inst->function->sig_id : 0));
4189 return;
4190
4191 case TGSI_OPCODE_TEX:
4192 case TGSI_OPCODE_TXB:
4193 case TGSI_OPCODE_TXD:
4194 case TGSI_OPCODE_TXL:
4195 case TGSI_OPCODE_TXP:
4196 case TGSI_OPCODE_TXQ:
4197 case TGSI_OPCODE_TXF:
4198 src[num_src++] = t->samplers[inst->sampler];
4199 for (i = 0; i < inst->tex_offset_num_offset; i++) {
4200 texoffsets[i] = translate_tex_offset(t, &inst->tex_offsets[i]);
4201 }
4202 ureg_tex_insn(ureg,
4203 inst->op,
4204 dst, num_dst,
4205 st_translate_texture_target(inst->tex_target, inst->tex_shadow),
4206 texoffsets, inst->tex_offset_num_offset,
4207 src, num_src);
4208 return;
4209
4210 case TGSI_OPCODE_SCS:
4211 dst[0] = ureg_writemask(dst[0], TGSI_WRITEMASK_XY);
4212 ureg_insn(ureg, inst->op, dst, num_dst, src, num_src);
4213 break;
4214
4215 default:
4216 ureg_insn(ureg,
4217 inst->op,
4218 dst, num_dst,
4219 src, num_src);
4220 break;
4221 }
4222 }
4223
4224 /**
4225 * Emit the TGSI instructions for inverting and adjusting WPOS.
4226 * This code is unavoidable because it also depends on whether
4227 * a FBO is bound (STATE_FB_WPOS_Y_TRANSFORM).
4228 */
4229 static void
4230 emit_wpos_adjustment( struct st_translate *t,
4231 const struct gl_program *program,
4232 boolean invert,
4233 GLfloat adjX, GLfloat adjY[2])
4234 {
4235 struct ureg_program *ureg = t->ureg;
4236
4237 /* Fragment program uses fragment position input.
4238 * Need to replace instances of INPUT[WPOS] with temp T
4239 * where T = INPUT[WPOS] by y is inverted.
4240 */
4241 static const gl_state_index wposTransformState[STATE_LENGTH]
4242 = { STATE_INTERNAL, STATE_FB_WPOS_Y_TRANSFORM,
4243 (gl_state_index)0, (gl_state_index)0, (gl_state_index)0 };
4244
4245 /* XXX: note we are modifying the incoming shader here! Need to
4246 * do this before emitting the constant decls below, or this
4247 * will be missed:
4248 */
4249 unsigned wposTransConst = _mesa_add_state_reference(program->Parameters,
4250 wposTransformState);
4251
4252 struct ureg_src wpostrans = ureg_DECL_constant( ureg, wposTransConst );
4253 struct ureg_dst wpos_temp = ureg_DECL_temporary( ureg );
4254 struct ureg_src wpos_input = t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]];
4255
4256 /* First, apply the coordinate shift: */
4257 if (adjX || adjY[0] || adjY[1]) {
4258 if (adjY[0] != adjY[1]) {
4259 /* Adjust the y coordinate by adjY[1] or adjY[0] respectively
4260 * depending on whether inversion is actually going to be applied
4261 * or not, which is determined by testing against the inversion
4262 * state variable used below, which will be either +1 or -1.
4263 */
4264 struct ureg_dst adj_temp = ureg_DECL_temporary(ureg);
4265
4266 ureg_CMP(ureg, adj_temp,
4267 ureg_scalar(wpostrans, invert ? 2 : 0),
4268 ureg_imm4f(ureg, adjX, adjY[0], 0.0f, 0.0f),
4269 ureg_imm4f(ureg, adjX, adjY[1], 0.0f, 0.0f));
4270 ureg_ADD(ureg, wpos_temp, wpos_input, ureg_src(adj_temp));
4271 } else {
4272 ureg_ADD(ureg, wpos_temp, wpos_input,
4273 ureg_imm4f(ureg, adjX, adjY[0], 0.0f, 0.0f));
4274 }
4275 wpos_input = ureg_src(wpos_temp);
4276 } else {
4277 /* MOV wpos_temp, input[wpos]
4278 */
4279 ureg_MOV( ureg, wpos_temp, wpos_input );
4280 }
4281
4282 /* Now the conditional y flip: STATE_FB_WPOS_Y_TRANSFORM.xy/zw will be
4283 * inversion/identity, or the other way around if we're drawing to an FBO.
4284 */
4285 if (invert) {
4286 /* MAD wpos_temp.y, wpos_input, wpostrans.xxxx, wpostrans.yyyy
4287 */
4288 ureg_MAD( ureg,
4289 ureg_writemask(wpos_temp, TGSI_WRITEMASK_Y ),
4290 wpos_input,
4291 ureg_scalar(wpostrans, 0),
4292 ureg_scalar(wpostrans, 1));
4293 } else {
4294 /* MAD wpos_temp.y, wpos_input, wpostrans.zzzz, wpostrans.wwww
4295 */
4296 ureg_MAD( ureg,
4297 ureg_writemask(wpos_temp, TGSI_WRITEMASK_Y ),
4298 wpos_input,
4299 ureg_scalar(wpostrans, 2),
4300 ureg_scalar(wpostrans, 3));
4301 }
4302
4303 /* Use wpos_temp as position input from here on:
4304 */
4305 t->inputs[t->inputMapping[FRAG_ATTRIB_WPOS]] = ureg_src(wpos_temp);
4306 }
4307
4308
4309 /**
4310 * Emit fragment position/ooordinate code.
4311 */
4312 static void
4313 emit_wpos(struct st_context *st,
4314 struct st_translate *t,
4315 const struct gl_program *program,
4316 struct ureg_program *ureg)
4317 {
4318 const struct gl_fragment_program *fp =
4319 (const struct gl_fragment_program *) program;
4320 struct pipe_screen *pscreen = st->pipe->screen;
4321 GLfloat adjX = 0.0f;
4322 GLfloat adjY[2] = { 0.0f, 0.0f };
4323 boolean invert = FALSE;
4324
4325 /* Query the pixel center conventions supported by the pipe driver and set
4326 * adjX, adjY to help out if it cannot handle the requested one internally.
4327 *
4328 * The bias of the y-coordinate depends on whether y-inversion takes place
4329 * (adjY[1]) or not (adjY[0]), which is in turn dependent on whether we are
4330 * drawing to an FBO (causes additional inversion), and whether the the pipe
4331 * driver origin and the requested origin differ (the latter condition is
4332 * stored in the 'invert' variable).
4333 *
4334 * For height = 100 (i = integer, h = half-integer, l = lower, u = upper):
4335 *
4336 * center shift only:
4337 * i -> h: +0.5
4338 * h -> i: -0.5
4339 *
4340 * inversion only:
4341 * l,i -> u,i: ( 0.0 + 1.0) * -1 + 100 = 99
4342 * l,h -> u,h: ( 0.5 + 0.0) * -1 + 100 = 99.5
4343 * u,i -> l,i: (99.0 + 1.0) * -1 + 100 = 0
4344 * u,h -> l,h: (99.5 + 0.0) * -1 + 100 = 0.5
4345 *
4346 * inversion and center shift:
4347 * l,i -> u,h: ( 0.0 + 0.5) * -1 + 100 = 99.5
4348 * l,h -> u,i: ( 0.5 + 0.5) * -1 + 100 = 99
4349 * u,i -> l,h: (99.0 + 0.5) * -1 + 100 = 0.5
4350 * u,h -> l,i: (99.5 + 0.5) * -1 + 100 = 0
4351 */
4352 if (fp->OriginUpperLeft) {
4353 /* Fragment shader wants origin in upper-left */
4354 if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT)) {
4355 /* the driver supports upper-left origin */
4356 }
4357 else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT)) {
4358 /* the driver supports lower-left origin, need to invert Y */
4359 ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT);
4360 invert = TRUE;
4361 }
4362 else
4363 assert(0);
4364 }
4365 else {
4366 /* Fragment shader wants origin in lower-left */
4367 if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT))
4368 /* the driver supports lower-left origin */
4369 ureg_property_fs_coord_origin(ureg, TGSI_FS_COORD_ORIGIN_LOWER_LEFT);
4370 else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT))
4371 /* the driver supports upper-left origin, need to invert Y */
4372 invert = TRUE;
4373 else
4374 assert(0);
4375 }
4376
4377 if (fp->PixelCenterInteger) {
4378 /* Fragment shader wants pixel center integer */
4379 if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER)) {
4380 /* the driver supports pixel center integer */
4381 adjY[1] = 1.0f;
4382 ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER);
4383 }
4384 else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER)) {
4385 /* the driver supports pixel center half integer, need to bias X,Y */
4386 adjX = -0.5f;
4387 adjY[0] = -0.5f;
4388 adjY[1] = 0.5f;
4389 }
4390 else
4391 assert(0);
4392 }
4393 else {
4394 /* Fragment shader wants pixel center half integer */
4395 if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER)) {
4396 /* the driver supports pixel center half integer */
4397 }
4398 else if (pscreen->get_param(pscreen, PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER)) {
4399 /* the driver supports pixel center integer, need to bias X,Y */
4400 adjX = adjY[0] = adjY[1] = 0.5f;
4401 ureg_property_fs_coord_pixel_center(ureg, TGSI_FS_COORD_PIXEL_CENTER_INTEGER);
4402 }
4403 else
4404 assert(0);
4405 }
4406
4407 /* we invert after adjustment so that we avoid the MOV to temporary,
4408 * and reuse the adjustment ADD instead */
4409 emit_wpos_adjustment(t, program, invert, adjX, adjY);
4410 }
4411
4412 /**
4413 * OpenGL's fragment gl_FrontFace input is 1 for front-facing, 0 for back.
4414 * TGSI uses +1 for front, -1 for back.
4415 * This function converts the TGSI value to the GL value. Simply clamping/
4416 * saturating the value to [0,1] does the job.
4417 */
4418 static void
4419 emit_face_var(struct st_translate *t)
4420 {
4421 struct ureg_program *ureg = t->ureg;
4422 struct ureg_dst face_temp = ureg_DECL_temporary(ureg);
4423 struct ureg_src face_input = t->inputs[t->inputMapping[FRAG_ATTRIB_FACE]];
4424
4425 /* MOV_SAT face_temp, input[face] */
4426 face_temp = ureg_saturate(face_temp);
4427 ureg_MOV(ureg, face_temp, face_input);
4428
4429 /* Use face_temp as face input from here on: */
4430 t->inputs[t->inputMapping[FRAG_ATTRIB_FACE]] = ureg_src(face_temp);
4431 }
4432
4433 static void
4434 emit_edgeflags(struct st_translate *t)
4435 {
4436 struct ureg_program *ureg = t->ureg;
4437 struct ureg_dst edge_dst = t->outputs[t->outputMapping[VERT_RESULT_EDGE]];
4438 struct ureg_src edge_src = t->inputs[t->inputMapping[VERT_ATTRIB_EDGEFLAG]];
4439
4440 ureg_MOV(ureg, edge_dst, edge_src);
4441 }
4442
4443 /**
4444 * Translate intermediate IR (glsl_to_tgsi_instruction) to TGSI format.
4445 * \param program the program to translate
4446 * \param numInputs number of input registers used
4447 * \param inputMapping maps Mesa fragment program inputs to TGSI generic
4448 * input indexes
4449 * \param inputSemanticName the TGSI_SEMANTIC flag for each input
4450 * \param inputSemanticIndex the semantic index (ex: which texcoord) for
4451 * each input
4452 * \param interpMode the TGSI_INTERPOLATE_LINEAR/PERSP mode for each input
4453 * \param numOutputs number of output registers used
4454 * \param outputMapping maps Mesa fragment program outputs to TGSI
4455 * generic outputs
4456 * \param outputSemanticName the TGSI_SEMANTIC flag for each output
4457 * \param outputSemanticIndex the semantic index (ex: which texcoord) for
4458 * each output
4459 *
4460 * \return PIPE_OK or PIPE_ERROR_OUT_OF_MEMORY
4461 */
4462 extern "C" enum pipe_error
4463 st_translate_program(
4464 struct gl_context *ctx,
4465 uint procType,
4466 struct ureg_program *ureg,
4467 glsl_to_tgsi_visitor *program,
4468 const struct gl_program *proginfo,
4469 GLuint numInputs,
4470 const GLuint inputMapping[],
4471 const ubyte inputSemanticName[],
4472 const ubyte inputSemanticIndex[],
4473 const GLuint interpMode[],
4474 GLuint numOutputs,
4475 const GLuint outputMapping[],
4476 const ubyte outputSemanticName[],
4477 const ubyte outputSemanticIndex[],
4478 boolean passthrough_edgeflags,
4479 boolean clamp_color)
4480 {
4481 struct st_translate *t;
4482 unsigned i;
4483 enum pipe_error ret = PIPE_OK;
4484
4485 assert(numInputs <= Elements(t->inputs));
4486 assert(numOutputs <= Elements(t->outputs));
4487
4488 t = CALLOC_STRUCT(st_translate);
4489 if (!t) {
4490 ret = PIPE_ERROR_OUT_OF_MEMORY;
4491 goto out;
4492 }
4493
4494 memset(t, 0, sizeof *t);
4495
4496 t->procType = procType;
4497 t->inputMapping = inputMapping;
4498 t->outputMapping = outputMapping;
4499 t->ureg = ureg;
4500
4501 if (program->shader_program) {
4502 for (i = 0; i < program->shader_program->NumUserUniformStorage; i++) {
4503 struct gl_uniform_storage *const storage =
4504 &program->shader_program->UniformStorage[i];
4505
4506 _mesa_uniform_detach_all_driver_storage(storage);
4507 }
4508 }
4509
4510 /*
4511 * Declare input attributes.
4512 */
4513 if (procType == TGSI_PROCESSOR_FRAGMENT) {
4514 for (i = 0; i < numInputs; i++) {
4515 t->inputs[i] = ureg_DECL_fs_input(ureg,
4516 inputSemanticName[i],
4517 inputSemanticIndex[i],
4518 interpMode[i]);
4519 }
4520
4521 if (proginfo->InputsRead & FRAG_BIT_WPOS) {
4522 /* Must do this after setting up t->inputs, and before
4523 * emitting constant references, below:
4524 */
4525 emit_wpos(st_context(ctx), t, proginfo, ureg);
4526 }
4527
4528 if (proginfo->InputsRead & FRAG_BIT_FACE)
4529 emit_face_var(t);
4530
4531 /*
4532 * Declare output attributes.
4533 */
4534 for (i = 0; i < numOutputs; i++) {
4535 switch (outputSemanticName[i]) {
4536 case TGSI_SEMANTIC_POSITION:
4537 t->outputs[i] = ureg_DECL_output(ureg,
4538 TGSI_SEMANTIC_POSITION, /* Z/Depth */
4539 outputSemanticIndex[i]);
4540 t->outputs[i] = ureg_writemask(t->outputs[i], TGSI_WRITEMASK_Z);
4541 break;
4542 case TGSI_SEMANTIC_STENCIL:
4543 t->outputs[i] = ureg_DECL_output(ureg,
4544 TGSI_SEMANTIC_STENCIL, /* Stencil */
4545 outputSemanticIndex[i]);
4546 t->outputs[i] = ureg_writemask(t->outputs[i], TGSI_WRITEMASK_Y);
4547 break;
4548 case TGSI_SEMANTIC_COLOR:
4549 t->outputs[i] = ureg_DECL_output(ureg,
4550 TGSI_SEMANTIC_COLOR,
4551 outputSemanticIndex[i]);
4552 break;
4553 default:
4554 assert(!"fragment shader outputs must be POSITION/STENCIL/COLOR");
4555 ret = PIPE_ERROR_BAD_INPUT;
4556 goto out;
4557 }
4558 }
4559 }
4560 else if (procType == TGSI_PROCESSOR_GEOMETRY) {
4561 for (i = 0; i < numInputs; i++) {
4562 t->inputs[i] = ureg_DECL_gs_input(ureg,
4563 i,
4564 inputSemanticName[i],
4565 inputSemanticIndex[i]);
4566 }
4567
4568 for (i = 0; i < numOutputs; i++) {
4569 t->outputs[i] = ureg_DECL_output(ureg,
4570 outputSemanticName[i],
4571 outputSemanticIndex[i]);
4572 }
4573 }
4574 else {
4575 assert(procType == TGSI_PROCESSOR_VERTEX);
4576
4577 for (i = 0; i < numInputs; i++) {
4578 t->inputs[i] = ureg_DECL_vs_input(ureg, i);
4579 }
4580
4581 for (i = 0; i < numOutputs; i++) {
4582 if (outputSemanticName[i] == TGSI_SEMANTIC_CLIPDIST) {
4583 int mask = ((1 << (program->num_clip_distances - 4*outputSemanticIndex[i])) - 1) & TGSI_WRITEMASK_XYZW;
4584 t->outputs[i] = ureg_DECL_output_masked(ureg,
4585 outputSemanticName[i],
4586 outputSemanticIndex[i],
4587 mask);
4588 } else {
4589 t->outputs[i] = ureg_DECL_output(ureg,
4590 outputSemanticName[i],
4591 outputSemanticIndex[i]);
4592 }
4593 }
4594 if (passthrough_edgeflags)
4595 emit_edgeflags(t);
4596 }
4597
4598 /* Declare address register.
4599 */
4600 if (program->num_address_regs > 0) {
4601 assert(program->num_address_regs == 1);
4602 t->address[0] = ureg_DECL_address(ureg);
4603 }
4604
4605 /* Declare misc input registers
4606 */
4607 {
4608 GLbitfield sysInputs = proginfo->SystemValuesRead;
4609 unsigned numSys = 0;
4610 for (i = 0; sysInputs; i++) {
4611 if (sysInputs & (1 << i)) {
4612 unsigned semName = mesa_sysval_to_semantic[i];
4613 t->systemValues[i] = ureg_DECL_system_value(ureg, numSys, semName, 0);
4614 numSys++;
4615 sysInputs &= ~(1 << i);
4616 }
4617 }
4618 }
4619
4620 if (program->indirect_addr_temps) {
4621 /* If temps are accessed with indirect addressing, declare temporaries
4622 * in sequential order. Else, we declare them on demand elsewhere.
4623 * (Note: the number of temporaries is equal to program->next_temp)
4624 */
4625 for (i = 0; i < (unsigned)program->next_temp; i++) {
4626 /* XXX use TGSI_FILE_TEMPORARY_ARRAY when it's supported by ureg */
4627 t->temps[i] = ureg_DECL_temporary(t->ureg);
4628 }
4629 }
4630
4631 /* Emit constants and uniforms. TGSI uses a single index space for these,
4632 * so we put all the translated regs in t->constants.
4633 */
4634 if (proginfo->Parameters) {
4635 t->constants = (struct ureg_src *)CALLOC(proginfo->Parameters->NumParameters * sizeof(t->constants[0]));
4636 if (t->constants == NULL) {
4637 ret = PIPE_ERROR_OUT_OF_MEMORY;
4638 goto out;
4639 }
4640
4641 for (i = 0; i < proginfo->Parameters->NumParameters; i++) {
4642 switch (proginfo->Parameters->Parameters[i].Type) {
4643 case PROGRAM_ENV_PARAM:
4644 case PROGRAM_LOCAL_PARAM:
4645 case PROGRAM_STATE_VAR:
4646 case PROGRAM_NAMED_PARAM:
4647 case PROGRAM_UNIFORM:
4648 t->constants[i] = ureg_DECL_constant(ureg, i);
4649 break;
4650
4651 /* Emit immediates for PROGRAM_CONSTANT only when there's no indirect
4652 * addressing of the const buffer.
4653 * FIXME: Be smarter and recognize param arrays:
4654 * indirect addressing is only valid within the referenced
4655 * array.
4656 */
4657 case PROGRAM_CONSTANT:
4658 if (program->indirect_addr_consts)
4659 t->constants[i] = ureg_DECL_constant(ureg, i);
4660 else
4661 t->constants[i] = emit_immediate(t,
4662 proginfo->Parameters->ParameterValues[i],
4663 proginfo->Parameters->Parameters[i].DataType,
4664 4);
4665 break;
4666 default:
4667 break;
4668 }
4669 }
4670 }
4671
4672 /* Emit immediate values.
4673 */
4674 t->immediates = (struct ureg_src *)CALLOC(program->num_immediates * sizeof(struct ureg_src));
4675 if (t->immediates == NULL) {
4676 ret = PIPE_ERROR_OUT_OF_MEMORY;
4677 goto out;
4678 }
4679 i = 0;
4680 foreach_iter(exec_list_iterator, iter, program->immediates) {
4681 immediate_storage *imm = (immediate_storage *)iter.get();
4682 assert(i < program->num_immediates);
4683 t->immediates[i++] = emit_immediate(t, imm->values, imm->type, imm->size);
4684 }
4685 assert(i == program->num_immediates);
4686
4687 /* texture samplers */
4688 for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
4689 if (program->samplers_used & (1 << i)) {
4690 t->samplers[i] = ureg_DECL_sampler(ureg, i);
4691 }
4692 }
4693
4694 /* Emit each instruction in turn:
4695 */
4696 foreach_iter(exec_list_iterator, iter, program->instructions) {
4697 set_insn_start(t, ureg_get_instruction_number(ureg));
4698 compile_tgsi_instruction(t, (glsl_to_tgsi_instruction *)iter.get(),
4699 clamp_color);
4700 }
4701
4702 /* Fix up all emitted labels:
4703 */
4704 for (i = 0; i < t->labels_count; i++) {
4705 ureg_fixup_label(ureg, t->labels[i].token,
4706 t->insn[t->labels[i].branch_target]);
4707 }
4708
4709 if (program->shader_program) {
4710 /* This has to be done last. Any operation the can cause
4711 * prog->ParameterValues to get reallocated (e.g., anything that adds a
4712 * program constant) has to happen before creating this linkage.
4713 */
4714 for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
4715 if (program->shader_program->_LinkedShaders[i] == NULL)
4716 continue;
4717
4718 _mesa_associate_uniform_storage(ctx, program->shader_program,
4719 program->shader_program->_LinkedShaders[i]->Program->Parameters);
4720 }
4721 }
4722
4723 out:
4724 if (t) {
4725 FREE(t->insn);
4726 FREE(t->labels);
4727 FREE(t->constants);
4728 FREE(t->immediates);
4729
4730 if (t->error) {
4731 debug_printf("%s: translate error flag set\n", __FUNCTION__);
4732 }
4733
4734 FREE(t);
4735 }
4736
4737 return ret;
4738 }
4739 /* ----------------------------- End TGSI code ------------------------------ */
4740
4741 /**
4742 * Convert a shader's GLSL IR into a Mesa gl_program, although without
4743 * generating Mesa IR.
4744 */
4745 static struct gl_program *
4746 get_mesa_program(struct gl_context *ctx,
4747 struct gl_shader_program *shader_program,
4748 struct gl_shader *shader,
4749 int num_clip_distances)
4750 {
4751 glsl_to_tgsi_visitor* v = new glsl_to_tgsi_visitor();
4752 struct gl_program *prog;
4753 GLenum target;
4754 const char *target_string;
4755 bool progress;
4756 struct gl_shader_compiler_options *options =
4757 &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(shader->Type)];
4758
4759 switch (shader->Type) {
4760 case GL_VERTEX_SHADER:
4761 target = GL_VERTEX_PROGRAM_ARB;
4762 target_string = "vertex";
4763 break;
4764 case GL_FRAGMENT_SHADER:
4765 target = GL_FRAGMENT_PROGRAM_ARB;
4766 target_string = "fragment";
4767 break;
4768 case GL_GEOMETRY_SHADER:
4769 target = GL_GEOMETRY_PROGRAM_NV;
4770 target_string = "geometry";
4771 break;
4772 default:
4773 assert(!"should not be reached");
4774 return NULL;
4775 }
4776
4777 validate_ir_tree(shader->ir);
4778
4779 prog = ctx->Driver.NewProgram(ctx, target, shader_program->Name);
4780 if (!prog)
4781 return NULL;
4782 prog->Parameters = _mesa_new_parameter_list();
4783 v->ctx = ctx;
4784 v->prog = prog;
4785 v->shader_program = shader_program;
4786 v->options = options;
4787 v->glsl_version = ctx->Const.GLSLVersion;
4788 v->native_integers = ctx->Const.NativeIntegers;
4789 v->num_clip_distances = num_clip_distances;
4790
4791 _mesa_generate_parameters_list_for_uniforms(shader_program, shader,
4792 prog->Parameters);
4793
4794 /* Remove reads from output registers. */
4795 lower_output_reads(shader->ir);
4796
4797 /* Emit intermediate IR for main(). */
4798 visit_exec_list(shader->ir, v);
4799
4800 /* Now emit bodies for any functions that were used. */
4801 do {
4802 progress = GL_FALSE;
4803
4804 foreach_iter(exec_list_iterator, iter, v->function_signatures) {
4805 function_entry *entry = (function_entry *)iter.get();
4806
4807 if (!entry->bgn_inst) {
4808 v->current_function = entry;
4809
4810 entry->bgn_inst = v->emit(NULL, TGSI_OPCODE_BGNSUB);
4811 entry->bgn_inst->function = entry;
4812
4813 visit_exec_list(&entry->sig->body, v);
4814
4815 glsl_to_tgsi_instruction *last;
4816 last = (glsl_to_tgsi_instruction *)v->instructions.get_tail();
4817 if (last->op != TGSI_OPCODE_RET)
4818 v->emit(NULL, TGSI_OPCODE_RET);
4819
4820 glsl_to_tgsi_instruction *end;
4821 end = v->emit(NULL, TGSI_OPCODE_ENDSUB);
4822 end->function = entry;
4823
4824 progress = GL_TRUE;
4825 }
4826 }
4827 } while (progress);
4828
4829 #if 0
4830 /* Print out some information (for debugging purposes) used by the
4831 * optimization passes. */
4832 for (i=0; i < v->next_temp; i++) {
4833 int fr = v->get_first_temp_read(i);
4834 int fw = v->get_first_temp_write(i);
4835 int lr = v->get_last_temp_read(i);
4836 int lw = v->get_last_temp_write(i);
4837
4838 printf("Temp %d: FR=%3d FW=%3d LR=%3d LW=%3d\n", i, fr, fw, lr, lw);
4839 assert(fw <= fr);
4840 }
4841 #endif
4842
4843 /* Perform optimizations on the instructions in the glsl_to_tgsi_visitor. */
4844 v->simplify_cmp();
4845 v->copy_propagate();
4846 while (v->eliminate_dead_code_advanced());
4847
4848 /* FIXME: These passes to optimize temporary registers don't work when there
4849 * is indirect addressing of the temporary register space. We need proper
4850 * array support so that we don't have to give up these passes in every
4851 * shader that uses arrays.
4852 */
4853 if (!v->indirect_addr_temps) {
4854 v->eliminate_dead_code();
4855 v->merge_registers();
4856 v->renumber_registers();
4857 }
4858
4859 /* Write the END instruction. */
4860 v->emit(NULL, TGSI_OPCODE_END);
4861
4862 if (ctx->Shader.Flags & GLSL_DUMP) {
4863 printf("\n");
4864 printf("GLSL IR for linked %s program %d:\n", target_string,
4865 shader_program->Name);
4866 _mesa_print_ir(shader->ir, NULL);
4867 printf("\n");
4868 printf("\n");
4869 fflush(stdout);
4870 }
4871
4872 prog->Instructions = NULL;
4873 prog->NumInstructions = 0;
4874
4875 do_set_program_inouts(shader->ir, prog, shader->Type == GL_FRAGMENT_SHADER);
4876 count_resources(v, prog);
4877
4878 _mesa_reference_program(ctx, &shader->Program, prog);
4879
4880 /* This has to be done last. Any operation the can cause
4881 * prog->ParameterValues to get reallocated (e.g., anything that adds a
4882 * program constant) has to happen before creating this linkage.
4883 */
4884 _mesa_associate_uniform_storage(ctx, shader_program, prog->Parameters);
4885 if (!shader_program->LinkStatus) {
4886 return NULL;
4887 }
4888
4889 struct st_vertex_program *stvp;
4890 struct st_fragment_program *stfp;
4891 struct st_geometry_program *stgp;
4892
4893 switch (shader->Type) {
4894 case GL_VERTEX_SHADER:
4895 stvp = (struct st_vertex_program *)prog;
4896 stvp->glsl_to_tgsi = v;
4897 break;
4898 case GL_FRAGMENT_SHADER:
4899 stfp = (struct st_fragment_program *)prog;
4900 stfp->glsl_to_tgsi = v;
4901 break;
4902 case GL_GEOMETRY_SHADER:
4903 stgp = (struct st_geometry_program *)prog;
4904 stgp->glsl_to_tgsi = v;
4905 break;
4906 default:
4907 assert(!"should not be reached");
4908 return NULL;
4909 }
4910
4911 return prog;
4912 }
4913
4914 /**
4915 * Searches through the IR for a declaration of gl_ClipDistance and returns the
4916 * declared size of the gl_ClipDistance array. Returns 0 if gl_ClipDistance is
4917 * not declared in the IR.
4918 */
4919 int get_clip_distance_size(exec_list *ir)
4920 {
4921 foreach_iter (exec_list_iterator, iter, *ir) {
4922 ir_instruction *inst = (ir_instruction *)iter.get();
4923 ir_variable *var = inst->as_variable();
4924 if (var == NULL) continue;
4925 if (!strcmp(var->name, "gl_ClipDistance")) {
4926 return var->type->length;
4927 }
4928 }
4929
4930 return 0;
4931 }
4932
4933 extern "C" {
4934
4935 struct gl_shader *
4936 st_new_shader(struct gl_context *ctx, GLuint name, GLuint type)
4937 {
4938 struct gl_shader *shader;
4939 assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER ||
4940 type == GL_GEOMETRY_SHADER_ARB);
4941 shader = rzalloc(NULL, struct gl_shader);
4942 if (shader) {
4943 shader->Type = type;
4944 shader->Name = name;
4945 _mesa_init_shader(ctx, shader);
4946 }
4947 return shader;
4948 }
4949
4950 struct gl_shader_program *
4951 st_new_shader_program(struct gl_context *ctx, GLuint name)
4952 {
4953 struct gl_shader_program *shProg;
4954 shProg = rzalloc(NULL, struct gl_shader_program);
4955 if (shProg) {
4956 shProg->Name = name;
4957 _mesa_init_shader_program(ctx, shProg);
4958 }
4959 return shProg;
4960 }
4961
4962 /**
4963 * Link a shader.
4964 * Called via ctx->Driver.LinkShader()
4965 * This actually involves converting GLSL IR into an intermediate TGSI-like IR
4966 * with code lowering and other optimizations.
4967 */
4968 GLboolean
4969 st_link_shader(struct gl_context *ctx, struct gl_shader_program *prog)
4970 {
4971 int num_clip_distances[MESA_SHADER_TYPES];
4972 assert(prog->LinkStatus);
4973
4974 for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
4975 if (prog->_LinkedShaders[i] == NULL)
4976 continue;
4977
4978 bool progress;
4979 exec_list *ir = prog->_LinkedShaders[i]->ir;
4980 const struct gl_shader_compiler_options *options =
4981 &ctx->ShaderCompilerOptions[_mesa_shader_type_to_index(prog->_LinkedShaders[i]->Type)];
4982
4983 /* We have to determine the length of the gl_ClipDistance array before
4984 * the array is lowered to two vec4s by lower_clip_distance().
4985 */
4986 num_clip_distances[i] = get_clip_distance_size(ir);
4987
4988 do {
4989 unsigned what_to_lower = MOD_TO_FRACT | DIV_TO_MUL_RCP |
4990 EXP_TO_EXP2 | LOG_TO_LOG2;
4991 if (options->EmitNoPow)
4992 what_to_lower |= POW_TO_EXP2;
4993 if (!ctx->Const.NativeIntegers)
4994 what_to_lower |= INT_DIV_TO_MUL_RCP;
4995
4996 progress = false;
4997
4998 /* Lowering */
4999 do_mat_op_to_vec(ir);
5000 lower_instructions(ir, what_to_lower);
5001
5002 progress = do_lower_jumps(ir, true, true, options->EmitNoMainReturn, options->EmitNoCont, options->EmitNoLoops) || progress;
5003
5004 progress = do_common_optimization(ir, true, true,
5005 options->MaxUnrollIterations)
5006 || progress;
5007
5008 progress = lower_quadop_vector(ir, false) || progress;
5009 progress = lower_clip_distance(ir) || progress;
5010
5011 if (options->MaxIfDepth == 0)
5012 progress = lower_discard(ir) || progress;
5013
5014 progress = lower_if_to_cond_assign(ir, options->MaxIfDepth) || progress;
5015
5016 if (options->EmitNoNoise)
5017 progress = lower_noise(ir) || progress;
5018
5019 /* If there are forms of indirect addressing that the driver
5020 * cannot handle, perform the lowering pass.
5021 */
5022 if (options->EmitNoIndirectInput || options->EmitNoIndirectOutput
5023 || options->EmitNoIndirectTemp || options->EmitNoIndirectUniform)
5024 progress =
5025 lower_variable_index_to_cond_assign(ir,
5026 options->EmitNoIndirectInput,
5027 options->EmitNoIndirectOutput,
5028 options->EmitNoIndirectTemp,
5029 options->EmitNoIndirectUniform)
5030 || progress;
5031
5032 progress = do_vec_index_to_cond_assign(ir) || progress;
5033 } while (progress);
5034
5035 validate_ir_tree(ir);
5036 }
5037
5038 for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
5039 struct gl_program *linked_prog;
5040
5041 if (prog->_LinkedShaders[i] == NULL)
5042 continue;
5043
5044 linked_prog = get_mesa_program(ctx, prog, prog->_LinkedShaders[i],
5045 num_clip_distances[i]);
5046
5047 if (linked_prog) {
5048 static const GLenum targets[] = {
5049 GL_VERTEX_PROGRAM_ARB,
5050 GL_FRAGMENT_PROGRAM_ARB,
5051 GL_GEOMETRY_PROGRAM_NV
5052 };
5053
5054 _mesa_reference_program(ctx, &prog->_LinkedShaders[i]->Program,
5055 linked_prog);
5056 if (!ctx->Driver.ProgramStringNotify(ctx, targets[i], linked_prog)) {
5057 _mesa_reference_program(ctx, &prog->_LinkedShaders[i]->Program,
5058 NULL);
5059 _mesa_reference_program(ctx, &linked_prog, NULL);
5060 return GL_FALSE;
5061 }
5062 }
5063
5064 _mesa_reference_program(ctx, &linked_prog, NULL);
5065 }
5066
5067 return GL_TRUE;
5068 }
5069
5070 void
5071 st_translate_stream_output_info(glsl_to_tgsi_visitor *glsl_to_tgsi,
5072 const GLuint outputMapping[],
5073 struct pipe_stream_output_info *so)
5074 {
5075 unsigned i;
5076 struct gl_transform_feedback_info *info =
5077 &glsl_to_tgsi->shader_program->LinkedTransformFeedback;
5078
5079 for (i = 0; i < info->NumOutputs; i++) {
5080 so->output[i].register_index =
5081 outputMapping[info->Outputs[i].OutputRegister];
5082 so->output[i].start_component = info->Outputs[i].ComponentOffset;
5083 so->output[i].num_components = info->Outputs[i].NumComponents;
5084 so->output[i].output_buffer = info->Outputs[i].OutputBuffer;
5085 so->output[i].dst_offset = info->Outputs[i].DstOffset;
5086 }
5087
5088 for (i = 0; i < PIPE_MAX_SO_BUFFERS; i++) {
5089 so->stride[i] = info->BufferStride[i];
5090 }
5091 so->num_outputs = info->NumOutputs;
5092 }
5093
5094 } /* extern "C" */