2 * Copyright © 2010 Intel Corporation
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:
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
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.
24 #include "glsl_types.h"
28 type_compare(const glsl_type
*a
, const glsl_type
*b
)
30 /* If the types are the same, they trivially match.
35 switch (a
->base_type
) {
39 /* There is no implicit conversion to or from integer types or bool.
41 if ((a
->is_integer() != b
->is_integer())
42 || (a
->is_boolean() != b
->is_boolean()))
48 if ((a
->vector_elements
!= b
->vector_elements
)
49 || (a
->matrix_columns
!= b
->matrix_columns
))
54 case GLSL_TYPE_SAMPLER
:
55 case GLSL_TYPE_STRUCT
:
56 /* Samplers and structures must match exactly.
61 if ((b
->base_type
!= GLSL_TYPE_ARRAY
)
62 || (a
->length
!= b
->length
))
65 /* From GLSL 1.50 spec, page 27 (page 33 of the PDF):
66 * "There are no implicit array or structure conversions."
68 * If the comparison of the array element types detects that a conversion
69 * would be required, the array types do not match.
71 return (type_compare(a
->fields
.array
, b
->fields
.array
) == 0) ? 0 : -1;
76 /* These are all error conditions. It is invalid for a parameter to
77 * a function to be declared as error, void, or a function.
82 /* This point should be unreachable.
89 * \brief Check if two parameter lists match.
91 * \param list_a Parameters of the function definition.
92 * \param list_b Actual parameters passed to the function.
93 * \return If an exact match, return 0.
94 * If an inexact match requiring implicit conversion, return 1.
95 * If not a match, return -1.
96 * \see matching_signature()
99 parameter_lists_match(const exec_list
*list_a
, const exec_list
*list_b
)
101 const exec_node
*node_a
= list_a
->head
;
102 const exec_node
*node_b
= list_b
->head
;
104 /* This is set to true if there is an inexact match requiring an implicit
106 bool inexact_match
= false;
109 ; !node_a
->is_tail_sentinel()
110 ; node_a
= node_a
->next
, node_b
= node_b
->next
) {
111 /* If all of the parameters from the other parameter list have been
112 * exhausted, the lists have different length and, by definition,
115 if (node_b
->is_tail_sentinel())
119 const ir_variable
*const param
= (ir_variable
*) node_a
;
120 const ir_instruction
*const actual
= (ir_instruction
*) node_b
;
122 if (param
->type
== actual
->type
)
125 /* Try to find an implicit conversion from actual to param. */
126 inexact_match
= true;
127 switch ((enum ir_variable_mode
)(param
->mode
)) {
130 case ir_var_temporary
:
131 /* These are all error conditions. It is invalid for a parameter to
132 * a function to be declared as auto (not in, out, or inout) or
138 case ir_var_const_in
:
140 if (!actual
->type
->can_implicitly_convert_to(param
->type
))
145 if (!param
->type
->can_implicitly_convert_to(actual
->type
))
150 /* Since there are no bi-directional automatic conversions (e.g.,
151 * there is int -> float but no float -> int), inout parameters must
162 /* If all of the parameters from the other parameter list have been
163 * exhausted, the lists have different length and, by definition, do not
166 if (!node_b
->is_tail_sentinel())
176 ir_function_signature
*
177 ir_function::matching_signature(const exec_list
*actual_parameters
)
179 ir_function_signature
*match
= NULL
;
180 bool multiple_inexact_matches
= false;
182 /* From page 42 (page 49 of the PDF) of the GLSL 1.20 spec:
184 * "If an exact match is found, the other signatures are ignored, and
185 * the exact match is used. Otherwise, if no exact match is found, then
186 * the implicit conversions in Section 4.1.10 "Implicit Conversions" will
187 * be applied to the calling arguments if this can make their types match
188 * a signature. In this case, it is a semantic error if there are
189 * multiple ways to apply these conversions to the actual arguments of a
190 * call such that the call can be made to match multiple signatures."
192 foreach_iter(exec_list_iterator
, iter
, signatures
) {
193 ir_function_signature
*const sig
=
194 (ir_function_signature
*) iter
.get();
196 const int score
= parameter_lists_match(& sig
->parameters
,
199 /* If we found an exact match, simply return it */
207 multiple_inexact_matches
= true;
211 /* There is no exact match (we would have returned it by now). If there
212 * are multiple inexact matches, the call is ambiguous, which is an error.
214 * FINISHME: Report a decent error. Returning NULL will likely result in
215 * FINISHME: a "no matching signature" error; it should report that the
216 * FINISHME: call is ambiguous. But reporting errors from here is hard.
218 if (multiple_inexact_matches
)
226 parameter_lists_match_exact(const exec_list
*list_a
, const exec_list
*list_b
)
228 const exec_node
*node_a
= list_a
->head
;
229 const exec_node
*node_b
= list_b
->head
;
232 ; !node_a
->is_tail_sentinel() && !node_b
->is_tail_sentinel()
233 ; node_a
= node_a
->next
, node_b
= node_b
->next
) {
234 ir_variable
*a
= (ir_variable
*) node_a
;
235 ir_variable
*b
= (ir_variable
*) node_b
;
237 /* If the types of the parameters do not match, the parameters lists
240 if (a
->type
!= b
->type
)
244 /* Unless both lists are exhausted, they differ in length and, by
245 * definition, do not match.
247 return (node_a
->is_tail_sentinel() == node_b
->is_tail_sentinel());
250 ir_function_signature
*
251 ir_function::exact_matching_signature(const exec_list
*actual_parameters
)
253 foreach_iter(exec_list_iterator
, iter
, signatures
) {
254 ir_function_signature
*const sig
=
255 (ir_function_signature
*) iter
.get();
257 if (parameter_lists_match_exact(&sig
->parameters
, actual_parameters
))