X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fglsl%2Fast_function.cpp;h=6ecf779c935abaf7a8ef7741f7ae5387f30b6a59;hb=36a59b29ef07b78378dcb3934131d262d42612cb;hp=20448f5a975c5b00e98d1830ab7ddebd875530e4;hpb=0072acd447dc6be652e63752e50215c3105322c8;p=mesa.git diff --git a/src/glsl/ast_function.cpp b/src/glsl/ast_function.cpp index 20448f5a975..6ecf779c935 100644 --- a/src/glsl/ast_function.cpp +++ b/src/glsl/ast_function.cpp @@ -93,16 +93,40 @@ prototype_string(const glsl_type *return_type, const char *name, static ir_rvalue * -process_call(exec_list *instructions, ir_function *f, - YYLTYPE *loc, exec_list *actual_parameters, - struct _mesa_glsl_parse_state *state) +match_function_by_name(exec_list *instructions, const char *name, + YYLTYPE *loc, exec_list *actual_parameters, + struct _mesa_glsl_parse_state *state) { void *ctx = state; + ir_function *f = state->symbols->get_function(name); + ir_function_signature *sig; - ir_function_signature *sig = f->matching_signature(actual_parameters); + sig = f ? f->matching_signature(actual_parameters) : NULL; + + /* FINISHME: This doesn't handle the case where shader X contains a + * FINISHME: matching signature but shader X + N contains an _exact_ + * FINISHME: matching signature. + */ + if (sig == NULL && (f == NULL || state->es_shader || !f->has_user_signature()) && state->symbols->get_type(name) == NULL && (state->language_version == 110 || state->symbols->get_variable(name) == NULL)) { + /* The current shader doesn't contain a matching function or signature. + * Before giving up, look for the prototype in the built-in functions. + */ + for (unsigned i = 0; i < state->num_builtins_to_link; i++) { + ir_function *builtin; + builtin = state->builtins_to_link[i]->symbols->get_function(name); + sig = builtin ? builtin->matching_signature(actual_parameters) : NULL; + if (sig != NULL) { + if (f == NULL) { + f = new(ctx) ir_function(name); + state->symbols->add_global_function(f); + emit_function(state, instructions, f); + } - /* The instructions param will be used when the FINISHMEs below are done */ - (void) instructions; + f->add_signature(sig->clone_prototype(f, NULL)); + break; + } + } + } if (sig != NULL) { /* Verify that 'out' and 'inout' actual parameters are lvalues. This @@ -167,45 +191,35 @@ process_call(exec_list *instructions, ir_function *f, return NULL; } } else { - char *str = prototype_string(NULL, f->name, actual_parameters); + char *str = prototype_string(NULL, name, actual_parameters); _mesa_glsl_error(loc, state, "no matching function for call to `%s'", 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); + for (int i = -1; i < state->num_builtins_to_link; i++) { + glsl_symbol_table *syms = i >= 0 ? state->builtins_to_link[i]->symbols + : state->symbols; + f = syms->get_function(name); + if (f == NULL) + continue; - prefix = " "; - } + foreach_list (node, &f->signatures) { + ir_function_signature *sig = (ir_function_signature *) node; - return ir_call::get_error_instruction(ctx); - } -} + str = prototype_string(sig->return_type, f->name, &sig->parameters); + _mesa_glsl_error(loc, state, "%s%s\n", prefix, str); + talloc_free(str); + prefix = " "; + } -static ir_rvalue * -match_function_by_name(exec_list *instructions, const char *name, - YYLTYPE *loc, exec_list *actual_parameters, - struct _mesa_glsl_parse_state *state) -{ - void *ctx = state; - ir_function *f = state->symbols->get_function(name); + } - if (f == NULL) { - _mesa_glsl_error(loc, state, "function `%s' undeclared", name); return ir_call::get_error_instruction(ctx); } - - /* Once we've determined that the function being called might exist, try - * to find an overload of the function that matches the parameters. - */ - return process_call(instructions, f, loc, actual_parameters, state); } @@ -545,7 +559,7 @@ emit_inline_vector_constructor(const glsl_type *type, /* Mask of fields to be written in the assignment. */ constant_mask |= ((1U << rhs_components) - 1) << base_lhs_component; - constant_components++; + constant_components += rhs_components; base_component += rhs_components; } @@ -580,18 +594,17 @@ emit_inline_vector_constructor(const glsl_type *type, const ir_constant *const c = param->as_constant(); if (c == NULL) { - /* Generate a swizzle in case rhs_components != rhs->type->vector_elements. */ - unsigned swiz[4] = { 0, 0, 0, 0 }; - for (unsigned i = 0; i < rhs_components; i++) - swiz[i] = i; - /* Mask of fields to be written in the assignment. */ const unsigned write_mask = ((1U << rhs_components) - 1) << base_component; ir_dereference *lhs = new(ctx) ir_dereference_variable(var); - ir_rvalue *rhs = new(ctx) ir_swizzle(param, swiz, rhs_components); + + /* 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); @@ -631,21 +644,21 @@ assign_to_matrix_column(ir_variable *var, unsigned column, unsigned row_base, assert(column_ref->type->components() >= (row_base + count)); assert(src->type->components() >= (src_base + count)); - /* Generate a swizzle that puts the first element of the source at the - * location of the first element of the destination. + /* Generate a swizzle that extracts the number of components from the source + * that are to be assigned to the column of the matrix. */ - unsigned swiz[4] = { src_base, src_base, src_base, src_base }; - for (unsigned i = 0; i < count; i++) - swiz[i + row_base] = i; - - ir_rvalue *const rhs = - new(mem_ctx) ir_swizzle(src, swiz, count); + 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, rhs, NULL, write_mask); + return new(mem_ctx) ir_assignment(column_ref, src, NULL, write_mask); }