projects / mesa.git / blob
? search:


41ebfa9003f829a62636e36a5689001afff58641
[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 "compiler/nir/nir.h"
42
43 #include "pipe/p_context.h"
44 #include "pipe/p_defines.h"
45 #include "pipe/p_shader_tokens.h"
46 #include "draw/draw_context.h"
47 #include "tgsi/tgsi_dump.h"
48 #include "tgsi/tgsi_emulate.h"
49 #include "tgsi/tgsi_parse.h"
50 #include "tgsi/tgsi_ureg.h"
51
52 #include "st_debug.h"
53 #include "st_cb_bitmap.h"
54 #include "st_cb_drawpixels.h"
55 #include "st_context.h"
56 #include "st_tgsi_lower_yuv.h"
57 #include "st_program.h"
58 #include "st_mesa_to_tgsi.h"
59 #include "st_atifs_to_tgsi.h"
60 #include "st_nir.h"
61 #include "st_shader_cache.h"
62 #include "cso_cache/cso_context.h"
63
64
65
66 static void
67 set_affected_state_flags(uint64_t *states,
68 struct gl_program *prog,
69 uint64_t new_constants,
70 uint64_t new_sampler_views,
71 uint64_t new_samplers,
72 uint64_t new_images,
73 uint64_t new_ubos,
74 uint64_t new_ssbos,
75 uint64_t new_atomics)
76 {
77 if (prog->Parameters->NumParameters)
78 *states |= new_constants;
79
80 if (prog->info.num_textures)
81 *states |= new_sampler_views | new_samplers;
82
83 if (prog->info.num_images)
84 *states |= new_images;
85
86 if (prog->info.num_ubos)
87 *states |= new_ubos;
88
89 if (prog->info.num_ssbos)
90 *states |= new_ssbos;
91
92 if (prog->info.num_abos)
93 *states |= new_atomics;
94 }
95
96 /**
97 * This determines which states will be updated when the shader is bound.
98 */
99 void
100 st_set_prog_affected_state_flags(struct gl_program *prog)
101 {
102 uint64_t *states;
103
104 switch (prog->info.stage) {
105 case MESA_SHADER_VERTEX:
106 states = &((struct st_vertex_program*)prog)->affected_states;
107
108 *states = ST_NEW_VS_STATE |
109 ST_NEW_RASTERIZER |
110 ST_NEW_VERTEX_ARRAYS;
111
112 set_affected_state_flags(states, prog,
113 ST_NEW_VS_CONSTANTS,
114 ST_NEW_VS_SAMPLER_VIEWS,
115 ST_NEW_VS_SAMPLERS,
116 ST_NEW_VS_IMAGES,
117 ST_NEW_VS_UBOS,
118 ST_NEW_VS_SSBOS,
119 ST_NEW_VS_ATOMICS);
120 break;
121
122 case MESA_SHADER_TESS_CTRL:
123 states = &(st_common_program(prog))->affected_states;
124
125 *states = ST_NEW_TCS_STATE;
126
127 set_affected_state_flags(states, prog,
128 ST_NEW_TCS_CONSTANTS,
129 ST_NEW_TCS_SAMPLER_VIEWS,
130 ST_NEW_TCS_SAMPLERS,
131 ST_NEW_TCS_IMAGES,
132 ST_NEW_TCS_UBOS,
133 ST_NEW_TCS_SSBOS,
134 ST_NEW_TCS_ATOMICS);
135 break;
136
137 case MESA_SHADER_TESS_EVAL:
138 states = &(st_common_program(prog))->affected_states;
139
140 *states = ST_NEW_TES_STATE |
141 ST_NEW_RASTERIZER;
142
143 set_affected_state_flags(states, prog,
144 ST_NEW_TES_CONSTANTS,
145 ST_NEW_TES_SAMPLER_VIEWS,
146 ST_NEW_TES_SAMPLERS,
147 ST_NEW_TES_IMAGES,
148 ST_NEW_TES_UBOS,
149 ST_NEW_TES_SSBOS,
150 ST_NEW_TES_ATOMICS);
151 break;
152
153 case MESA_SHADER_GEOMETRY:
154 states = &(st_common_program(prog))->affected_states;
155
156 *states = ST_NEW_GS_STATE |
157 ST_NEW_RASTERIZER;
158
159 set_affected_state_flags(states, prog,
160 ST_NEW_GS_CONSTANTS,
161 ST_NEW_GS_SAMPLER_VIEWS,
162 ST_NEW_GS_SAMPLERS,
163 ST_NEW_GS_IMAGES,
164 ST_NEW_GS_UBOS,
165 ST_NEW_GS_SSBOS,
166 ST_NEW_GS_ATOMICS);
167 break;
168
169 case MESA_SHADER_FRAGMENT:
170 states = &((struct st_fragment_program*)prog)->affected_states;
171
172 /* gl_FragCoord and glDrawPixels always use constants. */
173 *states = ST_NEW_FS_STATE |
174 ST_NEW_SAMPLE_SHADING |
175 ST_NEW_FS_CONSTANTS;
176
177 set_affected_state_flags(states, prog,
178 ST_NEW_FS_CONSTANTS,
179 ST_NEW_FS_SAMPLER_VIEWS,
180 ST_NEW_FS_SAMPLERS,
181 ST_NEW_FS_IMAGES,
182 ST_NEW_FS_UBOS,
183 ST_NEW_FS_SSBOS,
184 ST_NEW_FS_ATOMICS);
185 break;
186
187 case MESA_SHADER_COMPUTE:
188 states = &((struct st_compute_program*)prog)->affected_states;
189
190 *states = ST_NEW_CS_STATE;
191
192 set_affected_state_flags(states, prog,
193 ST_NEW_CS_CONSTANTS,
194 ST_NEW_CS_SAMPLER_VIEWS,
195 ST_NEW_CS_SAMPLERS,
196 ST_NEW_CS_IMAGES,
197 ST_NEW_CS_UBOS,
198 ST_NEW_CS_SSBOS,
199 ST_NEW_CS_ATOMICS);
200 break;
201
202 default:
203 unreachable("unhandled shader stage");
204 }
205 }
206
207 /**
208 * Delete a vertex program variant. Note the caller must unlink
209 * the variant from the linked list.
210 */
211 static void
212 delete_vp_variant(struct st_context *st, struct st_vp_variant *vpv)
213 {
214 if (vpv->driver_shader)
215 cso_delete_vertex_shader(st->cso_context, vpv->driver_shader);
216
217 if (vpv->draw_shader)
218 draw_delete_vertex_shader( st->draw, vpv->draw_shader );
219
220 if (((vpv->tgsi.type == PIPE_SHADER_IR_TGSI)) && vpv->tgsi.tokens)
221 ureg_free_tokens(vpv->tgsi.tokens);
222
223 free( vpv );
224 }
225
226
227
228 /**
229 * Clean out any old compilations:
230 */
231 void
232 st_release_vp_variants( struct st_context *st,
233 struct st_vertex_program *stvp )
234 {
235 struct st_vp_variant *vpv;
236
237 for (vpv = stvp->variants; vpv; ) {
238 struct st_vp_variant *next = vpv->next;
239 delete_vp_variant(st, vpv);
240 vpv = next;
241 }
242
243 stvp->variants = NULL;
244
245 if ((stvp->tgsi.type == PIPE_SHADER_IR_TGSI) && stvp->tgsi.tokens) {
246 tgsi_free_tokens(stvp->tgsi.tokens);
247 stvp->tgsi.tokens = NULL;
248 }
249 }
250
251
252
253 /**
254 * Delete a fragment program variant. Note the caller must unlink
255 * the variant from the linked list.
256 */
257 static void
258 delete_fp_variant(struct st_context *st, struct st_fp_variant *fpv)
259 {
260 if (fpv->driver_shader)
261 cso_delete_fragment_shader(st->cso_context, fpv->driver_shader);
262 free(fpv);
263 }
264
265
266 /**
267 * Free all variants of a fragment program.
268 */
269 void
270 st_release_fp_variants(struct st_context *st, struct st_fragment_program *stfp)
271 {
272 struct st_fp_variant *fpv;
273
274 for (fpv = stfp->variants; fpv; ) {
275 struct st_fp_variant *next = fpv->next;
276 delete_fp_variant(st, fpv);
277 fpv = next;
278 }
279
280 stfp->variants = NULL;
281
282 if ((stfp->tgsi.type == PIPE_SHADER_IR_TGSI) && stfp->tgsi.tokens) {
283 ureg_free_tokens(stfp->tgsi.tokens);
284 stfp->tgsi.tokens = NULL;
285 }
286 }
287
288
289 /**
290 * Delete a basic program variant. Note the caller must unlink
291 * the variant from the linked list.
292 */
293 static void
294 delete_basic_variant(struct st_context *st, struct st_basic_variant *v,
295 GLenum target)
296 {
297 if (v->driver_shader) {
298 switch (target) {
299 case GL_TESS_CONTROL_PROGRAM_NV:
300 cso_delete_tessctrl_shader(st->cso_context, v->driver_shader);
301 break;
302 case GL_TESS_EVALUATION_PROGRAM_NV:
303 cso_delete_tesseval_shader(st->cso_context, v->driver_shader);
304 break;
305 case GL_GEOMETRY_PROGRAM_NV:
306 cso_delete_geometry_shader(st->cso_context, v->driver_shader);
307 break;
308 case GL_COMPUTE_PROGRAM_NV:
309 cso_delete_compute_shader(st->cso_context, v->driver_shader);
310 break;
311 default:
312 assert(!"this shouldn't occur");
313 }
314 }
315
316 free(v);
317 }
318
319
320 /**
321 * Free all basic program variants.
322 */
323 void
324 st_release_basic_variants(struct st_context *st, GLenum target,
325 struct st_basic_variant **variants,
326 struct pipe_shader_state *tgsi)
327 {
328 struct st_basic_variant *v;
329
330 for (v = *variants; v; ) {
331 struct st_basic_variant *next = v->next;
332 delete_basic_variant(st, v, target);
333 v = next;
334 }
335
336 *variants = NULL;
337
338 if (tgsi->tokens) {
339 ureg_free_tokens(tgsi->tokens);
340 tgsi->tokens = NULL;
341 }
342 }
343
344
345 /**
346 * Free all variants of a compute program.
347 */
348 void
349 st_release_cp_variants(struct st_context *st, struct st_compute_program *stcp)
350 {
351 struct st_basic_variant **variants = &stcp->variants;
352 struct st_basic_variant *v;
353
354 for (v = *variants; v; ) {
355 struct st_basic_variant *next = v->next;
356 delete_basic_variant(st, v, stcp->Base.Target);
357 v = next;
358 }
359
360 *variants = NULL;
361
362 if (stcp->tgsi.prog) {
363 ureg_free_tokens(stcp->tgsi.prog);
364 stcp->tgsi.prog = NULL;
365 }
366 }
367
368 /**
369 * Translate a vertex program.
370 */
371 bool
372 st_translate_vertex_program(struct st_context *st,
373 struct st_vertex_program *stvp)
374 {
375 struct ureg_program *ureg;
376 enum pipe_error error;
377 unsigned num_outputs = 0;
378 unsigned attr;
379 ubyte input_to_index[VERT_ATTRIB_MAX] = {0};
380 ubyte output_semantic_name[VARYING_SLOT_MAX] = {0};
381 ubyte output_semantic_index[VARYING_SLOT_MAX] = {0};
382
383 stvp->num_inputs = 0;
384
385 if (stvp->Base.arb.IsPositionInvariant)
386 _mesa_insert_mvp_code(st->ctx, &stvp->Base);
387
388 /*
389 * Determine number of inputs, the mappings between VERT_ATTRIB_x
390 * and TGSI generic input indexes, plus input attrib semantic info.
391 */
392 for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
393 if ((stvp->Base.info.inputs_read & BITFIELD64_BIT(attr)) != 0) {
394 input_to_index[attr] = stvp->num_inputs;
395 stvp->index_to_input[stvp->num_inputs] = attr;
396 stvp->num_inputs++;
397 if ((stvp->Base.info.double_inputs_read &
398 BITFIELD64_BIT(attr)) != 0) {
399 /* add placeholder for second part of a double attribute */
400 stvp->index_to_input[stvp->num_inputs] = ST_DOUBLE_ATTRIB_PLACEHOLDER;
401 stvp->num_inputs++;
402 }
403 }
404 }
405 /* bit of a hack, presetup potentially unused edgeflag input */
406 input_to_index[VERT_ATTRIB_EDGEFLAG] = stvp->num_inputs;
407 stvp->index_to_input[stvp->num_inputs] = VERT_ATTRIB_EDGEFLAG;
408
409 /* Compute mapping of vertex program outputs to slots.
410 */
411 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
412 if ((stvp->Base.info.outputs_written & BITFIELD64_BIT(attr)) == 0) {
413 stvp->result_to_output[attr] = ~0;
414 }
415 else {
416 unsigned slot = num_outputs++;
417
418 stvp->result_to_output[attr] = slot;
419
420 unsigned semantic_name, semantic_index;
421 tgsi_get_gl_varying_semantic(attr, st->needs_texcoord_semantic,
422 &semantic_name, &semantic_index);
423 output_semantic_name[slot] = semantic_name;
424 output_semantic_index[slot] = semantic_index;
425 }
426 }
427 /* similar hack to above, presetup potentially unused edgeflag output */
428 stvp->result_to_output[VARYING_SLOT_EDGE] = num_outputs;
429 output_semantic_name[num_outputs] = TGSI_SEMANTIC_EDGEFLAG;
430 output_semantic_index[num_outputs] = 0;
431
432 /* ARB_vp: */
433 if (!stvp->glsl_to_tgsi && !stvp->shader_program) {
434 _mesa_remove_output_reads(&stvp->Base, PROGRAM_OUTPUT);
435
436 /* This determines which states will be updated when the assembly
437 * shader is bound.
438 */
439 stvp->affected_states = ST_NEW_VS_STATE |
440 ST_NEW_RASTERIZER |
441 ST_NEW_VERTEX_ARRAYS;
442
443 if (stvp->Base.Parameters->NumParameters)
444 stvp->affected_states |= ST_NEW_VS_CONSTANTS;
445
446 /* No samplers are allowed in ARB_vp. */
447 }
448
449 if (stvp->shader_program) {
450 nir_shader *nir = st_glsl_to_nir(st, &stvp->Base, stvp->shader_program,
451 MESA_SHADER_VERTEX);
452
453 stvp->tgsi.type = PIPE_SHADER_IR_NIR;
454 stvp->tgsi.ir.nir = nir;
455
456 struct gl_program *prog = stvp->shader_program->last_vert_prog;
457 if (prog) {
458 st_translate_stream_output_info2(prog->sh.LinkedTransformFeedback,
459 stvp->result_to_output,
460 &stvp->tgsi.stream_output);
461 }
462
463 return true;
464 }
465
466 ureg = ureg_create_with_screen(PIPE_SHADER_VERTEX, st->pipe->screen);
467 if (ureg == NULL)
468 return false;
469
470 if (stvp->Base.info.clip_distance_array_size)
471 ureg_property(ureg, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED,
472 stvp->Base.info.clip_distance_array_size);
473 if (stvp->Base.info.cull_distance_array_size)
474 ureg_property(ureg, TGSI_PROPERTY_NUM_CULLDIST_ENABLED,
475 stvp->Base.info.cull_distance_array_size);
476
477 if (ST_DEBUG & DEBUG_MESA) {
478 _mesa_print_program(&stvp->Base);
479 _mesa_print_program_parameters(st->ctx, &stvp->Base);
480 debug_printf("\n");
481 }
482
483 if (stvp->glsl_to_tgsi) {
484 error = st_translate_program(st->ctx,
485 PIPE_SHADER_VERTEX,
486 ureg,
487 stvp->glsl_to_tgsi,
488 &stvp->Base,
489 /* inputs */
490 stvp->num_inputs,
491 input_to_index,
492 NULL, /* inputSlotToAttr */
493 NULL, /* input semantic name */
494 NULL, /* input semantic index */
495 NULL, /* interp mode */
496 /* outputs */
497 num_outputs,
498 stvp->result_to_output,
499 output_semantic_name,
500 output_semantic_index);
501
502 st_translate_stream_output_info(stvp->glsl_to_tgsi,
503 stvp->result_to_output,
504 &stvp->tgsi.stream_output);
505
506 free_glsl_to_tgsi_visitor(stvp->glsl_to_tgsi);
507 } else
508 error = st_translate_mesa_program(st->ctx,
509 PIPE_SHADER_VERTEX,
510 ureg,
511 &stvp->Base,
512 /* inputs */
513 stvp->num_inputs,
514 input_to_index,
515 NULL, /* input semantic name */
516 NULL, /* input semantic index */
517 NULL,
518 /* outputs */
519 num_outputs,
520 stvp->result_to_output,
521 output_semantic_name,
522 output_semantic_index);
523
524 if (error) {
525 debug_printf("%s: failed to translate Mesa program:\n", __func__);
526 _mesa_print_program(&stvp->Base);
527 debug_assert(0);
528 return false;
529 }
530
531 unsigned num_tokens;
532 stvp->tgsi.tokens = ureg_get_tokens(ureg, &num_tokens);
533 ureg_destroy(ureg);
534
535 if (stvp->glsl_to_tgsi) {
536 stvp->glsl_to_tgsi = NULL;
537 st_store_tgsi_in_disk_cache(st, &stvp->Base, NULL, num_tokens);
538 }
539
540 return stvp->tgsi.tokens != NULL;
541 }
542
543 static struct st_vp_variant *
544 st_create_vp_variant(struct st_context *st,
545 struct st_vertex_program *stvp,
546 const struct st_vp_variant_key *key)
547 {
548 struct st_vp_variant *vpv = CALLOC_STRUCT(st_vp_variant);
549 struct pipe_context *pipe = st->pipe;
550
551 vpv->key = *key;
552 vpv->tgsi.stream_output = stvp->tgsi.stream_output;
553 vpv->num_inputs = stvp->num_inputs;
554
555 if (stvp->tgsi.type == PIPE_SHADER_IR_NIR) {
556 vpv->tgsi.type = PIPE_SHADER_IR_NIR;
557 vpv->tgsi.ir.nir = nir_shader_clone(NULL, stvp->tgsi.ir.nir);
558 if (key->clamp_color)
559 NIR_PASS_V(vpv->tgsi.ir.nir, nir_lower_clamp_color_outputs);
560 if (key->passthrough_edgeflags) {
561 NIR_PASS_V(vpv->tgsi.ir.nir, nir_lower_passthrough_edgeflags);
562 vpv->num_inputs++;
563 }
564
565 st_finalize_nir(st, &stvp->Base, vpv->tgsi.ir.nir);
566
567 vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
568 /* driver takes ownership of IR: */
569 vpv->tgsi.ir.nir = NULL;
570 return vpv;
571 }
572
573 vpv->tgsi.tokens = tgsi_dup_tokens(stvp->tgsi.tokens);
574
575 /* Emulate features. */
576 if (key->clamp_color || key->passthrough_edgeflags) {
577 const struct tgsi_token *tokens;
578 unsigned flags =
579 (key->clamp_color ? TGSI_EMU_CLAMP_COLOR_OUTPUTS : 0) |
580 (key->passthrough_edgeflags ? TGSI_EMU_PASSTHROUGH_EDGEFLAG : 0);
581
582 tokens = tgsi_emulate(vpv->tgsi.tokens, flags);
583
584 if (tokens) {
585 tgsi_free_tokens(vpv->tgsi.tokens);
586 vpv->tgsi.tokens = tokens;
587
588 if (key->passthrough_edgeflags)
589 vpv->num_inputs++;
590 } else
591 fprintf(stderr, "mesa: cannot emulate deprecated features\n");
592 }
593
594 if (ST_DEBUG & DEBUG_TGSI) {
595 tgsi_dump(vpv->tgsi.tokens, 0);
596 debug_printf("\n");
597 }
598
599 vpv->driver_shader = pipe->create_vs_state(pipe, &vpv->tgsi);
600 return vpv;
601 }
602
603
604 /**
605 * Find/create a vertex program variant.
606 */
607 struct st_vp_variant *
608 st_get_vp_variant(struct st_context *st,
609 struct st_vertex_program *stvp,
610 const struct st_vp_variant_key *key)
611 {
612 struct st_vp_variant *vpv;
613
614 /* Search for existing variant */
615 for (vpv = stvp->variants; vpv; vpv = vpv->next) {
616 if (memcmp(&vpv->key, key, sizeof(*key)) == 0) {
617 break;
618 }
619 }
620
621 if (!vpv) {
622 /* create now */
623 vpv = st_create_vp_variant(st, stvp, key);
624 if (vpv) {
625 /* insert into list */
626 vpv->next = stvp->variants;
627 stvp->variants = vpv;
628 }
629 }
630
631 return vpv;
632 }
633
634
635 /**
636 * Translate a Mesa fragment shader into a TGSI shader.
637 */
638 bool
639 st_translate_fragment_program(struct st_context *st,
640 struct st_fragment_program *stfp)
641 {
642 ubyte outputMapping[2 * FRAG_RESULT_MAX];
643 ubyte inputMapping[VARYING_SLOT_MAX];
644 ubyte inputSlotToAttr[VARYING_SLOT_MAX];
645 ubyte interpMode[PIPE_MAX_SHADER_INPUTS]; /* XXX size? */
646 GLuint attr;
647 GLbitfield64 inputsRead;
648 struct ureg_program *ureg;
649
650 GLboolean write_all = GL_FALSE;
651
652 ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
653 ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
654 uint fs_num_inputs = 0;
655
656 ubyte fs_output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
657 ubyte fs_output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
658 uint fs_num_outputs = 0;
659
660 memset(inputSlotToAttr, ~0, sizeof(inputSlotToAttr));
661
662 /* Non-GLSL programs: */
663 if (!stfp->glsl_to_tgsi && !stfp->shader_program) {
664 _mesa_remove_output_reads(&stfp->Base, PROGRAM_OUTPUT);
665 if (st->ctx->Const.GLSLFragCoordIsSysVal)
666 _mesa_program_fragment_position_to_sysval(&stfp->Base);
667
668 /* This determines which states will be updated when the assembly
669 * shader is bound.
670 *
671 * fragment.position and glDrawPixels always use constants.
672 */
673 stfp->affected_states = ST_NEW_FS_STATE |
674 ST_NEW_SAMPLE_SHADING |
675 ST_NEW_FS_CONSTANTS;
676
677 if (stfp->ati_fs) {
678 /* Just set them for ATI_fs unconditionally. */
679 stfp->affected_states |= ST_NEW_FS_SAMPLER_VIEWS |
680 ST_NEW_FS_SAMPLERS;
681 } else {
682 /* ARB_fp */
683 if (stfp->Base.SamplersUsed)
684 stfp->affected_states |= ST_NEW_FS_SAMPLER_VIEWS |
685 ST_NEW_FS_SAMPLERS;
686 }
687 }
688
689 /*
690 * Convert Mesa program inputs to TGSI input register semantics.
691 */
692 inputsRead = stfp->Base.info.inputs_read;
693 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
694 if ((inputsRead & BITFIELD64_BIT(attr)) != 0) {
695 const GLuint slot = fs_num_inputs++;
696
697 inputMapping[attr] = slot;
698 inputSlotToAttr[slot] = attr;
699
700 switch (attr) {
701 case VARYING_SLOT_POS:
702 input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
703 input_semantic_index[slot] = 0;
704 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
705 break;
706 case VARYING_SLOT_COL0:
707 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
708 input_semantic_index[slot] = 0;
709 interpMode[slot] = stfp->glsl_to_tgsi ?
710 TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_COLOR;
711 break;
712 case VARYING_SLOT_COL1:
713 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
714 input_semantic_index[slot] = 1;
715 interpMode[slot] = stfp->glsl_to_tgsi ?
716 TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_COLOR;
717 break;
718 case VARYING_SLOT_FOGC:
719 input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
720 input_semantic_index[slot] = 0;
721 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
722 break;
723 case VARYING_SLOT_FACE:
724 input_semantic_name[slot] = TGSI_SEMANTIC_FACE;
725 input_semantic_index[slot] = 0;
726 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
727 break;
728 case VARYING_SLOT_PRIMITIVE_ID:
729 input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
730 input_semantic_index[slot] = 0;
731 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
732 break;
733 case VARYING_SLOT_LAYER:
734 input_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
735 input_semantic_index[slot] = 0;
736 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
737 break;
738 case VARYING_SLOT_VIEWPORT:
739 input_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
740 input_semantic_index[slot] = 0;
741 interpMode[slot] = TGSI_INTERPOLATE_CONSTANT;
742 break;
743 case VARYING_SLOT_CLIP_DIST0:
744 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
745 input_semantic_index[slot] = 0;
746 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
747 break;
748 case VARYING_SLOT_CLIP_DIST1:
749 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
750 input_semantic_index[slot] = 1;
751 interpMode[slot] = TGSI_INTERPOLATE_PERSPECTIVE;
752 break;
753 case VARYING_SLOT_CULL_DIST0:
754 case VARYING_SLOT_CULL_DIST1:
755 /* these should have been lowered by GLSL */
756 assert(0);
757 break;
758 /* In most cases, there is nothing special about these
759 * inputs, so adopt a convention to use the generic
760 * semantic name and the mesa VARYING_SLOT_ number as the
761 * index.
762 *
763 * All that is required is that the vertex shader labels
764 * its own outputs similarly, and that the vertex shader
765 * generates at least every output required by the
766 * fragment shader plus fixed-function hardware (such as
767 * BFC).
768 *
769 * However, some drivers may need us to identify the PNTC and TEXi
770 * varyings if, for example, their capability to replace them with
771 * sprite coordinates is limited.
772 */
773 case VARYING_SLOT_PNTC:
774 if (st->needs_texcoord_semantic) {
775 input_semantic_name[slot] = TGSI_SEMANTIC_PCOORD;
776 input_semantic_index[slot] = 0;
777 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
778 break;
779 }
780 /* fall through */
781 case VARYING_SLOT_TEX0:
782 case VARYING_SLOT_TEX1:
783 case VARYING_SLOT_TEX2:
784 case VARYING_SLOT_TEX3:
785 case VARYING_SLOT_TEX4:
786 case VARYING_SLOT_TEX5:
787 case VARYING_SLOT_TEX6:
788 case VARYING_SLOT_TEX7:
789 if (st->needs_texcoord_semantic) {
790 input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
791 input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
792 interpMode[slot] = stfp->glsl_to_tgsi ?
793 TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_PERSPECTIVE;
794 break;
795 }
796 /* fall through */
797 case VARYING_SLOT_VAR0:
798 default:
799 /* Semantic indices should be zero-based because drivers may choose
800 * to assign a fixed slot determined by that index.
801 * This is useful because ARB_separate_shader_objects uses location
802 * qualifiers for linkage, and if the semantic index corresponds to
803 * these locations, linkage passes in the driver become unecessary.
804 *
805 * If needs_texcoord_semantic is true, no semantic indices will be
806 * consumed for the TEXi varyings, and we can base the locations of
807 * the user varyings on VAR0. Otherwise, we use TEX0 as base index.
808 */
809 assert(attr >= VARYING_SLOT_VAR0 || attr == VARYING_SLOT_PNTC ||
810 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
811 input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
812 input_semantic_index[slot] = st_get_generic_varying_index(st, attr);
813 if (attr == VARYING_SLOT_PNTC)
814 interpMode[slot] = TGSI_INTERPOLATE_LINEAR;
815 else {
816 interpMode[slot] = stfp->glsl_to_tgsi ?
817 TGSI_INTERPOLATE_COUNT : TGSI_INTERPOLATE_PERSPECTIVE;
818 }
819 break;
820 }
821 }
822 else {
823 inputMapping[attr] = -1;
824 }
825 }
826
827 /*
828 * Semantics and mapping for outputs
829 */
830 GLbitfield64 outputsWritten = stfp->Base.info.outputs_written;
831
832 /* if z is written, emit that first */
833 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
834 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
835 fs_output_semantic_index[fs_num_outputs] = 0;
836 outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
837 fs_num_outputs++;
838 outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
839 }
840
841 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
842 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
843 fs_output_semantic_index[fs_num_outputs] = 0;
844 outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
845 fs_num_outputs++;
846 outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
847 }
848
849 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK)) {
850 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_SAMPLEMASK;
851 fs_output_semantic_index[fs_num_outputs] = 0;
852 outputMapping[FRAG_RESULT_SAMPLE_MASK] = fs_num_outputs;
853 fs_num_outputs++;
854 outputsWritten &= ~(1 << FRAG_RESULT_SAMPLE_MASK);
855 }
856
857 /* handle remaining outputs (color) */
858 for (attr = 0; attr < ARRAY_SIZE(outputMapping); attr++) {
859 const GLbitfield64 written = attr < FRAG_RESULT_MAX ? outputsWritten :
860 stfp->Base.SecondaryOutputsWritten;
861 const unsigned loc = attr % FRAG_RESULT_MAX;
862
863 if (written & BITFIELD64_BIT(loc)) {
864 switch (loc) {
865 case FRAG_RESULT_DEPTH:
866 case FRAG_RESULT_STENCIL:
867 case FRAG_RESULT_SAMPLE_MASK:
868 /* handled above */
869 assert(0);
870 break;
871 case FRAG_RESULT_COLOR:
872 write_all = GL_TRUE; /* fallthrough */
873 default: {
874 int index;
875 assert(loc == FRAG_RESULT_COLOR ||
876 (FRAG_RESULT_DATA0 <= loc && loc < FRAG_RESULT_MAX));
877
878 index = (loc == FRAG_RESULT_COLOR) ? 0 : (loc - FRAG_RESULT_DATA0);
879
880 if (attr >= FRAG_RESULT_MAX) {
881 /* Secondary color for dual source blending. */
882 assert(index == 0);
883 index++;
884 }
885
886 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
887 fs_output_semantic_index[fs_num_outputs] = index;
888 outputMapping[attr] = fs_num_outputs;
889 break;
890 }
891 }
892
893 fs_num_outputs++;
894 }
895 }
896
897 if (stfp->shader_program) {
898 nir_shader *nir = st_glsl_to_nir(st, &stfp->Base, stfp->shader_program,
899 MESA_SHADER_FRAGMENT);
900
901 stfp->tgsi.type = PIPE_SHADER_IR_NIR;
902 stfp->tgsi.ir.nir = nir;
903
904 return true;
905 }
906
907 ureg = ureg_create_with_screen(PIPE_SHADER_FRAGMENT, st->pipe->screen);
908 if (ureg == NULL)
909 return false;
910
911 if (ST_DEBUG & DEBUG_MESA) {
912 _mesa_print_program(&stfp->Base);
913 _mesa_print_program_parameters(st->ctx, &stfp->Base);
914 debug_printf("\n");
915 }
916 if (write_all == GL_TRUE)
917 ureg_property(ureg, TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS, 1);
918
919 if (stfp->Base.info.fs.depth_layout != FRAG_DEPTH_LAYOUT_NONE) {
920 switch (stfp->Base.info.fs.depth_layout) {
921 case FRAG_DEPTH_LAYOUT_ANY:
922 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
923 TGSI_FS_DEPTH_LAYOUT_ANY);
924 break;
925 case FRAG_DEPTH_LAYOUT_GREATER:
926 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
927 TGSI_FS_DEPTH_LAYOUT_GREATER);
928 break;
929 case FRAG_DEPTH_LAYOUT_LESS:
930 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
931 TGSI_FS_DEPTH_LAYOUT_LESS);
932 break;
933 case FRAG_DEPTH_LAYOUT_UNCHANGED:
934 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
935 TGSI_FS_DEPTH_LAYOUT_UNCHANGED);
936 break;
937 default:
938 assert(0);
939 }
940 }
941
942 if (stfp->glsl_to_tgsi) {
943 st_translate_program(st->ctx,
944 PIPE_SHADER_FRAGMENT,
945 ureg,
946 stfp->glsl_to_tgsi,
947 &stfp->Base,
948 /* inputs */
949 fs_num_inputs,
950 inputMapping,
951 inputSlotToAttr,
952 input_semantic_name,
953 input_semantic_index,
954 interpMode,
955 /* outputs */
956 fs_num_outputs,
957 outputMapping,
958 fs_output_semantic_name,
959 fs_output_semantic_index);
960
961 free_glsl_to_tgsi_visitor(stfp->glsl_to_tgsi);
962 } else if (stfp->ati_fs)
963 st_translate_atifs_program(ureg,
964 stfp->ati_fs,
965 &stfp->Base,
966 /* inputs */
967 fs_num_inputs,
968 inputMapping,
969 input_semantic_name,
970 input_semantic_index,
971 interpMode,
972 /* outputs */
973 fs_num_outputs,
974 outputMapping,
975 fs_output_semantic_name,
976 fs_output_semantic_index);
977 else
978 st_translate_mesa_program(st->ctx,
979 PIPE_SHADER_FRAGMENT,
980 ureg,
981 &stfp->Base,
982 /* inputs */
983 fs_num_inputs,
984 inputMapping,
985 input_semantic_name,
986 input_semantic_index,
987 interpMode,
988 /* outputs */
989 fs_num_outputs,
990 outputMapping,
991 fs_output_semantic_name,
992 fs_output_semantic_index);
993
994 unsigned num_tokens;
995 stfp->tgsi.tokens = ureg_get_tokens(ureg, &num_tokens);
996 ureg_destroy(ureg);
997
998 if (stfp->glsl_to_tgsi) {
999 stfp->glsl_to_tgsi = NULL;
1000 st_store_tgsi_in_disk_cache(st, &stfp->Base, NULL, num_tokens);
1001 }
1002
1003 return stfp->tgsi.tokens != NULL;
1004 }
1005
1006 static struct st_fp_variant *
1007 st_create_fp_variant(struct st_context *st,
1008 struct st_fragment_program *stfp,
1009 const struct st_fp_variant_key *key)
1010 {
1011 struct pipe_context *pipe = st->pipe;
1012 struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
1013 struct pipe_shader_state tgsi = {0};
1014 struct gl_program_parameter_list *params = stfp->Base.Parameters;
1015 static const gl_state_index texcoord_state[STATE_LENGTH] =
1016 { STATE_INTERNAL, STATE_CURRENT_ATTRIB, VERT_ATTRIB_TEX0 };
1017 static const gl_state_index scale_state[STATE_LENGTH] =
1018 { STATE_INTERNAL, STATE_PT_SCALE };
1019 static const gl_state_index bias_state[STATE_LENGTH] =
1020 { STATE_INTERNAL, STATE_PT_BIAS };
1021
1022 if (!variant)
1023 return NULL;
1024
1025 if (stfp->tgsi.type == PIPE_SHADER_IR_NIR) {
1026 tgsi.type = PIPE_SHADER_IR_NIR;
1027 tgsi.ir.nir = nir_shader_clone(NULL, stfp->tgsi.ir.nir);
1028
1029 if (key->clamp_color)
1030 NIR_PASS_V(tgsi.ir.nir, nir_lower_clamp_color_outputs);
1031
1032 if (key->persample_shading) {
1033 nir_shader *shader = tgsi.ir.nir;
1034 nir_foreach_variable(var, &shader->inputs)
1035 var->data.sample = true;
1036 }
1037
1038 assert(!(key->bitmap && key->drawpixels));
1039
1040 /* glBitmap */
1041 if (key->bitmap) {
1042 nir_lower_bitmap_options options = {0};
1043
1044 variant->bitmap_sampler = ffs(~stfp->Base.SamplersUsed) - 1;
1045 options.sampler = variant->bitmap_sampler;
1046 options.swizzle_xxxx = (st->bitmap.tex_format == PIPE_FORMAT_L8_UNORM);
1047
1048 NIR_PASS_V(tgsi.ir.nir, nir_lower_bitmap, &options);
1049 }
1050
1051 /* glDrawPixels (color only) */
1052 if (key->drawpixels) {
1053 nir_lower_drawpixels_options options = {{0}};
1054 unsigned samplers_used = stfp->Base.SamplersUsed;
1055
1056 /* Find the first unused slot. */
1057 variant->drawpix_sampler = ffs(~samplers_used) - 1;
1058 options.drawpix_sampler = variant->drawpix_sampler;
1059 samplers_used |= (1 << variant->drawpix_sampler);
1060
1061 options.pixel_maps = key->pixelMaps;
1062 if (key->pixelMaps) {
1063 variant->pixelmap_sampler = ffs(~samplers_used) - 1;
1064 options.pixelmap_sampler = variant->pixelmap_sampler;
1065 }
1066
1067 options.scale_and_bias = key->scaleAndBias;
1068 if (key->scaleAndBias) {
1069 _mesa_add_state_reference(params, scale_state);
1070 memcpy(options.scale_state_tokens, scale_state,
1071 sizeof(options.scale_state_tokens));
1072 _mesa_add_state_reference(params, bias_state);
1073 memcpy(options.bias_state_tokens, bias_state,
1074 sizeof(options.bias_state_tokens));
1075 }
1076
1077 _mesa_add_state_reference(params, texcoord_state);
1078 memcpy(options.texcoord_state_tokens, texcoord_state,
1079 sizeof(options.texcoord_state_tokens));
1080
1081 NIR_PASS_V(tgsi.ir.nir, nir_lower_drawpixels, &options);
1082 }
1083
1084 if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) {
1085 nir_lower_tex_options options = {0};
1086 options.lower_y_uv_external = key->external.lower_nv12;
1087 options.lower_y_u_v_external = key->external.lower_iyuv;
1088 NIR_PASS_V(tgsi.ir.nir, nir_lower_tex, &options);
1089 }
1090
1091 st_finalize_nir(st, &stfp->Base, tgsi.ir.nir);
1092
1093 if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) {
1094 /* This pass needs to happen *after* nir_lower_sampler */
1095 NIR_PASS_V(tgsi.ir.nir, st_nir_lower_tex_src_plane,
1096 ~stfp->Base.SamplersUsed,
1097 key->external.lower_nv12,
1098 key->external.lower_iyuv);
1099 }
1100
1101 variant->driver_shader = pipe->create_fs_state(pipe, &tgsi);
1102 variant->key = *key;
1103
1104 return variant;
1105 }
1106
1107 tgsi.tokens = stfp->tgsi.tokens;
1108
1109 assert(!(key->bitmap && key->drawpixels));
1110
1111 /* Fix texture targets and add fog for ATI_fs */
1112 if (stfp->ati_fs) {
1113 const struct tgsi_token *tokens = st_fixup_atifs(tgsi.tokens, key);
1114
1115 if (tokens)
1116 tgsi.tokens = tokens;
1117 else
1118 fprintf(stderr, "mesa: cannot post-process ATI_fs\n");
1119 }
1120
1121 /* Emulate features. */
1122 if (key->clamp_color || key->persample_shading) {
1123 const struct tgsi_token *tokens;
1124 unsigned flags =
1125 (key->clamp_color ? TGSI_EMU_CLAMP_COLOR_OUTPUTS : 0) |
1126 (key->persample_shading ? TGSI_EMU_FORCE_PERSAMPLE_INTERP : 0);
1127
1128 tokens = tgsi_emulate(tgsi.tokens, flags);
1129
1130 if (tokens) {
1131 if (tgsi.tokens != stfp->tgsi.tokens)
1132 tgsi_free_tokens(tgsi.tokens);
1133 tgsi.tokens = tokens;
1134 } else
1135 fprintf(stderr, "mesa: cannot emulate deprecated features\n");
1136 }
1137
1138 /* glBitmap */
1139 if (key->bitmap) {
1140 const struct tgsi_token *tokens;
1141
1142 variant->bitmap_sampler = ffs(~stfp->Base.SamplersUsed) - 1;
1143
1144 tokens = st_get_bitmap_shader(tgsi.tokens,
1145 st->internal_target,
1146 variant->bitmap_sampler,
1147 st->needs_texcoord_semantic,
1148 st->bitmap.tex_format ==
1149 PIPE_FORMAT_L8_UNORM);
1150
1151 if (tokens) {
1152 if (tgsi.tokens != stfp->tgsi.tokens)
1153 tgsi_free_tokens(tgsi.tokens);
1154 tgsi.tokens = tokens;
1155 } else
1156 fprintf(stderr, "mesa: cannot create a shader for glBitmap\n");
1157 }
1158
1159 /* glDrawPixels (color only) */
1160 if (key->drawpixels) {
1161 const struct tgsi_token *tokens;
1162 unsigned scale_const = 0, bias_const = 0, texcoord_const = 0;
1163
1164 /* Find the first unused slot. */
1165 variant->drawpix_sampler = ffs(~stfp->Base.SamplersUsed) - 1;
1166
1167 if (key->pixelMaps) {
1168 unsigned samplers_used = stfp->Base.SamplersUsed |
1169 (1 << variant->drawpix_sampler);
1170
1171 variant->pixelmap_sampler = ffs(~samplers_used) - 1;
1172 }
1173
1174 if (key->scaleAndBias) {
1175 scale_const = _mesa_add_state_reference(params, scale_state);
1176 bias_const = _mesa_add_state_reference(params, bias_state);
1177 }
1178
1179 texcoord_const = _mesa_add_state_reference(params, texcoord_state);
1180
1181 tokens = st_get_drawpix_shader(tgsi.tokens,
1182 st->needs_texcoord_semantic,
1183 key->scaleAndBias, scale_const,
1184 bias_const, key->pixelMaps,
1185 variant->drawpix_sampler,
1186 variant->pixelmap_sampler,
1187 texcoord_const, st->internal_target);
1188
1189 if (tokens) {
1190 if (tgsi.tokens != stfp->tgsi.tokens)
1191 tgsi_free_tokens(tgsi.tokens);
1192 tgsi.tokens = tokens;
1193 } else
1194 fprintf(stderr, "mesa: cannot create a shader for glDrawPixels\n");
1195 }
1196
1197 if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) {
1198 const struct tgsi_token *tokens;
1199
1200 /* samplers inserted would conflict, but this should be unpossible: */
1201 assert(!(key->bitmap || key->drawpixels));
1202
1203 tokens = st_tgsi_lower_yuv(tgsi.tokens,
1204 ~stfp->Base.SamplersUsed,
1205 key->external.lower_nv12,
1206 key->external.lower_iyuv);
1207 if (tokens) {
1208 if (tgsi.tokens != stfp->tgsi.tokens)
1209 tgsi_free_tokens(tgsi.tokens);
1210 tgsi.tokens = tokens;
1211 } else {
1212 fprintf(stderr, "mesa: cannot create a shader for samplerExternalOES\n");
1213 }
1214 }
1215
1216 if (ST_DEBUG & DEBUG_TGSI) {
1217 tgsi_dump(tgsi.tokens, 0);
1218 debug_printf("\n");
1219 }
1220
1221 /* fill in variant */
1222 variant->driver_shader = pipe->create_fs_state(pipe, &tgsi);
1223 variant->key = *key;
1224
1225 if (tgsi.tokens != stfp->tgsi.tokens)
1226 tgsi_free_tokens(tgsi.tokens);
1227 return variant;
1228 }
1229
1230 /**
1231 * Translate fragment program if needed.
1232 */
1233 struct st_fp_variant *
1234 st_get_fp_variant(struct st_context *st,
1235 struct st_fragment_program *stfp,
1236 const struct st_fp_variant_key *key)
1237 {
1238 struct st_fp_variant *fpv;
1239
1240 /* Search for existing variant */
1241 for (fpv = stfp->variants; fpv; fpv = fpv->next) {
1242 if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
1243 break;
1244 }
1245 }
1246
1247 if (!fpv) {
1248 /* create new */
1249 fpv = st_create_fp_variant(st, stfp, key);
1250 if (fpv) {
1251 if (key->bitmap || key->drawpixels) {
1252 /* Regular variants should always come before the
1253 * bitmap & drawpixels variants, (unless there
1254 * are no regular variants) so that
1255 * st_update_fp can take a fast path when
1256 * shader_has_one_variant is set.
1257 */
1258 if (!stfp->variants) {
1259 stfp->variants = fpv;
1260 } else {
1261 /* insert into list after the first one */
1262 fpv->next = stfp->variants->next;
1263 stfp->variants->next = fpv;
1264 }
1265 } else {
1266 /* insert into list */
1267 fpv->next = stfp->variants;
1268 stfp->variants = fpv;
1269 }
1270 }
1271 }
1272
1273 return fpv;
1274 }
1275
1276
1277 /**
1278 * Translate a program. This is common code for geometry and tessellation
1279 * shaders.
1280 */
1281 static void
1282 st_translate_program_common(struct st_context *st,
1283 struct gl_program *prog,
1284 struct glsl_to_tgsi_visitor *glsl_to_tgsi,
1285 struct ureg_program *ureg,
1286 unsigned tgsi_processor,
1287 struct pipe_shader_state *out_state)
1288 {
1289 ubyte inputSlotToAttr[VARYING_SLOT_TESS_MAX];
1290 ubyte inputMapping[VARYING_SLOT_TESS_MAX];
1291 ubyte outputMapping[VARYING_SLOT_TESS_MAX];
1292 GLuint attr;
1293
1294 ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
1295 ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
1296 uint num_inputs = 0;
1297
1298 ubyte output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
1299 ubyte output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
1300 uint num_outputs = 0;
1301
1302 GLint i;
1303
1304 memset(inputSlotToAttr, 0, sizeof(inputSlotToAttr));
1305 memset(inputMapping, 0, sizeof(inputMapping));
1306 memset(outputMapping, 0, sizeof(outputMapping));
1307 memset(out_state, 0, sizeof(*out_state));
1308
1309 if (prog->info.clip_distance_array_size)
1310 ureg_property(ureg, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED,
1311 prog->info.clip_distance_array_size);
1312 if (prog->info.cull_distance_array_size)
1313 ureg_property(ureg, TGSI_PROPERTY_NUM_CULLDIST_ENABLED,
1314 prog->info.cull_distance_array_size);
1315
1316 /*
1317 * Convert Mesa program inputs to TGSI input register semantics.
1318 */
1319 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1320 if ((prog->info.inputs_read & BITFIELD64_BIT(attr)) != 0) {
1321 const GLuint slot = num_inputs++;
1322
1323 inputMapping[attr] = slot;
1324 inputSlotToAttr[slot] = attr;
1325
1326 switch (attr) {
1327 case VARYING_SLOT_PRIMITIVE_ID:
1328 assert(tgsi_processor == PIPE_SHADER_GEOMETRY);
1329 input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1330 input_semantic_index[slot] = 0;
1331 break;
1332 case VARYING_SLOT_POS:
1333 input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1334 input_semantic_index[slot] = 0;
1335 break;
1336 case VARYING_SLOT_COL0:
1337 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1338 input_semantic_index[slot] = 0;
1339 break;
1340 case VARYING_SLOT_COL1:
1341 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1342 input_semantic_index[slot] = 1;
1343 break;
1344 case VARYING_SLOT_FOGC:
1345 input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1346 input_semantic_index[slot] = 0;
1347 break;
1348 case VARYING_SLOT_CLIP_VERTEX:
1349 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1350 input_semantic_index[slot] = 0;
1351 break;
1352 case VARYING_SLOT_CLIP_DIST0:
1353 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1354 input_semantic_index[slot] = 0;
1355 break;
1356 case VARYING_SLOT_CLIP_DIST1:
1357 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1358 input_semantic_index[slot] = 1;
1359 break;
1360 case VARYING_SLOT_CULL_DIST0:
1361 case VARYING_SLOT_CULL_DIST1:
1362 /* these should have been lowered by GLSL */
1363 assert(0);
1364 break;
1365 case VARYING_SLOT_PSIZ:
1366 input_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1367 input_semantic_index[slot] = 0;
1368 break;
1369 case VARYING_SLOT_TEX0:
1370 case VARYING_SLOT_TEX1:
1371 case VARYING_SLOT_TEX2:
1372 case VARYING_SLOT_TEX3:
1373 case VARYING_SLOT_TEX4:
1374 case VARYING_SLOT_TEX5:
1375 case VARYING_SLOT_TEX6:
1376 case VARYING_SLOT_TEX7:
1377 if (st->needs_texcoord_semantic) {
1378 input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1379 input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1380 break;
1381 }
1382 /* fall through */
1383 case VARYING_SLOT_VAR0:
1384 default:
1385 assert(attr >= VARYING_SLOT_VAR0 ||
1386 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1387 input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1388 input_semantic_index[slot] =
1389 st_get_generic_varying_index(st, attr);
1390 break;
1391 }
1392 }
1393 }
1394
1395 /* Also add patch inputs. */
1396 for (attr = 0; attr < 32; attr++) {
1397 if (prog->info.patch_inputs_read & (1u << attr)) {
1398 GLuint slot = num_inputs++;
1399 GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1400
1401 inputMapping[patch_attr] = slot;
1402 inputSlotToAttr[slot] = patch_attr;
1403 input_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1404 input_semantic_index[slot] = attr;
1405 }
1406 }
1407
1408 /* initialize output semantics to defaults */
1409 for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
1410 output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
1411 output_semantic_index[i] = 0;
1412 }
1413
1414 /*
1415 * Determine number of outputs, the (default) output register
1416 * mapping and the semantic information for each output.
1417 */
1418 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1419 if (prog->info.outputs_written & BITFIELD64_BIT(attr)) {
1420 GLuint slot = num_outputs++;
1421
1422 outputMapping[attr] = slot;
1423
1424 switch (attr) {
1425 case VARYING_SLOT_POS:
1426 assert(slot == 0);
1427 output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1428 output_semantic_index[slot] = 0;
1429 break;
1430 case VARYING_SLOT_COL0:
1431 output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1432 output_semantic_index[slot] = 0;
1433 break;
1434 case VARYING_SLOT_COL1:
1435 output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1436 output_semantic_index[slot] = 1;
1437 break;
1438 case VARYING_SLOT_BFC0:
1439 output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1440 output_semantic_index[slot] = 0;
1441 break;
1442 case VARYING_SLOT_BFC1:
1443 output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1444 output_semantic_index[slot] = 1;
1445 break;
1446 case VARYING_SLOT_FOGC:
1447 output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1448 output_semantic_index[slot] = 0;
1449 break;
1450 case VARYING_SLOT_PSIZ:
1451 output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1452 output_semantic_index[slot] = 0;
1453 break;
1454 case VARYING_SLOT_CLIP_VERTEX:
1455 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1456 output_semantic_index[slot] = 0;
1457 break;
1458 case VARYING_SLOT_CLIP_DIST0:
1459 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1460 output_semantic_index[slot] = 0;
1461 break;
1462 case VARYING_SLOT_CLIP_DIST1:
1463 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1464 output_semantic_index[slot] = 1;
1465 break;
1466 case VARYING_SLOT_CULL_DIST0:
1467 case VARYING_SLOT_CULL_DIST1:
1468 /* these should have been lowered by GLSL */
1469 assert(0);
1470 break;
1471 case VARYING_SLOT_LAYER:
1472 output_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
1473 output_semantic_index[slot] = 0;
1474 break;
1475 case VARYING_SLOT_PRIMITIVE_ID:
1476 output_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1477 output_semantic_index[slot] = 0;
1478 break;
1479 case VARYING_SLOT_VIEWPORT:
1480 output_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
1481 output_semantic_index[slot] = 0;
1482 break;
1483 case VARYING_SLOT_TESS_LEVEL_OUTER:
1484 output_semantic_name[slot] = TGSI_SEMANTIC_TESSOUTER;
1485 output_semantic_index[slot] = 0;
1486 break;
1487 case VARYING_SLOT_TESS_LEVEL_INNER:
1488 output_semantic_name[slot] = TGSI_SEMANTIC_TESSINNER;
1489 output_semantic_index[slot] = 0;
1490 break;
1491 case VARYING_SLOT_TEX0:
1492 case VARYING_SLOT_TEX1:
1493 case VARYING_SLOT_TEX2:
1494 case VARYING_SLOT_TEX3:
1495 case VARYING_SLOT_TEX4:
1496 case VARYING_SLOT_TEX5:
1497 case VARYING_SLOT_TEX6:
1498 case VARYING_SLOT_TEX7:
1499 if (st->needs_texcoord_semantic) {
1500 output_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1501 output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1502 break;
1503 }
1504 /* fall through */
1505 case VARYING_SLOT_VAR0:
1506 default:
1507 assert(slot < ARRAY_SIZE(output_semantic_name));
1508 assert(attr >= VARYING_SLOT_VAR0 ||
1509 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1510 output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1511 output_semantic_index[slot] =
1512 st_get_generic_varying_index(st, attr);
1513 break;
1514 }
1515 }
1516 }
1517
1518 /* Also add patch outputs. */
1519 for (attr = 0; attr < 32; attr++) {
1520 if (prog->info.patch_outputs_written & (1u << attr)) {
1521 GLuint slot = num_outputs++;
1522 GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1523
1524 outputMapping[patch_attr] = slot;
1525 output_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1526 output_semantic_index[slot] = attr;
1527 }
1528 }
1529
1530 st_translate_program(st->ctx,
1531 tgsi_processor,
1532 ureg,
1533 glsl_to_tgsi,
1534 prog,
1535 /* inputs */
1536 num_inputs,
1537 inputMapping,
1538 inputSlotToAttr,
1539 input_semantic_name,
1540 input_semantic_index,
1541 NULL,
1542 /* outputs */
1543 num_outputs,
1544 outputMapping,
1545 output_semantic_name,
1546 output_semantic_index);
1547
1548 unsigned num_tokens;
1549 out_state->tokens = ureg_get_tokens(ureg, &num_tokens);
1550 ureg_destroy(ureg);
1551
1552 st_translate_stream_output_info(glsl_to_tgsi,
1553 outputMapping,
1554 &out_state->stream_output);
1555
1556 st_store_tgsi_in_disk_cache(st, prog, out_state, num_tokens);
1557
1558 if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
1559 _mesa_print_program(prog);
1560 debug_printf("\n");
1561 }
1562
1563 if (ST_DEBUG & DEBUG_TGSI) {
1564 tgsi_dump(out_state->tokens, 0);
1565 debug_printf("\n");
1566 }
1567 }
1568
1569
1570 /**
1571 * Translate a geometry program to create a new variant.
1572 */
1573 bool
1574 st_translate_geometry_program(struct st_context *st,
1575 struct st_common_program *stgp)
1576 {
1577 struct ureg_program *ureg;
1578
1579 ureg = ureg_create_with_screen(PIPE_SHADER_GEOMETRY, st->pipe->screen);
1580 if (ureg == NULL)
1581 return false;
1582
1583 ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM,
1584 stgp->Base.info.gs.input_primitive);
1585 ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM,
1586 stgp->Base.info.gs.output_primitive);
1587 ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES,
1588 stgp->Base.info.gs.vertices_out);
1589 ureg_property(ureg, TGSI_PROPERTY_GS_INVOCATIONS,
1590 stgp->Base.info.gs.invocations);
1591
1592 st_translate_program_common(st, &stgp->Base, stgp->glsl_to_tgsi, ureg,
1593 PIPE_SHADER_GEOMETRY, &stgp->tgsi);
1594
1595 free_glsl_to_tgsi_visitor(stgp->glsl_to_tgsi);
1596 stgp->glsl_to_tgsi = NULL;
1597 return true;
1598 }
1599
1600
1601 /**
1602 * Get/create a basic program variant.
1603 */
1604 struct st_basic_variant *
1605 st_get_basic_variant(struct st_context *st,
1606 unsigned pipe_shader,
1607 struct pipe_shader_state *tgsi,
1608 struct st_basic_variant **variants)
1609 {
1610 struct pipe_context *pipe = st->pipe;
1611 struct st_basic_variant *v;
1612 struct st_basic_variant_key key;
1613
1614 memset(&key, 0, sizeof(key));
1615 key.st = st->has_shareable_shaders ? NULL : st;
1616
1617 /* Search for existing variant */
1618 for (v = *variants; v; v = v->next) {
1619 if (memcmp(&v->key, &key, sizeof(key)) == 0) {
1620 break;
1621 }
1622 }
1623
1624 if (!v) {
1625 /* create new */
1626 v = CALLOC_STRUCT(st_basic_variant);
1627 if (v) {
1628 /* fill in new variant */
1629 switch (pipe_shader) {
1630 case PIPE_SHADER_TESS_CTRL:
1631 v->driver_shader = pipe->create_tcs_state(pipe, tgsi);
1632 break;
1633 case PIPE_SHADER_TESS_EVAL:
1634 v->driver_shader = pipe->create_tes_state(pipe, tgsi);
1635 break;
1636 case PIPE_SHADER_GEOMETRY:
1637 v->driver_shader = pipe->create_gs_state(pipe, tgsi);
1638 break;
1639 default:
1640 assert(!"unhandled shader type");
1641 free(v);
1642 return NULL;
1643 }
1644
1645 v->key = key;
1646
1647 /* insert into list */
1648 v->next = *variants;
1649 *variants = v;
1650 }
1651 }
1652
1653 return v;
1654 }
1655
1656
1657 /**
1658 * Translate a tessellation control program to create a new variant.
1659 */
1660 bool
1661 st_translate_tessctrl_program(struct st_context *st,
1662 struct st_common_program *sttcp)
1663 {
1664 struct ureg_program *ureg;
1665
1666 ureg = ureg_create_with_screen(PIPE_SHADER_TESS_CTRL, st->pipe->screen);
1667 if (ureg == NULL)
1668 return false;
1669
1670 ureg_property(ureg, TGSI_PROPERTY_TCS_VERTICES_OUT,
1671 sttcp->Base.info.tess.tcs_vertices_out);
1672
1673 st_translate_program_common(st, &sttcp->Base, sttcp->glsl_to_tgsi, ureg,
1674 PIPE_SHADER_TESS_CTRL, &sttcp->tgsi);
1675
1676 free_glsl_to_tgsi_visitor(sttcp->glsl_to_tgsi);
1677 sttcp->glsl_to_tgsi = NULL;
1678 return true;
1679 }
1680
1681
1682 /**
1683 * Translate a tessellation evaluation program to create a new variant.
1684 */
1685 bool
1686 st_translate_tesseval_program(struct st_context *st,
1687 struct st_common_program *sttep)
1688 {
1689 struct ureg_program *ureg;
1690
1691 ureg = ureg_create_with_screen(PIPE_SHADER_TESS_EVAL, st->pipe->screen);
1692 if (ureg == NULL)
1693 return false;
1694
1695 if (sttep->Base.info.tess.primitive_mode == GL_ISOLINES)
1696 ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, GL_LINES);
1697 else
1698 ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE,
1699 sttep->Base.info.tess.primitive_mode);
1700
1701 STATIC_ASSERT((TESS_SPACING_EQUAL + 1) % 3 == PIPE_TESS_SPACING_EQUAL);
1702 STATIC_ASSERT((TESS_SPACING_FRACTIONAL_ODD + 1) % 3 ==
1703 PIPE_TESS_SPACING_FRACTIONAL_ODD);
1704 STATIC_ASSERT((TESS_SPACING_FRACTIONAL_EVEN + 1) % 3 ==
1705 PIPE_TESS_SPACING_FRACTIONAL_EVEN);
1706
1707 ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1708 (sttep->Base.info.tess.spacing + 1) % 3);
1709
1710 ureg_property(ureg, TGSI_PROPERTY_TES_VERTEX_ORDER_CW,
1711 !sttep->Base.info.tess.ccw);
1712 ureg_property(ureg, TGSI_PROPERTY_TES_POINT_MODE,
1713 sttep->Base.info.tess.point_mode);
1714
1715 st_translate_program_common(st, &sttep->Base, sttep->glsl_to_tgsi,
1716 ureg, PIPE_SHADER_TESS_EVAL, &sttep->tgsi);
1717
1718 free_glsl_to_tgsi_visitor(sttep->glsl_to_tgsi);
1719 sttep->glsl_to_tgsi = NULL;
1720 return true;
1721 }
1722
1723
1724 /**
1725 * Translate a compute program to create a new variant.
1726 */
1727 bool
1728 st_translate_compute_program(struct st_context *st,
1729 struct st_compute_program *stcp)
1730 {
1731 struct ureg_program *ureg;
1732 struct pipe_shader_state prog;
1733
1734 if (stcp->shader_program) {
1735 nir_shader *nir = st_glsl_to_nir(st, &stcp->Base, stcp->shader_program,
1736 MESA_SHADER_COMPUTE);
1737
1738 /* no compute variants: */
1739 st_finalize_nir(st, &stcp->Base, nir);
1740
1741 stcp->tgsi.ir_type = PIPE_SHADER_IR_NIR;
1742 stcp->tgsi.prog = nir;
1743
1744 return true;
1745 }
1746
1747 ureg = ureg_create_with_screen(PIPE_SHADER_COMPUTE, st->pipe->screen);
1748 if (ureg == NULL)
1749 return false;
1750
1751 st_translate_program_common(st, &stcp->Base, stcp->glsl_to_tgsi, ureg,
1752 PIPE_SHADER_COMPUTE, &prog);
1753
1754 stcp->tgsi.ir_type = PIPE_SHADER_IR_TGSI;
1755 stcp->tgsi.prog = prog.tokens;
1756 stcp->tgsi.req_local_mem = stcp->Base.info.cs.shared_size;
1757 stcp->tgsi.req_private_mem = 0;
1758 stcp->tgsi.req_input_mem = 0;
1759
1760 free_glsl_to_tgsi_visitor(stcp->glsl_to_tgsi);
1761 stcp->glsl_to_tgsi = NULL;
1762 return true;
1763 }
1764
1765
1766 /**
1767 * Get/create compute program variant.
1768 */
1769 struct st_basic_variant *
1770 st_get_cp_variant(struct st_context *st,
1771 struct pipe_compute_state *tgsi,
1772 struct st_basic_variant **variants)
1773 {
1774 struct pipe_context *pipe = st->pipe;
1775 struct st_basic_variant *v;
1776 struct st_basic_variant_key key;
1777
1778 memset(&key, 0, sizeof(key));
1779 key.st = st->has_shareable_shaders ? NULL : st;
1780
1781 /* Search for existing variant */
1782 for (v = *variants; v; v = v->next) {
1783 if (memcmp(&v->key, &key, sizeof(key)) == 0) {
1784 break;
1785 }
1786 }
1787
1788 if (!v) {
1789 /* create new */
1790 v = CALLOC_STRUCT(st_basic_variant);
1791 if (v) {
1792 /* fill in new variant */
1793 v->driver_shader = pipe->create_compute_state(pipe, tgsi);
1794 v->key = key;
1795
1796 /* insert into list */
1797 v->next = *variants;
1798 *variants = v;
1799 }
1800 }
1801
1802 return v;
1803 }
1804
1805
1806 /**
1807 * Vert/Geom/Frag programs have per-context variants. Free all the
1808 * variants attached to the given program which match the given context.
1809 */
1810 static void
1811 destroy_program_variants(struct st_context *st, struct gl_program *target)
1812 {
1813 if (!target || target == &_mesa_DummyProgram)
1814 return;
1815
1816 switch (target->Target) {
1817 case GL_VERTEX_PROGRAM_ARB:
1818 {
1819 struct st_vertex_program *stvp = (struct st_vertex_program *) target;
1820 struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
1821
1822 for (vpv = stvp->variants; vpv; ) {
1823 struct st_vp_variant *next = vpv->next;
1824 if (vpv->key.st == st) {
1825 /* unlink from list */
1826 *prevPtr = next;
1827 /* destroy this variant */
1828 delete_vp_variant(st, vpv);
1829 }
1830 else {
1831 prevPtr = &vpv->next;
1832 }
1833 vpv = next;
1834 }
1835 }
1836 break;
1837 case GL_FRAGMENT_PROGRAM_ARB:
1838 {
1839 struct st_fragment_program *stfp =
1840 (struct st_fragment_program *) target;
1841 struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
1842
1843 for (fpv = stfp->variants; fpv; ) {
1844 struct st_fp_variant *next = fpv->next;
1845 if (fpv->key.st == st) {
1846 /* unlink from list */
1847 *prevPtr = next;
1848 /* destroy this variant */
1849 delete_fp_variant(st, fpv);
1850 }
1851 else {
1852 prevPtr = &fpv->next;
1853 }
1854 fpv = next;
1855 }
1856 }
1857 break;
1858 case GL_GEOMETRY_PROGRAM_NV:
1859 case GL_TESS_CONTROL_PROGRAM_NV:
1860 case GL_TESS_EVALUATION_PROGRAM_NV:
1861 case GL_COMPUTE_PROGRAM_NV:
1862 {
1863 struct st_common_program *p = st_common_program(target);
1864 struct st_compute_program *cp = (struct st_compute_program*)target;
1865 struct st_basic_variant **variants =
1866 target->Target == GL_COMPUTE_PROGRAM_NV ? &cp->variants :
1867 &p->variants;
1868 struct st_basic_variant *v, **prevPtr = variants;
1869
1870 for (v = *variants; v; ) {
1871 struct st_basic_variant *next = v->next;
1872 if (v->key.st == st) {
1873 /* unlink from list */
1874 *prevPtr = next;
1875 /* destroy this variant */
1876 delete_basic_variant(st, v, target->Target);
1877 }
1878 else {
1879 prevPtr = &v->next;
1880 }
1881 v = next;
1882 }
1883 }
1884 break;
1885 default:
1886 _mesa_problem(NULL, "Unexpected program target 0x%x in "
1887 "destroy_program_variants_cb()", target->Target);
1888 }
1889 }
1890
1891
1892 /**
1893 * Callback for _mesa_HashWalk. Free all the shader's program variants
1894 * which match the given context.
1895 */
1896 static void
1897 destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
1898 {
1899 struct st_context *st = (struct st_context *) userData;
1900 struct gl_shader *shader = (struct gl_shader *) data;
1901
1902 switch (shader->Type) {
1903 case GL_SHADER_PROGRAM_MESA:
1904 {
1905 struct gl_shader_program *shProg = (struct gl_shader_program *) data;
1906 GLuint i;
1907
1908 for (i = 0; i < ARRAY_SIZE(shProg->_LinkedShaders); i++) {
1909 if (shProg->_LinkedShaders[i])
1910 destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
1911 }
1912 }
1913 break;
1914 case GL_VERTEX_SHADER:
1915 case GL_FRAGMENT_SHADER:
1916 case GL_GEOMETRY_SHADER:
1917 case GL_TESS_CONTROL_SHADER:
1918 case GL_TESS_EVALUATION_SHADER:
1919 case GL_COMPUTE_SHADER:
1920 break;
1921 default:
1922 assert(0);
1923 }
1924 }
1925
1926
1927 /**
1928 * Callback for _mesa_HashWalk. Free all the program variants which match
1929 * the given context.
1930 */
1931 static void
1932 destroy_program_variants_cb(GLuint key, void *data, void *userData)
1933 {
1934 struct st_context *st = (struct st_context *) userData;
1935 struct gl_program *program = (struct gl_program *) data;
1936 destroy_program_variants(st, program);
1937 }
1938
1939
1940 /**
1941 * Walk over all shaders and programs to delete any variants which
1942 * belong to the given context.
1943 * This is called during context tear-down.
1944 */
1945 void
1946 st_destroy_program_variants(struct st_context *st)
1947 {
1948 /* If shaders can be shared with other contexts, the last context will
1949 * call DeleteProgram on all shaders, releasing everything.
1950 */
1951 if (st->has_shareable_shaders)
1952 return;
1953
1954 /* ARB vert/frag program */
1955 _mesa_HashWalk(st->ctx->Shared->Programs,
1956 destroy_program_variants_cb, st);
1957
1958 /* GLSL vert/frag/geom shaders */
1959 _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
1960 destroy_shader_program_variants_cb, st);
1961 }
1962
1963
1964 /**
1965 * For debugging, print/dump the current vertex program.
1966 */
1967 void
1968 st_print_current_vertex_program(void)
1969 {
1970 GET_CURRENT_CONTEXT(ctx);
1971
1972 if (ctx->VertexProgram._Current) {
1973 struct st_vertex_program *stvp =
1974 (struct st_vertex_program *) ctx->VertexProgram._Current;
1975 struct st_vp_variant *stv;
1976
1977 debug_printf("Vertex program %u\n", stvp->Base.Id);
1978
1979 for (stv = stvp->variants; stv; stv = stv->next) {
1980 debug_printf("variant %p\n", stv);
1981 tgsi_dump(stv->tgsi.tokens, 0);
1982 }
1983 }
1984 }
1985
1986
1987 /**
1988 * Compile one shader variant.
1989 */
1990 void
1991 st_precompile_shader_variant(struct st_context *st,
1992 struct gl_program *prog)
1993 {
1994 switch (prog->Target) {
1995 case GL_VERTEX_PROGRAM_ARB: {
1996 struct st_vertex_program *p = (struct st_vertex_program *)prog;
1997 struct st_vp_variant_key key;
1998
1999 memset(&key, 0, sizeof(key));
2000 key.st = st->has_shareable_shaders ? NULL : st;
2001 st_get_vp_variant(st, p, &key);
2002 break;
2003 }
2004
2005 case GL_TESS_CONTROL_PROGRAM_NV: {
2006 struct st_common_program *p = st_common_program(prog);
2007 st_get_basic_variant(st, PIPE_SHADER_TESS_CTRL, &p->tgsi, &p->variants);
2008 break;
2009 }
2010
2011 case GL_TESS_EVALUATION_PROGRAM_NV: {
2012 struct st_common_program *p = st_common_program(prog);
2013 st_get_basic_variant(st, PIPE_SHADER_TESS_EVAL, &p->tgsi, &p->variants);
2014 break;
2015 }
2016
2017 case GL_GEOMETRY_PROGRAM_NV: {
2018 struct st_common_program *p = st_common_program(prog);
2019 st_get_basic_variant(st, PIPE_SHADER_GEOMETRY, &p->tgsi, &p->variants);
2020 break;
2021 }
2022
2023 case GL_FRAGMENT_PROGRAM_ARB: {
2024 struct st_fragment_program *p = (struct st_fragment_program *)prog;
2025 struct st_fp_variant_key key;
2026
2027 memset(&key, 0, sizeof(key));
2028 key.st = st->has_shareable_shaders ? NULL : st;
2029 st_get_fp_variant(st, p, &key);
2030 break;
2031 }
2032
2033 case GL_COMPUTE_PROGRAM_NV: {
2034 struct st_compute_program *p = (struct st_compute_program *)prog;
2035 st_get_cp_variant(st, &p->tgsi, &p->variants);
2036 break;
2037 }
2038
2039 default:
2040 assert(0);
2041 }
2042 }