projects / mesa.git / blob
? search:


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