projects / mesa.git / blob
? search:


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