projects / mesa.git / blob
? search:


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