glsl: Fix gl_shader_stage enum unsigned comparison
[mesa.git] / src / compiler / glsl / link_varyings.cpp
1 /*
2 * Copyright © 2012 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 /**
25 * \file link_varyings.cpp
26 *
27 * Linker functions related specifically to linking varyings between shader
28 * stages.
29 */
30
31
32 #include "main/mtypes.h"
33 #include "glsl_symbol_table.h"
34 #include "glsl_parser_extras.h"
35 #include "ir_optimization.h"
36 #include "linker.h"
37 #include "link_varyings.h"
38 #include "main/macros.h"
39 #include "util/hash_table.h"
40 #include "program.h"
41
42
43 /**
44 * Get the varying type stripped of the outermost array if we're processing
45 * a stage whose varyings are arrays indexed by a vertex number (such as
46 * geometry shader inputs).
47 */
48 static const glsl_type *
49 get_varying_type(const ir_variable *var, gl_shader_stage stage)
50 {
51 const glsl_type *type = var->type;
52
53 if (!var->data.patch &&
54 ((var->data.mode == ir_var_shader_out &&
55 stage == MESA_SHADER_TESS_CTRL) ||
56 (var->data.mode == ir_var_shader_in &&
57 (stage == MESA_SHADER_TESS_CTRL || stage == MESA_SHADER_TESS_EVAL ||
58 stage == MESA_SHADER_GEOMETRY)))) {
59 assert(type->is_array());
60 type = type->fields.array;
61 }
62
63 return type;
64 }
65
66 static void
67 create_xfb_varying_names(void *mem_ctx, const glsl_type *t, char **name,
68 size_t name_length, unsigned *count,
69 const char *ifc_member_name,
70 const glsl_type *ifc_member_t, char ***varying_names)
71 {
72 if (t->is_interface()) {
73 size_t new_length = name_length;
74
75 assert(ifc_member_name && ifc_member_t);
76 ralloc_asprintf_rewrite_tail(name, &new_length, ".%s", ifc_member_name);
77
78 create_xfb_varying_names(mem_ctx, ifc_member_t, name, new_length, count,
79 NULL, NULL, varying_names);
80 } else if (t->is_record()) {
81 for (unsigned i = 0; i < t->length; i++) {
82 const char *field = t->fields.structure[i].name;
83 size_t new_length = name_length;
84
85 ralloc_asprintf_rewrite_tail(name, &new_length, ".%s", field);
86
87 create_xfb_varying_names(mem_ctx, t->fields.structure[i].type, name,
88 new_length, count, NULL, NULL,
89 varying_names);
90 }
91 } else if (t->without_array()->is_record() ||
92 t->without_array()->is_interface() ||
93 (t->is_array() && t->fields.array->is_array())) {
94 for (unsigned i = 0; i < t->length; i++) {
95 size_t new_length = name_length;
96
97 /* Append the subscript to the current variable name */
98 ralloc_asprintf_rewrite_tail(name, &new_length, "[%u]", i);
99
100 create_xfb_varying_names(mem_ctx, t->fields.array, name, new_length,
101 count, ifc_member_name, ifc_member_t,
102 varying_names);
103 }
104 } else {
105 (*varying_names)[(*count)++] = ralloc_strdup(mem_ctx, *name);
106 }
107 }
108
109 static bool
110 process_xfb_layout_qualifiers(void *mem_ctx, const gl_linked_shader *sh,
111 struct gl_shader_program *prog,
112 unsigned *num_tfeedback_decls,
113 char ***varying_names)
114 {
115 bool has_xfb_qualifiers = false;
116
117 /* We still need to enable transform feedback mode even if xfb_stride is
118 * only applied to a global out. Also we don't bother to propagate
119 * xfb_stride to interface block members so this will catch that case also.
120 */
121 for (unsigned j = 0; j < MAX_FEEDBACK_BUFFERS; j++) {
122 if (prog->TransformFeedback.BufferStride[j]) {
123 has_xfb_qualifiers = true;
124 break;
125 }
126 }
127
128 foreach_in_list(ir_instruction, node, sh->ir) {
129 ir_variable *var = node->as_variable();
130 if (!var || var->data.mode != ir_var_shader_out)
131 continue;
132
133 /* From the ARB_enhanced_layouts spec:
134 *
135 * "Any shader making any static use (after preprocessing) of any of
136 * these *xfb_* qualifiers will cause the shader to be in a
137 * transform feedback capturing mode and hence responsible for
138 * describing the transform feedback setup. This mode will capture
139 * any output selected by *xfb_offset*, directly or indirectly, to
140 * a transform feedback buffer."
141 */
142 if (var->data.explicit_xfb_buffer || var->data.explicit_xfb_stride) {
143 has_xfb_qualifiers = true;
144 }
145
146 if (var->data.explicit_xfb_offset) {
147 *num_tfeedback_decls += var->type->varying_count();
148 has_xfb_qualifiers = true;
149 }
150 }
151
152 if (*num_tfeedback_decls == 0)
153 return has_xfb_qualifiers;
154
155 unsigned i = 0;
156 *varying_names = ralloc_array(mem_ctx, char *, *num_tfeedback_decls);
157 foreach_in_list(ir_instruction, node, sh->ir) {
158 ir_variable *var = node->as_variable();
159 if (!var || var->data.mode != ir_var_shader_out)
160 continue;
161
162 if (var->data.explicit_xfb_offset) {
163 char *name;
164 const glsl_type *type, *member_type;
165
166 if (var->data.from_named_ifc_block) {
167 type = var->get_interface_type();
168 /* Find the member type before it was altered by lowering */
169 member_type =
170 type->fields.structure[type->field_index(var->name)].type;
171 name = ralloc_strdup(NULL, type->without_array()->name);
172 } else {
173 type = var->type;
174 member_type = NULL;
175 name = ralloc_strdup(NULL, var->name);
176 }
177 create_xfb_varying_names(mem_ctx, type, &name, strlen(name), &i,
178 var->name, member_type, varying_names);
179 ralloc_free(name);
180 }
181 }
182
183 assert(i == *num_tfeedback_decls);
184 return has_xfb_qualifiers;
185 }
186
187 static bool
188 anonymous_struct_type_matches(const glsl_type *output_type,
189 const glsl_type *to_match)
190 {
191 while (output_type->is_array() && to_match->is_array()) {
192 /* if the lengths at each level don't match fail. */
193 if (output_type->length != to_match->length)
194 return false;
195 output_type = output_type->fields.array;
196 to_match = to_match->fields.array;
197 }
198
199 if (output_type->is_array() || to_match->is_array())
200 return false;
201 return output_type->is_anonymous() &&
202 to_match->is_anonymous() &&
203 to_match->record_compare(output_type);
204 }
205
206 /**
207 * Validate the types and qualifiers of an output from one stage against the
208 * matching input to another stage.
209 */
210 static void
211 cross_validate_types_and_qualifiers(struct gl_shader_program *prog,
212 const ir_variable *input,
213 const ir_variable *output,
214 gl_shader_stage consumer_stage,
215 gl_shader_stage producer_stage)
216 {
217 /* Check that the types match between stages.
218 */
219 const glsl_type *type_to_match = input->type;
220
221 /* VS -> GS, VS -> TCS, VS -> TES, TES -> GS */
222 const bool extra_array_level = (producer_stage == MESA_SHADER_VERTEX &&
223 consumer_stage != MESA_SHADER_FRAGMENT) ||
224 consumer_stage == MESA_SHADER_GEOMETRY;
225 if (extra_array_level) {
226 assert(type_to_match->is_array());
227 type_to_match = type_to_match->fields.array;
228 }
229
230 if (type_to_match != output->type) {
231 /* There is a bit of a special case for gl_TexCoord. This
232 * built-in is unsized by default. Applications that variable
233 * access it must redeclare it with a size. There is some
234 * language in the GLSL spec that implies the fragment shader
235 * and vertex shader do not have to agree on this size. Other
236 * driver behave this way, and one or two applications seem to
237 * rely on it.
238 *
239 * Neither declaration needs to be modified here because the array
240 * sizes are fixed later when update_array_sizes is called.
241 *
242 * From page 48 (page 54 of the PDF) of the GLSL 1.10 spec:
243 *
244 * "Unlike user-defined varying variables, the built-in
245 * varying variables don't have a strict one-to-one
246 * correspondence between the vertex language and the
247 * fragment language."
248 */
249 if (!output->type->is_array() || !is_gl_identifier(output->name)) {
250 bool anon_matches = anonymous_struct_type_matches(output->type, type_to_match);
251
252 if (!anon_matches) {
253 linker_error(prog,
254 "%s shader output `%s' declared as type `%s', "
255 "but %s shader input declared as type `%s'\n",
256 _mesa_shader_stage_to_string(producer_stage),
257 output->name,
258 output->type->name,
259 _mesa_shader_stage_to_string(consumer_stage),
260 input->type->name);
261 return;
262 }
263 }
264 }
265
266 /* Check that all of the qualifiers match between stages.
267 */
268
269 /* According to the OpenGL and OpenGLES GLSL specs, the centroid qualifier
270 * should match until OpenGL 4.3 and OpenGLES 3.1. The OpenGLES 3.0
271 * conformance test suite does not verify that the qualifiers must match.
272 * The deqp test suite expects the opposite (OpenGLES 3.1) behavior for
273 * OpenGLES 3.0 drivers, so we relax the checking in all cases.
274 */
275 if (false /* always skip the centroid check */ &&
276 prog->data->Version < (prog->IsES ? 310 : 430) &&
277 input->data.centroid != output->data.centroid) {
278 linker_error(prog,
279 "%s shader output `%s' %s centroid qualifier, "
280 "but %s shader input %s centroid qualifier\n",
281 _mesa_shader_stage_to_string(producer_stage),
282 output->name,
283 (output->data.centroid) ? "has" : "lacks",
284 _mesa_shader_stage_to_string(consumer_stage),
285 (input->data.centroid) ? "has" : "lacks");
286 return;
287 }
288
289 if (input->data.sample != output->data.sample) {
290 linker_error(prog,
291 "%s shader output `%s' %s sample qualifier, "
292 "but %s shader input %s sample qualifier\n",
293 _mesa_shader_stage_to_string(producer_stage),
294 output->name,
295 (output->data.sample) ? "has" : "lacks",
296 _mesa_shader_stage_to_string(consumer_stage),
297 (input->data.sample) ? "has" : "lacks");
298 return;
299 }
300
301 if (input->data.patch != output->data.patch) {
302 linker_error(prog,
303 "%s shader output `%s' %s patch qualifier, "
304 "but %s shader input %s patch qualifier\n",
305 _mesa_shader_stage_to_string(producer_stage),
306 output->name,
307 (output->data.patch) ? "has" : "lacks",
308 _mesa_shader_stage_to_string(consumer_stage),
309 (input->data.patch) ? "has" : "lacks");
310 return;
311 }
312
313 /* The GLSL 4.30 and GLSL ES 3.00 specifications say:
314 *
315 * "As only outputs need be declared with invariant, an output from
316 * one shader stage will still match an input of a subsequent stage
317 * without the input being declared as invariant."
318 *
319 * while GLSL 4.20 says:
320 *
321 * "For variables leaving one shader and coming into another shader,
322 * the invariant keyword has to be used in both shaders, or a link
323 * error will result."
324 *
325 * and GLSL ES 1.00 section 4.6.4 "Invariance and Linking" says:
326 *
327 * "The invariance of varyings that are declared in both the vertex
328 * and fragment shaders must match."
329 */
330 if (input->data.invariant != output->data.invariant &&
331 prog->data->Version < (prog->IsES ? 300 : 430)) {
332 linker_error(prog,
333 "%s shader output `%s' %s invariant qualifier, "
334 "but %s shader input %s invariant qualifier\n",
335 _mesa_shader_stage_to_string(producer_stage),
336 output->name,
337 (output->data.invariant) ? "has" : "lacks",
338 _mesa_shader_stage_to_string(consumer_stage),
339 (input->data.invariant) ? "has" : "lacks");
340 return;
341 }
342
343 /* GLSL >= 4.40 removes text requiring interpolation qualifiers
344 * to match cross stage, they must only match within the same stage.
345 *
346 * From page 84 (page 90 of the PDF) of the GLSL 4.40 spec:
347 *
348 * "It is a link-time error if, within the same stage, the interpolation
349 * qualifiers of variables of the same name do not match.
350 *
351 */
352 if (input->data.interpolation != output->data.interpolation &&
353 prog->data->Version < 440) {
354 linker_error(prog,
355 "%s shader output `%s' specifies %s "
356 "interpolation qualifier, "
357 "but %s shader input specifies %s "
358 "interpolation qualifier\n",
359 _mesa_shader_stage_to_string(producer_stage),
360 output->name,
361 interpolation_string(output->data.interpolation),
362 _mesa_shader_stage_to_string(consumer_stage),
363 interpolation_string(input->data.interpolation));
364 return;
365 }
366 }
367
368 /**
369 * Validate front and back color outputs against single color input
370 */
371 static void
372 cross_validate_front_and_back_color(struct gl_shader_program *prog,
373 const ir_variable *input,
374 const ir_variable *front_color,
375 const ir_variable *back_color,
376 gl_shader_stage consumer_stage,
377 gl_shader_stage producer_stage)
378 {
379 if (front_color != NULL && front_color->data.assigned)
380 cross_validate_types_and_qualifiers(prog, input, front_color,
381 consumer_stage, producer_stage);
382
383 if (back_color != NULL && back_color->data.assigned)
384 cross_validate_types_and_qualifiers(prog, input, back_color,
385 consumer_stage, producer_stage);
386 }
387
388 /**
389 * Validate that outputs from one stage match inputs of another
390 */
391 void
392 cross_validate_outputs_to_inputs(struct gl_shader_program *prog,
393 gl_linked_shader *producer,
394 gl_linked_shader *consumer)
395 {
396 glsl_symbol_table parameters;
397 ir_variable *explicit_locations[MAX_VARYINGS_INCL_PATCH][4] =
398 { {NULL, NULL} };
399
400 /* Find all shader outputs in the "producer" stage.
401 */
402 foreach_in_list(ir_instruction, node, producer->ir) {
403 ir_variable *const var = node->as_variable();
404
405 if (var == NULL || var->data.mode != ir_var_shader_out)
406 continue;
407
408 if (!var->data.explicit_location
409 || var->data.location < VARYING_SLOT_VAR0)
410 parameters.add_variable(var);
411 else {
412 /* User-defined varyings with explicit locations are handled
413 * differently because they do not need to have matching names.
414 */
415 const glsl_type *type = get_varying_type(var, producer->Stage);
416 unsigned num_elements = type->count_attribute_slots(false);
417 unsigned idx = var->data.location - VARYING_SLOT_VAR0;
418 unsigned slot_limit = idx + num_elements;
419 unsigned last_comp;
420
421 if (type->without_array()->is_record()) {
422 /* The component qualifier can't be used on structs so just treat
423 * all component slots as used.
424 */
425 last_comp = 4;
426 } else {
427 unsigned dmul = type->without_array()->is_64bit() ? 2 : 1;
428 last_comp = var->data.location_frac +
429 type->without_array()->vector_elements * dmul;
430 }
431
432 while (idx < slot_limit) {
433 unsigned i = var->data.location_frac;
434 while (i < last_comp) {
435 if (explicit_locations[idx][i] != NULL) {
436 linker_error(prog,
437 "%s shader has multiple outputs explicitly "
438 "assigned to location %d and component %d\n",
439 _mesa_shader_stage_to_string(producer->Stage),
440 idx, var->data.location_frac);
441 return;
442 }
443
444 /* Make sure all component at this location have the same type.
445 */
446 for (unsigned j = 0; j < 4; j++) {
447 if (explicit_locations[idx][j] &&
448 (explicit_locations[idx][j]->type->without_array()
449 ->base_type != type->without_array()->base_type)) {
450 linker_error(prog,
451 "Varyings sharing the same location must "
452 "have the same underlying numerical type. "
453 "Location %u component %u\n", idx,
454 var->data.location_frac);
455 return;
456 }
457 }
458
459 explicit_locations[idx][i] = var;
460 i++;
461
462 /* We need to do some special handling for doubles as dvec3 and
463 * dvec4 consume two consecutive locations. We don't need to
464 * worry about components beginning at anything other than 0 as
465 * the spec does not allow this for dvec3 and dvec4.
466 */
467 if (i == 4 && last_comp > 4) {
468 last_comp = last_comp - 4;
469 /* Bump location index and reset the component index */
470 idx++;
471 i = 0;
472 }
473 }
474 idx++;
475 }
476 }
477 }
478
479
480 /* Find all shader inputs in the "consumer" stage. Any variables that have
481 * matching outputs already in the symbol table must have the same type and
482 * qualifiers.
483 *
484 * Exception: if the consumer is the geometry shader, then the inputs
485 * should be arrays and the type of the array element should match the type
486 * of the corresponding producer output.
487 */
488 foreach_in_list(ir_instruction, node, consumer->ir) {
489 ir_variable *const input = node->as_variable();
490
491 if (input == NULL || input->data.mode != ir_var_shader_in)
492 continue;
493
494 if (strcmp(input->name, "gl_Color") == 0 && input->data.used) {
495 const ir_variable *const front_color =
496 parameters.get_variable("gl_FrontColor");
497
498 const ir_variable *const back_color =
499 parameters.get_variable("gl_BackColor");
500
501 cross_validate_front_and_back_color(prog, input,
502 front_color, back_color,
503 consumer->Stage, producer->Stage);
504 } else if (strcmp(input->name, "gl_SecondaryColor") == 0 && input->data.used) {
505 const ir_variable *const front_color =
506 parameters.get_variable("gl_FrontSecondaryColor");
507
508 const ir_variable *const back_color =
509 parameters.get_variable("gl_BackSecondaryColor");
510
511 cross_validate_front_and_back_color(prog, input,
512 front_color, back_color,
513 consumer->Stage, producer->Stage);
514 } else {
515 /* The rules for connecting inputs and outputs change in the presence
516 * of explicit locations. In this case, we no longer care about the
517 * names of the variables. Instead, we care only about the
518 * explicitly assigned location.
519 */
520 ir_variable *output = NULL;
521 if (input->data.explicit_location
522 && input->data.location >= VARYING_SLOT_VAR0) {
523
524 const glsl_type *type = get_varying_type(input, consumer->Stage);
525 unsigned num_elements = type->count_attribute_slots(false);
526 unsigned idx = input->data.location - VARYING_SLOT_VAR0;
527 unsigned slot_limit = idx + num_elements;
528
529 while (idx < slot_limit) {
530 output = explicit_locations[idx][input->data.location_frac];
531
532 if (output == NULL ||
533 input->data.location != output->data.location) {
534 linker_error(prog,
535 "%s shader input `%s' with explicit location "
536 "has no matching output\n",
537 _mesa_shader_stage_to_string(consumer->Stage),
538 input->name);
539 break;
540 }
541 idx++;
542 }
543 } else {
544 output = parameters.get_variable(input->name);
545 }
546
547 if (output != NULL) {
548 /* Interface blocks have their own validation elsewhere so don't
549 * try validating them here.
550 */
551 if (!(input->get_interface_type() &&
552 output->get_interface_type()))
553 cross_validate_types_and_qualifiers(prog, input, output,
554 consumer->Stage,
555 producer->Stage);
556 } else {
557 /* Check for input vars with unmatched output vars in prev stage
558 * taking into account that interface blocks could have a matching
559 * output but with different name, so we ignore them.
560 */
561 assert(!input->data.assigned);
562 if (input->data.used && !input->get_interface_type() &&
563 !input->data.explicit_location && !prog->SeparateShader)
564 linker_error(prog,
565 "%s shader input `%s' "
566 "has no matching output in the previous stage\n",
567 _mesa_shader_stage_to_string(consumer->Stage),
568 input->name);
569 }
570 }
571 }
572 }
573
574 /**
575 * Demote shader inputs and outputs that are not used in other stages, and
576 * remove them via dead code elimination.
577 */
578 static void
579 remove_unused_shader_inputs_and_outputs(bool is_separate_shader_object,
580 gl_linked_shader *sh,
581 enum ir_variable_mode mode)
582 {
583 if (is_separate_shader_object)
584 return;
585
586 foreach_in_list(ir_instruction, node, sh->ir) {
587 ir_variable *const var = node->as_variable();
588
589 if (var == NULL || var->data.mode != int(mode))
590 continue;
591
592 /* A shader 'in' or 'out' variable is only really an input or output if
593 * its value is used by other shader stages. This will cause the
594 * variable to have a location assigned.
595 */
596 if (var->data.is_unmatched_generic_inout && !var->data.is_xfb_only) {
597 assert(var->data.mode != ir_var_temporary);
598
599 /* Assign zeros to demoted inputs to allow more optimizations. */
600 if (var->data.mode == ir_var_shader_in && !var->constant_value)
601 var->constant_value = ir_constant::zero(var, var->type);
602
603 var->data.mode = ir_var_auto;
604 }
605 }
606
607 /* Eliminate code that is now dead due to unused inputs/outputs being
608 * demoted.
609 */
610 while (do_dead_code(sh->ir, false))
611 ;
612
613 }
614
615 /**
616 * Initialize this object based on a string that was passed to
617 * glTransformFeedbackVaryings.
618 *
619 * If the input is mal-formed, this call still succeeds, but it sets
620 * this->var_name to a mal-formed input, so tfeedback_decl::find_output_var()
621 * will fail to find any matching variable.
622 */
623 void
624 tfeedback_decl::init(struct gl_context *ctx, const void *mem_ctx,
625 const char *input)
626 {
627 /* We don't have to be pedantic about what is a valid GLSL variable name,
628 * because any variable with an invalid name can't exist in the IR anyway.
629 */
630
631 this->location = -1;
632 this->orig_name = input;
633 this->lowered_builtin_array_variable = none;
634 this->skip_components = 0;
635 this->next_buffer_separator = false;
636 this->matched_candidate = NULL;
637 this->stream_id = 0;
638 this->buffer = 0;
639 this->offset = 0;
640
641 if (ctx->Extensions.ARB_transform_feedback3) {
642 /* Parse gl_NextBuffer. */
643 if (strcmp(input, "gl_NextBuffer") == 0) {
644 this->next_buffer_separator = true;
645 return;
646 }
647
648 /* Parse gl_SkipComponents. */
649 if (strcmp(input, "gl_SkipComponents1") == 0)
650 this->skip_components = 1;
651 else if (strcmp(input, "gl_SkipComponents2") == 0)
652 this->skip_components = 2;
653 else if (strcmp(input, "gl_SkipComponents3") == 0)
654 this->skip_components = 3;
655 else if (strcmp(input, "gl_SkipComponents4") == 0)
656 this->skip_components = 4;
657
658 if (this->skip_components)
659 return;
660 }
661
662 /* Parse a declaration. */
663 const char *base_name_end;
664 long subscript = parse_program_resource_name(input, &base_name_end);
665 this->var_name = ralloc_strndup(mem_ctx, input, base_name_end - input);
666 if (this->var_name == NULL) {
667 _mesa_error_no_memory(__func__);
668 return;
669 }
670
671 if (subscript >= 0) {
672 this->array_subscript = subscript;
673 this->is_subscripted = true;
674 } else {
675 this->is_subscripted = false;
676 }
677
678 /* For drivers that lower gl_ClipDistance to gl_ClipDistanceMESA, this
679 * class must behave specially to account for the fact that gl_ClipDistance
680 * is converted from a float[8] to a vec4[2].
681 */
682 if (ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].LowerCombinedClipCullDistance &&
683 strcmp(this->var_name, "gl_ClipDistance") == 0) {
684 this->lowered_builtin_array_variable = clip_distance;
685 }
686 if (ctx->Const.ShaderCompilerOptions[MESA_SHADER_VERTEX].LowerCombinedClipCullDistance &&
687 strcmp(this->var_name, "gl_CullDistance") == 0) {
688 this->lowered_builtin_array_variable = cull_distance;
689 }
690
691 if (ctx->Const.LowerTessLevel &&
692 (strcmp(this->var_name, "gl_TessLevelOuter") == 0))
693 this->lowered_builtin_array_variable = tess_level_outer;
694 if (ctx->Const.LowerTessLevel &&
695 (strcmp(this->var_name, "gl_TessLevelInner") == 0))
696 this->lowered_builtin_array_variable = tess_level_inner;
697 }
698
699
700 /**
701 * Determine whether two tfeedback_decl objects refer to the same variable and
702 * array index (if applicable).
703 */
704 bool
705 tfeedback_decl::is_same(const tfeedback_decl &x, const tfeedback_decl &y)
706 {
707 assert(x.is_varying() && y.is_varying());
708
709 if (strcmp(x.var_name, y.var_name) != 0)
710 return false;
711 if (x.is_subscripted != y.is_subscripted)
712 return false;
713 if (x.is_subscripted && x.array_subscript != y.array_subscript)
714 return false;
715 return true;
716 }
717
718
719 /**
720 * Assign a location and stream ID for this tfeedback_decl object based on the
721 * transform feedback candidate found by find_candidate.
722 *
723 * If an error occurs, the error is reported through linker_error() and false
724 * is returned.
725 */
726 bool
727 tfeedback_decl::assign_location(struct gl_context *ctx,
728 struct gl_shader_program *prog)
729 {
730 assert(this->is_varying());
731
732 unsigned fine_location
733 = this->matched_candidate->toplevel_var->data.location * 4
734 + this->matched_candidate->toplevel_var->data.location_frac
735 + this->matched_candidate->offset;
736 const unsigned dmul =
737 this->matched_candidate->type->without_array()->is_64bit() ? 2 : 1;
738
739 if (this->matched_candidate->type->is_array()) {
740 /* Array variable */
741 const unsigned matrix_cols =
742 this->matched_candidate->type->fields.array->matrix_columns;
743 const unsigned vector_elements =
744 this->matched_candidate->type->fields.array->vector_elements;
745 unsigned actual_array_size;
746 switch (this->lowered_builtin_array_variable) {
747 case clip_distance:
748 actual_array_size = prog->last_vert_prog ?
749 prog->last_vert_prog->info.clip_distance_array_size : 0;
750 break;
751 case cull_distance:
752 actual_array_size = prog->last_vert_prog ?
753 prog->last_vert_prog->info.cull_distance_array_size : 0;
754 break;
755 case tess_level_outer:
756 actual_array_size = 4;
757 break;
758 case tess_level_inner:
759 actual_array_size = 2;
760 break;
761 case none:
762 default:
763 actual_array_size = this->matched_candidate->type->array_size();
764 break;
765 }
766
767 if (this->is_subscripted) {
768 /* Check array bounds. */
769 if (this->array_subscript >= actual_array_size) {
770 linker_error(prog, "Transform feedback varying %s has index "
771 "%i, but the array size is %u.",
772 this->orig_name, this->array_subscript,
773 actual_array_size);
774 return false;
775 }
776 unsigned array_elem_size = this->lowered_builtin_array_variable ?
777 1 : vector_elements * matrix_cols * dmul;
778 fine_location += array_elem_size * this->array_subscript;
779 this->size = 1;
780 } else {
781 this->size = actual_array_size;
782 }
783 this->vector_elements = vector_elements;
784 this->matrix_columns = matrix_cols;
785 if (this->lowered_builtin_array_variable)
786 this->type = GL_FLOAT;
787 else
788 this->type = this->matched_candidate->type->fields.array->gl_type;
789 } else {
790 /* Regular variable (scalar, vector, or matrix) */
791 if (this->is_subscripted) {
792 linker_error(prog, "Transform feedback varying %s requested, "
793 "but %s is not an array.",
794 this->orig_name, this->var_name);
795 return false;
796 }
797 this->size = 1;
798 this->vector_elements = this->matched_candidate->type->vector_elements;
799 this->matrix_columns = this->matched_candidate->type->matrix_columns;
800 this->type = this->matched_candidate->type->gl_type;
801 }
802 this->location = fine_location / 4;
803 this->location_frac = fine_location % 4;
804
805 /* From GL_EXT_transform_feedback:
806 * A program will fail to link if:
807 *
808 * * the total number of components to capture in any varying
809 * variable in <varyings> is greater than the constant
810 * MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT and the
811 * buffer mode is SEPARATE_ATTRIBS_EXT;
812 */
813 if (prog->TransformFeedback.BufferMode == GL_SEPARATE_ATTRIBS &&
814 this->num_components() >
815 ctx->Const.MaxTransformFeedbackSeparateComponents) {
816 linker_error(prog, "Transform feedback varying %s exceeds "
817 "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS.",
818 this->orig_name);
819 return false;
820 }
821
822 /* Only transform feedback varyings can be assigned to non-zero streams,
823 * so assign the stream id here.
824 */
825 this->stream_id = this->matched_candidate->toplevel_var->data.stream;
826
827 unsigned array_offset = this->array_subscript * 4 * dmul;
828 unsigned struct_offset = this->matched_candidate->offset * 4 * dmul;
829 this->buffer = this->matched_candidate->toplevel_var->data.xfb_buffer;
830 this->offset = this->matched_candidate->toplevel_var->data.offset +
831 array_offset + struct_offset;
832
833 return true;
834 }
835
836
837 unsigned
838 tfeedback_decl::get_num_outputs() const
839 {
840 if (!this->is_varying()) {
841 return 0;
842 }
843 return (this->num_components() + this->location_frac + 3)/4;
844 }
845
846
847 /**
848 * Update gl_transform_feedback_info to reflect this tfeedback_decl.
849 *
850 * If an error occurs, the error is reported through linker_error() and false
851 * is returned.
852 */
853 bool
854 tfeedback_decl::store(struct gl_context *ctx, struct gl_shader_program *prog,
855 struct gl_transform_feedback_info *info,
856 unsigned buffer, unsigned buffer_index,
857 const unsigned max_outputs, bool *explicit_stride,
858 bool has_xfb_qualifiers) const
859 {
860 unsigned xfb_offset = 0;
861 unsigned size = this->size;
862 /* Handle gl_SkipComponents. */
863 if (this->skip_components) {
864 info->Buffers[buffer].Stride += this->skip_components;
865 size = this->skip_components;
866 goto store_varying;
867 }
868
869 if (this->next_buffer_separator) {
870 size = 0;
871 goto store_varying;
872 }
873
874 if (has_xfb_qualifiers) {
875 xfb_offset = this->offset / 4;
876 } else {
877 xfb_offset = info->Buffers[buffer].Stride;
878 }
879 info->Varyings[info->NumVarying].Offset = xfb_offset * 4;
880
881 {
882 unsigned location = this->location;
883 unsigned location_frac = this->location_frac;
884 unsigned num_components = this->num_components();
885 while (num_components > 0) {
886 unsigned output_size = MIN2(num_components, 4 - location_frac);
887 assert((info->NumOutputs == 0 && max_outputs == 0) ||
888 info->NumOutputs < max_outputs);
889
890 /* From the ARB_enhanced_layouts spec:
891 *
892 * "If such a block member or variable is not written during a shader
893 * invocation, the buffer contents at the assigned offset will be
894 * undefined. Even if there are no static writes to a variable or
895 * member that is assigned a transform feedback offset, the space is
896 * still allocated in the buffer and still affects the stride."
897 */
898 if (this->is_varying_written()) {
899 info->Outputs[info->NumOutputs].ComponentOffset = location_frac;
900 info->Outputs[info->NumOutputs].OutputRegister = location;
901 info->Outputs[info->NumOutputs].NumComponents = output_size;
902 info->Outputs[info->NumOutputs].StreamId = stream_id;
903 info->Outputs[info->NumOutputs].OutputBuffer = buffer;
904 info->Outputs[info->NumOutputs].DstOffset = xfb_offset;
905 ++info->NumOutputs;
906 }
907 info->Buffers[buffer].Stream = this->stream_id;
908 xfb_offset += output_size;
909
910 num_components -= output_size;
911 location++;
912 location_frac = 0;
913 }
914 }
915
916 if (explicit_stride && explicit_stride[buffer]) {
917 if (this->is_64bit() && info->Buffers[buffer].Stride % 2) {
918 linker_error(prog, "invalid qualifier xfb_stride=%d must be a "
919 "multiple of 8 as its applied to a type that is or "
920 "contains a double.",
921 info->Buffers[buffer].Stride * 4);
922 return false;
923 }
924
925 if ((this->offset / 4) / info->Buffers[buffer].Stride !=
926 (xfb_offset - 1) / info->Buffers[buffer].Stride) {
927 linker_error(prog, "xfb_offset (%d) overflows xfb_stride (%d) for "
928 "buffer (%d)", xfb_offset * 4,
929 info->Buffers[buffer].Stride * 4, buffer);
930 return false;
931 }
932 } else {
933 info->Buffers[buffer].Stride = xfb_offset;
934 }
935
936 /* From GL_EXT_transform_feedback:
937 * A program will fail to link if:
938 *
939 * * the total number of components to capture is greater than
940 * the constant MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT
941 * and the buffer mode is INTERLEAVED_ATTRIBS_EXT.
942 *
943 * From GL_ARB_enhanced_layouts:
944 *
945 * "The resulting stride (implicit or explicit) must be less than or
946 * equal to the implementation-dependent constant
947 * gl_MaxTransformFeedbackInterleavedComponents."
948 */
949 if ((prog->TransformFeedback.BufferMode == GL_INTERLEAVED_ATTRIBS ||
950 has_xfb_qualifiers) &&
951 info->Buffers[buffer].Stride >
952 ctx->Const.MaxTransformFeedbackInterleavedComponents) {
953 linker_error(prog, "The MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS "
954 "limit has been exceeded.");
955 return false;
956 }
957
958 store_varying:
959 info->Varyings[info->NumVarying].Name = ralloc_strdup(prog,
960 this->orig_name);
961 info->Varyings[info->NumVarying].Type = this->type;
962 info->Varyings[info->NumVarying].Size = size;
963 info->Varyings[info->NumVarying].BufferIndex = buffer_index;
964 info->NumVarying++;
965 info->Buffers[buffer].NumVaryings++;
966
967 return true;
968 }
969
970
971 const tfeedback_candidate *
972 tfeedback_decl::find_candidate(gl_shader_program *prog,
973 hash_table *tfeedback_candidates)
974 {
975 const char *name = this->var_name;
976 switch (this->lowered_builtin_array_variable) {
977 case none:
978 name = this->var_name;
979 break;
980 case clip_distance:
981 name = "gl_ClipDistanceMESA";
982 break;
983 case cull_distance:
984 name = "gl_CullDistanceMESA";
985 break;
986 case tess_level_outer:
987 name = "gl_TessLevelOuterMESA";
988 break;
989 case tess_level_inner:
990 name = "gl_TessLevelInnerMESA";
991 break;
992 }
993 hash_entry *entry = _mesa_hash_table_search(tfeedback_candidates, name);
994
995 this->matched_candidate = entry ?
996 (const tfeedback_candidate *) entry->data : NULL;
997
998 if (!this->matched_candidate) {
999 /* From GL_EXT_transform_feedback:
1000 * A program will fail to link if:
1001 *
1002 * * any variable name specified in the <varyings> array is not
1003 * declared as an output in the geometry shader (if present) or
1004 * the vertex shader (if no geometry shader is present);
1005 */
1006 linker_error(prog, "Transform feedback varying %s undeclared.",
1007 this->orig_name);
1008 }
1009
1010 return this->matched_candidate;
1011 }
1012
1013
1014 /**
1015 * Parse all the transform feedback declarations that were passed to
1016 * glTransformFeedbackVaryings() and store them in tfeedback_decl objects.
1017 *
1018 * If an error occurs, the error is reported through linker_error() and false
1019 * is returned.
1020 */
1021 static bool
1022 parse_tfeedback_decls(struct gl_context *ctx, struct gl_shader_program *prog,
1023 const void *mem_ctx, unsigned num_names,
1024 char **varying_names, tfeedback_decl *decls)
1025 {
1026 for (unsigned i = 0; i < num_names; ++i) {
1027 decls[i].init(ctx, mem_ctx, varying_names[i]);
1028
1029 if (!decls[i].is_varying())
1030 continue;
1031
1032 /* From GL_EXT_transform_feedback:
1033 * A program will fail to link if:
1034 *
1035 * * any two entries in the <varyings> array specify the same varying
1036 * variable;
1037 *
1038 * We interpret this to mean "any two entries in the <varyings> array
1039 * specify the same varying variable and array index", since transform
1040 * feedback of arrays would be useless otherwise.
1041 */
1042 for (unsigned j = 0; j < i; ++j) {
1043 if (!decls[j].is_varying())
1044 continue;
1045
1046 if (tfeedback_decl::is_same(decls[i], decls[j])) {
1047 linker_error(prog, "Transform feedback varying %s specified "
1048 "more than once.", varying_names[i]);
1049 return false;
1050 }
1051 }
1052 }
1053 return true;
1054 }
1055
1056
1057 static int
1058 cmp_xfb_offset(const void * x_generic, const void * y_generic)
1059 {
1060 tfeedback_decl *x = (tfeedback_decl *) x_generic;
1061 tfeedback_decl *y = (tfeedback_decl *) y_generic;
1062
1063 if (x->get_buffer() != y->get_buffer())
1064 return x->get_buffer() - y->get_buffer();
1065 return x->get_offset() - y->get_offset();
1066 }
1067
1068 /**
1069 * Store transform feedback location assignments into
1070 * prog->sh.LinkedTransformFeedback based on the data stored in
1071 * tfeedback_decls.
1072 *
1073 * If an error occurs, the error is reported through linker_error() and false
1074 * is returned.
1075 */
1076 static bool
1077 store_tfeedback_info(struct gl_context *ctx, struct gl_shader_program *prog,
1078 unsigned num_tfeedback_decls,
1079 tfeedback_decl *tfeedback_decls, bool has_xfb_qualifiers)
1080 {
1081 if (!prog->last_vert_prog)
1082 return true;
1083
1084 /* Make sure MaxTransformFeedbackBuffers is less than 32 so the bitmask for
1085 * tracking the number of buffers doesn't overflow.
1086 */
1087 assert(ctx->Const.MaxTransformFeedbackBuffers < 32);
1088
1089 bool separate_attribs_mode =
1090 prog->TransformFeedback.BufferMode == GL_SEPARATE_ATTRIBS;
1091
1092 struct gl_program *xfb_prog = prog->last_vert_prog;
1093 xfb_prog->sh.LinkedTransformFeedback =
1094 rzalloc(xfb_prog, struct gl_transform_feedback_info);
1095
1096 /* The xfb_offset qualifier does not have to be used in increasing order
1097 * however some drivers expect to receive the list of transform feedback
1098 * declarations in order so sort it now for convenience.
1099 */
1100 if (has_xfb_qualifiers)
1101 qsort(tfeedback_decls, num_tfeedback_decls, sizeof(*tfeedback_decls),
1102 cmp_xfb_offset);
1103
1104 xfb_prog->sh.LinkedTransformFeedback->Varyings =
1105 rzalloc_array(xfb_prog, struct gl_transform_feedback_varying_info,
1106 num_tfeedback_decls);
1107
1108 unsigned num_outputs = 0;
1109 for (unsigned i = 0; i < num_tfeedback_decls; ++i) {
1110 if (tfeedback_decls[i].is_varying_written())
1111 num_outputs += tfeedback_decls[i].get_num_outputs();
1112 }
1113
1114 xfb_prog->sh.LinkedTransformFeedback->Outputs =
1115 rzalloc_array(xfb_prog, struct gl_transform_feedback_output,
1116 num_outputs);
1117
1118 unsigned num_buffers = 0;
1119 unsigned buffers = 0;
1120
1121 if (!has_xfb_qualifiers && separate_attribs_mode) {
1122 /* GL_SEPARATE_ATTRIBS */
1123 for (unsigned i = 0; i < num_tfeedback_decls; ++i) {
1124 if (!tfeedback_decls[i].store(ctx, prog,
1125 xfb_prog->sh.LinkedTransformFeedback,
1126 num_buffers, num_buffers, num_outputs,
1127 NULL, has_xfb_qualifiers))
1128 return false;
1129
1130 buffers |= 1 << num_buffers;
1131 num_buffers++;
1132 }
1133 }
1134 else {
1135 /* GL_INVERLEAVED_ATTRIBS */
1136 int buffer_stream_id = -1;
1137 unsigned buffer =
1138 num_tfeedback_decls ? tfeedback_decls[0].get_buffer() : 0;
1139 bool explicit_stride[MAX_FEEDBACK_BUFFERS] = { false };
1140
1141 /* Apply any xfb_stride global qualifiers */
1142 if (has_xfb_qualifiers) {
1143 for (unsigned j = 0; j < MAX_FEEDBACK_BUFFERS; j++) {
1144 if (prog->TransformFeedback.BufferStride[j]) {
1145 buffers |= 1 << j;
1146 explicit_stride[j] = true;
1147 xfb_prog->sh.LinkedTransformFeedback->Buffers[j].Stride =
1148 prog->TransformFeedback.BufferStride[j] / 4;
1149 }
1150 }
1151 }
1152
1153 for (unsigned i = 0; i < num_tfeedback_decls; ++i) {
1154 if (has_xfb_qualifiers &&
1155 buffer != tfeedback_decls[i].get_buffer()) {
1156 /* we have moved to the next buffer so reset stream id */
1157 buffer_stream_id = -1;
1158 num_buffers++;
1159 }
1160
1161 if (tfeedback_decls[i].is_next_buffer_separator()) {
1162 if (!tfeedback_decls[i].store(ctx, prog,
1163 xfb_prog->sh.LinkedTransformFeedback,
1164 buffer, num_buffers, num_outputs,
1165 explicit_stride, has_xfb_qualifiers))
1166 return false;
1167 num_buffers++;
1168 buffer_stream_id = -1;
1169 continue;
1170 } else if (tfeedback_decls[i].is_varying()) {
1171 if (buffer_stream_id == -1) {
1172 /* First varying writing to this buffer: remember its stream */
1173 buffer_stream_id = (int) tfeedback_decls[i].get_stream_id();
1174 } else if (buffer_stream_id !=
1175 (int) tfeedback_decls[i].get_stream_id()) {
1176 /* Varying writes to the same buffer from a different stream */
1177 linker_error(prog,
1178 "Transform feedback can't capture varyings belonging "
1179 "to different vertex streams in a single buffer. "
1180 "Varying %s writes to buffer from stream %u, other "
1181 "varyings in the same buffer write from stream %u.",
1182 tfeedback_decls[i].name(),
1183 tfeedback_decls[i].get_stream_id(),
1184 buffer_stream_id);
1185 return false;
1186 }
1187 }
1188
1189 if (has_xfb_qualifiers) {
1190 buffer = tfeedback_decls[i].get_buffer();
1191 } else {
1192 buffer = num_buffers;
1193 }
1194 buffers |= 1 << buffer;
1195
1196 if (!tfeedback_decls[i].store(ctx, prog,
1197 xfb_prog->sh.LinkedTransformFeedback,
1198 buffer, num_buffers, num_outputs,
1199 explicit_stride, has_xfb_qualifiers))
1200 return false;
1201 }
1202 }
1203
1204 assert(xfb_prog->sh.LinkedTransformFeedback->NumOutputs == num_outputs);
1205
1206 xfb_prog->sh.LinkedTransformFeedback->ActiveBuffers = buffers;
1207 return true;
1208 }
1209
1210 namespace {
1211
1212 /**
1213 * Data structure recording the relationship between outputs of one shader
1214 * stage (the "producer") and inputs of another (the "consumer").
1215 */
1216 class varying_matches
1217 {
1218 public:
1219 varying_matches(bool disable_varying_packing, bool xfb_enabled,
1220 bool enhanced_layouts_enabled,
1221 gl_shader_stage producer_stage,
1222 gl_shader_stage consumer_stage);
1223 ~varying_matches();
1224 void record(ir_variable *producer_var, ir_variable *consumer_var);
1225 unsigned assign_locations(struct gl_shader_program *prog,
1226 uint8_t *components,
1227 uint64_t reserved_slots);
1228 void store_locations() const;
1229
1230 private:
1231 bool is_varying_packing_safe(const glsl_type *type,
1232 const ir_variable *var);
1233
1234 /**
1235 * If true, this driver disables varying packing, so all varyings need to
1236 * be aligned on slot boundaries, and take up a number of slots equal to
1237 * their number of matrix columns times their array size.
1238 *
1239 * Packing may also be disabled because our current packing method is not
1240 * safe in SSO or versions of OpenGL where interpolation qualifiers are not
1241 * guaranteed to match across stages.
1242 */
1243 const bool disable_varying_packing;
1244
1245 /**
1246 * If true, this driver has transform feedback enabled. The transform
1247 * feedback code requires at least some packing be done even when varying
1248 * packing is disabled, fortunately where transform feedback requires
1249 * packing it's safe to override the disabled setting. See
1250 * is_varying_packing_safe().
1251 */
1252 const bool xfb_enabled;
1253
1254 const bool enhanced_layouts_enabled;
1255
1256 /**
1257 * Enum representing the order in which varyings are packed within a
1258 * packing class.
1259 *
1260 * Currently we pack vec4's first, then vec2's, then scalar values, then
1261 * vec3's. This order ensures that the only vectors that are at risk of
1262 * having to be "double parked" (split between two adjacent varying slots)
1263 * are the vec3's.
1264 */
1265 enum packing_order_enum {
1266 PACKING_ORDER_VEC4,
1267 PACKING_ORDER_VEC2,
1268 PACKING_ORDER_SCALAR,
1269 PACKING_ORDER_VEC3,
1270 };
1271
1272 static unsigned compute_packing_class(const ir_variable *var);
1273 static packing_order_enum compute_packing_order(const ir_variable *var);
1274 static int match_comparator(const void *x_generic, const void *y_generic);
1275 static int xfb_comparator(const void *x_generic, const void *y_generic);
1276
1277 /**
1278 * Structure recording the relationship between a single producer output
1279 * and a single consumer input.
1280 */
1281 struct match {
1282 /**
1283 * Packing class for this varying, computed by compute_packing_class().
1284 */
1285 unsigned packing_class;
1286
1287 /**
1288 * Packing order for this varying, computed by compute_packing_order().
1289 */
1290 packing_order_enum packing_order;
1291 unsigned num_components;
1292
1293 /**
1294 * The output variable in the producer stage.
1295 */
1296 ir_variable *producer_var;
1297
1298 /**
1299 * The input variable in the consumer stage.
1300 */
1301 ir_variable *consumer_var;
1302
1303 /**
1304 * The location which has been assigned for this varying. This is
1305 * expressed in multiples of a float, with the first generic varying
1306 * (i.e. the one referred to by VARYING_SLOT_VAR0) represented by the
1307 * value 0.
1308 */
1309 unsigned generic_location;
1310 } *matches;
1311
1312 /**
1313 * The number of elements in the \c matches array that are currently in
1314 * use.
1315 */
1316 unsigned num_matches;
1317
1318 /**
1319 * The number of elements that were set aside for the \c matches array when
1320 * it was allocated.
1321 */
1322 unsigned matches_capacity;
1323
1324 gl_shader_stage producer_stage;
1325 gl_shader_stage consumer_stage;
1326 };
1327
1328 } /* anonymous namespace */
1329
1330 varying_matches::varying_matches(bool disable_varying_packing,
1331 bool xfb_enabled,
1332 bool enhanced_layouts_enabled,
1333 gl_shader_stage producer_stage,
1334 gl_shader_stage consumer_stage)
1335 : disable_varying_packing(disable_varying_packing),
1336 xfb_enabled(xfb_enabled),
1337 enhanced_layouts_enabled(enhanced_layouts_enabled),
1338 producer_stage(producer_stage),
1339 consumer_stage(consumer_stage)
1340 {
1341 /* Note: this initial capacity is rather arbitrarily chosen to be large
1342 * enough for many cases without wasting an unreasonable amount of space.
1343 * varying_matches::record() will resize the array if there are more than
1344 * this number of varyings.
1345 */
1346 this->matches_capacity = 8;
1347 this->matches = (match *)
1348 malloc(sizeof(*this->matches) * this->matches_capacity);
1349 this->num_matches = 0;
1350 }
1351
1352
1353 varying_matches::~varying_matches()
1354 {
1355 free(this->matches);
1356 }
1357
1358
1359 /**
1360 * Packing is always safe on individual arrays, structures, and matrices. It
1361 * is also safe if the varying is only used for transform feedback.
1362 */
1363 bool
1364 varying_matches::is_varying_packing_safe(const glsl_type *type,
1365 const ir_variable *var)
1366 {
1367 if (consumer_stage == MESA_SHADER_TESS_EVAL ||
1368 consumer_stage == MESA_SHADER_TESS_CTRL ||
1369 producer_stage == MESA_SHADER_TESS_CTRL)
1370 return false;
1371
1372 return xfb_enabled && (type->is_array() || type->is_record() ||
1373 type->is_matrix() || var->data.is_xfb_only);
1374 }
1375
1376
1377 /**
1378 * Record the given producer/consumer variable pair in the list of variables
1379 * that should later be assigned locations.
1380 *
1381 * It is permissible for \c consumer_var to be NULL (this happens if a
1382 * variable is output by the producer and consumed by transform feedback, but
1383 * not consumed by the consumer).
1384 *
1385 * If \c producer_var has already been paired up with a consumer_var, or
1386 * producer_var is part of fixed pipeline functionality (and hence already has
1387 * a location assigned), this function has no effect.
1388 *
1389 * Note: as a side effect this function may change the interpolation type of
1390 * \c producer_var, but only when the change couldn't possibly affect
1391 * rendering.
1392 */
1393 void
1394 varying_matches::record(ir_variable *producer_var, ir_variable *consumer_var)
1395 {
1396 assert(producer_var != NULL || consumer_var != NULL);
1397
1398 if ((producer_var && (!producer_var->data.is_unmatched_generic_inout ||
1399 producer_var->data.explicit_location)) ||
1400 (consumer_var && (!consumer_var->data.is_unmatched_generic_inout ||
1401 consumer_var->data.explicit_location))) {
1402 /* Either a location already exists for this variable (since it is part
1403 * of fixed functionality), or it has already been recorded as part of a
1404 * previous match.
1405 */
1406 return;
1407 }
1408
1409 bool needs_flat_qualifier = consumer_var == NULL &&
1410 (producer_var->type->contains_integer() ||
1411 producer_var->type->contains_double());
1412
1413 if (!disable_varying_packing &&
1414 (needs_flat_qualifier ||
1415 (consumer_stage != MESA_SHADER_NONE && consumer_stage != MESA_SHADER_FRAGMENT))) {
1416 /* Since this varying is not being consumed by the fragment shader, its
1417 * interpolation type varying cannot possibly affect rendering.
1418 * Also, this variable is non-flat and is (or contains) an integer
1419 * or a double.
1420 * If the consumer stage is unknown, don't modify the interpolation
1421 * type as it could affect rendering later with separate shaders.
1422 *
1423 * lower_packed_varyings requires all integer varyings to flat,
1424 * regardless of where they appear. We can trivially satisfy that
1425 * requirement by changing the interpolation type to flat here.
1426 */
1427 if (producer_var) {
1428 producer_var->data.centroid = false;
1429 producer_var->data.sample = false;
1430 producer_var->data.interpolation = INTERP_MODE_FLAT;
1431 }
1432
1433 if (consumer_var) {
1434 consumer_var->data.centroid = false;
1435 consumer_var->data.sample = false;
1436 consumer_var->data.interpolation = INTERP_MODE_FLAT;
1437 }
1438 }
1439
1440 if (this->num_matches == this->matches_capacity) {
1441 this->matches_capacity *= 2;
1442 this->matches = (match *)
1443 realloc(this->matches,
1444 sizeof(*this->matches) * this->matches_capacity);
1445 }
1446
1447 /* We must use the consumer to compute the packing class because in GL4.4+
1448 * there is no guarantee interpolation qualifiers will match across stages.
1449 *
1450 * From Section 4.5 (Interpolation Qualifiers) of the GLSL 4.30 spec:
1451 *
1452 * "The type and presence of interpolation qualifiers of variables with
1453 * the same name declared in all linked shaders for the same cross-stage
1454 * interface must match, otherwise the link command will fail.
1455 *
1456 * When comparing an output from one stage to an input of a subsequent
1457 * stage, the input and output don't match if their interpolation
1458 * qualifiers (or lack thereof) are not the same."
1459 *
1460 * This text was also in at least revison 7 of the 4.40 spec but is no
1461 * longer in revision 9 and not in the 4.50 spec.
1462 */
1463 const ir_variable *const var = (consumer_var != NULL)
1464 ? consumer_var : producer_var;
1465 const gl_shader_stage stage = (consumer_var != NULL)
1466 ? consumer_stage : producer_stage;
1467 const glsl_type *type = get_varying_type(var, stage);
1468
1469 if (producer_var && consumer_var &&
1470 consumer_var->data.must_be_shader_input) {
1471 producer_var->data.must_be_shader_input = 1;
1472 }
1473
1474 this->matches[this->num_matches].packing_class
1475 = this->compute_packing_class(var);
1476 this->matches[this->num_matches].packing_order
1477 = this->compute_packing_order(var);
1478 if ((this->disable_varying_packing && !is_varying_packing_safe(type, var)) ||
1479 var->data.must_be_shader_input) {
1480 unsigned slots = type->count_attribute_slots(false);
1481 this->matches[this->num_matches].num_components = slots * 4;
1482 } else {
1483 this->matches[this->num_matches].num_components
1484 = type->component_slots();
1485 }
1486
1487 this->matches[this->num_matches].producer_var = producer_var;
1488 this->matches[this->num_matches].consumer_var = consumer_var;
1489 this->num_matches++;
1490 if (producer_var)
1491 producer_var->data.is_unmatched_generic_inout = 0;
1492 if (consumer_var)
1493 consumer_var->data.is_unmatched_generic_inout = 0;
1494 }
1495
1496
1497 /**
1498 * Choose locations for all of the variable matches that were previously
1499 * passed to varying_matches::record().
1500 */
1501 unsigned
1502 varying_matches::assign_locations(struct gl_shader_program *prog,
1503 uint8_t *components,
1504 uint64_t reserved_slots)
1505 {
1506 /* If packing has been disabled then we cannot safely sort the varyings by
1507 * class as it may mean we are using a version of OpenGL where
1508 * interpolation qualifiers are not guaranteed to be matching across
1509 * shaders, sorting in this case could result in mismatching shader
1510 * interfaces.
1511 * When packing is disabled the sort orders varyings used by transform
1512 * feedback first, but also depends on *undefined behaviour* of qsort to
1513 * reverse the order of the varyings. See: xfb_comparator().
1514 */
1515 if (!this->disable_varying_packing) {
1516 /* Sort varying matches into an order that makes them easy to pack. */
1517 qsort(this->matches, this->num_matches, sizeof(*this->matches),
1518 &varying_matches::match_comparator);
1519 } else {
1520 /* Only sort varyings that are only used by transform feedback. */
1521 qsort(this->matches, this->num_matches, sizeof(*this->matches),
1522 &varying_matches::xfb_comparator);
1523 }
1524
1525 unsigned generic_location = 0;
1526 unsigned generic_patch_location = MAX_VARYING*4;
1527 bool previous_var_xfb_only = false;
1528
1529 for (unsigned i = 0; i < this->num_matches; i++) {
1530 unsigned *location = &generic_location;
1531
1532 const ir_variable *var;
1533 const glsl_type *type;
1534 bool is_vertex_input = false;
1535 if (matches[i].consumer_var) {
1536 var = matches[i].consumer_var;
1537 type = get_varying_type(var, consumer_stage);
1538 if (consumer_stage == MESA_SHADER_VERTEX)
1539 is_vertex_input = true;
1540 } else {
1541 var = matches[i].producer_var;
1542 type = get_varying_type(var, producer_stage);
1543 }
1544
1545 if (var->data.patch)
1546 location = &generic_patch_location;
1547
1548 /* Advance to the next slot if this varying has a different packing
1549 * class than the previous one, and we're not already on a slot
1550 * boundary.
1551 *
1552 * Also advance to the next slot if packing is disabled. This makes sure
1553 * we don't assign varyings the same locations which is possible
1554 * because we still pack individual arrays, records and matrices even
1555 * when packing is disabled. Note we don't advance to the next slot if
1556 * we can pack varyings together that are only used for transform
1557 * feedback.
1558 */
1559 if (var->data.must_be_shader_input ||
1560 (this->disable_varying_packing &&
1561 !(previous_var_xfb_only && var->data.is_xfb_only)) ||
1562 (i > 0 && this->matches[i - 1].packing_class
1563 != this->matches[i].packing_class )) {
1564 *location = ALIGN(*location, 4);
1565 }
1566
1567 previous_var_xfb_only = var->data.is_xfb_only;
1568
1569 /* The number of components taken up by this variable. For vertex shader
1570 * inputs, we use the number of slots * 4, as they have different
1571 * counting rules.
1572 */
1573 unsigned num_components = is_vertex_input ?
1574 type->count_attribute_slots(is_vertex_input) * 4 :
1575 this->matches[i].num_components;
1576
1577 /* The last slot for this variable, inclusive. */
1578 unsigned slot_end = *location + num_components - 1;
1579
1580 /* FIXME: We could be smarter in the below code and loop back over
1581 * trying to fill any locations that we skipped because we couldn't pack
1582 * the varying between an explicit location. For now just let the user
1583 * hit the linking error if we run out of room and suggest they use
1584 * explicit locations.
1585 */
1586 while (slot_end < MAX_VARYING * 4u) {
1587 const unsigned slots = (slot_end / 4u) - (*location / 4u) + 1;
1588 const uint64_t slot_mask = ((1ull << slots) - 1) << (*location / 4u);
1589
1590 assert(slots > 0);
1591 if (reserved_slots & slot_mask) {
1592 *location = ALIGN(*location + 1, 4);
1593 slot_end = *location + num_components - 1;
1594 continue;
1595 }
1596
1597 break;
1598 }
1599
1600 if (!var->data.patch && slot_end >= MAX_VARYING * 4u) {
1601 linker_error(prog, "insufficient contiguous locations available for "
1602 "%s it is possible an array or struct could not be "
1603 "packed between varyings with explicit locations. Try "
1604 "using an explicit location for arrays and structs.",
1605 var->name);
1606 }
1607
1608 if (slot_end < MAX_VARYINGS_INCL_PATCH * 4u) {
1609 for (unsigned j = *location / 4u; j < slot_end / 4u; j++)
1610 components[j] = 4;
1611 components[slot_end / 4u] = (slot_end & 3) + 1;
1612 }
1613
1614 this->matches[i].generic_location = *location;
1615
1616 *location = slot_end + 1;
1617 }
1618
1619 return (generic_location + 3) / 4;
1620 }
1621
1622
1623 /**
1624 * Update the producer and consumer shaders to reflect the locations
1625 * assignments that were made by varying_matches::assign_locations().
1626 */
1627 void
1628 varying_matches::store_locations() const
1629 {
1630 /* Check is location needs to be packed with lower_packed_varyings() or if
1631 * we can just use ARB_enhanced_layouts packing.
1632 */
1633 bool pack_loc[MAX_VARYINGS_INCL_PATCH] = { 0 };
1634 const glsl_type *loc_type[MAX_VARYINGS_INCL_PATCH][4] = { {NULL, NULL} };
1635
1636 for (unsigned i = 0; i < this->num_matches; i++) {
1637 ir_variable *producer_var = this->matches[i].producer_var;
1638 ir_variable *consumer_var = this->matches[i].consumer_var;
1639 unsigned generic_location = this->matches[i].generic_location;
1640 unsigned slot = generic_location / 4;
1641 unsigned offset = generic_location % 4;
1642
1643 if (producer_var) {
1644 producer_var->data.location = VARYING_SLOT_VAR0 + slot;
1645 producer_var->data.location_frac = offset;
1646 }
1647
1648 if (consumer_var) {
1649 assert(consumer_var->data.location == -1);
1650 consumer_var->data.location = VARYING_SLOT_VAR0 + slot;
1651 consumer_var->data.location_frac = offset;
1652 }
1653
1654 /* Find locations suitable for native packing via
1655 * ARB_enhanced_layouts.
1656 */
1657 if (producer_var && consumer_var) {
1658 if (enhanced_layouts_enabled) {
1659 const glsl_type *type =
1660 get_varying_type(producer_var, producer_stage);
1661 if (type->is_array() || type->is_matrix() || type->is_record() ||
1662 type->is_double()) {
1663 unsigned comp_slots = type->component_slots() + offset;
1664 unsigned slots = comp_slots / 4;
1665 if (comp_slots % 4)
1666 slots += 1;
1667
1668 for (unsigned j = 0; j < slots; j++) {
1669 pack_loc[slot + j] = true;
1670 }
1671 } else if (offset + type->vector_elements > 4) {
1672 pack_loc[slot] = true;
1673 pack_loc[slot + 1] = true;
1674 } else {
1675 loc_type[slot][offset] = type;
1676 }
1677 }
1678 }
1679 }
1680
1681 /* Attempt to use ARB_enhanced_layouts for more efficient packing if
1682 * suitable.
1683 */
1684 if (enhanced_layouts_enabled) {
1685 for (unsigned i = 0; i < this->num_matches; i++) {
1686 ir_variable *producer_var = this->matches[i].producer_var;
1687 ir_variable *consumer_var = this->matches[i].consumer_var;
1688 unsigned generic_location = this->matches[i].generic_location;
1689 unsigned slot = generic_location / 4;
1690
1691 if (pack_loc[slot] || !producer_var || !consumer_var)
1692 continue;
1693
1694 const glsl_type *type =
1695 get_varying_type(producer_var, producer_stage);
1696 bool type_match = true;
1697 for (unsigned j = 0; j < 4; j++) {
1698 if (loc_type[slot][j]) {
1699 if (type->base_type != loc_type[slot][j]->base_type)
1700 type_match = false;
1701 }
1702 }
1703
1704 if (type_match) {
1705 producer_var->data.explicit_location = 1;
1706 consumer_var->data.explicit_location = 1;
1707 producer_var->data.explicit_component = 1;
1708 consumer_var->data.explicit_component = 1;
1709 }
1710 }
1711 }
1712 }
1713
1714
1715 /**
1716 * Compute the "packing class" of the given varying. This is an unsigned
1717 * integer with the property that two variables in the same packing class can
1718 * be safely backed into the same vec4.
1719 */
1720 unsigned
1721 varying_matches::compute_packing_class(const ir_variable *var)
1722 {
1723 /* Without help from the back-end, there is no way to pack together
1724 * variables with different interpolation types, because
1725 * lower_packed_varyings must choose exactly one interpolation type for
1726 * each packed varying it creates.
1727 *
1728 * However, we can safely pack together floats, ints, and uints, because:
1729 *
1730 * - varyings of base type "int" and "uint" must use the "flat"
1731 * interpolation type, which can only occur in GLSL 1.30 and above.
1732 *
1733 * - On platforms that support GLSL 1.30 and above, lower_packed_varyings
1734 * can store flat floats as ints without losing any information (using
1735 * the ir_unop_bitcast_* opcodes).
1736 *
1737 * Therefore, the packing class depends only on the interpolation type.
1738 */
1739 unsigned packing_class = var->data.centroid | (var->data.sample << 1) |
1740 (var->data.patch << 2) |
1741 (var->data.must_be_shader_input << 3);
1742 packing_class *= 8;
1743 packing_class += var->is_interpolation_flat()
1744 ? unsigned(INTERP_MODE_FLAT) : var->data.interpolation;
1745 return packing_class;
1746 }
1747
1748
1749 /**
1750 * Compute the "packing order" of the given varying. This is a sort key we
1751 * use to determine when to attempt to pack the given varying relative to
1752 * other varyings in the same packing class.
1753 */
1754 varying_matches::packing_order_enum
1755 varying_matches::compute_packing_order(const ir_variable *var)
1756 {
1757 const glsl_type *element_type = var->type;
1758
1759 while (element_type->is_array()) {
1760 element_type = element_type->fields.array;
1761 }
1762
1763 switch (element_type->component_slots() % 4) {
1764 case 1: return PACKING_ORDER_SCALAR;
1765 case 2: return PACKING_ORDER_VEC2;
1766 case 3: return PACKING_ORDER_VEC3;
1767 case 0: return PACKING_ORDER_VEC4;
1768 default:
1769 assert(!"Unexpected value of vector_elements");
1770 return PACKING_ORDER_VEC4;
1771 }
1772 }
1773
1774
1775 /**
1776 * Comparison function passed to qsort() to sort varyings by packing_class and
1777 * then by packing_order.
1778 */
1779 int
1780 varying_matches::match_comparator(const void *x_generic, const void *y_generic)
1781 {
1782 const match *x = (const match *) x_generic;
1783 const match *y = (const match *) y_generic;
1784
1785 if (x->packing_class != y->packing_class)
1786 return x->packing_class - y->packing_class;
1787 return x->packing_order - y->packing_order;
1788 }
1789
1790
1791 /**
1792 * Comparison function passed to qsort() to sort varyings used only by
1793 * transform feedback when packing of other varyings is disabled.
1794 */
1795 int
1796 varying_matches::xfb_comparator(const void *x_generic, const void *y_generic)
1797 {
1798 const match *x = (const match *) x_generic;
1799
1800 if (x->producer_var != NULL && x->producer_var->data.is_xfb_only)
1801 return match_comparator(x_generic, y_generic);
1802
1803 /* FIXME: When the comparator returns 0 it means the elements being
1804 * compared are equivalent. However the qsort documentation says:
1805 *
1806 * "The order of equivalent elements is undefined."
1807 *
1808 * In practice the sort ends up reversing the order of the varyings which
1809 * means locations are also assigned in this reversed order and happens to
1810 * be what we want. This is also whats happening in
1811 * varying_matches::match_comparator().
1812 */
1813 return 0;
1814 }
1815
1816
1817 /**
1818 * Is the given variable a varying variable to be counted against the
1819 * limit in ctx->Const.MaxVarying?
1820 * This includes variables such as texcoords, colors and generic
1821 * varyings, but excludes variables such as gl_FrontFacing and gl_FragCoord.
1822 */
1823 static bool
1824 var_counts_against_varying_limit(gl_shader_stage stage, const ir_variable *var)
1825 {
1826 /* Only fragment shaders will take a varying variable as an input */
1827 if (stage == MESA_SHADER_FRAGMENT &&
1828 var->data.mode == ir_var_shader_in) {
1829 switch (var->data.location) {
1830 case VARYING_SLOT_POS:
1831 case VARYING_SLOT_FACE:
1832 case VARYING_SLOT_PNTC:
1833 return false;
1834 default:
1835 return true;
1836 }
1837 }
1838 return false;
1839 }
1840
1841
1842 /**
1843 * Visitor class that generates tfeedback_candidate structs describing all
1844 * possible targets of transform feedback.
1845 *
1846 * tfeedback_candidate structs are stored in the hash table
1847 * tfeedback_candidates, which is passed to the constructor. This hash table
1848 * maps varying names to instances of the tfeedback_candidate struct.
1849 */
1850 class tfeedback_candidate_generator : public program_resource_visitor
1851 {
1852 public:
1853 tfeedback_candidate_generator(void *mem_ctx,
1854 hash_table *tfeedback_candidates)
1855 : mem_ctx(mem_ctx),
1856 tfeedback_candidates(tfeedback_candidates),
1857 toplevel_var(NULL),
1858 varying_floats(0)
1859 {
1860 }
1861
1862 void process(ir_variable *var)
1863 {
1864 /* All named varying interface blocks should be flattened by now */
1865 assert(!var->is_interface_instance());
1866
1867 this->toplevel_var = var;
1868 this->varying_floats = 0;
1869 program_resource_visitor::process(var);
1870 }
1871
1872 private:
1873 virtual void visit_field(const glsl_type *type, const char *name,
1874 bool /* row_major */,
1875 const glsl_type * /* record_type */,
1876 const enum glsl_interface_packing,
1877 bool /* last_field */)
1878 {
1879 assert(!type->without_array()->is_record());
1880 assert(!type->without_array()->is_interface());
1881
1882 tfeedback_candidate *candidate
1883 = rzalloc(this->mem_ctx, tfeedback_candidate);
1884 candidate->toplevel_var = this->toplevel_var;
1885 candidate->type = type;
1886 candidate->offset = this->varying_floats;
1887 _mesa_hash_table_insert(this->tfeedback_candidates,
1888 ralloc_strdup(this->mem_ctx, name),
1889 candidate);
1890 this->varying_floats += type->component_slots();
1891 }
1892
1893 /**
1894 * Memory context used to allocate hash table keys and values.
1895 */
1896 void * const mem_ctx;
1897
1898 /**
1899 * Hash table in which tfeedback_candidate objects should be stored.
1900 */
1901 hash_table * const tfeedback_candidates;
1902
1903 /**
1904 * Pointer to the toplevel variable that is being traversed.
1905 */
1906 ir_variable *toplevel_var;
1907
1908 /**
1909 * Total number of varying floats that have been visited so far. This is
1910 * used to determine the offset to each varying within the toplevel
1911 * variable.
1912 */
1913 unsigned varying_floats;
1914 };
1915
1916
1917 namespace linker {
1918
1919 void
1920 populate_consumer_input_sets(void *mem_ctx, exec_list *ir,
1921 hash_table *consumer_inputs,
1922 hash_table *consumer_interface_inputs,
1923 ir_variable *consumer_inputs_with_locations[VARYING_SLOT_TESS_MAX])
1924 {
1925 memset(consumer_inputs_with_locations,
1926 0,
1927 sizeof(consumer_inputs_with_locations[0]) * VARYING_SLOT_TESS_MAX);
1928
1929 foreach_in_list(ir_instruction, node, ir) {
1930 ir_variable *const input_var = node->as_variable();
1931
1932 if (input_var != NULL && input_var->data.mode == ir_var_shader_in) {
1933 /* All interface blocks should have been lowered by this point */
1934 assert(!input_var->type->is_interface());
1935
1936 if (input_var->data.explicit_location) {
1937 /* assign_varying_locations only cares about finding the
1938 * ir_variable at the start of a contiguous location block.
1939 *
1940 * - For !producer, consumer_inputs_with_locations isn't used.
1941 *
1942 * - For !consumer, consumer_inputs_with_locations is empty.
1943 *
1944 * For consumer && producer, if you were trying to set some
1945 * ir_variable to the middle of a location block on the other side
1946 * of producer/consumer, cross_validate_outputs_to_inputs() should
1947 * be link-erroring due to either type mismatch or location
1948 * overlaps. If the variables do match up, then they've got a
1949 * matching data.location and you only looked at
1950 * consumer_inputs_with_locations[var->data.location], not any
1951 * following entries for the array/structure.
1952 */
1953 consumer_inputs_with_locations[input_var->data.location] =
1954 input_var;
1955 } else if (input_var->get_interface_type() != NULL) {
1956 char *const iface_field_name =
1957 ralloc_asprintf(mem_ctx, "%s.%s",
1958 input_var->get_interface_type()->without_array()->name,
1959 input_var->name);
1960 _mesa_hash_table_insert(consumer_interface_inputs,
1961 iface_field_name, input_var);
1962 } else {
1963 _mesa_hash_table_insert(consumer_inputs,
1964 ralloc_strdup(mem_ctx, input_var->name),
1965 input_var);
1966 }
1967 }
1968 }
1969 }
1970
1971 /**
1972 * Find a variable from the consumer that "matches" the specified variable
1973 *
1974 * This function only finds inputs with names that match. There is no
1975 * validation (here) that the types, etc. are compatible.
1976 */
1977 ir_variable *
1978 get_matching_input(void *mem_ctx,
1979 const ir_variable *output_var,
1980 hash_table *consumer_inputs,
1981 hash_table *consumer_interface_inputs,
1982 ir_variable *consumer_inputs_with_locations[VARYING_SLOT_TESS_MAX])
1983 {
1984 ir_variable *input_var;
1985
1986 if (output_var->data.explicit_location) {
1987 input_var = consumer_inputs_with_locations[output_var->data.location];
1988 } else if (output_var->get_interface_type() != NULL) {
1989 char *const iface_field_name =
1990 ralloc_asprintf(mem_ctx, "%s.%s",
1991 output_var->get_interface_type()->without_array()->name,
1992 output_var->name);
1993 hash_entry *entry = _mesa_hash_table_search(consumer_interface_inputs, iface_field_name);
1994 input_var = entry ? (ir_variable *) entry->data : NULL;
1995 } else {
1996 hash_entry *entry = _mesa_hash_table_search(consumer_inputs, output_var->name);
1997 input_var = entry ? (ir_variable *) entry->data : NULL;
1998 }
1999
2000 return (input_var == NULL || input_var->data.mode != ir_var_shader_in)
2001 ? NULL : input_var;
2002 }
2003
2004 }
2005
2006 static int
2007 io_variable_cmp(const void *_a, const void *_b)
2008 {
2009 const ir_variable *const a = *(const ir_variable **) _a;
2010 const ir_variable *const b = *(const ir_variable **) _b;
2011
2012 if (a->data.explicit_location && b->data.explicit_location)
2013 return b->data.location - a->data.location;
2014
2015 if (a->data.explicit_location && !b->data.explicit_location)
2016 return 1;
2017
2018 if (!a->data.explicit_location && b->data.explicit_location)
2019 return -1;
2020
2021 return -strcmp(a->name, b->name);
2022 }
2023
2024 /**
2025 * Sort the shader IO variables into canonical order
2026 */
2027 static void
2028 canonicalize_shader_io(exec_list *ir, enum ir_variable_mode io_mode)
2029 {
2030 ir_variable *var_table[MAX_PROGRAM_OUTPUTS * 4];
2031 unsigned num_variables = 0;
2032
2033 foreach_in_list(ir_instruction, node, ir) {
2034 ir_variable *const var = node->as_variable();
2035
2036 if (var == NULL || var->data.mode != io_mode)
2037 continue;
2038
2039 /* If we have already encountered more I/O variables that could
2040 * successfully link, bail.
2041 */
2042 if (num_variables == ARRAY_SIZE(var_table))
2043 return;
2044
2045 var_table[num_variables++] = var;
2046 }
2047
2048 if (num_variables == 0)
2049 return;
2050
2051 /* Sort the list in reverse order (io_variable_cmp handles this). Later
2052 * we're going to push the variables on to the IR list as a stack, so we
2053 * want the last variable (in canonical order) to be first in the list.
2054 */
2055 qsort(var_table, num_variables, sizeof(var_table[0]), io_variable_cmp);
2056
2057 /* Remove the variable from it's current location in the IR, and put it at
2058 * the front.
2059 */
2060 for (unsigned i = 0; i < num_variables; i++) {
2061 var_table[i]->remove();
2062 ir->push_head(var_table[i]);
2063 }
2064 }
2065
2066 /**
2067 * Generate a bitfield map of the explicit locations for shader varyings.
2068 *
2069 * Note: For Tessellation shaders we are sitting right on the limits of the
2070 * 64 bit map. Per-vertex and per-patch both have separate location domains
2071 * with a max of MAX_VARYING.
2072 */
2073 static uint64_t
2074 reserved_varying_slot(struct gl_linked_shader *stage,
2075 ir_variable_mode io_mode)
2076 {
2077 assert(io_mode == ir_var_shader_in || io_mode == ir_var_shader_out);
2078 /* Avoid an overflow of the returned value */
2079 assert(MAX_VARYINGS_INCL_PATCH <= 64);
2080
2081 uint64_t slots = 0;
2082 int var_slot;
2083
2084 if (!stage)
2085 return slots;
2086
2087 foreach_in_list(ir_instruction, node, stage->ir) {
2088 ir_variable *const var = node->as_variable();
2089
2090 if (var == NULL || var->data.mode != io_mode ||
2091 !var->data.explicit_location ||
2092 var->data.location < VARYING_SLOT_VAR0)
2093 continue;
2094
2095 var_slot = var->data.location - VARYING_SLOT_VAR0;
2096
2097 unsigned num_elements = get_varying_type(var, stage->Stage)
2098 ->count_attribute_slots(stage->Stage == MESA_SHADER_VERTEX);
2099 for (unsigned i = 0; i < num_elements; i++) {
2100 if (var_slot >= 0 && var_slot < MAX_VARYINGS_INCL_PATCH)
2101 slots |= UINT64_C(1) << var_slot;
2102 var_slot += 1;
2103 }
2104 }
2105
2106 return slots;
2107 }
2108
2109
2110 /**
2111 * Assign locations for all variables that are produced in one pipeline stage
2112 * (the "producer") and consumed in the next stage (the "consumer").
2113 *
2114 * Variables produced by the producer may also be consumed by transform
2115 * feedback.
2116 *
2117 * \param num_tfeedback_decls is the number of declarations indicating
2118 * variables that may be consumed by transform feedback.
2119 *
2120 * \param tfeedback_decls is a pointer to an array of tfeedback_decl objects
2121 * representing the result of parsing the strings passed to
2122 * glTransformFeedbackVaryings(). assign_location() will be called for
2123 * each of these objects that matches one of the outputs of the
2124 * producer.
2125 *
2126 * When num_tfeedback_decls is nonzero, it is permissible for the consumer to
2127 * be NULL. In this case, varying locations are assigned solely based on the
2128 * requirements of transform feedback.
2129 */
2130 static bool
2131 assign_varying_locations(struct gl_context *ctx,
2132 void *mem_ctx,
2133 struct gl_shader_program *prog,
2134 gl_linked_shader *producer,
2135 gl_linked_shader *consumer,
2136 unsigned num_tfeedback_decls,
2137 tfeedback_decl *tfeedback_decls,
2138 const uint64_t reserved_slots)
2139 {
2140 /* Tessellation shaders treat inputs and outputs as shared memory and can
2141 * access inputs and outputs of other invocations.
2142 * Therefore, they can't be lowered to temps easily (and definitely not
2143 * efficiently).
2144 */
2145 bool unpackable_tess =
2146 (consumer && consumer->Stage == MESA_SHADER_TESS_EVAL) ||
2147 (consumer && consumer->Stage == MESA_SHADER_TESS_CTRL) ||
2148 (producer && producer->Stage == MESA_SHADER_TESS_CTRL);
2149
2150 /* Transform feedback code assumes varying arrays are packed, so if the
2151 * driver has disabled varying packing, make sure to at least enable
2152 * packing required by transform feedback.
2153 */
2154 bool xfb_enabled =
2155 ctx->Extensions.EXT_transform_feedback && !unpackable_tess;
2156
2157 /* Disable packing on outward facing interfaces for SSO because in ES we
2158 * need to retain the unpacked varying information for draw time
2159 * validation.
2160 *
2161 * Packing is still enabled on individual arrays, structs, and matrices as
2162 * these are required by the transform feedback code and it is still safe
2163 * to do so. We also enable packing when a varying is only used for
2164 * transform feedback and its not a SSO.
2165 */
2166 bool disable_varying_packing =
2167 ctx->Const.DisableVaryingPacking || unpackable_tess;
2168 if (prog->SeparateShader && (producer == NULL || consumer == NULL))
2169 disable_varying_packing = true;
2170
2171 varying_matches matches(disable_varying_packing, xfb_enabled,
2172 ctx->Extensions.ARB_enhanced_layouts,
2173 producer ? producer->Stage : MESA_SHADER_NONE,
2174 consumer ? consumer->Stage : MESA_SHADER_NONE);
2175 hash_table *tfeedback_candidates =
2176 _mesa_hash_table_create(NULL, _mesa_key_hash_string,
2177 _mesa_key_string_equal);
2178 hash_table *consumer_inputs =
2179 _mesa_hash_table_create(NULL, _mesa_key_hash_string,
2180 _mesa_key_string_equal);
2181 hash_table *consumer_interface_inputs =
2182 _mesa_hash_table_create(NULL, _mesa_key_hash_string,
2183 _mesa_key_string_equal);
2184 ir_variable *consumer_inputs_with_locations[VARYING_SLOT_TESS_MAX] = {
2185 NULL,
2186 };
2187
2188 unsigned consumer_vertices = 0;
2189 if (consumer && consumer->Stage == MESA_SHADER_GEOMETRY)
2190 consumer_vertices = prog->Geom.VerticesIn;
2191
2192 /* Operate in a total of four passes.
2193 *
2194 * 1. Sort inputs / outputs into a canonical order. This is necessary so
2195 * that inputs / outputs of separable shaders will be assigned
2196 * predictable locations regardless of the order in which declarations
2197 * appeared in the shader source.
2198 *
2199 * 2. Assign locations for any matching inputs and outputs.
2200 *
2201 * 3. Mark output variables in the producer that do not have locations as
2202 * not being outputs. This lets the optimizer eliminate them.
2203 *
2204 * 4. Mark input variables in the consumer that do not have locations as
2205 * not being inputs. This lets the optimizer eliminate them.
2206 */
2207 if (consumer)
2208 canonicalize_shader_io(consumer->ir, ir_var_shader_in);
2209
2210 if (producer)
2211 canonicalize_shader_io(producer->ir, ir_var_shader_out);
2212
2213 if (consumer)
2214 linker::populate_consumer_input_sets(mem_ctx, consumer->ir,
2215 consumer_inputs,
2216 consumer_interface_inputs,
2217 consumer_inputs_with_locations);
2218
2219 if (producer) {
2220 foreach_in_list(ir_instruction, node, producer->ir) {
2221 ir_variable *const output_var = node->as_variable();
2222
2223 if (output_var == NULL || output_var->data.mode != ir_var_shader_out)
2224 continue;
2225
2226 /* Only geometry shaders can use non-zero streams */
2227 assert(output_var->data.stream == 0 ||
2228 (output_var->data.stream < MAX_VERTEX_STREAMS &&
2229 producer->Stage == MESA_SHADER_GEOMETRY));
2230
2231 if (num_tfeedback_decls > 0) {
2232 tfeedback_candidate_generator g(mem_ctx, tfeedback_candidates);
2233 g.process(output_var);
2234 }
2235
2236 ir_variable *const input_var =
2237 linker::get_matching_input(mem_ctx, output_var, consumer_inputs,
2238 consumer_interface_inputs,
2239 consumer_inputs_with_locations);
2240
2241 /* If a matching input variable was found, add this output (and the
2242 * input) to the set. If this is a separable program and there is no
2243 * consumer stage, add the output.
2244 *
2245 * Always add TCS outputs. They are shared by all invocations
2246 * within a patch and can be used as shared memory.
2247 */
2248 if (input_var || (prog->SeparateShader && consumer == NULL) ||
2249 producer->Stage == MESA_SHADER_TESS_CTRL) {
2250 matches.record(output_var, input_var);
2251 }
2252
2253 /* Only stream 0 outputs can be consumed in the next stage */
2254 if (input_var && output_var->data.stream != 0) {
2255 linker_error(prog, "output %s is assigned to stream=%d but "
2256 "is linked to an input, which requires stream=0",
2257 output_var->name, output_var->data.stream);
2258 return false;
2259 }
2260 }
2261 } else {
2262 /* If there's no producer stage, then this must be a separable program.
2263 * For example, we may have a program that has just a fragment shader.
2264 * Later this program will be used with some arbitrary vertex (or
2265 * geometry) shader program. This means that locations must be assigned
2266 * for all the inputs.
2267 */
2268 foreach_in_list(ir_instruction, node, consumer->ir) {
2269 ir_variable *const input_var = node->as_variable();
2270
2271 if (input_var == NULL || input_var->data.mode != ir_var_shader_in)
2272 continue;
2273
2274 matches.record(NULL, input_var);
2275 }
2276 }
2277
2278 _mesa_hash_table_destroy(consumer_inputs, NULL);
2279 _mesa_hash_table_destroy(consumer_interface_inputs, NULL);
2280
2281 for (unsigned i = 0; i < num_tfeedback_decls; ++i) {
2282 if (!tfeedback_decls[i].is_varying())
2283 continue;
2284
2285 const tfeedback_candidate *matched_candidate
2286 = tfeedback_decls[i].find_candidate(prog, tfeedback_candidates);
2287
2288 if (matched_candidate == NULL) {
2289 _mesa_hash_table_destroy(tfeedback_candidates, NULL);
2290 return false;
2291 }
2292
2293 if (matched_candidate->toplevel_var->data.is_unmatched_generic_inout) {
2294 matched_candidate->toplevel_var->data.is_xfb_only = 1;
2295 matches.record(matched_candidate->toplevel_var, NULL);
2296 }
2297 }
2298
2299 uint8_t components[MAX_VARYINGS_INCL_PATCH] = {0};
2300 const unsigned slots_used = matches.assign_locations(
2301 prog, components, reserved_slots);
2302 matches.store_locations();
2303
2304 for (unsigned i = 0; i < num_tfeedback_decls; ++i) {
2305 if (!tfeedback_decls[i].is_varying())
2306 continue;
2307
2308 if (!tfeedback_decls[i].assign_location(ctx, prog)) {
2309 _mesa_hash_table_destroy(tfeedback_candidates, NULL);
2310 return false;
2311 }
2312 }
2313 _mesa_hash_table_destroy(tfeedback_candidates, NULL);
2314
2315 if (consumer && producer) {
2316 foreach_in_list(ir_instruction, node, consumer->ir) {
2317 ir_variable *const var = node->as_variable();
2318
2319 if (var && var->data.mode == ir_var_shader_in &&
2320 var->data.is_unmatched_generic_inout) {
2321 if (!prog->IsES && prog->data->Version <= 120) {
2322 /* On page 25 (page 31 of the PDF) of the GLSL 1.20 spec:
2323 *
2324 * Only those varying variables used (i.e. read) in
2325 * the fragment shader executable must be written to
2326 * by the vertex shader executable; declaring
2327 * superfluous varying variables in a vertex shader is
2328 * permissible.
2329 *
2330 * We interpret this text as meaning that the VS must
2331 * write the variable for the FS to read it. See
2332 * "glsl1-varying read but not written" in piglit.
2333 */
2334 linker_error(prog, "%s shader varying %s not written "
2335 "by %s shader\n.",
2336 _mesa_shader_stage_to_string(consumer->Stage),
2337 var->name,
2338 _mesa_shader_stage_to_string(producer->Stage));
2339 } else {
2340 linker_warning(prog, "%s shader varying %s not written "
2341 "by %s shader\n.",
2342 _mesa_shader_stage_to_string(consumer->Stage),
2343 var->name,
2344 _mesa_shader_stage_to_string(producer->Stage));
2345 }
2346 }
2347 }
2348
2349 /* Now that validation is done its safe to remove unused varyings. As
2350 * we have both a producer and consumer its safe to remove unused
2351 * varyings even if the program is a SSO because the stages are being
2352 * linked together i.e. we have a multi-stage SSO.
2353 */
2354 remove_unused_shader_inputs_and_outputs(false, producer,
2355 ir_var_shader_out);
2356 remove_unused_shader_inputs_and_outputs(false, consumer,
2357 ir_var_shader_in);
2358 }
2359
2360 if (producer) {
2361 lower_packed_varyings(mem_ctx, slots_used, components, ir_var_shader_out,
2362 0, producer, disable_varying_packing,
2363 xfb_enabled);
2364 }
2365
2366 if (consumer) {
2367 lower_packed_varyings(mem_ctx, slots_used, components, ir_var_shader_in,
2368 consumer_vertices, consumer,
2369 disable_varying_packing, xfb_enabled);
2370 }
2371
2372 return true;
2373 }
2374
2375 bool
2376 check_against_output_limit(struct gl_context *ctx,
2377 struct gl_shader_program *prog,
2378 gl_linked_shader *producer,
2379 unsigned num_explicit_locations)
2380 {
2381 unsigned output_vectors = num_explicit_locations;
2382
2383 foreach_in_list(ir_instruction, node, producer->ir) {
2384 ir_variable *const var = node->as_variable();
2385
2386 if (var && !var->data.explicit_location &&
2387 var->data.mode == ir_var_shader_out &&
2388 var_counts_against_varying_limit(producer->Stage, var)) {
2389 /* outputs for fragment shader can't be doubles */
2390 output_vectors += var->type->count_attribute_slots(false);
2391 }
2392 }
2393
2394 assert(producer->Stage != MESA_SHADER_FRAGMENT);
2395 unsigned max_output_components =
2396 ctx->Const.Program[producer->Stage].MaxOutputComponents;
2397
2398 const unsigned output_components = output_vectors * 4;
2399 if (output_components > max_output_components) {
2400 if (ctx->API == API_OPENGLES2 || prog->IsES)
2401 linker_error(prog, "%s shader uses too many output vectors "
2402 "(%u > %u)\n",
2403 _mesa_shader_stage_to_string(producer->Stage),
2404 output_vectors,
2405 max_output_components / 4);
2406 else
2407 linker_error(prog, "%s shader uses too many output components "
2408 "(%u > %u)\n",
2409 _mesa_shader_stage_to_string(producer->Stage),
2410 output_components,
2411 max_output_components);
2412
2413 return false;
2414 }
2415
2416 return true;
2417 }
2418
2419 bool
2420 check_against_input_limit(struct gl_context *ctx,
2421 struct gl_shader_program *prog,
2422 gl_linked_shader *consumer,
2423 unsigned num_explicit_locations)
2424 {
2425 unsigned input_vectors = num_explicit_locations;
2426
2427 foreach_in_list(ir_instruction, node, consumer->ir) {
2428 ir_variable *const var = node->as_variable();
2429
2430 if (var && !var->data.explicit_location &&
2431 var->data.mode == ir_var_shader_in &&
2432 var_counts_against_varying_limit(consumer->Stage, var)) {
2433 /* vertex inputs aren't varying counted */
2434 input_vectors += var->type->count_attribute_slots(false);
2435 }
2436 }
2437
2438 assert(consumer->Stage != MESA_SHADER_VERTEX);
2439 unsigned max_input_components =
2440 ctx->Const.Program[consumer->Stage].MaxInputComponents;
2441
2442 const unsigned input_components = input_vectors * 4;
2443 if (input_components > max_input_components) {
2444 if (ctx->API == API_OPENGLES2 || prog->IsES)
2445 linker_error(prog, "%s shader uses too many input vectors "
2446 "(%u > %u)\n",
2447 _mesa_shader_stage_to_string(consumer->Stage),
2448 input_vectors,
2449 max_input_components / 4);
2450 else
2451 linker_error(prog, "%s shader uses too many input components "
2452 "(%u > %u)\n",
2453 _mesa_shader_stage_to_string(consumer->Stage),
2454 input_components,
2455 max_input_components);
2456
2457 return false;
2458 }
2459
2460 return true;
2461 }
2462
2463 bool
2464 link_varyings(struct gl_shader_program *prog, unsigned first, unsigned last,
2465 struct gl_context *ctx, void *mem_ctx)
2466 {
2467 bool has_xfb_qualifiers = false;
2468 unsigned num_tfeedback_decls = 0;
2469 char **varying_names = NULL;
2470 tfeedback_decl *tfeedback_decls = NULL;
2471
2472 /* From the ARB_enhanced_layouts spec:
2473 *
2474 * "If the shader used to record output variables for transform feedback
2475 * varyings uses the "xfb_buffer", "xfb_offset", or "xfb_stride" layout
2476 * qualifiers, the values specified by TransformFeedbackVaryings are
2477 * ignored, and the set of variables captured for transform feedback is
2478 * instead derived from the specified layout qualifiers."
2479 */
2480 for (int i = MESA_SHADER_FRAGMENT - 1; i >= 0; i--) {
2481 /* Find last stage before fragment shader */
2482 if (prog->_LinkedShaders[i]) {
2483 has_xfb_qualifiers =
2484 process_xfb_layout_qualifiers(mem_ctx, prog->_LinkedShaders[i],
2485 prog, &num_tfeedback_decls,
2486 &varying_names);
2487 break;
2488 }
2489 }
2490
2491 if (!has_xfb_qualifiers) {
2492 num_tfeedback_decls = prog->TransformFeedback.NumVarying;
2493 varying_names = prog->TransformFeedback.VaryingNames;
2494 }
2495
2496 if (num_tfeedback_decls != 0) {
2497 /* From GL_EXT_transform_feedback:
2498 * A program will fail to link if:
2499 *
2500 * * the <count> specified by TransformFeedbackVaryingsEXT is
2501 * non-zero, but the program object has no vertex or geometry
2502 * shader;
2503 */
2504 if (first >= MESA_SHADER_FRAGMENT) {
2505 linker_error(prog, "Transform feedback varyings specified, but "
2506 "no vertex, tessellation, or geometry shader is "
2507 "present.\n");
2508 return false;
2509 }
2510
2511 tfeedback_decls = rzalloc_array(mem_ctx, tfeedback_decl,
2512 num_tfeedback_decls);
2513 if (!parse_tfeedback_decls(ctx, prog, mem_ctx, num_tfeedback_decls,
2514 varying_names, tfeedback_decls))
2515 return false;
2516 }
2517
2518 /* If there is no fragment shader we need to set transform feedback.
2519 *
2520 * For SSO we also need to assign output locations. We assign them here
2521 * because we need to do it for both single stage programs and multi stage
2522 * programs.
2523 */
2524 if (last < MESA_SHADER_FRAGMENT &&
2525 (num_tfeedback_decls != 0 || prog->SeparateShader)) {
2526 const uint64_t reserved_out_slots =
2527 reserved_varying_slot(prog->_LinkedShaders[last], ir_var_shader_out);
2528 if (!assign_varying_locations(ctx, mem_ctx, prog,
2529 prog->_LinkedShaders[last], NULL,
2530 num_tfeedback_decls, tfeedback_decls,
2531 reserved_out_slots))
2532 return false;
2533 }
2534
2535 if (last <= MESA_SHADER_FRAGMENT) {
2536 /* Remove unused varyings from the first/last stage unless SSO */
2537 remove_unused_shader_inputs_and_outputs(prog->SeparateShader,
2538 prog->_LinkedShaders[first],
2539 ir_var_shader_in);
2540 remove_unused_shader_inputs_and_outputs(prog->SeparateShader,
2541 prog->_LinkedShaders[last],
2542 ir_var_shader_out);
2543
2544 /* If the program is made up of only a single stage */
2545 if (first == last) {
2546 gl_linked_shader *const sh = prog->_LinkedShaders[last];
2547
2548 do_dead_builtin_varyings(ctx, NULL, sh, 0, NULL);
2549 do_dead_builtin_varyings(ctx, sh, NULL, num_tfeedback_decls,
2550 tfeedback_decls);
2551
2552 if (prog->SeparateShader) {
2553 const uint64_t reserved_slots =
2554 reserved_varying_slot(sh, ir_var_shader_in);
2555
2556 /* Assign input locations for SSO, output locations are already
2557 * assigned.
2558 */
2559 if (!assign_varying_locations(ctx, mem_ctx, prog,
2560 NULL /* producer */,
2561 sh /* consumer */,
2562 0 /* num_tfeedback_decls */,
2563 NULL /* tfeedback_decls */,
2564 reserved_slots))
2565 return false;
2566 }
2567 } else {
2568 /* Linking the stages in the opposite order (from fragment to vertex)
2569 * ensures that inter-shader outputs written to in an earlier stage
2570 * are eliminated if they are (transitively) not used in a later
2571 * stage.
2572 */
2573 int next = last;
2574 for (int i = next - 1; i >= 0; i--) {
2575 if (prog->_LinkedShaders[i] == NULL && i != 0)
2576 continue;
2577
2578 gl_linked_shader *const sh_i = prog->_LinkedShaders[i];
2579 gl_linked_shader *const sh_next = prog->_LinkedShaders[next];
2580
2581 const uint64_t reserved_out_slots =
2582 reserved_varying_slot(sh_i, ir_var_shader_out);
2583 const uint64_t reserved_in_slots =
2584 reserved_varying_slot(sh_next, ir_var_shader_in);
2585
2586 do_dead_builtin_varyings(ctx, sh_i, sh_next,
2587 next == MESA_SHADER_FRAGMENT ? num_tfeedback_decls : 0,
2588 tfeedback_decls);
2589
2590 if (!assign_varying_locations(ctx, mem_ctx, prog, sh_i, sh_next,
2591 next == MESA_SHADER_FRAGMENT ? num_tfeedback_decls : 0,
2592 tfeedback_decls,
2593 reserved_out_slots | reserved_in_slots))
2594 return false;
2595
2596 /* This must be done after all dead varyings are eliminated. */
2597 if (sh_i != NULL) {
2598 unsigned slots_used = _mesa_bitcount_64(reserved_out_slots);
2599 if (!check_against_output_limit(ctx, prog, sh_i, slots_used)) {
2600 return false;
2601 }
2602 }
2603
2604 unsigned slots_used = _mesa_bitcount_64(reserved_in_slots);
2605 if (!check_against_input_limit(ctx, prog, sh_next, slots_used))
2606 return false;
2607
2608 next = i;
2609 }
2610 }
2611 }
2612
2613 if (!store_tfeedback_info(ctx, prog, num_tfeedback_decls, tfeedback_decls,
2614 has_xfb_qualifiers))
2615 return false;
2616
2617 return true;
2618 }