projects / mesa.git / blob
? search:


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