projects / mesa.git / blob
? search:


75ccaf2f26bf340d86a59028fef70368d0db28d5
[mesa.git] / src / mesa / state_tracker / st_program.c
1 /**************************************************************************
2 *
3 * Copyright 2007 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27 /*
28 * Authors:
29 * Keith Whitwell <keithw@vmware.com>
30 * Brian Paul
31 */
32
33
34 #include "main/imports.h"
35 #include "main/hash.h"
36 #include "main/mtypes.h"
37 #include "program/prog_parameter.h"
38 #include "program/prog_print.h"
39 #include "program/programopt.h"
40
41 #include "pipe/p_context.h"
42 #include "pipe/p_defines.h"
43 #include "pipe/p_shader_tokens.h"
44 #include "draw/draw_context.h"
45 #include "tgsi/tgsi_dump.h"
46 #include "tgsi/tgsi_emulate.h"
47 #include "tgsi/tgsi_parse.h"
48 #include "tgsi/tgsi_ureg.h"
49
50 #include "st_debug.h"
51 #include "st_cb_bitmap.h"
52 #include "st_cb_drawpixels.h"
53 #include "st_context.h"
54 #include "st_program.h"
55 #include "st_mesa_to_tgsi.h"
56 #include "cso_cache/cso_context.h"
57
58
59
60 /**
61 * Delete a vertex program variant. Note the caller must unlink
62 * the variant from the linked list.
63 */
64 static void
65 delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv)
66 {
67 if (vpv->driver_shader)
68 cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
69
70 if (vpv->draw_shader)
71 draw_delete_vertex_shader( st->draw, vpv->draw_shader );
72
73 if (vpv->tgsi.tokens)
74 ureg_free_tokens(vpv->tgsi.tokens);
75
76 free( vpv );
77 }
78
79
80
81 /**
82 * Clean out any old compilations:
83 */
84 void
85 st_release_vp_variants( struct st_context *st,
86 struct st_vertex_program *stvp )
87 {
88 struct st_vp_variant *vpv;
89
90 for (vpv = stvp->variants; vpv; ) {
91 struct st_vp_variant *next = vpv->next;
92 delete_vp_variant(st, vpv);
93 vpv = next;
94 }
95
96 stvp->variants = NULL;
97
98 if (stvp->tgsi.tokens) {
99 tgsi_free_tokens(stvp->tgsi.tokens);
100 stvp->tgsi.tokens = NULL;
101 }
102 }
103
104
105
106 /**
107 * Delete a fragment program variant. Note the caller must unlink
108 * the variant from the linked list.
109 */
110 static void
111 delete_fp_variant(struct st_context *st, struct st_fp_variant *fpv)
112 {
113 if (fpv->driver_shader)
114 cso_delete_fragment_shader(st->cso_context, fpv->driver_shader);
115 if (fpv->parameters)
116 _mesa_free_parameter_list(fpv->parameters);
117 free(fpv);
118 }
119
120
121 /**
122 * Free all variants of a fragment program.
123 */
124 void
125 st_release_fp_variants(struct st_context *st, struct st_fragment_program *stfp)
126 {
127 struct st_fp_variant *fpv;
128
129 for (fpv = stfp->variants; fpv; ) {
130 struct st_fp_variant *next = fpv->next;
131 delete_fp_variant(st, fpv);
132 fpv = next;
133 }
134
135 stfp->variants = NULL;
136
137 if (stfp->tgsi.tokens) {
138 ureg_free_tokens(stfp->tgsi.tokens);
139 stfp->tgsi.tokens = NULL;
140 }
141 }
142
143
144 /**
145 * Delete a geometry program variant. Note the caller must unlink
146 * the variant from the linked list.
147 */
148 static void
149 delete_gp_variant(struct st_context *st, struct st_gp_variant *gpv)
150 {
151 if (gpv->driver_shader)
152 cso_delete_geometry_shader(st->cso_context, gpv->driver_shader);
153
154 free(gpv);
155 }
156
157
158 /**
159 * Free all variants of a geometry program.
160 */
161 void
162 st_release_gp_variants(struct st_context *st, struct st_geometry_program *stgp)
163 {
164 struct st_gp_variant *gpv;
165
166 for (gpv = stgp->variants; gpv; ) {
167 struct st_gp_variant *next = gpv->next;
168 delete_gp_variant(st, gpv);
169 gpv = next;
170 }
171
172 stgp->variants = NULL;
173
174 if (stgp->tgsi.tokens) {
175 ureg_free_tokens(stgp->tgsi.tokens);
176 stgp->tgsi.tokens = NULL;
177 }
178 }
179
180
181 /**
182 * Delete a tessellation control program variant. Note the caller must unlink
183 * the variant from the linked list.
184 */
185 static void
186 delete_tcp_variant(struct st_context *st, struct st_tcp_variant *tcpv)
187 {
188 if (tcpv->driver_shader)
189 cso_delete_tessctrl_shader(st->cso_context, tcpv->driver_shader);
190
191 free(tcpv);
192 }
193
194
195 /**
196 * Free all variants of a tessellation control program.
197 */
198 void
199 st_release_tcp_variants(struct st_context *st, struct st_tessctrl_program *sttcp)
200 {
201 struct st_tcp_variant *tcpv;
202
203 for (tcpv = sttcp->variants; tcpv; ) {
204 struct st_tcp_variant *next = tcpv->next;
205 delete_tcp_variant(st, tcpv);
206 tcpv = next;
207 }
208
209 sttcp->variants = NULL;
210
211 if (sttcp->tgsi.tokens) {
212 ureg_free_tokens(sttcp->tgsi.tokens);
213 sttcp->tgsi.tokens = NULL;
214 }
215 }
216
217
218 /**
219 * Delete a tessellation evaluation program variant. Note the caller must
220 * unlink the variant from the linked list.
221 */
222 static void
223 delete_tep_variant(struct st_context *st, struct st_tep_variant *tepv)
224 {
225 if (tepv->driver_shader)
226 cso_delete_tesseval_shader(st->cso_context, tepv->driver_shader);
227
228 free(tepv);
229 }
230
231
232 /**
233 * Free all variants of a tessellation evaluation program.
234 */
235 void
236 st_release_tep_variants(struct st_context *st, struct st_tesseval_program *sttep)
237 {
238 struct st_tep_variant *tepv;
239
240 for (tepv = sttep->variants; tepv; ) {
241 struct st_tep_variant *next = tepv->next;
242 delete_tep_variant(st, tepv);
243 tepv = next;
244 }
245
246 sttep->variants = NULL;
247
248 if (sttep->tgsi.tokens) {
249 ureg_free_tokens(sttep->tgsi.tokens);
250 sttep->tgsi.tokens = NULL;
251 }
252 }
253
254
255 /**
256 * Translate a vertex program.
257 */
258 bool
259 st_translate_vertex_program(struct st_context *st,
260 struct st_vertex_program *stvp)
261 {
262 struct ureg_program *ureg;
263 enum pipe_error error;
264 unsigned num_outputs = 0;
265 unsigned attr;
266 unsigned input_to_index[VERT_ATTRIB_MAX] = {0};
267 unsigned output_slot_to_attr[VARYING_SLOT_MAX] = {0};
268 ubyte output_semantic_name[VARYING_SLOT_MAX] = {0};
269 ubyte output_semantic_index[VARYING_SLOT_MAX] = {0};
270
271 stvp->num_inputs = 0;
272
273 if (stvp->Base.IsPositionInvariant)
274 _mesa_insert_mvp_code(st->ctx, &stvp->Base);
275
276 /*
277 * Determine number of inputs, the mappings between VERT_ATTRIB_x
278 * and TGSI generic input indexes, plus input attrib semantic info.
279 */
280 for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
281 if ((stvp->Base.Base.InputsRead & BITFIELD64_BIT(attr)) != 0) {
282 input_to_index[attr] = stvp->num_inputs;
283 stvp->index_to_input[stvp->num_inputs] = attr;
284 stvp->num_inputs++;
285 if ((stvp->Base.Base.DoubleInputsRead & BITFIELD64_BIT(attr)) != 0) {
286 /* add placeholder for second part of a double attribute */
287 stvp->index_to_input[stvp->num_inputs] = ST_DOUBLE_ATTRIB_PLACEHOLDER;
288 stvp->num_inputs++;
289 }
290 }
291 }
292 /* bit of a hack, presetup potentially unused edgeflag input */
293 input_to_index[VERT_ATTRIB_EDGEFLAG] = stvp->num_inputs;
294 stvp->index_to_input[stvp->num_inputs] = VERT_ATTRIB_EDGEFLAG;
295
296 /* Compute mapping of vertex program outputs to slots.
297 */
298 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
299 if ((stvp->Base.Base.OutputsWritten & BITFIELD64_BIT(attr)) == 0) {
300 stvp->result_to_output[attr] = ~0;
301 }
302 else {
303 unsigned slot = num_outputs++;
304
305 stvp->result_to_output[attr] = slot;
306 output_slot_to_attr[slot] = attr;
307
308 switch (attr) {
309 case VARYING_SLOT_POS:
310 output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
311 output_semantic_index[slot] = 0;
312 break;
313 case VARYING_SLOT_COL0:
314 output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
315 output_semantic_index[slot] = 0;
316 break;
317 case VARYING_SLOT_COL1:
318 output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
319 output_semantic_index[slot] = 1;
320 break;
321 case VARYING_SLOT_BFC0:
322 output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
323 output_semantic_index[slot] = 0;
324 break;
325 case VARYING_SLOT_BFC1:
326 output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
327 output_semantic_index[slot] = 1;
328 break;
329 case VARYING_SLOT_FOGC:
330 output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
331 output_semantic_index[slot] = 0;
332 break;
333 case VARYING_SLOT_PSIZ:
334 output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
335 output_semantic_index[slot] = 0;
336 break;
337 case VARYING_SLOT_CLIP_DIST0:
338 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
339 output_semantic_index[slot] = 0;
340 break;
341 case VARYING_SLOT_CLIP_DIST1:
342 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
343 output_semantic_index[slot] = 1;
344 break;
345 case VARYING_SLOT_EDGE:
346 assert(0);
347 break;
348 case VARYING_SLOT_CLIP_VERTEX:
349 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
350 output_semantic_index[slot] = 0;
351 break;
352 case VARYING_SLOT_LAYER:
353 output_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
354 output_semantic_index[slot] = 0;
355 break;
356 case VARYING_SLOT_VIEWPORT:
357 output_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
358 output_semantic_index[slot] = 0;
359 break;
360
361 case VARYING_SLOT_TEX0:
362 case VARYING_SLOT_TEX1:
363 case VARYING_SLOT_TEX2:
364 case VARYING_SLOT_TEX3:
365 case VARYING_SLOT_TEX4:
366 case VARYING_SLOT_TEX5:
367 case VARYING_SLOT_TEX6:
368 case VARYING_SLOT_TEX7:
369 if (st->needs_texcoord_semantic) {
370 output_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
371 output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
372 break;
373 }
374 /* fall through */
375 case VARYING_SLOT_VAR0:
376 default:
377 assert(attr >= VARYING_SLOT_VAR0 ||
378 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
379 output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
380 output_semantic_index[slot] =
381 st_get_generic_varying_index(st, attr);
382 break;
383 }
384 }
385 }
386 /* similar hack to above, presetup potentially unused edgeflag output */
387 stvp->result_to_output[VARYING_SLOT_EDGE] = num_outputs;
388 output_semantic_name[num_outputs] = TGSI_SEMANTIC_EDGEFLAG;
389 output_semantic_index[num_outputs] = 0;
390
391 if (!stvp->glsl_to_tgsi)
392 _mesa_remove_output_reads(&stvp->Base.Base, PROGRAM_OUTPUT);
393
394 ureg = ureg_create_with_screen(TGSI_PROCESSOR_VERTEX, st->pipe->screen);
395 if (ureg == NULL)
396 return false;
397
398 if (stvp->Base.Base.ClipDistanceArraySize)
399 ureg_property(ureg, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED,
400 stvp->Base.Base.ClipDistanceArraySize);
401
402 if (ST_DEBUG & DEBUG_MESA) {
403 _mesa_print_program(&stvp->Base.Base);
404 _mesa_print_program_parameters(st->ctx, &stvp->Base.Base);
405 debug_printf("\n");
406 }
407
408 if (stvp->glsl_to_tgsi) {
409 error = st_translate_program(st->ctx,
410 TGSI_PROCESSOR_VERTEX,
411 ureg,
412 stvp->glsl_to_tgsi,
413 &stvp->Base.Base,
414 /* inputs */
415 stvp->num_inputs,
416 input_to_index,
417 NULL, /* inputSlotToAttr */
418 NULL, /* input semantic name */
419 NULL, /* input semantic index */
420 NULL, /* interp mode */
421 NULL, /* interp location */
422 /* outputs */
423 num_outputs,
424 stvp->result_to_output,
425 output_slot_to_attr,
426 output_semantic_name,
427 output_semantic_index);
428
429 st_translate_stream_output_info(stvp->glsl_to_tgsi,
430 stvp->result_to_output,
431 &stvp->tgsi.stream_output);
432
433 free_glsl_to_tgsi_visitor(stvp->glsl_to_tgsi);
434 stvp->glsl_to_tgsi = NULL;
435 } else
436 error = st_translate_mesa_program(st->ctx,
437 TGSI_PROCESSOR_VERTEX,
438 ureg,
439 &stvp->Base.Base,
440 /* inputs */
441 stvp->num_inputs,
442 input_to_index,
443 NULL, /* input semantic name */
444 NULL, /* input semantic index */
445 NULL,
446 /* outputs */
447 num_outputs,
448 stvp->result_to_output,
449 output_semantic_name,
450 output_semantic_index);
451
452 if (error) {
453 debug_printf("%s: failed to translate Mesa program:\n", __func__);
454 _mesa_print_program(&stvp->Base.Base);
455 debug_assert(0);
456 return false;
457 }
458
459 stvp->tgsi.tokens = ureg_get_tokens(ureg, NULL);
460 ureg_destroy(ureg);
461 return stvp->tgsi.tokens != NULL;
462 }
463
464 static struct st_vp_variant *
465 st_create_vp_variant(struct st_context *st,
466 struct st_vertex_program *stvp,
467 const struct st_vp_variant_key *key)
468 {
469 struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant);
470 struct pipe_context *pipe = st->pipe;
471
472 vpv->key = *key;
473 vpv->tgsi.tokens = tgsi_dup_tokens(stvp->tgsi.tokens);
474 vpv->tgsi.stream_output = stvp->tgsi.stream_output;
475 vpv->num_inputs = stvp->num_inputs;
476
477 /* Emulate features. */
478 if (key->clamp_color || key->passthrough_edgeflags) {
479 const struct tgsi_token *tokens;
480 unsigned flags =
481 (key->clamp_color ? TGSI_EMU_CLAMP_COLOR_OUTPUTS : 0) |
482 (key->passthrough_edgeflags ? TGSI_EMU_PASSTHROUGH_EDGEFLAG : 0);
483
484 tokens = tgsi_emulate(vpv->tgsi.tokens, flags);
485
486 if (tokens) {
487 tgsi_free_tokens(vpv->tgsi.tokens);
488 vpv->tgsi.tokens = tokens;
489
490 if (key->passthrough_edgeflags)
491 vpv->num_inputs++;
492 } else
493 fprintf(stderr, "mesa: cannot emulate deprecated features\n");
494 }
495
496 if (ST_DEBUG & DEBUG_TGSI) {
497 tgsi_dump(vpv->tgsi.tokens, 0);
498 debug_printf("\n");
499 }
500
501 vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
502 return vpv;
503 }
504
505
506 /**
507 * Find/create a vertex program variant.
508 */
509 struct st_vp_variant *
510 st_get_vp_variant(struct st_context *st,
511 struct st_vertex_program *stvp,
512 const struct st_vp_variant_key *key)
513 {
514 struct st_vp_variant *vpv;
515
516 /* Search for existing variant */
517 for (vpv = stvp->variants; vpv; vpv = vpv->next) {
518 if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {
519 break;
520 }
521 }
522
523 if (!vpv) {
524 /* create now */
525 vpv = st_create_vp_variant(st, stvp, key);
526 if (vpv) {
527 /* insert into list */
528 vpv->next = stvp->variants;
529 stvp->variants = vpv;
530 }
531 }
532
533 return vpv;
534 }
535
536
537 static unsigned
538 st_translate_interp(enum glsl_interp_qualifier glsl_qual, bool is_color)
539 {
540 switch (glsl_qual) {
541 case INTERP_QUALIFIER_NONE:
542 if (is_color)
543 return TGSI_INTERPOLATE_COLOR;
544 return TGSI_INTERPOLATE_PERSPECTIVE;
545 case INTERP_QUALIFIER_SMOOTH:
546 return TGSI_INTERPOLATE_PERSPECTIVE;
547 case INTERP_QUALIFIER_FLAT:
548 return TGSI_INTERPOLATE_CONSTANT;
549 case INTERP_QUALIFIER_NOPERSPECTIVE:
550 return TGSI_INTERPOLATE_LINEAR;
551 default:
552 assert(0 && "unexpected interp mode in st_translate_interp()");
553 return TGSI_INTERPOLATE_PERSPECTIVE;
554 }
555 }
556
557
558 /**
559 * Translate a Mesa fragment shader into a TGSI shader.
560 */
561 bool
562 st_translate_fragment_program(struct st_context *st,
563 struct st_fragment_program *stfp)
564 {
565 GLuint outputMapping[FRAG_RESULT_MAX];
566 GLuint inputMapping[VARYING_SLOT_MAX];
567 GLuint inputSlotToAttr[VARYING_SLOT_MAX];
568 GLuint interpMode[PIPE_MAX_SHADER_INPUTS]; /* XXX size? */
569 GLuint interpLocation[PIPE_MAX_SHADER_INPUTS];
570 GLuint attr;
571 GLbitfield64 inputsRead;
572 struct ureg_program *ureg;
573
574 GLboolean write_all = GL_FALSE;
575
576 ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
577 ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
578 uint fs_num_inputs = 0;
579
580 ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
581 ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
582 uint fs_num_outputs = 0;
583
584 memset(inputSlotToAttr, ~0, sizeof(inputSlotToAttr));
585
586 if (!stfp->glsl_to_tgsi)
587 _mesa_remove_output_reads(&stfp->Base.Base, PROGRAM_OUTPUT);
588
589 /*
590 * Convert Mesa program inputs to TGSI input register semantics.
591 */
592 inputsRead = stfp->Base.Base.InputsRead;
593 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
594 if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
595 const GLuint slot = fs_num_inputs++;
596
597 inputMapping[attr] = slot;
598 inputSlotToAttr[slot] = attr;
599 if (stfp->Base.IsCentroid & BITFIELD64_BIT(attr))
600 interpLocation[slot] = TGSI_INTERPOLATE_LOC_CENTROID;
601 else if (stfp->Base.IsSample & BITFIELD64_BIT(attr))
602 interpLocation[slot] = TGSI_INTERPOLATE_LOC_SAMPLE;
603 else
604 interpLocation[slot] = TGSI_INTERPOLATE_LOC_CENTER;
605
606 if (stfp->Base.Base.SystemValuesRead & (SYSTEM_BIT_SAMPLE_ID |
607 SYSTEM_BIT_SAMPLE_POS))
608 interpLocation[slot] = TGSI_INTERPOLATE_LOC_SAMPLE;
609
610 switch (attr) {
611 case VARYING_SLOT_POS:
612 input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
613 input_semantic_index[slot] = 0;
614 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
615 break;
616 case VARYING_SLOT_COL0:
617 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
618 input_semantic_index[slot] = 0;
619 interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
620 TRUE);
621 break;
622 case VARYING_SLOT_COL1:
623 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
624 input_semantic_index[slot] = 1;
625 interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
626 TRUE);
627 break;
628 case VARYING_SLOT_FOGC:
629 input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
630 input_semantic_index[slot] = 0;
631 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
632 break;
633 case VARYING_SLOT_FACE:
634 input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
635 input_semantic_index[slot] = 0;
636 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
637 break;
638 case VARYING_SLOT_PRIMITIVE_ID:
639 input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
640 input_semantic_index[slot] = 0;
641 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
642 break;
643 case VARYING_SLOT_LAYER:
644 input_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
645 input_semantic_index[slot] = 0;
646 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
647 break;
648 case VARYING_SLOT_VIEWPORT:
649 input_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
650 input_semantic_index[slot] = 0;
651 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
652 break;
653 case VARYING_SLOT_CLIP_DIST0:
654 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
655 input_semantic_index[slot] = 0;
656 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
657 break;
658 case VARYING_SLOT_CLIP_DIST1:
659 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
660 input_semantic_index[slot] = 1;
661 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
662 break;
663 /* In most cases, there is nothing special about these
664 * inputs, so adopt a convention to use the generic
665 * semantic name and the mesa VARYING_SLOT_ number as the
666 * index.
667 *
668 * All that is required is that the vertex shader labels
669 * its own outputs similarly, and that the vertex shader
670 * generates at least every output required by the
671 * fragment shader plus fixed-function hardware (such as
672 * BFC).
673 *
674 * However, some drivers may need us to identify the PNTC and TEXi
675 * varyings if, for example, their capability to replace them with
676 * sprite coordinates is limited.
677 */
678 case VARYING_SLOT_PNTC:
679 if (st->needs_texcoord_semantic) {
680 input_semantic_name[slot] = TGSI_SEMANTIC_PCOORD;
681 input_semantic_index[slot] = 0;
682 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
683 break;
684 }
685 /* fall through */
686 case VARYING_SLOT_TEX0:
687 case VARYING_SLOT_TEX1:
688 case VARYING_SLOT_TEX2:
689 case VARYING_SLOT_TEX3:
690 case VARYING_SLOT_TEX4:
691 case VARYING_SLOT_TEX5:
692 case VARYING_SLOT_TEX6:
693 case VARYING_SLOT_TEX7:
694 if (st->needs_texcoord_semantic) {
695 input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
696 input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
697 interpMode[slot] =
698 st_translate_interp(stfp->Base.InterpQualifier[attr], FALSE);
699 break;
700 }
701 /* fall through */
702 case VARYING_SLOT_VAR0:
703 default:
704 /* Semantic indices should be zero-based because drivers may choose
705 * to assign a fixed slot determined by that index.
706 * This is useful because ARB_separate_shader_objects uses location
707 * qualifiers for linkage, and if the semantic index corresponds to
708 * these locations, linkage passes in the driver become unecessary.
709 *
710 * If needs_texcoord_semantic is true, no semantic indices will be
711 * consumed for the TEXi varyings, and we can base the locations of
712 * the user varyings on VAR0. Otherwise, we use TEX0 as base index.
713 */
714 assert(attr >= VARYING_SLOT_VAR0 || attr == VARYING_SLOT_PNTC ||
715 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
716 input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
717 input_semantic_index[slot] = st_get_generic_varying_index(st, attr);
718 if (attr == VARYING_SLOT_PNTC)
719 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
720 else
721 interpMode[slot] = st_translate_interp(stfp->Base.InterpQualifier[attr],
722 FALSE);
723 break;
724 }
725 }
726 else {
727 inputMapping[attr] = -1;
728 }
729 }
730
731 /*
732 * Semantics and mapping for outputs
733 */
734 {
735 uint numColors = 0;
736 GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
737
738 /* if z is written, emit that first */
739 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
740 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
741 fs_output_semantic_index[fs_num_outputs] = 0;
742 outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
743 fs_num_outputs++;
744 outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
745 }
746
747 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
748 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
749 fs_output_semantic_index[fs_num_outputs] = 0;
750 outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
751 fs_num_outputs++;
752 outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
753 }
754
755 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK)) {
756 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_SAMPLEMASK;
757 fs_output_semantic_index[fs_num_outputs] = 0;
758 outputMapping[FRAG_RESULT_SAMPLE_MASK] = fs_num_outputs;
759 fs_num_outputs++;
760 outputsWritten &= ~(1 << FRAG_RESULT_SAMPLE_MASK);
761 }
762
763 /* handle remaining outputs (color) */
764 for (attr = 0; attr < FRAG_RESULT_MAX; attr++) {
765 if (outputsWritten & BITFIELD64_BIT(attr)) {
766 switch (attr) {
767 case FRAG_RESULT_DEPTH:
768 case FRAG_RESULT_STENCIL:
769 case FRAG_RESULT_SAMPLE_MASK:
770 /* handled above */
771 assert(0);
772 break;
773 case FRAG_RESULT_COLOR:
774 write_all = GL_TRUE; /* fallthrough */
775 default:
776 assert(attr == FRAG_RESULT_COLOR ||
777 (FRAG_RESULT_DATA0 <= attr && attr < FRAG_RESULT_MAX));
778 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
779 fs_output_semantic_index[fs_num_outputs] = numColors;
780 outputMapping[attr] = fs_num_outputs;
781 numColors++;
782 break;
783 }
784
785 fs_num_outputs++;
786 }
787 }
788 }
789
790 ureg = ureg_create_with_screen(TGSI_PROCESSOR_FRAGMENT, st->pipe->screen);
791 if (ureg == NULL)
792 return false;
793
794 if (ST_DEBUG & DEBUG_MESA) {
795 _mesa_print_program(&stfp->Base.Base);
796 _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
797 debug_printf("\n");
798 }
799 if (write_all == GL_TRUE)
800 ureg_property(ureg, TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS, 1);
801
802 if (stfp->Base.FragDepthLayout != FRAG_DEPTH_LAYOUT_NONE) {
803 switch (stfp->Base.FragDepthLayout) {
804 case FRAG_DEPTH_LAYOUT_ANY:
805 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
806 TGSI_FS_DEPTH_LAYOUT_ANY);
807 break;
808 case FRAG_DEPTH_LAYOUT_GREATER:
809 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
810 TGSI_FS_DEPTH_LAYOUT_GREATER);
811 break;
812 case FRAG_DEPTH_LAYOUT_LESS:
813 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
814 TGSI_FS_DEPTH_LAYOUT_LESS);
815 break;
816 case FRAG_DEPTH_LAYOUT_UNCHANGED:
817 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
818 TGSI_FS_DEPTH_LAYOUT_UNCHANGED);
819 break;
820 default:
821 assert(0);
822 }
823 }
824
825 if (stfp->glsl_to_tgsi) {
826 st_translate_program(st->ctx,
827 TGSI_PROCESSOR_FRAGMENT,
828 ureg,
829 stfp->glsl_to_tgsi,
830 &stfp->Base.Base,
831 /* inputs */
832 fs_num_inputs,
833 inputMapping,
834 inputSlotToAttr,
835 input_semantic_name,
836 input_semantic_index,
837 interpMode,
838 interpLocation,
839 /* outputs */
840 fs_num_outputs,
841 outputMapping,
842 NULL,
843 fs_output_semantic_name,
844 fs_output_semantic_index);
845
846 free_glsl_to_tgsi_visitor(stfp->glsl_to_tgsi);
847 stfp->glsl_to_tgsi = NULL;
848 } else
849 st_translate_mesa_program(st->ctx,
850 TGSI_PROCESSOR_FRAGMENT,
851 ureg,
852 &stfp->Base.Base,
853 /* inputs */
854 fs_num_inputs,
855 inputMapping,
856 input_semantic_name,
857 input_semantic_index,
858 interpMode,
859 /* outputs */
860 fs_num_outputs,
861 outputMapping,
862 fs_output_semantic_name,
863 fs_output_semantic_index);
864
865 stfp->tgsi.tokens = ureg_get_tokens(ureg, NULL);
866 ureg_destroy(ureg);
867 return stfp->tgsi.tokens != NULL;
868 }
869
870 static struct st_fp_variant *
871 st_create_fp_variant(struct st_context *st,
872 struct st_fragment_program *stfp,
873 const struct st_fp_variant_key *key)
874 {
875 struct pipe_context *pipe = st->pipe;
876 struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
877 struct pipe_shader_state tgsi = {0};
878
879 if (!variant)
880 return NULL;
881
882 tgsi.tokens = stfp->tgsi.tokens;
883
884 assert(!(key->bitmap && key->drawpixels));
885
886 /* Emulate features. */
887 if (key->clamp_color || key->persample_shading) {
888 const struct tgsi_token *tokens;
889 unsigned flags =
890 (key->clamp_color ? TGSI_EMU_CLAMP_COLOR_OUTPUTS : 0) |
891 (key->persample_shading ? TGSI_EMU_FORCE_PERSAMPLE_INTERP : 0);
892
893 tokens = tgsi_emulate(tgsi.tokens, flags);
894
895 if (tokens)
896 tgsi.tokens = tokens;
897 else
898 fprintf(stderr, "mesa: cannot emulate deprecated features\n");
899 }
900
901 /* glBitmap */
902 if (key->bitmap) {
903 const struct tgsi_token *tokens;
904
905 variant->bitmap_sampler = ffs(~stfp->Base.Base.SamplersUsed) - 1;
906
907 tokens = st_get_bitmap_shader(tgsi.tokens,
908 variant->bitmap_sampler,
909 st->needs_texcoord_semantic,
910 st->bitmap.tex_format ==
911 PIPE_FORMAT_L8_UNORM);
912
913 if (tokens) {
914 if (tgsi.tokens != stfp->tgsi.tokens)
915 tgsi_free_tokens(tgsi.tokens);
916 tgsi.tokens = tokens;
917 variant->parameters =
918 _mesa_clone_parameter_list(stfp->Base.Base.Parameters);
919 } else
920 fprintf(stderr, "mesa: cannot create a shader for glBitmap\n");
921 }
922
923 /* glDrawPixels (color only) */
924 if (key->drawpixels) {
925 const struct tgsi_token *tokens;
926 unsigned scale_const = 0, bias_const = 0, texcoord_const = 0;
927
928 /* Find the first unused slot. */
929 variant->drawpix_sampler = ffs(~stfp->Base.Base.SamplersUsed) - 1;
930
931 if (key->pixelMaps) {
932 unsigned samplers_used = stfp->Base.Base.SamplersUsed |
933 (1 << variant->drawpix_sampler);
934
935 variant->pixelmap_sampler = ffs(~samplers_used) - 1;
936 }
937
938 variant->parameters =
939 _mesa_clone_parameter_list(stfp->Base.Base.Parameters);
940
941 if (key->scaleAndBias) {
942 static const gl_state_index scale_state[STATE_LENGTH] =
943 { STATE_INTERNAL, STATE_PT_SCALE };
944 static const gl_state_index bias_state[STATE_LENGTH] =
945 { STATE_INTERNAL, STATE_PT_BIAS };
946
947 scale_const = _mesa_add_state_reference(variant->parameters,
948 scale_state);
949 bias_const = _mesa_add_state_reference(variant->parameters,
950 bias_state);
951 }
952
953 {
954 static const gl_state_index state[STATE_LENGTH] =
955 { STATE_INTERNAL, STATE_CURRENT_ATTRIB, VERT_ATTRIB_TEX0 };
956
957 texcoord_const = _mesa_add_state_reference(variant->parameters,
958 state);
959 }
960
961 tokens = st_get_drawpix_shader(tgsi.tokens,
962 st->needs_texcoord_semantic,
963 key->scaleAndBias, scale_const,
964 bias_const, key->pixelMaps,
965 variant->drawpix_sampler,
966 variant->pixelmap_sampler,
967 texcoord_const);
968
969 if (tokens) {
970 if (tgsi.tokens != stfp->tgsi.tokens)
971 tgsi_free_tokens(tgsi.tokens);
972 tgsi.tokens = tokens;
973 } else
974 fprintf(stderr, "mesa: cannot create a shader for glDrawPixels\n");
975 }
976
977 if (ST_DEBUG & DEBUG_TGSI) {
978 tgsi_dump(tgsi.tokens, 0);
979 debug_printf("\n");
980 }
981
982 /* fill in variant */
983 variant->driver_shader = pipe->create_fs_state(pipe, &tgsi);
984 variant->key = *key;
985
986 if (tgsi.tokens != stfp->tgsi.tokens)
987 tgsi_free_tokens(tgsi.tokens);
988 return variant;
989 }
990
991 /**
992 * Translate fragment program if needed.
993 */
994 struct st_fp_variant *
995 st_get_fp_variant(struct st_context *st,
996 struct st_fragment_program *stfp,
997 const struct st_fp_variant_key *key)
998 {
999 struct st_fp_variant *fpv;
1000
1001 /* Search for existing variant */
1002 for (fpv = stfp->variants; fpv; fpv = fpv->next) {
1003 if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
1004 break;
1005 }
1006 }
1007
1008 if (!fpv) {
1009 /* create new */
1010 fpv = st_create_fp_variant(st, stfp, key);
1011 if (fpv) {
1012 /* insert into list */
1013 fpv->next = stfp->variants;
1014 stfp->variants = fpv;
1015 }
1016 }
1017
1018 return fpv;
1019 }
1020
1021
1022 /**
1023 * Translate a program. This is common code for geometry and tessellation
1024 * shaders.
1025 */
1026 static void
1027 st_translate_program_common(struct st_context *st,
1028 struct gl_program *prog,
1029 struct glsl_to_tgsi_visitor *glsl_to_tgsi,
1030 struct ureg_program *ureg,
1031 unsigned tgsi_processor,
1032 struct pipe_shader_state *out_state)
1033 {
1034 GLuint inputSlotToAttr[VARYING_SLOT_TESS_MAX];
1035 GLuint inputMapping[VARYING_SLOT_TESS_MAX];
1036 GLuint outputSlotToAttr[VARYING_SLOT_TESS_MAX];
1037 GLuint outputMapping[VARYING_SLOT_TESS_MAX];
1038 GLuint attr;
1039
1040 ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
1041 ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
1042 uint num_inputs = 0;
1043
1044 ubyte output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
1045 ubyte output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
1046 uint num_outputs = 0;
1047
1048 GLint i;
1049
1050 memset(inputSlotToAttr, 0, sizeof(inputSlotToAttr));
1051 memset(inputMapping, 0, sizeof(inputMapping));
1052 memset(outputSlotToAttr, 0, sizeof(outputSlotToAttr));
1053 memset(outputMapping, 0, sizeof(outputMapping));
1054 memset(out_state, 0, sizeof(*out_state));
1055
1056 if (prog->ClipDistanceArraySize)
1057 ureg_property(ureg, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED,
1058 prog->ClipDistanceArraySize);
1059
1060 /*
1061 * Convert Mesa program inputs to TGSI input register semantics.
1062 */
1063 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1064 if ((prog->InputsRead & BITFIELD64_BIT(attr)) != 0) {
1065 const GLuint slot = num_inputs++;
1066
1067 inputMapping[attr] = slot;
1068 inputSlotToAttr[slot] = attr;
1069
1070 switch (attr) {
1071 case VARYING_SLOT_PRIMITIVE_ID:
1072 assert(tgsi_processor == TGSI_PROCESSOR_GEOMETRY);
1073 input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1074 input_semantic_index[slot] = 0;
1075 break;
1076 case VARYING_SLOT_POS:
1077 input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1078 input_semantic_index[slot] = 0;
1079 break;
1080 case VARYING_SLOT_COL0:
1081 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1082 input_semantic_index[slot] = 0;
1083 break;
1084 case VARYING_SLOT_COL1:
1085 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1086 input_semantic_index[slot] = 1;
1087 break;
1088 case VARYING_SLOT_FOGC:
1089 input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1090 input_semantic_index[slot] = 0;
1091 break;
1092 case VARYING_SLOT_CLIP_VERTEX:
1093 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1094 input_semantic_index[slot] = 0;
1095 break;
1096 case VARYING_SLOT_CLIP_DIST0:
1097 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1098 input_semantic_index[slot] = 0;
1099 break;
1100 case VARYING_SLOT_CLIP_DIST1:
1101 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1102 input_semantic_index[slot] = 1;
1103 break;
1104 case VARYING_SLOT_PSIZ:
1105 input_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1106 input_semantic_index[slot] = 0;
1107 break;
1108 case VARYING_SLOT_TEX0:
1109 case VARYING_SLOT_TEX1:
1110 case VARYING_SLOT_TEX2:
1111 case VARYING_SLOT_TEX3:
1112 case VARYING_SLOT_TEX4:
1113 case VARYING_SLOT_TEX5:
1114 case VARYING_SLOT_TEX6:
1115 case VARYING_SLOT_TEX7:
1116 if (st->needs_texcoord_semantic) {
1117 input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1118 input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1119 break;
1120 }
1121 /* fall through */
1122 case VARYING_SLOT_VAR0:
1123 default:
1124 assert(attr >= VARYING_SLOT_VAR0 ||
1125 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1126 input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1127 input_semantic_index[slot] =
1128 st_get_generic_varying_index(st, attr);
1129 break;
1130 }
1131 }
1132 }
1133
1134 /* Also add patch inputs. */
1135 for (attr = 0; attr < 32; attr++) {
1136 if (prog->PatchInputsRead & (1 << attr)) {
1137 GLuint slot = num_inputs++;
1138 GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1139
1140 inputMapping[patch_attr] = slot;
1141 inputSlotToAttr[slot] = patch_attr;
1142 input_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1143 input_semantic_index[slot] = attr;
1144 }
1145 }
1146
1147 /* initialize output semantics to defaults */
1148 for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
1149 output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
1150 output_semantic_index[i] = 0;
1151 }
1152
1153 /*
1154 * Determine number of outputs, the (default) output register
1155 * mapping and the semantic information for each output.
1156 */
1157 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1158 if (prog->OutputsWritten & BITFIELD64_BIT(attr)) {
1159 GLuint slot = num_outputs++;
1160
1161 outputMapping[attr] = slot;
1162 outputSlotToAttr[slot] = attr;
1163
1164 switch (attr) {
1165 case VARYING_SLOT_POS:
1166 assert(slot == 0);
1167 output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1168 output_semantic_index[slot] = 0;
1169 break;
1170 case VARYING_SLOT_COL0:
1171 output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1172 output_semantic_index[slot] = 0;
1173 break;
1174 case VARYING_SLOT_COL1:
1175 output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1176 output_semantic_index[slot] = 1;
1177 break;
1178 case VARYING_SLOT_BFC0:
1179 output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1180 output_semantic_index[slot] = 0;
1181 break;
1182 case VARYING_SLOT_BFC1:
1183 output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1184 output_semantic_index[slot] = 1;
1185 break;
1186 case VARYING_SLOT_FOGC:
1187 output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1188 output_semantic_index[slot] = 0;
1189 break;
1190 case VARYING_SLOT_PSIZ:
1191 output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1192 output_semantic_index[slot] = 0;
1193 break;
1194 case VARYING_SLOT_CLIP_VERTEX:
1195 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1196 output_semantic_index[slot] = 0;
1197 break;
1198 case VARYING_SLOT_CLIP_DIST0:
1199 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1200 output_semantic_index[slot] = 0;
1201 break;
1202 case VARYING_SLOT_CLIP_DIST1:
1203 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1204 output_semantic_index[slot] = 1;
1205 break;
1206 case VARYING_SLOT_LAYER:
1207 output_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
1208 output_semantic_index[slot] = 0;
1209 break;
1210 case VARYING_SLOT_PRIMITIVE_ID:
1211 output_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1212 output_semantic_index[slot] = 0;
1213 break;
1214 case VARYING_SLOT_VIEWPORT:
1215 output_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
1216 output_semantic_index[slot] = 0;
1217 break;
1218 case VARYING_SLOT_TESS_LEVEL_OUTER:
1219 output_semantic_name[slot] = TGSI_SEMANTIC_TESSOUTER;
1220 output_semantic_index[slot] = 0;
1221 break;
1222 case VARYING_SLOT_TESS_LEVEL_INNER:
1223 output_semantic_name[slot] = TGSI_SEMANTIC_TESSINNER;
1224 output_semantic_index[slot] = 0;
1225 break;
1226 case VARYING_SLOT_TEX0:
1227 case VARYING_SLOT_TEX1:
1228 case VARYING_SLOT_TEX2:
1229 case VARYING_SLOT_TEX3:
1230 case VARYING_SLOT_TEX4:
1231 case VARYING_SLOT_TEX5:
1232 case VARYING_SLOT_TEX6:
1233 case VARYING_SLOT_TEX7:
1234 if (st->needs_texcoord_semantic) {
1235 output_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1236 output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1237 break;
1238 }
1239 /* fall through */
1240 case VARYING_SLOT_VAR0:
1241 default:
1242 assert(slot < ARRAY_SIZE(output_semantic_name));
1243 assert(attr >= VARYING_SLOT_VAR0 ||
1244 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1245 output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1246 output_semantic_index[slot] =
1247 st_get_generic_varying_index(st, attr);
1248 break;
1249 }
1250 }
1251 }
1252
1253 /* Also add patch outputs. */
1254 for (attr = 0; attr < 32; attr++) {
1255 if (prog->PatchOutputsWritten & (1 << attr)) {
1256 GLuint slot = num_outputs++;
1257 GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1258
1259 outputMapping[patch_attr] = slot;
1260 outputSlotToAttr[slot] = patch_attr;
1261 output_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1262 output_semantic_index[slot] = attr;
1263 }
1264 }
1265
1266 st_translate_program(st->ctx,
1267 tgsi_processor,
1268 ureg,
1269 glsl_to_tgsi,
1270 prog,
1271 /* inputs */
1272 num_inputs,
1273 inputMapping,
1274 inputSlotToAttr,
1275 input_semantic_name,
1276 input_semantic_index,
1277 NULL,
1278 NULL,
1279 /* outputs */
1280 num_outputs,
1281 outputMapping,
1282 outputSlotToAttr,
1283 output_semantic_name,
1284 output_semantic_index);
1285
1286 out_state->tokens = ureg_get_tokens(ureg, NULL);
1287 ureg_destroy(ureg);
1288
1289 st_translate_stream_output_info(glsl_to_tgsi,
1290 outputMapping,
1291 &out_state->stream_output);
1292
1293 if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
1294 _mesa_print_program(prog);
1295 debug_printf("\n");
1296 }
1297
1298 if (ST_DEBUG & DEBUG_TGSI) {
1299 tgsi_dump(out_state->tokens, 0);
1300 debug_printf("\n");
1301 }
1302 }
1303
1304
1305 /**
1306 * Translate a geometry program to create a new variant.
1307 */
1308 bool
1309 st_translate_geometry_program(struct st_context *st,
1310 struct st_geometry_program *stgp)
1311 {
1312 struct ureg_program *ureg;
1313
1314 ureg = ureg_create_with_screen(TGSI_PROCESSOR_GEOMETRY, st->pipe->screen);
1315 if (ureg == NULL)
1316 return false;
1317
1318 ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM, stgp->Base.InputType);
1319 ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM, stgp->Base.OutputType);
1320 ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES,
1321 stgp->Base.VerticesOut);
1322 ureg_property(ureg, TGSI_PROPERTY_GS_INVOCATIONS, stgp->Base.Invocations);
1323
1324 st_translate_program_common(st, &stgp->Base.Base, stgp->glsl_to_tgsi, ureg,
1325 TGSI_PROCESSOR_GEOMETRY, &stgp->tgsi);
1326
1327 free_glsl_to_tgsi_visitor(stgp->glsl_to_tgsi);
1328 stgp->glsl_to_tgsi = NULL;
1329 return true;
1330 }
1331
1332
1333 static struct st_gp_variant *
1334 st_create_gp_variant(struct st_context *st,
1335 struct st_geometry_program *stgp,
1336 const struct st_gp_variant_key *key)
1337 {
1338 struct pipe_context *pipe = st->pipe;
1339 struct st_gp_variant *gpv;
1340
1341 gpv = CALLOC_STRUCT(st_gp_variant);
1342 if (!gpv)
1343 return NULL;
1344
1345 /* fill in new variant */
1346 gpv->driver_shader = pipe->create_gs_state(pipe, &stgp->tgsi);
1347 gpv->key = *key;
1348 return gpv;
1349 }
1350
1351
1352 /**
1353 * Get/create geometry program variant.
1354 */
1355 struct st_gp_variant *
1356 st_get_gp_variant(struct st_context *st,
1357 struct st_geometry_program *stgp,
1358 const struct st_gp_variant_key *key)
1359 {
1360 struct st_gp_variant *gpv;
1361
1362 /* Search for existing variant */
1363 for (gpv = stgp->variants; gpv; gpv = gpv->next) {
1364 if (memcmp(&gpv->key, key, sizeof(*key)) == 0) {
1365 break;
1366 }
1367 }
1368
1369 if (!gpv) {
1370 /* create new */
1371 gpv = st_create_gp_variant(st, stgp, key);
1372 if (gpv) {
1373 /* insert into list */
1374 gpv->next = stgp->variants;
1375 stgp->variants = gpv;
1376 }
1377 }
1378
1379 return gpv;
1380 }
1381
1382
1383 /**
1384 * Translate a tessellation control program to create a new variant.
1385 */
1386 bool
1387 st_translate_tessctrl_program(struct st_context *st,
1388 struct st_tessctrl_program *sttcp)
1389 {
1390 struct ureg_program *ureg;
1391
1392 ureg = ureg_create_with_screen(TGSI_PROCESSOR_TESS_CTRL, st->pipe->screen);
1393 if (ureg == NULL)
1394 return false;
1395
1396 ureg_property(ureg, TGSI_PROPERTY_TCS_VERTICES_OUT,
1397 sttcp->Base.VerticesOut);
1398
1399 st_translate_program_common(st, &sttcp->Base.Base, sttcp->glsl_to_tgsi,
1400 ureg, TGSI_PROCESSOR_TESS_CTRL, &sttcp->tgsi);
1401
1402 free_glsl_to_tgsi_visitor(sttcp->glsl_to_tgsi);
1403 sttcp->glsl_to_tgsi = NULL;
1404 return true;
1405 }
1406
1407
1408 static struct st_tcp_variant *
1409 st_create_tcp_variant(struct st_context *st,
1410 struct st_tessctrl_program *sttcp,
1411 const struct st_tcp_variant_key *key)
1412 {
1413 struct pipe_context *pipe = st->pipe;
1414 struct st_tcp_variant *tcpv;
1415
1416 tcpv = CALLOC_STRUCT(st_tcp_variant);
1417 if (!tcpv)
1418 return NULL;
1419
1420 /* fill in new variant */
1421 tcpv->driver_shader = pipe->create_tcs_state(pipe, &sttcp->tgsi);
1422 tcpv->key = *key;
1423 return tcpv;
1424 }
1425
1426
1427 /**
1428 * Get/create tessellation control program variant.
1429 */
1430 struct st_tcp_variant *
1431 st_get_tcp_variant(struct st_context *st,
1432 struct st_tessctrl_program *sttcp,
1433 const struct st_tcp_variant_key *key)
1434 {
1435 struct st_tcp_variant *tcpv;
1436
1437 /* Search for existing variant */
1438 for (tcpv = sttcp->variants; tcpv; tcpv = tcpv->next) {
1439 if (memcmp(&tcpv->key, key, sizeof(*key)) == 0) {
1440 break;
1441 }
1442 }
1443
1444 if (!tcpv) {
1445 /* create new */
1446 tcpv = st_create_tcp_variant(st, sttcp, key);
1447 if (tcpv) {
1448 /* insert into list */
1449 tcpv->next = sttcp->variants;
1450 sttcp->variants = tcpv;
1451 }
1452 }
1453
1454 return tcpv;
1455 }
1456
1457
1458 /**
1459 * Translate a tessellation evaluation program to create a new variant.
1460 */
1461 bool
1462 st_translate_tesseval_program(struct st_context *st,
1463 struct st_tesseval_program *sttep)
1464 {
1465 struct ureg_program *ureg;
1466
1467 ureg = ureg_create_with_screen(TGSI_PROCESSOR_TESS_EVAL, st->pipe->screen);
1468 if (ureg == NULL)
1469 return false;
1470
1471 if (sttep->Base.PrimitiveMode == GL_ISOLINES)
1472 ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, GL_LINES);
1473 else
1474 ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, sttep->Base.PrimitiveMode);
1475
1476 switch (sttep->Base.Spacing) {
1477 case GL_EQUAL:
1478 ureg_property(ureg, TGSI_PROPERTY_TES_SPACING, PIPE_TESS_SPACING_EQUAL);
1479 break;
1480 case GL_FRACTIONAL_EVEN:
1481 ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1482 PIPE_TESS_SPACING_FRACTIONAL_EVEN);
1483 break;
1484 case GL_FRACTIONAL_ODD:
1485 ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1486 PIPE_TESS_SPACING_FRACTIONAL_ODD);
1487 break;
1488 default:
1489 assert(0);
1490 }
1491
1492 ureg_property(ureg, TGSI_PROPERTY_TES_VERTEX_ORDER_CW,
1493 sttep->Base.VertexOrder == GL_CW);
1494 ureg_property(ureg, TGSI_PROPERTY_TES_POINT_MODE, sttep->Base.PointMode);
1495
1496 st_translate_program_common(st, &sttep->Base.Base, sttep->glsl_to_tgsi,
1497 ureg, TGSI_PROCESSOR_TESS_EVAL, &sttep->tgsi);
1498
1499 free_glsl_to_tgsi_visitor(sttep->glsl_to_tgsi);
1500 sttep->glsl_to_tgsi = NULL;
1501 return true;
1502 }
1503
1504
1505 static struct st_tep_variant *
1506 st_create_tep_variant(struct st_context *st,
1507 struct st_tesseval_program *sttep,
1508 const struct st_tep_variant_key *key)
1509 {
1510 struct pipe_context *pipe = st->pipe;
1511 struct st_tep_variant *tepv;
1512
1513 tepv = CALLOC_STRUCT(st_tep_variant);
1514 if (!tepv)
1515 return NULL;
1516
1517 /* fill in new variant */
1518 tepv->driver_shader = pipe->create_tes_state(pipe, &sttep->tgsi);
1519 tepv->key = *key;
1520 return tepv;
1521 }
1522
1523
1524 /**
1525 * Get/create tessellation evaluation program variant.
1526 */
1527 struct st_tep_variant *
1528 st_get_tep_variant(struct st_context *st,
1529 struct st_tesseval_program *sttep,
1530 const struct st_tep_variant_key *key)
1531 {
1532 struct st_tep_variant *tepv;
1533
1534 /* Search for existing variant */
1535 for (tepv = sttep->variants; tepv; tepv = tepv->next) {
1536 if (memcmp(&tepv->key, key, sizeof(*key)) == 0) {
1537 break;
1538 }
1539 }
1540
1541 if (!tepv) {
1542 /* create new */
1543 tepv = st_create_tep_variant(st, sttep, key);
1544 if (tepv) {
1545 /* insert into list */
1546 tepv->next = sttep->variants;
1547 sttep->variants = tepv;
1548 }
1549 }
1550
1551 return tepv;
1552 }
1553
1554
1555 /**
1556 * Vert/Geom/Frag programs have per-context variants. Free all the
1557 * variants attached to the given program which match the given context.
1558 */
1559 static void
1560 destroy_program_variants(struct st_context *st, struct gl_program *program)
1561 {
1562 if (!program || program == &_mesa_DummyProgram)
1563 return;
1564
1565 switch (program->Target) {
1566 case GL_VERTEX_PROGRAM_ARB:
1567 {
1568 struct st_vertex_program *stvp = (struct st_vertex_program *) program;
1569 struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
1570
1571 for (vpv = stvp->variants; vpv; ) {
1572 struct st_vp_variant *next = vpv->next;
1573 if (vpv->key.st == st) {
1574 /* unlink from list */
1575 *prevPtr = next;
1576 /* destroy this variant */
1577 delete_vp_variant(st, vpv);
1578 }
1579 else {
1580 prevPtr = &vpv->next;
1581 }
1582 vpv = next;
1583 }
1584 }
1585 break;
1586 case GL_FRAGMENT_PROGRAM_ARB:
1587 {
1588 struct st_fragment_program *stfp =
1589 (struct st_fragment_program *) program;
1590 struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
1591
1592 for (fpv = stfp->variants; fpv; ) {
1593 struct st_fp_variant *next = fpv->next;
1594 if (fpv->key.st == st) {
1595 /* unlink from list */
1596 *prevPtr = next;
1597 /* destroy this variant */
1598 delete_fp_variant(st, fpv);
1599 }
1600 else {
1601 prevPtr = &fpv->next;
1602 }
1603 fpv = next;
1604 }
1605 }
1606 break;
1607 case GL_GEOMETRY_PROGRAM_NV:
1608 {
1609 struct st_geometry_program *stgp =
1610 (struct st_geometry_program *) program;
1611 struct st_gp_variant *gpv, **prevPtr = &stgp->variants;
1612
1613 for (gpv = stgp->variants; gpv; ) {
1614 struct st_gp_variant *next = gpv->next;
1615 if (gpv->key.st == st) {
1616 /* unlink from list */
1617 *prevPtr = next;
1618 /* destroy this variant */
1619 delete_gp_variant(st, gpv);
1620 }
1621 else {
1622 prevPtr = &gpv->next;
1623 }
1624 gpv = next;
1625 }
1626 }
1627 break;
1628 case GL_TESS_CONTROL_PROGRAM_NV:
1629 {
1630 struct st_tessctrl_program *sttcp =
1631 (struct st_tessctrl_program *) program;
1632 struct st_tcp_variant *tcpv, **prevPtr = &sttcp->variants;
1633
1634 for (tcpv = sttcp->variants; tcpv; ) {
1635 struct st_tcp_variant *next = tcpv->next;
1636 if (tcpv->key.st == st) {
1637 /* unlink from list */
1638 *prevPtr = next;
1639 /* destroy this variant */
1640 delete_tcp_variant(st, tcpv);
1641 }
1642 else {
1643 prevPtr = &tcpv->next;
1644 }
1645 tcpv = next;
1646 }
1647 }
1648 break;
1649 case GL_TESS_EVALUATION_PROGRAM_NV:
1650 {
1651 struct st_tesseval_program *sttep =
1652 (struct st_tesseval_program *) program;
1653 struct st_tep_variant *tepv, **prevPtr = &sttep->variants;
1654
1655 for (tepv = sttep->variants; tepv; ) {
1656 struct st_tep_variant *next = tepv->next;
1657 if (tepv->key.st == st) {
1658 /* unlink from list */
1659 *prevPtr = next;
1660 /* destroy this variant */
1661 delete_tep_variant(st, tepv);
1662 }
1663 else {
1664 prevPtr = &tepv->next;
1665 }
1666 tepv = next;
1667 }
1668 }
1669 break;
1670 default:
1671 _mesa_problem(NULL, "Unexpected program target 0x%x in "
1672 "destroy_program_variants_cb()", program->Target);
1673 }
1674 }
1675
1676
1677 /**
1678 * Callback for _mesa_HashWalk. Free all the shader's program variants
1679 * which match the given context.
1680 */
1681 static void
1682 destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
1683 {
1684 struct st_context *st = (struct st_context *) userData;
1685 struct gl_shader *shader = (struct gl_shader *) data;
1686
1687 switch (shader->Type) {
1688 case GL_SHADER_PROGRAM_MESA:
1689 {
1690 struct gl_shader_program *shProg = (struct gl_shader_program *) data;
1691 GLuint i;
1692
1693 for (i = 0; i < shProg->NumShaders; i++) {
1694 destroy_program_variants(st, shProg->Shaders[i]->Program);
1695 }
1696
1697 for (i = 0; i < ARRAY_SIZE(shProg->_LinkedShaders); i++) {
1698 if (shProg->_LinkedShaders[i])
1699 destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
1700 }
1701 }
1702 break;
1703 case GL_VERTEX_SHADER:
1704 case GL_FRAGMENT_SHADER:
1705 case GL_GEOMETRY_SHADER:
1706 case GL_TESS_CONTROL_SHADER:
1707 case GL_TESS_EVALUATION_SHADER:
1708 {
1709 destroy_program_variants(st, shader->Program);
1710 }
1711 break;
1712 default:
1713 assert(0);
1714 }
1715 }
1716
1717
1718 /**
1719 * Callback for _mesa_HashWalk. Free all the program variants which match
1720 * the given context.
1721 */
1722 static void
1723 destroy_program_variants_cb(GLuint key, void *data, void *userData)
1724 {
1725 struct st_context *st = (struct st_context *) userData;
1726 struct gl_program *program = (struct gl_program *) data;
1727 destroy_program_variants(st, program);
1728 }
1729
1730
1731 /**
1732 * Walk over all shaders and programs to delete any variants which
1733 * belong to the given context.
1734 * This is called during context tear-down.
1735 */
1736 void
1737 st_destroy_program_variants(struct st_context *st)
1738 {
1739 /* If shaders can be shared with other contexts, the last context will
1740 * call DeleteProgram on all shaders, releasing everything.
1741 */
1742 if (st->has_shareable_shaders)
1743 return;
1744
1745 /* ARB vert/frag program */
1746 _mesa_HashWalk(st->ctx->Shared->Programs,
1747 destroy_program_variants_cb, st);
1748
1749 /* GLSL vert/frag/geom shaders */
1750 _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
1751 destroy_shader_program_variants_cb, st);
1752 }
1753
1754
1755 /**
1756 * For debugging, print/dump the current vertex program.
1757 */
1758 void
1759 st_print_current_vertex_program(void)
1760 {
1761 GET_CURRENT_CONTEXT(ctx);
1762
1763 if (ctx->VertexProgram._Current) {
1764 struct st_vertex_program *stvp =
1765 (struct st_vertex_program *) ctx->VertexProgram._Current;
1766 struct st_vp_variant *stv;
1767
1768 debug_printf("Vertex program %u\n", stvp->Base.Base.Id);
1769
1770 for (stv = stvp->variants; stv; stv = stv->next) {
1771 debug_printf("variant %p\n", stv);
1772 tgsi_dump(stv->tgsi.tokens, 0);
1773 }
1774 }
1775 }
1776
1777
1778 /**
1779 * Compile one shader variant.
1780 */
1781 void
1782 st_precompile_shader_variant(struct st_context *st,
1783 struct gl_program *prog)
1784 {
1785 switch (prog->Target) {
1786 case GL_VERTEX_PROGRAM_ARB: {
1787 struct st_vertex_program *p = (struct st_vertex_program *)prog;
1788 struct st_vp_variant_key key;
1789
1790 memset(&key, 0, sizeof(key));
1791 key.st = st->has_shareable_shaders ? NULL : st;
1792 st_get_vp_variant(st, p, &key);
1793 break;
1794 }
1795
1796 case GL_TESS_CONTROL_PROGRAM_NV: {
1797 struct st_tessctrl_program *p = (struct st_tessctrl_program *)prog;
1798 struct st_tcp_variant_key key;
1799
1800 memset(&key, 0, sizeof(key));
1801 key.st = st->has_shareable_shaders ? NULL : st;
1802 st_get_tcp_variant(st, p, &key);
1803 break;
1804 }
1805
1806 case GL_TESS_EVALUATION_PROGRAM_NV: {
1807 struct st_tesseval_program *p = (struct st_tesseval_program *)prog;
1808 struct st_tep_variant_key key;
1809
1810 memset(&key, 0, sizeof(key));
1811 key.st = st->has_shareable_shaders ? NULL : st;
1812 st_get_tep_variant(st, p, &key);
1813 break;
1814 }
1815
1816 case GL_GEOMETRY_PROGRAM_NV: {
1817 struct st_geometry_program *p = (struct st_geometry_program *)prog;
1818 struct st_gp_variant_key key;
1819
1820 memset(&key, 0, sizeof(key));
1821 key.st = st->has_shareable_shaders ? NULL : st;
1822 st_get_gp_variant(st, p, &key);
1823 break;
1824 }
1825
1826 case GL_FRAGMENT_PROGRAM_ARB: {
1827 struct st_fragment_program *p = (struct st_fragment_program *)prog;
1828 struct st_fp_variant_key key;
1829
1830 memset(&key, 0, sizeof(key));
1831 key.st = st->has_shareable_shaders ? NULL : st;
1832 st_get_fp_variant(st, p, &key);
1833 break;
1834 }
1835
1836 default:
1837 assert(0);
1838 }
1839 }