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