projects / mesa.git / blob
? search:


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