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/errors.h"
33 #include "main/consts_exts.h"
34 #include "main/shader_types.h"
35 #include "glsl_symbol_table.h"
36 #include "ir.h"
37 #include "linker.h"
38 #include "link_varyings.h"
39
40
41 /**
42 * Get the varying type stripped of the outermost array if we're processing
43 * a stage whose varyings are arrays indexed by a vertex number (such as
44 * geometry shader inputs).
45 */
46 static const glsl_type *
get_varying_type(const ir_variable * var,gl_shader_stage stage)47 get_varying_type(const ir_variable *var, gl_shader_stage stage)
48 {
49 const glsl_type *type = var->type;
50
51 if (!var->data.patch &&
52 ((var->data.mode == ir_var_shader_out &&
53 stage == MESA_SHADER_TESS_CTRL) ||
54 (var->data.mode == ir_var_shader_in &&
55 (stage == MESA_SHADER_TESS_CTRL || stage == MESA_SHADER_TESS_EVAL ||
56 stage == MESA_SHADER_GEOMETRY)))) {
57 assert(type->is_array());
58 type = type->fields.array;
59 }
60
61 return type;
62 }
63
64 /**
65 * Validate the types and qualifiers of an output from one stage against the
66 * matching input to another stage.
67 */
68 static void
cross_validate_types_and_qualifiers(const struct gl_constants * consts,struct gl_shader_program * prog,const ir_variable * input,const ir_variable * output,gl_shader_stage consumer_stage,gl_shader_stage producer_stage)69 cross_validate_types_and_qualifiers(const struct gl_constants *consts,
70 struct gl_shader_program *prog,
71 const ir_variable *input,
72 const ir_variable *output,
73 gl_shader_stage consumer_stage,
74 gl_shader_stage producer_stage)
75 {
76 /* Check that the types match between stages.
77 */
78 const glsl_type *type_to_match = input->type;
79
80 /* VS -> GS, VS -> TCS, VS -> TES, TES -> GS */
81 const bool extra_array_level = (producer_stage == MESA_SHADER_VERTEX &&
82 consumer_stage != MESA_SHADER_FRAGMENT) ||
83 consumer_stage == MESA_SHADER_GEOMETRY;
84 if (extra_array_level) {
85 assert(type_to_match->is_array());
86 type_to_match = type_to_match->fields.array;
87 }
88
89 if (type_to_match != output->type) {
90 if (output->type->is_struct()) {
91 /* Structures across shader stages can have different name
92 * and considered to match in type if and only if structure
93 * members match in name, type, qualification, and declaration
94 * order. The precision doesn’t need to match.
95 */
96 if (!output->type->record_compare(type_to_match,
97 false, /* match_name */
98 true, /* match_locations */
99 false /* match_precision */)) {
100 linker_error(prog,
101 "%s shader output `%s' declared as struct `%s', "
102 "doesn't match in type with %s shader input "
103 "declared as struct `%s'\n",
104 _mesa_shader_stage_to_string(producer_stage),
105 output->name,
106 output->type->name,
107 _mesa_shader_stage_to_string(consumer_stage),
108 input->type->name);
109 }
110 } else if (!output->type->is_array() || !is_gl_identifier(output->name)) {
111 /* There is a bit of a special case for gl_TexCoord. This
112 * built-in is unsized by default. Applications that variable
113 * access it must redeclare it with a size. There is some
114 * language in the GLSL spec that implies the fragment shader
115 * and vertex shader do not have to agree on this size. Other
116 * driver behave this way, and one or two applications seem to
117 * rely on it.
118 *
119 * Neither declaration needs to be modified here because the array
120 * sizes are fixed later when update_array_sizes is called.
121 *
122 * From page 48 (page 54 of the PDF) of the GLSL 1.10 spec:
123 *
124 * "Unlike user-defined varying variables, the built-in
125 * varying variables don't have a strict one-to-one
126 * correspondence between the vertex language and the
127 * fragment language."
128 */
129 linker_error(prog,
130 "%s shader output `%s' declared as type `%s', "
131 "but %s shader input declared as type `%s'\n",
132 _mesa_shader_stage_to_string(producer_stage),
133 output->name,
134 output->type->name,
135 _mesa_shader_stage_to_string(consumer_stage),
136 input->type->name);
137 return;
138 }
139 }
140
141 /* Check that all of the qualifiers match between stages.
142 */
143
144 /* According to the OpenGL and OpenGLES GLSL specs, the centroid qualifier
145 * should match until OpenGL 4.3 and OpenGLES 3.1. The OpenGLES 3.0
146 * conformance test suite does not verify that the qualifiers must match.
147 * The deqp test suite expects the opposite (OpenGLES 3.1) behavior for
148 * OpenGLES 3.0 drivers, so we relax the checking in all cases.
149 */
150 if (false /* always skip the centroid check */ &&
151 prog->data->Version < (prog->IsES ? 310 : 430) &&
152 input->data.centroid != output->data.centroid) {
153 linker_error(prog,
154 "%s shader output `%s' %s centroid qualifier, "
155 "but %s shader input %s centroid qualifier\n",
156 _mesa_shader_stage_to_string(producer_stage),
157 output->name,
158 (output->data.centroid) ? "has" : "lacks",
159 _mesa_shader_stage_to_string(consumer_stage),
160 (input->data.centroid) ? "has" : "lacks");
161 return;
162 }
163
164 if (input->data.sample != output->data.sample) {
165 linker_error(prog,
166 "%s shader output `%s' %s sample qualifier, "
167 "but %s shader input %s sample qualifier\n",
168 _mesa_shader_stage_to_string(producer_stage),
169 output->name,
170 (output->data.sample) ? "has" : "lacks",
171 _mesa_shader_stage_to_string(consumer_stage),
172 (input->data.sample) ? "has" : "lacks");
173 return;
174 }
175
176 if (input->data.patch != output->data.patch) {
177 linker_error(prog,
178 "%s shader output `%s' %s patch qualifier, "
179 "but %s shader input %s patch qualifier\n",
180 _mesa_shader_stage_to_string(producer_stage),
181 output->name,
182 (output->data.patch) ? "has" : "lacks",
183 _mesa_shader_stage_to_string(consumer_stage),
184 (input->data.patch) ? "has" : "lacks");
185 return;
186 }
187
188 /* The GLSL 4.20 and GLSL ES 3.00 specifications say:
189 *
190 * "As only outputs need be declared with invariant, an output from
191 * one shader stage will still match an input of a subsequent stage
192 * without the input being declared as invariant."
193 *
194 * while GLSL 4.10 says:
195 *
196 * "For variables leaving one shader and coming into another shader,
197 * the invariant keyword has to be used in both shaders, or a link
198 * error will result."
199 *
200 * and GLSL ES 1.00 section 4.6.4 "Invariance and Linking" says:
201 *
202 * "The invariance of varyings that are declared in both the vertex
203 * and fragment shaders must match."
204 */
205 if (input->data.explicit_invariant != output->data.explicit_invariant &&
206 prog->data->Version < (prog->IsES ? 300 : 420)) {
207 linker_error(prog,
208 "%s shader output `%s' %s invariant qualifier, "
209 "but %s shader input %s invariant qualifier\n",
210 _mesa_shader_stage_to_string(producer_stage),
211 output->name,
212 (output->data.explicit_invariant) ? "has" : "lacks",
213 _mesa_shader_stage_to_string(consumer_stage),
214 (input->data.explicit_invariant) ? "has" : "lacks");
215 return;
216 }
217
218 /* GLSL >= 4.40 removes text requiring interpolation qualifiers
219 * to match cross stage, they must only match within the same stage.
220 *
221 * From page 84 (page 90 of the PDF) of the GLSL 4.40 spec:
222 *
223 * "It is a link-time error if, within the same stage, the interpolation
224 * qualifiers of variables of the same name do not match.
225 *
226 * Section 4.3.9 (Interpolation) of the GLSL ES 3.00 spec says:
227 *
228 * "When no interpolation qualifier is present, smooth interpolation
229 * is used."
230 *
231 * So we match variables where one is smooth and the other has no explicit
232 * qualifier.
233 */
234 unsigned input_interpolation = input->data.interpolation;
235 unsigned output_interpolation = output->data.interpolation;
236 if (prog->IsES) {
237 if (input_interpolation == INTERP_MODE_NONE)
238 input_interpolation = INTERP_MODE_SMOOTH;
239 if (output_interpolation == INTERP_MODE_NONE)
240 output_interpolation = INTERP_MODE_SMOOTH;
241 }
242 if (input_interpolation != output_interpolation &&
243 prog->data->Version < 440) {
244 if (!consts->AllowGLSLCrossStageInterpolationMismatch) {
245 linker_error(prog,
246 "%s shader output `%s' specifies %s "
247 "interpolation qualifier, "
248 "but %s shader input specifies %s "
249 "interpolation qualifier\n",
250 _mesa_shader_stage_to_string(producer_stage),
251 output->name,
252 interpolation_string(output->data.interpolation),
253 _mesa_shader_stage_to_string(consumer_stage),
254 interpolation_string(input->data.interpolation));
255 return;
256 } else {
257 linker_warning(prog,
258 "%s shader output `%s' specifies %s "
259 "interpolation qualifier, "
260 "but %s shader input specifies %s "
261 "interpolation qualifier\n",
262 _mesa_shader_stage_to_string(producer_stage),
263 output->name,
264 interpolation_string(output->data.interpolation),
265 _mesa_shader_stage_to_string(consumer_stage),
266 interpolation_string(input->data.interpolation));
267 }
268 }
269 }
270
271 /**
272 * Validate front and back color outputs against single color input
273 */
274 static void
cross_validate_front_and_back_color(const struct gl_constants * consts,struct gl_shader_program * prog,const ir_variable * input,const ir_variable * front_color,const ir_variable * back_color,gl_shader_stage consumer_stage,gl_shader_stage producer_stage)275 cross_validate_front_and_back_color(const struct gl_constants *consts,
276 struct gl_shader_program *prog,
277 const ir_variable *input,
278 const ir_variable *front_color,
279 const ir_variable *back_color,
280 gl_shader_stage consumer_stage,
281 gl_shader_stage producer_stage)
282 {
283 if (front_color != NULL && front_color->data.assigned)
284 cross_validate_types_and_qualifiers(consts, prog, input, front_color,
285 consumer_stage, producer_stage);
286
287 if (back_color != NULL && back_color->data.assigned)
288 cross_validate_types_and_qualifiers(consts, prog, input, back_color,
289 consumer_stage, producer_stage);
290 }
291
292 static unsigned
compute_variable_location_slot(ir_variable * var,gl_shader_stage stage)293 compute_variable_location_slot(ir_variable *var, gl_shader_stage stage)
294 {
295 unsigned location_start = VARYING_SLOT_VAR0;
296
297 switch (stage) {
298 case MESA_SHADER_VERTEX:
299 if (var->data.mode == ir_var_shader_in)
300 location_start = VERT_ATTRIB_GENERIC0;
301 break;
302 case MESA_SHADER_TESS_CTRL:
303 case MESA_SHADER_TESS_EVAL:
304 if (var->data.patch)
305 location_start = VARYING_SLOT_PATCH0;
306 break;
307 case MESA_SHADER_FRAGMENT:
308 if (var->data.mode == ir_var_shader_out)
309 location_start = FRAG_RESULT_DATA0;
310 break;
311 default:
312 break;
313 }
314
315 return var->data.location - location_start;
316 }
317
318 struct explicit_location_info {
319 ir_variable *var;
320 bool base_type_is_integer;
321 unsigned base_type_bit_size;
322 unsigned interpolation;
323 bool centroid;
324 bool sample;
325 bool patch;
326 };
327
328 static bool
check_location_aliasing(struct explicit_location_info explicit_locations[][4],ir_variable * var,unsigned location,unsigned component,unsigned location_limit,const glsl_type * type,unsigned interpolation,bool centroid,bool sample,bool patch,gl_shader_program * prog,gl_shader_stage stage)329 check_location_aliasing(struct explicit_location_info explicit_locations[][4],
330 ir_variable *var,
331 unsigned location,
332 unsigned component,
333 unsigned location_limit,
334 const glsl_type *type,
335 unsigned interpolation,
336 bool centroid,
337 bool sample,
338 bool patch,
339 gl_shader_program *prog,
340 gl_shader_stage stage)
341 {
342 unsigned last_comp;
343 unsigned base_type_bit_size;
344 const glsl_type *type_without_array = type->without_array();
345 const bool base_type_is_integer =
346 glsl_base_type_is_integer(type_without_array->base_type);
347 const bool is_struct = type_without_array->is_struct();
348 if (is_struct) {
349 /* structs don't have a defined underlying base type so just treat all
350 * component slots as used and set the bit size to 0. If there is
351 * location aliasing, we'll fail anyway later.
352 */
353 last_comp = 4;
354 base_type_bit_size = 0;
355 } else {
356 unsigned dmul = type_without_array->is_64bit() ? 2 : 1;
357 last_comp = component + type_without_array->vector_elements * dmul;
358 base_type_bit_size =
359 glsl_base_type_get_bit_size(type_without_array->base_type);
360 }
361
362 while (location < location_limit) {
363 unsigned comp = 0;
364 while (comp < 4) {
365 struct explicit_location_info *info =
366 &explicit_locations[location][comp];
367
368 if (info->var) {
369 if (info->var->type->without_array()->is_struct() || is_struct) {
370 /* Structs cannot share location since they are incompatible
371 * with any other underlying numerical type.
372 */
373 linker_error(prog,
374 "%s shader has multiple %sputs sharing the "
375 "same location that don't have the same "
376 "underlying numerical type. Struct variable '%s', "
377 "location %u\n",
378 _mesa_shader_stage_to_string(stage),
379 var->data.mode == ir_var_shader_in ? "in" : "out",
380 is_struct ? var->name : info->var->name,
381 location);
382 return false;
383 } else if (comp >= component && comp < last_comp) {
384 /* Component aliasing is not allowed */
385 linker_error(prog,
386 "%s shader has multiple %sputs explicitly "
387 "assigned to location %d and component %d\n",
388 _mesa_shader_stage_to_string(stage),
389 var->data.mode == ir_var_shader_in ? "in" : "out",
390 location, comp);
391 return false;
392 } else {
393 /* From the OpenGL 4.60.5 spec, section 4.4.1 Input Layout
394 * Qualifiers, Page 67, (Location aliasing):
395 *
396 * " Further, when location aliasing, the aliases sharing the
397 * location must have the same underlying numerical type
398 * and bit width (floating-point or integer, 32-bit versus
399 * 64-bit, etc.) and the same auxiliary storage and
400 * interpolation qualification."
401 */
402
403 /* If the underlying numerical type isn't integer, implicitly
404 * it will be float or else we would have failed by now.
405 */
406 if (info->base_type_is_integer != base_type_is_integer) {
407 linker_error(prog,
408 "%s shader has multiple %sputs sharing the "
409 "same location that don't have the same "
410 "underlying numerical type. Location %u "
411 "component %u.\n",
412 _mesa_shader_stage_to_string(stage),
413 var->data.mode == ir_var_shader_in ?
414 "in" : "out", location, comp);
415 return false;
416 }
417
418 if (info->base_type_bit_size != base_type_bit_size) {
419 linker_error(prog,
420 "%s shader has multiple %sputs sharing the "
421 "same location that don't have the same "
422 "underlying numerical bit size. Location %u "
423 "component %u.\n",
424 _mesa_shader_stage_to_string(stage),
425 var->data.mode == ir_var_shader_in ?
426 "in" : "out", location, comp);
427 return false;
428 }
429
430 if (info->interpolation != interpolation) {
431 linker_error(prog,
432 "%s shader has multiple %sputs sharing the "
433 "same location that don't have the same "
434 "interpolation qualification. Location %u "
435 "component %u.\n",
436 _mesa_shader_stage_to_string(stage),
437 var->data.mode == ir_var_shader_in ?
438 "in" : "out", location, comp);
439 return false;
440 }
441
442 if (info->centroid != centroid ||
443 info->sample != sample ||
444 info->patch != patch) {
445 linker_error(prog,
446 "%s shader has multiple %sputs sharing the "
447 "same location that don't have the same "
448 "auxiliary storage qualification. Location %u "
449 "component %u.\n",
450 _mesa_shader_stage_to_string(stage),
451 var->data.mode == ir_var_shader_in ?
452 "in" : "out", location, comp);
453 return false;
454 }
455 }
456 } else if (comp >= component && comp < last_comp) {
457 info->var = var;
458 info->base_type_is_integer = base_type_is_integer;
459 info->base_type_bit_size = base_type_bit_size;
460 info->interpolation = interpolation;
461 info->centroid = centroid;
462 info->sample = sample;
463 info->patch = patch;
464 }
465
466 comp++;
467
468 /* We need to do some special handling for doubles as dvec3 and
469 * dvec4 consume two consecutive locations. We don't need to
470 * worry about components beginning at anything other than 0 as
471 * the spec does not allow this for dvec3 and dvec4.
472 */
473 if (comp == 4 && last_comp > 4) {
474 last_comp = last_comp - 4;
475 /* Bump location index and reset the component index */
476 location++;
477 comp = 0;
478 component = 0;
479 }
480 }
481
482 location++;
483 }
484
485 return true;
486 }
487
488 static bool
validate_explicit_variable_location(const struct gl_constants * consts,struct explicit_location_info explicit_locations[][4],ir_variable * var,gl_shader_program * prog,gl_linked_shader * sh)489 validate_explicit_variable_location(const struct gl_constants *consts,
490 struct explicit_location_info explicit_locations[][4],
491 ir_variable *var,
492 gl_shader_program *prog,
493 gl_linked_shader *sh)
494 {
495 const glsl_type *type = get_varying_type(var, sh->Stage);
496 unsigned num_elements = type->count_attribute_slots(false);
497 unsigned idx = compute_variable_location_slot(var, sh->Stage);
498 unsigned slot_limit = idx + num_elements;
499
500 /* Vertex shader inputs and fragment shader outputs are validated in
501 * assign_attribute_or_color_locations() so we should not attempt to
502 * validate them again here.
503 */
504 unsigned slot_max;
505 if (var->data.mode == ir_var_shader_out) {
506 assert(sh->Stage != MESA_SHADER_FRAGMENT);
507 slot_max =
508 consts->Program[sh->Stage].MaxOutputComponents / 4;
509 } else {
510 assert(var->data.mode == ir_var_shader_in);
511 assert(sh->Stage != MESA_SHADER_VERTEX);
512 slot_max =
513 consts->Program[sh->Stage].MaxInputComponents / 4;
514 }
515
516 if (slot_limit > slot_max) {
517 linker_error(prog,
518 "Invalid location %u in %s shader\n",
519 idx, _mesa_shader_stage_to_string(sh->Stage));
520 return false;
521 }
522
523 const glsl_type *type_without_array = type->without_array();
524 if (type_without_array->is_interface()) {
525 for (unsigned i = 0; i < type_without_array->length; i++) {
526 glsl_struct_field *field = &type_without_array->fields.structure[i];
527 unsigned field_location = field->location -
528 (field->patch ? VARYING_SLOT_PATCH0 : VARYING_SLOT_VAR0);
529 unsigned field_slots = field->type->count_attribute_slots(false);
530 if (!check_location_aliasing(explicit_locations, var,
531 field_location,
532 0,
533 field_location + field_slots,
534 field->type,
535 field->interpolation,
536 field->centroid,
537 field->sample,
538 field->patch,
539 prog, sh->Stage)) {
540 return false;
541 }
542 }
543 } else if (!check_location_aliasing(explicit_locations, var,
544 idx, var->data.location_frac,
545 slot_limit, type,
546 var->data.interpolation,
547 var->data.centroid,
548 var->data.sample,
549 var->data.patch,
550 prog, sh->Stage)) {
551 return false;
552 }
553
554 return true;
555 }
556
557 /**
558 * Validate explicit locations for the inputs to the first stage and the
559 * outputs of the last stage in a program, if those are not the VS and FS
560 * shaders.
561 */
562 void
validate_first_and_last_interface_explicit_locations(const struct gl_constants * consts,struct gl_shader_program * prog,gl_shader_stage first_stage,gl_shader_stage last_stage)563 validate_first_and_last_interface_explicit_locations(const struct gl_constants *consts,
564 struct gl_shader_program *prog,
565 gl_shader_stage first_stage,
566 gl_shader_stage last_stage)
567 {
568 /* VS inputs and FS outputs are validated in
569 * assign_attribute_or_color_locations()
570 */
571 bool validate_first_stage = first_stage != MESA_SHADER_VERTEX;
572 bool validate_last_stage = last_stage != MESA_SHADER_FRAGMENT;
573 if (!validate_first_stage && !validate_last_stage)
574 return;
575
576 struct explicit_location_info explicit_locations[MAX_VARYING][4];
577
578 gl_shader_stage stages[2] = { first_stage, last_stage };
579 bool validate_stage[2] = { validate_first_stage, validate_last_stage };
580 ir_variable_mode var_direction[2] = { ir_var_shader_in, ir_var_shader_out };
581
582 for (unsigned i = 0; i < 2; i++) {
583 if (!validate_stage[i])
584 continue;
585
586 gl_shader_stage stage = stages[i];
587
588 gl_linked_shader *sh = prog->_LinkedShaders[stage];
589 assert(sh);
590
591 memset(explicit_locations, 0, sizeof(explicit_locations));
592
593 foreach_in_list(ir_instruction, node, sh->ir) {
594 ir_variable *const var = node->as_variable();
595
596 if (var == NULL ||
597 !var->data.explicit_location ||
598 var->data.location < VARYING_SLOT_VAR0 ||
599 var->data.mode != var_direction[i])
600 continue;
601
602 if (!validate_explicit_variable_location(
603 consts, explicit_locations, var, prog, sh)) {
604 return;
605 }
606 }
607 }
608 }
609
610 /**
611 * Check if we should force input / output matching between shader
612 * interfaces.
613 *
614 * Section 4.3.4 (Inputs) of the GLSL 4.10 specifications say:
615 *
616 * "Only the input variables that are actually read need to be
617 * written by the previous stage; it is allowed to have
618 * superfluous declarations of input variables."
619 *
620 * However it's not defined anywhere as to how we should handle
621 * inputs that are not written in the previous stage and it's not
622 * clear what "actually read" means.
623 *
624 * The GLSL 4.20 spec however is much clearer:
625 *
626 * "Only the input variables that are statically read need to
627 * be written by the previous stage; it is allowed to have
628 * superfluous declarations of input variables."
629 *
630 * It also has a table that states it is an error to statically
631 * read an input that is not defined in the previous stage. While
632 * it is not an error to not statically write to the output (it
633 * just needs to be defined to not be an error).
634 *
635 * The text in the GLSL 4.20 spec was an attempt to clarify the
636 * previous spec iterations. However given the difference in spec
637 * and that some applications seem to depend on not erroring when
638 * the input is not actually read in control flow we only apply
639 * this rule to GLSL 4.20 and higher. GLSL 4.10 shaders have been
640 * seen in the wild that depend on the less strict interpretation.
641 */
642 static bool
static_input_output_matching(struct gl_shader_program * prog)643 static_input_output_matching(struct gl_shader_program *prog)
644 {
645 return prog->data->Version >= (prog->IsES ? 0 : 420);
646 }
647
648 /**
649 * Validate that outputs from one stage match inputs of another
650 */
651 void
cross_validate_outputs_to_inputs(const struct gl_constants * consts,struct gl_shader_program * prog,gl_linked_shader * producer,gl_linked_shader * consumer)652 cross_validate_outputs_to_inputs(const struct gl_constants *consts,
653 struct gl_shader_program *prog,
654 gl_linked_shader *producer,
655 gl_linked_shader *consumer)
656 {
657 glsl_symbol_table parameters;
658 struct explicit_location_info output_explicit_locations[MAX_VARYING][4] = {};
659 struct explicit_location_info input_explicit_locations[MAX_VARYING][4] = {};
660
661 /* Find all shader outputs in the "producer" stage.
662 */
663 foreach_in_list(ir_instruction, node, producer->ir) {
664 ir_variable *const var = node->as_variable();
665
666 if (var == NULL || var->data.mode != ir_var_shader_out)
667 continue;
668
669 if (!var->data.explicit_location
670 || var->data.location < VARYING_SLOT_VAR0)
671 parameters.add_variable(var);
672 else {
673 /* User-defined varyings with explicit locations are handled
674 * differently because they do not need to have matching names.
675 */
676 if (!validate_explicit_variable_location(consts,
677 output_explicit_locations,
678 var, prog, producer)) {
679 return;
680 }
681 }
682 }
683
684
685 /* Find all shader inputs in the "consumer" stage. Any variables that have
686 * matching outputs already in the symbol table must have the same type and
687 * qualifiers.
688 *
689 * Exception: if the consumer is the geometry shader, then the inputs
690 * should be arrays and the type of the array element should match the type
691 * of the corresponding producer output.
692 */
693 foreach_in_list(ir_instruction, node, consumer->ir) {
694 ir_variable *const input = node->as_variable();
695
696 if (input == NULL || input->data.mode != ir_var_shader_in)
697 continue;
698
699 if (strcmp(input->name, "gl_Color") == 0 && input->data.used) {
700 const ir_variable *const front_color =
701 parameters.get_variable("gl_FrontColor");
702
703 const ir_variable *const back_color =
704 parameters.get_variable("gl_BackColor");
705
706 cross_validate_front_and_back_color(consts, prog, input,
707 front_color, back_color,
708 consumer->Stage, producer->Stage);
709 } else if (strcmp(input->name, "gl_SecondaryColor") == 0 && input->data.used) {
710 const ir_variable *const front_color =
711 parameters.get_variable("gl_FrontSecondaryColor");
712
713 const ir_variable *const back_color =
714 parameters.get_variable("gl_BackSecondaryColor");
715
716 cross_validate_front_and_back_color(consts, prog, input,
717 front_color, back_color,
718 consumer->Stage, producer->Stage);
719 } else {
720 /* The rules for connecting inputs and outputs change in the presence
721 * of explicit locations. In this case, we no longer care about the
722 * names of the variables. Instead, we care only about the
723 * explicitly assigned location.
724 */
725 ir_variable *output = NULL;
726 if (input->data.explicit_location
727 && input->data.location >= VARYING_SLOT_VAR0) {
728
729 const glsl_type *type = get_varying_type(input, consumer->Stage);
730 unsigned num_elements = type->count_attribute_slots(false);
731 unsigned idx =
732 compute_variable_location_slot(input, consumer->Stage);
733 unsigned slot_limit = idx + num_elements;
734
735 if (!validate_explicit_variable_location(consts,
736 input_explicit_locations,
737 input, prog, consumer)) {
738 return;
739 }
740
741 while (idx < slot_limit) {
742 if (idx >= MAX_VARYING) {
743 linker_error(prog,
744 "Invalid location %u in %s shader\n", idx,
745 _mesa_shader_stage_to_string(consumer->Stage));
746 return;
747 }
748
749 output = output_explicit_locations[idx][input->data.location_frac].var;
750
751 if (output == NULL) {
752 /* A linker failure should only happen when there is no
753 * output declaration and there is Static Use of the
754 * declared input.
755 */
756 if (input->data.used && static_input_output_matching(prog)) {
757 linker_error(prog,
758 "%s shader input `%s' with explicit location "
759 "has no matching output\n",
760 _mesa_shader_stage_to_string(consumer->Stage),
761 input->name);
762 break;
763 }
764 } else if (input->data.location != output->data.location) {
765 linker_error(prog,
766 "%s shader input `%s' with explicit location "
767 "has no matching output\n",
768 _mesa_shader_stage_to_string(consumer->Stage),
769 input->name);
770 break;
771 }
772 idx++;
773 }
774 } else {
775 output = parameters.get_variable(input->name);
776 }
777
778 if (output != NULL) {
779 /* Interface blocks have their own validation elsewhere so don't
780 * try validating them here.
781 */
782 if (!(input->get_interface_type() &&
783 output->get_interface_type()))
784 cross_validate_types_and_qualifiers(consts, prog, input, output,
785 consumer->Stage,
786 producer->Stage);
787 } else {
788 /* Check for input vars with unmatched output vars in prev stage
789 * taking into account that interface blocks could have a matching
790 * output but with different name, so we ignore them.
791 */
792 assert(!input->data.assigned);
793 if (input->data.used && !input->get_interface_type() &&
794 !input->data.explicit_location &&
795 static_input_output_matching(prog))
796 linker_error(prog,
797 "%s shader input `%s' "
798 "has no matching output in the previous stage\n",
799 _mesa_shader_stage_to_string(consumer->Stage),
800 input->name);
801 }
802 }
803 }
804 }
805