projects / mesa.git / blob
? search:


cb402115c23f915420d3096b0bc8bac8f455b196
[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 GLbitfield64 outputsWritten = stfp->Base.Base.OutputsWritten;
786
787 /* if z is written, emit that first */
788 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_DEPTH)) {
789 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_POSITION;
790 fs_output_semantic_index[fs_num_outputs] = 0;
791 outputMapping[FRAG_RESULT_DEPTH] = fs_num_outputs;
792 fs_num_outputs++;
793 outputsWritten &= ~(1 << FRAG_RESULT_DEPTH);
794 }
795
796 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) {
797 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_STENCIL;
798 fs_output_semantic_index[fs_num_outputs] = 0;
799 outputMapping[FRAG_RESULT_STENCIL] = fs_num_outputs;
800 fs_num_outputs++;
801 outputsWritten &= ~(1 << FRAG_RESULT_STENCIL);
802 }
803
804 if (outputsWritten & BITFIELD64_BIT(FRAG_RESULT_SAMPLE_MASK)) {
805 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_SAMPLEMASK;
806 fs_output_semantic_index[fs_num_outputs] = 0;
807 outputMapping[FRAG_RESULT_SAMPLE_MASK] = fs_num_outputs;
808 fs_num_outputs++;
809 outputsWritten &= ~(1 << FRAG_RESULT_SAMPLE_MASK);
810 }
811
812 /* handle remaining outputs (color) */
813 for (attr = 0; attr < ARRAY_SIZE(outputMapping); attr++) {
814 const GLbitfield64 written = attr < FRAG_RESULT_MAX ? outputsWritten :
815 stfp->Base.Base.SecondaryOutputsWritten;
816 const unsigned loc = attr % FRAG_RESULT_MAX;
817
818 if (written & BITFIELD64_BIT(loc)) {
819 switch (loc) {
820 case FRAG_RESULT_DEPTH:
821 case FRAG_RESULT_STENCIL:
822 case FRAG_RESULT_SAMPLE_MASK:
823 /* handled above */
824 assert(0);
825 break;
826 case FRAG_RESULT_COLOR:
827 write_all = GL_TRUE; /* fallthrough */
828 default: {
829 int index;
830 assert(loc == FRAG_RESULT_COLOR ||
831 (FRAG_RESULT_DATA0 <= loc && loc < FRAG_RESULT_MAX));
832
833 index = (loc == FRAG_RESULT_COLOR) ? 0 : (loc - FRAG_RESULT_DATA0);
834
835 if (attr >= FRAG_RESULT_MAX) {
836 /* Secondary color for dual source blending. */
837 assert(index == 0);
838 index++;
839 }
840
841 fs_output_semantic_name[fs_num_outputs] = TGSI_SEMANTIC_COLOR;
842 fs_output_semantic_index[fs_num_outputs] = index;
843 outputMapping[attr] = fs_num_outputs;
844 break;
845 }
846 }
847
848 fs_num_outputs++;
849 }
850 }
851 }
852
853 if (stfp->shader_program) {
854 nir_shader *nir = st_glsl_to_nir(st, &stfp->Base.Base,
855 stfp->shader_program,
856 MESA_SHADER_FRAGMENT);
857
858 stfp->tgsi.type = PIPE_SHADER_IR_NIR;
859 stfp->tgsi.ir.nir = nir;
860
861 return true;
862 }
863
864 ureg = ureg_create_with_screen(PIPE_SHADER_FRAGMENT, st->pipe->screen);
865 if (ureg == NULL)
866 return false;
867
868 if (ST_DEBUG & DEBUG_MESA) {
869 _mesa_print_program(&stfp->Base.Base);
870 _mesa_print_program_parameters(st->ctx, &stfp->Base.Base);
871 debug_printf("\n");
872 }
873 if (write_all == GL_TRUE)
874 ureg_property(ureg, TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS, 1);
875
876 if (stfp->Base.FragDepthLayout != FRAG_DEPTH_LAYOUT_NONE) {
877 switch (stfp->Base.FragDepthLayout) {
878 case FRAG_DEPTH_LAYOUT_ANY:
879 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
880 TGSI_FS_DEPTH_LAYOUT_ANY);
881 break;
882 case FRAG_DEPTH_LAYOUT_GREATER:
883 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
884 TGSI_FS_DEPTH_LAYOUT_GREATER);
885 break;
886 case FRAG_DEPTH_LAYOUT_LESS:
887 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
888 TGSI_FS_DEPTH_LAYOUT_LESS);
889 break;
890 case FRAG_DEPTH_LAYOUT_UNCHANGED:
891 ureg_property(ureg, TGSI_PROPERTY_FS_DEPTH_LAYOUT,
892 TGSI_FS_DEPTH_LAYOUT_UNCHANGED);
893 break;
894 default:
895 assert(0);
896 }
897 }
898
899 if (stfp->glsl_to_tgsi) {
900 st_translate_program(st->ctx,
901 PIPE_SHADER_FRAGMENT,
902 ureg,
903 stfp->glsl_to_tgsi,
904 &stfp->Base.Base,
905 /* inputs */
906 fs_num_inputs,
907 inputMapping,
908 inputSlotToAttr,
909 input_semantic_name,
910 input_semantic_index,
911 interpMode,
912 interpLocation,
913 /* outputs */
914 fs_num_outputs,
915 outputMapping,
916 NULL,
917 fs_output_semantic_name,
918 fs_output_semantic_index);
919
920 free_glsl_to_tgsi_visitor(stfp->glsl_to_tgsi);
921 stfp->glsl_to_tgsi = NULL;
922 } else if (stfp->ati_fs)
923 st_translate_atifs_program(ureg,
924 stfp->ati_fs,
925 &stfp->Base.Base,
926 /* inputs */
927 fs_num_inputs,
928 inputMapping,
929 input_semantic_name,
930 input_semantic_index,
931 interpMode,
932 /* outputs */
933 fs_num_outputs,
934 outputMapping,
935 fs_output_semantic_name,
936 fs_output_semantic_index);
937 else
938 st_translate_mesa_program(st->ctx,
939 PIPE_SHADER_FRAGMENT,
940 ureg,
941 &stfp->Base.Base,
942 /* inputs */
943 fs_num_inputs,
944 inputMapping,
945 input_semantic_name,
946 input_semantic_index,
947 interpMode,
948 /* outputs */
949 fs_num_outputs,
950 outputMapping,
951 fs_output_semantic_name,
952 fs_output_semantic_index);
953
954 stfp->tgsi.tokens = ureg_get_tokens(ureg, NULL);
955 ureg_destroy(ureg);
956 return stfp->tgsi.tokens != NULL;
957 }
958
959 static struct st_fp_variant *
960 st_create_fp_variant(struct st_context *st,
961 struct st_fragment_program *stfp,
962 const struct st_fp_variant_key *key)
963 {
964 struct pipe_context *pipe = st->pipe;
965 struct st_fp_variant *variant = CALLOC_STRUCT(st_fp_variant);
966 struct pipe_shader_state tgsi = {0};
967 struct gl_program_parameter_list *params = stfp->Base.Base.Parameters;
968 static const gl_state_index texcoord_state[STATE_LENGTH] =
969 { STATE_INTERNAL, STATE_CURRENT_ATTRIB, VERT_ATTRIB_TEX0 };
970 static const gl_state_index scale_state[STATE_LENGTH] =
971 { STATE_INTERNAL, STATE_PT_SCALE };
972 static const gl_state_index bias_state[STATE_LENGTH] =
973 { STATE_INTERNAL, STATE_PT_BIAS };
974
975 if (!variant)
976 return NULL;
977
978 if (stfp->tgsi.type == PIPE_SHADER_IR_NIR) {
979 tgsi.type = PIPE_SHADER_IR_NIR;
980 tgsi.ir.nir = nir_shader_clone(NULL, stfp->tgsi.ir.nir);
981
982 if (key->clamp_color)
983 NIR_PASS_V(tgsi.ir.nir, nir_lower_clamp_color_outputs);
984
985 if (key->persample_shading) {
986 nir_shader *shader = tgsi.ir.nir;
987 nir_foreach_variable(var, &shader->inputs)
988 var->data.sample = true;
989 }
990
991 assert(!(key->bitmap && key->drawpixels));
992
993 /* glBitmap */
994 if (key->bitmap) {
995 nir_lower_bitmap_options options = {0};
996
997 variant->bitmap_sampler = ffs(~stfp->Base.Base.SamplersUsed) - 1;
998 options.sampler = variant->bitmap_sampler;
999 options.swizzle_xxxx = (st->bitmap.tex_format == PIPE_FORMAT_L8_UNORM);
1000
1001 NIR_PASS_V(tgsi.ir.nir, nir_lower_bitmap, &options);
1002 }
1003
1004 /* glDrawPixels (color only) */
1005 if (key->drawpixels) {
1006 nir_lower_drawpixels_options options = {{0}};
1007 unsigned samplers_used = stfp->Base.Base.SamplersUsed;
1008
1009 /* Find the first unused slot. */
1010 variant->drawpix_sampler = ffs(~samplers_used) - 1;
1011 options.drawpix_sampler = variant->drawpix_sampler;
1012 samplers_used |= (1 << variant->drawpix_sampler);
1013
1014 options.pixel_maps = key->pixelMaps;
1015 if (key->pixelMaps) {
1016 variant->pixelmap_sampler = ffs(~samplers_used) - 1;
1017 options.pixelmap_sampler = variant->pixelmap_sampler;
1018 }
1019
1020 options.scale_and_bias = key->scaleAndBias;
1021 if (key->scaleAndBias) {
1022 _mesa_add_state_reference(params, scale_state);
1023 memcpy(options.scale_state_tokens, scale_state,
1024 sizeof(options.scale_state_tokens));
1025 _mesa_add_state_reference(params, bias_state);
1026 memcpy(options.bias_state_tokens, bias_state,
1027 sizeof(options.bias_state_tokens));
1028 }
1029
1030 _mesa_add_state_reference(params, texcoord_state);
1031 memcpy(options.texcoord_state_tokens, texcoord_state,
1032 sizeof(options.texcoord_state_tokens));
1033
1034 NIR_PASS_V(tgsi.ir.nir, nir_lower_drawpixels, &options);
1035 }
1036
1037 if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) {
1038 nir_lower_tex_options options = {0};
1039 options.lower_y_uv_external = key->external.lower_nv12;
1040 options.lower_y_u_v_external = key->external.lower_iyuv;
1041 NIR_PASS_V(tgsi.ir.nir, nir_lower_tex, &options);
1042 }
1043
1044 st_finalize_nir(st, &stfp->Base.Base, tgsi.ir.nir);
1045
1046 if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) {
1047 /* This pass needs to happen *after* nir_lower_sampler */
1048 NIR_PASS_V(tgsi.ir.nir, st_nir_lower_tex_src_plane,
1049 ~stfp->Base.Base.SamplersUsed,
1050 key->external.lower_nv12,
1051 key->external.lower_iyuv);
1052 }
1053
1054 variant->driver_shader = pipe->create_fs_state(pipe, &tgsi);
1055 variant->key = *key;
1056
1057 return variant;
1058 }
1059
1060 tgsi.tokens = stfp->tgsi.tokens;
1061
1062 assert(!(key->bitmap && key->drawpixels));
1063
1064 /* Fix texture targets and add fog for ATI_fs */
1065 if (stfp->ati_fs) {
1066 const struct tgsi_token *tokens = st_fixup_atifs(tgsi.tokens, key);
1067
1068 if (tokens)
1069 tgsi.tokens = tokens;
1070 else
1071 fprintf(stderr, "mesa: cannot post-process ATI_fs\n");
1072 }
1073
1074 /* Emulate features. */
1075 if (key->clamp_color || key->persample_shading) {
1076 const struct tgsi_token *tokens;
1077 unsigned flags =
1078 (key->clamp_color ? TGSI_EMU_CLAMP_COLOR_OUTPUTS : 0) |
1079 (key->persample_shading ? TGSI_EMU_FORCE_PERSAMPLE_INTERP : 0);
1080
1081 tokens = tgsi_emulate(tgsi.tokens, flags);
1082
1083 if (tokens) {
1084 if (tgsi.tokens != stfp->tgsi.tokens)
1085 tgsi_free_tokens(tgsi.tokens);
1086 tgsi.tokens = tokens;
1087 } else
1088 fprintf(stderr, "mesa: cannot emulate deprecated features\n");
1089 }
1090
1091 /* glBitmap */
1092 if (key->bitmap) {
1093 const struct tgsi_token *tokens;
1094
1095 variant->bitmap_sampler = ffs(~stfp->Base.Base.SamplersUsed) - 1;
1096
1097 tokens = st_get_bitmap_shader(tgsi.tokens,
1098 st->internal_target,
1099 variant->bitmap_sampler,
1100 st->needs_texcoord_semantic,
1101 st->bitmap.tex_format ==
1102 PIPE_FORMAT_L8_UNORM);
1103
1104 if (tokens) {
1105 if (tgsi.tokens != stfp->tgsi.tokens)
1106 tgsi_free_tokens(tgsi.tokens);
1107 tgsi.tokens = tokens;
1108 } else
1109 fprintf(stderr, "mesa: cannot create a shader for glBitmap\n");
1110 }
1111
1112 /* glDrawPixels (color only) */
1113 if (key->drawpixels) {
1114 const struct tgsi_token *tokens;
1115 unsigned scale_const = 0, bias_const = 0, texcoord_const = 0;
1116
1117 /* Find the first unused slot. */
1118 variant->drawpix_sampler = ffs(~stfp->Base.Base.SamplersUsed) - 1;
1119
1120 if (key->pixelMaps) {
1121 unsigned samplers_used = stfp->Base.Base.SamplersUsed |
1122 (1 << variant->drawpix_sampler);
1123
1124 variant->pixelmap_sampler = ffs(~samplers_used) - 1;
1125 }
1126
1127 if (key->scaleAndBias) {
1128 scale_const = _mesa_add_state_reference(params, scale_state);
1129 bias_const = _mesa_add_state_reference(params, bias_state);
1130 }
1131
1132 texcoord_const = _mesa_add_state_reference(params, texcoord_state);
1133
1134 tokens = st_get_drawpix_shader(tgsi.tokens,
1135 st->needs_texcoord_semantic,
1136 key->scaleAndBias, scale_const,
1137 bias_const, key->pixelMaps,
1138 variant->drawpix_sampler,
1139 variant->pixelmap_sampler,
1140 texcoord_const, st->internal_target);
1141
1142 if (tokens) {
1143 if (tgsi.tokens != stfp->tgsi.tokens)
1144 tgsi_free_tokens(tgsi.tokens);
1145 tgsi.tokens = tokens;
1146 } else
1147 fprintf(stderr, "mesa: cannot create a shader for glDrawPixels\n");
1148 }
1149
1150 if (unlikely(key->external.lower_nv12 || key->external.lower_iyuv)) {
1151 const struct tgsi_token *tokens;
1152
1153 /* samplers inserted would conflict, but this should be unpossible: */
1154 assert(!(key->bitmap || key->drawpixels));
1155
1156 tokens = st_tgsi_lower_yuv(tgsi.tokens,
1157 ~stfp->Base.Base.SamplersUsed,
1158 key->external.lower_nv12,
1159 key->external.lower_iyuv);
1160 if (tokens) {
1161 if (tgsi.tokens != stfp->tgsi.tokens)
1162 tgsi_free_tokens(tgsi.tokens);
1163 tgsi.tokens = tokens;
1164 } else {
1165 fprintf(stderr, "mesa: cannot create a shader for samplerExternalOES\n");
1166 }
1167 }
1168
1169 if (ST_DEBUG & DEBUG_TGSI) {
1170 tgsi_dump(tgsi.tokens, 0);
1171 debug_printf("\n");
1172 }
1173
1174 /* fill in variant */
1175 variant->driver_shader = pipe->create_fs_state(pipe, &tgsi);
1176 variant->key = *key;
1177
1178 if (tgsi.tokens != stfp->tgsi.tokens)
1179 tgsi_free_tokens(tgsi.tokens);
1180 return variant;
1181 }
1182
1183 /**
1184 * Translate fragment program if needed.
1185 */
1186 struct st_fp_variant *
1187 st_get_fp_variant(struct st_context *st,
1188 struct st_fragment_program *stfp,
1189 const struct st_fp_variant_key *key)
1190 {
1191 struct st_fp_variant *fpv;
1192
1193 /* Search for existing variant */
1194 for (fpv = stfp->variants; fpv; fpv = fpv->next) {
1195 if (memcmp(&fpv->key, key, sizeof(*key)) == 0) {
1196 break;
1197 }
1198 }
1199
1200 if (!fpv) {
1201 /* create new */
1202 fpv = st_create_fp_variant(st, stfp, key);
1203 if (fpv) {
1204 /* insert into list */
1205 fpv->next = stfp->variants;
1206 stfp->variants = fpv;
1207 }
1208 }
1209
1210 return fpv;
1211 }
1212
1213
1214 /**
1215 * Translate a program. This is common code for geometry and tessellation
1216 * shaders.
1217 */
1218 static void
1219 st_translate_program_common(struct st_context *st,
1220 struct gl_program *prog,
1221 struct glsl_to_tgsi_visitor *glsl_to_tgsi,
1222 struct ureg_program *ureg,
1223 unsigned tgsi_processor,
1224 struct pipe_shader_state *out_state)
1225 {
1226 GLuint inputSlotToAttr[VARYING_SLOT_TESS_MAX];
1227 GLuint inputMapping[VARYING_SLOT_TESS_MAX];
1228 GLuint outputSlotToAttr[VARYING_SLOT_TESS_MAX];
1229 GLuint outputMapping[VARYING_SLOT_TESS_MAX];
1230 GLuint attr;
1231
1232 ubyte input_semantic_name[PIPE_MAX_SHADER_INPUTS];
1233 ubyte input_semantic_index[PIPE_MAX_SHADER_INPUTS];
1234 uint num_inputs = 0;
1235
1236 ubyte output_semantic_name[PIPE_MAX_SHADER_OUTPUTS];
1237 ubyte output_semantic_index[PIPE_MAX_SHADER_OUTPUTS];
1238 uint num_outputs = 0;
1239
1240 GLint i;
1241
1242 memset(inputSlotToAttr, 0, sizeof(inputSlotToAttr));
1243 memset(inputMapping, 0, sizeof(inputMapping));
1244 memset(outputSlotToAttr, 0, sizeof(outputSlotToAttr));
1245 memset(outputMapping, 0, sizeof(outputMapping));
1246 memset(out_state, 0, sizeof(*out_state));
1247
1248 if (prog->ClipDistanceArraySize)
1249 ureg_property(ureg, TGSI_PROPERTY_NUM_CLIPDIST_ENABLED,
1250 prog->ClipDistanceArraySize);
1251 if (prog->CullDistanceArraySize)
1252 ureg_property(ureg, TGSI_PROPERTY_NUM_CULLDIST_ENABLED,
1253 prog->CullDistanceArraySize);
1254
1255 /*
1256 * Convert Mesa program inputs to TGSI input register semantics.
1257 */
1258 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1259 if ((prog->InputsRead & BITFIELD64_BIT(attr)) != 0) {
1260 const GLuint slot = num_inputs++;
1261
1262 inputMapping[attr] = slot;
1263 inputSlotToAttr[slot] = attr;
1264
1265 switch (attr) {
1266 case VARYING_SLOT_PRIMITIVE_ID:
1267 assert(tgsi_processor == PIPE_SHADER_GEOMETRY);
1268 input_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1269 input_semantic_index[slot] = 0;
1270 break;
1271 case VARYING_SLOT_POS:
1272 input_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1273 input_semantic_index[slot] = 0;
1274 break;
1275 case VARYING_SLOT_COL0:
1276 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1277 input_semantic_index[slot] = 0;
1278 break;
1279 case VARYING_SLOT_COL1:
1280 input_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1281 input_semantic_index[slot] = 1;
1282 break;
1283 case VARYING_SLOT_FOGC:
1284 input_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1285 input_semantic_index[slot] = 0;
1286 break;
1287 case VARYING_SLOT_CLIP_VERTEX:
1288 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1289 input_semantic_index[slot] = 0;
1290 break;
1291 case VARYING_SLOT_CLIP_DIST0:
1292 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1293 input_semantic_index[slot] = 0;
1294 break;
1295 case VARYING_SLOT_CLIP_DIST1:
1296 input_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1297 input_semantic_index[slot] = 1;
1298 break;
1299 case VARYING_SLOT_CULL_DIST0:
1300 case VARYING_SLOT_CULL_DIST1:
1301 /* these should have been lowered by GLSL */
1302 assert(0);
1303 break;
1304 case VARYING_SLOT_PSIZ:
1305 input_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1306 input_semantic_index[slot] = 0;
1307 break;
1308 case VARYING_SLOT_TEX0:
1309 case VARYING_SLOT_TEX1:
1310 case VARYING_SLOT_TEX2:
1311 case VARYING_SLOT_TEX3:
1312 case VARYING_SLOT_TEX4:
1313 case VARYING_SLOT_TEX5:
1314 case VARYING_SLOT_TEX6:
1315 case VARYING_SLOT_TEX7:
1316 if (st->needs_texcoord_semantic) {
1317 input_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1318 input_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1319 break;
1320 }
1321 /* fall through */
1322 case VARYING_SLOT_VAR0:
1323 default:
1324 assert(attr >= VARYING_SLOT_VAR0 ||
1325 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1326 input_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1327 input_semantic_index[slot] =
1328 st_get_generic_varying_index(st, attr);
1329 break;
1330 }
1331 }
1332 }
1333
1334 /* Also add patch inputs. */
1335 for (attr = 0; attr < 32; attr++) {
1336 if (prog->PatchInputsRead & (1u << attr)) {
1337 GLuint slot = num_inputs++;
1338 GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1339
1340 inputMapping[patch_attr] = slot;
1341 inputSlotToAttr[slot] = patch_attr;
1342 input_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1343 input_semantic_index[slot] = attr;
1344 }
1345 }
1346
1347 /* initialize output semantics to defaults */
1348 for (i = 0; i < PIPE_MAX_SHADER_OUTPUTS; i++) {
1349 output_semantic_name[i] = TGSI_SEMANTIC_GENERIC;
1350 output_semantic_index[i] = 0;
1351 }
1352
1353 /*
1354 * Determine number of outputs, the (default) output register
1355 * mapping and the semantic information for each output.
1356 */
1357 for (attr = 0; attr < VARYING_SLOT_MAX; attr++) {
1358 if (prog->OutputsWritten & BITFIELD64_BIT(attr)) {
1359 GLuint slot = num_outputs++;
1360
1361 outputMapping[attr] = slot;
1362 outputSlotToAttr[slot] = attr;
1363
1364 switch (attr) {
1365 case VARYING_SLOT_POS:
1366 assert(slot == 0);
1367 output_semantic_name[slot] = TGSI_SEMANTIC_POSITION;
1368 output_semantic_index[slot] = 0;
1369 break;
1370 case VARYING_SLOT_COL0:
1371 output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1372 output_semantic_index[slot] = 0;
1373 break;
1374 case VARYING_SLOT_COL1:
1375 output_semantic_name[slot] = TGSI_SEMANTIC_COLOR;
1376 output_semantic_index[slot] = 1;
1377 break;
1378 case VARYING_SLOT_BFC0:
1379 output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1380 output_semantic_index[slot] = 0;
1381 break;
1382 case VARYING_SLOT_BFC1:
1383 output_semantic_name[slot] = TGSI_SEMANTIC_BCOLOR;
1384 output_semantic_index[slot] = 1;
1385 break;
1386 case VARYING_SLOT_FOGC:
1387 output_semantic_name[slot] = TGSI_SEMANTIC_FOG;
1388 output_semantic_index[slot] = 0;
1389 break;
1390 case VARYING_SLOT_PSIZ:
1391 output_semantic_name[slot] = TGSI_SEMANTIC_PSIZE;
1392 output_semantic_index[slot] = 0;
1393 break;
1394 case VARYING_SLOT_CLIP_VERTEX:
1395 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPVERTEX;
1396 output_semantic_index[slot] = 0;
1397 break;
1398 case VARYING_SLOT_CLIP_DIST0:
1399 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1400 output_semantic_index[slot] = 0;
1401 break;
1402 case VARYING_SLOT_CLIP_DIST1:
1403 output_semantic_name[slot] = TGSI_SEMANTIC_CLIPDIST;
1404 output_semantic_index[slot] = 1;
1405 break;
1406 case VARYING_SLOT_CULL_DIST0:
1407 case VARYING_SLOT_CULL_DIST1:
1408 /* these should have been lowered by GLSL */
1409 assert(0);
1410 break;
1411 case VARYING_SLOT_LAYER:
1412 output_semantic_name[slot] = TGSI_SEMANTIC_LAYER;
1413 output_semantic_index[slot] = 0;
1414 break;
1415 case VARYING_SLOT_PRIMITIVE_ID:
1416 output_semantic_name[slot] = TGSI_SEMANTIC_PRIMID;
1417 output_semantic_index[slot] = 0;
1418 break;
1419 case VARYING_SLOT_VIEWPORT:
1420 output_semantic_name[slot] = TGSI_SEMANTIC_VIEWPORT_INDEX;
1421 output_semantic_index[slot] = 0;
1422 break;
1423 case VARYING_SLOT_TESS_LEVEL_OUTER:
1424 output_semantic_name[slot] = TGSI_SEMANTIC_TESSOUTER;
1425 output_semantic_index[slot] = 0;
1426 break;
1427 case VARYING_SLOT_TESS_LEVEL_INNER:
1428 output_semantic_name[slot] = TGSI_SEMANTIC_TESSINNER;
1429 output_semantic_index[slot] = 0;
1430 break;
1431 case VARYING_SLOT_TEX0:
1432 case VARYING_SLOT_TEX1:
1433 case VARYING_SLOT_TEX2:
1434 case VARYING_SLOT_TEX3:
1435 case VARYING_SLOT_TEX4:
1436 case VARYING_SLOT_TEX5:
1437 case VARYING_SLOT_TEX6:
1438 case VARYING_SLOT_TEX7:
1439 if (st->needs_texcoord_semantic) {
1440 output_semantic_name[slot] = TGSI_SEMANTIC_TEXCOORD;
1441 output_semantic_index[slot] = attr - VARYING_SLOT_TEX0;
1442 break;
1443 }
1444 /* fall through */
1445 case VARYING_SLOT_VAR0:
1446 default:
1447 assert(slot < ARRAY_SIZE(output_semantic_name));
1448 assert(attr >= VARYING_SLOT_VAR0 ||
1449 (attr >= VARYING_SLOT_TEX0 && attr <= VARYING_SLOT_TEX7));
1450 output_semantic_name[slot] = TGSI_SEMANTIC_GENERIC;
1451 output_semantic_index[slot] =
1452 st_get_generic_varying_index(st, attr);
1453 break;
1454 }
1455 }
1456 }
1457
1458 /* Also add patch outputs. */
1459 for (attr = 0; attr < 32; attr++) {
1460 if (prog->PatchOutputsWritten & (1u << attr)) {
1461 GLuint slot = num_outputs++;
1462 GLuint patch_attr = VARYING_SLOT_PATCH0 + attr;
1463
1464 outputMapping[patch_attr] = slot;
1465 outputSlotToAttr[slot] = patch_attr;
1466 output_semantic_name[slot] = TGSI_SEMANTIC_PATCH;
1467 output_semantic_index[slot] = attr;
1468 }
1469 }
1470
1471 st_translate_program(st->ctx,
1472 tgsi_processor,
1473 ureg,
1474 glsl_to_tgsi,
1475 prog,
1476 /* inputs */
1477 num_inputs,
1478 inputMapping,
1479 inputSlotToAttr,
1480 input_semantic_name,
1481 input_semantic_index,
1482 NULL,
1483 NULL,
1484 /* outputs */
1485 num_outputs,
1486 outputMapping,
1487 outputSlotToAttr,
1488 output_semantic_name,
1489 output_semantic_index);
1490
1491 out_state->tokens = ureg_get_tokens(ureg, NULL);
1492 ureg_destroy(ureg);
1493
1494 st_translate_stream_output_info(glsl_to_tgsi,
1495 outputMapping,
1496 &out_state->stream_output);
1497
1498 if ((ST_DEBUG & DEBUG_TGSI) && (ST_DEBUG & DEBUG_MESA)) {
1499 _mesa_print_program(prog);
1500 debug_printf("\n");
1501 }
1502
1503 if (ST_DEBUG & DEBUG_TGSI) {
1504 tgsi_dump(out_state->tokens, 0);
1505 debug_printf("\n");
1506 }
1507 }
1508
1509
1510 /**
1511 * Translate a geometry program to create a new variant.
1512 */
1513 bool
1514 st_translate_geometry_program(struct st_context *st,
1515 struct st_geometry_program *stgp)
1516 {
1517 struct ureg_program *ureg;
1518
1519 ureg = ureg_create_with_screen(PIPE_SHADER_GEOMETRY, st->pipe->screen);
1520 if (ureg == NULL)
1521 return false;
1522
1523 ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM, stgp->Base.InputType);
1524 ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM, stgp->Base.OutputType);
1525 ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES,
1526 stgp->Base.VerticesOut);
1527 ureg_property(ureg, TGSI_PROPERTY_GS_INVOCATIONS, stgp->Base.Invocations);
1528
1529 st_translate_program_common(st, &stgp->Base.Base, stgp->glsl_to_tgsi, ureg,
1530 PIPE_SHADER_GEOMETRY, &stgp->tgsi);
1531
1532 free_glsl_to_tgsi_visitor(stgp->glsl_to_tgsi);
1533 stgp->glsl_to_tgsi = NULL;
1534 return true;
1535 }
1536
1537
1538 /**
1539 * Get/create a basic program variant.
1540 */
1541 struct st_basic_variant *
1542 st_get_basic_variant(struct st_context *st,
1543 unsigned pipe_shader,
1544 struct pipe_shader_state *tgsi,
1545 struct st_basic_variant **variants)
1546 {
1547 struct pipe_context *pipe = st->pipe;
1548 struct st_basic_variant *v;
1549 struct st_basic_variant_key key;
1550
1551 memset(&key, 0, sizeof(key));
1552 key.st = st->has_shareable_shaders ? NULL : st;
1553
1554 /* Search for existing variant */
1555 for (v = *variants; v; v = v->next) {
1556 if (memcmp(&v->key, &key, sizeof(key)) == 0) {
1557 break;
1558 }
1559 }
1560
1561 if (!v) {
1562 /* create new */
1563 v = CALLOC_STRUCT(st_basic_variant);
1564 if (v) {
1565 /* fill in new variant */
1566 switch (pipe_shader) {
1567 case PIPE_SHADER_TESS_CTRL:
1568 v->driver_shader = pipe->create_tcs_state(pipe, tgsi);
1569 break;
1570 case PIPE_SHADER_TESS_EVAL:
1571 v->driver_shader = pipe->create_tes_state(pipe, tgsi);
1572 break;
1573 case PIPE_SHADER_GEOMETRY:
1574 v->driver_shader = pipe->create_gs_state(pipe, tgsi);
1575 break;
1576 default:
1577 assert(!"unhandled shader type");
1578 free(v);
1579 return NULL;
1580 }
1581
1582 v->key = key;
1583
1584 /* insert into list */
1585 v->next = *variants;
1586 *variants = v;
1587 }
1588 }
1589
1590 return v;
1591 }
1592
1593
1594 /**
1595 * Translate a tessellation control program to create a new variant.
1596 */
1597 bool
1598 st_translate_tessctrl_program(struct st_context *st,
1599 struct st_tessctrl_program *sttcp)
1600 {
1601 struct ureg_program *ureg;
1602
1603 ureg = ureg_create_with_screen(PIPE_SHADER_TESS_CTRL, st->pipe->screen);
1604 if (ureg == NULL)
1605 return false;
1606
1607 ureg_property(ureg, TGSI_PROPERTY_TCS_VERTICES_OUT,
1608 sttcp->Base.info.tcs.vertices_out);
1609
1610 st_translate_program_common(st, &sttcp->Base, sttcp->glsl_to_tgsi, ureg,
1611 PIPE_SHADER_TESS_CTRL, &sttcp->tgsi);
1612
1613 free_glsl_to_tgsi_visitor(sttcp->glsl_to_tgsi);
1614 sttcp->glsl_to_tgsi = NULL;
1615 return true;
1616 }
1617
1618
1619 /**
1620 * Translate a tessellation evaluation program to create a new variant.
1621 */
1622 bool
1623 st_translate_tesseval_program(struct st_context *st,
1624 struct st_tesseval_program *sttep)
1625 {
1626 struct ureg_program *ureg;
1627
1628 ureg = ureg_create_with_screen(PIPE_SHADER_TESS_EVAL, st->pipe->screen);
1629 if (ureg == NULL)
1630 return false;
1631
1632 if (sttep->Base.PrimitiveMode == GL_ISOLINES)
1633 ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, GL_LINES);
1634 else
1635 ureg_property(ureg, TGSI_PROPERTY_TES_PRIM_MODE, sttep->Base.PrimitiveMode);
1636
1637 switch (sttep->Base.Spacing) {
1638 case GL_EQUAL:
1639 ureg_property(ureg, TGSI_PROPERTY_TES_SPACING, PIPE_TESS_SPACING_EQUAL);
1640 break;
1641 case GL_FRACTIONAL_EVEN:
1642 ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1643 PIPE_TESS_SPACING_FRACTIONAL_EVEN);
1644 break;
1645 case GL_FRACTIONAL_ODD:
1646 ureg_property(ureg, TGSI_PROPERTY_TES_SPACING,
1647 PIPE_TESS_SPACING_FRACTIONAL_ODD);
1648 break;
1649 default:
1650 assert(0);
1651 }
1652
1653 ureg_property(ureg, TGSI_PROPERTY_TES_VERTEX_ORDER_CW,
1654 sttep->Base.VertexOrder == GL_CW);
1655 ureg_property(ureg, TGSI_PROPERTY_TES_POINT_MODE, sttep->Base.PointMode);
1656
1657 st_translate_program_common(st, &sttep->Base.Base, sttep->glsl_to_tgsi,
1658 ureg, PIPE_SHADER_TESS_EVAL, &sttep->tgsi);
1659
1660 free_glsl_to_tgsi_visitor(sttep->glsl_to_tgsi);
1661 sttep->glsl_to_tgsi = NULL;
1662 return true;
1663 }
1664
1665
1666 /**
1667 * Translate a compute program to create a new variant.
1668 */
1669 bool
1670 st_translate_compute_program(struct st_context *st,
1671 struct st_compute_program *stcp)
1672 {
1673 struct ureg_program *ureg;
1674 struct pipe_shader_state prog;
1675
1676 ureg = ureg_create_with_screen(PIPE_SHADER_COMPUTE, st->pipe->screen);
1677 if (ureg == NULL)
1678 return false;
1679
1680 st_translate_program_common(st, &stcp->Base.Base, stcp->glsl_to_tgsi, ureg,
1681 PIPE_SHADER_COMPUTE, &prog);
1682
1683 stcp->tgsi.ir_type = PIPE_SHADER_IR_TGSI;
1684 stcp->tgsi.prog = prog.tokens;
1685 stcp->tgsi.req_local_mem = stcp->Base.SharedSize;
1686 stcp->tgsi.req_private_mem = 0;
1687 stcp->tgsi.req_input_mem = 0;
1688
1689 free_glsl_to_tgsi_visitor(stcp->glsl_to_tgsi);
1690 stcp->glsl_to_tgsi = NULL;
1691 return true;
1692 }
1693
1694
1695 /**
1696 * Get/create compute program variant.
1697 */
1698 struct st_basic_variant *
1699 st_get_cp_variant(struct st_context *st,
1700 struct pipe_compute_state *tgsi,
1701 struct st_basic_variant **variants)
1702 {
1703 struct pipe_context *pipe = st->pipe;
1704 struct st_basic_variant *v;
1705 struct st_basic_variant_key key;
1706
1707 memset(&key, 0, sizeof(key));
1708 key.st = st->has_shareable_shaders ? NULL : st;
1709
1710 /* Search for existing variant */
1711 for (v = *variants; v; v = v->next) {
1712 if (memcmp(&v->key, &key, sizeof(key)) == 0) {
1713 break;
1714 }
1715 }
1716
1717 if (!v) {
1718 /* create new */
1719 v = CALLOC_STRUCT(st_basic_variant);
1720 if (v) {
1721 /* fill in new variant */
1722 v->driver_shader = pipe->create_compute_state(pipe, tgsi);
1723 v->key = key;
1724
1725 /* insert into list */
1726 v->next = *variants;
1727 *variants = v;
1728 }
1729 }
1730
1731 return v;
1732 }
1733
1734
1735 /**
1736 * Vert/Geom/Frag programs have per-context variants. Free all the
1737 * variants attached to the given program which match the given context.
1738 */
1739 static void
1740 destroy_program_variants(struct st_context *st, struct gl_program *target)
1741 {
1742 if (!target || target == &_mesa_DummyProgram)
1743 return;
1744
1745 switch (target->Target) {
1746 case GL_VERTEX_PROGRAM_ARB:
1747 {
1748 struct st_vertex_program *stvp = (struct st_vertex_program *) target;
1749 struct st_vp_variant *vpv, **prevPtr = &stvp->variants;
1750
1751 for (vpv = stvp->variants; vpv; ) {
1752 struct st_vp_variant *next = vpv->next;
1753 if (vpv->key.st == st) {
1754 /* unlink from list */
1755 *prevPtr = next;
1756 /* destroy this variant */
1757 delete_vp_variant(st, vpv);
1758 }
1759 else {
1760 prevPtr = &vpv->next;
1761 }
1762 vpv = next;
1763 }
1764 }
1765 break;
1766 case GL_FRAGMENT_PROGRAM_ARB:
1767 {
1768 struct st_fragment_program *stfp =
1769 (struct st_fragment_program *) target;
1770 struct st_fp_variant *fpv, **prevPtr = &stfp->variants;
1771
1772 for (fpv = stfp->variants; fpv; ) {
1773 struct st_fp_variant *next = fpv->next;
1774 if (fpv->key.st == st) {
1775 /* unlink from list */
1776 *prevPtr = next;
1777 /* destroy this variant */
1778 delete_fp_variant(st, fpv);
1779 }
1780 else {
1781 prevPtr = &fpv->next;
1782 }
1783 fpv = next;
1784 }
1785 }
1786 break;
1787 case GL_GEOMETRY_PROGRAM_NV:
1788 case GL_TESS_CONTROL_PROGRAM_NV:
1789 case GL_TESS_EVALUATION_PROGRAM_NV:
1790 case GL_COMPUTE_PROGRAM_NV:
1791 {
1792 struct st_geometry_program *gp = (struct st_geometry_program*)target;
1793 struct st_tessctrl_program *tcp = (struct st_tessctrl_program*)target;
1794 struct st_tesseval_program *tep = (struct st_tesseval_program*)target;
1795 struct st_compute_program *cp = (struct st_compute_program*)target;
1796 struct st_basic_variant **variants =
1797 target->Target == GL_GEOMETRY_PROGRAM_NV ? &gp->variants :
1798 target->Target == GL_TESS_CONTROL_PROGRAM_NV ? &tcp->variants :
1799 target->Target == GL_TESS_EVALUATION_PROGRAM_NV ? &tep->variants :
1800 target->Target == GL_COMPUTE_PROGRAM_NV ? &cp->variants :
1801 NULL;
1802 struct st_basic_variant *v, **prevPtr = variants;
1803
1804 for (v = *variants; v; ) {
1805 struct st_basic_variant *next = v->next;
1806 if (v->key.st == st) {
1807 /* unlink from list */
1808 *prevPtr = next;
1809 /* destroy this variant */
1810 delete_basic_variant(st, v, target->Target);
1811 }
1812 else {
1813 prevPtr = &v->next;
1814 }
1815 v = next;
1816 }
1817 }
1818 break;
1819 default:
1820 _mesa_problem(NULL, "Unexpected program target 0x%x in "
1821 "destroy_program_variants_cb()", target->Target);
1822 }
1823 }
1824
1825
1826 /**
1827 * Callback for _mesa_HashWalk. Free all the shader's program variants
1828 * which match the given context.
1829 */
1830 static void
1831 destroy_shader_program_variants_cb(GLuint key, void *data, void *userData)
1832 {
1833 struct st_context *st = (struct st_context *) userData;
1834 struct gl_shader *shader = (struct gl_shader *) data;
1835
1836 switch (shader->Type) {
1837 case GL_SHADER_PROGRAM_MESA:
1838 {
1839 struct gl_shader_program *shProg = (struct gl_shader_program *) data;
1840 GLuint i;
1841
1842 for (i = 0; i < ARRAY_SIZE(shProg->_LinkedShaders); i++) {
1843 if (shProg->_LinkedShaders[i])
1844 destroy_program_variants(st, shProg->_LinkedShaders[i]->Program);
1845 }
1846 }
1847 break;
1848 case GL_VERTEX_SHADER:
1849 case GL_FRAGMENT_SHADER:
1850 case GL_GEOMETRY_SHADER:
1851 case GL_TESS_CONTROL_SHADER:
1852 case GL_TESS_EVALUATION_SHADER:
1853 case GL_COMPUTE_SHADER:
1854 break;
1855 default:
1856 assert(0);
1857 }
1858 }
1859
1860
1861 /**
1862 * Callback for _mesa_HashWalk. Free all the program variants which match
1863 * the given context.
1864 */
1865 static void
1866 destroy_program_variants_cb(GLuint key, void *data, void *userData)
1867 {
1868 struct st_context *st = (struct st_context *) userData;
1869 struct gl_program *program = (struct gl_program *) data;
1870 destroy_program_variants(st, program);
1871 }
1872
1873
1874 /**
1875 * Walk over all shaders and programs to delete any variants which
1876 * belong to the given context.
1877 * This is called during context tear-down.
1878 */
1879 void
1880 st_destroy_program_variants(struct st_context *st)
1881 {
1882 /* If shaders can be shared with other contexts, the last context will
1883 * call DeleteProgram on all shaders, releasing everything.
1884 */
1885 if (st->has_shareable_shaders)
1886 return;
1887
1888 /* ARB vert/frag program */
1889 _mesa_HashWalk(st->ctx->Shared->Programs,
1890 destroy_program_variants_cb, st);
1891
1892 /* GLSL vert/frag/geom shaders */
1893 _mesa_HashWalk(st->ctx->Shared->ShaderObjects,
1894 destroy_shader_program_variants_cb, st);
1895 }
1896
1897
1898 /**
1899 * For debugging, print/dump the current vertex program.
1900 */
1901 void
1902 st_print_current_vertex_program(void)
1903 {
1904 GET_CURRENT_CONTEXT(ctx);
1905
1906 if (ctx->VertexProgram._Current) {
1907 struct st_vertex_program *stvp =
1908 (struct st_vertex_program *) ctx->VertexProgram._Current;
1909 struct st_vp_variant *stv;
1910
1911 debug_printf("Vertex program %u\n", stvp->Base.Base.Id);
1912
1913 for (stv = stvp->variants; stv; stv = stv->next) {
1914 debug_printf("variant %p\n", stv);
1915 tgsi_dump(stv->tgsi.tokens, 0);
1916 }
1917 }
1918 }
1919
1920
1921 /**
1922 * Compile one shader variant.
1923 */
1924 void
1925 st_precompile_shader_variant(struct st_context *st,
1926 struct gl_program *prog)
1927 {
1928 switch (prog->Target) {
1929 case GL_VERTEX_PROGRAM_ARB: {
1930 struct st_vertex_program *p = (struct st_vertex_program *)prog;
1931 struct st_vp_variant_key key;
1932
1933 memset(&key, 0, sizeof(key));
1934 key.st = st->has_shareable_shaders ? NULL : st;
1935 st_get_vp_variant(st, p, &key);
1936 break;
1937 }
1938
1939 case GL_TESS_CONTROL_PROGRAM_NV: {
1940 struct st_tessctrl_program *p = (struct st_tessctrl_program *)prog;
1941 st_get_basic_variant(st, PIPE_SHADER_TESS_CTRL, &p->tgsi, &p->variants);
1942 break;
1943 }
1944
1945 case GL_TESS_EVALUATION_PROGRAM_NV: {
1946 struct st_tesseval_program *p = (struct st_tesseval_program *)prog;
1947 st_get_basic_variant(st, PIPE_SHADER_TESS_EVAL, &p->tgsi, &p->variants);
1948 break;
1949 }
1950
1951 case GL_GEOMETRY_PROGRAM_NV: {
1952 struct st_geometry_program *p = (struct st_geometry_program *)prog;
1953 st_get_basic_variant(st, PIPE_SHADER_GEOMETRY, &p->tgsi, &p->variants);
1954 break;
1955 }
1956
1957 case GL_FRAGMENT_PROGRAM_ARB: {
1958 struct st_fragment_program *p = (struct st_fragment_program *)prog;
1959 struct st_fp_variant_key key;
1960
1961 memset(&key, 0, sizeof(key));
1962 key.st = st->has_shareable_shaders ? NULL : st;
1963 st_get_fp_variant(st, p, &key);
1964 break;
1965 }
1966
1967 case GL_COMPUTE_PROGRAM_NV: {
1968 struct st_compute_program *p = (struct st_compute_program *)prog;
1969 st_get_cp_variant(st, &p->tgsi, &p->variants);
1970 break;
1971 }
1972
1973 default:
1974 assert(0);
1975 }
1976 }