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.
25 #include "glsl_symbol_table.h"
27 #include "glsl_types.h"
31 process_parameters(exec_list
*instructions
, exec_list
*actual_parameters
,
32 simple_node
*parameters
,
33 struct _mesa_glsl_parse_state
*state
)
35 simple_node
*const first
= parameters
;
39 simple_node
*ptr
= first
;
41 ir_rvalue
*const result
=
42 ((ast_node
*) ptr
)->hir(instructions
, state
);
45 actual_parameters
->push_tail(result
);
47 } while (ptr
!= first
);
55 process_call(exec_list
*instructions
, ir_function
*f
,
56 YYLTYPE
*loc
, exec_list
*actual_parameters
,
57 struct _mesa_glsl_parse_state
*state
)
59 const ir_function_signature
*sig
=
60 f
->matching_signature(actual_parameters
);
62 /* The instructions param will be used when the FINISHMEs below are done */
66 /* Verify that 'out' and 'inout' actual parameters are lvalues. This
67 * isn't done in ir_function::matching_signature because that function
68 * cannot generate the necessary diagnostics.
70 exec_list_iterator actual_iter
= actual_parameters
->iterator();
71 exec_list_iterator formal_iter
= sig
->parameters
.iterator();
73 while (actual_iter
.has_next()) {
74 ir_rvalue
*actual
= (ir_rvalue
*) actual_iter
.get();
75 ir_variable
*formal
= (ir_variable
*) formal_iter
.get();
77 assert(actual
!= NULL
);
78 assert(formal
!= NULL
);
80 if ((formal
->mode
== ir_var_out
)
81 || (formal
->mode
== ir_var_inout
)) {
82 if (! actual
->is_lvalue()) {
83 /* FINISHME: Log a better diagnostic here. There is no way
84 * FINISHME: to tell the user which parameter is invalid.
86 _mesa_glsl_error(loc
, state
, "`%s' parameter is not lvalue",
87 (formal
->mode
== ir_var_out
) ? "out" : "inout");
95 /* FINISHME: The list of actual parameters needs to be modified to
96 * FINISHME: include any necessary conversions.
98 return new ir_call(sig
, actual_parameters
);
100 /* FINISHME: Log a better error message here. G++ will show the types
101 * FINISHME: of the actual parameters and the set of candidate
102 * FINISHME: functions. A different error should also be logged when
103 * FINISHME: multiple functions match.
105 _mesa_glsl_error(loc
, state
, "no matching function for call to `%s'",
107 return ir_call::get_error_instruction();
113 match_function_by_name(exec_list
*instructions
, const char *name
,
114 YYLTYPE
*loc
, simple_node
*parameters
,
115 struct _mesa_glsl_parse_state
*state
)
117 ir_function
*f
= state
->symbols
->get_function(name
);
120 _mesa_glsl_error(loc
, state
, "function `%s' undeclared", name
);
121 return ir_call::get_error_instruction();
124 /* Once we've determined that the function being called might exist,
125 * process the parameters.
127 exec_list actual_parameters
;
128 process_parameters(instructions
, &actual_parameters
, parameters
, state
);
130 /* After processing the function's actual parameters, try to find an
131 * overload of the function that matches.
133 return process_call(instructions
, f
, loc
, &actual_parameters
, state
);
138 * Perform automatic type conversion of constructor parameters
141 convert_component(ir_rvalue
*src
, const glsl_type
*desired_type
)
143 const unsigned a
= desired_type
->base_type
;
144 const unsigned b
= src
->type
->base_type
;
146 if (src
->type
->is_error())
149 assert(a
<= GLSL_TYPE_BOOL
);
150 assert(b
<= GLSL_TYPE_BOOL
);
152 if ((a
== b
) || (src
->type
->is_integer() && desired_type
->is_integer()))
158 if (b
== GLSL_TYPE_FLOAT
)
159 return new ir_expression(ir_unop_f2i
, desired_type
, src
, NULL
);
161 assert(b
== GLSL_TYPE_BOOL
);
162 return new ir_expression(ir_unop_f2b
, desired_type
, src
, NULL
);
164 case GLSL_TYPE_FLOAT
:
167 return new ir_expression(ir_unop_u2f
, desired_type
, src
, NULL
);
169 return new ir_expression(ir_unop_i2f
, desired_type
, src
, NULL
);
171 return new ir_expression(ir_unop_b2f
, desired_type
, src
, NULL
);
174 case GLSL_TYPE_BOOL
: {
176 ir_constant
*const zero
= new ir_constant(src
->type
, &z
);
178 return new ir_expression(ir_binop_nequal
, desired_type
, src
, zero
);
182 assert(!"Should not get here.");
188 * Dereference a specific component from a scalar, vector, or matrix
191 dereference_component(ir_rvalue
*src
, unsigned component
)
193 assert(component
< src
->type
->components());
195 if (src
->type
->is_scalar()) {
197 } else if (src
->type
->is_vector()) {
198 return new ir_swizzle(src
, component
, 0, 0, 0, 1);
200 assert(src
->type
->is_matrix());
202 /* Dereference a row of the matrix, then call this function again to get
203 * a specific element from that row.
205 const int c
= component
/ src
->type
->column_type()->vector_elements
;
206 const int r
= component
% src
->type
->column_type()->vector_elements
;
207 ir_constant
*const col_index
= new ir_constant(glsl_type::int_type
, &c
);
208 ir_dereference
*const col
= new ir_dereference(src
, col_index
);
210 col
->type
= src
->type
->column_type();
212 return dereference_component(col
, r
);
215 assert(!"Should not get here.");
221 process_array_constructor(exec_list
*instructions
,
222 const glsl_type
*constructor_type
,
223 YYLTYPE
*loc
, simple_node
*parameters
,
224 struct _mesa_glsl_parse_state
*state
)
226 /* Array constructors come in two forms: sized and unsized. Sized array
227 * constructors look like 'vec4[2](a, b)', where 'a' and 'b' are vec4
228 * variables. In this case the number of parameters must exactly match the
229 * specified size of the array.
231 * Unsized array constructors look like 'vec4[](a, b)', where 'a' and 'b'
232 * are vec4 variables. In this case the size of the array being constructed
233 * is determined by the number of parameters.
235 * From page 52 (page 58 of the PDF) of the GLSL 1.50 spec:
237 * "There must be exactly the same number of arguments as the size of
238 * the array being constructed. If no size is present in the
239 * constructor, then the array is explicitly sized to the number of
240 * arguments provided. The arguments are assigned in order, starting at
241 * element 0, to the elements of the constructed array. Each argument
242 * must be the same type as the element type of the array, or be a type
243 * that can be converted to the element type of the array according to
244 * Section 4.1.10 "Implicit Conversions.""
246 exec_list actual_parameters
;
247 const unsigned parameter_count
=
248 process_parameters(instructions
, &actual_parameters
, parameters
, state
);
250 if ((parameter_count
== 0)
251 || ((constructor_type
->length
!= 0)
252 && (constructor_type
->length
!= parameter_count
))) {
253 const unsigned min_param
= (constructor_type
->length
== 0)
254 ? 1 : constructor_type
->length
;
256 _mesa_glsl_error(loc
, state
, "array constructor must have %s %u "
258 (constructor_type
->length
!= 0) ? "at least" : "exactly",
259 min_param
, (min_param
<= 1) ? "" : "s");
260 return ir_call::get_error_instruction();
263 if (constructor_type
->length
== 0) {
265 glsl_type::get_array_instance(constructor_type
->element_type(),
267 assert(constructor_type
!= NULL
);
268 assert(constructor_type
->length
== parameter_count
);
271 ir_function
*f
= state
->symbols
->get_function(constructor_type
->name
);
273 /* If the constructor for this type of array does not exist, generate the
274 * prototype and add it to the symbol table.
277 f
= constructor_type
->generate_constructor(state
->symbols
);
281 process_call(instructions
, f
, loc
, &actual_parameters
, state
);
284 assert(r
->type
->is_error() || (r
->type
== constructor_type
));
291 ast_function_expression::hir(exec_list
*instructions
,
292 struct _mesa_glsl_parse_state
*state
)
294 /* There are three sorts of function calls.
296 * 1. contstructors - The first subexpression is an ast_type_specifier.
297 * 2. methods - Only the .length() method of array types.
298 * 3. functions - Calls to regular old functions.
300 * Method calls are actually detected when the ast_field_selection
301 * expression is handled.
303 if (is_constructor()) {
304 const ast_type_specifier
*type
= (ast_type_specifier
*) subexpressions
[0];
305 YYLTYPE loc
= type
->get_location();
308 const glsl_type
*const constructor_type
= type
->glsl_type(& name
, state
);
311 /* Constructors for samplers are illegal.
313 if (constructor_type
->is_sampler()) {
314 _mesa_glsl_error(& loc
, state
, "cannot construct sampler type `%s'",
315 constructor_type
->name
);
316 return ir_call::get_error_instruction();
319 if (constructor_type
->is_array()) {
320 if (state
->language_version
<= 110) {
321 _mesa_glsl_error(& loc
, state
,
322 "array constructors forbidden in GLSL 1.10");
323 return ir_call::get_error_instruction();
326 return process_array_constructor(instructions
, constructor_type
,
327 & loc
, subexpressions
[1], state
);
330 /* There are two kinds of constructor call. Constructors for built-in
331 * language types, such as mat4 and vec2, are free form. The only
332 * requirement is that the parameters must provide enough values of the
333 * correct scalar type. Constructors for arrays and structures must
334 * have the exact number of parameters with matching types in the
335 * correct order. These constructors follow essentially the same type
336 * matching rules as functions.
338 if (constructor_type
->is_numeric() || constructor_type
->is_boolean()) {
339 /* Constructing a numeric type has a couple steps. First all values
340 * passed to the constructor are broken into individual parameters
341 * and type converted to the base type of the thing being constructed.
343 * At that point we have some number of values that match the base
344 * type of the thing being constructed. Now the constructor can be
345 * treated like a function call. Each numeric type has a small set
346 * of constructor functions. The set of new parameters will either
347 * match one of those functions or the original constructor is
350 const glsl_type
*const base_type
= constructor_type
->get_base_type();
352 /* Total number of components of the type being constructed.
354 const unsigned type_components
= constructor_type
->components();
356 /* Number of components from parameters that have actually been
357 * consumed. This is used to perform several kinds of error checking.
359 unsigned components_used
= 0;
361 unsigned matrix_parameters
= 0;
362 unsigned nonmatrix_parameters
= 0;
363 exec_list actual_parameters
;
364 simple_node
*const first
= subexpressions
[1];
366 assert(first
!= NULL
);
369 simple_node
*ptr
= first
;
371 ir_rvalue
*const result
=
372 ((ast_node
*) ptr
)->hir(instructions
, state
)->as_rvalue();
375 /* From page 50 (page 56 of the PDF) of the GLSL 1.50 spec:
377 * "It is an error to provide extra arguments beyond this
378 * last used argument."
380 if (components_used
>= type_components
) {
381 _mesa_glsl_error(& loc
, state
, "too many parameters to `%s' "
383 constructor_type
->name
);
384 return ir_call::get_error_instruction();
387 if (!result
->type
->is_numeric() && !result
->type
->is_boolean()) {
388 _mesa_glsl_error(& loc
, state
, "cannot construct `%s' from a "
389 "non-numeric data type",
390 constructor_type
->name
);
391 return ir_call::get_error_instruction();
394 /* Count the number of matrix and nonmatrix parameters. This
395 * is used below to enforce some of the constructor rules.
397 if (result
->type
->is_matrix())
400 nonmatrix_parameters
++;
403 /* Process each of the components of the parameter. Dereference
404 * each component individually, perform any type conversions, and
405 * add it to the parameter list for the constructor.
407 for (unsigned i
= 0; i
< result
->type
->components(); i
++) {
408 if (components_used
>= type_components
)
411 ir_rvalue
*const component
=
412 convert_component(dereference_component(result
, i
),
415 /* All cases that could result in component->type being the
416 * error type should have already been caught above.
418 assert(component
->type
== base_type
);
420 /* Don't actually generate constructor calls for scalars.
421 * Instead, do the usual component selection and conversion,
422 * and return the single component.
424 if (constructor_type
->is_scalar())
427 actual_parameters
.push_tail(component
);
430 } while (ptr
!= first
);
433 /* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec:
435 * "It is an error to construct matrices from other matrices. This
436 * is reserved for future use."
438 if ((state
->language_version
<= 110) && (matrix_parameters
> 0)
439 && constructor_type
->is_matrix()) {
440 _mesa_glsl_error(& loc
, state
, "cannot construct `%s' from a "
441 "matrix in GLSL 1.10",
442 constructor_type
->name
);
443 return ir_call::get_error_instruction();
446 /* From page 50 (page 56 of the PDF) of the GLSL 1.50 spec:
448 * "If a matrix argument is given to a matrix constructor, it is
449 * an error to have any other arguments."
451 if ((matrix_parameters
> 0)
452 && ((matrix_parameters
+ nonmatrix_parameters
) > 1)
453 && constructor_type
->is_matrix()) {
454 _mesa_glsl_error(& loc
, state
, "for matrix `%s' constructor, "
455 "matrix must be only parameter",
456 constructor_type
->name
);
457 return ir_call::get_error_instruction();
460 /* From page 28 (page 34 of the PDF) of the GLSL 1.10 spec:
462 * "In these cases, there must be enough components provided in the
463 * arguments to provide an initializer for every component in the
464 * constructed value."
466 if ((components_used
< type_components
) && (components_used
!= 1)) {
467 _mesa_glsl_error(& loc
, state
, "too few components to construct "
469 constructor_type
->name
);
470 return ir_call::get_error_instruction();
473 ir_function
*f
= state
->symbols
->get_function(constructor_type
->name
);
475 _mesa_glsl_error(& loc
, state
, "no constructor for type `%s'",
476 constructor_type
->name
);
477 return ir_call::get_error_instruction();
480 const ir_function_signature
*sig
=
481 f
->matching_signature(& actual_parameters
);
483 return new ir_call(sig
, & actual_parameters
);
485 /* FINISHME: Log a better error message here. G++ will show the
486 * FINSIHME: types of the actual parameters and the set of
487 * FINSIHME: candidate functions. A different error should also be
488 * FINSIHME: logged when multiple functions match.
490 _mesa_glsl_error(& loc
, state
, "no matching constructor for `%s'",
491 constructor_type
->name
);
492 return ir_call::get_error_instruction();
496 return ir_call::get_error_instruction();
498 const ast_expression
*id
= subexpressions
[0];
499 YYLTYPE loc
= id
->get_location();
501 return match_function_by_name(instructions
,
502 id
->primary_expression
.identifier
, & loc
,
503 subexpressions
[1], state
);
506 return ir_call::get_error_instruction();