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 "compiler/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
->get_head_raw();
47 const exec_node
*node_b
= list_b
->get_head_raw();
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
->is_double()) {
153 if (from_type
->is_float())
154 return PARAMETER_FLOAT_TO_DOUBLE
;
155 return PARAMETER_INT_TO_DOUBLE
;
158 if (to_type
->is_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
.get_head_raw();
226 const exec_node
*node_b
= (*other
)->parameters
.get_head_raw();
227 const exec_node
*node_p
= actual_parameters
->get_head_raw();
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, or MESA_shader_integer_functions,
272 * there is no overload resolution among multiple inexact matches. Note
273 * that state may be NULL here if called from the linker; in that case we
274 * assume everything supported in any GLSL version is available.
276 if (!state
|| state
->is_version(400, 0) || state
->ARB_gpu_shader5_enable
||
277 state
->MESA_shader_integer_functions_enable
||
278 state
->EXT_shader_implicit_conversions_enable
) {
279 for (ir_function_signature
**sig
= matches
; sig
< matches
+ num_matches
; sig
++) {
280 if (is_best_inexact_overload(actual_parameters
, matches
, num_matches
, *sig
))
285 return NULL
; /* no best candidate */
289 ir_function_signature
*
290 ir_function::matching_signature(_mesa_glsl_parse_state
*state
,
291 const exec_list
*actual_parameters
,
295 return matching_signature(state
, actual_parameters
, allow_builtins
,
299 ir_function_signature
*
300 ir_function::matching_signature(_mesa_glsl_parse_state
*state
,
301 const exec_list
*actual_parameters
,
305 ir_function_signature
**inexact_matches
= NULL
;
306 ir_function_signature
**inexact_matches_temp
;
307 ir_function_signature
*match
= NULL
;
308 int num_inexact_matches
= 0;
310 /* From page 42 (page 49 of the PDF) of the GLSL 1.20 spec:
312 * "If an exact match is found, the other signatures are ignored, and
313 * the exact match is used. Otherwise, if no exact match is found, then
314 * the implicit conversions in Section 4.1.10 "Implicit Conversions" will
315 * be applied to the calling arguments if this can make their types match
316 * a signature. In this case, it is a semantic error if there are
317 * multiple ways to apply these conversions to the actual arguments of a
318 * call such that the call can be made to match multiple signatures."
320 foreach_in_list(ir_function_signature
, sig
, &this->signatures
) {
321 /* Skip over any built-ins that aren't available in this shader. */
322 if (sig
->is_builtin() && (!allow_builtins
||
323 !sig
->is_builtin_available(state
)))
326 switch (parameter_lists_match(state
, & sig
->parameters
, actual_parameters
)) {
327 case PARAMETER_LIST_EXACT_MATCH
:
329 free(inexact_matches
);
331 case PARAMETER_LIST_INEXACT_MATCH
:
332 inexact_matches_temp
= (ir_function_signature
**)
333 realloc(inexact_matches
,
334 sizeof(*inexact_matches
) *
335 (num_inexact_matches
+ 1));
336 if (inexact_matches_temp
== NULL
) {
337 _mesa_error_no_memory(__func__
);
338 free(inexact_matches
);
341 inexact_matches
= inexact_matches_temp
;
342 inexact_matches
[num_inexact_matches
++] = sig
;
344 case PARAMETER_LIST_NO_MATCH
:
352 /* There is no exact match (we would have returned it by now). If there
353 * are multiple inexact matches, the call is ambiguous, which is an error.
355 * FINISHME: Report a decent error. Returning NULL will likely result in
356 * FINISHME: a "no matching signature" error; it should report that the
357 * FINISHME: call is ambiguous. But reporting errors from here is hard.
361 match
= choose_best_inexact_overload(state
, actual_parameters
,
362 inexact_matches
, num_inexact_matches
);
364 free(inexact_matches
);
370 parameter_lists_match_exact(const exec_list
*list_a
, const exec_list
*list_b
)
372 const exec_node
*node_a
= list_a
->get_head_raw();
373 const exec_node
*node_b
= list_b
->get_head_raw();
376 ; !node_a
->is_tail_sentinel() && !node_b
->is_tail_sentinel()
377 ; node_a
= node_a
->next
, node_b
= node_b
->next
) {
378 ir_variable
*a
= (ir_variable
*) node_a
;
379 ir_variable
*b
= (ir_variable
*) node_b
;
381 /* If the types of the parameters do not match, the parameters lists
384 if (a
->type
!= b
->type
)
388 /* Unless both lists are exhausted, they differ in length and, by
389 * definition, do not match.
391 return (node_a
->is_tail_sentinel() == node_b
->is_tail_sentinel());
394 ir_function_signature
*
395 ir_function::exact_matching_signature(_mesa_glsl_parse_state
*state
,
396 const exec_list
*actual_parameters
)
398 foreach_in_list(ir_function_signature
, sig
, &this->signatures
) {
399 /* Skip over any built-ins that aren't available in this shader. */
400 if (sig
->is_builtin() && !sig
->is_builtin_available(state
))
403 if (parameter_lists_match_exact(&sig
->parameters
, actual_parameters
))