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