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"
26 #include "glsl_parser_extras.h"
27 #include "main/errors.h"
30 PARAMETER_LIST_NO_MATCH
,
31 PARAMETER_LIST_EXACT_MATCH
,
32 PARAMETER_LIST_INEXACT_MATCH
/*< Match requires implicit conversion. */
33 } parameter_list_match_t
;
36 * \brief Check if two parameter lists match.
38 * \param list_a Parameters of the function definition.
39 * \param list_b Actual parameters passed to the function.
40 * \see matching_signature()
42 static parameter_list_match_t
43 parameter_lists_match(_mesa_glsl_parse_state
*state
,
44 const exec_list
*list_a
, const exec_list
*list_b
)
46 const exec_node
*node_a
= list_a
->head
;
47 const exec_node
*node_b
= list_b
->head
;
49 /* This is set to true if there is an inexact match requiring an implicit
51 bool inexact_match
= false;
54 ; !node_a
->is_tail_sentinel()
55 ; node_a
= node_a
->next
, node_b
= node_b
->next
) {
56 /* If all of the parameters from the other parameter list have been
57 * exhausted, the lists have different length and, by definition,
60 if (node_b
->is_tail_sentinel())
61 return PARAMETER_LIST_NO_MATCH
;
64 const ir_variable
*const param
= (ir_variable
*) node_a
;
65 const ir_rvalue
*const actual
= (ir_rvalue
*) node_b
;
67 if (param
->type
== actual
->type
)
70 /* Try to find an implicit conversion from actual to param. */
72 switch ((enum ir_variable_mode
)(param
->data
.mode
)) {
75 case ir_var_shader_storage
:
76 case ir_var_temporary
:
77 /* These are all error conditions. It is invalid for a parameter to
78 * a function to be declared as auto (not in, out, or inout) or
82 return PARAMETER_LIST_NO_MATCH
;
85 case ir_var_function_in
:
86 if (!actual
->type
->can_implicitly_convert_to(param
->type
, state
))
87 return PARAMETER_LIST_NO_MATCH
;
90 case ir_var_function_out
:
91 if (!param
->type
->can_implicitly_convert_to(actual
->type
, state
))
92 return PARAMETER_LIST_NO_MATCH
;
95 case ir_var_function_inout
:
96 /* Since there are no bi-directional automatic conversions (e.g.,
97 * there is int -> float but no float -> int), inout parameters must
100 return PARAMETER_LIST_NO_MATCH
;
104 return PARAMETER_LIST_NO_MATCH
;
108 /* If all of the parameters from the other parameter list have been
109 * exhausted, the lists have different length and, by definition, do not
112 if (!node_b
->is_tail_sentinel())
113 return PARAMETER_LIST_NO_MATCH
;
116 return PARAMETER_LIST_INEXACT_MATCH
;
118 return PARAMETER_LIST_EXACT_MATCH
;
122 /* Classes of parameter match, sorted (mostly) best matches first.
123 * See is_better_parameter_match() below for the exceptions.
126 PARAMETER_EXACT_MATCH
,
127 PARAMETER_FLOAT_TO_DOUBLE
,
128 PARAMETER_INT_TO_FLOAT
,
129 PARAMETER_INT_TO_DOUBLE
,
130 PARAMETER_OTHER_CONVERSION
,
134 static parameter_match_t
135 get_parameter_match_type(const ir_variable
*param
,
136 const ir_rvalue
*actual
)
138 const glsl_type
*from_type
;
139 const glsl_type
*to_type
;
141 if (param
->data
.mode
== ir_var_function_out
) {
142 from_type
= param
->type
;
143 to_type
= actual
->type
;
145 from_type
= actual
->type
;
146 to_type
= param
->type
;
149 if (from_type
== to_type
)
150 return PARAMETER_EXACT_MATCH
;
152 if (to_type
->base_type
== GLSL_TYPE_DOUBLE
) {
153 if (from_type
->base_type
== GLSL_TYPE_FLOAT
)
154 return PARAMETER_FLOAT_TO_DOUBLE
;
155 return PARAMETER_INT_TO_DOUBLE
;
158 if (to_type
->base_type
== GLSL_TYPE_FLOAT
)
159 return PARAMETER_INT_TO_FLOAT
;
161 /* int -> uint and any other oddball conversions */
162 return PARAMETER_OTHER_CONVERSION
;
167 is_better_parameter_match(parameter_match_t a_match
,
168 parameter_match_t b_match
)
170 /* From section 6.1 of the GLSL 4.00 spec (and the ARB_gpu_shader5 spec):
172 * 1. An exact match is better than a match involving any implicit
175 * 2. A match involving an implicit conversion from float to double
176 * is better than match involving any other implicit conversion.
178 * [XXX: Not in GLSL 4.0: Only in ARB_gpu_shader5:
179 * 3. A match involving an implicit conversion from either int or uint
180 * to float is better than a match involving an implicit conversion
181 * from either int or uint to double.]
183 * If none of the rules above apply to a particular pair of conversions,
184 * neither conversion is considered better than the other.
188 * Notably, the int->uint conversion is *not* considered to be better
189 * or worse than int/uint->float or int/uint->double.
192 if (a_match
>= PARAMETER_INT_TO_FLOAT
&& b_match
== PARAMETER_OTHER_CONVERSION
)
195 return a_match
< b_match
;
200 is_best_inexact_overload(const exec_list
*actual_parameters
,
201 ir_function_signature
**matches
,
203 ir_function_signature
*sig
)
205 /* From section 6.1 of the GLSL 4.00 spec (and the ARB_gpu_shader5 spec):
207 * "A function definition A is considered a better
208 * match than function definition B if:
210 * * for at least one function argument, the conversion for that argument
211 * in A is better than the corresponding conversion in B; and
213 * * there is no function argument for which the conversion in B is better
214 * than the corresponding conversion in A.
216 * If a single function definition is considered a better match than every
217 * other matching function definition, it will be used. Otherwise, a
218 * semantic error occurs and the shader will fail to compile."
220 for (ir_function_signature
**other
= matches
;
221 other
< matches
+ num_matches
; other
++) {
225 const exec_node
*node_a
= sig
->parameters
.head
;
226 const exec_node
*node_b
= (*other
)->parameters
.head
;
227 const exec_node
*node_p
= actual_parameters
->head
;
229 bool better_for_some_parameter
= false;
232 ; !node_a
->is_tail_sentinel()
233 ; node_a
= node_a
->next
,
234 node_b
= node_b
->next
,
235 node_p
= node_p
->next
) {
236 parameter_match_t a_match
= get_parameter_match_type(
237 (const ir_variable
*)node_a
,
238 (const ir_rvalue
*)node_p
);
239 parameter_match_t b_match
= get_parameter_match_type(
240 (const ir_variable
*)node_b
,
241 (const ir_rvalue
*)node_p
);
243 if (is_better_parameter_match(a_match
, b_match
))
244 better_for_some_parameter
= true;
246 if (is_better_parameter_match(b_match
, a_match
))
247 return false; /* B is better for this parameter */
250 if (!better_for_some_parameter
)
251 return false; /* A must be better than B for some parameter */
259 static ir_function_signature
*
260 choose_best_inexact_overload(_mesa_glsl_parse_state
*state
,
261 const exec_list
*actual_parameters
,
262 ir_function_signature
**matches
,
265 if (num_matches
== 0)
268 if (num_matches
== 1)
271 /* Without GLSL 4.0 / ARB_gpu_shader5, there is no overload resolution
272 * among multiple inexact matches. Note that state may be NULL here if
273 * called from the linker; in that case we assume everything supported in
274 * any GLSL version is available. */
275 if (!state
|| state
->is_version(400, 0) || state
->ARB_gpu_shader5_enable
) {
276 for (ir_function_signature
**sig
= matches
; sig
< matches
+ num_matches
; sig
++) {
277 if (is_best_inexact_overload(actual_parameters
, matches
, num_matches
, *sig
))
282 return NULL
; /* no best candidate */
286 ir_function_signature
*
287 ir_function::matching_signature(_mesa_glsl_parse_state
*state
,
288 const exec_list
*actual_parameters
,
292 return matching_signature(state
, actual_parameters
, allow_builtins
,
296 ir_function_signature
*
297 ir_function::matching_signature(_mesa_glsl_parse_state
*state
,
298 const exec_list
*actual_parameters
,
302 ir_function_signature
**inexact_matches
= NULL
;
303 ir_function_signature
**inexact_matches_temp
;
304 ir_function_signature
*match
= NULL
;
305 int num_inexact_matches
= 0;
307 /* From page 42 (page 49 of the PDF) of the GLSL 1.20 spec:
309 * "If an exact match is found, the other signatures are ignored, and
310 * the exact match is used. Otherwise, if no exact match is found, then
311 * the implicit conversions in Section 4.1.10 "Implicit Conversions" will
312 * be applied to the calling arguments if this can make their types match
313 * a signature. In this case, it is a semantic error if there are
314 * multiple ways to apply these conversions to the actual arguments of a
315 * call such that the call can be made to match multiple signatures."
317 foreach_in_list(ir_function_signature
, sig
, &this->signatures
) {
318 /* Skip over any built-ins that aren't available in this shader. */
319 if (sig
->is_builtin() && (!allow_builtins
||
320 !sig
->is_builtin_available(state
)))
323 switch (parameter_lists_match(state
, & sig
->parameters
, actual_parameters
)) {
324 case PARAMETER_LIST_EXACT_MATCH
:
326 free(inexact_matches
);
328 case PARAMETER_LIST_INEXACT_MATCH
:
329 inexact_matches_temp
= (ir_function_signature
**)
330 realloc(inexact_matches
,
331 sizeof(*inexact_matches
) *
332 (num_inexact_matches
+ 1));
333 if (inexact_matches_temp
== NULL
) {
334 _mesa_error_no_memory(__func__
);
335 free(inexact_matches
);
338 inexact_matches
= inexact_matches_temp
;
339 inexact_matches
[num_inexact_matches
++] = sig
;
341 case PARAMETER_LIST_NO_MATCH
:
349 /* There is no exact match (we would have returned it by now). If there
350 * are multiple inexact matches, the call is ambiguous, which is an error.
352 * FINISHME: Report a decent error. Returning NULL will likely result in
353 * FINISHME: a "no matching signature" error; it should report that the
354 * FINISHME: call is ambiguous. But reporting errors from here is hard.
358 match
= choose_best_inexact_overload(state
, actual_parameters
,
359 inexact_matches
, num_inexact_matches
);
361 free(inexact_matches
);
367 parameter_lists_match_exact(const exec_list
*list_a
, const exec_list
*list_b
)
369 const exec_node
*node_a
= list_a
->head
;
370 const exec_node
*node_b
= list_b
->head
;
373 ; !node_a
->is_tail_sentinel() && !node_b
->is_tail_sentinel()
374 ; node_a
= node_a
->next
, node_b
= node_b
->next
) {
375 ir_variable
*a
= (ir_variable
*) node_a
;
376 ir_variable
*b
= (ir_variable
*) node_b
;
378 /* If the types of the parameters do not match, the parameters lists
381 if (a
->type
!= b
->type
)
385 /* Unless both lists are exhausted, they differ in length and, by
386 * definition, do not match.
388 return (node_a
->is_tail_sentinel() == node_b
->is_tail_sentinel());
391 ir_function_signature
*
392 ir_function::exact_matching_signature(_mesa_glsl_parse_state
*state
,
393 const exec_list
*actual_parameters
)
395 foreach_in_list(ir_function_signature
, sig
, &this->signatures
) {
396 /* Skip over any built-ins that aren't available in this shader. */
397 if (sig
->is_builtin() && !sig
->is_builtin_available(state
))
400 if (parameter_lists_match_exact(&sig
->parameters
, actual_parameters
))