projects / mesa.git / blob
? search:


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