X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Fast_function.cpp;h=1e66033348c87191a54de7c8201eb396e5a9d08b;hb=b2ddb93ff3b8c88682634ccdef247967e31fab84;hp=bb45e2530db6d8ff5a79481c0b0d135dc1da7a06;hpb=46d91615a2f6e1beaee98f40af957ba1a1a6b349;p=mesa.git diff --git a/src/glsl/ast_function.cpp b/src/glsl/ast_function.cpp index bb45e2530db..1e66033348c 100644 --- a/src/glsl/ast_function.cpp +++ b/src/glsl/ast_function.cpp @@ -25,15 +25,15 @@ #include "ast.h" #include "glsl_types.h" #include "ir.h" - -inline unsigned min(unsigned a, unsigned b) -{ - return (a < b) ? a : b; -} +#include "main/core.h" /* for MIN2 */ static ir_rvalue * convert_component(ir_rvalue *src, const glsl_type *desired_type); +bool +apply_implicit_conversion(const glsl_type *to, ir_rvalue * &from, + struct _mesa_glsl_parse_state *state); + static unsigned process_parameters(exec_list *instructions, exec_list *actual_parameters, exec_list *parameters, @@ -57,6 +57,41 @@ process_parameters(exec_list *instructions, exec_list *actual_parameters, } +/** + * Generate a source prototype for a function signature + * + * \param return_type Return type of the function. May be \c NULL. + * \param name Name of the function. + * \param parameters Parameter list for the function. This may be either a + * formal or actual parameter list. Only the type is used. + * + * \return + * A talloced string representing the prototype of the function. + */ +char * +prototype_string(const glsl_type *return_type, const char *name, + exec_list *parameters) +{ + char *str = NULL; + + if (return_type != NULL) + str = talloc_asprintf(str, "%s ", return_type->name); + + str = talloc_asprintf_append(str, "%s(", name); + + const char *comma = ""; + foreach_list(node, parameters) { + const ir_instruction *const param = (ir_instruction *) node; + + str = talloc_asprintf_append(str, "%s%s", comma, param->type->name); + comma = ", "; + } + + str = talloc_strdup_append(str, ")"); + return str; +} + + static ir_rvalue * process_call(exec_list *instructions, ir_function *f, YYLTYPE *loc, exec_list *actual_parameters, @@ -66,9 +101,6 @@ process_call(exec_list *instructions, ir_function *f, ir_function_signature *sig = f->matching_signature(actual_parameters); - /* The instructions param will be used when the FINISHMEs below are done */ - (void) instructions; - if (sig != NULL) { /* Verify that 'out' and 'inout' actual parameters are lvalues. This * isn't done in ir_function::matching_signature because that function @@ -132,13 +164,23 @@ process_call(exec_list *instructions, ir_function *f, return NULL; } } else { - /* FINISHME: Log a better error message here. G++ will show the types - * FINISHME: of the actual parameters and the set of candidate - * FINISHME: functions. A different error should also be logged when - * FINISHME: multiple functions match. - */ + char *str = prototype_string(NULL, f->name, actual_parameters); + _mesa_glsl_error(loc, state, "no matching function for call to `%s'", - f->name); + str); + talloc_free(str); + + const char *prefix = "candidates are: "; + foreach_list (node, &f->signatures) { + ir_function_signature *sig = (ir_function_signature *) node; + + str = prototype_string(sig->return_type, f->name, &sig->parameters); + _mesa_glsl_error(loc, state, "%s%s\n", prefix, str); + talloc_free(str); + + prefix = " "; + } + return ir_call::get_error_instruction(ctx); } } @@ -388,137 +430,16 @@ process_array_constructor(exec_list *instructions, */ static ir_constant * constant_record_constructor(const glsl_type *constructor_type, - YYLTYPE *loc, exec_list *parameters, - struct _mesa_glsl_parse_state *state) + exec_list *parameters, void *mem_ctx) { - void *ctx = state; - bool all_parameters_are_constant = true; - - exec_node *node = parameters->head; - for (unsigned i = 0; i < constructor_type->length; i++) { - ir_instruction *ir = (ir_instruction *) node; - - if (node->is_tail_sentinal()) { - _mesa_glsl_error(loc, state, - "insufficient parameters to constructor for `%s'", - constructor_type->name); - return NULL; - } - - if (ir->type != constructor_type->fields.structure[i].type) { - _mesa_glsl_error(loc, state, - "parameter type mismatch in constructor for `%s' " - " (%s vs %s)", - constructor_type->name, - ir->type->name, - constructor_type->fields.structure[i].type->name); + foreach_list(node, parameters) { + ir_constant *constant = ((ir_instruction *) node)->as_constant(); + if (constant == NULL) return NULL; - } - - if (ir->as_constant() == NULL) - all_parameters_are_constant = false; - - node = node->next; + node->replace_with(constant); } - if (!all_parameters_are_constant) - return NULL; - - return new(ctx) ir_constant(constructor_type, parameters); -} - - -/** - * Generate data for a constant matrix constructor w/a single scalar parameter - * - * Matrix constructors in GLSL can be passed a single scalar of the - * approriate type. In these cases, the resulting matrix is the identity - * matrix multipled by the specified scalar. This function generates data for - * that matrix. - * - * \param type Type of the desired matrix. - * \param initializer Scalar value used to initialize the matrix diagonal. - * \param data Location to store the resulting matrix. - */ -void -generate_constructor_matrix(const glsl_type *type, ir_constant *initializer, - ir_constant_data *data) -{ - switch (type->base_type) { - case GLSL_TYPE_UINT: - case GLSL_TYPE_INT: - for (unsigned i = 0; i < type->components(); i++) - data->u[i] = 0; - - for (unsigned i = 0; i < type->matrix_columns; i++) { - /* The array offset of the ith row and column of the matrix. - */ - const unsigned idx = (i * type->vector_elements) + i; - - data->u[idx] = initializer->value.u[0]; - } - break; - - case GLSL_TYPE_FLOAT: - for (unsigned i = 0; i < type->components(); i++) - data->f[i] = 0; - - for (unsigned i = 0; i < type->matrix_columns; i++) { - /* The array offset of the ith row and column of the matrix. - */ - const unsigned idx = (i * type->vector_elements) + i; - - data->f[idx] = initializer->value.f[0]; - } - - break; - - default: - assert(!"Should not get here."); - break; - } -} - - -/** - * Generate data for a constant vector constructor w/a single scalar parameter - * - * Vector constructors in GLSL can be passed a single scalar of the - * approriate type. In these cases, the resulting vector contains the specified - * value in all components. This function generates data for that vector. - * - * \param type Type of the desired vector. - * \param initializer Scalar value used to initialize the vector. - * \param data Location to store the resulting vector data. - */ -void -generate_constructor_vector(const glsl_type *type, ir_constant *initializer, - ir_constant_data *data) -{ - switch (type->base_type) { - case GLSL_TYPE_UINT: - case GLSL_TYPE_INT: - for (unsigned i = 0; i < type->components(); i++) - data->u[i] = initializer->value.u[0]; - - break; - - case GLSL_TYPE_FLOAT: - for (unsigned i = 0; i < type->components(); i++) - data->f[i] = initializer->value.f[0]; - - break; - - case GLSL_TYPE_BOOL: - for (unsigned i = 0; i < type->components(); i++) - data->b[i] = initializer->value.b[0]; - - break; - - default: - assert(!"Should not get here."); - break; - } + return new(mem_ctx) ir_constant(constructor_type, parameters); } @@ -531,7 +452,7 @@ single_scalar_parameter(exec_list *parameters) const ir_rvalue *const p = (ir_rvalue *) parameters->head; assert(((ir_rvalue *)p)->as_rvalue() != NULL); - return (p->type->is_scalar() && p->next->is_tail_sentinal()); + return (p->type->is_scalar() && p->next->is_tail_sentinel()); } @@ -554,9 +475,7 @@ emit_inline_vector_constructor(const glsl_type *type, { assert(!parameters->is_empty()); - ir_variable *var = new(ctx) ir_variable(type, - talloc_strdup(ctx, "vec_ctor"), - ir_var_temporary); + ir_variable *var = new(ctx) ir_variable(type, "vec_ctor", ir_var_temporary); instructions->push_tail(var); /* There are two kinds of vector constructors. @@ -574,37 +493,106 @@ emit_inline_vector_constructor(const glsl_type *type, ir_rvalue *rhs = new(ctx) ir_swizzle(first_param, 0, 0, 0, 0, lhs_components); ir_dereference_variable *lhs = new(ctx) ir_dereference_variable(var); + const unsigned mask = (1U << lhs_components) - 1; assert(rhs->type == lhs->type); - ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL); + ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL, mask); instructions->push_tail(inst); } else { unsigned base_component = 0; + unsigned base_lhs_component = 0; + ir_constant_data data; + unsigned constant_mask = 0, constant_components = 0; + + memset(&data, 0, sizeof(data)); + foreach_list(node, parameters) { - ir_rvalue *rhs = (ir_rvalue *) node; - unsigned rhs_components = rhs->type->components(); + ir_rvalue *param = (ir_rvalue *) node; + unsigned rhs_components = param->type->components(); /* Do not try to assign more components to the vector than it has! */ - if ((rhs_components + base_component) > lhs_components) { - rhs_components = lhs_components - base_component; + if ((rhs_components + base_lhs_component) > lhs_components) { + rhs_components = lhs_components - base_lhs_component; } - /* Emit an assignment of the constructor parameter to the next set of - * components in the temporary variable. + const ir_constant *const c = param->as_constant(); + if (c != NULL) { + for (unsigned i = 0; i < rhs_components; i++) { + switch (c->type->base_type) { + case GLSL_TYPE_UINT: + data.u[i + base_component] = c->get_uint_component(i); + break; + case GLSL_TYPE_INT: + data.i[i + base_component] = c->get_int_component(i); + break; + case GLSL_TYPE_FLOAT: + data.f[i + base_component] = c->get_float_component(i); + break; + case GLSL_TYPE_BOOL: + data.b[i + base_component] = c->get_bool_component(i); + break; + default: + assert(!"Should not get here."); + break; + } + } + + /* Mask of fields to be written in the assignment. + */ + constant_mask |= ((1U << rhs_components) - 1) << base_lhs_component; + constant_components += rhs_components; + + base_component += rhs_components; + } + /* Advance the component index by the number of components + * that were just assigned. */ - unsigned mask[4] = { 0, 0, 0, 0 }; - for (unsigned i = 0; i < rhs_components; i++) { - mask[i] = i + base_component; + base_lhs_component += rhs_components; + } + + if (constant_mask != 0) { + ir_dereference *lhs = new(ctx) ir_dereference_variable(var); + const glsl_type *rhs_type = glsl_type::get_instance(var->type->base_type, + constant_components, + 1); + ir_rvalue *rhs = new(ctx) ir_constant(rhs_type, &data); + + ir_instruction *inst = + new(ctx) ir_assignment(lhs, rhs, NULL, constant_mask); + instructions->push_tail(inst); + } + + base_component = 0; + foreach_list(node, parameters) { + ir_rvalue *param = (ir_rvalue *) node; + unsigned rhs_components = param->type->components(); + + /* Do not try to assign more components to the vector than it has! + */ + if ((rhs_components + base_component) > lhs_components) { + rhs_components = lhs_components - base_component; } + const ir_constant *const c = param->as_constant(); + if (c == NULL) { + /* Mask of fields to be written in the assignment. + */ + const unsigned write_mask = ((1U << rhs_components) - 1) + << base_component; - ir_rvalue *lhs_ref = new(ctx) ir_dereference_variable(var); - ir_swizzle *lhs = new(ctx) ir_swizzle(lhs_ref, mask, rhs_components); + ir_dereference *lhs = new(ctx) ir_dereference_variable(var); - ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL); - instructions->push_tail(inst); + /* Generate a swizzle so that LHS and RHS sizes match. + */ + ir_rvalue *rhs = + new(ctx) ir_swizzle(param, 0, 1, 2, 3, rhs_components); + + ir_instruction *inst = + new(ctx) ir_assignment(lhs, rhs, NULL, write_mask); + instructions->push_tail(inst); + } /* Advance the component index by the number of components that were * just assigned. @@ -631,20 +619,29 @@ emit_inline_vector_constructor(const glsl_type *type, ir_instruction * assign_to_matrix_column(ir_variable *var, unsigned column, unsigned row_base, ir_rvalue *src, unsigned src_base, unsigned count, - TALLOC_CTX *ctx) + void *mem_ctx) { - const unsigned mask[8] = { 0, 1, 2, 3, 0, 0, 0, 0 }; - - ir_constant *col_idx = new(ctx) ir_constant(column); - ir_rvalue *column_ref = new(ctx) ir_dereference_array(var, col_idx); + ir_constant *col_idx = new(mem_ctx) ir_constant(column); + ir_dereference *column_ref = new(mem_ctx) ir_dereference_array(var, col_idx); assert(column_ref->type->components() >= (row_base + count)); - ir_rvalue *lhs = new(ctx) ir_swizzle(column_ref, &mask[row_base], count); - assert(src->type->components() >= (src_base + count)); - ir_rvalue *rhs = new(ctx) ir_swizzle(src, &mask[src_base], count); - return new(ctx) ir_assignment(lhs, rhs, NULL); + /* Generate a swizzle that extracts the number of components from the source + * that are to be assigned to the column of the matrix. + */ + if (count < src->type->vector_elements) { + src = new(mem_ctx) ir_swizzle(src, + src_base + 0, src_base + 1, + src_base + 2, src_base + 3, + count); + } + + /* Mask of fields to be written in the assignment. + */ + const unsigned write_mask = ((1U << count) - 1) << row_base; + + return new(mem_ctx) ir_assignment(column_ref, src, NULL, write_mask); } @@ -667,9 +664,7 @@ emit_inline_matrix_constructor(const glsl_type *type, { assert(!parameters->is_empty()); - ir_variable *var = new(ctx) ir_variable(type, - talloc_strdup(ctx, "mat_ctor"), - ir_var_temporary); + ir_variable *var = new(ctx) ir_variable(type, "mat_ctor", ir_var_temporary); instructions->push_tail(var); /* There are three kinds of matrix constructors. @@ -692,8 +687,7 @@ emit_inline_matrix_constructor(const glsl_type *type, * components with zero. */ ir_variable *rhs_var = - new(ctx) ir_variable(glsl_type::vec4_type, - talloc_strdup(ctx, "mat_ctor_vec"), + new(ctx) ir_variable(glsl_type::vec4_type, "mat_ctor_vec", ir_var_temporary); instructions->push_tail(rhs_var); @@ -709,10 +703,9 @@ emit_inline_matrix_constructor(const glsl_type *type, NULL); instructions->push_tail(inst); - ir_rvalue *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var); - ir_rvalue *const x_of_rhs = new(ctx) ir_swizzle(rhs_ref, 0, 0, 0, 0, 1); + ir_dereference *const rhs_ref = new(ctx) ir_dereference_variable(rhs_var); - inst = new(ctx) ir_assignment(x_of_rhs, first_param, NULL); + inst = new(ctx) ir_assignment(rhs_ref, first_param, NULL, 0x01); instructions->push_tail(inst); /* Assign the temporary vector to each column of the destination matrix @@ -728,8 +721,8 @@ emit_inline_matrix_constructor(const glsl_type *type, { 1, 1, 1, 0 } }; - const unsigned cols_to_init = min(type->matrix_columns, - type->vector_elements); + const unsigned cols_to_init = MIN2(type->matrix_columns, + type->vector_elements); for (unsigned i = 0; i < cols_to_init; i++) { ir_constant *const col_idx = new(ctx) ir_constant(i); ir_rvalue *const col_ref = new(ctx) ir_dereference_array(var, col_idx); @@ -763,7 +756,7 @@ emit_inline_matrix_constructor(const glsl_type *type, * identity matrix. If a matrix argument is given to a matrix * constructor, it is an error to have any other arguments." */ - assert(first_param->next->is_tail_sentinal()); + assert(first_param->next->is_tail_sentinel()); ir_rvalue *const src_matrix = first_param; /* If the source matrix is smaller, pre-initialize the relavent parts of @@ -807,8 +800,7 @@ emit_inline_matrix_constructor(const glsl_type *type, * generate a temporary and copy the paramter there. */ ir_variable *const rhs_var = - new(ctx) ir_variable(first_param->type, - talloc_strdup(ctx, "mat_ctor_mat"), + new(ctx) ir_variable(first_param->type, "mat_ctor_mat", ir_var_temporary); instructions->push_tail(rhs_var); @@ -818,12 +810,19 @@ emit_inline_matrix_constructor(const glsl_type *type, new(ctx) ir_assignment(rhs_var_ref, first_param, NULL); instructions->push_tail(inst); + const unsigned last_row = MIN2(src_matrix->type->vector_elements, + var->type->vector_elements); + const unsigned last_col = MIN2(src_matrix->type->matrix_columns, + var->type->matrix_columns); + + unsigned swiz[4] = { 0, 0, 0, 0 }; + for (unsigned i = 1; i < last_row; i++) + swiz[i] = i; + + const unsigned write_mask = (1U << last_row) - 1; - const unsigned swiz[4] = { 0, 1, 2, 3 }; - const unsigned last_col = min(src_matrix->type->matrix_columns, - var->type->matrix_columns); for (unsigned i = 0; i < last_col; i++) { - ir_rvalue *const lhs_col = + ir_dereference *const lhs = new(ctx) ir_dereference_array(var, new(ctx) ir_constant(i)); ir_rvalue *const rhs_col = new(ctx) ir_dereference_array(rhs_var, new(ctx) ir_constant(i)); @@ -836,31 +835,20 @@ emit_inline_matrix_constructor(const glsl_type *type, * It would be perfectly valid to unconditionally generate the * swizzles, this this will typically result in a more compact IR tree. */ - ir_rvalue *lhs; ir_rvalue *rhs; - if (lhs_col->type->vector_elements < rhs_col->type->vector_elements) { - lhs = lhs_col; - - rhs = new(ctx) ir_swizzle(rhs_col, swiz, - lhs_col->type->vector_elements); - } else if (lhs_col->type->vector_elements - > rhs_col->type->vector_elements) { - lhs = new(ctx) ir_swizzle(lhs_col, swiz, - rhs_col->type->vector_elements); - rhs = rhs_col; + if (lhs->type->vector_elements != rhs_col->type->vector_elements) { + rhs = new(ctx) ir_swizzle(rhs_col, swiz, last_row); } else { - lhs = lhs_col; rhs = rhs_col; } - assert(lhs->type == rhs->type); - - ir_instruction *inst = new(ctx) ir_assignment(lhs, rhs, NULL); + ir_instruction *inst = + new(ctx) ir_assignment(lhs, rhs, NULL, write_mask); instructions->push_tail(inst); } } else { - const unsigned rows = type->matrix_columns; - const unsigned cols = type->vector_elements; + const unsigned cols = type->matrix_columns; + const unsigned rows = type->vector_elements; unsigned col_idx = 0; unsigned row_idx = 0; @@ -874,9 +862,7 @@ emit_inline_matrix_constructor(const glsl_type *type, * generate a temporary and copy the paramter there. */ ir_variable *rhs_var = - new(ctx) ir_variable(rhs->type, - talloc_strdup(ctx, "mat_ctor_vec"), - ir_var_temporary); + new(ctx) ir_variable(rhs->type, "mat_ctor_vec", ir_var_temporary); instructions->push_tail(rhs_var); ir_dereference *rhs_var_ref = @@ -891,8 +877,8 @@ emit_inline_matrix_constructor(const glsl_type *type, * single vec4, for example, can completely fill a mat2. */ if (rhs_components >= components_remaining_this_column) { - const unsigned count = min(rhs_components, - components_remaining_this_column); + const unsigned count = MIN2(rhs_components, + components_remaining_this_column); rhs_var_ref = new(ctx) ir_dereference_variable(rhs_var); @@ -936,6 +922,39 @@ emit_inline_matrix_constructor(const glsl_type *type, } +ir_rvalue * +emit_inline_record_constructor(const glsl_type *type, + exec_list *instructions, + exec_list *parameters, + void *mem_ctx) +{ + ir_variable *const var = + new(mem_ctx) ir_variable(type, "record_ctor", ir_var_temporary); + ir_dereference_variable *const d = new(mem_ctx) ir_dereference_variable(var); + + instructions->push_tail(var); + + exec_node *node = parameters->head; + for (unsigned i = 0; i < type->length; i++) { + assert(!node->is_tail_sentinel()); + + ir_dereference *const lhs = + new(mem_ctx) ir_dereference_record(d->clone(mem_ctx, NULL), + type->fields.structure[i].name); + + ir_rvalue *const rhs = ((ir_instruction *) node)->as_rvalue(); + assert(rhs != NULL); + + ir_instruction *const assign = new(mem_ctx) ir_assignment(lhs, rhs, NULL); + + instructions->push_tail(assign); + node = node->next; + } + + return d; +} + + ir_rvalue * ast_function_expression::hir(exec_list *instructions, struct _mesa_glsl_parse_state *state) @@ -977,6 +996,7 @@ ast_function_expression::hir(exec_list *instructions, & loc, &this->expressions, state); } + /* There are two kinds of constructor call. Constructors for built-in * language types, such as mat4 and vec2, are free form. The only * requirement is that the parameters must provide enough values of the @@ -1040,7 +1060,7 @@ ast_function_expression::hir(exec_list *instructions, * "It is an error to construct matrices from other matrices. This * is reserved for future use." */ - if ((state->language_version <= 110) && (matrix_parameters > 0) + if (state->language_version == 110 && matrix_parameters > 0 && constructor_type->is_matrix()) { _mesa_glsl_error(& loc, state, "cannot construct `%s' from a " "matrix in GLSL 1.10", @@ -1068,7 +1088,8 @@ ast_function_expression::hir(exec_list *instructions, * arguments to provide an initializer for every component in the * constructed value." */ - if ((components_used < type_components) && (components_used != 1)) { + if (components_used < type_components && components_used != 1 + && matrix_parameters == 0) { _mesa_glsl_error(& loc, state, "too few components to construct " "`%s'", constructor_type->name); @@ -1135,32 +1156,7 @@ ast_function_expression::hir(exec_list *instructions, * constant representing the complete collection of parameters. */ if (all_parameters_are_constant) { - if (components_used >= type_components) - return new(ctx) ir_constant(constructor_type, - & actual_parameters); - - /* The above case must handle all scalar constructors. - */ - assert(constructor_type->is_vector() - || constructor_type->is_matrix()); - - /* Constructors with exactly one component are special for - * vectors and matrices. For vectors it causes all elements of - * the vector to be filled with the value. For matrices it - * causes the matrix to be filled with 0 and the diagonal to be - * filled with the value. - */ - ir_constant_data data; - ir_constant *const initializer = - (ir_constant *) actual_parameters.head; - if (constructor_type->is_matrix()) - generate_constructor_matrix(constructor_type, initializer, - &data); - else - generate_constructor_vector(constructor_type, initializer, - &data); - - return new(ctx) ir_constant(constructor_type, &data); + return new(ctx) ir_constant(constructor_type, &actual_parameters); } else if (constructor_type->is_scalar()) { return dereference_component((ir_rvalue *) actual_parameters.head, 0); @@ -1188,11 +1184,48 @@ ast_function_expression::hir(exec_list *instructions, state->symbols->get_type(id->primary_expression.identifier); if ((type != NULL) && type->is_record()) { - ir_constant *constant = - constant_record_constructor(type, &loc, &actual_parameters, state); + exec_node *node = actual_parameters.head; + for (unsigned i = 0; i < type->length; i++) { + ir_rvalue *ir = (ir_rvalue *) node; + + if (node->is_tail_sentinel()) { + _mesa_glsl_error(&loc, state, + "insufficient parameters to constructor " + "for `%s'", + type->name); + return ir_call::get_error_instruction(ctx); + } - if (constant != NULL) - return constant; + if (apply_implicit_conversion(type->fields.structure[i].type, ir, + state)) { + node->replace_with(ir); + } else { + _mesa_glsl_error(&loc, state, + "parameter type mismatch in constructor " + "for `%s.%s' (%s vs %s)", + type->name, + type->fields.structure[i].name, + ir->type->name, + type->fields.structure[i].type->name); + return ir_call::get_error_instruction(ctx);; + } + + node = node->next; + } + + if (!node->is_tail_sentinel()) { + _mesa_glsl_error(&loc, state, "too many parameters in constructor " + "for `%s'", type->name); + return ir_call::get_error_instruction(ctx); + } + + ir_rvalue *const constant = + constant_record_constructor(type, &actual_parameters, state); + + return (constant != NULL) + ? constant + : emit_inline_record_constructor(type, instructions, + &actual_parameters, state); } return match_function_by_name(instructions,