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