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 parameter_lists_match(const exec_list
*list_a
, const exec_list
*list_b
)
91 const exec_node
*node_a
= list_a
->head
;
92 const exec_node
*node_b
= list_b
->head
;
96 ; !node_a
->is_tail_sentinel()
97 ; node_a
= node_a
->next
, node_b
= node_b
->next
) {
98 /* If all of the parameters from the other parameter list have been
99 * exhausted, the lists have different length and, by definition,
102 if (node_b
->is_tail_sentinel())
106 const ir_variable
*const param
= (ir_variable
*) node_a
;
107 const ir_instruction
*const actual
= (ir_instruction
*) node_b
;
109 /* Determine whether or not the types match. If the types are an
110 * exact match, the match score is zero. If the types don't match
111 * but the actual parameter can be coerced to the type of the declared
112 * parameter, the match score is one.
115 switch ((enum ir_variable_mode
)(param
->mode
)) {
118 case ir_var_temporary
:
119 /* These are all error conditions. It is invalid for a parameter to
120 * a function to be declared as auto (not in, out, or inout) or
126 case ir_var_const_in
:
128 score
= type_compare(param
->type
, actual
->type
);
132 score
= type_compare(actual
->type
, param
->type
);
136 /* Since there are no bi-directional automatic conversions (e.g.,
137 * there is int -> float but no float -> int), inout parameters must
140 score
= (type_compare(actual
->type
, param
->type
) == 0) ? 0 : -1;
150 total_score
+= score
;
153 /* If all of the parameters from the other parameter list have been
154 * exhausted, the lists have different length and, by definition, do not
157 if (!node_b
->is_tail_sentinel())
164 ir_function_signature
*
165 ir_function::matching_signature(const exec_list
*actual_parameters
)
167 ir_function_signature
*match
= NULL
;
169 foreach_iter(exec_list_iterator
, iter
, signatures
) {
170 ir_function_signature
*const sig
=
171 (ir_function_signature
*) iter
.get();
173 const int score
= parameter_lists_match(& sig
->parameters
,
192 parameter_lists_match_exact(const exec_list
*list_a
, const exec_list
*list_b
)
194 const exec_node
*node_a
= list_a
->head
;
195 const exec_node
*node_b
= list_b
->head
;
198 ; !node_a
->is_tail_sentinel() && !node_b
->is_tail_sentinel()
199 ; node_a
= node_a
->next
, node_b
= node_b
->next
) {
200 ir_variable
*a
= (ir_variable
*) node_a
;
201 ir_variable
*b
= (ir_variable
*) node_b
;
203 /* If the types of the parameters do not match, the parameters lists
206 if (a
->type
!= b
->type
)
210 /* Unless both lists are exhausted, they differ in length and, by
211 * definition, do not match.
213 return (node_a
->is_tail_sentinel() == node_b
->is_tail_sentinel());
216 ir_function_signature
*
217 ir_function::exact_matching_signature(const exec_list
*actual_parameters
)
219 foreach_iter(exec_list_iterator
, iter
, signatures
) {
220 ir_function_signature
*const sig
=
221 (ir_function_signature
*) iter
.get();
223 if (parameter_lists_match_exact(&sig
->parameters
, actual_parameters
))